PageRenderTime 832ms CodeModel.GetById 28ms RepoModel.GetById 0ms app.codeStats 1ms

/app/vendors/pipeline.class.php

https://bitbucket.org/ducnv66/bbb-admin
PHP | 1228 lines | 874 code | 243 blank | 111 comment | 71 complexity | 6501f99a66cf0bba4d6a84ac698f499e MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. <?php

    2. 

  2. 

    3. 

  3. require_once(HTML2PS_DIR.'utils_array.php');

    4. 

  4. require_once(HTML2PS_DIR.'utils_graphic.php');

    5. 

  5. require_once(HTML2PS_DIR.'utils_url.php');

    6. 

  6. require_once(HTML2PS_DIR.'utils_text.php');

    7. 

  7. require_once(HTML2PS_DIR.'utils_units.php');

    8. 

  8. require_once(HTML2PS_DIR.'utils_number.php');

    9. 

  9. 

    10. 

  10. require_once(HTML2PS_DIR.'value.color.php');

    11. 

  11. 

    12. 

  12. require_once(HTML2PS_DIR.'config.parse.php');

    13. 

  13. 

    14. 

  14. require_once(HTML2PS_DIR.'flow_context.class.inc.php');

    15. 

  15. require_once(HTML2PS_DIR.'flow_viewport.class.inc.php');

    16. 

  16. 

    17. 

  17. require_once(HTML2PS_DIR.'output._interface.class.php');

    18. 

  18. require_once(HTML2PS_DIR.'output._generic.class.php');

    19. 

  19. require_once(HTML2PS_DIR.'output._generic.pdf.class.php');

    20. 

  20. require_once(HTML2PS_DIR.'output._generic.ps.class.php');

    21. 

  21. require_once(HTML2PS_DIR.'output.pdflib.old.class.php');

    22. 

  22. require_once(HTML2PS_DIR.'output.pdflib.1.6.class.php');

    23. 

  23. require_once(HTML2PS_DIR.'output.fpdf.class.php');

    24. 

  24. require_once(HTML2PS_DIR.'output.fastps.class.php');

    25. 

  25. require_once(HTML2PS_DIR.'output.fastps.l2.class.php');

    26. 

  26. require_once(HTML2PS_DIR.'output.png.class.php');

    27. 

  27. // require_once(HTML2PS_DIR.'output.pcl.class.php');

    28. 

  28. 

    29. 

  29. require_once(HTML2PS_DIR.'stubs.common.inc.php');

    30. 

  30. 

    31. 

  31. require_once(HTML2PS_DIR.'media.layout.inc.php');

    32. 

  32. 

    33. 

  33. require_once(HTML2PS_DIR.'box.php');

    34. 

  34. require_once(HTML2PS_DIR.'box.generic.php');

    35. 

  35. require_once(HTML2PS_DIR.'box.generic.formatted.php');

    36. 

  36. require_once(HTML2PS_DIR.'box.container.php');

    37. 

  37. require_once(HTML2PS_DIR.'box.generic.inline.php');

    38. 

  38. require_once(HTML2PS_DIR.'box.inline.php');

    39. 

  39. require_once(HTML2PS_DIR.'box.inline.control.php');

    40. 

  40. 

    41. 

  41. require_once(HTML2PS_DIR.'font.class.php');

    42. 

  42. require_once(HTML2PS_DIR.'font_factory.class.php');

    43. 

  43. 

    44. 

  44. require_once(HTML2PS_DIR.'box.br.php');

    45. 

  45. require_once(HTML2PS_DIR.'box.block.php');

    46. 

  46. require_once(HTML2PS_DIR.'box.page.php');

    47. 

  47. require_once(HTML2PS_DIR.'box.page.margin.class.php');

    48. 

  48. require_once(HTML2PS_DIR.'box.body.php');

    49. 

  49. require_once(HTML2PS_DIR.'box.block.inline.php');

    50. 

  50. require_once(HTML2PS_DIR.'box.button.php');

    51. 

  51. require_once(HTML2PS_DIR.'box.button.submit.php');

    52. 

  52. require_once(HTML2PS_DIR.'box.button.reset.php');

    53. 

  53. require_once(HTML2PS_DIR.'box.checkbutton.php');

    54. 

  54. require_once(HTML2PS_DIR.'box.form.php');

    55. 

  55. require_once(HTML2PS_DIR.'box.frame.php');

    56. 

  56. require_once(HTML2PS_DIR.'box.iframe.php');

    57. 

  57. require_once(HTML2PS_DIR.'box.input.text.php');

    58. 

  58. require_once(HTML2PS_DIR.'box.input.textarea.php');

    59. 

  59. require_once(HTML2PS_DIR.'box.input.password.php');

    60. 

  60. require_once(HTML2PS_DIR.'box.legend.php');

    61. 

  61. require_once(HTML2PS_DIR.'box.list-item.php');

    62. 

  62. require_once(HTML2PS_DIR.'box.null.php');

    63. 

  63. require_once(HTML2PS_DIR.'box.radiobutton.php');

    64. 

  64. require_once(HTML2PS_DIR.'box.select.php');

    65. 

  65. require_once(HTML2PS_DIR.'box.table.php');

    66. 

  66. require_once(HTML2PS_DIR.'box.table.cell.php');

    67. 

  67. require_once(HTML2PS_DIR.'box.table.cell.fake.php');

    68. 

  68. require_once(HTML2PS_DIR.'box.table.row.php');

    69. 

  69. require_once(HTML2PS_DIR.'box.table.section.php');

    70. 

  70. 

    71. 

  71. require_once(HTML2PS_DIR.'box.text.php');

    72. 

  72. require_once(HTML2PS_DIR.'box.text.string.php');

    73. 

  73. require_once(HTML2PS_DIR.'box.field.pageno.php');

    74. 

  74. require_once(HTML2PS_DIR.'box.field.pages.php');

    75. 

  75. 

    76. 

  76. require_once(HTML2PS_DIR.'box.whitespace.php');

    77. 

  77. 

    78. 

  78. require_once(HTML2PS_DIR.'box.img.php'); // Inherited from the text box!

    79. 

  79. require_once(HTML2PS_DIR.'box.input.img.php');

    80. 

  80. 

    81. 

  81. require_once(HTML2PS_DIR.'box.utils.text-align.inc.php');

    82. 

  82. 

    83. 

  83. require_once(HTML2PS_DIR.'manager.encoding.php');

    84. 

  84. 

    85. 

  85. require_once(HTML2PS_DIR.'ps.unicode.inc.php');

    86. 

  86. require_once(HTML2PS_DIR.'ps.utils.inc.php');

    87. 

  87. require_once(HTML2PS_DIR.'ps.whitespace.inc.php');

    88. 

  88. 

    89. 

  89. require_once(HTML2PS_DIR.'ps.image.encoder.inc.php');

    90. 

  90. require_once(HTML2PS_DIR.'ps.image.encoder.simple.inc.php');

    91. 

  91. require_once(HTML2PS_DIR.'ps.l2.image.encoder.stream.inc.php');

    92. 

  92. require_once(HTML2PS_DIR.'ps.l3.image.encoder.stream.inc.php');

    93. 

  93. 

    94. 

  94. require_once(HTML2PS_DIR.'tag.body.inc.php');

    95. 

  95. require_once(HTML2PS_DIR.'tag.font.inc.php');

    96. 

  96. require_once(HTML2PS_DIR.'tag.frame.inc.php');

    97. 

  97. require_once(HTML2PS_DIR.'tag.input.inc.php');

    98. 

  98. require_once(HTML2PS_DIR.'tag.img.inc.php');

    99. 

  99. require_once(HTML2PS_DIR.'tag.select.inc.php');

    100. 

  100. require_once(HTML2PS_DIR.'tag.span.inc.php');

    101. 

  101. require_once(HTML2PS_DIR.'tag.table.inc.php');

    102. 

  102. require_once(HTML2PS_DIR.'tag.td.inc.php');

    103. 

  103. require_once(HTML2PS_DIR.'tag.utils.inc.php');

    104. 

  104. 

    105. 

  105. require_once(HTML2PS_DIR.'tree.navigation.inc.php');

    106. 

  106. 

    107. 

  107. require_once(HTML2PS_DIR.'html.attrs.inc.php');

    108. 

  108. 

    109. 

  109. require_once(HTML2PS_DIR.'xhtml.autoclose.inc.php');

    110. 

  110. require_once(HTML2PS_DIR.'xhtml.utils.inc.php');

    111. 

  111. require_once(HTML2PS_DIR.'xhtml.tables.inc.php');

    112. 

  112. require_once(HTML2PS_DIR.'xhtml.p.inc.php');

    113. 

  113. require_once(HTML2PS_DIR.'xhtml.lists.inc.php');

    114. 

  114. require_once(HTML2PS_DIR.'xhtml.deflist.inc.php');

    115. 

  115. require_once(HTML2PS_DIR.'xhtml.script.inc.php');

    116. 

  116. require_once(HTML2PS_DIR.'xhtml.entities.inc.php');

    117. 

  117. require_once(HTML2PS_DIR.'xhtml.comments.inc.php');

    118. 

  118. require_once(HTML2PS_DIR.'xhtml.style.inc.php');

    119. 

  119. require_once(HTML2PS_DIR.'xhtml.selects.inc.php');

    120. 

  120. 

    121. 

  121. require_once(HTML2PS_DIR.'background.image.php');

    122. 

  122. require_once(HTML2PS_DIR.'background.position.php');

    123. 

  123. 

    124. 

  124. require_once(HTML2PS_DIR.'list-style.image.php');

    125. 

  125. 

    126. 

  126. require_once(HTML2PS_DIR.'height.php');

    127. 

  127. require_once(HTML2PS_DIR.'width.php');

    128. 

  128. 

    129. 

  129. require_once(HTML2PS_DIR.'css.counter.php');

    130. 

  130. require_once(HTML2PS_DIR.'css.counter.collection.php');

    131. 

  131. 

    132. 

  132. require_once(HTML2PS_DIR.'css.colors.inc.php');

    133. 

  133. 

    134. 

  134. require_once(HTML2PS_DIR.'css.constants.inc.php');

    135. 

  135. require_once(HTML2PS_DIR.'css.inc.php');

    136. 

  136. require_once(HTML2PS_DIR.'css.state.class.php');

    137. 

  137. require_once(HTML2PS_DIR.'css.cache.class.php');

    138. 

  138. require_once(HTML2PS_DIR.'css.property.handler.class.php');

    139. 

  139. require_once(HTML2PS_DIR.'css.property.stringset.class.php');

    140. 

  140. require_once(HTML2PS_DIR.'css.property.sub.class.php');

    141. 

  141. require_once(HTML2PS_DIR.'css.property.sub.field.class.php');

    142. 

  142. require_once(HTML2PS_DIR.'css.utils.inc.php');

    143. 

  143. 

    144. 

  144. require_once(HTML2PS_DIR.'css.background.attachment.inc.php');

    145. 

  145. require_once(HTML2PS_DIR.'css.background.color.inc.php');

    146. 

  146. require_once(HTML2PS_DIR.'css.background.image.inc.php');

    147. 

  147. require_once(HTML2PS_DIR.'css.background.repeat.inc.php');

    148. 

  148. require_once(HTML2PS_DIR.'css.background.position.inc.php');

    149. 

  149. require_once(HTML2PS_DIR.'css.background.inc.php');

    150. 

  150. 

    151. 

  151. require_once(HTML2PS_DIR.'css.border.inc.php');

    152. 

  152. require_once(HTML2PS_DIR.'css.border.style.inc.php');

    153. 

  153. require_once(HTML2PS_DIR.'css.border.collapse.inc.php');

    154. 

  154. require_once(HTML2PS_DIR.'css.bottom.inc.php');

    155. 

  155. require_once(HTML2PS_DIR.'css.clear.inc.php');

    156. 

  156. require_once(HTML2PS_DIR.'css.color.inc.php');

    157. 

  157. require_once(HTML2PS_DIR.'css.direction.inc.php');

    158. 

  158. require_once(HTML2PS_DIR.'css.html2ps.html.content.inc.php');

    159. 

  159. require_once(HTML2PS_DIR.'css.html2ps.pseudoelements.inc.php');

    160. 

  160. require_once(HTML2PS_DIR.'css.html2ps.pixels.php');

    161. 

  161. require_once(HTML2PS_DIR.'css.content.inc.php');

    162. 

  162. require_once(HTML2PS_DIR.'css.display.inc.php');

    163. 

  163. require_once(HTML2PS_DIR.'css.float.inc.php');

    164. 

  164. require_once(HTML2PS_DIR.'css.font.inc.php');

    165. 

  165. require_once(HTML2PS_DIR.'css.height.inc.php');

    166. 

  166. require_once(HTML2PS_DIR.'css.min-height.inc.php');

    167. 

  167. require_once(HTML2PS_DIR.'css.max-height.inc.php');

    168. 

  168. require_once(HTML2PS_DIR.'css.left.inc.php');

    169. 

  169. require_once(HTML2PS_DIR.'css.letter-spacing.inc.php');

    170. 

  170. 

    171. 

  171. require_once(HTML2PS_DIR.'css.list-style-image.inc.php');

    172. 

  172. require_once(HTML2PS_DIR.'css.list-style-position.inc.php');

    173. 

  173. require_once(HTML2PS_DIR.'css.list-style-type.inc.php');

    174. 

  174. require_once(HTML2PS_DIR.'css.list-style.inc.php');

    175. 

  175. 

    176. 

  176. require_once(HTML2PS_DIR.'css.margin.inc.php');

    177. 

  177. require_once(HTML2PS_DIR.'css.overflow.inc.php');

    178. 

  178. require_once(HTML2PS_DIR.'css.padding.inc.php');

    179. 

  179. 

    180. 

  180. require_once(HTML2PS_DIR.'css.page.inc.php');

    181. 

  181. require_once(HTML2PS_DIR.'css.page-break.inc.php');

    182. 

  182. require_once(HTML2PS_DIR.'css.page-break-after.inc.php');

    183. 

  183. require_once(HTML2PS_DIR.'css.page-break-before.inc.php');

    184. 

  184. require_once(HTML2PS_DIR.'css.page-break-inside.inc.php');

    185. 

  185. require_once(HTML2PS_DIR.'css.orphans.inc.php');

    186. 

  186. require_once(HTML2PS_DIR.'css.size.inc.php');

    187. 

  187. require_once(HTML2PS_DIR.'css.widows.inc.php');

    188. 

  188. 

    189. 

  189. require_once(HTML2PS_DIR.'css.position.inc.php');

    190. 

  190. require_once(HTML2PS_DIR.'css.right.inc.php');

    191. 

  191. require_once(HTML2PS_DIR.'css.property.declaration.php');

    192. 

  192. require_once(HTML2PS_DIR.'css.rules.inc.php');

    193. 

  193. require_once(HTML2PS_DIR.'css.ruleset.class.php');

    194. 

  194. require_once(HTML2PS_DIR.'css.selectors.inc.php');

    195. 

  195. require_once(HTML2PS_DIR.'css.table-layout.inc.php');

    196. 

  196. require_once(HTML2PS_DIR.'css.text-align.inc.php');

    197. 

  197. require_once(HTML2PS_DIR.'css.text-decoration.inc.php');

    198. 

  198. require_once(HTML2PS_DIR.'css.text-transform.inc.php');

    199. 

  199. require_once(HTML2PS_DIR.'css.text-indent.inc.php');

    200. 

  200. require_once(HTML2PS_DIR.'css.top.inc.php');

    201. 

  201. require_once(HTML2PS_DIR.'css.vertical-align.inc.php');

    202. 

  202. require_once(HTML2PS_DIR.'css.visibility.inc.php');

    203. 

  203. require_once(HTML2PS_DIR.'css.white-space.inc.php');

    204. 

  204. require_once(HTML2PS_DIR.'css.width.inc.php');

    205. 

  205. require_once(HTML2PS_DIR.'css.word-spacing.inc.php');

    206. 

  206. require_once(HTML2PS_DIR.'css.z-index.inc.php');

    207. 

  207. 

    208. 

  208. require_once(HTML2PS_DIR.'css.pseudo.add.margin.inc.php');

    209. 

  209. require_once(HTML2PS_DIR.'css.pseudo.align.inc.php');

    210. 

  210. require_once(HTML2PS_DIR.'css.pseudo.cellspacing.inc.php');

    211. 

  211. require_once(HTML2PS_DIR.'css.pseudo.cellpadding.inc.php');

    212. 

  212. require_once(HTML2PS_DIR.'css.pseudo.form.action.inc.php');

    213. 

  213. require_once(HTML2PS_DIR.'css.pseudo.form.radiogroup.inc.php');

    214. 

  214. require_once(HTML2PS_DIR.'css.pseudo.link.destination.inc.php');

    215. 

  215. require_once(HTML2PS_DIR.'css.pseudo.link.target.inc.php');

    216. 

  216. require_once(HTML2PS_DIR.'css.pseudo.listcounter.inc.php');

    217. 

  217. require_once(HTML2PS_DIR.'css.pseudo.localalign.inc.php');

    218. 

  218. require_once(HTML2PS_DIR.'css.pseudo.nowrap.inc.php');

    219. 

  219. require_once(HTML2PS_DIR.'css.pseudo.table.border.inc.php');

    220. 

  220. 

    221. 

  221. // After all CSS utilities and constants have been initialized, load the default (precomiled) CSS stylesheet

    222. 

  222. require_once(HTML2PS_DIR.'converter.class.php');

    223. 

  223. require_once(HTML2PS_DIR.'treebuilder.class.php');

    224. 

  224. require_once(HTML2PS_DIR.'image.class.php');

    225. 

  225. 

    226. 

  226. require_once(HTML2PS_DIR.'fetched_data._interface.class.php');

    227. 

  227. require_once(HTML2PS_DIR.'fetched_data._html.class.php');

    228. 

  228. require_once(HTML2PS_DIR.'fetched_data.url.class.php');

    229. 

  229. require_once(HTML2PS_DIR.'fetched_data.file.class.php');

    230. 

  230. 

    231. 

  231. require_once(HTML2PS_DIR.'filter.data._interface.class.php');

    232. 

  232. require_once(HTML2PS_DIR.'filter.data.doctype.class.php');

    233. 

  233. 

    234. 

  234. require_once(HTML2PS_DIR.'filter.data.utf8.class.php');

    235. 

  235. require_once(HTML2PS_DIR.'filter.data.ucs2.class.php');

    236. 

  236. 

    237. 

  237. require_once(HTML2PS_DIR.'filter.data.html2xhtml.class.php');

    238. 

  238. require_once(HTML2PS_DIR.'filter.data.xhtml2xhtml.class.php');

    239. 

  239. 

    240. 

  240. require_once(HTML2PS_DIR.'parser._interface.class.php');

    241. 

  241. require_once(HTML2PS_DIR.'parser.xhtml.class.php');

    242. 

  242. 

    243. 

  243. require_once(HTML2PS_DIR.'filter.pre._interface.class.php');

    244. 

  244. require_once(HTML2PS_DIR.'filter.pre.fields.class.php');

    245. 

  245. require_once(HTML2PS_DIR.'filter.pre.headfoot.class.php');

    246. 

  246. require_once(HTML2PS_DIR.'filter.pre.footnotes.class.php');

    247. 

  247. require_once(HTML2PS_DIR.'filter.pre.height-constraint.class.php');

    248. 

  248. 

    249. 

  249. require_once(HTML2PS_DIR.'layout._interface.class.php');

    250. 

  250. require_once(HTML2PS_DIR.'layout.default.class.php');

    251. 

  251. require_once(HTML2PS_DIR.'layout.page.breaks.php');

    252. 

  252. 

    253. 

  253. require_once(HTML2PS_DIR.'filter.post._interface.class.php');

    254. 

  254. require_once(HTML2PS_DIR.'filter.post.positioned.class.php');

    255. 

  255. require_once(HTML2PS_DIR.'filter.post.postponed.class.php');

    256. 

  256. 

    257. 

  257. require_once(HTML2PS_DIR.'filter.output._interface.class.php');

    258. 

  258. require_once(HTML2PS_DIR.'filter.output.ps2pdf.class.php');

    259. 

  259. require_once(HTML2PS_DIR.'filter.output.gzip.class.php');

    260. 

  260. 

    261. 

  261. require_once(HTML2PS_DIR.'destination._interface.class.php');

    262. 

  262. require_once(HTML2PS_DIR.'destination._http.class.php');

    263. 

  263. require_once(HTML2PS_DIR.'destination.browser.class.php');

    264. 

  264. require_once(HTML2PS_DIR.'destination.download.class.php');

    265. 

  265. require_once(HTML2PS_DIR.'destination.file.class.php');

    266. 

  266. 

    267. 

  267. require_once(HTML2PS_DIR.'xml.validation.inc.php');

    268. 

  268. 

    269. 

  269. require_once(HTML2PS_DIR.'content_type.class.php');

    270. 

  270. require_once(HTML2PS_DIR.'dispatcher.class.php');

    271. 

  271. require_once(HTML2PS_DIR.'observer.class.php');

    272. 

  272. 

    273. 

  273. require_once(HTML2PS_DIR.'strategy.page.break.simple.php');

    274. 

  274. require_once(HTML2PS_DIR.'strategy.page.break.smart.php');

    275. 

  275. 

    276. 

  276. require_once(HTML2PS_DIR.'strategy.link.rendering.normal.php');

    277. 

  277. require_once(HTML2PS_DIR.'strategy.position.absolute.php');

    278. 

  278. require_once(HTML2PS_DIR.'strategy.width.absolute.positioned.php');

    279. 

  279. require_once(HTML2PS_DIR.'autofix.url.php');

    280. 

  280. 

    281. 

  281. require_once(HTML2PS_DIR.'fetcher._interface.class.php');

    282. 

  282. require_once(HTML2PS_DIR.'features/_factory.php');

    283. 

  283. 

    284. 

  284. require_once(HTML2PS_DIR.'css.property.collection.php');

    285. 

  285. require_once(HTML2PS_DIR.'css.rules.page.inc.php');

    286. 

  286. 

    287. 

  287. require_once(HTML2PS_DIR.'css/lexer.php');

    288. 

  288. require_once(HTML2PS_DIR.'css/parser.php');

    289. 

  289. require_once(HTML2PS_DIR.'css/stream.string.php');

    290. 

  290. require_once(HTML2PS_DIR.'css/processor.php');

    291. 

  291. 

    292. 

  292. class Pipeline {

    293. 

  293.   var $fetchers;

    294. 

  294.   var $data_filters;

    295. 

  295.   var $error_message;

    296. 

  296.   var $parser;

    297. 

  297.   var $pre_tree_filters;

    298. 

  298.   var $layout_engine;

    299. 

  299.   var $post_tree_filters;

    300. 

  300.   var $output_driver;

    301. 

  301.   var $output_filters;

    302. 

  302.   var $destination;

    303. 

  303. 

    304. 

  304.   var $_base_url;

    305. 

  305. 

    306. 

  306.   var $_page_at_rules;

    307. 

  307.   var $_counters;

    308. 

  308.   var $_footnotes;

    309. 

  309. 

    310. 

  310.   var $_cssState;

    311. 

  311.   var $_css;

    312. 

  312.   var $_defaultCSS;

    313. 

  313. 

    314. 

  314.   var $_dispatcher;

    315. 

  315. 

    316. 

  316.   var $_current_page_name;

    317. 

  317. 

    318. 

  318.   var $_page_break_strategy;

    319. 

  319. 

    320. 

  320.   function Pipeline() {

    321. 

  321.     $this->_css = array();

    322. 

  322. 

    323. 

  323.     $this->_counters = array();

    324. 

  324.     $this->_footnotes = array();

    325. 

  325. 

    326. 

  326.     $this->_base_url = array('');

    327. 

  327.     $this->_reset_page_at_rules();

    328. 

  328. 

    329. 

  329.     $this->pre_tree_filters = array();

    330. 

  330. 

    331. 

  331.     $this->_dispatcher =& new DispatcherPdf();

    332. 

  332. 

    333. 

  333.     $this->_dispatcher->add_event('before-page-heights');

    334. 

  334.     $this->_dispatcher->add_event('before-page');

    335. 

  335.     $this->_dispatcher->add_event('after-page');

    336. 

  336.     $this->_dispatcher->add_event('before-batch-item');

    337. 

  337.     $this->_dispatcher->add_event('after-batch-item');

    338. 

  338.     $this->_dispatcher->add_event('after-parse');

    339. 

  339.     $this->_dispatcher->add_event('before-document');

    340. 

  340.     $this->_dispatcher->add_event('after-document');

    341. 

  341.     $this->_dispatcher->add_event('before-batch');

    342. 

  342.     $this->_dispatcher->add_event('after-batch');

    343. 

  343. 

    344. 

  344.     $this->_page_break_strategy = new StrategyPageBreakSimple();

    345. 

  345.   }

    346. 

  346. 

    347. 

  347.   function add_feature($feature_name, $params = array()) {

    348. 

  348.     $feature_object =& FeatureFactory::get($feature_name);

    349. 

  349.     if (is_null($feature_object)) {

    350. 

  350.       die(sprintf('No feature "%s" found', $feature_name));

    351. 

  351.     };

    352. 

  352. 

    353. 

  353.     $feature_object->install($this, $params);

    354. 

  354.   }

    355. 

  355. 

    356. 

  356.   function add_fetcher(&$fetcher) {

    357. 

  357.     array_unshift($this->fetchers, $fetcher);

    358. 

  358.   }

    359. 

  359. 

    360. 

  360.   function calculate_page_heights(&$media, &$box) {

    361. 

  361.     return $this->_page_break_strategy->run($this, $media, $box);

    362. 

  362.   }

    363. 

  363. 

    364. 

  364.   function clear_box_id_map() {

    365. 

  365.     $GLOBALS['__html_box_id_map'] = array();

    366. 

  366.   }

    367. 

  367. 

    368. 

  368.   function close() {

    369. 

  369.     $this->_dispatcher->fire('after-batch', array('pipeline' => &$this));

    370. 

  370. 

    371. 

  371.     $this->output_driver->close();

    372. 

  372.     $this->_output();

    373. 

  373.     $this->output_driver->release();   

    374. 

  374. 

    375. 

  375.     // Non HTML-specific cleanup

    376. 

  376.     //

    377. 

  377.     ImageFactory::clear_cache();

    378. 

  378.   }

    379. 

  379. 

    380. 

  380.   function configure($options) {

    381. 

  381.     $defaults = array('compress'      => false,

    382. 

  382.                       'cssmedia'      => 'screen',

    383. 

  383.                       'debugbox'      => false,

    384. 

  384.                       'debugnoclip'   => false,

    385. 

  385.                       'draw_page_border' => false,

    386. 

  386.                       'encoding'      => '',

    387. 

  387.                       'html2xhtml'    => true,

    388. 

  388.                       'imagequality_workaround' => false,

    389. 

  389.                       'landscape'     => false,

    390. 

  390.                       'margins'       => array('left' => 30,

    391. 

  391.                                                'right' => 15,

    392. 

  392.                                                'top' => 15,

    393. 

  393.                                                'bottom' => 15),

    394. 

  394.                       'media'         => 'A4',

    395. 

  395.                       'method'        => 'fpdf',

    396. 

  396.                       'mode'          => 'html',

    397. 

  397.                       'output'        => 0,

    398. 

  398.                       'pagewidth'     => 800,

    399. 

  399.                       'pdfversion'    => "1.2",

    400. 

  400.                       'ps2pdf'        => false,

    401. 

  401.                       'pslevel'       => 3,

    402. 

  402.                       'renderfields'  => false,

    403. 

  403.                       'renderforms'   => false,

    404. 

  404.                       'renderimages'  => true,

    405. 

  405.                       'renderlinks'   => false,

    406. 

  406.                       'scalepoints'   => true,

    407. 

  407.                       'smartpagebreak' => true,

    408. 

  408.                       'transparency_workaround' => false

    409. 

  409.                       );

    410. 

  410. 

    411. 

  411.     // As a reminder: If the input arrays have the same string keys, then the later value for that key will overwrite the previous one.

    412. 

  412.     $GLOBALS['g_config'] = array_merge($defaults, $options);

    413. 

  413. 

    414. 

  414.     // Note that CSS media names should be case-insensitive

    415. 

  415.     $GLOBALS['g_config']['cssmedia'] = strtolower($GLOBALS['g_config']['cssmedia']);

    416. 

  416. 

    417. 

  417.     if ($GLOBALS['g_config']['smartpagebreak']) {

    418. 

  418.       $this->_page_break_strategy = new StrategyPageBreakSmart();

    419. 

  419.     } else {

    420. 

  420.       $this->_page_break_strategy = new StrategyPageBreakSimple();

    421. 

  421.     };

    422. 

  422.   }

    423. 

  423. 

    424. 

  424.   function _addFootnote(&$note_call) {

    425. 

  425.     $this->_footnotes[] =& $note_call;

    426. 

  426.   }

    427. 

  427. 

    428. 

  428. //   function _fillContent($content) {

    429. 

  429. //     $filled = "";

    430. 

  430. 

    431. 

  431. //     while (preg_match("/^.*?('.*?'|\".*?\"|counter\(.*?\))(.*)$/", $content, $matches)) {

    432. 

  432. //       $data    = $matches[1];

    433. 

  433. //       $content = $matches[2];

    434. 

  434.       

    435. 

  435. //       if ($data{0} != '\'' && $data{0} != '"') {

    436. 

  436. //         $filled .= $this->_fillContentCounter($data);

    437. 

  437. //       } else {

    438. 

  438. //         $filled .= $this->_fillContentString($data);

    439. 

  439. //       };

    440. 

  440. //     };

    441. 

  441. 

    442. 

  442. //     return $filled;

    443. 

  443. //   }

    444. 

  444. 

    445. 

  445. //   function _fillContentString($content) {

    446. 

  446. //     $unescaped_content = css_process_escapes($content);

    447. 

  447. //     $unquoted_content = css_remove_value_quotes($unescaped_content);

    448. 

  448. //     return $unquoted_content;

    449. 

  449. //   }

    450. 

  450. 

    451. 

  451. //   function _fillContentCounter($content) {

    452. 

  452. //     preg_match("/counter\((.*?)\)/", $content, $matches);

    453. 

  453. //     return $this->get_counter($matches[1]);

    454. 

  454. //   }

    455. 

  455. 

    456. 

  456.   function &get_counters() {

    457. 

  457.     $counter_collection =& new CSSCounterCollection();

    458. 

  458. 

    459. 

  459.     foreach ($this->_counters as $counter_name => $counter_value) {

    460. 

  460.       $counter =& new CSSCounter($counter_name);

    461. 

  461.       $counter->set($counter_value);

    462. 

  462.       $counter_collection->add($counter);

    463. 

  463.     };

    464. 

  464. 

    465. 

  465.     return $counter_collection;

    466. 

  466.   }

    467. 

  467. 

    468. 

  468.   function &get_dispatcher() {

    469. 

  469.     return $this->_dispatcher;

    470. 

  470.   }

    471. 

  471. 

    472. 

  472.   function get_counter($counter) {

    473. 

  473.     if (isset($this->_counters[$counter])) { 

    474. 

  474.       return $this->_counters[$counter];

    475. 

  475.     };

    476. 

  476. 

    477. 

  477.     /**

    478. 

  478.      * CSS  2.1:   Counters  that  are   not  in  the  scope   of  any

    479. 

  479.      * 'counter-reset',  are assumed  to have  been  reset to  0 by  a

    480. 

  480.      * 'counter-reset' on the root element.

    481. 

  481.      */

    482. 

  482.     return 0;

    483. 

  483.   }

    484. 

  484. 

    485. 

  485.   function reset_counter($counter, $value) {

    486. 

  486.     $this->_counters[$counter] = $value;

    487. 

  487.   }

    488. 

  488. 

    489. 

  489.   function increment_counter($counter, $value) {

    490. 

  490.     $this->_counters[$counter] += $value;

    491. 

  491.   }

    492. 

  492. 

    493. 

  493.   function add_at_rule_page($at_rule) {

    494. 

  494.     $selector =& $at_rule->getSelector();

    495. 

  495.     $type = $selector->get_type();

    496. 

  496.     $this->_page_at_rules[$type][] = $at_rule;

    497. 

  497.   }

    498. 

  498. 

    499. 

  499.   function _reset_page_at_rules() {

    500. 

  500.     $this->_page_at_rules = array(CSS_PAGE_SELECTOR_ALL   => array(),

    501. 

  501.                                   CSS_PAGE_SELECTOR_FIRST => array(),

    502. 

  502.                                   CSS_PAGE_SELECTOR_LEFT  => array(),

    503. 

  503.                                   CSS_PAGE_SELECTOR_RIGHT => array(),

    504. 

  504.                                   CSS_PAGE_SELECTOR_NAMED => array());

    505. 

  505.   }

    506. 

  506. 

    507. 

  507.   function &get_default_css() {

    508. 

  508.     return $this->_defaultCSS;

    509. 

  509.   }

    510. 

  510. 

    511. 

  511.   function &get_current_css() {

    512. 

  512.     return $this->_css[0];

    513. 

  513.   }

    514. 

  514. 

    515. 

  515.   function &get_current_css_state() {

    516. 

  516.     return $this->_cssState[0];

    517. 

  517.   }

    518. 

  518. 

    519. 

  519.   function push_css() {

    520. 

  520.     array_unshift($this->_css, new CSSRuleset());

    521. 

  521.   }

    522. 

  522. 

    523. 

  523.   function pop_css() {

    524. 

  524.     array_shift($this->_css);

    525. 

  525.   }

    526. 

  526. 

    527. 

  527.   /**

    528. 

  528.    * Note that different pages  may define different margin boxes (for

    529. 

  529.    * example,  left and right  pages may  have different  headers). In

    530. 

  530.    * this  case, we  should  process  @page rules  in  order of  their

    531. 

  531.    * specificity (no selector  < :left / :right <  :first) and extract

    532. 

  532.    * margin boxes to be drawn

    533. 

  533.    *

    534. 

  534.    * @param $page_no Integer current page index (1-based)

    535. 

  535.    * @param $media 

    536. 

  536.    */

    537. 

  537.   function render_margin_boxes($page_no, &$media) {

    538. 

  538.     $boxes =& $this->reflow_margin_boxes($page_no, $media);

    539. 

  539. 

    540. 

  540.     foreach ($boxes as $selector => $box) {

    541. 

  541.       $boxes[$selector]->show($this->output_driver);

    542. 

  542.     };

    543. 

  543. 

    544. 

  544.     // Memleak fix

    545. 

  545.     for ($i=0, $size = count($boxes); $i < $size; $i++) {

    546. 

  546.       $boxes[$i]->destroy();

    547. 

  547.     };

    548. 

  548.     unset($boxes);

    549. 

  549.   }

    550. 

  550. 

    551. 

  551.   function get_page_media($page_no, &$media) {

    552. 

  552.     $page_rules =& $this->get_page_rules($page_no);

    553. 

  553.     $size_landscape = $page_rules->get_property_value(CSS_SIZE);

    554. 

  554.     if (!is_null($size_landscape)) {

    555. 

  555.       $media->set_width($size_landscape['size']['width']);

    556. 

  556.       $media->set_height($size_landscape['size']['height']);

    557. 

  557.       $media->set_landscape($size_landscape['landscape']);

    558. 

  558.     };

    559. 

  559. 

    560. 

  560.     $margins = $page_rules->get_property_value(CSS_MARGIN);

    561. 

  561.     if (!is_null($margins)) {

    562. 

  562.       $media->margins['left'] = $margins->left->calc(mm2pt($media->get_width())) / mm2pt(1) / pt2pt(1);

    563. 

  563.       $media->margins['right'] = $margins->right->calc(mm2pt($media->get_width())) / mm2pt(1) / pt2pt(1);

    564. 

  564.       $media->margins['top'] = $margins->top->calc(mm2pt($media->get_height())) / mm2pt(1) / pt2pt(1);

    565. 

  565.       $media->margins['bottom'] = $margins->bottom->calc(mm2pt($media->get_height())) / mm2pt(1) / pt2pt(1);

    566. 

  566.     };

    567. 

  567. 

    568. 

  568.     $left_margin = $page_rules->get_property_value(CSS_MARGIN_LEFT);

    569. 

  569.     if (!is_null($left_margin)) {

    570. 

  570.       $media->margins['left'] = $left_margin->calc(mm2pt($media->get_width())) / mm2pt(1) / pt2pt(1);

    571. 

  571.     };

    572. 

  572. 

    573. 

  573.     $right_margin = $page_rules->get_property_value(CSS_MARGIN_RIGHT);

    574. 

  574.     if (!is_null($right_margin)) {

    575. 

  575.       $media->margins['right'] = $right_margin->calc(mm2pt($media->get_width())) / mm2pt(1) / pt2pt(1);

    576. 

  576.     };

    577. 

  577. 

    578. 

  578.     $top_margin = $page_rules->get_property_value(CSS_MARGIN_TOP);

    579. 

  579.     if (!is_null($top_margin)) {

    580. 

  580.       $media->margins['top'] = $top_margin->calc(mm2pt($media->get_height())) / mm2pt(1) / pt2pt(1);

    581. 

  581.     };

    582. 

  582. 

    583. 

  583.     $bottom_margin = $page_rules->get_property_value(CSS_MARGIN_BOTTOM);

    584. 

  584.     if (!is_null($bottom_margin)) {

    585. 

  585.       $media->margins['bottom'] = $bottom_margin->calc(mm2pt($media->get_height())) / mm2pt(1) / pt2pt(1);

    586. 

  586.     };

    587. 

  587. 

    588. 

  588.     $pixels = $page_rules->get_property_value(CSS_HTML2PS_PIXELS);

    589. 

  589.     if (!is_null($pixels)) {

    590. 

  590.       $media->set_pixels($pixels);

    591. 

  591.     };

    592. 

  592.   }

    593. 

  593. 

    594. 

  594.   function &get_page_rules($page_no) {

    595. 

  595.     $collection =& new CSSPropertyCollection();

    596. 

  596. 

    597. 

  597.     foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_ALL] as $rule) {

    598. 

  598.       $collection->merge($rule->css);

    599. 

  599.     };

    600. 

  600. 

    601. 

  601.     /**

    602. 

  602.      * Check which one of :right/:left selector is applicable (assuming that first page matches :right)

    603. 

  603.      */

    604. 

  604.     if ($page_no % 2 == 0) {

    605. 

  605.       foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_LEFT] as $rule) {

    606. 

  606.         $collection->merge($rule->css);

    607. 

  607.       };

    608. 

  608.     } else {

    609. 

  609.       foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_RIGHT] as $rule) {

    610. 

  610.         $collection->merge($rule->css);

    611. 

  611.       };

    612. 

  612.     };

    613. 

  613. 

    614. 

  614.     if ($page_no == 1) {

    615. 

  615.       foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_FIRST] as $rule) {

    616. 

  616.         $collection->merge($rule->css);

    617. 

  617.       };

    618. 

  618.     };

    619. 

  619. 

    620. 

  620.     return $collection;

    621. 

  621.   }

    622. 

  622. 

    623. 

  623.   function &reflow_page_box($page_no, &$media) {

    624. 

  624.     $rules =& $this->get_page_rules($page_no);

    625. 

  625.     $box =& BoxPage::create($this, $rules);

    626. 

  626.     $box->reflow($media);

    627. 

  627.     return $box;

    628. 

  628.   }

    629. 

  629. 

    630. 

  630.   function render_page_box($page_no, &$media) {

    631. 

  631.     $box =& $this->reflow_page_box($page_no, $media);

    632. 

  632.     $box->show($this->output_driver);

    633. 

  633.     $box->destroy();

    634. 

  634.     unset($box);

    635. 

  635.   }

    636. 

  636. 

    637. 

  637.   function &reflow_margin_boxes($page_no, &$media) {

    638. 

  638.     $at_rules = $this->_getMarginBoxes($page_no, $media);

    639. 

  639. 

    640. 

  640.     $boxes = array();

    641. 

  641.     foreach ($at_rules as $at_rule) {

    642. 

  642.       $selector = $at_rule->getSelector();

    643. 

  643.       $boxes[$selector] =& BoxPageMargin::create($this, $at_rule);

    644. 

  644.     };

    645. 

  645. 

    646. 

  646.     foreach ($boxes as $selector => $box) {

    647. 

  647.       $linebox_started     = false;

    648. 

  648.       $previous_whitespace = false;

    649. 

  649.       $boxes[$selector]->reflow_whitespace($linebox_started, $previous_whitespace);

    650. 

  650.       $boxes[$selector]->reflow_text($this->output_driver);

    651. 

  651.     };

    652. 

  652. 

    653. 

  653.     foreach ($boxes as $selector => $box) {

    654. 

  654.       $boxes[$selector]->reflow($this->output_driver, 

    655. 

  655.                                 $media,

    656. 

  656.                                 $boxes);

    657. 

  657.     };

    658. 

  658. 

    659. 

  659.     return $boxes;

    660. 

  660.   }

    661. 

  661. 

    662. 

  662.   /**

    663. 

  663.    * Note that "+" operation on arrays will preserve existing elements; thus

    664. 

  664.    * we need to process @page rules in order of decreasing specificity

    665. 

  665.    *

    666. 

  666.    */

    667. 

  667.   function _getMarginBoxes($page_no, $media) {

    668. 

  668.     $applicable_margin_boxes = array();

    669. 

  669. 

    670. 

  670.     /**

    671. 

  671.      * Check if :first selector is applicable

    672. 

  672.      */

    673. 

  673.     if ($page_no == 1) {

    674. 

  674.       foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_FIRST] as $rule) {

    675. 

  675.         $applicable_margin_boxes = $applicable_margin_boxes + $rule->getAtRuleMarginBoxes();

    676. 

  676.       };

    677. 

  677.     };

    678. 

  678. 

    679. 

  679.     /**

    680. 

  680.      * Check which one of :right/:left selector is applicable (assuming that first page matches :right)

    681. 

  681.      */

    682. 

  682.     if ($page_no % 2 == 0) {

    683. 

  683.       foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_LEFT] as $rule) {

    684. 

  684.         $applicable_margin_boxes = $applicable_margin_boxes +  $rule->getAtRuleMarginBoxes();

    685. 

  685.       };

    686. 

  686.     } else {

    687. 

  687.       foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_RIGHT] as $rule) {

    688. 

  688.         $applicable_margin_boxes = $applicable_margin_boxes +  $rule->getAtRuleMarginBoxes();

    689. 

  689.       };

    690. 

  690.     };

    691. 

  691. 

    692. 

  692.     /**

    693. 

  693.      * Extract margin boxes from plain @page rules

    694. 

  694.      */

    695. 

  695.     foreach ($this->_page_at_rules[CSS_PAGE_SELECTOR_ALL] as $rule) {

    696. 

  696.       $applicable_margin_boxes = $applicable_margin_boxes + $rule->getAtRuleMarginBoxes();

    697. 

  697.     };

    698. 

  698. 

    699. 

  699.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP])) { 

    700. 

  700.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP] =& 

    701. 

  701.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_TOP,$this); 

    702. 

  702.     };

    703. 

  703. 

    704. 

  704.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_LEFT_CORNER])) { 

    705. 

  705.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_LEFT_CORNER] =& 

    706. 

  706.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_TOP_LEFT_CORNER,$this); 

    707. 

  707.     };

    708. 

  708. 

    709. 

  709.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_LEFT])) { 

    710. 

  710.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_LEFT] =& 

    711. 

  711.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_TOP_LEFT,$this); 

    712. 

  712.     };

    713. 

  713. 

    714. 

  714.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_CENTER])) { 

    715. 

  715.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_CENTER] =& 

    716. 

  716.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_TOP_CENTER,$this); 

    717. 

  717.     };

    718. 

  718. 

    719. 

  719.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_RIGHT])) { 

    720. 

  720.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_RIGHT] =& 

    721. 

  721.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_TOP_RIGHT,$this); 

    722. 

  722.     };

    723. 

  723. 

    724. 

  724.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_RIGHT_CORNER])) { 

    725. 

  725.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_TOP_RIGHT_CORNER] =& 

    726. 

  726.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_TOP_RIGHT_CORNER,$this); 

    727. 

  727.     };

    728. 

  728. 

    729. 

  729.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM])) { 

    730. 

  730.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM] =& 

    731. 

  731.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_BOTTOM,$this); 

    732. 

  732.     };

    733. 

  733. 

    734. 

  734.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_LEFT_CORNER])) { 

    735. 

  735.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_LEFT_CORNER] =& 

    736. 

  736.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_BOTTOM_LEFT_CORNER,$this); 

    737. 

  737.     };

    738. 

  738. 

    739. 

  739.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_LEFT])) { 

    740. 

  740.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_LEFT] =& 

    741. 

  741.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_BOTTOM_LEFT,$this); 

    742. 

  742.     };

    743. 

  743. 

    744. 

  744.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_CENTER])) { 

    745. 

  745.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_CENTER] =& 

    746. 

  746.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_BOTTOM_CENTER,$this); 

    747. 

  747.     };

    748. 

  748. 

    749. 

  749.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_RIGHT])) { 

    750. 

  750.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_RIGHT] =& 

    751. 

  751.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_BOTTOM_RIGHT,$this); 

    752. 

  752.     };

    753. 

  753. 

    754. 

  754.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_RIGHT_CORNER])) { 

    755. 

  755.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_BOTTOM_RIGHT_CORNER] =& 

    756. 

  756.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_BOTTOM_RIGHT_CORNER,$this); 

    757. 

  757.     };

    758. 

  758. 

    759. 

  759.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_LEFT_TOP])) { 

    760. 

  760.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_LEFT_TOP] =& 

    761. 

  761.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_LEFT_TOP,$this); 

    762. 

  762.     };

    763. 

  763. 

    764. 

  764.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_LEFT_MIDDLE])) { 

    765. 

  765.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_LEFT_MIDDLE] =& 

    766. 

  766.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_LEFT_MIDDLE,$this); 

    767. 

  767.     };

    768. 

  768. 

    769. 

  769.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_LEFT_BOTTOM])) { 

    770. 

  770.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_LEFT_BOTTOM] =& 

    771. 

  771.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_LEFT_BOTTOM,$this); 

    772. 

  772.     };

    773. 

  773. 

    774. 

  774.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_RIGHT_TOP])) { 

    775. 

  775.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_RIGHT_TOP] =& 

    776. 

  776.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_RIGHT_TOP,$this); 

    777. 

  777.     };

    778. 

  778. 

    779. 

  779.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_RIGHT_MIDDLE])) { 

    780. 

  780.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_RIGHT_MIDDLE] =& 

    781. 

  781.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_RIGHT_MIDDLE,$this); 

    782. 

  782.     };

    783. 

  783. 

    784. 

  784.     if (!isset($applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_RIGHT_BOTTOM])) { 

    785. 

  785.       $applicable_margin_boxes[CSS_MARGIN_BOX_SELECTOR_RIGHT_BOTTOM] =&

    786. 

  786.         new CSSAtRuleMarginBox(CSS_MARGIN_BOX_SELECTOR_RIGHT_BOTTOM,$this); 

    787. 

  787.     };

    788. 

  788. 

    789. 

  789.     return $applicable_margin_boxes;

    790. 

  790.   }

    791. 

  791. 

    792. 

  792.   function _process_item($data_id, &$media, $offset=0) {    

    793. 

  793.     $this->_dispatcher->fire('before-batch-item', array('pipeline' => &$this));

    794. 

  794. 

    795. 

  795.     $box =& $this->_layout_item($data_id, $media, $offset, $context, $postponed_filter);

    796. 

  796. 

    797. 

  797.     if (is_null($box)) {

    798. 

  798.       error_log(sprintf(_('Could not fetch: %s'), (string)$data_id));

    799. 

  799.       return true;

    800. 

  800.     };

    801. 

  801. 

    802. 

  802.     $this->_show_item($box, $offset, $context, $media, $postponed_filter);

    803. 

  803. 

    804. 

  804.     // Clear CSS for this item 

    805. 

  805.     $this->pop_css();

    806. 

  806.     $this->_defaultCSS = null;

    807. 

  807. 

    808. 

  808.     // Memory leak fix: caused by circular references?

    809. 

  809.     $box->destroy();

    810. 

  810. 

    811. 

  811.     $this->_dispatcher->fire('after-batch-item', array('pipeline' => &$this));

    812. 

  812.     return true;

    813. 

  813.   }

    814. 

  814. 

    815. 

  815.   function _show_item(&$box, $offset, &$context, &$media, &$postponed_filter) {

    816. 

  816.     $context->sort_absolute_positioned_by_z_index();

    817. 

  817. 

    818. 

  818.     $this->_dispatcher->fire('before-page-heights', array('pipeline' => &$this, 

    819. 

  819.                                                           'document' => &$box,

    820. 

  820.                                                           'media' => &$media));

    821. 

  821. 

    822. 

  822.     // Make batch-processing offset

    823. 

  823.     $page_heights = $this->calculate_page_heights($media, $box);

    824. 

  824.     $box->offset(0, $offset);

    825. 

  825. 

    826. 

  826.     $box->reflow_anchors($this->output_driver, $this->output_driver->anchors, $page_heights);

    827. 

  827.     

    828. 

  828.     $this->_dispatcher->fire('before-document', array('pipeline' => &$this, 

    829. 

  829.                                                       'document' => &$box,

    830. 

  830.                                                       'page-heights' => &$page_heights,

    831. 

  831.                                                       'media' => &$media));

    832. 

  832. 

    833. 

  833.     $expected_pages = count($page_heights);

    834. 

  834.     $this->output_driver->set_expected_pages($expected_pages);

    835. 

  835.     $this->reset_counter('pages', $expected_pages);

    836. 

  836.     $this->reset_counter('page',  0);

    837. 

  837. 

    838. 

  838.     // Output PDF pages using chosen PDF driver

    839. 

  839.     for ($i=0; $i<$expected_pages; $i++) {

    840. 

  840.       $this->get_page_media(1, $media);

    841. 

  841. 

    842. 

  842.       $this->output_driver->update_media($media);

    843. 

  843.       $this->_setupScales($media);

    844. 

  844. 

    845. 

  845.       $current_page_offset = $i == 0 ? 0 : $page_heights[$i-1];

    846. 

  846.       $current_page_height = $page_heights[$i];

    847. 

  847. 

    848. 

  848.       $this->output_driver->next_page($current_page_offset);

    849. 

  849. 

    850. 

  850.       // Preparen list of postponed (floating and relative-positioned) boxes for the current page

    851. 

  851.       $postponed_filter->process($box, null, $this);

    852. 

  852. 

    853. 

  853.       $this->reset_counter('footnote', 0);

    854. 

  854.       $this->increment_counter('page', 1);

    855. 

  855. 

    856. 

  856.       $this->output_driver->save();

    857. 

  857. 

    858. 

  858.       /**

    859. 

  859.        * Note that margin boxes should be rendered before 'setup_clip', as it will trim all

    860. 

  860.        * content rendered outside the 'main' page area

    861. 

  861.        */

    862. 

  862.       $this->render_margin_boxes($i+1, $media);

    863. 

  863.       $this->render_page_box($i+1, $media);

    864. 

  864. 

    865. 

  865.       $this->output_driver->setPageHeight($current_page_height);

    866. 

  866.       $this->output_driver->setup_clip();

    867. 

  867. 

    868. 

  868.       $this->_dispatcher->fire('before-page', array('pipeline' => &$this, 

    869. 

  869.                                                     'document' => &$box, 

    870. 

  870.                                                     'pageno' => $i));

    871. 

  871. 

    872. 

  872.       if (is_null($box->show($this->output_driver))) { 

    873. 

  873.         error_log('Pipeline::_process_item: output routine failed');

    874. 

  874.         return null; 

    875. 

  875.       };

    876. 

  876. 

    877. 

  877.       /**

    878. 

  878.        * Show postponed boxes - relative and floating boxes, as they should be 

    879. 

  879.        * shown over boxes on the same layer

    880. 

  880.        */

    881. 

  881.       $this->output_driver->show_postponed();

    882. 

  882. 

    883. 

  883.       $this->renderAbsolutePositioned($context);

    884. 

  884.       $this->output_driver->restore();

    885. 

  885.       $this->renderFixedPositioned($context);

    886. 

  886.       $this->renderFootnotes();

    887. 

  887. 

    888. 

  888.       global $g_config;

    889. 

  889.       if ($g_config['draw_page_border']) { 

    890. 

  890.         $this->output_driver->draw_page_border(); 

    891. 

  891.       };

    892. 

  892. 

    893. 

  893.       $this->_dispatcher->fire('after-page', array('pipeline' => &$this, 

    894. 

  894.                                                    'document' => &$box, 

    895. 

  895.                                                    'pageno' => $i));

    896. 

  896.     };

    897. 

  897. 

    898. 

  898.     $this->_dispatcher->fire('after-document', array('pipeline' => &$this, 

    899. 

  899.                                                      'document' => &$box));

    900. 

  900.   }

    901. 

  901. 

    902. 

  902.   function _output() {

    903. 

  903.     $temporary_output_filename = $this->output_driver->get_filename();

    904. 

  904. 

    905. 

  905.     for ($i=0; $i<count($this->output_filters); $i++) {

    906. 

  906.       $temporary_output_filename = $this->output_filters[$i]->process($temporary_output_filename);

    907. 

  907.     };

    908. 

  908. 

    909. 

  909.     // Determine the content type of the result

    910. 

  910.     $content_type = null;

    911. 

  911.     $i = count($this->output_filters)-1;

    912. 

  912.     while (($i >= 0) && (is_null($content_type))) {

    913. 

  913.       $content_type = $this->output_filters[$i]->content_type();

    914. 

  914.       $i--;

    915. 

  915.     };

    916. 

  916. 

    917. 

  917.     if (is_null($content_type)) {

    918. 

  918.       $content_type = $this->output_driver->content_type();

    919. 

  919.     };

    920. 

  920. 

    921. 

  921.     $this->destination->process($temporary_output_filename, $content_type);

    922. 

  922.     unlink($temporary_output_filename);

    923. 

  923.   }

    924. 

  924. 

    925. 

  925.   function scan_styles(&$root) {

    926. 

  926.     $css_processor =& new CSSProcessor(); 

    927. 

  927.     $css_processor->set_pipeline($this);

    928. 

  928. 

    929. 

  929.     $this->push_css();

    930. 

  930.     $ruleset =& $this->get_current_css();

    931. 

  931.     $css_processor->scan_node($root, $ruleset);

    932. 

  932.   }

    933. 

  933. 

    934. 

  934.   function set_destination(&$destination) {

    935. 

  935.     $this->destination =& $destination;

    936. 

  936.   }

    937. 

  937. 

    938. 

  938.   function set_output_driver(&$output_driver) {

    939. 

  939.     $this->output_driver =& $output_driver;

    940. 

  940.   }

    941. 

  941. 

    942. 

  942.   function &fetch($data_id) {

    943. 

  943.     if (count($this->fetchers) == 0) { 

    944. 

  944.       ob_start();

    945. 

  945.       include(HTML2PS_DIR.'/templates/error._no_fetchers.tpl');

    946. 

  946.       $this->error_message = ob_get_contents();

    947. 

  947.       ob_end_clean();

    948. 

  948. 

    949. 

  949.       $null = null;

    950. 

  950.       return $null; 

    951. 

  951.     };

    952. 

  952. 

    953. 

  953.     // Fetch data

    954. 

  954.     for ($i=0; $i<count($this->fetchers); $i++) {

    955. 

  955.       $data = $this->fetchers[$i]->get_data($data_id);

    956. 

  956. 

    957. 

  957.       if ($data != null) {

    958. 

  958.         $this->push_base_url($this->fetchers[$i]->get_base_url());

    959. 

  959.         return $data;

    960. 

  960.       };

    961. 

  961.     };

    962. 

  962. 

    963. 

  963.     if (defined('DEBUG_MODE')) {

    964. 

  964.       error_log(sprintf('Could not fetch %s', $data_id));

    965. 

  965.     };

    966. 

  966. 

    967. 

  967.     $null = null;

    968. 

  968.     return $null;

    969. 

  969.   }

    970. 

  970.   

    971. 

  971.   function process($data_id, &$media) {

    972. 

  972.     return $this->process_batch(array($data_id), $media);

    973. 

  973.   }

    974. 

  974. 

    975. 

  975.   function _setupScales(&$media) {

    976. 

  976.     global $g_config;

    977. 

  977.     global $g_px_scale;

    978. 

  978.     global $g_pt_scale;

    979. 

  979. 

    980. 

  980.     $g_px_scale = floor(mm2pt($media->width() - $media->margins['left'] - $media->margins['right'])) / $media->pixels;

    981. 

  981. 

    982. 

  982.     if ($g_config['scalepoints']) {

    983. 

  983.       $g_pt_scale = $g_px_scale * 1.33; // This is a magic number, just don't touch it, or everything will explode!

    984. 

  984.     } else {

    985. 

  985.       $g_pt_scale = 1.0;

    986. 

  986.     };

    987. 

  987.   }

    988. 

  988. 

    989. 

  989.   /**

    990. 

  990.    * Processes an set of URLs ot once; every URL is rendered on the separate page and 

    991. 

  991.    * merged to one PDF file.

    992. 

  992.    *

    993. 

  993.    * Note: to reduce peak memory requirement, URLs are processed one-after-one.

    994. 

  994.    *

    995. 

  995.    * @param Array $data_id_array Array of page identifiers to be processed (usually URLs or files paths)

    996. 

  996.    * @param Media $media Object describing the media to render for (size, margins, orientaiton & resolution)

    997. 

  997.    */

    998. 

  998.   function process_batch($data_id_array, &$media) {

    999. 

  999.     $this->clear_box_id_map();

    1000. 

  1000. 

    1001. 

  1001.     // Save and disable magic_quotes_runtime

    1002. 

  1002.     $mq_runtime = get_magic_quotes_runtime();

    1003. 

  1003.     set_magic_quotes_runtime(0);

    1004. 

  1004. 

    1005. 

  1005.     $this->_prepare($media);

    1006. 

  1006. 

    1007. 

  1007.     $this->_dispatcher->fire('before-batch', array('pipeline' => &$this));

    1008. 

  1008. 

    1009. 

  1009.     $i = 0;

    1010. 

  1010.     $offset = 0;

    1011. 

  1011.     foreach ($data_id_array as $data_id) {      

    1012. 

  1012.       $this->_process_item($data_id, $media, $offset);

    1013. 

  1013. 

    1014. 

  1014.       $i++;

    1015. 

  1015.       $offset = $this->output_driver->offset;

    1016. 

  1016.     };

    1017. 

  1017. 

    1018. 

  1018.     $this->close();

    1019. 

  1019. 

    1020. 

  1020.     // Restore magic_quotes_runtime setting

    1021. 

  1021.     set_magic_quotes_runtime($mq_runtime);

    1022. 

  1022. 

    1023. 

  1023.     return true;

    1024. 

  1024.   }

    1025. 

  1025. 

    1026. 

  1026.   function error_message() {

    1027. 

  1027.     $message = file_get_contents(HTML2PS_DIR.'/templates/error._header.tpl');

    1028. 

  1028. 

    1029. 

  1029.     $message .= $this->error_message;

    1030. 

  1030. 

    1031. 

  1031.     for ($i=0; $i<count($this->fetchers); $i++) {

    1032. 

  1032.       $message .= $this->fetchers[$i]->error_message();

    1033. 

  1033.     };

    1034. 

  1034. 

    1035. 

  1035.     $message .= $this->output_driver->error_message();

    1036. 

  1036.     

    1037. 

  1037.     $message .= file_get_contents(HTML2PS_DIR.'/templates/error._footer.tpl');

    1038. 

  1038.     return $message;

    1039. 

  1039.   }

    1040. 

  1040. 

    1041. 

  1041.   function push_base_url($url) {

    1042. 

  1042.     array_unshift($this->_base_url, $url);

    1043. 

  1043.   }

    1044. 

  1044. 

    1045. 

  1045.   function pop_base_url() {

    1046. 

  1046.     array_shift($this->_base_url);

    1047. 

  1047.   }

    1048. 

  1048. 

    1049. 

  1049.   function get_base_url() {

    1050. 

  1050.     return $this->_base_url[0];

    1051. 

  1051.   }

    1052. 

  1052. 

    1053. 

  1053.   function &get_output_driver() {

    1054. 

  1054.     return $this->output_driver;

    1055. 

  1055.   }  

    1056. 

  1056. 

    1057. 

  1057.   function guess_url($src) {

    1058. 

  1058.     return guess_url($src, $this->get_base_url());

    1059. 

  1059.   }

    1060. 

  1060. 

    1061. 

  1061.   function renderFootnotes() {

    1062. 

  1062.     /**

    1063. 

  1063.      * Render every footnote defined (note-call element is visible) on a current page

    1064. 

  1064.      */

    1065. 

  1065. 

    1066. 

  1066.     $footnote_y = $this->output_driver->getFootnoteTop() - FOOTNOTE_LINE_TOP_GAP - FOOTNOTE_LINE_BOTTOM_GAP;

    1067. 

  1067.     $footnote_x = $this->output_driver->getPageLeft();

    1068. 

  1068.     $footnotes_found = false;

    1069. 

  1069. 

    1070. 

  1070.     foreach ($this->_footnotes as $footnote) {

    1071. 

  1071.       // Note that footnote area for current page have been already defined,

    1072. 

  1072.       // as show_foonote is called after note-call boxes were placed.

    1073. 

  1073.       if ($this->output_driver->contains($footnote->_note_call_box)) { 

    1074. 

  1074.         $footnotes_found = true;

    1075. 

  1075.         $footnote_y = $footnote->show_footnote($this->output_driver, 

    1076. 

  1076.                                                $footnote_x,

    1077. 

  1077.                                                $footnote_y);

    1078. 

  1078.         $footnote_y -= FOOTNOTE_GAP;

    1079. 

  1079.       };

    1080. 

  1080.     };

    1081. 

  1081. 

    1082. 

  1082.     /**

    1083. 

  1083.      * Draw thin line separating footnotes from page content

    1084. 

  1084.      */

    1085. 

  1085.     if ($footnotes_found) {

    1086. 

  1086.       $this->output_driver->setrgbcolor(0,0,0);

    1087. 

  1087.       $this->output_driver->moveto($this->output_driver->getPageLeft(),

    1088. 

  1088.                                    $this->output_driver->getFootnoteTop() - FOOTNOTE_LINE_TOP_GAP);

    1089. 

  1089.       $this->output_driver->lineto($this->output_driver->getPageLeft() + $this->output_driver->getPageWidth()*FOOTNOTE_LINE_PERCENT/100,

    1090. 

  1090.                                    $this->output_driver->getFootnoteTop() - FOOTNOTE_LINE_TOP_GAP);

    1091. 

  1091.       $this->output_driver->stroke();

    1092. 

  1092.     };

    1093. 

  1093.   }

    1094. 

  1094. 

    1095. 

  1095.   function renderAbsolutePositioned(&$context) {

    1096. 

  1096.     for ($j=0, $size = count($context->absolute_positioned); $j<$size; $j++) {

    1097. 

  1097.       $current_box =& $context->absolute_positioned[$j];

    1098. 

  1098.       if ($current_box->get_css_property(CSS_VISIBILITY) === VISIBILITY_VISIBLE) {

    1099. 

  1099.         $this->output_driver->save();

    1100. 

  1100.         $current_box->_setupClip($this->output_driver);

    1101. 

  1101.         if (is_null($current_box->show($this->output_driver))) {

    1102. 

  1102.           return null;

    1103. 

  1103.         };

    1104. 

  1104.         $this->output_driver->restore();

    1105. 

  1105.       };

    1106. 

  1106.     };

    1107. 

  1107.     $this->output_driver->show_postponed_in_absolute();

    1108. 

  1108.   }

    1109. 

  1109. 

    1110. 

  1110.   function renderFixedPositioned(&$context) {

    1111. 

  1111.     for ($j=0, $size = count($context->fixed_positioned); $j<$size; $j++) {

    1112. 

  1112.       $current_box =& $context->fixed_positioned[$j];

    1113. 

  1113.       if ($current_box->get_css_property(CSS_VISIBILITY) === VISIBILITY_VISIBLE) {

    1114. 

  1114.         $this->output_driver->save();

    1115. 

  1115.         $current_box->_setupClip($this->output_driver);

    1116. 

  1116.         if (is_null($current_box->show_fixed($this->output_driver))) { 

    1117. 

  1117.           return null;

    1118. 

  1118.         };

    1119. 

  1119.         $this->output_driver->restore();

    1120. 

  1120.       };

    1121. 

  1121.     };

    1122. 

  1122.     $this->output_driver->show_postponed_in_fixed();

    1123. 

  1123.   }

    1124. 

  1124. 

    1125. 

  1125.   function _prepare(&$media) {

    1126. 

  1126.     $this->_setupScales($media);

    1127. 

  1127.     $GLOBALS['g_media'] =& $media;

    1128. 

  1128.     $this->output_driver->reset($media);

    1129. 

  1129.   }

    1130. 

  1130. 

    1131. 

  1131.   function &_layout_item($data_id, &$media, $offset, &$context, &$postponed_filter) {

    1132. 

  1132.     $this->_reset_page_at_rules();

    1133. 

  1133. 

    1134. 

  1134.     $css_cache = CSSCache::get();

    1135. 

  1135.     $this->_defaultCSS = $css_cache->compile('resource://default.css', 

    1136. 

  1136.                                              file_get_contents(HTML2PS_DIR.'/default.css'),

    1137. 

  1137.                                              $this);

    1138. 

  1138.     $this->_css = array();

    1139. 

  1139.     $this->push_css();

    1140. 

  1140. 

    1141. 

  1141.     $this->_cssState = array(new CSSState(CSS::get()));

    1142. 

  1142. 

    1143. 

  1143.     $font = $this->_cssState[0]->get_property(CSS_FONT);

    1144. 

  1144.     $font->units2pt(0);

    1145. 

  1145.     $this->_cssState[0]->set_property(CSS_FONT, $font);

    1146. 

  1146. 

    1147. 

  1147.     $data = $this->fetch($data_id);

    1148. 

  1148. 

    1149. 

  1149.     if (is_null($data)) { 

    1150. 

  1150.       $dummy = null;

    1151. 

  1151.       return $dummy;

    1152. 

  1152.     };

    1153. 

  1153. 

    1154. 

  1154.     // Run raw data filters

    1155. 

  1155.     for ($i=0; $i<count($this->data_filters); $i++) {

    1156. 

  1156.       $data = $this->data_filters[$i]->process($data);

    1157. 

  1157.     };

    1158. 

  1158. 

    1159. 

  1159.     // Parse the raw data

    1160. 

  1160.     $box =& $this->parser->process($data->get_content(), $this, $media);

    1161. 

  1161. 

    1162. 

  1162.     $this->_dispatcher->fire('after-parse', array('pipeline' => &$this,

    1163. 

  1163.                                                   'document' => &$box,

    1164. 

  1164.                                                   'media' => $media));

    1165. 

  1165. 

    1166. 

  1166.     /**

    1167. 

  1167.      * Run obligatory tree filters

    1168. 

  1168.      */

    1169. 

  1169. 

    1170. 

  1170.     /**

    1171. 

  1171.      * height-constraint processing filter;

    1172. 

  1172.      */

    1173. 

  1173.     $filter = new PreTreeFilterHeightConstraint();

    1174. 

  1174.     $filter->process($box, $data, $this);

    1175. 

  1175. 

    1176. 

  1176.     /**

    1177. 

  1177.      * Footnote support filter

    1178. 

  1178.      */

    1179. 

  1179.     $filter = new PreTreeFilterFootnotes();

    1180. 

  1180.     $filter->process($box, $data, $this);

    1181. 

  1181. 

    1182. 

  1182.     // Run pre-layout tree filters

    1183. 

  1183.     for ($i=0, $size = count($this->pre_tree_filters); $i < $size; $i++) {

    1184. 

  1184.       $this->pre_tree_filters[$i]->process($box, $data, $this);

    1185. 

  1185.     };

    1186. 

  1186. 

    1187. 

  1187.     $context = new FlowContext;

    1188. 

  1188. 

    1189. 

  1189.     /**

    1190. 

  1190.      * Extract absolute/fixed positioned boxes

    1191. 

  1191.      */

    1192. 

  1192.     $positioned_filter = new PostTreeFilterPositioned($context);

    1193. 

  1193.     $positioned_filter->process($box, null, $this);

    1194. 

  1194. 

    1195. 

  1195.     $postponed_filter = new PostTreeFilterPostponed($this->output_driver);

    1196. 

  1196.     $postponed_filter->process($box, null, $this);

    1197. 

  1197. 

    1198. 

  1198.     $this->output_driver->prepare();

    1199. 

  1199. 

    1200. 

  1200.     $status = $this->layout_engine->process($box, $media, $this->output_driver, $context);

    1201. 

  1201.     if (is_null($status)) { 

    1202. 

  1202.       error_log('Pipeline::_process_item: layout routine failed');

    1203. 

  1203.       $dummy = null;

    1204. 

  1204.       return $dummy;

    1205. 

  1205.     };

    1206. 

  1206. 

    1207. 

  1207.     // Run post-layout tree filters

    1208. 

  1208.     for ($i=0; $i<count($this->post_tree_filters); $i++) {

    1209. 

  1209.       $this->post_tree_filters[$i]->process($box);

    1210. 

  1210.     };

    1211. 

  1211. 

    1212. 

  1212.     return $box;

    1213. 

  1213.   }

    1214. 

  1214. 

    1215. 

  1215.   function &getDispatcher() {

    1216. 

  1216.     return $this->_dispatcher;

    1217. 

  1217.   }

    1218. 

  1218. 

    1219. 

  1219.   function get_current_page_name() {

    1220. 

  1220.     return $this->_current_page_name;

    1221. 

  1221.   }

    1222. 

  1222. 

    1223. 

  1223.   function set_current_page_name($name) {

    1224. 

  1224.     $this->_current_page_name = $name;

    1225. 

  1225.   }

    1226. 

  1226. }

    1227. 

  1227. 

    1228. 

  1228. ?>
    1229.