xajax.inc.php

Joomla!是一套获得过多个奖项的内容管理系统(Content Management System, CMS)。Joomla!采用PHP+MySQL数据库开发

<?php
///////////////////////////////////////////////////////////////////////////////
// xajax.inc.php::Main xajax class and setup file
//
// xajax version 0.2
// Copyright (C) 2005 - 2006 by Jared White & J. Max Wilson
// http://xajax.sourceforge.net
//
// xajax is an open source PHP class library for easily creating powerful
// PHP-driven, web-based AJAX Applications. Using xajax, you can asynchronously
// call PHP functions and update the content of your your webpage without
// reloading the page.
//
// xajax is released under the terms of the LGPL license
// http://www.gnu.org/copyleft/lesser.html#SEC3
//
// This library 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 library 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 library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
///////////////////////////////////////////////////////////////////////////////

// Define XAJAX_DEFAULT_CHAR_ENCODING that is used by both
// the xajax and xajaxResponse classes
if (!defined ('XAJAX_DEFAULT_CHAR_ENCODING')) {
	define ('XAJAX_DEFAULT_CHAR_ENCODING', 'utf-8' );
}

require_once(dirname( __FILE__ ).DIRECTORY_SEPARATOR."xajaxResponse.inc.php");

// Communication Method Defines
if (!defined ('XAJAX_GET'))
{
	define ('XAJAX_GET', 0);
}
if (!defined ('XAJAX_POST'))
{
	define ('XAJAX_POST', 1);
}

// the xajax class generates the xajax javascript for your page including the
// javascript wrappers for the PHP functions that you want to call from your page.
// It also handles processing and executing the command messages in the xml responses
// sent back to your page from your PHP functions.
class xajax
{
	var $aFunctions;				// Array of PHP functions that will be callable through javascript wrappers
	var $aObjects;				// Array of object callbacks that will allow Javascript to call PHP methods (key=function name)
	var $aFunctionRequestTypes;	// Array of RequestTypes to be used with each function (key=function name)
	var $aFunctionIncludeFiles;	// Array of Include Files for any external functions (key=function name)
	var $sCatchAllFunction;		// Name of the PHP function to call if no callable function was found
	var $sPreFunction;			// Name of the PHP function to call before any other function
	var $sRequestURI;			// The URI for making requests to the xajax object
	var $bDebug;					// Show debug messages (true/false)
	var $bExitAllowed;			// Allow xajax to exit after processing a request (true/false)
	var $bErrorHandler;			// Use an special xajax error handler so the errors are sent to the browser properly
	var $sLogFile;				// Specify if xajax should log errors (and more information in a future release)
	var $sWrapperPrefix;			// The prefix to prepend to the javascript wraper function name
	var $bStatusMessages;			// Show debug messages (true/false)
	var $bWaitCursor;			// Use wait cursor in browser (true/false)
	var $bCleanBuffer;			// Clean all output buffers before outputting response (true/false)
	var $aObjArray;				// Array for parsing complex objects
	var $iPos;					// Position in $aObjArray
	var $sEncoding;				// The Character Encoding to use

	// Contructor
	// $sRequestURI - defaults to the current page
	// $sWrapperPrefix - defaults to "xajax_";
	// $sEncoding - defaults to XAJAX_DEFAULT_CHAR_ENCODING defined above
	// $bDebug Mode - defaults to false
	// usage: $xajax = new xajax();
	function xajax($sRequestURI="",$sWrapperPrefix="xajax_",$sEncoding=XAJAX_DEFAULT_CHAR_ENCODING,$bDebug=false)
	{
		$this->aFunctions = array();
		$this->aObjects = array();
		$this->aFunctionIncludeFiles = array();
		$this->sRequestURI = $sRequestURI;
		if ($this->sRequestURI == "")
			$this->sRequestURI = $this->_detectURI();
		$this->sWrapperPrefix = $sWrapperPrefix;
		$this->setCharEncoding($sEncoding);
		$this->bDebug = $bDebug;
		$this->bWaitCursor = true;
		$this->bExitAllowed = true;
		$this->bErrorHandler = false;
		$this->sLogFile = "";
		$this->bCleanBuffer = true;
	}

