================= View constructor =================
765215
function View(context, type, parentView, data, template, key, onRender) {
		// Constructor for view object in view hierarchy. (Augmented by JsViews if JsViews is loaded)
		var views, parentView_,
			isArray = type === "array",
			self_ = {
				key: 0,
				useKey: isArray ? 0 : 1,
				id: "" + viewId++,
				onRender: onRender,
				bnd: {}
			},
			self = {
				data: data,
				tmpl: template,
				views: isArray ? [] : {},
				parent: parentView,
				ctx: context,
				type: type,
				// If the data is an array, this is an 'array view' with a views array for each child 'item view'
				// If the data is not an array, this is an 'item view' with a views 'map' object for any child nested views
				// ._.useKey is non zero if is not an 'array view' (owning a data array). Uuse this as next key for adding to child views map
				get: getView,
				getIndex: getIndex,
				getRsc: getResource,
				hlp: getHelper,
				_: self_
		};

		if (parentView) {
			views = parentView.views;
			parentView_ = parentView._;
			if (parentView_.useKey) {
				// Parent is an 'item view'. Add this view to its views object
				// self._key = is the key in the parent view map
				views[self_.key = "_" + parentView_.useKey++] = self;
			} else {
				// Parent is an 'array view'. Add this view to its views array
				views.splice(
					// self._.key = self.index - the index in the parent view array
					self_.key = self.index =
						key !== undefined
							? key
							: views.length,
				0, self);
			}
			// If no context was passed in, use parent context
			// If context was passed in, it should have been merged already with parent context
			self.ctx = context || parentView.ctx;
		}
		return self;
	}
971522
function(view) {
    if (view.options.layoutApplied) {
      return view;
    }

    // handle pre-layout middleware
    this.handle('preLayout', view);

    var opts = {};
    lazy.extend(opts, this.options);
    lazy.extend(opts, view.options);
    lazy.extend(opts, view.context());

    // get the layout stack
    var stack = {};
    var alias = this.viewTypes.layout;
    var len = alias.length, i = 0;

    while (len--) {
      var views = this.views[alias[i++]];
      for (var key in views) {
        var val = views[key];
        if (views.hasOwnProperty(key) && typeof val !== 'function' && val.path) {
          stack[key] = val;
        }
      }
    }

    // get the name of the first layout
    var name = view.layout;
    var str = view.content;
    var self = this;

    if (!name) return view;

    // Handle each layout before it's applied to a view
    function handleLayout(layoutObj) {
      view.currentLayout = layoutObj.layout;
      self.handle('onLayout', view);
      delete view.currentLayout;
    }

    // actually apply the layout
    var res = lazy.layouts(str, name, stack, opts, handleLayout);

    view.option('layoutStack', res.history);
    view.option('layoutApplied', true);
    view.content = res.result;

    // handle post-layout middleware
    this.handle('postLayout', view);
    return view;
  }
202640
protected function _initView ()
    {
        // Create default view model, to be used in all templates and layouts
        $this->appView  = new \Zend\View\Model\ViewModel();

        // Convenience access variables
        $this->_appView = $this->appView;
        $this->view     = $this->appView;
        $this->_view    = $this->appView;
    }
893086
function(element) {
    if (!element.bindings) {
      element.bindings = compile(this, element);
      View.makeInstanceOf(element);
    }

    return element;
  }
376651
function(view, config, widget) {

		this._view = view;
		//this._config = config;
		this._widget = widget;

		this._start_script_id = 'c' + view.guid + 's';
		this._end_script_id = 'c' + view.guid + 'e';

	}
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(" ");
          }
        });
      });
    }
