Laboratoire ICAR » Plateforme TXM

<?xml version="1.0" encoding="UTF-8"?>

<?eclipse version="3.2"?>

<plugin>

   <extension-point id="xmlCommandHandlers" name="XMLCommandHandlers" schema="schema/xmlCommandHandlers.exsd"/>

   <extension-point id="defineMacro" name="Define a macro" schema="schema/defineMacro.exsd"/>

   <extension-point id="scriptingSupport" name="Macro Scripting Support" schema="schema/scriptingSupport.exsd"/>

   <extension

         point="org.eclipse.core.runtime.preferences">

      <initializer

            class="practicallymacro.preferences.Initializer">

      </initializer>

   </extension>

   <extension

         point="org.eclipse.ui.actionSets">

      <actionSet

            id="com.none.playActionSet"

            label="EditorMacros.PlayActionSet"

            visible="true">

         <action

               class="practicallymacro.actions.PlayDropdownAction"

               definitionId="practicallymacro.actions.playLastMacro"

               icon="icons/play.gif"

               id="practicallymacro.actions.playMacroAction"

               label="&Play Macro"

               style="pulldown"

               toolbarPath="Normal/additions"

               tooltip="Play Macro">

<!--            <enablement>

            	<or>

               		<objectClass name="org.eclipse.jface.text.ITextSelection"/>

               		<objectClass name="org.eclipse.core.resources.IFile"/>

               	</or>

            </enablement>

            -->

          </action>

         <action

               class="practicallymacro.actions.RecordCommandAction"

               definitionId="practicallymacro.actions.recordMacro"

               icon="icons/record.gif"

               id="practicallymacro.actions.recordMacroAction"

               label="&Record Macro"

               retarget="false"

               state="false"

               style="push"

               toolbarPath="Normal/additions"

               tooltip="Record Macro">

            <!--<enablement>

            	<or>

               		<objectClass name="org.eclipse.jface.text.ITextSelection"/>

               	</or>

            </enablement>-->

         </action>

      </actionSet>

   </extension>

   <extension

         point="org.eclipse.ui.commands">

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.PlayHandler"

            description="Play the last recorded macro"

            id="practicallymacro.actions.playLastMacro"

            name="Play last macro"/>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.QuickPlayHandler"

            description="Play a command"

            id="practicallymacro.actions.quickExecuteCommand"

            name="Quick Play Command"/>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.RecordHandler"

            description="Record a new macro"

            id="practicallymacro.actions.recordMacro"

            name="Record Macro"/>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.PlayCommand"

            description="Play any defined command"

            id="practicallymacro.actions.playCommand"

            name="Play command"/>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.MarkSelectionStart"

            description="Set the mark at the location of the current selection start."

            id="practicallymacro.actions.markSelectionStartCommand"

            name="Mark selection start"/>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.MarkSelectionEnd"

            description="Set the mark at the location of the current selection end"

            id="practicallymacro.actions.markSelectionEndCommand"

            name="Mark selection end"/>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.MoveCursorToMark"

            description="Set the cursor at the last mark location"

            id="practicallymacro.actions.setCursorAtMarkCommand"

            name="Set cursor at mark"/>

      <category

            description="Editor macros defined by the user"

            id="practicallymacro.category.usermacros"

            name="User defined editor macros">

      </category>

      <category

            description="Utiliity commands for recording editor macros"

            id="practicallymacro.category.utility.command"

            name="PracticallyMacro utility command">

      </category>

      <command

            categoryId="practicallymacro.category.utility.command"

            defaultHandler="practicallymacro.commands.ExtendSelectionToMark"

            description="Extend the current selection to the current mark position, or the current cursor position if there is no mark.  If there is no selection, use the current cursor position."

            id="practicallymacro.actions.extendSelectionToMarkCommand"

            name="Extend selection to mark">

      </command>

   </extension>

   <extension

         point="org.eclipse.ui.bindings">

      <key

            commandId="practicallymacro.actions.playLastMacro"

            contextId="org.eclipse.ui.textEditorScope"

            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"

            sequence="M1+M3+P"/>

      <key

            commandId="practicallymacro.actions.recordMacro"

            contextId="org.eclipse.ui.textEditorScope"

            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"

            sequence="M1+M3+R"/>

      <key

            commandId="practicallymacro.actions.quickExecuteCommand"

            contextId="org.eclipse.ui.textEditorScope"

            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"

            sequence="M1+M3+Q"/>

   </extension>

   <extension

         point="PracticallyMacro.xmlCommandHandlers">

      <XMLCommandHandler class="practicallymacro.commands.EclipseCommand" type="EclipseCommand"/>

      <XMLCommandHandler class="practicallymacro.commands.InsertStringCommand" type="InsertStringCommand"/>

      <XMLCommandHandler class="practicallymacro.commands.MacroScriptCommand" type="MacroScriptCommand"/>

      <XMLCommandHandler class="practicallymacro.commands.StyledTextCommand" type="styledTextCommand"/>

      <XMLCommandHandler class="practicallymacro.commands.FindCommand" type="MacroFindCommand"/>

      <XMLCommandHandler class="practicallymacro.commands.KeystrokeCommand" type="MacroKeystrokeCommand"/>

   </extension>

   <extension

         point="org.eclipse.ui.preferencePages">

      <page

            category="practicallymacro.editormacros.optionsPage"

            class="practicallymacro.dialogs.MacroDefinitionsPage"

            id="practicallymacro.editormacros.editingpage"

            name="Editor Macro Definitions">

      </page>

      <page

            class="practicallymacro.dialogs.OptionsPage"

            id="practicallymacro.editormacros.optionsPage"

            name="Practically Macro Options">

      </page>

   </extension>

	<extension point="org.eclipse.help.contexts">

	    <contexts file="helpContexts.xml" />

	</extension>

 <extension

       point="org.eclipse.ui.startup">

    <startup

          class="practicallymacro.editormacros.MacroEarlyStatup">

    </startup>

 </extension>

