1*5900e8ecSAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 3*5900e8ecSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4*5900e8ecSAndrew Rist * or more contributor license agreements. See the NOTICE file 5*5900e8ecSAndrew Rist * distributed with this work for additional information 6*5900e8ecSAndrew Rist * regarding copyright ownership. The ASF licenses this file 7*5900e8ecSAndrew Rist * to you under the Apache License, Version 2.0 (the 8*5900e8ecSAndrew Rist * "License"); you may not use this file except in compliance 9*5900e8ecSAndrew Rist * with the License. You may obtain a copy of the License at 10*5900e8ecSAndrew Rist * 11*5900e8ecSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12*5900e8ecSAndrew Rist * 13*5900e8ecSAndrew Rist * Unless required by applicable law or agreed to in writing, 14*5900e8ecSAndrew Rist * software distributed under the License is distributed on an 15*5900e8ecSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*5900e8ecSAndrew Rist * KIND, either express or implied. See the License for the 17*5900e8ecSAndrew Rist * specific language governing permissions and limitations 18*5900e8ecSAndrew Rist * under the License. 19*5900e8ecSAndrew Rist * 20*5900e8ecSAndrew Rist *************************************************************/ 21*5900e8ecSAndrew Rist 22*5900e8ecSAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 25cdf0e10cSrcweir #include "precompiled_svtools.hxx" 26cdf0e10cSrcweir 27cdf0e10cSrcweir #include <string.h> 28cdf0e10cSrcweir #include <tools/debug.hxx> 29cdf0e10cSrcweir #include <vcl/svapp.hxx> 30cdf0e10cSrcweir #include <tools/poly.hxx> 31cdf0e10cSrcweir #include <vcl/i18nhelp.hxx> 32cdf0e10cSrcweir 33cdf0e10cSrcweir #define _SV_RULER_CXX 34cdf0e10cSrcweir #include <svtools/ruler.hxx> 35cdf0e10cSrcweir 36cdf0e10cSrcweir // ======================================================================= 37cdf0e10cSrcweir 38cdf0e10cSrcweir #define RULER_OFF 3 39cdf0e10cSrcweir #define RULER_TEXTOFF 2 40cdf0e10cSrcweir #define RULER_RESIZE_OFF 4 41cdf0e10cSrcweir #define RULER_LINE_WIDTH 7 42cdf0e10cSrcweir #define RULER_MIN_SIZE 3 43cdf0e10cSrcweir 44cdf0e10cSrcweir #define RULER_TICK1_WIDTH 1 45cdf0e10cSrcweir #define RULER_TICK2_WIDTH 3 46cdf0e10cSrcweir #define RULER_TICK3_WIDTH 5 47cdf0e10cSrcweir 48cdf0e10cSrcweir #define RULER_VAR_SIZE 8 49cdf0e10cSrcweir 50cdf0e10cSrcweir #define RULER_TAB_HEIGHT2 2 51cdf0e10cSrcweir #define RULER_TAB_WIDTH2 2 52cdf0e10cSrcweir #define RULER_TAB_CWIDTH 8 53cdf0e10cSrcweir #define RULER_TAB_CWIDTH2 4 54cdf0e10cSrcweir #define RULER_TAB_CWIDTH3 4 55cdf0e10cSrcweir #define RULER_TAB_CWIDTH4 2 56cdf0e10cSrcweir #define RULER_TAB_DHEIGHT 4 57cdf0e10cSrcweir #define RULER_TAB_DHEIGHT2 1 58cdf0e10cSrcweir #define RULER_TAB_DWIDTH 5 59cdf0e10cSrcweir #define RULER_TAB_DWIDTH2 3 60cdf0e10cSrcweir #define RULER_TAB_DWIDTH3 3 61cdf0e10cSrcweir #define RULER_TAB_DWIDTH4 1 62cdf0e10cSrcweir 63cdf0e10cSrcweir #define RULER_UPDATE_LINES 0x01 64cdf0e10cSrcweir #define RULER_UPDATE_DRAW 0x02 65cdf0e10cSrcweir 66cdf0e10cSrcweir #define RULER_CLIP 150 67cdf0e10cSrcweir 68cdf0e10cSrcweir // ======================================================================= 69cdf0e10cSrcweir 70cdf0e10cSrcweir #define RULER_UNIT_MM 0 71cdf0e10cSrcweir #define RULER_UNIT_CM 1 72cdf0e10cSrcweir #define RULER_UNIT_M 2 73cdf0e10cSrcweir #define RULER_UNIT_KM 3 74cdf0e10cSrcweir #define RULER_UNIT_INCH 4 75cdf0e10cSrcweir #define RULER_UNIT_FOOT 5 76cdf0e10cSrcweir #define RULER_UNIT_MILE 6 77cdf0e10cSrcweir #define RULER_UNIT_POINT 7 78cdf0e10cSrcweir #define RULER_UNIT_PICA 8 79cdf0e10cSrcweir #define RULER_UNIT_COUNT 9 80cdf0e10cSrcweir 81cdf0e10cSrcweir // ----------------- 82cdf0e10cSrcweir // - ImplRulerData - 83cdf0e10cSrcweir // ----------------- 84cdf0e10cSrcweir class ImplRulerData 85cdf0e10cSrcweir { 86cdf0e10cSrcweir friend class Ruler; 87cdf0e10cSrcweir 88cdf0e10cSrcweir private: 89cdf0e10cSrcweir RulerLine* pLines; 90cdf0e10cSrcweir RulerArrow* pArrows; 91cdf0e10cSrcweir RulerBorder* pBorders; 92cdf0e10cSrcweir RulerIndent* pIndents; 93cdf0e10cSrcweir RulerTab* pTabs; 94cdf0e10cSrcweir long nNullVirOff; 95cdf0e10cSrcweir long nRulVirOff; 96cdf0e10cSrcweir long nRulWidth; 97cdf0e10cSrcweir long nPageOff; 98cdf0e10cSrcweir long nPageWidth; 99cdf0e10cSrcweir long nNullOff; 100cdf0e10cSrcweir long nMargin1; 101cdf0e10cSrcweir long nMargin2; 102cdf0e10cSrcweir sal_uInt16 nLines; 103cdf0e10cSrcweir sal_uInt16 nArrows; 104cdf0e10cSrcweir sal_uInt16 nBorders; 105cdf0e10cSrcweir sal_uInt16 nIndents; 106cdf0e10cSrcweir sal_uInt16 nTabs; 107cdf0e10cSrcweir sal_uInt16 nMargin1Style; 108cdf0e10cSrcweir sal_uInt16 nMargin2Style; 109cdf0e10cSrcweir sal_Bool bAutoPageWidth; 110cdf0e10cSrcweir sal_Bool bTextRTL; 111cdf0e10cSrcweir 112cdf0e10cSrcweir #ifdef _SV_RULER_CXX 113cdf0e10cSrcweir public: 114cdf0e10cSrcweir ImplRulerData(); 115cdf0e10cSrcweir ~ImplRulerData(); 116cdf0e10cSrcweir ImplRulerData& operator=( const ImplRulerData& rData ); 117cdf0e10cSrcweir #endif 118cdf0e10cSrcweir }; 119cdf0e10cSrcweir 120cdf0e10cSrcweir 121cdf0e10cSrcweir struct ImplRulerUnitData 122cdf0e10cSrcweir { 123cdf0e10cSrcweir MapUnit eMapUnit; // MAP_UNIT zum Umrechnen 124cdf0e10cSrcweir long nTickUnit; // Teiler fuer Einheit 125cdf0e10cSrcweir long nTick1; // Schrittweite 126cdf0e10cSrcweir long nTick2; // Tick fuer halbe Werte 127cdf0e10cSrcweir long nTick3; // Tick fuer Zahlenausgabe 128cdf0e10cSrcweir long n100THMM; // Teiler fuer Einheit 129cdf0e10cSrcweir sal_uInt16 nUnitDigits; // Anzahl Nachkommastellen 130cdf0e10cSrcweir sal_Char aUnitStr[8]; // Einheiten-String 131cdf0e10cSrcweir }; 132cdf0e10cSrcweir 133cdf0e10cSrcweir static ImplRulerUnitData aImplRulerUnitTab[RULER_UNIT_COUNT] = 134cdf0e10cSrcweir { 135cdf0e10cSrcweir { MAP_100TH_MM, 100, 25, 50, 100, 100, 3, " mm" }, // MM 136cdf0e10cSrcweir { MAP_100TH_MM, 1000, 250, 500, 1000, 1000, 3, " cm" }, // CM 137cdf0e10cSrcweir { MAP_MM, 1000, 250, 500, 1000, 10000, 4, " m" }, // M 138cdf0e10cSrcweir { MAP_CM, 100000, 25000, 50000, 100000, 100000, 6, " km" }, // KM 139cdf0e10cSrcweir { MAP_100TH_INCH, 100, 10, 50, 100, 2540, 3, "\"" }, // INCH 140cdf0e10cSrcweir { MAP_100TH_INCH, 1200, 120, 600, 1200, 30480, 3, "'" }, // FOOT 141cdf0e10cSrcweir { MAP_10TH_INCH, 633600, 63360, 316800, 633600, 1609344, 4, " miles" }, // MILE 142cdf0e10cSrcweir { MAP_POINT, 1, 12, 12, 36, 353, 2, " pt" }, // POINT 143cdf0e10cSrcweir { MAP_100TH_MM, 423, 423, 423, 846, 423, 3, " pi" } // PICA 144cdf0e10cSrcweir }; 145cdf0e10cSrcweir 146cdf0e10cSrcweir // ======================================================================= 147cdf0e10cSrcweir 148cdf0e10cSrcweir struct ImplRulerHitTest 149cdf0e10cSrcweir { 150cdf0e10cSrcweir long nPos; 151cdf0e10cSrcweir RulerType eType; 152cdf0e10cSrcweir sal_uInt16 nAryPos; 153cdf0e10cSrcweir sal_uInt16 mnDragSize; 154cdf0e10cSrcweir sal_Bool bSize; 155cdf0e10cSrcweir sal_Bool bSizeBar; 156cdf0e10cSrcweir sal_Bool bExpandTest; 157cdf0e10cSrcweir ImplRulerHitTest() : 158cdf0e10cSrcweir bExpandTest( sal_False ) {} 159cdf0e10cSrcweir }; 160cdf0e10cSrcweir 161cdf0e10cSrcweir // ======================================================================= 162cdf0e10cSrcweir 163cdf0e10cSrcweir ImplRulerData::ImplRulerData() 164cdf0e10cSrcweir { 165cdf0e10cSrcweir memset( this, 0, sizeof( ImplRulerData ) ); 166cdf0e10cSrcweir 167cdf0e10cSrcweir // PageBreite == EditWinBreite 168cdf0e10cSrcweir bAutoPageWidth = sal_True; 169cdf0e10cSrcweir } 170cdf0e10cSrcweir 171cdf0e10cSrcweir // ----------------------------------------------------------------------- 172cdf0e10cSrcweir 173cdf0e10cSrcweir ImplRulerData::~ImplRulerData() 174cdf0e10cSrcweir { 175cdf0e10cSrcweir delete[] pLines; 176cdf0e10cSrcweir delete[] pArrows; 177cdf0e10cSrcweir delete[] pBorders; 178cdf0e10cSrcweir delete[] pIndents; 179cdf0e10cSrcweir delete[] pTabs; 180cdf0e10cSrcweir } 181cdf0e10cSrcweir 182cdf0e10cSrcweir // ----------------------------------------------------------------------- 183cdf0e10cSrcweir 184cdf0e10cSrcweir ImplRulerData& ImplRulerData::operator=( const ImplRulerData& rData ) 185cdf0e10cSrcweir { 186cdf0e10cSrcweir delete[] pLines; 187cdf0e10cSrcweir delete[] pArrows; 188cdf0e10cSrcweir delete[] pBorders; 189cdf0e10cSrcweir delete[] pIndents; 190cdf0e10cSrcweir delete[] pTabs; 191cdf0e10cSrcweir 192cdf0e10cSrcweir memcpy( this, &rData, sizeof( ImplRulerData ) ); 193cdf0e10cSrcweir 194cdf0e10cSrcweir if ( rData.pLines ) 195cdf0e10cSrcweir { 196cdf0e10cSrcweir pLines = new RulerLine[nLines]; 197cdf0e10cSrcweir memcpy( pLines, rData.pLines, nLines*sizeof( RulerLine ) ); 198cdf0e10cSrcweir } 199cdf0e10cSrcweir 200cdf0e10cSrcweir if ( rData.pArrows ) 201cdf0e10cSrcweir { 202cdf0e10cSrcweir pArrows = new RulerArrow[nArrows]; 203cdf0e10cSrcweir memcpy( pArrows, rData.pArrows, nArrows*sizeof( RulerArrow ) ); 204cdf0e10cSrcweir } 205cdf0e10cSrcweir 206cdf0e10cSrcweir if ( rData.pBorders ) 207cdf0e10cSrcweir { 208cdf0e10cSrcweir pBorders = new RulerBorder[nBorders]; 209cdf0e10cSrcweir memcpy( pBorders, rData.pBorders, nBorders*sizeof( RulerBorder ) ); 210cdf0e10cSrcweir } 211cdf0e10cSrcweir 212cdf0e10cSrcweir if ( rData.pIndents ) 213cdf0e10cSrcweir { 214cdf0e10cSrcweir pIndents = new RulerIndent[nIndents]; 215cdf0e10cSrcweir memcpy( pIndents, rData.pIndents, nIndents*sizeof( RulerIndent ) ); 216cdf0e10cSrcweir } 217cdf0e10cSrcweir 218cdf0e10cSrcweir if ( rData.pTabs ) 219cdf0e10cSrcweir { 220cdf0e10cSrcweir pTabs = new RulerTab[nTabs]; 221cdf0e10cSrcweir memcpy( pTabs, rData.pTabs, nTabs*sizeof( RulerTab ) ); 222cdf0e10cSrcweir } 223cdf0e10cSrcweir 224cdf0e10cSrcweir return *this; 225cdf0e10cSrcweir } 226cdf0e10cSrcweir 227cdf0e10cSrcweir // ======================================================================= 228cdf0e10cSrcweir 229cdf0e10cSrcweir void Ruler::ImplInit( WinBits nWinBits ) 230cdf0e10cSrcweir { 231cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 232cdf0e10cSrcweir 233cdf0e10cSrcweir // Default WinBits setzen 234cdf0e10cSrcweir if ( !(nWinBits & WB_VERT) ) 235cdf0e10cSrcweir { 236cdf0e10cSrcweir nWinBits |= WB_HORZ; 237cdf0e10cSrcweir 238cdf0e10cSrcweir // --- RTL --- no UI mirroring for horizontal rulers, because 239cdf0e10cSrcweir // the document is also not mirrored 240cdf0e10cSrcweir EnableRTL( sal_False ); 241cdf0e10cSrcweir } 242cdf0e10cSrcweir 243cdf0e10cSrcweir // Variablen initialisieren 244cdf0e10cSrcweir mnWinStyle = nWinBits; // Window-Style 245cdf0e10cSrcweir mnBorderOff = 0; // Border-Offset 246cdf0e10cSrcweir mnWinOff = 0; // EditWinOffset 247cdf0e10cSrcweir mnWinWidth = 0; // EditWinWidth 248cdf0e10cSrcweir mnWidth = 0; // Fensterbreite 249cdf0e10cSrcweir mnHeight = 0; // Fensterhoehe 250cdf0e10cSrcweir mnVirOff = 0; // Offset des VirtualDeice vom linke/oberen Rand 251cdf0e10cSrcweir mnVirWidth = 0; // Breite bzw. Hoehe vom VirtualDevice 252cdf0e10cSrcweir mnVirHeight = 0; // Hoehe bzw. Breite vom VirtualDevice 253cdf0e10cSrcweir mnDragPos = 0; // Drag-Position (NullPunkt) 254cdf0e10cSrcweir mnUpdateEvtId = 0; // Noch kein Update-Event verschickt 255cdf0e10cSrcweir mnDragAryPos = 0; // Drag-Array-Index 256cdf0e10cSrcweir mnDragSize = 0; // Wird beim Draggen die Groesse geaendert 257cdf0e10cSrcweir mnDragScroll = 0; // Soll beim Draggen gescrollt werden 258cdf0e10cSrcweir mnDragModifier = 0; // Modifier-Tasten beim Draggen 259cdf0e10cSrcweir mnExtraStyle = 0; // Style des Extra-Feldes 260cdf0e10cSrcweir mnExtraClicks = 0; // Click-Anzahl fuer Extra-Feld 261cdf0e10cSrcweir mnExtraModifier = 0; // Modifier-Tasten beim Click im Extrafeld 262cdf0e10cSrcweir mbCalc = sal_True; // Muessen Pagebreiten neu berechnet werden 263cdf0e10cSrcweir mbFormat = sal_True; // Muss neu ausgegeben werden 264cdf0e10cSrcweir mbDrag = sal_False; // Sind wir im Drag-Modus 265cdf0e10cSrcweir mbDragDelete = sal_False; // Wird Maus beim Draggen unten rausgezogen 266cdf0e10cSrcweir mbDragCanceled = sal_False; // Wurde Dragging abgebrochen 267cdf0e10cSrcweir mbAutoWinWidth = sal_True; // EditWinBreite == RulerBreite 268cdf0e10cSrcweir mbActive = sal_True; // Ist Lineal aktiv 269cdf0e10cSrcweir mnUpdateFlags = 0; // Was soll im Update-Handler upgedatet werden 270cdf0e10cSrcweir mpData = mpSaveData; // Wir zeigen auf die normalen Daten 271cdf0e10cSrcweir meExtraType = RULER_EXTRA_DONTKNOW; // Was im ExtraFeld dargestellt wird 272cdf0e10cSrcweir meDragType = RULER_TYPE_DONTKNOW; // Gibt an, was gedragt wird 273cdf0e10cSrcweir 274cdf0e10cSrcweir // Units initialisieren 275cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_CM; 276cdf0e10cSrcweir meUnit = FUNIT_CM; 277cdf0e10cSrcweir maZoom = Fraction( 1, 1 ); 278cdf0e10cSrcweir meSourceUnit = MAP_100TH_MM; 279cdf0e10cSrcweir 280cdf0e10cSrcweir // Border-Breiten berechnen 281cdf0e10cSrcweir if ( nWinBits & WB_BORDER ) 282cdf0e10cSrcweir { 283cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 284cdf0e10cSrcweir mnBorderWidth = 2; 285cdf0e10cSrcweir else 286cdf0e10cSrcweir mnBorderWidth = 1; 287cdf0e10cSrcweir } 288cdf0e10cSrcweir else 289cdf0e10cSrcweir mnBorderWidth = 0; 290cdf0e10cSrcweir 291cdf0e10cSrcweir // Einstellungen setzen 292cdf0e10cSrcweir ImplInitSettings( sal_True, sal_True, sal_True ); 293cdf0e10cSrcweir 294cdf0e10cSrcweir // Default-Groesse setzen 295cdf0e10cSrcweir long nDefHeight = GetTextHeight() + RULER_OFF*2 + RULER_TEXTOFF*2 + mnBorderWidth; 296cdf0e10cSrcweir Size aDefSize; 297cdf0e10cSrcweir if ( nWinBits & WB_HORZ ) 298cdf0e10cSrcweir aDefSize.Height() = nDefHeight; 299cdf0e10cSrcweir else 300cdf0e10cSrcweir aDefSize.Width() = nDefHeight; 301cdf0e10cSrcweir SetOutputSizePixel( aDefSize ); 302cdf0e10cSrcweir SetType(WINDOW_RULER); 303cdf0e10cSrcweir } 304cdf0e10cSrcweir 305cdf0e10cSrcweir // ----------------------------------------------------------------------- 306cdf0e10cSrcweir 307cdf0e10cSrcweir Ruler::Ruler( Window* pParent, WinBits nWinStyle ) : 308cdf0e10cSrcweir Window( pParent, nWinStyle & WB_3DLOOK ), 309cdf0e10cSrcweir maVirDev( *this ), 310cdf0e10cSrcweir maMapMode( MAP_100TH_MM ), 311cdf0e10cSrcweir mpSaveData(new ImplRulerData), 312cdf0e10cSrcweir mpData(0), 313cdf0e10cSrcweir mpDragData(new ImplRulerData) 314cdf0e10cSrcweir { 315cdf0e10cSrcweir ImplInit( nWinStyle ); 316cdf0e10cSrcweir } 317cdf0e10cSrcweir 318cdf0e10cSrcweir // ----------------------------------------------------------------------- 319cdf0e10cSrcweir 320cdf0e10cSrcweir Ruler::~Ruler() 321cdf0e10cSrcweir { 322cdf0e10cSrcweir if ( mnUpdateEvtId ) 323cdf0e10cSrcweir Application::RemoveUserEvent( mnUpdateEvtId ); 324cdf0e10cSrcweir delete mpSaveData; 325cdf0e10cSrcweir delete mpDragData; 326cdf0e10cSrcweir } 327cdf0e10cSrcweir 328cdf0e10cSrcweir // ----------------------------------------------------------------------- 329cdf0e10cSrcweir 330cdf0e10cSrcweir void Ruler::ImplVDrawLine( long nX1, long nY1, long nX2, long nY2 ) 331cdf0e10cSrcweir { 332cdf0e10cSrcweir if ( nX1 < -RULER_CLIP ) 333cdf0e10cSrcweir { 334cdf0e10cSrcweir nX1 = -RULER_CLIP; 335cdf0e10cSrcweir if ( nX2 < -RULER_CLIP ) 336cdf0e10cSrcweir return; 337cdf0e10cSrcweir } 338cdf0e10cSrcweir long nClip = mnVirWidth+RULER_CLIP; 339cdf0e10cSrcweir if ( nX2 > nClip ) 340cdf0e10cSrcweir { 341cdf0e10cSrcweir nX2 = nClip; 342cdf0e10cSrcweir if ( nX1 > nClip ) 343cdf0e10cSrcweir return; 344cdf0e10cSrcweir } 345cdf0e10cSrcweir 346cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 347cdf0e10cSrcweir maVirDev.DrawLine( Point( nX1, nY1 ), Point( nX2, nY2 ) ); 348cdf0e10cSrcweir else 349cdf0e10cSrcweir maVirDev.DrawLine( Point( nY1, nX1 ), Point( nY2, nX2 ) ); 350cdf0e10cSrcweir } 351cdf0e10cSrcweir 352cdf0e10cSrcweir // ----------------------------------------------------------------------- 353cdf0e10cSrcweir 354cdf0e10cSrcweir void Ruler::ImplVDrawRect( long nX1, long nY1, long nX2, long nY2 ) 355cdf0e10cSrcweir { 356cdf0e10cSrcweir if ( nX1 < -RULER_CLIP ) 357cdf0e10cSrcweir { 358cdf0e10cSrcweir nX1 = -RULER_CLIP; 359cdf0e10cSrcweir if ( nX2 < -RULER_CLIP ) 360cdf0e10cSrcweir return; 361cdf0e10cSrcweir } 362cdf0e10cSrcweir long nClip = mnVirWidth+RULER_CLIP; 363cdf0e10cSrcweir if ( nX2 > nClip ) 364cdf0e10cSrcweir { 365cdf0e10cSrcweir nX2 = nClip; 366cdf0e10cSrcweir if ( nX1 > nClip ) 367cdf0e10cSrcweir return; 368cdf0e10cSrcweir } 369cdf0e10cSrcweir 370cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 371cdf0e10cSrcweir maVirDev.DrawRect( Rectangle( nX1, nY1, nX2, nY2 ) ); 372cdf0e10cSrcweir else 373cdf0e10cSrcweir maVirDev.DrawRect( Rectangle( nY1, nX1, nY2, nX2 ) ); 374cdf0e10cSrcweir } 375cdf0e10cSrcweir 376cdf0e10cSrcweir // ----------------------------------------------------------------------- 377cdf0e10cSrcweir 378cdf0e10cSrcweir void Ruler::ImplVDrawText( long nX, long nY, const String& rText ) 379cdf0e10cSrcweir { 380cdf0e10cSrcweir if ( (nX > -RULER_CLIP) && (nX < mnVirWidth+RULER_CLIP) ) 381cdf0e10cSrcweir { 382cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 383cdf0e10cSrcweir maVirDev.DrawText( Point( nX, nY ), rText ); 384cdf0e10cSrcweir else 385cdf0e10cSrcweir maVirDev.DrawText( Point( nY, nX ), rText ); 386cdf0e10cSrcweir } 387cdf0e10cSrcweir } 388cdf0e10cSrcweir 389cdf0e10cSrcweir // ----------------------------------------------------------------------- 390cdf0e10cSrcweir 391cdf0e10cSrcweir void Ruler::ImplInvertLines( sal_Bool bErase ) 392cdf0e10cSrcweir { 393cdf0e10cSrcweir // Positionslinien 394cdf0e10cSrcweir if ( mpData->nLines && mbActive && !mbDrag && !mbFormat && 395cdf0e10cSrcweir !(mnUpdateFlags & RULER_UPDATE_LINES) ) 396cdf0e10cSrcweir { 397cdf0e10cSrcweir long n; 398cdf0e10cSrcweir long nNullWinOff = mpData->nNullVirOff+mnVirOff; 399cdf0e10cSrcweir long nRulX1 = mpData->nRulVirOff+mnVirOff; 400cdf0e10cSrcweir long nRulX2 = nRulX1+mpData->nRulWidth; 401cdf0e10cSrcweir long nY = (RULER_OFF*2)+mnVirHeight-1; 402cdf0e10cSrcweir 403cdf0e10cSrcweir // Rectangle berechnen 404cdf0e10cSrcweir Rectangle aRect; 405cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 406cdf0e10cSrcweir aRect.Bottom() = nY; 407cdf0e10cSrcweir else 408cdf0e10cSrcweir aRect.Right() = nY; 409cdf0e10cSrcweir 410cdf0e10cSrcweir // Linien ausgeben 411cdf0e10cSrcweir for ( sal_uInt16 i = 0; i < mpData->nLines; i++ ) 412cdf0e10cSrcweir { 413cdf0e10cSrcweir n = mpData->pLines[i].nPos+nNullWinOff; 414cdf0e10cSrcweir if ( (n >= nRulX1) && (n < nRulX2) ) 415cdf0e10cSrcweir { 416cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 417cdf0e10cSrcweir { 418cdf0e10cSrcweir aRect.Left() = n; 419cdf0e10cSrcweir aRect.Right() = n; 420cdf0e10cSrcweir } 421cdf0e10cSrcweir else 422cdf0e10cSrcweir { 423cdf0e10cSrcweir aRect.Top() = n; 424cdf0e10cSrcweir aRect.Bottom() = n; 425cdf0e10cSrcweir } 426cdf0e10cSrcweir if ( bErase ) 427cdf0e10cSrcweir { 428cdf0e10cSrcweir Rectangle aTempRect = aRect; 429cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 430cdf0e10cSrcweir aTempRect.Bottom() = RULER_OFF-1; 431cdf0e10cSrcweir else 432cdf0e10cSrcweir aTempRect.Right() = RULER_OFF-1; 433cdf0e10cSrcweir Erase( aTempRect ); 434cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 435cdf0e10cSrcweir { 436cdf0e10cSrcweir aTempRect.Bottom() = aRect.Bottom(); 437cdf0e10cSrcweir aTempRect.Top() = aTempRect.Bottom()-RULER_OFF+1; 438cdf0e10cSrcweir } 439cdf0e10cSrcweir else 440cdf0e10cSrcweir { 441cdf0e10cSrcweir aTempRect.Right() = aRect.Right(); 442cdf0e10cSrcweir aTempRect.Left() = aTempRect.Right()-RULER_OFF+1; 443cdf0e10cSrcweir } 444cdf0e10cSrcweir Erase( aTempRect ); 445cdf0e10cSrcweir } 446cdf0e10cSrcweir Invert( aRect ); 447cdf0e10cSrcweir } 448cdf0e10cSrcweir } 449cdf0e10cSrcweir } 450cdf0e10cSrcweir } 451cdf0e10cSrcweir 452cdf0e10cSrcweir // ----------------------------------------------------------------------- 453cdf0e10cSrcweir 454cdf0e10cSrcweir void Ruler::ImplDrawTicks( long nMin, long nMax, long nStart, long nCenter ) 455cdf0e10cSrcweir { 456cdf0e10cSrcweir long n = 0; 457cdf0e10cSrcweir long nTick = 0; 458cdf0e10cSrcweir long nTick3 = aImplRulerUnitTab[mnUnitIndex].nTick3; 459cdf0e10cSrcweir long nTickCount = aImplRulerUnitTab[mnUnitIndex].nTick1; 460cdf0e10cSrcweir Size aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode ); 461cdf0e10cSrcweir long nTickWidth; 462cdf0e10cSrcweir long nX; 463cdf0e10cSrcweir long nY; 464cdf0e10cSrcweir sal_Bool bNoTicks = sal_False; 465cdf0e10cSrcweir 466cdf0e10cSrcweir // Groessenvorberechnung 467cdf0e10cSrcweir // Sizes calculation 468cdf0e10cSrcweir sal_Bool bVertRight = sal_False; 469cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 470cdf0e10cSrcweir nTickWidth = aPixSize.Width(); 471cdf0e10cSrcweir else 472cdf0e10cSrcweir { 473cdf0e10cSrcweir Font aFont = GetFont(); 474cdf0e10cSrcweir if ( mnWinStyle & WB_RIGHT_ALIGNED ) 475cdf0e10cSrcweir { 476cdf0e10cSrcweir aFont.SetOrientation( 2700 ); 477cdf0e10cSrcweir bVertRight = sal_True; 478cdf0e10cSrcweir } 479cdf0e10cSrcweir else 480cdf0e10cSrcweir aFont.SetOrientation( 900 ); 481cdf0e10cSrcweir maVirDev.SetFont( aFont ); 482cdf0e10cSrcweir nTickWidth = aPixSize.Height(); 483cdf0e10cSrcweir } 484cdf0e10cSrcweir long nMaxWidth = maVirDev.PixelToLogic( Size( mpData->nPageWidth, 0 ), maMapMode ).Width(); 485cdf0e10cSrcweir if ( nMaxWidth < 0 ) 486cdf0e10cSrcweir nMaxWidth = -nMaxWidth; 487cdf0e10cSrcweir nMaxWidth /= aImplRulerUnitTab[mnUnitIndex].nTickUnit; 488cdf0e10cSrcweir UniString aNumStr( UniString::CreateFromInt32( nMaxWidth ) ); 489cdf0e10cSrcweir long nTxtWidth = GetTextWidth( aNumStr ); 490cdf0e10cSrcweir 491cdf0e10cSrcweir const long nTextOff = 4; 492cdf0e10cSrcweir if ( nTickWidth < nTxtWidth+nTextOff ) 493cdf0e10cSrcweir { 494cdf0e10cSrcweir // Calculate the scale of the ruler 495cdf0e10cSrcweir long nMulti = 1; 496cdf0e10cSrcweir long nOrgTick3 = nTick3; 497cdf0e10cSrcweir while ( nTickWidth < nTxtWidth+nTextOff ) 498cdf0e10cSrcweir { 499cdf0e10cSrcweir long nOldMulti = nMulti; 500cdf0e10cSrcweir if ( !nTickWidth ) //If nTickWidth equals 0 501cdf0e10cSrcweir nMulti *= 10; 502cdf0e10cSrcweir else if ( nMulti < 10 ) 503cdf0e10cSrcweir nMulti++; 504cdf0e10cSrcweir else if ( nMulti < 100 ) 505cdf0e10cSrcweir nMulti += 10; 506cdf0e10cSrcweir else if ( nMulti < 1000 ) 507cdf0e10cSrcweir nMulti += 100; 508cdf0e10cSrcweir else 509cdf0e10cSrcweir nMulti += 1000; 510cdf0e10cSrcweir // Ueberlauf, dann geben wir nichts aus, da wir bei so einem 511cdf0e10cSrcweir // unsinnigen Massstab sowieso nichts vernuenftiges anzeigen 512cdf0e10cSrcweir // koennen 513cdf0e10cSrcweir if ( nMulti < nOldMulti ) 514cdf0e10cSrcweir { 515cdf0e10cSrcweir bNoTicks = sal_True; 516cdf0e10cSrcweir break; 517cdf0e10cSrcweir } 518cdf0e10cSrcweir 519cdf0e10cSrcweir nTick3 = nOrgTick3 * nMulti; 520cdf0e10cSrcweir aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode ); 521cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 522cdf0e10cSrcweir nTickWidth = aPixSize.Width(); 523cdf0e10cSrcweir else 524cdf0e10cSrcweir nTickWidth = aPixSize.Height(); 525cdf0e10cSrcweir } 526cdf0e10cSrcweir nTickCount = nTick3; 527cdf0e10cSrcweir } 528cdf0e10cSrcweir else 529cdf0e10cSrcweir maVirDev.SetLineColor( GetSettings().GetStyleSettings().GetWindowTextColor() ); 530cdf0e10cSrcweir 531cdf0e10cSrcweir if ( !bNoTicks ) 532cdf0e10cSrcweir { 533cdf0e10cSrcweir long nTxtWidth2; 534cdf0e10cSrcweir long nTxtHeight2 = GetTextHeight()/2; 535cdf0e10cSrcweir while ( ((nStart-n) >= nMin) || ((nStart+n) <= nMax) ) 536cdf0e10cSrcweir { 537cdf0e10cSrcweir // Null-Punkt 538cdf0e10cSrcweir if ( !nTick ) 539cdf0e10cSrcweir { 540cdf0e10cSrcweir if ( nStart > nMin ) 541cdf0e10cSrcweir { 542cdf0e10cSrcweir // 0 is only painted when Margin1 is not equal to zero 543cdf0e10cSrcweir if ( (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) || (mpData->nMargin1 != 0) ) 544cdf0e10cSrcweir { 545cdf0e10cSrcweir aNumStr = (sal_Unicode)'0'; 546cdf0e10cSrcweir nTxtWidth2 = maVirDev.GetTextWidth( aNumStr )/2; 547cdf0e10cSrcweir if ( (mnWinStyle & WB_HORZ)^mpData->bTextRTL ) 548cdf0e10cSrcweir nX = nStart-nTxtWidth2; 549cdf0e10cSrcweir else 550cdf0e10cSrcweir nX = nStart+nTxtWidth2; 551cdf0e10cSrcweir long n_Y = bVertRight ? nCenter+nTxtHeight2 : nCenter-nTxtHeight2; 552cdf0e10cSrcweir ImplVDrawText( nX, n_Y, aNumStr ); 553cdf0e10cSrcweir } 554cdf0e10cSrcweir } 555cdf0e10cSrcweir } 556cdf0e10cSrcweir else 557cdf0e10cSrcweir { 558cdf0e10cSrcweir aPixSize = maVirDev.LogicToPixel( Size( nTick, nTick ), maMapMode ); 559cdf0e10cSrcweir 560cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 561cdf0e10cSrcweir n = aPixSize.Width(); 562cdf0e10cSrcweir else 563cdf0e10cSrcweir n = aPixSize.Height(); 564cdf0e10cSrcweir 565cdf0e10cSrcweir // Tick3 - Output (Text) 566cdf0e10cSrcweir if ( !(nTick % nTick3) ) 567cdf0e10cSrcweir { 568cdf0e10cSrcweir aNumStr = UniString::CreateFromInt32( nTick / aImplRulerUnitTab[mnUnitIndex].nTickUnit ); 569cdf0e10cSrcweir nTxtWidth2 = GetTextWidth( aNumStr )/2; 570cdf0e10cSrcweir 571cdf0e10cSrcweir nX = nStart+n; 572cdf0e10cSrcweir //different orientation needs a different starting position 573cdf0e10cSrcweir nY = bVertRight ? nCenter+nTxtHeight2 : nCenter-nTxtHeight2; 574cdf0e10cSrcweir 575cdf0e10cSrcweir // Check if we can display full number 576cdf0e10cSrcweir if ( nX < (nMax-nTxtWidth2) ) 577cdf0e10cSrcweir { 578cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 579cdf0e10cSrcweir nX -= nTxtWidth2; 580cdf0e10cSrcweir else 581cdf0e10cSrcweir nX += nTxtWidth2; 582cdf0e10cSrcweir ImplVDrawText( nX, nY, aNumStr ); 583cdf0e10cSrcweir } 584cdf0e10cSrcweir nX = nStart-n; 585cdf0e10cSrcweir if ( nX > (nMin+nTxtWidth2) ) 586cdf0e10cSrcweir { 587cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 588cdf0e10cSrcweir nX -= nTxtWidth2; 589cdf0e10cSrcweir else 590cdf0e10cSrcweir nX += nTxtWidth2; 591cdf0e10cSrcweir ImplVDrawText( nX, nY, aNumStr ); 592cdf0e10cSrcweir } 593cdf0e10cSrcweir } 594cdf0e10cSrcweir // Tick/Tick2 - Output (Strokes) 595cdf0e10cSrcweir else 596cdf0e10cSrcweir { 597cdf0e10cSrcweir if ( !(nTick % aImplRulerUnitTab[mnUnitIndex].nTick2) ) 598cdf0e10cSrcweir nTickWidth = RULER_TICK2_WIDTH; 599cdf0e10cSrcweir else 600cdf0e10cSrcweir nTickWidth = RULER_TICK1_WIDTH; 601cdf0e10cSrcweir long nT1 = nCenter-(nTickWidth/2); 602cdf0e10cSrcweir long nT2 = nT1+nTickWidth-1; 603cdf0e10cSrcweir long nT; 604cdf0e10cSrcweir 605cdf0e10cSrcweir nT = nStart+n; 606cdf0e10cSrcweir if ( nT < nMax ) 607cdf0e10cSrcweir ImplVDrawLine( nT, nT1, nT, nT2 ); 608cdf0e10cSrcweir nT = nStart-n; 609cdf0e10cSrcweir if ( nT > nMin ) 610cdf0e10cSrcweir ImplVDrawLine( nT, nT1, nT, nT2 ); 611cdf0e10cSrcweir } 612cdf0e10cSrcweir } 613cdf0e10cSrcweir // #i49017# with some zoom factors the value nTick can overflow 614cdf0e10cSrcweir if( ((sal_uLong)nTick + (sal_uLong)nTickCount) > (sal_uLong)LONG_MAX) 615cdf0e10cSrcweir break; 616cdf0e10cSrcweir nTick += nTickCount; 617cdf0e10cSrcweir } 618cdf0e10cSrcweir } 619cdf0e10cSrcweir } 620cdf0e10cSrcweir 621cdf0e10cSrcweir // ----------------------------------------------------------------------- 622cdf0e10cSrcweir 623cdf0e10cSrcweir void Ruler::ImplDrawArrows( long nCenter ) 624cdf0e10cSrcweir { 625cdf0e10cSrcweir sal_uInt16 i; 626cdf0e10cSrcweir long n1; 627cdf0e10cSrcweir long n2; 628cdf0e10cSrcweir long n3; 629cdf0e10cSrcweir long n4; 630cdf0e10cSrcweir long nLogWidth; 631cdf0e10cSrcweir String aStr; 632cdf0e10cSrcweir String aStr2; 633cdf0e10cSrcweir sal_Bool bDrawUnit; 634cdf0e10cSrcweir long nTxtWidth; 635cdf0e10cSrcweir long nTxtHeight2 = GetTextHeight()/2; 636cdf0e10cSrcweir 637cdf0e10cSrcweir const vcl::I18nHelper& rI18nHelper = GetSettings().GetLocaleI18nHelper(); 638cdf0e10cSrcweir 639cdf0e10cSrcweir maVirDev.SetLineColor( GetSettings().GetStyleSettings().GetWindowTextColor() ); 640cdf0e10cSrcweir for ( i = 0; i < mpData->nArrows; i++ ) 641cdf0e10cSrcweir { 642cdf0e10cSrcweir n1 = mpData->pArrows[i].nPos+mpData->nNullVirOff+1; 643cdf0e10cSrcweir n2 = n1+mpData->pArrows[i].nWidth-2; 644cdf0e10cSrcweir 645cdf0e10cSrcweir // Einheit umrechnen 646cdf0e10cSrcweir nLogWidth = mpData->pArrows[i].nLogWidth; 647cdf0e10cSrcweir if ( meSourceUnit == MAP_TWIP ) 648cdf0e10cSrcweir { 649cdf0e10cSrcweir if ( nLogWidth >= 100000 ) 650cdf0e10cSrcweir nLogWidth = (nLogWidth*254)/144; 651cdf0e10cSrcweir else 652cdf0e10cSrcweir nLogWidth = (nLogWidth*2540)/1440; 653cdf0e10cSrcweir } 654cdf0e10cSrcweir if ( nLogWidth >= 1000000 ) 655cdf0e10cSrcweir nLogWidth = (nLogWidth / aImplRulerUnitTab[mnUnitIndex].n100THMM) * 1000; 656cdf0e10cSrcweir else 657cdf0e10cSrcweir nLogWidth = (nLogWidth*1000) / aImplRulerUnitTab[mnUnitIndex].n100THMM; 658cdf0e10cSrcweir aStr = rI18nHelper.GetNum( nLogWidth, aImplRulerUnitTab[mnUnitIndex].nUnitDigits, sal_True, sal_False ); 659cdf0e10cSrcweir 660cdf0e10cSrcweir // Einheit an den String haengen 661cdf0e10cSrcweir aStr2 = aStr; 662cdf0e10cSrcweir aStr2.AppendAscii( aImplRulerUnitTab[mnUnitIndex].aUnitStr ); 663cdf0e10cSrcweir 664cdf0e10cSrcweir // Textbreite ermitteln 665cdf0e10cSrcweir bDrawUnit = sal_True; 666cdf0e10cSrcweir nTxtWidth = GetTextWidth( aStr2 ); 667cdf0e10cSrcweir if ( nTxtWidth < mpData->pArrows[i].nWidth-10 ) 668cdf0e10cSrcweir aStr = aStr2; 669cdf0e10cSrcweir else 670cdf0e10cSrcweir { 671cdf0e10cSrcweir nTxtWidth = GetTextWidth( aStr ); 672cdf0e10cSrcweir if ( nTxtWidth > mpData->pArrows[i].nWidth-10 ) 673cdf0e10cSrcweir bDrawUnit = sal_False; 674cdf0e10cSrcweir } 675cdf0e10cSrcweir 676cdf0e10cSrcweir // Ist genuegen Platz fuer Einheiten-String vorhanden 677cdf0e10cSrcweir if ( bDrawUnit ) 678cdf0e10cSrcweir { 679cdf0e10cSrcweir n3 = n1 + ((n2-n1)/2) - 1; 680cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 681cdf0e10cSrcweir n3 -= nTxtWidth/2; 682cdf0e10cSrcweir else 683cdf0e10cSrcweir n3 += nTxtWidth/2; 684cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 685cdf0e10cSrcweir { 686cdf0e10cSrcweir n4 = n3 + nTxtWidth + 2; 687cdf0e10cSrcweir ImplVDrawLine( n1, nCenter, n3, nCenter ); 688cdf0e10cSrcweir ImplVDrawLine( n4, nCenter, n2, nCenter ); 689cdf0e10cSrcweir } 690cdf0e10cSrcweir else 691cdf0e10cSrcweir { 692cdf0e10cSrcweir n4 = n3 - nTxtWidth - 2; 693cdf0e10cSrcweir ImplVDrawLine( n1, nCenter, n4, nCenter ); 694cdf0e10cSrcweir ImplVDrawLine( n3, nCenter, n2, nCenter ); 695cdf0e10cSrcweir } 696cdf0e10cSrcweir ImplVDrawText( n3, nCenter-nTxtHeight2, aStr ); 697cdf0e10cSrcweir } 698cdf0e10cSrcweir else 699cdf0e10cSrcweir ImplVDrawLine( n1, nCenter, n2, nCenter ); 700cdf0e10cSrcweir ImplVDrawLine( n1+1, nCenter-1, n1+1, nCenter+1 ); 701cdf0e10cSrcweir ImplVDrawLine( n1+2, nCenter-2, n1+2, nCenter+2 ); 702cdf0e10cSrcweir ImplVDrawLine( n2-1, nCenter-1, n2-1, nCenter+1 ); 703cdf0e10cSrcweir ImplVDrawLine( n2-2, nCenter-2, n2-2, nCenter+2 ); 704cdf0e10cSrcweir } 705cdf0e10cSrcweir } 706cdf0e10cSrcweir 707cdf0e10cSrcweir // ----------------------------------------------------------------------- 708cdf0e10cSrcweir 709cdf0e10cSrcweir void Ruler::ImplDrawBorders( long nMin, long nMax, long nVirTop, long nVirBottom ) 710cdf0e10cSrcweir { 711cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 712cdf0e10cSrcweir long n; 713cdf0e10cSrcweir long n1; 714cdf0e10cSrcweir long n2; 715cdf0e10cSrcweir long nTemp1; 716cdf0e10cSrcweir long nTemp2; 717cdf0e10cSrcweir sal_uInt16 i; 718cdf0e10cSrcweir 719cdf0e10cSrcweir for ( i = 0; i < mpData->nBorders; i++ ) 720cdf0e10cSrcweir { 721cdf0e10cSrcweir if ( mpData->pBorders[i].nStyle & RULER_STYLE_INVISIBLE ) 722cdf0e10cSrcweir continue; 723cdf0e10cSrcweir 724cdf0e10cSrcweir n1 = mpData->pBorders[i].nPos+mpData->nNullVirOff; 725cdf0e10cSrcweir n2 = n1+mpData->pBorders[i].nWidth; 726cdf0e10cSrcweir 727cdf0e10cSrcweir if ( ((n1 >= nMin) && (n1 <= nMax)) || ((n2 >= nMin) && (n2 <= nMax)) ) 728cdf0e10cSrcweir { 729cdf0e10cSrcweir if ( (n2-n1) > 3 ) 730cdf0e10cSrcweir { 731cdf0e10cSrcweir maVirDev.SetLineColor(); 732cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 733cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); 734cdf0e10cSrcweir else 735cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); 736cdf0e10cSrcweir ImplVDrawRect( n1, nVirTop, n2, nVirBottom ); 737cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 738cdf0e10cSrcweir { 739cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); 740cdf0e10cSrcweir ImplVDrawLine( n1+1, nVirTop, n1+1, nVirBottom ); 741cdf0e10cSrcweir ImplVDrawLine( n1, nVirTop, n2, nVirTop ); 742cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 743cdf0e10cSrcweir ImplVDrawLine( n1, nVirTop, n1, nVirBottom ); 744cdf0e10cSrcweir ImplVDrawLine( n1, nVirBottom, n2, nVirBottom ); 745cdf0e10cSrcweir ImplVDrawLine( n2-1, nVirTop, n2-1, nVirBottom ); 746cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 747cdf0e10cSrcweir ImplVDrawLine( n2, nVirTop, n2, nVirBottom ); 748cdf0e10cSrcweir } 749cdf0e10cSrcweir else 750cdf0e10cSrcweir { 751cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 752cdf0e10cSrcweir ImplVDrawLine( n1, nVirTop, n1, nVirBottom ); 753cdf0e10cSrcweir ImplVDrawLine( n2, nVirTop, n2, nVirBottom ); 754cdf0e10cSrcweir } 755cdf0e10cSrcweir 756cdf0e10cSrcweir if ( mpData->pBorders[i].nStyle & RULER_BORDER_VARIABLE ) 757cdf0e10cSrcweir { 758cdf0e10cSrcweir if ( n2-n1 > RULER_VAR_SIZE+4 ) 759cdf0e10cSrcweir { 760cdf0e10cSrcweir nTemp1 = n1 + (((n2-n1+1)-RULER_VAR_SIZE) / 2); 761cdf0e10cSrcweir nTemp2 = nVirTop + (((nVirBottom-nVirTop+1)-RULER_VAR_SIZE) / 2); 762cdf0e10cSrcweir long nTemp3 = nTemp1+RULER_VAR_SIZE-1; 763cdf0e10cSrcweir long nTemp4 = nTemp2+RULER_VAR_SIZE-1; 764cdf0e10cSrcweir long nTempY = nTemp2; 765cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 766cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); 767cdf0e10cSrcweir else 768cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 769cdf0e10cSrcweir while ( nTempY <= nTemp4 ) 770cdf0e10cSrcweir { 771cdf0e10cSrcweir ImplVDrawLine( nTemp1, nTempY, nTemp3, nTempY ); 772cdf0e10cSrcweir nTempY += 2; 773cdf0e10cSrcweir } 774cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 775cdf0e10cSrcweir { 776cdf0e10cSrcweir nTempY = nTemp2+1; 777cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 778cdf0e10cSrcweir while ( nTempY <= nTemp4 ) 779cdf0e10cSrcweir { 780cdf0e10cSrcweir ImplVDrawLine( nTemp1, nTempY, nTemp3, nTempY ); 781cdf0e10cSrcweir nTempY += 2; 782cdf0e10cSrcweir } 783cdf0e10cSrcweir } 784cdf0e10cSrcweir } 785cdf0e10cSrcweir } 786cdf0e10cSrcweir 787cdf0e10cSrcweir if ( mpData->pBorders[i].nStyle & RULER_BORDER_SIZEABLE ) 788cdf0e10cSrcweir { 789cdf0e10cSrcweir if ( n2-n1 > RULER_VAR_SIZE+10 ) 790cdf0e10cSrcweir { 791cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 792cdf0e10cSrcweir { 793cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 794cdf0e10cSrcweir ImplVDrawLine( n1+4, nVirTop+3, n1+4, nVirBottom-3 ); 795cdf0e10cSrcweir ImplVDrawLine( n2-5, nVirTop+3, n2-5, nVirBottom-3 ); 796cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); 797cdf0e10cSrcweir ImplVDrawLine( n1+5, nVirTop+3, n1+5, nVirBottom-3 ); 798cdf0e10cSrcweir ImplVDrawLine( n2-4, nVirTop+3, n2-4, nVirBottom-3 ); 799cdf0e10cSrcweir } 800cdf0e10cSrcweir else 801cdf0e10cSrcweir { 802cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 803cdf0e10cSrcweir ImplVDrawLine( n1+4, nVirTop+3, n1+4, nVirBottom-3 ); 804cdf0e10cSrcweir ImplVDrawLine( n2-4, nVirTop+3, n2-4, nVirBottom-3 ); 805cdf0e10cSrcweir } 806cdf0e10cSrcweir } 807cdf0e10cSrcweir } 808cdf0e10cSrcweir } 809cdf0e10cSrcweir else 810cdf0e10cSrcweir { 811cdf0e10cSrcweir n = n1+((n2-n1)/2); 812cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 813cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 814cdf0e10cSrcweir else 815cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 816cdf0e10cSrcweir if ( mpData->pBorders[i].nStyle & RULER_BORDER_SNAP ) 817cdf0e10cSrcweir ImplVDrawLine( n, nVirTop, n, nVirBottom ); 818cdf0e10cSrcweir else if ( mpData->pBorders[i].nStyle & RULER_BORDER_MARGIN ) 819cdf0e10cSrcweir ImplVDrawLine( n, nVirTop, n, nVirBottom ); 820cdf0e10cSrcweir else 821cdf0e10cSrcweir { 822cdf0e10cSrcweir ImplVDrawLine( n-1, nVirTop, n-1, nVirBottom ); 823cdf0e10cSrcweir ImplVDrawLine( n+1, nVirTop, n+1, nVirBottom ); 824cdf0e10cSrcweir maVirDev.SetLineColor(); 825cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); 826cdf0e10cSrcweir ImplVDrawRect( n, nVirTop, n, nVirBottom ); 827cdf0e10cSrcweir } 828cdf0e10cSrcweir } 829cdf0e10cSrcweir } 830cdf0e10cSrcweir } 831cdf0e10cSrcweir } 832cdf0e10cSrcweir 833cdf0e10cSrcweir // ----------------------------------------------------------------------- 834cdf0e10cSrcweir 835cdf0e10cSrcweir void Ruler::ImplDrawIndent( const Polygon& rPoly, sal_uInt16 nStyle ) 836cdf0e10cSrcweir { 837cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 838cdf0e10cSrcweir Point aPos1; 839cdf0e10cSrcweir Point aPos2; 840cdf0e10cSrcweir sal_uInt16 nIndentStyle = nStyle & RULER_INDENT_STYLE; 841cdf0e10cSrcweir 842cdf0e10cSrcweir if ( nStyle & RULER_STYLE_INVISIBLE ) 843cdf0e10cSrcweir return; 844cdf0e10cSrcweir 845cdf0e10cSrcweir if ( nStyle & RULER_STYLE_DONTKNOW ) 846cdf0e10cSrcweir { 847cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 848cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); 849cdf0e10cSrcweir } 850cdf0e10cSrcweir else 851cdf0e10cSrcweir { 852cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetDarkShadowColor() ); 853cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); 854cdf0e10cSrcweir } 855cdf0e10cSrcweir 856cdf0e10cSrcweir maVirDev.DrawPolygon( rPoly ); 857cdf0e10cSrcweir 858cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) && !(nStyle & RULER_STYLE_DONTKNOW) ) 859cdf0e10cSrcweir { 860cdf0e10cSrcweir if ( nIndentStyle == RULER_INDENT_BOTTOM ) 861cdf0e10cSrcweir { 862cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); 863cdf0e10cSrcweir aPos1 = rPoly.GetPoint( 2 ); 864cdf0e10cSrcweir aPos1.X()++; 865cdf0e10cSrcweir aPos2 = rPoly.GetPoint( 1 ); 866cdf0e10cSrcweir aPos2.X()++; 867cdf0e10cSrcweir maVirDev.DrawLine( aPos2, aPos1 ); 868cdf0e10cSrcweir aPos2.X()--; 869cdf0e10cSrcweir aPos2.Y()++; 870cdf0e10cSrcweir aPos1 = rPoly.GetPoint( 0 ); 871cdf0e10cSrcweir aPos1.Y()++; 872cdf0e10cSrcweir maVirDev.DrawLine( aPos2, aPos1 ); 873cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 874cdf0e10cSrcweir aPos2 = rPoly.GetPoint( 4 ); 875cdf0e10cSrcweir aPos2.Y()++; 876cdf0e10cSrcweir maVirDev.DrawLine( aPos1, aPos2 ); 877cdf0e10cSrcweir aPos2.X()--; 878cdf0e10cSrcweir aPos1 = rPoly.GetPoint( 3 ); 879cdf0e10cSrcweir aPos1.X()--; 880cdf0e10cSrcweir maVirDev.DrawLine( aPos2, aPos1 ); 881cdf0e10cSrcweir aPos1.Y()--; 882cdf0e10cSrcweir aPos2 = rPoly.GetPoint( 2 ); 883cdf0e10cSrcweir aPos2.X()++; 884cdf0e10cSrcweir aPos2.Y()--; 885cdf0e10cSrcweir maVirDev.DrawLine( aPos2, aPos1 ); 886cdf0e10cSrcweir } 887cdf0e10cSrcweir else 888cdf0e10cSrcweir { 889cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); 890cdf0e10cSrcweir aPos1 = rPoly.GetPoint( 2 ); 891cdf0e10cSrcweir aPos1.X()++; 892cdf0e10cSrcweir aPos1.Y()++; 893cdf0e10cSrcweir aPos2 = rPoly.GetPoint( 3 ); 894cdf0e10cSrcweir aPos2.Y()++; 895cdf0e10cSrcweir maVirDev.DrawLine( aPos1, aPos2 ); 896cdf0e10cSrcweir aPos2 = rPoly.GetPoint( 1 ); 897cdf0e10cSrcweir aPos2.X()++; 898cdf0e10cSrcweir maVirDev.DrawLine( aPos1, aPos2 ); 899cdf0e10cSrcweir aPos2.X()--; 900cdf0e10cSrcweir aPos2.Y()--; 901cdf0e10cSrcweir aPos1 = rPoly.GetPoint( 0 ); 902cdf0e10cSrcweir aPos1.Y()--; 903cdf0e10cSrcweir maVirDev.DrawLine( aPos2, aPos1 ); 904cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 905cdf0e10cSrcweir aPos2 = rPoly.GetPoint( 4 ); 906cdf0e10cSrcweir aPos2.Y()--; 907cdf0e10cSrcweir maVirDev.DrawLine( aPos1, aPos2 ); 908cdf0e10cSrcweir aPos2.X()--; 909cdf0e10cSrcweir aPos1 = rPoly.GetPoint( 3 ); 910cdf0e10cSrcweir aPos1.X()--; 911cdf0e10cSrcweir maVirDev.DrawLine( aPos2, aPos1 ); 912cdf0e10cSrcweir } 913cdf0e10cSrcweir 914cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetDarkShadowColor() ); 915cdf0e10cSrcweir maVirDev.SetFillColor(); 916cdf0e10cSrcweir maVirDev.DrawPolygon( rPoly ); 917cdf0e10cSrcweir } 918cdf0e10cSrcweir } 919cdf0e10cSrcweir 920cdf0e10cSrcweir // ----------------------------------------------------------------------- 921cdf0e10cSrcweir 922cdf0e10cSrcweir void Ruler::ImplDrawIndents( long nMin, long nMax, long nVirTop, long nVirBottom ) 923cdf0e10cSrcweir { 924cdf0e10cSrcweir sal_uInt16 j; 925cdf0e10cSrcweir long n; 926cdf0e10cSrcweir long nIndentHeight = (mnVirHeight/2) - 1; 927cdf0e10cSrcweir long nIndentWidth2 = nIndentHeight-3; 928cdf0e10cSrcweir Polygon aPoly( 5 ); 929cdf0e10cSrcweir 930cdf0e10cSrcweir for ( j = 0; j < mpData->nIndents; j++ ) 931cdf0e10cSrcweir { 932cdf0e10cSrcweir if ( mpData->pIndents[j].nStyle & RULER_STYLE_INVISIBLE ) 933cdf0e10cSrcweir continue; 934cdf0e10cSrcweir 935cdf0e10cSrcweir sal_uInt16 nStyle = mpData->pIndents[j].nStyle; 936cdf0e10cSrcweir sal_uInt16 nIndentStyle = nStyle & RULER_INDENT_STYLE; 937cdf0e10cSrcweir 938cdf0e10cSrcweir n = mpData->pIndents[j].nPos+mpData->nNullVirOff; 939cdf0e10cSrcweir 940cdf0e10cSrcweir if ( (n >= nMin) && (n <= nMax) ) 941cdf0e10cSrcweir { 942cdf0e10cSrcweir if(nIndentStyle == RULER_INDENT_BORDER) 943cdf0e10cSrcweir { 944cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 945cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 946cdf0e10cSrcweir ImplVDrawLine( n, nVirTop, n, nVirBottom ); 947cdf0e10cSrcweir } 948cdf0e10cSrcweir else if ( nIndentStyle == RULER_INDENT_BOTTOM ) 949cdf0e10cSrcweir { 950cdf0e10cSrcweir aPoly.SetPoint( Point( n+0, nVirBottom-nIndentHeight ), 0 ); 951cdf0e10cSrcweir aPoly.SetPoint( Point( n-nIndentWidth2, nVirBottom-3 ), 1 ); 952cdf0e10cSrcweir aPoly.SetPoint( Point( n-nIndentWidth2, nVirBottom ), 2 ); 953cdf0e10cSrcweir aPoly.SetPoint( Point( n+nIndentWidth2, nVirBottom ), 3 ); 954cdf0e10cSrcweir aPoly.SetPoint( Point( n+nIndentWidth2, nVirBottom-3 ), 4 ); 955cdf0e10cSrcweir } 956cdf0e10cSrcweir else 957cdf0e10cSrcweir { 958cdf0e10cSrcweir aPoly.SetPoint( Point( n+0, nVirTop+nIndentHeight ), 0 ); 959cdf0e10cSrcweir aPoly.SetPoint( Point( n-nIndentWidth2, nVirTop+3 ), 1 ); 960cdf0e10cSrcweir aPoly.SetPoint( Point( n-nIndentWidth2, nVirTop ), 2 ); 961cdf0e10cSrcweir aPoly.SetPoint( Point( n+nIndentWidth2, nVirTop ), 3 ); 962cdf0e10cSrcweir aPoly.SetPoint( Point( n+nIndentWidth2, nVirTop+3 ), 4 ); 963cdf0e10cSrcweir } 964cdf0e10cSrcweir 965cdf0e10cSrcweir if(0 == (mnWinStyle & WB_HORZ)) 966cdf0e10cSrcweir { 967cdf0e10cSrcweir Point aTmp; 968cdf0e10cSrcweir for(sal_uInt16 i = 0; i < 5; i++) 969cdf0e10cSrcweir { 970cdf0e10cSrcweir aTmp = aPoly[i]; 971cdf0e10cSrcweir Point aSet(nVirBottom - aTmp.Y(), aTmp.X()); 972cdf0e10cSrcweir aPoly[i] = aSet; 973cdf0e10cSrcweir } 974cdf0e10cSrcweir } 975cdf0e10cSrcweir if(RULER_INDENT_BORDER != nIndentStyle) 976cdf0e10cSrcweir ImplDrawIndent( aPoly, nStyle ); 977cdf0e10cSrcweir } 978cdf0e10cSrcweir } 979cdf0e10cSrcweir } 980cdf0e10cSrcweir 981cdf0e10cSrcweir // ----------------------------------------------------------------------- 982cdf0e10cSrcweir 983cdf0e10cSrcweir static void ImplCenterTabPos( Point& rPos, sal_uInt16 nTabStyle ) 984cdf0e10cSrcweir { 985cdf0e10cSrcweir sal_Bool bRTL = 0 != (nTabStyle & RULER_TAB_RTL); 986cdf0e10cSrcweir nTabStyle &= RULER_TAB_STYLE; 987cdf0e10cSrcweir rPos.Y() += RULER_TAB_HEIGHT/2; 988cdf0e10cSrcweir if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||( bRTL && nTabStyle == RULER_TAB_RIGHT)) 989cdf0e10cSrcweir rPos.X() -= RULER_TAB_WIDTH/2; 990cdf0e10cSrcweir else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||( bRTL && nTabStyle == RULER_TAB_LEFT)) 991cdf0e10cSrcweir rPos.X() += RULER_TAB_WIDTH/2; 992cdf0e10cSrcweir } 993cdf0e10cSrcweir 994cdf0e10cSrcweir // ----------------------------------------------------------------------- 995cdf0e10cSrcweir void lcl_RotateRect_Impl(Rectangle& rRect, const long nReference, sal_Bool bRightAligned) 996cdf0e10cSrcweir { 997cdf0e10cSrcweir if(!rRect.IsEmpty()) 998cdf0e10cSrcweir { 999cdf0e10cSrcweir Rectangle aTmp(rRect); 1000cdf0e10cSrcweir rRect.Top() = aTmp.Left(); 1001cdf0e10cSrcweir rRect.Bottom() = aTmp.Right(); 1002cdf0e10cSrcweir rRect.Left() = aTmp.Top(); 1003cdf0e10cSrcweir rRect.Right() = aTmp.Bottom(); 1004cdf0e10cSrcweir if(bRightAligned) 1005cdf0e10cSrcweir { 1006cdf0e10cSrcweir long nRef = 2 * nReference; 1007cdf0e10cSrcweir rRect.Left() = nRef - rRect.Left(); 1008cdf0e10cSrcweir rRect.Right() = nRef - rRect.Right(); 1009cdf0e10cSrcweir } 1010cdf0e10cSrcweir } 1011cdf0e10cSrcweir } 1012cdf0e10cSrcweir // ----------------------------------------------------------------------- 1013cdf0e10cSrcweir 1014cdf0e10cSrcweir static void ImplDrawRulerTab( OutputDevice* pDevice, 1015cdf0e10cSrcweir const Point& rPos, sal_uInt16 nStyle, WinBits nWinBits ) 1016cdf0e10cSrcweir { 1017cdf0e10cSrcweir if ( nStyle & RULER_STYLE_INVISIBLE ) 1018cdf0e10cSrcweir return; 1019cdf0e10cSrcweir 1020cdf0e10cSrcweir sal_uInt16 nTabStyle = nStyle & RULER_TAB_STYLE; 1021cdf0e10cSrcweir sal_Bool bRTL = 0 != (nStyle & RULER_TAB_RTL); 1022cdf0e10cSrcweir Rectangle aRect1, aRect2, aRect3; 1023cdf0e10cSrcweir aRect3.SetEmpty(); 1024cdf0e10cSrcweir if ( nTabStyle == RULER_TAB_DEFAULT ) 1025cdf0e10cSrcweir { 1026cdf0e10cSrcweir aRect1.Left() = rPos.X() - RULER_TAB_DWIDTH2 + 1 ; 1027cdf0e10cSrcweir aRect1.Top() = rPos.Y() - RULER_TAB_DHEIGHT2 + 1 ; 1028cdf0e10cSrcweir aRect1.Right() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH ; 1029cdf0e10cSrcweir aRect1.Bottom() = rPos.Y(); 1030cdf0e10cSrcweir aRect2.Left() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH3; 1031cdf0e10cSrcweir aRect2.Top() = rPos.Y() - RULER_TAB_DHEIGHT + 1; 1032cdf0e10cSrcweir aRect2.Right() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH3 + RULER_TAB_DWIDTH4 - 1; 1033cdf0e10cSrcweir aRect2.Bottom() = rPos.Y(); 1034cdf0e10cSrcweir 1035cdf0e10cSrcweir } 1036cdf0e10cSrcweir else if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||( bRTL && nTabStyle == RULER_TAB_RIGHT)) 1037cdf0e10cSrcweir { 1038cdf0e10cSrcweir aRect1.Left() = rPos.X(); 1039cdf0e10cSrcweir aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1; 1040cdf0e10cSrcweir aRect1.Right() = rPos.X() + RULER_TAB_WIDTH - 1; 1041cdf0e10cSrcweir aRect1.Bottom() = rPos.Y(); 1042cdf0e10cSrcweir aRect2.Left() = rPos.X(); 1043cdf0e10cSrcweir aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1; 1044cdf0e10cSrcweir aRect2.Right() = rPos.X() + RULER_TAB_WIDTH2 - 1; 1045cdf0e10cSrcweir aRect2.Bottom() = rPos.Y(); 1046cdf0e10cSrcweir } 1047cdf0e10cSrcweir else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||( bRTL && nTabStyle == RULER_TAB_LEFT)) 1048cdf0e10cSrcweir { 1049cdf0e10cSrcweir aRect1.Left() = rPos.X() - RULER_TAB_WIDTH + 1; 1050cdf0e10cSrcweir aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1; 1051cdf0e10cSrcweir aRect1.Right() = rPos.X(); 1052cdf0e10cSrcweir aRect1.Bottom() = rPos.Y(); 1053cdf0e10cSrcweir aRect2.Left() = rPos.X() - RULER_TAB_WIDTH2 + 1; 1054cdf0e10cSrcweir aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1; 1055cdf0e10cSrcweir aRect2.Right() = rPos.X(); 1056cdf0e10cSrcweir aRect2.Bottom() = rPos.Y(); 1057cdf0e10cSrcweir } 1058cdf0e10cSrcweir else 1059cdf0e10cSrcweir { 1060cdf0e10cSrcweir aRect1.Left() = rPos.X() - RULER_TAB_CWIDTH2 + 1; 1061cdf0e10cSrcweir aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1; 1062cdf0e10cSrcweir aRect1.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH; 1063cdf0e10cSrcweir aRect1.Bottom() = rPos.Y(); 1064cdf0e10cSrcweir aRect2.Left() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH3; 1065cdf0e10cSrcweir aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1; 1066cdf0e10cSrcweir aRect2.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH3 + RULER_TAB_CWIDTH4 - 1; 1067cdf0e10cSrcweir aRect2.Bottom() = rPos.Y(); 1068cdf0e10cSrcweir 1069cdf0e10cSrcweir if ( nTabStyle == RULER_TAB_DECIMAL ) 1070cdf0e10cSrcweir { 1071cdf0e10cSrcweir aRect3.Left() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH - 1; 1072cdf0e10cSrcweir aRect3.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1 + 1; 1073cdf0e10cSrcweir aRect3.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH; 1074cdf0e10cSrcweir aRect3.Bottom()= rPos.Y() - RULER_TAB_HEIGHT + 1 + 2 ; 1075cdf0e10cSrcweir } 1076cdf0e10cSrcweir } 1077cdf0e10cSrcweir if( 0 == (nWinBits&WB_HORZ) ) 1078cdf0e10cSrcweir { 1079cdf0e10cSrcweir sal_Bool bRightAligned = 0 != (nWinBits&WB_RIGHT_ALIGNED); 1080cdf0e10cSrcweir lcl_RotateRect_Impl(aRect1, rPos.Y(), bRightAligned); 1081cdf0e10cSrcweir lcl_RotateRect_Impl(aRect2, rPos.Y(), bRightAligned); 1082cdf0e10cSrcweir lcl_RotateRect_Impl(aRect3, rPos.Y(), bRightAligned); 1083cdf0e10cSrcweir } 1084cdf0e10cSrcweir pDevice->DrawRect( aRect1 ); 1085cdf0e10cSrcweir pDevice->DrawRect( aRect2 ); 1086cdf0e10cSrcweir if(!aRect2.IsEmpty()) 1087cdf0e10cSrcweir pDevice->DrawRect( aRect3 ); 1088cdf0e10cSrcweir 1089cdf0e10cSrcweir } 1090cdf0e10cSrcweir 1091cdf0e10cSrcweir // ----------------------------------------------------------------------- 1092cdf0e10cSrcweir 1093cdf0e10cSrcweir void Ruler::ImplDrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle ) 1094cdf0e10cSrcweir { 1095cdf0e10cSrcweir if ( nStyle & RULER_STYLE_INVISIBLE ) 1096cdf0e10cSrcweir return; 1097cdf0e10cSrcweir 1098cdf0e10cSrcweir pDevice->SetLineColor(); 1099cdf0e10cSrcweir if ( nStyle & RULER_STYLE_DONTKNOW ) 1100cdf0e10cSrcweir pDevice->SetFillColor( GetSettings().GetStyleSettings().GetFaceColor() ); 1101cdf0e10cSrcweir else 1102cdf0e10cSrcweir pDevice->SetFillColor( GetSettings().GetStyleSettings().GetWindowTextColor() ); 1103cdf0e10cSrcweir 1104cdf0e10cSrcweir if(mpData->bTextRTL) 1105cdf0e10cSrcweir nStyle |= RULER_TAB_RTL; 1106cdf0e10cSrcweir ImplDrawRulerTab( pDevice, rPos, nStyle, GetStyle()); 1107cdf0e10cSrcweir } 1108cdf0e10cSrcweir 1109cdf0e10cSrcweir // ----------------------------------------------------------------------- 1110cdf0e10cSrcweir 1111cdf0e10cSrcweir void Ruler::ImplDrawTabs( long nMin, long nMax, long nVirTop, long nVirBottom ) 1112cdf0e10cSrcweir { 1113cdf0e10cSrcweir for ( sal_uInt16 i = 0; i < mpData->nTabs; i++ ) 1114cdf0e10cSrcweir { 1115cdf0e10cSrcweir if ( mpData->pTabs[i].nStyle & RULER_STYLE_INVISIBLE ) 1116cdf0e10cSrcweir continue; 1117cdf0e10cSrcweir 1118cdf0e10cSrcweir long n; 1119cdf0e10cSrcweir n = mpData->pTabs[i].nPos; 1120cdf0e10cSrcweir n += +mpData->nNullVirOff; 1121cdf0e10cSrcweir long nTopBottom = GetStyle() & WB_RIGHT_ALIGNED ? nVirTop : nVirBottom; 1122cdf0e10cSrcweir if ( (n >= nMin) && (n <= nMax) ) 1123cdf0e10cSrcweir ImplDrawTab( &maVirDev, Point( n, nTopBottom ), mpData->pTabs[i].nStyle ); 1124cdf0e10cSrcweir } 1125cdf0e10cSrcweir } 1126cdf0e10cSrcweir 1127cdf0e10cSrcweir // ----------------------------------------------------------------------- 1128cdf0e10cSrcweir 1129cdf0e10cSrcweir void Ruler::ImplInitSettings( sal_Bool bFont, 1130cdf0e10cSrcweir sal_Bool bForeground, sal_Bool bBackground ) 1131cdf0e10cSrcweir { 1132cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1133cdf0e10cSrcweir 1134cdf0e10cSrcweir if ( bFont ) 1135cdf0e10cSrcweir { 1136cdf0e10cSrcweir Font aFont; 1137cdf0e10cSrcweir aFont = rStyleSettings.GetToolFont(); 1138cdf0e10cSrcweir if ( IsControlFont() ) 1139cdf0e10cSrcweir aFont.Merge( GetControlFont() ); 1140cdf0e10cSrcweir SetZoomedPointFont( aFont ); 1141cdf0e10cSrcweir } 1142cdf0e10cSrcweir 1143cdf0e10cSrcweir if ( bForeground || bFont ) 1144cdf0e10cSrcweir { 1145cdf0e10cSrcweir Color aColor; 1146cdf0e10cSrcweir if ( IsControlForeground() ) 1147cdf0e10cSrcweir aColor = GetControlForeground(); 1148cdf0e10cSrcweir else 1149cdf0e10cSrcweir aColor = rStyleSettings.GetWindowTextColor(); 1150cdf0e10cSrcweir SetTextColor( aColor ); 1151cdf0e10cSrcweir SetTextFillColor(); 1152cdf0e10cSrcweir } 1153cdf0e10cSrcweir 1154cdf0e10cSrcweir if ( bBackground ) 1155cdf0e10cSrcweir { 1156cdf0e10cSrcweir Color aColor; 1157cdf0e10cSrcweir if ( IsControlBackground() ) 1158cdf0e10cSrcweir aColor = GetControlBackground(); 1159cdf0e10cSrcweir else 1160cdf0e10cSrcweir aColor = rStyleSettings.GetFaceColor(); 1161cdf0e10cSrcweir SetBackground( aColor ); 1162cdf0e10cSrcweir } 1163cdf0e10cSrcweir 1164cdf0e10cSrcweir maVirDev.SetSettings( GetSettings() ); 1165cdf0e10cSrcweir maVirDev.SetBackground( GetBackground() ); 1166cdf0e10cSrcweir Font aFont = GetFont(); 1167cdf0e10cSrcweir if ( mnWinStyle & WB_VERT ) 1168cdf0e10cSrcweir aFont.SetOrientation( 900 ); 1169cdf0e10cSrcweir maVirDev.SetFont( aFont ); 1170cdf0e10cSrcweir maVirDev.SetTextColor( GetTextColor() ); 1171cdf0e10cSrcweir maVirDev.SetTextFillColor( GetTextFillColor() ); 1172cdf0e10cSrcweir } 1173cdf0e10cSrcweir 1174cdf0e10cSrcweir // ----------------------------------------------------------------------- 1175cdf0e10cSrcweir 1176cdf0e10cSrcweir void Ruler::ImplCalc() 1177cdf0e10cSrcweir { 1178cdf0e10cSrcweir // Offset berechnen 1179cdf0e10cSrcweir mpData->nRulVirOff = mnWinOff + mpData->nPageOff; 1180cdf0e10cSrcweir if ( mpData->nRulVirOff > mnVirOff ) 1181cdf0e10cSrcweir mpData->nRulVirOff -= mnVirOff; 1182cdf0e10cSrcweir else 1183cdf0e10cSrcweir mpData->nRulVirOff = 0; 1184cdf0e10cSrcweir long nRulWinOff = mpData->nRulVirOff+mnVirOff; 1185cdf0e10cSrcweir 1186cdf0e10cSrcweir // Nicht sichtbaren Bereich der Page berechnen 1187cdf0e10cSrcweir long nNotVisPageWidth; 1188cdf0e10cSrcweir if ( mpData->nPageOff < 0 ) 1189cdf0e10cSrcweir { 1190cdf0e10cSrcweir nNotVisPageWidth = -(mpData->nPageOff); 1191cdf0e10cSrcweir if ( nRulWinOff < mnWinOff ) 1192cdf0e10cSrcweir nNotVisPageWidth -= mnWinOff-nRulWinOff; 1193cdf0e10cSrcweir } 1194cdf0e10cSrcweir else 1195cdf0e10cSrcweir nNotVisPageWidth = 0; 1196cdf0e10cSrcweir 1197cdf0e10cSrcweir // Breite berechnen 1198cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1199cdf0e10cSrcweir { 1200cdf0e10cSrcweir if ( mbAutoWinWidth ) 1201cdf0e10cSrcweir mnWinWidth = mnWidth - mnVirOff; 1202cdf0e10cSrcweir if ( mpData->bAutoPageWidth ) 1203cdf0e10cSrcweir mpData->nPageWidth = mnWinWidth; 1204cdf0e10cSrcweir mpData->nRulWidth = Min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth ); 1205cdf0e10cSrcweir if ( nRulWinOff+mpData->nRulWidth > mnWidth ) 1206cdf0e10cSrcweir mpData->nRulWidth = mnWidth-nRulWinOff; 1207cdf0e10cSrcweir } 1208cdf0e10cSrcweir else 1209cdf0e10cSrcweir { 1210cdf0e10cSrcweir if ( mbAutoWinWidth ) 1211cdf0e10cSrcweir mnWinWidth = mnHeight - mnVirOff; 1212cdf0e10cSrcweir if ( mpData->bAutoPageWidth ) 1213cdf0e10cSrcweir mpData->nPageWidth = mnWinWidth; 1214cdf0e10cSrcweir mpData->nRulWidth = Min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth ); 1215cdf0e10cSrcweir if ( nRulWinOff+mpData->nRulWidth > mnHeight ) 1216cdf0e10cSrcweir mpData->nRulWidth = mnHeight-nRulWinOff; 1217cdf0e10cSrcweir } 1218cdf0e10cSrcweir 1219cdf0e10cSrcweir mbCalc = sal_False; 1220cdf0e10cSrcweir } 1221cdf0e10cSrcweir 1222cdf0e10cSrcweir // ----------------------------------------------------------------------- 1223cdf0e10cSrcweir 1224cdf0e10cSrcweir void Ruler::ImplFormat() 1225cdf0e10cSrcweir { 1226cdf0e10cSrcweir // Wenn schon formatiert ist, brauchen wir es nicht nochmal 1227cdf0e10cSrcweir if ( !mbFormat ) 1228cdf0e10cSrcweir return; 1229cdf0e10cSrcweir 1230cdf0e10cSrcweir // Wenn Fenster noch keine Groesse hat, brauchen wir noch nichts machen 1231cdf0e10cSrcweir if ( !mnVirWidth ) 1232cdf0e10cSrcweir return; 1233cdf0e10cSrcweir 1234cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1235cdf0e10cSrcweir long nP1; // Pixel-Position von Page1 1236cdf0e10cSrcweir long nP2; // Pixel-Position von Page2 1237cdf0e10cSrcweir long nM1; // Pixel-Position von Margin1 1238cdf0e10cSrcweir long nM2; // Pixel-Position von Margin2 1239cdf0e10cSrcweir long nVirTop; // Obere/Linke-Kante bei Ausgabe 1240cdf0e10cSrcweir long nVirBottom; // Untere/Rechte-Kante bei Ausgabe 1241cdf0e10cSrcweir long nVirLeft; // Linke/Obere-Kante bei Ausgabe 1242cdf0e10cSrcweir long nVirRight; // Rechte/Untere-Kante bei Ausgabe 1243cdf0e10cSrcweir long nNullVirOff; // Fuer schnellere Berechnung 1244cdf0e10cSrcweir 1245cdf0e10cSrcweir // Werte berechnen 1246cdf0e10cSrcweir if ( mbCalc ) 1247cdf0e10cSrcweir ImplCalc(); 1248cdf0e10cSrcweir mpData->nNullVirOff = mnWinOff+mpData->nPageOff+mpData->nNullOff-mnVirOff; 1249cdf0e10cSrcweir nNullVirOff = mpData->nNullVirOff; 1250cdf0e10cSrcweir nVirLeft = mpData->nRulVirOff; 1251cdf0e10cSrcweir nVirRight = nVirLeft+mpData->nRulWidth-1; 1252cdf0e10cSrcweir nVirTop = 0; 1253cdf0e10cSrcweir nVirBottom = mnVirHeight-1; 1254cdf0e10cSrcweir 1255cdf0e10cSrcweir if ( !IsReallyVisible() ) 1256cdf0e10cSrcweir return; 1257cdf0e10cSrcweir 1258cdf0e10cSrcweir Size aVirDevSize; 1259cdf0e10cSrcweir sal_Bool b3DLook = !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO); 1260cdf0e10cSrcweir 1261cdf0e10cSrcweir // VirtualDevice initialize 1262cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1263cdf0e10cSrcweir { 1264cdf0e10cSrcweir aVirDevSize.Width() = mnVirWidth; 1265cdf0e10cSrcweir aVirDevSize.Height() = mnVirHeight; 1266cdf0e10cSrcweir } 1267cdf0e10cSrcweir else 1268cdf0e10cSrcweir { 1269cdf0e10cSrcweir aVirDevSize.Height() = mnVirWidth; 1270cdf0e10cSrcweir aVirDevSize.Width() = mnVirHeight; 1271cdf0e10cSrcweir } 1272cdf0e10cSrcweir if ( aVirDevSize != maVirDev.GetOutputSizePixel() ) 1273cdf0e10cSrcweir maVirDev.SetOutputSizePixel( aVirDevSize, sal_True ); 1274cdf0e10cSrcweir else 1275cdf0e10cSrcweir maVirDev.Erase(); 1276cdf0e10cSrcweir 1277cdf0e10cSrcweir // Raender berechnen 1278cdf0e10cSrcweir if ( !(mpData->nMargin1Style & RULER_STYLE_INVISIBLE) ) 1279cdf0e10cSrcweir { 1280cdf0e10cSrcweir nM1 = mpData->nMargin1+nNullVirOff; 1281cdf0e10cSrcweir if ( mpData->bAutoPageWidth ) 1282cdf0e10cSrcweir { 1283cdf0e10cSrcweir nP1 = nVirLeft; 1284cdf0e10cSrcweir if ( nM1 < nVirLeft ) 1285cdf0e10cSrcweir nP1--; 1286cdf0e10cSrcweir } 1287cdf0e10cSrcweir else 1288cdf0e10cSrcweir nP1 = nNullVirOff-mpData->nNullOff; 1289cdf0e10cSrcweir } 1290cdf0e10cSrcweir else 1291cdf0e10cSrcweir { 1292cdf0e10cSrcweir nM1 = nVirLeft-1; 1293cdf0e10cSrcweir nP1 = nM1; 1294cdf0e10cSrcweir } 1295cdf0e10cSrcweir if ( !(mpData->nMargin2Style & RULER_STYLE_INVISIBLE) ) 1296cdf0e10cSrcweir { 1297cdf0e10cSrcweir nM2 = mpData->nMargin2+nNullVirOff; 1298cdf0e10cSrcweir if ( mpData->bAutoPageWidth ) 1299cdf0e10cSrcweir { 1300cdf0e10cSrcweir nP2 = nVirRight; 1301cdf0e10cSrcweir if ( nM2 > nVirRight ) 1302cdf0e10cSrcweir nP2++; 1303cdf0e10cSrcweir } 1304cdf0e10cSrcweir else 1305cdf0e10cSrcweir nP2 = nNullVirOff-mpData->nNullOff+mpData->nPageWidth; 1306cdf0e10cSrcweir if ( nM2 > nP2 ) 1307cdf0e10cSrcweir nM2 = nP2; 1308cdf0e10cSrcweir } 1309cdf0e10cSrcweir else 1310cdf0e10cSrcweir { 1311cdf0e10cSrcweir nM2 = nVirRight+1; 1312cdf0e10cSrcweir nP2 = nM2; 1313cdf0e10cSrcweir } 1314cdf0e10cSrcweir 1315cdf0e10cSrcweir // Obere/untere Kante ausgeben 1316cdf0e10cSrcweir if ( b3DLook ) 1317cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 1318cdf0e10cSrcweir else 1319cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 1320cdf0e10cSrcweir ImplVDrawLine( nVirLeft, nVirTop, nM1 - 1, nVirTop ); //top left line 1321cdf0e10cSrcweir ImplVDrawLine( nM2 +1, nVirTop, nP2 -1, nVirTop ); //top right line 1322cdf0e10cSrcweir 1323cdf0e10cSrcweir // Jetzt wird zwischen dem Schatten ausgegeben 1324cdf0e10cSrcweir nVirTop++; 1325cdf0e10cSrcweir nVirBottom--; 1326cdf0e10cSrcweir 1327cdf0e10cSrcweir // Margin1, Margin2 und Zwischenraum ausgeben 1328cdf0e10cSrcweir maVirDev.SetLineColor(); 1329cdf0e10cSrcweir if ( b3DLook ) 1330cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); 1331cdf0e10cSrcweir else 1332cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); 1333cdf0e10cSrcweir if ( nM1 > nVirLeft ) 1334cdf0e10cSrcweir ImplVDrawRect( nP1, nVirTop, nM1-1, nVirBottom ); //left gray rectangle 1335cdf0e10cSrcweir if ( nM2 < nP2 ) 1336cdf0e10cSrcweir ImplVDrawRect( nM2+1, nVirTop, nP2, nVirBottom ); //right gray rectangle 1337cdf0e10cSrcweir if ( nM2-nM1 > 0 ) 1338cdf0e10cSrcweir { 1339cdf0e10cSrcweir maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); 1340cdf0e10cSrcweir ImplVDrawRect( nM1, nVirTop, nM2-1, nVirBottom ); //center rectangle 1341cdf0e10cSrcweir } 1342cdf0e10cSrcweir if ( b3DLook ) 1343cdf0e10cSrcweir { 1344cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); 1345cdf0e10cSrcweir if ( nM1 > nVirLeft ) 1346cdf0e10cSrcweir { 1347cdf0e10cSrcweir ImplVDrawLine( nM1-1, nVirTop, nM1-1, nVirBottom );//right line of the left rectangle 1348cdf0e10cSrcweir ImplVDrawLine( nP1, nVirBottom, nM1-1, nVirBottom );//bottom line of the left rectangle 1349cdf0e10cSrcweir if ( nP1 >= nVirLeft ) 1350cdf0e10cSrcweir { 1351cdf0e10cSrcweir ImplVDrawLine( nP1, nVirTop, nP1, nVirBottom );//left line of the left rectangle 1352cdf0e10cSrcweir ImplVDrawLine( nP1, nVirBottom, nP1+1, nVirBottom );//? 1353cdf0e10cSrcweir } 1354cdf0e10cSrcweir } 1355cdf0e10cSrcweir if ( nM2 < nP2 ) 1356cdf0e10cSrcweir { 1357cdf0e10cSrcweir ImplVDrawLine( nM2+1, nVirBottom, nP2-1, nVirBottom );//bottom line of the right rectangle 1358cdf0e10cSrcweir ImplVDrawLine( nM2+1, nVirTop, nM2+1, nVirBottom );//left line of the right rectangle 1359cdf0e10cSrcweir if ( nP2 <= nVirRight+1 ) 1360cdf0e10cSrcweir ImplVDrawLine( nP2-1, nVirTop, nP2-1, nVirBottom );//right line of the right rectangle 1361cdf0e10cSrcweir } 1362cdf0e10cSrcweir } 1363cdf0e10cSrcweir else 1364cdf0e10cSrcweir { 1365cdf0e10cSrcweir maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); 1366cdf0e10cSrcweir if ( nP1 >= nVirLeft ) 1367cdf0e10cSrcweir ImplVDrawLine( nP1, nVirTop, nP1, nVirBottom+1 ); 1368cdf0e10cSrcweir if ( nM1 > nP1 ) 1369cdf0e10cSrcweir ImplVDrawLine( nM1, nVirTop, nM1, nVirBottom ); 1370cdf0e10cSrcweir if ( nM2 < nP2 ) 1371cdf0e10cSrcweir ImplVDrawLine( nM2, nVirTop, nM2, nVirBottom ); 1372cdf0e10cSrcweir if ( nP2 <= nVirRight+1 ) 1373cdf0e10cSrcweir ImplVDrawLine( nP2, nVirTop, nP2, nVirBottom+1 ); 1374cdf0e10cSrcweir } 1375cdf0e10cSrcweir 1376cdf0e10cSrcweir // Lineal-Beschriftung (nur wenn keine Bemassungspfeile) 1377cdf0e10cSrcweir if ( !mpData->pArrows ) 1378cdf0e10cSrcweir { 1379cdf0e10cSrcweir long nMin = nVirLeft; 1380cdf0e10cSrcweir long nMax = nP2; 1381cdf0e10cSrcweir long nStart = mpData->bTextRTL ? mpData->nMargin2 + nNullVirOff : nNullVirOff; 1382cdf0e10cSrcweir long nCenter = nVirTop+((nVirBottom-nVirTop)/2); 1383cdf0e10cSrcweir 1384cdf0e10cSrcweir // Nicht Schatten uebermalen 1385cdf0e10cSrcweir if ( nP1 > nVirLeft ) 1386cdf0e10cSrcweir nMin++; 1387cdf0e10cSrcweir if ( nP2 < nVirRight ) 1388cdf0e10cSrcweir nMax--; 1389cdf0e10cSrcweir 1390cdf0e10cSrcweir // Draw captions 1391cdf0e10cSrcweir ImplDrawTicks( nMin, nMax, nStart, nCenter ); 1392cdf0e10cSrcweir } 1393cdf0e10cSrcweir 1394cdf0e10cSrcweir // Draw borders 1395cdf0e10cSrcweir if ( mpData->pBorders ) 1396cdf0e10cSrcweir ImplDrawBorders( nVirLeft, nP2, nVirTop, nVirBottom ); 1397cdf0e10cSrcweir 1398cdf0e10cSrcweir // Draw indents 1399cdf0e10cSrcweir if ( mpData->pIndents ) 1400cdf0e10cSrcweir ImplDrawIndents( nVirLeft, nP2, nVirTop-1, nVirBottom+1 ); 1401cdf0e10cSrcweir 1402cdf0e10cSrcweir // Tabs 1403cdf0e10cSrcweir if ( mpData->pTabs ) 1404cdf0e10cSrcweir { 1405cdf0e10cSrcweir ImplDrawTabs( nVirLeft, nP2, nVirTop-1, nVirBottom+1 ); 1406cdf0e10cSrcweir } 1407cdf0e10cSrcweir 1408cdf0e10cSrcweir // Bemassungspfeile 1409cdf0e10cSrcweir if ( mpData->pArrows ) 1410cdf0e10cSrcweir ImplDrawArrows( nVirTop+((nVirBottom-nVirTop)/2) ); 1411cdf0e10cSrcweir 1412cdf0e10cSrcweir // Wir haben formatiert 1413cdf0e10cSrcweir mbFormat = sal_False; 1414cdf0e10cSrcweir } 1415cdf0e10cSrcweir 1416cdf0e10cSrcweir // ----------------------------------------------------------------------- 1417cdf0e10cSrcweir 1418cdf0e10cSrcweir void Ruler::ImplInitExtraField( sal_Bool bUpdate ) 1419cdf0e10cSrcweir { 1420cdf0e10cSrcweir // Extra-Field beruecksichtigen 1421cdf0e10cSrcweir if ( mnWinStyle & WB_EXTRAFIELD ) 1422cdf0e10cSrcweir { 1423cdf0e10cSrcweir maExtraRect.Left() = RULER_OFF; 1424cdf0e10cSrcweir maExtraRect.Top() = RULER_OFF; 1425cdf0e10cSrcweir maExtraRect.Right() = RULER_OFF+mnVirHeight-1; 1426cdf0e10cSrcweir maExtraRect.Bottom() = RULER_OFF+mnVirHeight-1; 1427cdf0e10cSrcweir if(mpData->bTextRTL) 1428cdf0e10cSrcweir { 1429cdf0e10cSrcweir Size aWinSize = GetOutputSizePixel(); 1430cdf0e10cSrcweir if(mnWinStyle & WB_HORZ) 1431cdf0e10cSrcweir maExtraRect.Move(aWinSize.Width() - maExtraRect.GetWidth() - maExtraRect.Left(), 0); 1432cdf0e10cSrcweir else 1433cdf0e10cSrcweir maExtraRect.Move(0, aWinSize.Height() - maExtraRect.GetHeight() - maExtraRect.Top()); 1434cdf0e10cSrcweir mnVirOff = 0; 1435cdf0e10cSrcweir } 1436cdf0e10cSrcweir else 1437cdf0e10cSrcweir mnVirOff = maExtraRect.Right()+1; 1438cdf0e10cSrcweir 1439cdf0e10cSrcweir } 1440cdf0e10cSrcweir else 1441cdf0e10cSrcweir { 1442cdf0e10cSrcweir maExtraRect.SetEmpty(); 1443cdf0e10cSrcweir mnVirOff = 0; 1444cdf0e10cSrcweir } 1445cdf0e10cSrcweir 1446cdf0e10cSrcweir if ( bUpdate ) 1447cdf0e10cSrcweir { 1448cdf0e10cSrcweir mbCalc = sal_True; 1449cdf0e10cSrcweir mbFormat = sal_True; 1450cdf0e10cSrcweir Invalidate(); 1451cdf0e10cSrcweir } 1452cdf0e10cSrcweir } 1453cdf0e10cSrcweir 1454cdf0e10cSrcweir // ----------------------------------------------------------------------- 1455cdf0e10cSrcweir 1456cdf0e10cSrcweir void Ruler::ImplDraw() 1457cdf0e10cSrcweir { 1458cdf0e10cSrcweir if ( mbFormat ) 1459cdf0e10cSrcweir ImplFormat(); 1460cdf0e10cSrcweir 1461cdf0e10cSrcweir if ( IsReallyVisible() ) 1462cdf0e10cSrcweir { 1463cdf0e10cSrcweir // Lineal ueber das VirtualDevice ausgeben 1464cdf0e10cSrcweir Point aOffPos; 1465cdf0e10cSrcweir Size aVirDevSize = maVirDev.GetOutputSizePixel(); 1466cdf0e10cSrcweir // Size aVirDevSize2 = maVirDev.GetOutputSizePixel(); 1467cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1468cdf0e10cSrcweir { 1469cdf0e10cSrcweir aOffPos.X() = mnVirOff; 1470cdf0e10cSrcweir if(mpData->bTextRTL) 1471cdf0e10cSrcweir aVirDevSize.Width() -= maExtraRect.GetWidth(); 1472cdf0e10cSrcweir 1473cdf0e10cSrcweir // else 1474cdf0e10cSrcweir // aVirDevSize.Width() -= mnVirOff; 1475cdf0e10cSrcweir aOffPos.Y() = RULER_OFF; 1476cdf0e10cSrcweir } 1477cdf0e10cSrcweir else 1478cdf0e10cSrcweir { 1479cdf0e10cSrcweir aOffPos.X() = RULER_OFF; 1480cdf0e10cSrcweir aOffPos.Y() = mnVirOff; 1481cdf0e10cSrcweir // else 1482cdf0e10cSrcweir // aVirDevSize.Height() -= mnVirOff; 1483cdf0e10cSrcweir } 1484cdf0e10cSrcweir DrawOutDev( aOffPos, aVirDevSize, Point(), aVirDevSize, maVirDev ); 1485cdf0e10cSrcweir 1486cdf0e10cSrcweir // Positionslinien neu malen 1487cdf0e10cSrcweir ImplInvertLines( sal_True ); 1488cdf0e10cSrcweir } 1489cdf0e10cSrcweir } 1490cdf0e10cSrcweir 1491cdf0e10cSrcweir // ----------------------------------------------------------------------- 1492cdf0e10cSrcweir 1493cdf0e10cSrcweir void Ruler::ImplDrawExtra( sal_Bool bPaint ) 1494cdf0e10cSrcweir { 1495cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1496cdf0e10cSrcweir Rectangle aRect = maExtraRect; 1497cdf0e10cSrcweir sal_Bool bEraseRect = sal_False; 1498cdf0e10cSrcweir 1499cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 1500cdf0e10cSrcweir { 1501cdf0e10cSrcweir aRect.Left() += 2; 1502cdf0e10cSrcweir aRect.Top() += 2; 1503cdf0e10cSrcweir aRect.Right() -= 2; 1504cdf0e10cSrcweir aRect.Bottom() -= 2; 1505cdf0e10cSrcweir } 1506cdf0e10cSrcweir else 1507cdf0e10cSrcweir { 1508cdf0e10cSrcweir aRect.Left() += 1; 1509cdf0e10cSrcweir aRect.Top() += 1; 1510cdf0e10cSrcweir aRect.Right() -= 1; 1511cdf0e10cSrcweir aRect.Bottom() -= 1; 1512cdf0e10cSrcweir } 1513cdf0e10cSrcweir 1514cdf0e10cSrcweir if ( !bPaint && !(mnExtraStyle & RULER_STYLE_HIGHLIGHT) ) 1515cdf0e10cSrcweir { 1516cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 1517cdf0e10cSrcweir SetFillColor( rStyleSettings.GetFaceColor() ); 1518cdf0e10cSrcweir else 1519cdf0e10cSrcweir SetFillColor( rStyleSettings.GetWindowColor() ); 1520cdf0e10cSrcweir bEraseRect = sal_True; 1521cdf0e10cSrcweir } 1522cdf0e10cSrcweir else 1523cdf0e10cSrcweir { 1524cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) && (mnExtraStyle & RULER_STYLE_HIGHLIGHT) ) 1525cdf0e10cSrcweir { 1526cdf0e10cSrcweir SetFillColor( rStyleSettings.GetCheckedColor() ); 1527cdf0e10cSrcweir bEraseRect = sal_True; 1528cdf0e10cSrcweir } 1529cdf0e10cSrcweir } 1530cdf0e10cSrcweir 1531cdf0e10cSrcweir if ( bEraseRect ) 1532cdf0e10cSrcweir { 1533cdf0e10cSrcweir SetLineColor(); 1534cdf0e10cSrcweir DrawRect( aRect ); 1535cdf0e10cSrcweir } 1536cdf0e10cSrcweir 1537cdf0e10cSrcweir // Inhalt ausgeben 1538cdf0e10cSrcweir if ( meExtraType == RULER_EXTRA_NULLOFFSET ) 1539cdf0e10cSrcweir { 1540cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 1541cdf0e10cSrcweir SetLineColor( rStyleSettings.GetButtonTextColor() ); 1542cdf0e10cSrcweir else 1543cdf0e10cSrcweir SetLineColor( rStyleSettings.GetWindowTextColor() ); 1544cdf0e10cSrcweir DrawLine( Point( aRect.Left()+1, aRect.Top()+4 ), 1545cdf0e10cSrcweir Point( aRect.Right()-1, aRect.Top()+4 ) ); 1546cdf0e10cSrcweir DrawLine( Point( aRect.Left()+4, aRect.Top()+1 ), 1547cdf0e10cSrcweir Point( aRect.Left()+4, aRect.Bottom()-1 ) ); 1548cdf0e10cSrcweir } 1549cdf0e10cSrcweir else if ( meExtraType == RULER_EXTRA_TAB ) 1550cdf0e10cSrcweir { 1551cdf0e10cSrcweir sal_uInt16 nTabStyle = mnExtraStyle & RULER_TAB_STYLE; 1552cdf0e10cSrcweir if(mpData->bTextRTL) 1553cdf0e10cSrcweir nTabStyle |= RULER_TAB_RTL; 1554cdf0e10cSrcweir Point aCenter = aRect.Center(); 1555cdf0e10cSrcweir Point aDraw(aCenter); 1556cdf0e10cSrcweir ImplCenterTabPos( aDraw, nTabStyle ); 1557cdf0e10cSrcweir WinBits nWinBits = GetStyle(); 1558cdf0e10cSrcweir if(0 == (nWinBits&WB_HORZ) ) 1559cdf0e10cSrcweir { 1560cdf0e10cSrcweir if(0 != (nWinBits&WB_RIGHT_ALIGNED)) 1561cdf0e10cSrcweir aDraw.Y() = 2 * aCenter.Y() - aDraw.Y(); 1562cdf0e10cSrcweir if(mpData->bTextRTL) 1563cdf0e10cSrcweir { 1564cdf0e10cSrcweir long nTemp = aDraw.X(); 1565cdf0e10cSrcweir aDraw.X() = aDraw.Y(); 1566cdf0e10cSrcweir aDraw.Y() = nTemp; 1567cdf0e10cSrcweir } 1568cdf0e10cSrcweir } 1569cdf0e10cSrcweir ImplDrawTab( this, aDraw, nTabStyle ); 1570cdf0e10cSrcweir } 1571cdf0e10cSrcweir 1572cdf0e10cSrcweir if ( (rStyleSettings.GetOptions() & STYLE_OPTION_MONO) && (mnExtraStyle & RULER_STYLE_HIGHLIGHT) ) 1573cdf0e10cSrcweir Invert( aRect ); 1574cdf0e10cSrcweir } 1575cdf0e10cSrcweir 1576cdf0e10cSrcweir // ----------------------------------------------------------------------- 1577cdf0e10cSrcweir 1578cdf0e10cSrcweir void Ruler::ImplUpdate( sal_Bool bMustCalc ) 1579cdf0e10cSrcweir { 1580cdf0e10cSrcweir // Hier schon Linien loeschen, damit Sie vor dem Neuberechnen schon 1581cdf0e10cSrcweir // geloscht sind, da danach die alten Positionen nicht mehr bestimmt 1582cdf0e10cSrcweir // werden koennen 1583cdf0e10cSrcweir if ( !mbFormat ) 1584cdf0e10cSrcweir ImplInvertLines(); 1585cdf0e10cSrcweir 1586cdf0e10cSrcweir // Flags setzen 1587cdf0e10cSrcweir if ( bMustCalc ) 1588cdf0e10cSrcweir mbCalc = sal_True; 1589cdf0e10cSrcweir mbFormat = sal_True; 1590cdf0e10cSrcweir 1591cdf0e10cSrcweir // Wenn wir am Draggen sind, wird nach dem Drag-Handler automatisch 1592cdf0e10cSrcweir // das Lineal neu upgedatet 1593cdf0e10cSrcweir if ( mbDrag ) 1594cdf0e10cSrcweir return; 1595cdf0e10cSrcweir 1596cdf0e10cSrcweir // Gegebenenfalls Update ausloesen 1597cdf0e10cSrcweir if ( IsReallyVisible() && IsUpdateMode() ) 1598cdf0e10cSrcweir { 1599cdf0e10cSrcweir mnUpdateFlags |= RULER_UPDATE_DRAW; 1600cdf0e10cSrcweir if ( !mnUpdateEvtId ) 1601cdf0e10cSrcweir mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); 1602cdf0e10cSrcweir } 1603cdf0e10cSrcweir } 1604cdf0e10cSrcweir 1605cdf0e10cSrcweir // ----------------------------------------------------------------------- 1606cdf0e10cSrcweir 1607cdf0e10cSrcweir sal_Bool Ruler::ImplHitTest( const Point& rPos, ImplRulerHitTest* pHitTest, 1608cdf0e10cSrcweir sal_Bool bRequireStyle, sal_uInt16 nRequiredStyle ) const 1609cdf0e10cSrcweir { 1610cdf0e10cSrcweir sal_uInt16 i; 1611cdf0e10cSrcweir sal_uInt16 nStyle; 1612cdf0e10cSrcweir long nHitBottom; 1613cdf0e10cSrcweir long nX; 1614cdf0e10cSrcweir long nY; 1615cdf0e10cSrcweir long n1; 1616cdf0e10cSrcweir long n2; 1617cdf0e10cSrcweir 1618cdf0e10cSrcweir if ( !mbActive ) 1619cdf0e10cSrcweir return sal_False; 1620cdf0e10cSrcweir 1621cdf0e10cSrcweir // Position ermitteln 1622cdf0e10cSrcweir sal_Bool bIsHori = 0 != (mnWinStyle & WB_HORZ); 1623cdf0e10cSrcweir if ( bIsHori ) 1624cdf0e10cSrcweir { 1625cdf0e10cSrcweir nX = rPos.X(); 1626cdf0e10cSrcweir nY = rPos.Y(); 1627cdf0e10cSrcweir } 1628cdf0e10cSrcweir else 1629cdf0e10cSrcweir { 1630cdf0e10cSrcweir nX = rPos.Y(); 1631cdf0e10cSrcweir nY = rPos.X(); 1632cdf0e10cSrcweir } 1633cdf0e10cSrcweir nHitBottom = mnVirHeight+(RULER_OFF*2); 1634cdf0e10cSrcweir 1635cdf0e10cSrcweir // --> FME 2004-08-05 #i32608# 1636cdf0e10cSrcweir pHitTest->nAryPos = 0; 1637cdf0e10cSrcweir pHitTest->mnDragSize = 0; 1638cdf0e10cSrcweir pHitTest->bSize = sal_False; 1639cdf0e10cSrcweir pHitTest->bSizeBar = sal_False; 1640cdf0e10cSrcweir // <-- 1641cdf0e10cSrcweir 1642cdf0e10cSrcweir // Damit ueberstehende Tabs und Einzuege mit beruecksichtigt werden 1643cdf0e10cSrcweir long nXExtraOff; 1644cdf0e10cSrcweir if ( mpData->pTabs || mpData->pIndents ) 1645cdf0e10cSrcweir nXExtraOff = (mnVirHeight/2) - 4; 1646cdf0e10cSrcweir else 1647cdf0e10cSrcweir nXExtraOff = 0; 1648cdf0e10cSrcweir 1649cdf0e10cSrcweir // Test auf ausserhalb 1650cdf0e10cSrcweir nX -= mnVirOff; 1651cdf0e10cSrcweir long nXTemp = nX; 1652cdf0e10cSrcweir if ( (nX < mpData->nRulVirOff-nXExtraOff) || (nX > mpData->nRulVirOff+mpData->nRulWidth+nXExtraOff) || 1653cdf0e10cSrcweir (nY < 0) || (nY > nHitBottom) ) 1654cdf0e10cSrcweir { 1655cdf0e10cSrcweir pHitTest->nPos = 0; 1656cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_OUTSIDE; 1657cdf0e10cSrcweir return sal_False; 1658cdf0e10cSrcweir } 1659cdf0e10cSrcweir 1660cdf0e10cSrcweir nX -= mpData->nNullVirOff; 1661cdf0e10cSrcweir pHitTest->nPos = nX; 1662cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_DONTKNOW; 1663cdf0e10cSrcweir 1664cdf0e10cSrcweir // Zuerst die Tabs testen 1665cdf0e10cSrcweir Rectangle aRect; 1666cdf0e10cSrcweir if ( mpData->pTabs ) 1667cdf0e10cSrcweir { 1668cdf0e10cSrcweir aRect.Bottom() = nHitBottom; 1669cdf0e10cSrcweir aRect.Top() = aRect.Bottom()-RULER_TAB_HEIGHT-RULER_OFF; 1670cdf0e10cSrcweir 1671cdf0e10cSrcweir for ( i = mpData->nTabs; i; i-- ) 1672cdf0e10cSrcweir { 1673cdf0e10cSrcweir nStyle = mpData->pTabs[i-1].nStyle; 1674cdf0e10cSrcweir if ( !(nStyle & RULER_STYLE_INVISIBLE) ) 1675cdf0e10cSrcweir { 1676cdf0e10cSrcweir nStyle &= RULER_TAB_STYLE; 1677cdf0e10cSrcweir 1678cdf0e10cSrcweir // Default-Tabs werden nur angezeigt 1679cdf0e10cSrcweir if ( nStyle != RULER_TAB_DEFAULT ) 1680cdf0e10cSrcweir { 1681cdf0e10cSrcweir n1 = mpData->pTabs[i-1].nPos; 1682cdf0e10cSrcweir 1683cdf0e10cSrcweir if ( nStyle == RULER_TAB_LEFT ) 1684cdf0e10cSrcweir { 1685cdf0e10cSrcweir aRect.Left() = n1; 1686cdf0e10cSrcweir aRect.Right() = n1+RULER_TAB_WIDTH-1; 1687cdf0e10cSrcweir } 1688cdf0e10cSrcweir else if ( nStyle == RULER_TAB_RIGHT ) 1689cdf0e10cSrcweir { 1690cdf0e10cSrcweir aRect.Right() = n1; 1691cdf0e10cSrcweir aRect.Left() = n1-RULER_TAB_WIDTH-1; 1692cdf0e10cSrcweir } 1693cdf0e10cSrcweir else 1694cdf0e10cSrcweir { 1695cdf0e10cSrcweir aRect.Left() = n1-RULER_TAB_CWIDTH2+1; 1696cdf0e10cSrcweir aRect.Right() = n1-RULER_TAB_CWIDTH2+RULER_TAB_CWIDTH; 1697cdf0e10cSrcweir } 1698cdf0e10cSrcweir 1699cdf0e10cSrcweir if ( aRect.IsInside( Point( nX, nY ) ) ) 1700cdf0e10cSrcweir { 1701cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_TAB; 1702cdf0e10cSrcweir pHitTest->nAryPos = i-1; 1703cdf0e10cSrcweir return sal_True; 1704cdf0e10cSrcweir } 1705cdf0e10cSrcweir } 1706cdf0e10cSrcweir } 1707cdf0e10cSrcweir } 1708cdf0e10cSrcweir } 1709cdf0e10cSrcweir 1710cdf0e10cSrcweir // Dann die Einzuege 1711cdf0e10cSrcweir if ( mpData->pIndents ) 1712cdf0e10cSrcweir { 1713cdf0e10cSrcweir long nIndentHeight = (mnVirHeight/2) - 1; 1714cdf0e10cSrcweir long nIndentWidth2 = nIndentHeight-3; 1715cdf0e10cSrcweir 1716cdf0e10cSrcweir for ( i = mpData->nIndents; i; i-- ) 1717cdf0e10cSrcweir { 1718cdf0e10cSrcweir nStyle = mpData->pIndents[i-1].nStyle; 1719cdf0e10cSrcweir if ( (! bRequireStyle || nStyle == nRequiredStyle) && 1720cdf0e10cSrcweir !(nStyle & RULER_STYLE_INVISIBLE) ) 1721cdf0e10cSrcweir { 1722cdf0e10cSrcweir nStyle &= RULER_INDENT_STYLE; 1723cdf0e10cSrcweir n1 = mpData->pIndents[i-1].nPos; 1724cdf0e10cSrcweir 1725cdf0e10cSrcweir if ( (nStyle == RULER_INDENT_BOTTOM) ^ (!bIsHori) ) 1726cdf0e10cSrcweir { 1727cdf0e10cSrcweir aRect.Left() = n1-nIndentWidth2; 1728cdf0e10cSrcweir aRect.Right() = n1+nIndentWidth2; 1729cdf0e10cSrcweir aRect.Top() = nHitBottom-nIndentHeight-RULER_OFF+1; 1730cdf0e10cSrcweir aRect.Bottom() = nHitBottom; 1731cdf0e10cSrcweir } 1732cdf0e10cSrcweir else 1733cdf0e10cSrcweir { 1734cdf0e10cSrcweir aRect.Left() = n1-nIndentWidth2; 1735cdf0e10cSrcweir aRect.Right() = n1+nIndentWidth2; 1736cdf0e10cSrcweir aRect.Top() = 0; 1737cdf0e10cSrcweir aRect.Bottom() = nIndentHeight+RULER_OFF-1; 1738cdf0e10cSrcweir } 1739cdf0e10cSrcweir 1740cdf0e10cSrcweir if ( aRect.IsInside( Point( nX, nY ) ) ) 1741cdf0e10cSrcweir { 1742cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_INDENT; 1743cdf0e10cSrcweir pHitTest->nAryPos = i-1; 1744cdf0e10cSrcweir return sal_True; 1745cdf0e10cSrcweir } 1746cdf0e10cSrcweir } 1747cdf0e10cSrcweir } 1748cdf0e10cSrcweir } 1749cdf0e10cSrcweir 1750cdf0e10cSrcweir // Jetzt zaehlt nichts mehr, was links oder rechts uebersteht 1751cdf0e10cSrcweir if ( (nXTemp < mpData->nRulVirOff) || (nXTemp > mpData->nRulVirOff+mpData->nRulWidth) ) 1752cdf0e10cSrcweir { 1753cdf0e10cSrcweir pHitTest->nPos = 0; 1754cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_OUTSIDE; 1755cdf0e10cSrcweir return sal_False; 1756cdf0e10cSrcweir } 1757cdf0e10cSrcweir 1758cdf0e10cSrcweir // Danach die Spalten testen 1759cdf0e10cSrcweir int nBorderTolerance = 1; 1760cdf0e10cSrcweir if(pHitTest->bExpandTest) 1761cdf0e10cSrcweir { 1762cdf0e10cSrcweir nBorderTolerance++; 1763cdf0e10cSrcweir } 1764cdf0e10cSrcweir 1765cdf0e10cSrcweir for ( i = mpData->nBorders; i; i-- ) 1766cdf0e10cSrcweir { 1767cdf0e10cSrcweir n1 = mpData->pBorders[i-1].nPos; 1768cdf0e10cSrcweir n2 = n1 + mpData->pBorders[i-1].nWidth; 1769cdf0e10cSrcweir 1770cdf0e10cSrcweir // Spalten werden mit mindestens 3 Pixel breite gezeichnet 1771cdf0e10cSrcweir if ( !mpData->pBorders[i-1].nWidth ) 1772cdf0e10cSrcweir { 1773cdf0e10cSrcweir n1 -= nBorderTolerance; 1774cdf0e10cSrcweir n2 += nBorderTolerance; 1775cdf0e10cSrcweir 1776cdf0e10cSrcweir } 1777cdf0e10cSrcweir 1778cdf0e10cSrcweir if ( (nX >= n1) && (nX <= n2) ) 1779cdf0e10cSrcweir { 1780cdf0e10cSrcweir nStyle = mpData->pBorders[i-1].nStyle; 1781cdf0e10cSrcweir if ( !(nStyle & RULER_STYLE_INVISIBLE) ) 1782cdf0e10cSrcweir { 1783cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_BORDER; 1784cdf0e10cSrcweir pHitTest->nAryPos = i-1; 1785cdf0e10cSrcweir 1786cdf0e10cSrcweir if ( !(nStyle & RULER_BORDER_SIZEABLE) ) 1787cdf0e10cSrcweir { 1788cdf0e10cSrcweir if ( nStyle & RULER_BORDER_MOVEABLE ) 1789cdf0e10cSrcweir { 1790cdf0e10cSrcweir pHitTest->bSizeBar = sal_True; 1791cdf0e10cSrcweir pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE; 1792cdf0e10cSrcweir } 1793cdf0e10cSrcweir } 1794cdf0e10cSrcweir else 1795cdf0e10cSrcweir { 1796cdf0e10cSrcweir long nMOff = RULER_MOUSE_BORDERWIDTH; 1797cdf0e10cSrcweir while ( nMOff*2 >= (n2-n1-RULER_MOUSE_BORDERMOVE) ) 1798cdf0e10cSrcweir { 1799cdf0e10cSrcweir if ( nMOff < 2 ) 1800cdf0e10cSrcweir { 1801cdf0e10cSrcweir nMOff = 0; 1802cdf0e10cSrcweir break; 1803cdf0e10cSrcweir } 1804cdf0e10cSrcweir else 1805cdf0e10cSrcweir nMOff--; 1806cdf0e10cSrcweir } 1807cdf0e10cSrcweir 1808cdf0e10cSrcweir if ( nX <= n1+nMOff ) 1809cdf0e10cSrcweir { 1810cdf0e10cSrcweir pHitTest->bSize = sal_True; 1811cdf0e10cSrcweir pHitTest->mnDragSize = RULER_DRAGSIZE_1; 1812cdf0e10cSrcweir } 1813cdf0e10cSrcweir else if ( nX >= n2-nMOff ) 1814cdf0e10cSrcweir { 1815cdf0e10cSrcweir pHitTest->bSize = sal_True; 1816cdf0e10cSrcweir pHitTest->mnDragSize = RULER_DRAGSIZE_2; 1817cdf0e10cSrcweir } 1818cdf0e10cSrcweir else 1819cdf0e10cSrcweir { 1820cdf0e10cSrcweir if ( nStyle & RULER_BORDER_MOVEABLE ) 1821cdf0e10cSrcweir { 1822cdf0e10cSrcweir pHitTest->bSizeBar = sal_True; 1823cdf0e10cSrcweir pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE; 1824cdf0e10cSrcweir } 1825cdf0e10cSrcweir } 1826cdf0e10cSrcweir } 1827cdf0e10cSrcweir 1828cdf0e10cSrcweir return sal_True; 1829cdf0e10cSrcweir } 1830cdf0e10cSrcweir } 1831cdf0e10cSrcweir } 1832cdf0e10cSrcweir 1833cdf0e10cSrcweir // Und zum Schluss die Raender 1834cdf0e10cSrcweir int nMarginTolerance = pHitTest->bExpandTest ? nBorderTolerance : RULER_MOUSE_MARGINWIDTH; 1835cdf0e10cSrcweir 1836cdf0e10cSrcweir if ( (mpData->nMargin1Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE ) 1837cdf0e10cSrcweir { 1838cdf0e10cSrcweir n1 = mpData->nMargin1; 1839cdf0e10cSrcweir if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) ) 1840cdf0e10cSrcweir { 1841cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_MARGIN1; 1842cdf0e10cSrcweir pHitTest->bSize = sal_True; 1843cdf0e10cSrcweir return sal_True; 1844cdf0e10cSrcweir } 1845cdf0e10cSrcweir } 1846cdf0e10cSrcweir if ( (mpData->nMargin2Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE ) 1847cdf0e10cSrcweir { 1848cdf0e10cSrcweir n1 = mpData->nMargin2; 1849cdf0e10cSrcweir if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) ) 1850cdf0e10cSrcweir { 1851cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_MARGIN2; 1852cdf0e10cSrcweir pHitTest->bSize = sal_True; 1853cdf0e10cSrcweir return sal_True; 1854cdf0e10cSrcweir } 1855cdf0e10cSrcweir } 1856cdf0e10cSrcweir 1857cdf0e10cSrcweir // Jetzt nocheinmal die Tabs testen, nur mit etwas mehr spielraum 1858cdf0e10cSrcweir if ( mpData->pTabs ) 1859cdf0e10cSrcweir { 1860cdf0e10cSrcweir aRect.Top() = RULER_OFF; 1861cdf0e10cSrcweir aRect.Bottom() = nHitBottom; 1862cdf0e10cSrcweir 1863cdf0e10cSrcweir for ( i = mpData->nTabs; i; i-- ) 1864cdf0e10cSrcweir { 1865cdf0e10cSrcweir nStyle = mpData->pTabs[i-1].nStyle; 1866cdf0e10cSrcweir if ( !(nStyle & RULER_STYLE_INVISIBLE) ) 1867cdf0e10cSrcweir { 1868cdf0e10cSrcweir nStyle &= RULER_TAB_STYLE; 1869cdf0e10cSrcweir 1870cdf0e10cSrcweir // Default-Tabs werden nur angezeigt 1871cdf0e10cSrcweir if ( nStyle != RULER_TAB_DEFAULT ) 1872cdf0e10cSrcweir { 1873cdf0e10cSrcweir n1 = mpData->pTabs[i-1].nPos; 1874cdf0e10cSrcweir 1875cdf0e10cSrcweir if ( nStyle == RULER_TAB_LEFT ) 1876cdf0e10cSrcweir { 1877cdf0e10cSrcweir aRect.Left() = n1; 1878cdf0e10cSrcweir aRect.Right() = n1+RULER_TAB_WIDTH-1; 1879cdf0e10cSrcweir } 1880cdf0e10cSrcweir else if ( nStyle == RULER_TAB_RIGHT ) 1881cdf0e10cSrcweir { 1882cdf0e10cSrcweir aRect.Right() = n1; 1883cdf0e10cSrcweir aRect.Left() = n1-RULER_TAB_WIDTH-1; 1884cdf0e10cSrcweir } 1885cdf0e10cSrcweir else 1886cdf0e10cSrcweir { 1887cdf0e10cSrcweir aRect.Left() = n1-RULER_TAB_CWIDTH2+1; 1888cdf0e10cSrcweir aRect.Right() = n1-RULER_TAB_CWIDTH2+RULER_TAB_CWIDTH; 1889cdf0e10cSrcweir } 1890cdf0e10cSrcweir 1891cdf0e10cSrcweir aRect.Left()--; 1892cdf0e10cSrcweir aRect.Right()++; 1893cdf0e10cSrcweir 1894cdf0e10cSrcweir if ( aRect.IsInside( Point( nX, nY ) ) ) 1895cdf0e10cSrcweir { 1896cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_TAB; 1897cdf0e10cSrcweir pHitTest->nAryPos = i-1; 1898cdf0e10cSrcweir return sal_True; 1899cdf0e10cSrcweir } 1900cdf0e10cSrcweir } 1901cdf0e10cSrcweir } 1902cdf0e10cSrcweir } 1903cdf0e10cSrcweir } 1904cdf0e10cSrcweir 1905cdf0e10cSrcweir return sal_False; 1906cdf0e10cSrcweir } 1907cdf0e10cSrcweir 1908cdf0e10cSrcweir // ----------------------------------------------------------------------- 1909cdf0e10cSrcweir 1910cdf0e10cSrcweir sal_Bool Ruler::ImplDocHitTest( const Point& rPos, RulerType eDragType, 1911cdf0e10cSrcweir ImplRulerHitTest* pHitTest ) const 1912cdf0e10cSrcweir { 1913cdf0e10cSrcweir Point aPos = rPos; 1914cdf0e10cSrcweir sal_Bool bRequiredStyle = sal_False; 1915cdf0e10cSrcweir sal_uInt16 nRequiredStyle = 0; 1916cdf0e10cSrcweir 1917cdf0e10cSrcweir if (eDragType == RULER_TYPE_INDENT) 1918cdf0e10cSrcweir { 1919cdf0e10cSrcweir bRequiredStyle = sal_True; 1920cdf0e10cSrcweir nRequiredStyle = RULER_INDENT_BOTTOM; 1921cdf0e10cSrcweir } 1922cdf0e10cSrcweir 1923cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1924cdf0e10cSrcweir aPos.X() += mnWinOff; 1925cdf0e10cSrcweir else 1926cdf0e10cSrcweir aPos.Y() += mnWinOff; 1927cdf0e10cSrcweir 1928cdf0e10cSrcweir if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_DONTKNOW) ) 1929cdf0e10cSrcweir { 1930cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1931cdf0e10cSrcweir aPos.Y() = RULER_OFF+1; 1932cdf0e10cSrcweir else 1933cdf0e10cSrcweir aPos.X() = RULER_OFF+1; 1934cdf0e10cSrcweir 1935cdf0e10cSrcweir // HitTest durchfuehren 1936cdf0e10cSrcweir if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) ) 1937cdf0e10cSrcweir { 1938cdf0e10cSrcweir if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) ) 1939cdf0e10cSrcweir return sal_True; 1940cdf0e10cSrcweir } 1941cdf0e10cSrcweir } 1942cdf0e10cSrcweir 1943cdf0e10cSrcweir if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_TAB) || 1944cdf0e10cSrcweir (eDragType == RULER_TYPE_DONTKNOW) ) 1945cdf0e10cSrcweir { 1946cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1947cdf0e10cSrcweir aPos.Y() = mnHeight-RULER_OFF-1; 1948cdf0e10cSrcweir else 1949cdf0e10cSrcweir aPos.X() = mnWidth-RULER_OFF-1; 1950cdf0e10cSrcweir 1951cdf0e10cSrcweir // HitTest durchfuehren 1952cdf0e10cSrcweir if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) ) 1953cdf0e10cSrcweir { 1954cdf0e10cSrcweir if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) ) 1955cdf0e10cSrcweir return sal_True; 1956cdf0e10cSrcweir } 1957cdf0e10cSrcweir } 1958cdf0e10cSrcweir 1959cdf0e10cSrcweir if ( (eDragType == RULER_TYPE_MARGIN1) || (eDragType == RULER_TYPE_MARGIN2) || 1960cdf0e10cSrcweir (eDragType == RULER_TYPE_BORDER) || (eDragType == RULER_TYPE_DONTKNOW) ) 1961cdf0e10cSrcweir { 1962cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 1963cdf0e10cSrcweir aPos.Y() = RULER_OFF + (mnVirHeight/2); 1964cdf0e10cSrcweir else 1965cdf0e10cSrcweir aPos.X() = RULER_OFF + (mnVirHeight/2); 1966cdf0e10cSrcweir 1967cdf0e10cSrcweir // HitTest durchfuehren 1968cdf0e10cSrcweir if ( ImplHitTest( aPos, pHitTest ) ) 1969cdf0e10cSrcweir { 1970cdf0e10cSrcweir if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) ) 1971cdf0e10cSrcweir return sal_True; 1972cdf0e10cSrcweir } 1973cdf0e10cSrcweir } 1974cdf0e10cSrcweir 1975cdf0e10cSrcweir // Auf DontKnow setzen 1976cdf0e10cSrcweir pHitTest->eType = RULER_TYPE_DONTKNOW; 1977cdf0e10cSrcweir 1978cdf0e10cSrcweir return sal_False; 1979cdf0e10cSrcweir } 1980cdf0e10cSrcweir 1981cdf0e10cSrcweir // ----------------------------------------------------------------------- 1982cdf0e10cSrcweir 1983cdf0e10cSrcweir sal_Bool Ruler::ImplStartDrag( ImplRulerHitTest* pHitTest, sal_uInt16 nModifier ) 1984cdf0e10cSrcweir { 1985cdf0e10cSrcweir // Wenn eine Spalte angeklick wurde, die weder verschiebar noch 1986cdf0e10cSrcweir // in der Groesse aenderbar ist, brauchen wir auch kein Drag ausloesen 1987cdf0e10cSrcweir if ( (pHitTest->eType == RULER_TYPE_BORDER) && 1988cdf0e10cSrcweir !pHitTest->bSize && !pHitTest->bSizeBar ) 1989cdf0e10cSrcweir return sal_False; 1990cdf0e10cSrcweir 1991cdf0e10cSrcweir // Dragdaten setzen 1992cdf0e10cSrcweir meDragType = pHitTest->eType; 1993cdf0e10cSrcweir mnDragPos = pHitTest->nPos; 1994cdf0e10cSrcweir mnDragAryPos = pHitTest->nAryPos; 1995cdf0e10cSrcweir mnDragSize = pHitTest->mnDragSize; 1996cdf0e10cSrcweir mnDragModifier = nModifier; 1997cdf0e10cSrcweir *mpDragData = *mpSaveData; 1998cdf0e10cSrcweir mpData = mpDragData; 1999cdf0e10cSrcweir 2000cdf0e10cSrcweir // Handler rufen 2001cdf0e10cSrcweir if ( StartDrag() ) 2002cdf0e10cSrcweir { 2003cdf0e10cSrcweir // Wenn der Handler das Draggen erlaubt, dann das Draggen 2004cdf0e10cSrcweir // initialisieren 2005cdf0e10cSrcweir ImplInvertLines(); 2006cdf0e10cSrcweir mbDrag = sal_True; 2007cdf0e10cSrcweir mnStartDragPos = mnDragPos; 2008cdf0e10cSrcweir StartTracking(); 2009cdf0e10cSrcweir return sal_True; 2010cdf0e10cSrcweir } 2011cdf0e10cSrcweir else 2012cdf0e10cSrcweir { 2013cdf0e10cSrcweir // Ansonsten muessen wir die Daten zuruecksetzen 2014cdf0e10cSrcweir meDragType = RULER_TYPE_DONTKNOW; 2015cdf0e10cSrcweir mnDragPos = 0; 2016cdf0e10cSrcweir mnDragAryPos = 0; 2017cdf0e10cSrcweir mnDragSize = 0; 2018cdf0e10cSrcweir mnDragModifier = 0; 2019cdf0e10cSrcweir mpData = mpSaveData; 2020cdf0e10cSrcweir } 2021cdf0e10cSrcweir 2022cdf0e10cSrcweir return sal_False; 2023cdf0e10cSrcweir } 2024cdf0e10cSrcweir 2025cdf0e10cSrcweir // ----------------------------------------------------------------------- 2026cdf0e10cSrcweir 2027cdf0e10cSrcweir void Ruler::ImplDrag( const Point& rPos ) 2028cdf0e10cSrcweir { 2029cdf0e10cSrcweir long nX; 2030cdf0e10cSrcweir long nY; 2031cdf0e10cSrcweir long nOutHeight; 2032cdf0e10cSrcweir 2033cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2034cdf0e10cSrcweir { 2035cdf0e10cSrcweir nX = rPos.X(); 2036cdf0e10cSrcweir nY = rPos.Y(); 2037cdf0e10cSrcweir nOutHeight = mnHeight; 2038cdf0e10cSrcweir } 2039cdf0e10cSrcweir else 2040cdf0e10cSrcweir { 2041cdf0e10cSrcweir nX = rPos.Y(); 2042cdf0e10cSrcweir nY = rPos.X(); 2043cdf0e10cSrcweir nOutHeight = mnWidth; 2044cdf0e10cSrcweir } 2045cdf0e10cSrcweir 2046cdf0e10cSrcweir // X berechnen und einpassen 2047cdf0e10cSrcweir nX -= mnVirOff; 2048cdf0e10cSrcweir if ( nX < mpData->nRulVirOff ) 2049cdf0e10cSrcweir { 2050cdf0e10cSrcweir nX = mpData->nRulVirOff; 2051cdf0e10cSrcweir mnDragScroll = RULER_SCROLL_1; 2052cdf0e10cSrcweir } 2053cdf0e10cSrcweir else if ( nX > mpData->nRulVirOff+mpData->nRulWidth ) 2054cdf0e10cSrcweir { 2055cdf0e10cSrcweir nX = mpData->nRulVirOff+mpData->nRulWidth; 2056cdf0e10cSrcweir mnDragScroll = RULER_SCROLL_2; 2057cdf0e10cSrcweir } 2058cdf0e10cSrcweir nX -= mpData->nNullVirOff; 2059cdf0e10cSrcweir 2060cdf0e10cSrcweir // Wenn oberhalb oder links vom Lineal, dann alte Werte 2061cdf0e10cSrcweir mbDragDelete = sal_False; 2062cdf0e10cSrcweir if ( nY < 0 ) 2063cdf0e10cSrcweir { 2064cdf0e10cSrcweir if ( !mbDragCanceled ) 2065cdf0e10cSrcweir { 2066cdf0e10cSrcweir // Daten wiederherstellen 2067cdf0e10cSrcweir mbDragCanceled = sal_True; 2068cdf0e10cSrcweir ImplRulerData aTempData; 2069cdf0e10cSrcweir aTempData = *mpDragData; 2070cdf0e10cSrcweir *mpDragData = *mpSaveData; 2071cdf0e10cSrcweir mbCalc = sal_True; 2072cdf0e10cSrcweir mbFormat = sal_True; 2073cdf0e10cSrcweir 2074cdf0e10cSrcweir // Handler rufen 2075cdf0e10cSrcweir mnDragPos = mnStartDragPos; 2076cdf0e10cSrcweir Drag(); 2077cdf0e10cSrcweir 2078cdf0e10cSrcweir // Und neu ausgeben (zeitverzoegert) 2079cdf0e10cSrcweir /* 2080cdf0e10cSrcweir mnUpdateFlags |= RULER_UPDATE_DRAW; 2081cdf0e10cSrcweir if ( mnUpdateEvtId ) 2082cdf0e10cSrcweir Application::RemoveUserEvent( mnUpdateEvtId ); 2083cdf0e10cSrcweir mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); 2084cdf0e10cSrcweir */ 2085cdf0e10cSrcweir ImplDraw(); 2086cdf0e10cSrcweir 2087cdf0e10cSrcweir // Daten wieder wie vor dem Cancel herstellen 2088cdf0e10cSrcweir *mpDragData = aTempData; 2089cdf0e10cSrcweir } 2090cdf0e10cSrcweir } 2091cdf0e10cSrcweir else 2092cdf0e10cSrcweir { 2093cdf0e10cSrcweir mbDragCanceled = sal_False; 2094cdf0e10cSrcweir 2095cdf0e10cSrcweir // +2, damit nicht so schnell die Tabs geloescht werden 2096cdf0e10cSrcweir if ( nY > nOutHeight+2 ) 2097cdf0e10cSrcweir mbDragDelete = sal_True; 2098cdf0e10cSrcweir 2099cdf0e10cSrcweir mnDragPos = nX; 2100cdf0e10cSrcweir 2101cdf0e10cSrcweir // Handler rufen 2102cdf0e10cSrcweir Drag(); 2103cdf0e10cSrcweir 2104cdf0e10cSrcweir // Und neu ausgeben 2105cdf0e10cSrcweir if ( mbFormat ) 2106cdf0e10cSrcweir ImplDraw(); 2107cdf0e10cSrcweir } 2108cdf0e10cSrcweir 2109cdf0e10cSrcweir mnDragScroll = 0; 2110cdf0e10cSrcweir } 2111cdf0e10cSrcweir 2112cdf0e10cSrcweir // ----------------------------------------------------------------------- 2113cdf0e10cSrcweir 2114cdf0e10cSrcweir void Ruler::ImplEndDrag() 2115cdf0e10cSrcweir { 2116cdf0e10cSrcweir // Werte uebernehmen 2117cdf0e10cSrcweir if ( mbDragCanceled ) 2118cdf0e10cSrcweir *mpDragData = *mpSaveData; 2119cdf0e10cSrcweir else 2120cdf0e10cSrcweir *mpSaveData = *mpDragData; 2121cdf0e10cSrcweir mpData = mpSaveData; 2122cdf0e10cSrcweir mbDrag = sal_False; 2123cdf0e10cSrcweir 2124cdf0e10cSrcweir // Handler rufen 2125cdf0e10cSrcweir EndDrag(); 2126cdf0e10cSrcweir 2127cdf0e10cSrcweir // Drag-Werte zuruecksetzen 2128cdf0e10cSrcweir meDragType = RULER_TYPE_DONTKNOW; 2129cdf0e10cSrcweir mnDragPos = 0; 2130cdf0e10cSrcweir mnDragAryPos = 0; 2131cdf0e10cSrcweir mnDragSize = 0; 2132cdf0e10cSrcweir mbDragCanceled = sal_False; 2133cdf0e10cSrcweir mbDragDelete = sal_False; 2134cdf0e10cSrcweir mnDragModifier = 0; 2135cdf0e10cSrcweir mnDragScroll = 0; 2136cdf0e10cSrcweir mnStartDragPos = 0; 2137cdf0e10cSrcweir 2138cdf0e10cSrcweir // Und neu ausgeben 2139cdf0e10cSrcweir ImplDraw(); 2140cdf0e10cSrcweir } 2141cdf0e10cSrcweir 2142cdf0e10cSrcweir // ----------------------------------------------------------------------- 2143cdf0e10cSrcweir 2144cdf0e10cSrcweir IMPL_LINK( Ruler, ImplUpdateHdl, void*, EMPTYARG ) 2145cdf0e10cSrcweir { 2146cdf0e10cSrcweir mnUpdateEvtId = 0; 2147cdf0e10cSrcweir 2148cdf0e10cSrcweir // Feststellen, was upgedatet werden muss 2149cdf0e10cSrcweir if ( mnUpdateFlags & RULER_UPDATE_DRAW ) 2150cdf0e10cSrcweir { 2151cdf0e10cSrcweir mnUpdateFlags = 0; 2152cdf0e10cSrcweir ImplDraw(); 2153cdf0e10cSrcweir } 2154cdf0e10cSrcweir else if ( mnUpdateFlags & RULER_UPDATE_LINES ) 2155cdf0e10cSrcweir { 2156cdf0e10cSrcweir mnUpdateFlags = 0; 2157cdf0e10cSrcweir ImplInvertLines(); 2158cdf0e10cSrcweir } 2159cdf0e10cSrcweir 2160cdf0e10cSrcweir return 0; 2161cdf0e10cSrcweir } 2162cdf0e10cSrcweir 2163cdf0e10cSrcweir // ----------------------------------------------------------------------- 2164cdf0e10cSrcweir 2165cdf0e10cSrcweir void Ruler::MouseButtonDown( const MouseEvent& rMEvt ) 2166cdf0e10cSrcweir { 2167cdf0e10cSrcweir if ( rMEvt.IsLeft() && !IsTracking() ) 2168cdf0e10cSrcweir { 2169cdf0e10cSrcweir Point aMousePos = rMEvt.GetPosPixel(); 2170cdf0e10cSrcweir sal_uInt16 nMouseClicks = rMEvt.GetClicks(); 2171cdf0e10cSrcweir sal_uInt16 nMouseModifier = rMEvt.GetModifier(); 2172cdf0e10cSrcweir 2173cdf0e10cSrcweir // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten 2174cdf0e10cSrcweir // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) 2175cdf0e10cSrcweir if ( mbFormat ) 2176cdf0e10cSrcweir { 2177cdf0e10cSrcweir ImplDraw(); 2178cdf0e10cSrcweir mnUpdateFlags &= ~RULER_UPDATE_DRAW; 2179cdf0e10cSrcweir } 2180cdf0e10cSrcweir 2181cdf0e10cSrcweir if ( maExtraRect.IsInside( aMousePos ) ) 2182cdf0e10cSrcweir { 2183cdf0e10cSrcweir mnExtraClicks = nMouseClicks; 2184cdf0e10cSrcweir mnExtraModifier = nMouseModifier; 2185cdf0e10cSrcweir ExtraDown(); 2186cdf0e10cSrcweir mnExtraClicks = 0; 2187cdf0e10cSrcweir mnExtraModifier = 0; 2188cdf0e10cSrcweir } 2189cdf0e10cSrcweir else 2190cdf0e10cSrcweir { 2191cdf0e10cSrcweir ImplRulerHitTest aHitTest; 2192cdf0e10cSrcweir 2193cdf0e10cSrcweir if ( nMouseClicks == 1 ) 2194cdf0e10cSrcweir { 2195cdf0e10cSrcweir if ( ImplHitTest( aMousePos, &aHitTest ) ) 2196cdf0e10cSrcweir ImplStartDrag( &aHitTest, nMouseModifier ); 2197cdf0e10cSrcweir else 2198cdf0e10cSrcweir { 2199cdf0e10cSrcweir // Position innerhalb des Lineal-Bereiches 2200cdf0e10cSrcweir if ( aHitTest.eType == RULER_TYPE_DONTKNOW ) 2201cdf0e10cSrcweir { 2202cdf0e10cSrcweir mnDragPos = aHitTest.nPos; 2203cdf0e10cSrcweir Click(); 2204cdf0e10cSrcweir mnDragPos = 0; 2205cdf0e10cSrcweir 2206cdf0e10cSrcweir // Nocheinmal HitTest durchfuehren, da durch den Click 2207cdf0e10cSrcweir // zum Beispiel ein neuer Tab gesetzt werden konnte 2208cdf0e10cSrcweir if ( ImplHitTest( aMousePos, &aHitTest ) ) 2209cdf0e10cSrcweir ImplStartDrag( &aHitTest, nMouseModifier ); 2210cdf0e10cSrcweir } 2211cdf0e10cSrcweir } 2212cdf0e10cSrcweir } 2213cdf0e10cSrcweir else 2214cdf0e10cSrcweir { 2215cdf0e10cSrcweir if ( ImplHitTest( aMousePos, &aHitTest ) ) 2216cdf0e10cSrcweir { 2217cdf0e10cSrcweir mnDragPos = aHitTest.nPos; 2218cdf0e10cSrcweir mnDragAryPos = aHitTest.nAryPos; 2219cdf0e10cSrcweir } 2220cdf0e10cSrcweir meDragType = aHitTest.eType; 2221cdf0e10cSrcweir 2222cdf0e10cSrcweir DoubleClick(); 2223cdf0e10cSrcweir 2224cdf0e10cSrcweir meDragType = RULER_TYPE_DONTKNOW; 2225cdf0e10cSrcweir mnDragPos = 0; 2226cdf0e10cSrcweir mnDragAryPos = 0; 2227cdf0e10cSrcweir } 2228cdf0e10cSrcweir } 2229cdf0e10cSrcweir } 2230cdf0e10cSrcweir } 2231cdf0e10cSrcweir 2232cdf0e10cSrcweir // ----------------------------------------------------------------------- 2233cdf0e10cSrcweir 2234cdf0e10cSrcweir void Ruler::MouseMove( const MouseEvent& rMEvt ) 2235cdf0e10cSrcweir { 2236cdf0e10cSrcweir PointerStyle ePtrStyle = POINTER_ARROW; 2237cdf0e10cSrcweir 2238cdf0e10cSrcweir // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten 2239cdf0e10cSrcweir // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) 2240cdf0e10cSrcweir if ( mbFormat ) 2241cdf0e10cSrcweir { 2242cdf0e10cSrcweir ImplDraw(); 2243cdf0e10cSrcweir mnUpdateFlags &= ~RULER_UPDATE_DRAW; 2244cdf0e10cSrcweir } 2245cdf0e10cSrcweir 2246cdf0e10cSrcweir ImplRulerHitTest aHitTest; 2247cdf0e10cSrcweir if ( ImplHitTest( rMEvt.GetPosPixel(), &aHitTest ) ) 2248cdf0e10cSrcweir { 2249cdf0e10cSrcweir if ( aHitTest.bSize ) 2250cdf0e10cSrcweir { 2251cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2252cdf0e10cSrcweir ePtrStyle = POINTER_ESIZE; 2253cdf0e10cSrcweir else 2254cdf0e10cSrcweir ePtrStyle = POINTER_SSIZE; 2255cdf0e10cSrcweir } 2256cdf0e10cSrcweir else if ( aHitTest.bSizeBar ) 2257cdf0e10cSrcweir { 2258cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2259cdf0e10cSrcweir ePtrStyle = POINTER_HSIZEBAR; 2260cdf0e10cSrcweir else 2261cdf0e10cSrcweir ePtrStyle = POINTER_VSIZEBAR; 2262cdf0e10cSrcweir } 2263cdf0e10cSrcweir } 2264cdf0e10cSrcweir 2265cdf0e10cSrcweir SetPointer( Pointer( ePtrStyle ) ); 2266cdf0e10cSrcweir } 2267cdf0e10cSrcweir 2268cdf0e10cSrcweir // ----------------------------------------------------------------------- 2269cdf0e10cSrcweir 2270cdf0e10cSrcweir void Ruler::Tracking( const TrackingEvent& rTEvt ) 2271cdf0e10cSrcweir { 2272cdf0e10cSrcweir if ( rTEvt.IsTrackingEnded() ) 2273cdf0e10cSrcweir { 2274cdf0e10cSrcweir // Bei Abbruch, den alten Status wieder herstellen 2275cdf0e10cSrcweir if ( rTEvt.IsTrackingCanceled() ) 2276cdf0e10cSrcweir { 2277cdf0e10cSrcweir mbDragCanceled = sal_True; 2278cdf0e10cSrcweir mbFormat = sal_True; 2279cdf0e10cSrcweir } 2280cdf0e10cSrcweir 2281cdf0e10cSrcweir ImplEndDrag(); 2282cdf0e10cSrcweir } 2283cdf0e10cSrcweir else 2284cdf0e10cSrcweir ImplDrag( rTEvt.GetMouseEvent().GetPosPixel() ); 2285cdf0e10cSrcweir } 2286cdf0e10cSrcweir 2287cdf0e10cSrcweir // ----------------------------------------------------------------------- 2288cdf0e10cSrcweir 2289cdf0e10cSrcweir void Ruler::Paint( const Rectangle& ) 2290cdf0e10cSrcweir { 2291cdf0e10cSrcweir ImplDraw(); 2292cdf0e10cSrcweir 2293cdf0e10cSrcweir const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 2294cdf0e10cSrcweir 2295cdf0e10cSrcweir // Extra-Field beruecksichtigen 2296cdf0e10cSrcweir if ( mnWinStyle & WB_EXTRAFIELD ) 2297cdf0e10cSrcweir { 2298cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 2299cdf0e10cSrcweir { 2300cdf0e10cSrcweir SetLineColor( rStyleSettings.GetShadowColor() ); 2301cdf0e10cSrcweir DrawLine( Point( maExtraRect.Left(), maExtraRect.Top() ), 2302cdf0e10cSrcweir Point( maExtraRect.Right()-1, maExtraRect.Top() ) ); 2303cdf0e10cSrcweir DrawLine( Point( maExtraRect.Left(), maExtraRect.Top() ), 2304cdf0e10cSrcweir Point( maExtraRect.Left(), maExtraRect.Bottom()-1 ) ); 2305cdf0e10cSrcweir DrawLine( Point( maExtraRect.Left(), maExtraRect.Bottom()-1 ), 2306cdf0e10cSrcweir Point( maExtraRect.Right()-1, maExtraRect.Bottom()-1 ) ); 2307cdf0e10cSrcweir DrawLine( Point( maExtraRect.Right()-1, maExtraRect.Top() ), 2308cdf0e10cSrcweir Point( maExtraRect.Right()-1, maExtraRect.Bottom()-1 ) ); 2309cdf0e10cSrcweir SetLineColor( rStyleSettings.GetLightColor() ); 2310cdf0e10cSrcweir DrawLine( Point( maExtraRect.Left()+1, maExtraRect.Top()+1 ), 2311cdf0e10cSrcweir Point( maExtraRect.Right()-2, maExtraRect.Top()+1 ) ); 2312cdf0e10cSrcweir DrawLine( Point( maExtraRect.Left()+1, maExtraRect.Top()+1 ), 2313cdf0e10cSrcweir Point( maExtraRect.Left()+1, maExtraRect.Bottom()-2 ) ); 2314cdf0e10cSrcweir DrawLine( Point( maExtraRect.Left(), maExtraRect.Bottom() ), 2315cdf0e10cSrcweir Point( maExtraRect.Right(), maExtraRect.Bottom() ) ); 2316cdf0e10cSrcweir DrawLine( Point( maExtraRect.Right(), maExtraRect.Top() ), 2317cdf0e10cSrcweir Point( maExtraRect.Right(), maExtraRect.Bottom() ) ); 2318cdf0e10cSrcweir } 2319cdf0e10cSrcweir else 2320cdf0e10cSrcweir { 2321cdf0e10cSrcweir SetLineColor( rStyleSettings.GetWindowTextColor() ); 2322cdf0e10cSrcweir SetFillColor( rStyleSettings.GetWindowColor() ); 2323cdf0e10cSrcweir DrawRect( maExtraRect ); 2324cdf0e10cSrcweir } 2325cdf0e10cSrcweir 2326cdf0e10cSrcweir // Imhalt vom Extrafeld ausgeben 2327cdf0e10cSrcweir ImplDrawExtra( sal_True ); 2328cdf0e10cSrcweir } 2329cdf0e10cSrcweir 2330cdf0e10cSrcweir if ( mnWinStyle & WB_BORDER ) 2331cdf0e10cSrcweir { 2332cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2333cdf0e10cSrcweir { 2334cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 2335cdf0e10cSrcweir { 2336cdf0e10cSrcweir SetLineColor( rStyleSettings.GetShadowColor() ); 2337cdf0e10cSrcweir DrawLine( Point( mnBorderOff, mnHeight-2 ), 2338cdf0e10cSrcweir Point( mnWidth, mnHeight-2 ) ); 2339cdf0e10cSrcweir if ( mnBorderOff ) 2340cdf0e10cSrcweir { 2341cdf0e10cSrcweir DrawLine( Point( mnBorderOff-1, mnHeight-2 ), 2342cdf0e10cSrcweir Point( mnBorderOff-1, mnHeight-1 ) ); 2343cdf0e10cSrcweir } 2344cdf0e10cSrcweir } 2345cdf0e10cSrcweir SetLineColor( rStyleSettings.GetWindowTextColor() ); 2346cdf0e10cSrcweir DrawLine( Point( mnBorderOff, mnHeight-1 ), 2347cdf0e10cSrcweir Point( mnWidth, mnHeight-1 ) ); 2348cdf0e10cSrcweir } 2349cdf0e10cSrcweir else 2350cdf0e10cSrcweir { 2351cdf0e10cSrcweir if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 2352cdf0e10cSrcweir { 2353cdf0e10cSrcweir SetLineColor( rStyleSettings.GetShadowColor() ); 2354cdf0e10cSrcweir DrawLine( Point( mnWidth-2, mnBorderOff ), 2355cdf0e10cSrcweir Point( mnWidth-2, mnHeight ) ); 2356cdf0e10cSrcweir if ( mnBorderOff ) 2357cdf0e10cSrcweir { 2358cdf0e10cSrcweir DrawLine( Point( mnWidth-2, mnBorderOff-1 ), 2359cdf0e10cSrcweir Point( mnWidth-1, mnBorderOff-1 ) ); 2360cdf0e10cSrcweir } 2361cdf0e10cSrcweir } 2362cdf0e10cSrcweir SetLineColor( rStyleSettings.GetWindowTextColor() ); 2363cdf0e10cSrcweir DrawLine( Point( mnWidth-1, mnBorderOff ), 2364cdf0e10cSrcweir Point( mnWidth-1, mnHeight ) ); 2365cdf0e10cSrcweir } 2366cdf0e10cSrcweir } 2367cdf0e10cSrcweir } 2368cdf0e10cSrcweir 2369cdf0e10cSrcweir // ----------------------------------------------------------------------- 2370cdf0e10cSrcweir 2371cdf0e10cSrcweir void Ruler::Resize() 2372cdf0e10cSrcweir { 2373cdf0e10cSrcweir Size aWinSize = GetOutputSizePixel(); 2374cdf0e10cSrcweir 2375cdf0e10cSrcweir long nNewHeight; 2376cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2377cdf0e10cSrcweir { 2378cdf0e10cSrcweir if ( aWinSize.Height() != mnHeight ) 2379cdf0e10cSrcweir nNewHeight = aWinSize.Height(); 2380cdf0e10cSrcweir else 2381cdf0e10cSrcweir nNewHeight = 0; 2382cdf0e10cSrcweir } 2383cdf0e10cSrcweir else 2384cdf0e10cSrcweir { 2385cdf0e10cSrcweir if ( aWinSize.Width() != mnWidth ) 2386cdf0e10cSrcweir nNewHeight = aWinSize.Width(); 2387cdf0e10cSrcweir else 2388cdf0e10cSrcweir nNewHeight = 0; 2389cdf0e10cSrcweir } 2390cdf0e10cSrcweir 2391cdf0e10cSrcweir // Hier schon Linien loeschen 2392cdf0e10cSrcweir sal_Bool bVisible = IsReallyVisible(); 2393cdf0e10cSrcweir if ( bVisible && mpData->nLines ) 2394cdf0e10cSrcweir { 2395cdf0e10cSrcweir ImplInvertLines(); 2396cdf0e10cSrcweir mnUpdateFlags |= RULER_UPDATE_LINES; 2397cdf0e10cSrcweir if ( !mnUpdateEvtId ) 2398cdf0e10cSrcweir mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); 2399cdf0e10cSrcweir } 2400cdf0e10cSrcweir mbFormat = sal_True; 2401cdf0e10cSrcweir 2402cdf0e10cSrcweir // Wenn sich die Hoehe bzw. Breite aendert, dann muessen besimmte Werte 2403cdf0e10cSrcweir // neu berechnet werden 2404cdf0e10cSrcweir //extra field should always be updated 2405cdf0e10cSrcweir ImplInitExtraField( mpData->bTextRTL ); 2406cdf0e10cSrcweir if ( nNewHeight ) 2407cdf0e10cSrcweir { 2408cdf0e10cSrcweir mbCalc = sal_True; 2409cdf0e10cSrcweir mnVirHeight = nNewHeight - mnBorderWidth - (RULER_OFF*2); 2410cdf0e10cSrcweir } 2411cdf0e10cSrcweir else 2412cdf0e10cSrcweir { 2413cdf0e10cSrcweir if ( mpData->bAutoPageWidth ) 2414cdf0e10cSrcweir ImplUpdate( sal_True ); 2415cdf0e10cSrcweir else if ( mbAutoWinWidth ) 2416cdf0e10cSrcweir mbCalc = sal_True; 2417cdf0e10cSrcweir } 2418cdf0e10cSrcweir 2419cdf0e10cSrcweir // Wenn Ruler eine Groesse hat, dann Groesse vom VirtualDevice setzen 2420cdf0e10cSrcweir if ( (mnVirWidth > RULER_MIN_SIZE) || 2421cdf0e10cSrcweir ((aWinSize.Width() > RULER_MIN_SIZE) && (aWinSize.Height() > RULER_MIN_SIZE)) ) 2422cdf0e10cSrcweir { 2423cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2424cdf0e10cSrcweir mnVirWidth = aWinSize.Width()-mnVirOff; 2425cdf0e10cSrcweir else 2426cdf0e10cSrcweir mnVirWidth = aWinSize.Height()-mnVirOff; 2427cdf0e10cSrcweir if ( mnVirWidth < RULER_MIN_SIZE ) 2428cdf0e10cSrcweir mnVirWidth = 0; 2429cdf0e10cSrcweir } 2430cdf0e10cSrcweir 2431cdf0e10cSrcweir // Gegebenenfalls ein Teil vom Rand loeschen, da 3D-Effekt/Trennlinie am 2432cdf0e10cSrcweir // Fensterrand 2433cdf0e10cSrcweir if ( bVisible ) 2434cdf0e10cSrcweir { 2435cdf0e10cSrcweir if ( nNewHeight ) 2436cdf0e10cSrcweir Invalidate(); 2437cdf0e10cSrcweir else if ( mpData->bAutoPageWidth ) 2438cdf0e10cSrcweir { 2439cdf0e10cSrcweir // Nur bei AutoPageWidth haben wir rechts einen 3D-Effekt, 2440cdf0e10cSrcweir // der sich der Fensterbreite anpasst und deshalb neu gezeichnet 2441cdf0e10cSrcweir // werden muss 2442cdf0e10cSrcweir Rectangle aRect; 2443cdf0e10cSrcweir 2444cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2445cdf0e10cSrcweir { 2446cdf0e10cSrcweir if ( mnWidth < aWinSize.Width() ) 2447cdf0e10cSrcweir aRect.Left() = mnWidth-RULER_RESIZE_OFF; 2448cdf0e10cSrcweir else 2449cdf0e10cSrcweir aRect.Left() = aWinSize.Width()-RULER_RESIZE_OFF; 2450cdf0e10cSrcweir aRect.Right() = aRect.Left()+RULER_RESIZE_OFF; 2451cdf0e10cSrcweir aRect.Top() = RULER_OFF; 2452cdf0e10cSrcweir aRect.Bottom() = RULER_OFF+mnVirHeight; 2453cdf0e10cSrcweir } 2454cdf0e10cSrcweir else 2455cdf0e10cSrcweir { 2456cdf0e10cSrcweir if ( mnHeight < aWinSize.Height() ) 2457cdf0e10cSrcweir aRect.Top() = mnHeight-RULER_RESIZE_OFF; 2458cdf0e10cSrcweir else 2459cdf0e10cSrcweir aRect.Top() = aWinSize.Height()-RULER_RESIZE_OFF; 2460cdf0e10cSrcweir aRect.Bottom() = aRect.Top()+RULER_RESIZE_OFF; 2461cdf0e10cSrcweir aRect.Left() = RULER_OFF; 2462cdf0e10cSrcweir aRect.Right() = RULER_OFF+mnVirHeight; 2463cdf0e10cSrcweir } 2464cdf0e10cSrcweir 2465cdf0e10cSrcweir Invalidate( aRect ); 2466cdf0e10cSrcweir } 2467cdf0e10cSrcweir } 2468cdf0e10cSrcweir 2469cdf0e10cSrcweir // Neue Groesse merken 2470cdf0e10cSrcweir mnWidth = aWinSize.Width(); 2471cdf0e10cSrcweir mnHeight = aWinSize.Height(); 2472cdf0e10cSrcweir } 2473cdf0e10cSrcweir 2474cdf0e10cSrcweir // ----------------------------------------------------------------------- 2475cdf0e10cSrcweir 2476cdf0e10cSrcweir void Ruler::StateChanged( StateChangedType nType ) 2477cdf0e10cSrcweir { 2478cdf0e10cSrcweir Window::StateChanged( nType ); 2479cdf0e10cSrcweir 2480cdf0e10cSrcweir if ( nType == STATE_CHANGE_INITSHOW ) 2481cdf0e10cSrcweir ImplFormat(); 2482cdf0e10cSrcweir else if ( nType == STATE_CHANGE_UPDATEMODE ) 2483cdf0e10cSrcweir { 2484cdf0e10cSrcweir if ( IsReallyVisible() && IsUpdateMode() ) 2485cdf0e10cSrcweir ImplDraw(); 2486cdf0e10cSrcweir } 2487cdf0e10cSrcweir else if ( (nType == STATE_CHANGE_ZOOM) || 2488cdf0e10cSrcweir (nType == STATE_CHANGE_CONTROLFONT) ) 2489cdf0e10cSrcweir { 2490cdf0e10cSrcweir ImplInitSettings( sal_True, sal_False, sal_False ); 2491cdf0e10cSrcweir Invalidate(); 2492cdf0e10cSrcweir } 2493cdf0e10cSrcweir else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) 2494cdf0e10cSrcweir { 2495cdf0e10cSrcweir ImplInitSettings( sal_False, sal_True, sal_False ); 2496cdf0e10cSrcweir Invalidate(); 2497cdf0e10cSrcweir } 2498cdf0e10cSrcweir else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) 2499cdf0e10cSrcweir { 2500cdf0e10cSrcweir ImplInitSettings( sal_False, sal_False, sal_True ); 2501cdf0e10cSrcweir Invalidate(); 2502cdf0e10cSrcweir } 2503cdf0e10cSrcweir } 2504cdf0e10cSrcweir 2505cdf0e10cSrcweir // ----------------------------------------------------------------------- 2506cdf0e10cSrcweir 2507cdf0e10cSrcweir void Ruler::DataChanged( const DataChangedEvent& rDCEvt ) 2508cdf0e10cSrcweir { 2509cdf0e10cSrcweir Window::DataChanged( rDCEvt ); 2510cdf0e10cSrcweir 2511cdf0e10cSrcweir if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || 2512cdf0e10cSrcweir (rDCEvt.GetType() == DATACHANGED_DISPLAY) || 2513cdf0e10cSrcweir (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || 2514cdf0e10cSrcweir ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && 2515cdf0e10cSrcweir (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) 2516cdf0e10cSrcweir { 2517cdf0e10cSrcweir mbFormat = sal_True; 2518cdf0e10cSrcweir ImplInitSettings( sal_True, sal_True, sal_True ); 2519cdf0e10cSrcweir Invalidate(); 2520cdf0e10cSrcweir } 2521cdf0e10cSrcweir } 2522cdf0e10cSrcweir 2523cdf0e10cSrcweir // ----------------------------------------------------------------------- 2524cdf0e10cSrcweir 2525cdf0e10cSrcweir long Ruler::StartDrag() 2526cdf0e10cSrcweir { 2527cdf0e10cSrcweir if ( maStartDragHdl.IsSet() ) 2528cdf0e10cSrcweir return maStartDragHdl.Call( this ); 2529cdf0e10cSrcweir else 2530cdf0e10cSrcweir return sal_False; 2531cdf0e10cSrcweir } 2532cdf0e10cSrcweir 2533cdf0e10cSrcweir // ----------------------------------------------------------------------- 2534cdf0e10cSrcweir 2535cdf0e10cSrcweir void Ruler::Drag() 2536cdf0e10cSrcweir { 2537cdf0e10cSrcweir maDragHdl.Call( this ); 2538cdf0e10cSrcweir } 2539cdf0e10cSrcweir 2540cdf0e10cSrcweir // ----------------------------------------------------------------------- 2541cdf0e10cSrcweir 2542cdf0e10cSrcweir void Ruler::EndDrag() 2543cdf0e10cSrcweir { 2544cdf0e10cSrcweir maEndDragHdl.Call( this ); 2545cdf0e10cSrcweir } 2546cdf0e10cSrcweir 2547cdf0e10cSrcweir // ----------------------------------------------------------------------- 2548cdf0e10cSrcweir 2549cdf0e10cSrcweir void Ruler::Click() 2550cdf0e10cSrcweir { 2551cdf0e10cSrcweir maClickHdl.Call( this ); 2552cdf0e10cSrcweir } 2553cdf0e10cSrcweir 2554cdf0e10cSrcweir // ----------------------------------------------------------------------- 2555cdf0e10cSrcweir 2556cdf0e10cSrcweir void Ruler::DoubleClick() 2557cdf0e10cSrcweir { 2558cdf0e10cSrcweir maDoubleClickHdl.Call( this ); 2559cdf0e10cSrcweir } 2560cdf0e10cSrcweir 2561cdf0e10cSrcweir // ----------------------------------------------------------------------- 2562cdf0e10cSrcweir 2563cdf0e10cSrcweir void Ruler::ExtraDown() 2564cdf0e10cSrcweir { 2565cdf0e10cSrcweir maExtraDownHdl.Call( this ); 2566cdf0e10cSrcweir } 2567cdf0e10cSrcweir 2568cdf0e10cSrcweir // ----------------------------------------------------------------------- 2569cdf0e10cSrcweir 2570cdf0e10cSrcweir void Ruler::Activate() 2571cdf0e10cSrcweir { 2572cdf0e10cSrcweir mbActive = sal_True; 2573cdf0e10cSrcweir 2574cdf0e10cSrcweir // Positionslinien wieder anzeigen (erst hinter mbActive=sal_True rufen, da 2575cdf0e10cSrcweir // von ImplInvertLines() ausgewertet wird). Das Zeichnen der Linien 2576cdf0e10cSrcweir // wird verzoegert, damit im vermutlich noch nicht gepainteten Zustand 2577cdf0e10cSrcweir // Linien gezeichnet werden. 2578cdf0e10cSrcweir mnUpdateFlags |= RULER_UPDATE_LINES; 2579cdf0e10cSrcweir if ( !mnUpdateEvtId ) 2580cdf0e10cSrcweir mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); 2581cdf0e10cSrcweir } 2582cdf0e10cSrcweir 2583cdf0e10cSrcweir // ----------------------------------------------------------------------- 2584cdf0e10cSrcweir 2585cdf0e10cSrcweir void Ruler::Deactivate() 2586cdf0e10cSrcweir { 2587cdf0e10cSrcweir // Positionslinien loeschen (schon vor mbActive=sal_False rufen, da 2588cdf0e10cSrcweir // von ImplInvertLines() ausgewertet wird) 2589cdf0e10cSrcweir ImplInvertLines(); 2590cdf0e10cSrcweir 2591cdf0e10cSrcweir mbActive = sal_False; 2592cdf0e10cSrcweir } 2593cdf0e10cSrcweir 2594cdf0e10cSrcweir // ----------------------------------------------------------------------- 2595cdf0e10cSrcweir 2596cdf0e10cSrcweir sal_Bool Ruler::StartDocDrag( const MouseEvent& rMEvt, RulerType eDragType ) 2597cdf0e10cSrcweir { 2598cdf0e10cSrcweir if ( !mbDrag ) 2599cdf0e10cSrcweir { 2600cdf0e10cSrcweir Point aMousePos = rMEvt.GetPosPixel(); 2601cdf0e10cSrcweir sal_uInt16 nMouseClicks = rMEvt.GetClicks(); 2602cdf0e10cSrcweir sal_uInt16 nMouseModifier = rMEvt.GetModifier(); 2603cdf0e10cSrcweir ImplRulerHitTest aHitTest; 2604cdf0e10cSrcweir if(eDragType != RULER_TYPE_DONTKNOW) 2605cdf0e10cSrcweir aHitTest.bExpandTest = sal_True; 2606cdf0e10cSrcweir 2607cdf0e10cSrcweir // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten 2608cdf0e10cSrcweir // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) 2609cdf0e10cSrcweir if ( mbFormat ) 2610cdf0e10cSrcweir { 2611cdf0e10cSrcweir ImplDraw(); 2612cdf0e10cSrcweir mnUpdateFlags &= ~RULER_UPDATE_DRAW; 2613cdf0e10cSrcweir } 2614cdf0e10cSrcweir 2615cdf0e10cSrcweir if ( nMouseClicks == 1 ) 2616cdf0e10cSrcweir { 2617cdf0e10cSrcweir if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) ) 2618cdf0e10cSrcweir { 2619cdf0e10cSrcweir Pointer aPtr; 2620cdf0e10cSrcweir 2621cdf0e10cSrcweir if ( aHitTest.bSize ) 2622cdf0e10cSrcweir { 2623cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2624cdf0e10cSrcweir aPtr = Pointer( POINTER_ESIZE ); 2625cdf0e10cSrcweir else 2626cdf0e10cSrcweir aPtr = Pointer( POINTER_SSIZE ); 2627cdf0e10cSrcweir } 2628cdf0e10cSrcweir else if ( aHitTest.bSizeBar ) 2629cdf0e10cSrcweir { 2630cdf0e10cSrcweir if ( mnWinStyle & WB_HORZ ) 2631cdf0e10cSrcweir aPtr = Pointer( POINTER_HSIZEBAR ); 2632cdf0e10cSrcweir else 2633cdf0e10cSrcweir aPtr = Pointer( POINTER_VSIZEBAR ); 2634cdf0e10cSrcweir } 2635cdf0e10cSrcweir SetPointer( aPtr ); 2636cdf0e10cSrcweir return ImplStartDrag( &aHitTest, nMouseModifier ); 2637cdf0e10cSrcweir } 2638cdf0e10cSrcweir } 2639cdf0e10cSrcweir else if ( nMouseClicks == 2 ) 2640cdf0e10cSrcweir { 2641cdf0e10cSrcweir if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) ) 2642cdf0e10cSrcweir { 2643cdf0e10cSrcweir mnDragPos = aHitTest.nPos; 2644cdf0e10cSrcweir mnDragAryPos = aHitTest.nAryPos; 2645cdf0e10cSrcweir } 2646cdf0e10cSrcweir eDragType = aHitTest.eType; 2647cdf0e10cSrcweir 2648cdf0e10cSrcweir DoubleClick(); 2649cdf0e10cSrcweir 2650cdf0e10cSrcweir eDragType = RULER_TYPE_DONTKNOW; 2651cdf0e10cSrcweir mnDragPos = 0; 2652cdf0e10cSrcweir mnDragAryPos = 0; 2653cdf0e10cSrcweir 2654cdf0e10cSrcweir return sal_True; 2655cdf0e10cSrcweir } 2656cdf0e10cSrcweir } 2657cdf0e10cSrcweir 2658cdf0e10cSrcweir return sal_False; 2659cdf0e10cSrcweir } 2660cdf0e10cSrcweir 2661cdf0e10cSrcweir // ----------------------------------------------------------------------- 2662cdf0e10cSrcweir 2663cdf0e10cSrcweir RulerType Ruler::GetDocType( const Point& rPos, RulerType eDragType, 2664cdf0e10cSrcweir sal_uInt16* pAryPos ) const 2665cdf0e10cSrcweir { 2666cdf0e10cSrcweir ImplRulerHitTest aHitTest; 2667cdf0e10cSrcweir 2668cdf0e10cSrcweir // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten 2669cdf0e10cSrcweir // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) 2670cdf0e10cSrcweir if ( IsReallyVisible() && mbFormat ) 2671cdf0e10cSrcweir { 2672cdf0e10cSrcweir ((Ruler*)this)->ImplDraw(); 2673cdf0e10cSrcweir ((Ruler*)this)->mnUpdateFlags &= ~RULER_UPDATE_DRAW; 2674cdf0e10cSrcweir } 2675cdf0e10cSrcweir 2676cdf0e10cSrcweir // HitTest durchfuehren 2677cdf0e10cSrcweir ImplDocHitTest( rPos, eDragType, &aHitTest ); 2678cdf0e10cSrcweir 2679cdf0e10cSrcweir // Werte zurueckgeben 2680cdf0e10cSrcweir if ( pAryPos ) 2681cdf0e10cSrcweir *pAryPos = aHitTest.nAryPos; 2682cdf0e10cSrcweir return aHitTest.eType; 2683cdf0e10cSrcweir } 2684cdf0e10cSrcweir 2685cdf0e10cSrcweir // ----------------------------------------------------------------------- 2686cdf0e10cSrcweir 2687cdf0e10cSrcweir void Ruler::CancelDrag() 2688cdf0e10cSrcweir { 2689cdf0e10cSrcweir if ( mbDrag ) 2690cdf0e10cSrcweir { 2691cdf0e10cSrcweir ImplDrag( Point( -1, -1 ) ); 2692cdf0e10cSrcweir ImplEndDrag(); 2693cdf0e10cSrcweir } 2694cdf0e10cSrcweir } 2695cdf0e10cSrcweir 2696cdf0e10cSrcweir // ----------------------------------------------------------------------- 2697cdf0e10cSrcweir 2698cdf0e10cSrcweir RulerType Ruler::GetType( const Point& rPos, sal_uInt16* pAryPos ) const 2699cdf0e10cSrcweir { 2700cdf0e10cSrcweir ImplRulerHitTest aHitTest; 2701cdf0e10cSrcweir 2702cdf0e10cSrcweir // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten 2703cdf0e10cSrcweir // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) 2704cdf0e10cSrcweir if ( IsReallyVisible() && mbFormat ) 2705cdf0e10cSrcweir { 2706cdf0e10cSrcweir ((Ruler*)this)->ImplDraw(); 2707cdf0e10cSrcweir ((Ruler*)this)->mnUpdateFlags &= ~RULER_UPDATE_DRAW; 2708cdf0e10cSrcweir } 2709cdf0e10cSrcweir 2710cdf0e10cSrcweir // HitTest durchfuehren 2711cdf0e10cSrcweir ImplHitTest( rPos, &aHitTest ); 2712cdf0e10cSrcweir 2713cdf0e10cSrcweir // Werte zurueckgeben 2714cdf0e10cSrcweir if ( pAryPos ) 2715cdf0e10cSrcweir *pAryPos = aHitTest.nAryPos; 2716cdf0e10cSrcweir return aHitTest.eType; 2717cdf0e10cSrcweir } 2718cdf0e10cSrcweir 2719cdf0e10cSrcweir // ----------------------------------------------------------------------- 2720cdf0e10cSrcweir 2721cdf0e10cSrcweir void Ruler::SetWinPos( long nNewOff, long nNewWidth ) 2722cdf0e10cSrcweir { 2723cdf0e10cSrcweir // Gegebenenfalls werden die Breiten automatisch berechnet 2724cdf0e10cSrcweir if ( !nNewWidth ) 2725cdf0e10cSrcweir mbAutoWinWidth = sal_True; 2726cdf0e10cSrcweir else 2727cdf0e10cSrcweir mbAutoWinWidth = sal_False; 2728cdf0e10cSrcweir 2729cdf0e10cSrcweir // Werte setzen (werden in ImplFormat gegebenenfalls mitberechnet) 2730cdf0e10cSrcweir mnWinOff = nNewOff; 2731cdf0e10cSrcweir mnWinWidth = nNewWidth; 2732cdf0e10cSrcweir ImplUpdate( sal_True ); 2733cdf0e10cSrcweir } 2734cdf0e10cSrcweir 2735cdf0e10cSrcweir // ----------------------------------------------------------------------- 2736cdf0e10cSrcweir 2737cdf0e10cSrcweir void Ruler::SetPagePos( long nNewOff, long nNewWidth ) 2738cdf0e10cSrcweir { 2739cdf0e10cSrcweir // Muessen wir ueberhaupt was machen 2740cdf0e10cSrcweir if ( (mpData->nPageOff == nNewOff) && (mpData->nPageWidth == nNewWidth) ) 2741cdf0e10cSrcweir return; 2742cdf0e10cSrcweir 2743cdf0e10cSrcweir // Gegebenenfalls werden die Breiten automatisch berechnet 2744cdf0e10cSrcweir if ( !nNewWidth ) 2745cdf0e10cSrcweir mpData->bAutoPageWidth = sal_True; 2746cdf0e10cSrcweir else 2747cdf0e10cSrcweir mpData->bAutoPageWidth = sal_False; 2748cdf0e10cSrcweir 2749cdf0e10cSrcweir // Werte setzen (werden in ImplFormat gegebenenfalls mitberechnet) 2750cdf0e10cSrcweir mpData->nPageOff = nNewOff; 2751cdf0e10cSrcweir mpData->nPageWidth = nNewWidth; 2752cdf0e10cSrcweir ImplUpdate( sal_True ); 2753cdf0e10cSrcweir } 2754cdf0e10cSrcweir 2755cdf0e10cSrcweir // ----------------------------------------------------------------------- 2756cdf0e10cSrcweir 2757cdf0e10cSrcweir void Ruler::SetBorderPos( long nOff ) 2758cdf0e10cSrcweir { 2759cdf0e10cSrcweir if ( mnWinStyle & WB_BORDER ) 2760cdf0e10cSrcweir { 2761cdf0e10cSrcweir if ( mnBorderOff != nOff ) 2762cdf0e10cSrcweir { 2763cdf0e10cSrcweir mnBorderOff = nOff; 2764cdf0e10cSrcweir 2765cdf0e10cSrcweir if ( IsReallyVisible() && IsUpdateMode() ) 2766cdf0e10cSrcweir Invalidate(); 2767cdf0e10cSrcweir } 2768cdf0e10cSrcweir } 2769cdf0e10cSrcweir } 2770cdf0e10cSrcweir 2771cdf0e10cSrcweir // ----------------------------------------------------------------------- 2772cdf0e10cSrcweir 2773cdf0e10cSrcweir void Ruler::SetUnit( FieldUnit eNewUnit ) 2774cdf0e10cSrcweir { 2775cdf0e10cSrcweir if ( meUnit != eNewUnit ) 2776cdf0e10cSrcweir { 2777cdf0e10cSrcweir meUnit = eNewUnit; 2778cdf0e10cSrcweir switch ( meUnit ) 2779cdf0e10cSrcweir { 2780cdf0e10cSrcweir case FUNIT_MM: 2781cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_MM; 2782cdf0e10cSrcweir break; 2783cdf0e10cSrcweir case FUNIT_CM: 2784cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_CM; 2785cdf0e10cSrcweir break; 2786cdf0e10cSrcweir case FUNIT_M: 2787cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_M; 2788cdf0e10cSrcweir break; 2789cdf0e10cSrcweir case FUNIT_KM: 2790cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_KM; 2791cdf0e10cSrcweir break; 2792cdf0e10cSrcweir case FUNIT_INCH: 2793cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_INCH; 2794cdf0e10cSrcweir break; 2795cdf0e10cSrcweir case FUNIT_FOOT: 2796cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_FOOT; 2797cdf0e10cSrcweir break; 2798cdf0e10cSrcweir case FUNIT_MILE: 2799cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_MILE; 2800cdf0e10cSrcweir break; 2801cdf0e10cSrcweir case FUNIT_POINT: 2802cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_POINT; 2803cdf0e10cSrcweir break; 2804cdf0e10cSrcweir case FUNIT_PICA: 2805cdf0e10cSrcweir mnUnitIndex = RULER_UNIT_PICA; 2806cdf0e10cSrcweir break; 2807cdf0e10cSrcweir default: 2808cdf0e10cSrcweir #ifdef DBG_UTIL 2809cdf0e10cSrcweir DBG_ERRORFILE( "Ruler::SetUnit() - Wrong Unit" ); 2810cdf0e10cSrcweir #endif 2811cdf0e10cSrcweir break; 2812cdf0e10cSrcweir } 2813cdf0e10cSrcweir 2814cdf0e10cSrcweir maMapMode.SetMapUnit( aImplRulerUnitTab[mnUnitIndex].eMapUnit ); 2815cdf0e10cSrcweir ImplUpdate(); 2816cdf0e10cSrcweir } 2817cdf0e10cSrcweir } 2818cdf0e10cSrcweir 2819cdf0e10cSrcweir // ----------------------------------------------------------------------- 2820cdf0e10cSrcweir 2821cdf0e10cSrcweir void Ruler::SetZoom( const Fraction& rNewZoom ) 2822cdf0e10cSrcweir { 2823cdf0e10cSrcweir DBG_ASSERT( rNewZoom.GetNumerator(), "Ruler::SetZoom() with scale 0 is not allowed" ); 2824cdf0e10cSrcweir 2825cdf0e10cSrcweir if ( maZoom != rNewZoom ) 2826cdf0e10cSrcweir { 2827cdf0e10cSrcweir maZoom = rNewZoom; 2828cdf0e10cSrcweir maMapMode.SetScaleX( maZoom ); 2829cdf0e10cSrcweir maMapMode.SetScaleY( maZoom ); 2830cdf0e10cSrcweir ImplUpdate(); 2831cdf0e10cSrcweir } 2832cdf0e10cSrcweir } 2833cdf0e10cSrcweir 2834cdf0e10cSrcweir // ----------------------------------------------------------------------- 2835cdf0e10cSrcweir 2836cdf0e10cSrcweir void Ruler::SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle ) 2837cdf0e10cSrcweir { 2838cdf0e10cSrcweir if ( mnWinStyle & WB_EXTRAFIELD ) 2839cdf0e10cSrcweir { 2840cdf0e10cSrcweir meExtraType = eNewExtraType; 2841cdf0e10cSrcweir mnExtraStyle = nStyle; 2842cdf0e10cSrcweir if ( IsReallyVisible() && IsUpdateMode() ) 2843cdf0e10cSrcweir ImplDrawExtra( sal_False ); 2844cdf0e10cSrcweir } 2845cdf0e10cSrcweir } 2846cdf0e10cSrcweir 2847cdf0e10cSrcweir // ----------------------------------------------------------------------- 2848cdf0e10cSrcweir 2849cdf0e10cSrcweir void Ruler::SetNullOffset( long nPos ) 2850cdf0e10cSrcweir { 2851cdf0e10cSrcweir if ( mpData->nNullOff != nPos ) 2852cdf0e10cSrcweir { 2853cdf0e10cSrcweir mpData->nNullOff = nPos; 2854cdf0e10cSrcweir ImplUpdate(); 2855cdf0e10cSrcweir } 2856cdf0e10cSrcweir } 2857cdf0e10cSrcweir 2858cdf0e10cSrcweir // ----------------------------------------------------------------------- 2859cdf0e10cSrcweir 2860cdf0e10cSrcweir void Ruler::SetMargin1( long nPos, sal_uInt16 nMarginStyle ) 2861cdf0e10cSrcweir { 2862cdf0e10cSrcweir if ( (mpData->nMargin1 != nPos) || (mpData->nMargin1Style != nMarginStyle) ) 2863cdf0e10cSrcweir { 2864cdf0e10cSrcweir mpData->nMargin1 = nPos; 2865cdf0e10cSrcweir mpData->nMargin1Style = nMarginStyle; 2866cdf0e10cSrcweir ImplUpdate(); 2867cdf0e10cSrcweir } 2868cdf0e10cSrcweir } 2869cdf0e10cSrcweir 2870cdf0e10cSrcweir // ----------------------------------------------------------------------- 2871cdf0e10cSrcweir 2872cdf0e10cSrcweir void Ruler::SetMargin2( long nPos, sal_uInt16 nMarginStyle ) 2873cdf0e10cSrcweir { 2874cdf0e10cSrcweir DBG_ASSERT( (nPos >= mpData->nMargin1) || 2875cdf0e10cSrcweir (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) || 2876cdf0e10cSrcweir (mpData->nMargin2Style & RULER_STYLE_INVISIBLE), 2877cdf0e10cSrcweir "Ruler::SetMargin2() - Margin2 < Margin1" ); 2878cdf0e10cSrcweir 2879cdf0e10cSrcweir if ( (mpData->nMargin2 != nPos) || (mpData->nMargin2Style != nMarginStyle) ) 2880cdf0e10cSrcweir { 2881cdf0e10cSrcweir mpData->nMargin2 = nPos; 2882cdf0e10cSrcweir mpData->nMargin2Style = nMarginStyle; 2883cdf0e10cSrcweir ImplUpdate(); 2884cdf0e10cSrcweir } 2885cdf0e10cSrcweir } 2886cdf0e10cSrcweir 2887cdf0e10cSrcweir // ----------------------------------------------------------------------- 2888cdf0e10cSrcweir 2889cdf0e10cSrcweir void Ruler::SetLines( sal_uInt16 n, const RulerLine* pLineAry ) 2890cdf0e10cSrcweir { 2891cdf0e10cSrcweir // To determine if what has changed 2892cdf0e10cSrcweir if ( mpData->nLines == n ) 2893cdf0e10cSrcweir { 2894cdf0e10cSrcweir sal_uInt16 i = n; 2895cdf0e10cSrcweir const RulerLine* pAry1 = mpData->pLines; 2896cdf0e10cSrcweir const RulerLine* pAry2 = pLineAry; 2897cdf0e10cSrcweir while ( i ) 2898cdf0e10cSrcweir { 2899cdf0e10cSrcweir if ( (pAry1->nPos != pAry2->nPos) || 2900cdf0e10cSrcweir (pAry1->nStyle != pAry2->nStyle) ) 2901cdf0e10cSrcweir break; 2902cdf0e10cSrcweir pAry1++; 2903cdf0e10cSrcweir pAry2++; 2904cdf0e10cSrcweir i--; 2905cdf0e10cSrcweir } 2906cdf0e10cSrcweir if ( !i ) 2907cdf0e10cSrcweir return; 2908cdf0e10cSrcweir } 2909cdf0e10cSrcweir 2910cdf0e10cSrcweir // New values and new share issue 2911cdf0e10cSrcweir sal_Bool bMustUpdate; 2912cdf0e10cSrcweir if ( IsReallyVisible() && IsUpdateMode() ) 2913cdf0e10cSrcweir bMustUpdate = sal_True; 2914cdf0e10cSrcweir else 2915cdf0e10cSrcweir bMustUpdate = sal_False; 2916cdf0e10cSrcweir 2917cdf0e10cSrcweir // Delete old lines 2918cdf0e10cSrcweir if ( bMustUpdate ) 2919cdf0e10cSrcweir ImplInvertLines(); 2920cdf0e10cSrcweir 2921cdf0e10cSrcweir // New data set 2922cdf0e10cSrcweir if ( !n || !pLineAry ) 2923cdf0e10cSrcweir { 2924cdf0e10cSrcweir if ( !mpData->pLines ) 2925cdf0e10cSrcweir return; 2926cdf0e10cSrcweir delete[] mpData->pLines; 2927cdf0e10cSrcweir mpData->nLines = 0; 2928cdf0e10cSrcweir mpData->pLines = NULL; 2929cdf0e10cSrcweir } 2930cdf0e10cSrcweir else 2931cdf0e10cSrcweir { 2932cdf0e10cSrcweir if ( mpData->nLines != n ) 2933cdf0e10cSrcweir { 2934cdf0e10cSrcweir delete[] mpData->pLines; 2935cdf0e10cSrcweir mpData->nLines = n; 2936cdf0e10cSrcweir mpData->pLines = new RulerLine[n]; 2937cdf0e10cSrcweir } 2938cdf0e10cSrcweir 2939cdf0e10cSrcweir memcpy( mpData->pLines, pLineAry, n*sizeof( RulerLine ) ); 2940cdf0e10cSrcweir 2941cdf0e10cSrcweir // Linien neu ausgeben 2942cdf0e10cSrcweir if ( bMustUpdate ) 2943cdf0e10cSrcweir ImplInvertLines(); 2944cdf0e10cSrcweir } 2945cdf0e10cSrcweir } 2946cdf0e10cSrcweir 2947cdf0e10cSrcweir // ----------------------------------------------------------------------- 2948cdf0e10cSrcweir 2949cdf0e10cSrcweir void Ruler::SetArrows( sal_uInt16 n, const RulerArrow* pArrowAry ) 2950cdf0e10cSrcweir { 2951cdf0e10cSrcweir if ( !n || !pArrowAry ) 2952cdf0e10cSrcweir { 2953cdf0e10cSrcweir if ( !mpData->pArrows ) 2954cdf0e10cSrcweir return; 2955cdf0e10cSrcweir delete[] mpData->pArrows; 2956cdf0e10cSrcweir mpData->nArrows = 0; 2957cdf0e10cSrcweir mpData->pArrows = NULL; 2958cdf0e10cSrcweir } 2959cdf0e10cSrcweir else 2960cdf0e10cSrcweir { 2961cdf0e10cSrcweir if ( mpData->nArrows != n ) 2962cdf0e10cSrcweir { 2963cdf0e10cSrcweir delete[] mpData->pArrows; 2964cdf0e10cSrcweir mpData->nArrows = n; 2965cdf0e10cSrcweir mpData->pArrows = new RulerArrow[n]; 2966cdf0e10cSrcweir } 2967cdf0e10cSrcweir else 2968cdf0e10cSrcweir { 2969cdf0e10cSrcweir sal_uInt16 i = n; 2970cdf0e10cSrcweir const RulerArrow* pAry1 = mpData->pArrows; 2971cdf0e10cSrcweir const RulerArrow* pAry2 = pArrowAry; 2972cdf0e10cSrcweir while ( i ) 2973cdf0e10cSrcweir { 2974cdf0e10cSrcweir if ( (pAry1->nPos != pAry2->nPos) || 2975cdf0e10cSrcweir (pAry1->nWidth != pAry2->nWidth) || 2976cdf0e10cSrcweir (pAry1->nLogWidth != pAry2->nLogWidth) || 2977cdf0e10cSrcweir (pAry1->nStyle != pAry2->nStyle) ) 2978cdf0e10cSrcweir break; 2979cdf0e10cSrcweir pAry1++; 2980cdf0e10cSrcweir pAry2++; 2981cdf0e10cSrcweir i--; 2982cdf0e10cSrcweir } 2983cdf0e10cSrcweir if ( !i ) 2984cdf0e10cSrcweir return; 2985cdf0e10cSrcweir } 2986cdf0e10cSrcweir 2987cdf0e10cSrcweir memcpy( mpData->pArrows, pArrowAry, n*sizeof( RulerArrow ) ); 2988cdf0e10cSrcweir } 2989cdf0e10cSrcweir 2990cdf0e10cSrcweir ImplUpdate(); 2991cdf0e10cSrcweir } 2992cdf0e10cSrcweir 2993cdf0e10cSrcweir // ----------------------------------------------------------------------- 2994cdf0e10cSrcweir 2995cdf0e10cSrcweir void Ruler::SetBorders( sal_uInt16 n, const RulerBorder* pBrdAry ) 2996cdf0e10cSrcweir { 2997cdf0e10cSrcweir if ( !n || !pBrdAry ) 2998cdf0e10cSrcweir { 2999cdf0e10cSrcweir if ( !mpData->pBorders ) 3000cdf0e10cSrcweir return; 3001cdf0e10cSrcweir delete[] mpData->pBorders; 3002cdf0e10cSrcweir mpData->nBorders = 0; 3003cdf0e10cSrcweir mpData->pBorders = NULL; 3004cdf0e10cSrcweir } 3005cdf0e10cSrcweir else 3006cdf0e10cSrcweir { 3007cdf0e10cSrcweir if ( mpData->nBorders != n ) 3008cdf0e10cSrcweir { 3009cdf0e10cSrcweir delete[] mpData->pBorders; 3010cdf0e10cSrcweir mpData->nBorders = n; 3011cdf0e10cSrcweir mpData->pBorders = new RulerBorder[n]; 3012cdf0e10cSrcweir } 3013cdf0e10cSrcweir else 3014cdf0e10cSrcweir { 3015cdf0e10cSrcweir sal_uInt16 i = n; 3016cdf0e10cSrcweir const RulerBorder* pAry1 = mpData->pBorders; 3017cdf0e10cSrcweir const RulerBorder* pAry2 = pBrdAry; 3018cdf0e10cSrcweir while ( i ) 3019cdf0e10cSrcweir { 3020cdf0e10cSrcweir if ( (pAry1->nPos != pAry2->nPos) || 3021cdf0e10cSrcweir (pAry1->nWidth != pAry2->nWidth) || 3022cdf0e10cSrcweir (pAry1->nStyle != pAry2->nStyle) ) 3023cdf0e10cSrcweir break; 3024cdf0e10cSrcweir pAry1++; 3025cdf0e10cSrcweir pAry2++; 3026cdf0e10cSrcweir i--; 3027cdf0e10cSrcweir } 3028cdf0e10cSrcweir if ( !i ) 3029cdf0e10cSrcweir return; 3030cdf0e10cSrcweir } 3031cdf0e10cSrcweir 3032cdf0e10cSrcweir memcpy( mpData->pBorders, pBrdAry, n*sizeof( RulerBorder ) ); 3033cdf0e10cSrcweir } 3034cdf0e10cSrcweir 3035cdf0e10cSrcweir ImplUpdate(); 3036cdf0e10cSrcweir } 3037cdf0e10cSrcweir 3038cdf0e10cSrcweir // ----------------------------------------------------------------------- 3039cdf0e10cSrcweir 3040cdf0e10cSrcweir void Ruler::SetIndents( sal_uInt16 n, const RulerIndent* pIndentAry ) 3041cdf0e10cSrcweir { 3042cdf0e10cSrcweir 3043cdf0e10cSrcweir if ( !n || !pIndentAry ) 3044cdf0e10cSrcweir { 3045cdf0e10cSrcweir if ( !mpData->pIndents ) 3046cdf0e10cSrcweir return; 3047cdf0e10cSrcweir delete[] mpData->pIndents; 3048cdf0e10cSrcweir mpData->nIndents = 0; 3049cdf0e10cSrcweir mpData->pIndents = NULL; 3050cdf0e10cSrcweir } 3051cdf0e10cSrcweir else 3052cdf0e10cSrcweir { 3053cdf0e10cSrcweir if ( mpData->nIndents != n ) 3054cdf0e10cSrcweir { 3055cdf0e10cSrcweir delete[] mpData->pIndents; 3056cdf0e10cSrcweir mpData->nIndents = n; 3057cdf0e10cSrcweir mpData->pIndents = new RulerIndent[n]; 3058cdf0e10cSrcweir } 3059cdf0e10cSrcweir else 3060cdf0e10cSrcweir { 3061cdf0e10cSrcweir sal_uInt16 i = n; 3062cdf0e10cSrcweir const RulerIndent* pAry1 = mpData->pIndents; 3063cdf0e10cSrcweir const RulerIndent* pAry2 = pIndentAry; 3064cdf0e10cSrcweir while ( i ) 3065cdf0e10cSrcweir { 3066cdf0e10cSrcweir if ( (pAry1->nPos != pAry2->nPos) || 3067cdf0e10cSrcweir (pAry1->nStyle != pAry2->nStyle) ) 3068cdf0e10cSrcweir break; 3069cdf0e10cSrcweir pAry1++; 3070cdf0e10cSrcweir pAry2++; 3071cdf0e10cSrcweir i--; 3072cdf0e10cSrcweir } 3073cdf0e10cSrcweir if ( !i ) 3074cdf0e10cSrcweir return; 3075cdf0e10cSrcweir } 3076cdf0e10cSrcweir 3077cdf0e10cSrcweir memcpy( mpData->pIndents, pIndentAry, n*sizeof( RulerIndent ) ); 3078cdf0e10cSrcweir } 3079cdf0e10cSrcweir 3080cdf0e10cSrcweir ImplUpdate(); 3081cdf0e10cSrcweir } 3082cdf0e10cSrcweir 3083cdf0e10cSrcweir // ----------------------------------------------------------------------- 3084cdf0e10cSrcweir 3085cdf0e10cSrcweir void Ruler::SetTabs( sal_uInt16 n, const RulerTab* pTabAry ) 3086cdf0e10cSrcweir { 3087cdf0e10cSrcweir if ( !n || !pTabAry ) 3088cdf0e10cSrcweir { 3089cdf0e10cSrcweir if ( !mpData->pTabs ) 3090cdf0e10cSrcweir return; 3091cdf0e10cSrcweir delete[] mpData->pTabs; 3092cdf0e10cSrcweir mpData->nTabs = 0; 3093cdf0e10cSrcweir mpData->pTabs = NULL; 3094cdf0e10cSrcweir } 3095cdf0e10cSrcweir else 3096cdf0e10cSrcweir { 3097cdf0e10cSrcweir if ( mpData->nTabs != n ) 3098cdf0e10cSrcweir { 3099cdf0e10cSrcweir delete[] mpData->pTabs; 3100cdf0e10cSrcweir mpData->nTabs = n; 3101cdf0e10cSrcweir mpData->pTabs = new RulerTab[n]; 3102cdf0e10cSrcweir } 3103cdf0e10cSrcweir else 3104cdf0e10cSrcweir { 3105cdf0e10cSrcweir sal_uInt16 i = n; 3106cdf0e10cSrcweir const RulerTab* pAry1 = mpData->pTabs; 3107cdf0e10cSrcweir const RulerTab* pAry2 = pTabAry; 3108cdf0e10cSrcweir while ( i ) 3109cdf0e10cSrcweir { 3110cdf0e10cSrcweir if ( (pAry1->nPos != pAry2->nPos) || 3111cdf0e10cSrcweir (pAry1->nStyle != pAry2->nStyle) ) 3112cdf0e10cSrcweir break; 3113cdf0e10cSrcweir pAry1++; 3114cdf0e10cSrcweir pAry2++; 3115cdf0e10cSrcweir i--; 3116cdf0e10cSrcweir } 3117cdf0e10cSrcweir if ( !i ) 3118cdf0e10cSrcweir return; 3119cdf0e10cSrcweir } 3120cdf0e10cSrcweir 3121cdf0e10cSrcweir memcpy( mpData->pTabs, pTabAry, n*sizeof( RulerTab ) ); 3122cdf0e10cSrcweir } 3123cdf0e10cSrcweir 3124cdf0e10cSrcweir ImplUpdate(); 3125cdf0e10cSrcweir } 3126cdf0e10cSrcweir 3127cdf0e10cSrcweir // ----------------------------------------------------------------------- 3128cdf0e10cSrcweir 3129cdf0e10cSrcweir void Ruler::SetStyle( WinBits nStyle ) 3130cdf0e10cSrcweir { 3131cdf0e10cSrcweir if ( mnWinStyle != nStyle ) 3132cdf0e10cSrcweir { 3133cdf0e10cSrcweir mnWinStyle = nStyle; 3134cdf0e10cSrcweir ImplInitExtraField( sal_True ); 3135cdf0e10cSrcweir } 3136cdf0e10cSrcweir } 3137cdf0e10cSrcweir 3138cdf0e10cSrcweir // ----------------------------------------------------------------------- 3139cdf0e10cSrcweir 3140cdf0e10cSrcweir void Ruler::DrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle ) 3141cdf0e10cSrcweir { 3142cdf0e10cSrcweir /*const StyleSettings& rStyleSettings =*/ pDevice->GetSettings().GetStyleSettings(); 3143cdf0e10cSrcweir Point aPos( rPos ); 3144cdf0e10cSrcweir sal_uInt16 nTabStyle = nStyle & (RULER_TAB_STYLE | RULER_TAB_RTL); 3145cdf0e10cSrcweir 3146cdf0e10cSrcweir pDevice->Push( PUSH_LINECOLOR | PUSH_FILLCOLOR ); 3147cdf0e10cSrcweir pDevice->SetLineColor(); 3148cdf0e10cSrcweir pDevice->SetFillColor( pDevice->GetSettings().GetStyleSettings().GetWindowTextColor() ); 3149cdf0e10cSrcweir ImplCenterTabPos( aPos, nTabStyle ); 3150cdf0e10cSrcweir ImplDrawRulerTab( pDevice, aPos, nTabStyle, nStyle ); 3151cdf0e10cSrcweir pDevice->Pop(); 3152cdf0e10cSrcweir } 3153cdf0e10cSrcweir /* -----------------16.10.2002 15:17----------------- 3154cdf0e10cSrcweir * 3155cdf0e10cSrcweir * --------------------------------------------------*/ 3156cdf0e10cSrcweir void Ruler::SetTextRTL(sal_Bool bRTL) 3157cdf0e10cSrcweir { 3158cdf0e10cSrcweir if(mpData->bTextRTL != bRTL) 3159cdf0e10cSrcweir { 3160cdf0e10cSrcweir mpData->bTextRTL = bRTL; 3161cdf0e10cSrcweir if ( IsReallyVisible() && IsUpdateMode() ) 3162cdf0e10cSrcweir ImplInitExtraField( sal_True ); 3163cdf0e10cSrcweir } 3164cdf0e10cSrcweir 3165cdf0e10cSrcweir } 3166cdf0e10cSrcweir long Ruler::GetPageOffset() const { return mpData->nPageOff; } 3167cdf0e10cSrcweir long Ruler::GetPageWidth() const { return mpData->nPageWidth; } 3168cdf0e10cSrcweir long Ruler::GetNullOffset() const { return mpData->nNullOff; } 3169cdf0e10cSrcweir long Ruler::GetMargin1() const { return mpData->nMargin1; } 3170cdf0e10cSrcweir sal_uInt16 Ruler::GetMargin1Style() const { return mpData->nMargin1Style; } 3171cdf0e10cSrcweir long Ruler::GetMargin2() const { return mpData->nMargin2; } 3172cdf0e10cSrcweir sal_uInt16 Ruler::GetMargin2Style() const { return mpData->nMargin2Style; } 3173cdf0e10cSrcweir sal_uInt16 Ruler::GetLineCount() const { return mpData->nLines; } 3174cdf0e10cSrcweir const RulerLine* Ruler::GetLines() const { return mpData->pLines; } 3175cdf0e10cSrcweir sal_uInt16 Ruler::GetArrowCount() const { return mpData->nArrows; } 3176cdf0e10cSrcweir const RulerArrow* Ruler::GetArrows() const { return mpData->pArrows; } 3177cdf0e10cSrcweir sal_uInt16 Ruler::GetBorderCount() const { return mpData->nBorders; } 3178cdf0e10cSrcweir const RulerBorder* Ruler::GetBorders() const { return mpData->pBorders; } 3179cdf0e10cSrcweir sal_uInt16 Ruler::GetIndentCount() const { return mpData->nIndents; } 3180cdf0e10cSrcweir const RulerIndent* Ruler::GetIndents() const { return mpData->pIndents; } 3181cdf0e10cSrcweir 3182