Ext/GXT/ExtGWT v2.1.0 vs. SmartGWT v2.0

[ahhughes]

For future reference....

At the time of writing the following are available:
GWT v2.0
and.....
SmartGWT v2.0 (http://code.google.com/p/smartgwt/ under Apache
License)
Ext GWT v2.1.0 (http://www.extjs.com/products/gxt/ under weird LGPL
License)

I don't want to discuss Ext GWT's weird license. It's weird, there's
no updates... e.t.c. e.t.c. The question is, if why would you purchase
it over SmartGWT? I am looking for technical reasons such as features,
performance, jsni wrap vs pure compiled gwt, or especially full GWT
2.0 compatibility e.t.c.

Help would be great as there are so many re-packed versions of these
things floating around as well as the fact a lot of information is out
of date (and so will this thread be in the not so distant future).

Thanks heaps in advance :)

[Siegfried Bolz]

I am currently using GXT 2.1.0 on a big customer project and my
experience is, that it is a great framework to
produce fast results. There are some bugs in each release but you have
the possibility to override the methods
to fix the bug by yourself. If you want to extend a widget, it is
possible.
One reason where i think this could be a problem in the future, is
that GXT use Listeners instead of Handlers.
With release 3, i think there could be a big API change coming.

On 29 Jan., 01:16, ahhughes <ahhug...@gmail.com> wrote:
> For future reference....
>
> At the time of writing the following are available:
> GWT v2.0
> and.....

