This view needs to be refreshed. If it has a container - then it can refresh itself independently,
but views without container must ask their parents to refresh them
766610
function() {

		if (this._is_inDOM) {

			if (this._container) {

				this._is_dirty = true;

				if (!this._is_queued_for_refresh) {

					Lava.view_manager.scheduleViewRefresh(this);
					this._is_queued_for_refresh = true;

				}

			} else if (this._parent_with_container) {

				this._parent_with_container.trySetDirty();

			}

		}

	}
603378
function () {
        var self = this;

        // Render any new items
        self.items().each(function (ctrl, index) {
          var containerElm;

          ctrl.parent(self);

          if (!ctrl.state.get('rendered')) {
            containerElm = self.getEl('body');

            // Insert or append the item
            if (containerElm.hasChildNodes() && index <= containerElm.childNodes.length - 1) {
              $(containerElm.childNodes[index]).before(ctrl.renderHtml());
            } else {
              $(containerElm).append(ctrl.renderHtml());
            }

            ctrl.postRender();
            ReflowQueue.add(ctrl);
          }
        });

        self._layout.applyClasses(self.items().filter(':visible'));
        self._lastRect = null;

        return self;
      }
956950
function() {

			var self = this;

			self.__refreshActive = false;
			if (self.__refreshDeactivate) {
				self.__refreshDeactivate();
			}

			self.scrollTo(self.__scrollLeft, self.__scrollTop, true);

		}
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);
        });
      }
1364132
function(options, parent) {
            View.__super__.initialize.call(this, options);
            this._ensureElement();
            this.delegateEvents();

            // Rendering queue
            this.renderQueue = new Queue();

            // Components map
            this.components = {};

            // parent view
            this.parent = parent || this;

            // Model
            this.model = this.options.model || null;

            // View state
            this.is_ready = false;

            // Counter for number of active components
            this.countComponents = 0;
            return this;
        }
393150
private void refreshLeftTopHeaderViewHolder(ViewHolder holder) {
        int left = calculateRowHeadersLeft();
        if (isRTL())
            left += mSettings.getCellMargin();

        int top = mSettings.isHeaderFixed() ? 0 : -mState.getScrollY();
        View view = holder.getItemView();

        int leftMargin = isRTL() ? 0 : mSettings.getCellMargin();
        int topMargin = mSettings.getCellMargin();

        view.layout(left + leftMargin,
                top + topMargin,
                left + mManager.getHeaderRowWidth() + leftMargin,
                top + mManager.getHeaderColumnHeight() + topMargin);
    }
250037
private void refresh() {
        if (this.previewedThread != null) {
            if (this.previewedThread.isComplete()) {
                setLatestPreview();
                disableRefresh();
            } else {
                this.previewedThread.getPreview(ALPreviewPanel.this);
            }
        }
    }
238605
function () {
        if (__autoresizes == null && layout._listeners && layout._listeners['viewportResized']) {
            __init();
        } else if (__autoresizes != null && __autoresizes.length === 0
                && (layout._listeners == null || layout._listeners['viewportResized'] == null)) {
            __reset();
        }
    }
79651
private void setRefreshEnabled(final boolean refreshEnabled) {
        this.isRefreshEnabled = refreshEnabled;
        view.setEnabled(refreshEnabled);
        refreshTime.setEnabled(refreshEnabled);
        refreshAlways.setEnabled(refreshEnabled);
    }
1279487
private void refreshMargin() {
        if (isWeakReferenceValid()) {
            ViewGroup.MarginLayoutParams layoutParams = (ViewGroup.MarginLayoutParams) getTextView().get().getLayoutParams();
            layoutParams.bottomMargin = mEdgeMarginInPx;
            layoutParams.topMargin = mEdgeMarginInPx;
            layoutParams.rightMargin = mEdgeMarginInPx;
            layoutParams.leftMargin = mEdgeMarginInPx;
            getTextView().get().setLayoutParams(layoutParams);
        }
    }