</plugin>

PracticallyMacro/.settings

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

/org.eclipse.jdt.core.prefs/1.3/Thu Oct  8 21:09:12 2009//

D

<?xml version="1.0" encoding="UTF-8"?>

<?NLS TYPE="org.eclipse.help.contexts"?>

  <contexts>

    <context id="overallHelp">

      <description>Help for Practically Macro plugin</description>

      <topic href="doc/overall.html" label="Practically Macro"/>

    </context>

    <context id="editDialogHelp">

      <description>Help for Practically Macro edit dialog</description>

      <topic href="doc/macroEdit.html" label="Practically Macro macro editing"/>

    </context>

    <context id="managingMacrosHelp">

      <description>Help for Practically Macro edit dialog</description>

      <topic href="doc/macroManage.html" label="Practically Macro macro management"/>

    </context>

  </contexts>

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

PracticallyMacro/META-INF

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

/MANIFEST.MF/1.13/Sat Jan  4 23:52:51 2014//

D

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: PracticallyMacro Plug-in

Bundle-SymbolicName: PracticallyMacro;singleton:=true

Bundle-Version: 0.4.5

Bundle-Activator: practicallymacro.editormacros.Activator

Require-Bundle: org.eclipse.ui,

 org.eclipse.core.runtime,

 org.eclipse.jface.text,

 org.eclipse.ui.workbench.texteditor,

 org.eclipse.ui.editors,

 org.eclipse.ui.console,

 org.eclipse.core.expressions,

 org.eclipse.e4.ui.model.workbench;resolution:=optional,

 org.eclipse.e4.core.contexts;resolution:=optional

Bundle-ActivationPolicy: lazy

Export-Package: practicallymacro.commands,

 practicallymacro.util

Bundle-RequiredExecutionEnvironment: J2SE-1.5

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="EditorMacros" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="EditorMacros" id="defineMacro" name="Define a macro"/>

      </appinfo>

      <documentation>

         This extension point is provided to allow users to publish macros they have defined in plugin form (instead of forcing users to import them from a file).  Users can do this by recording a macro and copying the text from the export dialog.

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="macroDefinition" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="macroDefinition">

      <complexType>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         [Enter extension point usage example here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

</schema>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="PracticallyMacro" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="PracticallyMacro" id="scriptingSupport" name="Macro Scripting Support"/>

      </appinfo>

      <documentation>

         This extension point allows scripting languages to be plugged into the macro script command.  If there are no scripting extension defined, then the macro script command will not be available.

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence minOccurs="1" maxOccurs="unbounded">

            <element ref="scriptSupport"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="scriptSupport">

      <annotation>

         <documentation>

            You should supply a class that implements the IMacroScriptSupport interface.  The main duties of this class are to provide a unique ID, to allow editing of the script in a dialog, and to execute the script (on the main thread) when requested.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn=":practicallymacro.commands.IMacroScriptSupport"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         [Enter extension point usage example here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

</schema>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="EditorMacros" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="EditorMacros" id="com.none.macros.xmlCommandHandlers" name="XMLCommandHandlers"/>

      </appinfo>

      <documentation>

         This extension point is for internal use at this time.  The idea is to associate handlers for reading in previously defined commands.  Since I haven't publicized a way for others to add new commands, this is effectively a private extension.

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="XMLCommandHandler" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="XMLCommandHandler">

      <complexType>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn=":practicallymacro.commands.IMacroCommand"/>

               </appinfo>

            </annotation>

         </attribute>

         <attribute name="type" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         [Enter extension point usage example here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

</schema>

/defineMacro.exsd/1.1/Wed Oct 22 22:12:13 2008//

/scriptingSupport.exsd/1.1/Wed Oct 22 22:12:13 2008//

/xmlCommandHandlers.exsd/1.1/Wed Oct 22 22:12:13 2008//

D

PracticallyMacro/schema

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

---how to record

---how to play

---gotchas

----commands you can't use

----recording modes 

---sharing

Practically Macro

================================================================================

Practically Macro is an attempt to add simple editor scripting to the Eclipse platform; it is not an attempt at scripting the Eclipse platform in general.  I believe that editor scripting, while similar to general scripting, is fundamentally a different problem.  The intent of this plug-in is to enable users to record/create editor macros in a lightweight manner that can be used temporarily or easily shared with others.  I have tried to do this in a way that uses public API and public assumptions, and I've mostly been able to do so.  In my opinion, every character entered or navigation button pressed should generate a command that can be recorded.  However, Eclipse doesn't generate commands for everything, so I've done the best I can.

Requirements

--------------------------------------------------------------------------------

Eclipse 3.4 or greater; will not run correctly at 3.3.  Requires the workbench.  Shouldn't require jdt.  

Recording a macro

--------------------------------------------------------------------------------

Start recording a macro by typing Alt+Ctrl+R or clicking the "Record Macro" button on the main toolbar.  The Record button is only enabled when a text editor has input focus.  Once record mode is invoked, the record button will appear depressed.  

Actions that will be captured by recording a macro are Eclipse commands and keystrokes.  Mouse activity is not captured and should be avoided in the editor window.

Once you are done recording a macro, click the "Record Macro" button again.  If you have recorded any macro contents, a Save dialog will pop up allowing you to supply a name/id/description for the macro.  You can cancel if you don't want to keep the macro.  To allow the macro to be persisted across Eclipse invocations or to allow mapping the command to a keystroke, you must supply an ID.  If you only supply a name, the macro can be used during the Eclipse session only.  You can modify/add an ID later in the session. 

Playing a macro

--------------------------------------------------------------------------------

To play a macro, use the drop down menu on the "Play Macro" button.  You can use the "Play command..." button to execute any Eclipse command or macro that is already defined.  If there are user macros defined with ids, they will show up in a menu called "Macros".  Only the last few will be available, and they will be ordered by last used time.  If there are commands that do not have associated ids, they will show up in the submenu named "Temporary Macros", ordered by last used time.  After you have execute a macro, clicking the Play button will execute the last executed macro.

Gotchas

-------------------------------------------------------------------------------

This plug-in is built on top of the Eclipse platform. Unfortunately, the Eclipse command structure is not designed with macro recording in mind.  What this means is that not all commands are recordable, and some behavior may be a little sketchy.  However, you can edit a macro after recording, so you should be able to patch up behavior that isn't desirable.  The lack of an official Eclipse strategy means that there is no guide to what commands should be recordable, so I don't impose any artificial limitations.

Here are some types of actions that make sense to record as part of a macro:

1)typing characters (see note below)

2)navigation characters (ex. arrows, page down)

3)find dialog (I've supplied my own since the standard dialog isn't public)