	// setRequestURI() sets the URI to which requests will be made
	// usage: $xajax->setRequestURI("http://xajax.sourceforge.net");
	function setRequestURI($sRequestURI)
	{
		$this->sRequestURI = $sRequestURI;
	}

	// debugOn() enables debug messages for xajax
	function debugOn()
	{
		$this->bDebug = true;
	}

	// debugOff() disables debug messages for xajax (default behavior)
	function debugOff()
	{
		$this->bDebug = false;
	}

	// statusMessagesOn() enables messages in the statusbar for xajax
	function statusMessagesOn()
	{
		$this->bStatusMessages = true;
	}

	// statusMessagesOff() disables messages in the statusbar for xajax (default behavior)
	function statusMessagesOff()
	{
		$this->bStatusMessages = false;
	}

	// waitCursor() enables the wait cursor to be displayed in the browser (default behavior)
	function waitCursorOn()
	{
		$this->bWaitCursor = true;
	}

	// waitCursorOff() disables the wait cursor to be displayed in the browser
	function waitCursorOff()
	{
		$this->bWaitCursor = false;
	}

	// exitAllowedOn() enables xajax to exit immediately after processing a request
	// and sending the response back to the browser (default behavior)
	function exitAllowedOn()
	{
		$this->bExitAllowed = true;
	}

	// exitAllowedOff() disables xajax's default behavior of exiting immediately
	// after processing a request and sending the response back to the browser
	function exitAllowedOff()
	{
		$this->bExitAllowed = false;
	}

	// errorHandlerOn() turns on xajax's error handling system so that PHP errors
	// that occur during a request are trapped and pushed to the browser in the
	// form of a Javascript alert
	function errorHandlerOn()
	{
		$this->bErrorHandler = true;
	}
	// errorHandlerOff() turns off xajax's error handling system (default behavior)
	function errorHandlerOff()
	{
		$this->bErrorHandler = false;
	}

	// setLogFile() specifies a log file that will be written to by xajax during
	// a request (used only by the error handling system at present). If you don't
	// invoke this method, or you pass in "", then no log file will be written to.
	// usage: $xajax->setLogFile("/xajax_logs/errors.log");
	function setLogFile($sFilename)
	{
		$this->sLogFile = $sFilename;
	}

	// cleanBufferOn() causes xajax to clean out all output buffers before outputting
	// a response (default behavior)
	function cleanBufferOn()
	{
		$this->bCleanBuffer = true;
	}
	// cleanBufferOff() turns off xajax's output buffer cleaning
	function cleanBufferOff()
	{
		$this->bCleanBuffer = false;
	}

	// setWrapperPrefix() sets the prefix that will be appended to the Javascript
	// wrapper functions (default is "xajax_").
	function setWrapperPrefix($sPrefix)
	{
		$this->sWrapperPrefix = $sPrefix;
	}

	// setCharEncoding() sets the character encoding to be used by xajax
	// usage: $xajax->setCharEncoding("utf-8");
	// *Note: to change the default character encoding for all xajax responses, set
	// the XAJAX_DEFAULT_CHAR_ENCODING constant near the beginning of the xajax.inc.php file
	function setCharEncoding($sEncoding)
	{
		$this->sEncoding = $sEncoding;
	}

