xref: /AOO41X/main/sc/workben/test.cxx (revision b3f79822e811ac3493b185030a72c3c5a51f32d8)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



#include <tools/debug.hxx>
#include <svtools/libcall.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/window.hxx>
#include <vcl/button.hxx>
#include <vcl/field.hxx>
#include <vcl/fixed.hxx>
#include <vcl/help.hxx>
#include <usr/conver.hxx>
#include <usr/uno.hxx>
#include <usr/refl.hxx>
#include <stardiv/one/frame/xcollect.hxx>
#include <stardiv/one/text/offfield.hxx>
#include <stardiv/one/offmisc.hxx>
#include <stardiv/one/sheet/offtable.hxx>
#include <stardiv/one/text/offtext.hxx>
#include <stardiv/one/offstyle.hxx>
#include <stardiv/one/offview.hxx>
#include <stardiv/uno/repos/serinfo.hxx>
#include <stardiv/one/sheet/sctypes.hxx>
#include <stardiv/one/sheet/scmodel.hxx>
#include <stardiv/one/sheet/sccells.hxx>
#include <stardiv/one/sheet/sctables.hxx>
#include <stardiv/one/sheet/sctable.hxx>
#include <stardiv/one/sheet/sccell.hxx>
#include <stardiv/one/sheet/scpostit.hxx>
#include <stardiv/one/sheet/scview.hxx>
#include <stardiv/one/sheet/scdata.hxx>
#include <stardiv/one/sheet/scattr.hxx>

//!	das muss als Konstante in irgendeine idl-Datei!!!!
#define TEXTCONTROLCHAR_PARAGRAPH_BREAK			0


class MyFixedText : public FixedText
{
protected:
	void		RequestHelp( const HelpEvent& rHEvt );
public:
				MyFixedText(Window* pParent) : FixedText(pParent) {}
};

class MyWindow : public Window
{
private:
	NumericField	aCountField;
	PushButton		aCountButton;
	MyFixedText		aTimeText;
	NumericField	aColField;
	NumericField	aRowField;
	NumericField	aPosField;
	NumericField	aLenField;
	Edit			aTextEdit;
	PushButton		aTextButton;
	PushButton		aBlaButton;
	PushButton		aTabButton;
	PushButton		aViewButton;

public:
			MyWindow( Window *pParent );

		DECL_LINK(CountHdl, PushButton*);
		DECL_LINK(TextHdl, PushButton*);
		DECL_LINK(BlaHdl, PushButton*);
		DECL_LINK(TabHdl, PushButton*);
		DECL_LINK(ViewHdl, PushButton*);
};

//-----------------------------------------------------------------------

class ScTestListener : public XSelectionChangeListener, public UsrObject
{
private:
	FixedText*	pFixedText;

public:
							ScTestListener(FixedText* pF);
	virtual					~ScTestListener();

							SMART_UNO_DECLARATION( ScTestListener, UsrObject );

	virtual XInterface *	queryInterface( UsrUik );
	virtual XIdlClassRef	getIdlClass(void);

	virtual void			disposing(const EventObject& Source);

							// XSelectionChangeListener
	virtual void			selectionChanged(const EventObject& aEvent);
};

//-----------------------------------------------------------------------

static long nBla = 0;

static XCellRef xGlobalCell;

//-----------------------------------------------------------------------

ScTestListener::ScTestListener(FixedText* pF) :
	pFixedText( pF )
{
}

ScTestListener::~ScTestListener()
{
}

XInterface* ScTestListener::queryInterface( UsrUik aUIK )
{
	if ( aUIK == XSelectionChangeListener::getSmartUik() )
		return (XSelectionChangeListener*) this;

	return UsrObject::queryInterface( aUIK );
}

XIdlClassRef ScTestListener::getIdlClass(void)
{
	static XIdlClassRef xClass = createStandardClass( L"ScTestListener",
		UsrObject::getUsrObjectIdlClass(),
		1, XSelectionChangeListener_getReflection() );
	return xClass;
}

void ScTestListener::disposing(const EventObject& Source)
{
}

// XSelectionChangeListener

void ScTestListener::selectionChanged(const EventObject& aEvent)
{
	static USHORT nBla = 0;
	pFixedText->SetText(++nBla);

	XInterfaceRef xInt = aEvent.Source;
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XCellCollectionRef xCells = (XCellCollection*)
				xSelInt->queryInterface(XCellCollection::getSmartUik());
	if (!xCells) return;

	String aStr = OUStringToString( xCells->getAddress(), CHARSET_SYSTEM );
	pFixedText->SetText(aStr);
}


//-----------------------------------------------------------------------

extern "C" Window* __LOADONCALLAPI CreateWindow( Window *pParent, const String& rParam )
{
	MyWindow *pWin = new MyWindow( pParent );
	return pWin;
}

void MyFixedText::RequestHelp( const HelpEvent& rHEvt )
{
	String	aTxtStr=GetText();
	Size	aTxtSize=GetTextSize(aTxtStr);
	Point	aShowPoint=	OutputToScreenPixel(Point(0,0));
	if ( ( rHEvt.GetMode() & HELPMODE_QUICK ) == HELPMODE_QUICK &&
		 aTxtSize.Width()>GetSizePixel().Width())
		Help::ShowQuickHelp( Rectangle(aShowPoint,aTxtSize), aTxtStr, QUICKHELP_TOP|QUICKHELP_LEFT );
	else
		FixedText::RequestHelp( rHEvt );
}

MyWindow::MyWindow( Window *pParent ) :
	Window( pParent ),
	aCountField( this, WinBits(WB_SPIN | WB_REPEAT | WB_BORDER) ),
	aCountButton( this ),
	aTimeText( this ),
	aColField( this, WinBits(WB_SPIN | WB_REPEAT | WB_BORDER) ),
	aRowField( this, WinBits(WB_SPIN | WB_REPEAT | WB_BORDER) ),
	aPosField( this, WinBits(WB_SPIN | WB_REPEAT | WB_BORDER) ),
	aLenField( this, WinBits(WB_SPIN | WB_REPEAT | WB_BORDER) ),
	aTextEdit( this, WinBits(WB_BORDER) ),
	aTextButton( this ),
	aBlaButton( this ),
	aTabButton( this ),
	aViewButton( this )
{
	aCountField.SetPosSizePixel( Point(10,10), Size(40,20) );
	aCountField.SetValue(1);

	aCountButton.SetPosSizePixel( Point(10,40), Size(100,30) );
	aCountButton.SetText("hochzaehlen");

	aTimeText.SetPosSizePixel( Point(10,80), Size(100,20) );

	aColField.SetPosSizePixel( Point(10,120), Size(40,20) );
	aRowField.SetPosSizePixel( Point(60,120), Size(40,20) );
	aPosField.SetPosSizePixel( Point(10,150), Size(40,20) );
	aLenField.SetPosSizePixel( Point(60,150), Size(40,20) );
	aTextEdit.SetPosSizePixel( Point(10,180), Size(100,20) );

	aTextButton.SetPosSizePixel( Point(10,210), Size(100,30) );
	aTextButton.SetText("col/row/pos/len");

	aBlaButton.SetPosSizePixel( Point(10,260), Size(100,30) );
	aBlaButton.SetText("Bla");

	aTabButton.SetPosSizePixel( Point(10,310), Size(100,30) );
	aTabButton.SetText("Tabellen");

	aViewButton.SetPosSizePixel( Point(10,360), Size(100,30) );
	aViewButton.SetText("Pfui");

	aCountButton.SetClickHdl(LINK(this, MyWindow, CountHdl));
	aTextButton.SetClickHdl(LINK(this, MyWindow, TextHdl));
	aBlaButton.SetClickHdl(LINK(this, MyWindow, BlaHdl));
	aTabButton.SetClickHdl(LINK(this, MyWindow, TabHdl));
	aViewButton.SetClickHdl(LINK(this, MyWindow, ViewHdl));

	aCountField.Show();
	aCountButton.Show();
	aTimeText.Show();
	aColField.Show();
	aRowField.Show();
	aPosField.Show();
	aLenField.Show();
	aTextEdit.Show();
	aTextButton.Show();
	aBlaButton.Show();
	aTabButton.Show();
	aViewButton.Show();
}

//-----------------------------------------------------------------------