4)incremental find (with some hacking)

5)previously recorded macros

6)other commands that don't pop up dialogs (ex. file save, find next, organize imports, toggle insert mode)

Here are some types of actions that almost certainly won't work correctly:

1) Commands that bring up dialogs (ex. Go to line)

2) Wizards and other dialogs (ex. Open File)

3) ctrl+space intellisense

4) invoking code templates like "foreach"

Special notes

Certain keystrokes are handled specially by the language editor.  However, these editors don't generate commands associated with their behavior, so they are difficult to interpret.  For example, in a Java file, if you type in a '<', a '>' will be inserted and the cursor will be placed between the two symbols.  Also, the editor is put into a special edit mode so that if you backspace, both characters are deleted.  However, there is no set of commands generated that accomplishes these tasks.  Instead, the editor document captures the initial '<' via a VerifyKeyListener and then does the inserts and sets the mode directly on the document.  Therefore, if you have this setting ("Automatically Close") turned on and type a '<', then the macro will not have any commands corresponding to some of these operations.  You can edit the macro afterward, but that may be inconvenient.  I've added another mode on the Options page that records keys as raw key events and plays them back.  This preserves the behavior of special characters like '<', but is more difficult to edit and may not be sharable with users on other platforms.

Editing macros

------------------------------------------------------------------------------------------

You can edit macros you have recorded via the Window->Preferences->PracticallyMacro Options->Editor Macro Definitions page.  From this page, you can delete existing macros or edit macros.  Select a macro and click the Edit... button.  From the edit dialog, you can reorder commands in the macro, remove commands, add new commands, and edit commands that have data associated with them (ex. the Find command).

The Edit dialog also allows you to add a new macro id to a command that didn't previously have an associated id (thus turning it into a persistent command), or alter the id of an existing command.

Sharing macros

---------------------------------------------------------------------------------------------

From the Editor Macro Definitions page you can export or import macros.  Macros exported to a file can be imported via the import dialog into another eclipse (with the Practically Macro plugins installed, as well as any required plugins/commands).  Macros with ids that already exist in the current Eclipse will be skipped (i.e. they will not replace the current command with that ID).  Also, from the export dialog you can copy the XML from the text box and put that directly into a plugin.xml definition with the following extension point:

   <extension point="PracticallyMacro.defineMacro">

       <include the text from the export page here>

   </extension>

Special macro helper commands

---------------------------------------------------------------------------------------------

1)Mark selection start - set a 'mark' at the current selection start, or at the caret pos if no selection

2)Mark selection end - set a 'mark' at the current selection end, or at the caret pos if no selection

3)Move cursor to mark - Set the editor cursor to the current mark position

4)Insert string - this is the workhorse command used to add text. Can contain carriage returns.

