<?php

/** KumbiaForms - PHP Rapid Development Framework *****************************
*	
* Copyright (C) 2005-2007 Andrés Felipe Gutiérrez (andresfelipe at vagoogle.net)
* 	
* This framework is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
* 
* This framework is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
* 
* You should have received a copy of the GNU Lesser General Public
* License along with this framework; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
* 
* Este framework es software libre; puedes redistribuirlo y/o modificarlo
* bajo los terminos de la licencia pública general GNU tal y como fue publicada
* por la Fundación del Software Libre; desde la versión 2.1 o cualquier
* versión superior.
* 
* Este framework es distribuido con la esperanza de ser util pero SIN NINGUN 
* TIPO DE GARANTIA; sin dejar atrás su LADO MERCANTIL o PARA FAVORECER ALGUN
* FIN EN PARTICULAR. Lee la licencia publica general para más detalles.
* 
* Debes recibir una copia de la Licencia Pública General GNU junto con este
* framework, si no es asi, escribe a Fundación del Software Libre Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
*****************************************************************************/

/****************************************************************************
* Main Forms Module
****************************************************************************/
require_once "forms/config/main.php";
require_once "forms/generator/main.php";
require_once "forms/xml/main.php";

/**
 * El driver de Kumbia es cargado segun lo que diga en config.ini
 */
if(!dbBase::load_driver()){
	Flash::warning('No se pudo cargar el driver de la base de datos definido en forms/config/config.ini');
	return false;
}

/**
 * La lista de modulos en core.ini son cacheados en la variable de sesion
 * $_SESSION['KUMBIA_MODULES'] para no leer este archivo muchas veces
 * 
 * La variable extensiones en el apartado modules en forms/config/core.ini 
 * tiene valores estilo kumbia.tags,... esto hace q Kumbia cargue 
 * automaticamente en el directorio lib/kumbia el archivo tags.php.
 * 
 * Esta variable tambien puede ser utilizada para cargar modulos de
 * usuario y clases personalizadas
 * 
 * Chequee la función import() en este mismo archivo para encontrar una forma
 * alternativa para cargar modulos y clases de usuario en Kumbia
 * 
 */
if(!isset($_SESSION['KUMBIA_MODULES'])){
	$_SESSION['KUMBIA_MODULES'] = array();
}
if(!isset($_SESSION['KUMBIA_MODULES'][$_SESSION['KUMBIA_PATH']])){
	$_SESSION['KUMBIA_MODULES'][$_SESSION['KUMBIA_PATH']] = array();
	if($kumbia_config = Config::read('core.ini')){
		$kumbia_config->modules->extensions = str_replace(" ", "", $kumbia_config->modules->extensions);
		$extensions = explode(",", $kumbia_config->modules->extensions);
		foreach($extensions as $extension){
			$ex = explode(".", $extension);
			$_SESSION['KUMBIA_MODULES'][$_SESSION['KUMBIA_PATH']][] = "lib/{$ex[0]}/{$ex[1]}.php";
		}
	}
}
foreach($_SESSION['KUMBIA_MODULES'][$_SESSION['KUMBIA_PATH']] as $kbmodule){
	require_once $kbmodule;
}

/**
 * Esta es la clase principal del framework, contiene metodos importantes 
 * para cargar los controladores y ejecutar las acciones en estos ademas
 * de otras funciones importantes
 *
 */
abstract class Kumbia {

	public $config;
	public $data = array();
	static private $persistence = array();
	static public $content = "";
	static public $smarty_object = "";
	static public $routed = true;
	static public $models = array();
	static public $controller;

