NetBeans the Definitive User Guide phần 3 pot

Figure 6.8. Ant Help page
Chapter 6. Compilation and Execution Services
106
You can add other elements to your build script from the Explorer. For each node, simply right-click and select Add
from the context menu, and a list of valid tags should appear.
Configuring the Ant Module
Chapter 6. Compilation and Execution Services
107
The Ant module is configurable via property sheets in the Options window, with global settings accessible at
Building->Ant Settings. Table 6.7 explains the properties for the Ant settings node.
The module also creates two compilation services and an execution service—Ant Script Compilation, Indirect Ant
Compilation, and Ant Script Execution. All compilation services implement Build, Clean, and Compile actions. The
Ant compilation services have properties that can be configured to define the actions by executing targets in an Ant
build script. For example, in the Options window see Building->Compiler Types->Ant Script Compilation. Notice the
Build Target(s) property. Its default setting is clean, all. The targets are executed from left to right. If a source object
uses Ant Script Compilation, then selecting the Build action from the object's context menu results in executing the
clean target, followed by the all target in the Ant build script. See Table 6.8.
The Indirect Ant Compilation compiler service is useful when you wish to call an Ant script while compiling another
file. For example, it could be used to call the compile target in an Ant script when compiling a Java file. The Indirect
Ant Compilation has the very same properties as the Ant Compiler with the addition of a property to specify the Ant
script that defines the necessary targets to invoke.
The Ant Executor found in the Options window at Debugging and Executing->Execution Types->Ant Script Execution
defines targets to run when an Ant script is executed. The default target of the Ant script is executed if no target is de-
fined here.
Executing and Compiling With Ant Scripts
By default, double-clicking an Ant build script should run the default target of that script. To run a specific target, you
can right-click on the target's node and select Execute from the context menu. The output from the Ant script should
appear in the Output tab. There is usually no need to define compilation for Ant script as you can simply execute the
compile target declared in the script. However, if you set the Compiler property to the Ant compiler service then you
could select Build or Compile from the Build menu and the respective targets will be executed.
Why Use Ant?

NetBeans already has compilation and execution services for all the object types that are supported for development.
Why not just use the services that are provided? The short answer is, if you're happy without Ant, then don't use Ant. If
you only build and execute single classes or small projects, then you probably don't need the flexibility that a build tool
like Ant offers. But if you're involved in a large project, especially a project that has needs complex and unique actions
to be performed many times during the course of development, then look to Ant for a powerful, easy to use, easy to
configure tool.
For example, this book was developed by several authors working remotely with Linux, Solaris and Windows comput-
ers with shared access to a CVS repository for storing the drafts of chapters, source examples, and related material. The
text was written in DocBook XML, which the authors and editors needed to validate and transform into HTML or PDF
frequently. We created an Ant build script to perform the tasks. As the project progressed and the variety of tasks ex-
panded, the build script grew to accomodate the needs. A simple CVS update automatically brought the enhanced build
script into each author's environment. Without CVS and Ant, there would have been many more emails and phone calls
asking how to do common tasks. With these tools, we have been able to keep our focus on the project goals.
Chapter 6. Compilation and Execution Services
108
Chapter 7. Customizing the environment
Table of Contents
TheSetupWizard 109
GeneralNetBeansSettings 109
ModuleInstallation 112
UpdateCenter 112
TheToolsOptionsDialog 113
ConfiguringToolbars 114
ConfiguringMenus 116
ConfiguringEditors 117
ObjectTypeAssociations 117
EditorSettings 118
Commandlineoptions 126
Modules 128
InstallingModules 128

