readConfig() is not naming convention, renamed to getConfigEntry()
[shipsimu.git] / application / selector / class_ApplicationSelector.php
1 <?php
2 /**
3  * The application selector class.
4  *
5  * @author              Roland Haeder <webmaster@ship-simu.org>
6  * @version             0.0.0
7  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 Ship-Simu Developer Team
8  * @license             GNU GPL 3.0 or any newer version
9  * @link                http://www.ship-simu.org
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <http://www.gnu.org/licenses/>.
23  */
24 class ApplicationSelector extends BaseFrameworkSystem {
25         /**
26          * An ArrayObject for all found applications
27          */
28         private $foundApps = null;
29
30         /**
31          * An array object for all loaded application templates (selector_app-name.tpl)
32          */
33         private $loadedTemplates = null;
34
35         /**
36          * A list of items we shall ignore while reading from directories
37          */
38         private $dirIgnoreList = array(
39                 ".",
40                 "..",
41                 ".htaccess",
42                 ".svn"
43         );
44
45         /**
46          * The protected constructor. No direct instances can be created from this.
47          *
48          * @return      void
49          */
50         protected function __construct() {
51                 // Call parent constructor
52                 parent::__construct(__CLASS__);
53
54                 // Remove system array and thousand seperator
55                 $this->removeSystemArray();
56                 $this->removeNumberFormaters();
57
58                 // Initialize the array lists
59                 $this->initializeAppsList();
60                 $this->initializeTemplatesList();
61         }
62
63         /**
64          * Create a prepared instance of ApplicationSelector
65          *
66          * @param       $langInstance           The language sub-system: LanguageSystem
67          * @param       $fileIOInstance         The file I/O instance
68          * @return      $selInstance            An instance of ApplicationSelector
69          */
70         public final static function createApplicationSelector (ManageableLanguage $langInstance, FileIoHandler $fileIOInstance) {
71                 // Get a new instance
72                 $selInstance = new ApplicationSelector();
73
74                 // Get all applications
75                 $selInstance->readApplicationDirectory();
76
77                 // Set language and file I/O instances
78                 $selInstance->setLanguageInstance($langInstance);
79                 $selInstance->setFileIoInstance($fileIOInstance);
80
81                 // Return the prepared instance
82                 return $selInstance;
83         }
84
85         /**
86          * Initialize the application list
87          *
88          * @return      void
89          */
90         private function initializeAppsList () {
91                 $this->foundApps = new FrameworkArrayObject("FakedFoundApplications");
92         }
93
94         /**
95          * Initialize the loaded templates list
96          *
97          * @return      void
98          */
99         private function initializeTemplatesList () {
100                 $this->loadedTemplates = new FrameworkArrayObject("FakedLoadedTemplates");
101         }
102
103         /**
104          * Load the data.php script of an application and append the application
105          * instance to $foundApps
106          *
107          * @param       $appData                The FQFN of data.php
108          * @param       $appName                The application's Uni* name
109          * @return      void
110          */
111         private function loadApplicationData ($appData, $appName) {
112                 // Is it a file and readable?
113                 if ((is_file($appData)) && (is_readable($appData))) {
114                         // Then include it
115                         include ($appData);
116
117                         // Add the current instance to the list
118                         $this->foundApps->append($app);
119                 } // END - if ((is_file(...
120         }
121
122         /**
123          * Getter for the $loadedTemplates array object
124          *
125          * @return      $loadedTemplates        An array object holding all loaded
126          *                                                      application templates
127          */
128         private final function getLoadedTemplates () {
129                 return $this->loadedTemplates;
130         }
131
132         /**
133          * Method for compatiblity with prepareTemplateInstance()
134          *
135          * @return      $shortName      This selector's short name
136          */
137         public function getAppShortName() {
138                 $shortName = $this->getConfigInstance()->getConfigEntry('selector_path');
139                 return $shortName;
140         }
141
142         /**
143          * Add a directory/file to the ignore list
144          *
145          * @param               $ignoreItem     The file/directory we shall ignore
146          * @return      void
147          */
148         public function addDirIgnoreList ($ignoreItem) {
149                 // Cast and add it
150                 $this->dirIgnoreList[] = (string) $ignoreItem;
151         }
152
153         /**
154          * Read the base path for all applications (application/) and create a
155          * list of all found applications
156          *
157          * @return      void
158          */
159         public function readApplicationDirectory () {
160                 // Generate the base path for all applications
161                 $appBasePath = $this->getConfigInstance()->getConfigEntry('application_path');
162
163                 // Add the selector path to the ignore list
164                 $this->addDirIgnoreList($this->getConfigInstance()->getConfigEntry('selector_path'));
165
166                 // Get a directory pointer for the application path
167                 $dirInstance = FrameworkDirectoryPointer::createFrameworkDirectoryPointer($appBasePath);
168
169                 // Read all directories&files except some parts
170                 while ($appName = $dirInstance->readDirectoryExcept($this->dirIgnoreList)) {
171                         // Generate FQFN for the application name (or better directory name)
172                         $fqfn = sprintf("%s%s", $appBasePath, $appName);
173
174                         // Is this a readable directory? (files will be ignored silently)
175                         if ((is_dir($fqfn)) && (is_readable($fqfn))) {
176                                 // Then get the data.php script for analyzing
177                                 $appData = sprintf("%s/data.php", $fqfn);
178
179                                 // Load the application's data.php script and append the
180                                 // application to the ArrayObject
181                                 $this->loadApplicationData($appData, $appName);
182                         } // END - if
183                 } // END - while
184
185                 // Close directory pointer
186                 $dirInstance->closeDirectory();
187         }
188
189         /**
190          * Load all templates for found applications in previous scan
191          *
192          * @return      void
193          */
194         public function loadApplicationTemplates () {
195                 // Iterate through all applications
196                 for ($idx = $this->foundApps->getIterator(); $idx->valid(); $idx->next()) {
197                         // Get current application
198                         $appInstance = $idx->current();
199
200                         // Prepare the template engine for the current template
201                         $templateInstance = $this->prepareTemplateInstance($appInstance);
202
203                         // Try to load the web template
204                         $templateInstance->loadWebTemplate(sprintf("%s_%s",
205                                 $this->getConfigInstance()->getConfigEntry('tpl_selector_prefix'),
206                                 strtolower($appInstance->getAppShortName())
207                         ));
208
209                         // Remember this template and the application for later usage
210                         $this->loadedTemplates->append(array(
211                                 'template_class'   => $templateInstance,
212                                 'app_instance' => $appInstance
213                         ));
214                 }
215
216                 // Re-initialize the application list to avoid double loading
217                 $this->initializeAppsList();
218         }
219
220         /**
221          * Removes $dirIgnoreList from the object to save some memory
222          *
223          * @return      void
224          */
225         public final function removeDirIgnoreList () {
226                 unset($this->dirIgnoreList);
227         }
228
229         /**
230          * Loads the selector's own main template. This step is not linking the
231          * application's templates into the main one.
232          *
233          * @return      void
234          */
235         public function loadSelectorTemplate () {
236                 // Prepare the template engine
237                 $templateInstance = $this->prepareTemplateInstance($this);
238
239                 // Load the selector's template
240                 $templateInstance->loadCodeTemplate($this->getConfigInstance()->getConfigEntry('selector_main_tpl'));
241
242                 // Now store it in the class, we need this later on final compilation of available applications
243                 $this->setTemplateInstance($templateInstance);
244         }
245
246         /**
247          * Inserts all loaded application templates into the selector's template
248          *
249          * @return      void
250          * @throws      NoArrayException                                If $curr is not an array
251          * @throws      InvalidArrayCountException              If $curr contains an
252          *                                                                                      unexpected count of elements
253          * @throws      MissingArrayElementsException   If $curr is missing expected
254          *                                                                                      array elements
255          * @todo        Finish handling all applications here
256          */
257         public function insertApplicationTemplates () {
258                 // First prepare the instance
259                 $templateInstance = $this->prepareTemplateInstance($this);
260
261                 // Load template which shall later hold all application templates
262                 $templateInstance->loadCodeTemplate($this->getConfigInstance()->getConfigEntry('selector_apps_tpl'));
263
264                 // Add all loaded application templates together
265                 $dummy = "";
266                 for ($idx = $this->getLoadedTemplates()->getIterator(); $idx->valid(); $idx->next()) {
267                         // Get current item from array object
268                         $curr = $idx->current();
269
270                         // Do some sanity checks on the loaded item
271                         if (!is_array($curr)) {
272                                 // Not an array
273                                 throw new NoArrayException($curr, self::EXCEPTION_IS_NO_ARRAY);
274                         } elseif (count($curr) != 2) {
275                                 // Not expected count of entries
276                                 throw new InvalidArrayCountException(array($this, "curr", count($curr), 2), self::EXCEPTION_ARRAY_HAS_INVALID_COUNT);
277                         } elseif (!isset($curr['template_class']) || (!isset($curr['app_instance']))) {
278                                 // Expected entries missing
279                                 throw new MissingArrayElementsException(array($this, "curr", array("template_class", "app_instance")), self::EXCEPTION_ARRAY_ELEMENTS_MISSING);
280                         }
281
282                         // Debug output
283                         die(__METHOD__."()<pre>".print_r($curr, true)."</pre>");
284                 } // END - for
285         }
286 }
287
288 // [EOF]
289 ?>