]> git.sur5r.net Git - bacula/bacula/blob - gui/baculum/framework/Web/UI/ActiveControls/TCallbackClientSide.php
449bea80adeb3463bd6c87f93856e78a8faf7039
[bacula/bacula] / gui / baculum / framework / Web / UI / ActiveControls / TCallbackClientSide.php
1 <?php
2 /**
3  * TCallbackClientSide class file
4  *
5  * @author Wei Zhuo <weizhuo[at]gamil[dot]com>
6  * @link http://www.pradosoft.com/
7  * @copyright Copyright &copy; 2005-2014 PradoSoft
8  * @license http://www.pradosoft.com/license/
9  * @package System.Web.UI.ActiveControls
10  */
11
12 /**
13  * TCallbackClientSide class.
14  *
15  * The following client side events are executing in order if the callback
16  * request and response are send and received successfuly.
17  *
18  * - <b>onPreDispatch</b> executed before a request is dispatched.
19  * - <b>onUninitialized</b> executed when callback request is uninitialized.
20  * - <b>onLoading</b>* executed when callback request is initiated
21  * - <b>onLoaded</b>* executed when callback request begins.
22  * - <b>onInteractive</b> executed when callback request is in progress.
23  * - <b>onComplete</b>executed when callback response returns.
24  * - <b>onSuccess</b> executed when callback request returns and is successful.
25  * - <b>onFailure</b> executed when callback request returns and fails.
26  * - <b>onException</b> raised when callback request fails due to request/response errors.
27  *
28  * * Note that theses 2 events are not fired correctly by Opera. To make
29  *   them work in this browser, Prado will fire them just after onPreDispatch.
30  *
31  * In a general way, onUninitialized, onLoading, onLoaded and onInteractive events
32  * are not implemented consistently in all browsers.When cross browser compatibility is
33  * needed, it is best to avoid use them
34  *
35  * The OnSuccess and OnFailure events are raised when the
36  * response is returned. A successful request/response will raise
37  * OnSuccess event otherwise OnFailure will be raised.
38  *
39  * - <b>PostState</b> true to collect the form inputs and post them during callback, default is true.
40  * - <b>RequestTimeOut</b> The request timeout in milliseconds.
41  * - <b>HasPriority</b> true to ensure that the callback request will be sent
42  *   immediately and will abort existing prioritized requests. It does not affect
43  *   callbacks that are not prioritized.
44  * - <b>EnablePageStateUpdate</b> enable the callback response to enable the
45  *   viewstate update. This will automatically set HasPriority to true when enabled.
46  *
47  * @author Wei Zhuo <weizhuo[at]gamil[dot]com>
48  * @package System.Web.UI.ActiveControls
49  * @since 3.1
50  */
51 class TCallbackClientSide extends TClientSideOptions
52 {
53         /**
54          * Returns javascript statement enclosed within a javascript function.
55          * @param string javascript statement
56          * @return string javascript statement wrapped in a javascript function
57          */
58         protected function ensureFunction($javascript)
59         {
60                 return "function(sender, parameter){ {$javascript} }";
61         }
62
63         /**
64          * @param string javascript code to be executed before a request is dispatched.
65          */
66         public function setOnPreDispatch($javascript)
67         {
68                 $this->setFunction('onPreDispatch', $javascript);
69         }
70
71         /**
72          * @return string javascript code to be executed before a request is dispatched.
73          */
74         public function getOnPreDispatch()
75         {
76                 return $this->getOption('onPreDispatch');
77         }
78
79         /**
80          * @return string javascript code for client-side onUninitialized event
81          */
82         public function getOnUninitialized()
83         {
84                 return $this->getOption('onUninitialized');
85         }
86
87         /**
88          * @param string javascript code for client-side onUninitialized event.
89          */
90         public function setOnUninitialized($javascript)
91         {
92                 $this->setFunction('onUninitialized', $javascript);
93         }
94
95         /**
96          * @return string javascript code for client-side onLoading event
97          */
98         public function getOnLoading()
99         {
100                 return $this->getOption('onLoading');
101         }
102
103         /**
104          * @param string javascript code for client-side onLoading event.
105          */
106         public function setOnLoading($javascript)
107         {
108                 $this->setFunction('onLoading', $javascript);
109         }
110
111         /**
112          * @return string javascript code for client-side onLoaded event
113          */
114         public function getOnLoaded()
115         {
116                 return $this->getOption('onLoaded');
117         }
118
119         /**
120          * @param string javascript code for client-side onLoaded event.
121          */
122         public function setOnLoaded($javascript)
123         {
124                 $this->setFunction('onLoaded', $javascript);
125         }
126         /**
127          * @return string javascript code for client-side onInteractive event
128          */
129         public function getOnInteractive()
130         {
131                 return $this->getOption('onInteractive');
132         }
133
134         /**
135          * @param string javascript code for client-side onInteractive event.
136          */
137         public function setOnInteractive($javascript)
138         {
139                 $this->setFunction('onInteractive', $javascript);
140         }
141         /**
142          * @return string javascript code for client-side onComplete event
143          */
144         public function getOnComplete()
145         {
146                 return $this->getOption('onComplete');
147         }
148
149         /**
150          * @param string javascript code for client-side onComplete event.
151          */
152         public function setOnComplete($javascript)
153         {
154                 $this->setFunction('onComplete', $javascript);
155         }
156         /**
157          * @return string javascript code for client-side onSuccess event
158          */
159         public function getOnSuccess()
160         {
161                 return $this->getOption('onSuccess');
162         }
163
164         /**
165          * @param string javascript code for client-side onSuccess event.
166          */
167         public function setOnSuccess($javascript)
168         {
169                 $this->setFunction('onSuccess', $javascript);
170         }
171
172         /**
173          * @return string javascript code for client-side onFailure event
174          */
175         public function getOnFailure()
176         {
177                 return $this->getOption('onFailure');
178         }
179
180         /**
181          * @param string javascript code for client-side onFailure event.
182          */
183         public function setOnFailure($javascript)
184         {
185                 $this->setFunction('onFailure', $javascript);
186         }
187
188         /**
189          * @return string javascript code for client-side onException event
190          */
191         public function getOnException()
192         {
193                 return $this->getOption('onException');
194         }
195
196         /**
197          * @param string javascript code for client-side onException event.
198          */
199         public function setOnException($javascript)
200         {
201                 $this->setFunction('onException', $javascript);
202         }
203
204         /**
205          * @return boolean true to post the inputs of the form on callback, default
206          * is post the inputs on callback.
207          */
208         public function getPostState()
209         {
210                 return $this->getOption('PostInputs');
211         }
212
213         /**
214          * @param boolean true to post the inputs of the form with callback
215          * requests. Default is to post the inputs.
216          */
217         public function setPostState($value)
218         {
219                 $this->setOption('PostInputs', TPropertyValue::ensureBoolean($value));
220         }
221
222         /**
223          * @return integer callback request timeout.
224          */
225         public function getRequestTimeOut()
226         {
227                 return $this->getOption('RequestTimeOut');
228         }
229
230         /**
231          * @param integer callback request timeout
232          */
233         public function setRequestTimeOut($value)
234         {
235                 $this->setOption('RequestTimeOut', TPropertyValue::ensureInteger($value));
236         }
237
238         /**
239          * @return boolean true if the callback request has priority and will abort
240          * existing prioritized request in order to send immediately. It does not
241          * affect callbacks that are not prioritized. Default is true.
242          */
243         public function getHasPriority()
244         {
245                 $option =  $this->getOption('HasPriority');
246                 return ($option===null) ? true : $option;
247         }
248
249         /**
250          * @param boolean true to ensure that the callback request will be sent
251          * immediately and will abort existing prioritized requests. It does not
252          * affect callbacks that are not prioritized.
253          */
254         public function setHasPriority($value)
255         {
256                 $hasPriority = TPropertyValue::ensureBoolean($value);
257                 $this->setOption('HasPriority', $hasPriority);
258                 if(!$hasPriority)
259                         $this->setEnablePageStateUpdate(false);
260         }
261
262         /**
263          * Set to true to enable the callback response to enable the viewstate
264          * update. This will automatically set HasPrority to true.
265          * @param boolean true enables the callback response to update the
266          * viewstate.
267          */
268         public function setEnablePageStateUpdate($value)
269         {
270                 $enabled = TPropertyValue::ensureBoolean($value);
271                 $this->setOption('EnablePageStateUpdate', $enabled);
272                 if($enabled)
273                         $this->setHasPriority(true);
274         }
275
276         /**
277          * @return boolean client-side viewstate will be updated on callback
278          * response if true. Default is true.
279          */
280         public function getEnablePageStateUpdate()
281         {
282                 $option = $this->getOption('EnablePageStateUpdate');
283                 return ($option===null) ? true : $option;
284         }
285
286         /**
287          * @return string post back target ID
288          */
289         public function getPostBackTarget()
290         {
291                 return $this->getOption('EventTarget');
292         }
293
294         /**
295          * @param string post back target ID
296          */
297         public function setPostBackTarget($value)
298         {
299                 if($value instanceof TControl)
300                         $value = $value->getUniqueID();
301                 $this->setOption('EventTarget', $value);
302         }
303
304         /**
305          * @return string post back event parameter.
306          */
307         public function getPostBackParameter()
308         {
309                 return $this->getOption('EventParameter');
310         }
311
312         /**
313          * @param string post back event parameter.
314          */
315         public function setPostBackParameter($value)
316         {
317                 $this->setOption('EventParameter', $value);
318         }
319 }
320