> SmartGWT v2.0 (http://code.google.com/p/smartgwt/under Apache
> License)
> Ext GWT v2.1.0 (http://www.extjs.com/products/gxt/under weird LGPL

[ckendrick]

With SmartGWT you can also extend widgets and override methods in pure
Java.

Just a tour through the SmartGWT and SmartGWT Pro/EE showcases should
be enough to identify a number of feature advantages which may matter
for your application.

http://www.smartclient.com/smartgwt/showcase/
http://www.smartclient.com/smartgwtee/showcase/

On Jan 29, 4:58 am, Siegfried Bolz <siegfried.b...@googlemail.com>
wrote:

> I am currently using GXT 2.1.0 on a big customer project and my
> experience is, that it is a great framework to
> produce fast results. There are some bugs in each release but you have
> the possibility to override the methods
> to fix the bug by yourself. If you want to extend a widget, it is
> possible.
> One reason where i think this could be a problem in the future, is
> that GXT use Listeners instead of Handlers.
> With release 3, i think there could be a big API change coming.
>
> On 29 Jan., 01:16, ahhughes <ahhug...@gmail.com> wrote:
>
> > For future reference....
>
> > At the time of writing the following are available:
> > GWT v2.0
> > and.....
> > SmartGWT v2.0 (http://code.google.com/p/smartgwt/underApache
> > License)

> > Ext GWT v2.1.0 (http://www.extjs.com/products/gxt/underweird LGPL

[Sorinel C]

There you go -- I hope, here:

http://ui-programming.blogspot.com/2010/01/comparation-ext-gwt-gxt-vs-gwt-ext-vs.html

you can find more info about the same topic.

Cheers!

[Andrew Hughes]

Thanks for everyone's replies. I'm still not sure what the fundemental differences are between the 2.5 options above.

The following appears to be the case:

• GXT superseed's the GWT-Ext (as GWT-Ext is no longer under active development), so really this concludes that GWT-Ext is not a viable option.
• Both GXT and Smart GWT are pure gwt (no underlying native JS library, so expect equivalent speed/performance from the GWT compiler).
• GXT's listener/update/event model is vastly different to the pattern used in GWT 2. (at least for GXT 2.1.0). I don't know about SmartGWT :/
• SmartGWT's look and feel is slightly more advanced than GXT's

Conclusion: None of the above really scream "use this one over the other". SmartGWT might have the edge (if there is one).

--AH

Additionally: both have WEIRD commercial licenses! I didn't want to talk about them... but they're probably the deciding factor here now anyway.

• GXT's commercial license is "all features" but you only get the incremental X.* updates (i.e. 2.1, 2.2, 2.3 but not 3.0).
• SmartGWT's commercial licensing appears to be limited on feature set. How useful SmartGWT's widgets are without the complete featureset (i.e. databindings e.t.c) remains a mystery and therefor a risk.

--
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-we...@googlegroups.com.
To unsubscribe from this group, send email to google-web-tool...@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/google-web-toolkit?hl=en.

[Open eSignForms]

On Sun, Jan 31, 2010 at 4:11 PM, Andrew Hughes <ahhu...@gmail.com> wrote:

• Both GXT and Smart GWT are pure gwt (no underlying native JS library, so expect equivalent speed/performance from the GWT compiler).

No, GXT is pure GWT, but SmartGWT is a GWT wrapper around the JS library, though they claim they've spent a lot of time on performance hand-tuning so that's harder to gauge.

 

Additionally: both have WEIRD commercial licenses! I didn't want to talk about them... but they're probably the deciding factor here now anyway.

• GXT's commercial license is "all features" but you only get the incremental X.* updates (i.e. 2.1, 2.2, 2.3 but not 3.0).
• SmartGWT's commercial licensing appears to be limited on feature set. How useful SmartGWT's widgets are without the complete featureset (i.e. databindings e.t.c) remains a mystery and therefor a risk.

This does give a challenge for SmartGWT since you can't demo all the versions and it's not always clear which features are available to which when you look at the myriad examples.  It seems easy to demo LGPL and the Enterprise and know that what you have is what you'll get and nothing more or less.  For us, the databindings likely would have been desirable, but since it requires a commercial, it was hard to build both a client-server solution that was also open source as it would make use of components that require a commercial license.  Of course, that's not a typical problem unless you dual license your product too.

It is a shame that any GUI library comes with runtime licenses as you have to go back pretty far in software engineering to find a UI scheme that could require licenses for deployed systems.  GWT will likely get there over time since I think they'll find supporting more enterprise needs will be a boost for their platform.

[Tercio]

>    - Both GXT and Smart GWT are pure gwt (no underlying native JS library,

>    so expect equivalent speed/performance from the GWT compiler).

Nope, SmartGWT is a wrapper to SmartClient JS Library.

ckendrick and I have different understandings about override ... :-P
We already discussed this some time ago ...

SmartGWT you can't override it's functionality, just it's behavior.

SmartGWT is more feature rich than GXT, but I don't like their
licensing terms, I prefer GXT one, not only because the price, but the
features, we just need a UI framework, the server we already have one.

Regards.

[Tom Schindl]

Though many people think that Overloading/Overwriting and JSNI don't
really fit together.
I think they do if you are a bit creative.

If you are interested in how I solved this problem for QxWT you should
take a look at this series of posts.

[1]http://tomsondev.bestsolution.at/2010/01/05/background-to-qxwt-and-gwt-generator-integration/
[2]http://tomsondev.bestsolution.at/2010/01/10/qxwt-explained-part-2/
[3]http://tomsondev.bestsolution.at/2010/01/12/qxwt-explained-part-3/
[4]http://tomsondev.bestsolution.at/2010/01/15/qxwt-explained-part-4/

The overloading/overwriting use case is discussed in [3]. I have no
deeper insights in SmartGWT but I guess writing something like this is
possible for their set of widgets as well (Probably one can extract
the code I've written for QxWT and make it useable to any JSNI-Wrapper
and even improve the functionality e.g. calling back to JavaScript
without writing any line of code, ... a rather advanced example can be
found here [5]).

BTW QxWT is completely free - everything is dual licensed under EPL and LGPL.

Tom

[5]https://svn.tomsondev.com/svn/ufacekit/qx/org.ufacekit.qx.viewers/src/main/java/org/ufacekit/qx/viewers/internal/TreeDataCellRenderer.java

[ckendrick]

@Tercio I'm not able to follow the distinction you wish to make
between "behavior" and "functionality", but in terms of what the Java
language calls an override, yes SmartGWT supports it. Demonstrated
here among many other places:

http://www.smartclient.com/smartgwt/showcase/#grid_appearance_hilite_add

As far SmartGWT's free vs commercial breakdown is exceeding the
simple: the commercial versions include Java Server functionality.
It's explained clearly here:

http://www.smartclient.com/product/

We also make a nice clean, clear distinction in the showcases.
Everything in this one is free:

http://www.smartclient.com/smartgwt/showcase/

This one has commercial functionality:

http://www.smartclient.com/smartgwtee/showcase/

There is no "mystery" or "risk" regarding what is free and what is
not, or whether it's useful.

Some other mis-statements in this thread:

1. the free version of SmartGWT supports databinding as well.
Approaches are covered here:

http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/docs/ClientDataIntegration.html

2. someone mentioned "already having" a server. SmartGWT's server-
side functionality integrates with any pre-existing server-side
functionality and provides features that don't exist in any server-
side library, so it applies regardless of whether you have a server or
not. Two examples:

Client and server-side validation driven from a single definition, so
you don't have to set up validation logic in both places:

http://www.smartclient.com/smartgwtee/showcase/#data_integration_form_validation

Automated aggregation of client-side requests into a compound request
to make transaction handling easier, cut down on HTTP requests and
simplify the re-use of data services:

http://www.smartclient.com/smartgwtee/showcase/#row_drag_save

And a deeper explanation of how SmartGWT's server-side features apply
even if you have a pre-existing persistence system and business logic:

http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/docs/FeaturesCustomPersistence.html

OK, that's it from the misconception police for today :)

On Feb 1, 6:24 am, Tom Schindl <tomson...@gmail.com> wrote:
> Though many people think that Overloading/Overwriting and JSNI don't
> really fit together.
> I think they do if you are a bit creative.
>
> If you are interested in how I solved this problem for QxWT you should
> take a look at this series of posts.
>

> [1]http://tomsondev.bestsolution.at/2010/01/05/background-to-qxwt-and-gw...

> [2]http://tomsondev.bestsolution.at/2010/01/10/qxwt-explained-part-2/
> [3]http://tomsondev.bestsolution.at/2010/01/12/qxwt-explained-part-3/
> [4]http://tomsondev.bestsolution.at/2010/01/15/qxwt-explained-part-4/
>
> The overloading/overwriting use case is discussed in [3]. I have no
> deeper insights in SmartGWT but I guess writing something like this is
> possible for their set of widgets as well (Probably one can extract
> the code I've written for QxWT and make it useable to any JSNI-Wrapper
> and even improve the functionality e.g. calling back to JavaScript
> without writing any line of code, ... a rather advanced example can be
> found here [5]).
>
> BTW QxWT is completely free - everything is dual licensed under EPL and LGPL.
>
> Tom
>

> [5]https://svn.tomsondev.com/svn/ufacekit/qx/org.ufacekit.qx.viewers/src...

[mariyan nenchev]

Hi,

i had the opportunity to write medium sized app with smart gwt, and for me it was the most painful framework for me ever. I do not know what are the changes in 2.0, i used 1.2, but i am not will never try it again. Also i don't like the resource management like images, css, modules so on... If you simply go arround the showcase you will notice that the interactions with the ui are not very pleasent. May be smart gwt pro/ee are very good for dev, but smart gwt is not, that is why it's free. So you who has money to spend i suggest you buy the paid edition don't kill yourself with smart gwt.

[David Durham]

I like a GXT and wrote a form generation library for it that you might
consider.

http://gxtforms.googlecode.com/

There's an appengine demo linked to from the project pages.

The basic is idea to annotate Model classes and get forms with
data-binding fairly easily. For the next release, I'm working to make
the field types and rendering more easily extensible. If anyone is
interested in contributing to this project, please let me know.

-Dave

[mariyan nenchev]

Thanks i look at it, but i prefer to use pure gwt&incubator. Advanced components also seems good.

[Kevin Q]

I have used both libraries. I would say, stay away from SmartGWT. It's
a wrapper on the SmartClient javascript library, which means the API
is an almost direct transliteration from Javascript. As Joshua Bloch
will tell you, direct transliteration of APIs is bad. A lot of times,
the API methods don't do what their name say and can cause some
surprises...the deal breaker for us was it didn't integrate with
native GWT widgets well. The problem I had at the time was it
customized GWT widgets disappear from a SmartGWT container when it's
resized and so on.

I have no ties with Ext whatsoever, but we're using GXT now because
it's built on top of GWT (not a wrapper of some JS library).
Customization is much easier and whenever a problem arises, you can
always trace down to the very bottom because they're all written in
Java. The same cannot be said about SmartGWT. Having said that, GXT
has quite a few quirks as well. Seems they've been abusing generics
and the event system is terrible to work with.

If you have the time and resource, I'd say writing in pure GWT is the
way to go.

Those are my subjective opinion. I've no intention of trolling.

On Feb 2, 12:28 pm, mariyan nenchev <nenchev.mari...@gmail.com> wrote:
> Thanks i look at it, but i prefer to use pure gwt&incubator. Advanced
> components also seems good.

> On Tue, Feb 2, 2010 at 7:19 PM, David Durham <david.durham...@gmail.com>wrote:

>
>
>
> > On Thu, Jan 28, 2010 at 6:16 PM, ahhughes <ahhug...@gmail.com> wrote:
> > > For future reference....
>
> > > At the time of writing the following are available:
> > > GWT v2.0
> > > and.....

> > > SmartGWT v2.0 (http://code.google.com/p/smartgwt/under Apache
> > > License)
> > > Ext GWT v2.1.0 (http://www.extjs.com/products/gxt/under weird LGPL

> > > License)
>
> > > I don't want to discuss Ext GWT's weird license. It's weird, there's
> > > no updates... e.t.c. e.t.c. The question is, if why would you purchase
> > > it over SmartGWT? I am looking for technical reasons such as features,
> > > performance, jsni wrap vs pure compiled gwt, or especially full GWT
> > > 2.0 compatibility e.t.c.
>
> > > Help would be great as there are so many re-packed versions of these
> > > things floating around as well as the fact a lot of information is out
> > > of date (and so will this thread be in the not so distant future).
>
> > I like a GXT and wrote a form generation library for it that you might
> > consider.
>
> >  http://gxtforms.googlecode.com/
>
> > There's an appengine demo linked to from the project pages.
>
> > The basic is idea to annotate Model classes and get forms with
> > data-binding fairly easily.  For the next release, I'm working to make
> > the field types and rendering more easily extensible.  If anyone is
> > interested in contributing to this project, please let me know.
>
> > -Dave
>
> > --
> > 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-we...@googlegroups.com.
> > To unsubscribe from this group, send email to

> > google-web-tool...@googlegroups.com<google-web-toolkit%2Bunsubs­cr...@googlegroups.com>

[Jeff Schnitzer]

My experience with GXT was horrible, and I ended up ripping it out of
my app entirely. I wrote about it in this thread:

http://groups.google.com/group/google-web-toolkit/msg/693cacbce437d08a

GXT's layout system is alien to GWT, the documentation is nonexistant,
the appearance is highly inflexible, and the attitude of the support
team sucks (even for customers that pay for support). Consider, for a
moment, that there is nobody at Ext commenting on the GXT-related
threads that show up in this forum. Totally out to lunch.

Unless you specifically need an advanced grid control, you're better
off rolling your own UI in vanilla GWT. Do not think "GXT will be
just like GWT, only prettier" - it is an entirely different creature
with a wholly incompatible (and irritatingly inconsistent) widget
library.

Jeff

> To unsubscribe from this group, send email to google-web-tool...@googlegroups.com.

[Bogdan Maryniuck]

On Wed, Feb 3, 2010 at 1:38 AM, mariyan nenchev
<nenchev...@gmail.com> wrote:
> i had the opportunity to write medium sized app with smart gwt, and for me
> it was the most painful framework for me ever.

Yes, it is.

> I do not know what are the changes in 2.0, i used 1.2, but i am not will never try it again.

Yes. And nobody here likes resource management. And Smart GWT is very
buggy. Yes, it is horrible, yes it is painful, but I am not really
sure what else exists that would work on older browsers, while having
same set of functionality. Maybe one day I have to play with
http://vaadin.com/ a little, but currently I stick to SmartGWT: works
for me, though I have to roll my eyes and sight deeply at least twice
per hour, while implementing things.

--
BM

[Sanjiv Jivan]

It's quite easy to criticize a library, isn't it? Instead of making blanket statements like these have you tried reporting the issues on the SmartGWT forum, or file an issue in tracker. I don't recall any posts from you on the SmartGWT forum, nor any issue in tracker. Given this, and your short history on the GWT forum, its hard to tell if you're just inexperienced, haven't read the extensive documentation, or have run into an issue but chose to roll your eyes instead of reporting it.

SmartGWT is based on SmartClient, which has been around for some 8+ years and it is very stable. No software is perfect, however if you take a step back and have a look at the depth and breath of functionality it provides you'll realize that how low the bug / functionality ratio is. 

The SmartGWT tracker has only 34 open defects  : http://code.google.com/p/smartgwt/issues/list

Try comparing this number with you favorite major library. If you have run into an issue that is not yet reported, please do report it. Complaining that a library is horrible, but still the best suited for you makes no sense. 

If you've already made up your mind that SmartGWT is not for you, thats fine. But if you're want to be constructive, post your questions and issues on the SmartGWT forum and you'll see that legitimate issues are resolved promptly.

Sanjiv  

[Bogdan Maryniuck]

On Wed, Feb 3, 2010 at 12:31 PM, Sanjiv Jivan <sanjiv...@gmail.com> wrote:
> It's quite easy to criticize a library, isn't it?

Sanjiv, I remember all that ugly story with you and Ext stuff. And
really appreciate the thing you do. But still, what's wrong with a
constrictive criticism? I am using SmartGWT as the only lib so far in
many projects (although free version :-). So at least I have a right
to "smoke my cigarette" and share with others that the lib is not very
brilliant BUT usable, so no need to run elsewhere, but TRY to improve
it (that's what I said between the lines, BTW). And you also have a
right to listen my stupid feedback and make your own conclusions. :-)

Besides, as a little example among dozen of others, folks (including
myself) were sending multiple complains to the forum about calendar
dialogs that are not customizable, that they are literally fugly:
because who would need ridiculously big dialog while editing an event,
but widgets are very small and grouped at left/top corner? — all the
rest space is for banners and ads or something?.. How to nicely
replace that dialog with my own and why this is so obvious thing
simply hard-coded? etc. Or I am missing something and this is changed
already? So far I've simply either got ignored or being told "we won't
change that".

Hence, if you, guys, "won't change that because we said so", then I
doubt anyone would waste their time writing any feedback or bugreport
knowing it will be rejected/ignored anyway...

--
bm

[Open eSignForms]

SmartGWT (UI part anyway) is open source, so you could modify it -- albeit have to share it back -- but you are not stuck.  Many commercial libraries are even harder to get a fix. Also, a feature any given person needs may not be top priority.

Heck, I love GWT, but it needs better enterprise paging table widgets and ready-made solutions for DTOs+RPC that work with the paging tables and the related page editor forms since listing objects and updating them are very common in enterprise configuration.  A nice customizable reporting feature (perhaps via paging tables with built in search/selectors) is also needed.  But GWT isn't building these anytime soon from what I've gathered, and it doesn't make GWT or Google bad.  They just have priorities that differ from mine.  The incubator has some, but they are not pretty (too much work IMHO) and appear to be under major revision, yet not here yet when I need something now.  Shucks!

I am currently evaluating vaadin and as a java/jsp/servlet programmer, I find their model quite appealing, though many may not.  And it's got ugly APIs as well because it's also "mature" and thus was based on older naming patterns, listeners, use of Object parameters that make it unclear what the heck is expected, but they do have documentation and examples and tutorials.  Naturally, they are missing a lot of key documentation to explain the extra mile coding that all programmers really need, since showcase examples are generally more trivial than anything in the real world.  Heck, I spent a lot of time today just trying to figure out how to make radio buttons whose values differ from the labels associated with the radios since all of the examples (for select boxes too) were just where the two were the same.  Nothing is perfect, but I do like their Table/Form combos and the ability to do only server-side programming so there's no RPC or DTOs to deal with.

But to each his own...  I personally found Ext GWT and SmartGWT to have licensing warts, confusing documentation and like the comments above, a bit abusive in their treatment of users.  Vaadin has a nice Apache 2 license, but they also seem to have a low volume forum that shows a less robust user base overall.  It's not clear if you can buy better forum/email support at a reasonable price.

[Sanjiv Jivan]

Bogdan,

Thanks for the kind words :) Constructive criticism is always welcome as the goal is to improve the product. However please do follow up with the appropriate posts and report enhancements / issues in tracker. 

Regarding the Calendar event dialog customization, that appears to be an enhancement request rather than a bug. I still could not find a user id by your name however I did find a similar thread :

http://forums.smartclient.com/showthread.php?t=4900

As you can see, the user was advised to 

1) either create an enhancement request that other users could vote on or

