qooxdoo Beginner's Guide


qooxdoo Beginner's Guide
eBook: $29.99
Formats: PDF, PacktLib, ePub and Mobi formats
$25.49
save 15%!
Print + free eBook + free PacktLib access to the book: $79.98    Print cover: $49.99
$49.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Support
Sample Chapters
  • Become a competent Rich Internet Application developer in qooxdoo
  • Gain knowledge on core object oriented programming concepts in qooxdoo
  • Get a good understanding on design and implementation of RIA in qooxdoo
  • Learn to do unit testing and automation testing of your qooxdoo application
  • Develop an end to end application, Team Twitter, using qooxdoo client and Java server

 

Book Details

Language : English
Paperback : 420 pages [ 235mm x 191mm ]
Release Date : December 2011
ISBN : 1849513708
ISBN 13 : 9781849513708
Author(s) : Mohamed Raffi, Rajesh Kumar Bachu
Topics and Technologies : All Books, Web Development, Beginner's Guides, Open Source

Table of Contents

Preface
Chapter 1: What is qooxdoo?
Chapter 2: Say Hello to the qooxdoo World!
Chapter 3: Core Programming Concepts
Chapter 4: Working with Layouts and Menus
Chapter 5: Working with Widgets
Chapter 6: Working with Forms and Data
Chapter 7: Testing and Debugging
Chapter 8: Internationalization
Chapter 9: Working with Themes
Chapter 10: Performance
Chapter 11: Miscellaneous
Appendix: Pop Quiz Answers
References
Index
  • Chapter 1: What is qooxdoo?
    • A feel of an RIA developed in qooxdoo
    • Time for action – play with the feed reader application
    • Architecture of qooxdoo SDK
      • Core layer
      • Browser Abstraction layer
      • Low-Level layer
      • GUI Toolkit layer
      • Data Binding
      • Internationalization
    • qooxdoo framework features
      • Language
      • Object-orientation
      • Programming
      • Internationalization
      • API reference
      • Testing
      • Deployment
      • Migration
      • Alternative programming models
    • Event-based rich UI programming
    • GUI widget library
    • Time for action – checking the demo browser and the playground applications
    • Application to be developed in this book—Team Twitter
    • Time for action – checking the Team Twitter application
    • What you should know and what you don't need to know
    • Summary
    • Chapter 2: Say Hello to the qooxdoo World!
      • Installing qooxdoo tools
      • Time for action – installing qooxdoo tools
        • Installing ActivePython
        • Installing Cygwin
      • Installing qooxdoo SDK
      • Time for action – installing qooxdoo SDK
      • Creating a simple qooxdoo application
      • Time for action – creating a simple qooxdoo application
      • Passing data to the server
        • JSON standard format
      • Communicating with the server
        • Setting up an RPC connection
        • Making a call
          • Request
          • Response
        • Aborting a call
        • Error handling
        • Cross-domain calls
        • Parameter and result conversion
      • RPC servers
      • Integrating with the Java server
      • Time for action – integrating with the Java server
        • Working with Eclipse IDE
      • Summary
      • Chapter 3: Core Programming Concepts
        • Code comments and API documentation
        • Time for action – generating API documentation for Team Twitter
        • Object-oriented programming
          • Object and class
          • Encapsulation
          • Inheritance
          • Overriding
          • Abstraction
          • Polymorphism
        • Interface
          • Members
          • Statics
          • Properties
          • Events
        • Class
          • Constructor and destructor
          • Members
            • Class members
            • Instance members
          • Types
            • Static class
            • Singleton class
            • Abstract class
          • Inheritance in qooxdoo
          • Overriding in qooxdoo
        • Mixin
          • Defining a mixin
          • Using a mixin in a class
        • Time for action – writing classes for Team Twitter
        • qooxdoo properties
          • Property initialization
          • Predefined methods
          • Property configurations
            • Apply
            • Check
            • Validate
            • Group
            • Event—property level
          • Property features
            • Value checks
            • Validation
            • Convenience
            • Notification
            • Advanced value handling
            • Performance
            • Memory management
        • Events—class level
          • Declaring events for a class
          • Adding listeners
          • Firing an event
        • Time for action – enhancing Team Twitter classes with properties
        • Summary
        • Chapter 4: Working with Layouts and Menus
          • Base classes for widgets
            • qx.core.Object
              • Object management
              • Event handling
              • Logging
            • qx.core.LayoutItem
            • qx.core.Widget
              • Widget properties
            • qx.application
          • Containers
            • Scroll
            • Stack
            • Resizer
            • Composite
            • Window
            • Tabview
            • Groupbox
          • Layout managers
            • Size hint of the widget and its parent widget
            • Layout properties
            • Auto sizing
            • Growing or shrinking
            • Overflow
              • Basic
              • Canvas
              • Dock
              • HBox
              • VBox
              • Flow
              • Grid
          • Time for action – designing layout managers for Team Twitter
          • Menu, MenuBar, and ToolBar
            • Menu
              • Menu creation
            • MenuBar
            • ToolBar
          • Summary
          • Chapter 5: Working with Widgets
            • Basic widgets
              • Label
              • Atom
              • Image
            • Time for action – enhancing the server application
            • Form widgets
              • Interface hierarchy
                • IBooleanForm, INumberForm, IDateForm, IColorForm, and IStringForm
                • IForm
                • IExecutable
                • IRange
                • IModel
                • IModelSelection
              • Class hierarchy
                • qx.ui.form.TextField
                • qx.ui.form.TextArea
                • qx.ui.form.PasswordField
                • qx.ui.form.CheckBox
                • qx.ui.form.RadioButton
                • qx.ui.form.RadioButtonGroup
                • qx.ui.form.SelectBox
                • qx.ui.form.ComboBox
                • qx.ui.form.Spinner
                • qx.ui.form.List
                • qx.ui.form.ListItem
                • qx.ui.form.DateField
                • qx.ui.form.Button
                • qx.ui.form.ToggleButton
                • qx.ui.form.MenuButton
                • qx.ui.form.SplitButton
                • qx.ui.form.HoverButton
                • qx.ui.form.RepeatButton
                • qx.ui.form.Slider
            • Time for action – adding widgets into Team Twitter
            • Special widgets
              • The popup widgets
                • qx.ui.popup
              • The tooltip widgets
                • qx.ui.tooltip
              • The control widgets
                • qx.ui.control.ColorPopup
                • qx.ui.control.ColorSelector
                • qx.ui.control.DateChooser
            • Custom widgets
            • Time for action – adding a custom widget to Team Twitter
            • Inline widgets
            • The table widget
              • Class hierarchy
              • Table construction
              • Remote table model
            • The tree widget
              • Class hierarchy
              • Tree construction
            • The treevirtual widget
              • Class hierarchy
              • TreeVirtual construction
            • Summary
            • Chapter 6: Working with Forms and Data
              • Form handling
                • Validation
                  • Synchronous
                  • Asynchronous
                • Resetting
                • Rendering
                  • Single column
                  • Double column
                  • Single column with placeholder
                • Serialization
              • Time for action – enhancing the UserSignUpForm
              • Object pooling
              • Data binding
                • Single value binding
                • Property binding
                • Event binding
                • Hierarchical data binding
                • Array binding
                  • Options map
                • Data controller
                  • Object controller
                  • List controller
                  • Form controller
                  • Tree controller
                  • Data stores
              • Time for action – enhancing the UserSignUpForm again
              • Summary
              • Chapter 7: Testing and Debugging
                • Unit testing
                • Time for action – performing unit test
                • Integration testing
                  • Integration test setup
                  • Writing test cases
                    • Simulator API documentation
                    • Simulator class hierarchy
                    • Selenium Java Client Driver API documentation
                    • Locating strategy
                • Time for action – performing integration test
                • Debugging
                  • Logging statements in qooxdoo code
                    • Console object
                    • Trace
                    • qx.dev.Debug
                    • Variant qx.debug
                    • Miscellaneous
                  • Introduction to Firebug
                  • Installing the Firebug add-on
                  • IE developer tools
                  • Tracing through AOP
                • Time for action – debugging
                • Summary
                • Chapter 8: Internationalization
                  • Internationalization
                    • Writing code to use internationalization
                      • qx.locale.Manager
                      • qx.locale.MTranslation
                      • qx.locale.String, qx.locale.Number, qx.locale.Date, and qx.locale.Key
                    • Writing PO files for various languages
                  • Time for action – generating PO files for Team Twitter
                  • Summary
                  • Chapter 9: Working with Themes
                    • Theme
                    • Meta theme
                      • Theme
                      • Font
                      • Color
                      • Decoration
                      • Appearance
                      • Modern theme
                      • Classic theme
                      • Simple theme
                    • Icon theme
                    • Color theme
                    • Font theme
                    • Decoration theme
                      • Aliases
                      • Decorations
                        • Decorator
                        • Style
                        • Writing new decorators
                    • Appearance theme
                      • Appearance selector (key)
                      • Appearance entry (value)
                        • Alias
                        • Appearance map
                      • Style entry in the appearance map
                      • The include entry in the appearance map
                      • The alias entry in the appearance map
                      • Base calls
                    • Performance
                      • Appearance queue
                      • Selector caching
                      • Alias caching
                      • Result caching
                    • Time for action – customizing themes for Team Twitter
                    • Summary
                    • Chapter 10: Performance
                      • Memory management
                      • Object pooling
                      • Profiling
                        • Limitations
                      • Compile-time tuning
                        • Class optimizations
                          • Strings
                          • Variables
                          • Private
                          • Base calls
                        • Identifying unused classes
                        • Lint check
                          • Improvements
                      • Partitioning and lazy loading
                        • Configuration
                        • Coding to load parts on demand
                        • Verification
                        • Recent improvements
                          • Part collapsing or merging
                          • Remove dependencies from the part loader
                          • Load packages in parallel
                          • Error handling
                        • Advantages
                      • Time for action – partitioning
                      • Good practices for performance
                        • Restrict the data in certain widgets
                        • Use filters
                        • Pagination
                        • .gz compression
                      • Summary
                      • Chapter 11: Miscellaneous
                        • Configuration
                          • config.json
                            • Listing of keys in context
                          • Job resolution
                            • The extend key
                            • The run key
                          • Job shadowing and partial overriding
                        • Migration
                        • Time for action – migration
                        • Back button support
                          • Identify application states
                          • Update history upon state change
                          • Add the event listener to the history manager
                          • Retrieve initial state
                        • qooxdoo license
                        • Summary

                        Mohamed Raffi

                        Mohamed Raffi is an Enterprise Application specialist. His area of work includes Architecture, Design, Development, Training, and Mentoring. He has over thirteen years of product development experience in variety of java and javascript-based technologies and frameworks. You can find more about him at http://in.linkedin.com/in/raffimd and he writes his thoughts at http://thoughtstoblog.blogspot.com

                        Rajesh Kumar Bachu

                        Rajesh Kumar Bachu has over six years of experience in the design and development of Enterprise Applications and Mobile Games. He is good at programming in java and j2ee technologies. He has worked extensively in Qooxdoo application development and migrated an enterprise application to Qooxdoo. You can find more about him at http://in.linkedin.com/in/rajbachu
                        Sorry, we don't have any reviews for this title yet.

                        Code Downloads

                        Download the code and support files for this book.


                        Submit Errata

                        Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                        Errata

                        - 2 submitted: last submission 02 Apr 2012

                        Errata type: Code | Page number: 78 | Errata date: 02 Apr 12

                        The code in the class map is incorrect. It should be:

                        qx.Class.define("org.test.ClassA", { construct : function(x,y) { // do some thing.... } }); /* Extend the class A to inherit the ClassA features. */ qx.Class.define("org.test.ClassB", { extend : "org.test.ClassA", construct : function(x,y) { /*You can call the super class constructor */ this.base(arguments,x,y); } });

                         

                         

                        Errata type: Code | Page number: 79 | Errata date: 02 Apr 12

                        The code is incorrect. It should be:

                        members : { baseFunction : function(x, y) { // do some thing... // Am inside base function } } }); // Extend the class A to inherit the ClassA features. qx.Class.define("org.test.ClassB", { extend : "org.test.ClassA", members : { baseFunction : function(x,y) { /* do some thing before calling base class implementation. */ // You can call the super class constructor this.base(arguments,x,y); // or arguments.callee.base.apply(this, x, y) ; /* do some thing before calling base class implementation. */ } } });

                         

                         

                        Sample chapters

                        You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                        Frequently bought together

                        qooxdoo Beginner's Guide +    SOA Approach to Integration =
                        50% Off
                        the second eBook
                        Price for both: €29.40

                        Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                        What you will learn from this book

                        • Gain knowledge on core object oriented programming concepts in qooxdoo
                        • Communicate through RPC-based AJAX calls
                        • Use light weight JSON to pass the data between client and server
                        • Get well versed with Containers and Layout Managers
                        • Learn most of the off the shelf widgets provided by qooxdoo in an organized way
                        • Design and implement Rich Internet Applications in qooxdoo
                        • Learn to do unit testing and automated testing of your qooxdoo application
                        • Easily internationalize your qooxdoo application to multiple languages
                        • Customize your qooxdoo application's look and feel using Themes
                        • Profile and improve performance of the qooxdoo applications
                        • Create reusable custom widgets for your qooxdoo applications
                        • Develop enterprise applications in qooxdoo

                         

                        In Detail

                        Over the past few years, all the major internet or enterprise applications are developed or migrated to Rich Internet Application to support all the features that are provided in the desktop applications. This helps organizations keep the end users happy and also improves application deployment and maintenance. qooxdoo is a stable, open source RIA framework. If you are waiting and watching for the right time to migrate your application to qooxdoo, this is the right time!

                        This book explains in detail about the rich user interface development in qooxdoo. It explains various concepts of qooxdoo framework in an easy to grasp and organized way, making it simple even for a novice in qooxdoo and also increases the competency level of the developer who is already working in qooxdoo.

                        This book helps developers understand the qooxdoo framework, setup the environment, and start the development of RIA using qooxdoo. You will learn the core programming techniques in qooxdoo, user interface development in qooxdoo, testing & debugging qooxdoo applications, internationalization of qooxdoo applications to multiple languages, customizing the look and feel of qooxdoo applications using Themes, Performance management, etc.

                        In the course of the book, we develop a complete application which will help the developer to understand the concepts better and to put things together to see the step-by-step progress to complete an application. By the end, this book will get the developer accustomed to the widgets and API available in the qooxdoo framework, and will enable him to design, develop, debug, and test the RIA in qooxdoo.

                        This book will take you through the various design and implementation concepts using qooxdoo. It helps you to develop Rich Internet Applications (RIA). qooxdoo 1.2 and qooxdoo1.4 are used to write this book.

                        Approach

                        This is a Packt beginner's guide. The unique style of the book is to set the requirements for an application, Team Twitter, in the first chapter and apply the concepts in the application as you learn in the following chapters. When you complete this book, you would have developed a complete application.

                        Although the scope of this book is only on the qooxdoo framework, which is a client side framework, we have explained how to set up one of the RPC servers and demonstrated the end to end application in the Team Twitter.

                        Who this book is for

                        This book is intended for the client side developers who design and develop internet web applications and enterprise web applications. If you want to start developing RIA applications in qooxdoo, this book would be a great help to jump start your development. If you are already developing qooxdoo applications, this book will help you to go through the qooxdoo framework quickly to improve your contribution to your project.

                        This book is also intended for the desktop application developers who want to move into RIA development and develop internet web applications and rich enterprise web applications.

                        It also provides an idea for the Architects and Lead developers to know about qooxdoo and evaluate the framework.

                        It helps beginners in qooxdoo to easily set up the development environment and explains the concepts in an order that is easily graspable by beginners.

                        Code Download and Errata
                        Packt Anytime, Anywhere
                        Register Books
                        Print Upgrades
                        eBook Downloads
                        Video Support
                        Contact Us
                        Awards Voting Nominations Previous Winners
                        Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                        Resources
                        Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software