1  <?php
  2  
  3  /**
  4   * @todo Rewrite to use Interchange objects
  5   */
  6  class HTMLPurifier_Printer_ConfigForm extends HTMLPurifier_Printer
  7  {
  8  
  9      /**
 10       * Printers for specific fields.
 11       * @type HTMLPurifier_Printer[]
 12       */
 13      protected $fields = array();
 14  
 15      /**
 16       * Documentation URL, can have fragment tagged on end.
 17       * @type string
 18       */
 19      protected $docURL;
 20  
 21      /**
 22       * Name of form element to stuff config in.
 23       * @type string
 24       */
 25      protected $name;
 26  
 27      /**
 28       * Whether or not to compress directive names, clipping them off
 29       * after a certain amount of letters. False to disable or integer letters
 30       * before clipping.
 31       * @type bool
 32       */
 33      protected $compress = false;
 34  
 35      /**
 36       * @param string $name Form element name for directives to be stuffed into
 37       * @param string $doc_url String documentation URL, will have fragment tagged on
 38       * @param bool $compress Integer max length before compressing a directive name, set to false to turn off
 39       */
 40      public function __construct(
 41          $name,
 42          $doc_url = null,
 43          $compress = false
 44      ) {
 45          parent::__construct();
 46          $this->docURL = $doc_url;
 47          $this->name = $name;
 48          $this->compress = $compress;
 49          // initialize sub-printers
 50          $this->fields[0] = new HTMLPurifier_Printer_ConfigForm_default();
 51          $this->fields[HTMLPurifier_VarParser::BOOL] = new HTMLPurifier_Printer_ConfigForm_bool();
 52      }
 53  
 54      /**
 55       * Sets default column and row size for textareas in sub-printers
 56       * @param $cols Integer columns of textarea, null to use default
 57       * @param $rows Integer rows of textarea, null to use default
 58       */
 59      public function setTextareaDimensions($cols = null, $rows = null)
 60      {
 61          if ($cols) {
 62              $this->fields['default']->cols = $cols;
 63          }
 64          if ($rows) {
 65              $this->fields['default']->rows = $rows;
 66          }
 67      }
 68  
 69      /**
 70       * Retrieves styling, in case it is not accessible by webserver
 71       */
 72      public static function getCSS()
 73      {
 74          return file_get_contents(HTMLPURIFIER_PREFIX . '/HTMLPurifier/Printer/ConfigForm.css');
 75      }
 76  
 77      /**
 78       * Retrieves JavaScript, in case it is not accessible by webserver
 79       */
 80      public static function getJavaScript()
 81      {
 82          return file_get_contents(HTMLPURIFIER_PREFIX . '/HTMLPurifier/Printer/ConfigForm.js');
 83      }
 84  
 85      /**
 86       * Returns HTML output for a configuration form
 87       * @param HTMLPurifier_Config|array $config Configuration object of current form state, or an array
 88       *        where [0] has an HTML namespace and [1] is being rendered.
 89       * @param array|bool $allowed Optional namespace(s) and directives to restrict form to.
 90       * @param bool $render_controls
 91       * @return string
 92       */
 93      public function render($config, $allowed = true, $render_controls = true)
 94      {
 95          if (is_array($config) && isset($config[0])) {
 96              $gen_config = $config[0];
 97              $config = $config[1];
 98          } else {
 99              $gen_config = $config;
100          }
101  
102          $this->config = $config;
103          $this->genConfig = $gen_config;
104          $this->prepareGenerator($gen_config);
105  
106          $allowed = HTMLPurifier_Config::getAllowedDirectivesForForm($allowed, $config->def);
107          $all = array();
108          foreach ($allowed as $key) {
109              list($ns, $directive) = $key;
110              $all[$ns][$directive] = $config->get($ns . '.' . $directive);
111          }
112  
113          $ret = '';
114          $ret .= $this->start('table', array('class' => 'hp-config'));
115          $ret .= $this->start('thead');
116          $ret .= $this->start('tr');
117          $ret .= $this->element('th', 'Directive', array('class' => 'hp-directive'));
118          $ret .= $this->element('th', 'Value', array('class' => 'hp-value'));
119          $ret .= $this->end('tr');
120          $ret .= $this->end('thead');
121          foreach ($all as $ns => $directives) {
122              $ret .= $this->renderNamespace($ns, $directives);
123          }
124          if ($render_controls) {
125              $ret .= $this->start('tbody');
126              $ret .= $this->start('tr');
127              $ret .= $this->start('td', array('colspan' => 2, 'class' => 'controls'));
128              $ret .= $this->elementEmpty('input', array('type' => 'submit', 'value' => 'Submit'));
129              $ret .= '[<a href="?">Reset</a>]';
130              $ret .= $this->end('td');
131              $ret .= $this->end('tr');
132              $ret .= $this->end('tbody');
133          }
134          $ret .= $this->end('table');
135          return $ret;
136      }
137  
138      /**
139       * Renders a single namespace
140       * @param $ns String namespace name
141       * @param array $directives array of directives to values
142       * @return string
143       */
144      protected function renderNamespace($ns, $directives)
145      {
146          $ret = '';
147          $ret .= $this->start('tbody', array('class' => 'namespace'));
148          $ret .= $this->start('tr');
149          $ret .= $this->element('th', $ns, array('colspan' => 2));
150          $ret .= $this->end('tr');
151          $ret .= $this->end('tbody');
152          $ret .= $this->start('tbody');
153          foreach ($directives as $directive => $value) {
154              $ret .= $this->start('tr');
155              $ret .= $this->start('th');
156              if ($this->docURL) {
157                  $url = str_replace('%s', urlencode("$ns.$directive"), $this->docURL);
158                  $ret .= $this->start('a', array('href' => $url));
159              }
160              $attr = array('for' => "{$this->name}:$ns.$directive");
161  
162              // crop directive name if it's too long
163              if (!$this->compress || (strlen($directive) < $this->compress)) {
164                  $directive_disp = $directive;
165              } else {
166                  $directive_disp = substr($directive, 0, $this->compress - 2) . '...';
167                  $attr['title'] = $directive;
168              }
169  
170              $ret .= $this->element(
171                  'label',
172                  $directive_disp,
173                  // component printers must create an element with this id
174                  $attr
175              );
176              if ($this->docURL) {
177                  $ret .= $this->end('a');
178              }
179              $ret .= $this->end('th');
180  
181              $ret .= $this->start('td');
182              $def = $this->config->def->info["$ns.$directive"];
183              if (is_int($def)) {
184                  $allow_null = $def < 0;
185                  $type = abs($def);
186              } else {
187                  $type = $def->type;
188                  $allow_null = isset($def->allow_null);
189              }
190              if (!isset($this->fields[$type])) {
191                  $type = 0;
192              } // default
193              $type_obj = $this->fields[$type];
194              if ($allow_null) {
195                  $type_obj = new HTMLPurifier_Printer_ConfigForm_NullDecorator($type_obj);
196              }
197              $ret .= $type_obj->render($ns, $directive, $value, $this->name, array($this->genConfig, $this->config));
198              $ret .= $this->end('td');
199              $ret .= $this->end('tr');
200          }
201          $ret .= $this->end('tbody');
202          return $ret;
203      }
204  
205  }
206  
207  /**
208   * Printer decorator for directives that accept null
209   */
210  class HTMLPurifier_Printer_ConfigForm_NullDecorator extends HTMLPurifier_Printer
211  {
212      /**
213       * Printer being decorated
214       * @type HTMLPurifier_Printer
215       */
216      protected $obj;
217  
218      /**
219       * @param HTMLPurifier_Printer $obj Printer to decorate
220       */
221      public function __construct($obj)
222      {
223          parent::__construct();
224          $this->obj = $obj;
225      }
226  
227      /**
228       * @param string $ns
229       * @param string $directive
230       * @param string $value
231       * @param string $name
232       * @param HTMLPurifier_Config|array $config
233       * @return string
234       */
235      public function render($ns, $directive, $value, $name, $config)
236      {
237          if (is_array($config) && isset($config[0])) {
238              $gen_config = $config[0];
239              $config = $config[1];
240          } else {
241              $gen_config = $config;
242          }
243          $this->prepareGenerator($gen_config);
244  
245          $ret = '';
246          $ret .= $this->start('label', array('for' => "$name:Null_$ns.$directive"));
247          $ret .= $this->element('span', "$ns.$directive:", array('class' => 'verbose'));
248          $ret .= $this->text(' Null/Disabled');
249          $ret .= $this->end('label');
250          $attr = array(
251              'type' => 'checkbox',
252              'value' => '1',
253              'class' => 'null-toggle',
254              'name' => "$name" . "[Null_$ns.$directive]",
255              'id' => "$name:Null_$ns.$directive",
256              'onclick' => "toggleWriteability('$name:$ns.$directive',checked)" // INLINE JAVASCRIPT!!!!
257          );
258          if ($this->obj instanceof HTMLPurifier_Printer_ConfigForm_bool) {
259              // modify inline javascript slightly
260              $attr['onclick'] =
261                  "toggleWriteability('$name:Yes_$ns.$directive',checked);" .
262                  "toggleWriteability('$name:No_$ns.$directive',checked)";
263          }
264          if ($value === null) {
265              $attr['checked'] = 'checked';
266          }
267          $ret .= $this->elementEmpty('input', $attr);
268          $ret .= $this->text(' or ');
269          $ret .= $this->elementEmpty('br');
270          $ret .= $this->obj->render($ns, $directive, $value, $name, array($gen_config, $config));
271          return $ret;
272      }
273  }
274  
275  /**
276   * Swiss-army knife configuration form field printer
277   */
278  class HTMLPurifier_Printer_ConfigForm_default extends HTMLPurifier_Printer
279  {
280      /**
281       * @type int
282       */
283      public $cols = 18;
284  
285      /**
286       * @type int
287       */
288      public $rows = 5;
289  
290      /**
291       * @param string $ns
292       * @param string $directive
293       * @param string $value
294       * @param string $name
295       * @param HTMLPurifier_Config|array $config
296       * @return string
297       */
298      public function render($ns, $directive, $value, $name, $config)
299      {
300          if (is_array($config) && isset($config[0])) {
301              $gen_config = $config[0];
302              $config = $config[1];
303          } else {
304              $gen_config = $config;
305          }
306          $this->prepareGenerator($gen_config);
307          // this should probably be split up a little
308          $ret = '';
309          $def = $config->def->info["$ns.$directive"];
310          if (is_int($def)) {
311              $type = abs($def);
312          } else {
313              $type = $def->type;
314          }
315          if (is_array($value)) {
316              switch ($type) {
317                  case HTMLPurifier_VarParser::LOOKUP:
318                      $array = $value;
319                      $value = array();
320                      foreach ($array as $val => $b) {
321                          $value[] = $val;
322                      }
323                      //TODO does this need a break?
324                  case HTMLPurifier_VarParser::ALIST:
325                      $value = implode(PHP_EOL, $value);
326                      break;
327                  case HTMLPurifier_VarParser::HASH:
328                      $nvalue = '';
329                      foreach ($value as $i => $v) {
330                          $nvalue .= "$i:$v" . PHP_EOL;
331                      }
332                      $value = $nvalue;
333                      break;
334                  default:
335                      $value = '';
336              }
337          }
338          if ($type === HTMLPurifier_VarParser::MIXED) {
339              return 'Not supported';
340              $value = serialize($value);
341          }
342          $attr = array(
343              'name' => "$name" . "[$ns.$directive]",
344              'id' => "$name:$ns.$directive"
345          );
346          if ($value === null) {
347              $attr['disabled'] = 'disabled';
348          }
349          if (isset($def->allowed)) {
350              $ret .= $this->start('select', $attr);
351              foreach ($def->allowed as $val => $b) {
352                  $attr = array();
353                  if ($value == $val) {
354                      $attr['selected'] = 'selected';
355                  }
356                  $ret .= $this->element('option', $val, $attr);
357              }
358              $ret .= $this->end('select');
359          } elseif ($type === HTMLPurifier_VarParser::TEXT ||
360                  $type === HTMLPurifier_VarParser::ITEXT ||
361                  $type === HTMLPurifier_VarParser::ALIST ||
362                  $type === HTMLPurifier_VarParser::HASH ||
363                  $type === HTMLPurifier_VarParser::LOOKUP) {
364              $attr['cols'] = $this->cols;
365              $attr['rows'] = $this->rows;
366              $ret .= $this->start('textarea', $attr);
367              $ret .= $this->text($value);
368              $ret .= $this->end('textarea');
369          } else {
370              $attr['value'] = $value;
371              $attr['type'] = 'text';
372              $ret .= $this->elementEmpty('input', $attr);
373          }
374          return $ret;
375      }
376  }
377  
378  /**
379   * Bool form field printer
380   */
381  class HTMLPurifier_Printer_ConfigForm_bool extends HTMLPurifier_Printer
382  {
383      /**
384       * @param string $ns
385       * @param string $directive
386       * @param string $value
387       * @param string $name
388       * @param HTMLPurifier_Config|array $config
389       * @return string
390       */
391      public function render($ns, $directive, $value, $name, $config)
392      {
393          if (is_array($config) && isset($config[0])) {
394              $gen_config = $config[0];
395              $config = $config[1];
396          } else {
397              $gen_config = $config;
398          }
399          $this->prepareGenerator($gen_config);
400          $ret = '';
401          $ret .= $this->start('div', array('id' => "$name:$ns.$directive"));
402  
403          $ret .= $this->start('label', array('for' => "$name:Yes_$ns.$directive"));
404          $ret .= $this->element('span', "$ns.$directive:", array('class' => 'verbose'));
405          $ret .= $this->text(' Yes');
406          $ret .= $this->end('label');
407  
408          $attr = array(
409              'type' => 'radio',
410              'name' => "$name" . "[$ns.$directive]",
411              'id' => "$name:Yes_$ns.$directive",
412              'value' => '1'
413          );
414          if ($value === true) {
415              $attr['checked'] = 'checked';
416          }
417          if ($value === null) {
418              $attr['disabled'] = 'disabled';
419          }
420          $ret .= $this->elementEmpty('input', $attr);
421  
422          $ret .= $this->start('label', array('for' => "$name:No_$ns.$directive"));
423          $ret .= $this->element('span', "$ns.$directive:", array('class' => 'verbose'));
424          $ret .= $this->text(' No');
425          $ret .= $this->end('label');
426  
427          $attr = array(
428              'type' => 'radio',
429              'name' => "$name" . "[$ns.$directive]",
430              'id' => "$name:No_$ns.$directive",
431              'value' => '0'
432          );
433          if ($value === false) {
434              $attr['checked'] = 'checked';
435          }
436          if ($value === null) {
437              $attr['disabled'] = 'disabled';
438          }
439          $ret .= $this->elementEmpty('input', $attr);
440  
441          $ret .= $this->end('div');
442  
443          return $ret;
444      }
445  }
446  
447  // vim: et sw=4 sts=4