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

<projectDescription>

	<name>org.openoffice.test.assistant.feature</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

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

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

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

	</natures>

</projectDescription>

bin.includes = feature.xml

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

<!--************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************ -->

<feature

      id="org.openoffice.test.assistant.feature"

      label="VCL Test Assistant - VclExplorer"

      version="1.0.3.qualifier"

      provider-name="Apache OpenOffice">

   <description url="http://wiki.services.openoffice.org/wiki/QA/vclauto">

      This plugin can assist testers/developers to write GUI testing

script for OpenOffice. The most-used function is to inspect the VCL control ID.

   </description>

   <copyright url="http://www.apache.org/licenses/LICENSE-2.0">

      Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

or implied.

See the License for the specific language governing permissions

and limitations under the License.

   </copyright>

   <license url="http://www.apache.org/licenses/LICENSE-2.0">

                                       Apache License

                           Version 2.0, January 2004

                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,

      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by

      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all

      other entities that control, are controlled by, or are under common

      control with that entity. For the purposes of this definition,

      "control" means (i) the power, direct or indirect, to cause the

      direction or management of such entity, whether by contract or

      otherwise, or (ii) ownership of fifty percent (50%) or more of the

      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity

      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,

      including but not limited to software source code, documentation

      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical

      transformation or translation of a Source form, including but

      not limited to compiled object code, generated documentation,

      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or

      Object form, made available under the License, as indicated by a

      copyright notice that is included in or attached to the work

      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object

      form, that is based on (or derived from) the Work and for which the

      editorial revisions, annotations, elaborations, or other modifications

      represent, as a whole, an original work of authorship. For the purposes

      of this License, Derivative Works shall not include works that remain

      separable from, or merely link (or bind by name) to the interfaces of,

      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including

      the original version of the Work and any modifications or additions

      to that Work or Derivative Works thereof, that is intentionally

      submitted to Licensor for inclusion in the Work by the copyright owner

      or by an individual or Legal Entity authorized to submit on behalf of

      the copyright owner. For the purposes of this definition, "submitted"

      means any form of electronic, verbal, or written communication sent

      to the Licensor or its representatives, including but not limited to

      communication on electronic mailing lists, source code control systems,

      and issue tracking systems that are managed by, or on behalf of, the

      Licensor for the purpose of discussing and improving the Work, but

      excluding communication that is conspicuously marked or otherwise

      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity

      on behalf of whom a Contribution has been received by Licensor and

      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of

      this License, each Contributor hereby grants to You a perpetual,

      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

      copyright license to reproduce, prepare Derivative Works of,

      publicly display, publicly perform, sublicense, and distribute the

      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of

      this License, each Contributor hereby grants to You a perpetual,

      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

      (except as stated in this section) patent license to make, have made,

      use, offer to sell, sell, import, and otherwise transfer the Work,

      where such license applies only to those patent claims licensable

      by such Contributor that are necessarily infringed by their

      Contribution(s) alone or by combination of their Contribution(s)

      with the Work to which such Contribution(s) was submitted. If You

      institute patent litigation against any entity (including a

      cross-claim or counterclaim in a lawsuit) alleging that the Work

      or a Contribution incorporated within the Work constitutes direct

      or contributory patent infringement, then any patent licenses

      granted to You under this License for that Work shall terminate

      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the

      Work or Derivative Works thereof in any medium, with or without

      modifications, and in Source or Object form, provided that You

      meet the following conditions:

      (a) You must give any other recipients of the Work or

          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices

          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works

          that You distribute, all copyright, patent, trademark, and

          attribution notices from the Source form of the Work,

          excluding those notices that do not pertain to any part of

          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its

          distribution, then any Derivative Works that You distribute must

          include a readable copy of the attribution notices contained

          within such NOTICE file, excluding those notices that do not

          pertain to any part of the Derivative Works, in at least one

          of the following places: within a NOTICE text file distributed

          as part of the Derivative Works; within the Source form or

          documentation, if provided along with the Derivative Works; or,

          within a display generated by the Derivative Works, if and

          wherever such third-party notices normally appear. The contents

          of the NOTICE file are for informational purposes only and

          do not modify the License. You may add Your own attribution

          notices within Derivative Works that You distribute, alongside

          or as an addendum to the NOTICE text from the Work, provided

          that such additional attribution notices cannot be construed

          as modifying the License.

      You may add Your own copyright statement to Your modifications and

      may provide additional or different license terms and conditions

      for use, reproduction, or distribution of Your modifications, or

      for any such Derivative Works as a whole, provided Your use,

      reproduction, and distribution of the Work otherwise complies with

      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,

      any Contribution intentionally submitted for inclusion in the Work

      by You to the Licensor shall be under the terms and conditions of

      this License, without any additional terms or conditions.

      Notwithstanding the above, nothing herein shall supersede or modify

      the terms of any separate license agreement you may have executed

      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade

      names, trademarks, service marks, or product names of the Licensor,

      except as required for reasonable and customary use in describing the

      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or

      agreed to in writing, Licensor provides the Work (and each

      Contributor provides its Contributions) on an "AS IS" BASIS,

      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

      implied, including, without limitation, any warranties or conditions

      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

      PARTICULAR PURPOSE. You are solely responsible for determining the

      appropriateness of using or redistributing the Work and assume any

      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,

      whether in tort (including negligence), contract, or otherwise,

      unless required by applicable law (such as deliberate and grossly

      negligent acts) or agreed to in writing, shall any Contributor be

      liable to You for damages, including any direct, indirect, special,

      incidental, or consequential damages of any character arising as a

      result of this License or out of the use or inability to use the

      Work (including but not limited to damages for loss of goodwill,

      work stoppage, computer failure or malfunction, or any and all

      other commercial damages or losses), even if such Contributor

      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing

      the Work or Derivative Works thereof, You may choose to offer,

      and charge a fee for, acceptance of support, warranty, indemnity,

      or other liability obligations and/or rights consistent with this

      License. However, in accepting such obligations, You may act only

      on Your own behalf and on Your sole responsibility, not on behalf

      of any other Contributor, and only if You agree to indemnify,

      defend, and hold each Contributor harmless for any liability

      incurred by, or claims asserted against, such Contributor by reason

      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   </license>

   <plugin

         id="org.openoffice.test.assistant"

         download-size="120"

         install-size="120"

         version="0.0.0"

         unpack="false"/>

