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 360Genre: 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 xixAcknowledgments 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