Message/DOM/Event.pm

package Message::DOM::Event;
use strict;
our $VERSION=do{my @r=(q$Revision: 1.16 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
push our @ISA, 'Message::IF::Event';

## The |Event| interface - constants

## |PhaseType|

sub CAPTURING_PHASE () { 1 }
sub AT_TARGET () { 2 }
sub BUBBLING_PHASE () { 3 }

sub AUTOLOAD {
  my $method_name = our $AUTOLOAD;
  $method_name =~ s/.*:://;
  return if $method_name eq 'DESTROY';

  if ({
    ## Read-only attributes (trivial accessors)
    'Message::DOM::Event::bubbles' => 1,
    'Message::DOM::Event::cancelable' => 1,
    'Message::DOM::Event::current_target' => 1,
    'Message::DOM::Event::default_prevented' => 1,
    'Message::DOM::Event::manakai_dispatched' => 1,
    'Message::DOM::Event::event_phase' => 1,
    'Message::DOM::Event::manakai_immediate_propagation_stopped' => 1,
    'Message::DOM::Event::namespace_uri' => 1,
    'Message::DOM::Event::manakai_propagation_stopped' => 1,
    'Message::DOM::Event::target' => 1,
    'Message::DOM::Event::time_stamp' => 1,
    'Message::DOM::Event::type' => 1,
 
    'Message::DOM::Event::CustomEvent::detail' => 1,
  }->{$AUTOLOAD}) {
    no strict 'refs';
    eval qq{
      sub $method_name (\$) {
        return \${\$_[0]}->{$method_name};
      }
    };
    goto &{ $AUTOLOAD };
  } else {
    require Carp;
    Carp::croak (qq<Can't locate method "$AUTOLOAD">);
  }
} # AUTOLOAD

## The |Event| interface - attributes

sub bubbles ($);

sub cancelable ($);

sub current_target ($);

sub default_prevented ($);

## TODO: documentation
sub manakai_dispatched ($);

sub event_phase ($);

## TODO: documentation
sub manakai_immediate_propagation_stopped ($);

sub namespace_uri ($);

## TODO: documentation
sub manakai_propagation_stopped ($);

sub target ($);

sub time_stamp ($);

sub type ($);

## The |Event| interface - methods

sub init_event ($$;$$) {
  my $self = $_[0];
  unless ($self->{manakai_dispatched}) {
    $self->{type} = ''.$_[1];
    $self->{bubbles} = $_[2];
    $self->{cancelable} = $_[3];
  }
} # init_event

sub init_event_ns ($$;$$) {
  my $self = $_[0];
  unless ($self->{manakai_dispatched}) {
    if (not defined $_[1] or $_[1] eq '') {
      $self->{namespace_uri} = $_[1];
    }
    $self->{type} = ''.$_[2];
    $self->{bubbles} = $_[3];
    $self->{cancelable} = $_[4];
  }
} # init_event_ns

sub prevent_default ($) {
  if ($_[0]->{cancelable}) {
    $_[0]->{default_prevented} = 1;
  }
} # prevent_default

sub stop_immediate_propagation ($) {
  $_[0]->{manakai_immediate_propagation_stopped} = 1;
  $_[0]->{manakai_propagation_stopped} = 1;
} # stop_immediate_propagation

sub stop_propagation ($) {
  $_[0]->{manakai_propagation_stopped} = 1;
} # stop_propagation

package Message::DOM::Event::CustomEvent;
push our @ISA, 'Message::DOM::Event', 'Message::IF::CustomEvent';

## The |CustomEvent| interface - attribute

sub detail ($);

## The |CustomEvent| interface - method

sub init_custom_event_ns ($$$;$$$) {
  my $self = $_[0];
  unless ($self->{manakai_dispatched}) {
    if (not defined $_[1] or $_[1] eq '') {
      $self->{namespace_uri} = $_[1];
    }
    $self->{type} = ''.$_[2];
    $self->{bubbles} = $_[3];
    $self->{cancelable} = $_[4];
    $self->{detail} = $_[5];
  }
} # init_custom_event_ns

package Message::IF::Event;
package Message::IF::CustomEvent;
                     
1;
1	wakaba	1.1	package Message::DOM::Event;
2			use strict;
3			our $VERSION=do{my @r=(q$Revision: 1.16 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4			push our @ISA, 'Message::IF::Event';
5
6			## The \|Event\| interface - constants
7
8			## \|PhaseType\|
9
10			sub CAPTURING_PHASE () { 1 }
11			sub AT_TARGET () { 2 }
12			sub BUBBLING_PHASE () { 3 }
13
14			sub AUTOLOAD {
15			my $method_name = our $AUTOLOAD;
16			$method_name =~ s/.*:://;
17			return if $method_name eq 'DESTROY';
18
19			if ({
20			## Read-only attributes (trivial accessors)
21			'Message::DOM::Event::bubbles' => 1,
22			'Message::DOM::Event::cancelable' => 1,
23			'Message::DOM::Event::current_target' => 1,
24			'Message::DOM::Event::default_prevented' => 1,
25			'Message::DOM::Event::manakai_dispatched' => 1,
26			'Message::DOM::Event::event_phase' => 1,
27			'Message::DOM::Event::manakai_immediate_propagation_stopped' => 1,
28			'Message::DOM::Event::namespace_uri' => 1,
29			'Message::DOM::Event::manakai_propagation_stopped' => 1,
30			'Message::DOM::Event::target' => 1,
31			'Message::DOM::Event::time_stamp' => 1,
32			'Message::DOM::Event::type' => 1,
33
34			'Message::DOM::Event::CustomEvent::detail' => 1,
35			}->{$AUTOLOAD}) {
36			no strict 'refs';
37			eval qq{
38			sub $method_name (\$) {
39			return \${\$_[0]}->{$method_name};
40			}
41			};
42			goto &{ $AUTOLOAD };
43			} else {
44			require Carp;
45			Carp::croak (qq<Can't locate method "$AUTOLOAD">);
46			}
47			} # AUTOLOAD
48
49			## The \|Event\| interface - attributes
50
51			sub bubbles ($);
52
53			sub cancelable ($);
54
55			sub current_target ($);
56
57			sub default_prevented ($);
58
59			## TODO: documentation
60			sub manakai_dispatched ($);
61
62			sub event_phase ($);
63
64			## TODO: documentation
65			sub manakai_immediate_propagation_stopped ($);
66
67			sub namespace_uri ($);
68
69			## TODO: documentation
70			sub manakai_propagation_stopped ($);
71
72			sub target ($);
73
74			sub time_stamp ($);
75
76			sub type ($);
77
78			## The \|Event\| interface - methods
79
80			sub init_event ($$;$$) {
81			my $self = $_[0];
82			unless ($self->{manakai_dispatched}) {
83			$self->{type} = ''.$_[1];
84			$self->{bubbles} = $_[2];
85			$self->{cancelable} = $_[3];
86			}
87			} # init_event
88
89			sub init_event_ns ($$;$$) {
90			my $self = $_[0];
91			unless ($self->{manakai_dispatched}) {
92			if (not defined $_[1] or $_[1] eq '') {
93			$self->{namespace_uri} = $_[1];
94			}
95			$self->{type} = ''.$_[2];
96			$self->{bubbles} = $_[3];
97			$self->{cancelable} = $_[4];
98			}
99			} # init_event_ns
100
101			sub prevent_default ($) {
102			if ($_[0]->{cancelable}) {
103			$_[0]->{default_prevented} = 1;
104			}
105			} # prevent_default
106
107			sub stop_immediate_propagation ($) {
108			$_[0]->{manakai_immediate_propagation_stopped} = 1;
109			$_[0]->{manakai_propagation_stopped} = 1;
110			} # stop_immediate_propagation
111
112			sub stop_propagation ($) {
113			$_[0]->{manakai_propagation_stopped} = 1;
114			} # stop_propagation
115
116			package Message::DOM::Event::CustomEvent;
117			push our @ISA, 'Message::DOM::Event', 'Message::IF::CustomEvent';
118
119			## The \|CustomEvent\| interface - attribute
120
121			sub detail ($);
122
123			## The \|CustomEvent\| interface - method
124
125			sub init_custom_event_ns ($$$;$$$) {
126			my $self = $_[0];
127			unless ($self->{manakai_dispatched}) {
128			if (not defined $_[1] or $_[1] eq '') {
129			$self->{namespace_uri} = $_[1];
130			}
131			$self->{type} = ''.$_[2];
132			$self->{bubbles} = $_[3];
133			$self->{cancelable} = $_[4];
134			$self->{detail} = $_[5];
135			}
136			} # init_custom_event_ns
137
138			package Message::IF::Event;
139			package Message::IF::CustomEvent;
140
141			1;