/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: svdibrow.cxx,v $
 * $Revision: 1.16 $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
#include <svx/eeitem.hxx>

#include "svdibrow.hxx"

#ifndef _STDLIB_H
#include <stdlib.h>
#define _STDLIB_H
#endif

#include "svditext.hxx"
#include <svx/flditem.hxx>
#include <svx/editdata.hxx>
#include <svx/svdpool.hxx>
#include <svx/svdattr.hxx>
#include <svx/svdattrx.hxx>
#include <svx/svdview.hxx>
#include <svx/xenum.hxx>
#include <svx/xlineit0.hxx>
#include <svx/xlnstwit.hxx>
#include <svx/xlnedwit.hxx>
#include <svx/xfillit0.hxx>
#include <svx/xflbmtit.hxx>
#include <svx/xtextit0.hxx>
#include <svx/xflbstit.hxx>
#include <svx/xflbtoxy.hxx>
#include <svx/xftshit.hxx>
#include <svx/colritem.hxx>


#include "fontitem.hxx"
#include <svx/fhgtitem.hxx>

#include <svx/charscaleitem.hxx>
#include <svtools/whiter.hxx>
#include <svtools/flagitem.hxx>
#include <svtools/ptitem.hxx>
#include <svtools/rectitem.hxx>

#include <svtools/rngitem.hxx>
#include <sdrpaintwindow.hxx>

////////////////////////////////////////////////////////////////////////////////////////////////////

#define ITEMBROWSER_WHICHCOL_ID 1
#define ITEMBROWSER_STATECOL_ID 2
#define ITEMBROWSER_TYPECOL_ID  3
#define ITEMBROWSER_NAMECOL_ID  4
#define ITEMBROWSER_VALUECOL_ID 5

enum ItemType {
	ITEM_DONTKNOW, ITEM_BYTE, ITEM_INT16, ITEM_UINT16, ITEM_INT32, ITEM_UINT32,
	ITEM_ENUM, ITEM_BOOL, ITEM_FLAG, ITEM_STRING, ITEM_POINT, ITEM_RECT, ITEM_RANGE, ITEM_LRANGE,
	ITEM_FRACTION,
	ITEM_XCOLOR,
	ITEM_COLOR,
	ITEM_FONT, ITEM_FONTHEIGHT, ITEM_FONTWIDTH, ITEM_FIELD
};

class ImpItemListRow
{
public:
	XubString					aName;
	XubString					aValue;
	SfxItemState				eState;
	UINT16						nWhichId;

	TypeId						pType;
	ItemType					eItemType;

	INT32						nVal;
	INT32						nMin;
	INT32						nMax;

	BOOL						bComment;
	BOOL						bIsNum;
	BOOL						bCanNum;

public:
	ImpItemListRow()
	:	eState(SFX_ITEM_UNKNOWN),
		nWhichId(0),
		pType(NULL),
		eItemType(ITEM_DONTKNOW),
		nVal(0),
		nMin(0),
		nMax(0),
		bComment(FALSE),
		bIsNum(FALSE),
		bCanNum(FALSE)
	{}

	XubString GetItemTypeStr() const;
	BOOL operator==(const ImpItemListRow& rEntry) const;
	BOOL operator!=(const ImpItemListRow& rEntry) const { return !operator==(rEntry); }
};

XubString ImpItemListRow::GetItemTypeStr() const
{
	XubString aStr;

	switch(eItemType)
	{
		case ITEM_BYTE		: aStr.AppendAscii("Byte");		break;
		case ITEM_INT16		: aStr.AppendAscii("Int16");	break;
		case ITEM_UINT16	: aStr.AppendAscii("UInt16");	break;
		case ITEM_INT32		: aStr.AppendAscii("Int32");	break;
		case ITEM_UINT32	: aStr.AppendAscii("UInt32");	break;
		case ITEM_ENUM		: aStr.AppendAscii("Enum");		break;
		case ITEM_BOOL		: aStr.AppendAscii("Bool");		break;
		case ITEM_FLAG		: aStr.AppendAscii("Flag");		break;
		case ITEM_STRING	: aStr.AppendAscii("String");	break;
		case ITEM_POINT		: aStr.AppendAscii("Point");	break;
		case ITEM_RECT		: aStr.AppendAscii("Rectangle");break;
		case ITEM_RANGE		: aStr.AppendAscii("Range");	break;
		case ITEM_LRANGE	: aStr.AppendAscii("LRange");	break;
		case ITEM_FRACTION	: aStr.AppendAscii("Fraction");	break;
		case ITEM_XCOLOR	: aStr.AppendAscii("XColor");	break;
		case ITEM_COLOR		: aStr.AppendAscii("Color");	break;
		case ITEM_FONT		: aStr.AppendAscii("Font");		break;
		case ITEM_FONTHEIGHT:aStr.AppendAscii("FontHeight");break;
		case ITEM_FONTWIDTH	:aStr.AppendAscii("FontWidth");	break;
		case ITEM_FIELD		:aStr.AppendAscii("Field");		break;
		default: break;
	}

	return aStr;
}

BOOL ImpItemListRow::operator==(const ImpItemListRow& rEntry) const
{
	return (aName.Equals(rEntry.aName)
		&& aValue.Equals(rEntry.aValue)
		&& eState==rEntry.eState
		&& nWhichId==rEntry.nWhichId
		&& bComment==rEntry.bComment
		&& bIsNum==rEntry.bIsNum
		&& bCanNum==rEntry.bCanNum
		&& pType==rEntry.pType
		&& eItemType==rEntry.eItemType
		&& nVal==rEntry.nVal
		&& nMin==rEntry.nMin
		&& nMax==rEntry.nMax);
}

////////////////////////////////////////////////////////////////////////////////////////////////////

class ImpItemEdit: public Edit
{
	_SdrItemBrowserControl*		pBrowse;

public:
	ImpItemEdit(Window* pParent, _SdrItemBrowserControl* pBrowse_, WinBits nBits=0)
	:	Edit(pParent, nBits),
		pBrowse(pBrowse_)
	{}

	virtual ~ImpItemEdit();
	virtual void KeyInput(const KeyEvent& rEvt);
};

__EXPORT ImpItemEdit::~ImpItemEdit()
{
}

void __EXPORT ImpItemEdit::KeyInput(const KeyEvent& rKEvt)
{
	_SdrItemBrowserControl* pBrowseMerk = pBrowse;

	UINT16 nKeyCode(rKEvt.GetKeyCode().GetCode() + rKEvt.GetKeyCode().GetModifier());

	if(nKeyCode == KEY_RETURN)
	{
		pBrowseMerk->EndChangeEntry();
		pBrowseMerk->GrabFocus();
	}
	else if(nKeyCode == KEY_ESCAPE)
	{
		pBrowseMerk->BrkChangeEntry();
		pBrowseMerk->GrabFocus();
	}
	else if(nKeyCode == KEY_UP || nKeyCode == KEY_DOWN)
	{
		pBrowseMerk->EndChangeEntry();
		pBrowseMerk->GrabFocus();
		pBrowseMerk->KeyInput(rKEvt);
	}
	else
		Edit::KeyInput(rKEvt);
}

////////////////////////////////////////////////////////////////////////////////////////////////////

#define MYBROWSEMODE (BROWSER_THUMBDRAGGING|BROWSER_KEEPHIGHLIGHT|BROWSER_NO_HSCROLL|BROWSER_HIDECURSOR)

_SdrItemBrowserControl::_SdrItemBrowserControl(Window* pParent, WinBits nBits):
	BrowseBox(pParent,nBits,MYBROWSEMODE),
	aList(1024,16,16)
{
	ImpCtor();
}

__EXPORT _SdrItemBrowserControl::~_SdrItemBrowserControl()
{
	if(pEditControl)
		delete pEditControl;

	if(pAktChangeEntry)
		delete pAktChangeEntry;

	Clear();
}

