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::C_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
|
|
|
if (is_array($v)) { |
331
|
|
|
// HACK |
332
|
|
|
$v = implode(";", $v); |
333
|
|
|
} |
334
|
|
|
$nvalue .= "$i:$v" . PHP_EOL; |
335
|
|
|
} |
336
|
|
|
$value = $nvalue; |
337
|
|
|
break; |
338
|
|
|
default: |
339
|
|
|
$value = ''; |
340
|
|
|
} |
341
|
|
|
} |
342
|
|
|
if ($type === HTMLPurifier_VarParser::C_MIXED) { |
343
|
|
|
return 'Not supported'; |
344
|
|
|
$value = serialize($value); |
|
|
|
|
345
|
|
|
} |
346
|
|
|
$attr = array( |
347
|
|
|
'name' => "$name" . "[$ns.$directive]", |
348
|
|
|
'id' => "$name:$ns.$directive" |
349
|
|
|
); |
350
|
|
|
if ($value === null) { |
|
|
|
|
351
|
|
|
$attr['disabled'] = 'disabled'; |
352
|
|
|
} |
353
|
|
|
if (isset($def->allowed)) { |
354
|
|
|
$ret .= $this->start('select', $attr); |
355
|
|
|
foreach ($def->allowed as $val => $b) { |
356
|
|
|
$attr = array(); |
357
|
|
|
if ($value == $val) { |
358
|
|
|
$attr['selected'] = 'selected'; |
359
|
|
|
} |
360
|
|
|
$ret .= $this->element('option', $val, $attr); |
361
|
|
|
} |
362
|
|
|
$ret .= $this->end('select'); |
363
|
|
|
} elseif ($type === HTMLPurifier_VarParser::TEXT || |
364
|
|
|
$type === HTMLPurifier_VarParser::ITEXT || |
365
|
|
|
$type === HTMLPurifier_VarParser::ALIST || |
366
|
|
|
$type === HTMLPurifier_VarParser::HASH || |
367
|
|
|
$type === HTMLPurifier_VarParser::LOOKUP) { |
368
|
|
|
$attr['cols'] = $this->cols; |
369
|
|
|
$attr['rows'] = $this->rows; |
370
|
|
|
$ret .= $this->start('textarea', $attr); |
371
|
|
|
$ret .= $this->text($value); |
372
|
|
|
$ret .= $this->end('textarea'); |
373
|
|
|
} else { |
374
|
|
|
$attr['value'] = $value; |
375
|
|
|
$attr['type'] = 'text'; |
376
|
|
|
$ret .= $this->elementEmpty('input', $attr); |
377
|
|
|
} |
378
|
|
|
return $ret; |
379
|
|
|
} |
380
|
|
|
} |
381
|
|
|
|
382
|
|
|
/** |
383
|
|
|
* Bool form field printer |
384
|
|
|
*/ |
385
|
|
|
class HTMLPurifier_Printer_ConfigForm_bool extends HTMLPurifier_Printer |
386
|
|
|
{ |
387
|
|
|
/** |
388
|
|
|
* @param string $ns |
389
|
|
|
* @param string $directive |
390
|
|
|
* @param string $value |
391
|
|
|
* @param string $name |
392
|
|
|
* @param HTMLPurifier_Config|array $config |
393
|
|
|
* @return string |
394
|
|
|
*/ |
395
|
|
|
public function render($ns, $directive, $value, $name, $config) |
396
|
|
|
{ |
397
|
|
|
if (is_array($config) && isset($config[0])) { |
398
|
|
|
$gen_config = $config[0]; |
399
|
|
|
$config = $config[1]; |
|
|
|
|
400
|
|
|
} else { |
401
|
|
|
$gen_config = $config; |
402
|
|
|
} |
403
|
|
|
$this->prepareGenerator($gen_config); |
404
|
|
|
$ret = ''; |
405
|
|
|
$ret .= $this->start('div', array('id' => "$name:$ns.$directive")); |
406
|
|
|
|
407
|
|
|
$ret .= $this->start('label', array('for' => "$name:Yes_$ns.$directive")); |
408
|
|
|
$ret .= $this->element('span', "$ns.$directive:", array('class' => 'verbose')); |
409
|
|
|
$ret .= $this->text(' Yes'); |
410
|
|
|
$ret .= $this->end('label'); |
411
|
|
|
|
412
|
|
|
$attr = array( |
413
|
|
|
'type' => 'radio', |
414
|
|
|
'name' => "$name" . "[$ns.$directive]", |
415
|
|
|
'id' => "$name:Yes_$ns.$directive", |
416
|
|
|
'value' => '1' |
417
|
|
|
); |
418
|
|
|
if ($value === true) { |
|
|
|
|
419
|
|
|
$attr['checked'] = 'checked'; |
420
|
|
|
} |
421
|
|
|
if ($value === null) { |
|
|
|
|
422
|
|
|
$attr['disabled'] = 'disabled'; |
423
|
|
|
} |
424
|
|
|
$ret .= $this->elementEmpty('input', $attr); |
425
|
|
|
|
426
|
|
|
$ret .= $this->start('label', array('for' => "$name:No_$ns.$directive")); |
427
|
|
|
$ret .= $this->element('span', "$ns.$directive:", array('class' => 'verbose')); |
428
|
|
|
$ret .= $this->text(' No'); |
429
|
|
|
$ret .= $this->end('label'); |
430
|
|
|
|
431
|
|
|
$attr = array( |
432
|
|
|
'type' => 'radio', |
433
|
|
|
'name' => "$name" . "[$ns.$directive]", |
434
|
|
|
'id' => "$name:No_$ns.$directive", |
435
|
|
|
'value' => '0' |
436
|
|
|
); |
437
|
|
|
if ($value === false) { |
|
|
|
|
438
|
|
|
$attr['checked'] = 'checked'; |
439
|
|
|
} |
440
|
|
|
if ($value === null) { |
|
|
|
|
441
|
|
|
$attr['disabled'] = 'disabled'; |
442
|
|
|
} |
443
|
|
|
$ret .= $this->elementEmpty('input', $attr); |
444
|
|
|
|
445
|
|
|
$ret .= $this->end('div'); |
446
|
|
|
|
447
|
|
|
return $ret; |
448
|
|
|
} |
449
|
|
|
} |
450
|
|
|
|
451
|
|
|
// vim: et sw=4 sts=4 |
452
|
|
|
|