628439
private void initView(){
        LinearLayout mProgressContainer = (LinearLayout) mLayout.findViewById(R.id.progress_container);

        int padding = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 16, mLayout.getResources().getDisplayMetrics());
        mLayout.setPadding(padding, padding, padding, padding);

        // Based on configuration from Builder, construct the Layout
        switch (mProgressStyle){
            case HORIZONTAL:
                mProgress = new ProgressBar(mCtx, null, android.R.attr.progressBarStyleHorizontal);
                break;
            case SMALL:
                mIsIndeterminate = true;
                mProgressText.setVisibility(View.GONE);
                mProgressMax.setVisibility(View.GONE);
                mProgress = new ProgressBar(mCtx, null, android.R.attr.progressBarStyleSmall);
                break;
            case NORMAL:
                mIsIndeterminate = true;
                mProgressText.setVisibility(View.GONE);
                mProgressMax.setVisibility(View.GONE);
                mProgress = new ProgressBar(mCtx);
                break;
            case LARGE:
                mIsIndeterminate = true;
                mProgressText.setVisibility(View.GONE);
                mProgressMax.setVisibility(View.GONE);
                mProgress = new ProgressBar(mCtx, null, android.R.attr.progressBarStyleLarge);
                break;
        }

        // The ProgressBar parameters
        LinearLayout.LayoutParams progressParams;

        // Generate the message parameters
        int margin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 16, mCtx.getResources().getDisplayMetrics());
        LinearLayout.LayoutParams messageParams = new LinearLayout.LayoutParams(0, ViewGroup.LayoutParams.WRAP_CONTENT);
        messageParams.weight = 1f;
        messageParams.gravity = Gravity.CENTER_VERTICAL;
        messageParams.setMargins(margin, 0, margin, 0);

        // Now based on the provided message content, change up hte LayoutParameters of the progresses
        if(mProgressStyle == HORIZONTAL){
            progressParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        }else{
            if(mMessage != null){
                progressParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
            }else{
                progressParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
            }
        }

        Log.d("ProgressStyle", "Setting ProgressBar LayoutParams(" + progressParams.width + "," + progressParams.height + ")");

        // Add the stylized progress bar to the layout
        mProgress.setLayoutParams(progressParams);
        mProgressContainer.addView(mProgress);

        // If the message isn't null, and it's not the progress style
        if(mMessage != null && mProgressStyle != HORIZONTAL){

            // Create and add the text view
            TextView message = new TextView(mCtx);
            message.setId(R.id.progress_mesage);
            FontLoader.applyTypeface(message, Types.ROBOTO_REGULAR);
            message.setText(mMessage);

            // Add this to the layout
            mProgressContainer.addView(message, messageParams);
        }

        // Now based on other attributes style the progressBar
        if(mProgressStyle == HORIZONTAL) {
            if (mIsIndeterminate) {
                Log.d(ProgressStyle.class.getName(), "Setting Indeterminate for Horizontal ProgressStyle");

                // Update the ProgressBar
                mProgress.setIndeterminate(true);

                // Hide the auxillary text
                mProgressText.setVisibility(View.GONE);
                mProgressMax.setVisibility(View.GONE);

            } else {
                Log.d(ProgressStyle.class.getName(), "Setting Progress for Horizontal ProgressStyle");

                // Only if the progress style is horizontal, should
                // we attempt to set the progress and max
                mProgress.setIndeterminate(false);
                setProgress(mInitProgress);
                setMax(mInitMax);

            }
        }
    }
793862
function DOMViewControllerMixin(view) {

  var _this = this;

  function attachEvents() {

    // Events can be an object or a function that returns an object
    var events;
    if (isFunction(view.events)) {
      events = view.events();
    } else {
      events = view.events || {};
    }

    for (var key in events) {
      if (events.hasOwnProperty(key)) {
        var fn;

        (function () {
          var firstSpaceIndex = key.indexOf(' ');
          var type = undefined;
          var selector = undefined;
          // Event on root element
          if (firstSpaceIndex === -1) {
            type = key;
          } else {
            type = key.substr(0, firstSpaceIndex);
            selector = key.substr(firstSpaceIndex + 1);
          }
          fn = events[key];

          (function (fn) {
            // Use 'on' instead of the elem[type] so that the handlers
            // stay bound if the view is updated with new elements
            view.$el.on(type, selector, function (event) {
              if (_this[fn] === undefined) {
                throw new Error('mixin target has no function: ' + fn);
              }
              _this[fn](event, view);
            });
          })(fn);
        })();
      }
    }
  }

  attachEvents();
}
603492
function VView(view, data, key, opts) {
	this.view = view;
	this.data = data;
	this.key = key;
	this.opts = opts;
}
1059913
function(config) {
		
		var cfg = config;
		var self = this;
		var viewList = this.list();
		
		$(viewList).each(function(i, view) {
			
			if (!view.isInit) {
				
				if (view.dom !== 'undefined' && view.dom.main !== 'undefined') {
					
					if (i === 0 && self.cmp().placeholder()) {
						self.cmp().placeholder().replaceWith( view.dom.main );
					}
					
					if (i > 0) {
						viewList[ i - 1 ].dom.main.after( view.dom.main );
					}
					
				}
				
				view.isInit = true;
				
			}
			
		}).promise().done(function() {
			self.cmp().trigger('view.ready');
		});
		
	}