void _SdrItemBrowserControl::ImpCtor()
{
	pEditControl = NULL;
	pAktChangeEntry = NULL;
	nLastWhichOfs = 0;
	nLastWhich = 0;
	nLastWhichOben = 0;  // not implemented yet
	nLastWhichUnten = 0; // not implemented yet
	bWhichesButNames = FALSE;
	bDontHideIneffectiveItems = FALSE;
	bDontSortItems = FALSE;
	bShowWhichIds = FALSE;
	bShowRealValues = FALSE;
	bShowWhichIds = TRUE;   // not implemented yet
	bShowRealValues = TRUE; // not implemented yet

	rtl_TextEncoding aTextEncoding = gsl_getSystemTextEncoding();

	InsertDataColumn(
		ITEMBROWSER_WHICHCOL_ID,
		String("Which", aTextEncoding),
		GetTextWidth(String(" Which ", aTextEncoding)) + 2);
	InsertDataColumn(
		ITEMBROWSER_STATECOL_ID,
		String("State", aTextEncoding),
		Max(GetTextWidth(String(" State ", aTextEncoding)) + 2 ,
			GetTextWidth(String("DontCare", aTextEncoding)) + 2));
	InsertDataColumn(
		ITEMBROWSER_TYPECOL_ID ,
		String("Type", aTextEncoding),
		GetTextWidth(String(" Type_ ", aTextEncoding)) + 2);
	InsertDataColumn(
		ITEMBROWSER_NAMECOL_ID ,
		String("Name", aTextEncoding),
		150);
	InsertDataColumn(
		ITEMBROWSER_VALUECOL_ID,
		String("Value", aTextEncoding),
		GetTextWidth(String("12345678901234567890", aTextEncoding)));
	SetDataRowHeight(
		GetTextHeight());

	long nWdt=GetColumnWidth(ITEMBROWSER_WHICHCOL_ID)+
			  GetColumnWidth(ITEMBROWSER_STATECOL_ID)+
			  GetColumnWidth(ITEMBROWSER_TYPECOL_ID )+
			  GetColumnWidth(ITEMBROWSER_NAMECOL_ID )+
			  GetColumnWidth(ITEMBROWSER_VALUECOL_ID);

	long nHgt=GetTitleHeight()+16*GetDataRowHeight();

	SetOutputSizePixel(Size(nWdt,nHgt));
}

void _SdrItemBrowserControl::Clear()
{
	ULONG nAnz=aList.Count();
	for (ULONG nNum=0; nNum<nAnz; nNum++) {
		delete ImpGetEntry(nNum);
	}
	aList.Clear();
	BrowseBox::Clear();
}

long __EXPORT _SdrItemBrowserControl::GetRowCount() const
{
	return aList.Count();
}

BOOL __EXPORT _SdrItemBrowserControl::SeekRow(long nRow)
{
	nAktPaintRow=nRow;
	return TRUE;
}

String _SdrItemBrowserControl::GetCellText(long _nRow, USHORT _nColId) const
{
	String sRet;
	if ( _nRow >= 0 && _nRow < (sal_Int32)aList.Count() )
	{
		ImpItemListRow* pEntry = ImpGetEntry(_nRow);
		if ( pEntry )
		{
			if ( pEntry->bComment )
			{
				if (_nColId == ITEMBROWSER_NAMECOL_ID)
					sRet = pEntry->aName;
			}
			else
			{
				rtl_TextEncoding aTextEncoding = gsl_getSystemTextEncoding();

				sRet = XubString("???", aTextEncoding);
				switch (_nColId)
				{
					case ITEMBROWSER_WHICHCOL_ID:
						sRet = UniString::CreateFromInt32(pEntry->nWhichId); break;
					case ITEMBROWSER_STATECOL_ID:
					{
						switch (pEntry->eState)
						{
							case SFX_ITEM_UNKNOWN : sRet=String("Uknown", aTextEncoding);   break;
							case SFX_ITEM_DISABLED: sRet=String("Disabled", aTextEncoding); break;
							case SFX_ITEM_DONTCARE: sRet=String("DontCare", aTextEncoding); break;
							case SFX_ITEM_SET     : sRet=String("Set", aTextEncoding);      break;
							case SFX_ITEM_DEFAULT : sRet=String("Default", aTextEncoding);  break;
						} // switch
					} break;
					case ITEMBROWSER_TYPECOL_ID: sRet = pEntry->GetItemTypeStr(); break;
					case ITEMBROWSER_NAMECOL_ID: sRet = pEntry->aName; break;
					case ITEMBROWSER_VALUECOL_ID: sRet = pEntry->aValue; break;
				} // switch
			}
		}
	}
	return sRet;
}

void __EXPORT _SdrItemBrowserControl::PaintField(OutputDevice& rDev, const Rectangle& rRect, USHORT nColumnId) const
{
	if (nAktPaintRow<0 || (ULONG)nAktPaintRow>=aList.Count()) {
		return;
	}
	Rectangle aR(rRect);
	aR.Bottom()++;
	ImpItemListRow* pEntry=ImpGetEntry(nAktPaintRow);
	if (pEntry->bComment)
	{
		if (nColumnId==ITEMBROWSER_NAMECOL_ID)
		{
			rDev.SetLineColor();
			rDev.SetFillColor( Color( COL_LIGHTGRAY ) );
			aR.Left()=0;
			aR.Right()=rDev.GetOutputSize().Width();
			rDev.DrawRect(aR);
			rDev.DrawText(rRect.TopLeft(),pEntry->aName);
		}
	} else {
		rDev.SetClipRegion(aR);
		rDev.DrawText(aR.TopLeft(),GetCellText(nAktPaintRow,nColumnId));
		rDev.SetClipRegion();
	}
}

ULONG _SdrItemBrowserControl::GetCurrentPos() const
{
	ULONG nRet=CONTAINER_ENTRY_NOTFOUND;
	if (GetSelectRowCount()==1) {
		long nPos=((BrowseBox*)this)->FirstSelectedRow();
		if (nPos>=0 && (ULONG)nPos<aList.Count()) {
			nRet=(ULONG)nPos;
		}
	}
	return nRet;
}

USHORT _SdrItemBrowserControl::GetCurrentWhich() const
{
	USHORT nRet=0;
	ULONG nPos=GetCurrentPos();
	if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
		nRet=ImpGetEntry(nPos)->nWhichId;
	}
	return nRet;
}

void __EXPORT _SdrItemBrowserControl::DoubleClick(const BrowserMouseEvent&)
{
	ULONG nPos=GetCurrentPos();
	if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
		BegChangeEntry(nPos);
	}
}

void __EXPORT _SdrItemBrowserControl::KeyInput(const KeyEvent& rKEvt)
{
	USHORT nKeyCode=rKEvt.GetKeyCode().GetCode()+rKEvt.GetKeyCode().GetModifier();
	FASTBOOL bAusgewertet=FALSE;
	ULONG nPos=GetCurrentPos();
	if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
		if (nKeyCode==KEY_RETURN) {
			if (BegChangeEntry(nPos)) bAusgewertet=TRUE;
		} else if (nKeyCode==KEY_ESCAPE) {
			// ...
		} else if (rKEvt.GetKeyCode().GetModifier()==KEY_SHIFT+KEY_MOD1+KEY_MOD2) { // Strg
			if (nKeyCode==KEY_SHIFT+KEY_MOD1+KEY_MOD2+KEY_W) {
				bWhichesButNames=!bWhichesButNames;
				SetDirty();
			}
			if (nKeyCode==KEY_SHIFT+KEY_MOD1+KEY_MOD2+KEY_I) {
				bDontHideIneffectiveItems=!bDontHideIneffectiveItems;
				SetDirty();
			}
			if (nKeyCode==KEY_SHIFT+KEY_MOD1+KEY_MOD2+KEY_S) {
				bDontSortItems=!bDontSortItems;
				SetDirty();
			}
		}
	}
	if (!bAusgewertet) BrowseBox::KeyInput(rKEvt);
}

void _SdrItemBrowserControl::SetDirty()
{
	aSetDirtyHdl.Call(this);
}

Rectangle _SdrItemBrowserControl::GetFieldCharacterBounds(sal_Int32 /*_nRow*/,sal_Int32 /*_nColumnPos*/,sal_Int32 /*nIndex*/)
{
    // no accessibility implementation required
    return Rectangle();
}