</feature>

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

<classpath>

	<classpathentry exported="true" kind="lib" path="lib/testcommon.jar"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>

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

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

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

</classpath>

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

<projectDescription>

	<name>org.openoffice.test.assistant</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>

source.. = src/

output.. = bin/

bin.includes = plugin.xml,\

               META-INF/,\

               .,\

               icons/,\

               contexts.xml,\

               lib/testcommon.jar

<!--************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************ -->

<contexts>

	<context id="viewer" title="Sample View">

		<description>This is the context help for the sample view with a table viewer. It was generated by a PDE template.</description>

		<topic href="/PLUGINS_ROOT/org.eclipse.platform.doc.isv/guide/ua_help_context.htm" label="Context-sensitive help">

			<enablement>

				<with variable="platform">

	            	<test property="org.eclipse.core.runtime.isBundleInstalled" args="org.eclipse.platform.doc.isv"/>

	     		</with>

			</enablement>

		</topic>

	</context>

</contexts>

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: VCL Test Assistant - VclExplorer

Bundle-SymbolicName: org.openoffice.test.assistant;singleton:=true

Bundle-Version: 1.0.3.qualifier

Bundle-Activator: org.openoffice.test.assistant.Activator

Require-Bundle: org.eclipse.ui,

 org.eclipse.core.runtime,

 org.eclipse.ui.editors;bundle-version="3.6.0",

 org.eclipse.jface.text;bundle-version="3.6.0",

 org.eclipse.core.resources;bundle-version="3.6.0",

 org.eclipse.jdt.core;bundle-version="3.6.0"

Bundle-ActivationPolicy: lazy

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Bundle-ClassPath: .,

 lib/testcommon.jar

Bundle-Vendor: Apache OpenOffice

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

<!--************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************ -->

<?eclipse version="3.4"?>

<plugin>

   <extension

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

      <category

            name="VCL Test Assistant"

            id="org.openoffice.test.assistant">

      </category>

      <view

            name="VCL Explorer"

            icon="icons/sample.gif"

            category="org.openoffice.test.assistant"

            class="org.openoffice.test.assistant.views.VclExplorer"

            id="org.openoffice.test.assistant.views.VclExplorer">

      </view>

   </extension>

   <extension

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

      <perspectiveExtension

            targetID="org.eclipse.jdt.ui.JavaPerspective">

         <view

               ratio="0.5"

               relative="org.eclipse.ui.views.TaskList"

               relationship="right"

               id="org.openoffice.test.assistant.views.VclExplorer">

         </view>

      </perspectiveExtension>

   </extension>

   <extension

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

      <contexts

            file="contexts.xml">

      </contexts>

   </extension>

   <extension

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

      <page

            class="org.openoffice.test.assistant.preferences.PreferencePage"

            id="org.openoffice.test.assistant.preferences.PreferencePage"

            name="VCL Test Assistant">

      </page>

   </extension>

   <extension

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

      <initializer

            class="org.openoffice.test.assistant.preferences.PreferenceInitializer">

      </initializer>

   </extension>

</plugin>

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

/**

 * The activator class controls the plug-in life cycle

 */

public class Activator extends AbstractUIPlugin {

	// The plug-in ID

	public static final String PLUGIN_ID = "org.openoffice.test.assistant"; //$NON-NLS-1$

	// The shared instance

	private static Activator plugin;

	/**

	 * The constructor

	 */

	public Activator() {

	}

