Explore topic-wise InterviewSolutions in .

This handler sends log messages to the server, where they will be logged using the server side logging mechanism.

FirebugLogHandler logs to Firebug console.

ConsoleLogHandler logs to the javascript console, which is used by Firebug Lite (for IE), Safari and Chrome.

DevelopmentModeLogHandler logs by calling method GWT.log. These messages can only be seen in Development Mode in the DevMode window.

SystemLogHandler logs to stdout and these messages can only be seen in Development Mode in the DevMode window.

The logging framework emulates java.util.logging, so it uses the same syntax and has the same behavior as server side logging code.

GWT logging is configured using .gwt.xml files.

We can configure logging to be enabled/disabled; we can enable/disable particular handlers, and change the default logging level.

In order to use GWT History support, we must first embed following iframe into our host HTML page.

<iframe src="javascript:''" id="__gwt_historyFrame" style="width:0;height:0;border:0"></iframe>

extend-property tag with attribute name set as locale and values as language specific locale, say de for german locale.

This technique is the most powerful among the three techniques. Implementing Localizable allows us to create localized versions of custom types. It's an advanced internationalization technique.

This technique is very flexible but slower than static string internationalization. Host page contains the localized strings therefore, applications are not required to be recompiled when we add a new locale. If GWT application is to be integrated with an existing server-side localization system, then this technique is to be used.

This technique is most prevalent and requires very little overhead at runtime; is a very efficient technique for translating both constant and parameterized strings;simplest to implement. Static string internationalization uses standard Java properties files to store translated strings and parameterized messages, and strongly-typed Java interfaces are created to retrieve their values.

GWT provides three ways to internationalize a GWT application −

• Static String Internationalization.

• Dynamic String Internationalization.

• Localizable Interface.

A java data object should implement isSerializable interface so that it can be transferred over the wire in GWT RPC.

Following are the three components used in GWT RPC communication mechanism −

• A remote service (server-side servlet) that runs on the server.

• Client code to invoke that service.

• Java data objects which will be passed between client and server.

• GWT client and server both serialize and deserialize data automatically so developers are not required to serialize/deserialize objects and data objects can travel over HTTP.

• RPC, Remote Procedure Call is the mechansim used by GWT in which client code can directly executes the server side methods.

• GWT RPC is servlet based.

• GWT RPC is asynchronous and client is never blocked during communication.

• Using GWT RPC Java objects can be sent directly between the client and the server (which are automatically serialized by the GWT framework).

• Server-side servlet is termed as service.

• Remote procedure call that is calling methods of server side servlets from client side code is referred to as invoking a service.

• The UiBinder is a framework designed to separate Functionality and View of User Interface.

• The UiBinder framework allows developers to build gwt applications as HTML pages with GWT widgets configured throughout them.

• The UiBinder framework makes easier collaboration with UI designers who are more comfortable with XML, HTML and CSS than Java source code.

• The UIBinder provides a declarative way of defining User Interface.

• The UIBinder seperates the programmic logic from UI.

• The UIBinder is similar to what JSP is to Servlets.

GWT provides three ways to create custom user interface elements. There are three general strategies to follow −

• Create a widget by extending Composite Class − This is the most common and easiest way to create custom widgets. Here you can use existing widgets to create composite view with custom properties.

• Create a widget using GWT DOM API in JAVA − GWT basic widgets are created in this way. Still its a very complicated way to create custom widget and should be used cautiously.

• Use JavaScript and wrap it in a widget using JSNI − This should generally only be done as a last resort. Considering the cross-browser implications of the native methods, it becomes very complicated and also becomes more difficult to debug.

GWT provides a event handler model similar to Java AWT or SWING User Interface frameworks.

A listener interface defines one or more methods that the widget calls to announce an event. GWT provides a list of interfaces corresponding to various possible events.

A class wishing to receive events of a particular type implements the associated handler interface and then passes a reference to itself to the widget to subscribe to a set of events.

For example, the Button class publishes click events so you will have to write a class to implement ClickHandler to handle click event.

