Patent Description:
European Patent Application Publication No. <CIT> relates to the development of software applications and particularly to component-based applications and their availability over a network. In this context a design tool is described. The design tool is operated in a computer as an application development environment for developing an application. The design tool is structured as a set of plug-ins to a generic integrated design environment (IDE) framework, such as the Eclipse Platform. In addition, it is explained that the Eclipse Platform is built on a mechanism for discovering, integrating, and running modules called plug-ins (i.e., editors and viewers).

Further, the article "<NPL> gives a high-level description of the Eclipse Platform. It also explains that the Eclipse Platform is built on a mechanism for discovering, integrating, and running modules called plug-ins. Each plug-in has a manifest file declaring its interconnections to other plug-ins. For example, a plug-in declares any number of named extension points, and any number of extensions to extension points in other plug-ins. The article also describes the UI and the workbench of the Eclipse Platform. The Eclipse Platform UI paradigm is based on editors, views, and perspectives. An editor can contribute actions to the workbench menus and toolbars.

For example, the present disclosure is directed to a system of one or more computers which can be configured to perform particular operations or actions by virtue of having software, firmware, hardware, or a combination thereof installed on the system that in operation causes or cause the system to perform actions and/or method steps as described herein. An aspect of the present technology relates to a method for accessing a plug-in registry using publicly available tools and publicly available published information; identifying a unique identifier for an integrated development environment editor using the plug-in registry; and adding the unique identifier for the integrated development environment editor to a plug-in installed in an integrated development environment allowing functions of the plug-in to be available in the integrated development environment.

The accompanying drawings, where like reference numerals refer to identical or functionally similar elements throughout the separate views, together with the detailed description below, are incorporated in and form part of the specification, and serve to further illustrate embodiments of concepts that include the claimed disclosure, and explain various principles and advantages of those embodiments.

The methods and systems disclosed herein have been represented where appropriate by conventional symbols in the drawings, showing only those specific details that are pertinent to understanding the embodiments of the present disclosure so as not to obscure the disclosure with details that will be readily apparent to those of ordinary skill in the art having the benefit of the description herein.

While the present technology is susceptible of embodiment in many different forms, there is shown in the drawings and will herein be described in detail several specific embodiments with the understanding that the present disclosure is to be considered as an exemplification of the principles of the present technology and is not intended to limit the technology to the embodiments illustrated.

An Integrated Development Environment (IDE), for example Eclipse, is the foundation for multiple commercial products. Various embodiments of the present technology are described using Eclipse as an exemplary IDE although other IDEs may be used with embodiments of the present technology. For example, the exemplary IDE Eclipse provides its own editors for editing files. For instance, making the same end-user function available in these editors provides consistency for both users and the support staff. A problem solved by embodiments of the present technology is to do so with a minimum amount of duplicated or similar code. The present technology provides a solution by providing a single code base that delivers the same functionality to different IDEs with as little development effort as possible.

Eclipse, an exemplary non-limiting IDE, is designed to support software development across a wide range of computing platforms. Based on an open-source, extension-based architecture, Eclipse has served as the foundation for several commercial products, each providing its own editors for editing files. Various embodiments of the present technology provide systems and methods for enhancing a user interface (UI) to provide an plug-in (i.e., add-on) function in an IDE with a single code base offering uniformity in the UI and internal design while keeping development and maintenance cost to a minimum.

For example, any product extending Eclipse with an editor must abide by certain design restrictions. In Eclipse parlance, these are known as extensions, through which Eclipse can control the lifecycle of the editor as well as interactions with Eclipse. One of these extensions identifies the editor by name in the form of a uniform resource identifier (URI). Although not enforced by a central authority, typically these names are unique because they embed the name of the company or the organization.

Eclipse also provides a mechanism through which a piece of add-on software, also known as a plug-in, can make its functions available to other components in Eclipse. The present technology leverages this mechanism to add the same function to different IDEs as descripted herein.