sal_Int32 _SdrItemBrowserControl::GetFieldIndexAtPoint(sal_Int32 /*_nRow*/,sal_Int32 /*_nColumnPos*/,const Point& /*_rPoint*/)
{
    // no accessibility implementation required
    return -1;
}

void __EXPORT _SdrItemBrowserControl::Select()
{
	EndChangeEntry();
	BrowseBox::Select();
	ImpSaveWhich();
}

void _SdrItemBrowserControl::ImpSaveWhich()
{
	USHORT nWh=GetCurrentWhich();
	if (nWh!=0) {
		long nPos=GetCurrentPos();
		long nTop=GetTopRow();
		long nBtm=GetTopRow()+GetVisibleRows()+1;
		nLastWhich=nWh;
		nLastWhichOfs=nPos-nTop;
		if (nTop<0) nTop=0;
		if (nBtm>=(long)aList.Count()) nBtm=aList.Count()-1;
		nLastWhichOben=ImpGetEntry(nTop)->nWhichId;
		nLastWhichUnten=ImpGetEntry(nBtm)->nWhichId;
	}
}

void _SdrItemBrowserControl::ImpRestoreWhich()
{
	if (nLastWhich!=0) {
		FASTBOOL bFnd=FALSE;
		USHORT nBestMinWh=0,nBestMaxWh=0xFFFF;       // not implemented yet
		ULONG nBestMinPos=0,nBestMaxPos=0xFFFFFFFF;  // not implemented yet
		ULONG nAnz=aList.Count();
		ULONG nNum;
		for (nNum=0; nNum<nAnz && !bFnd; nNum++) {
			ImpItemListRow* pEntry=ImpGetEntry(nNum);
			if (!pEntry->bComment) {
				USHORT nWh=pEntry->nWhichId;
				if (nWh==nLastWhich) bFnd=TRUE;
				else if (nWh<nLastWhich && nWh>nBestMinWh) nBestMinPos=nNum;
				else if (nWh>nLastWhich && nWh<nBestMaxWh) nBestMaxPos=nNum;
			}
		}
		if (bFnd) {
			long nPos=nNum-1;
			long nWhichOfs=nPos-GetTopRow();
			if (nWhichOfs!=nLastWhichOfs) {
				ScrollRows(nWhichOfs-nLastWhichOfs);
			}
			GoToRow(nPos);
		}
	}
}

FASTBOOL _SdrItemBrowserControl::BegChangeEntry(ULONG nPos)
{
	BrkChangeEntry();
	FASTBOOL bRet=FALSE;
	ImpItemListRow* pEntry=ImpGetEntry(nPos);
	if (pEntry!=NULL && !pEntry->bComment) {
		SetMode(MYBROWSEMODE & ~BROWSER_KEEPHIGHLIGHT);
		pEditControl=new ImpItemEdit(&GetDataWindow(),this,0/*|WB_BORDER|WB_3DLOOK*/);
		Rectangle aRect(GetFieldRectPixel(nPos,ITEMBROWSER_VALUECOL_ID,FALSE));
		aRect.Left()+=2; // Kleiner Offset fuer's Edit, damit's pixelgenau stimmt
		aRect.Right()--;
		pEditControl->SetPosSizePixel(aRect.TopLeft(),aRect.GetSize());
		pEditControl->SetText(pEntry->aValue);
		pEditControl->SetBackground( Wallpaper(Color(COL_LIGHTGRAY)));
		Font aFont(pEditControl->GetFont());
		aFont.SetFillColor(Color(COL_LIGHTGRAY));
		pEditControl->SetFont(aFont);
		pEditControl->Show();
		pEditControl->GrabFocus();
		pEditControl->SetSelection(Selection(SELECTION_MIN,SELECTION_MAX));
		Window* pParent=GetParent();
		aWNamMerk=pParent->GetText();
		XubString aNeuNam(aWNamMerk);
		aNeuNam += sal_Unicode(' ');
		aNeuNam += pEntry->GetItemTypeStr();
		if (pEntry->bCanNum) {
			aNeuNam.AppendAscii(": ");
			aNeuNam += UniString::CreateFromInt32(pEntry->nMin);
			aNeuNam.AppendAscii("..");
			aNeuNam += UniString::CreateFromInt32(pEntry->nMax);
		}
		aNeuNam.AppendAscii(" - Type 'del' to reset to default.");
		pParent->SetText(aNeuNam);
		pAktChangeEntry=new ImpItemListRow(*pEntry);
		bRet=TRUE;
	}
	return bRet;
}

FASTBOOL _SdrItemBrowserControl::EndChangeEntry()
{
	FASTBOOL bRet=FALSE;
	if (pEditControl!=NULL) {
		aEntryChangedHdl.Call(this);
		delete pEditControl;
		pEditControl=NULL;
		delete pAktChangeEntry;
		pAktChangeEntry=NULL;
		Window* pParent=GetParent();
		pParent->SetText(aWNamMerk);
		SetMode(MYBROWSEMODE);
		bRet=TRUE;
	}
	return bRet;
}

void _SdrItemBrowserControl::BrkChangeEntry()
{
	if (pEditControl!=NULL) {
		delete pEditControl;
		pEditControl=NULL;
		delete pAktChangeEntry;
		pAktChangeEntry=NULL;
		Window* pParent=GetParent();
		pParent->SetText(aWNamMerk);
		SetMode(MYBROWSEMODE);
	}
}

void _SdrItemBrowserControl::ImpSetEntry(const ImpItemListRow& rEntry, ULONG nEntryNum)
{
	ImpItemListRow* pAktEntry=ImpGetEntry(nEntryNum);
	if (pAktEntry==NULL) {
		aList.Insert(new ImpItemListRow(rEntry),CONTAINER_APPEND);
		RowInserted(nEntryNum);
	} else if (*pAktEntry!=rEntry) {
		FASTBOOL bStateDiff=rEntry.eState!=pAktEntry->eState;
		FASTBOOL bValueDiff=!rEntry.aValue.Equals(pAktEntry->aValue);
		FASTBOOL bAllDiff=TRUE;
		if (bStateDiff || bValueDiff) {
			// Checken, ob nur State und/oder Value geaendert
			ImpItemListRow aTest(rEntry);
			aTest.eState=pAktEntry->eState;
			aTest.aValue=pAktEntry->aValue;
			if (aTest==*pAktEntry) bAllDiff=FALSE;
		}
		*pAktEntry=rEntry;
		if (bAllDiff) {
			RowModified(nEntryNum);
		} else {
			if (bStateDiff) RowModified(nEntryNum,ITEMBROWSER_STATECOL_ID);
			if (bValueDiff) RowModified(nEntryNum,ITEMBROWSER_VALUECOL_ID);
		}
	}
}

FASTBOOL ImpGetItem(const SfxItemSet& rSet, USHORT nWhich, const SfxPoolItem*& rpItem)
{
	SfxItemState eState=rSet.GetItemState(nWhich,TRUE,&rpItem);
	if (eState==SFX_ITEM_DEFAULT) {
		rpItem=&rSet.Get(nWhich);
	}
	return (eState==SFX_ITEM_DEFAULT || eState==SFX_ITEM_SET) && rpItem!=NULL;
}

