com.newsblob.phphtmllib/widgets/PageWidget.inc

<?php
/**
 * This file contains the PageWidget class
 *
 * $Id: PageWidget.inc,v 1.5 2003/09/30 00:20:01 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 */

/**
 * Make sure we have the required parent class
 */ 
require_once($phphtmllib."/widgets/HTMLPageClass.inc");

/**
 * We need to make sure we have the MessageBoxWidget loaded
 * for the permissions checking.
 * 
 * NOTE: The InfoTable css classes must be included in any
 *       page that uses the permissions checking.
 */
require_once($phphtmllib."/widgets/MessageBoxWidget.inc");

/**
 * This class is used to build content 
 * for an entire page.  It uses the
 * HTMLPageClass widget from phphtmllib
 * to render the final output.
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 */
class PageWidget extends HTMLPageClass {

    /** CLASS VARS **/

    /**
     * This enables the ability to view the
     * source of a page bu setting debug=1
     * in the query string.
     *
     */
    var $_enable_debug = FALSE;


    /**
     * holds the page title text for
     * a page
     *
     */
    var $_title_text = NULL;

    /**
     * Does the user have permission
     * to build and view the content?
     */
    var $_perm_options = array("allowed" => TRUE,
                               "message" => "You are not allowed to view this page.",
                               "url" => NULL);

    /**
     * the message box for displaying
     * permissions errors
     */
    var $_permission_box = NULL;

    /**
     * This is to enable/disable the
     * permissions checking.
     * By default it is off.
     */
    var $_allow_permissions_checks = FALSE;


    /**
     * The width of the permissions dialog
     * table.
     */
    var $_permissions_error_width = "50%";


    /**
     * Constructor:
     *
     * @param   mixed  - $title Title string or TITLEtag object for the page.
     * @param   string - one of 3 types of html to render.  Setting this will
     *                   make the object declare the gobal define which tells
     *                   all of the tag objects what type of html tags to render.
     *                   some tags support special features.  such as the <IMG>
     *                   tag.  If xhtml is selected, the the IMGtag object and all
     *                   utility functions will not render "border=0" as a default
     *                   attribute, since this is not proper xhtml.
     *                   "html" - HTML 4.0 (default)
     *                   "xhtml_transitional" - render xhtml instead of html
     *                                        - doctype is XHTML transitional.
     *                   "xhtml_strict" - render xhtml instead of html 4.0.
     *                                  - doctype is XHTML strict.
     * @param   int   - one of 2 types.  INDENT_NICE or INDENT_LEFT_JUSTIFY
     *                  This tells the page how to render the indenting of the
     *                  output.  By default it is set to INDENT_NICE, which nicely
     *                  indents each nested tag.  You can have all tags rendered
     *                  left justified (smaller size in output) by using 
     *                  INDENT_LEFT_JUSTIFY
     *
     */
    function PageWidget( $title, $render_type = HTML, $indent_style=INDENT_NICE ) {     

        if ( defined("DEBUG") && 
             (isset($_GET["debug"]) || 
              isset($_POST["debug"]) ) ) {
            $this->enable_debug( TRUE );
        }
        //save the title for later.
        $this->_title_text = $title;

        //call the parent's constructor
        $this->HTMLPageClass( $title, $render_type, $indent_style );
        
        //see if we are allowed to check permissions
        //You need to have the CSS definitions for the
        //InfoTable defined in order to see the error 
        //table correctly.  Or you can override the
        //_build_permission_box() method to provide
        //a different object for displaying the 
        //permission errors.
        if ($this->_allow_permissions_checks) {
            //check the permissions on this page
            $this->_check_permissions();
        }        
    }

    /**
     * gets the current title of the page.
     *
     * @return string
     */
    function get_title() {
        return $this->_title_text;
    }

