SuikaWiki/View/Implementation.pm


=head1 NAME

SuikaWiki::View::Implementation --- SuikaWiki: WikiView implementation

=cut

package SuikaWiki::View::Implementation;
use strict;
our $VERSION = do{my @r=(q$Revision: 1.1 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
our @CommonViewDefs;

=head1 METHODS

=over 4

=item $v = SuikaWiki::View->new

Constructs new instance of WikiView implementation

=cut

sub new ($%) {
  my $class = shift;
  my $self = bless {@_, definition => {}}, $class;
  
  $self;
}

sub select ($$$) {
  my ($self, $mode, $opt) = @_;
  my $views = $self->{definition}->{$mode} || [];
  my @views;
  VIEW: for my $view (@$views) {
    my $point = 0;
    COND: for (keys %{$view->{condition}}) {
      next if $_ eq 'mode';
      if (ref ($view->{condition}->{$_}) eq 'ARRAY') {
        for my $item (@{$view->{condition}->{$_}}) {
          if ($item eq $opt->{condition}->{$_}) {
            $point++;
            next COND;
          }
        }
        next VIEW; # no match
      } elsif ($opt->{condition}->{$_} eq $view->{condition}->{$_}) {
        $point++;
      } else {
        next VIEW; # no match
      }
    }
    $views[$point] ||= [];
    push @{$views[$point]}, $view;
  }
  
  for (reverse 0..$#views) {
    for my $view (@{$views[$_]||[]}) {
      return $view if !$view->{check} || &{$view->{check}} ($self, $opt);
    }
  }
  
  if ($mode ne '#default') { 
    return $self->select ('#default', $opt);
  } else {
    return undef;
  }
}

sub instantiate ($$$) {
  my ($self, $mode, $opt) = @_;
  my $view = $self->select ($mode, $opt) or return undef;
  unless (ref $view->{object}) {
    if ($view->{object_class}) {
      $view->{object} = $view->{object_class}->new (view => $self, 
                                                    viewdef => $view, 
                                                    opt => $opt);
    } else {
      $view->{object} = &{$view->{object_init}} ($self, $opt, $view);
    }
  }
  $view->{object}->{viewdef} = $view;
  return $view->{object};
}

                 
sub register_mode ($$$) {
  my ($self, $mode, $view) = @_;
  $view->{condition}->{mode} ||= $mode;
  $self->{definition}->{$mode} ||= [];
  push @{$self->{definition}->{$mode}}, $view;
}

                   
sub init_db ($$) {
  my ($self, $opt) = @_;
  $self->{wiki}->init_db;
}

sub register_common_modes ($) {
  my ($self) = @_;
  for (@CommonViewDefs) {
    $self->register_mode ($_->{condition}->{mode} => $_);
  }
}

our %TemplateFragment;
sub assemble_template ($$) {
  my ($self, $name) = @_;
  join '',
    map {$_->{Main}}
    sort {$a->{Order} <=> $b->{Order}}
    @{$TemplateFragment{$name}||{}};
}

=item $v->{definition}->{ $mode } = [{ condition => {mode => $mode,...}, ... },...]

=item $v->{wiki}

Instance of wiki implementation

=back

=cut

package SuikaWiki::View::template;

sub new ($%) {
  my $class = shift;
  bless {@_}, $class;
}

sub main ($$) {
  my ($self, $opt) = @_;
  my $opt2 = {};
  $self->main_pre ($opt, $opt2)
    &&
  1
    &&
  $self->main_post ($opt, $opt2);
}

sub main_pre ($$$) {
  1;
}

sub main_post ($$$) {
  1;
}

=head1 LICENSE

Copyright 2003 Wakaba <[email protected]>

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut

1; # $Date: 2003/10/05 11:55:29 $
1
2	=head1 NAME
3
4	SuikaWiki::View::Implementation --- SuikaWiki: WikiView implementation
5
6	=cut
7
8	package SuikaWiki::View::Implementation;
9	use strict;
10	our $VERSION = do{my @r=(q$Revision: 1.1 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
11	our @CommonViewDefs;
12
13	=head1 METHODS
14
15	=over 4
16
17	=item $v = SuikaWiki::View->new
18
19	Constructs new instance of WikiView implementation
20
21	=cut
22
23	sub new ($%) {
24	my $class = shift;
25	my $self = bless {@_, definition => {}}, $class;
26
27	$self;
28	}
29
30	sub select ($$$) {
31	my ($self, $mode, $opt) = @_;
32	my $views = $self->{definition}->{$mode} \|\| [];
33	my @views;
34	VIEW: for my $view (@$views) {
35	my $point = 0;
36	COND: for (keys %{$view->{condition}}) {
37	next if $_ eq 'mode';
38	if (ref ($view->{condition}->{$_}) eq 'ARRAY') {
39	for my $item (@{$view->{condition}->{$_}}) {
40	if ($item eq $opt->{condition}->{$_}) {
41	$point++;
42	next COND;
43	}
44	}
45	next VIEW; # no match
46	} elsif ($opt->{condition}->{$_} eq $view->{condition}->{$_}) {
47	$point++;
48	} else {
49	next VIEW; # no match
50	}
51	}
52	$views[$point] \|\|= [];
53	push @{$views[$point]}, $view;
54	}
55
56	for (reverse 0..$#views) {
57	for my $view (@{$views[$_]\|\|[]}) {
58	return $view if !$view->{check} \|\| &{$view->{check}} ($self, $opt);
59	}
60	}
61
62	if ($mode ne '#default') {
63	return $self->select ('#default', $opt);
64	} else {
65	return undef;
66	}
67	}
68
69	sub instantiate ($$$) {
70	my ($self, $mode, $opt) = @_;
71	my $view = $self->select ($mode, $opt) or return undef;
72	unless (ref $view->{object}) {
73	if ($view->{object_class}) {
74	$view->{object} = $view->{object_class}->new (view => $self,
75	viewdef => $view,
76	opt => $opt);
77	} else {
78	$view->{object} = &{$view->{object_init}} ($self, $opt, $view);
79	}
80	}
81	$view->{object}->{viewdef} = $view;
82	return $view->{object};
83	}
84
85
86	sub register_mode ($$$) {
87	my ($self, $mode, $view) = @_;
88	$view->{condition}->{mode} \|\|= $mode;
89	$self->{definition}->{$mode} \|\|= [];
90	push @{$self->{definition}->{$mode}}, $view;
91	}
92
93
94	sub init_db ($$) {
95	my ($self, $opt) = @_;
96	$self->{wiki}->init_db;
97	}
98
99	sub register_common_modes ($) {
100	my ($self) = @_;
101	for (@CommonViewDefs) {
102	$self->register_mode ($_->{condition}->{mode} => $_);
103	}
104	}
105
106	our %TemplateFragment;
107	sub assemble_template ($$) {
108	my ($self, $name) = @_;
109	join '',
110	map {$_->{Main}}
111	sort {$a->{Order} <=> $b->{Order}}
112	@{$TemplateFragment{$name}\|\|{}};
113	}
114
115	=item $v->{definition}->{ $mode } = [{ condition => {mode => $mode,...}, ... },...]
116
117	=item $v->{wiki}
118
119	Instance of wiki implementation
120
121	=back
122
123	=cut
124
125	package SuikaWiki::View::template;
126
127	sub new ($%) {
128	my $class = shift;
129	bless {@_}, $class;
130	}
131
132	sub main ($$) {
133	my ($self, $opt) = @_;
134	my $opt2 = {};
135	$self->main_pre ($opt, $opt2)
136	&&
137	1
138	&&
139	$self->main_post ($opt, $opt2);
140	}
141
142	sub main_pre ($$$) {
143	1;
144	}
145
146	sub main_post ($$$) {
147	1;
148	}
149
150	=head1 LICENSE
151
152	Copyright 2003 Wakaba <[email protected]>
153
154	This program is free software; you can redistribute it and/or
155	modify it under the same terms as Perl itself.
156
157	=cut
158
159	1; # $Date: 2003/10/05 11:55:29 $