Set the cell value from the specified location

        :param x: The column (x coord) of the character.
        :param y: The row (y coord) of the character.
        :param value: A 5-tuple of (unicode, foreground, attributes, background, width).
772937
def set(self, x, y, value):
        
        self._double_buffer[y][x] = value
356483
def write_cell(self, x, y, value):
        
        x += 1
        y += 1
        self._sheet.update_cell(x, y, value)
789818
def set_subplot_ylabel(self, row, column, text):
        
        subplot = self.get_subplot_at(row, column)
        subplot.set_ylabel(text)
354123
def set_range_y(self,val):
        
        d = self.declaration
        if d.auto_range[1]:
            return
        self.widget.setYRange(*val,padding=0)
232216
def write(self, value):  # type: (int) -> None
        """"""

        # Get current position
        row, col = self._cursor_pos

        # Write byte if changed
        try:
            if self._content[row][col] != value:
                self._send_data(value)
                self._content[row][col] = value  # Update content cache
                unchanged = False
            else:
                unchanged = True
        except IndexError as e:
            # Position out of range
            if self.auto_linebreaks is True:
                raise e
            self._send_data(value)
            unchanged = False

        # Update cursor position.
        if self.text_align_mode == 'left':
            if self.auto_linebreaks is False or col < self.lcd.cols - 1:
                # No newline, update internal pointer
                newpos = (row, col + 1)
                if unchanged:
                    self.cursor_pos = newpos
                else:
                    self._cursor_pos = newpos
                self.recent_auto_linebreak = False
            else:
                # Newline, reset pointer
                if row < self.lcd.rows - 1:
                    self.cursor_pos = (row + 1, 0)
                else:
                    self.cursor_pos = (0, 0)
                self.recent_auto_linebreak = True
        else:
            if self.auto_linebreaks is False or col > 0:
                # No newline, update internal pointer
                newpos = (row, col - 1)
                if unchanged:
                    self.cursor_pos = newpos
                else:
                    self._cursor_pos = newpos
                self.recent_auto_linebreak = False
            else:
                # Newline, reset pointer
                if row < self.lcd.rows - 1:
                    self.cursor_pos = (row + 1, self.lcd.cols - 1)
                else:
                    self.cursor_pos = (0, self.lcd.cols - 1)
                self.recent_auto_linebreak = True