XSpreadsheetDocumentRef lcl_GetDocument()
{
	XServiceManagerRef xProv = getGlobalServiceManager();
	DBG_ASSERT( xProv.is(), "Kein ServiceManager!" );

	XServiceRegistryRef xReg = (XServiceRegistry*)xProv->queryInterface(XServiceRegistry::getSmartUik());
	if ( !xReg )
		return NULL;

	Sequence<Uik> aIfaces( 1 );
	aIfaces.getArray()[0] = XModelCollection::getSmartUik();
	XServiceProviderRef xSSI = xProv->getServiceProvider( L"stardiv.desktop.ModelCollection",
															aIfaces, Sequence<Uik>() );

	XModelCollectionRef aCollRef = (XModelCollection*)
						xSSI->newInstance()->queryInterface( XModelCollection::getSmartUik() );
	USHORT nCount = aCollRef->getCount();

	XSpreadsheetDocumentRef xModel;							// Calc-Model
	for (USHORT nMod=0; nMod<nCount && !xModel; nMod++)		// Calc-Doc suchen
	{
		XModelRef aRef = aCollRef->getItemByIndex( nMod );
		if ( aRef )
		{
			aRef->acquire();
			xModel = (XSpreadsheetDocument*) aRef->queryInterface( XSpreadsheetDocument::getSmartUik() );
			aRef->release();
		}
	}
	return xModel;
}

XInterfaceRef lcl_GetView()
{
	XInterfaceRef xView;
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
		xView = xDoc->getDDELinks();		//! temporaer zum Testen !!!!!!!!!

	return xView;
}

//-----------------------------------------------------------------------

void lcl_OutputNames( const XInterfaceRef& xSource,		// XNameAccess
						const XSpreadsheetDocumentRef& xDoc,
						USHORT nCol, USHORT nRow, USHORT nTab )
{
	CellAddress aAdr;
	aAdr.Sheet	= nTab;
	aAdr.Column	= nCol;
	aAdr.Row	= nRow;

	XNameAccessRef xNames = (XNameAccess*)xSource->queryInterface(XNameAccess::getSmartUik());
	if (!xNames) return;
	Sequence<UString> aSeq = xNames->getElementNames();

	USHORT nLen = (USHORT)aSeq.getLen();

	XCellRef xCell = xDoc->getCell(aAdr);
	if (!xCell) return;
	xCell->setValue( nLen );
	++aAdr.Row;

	UString* pAry = aSeq.getArray();
	for (USHORT i=0; i<nLen; i++)
	{
		xCell = xDoc->getCell(aAdr);
		if (!xCell) return;
		XTextRef xText = (XText*)xCell->queryInterface(XText::getSmartUik());
		if (!xText) return;
		xText->setText( pAry[i] );
		++aAdr.Row;
	}
}

//-----------------------------------------------------------------------

void lcl_SetText( const XTextRef& xText )
{
	if (!xText.is()) return;
	XTextCursorRef xCursor = xText->createTextCursor();
	if (!xCursor.is()) return;
	XTextPositionRef xPos = (XTextPosition*)xCursor->queryInterface(XTextPosition::getSmartUik());
	XPropertySetRef xProp = (XPropertySet*)xCursor->queryInterface(XPropertySet::getSmartUik());
	XControlCharacterInsertableRef xControl = (XControlCharacterInsertable*)
							xCursor->queryInterface(XControlCharacterInsertable::getSmartUik());
	XParagraphCursorRef xPara = (XParagraphCursor*)
							xCursor->queryInterface(XParagraphCursor::getSmartUik());

	if (!xPos.is() || !xControl.is() || !xPara.is()) return;	// PropertySet kann fehlen

	xText->setText(L"bla fasel");
	xCursor->gotoEnd(FALSE);
	xControl->insertControlCharacter( TEXTCONTROLCHAR_PARAGRAPH_BREAK );
	xPos->collapseToEnd();
    xPos->setText(L"s\xFClz");      // zweiter Absatz

	xCursor->gotoStart(FALSE);
	xPara->gotoEndOfParagraph(FALSE);
	xCursor->goLeft(5, TRUE);				// letzte 5 Zeichen im 1. Absatz
	if (xProp.is())
		xProp->setPropertyValue(L"Bold", UsrAny((BOOL)TRUE));
}

//-----------------------------------------------------------------------

void lcl_DoCount()
{
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		XActionLockableRef xLock = (XActionLockable*)
							xDoc->queryInterface(XActionLockable::getSmartUik());
		XCalculateRef xCalc = (XCalculate*)
							xDoc->queryInterface(XCalculate::getSmartUik());
		if (xLock)
			xLock->addActionLock();							// nicht zwischendurch painten
		if (xCalc)
			xCalc->setAutomaticCalculation(FALSE);

		CellAddress aPos;
		aPos.Sheet  = 0;

		for (USHORT nRow = 0; nRow < 20; nRow++)
		{
			aPos.Row = nRow;
			for (USHORT nCol = 0; nCol < 10; nCol++)
			{
				aPos.Column = nCol;
				XCellRef xCell = xDoc->getCell(aPos);
				if ( xCell )
				{
					//	Wert der Zelle um 1 hochzaehlen

					double fVal = xCell->getValue();
					fVal += 1.0;
					xCell->setValue( fVal );
				}
			}
		}

		if (xCalc)
			xCalc->setAutomaticCalculation(TRUE);
		if (xLock)
			xLock->removeActionLock();
	}
}


void lcl_GlobalCell()
{
	if ( xGlobalCell )
	{
		String aStr = OUStringToString( xGlobalCell->getFormula(), CHARSET_SYSTEM );
		aStr+='0';
		xGlobalCell->setFormula( StringToOUString( aStr, CHARSET_SYSTEM ) );
	}
}


void lcl_Annotations( FixedText& aTimeText )
{
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		CellAddress aPos;
		aPos.Sheet  = 0;
		aPos.Column = 1;
		aPos.Row    = 2;
		XCellRef xCell = xDoc->getCell(aPos);
		if ( xCell )
		{
			XSheetAnnotationAnchorRef xAnchor =
				(XSheetAnnotationAnchor*)xCell->queryInterface(XSheetAnnotationAnchor::getSmartUik());
			if ( xAnchor )
			{
				XSheetAnnotationRef xAnnotation = xAnchor->getAnnotation();
				if ( xAnnotation )
				{
					String aBlubb = OUStringToString( xAnnotation->getAuthor(), CHARSET_SYSTEM )+
									String(" - ")+
									OUStringToString( xAnnotation->getDate(), CHARSET_SYSTEM );
					aTimeText.SetText(aBlubb);

					XTextRef xAnnotationText =
						(XText*)xAnnotation->queryInterface(XText::getSmartUik());
					if ( xAnnotationText )
					{
						XTextCursorRef xCursor = xAnnotationText->createTextCursor();
						if (xCursor)
						{
							XTextPositionRef xPos = (XTextPosition*)
								xCursor->queryInterface(XTextPosition::getSmartUik());
							XControlCharacterInsertableRef xControl = (XControlCharacterInsertable*)
								xCursor->queryInterface(XControlCharacterInsertable::getSmartUik());

							if (xPos && xControl)
							{
								ULONG nStart = Time::GetSystemTicks();

								xAnnotationText->setText(L"bla");
								xCursor->gotoEnd(FALSE);
								xCursor->goLeft(1,TRUE);
								xPos->setText(L"ubb");
								for (USHORT i=0; i<10; i++)
								{
									xPos->collapseToEnd();
									xControl->insertControlCharacter( TEXTCONTROLCHAR_PARAGRAPH_BREAK );
									xPos->collapseToEnd();
									xPos->setText(L"dumdi");
								}

								ULONG nEnd = Time::GetSystemTicks();
								aTimeText.SetText(String(nEnd-nStart)+String(" ms"));
							}
						}
					}
				}
			}
		}
	}
}


