Notifies model that items has changed and view must be refreshed. This will trigger a change event.
766683
public void invalidateDataSet () {
		updateCurrentItem(MathUtils.clamp(currentIndex, 0, items.size - 1));
		spinner.notifyValueChanged(true);
	}
215734
def item_selection_changed(self):
        """"""
        row = self.current_row()
        if self.count() and row >= 0:
            if '</b></big><br>' in self.list.currentItem().text() and row == 0:
                self.next_row()
            if self.mode == self.FILE_MODE:
                try:
                    stack_index = self.paths.index(self.filtered_path[row])
                    self.plugin = self.widgets[stack_index][1]
                    self.goto_line(self.line_number)
                    try:
                        self.plugin.switch_to_plugin()
                        self.raise_()
                    except AttributeError:
                        # The widget using the fileswitcher is not a plugin
                        pass
                    self.edit.setFocus()
                except ValueError:
                    pass
            else:
                line_number = self.filtered_symbol_lines[row]
                self.goto_line(line_number)
832658
public void itemStateChanged(ItemEvent ie) {
		Object source = ie.getSource();
		// System.out.println("ItemEvent:"+source);
		if (source == socks5radio || source == socks4radio)
			onSocksChange();
		else if (source == up_check)
			onUPChange();

	}
808150
@Override
    public void notifyItemChanged(int rowIndex, int columnIndex) {
        for (AdaptiveTableDataSetObserver observer : mAdaptiveTableDataSetObservers) {
            observer.notifyItemChanged(rowIndex, columnIndex);
        }
    }
540732
def _on_prop_changed(self, instance, meth_name, res, args, kwargs):
        """"""
        if  not self._itsme and meth_name == "__setitem__": self.update_widget(args[0])
        return
1056752
def OnTableChanged(self, event):
        """"""

        if hasattr(event, 'updated_cell'):
            # Event posted by cell edit widget.  Even more up to date
            #  than the current cell's contents
            self.ignore_changes = True
            try:
                self.SetValue(event.updated_cell)

            except TypeError:
                # None instead of string present
                pass
            self.ignore_changes = False

        else:
            current_cell = self.main_window.grid.actions.cursor
            current_cell_code = self.main_window.grid.code_array(current_cell)

            if current_cell_code is None:
                self.SetValue(u"")
            else:
                self.SetValue(current_cell_code)

        event.Skip()
960864
@Override
	public void detectAndSendChanges()
	{
		playerInventoryCache.sendChanges();
		inventoryCaches.values().forEach(InventoryCache::sendChanges);

		//picked itemStack
		pickedItemStackCache.update();
		if (pickedItemStackCache.hasChanged())
			UpdateInventorySlotsMessage.updatePickedItemStack(pickedItemStackCache.get(), (EntityPlayerMP) owner, windowId);
	}
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)
1288176
public static <Item extends IItem & IExpandable> void notifyItemsChanged(final FastAdapter adapter, ExpandableExtension expandableExtension, Set<Long> identifiers, boolean restoreExpandedState) {
        int i;
        IItem item;
        for (i = 0; i < adapter.getItemCount(); i++) {
            item = adapter.getItem(i);
            if (item instanceof IExpandable) {
                notifyItemsChanged(adapter, expandableExtension, (Item) item, identifiers, true, restoreExpandedState);
            } else if (identifiers.contains(item.getIdentifier())) {
                adapter.notifyAdapterItemChanged(i);
            }
        }
    }
252045
protected void notifySaveItems(final ItemStateChangesLog changesLog, boolean isListenerTXAware)
   {
      for (MandatoryItemsPersistenceListener mlistener : mandatoryListeners)
      {
         if (mlistener.isTXAware() == isListenerTXAware)
         {
            mlistener.onSaveItems(changesLog);
         }
      }

      for (ExtendedMandatoryItemsPersistenceListener mlistener : extendedMandatoryListeners)
      {
         if (mlistener.isTXAware() == isListenerTXAware)
         {
            mlistener.onSaveItems(changesLog);
         }
      }

      for (ItemsPersistenceListener listener : listeners)
      {
         if (listener.isTXAware() == isListenerTXAware)
         {
            listener.onSaveItems(changesLog);
         }
      }

   }
174029
function(data) { 
			if (data && data.handler.changedItem) {
				data.handler.changedItem();
			} else { 
				explorer.changedItem(); 
			}
		}
279464
function() {
      var newItemViews = [];
      _.each(this.modelsToRender(), function(model, indexOfModel) {
        var itemView = this.getItemViewFromModel(model);
        if (!itemView) {
          newItemViews.push({
            view: this.__createItemView(model, true),
            indexOfModel: indexOfModel
          });
        }
      }, this);
      this.__updateOrderedModelIdList();
      return newItemViews;
    }
755103
def on_selection_changed(self, sel):
        """"""
        m, self.editing_iter = sel.get_selected()

        if self.editing_iter:
            self.editing_model = m[self.editing_iter][0]
            self.show_curr_model_view(self.editing_model, False)
            
        else: self.view.remove_currency_view()
            
        return
665487
def changed(self, item):
        
        if self._rejectChanges:
            raise errors.ChangeRejected()
        if self.transaction is not None:
            self.transaction.add(item)
            self.touched.add(item)
681390
def handle_new_selection(self, items):
        
        if items is None:
            items = ()
        elif not hasattr(items, "__iter__"):
            items = (items,)
        models = set(item.model for item in items)
        self._selection.handle_new_selection(models)
1159296
def refresh(self, item):
        
        client = self._clients[item].get_client()
        self[item] = val = self.item_class(client)
        return val
500000
function(item) {
        var id = item.id || item;

        var removedItem;
        var index = Selectivity.findIndexById(this._data, id);
        if (index > -1) {
            removedItem = this._data[index];
            this._data.splice(index, 1);
        }

        if (this._value[index] !== id) {
            index = this._value.indexOf(id);
        }
        if (index > -1) {
            this._value.splice(index, 1);
        }

        if (removedItem) {
            this.triggerChange({ removed: removedItem });
        }

        if (id === this._highlightedItemId) {
            this._highlightedItemId = null;
        }

        this._updateInputWidth();
    }