[Summary view] [Print] [Text view]

   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