void lcl_Cursor( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		XActionLockableRef xLock = (XActionLockable*)
							xDoc->queryInterface(XActionLockable::getSmartUik());
		if (xLock)
			xLock->addActionLock();

		CellAddress aPos;
		aPos.Sheet  = 0;
		aPos.Column = 1;
		aPos.Row    = 2;
		XCellRef xCell = xDoc->getCell(aPos);
		if ( xCell )
		{
			XTextRef xText = (XText*)xCell->queryInterface(XText::getSmartUik());
			XCellCollectionRef xColl = (XCellCollection*)xCell->queryInterface(XCellCollection::getSmartUik());
			if ( xText && xColl )
			{
				xText->setText(L"bla");
				XLineCursorRef xCursor = xColl->createCursor();
				if ( xCursor )
				{
					XCellCursorRef xCC = (XCellCursor*)xCursor->queryInterface(XCellCursor::getSmartUik());
					XCellRangesCursorRef xRC = (XCellRangesCursor*)
										xCursor->queryInterface(XCellRangesCursor::getSmartUik());

					if ( xCC && xRC )
					{
						xCursor->goDown( 1, FALSE );

						xColl = xCC->getRanges();
						if ( xColl )
						{
							//	XText ist drin, wenn's ne einzelne Zelle ist
							xText = (XText*)xColl->queryInterface(XText::getSmartUik());
							if ( xText )
							{
								xText->setText(L"fasel");
							}
						}

						CellRangeAddress aSecond;
						aSecond.Sheet		= 0;
						aSecond.StartColumn	= 3;
						aSecond.StartRow	= 4;
						aSecond.EndColumn	= 3;
						aSecond.EndRow		= 4;
						xRC->gotoUnion(aSecond);

						xColl = xCC->getRanges();
						if ( xColl )
						{
							XPropertySetRef xProp = (XPropertySet*)
												xColl->queryInterface(XPropertySet::getSmartUik());
							if ( xProp )
							{
								UsrAny aAny;

								aAny = xProp->getPropertyValue(L"ShadowFormat");
								if ( aAny.getReflection()->getName() ==
									 ShadowFormat_getReflection()->getName() )
								{
									//ShadowFormat* pOld = (ShadowFormat*)aAny.get();
									ShadowFormat aNew;
									aNew.Location 		= SHADOWLOCATION_BOTTOMRIGHT;
									aNew.ShadowWidth	= 100;
									aNew.IsTransparent	= FALSE;
									aNew.Color			= 0xff0000L;
									aAny.set( &aNew, aAny.getReflection() );
									xProp->setPropertyValue(L"ShadowFormat", aAny);
								}

								aAny = xProp->getPropertyValue(L"RotationValue");
								aAny.setINT32(4500);
								xProp->setPropertyValue(L"RotationValue", aAny);

								aAny = xProp->getPropertyValue(L"FontHeight");
								aAny.setUINT32(280);
								xProp->setPropertyValue(L"FontHeight", aAny);

								aAny = xProp->getPropertyValue(L"TransparentBackground");
								aAny.setBOOL(FALSE);
								xProp->setPropertyValue(L"TransparentBackground", aAny);

								aAny = xProp->getPropertyValue(L"BackgroundColor");
								aAny.setUINT32(0xffff00);
								xProp->setPropertyValue(L"BackgroundColor", aAny);

								aAny = xProp->getPropertyValue(L"CellProtection");
								if ( aAny.getReflection()->getName() ==
									 CellProtection_getReflection()->getName() )
								{
									//CellProtection* pOld = (CellProtection*)aAny.get();
									CellProtection aNew;
									aNew.Locked			= FALSE;
									aNew.FormulaHidden	= FALSE;
									aNew.Hidden			= FALSE;
									aNew.PrintHidden	= FALSE;
									aAny.set( &aNew, aAny.getReflection() );
									xProp->setPropertyValue(L"CellProtection", aAny);
								}
							}

							// XIndexAccess gibts nur wenn's mehrere sind (??!??!)
							XIndexAccessRef xIndex = (XIndexAccess*)
												xColl->queryInterface(XIndexAccess::getSmartUik());
							if ( xIndex )
							{
								USHORT nCount = (USHORT)xIndex->getCount();
								aTimeText.SetText( String(nCount) );
							}
						}
					}
				}
			}
		}

		if (xLock)
			xLock->removeActionLock();
	}
}


void lcl_Cells( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		long nCount = 0;
		ULONG nStart = Time::GetSystemTicks();

		XActionLockableRef xLock = (XActionLockable*)
							xDoc->queryInterface(XActionLockable::getSmartUik());
//		if (xLock)
//			xLock->addActionLock();

		CellRangeAddress aRngAddr;
		aRngAddr.Sheet		 = 0;
		aRngAddr.StartColumn = 0;
		aRngAddr.StartRow	 = 0;
		aRngAddr.EndColumn	 = 9;
		aRngAddr.EndRow		 = 19;
		XCellRangeRef xRange = xDoc->getCellRange(aRngAddr);
		if (xRange)
		{
			XCellCollectionRef xColl = (XCellCollection*)
						xRange->queryInterface(XCellCollection::getSmartUik());
			if (xColl)
			{
				XEnumerationAccessRef xEnAcc = xColl->getCells();
				if (xEnAcc)
				{
					XEnumerationRef xEnum = xEnAcc->getEnumeration();
					if (xEnum)
					{
						while (xEnum->hasMoreElements())
						{
							XInterfaceRef xInt = xEnum->nextElement();
							if (xInt)
							{
								++nCount;
							}
						}
					}
				}
			}
		}

		ULONG nEnd = Time::GetSystemTicks();
		aTimeText.SetText(String(nCount)+String(" ")+String(nEnd-nStart)+String(" ms"));


//		if (xLock)
//			xLock->removeActionLock();
	}
}

void lcl_Sheet( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;
	XTableSheetRef xSheet = xSheets->getSheetByIndex(0);
	if (!xSheet) return;
	XNamedRef xNamed = (XNamed*)xSheet->queryInterface(XNamed::getSmartUik());
	if (!xNamed) return;

	String aName = OUStringToString( xNamed->getName(), CHARSET_SYSTEM );
	aName += 'X';
	xNamed->setName(StringToOUString( aName, CHARSET_SYSTEM ));

	XCellRangeRef xRange = (XCellRange*)xSheet->queryInterface(XCellRange::getSmartUik());
	if (!xRange) return;
	XCellRef xCell = xRange->getCell(2,1);
	if (!xCell) return;
	XTextRef xText = (XText*)xCell->queryInterface(XText::getSmartUik());
	if (!xText) return;
	String aBla = OUStringToString( xText->getText(), CHARSET_SYSTEM );
	aBla += "bla";
	xText->setText(StringToOUString( aBla, CHARSET_SYSTEM ));

	XColumnRowRangeRef xCRR = (XColumnRowRange*)xSheet->queryInterface(XColumnRowRange::getSmartUik());
	if (!xCRR) return;

	XTableColumnsRef xCols = xCRR->getColumns();
	if (!xCols) return;
	XPropertySetRef xCol = xCols->getColumnByIndex(2);
	if (!xCol) return;

	UINT16 nWidth = TypeConversion::toUINT16(xCol->getPropertyValue(L"Width"));
//	UINT16 nNewWidth = nWidth + 100;
//	xCol->setPropertyValue(L"Width", UsrAny(nNewWidth));

	xCol->setPropertyValue(L"OptimalWidth", UsrAny((BOOL)TRUE));
	xCol->setPropertyValue(L"NewPage", UsrAny((BOOL)FALSE));

	UsrAny aAny = xCol->getPropertyValue(L"ShadowFormat");
	if ( aAny.getReflection()->getName() ==
		 ShadowFormat_getReflection()->getName() )
	{
		//ShadowFormat* pOld = (ShadowFormat*)aAny.get();
		ShadowFormat aNew;
		aNew.Location		= SHADOWLOCATION_BOTTOMRIGHT;
		aNew.ShadowWidth	= 100;
		aNew.IsTransparent	= FALSE;
		aNew.Color			= 0xff0000L;
		aAny.set( &aNew, aAny.getReflection() );
		xCol->setPropertyValue(L"ShadowFormat", aAny);
	}

	XTableRowsRef xRows = xCRR->getRows();
	if (!xRows) return;
	XPropertySetRef xRow = xRows->getRowByIndex(1);
	if (!xRow) return;

	xRows->removeRowsByIndex( 2, 1 );

	UINT16 nHeight = TypeConversion::toUINT16(xRow->getPropertyValue(L"Height"));
	BOOL bOptH = TypeConversion::toBOOL(xRow->getPropertyValue(L"OptimalHeight"));

	UINT16 nNewHeight = nHeight + 100;
	xRow->setPropertyValue(L"Height", UsrAny(nNewHeight));

	aTimeText.SetText(String("W:")+String(nWidth)+String(" H:")+String(nHeight)+
						String(" ")+String((USHORT)bOptH));
}