Enablingand DisablingModules 131
The NetBeans IDE offers a highly customizeable environment through wizards and serializable options. In this chapter
you will learn how to customize your IDE environment. We will look at the following areas of customization:
• The Setup Wizard
• Toolbars
• Menus
• Editors
• Modules
The Setup Wizard
The Setup Wizards allows you to quickly configure your IDE with some general settings required for everyday use. It
is especially useful after an initial install of the IDE and is usually launched the first time you run NetBeans. To use the
Setup Wizard any time after the initial launch select Tools->Setup Wizard from the menu bar.
General NetBeans Settings
Figure 7.1. The first pane of the Setup Wizard
Chapter 7. Customizing the environment
109
The first pane of the Setup Wizard, shown in Figure 7.1, allows you to configure a proxy server, a window mode, and
an HTML browser.
The proxy server settings will be used for all the network and Internet needs of the IDE such as acquiring information
for AutoUpdate from a remote Update Center. Your network administrator should be able to supply you with the server
and port information of your proxy server. You will generally only need these settings if you are using the IDE behind
a firewall.
The window mode setting is used to determine the type of windowing interface NetBeans should use. There are gener-
ally two types of interfaces: SDI, or Single Document Interface , and MDI, or Multiple Document Interface . Ignoring
the word "Document", the main difference between the two interfaces is that in SDI mode, the IDE has no main win-
dow, and each workspace has its own window, whereas in MDI mode, all the windows are managed by a single win-
dow known as the Main Frame. Your choice of a window mode depends on your taste. They both have their advan-
tages. In SDI mode the proliferation of windows for every document and workspace can be quite messy and annoying.
The one benifit is that screen size per window can be maximized. In MDI mode there is one window and everything
else is a child of that window. This makes window management very easy and agreeable with the programmer who al-

ready has twelve other applications opened. The one caveat is that since MDI child windows share space with a parent
window, they cannot be maximized to take advantage of the entire screen area. This can be especially annoying with an
editor window displaying Java source. It's often convenient to minimize scrolling by showing as much text as possible.
Microsoft Windows users may favor MDI mode because many Windows applications are MDI, including the DevStu-
dio IDE.
The differences of the two modes do not necessarily form a fork in the road, and neither of the two can be considered
"the road less traveled". This is because the IDE lets you have the best of both worlds. In NetBeans, windows can be
Chapter 7. Customizing the environment
110
docked into one another. Windows - also referred to as frames - can also be made into separate windows, regardless of
the mode you chose. This is an advanced level of customization for the NetBeans IDE, but remains simple to accom-
plish. For example, if you chose MDI mode from the Setup Wizard, but would like your editor to be displayed as a sep-
arate window so that you could take advantage of more screen real estate, simply open a Java file; once the editor is
opened select Window->Frame Resides ->As Separate Window from the menu bar. You should now see the editor in a
separate window. Conversely, if you preferred to dock the editor window, back Window->Frame Resides->As Separate
Window into the main frame, you would select Window->Frame Resides->In IDE Desktop. You can also chose to
combine multiple windows via docking. For example, to add the filesystem explorer to the left side of an editor win-
dow set the focus to the filesystem explorer, select Window+->Dock View Into->Source Editor-> Left . Figure 7.2
shows an editor window with a filesystem explorer docked on the left.
Figure 7.2. An editor window with a filesystem explorer docked on the left
The Web Browser selection is used for all the IDE's browsing needs such as Javadoc searching and JSP previewing.
NetBeans comes with the ICE Browser embedded. This will usually be sufficient for all your needs and provides the
tightest integration with the IDE, however it lacks the feature rich capabilities of some commercial browsers and in that
case you may wish to select an external browser for default HTML browsing. If you choose an external browser, you
will have to configure it later by selecting Tools->Options and then expand the web browsers node.
Chapter 7. Customizing the environment
111
Module Installation
Figure 7.3. The second pane of the Setup Wizard
The second pane of the Setup Wizard (see Figure 7.3) allows you to configure which modules will be used by the IDE