FASTBOOL IsItemIneffective(USHORT nWhich, const SfxItemSet* pSet, USHORT& rIndent)
{
	rIndent=0;
	if (pSet==NULL) return FALSE;
	const SfxPoolItem* pItem=NULL;
	FASTBOOL bRet=FALSE;
	switch (nWhich) {
		case XATTR_LINEDASH         :
		case XATTR_LINEWIDTH        :
		case XATTR_LINECOLOR        :
		case XATTR_LINESTART        :
		case XATTR_LINEEND          :
		case XATTR_LINESTARTWIDTH   :
		case XATTR_LINEENDWIDTH     :
		case XATTR_LINESTARTCENTER  :
		case XATTR_LINEENDCENTER    :
		case XATTR_LINETRANSPARENCE : {
			rIndent=1;
			if (ImpGetItem(*pSet,XATTR_LINESTYLE,pItem)) {
				XLineStyle eLineStyle=((const XLineStyleItem*)pItem)->GetValue();
				if (eLineStyle==XLINE_NONE) return TRUE;
				if (eLineStyle!=XLINE_DASH && nWhich==XATTR_LINEDASH) return TRUE;
			}
			if (nWhich==XATTR_LINESTART || nWhich==XATTR_LINESTARTCENTER) {
				rIndent=2;
				if (ImpGetItem(*pSet,XATTR_LINESTARTWIDTH,pItem)) {
					INT32 nWdt=((const XLineStartWidthItem*)pItem)->GetValue();
					if (nWdt==0) return TRUE;
				}
			}
			if (nWhich==XATTR_LINEEND || nWhich==XATTR_LINEENDCENTER) {
				rIndent=2;
				if (ImpGetItem(*pSet,XATTR_LINEENDWIDTH,pItem)) {
					INT32 nWdt=((const XLineEndWidthItem*)pItem)->GetValue();
					if (nWdt==0) return TRUE;
				}
			}
		} break;
		case XATTR_FILLCOLOR           : /*nur bei Style=Color*/
		case XATTR_FILLGRADIENT        : /*nur bei Style=Gradient*/
		case XATTR_FILLHATCH           : /*nur bei Style=Hatch*/
		case XATTR_FILLTRANSPARENCE    : /*nur bei Style=Color*/
		case XATTR_GRADIENTSTEPCOUNT   : /*nur bei Style=Gradient*/
		case XATTR_FILLBACKGROUND	   : /*nur bei Style=Hatch*/
		{
			rIndent=1;
			if (ImpGetItem(*pSet,XATTR_FILLSTYLE,pItem)) {
				XFillStyle eFillStyle=((const XFillStyleItem*)pItem)->GetValue();
				if (eFillStyle==XFILL_NONE) return TRUE;
				// Transparenz z.Zt. nur fuer SolidFill
				if (eFillStyle!=XFILL_SOLID && (nWhich==XATTR_FILLCOLOR || nWhich==XATTR_FILLTRANSPARENCE)) return TRUE;
				if (eFillStyle!=XFILL_GRADIENT && (nWhich==XATTR_FILLGRADIENT || nWhich==XATTR_GRADIENTSTEPCOUNT)) return TRUE;
				if (eFillStyle!=XFILL_HATCH && (nWhich==XATTR_FILLHATCH || nWhich==XATTR_FILLBACKGROUND)) return TRUE;
			}
		} break;
		case XATTR_FILLBITMAP          :
		case XATTR_FILLBMP_TILE        :
		case XATTR_FILLBMP_POS         : /* z.Zt. nur wenn TILE=TRUE */
		case XATTR_FILLBMP_SIZEX       : /* nur wenn nicht Stretch */
		case XATTR_FILLBMP_SIZEY       : /* nur wenn nicht Stretch */
		case XATTR_FILLBMP_SIZELOG     : /* nur wenn SIZELOG=FALSE zum ruecksetzen auf TRUE (alt) -> doch noch in Gebrauch */
		case XATTR_FILLBMP_TILEOFFSETX : /* nur wenn TILE=TRUE */
		case XATTR_FILLBMP_TILEOFFSETY : /* nur wenn TILE=TRUE */
		case XATTR_FILLBMP_STRETCH     : /* nur wenn TILE=FALSE */
		case XATTR_FILLBMP_POSOFFSETX  : /* nur wenn TILE=TRUE*/
		case XATTR_FILLBMP_POSOFFSETY  : { /* nur wenn TILE=TRUE*/
			rIndent=1;
			if (ImpGetItem(*pSet,XATTR_FILLSTYLE,pItem)) {
				XFillStyle eFillStyle=((const XFillStyleItem*)pItem)->GetValue();
				if (eFillStyle!=XFILL_BITMAP) return TRUE;
			}
			if (nWhich==XATTR_FILLBITMAP || nWhich==XATTR_FILLBMP_TILE) {
				return FALSE; // immer anwaehlbar
			}
			FASTBOOL bTileTRUE=FALSE;
			FASTBOOL bTileFALSE=FALSE;
			FASTBOOL bStretchTRUE=FALSE;
			FASTBOOL bStretchFALSE=FALSE;
			if (ImpGetItem(*pSet,XATTR_FILLBMP_TILE,pItem)) {
				bTileTRUE=((const XFillBmpTileItem*)pItem)->GetValue();
				bTileFALSE=!bTileTRUE;
			}
			if (ImpGetItem(*pSet,XATTR_FILLBMP_STRETCH,pItem)) {
				bStretchTRUE=((const XFillBmpStretchItem*)pItem)->GetValue();
				bStretchFALSE=!bStretchTRUE;
			}
			// Stretch nicht anwaehlbar, wenn Tile=TRUE
			if (nWhich==XATTR_FILLBMP_STRETCH) return bTileTRUE;
			// und uebrig bleiben 7+1 Item (Unterattribute)
			rIndent=2;
			// Pos (enum) nicht anwaehlbar, wenn Tile=FALSE
			if (nWhich==XATTR_FILLBMP_POS) return bTileFALSE;
			// SizeXY nicht anwaehlbar bei Stretch=TRUE
			if (nWhich==XATTR_FILLBMP_SIZEX || nWhich==XATTR_FILLBMP_SIZEY) {
				return bTileFALSE && bStretchTRUE;
			}
			// 2 Items speziell fuer Tile
			if (nWhich==XATTR_FILLBMP_POSOFFSETX  || nWhich==XATTR_FILLBMP_POSOFFSETY) {
				return bTileFALSE;
			}
			// Noch 2 Items speziell fuer Tile die sich jedoch gegenseitig ausschliessen
			if (nWhich==XATTR_FILLBMP_TILEOFFSETX || nWhich==XATTR_FILLBMP_TILEOFFSETY) {
				if (bTileFALSE) return TRUE;
				USHORT nX=0,nY=0;
				FASTBOOL bX=FALSE,bY=FALSE;
				if (ImpGetItem(*pSet,XATTR_FILLBMP_TILEOFFSETX,pItem)) {
					nX=((const XFillBmpTileOffsetXItem*)pItem)->GetValue();
					bX=TRUE;
				}
				if (ImpGetItem(*pSet,XATTR_FILLBMP_TILEOFFSETY,pItem)) {
					nY=((const XFillBmpTileOffsetYItem*)pItem)->GetValue();
					bY=TRUE;
				}
				if (nWhich==XATTR_FILLBMP_TILEOFFSETX) {
					if (nX!=0 || !bX) return FALSE;
					if (nY!=0) return TRUE;
				} else {
					if (nY!=0 || !bY) return FALSE;
					if (nX!=0) return TRUE;
				}
			}
			// SizeLog nicht anwaehlbar bei Stretch=TRUE
			// und sonst auch nur wenn es auf SizeLog=FALSE gesetzt ist.
			// -> wohl doch noch in Gebrauch
			// (TRUE ist der statische PoolDefault)
			if (nWhich==XATTR_FILLBMP_SIZELOG) {
				if (bTileFALSE && bStretchTRUE) return TRUE;
			}
		} break;

		case XATTR_FORMTXTADJUST    :
		case XATTR_FORMTXTDISTANCE  :
		case XATTR_FORMTXTSTART     :
		case XATTR_FORMTXTMIRROR    :
		case XATTR_FORMTXTOUTLINE   :
		case XATTR_FORMTXTSHADOW    :
		case XATTR_FORMTXTSHDWCOLOR :
		case XATTR_FORMTXTSHDWXVAL  :
		case XATTR_FORMTXTSHDWYVAL  :
		case XATTR_FORMTXTSTDFORM   :
		case XATTR_FORMTXTHIDEFORM  :
		case XATTR_FORMTXTSHDWTRANSP: {
			rIndent=1;
			if (ImpGetItem(*pSet,XATTR_FORMTXTSTYLE,pItem)) {
				XFormTextStyle eStyle=((const XFormTextStyleItem*)pItem)->GetValue();
				if (eStyle==XFT_NONE) return TRUE;
			}
			if ((nWhich>=XATTR_FORMTXTSHDWCOLOR && nWhich<=XATTR_FORMTXTSHDWYVAL) || nWhich>=XATTR_FORMTXTSHDWTRANSP) {
				rIndent=2;
				if (ImpGetItem(*pSet,XATTR_FORMTXTSHADOW,pItem)) {
					XFormTextShadow eShadow=((const XFormTextShadowItem*)pItem)->GetValue();
					if (eShadow==XFTSHADOW_NONE) return TRUE;
				}
			}
		} break;

		case SDRATTR_SHADOWCOLOR       :
		case SDRATTR_SHADOWXDIST       :
		case SDRATTR_SHADOWYDIST       :
		case SDRATTR_SHADOWTRANSPARENCE:
		case SDRATTR_SHADOW3D          :
		case SDRATTR_SHADOWPERSP       : {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_SHADOW,pItem)) {
				FASTBOOL bShadow=((const SdrShadowItem*)pItem)->GetValue();
				if (!bShadow) return TRUE;
			}
		} break;

		case SDRATTR_CAPTIONANGLE: {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_CAPTIONFIXEDANGLE,pItem)) {
				FASTBOOL bFixed=((const SdrCaptionFixedAngleItem*)pItem)->GetValue();
				if (!bFixed) return TRUE;
			}
		} break;
		case SDRATTR_CAPTIONESCREL:
		case SDRATTR_CAPTIONESCABS: {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_CAPTIONESCISREL,pItem)) {
				FASTBOOL bRel=((const SdrCaptionEscIsRelItem*)pItem)->GetValue();
				if (bRel && nWhich==SDRATTR_CAPTIONESCABS) return TRUE;
				if (!bRel && nWhich==SDRATTR_CAPTIONESCREL) return TRUE;
			}
		} break;
		case SDRATTR_CAPTIONLINELEN: {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_CAPTIONFITLINELEN,pItem)) {
				FASTBOOL bFit=((const SdrCaptionFitLineLenItem*)pItem)->GetValue();
				if (bFit) return TRUE;
			}
		} break;

		case SDRATTR_TEXT_MINFRAMEHEIGHT:
		case SDRATTR_TEXT_MAXFRAMEHEIGHT: {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_TEXT_AUTOGROWHEIGHT,pItem)) {
				FASTBOOL bAutoGrow=((const SdrTextAutoGrowHeightItem*)pItem)->GetValue();
				if (!bAutoGrow) return TRUE;
			}
		} break;
		case SDRATTR_TEXT_MINFRAMEWIDTH:
		case SDRATTR_TEXT_MAXFRAMEWIDTH: {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_TEXT_AUTOGROWWIDTH,pItem)) {
				FASTBOOL bAutoGrow=((const SdrTextAutoGrowWidthItem*)pItem)->GetValue();
				if (!bAutoGrow) return TRUE;
			}
		} break;
		case SDRATTR_TEXT_VERTADJUST:
		case SDRATTR_TEXT_HORZADJUST: {
			if (ImpGetItem(*pSet,SDRATTR_TEXT_FITTOSIZE,pItem)) {
				SdrFitToSizeType eFit=((const SdrTextFitToSizeTypeItem*)pItem)->GetValue();
				if (eFit!=SDRTEXTFIT_NONE) return TRUE;
			}
		} break;

		case SDRATTR_TEXT_ANIDIRECTION  :
		case SDRATTR_TEXT_ANISTARTINSIDE:
		case SDRATTR_TEXT_ANISTOPINSIDE :
		case SDRATTR_TEXT_ANICOUNT      :
		case SDRATTR_TEXT_ANIDELAY      :
		case SDRATTR_TEXT_ANIAMOUNT     : {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_TEXT_ANIKIND,pItem)) {
				SdrTextAniKind eAniKind=((const SdrTextAniKindItem*)pItem)->GetValue();
				if (eAniKind==SDRTEXTANI_NONE) return TRUE;
				if (eAniKind==SDRTEXTANI_BLINK && (nWhich==SDRATTR_TEXT_ANIDIRECTION || nWhich==SDRATTR_TEXT_ANIAMOUNT)) return TRUE;
				if (eAniKind==SDRTEXTANI_SLIDE && (nWhich==SDRATTR_TEXT_ANISTARTINSIDE || nWhich==SDRATTR_TEXT_ANISTOPINSIDE)) return TRUE;
			}
		} break;

		case SDRATTR_EDGELINEDELTAANZ: return TRUE;
		case SDRATTR_EDGELINE1DELTA:
		case SDRATTR_EDGELINE2DELTA:
		case SDRATTR_EDGELINE3DELTA: {
			if (ImpGetItem(*pSet,SDRATTR_EDGEKIND,pItem)) {
				SdrEdgeKind eKind=((const SdrEdgeKindItem*)pItem)->GetValue();
				if (eKind==SDREDGE_THREELINES) {
					if (nWhich>SDRATTR_EDGELINE2DELTA) return TRUE;
					else return FALSE;
				}
				if (eKind!=SDREDGE_ORTHOLINES && eKind!=SDREDGE_BEZIER) return TRUE;
			}
			if (ImpGetItem(*pSet,SDRATTR_EDGELINEDELTAANZ,pItem)) {
				UINT16 nAnz=((const SdrEdgeLineDeltaAnzItem*)pItem)->GetValue();
				if (nAnz==0) return TRUE;
				if (nAnz==1 && nWhich>SDRATTR_EDGELINE1DELTA) return TRUE;
				if (nAnz==2 && nWhich>SDRATTR_EDGELINE2DELTA) return TRUE;
				if (nAnz==3 && nWhich>SDRATTR_EDGELINE3DELTA) return TRUE;
			}
		} break;

		case SDRATTR_CIRCSTARTANGLE:
		case SDRATTR_CIRCENDANGLE  : {
			rIndent=1;
			if (ImpGetItem(*pSet,SDRATTR_CIRCKIND,pItem)) {
				SdrCircKind eKind=((const SdrCircKindItem*)pItem)->GetValue();
				if (eKind==SDRCIRC_FULL) return TRUE;
			}
		} break;
	} // switch
	return bRet;
}