void lcl_Names( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XNamedRangesRef xNames = xDoc->getNamedRanges();
	if (!xNames) return;
	XNamedRangeRef xName = xNames->getRangeByName(L"bla");
	if (!xName) return;
	String aCont = OUStringToString( xName->getContent(), CHARSET_SYSTEM );
	aTimeText.SetText(aCont);

	XCellRangeSourceRef xSource = (XCellRangeSource*)
							xName->queryInterface(XCellRangeSource::getSmartUik());
	if (!xSource) return;
	XCellRangeRef xRange = xSource->getReferredCells();
	if (!xRange) return;
	XPropertySetRef xProp = (XPropertySet*)xRange->queryInterface(XPropertySet::getSmartUik());
	if (!xProp) return;
	UsrAny aAny = xProp->getPropertyValue(L"RotationValue");
	aAny.setINT32(3000);
	xProp->setPropertyValue(L"RotationValue", aAny);
}

void lcl_Sheets( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;

#if 0
	xSheets->insertSheet( "hinten", 100 );
	xSheets->insertSheet( "vorne", 0 );
	xSheets->removeSheetByName( "hinten" );
	xSheets->removeSheetByName( "vorne" );
#endif

	xSheets->moveSheet(0, 1, TRUE);
	xSheets->moveSheet(0, 2, FALSE);
}

void lcl_Goal( FixedText& aTimeText )
{
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XGoalSeekRef xGoal = (XGoalSeek*)xDoc->queryInterface(XGoalSeek::getSmartUik());
	if (!xGoal) return;

	double fResult;
	CellAddress aFormula;	// A1
	aFormula.Sheet  = 0;
	aFormula.Column = 0;
	aFormula.Row    = 0;
	CellAddress aVar;		// A2
	aVar.Sheet  = 0;
	aVar.Column = 0;
	aVar.Row    = 1;
	BOOL bFound = xGoal->doGoalSeek(fResult, aFormula, aVar, L"42");

	if (bFound)
	{
		CellAddress aOut;		// A3
		aOut.Sheet  = 0;
		aOut.Column = 0;
		aOut.Row    = 2;

		XCellRef xCell = xDoc->getCell(aOut);
		if (!xCell) return;
		xCell->setValue(fResult);
	}
}

void lcl_TabOp( FixedText& aTimeText )
{
	//	Mehrfachoperation auf Tabelle2
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;

	XCellRangeRef xRange;
	XTableOperationRef xGoal;
	CellRangeAddress aRangeAddr;
	CellRangeAddress aFormulaRange;
	CellAddress aColumnCell;
	CellAddress aRowCell;
	TableOperationMode nMode;

	aRangeAddr.Sheet			= 1;	// c9:e11
	aRangeAddr.StartColumn		= 2;
	aRangeAddr.StartRow			= 8;
	aRangeAddr.EndColumn		= 4;
	aRangeAddr.EndRow			= 10;
	aFormulaRange.Sheet			= 1;	// c6:c7
	aFormulaRange.StartColumn	= 2;
	aFormulaRange.StartRow		= 5;
	aFormulaRange.EndColumn		= 2;
	aFormulaRange.EndRow		= 6;
	aColumnCell.Sheet			= 0;	// nicht benutzt
	aColumnCell.Column			= 0;
	aColumnCell.Row				= 0;
	aRowCell.Sheet				= 1;	// c5
	aRowCell.Column				= 2;
	aRowCell.Row				= 4;
	nMode = TABLEOP_ROW;

	xRange = xDoc->getCellRange(aRangeAddr);
	if (!xRange) return;
	xGoal = (XTableOperation*)xRange->queryInterface(XTableOperation::getSmartUik());
	if (!xGoal) return;
	xGoal->setTableOperation( nMode, aFormulaRange, aColumnCell, aRowCell );

	aRangeAddr.Sheet			= 1;	// b19:d21
	aRangeAddr.StartColumn		= 1;
	aRangeAddr.StartRow			= 18;
	aRangeAddr.EndColumn		= 3;
	aRangeAddr.EndRow			= 20;
	aFormulaRange.Sheet			= 1;	// c16:d16
	aFormulaRange.StartColumn	= 2;
	aFormulaRange.StartRow		= 15;
	aFormulaRange.EndColumn		= 3;
	aFormulaRange.EndRow		= 15;
	aColumnCell.Sheet			= 1;	// b16
	aColumnCell.Column			= 1;
	aColumnCell.Row				= 15;
	aRowCell.Sheet				= 0;	// nicht benutzt
	aRowCell.Column				= 0;
	aRowCell.Row				= 0;
	nMode = TABLEOP_COLUMN;

	xRange = xDoc->getCellRange(aRangeAddr);
	if (!xRange) return;
	xGoal = (XTableOperation*)xRange->queryInterface(XTableOperation::getSmartUik());
	if (!xGoal) return;
	xGoal->setTableOperation( nMode, aFormulaRange, aColumnCell, aRowCell );

	aRangeAddr.Sheet			= 1;	// b29:e32
	aRangeAddr.StartColumn		= 1;
	aRangeAddr.StartRow			= 28;
	aRangeAddr.EndColumn		= 4;
	aRangeAddr.EndRow			= 31;
	aFormulaRange.Sheet			= 1;	// c27:c27
	aFormulaRange.StartColumn	= 2;
	aFormulaRange.StartRow		= 26;
	aFormulaRange.EndColumn		= 2;
	aFormulaRange.EndRow		= 26;
	aColumnCell.Sheet			= 1;	// c25
	aColumnCell.Column			= 2;
	aColumnCell.Row				= 24;
	aRowCell.Sheet				= 1;	// c26
	aRowCell.Column				= 2;
	aRowCell.Row				= 25;
	nMode = TABLEOP_BOTH;

	xRange = xDoc->getCellRange(aRangeAddr);
	if (!xRange) return;
	xGoal = (XTableOperation*)xRange->queryInterface(XTableOperation::getSmartUik());
	if (!xGoal) return;
	xGoal->setTableOperation( nMode, aFormulaRange, aColumnCell, aRowCell );
}

void lcl_Fill( FixedText& aTimeText )
{
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;

	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;

	XCellSeriesRef xFill = (XCellSeries*)xSelInt->queryInterface(XCellSeries::getSmartUik());
	if (!xFill) return;

//	xFill->fillAuto( FILL_DIRECTION_TO_BOTTOM, 2 );

	xFill->fillSeries( FILL_DIRECTION_TO_LEFT, FILL_MODE_GROWTH, FILL_DATE_DAY,
						2.0, 1000.0 );
}

void lcl_Audi( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;
	XTableSheetRef xSheet = xSheets->getSheetByIndex(0);
	if (!xSheet) return;

	XSheetAuditingRef xAudi = (XSheetAuditing*)xSheet->queryInterface(XSheetAuditing::getSmartUik());
	if (!xAudi) return;

	CellAddress aPosition;
	aPosition.Sheet		= 0;
	aPosition.Column	= 0;
	aPosition.Row		= 0;
	xAudi->showDependents(aPosition);
}

void lcl_Consoli( FixedText& aTimeText )
{
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XConsolidationRef xCons = (XConsolidation*)xDoc->queryInterface(XConsolidation::getSmartUik());
	if (!xCons) return;
	XConsolidationDescriptorRef xDesc = xCons->createConsolidationDescriptor(FALSE);
	if (!xDesc) return;
	xDesc->setFunction(SUMMARY_COUNTNUMS);
	xCons->consolidate(xDesc);
}

void lcl_Sort( FixedText& aTimeText )
{
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XSortableRef xSort = (XSortable*)xSelInt->queryInterface(XSortable::getSmartUik());
	if (!xSort) return;
	XSortDescriptorRef xDesc = xSort->createSortDescriptor(FALSE);
	if (!xDesc) return;
	Sequence<SortField> aFields = xDesc->getSortFields();
	if (aFields.getLen())
	{
		//	1.Feld umkehren
		SortField* pAry = aFields.getArray();
		if (!pAry) return;
		pAry[0].Ascending = !pAry[0].Ascending;
	}
	else	// neue Sequence, 1. Spalte aufsteigend
	{
		aFields = Sequence<SortField>(1);
		SortField* pAry = aFields.getArray();
		if (!pAry) return;
		pAry[0].Field	  = 0;
		pAry[0].Ascending = TRUE;
		pAry[0].Type	  = SORT_FIELD_AUTOMATIC;
	}
	xDesc->setSortFields(aFields);

	XTableSortDescriptorRef xTableSort = (XTableSortDescriptor*)
							xDesc->queryInterface(XTableSortDescriptor::getSmartUik());
	if (!xTableSort) return;
	CellAddress aOutPos;
	aOutPos.Sheet  = 2;
	aOutPos.Column = 0;
	aOutPos.Row    = 0;
	xTableSort->setUseOutputPosition(TRUE);
	xTableSort->setOutputPosition(aOutPos);

	XPropertySetRef xPropSet = (XPropertySet*)
							xDesc->queryInterface(XPropertySet::getSmartUik());
	if (!xPropSet) return;
	xPropSet->setPropertyValue(L"IncludeFormats", UsrAny((BOOL)FALSE));

	xSort->sort(xDesc);
}

