Context Navigation

xajaxResponse.inc.php @ 366

Revision 259, 39.9 KB (checked in by exi, 14 years ago)
Including the xajax mod into svn

Line
1	<?php
2	/*
3	File: xajaxResponse.inc.php
4
5	Contains the response class.
6
7	Title: xajax response class
8
9	Please see <copyright.inc.php> for a detailed description, copyright
10	and license information.
11	*/
12
13	/*
14	@package xajax
15	@version $Id: xajaxResponse.inc.php 361 2007-05-24 12:48:14Z calltoconstruct $
16	@copyright Copyright (c) 2005-2006 by Jared White & J. Max Wilson
17	@license http://www.xajaxproject.org/bsd_license.txt BSD License
18	*/
19
20	/*
21	Class: xajaxResponse
22
23	Collect commands to be sent back to the browser in response to a xajax
24	request. Commands are encoded and packaged in a format that is acceptable
25	to the response handler from the javascript library running on the client
26	side.
27
28	Common commands include:
29	- <xajaxResponse->assign>: Assign a value to an elements property.
30	- <xajaxResponse->append>: Append a value on to an elements property.
31	- <xajaxResponse->script>: Execute a portion of javascript code.
32	- <xajaxResponse->call>: Execute an existing javascript function.
33	- <xajaxResponse->alert>: Display an alert dialog to the user.
34
35	Elements are identified by the value of the HTML id attribute. If you do
36	not see your updates occuring on the browser side, ensure that you are
37	using the correct id in your response.
38	*/
39	class xajaxResponse
40	{
41	/**#@+
42	* @access protected
43	*/
44
45	/*
46	Array: aCommands
47
48	Stores the commands that will be sent to the browser in the response.
49	*/
50	var $aCommands;
51
52	/*
53	String: sCharacterEncoding
54
55	The name of the encoding method you wish to use when dealing with
56	special characters. See <xajax->setEncoding> for more information.
57	*/
58	var $sCharacterEncoding;
59
60	/*
61	Boolean: bOutputEntities
62
63	Convert special characters to the HTML equivellent. See also
64	<xajax->bOutputEntities> and <xajax->setFlag>.
65	*/
66	var $bOutputEntities;
67
68	/*
69	Mixed: returnValue
70
71	A string, array or integer value to be returned to the caller when
72	using 'synchronous' mode requests. See <xajax->setMode> for details.
73	*/
74	var $returnValue;
75
76	/*
77	Object: objPluginManager
78
79	A reference to the global plugin manager.
80	*/
81	var $objPluginManager;
82
83	/*#@-/
84
85	/*
86	Constructor: xajaxResponse
87
88	Create and initialize a xajaxResponse object.
89	*/
90	function xajaxResponse()
91	{
92	//SkipDebug
93	if (0 < func_num_args()) {
94	$objLanguageManager =& xajaxLanguageManager::getInstance();
95	trigger_error(
96	$objLanguageManager->getText('XJXRSP:EDERR:01')
97	, E_USER_ERROR
98	);
99	}
100	//EndSkipDebug
101
102	$this->aCommands = array();
103
104	$objResponseManager =& xajaxResponseManager::getInstance();
105
106	$this->sCharacterEncoding = $objResponseManager->getCharacterEncoding();
107	$this->bOutputEntities = $objResponseManager->getOutputEntities();
108
109	$this->objPluginManager =& xajaxPluginManager::getInstance();
110	}
111
112	/*
113	Function: setCharacterEncoding
114
115	Overrides the default character encoding (or the one specified in the
116	constructor) to the specified character encoding.
117
118	sCharacterEncoding - (string): The encoding method to use for this response.
119
120	See also, <xajaxResponse->xajaxResponse>()
121
122	Returns:
123
124	object - The xajaxResponse object.
125	*/
126	function setCharacterEncoding($sCharacterEncoding)
127	{
128	$this->sCharacterEncoding = $sCharacterEncoding;
129	return $this;
130	}
131
132	/*
133	Function: setOutputEntities
134
135	Convert special characters to their HTML equivellent automatically
136	(only works if the mb_string extension is available).
137
138	bOption - (boolean): Convert special characters
139
140	Returns:
141
142	object - The xajaxResponse object.
143	*/
144	function setOutputEntities($bOutputEntities)
145	{
146	$this->bOutputEntities = (boolean)$bOutputEntities;
147	return $this;
148	}
149
150	/*
151	Function: plugin
152
153	Provides access to registered response plugins. If you are using PHP
154	4 or 5, pass the plugin name as the first argument, the plugin method
155	name as the second argument and subsequent arguments (if any) to be
156	passed along to the plugin.
157
158	Optionally, if you use PHP 5, you can pass just the plugin name as the
159	first argument and the plugin object will be returned. You can then
160	access the methods of the plugin directly.
161
162	sName - (string): Name of the plugin.
163	sFunction - (string, optional): The name of the method to call.
164	arg1...argn - (mixed, optional): Additional arguments to pass on to
165	the plugin function.
166
167	Returns:
168
169	object - The plugin specified by sName.
170	*/
171	function &plugin()
172	{
173	$aArgs = func_get_args();
174	$nArgs = func_num_args();
175
176	//SkipDebug
177	if (false == (0 < $nArgs)) {
178	$objLanguageManager =& xajaxLanguageManager::getInstance();
179	trigger_error(
180	$objLanguageManager->getText('XJXRSP:MPERR:01')
181	, E_USER_ERROR
182	);
183	}
184	//EndSkipDebug
185
186	$sName = array_shift($aArgs);
187
188	$objPlugin =& $this->objPluginManager->getPlugin($sName);
189
190	if (false === $objPlugin)
191	{
192	$bReturn = false;
193	return $bReturn;
194	}
195
196	$objPlugin->setResponse($this);
197
198	if (0 < count($aArgs))
199	{
200	$sMethod = array_shift($aArgs);
201
202	$aFunction = array(&$objPlugin, $sMethod);
203	call_user_func_array($aFunction, $aArgs);
204	}
205
206	return $objPlugin;
207	}
208
209	/*
210	Function: __get
211
212	Magic function for PHP 5. Used to permit plugins to be called as if they
213	where native members of the xajaxResponse instance.
214
215	sPluginName - (string): The name of the plugin.
216
217	Returns:
218
219	object - The plugin specified by sPluginName.
220	*/
221	function &__get($sPluginName)
222	{
223	$objPlugin =& $this->plugin($sPluginName);
224	return $objPlugin;
225	}
226
227	/*
228	Function: confirmCommands
229
230	Response command that prompts user with [ok] [cancel] style
231	message box. If the user clicks cancel, the specified
232	number of response commands following this one, will be
233	skipped.
234
235	iCmdNumber - (integer): The number of commands to skip upon cancel.
236	sMessage - (string): The message to display to the user.
237
238	Returns:
239
240	object - The xajaxResponse object.
241	*/
242	function confirmCommands($iCmdNumber, $sMessage)
243	{
244	return $this->addCommand(
245	array(
246	'n'=>'cc',
247	't'=>$iCmdNumber
248	),
249	$sMessage
250	);
251	}
252
253	/*
254	Function: assign
255
256	Response command indicating that the specified value should be
257	assigned to the given element's attribute.
258
259	sTarget - (string): The id of the html element on the browser.
260	sAttribute - (string): The property to be assigned.
261	sData - (string): The value to be assigned to the property.
262
263	Returns:
264
265	object - The <xajaxResponse> object.
266
267	Example:
268
269	$objResponse->assign("contentDiv", "innerHTML", "Some Text");
270	*/
271	function assign($sTarget,$sAttribute,$sData)
272	{
273	return $this->addCommand(
274	array(
275	'n'=>'as',
276	't'=>$sTarget,
277	'p'=>$sAttribute
278	),
279	$sData
280	);
281	}
282
283	/*
284	Function: append
285
286	Response command that indicates the specified data should be appended
287	to the given element's property.
288
289	sTarget - (string): The id of the element to be updated.
290	sAttribute - (string): The name of the property to be appended to.
291	sData - (string): The data to be appended to the property.
292
293	Returns:
294
295	object - The <xajaxResponse> object.
296	*/
297	function append($sTarget,$sAttribute,$sData)
298	{
299	return $this->addCommand(
300	array(
301	'n'=>'ap',
302	't'=>$sTarget,
303	'p'=>$sAttribute
304	),
305	$sData
306	);
307	}
308
309	/*
310	Function: prepend
311
312	Response command to prepend the specified value onto the given
313	element's property.
314
315	sTarget - (string): The id of the element to be updated.
316	sAttribute - (string): The property to be updated.
317	sData - (string): The value to be prepended.
318
319	Returns:
320
321	object - The <xajaxResponse> object.
322	*/
323	function prepend($sTarget,$sAttribute,$sData)
324	{
325	return $this->addCommand(
326	array(
327	'n'=>'pp',
328	't'=>$sTarget,
329	'p'=>$sAttribute
330	),
331	$sData
332	);
333	}
334
335	/*
336	Function: replace
337
338	Replace a specified value with another value within the given
339	element's property.
340
341	sTarget - (string): The id of the element to update.
342	sAttribute - (string): The property to be updated.
343	sSearch - (string): The needle to search for.
344	sData - (string): The data to use in place of the needle.
345	*/
346	function replace($sTarget,$sAttribute,$sSearch,$sData)
347	{
348	return $this->addCommand(
349	array(
350	'n'=>'rp',
351	't'=>$sTarget,
352	'p'=>$sAttribute
353	),
354	array(
355	's' => $sSearch,
356	'r' => $sData
357	)
358	);
359	}
360
361	/*
362	Function: clear
363
364	Response command used to clear the specified property of the
365	given element.
366
367	sTarget - (string): The id of the element to be updated.
368	sAttribute - (string): The property to be clared.
369
370	Returns:
371
372	object - The <xajaxResponse> object.
373	*/
374	function clear($sTarget,$sAttribute)
375	{
376	return $this->assign(
377	$sTarget,
378	$sAttribute,
379	''
380	);
381	}
382
383	/*
384	Function: contextAssign
385
386	Response command used to assign a value to a member of a
387	javascript object (or element) that is specified by the context
388	member of the request. The object is referenced using the 'this' keyword
389	in the sAttribute parameter.
390
391	sAttribute - (string): The property to be updated.
392	sData - (string): The value to assign.
393
394	Returns:
395
396	object - The <xajaxResponse> object.
397	*/
398	function contextAssign($sAttribute, $sData)
399	{
400	return $this->addCommand(
401	array(
402	'n'=>'c:as',
403	'p'=>$sAttribute
404	),
405	$sData
406	);
407	}
408
409	/*
410	Function: contextAppend
411
412	Response command used to append a value onto the specified member
413	of the javascript context object (or element) specified by the context
414	member of the request. The object is referenced using the 'this' keyword
415	in the sAttribute parameter.
416
417	sAttribute - (string): The member to be appended to.
418	sData - (string): The value to append.
419
420	Returns:
421
422	object - The <xajaxResponse> object.
423	*/
424	function contextAppend($sAttribute, $sData)
425	{
426	return $this->addCommand(
427	array(
428	'n'=>'c:ap',
429	'p'=>$sAttribute
430	),
431	$sData
432	);
433	}
434
435	/*
436	Function: contextPrepend
437
438	Response command used to prepend the speicified data to the given
439	member of the current javascript object specified by context in the
440	current request. The object is access via the 'this' keyword in the
441	sAttribute parameter.
442
443	sAttribute - (string): The member to be updated.
444	sData - (string): The value to be prepended.
445
446	Returns:
447
448	object - The <xajaxResponse> object.
449	*/
450	function contextPrepend($sAttribute, $sData)
451	{
452	return $this->addCommand(
453	array(
454	'n'=>'c:pp',
455	'p'=>$sAttribute
456	),
457	$sData
458	);
459	}
460
461	/*
462	Function: contextClear
463
464	Response command used to clear the value of the property specified
465	in the sAttribute parameter. The member is access via the 'this'
466	keyword and can be used to update a javascript object specified
467	by context in the request parameters.
468
469	sAttribute - (string): The member to be cleared.
470
471	Returns:
472
473	object - The <xajaxResponse> object.
474	*/
475	function contextClear($sAttribute)
476	{
477	return $this->contextAssign(
478	$sAttribute,
479	''
480	);
481	}
482
483	/*
484	Function: alert
485
486	Response command that is used to display an alert message to the user.
487
488	sMsg - (string): The message to be displayed.
489
490	Returns:
491
492	object - The <xajaxResponse> object.
493	*/
494	function alert($sMsg)
495	{
496	return $this->addCommand(
497	array(
498	'n'=>'al'
499	),
500	$sMsg
501	);
502	}
503
504	function debug($sMessage)
505	{
506	return $this->addCommand(
507	array(
508	'n'=>'dbg'
509	),
510	$sMessage
511	);
512	}
513
514	/*
515	Function: redirect
516
517	Response command that causes the browser to navigate to the specified
518	URL.
519
520	sURL - (string): The relative or fully qualified URL.
521	iDelay - (integer, optional): Number of seconds to delay before
522	the redirect occurs.
523
524	Returns:
525
526	object - The <xajaxResponse> object.
527	*/
528	function redirect($sURL, $iDelay=0)
529	{
530	//we need to parse the query part so that the values are rawurlencode()'ed
531	//can't just use parse_url() cos we could be dealing with a relative URL which
532	// parse_url() can't deal with.
533	$queryStart = strpos($sURL, '?', strrpos($sURL, '/'));
534	if ($queryStart !== FALSE)
535	{
536	$queryStart++;
537	$queryEnd = strpos($sURL, '#', $queryStart);
538	if ($queryEnd === FALSE)
539	$queryEnd = strlen($sURL);
540	$queryPart = substr($sURL, $queryStart, $queryEnd-$queryStart);
541	parse_str($queryPart, $queryParts);
542	$newQueryPart = "";
543	if ($queryParts)
544	{
545	$first = true;
546	foreach($queryParts as $key => $value)
547	{
548	if ($first)
549	$first = false;
550	else
551	$newQueryPart .= ini_get('arg_separator.output');
552	$newQueryPart .= rawurlencode($key).'='.rawurlencode($value);
553	}
554	} else if ($_SERVER['QUERY_STRING']) {
555	//couldn't break up the query, but there's one there
556	//possibly "http://url/page.html?query1234" type of query?
557	//just encode it and hope it works
558	$newQueryPart = rawurlencode($_SERVER['QUERY_STRING']);
559	}
560	$sURL = str_replace($queryPart, $newQueryPart, $sURL);
561	}
562	if ($iDelay)
563	$this->script(
564	'window.setTimeout("window.location = \''
565	. $sURL
566	. '\';",'
567	. ($iDelay*1000)
568	. ');'
569	);
570	else
571	$this->script(
572	'window.location = "'
573	. $sURL
574	. '";'
575	);
576	return $this;
577	}
578
579	/*
580	Function: script
581
582	Response command that is used to execute a portion of javascript on
583	the browser. The script runs in it's own context, so variables declared
584	locally, using the 'var' keyword, will no longer be available after the
585	call. To construct a variable that will be accessable globally, even
586	after the script has executed, leave off the 'var' keyword.
587
588	sJS - (string): The script to execute.
589
590	Returns:
591
592	object - The <xajaxResponse> object.
593	*/
594	function script($sJS)
595	{
596	return $this->addCommand(
597	array(
598	'n'=>'js'
599	),
600	$sJS
601	);
602	}
603
604	/*
605	Function: call
606
607	Response command that indicates that the specified javascript
608	function should be called with the given (optional) parameters.
609
610	arg1 - (string): The name of the function to call.
611	arg2 .. argn - arguments to be passed to the function.
612
613	Returns:
614
615	object - The <xajaxResponse> object.
616	*/
617	function call() {
618	$aArgs = func_get_args();
619	$sFunc = array_shift($aArgs);
620	return $this->addCommand(
621	array(
622	'n'=>'jc',
623	'f'=>$sFunc
624	),
625	$aArgs
626	);
627	}
628
629	/*
630	Function: remove
631
632	Response command used to remove an element from the document.
633
634	sTarget - (string): The id of the element to be removed.
635
636	Returns:
637
638	object - The <xajaxResponse> object.
639	*/
640	function remove($sTarget)
641	{
642	return $this->addCommand(
643	array(
644	'n'=>'rm',
645	't'=>$sTarget),
646	''
647	);
648	}
649
650	/*
651	Function: create
652
653	Response command used to create a new element on the browser.
654
655	sParent - (string): The id of the parent element.
656	sTag - (string): The tag name to be used for the new element.
657	sId - (string): The id to assign to the new element.
658	sType - (string, optional): The type of tag, deprecated, use
659	<xajaxResponse->createInput> instead.
660
661	Returns:
662
663	object - The <xajaxResponse> object.
664	*/
665	function create($sParent, $sTag, $sId, $sType=null)
666	{
667	//SkipDebug
668	if (false === (null === $sType)) {
669	$objLanguageManager =& xajaxLanguageManager::getInstance();
670	trigger_error(
671	$objLanguageManager->getText('XJXRSP:CPERR:01')
672	, E_USER_WARNING
673	);
674	}
675	//EndSkipDebug
676
677	return $this->addCommand(
678	array(
679	'n'=>'ce',
680	't'=>$sParent,
681	'p'=>$sId
682	),
683	$sTag
684	);
685	}
686
687	/*
688	Function: insert
689
690	Response command used to insert a new element just prior to the specified
691	element.
692
693	sBefore - (string): The element used as a reference point for the
694	insertion.
695	sTag - (string): The tag to be used for the new element.
696	sId - (string): The id to be used for the new element.
697
698	Returns:
699
700	object - The <xajaxResponse> object.
701	*/
702	function insert($sBefore, $sTag, $sId)
703	{
704	return $this->addCommand(
705	array(
706	'n'=>'ie',
707	't'=>$sBefore,
708	'p'=>$sId
709	),
710	$sTag
711	);
712	}
713
714	/*
715	Function: insertAfter
716
717	Response command used to insert a new element after the specified
718	one.
719
720	sAfter - (string): The id of the element that will be used as a reference
721	for the insertion.
722	sTag - (string): The tag name to be used for the new element.
723	sId - (string): The id to be used for the new element.
724
725	Returns:
726
727	object - The <xajaxResponse> object.
728	*/
729	function insertAfter($sAfter, $sTag, $sId)
730	{
731	return $this->addCommand(
732	array(
733	'n'=>'ia',
734	't'=>$sAfter,
735	'p'=>$sId
736	),
737	$sTag
738	);
739	}
740
741	/*
742	Function: createInput
743
744	Response command used to create an input element on the browser.
745
746	sParent - (string): The id of the parent element.
747	sType - (string): The type of the new input element.
748	sName - (string): The name of the new input element.
749	sId - (string): The id of the new element.
750
751	Returns:
752
753	object - The <xajaxResponse> object.
754	*/
755	function createInput($sParent, $sType, $sName, $sId)
756	{
757	return $this->addCommand(
758	array(
759	'n'=>'ci',
760	't'=>$sParent,
761	'p'=>$sId,
762	'c'=>$sType
763	),
764	$sName
765	);
766	}
767
768	/*
769	Function: insertInput
770
771	Response command used to insert a new input element preceeding the
772	specified element.
773
774	sBefore - (string): The id of the element to be used as the reference
775	point for the insertion.
776	sType - (string): The type of the new input element.
777	sName - (string): The name of the new input element.
778	sId - (string): The id of the new input element.
779
780	Returns:
781
782	object - The <xajaxResponse> object.
783	*/
784	function insertInput($sBefore, $sType, $sName, $sId)
785	{
786	return $this->addCommand(
787	array(
788	'n'=>'ii',
789	't'=>$sBefore,
790	'p'=>$sId,
791	'c'=>$sType
792	),
793	$sName
794	);
795	}
796
797	/*
798	Function: insertInputAfter
799
800	Response command used to insert a new input element after the
801	specified element.
802
803	sAfter - (string): The id of the element that is to be used
804	as the insertion point for the new element.
805	sType - (string): The type of the new input element.
806	sName - (string): The name of the new input element.
807	sId - (string): The id of the new input element.
808
809	Returns:
810
811	object - The <xajaxResponse> object.
812	*/
813	function insertInputAfter($sAfter, $sType, $sName, $sId)
814	{
815	return $this->addCommand(
816	array(
817	'n'=>'iia',
818	't'=>$sAfter,
819	'p'=>$sId,
820	'c'=>$sType
821	),
822	$sName
823	);
824	}
825
826	/*
827	Function: setEvent
828
829	Response command used to set an event handler on the browser.
830
831	sTarget - (string): The id of the element that contains the event.
832	sEvent - (string): The name of the event.
833	sScript - (string): The javascript to execute when the event is fired.
834
835	Returns:
836
837	object - The <xajaxResponse> object.
838	*/
839	function setEvent($sTarget,$sEvent,$sScript)
840	{
841	return $this->addCommand(
842	array(
843	'n'=>'ev',
844	't'=>$sTarget,
845	'p'=>$sEvent
846	),
847	$sScript
848	);
849	}
850
851	function addEvent($sTarget,$sEvent,$sScript)
852	{
853	return $this->setEvent(
854	$sTarget,
855	$sEvent,
856	$sScript
857	);
858	}
859
860	/*
861	Function: addHandler
862
863	Response command used to install an event handler on the specified element.
864
865	sTarget - (string): The id of the element.
866	sEvent - (string): The name of the event to add the handler to.
867	sHandler - (string): The javascript function to call when the event is fired.
868
869	You can add more than one event handler to an element's event using this method.
870
871	Returns:
872
873	object - The <xajaxResponse> object.
874	*/
875	function addHandler($sTarget,$sEvent,$sHandler)
876	{
877	return $this->addCommand(
878	array(
879	'n'=>'ah',
880	't'=>$sTarget,
881	'p'=>$sEvent
882	),
883	$sHandler
884	);
885	}
886
887	/*
888	Function: removeHandler
889
890	Response command used to remove an event handler from an element.
891
892	sTarget - (string): The id of the element.
893	sEvent - (string): The name of the event.
894	sHandler - (string): The javascript function that is called when the
895	event is fired.
896
897	Returns:
898
899	object - The <xajaxResponse> object.
900	*/
901	function removeHandler($sTarget,$sEvent,$sHandler)
902	{
903	return $this->addCommand(
904	array(
905	'n'=>'rh',
906	't'=>$sTarget,
907	'p'=>$sEvent
908	),
909	$sHandler);
910	}
911
912	/*
913	Function: setFunction
914
915	Response command used to construct a javascript function on the browser.
916
917	sFunction - (string): The name of the function to construct.
918	sArgs - (string): Comma separated list of parameter names.
919	sScript - (string): The javascript code that will become the body of the
920	function.
921
922	Returns:
923
924	object - The <xajaxResponse> object.
925	*/
926	function setFunction($sFunction, $sArgs, $sScript)
927	{
928	return $this->addCommand(
929	array(
930	'n'=>'sf',
931	'f'=>$sFunction,
932	'p'=>$sArgs
933	),
934	$sScript
935	);
936	}
937
938	/*
939	Function: wrapFunction
940
941	Response command used to construct a wrapper function around
942	and existing javascript function on the browser.
943
944	sFunction - (string): The name of the existing function to wrap.
945	sArgs - (string): The comma separated list of parameters for the function.
946	aScripts - (array): An array of javascript code snippets that will
947	be used to build the body of the function. The first piece of code
948	specified in the array will occur before the call to the original
949	function, the second will occur after the original function is called.
950	sReturnValueVariable - (string): The name of the variable that will
951	retain the return value from the call to the original function.
952
953	Returns:
954
955	object - The <xajaxResponse> object.
956	*/
957	function wrapFunction($sFunction, $sArgs, $aScripts, $sReturnValueVariable)
958	{
959	return $this->addCommand(
960	array(
961	'n'=>'wpf',
962	'f'=>$sFunction,
963	'p'=>$sArgs,
964	'c'=>$sReturnValueVariable
965	),
966	$aScripts
967	);
968	}
969
970	/*
971	Function: includeScript
972
973	Response command used to load a javascript file on the browser.
974
975	sFileName - (string): The relative or fully qualified URI of the
976	javascript file.
977
978	Returns:
979
980	object - The <xajaxResponse> object.
981	*/
982	function includeScript($sFileName)
983	{
984	return $this->addCommand(
985	array(
986	'n'=>'in'
987	),
988	$sFileName
989	);
990	}
991
992	/*
993	Function: includeScriptOnce
994
995	Response command used to include a javascript file on the browser
996	if it has not already been loaded.
997
998	sFileName - (string): The relative for fully qualified URI of the
999	javascript file.
1000
1001	Returns:
1002
1003	object - The <xajaxResponse> object.
1004	*/
1005	function includeScriptOnce($sFileName)
1006	{
1007	return $this->addCommand(
1008	array(
1009	'n'=>'ino'
1010	),
1011	$sFileName
1012	);
1013	}
1014
1015	/*
1016	Function: removeScript
1017
1018	Response command used to remove a SCRIPT reference to a javascript
1019	file on the browser. Optionally, you can call a javascript function
1020	just prior to the file being unloaded (for cleanup).
1021
1022	sFileName - (string): The relative or fully qualified URI of the
1023	javascript file.
1024	sUnload - (string): Name of a javascript function to call prior
1025	to unlaoding the file.
1026
1027	Returns:
1028
1029	object - The <xajaxResponse> object.
1030	*/
1031	function removeScript($sFileName, $sUnload = '') {
1032	$this->addCommand(
1033	array(
1034	'n'=>'rjs'
1035	),
1036	('' != $sUnload)
1037	? array($sFileName, $sUnload)
1038	: $sFileName
1039	);
1040	return $this;
1041	}
1042
1043	/*
1044	Function: includeCSS
1045
1046	Response command used to include a LINK reference to
1047	the specified CSS file on the browser. This will cause the
1048	browser to load and apply the style sheet.
1049
1050	sFileName - (string): The relative or fully qualified URI of
1051	the css file.
1052
1053	Returns:
1054
1055	object - The <xajaxResponse> object.
1056	*/
1057	function includeCSS($sFileName)
1058	{
1059	return $this->addCommand(
1060	array(
1061	'n'=>'css'
1062	),
1063	$sFileName
1064	);
1065	}
1066
1067	/*
1068	Function: removeCSS
1069
1070	Response command used to remove a LINK reference to
1071	a CSS file on the browser. This causes the browser to
1072	unload the style sheet, effectively removing the style
1073	changes it caused.
1074
1075	sFileName - (string): The relative or fully qualified URI
1076	of the css file.
1077
1078	Returns:
1079
1080	object - The <xajaxResponse> object.
1081	*/
1082	function removeCSS($sFileName)
1083	{
1084	return $this->addCommand(
1085	array(
1086	'n'=>'rcss'
1087	),
1088	$sFileName
1089	);
1090	}
1091
1092	/*
1093	Function: waitForCSS
1094
1095	Response command instructing xajax to pause while the CSS
1096	files are loaded. The browser is not typically a multi-threading
1097	application, with regards to javascript code. Therefore, the
1098	CSS files included or removed with <xajaxResponse->includeCSS> and
1099	<xajaxResponse->removeCSS> respectively, will not be loaded or
1100	removed until the browser regains control from the script. This
1101	command returns control back to the browser and pauses the execution
1102	of the response until the CSS files, included previously, are
1103	loaded.
1104
1105	iTimeout - (integer): The number of 1/10ths of a second to pause
1106	before timing out and continuing with the execution of the
1107	response commands.
1108
1109	Returns:
1110
1111	object - The <xajaxResponse> object.
1112	*/
1113	function waitForCSS($iTimeout = 600) {
1114	$sData = "";
1115	$this->addCommand(
1116	array(
1117	'n'=>'wcss',
1118	'p'=>$iTimeout
1119	),
1120	$sData
1121	);
1122	return $this;
1123	}
1124
1125	/*
1126	Function: waitFor
1127
1128	Response command instructing xajax to delay execution of the response
1129	commands until a specified condition is met. Note, this returns control
1130	to the browser, so that other script operations can execute. xajax
1131	will continue to monitor the specified condition and, when it evaulates
1132	to true, will continue processing response commands.
1133
1134	script - (string): A piece of javascript code that evaulates to true
1135	or false.
1136	tenths - (integer): The number of 1/10ths of a second to wait before
1137	timing out and continuing with the execution of the response
1138	commands.
1139
1140	Returns:
1141
1142	object - The <xajaxResponse> object.
1143	*/
1144	function waitFor($script, $tenths) {
1145	return $this->addCommand(
1146	array(
1147	'n'=>'wf',
1148	'p'=>$tenths
1149	),
1150	$script
1151	);
1152	}
1153
1154	/*
1155	Function: sleep
1156
1157	Response command which instructs xajax to pause execution
1158	of the response commands, returning control to the browser
1159	so it can perform other commands asynchronously. After
1160	the specified delay, xajax will continue execution of the
1161	response commands.
1162
1163	tenths - (integer): The number of 1/10ths of a second to
1164	sleep.
1165
1166	Returns:
1167
1168	object - The <xajaxResponse> object.
1169	*/
1170	function sleep($tenths) {
1171	$this->addCommand(
1172	array(
1173	'n'=>'s',
1174	'p'=>$tenths
1175	),
1176	''
1177	);
1178	return $this;
1179	}
1180
1181	/*
1182	Function: setReturnValue
1183
1184	Stores a value that will be passed back as part of the response.
1185	When making synchronous requests, the calling javascript can
1186	obtain this value immediately as the return value of the
1187	<xajax.call> function.
1188
1189	value - (mixed): Any value.
1190
1191	Returns:
1192
1193	object - The <xajaxResponse> object.
1194	*/
1195	function setReturnValue($value) {
1196	$this->returnValue = $this->_encodeArray($value);
1197	return $this;
1198	}
1199
1200	/*
1201	Function: getContentType
1202
1203	Returns the current content type that will be used for the
1204	response packet. (typically: "text/xml")
1205
1206	Returns:
1207
1208	string - The content type.
1209	*/
1210	function getContentType()
1211	{
1212	return 'text/xml';
1213	}
1214
1215	/*
1216	Function: getOutput
1217	*/
1218	function getOutput()
1219	{
1220	ob_start();
1221	$this->_printHeader_XML();
1222	$this->_printResponse_XML();
1223	return ob_get_clean();
1224	}
1225
1226	/*
1227	Function: printOutput
1228
1229	Prints the output, generated from the commands added to the response,
1230	that will be sent to the browser.
1231
1232	Returns:
1233
1234	string - The textual representation of the response commands.
1235	*/
1236	function printOutput()
1237	{
1238	$this->_sendHeaders();
1239	$this->_printHeader_XML();
1240	$this->_printResponse_XML();
1241	}
1242
1243	/*
1244	Function: _sendHeaders
1245
1246	Used internally to generate the response headers.
1247	*/
1248	function _sendHeaders()
1249	{
1250	$objArgumentManager =& xajaxArgumentManager::getInstance();
1251	if (XAJAX_METHOD_GET == $objArgumentManager->getRequestMethod())
1252	{
1253	header ("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
1254	header ("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
1255	header ("Cache-Control: no-cache, must-revalidate");
1256	header ("Pragma: no-cache");
1257	}
1258
1259	$sCharacterSet = '';
1260	if ($this->sCharacterEncoding && 0 < strlen(trim($this->sCharacterEncoding))) {
1261	$sCharacterSet = '; charset="' . trim($this->sCharacterEncoding) . '"';
1262	}
1263
1264	$sContentType = $this->getContentType();
1265
1266	header('content-type: ' . $sContentType . ' ' . $sCharacterSet);
1267	}
1268
1269	/*
1270	Function: getCommandCount
1271
1272	Returns:
1273
1274	integer - The number of commands in the response.
1275	*/
1276	function getCommandCount()
1277	{
1278	return count($this->aCommands);
1279	}
1280
1281	/*
1282	Function: loadCommands
1283
1284	Merges the response commands from the specified <xajaxResponse>
1285	object with the response commands in this <xajaxResponse> object.
1286
1287	mCommands - (object): <xajaxResponse> object.
1288	bBefore - (boolean): Add the new commands to the beginning
1289	of the list.
1290
1291	*/
1292	function loadCommands($mCommands, $bBefore=false)
1293	{
1294	if (is_a($mCommands, 'xajaxResponse')) {
1295	$this->returnValue = $mCommands->returnValue;
1296
1297	if ($bBefore) {
1298	$this->aCommands = array_merge($mCommands->aCommands, $this->aCommands);
1299	}
1300	else {
1301	$this->aCommands = array_merge($this->aCommands, $mCommands->aCommands);
1302	}
1303	}
1304	else if (is_array($mCommands)) {
1305	if ($bBefore) {
1306	$this->aCommands = array_merge($mCommands, $this->aCommands);
1307	}
1308	else {
1309	$this->aCommands = array_merge($this->aCommands, $mCommands);
1310	}
1311	}
1312	else {
1313	//SkipDebug
1314	if (!empty($mCommands)) {
1315	$objLanguageManager =& xajaxLanguageManager::getInstance();
1316	trigger_error(
1317	$objLanguageManager->getText('XJXRSP:LCERR:01')
1318	, E_USER_ERROR
1319	);
1320	}
1321	//EndSkipDebug
1322	}
1323	}
1324
1325	function absorb($objResponse)
1326	{
1327	$this->loadCommands($objResponse);
1328	}
1329
1330	/*
1331	Function: addPluginCommand
1332
1333	Adds a response command that is generated by a plugin.
1334
1335	objPlugin - (object): A reference to a plugin object.
1336	aAttributes - (array): Array containing the attributes for this
1337	response command.
1338	mData - (mixed): The data to be sent with this command.
1339
1340	Returns:
1341
1342	object - The <xajaxResponse> object.
1343	*/
1344	function addPluginCommand($objPlugin, $aAttributes, $mData)
1345	{
1346	$aAttributes['plg'] = $objPlugin->getName();
1347	return $this->addCommand($aAttributes, $mData);
1348	}
1349
1350	/*
1351	Function: addCommand
1352
1353	Add a response command to the array of commands that will
1354	be sent to the browser.
1355
1356	aAttributes - (array): Associative array of attributes that
1357	will describe the command.
1358	mData - (mixed): The data to be associated with this command.
1359
1360	Returns:
1361
1362	object - The <xajaxResponse> command.
1363	*/
1364	function addCommand($aAttributes, $mData)
1365	{
1366	$aAttributes['data'] = $this->_encodeArray($mData);
1367	$this->aCommands[] = $aAttributes;
1368	return $this;
1369	}
1370
1371	/*
1372	Function: _printHeader_XML
1373
1374	Used internally to print XML start tag.
1375	*/
1376	function _printHeader_XML()
1377	{
1378	print '<';
1379	print '?';
1380	print 'xml version="1.0"';
1381
1382	$sEncoding = trim($this->sCharacterEncoding);
1383	if ($this->sCharacterEncoding && 0 < strlen($sEncoding)) {
1384	print ' encoding="';
1385	print $sEncoding;
1386	print '"';
1387	}
1388
1389	print ' ?';
1390	print '>';
1391	}
1392
1393	/*
1394	Function: _printResponse_XML
1395
1396	Used internally to generate the command output.
1397	*/
1398	function _printResponse_XML()
1399	{
1400	print '<';
1401	print 'xjx>';
1402
1403	if (null !== $this->returnValue)
1404	{
1405	print '<';
1406	print 'xjxrv>';
1407
1408	$this->_printArray_XML($this->returnValue);
1409
1410	print '<';
1411	print '/xjxrv>';
1412	}
1413
1414	foreach(array_keys($this->aCommands) as $sKey)
1415	$this->_printCommand_XML($this->aCommands[$sKey]);
1416
1417	print '<';
1418	print '/xjx>';
1419	}
1420
1421	/*
1422	Function: _printCommand_XML
1423
1424	Prints an XML representation of the command.
1425
1426	aAttributes - (array): Associative array of attributes for this
1427	command.
1428	*/
1429	function _printCommand_XML(&$aAttributes)
1430	{
1431	print '<';
1432	print 'cmd';
1433
1434	$mData = '';
1435
1436	foreach (array_keys($aAttributes) as $sKey) {
1437	if ($sKey) {
1438	if ('data' != $sKey) {
1439	print ' ';
1440	print $sKey;
1441	print '="';
1442	print $aAttributes[$sKey];
1443	print '"';
1444	} else
1445	$mData =& $aAttributes[$sKey];
1446	}
1447	}
1448
1449	print '>';
1450
1451	$this->_printArray_XML($mData);
1452
1453	print '<';
1454	print '/cmd>';
1455	}
1456
1457	/*
1458	Function: _printArray_XML
1459
1460	Prints an XML representation of a php array suitable
1461	for inclusion in the response to the browser. Arrays
1462	sent via this method will be converted into a javascript
1463	array on the browser.
1464
1465	mArray - (array): Array to be converted.
1466	*/
1467	function _printArray_XML(&$mArray) {
1468	if ('object' == gettype($mArray))
1469	$mArray = get_object_vars($mArray);
1470
1471	if (false == is_array($mArray)) {
1472	$this->_printEscapedString_XML($mArray);
1473	return;
1474	}
1475
1476	print '<';
1477	print 'xjxobj>';
1478
1479	foreach (array_keys($mArray) as $sKey) {
1480	if (is_array($mArray[$sKey])) {
1481	print '<';
1482	print 'e>';
1483
1484	foreach (array_keys($mArray[$sKey]) as $sInnerKey) {
1485	//SkipDebug
1486	if (htmlspecialchars($sInnerKey, ENT_COMPAT, 'UTF-8') != $sInnerKey) {
1487	$objLanguageManager =& xajaxLanguageManager::getInstance();
1488	trigger_error(
1489	$objLanguageManager->getText('XJXRSP:AKERR:01')
1490	, E_USER_ERROR
1491	);
1492	}
1493	//EndSkipDebug
1494
1495	if ('k' == $sInnerKey \|\| 'v' == $sInnerKey) {
1496	print '<';
1497	print $sInnerKey;
1498	print '>';
1499	$this->_printArray_XML($mArray[$sKey][$sInnerKey]);
1500	print '<';
1501	print '/';
1502	print $sInnerKey;
1503	print '>';
1504	} else {
1505	//SkipDebug
1506	$objLanguageManager =& xajaxLanguageManager::getInstance();
1507	trigger_error(
1508	$objLanguageManager->getText('XJXRSP:IEAERR:01')
1509	, E_USER_ERROR
1510	);
1511	//EndSkipDebug
1512	}
1513	}
1514
1515	print '<';
1516	print '/e>';
1517	} else {
1518	//SkipDebug
1519	$objLanguageManager =& xajaxLanguageManager::getInstance();
1520	trigger_error(
1521	$objLanguageManager->getText('XJXRSP:NEAERR:01')
1522	, E_USER_ERROR
1523	);
1524	//EndSkipDebug
1525	}
1526	}
1527
1528	print '<';
1529	print '/xjxobj>';
1530	}
1531
1532	/*
1533	Function: _printEscapedString_XML
1534
1535	Escape the specified data if necessary, so special characters in the
1536	command data does not interfere with the structure of the response.
1537
1538	This could be overridden to allow for transport encodings other than
1539	XML.
1540
1541	sData - (string): The data to be escaped.
1542
1543	Returns:
1544
1545	string - The escaped data.
1546	*/
1547	function _printEscapedString_XML(&$sData)
1548	{
1549	if (null === $sData) {
1550	print '';
1551	return;
1552	}
1553
1554	if ($this->bOutputEntities) {
1555	//SkipDebug
1556	if (false === function_exists('mb_convert_encoding')) {
1557	$objLanguageManager =& xajaxLanguageManager::getInstance();
1558	trigger_error(
1559	$objLanguageManager->getText('XJXRSP:MBEERR:01')
1560	, E_USER_NOTICE
1561	);
1562	}
1563	//EndSkipDebug
1564
1565	print call_user_func_array('mb_convert_encoding', array(&$sData, 'HTML-ENTITIES', $this->sCharacterEncoding));
1566	return;
1567	}
1568
1569	$nCDATA = 0;
1570
1571	$bNoOpenCDATA = (false === strpos($sData, '<'.'![CDATA['));
1572	if ($bNoOpenCDATA) {
1573	$bNoCloseCDATA = (false === strpos($sData, ']]>'));
1574	if ($bNoCloseCDATA) {
1575	$bSpecialChars = (htmlspecialchars($sData, ENT_COMPAT, 'UTF-8') != $sData);
1576	if ($bSpecialChars)
1577	$nCDATA = 1;
1578	} else
1579	$nCDATA = 2;
1580	} else
1581	$nCDATA = 2;
1582
1583	if (0 < $nCDATA) {
1584	print '<';
1585	print '![CDATA[';
1586
1587	if (1 < $nCDATA) {
1588	$aSegments = explode('<'.'![CDATA[', $sData);
1589	$aOutput = array();
1590	$nOutput = 0;
1591	foreach (array_keys($aSegments) as $keySegment) {
1592	$aFragments = explode(']]>', $aSegments[$keySegment]);
1593	$aStack = array();
1594	$nStack = 0;
1595	foreach (array_keys($aFragments) as $keyFragment) {
1596	if (0 < $nStack)
1597	array_push($aStack, ']]]]><', '![CDATA[>', $aFragments[$keyFragment]);
1598	else
1599	$aStack[] = $aFragments[$keyFragment];
1600	++$nStack;
1601	}
1602	if (0 < $nOutput)
1603	array_push($aOutput, '<', '![]]><', '![CDATA[CDATA[', implode('', $aStack));
1604	else
1605	$aOutput[] = implode('', $aStack);
1606	++$nOutput;
1607	}
1608	print implode('', $aOutput);
1609	} else
1610	print $sData;
1611
1612	print ']]>';
1613	} else
1614	print $sData;
1615	}
1616
1617	/*
1618	Function: _encodeArray
1619
1620	Recursively serializes a data structure in an array so that it can
1621	be sent to the browser. This can be thought of as the opposite of
1622	<xajaxRequestProcessorPlugin->_parseObjXml>.
1623
1624	mData - (mixed): The data to be evaluated.
1625
1626	Returns:
1627
1628	mixed - The object constructed from the data.
1629	*/
1630	function _encodeArray(&$mData) {
1631	if ('object' === gettype($mData))
1632	$mData = get_object_vars($mData);
1633
1634	if (false === is_array($mData))
1635	return $mData;
1636
1637	$aData = array();
1638	foreach (array_keys($mData) as $sKey)
1639	$aData[] = array(
1640	// key does not need to be encoded
1641	'k'=>$sKey,
1642	'v'=>$this->_encodeArray($mData[$sKey])
1643	);
1644	return $aData;
1645	}
1646
1647	}// end class xajaxResponse
1648
1649	class xajaxCustomResponse
1650	{
1651	var $sOutput;
1652	var $sContentType;
1653
1654	var $sCharacterEncoding;
1655	var $bOutputEntities;
1656
1657	function xajaxCustomResponse($sContentType)
1658	{
1659	$this->sOutput = '';
1660	$this->sContentType = $sContentType;
1661
1662	$objResponseManager =& xajaxResponseManager::getInstance();
1663
1664	$this->sCharacterEncoding = $objResponseManager->getCharacterEncoding();
1665	$this->bOutputEntities = $objResponseManager->getOutputEntities();
1666	}
1667
1668	function setCharacterEncoding($sCharacterEncoding)
1669	{
1670	$this->sCharacterEncoding = $sCharacterEncoding;
1671	}
1672
1673	function setOutputEntities($bOutputEntities)
1674	{
1675	$this->bOutputEntities = $bOutputEntities;
1676	}
1677
1678	function clear()
1679	{
1680	$this->sOutput = '';
1681	}
1682
1683	function append($sOutput)
1684	{
1685	$this->sOutput .= $sOutput;
1686	}
1687
1688	function absorb($objResponse)
1689	{
1690	//SkipDebug
1691	if (false == is_a($objResponse, 'xajaxCustomResponse')) {
1692	$objLanguageManager =& xajaxLanguageManager::getInstance();
1693	trigger_error(
1694	$objLanguageManager->getText('XJXRSP:MXRTERR')
1695	, E_USER_ERROR
1696	);
1697	}
1698
1699	if ($objResponse->getContentType() != $this->getContentType()) {
1700	$objLanguageManager =& xajaxLanguageManager::getInstance();
1701	trigger_error(
1702	$objLanguageManager->getText('XJXRSP:MXCTERR')
1703	, E_USER_ERROR
1704	);
1705	}
1706
1707	if ($objResponse->getCharacterEncoding() != $this->getCharacterEncoding()) {
1708	$objLanguageManager =& xajaxLanguageManager::getInstance();
1709	trigger_error(
1710	$objLanguageManager->getText('XJXRSP:MXCEERR')
1711	, E_USER_ERROR
1712	);
1713	}
1714
1715	if ($objResponse->getOutputEntities() != $this->getOutputEntities()) {
1716	$objLanguageManager =& xajaxLanguageManager::getInstance();
1717	trigger_error(
1718	$objLanguageManager->getText('XJXRSP:MXOEERR')
1719	, E_USER_ERROR
1720	);
1721	}
1722	//EndSkipDebug
1723
1724	$this->sOutput .= $objResponse->getOutput();
1725	}
1726
1727	function getContentType()
1728	{
1729	return $this->sContentType;
1730	}
1731
1732	function getCharacterEncoding()
1733	{
1734	return $this->sCharacterEncoding;
1735	}
1736
1737	function getOutputEntities()
1738	{
1739	return $this->bOutputEntities;
1740	}
1741
1742	function getOutput()
1743	{
1744	return $this->sOutput;
1745	}
1746
1747	function printOutput()
1748	{
1749	$sContentType = $this->sContentType;
1750	$sCharacterSet = $this->sCharacterEncoding;
1751
1752	header("content-type: {$sContentType}; charset={$sCharacterSet}");
1753
1754	print $this->sOutput;
1755	}
1756	}

Note: See TracBrowser for help on using the browser.

Context Navigation

root/dev/mods/xajax/xajax_core/xajaxResponse.inc.php @ 366

Download in other formats: