Constructor for IE environment

@param {Lava.view.Abstract} view
@param {_cElementContainer} config
@param {Lava.widget.Standard} widget
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();
			}
		};

	}
1350121
function () {
            this.$Container.initWidget.apply(this, arguments);
            var getChild = ariaUtilsDom.getDomElementChild;
            var parentContainer = getChild(getChild(this.getDom(), 0), 0);
            this._splitPanel1 = getChild(parentContainer, 0);
            this._splitBar = getChild(parentContainer, 1);
            this._splitBarProxy = getChild(parentContainer, 2);
            this._splitPanel2 = getChild(parentContainer, 3);

            this._splitBarProxyClass = new ariaUtilsClassList(this._splitBarProxy);
            var handleBarElem = "splitBarProxy_" + this._domId;
            var cursor = this._orientation ? "n-resize" : "e-resize";
            this._draggable = new ariaUtilsDragdropDrag(handleBarElem, {
                handle : handleBarElem,
                cursor : cursor,
                proxy : null,
                constrainTo : parentContainer
            });

            this._draggable.$on({
                "dragstart" : {
                    fn : this._onDragStart,
                    scope : this
                },

                "dragend" : {
                    fn : this._onDragEnd,
                    scope : this
                }
            });

        }
704343
function(options) {
    _.extend(LayoutManager.prototype, options);

    // Allow LayoutManager to manage Backbone.View.prototype.
    if (options.manage) {
      Backbone.View.prototype.manage = true;
    }

    // Disable the element globally.
    if (options.el === false) {
      Backbone.View.prototype.el = false;
    }

    // Allow global configuration of `suppressWarnings`.
    if (options.suppressWarnings === true) {
      Backbone.View.prototype.suppressWarnings = true;
    }

    // Allow global configuration of `useRAF`.
    if (options.useRAF === false) {
      Backbone.View.prototype.useRAF = false;
    }

    // Allow underscore to be swapped out
    if (options._) {
      _ = options._;
    }
  }
939614
function HttpViewContext(context) {
    /**
     * Gets or sets the body of the current view
     * @type {String}
     */
    this.body='';
    /**
     * Gets or sets the title of the page if the view will be fully rendered
     * @type {String}
     */
    this.title='';
    /**
     * Gets or sets the view layout page if the view will be fully rendered
     * @type {String}
     */
    this.layout = null;
    /**
     * Gets or sets the view data
     * @type {String}
     */
    this.data = null;
    /**
     * Represents the current HTTP context
     * @type {HttpContext}
     */
    this.context = context;

    /**
     * @name HttpViewContext#writer
     * @type HtmlWriter
     * @description Gets an instance of HtmlWriter helper class
     */
    var writer;
    Object.defineProperty(this, 'writer', {
        get:function() {
            if (writer)
                return writer;
            writer = new HtmlWriter();
            writer.indent = false;
            return writer;
        }, configurable:false, enumerable:false
    });

    var self = this;
    Object.defineProperty(this, 'model', {
        get:function() {
            if (self.context.params)
                if (self.context.params.controller)
                    return self.context.model(self.context.params.controller);
            return null;
        }, configurable:false, enumerable:false
    });

    //class extension initiators
    if (typeof this.init === 'function') {
        //call init() method
        this.init();
    }
}
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');
		});
		
	}