5)Find - perform various kinds of text searching

6)Styled Text commands - These are commands I've added to the system since they aren't commands by default.  Actions like "move cursor right" are supported by the StyledText widget but aren't mapped as key bindings.

7)Macro script - You can write whatever scripts you'd like using beanshell.  I pass in several variables for the editor that should be useful.

The Mark commands are provided as a way to maintain some state while other operations are performed without requiring scripting.  

For example, to comment a selected area, you could record a sequence of commands like:

a)mark selection start

b)move cursor right (puts cursor at end of selection

c)insert string "*/"

d)move cursor to mark

e)insert string "/*"

Macro scripting is embryonic and complicated.  There is some help when you are editing the script itself (via "question mark" help).

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>PracticallyMacro</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

<html>

<h1>Practically Macro</h1>

Practically Macro is an attempt to add simple editor scripting to the Eclipse platform; it is not an attempt at scripting the Eclipse platform in general.  I believe that editor scripting, while similar to general scripting, is fundamentally a different problem.  The intent of this plug-in is to enable users to record/create editor macros in a lightweight manner that can be used temporarily or easily shared with others.  I have tried to do this in a way that uses public API and public assumptions, and I've mostly been able to do so.  In my opinion, every character entered or navigation button pressed should generate a command that can be recorded.  However, Eclipse doesn't generate commands for everything, so I've done the best I can.

<h2>Requirements</h2>

Eclipse 3.4 or greater; will not run correctly at 3.3.  Requires the workbench.  Shouldn't require jdt.  

<h2>Recording a macro</h2>

Start recording a macro by typing Alt+Ctrl+R or clicking the "Record Macro" button on the main toolbar.  The Record button is only enabled when a text editor has input focus.  Once record mode is invoked, the record button will appear depressed.  

Actions that will be captured by recording a macro are Eclipse commands and keystrokes.  Mouse activity is not captured and should be avoided in the editor window.

Once you are done recording a macro, click the "Record Macro" button again.  If you have recorded any macro contents, a Save dialog will pop up allowing you to supply a name/id/description for the macro.  You can cancel if you don't want to keep the macro.  To allow the macro to be persisted across Eclipse invocations or to allow mapping the command to a keystroke, you must supply an ID.  If you only supply a name, the macro can be used during the Eclipse session only.  You can modify/add an ID later in the session. 

<h2>Playing a macro</h2>

To play a macro, use the drop down menu on the "Play Macro" button.  You can use the "Play command..." button to execute any Eclipse command or macro that is already defined.  If there are user macros defined with ids, they will show up in a menu called "Macros".  Only the last few will be available, and they will be ordered by last used time.  If there are commands that do not have associated ids, they will show up in the submenu named "Temporary Macros", ordered by last used time.  After you have execute a macro, clicking the Play button will execute the last executed macro.

<h2>Gotchas</h2>

This plug-in is built on top of the Eclipse platform. Unfortunately, the Eclipse command structure is not designed with macro recording in mind.  What this means is that not all commands are recordable, and some behavior may be a little sketchy.  However, you can edit a macro after recording, so you should be able to patch up behavior that isn't desirable.  The lack of an official Eclipse strategy means that there is no guide to what commands should be recordable, so I don't impose any artificial limitations.<br>

Here are some types of actions that make sense to record as part of a macro:<br>

<ul>typing characters (see note below)</ul>

<ul>navigation characters (ex. arrows, page down)</ul>

<ul>find dialog (I've supplied my own since the standard dialog isn't public)</ul>

<ul>incremental find (with some hacking)</ul>

<ul>previously recorded macros</ul>

<ul>other commands that don't pop up dialogs (ex. file save, find next, organize imports, toggle insert mode)</ul>

<br> 

Here are some types of actions that almost certainly won't work correctly:<br>

<ul>Commands that bring up dialogs (ex. Go to line)</ul>

<ul>Wizards and other dialogs (ex. Open File)</ul>

<ul>ctrl+space intellisense</ul>

<ul>invoking code templates like "foreach"</ul>

<h3>Special notes</h3>

Certain keystrokes are handled specially by the language editor.  However, these editors don't generate commands associated with their behavior, so they are difficult to interpret.  For example, in a Java file, if you type in a '<', a '>' will be inserted and the cursor will be placed between the two symbols.  Also, the editor is put into a special edit mode so that if you backspace, both characters are deleted.  However, there is no set of commands generated that accomplishes these tasks.  Instead, the editor document captures the initial '<' via a VerifyKeyListener and then does the inserts and sets the mode directly on the document.  Therefore, if you have this setting ("Automatically Close") turned on and type a '<', then the macro will not have any commands corresponding to some of these operations.  You can edit the macro afterward, but that may be inconvenient.  I've added another mode on the Options page that records keys as raw key events and plays them back.  This preserves the behavior of special characters like '<', but is more difficult to edit and may not be sharable with users on other platforms.

<br><bold>In general, I recommend running in 'Command' mode and 'typing through' special keystroke modes while recording a macro.</bold>

<h2>Editing macros</h2>

