Updates the items to reflect the current check state system.
513735
def updateCheckState( self ):
        
        checkable = self.isCheckable()
        model     = self.model()
        flags     = Qt.ItemIsSelectable | Qt.ItemIsEnabled
        
        for i in range(self.count()):
            item = model.item(i)
            
            if not (checkable and item.text()):
                item.setCheckable(False)
                item.setFlags(flags)
            
            # only allow checking for items with text
            else:
                item.setCheckable(True)
                item.setFlags(flags | Qt.ItemIsUserCheckable)
1020988
public void updateItem (T item)
    {
        if (_items == null) {
            return;
        }
        int idx = _items.indexOf(item);
        if (idx == -1) {
            _items.add(0, item);
        } else {
            _items.set(idx, item);
        }
    }
567211
protected void update() {
        int sz = dataModel.getSize();
        int[] selected = helperList.getSelectedIndices();
        ArrayList sourceItems = new ArrayList(sz);
        ArrayList chosenItems = new ArrayList(selected.length);

        // Start with the source items filled from our data model
        for (int i = 0; i < sz; i++) {
            sourceItems.add(dataModel.getElementAt(i));
        }

        // Now move the selected items to the chosen list
        for (int i = selected.length - 1; i >= 0; i--) {
            chosenItems.add(sourceItems.remove(selected[i]));
        }

        Collections.reverse(chosenItems); // We built it backwards

        // Now install the two new lists
        sourceList.setListData(sourceItems.toArray());
        chosenList.setListData(chosenItems.toArray());
    }
1242229
def _reset_changes(self):
        """"""
        self._original = {}
        if self.last_updated is not None:
            self._original['last_updated'] = self.last_updated
1160857
def _update_states(self, uid, states):
        
        #TODO: use try and catch all exceptions
        # test if uid exists
        if self.controllers[uid]:
            # test if states have correct lenght
            if len(states) == 14:
                old_states = self.controllers[uid][2]
                if old_states != states:
                    for key in range(14):
                        if int(old_states[key]) > int(states[key]):
                            e = Event(uid, E_KEYUP, key)
                            self.queue.put_nowait(e)
                        elif int(old_states[key]) < int(states[key]):
                            e = Event(uid, E_KEYDOWN, key)
                            self.queue.put_nowait(e)
                self.controllers[uid][2] = states
            self.controllers[uid][3] = time.time()
579351
function update() {
        for (var i = 0; i < states.length; i++) {
          if (anyMatch(states[i].state, states[i].params)) {
            addClass($element, activeClasses[states[i].hash]);
          } else {
            removeClass($element, activeClasses[states[i].hash]);
          }

          if (exactMatch(states[i].state, states[i].params)) {
            addClass($element, activeEqClass);
          } else {
            removeClass($element, activeEqClass);
          }
        }
      }
160539
def add_check(self, check_item):
        """"""
        self.checks.append(check_item)
        for other in self.others:
            other.add_check(check_item)
186053
def update(self, *args, **kwargs):
        """"""
        self._extend(args, kwargs, 'update', self._update_items)
589920
function(items) {
				items.forEach(function(item) {
					update(item._positions);
					if (item.type == 'container') {
						recursiveUpdate(item.list());
					}
				});
			}
267394
def refresh(self):
        
        self.invalidate()
        full = not self._manager._list_has_name
        res_list = self._manager.list(full_properties=full)
        self.update_from(res_list)
452046
private function updateStatus()
    {
        $status = $this->deliveryExecution->getState()->getUri();
        $this->addValue(DeliveryMonitoringService::STATUS, $status, true);
        if ($status == ProctoredDeliveryExecution::STATE_PAUSED) {
            $this->addValue(DeliveryMonitoringService::LAST_PAUSE_TIMESTAMP, microtime(true), true);
        }
    }
616846
def update(self):
        """"""

        if self.device_time_check():

            if not self.in_process:
                outlets, switches, fans = self.get_devices()

                self.outlets = helpers.resolve_updates(self.outlets, outlets)
                self.switches = helpers.resolve_updates(
                    self.switches, switches)
                self.fans = helpers.resolve_updates(self.fans, fans)

                self.last_update_ts = time.time()
265178
public void updateState() {
        // Applying zoom patch (needed in case if image size is changed)
        stateController.applyZoomPatch(state);
        stateController.applyZoomPatch(prevState);
        stateController.applyZoomPatch(stateStart);
        stateController.applyZoomPatch(stateEnd);
        exitController.applyZoomPatch();

        boolean reset = stateController.updateState(state);
        if (reset) {
            notifyStateReset();
        } else {
            notifyStateUpdated();
        }
    }
98828
def update(self, *args):
        
        for d in args:
            for (key, value) in d.items():
                self.__setitem__(key, value)
487480
public void updateChecksums() {
        for (Entry<File, ChecksumData> entry : checksumsMap.entrySet()) {
            updateChecksums(entry.getKey(), entry.getValue());
        }
    }
219382
public void update(CmsPublishItemStatus status) {

        if (status.isDisabled()) {
            m_selectedCheckBox.setEnabled(false);
            m_selectedCheckBox.setChecked(false);
            m_removeCheckBox.setChecked(status.getState() == State.remove);
            updateRemoval(status.getState() == State.remove);
        } else {
            switch (status.getState()) {
                case remove:
                    m_selectedCheckBox.setChecked(false);
                    m_selectedCheckBox.setEnabled(false);
                    m_removeCheckBox.setChecked(true);
                    updateRemoval(true);
                    break;
                case publish:
                    m_selectedCheckBox.setEnabled(true);
                    m_selectedCheckBox.setChecked(true);
                    m_removeCheckBox.setChecked(false);
                    updateRemoval(false);
                    break;
                case normal:
                default:
                    m_selectedCheckBox.setChecked(false);
                    m_selectedCheckBox.setEnabled(true);
                    m_removeCheckBox.setChecked(false);
                    updateRemoval(false);
                    break;

            }
        }
    }
1219621
private void update() {
                if (!uptodate) {
                        summary.clear();
                        distinctTraces.clear();
                        traces.clear();
                        addTraces(allTraces, false);
                        uptodate = true;
                }
        }