VCL
[ class tree: VCL ] [ index: VCL ] [ all elements ]
Packages:
VCL

Source for file actnlist.inc.php

Documentation is available at actnlist.inc.php

  1. <?php
  2. /**
  3. *  This file is part of the VCL for PHP project
  4. *
  5. *  Copyright (c) 2004-2007 qadram software <support@qadram.com>
  6. *
  7. *  Checkout AUTHORS file for more information on the developers
  8. *
  9. *  This library is free software; you can redistribute it and/or
  10. *  modify it under the terms of the GNU Lesser General Public
  11. *  License as published by the Free Software Foundation; either
  12. *  version 2.1 of the License, or (at your option) any later version.
  13. *
  14. *  This library is distributed in the hope that it will be useful,
  15. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. *  Lesser General Public License for more details.
  18. *
  19. *  You should have received a copy of the GNU Lesser General Public
  20. *  License along with this library; if not, write to the Free Software
  21. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22. *  USA
  23. *
  24. */
  25.  
  26. use_unit("classes.inc.php");
  27.  
  28. /**
  29.  * ActionList Class
  30.  *
  31.  * A list of actions for processing web requests.
  32.  * Currently the ActionList is just a list of strings (actions) and when matched
  33.  * by a web request the OnExecute event is fired.
  34.  *
  35.  * Example: If an ActionList1 is defined in unit1.php and the list contains
  36.  *          the string "showmessage" following URL will trigger an OnExecute:
  37.  *          http://localhost/unit1.php/?ActionList1=showmessage
  38.  *          Use the $params["action"] of the OnExecute event handler to distinguish
  39.  *          between actions.
  40.  */
  41. class ActionList extends Component
  42. {
  43.         protected $_actions = array();
  44.         protected $_onexecute = null;
  45.  
  46.  
  47.         function __construct($aowner=null)
  48.         {
  49.                 //Calls inherited constructor
  50.                 parent::__construct($aowner);
  51.         }
  52.  
  53.         function init()
  54.         {
  55.                 parent::init();
  56.  
  57.                 $action = $this->input->{$this->_name};
  58.                 if (is_object($action))
  59.                 {
  60.                         $this->executeAction($action->asString());
  61.                 }
  62.         }
  63.  
  64.         /**
  65.         * Add a new action to the Actions array.
  66.         * @param string $action  Name of the action.
  67.         */
  68.         function addAction($action)
  69.         {
  70.                 $this->_actions[] = $action;
  71.         }
  72.  
  73.         /**
  74.         * Deletes an action from the Actions array.
  75.         * @param string $action  Name of the action.
  76.         */
  77.         function deleteAction($action)
  78.         {
  79.                 if (in_array($action, $this->_actions))
  80.                 {
  81.                         $key = array_search($action, $this->_actions);
  82.                         array_splice($this->_actions, $key, 1);
  83.                 }
  84.         }
  85.  
  86.         /**
  87.         * Generates an OnExecute event.
  88.         * @param string $action  Name of the action.
  89.         * @return bool Returns true if the OnExecute event was successfully called,
  90.         *               false otherwise.
  91.         */
  92.         function executeAction($action)
  93.         {
  94.                 // only execute the action if a handler has been assigned and
  95.                 // the action is in the list
  96.                 if ($this->_onexecute != null && in_array($action, $this->_actions))
  97.                 {
  98.                         return $this->callEvent('onexecute', array("action" => $action));
  99.                 }
  100.                 // action was not handled
  101.                 return false;
  102.         }
  103.  
  104.         /**
  105.         * Add an action to an URL.
  106.         * Note: Currently only one action per ActionList and URL can be added.
  107.         *       If more actions of the same list are added the behavior is undefined.
  108.         * @param string $action  Name of the action.
  109.         * @param string $url     An URL to another script. If empty the same
  110.         *                         script as ActionList is defined will be called.
  111.         * @return bool Returns true if the action was successfully added to the
  112.         *               URL, false otherwise.
  113.         */
  114.         function expandActionToURL($action, &$url)
  115.         {
  116.                 // get the key of the action (if exists);
  117.                 if (in_array($action, $this->_actions))
  118.                 {
  119.                         $key = array_search($action, $this->_actions);
  120.  
  121.                         // check if the query already started
  122.                         $url .= (strpos($url, '?') === false) ? "?" : "&";
  123.                         // expand the URL with the action
  124.                         $url .= urlencode($this->_name)."=".urlencode($this->_actions[$key]);
  125.                         return true;
  126.                 }
  127.  
  128.                 // attachActionToURL failed to expand the URL
  129.                 return false;
  130.         }
  131.  
  132.         /**
  133.         * OnExecute event
  134.         * Occurs when a web request contained an action of the list.
  135.         * Use the $params argument passed to the event handler to get the name
  136.         * of the executed action (e.g. $params["action"]).
  137.         * @return mixed 
  138.         */
  139.         function getOnExecute() { return $this->_onexecute; }
  140.         /**
  141.         * OnExecute event
  142.         * Occurs when a web request contained an action of the list.
  143.         * Use the $params argument passed to the event handler to get the name
  144.         * of the executed action (e.g. $params["action"]).
  145.         * @param mixed $value 
  146.         */
  147.         function setOnExecute($value) { $this->_onexecute=$value; }
  148.         function defaultOnExecute() { return null; }
  149.  
  150.         /**
  151.         * Array of all actions in the list.
  152.         * Use addAction() and deleteAction() to modify the array easily.
  153.         * @return array 
  154.         */
  155.         function getActions() { return $this->_actions; }
  156.         /**
  157.         * Array of all actions in the list.
  158.         * Use addAction() and deleteAction() to modify the array easily.
  159.         * @param array $value 
  160.         */
  161.         function setActions($value) { $this->_actions=$value; }
  162.         function defaultActions() { return array(); }
  163.  
  164.  
  165.  
  166. }
  167.  
  168. ?>
Documentation generated on Tue, 27 Mar 2007 13:33:13 +0200 by phpDocumentor 1.3.1