2) make the enhancement themselves since it is open source and share their work.

However no such enhancement request was created in tracker.  Please email me your SmartGWT forum user name so that I can view the other posts / issues reported by you.

New features are being added to SmartGWT / SmartClient at a really really fast pace. This should be evident by the release notes of each new release, and the commit logs in SVN. For example some 10 significant new features have already been added since the SmartGWT 2.0 release, and countless other minor enhancements as well. So unless users file issues and enhancements, it is not going to be easy to track. Moreover even if you do have a feature request, prioritization will depend on the number of votes it receives which is typical of how most OSS works. If you are a commercial entity you also have the option of contacting Isomorphic and getting the feature added in a timeframe that meets your needs. As mentioned above, you can also dive in and make the change yourself since it is open source.

So kindly be a little patient when reporting enhancements and issues, and follow up by posting a request in tracker with a testcase if you encounter a bug. 

Sanjiv

[Jeff Larsen]

We're currently using GXT on a large project and I'd like to say that

"GXT's layout system is alien to GWT, the documentation is
nonexistant,
the appearance is highly inflexible, and the attitude of the support
team sucks (even for customers that pay for support). Consider, for a
moment, that there is nobody at Ext commenting on the GXT-related
threads that show up in this forum. Totally out to lunch. "

is 100% accurate to my experience. I don't have the luxury of ripping
it out of my app at work, but I wouldn't use it in personal app if it
were free.