<FIG> illustrates a system for discovering a unique identifier for an integrated development environment editor so the integrated development environment editor can be recognized by a plug-in as a recipient of functionality of the plug-in according to exemplary embodiments of the present technology. In some implementations, system <NUM> may include one or more servers <NUM>. Server(s) <NUM> may be configured to communicate with one or more client computing platform(s) <NUM> according to a client/server architecture and/or other architectures. Client computing platform(s) <NUM> may be configured to communicate with other client computing platforms via server(s) <NUM> and/or according to a peer-to-peer architecture and/or other architectures. Users may access system <NUM> via client computing platform(s) <NUM>.

Server(s) <NUM> may be configured by machine-readable instructions <NUM>. Machine-readable instructions <NUM> may include one or more instruction modules. The instruction modules may include computer program modules. The instruction modules may include one or more of modules including accessing a plug-in registry using publicly available tools and publicly available published information module <NUM>, identifying a unique identifier for an integrated development environment editor using the plug-in registry module <NUM>, adding the unique identifier for the integrated development environment editor to a plug-in installed in an integrated development environment allowing functions of the plug-in to be available in the integrated development environment module <NUM>, and/or other instruction modules.

In some implementations, server(s) <NUM>, client computing platform(s) <NUM>, and/or external resources <NUM> may be operatively linked via one or more electronic communication links. For example, such electronic communication links may be established, at least in part, via a network such as the Internet and/or other networks. It will be appreciated that this is not intended to be limiting, and that the scope of this disclosure includes implementations in which server(s) <NUM>, client computing platform(s) <NUM>, and/or external resources <NUM> may be operatively linked via some other communication media.

A given client computing platform <NUM> may include one or more processors configured to execute computer program modules. The computer program modules may be configured to enable an expert or user associated with the given client computing platform <NUM> to interface with system <NUM> and/or external resources <NUM>, and/or provide other functionality attributed herein to client computing platform(s) <NUM>. By way of non-limiting example, the given client computing platform <NUM> may include one or more of a desktop computer, a laptop computer, a handheld computer, a tablet computing platform, a NetBook, a Smartphone, a gaming console, and/or other computing platforms such as the computing platform described in <FIG>.

External resources <NUM> may include sources of information outside of system <NUM>, external entities participating with system <NUM>, and/or other resources. In some implementations, some or all of the functionality attributed herein to external resources <NUM> may be provided by resources included in system <NUM>.

Server(s) <NUM> may include electronic storage <NUM>, one or more processors <NUM>, and/or other components. Server(s) <NUM> may include communication lines, or ports to enable the exchange of information with a network and/or other computing platforms. Illustration of server(s) <NUM> in <FIG> is not intended to be limiting. Server(s) <NUM> may include a plurality of hardware, software, and/or firmware components operating together to provide the functionality attributed herein to server(s) <NUM>. For example, server(s) <NUM> may be implemented by a cloud of computing platforms operating together as server(s) <NUM>.

Electronic storage <NUM> may comprise non-transitory storage media that electronically stores information. The electronic storage media of electronic storage <NUM> may include one or both of system storage that is provided integrally (i.e., substantially non-removable) with server(s) <NUM> and/or removable storage that is removably connectable to server(s) <NUM> via, for example, a port (e.g., a USB port, a firewire port, etc.) or a drive (e.g., a disk drive, etc.). Electronic storage <NUM> may include one or more of optically readable storage media (e.g., optical disks, etc.), magnetically readable storage media (e.g., magnetic tape, magnetic hard drive, floppy drive, etc.), electrical charge-based storage media (e.g., EEPROM, RAM, etc.), solid-state storage media (e.g., flash drive, etc.), and/or other electronically readable storage media. Electronic storage <NUM> may include one or more virtual storage resources (e.g., cloud storage, a virtual private network, and/or other virtual storage resources). Electronic storage <NUM> may store software algorithms, information determined by processor(s) <NUM>, information received from server(s) <NUM>, information received from client computing platform(s) <NUM>, and/or other information that enables server(s) <NUM> to function as described herein.

