Group items matching

in title, tags, annotations or url

Compile the top level module

conflict with each other during event handling

Linkers are divided into three categories, PRE, POST, and PRIMARY

one primary linker is run for a compilation

everal linkers are provided by Core.gwt.xml, which is automatically inherited by User.gwt.xml.

monolithic JavaScript file.

cross-site deployment model.

standard iframe-based

<add-linker name="xs" />

The GWT compiler

packaging its output with the Linker subsystem

re-use an existing Java API for a GWT project,

"re-root" a source path

tells the compiler to add all subfolders of com/example/myproject/jre/

to the source path

com/google/myproject/gwt/jre/java/util/UUID.java

most commonly used elements in the module XML file.

herits all the settings from the specified module

Entry points are all compiled into a single codebase

Any number of entry-point classes can be added

resources get copied into the output directory during a GWT compile.

client subpackage is implicitly added to the source path

treated as a publicly-accessible resource.

resources get copied into the output directory

the public subpackage is implicitly added to the public

For RPC, this element loads a servlet class

mounted at the specified URL path

path=

class="

URL path should be absolute

you must configure a WEB-INF/web.xml in your war directory to load any servlets needed.

n development mode,

external JavaScrip

Extends the set of values

for an existing client property

three different types of predicates are

<all>

<any>

<none>

you want to inherit at least the User module

contains all the core GWT functionality

including the EntryPoint class

widgets and panels

History feature

Internationalization

DOM programming, and more

Low-level HTTP

Use the following syntax to cause an external JavaScript file to be loaded

as if you had included it explicitly using the HTML <script

loaded before your onModuleLoad() is called.

associate external CSS files with your module

GWT.getModuleBaseURL() + "foo.css" in client code

module's public path

useful when

inheritance makes resource inclusion particularly convenient.

see the documentation for FileSet for a general overview

includes

excludes

defaultexcludes

casesensitive

By default, the patterns listed here are excluded.

<script src='myApp/myApp.nocache.js'></script>

two simultaneous connections

GWT selection script

like a normal script tag

Parsing is blocked until externalScriptZero.js is done fetching and evaluating.

myApp/myApp.nocache.js completes

the compiled scrip

begins fetching in a hidden IFRAME (this is non-blocking).

onModuleLoad() is not called yet, as we're still waiting on externalScriptOne.js

body.onload() fires

onload='alert("w00t!")

because it won't block any other script requests

<img> tags are not guaranteed to be done loading when onModuleLoad() is called

<script> tags are guaranteed to be done loading when onModuleLoad() is called

will all be called in sequence as soon as that module (and the outer document) is ready

each module's EntryPoint will be called as soon as both that module and the outer document is ready

in which their selection scripts were specified in the host page

@UiField have default visibility

UIObject

DivElement

If your factory method needs arguments, those will be required as attributes.

you can define a @UiFactory method on the UiBinder's owner

annotate a constructor of CricketScores with @UiConstructor.

public interface Display

methods can be called to fill in attribute values

onAddButtonClicked

eventBus.fireEvent(new AddContactEvent());

presenter needs to know more about the view

view needs to know more about the data model

houses the any type-specific code (this is the third party mentioned above)

ColumnDefinition

we can reuse its logic regardless of what view we've attached ourself to

update our views such that we can set their ColumnDefinition(s).

setColumnDefinitions

this.columnDefinitions = columnDefinitions;

so that we can pass in

a mocked ContactsView instance when testing our ContactsPresenter

in our AppController, when we create the ContactsView,

new ContactsViewColumnDefinitions().getColumnDefinitions();

we can initialize it with the necessary ColumnDefinition(s).

contactsView.setColumnDefiniions(

As mentioned above we were previously dumbing down the model into a list of Strings

List<String> data

display.setData(data);

how that data type is rendered.

knowledge of a cell's data type

stringing together a list of these classes

providing the necessary render()

and isClickable()/isSelectable() override

columnDefinitions =      new ArrayList<ColumnDefinition<ContactDetails>>()

ColumnDefinition<T> columnDefinition = columnDefinitions.get(j);

that we would otherwise need to test. And the fun doesn't stop there.

presenter.onItemClicked(

presenter.onItemSelected

ClickEvent

cell.getCellIndex()

columnDefinition.isClickable()

SelectEvent

columnDefinition.isSelectable()

return shouldFireClickEvent;

return shouldFireSelectEvent;

respond to user interaction in different ways based upon the cell type that was clicked

we're going to remove any application state from the ContactsView

replace the view's getSelectedRows() with a SelectionModel

ContactsPresenter holds on to an instance of this class

onItemSelected

Reduce the event overhead by sinking events on the HTML widget

update our ContactsView.ui.xml file to use a

HTML widget rather than a FlexTable widget.

for each item ask our column definitions to render accordingly

This will decrease your load time, especially as your tables start to grow.

we're reducing the overhead of sinking events on per-cell widgets

ClickEvents are still wired up via our UiHandler annotations

we can determine the row

to take as a parameter a TableCellElement rather than a HTMLTable.Cell.

faster startup times via Code Splitting.

split portion of your code is purely segmented

not referenced by other parts of the app

it will be downloaded and executed at the point that it needs to run

Do we really want to download all of that code before the user even logs in?

Not really.

wrap the code that creates the ContactsView and ContactsPresenter in a runAsync() call

as optimizations such as this one become easier and easier to implement.

serialVersionUID = 2L;

static final

Exception in thread "main" java.io.InvalidClassException:

As you can see, this time the deserialization didn’t go well. ObjectInputStream complained about the serialVersionUID being changed.

How does he know that it changed? If serialVersinUID is static, then it should not have been serialized in the first place, and there should be no information about the previous value 1 during the deserialization, right? Well, serialVersionUID is an exception to the rule that “static fields don’t get serialized”.

Moreover, if there is no serialVersionUID officially declared in the class to be serialized, compiler automatically adds it with a value generated based on the fields declared in the class.