2.0+
Shutter calls
Shutter controls (< 2.0)
Shutter calls are window methods or classes called from window's in-built shutter methods. When shutters are called arguments are passed into the method or class through predefined arguments which the method or class called picks up form its parent caller. In previous versions arguments are passed to methods through the SELF::ARG or SELF::PARAM shutter key as shown below: 
namespace spoova/mi/windows/Routes;

use Window;
use spoova/mi/core/classes/Ajax;

class Home extends Window { 

    function __construct() {

        $Ajax = new Ajax;
        $myArray = [1,2,3];

        self::call($this, 
            [
                window(':user/2.0') => 'user',
                
                SELF::ARG => [$Ajax, $myArray]
            ]
        );

    }


    function user($vars) {

        $Ajax = $vars[0];
        $myArray = $vars[1];

        //do something ...

    }

}
The example above reveals how to pass in arguments in previous versions. The main issue with this is that the supplied arguments are passed across to all methods called by the shutter even if they are not used and it is more difficult to pass different dependencies to different methods.


Shutter controls (2.0+)
In version 2.0, there is an improved way of passing in dependencies into method using type hinting. Once the type is defined, the method will ensure that the dependency is initialized and passed into the method. This is shown below: 
namespace spoova/mi/windows/Routes;

use Window;
use spoova/mi/core/classes/Ajax;
use spoova/mi/core/classes/Filemanager;

class Home extend Window { 

    function __construct() {

        $myArray = [1,2,3];

        self::call($this, 
            [
                window(':user') => 'user',
                window(':profile') => 'profile',

                self::ARG => $myArray
            ]
        );

    }


    function user($Ajax Ajax, $myArray) {

        //do something ...

    }

    function profile(Filemanager $Filemanager) {

        //do something ...

    }

}
In the example above, the dependencies are first called using type hinting while the passed arguments are obtained afterwards. This makes it easier to pass variables to the called methods on if it is required for use.