Recently in Dynamic Content Category

site map · Dynamic Content

left,Left
right,Right
#!/usr/bin/perl

use strict;
use warnings;

use HTML::Widgets::NavMenu;
use File::Path;
my $css_style = <<"EOF";
a:hover { background-color : palegreen; }
.body {
.
.
.
EOF
my $nav_menu_tree =
{
    'host'  => "default",
    'text'  => "Top 1",
    'title' => "T1 Title",
    'subs'  =>
    [
        {
            'text' => "Home",
            'url'  => "",
        },
        {
            'text'  => "About Me",
            'title' => "About Myself",
            'url'   => "me/",
        },
        {
            'text'  => "Links",
            'title' => "Hyperlinks to other Pages",
            'url'   => "links/",
        },
    ],
};
my %hosts =
(
    'hosts' =>
    {
        'default' =>
        {
            'base_url' => ("http://web-cpan.berlios.de/modules/" .
                "HTML-Widgets-NavMenu/article/examples/simple/dest/"),
        },
    },
);
my @pages =
(
    {
        'path'    => "",
        'title'   => "John Doe's Homepage",
        'content' => <<'EOF',
<p>
Hi! This is the homepage of John Doe. I hope you enjoy your stay here.
</p>
EOF
    },
    .
    .
    .
);
foreach my $page (@pages)
{
    my $path     = $page->{'path'};
    my $title    = $page->{'title'};
    my $content  = $page->{'content'};
    my $nav_menu =

        HTML::Widgets::NavMenu->new(
            path_info     => "/$path",
            current_host  => "default",
            hosts         => \%hosts,
            tree_contents => $nav_menu_tree,
        );

    my $nav_menu_results = $nav_menu->render();
    my $nav_menu_text    = join("\n", @{$nav_menu_results->{'html'}});
    
    my $file_path = $path;
    if (($file_path =~ m{/$}) || ($file_path eq ""))
    {
        $file_path .= "index.html";
    }
    my $full_path = "dest/$file_path";
    $full_path =~ m{^(.*)/[^/]+$};

	# mkpath() throws an exception if it isn't successful, which will cause
	# this program to terminate.  This is what we want.
    mkpath($1, 0, 0755);
    open my $out, ">", $full_path or
        die "Could not open \"$full_path\" for writing: $!\n";
    
    print {$out} <<"EOF";
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html
     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<title>$title</title>
<style type="text/css">
$css_style
</style>
</head>
<body>
<div class="navbar">
$nav_menu_text
</div>
<div class="body">
<h1>$title</h1>
$content
</div>
</body>
</html>
EOF

    close($out);
}
    my $nav_menu =
        HTML::Widgets::NavMenu->new(
            path_info     => "/$path",
            current_host  => "default",
            hosts         => \%hosts,
            tree_contents => $nav_menu_tree,
        );

    my $nav_menu_results = $nav_menu->render();
    my $nav_menu_text    = join("\n", @{$nav_menu_results->{'html'}});
use Catalyst qw/Email Prototype Textile/;
$c->log->info("We made it past the for loop");
$c->log->debug( $sql_query );
package MyApp::C::Quux;

# matches only http://localhost:3000/foo/bar/yada
sub baz : Path('foo/bar/yada') { }
package MyApp::C::Foo;

# matches only http://localhost:3000/bar
sub bar : Global { }
package MyApp::C::Catalog::Product;

# matches http://localhost:3000/catalog/product/buy
sub buy : Local { }

package MyApp::C::Catalog::Order;

# matches http://localhost:3000/catalog/order/review
sub review : Local { }
package MyApp::C::Catalog;

# will match http://localhost:3000/item23/order189
sub bar : Regex('^item(\d+)/order(\d+)$') { 
   my ( $self, $c ) = @_;
   my $item_number  = $c->request->snippets->[0];
   my $order_number = $c->request->snippets->[1];
   # ...    
}
sub foo : Regex('^catalog/item(\d+)$') { # ...
package MyApp::C::Foo;
# matches nothing, and is only available via $c->forward('/foo/bar').
sub bar : Private { }
$c->stash->{error_message} = "You must select an entry";

# then, in a TT template:
[% IF error_message %]
   <h3>[% error_message %]</h3>
[% END %]
<h1>[% c.config.name %]</h1>
% foreach my $k (keys $c->req->params) {
  param: <% $k %>: value: <% $c->req->params->{$k} %>
% }
$ catalyst.pl MiniMojo
$ cd MiniMojo
$ script/minimojo_server.pl
sub end : Private {
    my ( $self, $c ) = @_;
    $c->forward('MiniMojo::V::TT') unless $c->res->output;
}
sub default : Private {
    my ( $self, $c ) = @_;
    $c->forward('/page/show');
}
-- minimojo.sql
CREATE TABLE page (
    id INTEGER PRIMARY KEY,
    title TEXT,
    body TEXT
);
$ sqlite minimojo.db < minimojo.sql
$ script/minimojo_create.pl model CDBI CDBI dbi:SQLite:/path/to/minimojo.db
$ script/minimojo_create.pl view TT TT
$ script/minimojo_create.pl controller Page
sub show : Regex('^(\w+)\.html$') {
    my ( $self, $c ) = @_;
    $c->stash->{template} = 'view.tt';
    # $c->forward('page');
}
<html>
    <head><title>MiniMojo</title></head>
    <body>
        <h1>MiniMojo is set up!</h1>
    </body>
</html>
use Catalyst qw/-Debug Prototype Textile/;
sub page : Private {
    my ( $self, $c, $title ) = @_;
    $title ||= $c->req->snippets->[0] || 'Frontpage';
    my $query = { title => $title };
    $c->stash->{page} = MiniMojo::M::CDBI::Page->find_or_create($query);
}
sub edit : Local {
    my ( $self, $c, $title ) = @_;
    $c->forward('page');
    $c->stash->{page}->body( $c->req->params->{body} )
      if $c->req->params->{body};
    my $body = $c->stash->{page}->body || 'Just type something...';
    my $html = $c->textile->process($body);

    my $base = $c->req->base;
    $html    =~ s{(?<![\?\\\/\[])(\b[A-Z][a-z]+[A-Z]\w*)}
                 {<a href="$base$1.html">$1</a>}g;

    $c->res->output($html);
}
<html>
     <head><title>MiniMojo</title></head>
     [% c.prototype.define_javascript_functions %]
     [% url = base _ 'page/edit/' _ page.title %]
     <body Onload="new Ajax.Updater( 'view',  '[% url %]' )">
         <h1>[% page.title %]</h1>
         <div id="view"></div>
         <textarea id="editor" rows="24" cols="80">[% page.body %]</textarea>
         [% c.prototype.observe_field( 'editor', {
             url => url,
             with => "'body='+value",
             update => 'view' }
         ) %]
     </body>
</html>
[% c.prototype.define_javascript_functions %]
[% url = base _ 'page/edit/' _ page.title %] 
<body Onload="new Ajax.Updater( 'view',  '[% url %]' )">
<h1>[% page.title %]</h1>
<div id="view"></div>
<textarea id="editor" rows="24" cols="80">[% page.body %]</textarea>
    [% c.prototype.observe_field( 'editor', {
        url => url,
        with => "'body='+value",
        update => 'view' }
    ) %]

Recently in Dynamic Content Category

Document Modeling with Bricolage

The Elements of Bricolage Stories

Document Analysis

Identifying Content

Defining the Top Element

Identifying Subelements

A Note on Layout

The Document Model

Element Administration

Element Types

Elements

Categories

Document Editing

Up Next: Templating

Building Navigation Menus

Common Patterns in Navigation Menus and Site Flow

A Tree of Items

Next/Previous/Up Links to Traverse a Site

Site Maps and Breadcrumb Trails

Hidden Pages and Skipped Pages

Introducing HTML::Widgets::NavMenu

A Simple Example

A More Complex Example

Adding More Navigation Aids

Fine-Grained Site Flow

A CGI Script

Conclusion

Acknowledgments

Catalyst

Inspirations

Features

Speed

Simplicity

Flexibility

Sample Application: MiniMojo, an Ajax-Based Wiki in 30 Lines of Written Code

Installation

Generate the Application Skeleton

Add Basic Methods to Your Application Class

Set Up the Model (SQLite Database) and Use the Helper to Create Model Classes

Set Up the View (Template::Toolkit) and Use the Helper to Create View Classes

Set Up a Controller Class Using the Helper

Add the Display and Edit Code

Set Up the Wiki with Ajax

Resources

Sponsored by

Set Up the View (`Template::Toolkit`) and Use the Helper to Create View Classes