void lcl_Filter( FixedText& aTimeText )
{
	aTimeText.SetText("...");

	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XFilterableRef xFilter = (XFilterable*)xSelInt->queryInterface(XFilterable::getSmartUik());
	if (!xFilter) return;

#if 0
	XTableFilterDescriptorRef xDesc = xFilter->createFilterDescriptor(FALSE);
	if (!xDesc) return;
	Sequence<TableFilterField> aFields = xDesc->getFilterFields();
	if (aFields.getLen())
	{
		//	1.Feld zwischen 1. und 2. Spalte toggeln
		TableFilterField* pAry = aFields.getArray();
		if (!pAry) return;
		pAry[0].Field = pAry[0].Field ? 0 : 1;
	}
	xDesc->setFilterFields(aFields);
	xFilter->filter(xDesc);
#endif

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	CellRangeAddress aAddress;
	aAddress.Sheet		 = 3;
	aAddress.StartColumn = 0;
	aAddress.StartRow	 = 0;
	aAddress.EndColumn	 = 1;
	aAddress.EndRow		 = 2;
	XCellRangeRef xRange = xDoc->getCellRange(aAddress);
	if (!xRange) return;
	XAdvancedFilterSourceRef xSource = (XAdvancedFilterSource*)
							xRange->queryInterface(XAdvancedFilterSource::getSmartUik());
	if (!xSource) return;

	XTableFilterDescriptorRef xDesc = xSource->createAdvancedFilter(xFilter);
	if (!xDesc)
	{
		aTimeText.SetText("kein Filter");
		return;
	}
	aTimeText.SetText("Filter gefunden");
	xFilter->filter(xDesc);
}

void lcl_AutoFilter( FixedText& aTimeText )
{
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XFilterableRef xFilter = (XFilterable*)xSelInt->queryInterface(XFilterable::getSmartUik());
	if (!xFilter) return;

	BOOL bAuto = xFilter->getAutoFilter();
	xFilter->setAutoFilter(!bAuto);
}

void lcl_Merge( FixedText& aTimeText )
{
	static BOOL bMerged = FALSE;

	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XMergeableRef xMerge = (XMergeable*)xSelInt->queryInterface(XMergeable::getSmartUik());
	if (!xMerge) return;

	if (bMerged)
		xMerge->unmergeCells();
	else
		xMerge->mergeCells();
	bMerged = !bMerged;
}

void lcl_Outline( FixedText& aTimeText )
{
	static BOOL bOutline = FALSE;

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;
	XTableSheetRef xSheet = xSheets->getSheetByIndex(0);
	if (!xSheet) return;
	XSheetOutlineRef xOut = (XSheetOutline*)xSheet->queryInterface(XSheetOutline::getSmartUik());
	if (!xOut) return;

	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XAddressableCellRangeRef xRange = (XAddressableCellRange*)
								xSelInt->queryInterface(XAddressableCellRange::getSmartUik());
	if (!xRange) return;
	CellRangeAddress aRange = xRange->getRangeAddress();

	if (bOutline)
		xOut->showDetail( aRange );
	else
		xOut->hideDetail( aRange );

	bOutline = !bOutline;
}

void lcl_Bla( FixedText& aTimeText )
{
	aTimeText.SetText("...");

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XActionLockableRef xLock = (XActionLockable*)xDoc->queryInterface(XActionLockable::getSmartUik());
	if (!xLock) return;
	xLock->addActionLock();
	xLock->addActionLock();
	USHORT nCount = xLock->resetActionLocks();		// sollte 2 sein
	String aBla = nCount;
	xLock->setActionLocks(nCount);
	xLock->removeActionLock();
	xLock->removeActionLock();

	aBla += '/'; aBla += xLock->resetActionLocks();	// sollte 0 sein

	aTimeText.SetText(aBla);
}

void lcl_CellCursor( FixedText& aTimeText )
{
	static int nCursorCount = 0;

	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XCellCollectionRef xColl = (XCellCollection*)xSelInt->queryInterface(XCellCollection::getSmartUik());
	if (!xColl) return;

	XLineCursorRef xCursor = xColl->createCursor();
	if (!xCursor) return;
	XCellCursorRef xCC = (XCellCursor*)xCursor->queryInterface(XCellCursor::getSmartUik());
	if (!xCC) return;
	XCellRangesCursorRef xCRC = (XCellRangesCursor*)xCursor->queryInterface(XCellRangesCursor::getSmartUik());
	if (!xCRC) return;
	XCellRangeCursorRef xCR = (XCellRangeCursor*)xCursor->queryInterface(XCellRangeCursor::getSmartUik());
	if (!xCR) return;
	XCellContentCursorRef xCCC = (XCellContentCursor*)xCursor->queryInterface(XCellContentCursor::getSmartUik());
	if (!xCCC) return;
	XFormulaCursorRef xFC = (XFormulaCursor*)xCursor->queryInterface(XFormulaCursor::getSmartUik());
	if (!xFC) return;

	CellAddress aPos;
	aPos.Sheet  = 0;		// ignored
	aPos.Row    = 3;
	aPos.Column = 2;

	switch (nCursorCount++)
	{
		case 0:
			xFC->gotoDependents(FALSE);
			break;
		case 1:
			xFC->gotoDependents(TRUE);
			break;
		case 2:
			xFC->gotoPrecedents(FALSE);
			break;
		case 3:
			xFC->gotoPrecedents(TRUE);

			nCursorCount = 0;
			break;
	}

	XCellCollectionRef xNew = xCC->getRanges();
	if (!xNew) return;
	xView->select( xNew );
}

void lcl_Notes( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;
	XTableSheetRef xSheet = xSheets->getSheetByIndex(0);
	if (!xSheet) return;

	XSheetAnnotationsRef xNotes = xSheet->getAnnotations();
	if (!xNotes) return;
	XIndexAccessRef xNIndex = (XIndexAccess*)xNotes->queryInterface(XIndexAccess::getSmartUik());
	if (!xNIndex) return;

	CellAddress aPos;
	aPos.Column	= 0;
	aPos.Row	= 0;
	aPos.Sheet	= 0;
	xNotes->addAnnotation( L"neu", aPos );

	ULONG nCount = xNIndex->getCount();
	for (ULONG i=0; i<nCount; i++)
	{
		XSheetAnnotationRef xAnn = xNotes->getAnnotationByIndex((UINT16)i);
		XTextRef xText = (XText*)xAnn->queryInterface(XText::getSmartUik());
		if (xText)
		{
			String aStr = OUStringToString( xText->getText(), CHARSET_SYSTEM );
			aStr += "x";
			xText->setText(StringToOUString( aStr, CHARSET_SYSTEM ));
		}
	}
}

void lcl_Scenario( FixedText& aTimeText )
{
	aTimeText.SetText( "..." );
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;
	XTableSheetRef xSheet = xSheets->getSheetByIndex(0);
	if (!xSheet) return;

	XScenariosRef xColl = xSheet->getScenarios();
	if (!xColl) return;

	Sequence<CellRangeAddress> aRanges(2);
	CellRangeAddress* pAry = aRanges.getArray();
	if (!pAry) return;
	pAry[0].Sheet	  	= 0;
	pAry[0].StartColumn	= 0;
	pAry[0].StartRow	= 0;
	pAry[0].EndColumn	= 1;
	pAry[0].EndRow		= 1;
	pAry[1].Sheet	  	= 0;
	pAry[1].StartColumn	= 3;
	pAry[1].StartRow	= 3;
	pAry[1].EndColumn	= 4;
	pAry[1].EndRow		= 4;

	xColl->addScenario( aRanges, L"bla", L"bla blubb" );

	XIndexAccessRef xIndex = (XIndexAccess*)xColl->queryInterface(XIndexAccess::getSmartUik());
	if (!xIndex) return;
	ULONG nCount = xIndex->getCount();
	aTimeText.SetText( nCount );

	XScenarioRef xScen = xColl->getScenarioByIndex(0);
	if (!xScen) return;

	aRanges = Sequence<CellRangeAddress>(1);
	pAry = aRanges.getArray();
	if (!pAry) return;
	pAry[0].Sheet	  	= 0;
	pAry[0].StartColumn	= 6;
	pAry[0].StartRow	= 6;
	pAry[0].EndColumn	= 7;
	pAry[0].EndRow		= 7;

	xScen->addRanges( aRanges );

	XTableSheetRef xSh2 = xSheets->getSheetByIndex(1);
	if (!xSh2) return;

	xSh2->setVisible( TRUE );
	xSh2->setVisible( FALSE );
}

