1 var Class = require("../lib/mootools/mootools-node.js").Class;
  2 var Event = require('../lib/core/event/Event.js').Event;
  3 var ErrorEvent = require('../lib/core/event/ErrorEvent.js').ErrorEvent;
  4 var EventDispatcher = require('../lib/core/event/EventDispatcher.js').EventDispatcher;
  5 var DriverManager = require('../lib/DriverManager.js').DriverManager;
  6 var DriverLocal = require('../lib/DriverManager.js').DriverLocal;
  7 var DriverAbstract = require('../lib/DriverAbstract.js').DriverAbstract;
  8 var TemplateManager = require('../lib/TemplateManager.js').TemplateManager;
  9 
 10 
 11 /**
 12  * @class RenderingController Responsible for holding and parsing configuration.
 13  * @extends EventDispatcher
 14  * @requires Class 
 15  * @requires Event 
 16  * @requires ErrorEvent 
 17  * @requires EventDispatcher 
 18  * @requires DriverManager 
 19  * @requires DriverAbstract 
 20  * @requires TemplateManager
 21  * @param {Object} configuration Rendering configuration
 22  * @throws {RenderingController.Exception.WRONG_CONFIGURATION} if given configuration isn't valid - is null or is'nt {@link Object} or {@link Array}.
 23  */
 24 
 25 var RenderingController = function(){
 26     /** @ignore */
 27     this.Extends = EventDispatcher;
 28     /**
 29      * @property {DriverManager} _driverManager holds reference to driverManager
 30      * @private
 31      */
 32     this._driverManager = null;
 33     /**
 34      * @property {TemplateManager} _templateManagers holds references to templateManagers
 35      * @private
 36      */
 37     this._templateManagers = [];
 38     /**
 39      * @property {Object} _configuration holds the configuration
 40      * @private
 41      */
 42     this._configuration = null;
 43     /**
 44      * @property {Number} _counter holds number of rendered templateManager
 45      * @private
 46      */
 47     this._counter = 0;
 48 
 49     /** @ignore */
 50     this.initialize = function(configuration){
 51         if(!configuration || typeof configuration != "object" || configuration.constructor != Array){
 52             throw RenderingController.Exception.WRONG_CONFIGURATION;
 53         }
 54         this._driverManager = new DriverManager();
 55         this._templateManagers = [];
 56         this._configuration = configuration;
 57         this._counter = 0;
 58     };
 59 
 60     /**
 61      * callback dispatched when templateManager renders all of its templates
 62      * 
 63      * @param {Event} e
 64      * @private
 65      */
 66     this._onTemplateManagerRendered = function(e){
 67         this._counter++;
 68         if(this._counter == this._templateManagers.length){
 69             console.log('   -- RenderingController::onTemplateManagerRendered');
 70             var data = [];
 71             for( var i = 0; i < this._templateManagers.length; i++){
 72                 data.push(this._templateManagers[i].getTemplatesContent());
 73             }
 74             this.dispatchEvent(new Event(RenderingController.RENDERED, data));
 75         }
 76     };
 77 
 78     /**
 79      * callback dispatched when an error occurs in templateManager rendering process
 80      * 
 81      * @param {ErrorEvent} e
 82      * @private
 83      */
 84     this._onTemplateManagerError = function(e){
 85         this.dispatchEvent(new ErrorEvent(RenderingController.ERROR, e));
 86     };
 87 
 88     /**
 89      * wraps DriverManager.createDriver factory method,
 90      * creates proper instance of driver based on the given configuration
 91      * 
 92      * @param {Object} configItem Configuration of transformation rule 
 93      * @private
 94      */
 95     this._createDriver = function(configItem){
 96         var driver;
 97 
 98         if(configItem.hasOwnProperty('#data')){
 99             var data = configItem['#data'];
100             if(data.hasOwnProperty('driver')){
101                 //TODO make a call;
102                 driver = DriverManager.createDriver(data.driver, data);
103             }
104             else{
105                 throw RenderingController.Exception.NO_REMOTE_DRIVER;
106             }
107         }else{
108             driver = DriverManager.createDriver('DriverLocal', configItem.data || {});
109         }
110 
111         return driver;
112     };
113     /**
114      * Executing rendering flow. Creates {@link TemplateManager} instances, adds templates, creates drivers and fetches them
115      * @public
116      * @throws {RenderingController.Exception.NO_REMOTE_DRIVER} if given transformation rule has declared remote driver use <i>#data</i> but no <i>driver</i> field is declared.
117      */
118     this.render = function(){
119 
120         var config = this._configuration;
121 
122         console.log('   -- RenderingController::render');
123 
124         // lece po wszystkich galeziach drzewa
125         for( var i = 0, max = config.length; i < max; i++ ){
126             // tworze TemplateManagery dla kazdej z glownych galezi drzewa
127             var manager = new TemplateManager();
128             this.addTemplateManager(manager);
129             
130             // lece po wszystkich itemach w danej galezi
131             for(var name in config[i]){
132                 if(config[i].hasOwnProperty(name)){
133 
134                     //sprawdzam czy obslugujemy podany templejt
135                     try{
136                         var template = TemplateManager.createTemplate(name, config[i][name]);
137                     }catch(e){
138                         continue;
139                     }
140 
141                     manager.addTemplate(template);
142 
143                     var driver = this._createDriver(config[i][name]);
144 
145                     driver.addEventListener(DriverAbstract.LOADED, template.onData, template);
146                     driver.addEventListener(DriverAbstract.ERROR, template.onDataError, template);   
147 
148                     this._driverManager.addDriver(driver);
149                 }
150             }
151         }
152         this._driverManager.fetch();
153     };
154     /**
155      * Adds event listeners to the given templateManager and holds it
156      * @public
157      * @param {TemplateManager} manager 
158      */
159     this.addTemplateManager = function(manager){
160         this._templateManagers.push(manager);
161         manager.addEventListener(TemplateManager.RENDERED, this._onTemplateManagerRendered, this);
162         manager.addEventListener(TemplateManager.ERROR, this._onTemplateManagerError, this);
163         //TODO error event  
164     };
165 };
166 
167 RenderingController = new Class(new RenderingController());
168 /**
169  * @static
170  * @constant
171  */
172 RenderingController.RENDERED = "RenderingController_RENDERED";
173 /**
174  * @static
175  * @constant
176  */
177 RenderingController.ERROR = "RenderingController_ERROR";
178 /**
179  * Namespace for exeptions messages.
180  * @static
181  * @constant
182  * @namespace
183  */
184 RenderingController.Exception = {};
185 /**
186  * @static
187  * @constant
188  */
189 RenderingController.Exception.WRONG_CONFIGURATION = 'Given configuration is not proper';
190 /**
191  * @static
192  * @constant
193  */
194 RenderingController.Exception.NO_REMOTE_DRIVER = "Remote data marker given but no driver specified!";
195 
196 exports.RenderingController = RenderingController;