Everything you know about GWT and GWT widgets can basically be thrown
out the window. The event model is entirely different. The widgets
have a ton of properties that are set on construction that you cannot
change. Oh and when you decide on GXT know that you're probably going
to be locked into that version and will not be able to upgrade to any
new versions of the software.

I would recommend not using GXT.

> On Tue, Feb 2, 2010 at 11:03 PM, Bogdan Maryniuck <b.maryni...@gmail.com>wrote:
>
> > On Wed, Feb 3, 2010 at 12:31 PM, Sanjiv Jivan <sanjiv.ji...@gmail.com>

> > google-web-tool...@googlegroups.com<google-web-toolkit%2Bunsu...@googlegroups.com>

[Tercio]

You know guys, this is a tough decision. We all differ in experience
and knowledge.

I think that this criticism is good for every one.

SmartGWT is very good in Server-side integration, with a lot UI
widgets, but it's a wrapper to JS and you can't override the way it
work internally(Yes, some will disagree), you can just override some
PROPERTY methods, and I think that this discussion is over.

GXT has no Server-side integration, they have far less widgets than
SmartGWT, but, it's pure Java, you can change it completely just
overriding some methods or classes and yes, NO documentation at all,
theirs JavaDoc just SUCKS.

But.... I'd prefer GXT instead SmartGWT. My experience with SmartGWT
isn't that good, the way the data is managed in the UI is a little bit
weird to me.

I'd recommend to use GXT.

> > > google-web-tool...@googlegroups.com<google-web-toolkit%2Bunsubs cr...@googlegroups.com>

[gengstrand]

I noticed that SmartGWT doesn't support the iPhone whereas GWT does.
This surprised me because SmartGWT does work when using Safari on
either PC or Mac.

How do GXT apps work when surfed to by an iPhone?

[mariyan nenchev]

On Wed, Feb 3, 2010 at 6:24 PM, Tercio <terci...@gmail.com> wrote:

SmartGWT is very good in Server-side integration, with a lot UI

Smart gwt pro/ee may be, but not smart gwt. Tell me how many lines of code you must write in order to integrate it with EJBS? What steps you must do in order to create single list operation?

[siberian]

We've found this ability to override methods and subclass components
to be invaluable. You may be able to do some of this with SmartGWT, I
have not specifically looked. Coming from a Wicket background I found
GXT to be very comfortable and 'Wicketlike' in the way thats its pure
Java and abstracts that level of the platform away.

For example, I needed to add a rowexpander to a grid that expanded out
to show editable record details. GXT has a widget that lets you inject
arbitrary html into an expanded row out of the box. This obviously
sucks when your dealing with a complex and interactive editable row
detail. The entire point (for us) of working in this environment is to
be widget driven vs html driven. With a touch of work I was able to
expand the RowExpander class with my own version that allowed me to
put a Composite Panel in the expanded row vs plain html which let all
of my other tools and the panels sub-components do their job. Once
again, very Wicket-Like for me.

Probably totally possible and easy for SmartGWT (maybe even Out Of The
Box) but I also found it very easy with GXT.

The docs are crap though. One you get into the 'GXT Mindset' it comes
fast and easy but it takes a looooonggggg time to get into the GXT
mindset.

We will evaluate SmartGWT for a future project, the pace of
development there and the level of support can't really be denied. GXT
is falling over in this regard. Slow release process and no real
support (even Premium forums are mostly dead) is a big concern.

For now we're GXT though.
John-

[Jonathan]