Processor(s) <NUM> may be configured to provide information processing capabilities in server(s) <NUM>. As such, processor(s) <NUM> may include one or more of a digital processor, an analog processor, a digital circuit designed to process information, an analog circuit designed to process information, a state machine, and/or other mechanisms for electronically processing information. Although processor(s) <NUM> is shown in <FIG> as a single entity, this is for illustrative purposes only. In some implementations, processor(s) <NUM> may include a plurality of processing units. These processing units may be physically located within the same device, or processor(s) <NUM> may represent processing functionality of a plurality of devices operating in coordination. Processor(s) <NUM> may be configured to execute modules <NUM>, <NUM>, and/or <NUM>, and/or other modules. Processor(s) <NUM> may be configured to execute modules <NUM>, <NUM>, and/or <NUM>, and/or other modules by software; hardware; firmware; some combination of software, hardware, and/or firmware; and/or other mechanisms for configuring processing capabilities on processor(s) <NUM>. As used herein, the term "module" may refer to any component or set of components that perform the functionality attributed to the module. This may include one or more physical processors during execution of processor readable instructions, the processor readable instructions, circuitry, hardware, storage media, or any other components.

It should be appreciated that although modules <NUM>, <NUM>, and/or <NUM>, are illustrated in <FIG> as being implemented within a single processing unit, in implementations in which processor(s) <NUM> includes multiple processing units, one or more of modules <NUM>, <NUM>, and/or <NUM>, may be implemented remotely from the other modules. The description of the functionality provided by the different modules <NUM>, <NUM>, and/or <NUM>, described below is for illustrative purposes, and is not intended to be limiting, as any of modules <NUM>, <NUM>, and/or <NUM>,may provide more or less functionality than is described. For example, one or more of modules <NUM>, <NUM>, and/or <NUM>, may be eliminated, and some or all of its functionality may be provided by other ones of modules <NUM>, <NUM>, and/or <NUM>. As another example, processor(s) <NUM> may be configured to execute one or more additional modules that may perform some or all of the functionality attributed below to one of modules <NUM>, <NUM>, and/or <NUM>.

<FIG> illustrates an exemplary flow chart for discovering a unique identifier for an integrated development environment editor so the integrated development environment editor can be recognized by a plug-in as a recipient of functionality of the plug-in according to exemplary embodiments of the present technology. The steps of flow chart <NUM> presented below are intended to be illustrative. In some implementations, flow chart <NUM> may be accomplished with one or more additional steps not described, and/or without one or more of the steps discussed. Additionally, the order in which the steps of flow chart <NUM> are illustrated in <FIG> and described below is not intended to be limiting.

In some implementations, flow chart <NUM> may be implemented in one or more processing devices (e.g., a digital processor, an analog processor, a digital circuit designed to process information, an analog circuit designed to process information, a state machine, and/or other mechanisms for electronically processing information). The one or more processing devices may include one or more devices executing some or all of the steps of flow chart <NUM> in response to instructions stored electronically on an electronic storage medium (e.g., electronic storage <NUM>). The one or more processing devices may include one or more devices configured through hardware, firmware, and/or software to be specifically designed for execution of one or more of the steps of flow chart <NUM>.

A step <NUM> may include accessing a plug-in registry using publicly available tools and publicly available published information. Step <NUM> may be performed by one or more hardware processors configured by machine-readable instructions including a module that is the same as or similar to accessing a plug-in registry using publicly available tools and publicly available published information module <NUM>, in accordance with one or more implementations.

A step <NUM> may include identifying a unique identifier for an integrated development environment editor using the plug-in registry. Step <NUM> may be performed by one or more hardware processors configured by machine-readable instructions including a module that is the same as or similar to identifying a unique identifier for an integrated development environment editor using the plug-in registry module <NUM>, in accordance with one or more implementations.

A step <NUM> may include adding the unique identifier for the integrated development environment editor to a plug-in allowing functions of the plug-in to be available in the integrated development environment. Step <NUM> may be performed by one or more hardware processors configured by machine-readable instructions including a module that is the same as or similar to adding the unique identifier for the integrated development environment editor to a plug-in allowing functions of the plug-in to be available in the integrated development environment module <NUM>, in accordance with one or more implementations.

