xref: /AOO42X/main/automation/source/server/statemnt.cxx (revision 1a9ecf28287d28b6b3ee0448b1cc3a0b3483019e)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_automation.hxx"
#include <com/sun/star/frame/XFramesSupplier.hpp>
#include <com/sun/star/frame/XDispatch.hpp>
#include <com/sun/star/frame/XDispatchProvider.hpp>
#include <com/sun/star/util/XURLTransformer.hpp>
#include <comphelper/processfactory.hxx>
#include <comphelper/uieventslogger.hxx>

#include <tools/wintypes.hxx>
#include <vcl/dialog.hxx>
#include <vcl/button.hxx>
#include <vcl/menubtn.hxx>
#include <svtools/svtreebx.hxx>
#include <svtools/brwbox.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/dockwin.hxx>
#include <vcl/floatwin.hxx>
#include <vcl/lstbox.hxx>
#include <vcl/combobox.hxx>
#include <vcl/morebtn.hxx>
#include <vcl/field.hxx>
#include <vcl/toolbox.hxx>
#include <vcl/tabctrl.hxx>
#include <vcl/tabpage.hxx>
#include <vcl/menu.hxx>
#include <vcl/status.hxx>
#include <svtools/prgsbar.hxx>
#include <svtools/editbrowsebox.hxx>
#include <vcl/splitwin.hxx>
#include <vcl/group.hxx>
#include <vcl/fixed.hxx>
#include <vcl/wrkwin.hxx>
#include <osl/diagnose.h>
#include <svtools/valueset.hxx>
#include <svtools/roadmap.hxx>
#include <svtools/table/tablecontrol.hxx>
#include <svtools/table/tablecontrolinterface.hxx>
#include <svl/poolitem.hxx>
#include <svtools/extensionlistbox.hxx>
#include <svtools/svtdata.hxx>
#include <tools/time.hxx>
#include <svtools/stringtransfer.hxx>
#include <tools/stream.hxx>
#include <tools/fsys.hxx>
#include <svl/stritem.hxx>
#include <svtools/ttprops.hxx>
#include <basic/ttstrhlp.hxx>
#include <basic/dispdefs.hxx>
#include <basic/sbuno.hxx>
#include <vos/socket.hxx>
#include <svl/pickerhistory.hxx>
#include <com/sun/star/util/XCancellable.hpp>
#include <sot/storage.hxx>
#include <sot/storinfo.hxx>
#include "statemnt.hxx"
#include "scmdstrm.hxx"
#include "retstrm.hxx"
#if OSL_DEBUG_LEVEL > 1
#include "editwin.hxx"
#endif
#include "rcontrol.hxx"
#include <automation/communi.hxx>
#include "testtool.hxx"
#include "profiler.hxx"
#include "recorder.hxx"
#include "testtool.hrc"
#include <basic/svtmsg.hrc>
#include <algorithm>
#include <vcl/dibtools.hxx>

using namespace com::sun::star::frame;
using namespace com::sun::star::uno;
//using namespace com::sun::star::util; can't be done because of Color
using namespace com::sun::star::beans;
using namespace svt;
//using namespace svt::table;

#ifndef SBX_VALUE_DECL_DEFINED
#define SBX_VALUE_DECL_DEFINED
SV_DECL_REF(SbxValue)
#endif
SV_IMPL_REF(SbxValue)

CommunicationLink *StatementFlow::pCommLink = NULL;
sal_Bool StatementFlow::bUseIPC = sal_True;
sal_Bool StatementFlow::bSending = sal_False;
ImplRemoteControl *StatementFlow::pRemoteControl = NULL;

sal_uInt16 StatementCommand::nDirPos = 0;
Dir *StatementCommand::pDir = NULL;
pfunc_osl_printDebugMessage StatementCommand::pOriginal_osl_DebugMessageFunc = NULL;

#define RESET_APPLICATION_TO_BACKING_WINDOW

#define SET_WINP_CLOSING(pWin) \
    pWindowWaitPointer = pWin; \
    aWindowWaitUId = pControl->GetUniqueOrHelpId(); \
    aWindowWaitOldHelpId = pWin->GetHelpId(); \
    aWindowWaitOldUniqueId = pWin->GetUniqueId(); \
    pWin->SetHelpId( rtl::OString("TT_Win_is_closing_HID") ); \
    pWin->SetUniqueId( rtl::OString("TT_Win_is_closing_UID") );

// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

StatementFlow::StatementFlow( StatementList *pAfterThis, sal_uInt16 nArtP )
: nArt(nArtP)
, nParams(0)
, nSNr1(0)
, nLNr1(0)
, aString1()
, bBool1(sal_False)
{
    QueStatement( pAfterThis );
}

StatementFlow::StatementFlow( sal_uLong nServiceId, SCmdStream *pCmdIn, ImplRemoteControl *pRC )
: nArt(0)
, nParams(0)
, nSNr1(0)
, nLNr1(0)
, aString1()
, bBool1(sal_False)
{
    QueStatement( NULL );
    bUseIPC = (nServiceId == SI_IPCCommandBlock);
    pRemoteControl = pRC;
    pCmdIn->Read( nArt );
    pCmdIn->Read( nParams );

    if( nParams & PARAM_USHORT_1 )  pCmdIn->Read( nSNr1 );
    if( nParams & PARAM_ULONG_1 )   pCmdIn->Read( nLNr1 );
    if( nParams & PARAM_STR_1 )     pCmdIn->Read( aString1 );
    if( nParams & PARAM_BOOL_1 )    pCmdIn->Read( bBool1 ); // should never occur!!

#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Reading FlowControl: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nArt ) );
    m_pDbgWin->AddText( " Params:" );
    if( nParams & PARAM_USHORT_1 )  {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nSNr1 ) );}
    if( nParams & PARAM_ULONG_1 )   {m_pDbgWin->AddText( " l1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
    if( nParams & PARAM_STR_1 )     {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
    if( nParams & PARAM_BOOL_1 )    {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
    m_pDbgWin->AddText( "\n" );
#endif
}

void StatementFlow::SendViaSocket()
{
    if ( bSending )
    {
#if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "SendViaSocket called recursively. Aborted!!!\n" );
#endif
        DBG_ERROR("SendViaSocket called recursively. Aborted!!!");
        return;
    }
    bSending = sal_True;
    if ( pCommLink )
    {
        if ( !pCommLink->TransferDataStream( pRet->GetStream() ) )  // If an error occurs, it is deleted immediately. ...
            pCommLink = NULL;
    }
    else
    {
        // It doesn't matter if there is no basic core for the testtool.
        DBG_ERROR("Cannot send results to TestTool");
    }

    pRet->Reset();
    bSending = sal_False;
    IsError = sal_False;
}

sal_Bool StatementFlow::Execute()
{
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Executing Flow: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nArt ) );
    m_pDbgWin->AddText( "\n" );
#endif
    switch ( nArt )
    {
    case F_EndCommandBlock:
        {

            if ( !bUseIPC )
            {
                // bBool1 was initialized to sal_False in CTOR
                if ( !bBool1 )  // so first run
                {
                    pRemoteControl->pRetStream = pRet->GetStream();
                    bBool1 = sal_True;  // was initialized to sal_False in CTOR
                    nRetryCount = nRetryCount * 4;
                }
                if ( pRemoteControl->pRetStream && (nRetryCount--) )    // unless you picked up it.
                {
                    return sal_False;   // Please get off the call stack once.
                }
            }

        }
        break;
    }

    Advance();
    switch ( nArt )
    {
    case F_EndCommandBlock:
        if ( !bUseIPC )
        {   // is discussed above
            pRet->Reset();
            IsError = sal_False;
        }
        else
            SendViaSocket();

        break;

    case F_Sequence:

        pRet->GenReturn(RET_Sequence,nLNr1);
        #if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "Sending Sequence Nr: " );
        m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );
        m_pDbgWin->AddText( "\n" );
        #endif

        break;
//  case RET_:
    default:
        DBG_ERROR( "Unknown Flowcontrol" );
        break;
    }

    delete this;
    return sal_True;
}

// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

// new auxiliary function, which must be constantly extended
static short ImpGetRType( Window *pWin )
{
    short nRT = C_NoType;
    WindowType eRT = pWin->GetType();
    switch( eRT ) {
        case WINDOW_WINDOW:             nRT = C_Window            ; break;

        case WINDOW_TABCONTROL:         nRT = C_TabControl        ; break;
        case WINDOW_RADIOBUTTON:        nRT = C_RadioButton       ; break;
        case WINDOW_CHECKBOX:           nRT = C_CheckBox          ; break;
        case WINDOW_TRISTATEBOX:        nRT = C_TriStateBox       ; break;
        case WINDOW_EDIT:               nRT = C_Edit              ; break;
        case WINDOW_MULTILINEEDIT:      nRT = C_MultiLineEdit     ; break;
        case WINDOW_MULTILISTBOX:       nRT = C_MultiListBox      ; break;
        case WINDOW_LISTBOX:            nRT = C_ListBox           ; break;
        case WINDOW_COMBOBOX:           nRT = C_ComboBox          ; break;
        case WINDOW_PUSHBUTTON:         nRT = C_PushButton        ; break;
        case WINDOW_SPINFIELD:          nRT = C_SpinField         ; break;
        case WINDOW_PATTERNFIELD:       nRT = C_PatternField      ; break;
        case WINDOW_NUMERICFIELD:       nRT = C_NumericField      ; break;
        case WINDOW_METRICFIELD:        nRT = C_MetricField       ; break;
        case WINDOW_CURRENCYFIELD:      nRT = C_CurrencyField     ; break;
        case WINDOW_DATEFIELD:          nRT = C_DateField         ; break;
        case WINDOW_TIMEFIELD:          nRT = C_TimeField         ; break;
        case WINDOW_IMAGERADIOBUTTON:   nRT = C_ImageRadioButton  ; break;
        case WINDOW_NUMERICBOX:         nRT = C_NumericBox        ; break;
        case WINDOW_METRICBOX:          nRT = C_MetricBox         ; break;
        case WINDOW_CURRENCYBOX:        nRT = C_CurrencyBox       ; break;
        case WINDOW_DATEBOX:            nRT = C_DateBox           ; break;
        case WINDOW_TIMEBOX:            nRT = C_TimeBox           ; break;
        case WINDOW_IMAGEBUTTON:        nRT = C_ImageButton       ; break;
        case WINDOW_MENUBUTTON:         nRT = C_MenuButton        ; break;
        case WINDOW_MOREBUTTON:         nRT = C_MoreButton        ; break;


        case WINDOW_TABPAGE:            nRT = C_TabPage;        break;
        case WINDOW_MODALDIALOG:        nRT = C_ModalDlg;       break;
        case WINDOW_FLOATINGWINDOW:     nRT = C_FloatWin;       break;
        case WINDOW_MODELESSDIALOG:     nRT = C_ModelessDlg;    break;
        case WINDOW_WORKWINDOW:         nRT = C_WorkWin;        break;
        case WINDOW_DOCKINGWINDOW:      nRT = C_DockingWin;     break;

        case WINDOW_MESSBOX:            nRT = C_MessBox;        break;
        case WINDOW_INFOBOX:            nRT = C_InfoBox;        break;
        case WINDOW_WARNINGBOX:         nRT = C_WarningBox;     break;
        case WINDOW_ERRORBOX:           nRT = C_ErrorBox;       break;
        case WINDOW_QUERYBOX:           nRT = C_QueryBox;       break;
#if 0 //ifndef VCL
        case WINDOW_FILEDIALOG:         nRT = C_FileDlg;        break;
        case WINDOW_PATHDIALOG:         nRT = C_PathDlg;        break;
        case WINDOW_PRINTDIALOG:        nRT = C_PrintDlg;       break;
        case WINDOW_PRINTERSETUPDIALOG: nRT = C_PrinterSetupDlg;break;
        case WINDOW_COLORDIALOG:        nRT = C_ColorDlg;       break;
#endif
        case WINDOW_TABDIALOG:          nRT = C_TabDlg;         break;
//      case WINDOW_TABDIALOG:          nRT = C_SingleTabDlg;   break;

        case WINDOW_PATTERNBOX:         nRT = C_PatternBox;     break;
        case WINDOW_TOOLBOX:            nRT = C_ToolBox;        break;
// Doesn't exist       case WINDOW_VALUESET:            nRT = C_ValueSet;       break;
        case WINDOW_CONTROL:            nRT = C_Control;        break;
        case WINDOW_OKBUTTON:           nRT = C_OkButton;       break;
        case WINDOW_CANCELBUTTON:       nRT = C_CancelButton;   break;
        case WINDOW_BUTTONDIALOG:       nRT = C_ButtonDialog;   break;
        case WINDOW_TREELISTBOX:        nRT = C_TreeListBox;    break;

        case WINDOW_DIALOG:             nRT = C_Dialog;         break;
    }
    return nRT;
}

// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

StatementSlot::StatementSlot( SCmdStream *pCmdIn )
: pItemArr(NULL)
{
    QueStatement( NULL );
    pCmdIn->Read( nFunctionId );
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Reading Slot: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
    m_pDbgWin->AddText( "\n" );
#endif
    pCmdIn->Read( nAnzahl );
    if ( nAnzahl )
    {
        switch ( pCmdIn->GetNextType() )
        {
            case BinUSHORT: // use old calling method
                {
                    nAnzahl++;
                    pItemArr = new SfxPoolItem*[nAnzahl];
                    for (sal_uInt16 i = 0 ; i+1 < nAnzahl ; i++)
                        pCmdIn->Read( pItemArr[i] );
                    pItemArr[nAnzahl-1] = NULL;
                }
                break;
            case BinString: // new Method
                {
                    aArgs.realloc(nAnzahl);
                    PropertyValue* pArg = aArgs.getArray();
                    for (sal_uInt16 i = 0 ; i < nAnzahl ; i++)
                        pCmdIn->Read( pArg[i] );
                }
                break;
        }
    }
}

// Constructor for UnoSlot
StatementSlot::StatementSlot()
: nAnzahl( 0 )
, pItemArr(NULL)
, nFunctionId( 0 )
, bMenuClosed(sal_False)
{}

StatementSlot::StatementSlot( sal_uLong nSlot, SfxPoolItem* pItem )
: pItemArr(NULL)
, bMenuClosed(sal_False)
{
    QueStatement( NULL );
    nFunctionId = sal_uInt16(nSlot);
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Reading Slot: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
    m_pDbgWin->AddText( "\n" );
#endif
    if ( pItem )
    {
        nAnzahl = 2;
        pItemArr = new SfxPoolItem*[2];
        pItemArr[0] = pItem;
        pItemArr[1] = NULL;
    }
    else
        nAnzahl = 0;
}

StatementSlot::~StatementSlot()
{
    if (nAnzahl)
    {
        if ( pItemArr )
        {
            for (sal_uInt16 i = 0 ; i+1 < nAnzahl ; i++)
                delete pItemArr[i];
            delete[] pItemArr;
        }

        aArgs.realloc( 0 );
    }
}

void StatementSlot::AddReferer()
{
    HACK( "only to test!" );
// because slot 6102 /*SID_VERB_START*/ crashes when called with Property Referer
// We return to the previous behavior (which was a bug really) of not adding this Property to calls which have no properties at all
// according to MBA most likely this Property can be removed at all and is maybe only needed for Slots with URLs
    if ( !nAnzahl )
        return;

    PropertyValue* pArg;

    nAnzahl++;
    aArgs.realloc(nAnzahl);
    pArg = aArgs.getArray();
    pArg[nAnzahl-1].Name = rtl::OUString::createFromAscii("Referer");
    pArg[nAnzahl-1].Value <<= ::rtl::OUString::createFromAscii("private:user");

    nAnzahl++;
    aArgs.realloc(nAnzahl);
    pArg = aArgs.getArray();
    pArg[nAnzahl-1].Name = rtl::OUString::createFromAscii("SynchronMode");
    pArg[nAnzahl-1].Value <<= sal_Bool( sal_True );
}

class SlotStatusListener : public cppu::WeakImplHelper1< XStatusListener >
{
public:
    SlotStatusListener();

    // XStatusListener
    virtual void SAL_CALL statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) throw (::com::sun::star::uno::RuntimeException);
    // XEventListener
    virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (::com::sun::star::uno::RuntimeException);

    // local Members
    sal_Bool bDisposed;
    sal_Bool bEnabled;
};
/*
struct FeatureStateEvent : public ::com::sun::star::lang::EventObject
    ::com::sun::star::util::URL FeatureURL;
    ::rtl::OUString FeatureDescriptor;
    sal_Bool IsEnabled;
    sal_Bool Requery;
    ::com::sun::star::uno::Any State;

    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > Source;
*/

SlotStatusListener::SlotStatusListener()
: bDisposed( sal_False )
, bEnabled( sal_True )
{}

// XStatusListener
void SAL_CALL SlotStatusListener::statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
{
//    DBG_ERROR1("FeatureURL: %s", ByteString( String( Event.FeatureURL.Complete ), RTL_TEXTENCODING_UTF8 ).GetBuffer() );
//    DBG_ERROR1("FeatureDescriptor: %s", ByteString( String( Event.FeatureDescriptor ), RTL_TEXTENCODING_UTF8 ).GetBuffer() );
    bEnabled = Event.IsEnabled;
//    DBG_ASSERT( Event.IsEnabled, "Not enabled" );
//    DBG_ASSERT( !Event.Requery, "Requery" );
}

// XEventListener
void SAL_CALL SlotStatusListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException)
{
    bDisposed = sal_True;
}

sal_Bool StatementSlot::Execute()
{
    if ( IsError )
    {
        #if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "Skipping Slot: " );
        m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
        m_pDbgWin->AddText( "\n" );
        #endif

        Advance();
        delete this;
        return sal_True;
    }

    InitProfile();
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Executing Slot: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
    m_pDbgWin->AddText( "\n" );
#endif

    PopupMenu *pPopup = NULL;
    MenuBar *pMenuBar = NULL;
    Menu *pMenu;

    GetCurrentMenues( pPopup, pMenuBar, pMenu );
    if ( pPopup )
    {
        if ( !bMenuClosed )
        {
            pPopup->EndExecute(0);
            aSubMenuId1 = 0;
            aSubMenuId2 = 0;
            aSubMenuId3 = 0;
            pMenuWindow = NULL;
            bMenuClosed = sal_True;
#if OSL_DEBUG_LEVEL > 1
            m_pDbgWin->AddText( "Closed contextmenu\n" );
#endif
            return sal_False;
        }
        else if ( nRetryCount-- )
        {
#if OSL_DEBUG_LEVEL > 1
            m_pDbgWin->AddText( "Waiting for contextmenu to close\n" );
#endif
            return sal_False;
        }
        else
            ReportError( GEN_RES_STR0( S_MENU_NOT_CLOSING ) );
    }

    Advance();

    if ( !IsError )
    {
        if ( ( nAnzahl == 0 && !getenv("OLDSLOTHANDLING") ) || aArgs.hasElements() )
        {   // trying to call slots via uno
            AddReferer();
            if ( !aUnoUrl.Len() )
                aUnoUrl = CUniString("slot:").Append( String::CreateFromInt32( nFunctionId ) );
            ::com::sun::star::util::URL aTargetURL;
            aTargetURL.Complete = aUnoUrl;
            Reference < XFramesSupplier > xDesktop = Reference < XFramesSupplier >( ::comphelper::getProcessServiceFactory()->createInstance( CUniString("com.sun.star.frame.Desktop") ), UNO_QUERY );
            Reference < XFrame > xFrame;

            if ( xDesktop.is() )
            {
                xFrame = xDesktop->getActiveFrame();
                if ( !xFrame.is() )
                {
                    Reference < XFrames > xFrames;
                    xFrames = xDesktop->getFrames();
                    if ( xFrames.is() && xFrames->getCount() > 0 )
                    {
                        Any aFrame = xFrames->getByIndex( xFrames->getCount() -1 );
                        aFrame >>= xFrame;
                    }
                }
                if ( !xFrame.is() )
                {
                    if ( GetFirstDocFrame() )
                        GetFirstDocFrame()->ToTop();
                    xFrame = xDesktop->getActiveFrame();
                }
            }

            if ( xFrame.is() )
                xDesktop = Reference < XFramesSupplier >( xFrame, UNO_QUERY );
            else
                xDesktop.clear();

            while ( xDesktop.is() && xDesktop->getActiveFrame().is() )
            {
                xFrame = xDesktop->getActiveFrame();
#if OSL_DEBUG_LEVEL > 1
                ::rtl::OUString aName;
                if ( xFrame.is() )
                    aName = xFrame->getName();
#endif
                xDesktop = Reference < XFramesSupplier >( xFrame, UNO_QUERY );
            }

            if ( !xFrame.is() )
                ReportError( GEN_RES_STR1( S_UNO_URL_EXECUTE_FAILED_NO_FRAME, aTargetURL.Complete ) );
            else
            {
                Reference < ::com::sun::star::util::XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( CUniString("com.sun.star.util.URLTransformer" )), UNO_QUERY );
                xTrans->parseStrict( aTargetURL );

                Reference < XDispatchProvider > xProv( xFrame, UNO_QUERY );
                Reference < XDispatch > xDisp;
                while ( xProv.is() && !xDisp.is() )
                {
                    xDisp = xProv->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
                    if ( !xDisp.is() )
                    {
                        xFrame = Reference < XFrame > ( xFrame->getCreator(), UNO_QUERY );
                        xProv = Reference < XDispatchProvider > ( xFrame, UNO_QUERY );
                    }
                }

                if ( xDisp.is() )
                {
                    Reference < XStatusListener > xListener = ( XStatusListener* )new SlotStatusListener;
                    xDisp->addStatusListener( xListener, aTargetURL );
                    if ( static_cast< SlotStatusListener* >(xListener.get())->bEnabled )
                    {
                        if ( bIsSlotInExecute )
                            ReportError( GEN_RES_STR0( S_SLOT_IN_EXECUTE ) );
                        else
                        {
                            bIsSlotInExecute = sal_True;
                            xDisp->dispatch( aTargetURL, aArgs );
                            bIsSlotInExecute = sal_False;
                        }
                    }
                    else
                        ReportError( GEN_RES_STR1( S_UNO_URL_EXECUTE_FAILED_DISABLED, aTargetURL.Complete ) );
                    xDisp->removeStatusListener( xListener, aTargetURL );
                }
                else
                    ReportError( GEN_RES_STR1( S_UNO_URL_EXECUTE_FAILED_NO_DISPATCHER, aTargetURL.Complete ) );
            }
        }
        else
        {
            DirectLog( S_QAError, GEN_RES_STR0( S_DEPRECATED ) );
            if ( !pTTProperties )
                pTTProperties = new TTProperties();

            switch ( pTTProperties->ExecuteFunction( nFunctionId, pItemArr, EXECUTEMODE_DIALOGASYNCHRON | nUseBindings ) )
            {
            case TT_PR_ERR_NODISPATCHER:
                {
                    ReportError( rtl::OString::valueOf((sal_Int32)nFunctionId), GEN_RES_STR0( S_SID_EXECUTE_FAILED_NO_DISPATCHER ) );
                }
                break;
            case TT_PR_ERR_NOEXECUTE:
                {
                    ReportError( rtl::OString::valueOf((sal_Int32)nFunctionId), GEN_RES_STR0( S_SID_EXECUTE_FAILED ) );
                }
                break;
            }
        }
    }


/*  New method from the line 334!
    New method for setting that modal dialogs are always called asynchronously
    and a real return value, whether slot has worked
    and testing whether slot can be called by UI at all       */


    SendProfile( SlotString( nFunctionId ) );
    delete this;
    return sal_True;
}

// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

StatementUnoSlot::StatementUnoSlot(SCmdStream *pIn)
{
    QueStatement( NULL );

    pIn->Read( aUnoUrl );

#if OSL_DEBUG_LEVEL > 1
    StatementList::m_pDbgWin->AddText( "UnoUrl:" );
    StatementList::m_pDbgWin->AddText( aUnoUrl );
    StatementList::m_pDbgWin->AddText( "\n" );
#endif

}

// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

