Set the changed flag to indicate if the component changed in the last request.

@param changed true if the value changed in the request
183588
protected void setChangedInLastRequest(final boolean changed) {
		if (isChangedInLastRequest() != changed) {
			InputModel model = getOrCreateComponentModel();
			model.changedInLastRequest = changed;
		}
	}
869292
@Override
    public void changed(ChangeEvent event) {
        // forget cached IDs (Should be executed in workExecutor)
        final long lastSeqPushed = (isPull() || replicationInternal.lastSequence == null) ? -1L :
                Long.valueOf(replicationInternal.lastSequence);
        if (lastSeqPushed >= 0 && lastSeqPushed != _lastSequencePushed) {
            db.runAsync(new AsyncTask() {
                @Override
                public void run(Database database) {
                    synchronized (_lockPendingDocIDs) {
                        _lastSequencePushed = lastSeqPushed;
                        _pendingDocIDs = null;
                    }
                }
            });
        }

        for (ChangeListener changeListener : changeListeners) {
            try {
                changeListener.changed(event);
            } catch (Exception e) {
                Log.e(Log.TAG_SYNC, "Exception calling changeListener.changed", e);
            }
        }
    }
102523
private void onChanged() {
    // If builder is null, this is the case where onChanged is being called
    // from setMessage or clear.
    if (builder != null) {
      message = null;
    }
    if (isClean && parent != null) {
      parent.markDirty();

      // Don't keep dispatching invalidations until build is called again.
      isClean = false;
    }
  }
650602
void onItemsChanged(boolean structureChanged) {
        if (!mPreventDispatchingItemsChanged) {
            if (structureChanged) {
                mIsVisibleItemsStale = true;
                mIsActionItemsStale = true;
            }

            dispatchPresenterUpdate(structureChanged);
        } else {
            mItemsChangedWhileDispatchPrevented = true;
        }
    }
263492
private void initializeChangedMap() {
    // set changed flags
    changed.put("display_name", false);
    changed.put("description", false);
    changed.put("notes", false);
    changed.put("custom", false);
    changed.put("created", false); 
  }
987659
public void valueChanged( ListSelectionEvent e ) {
        if( !e.getValueIsAdjusting() ) {

            // We need to install this new value into the value model, but
            // we don't want to propogate it back down to the adapted selection
            // model (since we are responding to a change in that model).
            skipSelectionModelUpdate = true;
            setValue(getSelectedRows());
            skipSelectionModelUpdate = false;
        }
    }
1217077
def on_property_change(self, name, old_value, new_value):
        # pylint: disable=W0613
        
        if name in self._keys:
            try:
                if self.update_filter():
                    # This is a key for the filter and the filter has changed
                    # => Force the handler to update its dependency
                    self._reset()
            except ValueError:
                # Invalid filter: clear all references, this will invalidate
                # the component
                for svc_ref in self.get_bindings():
                    self.on_service_departure(svc_ref)
475891
private void setValue(boolean rollover) {
        if (!ValueUtils.areEqual(this.rollover, rollover)) {
            boolean oldValue = this.rollover;
            this.rollover = rollover;
            maybeNotifyListeners(oldValue, rollover);
        }
    }
406325
@Override
    public void notifyLayerChanged(FeatureProvider provider,
                                   Integer layerRefreshOld,
                                   Integer layerRefreshNew,
                                   Integer layerDisplayOld,
                                   Integer layerDisplayNew)
    {
        if (provider.hasFeature(Displayable.class))
        {
            final Displayable displayable = provider.getFeature(Displayable.class);
            getLayer(layerDisplayOld).remove(displayable);
            getLayer(layerDisplayNew).add(displayable);
            indexs.add(layerDisplayNew);
        }
    }
553601
void onSubFolderChange(Boolean value) {

        List<I_CmsHistoryResource> historyResources;
        try {
            CmsObject cms = m_dialogContext.getCms();
            historyResources = cms.readDeletedResources(cms.getSitePath(m_resource), value.booleanValue());
            initDeletedResources(cms, historyResources);
        } catch (CmsException e) {
            m_dialogContext.error(e);
        }
    }
1181754
@Override
    public void valueChanged(TreeSelectionEvent e) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();

        if (node != null && node.isLeaf()) {
            int pos = workspace.getDividerLocation();
            workspace.setTopComponent((JPanel) node.getUserObject());
            workspace.setDividerLocation(pos);
        }
    }
82852
public void propertyChange(PropertyChangeEvent evt)
    {
        if (JCalendarPopup.DATE_PARAM.equalsIgnoreCase(evt.getPropertyName()))
            if (evt.getNewValue() instanceof java.util.Date)
        {
            this.setControlValue(evt.getNewValue());
        }
    }
1018103
public void setProjectChanged(boolean b) {
        if (curProject == null) {
            return;
        }

        if (projectChanged == b) {
            return;
        }

        projectChanged = b;
        mainFrameMenu.setSaveMenu(this);

        getRootPane().putClientProperty(WINDOW_MODIFIED, b);

    }
199054
public void propertyChange(PropertyChangeEvent event)
	{
		if (contains(event.getSource()) && "beanContext".equals(event.getPropertyName()) && event.getOldValue() == getBeanContextPeer())
		{
			remove(event.getSource(), false);
		}
	}
469670
@Override
    public void configurationChanged() {

        HashSet<Param> changedParams = new HashSet();

        // read dynamic parameters
        for (Param param : parameters) {

            if (! param.isStatic()) {

                // preserve current value
                Object oldValue = param.getValue();

                // read new value
                readAndValidateParameter(param);

                // get if parameter value had changed
                if (! ConfigUtil.equalValues(oldValue, param.getValue())) {
                    changedParams.add(param);
                }
            }

        }

        // invoke listeners for all changed parameters
        if (! changedParams.isEmpty()) {

            for (ConfigChangeListener listener : configChangeListeners) {
                listener.configurationChanged(changedParams);
            }

        }

    }
703787
void changedValue(Object value) {
		Object oldValue = super.putSilent(VALUE, value);
		if (!Objects.equals(oldValue, value)) {
			fireChange();
		}
	}
1336823
public void onMapViewChanged(MapViewChangedEvent event) {
		super.onMapViewChanged(event);
		if (null != activeViewConfig && !event.isSameScaleLevel()) {
			resetIcons();
		}
	}