As GWT newbie I'm currently evaluating GWT for some potential future
projects. After reading available introductory materials, I'm now
wondering if GWT is the appropriate candidate for my specific app
scenario.
If I got it right, there basically exist 2 methods to develop GWT
apps:
(1) "desktop-app setup": one GWT module integrated in one almost empty
"carrier" HTML page.
(2) "traditional-web setup": several traditional HTML pages with some
GWT widgets placed in.
Supposing this is correct: What would be the ideal GWT app
architecture for the following, "more hybrid" scenerio?
Say we wanna build a kind of "Mini Online Site Builder" with some
rudimentary CMS functionality and basically consisting of 2 main
requirements for 2 available enduser roles:
(A) 'SiteAdmins' have secured access to an 'AdminConsole' where they
dynamically *compose/edit*,
*preview* and publish 'WebSites' -- the AdminConsole thus
supporting *2 work modes*: Edit, Preview!
- 'WebSites' are published under a common base URL followed by an
admin-specified top-level site name/path.
- 'WebSites' consist of several 'Pages', probably associated to a
default 'MasterPage' (page layout) and
default "Theme" (page layout styles).
- 'Page' may have own 'MasterPage' and own 'Theme' (thus
overriding the default ones).
- 'MasterPage' is composed of typed 'PageRegions'
(e.g. HeaderRegion, FooterRegion, NavRegion,
MainContentRegion, ...).
- 'PageRegion' has list of 'Content' elements of some
'ContentType' that is permissible with that region's type.
ContentTypes could be: TextParagraph, HTMLParagraph,
ImagedTextParagraph, Image, Table, Form, etc.
- Admins would have some advanced widgets to define complex
domain content elements, e.g.
spreadsheets, price tables, etc.
(B) 'Users' visit the resulting web sites which offer a *traditional
web site experience*!!! Thus, they navigate
through the pages and possibly submit some forms -- only public
forms if 'unauthenticated' as well as
ordering or posting forms if 'authenticated' (=> so enduser
accounts management is in place).
Obviously, the AdminConsole impl is a good candidate for a pure GWT
module (see (1) above) whereas I rather would choose pattern (2) for
the web site renderings -- the above-mentioned "hybridity".
Now, I need some expert's advice in the following topics:
1. In GWT, is it realizable to "mimic" traditional web pages within a
GWT widget pane?
I suppose this would imply *client-side* interpretation of the
page components plus inter-page
navigation behaviour, all visualized within GWT panels, wouldn't
it?
2. What would be a practicable top-level design???
Obviously I could have the AdminConsole -- implemented as pure GWT
module -- running on the
client which communicates with "GWTAdminConsoleServlet" via GWT-
RPC, passing serialized
WebSite elements (alt.: XML, JSON) back and forth to provide the
required CRUD services. But...
2.a. Where would I place the component(s) for WebSite generation and
final publication, and
what rendering output would I produce for correct client-side
visualization???...
... Having in mind that ...
2.b. ... each WebSite content element is exposed in "2 flavors":
(a) within a read-only widget for the final publication as
well as the AdminConsole's preview mode, and
(b) within a read-write widget for the AdminConsole's edit
mode.
I.e., how could I best realize this 2-mode support???
3. Is there a client-side storage mechanism to temporarily save
current WebSite definition entities?
If so, is there a size limitation for this storage?
In my current situation, I would highly appreciate any realization
hints.
Thank you very much in advance.
Best regards,
Alessandro
--
You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.
To post to this group, send email to google-web-toolkit@googlegroups.com.
To unsubscribe from this group, send email to google-web-toolkit+unsubscribe@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/google-web-toolkit?hl=en.
No comments:
Post a Comment