StatementCommand::StatementCommand( StatementList *pAfterThis, sal_uInt16 MethodId, sal_uInt16 Params, sal_uInt16 Nr1 )
: nMethodId( MethodId )
, nParams(Params)
, nNr1(Nr1)
, nNr2(0)
, nNr3(0)
, nNr4(0)
, nLNr1(0)
, aString1()
, aString2()
, bBool1(sal_False)
, bBool2(sal_False)
{
    QueStatement( pAfterThis );

#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Directly adding Conmmand:" );
    m_pDbgWin->AddText( " Methode: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
    m_pDbgWin->AddText( " Params:" );
    if( nParams & PARAM_USHORT_1 )  {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
    if( nParams & PARAM_USHORT_2 )  {m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
    if( nParams & PARAM_USHORT_3 )  {m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
    if( nParams & PARAM_USHORT_4 )  {m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
    if( nParams & PARAM_ULONG_1 )   {m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
    if( nParams & PARAM_STR_1 )     {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
    if( nParams & PARAM_STR_2 )     {m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
    if( nParams & PARAM_BOOL_1 )    {m_pDbgWin->AddText( " b1:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
    if( nParams & PARAM_BOOL_2 )    {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool2 ? "TRUE" : "FALSE" );}
    m_pDbgWin->AddText( "\n" );
#endif
}


StatementCommand::StatementCommand( SCmdStream *pCmdIn )
: nMethodId(0)
, nParams(0)
, nNr1(0)
, nNr2(0)
, nNr3(0)
, nNr4(0)
, nLNr1(0)
, aString1()
, aString2()
, bBool1(sal_False)
, bBool2(sal_False)
{
    QueStatement( NULL );
    pCmdIn->Read( nMethodId );
    pCmdIn->Read( nParams );

    if( nParams & PARAM_USHORT_1 )  pCmdIn->Read( nNr1 );
    if( nParams & PARAM_USHORT_2 )  pCmdIn->Read( nNr2 );
    if( nParams & PARAM_USHORT_3 )  pCmdIn->Read( nNr3 );
    if( nParams & PARAM_USHORT_4 )  pCmdIn->Read( nNr4 );
    if( nParams & PARAM_ULONG_1 )   pCmdIn->Read( nLNr1 );
    if( nParams & PARAM_STR_1 )     pCmdIn->Read( aString1 );
    if( nParams & PARAM_STR_2 )     pCmdIn->Read( aString2 );
    if( nParams & PARAM_BOOL_1 )    pCmdIn->Read( bBool1 );
    if( nParams & PARAM_BOOL_2 )    pCmdIn->Read( bBool2 );

#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Reading Conmmand:" );
    m_pDbgWin->AddText( " Methode: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
    m_pDbgWin->AddText( " Params:" );
    if( nParams & PARAM_USHORT_1 )  {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
    if( nParams & PARAM_USHORT_2 )  {m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
    if( nParams & PARAM_USHORT_3 )  {m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
    if( nParams & PARAM_USHORT_4 )  {m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
    if( nParams & PARAM_ULONG_1 )   {m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
    if( nParams & PARAM_STR_1 )     {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
    if( nParams & PARAM_STR_2 )     {m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
    if( nParams & PARAM_BOOL_1 )    {m_pDbgWin->AddText( " b1:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
    if( nParams & PARAM_BOOL_2 )    {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool2 ? "TRUE" : "FALSE" );}
    m_pDbgWin->AddText( "\n" );
#endif

    if ( nMethodId == RC_AppAbort )
    {
        #if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "*Deleting all Commands:\n" );
        #endif
        bReadingCommands = sal_False;
        while ( StatementList::pFirst != this ) // Delete everything except myself
        {
            StatementList *pDeQue = StatementList::pFirst;
            pDeQue->Advance();
            delete pDeQue;
        }
        bReadingCommands = sal_True;
        #if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "*Done deleting all Commands:\n" );
        #endif
    }

}

void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Bool bFirst )
{

    if ( IsDialog(pBase) && !bFirst )
        return;

    if ( bFirst )
        pRet->GenReturn ( RET_WinInfo, rtl::OString(), (comm_ULONG)nConf | DH_MODE_DATA_VALID, UniString(), sal_True );

    if ( bFirst )
    {
        if ( pBase->GetType() == WINDOW_WINDOW && pBase->GetParent() && pBase->GetParent()->GetType() == WINDOW_CONTROL &&
            dynamic_cast< svt::table::TableControl* > ( pBase->GetParent() ) )
            pBase = pBase->GetParent();
    }

    {   // KParentheses, so that the string does not persist during recursion.
        String aName;
        sal_Bool bSkip = sal_False;

        switch ( pBase->GetType() )
        {
            case WINDOW_RADIOBUTTON:
            case WINDOW_CHECKBOX:
            case WINDOW_TRISTATEBOX:
            case WINDOW_PUSHBUTTON:
            case WINDOW_OKBUTTON:
            case WINDOW_CANCELBUTTON:
            case WINDOW_IMAGERADIOBUTTON:
            case WINDOW_IMAGEBUTTON:
            case WINDOW_MENUBUTTON:
            case WINDOW_MOREBUTTON:
            case WINDOW_TABPAGE:
            case WINDOW_MODALDIALOG:
            case WINDOW_FLOATINGWINDOW:
            case WINDOW_MODELESSDIALOG:
            case WINDOW_WORKWINDOW:
            case WINDOW_DOCKINGWINDOW:
            case WINDOW_CONTROL:

            case WINDOW_FILEDIALOG:
            case WINDOW_PATHDIALOG:
            case WINDOW_PRINTDIALOG:
            case WINDOW_PRINTERSETUPDIALOG:
            case WINDOW_COLORDIALOG:
            case WINDOW_TABDIALOG:

            case WINDOW_BUTTONDIALOG:

            case WINDOW_MENUBARWINDOW:
                aName = pBase->GetText().EraseAllChars('~');
                break;

            case WINDOW_EDIT:
            case WINDOW_MULTILINEEDIT:
            case WINDOW_MULTILISTBOX:
            case WINDOW_LISTBOX:
            case WINDOW_COMBOBOX:
            case WINDOW_SPINFIELD:
            case WINDOW_PATTERNFIELD:
            case WINDOW_NUMERICFIELD:
            case WINDOW_METRICFIELD:
            case WINDOW_CURRENCYFIELD:
            case WINDOW_DATEFIELD:
            case WINDOW_TIMEFIELD:
            case WINDOW_NUMERICBOX:
            case WINDOW_METRICBOX:
            case WINDOW_CURRENCYBOX:
            case WINDOW_DATEBOX:
            case WINDOW_TIMEBOX:
            case WINDOW_PATTERNBOX:
            case WINDOW_TOOLBOX:
                aName = pBase->GetQuickHelpText();
                break;

            case WINDOW_MESSBOX:
            case WINDOW_INFOBOX:
            case WINDOW_WARNINGBOX:
            case WINDOW_ERRORBOX:
            case WINDOW_QUERYBOX:
                aName = ((MessBox*)pBase)->GetMessText();
                break;

            default:
                if ( pBase->GetUniqueOrHelpId().isEmpty() && !( nConf & DH_MODE_ALLWIN ) )
                    bSkip = sal_True;
                break;
        }

        if ( !bSkip )
        {
            if ( aName.Len() == 0 )
                aName = pBase->GetQuickHelpText();
            if ( aName.Len() == 0 )
                aName = pBase->GetHelpText();
            if ( aName.Len() == 0 )
                aName = pBase->GetText();


            String aTypeSuffix;
            if ( pBase->GetType() == WINDOW_CONTROL )
            {
                if ( dynamic_cast< EditBrowseBox* >(pBase) )
                    aTypeSuffix.AppendAscii( "/BrowseBox", 10 );
                else if ( dynamic_cast< ValueSet* >(pBase) )
                    aTypeSuffix.AppendAscii( "/ValueSet", 9 );
                else if ( dynamic_cast< ORoadmap* >(pBase) )
                    aTypeSuffix.AppendAscii( "/RoadMap", 8 );
                else if ( dynamic_cast< IExtensionListBox* >(pBase) )
                    aTypeSuffix.AppendAscii( "/ExtensionListBox" );
                else if ( dynamic_cast< svt::table::TableControl* >(pBase) )
                    aTypeSuffix.AppendAscii( "/TableControl" );
                else
                    aTypeSuffix.AppendAscii( "/Unknown", 8 );
            }

            rtl::OString aId = pBase->GetUniqueOrHelpId();
            pRet->GenReturn ( RET_WinInfo, aId, (comm_ULONG)pBase->GetType(),
                TypeString(pBase->GetType()).Append(aTypeSuffix).AppendAscii(": ").Append(aName), sal_False );


            if ( pBase->GetType() == WINDOW_TOOLBOX )   // Buttons and Controls in Toolboxes.
            {
                ToolBox *pTB = ((ToolBox*)pBase);
                sal_uInt16 i;
                for ( i = 0; i < pTB->GetItemCount() ; i++ )
                {
                    aName = String();
//                  if ( aName.Len() == 0 )
//                      aName = pTB->GetQuickHelpText();
                    if ( aName.Len() == 0 )
                        aName = pTB->GetHelpText( pTB->GetItemId( i ) );
                    if ( aName.Len() == 0 )
                        aName = pTB->GetItemText( pTB->GetItemId( i ) );

                    Window *pItemWin;
                    pItemWin = pTB->GetItemWindow( pTB->GetItemId( i ) );
                    if ( pTB->GetItemType( i ) == TOOLBOXITEM_BUTTON && ( !pItemWin || !pItemWin->IsVisible() ) )
                    {
                        if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
                            pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_ULONG)WINDOW_BUTTON,
                                TypeString(WINDOW_BUTTON).AppendAscii(": ").Append(aName), sal_False );
                        if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
                            pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)WINDOW_BUTTON,
                                TypeString(WINDOW_BUTTON).AppendAscii(": ").Append(aName), sal_False );
                    }
                    else
                    {
                        if ( pItemWin )
                        {
                            if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
                                pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_ULONG)pItemWin->GetType(),
                                    TypeString(pItemWin->GetType()).AppendAscii(": ").Append(aName), sal_False );
                            if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
                                pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)pItemWin->GetType(),
                                    TypeString(pItemWin->GetType()).AppendAscii(": ").Append(aName), sal_False );
                            sal_uInt16 ii;
                            for( ii = 0 ; ii < pItemWin->GetChildCount(); ii++ )
                                WriteControlData( pItemWin->GetChild(ii), nConf, sal_False );
                        }
                        else
                        {
                            if ( nConf & DH_MODE_ALLWIN )
                            {
                                String aToolBoxItemType;
                                switch ( pTB->GetItemType( i ) )
                                {
                                case TOOLBOXITEM_DONTKNOW:
                                    aToolBoxItemType.AssignAscii("TOOLBOXITEM_DONTKNOW");
                                    break;
                                case TOOLBOXITEM_BUTTON:
                                    aToolBoxItemType.AssignAscii("TOOLBOXITEM_BUTTON");
                                    break;
                                case TOOLBOXITEM_SPACE:
                                    aToolBoxItemType.AssignAscii("TOOLBOXITEM_SPACE");
                                    break;
                                case TOOLBOXITEM_SEPARATOR:
                                    aToolBoxItemType.AssignAscii("TOOLBOXITEM_SEPARATOR");
                                    break;
                                case TOOLBOXITEM_BREAK:
                                    aToolBoxItemType.AssignAscii("TOOLBOXITEM_BREAK");
                                    break;
                                default:
                                    DBG_ERROR1( "Unknown TOOLBOXITEM %i", pTB->GetItemType( i ) );
                                }
                                if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
                                    pRet->GenReturn ( RET_WinInfo, Str2Id( pTB->GetItemCommand(pTB->GetItemId( i )) ), (comm_ULONG)WINDOW_BASE,
                                        aToolBoxItemType.AppendAscii(": ").Append(aName), sal_False );
                                if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
                                    pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)WINDOW_BASE,
                                        aToolBoxItemType.AppendAscii(": ").Append(aName), sal_False );
                            }
                        }
                    }
                }

                return; // ToolBox is already completely covered here..
            }


            if ( pBase->GetType() == WINDOW_BUTTONDIALOG    // Buttons on button dialogs with ID
                || pBase->GetType() == WINDOW_MESSBOX
                || pBase->GetType() == WINDOW_INFOBOX
                || pBase->GetType() == WINDOW_WARNINGBOX
                || pBase->GetType() == WINDOW_ERRORBOX
                || pBase->GetType() == WINDOW_QUERYBOX )
            {
                ButtonDialog *pBD = ((ButtonDialog*)pBase);
                sal_uInt16 i;
                for ( i = 0; i < pBD->GetButtonCount() ; i++ )
                {
                    aName = String();
                    if ( aName.Len() == 0 )
                        aName = pBD->GetPushButton( pBD->GetButtonId(i) )->GetText();
                    ByteString aID;
                    switch ( pBD->GetButtonId(i) )
                    {
                        case BUTTONID_OK:
                            aID.Assign("Ok");
                            break;
                        case BUTTONID_CANCEL:
                            aID.Assign("Cancel");
                            break;
                        case BUTTONID_YES:
                            aID.Assign("Yes");
                            break;
                        case BUTTONID_NO:
                            aID.Assign("No");
                            break;
                        case BUTTONID_RETRY:
                            aID.Assign("Retry");
                            break;
                        case BUTTONID_HELP:
                            aID.Assign("Help");
                            break;
                        default:
                            aID = ByteString::CreateFromInt32( pBD->GetButtonId(i) );
                            break;
                    }

                    pRet->GenReturn ( RET_WinInfo, aID, (comm_ULONG)pBD->GetPushButton( pBD->GetButtonId(i) )->GetType(),   // so the text is displayed!
                        TypeString(pBD->GetPushButton( pBD->GetButtonId(i) )->GetType()).AppendAscii(": ").Append(aName)
                        .AppendAscii(" ButtonId = ").AppendAscii( aID.GetBuffer() ), sal_False );
                }

                return; // ButtonDialog is already completely covered here.
            }


            Menu* pMenu = GetMatchingMenu( pBase );

            if ( pMenu )    // Menus
            {
                sal_uInt16 i;
                for ( i = 0; i < pMenu->GetItemCount() ; i++ )
                {
                    sal_uInt16 nID = pMenu->GetItemId( i );

                    aName = String();
                    if ( aName.Len() == 0 )
                        aName = pMenu->GetHelpText( nID );
                    if ( aName.Len() == 0 )
                        aName = pMenu->GetItemText( nID );


                    if ( pMenu->GetItemType( i ) == MENUITEM_STRING || pMenu->GetItemType( i ) == MENUITEM_IMAGE || pMenu->GetItemType( i ) == MENUITEM_STRINGIMAGE || (nConf & DH_MODE_ALLWIN) )
                    {
                        String aMenuItemType;
                        switch ( pMenu->GetItemType( i ) )
                        {
                        case MENUITEM_STRING:
                            aMenuItemType.AssignAscii("MENUITEM_STRING");
                            break;
                        case MENUITEM_STRINGIMAGE:
                            aMenuItemType.AssignAscii("MENUITEM_STRINGIMAGE");
                            break;
                        case MENUITEM_IMAGE:
                            aMenuItemType.AssignAscii("MENUITEM_IMAGE");
                            break;
                        case MENUITEM_SEPARATOR:
                            aMenuItemType.AssignAscii("MENUITEM_SEPARATOR");
                            break;
                        case MENUITEM_DONTKNOW:
                            aMenuItemType.AssignAscii("MENUITEM_DONTKNOW");
                            break;
                        default:
                            DBG_ERROR1( "Unknown MENUITEM %i", pMenu->GetItemType( i ) );
                        }
                        if ( pMenu->GetItemCommand(nID).Len() || ( nConf & DH_MODE_ALLWIN ) )
                            pRet->GenReturn ( RET_WinInfo, Str2Id( pMenu->GetItemCommand(nID) ), (comm_ULONG)0,
                                aMenuItemType.AppendAscii(": ").Append(aName), sal_False );
                        if ( !pMenu->GetItemCommand(nID).Len() || ( nConf & DH_MODE_ALLWIN ) )
                            pRet->GenReturn ( RET_WinInfo, rtl::OString::valueOf( (sal_Int32)nID ), (comm_ULONG)0,
                                aMenuItemType.AppendAscii(": ").Append(aName), sal_False );
                    }
                }

                return; // Menu is already completely covered here
            }
        }
    }

    for( sal_uInt16 i = 0 ; i < pBase->GetChildCount(); i++ )
        WriteControlData( pBase->GetChild(i), nConf, sal_False );
}

class SysWinContainer : public WorkWindow
{
private:
    ToolBox *pClientWin;
    DockingWindow *pDock;
public:
    SysWinContainer( ToolBox *pClient );
    ~SysWinContainer();
    virtual void    Resize();
    virtual void    Resizing( Size& rSize );
};

SysWinContainer::SysWinContainer( ToolBox *pClient )
: WorkWindow( NULL, WB_BORDER | WB_SIZEMOVE | WB_CLOSEABLE )
, pClientWin( pClient )
{
    pDock = new DockingWindow( this );
    pClientWin->SetParent( pDock );
    pClientWin->SetFloatingMode( sal_False );
    SetText( pClient->GetText() );
    SetPosPixel( Point( 1,40 ) );
    Resize();
    pDock->Show();
    EnableAlwaysOnTop();
    Show();
}

SysWinContainer::~SysWinContainer()
{
    delete pDock;
}

void SysWinContainer::Resize()
{
    Size aSize( GetOutputSizePixel() );
    Resizing( aSize );
//  aSize = pClientWin->GetSizePixel();
//  aSize = pClientWin->CalcWindowSizePixel();
    if ( aSize != GetSizePixel() )
    {
        SetOutputSizePixel( aSize );
        pDock->SetSizePixel( aSize );
        pClientWin->SetSizePixel( aSize );
    }
}

void SysWinContainer::Resizing( Size& rSize )
{
    Size aSize;
    Size aBestSize;
    sal_uInt16 i;
    sal_Bool bHasValue = sal_False;
    sal_uLong nBestValue = 0;
    sal_uLong nThisValue;
    for ( i=1 ; i<=1 ; i++ )
    {
        aSize = pClientWin->CalcWindowSizePixel( i );
        nThisValue = Abs( aSize.Width() - rSize.Width() ) + Abs( aSize.Height() - rSize.Height() );
        if ( !bHasValue || ( nThisValue < nBestValue ) )
        {
            nBestValue = nThisValue;
            aBestSize = aSize;
            bHasValue = sal_True;
        }
    }
    rSize = aBestSize;
}

class DisplayHidWin : public ToolBox
{
    Edit    *pEdit;
    Size    aMinEditSize;
    sal_uInt16  nLastItemID;
    sal_Bool bIsDraging;
    sal_Bool bIsPermanentDraging;
    void SetDraging( sal_Bool bNewDraging );
    Image *pShow, *pShow2;
    sal_Bool bConfigChanged;
    void EnableButtons( sal_uLong nConf );

    sal_uLong nEventHookID;
    static long stub_VCLEventHookProc( NotifyEvent& rEvt, void* pData )
    {
        return ((DisplayHidWin*)pData)->VCLEventHook( rEvt );
    }

    long VCLEventHook( NotifyEvent& rEvt );
    Window *pLastMouseMoveWin;

    SysWinContainer *pContainer;

    // aborting by pressing shift twice
    sal_Bool bOldShift;
    Time aLatest;
    sal_uInt16 nShiftCount;

public:
    DisplayHidWin();
    ~DisplayHidWin();

    virtual void    Tracking( const TrackingEvent& rTEvt );
    virtual void    Click();
    virtual void    Select();
    virtual void    SetText( const XubString& rStr );

    void SetDisplayText( const String &aNewText ){ pEdit->SetText(aNewText); }
    String GetDisplayText() const { return pEdit->GetText(); }
    sal_Bool IsDisplayTextModified() const { return pEdit->IsModified(); }
    void ClearDisplayTextModified() const { pEdit->ClearModifyFlag(); }

    void SetConfig( sal_uLong nConf );
    sal_uLong GetConfig();

    sal_Bool IsConfigChanged() { return bConfigChanged; }
    void ConfigSent() { bConfigChanged = sal_False; }

    sal_Bool IsSendData() { return GetItemState( TT_SEND_DATA ) == STATE_CHECK; }
//  sal_Bool IsAllWin() { return GetItemState( TT_ALLWIN ) == STATE_CHECK; }

    sal_Bool IsDraging() { return bIsDraging; }

    Window* LastMouseMoveWin() { return pLastMouseMoveWin; }
};

DisplayHidWin::DisplayHidWin()
: ToolBox( StatementList::GetFirstDocFrame(), TTProperties::GetSvtResId(DisplayHidToolBox) )
, bIsDraging( sal_False )
, bIsPermanentDraging( sal_False )
, pShow( NULL )
, pShow2( NULL )
, pLastMouseMoveWin( NULL )
, bOldShift( 0 )
, nShiftCount( 0 )
{
    SetOutStyle( TOOLBOX_STYLE_HANDPOINTER | TOOLBOX_STYLE_FLAT );
    pEdit = new Edit( this, WB_CENTER | WB_BORDER );
    aMinEditSize = GetItemRect( TT_OUTPUT ).GetSize();
/**/    aMinEditSize=Size(20,20);
    aMinEditSize.Width() *= 12;
    pEdit->SetSizePixel( aMinEditSize );
    pEdit->Show();
    SetItemWindow( TT_OUTPUT, pEdit );
    Resize();
    pContainer = new SysWinContainer( this );
    nEventHookID = Application::AddEventHook( stub_VCLEventHookProc, this );
}

DisplayHidWin::~DisplayHidWin()
{
    Application::RemoveEventHook( nEventHookID );
    Hide(); // so GetFirstDocFrame won't return ourselves (needed for SOPlayer)
    SetParent( StatementList::GetFirstDocFrame() );
    delete pContainer;
    delete pEdit;
}

void DisplayHidWin::SetDraging( sal_Bool bNewDraging )
{
    if ( !pShow )
        pShow = new Image( GetItemImage( TT_SHOW ) );
    if ( !pShow2 )
        pShow2 = new Image( Bitmap( TTProperties::GetSvtResId( TT_SHOW2 ) ) );

    if ( bNewDraging )
        SetItemImage( TT_SHOW, *pShow2 );
    else
        SetItemImage( TT_SHOW, *pShow );

    bIsDraging = bNewDraging;
}

void DisplayHidWin::EnableButtons( sal_uLong nConf )
{
    sal_Bool bSend = sal_Bool(nConf & DH_MODE_SEND_DATA);
    EnableItem( TT_ALLWIN, bSend );
    EnableItem( TT_KURZNAME, bSend );
    EnableItem( TT_LANGNAME, bSend );
}

void DisplayHidWin::Tracking( const TrackingEvent& rTEvt )
{
//  if ( nLastItemID == TT_SHOW && GetItemState( TT_SHOW ) == STATE_NOCHECK && ( rTEvt.IsTrackingEnded() || rTEvt.IsTrackingCanceled() ) )
//      SetDraging( sal_False );
    if ( nLastItemID == TT_SHOW && GetItemState( TT_SHOW ) == STATE_NOCHECK )
        EndTracking( ENDTRACK_CANCEL );
    ToolBox::Tracking( rTEvt);
}

void DisplayHidWin::Click()
{
    nLastItemID = GetCurItemId();
    if ( nLastItemID == TT_SHOW )
    {
        SetDraging( sal_True );
    }
    ToolBox::Click();
}

void DisplayHidWin::Select()
{
    if ( GetItemState( GetCurItemId() ) == STATE_NOCHECK )
    {
        SetItemState( GetCurItemId(), STATE_CHECK );
        if ( GetCurItemId() == TT_SHOW )
        {
            bIsPermanentDraging = sal_True;
            SetDraging( sal_True );
        }
    }
    else
    {
        SetItemState( GetCurItemId(), STATE_NOCHECK );
        if ( GetCurItemId() == TT_SHOW )
        {
            bIsPermanentDraging = sal_False;
            SetDraging( sal_False );
        }
    }
    if ( GetCurItemId() == TT_SEND_DATA )
    {
        EnableButtons( GetConfig() );
    }
}

void DisplayHidWin::SetConfig( sal_uLong nConf )
{
    SetItemState( TT_KURZNAME,  ( nConf & DH_MODE_KURZNAME )  ? STATE_CHECK : STATE_NOCHECK );
    SetItemState( TT_LANGNAME,  ( nConf & DH_MODE_LANGNAME )  ? STATE_CHECK : STATE_NOCHECK );
    SetItemState( TT_ALLWIN,    ( nConf & DH_MODE_ALLWIN )    ? STATE_CHECK : STATE_NOCHECK );
    SetItemState( TT_SEND_DATA, ( nConf & DH_MODE_SEND_DATA ) ? STATE_CHECK : STATE_NOCHECK );
    EnableButtons( nConf );
}

sal_uLong DisplayHidWin::GetConfig()
{
    sal_uLong nConf = 0;
    if ( GetItemState( TT_KURZNAME ) == STATE_CHECK )
        nConf |= DH_MODE_KURZNAME;
    if ( GetItemState( TT_LANGNAME ) == STATE_CHECK )
        nConf |= DH_MODE_LANGNAME;
    if ( GetItemState( TT_ALLWIN ) == STATE_CHECK )
        nConf |= DH_MODE_ALLWIN;
    if ( IsSendData() )
        nConf |= DH_MODE_SEND_DATA;

    return nConf;
}

void DisplayHidWin::SetText( const XubString& rStr )
{
    pContainer->SetText( rStr );
}

long DisplayHidWin::VCLEventHook( NotifyEvent& rEvt )
{
    if ( EVENT_MOUSEMOVE == rEvt.GetType() )
    {
        pLastMouseMoveWin = rEvt.GetWindow();

        // check if abort with pressing shift twice
        MouseEvent* pMEvt = (MouseEvent*)rEvt.GetMouseEvent();

        if ( ( pMEvt->IsShift() && !bOldShift ) ) // Shift pressed
        {
            if ( aLatest < Time() )
            {
                nShiftCount = 0;
                aLatest = Time()+Time( 0, 0, 0, 50 );
            }
            nShiftCount++;
        }
        if ( ( !pMEvt->IsShift() && bOldShift ) ) // Shift released
        {
            nShiftCount++;
            if ( nShiftCount == 4 && aLatest > Time() )
            {
                bIsPermanentDraging = sal_False;
                SetDraging( sal_False );
                SetItemState( TT_SHOW, STATE_NOCHECK );
            }
        }
        bOldShift = pMEvt->IsShift();
    }
    if ( ( ( EVENT_MOUSEBUTTONUP == rEvt.GetType() && rEvt.GetMouseEvent()->GetButtons() == MOUSE_LEFT) || ( EVENT_MOUSEMOVE == rEvt.GetType() && !rEvt.GetMouseEvent()->GetButtons() ) )
            && IsDraging() && !bIsPermanentDraging )
        SetDraging( sal_False );
    return 0;
}


sal_Bool StatementCommand::DisplayHID()
{
    // Return sal_True -> reexecute command

    if ( !bBool2 )  // Wird auf sal_False initialisiert
    {
        bBool2 = sal_True;              // Wir sind initialisiert.
        GetTTSettings()->pDisplayInstance = this;   // Und haben die Macht (Alle anderen beenden sich)

        if ( !(nParams & PARAM_ULONG_1) )
        {
            if( GetTTSettings()->pDisplayHidWin )   // Nichts verändern
                nLNr1 = GetTTSettings()->pDisplayHidWin->GetConfig();
            else    // Beim ersten Aufruf wollen wir alles richtig einstellen
                nLNr1 = DH_MODE_KURZNAME | DH_MODE_LANGNAME;

            if( ((nParams & PARAM_BOOL_1) && bBool1) )
                nLNr1 |= DH_MODE_SEND_DATA;
            else
                nLNr1 &= ( ~DH_MODE_SEND_DATA );
        }

        if ( GetTTSettings()->pDisplayHidWin )
            GetTTSettings()->pDisplayHidWin->SetConfig( nLNr1 );
    }

    if ( GetTTSettings()->pDisplayInstance && GetTTSettings()->pDisplayInstance != this )
    {
        DBG_WARNING("Mehrere DisplayHID am laufen");
        return sal_False;       // Noch eine andere Instanz macht das gleiche!
    }

    if ( !GetTTSettings()->pDisplayHidWin )
    {
        GetTTSettings()->pDisplayHidWin = new DisplayHidWin();
        GetTTSettings()->aOriginalCaption = GetTTSettings()->pDisplayHidWin->GetText();
        GetTTSettings()->pDisplayHidWin->Show();
        if ( bBool1 )
            nLNr1 |= DH_MODE_SEND_DATA;
        GetTTSettings()->pDisplayHidWin->SetConfig( nLNr1 );

        GetTTSettings()->Old = NULL;
        GetTTSettings()->Act = NULL;
        GetTTSettings()->pDisplayInstance = this;
    }
    else
    {
        GetTTSettings()->pDisplayHidWin->GetWindow( WINDOW_OVERLAP )->Enable( sal_True, sal_True );
        GetTTSettings()->pDisplayHidWin->GetWindow( WINDOW_OVERLAP )->EnableInput( sal_True, sal_True );
    }


    if ( GetTTSettings()->pDisplayHidWin->IsVisible() && !bDying )
    {

        if ( GetTTSettings()->pDisplayHidWin->IsDraging() )
        {


#define HIGHLIGHT_WIN( WinPtr )                                     \
        {                                                           \
            Color aLineColMem = WinPtr->GetLineColor();             \
            WinPtr->SetLineColor( Color( COL_WHITE ) );             \
            Color aFillColMem = WinPtr->GetFillColor();             \
            WinPtr->SetFillColor( Color( COL_LIGHTRED ) );          \
            RasterOp aROp = WinPtr->GetRasterOp();                  \
            WinPtr->SetRasterOp( ROP_XOR );                         \
            Size aSz = WinPtr->PixelToLogic( WinPtr->GetSizePixel() );\
            sal_uLong nMaxCornerRadius = WinPtr->PixelToLogic( Point( 80, 0 ) ).X();\
            sal_uLong iCorner = std::max ((sal_uLong) 8, (sal_uLong) std::min( nMaxCornerRadius, (sal_uLong) std::min((sal_uLong) (aSz.Width() / 6), (sal_uLong)(aSz.Height() / 6))));\
            WinPtr->DrawRect(Rectangle(Point(),aSz), iCorner, iCorner);\
            WinPtr->SetLineColor( aLineColMem );                    \
            WinPtr->SetFillColor( aFillColMem );                    \
            WinPtr->SetRasterOp( aROp );                            \
        }


#define SET_WIN( WinPtr )                                           \
            if ( StatementList::WinPtrValid(WinPtr) )   \
            {                                                       \
                HIGHLIGHT_WIN ( WinPtr );                           \
            }

#define RESET_WIN( WinPtr )                                         \
            if ( StatementList::WinPtrValid(WinPtr) )   \
            {                                                       \
                WinPtr->Invalidate( INVALIDATE_NOTRANSPARENT );     \
                WinPtr->Update();       \
            }


            GetTTSettings()->Old = GetTTSettings()->Act;
//          GetTTSettings()->Act = GetMouseWin();
            GetTTSettings()->Act = GetTTSettings()->pDisplayHidWin->LastMouseMoveWin();

            if ( !StatementList::WinPtrValid ( GetTTSettings()->Old ) )
                GetTTSettings()->Old = NULL;
            if ( !StatementList::WinPtrValid ( GetTTSettings()->Act ) )
                GetTTSettings()->Act = NULL;

            if ( GetTTSettings()->Act && GetTTSettings()->Act->GetType() == WINDOW_BORDERWINDOW )
                GetTTSettings()->Act = GetTTSettings()->Act->GetWindow( WINDOW_CLIENT );

            if ( GetTTSettings()->Act != GetTTSettings()->Old )
            {
                if ( GetTTSettings()->Old )
                {
                    RESET_WIN(GetTTSettings()->Old);
                }
                if ( GetTTSettings()->Act )
                {
                    SET_WIN(GetTTSettings()->Act);
                    GetTTSettings()->pDisplayHidWin->SetDisplayText( Id2Str(GetTTSettings()->Act->GetUniqueOrHelpId()).AppendAscii(" WinType: ")
                        .Append(UniString::CreateFromInt64(GetTTSettings()->Act->GetType())).AppendAscii("  ").Append(GetTTSettings()->Act->GetText()));
                    if ( GetTTSettings()->Act && !GetTTSettings()->Act->GetUniqueId().equals( GetTTSettings()->Act->GetHelpId() ) )
                        GetTTSettings()->pDisplayHidWin->SetText(UniString( TTProperties::GetSvtResId( TT_ALTERNATE_CAPTION ) ).AppendAscii(GetTTSettings()->Act->GetHelpId().getStr()));
                    else
                        GetTTSettings()->pDisplayHidWin->SetText( GetTTSettings()->aOriginalCaption );
                }
                else
                    GetTTSettings()->pDisplayHidWin->SetDisplayText(CUniString("Kein Window/Control gefunden"));
            }
            else if ( GetTTSettings()->Act )
            {
//              SET_WIN(GetTTSettings()->Act);
                // allow setting a HelpID manually (just enter the ID in the displayHID Window and terminate it by |
                if ( GetTTSettings()->pDisplayHidWin->IsDisplayTextModified() && GetTTSettings()->pDisplayHidWin->GetDisplayText().GetTokenCount( '|' ) > 1 )
                {
                    GetTTSettings()->Act->SetUniqueId( Str2Id( GetTTSettings()->pDisplayHidWin->GetDisplayText().GetToken( '|' ) ) );
                    GetTTSettings()->pDisplayHidWin->ClearDisplayTextModified();
                }
            }
/*          if ( Application::GetLastInputInterval() > 5000 )   // 5 Sekunden lang nichts geschehen
            {
                GetTTSettings()->pDisplayHidWin->ToTop( TOTOP_NOGRABFOCUS );
            }
*/
            if ( GetTTSettings()->pDisplayHidWin->IsSendData() /*&& bBool2*/ && GetTTSettings()->Act )
            {
                if ( !StatementFlow::bSending )
                {   // Normalerweise syncronisierung über Protokoll. Hier ist das aber asyncron!!!
                    WriteControlData( GetTTSettings()->Act, GetTTSettings()->pDisplayHidWin->GetConfig() );
                    new StatementFlow( this, F_EndCommandBlock );   // Kommando zum Senden erzeugen und in que eintragen
                }
            }
        }   //if ( GetTTSettings()->pDisplayHidWin->IsDraging() )
        else
        {
            if ( GetTTSettings()->Act )
            {
                RESET_WIN(GetTTSettings()->Act);
                GetTTSettings()->Act = NULL;
            }
        }

        if ( pFirst == this )   // Sollte immer so sein, aber besser ist es
            if ( pNext )        // Befehle warten auf Ausführung
            {                   // An Ende neu einsortieren
                Advance();
                QueStatement( NULL );
            }
//          {                   // Ersten und 2. austauschen.
//              pFirst = pNext;
//              pNext = pNext->pNext;
//              pFirst->pNext = this;
//          }

    }
    else
    {
        delete GetTTSettings()->pDisplayHidWin;
        GetTTSettings()->pDisplayHidWin = NULL;
        GetTTSettings()->pDisplayInstance = NULL;
    }

    return GetTTSettings()->pDisplayHidWin != NULL;
}

class TranslateWin : public WorkWindow
{
private:
    DECL_LINK( DoAccept, PushButton* );
    DECL_LINK( DoNext, PushButton* );
    DECL_LINK( DoSelect, PushButton* );
    DECL_LINK( DoRestore, PushButton* );
    DECL_LINK( TranslationChanged, Edit* );
    DECL_LINK( ShowInplace, Timer* );

    Timer InplaceTimer;

//  virtual void MouseButtonUp( const MouseEvent& rMEvt );
//  virtual void MouseMove( const MouseEvent& rMEvt );

    PushButton PushButtonTT_PB_NEXT;
    GroupBox GroupBoxTT_GB_TRANSLATION;
    Edit EditTT_E_NEW;
    GroupBox GroupBoxTT_GB_COMMENT;
    Edit EditTT_E_COMMENT;
    PushButton PushButtonTT_PB_ACCEPT;
    FixedText FixedTextTT_FT_OLD;
    PushButton PushButtonTT_PB_SELECT;
    PushButton PushButtonTT_PB_RESTORE;

    Window *Old;
    Window *Act;
    Window *pTranslateWin;
    sal_Bool bSelecting;

    sal_Bool bAvailable;
    sal_Bool bNext;

    sal_Bool TestChangedDataSaved();


    sal_uLong nEventHookID;
    static long stub_VCLEventHookProc( NotifyEvent& rEvt, void* pData )
    {
        return ((TranslateWin*)pData)->VCLEventHook( rEvt );
    }

    long VCLEventHook( NotifyEvent& rEvt );

public:
    TranslateWin();
    ~TranslateWin();

    static String MarkShortcutErrors( Window* pBase, sal_Bool bMark );

    sal_Bool IsTranslationAvailable(){ return bAvailable; }
    sal_Bool IsNextDialog(){ return bNext; }
    void ResetNextDialog(){ bNext = sal_False; }

    Window* GetTranslationWindow(){ return pTranslateWin; }
    String GetOriginalText(){ return FixedTextTT_FT_OLD.GetText(); }
    String GetTranslationText(){ return EditTT_E_NEW.GetText(); }
    String GetComment(){ return EditTT_E_COMMENT.GetText(); }

    void EnableTranslation();
};

TranslateWin::TranslateWin()
: WorkWindow( NULL, TTProperties::GetSvtResId( TT_INLINE_TRANSLATION ) )
, PushButtonTT_PB_NEXT( this, TTProperties::GetSvtResId( TT_PB_NEXT ) )
, GroupBoxTT_GB_TRANSLATION( this, TTProperties::GetSvtResId( TT_GB_TRANSLATION ) )
, EditTT_E_NEW( this, TTProperties::GetSvtResId( TT_E_NEW ) )
, GroupBoxTT_GB_COMMENT( this, TTProperties::GetSvtResId( TT_GB_COMMENT ) )
, EditTT_E_COMMENT( this, TTProperties::GetSvtResId( TT_E_COMMENT ) )
, PushButtonTT_PB_ACCEPT( this, TTProperties::GetSvtResId( TT_PB_ACCEPT ) )
, FixedTextTT_FT_OLD( this, TTProperties::GetSvtResId( TT_FT_OLD ) )
, PushButtonTT_PB_SELECT( this, TTProperties::GetSvtResId( TT_PB_SELECT ) )
, PushButtonTT_PB_RESTORE( this, TTProperties::GetSvtResId( TT_PB_RESTORE ) )
, Old( NULL )
, Act( NULL )
, pTranslateWin( NULL )
, bSelecting( sal_False )
, bAvailable( sal_False )
, bNext( sal_False )
{
    FreeResource();
    PushButtonTT_PB_NEXT.SetClickHdl( LINK( this, TranslateWin, DoNext ) );
    PushButtonTT_PB_ACCEPT.SetClickHdl( LINK( this, TranslateWin, DoAccept ) );
    PushButtonTT_PB_SELECT.SetClickHdl( LINK( this, TranslateWin, DoSelect ) );
    PushButtonTT_PB_RESTORE.SetClickHdl( LINK( this, TranslateWin, DoRestore ) );
    EditTT_E_NEW.SetModifyHdl( LINK( this, TranslateWin, TranslationChanged ) );
    InplaceTimer.SetTimeout( 250 );
    InplaceTimer.SetTimeoutHdl( LINK( this, TranslateWin, ShowInplace ) );
    EnableAlwaysOnTop();
    nEventHookID = Application::AddEventHook( stub_VCLEventHookProc, this );
}

TranslateWin::~TranslateWin()
{
    Application::RemoveEventHook( nEventHookID );
}

sal_Bool TranslateWin::TestChangedDataSaved()
{
    if ( ( EditTT_E_NEW.GetText().CompareTo( FixedTextTT_FT_OLD.GetText() ) != COMPARE_EQUAL
            || EditTT_E_COMMENT.GetText().Len() )
        && PushButtonTT_PB_ACCEPT.IsEnabled() )
    {
        return MessBox( this, TTProperties::GetSvtResId( TT_DISCARD_CHANGED_DATA ) ).Execute() == RET_YES;
    }
    else
        return sal_True;
}

IMPL_LINK( TranslateWin, DoAccept, PushButton*, EMPTYARG )
{
    PushButtonTT_PB_SELECT.Disable();
    PushButtonTT_PB_NEXT.Disable();
        PushButtonTT_PB_RESTORE.Disable();
    EditTT_E_NEW.Disable();
    EditTT_E_COMMENT.Disable();
    PushButtonTT_PB_ACCEPT.Disable();
    bAvailable = sal_True;
    return 0;
}

IMPL_LINK( TranslateWin, DoNext, PushButton*, EMPTYARG )
{
    if ( TestChangedDataSaved() )
    {
        PushButtonTT_PB_SELECT.Disable();
        PushButtonTT_PB_NEXT.Disable();
        PushButtonTT_PB_RESTORE.Disable();
        EditTT_E_NEW.Disable();
        EditTT_E_COMMENT.Disable();
        PushButtonTT_PB_ACCEPT.Disable();
        bNext = sal_True;
    }
    return 0;
}

IMPL_LINK( TranslateWin, DoSelect, PushButton*, EMPTYARG )
{
    if ( bSelecting )
    {
//      ReleaseMouse();
        bSelecting = sal_False;
    }
    else
    {
        if ( TestChangedDataSaved() )
        {
            PushButtonTT_PB_RESTORE.Disable();
//          CaptureMouse();
            bSelecting = sal_True;
        }
    }
    return 0;
}

IMPL_LINK( TranslateWin, DoRestore, PushButton*, EMPTYARG )
{
    String sTT_E_OLD( FixedTextTT_FT_OLD.GetText());
    sTT_E_OLD.SearchAndReplaceAll( CUniString("\\n"), CUniString("\n") );
    sTT_E_OLD.SearchAndReplaceAll( CUniString("\\t"), CUniString("\t") );

    String sTT_E_NEW( EditTT_E_NEW.GetText());
    sTT_E_NEW.SearchAndReplaceAll( CUniString("\\n"), CUniString("\n") );
    sTT_E_NEW.SearchAndReplaceAll( CUniString("\\t"), CUniString("\t") );

    if ( StatementList::WinPtrValid( pTranslateWin ) && pTranslateWin->GetText().CompareTo( sTT_E_NEW ) == COMPARE_EQUAL )
    {   // Im ersten schritt nur in der UI zurück
        pTranslateWin->SetText( sTT_E_OLD );
    }
    else
    {   // Im zweite Schritt auch den eingegebenen Text
        EditTT_E_NEW.SetText( FixedTextTT_FT_OLD.GetText() );
        PushButtonTT_PB_RESTORE.Disable();
    }
    if ( StatementList::WinPtrValid( pTranslateWin ) )
        MarkShortcutErrors( pTranslateWin->GetWindow( WINDOW_OVERLAP ), sal_True );
    return 0;
}

IMPL_LINK( TranslateWin, TranslationChanged, Edit*, pEdit )
{
    (void) pEdit; /* avoid warning about unused parameter */
    PushButtonTT_PB_RESTORE.Enable();
    InplaceTimer.Start();
    return 0;
}

IMPL_LINK( TranslateWin, ShowInplace, Timer*, EMPTYARG )
{
    PushButtonTT_PB_RESTORE.Enable();
    if ( StatementList::WinPtrValid( pTranslateWin ) )
    {
        String sTT_E_NEW( EditTT_E_NEW.GetText());
        // alle CRs UnQuoten
        sTT_E_NEW.SearchAndReplaceAll( CUniString("\\n"), CUniString("\n") );
        // alle TABSs UnQuoten
        sTT_E_NEW.SearchAndReplaceAll( CUniString("\\t"), CUniString("\t") );
        pTranslateWin->SetText( sTT_E_NEW );

        MarkShortcutErrors( pTranslateWin->GetWindow( WINDOW_OVERLAP ), sal_True );
    }
    return 0;
}

long TranslateWin::VCLEventHook( NotifyEvent& rEvt )
{
    if ( EVENT_MOUSEMOVE == rEvt.GetType() )
    {
        if ( bSelecting )
        {
            const MouseEvent *pMEvt = rEvt.GetMouseEvent();
            Old = Act;
            Act = rEvt.GetWindow();

            if ( Act )
            {
                Window *pWin = Act;
                sal_uInt16 i;
                for ( i = 0 ; i < Act->GetChildCount() ; i++ )
                {
                    pWin = Act->GetChild(i);
                    Rectangle aWinPosSize( pWin->GetPosPixel(), pWin->GetSizePixel() );

                    if ( ( pWin->IsMouseTransparent() || !pWin->IsEnabled() ) && aWinPosSize.IsInside( pMEvt->GetPosPixel() ) )
                    {
                        Act = pWin;
                        break;
                    }
                }
            }

            if ( !StatementList::WinPtrValid ( Old ) )
                Old = NULL;

            if ( Act != Old )
            {
                if ( Old )
                {
                    Window *pWin;
                    if ( Old->IsMouseTransparent() && Old->GET_REAL_PARENT() )
                        pWin = Old->GET_REAL_PARENT();
                    else
                        pWin = Old;
                    RESET_WIN(pWin);
                }
                if ( Act )
                {
                    SET_WIN(Act);
                    FixedTextTT_FT_OLD.SetText( Act->GetText() );
                }
                else
                    FixedTextTT_FT_OLD.SetText( String() );
            }
            else if ( Act )
            {
    //          SET_WIN(Act);
            }
    /*      if ( Application::GetLastInputInterval() > 5000 )   // 5 Sekunden lang nichts geschehen
            {
                ToTop();
            }
    */
        }   //if ( bSelecting )
        else
        {
            if ( Act )
            {
                if ( Act->IsMouseTransparent() && Act->GET_REAL_PARENT() )
                    Act = Act->GET_REAL_PARENT();
                RESET_WIN(Act);
                Act = NULL;
            }
        }
    }
    else if ( EVENT_MOUSEBUTTONUP == rEvt.GetType() )
    {
        if ( bSelecting )
        {
            pTranslateWin = Act;
            if ( pTranslateWin )
            {
                MarkShortcutErrors( pTranslateWin->GetWindow( WINDOW_OVERLAP ), sal_True );
                // alle CRs quoten (NF)
                String sTT_E_NEW( pTranslateWin->GetText());
                sTT_E_NEW.SearchAndReplaceAll( CUniString("\n"), CUniString("\\n") );
                // alle TABSs quoten ()
                sTT_E_NEW.SearchAndReplaceAll( CUniString("\t"), CUniString("\\t") );

                FixedTextTT_FT_OLD.SetText( sTT_E_NEW );
                EditTT_E_NEW.SetText( sTT_E_NEW );
                EditTT_E_NEW.Enable();
                EditTT_E_NEW.GrabFocus();
                EditTT_E_COMMENT.SetText( String() );
                EditTT_E_COMMENT.Enable();
                PushButtonTT_PB_ACCEPT.Enable();
            }
    //      ReleaseMouse();
            bSelecting = sal_False;
        }
    }

    return 0;
}

#define FDS_ACTION_COLLECT  1
#define FDS_ACTION_MARK     2
#define FDS_ACTION_UNMARK   3

class FindShortcutErrors: public Search
{
    String aShortcuts,aDoubleShortcuts;
    sal_uInt16 nAction;
public:
    FindShortcutErrors();
    virtual sal_Bool IsWinOK( Window *pWin );
    void SetAction( sal_uInt16 nA );
    String GetDoubleShortcuts() { return aDoubleShortcuts; }
};

FindShortcutErrors::FindShortcutErrors()
: Search( SEARCH_NOOVERLAP | SEARCH_NO_TOPLEVEL_WIN )
{
    SetAction( FDS_ACTION_COLLECT );    // Wir fange immer mit sammeln an, ODER??
}

void FindShortcutErrors::SetAction( sal_uInt16 nA )
{
    nAction = nA;
    if ( FDS_ACTION_COLLECT == nAction )
    {
        aShortcuts = UniString();
        aDoubleShortcuts = UniString();
    }
}

sal_Bool FindShortcutErrors::IsWinOK( Window *pWin )
{
    if ( pWin->IsReallyVisible() )
    {
        String aText = pWin->GetText();
        xub_StrLen nPos = aText.Search('~');
        String aShortcut;
        sal_Bool bHasAccel = sal_False;
        if ( nPos != STRING_NOTFOUND )
        {
            aShortcut = aText.Copy( nPos+1, 1 );
            aShortcut.ToLowerAscii();
            bHasAccel = aShortcut.Len() == 1;
        }

        switch ( nAction )
        {
            case FDS_ACTION_COLLECT:
                {
                    if ( aShortcuts.Search( aShortcut ) != STRING_NOTFOUND )
                        aDoubleShortcuts += aShortcut;
                    else
                        aShortcuts += aShortcut;
                }
                break;
            case FDS_ACTION_MARK:
                {
                    sal_Bool bMissing = sal_False;
                    if ( !bHasAccel && aText.Len() )    // should there be an accelerator defined
                    {

                        Window*     pChild;
                        pChild = pWin->GetWindow( WINDOW_CLIENT );

                        if ( (pChild->GetType() == WINDOW_RADIOBUTTON) ||
                             (pChild->GetType() == WINDOW_IMAGERADIOBUTTON) ||
                             (pChild->GetType() == WINDOW_CHECKBOX) ||
                             (pChild->GetType() == WINDOW_TRISTATEBOX) ||
                             (pChild->GetType() == WINDOW_PUSHBUTTON) )
                        {
                            if ( !pChild->GetText().EqualsAscii( "..." ) )
                                bMissing = sal_True;
                        }

                        if ( pChild->GetType() == WINDOW_FIXEDTEXT )
                        {
                            Window* pTempChild = pWin->GetWindow( WINDOW_NEXT );
                            if ( pTempChild )
                                pTempChild = pTempChild->GetWindow( WINDOW_CLIENT );

                            if ( pTempChild && pChild->GetText().Len() )
                            {
                                if ( (pTempChild->GetType() == WINDOW_EDIT) ||
                                     (pTempChild->GetType() == WINDOW_MULTILINEEDIT) ||
                                     (pTempChild->GetType() == WINDOW_SPINFIELD) ||
                                     (pTempChild->GetType() == WINDOW_PATTERNFIELD) ||
                                     (pTempChild->GetType() == WINDOW_NUMERICFIELD) ||
                                     (pTempChild->GetType() == WINDOW_METRICFIELD) ||
                                     (pTempChild->GetType() == WINDOW_CURRENCYFIELD) ||
                                     (pTempChild->GetType() == WINDOW_DATEFIELD) ||
                                     (pTempChild->GetType() == WINDOW_TIMEFIELD) ||
                                     (pTempChild->GetType() == WINDOW_LISTBOX) ||
                                     (pTempChild->GetType() == WINDOW_MULTILISTBOX) ||
                                     (pTempChild->GetType() == WINDOW_COMBOBOX) ||
                                     (pTempChild->GetType() == WINDOW_PATTERNBOX) ||
                                     (pTempChild->GetType() == WINDOW_NUMERICBOX) ||
                                     (pTempChild->GetType() == WINDOW_METRICBOX) ||
                                     (pTempChild->GetType() == WINDOW_CURRENCYBOX) ||
                                     (pTempChild->GetType() == WINDOW_DATEBOX) ||
                                     (pTempChild->GetType() == WINDOW_TIMEBOX) )
                                {
                                    bMissing = sal_True;
                                }
                            }
                        }
                    }

                    if ( bHasAccel && aDoubleShortcuts.Search( aShortcut ) != STRING_NOTFOUND )
                    {
                        if ( pWin->GetType() == WINDOW_GROUPBOX )
                            pWin->SetControlForeground( Color( COL_LIGHTRED ) );
                        else
                        {
                            pWin->SetControlBackground();
                            Color aCol(COL_GRAY);
                            aCol.SetRed( 0xff );
                            pWin->SetControlBackground( aCol );
                        }
                    }
                    else if ( bMissing )
                    {
                        pWin->SetControlBackground();
                        Color aCol(COL_GRAY);
                        aCol.SetRed( 0xff );
                        aCol.SetGreen( 0xff );
                        pWin->SetControlBackground( aCol );
                    }
                    else
                    {
                        pWin->SetControlForeground();
                        pWin->SetControlBackground();
                    }
                }
                break;
            case FDS_ACTION_UNMARK:
                {
                    pWin->SetControlForeground();
                    pWin->SetControlBackground();
                }
                break;
        }
    }
    else
        if ( FDS_ACTION_MARK == nAction || FDS_ACTION_UNMARK == nAction )
        {
            pWin->SetControlForeground();
            pWin->SetControlBackground();
        }

    return sal_False;
}

String TranslateWin::MarkShortcutErrors( Window* pBase, sal_Bool bMark )
{
    if ( pBase )
    {
        FindShortcutErrors aFinder;
        if ( bMark )
        {
            StatementList::SearchAllWin( pBase, aFinder, sal_True );    // collect Shortcuts first
            aFinder.SetAction( FDS_ACTION_MARK );
        }
        else
            aFinder.SetAction( FDS_ACTION_UNMARK );
        StatementList::SearchAllWin( pBase, aFinder, sal_True );
        return aFinder.GetDoubleShortcuts();
    }
    return UniString();
}

void TranslateWin::EnableTranslation()
{
    PushButtonTT_PB_SELECT.Enable();
    PushButtonTT_PB_NEXT.Enable();
    bAvailable = sal_False;
    bNext = sal_False;
}

void StatementCommand::Translate()
{
    // Es wurde eine initale UniqueId mitgegeben. Dann nur die dopelten Shortcuts liefern
    if( (nParams & PARAM_STR_1) && nLNr1 )
    {
        String aDouble;
        Window *pWin = SearchTree( Str2Id( aString1 ) ,sal_False );
        if ( pWin )
        {
            pWin = pWin->GetWindow( WINDOW_OVERLAP );
            aDouble = TranslateWin::MarkShortcutErrors( pWin, sal_True );
        }
        pRet->GenReturn ( RET_Value, nMethodId, aDouble );
        return;
    }

    if ( !GetTTSettings()->pTranslateWin )
    {
        GetTTSettings()->pTranslateWin = new TranslateWin;
        GetTTSettings()->bToTop = sal_True;
    }

    GetTTSettings()->pTranslateWin->Show();
    if ( GetTTSettings()->bToTop )
    {
        GetTTSettings()->pTranslateWin->ToTop();
        GetTTSettings()->bToTop = sal_False;
    }

//  GetTTSettings()->pTranslateWin->GetWindow( WINDOW_OVERLAP )->Enable( sal_True, sal_True );
    GetTTSettings()->pTranslateWin->GetWindow( WINDOW_OVERLAP )->EnableInput( sal_True, sal_True );

    if ( GetTTSettings()->pTranslateWin->IsTranslationAvailable() )
    {
        String aTranslation;
        Window* pTranslationWindow = GetTTSettings()->pTranslateWin->GetTranslationWindow();

        DBG_ASSERT( pTranslationWindow, "Kein Translation Window" );

        if ( WinPtrValid( pTranslationWindow ) )
        {
            if ( pTranslationWindow->GetType() == WINDOW_BORDERWINDOW && pTranslationWindow->GetWindow( WINDOW_CLIENT ) )
            {
                Window* pNew = pTranslationWindow->GetWindow( WINDOW_CLIENT );
                // Bei Dockingwindows das ganze Geraffel von Docking Floating überspringen
                while ( IsDialog( pNew ) && pNew->GetUniqueOrHelpId().isEmpty() && pNew->GetChildCount() == 1 )
                    pNew = pNew->GetChild( 0 );
                pTranslationWindow = pNew;
            }

            aTranslation = CUniString("0;");

            aTranslation += Id2Str( pTranslationWindow->GetUniqueOrHelpId() );
            aTranslation += ';';

            aTranslation += TypeString( pTranslationWindow->GetType() );
            aTranslation += ';';

            Window* pParentDialog = pTranslationWindow;
            while ( pParentDialog && !IsDialog( pParentDialog ) )
            {
                pParentDialog = pParentDialog->GET_REAL_PARENT();
            }

            if ( pParentDialog )
            {
                aTranslation += Id2Str(pParentDialog->GetUniqueOrHelpId());
                aTranslation += ';';
                aTranslation += TypeString( pParentDialog->GetType() );
            }
            else
                aTranslation.AppendAscii( "0;" ); // Zahl + leerer String
            aTranslation += ';';

            aTranslation += '\"';
            aTranslation += GetTTSettings()->pTranslateWin->GetOriginalText();
            aTranslation += '\"';

            aTranslation += ';';

            aTranslation += '\"';
            aTranslation += GetTTSettings()->pTranslateWin->GetTranslationText();
            aTranslation += '\"';

            aTranslation += ';';

            aTranslation += '\"';
            aTranslation += GetTTSettings()->pTranslateWin->GetComment();
            aTranslation += '\"';

            // alle CRs quoten (NF)
            aTranslation.SearchAndReplaceAll( CUniString("\n"), CUniString("\\n") );
            // alle TABSs quoten ()
            aTranslation.SearchAndReplaceAll( CUniString("\t"), CUniString("\\t") );

            pRet->GenReturn ( RET_Value, nMethodId, aTranslation );
            GetTTSettings()->pTranslateWin->EnableTranslation();
            GetTTSettings()->bToTop = sal_True;
        }
        else
        {
            pRet->GenReturn ( RET_Value, nMethodId, String() );
            GetTTSettings()->pTranslateWin->EnableTranslation();
            ErrorBox err( GetTTSettings()->pTranslateWin, TTProperties::GetSvtResId( TT_NO_CONTROL ));
            err.Execute();
            GetTTSettings()->bToTop = sal_True;
        }

    }
    else if ( GetTTSettings()->pTranslateWin->IsNextDialog() )
    {
        pRet->GenReturn ( RET_Value, nMethodId, CUniString("1") );
        GetTTSettings()->pTranslateWin->ResetNextDialog();
        GetTTSettings()->pTranslateWin->LoseFocus();
        GetTTSettings()->bToTop = sal_True;
    }
    else
    {
        GetTTSettings()->pTranslateWin->EnableTranslation();
        pRet->GenReturn ( RET_Value, nMethodId, String() );
    }
}

Window* StatementCommand::GetNextOverlap( Window* pBase )
{   // Findet irgendwelche Overlap-Fenster, die schließbar aussehen
    // Eventuell muß noch die Auswahl verfeinert werden.

    if ( pBase->GetType() != WINDOW_BORDERWINDOW )
        pBase = pBase->GetWindow( WINDOW_OVERLAP );

    Window *pControl = NULL;
    if ( pBase->GetWindow( WINDOW_FIRSTOVERLAP ) )
    {
        pControl = GetNextOverlap( pBase->GetWindow( WINDOW_FIRSTOVERLAP ) );
    }

    if ( !pControl && pBase->GetWindow( WINDOW_NEXT ) )
    {
        pControl = GetNextOverlap( pBase->GetWindow( WINDOW_NEXT ) );
    }

    if ( !pControl )
    {
        Window *pTest = pBase->GetWindow( WINDOW_CLIENT );
        if ( IsAccessable (pTest)
            && pTest->IsEnabled()
            && pTest->IsVisible()
            && ((pTest->GetStyle() & WB_CLOSEABLE ) || (pBase->GetStyle() & WB_CLOSEABLE )) )
            return pTest;
        else
            return NULL;
    }
    else
        return pControl;
}

Window* StatementCommand::GetNextRecoverWin()
{
    // über die TopLevelWindows der App iterieren
    Window* pBase = Application::GetFirstTopLevelWindow();
    Window *pControl = NULL;
    Window* pMyFirstDocFrame = NULL;
    while ( pBase )
    {
        // zuerst weitere Fenster auf dem Fenster suchen und schliessen
        pControl = GetNextOverlap( pBase );
        if ( pControl && pControl->GetType() == WINDOW_HELPTEXTWINDOW )
        {}  // skip it
        else
        {
            if ( pControl && pControl->IsVisible() && !IsFirstDocFrame( pControl ) && !IsIMEWin( pControl ) )
            {
                Window* pTB = pControl->GetChild( 0 );
                if ( pControl->GetChildCount() == 1 && pTB->GetType() == WINDOW_TOOLBOX )
//                  return pTB;
                    ;   // do not act on floating toolboxes #i38796
                else
                    return pControl;
            }

            // dann das Fenster selbst schliessen
            // erstes DocWin überspringen
            // Assumption that Doc Windows are Borderwindows and ButtonDialog and such are not
            if ( pBase->IsVisible() && !IsFirstDocFrame( pBase ) && pBase->GetType() != WINDOW_BORDERWINDOW && !IsIMEWin( pBase ) )
                return pBase;

            if ( !pMyFirstDocFrame && IsFirstDocFrame( pBase ) )
                pMyFirstDocFrame = pBase;
        }

        pBase = Application::GetNextTopLevelWindow( pBase );
    }
#ifdef RESET_APPLICATION_TO_BACKING_WINDOW
    // close the FirstDocFrame last, It will not be closed, but the Document inside will be closed.
    if ( IsDocWin( pMyFirstDocFrame ) )
        return pMyFirstDocFrame;
#endif // def RESET_APPLICATION_TO_BACKING_WINDOW

    return NULL;
}

sal_Bool StatementCommand::Execute()
{
    if ( IsError )
    {
#if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "Skipping Command: " );
        m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
        m_pDbgWin->AddText( "\n" );
        #endif

        Advance();
        delete this;
        return sal_True;
    }

    InitProfile();
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Executing Command: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
    m_pDbgWin->AddText( "\n" );
#endif





#if OSL_DEBUG_LEVEL > 1
#define REPORT_WIN_CLOSED(pControl, aInfo)          \
    _REPORT_WIN_CLOSED(pControl, aInfo)             \
    m_pDbgWin->AddText( aInfo.AppendAscii(" \"").Append( pControl->GetText() ).AppendAscii("\" geschlossen, RType = ").Append( TypeString(pControl->GetType()) ).AppendAscii(", UId = ").Append( UIdString( pControl->GetUniqueOrHelpId() ) ) );
#else
#define REPORT_WIN_CLOSED(pControl, aInfo) _REPORT_WIN_CLOSED(pControl, aInfo)
#endif

#define REPORT_WIN_CLOSEDc(pControl, aInfo )        \
    REPORT_WIN_CLOSED(pControl, CUniString(aInfo) )

#define _REPORT_WIN_CLOSED(pControl, aInfo)         \
    if ( aString1.Len() )                           \
        aString1 += '\n';                           \
    aString1 += aInfo;                              \
    aString1.AppendAscii(" \"");                    \
    aString1 += pControl->GetText();                \
    aString1.AppendAscii("\" geschlossen, RType = ");\
    aString1 += TypeString(pControl->GetType());    \
    aString1.AppendAscii(", UId = ");               \
    aString1 += UIdString(pControl->GetUniqueOrHelpId());


    switch ( nMethodId )
    {
        case RC_AppDelay:
            if ( !bBool1 )
            {
                nLNr1 = Time().GetTime() + nNr1/10;
                bBool1 = sal_True;
            }
            if ( Time().GetTime() < long(nLNr1) )   // Aktuelle Zeit kleiner Endzeit
                return sal_False;
            break;
        case RC_DisplayHid:
            if ( DisplayHID() )
                return sal_False;
            break;
        case RC_ResetApplication:
            {
                if ( !bBool1 )
                {
                    nRetryCount = 150;      // das sollte reichen.
                    bBool1 = sal_True;      // Nur beim ersten mal!
                    nNr1 = 1;               // Welcher Button ist dran?
                    nLNr1 = 0;              // Speichern des AppWin
                    aString1 = UniString(); // Liste der geschlossenen Fenster

                    // So daß nacher auch wieder alles auf Default steht
                    nUseBindings = 0;
                    bCatchGPF = sal_True;
                    bUsePostEvents = sal_True;

                    aSubMenuId1 = 0;
                    aSubMenuId2 = 0;
                    aSubMenuId3 = 0;
                    pMenuWindow = NULL;
                }
                if ( !nRetryCount )
                    ReportError( GEN_RES_STR0( S_RESETAPPLICATION_FAILED_COMPLEX ) );

                Window *pControl = GetNextRecoverWin();

                if ( pControl )
                {
                    bBool2 = sal_False; // flag for wait when all windows are closed
                    pControl->GrabFocus();

                    if (    pControl->GetType() != WINDOW_DOCKINGWINDOW
                         && pControl->GetType() != WINDOW_FLOATINGWINDOW
                         && pControl->GetType() != WINDOW_MODELESSDIALOG
                         && pControl->GetType() != WINDOW_WORKWINDOW
                         && pControl->GetType() != WINDOW_TOOLBOX
                         && pControl->GetType() != WINDOW_BORDERWINDOW
                         && nRetryCount-- )
                    {
                        short nRT = ImpGetRType( pControl );

                        if ( nRT == C_TabControl && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
                        {   // Bei Tabcontrol den zugehörigen Tabdialog nehmen
                            pControl = pControl->GET_REAL_PARENT();
                            nRT = ImpGetRType( pControl );
                        }

                        switch( nRT )
                        {
                            case C_ModalDlg:
                            case C_Dialog:
                            case C_TabDlg:
                                REPORT_WIN_CLOSEDc(pControl, "Dialog");
                                SET_WINP_CLOSING(pControl);
                                ((SystemWindow*)pControl)->Close();
                                break;
                            case C_WorkWin:
                                break;
                            case C_MessBox:
                            case C_InfoBox:
                            case C_WarningBox:
                            case C_ErrorBox:
                            case C_QueryBox:
                            case C_ButtonDialog:
                                {
                                    ButtonDialog* pBD = (ButtonDialog*)pControl;
                                    // nNr1 >= 10 bedeutet (Custom)-Buttons durchgehen
                                    if ( nNr1 >= 10+pBD->GetButtonCount() ) nNr1 = 1;
                                    switch( nNr1 )
                                    {
                                        case 5:
                                            if ( pBD->GetPushButton( BUTTONID_OK ) )
                                            {
                                                REPORT_WIN_CLOSEDc(pControl, "Message Box (OK)");
                                                SET_WINP_CLOSING(pControl);
                                                pBD->EndDialog(RET_OK);
                                            }
                                            nNr1 = 10;  // Nochmal alle Buttons der Reihe nach
                                            break;
                                        case 4:
                                            if ( pBD->GetPushButton( BUTTONID_CANCEL ) )
                                            {
                                                REPORT_WIN_CLOSEDc(pControl, "Message Box (Cancel)");
                                                SET_WINP_CLOSING(pControl);
                                                pBD->EndDialog(RET_CANCEL);
                                            }
                                            nNr1++;
                                            break;
                                        case 3:
                                            if ( pBD->GetPushButton( BUTTONID_YES ) )
                                            {
                                                REPORT_WIN_CLOSEDc(pControl, "Message Box (Yes)");
                                                SET_WINP_CLOSING(pControl);
                                                pBD->EndDialog(RET_YES);
                                            }
                                            nNr1++;
                                            break;
                                        case 2:     // BUG 48239
                                        case 1:
                                            if ( pBD->GetPushButton( BUTTONID_NO ) )
                                            {
                                                REPORT_WIN_CLOSEDc(pControl, "Message Box (No)");
                                                SET_WINP_CLOSING(pControl);
                                                pBD->EndDialog(RET_NO);
                                            }
                                            nNr1++;
                                            break;
                                        default:
                                            {
                                                sal_uInt16 nID = pBD->GetButtonId( nNr1-10 );
                                                if ( nID != BUTTONID_HELP )
                                                {
                                                    REPORT_WIN_CLOSED(pControl, CUniString("Message Box (").Append( UniString::CreateFromInt32(nID) ).AppendAscii(")"));
                                                    SET_WINP_CLOSING(pControl);
                                                    pBD->EndDialog(nID);
                                                }
                                                nNr1++;
                                            }
                                    }
                                    break;
                                }
                            default:
                                DBG_ERROR( "Unknown Windowtype" );
                                REPORT_WIN_CLOSEDc(pControl, "Unknown Windowtype");
                                ReportError( GEN_RES_STR0( S_RESETAPPLICATION_FAILED_UNKNOWN ), pControl->GetType() );
                                #if OSL_DEBUG_LEVEL > 1
                                m_pDbgWin->AddText( " Unbekannter Objekttyp aus UId" );
                                #endif
                                break;
                        }
                        return sal_False;
                    }
                    else
                    {
                        if ( (pControl->GetType() == WINDOW_DOCKINGWINDOW || pControl->GetType() == WINDOW_TOOLBOX) && nRetryCount-- )
                        {
                            if ( (((DockingWindow*)pControl)->GetStyle() | ((DockingWindow*)pControl)->GetFloatStyle()) & WB_CLOSEABLE )
                            {
                                REPORT_WIN_CLOSED(pControl, TypeString(pControl->GetType()));
                                SET_WINP_CLOSING(pControl);
                                ((DockingWindow*)pControl)->Close();

                                // Eigentlich nur bei TaskWindows! Hoffen wir mal, daß keine anderen DockingWindows dazwischen hauen.
                                if ( (Window*)nLNr1 != pControl )
                                    nNr1 = 1;       // Zum durchprobieren der Buttons beim schließen
                                nLNr1 = (sal_uLong)pControl;

                                return sal_False;
                            }
                        }
                        if ( nRetryCount--
                                && (    (pControl->GetType() == WINDOW_FLOATINGWINDOW)
                                    ||  (pControl->GetType() == WINDOW_MODELESSDIALOG)
                                    ||  (pControl->GetType() == WINDOW_WORKWINDOW)
                                    ||  (pControl->GetType() == WINDOW_BORDERWINDOW) ) )
                        {
    //                      if ( pControl->GetStyle() & WB_CLOSEABLE )
                            {
#ifdef RESET_APPLICATION_TO_BACKING_WINDOW
                                // Special handling for last Document; do not close the Frame, only the Document
                                if ( GetDocWinCount() == 1 && IsDocFrame( pControl ) )
                                {
                                    if ( IsDocWin( pControl ) )
                                    {
                                        if ( GetDocFrameMenuBar( pControl ) )
                                        {
                                            MenuBar* pMenu = GetDocFrameMenuBar( pControl );
                                            if ( pMenu->HasCloser() )
                                            {
                                                REPORT_WIN_CLOSED( pControl, TypeString(pControl->GetType()));
                                                SET_WINP_CLOSING(pControl);

                                                pMenu->GetCloserHdl().Call( pMenu );

                                                // nur bei TaskWindows!
                                                if ( (Window*)nLNr1 != pControl )
                                                    nNr1 = 1;       // Zum durchprobieren der Buttons beim Schließen
                                                nLNr1 = (sal_uLong)pControl;

                                                return sal_False;
                                            }
                                        }
                                    }
                                }
                                else
#endif // def RESET_APPLICATION_TO_BACKING_WINDOW
                                {
                                    REPORT_WIN_CLOSED( pControl, TypeString(pControl->GetType()));
                                    SET_WINP_CLOSING(pControl);
                                    ((SystemWindow*)pControl)->Close();

                                    // Eigentlich nur bei TaskWindows!
                                    if ( (Window*)nLNr1 != pControl )
                                        nNr1 = 1;       // Zum durchprobieren der Buttons beim Schließen
                                    nLNr1 = (sal_uLong)pControl;

                                    return sal_False;
                                }
                            }
                        }
                    }
                }
                // wait for some time if more windows show up
                // E.g.: Floating toolbars on a Task which was hidden by another Task before
                if ( !bBool2 )
                {
                    nLNr1 = Time().GetTime() + 100; // 100 = 1 Second
                    bBool2 = sal_True;
                }
                if ( Time().GetTime() < long(nLNr1) )   // Aktuelle Zeit kleiner Endzeit
                    return sal_False;
                else
                    pRet->GenReturn ( RET_Value, nMethodId, aString1);
            }
            break;
        case RC_WaitSlot:
            {
                if ( ! (nParams & PARAM_USHORT_1) )
                    nNr1 = 1000;    // defaults to 1000 = 1 Sec.
                if ( !bBool1 )
                {
                    nLNr1 = Time().GetTime() + nNr1/10;
                    bBool1 = sal_True;
                }

                if ( !bIsSlotInExecute )
                    pRet->GenReturn ( RET_Value, nMethodId, comm_USHORT(CONST_WSFinished) );
                else
                {
                    if ( Time().GetTime() < long(nLNr1) )   // Aktuelle Zeit kleiner Endzeit
                        return sal_False;
                    pRet->GenReturn ( RET_Value, nMethodId, comm_USHORT(CONST_WSTimeout) );
                }
            }
            break;
    }


    Advance();


    switch ( nMethodId )
    {
        case RC_AppDelay:       // Diese Befehle werden anderswo behandelt
        case RC_DisplayHid:
        case RC_ResetApplication:
        case RC_WaitSlot:

        case RC_AppAbort:       // Sofortiges Löschen aller Befehle
            break;
        case RC_Assert:
            {
                ByteString aAssertion( "Diese Assertion wurde vom Testtool per Befehl ausgelöst" );
                aAssertion = ByteString( String( aAssertion, RTL_TEXTENCODING_MS_1252 ), RTL_TEXTENCODING_UTF8 );
                DBG_ASSERT( !aString1.Len(), ByteString( aString1, RTL_TEXTENCODING_UTF8 ).GetBuffer() );
                DBG_ASSERT(  aString1.Len(), aAssertion.GetBuffer() );
                OSL_ENSURE( !aString1.Len(), ByteString( aString1, RTL_TEXTENCODING_UTF8 ).GetBuffer() );
                OSL_ENSURE(  aString1.Len(), aAssertion.GetBuffer() );
            }
            break;
        case RC_CaptureAssertions:
#ifdef DBG_UTIL
            if( !(nParams & PARAM_BOOL_1) || bBool1 )
            {
                DBG_INSTOUTERROR( DBG_OUT_TESTTOOL );
                osl_setDebugMessageFunc( osl_TestToolDebugPrint );
            }
            else
            {
                DBG_INSTOUTERROR( DBG_OUT_MSGBOX );
                osl_setDebugMessageFunc( pOriginal_osl_DebugMessageFunc );
            }
#endif
            break;
        case RC_Translate:
            Translate();
            break;
        case RC_ApplicationBusy:
        {
            sal_Bool bWait = sal_False;
            ReportError( GEN_RES_STR0( S_NO_ACTIVE_WINDOW ) );
//          if ( Application::GetAppWindow() )
//              bWait = Application::GetAppWindow()->IsWait();
            pRet->GenReturn ( RET_Value, nMethodId, bWait );
            break;
        }
        case RC_GetClipboard:
            {
                ::rtl::OUString aTemp;
                ::svt::OStringTransfer::PasteString( aTemp, GetFirstDocFrame() );
                pRet->GenReturn ( RET_Value, nMethodId, String( aTemp ) );
            }
            break;
        case RC_SetClipboard:
            ::svt::OStringTransfer::CopyString(aString1,GetFirstDocFrame());
            break;
        case RC_WinTree:
            pRet->GenReturn ( RET_Value, nMethodId, Tree( NULL, 0));
            break;
    #if OSL_DEBUG_LEVEL > 1
        case RC_NoDebug:
            m_pDbgWin->bQuiet = sal_True;
            m_pDbgWin->Hide();
            m_pDbgWin->Clear();
            break;
        case RC_Debug:
            m_pDbgWin->bQuiet = sal_False;
            m_pDbgWin->Show();
            break;
    #endif
        case RC_GPF:
            ((TabControl*)NULL)->SetCurPageId( 12345 );
            break;
        case RC_GetNextCloseWindow:
            {
                Window *pWin = GetActive( WINDOW_BASE );      // WINDOW_ANYTYPE
                if ( !pWin )
                    ReportError( GEN_RES_STR0( S_NO_ACTIVE_WINDOW ) );
                else if ( !IsDialog(pWin) )
                    ReportError( GEN_RES_STR0( S_NO_DIALOG_IN_GETACTIVE ) );
                else
                {
                    pRet->GenReturn( RET_Value, nMethodId, Id2Str(pWin->GetUniqueOrHelpId()) );
                }
            }
            break;
        case RC_UseBindings:
            if( !(nParams & PARAM_BOOL_1) || bBool1 )
                nUseBindings = SFX_USE_BINDINGS;
            else
                nUseBindings = 0;
            break;
        case RC_Profile:
            //  Bei folgenden Parametern passiert folgendes:
            //  ein boolean=false                   Alles Profiling stoppen (Ergebnisse liefern)
            //  ein boolean=true, 1-4 ints          Einteilung der Zeiten in Kästchen
            //  kein! boolean keine ints            loggen jeden Befehls
            //  kein! boolean 1 int                 loggen alle int Millisekunden
            //  ein String                          wird in das Logfile übernommen(sonst passiert nichts)
            if( !(nParams & PARAM_BOOL_1) || bBool1 )
            {
                if ( !pProfiler )
                {
                    pProfiler = new TTProfiler;
                    InitProfile();
                }

                if( !(nParams & PARAM_BOOL_1) && (nParams & PARAM_USHORT_1) )
                {   // Autoprofiling: Profile nNr
                    if ( pProfiler->IsProfilingPerCommand() )
                    {
                        pProfiler->StopProfilingPerCommand();
                    }
                    pProfiler->StartAutoProfiling( nNr1 );

                    // Der Header ist abhängig vom Modus
                    pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetProfileHeader() );
                }
                else if ( nParams & PARAM_USHORT_1 )
                {   // Partitioning initialisieren: Profile true [,nNr][,nNr][,nNr][,nNr]
                    comm_ULONG nAnzahl=0;
                    if ( nParams & PARAM_USHORT_1 ) { nAnzahl++; };
                    if ( nParams & PARAM_USHORT_2 ) { nAnzahl++; };
                    if ( nParams & PARAM_USHORT_3 ) { nAnzahl++; };
                    if ( nParams & PARAM_USHORT_4 ) { nAnzahl++; };

                    // Hier werden die Parameter ans Testtool zurück übertragen.
                    // Das ist zwar etwas eigenartig, aber ansonsten müsste man im Testtool
                    // die einfache Struktur der Remotebefehle aufbrechen.
                    pRet->GenReturn( RET_ProfileInfo, S_ProfileReset, nAnzahl );

                    // Und die einzelnen Grenzen
                    if ( nParams & PARAM_USHORT_1 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder1, (comm_ULONG)nNr1 ); };
                    if ( nParams & PARAM_USHORT_2 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder2, (comm_ULONG)nNr2 ); };
                    if ( nParams & PARAM_USHORT_3 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder3, (comm_ULONG)nNr3 ); };
                    if ( nParams & PARAM_USHORT_4 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder4, (comm_ULONG)nNr4 ); };

                    pProfiler->StartPartitioning();
                }
                else if( nParams == PARAM_STR_1 )   // Genau ein String!
                {   // Nur einen String ins Profiling aufnehmen
                    aString1 += '\n';
                    pRet->GenReturn( RET_ProfileInfo, 0, aString1 );
                }
                else
                {   // Normales Profiling je Kommando: profile
                    if ( pProfiler->IsAutoProfiling() )
                    {
                        pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetAutoProfiling() );
                        pProfiler->StopAutoProfiling();
                    }
                    pProfiler->StartProfilingPerCommand();

                    // Der Header ist abhängig vom Modus
                    pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetProfileHeader() );
                }
            }
            else        // Profiling wieder ausschalten: Profile false
                if ( pProfiler )
                {
                    if ( pProfiler->IsProfilingPerCommand() )
                        pProfiler->StopProfilingPerCommand();

                    if ( pProfiler->IsAutoProfiling() )
                    {
                        pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetAutoProfiling() );
                        pProfiler->StopAutoProfiling();
                    }

                    if ( pProfiler->IsPartitioning() )
                    {
                        pRet->GenReturn( RET_ProfileInfo, S_ProfileDump, (comm_ULONG)0 );
                        pProfiler->StopPartitioning();
                    }

                    delete pProfiler;
                    pProfiler = NULL;
                }
            break;
        case RC_MenuGetItemCount:
        case RC_MenuGetItemId:
        case RC_MenuGetItemPos:
        case RC_MenuIsSeperator:
        case RC_MenuIsItemChecked:
        case RC_MenuIsItemEnabled:
        case RC_MenuGetItemText:
        case RC_MenuGetItemCommand:
        case RC_MenuHasSubMenu:
        case RC_MenuSelect:
            {
                PopupMenu *pPopup = NULL;
                MenuBar *pMenuBar = NULL;
                Menu *pMenu;

                sal_uInt16 nErr = GetCurrentMenues( pPopup, pMenuBar, pMenu );

                if ( !pMenu )
                {
                    if ( nErr == 1 )
                        ReportError( GEN_RES_STR0( S_NO_POPUP ) );
                    else
                        ReportError( GEN_RES_STR0( S_NO_SUBMENU ) );
                    break;
                }

                sal_uInt16 nItemCount = 0;
                switch ( nMethodId )
                {
                    case RC_MenuGetItemCount:
                    case RC_MenuGetItemId:
                    case RC_MenuIsSeperator:
                        {
                            nItemCount = pMenu->GetItemCount();
                            if ( pMenu->GetMenuFlags() & MENU_FLAG_HIDEDISABLEDENTRIES )
                            {   // jep, we have to adjust the count
                                sal_Bool bLastWasSeperator = sal_True;  // sal_True for Separator at the top
                                for ( sal_uInt16 i = 0 ; i < pMenu->GetItemCount() ; i++ )
                                {
                                    if ( !pMenu->IsItemEnabled( pMenu->GetItemId( i ) ) )
                                        nItemCount--;
                                    else
                                    {
                                        if ( pMenu->GetItemType( i ) == MENUITEM_SEPARATOR && bLastWasSeperator )
                                            nItemCount--;
                                        bLastWasSeperator = pMenu->GetItemType( i ) == MENUITEM_SEPARATOR;
                                    }
                                }
                                if ( bLastWasSeperator )    // Separator at bottom
                                    nItemCount--;
                            }
                        }
                        break;
                }

                // for certain methods calculate the physical index (reinserting the hidden entries)
                sal_uInt16 nPhysicalIndex = 0;
                switch ( nMethodId )
                {
                    case RC_MenuGetItemId:
                    case RC_MenuIsSeperator:
                        {
                            nPhysicalIndex = nNr1;
                            if ( pMenu->GetMenuFlags() & MENU_FLAG_HIDEDISABLEDENTRIES )
                            {   // jep, we have to adjust the position
                                sal_Bool bLastWasSeperator = sal_True;  // sal_True for Separator at the top
                                sal_uInt16 nVisibleCount = 0;
                                for ( sal_uInt16 i = 0 ; i < pMenu->GetItemCount() && nVisibleCount < nNr1 ; i++ )
                                {
                                    if ( pMenu->IsItemEnabled( pMenu->GetItemId( i ) )
                                         && !( pMenu->GetItemType( i ) == MENUITEM_SEPARATOR && bLastWasSeperator ) )
                                    {
                                        nVisibleCount++;
                                        bLastWasSeperator = pMenu->GetItemType( i ) == MENUITEM_SEPARATOR;
                                    }
                                    else
                                        nPhysicalIndex++;
                                }
                                DBG_ASSERT( nVisibleCount == nNr1, "Adaption of Index failed: nVisibleCount != nNr1" );
                            }
                        }
                        break;
                }



                switch ( nMethodId )
                {
                    case RC_MenuGetItemCount:
                        {
                            pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)nItemCount );
                        }
                        break;
                    case RC_MenuGetItemId:
                        {
                            if ( ValueOK( rtl::OString(), RcString( nMethodId ),nNr1,nItemCount) )
                                pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)pMenu->GetItemId(nPhysicalIndex-1) );
                        }
                        break;
                    case RC_MenuGetItemPos:
                        {
                            sal_uInt16 nLogicalPos = pMenu->GetItemPos(nNr1);
                            if ( MENU_ITEM_NOTFOUND != nLogicalPos && pMenu->GetMenuFlags() & MENU_FLAG_HIDEDISABLEDENTRIES )
                            {   // jep, we have to adjust the position
                                if ( !pMenu->IsItemEnabled( nNr1 ) )
                                    nLogicalPos = MENU_ITEM_NOTFOUND;
                                else
                                {
                                    sal_Bool bLastWasSeperator = sal_False;
                                    for ( int i = nLogicalPos ; i >= 0 ; i-- )
                                    {
                                        if ( !pMenu->IsItemEnabled( pMenu->GetItemId( sal::static_int_cast< sal_uInt16 >(i) ) ) ||
                                             ( pMenu->GetItemType( sal::static_int_cast< sal_uInt16 >(i) ) == MENUITEM_SEPARATOR && bLastWasSeperator ) )
                                            nLogicalPos--;
                                        bLastWasSeperator = pMenu->GetItemType( sal::static_int_cast< sal_uInt16 >(i) ) == MENUITEM_SEPARATOR;
                                    }
                                }
                            }
                            pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)(nLogicalPos+1) );
                        }
                        break;
                    case RC_MenuIsSeperator:
                        {
                            if ( ValueOK( rtl::OString(), RcString( nMethodId ),nNr1,nItemCount) )
                                pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)(pMenu->GetItemType(nPhysicalIndex-1) == MENUITEM_SEPARATOR) );
                        }
                        break;
                    case RC_MenuIsItemChecked:
                        {
                            pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)pMenu->IsItemChecked(nNr1) );
                        }
                        break;
                    case RC_MenuIsItemEnabled:
                        {
                            pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)pMenu->IsItemEnabled(nNr1) );
                        }
                        break;
                    case RC_MenuGetItemText:
                        {
                            pRet->GenReturn ( RET_Value, nMethodId, (String)pMenu->GetItemText(nNr1) );
                        }
                        break;
                    case RC_MenuGetItemCommand:
                        {
                            pRet->GenReturn ( RET_Value, nMethodId, (String)pMenu->GetItemCommand(nNr1) );
                        }
                        break;
                    case RC_MenuHasSubMenu:
                        {
                            pRet->GenReturn ( RET_Value, nMethodId, (sal_Bool)(pMenu->GetPopupMenu(nNr1) != NULL) );
                        }
                        break;
                    case RC_MenuSelect:
                        {
                            if ( pMenu->GetPopupMenu(nNr1) )
                            {
                                if ( !aSubMenuId1 )
                                    aSubMenuId1 = nNr1;
                                else if ( !aSubMenuId2 )
                                    aSubMenuId2 = nNr1;
                                else if ( !aSubMenuId3 )
                                    aSubMenuId3 = nNr1;

                                if ( pPopup )
                                    pPopup->SelectEntry(nNr1);
                                else
                                    pMenuBar->SelectEntry(nNr1);
                            }
                            else
                            {
                                if ( pPopup )
                                {
                                    pPopup->EndExecute(nNr1);
                                    aSubMenuId1 = 0;
                                    aSubMenuId2 = 0;
                                    aSubMenuId3 = 0;
                                    pMenuWindow = NULL;
                                }
                                else
                                {
                                    pMenuBar->SelectEntry(nNr1);
                                    aSubMenuId1 = 0;
                                    aSubMenuId2 = 0;
                                    aSubMenuId3 = 0;
                                    pMenuWindow = NULL;
                                }
                            }
                        }
                        break;
                }
            }
            break;
        case RC_SetControlType:
            {
                DirectLog( S_QAError, GEN_RES_STR0( S_DEPRECATED ) );
            }
            break;
        case RC_Kill:
        case RC_RmDir:
        case RC_MkDir:
        case RC_FileCopy:
        case RC_Name:
        case RC_Dir:
        case RC_FileLen:
        case RC_FileDateTime:
            {
                long nErrorcode = FSYS_ERR_OK;
                switch ( nMethodId )
                {
                    case RC_Kill:
                        {
                            DirEntry aFile( aString1 );
                            nErrorcode = aFile.GetError();
                            if ( FSYS_ERR_OK == nErrorcode && FileStat( aFile ).IsKind( FSYS_KIND_FILE ) )
                                nErrorcode = aFile.Kill();
                            else
                                nErrorcode = FSYS_ERR_NOTAFILE;
                        }
                        break;
                    case RC_RmDir:
                        {
                            DirEntry aDir( aString1 );
                            nErrorcode = aDir.GetError();
                            if ( FSYS_ERR_OK == nErrorcode && FileStat( aDir ).IsKind( FSYS_KIND_DIR ) )
                                nErrorcode = aDir.Kill();
                            else
                                nErrorcode = FSYS_ERR_NOTADIRECTORY;
                        }
                        break;
                    case RC_MkDir:
                        {
                            DirEntry aDir( aString1 );
                            nErrorcode = aDir.GetError();
                            if ( !nErrorcode && !aDir.MakeDir() )
                                nErrorcode = FSYS_ERR_UNKNOWN;
//  Workaround für Bug 60693
//                              nErrorcode = aDir.GetError();
                        }
                        break;
                    case RC_FileCopy:
                        {
                            nErrorcode = DirEntry( aString1 ).CopyTo( DirEntry( aString2 ), FSYS_ACTION_COPYFILE );
                        }
                        break;
                    case RC_Name:
                        {
                            nErrorcode = DirEntry( aString1 ).MoveTo( DirEntry( aString2 ) );
                        }
                        break;
                    case RC_Dir:
                        {

                            String aPath;
                            sal_uInt16 nDirFlags = 0;
// from basic/source/inc/runtime.hxx
#define Sb_ATTR_NORMAL          0x0000
#define Sb_ATTR_HIDDEN          0x0002
#define Sb_ATTR_SYSTEM          0x0004
#define Sb_ATTR_VOLUME          0x0008
#define Sb_ATTR_DIRECTORY       0x0010
#define Sb_ATTR_ARCHIVE         0x0020
                            // copied from Basic and adapted  basic/source/runtime/methods.cxx Revision 1.54
                            if ( (nParams & PARAM_STR_1) )
                            {
                                delete pDir;
                                pDir = NULL; // wg. Sonderbehandlung Sb_ATTR_VOLUME
                                DirEntry aEntry( aString1 );
                                FileStat aStat( aEntry );
                                if(!aStat.GetError() && (aStat.GetKind() & FSYS_KIND_FILE))
                                {
                                    // OK, only a filename
                                    // cut off path (VB4)
                                    aPath = aEntry.GetName();
                                }
                                else
                                {
                                    sal_uInt16 nFlags = 0;
                                    if ( (nParams & PARAM_USHORT_1) )
                                        nDirFlags = nFlags = nNr1;
                                    else
                                        nDirFlags = nFlags = Sb_ATTR_HIDDEN | Sb_ATTR_SYSTEM | Sb_ATTR_DIRECTORY;

                                    // Nur diese Bitmaske ist unter Windows erlaubt
                                    // Sb_ATTR_VOLUME wird getrennt gehandelt
                                    if( nDirFlags & Sb_ATTR_VOLUME )
                                        aPath = aEntry.GetVolume();
                                    else
                                    {
                                        // Die richtige Auswahl treffen
                                        sal_uInt16 nMode = FSYS_KIND_FILE;
                                        if( nFlags & Sb_ATTR_DIRECTORY )
                                            nMode |= FSYS_KIND_DIR;
                                        if( nFlags == Sb_ATTR_DIRECTORY )
                                            nMode = FSYS_KIND_DIR;
                                        pDir = new Dir( aEntry, (DirEntryKind) nMode );
                                        nErrorcode = pDir->GetError();
                                        nDirPos = 0;
                                    }
                                }
                            }

                            if( pDir )
                            {
                                for( ;; )
                                {
                                    if( nDirPos >= pDir->Count() )
                                    {
                                        delete pDir;
                                        pDir = NULL;
                                        aPath.Erase();
                                        break;
                                    }
                                    DirEntry aNextEntry=(*(pDir))[nDirPos++];
                                    aPath = aNextEntry.GetName(); //Full();
                                    break;
                                }
                            }
                            if ( !nErrorcode )
                            {
                                pRet->GenReturn ( RET_Value, nMethodId, aPath );
                            }

/* keep old Implementation for now
                            // neues Verzeichnis einlesen
                            if ( (nParams & PARAM_STR_1) )
                            {
                                if ( pDir )
                                {
                                    delete pDir;
                                    pDir = NULL;
                                }
                                DirEntryKind aDirEntryKind = FSYS_KIND_FILE | FSYS_KIND_DIR;
                                if ( (nParams & PARAM_USHORT_1) && nNr1 )
                                {
                                    if ( nNr1 & 16 )
                                        aDirEntryKind = FSYS_KIND_DIR;
                                    else
                                        ReportError( GEN_RES_STR0( S_SELECTION_BY_ATTRIBUTE_ONLY_DIRECTORIES ) );
                                }

                                DirEntry aEntry( aString1 );
                                nErrorcode = aEntry.GetError();
                                if ( !nErrorcode )
                                {
                                    nDirPos = 0;
                                    FileStat aFS( aEntry );
                                    if ( !aFS.IsKind( FSYS_KIND_WILD ) && !aFS.IsKind( FSYS_KIND_DIR ) && aEntry.Exists() )
                                    {   // Sonderbehandlung für genau einen Eintrag
                                        if ( !aFS.IsKind( FSYS_KIND_DIR ) && ( aDirEntryKind == FSYS_KIND_DIR ) )
                                            pRet->GenReturn ( RET_Value, nMethodId, String() );
                                        else
                                            pRet->GenReturn ( RET_Value, nMethodId, (String)(aEntry.GetName()) );

                                        break;
                                    }
                                    else
                                    {
                                        pDir = new Dir( aEntry, aDirEntryKind );
                                        nErrorcode = pDir->GetError();
                                    }
                                }
                            }

                            if ( !pDir )
                                pDir = new Dir;

                            if ( !nErrorcode && ValueOK( nMethodId, GEN_RES_STR0( S_NO_MORE_FILES ), nDirPos+1, pDir->Count()+1 ) )
                            {
                                if ( nDirPos == pDir->Count() )
                                    pRet->GenReturn ( RET_Value, nMethodId, String() );
                                else
                                    pRet->GenReturn ( RET_Value, nMethodId, (String)((*pDir)[ nDirPos ].GetName()) );
                                nDirPos++;
                            }*/
                        }
                        break;
                    case RC_FileLen:
                        {
                            DirEntry aFile( aString1 );
                            nErrorcode = aFile.GetError();
                            if ( FSYS_ERR_OK == nErrorcode )
                            {
                                FileStat aFS( aFile );
                                pRet->GenReturn ( RET_Value, nMethodId, static_cast<comm_ULONG>(aFS.GetSize()) ); //GetSize() sal_uLong != comm_ULONG on 64bit
                                nErrorcode = aFS.GetError();
                            }
                        }
                        break;
                    case RC_FileDateTime:
                        {
                            DirEntry aFile( aString1 );
                            nErrorcode = aFile.GetError();
                            if ( FSYS_ERR_OK == nErrorcode )
                            {
                                FileStat aStat( aFile );
                                Time aTime( aStat.TimeModified() );
                                Date aDate( aStat.DateModified() );
                                nErrorcode = aStat.GetError();

                                double fSerial = (double)( aDate - Date(30,12,1899) );
                                long nSeconds = aTime.GetHour();
                                nSeconds *= 3600;
                                nSeconds += aTime.GetMin() * 60;
                                nSeconds += aTime.GetSec();
                                double nDays = ((double)nSeconds) / (double)(24.0*3600.0);
                                fSerial += nDays;

                                SbxValueRef xValue = new SbxValue( SbxDATE );
                                xValue->PutDate( fSerial );

                                pRet->GenReturn ( RET_Value, nMethodId, *xValue );
                            }
                        }
                        break;
                }
                switch ( nErrorcode )
                {
                    case FSYS_ERR_OK:
                        break;
                    case FSYS_ERR_MISPLACEDCHAR:
                        {
                            ReportError( CUniString("MISPLACEDCHAR") );
                        }
                        break;
                    case FSYS_ERR_INVALIDCHAR:
                        {
                            ReportError( CUniString("INVALIDCHAR") );
                        }
                        break;
                    case FSYS_ERR_NOTEXISTS:
                        {
                            ReportError( CUniString("NOTEXISTS") );
                        }
                        break;
                    case FSYS_ERR_ALREADYEXISTS:
                        {
                            ReportError( CUniString("ALREADYEXISTS") );
                        }
                        break;
                    case FSYS_ERR_NOTADIRECTORY:
                        {
                            ReportError( CUniString("NOTADIRECTORY") );
                        }
                        break;
                    case FSYS_ERR_NOTAFILE:
                        {
                            ReportError( CUniString("NOTAFILE") );
                        }
                        break;
                    case FSYS_ERR_INVALIDDEVICE:
                        {
                            ReportError( CUniString("INVALIDDEVICE") );
                        }
                        break;
                    case FSYS_ERR_ACCESSDENIED:
                        {
                            ReportError( CUniString("ACCESSDENIED") );
                        }
                        break;
                    case FSYS_ERR_LOCKVIOLATION:
                        {
                            ReportError( CUniString("LOCKVIOLATION") );
                        }
                        break;
                    case FSYS_ERR_VOLUMEFULL:
                        {
                            ReportError( CUniString("VOLUMEFULL") );
                        }
                        break;
                    case FSYS_ERR_ISWILDCARD:
                        {
                            ReportError( CUniString("ISWILDCARD") );
                        }
                        break;
                    case FSYS_ERR_NOTSUPPORTED:
                        {
                            ReportError( CUniString("NOTSUPPORTED") );
                        }
                        break;
                    case FSYS_ERR_UNKNOWN:
                        {
                            ReportError( CUniString("UNKNOWN") );
                        }
                        break;
                    default:
                        {
                            ReportError( CUniString("Not an FSYS Error") );
                        }
                }

            }
            break;
        case RC_TypeKeysDelay:
            {
                if( (nParams & PARAM_BOOL_1) )
                {
                    bDoTypeKeysDelay = bBool1;
                }
                else if( nParams & PARAM_USHORT_1 )
                {
                    nMinTypeKeysDelay = nNr1;
                    if( nParams & PARAM_USHORT_2 )
                        nMaxTypeKeysDelay = nNr2;
                    else
                        nMaxTypeKeysDelay = nMinTypeKeysDelay;
                }
                else
                    ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
            }
            break;
        case RC_GetMouseStyle:
            {
                Pointer aPointer;
//              if ( DragManager::GetDragManager() )
//                  aPointer = DragManager::GetDragManager()->GetDragPointer();
//              else
                {
                    Window *pActualWin = GetMouseWin();
                    if ( pActualWin )
                        aPointer = pActualWin->GetPointer();
                    else
                    {
                        ReportError( GEN_RES_STR1( S_POINTER_OUTSIDE_APPWIN, RcString( nMethodId ) ) );
                        aPointer = Pointer( POINTER_NULL );
                    }
                }
                pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)aPointer.GetStyle() );
            }
            break;
        case RC_UnpackStorage:
            {
                if( (nParams & PARAM_STR_1) )
                {
                    String aFileName( aString1 );
                    DirEntry aDestPath;
                    if( (nParams & PARAM_STR_2) )
                        aDestPath = DirEntry( aString2 );
                    else
                    {
                        aDestPath = DirEntry( aFileName );
                        aDestPath.SetExtension( CUniString( "plaintext" ) );
                    }

#if OSL_DEBUG_LEVEL > 1
                    sal_uInt16 nEntries = Dir( aDestPath, FSYS_KIND_FILE | FSYS_KIND_DIR ).Count();
                    (void) nEntries; /* avoid warning about unused parameter */
#endif
                    // The Count is only larger than 2 is the path is a directory which is not empty
                    // the Count of 2 results from the "." and ".." directory
                    if ( Dir( aDestPath, FSYS_KIND_FILE | FSYS_KIND_DIR ).Count() > 2 )
                        DirectLog( S_QAError, GEN_RES_STR1( S_DIRECTORY_NOT_EMPTY, aDestPath.GetFull() ) );

                    SotStorageRef xStorage = new SotStorage( aFileName, STREAM_STD_READ );
                    if ( xStorage->GetError() )
                        ReportError( GEN_RES_STR2(S_UNPACKING_STORAGE_FAILED, aFileName, aDestPath.GetFull()) );
                    else
                        UnpackStorage( xStorage, aDestPath );
                }
                else
                    ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
            }
            break;
        case RC_CloseSysDialog:
        case RC_ExistsSysDialog:
            {
                if( (nParams & PARAM_USHORT_1) )
                {
                    Reference < ::com::sun::star::util::XCancellable > xPicker;
                    switch( nNr1 )
                    {
                        case CONST_FilePicker:
                            {
                                xPicker.set( Reference < ::com::sun::star::util::XCancellable >( svt::GetTopMostFilePicker(), UNO_QUERY ) );
                            }
                            break;
                        case CONST_FolderPicker:
                            {
                                xPicker.set( Reference < ::com::sun::star::util::XCancellable >( svt::GetTopMostFolderPicker(), UNO_QUERY ) );
                            }
                            break;
                        default:
                            ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
                    }
                    switch( nMethodId )
                    {
                        case RC_CloseSysDialog:
                            {
                                if ( xPicker.is() )
                                    xPicker->cancel();
                                else
                                    ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
                            }
                            break;
                        case RC_ExistsSysDialog:
                            {
                                pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)xPicker.is() );
                            }
                            break;
                        default:
                            ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
                    }
                }
                else
                    ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
            }
            break;
        case RC_SAXCheckWellformed:
        case RC_SAXReadFile:

        case RC_SAXGetNodeType:
        case RC_SAXGetAttributeCount:
        case RC_SAXGetAttributeName:
        case RC_SAXGetAttributeValue:
        case RC_SAXGetChildCount:
        case RC_SAXGetElementName:
        case RC_SAXGetChars:

        case RC_SAXSeekElement:
        case RC_SAXHasElement:
        case RC_SAXGetElementPath:

        case RC_SAXRelease:
            {
                HandleSAXParser();
            }
            break;
        case RC_RecordMacro:
            {
                if ( ! (nParams & PARAM_BOOL_1) )
                    bBool1 = sal_True;

                MacroRecorder::GetMacroRecorder()->SetActionRecord( bBool1 );
            }
            break;
        case RC_GetDocumentCount :
            {
                pRet->GenReturn ( RET_Value, nMethodId, (comm_USHORT)GetDocWinCount() );
            }
            break;
        case RC_ActivateDocument :
            {
                if( nParams & PARAM_USHORT_1 )
                {
                    if ( ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, GetDocWinCount() ) )
                    {
                        Window* pWin = GetDocWin( nNr1-1 );
                        if ( pWin )
                        {
                            pWin->ToTop();
                            pWin->GrabFocus();
                        }
                    }
                }
                else
                    ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
            }
            break;
        case RC_GetSystemLanguage :
            {
                pRet->GenReturn ( RET_Value, nMethodId, (comm_USHORT)Application::GetSettings().GetLanguage() );
            }
            break;
        case RC_CatchGPF :
            {
                if( (nParams & PARAM_BOOL_1) )
                    bCatchGPF = bBool1;
                else
                    bCatchGPF = sal_True;
            }
            break;
        case RC_IsProduct :
            {
                sal_Bool bIsProduct;
                #ifdef DBG_UTIL
                    bIsProduct = sal_False;
                #else
                    bIsProduct = sal_True;
                #endif
                pRet->GenReturn ( RET_Value, nMethodId, (sal_Bool)bIsProduct );
            }
            break;
        case RC_UsePostEvents :
            {
                if( (nParams & PARAM_BOOL_1) )
                    bUsePostEvents = bBool1;
                else
                    bUsePostEvents = sal_True;
            }
            break;
        default:
            ReportError( GEN_RES_STR1( S_UNKNOWN_COMMAND, RcString( nMethodId ) ) );
    }
    SendProfile( RcString(nMethodId) );
    delete this;
    return sal_True;
}


