Tuesday, January 13, 2009

Infinite Undiscovery Signature Series Guide or GWT in Action

Infinite Undiscovery Signature Series Guide

Author: Brady Games Staff

Break the Chains that Enslave the World!


The Order of Chains, led by the Dreadknight, has locked the moon in place with massive chains to leech its power. The ominous power of these chains has spawned deadly creatures that blight the land. Crops fail, trees wither, and humanity cries out for salvation. Who will heal the land?


 


Complete Walkthrough


Use our strategies to complete every mission. Detailed area maps illustrate important characters, mission objectives, and treasure chests.


 


Full Bestiary


Learn the strengths and weaknesses of every enemy type and discover tips and tactics to get the best loot drops.


 


Item List and Crafting Guide


Complete statistics and effects for every weapon, armor piece, accessory, and item in the game. Study our exhaustive lists to craft rare and powerful equipment.


 


Battle Skills, Side Quests, and More!


 


2-Sided Foldout Poster


 


Platform: Xbox 360

Genre: Role-Playing Game



Read also Konjunkturforschungsmethoden mit der DVD

GWT in Action: Easy Ajax with the Google Web Toolkit

Author: Robert Hanson

The Web is experiencing a new growth with an emphasis on rich, web-based applications. These applications can be difficult to build because they rely on JavaScript, which lacks the sophisticated object-oriented structures and static typing of Java, they are tricky to debug, and they require you to manage numerous browser inconsistencies.

In May of 2006 Google released the Google Web Toolkit. GWT enables developers to create Ajax applications in Java. With GWT, you can build your applications using a real object-oriented language and take advantage of Java tools like Eclipse that are already available. Instead of trying to bring tool support to Ajax, Google brought Ajax to a place where the tools already existed.

GWT in Action shows you how to take advantage of these exciting new tools. This clearly-written book is packed with hands-on GWT examples. You'll absorb the GWT philosophy as you build your first working GWT application.

The book begins by exploring the main features of GWT, including
-Compiling Java to JavaScript, the magic that really defines GWT
-Building client-side components
-Convenient JUnit integration and testing
-Interacting with JavaScript and existing JavaScript libraries
-Internationalization

You'll also see how GWT compares to other toolkits.
GWT in Action shows you how to set up your development environment, use and create widgets, communicate with the server, and much more. Readers will follow an example running throughout the book and quickly master the basics of GWT: widgets, panels, and event handling. The book covers the full development cycle, from setting up your development environment, to building the application, then deploying it to the web server. The entire core GWT library is discussed, with details and examples on how it can be extended.

You'll cover:
-Testing, debugging, and deploying GWT Applications
-Communicating with GWT-RPC
-Examining client-side RPC architecture
-Alternative RPC tools: HTTPRequest, RequestBuilder, and FormPanel
-Achieving interoperability in GWT with JavaScript Object Notation (JSON)
-Making your GWT application flexible and supportable

GWT helps you make the most of Ajax in your web applications and GWT in Action helps you get more out of GWT.



