GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  REACTION::MANUAL::GLOSSARY (3)

.ds Aq ’

NAME

Reaction::Manual::Glossary - Terms and Definitions used in Reaction

CONTENTS

GLOSSARY

Controller

Reaction controllers are extended Catalyst controllers. The controllers coordinate Interface Model access and actions with the view logic in your ViewPorts.
o Reaction::UI::Controller
o Reaction::UI::Controller::Root
Domain Model

This is the implementation of your business logic. An example would be a DBIx::Class schema providing you with collections, objects and relationships.

Your Domain Model will interface with Reaction through an Interface Model. Therefore your domain model itself can and should be decoupled from your Reaction application.
o Reaction::Manual::Overview
Focus Stack

Whenever you push a 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’ Widgets will be rendered inside each other.

A typical example would be a SiteLayout ViewPort being pushed onto the Focus Stack by your root action. A CRUD controller would then, if its list action was requested, push a ListView ViewPort. On flushing, the ListView will be rendered inside the SiteLayout.
o Reaction::UI::FocusStack
Interface Model

Provides a standardized way for the application to interact with the Domain Models. It does this by providing objects, collections and actions.

A CRUD capable interface model can be generated from a DBIx::Class schema on-the-fly via Reaction::InterfaceModel::Reflector::DBIC.
o Reaction::Manual::Overview
o Reaction::Manual::Tutorial
o Reaction::InterfaceModel::Object
o Reaction::InterfaceModel::Collection
o Reaction::InterfaceModel::Action
Layout

Defines how a Widget fragment is rendered. They are organized in LayoutSets. 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.
o Reaction::Manual::Templates
o Reaction::Manual::RenderPage
LayoutSet

Contains Layouts. A LayoutSet is specified (or autodiscovered) for any ViewPort. It determines which Widget to use as the functional part used to render the ViewPort. A LayoutSet can also extend on another LayoutSet. With this, Layouts of the parent can be modified. This allows for very fine-grained control when developing different Skins.
o Reaction::Manual::RenderPage
o Reaction::Manual::Overview
o Reaction::UI::LayoutSet
ListView

The ListView Widget, ViewPort and LayoutSet group allows you to render an Interface Model collection as a table.
o Reaction::UI::ViewPort::ListView
o Reaction::UI::Widget::ListView
o Reaction::InterfaceModel::Collection
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.

Observer

DOCTODO: A software design pattern in which one

RenderingContext

The context in which the Widget’s rendering via the LayoutSet will be done. A typical example would be a Template Toolkit LayoutSet being used to render a Widget in the Reaction::UI::RenderingContext::TT context.
o Reaction::Manual::RenderPage
o Reaction::UI::RenderingContext
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.
o Moose
o Moose::Role
Skin

A Skin usually contains LayoutSets 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.
o Reaction::Manual::RenderPage
o Reaction::UI::Skin
View

In Reaction, the View modules handle rendering the ViewPort. ViewPorts are the V in MVC.

Technically, the View creates the RenderingContext and finds the LayoutSets via the ViewPorts and Widgets from the LayoutSets that are required to render your page.
o Reaction::Manual::RenderPage
o Reaction::UI::View
o Reaction::UI::View::TT
ViewPort

Represents a part of your web pages output. Your application creates a page by stacking ViewPorts referencing your Interface Models inside another. To each ViewPort belongs a LayoutSet, which will determine the layout and type of the Widgets rendering your page.
o Reaction::Manual::RenderPage
o Reaction::UI::ViewPort
Widget

The functionality needed to render a part of your page. The Widget that is used is determined by the LayoutSet, which is in turn determined by the ViewPort.

The Widget organizes the layouts contained in the LayoutSet and provides them with data to render.
o Reaction::Manual::RenderPage
o Reaction::Manual::Widgets
o Reaction::UI::Widget

SEE ALSO

Please refer to these documents for further and more general information:
o Reaction::Manual
o Reaction::Manual::Overview
o Reaction::Manual::Intro

AUTHORS

See Reaction::Class for authors.

LICENSE

See Reaction::Class for the license.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 REACTION::MANUAL::GLOSSARY (3) 2010-10-29

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.