Update the tabIndex attribute, in case of changes to tabIndex or disabled
state.

@return $this
765309
public function updateTabIndex() {
		$disabled = $this->isDisabled();
		if ( $this->tabIndex !== null ) {
			$this->tabIndexed->setAttributes( [
				// Do not index over disabled elements
				'tabindex' => $disabled ? -1 : $this->tabIndex,
				// ChromeVox and NVDA do not seem to inherit this from parent elements
				'aria-disabled' => ( $disabled ? 'true' : 'false' )
			] );
		} else {
			$this->tabIndexed->removeAttributes( [ 'tabindex', 'aria-disabled' ] );
		}
		return $this;
	}
583310
public function updateContent()
    {
        $params = array(
            'content' => $this->ensureParameter('content'),
        );

        $this->put(
            sprintf(
                'project/%s/resource/%s/content/',
                $this->ensureParameter('project'),
                $this->ensureParameter('slug')
            ),
            $params
        );

        return $this;
    }
455919
public function update()
    {
        if (!isset($this->_links->self->href)) {
            return $this;
        }

        $body = json_encode(array(
            "billingAddress" => $this->billingAddress,
            "shippingAddress" => $this->shippingAddress,
        ));

        $result = $this->client->performHttpCallToFullUrl(MollieApiClient::HTTP_PATCH, $this->_links->self->href, $body);

        return ResourceFactory::createFromApiResult($result, new Order($this->client));
    }
1284682
public function setActive($tabId = null)
    {
        $tabId = is_null($tabId) ? $this->getTabId(true) : $tabId;
        if (empty($this->tabs[$tabId])) {
            throw new Exception\InvalidArgumentException('Invalid tab id supplied.');
        }

        if (null !== $this->active) {
            $this->tabs[$this->active]['active'] = false;
        }

        $this->tabs[$tabId]['active'] = true;
        $this->active                 = $tabId;

        return $this;
    }
401349
function() {
			var self = this;
			self.$input.prop('disabled', false);
			self.$control_input.prop('disabled', false).prop('tabindex', self.tabIndex);
			self.isDisabled = false;
			self.unlock();
		}
86035
public function getUpdated()
    {
        return $this->getCachedProperty(
            'updated',
            function () {
                $element = $this->query('atom:updated', Node::SINGLE | Node::REQUIRED);

                /** @var Element $this */
                return $this->getExtensions()->parseElement($this, $element);
            }
        );
    }
377409
private function updateOffset()
    {
        if ($this->after()) {
            $this->params['after'] = $this->collection[$this->total_count - 1]['id'];
        } else {
            $this->params['before'] = $this->collection[$this->total_count - 1]['id'];
        }
        return $this;
    }
174055
protected function updateInstance()
    {
        $this->instances++;
        $id = $this->generateId();
        $this->setAttribute($id, $id);
        if ($label = $this->getLabel()) {
            $label->setAttribute('for', $id);
        }
        
        return $this;
    }
1032786
protected function updateIndex()
    {
        $configurator = $this->getIndexConfigurator();

        $indexPayload = (new IndexPayload($configurator))->get();

        $indices = ElasticClient::indices();

        if (! $indices->exists($indexPayload)) {
            throw new LogicException(sprintf(
                'Index %s doesn\'t exist',
                $configurator->getName()
            ));
        }

        try {
            $indices->close($indexPayload);

            if ($settings = $configurator->getSettings()) {
                $indexSettingsPayload = (new IndexPayload($configurator))
                    ->set('body.settings', $settings)
                    ->get();

                $indices->putSettings($indexSettingsPayload);
            }

            if ($defaultMapping = $configurator->getDefaultMapping()) {
                $indexMappingPayload = (new IndexPayload($configurator))
                    ->set('type', '_default_')
                    ->set('body._default_', $defaultMapping)
                    ->get();

                $indices->putMapping($indexMappingPayload);
            }

            $indices->open($indexPayload);
        } catch (Exception $exception) {
            $indices->open($indexPayload);

            throw $exception;
        }

        $this->info(sprintf(
            'The index %s was updated!',
            $configurator->getName()
        ));
    }
407265
def _update_gui_text_tabs(self):
        """"""
        for index, page in enumerate(self.pages):
            self.tabWidget.setTabText(index, "{} (Alt+&{}){}".format(page.text_tab, index+1, (" (changed)" if page.flag_changed else "")))
610510
public function setCheckboxAttributes(array $a)
    {
        foreach ($this->checkboxes as $checkbox) {
            $checkbox->setAttributes($a);
            if (isset($a['tabindex'])) {
                $a['tabindex']++;
            }
        }
        return $this;
    }
596828
protected function update() {
		
		if(!is_null($this->callback)) {
			
			// Not using application/javascript for compatibility reasons with older browsers.
			$this->headers->set('Content-Type', 'text/javascript');
				
			return $this->setContent(sprintf('/**/%s(%s);', $this->callback, $this->data)); 

		}
		
		// set header only when there is none or when it equals 'text/javascript' (from a previous update with callback)
		// in order to not overwrite a custom definition

		if(!$this->headers->has('Content-Type') || $this->headers->get('Content-Type') === 'text/javascript') {
			$this->headers->set('Content-Type', 'application/json');
		}

		return $this->setContent($this->data);

	}
83988
public function getTabButton() {
    if (!isset($this->tabButton)) {
      if ($this->context === self::CONTEXT_DELETE) {
        $this->tabButton = new DeleteTabButton($this);
      } else {
        $this->tabButton = new TabButton($this);
      }
    }
    return $this->tabButton;
  }
345606
public function setInactiveAll() {
		foreach ($this->getElements() as $element) {
			if ($element instanceof Element) {
				$element->setInactive();
			}
		}
		
		return $this;
	}
652917
public function refresh()
    {
        $behaviors = $this->owner->behaviors();
        $settings = $behaviors[$this->getName()];
        foreach ($settings as $attribute=>$value) {
            if (in_array($attribute, array('class'))) {
                continue;
            }
            $this->$attribute = $value;
        }
        return $this;
    }
1226723
public function updateValue()
    {
        $name = $this->getName();
        foreach ($this->getDataSources() as $ds) {
            if (null !== ($value = $ds->getValue($name))) {
                $this->setValue($value);
                return;
            }
        }
        parent::updateValue();
    }
1008581
protected function updateTargetIndexMapping()
    {
        $sourceModel = $this->getModel();
        $sourceIndexConfigurator = $sourceModel->getIndexConfigurator();

        $targetIndex = $this->argument('target-index');
        $targetType = $sourceModel->searchableAs();

        $mapping = array_merge_recursive(
            $sourceIndexConfigurator->getDefaultMapping(),
            $sourceModel->getMapping()
        );

        if (empty($mapping)) {
            $this->warn(sprintf(
                'The %s mapping is empty.',
                get_class($sourceModel)
            ));

            return;
        }

        $payload = (new RawPayload())
            ->set('index', $targetIndex)
            ->set('type', $targetType)
            ->set('body.'.$targetType, $mapping)
            ->get();

        ElasticClient::indices()
            ->putMapping($payload);

        $this->info(sprintf(
            'The %s mapping was updated.',
            $targetIndex
        ));
    }