All GWT event handlers have been extended from EventHandler interface and each handler has only a single method with a single argument. This argument is always an object of associated event type. Each event object have a number of methods to manipulate the passed event object.

This widget represents a form of popup that has a caption area at the top and can be dragged by the user. Unlike a PopupPanel, calls to PopupPanel.setWidth(String) and PopupPanel.setHeight(String) will set the width and height of the dialog box itself, even if a widget has not been added as yet.

This widget represents a panel that can pop up over other widgets. It overlays the browser's client area (and any previously-created popups).

This widget represents a panel that wraps its contents in an HTML <FORM> element.

FocusPanel widget represents a simple panel that makes its contents focusable, and adds the ability to catch mouse and keyboard events.

ScrollPanel widget represents a simple panel that wraps its contents in a scrollable area.

SimplePanel is the base class for panels that contain only one widget.

This widget represents a type of widget that can wrap another widget, hiding the wrapped widget's methods. When added to a panel, a composite behaves exactly as if the widget it wraps had been added.

This widget represents a panel that represents a tabbed set of pages, each of which contains another widget. Its child widgets are shown as the user selects the various tabs associated with them. The tabs can contain arbitrary HTML.

This widget represents a panel that contains HTML, and which can attach child widgets to identified elements within that HTML.

This widget represents a panel that lays its child widgets out "docked" at its outer edges, and allows its last widget to take up the remaining space in its center.

DeckPanel is a panel that displays all of its child widgets in a 'deck', where only one can be visible at a time. It is used by TabPanel.

Grid widget represents a rectangular grid that can contain text, html, or a child Widget within its cells. It must be resized explicitly to the desired number of rows and columns.

FlexTable widget represents a flexible table that creates cells on demand. It can be jagged (that is, each row can contain a different number of cells) and individual cells can be set to span multiple rows or columns.

VerticalSplitPanel widget represents a A panel that arranges two widgets in a single vertical column and allows the user to interactively change the proportion of the height dedicated to each of the two widgets. Widgets contained within a VertialSplitPanel will be automatically decorated with scrollbars when necessary.

HorizontalSplitPanel widget represents a panel that arranges two widgets in a single horizontal row and allows the user to interactively change the proportion of the width dedicated to each of the two widgets. Widgets contained within a HorizontalSplitPanel will be automatically decorated with scrollbars when necessary.

VerticalPanel widget represents a panel that lays all of its widgets out in a single vertical column.

HorizontalPanel widget represents a panel that lays all of its widgets out in a single horizontal column.

FlowPanel widget represents a panel that formats its child widgets using the default HTML layout behavior.

Panel is the abstract base class for all panels, which are widgets that can contain other widgets.

Layout Panels can contain other widgets. These panels controls the way widgets to be shown on User Interface. Every Panel widget inherits properties from Panel class which in turn inherits properties from Widget class and which in turn inherits properties from UIObject class.

CellBrowser widget represents a browsable view of a tree in which only a single node per level may be open at one time. This widget will only work in standards mode, which requires that the HTML page in which it is run have an explicit <!DOCTYPE> declaration.

CellTable widget represents a tabular view that supports paging and columns.

CellList widget represents a single column list of cells.

CellTree widget represents a view of a tree. This widget will only work in standards mode, which requires that the HTML page in which it is run have an explicit <!DOCTYPE> declaration.

DatePicker widget represents a standard GWT date picker.

MenuBar widget represents a standard menu bar widget. A menu bar can contain any number of menu items, each of which can either fire a Command or open a cascaded menu bar.

Tree widget represents a standard hierarchical tree widget. The tree contains a hierarchy of TreeItems that the user can open, close, and select.

Hidden widget represets a hidden field in an HTML form.

FileUpload widget wraps the HTML <input type='file'> element.

RichTextArea widget represents a rich text editor that allows complex styling and formatting.

TextArea widget represents a text box that allows multiple lines of text to be entered.

PasswordTextBox widget represents a text box that visually masks its input to prevent eavesdropping.