Message/DOM/Event.pm

package Message::DOM::Event;
use strict;
our $VERSION=do{my @r=(q$Revision: 1.1 $=~/\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}) {
    delete $self->{namespace_uri};
    $self->{type} = ''.$_[1];
    $self->{bubbles} = $_[2];
    $self->{cancelable} = $_[3];
  }
} # init_event

sub init_event_ns ($$;$$) {
  my $self = $_[0];
  unless ($self->{manakai_dispatched}) {
    unless (not defined $_[1] or $_[1] eq '') {
      $self->{namespace_uri} = $_[1];
    } else {
      delete $self->{namespace_uri};
    }
    $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}) {
    unless (not defined $_[1] or $_[1] eq '') {
      $self->{namespace_uri} = $_[1];
    } else {
      delete $self->{namespace_uri};
    }
    $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	package Message::DOM::Event;
2	use strict;
3	our $VERSION=do{my @r=(q$Revision: 1.1 $=~/\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	delete $self->{namespace_uri};
84	$self->{type} = ''.$_[1];
85	$self->{bubbles} = $_[2];
86	$self->{cancelable} = $_[3];
87	}
88	} # init_event
89
90	sub init_event_ns ($$;$$) {
91	my $self = $_[0];
92	unless ($self->{manakai_dispatched}) {
93	unless (not defined $_[1] or $_[1] eq '') {
94	$self->{namespace_uri} = $_[1];
95	} else {
96	delete $self->{namespace_uri};
97	}
98	$self->{type} = ''.$_[2];
99	$self->{bubbles} = $_[3];
100	$self->{cancelable} = $_[4];
101	}
102	} # init_event_ns
103
104	sub prevent_default ($) {
105	if ($_[0]->{cancelable}) {
106	$_[0]->{default_prevented} = 1;
107	}
108	} # prevent_default
109
110	sub stop_immediate_propagation ($) {
111	$_[0]->{manakai_immediate_propagation_stopped} = 1;
112	$_[0]->{manakai_propagation_stopped} = 1;
113	} # stop_immediate_propagation
114
115	sub stop_propagation ($) {
116	$_[0]->{manakai_propagation_stopped} = 1;
117	} # stop_propagation
118
119	package Message::DOM::Event::CustomEvent;
120	push our @ISA, 'Message::DOM::Event', 'Message::IF::CustomEvent';
121
122	## The \|CustomEvent\| interface - attribute
123
124	sub detail ($);
125
126	## The \|CustomEvent\| interface - method
127
128	sub init_custom_event_ns ($$$;$$$) {
129	my $self = $_[0];
130	unless ($self->{manakai_dispatched}) {
131	unless (not defined $_[1] or $_[1] eq '') {
132	$self->{namespace_uri} = $_[1];
133	} else {
134	delete $self->{namespace_uri};
135	}
136	$self->{type} = ''.$_[2];
137	$self->{bubbles} = $_[3];
138	$self->{cancelable} = $_[4];
139	$self->{detail} = $_[5];
140	}
141	} # init_custom_event_ns
142
143	package Message::IF::Event;
144	package Message::IF::CustomEvent;
145
146	1;