Refreshes the view, executing the following steps in that order:
triggers init hooks, refreshes dynamic embedded views, triggers content hooks, sets host
bindings,
refreshes child components.
Note: view hooks are triggered later when leaving the view.
358803
function refreshView() {
    if (!checkNoChangesMode) {
        executeInitHooks(viewData, tView, creationMode);
    }
    refreshDynamicEmbeddedViews(viewData);
    if (!checkNoChangesMode) {
        executeHooks(directives, tView.contentHooks, tView.contentCheckHooks, creationMode);
    }
    // This needs to be set before children are processed to support recursive components
    tView.firstTemplatePass = firstTemplatePass = false;
    setHostBindings(tView.hostBindings);
    refreshContentQueries(tView);
    refreshChildComponents(tView.components);
}
1245062
function registerView(view) {
  var name = view.getDebugName();
  var wrapped = new RegistryWrapper(view, 'views');
  flatRegistry.views[name] = wrapped;
  if (!view.parentView && !view.isComponentView) {
    nestedRegistry.views[name] = wrapped;
  }
  if (typeof view.destroy === 'function') {
    wrapped.destroy = _.bind(view.destroy, view);
    view.destroy = _.bind(function() {
      var name = this.obj.getDebugName();
      delete nestedRegistry.views[name];
      delete flatRegistry.views[name];
      updateNestedModels();
      triggerChange();
      this.destroy();
    }, wrapped);
  }
  updateNestedModels();
  triggerChange();
}
250037
private void refresh() {
        if (this.previewedThread != null) {
            if (this.previewedThread.isComplete()) {
                setLatestPreview();
                disableRefresh();
            } else {
                this.previewedThread.getPreview(ALPreviewPanel.this);
            }
        }
    }
505434
function initViews () {
    // list of views - may be empty
    this.modelViews = []
    // if view is false no model views will be applied overriding any defaults
    if (this.args.view === false) {
        return
    }
    // get view from args or default
    var viewArg = defined(this.args.view) ? this.args.view : this.model.views.default
    // skip unless view arg is set from args or default
    if (!defined(viewArg)) {
        return
    }
    // list of views to apply to model
    var views
    // if view is string then convert to array
    if (typeof viewArg === 'string') {
        views = [viewArg]
    }
    // if view is array use it
    else if (Array.isArray(viewArg)) {
        views = viewArg
    }
    // invalid argument
    else {
        throw this.error('invalid view argument')
    }
    // iterate over views getting model view objects
    _.each(views, view => {
        var modelView = requireValidModelView(view, this.model.views, true)
        // if result is array then add all
        if (Array.isArray(modelView)) {
            _.each(modelView, modelView => this.modelViews.push(modelView))
        }
        // otherwise add object
        else {
            this.modelViews.push(modelView)
        }
    })
    // instantiate model view engine if there are views
    if (this.modelViews.length > 0) {
        this.modelViewEngine = new ImmutableCoreModelViewEngine({query: this})
    }
}
308021
def refresh_views(self, change=None):
        
        adapter = self.adapter

        # Set initial ListItem state
        item_mapping = self.item_mapping
        for i, item in enumerate(self.list_items):
            item_mapping[i] = item
            item.recycle_view(i)

        if adapter:
           adapter.clearRecycleViews()
           adapter.setRecycleViews(
                [encode(li.get_view()) for li in self.list_items])
662800
public function viewAction()
    {
        $stack = $this->_initStackInstance();
        if (!$stack) {
            $this->_redirect('*/*/');
            return;
        }
        $this->_initAction();
        $this->renderLayout();
    }
1181918
function handleRefresh (refresh, e) {
  refresh.node.style.height = refresh.clamp + 'px'
  refresh.dispatchEvent('refresh')
  refresh.isRefreshing = true
}
1230922
function executeNext() {
	// Get the next data update.
	const dataNew = executeQueue[0];

	// Merge new data into current data.
	for (let key in dataNew) {
		data[key] = dataNew[key];
	}

	// Begin executing the view.
	const viewNew = viewCurrent(data);

	setViewNew(viewNew);
	executeView([viewNew], [null], [0]);
}
935785
function onLinksDone(loaded) {
                                if (loaded === 2) {
                                    if (hasLayoutChanged) {
                                        $target.find('[lazo-cmp-name]').remove();
                                        $target.append(html);
                                    } else {
                                        $target.html(html);
                                    }
                                    setTimeout(function () {
                                        LAZO.error.clear();
                                        $target.css({ 'visibility': 'visible'} );
                                        viewManager.attachViews(ctl, function (err, success) {
                                            if (err) {
                                                LAZO.logger.error('[LAZO.navigate] Error attaching views', err);
                                            }

                                            doc.updatePageTags(LAZO.ctl.ctx, function (err) {
                                                if (err) {
                                                    LAZO.logger.error('[LAZO.navigate] Error updating page tags', err);
                                                }

                                                doc.setTitle(LAZO.ctl.ctx._rootCtx.pageTitle);
                                                LAZO.app.trigger('navigate:application:complete', eventData);
                                            });
                                        });
                                    }, 0);
                                }
                            }
