Save the modified properties
437916
function() {
        elemData.buttonText = buttonEditor.find('.kelmu-button-text').val() || '?';
        elemData.font = buttonEditor.find('.kelmu-button-font').val() || window.kelmu.defaults.button.font;
        elemData.size = buttonEditor.find('.kelmu-button-size').val() || window.kelmu.defaults.button.size;
        elemData.rotate = buttonEditor.find('.kelmu-button-rotate').val() || window.kelmu.defaults.button.rotate;
        elemData.button = buttonEditor.find('.kelmu-button-action').val() || 'show';
        elemData.parameter = buttonEditor.find('.kelmu-button-parameter').val();
        window.kelmu.data[id].actions.update();
        updateView(true, true);
        notifyModifications();
      }
265514
def save(self):
        

        # create or update instance node
        if hasattr(self, 'id'):
            # update
            params = self.deflate(self.__properties__, self)
            query = "MATCH (n) WHERE id(n)={self} \n"
            query += "\n".join(["SET n.{0} = {{{1}}}".format(key, key) + "\n"
                                for key in params.keys()])
            for label in self.inherited_labels():
                query += "SET n:`{0}`\n".format(label)
            self.cypher(query, params)
        elif hasattr(self, 'deleted') and self.deleted:
            raise ValueError("{0}.save() attempted on deleted node".format(
                self.__class__.__name__))
        else:  # create
            self.id = self.create(self.__properties__)[0].id
        return self
826657
public function postSave()
    {
        if ($this->updating) {
            foreach ($this->changedRevisionableFields() as $key => $change) {
                RevisionRepository::create([
                    'revisionable_type' => get_class($this),
                    'revisionable_id'   => $this->getKey(),
                    'key'               => $key,
                    'old_value'         => $this->getDataValue('original', $key),
                    'new_value'         => $this->getDataValue('updated', $key),
                    'user_id'           => $this->getUserId(),
                ]);
            }
        } else {
            RevisionRepository::create([
                'revisionable_type' => get_class($this),
                'revisionable_id'   => $this->getKey(),
                'key'               => 'created_at',
                'old_value'         => null,
                'new_value'         => new DateTime(),
                'user_id'           => $this->getUserId(),
            ]);
        }
    }
987834
private void modifyTenantProperties(TenantDefinition oldTenantDef, TenantDefinition newTenantDef) {
        // _CreatedOn must be the same. _ModifiedOn must be updated.
        newTenantDef.setProperty(CREATED_ON_PROP, oldTenantDef.getProperty(CREATED_ON_PROP));
        newTenantDef.setProperty(MODIFIED_ON_PROP, Utils.formatDate(new Date().getTime()));
    }
1143059
def add_properties(self, properties):
        
        if isinstance(properties, dict):
            self._properties.update(properties)
443407
public void saveOldProperty(Map<String,String> oldProperties, String param)
    {
        oldProperties.put(param, this.getTask().getProperty(param));
    }
588101
public void save() {
        SC.ask("Do you want to save changes", new BooleanCallback() {
            @Override
            public void execute(Boolean yesSelected) {
                if (yesSelected) {
                    jcrService().save(repository(), workspace(), new BaseCallback<Object>() {
                            @Override
                            public void onSuccess(Object result) {
                                session().setHasChanges(false);
                                updateControls();
                            }
                    });
                }
            }
        });
    }
414219
public synchronized void save() {
        SharedPreferences prefs = loadSharedPreferences("object");

        if (find(getId()) == null) {
            addObject();

            modelListenerHandler.execOnUpdateListeners(this, OnUpdateListener.Status.CREATED);

            if (cache && cachedObjects != null) {
                cachedObjects.add((T) this);
            }
        } else {
            modelListenerHandler.execOnUpdateListeners(this, OnUpdateListener.Status.UPDATED);
        }

        prefs.edit().putString(String.valueOf(getId()), toJson().toString()).commit();
    }
1191440
def _apply_properties(widget, properties={}):
    
    with widget.hold_sync():
        for key, value in properties.items():
            setattr(widget, key, value)
1152
def on_modified(self, event):
        """"""
        path = event.src_path
        if path not in self.saw:
            self.saw.add(path)
            self.recompile(path)
1241777
def save(self):
        """"""
        if not self._dirty:
            return

        fields = []
        formdata = dict(self._p4dict)
        del formdata['code']
        for key, value in six.iteritems(formdata):
            match = re.search('\d$', key)
            if match:
                value = '\t{}'.format(value)
                key = key[:match.start()]

            value = value.replace('\n', '\n\t')
            fields.append('{}:  {}'.format(key, value))
        form = '\n'.join(fields)
        self._connection.run([self.COMMAND, '-i'], stdin=form, marshal_output=False)
        self._dirty = False
32199
public void save(File propertiesFile, String comments) throws IOException {
        FileWriter writer = new FileWriter(propertiesFile);
        _properties.store(writer, comments);
        writer.close();
    }
530755
def save(self):
        
        props = self.deflate(self.__properties__)
        query = "MATCH ()-[r]->() WHERE id(r)={self} "
        for key in props:
            query += " SET r.{0} = {{{1}}}".format(key, key)
        props['self'] = self.id

        db.cypher_query(query, props)

        return self
240011
def save(self):
        """"""

        for key in self.defaults.__dict__:
            data = getattr(self.data, key)

            self.cfg_file.Write(key, data)
1052369
def save(self):
        """"""
        self._connection.run(['change', '-i'], stdin=format(self), marshal_output=False)
        self._dirty = False
576142
def save(self):
        '''
        
        '''
        client = self._new_api_client()
        params = {'id': self.id} if hasattr(self, 'id') else {}
        action =  'patch' if hasattr(self, 'id') else 'post'
        saved_model = client.make_request(self, action, url_params=params, post_data=self._to_json)
        self.__init__(**saved_model._to_dict)
205138
def save!
      object = self.class.name.split("::").last.downcase
      data = {}

      self.class.accessor_properties.each do |property|
        data[property] = instance_variable_get "@#{property}"
      end

      API.send("update_#{object}", @id, data)
    end