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