774595
function (out) {
            var errorMessage;
            if (this._WidgetCfg.formatError) {// framework errors
                errorMessage = this._WidgetCfg.formatErrorMessages;
            } else if (this._WidgetCfg.error) {// template errors
                errorMessage = this._WidgetCfg.errorMessages;
            }

            var div = new ariaWidgetsContainerDiv({
                sclass : "errortip",
                width : 289,
                margins : "0 0 0 0"
            }, this._context);

            var msg = this._checkErrorMessage(errorMessage);
            if (this._WidgetCfg.waiAria) {
                div.addExtraAttributes('aria-hidden="true"');
                this._widget.waiReadText(msg, {
                    alert: true
                });
            }

            out.registerBehavior(div);
            div.writeMarkupBegin(out);
            out.write(msg);
            div.writeMarkupEnd(out);


            this._div = div;
        }
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})
    }
}
371057
private void buildUI() {
		add(messages);
		add(tabset);
		// add(new AccessibilityWarningContainer());

		container.add(new WText("Select an example from the menu"));
		// Set a static ID on container and it becomes a de-facto naming context.
		container.setIdName("eg");
		tabset.addTab(container, "(no selection)", WTabSet.TAB_MODE_CLIENT);

		WImage srcImage = new WImage(new ImageResource("/image/text-x-source.png", "View Source"));
		srcImage.setCacheKey("srcTabImage");
		tabset.addTab(source, new WDecoratedLabel(srcImage), WTabSet.TAB_MODE_LAZY).setToolTip("View Source");

		// The refresh current view button.
		WButton refreshButton = new WButton("\u200b");
		refreshButton.setToolTip("Refresh");
		refreshButton.setHtmlClass(HtmlIconUtil.getIconClasses("fa-refresh"));
		//refreshButton.setImage("/image/refresh-w.png");
		refreshButton.setRenderAsLink(true);
		refreshButton.setAction(new ValidatingAction(messages.getValidationErrors(), refreshButton) {
			@Override
			public void executeOnValid(final ActionEvent event) {
				// Do Nothing
			}
		});

		// The reset example button.
		final WButton resetButton = new WButton("\u200b");
		resetButton.setToolTip("Reset");
		resetButton.setHtmlClass(HtmlIconUtil.getIconClasses("fa-times-circle"));
		//resetButton.setImage("/image/cancel-w.png");
		resetButton.setRenderAsLink(true);
		resetButton.setAction(new ValidatingAction(messages.getValidationErrors(), resetButton) {
			@Override
			public void executeOnValid(final ActionEvent event) {
				resetExample();
			}
		});

		addToTail(refreshButton);
		addToTail(new WText("\u2002"));
		addToTail(resetButton);
	}
1267955
function(starting_widget, guid) {

		if (Lava.schema.DEBUG && !guid) Lava.t();

		return this._views_by_guid[guid];

	}
749746
function(config) {

      var x, style;

      // save config
      hashedit.config = config;

      // set path
      if (config.path != null) {
        hashedit.path = config.path;
      }

      // set login
      if (config.login != null) {
        hashedit.loginUrl = config.login;
      }

      // set grid
      if (config.grid != null) {
        hashedit.grid = config.grid;
      }

      // create container
      hashedit.current.container = document.createElement('div');
      hashedit.current.container.setAttribute('class', 'hashedit-container');
      hashedit.current.container.setAttribute('id', 'hashedit-container');

      // set stylesheet
      if (config.stylesheet !== null) {
        hashedit.stylesheet = config.stylesheet;
      }

      // set url
      if (config.url !== null) {
        hashedit.url = config.url;
      }

      // append container to body
      document.body.appendChild(hashedit.current.container);

      // create style
      style = document.createElement('style');

      // append scoped stylesheet to container
      for (x = 0; x < hashedit.stylesheet.length; x++) {
        style.innerHTML += '@import url(' + hashedit.stylesheet[x] + ');';
      }

      hashedit.current.container.appendChild(style);

      // check auth
      if (config.demo === true) {

        hashedit.demo = true;

        // init hashedit
        hashedit.setActive();
        hashedit.setupView();
        hashedit.setupSortable();
        hashedit.setupBlocks();
        hashedit.setContentEditable();
        hashedit.setupContentEditableEvents();
        hashedit.setupMenu(config.path);
        hashedit.setupToast();
        hashedit.createMenu(config.path);
        hashedit.loadHTML(config.path);
        hashedit.translate();

      }
      else {

        // set default auth
        var obj = {
          credentials: 'include'
        }

        // enable token based auth
        if(hashedit.useToken) {

          // set obj headers
          obj = {
            headers: {}
          };

          obj.headers[hashedit.authHeader] = hashedit.authHeaderPrefix + ' ' + localStorage.getItem(hashedit.tokenName);
        }

        // check auth
        fetch(hashedit.authUrl, obj)
          .then(function(response) {

            if (response.status !== 200) {
              hashedit.showAuth();
            }
            else {

              // init hashedit
              hashedit.setActive();
              hashedit.setupView();
              hashedit.setupSortable();
              hashedit.setupBlocks();
              hashedit.setContentEditable();
              hashedit.setupContentEditableEvents();
              hashedit.setupMenu(config.path);
              hashedit.setupToast();
              hashedit.createMenu(config.path);
              hashedit.loadHTML(config.path);
              hashedit.translate();

              // setup loaded event
              var event = new Event('hashedit.loaded');
              document.dispatchEvent(event);

            }

          });
      }

    }