    /**
     * This function is used to build 
     * addition head content that isn't 
     * built by the HTMLPageClass parent
     * class by default.
     * NOTE: you can add addition content
     *       to the head in 1 of 2 ways.
     *       1) inside the call return the
     *          addition content in the
     *          return $foo;
     *       2) or use the HTMLPageClass'
     *          $this->add_head_content()
     *          from within the head_content()
     *          call.
     *
     * @return mixed.
     */ 
    function head_content() {
        return NULL;
    }


    /**
     * This function is meant to be overridden
     * by the child class.  
     * This provides all of the content
     * for the page.
     * NOTE: You add the content to the 
     *       body in 1 of 2 ways.
     *       1) return the content from this
     *          call.
     *       2) inside the call, you can
     *          just call $this->add();
     *          and then return NULL;
     *
     * @return mixed.
     */
    function body_content() {
        return NULL;
    }


    /**
     * This function is used to save
     * a frameset to the page.  This will
     * automatically output a properly
     * formatted 
     */
    function frameset() {
        return NULL;
    }

    /**
     * This function is called to build
     * any JavaScript that is needed in the
     * <HEAD> portion of a document.
     *
     * @return string - the raw JS code to be
     *                  put inside the <head>
     */
    function head_javascript() {
        return NULL;
    }


    /**
     * This sets the debug option for
     * the HTMLPageClass
     *
     * @param boolean TRUE for on, FALSE for off
     */
    function enable_debug( $flag = TRUE ) {
        $this->_enable_debug = $flag;
    }


    /**
     * This is the function that renders the HTML
     * for this widget.
     *
     * @return string - the HTML
     */
    function render() {

        //test to see if they want debugging of
        //output enabled.
        if ( $this->_enable_debug ) {
            if ( isset($_GET["debug"]) ) {
                $this->set_text_debug( TRUE );
            }
        }

        //see if we have permissions to build the
        //content for this page.  If permissions checks
        //aren't allowed, this will pass.
        if ($this->_has_permission()) {
            //check to see if they want to render a frameset
            $frameset = $this->frameset();
            if ( $frameset != NULL ) {
                //add and set the page output
                //to be a frameset.
                $this->set_frameset( $frameset );
            } else {

                //Try and get some more head content
                $content = "";
                $content = $this->head_content();
                if ( $content != "" ) {
                    $this->add_head_content( $content );
                }

                //try and get the body content.
                //the user could just have added
                //the data manually.
                $content = "";
                $content = $this->body_content();
                if ( $content != "" ) {
                    $this->add( $content );
                }
            }

            //Lets see if they have any javascript 
            //for the head
            $js = $this->head_javascript();
            if ( $js != NULL ) {
                $this->add_head_js( $js );
            }           
        } else {
            $this->add( html_br(), $this->_permission_box);
        }
        
        return HTMLPageClass::render();
    }


    /**
     * This method is used to enable or disable the
     * built in permissions checking mechanism.
     * 
     * @param boolean TRUE = enable permissions checks
     */
    function allow_permissions_checks($flag=true) {
        $this->_allow_permissions_checks = $flag;
    }


    /**
     * This method allows all PageWidget children to
     * do any kind of permissions checking before
     * any content methods are called.
     * This allows for a very secure method of building
     * and rendering the page content.
     *
     */
    function _check_permissions() {        
        //call the child permission() method
        if ( !$this->permission() ) {
            //looks like the user doesn't have
            //permissions to view this page
            $this->_set_perms( FALSE );

            $this->_build_permission_box();            
        }
    }

    /**
     * This is meant to be extended by the child class
     * to do any generic permissions checking for access
     * to the content that the child builds
     *
     * @return boolean - TRUE = has permissions to build
     *                          and view content.
     */
    function permission() {
        //by default return true.
        return true;
    }

    /**
     * set the value of the permissions
     *
     * @param boolean - TRUE = has permission
     */
    function _set_perms( $flag ) {
        $this->_perm_options["allowed"] = $flag;
    }

    /**
     * do we have permissions to build/view the content?
     *
     * @return boolean
     */
    function _has_permission() {
        if (!$this->_allow_permissions_checks) {
            //permissions checks aren't allowed
            //so just return true.
            return TRUE;
        } else {
            return $this->_perm_options["allowed"];
        }        
    }