Eclipse is an exemplary, non-limiting IDE that is used with embodiments of the present technology described herein and also provides a mechanism through which a piece of add-on software, also known as a plug-in, can make its functions available to other components in Eclipse. The present technology leverages this mechanism to add the same function to different editors as follows below.

Identify the editors in which the function should be made available.

Collect the unique identifiers of these editors.

Identify the locations where the function should appear in the user interface. For example, a function may appear in the toolbar, a drop-down menu, or a pop-up menu.

To add a function to a drop-down menu, add a menu contribution section to the plug-in's definition file. A user may specify the command that will get control when the menu is selected.

The command specification syntax also allows the specification of when the command is visible. To support multiple editors, the visibility section may start with an OR operator, followed by a list of expressions identifying which editors meet the condition for displaying the command.

Another section in the plug-in's definition file associates a command to the actual code that handles the command. Given the visibility section defined in the previous step, all the editors in the list would invoke the same command when its menu item is selected, thus invoking the same code to handle the command.

The process to add a function to a toolbar or a pop-up menu is similar, the only difference being the location specified in the menu contribution as a user may specify the command that will get control when the menu is selected as described above.

In various embodiments, a novel aspect of the present technology is the sub-steps that an Eclipse editor's unique identifier is discovered using publicly available tools and published information. The sub-steps are as follows:.

In various embodiments, the sub-steps of the present technology (e.g., sub-steps I - X above) work because any editor that plugs into the Eclipse workbench must meet the interface requirements for org. The interface must be published to the Plug-in Registry. The sub-steps of the present technology recognize that the plug-in registry can be accessed easily using a publicly available tool; the information accessed is published, and no reverse engineering is necessary, and the steps to access the information are documented and repeatable.

Installing plug-in development tools is described according to various embodiments of the present technology. The process documented herein relies on plug-in development tools that are a part of the Eclipse inventory as an exemplary IDE. However, not all products based on Eclipse will include the plug-in development tools in their basic installation. To install the plug-in development tools a user may complete the following:.

The Plug-in Development folder and the Plug-in Registry view may be available in the list of views after the installation of plug-in development tools.

In various embodiments of the present technology, knowing which plug-in in the plug-in registry represents the editor to be supported can be a challenge, as the list of plug-ins can contain hundreds of items. An easy way to identify which plug-in may embody the editor in question is to look for something that looks like com. companyname. productname. filetype, where:.

Although this format may not be universally adopted, it is a convention followed closely by most product companies in the Eclipse community.

In various embodiments a unique IDE identifier may be used in another IDE. Thus, a unique IDE identifier may be used in multiple IDE. In various embodiments, steps described above provide the basic procedure for updating a plug-in definition file to allow the same function to appear in multiple editors. The following is an excerpt from an actual definition file, serving as an example for various embodiments:
<extension point="org. menus">
<menuContribution
allPopups="false"
locationURI="menu:edit?after=selectAll">
<command
commandId="com. scanjcl"
id="com. scanjcl"
label="Scan JCL"
style="push">
<visibleWhen checkEnabled="false">
<or>
<with variable="activeEditorId">
<equals
value="org. DefaultTextEditor">
</equals>
</with>
<with variable="activeEditorId">
<equals
value="com. JCLEditor">
</equals>
</with>
</or>
</visibleWhen>
</command>
</menuContribution>
</extension>.

In this example, the two editors that share the same command are identified by:.

Turning to <FIG> though <FIG> that show an exemplary specific use case according to various embodiments of systems and methods for discovering a unique identifier for an integrated development environment editor so the integrated development environment editor can be recognized by a plug-in as a recipient of functionality of the plug-in.

<FIG> illustrates a Graphical User Interface (GUI) showing selection of an integrated development environment editor according to exemplary embodiments of the present technology. For example, selection of a Topaz Editor <NUM> for editing Job Control Language (JCL) for scripting languages used on IBM mainframe operating systems is shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing selection <NUM> of a project for an integrated development environment editor according to exemplary embodiments of the present technology.