sal_Bool StatementCommand::UnpackStorage( SotStorageRef xStorage, DirEntry &aBaseDir )
{
    SvStorageInfoList aList;
    xStorage->FillInfoList( &aList );

    for( sal_uInt16 i = 0; i < aList.Count(); i++ )
    {
        SvStorageInfo& rInfo = aList.GetObject( i );
        String aName = rInfo.GetName();
        DirEntry aPath ( aBaseDir );
        aPath += DirEntry( aName );
        sal_Bool bIsStorage = xStorage->IsStorage( aName );
        if ( bIsStorage )
        {
            SotStorageRef xSubStorage = xStorage->OpenSotStorage( aName, STREAM_STD_READ );
                if ( xSubStorage->GetError() )
                {
                    ReportError( GEN_RES_STR2(S_UNPACKING_STORAGE_FAILED, aName, aPath.GetFull()) );
                    return sal_False;
                }
                UnpackStorage( xSubStorage, aPath );
        }
        else
        {
            if ( !aPath.MakeDir( sal_True ) )
            {
                ReportError( GEN_RES_STR1(S_CANNOT_CREATE_DIRECTORY, aPath.GetFull()) );
                return sal_False;
            }
            SotStorageStreamRef xStream = xStorage->OpenSotStream( aName, STREAM_STD_READ );
            SvFileStream aDestination( aPath.GetFull(), STREAM_STD_READWRITE | STREAM_TRUNC );
            (*xStream) >> aDestination;
            if ( aDestination.GetError() != ERRCODE_NONE )
            {
                ReportError( GEN_RES_STR2(S_UNPACKING_STORAGE_FAILED, aName, aPath.GetFull()) );
                return sal_False;
            }
            aDestination.Close();
        }
    }
    return sal_True;
}


// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

StatementControl::StatementControl( SCmdStream *pCmdIn, sal_uInt16 nControlIdType )
: StatementList()
, nNr1( 0 )
, nNr2( 0 )
, nNr3( 0 )
, nNr4( 0 )
, nLNr1( 0 )
, aString1()
, aString2()
, bBool1(sal_False)
, bBool2(sal_False)
{
    QueStatement( NULL );
    //HELPID BACKWARD (SIControl is no longer needed)
    if ( nControlIdType == SIControl )
    {
        comm_ULONG nId;
        pCmdIn->Read( nId );
        aUId = rtl::OString( nId );
        if ( nId == 0 )
            aUId = UID_ACTIVE;
        else
            ReportError( aUId, GEN_RES_STR1c( S_INTERNAL_ERROR, "using numeric HelpID from old Testtool" ) );
    }
    else if ( nControlIdType == SIStringControl )
    {
        String aId;
        pCmdIn->Read( aId );
        aUId = Str2Id( aId );
    }
    else
    {
        DBG_ERROR( "Wrong ControlType" );
    }

    pCmdIn->Read( nMethodId );
    pCmdIn->Read( nParams );

    if( nParams & PARAM_USHORT_1 )  pCmdIn->Read( nNr1 );
    if( nParams & PARAM_USHORT_2 )  pCmdIn->Read( nNr2 );
    if( nParams & PARAM_USHORT_3 )  pCmdIn->Read( nNr3 );
    if( nParams & PARAM_USHORT_4 )  pCmdIn->Read( nNr4 );
    if( nParams & PARAM_ULONG_1 )   pCmdIn->Read( nLNr1 );
    if( nParams & PARAM_STR_1 )     pCmdIn->Read( aString1 );
    if( nParams & PARAM_STR_2 )     pCmdIn->Read( aString2 );
    if( nParams & PARAM_BOOL_1 )    pCmdIn->Read( bBool1 );
    if( nParams & PARAM_BOOL_2 )    pCmdIn->Read( bBool2 );

#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Reading Control: UId: " );
    m_pDbgWin->AddText( Id2Str( aUId ) );
    m_pDbgWin->AddText( " Methode: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
    m_pDbgWin->AddText( " Params:" );
    if( nParams & PARAM_USHORT_1 )  {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
    if( nParams & PARAM_USHORT_2 )  {m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
    if( nParams & PARAM_USHORT_3 )  {m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
    if( nParams & PARAM_USHORT_4 )  {m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
    if( nParams & PARAM_ULONG_1 )   {m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
    if( nParams & PARAM_STR_1 )     {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
    if( nParams & PARAM_STR_2 )     {m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
/*    if( nParams & PARAM_BOOL_1 )    pCmdIn->Read( bBool1 );
    if( nParams & PARAM_BOOL_2 )    pCmdIn->Read( bBool2 );*/
    m_pDbgWin->AddText( "\n" );
#endif
}

sal_Bool IsDialog(Window *pWin)
{   // Alles was von SystemWindow abgeleitet ist
    if ( !pWin )
        return sal_False;

    switch (pWin->GetType())
    {
        case WINDOW_FLOATINGWINDOW:
        case WINDOW_DOCKINGWINDOW:
        case WINDOW_MODELESSDIALOG:
        case WINDOW_DIALOG:
        case WINDOW_MODALDIALOG:
        case WINDOW_WORKWINDOW:
        case WINDOW_TABDIALOG:

        case WINDOW_MESSBOX:
        case WINDOW_INFOBOX:
        case WINDOW_WARNINGBOX:
        case WINDOW_ERRORBOX:
        case WINDOW_QUERYBOX:
        case WINDOW_BUTTONDIALOG:
        case WINDOW_FILEDIALOG:
        case WINDOW_PRINTDIALOG:
        case WINDOW_PRINTERSETUPDIALOG:

// ab hier nicht ansprechbar (da nicht implementiert)
        case WINDOW_SYSWINDOW:
        case WINDOW_SYSTEMDIALOG:
        case WINDOW_COLORDIALOG:
        case WINDOW_FONTDIALOG:
        case WINDOW_PATHDIALOG:


            return sal_True;
//          break;
        default:
            return sal_False;
//          break;
    }
}


sal_Bool IsAccessable(Window *pWin)
{
    if ( pWin == NULL )
        return sal_False;

    return pWin->IsEnabled() && pWin->IsInputEnabled();
}



// neue Hilfsfunktion
static Window*ImpGetButton( Window *pBase, WinBits nMask, WinBits nWinBits )
{
    sal_uInt16 n = pBase->GetChildCount();
    for( sal_uInt16 i = 0 ; i < n; i++ ) {
        Window *pChild = pBase->GetChild(i);
        if(    pChild->GetType() == WINDOW_OKBUTTON
            || pChild->GetType() == WINDOW_CANCELBUTTON
            || pChild->GetType() == WINDOW_HELPBUTTON
            || pChild->GetType() == WINDOW_PUSHBUTTON )
            if( !nMask || ( pChild->GetStyle() & nMask ) == nWinBits )
                return pChild;
    }
    return NULL;
}

sal_Bool StatementControl::ControlOK( Window *pControl, const sal_Char* cBezeichnung )
{
    if ( pControl && ( ( ( IsAccessable(pControl) || (nMethodId & M_WITH_RETURN) ) &&
                         pControl->IsVisible() ) ||
                         aUId.equals( UID_ACTIVE ) ) )
        return sal_True;
    else
    {
        UniString aBezeichnung( cBezeichnung, RTL_TEXTENCODING_ASCII_US );
        if ( aBezeichnung.Len() > 0 )
        {
            if (!pControl)
                ReportError( aUId, GEN_RES_STR1( S_WIN_NOT_FOUND, aBezeichnung ) );
            else if ( !pControl->IsVisible() )
                ReportError( aUId, GEN_RES_STR1( S_WIN_INVISIBLE, aBezeichnung ) );
            else
                ReportError( aUId, GEN_RES_STR1( S_WIN_DISABLED, aBezeichnung ) );
        }
        #if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( aBezeichnung.AppendAscii(" NotFound or Disabled or Invisible") );
        #endif

        return sal_False;
    }
}


sal_Bool StatementList::ValueOK( rtl::OString aId, String aBezeichnung, sal_uLong nValue, sal_uLong nMax )
{

    if ( nMax < nValue )
    {
        if ( aBezeichnung.Len() > 0 )
            ReportError( aId, GEN_RES_STR3( S_NUMBER_TOO_BIG, aBezeichnung, UniString::CreateFromInt32( nValue ), UniString::CreateFromInt32( nMax ) ) );
        return sal_False;
    }
    if ( nValue < 1 )
    {
        if ( aBezeichnung.Len() > 0 )
            ReportError( aId, GEN_RES_STR3c3( S_NUMBER_TOO_SMALL, aBezeichnung, UniString::CreateFromInt32( nValue ), "1" ) );
        return sal_False;
    }
    return sal_True;
}

sal_uInt16 StatementList::GetCurrentMenues( PopupMenu *&pPopup, MenuBar *&pMenuBar, Menu *&pMenu )
{
    if ( WinPtrValid( pMenuWindow ) )
        pMenuBar = pMenuWindow->GetMenuBar();

    if ( pMenuBar )     // use MenuBar as base
        pMenu = pMenuBar;
    else        // use contextmenu as base
    {
        pMenu = PopupMenu::GetActivePopupMenu();
        pPopup = PopupMenu::GetActivePopupMenu();
    }

    if ( !pMenu )
        return 1;

    if ( aSubMenuId1 )
    {
        pPopup = pMenu->GetPopupMenu( aSubMenuId1 );
        pMenu = pPopup;
    }

    if ( pMenu && aSubMenuId2 )
    {
        pPopup = pMenu->GetPopupMenu( aSubMenuId2 );
        pMenu = pPopup;
    }

    if ( pMenu && aSubMenuId3 )
    {
        pPopup = pMenu->GetPopupMenu( aSubMenuId3 );
        pMenu = pPopup;
    }

    return 0;
}

void StatementControl::AnimateMouse( Window *pControl, TTHotSpots aWohin )
{
    Point aZiel;

    switch (aWohin)
    {
        case MitteLinks:
            {
                long nHeight = pControl->GetSizePixel().Height();
                aZiel.X() += 5;
                aZiel.Y() += nHeight / 2;
            }
            break;
        case Mitte:
            {
                Size aSize = pControl->GetOutputSizePixel();
                aZiel.Move( aSize.Width() / 2, aSize.Height() / 2 );
            }
            break;
        case MitteOben:
            {
                long nWidth = pControl->GetSizePixel().Width();
                aZiel.X() += nWidth / 2;
                aZiel.Y() += 5;
            }
            break;
    }
    AnimateMouse( pControl, aZiel );
}


void StatementControl::AnimateMouse( Window *pControl, Point aWohin )
{
    Point aAkt = pControl->GetPointerPosPixel();
    Point aZiel = aWohin;

    long nSteps;
    Point aDiff = aAkt - aZiel;

    if ( Abs(aDiff.X()) < Abs(aDiff.Y()) )
        nSteps = Abs(aDiff.Y()) / 5;
    else
        nSteps = Abs(aDiff.X()) / 5;
    if ( nSteps == 0 )
        return;

    aDiff *= 1000;
    aDiff /= nSteps;

    StatementList::bExecuting = sal_True;       // Bah ist das ein ekliger Hack
                                                // Das verhindert, daß schon der nächste Befehl ausgeführt wird.

    for ( ; nSteps ; nSteps-- )
    {
        if ( Abs((aAkt - pControl->GetPointerPosPixel()).X()) > 5 ||
             Abs((aAkt - pControl->GetPointerPosPixel()).Y()) > 5 )
            nSteps = 1;
        aAkt = aZiel + aDiff * nSteps / 1000;
        pControl->SetPointerPosPixel(aAkt);
        SafeReschedule();
    }
    pControl->SetPointerPosPixel(aZiel);
    StatementList::bExecuting = sal_False;  // Bah ist das ein ekliger Hack
}


sal_Bool StatementControl::MaybeDoTypeKeysDelay( Window *pTestWindow )
{
    if ( bDoTypeKeysDelay )
    {
        sal_uLong nTimeWait = nMinTypeKeysDelay;
        if ( nMaxTypeKeysDelay != nMinTypeKeysDelay )
            nTimeWait  += Time::GetSystemTicks() % ( nMaxTypeKeysDelay - nMinTypeKeysDelay );
        Timer aTimer;
        aTimer.SetTimeout( nTimeWait );
        aTimer.Start();
        StatementList::bExecuting = sal_True;       // Bah ist das ein ekliger Hack
                                                    // Das verhindert, daß schon der nächste Befehl ausgeführt wird.
        while ( aTimer.IsActive() )
        {
            SafeReschedule( sal_True );
        }
        StatementList::bExecuting = sal_False;  // Bah ist das ein ekliger Hack
        if ( !WinPtrValid(pTestWindow ) )
        {
            ReportError( aUId, GEN_RES_STR1( S_WINDOW_DISAPPEARED, MethodString( nMethodId ) ) );
            return sal_False;
        }
    }
    return sal_True;
}

sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
{
    if( pControl )      // Also auch bei Disabled nicht jedoch bei Invisible
    {
        switch( nMethodId )
        {
        case M_IsEnabled:
            pRet->GenReturn ( RET_Value, aUId, IsAccessable(pControl) );
            break;
        case M_IsVisible:
            pRet->GenReturn ( RET_Value, aUId, pControl->IsVisible() );
            break;
        case M_GetPosX:
            if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für FloatingWindows
            if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für TabDialoge
            if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für Border
            if ( (nParams & PARAM_BOOL_1) && bBool1 )
                pControl = pControl->GetWindow( WINDOW_OVERLAP );

            if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_SPLITWINDOW )
            {
                Point aPos = pControl->GetPosPixel();
                aPos = pControl->GET_REAL_PARENT()->OutputToScreenPixel( aPos );
                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)aPos.X() );
            }
            else
                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetPosPixel().X() );
            break;
        case M_GetPosY:
            if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für FloatingWindows
            if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für TabDialoge
            if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für Border
            if ( (nParams & PARAM_BOOL_1) && bBool1 )
                pControl = pControl->GetWindow( WINDOW_OVERLAP );

            if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_SPLITWINDOW )
            {
                Point aPos = pControl->GetPosPixel();
                aPos = pControl->GET_REAL_PARENT()->OutputToScreenPixel( aPos );
                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)aPos.Y() );
            }
            else
                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetPosPixel().Y() );
            break;
        case M_GetSizeX:
            if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für FloatingWindows
            if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für TabDialoge
            if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für Border
            if ( (nParams & PARAM_BOOL_1) && bBool1 )
                pControl = pControl->GetWindow( WINDOW_OVERLAP );

            pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetSizePixel().Width() );
            break;
        case M_GetSizeY:
            if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für FloatingWindows
            if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für TabDialoge
            if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
                pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für Border
            if ( (nParams & PARAM_BOOL_1) && bBool1 )
                pControl = pControl->GetWindow( WINDOW_OVERLAP );

            pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetSizePixel().Height() );
            break;
        case M_SnapShot:
            {
                if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
                    pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für FloatingWindows
                if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
                    pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für TabDialoge
                if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
                    pControl = pControl->GET_REAL_PARENT();     // Sonderbehandlung für Border
                if ( (nParams & PARAM_BOOL_1) && bBool1 )
                    pControl = pControl->GetWindow( WINDOW_OVERLAP );

                Bitmap aBmp = pControl->SnapShot();
                if ( pControl->GetType() == WINDOW_WORKWINDOW )
                {
                    Point aStart = pControl->GetPosPixel();
                    if ( !(nParams & PARAM_USHORT_4) )
                    {
                        nParams |= PARAM_USHORT_1;
                        nParams |= PARAM_USHORT_2;
                        nParams |= PARAM_USHORT_3;
                        nParams |= PARAM_USHORT_4;
                        nNr1 = (sal_uInt16)-aStart.X();
                        nNr2 = (sal_uInt16)-aStart.Y();
                        nNr3 = (sal_uInt16)pControl->GetSizePixel().Width() + 2*(sal_uInt16)aStart.X();
                        nNr4 = (sal_uInt16)pControl->GetSizePixel().Height() + 2*(sal_uInt16)aStart.Y();
                    }
                    nNr1 = std::max((sal_uInt16)-aStart.X(),nNr1);
                    nNr2 = std::max((sal_uInt16)-aStart.Y(),nNr2);
                    nNr3 = std::min((sal_uInt16)(pControl->GetSizePixel().Width() + 2*(sal_uInt16)aStart.X()),nNr3);
                    nNr4 = std::min((sal_uInt16)(pControl->GetSizePixel().Height() + 2*(sal_uInt16)aStart.Y()),nNr4);
                }
                if( nParams & PARAM_USHORT_4 )
                {   // Zuschneiden
                    Point aPt(-nNr1,-nNr2);
                    Size aSz(nNr3,nNr4);
                    VirtualDevice aVDev( *pControl );

                    aVDev.SetOutputSizePixel( aSz );
                    aVDev.DrawBitmap( aPt, aBmp );
                    aBmp = aVDev.GetBitmap( Point(), aSz );
                }

                SvFileStream fOut;
                fOut.Open(aString1,STREAM_STD_WRITE);
                WriteDIB(aBmp, fOut, true, true);
                if ( fOut.GetError() )
                    ReportError( aUId, GEN_RES_STR1( S_ERROR_SAVING_IMAGE, UniString::CreateFromInt32( fOut.GetError() ) ) );
                fOut.Close();
            }
            break;
        case M_GetFixedTextCount:
            {
                pRet->GenReturn ( RET_Value, aUId, CountWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True ) );
            }
            break;
        case M_GetFixedText:
            {
                if( ( nParams & PARAM_USHORT_1 ) == 0 )
                    nNr1 = 1;

                FixedText* pFixedText = (FixedText*)GetWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True, nNr1-1 );
                if ( pFixedText )
                    pRet->GenReturn ( RET_Value, aUId, pFixedText->GetText() );
                else
                    ValueOK(aUId, MethodString( nMethodId ),nNr1,CountWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True ) );
            }
            break;
        case M_HasFocus:
            {
                pRet->GenReturn ( RET_Value, aUId, pControl->HasFocus() );
            break;
            }
        case M_GetScreenRectangle:
            {
                Rectangle aRect =  bBool1 ? pControl->GetClientWindowExtentsRelative(NULL) : pControl->GetWindowExtentsRelative( NULL );
                pRet->GenReturn ( RET_Value, aUId,
                    UniString::CreateFromInt32(aRect.Left()).
                    AppendAscii(",").Append(UniString::CreateFromInt32(aRect.Top())).
                    AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetWidth())).
                    AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetHeight()))
                    );
            }
            break;
        case M_GetHelpText:
            {
                pRet->GenReturn ( RET_Value, aUId, pControl->GetHelpText());
            }
            break;
        case M_GetQuickHelpText:
            {
                pRet->GenReturn ( RET_Value, aUId,pControl->GetQuickHelpText());
            }
            break;
        default:
            return sal_False;
        }
        SendProfile( UIdString( aUId ).Append('.').Append( MethodString( nMethodId ) ) );
        return sal_True;
    }
    return sal_False;
}

sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
{
    switch( nMethodId )     // Diese können an jedem Window ausgeführt werden
    {
        case M_Exists:          // Oben schon behandelt. Unterdrückt hier nur Fehler
        case M_NotExists:
        case M_IsEnabled:
        case M_IsVisible:
        case M_SnapShot:
            break;
        case M_Caption :
            {
                if ( pControl->GetText().Len() == 0 && IsDocFrame( pControl->GetWindow( WINDOW_FRAME ) ) )
                    pRet->GenReturn ( RET_Value, aUId, pControl->GetWindow( WINDOW_FRAME )->GetText());
                else
                    pRet->GenReturn ( RET_Value, aUId, pControl->GetText());
            }
            break;
        case M_GetRT:
            {
                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetType() );
            }
            break;
        case M_TypeKeys:
            {
                if( !(nParams & PARAM_USHORT_1) )   // Anzahl Wiederholungen
                    nNr1 = 1;
                if( !(nParams & PARAM_BOOL_1) )     // Follow Focus
                    bBool1 = sal_False;     // so bleibt das bisherige Verhalten

                if ( !bBool1 )          // Altes Verhalten
                    pControl->GrabFocus();
                else    // If focus is not inside given control we grab it once.
                {
                    Window *pFocus = GetpApp()->GetFocusWindow();
                    if ( !pFocus || !pControl->IsWindowOrChild( pFocus, sal_True ) )
                        pControl->GrabFocus();
                }


                // maybe this can get removed since we are using GetPreferredKeyInputWindow()
                if ( pControl->GetType() == WINDOW_COMBOBOX )
                {   // Bei COMBOBOX an das Edit direkt liefern
                    Window *pTemp = NULL;
                    for ( sal_uInt16 i = 0 ; i < pControl->GetChildCount() && !pTemp ; i++ )
                        if ( pControl->GetChild( i )->GetType() == WINDOW_EDIT )
                            pTemp = pControl->GetChild( i );
                    if ( pTemp )
                        pControl = pTemp;
                }

                Window *pDeliverHere = pControl;
                for (int j = 0; j < nNr1; j++)
                    for (xub_StrLen i = 0; i < aString1.Len(); i++)
                    {
                        if ( StatementList::bUsePostEvents )
                        { // grab focus every time
                            Window *pFocus = GetpApp()->GetFocusWindow();
                            if ( !pFocus || !pControl->IsWindowOrChild( pFocus, sal_True ) )
                                pControl->GrabFocus();
                        }
                        if ( bBool1 ) // Jedesmal das FocusWindow finden
                        {
                            Window *pFocus = GetpApp()->GetFocusWindow();
                            if ( pFocus && pControl->IsWindowOrChild( pFocus, sal_True ) )
                                pDeliverHere = pFocus;
                            else // sonst Fallback auf das Basisfenster
                                pDeliverHere = pControl;
                        }
                        pDeliverHere = pDeliverHere->GetPreferredKeyInputWindow();
                        KeyEvent aEvent;
                        if ( ((sal_uInt16)aString1.GetChar(i)) <= 7 )
                        {
                            sal_uInt16 nVal = 0;
                            switch (aString1.GetChar(i))
                            {
                                case 1: nVal = aString1.GetChar(i+1) + (aString1.GetChar(i+2) << 8);
                                        i += 2;
                                        break;
                                case 3: nVal = (aString1.GetChar(i+1) << 8);
                                        i++;
                                        break;
                                case 5: nVal = aString1.GetChar(i+1);
                                        i++;
                                        break;
                                case 7: nVal = 0;
                                        break;
                            }
                            // #105672#
                            // find out the keycode
                            sal_uInt16 nKeygroup = nVal & KEYGROUP_TYPE;
                            sal_uInt16 nKeyCode = nVal & KEY_CODE;
                            sal_Unicode aCh;
                            switch (nKeygroup)
                            {
                                case KEYGROUP_NUM:
                                    aCh = nKeyCode - KEY_0 + '0';
                                    break;
                                case KEYGROUP_ALPHA:
                                    aCh = nKeyCode - KEY_A;
                                    if ( nVal & KEY_MOD1 )
                                    {}
                                    else if ( nVal & KEY_SHIFT )
                                        aCh += 'A';
                                    else
                                        aCh += 'a';
                                break;
                                case KEYGROUP_MISC:
                                    {                           //  CR  ESC TAB BACK
                                        ByteString aPrintableMisc("\x0d\x1b\x09\x08 **+-*/.,<>=",16);
                                        if ( nKeyCode-KEY_RETURN < aPrintableMisc.Len()
                                            && nKeyCode != KEY_INSERT && nKeyCode != KEY_DELETE )
                                            aCh = aPrintableMisc.GetChar( nKeyCode-KEY_RETURN );
                                        else
                                            aCh = 0;
                                    }
                                    break;
                                case KEYGROUP_CURSOR:
                                case KEYGROUP_FKEYS:
                                default:
                                    aCh = 0;
                            }
                            aEvent = KeyEvent(aCh,KeyCode(nVal & 0xFFF,nVal & 0xF000));
                        }
                        else
                        {
                                                            //   CR  ESC TAB BACK
                            String aPrintableMisc = CUniString("\x0d\x1b\x09\x08 xx+-*/.,<>=");
                            sal_Unicode aCh = aString1.GetChar(i);
                            if ( aCh >= 'a' && aCh <= 'z' )
                                aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_ALPHA + aCh-'a', 0));
                            else if ( aCh >= 'A' && aCh <= 'Z' )
                                aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_ALPHA + aCh-'a', KEY_SHIFT));
                            else if ( aCh >= '0' && aCh <= '9' )
                                aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_NUM + aCh-'0', 0));
                            else if ( aPrintableMisc.Search(aCh) != STRING_NOTFOUND )
                                aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_MISC + (sal_uInt16)aPrintableMisc.Search(aCh), 0));
                            else    // Sollte eigentlich nicht auftreten
                                aEvent = KeyEvent(aCh, KeyCode());
                        }
                        ImplKeyInput( pDeliverHere, aEvent );
                        if ( !MaybeDoTypeKeysDelay( pControl ) )
                            break;
                        else
                            SafeReschedule();SafeReschedule();SafeReschedule();
                    }
            }
            break;