USHORT ImpSortWhich(USHORT nWhich)
{
	switch (nWhich) {
		// Line
		case XATTR_LINESTART            : nWhich=XATTR_LINETRANSPARENCE     ; break;
		case XATTR_LINEEND              : nWhich=XATTR_LINESTARTWIDTH       ; break;
		case XATTR_LINESTARTWIDTH       : nWhich=XATTR_LINESTART            ; break;
		case XATTR_LINEENDWIDTH         : nWhich=XATTR_LINESTARTCENTER      ; break;
		case XATTR_LINESTARTCENTER      : nWhich=XATTR_LINEENDWIDTH         ; break;
		case XATTR_LINEENDCENTER        : nWhich=XATTR_LINEEND              ; break;
		case XATTR_LINETRANSPARENCE     : nWhich=XATTR_LINEENDCENTER        ; break;

		// Fill
		case XATTR_FILLBMP_POS          : nWhich=XATTR_FILLBMP_STRETCH      ; break;
		case XATTR_FILLBMP_SIZEX        : nWhich=XATTR_FILLBMP_POS          ; break;
		case XATTR_FILLBMP_SIZEY        : nWhich=XATTR_FILLBMP_SIZEX        ; break;
		case XATTR_FILLBMP_SIZELOG      : nWhich=XATTR_FILLBMP_SIZEY        ; break;
		case XATTR_FILLBMP_TILEOFFSETX  : nWhich=XATTR_FILLBMP_SIZELOG      ; break;
		case XATTR_FILLBMP_TILEOFFSETY  : nWhich=XATTR_FILLBMP_TILEOFFSETX  ; break;
		case XATTR_FILLBMP_STRETCH      : nWhich=XATTR_FILLBMP_TILEOFFSETY  ; break;

		// Fontwork
		case XATTR_FORMTXTSHADOW        : nWhich=XATTR_FORMTXTSTDFORM       ; break;
		case XATTR_FORMTXTSHDWCOLOR     : nWhich=XATTR_FORMTXTHIDEFORM      ; break;
		case XATTR_FORMTXTSHDWXVAL      : nWhich=XATTR_FORMTXTSHADOW        ; break;
		case XATTR_FORMTXTSHDWYVAL      : nWhich=XATTR_FORMTXTSHDWCOLOR     ; break;
		case XATTR_FORMTXTSTDFORM       : nWhich=XATTR_FORMTXTSHDWXVAL      ; break;
		case XATTR_FORMTXTHIDEFORM      : nWhich=XATTR_FORMTXTSHDWYVAL      ; break;

		// Misc
		case SDRATTR_TEXT_MINFRAMEHEIGHT: nWhich=SDRATTR_TEXT_FITTOSIZE     ; break;
		case SDRATTR_TEXT_AUTOGROWHEIGHT: nWhich=SDRATTR_TEXT_LEFTDIST      ; break;
		case SDRATTR_TEXT_FITTOSIZE     : nWhich=SDRATTR_TEXT_RIGHTDIST     ; break;
		case SDRATTR_TEXT_LEFTDIST      : nWhich=SDRATTR_TEXT_UPPERDIST     ; break;
		case SDRATTR_TEXT_RIGHTDIST     : nWhich=SDRATTR_TEXT_LOWERDIST     ; break;
		case SDRATTR_TEXT_UPPERDIST     : nWhich=SDRATTR_TEXT_AUTOGROWWIDTH ; break;
		case SDRATTR_TEXT_LOWERDIST     : nWhich=SDRATTR_TEXT_MINFRAMEWIDTH ; break;
		case SDRATTR_TEXT_VERTADJUST    : nWhich=SDRATTR_TEXT_MAXFRAMEWIDTH ; break;
		case SDRATTR_TEXT_MAXFRAMEHEIGHT: nWhich=SDRATTR_TEXT_AUTOGROWHEIGHT; break;
		case SDRATTR_TEXT_MINFRAMEWIDTH : nWhich=SDRATTR_TEXT_MINFRAMEHEIGHT; break;
		case SDRATTR_TEXT_MAXFRAMEWIDTH : nWhich=SDRATTR_TEXT_MAXFRAMEHEIGHT; break;
		case SDRATTR_TEXT_AUTOGROWWIDTH : nWhich=SDRATTR_TEXT_HORZADJUST    ; break;
		case SDRATTR_TEXT_HORZADJUST    : nWhich=SDRATTR_TEXT_VERTADJUST    ; break;
	} // switch
	return nWhich;
}