void lcl_Formula( FixedText& aTimeText )
{
	aTimeText.SetText("...");

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	CellAddress aPos;
	aPos.Sheet  = 0;
	aPos.Column = 0;
	aPos.Row    = 0;
	XCellRef xCell = xDoc->getCell(aPos);
	if (!xCell) return;

//	String aStr = OUStringToString( xCell->getFormula(), CHARSET_SYSTEM );
//	aTimeText.SetText(aStr);

	XTextRef xText = (XText*)xCell->queryInterface(XText::getSmartUik());
	if (!xText) return;
	String aStr = OUStringToString( xText->getText(), CHARSET_SYSTEM );
	aTimeText.SetText(aStr);
}

void lcl_DBRange( FixedText& aTimeText )	// 23
{
	aTimeText.SetText("...");

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XDatabaseRangesRef xDBs = xDoc->getDatabaseRanges();
	if (!xDBs) return;

	CellRangeAddress aRange;
	aRange.Sheet		= 0;
	aRange.StartColumn	= 1;
	aRange.StartRow		= 1;
	aRange.EndColumn	= 3;
	aRange.EndRow		= 10;

	xDBs->addRange( L"blubb", aRange );

	xDBs->removeRangeByName( L"gaga" );

	XDatabaseRangeRef xDB = xDBs->getRangeByName( L"blubb" );
	if (!xDB) return;

	String aName = OUStringToString( xDB->getName(), CHARSET_SYSTEM );
	aTimeText.SetText(aName);

	xDB->setName( L"gaga" );

	CellRangeAddress aDBRange = xDB->getDataArea();
	++aDBRange.Sheet;
	xDB->setDataArea(aDBRange);
}

void lcl_FillTab( FixedText& aTimeText )	// 24
{
	aTimeText.SetText("...");

	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;

	XCellRangesRef xRanges = (XCellRanges*)xSelInt->queryInterface(XCellRanges::getSmartUik());
	XIndexAccessRef xIndex = (XIndexAccess*)xSelInt->queryInterface(XIndexAccess::getSmartUik());
	if (!xRanges || !xIndex) return;

	ULONG nCount = xIndex->getCount();
	aTimeText.SetText(nCount);
}

void lcl_Listener( FixedText& aTimeText )	// 25
{
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XStarCalcViewRef xView = (XStarCalcView*)xInt->queryInterface(XStarCalcView::getSmartUik());
	if (!xView) return;
	xView->addSelectionChangeListener( new ScTestListener(&aTimeText) );
}

void lcl_CellAttrib( FixedText& aTimeText )	// 26
{
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return;
	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return;
	XTextRef xText = (XText*)xSelInt->queryInterface(XText::getSmartUik());
	if (!xText) return;

	XTextCursorRef xCursor = xText->createTextCursor();
	if (!xCursor) return;

	XTextPositionRef xPos = (XTextPosition*)xCursor->queryInterface(XTextPosition::getSmartUik());
	XPropertySetRef xProp = (XPropertySet*)xCursor->queryInterface(XPropertySet::getSmartUik());
	XParagraphCursorRef xPar = (XParagraphCursor*)xCursor->queryInterface(XParagraphCursor::getSmartUik());
	if (!xPos || !xProp || !xPar) return;

	xCursor->gotoStart(FALSE);
	xCursor->goRight(1,FALSE);
	xCursor->goRight(1,TRUE);

	UsrAny aAny = xProp->getPropertyValue(L"FontHeight");
	UINT32 nOld = aAny.getUINT32();
	aAny.setUINT32(nOld*11/10);
	xProp->setPropertyValue(L"FontHeight", aAny);

	xPos->collapseToEnd();
	xCursor->goRight(1,TRUE);

	xProp->setPropertyValue(L"Bold", UsrAny((BOOL)TRUE));

	xPos->setText(L"x");

	xPos->collapseToEnd();
	xPar->gotoNextParagraph(FALSE,TRUE);
	xProp->setPropertyValue(L"Italic", UsrAny((BOOL)TRUE));
	xProp->setPropertyValue(L"Underlined", UsrAny((BOOL)TRUE));
}

void lcl_Styles( FixedText& aTimeText )	// 27
{
	aTimeText.SetText("...");
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XStyleFamiliesRef xFamilies = xDoc->getStyleFamilies();
	if (!xFamilies) return;
	XStyleFamilyRef	xFamily = xFamilies->getStyleFamilyByType( STYLE_FAMILY_CELL );
//	XStyleFamilyRef	xFamily = xFamilies->getStyleFamilyByType( STYLE_FAMILY_PAGE );
	if (!xFamily) return;
	long nCount = xFamily->getCount();
	aTimeText.SetText(nCount);

	XStyleRef xStyle = xFamily->getStyleByName(L"rot");
	if (!xStyle) return;
//	XPropertySetRef xProp = (XPropertySet*)xStyle->queryInterface(XPropertySet::getSmartUik());
//	if (!xProp) return;

	XStyleRef xNew = xFamily->addStyle( L"gaga", xStyle );
	if (!xNew) return;
	XPropertySetRef xProp = (XPropertySet*)xNew->queryInterface(XPropertySet::getSmartUik());
	if (!xProp) return;

	UsrAny aAny;
	aAny = xProp->getPropertyValue(L"TransparentBackground");
	aAny.setBOOL(FALSE);
	xProp->setPropertyValue(L"TransparentBackground", aAny);
	aAny = xProp->getPropertyValue(L"BackgroundColor");
	aAny.setUINT32(0xffff00);
	xProp->setPropertyValue(L"BackgroundColor", aAny);

	xFamily->removeStyle( L"rot" );
}

void lcl_PageStyle( FixedText& aTimeText )	// 28
{
	aTimeText.SetText("...");

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;
	XStyleFamiliesRef xFamilies = xDoc->getStyleFamilies();
	if (!xFamilies) return;
	XStyleFamilyRef	xFamily = xFamilies->getStyleFamilyByType( STYLE_FAMILY_PAGE );
	if (!xFamily) return;
	XStyleRef xStyle = xFamily->getStyleByName(L"Standard");
	if (!xStyle) return;
	XPropertySetRef xProp = (XPropertySet*)xStyle->queryInterface(XPropertySet::getSmartUik());
	if (!xProp) return;

	UsrAny aAny;
	aAny = xProp->getPropertyValue(L"RightPageHeaderContent");

	// geht nicht:
//	if ( !XHeaderFooterContent_getReflection()->equals(*aAny.getReflection()) )
//		return;

	XHeaderFooterContentRef* pxContent = (XHeaderFooterContentRef*)aAny.get();
	if (!pxContent || !pxContent->is()) return;

	XTextRef xText = (*pxContent)->getCenterText();
	if (!xText) return;

	String aVal = OUStringToString(xText->getText(), CHARSET_SYSTEM);
	aTimeText.SetText(aVal);

//  xText->setText(L"Bla fasel s\xFClz");
	lcl_SetText(xText);

	xProp->setPropertyValue(L"RightPageHeaderContent", aAny);
}

void lcl_AutoForm( FixedText& aTimeText )	// 29
{
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return;

#if 0
	//!	Test - AutoFormat muss von der App kommen
	XStarCalcViewRef xView = (XStarCalcView*)xInt->queryInterface(XStarCalcView::getSmartUik());
	if (!xView) return;
	XTableAutoFormatsRef xFormats = xView->getTableAutoFormats();
	if (!xFormats) return;
	//!	Test
#endif
	XTableAutoFormatsRef xFormats;

	XTableAutoFormatRef xFormat = xFormats->getAutoFormatByName(L"gaga");
	if (!xFormat) return;
	XPropertySetRef xProp = (XPropertySet*)xFormat->queryInterface(XPropertySet::getSmartUik());
	if (!xProp) return;

	BOOL bVal = TypeConversion::toBOOL(xProp->getPropertyValue(L"IncludeBackground"));
	xProp->setPropertyValue(L"IncludeBackground", UsrAny(BOOL(!bVal)));

	XNamedRef xNamed = (XNamed*)xFormat->queryInterface(XNamed::getSmartUik());
	if (!xNamed) return;
	xNamed->setName(L"zzz");

	xFormats->addAutoFormat(L"gaga");
	XTableAutoFormatRef xNew = xFormats->getAutoFormatByName(L"gaga");
	if (!xNew) return;

	for (USHORT i=0; i<16; i++)
	{
		XPropertySetRef xNewProp = xNew->getFieldByIndex(i);
		if (!xNewProp) return;

		xNewProp->setPropertyValue(L"TransparentBackground", UsrAny(BOOL(FALSE)));
		UINT32 nColor = 0x111100 * i;
		xNewProp->setPropertyValue(L"BackgroundColor", UsrAny(nColor));
	}
}

