1302 lines
52 KiB
C++
1302 lines
52 KiB
C++
/*************************************************************************
|
||
*
|
||
* 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 <20> 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;
|
||
}
|
||
|
||
|