Source for file Client.class.php

Documentation is available at Client.class.php

  1. <?php
  2. /**
  3. * NAJAX Client Namespace file.
  4. *
  5. * <p>This file defines the {@link NAJAX_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('najax.php');
  27. *
  28. * print NAJAX_Client::register('Calculator', 'server.php');
  29. *
  30. * ?>
  31. * </script>
  32. * </code>
  33. *
  34. * @author Stanimir Angeloff
  35. *
  36. * @package NAJAX
  37. *
  38. * @version 0.4.1.0
  39. *
  40. */
  41.  
  42. /**
  43. * NAJAX 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 NAJAX_Client::publicMethods},
  50. * {@link NAJAX_Client::privateMethods},
  51. * {@link NAJAX_Client::publicVariables},
  52. * {@link NAJAX_Client::privateVariables} and
  53. * {@link NAJAX_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('NAJAX_AUTOHANDLE', true);
  74. *
  75. * require_once('najax.php');
  76. *
  77. * ?>
  78. * <?= NAJAX_Utilities::header() ?>
  79. * <script type="text/javascript">
  80. *
  81. * var calc = <?= NAJAX_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 NAJAX
  94. *
  95. * @version 0.4.1.0
  96. *
  97. */
  98. class NAJAX_Client extends NAJAX_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('najax.php'); ?>
  107. *
  108. * var arr = <?= NAJAX_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 = NAJAX_Utilities::getType($var);
  131.  
  132. if ($type == 'object') {
  133.  
  134. $paramsType = NAJAX_Utilities::getType($params);
  135.  
  136. if ($paramsType != 'string') {
  137.  
  138. $callbackUrl = $_SERVER['PHP_SELF'];
  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, NAJAX_CLIENT_METADATA_METHOD_NAME)) {
  159.  
  160. call_user_func_array(array(&$var, NAJAX_CLIENT_METADATA_METHOD_NAME), null);
  161. }
  162.  
  163. $objectCode = array();
  164.  
  165. if (empty($className)) {
  166.  
  167. $className = NAJAX_Utilities::caseConvert(get_class($var));
  168. }
  169.  
  170. $meta = get_object_vars($var);
  171.  
  172. $objectMeta = null;
  173.  
  174. if (isset($meta['najaxMeta'])) {
  175.  
  176. if (NAJAX_Utilities::getType($meta['najaxMeta']) == 'object') {
  177.  
  178. if (strcasecmp(get_class($meta['najaxMeta']), 'NAJAX_Meta') == 0) {
  179.  
  180. $objectMeta = $meta['najaxMeta'];
  181.  
  182. unset($meta['najaxMeta']);
  183.  
  184. unset($var->najaxMeta);
  185. }
  186. }
  187. }
  188.  
  189. if (sizeof($meta) > 0) {
  190.  
  191. foreach ($meta as $key => $value) {
  192.  
  193. if ( ! empty($objectMeta)) {
  194.  
  195. if ( ! $objectMeta->isPublicVariable($key)) {
  196.  
  197. unset($meta[$key]);
  198.  
  199. unset($var->$key);
  200.  
  201. continue;
  202. }
  203. }
  204.  
  205. $valueType = NAJAX_Utilities::getType($value);
  206.  
  207. if (
  208. ($valueType == 'object') ||
  209. ($valueType == 's_array') ||
  210. ($valueType == 'a_array')) {
  211.  
  212. $var->$key = NAJAX_SERIALIZER_SKIP_STRING . NAJAX_Client::register($var->$key, $callbackUrl);
  213. }
  214.  
  215. $meta[$key] = $valueType;
  216. }
  217.  
  218. $var->__meta = $meta;
  219.  
  220. $var->__size = sizeof($meta);
  221.  
  222. } else {
  223.  
  224. $var->__meta = null;
  225.  
  226. $var->__size = 0;
  227. }
  228.  
  229. $var->__class = $className;
  230.  
  231. $var->__url = $callbackUrl;
  232.  
  233. $var->__uid = md5(uniqid(rand(), true));
  234.  
  235. $var->__output = null;
  236.  
  237. $var->__timeout = null;
  238.  
  239. $serialized = NAJAX_Serializer::serialize($var);
  240.  
  241. $objectCode[] = substr($serialized, 1, strlen($serialized) - 2);
  242.  
  243. $objectCode[] = '"__clone":function(obj){najax.clone(this, obj)}';
  244.  
  245. $objectCode[] = '"__serialize":function(){return najax.serialize(this)}';
  246.  
  247. $objectCode[] = '"catchEvent":function(){return najax.catchEvent(this, arguments)}';
  248.  
  249. $objectCode[] = '"ignoreEvent":function(){return najax.ignoreEvent(this, arguments)}';
  250.  
  251. $objectCode[] = '"postEvent":function(){return najax.postEvent(this, arguments)}';
  252.  
  253. $objectCode[] = '"fetchOutput":function(){return this.__output}';
  254.  
  255. $objectCode[] = '"setTimeout":function(miliseconds){this.__timeout = miliseconds}';
  256.  
  257. $objectCode[] = '"getTimeout":function(){return this.__timeout}';
  258.  
  259. $objectCode[] = '"clearTimeout":function(){this.__timeout = null}';
  260.  
  261. $classMethods = get_class_methods($var);
  262.  
  263. for ($iterator = sizeof($classMethods) - 1; $iterator >= 0; $iterator --) {
  264.  
  265. if (strcasecmp($className, $classMethods[$iterator]) == 0) {
  266.  
  267. unset($classMethods[$iterator]);
  268.  
  269. continue;
  270. }
  271.  
  272. if (strcasecmp($classMethods[$iterator], NAJAX_CLIENT_METADATA_METHOD_NAME) == 0) {
  273.  
  274. unset($classMethods[$iterator]);
  275.  
  276. continue;
  277. }
  278.  
  279. if ( ! empty($objectMeta)) {
  280.  
  281. if ( ! $objectMeta->isPublicMethod($classMethods[$iterator])) {
  282.  
  283. unset($classMethods[$iterator]);
  284.  
  285. continue;
  286. }
  287. }
  288. }
  289.  
  290. if (sizeof($classMethods) > 0) {
  291.  
  292. $index = 0;
  293.  
  294. $length = sizeof($classMethods);
  295.  
  296. $returnValue = '';
  297.  
  298. foreach ($classMethods as $method) {
  299.  
  300. $methodName = NAJAX_Utilities::caseConvert($method);
  301.  
  302. if ( ! empty($objectMeta)) {
  303.  
  304. $mapMethodName = $objectMeta->findMethodName($methodName);
  305.  
  306. if (strcmp($mapMethodName, $methodName) != 0) {
  307.  
  308. $methodName = $mapMethodName;
  309. }
  310. }
  311.  
  312. $serialized = NAJAX_Serializer::serialize($methodName);
  313.  
  314. $returnValue .= $serialized;
  315.  
  316. $returnValue .= ':';
  317.  
  318. $returnValue .= 'function(){return najax.call(this,' . $serialized .',arguments)}';
  319.  
  320. if ($index < $length - 1) {
  321.  
  322. $returnValue .= ',';
  323. }
  324.  
  325. $index ++;
  326. }
  327.  
  328. $objectCode[] = $returnValue;
  329. }
  330.  
  331. $returnValue = '{' . join(',', $objectCode) . '}';
  332.  
  333. return $returnValue;
  334.  
  335. } else if (($type == 's_array') || ($type == 'a_array')) {
  336.  
  337. foreach ($var as $key => $value) {
  338.  
  339. $valueType = NAJAX_Utilities::getType($value);
  340.  
  341. if (
  342. ($valueType == 'object') ||
  343. ($valueType == 's_array') ||
  344. ($valueType == 'a_array')) {
  345.  
  346. $var[$key] = NAJAX_SERIALIZER_SKIP_STRING . NAJAX_Client::register($var[$key], $params);
  347. }
  348. }
  349.  
  350. } else if ($type == 'string') {
  351.  
  352. $paramsType = NAJAX_Utilities::getType($params);
  353.  
  354. if ($paramsType == 'string') {
  355.  
  356. if (class_exists($var)) {
  357.  
  358. $classObject = new $var;
  359.  
  360. $classCode = NAJAX_Client::register($classObject, array('class' => $var, 'url' => $params));
  361.  
  362. $classCode = $var . '=function(){return ' . $classCode . '}';
  363.  
  364. return $classCode;
  365. }
  366. }
  367. }
  368.  
  369. return NAJAX_Serializer::serialize($var);
  370. }
  371.  
  372. /**
  373. * Assigns public methods to the class meta data.
  374. *
  375. * @param object $var The object where the meta data is stored.
  376. *
  377. * @param array $methods The class public methods.
  378. *
  379. * @return void
  380. *
  381. * @static
  382. *
  383. */
  384. function publicMethods(&$var, $methods)
  385. {
  386. if (NAJAX_Utilities::getType($var) != 'object') {
  387.  
  388. return false;
  389. }
  390.  
  391. if ( ! isset($var->najaxMeta)) {
  392.  
  393. require_once(NAJAX_BASE . '/classes/Meta.class.php');
  394.  
  395. $var->najaxMeta = new NAJAX_Meta();
  396. }
  397.  
  398. $var->najaxMeta->setPublicMethods($methods);
  399. }
  400.  
  401. /**
  402. * Assigns private methods to the class meta data.
  403. *
  404. * @param object $var The object where the meta data is stored.
  405. *
  406. * @param array $methods The class private methods.
  407. *
  408. * @return void
  409. *
  410. * @static
  411. *
  412. */
  413. function privateMethods(&$var, $methods)
  414. {
  415. if (NAJAX_Utilities::getType($var) != 'object') {
  416.  
  417. return false;
  418. }
  419.  
  420. if ( ! isset($var->najaxMeta)) {
  421.  
  422. require_once(NAJAX_BASE . '/classes/Meta.class.php');
  423.  
  424. $var->najaxMeta = new NAJAX_Meta();
  425. }
  426.  
  427. $var->najaxMeta->setPrivateMethods($methods);
  428. }
  429.  
  430. /**
  431. * Assigns public variables to the class meta data.
  432. *
  433. * @param object $var The object where the meta data is stored.
  434. *
  435. * @param array $variables The class public variables.
  436. *
  437. * @return void
  438. *
  439. * @static
  440. *
  441. */
  442. function publicVariables(&$var, $variables)
  443. {
  444. if (NAJAX_Utilities::getType($var) != 'object') {
  445.  
  446. return false;
  447. }
  448.  
  449. if ( ! isset($var->najaxMeta)) {
  450.  
  451. require_once(NAJAX_BASE . '/classes/Meta.class.php');
  452.  
  453. $var->najaxMeta = new NAJAX_Meta();
  454. }
  455.  
  456. $var->najaxMeta->setPublicVariables($variables);
  457. }
  458.  
  459. /**
  460. * Assigns private variables to the class meta data.
  461. *
  462. * @param object $var The object where the meta data is stored.
  463. *
  464. * @param array $variables The class private variables.
  465. *
  466. * @return void
  467. *
  468. * @static
  469. *
  470. */
  471. function privateVariables(&$var, $variables)
  472. {
  473. if (NAJAX_Utilities::getType($var) != 'object') {
  474.  
  475. return false;
  476. }
  477.  
  478. if ( ! isset($var->najaxMeta)) {
  479.  
  480. require_once(NAJAX_BASE . '/classes/Meta.class.php');
  481.  
  482. $var->najaxMeta = new NAJAX_Meta();
  483. }
  484.  
  485. $var->najaxMeta->setPrivateVariables($variables);
  486. }
  487.  
  488. /**
  489. * Assigns methods map to the class meta data.
  490. *
  491. * @param object $var The object where the meta data is stored.
  492. *
  493. * @param array $methodsMap The class methods map.
  494. *
  495. * @return void
  496. *
  497. * @static
  498. *
  499. */
  500. function mapMethods(&$var, $methodsMap)
  501. {
  502. if (NAJAX_Utilities::getType($var) != 'object') {
  503.  
  504. return false;
  505. }
  506.  
  507. if ( ! isset($var->najaxMeta)) {
  508.  
  509. require_once(NAJAX_BASE . '/classes/Meta.class.php');
  510.  
  511. $var->najaxMeta = new NAJAX_Meta();
  512. }
  513.  
  514. $var->najaxMeta->setMethodsMap($methodsMap);
  515. }
  516.  
  517. /**
  518. * Adds a {@link NAJAX_Client} events observer.
  519. *
  520. * @access public
  521. *
  522. * @param mixed $observer The observer object to add (must extend {@link NAJAX_Observer}).
  523. *
  524. * @return string true on success, false otherwise.
  525. *
  526. * @static
  527. *
  528. */
  529. function addObserver(&$observer)
  530. {
  531. return parent::addObserver($observer, 'NAJAX_Client');
  532. }
  533.  
  534. /**
  535. *
  536. * @access private
  537. *
  538. * @return bool
  539. *
  540. */
  541. function notifyObservers($event = 'default', $arg = null)
  542. {
  543. return parent::notifyObservers($event, $arg, 'NAJAX_Client');
  544. }
  545. }
  546. ?>

Documentation generated on Tue, 20 Sep 2005 21:39:54 +0300 by phpDocumentor 1.3.0RC3