3 Reaction::Manual::Glossary - Terms and Definitions used in Reaction
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.
15 =item * L<Reaction::UI::Controller>
17 =item * L<Reaction::UI::Controller::Root>
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.
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.
32 =item * L<Reaction::Manual::Overview>
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.
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.
51 =item * L<Reaction::UI::FocusStack>
56 =head3 Interface Model
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.
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>.
66 =item * L<Reaction::Manual::Overview>
68 =item * L<Reaction::Manual::Tutorial>
70 =item * L<Reaction::InterfaceModel::Object>
72 =item * L<Reaction::InterfaceModel::Collection>
74 =item * L<Reaction::InterfaceModel::Action>
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.
84 Layout fragments reference other fragments and can be overridden or wrapped when the
85 LayoutSet is an extension of another.
89 =item * L<Reaction::Manual::Templates>
91 =item * L<Reaction::Manual::RenderPage>
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.
106 =item * L<Reaction::Manual::RenderPage>
108 =item * L<Reaction::Manual::Overview>
110 =item * L<Reaction::UI::LayoutSet>
117 The ListView L</Widget>, L</ViewPort> and L</LayoutSet> group
118 allows you to render an L</Interface Model> collection as a table.
122 =item * L<Reaction::UI::ViewPort::ListView>
124 =item * L<Reaction::UI::Widget::ListView>
126 =item * L<Reaction::InterfaceModel::Collection>
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.
141 DOCTODO: A software design pattern in which one
144 =head3 RenderingContext
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.
152 =item * L<Reaction::Manual::RenderPage>
154 =item * L<Reaction::UI::RenderingContext>
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.
168 =item * L<Moose::Role>
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
181 =item * L<Reaction::Manual::RenderPage>
183 =item * L<Reaction::UI::Skin>
190 In Reaction, the View modules handle rendering the ViewPort. ViewPorts are the V in MVC.
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.
197 =item * L<Reaction::Manual::RenderPage>
199 =item * L<Reaction::UI::View>
201 =item * L<Reaction::UI::View::TT>
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.
214 =item * L<Reaction::Manual::RenderPage>
216 =item * L<Reaction::UI::ViewPort>
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>.
226 The Widget organizes the layouts contained in the LayoutSet and provides them with
231 =item * L<Reaction::Manual::RenderPage>
233 =item * L<Reaction::Manual::Widgets>
235 =item * L<Reaction::UI::Widget>
242 Please refer to these documents for further and more general information:
246 =item * L<Reaction::Manual>
248 =item * L<Reaction::Manual::Overview>
250 =item * L<Reaction::Manual::Intro>
256 See L<Reaction::Class> for authors.
260 See L<Reaction::Class> for the license.