]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - lib/htmloutputter.php
notice_favorite class
[quix0rs-gnu-social.git] / lib / htmloutputter.php
1 <?php
2 /**
3  * Laconica, the distributed open-source microblogging tool
4  *
5  * Low-level generator for HTML
6  *
7  * PHP version 5
8  *
9  * LICENCE: This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU Affero General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU Affero General Public License for more details.
18  *
19  * You should have received a copy of the GNU Affero General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  * @category  Output
23  * @package   Laconica
24  * @author    Evan Prodromou <evan@controlyourself.ca>
25  * @author    Sarven Capadisli <csarven@controlyourself.ca>
26  * @copyright 2008 Control Yourself, Inc.
27  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
28  * @link      http://laconi.ca/
29  */
30
31 if (!defined('LACONICA')) {
32     exit(1);
33 }
34
35 require_once INSTALLDIR.'/lib/xmloutputter.php';
36
37 define('PAGE_TYPE_PREFS',
38        'text/html,application/xhtml+xml,'.
39        'application/xml;q=0.3,text/xml;q=0.2');
40
41 /**
42  * Low-level generator for HTML
43  *
44  * Abstracts some of the code necessary for HTML generation. Especially
45  * has methods for generating HTML form elements. Note that these have
46  * been created kind of haphazardly, not with an eye to making a general
47  * HTML-creation class.
48  *
49  * @category Output
50  * @package  Laconica
51  * @author   Evan Prodromou <evan@controlyourself.ca>
52  * @author   Sarven Capadisli <csarven@controlyourself.ca>
53  * @license  http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
54  * @link     http://laconi.ca/
55  *
56  * @see      Action
57  * @see      XMLOutputter
58  */
59
60 class HTMLOutputter extends XMLOutputter
61 {
62     /**
63      * Constructor
64      *
65      * Just wraps the XMLOutputter constructor.
66      *
67      * @param string  $output URI to output to, default = stdout
68      * @param boolean $indent Whether to indent output, default true
69      */
70
71     function __construct($output='php://output', $indent=true)
72     {
73         parent::__construct($output, $indent);
74     }
75
76     /**
77      * Start an HTML document
78      *
79      * If $type isn't specified, will attempt to do content negotiation.
80      *
81      * Attempts to do content negotiation for language, also.
82      *
83      * @param string $type MIME type to use; default is to do negotation.
84      *
85      * @todo extract content negotiation code to an HTTP module or class.
86      *
87      * @return void
88      */
89
90     function startHTML($type=null)
91     {
92         if (!$type) {
93             $httpaccept = isset($_SERVER['HTTP_ACCEPT']) ?
94               $_SERVER['HTTP_ACCEPT'] : null;
95
96             // XXX: allow content negotiation for RDF, RSS, or XRDS
97
98             $cp = common_accept_to_prefs($httpaccept);
99             $sp = common_accept_to_prefs(PAGE_TYPE_PREFS);
100
101             $type = common_negotiate_type($cp, $sp);
102
103             if (!$type) {
104                 common_user_error(_('This page is not available in a '.
105                                     'media type you accept'), 406);
106                 exit(0);
107             }
108         }
109
110         header('Content-Type: '.$type);
111
112         $this->startXML('html',
113                         '-//W3C//DTD XHTML 1.0 Strict//EN',
114                         'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd');
115
116         // FIXME: correct language for interface
117
118         $language = common_language();
119
120         $this->elementStart('html', array('xmlns' => 'http://www.w3.org/1999/xhtml',
121                                           'xml:lang' => $language,
122                                           'lang' => $language));
123     }
124
125     /**
126     *  Ends an HTML document
127     *
128     *  @return void
129     */
130     function endHTML()
131     {
132         $this->elementEnd('html');
133         $this->endXML();
134     }
135
136     /**
137      * Output an HTML text input element
138      *
139      * Despite the name, it is specifically for outputting a
140      * text input element, not other <input> elements. It outputs
141      * a cluster of elements, including a <label> and an associated
142      * instructions span.
143      *
144      * @param string $id           element ID, must be unique on page
145      * @param string $label        text of label for the element
146      * @param string $value        value of the element, default null
147      * @param string $instructions instructions for valid input
148      *
149      * @todo add a $name parameter
150      * @todo add a $maxLength parameter
151      * @todo add a $size parameter
152      *
153      * @return void
154      */
155
156     function input($id, $label, $value=null, $instructions=null)
157     {
158         $this->elementStart('p');
159         $this->element('label', array('for' => $id), $label);
160         $attrs = array('name' => $id,
161                        'type' => 'text',
162                        'class' => 'input_text',
163                        'id' => $id);
164         if ($value) {
165             $attrs['value'] = htmlspecialchars($value);
166         }
167         $this->element('input', $attrs);
168         if ($instructions) {
169             $this->element('span', 'input_instructions', $instructions);
170         }
171         $this->elementEnd('p');
172     }
173
174     /**
175      * output an HTML checkbox and associated elements
176      *
177      * Note that the value is default 'true' (the string), which can
178      * be used by Action::boolean()
179      *
180      * @param string $id           element ID, must be unique on page
181      * @param string $label        text of label for the element
182      * @param string $checked      if the box is checked, default false
183      * @param string $instructions instructions for valid input
184      * @param string $value        value of the checkbox, default 'true'
185      * @param string $disabled     show the checkbox disabled, default false
186      *
187      * @return void
188      *
189      * @todo add a $name parameter
190      */
191
192     function checkbox($id, $label, $checked=false, $instructions=null,
193                       $value='true', $disabled=false)
194     {
195         $this->elementStart('p');
196         $attrs = array('name' => $id,
197                        'type' => 'checkbox',
198                        'class' => 'checkbox',
199                        'id' => $id);
200         if ($value) {
201             $attrs['value'] = htmlspecialchars($value);
202         }
203         if ($checked) {
204             $attrs['checked'] = 'checked';
205         }
206         if ($disabled) {
207             $attrs['disabled'] = 'true';
208         }
209         $this->element('input', $attrs);
210         $this->text(' ');
211         $this->element('label', array('class' => 'checkbox_label',
212                                       'for' => $id),
213                        $label);
214         $this->text(' ');
215         if ($instructions) {
216             $this->element('span', 'input_instructions', $instructions);
217         }
218         $this->elementEnd('p');
219     }
220
221     /**
222      * output an HTML combobox/select and associated elements
223      *
224      * $content is an array of key-value pairs for the dropdown, where
225      * the key is the option value attribute and the value is the option
226      * text. (Careful on the overuse of 'value' here.)
227      *
228      * @param string $id           element ID, must be unique on page
229      * @param string $label        text of label for the element
230      * @param array  $content      options array, value => text
231      * @param string $instructions instructions for valid input
232      * @param string $blank_select whether to have a blank entry, default false
233      * @param string $selected     selected value, default null
234      *
235      * @return void
236      *
237      * @todo add a $name parameter
238      */
239
240     function dropdown($id, $label, $content, $instructions=null,
241                       $blank_select=false, $selected=null)
242     {
243         $this->elementStart('p');
244         $this->element('label', array('for' => $id), $label);
245         $this->elementStart('select', array('id' => $id, 'name' => $id));
246         if ($blank_select) {
247             $this->element('option', array('value' => ''));
248         }
249         foreach ($content as $value => $option) {
250             if ($value == $selected) {
251                 $this->element('option', array('value' => $value,
252                                                'selected' => $value),
253                                $option);
254             } else {
255                 $this->element('option', array('value' => $value), $option);
256             }
257         }
258         $this->elementEnd('select');
259         if ($instructions) {
260             $this->element('span', 'input_instructions', $instructions);
261         }
262         $this->elementEnd('p');
263     }
264
265     /**
266      * output an HTML hidden element
267      *
268      * $id is re-used as name
269      *
270      * @param string $id    element ID, must be unique on page
271      * @param string $value hidden element value, default null
272      * @param string $name  name, if different than ID
273      *
274      * @return void
275      */
276
277     function hidden($id, $value, $name=null)
278     {
279         $this->element('input', array('name' => ($name) ? $name : $id,
280                                       'type' => 'hidden',
281                                       'id' => $id,
282                                       'value' => $value));
283     }
284
285     /**
286      * output an HTML password input and associated elements
287      *
288      * @param string $id           element ID, must be unique on page
289      * @param string $label        text of label for the element
290      * @param string $instructions instructions for valid input
291      *
292      * @return void
293      *
294      * @todo add a $name parameter
295      */
296
297     function password($id, $label, $instructions=null)
298     {
299         $this->elementStart('p');
300         $this->element('label', array('for' => $id), $label);
301         $attrs = array('name' => $id,
302                        'type' => 'password',
303                        'class' => 'password',
304                        'id' => $id);
305         $this->element('input', $attrs);
306         if ($instructions) {
307             $this->element('span', 'input_instructions', $instructions);
308         }
309         $this->elementEnd('p');
310     }
311
312     /**
313      * output an HTML submit input and associated elements
314      *
315      * @param string $id    element ID, must be unique on page
316      * @param string $label text of the button
317      * @param string $cls   class of the button, default 'submit'
318      * @param string $name  name, if different than ID
319      *
320      * @return void
321      *
322      * @todo add a $name parameter
323      */
324
325     function submit($id, $label, $cls='submit', $name=null)
326     {
327         $this->element('input', array('type' => 'submit',
328                                       'id' => $id,
329                                       'name' => ($name) ? $name : $id,
330                                       'class' => $cls,
331                                       'value' => $label));
332     }
333
334     /**
335      * output an HTML textarea and associated elements
336      *
337      * @param string $id           element ID, must be unique on page
338      * @param string $label        text of label for the element
339      * @param string $content      content of the textarea, default none
340      * @param string $instructions instructions for valid input
341      *
342      * @return void
343      *
344      * @todo add a $name parameter
345      * @todo add a $cols parameter
346      * @todo add a $rows parameter
347      */
348
349     function textarea($id, $label, $content=null, $instructions=null)
350     {
351         $this->elementStart('p');
352         $this->element('label', array('for' => $id), $label);
353         $this->element('textarea', array('rows' => 3,
354                                          'cols' => 40,
355                                          'name' => $id,
356                                          'id' => $id),
357                        ($content) ? $content : '');
358         if ($instructions) {
359             $this->element('span', 'input_instructions', $instructions);
360         }
361         $this->elementEnd('p');
362     }
363 }