In a previous article I explored ng-repeat, it’s implementation, and how to create a custom repeater. In this article I’ll first delve into the inner workings of ngView and then walk through the creation of an “ngMultiView” directive. To get the most out of this article you’ll need an intermediate understanding of creating directives (via the previous article on ng-repeat and reading the the AngularJS directive guide).
Starting with AngualrJS 1.2, the
ngView directive, and the
$route service were moved into a separate module called
ngRoute. As a result, to use routes and
ngView your app must explicitly declare it as a dependency. Furthermore, the syntax for the “otherwise” statement is slightly different from older versions of AngularJS. Below is a complete example of a tiny AngularJS 1.2 app with two routes and a default:
Undocumented features of ngView
In the process of understanding the code behind ngView I came across two undocumented attributes: “onload” and “autoscroll”. The onload attribute can take any Angular expression and will execute it every time the view changes. Autoscroll uses the $autoScroll service and scrolls to a specific element based on the current value of $location.hash(). Finally, near the very end of the directive, after
link(currentScope) is called the
'$viewContentLoaded' is emitted within the current scope - an event which you can use within your controller. Below is a revised version of the above example that includes the onload attribute.
How ngView Works?
In order to understand ngView, I think it’s useful to create a simplified version of it. Below is ngViewLite, a version of ngView that does not include scope cleanup or animations, but is otherwise identical to ngView.
First, we bind a function
update to the
$routeChangeSuccess; when the route changes, update will be called. Right after attaching the function to the event we immediately call
update() to load the initial contents into the view.
The update function checks if there is a defined template for the current route, if so it proceeds by calling the linker function, passing in a new scope, and a callback function. The callback function’s only parameter is the cloned element, whose html will be replaced with the route’s current template. The cloned element is then appended to div with the ng-view-lite attribute. Afterwhich we remove the previous contents from the view.
Finally, the template must be compiled (
$compile(clone.contents())) and a new scope is injected into it (
link(newScope)). In between those two steps we check if the current route has an associated controller: if so we instantiate the controller with the newScope and the local variables from the current route.
Making an ngMultiView
ngView works well, but what if you want multiple views to change according the url? According to the documentation ngView can only be used once within an application. To accomplish our
ngMultiView we’ll slightly modify
ngView and create an Angular value (
MultiViewPaths) to hold the mapping between urls, views, controllers and templates.
In ngMultiView, a parameter is passed into the directive
<div ng-multi-view="secondaryContent"></div>, in the directive this attribute will be called “panel”. Instead of binding to the
'$routeChangeSuccess' event, we’ll bind to
'$locationChangeSuccess' to make our directive completely independent of
ngRoute. ngMultiView will work the following way:
- A url change will trigger
'$locationChangeSuccess', which in turn will call
- Within update: grab the portion of the URL after the hash (in the code this portion is just called url).
- Using the url variable, and the panel, we can lookup the corresponding controller and template from the
- Once we have the controller and template, ngMultiView works almost identically to
Our ngMultiView is very basic, it doesn’t take into account parameters being passed through urls, nor does it deal with scope cleanup, or animations. If you need more functionality I’d recommend starting with the
$routes service and modifying it to accommodate multiple views.
Creating custom directives can be intimidating at first. There’s a lot of jargon to overcome, and many little nuances. However, once those are overcome it becomes relatively easy to alter existing directives or create your own.