content:
Function Components Package Plug-in Main Features Identify Products (But You have Control) Function Components Build Plugins (if you allow them) Platform configuration management features In the runtime Identification component, the policy organizational component of the PDE builds a function component to make Eclipse (or Any Eclipse-based product) Working with your way Reference information about the author's evaluation
related information:
Developing Eclipse plugins Extend Eclipse Java Development Tool All Eclipse Articles on DeveloperWorks
In the Linux area:
Tutorial Tools & Product Codes & Component Articles
How to customize Eclipse behavior using the Eclipse feature
Level: Senior Pat McCarthy Senior Software Engineer, IBM 2003 December
If you want to develop a plugin to share to others, learn how to effectively use the functional components. This article has proposed some suggestions on how to organize functional components and optimize the use of plug-in development environments, and introduce advanced technologies for custom Eclipse behavior. Even if you just want to learn how to set Eclipse so that you can customize any workspace initialization attribute values, or learn how to use link files to manage you to add components that you add to Eclipse, this article will help you.
Build a plugin is very interesting: You start writing code and create tools you want. Copy the plugin to Eclipse or a / PLUPGINS directory in an Eclipse-based product, which can be used in the Eclipse runtime environment. When using Eclipse once again, the plugin will be found, and the platform startup processing will be available in the runtime configuration. But who knows or cares about your plugin? Users can understand what tools you provide? Can they disable, patches or manage your components via Eclipse? The answer is obviously negative. The plugin itself is just a plugin instead of integrated components with the Eclipse platform. Function Component Package Plugin If there is no functional component, the plugin is difficult to control, it is popular, and the plugin that is not a functional component is an unrequited plugin. The startup process of the Eclipse platform includes a configuration step. If a new plugin is copied to the / plugins directory, or otherwise makes Eclipse can be found when starting, the configuration process will find it, but just flicker twice by flashing the Splash icon of the new plugin twice. The reason why Eclipse will find a new plugin because the configuration checksum of the current workspace stored in /.Metadate/.config/platform; because you did not provide a configuration to the platform to make configuration modifications The functional components, Eclipse can only be prompted by splash-flash. Pack your plugin as a (or two) feature, you will get the following:
List the prerequisites required for your component (in the feature.xml file) during the configuration process of Eclipse, allow your components to manage the creation tag information as an activity section of the Eclipse configuration, so that users who use those operating period environments You can identify your components and use a welcome page to tell the user provided by your feature (in the Welcome.xml file associated with your feature) to use the Eclipse Update Manager to modify your components Do not Wait until your plugin is developed, then package it as a functional component. The design results reflected in the definition of the functional component will affect how you build your plugin. For example, most Eclipse components have a UI feature and core (not UI) feature. If your plugin is divided into this method, you may think about redesigning them. Functional components can also be used to automatically compile the process referenced plugins. The main features identify a product (but you have control) although there are many features, only one feature is controlled when you start Eclipse. This primary feature determines the identity of the product and other runtime behavior, including identifying the name and the diagram associated with the runtime platform, and redefine options for all plug-in default attribute values. You can see in your own global properties, this powerful option allows you to customize your own Eclipse settings. Function Components Build Plugins (if you allow them) Plug-in Development Environment (PDE) can automatically complete most of your functionality and plug-ins. See the discussion of "PDE Generating Plugins" in Eclipse.org (there is associated link in the rear reference). These basic steps have also been practiced as an exercise in the Java Developer's Guide to Eclipse (Links to the References). It can be said that if you have a feature and understand how PDE helps you build plugins and feature, you can build a feature, then let it build all related plugins. Building control strategy (bin.excludes and bin.includes) will discuss in the strategy of using PDE build features later. These strategies are complementary to the Eclipse.org article and the Java Developer's Guide to Eclipse book. Platform configuration management understanding The conditions need to help understand how they manage the content available in the active configuration. The startup process If you are a just decompressed Eclipse platform, you will happen when you start Eclipse.exe: Installation may have completed if a workspace already exists, then there will be a .metadata / .config / platform.cfg configuration file. If you are installing Eclipse in a regular manner, you have to run the Eclipse -Initialize command to generate a default initialization profile, place it in the Eclipse / .config directory. This no longer appears in the new workspace when the new workspace is started.
Find the Java runtime environment (JRE). By default, Eclipse first looks for the EXLIPSE / JRE subdirectory. If not found, Eclipse will find the Java runtime environment registered in the system. Note: -VM DIR-Location parameters can be used to specify other JREs. The configuration is created as part of the new work area. The new workspace usually does not have any configuration, so you will see an icon before the real Splash icon, inform you to the installation settings. Handle those feature and plugins that register to Eclipse and create checksums that will be used later to detect changes. These features and plugins are located in the current Eclipse / Features directory, or in the Eclipse / ... directory structure specified by the link file. Once the Eclipse starts, the active configuration definition will be included in the .metadata / .config / platform.cfg file. Link file How to extend an Eclipse installation setting If you have already used Eclipse or add even a new plugin in your configuration, you must know that Eclipse / Features directory and Eclipse / Plugins directory look for functions Parts and plugins. But do you know that Eclipse will also go to the file system to find features and plugins? If there is a format correct link file in the Eclipse / Links directory, these files will be processed, associated features and plugins (including plugins with no related feature) are available in runtime configurations. A link file is just an arbitrary file named ID.LINK, where ID is usually the ID of the root function component being referenced. You can define not only one feature in the link file target, and the name is named foo.LINK is also acceptable. A link file containing the following: path = e: /eclipse-2.1.1/installedfeatures will find the Eclipse / Features directory and the Eclipse / plugins directory to see if there is a legitimate component. And / or plugin. That is, the target directory must contain a / eclipse directory. If found, the additional feature and plugin will be available in the runtime configuration, if the link file is added after the workspace is created, the additional functional part and the plugin will be processed as a new configuration change. Use link files to customize your own Eclipse installation settings to discuss in this document later using link file management Eclipse installation settings. Configuration Update - Add a feature If a new feature and the plugin used to use to the existing / features directory and / plugins directory, or register with Eclipse through a link file, the changes in the checksum will trigger Configure the processing process. This process is performed after a simple Splash-Flash. The new functional component is handled as a configuration change and displays a dialog box for configuring changes. For example, if you open a standard Eclipse unzipped environment workspace, then find Eclipse Examples, you decompress it into the same directory tree in Eclipse, or add a link file to indicate where this example is decompressed. There will be a dialog shown in Figure 1. Figure 1. Configure the change dialog, so if you see a dialog that is similar to this, because when you run a configuration program, you or others have modified the configuration of the Eclipse, and the platform found new Or update the available functional components. If an entry can be selected, you can add this change to your current configuration.
If an entry is disabled, there is a problem with configuration, which cannot be added. Press the ERROR DETAILS button to view information about configuration issues. Configuration management annotations: There is no change in change that you have to accept them right away, you can completely pay attention to it at a quite time, just cancel the choice of the entry, and click Finish. To add them later, you can choose Help> Software Updates> Pending Changes ... to open the dialog again. Changes that have been accepted can be disabled later. Open the Install / Update perspective, select the feature in the Install Configuration view, and then select Disable in the Preview view. Disabled features can also be enabled by similar steps. Click the Show Disabled Features icon in the Install Configuration view to display the disabled features. Functional components can be identified at the running period component Eclipse to allow identification of the active product, and you can also select each of the functional components in the runtime configuration. Functional components must not be identified, you don't identify all your features, but you should identify one. Identification Definition - The key issue of adding identifiers for plug-ins is to understand where to define the identity. You define the identified functionality, but the identified content is from the plugin. The plugin is identical to the ID of the function (default), or the plugin is clearly identified in the definition of the functional component (this is the new function of Eclipse 2.1.1). In Eclipse 2.1, a functional component definition can define other plugins by specifying attribute plugin = ... in the feature.xml file. The plugin contains files for defining and providing identification content. Identification Content Summary The About.ini control file defines the identity of the product level and feature level. The product logo must correctly include the following two aspects:
Functional components must be defined as a possible primary feature, that is, in the feature.xml definition file, you want to include Primary = "True". Functional components must be identified as the primary functional component of the activity, which is usually set in the product in the install.ini file in the / eclipse directory. The main functional components can also be defined by using the -Feature FeatureID startup parameters at the runtime. Understanding the easiest way to mark the identity of the component is to view which elements are defined in the About.ini control file, and how they work in an identified product or feature. Figure 2. Number content available in the Eclipse perspective is only used for product identity:
WindowImage Appname Aboutimage is used during product and feature identity. The value starting with a percent (%) is parsed in the About.properties file. When a functional component is the primary function component, the text defined with the Aboutext keyword is displayed in the About Product dialog. When the user clicks on the Feature Details button, these contents are also displayed in the About Features dialog box. When the feature is added to the running period, the WelcomePage entry is opened, and then you can also open this welcome page by selecting the Eclipse menu option Help> Welcome ... Open this welcome page. The fastest way to build a feasible functional component is to clone an existing feature that can be found in the Eclipse itself. Features and plugins with org.eclipse.platform IDs provide feature identification and plug-in identity. There is a step of detailed guidance instructions in Chapter 34 of the Java Developer's Guide To Eclipse. In the development resource of the Eclipse.org's Update Manager Sub-project, you can find additional details about the identity (see links in the reference). The policy of building a feature development in the Java Developer's Guide to Eclipse is introduced in the Java Developer's Guide to Eclipse book, and the process of building a feature is introduced in the article "PDE generated plugin" in the Java Developer's Guide to Eclipse. Some other ways. When you understand how to build features and associated plugins, you can complete them automatically. The ANT target implemented by the PDE allows us to start from the functional summary of PDE. PDE will generate a build.xml file for a plugin.xml or feature.xml file. Build.xml is an ANT script that can complete the different tasks required for the functional components of the running schedule and plugins. The PDE build process allows you to generate one or more of the following build destination. Important Function Component Build Objectives: Build.jars calls the build.jars task in the build.xml file for each referenced plugin. Build.UPdate.jar calls the build.Uild.Uld.Uld.Update.jars task in the build.xml file for each referenced plugin. At the same time, you will create an Update JAR for the functional components. This is the default target of the ANT script. Build.Sources calls the build.source task in the build.xml file for each referenced plugin. Zip.distribution Creates a compressed file that contains all files required for the plugin that features and references. Refresh makes Eclipse refreshes the functional part project and any referenced plugin. Important plugin build goals:
Build.jars calls many of the goals in the build.xml file for each running period JAR defined by the plugin. The name called the target is the same as the name of the running JAR file. These targets compile JAVA code and create a JAR file that contains any resources in the source file directory. Build.Update.jar Pack all the required files under all running dial directories into a file that is Plugin.id_version.jar, where pop.id and version are from the Plugin.xml file. This is the default target of the ANT script. Build.Sources Create a compressed package of a Java source file based on the source file directory defined by a given period JAR file. Zip.plugin Creates a compressed package that contains all the contents you need to plugin. Refresh makes the Eclipse refreshes the plugin project. Note: During the ANT processing of the functional components and plugins, update the JAR or the file packaged during the processing of the compression package is those required by the running period environment. These contents are described in the runtime JAR file of the functional component or plugin's build.properties file and each plugin defined in PLUGIN.XML, by bin.includes or bin.excludes entry. In order to build a plugin, you may specify Clean, Build.Sources, Build.jars, Zip.plugin, Refresh. In order to build a functional component, you may specify Clean, Build.Sources, Build.jars, Zip.Distribution, refresh. You may want to use clean when you start using Clean to enforce all results, often there will be this situation. Although the Ant processing process will re-execute the desired steps based on the input change, some changes do not trigger all required processing procedures. Test results show that if you change a Java source file, the corresponding source file compression package will be updated, but the class will not be recompiled, and the running period JAR will not be updated. Therefore, it is recommended that you will clear the output results first to ensure that you are using the running period corresponding to the current source file after rebuilding. The discussion scheme is for discussion, we first describe the content required in the runtime configuration when only one functional component and plug-in are. Component Structure Sample Component Type File Function Components Feature.xmlfeature_Image.jpg / License / License.html / License / license.pdf / Plan / Project-Plan.doc Plugin PLUGIN.XML / IMAGES / ACTION.GIF / Images / Editor.gif / SRC / CO / PKG / ID / ACTION.JAVA / SRC / CO / PKG / ID / Editor.java / Design-DOCS / PLUG-IN.DOC / Design-DOCS / Editor.doc is as the file name you see, Although most of these files belong to the runtime environment, there are still some files that you want to share with others (for example, your design documentation). Contains policies - indicate that the required parts are at least until the beginning, the easiest way is to list the part you want to package during the construction process as part of the feature or plugin in the runtime configuration. The corresponding build.properties file is shown below: Build.Properties content
Component build.properties file content features bin.includes = feature.xml, / license / plugin Source.Runtime.jar = src / bin.includes = plugin.xml, / images / rejection policy - Specify unwanted or private Some of the other way is to list some of the parts you don't want to pack in the construction process as part of the functional component or plugin. This not only includes files you don't want to share, but also include files and directories created during the build process (there are some temporary). The build.properties file used in this method is as follows: build.properties
Component build.properties file content features Bin.ExCludes = Temp.Folder /, / com.ibm.master.lab.core_1.0.0.bin.dist.zip, / .classpath, / .project, / build.xml, / Build.properties plugin bin.excludes = Temp.Folder /, / bin /, / .classpath, / .project, / build.xml, / build.properties, / makeesrczip.xml, / src / if gived features or plugins The ID value is com.your.feature.id or com.your.plugin.id, then you need to include the following entry in the file when using the rejection policy: com.your.feature.id_1.0.0.bin.dist .zip, / com.your.feature.id_1.0.0.jar, / com.your.plugin.id_1.0.0.jar, / zip entry will make the generated component compressed package is not included in the Update JAR or component compression package itself . The JAR entry will enable the generated features or plugins of the Update Jar from being compressed by the component compression package or Update Jar itself. When your component compressed package or Update Jar looks larger than it should be large, or you should have a jump growth in each time you compile time, you should perform the above steps. You need to add the above entry to the above entry to solve this problem in the build.properties file of the appropriate feature or plugin. In addition to the above mentioned, the response to file or structure is mentioned above, it is necessary to consider the necessary response when a new file or directory is added to the feature or plugin. We mean that you have to make your feature and plug-in to cope with possible changes, that is to say they need a feature.properties file and a plugin.properties file. When you use a policy, you need to add an appropriate property to the .properties file, if you use the rejection policy, you don't have to do this. No matter which method, if you add a file to a directory, you don't need to do anything else. For newly added files, if you use a policy, it will be sent, if you use a rejection policy, it will not be sent. This is actually the reason you may have to consider using different directorys to store different files. For example, the directory where all images used by your plug-in should be included, while a directory of the design discussion or documentation of the plugin during development is. The worst case is when you have forgotten to update the build.properties: a product that will fail or generate an error-free product. If you are using a policy, newly added files or directories are unavailable after packaging, this may cause your plugin to not use or display the Eclipse default icon (red box). If you add a new file or directory using the rejection policy, the contents of these files or directories are included in the packaging process. Depending on your style, choose the right method, thereby minimizing the risk of forgetting to perform updates. This will depend on the main problem you face: Is the feature or plugin that cannot be run, or other people should not see the files in the running directory. Organizational Function When you develop your tool, do you take into account how many plugins do you need? The answer is at least three: one is your model, that is, the core part of the non-UI, one is your UI content, and one or more is used to provide help. If you pay attention, you will find that this is the basic mode of Eclipse itself (JDT.core, JDT.UI, JDT.Doc; debug.core, debug.ui; etc.).
One of the reasons why this is that the plug-in for the UI requires a different Eclipse component support relative to the plug-in not for the UI, org.eclipse.ui. Contains Other Function Components Functions If they are not included in the other features, they are configured to root functionality in the Eclipse configuration. By default, the root functionality can be disabled or enabled by the user in the Install / Update perspective, and you can determine a URL in the feature.xml file. When a functional component is included, only the update URL in the root feature unit will be processed, otherwise it can only be defined by Search-Location. By including the functional components, you can manage the organizational structure of the package. You may have multiple features, but there is only one identifier, the rest or is used to constitute a structure, or to manage components. Keep in mind that the root function component defines the updated site, although this role can be delegated to the functional components contained in the function, by setting the search-location attribute value Selfboth. If you are building an eclipse-based product, you may want your feature to include the Eclipse feature tree. This is not needed for identifying this product, but you can specify additional update sites (Eclipse yourself use http://update.eclipse.org/updates), or do not specify an update site at all, disable web-based updates . The role of optional features When you contain a functional component to another, you can choose whether to set it to optional. The main reason is that the creation of such a structure allows users to disable part of the components you provide according to his own needs. When the new features include optional features, those optional features do not exist, the Eclipse configuration logic does not allow this new feature. That is, if appropriate prerequisites are established, optional features can be used to create a layer structure. However, these layers need to be stored under different directory trees and each layer uses a separate linked file. You can add a limited number of restrictions on the Eclipse configuration to increase their features. Let Eclipse (or any Eclipse product) work in your way now two points: The specified main feature controls the identity and default properties of the entire product, Eclipse can be in the installation configuration directory or any link Find components under the Eclipse directory structure. This means you can change Eclipse (there is related risk, but just mean you when you modify it!). These changes can help you manage Eclipse-based installation configurations and support it to support your personal preferences. Use link files to manage Eclipse installation configurations You may want to manage more management, rather than all plugins (I hope to be referenced by features) under your Eclipse directory tree . If you need to update Eclipse, you don't want to add a new Eclipse or look for the features and plugins you want in the list. Below is a method of organizing your Eclipse or Eclipse-based product and components with link files:
Keep Eclipse or Eclipse-based products are clean. That is, don't add any of your functional components or plugins to the Eclipse / Features and Eclipse / Plugins directory. Create an Eclipse / Links directory and an Eclipse / links-out directory in an existing Eclipse directory. If you use an Eclipse-based product, there may already have an Eclipse / Links-Out directory. This catalog is not special, just a place to facilitate the storage of unused link files. Create one or more add-Ons directories for the features and plugins that you want to add to your configuration. Under these directories, create an Eclipse / FeatureS and an Eclipse / PLUGINS directory structure. Create a link file in the Eclipse / Links-Out directory for each add-overs directory. Copy the link files you currently have to your activity configuration to the Eclipse / Links directory. For example, assume that you extract Eclipse to a directory named Eclipse-2.1.1, then create a Add-ons directory called CoolTools, and placed in the Eclipse-2.1.1 directory. In the CoolTools directory, you can have multiple directories, each directory for one or a tool you want to add to the Eclipse. Your directory structure may be shown in Figure 3. Figure 3. Link file directory structure EditorList.Link files To include one of them (not all) Path = D: /eclipse-2.1.1/cooltools/EditorListPath=d: //eclipse-2.1.1//cooltools The // EditorList slant is a (/) or two (//) depends on the directory structure. Confirm that the entry should not end with spaces, because this Eclipse will ignore it - I used a link file for the first time to understand this. If you use a new workspace to launch Eclipse, all Eclipse comes with features and plugins found through link files are available. If you want to add a link file and restart the Eclipse using an existing workspace, the Configuration Changes dialog box will pop up. If you delete a link file (very simple, just move it to the / links-out directory), the configuration changes will also be noted by Eclipse, but you can see just splash-flash. In fact, you don't have to move the link file into the transfer to control the configuration, and better ways to use the Install / Update perspective to adjust the configuration. Of course, the premise that you can do is that your plugin belongs to the feature (see, this is another reason for the functional components). Adjustments configured using Eclipse will be discussed later. Use the Install / Update perspective to modify the configured root functional components, as well as any defined feature, can be disabled in the current configuration. After being disabled, the functionality can still be recognized by the platform; they are only no longer included in the current runtime configuration. Let's talk about adding Eclipse Examples to the active configuration. After adding, we can use the Install / Update perspective to disable it. If you are opening an install / update perspective that contains Eclipse Examples configured, you will see as shown in Figure 4.
Figure 4. Eclipse Examples feature in the Install / Update perspective Click the Disable Now button in the Preview view, you can temporarily remove the Eclipse Examples feature from the runtime configuration. After clicking, Eclipse will prompt you to restart the platform to make the configured changes. The Eclipse Examples feature will no longer visible in the current configuration (or not active). In order to see this feature again and enable, you need to click the Show Disabled Features switch button in the Install Configuration view (see Figure 5). Figure 5. Disabling the Eclipse Examples feature in the Install / Update perspective Because the Eclipse Examples feature is a root functionality, you can do this. If you browse other features in the Eclipse SDK, you will find that they have no corresponding disable now buttons in the Preview view, because they are defined as required. If you use Eclipse SDK, you should have a default configuration platform, JDT, and PDE. If you are doing some plug-ins, you don't need PDE - or in some cases, you don't need JDT - you can disable these features as long as you do a small modification for Eclipse. Open the feature.xml file of the org.eclipse.platform.sdk.win32 feature, modify the following lines to contain optional = "true" properties. Listing 1. Disable PDE and JDT
Optional = "true" /> Now you can select these features and disable them in the Install Configuration view. If all previously mentioned those defined as optional features are disabled, the platform can still be run. Also, you can re-enable them at any time. Figure 6 is a disabled functional component displayed in the Install Configuration view of the INSTALL Configuration view. Figure 6. Disabling Eclipse Multiple Features These Disabled / Enable settings are valid only for the current workspace. You can have additional activity workspaces, which contain some or all of the features that are disabled in the current workspace. This simple example illustrates the advantages of using the functional components (they can be disabled) and using link files to add all possible features to your configuration. Disable the features you don't need in a given work area so you can optimize the current configuration. Define your own global properties Eclipse is an excellent tool, but like any tool, you have to customize it, it can be perfect. Tools provide property pages to allow you to change the behavior or visual display of the tool. Latest statistics, there are 62 attributes pages in Eclipse. Almost every time you use a new tool, you will find some options you want to modify. But when you use multiple workspaces, or in a team's environment, some options need to be coordinated with others, so that there is a best management of the options in cross-workspace and coordination with others. problem. Eclipse provides features for import / export properties. In any property dialog box, you can export attributes into a .epf file. This file can be imported again when using other workspaces or sharing with others. You can even add it to the project with team members so that everyone can get standard properties. But this will become monotonous and boring, and if you have forgotten, you will be troublesome. When using Eclipse or any Eclipse-based product, you should realize that there is another method to define global properties. You can customize the default value of the properties by modifying the Plugin_Customization.ini file of the primary feature. You can find the primary feature in the install.ini file in the Eclipse directory. For example, the contents of Install.ini in the standard Eclipse decompression are as follows: Listing 2. The standard Eclipse decompressed content in install.ini content # install.ini # java.io.properties file (ISO 8859-1 with "/" escapes) # This file does not need to be translated. # Required Property "feature.default.id" Contains the id of the primary feature # (The Primary Feature Controls Product Branding, Splash Screens, and Plug-In Customization) Feature.default.id = org.eclipse.platform # Required property "feature.default.Application" Contains id of the core # Application That Gets Control on Startup. for Products with a ui, this # is always org.eclipse.ui.Workbench; for "Headless" Products, this is product-specific. Feature.default.Application = org.eclipse.ui.Workbench Feature.default.id = ... Specifies the default main feature. It should be noted that by using the -feature option when starting Eclipse, other features can be declared as main. Like most of the functional components, the actual work is done in a plugin associated with the functional component. For Eclipse, this is the same plugin as the functionality, org.eclipse.platform plugin. If you carefully view this plugin as a primary feature identifier, you will find a file called Plugin_Customization.ini. The content of this file is similar to the file export attribute. This file is read when the Eclipse starts and is used to specify all the default attribute values, not those values defined by the plugin itself. This makes the product, or you can change the behavior of the plugin. The content of the default plugin_customization.ini file has only one: Listing 3. Default Plugin_Customization.ini file # plugin_customization.ini # sets default values for plug-in-specific preferences # keys area qualified by plug-in ID # E.g., com.example.acmeplugin / myproperty = myvalue # java.io.properties file (ISO 8859-1 with "/" escapes) # "% KEY" Are Externalized strings defined in plugin_customization.properties # This file does not need to be translated. # Property "Org.eclipse.ui / defaultperspectiveID" Controls the # Perspective That The Workbench Opens Initially Org.eclipse.ui / defaultPerspectiveID = Org.eclipse.ui.resourcePerspective This entry specifies the perspective of opening a new work area and turning off the Eclipse when you turn off all perspective. This entry may vary if you use Eclipse-based products. Specifies the process of the process to be included, but at least you should do the following steps: Start a clean work area. Modify an attribute you want to change. Export attributes to a .epf file. Find new health in the exported file and determine if it reflects the changes you have just made. Copy the entry of one or more keys to the lauGin_customization.ini file of the ORG.ECLIPSE.PLATFORM when using Eclipse when using Eclipse. Test results, or keep new keys, or try again. Note: If you are not accustomed to updating the Plugin_Customization.ini file of the product, you can create a copy of this file in other locations, using parameters when you start Eclipse or Eclipse-based products to specify it. Eclipse -plugincustomization mycustomdefaults.ini The overall property examples have previously mentioned the description of related technologies, and proposes suggestions for some values you might want to include the Plugin_Customization.ini file you customized, here, the sample properties rewrite, as the front two aspects Description of the content. We will introduce them to some parts of my customized purpose in logically. You can download a full plugin Customization.ini file. View the default is at the bottom, but I like to put them at the top: # View Tabs At the Bottom Org.eclipse.ui.Workbench / View_tab_position = 128 When the new work area is opened, the welcome page is not opened, and it will not be prompted when shutting down the workbench: # No Welcome Dialog At Open and No Confirm on Close Org.eclipse.ui.Workbench / Welcome_Dialog = FALSE Org.eclipse.ui.Workbench / EXIT_PROMPT_ON_CLOSE_LAST_WINDOW = FALSE Disable prompts or other actions when opening a new engineering guidelines: # Never change to persft Required by New Project Wizard (No Prompt) Org.eclipse.ui.Workbench / Switch_Perspective_on_project_creation = NEVER Define additional default text fonts: # Default text font (Leaks Into Java Editor) # Note: you have to touch the font page and say ok / apply (probable bug) Org.eclipse.ui.workbench / org.eclipse.jface.textFont = 1 | Lucida Console | 9 | 1 | Windows | 1 | -15 | 0 | 0 | 0 | 700 | 0 | 0 | 0 | 0 | 3 | 2 | 1 | 49 | Lucida Console Note: The font attribute entries are special, and the modifications to it will not take effect immediately. If you access the font properties page, the content defined in front will be displayed, but it will take effect after you choose OK or Apply. I can't let this key save it for Java text fonts. Predefined Additional Java Editor Task Tab: # Add to the default jdt task tags (Todo Should Probably Be Left) Org.eclipse.jdt.core / org.eclipse.jdt.core.compiler.tasktags = Todo, EDU-SOL Double-click the default to the Package Explorer to Go INTO Action: # Package Explorer Gointo on Double Click Org.eclipse.jdt.ui / packageview.doubleClick = packageview.goinTo There are some options that are not defined attributes to be customized. In the .epf file exported to the UI's standard setting, I found that some JDT option values are saved as attributes. This property key is used to inform the JDT UI it wants to read attributes and to change the default UI behavior: # TELLS JDT IT Does Have Some Prefs To Use (Forces a Read of these Values) Org.eclipse.jdt.ui / CustomFiltersActionGroup.org.eclipse.jdt.ui.PackageExplorer. Tag_dummy_to_test_existence = StoredViewPReference: Note: If there is no above, the next two sets of settings will be ignored. Activity Package Explorer filter Saves in the form of attribute values: # Package Explorer Filter - Standard JDT DEFAULTS LIBRARY FILTER Org.eclipse.jdt.ui / org.eclipse.jdt.ui.PackageExplorer.libraryfilter = true Org.eclipse.jdt.ui / org.eclipse.jdt.ui.packageExplorer_patternfilterid_. * = true Org.eclipse.jdt.ui / org.eclipse.jdt.ui.PackageExplorer.PackageDeclarationFilter = true Org.eclipse.jdt.ui / org.eclipse.jdt.ui.packageExplorer_patternfilterid_ * $ *. Class = true Org.eclipse.jdt.ui / org.eclipse.jdt.internal.ui.PackageExplorer.emptyInnerPackageFilter = True Outline view has a display option that reduces the depth of the tree when the content is displayed in the active JDT Java editor. This icon has a suspended helping Go INTO TOP Level Type, which is controlled by the following attributes: # OUTLINE View Gointo Toggle When Using JDT Editor Org.eclipse.jdt.ui / gointotoplevelTypeAction.ischecked = true You may want to try to specify a new default value for more properties, and then check the results in the previously described. You may wish to do these things in a temporary work area, after reaching the purpose of modifying, you can call the PLUGIN_CUSTOMIZATION.INI file for the primary features of the event (do not tell anyone who is taught you this! ). And note that you may find that some other keys have been ignored, I have encountered this situation, because the font is used for JDT, so this entry is added to the Plugin_Customization.ini file, attribute page This change will not be reflected in the whole. Conclusion Functions are Eclipse's behind-the-scenes hero - they are important because they are components of Eclipse configuration management, support product identity, and they are part of the product of building custom solutions on the Eclipse platform. Use features you can: When you work with Eclipse-based products, you can identify the identity of the feature identity to provide which different available features to identify the logo of the product can help further customize Eclipse automatically complete the task in the plugin development environment. Automatically complete the task by disabling / enabling roots Functional components, or use the Install / Update perspective to disable / enable defined as an optionally included feature, you can dynamically change the configuration of a given workspace, so use the feature, it can help you complete the build Some steps of the plug-in, using the custom install / link files mentioned in the text, allowing your Eclipse environment to make your Eclipse environment. Reference