554294
function(appConfig, appContent) {
		// instantiate F2.UI
		appConfig.ui = new F2.UI(appConfig);

		// instantiate F2.App
		if (F2.Apps[appConfig.appId] !== undefined) {
			if (typeof F2.Apps[appConfig.appId] === 'function') {

				// IE
				setTimeout(function() {
					_apps[appConfig.instanceId].app = new F2.Apps[appConfig.appId](appConfig, appContent, appConfig.root);
					if (_apps[appConfig.instanceId].app['init'] !== undefined) {
						_apps[appConfig.instanceId].app.init();
					}
				}, 0);

			}
			else {
				F2.log('app initialization class is defined but not a function. (' + appConfig.appId + ')');
			}
		}
	}
275375
function (config) {
			if (config) {
				if (config.element) {
					this.expect.element(config.element).to.be.present;
				} else {
					throw new Error('adminUIApp:must specify an element!');
				}
			} else {
				throw new Error('adminUIApp:invalid config specification!');
			}
			return this;
		}
476946
function (conf) {

            this.conf = conf;

            if (conf.waiAria == null) {
                conf.waiAria = environment.isWaiAria();
            }

            ariaCoreJsonValidator.normalize({
                json : conf,
                beanName : "aria.popups.Beans.PopupConf"
            });

            if (this.modalMaskDomElement) {
                ariaUtilsDom.removeElement(this.modalMaskDomElement);
                this.modalMaskDomElement = null;
            }
            this.popupContainer = (conf.popupContainer || ViewportPopupContainer).$interface("aria.popups.container.IPopupContainer");
            if (conf.modal) {
                this.modalMaskDomElement = this._createMaskDomElement(conf.maskCssClass);
            }
            if (this.domElement != null) {
                ariaUtilsDom.removeElement(this.domElement);
            }
            this.domElement = this._createDomElement();

            this.setPreferredPositions(conf.preferredPositions);
            this.setSection(conf.section);

            if (!conf.center) {
                if (!conf.absolutePosition || conf.domReference) {
                    this.setReference(conf.domReference);
                } else {
                    this.setPositionAsReference(conf.absolutePosition);
                }
            } else {
                this.setPositionAsReference(this._getPosition(this._getFreeSize()));
            }

            this._ignoreClicksOn = conf.ignoreClicksOn;

            this._parentDialog = conf.parentDialog;

        }
2302
function(config){
        
        if(isString(config)){
            this.config.appBase = config;
        }else if(isObject(config)){// If the config object is provided
            this.config = Object.assign(this.config, config);
        }

        // If the app base isn't provided
        if(!this.config.appBase){
            this.config.appBase = utils.getAppLocalPath();
        }else if(this.config.appBase.length && this.config.appBase[this.config.appBase.length-1] !== '/'){
            this.config.appBase += '/';
        }

        // If the layouts list was passed in the config
        if(this.config.layouts && isObject(this.config.layouts)){
            Object.keys(this.config.layouts).forEach(key => {
                layouts.add(key, this.config.layouts[key]);
            });
        }

        // If the dev mode is on
        if(this.config.devMode === true){
            // Attach some shortcuts
            Application.on('ready', function(){

                // Ctrl+F12 to toggle the dev tools
                Shortcuts.register('CmdOrCtrl+F12', function(){
                    const window = windowManager.getCurrent();
                    if(window) window.toggleDevTools();
                });

                // Ctrl+R to reload the page
                Shortcuts.register('CmdOrCtrl+R', function(){
                    const window = windowManager.getCurrent();
                    if(window) window.reload();
                });

            });
        }

        // If a default setup is provided
        if(this.config.defaultSetup){
            this.setDefaultSetup(this.config.defaultSetup);
            delete this.config.defaultSetup;
        }
    }
257637
function (View, name, eventsObj) { //eslint-disable-line no-shadow
            console.assert(View.prototype instanceof Backbone.BaseView, 'View must a Backbone.BaseView constructor');
            _addEvents(View.prototype, name, eventsObj);
        }
1289025
function (view, engine = 'html') {
	return async function DefaultView (ctx, next) {
		await ctx.render(`${view}.${engine}`);
	};
}
1010224
function(path_config) {

		var widget = this._widget.locateViewByPathConfig(path_config);
		if (Lava.schema.DEBUG && !widget.isWidget) Lava.t("Tried to call a modifier from non-widget view");

		return /** @type {Lava.widget.Standard} */ widget;

	}