I'm also using GXT on a very, very large project. My experience has
been pretty positive. I've been working with the GXT library over a
year. The appearance of most components can be changed pretty
easily. I prefer the GXT rendering model over GWT. We have custom
versions of nearly every GXT component and for the most part there's
only minor things that had to be changed in the last major GXT upgrade
1.x -> 2.0 (but since our code-base is so large it took us nearly 1.5
weeks to perform this upgrade.

I did find the layout managers a little bit lacking so I wrote my own
layout manager which is far superior. Most of our UI's are form
related and fairly complex which is where simple uni-directional
layouts like the ones in GXT are worst suited. I also borrowed some
swing/awt concepts such as invalidate/revalidate so if you change a
value in any component which will affects its bound size, it will
bubble up invalidating all components to the top layout container and
then run the layout. But after all of this, I'm not sure if the GXT
layout managers are the best approach. Performing layout via
javascript is a little sluggish - except in chrome. I'm hoping the
other browsers catch up.

If you decide to use GXT 2.0, you won't be able to use some of the
newer GWT features, like UIBinder. And for the most part, once you
start using GXT, you should avoid using any plain GWT concepts. All
of our components are built off of the base GXT component and
boxcomponent classes.

If I were working on a simpler project, such as a personal project, I
would use plain GWT.

[Bogdan Maryniuck]

One more thing, regardless to SmartGWT or GXT (though was noticed with
Isomorphic thing): browser just get nuts if you put enough complexity
in there and then resize the UI. Since they don't use sizing like 100%
or something, they use actual size recalculation in pixels. I know why
and that's a reason for it. But still this makes your little Atom
processor on netbooks to feel really sorry.

In other words, let's back to applets/JNLP. :-) JavaFX, for example,
is a great thing anyway. For graphs/charts etc. And CPU/memory wise it
is still reasonable and competitive. The only thing I really dislike:
that ugly startup in the applet. But once it is cached — users are
very satisfied much more than with Flash thing.

--
bm

[ckendrick]

Re: widgets inside grid rows: not only is it "out of the box" in
SmartGWT, there are multiple out of the box modes for it, including
nested editable grids.

http://www.smartclient.com/smartgwt/showcase/#featured_nested_grid
http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/types/ExpansionMode.html

In the latest nightlies you can play with yet another level of
sophistication, for release in 2.1:

1. general purpose APIs for attaching components to any individual
cell or row, with multiple sizing modes
2. support for automatic pooling of components at the record level,
for use cases where you have components in most/every row and you are
paging through a large dataset and need to re-use a pool of components
attached to the currently visible records

If it's a "positive" experience to have to fix a lot of bugs, and have
to add missing features, can't wait to see what you guys say when you
evaluate SmartGWT for your next project ;)

[ahhughes]

Thanks to everyone who has chipped in on this discussion. I'm glad I
posted the question and go so much attention.

My take on this:

Point #1: Both GXT and SmartGWT have issues. There are so many
different opinions in this discuss and I feel that signifies that
neither have been widely accepted as reliable/mature/enterprise
extensions. Respond if you like, but the evidence is past history :)

Point #2: There are issues regarding JSNI wrapping libraries (i.e. not
"pure gwt") which result in instability, inconsistancies between API's
and a lack of interaction between JavaScript and GWT communities. None
of which is beneficial and is causing problems.

Conclusion:

Sticking to just the CORE GWT 2.0 seems like the best advice! In case
you are wondering, here's how.. http://code.google.com/webtoolkit/doc/latest/DevGuide.html

CHEERS :)

[Jeff Schnitzer]

I just want to echo this for anyone who hasn't already made up their mind:

* Writing your own UI in straight-up GWT is not as hard as you might think.

The stock widgets are not beautiful out-of-the-box but they are
heavily customizable with CSS. They are *very* easy to learn and
nearly always behave "the way you would expect". You can extend the
stock widgets easily, adding behavior, events, visual effects,
whatever you want. Client/server communication is already elegantly
implemented in stock GWT.

GXT and SmartGWT have very pretty demos. If what you're really
looking for is an attractive app (as opposed to specific behavior in
some of their advanced widgets), consider that they both have very
steep learning curves. In the time it will take you to learn to use
these systems with facility, you could learn enough to extend GWT with
custom widgets and customize the CSS to your liking. Maybe even
publish a few pieces as opensource for the rest of us :-)

It should also not go without mention that GXT and SmartGWT will have
a significant impact on the size of your download. Even trivial GXT
apps are 600+k, and code splitting is useless.

Jeff

> --
> 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-we...@googlegroups.com.

> To unsubscribe from this group, send email to google-web-tool...@googlegroups.com.

[mariyan nenchev]

Yes it has very fancy widgets but the integration with the server side is killing unless you decide to purchase pro/ee, which is why it is done that way, to show the devs how rich library it is and when they began to use it they understand that they must buy pro/ee else they will code hundreds lines of code to do something simple. No body told me how many steps are needed to list some data in table if your backend is EJBs and you are using GWT-RPC?

--
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-we...@googlegroups.com.

To unsubscribe from this group, send email to google-web-tool...@googlegroups.com.

[Ben]

I've been using GXT for a while, and as previous posts have mentioned,
the amount of documentation is pretty sparse. I've been able to
overcome that by relying on their extensive set of demo apps, and by
reading through the API's source code. If you're comfortable reading
someone else's Java code, then you'll be able to figure out how to use
it. IMHO, I'd rather have zero documentation instead of bad/wrong
documentation.

The features I like about GXT are:
- The UI looks super clean and polished
- I actually like the layouts managers - I spent too many years
doing Swing, so my brain is warped into understanding things like
BorderLayout.
- Its developed by the same company/group/people that work on EXT
- The grid can easily handle "large" sets of data (1000 rows per
page, with delayed rendering). One of the previous posts griped about
no server-side integration, but I disagree - GXT provides objects like
BasePagingLoadConfig and BaseTreeLoader for asynchronous on-demand
loading of data.

I haven't used SmartGWT, so it probably has many of these same nifty
features. I basically had about a day to pick one, and so far GXT
hasn't disappointed me.

Good luck!

[Tercio]

@mariyan nenchev, my bad, I forgot to mention that it's a EE feature.
But the UI is available in the free version.

GXT API is much like the AWT API.

> > > > google-web-tool...@googlegroups.com<google-web-toolkit%2Bunsubs cr...@googlegroups.com>

[Tercio]

@mariyan nenchev, I used SmartGWT free version for some time and it
was a pain to integrate with EJB(To be honest I gave up). I considered
the paid version, but it's too expensive. You receive a lot of
"useless" features. You can't choose the ones you need, you must buy
the whole package.

On Feb 3, 2:21 pm, Jonathan <jona...@gmail.com> wrote:

> > > > google-web-tool...@googlegroups.com<google-web-toolkit%2Bunsubs cr...@googlegroups.com>

[siberian]

We don't want nested grids. We don't want nested html. We want a
nested composite panel with arbitrary widgets in them. Neither
framework does well there, hence the custom solution.

Anyhow, we'll be looking on our next project and seeing how we feel
about it. Extended GXT was very simple for us once we got over the
learning curve and SmartGWT will have the same learning curve.

John-