void lcl_Pivot( FixedText& aTimeText )	// 30
{
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (!xDoc) return;

	XSpreadsheetsRef xSheets = xDoc->getSheets();
	if (!xSheets) return;
	XIndexAccessRef xInd = (XIndexAccess*)xSheets->queryInterface(XIndexAccess::getSmartUik());
	if (!xInd) return;
	USHORT nCount = (USHORT)xInd->getCount();

	for (USHORT nTab=0; nTab<nCount; nTab++)
	{
		XTableSheetRef xSheet = xSheets->getSheetByIndex(nTab);
		if (!xSheet) return;
		XDataPilotTablesRef xPivots = xSheet->getDataPilotTables();
		if (!xPivots) return;
		lcl_OutputNames( xPivots, xDoc, nTab,0,0 );
		XIndexAccessRef xPInd = (XIndexAccess*)xPivots->queryInterface(XIndexAccess::getSmartUik());
		if (!xPInd) return;
		USHORT nPCount = (USHORT)xPInd->getCount();
		for (USHORT nP=0; nP<nPCount; nP++)
		{
			XDataPilotTableRef xTable = xPivots->getTableByIndex(nP);
			if (!xTable) return;

//			xTable->refreshTable();

			XDataPilotDescriptorRef xDesc = (XDataPilotDescriptor*)
							xTable->queryInterface(XDataPilotDescriptor::getSmartUik());
			if (!xDesc) return;
			CellRangeAddress aSource = xDesc->getSourceRange();
			++aSource.Sheet;
			xDesc->setSourceRange(aSource);

			CellRangeAddress aAddr = xTable->getOutputRange();
			XCellRangeRef xRange = xDoc->getCellRange(aAddr);
			if (!xRange) return;
			XPropertySetRef xProp = (XPropertySet*)xRange->queryInterface(XPropertySet::getSmartUik());
			if (!xProp) return;
			xProp->setPropertyValue(L"TransparentBackground", UsrAny(BOOL(FALSE)));
			xProp->setPropertyValue(L"BackgroundColor", UsrAny((UINT32)0x00FF00));
		}
	}
}

IMPL_LINK(MyWindow, CountHdl, PushButton*, EMPTYARG)
{
#if 0

	long nCount = aCountField.GetValue();
	if (nCount < 1)
		nCount = 1;

	ULONG nStart = Time::GetSystemTicks();
	for (long i=0; i<nCount; i++)
		lcl_DoCount();
	ULONG nEnd = Time::GetSystemTicks();
	aTimeText.SetText(String(nCount)+String(" x Count: ")+String(nEnd-nStart)+String(" ms"));

#else

	long nCount = aCountField.GetValue();
	switch ( nCount )
	{
		case 0:
			{
				ULONG nStart = Time::GetSystemTicks();
				lcl_DoCount();
				ULONG nEnd = Time::GetSystemTicks();
				aTimeText.SetText(String("Count: ")+String(nEnd-nStart)+String(" ms"));
			}
			break;
		case 1:
			lcl_GlobalCell();
			break;
		case 2:
			lcl_Annotations(aTimeText);
			break;
		case 3:
			lcl_Cursor(aTimeText);
			break;
		case 4:
			lcl_Cells(aTimeText);
			break;
		case 5:
			lcl_Sheet(aTimeText);
			break;
		case 6:
			lcl_Names(aTimeText);
			break;
		case 7:
			lcl_Sheets(aTimeText);
			break;
		case 8:
			lcl_Goal(aTimeText);
			break;
		case 9:
			lcl_TabOp(aTimeText);
			break;
		case 10:
			lcl_Fill(aTimeText);
			break;
		case 11:
			lcl_Audi(aTimeText);
			break;
		case 12:
			lcl_Consoli(aTimeText);
			break;
		case 13:
			lcl_Sort(aTimeText);
			break;
		case 14:
			lcl_Filter(aTimeText);
			break;
		case 15:
			lcl_AutoFilter(aTimeText);
			break;
		case 16:
			lcl_Merge(aTimeText);
			break;
		case 17:
			lcl_Outline(aTimeText);
			break;
		case 18:
			lcl_Bla(aTimeText);
			break;
		case 19:
			lcl_CellCursor(aTimeText);
			break;
		case 20:
			lcl_Notes(aTimeText);
			break;
		case 21:
			lcl_Scenario(aTimeText);
			break;
		case 22:
			lcl_Formula(aTimeText);
			break;
		case 23:
			lcl_DBRange(aTimeText);
			break;
		case 24:
			lcl_FillTab(aTimeText);
			break;
		case 25:
			lcl_Listener(aTimeText);
			break;
		case 26:
			lcl_CellAttrib(aTimeText);
			break;
		case 27:
			lcl_Styles(aTimeText);
			break;
		case 28:
			lcl_PageStyle(aTimeText);
			break;
		case 29:
			lcl_AutoForm(aTimeText);
			break;
		case 30:
			lcl_Pivot(aTimeText);
			break;
	}

#endif

	return 0;
}

//-----------------------------------------------------------------------

IMPL_LINK(MyWindow, TextHdl, PushButton*, EMPTYARG)
{
	USHORT nTab = 0;
	USHORT nCol = (USHORT)aColField.GetValue();
	USHORT nRow = (USHORT)aRowField.GetValue();
	USHORT nPos = (USHORT)aPosField.GetValue();
	USHORT nLen = (USHORT)aLenField.GetValue();
	String aStr = aTextEdit.GetText();

	aTimeText.SetText("...");

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		CellAddress aPos;
		aPos.Sheet  = nTab;
		aPos.Column = nCol;
		aPos.Row    = nRow;
		XCellRef xCell = xDoc->getCell(aPos);
		if ( xCell )
		{
			XTextRef xCellText = (XText*)xCell->queryInterface(XText::getSmartUik());
			if (xCellText)
			{
				XTextCursorRef xCursor = xCellText->createTextCursor();
				if (xCursor)
				{
					XTextPositionRef xPos = (XTextPosition*)
						xCursor->queryInterface(XTextPosition::getSmartUik());
					XControlCharacterInsertableRef xControl = (XControlCharacterInsertable*)
						xCursor->queryInterface(XControlCharacterInsertable::getSmartUik());

					if (xPos && xControl)
					{
						xCursor->gotoStart(FALSE);
						xCursor->goRight(11,TRUE);
						String aVal = OUStringToString( xPos->getText(), CHARSET_SYSTEM );
						aTimeText.SetText(aVal);
					}
				}
			}
		}
	}

	return 0;
}

//-----------------------------------------------------------------------