at runtime. The modules are shown in a table along with their enabled status (true\false), version number, and descrip-
tion. Upon startup, the IDE will attempt to load each of the enabled modules. This process becomes slower with the
number and complexity of the installed modules. Memory usage is also a consideration since all modules are issued
their own classloader and run simultaneously in memory. For these reasons it may not be desirable to enable every pos-
sible module. To disable a module, simply select "false" under the enabled column of that module's entry.
Update Center
Figure 7.4. The third pane of the Setup Wizard
Chapter 7. Customizing the environment
112
The third pane of the Setup Wizard, shown in Figure 7.4, allows you to configure the Update Center connection for the
IDE's Auto Update tool. The Auto Update tool connects to an Update Center to acquire modules and core components
for installation. You can configure Auto Update to be automatically invoked on a recurring schedule, or you can manu-
ally invoke it any time by selecting Tools->Update Center from the menu bar.
The ToolsOptions Dialog
Most NetBeans global or project level settings can be managed in the dialog invoked when you pull down Op-
Tools->tions dialog. The components in this dialog represent the vast array of configurable settings in the IDE. The
components are organized in the left pane of this dialog in a tree of nodes. Each node represents a specific configura-
tion component while the folders represent categories by which the components are grouped by.
When you select a component its properties will appear in the left pane in a table that is known as the property sheet.
Property sheets consist of two cells. A property name cell and a property value cell. Typically the property value cell is
to the right of the property name cell. You can change a component's settings by changing the data in its property value
cell.
Some property value cells allow you to enter plain text. Others, such as true/false properties will have a combo box of
valid entries. Some value cells may require data that is not easily entered as text and will prompt you to use a special
property editor. When the option to use a property editor is available, an ellipsis ( ) will appear in the rightmost end of
the cell when you click on it. Clicking on this ellipsis will launch the property editor for that cell. Cell's that require
Color values frequently provide property editors that allow you to choose colors from a pallete.
Some settings you change you may wish to change globally. Other settings changes you may wish to apply only to the
project you have open. Fortunately, NetBeans provides a means to specify the scope of a Tools Options setting.
Chapter 7. Customizing the environment

113
In the figure below, we have circled a very small and important button!
This button which bears two left angle brackets, or "arrows" (<<) as its emblem is called the Show Levels button. If
you click it, a new panel "unfolds" into the options listing and you are offered three choices for the level of settings per-
sistence which can be applied on a per-setting basis, as shown in the figure below.
The three choices for settings persistence are as follows:
• Default means "keep the default settings shipped with NetBeans and don't allow the user to apply any changes." Of
course, if you change your mind, you can always remove this persistence and allow yourself to change the given
setting. It's just a safety net.
• Project means settings changes are applied to the current project only. Any other project will retain the settings it
was left with until they are changed while that project is open.
• User means all changes apply to all projects for that user.
You can click the Show Levels button again to fold back this settings persistence panel so that it's out of your way.
Configuring Toolbars
Toolbars are similar to menus. They are panels consisting of image buttons that are mapped to a specific task. Each but-
ton on a toolbar will usually have a brief text description, commonly called a tooltip, and there may also be a sequence
of keys associated with a button known as its shortcut key. The IDE comes preconfigured with several toolbars that
would most likely be sufficient for everyday development tasks. If the preconfigured toolbars do not meet your needs
you can always modify them, or create entirely new ones, to perform your custom tasks.
In the NetBeans IDE, each toolbar button is tied to an Action. You may think of an action as a task. For example Cut,
Paste, and Copy are all actions. Most of the IDE's actions are pre-packaged, while others are provided by third party
modules. To begin configuring toolbars select Tools->Options and then go to IDE Configuration->Look and
Feel->Toolbars. Figure 7.5 shows the toolbar options.
Chapter 7. Customizing the environment
114
Figure 7.5. Toolbar options
These options allow you to edit and delete existing toolbars, or create your own. You can add new buttons to an exist-
ing toolbar by copying and pasting actions. For example, to add a new button to the Build toolbar for compiling you
would perform the following steps:
1. Expand the Build toolbarnode.

