you got to bind view object to this function
@param {function} callback
481884
function kappInit(subject, callback) {

    //if expose option is added we expose this view
    console.log("kappInit:", subject)
    if (subject.getOption("expose_as")) {
        console.log("kappInit: found exposeAs option " + subject.getOption("expose_as"))
        subject.exposeAs(subject.getOption("expose_as"))

    }

    //as backbone has its owne method to bind a model and collections to views we just
    //avoid to merge it to the object atributes by this way
    omitBackboneOptsAsProps(subject, ['model', 'collection'])
    //giving the replaceable regions to the view
    if (typeof subject._addReplaceableRegions === "function") {
        subject._addReplaceableRegions();
    };

    if (typeof callback === "function") {
        callback()
    }


}
1296843
function() {
        removeElement(this.$(LOAD_MORE_SELECTOR));
        this.resultsContainer.innerHTML += this.selectivity.template('loading');

        this.options.query({
            callback: function(response) {
                if (response && response.results) {
                    this._showResults(Selectivity.processItems(response.results), {
                        add: true,
                        hasMore: !!response.more
                    });
                } else {
                    throw new Error('callback must be passed a response object');
                }
            }.bind(this),
            error: this._showResults.bind(this, [], { add: true }),
            offset: this.results.length,
            selectivity: this.selectivity,
            term: this.term
        });
    }
11280
function (fn) {
    if (!fn || !_.isFunction(fn)) {
      var err = new Error('Please pass a valid function!');
      debug(err);
      throw err;
    }

    if (fn.length === 2) {
      this.getQueryForThisViewBuilder = fn;
      return this;
    }

    this.getQueryForThisViewBuilder = function (evt, callback) {
      callback(null, fn(evt));
    };

    var unwrappedFn = this.getQueryForThisViewBuilder;

    this.getQueryForThisViewBuilder = function (evt, clb) {
      var wrappedCallback = function () {
        try {
          clb.apply(this, _.toArray(arguments));
        } catch (e) {
          debug(e);
          process.emit('uncaughtException', e);
        }
      };

      try {
        unwrappedFn.call(this, evt, wrappedCallback);
      } catch (e) {
        debug(e);
        process.emit('uncaughtException', e);
      }
    };

    return this;
  }
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;
	}
1088979
function bind( fn, scope ) {
    var bound, args;
    if ( fn.bind === nativeBind && nativeBind ) return nativeBind.apply( fn, Array.prototype.slice.call( arguments, 1 ) );
    args = Array.prototype.slice.call( arguments, 2 );
    // @todo: don't link this
    bound = function() {
        if ( !(this instanceof bound) ) return fn.apply( scope, args.concat( Array.prototype.slice.call( arguments ) ) );
        W.ctor.prototype = fn.prototype;
        var self = new ctor();
        var result = fn.apply( self, args.concat( Array.prototype.slice.call( arguments ) ) );
        if ( Object( result ) === result ) return result;
        return self;
    };
    return bound;
}
87832
function (view/*, locals, fn*/) {
    var args = [].slice.call(arguments, 1);
    var app = this.app;
    if (typeof view === 'string') view = this[view];

    app.render.apply(app, [view].concat(args));
    return this;
  }
353283
function (callback) {
      var _this = this;

      var guid = _emberMetalUtils.guidFor(this);

      _emberViewsSystemJquery.default(window).on('popstate.ember-location-' + guid, function (e) {
        // Ignore initial page load popstate event in Chrome
        if (!popstateFired) {
          popstateFired = true;
          if (_this.getURL() === _this._previousURL) {
            return;
          }
        }
        callback(_this.getURL());
      });
    }
477391
function(node, callback) {
    if (node.firstViewNode) node = node.firstViewNode;

    this.animateNode('out', node, callback);
  }