549185
protected void doHandleAjaxRefresh() {
		final Action action = getRefreshAction();
		if (action == null) {
			return;
		}

		final ActionEvent event = new ActionEvent(this, AJAX_REFRESH_ACTION_COMMAND, getAjaxFilter());
		Runnable later = new Runnable() {
			@Override
			public void run() {
				action.execute(event);
			}
		};

		invokeLater(later);
	}
79651
private void setRefreshEnabled(final boolean refreshEnabled) {
        this.isRefreshEnabled = refreshEnabled;
        view.setEnabled(refreshEnabled);
        refreshTime.setEnabled(refreshEnabled);
        refreshAlways.setEnabled(refreshEnabled);
    }
41469
function(views) {
    // Clear out all existing views.
    _.each(aConcat.call([], views), function(view) {
      // fire cleanup event to the attached handlers
      view.trigger("cleanup", view);

      // Remove all custom events attached to this View.
      view.unbind();

      // Automatically unbind `model`.
      if (view.model instanceof Backbone.Model) {
        view.model.off(null, null, view);
      }

      // Automatically unbind `collection`.
      if (view.collection instanceof Backbone.Collection) {
        view.collection.off(null, null, view);
      }

      // Automatically unbind events bound to this View.
      view.stopListening();

      // If a custom cleanup method was provided on the view, call it after
      // the initial cleanup is done
      if (_.isFunction(view.cleanup)) {
        view.cleanup();
      }
    });
  }
144193
function(view) {
        if (view._root._morph && !view._elementInserted) {
          throw new EmberError("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.");
        }
        // TODO: should be scheduled with renderer
        run.scheduleOnce('render', function () {
          if (view.isDestroying) return;
          view._renderer.renderTree(view, view._parentView);
        });
      }
133869
function()
	{
		var view = this;
		while(view.parentView)
		{
			view = view.parentView;
		}

		if(view.dispatcher !== null)
		{
			view.dispatcher.trigger({ type: 'refresh' });
			this._pendingRefreshRoot = false;
		}
	}
404078
function onActivateEvent() {
         var _updateLayerFn = this.updateLayer.bind(this); // register to the viewport change notification


         this.vpChangeHdlr = me.event.subscribe(me.event.VIEWPORT_ONCHANGE, _updateLayerFn);
         this.vpResizeHdlr = me.event.subscribe(me.event.VIEWPORT_ONRESIZE, this.resize.bind(this));
         this.vpLoadedHdlr = me.event.subscribe(me.event.LEVEL_LOADED, function () {
           // force a first refresh when the level is loaded
           _updateLayerFn(me.game.viewport.pos);
         }); // in case the level is not added to the root container,
         // the onActivateEvent call happens after the LEVEL_LOADED event
         // so we need to force a first update

         if (this.ancestor.root !== true) {
           this.updateLayer(me.game.viewport.pos);
         }
       }
1221174
function () {
            this.$Element.initWidget.call(this);
            this.setOptions();

            var newIndex = this.getSelectedIndexFromBindings();
            if (newIndex != null) {
                this._domElt.selectedIndex = newIndex;
            }
            this.initDisabledWidgetAttribute();

            this.__updateDataModel();
        }
1062842
@Override
    public void refreshView()
    {
        boxTree.setModel(new BoxTreeModel(proc.getPage().getRoot()));
        if (proc.getAreaTree() != null)
        {
            TreePath path = areaJTree.getSelectionPath();
            areaJTree.setModel(new AreaTreeModel(proc.getAreaTree().getRoot()));
            if (path != null)
                areaJTree.setSelectionPath(path);
        }
        if (proc.getLogicalAreaTree() != null)
        {
            TreePath path = logicalTree.getSelectionPath();
            logicalTree.setModel(new LogicalTreeModel(proc.getLogicalAreaTree().getRoot()));
            if (path != null)
                logicalTree.setSelectionPath(path);
        }
    }