#define CalcMouseButton\
    sal_uInt16 nButton = MOUSE_LEFT;\
    if ( (nParams & PARAM_USHORT_3) )\
    {\
        switch ( nNr3 )\
        {\
            case 1: nButton = MOUSE_LEFT; break;\
            case 2: nButton = MOUSE_MIDDLE; break;\
            case 3: nButton = MOUSE_RIGHT; break;\
        }\
    }\

        case M_MouseDown:
            {
                CalcMouseButton;
                Size aS = pControl->GetOutputSizePixel();
                Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
                Window *pActualWin = pControl->FindWindow( aPos );
//                  AnimateMouse( pControl, aPos );

                if ( pActualWin )
                    aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
//                  aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
                else
                    pActualWin = pControl;

                AnimateMouse( pActualWin, aPos );
                pActualWin->GrabFocus();
                MouseEvent aMEvnt(aPos,1,MOUSE_SIMPLECLICK|MOUSE_SELECT,nButton);
                ImplMouseButtonDown( pActualWin, aMEvnt );
            }
            break;
        case M_MouseUp:
            {
                CalcMouseButton;
                Size aS = pControl->GetOutputSizePixel();
                Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
                Window *pActualWin = pControl->FindWindow( aPos );

                if ( pActualWin )
                    aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
//                  aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
                else
                    pActualWin = pControl;

                AnimateMouse( pActualWin, aPos );
//                  pActualWin->GrabFocus();
                MouseEvent aMEvt( aPos, 1, MOUSE_SIMPLECLICK|MOUSE_SELECT, nButton );
                ImplMouseButtonUp( pActualWin, aMEvt );
            }
            break;
        case M_MouseMove:
            {
                CalcMouseButton;
                Size aS = pControl->GetOutputSizePixel();
                Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
                Window *pActualWin = pControl->FindWindow( aPos );

                if ( pActualWin )
                {
                    aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
//                  aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
                }
                else
                    pActualWin = pControl;

                AnimateMouse( pActualWin, aPos );
//                  pActualWin->GrabFocus();
                MouseEvent aMEvt( aPos, 0, MOUSE_SIMPLEMOVE|MOUSE_DRAGMOVE, nButton );
                ImplMouseMove( pActualWin, aMEvt );
            }
            break;
        case M_MouseDoubleClick:
            {
                CalcMouseButton;
                Size aS = pControl->GetOutputSizePixel();
                Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
                Window *pActualWin = pControl->FindWindow( aPos );

                if ( pActualWin )
                {
                    aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
//                  aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
                }
                else
                    pActualWin = pControl;

                AnimateMouse( pActualWin, aPos );
                pActualWin->GrabFocus();
                MouseEvent aMEvnt;
                aMEvnt = MouseEvent(aPos,1,MOUSE_SIMPLECLICK|MOUSE_SELECT,nButton);
                ImplMouseButtonDown( pActualWin, aMEvnt );
                ImplMouseButtonUp  ( pActualWin, aMEvnt );
                aMEvnt = MouseEvent(aPos,2,MOUSE_SIMPLECLICK|MOUSE_SELECT,nButton);
                ImplMouseButtonDown( pActualWin, aMEvnt );
                ImplMouseButtonUp  ( pActualWin, aMEvnt );
            }
            break;
        case M_DisplayPercent:
            {
                ModelessDialog *pDlg = new ModelessDialog(NULL);
                pDlg->SetOutputSizePixel(Size(100,30));

                Edit *pMyEd = new Edit(pDlg,WB_CENTER | WB_BORDER );
                pMyEd->SetSizePixel(Size(100,30));
                pDlg->SetText(UniString("Schließen", RTL_TEXTENCODING_ISO_8859_1));
                pDlg->Show();
                pMyEd->Show();
                sal_uLong nTime = Time().GetTime();

                while (pDlg->IsVisible())
                {
                    pDlg->ToTop();
                    for (int i = 1 ; i<10 ; i++)
                        SafeReschedule();
                    Point Pos = pControl->GetPointerPosPixel();
                    Size Siz=pControl->GetOutputSizePixel();
                    if ( Time().GetTime() - nTime > 10 )
                    {
                        nTime = Time().GetTime();
                        pMyEd->SetText(UniString::CreateFromInt32(Pos.X()*100/Siz.Width()).AppendAscii("%x").Append( UniString::CreateFromInt32(Pos.Y()*100/Siz.Height()) ).Append('%'));
                    }
                }

                delete pMyEd;
                delete pDlg;
            }
            break;
        case M_OpenContextMenu:
            {
                aSubMenuId1 = 0;
                aSubMenuId2 = 0;
                aSubMenuId3 = 0;
                pMenuWindow = NULL;
                Point aPos;
                ToolBox* pTB = (ToolBox*)pControl;
                if ( (pControl->GetType() == WINDOW_TOOLBOX) && pTB->IsMenuEnabled() )
                {
                    pTB->ExecuteCustomMenu();
/*                    Rectangle aRect = pTB->GetMenubuttonRect();
                    AnimateMouse( pControl, aRect.Center() );
                    MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
                    ImplMouseButtonDown( pTB, aMEvnt );*/
                }
                else
                {
                    sal_Bool bAtMousePos = ( nParams & PARAM_BOOL_1 ) && bBool1;
                    if ( bAtMousePos )
                    {
                        aPos = pControl->GetPointerPosPixel();
                        Window *pActualWin = pControl->FindWindow( aPos );

                        if ( pActualWin )
                        {
                            aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
    //                      aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
                            pControl = pActualWin;
                        }
                    }
                    CommandEvent aEvent( aPos, COMMAND_CONTEXTMENU, bAtMousePos );
                    ImplCommand( pControl, aEvent );
                }
            }
            break;
        case M_UseMenu:
            {
                aSubMenuId1 = 0;
                aSubMenuId2 = 0;
                aSubMenuId3 = 0;
                pMenuWindow = NULL;

                while ( pControl && !( ( pControl->GetType() == WINDOW_SYSWINDOW || pControl->GetType() == WINDOW_WORKWINDOW ) && ControlOK( pControl, "" ) ) )
                    pControl = pControl->GET_REAL_PARENT();

                if ( pControl && ((SystemWindow*)pControl)->GetMenuBar() )
                    pMenuWindow = ((SystemWindow*)pControl);
                else
                    ReportError( GEN_RES_STR1( S_NO_MENU, MethodString( nMethodId ) ) );
            }
            break;
        case M_FadeIn:
        case M_FadeOut:
        case M_Pin:
        case M_IsFadeIn:
        case M_IsPin:
            {
                WindowAlign aWindowAlign = WINDOWALIGN_LEFT;
                if ( (nParams & PARAM_USHORT_1) )
                {
                    switch ( nNr1 )
                    {
                        case CONST_ALIGN_LEFT:
                            aWindowAlign = WINDOWALIGN_LEFT;
                            break;
                        case CONST_ALIGN_TOP:
                            aWindowAlign = WINDOWALIGN_TOP;
                            break;
                        case CONST_ALIGN_RIGHT:
                            aWindowAlign = WINDOWALIGN_RIGHT;
                            break;
                        case CONST_ALIGN_BOTTOM:
                            aWindowAlign = WINDOWALIGN_BOTTOM;
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR1( S_INVALID_POSITION, MethodString( nMethodId ) ) );
                    }
                }

                Window* pTemp = NULL;
                while ( !pTemp && pControl )
                {
                    pTemp = GetFadeSplitWin( pControl, aWindowAlign );
                    pControl = pControl->GET_REAL_PARENT();
                }

                if ( !pTemp )
                {
                    ReportError( aUId, GEN_RES_STR1( S_SPLITWIN_NOT_FOUND, MethodString( nMethodId ) ) );
                    break;
                }

                pControl = pTemp;   // So daß wir unten ohne Fehler durchkommen
                SplitWindow *pSW = (SplitWindow*) pTemp;

//  Rectangle           GetAutoHideRect() const;
//  Rectangle           GetFadeInRect() const;
//  Rectangle           GetFadeOutRect() const;

                switch( nMethodId )
                {
                    case M_FadeIn:
                        if ( pSW->IsFadeInButtonVisible() )
                            pSW->FadeIn();
                        break;
                    case M_FadeOut:
                        if ( pSW->IsFadeOutButtonVisible() )
                            pSW->FadeOut();
                        break;
                    case M_Pin:
                        if (   ( pSW->GetAutoHideState() && bBool1 )
                            || ( !pSW->GetAutoHideState() && !bBool1 ) )
                        {
                            MouseEvent aMEvnt;
                            Point aPt( pSW->GetAutoHideRect().Center() );
                            aMEvnt = MouseEvent( aPt,1,MOUSE_SIMPLECLICK,MOUSE_LEFT );
                            ImplMouseButtonDown( pControl, aMEvnt, FORCE_DIRECT_CALL );
                            ImplMouseButtonUp  ( pControl, aMEvnt, FORCE_DIRECT_CALL );
                        }
//                              pSW->AutoHide();
                        break;
                    case M_IsFadeIn:
                        pRet->GenReturn ( RET_Value, aUId, pSW->IsFadeOutButtonVisible() );
                        break;
                    case M_IsPin:
                        pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)!pSW->GetAutoHideState() );
                        break;
                    default:
                        ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
                }
                SendProfile( UIdString( aUId ).Append('.').Append( MethodString( nMethodId ) ) );
            }
            break;
        case M_StatusGetText:
        case M_StatusIsProgress:
        case M_StatusGetItemCount:
        case M_StatusGetItemId:
            {
                StatusBar *pStatus = NULL;
                while ( !pStatus && pControl )
                {
                    pStatus = (StatusBar*)GetWinByRT( pControl, WINDOW_STATUSBAR, sal_True );
                    pControl = pControl->GET_REAL_PARENT();
                }

                if ( !pStatus )
                {
                    ReportError( aUId, GEN_RES_STR1( S_NO_STATUSBAR, MethodString( nMethodId ) ) );
                    break;
                }

                switch ( nMethodId )
                {
                    case M_StatusGetText:
                        {
                            if ( (nParams & PARAM_USHORT_1) )
                            {
                                if ( pStatus->AreItemsVisible() )
                                    pRet->GenReturn ( RET_Value, aUId, String(pStatus->GetItemText(nNr1)));
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_ITEMS_INVISIBLE, MethodString( nMethodId ) ) );
                            }
                            else
                            {
                                if ( pStatus->AreItemsVisible() )
                                {
                                    if ( pStatus->GetItemCount() == 1 )
                                    {
                                        pRet->GenReturn ( RET_Value, aUId, pStatus->GetItemText( pStatus->GetItemId(0) ));
                                    }
                                    else
                                    {
                                        pRet->GenReturn ( RET_Value, aUId, String() );
                                    }
                                }
                                else
                                    pRet->GenReturn ( RET_Value, aUId, (String)pStatus->GetText() );
                            }
                        }
                        break;
                    case M_StatusIsProgress:
                        {
                            pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)pStatus->IsProgressMode() );
                        }
                        break;
                    case M_StatusGetItemCount:
                        if ( pStatus->AreItemsVisible() )
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pStatus->GetItemCount()));
                        else
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
                        break;
                    case M_StatusGetItemId:
                        if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pStatus->GetItemCount()) )
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pStatus->GetItemId(nNr1-1)));
                        break;
                }
            }
            break;
        case M_HasScrollBar:
        case M_IsScrollBarEnabled:
            {
                if ( (nParams | PARAM_USHORT_1) != PARAM_USHORT_1 )     // so there are other params
                {
                    ReportError( aUId, GEN_RES_STR0( S_INVALID_PARAMETERS ) );
                    break;
                }

                if( !(nParams & PARAM_USHORT_1) )
                    nNr1 = CONST_ALIGN_RIGHT;       // default is right Scrollbar (vertical)

                if ( (nNr1 != CONST_ALIGN_RIGHT) && (nNr1 != CONST_ALIGN_BOTTOM) )
                {
                    ReportError( aUId, GEN_RES_STR1( S_INVALID_POSITION, MethodString( nMethodId ) ) );
                    break;
                }

                ScrollBar *pScroll = NULL;

                sal_uInt16 nSteps = 2;
                while ( !pScroll && pControl && nSteps-- )
                {
                    pScroll = GetScrollBar( pControl, nNr1, sal_True );
                    pControl = pControl->GET_REAL_PARENT();
                }

                switch ( nMethodId )
                {
                    case M_HasScrollBar:
                        {
                            if ( pScroll )
                                pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_True );
                            else
                                pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_False );
                        }
                        break;
                    case M_IsScrollBarEnabled:
                        {
                            if ( !pScroll )
                            {
                                ReportError( aUId, GEN_RES_STR1( S_NO_SCROLLBAR, MethodString( nMethodId ) ) );
                                break;
                            }
                            pRet->GenReturn ( RET_Value, aUId, pScroll->IsEnabled() );
                        }
                        break;
                }
            }
            break;
        default:
            return sal_False;
    }
    return sal_True;
}


sal_Bool StatementControl::Execute()
{
    Window *pControl;
    sal_Bool bStatementDone = sal_True;


    if ( IsError )
    {
        #if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "Skipping Window: " );
        m_pDbgWin->AddText( Id2Str( aUId ) );
        m_pDbgWin->AddText( " Method: " );
        m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
        m_pDbgWin->AddText( "\n" );
        #endif
        Advance();
        delete this;
        return sal_True;
    }

    InitProfile();
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "Executing Window: " );
    m_pDbgWin->AddText( Id2Str( aUId ) );
    m_pDbgWin->AddText( " Method: " );
    m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
    m_pDbgWin->AddText( "\n" );
#endif


    if ( aUId.equals( UID_ACTIVE ) )
        pControl = GetAnyActive();
    else
    {
        sal_Bool bSearchButtonOnToolbox = (nParams == PARAM_NONE) && ((M_Click == nMethodId) || (M_TearOff == nMethodId) || (M_IsEnabled == nMethodId) || (M_OpenMenu == nMethodId));
        bSearchButtonOnToolbox |= (nParams == PARAM_USHORT_1) && (M_GetState == nMethodId);
        if ( nMethodId == M_TypeKeys || nMethodId == M_MouseDown
            || nMethodId == M_MouseUp || nMethodId ==  M_MouseMove
            || nMethodId == M_SnapShot )
        {
            pControl = NULL;
            if ( /*(nMethodId == M_SnapShot || nMethodId == M_TypeKeys) &&*/ !pControl )
                pControl = SearchTree( aUId ,bSearchButtonOnToolbox );
        }
        else
            pControl = SearchTree( aUId ,bSearchButtonOnToolbox );
    }


    if ( pControl && pControl->GetType() == WINDOW_TOOLBOX )
    {
        if ( !aUId.equals( pControl->GetUniqueOrHelpId() ) )
        {   // Also wenn wir irgendwas auf einer Toolbox gefunden haben
            switch ( nMethodId )
            {
                case M_Click:
                case M_TearOff:
                case M_OpenMenu:
                case M_GetState:
                    break;
                case M_IsEnabled:
                    nMethodId = _M_IsEnabled;   // Umlabeln, da die Behandlung essentiell anders ist!
                    break;
                default:
                    pControl = NULL;
            }
        }
    }


    switch ( nMethodId )
    {
        case M_Exists:
        case M_NotExists:
            Time aT;
            sal_uInt16 aSeconds = aT.GetMin()*60+aT.GetSec();
            if ( !bBool2 )          // wurde im Konstruktor auf sal_False gesetzt
            {
                bBool2 = sal_True;
                nNr2 = aSeconds;
                if( !(nParams & PARAM_USHORT_1) )
                    nNr1 = 0;       // defaultmäßig sofort zurück
            }
            if ( aSeconds < nNr2 )          // Falls die Stunde umgesprungen ist
                aSeconds += 60*60;

            if ( /* !IsAccessable(pControl)#87019# */ !pControl || !pControl->IsVisible() )
                pControl = NULL;
            if ( ((nMethodId == M_Exists) && pControl) ||
                 ((nMethodId == M_NotExists) && !pControl) )
            {   // Wenn Bedingung erfüllt
                pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_True );
            }
            else
                if ( aSeconds <= nNr2 + nNr1 )      // Zeit ist noch nicht abgelaufen
                    return sal_False;
                else
                    pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_False );

            Advance();
            delete this;
            return sal_True;