2. Expand Actions->Build, right click on the Compile node, and select Copy from the context menu.
3. Right-click on the Build toolbar node and select Paste->Copy from the context menu.
You can also rearrange the ordering of toolbar buttons. To change the button order on a particular toolbar, right-click
on its node and select "Change Order" from the context menu. You will be presented with the dialog box shown in Fig-
ure 7.6. Use the "Move Up" and "Move Down" buttons to reorder each toolbar button's position. The toolbar button at
the top of the list will appear first from the left on the toolbar.
Figure 7.6. Changing the toolbar button order
Chapter 7. Customizing the environment
115
Configuring Menus
The IDE also allows you to edit and create menus in the same way you edit and create toolbars. To begin editing and
creating menus open the options dialog box (Tools-> Options) and go to IDE Configuration->Look and Feel->Menu
Bar. You should see a list of nodes similar to the ones seen in Figure 7.7 that represent your current menu bar. By ex-
panding each menu, you will see a list of menu items. An item can be either an Action or a separator. Menus can also
contain submenus.
To add a submenu to a menu, right-click on the menu node and select New->Menu New->Menu from the context
menu. The new menu is immediately viewable under the menu you created it. To add a menu item would require steps
similar to the aforementioned toolbar button steps. After copying an action, right-click on the destination menu node
and select Paste->Copy from the context menu. The reordering of menu items within menus is done exactly the same
way toolbar buttons are reordered (right-click a menu node and select "Change Order " from the context menu). You
can also delete and rename menu items and menus in much the same way you would any node in the IDE. There is also
an easy way for mapping shortcuts to menus. When supplying a name for the menu, type an ampersand (&) in front of
the letter you wish to map. For example, &File will be mapped to the shortcut Alt+F.
Figure 7.7. Creating and editing menus
Chapter 7. Customizing the environment
116
Configuring Editors
Of all the components in the IDE, the editor will most likely be the one involved in your day-to-day programming use.
Therefore it makes sense that is one of the most configurable of all the components in the IDE. Although it may seem
that you are always working with one editor, there are in fact different editors for different types of files. A file type is

identified by its extension. The mapping of editor to file type is a one-to-many relationship. Although the content they
handle may be different, editors share a common set of configurable attributes. Some editors may choose to disable
some of these attributes because of the irrelevance to the particular implementation - for example the "Auto Popup
Code Completion" feature is disabled in the Plain editor. Editors for some object types may have multiple views; in
such cases special menu items are provided for switching between views. For example, there is a specialized editor for
modifying Properties files. That editor has two views: one provides a table for editing properties and values, and the
other provides a plain text view. Selecting Open from the context menu for a Properties file results in the default view,
which is the table view. To access the alternate plain text view, select Edit from the context menu.
Object Type Associations
As previously mentioned, editors are mapped to file and MIME types. In the IDE, a file is basically a type of object.
The IDE uses Object Types to identify files based on their extensions. Object Types do not always map to files. Some
are used internally as objects by modules. You can map several file extensions to a single Object Type, thereby associ-
Chapter 7. Customizing the environment
117
ating the files with those extensions to a particular file type in the IDE. For example, adding java as an extension to the
Java Source Object Type would make all files ending in .java recognized as Java file types in the IDE. The real
power of Object Types comes in when you associate Actions with an Object Type. Actions are objects in the IDE that
are mapped to menu items and used to carry out a specific task on a target object. "Compile" is one example of an IDE
Action. The Compile Action can be used on Java Object types to invoke a configured Compiler Service with a Java file
as its target. Nothing stops you from adding the Compile Action to an Image Object Type. If for example you had a
special Compiler Service that converted GIF to JPEG it would be useful to be able to right click on a .gif file, select
Compile from the menu and have your file converted. Configuring Object Types makes all this possible. Usually Ob-
ject Types come with preconfigured Actions and extensions. You would only need to change these to add custom be-
havior.
Table 7.1 shows some common Object Types and their descriptions.
Usually the only property of an Object Type you would configure would be the extensions. This is useful if you would
like to add a new extension so that it is recognized by the IDE. For example, if you want the IDE to recognized files
with the jad extensions as Java Source files simply go to the Java Source Objects node, and in the property sheet click
on the pane to edit the "Extensions and Mime Types". Click on the ellipsis that appears and you should see a dialog box
like the one shown in Figure 7.8. Enter jad (NB You enter extensions without the dot prefix) in the input box and then