1003627
public function init()
    {
        // set name and id of view
        if (!$this->name) {
            if (!$this->id) {
                $this->id = $this->name = 'atk';
            } else {
                $this->name = $this->id;
            }
        } elseif (!$this->id) {
            $this->id = $this->name;
        }

        // initialize
        $this->_init();

        if (!$this->app) {
            $this->initDefaultApp();
        }

        if ($this->region && !$this->template && !$this->defaultTemplate && $this->owner && $this->owner->template) {
            $this->template = $this->owner->template->cloneRegion($this->region);

            $this->owner->template->del($this->region);
        } else {
            // set up template
            if (is_string($this->defaultTemplate) && is_null($this->template)) {
                $this->template = $this->app->loadTemplate($this->defaultTemplate);
            }

            if (!$this->region) {
                $this->region = 'Content';
            }
        }

        if ($this->template && !isset($this->template->app) && isset($this->app)) {
            $this->template->app = $this->app;
        }

        // add default objects
        foreach ($this->_add_later as list($object, $region)) {
            $this->add($object, $region);
        }

        $this->_add_later = [];
    }
551977
function View(view, options) {
  this.history = [];
  Item.call(this, view, options);
  this.init(view);
  return view;
}
411231
function(view)
	{
		if (arguments.length > 1)
		{
			conbo.forEach(arguments, function(view, index, list) 
			{
				this.appendView(view);
			},
			this);
			
			return this;
		}
	
		if (typeof view === 'function')
		{
			view = new view(this.context);
		}

		if (!(view instanceof conbo.View))
		{
			throw new Error('Parameter must be conbo.View class or instance of it');
		}
	
		this.body.appendChild(view.el);
		
		return this;
	}
1289025
function (view, engine = 'html') {
	return async function DefaultView (ctx, next) {
		await ctx.render(`${view}.${engine}`);
	};
}
324261
function (options) {
    options = options || {};

    this._firstRender = true;
    this._initializeRegions(options);
    
    Marionette.ItemView.prototype.constructor.call(this, options);
  }
266081
function observer(name, view) {
	// If no name provided for the observer:
	if (view === undefined) {
		view = name;

		// Generate friendly name for debugging (See: https://github.com/infernojs/inferno/blob/master/packages/inferno-mobx/src/observer.ts#L105)
		name = view.displayName || view.name || (view.constructor && (view.constructor.displayName || view.constructor.name)) || '<View>';
	}

	// The name for the MobX Reaction, for debugging:
	var reactionName = name + ".render()";


	// We need to hook into the init() of the vm, just after that init() is executed,
	// so that all the vm.config(...) have been executed on the vm.
	// This is a bit complex depending on the type of the view.
	// Refer to the ViewModel constructor for details:
	//	 https://github.com/domvm/domvm/blob/3.4.8/src/view/ViewModel.js#L48

	if (isPlainObj(view)) {
		// view is an object: just set our own init on it.
		wrapInit(view, reactionName);
	}
	else {
		// view is a function: we can't do anything before it is executed, so we wrap it
		// with a function that will set our own init later.
		view = (function(view) {
			return function(vm) {
				var out = view.apply(this, arguments);

				if (isFunc(out))
					wrapInit(vm, reactionName);
				else {
					// In case multiple executions of view() returns the same object,
					// we want to wrap init only once:
					wrapInitOnce(out, reactionName);
				}

				return out;
			};
		})(view);
	}

	return view;
}
388633
function(options) {
      if (this.options) options = _.extend({}, this.options, options);
      for (var i = 0, l = viewOptions.length; i < l; i++) {
        var attr = viewOptions[i];
        if (options[attr]) this[attr] = options[attr];
      }
      this.options = options;
    }