{{{ private function applyPropertyValuesToClonedWidget()
190973
private function applyPropertyValuesToClonedWidget($cloned_widget)
    {
        foreach ($this->property_values as $name => $value) {
            $object = $this->mappings[$name]['object'];
            $property = $this->mappings[$name]['property'];

            $prototype_descendants = array($this->prototype_widget);
            $cloned_descendants = array($cloned_widget);

            if ($this->prototype_widget instanceof SwatUIParent) {
                $prototype_descendants = array_merge(
                    $prototype_descendants,
                    $this->prototype_widget->getDescendants()
                );

                $cloned_descendants = array_merge(
                    $cloned_descendants,
                    $cloned_widget->getDescendants()
                );
            }

            $cloned_object = null;
            foreach ($prototype_descendants as $index => $prototype_object) {
                if ($object === $prototype_object) {
                    $cloned_object =
                        $this->widgets[$this->replicator_id][$object->id];

                    break;
                }
            }

            if ($cloned_object === null) {
                throw new SwatException(
                    'Cloned widget tree does not match ' .
                        'prototype widget tree.'
                );
            }

            if ($cloned_object->$property instanceof SwatCellRendererMapping) {
                $cloned_object->$property = $value;
            }
        }
    }
1240954
public void afterPropertiesSet() {
        for (Properties properties : propertiesArray) {
            if (properties instanceof ReloadableProperties) {
                logger.debug("add property listener: " + properties.toString());
                ((ReloadableProperties) properties).addReloadablePropertiesListener(this);
            }
        }
    }
274438
private void processPropDefaultValues() {
    getMethodsWithAnnotation(component, PropDefault.class).forEach(method -> {
      PropDefault propValidator = method.getAnnotation(PropDefault.class);

      String exposedMethodName = exposeExistingJavaMethodToJs(method);
      String propertyName = propValidator.value();
      optionsBuilder.addStatement("options.addJavaPropDefaultValue(p.$L, $S)",
          exposedMethodName,
          propertyName);
    });
  }
932827
function() {

		var data_source = this._foreach_scope.getValue(),
			new_uids = data_source.getUIDs(),
			new_uid_to_index_map = data_source.getUIDToIndexMap(),
			count = data_source.getCount(),
			i = 0,
			uid,
			template,
			removed_templates = [],
			child_properties,
			current_templates = [];

		for (; i < this._current_count; i++) {

			uid = this._current_uids[i];

			if (!(uid in new_uid_to_index_map)) {

				removed_templates.push(this._current_hash[uid]);
				delete this._current_hash[uid];

			}

		}

		for (i = 0; i < count; i++) {

			uid = new_uids[i];

			child_properties = {
				foreach_index: i,
				foreach_name: data_source.getNameAt(new_uid_to_index_map[uid])
			};
			child_properties[this._as] = data_source.getValueAt(new_uid_to_index_map[uid]);

			if (uid in this._current_hash) {

				template = this._current_hash[uid];
				template.batchSetProperties(child_properties);

			} else {

				template = new Lava.system.Template(this._config.template, this._widget, this, child_properties);
				this._current_hash[uid] = template;

			}

			current_templates.push(template);

		}

		removed_templates.length && this._removeTemplates(removed_templates);

		this._current_count = count;
		this._current_uids = new_uids;
		this._current_templates = current_templates;
		this._requires_refresh_children = false;

	}
1016275
def propertyWidgetMap(self):
        
        out = {}
        scaffold = self.scaffold()
        
        # initialize the scaffold properties
        for widget in self.findChildren(QtGui.QWidget):
            propname = unwrapVariant(widget.property('propertyName'))
            if not propname: continue
            
            prop = scaffold.property(propname)
            if not prop: continue
            
            out[prop] = widget

        return out
837941
function () {
            this.$BindableWidget.initWidget.call(this);

            var bindings = this._cfg.bind;
            var isBound = false;

            if (bindings.visible) {
                var visible = this._transform(bindings.visible.transform, bindings.visible.inside[bindings.visible.to], "toWidget");
                if (visible === true) {
                    this.show();
                }
                isBound = true;
            }
            if (!isBound) {
                this.$logWarn(this.BINDING_NEEDED, [this.$class, "visible"]);
            }
        }
763023
function(){
      if (this.locked)
      {
        this.locked--;

        if (!this.locked)
        {
          var lockedValue = this.lockedValue_;

          this.lockedValue_ = null;

          if (this.value !== lockedValue)
            this.emit_change(lockedValue);
        }
      }
    }
548703
function(view, config, widget) {

		this.Element$init(view, config, widget);

		var self = this;

		this._OldIE_refresh_callback = function() {
			self._sendRefreshValue();
		};
		this._OldIE_property_change_callback = function(e) {
			if (e.propertyName == "value") {
				self._sendRefreshValue();
			}
		};

	}
278729
function(value) {
                this.lastValue = this.currentValue;
                this.currentValue = value;
                this.setter.call(this.target, this.target, value, this);
            }
1286910
public function handleEncodePropertyValueFromWidget(EncodePropertyValueFromWidgetEvent $event)
    {
        $attribute = $this->getSupportedAttribute($event);
        if (!$attribute) {
            return;
        }

        $date = \DateTime::createFromFormat($attribute->getDateTimeFormatString(), $event->getValue());

        if ($date) {
            $event->setValue($date->getTimestamp());
        }
    }
1305391
private void updateBeanValueForRenderedRows() {
		WTableRowRenderer rowRenderer = (WTableRowRenderer) repeater.getRepeatedComponent();
		TableModel model = getTableModel();

		int index = 0;

		List<RowIdWrapper> wrappers = repeater.getBeanList();

		int columnCount = getColumnCount();

		for (RowIdWrapper wrapper : wrappers) {
			UIContext rowContext = repeater.getRowContext(wrapper, index++);
			List<Integer> rowIndex = wrapper.getRowIndex();

			Class<? extends WComponent> expandRenderer = model.getRendererClass(rowIndex);
			if (expandRenderer == null) {
				// Process Columns
				for (int col = 0; col < columnCount; col++) {
					// Check if this cell is editable
					if (model.isCellEditable(rowIndex, col)) {
						updateBeanValueForColumnInRow(rowRenderer, rowContext, rowIndex, col, model);
					}
				}
			} else if (model.isCellEditable(rowIndex, -1)) {
				// Check if this expanded row is editable
				updateBeanValueForRowRenderer(rowRenderer, rowContext, expandRenderer);
			}

		}
	}
753164
def _update_widgets(self):
        ''

        self._time_sensitive = any(getattr(w, 'TIME_SENSITIVE', False)
                                    for w in self.widgets)
1226723
public function updateValue()
    {
        $name = $this->getName();
        foreach ($this->getDataSources() as $ds) {
            if (null !== ($value = $ds->getValue($name))) {
                $this->setValue($value);
                return;
            }
        }
        parent::updateValue();
    }
747353
function() {

		Lava.suspendListener(this._widget_property_changed_listener);
		this._scope_changed_listener && Lava.suspendListener(this._scope_changed_listener);
		this._scope.setValue(this._widget.get(this._property_name));
		Lava.resumeListener(this._widget_property_changed_listener);
		this._scope_changed_listener && Lava.resumeListener(this._scope_changed_listener);

	}
531065
public void apply(FaceletContext ctx, UIComponent parent) throws IOException, FacesException, FaceletException,
            ELException
    {
        if (!ComponentHandler.isNew(parent))
        {
            return;
        }
        if (parent instanceof EditableValueHolder)
        {
            applyAttachedObject(ctx.getFacesContext(), parent);
        }
        else if (UIComponent.isCompositeComponent(parent))
        {
            FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance(ctx);
            mctx.addAttachedObjectHandler(parent, this);
        }
        else
        {
            throw new TagException(this.tag,
                    "Parent not composite component or an instance of EditableValueHolder: " + parent);
        }
    }
667087
def updateFromKwargs(self, properties, kwargs, collector, **unused):
        """'"""
        properties[self.name] = self.getFromKwargs(kwargs)
1364727
function () {
                this.$InputElement.initWidget.call(this);

                var bindings = this._cfg.bind;
                var binding = bindings.selectedValue;
                if (binding) {
                    var newValue = this._transform(binding.transform, binding.inside[binding.to], "toWidget");
                    this._domElt.checked = (newValue === this._cfg.value);
                } else {
                    this.$logWarn(this.BINDING_NEEDED, [this.$class, "selectedValue"]);
                }
            }