	/**
	 * Función Principal donde se ejecutan los controladores
	 *
	 * @return boolean
	 */
	static function main(){
		require "controllers/application.php";
		require "forms/controller/application_controller.php";
		require "forms/controller/standard_form_controller.php";
		require "forms/controller/grid_form_controller.php";
		require "forms/controller/master_detail_form_controller.php";
		require "forms/session/main.php";
		$_REQUEST['controller'] = str_replace("/", "", $_REQUEST['controller']);
		$_REQUEST['controller'] = str_replace("\\", "", $_REQUEST['controller']);
		$_REQUEST['controller'] = str_replace("..", "", $_REQUEST['controller']);
		if($_REQUEST['action']==''){
			$_REQUEST['action'] = "index";
		}
		try {
			if(!$_REQUEST['controller']){
				$app = new ApplicationController();
				if(method_exists($app, 'init')){
					$app->init();
				} else {
					throw new kumbiaException("No se encontr&oacute; la Acci&oacute;n por defecto \"init\"",
					"Es necesario definir un m&eacute;todo en la clase controladora
					'ApplicationController' llamado 'init' para que esto funcione correctamente.");			  
					return false;;
				}
			}
			if($_REQUEST['controller']){
				self::if_routed();
				if($_SESSION['session_data']){
					if(!is_array($_SESSION['session_data'])){
						$_SESSION['session_data'] = unserialize($_SESSION['session_data']);
					}
				}
				self::$persistence = array();
				foreach(self::$persistence as $p){
					if(Session::get_data($p)){
						$GLOBALS[$p] = Session::get_data($p);
					}
				}

				foreach(scandir('models/') as $model){
					if(strpos($model, ".php")){
						require "models/$model";
						$model = str_replace(".php", "", $model);
						$objModel = str_replace("_", " ", $model);
						$objModel = ucwords($objModel);
						$objModel = str_replace(" ", "", $objModel);
						if(!class_exists($objModel)){
							throw new kumbiaException("
							No se encontr&oacute; la Clase \"$objModel\"",							
							"Es necesario definir una clase en el modelo 
							'$model' llamado '$objModel' para que esto funcione correctamente.");
							return false;
						} else {
							$GLOBALS[$objModel] = new $objModel($model, false);
							$GLOBALS[$objModel]->source = $model;
							global $$objModel;
							if(isset($GLOBALS[$objModel]->persistent)){
								if($GLOBALS[$objModel]->persistent)
								self::$persistence[] = $objModel;
							}
							$GLOBALS[$objModel]->source = $model;
							self::$models[$objModel] = $GLOBALS[$objModel];
						}
					}
				}
				ob_start();
				while(self::$routed){
					self::$routed = false;
					if(file_exists("controllers/".$_REQUEST['controller']."_controller.php")){
						$appController = $_REQUEST['controller']."Controller";
						if(!class_exists($appController)){
							require "controllers/".$_REQUEST['controller']."_controller.php";
						}
						if(class_exists(ucwords($_REQUEST['controller'])."Controller")) {
							if(!isset($_SESSION['KUMBIA_CONTROLLERS'][$appController])){
								self::$controller = new $appController();
							} else {
								self::$controller = unserialize($_SESSION['KUMBIA_CONTROLLERS'][$appController]);
							}
							self::$controller->response = "";
							self::$controller->controller_name = $_REQUEST['controller'];
							self::$controller->action_name = $_REQUEST['action'];
							self::$controller->id = $_REQUEST['id'];
							self::$controller->params = $_REQUEST['params'];
							foreach(self::$models as $model_name => $model){
								self::$controller->{$model_name} = $model;
							}
							/**
					 		 * El metodo before_filter es llamado antes de ejecutar una accion en un
					 		 * controlador, puede servir para realizar ciertas validaciones
					 		 */
							if(method_exists($appController, "before_filter")){
								if(self::$controller->before_filter($_REQUEST['controller'], $_REQUEST['action'], $_REQUEST['id'])===false){
									continue;
								}
							} else {
								if(isset(self::$controller->before_filter)){
									if(self::$controller->{self::$controller->before_filter}($_REQUEST['controller'], $_REQUEST['action'], $_REQUEST['id'])===false){
										continue;
									}
								}
							}
							if(method_exists(self::$controller, $_REQUEST['action'])){
								/**
								 * Cuando una acción retorna un valor diferente de Nulo
						 		 * Kumbia automaticamente crea una salida XML
						 		 * para la acción utilizando un CDATA, es muy 
						 		 * util en conjunto a la función JavaScript 
						 		 * AJAX.query
						 		 */
								$value_returned = self::$controller->$_REQUEST['action']($_REQUEST['id']);
								if(!is_null($value_returned)){
									$xml = new simpleXMLResponse();
									$xml->addData($value_returned);
									$xml->outResponse();
									self::$controller->set_response('xml');
								}
								foreach(self::$models as $model_name => $model){
									unset(self::$controller->{$model_name});
								}
								$_SESSION['KUMBIA_CONTROLLERS'][$appController] = serialize(self::$controller);
								if(is_subclass_of(self::$controller, "ApplicationController")){
									foreach(self::$controller as $var => $value) {
										$$var = $value;
									}
								}
								foreach(self::$persistence as $p){
									Session::set_data($p, $GLOBALS[$p]);
								}
							} else {
								throw new kumbiaException(
								"No se encontr&oacute; la Acci&oacute;n \"{$_REQUEST['action']}\"",
								"Es necesario definir un m&eacute;todo en la clase
									controladora '{$_REQUEST['controller']}' llamado
									'{$_REQUEST['action']}' para que esto funcione correctamente.");
								return false;
							}
							/**
					 		 * El metodo after_filter es llamado despues de ejecutar una accion en un
					 		 * controlador, puede servir para realizar ciertas validaciones
					 		 */
							if(method_exists($appController, "after_filter")){
								self::$controller->after_filter($_REQUEST['controller'], $_REQUEST['action'], $_REQUEST['id']);
							} else {
								if(isset(self::$controller->after_filter)){
									self::$controller->{self::$controller->after_filter}($_REQUEST['controller'], $_REQUEST['action'], $_REQUEST['id']);
								}
							}
						} else {
							throw new kumbiaException("
							No se encontr&oacute; el Clase Controladora \"{$_REQUEST['controller']}Controller\"",
							"Debe definir esta clase para poder trabajar este controlador");
							return false;
						}
					} else {
						throw new kumbiaException("
						No se encontr&oacute; el Controlador \"{$_REQUEST['controller']}\"",
						"Hubo un problema al cargar el controlador, probablemente
						el archivo no exista en el directorio de m&oacute;dulos &oacute; exista algun error
						de sintaxis. Si desconoce la naturaleza
						de este mensaje consulte con el administrador del sistema");
						return false;
					}
				}

				/**
				* Kumbia busca un los templates correspondientes al nombre de la accion y el layout
				* del controlador. Si el controlador tiene un atributo $template tambien va a 
				* cargar la vista ubicada en layouts con el valor de esta
				* 
				* en views/$controller/$action
				* en views/layouts/$controller
				* en views/layouts/$template
				* 
				* Los archivos con extensión .phtml son archivos template de kumbia que
				* tienen codigo html y php y son el estandar, tambien pueden tener
				* extensión .tpl, en este caso, Kumbia hace la integración con Smarty si
				* este esta disponible.
				* 	
				*/		
				Kumbia::$content = ob_get_contents();
				/**
			 	* Verifica si existe cache para el layout, vista ó template
		 		* sino, crea un directorio en cache
		 		*/				
				if($_REQUEST['controller']){
					if(self::$controller->get_view_cache()||
					self::$controller->get_layout_cache()){
						$view_cache_dir = "cache/".session_id()."/";
						if(!file_exists("cache/".session_id()."/")){
							mkdir($view_cache_dir);
						}
						$view_cache_dir.=$_REQUEST['controller'];
						if(!file_exists($view_cache_dir)){
							mkdir($view_cache_dir);
						}
					}
					if(self::$controller->response!='xml'){
						if(file_exists("views/{$_REQUEST['controller']}/{$_REQUEST['action']}.phtml")){
							ob_clean();
							/**
							 * Aqui verifica si existe un valor en minutos para el cache
				 			 */
							if(self::$controller->get_view_cache()){
								/**
					 			 * Busca el archivo en el directorio de cache que se crea
					 			 * a partir del valor $_SESSION['SID'] para que sea único
					 			 * para cada sesión
					 			 */
								if(!file_exists($view_cache_dir."/{$_REQUEST['action']}")){
									include "views/{$_REQUEST['controller']}/{$_REQUEST['action']}.phtml";
									file_put_contents($view_cache_dir."/{$_REQUEST['action']}", ob_get_contents());
								} else {
									include $view_cache_dir."/{$_REQUEST['action']}";
								}
							} else {
								include "views/{$_REQUEST['controller']}/{$_REQUEST['action']}.phtml";
							}
							Kumbia::$content = ob_get_contents();
						} else {
							if(defined('USE_SMARTY')){
								if(file_exists("views/{$_REQUEST['controller']}/{$_REQUEST['action']}.tpl")){
									if(!Kumbia::$smarty_object){
										self::kumbia_smarty(self::$controller);
									}
									foreach(self::$controller as $_key => $_value){
										Kumbia::$smarty_object->assign($_key, $_value);
									}
									foreach(self::$models as $_model_name => $_model){
										Kumbia::$smarty_object->assign($_model_name, $_model);
									}
									Kumbia::$smarty_object->display($_REQUEST['action'].".tpl");
									Kumbia::$content = ob_get_contents();
								}

							}
						}
					}
					if(self::$controller->response!='xml'&&self::$controller->response!='view'){
						if(self::$controller->template){
							/**
				 			 * Aqui verifica si existe un valor en minutos para el cache
				 			 */
							if(file_exists("views/layouts/".self::$controller->template.".phtml")){
								ob_clean();
								if(self::$controller->get_layout_cache()){
									/**
					   				 * Busca el archivo en el directorio de cache que se crea
					 	 			 * a partir del valor session_id() para que sea único
					 	 			 * para cada sesión
					 	 			 */											
									if(!file_exists($view_cache_dir."/layout")){
										include "views/layouts/".self::$controller->template.".phtml";
										file_put_contents($view_cache_dir."/layout", ob_get_contents());
									} else {
										include $view_cache_dir."/{$_REQUEST['action']}";
									}
								} else {
									include "views/layouts/".self::$controller->template.".phtml";
								}
								Kumbia::$content = ob_get_contents();
							}
						}
					}
					if((self::$controller->response!='xml')&&(self::$controller->response!='view')){
						if(file_exists("views/layouts/{$_REQUEST['controller']}.phtml")){
							ob_clean();
							if(self::$controller->get_layout_cache()){
								/**
				 				 * Busca el archivo en el directorio de cache que se crea
				 	 			 * a partir del valor session_id() para que sea único
				 	 			 * para cada sesión
				 	 			 */											
								if(!file_exists($view_cache_dir."/layout")){
									include "views/layouts/{$_REQUEST['controller']}.phtml";
									file_put_contents($view_cache_dir."/layout", ob_get_contents());
								} else {
									include $view_cache_dir."/layout";
								}
							} else {
								include "views/layouts/{$_REQUEST['controller']}.phtml";
							}
							Kumbia::$content = ob_get_contents();
						}
					}
				}
				if((self::$controller->response!='view')&&(self::$controller->response!='xml')){
					if(file_exists("views/index.phtml")){
						ob_clean();
						include "views/index.phtml";
						Kumbia::$content = ob_get_contents();
					}
					if($_SESSION['session_data']){
						$_SESSION['session_data'] = serialize($_SESSION['session_data']);
					}
					ob_end_flush();
					self::$controller = null;
				}
			}
		}
		catch(kumbiaException $e){
			if($_SESSION['session_data']){
				$_SESSION['session_data'] = serialize($_SESSION['session_data']);
			}
			$e->show_message();
			return;
		}
		catch(dbException $e){
			if($_SESSION['session_data']){
				$_SESSION['session_data'] = serialize($_SESSION['session_data']);
			}
			$e->show_message();
			return;
		}
		catch(ActiveRecordException $e){
			if($_SESSION['session_data']){
				$_SESSION['session_data'] = serialize($_SESSION['session_data']);
			}
			$e->show_message();
			return;
		}
	}

	/**
 	 * Busca en la tabla de entutamiento si hay una ruta en forms/config/routes.ini
 	 * para el controlador, accion, id actual
     *
     */
	static function if_routed(){
		unset($_SESSION['KUMBIA_STATIC_ROUTES']);
		if(!isset($_SESSION['KUMBIA_STATIC_ROUTES'])){
			$routes = Config::read('routes.ini');
			if(isset($routes->routes)){
				foreach($routes->routes as $source => $destination){
					if(count(explode("/", $source))!=3||count(explode("/", $destination))!=3){
						Flash::warning("Pol&iacute;tica de enrutamiento invalida '$source' a '$destination' en forms/config/routes.ini");
					} else {
						list($controller_source,
						$action_source,
						$id_source) = explode("/", $source);
						list($controller_destination,
						$action_destination,
						$id_destination) = explode("/", $destination);
						if(($controller_source==$controller_destination)&&
						($action_source==$action_destination)&&
						($id_source==$id_destination)){
							Flash::warning("Politica de enrutamiento ciclica de '$source' a '$destination' en forms/config/routes.ini");
						} else {
							$_SESSION['KUMBIA_STATIC_ROUTES'][$controller_source][$action_source][$id_source] =
							array("controller" => $controller_destination,
							"action" => $action_destination,
							"id" => $id_destination);
						}
					}
				}
			}
		}
		$new_route = array("controller" => '*', "action" => '*', "id" => '*');
		if(isset($_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['*']][$_REQUEST['action']]['*'])){
			$new_route = $_SESSION['KUMBIA_STATIC_ROUTES']['*'][$_REQUEST['action']]['*'];
		}
		if(isset($_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']]['*']['*'])){
			$new_route = $_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']]['*']['*'];
		}
		if(isset($_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']]['*'][$_REQUEST['id']])){
			$new_route = $_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']]['*'][$_REQUEST['id']];
		}
		if(isset($_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']][$_REQUEST['action']]['*'])){
			$new_route = $_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']][$_REQUEST['action']]['*'];
		}
		if(isset($_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']][$_REQUEST['action']][$_REQUEST['id']])){
			$new_route = $_SESSION['KUMBIA_STATIC_ROUTES'][$_REQUEST['controller']][$_REQUEST['action']][$_REQUEST['id']];
		}
		if($new_route['controller']!='*'){
			$_REQUEST['controller']	= $_POST['controller'] = $_GET['controller'] = $new_route['controller'];
		}
		if($new_route['action']!='*'){
			$_REQUEST['action']	= $_POST['action'] = $_GET['action'] = $new_route['action'];
		}
		if($new_route['id']!='*'){
			$_REQUEST['id']	= $_POST['id'] = $_GET['id'] = $new_route['id'];
		}
		return;
	}

	/**
	 * Esta función realiza la integración con Smarty, creando los
	 * directorios necesarios para que un controlador pueda
	 * utlizar templates Smarty
	 *
	 * @param $controllerObj
	 */
	static function kumbia_smarty($controllerObject){
		if(!Kumbia::$smarty_object){
			foreach($controllerObject as $property => $value){
				if(@get_class($value)=="Smarty"){
					Kumbia::$smarty_object = $value;
				}
			}
		}
		if(!Kumbia::$smarty_object){
			Kumbia::$smarty_object = new Smarty();
		}
		if(!file_exists("cache/{$_REQUEST['controller']}")){
			mkdir("cache/{$_REQUEST['controller']}");
			mkdir("cache/{$_REQUEST['controller']}/compile");
			mkdir("cache/{$_REQUEST['controller']}/cache");
			mkdir("cache/{$_REQUEST['controller']}/config");
		}
		Kumbia::$smarty_object->template_dir = "views/{$_REQUEST['controller']}/";
		Kumbia::$smarty_object->compile_dir = "cache/{$_REQUEST['controller']}/compile";
		Kumbia::$smarty_object->cache_dir = "cache/{$_REQUEST['controller']}/cache";
		Kumbia::$smarty_object->config_dir = "cache/{$_REQUEST['controller']}/config";
	}

	/**
	 * Verifica si $model es un modelo del Proyecto
	 *
	 * @param string $model
	 * @return boolean
	 */
	static function is_model($model){

		if($model==''){
			return false;
		}

		return isset(self::$models[self::get_model_name($model)]);

	}

	/**
	 * Devuelve el nombre de modelo de la entidad $model
	 *
	 * @param string $model
	 * @return string
	 */
	static function get_model_name($model){

		if($model==''){
			return false;
		}

		$objModel = str_replace("_", " ", $model);
		$objModel = ucwords($objModel);
		$objModel = str_replace(" ", "", $objModel);

		return $objModel;

	}

	static function kumbia_helper(){
		$_REQUEST['controller'] = str_replace("/", "", $_REQUEST['controller']);
		$_REQUEST['controller'] = str_replace("\\", "", $_REQUEST['controller']);
		$_REQUEST['controller'] = str_replace("..", "", $_REQUEST['controller']);
		if($_REQUEST['controller']){
			$GLOBALS['IS_HELPER'] = true;
			include "helpers/".$_REQUEST['controller'].".php";
			if($formulario){
				buildForm($formulario);
			}else {
				if(isset($$_REQUEST['controller'])){
					buildForm($$_REQUEST['controller']);
				}
			}
		}
	}

	/**
	 * Carga Librerias JavaScript Importantes en el Framework
	 *
	 */
	static function javascript_base(){
		print "\t<script type='text/javascript' src='".KUMBIA_PATH."javascript/scriptaculous/prototype.js'></script>\r\n";
		print "\t<script type='text/javascript' src='".KUMBIA_PATH."javascript/scriptaculous/effects.js'></script>\r\n";
		print "\t<script type='text/javascript' src='".KUMBIA_PATH."javascript/kumbia/base.js'></script>\r\n";
		print "\t<script type='text/javascript' src='".KUMBIA_PATH."javascript/kumbia/main.php?path=".urlencode(KUMBIA_PATH)."&controller={$_REQUEST['controller']}&action={$_REQUEST['action']}&id={$_REQUEST['id']}'></script>\r\n";
	}

	/**
	 * Carga otras librerias para realizar efectos en JavaScript
	 *
	 */
	static function javascript_use_drag(){
		print "\t<script src='".KUMBIA_PATH."javascript/scriptaculous/unittest.js' type='text/javascript'></script>\r\n";
		print "\t<script src='".KUMBIA_PATH."javascript/scriptaculous/scriptaculous.js' type='text/javascript'></script>\r\n";
	}

	/**
	 * Enruta el controlador actual a otro controlador,
	 * ó otra acción 
	 * Ej:
	 * kumbia::route_to("controller: nombre", ["action: accion"], ["id: id"])
	 *
	 * @return null
	 */
	static function route_to(){
		Kumbia::$routed = false;
		$url = get_params(func_get_args());
		if($url['controller']){
			$_REQUEST['controller'] = $url['controller'];
			$_REQUEST['action'] = "index";
			Kumbia::$routed = true;
		}
		if($url['action']){
			$_REQUEST['action'] = $url['action'];
			Kumbia::$routed = true;
		}
		if($url['id']){
			$_REQUEST['id'] = $url['id'];
			Kumbia::$routed = true;
		}
		return null;
	}

	/**
	 * Metodo que muestra información del Framework y la licensia
	 *
	 */
	static function info(){
		$config = Config::read();
		self::javascript_base();
		if(strpos(" ".$_SERVER['HTTP_ACCEPT_LANGUAGE'], 'es')){
			print "<table align='center' style='border:1px solid black' width=700 bgcolor='#1B1B1B'
			cellspacing='0'><td><img src='".KUMBIA_PATH."img/kumbia.jpg'></td>
		<tr><td bgcolor='white'>
		<div style='padding:10px'>
	    <span style='font-family:LucidaMac,Verdana;color:#2C2C2C;font-size:32px'>Bienvenido</span>
	    </div>
	    </tr>
	    <tr><td bgcolor='white'>
	    <div style='padding:10px'>
	    <span style='font-family:LucidaMac,Verdana;font-size:14px'
		>Ya puedes empezar a usar el mejor framework
	    para desarrollar aplicaciones web con php.<br/>
	    KumbiaForms es un framework PHP desarrollado para la creaci&oacute;n de aplicaciones 
		orientadas a base de datos.<br/><br/>
		La creación rapida de formularios que trabajen sobre entidades de bases de datos 
		es la especialidad de KumbiaForms. Para iniciar edite el archivo <b>forms/config/config.ini</b><br/><br/>

	    <a href='#' style='color:#2C2C2C' onclick='new Effect.toggle(\"license\", \"blind\")'>Ver Licencia</a>
	    <div id='license' style='display:none;text-align:center' >
	    <pre style='border:1px solid #808080;background:#F0F0F0;font-size:10px;width:500px;text-align:left'>
		
** KumbiaForms - PHP Rapid Development Framework *****************************
*	 	
* This framework is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
* 
* This framework is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
* 
* You should have received a copy of the GNU Lesser General Public
* License along with this framework; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
* 
* Este framework es software libre; puedes redistribuirlo y/o modificarlo
* bajo los terminos de la licencia pública general GNU tal y como fue publicada
* por la Fundación del Software Libre; desde la versión 2.1 o cualquier
* versión superior.
* 
* Este framework es distribuido con la esperanza de ser util pero SIN NINGUN 
* TIPO DE GARANTIA; sin dejar atrás su LADO MERCANTIL o PARA FAVORECER ALGUN
* FIN EN PARTICULAR. Lee la licencia publica general para más detalles.
* 
* Debes recibir una copia de la Licencia Pública General GNU junto con este
* framework, si no es asi, escribe a Fundación del Software Libre Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
*****************************************************************************
	    </pre></div>
		<br/></span></pre>
		</td></tr></table>";
		} else {
			print "<table align='center' style='border:1px solid black' width=700
		cellspacing='0'><td><img src='".KUMBIA_PATH."img/kumbia.jpg'></td>
		<tr><td bgcolor='white'>
	    <h1 style='font-family: LucidaMac,\"Lucida Sans Unicode\", Verdana;color:black'>Welcome to KumbiaForms!</h1>
	    </tr>
	    <tr><td bgcolor='white'>
	    <span style='font-family:LucidaMac,Verdana;font-size:14px'>
		Now you can use the best 
		framework to develop Web enabled Applications. KumbiaForms is free software!
		<br/><br/></span>
		</td></tr></table>";
		}
	}

	static function scandir_recursive($package_dir, $files=array()){
		foreach(scandir($package_dir) as $file){
			if($file!='.'&&$file!='..'){
				if(is_dir($package_dir."/".$file)){
					$files = self::scandir_recursive($package_dir."/".$file, $files);
				} else {
					if(ereg("(.)+\.php$", $file)){
						$files[] = $package_dir."/".$file;
					}
				}
			}
		}
		return $files;
	}

	static function import($package){

		$package_array = explode(".", $package);
		$package_dir = "";
		$class = "";

		if($package_array[count($package_array)-1]=='*'){
			unset($package_array[count($package_array)-1]);
			$package_dir = join(".", $package_array);
			$class = '*';
		} else {
			$package_dir = $package;
		}

		if($class=='*'){
			$package_dir = str_replace('.', '/', $package_dir);
			if(!file_exists($package_dir)){
				throw new kumbiaException("No existe el directorio '$package_dir'\n");
			}
			$files = self::scandir_recursive($package_dir);
			foreach($files as $file){
				include_once $file;
			}
		} else {
			$package_dir = str_replace('.', '/', $package_dir);
			if(file_exists($package_dir.'.php')){
				include_once $package_dir.'.php';
			} else {
				throw new kumbiaException("No existe el directorio '$package_dir'\n");
			}
		}
	}

}
/**
 * Muestra el contenido acumulado en llamados anteriores
 * en las vistas
 *
 */
function content(){
	print Kumbia::$content;
}


?>