1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
=head1 NAME
Reaction::Manual::Glossary - Terms and Definitions used in Reaction
=head1 GLOSSARY
=head3 Controller
Reaction controllers are extended L<Catalyst> controllers. The controllers coordinate
L</Interface Model> access and actions with the view logic in your L</ViewPort>s.
=over
=item * L<Reaction::UI::Controller>
=item * L<Reaction::UI::Controller::Root>
=back
=head3 Domain Model
This is the implementation of your business logic. An example would be a L<DBIx::Class> schema
providing you with collections, objects and relationships.
Your Domain Model will interface with Reaction through an L</Interface Model>. Therefore your
domain model itself can and should be decoupled from your Reaction application.
=over
=item * L<Reaction::Manual::Overview>
=back
=head3 Focus Stack
Whenever you push a L</ViewPort> in your controller, you are pushing it onto the Focus Stack.
When the root window (containing the root Focus Stack) is flushed by Reaction at the end
of the request, the ViewPorts' L</Widget>s will be rendered inside each other.
A typical example would be a L<SiteLayout|Reaction::UI::ViewPort::SiteLayout> ViewPort
being pushed onto the Focus Stack by your root action. A
L<CRUD|Reaction::UI::Controller::Collection::CRUD> controller would then, if its list action
was requested, push a L<ListView|Reaction::UI::ViewPort::ListView> ViewPort. On flushing,
the ListView will be rendered inside the SiteLayout.
=over
=item * L<Reaction::UI::FocusStack>
=back
=head3 Interface Model
Provides a standardized way for the application to interact with the
L</Domain Model>s. It does this by providing objects, collections and actions.
A CRUD capable interface model can be generated from a L<DBIx::Class> schema on-the-fly via
L<Reaction::InterfaceModel::Reflector::DBIC>.
=over
=item * L<Reaction::Manual::Overview>
=item * L<Reaction::Manual::Tutorial>
=item * L<Reaction::InterfaceModel::Object>
=item * L<Reaction::InterfaceModel::Collection>
=item * L<Reaction::InterfaceModel::Action>
=back
=head3 Layout
Defines how a L</Widget> fragment is rendered. They are organized in L</LayoutSet>s. Its
arguments are provided by the Widget the LayoutSet specified.
Layout fragments reference other fragments and can be overridden or wrapped when the
LayoutSet is an extension of another.
=over
=item * L<Reaction::Manual::Templates>
=item * L<Reaction::Manual::RenderPage>
=back
=head3 LayoutSet
Contains L</Layout>s. A LayoutSet is specified (or autodiscovered) for any
L</ViewPort>. It determines which L</Widget> to use as the functional part used to
render the ViewPort. A LayoutSet can also extend on another LayoutSet. With this,
L</Layout>s of the parent can be modified. This allows for very fine-grained control
when developing different L<Skin>s.
=over
=item * L<Reaction::Manual::RenderPage>
=item * L<Reaction::Manual::Overview>
=item * L<Reaction::UI::LayoutSet>
=back
=head3 ListView
The ListView L</Widget>, L</ViewPort> and L</LayoutSet> group
allows you to render an L</Interface Model> collection as a table.
=over
=item * L<Reaction::UI::ViewPort::ListView>
=item * L<Reaction::UI::Widget::ListView>
=item * L<Reaction::InterfaceModel::Collection>
=back
=head3 MVC
Model-View-Controller - a high-level software design pattern, which focuses on separation of
concerns. For details on MVC, try here, here, and here. Reaction is an extended MVC system;
it uses a two-layer Model (the Interface Model, with the Domain Model below it). Views are
implemented by DOCTODO. Controllers are represented by DOCTODO.
=head3 Observer
DOCTODO: A software design pattern in which one
=head3 RenderingContext
The context in which the L</Widget>'s rendering via the L</LayoutSet> will be done. A typical
example would be a L<Template Toolkit|Template> LayoutSet being used to render a
L</Widget> in the L<Reaction::UI::RenderingContext::TT> context.
=over
=item * L<Reaction::Manual::RenderPage>
=item * L<Reaction::UI::RenderingContext>
=back
=head3 Role
A particular interface that a class implements. Here, Role is used in the sense of Moose::Role;
this same concept is sometimes called a Mix-In Class or a Decorator pattern.
=over
=item * L<Moose>
=item * L<Moose::Role>
=back
=head3 Skin
A Skin usually contains L</LayoutSet>s and files for static delivery. Since Skins are extendable
and can be switched by configuration, they allow easy customization of your application's
look and feel.
=over
=item * L<Reaction::Manual::RenderPage>
=item * L<Reaction::UI::Skin>
=back
=head3 View
In Reaction, the View modules handle rendering the ViewPort. ViewPorts are the V in MVC.
Technically, the View creates the L</RenderingContext> and finds the L</LayoutSet>s via the
L</ViewPort>s and L</Widget>s from the LayoutSets that are required to render your page.
=over
=item * L<Reaction::Manual::RenderPage>
=item * L<Reaction::UI::View>
=item * L<Reaction::UI::View::TT>
=back
=head3 ViewPort
Represents a part of your web pages output. Your application creates a page by stacking
ViewPorts referencing your L</Interface Model>s inside another. To each ViewPort belongs a
L</LayoutSet>, which will determine the layout and type of the L</Widget>s rendering your page.
=over
=item * L<Reaction::Manual::RenderPage>
=item * L<Reaction::UI::ViewPort>
=back
=head3 Widget
The functionality needed to render a part of your page. The Widget that is used
is determined by the L</LayoutSet>, which is in turn determined by the L</ViewPort>.
The Widget organizes the layouts contained in the LayoutSet and provides them with
data to render.
=over
=item * L<Reaction::Manual::RenderPage>
=item * L<Reaction::Manual::Widgets>
=item * L<Reaction::UI::Widget>
=back
=head1 SEE ALSO
Please refer to these documents for further and more general information:
=over
=item * L<Reaction::Manual>
=item * L<Reaction::Manual::Overview>
=item * L<Reaction::Manual::Intro>
=back
=head1 AUTHORS
See L<Reaction::Class> for authors.
=head1 LICENSE
See L<Reaction::Class> for the license.
=cut
|