#define INSERTCOMMENT(nStartId,nEndId,aStr) \
    { if (nWhich0<nStartId && nWhich>=nStartId && nWhich<=nEndId) aCommentStr=aStr; }

void _SdrItemBrowserControl::SetAttributes(const SfxItemSet* pSet, const SfxItemSet* p2ndSet)
{
	SetMode(MYBROWSEMODE & ~BROWSER_KEEPHIGHLIGHT);
	if (pSet!=NULL) {
		rtl_TextEncoding aTextEncoding = gsl_getSystemTextEncoding();
		USHORT nEntryNum=0;
		SfxWhichIter aIter(*pSet);
		const SfxItemPool* pPool=pSet->GetPool();
		USHORT nWhich0=0;
		USHORT nWhich=aIter.FirstWhich();
		while (nWhich!=0) {
			// Nun erstmal etwas umsortieren
			// Geht nur, solange keine InvalidItems, d.h. keine Luecken
			// an dieser Stelle im Set sind
			if (!bDontSortItems) nWhich=ImpSortWhich(nWhich);
			SfxItemState eState=pSet->GetItemState(nWhich);
			if (p2ndSet!=NULL) {
				SfxItemState e2ndState=p2ndSet->GetItemState(nWhich);
				if (eState==SFX_ITEM_DEFAULT) eState=SFX_ITEM_DISABLED;
				else if (e2ndState==SFX_ITEM_DEFAULT) eState=SFX_ITEM_DEFAULT;
			}
			if (eState!=SFX_ITEM_DISABLED) {
				const SfxPoolItem& rItem=pSet->Get(nWhich);
				USHORT nIndent=0;
				if (!HAS_BASE(SfxVoidItem,&rItem) && !HAS_BASE(SfxSetItem,&rItem) && (!IsItemIneffective(nWhich,pSet,nIndent) || bDontHideIneffectiveItems)) {
					XubString aCommentStr;

					INSERTCOMMENT(XATTR_LINE_FIRST,XATTR_LINE_LAST,String("L I N I E", aTextEncoding));
                    INSERTCOMMENT(XATTR_FILL_FIRST,XATTR_FILL_LAST,String("F L Ä C H E", aTextEncoding));
					INSERTCOMMENT(XATTR_TEXT_FIRST,XATTR_TEXT_LAST,String("F O N T W O R K", aTextEncoding));
					INSERTCOMMENT(SDRATTR_SHADOW_FIRST,SDRATTR_SHADOW_LAST,String("S C H A T T E N", aTextEncoding));
					INSERTCOMMENT(SDRATTR_CAPTION_FIRST,SDRATTR_CAPTION_LAST,String("L E G E N D E", aTextEncoding));
					INSERTCOMMENT(SDRATTR_MISC_FIRST,SDRATTR_MISC_LAST,String("V E R S C H I E D E N E S", aTextEncoding));
					INSERTCOMMENT(SDRATTR_EDGE_FIRST,SDRATTR_EDGE_LAST,String("V E R B I N D E R", aTextEncoding));
					INSERTCOMMENT(SDRATTR_MEASURE_FIRST,SDRATTR_MEASURE_LAST,String("B E M A S S U N G", aTextEncoding));
					INSERTCOMMENT(SDRATTR_CIRC_FIRST,SDRATTR_CIRC_LAST,String("K R E I S", aTextEncoding));
					INSERTCOMMENT(SDRATTR_NOTPERSIST_FIRST,SDRATTR_NOTPERSIST_LAST,String("N O T P E R S I S T", aTextEncoding));
					INSERTCOMMENT(SDRATTR_MOVEX,SDRATTR_VERTSHEARONE,String("Transformationen auf alle Objekte einzeln", aTextEncoding));
					INSERTCOMMENT(SDRATTR_RESIZEXALL,SDRATTR_VERTSHEARALL,String("Transformationen auf alle Objekte gemeinsam", aTextEncoding));
					INSERTCOMMENT(SDRATTR_TRANSFORMREF1X,SDRATTR_TRANSFORMREF2Y,String("View-Referenzpunkte", aTextEncoding));
					INSERTCOMMENT(SDRATTR_GRAF_FIRST,SDRATTR_GRAF_LAST,String("G R A F I K", aTextEncoding));
					INSERTCOMMENT(EE_ITEMS_START,EE_ITEMS_END,String("E D I T  E N G I N E", aTextEncoding));
					INSERTCOMMENT(EE_ITEMS_END+1,EE_ITEMS_END+1,String("... by Joe Merten, JME Engineering Berlin ...", aTextEncoding));

					if(aCommentStr.Len())
					{
						ImpItemListRow aEntry;
						aEntry.bComment=TRUE;
						aEntry.aName=aCommentStr;
						ImpSetEntry(aEntry,nEntryNum);
						nEntryNum++;
					}
					nWhich0=nWhich;
					ImpItemListRow aEntry;
					SdrItemPool::TakeItemName(nWhich, aEntry.aName);
					nIndent*=2;

					while(nIndent > 0)
					{
						aEntry.aName.Insert(sal_Unicode(' '), 0);
						nIndent--;
					}

					aEntry.eState=eState;
					aEntry.nWhichId=nWhich;
					if (!IsInvalidItem(&rItem)) {
						aEntry.pType=rItem.Type();
						aEntry.nMax=0x7FFFFFFF;
						aEntry.nMin=-aEntry.nMax;
						aEntry.nVal=-4711;
						if      (HAS_BASE(SfxByteItem     ,&rItem)) aEntry.eItemType=ITEM_BYTE;
						else if (HAS_BASE(SfxInt16Item    ,&rItem)) aEntry.eItemType=ITEM_INT16;
						else if (HAS_BASE(SfxUInt16Item   ,&rItem)) aEntry.eItemType=ITEM_UINT16;
						else if (HAS_BASE(SfxInt32Item    ,&rItem)) aEntry.eItemType=ITEM_INT32;
						else if (HAS_BASE(SfxUInt32Item   ,&rItem)) aEntry.eItemType=ITEM_UINT32;
						else if (HAS_BASE(SfxEnumItemInterface,&rItem)) aEntry.eItemType=ITEM_ENUM;
						else if (HAS_BASE(SfxBoolItem     ,&rItem)) aEntry.eItemType=ITEM_BOOL;
						else if (HAS_BASE(SfxFlagItem     ,&rItem)) aEntry.eItemType=ITEM_FLAG;
						else if (HAS_BASE(XColorItem      ,&rItem)) aEntry.eItemType=ITEM_XCOLOR;
						else if (HAS_BASE(SfxStringItem   ,&rItem)) aEntry.eItemType=ITEM_STRING;
						else if (HAS_BASE(SfxPointItem    ,&rItem)) aEntry.eItemType=ITEM_POINT;
						else if (HAS_BASE(SfxRectangleItem,&rItem)) aEntry.eItemType=ITEM_RECT;
						else if (HAS_BASE(SfxRangeItem    ,&rItem)) aEntry.eItemType=ITEM_RANGE;
						else if (HAS_BASE(SdrFractionItem ,&rItem)) aEntry.eItemType=ITEM_FRACTION;
						else if (HAS_BASE(SvxColorItem    ,&rItem)) aEntry.eItemType=ITEM_COLOR;
						else if (HAS_BASE(SvxFontItem     ,&rItem)) aEntry.eItemType=ITEM_FONT;
						else if (HAS_BASE(SvxFontHeightItem,&rItem))aEntry.eItemType=ITEM_FONTHEIGHT;
						else if (HAS_BASE(SvxCharScaleWidthItem,&rItem)) aEntry.eItemType=ITEM_FONTWIDTH;
						else if (HAS_BASE(SvxFieldItem    ,&rItem)) aEntry.eItemType=ITEM_FIELD;
						switch (aEntry.eItemType) {
							case ITEM_BYTE      : aEntry.bIsNum=TRUE;  aEntry.nVal=((SfxByteItem  &)rItem).GetValue(); aEntry.nMin=0;      aEntry.nMax=255;   break;
							case ITEM_INT16     : aEntry.bIsNum=TRUE;  aEntry.nVal=((SfxInt16Item &)rItem).GetValue(); aEntry.nMin=-32767; aEntry.nMax=32767; break;
							case ITEM_UINT16    : aEntry.bIsNum=TRUE;  aEntry.nVal=((SfxUInt16Item&)rItem).GetValue(); aEntry.nMin=0;      aEntry.nMax=65535; break;
							case ITEM_INT32     : aEntry.bIsNum=TRUE;  aEntry.nVal=((SfxInt32Item &)rItem).GetValue();                                        break;
							case ITEM_UINT32    : aEntry.bIsNum=TRUE;  aEntry.nVal=((SfxUInt32Item&)rItem).GetValue(); aEntry.nMin=0; /*aEntry.nMax=0xFF...*/;break;
							case ITEM_ENUM      : aEntry.bCanNum=TRUE; aEntry.nVal=((SfxEnumItemInterface&)rItem).GetEnumValue(); aEntry.nMin=0; aEntry.nMax=((SfxEnumItemInterface&)rItem).GetValueCount()-1; break;
							case ITEM_BOOL      : aEntry.bCanNum=TRUE; aEntry.nVal=((SfxBoolItem  &)rItem).GetValue(); aEntry.nMin=0; aEntry.nMax=1;          break;
							case ITEM_FLAG      : aEntry.bCanNum=TRUE; aEntry.nVal=((SfxFlagItem  &)rItem).GetValue(); aEntry.nMin=0; aEntry.nMax=0xFFFF;     break;
							case ITEM_FONTHEIGHT: aEntry.bCanNum=TRUE; aEntry.nVal=((SvxFontHeightItem&)rItem).GetHeight(); aEntry.nMin=0;                    break;
							case ITEM_FONTWIDTH : aEntry.bCanNum=TRUE; aEntry.nVal=((SvxCharScaleWidthItem&)rItem).GetValue();    aEntry.nMin=0; aEntry.nMax=0xFFFF;break;
							default: break;
						} // switch
						if (aEntry.bIsNum) aEntry.bCanNum=TRUE;
						FASTBOOL bGetPres=TRUE;
						if (bGetPres) {
							rItem.GetPresentation(SFX_ITEM_PRESENTATION_NAMELESS,
												  pPool->GetMetric(nWhich),
												  SFX_MAPUNIT_MM,aEntry.aValue);
							if (aEntry.bCanNum) {
								aEntry.aValue.InsertAscii(": ",0);
								aEntry.aValue.Insert(UniString::CreateFromInt32(aEntry.nVal),0);
							}
						} else {
							if (aEntry.eItemType==ITEM_BOOL) aEntry.aValue.AppendAscii(aEntry.nVal!=0 ? "True" : "False");
							else if (aEntry.bCanNum) aEntry.aValue = UniString::CreateFromInt32(aEntry.nVal);
							else if (aEntry.eItemType==ITEM_STRING) aEntry.aValue=((SfxStringItem&)rItem).GetValue();
							else if (aEntry.eItemType==ITEM_ENUM && nWhich!=EE_CHAR_WEIGHT) aEntry.aValue=((SfxEnumItemInterface&)rItem).GetValueTextByPos((BOOL)aEntry.nVal);
							else aEntry.aValue = String("GPF", aTextEncoding);
						}
					} else {
						aEntry.aValue = String("InvalidItem", aTextEncoding);
					}
					ImpSetEntry(aEntry,nEntryNum);
					nEntryNum++;
				}
			}
			nWhich=aIter.NextWhich();
		} // while

		if (aList.Count()>nEntryNum) { // evtl. noch zuviele Eintraege
			ULONG nTooMuch=aList.Count()-nEntryNum;
			for (ULONG nNum=0; nNum<nTooMuch; nNum++) {
				delete ImpGetEntry(nEntryNum);
				aList.Remove(nEntryNum);
			}
			RowRemoved(nEntryNum,nTooMuch);
		}
	} else {
		Clear(); // wenn pSet==NULL
	}
	ImpRestoreWhich();
	SetMode(MYBROWSEMODE);
}