104736
function(refresh_id) {

		if (Lava.schema.DEBUG && !this._container) Lava.t("Refresh on a view without container");

		this._is_queued_for_refresh = false;

		if (this._is_inDOM && this._is_dirty) {

			if (this._last_refresh_id == refresh_id) {

				this._refresh_cycle_count++;
				if (this._refresh_cycle_count > Lava.schema.system.REFRESH_INFINITE_LOOP_THRESHOLD) {

					// schedule this view for refresh in the next refresh loop
					Lava.view_manager.scheduleViewRefresh(this);
					this._is_queued_for_refresh = true;
					// when refresh returns true - it means an infinite loop exception,
					// it stops current refresh loop.
					return true;

				}

			} else {

				this._last_refresh_id = refresh_id;
				this._refresh_cycle_count = 0;

			}

			this._refresh();
			this._is_dirty = false;

		}

		return false;

	}
818655
public function doBefore() {
        if(count($this->_controller->getViews()) == 0) {
            $l = FLayout::create('main_layout.php', $this->_app);
            $this->_controller->setLayout($l);
        }
    }
77501
function(name) {

		var view = this;

		while (view && !view.isset(name)) {

			view = view.getParentView();

		}

		return view;

	}
962521
private boolean updateAnchorFromChildren(RecyclerView.State state, AnchorInfo anchorInfo) {
        if (getChildCount() == 0) {
            return false;
        }
        final View focused = getFocusedChild();
        if (focused != null && anchorInfo.isViewValidAsAnchor(focused, state)) {
            anchorInfo.assignFromViewAndKeepVisibleRect(focused);
            return true;
        }
        /*
        if (mLastStackFromEnd != mStackFromEnd) {
            return false;
        }
        */
        View referenceChild = anchorInfo.mLayoutFromEnd ? findReferenceChildClosestToEnd(state)
                : findReferenceChildClosestToStart(state);
        if (referenceChild != null) {
            anchorInfo.assignFromView(referenceChild);
            // If all visible views are removed in 1 pass, reference child might be out of bounds.
            // If that is the case, offset it back to 0 so that we use these pre-layout children.
            if (!state.isPreLayout() && supportsPredictiveItemAnimations()) {
                // validate this child is at least partially visible. if not, offset it to start
                final boolean notVisible =
                        mOrientationHelper.getDecoratedStart(referenceChild) >= mOrientationHelper
                                .getEndAfterPadding()
                                || mOrientationHelper.getDecoratedEnd(referenceChild)
                                < mOrientationHelper.getStartAfterPadding();
                if (notVisible) {
                    anchorInfo.mCoordinate = anchorInfo.mLayoutFromEnd
                            ? mOrientationHelper.getEndAfterPadding()
                            : mOrientationHelper.getStartAfterPadding();
                }
            }
            return true;
        }
        return false;
    }
536840
@Override
    public void refreshContainer() {
        final Indexed container = getContainerDataSource();
        if (hasGeneratedPropertySupport()
                && getGeneratedPropertySupport().getRawContainer() instanceof LazyQueryContainer) {
            ((LazyQueryContainer) getGeneratedPropertySupport().getRawContainer()).refresh();
            return;
        }

        if (container instanceof LazyQueryContainer) {
            ((LazyQueryContainer) container).refresh();
        }
    }
733473
public void clearViewCached(int parentId, int viewId) {
        SparseArray<View> sparseArrayViewsParent = mSparseSparseArrayView.get(parentId);
        if (sparseArrayViewsParent != null) {
            sparseArrayViewsParent.remove(viewId);
        }
    }
221272
function() {
      _.each(cdb.core.View.views, function(view) {
        _.each(view, function(prop, k) {
          if( k !== '_parent' &&
              view.hasOwnProperty(k) &&
              prop instanceof cdb.core.View &&
              view._subviews[prop.cid] === undefined) {
            console.log("=========");
            console.log("untracked view: ");
            console.log(prop.el);
            console.log('parent');
            console.log(view.el);
            console.log(" ");
          }
        });
      });
    }