click add. Close the dialog box. Any files in your mounted filesystems that has a jad extension should now appear with
the icon denoted for Java source files. When you double click the file, you should see the source code in the Java edi-
tor.
Editor Settings
At the heart of Editor configuration is the Editor Settings. The Editor Settings node can be found in the Options Dialog
under Editing->Editor Settings. When you expand this node you will see all the various editors in the IDE. Usually an
editor's name will give you a good idea of the types of files it supports. Most of the editors have the same configuration
parameters, however you will be able to configure them separately and maintain your changes.
Global Key Bindings (Shortcut Keys)
Key bindings are the mapping of keys to predefined IDE actions. For example, the mapping of the Control key and the
'C' key combination is to the Copy action. Many combinations can be mapped to a single action. Each mapping is
known as a binding, since the sequence of key strokes is bound to the particular action. Global Key Bindings are inher-
ited by all the editors. Each editor also has its own specific bindings that can override global key bindings or provide
their own mapping. Global key bindings are configured by selecting the Editor Settings node and clicking on the Key
Bindings cell in the property sheet, and then clicking on the ellipsis ( ) that appears. You should see a dialog box simi-
lar to the one shown in Figure 7.8. The predefined actions are shown in the List box and can be sorted by Name or Ac-
tion (the internal action name). To add a new binding, first select an action from the list and then click on the Add
button. In the dialog box that appears, enter the key sequence that will cause the IDE to invoke the action. For meta
keys such as Control and Alt, you will need to hold on the key while typing. So for binding the beep action to the Con-
trol key and 'B' key combination, you would hold on the Control key while typing 'B' in this dialog box. After clicking
OK to close the dialog box the new key binding should appear in the Keybindings list box.
Figure 7.8. Global key bindings
Chapter 7. Customizing the environment
118
You can modify an editor's local key bindings by selecting that editor from the list of nodes under Editor Settings, and
editing its Key Binding property. This behaves exactly like the global options, except these local options override any
existing global key bindings for the specific editor the binding is associated with.
Fonts and Colors
Each editor has its own properties for fonts and colors. Color is divided into foreground and background and is individ-
ually configured for each syntax element of an editor. For example in the Java Editor, "Java Keyword" is a syntax ele-

ment and it has its own foreground and background color properties. So for a keyword such as "if" the foreground and
background color properties selected would be shown whenever it is typed. There is a default syntax element whose
properties the other syntax elements can inherit or override. This allows you to set a consistent background color for in-
stance, and only chose different foreground colors for various elements. Fonts are also chosen independently for each
syntax element and may be inherited from the default. To modify fonts or colors for a particular editor, select that edi-
tor from the nodes under Editor Settings, click the Colors and Fonts cell in the property sheet and then click on the el-
Chapter 7. Customizing the environment
119
lipsis that appears. You should see a dialog box that looks like Figure 7.9 . Syntax elements are listed in the list box to
the right. Click on an element to modify its font and color properties. The Default element should be at the top of the
list. To change the background from the white default to a light yellow (the color of a sticky pad for instance), select
the default syntax element and click on the button in the "Background Color" box and then click on the ellipsis that ap-
pears. You should see a dialog box like the one shown in Figure 7.10. This is the color picker dialog box. Each tab
shows a pallete from which you can chose colors from. Use the first pallette to select the light shade of yellow. As an
alternative, instead of clicking on the ellipsis and using the color picker, you could type in the RGB color code in the
edit box. The RGB color code for this shade of yellow is 255,255,204.
Figure 7.9. The fonts and colors editor
Chapter 7. Customizing the environment
120
Figure 7.10. The color picker
Chapter 7. Customizing the environment
121
Your default background color should now be set; however, some of the syntax elements may not choose to inherit this
property. You will need to go through the elements and click the Inherit check box in the Background Color. This
causes the Background Color chosen for the default syntax element to be applied to the current syntax element.
Choosing a font is just as easy as choosing colors. To modify the font for single line comments in the Java Editor,
changing it from plain italics to bold italics, click on the button in the Font box and then click on the ellipsis that ap-
pears. You should see a dialog box similar to the one shown in Figure 7.11. In the first list you select the Font name.
The second list allows you to configure the syle of the font. For this example you would select Bold Italic from that list.
The third list allows you to select the font size. Once you're done configuring the font settings, click OK to close the di-