////////////////////////////////////////////////////////////////////////////////////////////////////

_SdrItemBrowserWindow::_SdrItemBrowserWindow(Window* pParent, WinBits nBits):
	FloatingWindow(pParent,nBits),
	aBrowse(this)
{
	SetOutputSizePixel(aBrowse.GetSizePixel());
	SetText(String("Joe's ItemBrowser", gsl_getSystemTextEncoding()));
	aBrowse.Show();
}

__EXPORT _SdrItemBrowserWindow::~_SdrItemBrowserWindow()
{
}

void __EXPORT _SdrItemBrowserWindow::Resize()
{
	aBrowse.SetSizePixel(GetOutputSizePixel());
}

void __EXPORT _SdrItemBrowserWindow::GetFocus()
{
	aBrowse.GrabFocus();
}

////////////////////////////////////////////////////////////////////////////////////////////////////

SdrItemBrowser::SdrItemBrowser(SdrView& rView):
	_SdrItemBrowserWindow(ImpGetViewWin(rView)),
	pView(&rView),
	bDirty(FALSE)
{
	aIdleTimer.SetTimeoutHdl(LINK(this,SdrItemBrowser,IdleHdl));
	GetBrowserControl().SetEntryChangedHdl(LINK(this,SdrItemBrowser,ChangedHdl));
	GetBrowserControl().SetSetDirtyHdl(LINK(this,SdrItemBrowser,SetDirtyHdl));
	SetDirty();
}