<FIG> illustrates a Graphical User Interface (GUI) showing a version of an integrated development environment editor according to exemplary embodiments of the present technology. For example, version <NUM>. <NUM> of Eclipse <NUM> shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing selection of plug-in development tools according to exemplary embodiments of the present technology. For example, selecting Eclipse plug-in development tools <NUM> is shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing opening of a plug-in registry according to exemplary embodiments of the present technology. For example, opening plug-in registry <NUM> is shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing locating an integrated development environment editor in a plug-in registry according to exemplary embodiments of the present technology. For example, locating an integrated development environment editor in a plug-in registry <NUM> is shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing identifying a unique identifier for an integrated development environment editor according to exemplary embodiments of the present technology. For example, identifying a unique identifier <NUM> for an integrated development environment is shown in <FIG>. For instance, the unique identifier <NUM> for an integrated development environment is an item named id = <some identifier>, which is the unique identifier for an integrated development environment editor that is used in a definition file of the plug-in. The unique identifier <NUM> for an integrated development environment is id = "com. JCLEditor" as shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing adding a unique identifier for an integrated development environment editor to a plug-in according to exemplary embodiments of the present technology. For instance, the unique identifier for an integrated development environment "com. JCLEditor" <NUM> is shown being added to the plug-in as shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing installing a plug-in according to exemplary embodiments of the present technology. For example, installing the plug-in <NUM> with the unique identifier for an integrated development environment "com. JCLEditor" is shown in <FIG>.

<FIG> illustrates a Graphical User Interface (GUI) showing functions of a plug-in available in an integrated development environment according to exemplary embodiments of the present technology. As a result of adding the unique identifier for an integrated development environment to the plug-in, functions of the plug-in are available in an integrated development environment as shown in <FIG>. The two extra buttons <NUM> (one button looks like a magnifying glass over a sheet of paper and the other button is a sheet of paper with a red arrow over it on the left side). The two extra buttons <NUM> in <FIG> are not present in <FIG>, indicating that the newly installed plug-in recognizes the integrated development environment editor because the unique identifier of the integrated development environment editor has been provided to the plug-in allowing functions of the plug-in to be available in the integrated development environment.

<FIG> illustrates a Graphical User Interface (GUI) showing adding another integrated development environment according to exemplary embodiments of the present technology.

<FIG> illustrates a Graphical User Interface (GUI) showing the same plug-in is available in another integrated development environment according to exemplary embodiments of the present technology. <FIG> shows that the two extra buttons <NUM> (one button looks like a magnifying glass over a sheet of paper and the other button is a sheet of paper with a red arrow over it on the left side) shown in <FIG> now appear in <FIG> in a different location in the Graphical User Interface (GUI). For example, <FIG> shows the two extra buttons <NUM> in the center of the toolbar, above the box with the text "Scan JCL on z/OS. The presence of two extra buttons <NUM> in the Graphical User Interface (GUI) is an indication that the same plug-in now appears in another integrated development environment editor (i.e., a second integrated development environment) allowing functions of the plug-in to be available in the another integrated development environment editor (i.e., a second integrated development environment).

<FIG> illustrates a computer system for implementing embodiments according to exemplary embodiments of the present technology. <FIG> is a diagrammatic representation of an example machine in the form of a computer system <NUM>, within which a set of instructions for causing the machine to perform any one or more of the methodologies discussed herein may be executed. In various example embodiments, the machine operates as a standalone device or may be connected (e.g., networked) to other machines. In a networked deployment, the machine may operate in the capacity of a server or a client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular telephone, a portable music player (e.g., a portable hard drive audio device such as an Moving Picture Experts Group Audio Layer <NUM> (MP3) player), a web appliance, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term "machine" shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

The example computer system <NUM> includes a processor or multiple processor(s) <NUM> (e.g., a central processing unit (CPU), a graphics processing unit (GPU), or both), and a main memory <NUM> and static memory <NUM>, which communicate with each other via a bus <NUM>. The computer system <NUM> may further include a video display <NUM> (e.g., a liquid crystal display (LCD)). The computer system <NUM> may also include an alphanumeric input device(s) <NUM> (e.g., a keyboard), a cursor control device (e.g., a mouse), a voice recognition or biometric verification unit (not shown), a drive unit <NUM> (also referred to as disk drive unit), a signal generation device <NUM> (e.g., a speaker), and a network interface device <NUM>. The computer system <NUM> may further include a data encryption module (not shown) to encrypt data.