655138
def set_value(self, value: str):
        

        self.clear()

        if '.' in value:
            self._segments['period'].configure(background=self._color)

        if value in ['0', '0.']:
            self._segments['a'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
            self._segments['d'].configure(background=self._color)
            self._segments['e'].configure(background=self._color)
            self._segments['f'].configure(background=self._color)
        elif value in ['1', '1.']:
            self._segments['b'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
        elif value in ['2', '2.']:
            self._segments['a'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
            self._segments['e'].configure(background=self._color)
            self._segments['d'].configure(background=self._color)
        elif value in ['3', '3.']:
            self._segments['a'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
            self._segments['d'].configure(background=self._color)
        elif value in ['4', '4.']:
            self._segments['f'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
        elif value in ['5', '5.']:
            self._segments['a'].configure(background=self._color)
            self._segments['f'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
            self._segments['d'].configure(background=self._color)
        elif value in ['6', '6.']:
            self._segments['f'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
            self._segments['d'].configure(background=self._color)
            self._segments['e'].configure(background=self._color)
        elif value in ['7', '7.']:
            self._segments['a'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
        elif value in ['8', '8.']:
            self._segments['a'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
            self._segments['d'].configure(background=self._color)
            self._segments['e'].configure(background=self._color)
            self._segments['f'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
        elif value in ['9', '9.']:
            self._segments['a'].configure(background=self._color)
            self._segments['b'].configure(background=self._color)
            self._segments['c'].configure(background=self._color)
            self._segments['f'].configure(background=self._color)
            self._segments['g'].configure(background=self._color)
        elif value in ['-']:
            self._segments['g'].configure(background=self._color)

        else:
            raise ValueError('unsupported character: {}'.format(value))
1208513
def set_row_gap(self, value):
        
        value = str(value) + 'px'
        value = value.replace('pxpx', 'px')
        self.style['grid-row-gap'] = value
1016329
def set(row, col, value, sheet = nil) #:nodoc:
      key = normalize(row, col)
      cell_type = cell_type_by_value(value)
      sheet_for(sheet).cells[key] = Cell.new(value, cell_type, nil, cell_type, value, nil, nil, nil, Coordinate.new(row, col))
    end
276272
def set_column_gap(self, value):
        
        value = str(value) + 'px'
        value = value.replace('pxpx', 'px')
        self.style['grid-column-gap'] = value
1288419
def set_y(self, y):
        ""
        self.x=self.l_margin
        if(y>=0):
            self.y=y
        else:
            self.y=self.h+y
386742
def setValuesTyped(self, rows, *values):
        ''
        for r, v in zip(rows, itertools.cycle(self.type(val) for val in values)):
            self.setValueSafe(r, v)
        self.recalc()
        return status('set %d cells to %d values' % (len(rows), len(values)))
337935
def set_cell_values(sheet, x, y, i, v, value_type, formula, table_cell, str_v, style_name)
      key = [y, x + i]
      @cell_type[sheet] ||= {}
      @cell_type[sheet][key] = value_type.to_sym if value_type
      @formula[sheet] ||= {}
      if formula
        ['of:', 'oooc:'].each do |prefix|
          if formula[0, prefix.length] == prefix
            formula = formula[prefix.length..-1]
          end
        end
        @formula[sheet][key] = formula
      end
      @cell[sheet] ||= {}
      @style[sheet] ||= {}
      @style[sheet][key] = style_name
      case @cell_type[sheet][key]
      when :float
        @cell[sheet][key] = (table_cell.attributes['value'].to_s.include?(".") || table_cell.children.first.text.include?(".")) ? v.to_f : v.to_i
      when :percentage
        @cell[sheet][key] = v.to_f
      when :string
        @cell[sheet][key] = str_v
      when :date
        # TODO: if table_cell.attributes['date-value'].size != "XXXX-XX-XX".size
        if attribute(table_cell, 'date-value').size != 'XXXX-XX-XX'.size
          #-- dann ist noch eine Uhrzeit vorhanden
          #-- "1961-11-21T12:17:18"
          @cell[sheet][key]      = DateTime.parse(attribute(table_cell, 'date-value').to_s)
          @cell_type[sheet][key] = :datetime
        else
          @cell[sheet][key] = table_cell.attributes['date-value']
        end
      when :time
        hms = v.split(':')
        @cell[sheet][key] = hms[0].to_i * 3600 + hms[1].to_i * 60 + hms[2].to_i
      else
        @cell[sheet][key] = v
      end
    end
493266
def set_pixel(self, x, y, value):
        
        if x < 0 or x > 7 or y < 0 or y > 7:
            # Ignore out of bounds pixels.
            return
        # Set green LED based on 1st bit in value.
        self.set_led(y * 16 + x, 1 if value & GREEN > 0 else 0)
        # Set red LED based on 2nd bit in value.
        self.set_led(y * 16 + x + 8, 1 if value & RED > 0 else 0)
83178
def set_val val, x, y
    if !x.is_a?Integer
      Error.call "Matrix::set_val : '#{x}' is not a correct line"
      return nil
    elsif !y.is_a?Integer
      Error.call "Matrix::set_val : '#{y}' is not a correct column"
      return nil
    elsif !val.is_a?Numeric
      Error.call "Matrix::set_val : '#{val}' is not a correct value"
      return nil
    elsif x < 0 or y < 0 or x >= @lines or y >= @columns
      Error.call "Matrix::set_val : The specified positions are invalids (#{x} >= #{@lines},#{y} >= #{@columns})\n#{self.to_s}"
      return nil
    else
      @v[x][y] = val
      return @v[x][y]
    end
  end
767361
def set(self, x, y):
        
        x = normalize(x)
        y = normalize(y)
        col, row = get_pos(x, y)

        if type(self.chars[row][col]) != int:
            return

        self.chars[row][col] |= pixel_map[y % 4][x % 2]
931088
def _set_text(self, value):
        
        working_index = self.working_index
        working_lines = self._working_lines

        original_value = working_lines[working_index]
        working_lines[working_index] = value

        # Return True when this text has been changed.
        if len(value) != len(original_value):
            # For Python 2, it seems that when two strings have a different
            # length and one is a prefix of the other, Python still scans
            # character by character to see whether the strings are different.
            # (Some benchmarking showed significant differences for big
            # documents. >100,000 of lines.)
            return True
        elif value != original_value:
            return True
        return False
1371463
def set(self, value: int):
        
        max_value = int(''.join(['1' for _ in range(self._bit_width)]), 2)

        if value > max_value:
            raise ValueError('the value {} is larger than '
                             'the maximum value {}'.format(value, max_value))

        self._value = value
        self._text_update()