Window* SdrItemBrowser::ImpGetViewWin(SdrView& rView)
{
	const sal_uInt32 nWinCount(rView.PaintWindowCount());

	for(sal_uInt32 a(0L); a < nWinCount; a++)
	{
		SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);

		if(OUTDEV_WINDOW == pCandidate->GetOutputDevice().GetOutDevType())
		{
			return (Window*)(&pCandidate->GetOutputDevice());
		}
	}

	return 0L;
}

void SdrItemBrowser::ForceParent()
{
	Window* pWin=ImpGetViewWin(*pView);
	if (pWin!=NULL) SetParent(pWin);
}

void SdrItemBrowser::SetDirty()
{
	if (!bDirty) {
		bDirty=TRUE;
		aIdleTimer.SetTimeout(1);
		aIdleTimer.Start();
	}
}

void SdrItemBrowser::Undirty()
{
	aIdleTimer.Stop();
	bDirty = FALSE;

//	SfxItemSet aSet(pView->GetAttributes());
	SfxItemSet aSet(pView->GetModel()->GetItemPool());
	pView->GetAttributes(aSet);

	if(pView->AreObjectsMarked())
	{
		// SfxItemSet a2ndSet(pView->GetAttributes(TRUE));
		SfxItemSet a2ndSet(pView->GetModel()->GetItemPool());
		pView->GetAttributes(a2ndSet, TRUE);

		SetAttributes(&aSet,&a2ndSet);
	}
	else
	{
		SetAttributes(&aSet);
	}
}

IMPL_LINK(SdrItemBrowser,IdleHdl,Timer*,EMPTYARG)
{
	Undirty();
	return 0;
}

IMPL_LINK(SdrItemBrowser,ChangedHdl,_SdrItemBrowserControl*,pBrowse)
{
	const ImpItemListRow* pEntry=pBrowse->GetAktChangeEntry();
	if (pEntry!=NULL)
	{
//		SfxItemSet aSet(pView->GetAttributes());
		SfxItemSet aSet(pView->GetModel()->GetItemPool());
		pView->GetAttributes(aSet);

		SfxItemSet aNewSet(*aSet.GetPool(),pEntry->nWhichId,pEntry->nWhichId);
		XubString aNewText(pBrowse->GetNewEntryValue());
		BOOL bDel( aNewText.EqualsAscii("del")
			|| aNewText.EqualsAscii("Del")
			|| aNewText.EqualsAscii("DEL")
			|| aNewText.EqualsAscii("default")
			|| aNewText.EqualsAscii("Default")
			|| aNewText.EqualsAscii("DEFAULT"));

		if (!bDel) {
			SfxPoolItem* pNewItem=aSet.Get(pEntry->nWhichId).Clone();
			long nLongVal=0;
			nLongVal = aNewText.ToInt32();
			if (pEntry->bCanNum) {
				if (nLongVal>pEntry->nMax) nLongVal=pEntry->nMax;
				if (nLongVal<pEntry->nMin) nLongVal=pEntry->nMin;
			}
			FASTBOOL bPair=FALSE;
			FASTBOOL bPairX=TRUE;
			FASTBOOL bPairY=FALSE;
			USHORT nSepLen=1;
			long nLongX = aNewText.ToInt32();
			long nLongY=0;
			xub_StrLen nPos = aNewText.Search(sal_Unicode('/'));
			if (nPos==STRING_NOTFOUND) nPos=aNewText.Search(sal_Unicode(':'));
			if (nPos==STRING_NOTFOUND) nPos=aNewText.Search(sal_Unicode(' '));
			if (nPos==STRING_NOTFOUND) { nPos=aNewText.SearchAscii(".."); if (nPos!=STRING_NOTFOUND) nSepLen=2; }
			if (nPos!=STRING_NOTFOUND) {
				bPair=TRUE;
				bPairX=nPos>0;
				XubString s(aNewText);
				s.Erase(0,nPos+nSepLen);
				bPairY = (BOOL)aNewText.Len();
				nLongY = s.ToInt32();
			}
			switch (pEntry->eItemType) {
				case ITEM_BYTE  : ((SfxByteItem  *)pNewItem)->SetValue((BYTE  )nLongVal); break;
				case ITEM_INT16 : ((SfxInt16Item *)pNewItem)->SetValue((INT16 )nLongVal); break;
				case ITEM_UINT16: ((SfxUInt16Item*)pNewItem)->SetValue((UINT16)nLongVal); break;
				case ITEM_INT32: {
					if(HAS_BASE(SdrAngleItem, pNewItem))
					{
						aNewText.SearchAndReplace(sal_Unicode(','), sal_Unicode('.'));
						double nVal = aNewText.ToFloat();
						nLongVal = (long)(nVal * 100 + 0.5);
					}
					((SfxInt32Item *)pNewItem)->SetValue((INT32)nLongVal);
				} break;
				case ITEM_UINT32: ((SfxUInt32Item*)pNewItem)->SetValue(aNewText.ToInt32()); break;
				case ITEM_ENUM  : ((SfxEnumItemInterface*)pNewItem)->SetEnumValue((USHORT)nLongVal); break;
				case ITEM_BOOL: {
					aNewText.ToUpperAscii();
					if (aNewText.EqualsAscii("TRUE")) nLongVal=1;
					if (aNewText.EqualsAscii("JA")) nLongVal=1;
					if (aNewText.EqualsAscii("AN")) nLongVal=1;
					if (aNewText.EqualsAscii("EIN")) nLongVal=1;
					if (aNewText.EqualsAscii("ON")) nLongVal=1;
					if (aNewText.EqualsAscii("YES")) nLongVal=1;
					((SfxBoolItem*)pNewItem)->SetValue((BOOL)nLongVal);
				} break;
				case ITEM_FLAG  : ((SfxFlagItem  *)pNewItem)->SetValue((USHORT)nLongVal); break;
				case ITEM_STRING: ((SfxStringItem*)pNewItem)->SetValue(aNewText); break;
				case ITEM_POINT : ((SfxPointItem*)pNewItem)->SetValue(Point(nLongX,nLongY)); break;
				case ITEM_RECT  : break;
				case ITEM_RANGE : {
					((SfxRangeItem*)pNewItem)->From()=(USHORT)nLongX;
					((SfxRangeItem*)pNewItem)->From()=(USHORT)nLongY;
				} break;
				case ITEM_LRANGE : {
				} break;
				case ITEM_FRACTION: {
					if (!bPairX) nLongX=1;
					if (!bPairY) nLongY=1;
					((SdrFractionItem*)pNewItem)->SetValue(Fraction(nLongX,nLongY));
				} break;
				case ITEM_XCOLOR: break;
				case ITEM_COLOR: break;
				case ITEM_FONT: {
					((SvxFontItem*)pNewItem)->GetFamily()=FAMILY_DONTKNOW;
					((SvxFontItem*)pNewItem)->GetFamilyName()=aNewText;
					((SvxFontItem*)pNewItem)->GetStyleName().Erase();
				} break;
				case ITEM_FONTHEIGHT: {
					ULONG nHgt=0;
					USHORT nProp=100;
					if (aNewText.Search(sal_Unicode('%'))!=STRING_NOTFOUND) {
						nProp=(USHORT)nLongVal;
					} else {
						nHgt=nLongVal;
					}
					((SvxFontHeightItem*)pNewItem)->SetHeight(nHgt,nProp);
				} break;
				case ITEM_FONTWIDTH: {
					USHORT nProp=100;
					if (aNewText.Search(sal_Unicode('%'))!=STRING_NOTFOUND) {
						nProp=(USHORT)nLongVal;
					}
					((SvxCharScaleWidthItem*)pNewItem)->SetValue(nProp);
				} break;
				case ITEM_FIELD: break;
				default: break;
			} // switch
			aNewSet.Put(*pNewItem);
			delete pNewItem;
		}
		pView->SetAttributes(aNewSet,bDel);
	}
	return 0;
}

IMPL_LINK(SdrItemBrowser,SetDirtyHdl,_SdrItemBrowserControl*,EMPTYARG)
{
	SetDirty();
	return 0;
}