The disk drive unit <NUM> includes a computer or machine-readable medium <NUM> on which is stored one or more sets of instructions and data structures (e.g., instructions <NUM>) embodying or utilizing any one or more of the methodologies or functions described herein. The instructions <NUM> may also reside, completely or at least partially, within the main memory <NUM> and/or within the processor(s) <NUM> during execution thereof by the computer system <NUM>. The main memory <NUM> and the processor(s) <NUM> may also constitute machine-readable media.

The instructions <NUM> may further be transmitted or received over a network via the network interface device <NUM> utilizing any one of a number of well-known transfer protocols (e.g., Hyper Text Transfer Protocol (HTTP)). While the machine-readable medium <NUM> is shown in an example embodiment to be a single medium, the term "computer-readable medium" should be taken to include a single medium or multiple media (e.g., a centralized or distributed database and/or associated caches and servers) that store the one or more sets of instructions. The term "computer-readable medium" shall also be taken to include any medium that is capable of storing, encoding, or carrying a set of instructions for execution by the machine and that causes the machine to perform any one or more of the methodologies of the present application, or that is capable of storing, encoding, or carrying data structures utilized by or associated with such a set of instructions. The term "computer-readable medium" shall accordingly be taken to include, but not be limited to, solid-state memories, optical and magnetic media, and carrier wave signals. Such media may also include, without limitation, hard disks, floppy disks, flash memory cards, digital video disks, random access memory (RAM), read only memory (ROM), and the like. The example embodiments described herein may be implemented in an operating environment comprising software installed on a computer, in hardware, or in a combination of software and hardware.

One skilled in the art will recognize that the Internet service may be configured to provide Internet access to one or more computing devices that are coupled to the Internet service, and that the computing devices may include one or more processors, buses, memory devices, display devices, input/output devices, and the like. Furthermore, those skilled in the art may appreciate that the Internet service may be coupled to one or more databases, repositories, servers, and the like, which may be utilized in order to implement any of the embodiments of the disclosure as described herein.

In the description, for purposes of explanation and not limitation, specific details are set forth, such as particular embodiments, procedures, techniques, and so forth, in order to provide a thorough understanding of the present technology. However, it will be apparent to one skilled in the art that the present technology may be practiced in other embodiments that depart from these specific details.

The specific embodiments of, and examples for, the system are described above for illustrative purposes as those skilled in the relevant art will recognize. For example, while processes or steps are presented in a given order, alternative embodiments may perform routines having steps in a different order, and some processes or steps may be deleted, moved, added, subdivided, combined, and/or modified to provide alternative or sub-combinations. Each of these processes or steps may be implemented in a variety of different ways. Also, while processes or steps are at times shown as being performed in series, these processes or steps may instead be performed in parallel, or may be performed at different times.

Claim 1:
A method for discovering a unique identifier for an integrated development environment editor so the integrated development environment editor can be recognized by a plug-in as a recipient of functionality of the plug-in, the method comprising:
accessing (<NUM>) a plug-in registry (<NUM>, <NUM>) using publicly available tools and publicly available published information;
identifying (<NUM>) a first unique identifier for a first integrated development environment editor of a plurality of integrated development environment editors using the plug-in registry (<NUM>, <NUM>);
identifying a second unique identifier for a second integrated development environment editor of the plurality of integrated development environment editors using the plug-in registry (<NUM>, <NUM>);
adding (<NUM>) the first unique identifier for the first integrated development environment editor to a definition file of a plug-in installed in an integrated development environment allowing functions of the plug-in to be available to the first integrated development environment editor in the integrated development environment; and
adding the second unique identifier for the second integrated development environment editor to the definition file of the plug-in installed in the integrated development environment allowing the functions of the plug-in to be available to the second integrated development environment editor in the integrated development environment;
wherein the functions of the plug-in are available for being invoked by the first integrated development environment editor and the second integrated development environment editor.