O'Reilly logo



Start Free Trial

No credit card required

NetBeans Platform 6.9 Developer's Guide

Book Description

Create professional desktop rich-client Swing applications using the world's only modular Swing application framework

  • Create large, scalable, modular Swing applications from scratch

  • Master a broad range of topics essential to have in your desktop application development toolkit, right from conceptualization to distribution

  • Pursue an easy-to-follow sequential and tutorial approach that builds to a complete Swing application

  • English translation by leaders of the NetBeans community of a Germany Developer's Notebook on the NetBeans platform

  • In Detail

    The NetBeans Platform has many features provided out of the box for Swing desktop application developers. It can take you hours just to create menu bars, toolbars, a window system, and other typical desktop application infrastructural needs rather than you focusing on your domain knowledge. Imagine how much time you could save with a hands-on guide for using the NetBeans Platform, which relieves you from creating desktop functions for each of your applications.

    This book guides you through the development of a complete Swing application built on the NetBeans Platform. Each chapter introduces a number of new concepts relating to a theme, such as the window system, and then shows you how to implement the concepts in the application you are creating. At the end of the book you have a task manager, which you can adapt to your own purposes. Or you can, of course, create your own applications, now that you have built up a solid basis of NetBeans Platform knowledge.

    The NetBeans Platform is a framework for developing large distributed desktop applications. It aims to drastically simplify desktop application development by providing a number of techniques, patterns, and full-blown Swing components out of the box. Most desktop applications have very similar technical requirements, such as: a consistent user interface, extensibility, data display, configuration settings, a help system, distribution mechanisms, on-line update possibilities, and the ability to be deployed to multiple operating systems.

    Fulfilling these technical requirements over and over again for each new application is expensive, superfluous, and boring. The NetBeans Platform gives developers a transparent, open source, extensible, and free framework that address all of these technical requirements. This book will guide you through all these topics and show you how you can apply the lessons learned in the context of a real application.

    The central driver of the book is the creation of a complete sample application, chapter by chapter, throughout the length of this book. You will learn how to apply the key concepts in your own work environment, so that you will be able to build flexible, reliable, robust and scalable Swing applications yourself. At the end of the book, you will be comfortable creating similar applications yourself and you will know what to do when you get stuck.

    This book helps you to create robust Swing applications by providing an in-depth coverage of all the features of the powerful NetBeans Platform 6.9

    Table of Contents

    1. NetBeans Platform 6.9 Developer's Guide
      1. NetBeans Platform 6.9 Developer's Guide
      2. Credits
      3. Foreword
      4. About the Author
      5. Acknowledgement
      6. Preface
        1. What this book covers
        2. What you need for this book
        3. Who this book is for
        4. Conventions
        5. Reader feedback
        6. Customer support
          1. Errata
          2. Piracy
          3. Questions
      7. 1. Modules
        1. Modular application development
        2. Characteristics of a module
          1. Deployment format
          2. Uniqueness
          3. Versioning
          4. Exposed interfaces
          5. Declarative dependencies
          6. Lifecycle
        3. Creating an application
        4. Setting dependencies
        5. Versioning
        6. Installing modules
        7. Integrating OSGi Bundles
        8. The sample application
        9. Summary
      8. 2. Forms
        1. Form Builder
          1. Creating a form
          2. Laying out a form
          3. Aligning components on a form
          4. Space distribution
        2. Properties window
        3. Event handling
        4. Modification of generated code
        5. Extending the palette
        6. Summary
      9. 3. Window System
        1. Creating a window
          1. Examining the generated files
        2. Automatic window lifecycle management
          1. Programmatically managing the Window lifecycle
        3. Positioning of windows
        4. Creating custom modes
        5. Creating window groups
        6. Extending the default TopComponent persistence
        7. Summary
      10. 4. Lookup
        1. Registering and finding services
        2. Creating extension points
          1. Using extension points externally
        3. Enabling loosely-coupled communication
          1. Loosely-coupled consumption
          2. Creating new tasks
        4. Dynamic changes and notifications
          1. Creating an additional TaskProvider
        5. Proxy Lookups
        6. Listening to the selection
          1. Creating a service facade
        7. Summary
      11. 5. Actions
        1. Preparing to work with global actions
        2. Creating global actions
        3. Examining the created files
        4. Enabling Users to Invoke actions
          1. Toolbar
          2. Keyboard
        5. Summary
      12. 6. Nodes and Explorer Views
        1. Multiple models in pure Swing
        2. Nodes and the global Lookup
        3. Multiple node implementations
          1. Creating a node
        4. Multiple explorer view implementations
          1. Creating an explorer view
        5. Controlling views with the ExplorerManager
          1. Creating an ExplorerManager
        6. Key-based node hierarchies
          1. Creating a key-based node hierarchy
          2. Displaying nodes in an explorer view
          3. Exchanging explorer views
        7. Lazy child creation
        8. Context-sensitive actions
          1. Creating the Edit Task Action
          2. Creating the Add Task Action
          3. Creating the Copy Task Action
          4. Creating the Delete Task Action
          5. Connecting the Actions to the User Interface
        9. Decorating nodes
          1. Creating a FilterNode
        10. Displaying properties
          1. Creating a Property sheet
        11. Inplace property editors
        12. Adding widgets
          1. Creating a first scene
          2. Integrating a scene into the Task Manager
        13. Summary
      13. 7. File System
        1. Central registry
        2. Accessing the local FileSystem
          1. Providing additional attributes
        3. Listening to file changes
        4. Summary
      14. 8. Data System
        1. Support for new file types
          1. Creating support for Task files
          2. Examining the generated files
          3. Customizing the DataObject
              1. Refactoring the TaskModel
          4. Refactoring the DueList module
          5. Refactoring the TaskEditor module
          6. Refactoring the TaskActions module
          7. Refactoring the Overview module
          8. Trying out the New Task File Support
        2. Context-sensitive capabilities
          1. Creating a save capability
          2. Invoking the Save capability
          3. Providing Icon Badging
        3. Summary
      15. 9. Dialogs
        1. Notifications
        2. Standard dialogs
        3. Custom dialogs
        4. Wizards
          1. Creating a wizard
          2. Designing the wizard panels
          3. Controlling the wizard panels
            1. Validating entered values
            2. Invoking the wizard
        5. Summary
      16. 10. Settings
        1. Options window
          1. Integrating with the Options window
        2. Preferences
          1. Setting and using a Preference
        3. Summary
      17. 11. Help
        1. Creating a helpset
        2. Creating context-sensitive help
        3. Combining help sets from different modules
        4. Removing help sets provided by other modules
        5. Summary
      18. 12. Branding
        1. Application launcher
        2. Limiting the set of modules
        3. Branding editor
          1. Application title and icons
          2. Splash screen
          3. Window system features
          4. Display texts
        4. Summary
      19. 13. Distribution and Updates
        1. Creating a ZIP distribution
        2. Creating an installer
        3. Enabling online updates
        4. Summary