is there a difference between Ext GWT and GWT-Ext? Cos i was surfing Ext GWT and saw this page http://gwt-ext.com/demo/. any help guys?
ExtGWT is marketed and maintained by the same guys who developed ExtJs library. ExtGWT shares its look and feel and API structure with ExtJS. Contrary to popular perception, ExtGWT is not a wrapper around ExtJS javascript, but written ground up using GWT DOM and other low level GWT API's. It is 99% java based and uses no (or very little) JSNI to get things done. It also supports data binding. This library is actively supported and also has a paid commercial version.
On the other hand GWT Ext was developed by Sanjeev Jeevan as a wrapper around LGPL version (no support now) of ExtJS. So the library is a very shallow wrapper around ExtJS javascript and uses JSNI extensively. This can create problems, particularly if you need to debug the library. GWT Ext does not enjoy the same level of community support as ExtGWT and also the original author has long since moved on to a different project. Read about the reasons here.
If you have to choose between the two, and plain old GWT is not an option, choose ExtGWT. Keep in mind that it is GNU GPL licensed.
Neither. You'll have nothing, but problems with third-party GWT widget libraries. I've wasted four years on significantly more refined and mature SmartGWT and finally gave up.
Styling standard GWT components that wrap native browser controls is easy. You should strive for native portable control set and you'll rarely need anything more for a modern minimalistic mobile-friendly UX. However if you still crave some third-party widgets, look at GWT-Bootstrap3: https://github.com/gwtbootstrap3/gwtbootstrap3
Related
I am on searching special features of GWT which are present only in GWT and not in other web framework. I am a student and I am not well acquainted to the many web frameworks on the market, so if u can help me increasing my list of special GWT features, it would be a great help. Some which i know are:
1. GWT allows using java to program
web. (only, it also allows merging
javascript through JSNI of course)
2. The developer does not have to be a guru in browser incompatibilities
to develop web sites which works on
a variety of browsers because
incompatibilities are handled by GWT
through differed bindind
3. GWT allows easy integration of popular Java Tools such as ,
hibernate through gilead
4. GWT enables server implementation not only in java but also other
languages such as php
5. GWT enables code splitting which improves application interactivity
by allowing javaScript file to
download only when required
6. In essence GWT is toolkit, it does not force a way to program,
other layers can be placed on top of
it to program such as placing MVP or
MVC framework on top of GWT and then
develop app
7. GWT MVP is great because first it allows collaborative working, faster
testing with JUnit and the event bus
allows many updates in client side
application by placing event on the
event bus
8. GWT compiled java files to obfuscated mode which is first small
and make the application safer
because bots fails on the javascript
generated during the obfuscated mode
In case in the 8 points, i've mention something which not special to GWT, then let me know.
There's also 'perfect caching', which is the term used to describe the way that GWT optimises JavaScript for each browser.
Instead of building a large JavaScript file, with code that can handle all of the various browsers, GWT builds multiple JavaScript files at compile time, and downloads only the one that is relevant to the browser type that is being used.
EDIT: Every time you make a change to your Java code, GWT changes the name of the corresponding JavaScript file. Web servers can turn on caching for the JavaScript files (so that browsers won't re-download the same file), assured that the name will change when the Java code changes, and the browser will then download the latest version.
EDIT: I also really like the CssResource feature. By creating obfuscated CSS style names, GWT effectively gives each widget its own namespace for CSS styles; for example, I could define a 'pretty' style name on two different widgets, and have those styles using different CSS rules. Of course, it is possible to share CSS styles between widgets too.
Image resources are cool too. They optimise the way that images are downloaded and accessed.
Don't forget internationalization.
I think you pulled together a pretty decent list of differentiators there already. I think that one point worth adding is the RequestFactory feature in the most recent release, which, if you will, is simplistically speaking and RPC for data and makes it quite easy to develop Create, Read, Update and Delete - type (CRUD) of applications.
There are other, more important/wider accepted GUI-Frameworks that are based on Java.
There are for example Struts and JSF. That's why some of your points don't fit only for GWT, but for all GUI java frameworks in general, e.g. bullet point 1, 2 & 3.
But to add another one:
I think GWT is an easy way to code an AJAX-application, because it hides the AJAX stuff quite well. Wouldn't you agree?
Furthermore, GWT is a proprietary framework (which is somehow a unique property). JSF is standardized and Struts is lead by Apache.
I have my first GWT project that I created using UiBinder (GWT 2.0 way) which I found to be easier than write my UI creation Java source code (GWT 1.0 way).
But I saw this thing called GWT Designer that Google are releasing for free. It has nice features and wizards which were missing with the standard Google Eclipse Plugin. I like it, but I still think that using UiBinder is better. I think GWT Designer will be really useful when it can help you write UiBinder XML files (GWT 2.0 way), and not just source code (GWT 1.0 way).
What do you think about it?
Do I need to migrate to GWT Designer project?
Will it be better if I migrate but still keep UiBinder UI creation?
The latest GWT Designer now has support for UiBinder, and it works great.
http://download.instantiations.com/D2GWTDoc/continuous/latest/docs/html/wizards/gwt/uibinder_composite.html
UiBinder can give you better performance and a better optimized download than traditional widget construction; to me that's enough of a reason to stick with UiBinder. If your app is light and fast enough as it is then the choice probably comes down to what style of development suits you best.
I wouldn't go as far as to port your existing UiBinder templates into the designer. Google will be adding support for them to GWT designer soon enough.
I haven't used the newly-freed GWT Designer yet myself, but I wouldn't expect that it would warrant migrating your entire project over to it if it's already written using UIBinder.
Remember that the two methods of constructing a UI are not mutually exclusive -- you can use the GWT Designer to create a new widget and use it in an existing UIBinder project, and if you decide it's that much better, you can consider migrating at that point. Or not, since they can still happily coexist.
If you are doing professional development in an organization that utilizes experts in CSS and html, then GWt is going to be a tough sell if you don't use something like UIBinder for layouting as well as individual pages. I also think that a CSS designer can do a better job at responding to UI requirement changes than a java developer using GWT layouting techniques.
However if your java staff has control of the requirements and don't have to answer to UI designers, then I suppose choosing between delcarative templates and something like GWT Designer is just a matter preference.
As said in the relaunch announcement:
Now that these products are available again, we hope you’ll start using them within your GWT projects. Meanwhile, our next step is to more deeply unify them into the GWT family of tools by blending the fantastic Instantiations technology into the Google Plugin for Eclipse (GPE). So, there’s much more to come, including things we’re pretty sure you’ll like, such as UiBinder support in GWT Designer.
It wouldn't make sense to get ride of your UiBinder code since GWT Designer will support it soon.
DON'T use the designer plugin. The most recent update (8.1.1 at the time of this post) contains buttons that allow the user to add elements that are incompatible with IE, for instance CellTable, DeckPanel, HorizontalPanel and VerticalPanel.
This means whoever uses the plugin, uses it entirely at their peril. If IE7 tries to pull in these elements, it will load a partial page but fail to load components that use these elements. IE8 may not be able to load the application at all.
Are there any good themes or component libraries for GWT? The built-in themes are rather plain for my purposes. I've seen gwt-ext and smartgwt, but those aren't that great looking. Are there any others that have a real nice look? I know of vaadin an I really really like the look, but from what I understand that just an entirely new framework.
The first thing to be careful of is that there are two frameworks which use EXT and GWT:
GWT-Ext
Ext GWT
Both are based on the Ext JS component library.
Gwt-Ext is based on an old version of Ext JS when it was still LGPL but is no longer developed.
Ext GWT is from the same company who are still developing Ext JS. It's still being developed and is available under free and commercial licenses, and of the two is the one I would use.
SmartGWT is an alternative (and is what the GWT-Ext people are moving to). A colleague of mine looked at it and did not like it as much as Ext GWT as it's a fairly thin wrapper around the SmartClient JavaScript whereas Ext GWT has quite a lot of Java code. The difference being that if you run an Ext GWT application in Hosted Mode and attach your debugger you can see what Ext GWT is doing, but with SmartGWT you'll just see lots of IDispatch calls where it disappears into native JavaScript where your debugger won't be able to follow.
There are some themes developed for EXT GWT that can be found at:
Olive Theme: http://extjs.com/forum/showthread.php?t=15505
Dark Grey Theme: http://extjs.com/forum/showthread.php?t=15341
Purple Theme: http://extjs.com/forum/showthread.php?t=15377
Black Theme: http://extjs.com/forum/showthread.php?t=15504
In order to use these themes you will also need to use the EXT GWT widgets instead of the ones supplied with the GWT library.
I am also currently evaluating ExtGWT: at least with the new 2.0 release, that just came out today, it is not relying on the ExtJS library but is almost completely written in GWT, which is a nice thing. Exceptions are the chart widgets, wrapping the open flash charts library, that rely on additional javascript (plus flash obviously).
Try Extjs GWT basically is the same framework of ext-gwt but in another approach.
Searching in google in found another:
http://gwt.components.googlepages.com/
http://advanced-gwt.sourceforge.net/
http://www.gwtsite.com/top-5-gwt-libraries/
For me Extjs GWT is the best you can find, and is developed by an foundation, this means you have support.
I need recommendations from people whom have implemented an easy to use GWT editable datagrid.
I spent 4 hours with the PagingScrollTable in the gwt-incubator-july-14-2009.jar, and would now like to try other options.
What I'm looking for:
easy to get started (ex. drop a jar, edit .gwt.xml)
advanced features once you have gotten started
documentation of advanced features
self-contained module with minimal dependencies on other modules, jars or components
low cost/free
Thats all :)
Please, for goodness' sake, stick with vanilla GWT. Just use GWT data cell tables, lists and trees.
Smart-GWT and GXT really look good in their demo. e.g., Smart-GWT has widgets that accepts xml/json datasource directly that would save you time.
But, you find that your application requirements would "just need that tiny tweak" in the way the widget eats the datasource. Both GXT and Smart-GWT have attractive convenient widgets, but you find you need "just a little" tweak to make them suit your requirement.
Is your "little" tweak "important" enough? So, you resort to writing your patch for that "little" tweak. And soon you find that there is a whole entrail of "little" tweaks. You experiment and research and try untried means.
Finally, you discover that you might just as well had used vanilla GWT for which you would have taken less time to get the behaviour you want. Vanilla GWT is tried and proven.
Do not be tempted by the showcases of SmartGWT or GXT. Learn CSS and learn how to integrate CSS into vanilla GWT, which would make your widgets just as attractive as SmartGWT or GXT.
Then you would not regret because you would not face any impediments toward using other GWT features.
What is good enough for Google is good enough for me.
Hi HJO there are many solutions to problem depends on what you want. The GWT-EXT, EXT-GWt and SmartGWT libraries all have editable data grid implemented. Or you can make your own with FlexTable,ScrollPanel,TextBox and add a few event handlers. Both GWT-EXT and SmartGWT are in LGPL license and I believe EXT-GWT is GPL license. If you not doing it for production then any will do, but if you are doing it for big production environment I suggest to really test each of their performance first. I suggest to choose something light weight and robust instead of simplicity or appearance on production environments. At the end, the less data/widget loaded + less handlers = performance and happy user.
Take care,
NingZhang.info
I do not recommend to use GWT DataGrid for production (in GWT 2.4), unless you like coding workarounds for several bugs (most of them on Internet Explorer):
http://code.google.com/p/google-web-toolkit/issues/detail?id=7065
http://code.google.com/p/google-web-toolkit/issues/detail?id=7347
http://code.google.com/p/google-web-toolkit/issues/detail?id=7139
http://code.google.com/p/google-web-toolkit/issues/detail?id=6747
I use CellTable instead of DataGrid and wait for bugfixing from GWT team.
do you know where to download GWT components and widgets?
thanks.
by the way, where do i need to put the GWT components & widgets in my project?
Here's just a few places:
http://gwt-widget.sourceforge.net/
http://code.google.com/p/gwt-ext/
In terms of where you put them, you just generally add the jar file to the classpath of your build process, and the put an inherits line in whatever .gwt.xml file you want to use them in, for example for the widget library:
<inherits name="org.gwtwidgets.WidgetLibrary" />
After a review of GWT widgets, we are focusing on
SmartGWT
Ext-GWT
with Ext-GWT looking like the final candidate.
I looked at mainly three GWT component libraries:
GWT-Ext : http://gwt-ext.com/
Ext-GWT : http://extjs.com/
SmartGWT : http://code.google.com/p/smartgwt/ (google code page with links)
In terms of widgets these libraries seem to be quite similar, but of course the underlying API is different. All three of these libraries are based on existing JavaScript component libraries: Ext JS for GWT-Ext and Ext-GWT, and SmartClient for SmartGWT. Hence, I think you can say that these libraries are GWT wrappers around existing JavaScript libraries.
For me the main factor for making a choice for one of these libraries is not the underlying technology but their licensing model. GWT-Ext seems to be a solid and popular component library, however it has a lock-in on Ext JS 2.0.2 which was the last version of Ext JS under LGPL. Newer versions of the Ext JS library are either available under GPL or a commercial license. Ext-GWT comes from the developer of Ext JS and follows the same dual licensing option. SmartGWT is available under both LGPL and a commercial license. If you do not mind a commercial license then Ext-GWT and SmartGWT may both the viable alternatives in terms of licensing. Otherwise SmartGWT using LGPL seems more attractive to me.
In terms of available widgets GWT-Ext is/was ahead of SmartGWT, but SmartGWT seems to be catching up fast. In terms of coding I prefer SmartGWT. I have no experience with Ext-GWT so I cannot tell.