	// registerFunction() registers a PHP function or method to be callable through
	// xajax in your Javascript. If you want to register a function, pass in the name
	// of that function. If you want to register a static class method, pass in an array
	// like so:
	// array("myFunctionName", "myClass", "myMethod")
	// For an object instance method, use an object variable for the second array element
	// (and in PHP 4 make sure you put an & before the variable to pass the object by
	// reference). Note: the function name is what you call via Javascript, so it can be
	// anything as long as it doesn't conflict with any other registered function name.
	//
	// $mFunction is a string containing the function name or an object callback array
	// $sRequestType is the RequestType (XAJAX_GET/XAJAX_POST) that should be used
	//		for this function.  Defaults to XAJAX_POST.
	// usage: $xajax->registerFunction("myFunction");
	//    or: $xajax->registerFunction(array("myFunctionName", &$myObject, "myMethod"));
	function registerFunction($mFunction,$sRequestType=XAJAX_POST)
	{
		if (is_array($mFunction)) {
			$this->aFunctions[$mFunction[0]] = 1;
			$this->aFunctionRequestTypes[$mFunction[0]] = $sRequestType;
			$this->aObjects[$mFunction[0]] = array_slice($mFunction, 1);
		}
		else {
			$this->aFunctions[$mFunction] = 1;
			$this->aFunctionRequestTypes[$mFunction] = $sRequestType;
		}
	}

	// registerExternalFunction() registers a PHP function to be callable through xajax
	// which is located in some other file.  If the function is requested the external
	// file will be included to define the function before the function is called
	// $mFunction is a string containing the function name or an object callback array
	//   see registerFunction() for more info on object callback arrays
	// $sIncludeFile is a string containing the path and filename of the include file
	// $sRequestType is the RequestType (XAJAX_GET/XAJAX_POST) that should be used
	//		for this function.  Defaults to XAJAX_POST.
	// usage: $xajax->registerExternalFunction("myFunction","myFunction.inc.php",XAJAX_POST);
	function registerExternalFunction($mFunction,$sIncludeFile,$sRequestType=XAJAX_POST)
	{
		$this->registerFunction($mFunction, $sRequestType);

		if (is_array($mFunction)) {
			$this->aFunctionIncludeFiles[$mFunction[0]] = $sIncludeFile;
		}
		else {
			$this->aFunctionIncludeFiles[$mFunction] = $sIncludeFile;
		}
	}

	// registerCatchAllFunction() registers a PHP function to be called when xajax cannot
	// find the function being called via Javascript. Because this is technically
	// impossible when using "wrapped" functions, the catch-all feature is only useful
	// when you're directly using the xajax.call() Javascript method. Use the catch-all
	// feature when you want more dynamic ability to intercept unknown calls and handle
	// them in a custom way.
	// $mFunction is a string containing the function name or an object callback array
	//   see registerFunction() for more info on object callback arrays
	// usage: $xajax->registerCatchAllFunction("myCatchAllFunction");
	function registerCatchAllFunction($mFunction)
	{
		if (is_array($mFunction)) {
			$this->sCatchAllFunction = $mFunction[0];
			$this->aObjects[$mFunction[0]] = array_slice($mFunction, 1);
		}
		else {
			$this->sCatchAllFunction = $mFunction;
		}
	}

	// registerPreFunction() registers a PHP function to be called before xajax calls
	// the requested function. xajax will automatically add the request function's response
	// to the pre-function's response to create a single response. Another feature is
	// the ability to return not just a response, but an array with the first element
	// being false (a boolean) and the second being the response. In this case, the
	// pre-function's response will be returned to the browser without xajax calling
	// the requested function.
	// $mFunction is a string containing the function name or an object callback array
	//   see registerFunction() for more info on object callback arrays
	// usage $xajax->registerPreFunction("myPreFunction");
	function registerPreFunction($mFunction)
	{
		if (is_array($mFunction)) {
			$this->sPreFunction = $mFunction[0];
			$this->aObjects[$mFunction[0]] = array_slice($mFunction, 1);
		}
		else {
			$this->sPreFunction = $mFunction;
		}
	}

	// returns true if xajax can process the request, false if otherwise
	// you can use this to determine if xajax needs to process the request or not
	function canProcessRequests()
	{
		if ($this->getRequestMode() != -1) return true;
		return false;
	}

	// returns the current request mode, or -1 if there is none
	function getRequestMode()
	{
		if (!empty($_GET["xajax"]))
			return XAJAX_GET;

		if (!empty($_POST["xajax"]))
			return XAJAX_POST;

		return -1;
	}