alog box. The settings in this example should only affect single line comments (comments that begin with "//"). Now
every time you type a single line comment it will appear as a font with a bold-italic style.
Chapter 7. Customizing the environment
122
Figure 7.11. The font picker
Macros
In chapter three you learned about macros in templates which were used for string expansion. In this section you will
learn about a different macro used to execute a task on a particular editor. You can refer to these as editor macros. Edi-
tor macros can be recorded, saved, and executed. An editor macro can only be executed in the editor that it was
recorded and saved in. Finally an editor macro is mapped to a shortcut key so that it can be easily invoked through con-
venient keystrokes.
Recording and Saving Macros
Let's say you were using a logging class that would emit messages to a log file when the log method was called with
the classname and log message as parameters. The static method signature is:
Logger.logMessage(this.getClass(),"message");
Instead of having to type that every time you wish to log a message, an editor macro can be created to type the entire
Chapter 7. Customizing the environment
123
method signature and then position the caret between the quotation marks so that a message can be typed.
To begin recording your macro open a Java source file. This macro will be available for all source files opened with the
Java editor. Start the macro recorder by typing Ctrl+J and then S (Hold Ctrl key, type J, release Crtl Key, type S). You
should see the message "Recording" appear in the editor's status bar (the message goes away once you begin typing).
Every keystroke beyond this point is recorded as part of the macro. Type the following code snippet:
Logger.logMessage(this.getClass(),"");
When finished typing use the back arrow key to move the caret between the two quotation marks. Type Ctrl+J and then
E to end the macro recorder. A dialog box like the one shown in Figure 7.12 should appear. Type in a canonical name
for the macro in the Name edit box and then click the Add button. Another dialog should pop up prompting you to
enter a key binding for this macro. Type in a key sequence that you find convenient, for example Alt+Shift+0 (do not
type in the plus signs and remember to keep holding meta keys such as Alt while you type). Click Ok and your new
macro should be saved.

Figure 7.12. Recording a macro
Note
When recording macros the IDE ignores mouse movements. Therefore avoid using the mouse while recording.
You can use shortcut keys, however. This allows you to build complex actions, made up of several shortcut
key sequences, and then assign the complex action to a single shortcut key sequence.
Chapter 7. Customizing the environment
124
Editing and Executing Macros
After a macro is saved, it becomes one of the properties of the editor in which it was recorded. The macro we wrote in
the previous section will be available to any source file opened with the Java editor. To modify the macro we can edit it
through the macro property found in the property sheet for the particular editor. Click on the Macros cell to edit the
property and click on the ellipsis. You should see a dialog box similar to that shown in Figure 7.13. Select the macro
you wish to edit from the table and click on the Edit button to change the name or macro expansion.
Figure 7.13. Editing macros
Chapter 7. Customizing the environment
125
To execute the macro, type the keyboard shortcut anywhere in the editor. For this example we used Ctrl+Alt+0, so typ-
ing that will execute the macro and we should see the code with our caret positioned between the quotation marks.
Indentation Engines
The IDE uses the concept of an indentation engine to format code in the Source Editor. Setting the width of tab spaces,
adding a leading asterisk to comment lines, and placing spaces before parentheses are some examples of its usage. You
can create two types of engines, a Java Indentation Engine or a Simple Indentation Engine. The Java Indentation En-
gine has more options and is specific to formatting Java source code. Simple Indentation only allows you to configure
the number of spaces for tab. Table 7.2 shows the properties of the Java Indentation Engine. You can associate an en-
gine with any of the editors by selecting the editor from the list of nodes under Editor Settings, click on the Indentation
Engine cell in the property editor and then click on the ellipsis. You should see a dialog similar to the one shown in
Figure 7.14 allowing you to select an Indentation Engine and configure it. Many editors can use the same engine.
Changing the engine's settings will affect all the editors that reference it.
Figure 7.14. Indentation Engine
Command line options