//          break;
    }


    short nRT = 0;

    if( pControl )          // Das Fenster existiert irgendwo, kann aber auch hidden sein!
    {
        nRT = ImpGetRType( pControl );
#if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( "Type is: " );
        m_pDbgWin->AddText( String::CreateFromInt32( nRT ) );
        m_pDbgWin->AddText( "\n" );
#endif
    }

    if (   nRT == C_Window &&       // Search for WorkWindow to satisfy these commands
         ( nMethodId == M_Close
//      || nMethodId == M_Size
//      || nMethodId == M_Move
        || nMethodId == M_IsMax
        || nMethodId == M_IsMin
        || nMethodId == M_IsRestore
        || nMethodId == M_Minimize
        || nMethodId == M_Maximize
        || nMethodId == M_Restore ) )
    {
        Window* pNewControl = pControl;
        while ( pNewControl && pNewControl->GetType() != WINDOW_WORKWINDOW )
            pNewControl = pNewControl->GET_REAL_PARENT();

        if ( pNewControl )
        {
            pControl = pNewControl;
            nRT = C_WorkWin;
        }
    }


    if ( (!ControlOK( pControl, "" )) && ( nMethodId != M_SnapShot ) && (nRetryCount--))
    {
#if OSL_DEBUG_LEVEL > 1
        m_pDbgWin->AddText( CUniString("Reschedule command (").Append( UniString::CreateFromInt32(nRetryCount) ).AppendAscii(")\n") );
#endif
        return sal_False;
    }

    if( ControlOK( pControl, "" ) )
    {
        if ( nMethodId == M_OpenContextMenu && !bBool2 )
        {
            pControl->GrabFocus();  // to get asyncron focus on unix
            bBool2 = sal_True;
            return sal_False;
        }
        // TODO: handle GetFocus for all Methods and Windows like this (remove part below)
        //       See for impact of changed focus for HandleVisibleControls() (taking Snapshots might be different, possible exclude those methods)
        if (( (nRT == C_TreeListBox) && !bBool2 )
            && nMethodId != M_TypeKeys          // TypeKeys macht das selbst, falls eigenes Focushandling gewünscht
            && nMethodId != M_MouseDown
            && nMethodId != M_MouseUp
            && nMethodId != M_MouseMove
            /*&& nMethodId != M_MouseDoubleClick*/ )
        {
            if ( !pControl->HasFocus() )
            {
                pControl->GrabFocus();
                int i = 10;
                while ( i-- && !pControl->HasFocus() )    // reschedule a bit
                {
                    SafeReschedule();
                    if ( !WinPtrValid( pControl ) )
                        return sal_False;
                }
                if ( !pControl->HasFocus() )  // to get asynchronous focus
                {
                    bBool2 = sal_True;
                    return sal_False;
                }
            }
        }
    }

    Advance();

    if ( HandleVisibleControls( pControl ) )
    {
        delete this;
        return sal_True;
    }
    if( ControlOK( pControl, "Window/Control" ) )
    {
        if (((( nRT < C_TabPage && nRT > C_TabControl )
              || nRT == C_PatternBox
              || nRT == C_ToolBox
              || nRT == C_ValueSet
              || nRT == C_Control
              || nRT == C_TreeListBox
             )
            || nMethodId == M_OpenContextMenu )
            && nMethodId != M_TypeKeys          // TypeKeys macht das selbst, falls eigenes Focushandling gewünscht
            && nMethodId != M_MouseDown
            && nMethodId != M_MouseUp
            && nMethodId != M_MouseMove
            /*&& nMethodId != M_MouseDoubleClick*/ )
            pControl->GrabFocus();

/*  leads to problems because settext sets the text whereas typekeys adds to the text.
        if ( bDoTypeKeysDelay && nMethodId == M_SetText && ( nParams & PARAM_STR_1 ) )
        {   // Here the statement is bent to a TypeKeys
            nMethodId = M_TypeKeys;
            nParams = PARAM_BOOL_1 | PARAM_STR_1;
            bBool1 = sal_True;
            pControl->GrabFocus();
        }
*/
        if ( !HandleCommonMethods( pControl ) )
        {
            switch( nRT )
            {
                case C_TabControl:
                    switch( nMethodId )
                    {
                        case M_GetPageId:
                            if ( (nParams & PARAM_USHORT_1) )
                            {
                                if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((TabControl*)pControl)->GetPageCount() ) )
                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetPageId(nNr1-1));
                            }
                            else
                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetCurPageId());
                            break;
                        case M_GetPageCount:
                            pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetPageCount());
                            break;
                        case M_SetPageId:
                            if (((TabControl*)pControl)->GetCurPageId())
                                ((TabControl*)pControl)->DeactivatePage();
                            ((TabControl*)pControl)->SetCurPageId( nNr1 );
                            ((TabControl*)pControl)->ActivatePage();
                            break;
                        case M_SetPageNr:
                            if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((TabControl*)pControl)->GetPageCount() ) )
                            {
                                if (((TabControl*)pControl)->GetCurPageId())
                                    ((TabControl*)pControl)->DeactivatePage();
                                ((TabControl*)pControl)->SetCurPageId( ((TabControl*)pControl)->GetPageId( nNr1-1 ) );
                                ((TabControl*)pControl)->ActivatePage();
                            }
                            break;
                        case M_GetPage:
                            pRet->GenReturn ( RET_Value, aUId, Id2Str( ((TabControl*)pControl)->GetTabPage(((TabControl*)pControl)->GetCurPageId())->GetUniqueOrHelpId() ) );
                            break;
                        case M_SetPage :
                            {       // Due to local variables
                                TabControl *pTControl = ((TabControl*)pControl);
                                sal_uInt16 nActive = pTControl->GetCurPageId();
                                sal_uInt16 i,anz;
                                rtl::OString aID;
                                rtl::OString aWantedID;
                                //HELPID BACKWARD (No numbers please (remove PARAM_ULONG_1 part)
                                if ( (nParams & PARAM_ULONG_1) )
                                {
                                    //aWantedID = rtl::OString( nLNr1 );
                                    ReportError( aUId, GEN_RES_STR1c( S_INTERNAL_ERROR, "using numeric HelpID from old Testtool" ) );
                                }
                                else if ( (nParams & PARAM_STR_1) )
                                {
                                    aWantedID = Str2Id( aString1 );
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );

                                i = pTControl->GetPagePos( pTControl->GetCurPageId() );
                                for ( anz=0 ; anz < pTControl->GetPageCount() && !aID.equals( aWantedID ) ; anz++ )
                                {
                                    pTControl->SelectTabPage( pTControl->GetPageId(i) );
                                    /*if (pTControl->GetCurPageId())
                                        pTControl->DeactivatePage();
                                    pTControl->SetCurPageId( pTControl->GetPageId(i) );
                                    pTControl->ActivatePage();*/
                                    aID = pTControl->GetTabPage(pTControl->GetCurPageId())->GetUniqueOrHelpId();
                                    i++;
                                    if ( i >= pTControl->GetPageCount() )
                                        i = 0;
                                    if ( !MaybeDoTypeKeysDelay( pTControl ) || !MaybeDoTypeKeysDelay( pTControl ) || !MaybeDoTypeKeysDelay( pTControl ) )   // Call up 3 times
                                        break;
                                }
                                if ( !aID.equals( aWantedID ) )
                                {
                                    pTControl->SelectTabPage( nActive );
                                    /*if (pTControl->GetCurPageId())
                                        pTControl->DeactivatePage();
                                    pTControl->SetCurPageId( nActive );
                                    pTControl->ActivatePage();*/
                                    ReportError( aWantedID, GEN_RES_STR1( S_TABPAGE_NOT_FOUND, MethodString( nMethodId ) ) );
                                }
                            }
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TabControl" ) );
                            break;
                    }
                    break;
                case C_RadioButton:
                case C_ImageRadioButton:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteLinks);
                            break;
                        case M_IsChecked :
                            pRet->GenReturn ( RET_Value, aUId, ((RadioButton*)pControl)->IsChecked());
                            break;
                        case M_Check :
                            ((RadioButton*)pControl)->Check();
                            ((RadioButton*)pControl)->Click();
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RadioButton" ) );
                            break;
                    }
                    break;
                case C_CheckBox:
                case C_TriStateBox:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteLinks);
                            break;
                        case M_IsChecked :
                            pRet->GenReturn ( RET_Value, aUId, comm_BOOL( ((TriStateBox*)pControl)->GetState() == STATE_CHECK) );
                            break;
                        case M_IsTristate :
                            pRet->GenReturn ( RET_Value, aUId, comm_BOOL( ((TriStateBox*)pControl)->GetState() == STATE_DONTKNOW) );
                            break;
                        case M_GetState :
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((TriStateBox*)pControl)->GetState()));
                            break;
                        case M_Check :
                            ((TriStateBox*)pControl)->SetState( STATE_CHECK );
                            ((TriStateBox*)pControl)->Click();
                            break;
                        case M_UnCheck :
                            ((TriStateBox*)pControl)->SetState( STATE_NOCHECK );
                            ((TriStateBox*)pControl)->Click();
                            break;
                        case M_TriState :
                            if ( ((TriStateBox*)pControl)->IsTriStateEnabled() )
                            {
                                ((TriStateBox*)pControl)->SetState( STATE_DONTKNOW );
                                ((TriStateBox*)pControl)->Click();
                            }
                            else
                            {
                                ReportError( aUId, GEN_RES_STR0( S_TRISTATE_NOT_ALLOWED ) );
                            }
                            break;
                        case M_Click :
                            {
                                TriStateBox *pTB = ((TriStateBox*)pControl);
                                if ( pTB->GetState() == STATE_NOCHECK )
                                    pTB->SetState( STATE_CHECK );
                                else if ( pTB->GetState() == STATE_CHECK )
                                {
                                    if ( pTB->IsTriStateEnabled() )
                                        pTB->SetState( STATE_DONTKNOW );
                                    else
                                        pTB->SetState( STATE_NOCHECK );
                                }
                                else
                                    pTB->SetState( STATE_NOCHECK );
                                pTB->Click();
                                }
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TriStateBox" ) );
                            break;
                    }
                    break;
                case C_Edit:
                case C_MultiLineEdit:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, Mitte);
                            break;
                        case M_GetText :
                            pRet->GenReturn ( RET_Value, aUId, ((Edit*)pControl)->GetText());
                            break;
                        case M_IsWritable:
                            pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((Edit*)pControl)->IsReadOnly() );
                            break;
                        default:
                            if ( ! ((Edit*)pControl)->IsReadOnly() )
                            {
                                switch( nMethodId )
                                {
                                    case M_SetText :
                                        ((Edit*)pControl)->SetText( aString1 );
                                        if ( nRT == C_MultiLineEdit )   // since SetModifyFlag is not virtual we have to do this
                                            ((MultiLineEdit*)pControl)->SetModifyFlag();
                                        else
                                            ((Edit*)pControl)->SetModifyFlag();
                                        ((Edit*)pControl)->Modify();
                                        if ( ((Edit*)pControl)->GetText().CompareTo(aString1) != COMPARE_EQUAL )
                                            ReportError( aUId, GEN_RES_STR1( S_ERROR_IN_SET_TEXT, MethodString( nMethodId ) ) );
                                        break;
                                    default:
                                        ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "(MultiLine)Edit" ) );
                                        break;
                                }
                            }
                            else
                                ReportError( aUId, GEN_RES_STR1c( S_ATTEMPT_TO_WRITE_READONLY, "(MultiLine)Edit" ) );
                    }
                    break;
                case C_MultiListBox:
                case C_ListBox:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        case M_GetSelCount :
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetSelectEntryCount()));
                            break;
                        case M_GetSelIndex :
                            if ( ! (nParams & PARAM_USHORT_1) )
                            {
                                if ( ((ListBox*)pControl)->GetSelectEntryCount() == 0 )
                                {
                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
                                    break;
                                }
                                nNr1 = 1;
                            }
                            ValueOK(aUId, MethodString( nMethodId ),nNr1,((ListBox*)pControl)->GetSelectEntryCount());
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetSelectEntryPos(nNr1-1)) +1);
                            break;
                        case M_GetSelText :
                            if ( ! (nParams & PARAM_USHORT_1) )
                                nNr1 = 1;
                            pRet->GenReturn ( RET_Value, aUId, ((ListBox*)pControl)->GetSelectEntry(nNr1-1));
                            break;
                        case M_GetItemCount :
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetEntryCount()));
                            break;
                        case M_GetItemText :
                            pRet->GenReturn ( RET_Value, aUId, ((ListBox*)pControl)->GetEntry(nNr1-1));
                            break;
                        case M_Select:
                        case M_MultiSelect:
                            {
                                sal_Bool bUnselectBeforeSelect = ( nMethodId == M_Select );
                                sal_Bool bFehler = sal_False;
                                if ( ! (nParams & PARAM_BOOL_1) )
                                    bBool1 = sal_True;

                                if ( nMethodId == M_MultiSelect && nRT == C_ListBox )
                                {
                                    ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ListBox" ) );
                                    bFehler = sal_True;
                                }

                                if ( !bBool1 && nMethodId == M_Select )
                                {
                                    ReportError( aUId, GEN_RES_STR1( S_NO_SELECT_FALSE, MethodString( nMethodId ) ) );
                                    bFehler = sal_True;
                                }

                                if ( !bFehler )
                                {
                                    if( nParams & PARAM_STR_1 )
                                    {
                                        ListBox *pLB = ((ListBox*)pControl);
                                        sal_uInt16 nPos;
                                        if ( (nPos = pLB->GetEntryPos( aString1 )) == LISTBOX_ENTRY_NOTFOUND )
                                            ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
                                        else
                                        {
                                            if ( bUnselectBeforeSelect )
                                                pLB->SetNoSelection();
                                            pLB->SelectEntryPos( nPos, bBool1 );
                                            if ( pLB->IsEntryPosSelected( nPos ) ? !bBool1 : bBool1 )   // XOR into with BOOL
                                                ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), aString1 ) );
                                        }
                                    }
                                    else
                                    {
                                        ListBox *pLB = ((ListBox*)pControl);
                                        pLB = static_cast<ListBox*>(pControl);
                                        if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pLB->GetEntryCount()) )
                                        {
                                            if ( bUnselectBeforeSelect )
                                                pLB->SetNoSelection();
                                            pLB->SelectEntryPos( nNr1-1, bBool1 );
                                            if ( pLB->IsEntryPosSelected( nNr1-1 ) ? !bBool1 : bBool1 ) // XOR into with BOOL
                                                ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), UniString::CreateFromInt32( nNr1 ) ) );
                                        }
                                    }
                                    ((ListBox*)pControl)->Select();
                                }
                            }
                            break;
                        case M_SetNoSelection :
                            ((ListBox*)pControl)->SetNoSelection();
                            ((ListBox*)pControl)->Select();
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "(Multi)ListBox" ) );
                            break;
                    }
                    break;
                case C_ComboBox:
                case C_PatternBox:
                case C_NumericBox:
                case C_MetricBox:
                case C_CurrencyBox:
                case C_DateBox:
                case C_TimeBox:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        case M_GetSelText :
                            pRet->GenReturn ( RET_Value, aUId, ((ComboBox*)pControl)->GetText());
                            break;
                        case M_GetSelIndex :
                            {
                                sal_uInt16 nPos = ((ComboBox*)pControl)->GetEntryPos(((ComboBox*)pControl)->GetText());
                                if ( nPos == COMBOBOX_ENTRY_NOTFOUND )
                                    nPos = 0;
                                else
                                    nPos++;
                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG) nPos);
                            }
                            break;
                        case M_GetItemCount :
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ComboBox*)pControl)->GetEntryCount()));
                            break;
                        case M_GetItemText :
                            pRet->GenReturn ( RET_Value, aUId, ((ComboBox*)pControl)->GetEntry(nNr1-1));
                            break;
                        case M_IsWritable:
                            pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((ComboBox*)pControl)->IsReadOnly() );
                            break;
                        case M_Select :
                            if( nParams & PARAM_USHORT_1 )
                            {
                                if ( !ValueOK(aUId, MethodString( nMethodId ),nNr1,((ComboBox*)pControl)->GetEntryCount()) )
                                    break;
                                aString1 = ((ComboBox*)pControl)->GetEntry(nNr1-1);
                            }
                            else
                            {
                                if ( ((ComboBox*)pControl)->GetEntryPos( aString1 ) == COMBOBOX_ENTRY_NOTFOUND )
                                {
                                    ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
                                    break;
                                }
                            }


                            ((ComboBox*)pControl)->SetText( aString1 );
                            ((ComboBox*)pControl)->SetModifyFlag();
                            ((ComboBox*)pControl)->Modify();
                            break;
                        case M_SetText :
                            if ( ! ((ComboBox*)pControl)->IsReadOnly() )
                            {
                                if ( ! (nParams & PARAM_STR_1) )
                                    aString1 = String();
                                ((ComboBox*)pControl)->SetText( aString1 );
                                ((ComboBox*)pControl)->SetModifyFlag();
                                ((ComboBox*)pControl)->Modify();
                            }
                            else
                                ReportError( aUId, GEN_RES_STR1c( S_ATTEMPT_TO_WRITE_READONLY, "ComboBox" ) );
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ComboBox" ) );
                            break;
                    }
                    break;
                case C_PushButton:
                case C_OkButton:
                case C_CancelButton:
                case C_ImageButton:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, Mitte);
                            break;
                        case M_Click :
                            ((PushButton*)pControl)->Click();
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "PushButton" ) );
                            break;
                    }
                    break;
                case C_MoreButton:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, Mitte);
                            break;
                        case M_IsOpen :
                            pRet->GenReturn ( RET_Value, aUId, ((MoreButton*)pControl)->GetState());
                            break;
                        case M_Click :
                            ((MoreButton*)pControl)->Click();
                            break;
                        case M_Open :
                            ((MoreButton*)pControl)->SetState(sal_True);
                            break;
                        case M_Close :
                            ((MoreButton*)pControl)->SetState(sal_False);
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MoreButton" ) );
                            break;
                    }
                    break;
                case C_SpinField:
                case C_PatternField:
                case C_NumericField:
                case C_MetricField:
                case C_CurrencyField:
                case C_DateField:
                case C_TimeField:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, Mitte);
                            break;
                        case M_GetText :
                            pRet->GenReturn ( RET_Value, aUId, ((SpinField*)pControl)->GetText());
                            break;
                        case M_IsWritable:
                            pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((SpinField*)pControl)->IsReadOnly() );
                            break;
                        case M_SetText :
                            if ( ! ((SpinField*)pControl)->IsReadOnly() )
                            {
                                ((SpinField*)pControl)->SetText( aString1 );
                                ((SpinField*)pControl)->SetModifyFlag();
                                ((SpinField*)pControl)->Modify();
                            }
                            else
                                ReportError( aUId, GEN_RES_STR1c( S_ATTEMPT_TO_WRITE_READONLY, "SpinField" ) );
                            break;
                        case M_More :
                            {
                                if ( !(nParams & PARAM_USHORT_1) )
                                    nNr1 = 1;
                                for (int i = 1; i<= nNr1; i++)
                                {
                                    ((SpinField*)pControl)->Up();
                                    ((SpinField*)pControl)->SetModifyFlag();
                                    ((SpinField*)pControl)->Modify();
                                }
                            }
                            break;
                        case M_Less :
                            {
                                if ( !(nParams & PARAM_USHORT_1) )
                                    nNr1 = 1;
                                for (int i = 1; i<= nNr1; i++)
                                {
                                    ((SpinField*)pControl)->Down();
                                    ((SpinField*)pControl)->SetModifyFlag();
                                    ((SpinField*)pControl)->Modify();
                                }
                            }
                            break;
                        case M_ToMin :
                            ((SpinField*)pControl)->First();
                            ((SpinField*)pControl)->SetModifyFlag();
                            ((SpinField*)pControl)->Modify();
                            break;
                        case M_ToMax :
                            ((SpinField*)pControl)->Last();
                            ((SpinField*)pControl)->SetModifyFlag();
                            ((SpinField*)pControl)->Modify();
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "SpinField" ) );
                            break;
                    }
                    break;

                case C_MenuButton:
                        switch( nMethodId )
                        {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, Mitte);
                            break;
                        case M_Click :
                            {
                                MouseEvent aMEvnt;
                                Point aPt( pControl->GetSizePixel().Width() / 2, pControl->GetSizePixel().Height() / 2 );
                                aMEvnt = MouseEvent( aPt,1,MOUSE_SIMPLECLICK,MOUSE_LEFT );
                                ImplMouseButtonDown( pControl, aMEvnt, FORCE_DIRECT_CALL );
                                ImplMouseButtonUp  ( pControl, aMEvnt, FORCE_DIRECT_CALL );
                            }
                            break;
                        case M_Open :
                        case M_OpenMenu :
                            {
                                MouseEvent aMEvnt;
                                Point aPt( pControl->GetSizePixel().Width() / 2, pControl->GetSizePixel().Height() / 2 );
                                aMEvnt = MouseEvent( aPt,1,MOUSE_SIMPLECLICK,MOUSE_LEFT );
                                ImplMouseButtonDown( pControl, aMEvnt, FORCE_DIRECT_CALL );

                                sal_uLong nStart = Time::GetSystemTicks();
                                sal_uLong nDelay = pControl->GetSettings().GetMouseSettings().GetActionDelay();
                                while ( ( Time::GetSystemTicks() - nStart ) < nDelay + 100 )
                                    SafeReschedule();

                                ImplMouseButtonUp  ( pControl, aMEvnt, FORCE_DIRECT_CALL );

                                aSubMenuId1 = 0;
                                aSubMenuId2 = 0;
                                aSubMenuId3 = 0;
                                pMenuWindow = NULL;
                            }
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MenuButton" ) );
                            break;
                    }
                    break;
                case C_ToolBox:
                    {
                        ToolBox *pTB = ((ToolBox*)pControl);
                        if ( !aUId.equals( pTB->GetUniqueOrHelpId() ) ) // So we found a Button on the ToolBox
                        {
                            if ( (nParams == PARAM_NONE) || (nParams == PARAM_USHORT_1) )
                            {           // We fake a parameter
                                nParams |= PARAM_STR_1;
                                aString1 = Id2Str( aUId );
                            }
                            else
                                ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
                        }

#define FIND_ITEM\
    sal_uInt16 nItemPos = 0;\
    sal_Bool bItemFound = sal_False;\
    {\
        rtl::OString aButtonId;\
        if( nParams & PARAM_STR_1 )\
            aButtonId = Str2Id( aString1 );\
        else\
            ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );\
        for ( nItemPos = 0; nItemPos < pTB->GetItemCount() && !aButtonId.equals(Str2Id( pTB->GetItemCommand(pTB->GetItemId(nItemPos)) )) &&\
                                                      !aButtonId.equals(pTB->GetHelpId(pTB->GetItemId(nItemPos))) ; nItemPos++ ) {}\
        bItemFound = aButtonId.equals(Str2Id( pTB->GetItemCommand(pTB->GetItemId(nItemPos)) )) || aButtonId.equals(pTB->GetHelpId(pTB->GetItemId(nItemPos)));\
        if ( !bItemFound )\
            ReportError( aUId, GEN_RES_STR1( S_HELPID_ON_TOOLBOX_NOT_FOUND, MethodString( nMethodId ) ) );\
        else\
        {\
            if ( !pTB->IsItemEnabled( pTB->GetItemId(nItemPos) ) && nMethodId != _M_IsEnabled && nMethodId != M_GetState )\
            {\
                ReportError( aUId, GEN_RES_STR1( S_BUTTON_DISABLED_ON_TOOLBOX, MethodString( nMethodId ) ) );\
                bItemFound = sal_False;\
            }\
            else if ( !pTB->IsItemVisible( pTB->GetItemId(nItemPos) ) && nMethodId != M_GetState )\
            {\
                ReportError( aUId, GEN_RES_STR1( S_BUTTON_HIDDEN_ON_TOOLBOX, MethodString( nMethodId ) ) );\
                bItemFound = sal_False;\
            }\
            else\
            {\
                if ( pTB->IsMenuEnabled() )\
                {   /* button is in Menu */\
                }\
                else\
                {   /* Try the multi line way */\
                    if ( pTB->GetItemRect(pTB->GetItemId(nItemPos)).IsEmpty() )\
                    {\
                        sal_uInt16 nLine = pTB->GetCurLine();\
                        do\
                        {\
                            pTB->ShowLine( sal_False );\
                            for ( int i = 1 ; i < 30 ; i++ )\
                                SafeReschedule();\
                        }\
                        while ( pTB->GetCurLine() != nLine && pTB->GetItemRect(pTB->GetItemId(nItemPos)).IsEmpty() );\
                        pTB->Invalidate( pTB->GetScrollRect() );\
                    }\
                    if ( pTB->GetItemRect(pTB->GetItemId(nItemPos)).IsEmpty() )\
                    {\
                        ReportError( aUId, GEN_RES_STR1( S_CANNOT_MAKE_BUTTON_VISIBLE_IN_TOOLBOX, MethodString( nMethodId ) ) );\
                        bItemFound = sal_False;\
                    }\
                }\
            }\
        }\
    }

                        switch( nMethodId )
                        {
                            case M_AnimateMouse :
                                AnimateMouse( pControl, MitteLinks);
                                break;
                            case M_Click :
                                {
                                    FIND_ITEM;
                                    if ( bItemFound )   // FIND_ITEM successful
                                    {
                                        Rectangle aRect = pTB->GetItemRect(pTB->GetItemId(nItemPos));
                                        if ( aRect.IsEmpty() )
                                        {
                                            pTB->ExecuteCustomMenu();
/*                                          aRect = pTB->GetMenubuttonRect();
                                            MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
                                            ImplMouseButtonDown( pTB, aMEvnt );*/

                                            aSubMenuId1 = 0;
                                            aSubMenuId2 = 0;
                                            aSubMenuId3 = 0;
                                            pMenuWindow = NULL;

                                            new StatementCommand( this, RC_MenuSelect, PARAM_USHORT_1, pTB->GetItemId(nItemPos) + TOOLBOX_MENUITEM_START );
                                        }
                                        else
                                        {
                                            aRect = pTB->GetItemRect(pTB->GetItemId(nItemPos));
                                            MouseEvent aMEvnt;
                                            aMEvnt = MouseEvent(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
                                            ImplMouseButtonDown( pTB, aMEvnt, FORCE_DIRECT_CALL );
                                            ImplMouseButtonUp  ( pTB, aMEvnt, FORCE_DIRECT_CALL );
                                        }
                                    }
                                }
                                break;
                            case M_TearOff :
                                {
                                    FIND_ITEM;
                                    if ( bItemFound )   // FIND_ITEM successful
                                    {
                                        Rectangle aRect = pTB->GetItemPosDropDownRect( nItemPos );
                                        AnimateMouse( pControl, aRect.Center() );
                                        MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
                                        ImplMouseButtonDown( pTB, aMEvnt, FORCE_DIRECT_CALL );

                                        Window *pWin = NULL;
                                        // Wait for the window to open.
                                        StatementList::bExecuting = sal_True;       // Bah, that's a nasty hack.
                                        {                                           // This prevents the next command from being executed.
                                            Time aDelay;
                                            while ( !pWin && ( (pWin = GetPopupFloatingWin()) == NULL ) && ( Time() - aDelay ).GetSec() < 15 )
                                                SafeReschedule();
                                        }
                                        StatementList::bExecuting = sal_False;  // Bah, that's a nasty hack.

                                        if ( pWin && pWin->GetType() == WINDOW_FLOATINGWINDOW )
                                        {
                                            aMEvnt = MouseEvent(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
                                            ImplMouseButtonUp( pTB, aMEvnt, FORCE_DIRECT_CALL );
                                            ((FloatingWindow*)pWin)->EndPopupMode( FLOATWIN_POPUPMODEEND_TEAROFF );
                                        }
                                        else
                                        {
                                            aMEvnt = MouseEvent(Point(1,-10), 1, MOUSE_SIMPLECLICK,MOUSE_LEFT);
                                            ImplMouseButtonUp( pTB, aMEvnt, FORCE_DIRECT_CALL );
                                            ReportError( aUId, GEN_RES_STR1( S_TEAROFF_FAILED, MethodString( nMethodId ) ) );
                                        }
                                    }
                                }
                                break;
                            case M_OpenMenu :
                                {
                                    FIND_ITEM;
                                    if ( bItemFound ) // FIND_ITEM successful
                                    {
                                        Rectangle aRect = pTB->GetItemPosDropDownRect( nItemPos );
                                        AnimateMouse( pControl, aRect.Center() );
                                        MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
                                        ImplMouseButtonDown( pTB, aMEvnt);
                                        ImplMouseButtonUp( pTB, aMEvnt);

                                        // The window is open
                                        aSubMenuId1 = 0;
                                        aSubMenuId2 = 0;
                                        aSubMenuId3 = 0;
                                        pMenuWindow = NULL;
                                    }
                                }
                                break;
                            case _M_IsEnabled:
                                {
                                    FIND_ITEM;
                                    if ( bItemFound ) // FIND_ITEM successful
                                    {
                                        pRet->GenReturn ( RET_Value, aUId, pTB->IsItemEnabled( pTB->GetItemId(nItemPos) ) );
                                    }
                                }
                                break;
                            case M_GetState :
                                {
                                    FIND_ITEM;
                                    if ( bItemFound ) // FIND_ITEM successful
                                    {
                                        if ( ValueOK( aUId, CUniString("GetState"), nNr1, 4 ) )
                                            switch (nNr1)
                                            {
                                            case 0:
                                                pRet->GenReturn ( RET_Value, aUId, Id2Str( pTB->GetHelpId(pTB->GetItemId(nItemPos)) ) );
                                                break;
                                            case 1:
                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemType(nItemPos));
                                                break;
                                            case 2:
                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemState(pTB->GetItemId(nItemPos)));
                                                break;
                                            case 3:
                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemId(nItemPos));
                                                break;
                                            case 11:
                                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG) nItemPos + 1);
                                                break;
                                            case 12:
                                                pRet->GenReturn ( RET_Value, aUId, Id2Str(pTB->GetHelpId())); // The toolbox's help id
                                                break;
                                            case 13:
                                            {
                                                Rectangle aRect = pTB->GetItemPosRect( nItemPos );
                                                Rectangle aTBRect = pTB->GetWindowExtentsRelative( NULL );
                                                pRet->GenReturn ( RET_Value, aUId,
                                                UniString::CreateFromInt32(aRect.Left()+aTBRect.Left()).
                                                    AppendAscii(",").Append(UniString::CreateFromInt32(aRect.Top()+aTBRect.Top())).
                                                    AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetWidth())).
                                                    AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetHeight()))
                                                );
                                                break;
                                            }
                                            default:
                                                ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
                                                break;
                                            }
                                    }
                                }
                                break;
                            case M_GetItemHelpText :
                                if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTB->GetItemCount() ))
                                    pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetHelpText(pTB->GetItemId(nNr1-1)));
                                break;
                            case M_GetItemQuickHelpText :
                                if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTB->GetItemCount() ))
                                    pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetQuickHelpText(pTB->GetItemId(nNr1-1)));
                                break;
                            case M_GetItemText2:
                                if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTB->GetItemCount() ))
                                    pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetItemText(pTB->GetItemId(nNr1-1)));
                                break;
                            case M_GetItemText :
                                pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetItemText(nNr1));
                                break;
                            case M_GetText :
                                pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetText());
                                break;
                            case M_GetItemCount :
                                pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemCount());
                                break;
                            case M_SetNextToolBox :
                                if ( (nParams & PARAM_STR_1) )
                                    pTB->SetNextToolBox( aString1 );
                                else
                                    pTB->SetNextToolBox( pTB->GetNextToolBox() );
                                pTB->NextToolBox();
                                break;
                            case M_GetNextToolBox :
                                pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetNextToolBox());
                                break;
                            case M_Dock :
                            case M_Undock :
                            case M_IsDocked :
                            case M_Close:
                            case M_Size:
                            case M_Move:
                            case M_IsMax:
                            case M_Minimize:
                            case M_Maximize:
                            case M_Help: // Everything to be treated below
                                goto DockingWin;
                            default:
                                ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ToolBox" ) );
                                break;
                        }
                    }
                    break;

                case C_TreeListBox:
                    switch( nMethodId )
                    {



#define GET_NTH_ENTRY_LBOX( First, Next, Anzahl)    \
    SvLBoxEntry *pThisEntry = ((SvTreeListBox*)pControl)->First(); \
    { \
        int niTemp = Anzahl; \
        while ( niTemp-- ) \
        { \
            pThisEntry = ((SvTreeListBox*)pControl)->Next( pThisEntry ); \
        } \
    }

                        case M_GetText :               // Get the first text of the given (default=1) line
                            {                          // should get removed some time
                                SvTreeListBox *pTree = (SvTreeListBox*)pControl;
                                SvLBoxEntry *pThisEntry = pTree->GetCurEntry();
                                if ( ! (nParams & PARAM_USHORT_1) )
                                    nNr1 = 1;
                                if ( pThisEntry )
                                {
                                    SvLBoxString* pItem = NULL;
                                    sal_uInt16 nValidTextItemCount = 0;
                                    {
                                        sal_uInt16 nIndex = 0;
                                        SvLBoxItem *pMyItem;
                                        while ( ( nValidTextItemCount < nNr1 ) && nIndex < pThisEntry->ItemCount() )
                                        {
                                            pMyItem = pThisEntry->GetItem( nIndex );
                                            if ( pMyItem->IsA() == SV_ITEM_ID_LBOXSTRING )
                                            {
                                                pItem = (SvLBoxString*)pMyItem;
                                                nValidTextItemCount++;
                                            }
                                            nIndex++;
                                        }
                                    }
                                    if ( ValueOK( aUId, CUniString("GetText"), nNr1, nValidTextItemCount ) )
                                        pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR2c2( S_NO_SELECTED_ENTRY, MethodString( nMethodId ), "TreeListBox" ) );
                            }
                            break;
                        case M_GetSelCount :
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetSelectionCount()));
                            break;
                        case M_GetItemCount :
                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetVisibleCount()) );
                            break;
                        case M_GetSelIndex :
                            if ( ! (nParams & PARAM_USHORT_1) )
                                nNr1 = 1;
                            if ( ValueOK(aUId, CUniString("GetSelIndex"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                            {
                                nNr1--;
                                GET_NTH_ENTRY_LBOX( FirstSelected, NextSelected, nNr1);
                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( ((SvTreeListBox*)pControl)->GetVisiblePos( pThisEntry )) +1 );
                            }
                            break;
                        case M_Select :
                            if ( ! (nParams & PARAM_BOOL_1) )
                                bBool1 = sal_True;
                            if( nParams & PARAM_STR_1 )
                            {
/*                                  ListBox *pLB = ((ListBox*)pControl);
                                if ( pLB->GetEntryPos( aString1 ) == LISTBOX_ENTRY_NOTFOUND )
                                    ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
                                else
                                {
                                    pLB->SelectEntry( aString1, bBool1 );
                                    if ( pLB->IsEntrySelected( aString1 ) ? !bBool1 : bBool1 )  // XOR rein mit BOOL
                                        ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), aString1 ) );
                                }
*/                                  ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
                            }
                            else
                            {
                                if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                {
                                    SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
                                    ((SvTreeListBox*)pControl)->Select ( pEntry, bBool1 );
                                }
                            }
                            break;
                        case M_Collapse :
                            if( nParams & PARAM_STR_1 )
                            {
                                ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
                            }
                            else
                            {
                                if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                {
                                    SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
                                    ((SvTreeListBox*)pControl)->Collapse ( pEntry );
                                }
                            }
                            break;
                        case M_Expand :
                            if( nParams & PARAM_STR_1 )
                            {
                                ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
                            }
                            else
                            {
                                if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                {
                                    SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
                                    ((SvTreeListBox*)pControl)->Expand ( pEntry );
                                }
                            }
                            break;
                        case M_GetSelText :
                            if ( ! (nParams & PARAM_USHORT_1) )
                                nNr1 = 1;
                            if ( ! (nParams & PARAM_USHORT_2) )
                                nNr2 = 1;
                            if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                            {
                                nNr1--;
                                GET_NTH_ENTRY_LBOX( FirstSelected, NextSelected, nNr1);
                                if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                {
                                    SvLBoxString* pItem = NULL;
                                    if ( ! (nParams & PARAM_USHORT_2) )
                                        pItem = (SvLBoxString*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
                                    else
                                    {
                                        SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
                                        if ( pMyItem->IsA() == SV_ITEM_ID_LBOXSTRING )
                                            pItem = (SvLBoxString*)pMyItem;
                                    }

                                    if ( pItem )
                                        pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
                                    else
                                        ReportError( aUId, GEN_RES_STR1( S_NO_LIST_BOX_STRING, MethodString( nMethodId ) ) );
                                }
                            }
                            break;
                        case M_GetItemText :
                            if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                            {
                                SvLBoxEntry *pThisEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
                                if ( ! (nParams & PARAM_USHORT_2) )
                                    nNr2 = 1;
                                if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                {
                                    SvLBoxString* pItem = NULL;
                                    if ( ! (nParams & PARAM_USHORT_2) )
                                        pItem = (SvLBoxString*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
                                    else
                                    {
                                        SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
                                        if ( pMyItem->IsA() == SV_ITEM_ID_LBOXSTRING )
                                            pItem = (SvLBoxString*)pMyItem;
                                    }

                                    if ( pItem )
                                        pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
                                    else
                                        ReportError( aUId, GEN_RES_STR1( S_NO_LIST_BOX_STRING, MethodString( nMethodId ) ) );
                                }
                            }
                            break;
                        case M_IsChecked :
                        case M_IsTristate :
                        case M_GetState :
                        case M_Check :
                        case M_UnCheck :
                        case M_TriState :
                            {
                                SvTreeListBox *pTree = (SvTreeListBox*)pControl;
                                SvLBoxEntry *pThisEntry = NULL;

                                if ( ! (nParams & PARAM_USHORT_1) )
                                {
                                    pThisEntry = pTree->GetCurEntry();
                                    if ( !pThisEntry )
                                        ReportError( aUId, GEN_RES_STR2c2( S_NO_SELECTED_ENTRY, MethodString( nMethodId ), "TreeListBox" ) );
                                }
                                else
                                {
                                    if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                    {
                                        pThisEntry = (SvLBoxEntry*)pTree->GetEntryAtVisPos( nNr1-1 );
                                    }
                                }

                                if ( ! (nParams & PARAM_USHORT_2) )
                                    nNr2 = 1;

                                if ( pThisEntry )
                                {
                                    if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                    {
                                        SvLBoxButton* pItem = NULL;
                                        if ( ! (nParams & PARAM_USHORT_2) )
                                            pItem = (SvLBoxButton*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXBUTTON );
                                        else
                                        {
                                            SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
                                            if ( pMyItem->IsA() == SV_ITEM_ID_LBOXBUTTON )
                                                pItem = (SvLBoxButton*)pMyItem;
                                        }

                                        if ( pItem )
                                        {
                                            switch( nMethodId )
                                            {
                                                case M_IsChecked :
                                                    pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pItem->IsStateChecked() ) );
                                                    break;
                                                case M_IsTristate :
                                                    pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pItem->IsStateTristate() ) );
                                                    break;
                                                case M_GetState :
                                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pItem->GetButtonFlags() & ~SV_STATE_MASK ));
                                                    break;
                                                case M_Check :
                                                    if ( !pItem->IsStateChecked() )
                                                    {
                                                        pItem->SetStateChecked();
                                                        pTree->CheckButtonHdl();
                                                        pTree->InvalidateEntry( pThisEntry );
                                                    }
                                                    break;
                                                case M_UnCheck :
                                                    if ( pItem->IsStateChecked() || pItem->IsStateTristate() )
                                                    {
                                                        pItem->SetStateUnchecked();
                                                        pTree->CheckButtonHdl();
                                                        pTree->InvalidateEntry( pThisEntry );
                                                    }
                                                    break;
                                                case M_TriState :
                                                    if ( !pItem->IsStateTristate() )
                                                    {
                                                        pItem->SetStateTristate();
                                                        pTree->CheckButtonHdl();
                                                        pTree->InvalidateEntry( pThisEntry );
                                                    }
                                                    break;
                                                default:
                                                    ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
                                                    break;
                                            }
                                        }
                                        else
                                            ReportError( aUId, GEN_RES_STR1( S_NO_LIST_BOX_BUTTON, MethodString( nMethodId ) ) );
                                    }
                                }
                            }
                            break;
                        case M_GetItemType :
                            {
                                SvTreeListBox *pTree = (SvTreeListBox*)pControl;
                                SvLBoxEntry *pThisEntry = NULL;

                                if ( ! (nParams & PARAM_USHORT_1) )
                                {
                                    pThisEntry = pTree->GetCurEntry();
                                    if ( !pThisEntry )
                                        ReportError( aUId, GEN_RES_STR2c2( S_NO_SELECTED_ENTRY, MethodString( nMethodId ), "TreeListBox" ) );
                                }
                                else
                                {
                                    if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                    {
                                        pThisEntry = (SvLBoxEntry*)pTree->GetEntryAtVisPos( nNr1-1 );
                                    }
                                }

                                if ( pThisEntry )
                                {
                                    if ( ! (nParams & PARAM_USHORT_2) )
                                        nNr2 = 1;
                                    if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
                                    {
                                        SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
                                        comm_USHORT nType;
                                        switch ( pMyItem->IsA() )
                                        {
                                            case SV_ITEM_ID_LBOXSTRING: nType = CONST_ItemTypeText ; break;
                                            case SV_ITEM_ID_LBOXBMP: nType = CONST_ItemTypeBMP ; break;
                                            case SV_ITEM_ID_LBOXBUTTON: nType = CONST_ItemTypeCheckbox ; break;
                                            case SV_ITEM_ID_LBOXCONTEXTBMP: nType = CONST_ItemTypeContextBMP ; break;
                                            default: nType = CONST_ItemTypeUnknown;
                                        }
                                        pRet->GenReturn ( RET_Value, aUId, nType );
                                    }
                                }
                            }
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TreeListBox" ) );
                            break;
                    }
                    break;
                case C_Control:
    {
                    sal_uInt16 nRealControlType = 0;
                    if ( dynamic_cast< EditBrowseBox* >(pControl) )
                        nRealControlType = CONST_CTBrowseBox;
                    else if ( dynamic_cast< ValueSet* >(pControl) )
                        nRealControlType = CONST_CTValueSet;
                    else if ( dynamic_cast< ORoadmap* >(pControl) )
                        nRealControlType = CONST_CTORoadmap;
                    else if ( dynamic_cast< IExtensionListBox* >(pControl) )
                        nRealControlType = CONST_CTIExtensionListBox;
                    else if ( dynamic_cast< ::svt::table::TableControl* >(pControl) )
                        nRealControlType = CONST_CTTableControl;
                    else
                        nRealControlType = CONST_CTUnknown;

                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        default:
                            switch( nRealControlType )
                            {
                                case CONST_CTBrowseBox:
                                    {
                                        EditBrowseBox* pEBBox = dynamic_cast< EditBrowseBox* >(pControl);
                                        switch( nMethodId )
                                        {

    /*
    sal_Bool            MakeFieldVisible( long nRow, sal_uInt16 nColId, sal_Bool bComplete = sal_False );
    // access to dynamic values of cursor row
    String          GetColumnTitle( sal_uInt16 nColumnId ) const;
    sal_uInt16          GetColumnId( sal_uInt16 nPos ) const;
    sal_uInt16          GetColumnPos( sal_uInt16 nColumnId ) const;
    // access and movement of cursor
    long            GetCurRow() const { return nCurRow; }
    sal_uInt16          GetCurColumnId() const { return nCurColId; }
    sal_Bool            GoToRow( long nRow );
    sal_Bool            GoToRowAndDoNotModifySelection( long nRow );
    sal_Bool            GoToColumnId( sal_uInt16 nColId );
    sal_Bool            GoToRowColumnId( long nRow, sal_uInt16 nColId );
    // selections
    void            SetNoSelection();
    void            SelectAll();
    void            SelectRow( long nRow, sal_Bool bSelect = sal_True, sal_Bool bExpand = sal_True );
    void            SelectColumnPos( sal_uInt16 nCol, sal_Bool bSelect = sal_True )
                        { SelectColumnPos( nCol, bSelect, sal_True); }
    void            SelectColumnId( sal_uInt16 nColId, sal_Bool bSelect = sal_True )
                        { SelectColumnPos( GetColumnPos(nColId), bSelect, sal_True); }
    long            GetSelectRowCount() const;
    sal_uInt16          GetSelectColumnCount() const;
    sal_Bool            IsRowSelected( long nRow ) const;
    sal_Bool            IsColumnSelected( sal_uInt16 nColumnId ) const;
    long            FirstSelectedRow( sal_Bool bInverse = sal_False );
    long            LastSelectedRow( sal_Bool bInverse = sal_False );
    long            PrevSelectedRow();
    long            NextSelectedRow();
    const MultiSelection* GetSelection() const
                    { return bMultiSelection ? uRow.pSel : 0; }
    void            SetSelection( const MultiSelection &rSelection );

    virtual String  GetCellText(long _nRow, sal_uInt16 _nColId) const;
    sal_uInt16 GetColumnCount() const { return ColCount(); }
protected:
    virtual long    GetRowCount() const;


    EditBrowseBox

            sal_Bool IsEditing() const {return aController.Is();}
            void InvalidateStatusCell(long nRow) {RowModified(nRow, 0);}
            void InvalidateHandleColumn();

            CellControllerRef Controller() const { return aController; }
            sal_Int32   GetBrowserFlags() const { return m_nBrowserFlags; }

            virtual void ActivateCell(long nRow, sal_uInt16 nCol, sal_Bool bSetCellFocus = sal_True);
            virtual void DeactivateCell(sal_Bool bUpdate = sal_True);
    */

                                            case M_GetSelText :
                                                {
                                                    pRet->GenReturn ( RET_Value, aUId, pEBBox->GetCellText( pEBBox->GetCurrRow(), pEBBox->GetColumnId( pEBBox->GetCurrColumn() )));
                                                }
                                                break;
                                            case M_GetColumnCount :
                                                {
                                                    sal_uInt16 nColCount = pEBBox->GetColumnCount();
                                                    comm_USHORT nUnfrozenColCount = 0;
                                                    sal_uInt16 i;
                                                    for ( i=0 ; i < nColCount ; i++ )
                                                    {
                                                        if ( !pEBBox->IsFrozen( pEBBox->GetColumnId( i ) ) )
                                                            nUnfrozenColCount++;
                                                    }
                                                    pRet->GenReturn ( RET_Value, aUId, nUnfrozenColCount );
                                                }
                                                break;
                                            case M_GetRowCount :
                                                {
                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pEBBox->GetRowCount() );
                                                }
                                                break;
                                            case M_IsEditing :
                                                {
                                                    CellControllerRef aControler;
                                                    aControler = pEBBox->Controller();
                                                    pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)aControler.Is() );
                                                }
                                                break;
                                            case M_Select :
                                                {
                                                    if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pEBBox->GetRowCount() ) )
                                                    {
                                                        sal_uInt16 nColCount = pEBBox->GetColumnCount();
                                                        comm_USHORT nUnfrozenColCount = 0;
                                                        sal_uInt16 i;
                                                        for ( i=0 ; i < nColCount ; i++ )
                                                        {
                                                            if ( !pEBBox->IsFrozen( pEBBox->GetColumnId( i ) ) )
                                                                nUnfrozenColCount++;
                                                        }
                                                        if ( ValueOK(aUId, MethodString( nMethodId ),nNr2,nUnfrozenColCount ) )
                                                            pEBBox->GoToRowColumnId( nNr1-1, pEBBox->GetColumnId( nNr2 ) );
                                                    }
                                                }
                                                break;

                                                /*
                                            case M_GetSelCount :
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetSelectionCount()));
                                                break;
                                            case M_GetSelIndex :
                                                if ( ! (nParams & PARAM_USHORT_1) )
                                                    nNr1 = 1;
                                                if ( ValueOK(aUId, CUniString("GetSelIndex"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                                                {
                                                    nNr1--;
                                                    COUNT_LBOX( FirstSelected, NextSelected, nNr1);
                                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG( ((SvTreeListBox*)pControl)->GetVisiblePos( pThisEntry )) +1 );
                                                }
                                                break;
                                            case M_GetSelText :
                                                if ( ! (nParams & PARAM_USHORT_1) )
                                                    nNr1 = 1;
                                                if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                                                {
                                                    nNr1--;
                                                    COUNT_LBOX( FirstSelected, NextSelected, nNr1);
                                                    GetFirstValidTextItem( pThisEntry );
                                                    pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
                                                }
                                                break;
                                            case M_GetItemCount :
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetVisibleCount()) );
                                                break;
                                            case M_GetItemText :
                                                if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                                {
                                                    SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
                                                    GetFirstValidTextItem( pEntry );
                                                    pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
                                                }
                                                break;
                                            case M_Select :
                                                if ( ! (nParams & PARAM_BOOL_1) )
                                                    bBool1 = sal_True;
                                                if( nParams & PARAM_STR_1 )
                                                {
                / *                                 ListBox *pLB = ((ListBox*)pControl);
                                                    if ( pLB->GetEntryPos( aString1 ) == LISTBOX_ENTRY_NOTFOUND )
                                                        ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
                                                    else
                                                    {
                                                        pLB->SelectEntry( aString1, bBool1 );
                                                        if ( pLB->IsEntrySelected( aString1 ) ? !bBool1 : bBool1 )  // XOR rein mit BOOL
                                                            ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), aString1 ) );
                                                    }
                * /                                 ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
                                                }
                                                else
                                                {
                                                    if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
                                                    {
                                                        SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
                                                        ((SvTreeListBox*)pControl)->Select ( pEntry, bBool1 );
                                                    }
                                                }
                                                break;*/
                                            default:
                                                ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "EditBrowseBox" ) );
                                                break;
                                        }
                                    }
                                    break;
                                case CONST_CTValueSet:
                                    {
                                        ValueSet *pVS = dynamic_cast< ValueSet* >(pControl);
                                        switch ( nMethodId )
                                        {
                                        case M_GetItemCount:
                                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pVS->GetItemCount()));
                                            break;
                                        case M_GetItemText:
                                            if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pVS->GetItemCount() ))
                                                pRet->GenReturn ( RET_Value, aUId, pVS->GetItemText( pVS->GetItemId( nNr1-1 ) ) );
                                            break;
                                        case M_Select:
                                            if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pVS->GetItemCount() ))
                                                pVS->SelectItem( pVS->GetItemId( nNr1-1 ) );
                                            break;
                                        case M_GetSelIndex :
                                            if ( pVS->IsNoSelection() )
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
                                            else
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pVS->GetItemPos( pVS->GetSelectItemId() ) +1));
                                            break;
                                        case M_GetSelText :
                                            if ( pVS->IsNoSelection() )
                                                pRet->GenReturn ( RET_Value, aUId, String() );
                                            else
                                                pRet->GenReturn ( RET_Value, aUId, pVS->GetItemText( pVS->GetSelectItemId() ) );
                                            break;
                                        case M_SetNoSelection :
                                            pVS->SetNoSelection();
                                            break;
                                        default:
                                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ValueSet" ) );
                                            break;
                                        }
                                    }
                                    break;
                                case CONST_CTORoadmap:
                                    {
                                        ORoadmap *pRM = dynamic_cast< ORoadmap* >(pControl);
                                        switch ( nMethodId )
                                        {
                                        case M_GetItemCount:
                                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pRM->GetItemCount()));
                                            break;
                                        case M_GetItemText:
                                            if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
                                                pRet->GenReturn ( RET_Value, aUId, pRM->GetRoadmapItemLabel( pRM->GetItemID( nNr1-1 ) ) );
                                            break;
                                        case M_Select:
                                            if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
                                            {
                                                if ( pRM->IsRoadmapItemEnabled( pRM->GetItemID( nNr1-1 ) ) )
                                                    pRM->SelectRoadmapItemByID( pRM->GetItemID( nNr1-1 ) );
                                                else
                                                    ReportError( aUId, GEN_RES_STR1c( S_WIN_DISABLED, "RoadmapItem" ) );
                                            }
                                            break;
                                        case M_GetSelIndex :
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pRM->GetItemIndex( pRM->GetCurrentRoadmapItemID() ) +1));
                                            break;
                                        case M_GetSelText :
                                                pRet->GenReturn ( RET_Value, aUId, pRM->GetRoadmapItemLabel( pRM->GetCurrentRoadmapItemID() ) );
                                            break;
                                        case M_IsItemEnabled :
                                            if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
                                                pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)pRM->IsRoadmapItemEnabled( pRM->GetItemID( nNr1-1 ) ) );
                                            break;
                                        default:
                                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RoadMap" ) );
                                            break;
                                        }
                                    }
                                    break;
                                case CONST_CTIExtensionListBox:
                                    {
                                        IExtensionListBox *pELB = dynamic_cast< IExtensionListBox* >(pControl);
                                        switch ( nMethodId )
                                        {
                                        case M_GetItemCount:
                                            pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pELB->getItemCount()));
                                            break;
                                        case M_GetItemText:
                                            if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pELB->getItemCount() ))
                                                switch ( nNr2 )
                                                {
                                                case 1:
                                                    pRet->GenReturn ( RET_Value, aUId, pELB->getItemName( nNr1 -1 ) );
                                                    break;
                                                case 2:
                                                    pRet->GenReturn ( RET_Value, aUId, pELB->getItemVersion( nNr1 -1 ) );
                                                    break;
                                                case 3:
                                                    pRet->GenReturn ( RET_Value, aUId, pELB->getItemDescription( nNr1 -1 ) );
                                                    break;
                                                case 4:
                                                    pRet->GenReturn ( RET_Value, aUId, pELB->getItemPublisher( nNr1 -1 ) );
                                                    break;
                                                case 5:
                                                    pRet->GenReturn ( RET_Value, aUId, pELB->getItemPublisherLink( nNr1 -1 ) );
                                                    break;
                                                default:
                                                    ValueOK( aUId, MethodString( nMethodId ).AppendAscii(" String Number"), nNr2, 5 );
                                                }
                                            break;
                                        case M_Select:
                                            if ( (nParams & PARAM_USHORT_1) )
                                            {
                                                if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pELB->getItemCount() ))
                                                {
                                                    pELB->select( nNr1-1 );
                                                }
                                            }
                                            else if ( (nParams & PARAM_STR_1) )
                                            {
                                                pELB->select( aString1 );
                                                sal_Bool bSuccess = sal_True;
                                                if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
                                                    bSuccess = sal_False;
                                                else
                                                {
                                                    if ( !aString1.Equals( String( pELB->getItemName( pELB->getSelIndex() ) ) ) )
                                                        bSuccess = sal_False;
                                                }
                                                if ( !bSuccess )
                                                    ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
                                            }
                                            break;
                                        case M_GetSelCount :
                                            if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 0 ));
                                            else
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 1 ));
                                            break;
                                        case M_GetSelIndex :
                                            if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 0 ));
                                            else
                                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pELB->getSelIndex() +1));
                                            break;