You can edit macros you have recorded via the Window->Preferences->PracticallyMacro Options->Editor Macro Definitions page.  From this page, you can delete existing macros or edit macros.  Select a macro and click the Edit... button.  From the edit dialog, you can reorder commands in the macro, remove commands, add new commands, and edit commands that have data associated with them (ex. the Find command).

The Edit dialog also allows you to add a new macro id to a command that didn't previously have an associated id (thus turning it into a persistent command), or alter the id of an existing command.

<h2>Sharing macros</h2>

From the Editor Macro Definitions page you can export or import macros.  Macros exported to a file can be imported via the import dialog into another eclipse (with the Practically Macro plugins installed, as well as any required plugins/commands).  

<h2>Scripting</h2>

Macro scripting is provided by plugins via an extension point.  See the help for different script types on pref or edit pages for those plugins.  There is no innate scripting provided by the base Practically Macro plugin, but there is a default beanshell plugin paired with the main plugin.  

</html>

<html>

From the edit dialog, you can:<br>

<ul>reorder commands in the macro</ul>

<ul>remove commands</ul>

<ul>add new commands</ul>

<ul>edit commands that have data associated with them (ex. the Find command).</ul>

<br>The Edit dialog also allows you to add a new macro id to a command that didn't previously have an associated id (thus turning it into a persistent command), or alter (or remove) the id of an existing command.

<br>Adding new commands to the macro requires that you have some knowledge of the commands.  There is a filter above the <bold>Available Commands</bold> list that defaults to showing only edit commands (based on looking at categories).  Some commands are not appropriate to a macro, but it's impossible for me to tell what they are, so you may have to experiment.

<h3>Special macro helper commands</h3>

<ul>Mark selection start - set a 'mark' at the current selection start, or at the caret pos if no selection</ul>

<ul>Mark selection end - set a 'mark' at the current selection end, or at the caret pos if no selection</ul>

<ul>Move cursor to mark - Set the editor cursor to the current mark position</ul>

<ul>Insert string - this is the workhorse command used to add text. Can contain carriage returns.</ul>

<ul>Find - perform various kinds of text searching</ul>

<ul>Styled Text commands - These are commands I've added to the system since they aren't commands by default.  Actions like "move cursor right" are supported by the StyledText widget but aren't mapped as key bindings.</ul>

<ul>Macro script - You can write whatever scripts you'd like using beanshell.  I pass in several variables for the editor that should be useful.</ul>

<br>

The Mark commands are provided as a way to maintain some state while other operations are performed without requiring scripting.  

For example, to comment a selected area, you could record a sequence of commands like:

<ol>mark selection start</ol>