On Feb 3, 4:26 pm, ckendrick <charles.kendr...@gmail.com> wrote:
> Re: widgets inside grid rows: not only is it "out of the box" in
> SmartGWT, there are multiple out of the box modes for it, including
> nested editable grids.
>
>    http://www.smartclient.com/smartgwt/showcase/#featured_nested_grid

>    http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/typ...

[ckendrick]

@Jeff, ahhughes: as far as the built-in GWT widgets, they are well-
designed and fine for simple things, but if your requirement is to
have a grid that supports full-row inline editing, grouping,
filtering, frozen columns, paging through large datasets, resizable/
reorderable headers with persistence, nested headers, all of this
active at once - or if you need even a significant subset of this
functionality - this will take you a minimum of 2 years with core GWT
and you will achieve it really only with a ground-up custom widget
that you will need to maintain. So it's just a matter of recognizing
that many people have requirements that go way, way beyond the core
GWT widgets. Google employees have posted a number of times
acknowledging this.

Note that even if you don't have hard requirements for these features,
the fact is that they make your application better, and you will never
have to deal with a user request for such a feature: it's already
there.

ahhughes as far as your #2, please point to examples. Almost everyone
who has *actually tried* SmartGWT remarks on the extremely low number
of bugs.

@Tercio, mariyan: unclear on why you found server integration with the
SmartGWT LGPL version difficult. All you need to do is expose your
EJBs as REST services and there are countless tutorials on the web on
how to do this, as well as frameworks that can do this from Java
annotations. People achieve this all the time.

Tercio in particular, I'm guessing this was you:

http://forums.smartclient.com/showthread.php?t=5632

You took the wrong approach, and our Support staff told you it wasn't
a good idea and gave you appropriate alternatives.

As far as "useless" features, if you think they're useless, you
frankly have not absorbed what they actually do. Remember, Isomorphic
is a consulting company too. We build applications in defense, life
sciences, insurance, financials and many other verticals. We use the
features of Pro/EE *every single time*.

[Bogdan Maryniuck]

On Thu, Feb 4, 2010 at 6:25 PM, mariyan nenchev
<nenchev...@gmail.com> wrote:
> Yes it has very fancy widgets but the integration with the server side is
> killing unless you decide to purchase pro/ee, which is why it is done that
> way, to show the devs how rich library it is and when they began to use it
> they understand that they must buy pro/ee else they will code hundreds lines
> of code to do something simple. No body told me how many steps are needed to
> list some data in table if your backend is EJBs and you are using GWT-RPC?

Dude, but after all, SmartGWT so far is the best among others, despite
its somewhat tragifunky API. Yes, for us, who are doing Swing as well,
SmartGWT is quite painful, although it intended to be like Swing for
Web. Yes, method names are wicked, composing widgets is weird etc. And
there is also a number of reasons why they're done this way — hence
let's don't regard them as fools — the guys, actually doing awesome
job. Because what else on the market is available right now that could
solve a huge number of a problems that we facing every day, making
enterprise software for the Web?

Personally I don't like concentrating on JavaScript horror and prefer
Java Swing over JNLP in most cases. In Enterprise controlled internal
network we never allow web stuff — there is only Swing and it works
rock stable. But it requires very clean and highly controlled
networks. Since outside the company, in the wild world, there are
anything you might expect, so browsers + JavaScript + HTML is the only
way. However, it is horrific way to make UIs, has no real standards,
is very unpredictable, slippery and unreliable.

So let's better think how we can help them instead, because everyone
can bashing things: that's no brainer...

--
bm

[ckendrick]

Just to sum up, the only people in this thread reporting negative
hands-on experiences with SmartGWT have all gone against our explicit
advice in the documentation, FAQ, and in some cases, personal
attention in the forums.

The only person with hands-on experience claiming there are bugs
turned out to be talking about a particular, narrow Calendar
enhancement that he was displeased had not received more attention.

The actual samples should be self-explanatory. The functionality
demonstrated is extremely broad and deep, the code required is clear
and concise, it's difficult to find a bug and what few exist are
addressed quickly.

See for yourself.

http://www.smartclient.com/smartgwt/showcase/
http://www.smartclient.com/smartgwtee/showcase/

[cretz]

I too have seen many negative comments on SmartGWT. I am not
associated with the project in any way, but I do use it for several
projects lately. I do agree that some of it is difficult to debug/
understand do to the extensive use of JSNI. However, I have received
great forum-based support, and I use the LGPL version. That coupled
with the continued improvement of the library make it a great choice.
Ntm, the license makes me happy.

But I am encouraged by the wrapping of Qooxdoo (finally) at
http://www.ufacekit.org/index.php?cat=02_Qooxdoo&page=01_QxWT.

[Tom Schindl]

On Thu, Feb 11, 2010 at 5:29 PM, cretz <chad...@gmail.com> wrote:
> I too have seen many negative comments on SmartGWT. I am not
> associated with the project in any way, but I do use it for several
> projects lately. I do agree that some of it is difficult to debug/
> understand do to the extensive use of JSNI. However, I have received
> great forum-based support, and I use the LGPL version. That coupled
> with the continued improvement of the library make it a great choice.
> Ntm, the license makes me happy.
>
> But I am encouraged by the wrapping of Qooxdoo (finally) at
> http://www.ufacekit.org/index.php?cat=02_Qooxdoo&page=01_QxWT.
>

The latest Demo can be found here:
http://www.ufacekit.org/qxwt/demos/QxDemo-dev/QxDemo.html. The next
release is scheduled for End of Febuary and I'm just working on a real
world example application as a show case.

From a technical point of view QxWT is doing the same SmartGWT does
because after evaluating a complete
rewrite in Java it didn't make sense to me from a business point of
view (I guess the same was true for SmartGWT).

I've used SmartGWT some time ago and didn't had any problems with
using it still I decided to start QxWT
because though it might sound strange LGPL is something some of my
customer don't allow to be used (hence all code is dual licensed under
EPL and LGPL)
and because I'm confident that there has to be competition and we can
learn all from each other.