	/*

	 * (non-Javadoc)

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

	 */

	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)

	 */

	public void stop(BundleContext context) throws Exception {

		plugin = null;

		super.stop(context);

	}

	/**

	 * Returns the shared instance

	 *

	 * @return the shared instance

	 */

	public static Activator getDefault() {

		return plugin;

	}

	/**

	 * Returns an image descriptor for the image file at the given

	 * plug-in relative path

	 *

	 * @param path the path

	 * @return the image descriptor

	 */

	public static ImageDescriptor getImageDescriptor(String path) {

		return imageDescriptorFromPlugin(PLUGIN_ID, path);

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.preferences;

/**

 * Constant definitions for plug-in preferences

 */

public class PreferenceConstants {

	public static final String P_OPENOFFICE_HOME = "openoffice.home";

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.preferences;

import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;

import org.eclipse.jface.preference.IPreferenceStore;

import org.openoffice.test.assistant.Activator;

/**

 * Class used to initialize default preference values.

 */

public class PreferenceInitializer extends AbstractPreferenceInitializer {

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer#initializeDefaultPreferences()

	 */

	public void initializeDefaultPreferences() {

		IPreferenceStore store = Activator.getDefault().getPreferenceStore();

		store.setDefault(PreferenceConstants.P_OPENOFFICE_HOME, "");

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.preferences;

import org.eclipse.jface.preference.*;

import org.eclipse.ui.IWorkbenchPreferencePage;

import org.eclipse.ui.IWorkbench;

import org.openoffice.test.assistant.Activator;

/**

 * This class represents a preference page that

 * is contributed to the Preferences dialog. By 

 * subclassing <samp>FieldEditorPreferencePage</samp>, we

 * can use the field support built into JFace that allows

 * us to create a page that is small and knows how to 

 * save, restore and apply itself.

 * <p>

 * This page is used to modify preferences only. They

 * are stored in the preference store that belongs to

 * the main plug-in class. That way, preferences can

 * be accessed directly via the preference store.

 */

public class PreferencePage

	extends FieldEditorPreferencePage

	implements IWorkbenchPreferencePage {

	public PreferencePage() {

		super(GRID);

		setPreferenceStore(Activator.getDefault().getPreferenceStore());

		setDescription("VCL Test Assistant Setting");

	}

	/**

	 * Creates the field editors. Field editors are abstractions of

	 * the common GUI blocks needed to manipulate various types

	 * of preferences. Each field editor knows how to save and

	 * restore itself.

	 */

	public void createFieldEditors() {

		addField(new DirectoryFieldEditor(PreferenceConstants.P_OPENOFFICE_HOME, 

				"&OpenOffice Home (the directory containing soffice.bin):", getFieldEditorParent()));

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	public void init(IWorkbench workbench) {

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.views;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.util.HashMap;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Rectangle;

import org.openoffice.test.vcl.client.SmartId;

import org.openoffice.test.vcl.widgets.VclControl;

public class ControlInfo {

	private static final HashMap<Long, String> vcltypes = new  HashMap<Long, String>();

	static {

		Field[] fields = VclControl.class.getDeclaredFields();

		for (Field field : fields) {

			int modifiers = field.getModifiers();

			if (modifiers == (Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL) && field.getType() == Integer.TYPE) {

				try {

					int v = (Integer) field.get(null);

					vcltypes.put((long)v, field.getName());

				} catch (Exception e) {

					//ignore

				}

			}

		}

	}

	public SmartId id;

	public long type;

	public String tip;

	public Image appearance;

	public Rectangle rectangle;

	public String name;

	public ControlInfo(SmartId id, long type, String tip) {

		super();

		this.id = id;

		this.type = type;

		this.tip = tip;

	}

	public String getVclType() {

		return vcltypes.get(type);

	}

	public void shot() {

		if (id.getId() != 0 || id.getSid() != null) {

			VclControl vclControl = new VclControl(id);

			try {

				if (!vclControl.exists())

					return;

				java.awt.Rectangle rect = vclControl.getScreenRectangle();

//				Display display = Display.getDefault();

//				GC gc = new GC(display);

				rectangle = new Rectangle(rect.x, rect.y, rect.width, rect.height);

//				appearance = new Image(display, rectangle);

//				gc.copyArea(appearance, 0, 0);

//				gc.dispose();

			} catch (Throwable t) {

			}

		}

	}

	public void dispose() {

		if (appearance != null)

			appearance.dispose();

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.views;

import static org.openoffice.test.vcl.widgets.VclControl.*;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.core.WorkingCopyOwner;

import org.eclipse.jdt.core.dom.AST;

import org.eclipse.jdt.core.dom.ASTParser;

import org.eclipse.jdt.core.dom.CompilationUnit;

import org.eclipse.jdt.core.dom.FieldDeclaration;

import org.eclipse.jdt.core.dom.MethodInvocation;

import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;

import org.eclipse.jdt.core.dom.StringLiteral;

import org.eclipse.jdt.core.dom.TypeDeclaration;

import org.eclipse.jdt.core.dom.VariableDeclarationFragment;

import org.eclipse.jface.text.Document;

import org.eclipse.text.edits.TextEdit;

import org.openoffice.test.vcl.IDList;

import org.openoffice.test.vcl.client.SmartId;

@SuppressWarnings({ "unchecked", "rawtypes" })

public class UIMapOp {

	private ICompilationUnit uiMap = null;

	private IDList idList = null;

	public ArrayList<String> names = new ArrayList<String>();

	public ArrayList<String> ids = new ArrayList<String>();

	public UIMapOp() {

	}

	private boolean locateUIMap() {

		uiMap = null;

		IWorkspace workspace = ResourcesPlugin.getWorkspace();

		IWorkspaceRoot root = workspace.getRoot();

		IProject[] projects = root.getProjects();

		for (IProject project : projects) {

			try {

				if (project.isNatureEnabled("org.eclipse.jdt.core.javanature")) {

					IJavaProject javaProject = JavaCore.create(project);

					uiMap = findUIMap(javaProject);

					if (uiMap != null) {

						return true;

					}

				}

			} catch (Exception e) {

			}

		}

		return false;

	}

	private ICompilationUnit findUIMap(IJavaProject javaProject) throws JavaModelException {

		IPackageFragment[] packages = javaProject.getPackageFragments();

		for (IPackageFragment mypackage : packages) {

			if (mypackage.getKind() == IPackageFragmentRoot.K_SOURCE) {

				ICompilationUnit ret = findUIMap(mypackage);

				if (ret != null) {

					return ret;

				}

			}

		}

		return null;

	}

	private ICompilationUnit findUIMap(IPackageFragment mypackage) throws JavaModelException {

		for (ICompilationUnit unit : mypackage.getCompilationUnits()) {

			if ("UIMap.java".equals(unit.getElementName())) {

				return unit;

			}

		}

		return null;

	}

	private static CompilationUnit parse(ICompilationUnit unit) {

		ASTParser parser = ASTParser.newParser(AST.JLS3);

		parser.setKind(ASTParser.K_COMPILATION_UNIT);

		parser.setSource(unit);

		parser.setResolveBindings(true);

		return (CompilationUnit) parser.createAST(null); // parse

	}

	public boolean scan() {

		if (!locateUIMap())

			return false;

		IProject project = uiMap.getResource().getProject();

		try {

			uiMap.getResource().refreshLocal(1, null);

		} catch (CoreException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		IFile file = project.getFile("ids");

		idList = new IDList(file.getLocation().toFile());

		names.clear();

		ids.clear();

		CompilationUnit compilationUnit = parse(uiMap);

		TypeDeclaration typeDeclaration = (TypeDeclaration) compilationUnit.types().get(0);

		FieldDeclaration[] fields = typeDeclaration.getFields();

		for (FieldDeclaration field : fields) {

			List fragments = field.fragments();

			for (Object o : fragments) {

				VariableDeclarationFragment fragment = (VariableDeclarationFragment) o;

				System.out.println(fragment);

				names.add(fragment.getName().toString());

				String code = fragment.toString();

				int left = code.indexOf('(');

				if (left >= 0) {

					int right = code.indexOf(')', left);

					if (right >= 0) {

						String idInDeclaration = code.substring(left + 1, right);

						if (idInDeclaration.startsWith("\"")) {

							// It's string....

							idInDeclaration = idInDeclaration.substring(1, idInDeclaration.length() - 1);

							ids.add(idInDeclaration);

							continue;

						}

					}

				}

				ids.add(null);

			}

		}

		return true;

	}

	/**

	 * Return the control name defined in UIMap with the given id

	 * 

	 * @param id

	 * @return

	 */

	public void populateName(ArrayList<ControlInfo> controlInfos) {

		for (int i = names.size() - 1; i >= 0; i--) {

			String name = names.get(i);

			String id = ids.get(i);

			if (id == null)

				continue;

			SmartId smartId = idList.getId(id);

			for (ControlInfo ci : controlInfos) {

				if (ci.id.equals(smartId)) {

					ci.name = name;

					break;

				}

			}

		}

	}

	/**

	 * 

	 */

	private String[] codeParts(ControlInfo info) {

		String method = null;

		String type = null;

		switch ((int) info.type) {

		case WINDOW_BUTTON:

		case WINDOW_PUSHBUTTON:

		case WINDOW_IMAGEBUTTON:

		case WINDOW_MENUBUTTON:

		case WINDOW_MOREBUTTON:

		case WINDOW_RADIOBUTTON:

		case WINDOW_IMAGERADIOBUTTON:

		case WINDOW_CHECKBOX:

		case WINDOW_TRISTATEBOX:

			method = "button";

			type = "VclButton";

			break;

		case WINDOW_EDIT:

		case WINDOW_MULTILINEEDIT:

		case WINDOW_PATTERNBOX:

		case WINDOW_NUMERICBOX:

		case WINDOW_METRICBOX:

		case WINDOW_CURRENCYBOX:

		case WINDOW_DATEBOX:

		case WINDOW_TIMEBOX:

		case WINDOW_LONGCURRENCYBOX:

			method = "editbox";

			type = "VclEditBox";

			break;

		case WINDOW_COMBOBOX:

			method = "combobox";

			type = "VclComboBox";

			break;

		case WINDOW_LISTBOX:

		case WINDOW_MULTILISTBOX:

		case WINDOW_VALUESETLISTBOX:

			method = "listbox";

			type = "VclListBox";

			break;

		case WINDOW_TABPAGE:

			method = "tabpage";

			type = "VclTabPage";

			break;

		case WINDOW_TOOLBOX:

			method = "toolbox";

			type = "VclToolBox";

			break;

		case WINDOW_TABCONTROL:

			method = "tabcontrol";

			type = "VclTabControl";

			break;

		case WINDOW_WINDOW:

		case WINDOW_BORDERWINDOW:

		case WINDOW_SYSTEMCHILDWINDOW:

			method = "window";

			type = "VclWindow";

			break;

		case WINDOW_DIALOG:

		case WINDOW_MODELESSDIALOG:

		case WINDOW_MODALDIALOG:

		case WINDOW_SYSTEMDIALOG :

		case WINDOW_PATHDIALOG :

		case WINDOW_FILEDIALOG :

		case WINDOW_PRINTERSETUPDIALOG :

		case WINDOW_PRINTDIALOG :

		case WINDOW_COLORDIALOG :

		case WINDOW_FONTDIALOG:

			method = "dialog";

			type = "VclDialog";

			break;

		case WINDOW_DOCKINGWINDOW:

			method = "dockingwin";

			type = "VclDocingWin";

			break;

		case WINDOW_SPINFIELD:

		case WINDOW_PATTERNFIELD:

		case WINDOW_NUMERICFIELD:

		case WINDOW_METRICFIELD:

		case WINDOW_CURRENCYFIELD:

		case WINDOW_DATEFIELD:

		case WINDOW_TIMEFIELD:

		case WINDOW_LONGCURRENCYFIELD:

			method = "field";

			type = "VclField";

			break;

		default:

			method = "control";

			type = "VclControl";

		}

		return new String[] { type, method };

	}

	public void define(ControlInfo info) throws Exception {

		String[] codeParts = codeParts(info);

		String type = codeParts[0];

		String method = codeParts[1];

		String source = uiMap.getSource();

		Document document = new Document(source);

		// creation of DOM/AST from a ICompilationUnit

		ASTParser parser = ASTParser.newParser(AST.JLS3);

		parser.setSource(uiMap);

		CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);

		AST ast = astRoot.getAST();

		astRoot.recordModifications();

		VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();

		StringLiteral literal = ast.newStringLiteral();

		literal.setLiteralValue(info.id.toString());

		MethodInvocation methodInvocation = ast.newMethodInvocation();

		methodInvocation.setName(ast.newSimpleName(method));

		methodInvocation.arguments().add(literal);

		vdf.setInitializer(methodInvocation);

		vdf.setName(ast.newSimpleName(info.name));

		FieldDeclaration fieldDeclaration = ast.newFieldDeclaration(vdf);

		fieldDeclaration.setType(ast.newSimpleType(ast.newSimpleName(type)));

		fieldDeclaration.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));

		fieldDeclaration.modifiers().add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));

		fieldDeclaration.modifiers().add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD));

		TypeDeclaration typeDeclaration = (TypeDeclaration) astRoot.types().get(0);

		typeDeclaration.bodyDeclarations().add(fieldDeclaration);

		TextEdit edits = astRoot.rewrite(document, uiMap.getJavaProject().getOptions(true));

		edits.apply(document);

		String newSource = document.get();

		WorkingCopyOwner owner = new WorkingCopyOwner() {};

		// Create working copy

		ICompilationUnit workingCopy = uiMap.getWorkingCopy(owner, null);

		workingCopy.getBuffer().setContents(newSource);

		workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null);

		// Commit changes

		workingCopy.commitWorkingCopy(true, null);

		// Destroy working copy

		workingCopy.discardWorkingCopy();

		// return "public static final " + type + " " + info.name + " = " +

		// method + "(\"" + info.id + "\")";

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.views;

import java.io.File;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.jdt.core.JavaConventions;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.IMenuListener;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.jface.action.IToolBarManager;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.action.Separator;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ColumnViewerEditor;

import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;

import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.ICellModifier;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerEditor;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.IActionBars;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IWorkbench;

import org.eclipse.ui.IWorkbenchActionConstants;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.ViewPart;

import org.eclipse.ui.texteditor.AbstractTextEditor;

import org.eclipse.ui.texteditor.IDocumentProvider;

import org.openoffice.test.assistant.Activator;

import org.openoffice.test.assistant.preferences.PreferenceConstants;

import org.openoffice.test.vcl.client.CommandCaller.WinInfoReceiver;

import org.openoffice.test.vcl.client.Constant;

import org.openoffice.test.vcl.client.SmartId;

import org.openoffice.test.vcl.client.VclHook;

import org.openoffice.test.vcl.widgets.VclApp;

public class VclExplorer extends ViewPart implements WinInfoReceiver {

	public static final String ID = "org.vclauto.assistant.views.VclExplorer";

	private TableViewer viewer;

	private Label messageLabel;

	private Action inspectAction;

	private Action launchAction;

	private Action insertCodeAction;

	private UIMapOp uiMapOp = new UIMapOp();

	private ArrayList<ControlInfo> controlInfos = new ArrayList<ControlInfo>();

	private Display display;

	private Color duplicatedNameColor;

	/**

	 * The constructor.

	 */

	public VclExplorer() {

		VclHook.getCommandCaller().setWinInfoReceiver(this);

	}

	public void createPartControl(Composite parent) {

		GridLayout layout = new GridLayout();

		layout.numColumns = 1;

		layout.marginLeft = 0;

		layout.marginRight = 0;

		layout.marginTop = 0;

		layout.marginBottom = 0;

		layout.marginHeight = 0;

		layout.marginWidth = 0;

		parent.setLayout(layout);

		messageLabel = new Label(parent, SWT.NONE);

		GridData gridData = new GridData(GridData.FILL_HORIZONTAL);

		gridData.minimumHeight = 14;

		gridData.heightHint = 14;

		messageLabel.setLayoutData(gridData);

		viewer = new TableViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);

		gridData = new GridData(GridData.FILL_BOTH);

		viewer.getTable().setLayoutData(gridData);

		viewer.setContentProvider(new VclExplorerContentProvider());

		viewer.setLabelProvider(new VclExplorerLabelProvider());

		viewer.setInput(controlInfos);

		display = parent.getDisplay();

		duplicatedNameColor = new Color(display, 255, 160, 160);

		final Table table = viewer.getTable();

		table.setHeaderVisible(true);

		table.setLinesVisible(true);

		TableColumn column = new TableColumn(table, SWT.NONE);

		column.setText("ID");

		column.setResizable(true);

		column.setMoveable(false);

		column.setWidth(100);

		column = new TableColumn(table, SWT.NONE);

		column.setText("Name");

		column.setResizable(true);

		column.setMoveable(false);

		column.setWidth(150);

		column = new TableColumn(table, SWT.NONE);

		column.setText("Type");

		column.setResizable(true);

		column.setMoveable(false);

		column.setWidth(100);

		column = new TableColumn(table, SWT.NONE);

		column.setText("Tips");

		column.setResizable(true);

		column.setMoveable(false);

		column.setWidth(200);

		viewer.setColumnProperties(new String[] { "ID", "Name", "Type", "Tips" });

		TextCellEditor nameCellEditor = new TextCellEditor(viewer.getTable());

		final Text nameText = ((Text) nameCellEditor.getControl());

		nameText.addModifyListener(new ModifyListener() {

					public void modifyText(ModifyEvent me) {

						String message = validateName(nameText.getText());

						if (message != null) {

							messageLabel.setText(message);

							nameText.setBackground(duplicatedNameColor);

						} else {

							messageLabel.setText("");

							nameText.setBackground(null);

						}

					}

				});

		viewer.setCellEditors(new CellEditor[] { null, nameCellEditor, null, null});

		viewer.setCellModifier(new ICellModifier() {

			public boolean canModify(Object element, String property) {

				if (!"Name".equals(property))

					return false;

				ControlInfo controlInfo = (ControlInfo) element;

				if (controlInfo.name != null)

					return false;

				return uiMapOp.scan();

			}

			public Object getValue(Object element, String property) {

//				if (!"Name".equals(property))

//					return false;

				ControlInfo controlInfo = (ControlInfo) element;

				return controlInfo.name == null ? "" : controlInfo.name;

			}

			public void modify(Object element, String property, Object value) {

//				if (!"Name".equals(property))

//					return;

				TableItem item = (TableItem) element;

				ControlInfo controlInfo = (ControlInfo) item.getData();

				String newName = (String) value;

				String msg = validateName(newName);

				if (msg == null) {

					controlInfo.name = newName;

					if (doDefineName(controlInfo)) {

						item.setText(1, newName);

						messageLabel.setText("");

					} else {

						controlInfo.name = null;

						messageLabel.setText("Can't define the control in UIMap. UIMap maybe is broken!");

					}

				} else {

					messageLabel.setText(msg);

				}

			}

		});

		ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(

				viewer) {

			protected boolean isEditorActivationEvent(

					ColumnViewerEditorActivationEvent event) {

				return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL

						|| event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION

						|| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC;

			}

		};

		TableViewerEditor.create(viewer, actSupport,

				ColumnViewerEditor.TABBING_HORIZONTAL

						| ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR

						| ColumnViewerEditor.TABBING_VERTICAL

						| ColumnViewerEditor.KEYBOARD_ACTIVATION);

		// Create the help context id for the viewer's control

		PlatformUI.getWorkbench().getHelpSystem().setHelp(viewer.getControl(), "org.vclauto.assistant.viewer");

		makeActions();

		hookContextMenu();

		hookDoubleClickAction();

		contributeToActionBars();

	}

	private void hookContextMenu() {

		MenuManager menuMgr = new MenuManager("#PopupMenu");

		menuMgr.setRemoveAllWhenShown(true);

		menuMgr.addMenuListener(new IMenuListener() {

			public void menuAboutToShow(IMenuManager manager) {

				VclExplorer.this.fillContextMenu(manager);

			}

		});

		Menu menu = menuMgr.createContextMenu(viewer.getControl());

		viewer.getControl().setMenu(menu);

		getSite().registerContextMenu(menuMgr, viewer);

	}

	private void contributeToActionBars() {

		IActionBars bars = getViewSite().getActionBars();

		fillLocalPullDown(bars.getMenuManager());

		fillLocalToolBar(bars.getToolBarManager());

	}

	private void fillLocalPullDown(IMenuManager manager) {

		manager.add(inspectAction);

		manager.add(new Separator());

		manager.add(launchAction);

	}

	private void fillContextMenu(IMenuManager manager) {

		manager.add(inspectAction);

		manager.add(launchAction);

		// Other plug-ins can contribute there actions here

		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));

	}

	private void fillLocalToolBar(IToolBarManager manager) {

		manager.add(inspectAction);

		manager.add(launchAction);

	}

	private void makeActions() {

		inspectAction = new Action() {

			public void run() {

				if (!VclHook.available()) {

					showMessage("OpenOffice is not launched or initializing. Click \"Launch\" to start OpenOffice or wait it to finish initializing.");

					return;

				}

				try {

					VclHook.invokeCommand(Constant.RC_DisplayHid, new Object[]{Boolean.TRUE});

				} catch (Exception e) {

					showMessage("OpenOffice disappeared! It maybe crashed or freezed. Please re-launch it.");

				}

			}

		};

		inspectAction.setText("Inspect");

		inspectAction.setToolTipText("Inspect VCL controls.");

//		action1.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().

//			getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK));

		launchAction = new Action() {

			public void run() {

				IPreferenceStore store = Activator.getDefault().getPreferenceStore();

				final String ooHome = store.getString(PreferenceConstants.P_OPENOFFICE_HOME);

				if (ooHome == null || ooHome.length() == 0) {

					showMessage("Please set OpenOffice home in the Vclauto assistant preference page.");

					return;

				}

				File ooHomeFile = new File(ooHome, "soffice.bin");

				if (!ooHomeFile.exists()) {

					showMessage("OpenOffice home is not set correctly in the Vclauto assistant preference page.");

					return;

				}

				IRunnableWithProgress op = new IRunnableWithProgress() {

					@Override

					public void run(IProgressMonitor arg0) throws InvocationTargetException, InterruptedException {

						VclApp app = new VclApp(ooHome);

						if (!app.exists()) {

							app.kill();

							app.start();

						}

					}

				};

				IWorkbench wb = PlatformUI.getWorkbench();

				try {

					wb.getProgressService().run(true, false, op);

				} catch (InvocationTargetException e) {

					e.printStackTrace();

				} catch (InterruptedException e) {

					e.printStackTrace();

				}

			}

		};

		launchAction.setText("Launch");

		launchAction.setToolTipText("Launch OpenOffice");

//		action2.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().

//				getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK));

		insertCodeAction = new Action() {

			public void run() {

				ISelection selection = viewer.getSelection();

				if (selection == null)

					return;

				final ControlInfo controlInfo = (ControlInfo)((IStructuredSelection) selection).getFirstElement();

				if (controlInfo.name != null) {

					doInsertCode(controlInfo.name);

				}		          

			}

		};

	}

	private String validateName(String name) {

		 if (uiMapOp.names.contains(name))

			 return "Duplicated name.";

		 IStatus status = JavaConventions.validateFieldName(name, "1.5", "1.5");

		 return status.isOK() ? null : "It's an invalidate java field name.";

	}

	private boolean doDefineName(ControlInfo controlInfo) {

		try {

			uiMapOp.define(controlInfo);

		} catch (Exception e) {

			controlInfo.name = null;

			e.printStackTrace();

		}

		return true;

	}

	private void doInsertCode(String code) {

		IWorkbench wb = PlatformUI.getWorkbench();

		IWorkbenchWindow window = wb.getActiveWorkbenchWindow();

		IWorkbenchPage page = window.getActivePage();

		IEditorPart editorPart = page.getActiveEditor();

		if (!(editorPart instanceof AbstractTextEditor))

			return;

		AbstractTextEditor editor = (AbstractTextEditor) editorPart;

		IDocumentProvider dp = editor.getDocumentProvider();

		IDocument doc = dp.getDocument(editor.getEditorInput());

		try {			

			ITextSelection textSelection = (ITextSelection) editorPart.getSite().getSelectionProvider().getSelection();

			int offset = textSelection.getOffset();				

			doc.replace(offset, textSelection.getLength(), code);

		} catch (Exception e) {

			// TODO: handle exception

			e.printStackTrace();

		}

	}

	private void hookDoubleClickAction() {

		viewer.addDoubleClickListener(new IDoubleClickListener() {

			public void doubleClick(DoubleClickEvent event) {

				insertCodeAction.run();

			}

		});

	}

	private void showMessage(String message) {

		MessageDialog.openInformation(

			viewer.getControl().getShell(),

			"Vcl Explorer",

			message);

	}

	/**

	 * Passing the focus request to the viewer's control.

	 */

	public void setFocus() {

		viewer.getControl().setFocus();

	}

	@Override

	public void addWinInfo(final SmartId id, final long type, final String t) {

		final String tooltip = t.replaceAll("%.*%.*:", "");

		ControlInfo info = new ControlInfo(id, type, tooltip);

		//info.shot();

		controlInfos.add(info);

	}

	@Override

	public void onFinishReceiving() {

//		for (ControlInfo info : controlInfos) {

//			info.shot();

//		}

//		

		display.asyncExec(new Runnable() {

			public void run() {

				if (uiMapOp.scan()) {

					uiMapOp.populateName(controlInfos);

				} else {

					messageLabel.setText("Can not find UIMap and code generating will not work.");

				}

				viewer.setInput(controlInfos);

			}

		});

	}

	@Override

	public void onStartReceiving() {

		controlInfos = new ArrayList<ControlInfo>();

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.views;

import java.util.ArrayList;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.Viewer;

public class VclExplorerContentProvider implements IStructuredContentProvider {

	public VclExplorerContentProvider() {

	}

	public void inputChanged(Viewer v, Object oldInput, Object newInput) {

		ArrayList<ControlInfo> oldControlInfos = (ArrayList<ControlInfo>) oldInput;

		if (oldControlInfos != null) {

			for (ControlInfo info : oldControlInfos) {

				info.dispose();

			}

		}

	}

	public void dispose() {

	}

	public Object[] getElements(Object parent) {

		ArrayList<ControlInfo> controlInfos = (ArrayList<ControlInfo>) parent;

		if (controlInfos != null)

			return controlInfos.toArray();

		return new Object[0];

	}

}

/************************************************************************

 *

 * Licensed Materials - Property of IBM.

 * (C) Copyright IBM Corporation 2003, 2012.  All Rights Reserved.

 * U.S. Government Users Restricted Rights:

 * Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

 *

 ************************************************************************/

package org.openoffice.test.assistant.views;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.swt.graphics.Image;

public class VclExplorerLabelProvider extends LabelProvider implements ITableLabelProvider {

	public VclExplorerLabelProvider() {

	}

	public String getColumnText(Object obj, int index) {

		ControlInfo info = (ControlInfo) obj;

		switch (index) {

		case 0:

			return info.id.toString();

		case 1:

			return info.name;

		case 2:

			return Long.toString(info.type) + " " + info.getVclType();

		case 3:

			return info.tip;

		}

		return "";

	}

	public Image getColumnImage(Object obj, int index) {

		return null;

	}

}

1. Java utilities to facilitate testing OpenOffice. e.g. file operation, graphics analysis and so on.

2. Vclauto: Java API to perform GUI testing. e.g. keyboard/mouse event simulation, user interaction with VCL controls, get information of GUI and so on.

	<classpathentry combineaccessrules="false" kind="src" path="/testcommon"/>

				<isset property="openoffice.archive.url" />

UID_ACTIVE 0

SD_HID_SDDRAWVIEWSHELL 203

SD_HID_SDGRAPHICVIEWSHELL 211

.uno:InsertTable 20330

.uno:SearchDialog 5961

cui:ModalDialog:RID_SVX_NEWTABLE_DLG 1238302720

.uno:About 5301

CUI_HID_OFADLG_OPTIONS_TREE 34904

CUI_HID_OFADLG_TREELISTBOX 34917

.uno:ConvertTableText 20500

.uno:DefineName 26271

.uno:DeleteCell 26222

DLG_INSERT_PAGES_OBJS 938

DLG_JOIN_TABADD 19214

FID_ADJUST_PRINTZOOM 26652

FID_APPLY_NAME 26274

FID_AUTOCOMPLETE 26319

FID_AUTO_CALC 26303

FID_CELL_FORMAT 26280

FID_CHG_ACCEPT 26258

FID_CHG_COMMENT 26259

FID_CHG_RECORD 26238

FID_CHG_SHOW 26239

FID_COL_HIDE 26287

FID_COL_OPT_DIRECT 26299

FID_COL_OPT_WIDTH 26286

FID_COL_SHOW 26288

FID_COL_WIDTH 26285

FID_CONDITIONAL_FORMAT 26291

FID_DEFINE_NAME 26271

FID_DELETE_CELL 26222

FID_DELETE_TABLE 26223

FID_DEL_COLBRK 26264

FID_DEL_MANUALBREAKS 26650

FID_DEL_ROWBRK 26263

FID_FILL_AUTO 26556

FID_FILL_SERIES 26229

FID_FILL_TAB 26228

FID_FILL_TO_BOTTOM 26224

FID_FILL_TO_LEFT 26227

FID_FILL_TO_RIGHT 26225

FID_FILL_TO_TOP 26226

FID_FILTER_OK 26108

FID_FOCUS_POSWND 26645

FID_FUNCTION_BOX 26248

FID_HARD_RECALC 26318

FID_INPUTLINE_BLOCK 26129

FID_INPUTLINE_ENTER 26101

FID_INPUTLINE_MATRIX 26111

FID_INPUTLINE_STATUS 26100

FID_INSERT_FILE 26624

FID_INSERT_NAME 26272

FID_INS_CELL 26266

FID_INS_CELLSDOWN 26278

FID_INS_CELLSRIGHT 26279

FID_INS_CELL_CONTENTS 26265

FID_INS_COLBRK 26262

FID_INS_COLUMN 26268

FID_INS_ROW 26267

FID_INS_ROWBRK 26261

FID_INS_TABLE 26269

FID_INS_TABLE_EXT 26275

FID_MERGE_OFF 26294

FID_MERGE_ON 26293

FID_MERGE_TOGGLE 26581

FID_NORMALVIEWMODE 26249

FID_NOTE_VISIBLE 26630

FID_PAGEBREAKMODE 26247

FID_PROTECT_DOC 26307

FID_PROTECT_TABLE 26306

FID_RECALC 26304

FID_REPEAT_SEARCH 26612

FID_REPLACE 26613

FID_REPLACE_ALL 26615

FID_RESET_PRINTZOOM 26653

FID_ROW_HEIGHT 26281

FID_ROW_HIDE 26283

FID_ROW_OPT_HEIGHT 26282

FID_ROW_SHOW 26284

FID_SCALE 26244

FID_SCALESTATUS 26010

FID_SEARCH 26611

FID_SEARCH_ALL 26614

FID_SEARCH_NOW 10502

FID_SEARCH_OFF 10501

FID_SEARCH_ON 10500

FID_SEARCH_REPLACESET 10505

FID_SEARCH_SEARCHSET 10504

FID_TABLE_HIDE 26289

FID_TABLE_SHOW 26290

FID_TABLE_VISIBLE 26298

FID_TAB_APPEND 26350

FID_TAB_DESELECTALL 26353

FID_TAB_MENU_RENAME 26346

FID_TAB_MOVE 26348

FID_TAB_RENAME 26347

FID_TAB_RTL 26352

FID_TAB_SELECTALL 26349

FID_TOGGLEFORMULA 26250

FID_TOGGLEHEADERS 26242

FID_TOGGLEINPUTLINE 26241

FID_TOGGLESYNTAX 26245

FID_USE_NAME 26273

FID_VALIDATION 26625

FN_ABSTRACT_NEWDOC 21612

FN_ABSTRACT_STARIMPRESS 21613

FN_ADD_UNKNOWN 20606

FN_AUTOFORMAT_APPLY 20401

FN_AUTOFORMAT_AUTO 20402

FN_AUTOFORMAT_REDLINE_APPLY 20406

FN_AUTO_CORRECT 20649

FN_BACKSPACE 20926

FN_BUSINESS_CARD 21052

FN_CALCULATE 20615

FN_CALC_TABLE 20129

FN_CHANGE_DBFIELD 20309

FN_CHANGE_PAGENUM 20634

FN_CHAR_LEFT 20901

FN_CHAR_LEFT_SEL 20801

FN_CHAR_RIGHT 20902

FN_CHAR_RIGHT_SEL 20802

FN_CLOSE_PAGEPREVIEW 21254

FN_CNTNT_TO_NEXT_FRAME 20958

FN_CONVERT_TABLE_TO_TEXT 20532

FN_CONVERT_TEXT_TABLE 20500

FN_CONVERT_TEXT_TO_TABLE 20531

FN_COPY_HYPERLINK_LOCATION 21840

FN_DEC_INDENT_OFFSET 21751

FN_DELETE_ALL_NOTES 22502

FN_DELETE_BACK_LINE 20932

FN_DELETE_BACK_PARA 20934

FN_DELETE_BACK_SENT 20928

FN_DELETE_BACK_WORD 20930

FN_DELETE_BOOKMARK 20301

FN_DELETE_COMMENT 22506

FN_DELETE_LINE 20931

FN_DELETE_NOTE 22500

FN_DELETE_NOTE_AUTHOR 22501

FN_DELETE_PARA 20933

FN_DELETE_SENT 20927

FN_DELETE_WHOLE_LINE 20935

FN_DELETE_WORD 20929

FN_DRAWTEXT_ATTR_DLG 20376

FN_DRAW_WRAP_DLG 20203

FN_DROP_CHAR_STYLE_NAME 22419

FN_DROP_TEXT 22418

FN_EDIT_AUTH_ENTRY_DLG 21833

FN_EDIT_CURRENT_TOX 21832

FN_EDIT_FIELD 20104

FN_EDIT_FOOTNOTE 20162

FN_EDIT_FORMULA 20128

FN_EDIT_HYPERLINK 21835

FN_EDIT_IDX_ENTRY_DLG 20123

FN_EDIT_LINK_DLG 20109

FN_EDIT_REGION 20165

FN_END_DOC_DIRECT 20979

FN_END_OF_COLUMN 20918

FN_END_OF_DOCUMENT 20908

FN_END_OF_DOCUMENT_SEL 20808

FN_END_OF_LINE 20906

FN_END_OF_LINE_SEL 20806

FN_END_OF_NEXT_COLUMN 20952

FN_END_OF_NEXT_PAGE 20910

FN_END_OF_NEXT_PAGE_SEL 20810

FN_END_OF_PAGE 20914

FN_END_OF_PAGE_SEL 20814

FN_END_OF_PARA 20920

FN_END_OF_PARA_SEL 20820

FN_END_OF_PREV_COLUMN 20954

FN_END_OF_PREV_PAGE 20912

FN_END_OF_PREV_PAGE_SEL 20812

FN_END_TABLE 20948

FN_ENVELOP 21050

FN_ESCAPE 20941

FN_EXECUTE_MACROFIELD 20127

FN_EXPAND_GLOSSARY 20628

FN_FAX 20028

FN_FLIP_HORZ_GRAFIC 20425

FN_FLIP_VERT_GRAFIC 20426

FN_FOOTNOTE_TO_ANCHOR 20955

FN_FORMAT_APPLY_DEFAULT 21757

FN_FORMAT_APPLY_HEAD1 21754

FN_FORMAT_APPLY_HEAD2 21755

FN_FORMAT_APPLY_HEAD3 21756

FN_FORMAT_APPLY_TEXTBODY 21758

FN_FORMAT_BACKGROUND_DLG 20450

FN_FORMAT_BORDER_DLG 20448

FN_FORMAT_COLUMN 20453

FN_FORMAT_DROPCAPS 20454

FN_FORMAT_FOOTNOTE_DLG 20468

FN_FORMAT_FRAME_DLG 20456

FN_FORMAT_GRAFIC_DLG 20458

FN_FORMAT_LINENUMBER 21744

FN_FORMAT_PAGE_COLUMN_DLG 20449

FN_FORMAT_PAGE_DLG 20452

FN_FORMAT_RESET 20469

FN_FORMAT_TABLE_DLG 20460

FN_FORMULA_APPLY 20558

FN_FORMULA_CALC 20556

FN_FORMULA_CANCEL 20557

FN_FRAME_ALIGN_HORZ_CENTER 20477

FN_FRAME_ALIGN_HORZ_LEFT 20475

FN_FRAME_ALIGN_HORZ_RIGHT 20476

FN_FRAME_ALIGN_VERT_BOTTOM 20479

FN_FRAME_ALIGN_VERT_CENTER 20480

FN_FRAME_ALIGN_VERT_CHAR_BOTTOM 20569

FN_FRAME_ALIGN_VERT_CHAR_CENTER 20570

FN_FRAME_ALIGN_VERT_CHAR_TOP 20568

FN_FRAME_ALIGN_VERT_ROW_BOTTOM 20566

FN_FRAME_ALIGN_VERT_ROW_CENTER 20567

FN_FRAME_ALIGN_VERT_ROW_TOP 20565

FN_FRAME_ALIGN_VERT_TOP 20478

FN_FRAME_CHAIN 21736

FN_FRAME_DOWN 20523

FN_FRAME_MIRROR_ON_EVEN_PAGES 21740

FN_FRAME_NOWRAP 20472

FN_FRAME_TO_ANCHOR 20959

FN_FRAME_UNCHAIN 21737

FN_FRAME_UP 20522

FN_FRAME_WRAP 20473

FN_FRAME_WRAPTHRU 20474

FN_FRAME_WRAPTHRU_TRANSP 20564

FN_FRAME_WRAP_CONTOUR 20584

FN_FRAME_WRAP_IDEAL 20563

FN_FRAME_WRAP_LEFT 20572

FN_FRAME_WRAP_RIGHT 20573

FN_GLOSSARY_DLG 20620

FN_GOTO_NEXT_CELL 20545

FN_GOTO_NEXT_INPUTFLD 20147

FN_GOTO_NEXT_MARK 20976