/*                                      xxxcase M_SetNoSelection :
                                            ((ListBox*)pControl)->SetNoSelection();
                                            ((ListBox*)pControl)->Select();
                                            break; */
                                        default:
                                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RoadMap" ) );
                                            break;
                                        }
                                    }
                                    break;

                                case CONST_CTTableControl:
                                    {
                                        ::svt::table::TableControl *pTC = dynamic_cast< ::svt::table::TableControl* >(pControl);
                                        switch ( nMethodId )
                                        {
                                           case M_GetItemType :
                                                {
                                                    if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTC->GetColumnCount() ) &&
                                                         ValueOK( aUId, MethodString( nMethodId ), nNr2, pTC->GetRowCount() ))
                                                    {
                                                        ::svt::table::PTableModel pModel = pTC->GetModel();
                                                        Any aCell;
                                                        pModel->getCellContent( nNr1-1, nNr2-1, aCell );
                                                        pRet->GenReturn ( RET_Value, aUId, String( aCell.getValueTypeName() ));
                                                    }
                                                }
                                                break;
                                           case M_GetItemText :
                                                {
                                                    if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTC->GetColumnCount() ) &&
                                                         ValueOK( aUId, MethodString( nMethodId ), nNr2, pTC->GetRowCount() ))
                                                    {
                                                        ::svt::table::PTableModel pModel = pTC->GetModel();
                                                        Any aCell;
                                                        pModel->getCellContent( nNr1-1, nNr2-1, aCell );
                                                        /* doesn't work ATM since it gets casted to SbxDATE in VCLTestTool unfortunately
                                                        SbxVariableRef xRes = new SbxVariable( SbxVARIANT );
                                                        unoToSbxValue( xRes, aCell );
                                                        pRet->GenReturn ( RET_Value, aUId, *xRes );*/

                                                        Type aType = aCell.getValueType();
                                                        TypeClass eTypeClass = aType.getTypeClass();
                                                        switch( eTypeClass )
                                                        {
                                                            /*case TypeClass_ENUM:
                                                                {
                                                                    sal_Int32 nEnum = 0;
                                                                    enum2int( nEnum, aValue );
                                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)nEnum );
                                                                }
                                                                break;*/
                                                            case TypeClass_BOOLEAN:
                                                                pRet->GenReturn ( RET_Value, aUId, *(sal_Bool*)aCell.getValue() );
                                                                break;
                                                            case TypeClass_CHAR:
                                                                {
                                                                    ::rtl::OUString aContent( *(sal_Unicode*)aCell.getValue() );
                                                                    pRet->GenReturn ( RET_Value, aUId, aContent );
                                                                }
                                                                break;
                                                            case TypeClass_STRING:
                                                                {
                                                                    ::rtl::OUString aContent;
                                                                    aCell >>= aContent;
                                                                    pRet->GenReturn ( RET_Value, aUId, aContent );
                                                                }
                                                                break;
                                                            //case TypeClass_FLOAT:         break;
                                                            //case TypeClass_DOUBLE:        break;
                                                            //case TypeClass_OCTET:         break;
                                                            case TypeClass_BYTE:
                                                            case TypeClass_SHORT:
                                                            case TypeClass_LONG:
                                                            case TypeClass_HYPER:
                                                            case TypeClass_UNSIGNED_LONG:
                                                            case TypeClass_UNSIGNED_HYPER:
                                                                {
                                                                    comm_ULONG val = 0;
                                                                    aCell >>= val;
                                                                    pRet->GenReturn ( RET_Value, aUId, val );
                                                                }
                                                                break;
                                                            //case TypeClass_UNSIGNED_OCTET:break;
                                                            case TypeClass_UNSIGNED_SHORT:
                                                                {
                                                                    comm_USHORT val = 0;
                                                                    aCell >>= val;
                                                                    pRet->GenReturn ( RET_Value, aUId, val );
                                                                }
                                                                break;
                                                            default:
                                                                pRet->GenReturn ( RET_Value, aUId, comm_USHORT(0) );
                                                                break;
                                                        }
                                                    }
                                                }
                                                break;
                                            case M_GetColumnCount :
                                                {
                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTC->GetColumnCount() );
                                                }
                                                break;
                                            case M_GetRowCount :
                                                {
                                                    pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTC->GetRowCount() );
                                                }
                                                break;
                                            case M_Select :
                                                {
                                                    if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTC->GetRowCount() ))
                                                    {
                                                        if ( pTC->GoToRow( ::svt::table::RowPos( nNr1-1 ) ) )
                                                        {
                                                            Size aSize( pTC->GetSizePixel() );
//                                                            DirectLog( S_QAError, UniString::CreateFromInt32( aSize.Width() ).Append( UniString::CreateFromInt32( aSize.Height() ) ) );
                                                            Point aPos( aSize.Width() / 2, aSize.Height() / 2 );
                                                            long nStep = aSize.Height() / 4;
                                                            ::svt::table::RowPos nLastPos;
                                                            while ( ( nLastPos = pTC->getTableControlInterface().hitTest( aPos ).nRow ) != nNr1-1 && nStep > 0 )
                                                            {
                                                                if ( nLastPos > nNr1-1 || nLastPos == ROW_INVALID )
                                                                    aPos.Y() -= nStep;
                                                                else
                                                                    aPos.Y() += nStep;
                                                                nStep /= 2;
                                                            }
                                                            if ( pTC->getTableControlInterface().hitTest( aPos ).nRow == nNr1-1 )
                                                            {
                                                                MouseEvent aMEvnt(aPos,1,MOUSE_SIMPLECLICK|MOUSE_SELECT,MOUSE_LEFT,KEY_MOD1);
                                                                pTC->getSelEngine()->SelMouseButtonDown( aMEvnt );
                                                                pTC->getSelEngine()->SelMouseButtonUp( aMEvnt );
                                                                if ( pTC->IsRowSelected( nNr1-1 ) )
                                                                    pTC->Select();
                                                            }
                                                            else
                                                                ReportError( aUId, GEN_RES_STR2c2( S_METHOD_FAILED, MethodString( nMethodId ), "find pos" ) );
                                                        }
                                                        else
                                                            ReportError( aUId, GEN_RES_STR2c2( S_METHOD_FAILED, MethodString( nMethodId ), "GoTo" ) );
                                                    }
                                                }
                                                break;
                                            case M_GetSelCount :
                                                pRet->GenReturn ( RET_Value, aUId, comm_USHORT( pTC->GetSelectedRowCount() ));
                                                break;
                                            case M_GetSelIndex :
                                                if ( ! (nParams & PARAM_USHORT_1) )
                                                    nNr1 = 1;
                                                if ( ValueOK( aUId, CUniString("GetSelIndex"), nNr1, pTC->GetSelectedRowCount() ) )
                                                    pRet->GenReturn ( RET_Value, aUId, comm_USHORT( pTC->GetSelectedRowIndex( nNr1-1 ) +1 ) );
                                                break;
/*                                          case M_GetSelText :
                                                if ( ! (nParams & PARAM_USHORT_1) )
                                                    nNr1 = 1;
                                                if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
                                                {
                                                    nNr1--;
                                                    COUNT_LBOX( FirstSelected, NextSelected, nNr1);
                                                    GetFirstValidTextItem( pThisEntry );
                                                    pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
                                                }
                                                break;
                                                */
                                        default:
                                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TableControl" ) );
                                            break;
                                        }
                                    }
                                    break;

                                case CONST_CTUnknown:
                                    ReportError( aUId, GEN_RES_STR2( S_UNKNOWN_TYPE, UniString::CreateFromInt32( nRT ), MethodString(nMethodId) ) );
                                    break;
                                default:
                                    ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
                                    break;
                            }
                    }
                    break;
                }
                case C_Window:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "Window" ) );
                            break;
                    }
                    break;

                case C_DockingWin:
                    DockingWin:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        case M_Dock :
                            if ( ((DockingWindow*)pControl)->IsFloatingMode() )
                                ((DockingWindow*)pControl)->SetFloatingMode(sal_False);
                            else
                                ReportError( aUId, GEN_RES_STR1( S_ALLOWED_ONLY_IN_FLOATING_MODE, MethodString( nMethodId ) ) );
                            break;
                        case M_Undock :
                            if ( !((DockingWindow*)pControl)->IsFloatingMode() )
                                ((DockingWindow*)pControl)->SetFloatingMode(sal_True);
                            else
                                ReportError( aUId, GEN_RES_STR1( S_ALLOWED_ONLY_IN_FLOATING_MODE, MethodString( nMethodId ) ) );
                            break;
                        case M_IsDocked :
                            pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((DockingWindow*)pControl)->IsFloatingMode());
                            break;
                        case M_Close:
                                //aWindowWaitUId = aUId;
                            DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
                            SET_WINP_CLOSING(pControl);
                            ((DockingWindow*)pControl)->Close();
                            break;
                        case M_Size:
                        case M_Move:
                        case M_IsMax:
                        case M_Minimize:
                        case M_Maximize:
                            if ( ((DockingWindow*)pControl)->IsFloatingMode() )
                            {
                                Window* pFloat = ((DockingWindow*)pControl)->GetFloatingWindow();
                                if ( !pFloat && ((DockingWindow*)pControl)->IsFloatingMode() )
                                {
                                    if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
                                        pFloat = pControl->GET_REAL_PARENT();
                                    else
                                    {
                                        DBG_ERROR("FloatingMode set but Parent is no FloatingWindow");
                                    }
                                }
                                if ( pFloat && pFloat->GetType() == WINDOW_FLOATINGWINDOW )
                                {
                                    pControl = pFloat;
                                    goto FloatWin;
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_CANNOT_FIND_FLOATING_WIN, MethodString( nMethodId ) ) );
                            }
                            else
                                ReportError( aUId, GEN_RES_STR1( S_ALLOWED_ONLY_IN_DOCKING_MODE, MethodString( nMethodId ) ) );
                            break;
                        case M_Help:        // Everything to be treated below
                            goto MoreDialog;

                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "DockingWindow" ) );
                            break;
                    }
                    break;
                case C_FloatWin:
                    FloatWin:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        case M_IsMax :
                            pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)!((FloatingWindow*)pControl)->IsRollUp());
                            break;
                        case M_Minimize :
                            ((FloatingWindow*)pControl)->RollUp();
                            break;
                        case M_Maximize :
                            ((FloatingWindow*)pControl)->RollDown();
                            break;
                        case M_Size:
                        {
                            if ( pControl->GetStyle() & WB_SIZEABLE )
                            {
                                Size aMin = ((FloatingWindow*)pControl)->GetMinOutputSizePixel();
                                if ( aMin.Width() <= nNr1 && aMin.Height() <= nNr2 )
                                {
                                    pControl->SetSizePixel(Size(nNr1,nNr2));
                                    pControl->Resize();
                                }
                                else
                                {
                                    ReportError( aUId, GEN_RES_STR2( S_SIZE_BELOW_MINIMUM, String::CreateFromInt32( aMin.Width() ), String::CreateFromInt32( aMin.Height() ) ) );
                                }
                            }
                            else
                                ReportError( aUId, GEN_RES_STR1( S_SIZE_NOT_CHANGEABLE, MethodString( nMethodId ) ) );
                            break;
                        }
                        case M_Close:
                            DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
                            SET_WINP_CLOSING(pControl);
                            ((FloatingWindow*)pControl)->Close();
                            break;
                        case M_Help:        // Everything to be treated below
                        case M_Move:
                            goto MoreDialog;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "FloatingWin" ) );
                            break;
                    }
                    break;
                case C_ModelessDlg:
                case C_ModalDlg:
                case C_Dialog:
                case C_TabDlg:
                    MoreDialog:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        case M_Close:
                            DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
                            SET_WINP_CLOSING(pControl);
                            ((SystemWindow*)pControl)->Close();
                            break;
                        case M_OK:
                        {
                            Window *pChild = GetWinByRT( pControl, WINDOW_OKBUTTON );
                            if( ControlOK( pChild, "OK Button" ) )
                            {
                                DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
                                SET_WINP_CLOSING(pControl);
                                ((Button*)pChild)->Click();
                            }
                            break;
                        }
                        case M_Cancel:
                        {
                            Window *pChild = GetWinByRT( pControl, WINDOW_CANCELBUTTON );
                            if( ControlOK( pChild, "Cancel Button" ) )
                            {
                                DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
                                SET_WINP_CLOSING(pControl);
                                ((Button*)pChild)->Click();
                            }
                            break;
                        }
                        case M_Help:
                        {
                            Window *pChild = GetWinByRT( pControl, WINDOW_HELPBUTTON );
                            if( ControlOK( pChild, "Help Button" ) )
                                ((Button*)pChild)->Click();
                            break;
                        }
                        case M_Default:
                        {
                            Window *pChild = ImpGetButton( pControl, WB_DEFBUTTON, WB_DEFBUTTON );
                            if( ControlOK( pChild, "Default Button" ) )
                                ((Button*)pChild)->Click();
                            break;
                        }
                        case M_Move:
                        {
                            pControl->SetPosPixel(Point(nNr1,nNr2));
                            break;
                        }
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "Dialog" ) );
                            break;
                    }
                    break;
                case C_WorkWin:
                    switch( nMethodId )
                    {
                        case M_AnimateMouse :
                            AnimateMouse( pControl, MitteOben);
                            break;
                        case M_Close:
                            DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
                            SET_WINP_CLOSING(pControl);
                            ((WorkWindow*)pControl)->Close();
                            break;
                        case M_Size:
                        case M_Move:
                            goto FloatWin;
//                          break;
                        case M_IsMax :
                            pRet->GenReturn ( RET_Value, aUId, ((WorkWindow*)pControl)->IsMaximized() );
                            break;
                        case M_IsMin :
                            pRet->GenReturn ( RET_Value, aUId, ((WorkWindow*)pControl)->IsMinimized() );
                            break;
                        case M_IsRestore :
                            pRet->GenReturn ( RET_Value, aUId, comm_BOOL (!((WorkWindow*)pControl)->IsMaximized() && !((WorkWindow*)pControl)->IsMinimized()) );
                            break;
                        case M_Minimize :
                            ((WorkWindow*)pControl)->Maximize( sal_False );
                            ((WorkWindow*)pControl)->Minimize();
                            break;
                        case M_Maximize :
                            ((WorkWindow*)pControl)->Maximize();
                            break;
                        case M_Restore :
                            ((WorkWindow*)pControl)->Maximize( sal_False );
                            ((WorkWindow*)pControl)->Restore();
                            break;
                        case M_Help:        // Everything to be treated below
                            goto MoreDialog;
                        default:
                            ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "WorkWindow" ) );
                            break;
                    }
                    break;
                case C_TabPage:
                    ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
                    break;
                case C_MessBox:
                case C_InfoBox:
                case C_WarningBox:
                case C_ErrorBox:
                case C_QueryBox:
                    {
                        sal_Bool bDone = sal_True;
                        MessBox* pMB = (MessBox*)pControl;
                        switch( nMethodId )
                        {
                            case M_GetCheckBoxText:
                                pRet->GenReturn ( RET_Value, aUId, pMB->GetCheckBoxText() );
                                break;
                            case M_IsChecked :
                                pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pMB->GetCheckBoxState() == STATE_CHECK) );
                                break;
                            case M_Check :
                                pMB->SetCheckBoxState( sal_True );
                                break;
                            case M_UnCheck :
                                pMB->SetCheckBoxState( sal_False );
                                break;
                            case M_GetText :
                                pRet->GenReturn ( RET_Value, aUId, pMB->GetMessText());
                                break;

                            default:
                                bDone = sal_False;
                                break;
                        }
                        if ( bDone )
                            break;  // break the case here else continue at C_ButtonDialog
                    }
                case C_ButtonDialog:
                    {
                        ButtonDialog* pBD = (ButtonDialog*)pControl;
#if OSL_DEBUG_LEVEL > 1
                        m_pDbgWin->AddText( "Working MessBox: " );
                        if (pControl->IsVisible())
                            m_pDbgWin->AddText("*(Visible)\n");
                        else
                            m_pDbgWin->AddText("*(nicht Visible)\n");
#endif
                        switch( nMethodId )
                        {
                            case M_AnimateMouse :
                                AnimateMouse( pControl, Mitte);
                                break;
                            case M_OK:
                                if ( pBD->GetPushButton( BUTTONID_OK ) )
                                {
                                    SET_WINP_CLOSING(pControl);
                                    pBD->EndDialog(RET_OK);
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_NO_OK_BUTTON, MethodString( nMethodId ) ) );
                                break;
                            case M_Cancel:
                                if ( pBD->GetPushButton( BUTTONID_CANCEL ) )
                                {
                                    SET_WINP_CLOSING(pControl);
                                    pBD->EndDialog(RET_CANCEL);
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_NO_CANCEL_BUTTON, MethodString( nMethodId ) ) );
                                break;
                            case M_Yes:
                                if ( pBD->GetPushButton( BUTTONID_YES ) )
                                {
                                    SET_WINP_CLOSING(pControl);
                                    pBD->EndDialog(RET_YES);
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_NO_YES_BUTTON, MethodString( nMethodId ) ) );
                                break;
                            case M_No:
                                if ( pBD->GetPushButton( BUTTONID_NO ) )
                                {
                                    SET_WINP_CLOSING(pControl);
                                    pBD->EndDialog(RET_NO);
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_NO_NO_BUTTON, MethodString( nMethodId ) ) );
                                break;
                            case M_Repeat:
                                if ( pBD->GetPushButton( BUTTONID_RETRY ) )
                                {
                                    SET_WINP_CLOSING(pControl);
                                    pBD->EndDialog(RET_RETRY);
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_NO_RETRY_BUTTON, MethodString( nMethodId ) ) );
                                break;
                            case M_Help:
                                if ( pBD->GetPushButton( BUTTONID_HELP ) )
                                {
                                    SET_WINP_CLOSING(pControl);
                                    pBD->EndDialog(BUTTONID_HELP);
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_NO_HELP_BUTTON, MethodString( nMethodId ) ) );
                                break;
                            case M_Default:
                                {
                                    WinBits Style = pControl->GetStyle();
                                    if ( Style & WB_DEF_OK )
                                    {
                                        SET_WINP_CLOSING(pControl);
                                        pBD->EndDialog(RET_OK);
                                    }
                                    else if ( Style & WB_DEF_CANCEL )
                                    {
                                        SET_WINP_CLOSING(pControl);
                                        pBD->EndDialog(RET_CANCEL);
                                    }
                                    else if ( Style & WB_DEF_YES )
                                    {
                                        SET_WINP_CLOSING(pControl);
                                        pBD->EndDialog(RET_YES);
                                    }
                                    else if ( Style & WB_DEF_NO )
                                    {
                                        SET_WINP_CLOSING(pControl);
                                        pBD->EndDialog(RET_NO);
                                    }
                                    else if ( Style & WB_DEF_RETRY )
                                    {
                                        SET_WINP_CLOSING(pControl);
                                        pBD->EndDialog(RET_RETRY);
                                    }
                                    else
                                        ReportError( aUId, GEN_RES_STR1( S_NO_DEFAULT_BUTTON, MethodString( nMethodId ) ) );
                                }
                                break;
                            case M_GetText :
                                pRet->GenReturn ( RET_Value, aUId, pControl->GetText());
                                break;
                            case M_Click:
                                if ( nParams & PARAM_USHORT_1 )
                                {
                                    if ( pBD->GetPushButton( nNr1 ) )
                                    {
                                        if ( nNr1 != BUTTONID_HELP )
                                        {
                                            SET_WINP_CLOSING(pControl);
                                        }
                                        pBD->GetPushButton( nNr1 )->Click();
                                    }
                                    else
                                        ReportError( aUId, GEN_RES_STR2( S_NO_DEFAULT_BUTTON, UniString::CreateFromInt32( nNr1 ), MethodString( nMethodId ) ) );
                                }
                                else
                                    ReportError( aUId, GEN_RES_STR1( S_BUTTONID_REQUIRED, MethodString( nMethodId ) ) );
                                break;
                            case M_GetButtonCount :
                                pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pBD->GetButtonCount()));
                                break;
                            case M_GetButtonId :
                                if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pBD->GetButtonCount()) )
                                    pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pBD->GetButtonId(nNr1-1)));
                                break;
                            default:
                                ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MessageBox" ) );
                                break;
                        }
                        break;
                    }
                default:
                    DBG_ERROR( "Unknown object type from UId or Method not supported" );
                    ReportError( aUId, GEN_RES_STR2( S_UNKNOWN_TYPE, UniString::CreateFromInt32( nRT ), MethodString(nMethodId) ) );
#if OSL_DEBUG_LEVEL > 1
                    m_pDbgWin->AddText( " Unknown object type from UId or Method not supported" );
#endif
                    break;
            }
        }
        for( int i = 0; i < 32; i++ )
            SafeReschedule();
    }
#if OSL_DEBUG_LEVEL > 1
    m_pDbgWin->AddText( "\n" );
#endif
    if ( bStatementDone )
    {
        SendProfile( UIdString( aUId ).Append('.').Append( MethodString( nMethodId ) ) );
        delete this;
    }
    else
    {
        if ( nRetryCount-- )
        {
#if OSL_DEBUG_LEVEL > 1
            m_pDbgWin->AddText( CUniString("Reschedule command (requed) (").Append( UniString::CreateFromInt32(nRetryCount) ).AppendAscii(")\n") );
#endif
            QueStatement( this );   // will que at the start of the list
        }
        else
        {
            bStatementDone=sal_True;
        }
    }
    return bStatementDone;

#define FINISH_NEXT
#define FINISH_SAME

}

/* vim: set noet sw=4 ts=4: */