#119998# copy the VCLAuto from Symphony code base to AOO trunk.

More info, check here
http://wiki.services.openoffice.org/wiki/QA/vclauto
http://wiki.services.openoffice.org/wiki/Test_Refactor
Copy the testgui/source/org/openoffice/test/vcl to test/testcommon/source/org/openoffice/test/vcl

29 files changed, 4763 insertions, 0 deletions

diff --git a/test/testcommon/source/org/openoffice/test/vcl/IDList.java b/test/testcommon/source/org/openoffice/test/vcl/IDList.java
new file mode 100644
index 000000000000..7b77704e87d8
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/IDList.java
@@ -0,0 +1,114 @@
+/************************************************************************
+ *
+ * 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.vcl;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ *
+ * The class is used to read an from external files to replace the id in the code.
+ */
+public class IDList {
+
+    private HashMap<String, String> map = new HashMap<String, String>();
+
+    private File dir = null;
+
+    public IDList(File dir) {
+        this.dir = dir;
+        load();
+    }
+
+
+    private void readFile(File file, HashMap<String, String> map) {
+        BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new FileReader(file));
+            String line = null;
+            while ((line = reader.readLine()) != null ) {
+                line = line.trim();
+                if (line.length() == 0 /*|| line.startsWith("//")*/)
+                    continue;
+                String[] parts = line.split(" ");
+                if (parts.length != 2)
+                    continue;
+                map.put(parts[0], parts[1]);
+            }
+
+        } catch (IOException e) {
+            // for debug
+            e.printStackTrace();
+        } finally {
+            if (reader != null)
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+        }
+    }
+
+
+    public void load() {
+        if (dir == null)
+            return;
+
+        map.clear();
+        ArrayList<File> validFiles = new ArrayList<File>();
+        File[] files = dir.listFiles();
+        for (File file : files) {
+            if (file.isFile() && file.getName().endsWith(".lst")) {
+                validFiles.add(file);
+            }
+        }
+
+        // Sort by file name. Maybe the sorting is redundant!?
+        Collections.sort(validFiles, new Comparator<File>() {
+            public int compare(File o1, File o2) {
+                return o1.getName().compareTo(o2.getName());
+            }
+        });
+
+        for (File file: validFiles) {
+            readFile(file, map);
+        }
+    }
+
+    public SmartId getId(String id) {
+        String value = map.get(id);
+        if (value == null) {
+            int i = id.indexOf("_");
+            if (i >= 0) {
+                value = map.get(id.substring(++i));
+            }
+        }
+        if (value != null)
+            //The external definition overwrites the id.
+            id = value;
+
+        try {
+            //Try to convert ID to number ID for old build.
+            //From OO3.4 all IDs should be string.
+            return new SmartId(Long.parseLong(id));
+        } catch (NumberFormatException e) {
+
+        }
+        return new SmartId(id);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/Tester.java b/test/testcommon/source/org/openoffice/test/vcl/Tester.java
new file mode 100644
index 000000000000..634f24ee13a5
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/Tester.java
@@ -0,0 +1,298 @@
+/************************************************************************
+ *
+ * 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.vcl;
+
+import java.awt.AWTException;
+import java.awt.Robot;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.util.HashMap;
+import java.util.StringTokenizer;
+
+
+/**
+ *
+ */
+public class Tester {
+    static Robot robot;
+
+    static {
+        try {
+            robot = new Robot();
+            robot.setAutoDelay(20);
+            robot.setAutoWaitForIdle(true);
+        } catch (AWTException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public Tester() {
+
+    }
+
+    /**
+     *
+     * @param delay
+     */
+    public static void sleep(double delay) {
+        try {
+            Thread.sleep((long) (delay * 1000));
+        } catch (InterruptedException e) {
+        }
+    }
+
+    /**
+     * Click on the screen
+     * @param x
+     * @param y
+     */
+    public static void click(int x, int y) {
+        robot.mouseMove(x, y);
+        robot.mousePress(InputEvent.BUTTON1_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_MASK);
+        robot.delay(100);
+    }
+
+    public static void doubleClick(int x, int y) {
+        robot.mouseMove(x, y);
+        robot.mousePress(InputEvent.BUTTON1_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_MASK);
+        robot.mousePress(InputEvent.BUTTON1_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_MASK);
+        robot.delay(100);
+    }
+
+    /**
+     * Right click on the screen
+     * @param x
+     * @param y
+     */
+    public static void rightClick(int x, int y) {
+        robot.mouseMove(x, y);
+        robot.mousePress(InputEvent.BUTTON2_MASK);
+        robot.mouseRelease(InputEvent.BUTTON2_MASK);
+        robot.mousePress(InputEvent.BUTTON2_MASK);
+        robot.mouseRelease(InputEvent.BUTTON2_MASK);
+        robot.delay(100);
+    }
+
+    public static void drag(int fromX, int fromY, int toX, int toY) {
+        robot.mouseMove(fromX, fromY);
+        robot.mousePress(InputEvent.BUTTON1_MASK);
+        int x = fromX;
+        int y = fromY;
+        int dx = toX > fromX ? 1 : -1;
+        int dy = toY > fromY ? 1 : -1;
+        while (x != toX || y != toY) {
+            if (x != toX)
+                x = x + dx;
+            if (y != toY)
+                y = y + dy;
+            robot.mouseMove(x, y);
+        }
+        robot.mouseRelease(InputEvent.BUTTON1_MASK);
+        robot.delay(100);
+    }
+
+    /**
+     * Type String
+     * @param text
+     */
+    public static void typeText(String text) {
+        for (int i = 0; i < text.length(); i++) {
+            char ch = text.charAt(i);
+            String[] shiftKeys = keyMap.get(ch);
+            if (shiftKeys == null)
+                throw new RuntimeException("Keys is invalid!");
+            typeShortcut(shiftKeys);
+        }
+    }
+
+    /**
+     * Type shortcut
+     * @param keys
+     */
+    public static void typeShortcut(String... keys) {
+        for(int i = 0; i < keys.length; i++) {
+            String key = keys[i];
+            key = key.toLowerCase();
+            Integer keyCode = keyCodeMap.get(key);
+            if (keyCode == null)
+                throw new RuntimeException("Invalid keys!");
+            robot.keyPress(keyCode);
+        }
+
+        for(int i = keys.length - 1; i >= 0; i--) {
+            String key = keys[i];
+            key = key.toLowerCase();
+            Integer keyCode = keyCodeMap.get(key);
+            if (keyCode == null)
+                throw new RuntimeException("Invalid keys!");
+            robot.keyRelease(keyCode);
+        }
+    }
+
+    /**
+     * Type the keys
+     * To input shortcut, use "<key key key ...>". The keys is separated with space and surrounded with angle brackets.
+     * For example, input the word "hello" and then press Ctrl+A to select the all content.
+     * typeKeys("hello<ctrl a>");
+     *
+     *
+     *
+     * @param keys
+     */
+    public static void typeKeys(String keys) {
+        StringTokenizer tokenizer = new StringTokenizer(keys, "<>", true);
+        int state = 0;
+        while (tokenizer.hasMoreTokens()) {
+            String token = tokenizer.nextToken();
+            switch (state) {
+            case 0:
+                if ("<".equals(token)) {
+                    state = 1;
+                } else if (">".equals(token)) {
+                    throw new RuntimeException("Invalid keys!");
+                } else {
+                    typeText(token);
+                }
+            break;
+            case 1:
+                if (">".equals(token)) {
+                    state = 0;
+                } else if ("<".equals(token)){
+                    throw new RuntimeException("Invalid keys!");
+                } else {
+                    if (token.startsWith("$")) {
+                        String[] ckeys = customizedMap.get(token.substring(1));
+                        if (ckeys == null || ckeys.length == 0)
+                            throw new RuntimeException(token + " is not a customized shortcut!");
+                        typeShortcut(ckeys);
+                    } else {
+                        String[] ckeys = token.split(" ");
+                        typeShortcut(ckeys);
+                    }
+                }
+            }
+        }
+    }
+    protected static HashMap<String, Integer> keyCodeMap = new HashMap<String, Integer>();
+    protected static HashMap<Character, String[]> keyMap = new HashMap<Character, String[]>();
+    protected static HashMap<String, String[]> customizedMap = new HashMap<String, String[]>();
+    static {
+        //US keyboard
+        keyCodeMap.put("esc", KeyEvent.VK_ESCAPE);
+        keyCodeMap.put("f1", KeyEvent.VK_F1);
+        keyCodeMap.put("f2", KeyEvent.VK_F2);
+        keyCodeMap.put("f3", KeyEvent.VK_F3);
+        keyCodeMap.put("f4", KeyEvent.VK_F4);
+        keyCodeMap.put("f5", KeyEvent.VK_F5);
+        keyCodeMap.put("f6", KeyEvent.VK_F6);
+        keyCodeMap.put("f7", KeyEvent.VK_F7);
+        keyCodeMap.put("f8", KeyEvent.VK_F8);
+        keyCodeMap.put("f9", KeyEvent.VK_F9);
+        keyCodeMap.put("f10", KeyEvent.VK_F10);
+        keyCodeMap.put("f11", KeyEvent.VK_F11);
+        keyCodeMap.put("f12", KeyEvent.VK_F12);
+        keyCodeMap.put("printscreen", KeyEvent.VK_PRINTSCREEN);
+        keyCodeMap.put("scrolllock", KeyEvent.VK_SCROLL_LOCK);
+        keyCodeMap.put("pause", KeyEvent.VK_PAUSE);
+        keyCodeMap.put("tab", KeyEvent.VK_TAB);
+        keyCodeMap.put("space", KeyEvent.VK_SPACE);
+        keyCodeMap.put("capslock", KeyEvent.VK_CAPS_LOCK);
+        keyCodeMap.put("shift", KeyEvent.VK_SHIFT);
+        keyCodeMap.put("ctrl", KeyEvent.VK_CONTROL);
+        keyCodeMap.put("alt", KeyEvent.VK_ALT);
+        keyCodeMap.put("bs", KeyEvent.VK_BACK_SPACE);
+        keyCodeMap.put("backspace", KeyEvent.VK_BACK_SPACE);
+        keyCodeMap.put("enter", KeyEvent.VK_ENTER);
+        keyCodeMap.put("cr", KeyEvent.VK_ENTER);
+        keyCodeMap.put("command", 157);
+        keyCodeMap.put("control", KeyEvent.VK_CONTROL);
+        keyCodeMap.put("insert", KeyEvent.VK_INSERT);
+        keyCodeMap.put("del", KeyEvent.VK_DELETE);
+        keyCodeMap.put("delete", KeyEvent.VK_DELETE);
+        keyCodeMap.put("home", KeyEvent.VK_HOME);
+        keyCodeMap.put("end", KeyEvent.VK_END);
+        keyCodeMap.put("pageup", KeyEvent.VK_PAGE_UP);
+        keyCodeMap.put("pagedown", KeyEvent.VK_PAGE_DOWN);
+        keyCodeMap.put("up", KeyEvent.VK_UP);
+        keyCodeMap.put("left", KeyEvent.VK_LEFT);
+        keyCodeMap.put("right", KeyEvent.VK_RIGHT);
+        keyCodeMap.put("down", KeyEvent.VK_DOWN);
+        keyCodeMap.put("numlock", KeyEvent.VK_NUM_LOCK);
+        keyCodeMap.put("a", KeyEvent.VK_A);
+        keyCodeMap.put("b", KeyEvent.VK_B);
+        keyCodeMap.put("c", KeyEvent.VK_C);
+        keyCodeMap.put("d", KeyEvent.VK_D);
+        keyCodeMap.put("e", KeyEvent.VK_E);
+        keyCodeMap.put("f", KeyEvent.VK_F);
+        keyCodeMap.put("g", KeyEvent.VK_G);
+        keyCodeMap.put("h", KeyEvent.VK_H);
+        keyCodeMap.put("i", KeyEvent.VK_I);
+        keyCodeMap.put("j", KeyEvent.VK_J);
+        keyCodeMap.put("k", KeyEvent.VK_K);
+        keyCodeMap.put("l", KeyEvent.VK_L);
+        keyCodeMap.put("m", KeyEvent.VK_M);
+        keyCodeMap.put("n", KeyEvent.VK_N);
+        keyCodeMap.put("o", KeyEvent.VK_O);
+        keyCodeMap.put("p", KeyEvent.VK_P);
+        keyCodeMap.put("q", KeyEvent.VK_Q);
+        keyCodeMap.put("r", KeyEvent.VK_R);
+        keyCodeMap.put("s", KeyEvent.VK_S);
+        keyCodeMap.put("t", KeyEvent.VK_T);
+        keyCodeMap.put("u", KeyEvent.VK_U);
+        keyCodeMap.put("v", KeyEvent.VK_V);
+        keyCodeMap.put("w", KeyEvent.VK_W);
+        keyCodeMap.put("x", KeyEvent.VK_X);
+        keyCodeMap.put("y", KeyEvent.VK_Y);
+        keyCodeMap.put("z", KeyEvent.VK_Z);
+        keyCodeMap.put("0", KeyEvent.VK_0);
+        keyCodeMap.put("1", KeyEvent.VK_1);
+        keyCodeMap.put("2", KeyEvent.VK_2);
+        keyCodeMap.put("3", KeyEvent.VK_3);
+        keyCodeMap.put("4", KeyEvent.VK_4);
+        keyCodeMap.put("5", KeyEvent.VK_5);
+        keyCodeMap.put("6", KeyEvent.VK_6);
+        keyCodeMap.put("7", KeyEvent.VK_7);
+        keyCodeMap.put("8", KeyEvent.VK_8);
+        keyCodeMap.put("9", KeyEvent.VK_9);
+        keyCodeMap.put("`", KeyEvent.VK_BACK_QUOTE);
+        keyCodeMap.put("-", KeyEvent.VK_MINUS);
+        keyCodeMap.put("=", KeyEvent.VK_EQUALS);
+        keyCodeMap.put("[", KeyEvent.VK_OPEN_BRACKET);
+        keyCodeMap.put("]", KeyEvent.VK_CLOSE_BRACKET);
+        keyCodeMap.put("\\", KeyEvent.VK_BACK_SLASH);
+        keyCodeMap.put(";", KeyEvent.VK_SEMICOLON);
+        keyCodeMap.put("\'", KeyEvent.VK_QUOTE);
+        keyCodeMap.put(",", KeyEvent.VK_COMMA);
+        keyCodeMap.put(".", KeyEvent.VK_PERIOD);
+        keyCodeMap.put("/", KeyEvent.VK_SLASH);
+
+
+        String chars = "`1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./";
+        String shiftChars = "~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?";
+        for(int i = 0; i < chars.length(); i++) {
+            keyMap.put(chars.charAt(i), new String[]{chars.substring(i, i + 1)});
+            keyMap.put(shiftChars.charAt(i), new String[]{"shift", chars.substring(i, i + 1)});
+        }
+        keyMap.put(' ', new String[]{"space"});
+        keyMap.put('\t', new String[]{"tab"});
+    }
+
+    public static void setCustomizedShortcut(String name, String... keys) {
+        customizedMap.put(name, keys);
+    }
+
+    public static void main(String[] args) {
+        Tester.sleep(3);
+        Tester.typeKeys("    ");
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/VclInspector.java b/test/testcommon/source/org/openoffice/test/vcl/VclInspector.java
new file mode 100644
index 000000000000..73c039443074
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/VclInspector.java
@@ -0,0 +1,128 @@
+/************************************************************************
+ *
+ * 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.vcl;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JToolBar;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.table.DefaultTableModel;
+
+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.client.CommandCaller.WinInfoReceiver;
+
+/**
+ * Use the application to inspect vcl widgets in the openoffice.
+ *
+ */
+public class VclInspector extends JFrame implements WinInfoReceiver {
+
+    /**
+     *
+     */
+    private static final long serialVersionUID = 1L;
+
+    private JTable winInfoEditor = null;
+
+    public VclInspector(){
+        super("VCL Inspector");
+    }
+
+
+    private void init() {
+        try {
+            UIManager.getInstalledLookAndFeels();
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (Exception e1) {
+        }
+
+        setSize(800, 600);
+
+        JToolBar toolBar = new JToolBar("Tools");
+        JButton button = new JButton("Inspect");
+        button.setToolTipText("Inspect VCL controls.");
+        button.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                inspect();
+              }
+        });
+        toolBar.add(button);
+
+        add(toolBar, BorderLayout.PAGE_START);
+        String col[] = {"Type", "ID", "ToolTip"};
+        DefaultTableModel model = new DefaultTableModel(null ,col);
+        winInfoEditor = new JTable(model);
+        winInfoEditor.getColumnModel().getColumn(0).setMaxWidth(60);
+        winInfoEditor.getColumnModel().getColumn(1).setMaxWidth(100);
+        JScrollPane pane1 = new JScrollPane(winInfoEditor);
+
+        add(pane1, BorderLayout.CENTER);
+
+        addWindowListener(new WindowAdapter() {
+            public void windowClosing(WindowEvent e) {
+                VclHook.getCommunicationManager().stop();
+                System.exit(0);
+            };
+
+        });
+    }
+
+    public void open() {
+        init();
+        setVisible(true);
+    }
+
+
+
+    public void addWinInfo(final SmartId id, final long type, final String t) {
+        final String tooltip = t.replaceAll("%.*%.*:", "");
+        SwingUtilities.invokeLater(new Runnable() {
+            public void run() {
+                ((DefaultTableModel)winInfoEditor.getModel()).addRow(new Object[]{type, id, tooltip});
+            }
+        });
+
+    }
+
+    public void onStartReceiving() {
+        SwingUtilities.invokeLater(new Runnable() {
+            public void run() {
+                ((DefaultTableModel)winInfoEditor.getModel()).setRowCount(0);
+            }
+        });
+    }
+
+
+    public void inspect() {
+        VclHook.invokeCommand(Constant.RC_DisplayHid, new Object[]{Boolean.TRUE});
+    }
+
+    public static void main(String[] args) {
+        VclInspector inspector = new VclInspector();
+        VclHook.getCommandCaller().setWinInfoReceiver(inspector);
+        inspector.open();
+    }
+
+
+    public void onFinishReceiving() {
+
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/CommandCaller.java b/test/testcommon/source/org/openoffice/test/vcl/client/CommandCaller.java
new file mode 100644
index 000000000000..2bf6932f317d
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/CommandCaller.java
@@ -0,0 +1,559 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * The class is used to send a statement to the automation server.
+ *
+ *
+ */
+public class CommandCaller implements CommunicationListener, Constant {
+
+    public static interface WinInfoReceiver {
+        void onStartReceiving();
+        void addWinInfo(SmartId id, long type, String t1);
+        void onFinishReceiving();
+
+    }
+
+    private ByteArrayOutputStream dataOutput = new ByteArrayOutputStream(1024);
+
+    private ByteArrayInputStream dataInput = null;
+
+    private CommunicationManager communicationManager = null;
+
+    private int sequence = 0;
+
+    private WinInfoReceiver winInfoReceiver = null;
+
+    private boolean receivingWinInfo = false;
+
+    /**Store the response**/
+    private Object response = null;
+
+    private SmartId responseExceptionId = null;
+
+    private String responseExceptionMessage = null;
+
+    /**A variable to indicate if the server answered the request **/
+    private boolean answered = false;
+
+    public CommandCaller(CommunicationManager communicationManager) {
+        this.communicationManager = communicationManager;
+    }
+
+    private void write(byte[] bytes) {
+        try {
+            dataOutput.write(bytes);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private byte[] read(int len) {
+        byte[] bytes = new byte[len];
+        try {
+            dataInput.read(bytes);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return bytes;
+    }
+
+
+    /**
+     * Write the data type
+     * @param i
+     */
+    private void writeChar(int i) {
+        byte[] bytes = new byte[2];
+        bytes[1] = (byte) ((i & 0xFF00) >> 8);
+        bytes[0] = (byte) (i & 0x00FF);
+        write(bytes);
+    }
+
+    private int readChar() {
+        byte[] bytes = read(2);
+        return (bytes[0] & 0x00FF) + ((bytes[1] & 0x00FF) << 8);
+    }
+
+
+    /**
+     * Check the type of next data
+     * The bytes used to identify the type will not be read out from the stream
+     * @return
+     */
+    private int nextType() {
+        dataInput.mark(0);
+        int type = readChar();
+        dataInput.reset();
+        return type;
+    }
+
+    /**
+     * Write an unsigned 16-bit integer
+     * @param i
+     */
+    private void writeUShort(int i) {
+        writeChar(BinUSHORT);
+        writeChar(i);
+    }
+
+    /**
+     * Read an unsigned 16-bit integer
+     * @return
+     */
+    private int readUShort() {
+        if (readChar() != BinUSHORT)
+            throw new RuntimeException("Bad data!");
+
+        byte[] bytes = read(2);
+        return (bytes[0] & 0x00FF) + ((bytes[1] & 0x00FF) << 8);
+    }
+
+    /**
+     * Write an unsigned 32-bit integer
+     * @param i
+     */
+    private void writeULong(long i)  {
+        writeChar(BinULONG);
+        byte[] bytes = new byte[4];
+        bytes[3] = (byte) ((i & 0xFF000000L) >> 24);
+        bytes[2] = (byte) ((i & 0x00FF0000L) >> 16);
+        bytes[1] = (byte) ((i & 0x0000FF00L) >> 8);
+        bytes[0] = (byte) ((i & 0x000000FFL));
+        write(bytes);
+    }
+
+    /**
+     * Read an unsigned 32-bit integer
+     * @return
+     */
+    private long readULong() {
+        if (readChar() != BinULONG)
+            throw new RuntimeException("Bad data!");
+        byte[] bytes = read(4);
+        return (bytes[0] & 0x00FFL) + ((bytes[1] & 0x00FFL) << 8) + ((bytes[2] & 0x00FFL) << 16) + ((bytes[3] & 0x00FFL) << 24);
+    }
+
+    /**
+     * Write boolean
+     * @param bBool
+     */
+    private void writeBoolean(boolean bBool) {
+        writeChar(BinBool);
+        write(new byte[] { bBool ? (byte) 1 : 0 });
+    }
+
+    /**
+     * Read boolean
+     * @return
+     */
+    private boolean readBoolean() {
+        if (readChar() != BinBool)
+            throw new RuntimeException("Bad data!");
+        byte[] bytes = read(1);
+        return bytes[0] != 0;
+    }
+
+    /**
+     * Write a string
+     * @param str
+     */
+    private void writeString(String str) {
+        writeChar(BinString);
+        int len =  str.length();
+        if (len > 0xFFFF) {
+            throw new RuntimeException("String is too long.");
+        }
+        writeChar(len);
+        char[] chars = str.toCharArray();
+        for (int i = 0 ; i < len; i++)
+            writeChar(chars[i]);
+    }
+
+    /**
+     * Read a string
+     * @return
+     */
+    private String readString() {
+        if (readChar() != BinString)
+            throw new RuntimeException("Bad data!");
+        int len = readChar();
+        char[] chars = new char[len];
+        for (int i = 0; i < len; i++) {
+            chars[i] = (char) readChar();
+        }
+        return new String(chars);
+    }
+
+    private void writeParams(Object[] args) {
+        int nParams = PARAM_NONE;
+        int nNr1=0;
+        int nNr2=0;
+        int nNr3=0;
+        int nNr4=0;
+        long nLNr1=0;
+        String aString1=null;
+        String aString2=null;
+        boolean bBool1=false;
+        boolean bBool2=false;
+
+        if (args != null) {
+            for (int i = 0; i < args.length; i++) {
+                if (args[i] instanceof Short || args[i] instanceof Integer) {
+                    int c =  ((Number) args[i]).intValue();
+                    if ((nParams & PARAM_USHORT_1) == 0) {
+                        nParams |= PARAM_USHORT_1;
+                        nNr1 = c;
+                    } else if ((nParams & PARAM_USHORT_2) == 0) {
+                        nParams |= PARAM_USHORT_2;
+                        nNr2 = c;
+                    } else if ((nParams & PARAM_USHORT_3) == 0) {
+                        nParams |= PARAM_USHORT_3;
+                        nNr3 = c;
+                    } else if ((nParams & PARAM_USHORT_4) == 0) {
+                        nParams |= PARAM_USHORT_4;
+                        nNr4 = c;
+                    } else {
+                        //TODO error
+                    }
+                } else if (args[i] instanceof Long) {
+                    long l = ((Long) args[i]).longValue();
+                    nParams |= PARAM_ULONG_1;
+                    nLNr1 = l;
+                } else if (args[i] instanceof Boolean) {
+                    if ((nParams & PARAM_BOOL_1) == 0) {
+                        nParams |= PARAM_BOOL_1;
+                        bBool1 = ((Boolean) args[i]).booleanValue();
+                    } else if ((nParams & PARAM_BOOL_2) == 0) {
+                        nParams |= PARAM_BOOL_2;
+                        bBool2 = ((Boolean) args[i]).booleanValue();
+                    } else {
+                        //TODO error
+                    }
+
+                } else if (args[i] instanceof String) {
+                    if ((nParams & PARAM_STR_1) == 0) {
+                        nParams |= PARAM_STR_1;
+                        aString1 = (String) args[i];
+                    } else if ((nParams & PARAM_STR_2) == 0) {
+                        nParams |= PARAM_STR_2;
+                        aString2 = (String) args[i];
+                    } else {
+                        //TODO error
+                    }
+                }
+            }
+        }
+
+        writeUShort(nParams);
+        if ((nParams & PARAM_USHORT_1) != 0) {
+            writeUShort(nNr1);
+        }
+
+        if ((nParams & PARAM_USHORT_2) != 0) {
+            writeUShort(nNr2);
+        }
+
+        if ((nParams & PARAM_USHORT_3) != 0) {
+            writeUShort(nNr3);
+        }
+
+        if ((nParams & PARAM_USHORT_4) != 0) {
+            writeUShort(nNr4);
+        }
+
+        if ((nParams & PARAM_ULONG_1) != 0) {
+            writeULong(nLNr1);
+        }
+
+        if ((nParams & PARAM_STR_1) != 0) {
+            writeString(aString1);
+        }
+
+        if ((nParams & PARAM_STR_2) != 0) {
+            writeString(aString2);
+        }
+
+        if ((nParams & PARAM_BOOL_1) != 0) {
+            writeBoolean(bBool1);
+        }
+        if ((nParams & PARAM_BOOL_2) != 0) {
+            writeBoolean(bBool2);
+        }
+
+    }
+
+    private void send() {
+        byte[] data = dataOutput.toByteArray();
+        dataOutput.reset();
+        int protocal = CM_PROTOCOL_OLDSTYLE;
+        byte[] header = new byte[]{(byte)((protocal >>> 8) & 0xFF), (byte) ((protocal >>> 0) & 0xFF)};
+        communicationManager.sendPackage(CH_SimpleMultiChannel, header, data);
+    }
+
+    /**
+     * The data arrives
+     */
+    public synchronized void received(int headerType, byte[] header, byte[] data) {
+        if (headerType != CommunicationManager.CH_Handshake) {
+            dataInput = new ByteArrayInputStream(data);
+            handleResponse();
+            dataInput = null;
+            answered = true;
+            notifyAll();
+        }
+    }
+
+    /**
+     * This method is called when the communication is started.
+     */
+    public void start() {
+    }
+
+    /**
+     * This method is called when the communication is closed
+     */
+    public synchronized void stop() {
+        answered = true;
+        notifyAll();
+    }
+
+
+    private SmartId readId() {
+        int type = nextType();
+        if ( type == BinString) {
+            return new SmartId(readString());
+        } else if (type == BinULONG) {
+            return new SmartId(readULong());
+        }
+
+        throw new RuntimeException("Bad data!");
+    }
+
+    private void handleResponse() {
+        this.response = null;
+        this.responseExceptionId = null;
+        this.responseExceptionMessage = null;
+
+        while (dataInput.available() >= 2) {
+            int id = readUShort();
+            switch (id) {
+            case SIReturn:
+                int returnType = readUShort();
+                SmartId sid = readId();
+                int nNr1 = 0;
+                long nLNr1 = 0;
+                String aString1 = null;
+                boolean bBool1 = false;
+                int params = readUShort();
+                if ((params & PARAM_USHORT_1) != 0)
+                    nNr1 = readUShort();
+                if ((params & PARAM_ULONG_1) != 0)
+                    nLNr1 = readULong();
+                if ((params & PARAM_STR_1) != 0)
+                    aString1 = readString();
+                if ((params & PARAM_BOOL_1) != 0)
+                    bBool1 = readBoolean();
+                if ((params & PARAM_SBXVALUE_1) != 0) {
+                    // Don't support????
+                }
+
+                switch (returnType) {
+                case RET_Sequence:
+                    if (sid.getId() != sequence)
+                        this.responseExceptionMessage = "Bad sequence of command.";
+                    break;
+                case RET_Value:
+                    List<Object> ret = new ArrayList<Object>();
+                    if ((params & PARAM_USHORT_1) != 0)
+                        ret.add(new Integer(nNr1));
+                    if ((params & PARAM_ULONG_1) != 0)
+                        ret.add(new Long(nLNr1));
+                    if ((params & PARAM_STR_1) != 0)
+                        ret.add(aString1);
+                    if ((params & PARAM_BOOL_1) != 0)
+                        ret.add(new Boolean(bBool1));
+                    this.response = ret.size() == 1 ? ret.get(0): ret;
+                    break;
+                case RET_WinInfo:
+                    if (bBool1) {
+                        receivingWinInfo = true;
+                        if (winInfoReceiver != null)
+                            winInfoReceiver.onStartReceiving();
+                    } else {
+                        if (winInfoReceiver != null)
+                            winInfoReceiver.addWinInfo(sid, nLNr1, aString1);
+                    }
+                    break;
+                }
+
+                break;
+            case SIReturnError:
+                this.responseExceptionId = readId();
+                this.responseExceptionMessage = readString();
+                break;
+            }
+        }
+
+        if (receivingWinInfo) {
+            if (winInfoReceiver != null)
+                winInfoReceiver.onFinishReceiving();
+            receivingWinInfo = false;
+        }
+    }
+
+
+    public void setWinInfoReceiver(WinInfoReceiver receiver) {
+        this.winInfoReceiver = receiver;
+    }
+
+    private void callFlow(int nArt) {
+        writeUShort(SIFlow);
+        writeUShort(nArt);
+        writeUShort(PARAM_NONE);
+    }
+
+
+    private void callFlow(int nArt, long nLNr1) {
+        writeUShort(SIFlow);
+        writeUShort(nArt);
+        writeUShort(PARAM_ULONG_1);
+        writeULong(nLNr1);
+    }
+
+    /**
+     * Tell automation server to execute a 'StatementCommand'
+     * @param methodId The method ID
+     * @param args the arguments. The arguments can be Integer, Long, Boolean and String.
+     * @return The return can be Integer, Long, String and Boolean or an Object[] includes these types of object.
+     */
+    public synchronized Object callCommand(int methodId, Object[] args) {
+        beginBlock();
+        writeUShort(SICommand);
+        writeUShort(methodId);
+        writeParams(args);
+        endBlock();
+
+        if ((methodId & M_WITH_RETURN) != 0) {
+            return response;
+        }
+
+        return null;
+    }
+
+    /**
+     *  Tell automation server to execute a 'StatementControl'
+     * @param uid the control ID
+     * @param methodId the method ID defined Constant class
+     * @param args the arguments. The arguments can be Integer, Long, Boolean and String.
+     * @return The return can be Integer, Long, String and Boolean or an Object[] includes these types of object.
+     */
+    public synchronized Object callControl(SmartId uid, int methodId, Object[] args){
+        beginBlock();
+        if (uid.getSid() != null) {
+            writeUShort(SIStringControl);
+            writeString(uid.getSid());
+        } else {
+            writeUShort(SIControl);
+            writeULong(uid.getId());
+        }
+
+        writeUShort(methodId);
+        writeParams(args);
+        endBlock();
+
+        if ((methodId & M_WITH_RETURN) != 0) {
+            return response;
+        }
+
+        return null;
+    }
+
+    /**
+     * Tell automation server to execute a 'StatementUNOSlot'
+     * @param url the UNO slot url
+     */
+    public synchronized void callUNOSlot(String url) {
+        beginBlock();
+        writeUShort(SIUnoSlot);
+        writeString(url);
+        endBlock();
+    }
+
+    /**
+     * Tell automation server to execute a 'StatementSlot'
+     * @param id the slot ID
+     * @param args the slot args
+     */
+    public synchronized void callSlot(int id, Object[] args) {
+        beginBlock();
+        writeUShort(SISlot);
+        writeUShort(id);
+        if (args.length % 2 != 0)
+            throw new RuntimeException("bad arg");
+        writeUShort(args.length / 2);
+        for (int i = 0; i < args.length; i++) {
+            if (!(args[i] instanceof String))
+                throw new RuntimeException("bad arg");
+            writeString((String)args[i]);
+            i++;
+            if (args[i] instanceof Boolean) {
+                writeBoolean((Boolean)args[i]);
+            } else if (args[i] instanceof String) {
+                writeString((String)args[i]);
+            } else if (args[i] instanceof Short || args[i] instanceof Integer) {
+                writeUShort(((Number) args[i]).intValue());
+            } else if (args[i] instanceof Long) {
+                writeULong((Long) args[i]);
+            } else {
+                throw new RuntimeException("bad arg");
+            }
+        }
+        endBlock();
+    }
+
+
+    private void beginBlock() {
+        callFlow(F_Sequence, ++sequence);
+    }
+
+    private void endBlock() {
+        callFlow(F_EndCommandBlock);
+        answered = false;
+        send();
+        int MAX_RETRY = 240;//max waiting time is two minutes.
+        for (int i = 0; !answered && i < MAX_RETRY; i++) {
+            try {
+                wait(500);
+            } catch (InterruptedException e) {
+
+            }
+        }
+
+        // Still answered
+        if (!answered) {
+            communicationManager.stop();
+            throw new CommunicationException("Failed to get data from automation server!");
+        }
+
+        if (responseExceptionId != null || responseExceptionMessage != null)
+            throw new VclHookException(responseExceptionId, responseExceptionMessage);
+
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationException.java b/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationException.java
new file mode 100644
index 000000000000..3ec1d51bc9b3
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationException.java
@@ -0,0 +1,39 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+/**
+ * Exception that occurs when socket communication has a problem.
+ *
+ */
+public class CommunicationException extends RuntimeException {
+
+    /**
+     *
+     */
+    private static final long serialVersionUID = 1L;
+
+    public CommunicationException() {
+        super();
+    }
+
+    public CommunicationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public CommunicationException(String message) {
+        super(message);
+    }
+
+    public CommunicationException(Throwable cause) {
+        super(cause);
+    }
+
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationListener.java b/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationListener.java
new file mode 100644
index 000000000000..4a5068d4a331
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationListener.java
@@ -0,0 +1,23 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+/**
+ * Callback when data package is arriving.
+ *
+ */
+public interface CommunicationListener {
+
+    public void start();
+
+    public void received(int headerType, byte[] header, byte[] data);
+
+    public void stop();
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationManager.java b/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationManager.java
new file mode 100644
index 000000000000..7528d44ee69c
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/CommunicationManager.java
@@ -0,0 +1,269 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.List;
+import java.util.Vector;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Manage the communication with the automation server.
+ * It's used to establish the connection, send and receive data package.
+ * Data package format:
+ *
+ * | [Force Multi Channel (0xFFFFFFFF)] | Data Length (32 bits) | Check Byte (8 bits) | Header Length (16 bits) | Header Data | Body Data |
+ *
+ * To handle the received data, add a communication listener to the manager.
+ * The listner will be called back when data package arrives.
+ *
+ */
+public class CommunicationManager implements Runnable, Constant{
+
+    private static Logger logger = Logger.getLogger("CommunicationManager");
+
+    private final static int DEFAULT_PORT = 12479;
+
+    private String host = "localhost";
+
+    private int port = DEFAULT_PORT;
+
+    private Socket socket = null;
+
+    private int reconnectInterval = 4000;
+
+    private int reconnectCount = 3;
+
+    private List<CommunicationListener> listeners = new Vector<CommunicationListener>();
+
+    /**
+     * Create a communication manager with the default host and port.
+     * The default host is local and the default port is 12479.
+     *
+     */
+    public CommunicationManager() {
+        try {
+            String portValue = System.getProperty("openoffice.automation.port");
+            if (portValue != null)
+                port = Integer.parseInt(portValue);
+        } catch (NumberFormatException e) {
+            // use default
+        }
+    }
+
+    /**
+     * Create a communication manager with the given host and port
+     * @param host
+     * @param port
+     */
+    public CommunicationManager(String host, int port) {
+        this.host = host;
+        this.port = port;
+    }
+
+
+    /**
+     * Get the max count retrying to connect the server
+     * @return
+     */
+    public int getReconnectCount() {
+        return reconnectCount;
+    }
+
+    /**
+     * Set the max count retrying to connect the server
+     * @param reconnectCount
+     */
+    public void setReconnectCount(int reconnectCount) {
+        this.reconnectCount = reconnectCount;
+    }
+
+    /**
+     * Get the interval between retrying to connect the server
+     * @return
+     */
+    public int getReconnectInterval() {
+        return reconnectInterval;
+    }
+
+    /**
+     * Set the interval between retrying to connect the server
+     * @param reconnectInterval
+     */
+    public void setReconnectInterval(int reconnectInterval) {
+        this.reconnectInterval = reconnectInterval;
+    }
+
+    /**
+     * Send a data package to server
+     * @param headerType the package header type
+     * @param header the data in the header
+     * @param data the data in the body
+     */
+    public synchronized void sendPackage(int headerType, byte[] header, byte[] data) throws CommunicationException {
+        if (socket == null)
+            start();
+
+        try {
+            if (header == null)
+                header = new byte[0];
+
+            if (data == null)
+                data = new byte[0];
+
+            DataOutputStream os = new DataOutputStream(socket.getOutputStream());
+            int len = 1 + 2 + 2 + header.length + data.length;
+            // Total len
+            os.writeInt(len);
+            // Check byte
+            os.writeByte(calcCheckByte(len));
+            // Header len
+            os.writeChar(2 + header.length);
+            // Header
+            os.writeChar(headerType);
+            os.write(header);
+            // Data
+            os.write(data);
+            os.flush();
+        } catch (IOException e) {
+            stop();
+            throw new CommunicationException("Failed to send data to automation server!", e);
+        }
+    }
+
+    /**
+     * Start a new thread to read the data sent by sever
+     */
+    public void run() {
+        try {
+            while (socket != null) {
+                DataInputStream is = new DataInputStream(socket.getInputStream());
+
+                int len = is.readInt();
+                if (len == 0xFFFFFFFF)
+                    len = is.readInt();
+
+                byte checkByte = is.readByte();
+                if (calcCheckByte(len) != checkByte)
+                    throw new CommunicationException("Bad data package. Wrong check byte.");
+
+                int headerLen = is.readUnsignedShort();
+                int headerType = is.readUnsignedShort();
+                byte[] header = new byte[headerLen - 2];
+                is.readFully(header);
+                byte[] data = new byte[len - headerLen - 3];
+                is.readFully(data);
+                for (int i = 0; i < listeners.size(); i++)
+                    ((CommunicationListener) listeners.get(i)).received(headerType, header, data);
+            }
+        } catch (Exception e) {
+            logger.log(Level.FINEST, "Failed to receive data!", e);
+            stop();
+        }
+    }
+
+    /**
+     * Add a communication listener
+     * @param listener
+     */
+    public void addListener(CommunicationListener listener) {
+        if (listener != null && !listeners.contains(listener))
+            listeners.add(listener);
+    }
+
+
+    /**
+     * Stop the communication manager.
+     *
+     */
+    public synchronized void stop() {
+        if (socket == null)
+            return;
+
+        try {
+            socket.close();
+        } catch (IOException e) {
+            //ignore
+        }
+        socket = null;
+        logger.log(Level.CONFIG, "Stop Communication Manager");
+        for (int i = 0; i < listeners.size(); i++)
+            ((CommunicationListener) listeners.get(i)).stop();
+    }
+
+    public synchronized boolean isConnected() {
+        return socket != null;
+    }
+
+
+    public synchronized void connect() throws IOException {
+        if (socket != null)
+            return;
+
+        try{
+            socket = new Socket();
+            socket.setTcpNoDelay(true);
+            socket.setSoTimeout(240 * 1000); // if in 4 minutes we get nothing from server, an exception will thrown.
+            socket.connect(new InetSocketAddress(host, port));
+            Thread thread = new Thread(this);
+            thread.setDaemon(true);
+            thread.start();
+        } catch (IOException e){
+            socket = null;
+            throw e;
+        }
+    }
+
+    /**
+     * Start the communication manager.
+     *
+     */
+    public synchronized void start() {
+        logger.log(Level.CONFIG, "Start Communication Manager");
+        //connect and retry if fails
+        for (int i = 0; i < reconnectCount; i++) {
+            try {
+                connect();
+                return;
+            } catch (IOException e) {
+                logger.log(Level.FINEST, "Failed to connect! Tried " + i, e);
+            }
+
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException e) {
+                //ignore
+            }
+        }
+
+        throw new CommunicationException("Failed to connect automation server!");
+    }
+
+
+    private static byte calcCheckByte(int i) {
+        int nRes = 0;
+        int[] bytes = new int[4];
+        bytes[0] = (i >>> 24) & 0x00FF;
+        bytes[1] = (i >>> 16) & 0x00FF;
+        bytes[2] = (i >>> 8) & 0x00FF;
+        bytes[3] = (i >>> 0) & 0x00FF;
+        nRes += bytes[0] ^ 0xf0;
+        nRes += bytes[1] ^ 0x0f;
+        nRes += bytes[2] ^ 0xf0;
+        nRes += bytes[3] ^ 0x0f;
+        nRes ^= (nRes >>> 8);
+        return (byte) nRes;
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/Constant.java b/test/testcommon/source/org/openoffice/test/vcl/client/Constant.java
new file mode 100644
index 000000000000..887a1613c276
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/Constant.java
@@ -0,0 +1,499 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+/**
+ * Define all constant variables
+ *
+ */
+public interface Constant {
+
+    public final static int CH_NoHeader = 0x0000;
+
+    public final static int CH_SimpleMultiChannel = 0x0001;
+
+    public final static int CH_Handshake = 0x0002;
+
+    public final static int CH_REQUEST_HandshakeAlive = 0x0101;
+
+    public final static int CH_RESPONSE_HandshakeAlive = 0x0102;
+
+    public final static int CH_REQUEST_ShutdownLink = 0x0104;
+
+    public final static int CH_ShutdownLink = 0x0105;
+
+    public final static int CH_SUPPORT_OPTIONS = 0x0103;
+
+    public final static int CH_SetApplication = 0x0106;
+
+    public final static int CM_PROTOCOL_OLDSTYLE = 0x0001;
+
+    public final static int CM_PROTOCOL_MARS = 0x0001;
+
+    public final static int CM_PROTOCOL_BROADCASTER = 0x0002;
+
+    public final static int CM_PROTOCOL_USER_START = 0x0100;
+
+    public static final char SIControl = 3;
+
+    public static final char SISlot = 4;
+
+    public static final char SIFlow = 5;
+
+    public static final char SICommand = 6;
+
+    public static final char SIUnoSlot = 7;
+
+    public static final char SIStringControl = 8;
+
+    public static final char SIReturnBlock = 11;
+
+    public static final char SIReturn = 12;
+
+    public static final char SIReturnError = 13;
+
+    public static final char RET_Sequence = 132;
+
+    public static final char RET_Value = 133;
+
+    public static final char RET_WinInfo = 134;
+
+    public static final char RET_ProfileInfo = 135;
+
+    public static final char RET_DirectLoging = 136;
+
+    public static final char RET_MacroRecorder = 137;
+
+    public static final char BinUSHORT = 11;
+
+    public static final char BinULONG = 14;
+
+    public static final char BinString = 12;
+
+    public static final char BinBool = 13;
+
+    public static final char BinSbxValue = 15;
+
+    public static final char PARAM_NONE = 0x0000;
+
+    public static final char PARAM_USHORT_1 = 0x0001;
+
+    public static final char PARAM_USHORT_2 = 0x0002;
+
+    public static final char PARAM_USHORT_3 = 0x0100;
+
+    public static final char PARAM_USHORT_4 = 0x0200;
+
+    public static final char PARAM_ULONG_1 = 0x0004;
+
+    public static final char PARAM_ULONG_2 = 0x0008;
+
+    public static final char PARAM_STR_1 = 0x0010;
+
+    public static final char PARAM_STR_2 = 0x0020;
+
+    public static final char PARAM_BOOL_1 = 0x0040;
+
+    public static final char PARAM_BOOL_2 = 0x0080;
+
+    public static final char PARAM_SBXVALUE_1 = 0x0400;
+
+    public static final char F_EndCommandBlock = 101;
+
+    public static final char F_Sequence = 102;
+
+    public static final char M_WITH_RETURN = 0x0200;
+
+    public static final char M_KEY_STRING = 0x0400;
+
+    public static final char M_SOFFICE = 0x0800;
+
+    public static final char M_MOZILLA = 0x1000;
+
+    // for MacroRecorder
+    public static final char M_RET_NUM_CONTROL = 0x2000; // decode ULong as
+    // Control (For
+    // Tabpages,
+    // Toolboxes, ... )
+
+    public static final char M_Select = 21;
+
+    public static final char M_SetNoSelection = 22;
+
+    public static final char M_SetText = 23;
+
+    public static final char M_More = 24;
+
+    public static final char M_Less = 25;
+
+    public static final char M_ToMin = 26;
+
+    public static final char M_ToMax = 27;
+
+    public static final char M_Check = 28;
+
+    public static final char M_UnCheck = 29;
+
+    public static final char M_TriState = 30;
+
+    public static final char M_SetPage = 31;
+
+    public static final char M_Click = 32;
+
+    public static final char M_Close = 33; // Push Buttons on Dialog (Auch More
+    // Button)
+
+    public static final char M_Cancel = 34;
+
+    public static final char M_OK = 35;
+
+    public static final char M_Help = 36;
+
+    public static final char M_Default = 37; // Push defaultbutton on Dialog
+
+    public static final char M_Yes = 38;
+
+    public static final char M_No = 39;
+
+    public static final char M_Repeat = 40;
+
+    public static final char M_Open = 41;
+
+    public static final char M_Pick = 42;
+
+    public static final char M_Move = 43;
+
+    public static final char M_Size = 44;
+
+    public static final char M_Minimize = 45;
+
+    public static final char M_Maximize = 46;
+
+    public static final char M_Dock = 47;
+
+    public static final char M_Undock = 48;
+
+    public static final char M_TypeKeys = (M_KEY_STRING | 50);
+
+    public static final char M_MouseDown = 51;
+
+    public static final char M_MouseUp = 52;
+
+    public static final char M_MouseMove = 53;
+
+    public static final char M_MouseDoubleClick = 54;
+
+    public static final char M_SnapShot = 55;
+
+    public static final char M_SetNextToolBox = 56;
+
+    public static final char M_OpenContextMenu = 57;
+
+    public static final char M_MultiSelect = 58;
+
+    // Filedialog
+    public static final char M_SetPath = 60;
+
+    public static final char M_SetCurFilter = 61;
+
+    // Printdialog
+    public static final char M_SetPrinter = 70;
+
+    public static final char M_CheckRange = 71;
+
+    public static final char M_SetRangeText = 72;
+
+    public static final char M_SetFirstPage = 73;
+
+    public static final char M_SetLastPage = 74;
+
+    public static final char M_CheckCollate = 75;
+
+    public static final char M_SetPageId = 76;
+
+    public static final char M_SetPageNr = 77;
+
+    public static final char M_AnimateMouse = 78;
+
+    public static final char M_TearOff = 79;
+
+    public static final char M_FadeIn = 80;
+
+    public static final char M_FadeOut = 81;
+
+    public static final char M_Pin = 82;
+
+    public static final char M_UseMenu = 83; // Use the menu of the next
+    // possible parent of given
+    // Window
+
+    public static final char M_OpenMenu = 84; // MenuButtons and Menus in
+    // ToolBoxes
+
+    public static final char M_Restore = 85; // Window Control together with
+    // M_Maximize and M_Minimize
+
+    public static final char M_DisplayPercent = 200;
+
+    public static final char M_LAST_NO_RETURN = 200;
+
+    public static final char M_Exists = (M_WITH_RETURN | 1);
+
+    public static final char M_NotExists = (M_WITH_RETURN | 2);
+
+    public static final char M_IsEnabled = (M_WITH_RETURN | 3);
+
+    public static final char M_IsVisible = (M_WITH_RETURN | 4);
+
+    public static final char M_IsWritable = (M_WITH_RETURN | 5);
+
+    public static final char M_GetPage = (M_WITH_RETURN | 6);
+
+    public static final char M_IsChecked = (M_WITH_RETURN | 7);
+
+    public static final char M_IsTristate = (M_WITH_RETURN | 8);
+
+    public static final char M_GetState = (M_WITH_RETURN | 9);
+
+    public static final char M_GetText = (M_WITH_RETURN | 10);
+
+    public static final char M_GetSelCount = (M_WITH_RETURN | 11);
+
+    public static final char M_GetSelIndex = (M_WITH_RETURN | 12);
+
+    public static final char M_GetSelText = (M_WITH_RETURN | 13);
+
+    public static final char M_GetItemCount = (M_WITH_RETURN | 14);
+
+    public static final char M_GetItemText = (M_WITH_RETURN | 15);
+
+    public static final char M_IsOpen = (M_WITH_RETURN | 16);
+
+    public static final char M_Caption = (M_WITH_RETURN | 17);
+
+    public static final char M_IsMax = (M_WITH_RETURN | 18);
+
+    public static final char M_IsDocked = (M_WITH_RETURN | 19);
+
+    public static final char M_GetRT = (M_WITH_RETURN | 20);
+
+    public static final char M_GetPageId = (M_WITH_RETURN | 21);
+
+    public static final char M_GetPageCount = (M_WITH_RETURN | 22);
+
+    public static final char M_GetPosX = (M_WITH_RETURN | 23);
+
+    public static final char M_GetPosY = (M_WITH_RETURN | 24);
+
+    public static final char M_GetSizeX = (M_WITH_RETURN | 25);
+
+    public static final char M_GetSizeY = (M_WITH_RETURN | 26);
+
+    public static final char M_GetNextToolBox = (M_WITH_RETURN | 27);
+
+    public static final char M_GetButtonCount = (M_WITH_RETURN | 28);
+
+    public static final char M_GetButtonId = (M_WITH_RETURN | 29);
+
+    public static final char M_IsFadeIn = (M_WITH_RETURN | 30);
+
+    public static final char M_IsPin = (M_WITH_RETURN | 31);
+
+    // Statusbar
+    public static final char M_StatusGetText = (M_WITH_RETURN | 32);
+
+    public static final char M_StatusIsProgress = (M_WITH_RETURN | 33);
+
+    public static final char M_StatusGetItemCount = (M_WITH_RETURN | 34);
+
+    public static final char M_StatusGetItemId = (M_WITH_RETURN | 35);
+
+    //
+    public static final char M_GetMouseStyle = (M_WITH_RETURN | 36);
+
+    // support for Messagebox with checkbox
+    public static final char M_GetCheckBoxText = (M_WITH_RETURN | 37);
+
+    // Scrollbars
+    public static final char M_HasScrollBar = (M_WITH_RETURN | 38);
+
+    public static final char M_IsScrollBarEnabled = (M_WITH_RETURN | 39);
+
+    // Dieser befehl wird nur intern im Controller (sts library) verwendet. Sie
+    // tauchen nicht im Testtool auf!
+    public static final char _M_IsEnabled = (M_WITH_RETURN | 50);
+
+    public static final char M_GetFixedTextCount = (M_WITH_RETURN | 51);
+
+    public static final char M_GetFixedText = (M_WITH_RETURN | 52);
+
+    public static final char M_IsMin = (M_WITH_RETURN | 53);
+
+    public static final char M_IsRestore = (M_WITH_RETURN | 54);
+
+    public static final char M_GetItemType = (M_WITH_RETURN | 55);
+
+    // Commands for (Edit)BrowseBox
+    public static final char M_GetColumnCount = (M_WITH_RETURN | 56);
+
+    public static final char M_GetRowCount = (M_WITH_RETURN | 57);
+
+    public static final char M_IsEditing = (M_WITH_RETURN | 58);
+
+    public static final char M_IsItemEnabled = (M_WITH_RETURN | 59);
+
+    // Symphony Special
+    public static final char M_GetHelpText = (M_WITH_RETURN | 90);
+    public static final char M_GetQuickHelpText = (M_WITH_RETURN | 91);
+    public static final char M_GetScreenRectangle = (M_WITH_RETURN | 92);
+    public static final char M_HasFocus = (M_WITH_RETURN | 93);
+    public static final char M_GetItemHelpText = (M_WITH_RETURN | 94);
+    public static final char M_GetItemQuickHelpText = (M_WITH_RETURN | 95);
+    public static final char M_GetItemText2 = (M_WITH_RETURN | 96);
+    // Symphony Special End
+
+    public static final char RC_AppAbort = (M_SOFFICE | M_MOZILLA | 1);
+
+    public static final char RC_SetClipboard = (M_SOFFICE | M_MOZILLA | 2);
+
+    public static final char RC_NoDebug = (M_SOFFICE | M_MOZILLA | 3);
+
+    public static final char RC_Debug = (M_SOFFICE | M_MOZILLA | 4);
+
+    public static final char RC_GPF = (M_SOFFICE | M_MOZILLA | 5);
+
+    public static final char RC_DisplayHid = (M_SOFFICE | M_MOZILLA | 6);
+
+    public static final char RC_AppDelay = (M_SOFFICE | M_MOZILLA | 7);
+
+    public static final char RC_UseBindings = (M_SOFFICE | 8);
+
+    public static final char RC_Profile = (M_SOFFICE | M_MOZILLA | 9);
+
+    // =(Popup);Menu
+    public static final char RC_MenuSelect = (M_SOFFICE | M_MOZILLA | 10);
+
+    public static final char RC_SetControlType = (M_SOFFICE | 11);
+
+    // RemoteFileAccess
+    public static final char RC_Kill = (M_SOFFICE | 12);
+
+    public static final char RC_RmDir = (M_SOFFICE | 13);
+
+    public static final char RC_MkDir = (M_SOFFICE | 14);
+
+    public static final char RC_FileCopy = (M_SOFFICE | 15);
+
+    public static final char RC_Name = (M_SOFFICE | 16);
+
+    public static final char RC_CaptureAssertions = (M_SOFFICE | M_MOZILLA | 17);
+
+    public static final char RC_Assert = (M_SOFFICE | M_MOZILLA | 18);
+
+    public static final char RC_MenuOpen = (M_SOFFICE | M_MOZILLA | 19);
+
+    public static final char RC_TypeKeysDelay = (M_SOFFICE | M_MOZILLA | 20);
+
+    public static final char RC_ShowBar = (M_MOZILLA | 21);
+
+    public static final char RC_LoadURL = (M_MOZILLA | 22);
+
+    public static final char RC_CloseSysDialog = (M_SOFFICE | 23);
+
+    public static final char RC_SAXRelease = (M_SOFFICE | 24);
+
+    public static final char RC_RecordMacro = (M_SOFFICE | 25);
+
+    public static final char RC_ActivateDocument = (M_SOFFICE | 26);
+
+    public static final char RC_CatchGPF = (M_SOFFICE | 27);
+
+    // Befehle mit Returnwert
+    public static final char RC_GetClipboard = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 1);
+
+    public static final char RC_WinTree = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 2);
+
+    public static final char RC_ResetApplication = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 3);
+
+    public static final char RC_GetNextCloseWindow = (M_SOFFICE | M_WITH_RETURN | 4);
+
+    public static final char RC_ApplicationBusy = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 5);
+
+    // =(Popup);Menu
+    public static final char RC_MenuGetItemCount = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 6);
+
+    public static final char RC_MenuGetItemId = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 7);
+
+    public static final char RC_MenuGetItemPos = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 8);
+
+    public static final char RC_MenuIsSeperator = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 9);
+
+    public static final char RC_MenuIsItemChecked = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 10);
+
+    public static final char RC_MenuIsItemEnabled = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 11);
+
+    public static final char RC_MenuGetItemText = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 12);
+
+    // RemoteFileAccess
+    public static final char RC_Dir = (M_SOFFICE | M_WITH_RETURN | 18);
+
+    public static final char RC_FileLen = (M_SOFFICE | M_WITH_RETURN | 19);
+
+    public static final char RC_FileDateTime = (M_SOFFICE | M_WITH_RETURN | 20);
+
+    public static final char RC_Translate = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 21);
+
+    public static final char RC_GetMouseStyle = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 22);
+
+    public static final char RC_UnpackStorage = (M_SOFFICE | M_WITH_RETURN | 23);
+
+    public static final char RC_IsBarVisible = (M_MOZILLA | M_WITH_RETURN | 24);
+
+    public static final char RC_MenuGetItemCommand = (M_SOFFICE | M_MOZILLA | M_WITH_RETURN | 25);
+
+    public static final char RC_ExistsSysDialog = (M_SOFFICE | M_WITH_RETURN | 26);
+
+    public static final char RC_SAXCheckWellformed = (M_SOFFICE | M_WITH_RETURN | 27);
+
+    public static final char RC_SAXReadFile = (M_SOFFICE | M_WITH_RETURN | 28);
+
+    public static final char RC_SAXGetNodeType = (M_SOFFICE | M_WITH_RETURN | 29);
+
+    public static final char RC_SAXGetElementName = (M_SOFFICE | M_WITH_RETURN | 30);
+
+    public static final char RC_SAXGetChars = (M_SOFFICE | M_WITH_RETURN | 31);
+
+    public static final char RC_SAXGetChildCount = (M_SOFFICE | M_WITH_RETURN | 32);
+
+    public static final char RC_SAXGetAttributeCount = (M_SOFFICE | M_WITH_RETURN | 33);
+
+    public static final char RC_SAXGetAttributeName = (M_SOFFICE | M_WITH_RETURN | 34);
+
+    public static final char RC_SAXGetAttributeValue = (M_SOFFICE | M_WITH_RETURN | 35);
+
+    public static final char RC_SAXSeekElement = (M_SOFFICE | M_WITH_RETURN | 36);
+
+    public static final char RC_SAXHasElement = (M_SOFFICE | M_WITH_RETURN | 37);
+
+    public static final char RC_SAXGetElementPath = (M_SOFFICE | M_WITH_RETURN | 38);
+
+    public static final char RC_GetDocumentCount = (M_SOFFICE | M_WITH_RETURN | 39);
+
+    public static final char RC_GetSystemLanguage = (M_SOFFICE | M_WITH_RETURN | 40);
+
+    public static final char RC_IsProduct = (M_SOFFICE | M_WITH_RETURN | 41);
+
+    public static final char RC_MenuHasSubMenu = (M_SOFFICE | M_WITH_RETURN | 42);
+
+    public static final char RC_UsePostEvents = (M_SOFFICE | M_WITH_RETURN | 43);
+
+    public static final char RC_WaitSlot = (M_SOFFICE | M_WITH_RETURN | 44);
+
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/Handshaker.java b/test/testcommon/source/org/openoffice/test/vcl/client/Handshaker.java
new file mode 100644
index 000000000000..edfd5f6d4d96
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/Handshaker.java
@@ -0,0 +1,75 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+
+/**
+ *
+ * The class is used to handle handshake package
+ *
+ */
+public class Handshaker implements CommunicationListener, Constant {
+
+    private static Logger logger = Logger.getLogger("com.ibm.vclhook");
+
+    private CommunicationManager communicationManager = null;
+
+    public Handshaker(CommunicationManager communicationManager) {
+        this.communicationManager = communicationManager;
+        this.communicationManager.addListener(this);
+    }
+
+    public void received(int headerType, byte[] header, byte[] data) {
+        if (headerType == CH_Handshake) {
+            int handshakeType = data[1] + ((data[0] & 255) << 8);
+            switch (handshakeType) {
+            case CH_REQUEST_HandshakeAlive:
+                logger.log(Level.CONFIG, "Receive Handshake - CH_REQUEST_HandshakeAlive");
+                sendHandshake(CH_RESPONSE_HandshakeAlive);
+                break;
+            case CH_REQUEST_ShutdownLink:
+                logger.log(Level.CONFIG, "Receive Handshake - CH_REQUEST_ShutdownLink");
+                sendHandshake(CH_ShutdownLink);
+                break;
+            case CH_ShutdownLink:
+                logger.log(Level.CONFIG, "Receive Handshake - CH_ShutdownLink");
+                communicationManager.stop();
+                break;
+            case CH_SetApplication:
+                //String len
+//              int len = data[2] + ((data[3] & 255) << 8);
+//              String app = new String(data, 4, data.length - 4);
+                logger.log(Level.CONFIG, "Receive Handshake - CH_SetApplication - app");
+                //sendHandshake(CH_SetApplication);
+                break;
+            default:
+            }
+        }
+    }
+    public void sendHandshake(int handshakeType) {
+        sendHandshake(handshakeType, new byte[0]);
+    }
+    public void sendHandshake(int handshakeType, byte[] data) {
+        byte[] realData = new byte[data.length + 2];
+        realData[0] = (byte) ((handshakeType >>> 8) & 0xFF);
+        realData[1] = (byte) ((handshakeType >>> 0) & 0xFF);
+        System.arraycopy(data, 0, realData, 2, data.length);
+        communicationManager.sendPackage(CH_Handshake, null, realData);
+    }
+
+    public void start() {
+    }
+
+    public void stop() {
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/SmartId.java b/test/testcommon/source/org/openoffice/test/vcl/client/SmartId.java
new file mode 100644
index 000000000000..0471ad38fb9b
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/SmartId.java
@@ -0,0 +1,60 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+
+/**
+ * ID of GUI controls may have two types: number or string.
+ * From AOO3.4, all IDs should be string.
+ */
+public class SmartId {
+
+    private long id = 0;
+
+    private String sid = null;
+
+    public SmartId(long id) {
+        super();
+        this.id = id;
+    }
+
+    public SmartId(String sid) {
+        super();
+        this.sid = sid;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public String getSid() {
+        return sid;
+    }
+
+    public String toString() {
+        if (sid == null)
+            return Long.toString(id);
+        else
+            return sid;
+    }
+
+    public int hashCode() {
+        if (sid == null)
+            return new Long(id).hashCode();
+        return sid.hashCode();
+    }
+
+    public boolean equals (Object o) {
+        if (!(o instanceof SmartId))
+            return false;
+        SmartId id2 = (SmartId) o;
+        return id2.id == this.id && ((this.sid == null && id2.sid == null) || (this.sid != null && this.sid.equals(id2.sid)));
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/VclHook.java b/test/testcommon/source/org/openoffice/test/vcl/client/VclHook.java
new file mode 100644
index 000000000000..3f013049be2b
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/VclHook.java
@@ -0,0 +1,104 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+import java.io.IOException;
+
+
+
+/**
+ * The entry to remotely invoke the methods supported by the automation server
+ *
+ */
+public class VclHook {
+
+    private static final String DEFAULT_HOST = "localhost";
+
+    private static final int DEFAULT_PORT = 12479;
+
+    private static CommunicationManager communicationManager = null;
+
+    private static CommandCaller commandCaller = null;
+
+    private static Handshaker handshaker = null;
+
+    static {
+        init();
+    }
+
+    private static void init() {
+        String host = System.getProperty("AutomationServerHost", DEFAULT_HOST);
+        int port = DEFAULT_PORT;
+        try {
+            port = Integer.parseInt(System.getProperty("AutomationServerPort"));
+        } catch(NumberFormatException e) {
+
+        }
+        communicationManager = new CommunicationManager(host, port);
+        commandCaller = new CommandCaller(communicationManager);
+        communicationManager.addListener(commandCaller);
+        handshaker = new Handshaker(communicationManager);
+        communicationManager.addListener(handshaker);
+    }
+
+    public static CommandCaller getCommandCaller() {
+        return commandCaller;
+    }
+
+    public static CommunicationManager getCommunicationManager() {
+        return communicationManager;
+    }
+
+    public static boolean available() {
+        try {
+            communicationManager.connect();
+        } catch (IOException e) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static Object invokeControl(SmartId uid, int methodId, Object[] args) {
+        return commandCaller.callControl(uid, methodId, args);
+    }
+
+    public static Object invokeControl(SmartId uid, int methodId) {
+        return commandCaller.callControl(uid, methodId, null);
+    }
+
+    public static Object invokeCommand(int methodId, Object... args) {
+        return commandCaller.callCommand(methodId, args);
+    }
+
+    public static Object invokeCommand(int methodId) {
+        return commandCaller.callCommand(methodId, null);
+    }
+
+    public static void invokeUNOSlot(String url) {
+        commandCaller.callUNOSlot(url);
+    }
+
+    public static void invokeSlot(int id) {
+        commandCaller.callSlot(id, new Object[]{});
+    }
+
+    public static void invokeSlot(int id, String arg0, Object val0) {
+        commandCaller.callSlot(id, new Object[]{arg0, val0});
+    }
+
+    public static void invokeSlot(int id, String arg0, Object val0, String arg1, Object val1) {
+        commandCaller.callSlot(id, new Object[]{arg0, val0, arg1, val1});
+    }
+
+    public static void invokeSlot(int id, String arg0, Object val0, String arg1, Object val1, String arg2, Object val2) {
+        commandCaller.callSlot(id, new Object[]{arg0, val0, arg1, val1, arg2, val2});
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/client/VclHookException.java b/test/testcommon/source/org/openoffice/test/vcl/client/VclHookException.java
new file mode 100644
index 000000000000..99b38caebfd7
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/client/VclHookException.java
@@ -0,0 +1,355 @@
+/************************************************************************
+ *
+ * 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.vcl.client;
+
+import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * The exception during executing the remote method.
+ *
+ */
+public class VclHookException extends RuntimeException {
+    /**
+     *
+     */
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * The messages are from basic\source\app\svtmsg.src
+     */
+    /***ERROR****/
+    public static final int SVT_START = 22000;
+
+    public static final int S_GPF_ABORT                                 =( SVT_START +   0 );
+    public static final int S_APP_SHUTDOWN                              =( SVT_START +   1 );
+    public static final int S_SID_EXECUTE_FAILED_NO_DISPATCHER          =( SVT_START +   2 );
+    public static final int S_SID_EXECUTE_FAILED                        =( SVT_START +   3 );
+    public static final int S_UNO_PROPERTY_NITIALIZE_FAILED             =( SVT_START +   4 );
+    public static final int S_RESETAPPLICATION_FAILED_COMPLEX           =( SVT_START +   5 );
+    public static final int S_RESETAPPLICATION_FAILED_UNKNOWN           =( SVT_START +   6 );
+    public static final int S_NO_ACTIVE_WINDOW                          =( SVT_START +   7 );
+    public static final int S_NO_DIALOG_IN_GETACTIVE                    =( SVT_START +   8 );
+    public static final int S_NO_POPUP                                  =( SVT_START +   9 );
+    public static final int S_NO_SUBMENU                                =( SVT_START +  10 );
+    public static final int S_CONTROLTYPE_NOT_SUPPORTED                 =( SVT_START +  11 );
+    public static final int S_SELECTION_BY_ATTRIBUTE_ONLY_DIRECTORIES   =( SVT_START +  12 );
+    public static final int S_NO_MORE_FILES                             =( SVT_START +  13 );
+    public static final int S_UNKNOWN_METHOD                            =( SVT_START +  14 );
+    public static final int S_INVALID_PARAMETERS                        =( SVT_START +  15 );
+    public static final int S_POINTER_OUTSIDE_APPWIN                    =( SVT_START +  16 );
+    public static final int S_UNKNOWN_COMMAND                           =( SVT_START +  17 );
+    public static final int S_WIN_NOT_FOUND                             =( SVT_START +  18 );
+    public static final int S_WIN_INVISIBLE                             =( SVT_START +  19 );
+    public static final int S_WIN_DISABLED                              =( SVT_START +  20 );
+    public static final int S_NUMBER_TOO_BIG                            =( SVT_START +  21 );
+    public static final int S_NUMBER_TOO_SMALL                          =( SVT_START +  22 );
+    public static final int S_WINDOW_DISAPPEARED                        =( SVT_START +  23 );
+    public static final int S_ERROR_SAVING_IMAGE                        =( SVT_START +  24 );
+    public static final int S_INVALID_POSITION                          =( SVT_START +  25 );
+    public static final int S_SPLITWIN_NOT_FOUND                        =( SVT_START +  26 );
+    public static final int S_INTERNAL_ERROR                            =( SVT_START +  27 );
+    public static final int S_NO_STATUSBAR                              =( SVT_START +  28 );
+    public static final int S_ITEMS_INVISIBLE                           =( SVT_START +  29 );
+    public static final int S_TABPAGE_NOT_FOUND                         =( SVT_START +  30 );
+    public static final int S_TRISTATE_NOT_ALLOWED                      =( SVT_START +  31 );
+    public static final int S_ERROR_IN_SET_TEXT                         =( SVT_START +  32 );
+    public static final int S_ATTEMPT_TO_WRITE_READONLY                 =( SVT_START +  33 );
+    public static final int S_NO_SELECT_FALSE                           =( SVT_START +  34 );
+    public static final int S_ENTRY_NOT_FOUND                           =( SVT_START +  35 );
+    public static final int S_METHOD_FAILED                             =( SVT_START +  36 );
+    public static final int S_HELPID_ON_TOOLBOX_NOT_FOUND               =( SVT_START +  37 );
+    public static final int S_BUTTON_DISABLED_ON_TOOLBOX                =( SVT_START +  38 );
+    public static final int S_BUTTON_HIDDEN_ON_TOOLBOX                  =( SVT_START +  39 );
+    public static final int S_CANNOT_MAKE_BUTTON_VISIBLE_IN_TOOLBOX     =( SVT_START +  40 );
+    public static final int S_TEAROFF_FAILED                            =( SVT_START +  41 );
+    public static final int S_NO_SELECTED_ENTRY_DEPRECATED              =( SVT_START +  42 ); // Has to stay in for old res files
+    public static final int S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED =( SVT_START +  43 );
+    public static final int S_ALLOWED_ONLY_IN_FLOATING_MODE             =( SVT_START +  44 );
+    public static final int S_ALLOWED_ONLY_IN_DOCKING_MODE              =( SVT_START +  45 );
+    public static final int S_SIZE_NOT_CHANGEABLE                       =( SVT_START +  46 );
+    public static final int S_NO_OK_BUTTON                              =( SVT_START +  47 );
+    public static final int S_NO_CANCEL_BUTTON                          =( SVT_START +  48 );
+    public static final int S_NO_YES_BUTTON                             =( SVT_START +  49 );
+    public static final int S_NO_NO_BUTTON                              =( SVT_START +  50 );
+    public static final int S_NO_RETRY_BUTTON                           =( SVT_START +  51 );
+    public static final int S_NO_HELP_BUTTON                            =( SVT_START +  52 );
+    public static final int S_NO_DEFAULT_BUTTON                         =( SVT_START +  53 );
+    public static final int S_BUTTON_ID_NOT_THERE                       =( SVT_START +  54 );
+    public static final int S_BUTTONID_REQUIRED                         =( SVT_START +  55 );
+    public static final int S_UNKNOWN_TYPE                              =( SVT_START +  56 );
+    public static final int S_UNPACKING_STORAGE_FAILED                  =( SVT_START +  57 );
+    public static final int S_NO_LIST_BOX_BUTTON                        =( SVT_START +  58 );
+    public static final int S_UNO_URL_EXECUTE_FAILED_NO_DISPATCHER      =( SVT_START +  59 );
+    public static final int S_UNO_URL_EXECUTE_FAILED_NO_FRAME           =( SVT_START +  60 );
+    public static final int S_NO_MENU                                   =( SVT_START +  61 );
+    public static final int S_NO_SELECTED_ENTRY                         =( SVT_START +  62 );
+    public static final int S_UNO_URL_EXECUTE_FAILED_DISABLED           =( SVT_START +  63 );
+    public static final int S_NO_SCROLLBAR                              =( SVT_START +  64 );
+    public static final int S_NO_SAX_PARSER                             =( SVT_START +  65 );
+    public static final int S_CANNOT_CREATE_DIRECTORY                   =( SVT_START +  66 );
+    public static final int S_DIRECTORY_NOT_EMPTY                       =( SVT_START +  67 );
+    public static final int S_DEPRECATED                                =( SVT_START +  68 );
+    public static final int S_SIZE_BELOW_MINIMUM                        =( SVT_START +  69 );
+    public static final int S_CANNOT_FIND_FLOATING_WIN                  =( SVT_START +  70 );
+    public static final int S_NO_LIST_BOX_STRING                        =( SVT_START +  71 );
+    public static final int S_SLOT_IN_EXECUTE                           =( SVT_START +  72 );
+
+    public static Properties MESSAGES = new Properties();
+
+    static {
+        MESSAGES.put(new Integer(S_GPF_ABORT), "Program aborted with GPF");
+        MESSAGES.put(new Integer(S_APP_SHUTDOWN), "Application has been shut down");
+        MESSAGES.put(new Integer(S_SID_EXECUTE_FAILED_NO_DISPATCHER), "Slot ID cannot be executed. No ActiveDispatcher");
+        MESSAGES.put(new Integer(S_SID_EXECUTE_FAILED), "Slot ID could not be executed");
+        MESSAGES.put(new Integer(S_UNO_PROPERTY_NITIALIZE_FAILED), "UnoSlot: Properties could not be initialized");
+        MESSAGES.put(new Integer(S_RESETAPPLICATION_FAILED_COMPLEX),
+                "ResetApplication failed: too complex");
+        MESSAGES.put(new Integer(S_RESETAPPLICATION_FAILED_UNKNOWN),
+                "ResetApplication failed: unknown window type");
+        MESSAGES.put(new Integer(S_NO_ACTIVE_WINDOW),
+                "No active window found (GetNextCloseWindow)");
+        MESSAGES.put(new Integer(S_NO_DIALOG_IN_GETACTIVE),
+                "GetActive does not return a dialog! Inform development");
+        MESSAGES.put(new Integer(S_NO_POPUP), "Pop-up menu not open");
+        MESSAGES.put(new Integer(S_NO_SUBMENU), "Submenu does not exist");
+        MESSAGES.put(new Integer(S_CONTROLTYPE_NOT_SUPPORTED),
+                "ControlType ($Arg1) is not supported");
+        MESSAGES.put(new Integer(S_SELECTION_BY_ATTRIBUTE_ONLY_DIRECTORIES),
+                "Selection by attributes only possible for directories");
+        MESSAGES.put(new Integer(S_NO_MORE_FILES), "No more files");
+        MESSAGES.put(new Integer(S_UNKNOWN_METHOD),
+                "Unknown method '($Arg1)' on ($Arg2)");
+        MESSAGES.put(new Integer(S_INVALID_PARAMETERS), "Invalid Parameters");
+        MESSAGES.put(new Integer(S_POINTER_OUTSIDE_APPWIN),
+                "Pointer not inside application window at '($Arg1)'");
+        MESSAGES.put(new Integer(S_UNKNOWN_COMMAND),
+                "Unknown command '($Arg1)'");
+        MESSAGES.put(new Integer(S_WIN_NOT_FOUND), "($Arg1) could not be found");
+        MESSAGES.put(new Integer(S_WIN_INVISIBLE), "($Arg1) is not visible");
+        MESSAGES.put(new Integer(S_WIN_DISABLED), "($Arg1) could not be accessed. Disabled");
+        MESSAGES.put(new Integer(S_NUMBER_TOO_BIG),
+                        "Entry number ($Arg2) is too large in ($Arg1). Max. allowed is ($Arg3)");
+        MESSAGES.put(new Integer(S_NUMBER_TOO_SMALL),
+                        "The entry number ($Arg2) is too small in ($Arg1). Min allowed is ($Arg3)");
+        MESSAGES.put(new Integer(S_WINDOW_DISAPPEARED), "Window disappeared in the meantime at ($Arg1)");
+        MESSAGES.put(new Integer(S_ERROR_SAVING_IMAGE), "Error #($Arg1) when saving the image");
+        MESSAGES.put(new Integer(S_INVALID_POSITION),
+                "Invalid position at ($Arg1)");
+        MESSAGES.put(new Integer(S_SPLITWIN_NOT_FOUND),
+                "SplitWindow not found at ($Arg1)");
+        MESSAGES
+                .put(new Integer(S_INTERNAL_ERROR), "Internal error at ($Arg1)");
+        MESSAGES.put(new Integer(S_NO_STATUSBAR), "No status bar at ($Arg1)");
+        MESSAGES.put(new Integer(S_ITEMS_INVISIBLE),
+                "The items are hidden at ($Arg1)");
+        MESSAGES.put(new Integer(S_TABPAGE_NOT_FOUND),
+                "Tab page not found at ($Arg1)");
+        MESSAGES.put(new Integer(S_TRISTATE_NOT_ALLOWED),
+                "Tristate cannot be set at ($Arg1)");
+        MESSAGES.put(new Integer(S_ERROR_IN_SET_TEXT),
+                "Set text did not function");
+        MESSAGES.put(new Integer(S_ATTEMPT_TO_WRITE_READONLY),
+                "Attempt to write on read-only ($Arg1)");
+        MESSAGES.put(new Integer(S_NO_SELECT_FALSE),
+                "Select FALSE not allowed. Use MultiSelect at ($Arg1)");
+        MESSAGES.put(new Integer(S_ENTRY_NOT_FOUND),
+                "\"($Arg2)\" entry at ($Arg1) not found");
+        MESSAGES.put(new Integer(S_METHOD_FAILED),
+                "($Arg1) of entry \"($Arg2)\" failed");
+        MESSAGES.put(new Integer(S_HELPID_ON_TOOLBOX_NOT_FOUND),
+                "HelpID in ToolBox not found at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_BUTTON_DISABLED_ON_TOOLBOX),
+                "The button is disabled in ToolBox at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_BUTTON_HIDDEN_ON_TOOLBOX),
+                "The button is hidden in ToolBox at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_CANNOT_MAKE_BUTTON_VISIBLE_IN_TOOLBOX),
+                "Button cannot be made visible in ToolBox at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_TEAROFF_FAILED),
+                "TearOff failed in ToolBox at ($Arg1)");
+
+        // Has to stay in for old res files
+        MESSAGES.put(new Integer(S_NO_SELECTED_ENTRY_DEPRECATED),
+                "No entry is selected in TreeListBox at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_SELECTED_ENTRY),
+                "No entry is selected in ($Arg2) at ($Arg1)");
+
+        MESSAGES
+                .put(new Integer(S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED),
+                        "Select/Deselect with MESSAGES.put(new Integer(not implemented at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_ALLOWED_ONLY_IN_FLOATING_MODE),
+                "Method only allowed in floating mode at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_ALLOWED_ONLY_IN_DOCKING_MODE),
+                "Method only allowed in docking mode at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_SIZE_NOT_CHANGEABLE),
+                "Size cannot be altered at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_OK_BUTTON),
+                "There is no OK button at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_CANCEL_BUTTON),
+                "There is no Cancel button at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_YES_BUTTON),
+                "There is no Yes button at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_NO_BUTTON),
+                "There is no No button at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_RETRY_BUTTON),
+                "There is no Repeat button at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_HELP_BUTTON),
+                "There is no Help button at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_NO_DEFAULT_BUTTON),
+                "There is no Default button defined at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_BUTTON_ID_NOT_THERE),
+                "There is no button with ID ($Arg1) at ($Arg2)");
+
+        MESSAGES.put(new Integer(S_BUTTONID_REQUIRED),
+                "A button ID needs to be given at ($Arg1)");
+
+        MESSAGES
+                .put(new Integer(S_UNKNOWN_TYPE),
+                        "Unknown object type ($Arg1) from UId or method '($Arg2)' not supported");
+
+        MESSAGES.put(new Integer(S_UNPACKING_STORAGE_FAILED),
+                "Unpacking storage \"($Arg1)\" to \"($Arg2)\" failed");
+
+        MESSAGES.put(new Integer(S_NO_LIST_BOX_BUTTON),
+                "ListBoxButton does not exist in ($Arg1)");
+
+        MESSAGES
+                .put(new Integer(S_UNO_URL_EXECUTE_FAILED_NO_DISPATCHER),
+                        "UNO URL \"($Arg1)\" could not be executed: No dispatcher was found.");
+
+        MESSAGES
+                .put(new Integer(S_UNO_URL_EXECUTE_FAILED_NO_FRAME),
+                        "UNO URL \"($Arg1)\" could not be executed: No ActiveFrame on desktop.");
+
+        MESSAGES.put(new Integer(S_NO_MENU), "There is no menu at ($Arg1)");
+
+        MESSAGES.put(new Integer(S_UNO_URL_EXECUTE_FAILED_DISABLED),
+                "UNO URL \"($Arg1)\" could not be run: Disabled");
+
+        MESSAGES.put(new Integer(S_NO_SCROLLBAR), "No scroll bar at ($Arg1)");
+
+        MESSAGES
+                .put(new Integer(S_NO_SAX_PARSER),
+                        "No SAX Parser when using ($Arg1). Initialize with 'SAXReadFile' first.");
+
+        MESSAGES.put(new Integer(S_CANNOT_CREATE_DIRECTORY),
+                "Cannot create Directory: \"($Arg1)\"");
+
+        MESSAGES
+                .put(new Integer(S_DIRECTORY_NOT_EMPTY),
+                        "Directory has to be Empty to unpack to. Directory: \"($Arg1)\"");
+
+        MESSAGES.put(new Integer(S_DEPRECATED),
+                "Deprecated! Please change the script.");
+
+        MESSAGES.put(new Integer(S_SIZE_BELOW_MINIMUM),
+                "The Size is below the minimum. x=($Arg1) ,y=($Arg2)");
+
+        MESSAGES
+                .put(new Integer(S_CANNOT_FIND_FLOATING_WIN),
+                        "Cannot find FloatingWindow for floating DockingWindow at ($Arg1).");
+
+        MESSAGES.put(new Integer(S_NO_LIST_BOX_STRING),
+                "String does not exist in ($Arg1)");
+
+        MESSAGES.put(new Integer(S_SLOT_IN_EXECUTE),
+                "Another Slot is being executed already.");
+
+    }
+
+    private SmartId id = null;
+
+    private String message = null;
+
+    private int code = -1;
+
+    private Properties properties = new Properties();
+
+    public VclHookException(String message) {
+        this(null, message);
+    }
+
+    public VclHookException(SmartId id, String message) {
+        this.id = id;
+        this.message = message;
+        if (id != null)
+            parse();
+    }
+
+
+    public String getMessage() {
+        return this.message;
+    }
+
+
+    private void parse() {
+        if (message == null)
+            return;
+
+        //Replace some key
+        message = message.replaceAll("%Method=([^%]*)%", "$1");
+        message = message.replaceAll("%RType=([^%]*)%", "$1");
+        message = message.replaceAll("%RCommand=([^%]*)%", "$1");
+        message = message.replaceAll("%UId=([^%]*)%", "$1");
+
+        // Parse String into Properties
+        int start = -1, sep = -1, end =-1, pos = 0;
+        String key = null;
+        String value= null;
+        while( (start = message.indexOf('%', pos)) != -1
+                && (sep = message.indexOf('=', start + 1)) != -1
+                && (end = message.indexOf('%', sep + 1)) != -1) {
+            key = message.substring(start + 1, sep);
+            value = message.substring(sep + 1, end);
+            pos = end + 1;
+            properties.put(key, value);
+        }
+
+        String resId = properties.getProperty("ResId");
+        if (resId == null)
+            return;
+        this.code = Integer.parseInt(resId);
+        String originalMsg = (String) MESSAGES.get(this.code);
+        if (originalMsg == null)
+            return;
+
+        Pattern pattern = Pattern.compile("\\(\\$([^\\)]*)\\)");
+        Matcher matcher = pattern.matcher(originalMsg);
+        StringBuffer result = new StringBuffer();
+        while (matcher.find()) {
+            String rep = properties.getProperty(matcher.group(1), matcher.group()).replace("$", "\\$");
+            matcher.appendReplacement(result, rep);
+        }
+        matcher.appendTail(result);
+        message =  "ID:" + id + " - " + result.toString();
+    }
+
+
+    public int getCode() {
+        return this.code;
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclApp.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclApp.java
new file mode 100644
index 000000000000..4aee02e5a5b7
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclApp.java
@@ -0,0 +1,181 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+
+import java.util.Properties;
+
+import org.openoffice.test.common.FileUtil;
+import org.openoffice.test.common.SystemUtil;
+import org.openoffice.test.vcl.Tester;
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.VclHook;
+
+public class VclApp {
+    String home = null;
+
+    public static final String CMD_KILL_WINDOWS = "taskkill /F /IM soffice.bin /IM soffice.exe";
+
+    public static final String CMD_KILL_LINUX = "killall -9 soffice soffice.bin";
+
+    String cmdKill = null;
+
+    String cmdStart = null;
+
+    String versionFile = null;
+
+    Properties version = null;
+
+    String port = System.getProperty("openoffice.automation.port", "12479");
+
+    public VclApp(String appHome) {
+        setHome(appHome);
+    }
+
+    public VclApp() {
+        this(null);
+    }
+
+    public void setHome(String home) {
+        this.home = home;
+        if (home == null)
+            home = System.getProperty("openoffice.home");
+        if (home == null)
+            home = System.getenv("OPENOFFICE_HOME");
+        if (home == null)
+            home = "unkown";
+
+        versionFile = "versionrc";
+
+        cmdKill = CMD_KILL_LINUX;
+        cmdStart = "cd \"" + home + "\" ; ./soffice";
+        if (SystemUtil.isWindows()) {
+            cmdKill = CMD_KILL_WINDOWS;
+            cmdStart = "\"" + home + "\\soffice.exe\"";
+            versionFile = "version.ini";
+
+        } else if (SystemUtil.isMac()) {
+
+        } else {
+
+        }
+
+    }
+    public String getHome() {
+        return home;
+    }
+
+    public void kill() {
+        SystemUtil.execScript(cmdKill, false);
+    }
+
+    public int start(String args) {
+        if (args == null)
+            args = "";
+
+        return SystemUtil.execScript(cmdStart + " -norestore -quickstart=no -nofirststartwizard -enableautomation -automationport=" + port + " " + args, true);
+    }
+
+    public void start() {
+        start(null);
+    }
+
+    /**
+     * Activate the document window at the given index
+     *
+     * @param i
+     * @return
+     */
+    public void activateDoc(int i) {
+        VclHook.invokeCommand(Constant.RC_ActivateDocument,
+                new Object[] { i + 1 });
+    }
+
+    public void reset() {
+        VclHook.invokeCommand(Constant.RC_ResetApplication);
+    }
+
+    public boolean existsSysDialog() {
+        return (Boolean) VclHook.invokeCommand(Constant.RC_ExistsSysDialog);
+    }
+
+    public void closeSysDialog() {
+        VclHook.invokeCommand(Constant.RC_CloseSysDialog);
+    }
+
+    public String getClipboard() {
+        return (String) VclHook.invokeCommand(Constant.RC_GetClipboard);
+    }
+
+    public void setClipboard(String content) {
+        VclHook.invokeCommand(Constant.RC_SetClipboard, content);
+    }
+
+    public boolean exists() {
+        return VclHook.available();
+    }
+
+    /**
+     * Check if the control exists in a period of time
+     */
+    public boolean exists(double iTimeout) {
+        return exists(iTimeout, 1);
+    }
+
+    /**
+     * Check if the control exists in a period of time
+     */
+    public boolean exists(double iTimeout, double interval) {
+        long startTime = System.currentTimeMillis();
+        while (System.currentTimeMillis() - startTime < iTimeout * 1000) {
+            if (exists())
+                return true;
+            Tester.sleep(interval);
+        }
+
+        return exists();
+    }
+
+    public void waitForExistence(double iTimeout, double interval) {
+        if (!exists(iTimeout, interval))
+            throw new RuntimeException("OpenOffice is not found!");
+    }
+
+    /**
+     * Get document window count
+     *
+     * @return
+     */
+    public int getDocCount() {
+        return (Integer) VclHook.invokeCommand(Constant.RC_GetDocumentCount);
+    }
+
+    public Properties getVersion() {
+        if (version == null)
+            version = FileUtil.loadProperties(home + "/" + versionFile);
+        return version;
+    }
+
+
+    public void dispatch(String url) {
+        VclHook.invokeUNOSlot(url);
+    }
+
+    private static final int CONST_WSTimeout = 701;
+//  private static final int CONST_WSAborted = 702; // Not used now!
+//  private static final int CONST_WSFinished = 703; //
+
+    public void dispatch(String url, double time) {
+        VclHook.invokeUNOSlot(url);
+        int result = (Integer) VclHook.invokeCommand(Constant.RC_WaitSlot, (int) time * 1000);
+        if (result == CONST_WSTimeout)
+            throw new RuntimeException("Timeout to execute the dispatch!");
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclButton.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclButton.java
new file mode 100644
index 000000000000..c6b71fa85855
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclButton.java
@@ -0,0 +1,90 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+
+/**
+ *
+ * Button/CheckBox/RadioBox/TriStateBox
+ *
+ */
+public class VclButton extends VclControl {
+
+    /**
+     * Construct the control with its String id
+     * @param uid
+     */
+    public VclButton(String uid) {
+        super(uid);
+    }
+
+
+    public VclButton(SmartId id) {
+        super(id);
+    }
+
+    /**
+     *
+     * Click the check box
+     */
+    public void click() {
+        invoke(Constant.M_Click);
+    }
+
+    /**
+     * Check if the check box is tristate
+     */
+    public boolean isTristate() {
+        return (Boolean)invoke(Constant.M_IsTristate);
+    }
+
+    /**
+     * Set the check box to triState status
+     */
+    public void triState() {
+        invoke(Constant.M_TriState);
+    }
+
+    /**
+     * Check if the check box is checked
+     */
+    public boolean isChecked() {
+        return (Boolean) invoke(Constant.M_IsChecked);
+    }
+
+    /**
+     * Set the check box to checked status
+     *
+     */
+    public void check() {
+        invoke(Constant.M_Check);
+    }
+
+    /**
+     * Set the check box to unchecked status
+     */
+    public void uncheck() {
+        invoke(Constant.M_UnCheck);
+    }
+
+    /**
+     * Set the status to checked or unchecked
+     * @param checked
+     */
+    public void setChecked(boolean checked) {
+        if (checked)
+            this.check();
+        else
+            this.uncheck();
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclComboBox.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclComboBox.java
new file mode 100644
index 000000000000..61d8ed3542cc
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclComboBox.java
@@ -0,0 +1,130 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ * Proxy used to access Vcl Combo Box
+ *
+ */
+public class VclComboBox extends VclControl {
+
+    public VclComboBox(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Define VclComboBox with String id
+     *
+     * @param uid
+     */
+    public VclComboBox(String uid) {
+        super(uid);
+    }
+
+    /**
+     * Get the item count
+     */
+    public int getItemCount() {
+        return ((Long) invoke(Constant.M_GetItemCount)).intValue();
+    }
+
+    /**
+     * Get the text of the index-th item.
+     * @index The index starts from 0.
+     */
+    public String getItemText(int index) {
+        return (String) invoke(Constant.M_GetItemText, new Object[] {index + 1});
+    }
+
+    /**
+     * Get the index of the selected item.
+     * @index The index starts from 0.
+     */
+    public int getSelIndex() {
+        int index = ((Long) invoke(Constant.M_GetSelIndex)).intValue();
+        return index - 1;
+    }
+
+    /**
+     * Get the text of the selected item.
+     */
+    public String getSelText() {
+        return (String) invoke(Constant.M_GetSelText);
+    }
+
+    /**
+     * Get the text in the combo box
+     */
+    public String getText() {
+        // Fix: Use M_Caption to get the text. M_GetText does not work
+        return (invoke(Constant.M_Caption)).toString();
+    }
+
+    /**
+     * Get the text of all items
+     */
+    public String[] getItemsText() {
+        int count = getItemCount();
+        String[] res = new String[count];
+        for (int i = 0; i < count; i++) {
+            res[i] = getItemText(i);
+        }
+        return res;
+    }
+
+    /**
+     * Select the index-th item.
+     * @index The index starts from 0.
+     */
+    public void select(int index) {
+        invoke(Constant.M_Select, new Object[] {index + 1});
+    }
+
+    /**
+     * Select the item with the given text
+     */
+    public void select(String text) {
+        invoke(Constant.M_Select, new Object[] {text});
+    }
+
+    /**
+     * Sets no selection in a list (Sometimes this corresponds to the first
+     * entry in the list)
+     *
+     */
+    public void setNoSelection() {
+        invoke(Constant.M_SetNoSelection);
+    }
+
+    /**
+     * Set the text of the combo box
+     */
+    public void setText(String text) {
+        invoke(Constant.M_SetText, new Object[] {text});
+    }
+
+    /**
+     * Check if the list box has the specified item
+     * @param str
+     * @return
+     */
+    public boolean hasItem(String str) {
+        int len = getItemCount();
+        for (int i = 0; i < len; i++) {
+            String text = getItemText(i);
+            if (str.equals(text))
+                return true;
+        }
+        return false;
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclControl.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclControl.java
new file mode 100644
index 000000000000..50f5288c76f2
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclControl.java
@@ -0,0 +1,506 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import java.awt.Rectangle;
+import java.io.IOException;
+
+import org.openoffice.test.common.Condition;
+import org.openoffice.test.vcl.Tester;
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+import org.openoffice.test.vcl.client.VclHook;
+
+/**
+ * VCL control proxy
+ */
+public class VclControl {
+
+    public final static long ACTIVE = 0;
+
+    public final static int WINDOW_BASE = 0x0100;
+
+    public final static int WINDOW_FIRST = (WINDOW_BASE + 0x30);
+
+    public final static int WINDOW_MESSBOX = (WINDOW_FIRST);
+
+    public final static int WINDOW_INFOBOX = (WINDOW_FIRST + 0x01);
+
+    public final static int WINDOW_WARNINGBOX = (WINDOW_FIRST + 0x02);
+
+    public final static int WINDOW_ERRORBOX = (WINDOW_FIRST + 0x03);
+
+    public final static int WINDOW_QUERYBOX = (WINDOW_FIRST + 0x04);
+
+    public final static int WINDOW_WINDOW = (WINDOW_FIRST + 0x05);
+
+    public final static int WINDOW_SYSWINDOW = (WINDOW_FIRST + 0x06);
+
+    public final static int WINDOW_WORKWINDOW = (WINDOW_FIRST + 0x07);
+
+    // public final static int WINDOW_MDIWINDOW = (WINDOW_FIRST + 0x08);
+    public final static int WINDOW_FLOATINGWINDOW = (WINDOW_FIRST + 0x09);
+
+    public final static int WINDOW_DIALOG = (WINDOW_FIRST + 0x0a);
+
+    public final static int WINDOW_MODELESSDIALOG = (WINDOW_FIRST + 0x0b);
+
+    public final static int WINDOW_MODALDIALOG = (WINDOW_FIRST + 0x0c);
+
+    public final static int WINDOW_SYSTEMDIALOG = (WINDOW_FIRST + 0x0d);
+
+    public final static int WINDOW_PATHDIALOG = (WINDOW_FIRST + 0x0e);
+
+    public final static int WINDOW_FILEDIALOG = (WINDOW_FIRST + 0x0f);
+
+    public final static int WINDOW_PRINTERSETUPDIALOG = (WINDOW_FIRST + 0x10);
+
+    public final static int WINDOW_PRINTDIALOG = (WINDOW_FIRST + 0x11);
+
+    public final static int WINDOW_COLORDIALOG = (WINDOW_FIRST + 0x12);
+
+    public final static int WINDOW_FONTDIALOG = (WINDOW_FIRST + 0x13);
+
+    public final static int WINDOW_CONTROL = (WINDOW_FIRST + 0x14);
+
+    public final static int WINDOW_BUTTON = (WINDOW_FIRST + 0x15);
+
+    public final static int WINDOW_PUSHBUTTON = (WINDOW_FIRST + 0x16);
+
+    public final static int WINDOW_OKBUTTON = (WINDOW_FIRST + 0x17);
+
+    public final static int WINDOW_CANCELBUTTON = (WINDOW_FIRST + 0x18);
+
+    public final static int WINDOW_HELPBUTTON = (WINDOW_FIRST + 0x19);
+
+    public final static int WINDOW_IMAGEBUTTON = (WINDOW_FIRST + 0x1a);
+
+    public final static int WINDOW_MENUBUTTON = (WINDOW_FIRST + 0x1b);
+
+    public final static int WINDOW_MOREBUTTON = (WINDOW_FIRST + 0x1c);
+
+    public final static int WINDOW_SPINBUTTON = (WINDOW_FIRST + 0x1d);
+
+    public final static int WINDOW_RADIOBUTTON = (WINDOW_FIRST + 0x1e);
+
+    public final static int WINDOW_IMAGERADIOBUTTON = (WINDOW_FIRST + 0x1f);
+
+    public final static int WINDOW_CHECKBOX = (WINDOW_FIRST + 0x20);
+
+    public final static int WINDOW_TRISTATEBOX = (WINDOW_FIRST + 0x21);
+
+    public final static int WINDOW_EDIT = (WINDOW_FIRST + 0x22);
+
+    public final static int WINDOW_MULTILINEEDIT = (WINDOW_FIRST + 0x23);
+
+    public final static int WINDOW_COMBOBOX = (WINDOW_FIRST + 0x24);
+
+    public final static int WINDOW_LISTBOX = (WINDOW_FIRST + 0x25);
+
+    public final static int WINDOW_MULTILISTBOX = (WINDOW_FIRST + 0x26);
+
+    public final static int WINDOW_FIXEDTEXT = (WINDOW_FIRST + 0x27);
+
+    public final static int WINDOW_FIXEDLINE = (WINDOW_FIRST + 0x28);
+
+    public final static int WINDOW_FIXEDBITMAP = (WINDOW_FIRST + 0x29);
+
+    public final static int WINDOW_FIXEDIMAGE = (WINDOW_FIRST + 0x2a);
+
+    public final static int WINDOW_GROUPBOX = (WINDOW_FIRST + 0x2c);
+
+    public final static int WINDOW_SCROLLBAR = (WINDOW_FIRST + 0x2d);
+
+    public final static int WINDOW_SCROLLBARBOX = (WINDOW_FIRST + 0x2e);
+
+    public final static int WINDOW_SPLITTER = (WINDOW_FIRST + 0x2f);
+
+    public final static int WINDOW_SPLITWINDOW = (WINDOW_FIRST + 0x30);
+
+    public final static int WINDOW_SPINFIELD = (WINDOW_FIRST + 0x31);
+
+    public final static int WINDOW_PATTERNFIELD = (WINDOW_FIRST + 0x32);
+
+    public final static int WINDOW_NUMERICFIELD = (WINDOW_FIRST + 0x33);
+
+    public final static int WINDOW_METRICFIELD = (WINDOW_FIRST + 0x34);
+
+    public final static int WINDOW_CURRENCYFIELD = (WINDOW_FIRST + 0x35);
+
+    public final static int WINDOW_DATEFIELD = (WINDOW_FIRST + 0x36);
+
+    public final static int WINDOW_TIMEFIELD = (WINDOW_FIRST + 0x37);
+
+    public final static int WINDOW_PATTERNBOX = (WINDOW_FIRST + 0x38);
+
+    public final static int WINDOW_NUMERICBOX = (WINDOW_FIRST + 0x39);
+
+    public final static int WINDOW_METRICBOX = (WINDOW_FIRST + 0x3a);
+
+    public final static int WINDOW_CURRENCYBOX = (WINDOW_FIRST + 0x3b);
+
+    public final static int WINDOW_DATEBOX = (WINDOW_FIRST + 0x3c);
+
+    public final static int WINDOW_TIMEBOX = (WINDOW_FIRST + 0x3d);
+
+    public final static int WINDOW_LONGCURRENCYFIELD = (WINDOW_FIRST + 0x3e);
+
+    public final static int WINDOW_LONGCURRENCYBOX = (WINDOW_FIRST + 0x3f);
+
+    public final static int WINDOW_TOOLBOX = (WINDOW_FIRST + 0x41);
+
+    public final static int WINDOW_DOCKINGWINDOW = (WINDOW_FIRST + 0x42);
+
+    public final static int WINDOW_STATUSBAR = (WINDOW_FIRST + 0x43);
+
+    public final static int WINDOW_TABPAGE = (WINDOW_FIRST + 0x44);
+
+    public final static int WINDOW_TABCONTROL = (WINDOW_FIRST + 0x45);
+
+    public final static int WINDOW_TABDIALOG = (WINDOW_FIRST + 0x46);
+
+    public final static int WINDOW_BORDERWINDOW = (WINDOW_FIRST + 0x47);
+
+    public final static int WINDOW_BUTTONDIALOG = (WINDOW_FIRST + 0x48);
+
+    public final static int WINDOW_SYSTEMCHILDWINDOW = (WINDOW_FIRST + 0x49);
+
+    public final static int WINDOW_FIXEDBORDER = (WINDOW_FIRST + 0x4a);
+
+    public final static int WINDOW_SLIDER = (WINDOW_FIRST + 0x4b);
+
+    public final static int WINDOW_MENUBARWINDOW = (WINDOW_FIRST + 0x4c);
+
+    public final static int WINDOW_TREELISTBOX = (WINDOW_FIRST + 0x4d);
+
+    public final static int WINDOW_HELPTEXTWINDOW = (WINDOW_FIRST + 0x4e);
+
+    public final static int WINDOW_INTROWINDOW = (WINDOW_FIRST + 0x4f);
+
+    public final static int WINDOW_LISTBOXWINDOW = (WINDOW_FIRST + 0x50);
+
+    public final static int WINDOW_DOCKINGAREA = (WINDOW_FIRST + 0x51);
+
+    public final static int WINDOW_VALUESETLISTBOX = (WINDOW_FIRST + 0x55);
+
+    public final static int WINDOW_LAST = (WINDOW_DOCKINGAREA);
+
+    protected SmartId uid = null;
+
+    protected int type = -1;
+
+    /**
+     * Construct using smart ID
+     * @param id
+     */
+    public VclControl(SmartId id) {
+        this.uid = id;
+    }
+
+    /**
+     * Construct using string ID or a
+     * string indicating to dynamically find a control with the following
+     * pattern: <br>
+     * .find:ContainerControlID ControlType ControlIndex<br>
+     * A space is needed to separate ContainerControlID ControlType and
+     * ControlIndex.<br>
+     * ".find:" is fixed prefix to tell automation server to dynamically find a
+     * control.<br>
+     * ContainerControlID is container control ID which is searched in<br>
+     * ControlType gives the target control type <br>
+     * ControlIndex is the index of target control<br>
+     * e.g.<br>
+     * new VclControl(".find:52821 326 2")
+     *
+     * @param uid
+     */
+    public VclControl(String uid) {
+        this.uid = new SmartId(uid);
+    }
+
+    /**
+     * Get the ID of the control
+     *
+     * @return
+     */
+    public SmartId getUID() {
+        return this.uid;
+    }
+
+    public void click() {
+        invoke(Constant.M_Click);
+    }
+
+    /**
+     * Click
+     *
+     * @param locator
+     * @param x
+     * @param y
+     */
+    public void click(int x, int y) {
+        Rectangle rect = getValidScreenRectangle();
+        Tester.click((int) rect.x + x, (int) rect.y + y);
+    }
+
+    public void doubleClick(int x, int y) {
+        Rectangle rect = getValidScreenRectangle();
+        Tester.doubleClick((int) rect.x + x, (int) rect.y + y);
+    }
+
+    public void click(double xPercent, double yPercent) {
+        Rectangle rect = getValidScreenRectangle();
+        Tester.click((int)(rect.x + xPercent * rect.width), (int) (rect.y + yPercent * rect.height));
+    }
+
+    public void doubleClick(double xPercent, double yPercent) {
+        Rectangle rect = getValidScreenRectangle();
+        Tester.doubleClick((int)(rect.x + xPercent * rect.width), (int) (rect.y + yPercent * rect.height));
+    }
+
+    public void rightClick(int x, int y) {
+        Rectangle rect = getValidScreenRectangle();
+        Tester.rightClick((int) rect.x + x, (int) rect.y + y);
+    }
+
+    public void drag(int fromX, int fromY, int toX, int toY) {
+        Rectangle rect = getValidScreenRectangle();
+        Tester.drag((int) rect.x + fromX, (int) rect.y + fromY, (int) rect.x + toX, (int) rect.y + toY);
+    }
+
+    /**
+     * Return the caption of control
+     *
+     * @return
+     */
+    public String getCaption() {
+        return (String) invoke(Constant.M_Caption);
+    }
+
+    /**
+     * Returns if the control is enabled
+     *
+     * @return Returns true if the control is enabled, otherwise false is
+     *         returned.
+     */
+    public boolean isEnabled() {
+        return (Boolean) invoke(Constant.M_IsEnabled);
+    }
+
+    /**
+     * Returns if the control is checked
+     *
+     * @return Returns true if the control is enabled, otherwise false is
+     *         returned.
+     */
+    public boolean isChecked() {
+        return (Boolean) invoke(Constant.M_IsChecked);
+    }
+
+    /**
+     * Return the count of fixed text in the control
+     *
+     * @return
+     */
+    protected int getFixedTextCount() {
+        return (Integer) invoke(Constant.M_GetFixedTextCount);
+
+    }
+
+    /**
+     * Return the fixed text in the control
+     *
+     * @param i
+     *            the index of fixed text
+     * @return the text of fixed text
+     */
+    protected String getFixedText(int i) {
+        return (String) invoke(Constant.M_GetFixedText, new Object[] { new Integer(i + 1) });
+    }
+
+    /**
+     * Operate the control via VclHook
+     *
+     * @param methodId
+     * @param args
+     * @return
+     */
+    public Object invoke(int methodId, Object... args) {
+        return VclHook.invokeControl(getUID(), methodId, args);
+    }
+
+    /**
+     *
+     * @param methodId
+     * @return
+     */
+    public Object invoke(int methodId) {
+        return VclHook.invokeControl(getUID(), methodId, null);
+    }
+
+    /**
+     * Internal use
+     *
+     */
+    protected void useMenu() {
+        invoke(Constant.M_UseMenu);
+    }
+
+    /**
+     * TODO implement it. This is test tool implementation to input keyboard
+     * keys.
+     *
+     */
+    public void inputKeys(String keys) {
+        invoke(Constant.M_TypeKeys, new Object[] { keys });
+    }
+
+    /**
+     * Check if the control exists in a period of time
+     */
+    public boolean exists(double iTimeout) {
+        return exists(iTimeout, 1);
+    }
+
+    /**
+     * Check if the control exists in a period of time
+     */
+    public boolean exists(double iTimeout, double interval) {
+        return new Condition() {
+            @Override
+            public boolean value() {
+                return VclControl.this.exists();
+            }
+        }.test(iTimeout, interval);
+    }
+
+    /**
+     * Wait for the control to exist in a period of time. If the time is out, an
+     * ObjectNotFoundException will be throwed.
+     *
+     * @param iTimeout
+     * @param interval
+     */
+    public void waitForExistence(double iTimeout, double interval) {
+        new Condition() {
+            @Override
+            public boolean value() {
+                return VclControl.this.exists();
+            }
+        }.waitForTrue( this + " is not found!", iTimeout, interval);
+    }
+
+
+    public void waitForEnabled(double iTimeout, double interval) {
+        new Condition() {
+
+            @Override
+            public boolean value() {
+                return VclControl.this.isEnabled();
+            }
+
+        }.waitForTrue("Time out to wait the control to be enabled!", iTimeout, interval);
+    }
+
+    public void waitForDisabled(double iTimeout, double interval) {
+        new Condition() {
+
+            @Override
+            public boolean value() {
+                return !VclControl.this.isEnabled();
+            }
+
+        }.waitForTrue("Time out to wait the control to be disabled!", iTimeout, interval);
+    }
+
+    public void waitForText(final String text, double iTimeout, double interval) {
+        new Condition() {
+
+            @Override
+            public boolean value() {
+                return text.equals(VclControl.this.getCaption());
+            }
+
+        }.waitForTrue("Time out to wait the control to show the text: " + text, iTimeout, interval);
+    }
+
+
+    public int getType() {
+        if (type == -1)
+            type = ((Long) invoke(Constant.M_GetRT)).intValue();
+        return type;
+    }
+
+    /**
+     * Returns if the control exists
+     *
+     * @return Returns true if the control is existed, otherwise false is
+     *         returned.
+     *
+     */
+    public boolean exists() {
+        // If the communication is not established. return false
+        try {
+            VclHook.getCommunicationManager().connect();
+        } catch (IOException e) {
+            return false;
+        }
+        return (Boolean) invoke(Constant.M_Exists);
+    }
+
+    public void focus() {
+        inputKeys("");
+    }
+
+    public Rectangle getScreenRectangle() {
+        String ret = (String) invoke(Constant.M_GetScreenRectangle, new Object[] { Boolean.FALSE });
+        if (ret == null)
+            return null;
+        String[] data = ret.split(",");
+        int x = Integer.parseInt(data[0]);
+        int y = Integer.parseInt(data[1]);
+        int w = Integer.parseInt(data[2]);
+        int h = Integer.parseInt(data[3]);
+        return new Rectangle(x, y, w, h);
+    }
+
+    public Rectangle getValidScreenRectangle() {
+        Rectangle rect = getScreenRectangle();
+        if (rect == null)
+            throw new RuntimeException(this + " - screen rectangle could not be computed! Maybe it is not showing!");
+        return rect;
+    }
+
+    public VclMenuItem menuItem(String path) {
+        return new VclMenuItem(new VclMenu(this), path);
+    }
+    /**
+     * Opens the context menu of the control.
+     * <p>
+     * The context menu opens at the position of the mouse.
+     * <p>
+     * To open the context menu at a specific position in a window, you have to
+     * first move the mouse to the position before using this method.
+     * <p>
+     *
+     * @param
+     */
+    public void openContextMenu() {
+        invoke(Constant.M_OpenContextMenu);
+    }
+
+
+    public String toString() {
+        if (uid != null)
+            return uid.toString();
+        else
+            return null;
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclDialog.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclDialog.java
new file mode 100644
index 000000000000..6d680d372746
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclDialog.java
@@ -0,0 +1,56 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+
+
+/**
+ * Proxy to access the VCL dialog
+ */
+public class VclDialog extends VclWindow {
+
+    /**
+     * Define the dialog with its string ID
+     * @param id
+     */
+    public VclDialog(String uid) {
+        super(uid);
+    }
+
+
+    public VclDialog(SmartId id) {
+        super(id);
+    }
+
+
+    /**
+     * Closes a dialog by pressing the Cancel button.
+     */
+    public void cancel() {
+        invoke(Constant.M_Cancel);
+    }
+
+    /**
+     * Closes a dialog with the Default button.
+     */
+    public void restoreDefaults()  {
+        invoke(Constant.M_Default);
+    }
+
+    /**
+     * Closes a dialog with the OK button.
+     */
+    public void ok()  {
+        invoke(Constant.M_OK);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclDockingWin.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclDockingWin.java
new file mode 100644
index 000000000000..052a069d8ae0
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclDockingWin.java
@@ -0,0 +1,58 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+
+
+/**
+ * Proxy used to access VCL Docking window
+ *
+ */
+public class VclDockingWin extends VclWindow {
+    /**
+     * Define VCL Docking window
+     * @param uid the string id
+     */
+    public VclDockingWin(String uid) {
+        super(uid);
+    }
+
+    public VclDockingWin(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Docks a window on one edge of the desktop.
+     */
+    public void dock() {
+        if (!isDocked())
+            invoke(Constant.M_Dock);
+    }
+
+    /**
+     * Undocks a docking window.
+     */
+    public void undock() {
+        if (isDocked())
+            invoke(Constant.M_Undock);
+    }
+
+    /**
+     * Returns the docking state.
+     * @return Returns TRUE if the window is docking, otherwise FALSE is
+     *         returned.
+     */
+    public boolean isDocked() {
+        return (Boolean) invoke(Constant.M_IsDocked);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclEditBox.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclEditBox.java
new file mode 100644
index 000000000000..6d7d324df596
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclEditBox.java
@@ -0,0 +1,58 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ * Proxy used to access VCL EditField/MultiLineEditField
+ *
+ */
+public class VclEditBox extends VclControl {
+
+    /**
+     * Construct the control with its string ID
+     * @param uid
+     */
+    public VclEditBox(String uid) {
+        super(uid);
+    }
+
+    public VclEditBox(SmartId smartId) {
+        super(smartId);
+    }
+
+    /**
+     * Set the text of edit box
+     * @param str
+     */
+    public void setText(String str) {
+        invoke(Constant.M_SetText, new Object[]{str});
+    }
+
+
+    /**
+     * Is the edit box writable?
+     * @return true if it is writable, false otherwise
+     */
+    public boolean isWritable() {
+        return (Boolean)invoke(Constant.M_IsWritable);
+    }
+
+
+    /**
+     * Get the text of edit box
+     * @return the text of edit box
+     */
+    public String getText(){
+        return (String) invoke(Constant.M_GetText);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclField.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclField.java
new file mode 100644
index 000000000000..8f163187dae8
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclField.java
@@ -0,0 +1,64 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ * Proxy used to access all VCL field controls
+ *
+ */
+public class VclField extends VclEditBox{
+
+    public VclField(SmartId smartId) {
+        super(smartId);
+    }
+
+    /**
+     * Construct the field control with its string ID
+     * @param uid
+     */
+    public VclField(String uid) {
+        super(uid);
+    }
+
+    /**
+     * Move one entry higher of Field
+     *
+     */
+    public void more() {
+        invoke(Constant.M_More);
+    }
+
+    /**
+     * Move one entry lower of Field
+     *
+     */
+    public void less() {
+        invoke(Constant.M_Less);
+    }
+
+    /**
+     * Goes to the maximum value of Field
+     *
+     */
+    public void toMax() {
+        invoke(Constant.M_ToMax);
+    }
+
+
+    /**
+     * Goes to the minimum value of Field
+     */
+    public void toMin() {
+        invoke(Constant.M_ToMin);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclListBox.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclListBox.java
new file mode 100644
index 000000000000..13ce8ab5c19e
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclListBox.java
@@ -0,0 +1,184 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+
+public class VclListBox extends VclControl  {
+
+    /**
+     * Construct the list box with its string ID
+     * @param uid
+     */
+    public VclListBox(String uid) {
+        super(uid);
+    }
+
+    public VclListBox(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Returns the number of entries in a TreeListBox.
+     *
+     * @return Number of list box entries. Error if the return value is -1.
+     */
+    public int getItemCount() {
+        return ((Long) invoke(Constant.M_GetItemCount)).intValue();
+    }
+
+    /**
+     * Get the text of the specified entry in the tree list box Notice:
+     * index,col starting from 0
+     *
+     * @param index
+     * @param col
+     * @return
+     */
+    public String getItemText(int index, int col) {
+        return (String) invoke(Constant.M_GetItemText, new Object[] { new Integer(index + 1), new Integer(col + 1) });
+    }
+
+    /**
+     * Get the text of the specified node Notice: index starting from 0
+     *
+     * @param index
+     * @return
+     */
+    public String getItemText(int index) {
+        return getItemText(index, 0);
+    }
+
+    /**
+     * Returns the number of selected entries in a TreeListbox(you can select
+     * more than one entry).
+     *
+     * @return The number of selected entries. Error is the return value is -1.
+     */
+    public int getSelCount() {
+        return ((Long) invoke(Constant.M_GetSelCount)).intValue();
+    }
+
+    /**
+     * Returns the index number of the selected entry in the TreeListBox.
+     * Notice: index starting from 0
+     *
+     * @return The index number of selected entries. Error is the return value
+     *         is -1.
+     */
+    public int getSelIndex() {
+        return ((Long) invoke(Constant.M_GetSelIndex)).intValue() - 1;
+    }
+
+    /**
+     * Get the text of the selected item
+     */
+    public String getSelText() {
+        return (String) invoke(Constant.M_GetSelText);
+    }
+
+    /**
+     * Select the specified node via its index Notice: index starting from 0
+     *
+     * @param index
+     */
+    public void select(int index) {
+        invoke(Constant.M_Select, new Object[] { new Integer(index + 1) });
+    }
+
+    /**
+     * Selects the text of an entry.
+     *
+     * @param str
+     *            the item string
+     */
+    public void select(String text) {
+        if (getType() == 324) {
+            int count = getItemCount();
+            for (int i = 0; i < count; i++) {
+                if (text.equals(getItemText(i))) {
+                    select(i);
+                    return;
+                }
+            }
+
+            throw new RuntimeException(text + " is not found in the list box");
+        } else {
+            invoke(Constant.M_Select, new Object[] { text });
+        }
+    }
+
+    /**
+     * Append one item to be selected after selected some items.
+     *
+     * @param i
+     *            the index of the item
+     */
+    public void multiSelect(int i) {
+        invoke(Constant.M_MultiSelect, new Object[] { new Integer(i + 1) });
+    }
+
+    /**
+     * Append one item to be selected after selected some items.
+     *
+     * @param text
+     *            the text of the item
+     */
+    public void multiSelect(String text) {
+        invoke(Constant.M_MultiSelect, new Object[] { text });
+    }
+
+    /**
+     * get all items'text.
+     *
+     */
+    public String[] getItemsText() {
+        int count = getItemCount();
+        String[] res = new String[count];
+        for (int i = 0; i < count; i++) {
+            res[i] = getItemText(i);
+        }
+        return res;
+    }
+
+    /**
+     *
+     * @param text
+     * @return
+     */
+    public int getItemIndex(String text) {
+        int count = getItemCount();
+        for (int i = 0; i < count; i++) {
+            if (text.equals(getItemText(i)))
+                return i;
+        }
+
+        throw new RuntimeException(text + " is not found in the list box");
+    }
+
+
+    /**
+     * Check if the list box has the specified item
+     *
+     * @param str
+     * @return
+     */
+    public boolean hasItem(String str) {
+        int len = getItemCount();
+        for (int i = 0; i < len; i++) {
+            String text = getItemText(i);
+            if (str.equals(text))
+                return true;
+        }
+        return false;
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMenu.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMenu.java
new file mode 100644
index 000000000000..1643ef50ead2
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMenu.java
@@ -0,0 +1,70 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.VclHook;
+
+/**
+ * Define VCL menu on a window
+ *
+ */
+public class VclMenu {
+
+    private VclControl window = null;
+
+    /**
+     * Construct the popup menu
+     *
+     */
+    public VclMenu() {
+
+    }
+
+    /**
+     * Construct the menu on the given window
+     *
+     * @param window
+     */
+    public VclMenu(VclControl window) {
+        this.window = window;
+    }
+
+    /**
+     * Returns the numbers of menu items (including the menu separators)
+     *
+     * @return Number of menu items in a menu . -1 : Return value error
+     *
+     */
+    public int getItemCount() {
+        use();
+        return ((Long) VclHook.invokeCommand(Constant.RC_MenuGetItemCount)).intValue();
+    }
+
+    /**
+     * Return the menu item at the n-th index
+     *
+     * @param index
+     * @return null when the item is separator
+     */
+    public VclMenuItem getItem(int index) {
+        use();
+        long id = ((Long) VclHook.invokeCommand(Constant.RC_MenuGetItemId, new Object[] { new Integer(index + 1) })).intValue();
+        if (id == 0)
+            return null;
+        return new VclMenuItem(this, (int) id);
+    }
+
+    protected void use() {
+        if (window != null) {
+            window.useMenu();
+        }
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMenuItem.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMenuItem.java
new file mode 100644
index 000000000000..e06d5ec339d5
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMenuItem.java
@@ -0,0 +1,242 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.common.SystemUtil;
+import org.openoffice.test.vcl.Tester;
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.VclHook;
+
+/**
+ *
+ */
+public class VclMenuItem {
+
+    private int id = -1;
+
+    private String[] path = null;
+
+    private VclMenu menu = null;
+
+    /**
+     * Construct menu item with its ID
+     *
+     * @param id
+     */
+    public VclMenuItem(int id) {
+        this.id = id;
+    }
+
+    /**
+     * Construct menu item with its path like
+     * "RootMenuItem->Level1Item->Level2Item".
+     *
+     * @param path
+     */
+    public VclMenuItem(String path) {
+        this.path = path.split("->");
+    }
+
+    /**
+     * Vcl Menu Item on menu bar
+     *
+     * @param menu
+     * @param id
+     */
+    public VclMenuItem(VclMenu menu, int id) {
+        this.id = id;
+        this.menu = menu;
+    }
+
+    /**
+     * Vcl Menu Item on menu bar
+     *
+     * @param menu
+     * @param path
+     */
+    public VclMenuItem(VclMenu menu, String path) {
+        this.path = path.split("->");
+        this.menu = menu;
+    }
+
+    private Object invoke(int methodId) {
+        int id = getId();
+        if (id == -1)
+            throw new RuntimeException("Menu item '" + path[path.length - 1] + "' can be found!");
+        return VclHook.invokeCommand(methodId, new Object[] { id });
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int getId() {
+        VclMenu menu = new VclMenu();
+        if (path != null) {
+            int count = menu.getItemCount();
+            for (int i = 0; i < count; i++) {
+                VclMenuItem item = menu.getItem(i);
+                if (item == null)
+                    continue;
+                String itemText = path[path.length - 1];
+                if (item.getTextWithoutMneumonic().contains(itemText)) {
+                    return item.getId();
+                }
+            }
+
+            return -1;
+        }
+
+        return this.id;
+    }
+
+    /**
+     * Select the menu item
+     *
+     */
+    public void select() {
+        if (menu != null)
+            menu.use();
+        for (int i = 0; i < path.length; i++) {
+            new VclMenuItem(path[i]).pick();
+            Tester.sleep(0.5);
+        }
+    }
+
+    private void pick() {
+        invoke(Constant.RC_MenuSelect);
+    }
+
+    /**
+     * Select the parent of the item
+     *
+     */
+    public void selectParent() {
+        if (menu != null)
+            menu.use();
+        for (int i = 0; i < path.length - 1; i++)
+            new VclMenuItem(path[i]).pick();
+    }
+
+    /**
+     * Check if the menu item exists
+     *
+     * @return
+     */
+    public boolean exists() {
+        return getId() != -1;
+    }
+
+    /**
+     * Check if the menu item is selected!
+     *
+     * @return
+     */
+    public boolean isSelected() {
+        return ((Boolean) invoke(Constant.RC_MenuIsItemChecked)).booleanValue();
+    }
+
+    /**
+     * Check if the menu item is enabled
+     *
+     * @return
+     */
+    public boolean isEnabled() {
+        return ((Boolean) invoke(Constant.RC_MenuIsItemEnabled)).booleanValue();
+    }
+
+    /**
+     * Get the menu item position
+     *
+     * @return
+     */
+    public int getPosition() {
+        return ((Long) invoke(Constant.RC_MenuGetItemPos)).intValue();
+    }
+
+    /**
+     * Get the menu item text
+     *
+     * @return
+     */
+    public String getText() {
+        return (String) invoke(Constant.RC_MenuGetItemText);
+    }
+
+    /**
+     * Get the command id which is UNO-Slot
+     *
+     * @return
+     */
+    public String getCommand() {
+        return (String) invoke(Constant.RC_MenuGetItemCommand);
+    }
+
+    /**
+     * Get the accelerator character
+     */
+    public int getAccelerator() {
+        String text = this.getText();
+        if (text == null)
+            return 0;
+        int index = text.indexOf("~");
+        return index != -1 && index + 1 < text.length() ? text.charAt(index + 1) : 0;
+    }
+
+    /**
+     * Get text without mneumonic
+     */
+    public String getTextWithoutMneumonic() {
+        String text = this.getText();
+        return text != null ? text.replace("~", "") : text;
+    }
+
+    /**
+     * Check if the menu item is showing
+     */
+    public boolean isShowing() {
+        return exists();
+    }
+
+    /**
+     * Check if the menu item has sub menu
+     *
+     * @return
+     */
+    public boolean hasSubMenu() {
+        return (Boolean) invoke(Constant.RC_MenuHasSubMenu);
+    }
+
+    public String toString() {
+        return "ID:" + getId() + ", Text:" + getText() + ", Selected:" + isSelected() + ", Enabled:" + isEnabled() + ", Command:" + getCommand()
+                + ", Position:" + getPosition();
+    }
+
+    /**
+     * Check if the widget exists in a period of time
+     */
+    public boolean exists(double iTimeout) {
+        return exists(iTimeout, 1);
+    }
+
+    /**
+     * Check if the widget exists in a period of time
+     */
+    public boolean exists(double iTimeout, double interval) {
+        long startTime = System.currentTimeMillis();
+        while (System.currentTimeMillis() - startTime < iTimeout * 1000) {
+            if (exists())
+                return true;
+            SystemUtil.sleep(interval);
+        }
+
+        return exists();
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMessageBox.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMessageBox.java
new file mode 100644
index 000000000000..39c4f46ffcbc
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclMessageBox.java
@@ -0,0 +1,166 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+import org.openoffice.test.vcl.client.VclHookException;
+
+/**
+ * VCL message box proxy.
+ *
+ */
+public class VclMessageBox extends VclControl {
+
+    private String message = null;
+
+
+    public VclMessageBox(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Construct the active message box with a given message.
+     * The message can be used to distinguish message boxes.
+     * @param msg
+     */
+    public VclMessageBox(SmartId id, String msg) {
+        super(id);
+        this.message = msg;
+    }
+
+    public VclMessageBox(String id, String msg) {
+        super(id);
+        this.message = msg;
+    }
+
+    /**
+     * Get the message on the message box
+     * @return
+     */
+    public String getMessage() {
+        return (String) invoke(Constant.M_GetText);
+    }
+
+    public boolean exists() {
+        try {
+            boolean exists = super.exists();
+            if (!exists)
+                return false;
+
+            if (WINDOW_MESSBOX != getType())
+                return false;
+
+            if (message != null) {
+                String msg = getMessage();
+                return msg.contains(message);
+            }
+
+            return true;
+        } catch (VclHookException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Click the yes button on the message box
+     *
+     */
+    public void yes(){
+        invoke(Constant.M_Yes);
+    }
+
+    /**
+     * Click the no button on the message box
+     *
+     */
+    public void no(){
+        invoke(Constant.M_No);
+    }
+
+
+    /**
+     * Closes a dialog by pressing the Cancel button.
+     */
+    public void cancel() {
+        invoke(Constant.M_Cancel);
+    }
+
+    /**
+     * Closes a dialog with the Close button.
+     */
+    public void close() {
+        invoke(Constant.M_Close);
+    }
+
+    /**
+     * Closes a dialog with the Default button.
+     */
+    public void doDefault()  {
+        invoke(Constant.M_Default);
+    }
+
+    /**
+     * Presses the Help button to open the help topic for the dialog.
+     *
+     */
+    public void help()  {
+        invoke(Constant.M_Help);
+    }
+
+    /**
+     * Closes a dialog with the OK button.
+     */
+    public void ok()  {
+        invoke(Constant.M_OK);
+    }
+
+
+    /**
+     * Closes a dialog with the OK button.
+     */
+    public void repeat()  {
+        invoke(Constant.M_Repeat);
+    }
+
+    /**
+     * Get the check box text if it exists
+     *
+     * @return the check box text
+     */
+    public String getCheckBoxText() {
+        return (String) invoke(Constant.M_GetCheckBoxText);
+    }
+
+    /**
+     * Get the status of check box on the message box
+     * @return
+     */
+    public boolean isChecked() {
+        return (Boolean) invoke(Constant.M_IsChecked);
+    }
+
+    /**
+     * Check the check box on the message box
+     *
+     */
+    public void check() {
+        invoke(Constant.M_Check);
+    }
+
+    /**
+     * Uncheck the check box on the message box
+     *
+     */
+    public void uncheck() {
+        invoke(Constant.M_UnCheck);
+    }
+
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclStatusBar.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclStatusBar.java
new file mode 100644
index 000000000000..a2f4aced2436
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclStatusBar.java
@@ -0,0 +1,71 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ * VCL status bar proxy
+ *
+ */
+public class VclStatusBar extends VclControl {
+
+    public VclStatusBar(SmartId id) {
+        super(id);
+    }
+
+    public VclStatusBar(String uid) {
+        super(uid);
+    }
+
+    /**
+     * Get the text of the item with the given ID
+     * @param id
+     * @return
+     */
+    public String getItemTextById(int id) {
+        return (String) invoke(Constant.M_StatusGetText, new Object[]{id});
+    }
+
+    /**
+     * Get the text of the item at the given index
+     * @param i
+     * @return
+     */
+    public String getItemText(int i) {
+        return getItemTextById(getItemId(i));
+    }
+
+    /**
+     * Get the item count
+     * @return
+     */
+    public int getItemCount() {
+        return ((Long) invoke(Constant.M_StatusGetItemCount)).intValue();
+    }
+
+    /**
+     * Get the item ID at the given index
+     * @param i
+     * @return
+     */
+    public int getItemId(int i) {
+        return ((Long) invoke(Constant.M_StatusGetItemId, new Object[]{i + 1})).intValue();
+    }
+
+    /**
+     * Check if the status box is progress box.
+     * @return
+     */
+    public boolean isProgress() {
+        return (Boolean) invoke(Constant.M_StatusIsProgress);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclTabControl.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclTabControl.java
new file mode 100644
index 000000000000..630e05ffe658
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclTabControl.java
@@ -0,0 +1,111 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ * Proxy to access VCL tab control
+ *
+ */
+public class VclTabControl extends VclControl {
+
+    /**
+     * Construct the tab folder with its string ID
+     * @param uid
+     */
+    public VclTabControl(String uid) {
+        super(uid);
+    }
+
+    public VclTabControl(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Get the current page
+     * @return
+     */
+    public int getPage() {
+        return ((Long) invoke(Constant.M_GetPage)).intValue();
+    }
+
+    /**
+     * Returns the number of tab pages in the TabControl.
+     * <p>
+     *
+     * @return number of tab pages in the dialog. -1 : Return value error
+     *         <p>
+     */
+    public int getPageCount() {
+        return ((Long) invoke(Constant.M_GetPageCount)).intValue();
+    }
+
+    /**
+     * Returns the TabpageID of current Tab Page in the Tab dialog. This not the
+     * UniqueID and is only needed for the SetPageID instruction..
+     * <p>
+     *
+     * @return TabpageID used in SetPageID instruction; -1 : Return value error
+     *         <p>
+     */
+    public int getPageId() {
+        return ((Long) invoke(Constant.M_GetPageId)).intValue();
+    }
+
+    /**
+     * Returns the TabpageID of specified Tab page in the Tab dialog. This not
+     * the UniqueID and is only needed for the SetPageID instruction..
+     * <p>
+     *
+     * @param nTabID :
+     *            Specified Tab Page which order from 1. eg. A tab dialog have
+     *            two Tab pages, nTabID is 2 if you want to get the TabpageID of
+     *            second Tab page
+     * @return TabpageID used in SetPageID instruction; -1 : Return value error
+     *         <p>
+     */
+    public int getPageId(short nTabID) {
+        return ((Long) invoke(Constant.M_GetPageId, new Object[] { nTabID }))
+                .intValue();
+    }
+
+    /**
+     * Changes to the tab page that has the TabpageID that you specify.
+     * <p>
+     *
+     * @param id
+     *            TabpageID of tab page
+     */
+    public void setPageId(int id) {
+        invoke(Constant.M_SetPageId, new Object[] { id });
+    }
+
+    /**
+     * Change to the tab page you specify
+     * <p>
+     *
+     * @param nTabResID
+     *            The resource ID of the specified Tab page in Tab Dialog
+     */
+    public void setPage(long nTabResID) {
+        invoke(Constant.M_SetPage, new Object[] { nTabResID });
+    }
+
+    /**
+     * Change to the specified tab page
+     * @param widget the TabPage widget (Type: 372)
+     * @throws Exception
+     */
+    public void setPage(VclControl widget) {
+        setPage(widget.getUID().getId());
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclTabPage.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclTabPage.java
new file mode 100644
index 000000000000..1c492daea620
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclTabPage.java
@@ -0,0 +1,38 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.SmartId;
+
+
+public class VclTabPage extends VclDialog {
+
+    private VclTabControl tabControl = null;
+
+    public VclTabPage(SmartId id, VclTabControl tabControl) {
+        super(id);
+        this.tabControl = tabControl;
+    }
+
+    public VclTabPage(String uid, VclTabControl tabControl) {
+        super(uid);
+        this.tabControl = tabControl;
+    }
+
+
+    /**
+     * Selects the tab page to be active.
+     *
+     */
+    public void select() {
+        if (tabControl != null)
+            tabControl.setPage(this.getUID().getId());
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclToolBox.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclToolBox.java
new file mode 100644
index 000000000000..0cb042e9763d
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclToolBox.java
@@ -0,0 +1,87 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+
+/**
+ * Proxy to access the VCL tool box
+ *
+ * Type: WINDOW_TOOLBOX
+ *
+ */
+public class VclToolBox extends VclDockingWin {
+
+    public VclToolBox(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Define a vcl tool bar
+     * @param uid the string id
+     */
+    public VclToolBox(String uid) {
+        super(uid);
+    }
+
+    /**
+     * Click the down arrow of tool bar to show the menu
+     *
+     */
+    public void openMenu() {
+        invoke(Constant.M_OpenContextMenu);
+    }
+
+    /**
+     * Returns the count of items in the tool bar
+     *
+     * @return the count
+     */
+    public int getItemCount() {
+        return ((Long) invoke(Constant.M_GetItemCount)).intValue();
+    }
+
+    /**
+     * Get the text of the index-th item
+     * @param index
+     * @return
+     */
+    public String getItemText(int index) {
+        return (String) invoke(Constant.M_GetItemText2, new Object[] {index + 1});
+    }
+
+    /**
+     * Get the quick tooltip text of the index-th item
+     * @param index
+     * @return
+     */
+    public String getItemQuickToolTipText(int index) {
+        return (String) invoke(Constant.M_GetItemQuickHelpText, new Object[] {index + 1});
+    }
+
+    /**
+     * Get the tooltip text of the index-th item
+     * @param index
+     * @return
+     */
+    public String getItemToolTipText(int index) {
+        return (String) invoke(Constant.M_GetItemHelpText, new Object[] {index + 1});
+    }
+
+    /**
+     * Get the name of the next tool bar
+     * @return
+     */
+    public String getNextToolBar() {
+        return (String) invoke(Constant.M_GetNextToolBox);
+    }
+}
diff --git a/test/testcommon/source/org/openoffice/test/vcl/widgets/VclWindow.java b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclWindow.java
new file mode 100644
index 000000000000..6bb933831fc7
--- /dev/null
+++ b/test/testcommon/source/org/openoffice/test/vcl/widgets/VclWindow.java
@@ -0,0 +1,128 @@
+/************************************************************************
+ *
+ * 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.vcl.widgets;
+
+import java.awt.Point;
+
+import org.openoffice.test.vcl.client.Constant;
+import org.openoffice.test.vcl.client.SmartId;
+
+/**
+ * Proxy to access a VCL window.
+ *
+ */
+public class VclWindow extends VclControl {
+
+    /**
+     * Define a VCL window
+     * @param uid the string id
+     */
+    public VclWindow(String uid) {
+        super(uid);
+    }
+
+    public VclWindow(SmartId id) {
+        super(id);
+    }
+
+    /**
+     * Get the title of the window
+     * @return
+     */
+    public String getText() {
+        return getCaption();
+    }
+
+    /**
+     * Presses the Help button to open the help topic for the window
+     *
+     */
+    public void help()  {
+        invoke(Constant.M_Help);
+    }
+
+    /**
+     * Closes a window with the Close button.
+     */
+    public void close() {
+        invoke(Constant.M_Close);
+    }
+
+    /**
+     * Move the window by percent
+     *
+     * @param x
+     * @param y
+     */
+    public void move(int x, int y)  {
+        invoke(Constant.M_Move, new Object[]{new Integer(x), new Integer(y)});
+    }
+
+    /**
+     * Move the window by pixel
+     * @param p
+     */
+    public void move(Point p) {
+        move(p.x, p.y);
+    }
+
+
+
+    /**
+     * Returns the state of the window (maximize or minimize).
+     * <p>
+     *
+     * @return Returns TRUE if the window is maximized, otherwise FALSE is
+     *         returned.
+     */
+    public boolean isMax() {
+        return (Boolean)invoke(Constant.M_IsMax);
+    }
+
+    /**
+     * Maximizes a window so that the contents of the window are visible.
+     */
+    public void maximize() {
+        invoke(Constant.M_Maximize);
+    }
+
+    /**
+     * Minimizes a window so that only the title bar of the window is visible
+     */
+    public void minimize() {
+        invoke(Constant.M_Minimize);
+    }
+
+
+    /**
+     * Resize the window
+     * @param x
+     * @param y
+     */
+    public void resize(int x, int y) {
+        invoke(Constant.M_Size, new Object[]{new Integer(x), new Integer(y)});
+    }
+
+    /**
+     * Restore the window
+     *
+     */
+    public void restore() {
+        invoke(Constant.M_Restore);
+    }
+
+    /**
+     * Activate the window
+     */
+    public void activate() {
+        // focus it
+        focus();
+    }
+}