IMPL_LINK(MyWindow, BlaHdl, PushButton*, EMPTYARG)
{
	aTimeText.SetText("...");

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		CellAddress aPos;
		aPos.Sheet  = 0;
		aPos.Column = 1;
		aPos.Row    = 2;
		XCellRef xCell = xDoc->getCell(aPos);
		if ( xCell )
		{
			XTextRef xText = (XText*)xCell->queryInterface(XText::getSmartUik());
			XFieldContainerRef xCont = (XFieldContainer*)
								xCell->queryInterface(XFieldContainer::getSmartUik());

			if ( xText && xCont )
			{
				XFieldTypesRef xTypes = xCont->getFieldTypes();
				if ( xTypes )
				{
					XTextFieldTypeRef xType = xTypes->getFieldType( FIELDTYPE_INTERNET );
					XTextCursorRef xCursor = xText->createTextCursor();
					if ( xCursor && xType )
					{
#if 0
						//	Feld einfuegen
						XTextPositionRef xPos = (XTextPosition*)
									xCursor->queryInterface(XTextPosition::getSmartUik());
						if ( xPos )
						{
							xCursor->gotoEnd(FALSE);
							XTextFieldRef xField = xTypes->insertTextField( xType, xPos );
							if (xField)
							{
								//	Eigenschaften setzen
								XPropertySetRef xProp = (XPropertySet*)xField->
												queryInterface(XPropertySet::getSmartUik());
								if ( xProp )
								{
									xProp->setPropertyValue(L"URL",
												UsrAny(String("http://www.mopo.de/")));
									xProp->setPropertyValue(L"Representation",
												UsrAny(String("ein Hyperlink")));
								}
							}
						}
#endif

						//	letztes Feld loeschen
						XIndexAccessRef xIndex = (XIndexAccess*)
									xType->queryInterface(XIndexAccess::getSmartUik());
						if (xIndex)
						{
							String aBla;
							ULONG nCount = xIndex->getCount();
							for (ULONG i=0; i<nCount; i++)
							{
								XInterfaceRef xInt = xIndex->getElementByIndex(i);
								if (xInt)
								{
									XPropertySetRef xProp = (XPropertySet*)xInt->
													queryInterface(XPropertySet::getSmartUik());
									if ( xProp )
									{
										if (aBla.Len()) aBla += ',';
										aBla += OUStringToString(
													TypeConversion::toString(
														xProp->getPropertyValue(L"URL") ),
													CHARSET_SYSTEM );
									}
									if ( i+1 == nCount )		// letztes
									{
										XTextFieldRef xField = (XTextField*)xInt->
													queryInterface(XTextField::getSmartUik());
										if (xField)
											xTypes->removeTextField(xField);
									}
								}
							}
							aTimeText.SetText(aBla);
						}
					}
				}
			}
		}

		xGlobalCell = xCell;
	}
	return 0;
}


//-----------------------------------------------------------------------

IMPL_LINK(MyWindow, TabHdl, PushButton*, EMPTYARG)
{
	String aResult;

	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	if (xDoc)
	{
		XSpreadsheetsRef xSheets = xDoc->getSheets();
		if (xSheets)
		{
			XIndexAccessRef xIndex = (XIndexAccess*)xSheets->queryInterface(XIndexAccess::getSmartUik());
			if (xIndex)
			{
				USHORT nCount = (USHORT) xIndex->getCount();
				for (USHORT nTab=0; nTab<nCount; nTab++)
				{
					XInterfaceRef xInt = xIndex->getElementByIndex(nTab);
					if (xInt)
					{
						XNamedRef xNamed = (XNamed*)xInt->queryInterface(XNamed::getSmartUik());
						if (xNamed)
						{
							if (nTab)
								aResult += ",";
							aResult += OUStringToString( xNamed->getName(), CHARSET_SYSTEM );
						}
					}
				}
			}

			CellAddress aPos;
			aPos.Sheet  = 0;
			aPos.Column = 0;
			aPos.Row    = 0;

			XEnumerationAccessRef xEAcc = (XEnumerationAccess*)
							xSheets->queryInterface(XEnumerationAccess::getSmartUik());
			if (xEAcc)
			{
				XEnumerationRef xEnum = xEAcc->getEnumeration();
				if (xEnum)
				{
					while (xEnum->hasMoreElements())
					{
						XInterfaceRef xInt = xEnum->nextElement();
						if (xInt)
						{
							XNamedRef xNamed = (XNamed*)xInt->queryInterface(XNamed::getSmartUik());
							if (xNamed)
							{
								UString aName = xNamed->getName();
								XCellRef xCell = xDoc->getCell(aPos);
								if ( xCell )
								{
									XTextRef xText = (XText*)xCell->queryInterface(XText::getSmartUik());
									xText->setText( aName );
									++aPos.Row;
								}
							}
						}
					}
				}
			}
		}
	}

	aTimeText.SetText(aResult);

	return 0;
}

//-----------------------------------------------------------------------

void lcl_FillCells(XCellCollectionRef xColl)
{
	XEnumerationAccessRef xEnAcc = xColl->getCells();
	if (!xEnAcc) return;
	XEnumerationRef xEnum = xEnAcc->getEnumeration();
	if (!xEnum) return;
	while (xEnum->hasMoreElements())
	{
		XInterfaceRef xInt = xEnum->nextElement();
		if (xInt)
		{
			XCellRef xCell = (XCell*)xInt->queryInterface(XCell::getSmartUik());
			if (xCell)
			{
				xCell->setValue(42.0);
			}
		}
	}
}

IMPL_LINK(MyWindow, ViewHdl, PushButton*, EMPTYARG)
{
	XSpreadsheetDocumentRef xDoc = lcl_GetDocument();			// Calc-Model
	XInterfaceRef xInt = lcl_GetView();
	if (!xInt) return 0;
	XDocumentViewRef xView = (XDocumentView*)xInt->queryInterface(XDocumentView::getSmartUik());
	if (!xView) return 0;

	XInterfaceRef xSelInt = xView->getSelection();
	if (!xSelInt) return 0;

#if 0
	XPropertySetRef xProp = (XPropertySet*)xSelInt->queryInterface(XPropertySet::getSmartUik());
	if ( xProp )
	{
		UsrAny aAny;

		aAny = xProp->getPropertyValue(L"TransparentBackground");
		aAny.setBOOL(FALSE);
		xProp->setPropertyValue(L"TransparentBackground", aAny);

		aAny = xProp->getPropertyValue(L"BackgroundColor");
		aAny.setUINT32(0xffff00);
		xProp->setPropertyValue(L"BackgroundColor", aAny);
	}
	XIndentRef xInd = (XIndent*)xSelInt->queryInterface(XIndent::getSmartUik());
	if ( xInd )
	{
		xInd->incrementIndent();
	}
#endif

	XAutoFormattableRef xAuto = (XAutoFormattable*)xSelInt->
									queryInterface(XAutoFormattable::getSmartUik());
	if ( xAuto )
		xAuto->applyAutoFormat(	L"gaga" );

	XFormulaArrayRef xArr = (XFormulaArray*)xSelInt->queryInterface(XFormulaArray::getSmartUik());
	if ( xArr )
	{
//		xArr->setFormulaArray( "123" );
		String aFormula = OUStringToString( xArr->getFormulaArray(), CHARSET_SYSTEM );
		aTimeText.SetText(aFormula);
	}
	else
		aTimeText.SetText("...");

	XTextRef xText = (XText*)xSelInt->queryInterface(XText::getSmartUik());
	if ( xText )
	{
		String aStr = OUStringToString( xText->getText(), CHARSET_SYSTEM );
		aStr += 'X';
		xText->setText(StringToOUString(aStr, CHARSET_SYSTEM));
	}

	//	Zelle selektieren

#if 0
	if (xDoc)
	{
		CellAddress aPos;
		aPos.Sheet  = 0;
		aPos.Column = 1;
		aPos.Row    = 2;
		XCellRef xCell = xDoc->getCell(aPos);
		if ( xCell )
			xView->select( xCell );
	}
#endif

	XPrintableRef xPrint = (XPrintable*)xInt->queryInterface(XPrintable::getSmartUik());
	String aName = OUStringToString( xPrint->getPrinterName(), CHARSET_SYSTEM );
//	aTimeText.SetText(aName);

	xPrint->setPrinterName(L"HP5_2");
//	xPrint->setPrinterName(L"blubb");

//	XPropertySetRef xOptions;
//	xPrint->print(xOptions);

/*	XViewPaneRef xPane = (XViewPane*)xInt->queryInterface(XViewPane::getSmartUik());
	if (!xPane) return 0;
	xPane->setScrollRow( 2 );
*/

	XCellRangeSourceRef xSrc = (XCellRangeSource*)
									xInt->queryInterface(XCellRangeSource::getSmartUik());
	if (!xSrc) return 0;
	XCellRangeRef xRange = xSrc->getReferredCells();
	if (!xRange) return 0;
	XCellCollectionRef xColl = (XCellCollection*)
									xRange->queryInterface(XCellCollection::getSmartUik());
	if (!xColl) return 0;

	XActionLockableRef xLock = (XActionLockable*)
						xDoc->queryInterface(XActionLockable::getSmartUik());
	if (xLock)
		xLock->addActionLock();							// nicht zwischendurch painten

//	lcl_FillCells(xColl);

	if (xLock)
		xLock->removeActionLock();							// nicht zwischendurch painten

	XStarCalcViewRef xCalc = (XStarCalcView*)xInt->queryInterface(XStarCalcView::getSmartUik());
	if (!xCalc) return 0;

	return 0;
}