Source for file Client.class.php

Documentation is available at Client.class.php

  1. <?php
  2. /**
  3. * XOAD Client file.
  4. *
  5. * <p>This file defines the {@link XOAD_Client} Class.</p>
  6. * <p>Example:</p>
  7. * <code>
  8. * <script type="text/javascript">
  9. * <?php
  10. *
  11. * class Calculator
  12. * {
  13. * var $result;
  14. *
  15. * function Calculator()
  16. * {
  17. * $this->result = 0;
  18. * }
  19. *
  20. * function Add($arg)
  21. * {
  22. * $this->result += $arg;
  23. * }
  24. * }
  25. *
  26. * require_once('xoad.php');
  27. *
  28. * print XOAD_Client::register('Calculator', 'server.php');
  29. *
  30. * ?>
  31. * </script>
  32. * </code>
  33. *
  34. * @author Stanimir Angeloff
  35. *
  36. * @package XOAD
  37. *
  38. * @version 0.6.0.0
  39. *
  40. */
  41.  
  42. /**
  43. * XOAD Client Class.
  44. *
  45. * <p>This class is used to register a PHP variable/class
  46. * in JavaScript.</p>
  47. * <p>This class is also used to assign meta data
  48. * to the classes. See
  49. * {@link XOAD_Client::publicMethods},
  50. * {@link XOAD_Client::privateMethods},
  51. * {@link XOAD_Client::publicVariables},
  52. * {@link XOAD_Client::privateVariables} and
  53. * {@link XOAD_Client::mapMethods} for more information.</p>
  54. * <p>Example:</p>
  55. * <code>
  56. * <?php
  57. *
  58. * class Calculator
  59. * {
  60. * var $result;
  61. *
  62. * function Calculator()
  63. * {
  64. * $this->result = 0;
  65. * }
  66. *
  67. * function Add($arg)
  68. * {
  69. * $this->result += $arg;
  70. * }
  71. * }
  72. *
  73. * define('XOAD_AUTOHANDLE', true);
  74. *
  75. * require_once('xoad.php');
  76. *
  77. * ?>
  78. * <?= XOAD_Utilities::header() ?>
  79. * <script type="text/javascript">
  80. *
  81. * var calc = <?= XOAD_Client::register(new Calculator()) ?>;
  82. *
  83. * calc.add(10);
  84. * calc.add(20);
  85. *
  86. * alert(calc.result);
  87. *
  88. * </script>
  89. * </code>
  90. *
  91. * @author Stanimir Angeloff
  92. *
  93. * @package XOAD
  94. *
  95. * @version 0.6.0.0
  96. *
  97. */
  98. class XOAD_Client extends XOAD_Observable
  99. {
  100. /**
  101. * Registers a PHP variable/class in JavaScript.
  102. *
  103. * <p>Example:</p>
  104. * <code>
  105. * <script type="text/javascript">
  106. * <?php require_once('xoad.php'); ?>
  107. *
  108. * var arr = <?= XOAD_Client::register(array(1, 2, "string", array("Nested"))) ?>;
  109. *
  110. * alert(arr);
  111. *
  112. * </script>
  113. * </code>
  114. *
  115. * @access public
  116. *
  117. * @param mixed $var Variable/Class name to register.
  118. *
  119. * @param mixed $params When registering a variable/class you can
  120. * provide extended parameters, like class name
  121. * and callback URL.
  122. *
  123. * @return string JavaString code that represents the variable/class.
  124. *
  125. * @static
  126. *
  127. */
  128. function register($var, $params = null)
  129. {
  130. $type = XOAD_Utilities::getType($var);
  131.  
  132. if ($type == 'object') {
  133.  
  134. $paramsType = XOAD_Utilities::getType($params);
  135.  
  136. if ($paramsType != 'string') {
  137.  
  138. $callbackUrl = XOAD_Utilities::getRequestUrl();
  139.  
  140. if ($paramsType == 'a_array') {
  141.  
  142. if ( ! empty($params['class'])) {
  143.  
  144. $className = $params['class'];
  145. }
  146.  
  147. if ( ! empty($params['url'])) {
  148.  
  149. $callbackUrl = $params['url'];
  150. }
  151. }
  152.  
  153. } else {
  154.  
  155. $callbackUrl = $params;
  156. }
  157.  
  158. if (method_exists($var, XOAD_CLIENT_METADATA_METHOD_NAME)) {
  159.  
  160. call_user_func_array(array(&$var, XOAD_CLIENT_METADATA_METHOD_NAME), null);
  161. }
  162.  
  163. $objectCode = array();
  164.  
  165. if (empty($className)) {
  166.  
  167. $className = XOAD_Utilities::caseConvert(get_class($var));
  168. }
  169.  
  170. $meta = get_object_vars($var);
  171.  
  172. $objectMeta = null;
  173.  
  174. if (isset($meta['xoadMeta'])) {
  175.  
  176. if (XOAD_Utilities::getType($meta['xoadMeta']) == 'object') {
  177.  
  178. if (strcasecmp(get_class($meta['xoadMeta']), 'XOAD_Meta') == 0) {
  179.  
  180. $objectMeta = $meta['xoadMeta'];
  181.  
  182. unset($meta['xoadMeta']);
  183.  
  184. unset($var->xoadMeta);
  185. }
  186. }
  187. }
  188.  
  189. if (sizeof($meta) > 0) {
  190.  
  191. $attachMeta = array();
  192.  
  193. foreach ($meta as $key => $value) {
  194.  
  195. if ( ! empty($objectMeta)) {
  196.  
  197. if ( ! $objectMeta->isPublicVariable($key)) {
  198.  
  199. unset($meta[$key]);
  200.  
  201. unset($var->$key);
  202.  
  203. continue;
  204. }
  205. }
  206.  
  207. $valueType = XOAD_Utilities::getType($value);
  208.  
  209. if (
  210. ($valueType == 'object') ||
  211. ($valueType == 's_array') ||
  212. ($valueType == 'a_array')) {
  213.  
  214. $var->$key = XOAD_SERIALIZER_SKIP_STRING . XOAD_Client::register($var->$key, $callbackUrl);
  215. }
  216.  
  217. $attachMeta[$key] = $valueType;
  218. }
  219.  
  220. $var->__meta = $attachMeta;
  221.  
  222. $var->__size = sizeof($attachMeta);
  223.  
  224. } else {
  225.  
  226. $var->__meta = null;
  227.  
  228. $var->__size = 0;
  229. }
  230.  
  231. $var->__class = $className;
  232.  
  233. $var->__url = $callbackUrl;
  234.  
  235. $var->__uid = md5(uniqid(rand(), true));
  236.  
  237. $var->__output = null;
  238.  
  239. $var->__timeout = null;
  240.  
  241. $serialized = XOAD_Serializer::serialize($var);
  242.  
  243. $objectCode[] = substr($serialized, 1, strlen($serialized) - 2);
  244.  
  245. $objectCode[] = '"__clone":function(obj){xoad.clone(this,obj)}';
  246.  
  247. $objectCode[] = '"__serialize":function(){return xoad.serialize(this)}';
  248.  
  249. $objectCode[] = '"catchEvent":function(){return xoad.catchEvent(this,arguments)}';
  250.  
  251. $objectCode[] = '"ignoreEvent":function(){return xoad.ignoreEvent(this,arguments)}';
  252.  
  253. $objectCode[] = '"postEvent":function(){return xoad.postEvent(this,arguments)}';
  254.  
  255. $objectCode[] = '"fetchOutput":function(){return this.__output}';
  256.  
  257. $objectCode[] = '"setTimeout":function(miliseconds){this.__timeout=miliseconds}';
  258.  
  259. $objectCode[] = '"getTimeout":function(){return this.__timeout}';
  260.  
  261. $objectCode[] = '"clearTimeout":function(){this.__timeout=null}';
  262.  
  263. $classMethods = get_class_methods($var);
  264.  
  265. for ($iterator = sizeof($classMethods) - 1; $iterator >= 0; $iterator --) {
  266.  
  267. if (strcasecmp($className, $classMethods[$iterator]) == 0) {
  268.  
  269. unset($classMethods[$iterator]);
  270.  
  271. continue;
  272. }
  273.  
  274. if (strcasecmp($classMethods[$iterator], XOAD_CLIENT_METADATA_METHOD_NAME) == 0) {
  275.  
  276. unset($classMethods[$iterator]);
  277.  
  278. continue;
  279. }
  280.  
  281. if ( ! empty($objectMeta)) {
  282.  
  283. if ( ! $objectMeta->isPublicMethod($classMethods[$iterator])) {
  284.  
  285. unset($classMethods[$iterator]);
  286.  
  287. continue;
  288. }
  289. }
  290. }
  291.  
  292. if (sizeof($classMethods) > 0) {
  293.  
  294. $index = 0;
  295.  
  296. $length = sizeof($classMethods);
  297.  
  298. $returnValue = '';
  299.  
  300. foreach ($classMethods as $method) {
  301.  
  302. $methodName = XOAD_Utilities::caseConvert($method);
  303.  
  304. if ( ! empty($objectMeta)) {
  305.  
  306. $mapMethodName = $objectMeta->findMethodName($methodName);
  307.  
  308. if (strcmp($mapMethodName, $methodName) != 0) {
  309.  
  310. $methodName = $mapMethodName;
  311. }
  312. }
  313.  
  314. $serialized = XOAD_Serializer::serialize($methodName);
  315.  
  316. $returnValue .= $serialized;
  317.  
  318. $returnValue .= ':';
  319.  
  320. $returnValue .= 'function(){return xoad.call(this,' . $serialized .',arguments)}';
  321.  
  322. if ($index < $length - 1) {
  323.  
  324. $returnValue .= ',';
  325. }
  326.  
  327. $index ++;
  328. }
  329.  
  330. $objectCode[] = $returnValue;
  331. }
  332.  
  333. $returnValue = '{' . join(',', $objectCode) . '}';
  334.  
  335. return $returnValue;
  336.  
  337. } else if (($type == 's_array') || ($type == 'a_array')) {
  338.  
  339. foreach ($var as $key => $value) {
  340.  
  341. $valueType = XOAD_Utilities::getType($value);
  342.  
  343. if (
  344. ($valueType == 'object') ||
  345. ($valueType == 's_array') ||
  346. ($valueType == 'a_array')) {
  347.  
  348. $var[$key] = XOAD_SERIALIZER_SKIP_STRING . XOAD_Client::register($var[$key], $params);
  349. }
  350. }
  351.  
  352. } else if ($type == 'string') {
  353.  
  354. $paramsType = XOAD_Utilities::getType($params);
  355.  
  356. if ($paramsType == 'string') {
  357.  
  358. if (class_exists($var)) {
  359.  
  360. $classObject = new $var;
  361.  
  362. $classCode = XOAD_Client::register($classObject, array('class' => $var, 'url' => $params));
  363.  
  364. $classCode = $var . '=function(){return ' . $classCode . '}';
  365.  
  366. return $classCode;
  367. }
  368. }
  369. }
  370.  
  371. return XOAD_Serializer::serialize($var);
  372. }
  373.  
  374. /**
  375. * Assigns public methods to the class meta data.
  376. *
  377. * @param object $var The object where the meta data is stored.
  378. *
  379. * @param array $methods The class public methods.
  380. *
  381. * @return void
  382. *
  383. * @static
  384. *
  385. */
  386. function publicMethods(&$var, $methods)
  387. {
  388. if (XOAD_Utilities::getType($var) != 'object') {
  389.  
  390. return false;
  391. }
  392.  
  393. if ( ! isset($var->xoadMeta)) {
  394.  
  395. require_once(XOAD_BASE . '/classes/Meta.class.php');
  396.  
  397. $var->xoadMeta = new XOAD_Meta();
  398. }
  399.  
  400. $var->xoadMeta->setPublicMethods($methods);
  401. }
  402.  
  403. /**
  404. * Assigns private methods to the class meta data.
  405. *
  406. * @param object $var The object where the meta data is stored.
  407. *
  408. * @param array $methods The class private methods.
  409. *
  410. * @return void
  411. *
  412. * @static
  413. *
  414. */
  415. function privateMethods(&$var, $methods)
  416. {
  417. if (XOAD_Utilities::getType($var) != 'object') {
  418.  
  419. return false;
  420. }
  421.  
  422. if ( ! isset($var->xoadMeta)) {
  423.  
  424. require_once(XOAD_BASE . '/classes/Meta.class.php');
  425.  
  426. $var->xoadMeta = new XOAD_Meta();
  427. }
  428.  
  429. $var->xoadMeta->setPrivateMethods($methods);
  430. }
  431.  
  432. /**
  433. * Assigns public variables to the class meta data.
  434. *
  435. * @param object $var The object where the meta data is stored.
  436. *
  437. * @param array $variables The class public variables.
  438. *
  439. * @return void
  440. *
  441. * @static
  442. *
  443. */
  444. function publicVariables(&$var, $variables)
  445. {
  446. if (XOAD_Utilities::getType($var) != 'object') {
  447.  
  448. return false;
  449. }
  450.  
  451. if ( ! isset($var->xoadMeta)) {
  452.  
  453. require_once(XOAD_BASE . '/classes/Meta.class.php');
  454.  
  455. $var->xoadMeta = new XOAD_Meta();
  456. }
  457.  
  458. $var->xoadMeta->setPublicVariables($variables);
  459. }
  460.  
  461. /**
  462. * Assigns private variables to the class meta data.
  463. *
  464. * @param object $var The object where the meta data is stored.
  465. *
  466. * @param array $variables The class private variables.
  467. *
  468. * @return void
  469. *
  470. * @static
  471. *
  472. */
  473. function privateVariables(&$var, $variables)
  474. {
  475. if (XOAD_Utilities::getType($var) != 'object') {
  476.  
  477. return false;
  478. }
  479.  
  480. if ( ! isset($var->xoadMeta)) {
  481.  
  482. require_once(XOAD_BASE . '/classes/Meta.class.php');
  483.  
  484. $var->xoadMeta = new XOAD_Meta();
  485. }
  486.  
  487. $var->xoadMeta->setPrivateVariables($variables);
  488. }
  489.  
  490. /**
  491. * Assigns methods map to the class meta data.
  492. *
  493. * @param object $var The object where the meta data is stored.
  494. *
  495. * @param array $methodsMap The class methods map.
  496. *
  497. * @return void
  498. *
  499. * @static
  500. *
  501. */
  502. function mapMethods(&$var, $methodsMap)
  503. {
  504. if (XOAD_Utilities::getType($var) != 'object') {
  505.  
  506. return false;
  507. }
  508.  
  509. if ( ! isset($var->xoadMeta)) {
  510.  
  511. require_once(XOAD_BASE . '/classes/Meta.class.php');
  512.  
  513. $var->xoadMeta = new XOAD_Meta();
  514. }
  515.  
  516. $var->xoadMeta->setMethodsMap($methodsMap);
  517. }
  518.  
  519. /**
  520. * Adds a {@link XOAD_Client} events observer.
  521. *
  522. * @access public
  523. *
  524. * @param mixed $observer The observer object to add (must extend {@link XOAD_Observer}).
  525. *
  526. * @return string true on success, false otherwise.
  527. *
  528. * @static
  529. *
  530. */
  531. function addObserver(&$observer)
  532. {
  533. return parent::addObserver($observer, 'XOAD_Client');
  534. }
  535.  
  536. /**
  537. *
  538. * @access public
  539. *
  540. * @return bool
  541. *
  542. */
  543. function notifyObservers($event = 'default', $arg = null)
  544. {
  545. return parent::notifyObservers($event, $arg, 'XOAD_Client');
  546. }
  547. }
  548. ?>

Documentation generated on Sat, 12 Nov 2005 20:23:55 +0200 by phpDocumentor 1.3.0RC3