895689
function wrapInView(node) {
  if (!node) {
    return node;
  }
  if (typeof node === 'function') {
    // React.Children does not traverse functions.
    // All render callbacks must be protected under a <View>
    return createElement(View, {}, node);
  }
  if (Array.isArray(node)) {
    return node.map(wrapInView);
  }
  if (inheritsFrom(node.type, View)) {
    return node;
  }
  return node;
}
24861
function (customParams, callback) {
      [customParams, callback] = doArgs(arguments, [['object', {}], 'function']);

      doRequest({
        urlPattern: [VIEW_LIST],
        bodyProp: 'views'
      }, customParams, callback);
    }
301921
def bind(self, callback, sender=None):
        ''''''
        key = (_make_id(callback), _make_id(sender))
        self.callbacks.append((key, callback))
1058415
function bind(property, options, preserveContext, shouldDisplay, valueNormalizer, childProperties) {
      var data = options.data;
      var fn = options.fn;
      var inverse = options.inverse;
      var view = data.view;
      var normalized, observer, i;

      // we relied on the behavior of calling without
      // context to mean this === window, but when running
      // "use strict", it's possible for this to === undefined;
      var currentContext = this || window;

      normalized = normalizePath(currentContext, property, data);

      if (data.insideGroup) {
        observer = function() {
          while (view._contextView) {
            view = view._contextView;
          }
          run.once(view, 'rerender');
        };

        var template, context;
        var result = handlebarsGet(currentContext, property, options);

        result = valueNormalizer ? valueNormalizer(result) : result;

        context = preserveContext ? currentContext : result;
        if (shouldDisplay(result)) {
          template = fn;
        } else if (inverse) {
          template = inverse;
        }

        template(context, { data: options.data });
      } else {
        var viewClass = _HandlebarsBoundView;
        var viewOptions = {
          preserveContext: preserveContext,
          shouldDisplayFunc: shouldDisplay,
          valueNormalizerFunc: valueNormalizer,
          displayTemplate: fn,
          inverseTemplate: inverse,
          path: property,
          pathRoot: currentContext,
          previousContext: currentContext,
          isEscaped: !options.hash.unescaped,
          templateData: options.data,
          templateHash: options.hash,
          helperName: options.helperName
        };

        if (options.isWithHelper) {
          viewClass = WithView;
        }

        // Create the view that will wrap the output of this template/property
        // and add it to the nearest view's childViews array.
        // See the documentation of Ember._HandlebarsBoundView for more.
        var bindView = view.createChildView(viewClass, viewOptions);

        view.appendChild(bindView);

        observer = function() {
          run.scheduleOnce('render', bindView, 'rerenderIfNeeded');
        };
      }

      // Observes the given property on the context and
      // tells the Ember._HandlebarsBoundView to re-render. If property
      // is an empty string, we are printing the current context
      // object ({{this}}) so updating it is not our responsibility.
      if (typeof this === 'object' && normalized.path !== '') {
        view.registerObserver(normalized.root, normalized.path, observer);
        if (childProperties) {
          for (i=0; i<childProperties.length; i++) {
            view.registerObserver(normalized.root, normalized.path+'.'+childProperties[i], observer);
          }
        }
      }
    }
303283
function callback(fn, context, event) {
        //window.setTimeout(function(){
        event.target = context;
        (typeof context[fn] === "function") && context[fn].apply(context, [event]);
        //}, 1);
    }
313579
function bind (obj, method) {
    var fn = obj[method];
    obj[method] = function () {
      fn.apply(obj, arguments);
    };
  }
689968
function (rootNode, viewKey) {
            var views = this.getList('view', rootNode);
            var self = this;

            _.each(views, function (view) {
                view.remove();
            });

            return this;
        }
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();
			}
		};

	}
435725
public function onClickConsole($callback, $title = null)
    {
        if (is_null($title)) {
            $title = $this->template->get('Content');
        }

        $this->virtual_page = $this->add('VirtualPage', ['type' => 'frameURL']);
        /** @type VirtualPage $this->virtual_page */
        $this->virtual_page
            ->bindEvent($title)
            ->set(function ($p) use ($callback) {
                /** @type View_Console $console */
                $console = $p->add('View_Console');
                $console->set($callback);
            });
    }