Table of Contents:
Preface     xix
Acknowledgments     xxi
About this book     xxiii
About the title     xxx
About the cover illustration     xxxi
Getting started     1
Introducing GWT     3
A walk through GWT     5
Explaining GWT's Java-to-JavaScript compiler     6
Using JSNI to execute JavaScript from Java     8
Accessing the JRE emulation library     10
Understanding GWT's widget and panel library     12
Examining GWT's internationalization and configuration tools     14
Calling remote procedures with GWT     16
Investigating GWT's XML parser     20
Managing the browser history     21
Introducing GWT's JUnit integration     22
GWT vs. other solutions     23
GWT vs. Swing     25
GWT vs. Echo2     26
GWT vs. JavaServer Faces     27
GWT vs. Ruby on Rails     29
Building your first GWT application     30
Building and running an example application     30
Building Tic-Tac-Toe with GWT     32
Summary     37
Creating the default application     38
The GWT applicationdevelopment lifecycle     39
Stage 1: Creating a GWT application     44
Creating the project     47
Creating an application     50
Setting up internationalization     54
Implementing internationalization     56
Creating unit test cases     57
Importing into your IDE     59
Summary     63
Advancing to your own application     64
Describing the application example     65
Stage 2: Developing your application     67
Implementing internationalization     68
Constructing the application     72
Applying styling     83
Stage 3: Testing and debugging in hosted mode     86
Preparing for hosted mode     86
Running the Dashboard in hosted mode     90
Debugging the Dashboard in hosted mode through Eclipse     92
Stage 4: Compiling the code     94
Compiling the code/preparing for web mode     95
Viewing the compilation results     97
Stage 5: Deploying the code     98
Deploying to a web server     98
Deploying to a filesystem     99
Stage 6: Running in web mode     99
Implementing application logging     100
Logging information on the client-side     100
Logging information on the server-side     103
Summary     104
Building user interfaces     107
Working with widgets     109
What is a widget?     111
Using widgets as Java objects     112
Considering widgets as DOM elements     113
The standard GWT widgets     115
Interacting with the basic widgets     118
Displaying text on the application     131
Grabbing the user's interaction using focus widgets     133
Getting user input through text input     139
Creating new widgets     141
Creating new widgets by manipulating the DOM     142
Creating new widgets by extending existing widgets     146
Developing the Dashboard's ToggleMenuItem widget     150
Building the TwoComponentMenuItem     151
Building the ToggleMenuItem     154
Summary     155
Working with panels     157
What is a panel?     158
Using panels as Java Objects     159
Considering panels as DOM elements     160
The standard GWT panels     162
Interacting with simple panels     164
Considering more complex panels     170
Considering HTML table-based panels     178
Considering composite panels     181
Splitting panels     182
Creating new panels     182
Creating a new panel from scratch     183
Creating a new panel by extending an existing panel     186
Creating the Dashboard panel     187
Summary     191
Handling events     192
Exploring events     193
Identifying event model browser differences     195
Understanding the GWT event model     196
Listening to events     200
Sinking events     200
Managing sunk events with the onBrowserEvent() method     203
Linking sunk events to the onBrowserEvent() method     207
Previewing events     208
Handling events by extending the listener classes     211
Moving events further into your GWT code     212
Preventing default browser event handling     216
Handling standard browser events     216
Reacting to change     218
Clicking around     221
Gaining/Losing focus     222
Capturing keyboard inputs     223
Loading images     223
Managing mouse inputs     224
Scrolling     224
Window resize events     226
Window close events     227
Handling other event types     231
Handling forms     231
Reacting to closing pop-ups     231
Tab events     232
Tabling events     234
Tree events     235
Implementing drag-and-drop     236
Implementing the drag part     236
Implementing the drop part     241
Summary     244
Creating composite widgets     246
What is a composite widget?     247
Composite widget development steps     248
Building the editable label     250
Identifying the components     251
Choosing the panel layout and structure     253
Implementing the right GWT Java interfaces     255
Building the composite widget     258
Styling the composite widget     267
Creating a composite widget from other composite widgets     269
Creating a slider     270
Constructing the ColourPicker composite     273
Creating the Dashboard composite     274
Summary     276
Building JSNI components     277
Introducing JavaScript Native Interface (JSNI)     279
Understanding JSNI     281
Communicating using JSNI     290
Chatting to the browser via GWT Java     291
Chatting to the browser via JavaScript     292
Talking to a GWT application via a JavaScript API     294
Talking between GWT applications     296
Loading a JavaScript library     299
Using HTML to load a JavaScript library     299
Using the module XML to load a JavaScript library     299
Wrapping a simple JavaScript library     300
Accessing the loaded JavaScript library     302
Using the widget in an application     307
Wrapping a complex JavaScript library     309
Generating the classes     309
Keeping JavaScript objects as Java objects     310
Calling user-defined code from a library     312
Using a complex wrapped widget in an application     314
Summary     315
Modularizing an application     317
Creating a modularization structure     318
Modularization in GWT     319
Including other modules in an application     321
Setting source and other resource paths     325
Defining an application's server resources     326
Managing an application's GWT properties     327
Replacing classes based on property values     332
Registering generators in the XML module file     333
Injecting resources into an application at runtime     334
Setting an application's entry point     337
The Dashboard's module XML file     337
Including third-party modules     339
Packaging your own modules     341
Creating the Java package structure     343
Summary     344
Advanced techniques     345
Communicating with GWT-RPC     347
Underlying RFC concepts     348
Understanding asynchronous communication     350
Restrictions for communicating with remote servers     351
Creating the Server Status project     353
Implementing GWT-RPC     356
Understanding serializable data objects     356
Defining the GWT-RPC service     360
Preparing the client side of a GWT-RPC call     366
Calling the remote server service     368
Project summary      370
Project overview     370
Server-side service implementation     371
Calling the service from the client     372
Summary     374
Examining client-side RPC architecture     375
Structuring the client code     376
Encapsulating the Server Status component     376
Encapsulating remote calls in a facade     382
Callback routine using the Command pattern     384
Examining different polling techniques     392
Understanding polling issues     392
Implementing a continuously updating component     393
Emulating server-push by blocking server threads     398
Writing custom field serializers     402
Creating a custom field serializer class     403
Implementing custom field serialization     404
Summary     407
Classic Ajax and HTML forms     409
Classic Ajax with RequestBuilder     410
Examining HTTP methods     411
Simple RPC with RequestBuilder     414
Using RequestBuilder to load XML data     417
Examining FormPanel basics     424
Introducing the FormPanel     425
Listening to FormPanel events      428
Altering the FormPanel target     429
Using the various form controls     432
Summary     439
Achieving interoperability with JSON     442
Introducing JavaScript Object Notation (JSON)     443
Understanding the JSON data format     443
Using JSONParser to parse JSON messages     445
Examining GWT's JSON data objects     445
Introducing the JSONValue object     445
Examining basic JSON types     446
Storing JSONValue objects in a JSONArray     448
Collecting JSONValue objects in a JSONObject     449
Creating a search component using JSON     450
Examining the Yahoo Search API     451
Implementing the Yahoo search component     453
Sending JSON data to the server     455
Parsing and validating a JSON server response     457
Implementing a Yahoo Search proxy service     461
Using JSON with Java on the server     461
Using JSON with Perl on the server     465
Using JSON with Ruby on the server     467
Summary     469
Automatically generating new code     471
Generating new types     472
Investigating GWT generators      473
Basic generator code     476
Creating a generator for the Dashboard     477
Accessing the input class     478
Accessing properties of the context     479
Adding logging to a generator     480
Generating the new type structure     482
Creating the new class     484
Using the classes that have been generated     491
Summary     492
Changing applications based on GWT properties     494
Quick summary of properties     495
Managing browser differences     496
How GWT manages browser differences     497
Building the Flash widget     498
Setting up the property replacement     501
Supporting internationalization in full     502
Using static-string internationalization     503
Using dynamic string internationalization     516
Altering the application for the locale     518
Implementing the default component     518
Locale-specific classes     519
Implementing user-defined properties     520
Defining user-specified properties     521
Defining a user-specified property provider     521
Checking the provided property value      522
Building the code     522
Summary     523
Completing the understanding     525
Testing and deploying GWT applications     527
Testing GWT code using JUnit     528
Overview of JUnit for GWT developers     529
Creating a new test case     534
Testing asynchronous code     537
Deploying GWT applications     539
Organizing your project     540
Installing RPC servlets     548
Summary     554
Peeking into how GWT works     555
Examining the compilation process and output     556
Investigating compilation     556
Examining the output     559
The GWT application-loading mechanism     564
Legacy applications     565
Standard applications     566
Bootstrapping the standard application     567
Cross-script applications     572
Compiling Java to JavaScript     573
Exploring the produced JavaScript     573
Reviewing standard Java objects: the vector object     574
Exploring program code as JavaScript     576
Understanding the initialization code segment      578
Summary     579
Index     581

No comments:

Post a Comment