Chapter 7. Customizing the environment
126
The IDE can be run from the command line with arguments. At the command line type runide.exe -help
(runide.sh on UNIX systems) and you will see a dialog box like the one shown in Figure 7.15 with the command
line options. These options are shown and described in Table 7.3.
Figure 7.15. IDE command line options
Instead of typing the arguments at the command line each time you run the IDE, you can save your settings to a file that
is read into the IDE as command line parameters. Your arguments need to be in the ide.cfg file found in the bin di-
rectory of your installation. For example, if you wanted to specify xerces.jar ahead of the IDE's classpath and set
the maximum heap size to 256MB your ide.cfg file will consist of a single line that looked like:
-cp:pc:\xerces\lib\xerces.jar -J-Xmx256m
Chapter 7. Customizing the environment
127
Modules
Modules are what make the NetBeans IDE extensible. The IDE consists of a thin layer known as the core on top of
which are modules that provide most of the features you use. In the second part of this book you will learn how to cre-
ate modules and build the IDE sources with minimal modules. This section gives you an introduction to modules and
shows you how to install, uninstall and configure them in the IDE.
Installing Modules
The IDE allows you to install modules from NetBeans Update Centers (available through the web) or manually down-
loaded NBM files. Both of these methods are accomplished using the Auto Update Tool. To use Auto Update select
Tools-> UpdateCenter. You will see a dialog box like the one shown in Figure 7.16 .
Figure 7.16. The Auto Update Center - Pane 1
Chapter 7. Customizing the environment
128
If you are installing modules from the web, select the Update Centers you wish to connect to from the list provided and
click next. If you are behind a firewall you will need to click on the Proxy Configuration button and supply the proxy
server and port.
Installing From The Web
If you chose to install from the web and clicked the next button you should see the next pane of the wizard as shown in

Figure 7.17 . If you do not see this pane there may be something wrong with your Internet connection, or the Update
Centers you chose were invalid or experiencing network problems. Another cause for problems could be your proxy
settings. Check your settings, or consult with a systems administrator if you're using your company network, and try to
connect again.
Figure 7.17. Installing modules from the web
The modules are listed under each Update Center you selected in the first pane. When you select a module the dialog
displays the module's version info compared to what you currently have installed. The text box gives a description of
the module and what it does. A web page giving more information about the module can be viewed by clicking on the
More button. To select a module to be installed, select the module's node in left list box then click on the arrow point-
Chapter 7. Customizing the environment
129
ing to the right, or to the "Include To Install" list box. You can select multiple modules by holding the Ctrl key while
selecting and use the same arrow to chose those modules for installation. The other arrow button pointing to the right
allows you to select all the modules for installation. Click the next button and you might see a license agreement. If you
chose many modules you might have to click "Accept" on each of the license agreement dialogs that pop up. After ac-
cepting the license agreement the IDE will attempt to download the modules and check for any digital signatures.
When the downloading is complete, you will be able to click Next and should see a dialog box like the one in Figure
7.18.
Figure 7.18. Completing Installation of modules for the web
This is the final pane. You should see a list of modules that were downloaded. If the module is digitally signed and has
a valid certificate it will appear with the word Trusted under it. You can select a module and click the View Certificate
button to view its digital signature certificate. The checkbox to the left of a module indicates whether you want this
module installed when you click the Finish button. Checking it means you would like it installed. The IDE must be
restarted for a module to be utilized. You can choose to have the IDE restart immediately (don't worry, your files will
be automatically saved first), or install immediately and restart later at your own convenience. Once you click the Fin-
ish button, the module will be installed.
Chapter 7. Customizing the environment
130