Eclipse Plug-ins Training

Duration: 5 days
Course code: SS-ECL-001

Audience

This course is for developers who already know Java and want to master the Eclipse platform.

  • Java developers
  • Architects
Prerequisites

Attendees must be proficient in Java in order to do the labs.

Description

Our Eclipse Plugins training course aims at making Java programmers efficient at building component based software on top of the Eclipse framework. Eclipse has proven to be a very effective framework for building client deployed rich applications. The Eclipse framework is component based and built on the specifications of OSGi. This component model enables application developers to extend an existing eclipse-based product with their new components (or plug-ins). The platform is compliant with the OSGI standard for dynamic discovery and loading of components. The platform provides a common graphical user interface model. It is designed to run on multiple operating systems. Plug-ins can be built using the Eclipse portable APIs and may run unchanged on any of the supported operating systems.

The Eclipse Plugins training course teaches attendees the architecture of the Eclipse platform, plug-in development, testing, debugging, packaging, branding and deployment. It covers the whole spectrum of writing a plug-in for the platform. This is a highly hands-on course, with programming labs constituting about 60% of the course.

Objectives

Upon completion of this course, attendees will be able to:

  • Understand the architecture of the Eclipse platform
  • Use the Standard Widget Toolkit (SWT) and JFace to build graphical user interfaces for the plug-ins
  • Master a large set of the standard eclipse extension points
  • Develop several kinds of plug-ins using many of the standard extension points
  • Develop functionally and visual rich desktop applications using the Rich Client Platform (RCP) support
  • Brand, package, productize and deploy plug-ins
  • Define new extension points on plug-ins
  • Use the resource plug-in
  • Use the Jobs API to create highly responsive UI applications

Outline for Eclipse Plugins Training Course

Eclipse Overview

  • Eclipse platform architecture
  • Anatomy of a Plug-in
  • Extension points and contributions
  • Eclipse SDK
  • Write your first plug-in using Java tooling
  • The plugin.xml file
  • Packaging and installing a plug-in

Plug-in Development Environment (PDE)

  • PDE concepts
  • plugin.xml editor
  • Extension point wizards
  • Using PDE to build a simple plug-in
  • Debugging, testing and deploying a plug-in

SWT - The Standard Widget Toolkit

  • SWT overview - What, why, and how
  • SWT widgets
  • Layouts
  • SWT event model
  • Graphics
  • Color model
  • Thread model

JFace - The User Interface Framework for Plug-Ins

  • JFace overview
  • The JFace Viewer framework
  • Tree, Table, List and Text Viewers
  • Editors
  • JFace resource module
  • JFace wizard module
  • Progress indicators
  • Dialogs

Defining Extension Points

  • Design strategies for providing the extension points
  • Extension point definition
  • Defining the extension point schema in XSD
  • Using the EXSD edition in the PDE
  • Dynamically load and execute the extensions

Resources and Resources Plug-In

  • Resources overview
  • Resources and workspace
  • Resources and file systems
  • The Resources API
  • Resource markers
  • Tracking resource changes
  • Incremental project builders
  • Project natures
  • Participating in workspace save

Writing Workbench Plug-ins

  • Overview of Workbench Components
  • Overview of workbench extension points
  • The Activator class
  • Life cycle of a plug-in
  • View Actions Extension Point
  • Editors Extension Point
  • Editor Action Extension Point
  • Popup Menus Extension Point
  • Workbench Menu contribution
  • ActionSet Extension Point
  • Perspectives Extension Point
  • Internationalization & Localization

Dialogs and Wizards

  • Dialogs Overview
  • JFace Dialog Framework
  • SWT Dialog Widgets
  • newWizards Extension Point
  • Process of Creating a Wizard

Preferences and Properties

  • Extending the Preferences & Properties Dialog
  • Using preferences and properties in plug-ins
  • Storing preferences and properties
  • Defining a Preference Page Extension
  • Defining a Property Page Extension
  • Interacting between GUI and preference & property storage
  • Monitoring changes to the preference storage

Offering Help

  • Contributing online Help
  • Process of offering Help
  • Creating HTML contents
  • Creating Table of Contents Files
  • Linking Table of Contents Files
  • Providing Anchors
  • Declaring the Help Extension
  • Providing Context Sensitive Help
  • Process of adding Context Sensitive Help
  • Declaring a Help Context Extension
  • Creating the Infopop Contents
  • Associating the Context Id with UI Component

Fragments

  • What is a plug-in fragment?
  • Where is the fragment defined?
  • The fragment.xml file
  • Using the PDE to create fragments

Features, Products, Branding, and Packaging

  • Features
  • Use PDE to define features
  • Branding features
  • Branding products
  • Packaging for delivery
  • Updating features

Rich Client Platform

  • Overview
  • Headless Application
  • Simple SWT Application with RCP
  • Building a comprehensive RCP application
  • Adding Menus, toolbars, etc.
  • Package, brand and export an RCP product

Jobs Framework

  • Handling concurrency using the Jobs framework
  • The Job API
  • The Job manager
  • Jobs and threads
  • Jobs and synchronization
  • Scheduling Rules
  • The Lock API
  • Resource locks

Comments are closed.