LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdibrow.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 1 743 0.1 %
Date: 2014-11-03 Functions: 2 56 3.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <stdlib.h>
      21             : 
      22             : #include "editeng/fontitem.hxx"
      23             : #include "svdibrow.hxx"
      24             : #include <editeng/charscaleitem.hxx>
      25             : #include <editeng/colritem.hxx>
      26             : #include <editeng/editdata.hxx>
      27             : #include <editeng/eeitem.hxx>
      28             : #include <editeng/fhgtitem.hxx>
      29             : #include <editeng/flditem.hxx>
      30             : #include <svl/flagitem.hxx>
      31             : #include <svl/ptitem.hxx>
      32             : #include <svl/rectitem.hxx>
      33             : #include <svl/rngitem.hxx>
      34             : #include <svl/whiter.hxx>
      35             : 
      36             : #include <svx/sdrpaintwindow.hxx>
      37             : #include <svx/svdattr.hxx>
      38             : #include <svx/svdpool.hxx>
      39             : #include <svx/svdview.hxx>
      40             : #include <svx/sxcaitm.hxx>
      41             : #include <svx/sxcecitm.hxx>
      42             : #include <sxcikitm.hxx>
      43             : #include <svx/sxcllitm.hxx>
      44             : #include <svx/sxekitm.hxx>
      45             : #include <svx/sxelditm.hxx>
      46             : #include <svx/sxfiitm.hxx>
      47             : #include <svx/xenum.hxx>
      48             : #include <svx/xfillit0.hxx>
      49             : #include <svx/xflbmtit.hxx>
      50             : #include <svx/xflbstit.hxx>
      51             : #include <svx/xflbtoxy.hxx>
      52             : #include <svx/xftshit.hxx>
      53             : #include <svx/xlineit0.hxx>
      54             : #include <svx/xlnedwit.hxx>
      55             : #include <svx/xlnstwit.hxx>
      56             : #include <svx/xtextit0.hxx>
      57             : 
      58             : using namespace com::sun::star;
      59             : 
      60             : #define ITEMBROWSER_WHICHCOL_ID 1
      61             : #define ITEMBROWSER_STATECOL_ID 2
      62             : #define ITEMBROWSER_TYPECOL_ID  3
      63             : #define ITEMBROWSER_NAMECOL_ID  4
      64             : #define ITEMBROWSER_VALUECOL_ID 5
      65             : 
      66             : enum ItemType {
      67             :     ITEM_DONTKNOW, ITEM_BYTE, ITEM_INT16, ITEM_UINT16, ITEM_INT32, ITEM_UINT32,
      68             :     ITEM_ENUM, ITEM_BOOL, ITEM_FLAG, ITEM_STRING, ITEM_POINT, ITEM_RECT, ITEM_RANGE, ITEM_LRANGE,
      69             :     ITEM_FRACTION,
      70             :     ITEM_XCOLOR,
      71             :     ITEM_COLOR,
      72             :     ITEM_FONT, ITEM_FONTHEIGHT, ITEM_FONTWIDTH, ITEM_FIELD
      73             : };
      74             : 
      75             : // - ImpItemListRow -
      76             : 
      77           0 : class ImpItemListRow
      78             : {
      79             : public:
      80             :     OUString                        aName;
      81             :     OUString                        aValue;
      82             :     SfxItemState                    eState;
      83             :     sal_uInt16                      nWhichId;
      84             : 
      85             :     TypeId                          pType;
      86             :     ItemType                        eItemType;
      87             : 
      88             :     sal_Int32                       nVal;
      89             :     sal_Int32                       nMin;
      90             :     sal_Int32                       nMax;
      91             : 
      92             :     bool                            bComment;
      93             :     bool                            bIsNum;
      94             :     bool                            bCanNum;
      95             : 
      96             : public:
      97           0 :     ImpItemListRow()
      98             :     :   eState(SfxItemState::UNKNOWN),
      99             :         nWhichId(0),
     100             :         pType(NULL),
     101             :         eItemType(ITEM_DONTKNOW),
     102             :         nVal(0),
     103             :         nMin(0),
     104             :         nMax(0),
     105             :         bComment(false),
     106             :         bIsNum(false),
     107           0 :         bCanNum(false)
     108           0 :     {}
     109             : 
     110             :     OUString GetItemTypeStr() const;
     111             :     bool operator==(const ImpItemListRow& rEntry) const;
     112           0 :     bool operator!=(const ImpItemListRow& rEntry) const { return !operator==(rEntry); }
     113             : };
     114             : 
     115           0 : OUString ImpItemListRow::GetItemTypeStr() const
     116             : {
     117           0 :     switch(eItemType)
     118             :     {
     119           0 :         case ITEM_BYTE      : return OUString("Byte");     break;
     120           0 :         case ITEM_INT16     : return OUString("Int16");    break;
     121           0 :         case ITEM_UINT16    : return OUString("UInt16");   break;
     122           0 :         case ITEM_INT32     : return OUString("Int32");    break;
     123           0 :         case ITEM_UINT32    : return OUString("UInt32");   break;
     124           0 :         case ITEM_ENUM      : return OUString("Enum");     break;
     125           0 :         case ITEM_BOOL      : return OUString("Bool");     break;
     126           0 :         case ITEM_FLAG      : return OUString("Flag");     break;
     127           0 :         case ITEM_STRING    : return OUString("String");   break;
     128           0 :         case ITEM_POINT     : return OUString("Point");    break;
     129           0 :         case ITEM_RECT      : return OUString("Rectangle");break;
     130           0 :         case ITEM_RANGE     : return OUString("Range");    break;
     131           0 :         case ITEM_LRANGE    : return OUString("LRange");   break;
     132           0 :         case ITEM_FRACTION  : return OUString("Fraction"); break;
     133           0 :         case ITEM_XCOLOR    : return OUString("XColor");   break;
     134           0 :         case ITEM_COLOR     : return OUString("Color");    break;
     135           0 :         case ITEM_FONT      : return OUString("Font");     break;
     136           0 :         case ITEM_FONTHEIGHT: return OUString("FontHeight");break;
     137           0 :         case ITEM_FONTWIDTH : return OUString("FontWidth"); break;
     138           0 :         case ITEM_FIELD     : return OUString("Field");     break;
     139           0 :         default: break;
     140             :     }
     141             : 
     142           0 :     return OUString();
     143             : }
     144             : 
     145           0 : bool ImpItemListRow::operator==(const ImpItemListRow& rEntry) const
     146             : {
     147           0 :     return (aName.equals(rEntry.aName)
     148           0 :         && aValue.equals(rEntry.aValue)
     149           0 :         && eState==rEntry.eState
     150           0 :         && nWhichId==rEntry.nWhichId
     151           0 :         && bComment==rEntry.bComment
     152           0 :         && bIsNum==rEntry.bIsNum
     153           0 :         && bCanNum==rEntry.bCanNum
     154           0 :         && pType==rEntry.pType
     155           0 :         && eItemType==rEntry.eItemType
     156           0 :         && nVal==rEntry.nVal
     157           0 :         && nMin==rEntry.nMin
     158           0 :         && nMax==rEntry.nMax);
     159             : }
     160             : 
     161             : // - ImpItemEdit -
     162             : 
     163             : class ImpItemEdit: public Edit
     164             : {
     165             :     _SdrItemBrowserControl*     pBrowse;
     166             : 
     167             : public:
     168           0 :     ImpItemEdit(vcl::Window* pParent, _SdrItemBrowserControl* pBrowse_, WinBits nBits=0)
     169             :     :   Edit(pParent, nBits),
     170           0 :         pBrowse(pBrowse_)
     171           0 :     {}
     172             : 
     173             :     virtual ~ImpItemEdit();
     174             :     virtual void KeyInput(const KeyEvent& rEvt) SAL_OVERRIDE;
     175             : };
     176             : 
     177           0 : ImpItemEdit::~ImpItemEdit()
     178             : {
     179           0 : }
     180             : 
     181           0 : void ImpItemEdit::KeyInput(const KeyEvent& rKEvt)
     182             : {
     183           0 :     _SdrItemBrowserControl* pBrowseMerk = pBrowse;
     184             : 
     185           0 :     sal_uInt16 nKeyCode(rKEvt.GetKeyCode().GetCode() + rKEvt.GetKeyCode().GetModifier());
     186             : 
     187           0 :     if(nKeyCode == KEY_RETURN)
     188             :     {
     189           0 :         pBrowseMerk->EndChangeEntry();
     190           0 :         pBrowseMerk->GrabFocus();
     191             :     }
     192           0 :     else if(nKeyCode == KEY_ESCAPE)
     193             :     {
     194           0 :         pBrowseMerk->BrkChangeEntry();
     195           0 :         pBrowseMerk->GrabFocus();
     196             :     }
     197           0 :     else if(nKeyCode == KEY_UP || nKeyCode == KEY_DOWN)
     198             :     {
     199           0 :         pBrowseMerk->EndChangeEntry();
     200           0 :         pBrowseMerk->GrabFocus();
     201           0 :         pBrowseMerk->KeyInput(rKEvt);
     202             :     }
     203             :     else
     204           0 :         Edit::KeyInput(rKEvt);
     205           0 : }
     206             : 
     207             : // - _SdrItemBrowserControl -
     208             : 
     209             : #define MYBROWSEMODE (BROWSER_THUMBDRAGGING|BROWSER_KEEPHIGHLIGHT|BROWSER_NO_HSCROLL|BROWSER_HIDECURSOR)
     210             : 
     211           0 : _SdrItemBrowserControl::_SdrItemBrowserControl(vcl::Window* pParent, WinBits nBits):
     212             :     BrowseBox(pParent,nBits,MYBROWSEMODE),
     213           0 :     aList()
     214             : {
     215           0 :     ImpCtor();
     216           0 : }
     217             : 
     218           0 : _SdrItemBrowserControl::~_SdrItemBrowserControl()
     219             : {
     220           0 :     delete pEditControl;
     221             : 
     222           0 :     delete pAktChangeEntry;
     223             : 
     224           0 :     Clear();
     225           0 : }
     226             : 
     227           0 : void _SdrItemBrowserControl::ImpCtor()
     228             : {
     229           0 :     pEditControl = NULL;
     230           0 :     pAktChangeEntry = NULL;
     231           0 :     nLastWhichOfs = 0;
     232           0 :     nLastWhich = 0;
     233           0 :     nLastWhichOben = 0;  // not implemented yet
     234           0 :     nLastWhichUnten = 0; // not implemented yet
     235           0 :     bWhichesButNames = false;
     236           0 :     bDontHideIneffectiveItems = false;
     237           0 :     bDontSortItems = false;
     238           0 :     bShowWhichIds = false;
     239           0 :     bShowRealValues = false;
     240           0 :     bShowWhichIds = true;   // not implemented yet
     241           0 :     bShowRealValues = true; // not implemented yet
     242             : 
     243             :     InsertDataColumn(
     244             :         ITEMBROWSER_WHICHCOL_ID,
     245             :         OUString("Which"),
     246           0 :         GetTextWidth(OUString(" Which ")) + 2);
     247             :     InsertDataColumn(
     248             :         ITEMBROWSER_STATECOL_ID,
     249             :         OUString("State"),
     250           0 :         std::max(GetTextWidth(OUString(" State ")) + 2 ,
     251           0 :             GetTextWidth(OUString("DontCare")) + 2));
     252             :     InsertDataColumn(
     253             :         ITEMBROWSER_TYPECOL_ID ,
     254             :         OUString("Type"),
     255           0 :         GetTextWidth(OUString(" Type_ ")) + 2);
     256             :     InsertDataColumn(
     257             :         ITEMBROWSER_NAMECOL_ID ,
     258             :         OUString("Name"),
     259           0 :         150);
     260             :     InsertDataColumn(
     261             :         ITEMBROWSER_VALUECOL_ID,
     262             :         OUString("Value"),
     263           0 :         GetTextWidth(OUString("12345678901234567890")));
     264             :     SetDataRowHeight(
     265           0 :         GetTextHeight());
     266             : 
     267           0 :     long nWdt=GetColumnWidth(ITEMBROWSER_WHICHCOL_ID)+
     268           0 :               GetColumnWidth(ITEMBROWSER_STATECOL_ID)+
     269           0 :               GetColumnWidth(ITEMBROWSER_TYPECOL_ID )+
     270           0 :               GetColumnWidth(ITEMBROWSER_NAMECOL_ID )+
     271           0 :               GetColumnWidth(ITEMBROWSER_VALUECOL_ID);
     272             : 
     273           0 :     long nHgt=GetTitleHeight()+16*GetDataRowHeight();
     274             : 
     275           0 :     SetOutputSizePixel(Size(nWdt,nHgt));
     276           0 : }
     277             : 
     278           0 : void _SdrItemBrowserControl::Clear()
     279             : {
     280           0 :     sal_uIntPtr nAnz=aList.size();
     281           0 :     for (sal_uIntPtr nNum=0; nNum<nAnz; nNum++) {
     282           0 :         delete ImpGetEntry(nNum);
     283             :     }
     284           0 :     aList.clear();
     285           0 :     BrowseBox::Clear();
     286           0 : }
     287             : 
     288           0 : long _SdrItemBrowserControl::GetRowCount() const
     289             : {
     290           0 :     return aList.size();
     291             : }
     292             : 
     293           0 : bool _SdrItemBrowserControl::SeekRow(long nRow)
     294             : {
     295           0 :     nAktPaintRow = nRow;
     296           0 :     return true;
     297             : }
     298             : 
     299           0 : OUString _SdrItemBrowserControl::GetCellText(long _nRow, sal_uInt16 _nColId) const
     300             : {
     301           0 :     OUString sRet;
     302           0 :     if ( _nRow >= 0 && _nRow < (sal_Int32)aList.size() )
     303             :     {
     304           0 :         ImpItemListRow* pEntry = ImpGetEntry(_nRow);
     305           0 :         if ( pEntry )
     306             :         {
     307           0 :             if ( pEntry->bComment )
     308             :             {
     309           0 :                 if (_nColId == ITEMBROWSER_NAMECOL_ID)
     310           0 :                     sRet = pEntry->aName;
     311             :             }
     312             :             else
     313             :             {
     314           0 :                 sRet = "???";
     315           0 :                 switch (_nColId)
     316             :                 {
     317             :                     case ITEMBROWSER_WHICHCOL_ID:
     318           0 :                         sRet = OUString::number( pEntry->nWhichId ); break;
     319             :                     case ITEMBROWSER_STATECOL_ID:
     320             :                     {
     321           0 :                         switch (pEntry->eState)
     322             :                         {
     323           0 :                             case SfxItemState::UNKNOWN : sRet = "Unknown";  break;
     324           0 :                             case SfxItemState::DISABLED: sRet = "Disabled"; break;
     325           0 :                             case SfxItemState::DONTCARE: sRet = "DontCare"; break;
     326           0 :                             case SfxItemState::SET     : sRet = "Set";      break;
     327           0 :                             case SfxItemState::DEFAULT : sRet = "Default";  break;
     328           0 :                             case SfxItemState::READONLY: sRet = "ReadOnly";  break;
     329             :                         } // switch
     330           0 :                     } break;
     331           0 :                     case ITEMBROWSER_TYPECOL_ID: sRet = pEntry->GetItemTypeStr(); break;
     332           0 :                     case ITEMBROWSER_NAMECOL_ID: sRet = pEntry->aName; break;
     333           0 :                     case ITEMBROWSER_VALUECOL_ID: sRet = pEntry->aValue; break;
     334             :                 } // switch
     335             :             }
     336             :         }
     337             :     }
     338           0 :     return sRet;
     339             : }
     340             : 
     341           0 : void _SdrItemBrowserControl::PaintField(OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId) const
     342             : {
     343           0 :     if (nAktPaintRow<0 || (sal_uIntPtr)nAktPaintRow>=aList.size()) {
     344           0 :         return;
     345             :     }
     346           0 :     Rectangle aR(rRect);
     347           0 :     aR.Bottom()++;
     348           0 :     ImpItemListRow* pEntry=ImpGetEntry(nAktPaintRow);
     349           0 :     if (pEntry->bComment)
     350             :     {
     351           0 :         if (nColumnId==ITEMBROWSER_NAMECOL_ID)
     352             :         {
     353           0 :             rDev.SetLineColor();
     354           0 :             rDev.SetFillColor( Color( COL_LIGHTGRAY ) );
     355           0 :             aR.Left()=0;
     356           0 :             aR.Right()=rDev.GetOutputSize().Width();
     357           0 :             rDev.DrawRect(aR);
     358           0 :             rDev.DrawText(rRect.TopLeft(),pEntry->aName);
     359             :         }
     360             :     } else {
     361           0 :         rDev.SetClipRegion(vcl::Region(aR));
     362           0 :         rDev.DrawText(aR.TopLeft(),GetCellText(nAktPaintRow,nColumnId));
     363           0 :         rDev.SetClipRegion();
     364             :     }
     365             : }
     366             : 
     367           0 : sal_uIntPtr _SdrItemBrowserControl::GetCurrentPos() const
     368             : {
     369           0 :     sal_uIntPtr nRet=CONTAINER_ENTRY_NOTFOUND;
     370           0 :     if (GetSelectRowCount()==1) {
     371           0 :         long nPos=((BrowseBox*)this)->FirstSelectedRow();
     372           0 :         if (nPos>=0 && (sal_uIntPtr)nPos<aList.size()) {
     373           0 :             nRet=(sal_uIntPtr)nPos;
     374             :         }
     375             :     }
     376           0 :     return nRet;
     377             : }
     378             : 
     379           0 : sal_uInt16 _SdrItemBrowserControl::GetCurrentWhich() const
     380             : {
     381           0 :     sal_uInt16 nRet=0;
     382           0 :     sal_uIntPtr nPos=GetCurrentPos();
     383           0 :     if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
     384           0 :         nRet=ImpGetEntry(nPos)->nWhichId;
     385             :     }
     386           0 :     return nRet;
     387             : }
     388             : 
     389           0 : void _SdrItemBrowserControl::DoubleClick(const BrowserMouseEvent&)
     390             : {
     391           0 :     sal_uIntPtr nPos=GetCurrentPos();
     392           0 :     if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
     393           0 :         BegChangeEntry(nPos);
     394             :     }
     395           0 : }
     396             : 
     397           0 : void _SdrItemBrowserControl::KeyInput(const KeyEvent& rKEvt)
     398             : {
     399           0 :     sal_uInt16 nKeyCode=rKEvt.GetKeyCode().GetCode()+rKEvt.GetKeyCode().GetModifier();
     400           0 :     bool bAusgewertet = false;
     401           0 :     sal_uIntPtr nPos=GetCurrentPos();
     402           0 :     if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
     403           0 :         if (nKeyCode==KEY_RETURN) {
     404           0 :             if (BegChangeEntry(nPos)) bAusgewertet = true;
     405           0 :         } else if (nKeyCode==KEY_ESCAPE) {
     406             : 
     407           0 :         } else if (rKEvt.GetKeyCode().GetModifier()==KEY_SHIFT+KEY_MOD1+KEY_MOD2) { // Ctrl
     408           0 :             if (nKeyCode==KEY_SHIFT+KEY_MOD1+KEY_MOD2+KEY_W) {
     409           0 :                 bWhichesButNames=!bWhichesButNames;
     410           0 :                 SetDirty();
     411             :             }
     412           0 :             if (nKeyCode==KEY_SHIFT+KEY_MOD1+KEY_MOD2+KEY_I) {
     413           0 :                 bDontHideIneffectiveItems=!bDontHideIneffectiveItems;
     414           0 :                 SetDirty();
     415             :             }
     416           0 :             if (nKeyCode==KEY_SHIFT+KEY_MOD1+KEY_MOD2+KEY_S) {
     417           0 :                 bDontSortItems=!bDontSortItems;
     418           0 :                 SetDirty();
     419             :             }
     420             :         }
     421             :     }
     422           0 :     if (!bAusgewertet) BrowseBox::KeyInput(rKEvt);
     423           0 : }
     424             : 
     425           0 : void _SdrItemBrowserControl::SetDirty()
     426             : {
     427           0 :     aSetDirtyHdl.Call(this);
     428           0 : }
     429             : 
     430           0 : Rectangle _SdrItemBrowserControl::GetFieldCharacterBounds(sal_Int32 /*_nRow*/,sal_Int32 /*_nColumnPos*/,sal_Int32 /*nIndex*/)
     431             : {
     432             :     // no accessibility implementation required
     433           0 :     return Rectangle();
     434             : }
     435             : 
     436           0 : sal_Int32 _SdrItemBrowserControl::GetFieldIndexAtPoint(sal_Int32 /*_nRow*/,sal_Int32 /*_nColumnPos*/,const Point& /*_rPoint*/)
     437             : {
     438             :     // no accessibility implementation required
     439           0 :     return -1;
     440             : }
     441             : 
     442           0 : void _SdrItemBrowserControl::Select()
     443             : {
     444           0 :     EndChangeEntry();
     445           0 :     BrowseBox::Select();
     446           0 :     ImpSaveWhich();
     447           0 : }
     448             : 
     449           0 : void _SdrItemBrowserControl::ImpSaveWhich()
     450             : {
     451           0 :     sal_uInt16 nWh=GetCurrentWhich();
     452           0 :     if (nWh!=0) {
     453           0 :         long nPos=GetCurrentPos();
     454           0 :         long nTop=GetTopRow();
     455           0 :         long nBtm=GetTopRow()+GetVisibleRows()+1;
     456           0 :         nLastWhich=nWh;
     457           0 :         nLastWhichOfs=nPos-nTop;
     458           0 :         if (nTop<0) nTop=0;
     459           0 :         if (nBtm>=(long)aList.size()) nBtm=aList.size()-1;
     460           0 :         nLastWhichOben=ImpGetEntry(nTop)->nWhichId;
     461           0 :         nLastWhichUnten=ImpGetEntry(nBtm)->nWhichId;
     462             :     }
     463           0 : }
     464             : 
     465           0 : void _SdrItemBrowserControl::ImpRestoreWhich()
     466             : {
     467           0 :     if (nLastWhich!=0) {
     468           0 :         bool bFnd = false;
     469           0 :         sal_uIntPtr nAnz=aList.size();
     470             :         sal_uIntPtr nNum;
     471           0 :         for (nNum=0; nNum<nAnz && !bFnd; nNum++) {
     472           0 :             ImpItemListRow* pEntry=ImpGetEntry(nNum);
     473           0 :             if (!pEntry->bComment) {
     474           0 :                 sal_uInt16 nWh=pEntry->nWhichId;
     475           0 :                 if (nWh==nLastWhich) bFnd = true;
     476             :             }
     477             :         }
     478           0 :         if (bFnd) {
     479           0 :             long nPos=nNum-1;
     480           0 :             long nWhichOfs=nPos-GetTopRow();
     481           0 :             if (nWhichOfs!=nLastWhichOfs) {
     482           0 :                 ScrollRows(nWhichOfs-nLastWhichOfs);
     483             :             }
     484           0 :             GoToRow(nPos);
     485             :         }
     486             :     }
     487           0 : }
     488             : 
     489           0 : bool _SdrItemBrowserControl::BegChangeEntry(sal_uIntPtr nPos)
     490             : {
     491           0 :     BrkChangeEntry();
     492           0 :     bool bRet = false;
     493           0 :     ImpItemListRow* pEntry=ImpGetEntry(nPos);
     494           0 :     if (pEntry!=NULL && !pEntry->bComment) {
     495           0 :         SetMode(MYBROWSEMODE & ~BROWSER_KEEPHIGHLIGHT);
     496           0 :         pEditControl=new ImpItemEdit(&GetDataWindow(),this,0);
     497           0 :         Rectangle aRect(GetFieldRectPixel(nPos, ITEMBROWSER_VALUECOL_ID, false));
     498           0 :         aRect.Left()+=2; // little offset for the Edit, so it's exact to the pixel
     499           0 :         aRect.Right()--;
     500           0 :         pEditControl->SetPosSizePixel(aRect.TopLeft(),aRect.GetSize());
     501           0 :         pEditControl->SetText(pEntry->aValue);
     502           0 :         pEditControl->SetBackground( Wallpaper(Color(COL_LIGHTGRAY)));
     503           0 :         vcl::Font aFont(pEditControl->GetFont());
     504           0 :         aFont.SetFillColor(Color(COL_LIGHTGRAY));
     505           0 :         pEditControl->SetFont(aFont);
     506           0 :         pEditControl->Show();
     507           0 :         pEditControl->GrabFocus();
     508           0 :         pEditControl->SetSelection(Selection(SELECTION_MIN,SELECTION_MAX));
     509           0 :         vcl::Window* pParent=GetParent();
     510           0 :         aWNamMerk=pParent->GetText();
     511           0 :         OUString aNeuNam(aWNamMerk);
     512           0 :         aNeuNam += " ";
     513           0 :         aNeuNam += pEntry->GetItemTypeStr();
     514           0 :         if (pEntry->bCanNum) {
     515           0 :             aNeuNam += ": ";
     516           0 :             aNeuNam += OUString::number(pEntry->nMin);
     517           0 :             aNeuNam += "..";
     518           0 :             aNeuNam += OUString::number(pEntry->nMax);
     519             :         }
     520           0 :         aNeuNam += " - Type 'del' to reset to default.";
     521           0 :         pParent->SetText(aNeuNam);
     522           0 :         pAktChangeEntry=new ImpItemListRow(*pEntry);
     523           0 :         bRet = true;
     524             :     }
     525           0 :     return bRet;
     526             : }
     527             : 
     528           0 : bool _SdrItemBrowserControl::EndChangeEntry()
     529             : {
     530           0 :     bool bRet = false;
     531           0 :     if (pEditControl!=NULL) {
     532           0 :         aEntryChangedHdl.Call(this);
     533           0 :         delete pEditControl;
     534           0 :         pEditControl=NULL;
     535           0 :         delete pAktChangeEntry;
     536           0 :         pAktChangeEntry=NULL;
     537           0 :         vcl::Window* pParent=GetParent();
     538           0 :         pParent->SetText(aWNamMerk);
     539           0 :         SetMode(MYBROWSEMODE);
     540           0 :         bRet = true;
     541             :     }
     542           0 :     return bRet;
     543             : }
     544             : 
     545           0 : void _SdrItemBrowserControl::BrkChangeEntry()
     546             : {
     547           0 :     if (pEditControl!=NULL) {
     548           0 :         delete pEditControl;
     549           0 :         pEditControl=NULL;
     550           0 :         delete pAktChangeEntry;
     551           0 :         pAktChangeEntry=NULL;
     552           0 :         vcl::Window* pParent=GetParent();
     553           0 :         pParent->SetText(aWNamMerk);
     554           0 :         SetMode(MYBROWSEMODE);
     555             :     }
     556           0 : }
     557             : 
     558           0 : void _SdrItemBrowserControl::ImpSetEntry(const ImpItemListRow& rEntry, sal_uIntPtr nEntryNum)
     559             : {
     560             :     SAL_WARN_IF(nEntryNum > aList.size(), "svx", "trying to set item " << nEntryNum << "in a vector of size " << aList.size());
     561           0 :     if (nEntryNum >= aList.size()) {
     562           0 :         nEntryNum = aList.size();
     563           0 :         aList.push_back(new ImpItemListRow(rEntry));
     564           0 :         RowInserted(nEntryNum);
     565             :     } else {
     566           0 :         ImpItemListRow* pAktEntry=ImpGetEntry(nEntryNum);
     567           0 :         if (*pAktEntry!=rEntry) {
     568           0 :             bool bStateDiff=rEntry.eState!=pAktEntry->eState;
     569           0 :             bool bValueDiff=!rEntry.aValue.equals(pAktEntry->aValue);
     570           0 :             bool bAllDiff = true;
     571           0 :             if (bStateDiff || bValueDiff) {
     572             :                 // check whether only state and/or value have changed
     573           0 :                 ImpItemListRow aTest(rEntry);
     574           0 :                 aTest.eState=pAktEntry->eState;
     575           0 :                 aTest.aValue=pAktEntry->aValue;
     576           0 :                 if (aTest==*pAktEntry) bAllDiff = false;
     577             :             }
     578           0 :             *pAktEntry=rEntry;
     579           0 :             if (bAllDiff) {
     580           0 :                 RowModified(nEntryNum);
     581             :             } else {
     582           0 :                 if (bStateDiff) RowModified(nEntryNum,ITEMBROWSER_STATECOL_ID);
     583           0 :                 if (bValueDiff) RowModified(nEntryNum,ITEMBROWSER_VALUECOL_ID);
     584             :             }
     585             :         }
     586             :     }
     587           0 : }
     588             : 
     589           0 : bool ImpGetItem(const SfxItemSet& rSet, sal_uInt16 nWhich, const SfxPoolItem*& rpItem)
     590             : {
     591           0 :     SfxItemState eState=rSet.GetItemState(nWhich,true,&rpItem);
     592           0 :     if (eState==SfxItemState::DEFAULT) {
     593           0 :         rpItem=&rSet.Get(nWhich);
     594             :     }
     595           0 :     return (eState==SfxItemState::DEFAULT || eState==SfxItemState::SET) && rpItem!=NULL;
     596             : }
     597             : 
     598           0 : bool IsItemIneffective(sal_uInt16 nWhich, const SfxItemSet* pSet, sal_uInt16& rIndent)
     599             : {
     600           0 :     rIndent=0;
     601           0 :     if (pSet==NULL) return false;
     602           0 :     const SfxPoolItem* pItem=NULL;
     603           0 :     bool bRet = false;
     604           0 :     switch (nWhich) {
     605             :         case XATTR_LINEDASH         :
     606             :         case XATTR_LINEWIDTH        :
     607             :         case XATTR_LINECOLOR        :
     608             :         case XATTR_LINESTART        :
     609             :         case XATTR_LINEEND          :
     610             :         case XATTR_LINESTARTWIDTH   :
     611             :         case XATTR_LINEENDWIDTH     :
     612             :         case XATTR_LINESTARTCENTER  :
     613             :         case XATTR_LINEENDCENTER    :
     614             :         case XATTR_LINETRANSPARENCE : {
     615           0 :             rIndent=1;
     616           0 :             if (ImpGetItem(*pSet,XATTR_LINESTYLE,pItem)) {
     617           0 :                 XLineStyle eLineStyle=static_cast<const XLineStyleItem*>(pItem)->GetValue();
     618           0 :                 if (eLineStyle==XLINE_NONE) return true;
     619           0 :                 if (eLineStyle!=XLINE_DASH && nWhich==XATTR_LINEDASH) return true;
     620             :             }
     621           0 :             if (nWhich==XATTR_LINESTART || nWhich==XATTR_LINESTARTCENTER) {
     622           0 :                 rIndent=2;
     623           0 :                 if (ImpGetItem(*pSet,XATTR_LINESTARTWIDTH,pItem)) {
     624           0 :                     sal_Int32 nWdt=static_cast<const XLineStartWidthItem*>(pItem)->GetValue();
     625           0 :                     if (nWdt==0) return true;
     626             :                 }
     627             :             }
     628           0 :             if (nWhich==XATTR_LINEEND || nWhich==XATTR_LINEENDCENTER) {
     629           0 :                 rIndent=2;
     630           0 :                 if (ImpGetItem(*pSet,XATTR_LINEENDWIDTH,pItem)) {
     631           0 :                     sal_Int32 nWdt=static_cast<const XLineEndWidthItem*>(pItem)->GetValue();
     632           0 :                     if (nWdt==0) return true;
     633             :                 }
     634             :             }
     635           0 :         } break;
     636             :         case XATTR_FILLCOLOR           : /* only for Style=Color */
     637             :         case XATTR_FILLGRADIENT        : /* only for Style=Gradient */
     638             :         case XATTR_FILLHATCH           : /* only for Style=Hatch */
     639             :         case XATTR_FILLTRANSPARENCE    : /* only for Style=Color */
     640             :         case XATTR_GRADIENTSTEPCOUNT   : /* only for Style=Gradient */
     641             :         case XATTR_FILLBACKGROUND      : /* only for Style=Hatch */
     642             :         {
     643           0 :             rIndent=1;
     644           0 :             if (ImpGetItem(*pSet,XATTR_FILLSTYLE,pItem)) {
     645           0 :                 drawing::FillStyle eFillStyle=static_cast<const XFillStyleItem*>(pItem)->GetValue();
     646           0 :                 if (eFillStyle==drawing::FillStyle_NONE) return true;
     647             :                 // transparency currently only for SolidFill
     648           0 :                 if (eFillStyle!=drawing::FillStyle_SOLID && (nWhich==XATTR_FILLCOLOR || nWhich==XATTR_FILLTRANSPARENCE)) return true;
     649           0 :                 if (eFillStyle!=drawing::FillStyle_GRADIENT && (nWhich==XATTR_FILLGRADIENT || nWhich==XATTR_GRADIENTSTEPCOUNT)) return true;
     650           0 :                 if (eFillStyle!=drawing::FillStyle_HATCH && (nWhich==XATTR_FILLHATCH || nWhich==XATTR_FILLBACKGROUND)) return true;
     651             :             }
     652           0 :         } break;
     653             :         case XATTR_FILLBITMAP          :
     654             :         case XATTR_FILLBMP_TILE        :
     655             :         case XATTR_FILLBMP_POS         : /* currently only if TILE=sal_True */
     656             :         case XATTR_FILLBMP_SIZEX       : /* only if not Stretch */
     657             :         case XATTR_FILLBMP_SIZEY       : /* only if not Stretch */
     658             :         case XATTR_FILLBMP_SIZELOG     : /* only if SIZELOG=sal_False to reset to sal_True (old) -> but is still in use */
     659             :         case XATTR_FILLBMP_TILEOFFSETX : /* only if TILE=sal_True */
     660             :         case XATTR_FILLBMP_TILEOFFSETY : /* only if TILE=sal_True */
     661             :         case XATTR_FILLBMP_STRETCH     : /* only if TILE=sal_False */
     662             :         case XATTR_FILLBMP_POSOFFSETX  : /* only if TILE=sal_True*/
     663             :         case XATTR_FILLBMP_POSOFFSETY  : { /* only if TILE=sal_True*/
     664           0 :             rIndent=1;
     665           0 :             if (ImpGetItem(*pSet,XATTR_FILLSTYLE,pItem)) {
     666           0 :                 drawing::FillStyle eFillStyle=static_cast<const XFillStyleItem*>(pItem)->GetValue();
     667           0 :                 if (eFillStyle!=drawing::FillStyle_BITMAP) return true;
     668             :             }
     669           0 :             if (nWhich==XATTR_FILLBITMAP || nWhich==XATTR_FILLBMP_TILE) {
     670           0 :                 return false; // always selectable
     671             :             }
     672           0 :             bool bTileTRUE = false;
     673           0 :             bool bTileFALSE = false;
     674           0 :             bool bStretchTRUE = false;
     675           0 :             if (ImpGetItem(*pSet,XATTR_FILLBMP_TILE,pItem)) {
     676           0 :                 bTileTRUE=static_cast<const XFillBmpTileItem*>(pItem)->GetValue();
     677           0 :                 bTileFALSE=!bTileTRUE;
     678             :             }
     679           0 :             if (ImpGetItem(*pSet,XATTR_FILLBMP_STRETCH,pItem)) {
     680           0 :                 bStretchTRUE=static_cast<const XFillBmpStretchItem*>(pItem)->GetValue();
     681             :             }
     682             :             // Stretch not selectable if Tile=TRUE
     683           0 :             if (nWhich==XATTR_FILLBMP_STRETCH) return bTileTRUE;
     684             :             // and 7+1 items (sub-attributes) remain
     685           0 :             rIndent=2;
     686             :             // Pos (enum) not selectable if Tile=FALSE
     687           0 :             if (nWhich==XATTR_FILLBMP_POS) return bTileFALSE;
     688             :             // SizeXY not selectable if Stretch=TRUE
     689           0 :             if (nWhich==XATTR_FILLBMP_SIZEX || nWhich==XATTR_FILLBMP_SIZEY) {
     690           0 :                 return bTileFALSE && bStretchTRUE;
     691             :             }
     692             :             // 2 items specially for Tile
     693           0 :             if (nWhich==XATTR_FILLBMP_POSOFFSETX  || nWhich==XATTR_FILLBMP_POSOFFSETY) {
     694           0 :                 return bTileFALSE;
     695             :             }
     696             :             // another 2 items specially for Tile -- however, these exclude each other
     697           0 :             if (nWhich==XATTR_FILLBMP_TILEOFFSETX || nWhich==XATTR_FILLBMP_TILEOFFSETY) {
     698           0 :                 if (bTileFALSE) return true;
     699           0 :                 sal_uInt16 nX=0,nY=0;
     700           0 :                 bool bX = false,bY = false;
     701           0 :                 if (ImpGetItem(*pSet,XATTR_FILLBMP_TILEOFFSETX,pItem)) {
     702           0 :                     nX=static_cast<const XFillBmpTileOffsetXItem*>(pItem)->GetValue();
     703           0 :                     bX = true;
     704             :                 }
     705           0 :                 if (ImpGetItem(*pSet,XATTR_FILLBMP_TILEOFFSETY,pItem)) {
     706           0 :                     nY=static_cast<const XFillBmpTileOffsetYItem*>(pItem)->GetValue();
     707           0 :                     bY = true;
     708             :                 }
     709           0 :                 if (nWhich==XATTR_FILLBMP_TILEOFFSETX) {
     710           0 :                     if (nX!=0 || !bX) return false;
     711           0 :                     if (nY!=0) return true;
     712             :                 } else {
     713           0 :                     if (nY!=0 || !bY) return false;
     714           0 :                     if (nX!=0) return true;
     715             :                 }
     716             :             }
     717             :             // SizeLog not selectable if Stretch=TRUE and/or
     718             :             // if SizeLog=sal_False.
     719             :             // -> apparently still in use
     720             :             // (sal_True is the static PoolDefault)
     721           0 :             if (nWhich==XATTR_FILLBMP_SIZELOG) {
     722           0 :                 if (bTileFALSE && bStretchTRUE) return true;
     723             :             }
     724           0 :         } break;
     725             : 
     726             :         case XATTR_FORMTXTADJUST    :
     727             :         case XATTR_FORMTXTDISTANCE  :
     728             :         case XATTR_FORMTXTSTART     :
     729             :         case XATTR_FORMTXTMIRROR    :
     730             :         case XATTR_FORMTXTOUTLINE   :
     731             :         case XATTR_FORMTXTSHADOW    :
     732             :         case XATTR_FORMTXTSHDWCOLOR :
     733             :         case XATTR_FORMTXTSHDWXVAL  :
     734             :         case XATTR_FORMTXTSHDWYVAL  :
     735             :         case XATTR_FORMTXTHIDEFORM  :
     736             :         case XATTR_FORMTXTSHDWTRANSP: {
     737           0 :             rIndent=1;
     738           0 :             if (ImpGetItem(*pSet,XATTR_FORMTXTSTYLE,pItem)) {
     739           0 :                 XFormTextStyle eStyle=static_cast<const XFormTextStyleItem*>(pItem)->GetValue();
     740           0 :                 if (eStyle==XFT_NONE) return true;
     741             :             }
     742           0 :             if ((nWhich>=XATTR_FORMTXTSHDWCOLOR && nWhich<=XATTR_FORMTXTSHDWYVAL) || nWhich>=XATTR_FORMTXTSHDWTRANSP) {
     743           0 :                 rIndent=2;
     744           0 :                 if (ImpGetItem(*pSet,XATTR_FORMTXTSHADOW,pItem)) {
     745           0 :                     XFormTextShadow eShadow=static_cast<const XFormTextShadowItem*>(pItem)->GetValue();
     746           0 :                     if (eShadow==XFTSHADOW_NONE) return true;
     747             :                 }
     748             :             }
     749           0 :         } break;
     750             : 
     751             :         case SDRATTR_SHADOWCOLOR       :
     752             :         case SDRATTR_SHADOWXDIST       :
     753             :         case SDRATTR_SHADOWYDIST       :
     754             :         case SDRATTR_SHADOWTRANSPARENCE:
     755             :         case SDRATTR_SHADOW3D          :
     756             :         case SDRATTR_SHADOWPERSP       : {
     757           0 :             rIndent=1;
     758           0 :             if (ImpGetItem(*pSet,SDRATTR_SHADOW,pItem)) {
     759           0 :                 bool bShadow=static_cast<const SdrOnOffItem*>(pItem)->GetValue();
     760           0 :                 if (!bShadow) return true;
     761             :             }
     762           0 :         } break;
     763             : 
     764             :         case SDRATTR_CAPTIONANGLE: {
     765           0 :             rIndent=1;
     766           0 :             if (ImpGetItem(*pSet,SDRATTR_CAPTIONFIXEDANGLE,pItem)) {
     767           0 :                 bool bFixed=static_cast<const SdrOnOffItem*>(pItem)->GetValue();
     768           0 :                 if (!bFixed) return true;
     769             :             }
     770           0 :         } break;
     771             :         case SDRATTR_CAPTIONESCREL:
     772             :         case SDRATTR_CAPTIONESCABS: {
     773           0 :             rIndent=1;
     774           0 :             if (ImpGetItem(*pSet,SDRATTR_CAPTIONESCISREL,pItem)) {
     775           0 :                 bool bRel=static_cast<const SdrCaptionEscIsRelItem*>(pItem)->GetValue();
     776           0 :                 if (bRel && nWhich==SDRATTR_CAPTIONESCABS) return true;
     777           0 :                 if (!bRel && nWhich==SDRATTR_CAPTIONESCREL) return true;
     778             :             }
     779           0 :         } break;
     780             :         case SDRATTR_CAPTIONLINELEN: {
     781           0 :             rIndent=1;
     782           0 :             if (ImpGetItem(*pSet,SDRATTR_CAPTIONFITLINELEN,pItem)) {
     783           0 :                 bool bFit=static_cast<const SdrCaptionFitLineLenItem*>(pItem)->GetValue();
     784           0 :                 if (bFit) return true;
     785             :             }
     786           0 :         } break;
     787             : 
     788             :         case SDRATTR_TEXT_MINFRAMEHEIGHT:
     789             :         case SDRATTR_TEXT_MAXFRAMEHEIGHT: {
     790           0 :             rIndent=1;
     791           0 :             if (ImpGetItem(*pSet,SDRATTR_TEXT_AUTOGROWHEIGHT,pItem)) {
     792           0 :                 bool bAutoGrow=static_cast<const SdrOnOffItem*>(pItem)->GetValue();
     793           0 :                 if (!bAutoGrow) return true;
     794             :             }
     795           0 :         } break;
     796             :         case SDRATTR_TEXT_MINFRAMEWIDTH:
     797             :         case SDRATTR_TEXT_MAXFRAMEWIDTH: {
     798           0 :             rIndent=1;
     799           0 :             if (ImpGetItem(*pSet,SDRATTR_TEXT_AUTOGROWWIDTH,pItem)) {
     800           0 :                 bool bAutoGrow=static_cast<const SdrOnOffItem*>(pItem)->GetValue();
     801           0 :                 if (!bAutoGrow) return true;
     802             :             }
     803           0 :         } break;
     804             :         case SDRATTR_TEXT_VERTADJUST:
     805             :         case SDRATTR_TEXT_HORZADJUST: {
     806           0 :             if (ImpGetItem(*pSet,SDRATTR_TEXT_FITTOSIZE,pItem)) {
     807           0 :                 SdrFitToSizeType eFit=static_cast<const SdrTextFitToSizeTypeItem*>(pItem)->GetValue();
     808           0 :                 if (eFit!=SDRTEXTFIT_NONE) return true;
     809             :             }
     810           0 :         } break;
     811             : 
     812             :         case SDRATTR_TEXT_ANIDIRECTION  :
     813             :         case SDRATTR_TEXT_ANISTARTINSIDE:
     814             :         case SDRATTR_TEXT_ANISTOPINSIDE :
     815             :         case SDRATTR_TEXT_ANICOUNT      :
     816             :         case SDRATTR_TEXT_ANIDELAY      :
     817             :         case SDRATTR_TEXT_ANIAMOUNT     : {
     818           0 :             rIndent=1;
     819           0 :             if (ImpGetItem(*pSet,SDRATTR_TEXT_ANIKIND,pItem)) {
     820           0 :                 SdrTextAniKind eAniKind=static_cast<const SdrTextAniKindItem*>(pItem)->GetValue();
     821           0 :                 if (eAniKind==SDRTEXTANI_NONE) return true;
     822           0 :                 if (eAniKind==SDRTEXTANI_BLINK && (nWhich==SDRATTR_TEXT_ANIDIRECTION || nWhich==SDRATTR_TEXT_ANIAMOUNT)) return true;
     823           0 :                 if (eAniKind==SDRTEXTANI_SLIDE && (nWhich==SDRATTR_TEXT_ANISTARTINSIDE || nWhich==SDRATTR_TEXT_ANISTOPINSIDE)) return true;
     824             :             }
     825           0 :         } break;
     826             : 
     827           0 :         case SDRATTR_EDGELINEDELTAANZ: return true;
     828             :         case SDRATTR_EDGELINE1DELTA:
     829             :         case SDRATTR_EDGELINE2DELTA:
     830             :         case SDRATTR_EDGELINE3DELTA: {
     831           0 :             if (ImpGetItem(*pSet,SDRATTR_EDGEKIND,pItem)) {
     832           0 :                 SdrEdgeKind eKind=static_cast<const SdrEdgeKindItem*>(pItem)->GetValue();
     833           0 :                 if (eKind==SDREDGE_THREELINES) {
     834           0 :                     if (nWhich>SDRATTR_EDGELINE2DELTA) return true;
     835           0 :                     else return false;
     836             :                 }
     837           0 :                 if (eKind!=SDREDGE_ORTHOLINES && eKind!=SDREDGE_BEZIER) return true;
     838             :             }
     839           0 :             if (ImpGetItem(*pSet,SDRATTR_EDGELINEDELTAANZ,pItem)) {
     840           0 :                 sal_uInt16 nAnz=static_cast<const SdrEdgeLineDeltaAnzItem*>(pItem)->GetValue();
     841           0 :                 if (nAnz==0) return true;
     842           0 :                 if (nAnz==1 && nWhich>SDRATTR_EDGELINE1DELTA) return true;
     843           0 :                 if (nAnz==2 && nWhich>SDRATTR_EDGELINE2DELTA) return true;
     844             :             }
     845           0 :         } break;
     846             : 
     847             :         case SDRATTR_CIRCSTARTANGLE:
     848             :         case SDRATTR_CIRCENDANGLE  : {
     849           0 :             rIndent=1;
     850           0 :             if (ImpGetItem(*pSet,SDRATTR_CIRCKIND,pItem)) {
     851           0 :                 SdrCircKind eKind=static_cast<const SdrCircKindItem*>(pItem)->GetValue();
     852           0 :                 if (eKind==SDRCIRC_FULL) return true;
     853             :             }
     854           0 :         } break;
     855             :     } // switch
     856           0 :     return bRet;
     857             : }
     858             : 
     859           0 : sal_uInt16 ImpSortWhich(sal_uInt16 nWhich)
     860             : {
     861           0 :     switch (nWhich) {
     862             :         // Line
     863           0 :         case XATTR_LINESTART            : nWhich=XATTR_LINETRANSPARENCE     ; break;
     864           0 :         case XATTR_LINEEND              : nWhich=XATTR_LINESTARTWIDTH       ; break;
     865           0 :         case XATTR_LINESTARTWIDTH       : nWhich=XATTR_LINESTART            ; break;
     866           0 :         case XATTR_LINEENDWIDTH         : nWhich=XATTR_LINESTARTCENTER      ; break;
     867           0 :         case XATTR_LINESTARTCENTER      : nWhich=XATTR_LINEENDWIDTH         ; break;
     868           0 :         case XATTR_LINEENDCENTER        : nWhich=XATTR_LINEEND              ; break;
     869           0 :         case XATTR_LINETRANSPARENCE     : nWhich=XATTR_LINEENDCENTER        ; break;
     870             : 
     871             :         // Fill
     872           0 :         case XATTR_FILLBMP_POS          : nWhich=XATTR_FILLBMP_STRETCH      ; break;
     873           0 :         case XATTR_FILLBMP_SIZEX        : nWhich=XATTR_FILLBMP_POS          ; break;
     874           0 :         case XATTR_FILLBMP_SIZEY        : nWhich=XATTR_FILLBMP_SIZEX        ; break;
     875           0 :         case XATTR_FILLBMP_SIZELOG      : nWhich=XATTR_FILLBMP_SIZEY        ; break;
     876           0 :         case XATTR_FILLBMP_TILEOFFSETX  : nWhich=XATTR_FILLBMP_SIZELOG      ; break;
     877           0 :         case XATTR_FILLBMP_TILEOFFSETY  : nWhich=XATTR_FILLBMP_TILEOFFSETX  ; break;
     878           0 :         case XATTR_FILLBMP_STRETCH      : nWhich=XATTR_FILLBMP_TILEOFFSETY  ; break;
     879             : 
     880             :         // Fontwork
     881           0 :         case XATTR_FORMTXTSHADOW        : nWhich=XATTR_FORMTXTSHDWXVAL      ; break;
     882           0 :         case XATTR_FORMTXTSHDWCOLOR     : nWhich=XATTR_FORMTXTHIDEFORM      ; break;
     883           0 :         case XATTR_FORMTXTSHDWXVAL      : nWhich=XATTR_FORMTXTSHADOW        ; break;
     884           0 :         case XATTR_FORMTXTSHDWYVAL      : nWhich=XATTR_FORMTXTSHDWCOLOR     ; break;
     885           0 :         case XATTR_FORMTXTHIDEFORM      : nWhich=XATTR_FORMTXTSHDWYVAL      ; break;
     886             : 
     887             :         // Misc
     888           0 :         case SDRATTR_TEXT_MINFRAMEHEIGHT: nWhich=SDRATTR_TEXT_FITTOSIZE     ; break;
     889           0 :         case SDRATTR_TEXT_AUTOGROWHEIGHT: nWhich=SDRATTR_TEXT_LEFTDIST      ; break;
     890           0 :         case SDRATTR_TEXT_FITTOSIZE     : nWhich=SDRATTR_TEXT_RIGHTDIST     ; break;
     891           0 :         case SDRATTR_TEXT_LEFTDIST      : nWhich=SDRATTR_TEXT_UPPERDIST     ; break;
     892           0 :         case SDRATTR_TEXT_RIGHTDIST     : nWhich=SDRATTR_TEXT_LOWERDIST     ; break;
     893           0 :         case SDRATTR_TEXT_UPPERDIST     : nWhich=SDRATTR_TEXT_AUTOGROWWIDTH ; break;
     894           0 :         case SDRATTR_TEXT_LOWERDIST     : nWhich=SDRATTR_TEXT_MINFRAMEWIDTH ; break;
     895           0 :         case SDRATTR_TEXT_VERTADJUST    : nWhich=SDRATTR_TEXT_MAXFRAMEWIDTH ; break;
     896           0 :         case SDRATTR_TEXT_MAXFRAMEHEIGHT: nWhich=SDRATTR_TEXT_AUTOGROWHEIGHT; break;
     897           0 :         case SDRATTR_TEXT_MINFRAMEWIDTH : nWhich=SDRATTR_TEXT_MINFRAMEHEIGHT; break;
     898           0 :         case SDRATTR_TEXT_MAXFRAMEWIDTH : nWhich=SDRATTR_TEXT_MAXFRAMEHEIGHT; break;
     899           0 :         case SDRATTR_TEXT_AUTOGROWWIDTH : nWhich=SDRATTR_TEXT_HORZADJUST    ; break;
     900           0 :         case SDRATTR_TEXT_HORZADJUST    : nWhich=SDRATTR_TEXT_VERTADJUST    ; break;
     901             :     } // switch
     902           0 :     return nWhich;
     903             : }
     904             : 
     905             : #define INSERTCOMMENT(nStartId,nEndId,aStr) \
     906             :     { if (nWhich0<nStartId && nWhich>=nStartId && nWhich<=nEndId) aCommentStr=aStr; }
     907             : 
     908           0 : void _SdrItemBrowserControl::SetAttributes(const SfxItemSet* pSet, const SfxItemSet* p2ndSet)
     909             : {
     910           0 :     SetMode(MYBROWSEMODE & ~BROWSER_KEEPHIGHLIGHT);
     911           0 :     if (pSet!=NULL) {
     912           0 :         sal_uInt16 nEntryNum=0;
     913           0 :         SfxWhichIter aIter(*pSet);
     914           0 :         const SfxItemPool* pPool=pSet->GetPool();
     915           0 :         sal_uInt16 nWhich0=0;
     916           0 :         sal_uInt16 nWhich=aIter.FirstWhich();
     917           0 :         while (nWhich!=0) {
     918             :             // Now sort this a little bit differently.
     919             :             // Only works as long as there are no InvalidItems, i. e. no gaps
     920             :             // at this position in the Set.
     921           0 :             if (!bDontSortItems) nWhich=ImpSortWhich(nWhich);
     922           0 :             SfxItemState eState=pSet->GetItemState(nWhich);
     923           0 :             if (p2ndSet!=NULL) {
     924           0 :                 SfxItemState e2ndState=p2ndSet->GetItemState(nWhich);
     925           0 :                 if (eState==SfxItemState::DEFAULT) eState=SfxItemState::DISABLED;
     926           0 :                 else if (e2ndState==SfxItemState::DEFAULT) eState=SfxItemState::DEFAULT;
     927             :             }
     928           0 :             if (eState!=SfxItemState::DISABLED) {
     929           0 :                 const SfxPoolItem& rItem=pSet->Get(nWhich);
     930           0 :                 sal_uInt16 nIndent=0;
     931           0 :                 if (!HAS_BASE(SfxVoidItem,&rItem) && !HAS_BASE(SfxSetItem,&rItem) && (!IsItemIneffective(nWhich,pSet,nIndent) || bDontHideIneffectiveItems)) {
     932           0 :                     OUString aCommentStr;
     933             : 
     934           0 :                     INSERTCOMMENT(XATTR_LINE_FIRST,XATTR_LINE_LAST,OUString("L I N E"));
     935           0 :                     INSERTCOMMENT(XATTR_FILL_FIRST,XATTR_FILL_LAST,OUString("F I L L"));
     936           0 :                     INSERTCOMMENT(XATTR_TEXT_FIRST,XATTR_TEXT_LAST,OUString("F O N T W O R K"));
     937           0 :                     INSERTCOMMENT(SDRATTR_SHADOW_FIRST,SDRATTR_SHADOW_LAST,OUString("S H A D O W"));
     938           0 :                     INSERTCOMMENT(SDRATTR_CAPTION_FIRST,SDRATTR_CAPTION_LAST,OUString("C A P T I O N"));
     939           0 :                     INSERTCOMMENT(SDRATTR_MISC_FIRST,SDRATTR_MISC_LAST,OUString("M I S C E L L A N E O U S"));
     940           0 :                     INSERTCOMMENT(SDRATTR_EDGE_FIRST,SDRATTR_EDGE_LAST,OUString("C O N N E C T O R"));
     941           0 :                     INSERTCOMMENT(SDRATTR_MEASURE_FIRST,SDRATTR_MEASURE_LAST,OUString("D I M E N S I O N"));
     942           0 :                     INSERTCOMMENT(SDRATTR_CIRC_FIRST,SDRATTR_CIRC_LAST,OUString("C I R C U L A R"));
     943           0 :                     INSERTCOMMENT(SDRATTR_NOTPERSIST_FIRST,SDRATTR_NOTPERSIST_LAST,OUString("N O T P E R S I S T"));
     944           0 :                     INSERTCOMMENT(SDRATTR_MOVEX,SDRATTR_VERTSHEARONE,OUString("Transformation of all object individually"));
     945           0 :                     INSERTCOMMENT(SDRATTR_RESIZEXALL,SDRATTR_VERTSHEARALL,OUString("Transformation of all objects together"));
     946           0 :                     INSERTCOMMENT(SDRATTR_TRANSFORMREF1X,SDRATTR_TRANSFORMREF2Y,OUString("V I E W R E F E R E N C E P O I N T S"));
     947           0 :                     INSERTCOMMENT(SDRATTR_GRAF_FIRST,SDRATTR_GRAF_LAST,OUString("G R A P H I C"));
     948           0 :                     INSERTCOMMENT(EE_ITEMS_START,EE_ITEMS_END,OUString("E D I T  E N G I N E"));
     949           0 :                     INSERTCOMMENT(EE_ITEMS_END+1,EE_ITEMS_END+1,OUString("... by Joe Merten, JME Engineering Berlin ..."));
     950             : 
     951           0 :                     if (!aCommentStr.isEmpty())
     952             :                     {
     953           0 :                         ImpItemListRow aEntry;
     954           0 :                         aEntry.bComment = true;
     955           0 :                         aEntry.aName=aCommentStr;
     956           0 :                         ImpSetEntry(aEntry,nEntryNum);
     957           0 :                         nEntryNum++;
     958             :                     }
     959           0 :                     nWhich0=nWhich;
     960           0 :                     ImpItemListRow aEntry;
     961           0 :                     SdrItemPool::TakeItemName(nWhich, aEntry.aName);
     962           0 :                     nIndent*=2;
     963             : 
     964           0 :                     while(nIndent > 0)
     965             :                     {
     966           0 :                         aEntry.aName = " " + aEntry.aName;
     967           0 :                         nIndent--;
     968             :                     }
     969             : 
     970           0 :                     aEntry.eState=eState;
     971           0 :                     aEntry.nWhichId=nWhich;
     972           0 :                     if (!IsInvalidItem(&rItem)) {
     973           0 :                         aEntry.pType=rItem.Type();
     974           0 :                         aEntry.nMax=0x7FFFFFFF;
     975           0 :                         aEntry.nMin=-aEntry.nMax;
     976           0 :                         aEntry.nVal=-4711;
     977           0 :                         if      (HAS_BASE(SfxByteItem     ,&rItem)) aEntry.eItemType=ITEM_BYTE;
     978           0 :                         else if (HAS_BASE(SfxInt16Item    ,&rItem)) aEntry.eItemType=ITEM_INT16;
     979           0 :                         else if (HAS_BASE(SfxUInt16Item   ,&rItem)) aEntry.eItemType=ITEM_UINT16;
     980           0 :                         else if (HAS_BASE(SfxInt32Item    ,&rItem)) aEntry.eItemType=ITEM_INT32;
     981           0 :                         else if (HAS_BASE(SfxUInt32Item   ,&rItem)) aEntry.eItemType=ITEM_UINT32;
     982           0 :                         else if (HAS_BASE(SfxEnumItemInterface,&rItem)) aEntry.eItemType=ITEM_ENUM;
     983           0 :                         else if (HAS_BASE(SfxBoolItem     ,&rItem)) aEntry.eItemType=ITEM_BOOL;
     984           0 :                         else if (HAS_BASE(SfxFlagItem     ,&rItem)) aEntry.eItemType=ITEM_FLAG;
     985           0 :                         else if (HAS_BASE(XColorItem      ,&rItem)) aEntry.eItemType=ITEM_XCOLOR;
     986           0 :                         else if (HAS_BASE(SfxStringItem   ,&rItem)) aEntry.eItemType=ITEM_STRING;
     987           0 :                         else if (HAS_BASE(SfxPointItem    ,&rItem)) aEntry.eItemType=ITEM_POINT;
     988           0 :                         else if (HAS_BASE(SfxRectangleItem,&rItem)) aEntry.eItemType=ITEM_RECT;
     989           0 :                         else if (HAS_BASE(SfxRangeItem    ,&rItem)) aEntry.eItemType=ITEM_RANGE;
     990           0 :                         else if (HAS_BASE(SdrFractionItem ,&rItem)) aEntry.eItemType=ITEM_FRACTION;
     991           0 :                         else if (HAS_BASE(SvxColorItem    ,&rItem)) aEntry.eItemType=ITEM_COLOR;
     992           0 :                         else if (HAS_BASE(SvxFontItem     ,&rItem)) aEntry.eItemType=ITEM_FONT;
     993           0 :                         else if (HAS_BASE(SvxFontHeightItem,&rItem))aEntry.eItemType=ITEM_FONTHEIGHT;
     994           0 :                         else if (HAS_BASE(SvxCharScaleWidthItem,&rItem)) aEntry.eItemType=ITEM_FONTWIDTH;
     995           0 :                         else if (HAS_BASE(SvxFieldItem    ,&rItem)) aEntry.eItemType=ITEM_FIELD;
     996           0 :                         switch (aEntry.eItemType) {
     997           0 :                             case ITEM_BYTE      : aEntry.bIsNum = true;  aEntry.nVal=static_cast<const SfxByteItem  &>(rItem).GetValue(); aEntry.nMin=0;      aEntry.nMax=255;   break;
     998           0 :                             case ITEM_INT16     : aEntry.bIsNum = true;  aEntry.nVal=static_cast<const SfxInt16Item &>(rItem).GetValue(); aEntry.nMin=-32767; aEntry.nMax=32767; break;
     999           0 :                             case ITEM_UINT16    : aEntry.bIsNum = true;  aEntry.nVal=static_cast<const SfxUInt16Item&>(rItem).GetValue(); aEntry.nMin=0;      aEntry.nMax=65535; break;
    1000           0 :                             case ITEM_INT32     : aEntry.bIsNum = true;  aEntry.nVal=static_cast<const SfxInt32Item &>(rItem).GetValue();                                        break;
    1001           0 :                             case ITEM_UINT32    : aEntry.bIsNum = true;  aEntry.nVal=static_cast<const SfxUInt32Item&>(rItem).GetValue(); aEntry.nMin=0; /*aEntry.nMax=0xFF...*/;break;
    1002           0 :                             case ITEM_ENUM      : aEntry.bCanNum = true; aEntry.nVal=static_cast<const SfxEnumItemInterface&>(rItem).GetEnumValue(); aEntry.nMin=0; aEntry.nMax=static_cast<const SfxEnumItemInterface&>(rItem).GetValueCount()-1; break;
    1003           0 :                             case ITEM_BOOL      : aEntry.bCanNum = true; aEntry.nVal=sal_Int32(static_cast<const SfxBoolItem  &>(rItem).GetValue()); aEntry.nMin=0; aEntry.nMax=1;          break;
    1004           0 :                             case ITEM_FLAG      : aEntry.bCanNum = true; aEntry.nVal=static_cast<const SfxFlagItem  &>(rItem).GetValue(); aEntry.nMin=0; aEntry.nMax=0xFFFF;     break;
    1005           0 :                             case ITEM_FONTHEIGHT: aEntry.bCanNum = true; aEntry.nVal=static_cast<const SvxFontHeightItem&>(rItem).GetHeight(); aEntry.nMin=0;                    break;
    1006           0 :                             case ITEM_FONTWIDTH : aEntry.bCanNum = true; aEntry.nVal=static_cast<const SvxCharScaleWidthItem&>(rItem).GetValue();    aEntry.nMin=0; aEntry.nMax=0xFFFF;break;
    1007           0 :                             default: break;
    1008             :                         } // switch
    1009           0 :                         if (aEntry.bIsNum) aEntry.bCanNum = true;
    1010             : 
    1011             :                         rItem.GetPresentation(SFX_ITEM_PRESENTATION_NAMELESS,
    1012           0 :                                               pPool->GetMetric(nWhich),
    1013           0 :                                               SFX_MAPUNIT_MM, aEntry.aValue);
    1014           0 :                         if (aEntry.bCanNum)
    1015             :                         {
    1016           0 :                             aEntry.aValue = OUString::number(aEntry.nVal) + ": " + aEntry.aValue;
    1017             :                         }
    1018             :                     }
    1019             :                     else
    1020             :                     {
    1021           0 :                         aEntry.aValue = "InvalidItem";
    1022             :                     }
    1023           0 :                     ImpSetEntry(aEntry,nEntryNum);
    1024           0 :                     nEntryNum++;
    1025             :                 }
    1026             :             }
    1027           0 :             nWhich=aIter.NextWhich();
    1028             :         } // while
    1029             : 
    1030           0 :         if (aList.size()>nEntryNum) { // maybe still too many entries
    1031           0 :             size_t const nTooMuch = aList.size() - nEntryNum;
    1032           0 :             for (size_t n = nEntryNum; n < aList.size(); ++n) {
    1033           0 :                 delete aList[n];
    1034             :             }
    1035           0 :             aList.erase(aList.begin() + nEntryNum, aList.end());
    1036           0 :             RowRemoved(nEntryNum,nTooMuch);
    1037           0 :         }
    1038             :     } else {
    1039           0 :         Clear(); // if pSet==NULL
    1040             :     }
    1041           0 :     ImpRestoreWhich();
    1042           0 :     SetMode(MYBROWSEMODE);
    1043           0 : }
    1044             : 
    1045             : // - _SdrItemBrowserWindow -
    1046             : 
    1047           0 : _SdrItemBrowserWindow::_SdrItemBrowserWindow(vcl::Window* pParent, WinBits nBits):
    1048             :     FloatingWindow(pParent,nBits),
    1049           0 :     aBrowse(this)
    1050             : {
    1051           0 :     SetOutputSizePixel(aBrowse.GetSizePixel());
    1052           0 :     SetText(OUString("Joe's ItemBrowser"));
    1053           0 :     aBrowse.Show();
    1054           0 : }
    1055             : 
    1056           0 : _SdrItemBrowserWindow::~_SdrItemBrowserWindow()
    1057             : {
    1058           0 : }
    1059             : 
    1060           0 : void _SdrItemBrowserWindow::Resize()
    1061             : {
    1062           0 :     aBrowse.SetSizePixel(GetOutputSizePixel());
    1063           0 : }
    1064             : 
    1065           0 : void _SdrItemBrowserWindow::GetFocus()
    1066             : {
    1067           0 :     aBrowse.GrabFocus();
    1068           0 : }
    1069             : 
    1070             : // - SdrItemBrowser -
    1071             : 
    1072           0 : SdrItemBrowser::SdrItemBrowser(SdrView& rView):
    1073             :     _SdrItemBrowserWindow(ImpGetViewWin(rView)),
    1074             :     pView(&rView),
    1075           0 :     bDirty(false)
    1076             : {
    1077           0 :     aIdleTimer.SetTimeoutHdl(LINK(this,SdrItemBrowser,IdleHdl));
    1078           0 :     GetBrowserControl().SetEntryChangedHdl(LINK(this,SdrItemBrowser,ChangedHdl));
    1079           0 :     GetBrowserControl().SetSetDirtyHdl(LINK(this,SdrItemBrowser,SetDirtyHdl));
    1080           0 :     SetDirty();
    1081           0 : }
    1082             : 
    1083           0 : vcl::Window* SdrItemBrowser::ImpGetViewWin(SdrView& rView)
    1084             : {
    1085           0 :     const sal_uInt32 nWinCount(rView.PaintWindowCount());
    1086             : 
    1087           0 :     for(sal_uInt32 a(0L); a < nWinCount; a++)
    1088             :     {
    1089           0 :         SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
    1090             : 
    1091           0 :         if(OUTDEV_WINDOW == pCandidate->GetOutputDevice().GetOutDevType())
    1092             :         {
    1093           0 :             return static_cast<vcl::Window*>(&pCandidate->GetOutputDevice());
    1094             :         }
    1095             :     }
    1096             : 
    1097           0 :     return 0L;
    1098             : }
    1099             : 
    1100           0 : void SdrItemBrowser::ForceParent()
    1101             : {
    1102           0 :     vcl::Window* pWin=ImpGetViewWin(*pView);
    1103           0 :     if (pWin!=NULL) SetParent(pWin);
    1104           0 : }
    1105             : 
    1106           0 : void SdrItemBrowser::SetDirty()
    1107             : {
    1108           0 :     if (!bDirty) {
    1109           0 :         bDirty = true;
    1110           0 :         aIdleTimer.SetTimeout(1);
    1111           0 :         aIdleTimer.Start();
    1112             :     }
    1113           0 : }
    1114             : 
    1115           0 : void SdrItemBrowser::Undirty()
    1116             : {
    1117           0 :     aIdleTimer.Stop();
    1118           0 :     bDirty = false;
    1119             : 
    1120           0 :     SfxItemSet aSet(pView->GetModel()->GetItemPool());
    1121           0 :     pView->GetAttributes(aSet);
    1122             : 
    1123           0 :     if(pView->AreObjectsMarked())
    1124             :     {
    1125           0 :         SfxItemSet a2ndSet(pView->GetModel()->GetItemPool());
    1126           0 :         pView->GetAttributes(a2ndSet, true);
    1127             : 
    1128           0 :         SetAttributes(&aSet,&a2ndSet);
    1129             :     }
    1130             :     else
    1131             :     {
    1132           0 :         SetAttributes(&aSet);
    1133           0 :     }
    1134           0 : }
    1135             : 
    1136           0 : IMPL_LINK_NOARG(SdrItemBrowser, IdleHdl)
    1137             : {
    1138           0 :     Undirty();
    1139           0 :     return 0;
    1140             : }
    1141             : 
    1142           0 : IMPL_LINK(SdrItemBrowser,ChangedHdl,_SdrItemBrowserControl*,pBrowse)
    1143             : {
    1144           0 :     const ImpItemListRow* pEntry=pBrowse->GetAktChangeEntry();
    1145           0 :     if (pEntry!=NULL)
    1146             :     {
    1147           0 :         SfxItemSet aSet(pView->GetModel()->GetItemPool());
    1148           0 :         pView->GetAttributes(aSet);
    1149             : 
    1150           0 :         SfxItemSet aNewSet(*aSet.GetPool(),pEntry->nWhichId,pEntry->nWhichId);
    1151           0 :         OUString aNewText(pBrowse->GetNewEntryValue());
    1152           0 :         bool bDel( aNewText == "del"
    1153           0 :             || aNewText == "Del"
    1154           0 :             || aNewText == "DEL"
    1155           0 :             || aNewText == "default"
    1156           0 :             || aNewText == "Default"
    1157           0 :             || aNewText == "DEFAULT" );
    1158             : 
    1159           0 :         if (!bDel) {
    1160           0 :             SfxPoolItem* pNewItem=aSet.Get(pEntry->nWhichId).Clone();
    1161           0 :             long nLongVal = aNewText.toInt32();
    1162           0 :             if (pEntry->bCanNum) {
    1163           0 :                 if (nLongVal>pEntry->nMax) nLongVal=pEntry->nMax;
    1164           0 :                 if (nLongVal<pEntry->nMin) nLongVal=pEntry->nMin;
    1165             :             }
    1166           0 :             bool bPairX = true;
    1167           0 :             bool bPairY = false;
    1168           0 :             sal_uInt16 nSepLen=1;
    1169           0 :             long nLongX = aNewText.toInt32();
    1170           0 :             long nLongY=0;
    1171           0 :             sal_Int32 nPos = aNewText.indexOf('/');
    1172           0 :             if (nPos==-1) nPos=aNewText.indexOf(':');
    1173           0 :             if (nPos==-1) nPos=aNewText.indexOf(' ');
    1174           0 :             if (nPos==-1) { nPos=aNewText.indexOf(".."); if (nPos!=-1) nSepLen=2; }
    1175           0 :             if (nPos!=01)
    1176             :             {
    1177           0 :                 bPairX=nPos>0;
    1178           0 :                 OUString s(aNewText.copy(nPos+nSepLen));
    1179           0 :                 bPairY = !aNewText.isEmpty();
    1180           0 :                 nLongY = s.toInt32();
    1181             :             }
    1182           0 :             switch (pEntry->eItemType) {
    1183           0 :                 case ITEM_BYTE  : static_cast<SfxByteItem  *>(pNewItem)->SetValue((sal_uInt8  )nLongVal); break;
    1184           0 :                 case ITEM_INT16 : static_cast<SfxInt16Item *>(pNewItem)->SetValue((sal_Int16 )nLongVal); break;
    1185           0 :                 case ITEM_UINT16: static_cast<SfxUInt16Item*>(pNewItem)->SetValue((sal_uInt16)nLongVal); break;
    1186             :                 case ITEM_INT32: {
    1187           0 :                     if(HAS_BASE(SdrAngleItem, pNewItem))
    1188             :                     {
    1189           0 :                         aNewText = aNewText.replace(',', '.');
    1190           0 :                         double nVal = aNewText.toFloat();
    1191           0 :                         nLongVal = (long)(nVal * 100 + 0.5);
    1192             :                     }
    1193           0 :                     static_cast<SfxInt32Item *>(pNewItem)->SetValue((sal_Int32)nLongVal);
    1194           0 :                 } break;
    1195           0 :                 case ITEM_UINT32: static_cast<SfxUInt32Item*>(pNewItem)->SetValue(aNewText.toInt32()); break;
    1196           0 :                 case ITEM_ENUM  : static_cast<SfxEnumItemInterface*>(pNewItem)->SetEnumValue((sal_uInt16)nLongVal); break;
    1197             :                 case ITEM_BOOL: {
    1198           0 :                     aNewText = aNewText.toAsciiUpperCase();
    1199           0 :                     if (aNewText == "TRUE") nLongVal=1;
    1200           0 :                     if (aNewText == "JA") nLongVal=1;
    1201           0 :                     if (aNewText == "AN") nLongVal=1;
    1202           0 :                     if (aNewText == "EIN") nLongVal=1;
    1203           0 :                     if (aNewText == "ON") nLongVal=1;
    1204           0 :                     if (aNewText == "YES") nLongVal=1;
    1205           0 :                     static_cast<SfxBoolItem*>(pNewItem)->SetValue(nLongVal == 1);
    1206           0 :                 } break;
    1207           0 :                 case ITEM_FLAG  : static_cast<SfxFlagItem  *>(pNewItem)->SetValue((sal_uInt16)nLongVal); break;
    1208           0 :                 case ITEM_STRING: static_cast<SfxStringItem*>(pNewItem)->SetValue(aNewText); break;
    1209           0 :                 case ITEM_POINT : static_cast<SfxPointItem*>(pNewItem)->SetValue(Point(nLongX,nLongY)); break;
    1210           0 :                 case ITEM_RECT  : break;
    1211             :                 case ITEM_RANGE : {
    1212           0 :                     static_cast<SfxRangeItem*>(pNewItem)->From()=(sal_uInt16)nLongX;
    1213           0 :                     static_cast<SfxRangeItem*>(pNewItem)->From()=(sal_uInt16)nLongY;
    1214           0 :                 } break;
    1215             :                 case ITEM_LRANGE : {
    1216           0 :                 } break;
    1217             :                 case ITEM_FRACTION: {
    1218           0 :                     if (!bPairX) nLongX=1;
    1219           0 :                     if (!bPairY) nLongY=1;
    1220           0 :                     static_cast<SdrFractionItem*>(pNewItem)->SetValue(Fraction(nLongX,nLongY));
    1221           0 :                 } break;
    1222           0 :                 case ITEM_XCOLOR: break;
    1223           0 :                 case ITEM_COLOR: break;
    1224             :                 case ITEM_FONT: {
    1225           0 :                     static_cast<SvxFontItem*>(pNewItem)->SetFamily( FAMILY_DONTKNOW );
    1226           0 :                     static_cast<SvxFontItem*>(pNewItem)->SetFamilyName(aNewText);
    1227           0 :                     static_cast<SvxFontItem*>(pNewItem)->SetStyleName(OUString());
    1228           0 :                 } break;
    1229             :                 case ITEM_FONTHEIGHT: {
    1230           0 :                     sal_uIntPtr nHgt=0;
    1231           0 :                     sal_uInt16 nProp=100;
    1232           0 :                     if (aNewText.indexOf('%') != -1) {
    1233           0 :                         nProp=(sal_uInt16)nLongVal;
    1234             :                     } else {
    1235           0 :                         nHgt=nLongVal;
    1236             :                     }
    1237           0 :                     static_cast<SvxFontHeightItem*>(pNewItem)->SetHeight(nHgt,nProp);
    1238           0 :                 } break;
    1239             :                 case ITEM_FONTWIDTH: {
    1240           0 :                     sal_uInt16 nProp=100;
    1241           0 :                     if (aNewText.indexOf('%') != -1) {
    1242           0 :                         nProp=(sal_uInt16)nLongVal;
    1243             :                     }
    1244           0 :                     static_cast<SvxCharScaleWidthItem*>(pNewItem)->SetValue(nProp);
    1245           0 :                 } break;
    1246           0 :                 case ITEM_FIELD: break;
    1247           0 :                 default: break;
    1248             :             } // switch
    1249           0 :             aNewSet.Put(*pNewItem);
    1250           0 :             delete pNewItem;
    1251             :         }
    1252           0 :         pView->SetAttributes(aNewSet,bDel);
    1253             :     }
    1254           0 :     return 0;
    1255             : }
    1256             : 
    1257           0 : IMPL_LINK_NOARG(SdrItemBrowser, SetDirtyHdl)
    1258             : {
    1259           0 :     SetDirty();
    1260           0 :     return 0;
    1261         651 : }
    1262             : 
    1263             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10