<ol>move cursor right (puts cursor at end of selection</ol>

<ol>insert string "*/"</ol>

<ol>move cursor to mark</ol>

<ol>insert string "/*"</ol>

</html>

PracticallyMacro/doc

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

/macroEdit.html/1.1/Wed Oct 22 22:12:13 2008//

/macroManage.html/1.1/Wed Oct 22 22:12:13 2008//

/overall.html/1.1/Wed Oct 22 22:12:13 2008//

D

<html>

<h1>Creating new macros</h2>

Click the <bold>New</bold> button to create a new macro from scratch.

<h1>Deleting Macros</h2>

Select one or more macros to delete and click the delete button.  Macros that are mapped to keystrokes will fail to delete, as will macro contributed by plug-ins.  To delete a macro mapped to a key, you must first remove the key binding.

<h1>Editing Macros</h2>

Click the <bold>Edit</bold> button to edit an existing macro.  Macros contributed from plug-ins cannot be edited.

<h1>Copying Macros</h2>

To copy one or more macros, select them and click the <bold>Copy</bold> button.  Each macro will be copied and added to the list with a new name.  This is useful if you need another similar command, or if you want to see the contents of a macro contributed from a plug-in.

<h1>Sharing macros</h2>

Click the <bold>Export</bold> or <bold>Import</bold> buttons to export or import macros.  Macros exported to a file can be imported via the import dialog into another eclipse (with the Practically Macro plugins installed, as well as any required plugins/commands).  Macros with ids that already exist in the current Eclipse will be skipped (i.e. they will not replace the current command with that ID).  Also, from the export dialog you can copy the XML from the text box and put that directly into a plugin.xml definition with the following extension point:

<br><pre>   &lt;extension point="PracticallyMacro.defineMacro"&gt;

      include the text from the export page here

   &lt;/extension&gt;</pre><br>

When exporting to a file, you can export one macro or a set of macros to the same file.  If a macro uses other macros you have defined, you should export them all together.

</html>

D/actions////

D/commands////

D/dialogs////

D/editormacros////

D/model////

D/preferences////

D/util////

PracticallyMacro/src/practicallymacro

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

/Activator.java/1.5/Sat Nov 10 12:00:39 2012//

/MacroEarlyStatup.java/1.1/Wed Dec 10 23:19:30 2008//

D

PracticallyMacro/src/practicallymacro/editormacros

package practicallymacro.editormacros;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

import practicallymacro.model.MacroManager;

/**

 * The activator class controls the plug-in life cycle

 */

public class Activator extends AbstractUIPlugin {

	// The plug-in ID

	public static final String PLUGIN_ID = "PracticallyMacro";

	// The shared instance

	private static Activator plugin;

	/**

	 * The constructor

	 */

	public Activator() {

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)

	 */

	@Override

	public void start(BundleContext context) throws Exception {

		super.start(context);

		plugin = this;

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)

	 */

	@Override

	public void stop(BundleContext context) throws Exception {

		if (!MacroManager.isNull())

			MacroManager.getManager().saveMacros();

		plugin = null;

		super.stop(context);

	}

	/**

	 * Returns the shared instance

	 *

	 * @return the shared instance

	 */

	public static Activator getDefault() {

		return plugin;

	}

}

package practicallymacro.editormacros;

import org.eclipse.ui.IStartup;

import practicallymacro.model.MacroManager;

public class MacroEarlyStatup implements IStartup {

	public void earlyStartup()

	{

		//this just kicks the manager so that it will load previously defined macros

		//and register commands

		MacroManager.getManager();

	}

}

PracticallyMacro/src/practicallymacro/util

:pserver:anonymous@practicalmacro.cvs.sourceforge.net:/cvsroot/practicalmacro

/MacroConsole.java/1.4/Wed May 27 23:39:14 2009//

/Utilities.java/1.7/Sat Jan  4 23:20:02 2014//

D

package practicallymacro.util;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.eclipse.core.commands.Category;

import org.eclipse.core.commands.Command;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.IHandler;

import org.eclipse.core.commands.IHandlerListener;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IFindReplaceTarget;

import org.eclipse.jface.text.ITextOperationTarget;

import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.ST;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.widgets.Event;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IPartService;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.commands.ICommandService;

import org.eclipse.ui.editors.text.TextFileDocumentProvider;

import org.w3c.dom.CDATASection;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import practicallymacro.commands.EclipseCommand;

import practicallymacro.commands.FindCommand;

import practicallymacro.commands.IMacroCommand;

import practicallymacro.commands.InsertStringCommand;

import practicallymacro.editormacros.Activator;

import practicallymacro.model.MacroManager;

public class Utilities {

	private static Map<Integer, Command> mFillInCommands=new HashMap<Integer, Command>();

	public static final String FillInPrefix="practicallyMacro.styledTextCommand";

	private static Set<String> mEditCategories;

	static

	{

		mEditCategories=new HashSet<String>();

		mEditCategories.add(MacroManager.UserMacroCategoryID);

		mEditCategories.add("org.eclipse.ui.category.edit");

		mEditCategories.add("org.eclipse.ui.category.textEditor");

		mEditCategories.add("org.eclipse.jdt.ui.category.source");

		mEditCategories.add("org.eclipse.jdt.ui.category.refactoring");

		mEditCategories.add(MacroManager.MacroCommandCategoryID);

		mEditCategories.add("eclipse.ui.category.navigate");

		mEditCategories.add(FillInPrefix);

	}

	public static IEditorPart getActiveEditor() {

		IEditorPart editor = null;

		// find the active part

		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();

		if (window!=null)

		{

			IPartService partService = window.getPartService();

			IWorkbenchPart part = partService.getActivePart();

			// Is the part an editor?

			if (part instanceof IEditorPart) {

				editor = (IEditorPart) part;

			}

		}

		return editor;

	}

	public static StyledText getStyledText(IEditorPart editor) {

		if (editor==null)

			return null;

		StyledText styledText = null;

		ISourceViewer viewer = (ISourceViewer)

			editor.getAdapter(ITextOperationTarget.class);

		if (viewer != null) {

			styledText= viewer.getTextWidget();

		}

		return styledText;

	}

//	public static List<Command> getFillInCommands()

//	{

//		if (mFillInCommands.size()>0)

//	}

	private static Command getStyledTextCommand(int styledTextCode)

	{

		if (mFillInCommands.size()==0)

			createStyledTextCommands();

		return mFillInCommands.get(styledTextCode);

	}

	public static List<IMacroCommand> getMacroSupportCommands()

	{

		List<IMacroCommand> commands=new ArrayList<IMacroCommand>();

		commands.add(new InsertStringCommand(null));

		commands.addAll(MacroManager.getManager().getCanonicalScriptCommands());

		commands.add(new FindCommand(""));

		return commands;

	}

	public static void createStyledTextCommands()

	{

		if (mFillInCommands.size()>0)

			return;

		//create styled text commands and fill in map

		int[] styledTextConstants={ST.DELETE_PREVIOUS, ST.LINE_DOWN, ST.SELECT_WORD_PREVIOUS, ST.WORD_PREVIOUS, ST.SELECT_COLUMN_PREVIOUS, ST.COLUMN_PREVIOUS, ST.SELECT_WORD_NEXT

				,ST.WORD_NEXT,ST.SELECT_COLUMN_NEXT,ST.COLUMN_NEXT,ST.LINE_UP,ST.SELECT_TEXT_START,ST.TEXT_START

				,ST.SELECT_LINE_START,ST.LINE_START,ST.SELECT_TEXT_END,ST.TEXT_END,ST.SELECT_LINE_END,ST.LINE_END

				,ST.SELECT_WINDOW_END,ST.WINDOW_END,ST.SELECT_PAGE_DOWN,ST.PAGE_DOWN,ST.SELECT_WINDOW_START

				,ST.WINDOW_START,ST.SELECT_PAGE_UP,ST.PAGE_UP,ST.DELETE_WORD_NEXT,ST.CUT,ST.DELETE_NEXT,ST.COPY

				,ST.PASTE,ST.TOGGLE_OVERWRITE,ST.SELECT_LINE_UP, ST.SELECT_LINE_DOWN, ST.DELETE_WORD_PREVIOUS};

		ICommandService cs = MacroManager.getOldCommandService();

		Category cat=cs.getCategory(FillInPrefix);

		cat.define("Styled Text Commands", "");

		for (int i = 0; i < styledTextConstants.length; i++)

		{

			int constant = styledTextConstants[i];

			Command newCommand=cs.getCommand(FillInPrefix+"."+Integer.toString(constant));

			newCommand.define(getNameForStyledTextConstant(constant), "", cat);

			newCommand.setHandler(new StyledTextHandler(constant));

			mFillInCommands.put(constant, newCommand);

		}

	}

	public static IMacroCommand getCommandForKeyEvent(Event event)

	{

		final int key = (SWT.KEY_MASK & event.keyCode);

		if ((key != 0 && !Character.isISOControl(event.character)))

		{

			return new InsertStringCommand(new String(new char[]{event.character}));

		}

		boolean isCtrl=((event.stateMask & SWT.MOD1) > 0); //ctrl

		boolean isShift=((event.stateMask & SWT.MOD2) > 0);  //shift

		switch (key)

		{

			case SWT.BS:

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.DELETE_WORD_PREVIOUS).getId());

				else

					return new EclipseCommand(getStyledTextCommand(ST.DELETE_PREVIOUS).getId());

			case SWT.ARROW_DOWN:

				if (isShift && !isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_LINE_DOWN).getId());

				else if (!isCtrl && !isShift)

					return new EclipseCommand(getStyledTextCommand(ST.LINE_DOWN).getId());

			case SWT.ARROW_LEFT:

				if (isCtrl && isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_WORD_PREVIOUS).getId());

				else if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.WORD_PREVIOUS).getId());

				else if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_COLUMN_PREVIOUS).getId());

				return new EclipseCommand(getStyledTextCommand(ST.COLUMN_PREVIOUS).getId());

			case SWT.ARROW_RIGHT: 

				if (isCtrl && isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_WORD_NEXT).getId());

				else if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.WORD_NEXT).getId());

				else if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_COLUMN_NEXT).getId());

				return new EclipseCommand(getStyledTextCommand(ST.COLUMN_NEXT).getId());

			case SWT.ARROW_UP: 

				if (isShift && !isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_LINE_UP).getId());

				else if (!isCtrl && !isShift)

					return new EclipseCommand(getStyledTextCommand(ST.LINE_UP).getId());

			case SWT.HOME:

				if (isCtrl && isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_TEXT_START).getId());

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.TEXT_START).getId());

				if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_LINE_START).getId());

				return new EclipseCommand(getStyledTextCommand(ST.LINE_START).getId());

			case SWT.END: 

				if (isCtrl && isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_TEXT_END).getId());

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.TEXT_END).getId());

				if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_LINE_END).getId());

				return new EclipseCommand(getStyledTextCommand(ST.LINE_END).getId());

			case SWT.PAGE_DOWN: 

				if (isCtrl && isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_WINDOW_END).getId());

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.WINDOW_END).getId());

				if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_PAGE_DOWN).getId());

				return new EclipseCommand(getStyledTextCommand(ST.PAGE_DOWN).getId());

			case SWT.PAGE_UP: 

				if (isCtrl && isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_WINDOW_START).getId());

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.WINDOW_START).getId());

				if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.SELECT_PAGE_UP).getId());

				return new EclipseCommand(getStyledTextCommand(ST.PAGE_UP).getId());

			case SWT.DEL:

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.DELETE_WORD_NEXT).getId());

				if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.CUT).getId());

				return new EclipseCommand(getStyledTextCommand(ST.DELETE_NEXT).getId());

			case SWT.INSERT: 

				if (isCtrl)

					return new EclipseCommand(getStyledTextCommand(ST.COPY).getId());

				if (isShift)

					return new EclipseCommand(getStyledTextCommand(ST.PASTE).getId());

				return new EclipseCommand(getStyledTextCommand(ST.TOGGLE_OVERWRITE).getId());

		}

		if (key == SWT.CR || key==SWT.LF)

		{

//			return new EclipseCommand("org.eclipse.ui.edit.text.smartEnter");

//			try

//			{

//				String delimiter=Utilities.getStyledText(Utilities.getActiveEditor()).getLineDelimiter();

//				return new InsertStringCommand(delimiter);

//			}

//			catch (Exception e)

			{

				return new InsertStringCommand(new String(new char[]{(char)key}));	

			}

		}

		if (key == SWT.TAB)

		{

			return new InsertStringCommand(new String(new char[]{(char)key}));

		}

		//skip if this doesn't seem to correspond to anything we understand

		return null;

	}

	public static String getNameForStyledTextConstant(int constant)

	{

		switch (constant)

		{

		case ST.DELETE_PREVIOUS: return "Delete previous character";

		case ST.LINE_DOWN: return "Move cursor down";

		case ST.SELECT_WORD_PREVIOUS: return "Select previous word";

		case ST.WORD_PREVIOUS: return "Move cursor to previous word";

		case ST.SELECT_COLUMN_PREVIOUS: return "Select previous character";

		case ST.COLUMN_PREVIOUS: return "Move cursor left";

		case ST.SELECT_WORD_NEXT: return "Select next word";

		case ST.WORD_NEXT: return "Move cursor to next word";

		case ST.SELECT_COLUMN_NEXT: return "Select next character";

		case ST.COLUMN_NEXT: return "Move cursor right";

		case ST.LINE_UP: return "Move cursor up";

		case ST.SELECT_TEXT_START: return "Select to start of document";

		case ST.TEXT_START: return "Move cursor to start of document";

		case ST.SELECT_LINE_START: return "Select to line start";

		case ST.LINE_START: return "Move cursor to line start";

		case ST.SELECT_TEXT_END: return "Select to end of document";

		case ST.TEXT_END: return "Move cursor to end of document";

		case ST.SELECT_LINE_END: return "Select to end of line";

		case ST.LINE_END: return "Move cursor to end of line";

		case ST.SELECT_WINDOW_END: return "Select to window end";

		case ST.WINDOW_END: return "Move cursor to window end";

		case ST.SELECT_PAGE_DOWN: return "Select page down";

		case ST.PAGE_DOWN: return "Move cursor down a page";

		case ST.SELECT_WINDOW_START: return "Select to window start";

		case ST.WINDOW_START: return "Move cursor to window start";

		case ST.SELECT_PAGE_UP: return "Select page up";

		case ST.PAGE_UP: return "Move cursor up a page";

		case ST.DELETE_WORD_NEXT: return "Delete next word";

		case ST.DELETE_WORD_PREVIOUS: return "Delete previous word";

		case ST.CUT: return "Cut";

		case ST.DELETE_NEXT: return "Delete next character";

		case ST.COPY: return "Copy";

		case ST.PASTE: return "Paste";

		case ST.TOGGLE_OVERWRITE: return "Toggle overwrite mode";

		case ST.SELECT_LINE_DOWN: return "Select line down";

		case ST.SELECT_LINE_UP: return "Select line up";

		}

		return "Unknown constant";

	}

	static class StyledTextHandler implements IHandler

	{

		private int mStyledTextAction;

		public StyledTextHandler(int styledTextConstant)

		{

			mStyledTextAction=styledTextConstant;

		}

		public void addHandlerListener(IHandlerListener handlerListener) {

		}

		public void dispose() {

		}

		public Object execute(ExecutionEvent event) throws ExecutionException

		{

			IEditorPart target=getActiveEditor();

			Utilities.getStyledText(target).invokeAction(mStyledTextAction);

			return null;

		}

		public boolean isEnabled()

		{

			return true;

		}

		public boolean isHandled()

		{

			return true;

		}

		public void removeHandlerListener(IHandlerListener handlerListener) {

		}

	}

	public static boolean isEditCategory(String categoryID)

	{

		System.out.println("category test:"+categoryID);

		return mEditCategories.contains(categoryID);

	}

	public static IFindReplaceTarget getFindReplaceTarget(IEditorPart editor)

	{

		IFindReplaceTarget target=(IFindReplaceTarget) editor.getAdapter(IFindReplaceTarget.class);

		return target;

	}

	public static void persistCommand(Document doc, Element commandElement, String type, Map<String, String> attrs, Map<String, String> data)

	{

		commandElement.setAttribute(MacroManager.XML_CommandType_ATTR, type);

		if (attrs!=null)

		{

			for (String attr : attrs.keySet())

			{

				commandElement.setAttribute(attr, attrs.get(attr));

			}

		}

		if (data!=null)

		{

			for (String dataTag : data.keySet())

			{

				String dataContent=data.get(dataTag);

				Element dataChild = doc.createElement(dataTag);

				CDATASection cdataContent = doc.createCDATASection(dataContent);

//				child.setTextContent(dataContent);

				commandElement.appendChild(dataChild);

				dataChild.appendChild(cdataContent);

			}

		}

	}

	public static void getCommandData(Element commandElement, Set<String> attrKeys, Set<String> dataKeys, Map<String, String> attrMap, Map<String, String> dataMap)

	{

		if (attrMap!=null)

		{

			for (String attrName : attrKeys)

			{

				String attrValue=commandElement.getAttribute(attrName);

				attrMap.put(attrName, attrValue);

			}

		}

		if (dataMap!=null)

		{

			NodeList children=commandElement.getChildNodes();

			for (int i=0;i<children.getLength();i++)

			{

				String tagName=children.item(i).getNodeName();

				if (dataKeys.contains(tagName))

				{

					String data=children.item(i).getTextContent();

					dataMap.put(tagName, data);

				}

			}