    /**
     * This is used to set the various options for displaying
     * the failed permissions box.  This should be called
     * prior to returning false in the permissions() method
     *
     * @param string - the permissions message
     *                 NOTE: NULL message means use the default.
     * @param string - the url where to go to.
     *                 NOTE: if NULL, then there will be no
     *                       button shown
     */
    function set_permissions_message($message=NULL, $url=NULL) {
        if ( $message != NULL ) {
            $this->_perm_options["message"] = $message;
        }
        $this->_perm_options["url"] = $url;
    }

    /**
     * This is the method used to build the
     * object to display the permissions error.
     * 
     * By default it uses either the MessageBoxWidget
     * or the MessageBoxOK widget which both rely on
     * having the InfoTable object's css included in the page.
     * 
     * @return none
     */
    function _build_permission_box() {
        if ( $this->_perm_options["url"] == NULL ) {
                $this->_permission_box = new MessageBoxWidget("Error", $this->_permissions_error_width,
                                                              $this->_perm_options["message"]);
            } else {
                $this->_permission_box = new MessageBoxOK("Error", $this->_permissions_error_width,
                                                          $this->_perm_options["message"],
                                                          $this->_perm_options["url"]);
            }
    }
}
?>
1	jonen	1.1	<?php
2			/**
3			* This file contains the PageWidget class
4			*
5	jonen	1.4	* $Id: PageWidget.inc,v 1.5 2003/09/30 00:20:01 hemna Exp $
6	jonen	1.1	*
7			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
8			* @package phpHtmlLib
9			*/
10
11			/**
12			* Make sure we have the required parent class
13			*/
14			require_once($phphtmllib."/widgets/HTMLPageClass.inc");
15
16			/**
17	jonen	1.4	* We need to make sure we have the MessageBoxWidget loaded
18			* for the permissions checking.
19			*
20			* NOTE: The InfoTable css classes must be included in any
21			* page that uses the permissions checking.
22			*/
23			require_once($phphtmllib."/widgets/MessageBoxWidget.inc");
24
25			/**
26	jonen	1.1	* This class is used to build content
27			* for an entire page. It uses the
28			* HTMLPageClass widget from phphtmllib
29			* to render the final output.
30			*
31			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
32			* @package phpHtmlLib
33			*/
34			class PageWidget extends HTMLPageClass {
35
36	jonen	1.4	/ CLASS VARS /
37	jonen	1.1
38	jonen	1.4	/**
39			* This enables the ability to view the
40			* source of a page bu setting debug=1
41			* in the query string.
42			*
43			*/
44			var $_enable_debug = FALSE;
45	jonen	1.1
46
47			/**
48			* holds the page title text for
49			* a page
50			*
51			*/
52			var $_title_text = NULL;
53
54	jonen	1.4	/**
55			* Does the user have permission
56			* to build and view the content?
57			*/
58			var $_perm_options = array("allowed" => TRUE,
59			"message" => "You are not allowed to view this page.",
60			"url" => NULL);
61
62			/**
63			* the message box for displaying
64			* permissions errors
65			*/
66			var $_permission_box = NULL;
67	jonen	1.1
68	jonen	1.4	/**
69			* This is to enable/disable the
70			* permissions checking.
71			* By default it is off.
72			*/
73			var $_allow_permissions_checks = FALSE;
74
75
76			/**
77			* The width of the permissions dialog
78			* table.
79			*/
80			var $_permissions_error_width = "50%";
81
82
83			/**
84			* Constructor:
85			*
86	jonen	1.1	* @param mixed - $title Title string or TITLEtag object for the page.
87			* @param string - one of 3 types of html to render. Setting this will
88			* make the object declare the gobal define which tells
89			* all of the tag objects what type of html tags to render.
90			* some tags support special features. such as the <IMG>
91			* tag. If xhtml is selected, the the IMGtag object and all
92			* utility functions will not render "border=0" as a default
93			* attribute, since this is not proper xhtml.
94			* "html" - HTML 4.0 (default)
95			* "xhtml_transitional" - render xhtml instead of html
96			* - doctype is XHTML transitional.
97			* "xhtml_strict" - render xhtml instead of html 4.0.
98			* - doctype is XHTML strict.
99	jonen	1.4	* @param int - one of 2 types. INDENT_NICE or INDENT_LEFT_JUSTIFY
100			* This tells the page how to render the indenting of the
101			* output. By default it is set to INDENT_NICE, which nicely
102			* indents each nested tag. You can have all tags rendered
103			* left justified (smaller size in output) by using
104			* INDENT_LEFT_JUSTIFY
105			*
106			*/
107			function PageWidget( $title, $render_type = HTML, $indent_style=INDENT_NICE ) {
108	jonen	1.1
109	jonen	1.4	if ( defined("DEBUG") &&
110	jonen	1.1	(isset($_GET["debug"]) \|\|
111			isset($_POST["debug"]) ) ) {
112	jonen	1.4	$this->enable_debug( TRUE );
113			}
114	jonen	1.1	//save the title for later.
115			$this->_title_text = $title;
116
117	jonen	1.4	//call the parent's constructor
118			$this->HTMLPageClass( $title, $render_type, $indent_style );
119
120			//see if we are allowed to check permissions
121			//You need to have the CSS definitions for the
122			//InfoTable defined in order to see the error
123			//table correctly. Or you can override the
124			//_build_permission_box() method to provide
125			//a different object for displaying the
126			//permission errors.
127			if ($this->_allow_permissions_checks) {
128			//check the permissions on this page
129			$this->_check_permissions();
130			}
131			}
132	jonen	1.1
133			/**
134			* gets the current title of the page.
135			*
136			* @return string
137			*/
138			function get_title() {
139			return $this->_title_text;
140			}
141
142	jonen	1.4	/**
143			* This function is used to build
144			* addition head content that isn't
145			* built by the HTMLPageClass parent
146			* class by default.
147			* NOTE: you can add addition content
148			* to the head in 1 of 2 ways.
149			* 1) inside the call return the
150			* addition content in the
151			* return $foo;
152			* 2) or use the HTMLPageClass'
153			* $this->add_head_content()
154			* from within the head_content()
155			* call.
156			*
157			* @return mixed.
158			*/
159			function head_content() {
160			return NULL;
161			}
162
163
164			/**
165			* This function is meant to be overridden
166			* by the child class.
167			* This provides all of the content
168			* for the page.
169			* NOTE: You add the content to the
170			* body in 1 of 2 ways.
171			* 1) return the content from this
172			* call.
173			* 2) inside the call, you can
174			* just call $this->add();
175			* and then return NULL;
176			*
177			* @return mixed.
178			*/
179			function body_content() {
180			return NULL;
181			}
182
183
184			/**
185			* This function is used to save
186			* a frameset to the page. This will
187			* automatically output a properly
188			* formatted
189			*/
190			function frameset() {
191			return NULL;
192			}
193
194			/**
195			* This function is called to build
196			* any JavaScript that is needed in the
197			* <HEAD> portion of a document.
198			*
199			* @return string - the raw JS code to be
200			* put inside the <head>
201			*/
202			function head_javascript() {
203			return NULL;
204			}
205
206
207			/**
208			* This sets the debug option for
209			* the HTMLPageClass
210			*
211			* @param boolean TRUE for on, FALSE for off
212			*/
213			function enable_debug( $flag = TRUE ) {
214			$this->_enable_debug = $flag;
215			}
216
217
218			/**
219			* This is the function that renders the HTML
220			* for this widget.
221			*
222			* @return string - the HTML
223			*/
224			function render() {
225
226			//test to see if they want debugging of
227			//output enabled.
228			if ( $this->_enable_debug ) {
229			if ( isset($_GET["debug"]) ) {
230			$this->set_text_debug( TRUE );
231			}
232			}
233
234			//see if we have permissions to build the
235			//content for this page. If permissions checks
236			//aren't allowed, this will pass.
237			if ($this->_has_permission()) {
238			//check to see if they want to render a frameset
239			$frameset = $this->frameset();
240			if ( $frameset != NULL ) {
241			//add and set the page output
242			//to be a frameset.
243			$this->set_frameset( $frameset );
244			} else {
245
246			//Try and get some more head content
247			$content = "";
248			$content = $this->head_content();
249			if ( $content != "" ) {
250			$this->add_head_content( $content );
251			}
252
253			//try and get the body content.
254			//the user could just have added
255			//the data manually.
256			$content = "";
257			$content = $this->body_content();
258			if ( $content != "" ) {
259			$this->add( $content );
260			}
261			}
262
263			//Lets see if they have any javascript
264			//for the head
265			$js = $this->head_javascript();
266			if ( $js != NULL ) {
267			$this->add_head_js( $js );
268			}
269			} else {
270			$this->add( html_br(), $this->_permission_box);
271			}
272
273			return HTMLPageClass::render();
274			}
275	jonen	1.1
276
277	jonen	1.4	/**
278			* This method is used to enable or disable the
279			* built in permissions checking mechanism.
280			*
281			* @param boolean TRUE = enable permissions checks
282			*/
283			function allow_permissions_checks($flag=true) {
284			$this->_allow_permissions_checks = $flag;
285			}
286
287
288			/**
289			* This method allows all PageWidget children to
290			* do any kind of permissions checking before
291			* any content methods are called.
292			* This allows for a very secure method of building
293			* and rendering the page content.
294			*
295			*/
296			function _check_permissions() {
297			//call the child permission() method
298			if ( !$this->permission() ) {
299			//looks like the user doesn't have
300			//permissions to view this page
301			$this->_set_perms( FALSE );
302
303			$this->_build_permission_box();
304			}
305			}
306
307			/**
308			* This is meant to be extended by the child class
309			* to do any generic permissions checking for access
310			* to the content that the child builds
311			*
312			* @return boolean - TRUE = has permissions to build
313			* and view content.
314			*/
315			function permission() {
316			//by default return true.
317			return true;
318			}
319
320			/**
321			* set the value of the permissions
322			*
323			* @param boolean - TRUE = has permission
324			*/
325			function _set_perms( $flag ) {
326			$this->_perm_options["allowed"] = $flag;
327			}
328
329			/**
330			* do we have permissions to build/view the content?
331			*
332			* @return boolean
333			*/
334			function _has_permission() {
335			if (!$this->_allow_permissions_checks) {
336			//permissions checks aren't allowed
337			//so just return true.
338			return TRUE;
339			} else {
340			return $this->_perm_options["allowed"];
341			}
342			}
343
344			/**
345			* This is used to set the various options for displaying
346			* the failed permissions box. This should be called
347			* prior to returning false in the permissions() method
348			*
349			* @param string - the permissions message
350			* NOTE: NULL message means use the default.
351			* @param string - the url where to go to.
352			* NOTE: if NULL, then there will be no
353			* button shown
354			*/
355			function set_permissions_message($message=NULL, $url=NULL) {
356			if ( $message != NULL ) {
357			$this->_perm_options["message"] = $message;
358			}
359			$this->_perm_options["url"] = $url;
360			}
361
362			/**
363			* This is the method used to build the
364			* object to display the permissions error.
365			*
366			* By default it uses either the MessageBoxWidget
367			* or the MessageBoxOK widget which both rely on
368			* having the InfoTable object's css included in the page.
369			*
370			* @return none
371			*/
372			function _build_permission_box() {
373			if ( $this->_perm_options["url"] == NULL ) {
374			$this->_permission_box = new MessageBoxWidget("Error", $this->_permissions_error_width,
375			$this->_perm_options["message"]);
376			} else {
377			$this->_permission_box = new MessageBoxOK("Error", $this->_permissions_error_width,
378			$this->_perm_options["message"],
379			$this->_perm_options["url"]);
380			}
381			}
382	jonen	1.1	}
383			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26