Another important part which made me write the QxWT port is that
Qooxdoo-Widgets are plain widgets which means there are no stores
and all those stuff but I can create my own domain-model integration
(I don't know if this changed since I worked with SmartGWT and GXT).

For those interested on the progress can subscribe themselves to my
personal blog http://tomsondev.bestsolution.at/

Tom

[Carl Pritchett]

We have used GXT from 1.2 to 2.1.1 on a mid-sized project.

Pros
- I think the look and feel is sharp and responsive (much nicer that
SmartGWT IMHO - but look at the showcases and judge for youself).
- Grids are the best I've seen (sorry SmartGWT) but no lockable
columns (which Smart does have) - we had to write our own (I've
posted them on the forums)
- It's all java and it's trivial to debug / overrride features
- Good community in the forums
- Bugs get fixed if you are persistent enough

Cons
- Quirky bugs and behaviour changes in each version - need to check
for regression when taking an upgrade.
- Only first point release if available if you don't have a support
contract (even if you buy the product) and there can be a long wait
(for your business / customers) between versions.
- Mostly trivial examples in showcase that aren't like an app you will
build (though to be fair same can be said for most GWT frameworks)
- Not much doco / java doc, which can make complex apps / layouts
difficult to get right - some unexpected behaviours

[ckendrick]

Carl,

On skins, you don't sound as though you've looked at the Showcase
since 2.0, when we made a series of improvements which now has most
users commenting that our skins are sharper than GXTs.

On grids, this is the first time I've ever seen someone claim the GXT
grids are better, I really don't think you took more than a cursory
look at the samples. Here are some of the largest features missing
from GXT's grids (there are many many more):

Adaptive Filtering
http://www.smartclient.com/smartgwt/showcase/#grid_adaptive_filter_featured_category

Databound Dragging
http://www.smartclient.com/smartgwt/showcase/#grid_db_dragging_featured_category

Custom nested components (embed anything)
http://www.smartclient.com/smartgwt/showcase/#featured_nested_grid
http://www.smartclient.com/smartgwt/showcase/#grid_nested_form_new_category

Pluggable data models (build a master-detail component for any data
model)
http://www.smartclient.com/smartgwt/showcase/#featured_master_detail

Frozen columns with editing, drag and drop and all other features
still supported
http://www.smartclient.com/smartgwt/showcase/#grid_frozen_editing

Multi-level sort
http://www.smartclient.com/smartgwt/showcase/#grid_multisort_new_category

Automatic cache synchronization on update
http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/data/ResultSet.html

Multi-level filtering
http://www.smartclient.com/smartgwt/showcase/#grid_nested_filter_builder

Multiple rows of headers
http://www.smartclient.com/smartgwt/showcase/#grid_appearance_header_spans

User-specified formula and summary columns
http://www.smartclient.com/smartgwt/showcase/#grid_appearance_formula_sumamry_builder

Also, once again, these features work *together*. There are many
combinations of GXT features that don't (eg Live Grid and most major
grid features), and if you go with some hack from the forums to enable
one of the missing features, you'll find even less compatibility with
other features (and no support).

Just didn't want anyone to think the grids are even close to
comparable. The features above are all part of the free LGPL edition
by the way.

On Feb 14, 7:00 pm, Carl Pritchett <bogusggem...@gmail.com> wrote:
> We have used GXT from 1.2 to 2.1.1 on a mid-sized project.
>
> Pros

> - I think the look and feel is sharp and responsive (much nicer thatSmartGWTIMHO - but look at the showcases and judge for youself).
> - Grids are the best I've seen (sorrySmartGWT) but no lockable

[ckendrick]

Um, so, it was pointed out to me that I missed some major ones. Even
some I wrote personally :)

Drag Reorder of columns
http://www.smartclient.com/smartgwt/showcase/#grid_appearance_columnorder

The CubeGrid (multi-dimensional data model support)
http://www.smartclient.com/index.jsp#basicCube
http://www.smartclient.com/index.jsp#analytics

A whole range of autoFit behaviors (not just this sample, the whole
folder)
http://www.smartclient.com/smartgwt/showcase/#grid_autofit_filter

Also, the fact that all of these features also apply to TreeGrids (eg
frozen columns and full-row editing).

Also, SmartGWT's data connector architecture and it's ability to
support multiple caches on the same large data set, with independent
search criteria, sort direction, etc. This is needed for dozens of
use cases involving large data sets, such as moving records from one
category to another by drag and drop. GXT's "Store" is extremely
primitive by comparison and a lot of manual effort is required to
achieve something like this:
http://www.smartclient.com/smartgwtee/showcase/#row_drag_save

I have probably missed another 9 major grid features, and this only
covers feature advantages related to grids, however this and my
previous post are probably the best answer to the original question:
what are the technical advantages.

On Feb 15, 12:02 pm, ckendrick <charles.kendr...@gmail.com> wrote:
> Carl,
>
> On skins, you don't sound as though you've looked at the Showcase
> since 2.0, when we made a series of improvements which now has most
> users commenting that our skins are sharper than GXTs.
>
> On grids, this is the first time I've ever seen someone claim the GXT
> grids are better, I really don't think you took more than a cursory
> look at the samples.  Here are some of the largest features missing
> from GXT's grids (there are many many more):
>
> Adaptive Filtering

>    http://www.smartclient.com/smartgwt/showcase/#grid_adaptive_filter_fe...
>
> Databound Dragging
>    http://www.smartclient.com/smartgwt/showcase/#grid_db_dragging_featur...

>
> Custom nested components (embed anything)
>    http://www.smartclient.com/smartgwt/showcase/#featured_nested_grid

>    http://www.smartclient.com/smartgwt/showcase/#grid_nested_form_new_ca...

>
> Pluggable data models (build a master-detail component for any data
> model)
>    http://www.smartclient.com/smartgwt/showcase/#featured_master_detail
>
> Frozen columns with editing, drag and drop and all other features
> still supported
>    http://www.smartclient.com/smartgwt/showcase/#grid_frozen_editing
>
> Multi-level sort

>    http://www.smartclient.com/smartgwt/showcase/#grid_multisort_new_cate...

>
> Automatic cache synchronization on update

>    http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/dat...

>
> Multi-level filtering
>    http://www.smartclient.com/smartgwt/showcase/#grid_nested_filter_builder
>
> Multiple rows of headers

>    http://www.smartclient.com/smartgwt/showcase/#grid_appearance_header_...

>
> User-specified formula and summary columns

>    http://www.smartclient.com/smartgwt/showcase/#grid_appearance_formula...

[mariyan nenchev]

Very nice features... until they get in touch with server side code :) (not talking about ee/pro).

--
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-we...@googlegroups.com.

To unsubscribe from this group, send email to google-web-tool...@googlegroups.com.

[Sanjiv Jivan]

What are you talking about? Care to elaborate instead of writing a one liner with a smiley which makes no sense.

"until they get in touch with server side code :) (not talking about ee/pro)"

Are you having trouble writing server side code?

Sanjiv

[mariyan nenchev]

Personally - yes. It is to much code for basic stuff. Don't understand me wrong, if i look smart gwt only as client side framework, it is very good and rich, but most users(developers) have trouble integrating it with other frameworks, technologies and so on...You see how many users write every day in the smartclient's forum and all have problems with server integration. May be they are not experienced, may be it is unnessesery complicated or may be smart gwt is like that, because smart gwt pro/ee are better. Every thing is just bussines, and so it should be. I am just saying my personal opinion.