	// processRequests() is the main communications engine of xajax
	// The engine handles all incoming xajax requests, calls the apporiate PHP functions
	// and passes the xml responses back to the javascript response handler
	// if your RequestURI is the same as your web page then this function should
	// be called before any headers or html has been sent.
	// usage: $xajax->processRequests()
	function processRequests()
	{

		$requestMode = -1;
		$sFunctionName = "";
		$bFoundFunction = true;
		$bFunctionIsCatchAll = false;
		$sFunctionNameForSpecial = "";
		$aArgs = array();
		$sPreResponse = "";
		$bEndRequest = false;
		$sResponse = "";

		$requestMode = $this->getRequestMode();
		if ($requestMode == -1) return;

		if ($requestMode == XAJAX_POST)
		{
			$sFunctionName = $_POST["xajax"];

			if (!empty($_POST["xajaxargs"]))
				$aArgs = $_POST["xajaxargs"];
		}
		else
		{
			header ("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
			header ("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
			header ("Cache-Control: no-cache, must-revalidate");
			header ("Pragma: no-cache");
			header("Content-type: text/xml");

			$sFunctionName = $_GET["xajax"];

			if (!empty($_GET["xajaxargs"]))
				$aArgs = $_GET["xajaxargs"];
		}

		// Use xajax error handler if necessary
		if ($this->bErrorHandler) {
			$GLOBALS['xajaxErrorHandlerText'] = "";
			set_error_handler("xajaxErrorHandler");
		}

		if ($this->sPreFunction) {
			if (!$this->_isFunctionCallable($this->sPreFunction)) {
				$bFoundFunction = false;
				$objResponse = new xajaxResponse();
				$objResponse->addAlert("Unknown Pre-Function ". $this->sPreFunction);
				$sResponse = $objResponse->getXML();
			}
		}
		//include any external dependencies associated with this function name
		if (array_key_exists($sFunctionName,$this->aFunctionIncludeFiles))
		{
			ob_start();
			include_once($this->aFunctionIncludeFiles[$sFunctionName]);
			ob_end_clean();
		}

		if ($bFoundFunction) {
			$sFunctionNameForSpecial = $sFunctionName;
			if (!array_key_exists($sFunctionName, $this->aFunctions))
			{
				if ($this->sCatchAllFunction) {
					$sFunctionName = $this->sCatchAllFunction;
					$bFunctionIsCatchAll = true;
				}
				else {
					$bFoundFunction = false;
					$objResponse = new xajaxResponse();
					$objResponse->addAlert("Unknown Function $sFunctionName.");
					$sResponse = $objResponse->getXML();
				}
			}
			else if ($this->aFunctionRequestTypes[$sFunctionName] != $requestMode)
			{
				$bFoundFunction = false;
				$objResponse = new xajaxResponse();
				$objResponse->addAlert("Incorrect Request Type.");
				$sResponse = $objResponse->getXML();
			}
		}

		if ($bFoundFunction)
		{
			for ($i = 0; $i < sizeof($aArgs); $i++)
			{
				// If magic quotes is on, then we need to strip the slashes from the args
				if (get_magic_quotes_gpc() == 1 && is_string($aArgs[$i])) {

					$aArgs[$i] = stripslashes($aArgs[$i]);
				}
				if (stristr($aArgs[$i],"<xjxobj>") != false)
				{
					$aArgs[$i] = $this->_xmlToArray("xjxobj",$aArgs[$i]);
				}
				else if (stristr($aArgs[$i],"<xjxquery>") != false)
				{
					$aArgs[$i] = $this->_xmlToArray("xjxquery",$aArgs[$i]);
				}
			}

			if ($this->sPreFunction) {
				$mPreResponse = $this->_callFunction($this->sPreFunction, array($sFunctionNameForSpecial, $aArgs));
				if (is_array($mPreResponse) && $mPreResponse[0] === false) {
					$bEndRequest = true;
					$sPreResponse = $mPreResponse[1];