Regards.

[Sanjiv Jivan]

mariyan,

The SmartGWT LGPL server side code can be as little or much depending on how the developer codes it. Pro / EE handle the server side persistence so there's minimal code to writ. With LGPL, the SmartGWT datasource protocol simply passes the relevant information for various operations like fetch, update, delete and insert. Thats it! From there on, the developer needs to act on this information to service the operation request. 

A fetch operation for example will pass the startRow, endRow and the applications server side code needs to return data as XML, JSON or GWT-RPC beans in response to this request. Similarly an insert or update operation passes the data of the new record to the server. There's nothing inherent to SmartGWT that requires "more server side" code. Infact its a very simple protocol that imposes no extra overhead or server side requirements whether you're using the Restful DataSource, or the GWT-RPC Datasource.

Have a look at this sample : http://www.smartclient.com/smartgwt/showcase/#featured_restfulds 

Hopefully this clarifies things. If you need some more information, there is plenty of information in the Javadocs and also feel free to post on the SmartGWT forum. 

Sanjiv

[gengstrand]

It looks like we're having a little bit of a flame war going here.

Our current KATO demo ( see http://myjsp.dynamicalsoftware.com/kato )
uses SmartGWT and, though not perfect, the default eye candy does look
nice and we will most probably stay with SmartGWT.

Those who are in Birmingham, AL might consider attending the JUG ( see
http://groups.google.com/group/birmingham-jug ) meeting on the 25th
where I will give a presentation on GWT. In that talk, I will share my
opinions on Incubator, SmartGWT, and GXT.

On Feb 15, 2:02 pm, ckendrick <charles.kendr...@gmail.com> wrote:
> Carl,
>
> On skins, you don't sound as though you've looked at the Showcase
> since 2.0, when we made a series of improvements which now has most
> users commenting that our skins are sharper than GXTs.
>
> On grids, this is the first time I've ever seen someone claim the GXT
> grids are better, I really don't think you took more than a cursory
> look at the samples.  Here are some of the largest features missing
> from GXT's grids (there are many many more):
>
> Adaptive Filtering

>    http://www.smartclient.com/smartgwt/showcase/#grid_adaptive_filter_fe...
>
> Databound Dragging
>    http://www.smartclient.com/smartgwt/showcase/#grid_db_dragging_featur...
>

> Custom nested components (embed anything)
>    http://www.smartclient.com/smartgwt/showcase/#featured_nested_grid

>    http://www.smartclient.com/smartgwt/showcase/#grid_nested_form_new_ca...

>
> Pluggable data models (build a master-detail component for any data
> model)
>    http://www.smartclient.com/smartgwt/showcase/#featured_master_detail
>
> Frozen columns with editing, drag and drop and all other features
> still supported
>    http://www.smartclient.com/smartgwt/showcase/#grid_frozen_editing
>
> Multi-level sort

>    http://www.smartclient.com/smartgwt/showcase/#grid_multisort_new_cate...

>
> Automatic cache synchronization on update

>    http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/dat...

>
> Multi-level filtering
>    http://www.smartclient.com/smartgwt/showcase/#grid_nested_filter_builder
>
> Multiple rows of headers

>    http://www.smartclient.com/smartgwt/showcase/#grid_appearance_header_...

>
> User-specified formula and summary columns

>    http://www.smartclient.com/smartgwt/showcase/#grid_appearance_formula...

[Shawn Brown]

Well I use GXT but like the smartgwt grids better so am looking at
this datasource issue.

It's worrysome:
Thread
http://forums.smartclient.com/showthread.php?t=3012

Bug report asking for RPC datasource
http://code.google.com/p/smartgwt/issues/detail?id=303

I see there is an api but it states:

Smart GWT supports declarative, XPath-based binding of visual
components to any server capable of returning XML or JSON responses
over HTTP, without the need for the 'Smart GWT server'.

> A fetch operation for example will pass the startRow, endRow and the
> applications server side code needs to return data as XML, JSON or GWT-RPC
> beans in response to this request.

> : http://www.smartclient.com/smartgwt/showcase/#featured_restfulds

Are there any examples using GWT-RPC (without the smart server)

Sanjiv what you said and what the docs say seem to be different. Can
we really use GWT-RPC to get a bean back that can be used as a
datasource?

[Sanjiv Jivan]

On Tue, Feb 16, 2010 at 5:08 PM, Shawn Brown <big.coff...@gmail.com> wrote:

Well I use GXT but like the smartgwt grids better so am looking at
this datasource issue.

It's worrysome:
Thread
http://forums.smartclient.com/showthread.php?t=3012

Bug report asking for RPC datasource
http://code.google.com/p/smartgwt/issues/detail?id=303

Shawn,

The thread you point to is really old (2008). Since then, alius, one of the SmartGWT users has come up with a good implementation of GwtRpcDataSource. You can read this rather long thread ( http://forums.smartclient.com/showthread.php?t=4814 ), but all the information you'll need is in there along with the GwtRpcDataSource implementation. 

The GwtRpcDataSource implementation is part of the smartgwt-extensions project : http://code.google.com/p/smartgwt-extensions/

 

I see there is an api but it states:

Smart GWT supports declarative, XPath-based binding of visual
components to any server capable of returning XML or JSON responses
over HTTP, without the need for the 'Smart GWT server'.

Yes, this is true and there are a number of samples of this in the SmartGWT Showcase.

http://www.smartclient.com/smartgwt/showcase/

Go to Data Integration-- > XML, or JSON. You can even use Webservices / WSDL based DataSources.

 

> A fetch operation for example will pass the startRow, endRow and the
> applications server side code needs to return data as XML, JSON or GWT-RPC
> beans in response to this request.

> : http://www.smartclient.com/smartgwt/showcase/#featured_restfulds

Are there any examples using GWT-RPC (without the smart server) 

Sanjiv what you said and what the docs say seem to be different.  Can
we really use GWT-RPC to get a bean back that can be used as a
datasource?

Yes. sunnyl, another experienced SmartGWT has posted a complete standalone project illustrating the use of GwtRpcDataSource here : http://forums.smartclient.com/showthread.php?t=4814&page=22

It's not fair to have these long discussion specific to SmartGWT on the GWT forum. However its hard not to respond posts are made either intended to be flame bait or from users who have not taken time to explore the product features but make false assertions, or statements that are plain wrong.

Shawn, I would encourage you and any other user interested in SmartGWT to post on the SmartGWT forum ( http://forums.smartclient.com/forumdisplay.php?f=14 )  - whether it be a technical question, or about product features and capabilities. There's a lot of SmartGWT introduction and related material even on my blog : http://www.jroller.com/sjivan/

Thanks,

Sanjiv