| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| |
| #include <string.h> |
| #include <tools/debug.hxx> |
| #include <vcl/svapp.hxx> |
| #include <tools/poly.hxx> |
| #include <vcl/i18nhelp.hxx> |
| |
| #define _SV_RULER_CXX |
| #include <svtools/ruler.hxx> |
| #include <svtools/svtdata.hxx> |
| #include <svtools/svtools.hrc> |
| using namespace ::rtl; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::accessibility; |
| // ======================================================================= |
| |
| #define RULER_OFF 3 |
| #define RULER_TEXTOFF 2 |
| #define RULER_RESIZE_OFF 4 |
| #define RULER_LINE_WIDTH 7 |
| #define RULER_MIN_SIZE 3 |
| |
| #define RULER_TICK1_WIDTH 1 |
| #define RULER_TICK2_WIDTH 3 |
| #define RULER_TICK3_WIDTH 5 |
| |
| #define RULER_VAR_SIZE 8 |
| |
| #define RULER_TAB_HEIGHT2 2 |
| #define RULER_TAB_WIDTH2 2 |
| #define RULER_TAB_CWIDTH 8 |
| #define RULER_TAB_CWIDTH2 4 |
| #define RULER_TAB_CWIDTH3 4 |
| #define RULER_TAB_CWIDTH4 2 |
| #define RULER_TAB_DHEIGHT 4 |
| #define RULER_TAB_DHEIGHT2 1 |
| #define RULER_TAB_DWIDTH 5 |
| #define RULER_TAB_DWIDTH2 3 |
| #define RULER_TAB_DWIDTH3 3 |
| #define RULER_TAB_DWIDTH4 1 |
| |
| #define RULER_UPDATE_LINES 0x01 |
| #define RULER_UPDATE_DRAW 0x02 |
| |
| #define RULER_CLIP 150 |
| |
| // ======================================================================= |
| |
| #define RULER_UNIT_MM 0 |
| #define RULER_UNIT_CM 1 |
| #define RULER_UNIT_M 2 |
| #define RULER_UNIT_KM 3 |
| #define RULER_UNIT_INCH 4 |
| #define RULER_UNIT_FOOT 5 |
| #define RULER_UNIT_MILE 6 |
| #define RULER_UNIT_POINT 7 |
| #define RULER_UNIT_PICA 8 |
| #define RULER_UNIT_COUNT 9 |
| |
| // ----------------- |
| // - ImplRulerData - |
| // ----------------- |
| class ImplRulerData |
| { |
| friend class Ruler; |
| |
| private: |
| RulerLine* pLines; |
| RulerArrow* pArrows; |
| RulerBorder* pBorders; |
| RulerIndent* pIndents; |
| RulerTab* pTabs; |
| long nNullVirOff; |
| long nRulVirOff; |
| long nRulWidth; |
| long nPageOff; |
| long nPageWidth; |
| long nNullOff; |
| long nMargin1; |
| long nMargin2; |
| sal_uInt16 nLines; |
| sal_uInt16 nArrows; |
| sal_uInt16 nBorders; |
| sal_uInt16 nIndents; |
| sal_uInt16 nTabs; |
| sal_uInt16 nMargin1Style; |
| sal_uInt16 nMargin2Style; |
| sal_Bool bAutoPageWidth; |
| sal_Bool bTextRTL; |
| |
| #ifdef _SV_RULER_CXX |
| public: |
| ImplRulerData(); |
| ~ImplRulerData(); |
| ImplRulerData& operator=( const ImplRulerData& rData ); |
| #endif |
| }; |
| |
| |
| struct ImplRulerUnitData |
| { |
| MapUnit eMapUnit; // MAP_UNIT zum Umrechnen |
| long nTickUnit; // Teiler fuer Einheit |
| long nTick1; // Schrittweite |
| long nTick2; // Tick fuer halbe Werte |
| long nTick3; // Tick fuer Zahlenausgabe |
| long n100THMM; // Teiler fuer Einheit |
| sal_uInt16 nUnitDigits; // Anzahl Nachkommastellen |
| sal_Char aUnitStr[8]; // Einheiten-String |
| }; |
| |
| static ImplRulerUnitData aImplRulerUnitTab[RULER_UNIT_COUNT] = |
| { |
| { MAP_100TH_MM, 100, 25, 50, 100, 100, 3, " mm" }, // MM |
| { MAP_100TH_MM, 1000, 250, 500, 1000, 1000, 3, " cm" }, // CM |
| { MAP_MM, 1000, 250, 500, 1000, 10000, 4, " m" }, // M |
| { MAP_CM, 100000, 25000, 50000, 100000, 100000, 6, " km" }, // KM |
| { MAP_100TH_INCH, 100, 10, 50, 100, 2540, 3, "\"" }, // INCH |
| { MAP_100TH_INCH, 1200, 120, 600, 1200, 30480, 3, "'" }, // FOOT |
| { MAP_10TH_INCH, 633600, 63360, 316800, 633600, 1609344, 4, " miles" }, // MILE |
| { MAP_POINT, 1, 12, 12, 36, 353, 2, " pt" }, // POINT |
| { MAP_100TH_MM, 423, 423, 423, 846, 423, 3, " pi" } // PICA |
| }; |
| |
| // ======================================================================= |
| |
| struct ImplRulerHitTest |
| { |
| long nPos; |
| RulerType eType; |
| sal_uInt16 nAryPos; |
| sal_uInt16 mnDragSize; |
| sal_Bool bSize; |
| sal_Bool bSizeBar; |
| sal_Bool bExpandTest; |
| ImplRulerHitTest() : |
| bExpandTest( sal_False ) {} |
| }; |
| |
| // ======================================================================= |
| |
| ImplRulerData::ImplRulerData() |
| { |
| memset( this, 0, sizeof( ImplRulerData ) ); |
| |
| // PageBreite == EditWinBreite |
| bAutoPageWidth = sal_True; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ImplRulerData::~ImplRulerData() |
| { |
| delete[] pLines; |
| delete[] pArrows; |
| delete[] pBorders; |
| delete[] pIndents; |
| delete[] pTabs; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ImplRulerData& ImplRulerData::operator=( const ImplRulerData& rData ) |
| { |
| delete[] pLines; |
| delete[] pArrows; |
| delete[] pBorders; |
| delete[] pIndents; |
| delete[] pTabs; |
| |
| memcpy( this, &rData, sizeof( ImplRulerData ) ); |
| |
| if ( rData.pLines ) |
| { |
| pLines = new RulerLine[nLines]; |
| memcpy( pLines, rData.pLines, nLines*sizeof( RulerLine ) ); |
| } |
| |
| if ( rData.pArrows ) |
| { |
| pArrows = new RulerArrow[nArrows]; |
| memcpy( pArrows, rData.pArrows, nArrows*sizeof( RulerArrow ) ); |
| } |
| |
| if ( rData.pBorders ) |
| { |
| pBorders = new RulerBorder[nBorders]; |
| memcpy( pBorders, rData.pBorders, nBorders*sizeof( RulerBorder ) ); |
| } |
| |
| if ( rData.pIndents ) |
| { |
| pIndents = new RulerIndent[nIndents]; |
| memcpy( pIndents, rData.pIndents, nIndents*sizeof( RulerIndent ) ); |
| } |
| |
| if ( rData.pTabs ) |
| { |
| pTabs = new RulerTab[nTabs]; |
| memcpy( pTabs, rData.pTabs, nTabs*sizeof( RulerTab ) ); |
| } |
| |
| return *this; |
| } |
| |
| // ======================================================================= |
| |
| void Ruler::ImplInit( WinBits nWinBits ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| |
| // Default WinBits setzen |
| if ( !(nWinBits & WB_VERT) ) |
| { |
| nWinBits |= WB_HORZ; |
| |
| // --- RTL --- no UI mirroring for horizontal rulers, because |
| // the document is also not mirrored |
| EnableRTL( sal_False ); |
| } |
| |
| // Variablen initialisieren |
| mnWinStyle = nWinBits; // Window-Style |
| mnBorderOff = 0; // Border-Offset |
| mnWinOff = 0; // EditWinOffset |
| mnWinWidth = 0; // EditWinWidth |
| mnWidth = 0; // Fensterbreite |
| mnHeight = 0; // Fensterhoehe |
| mnVirOff = 0; // Offset des VirtualDeice vom linke/oberen Rand |
| mnVirWidth = 0; // Breite bzw. Hoehe vom VirtualDevice |
| mnVirHeight = 0; // Hoehe bzw. Breite vom VirtualDevice |
| mnDragPos = 0; // Drag-Position (NullPunkt) |
| mnUpdateEvtId = 0; // Noch kein Update-Event verschickt |
| mnDragAryPos = 0; // Drag-Array-Index |
| mnDragSize = 0; // Wird beim Draggen die Groesse geaendert |
| mnDragScroll = 0; // Soll beim Draggen gescrollt werden |
| mnDragModifier = 0; // Modifier-Tasten beim Draggen |
| mnExtraStyle = 0; // Style des Extra-Feldes |
| mnExtraClicks = 0; // Click-Anzahl fuer Extra-Feld |
| mnExtraModifier = 0; // Modifier-Tasten beim Click im Extrafeld |
| mbCalc = sal_True; // Muessen Pagebreiten neu berechnet werden |
| mbFormat = sal_True; // Muss neu ausgegeben werden |
| mbDrag = sal_False; // Sind wir im Drag-Modus |
| mbDragDelete = sal_False; // Wird Maus beim Draggen unten rausgezogen |
| mbDragCanceled = sal_False; // Wurde Dragging abgebrochen |
| mbAutoWinWidth = sal_True; // EditWinBreite == RulerBreite |
| mbActive = sal_True; // Ist Lineal aktiv |
| mnUpdateFlags = 0; // Was soll im Update-Handler upgedatet werden |
| mpData = mpSaveData; // Wir zeigen auf die normalen Daten |
| meExtraType = RULER_EXTRA_DONTKNOW; // Was im ExtraFeld dargestellt wird |
| meDragType = RULER_TYPE_DONTKNOW; // Gibt an, was gedragt wird |
| |
| // Units initialisieren |
| mnUnitIndex = RULER_UNIT_CM; |
| meUnit = FUNIT_CM; |
| maZoom = Fraction( 1, 1 ); |
| meSourceUnit = MAP_100TH_MM; |
| |
| // Border-Breiten berechnen |
| if ( nWinBits & WB_BORDER ) |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| mnBorderWidth = 2; |
| else |
| mnBorderWidth = 1; |
| } |
| else |
| mnBorderWidth = 0; |
| |
| // Einstellungen setzen |
| ImplInitSettings( sal_True, sal_True, sal_True ); |
| |
| // Default-Groesse setzen |
| long nDefHeight = GetTextHeight() + RULER_OFF*2 + RULER_TEXTOFF*2 + mnBorderWidth; |
| Size aDefSize; |
| if ( nWinBits & WB_HORZ ) |
| aDefSize.Height() = nDefHeight; |
| else |
| aDefSize.Width() = nDefHeight; |
| SetOutputSizePixel( aDefSize ); |
| SetType(WINDOW_RULER); |
| pAccContext = NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Ruler::Ruler( Window* pParent, WinBits nWinStyle ) : |
| Window( pParent, nWinStyle & WB_3DLOOK ), |
| maVirDev( *this ), |
| maMapMode( MAP_100TH_MM ), |
| mpSaveData(new ImplRulerData), |
| mpData(0), |
| mpDragData(new ImplRulerData) |
| { |
| ImplInit( nWinStyle ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Ruler::~Ruler() |
| { |
| if ( mnUpdateEvtId ) |
| Application::RemoveUserEvent( mnUpdateEvtId ); |
| delete mpSaveData; |
| delete mpDragData; |
| if( pAccContext ) |
| pAccContext->release(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplVDrawLine( long nX1, long nY1, long nX2, long nY2 ) |
| { |
| if ( nX1 < -RULER_CLIP ) |
| { |
| nX1 = -RULER_CLIP; |
| if ( nX2 < -RULER_CLIP ) |
| return; |
| } |
| long nClip = mnVirWidth+RULER_CLIP; |
| if ( nX2 > nClip ) |
| { |
| nX2 = nClip; |
| if ( nX1 > nClip ) |
| return; |
| } |
| |
| if ( mnWinStyle & WB_HORZ ) |
| maVirDev.DrawLine( Point( nX1, nY1 ), Point( nX2, nY2 ) ); |
| else |
| maVirDev.DrawLine( Point( nY1, nX1 ), Point( nY2, nX2 ) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplVDrawRect( long nX1, long nY1, long nX2, long nY2 ) |
| { |
| if ( nX1 < -RULER_CLIP ) |
| { |
| nX1 = -RULER_CLIP; |
| if ( nX2 < -RULER_CLIP ) |
| return; |
| } |
| long nClip = mnVirWidth+RULER_CLIP; |
| if ( nX2 > nClip ) |
| { |
| nX2 = nClip; |
| if ( nX1 > nClip ) |
| return; |
| } |
| |
| if ( mnWinStyle & WB_HORZ ) |
| maVirDev.DrawRect( Rectangle( nX1, nY1, nX2, nY2 ) ); |
| else |
| maVirDev.DrawRect( Rectangle( nY1, nX1, nY2, nX2 ) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplVDrawText( long nX, long nY, const String& rText ) |
| { |
| if ( (nX > -RULER_CLIP) && (nX < mnVirWidth+RULER_CLIP) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| maVirDev.DrawText( Point( nX, nY ), rText ); |
| else |
| maVirDev.DrawText( Point( nY, nX ), rText ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplInvertLines( sal_Bool bErase ) |
| { |
| // Positionslinien |
| if ( mpData->nLines && mbActive && !mbDrag && !mbFormat && |
| !(mnUpdateFlags & RULER_UPDATE_LINES) ) |
| { |
| long n; |
| long nNullWinOff = mpData->nNullVirOff+mnVirOff; |
| long nRulX1 = mpData->nRulVirOff+mnVirOff; |
| long nRulX2 = nRulX1+mpData->nRulWidth; |
| long nY = (RULER_OFF*2)+mnVirHeight-1; |
| |
| // Rectangle berechnen |
| Rectangle aRect; |
| if ( mnWinStyle & WB_HORZ ) |
| aRect.Bottom() = nY; |
| else |
| aRect.Right() = nY; |
| |
| // Linien ausgeben |
| for ( sal_uInt16 i = 0; i < mpData->nLines; i++ ) |
| { |
| n = mpData->pLines[i].nPos+nNullWinOff; |
| if ( (n >= nRulX1) && (n < nRulX2) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| aRect.Left() = n; |
| aRect.Right() = n; |
| } |
| else |
| { |
| aRect.Top() = n; |
| aRect.Bottom() = n; |
| } |
| if ( bErase ) |
| { |
| Rectangle aTempRect = aRect; |
| if ( mnWinStyle & WB_HORZ ) |
| aTempRect.Bottom() = RULER_OFF-1; |
| else |
| aTempRect.Right() = RULER_OFF-1; |
| Erase( aTempRect ); |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| aTempRect.Bottom() = aRect.Bottom(); |
| aTempRect.Top() = aTempRect.Bottom()-RULER_OFF+1; |
| } |
| else |
| { |
| aTempRect.Right() = aRect.Right(); |
| aTempRect.Left() = aTempRect.Right()-RULER_OFF+1; |
| } |
| Erase( aTempRect ); |
| } |
| Invert( aRect ); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawTicks( long nMin, long nMax, long nStart, long nCenter ) |
| { |
| long n = 0; |
| long nTick = 0; |
| long nTick3 = aImplRulerUnitTab[mnUnitIndex].nTick3; |
| long nTickCount = aImplRulerUnitTab[mnUnitIndex].nTick1; |
| Size aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode ); |
| long nTickWidth; |
| long nX; |
| long nY; |
| sal_Bool bNoTicks = sal_False; |
| |
| // Groessenvorberechnung |
| // Sizes calculation |
| sal_Bool bVertRight = sal_False; |
| if ( mnWinStyle & WB_HORZ ) |
| nTickWidth = aPixSize.Width(); |
| else |
| { |
| Font aFont = GetFont(); |
| if ( mnWinStyle & WB_RIGHT_ALIGNED ) |
| { |
| aFont.SetOrientation( 2700 ); |
| bVertRight = sal_True; |
| } |
| else |
| aFont.SetOrientation( 900 ); |
| maVirDev.SetFont( aFont ); |
| nTickWidth = aPixSize.Height(); |
| } |
| long nMaxWidth = maVirDev.PixelToLogic( Size( mpData->nPageWidth, 0 ), maMapMode ).Width(); |
| if ( nMaxWidth < 0 ) |
| nMaxWidth = -nMaxWidth; |
| nMaxWidth /= aImplRulerUnitTab[mnUnitIndex].nTickUnit; |
| UniString aNumStr( UniString::CreateFromInt32( nMaxWidth ) ); |
| long nTxtWidth = GetTextWidth( aNumStr ); |
| |
| const long nTextOff = 4; |
| if ( nTickWidth < nTxtWidth+nTextOff ) |
| { |
| // Calculate the scale of the ruler |
| long nMulti = 1; |
| long nOrgTick3 = nTick3; |
| while ( nTickWidth < nTxtWidth+nTextOff ) |
| { |
| long nOldMulti = nMulti; |
| if ( !nTickWidth ) //If nTickWidth equals 0 |
| nMulti *= 10; |
| else if ( nMulti < 10 ) |
| nMulti++; |
| else if ( nMulti < 100 ) |
| nMulti += 10; |
| else if ( nMulti < 1000 ) |
| nMulti += 100; |
| else |
| nMulti += 1000; |
| // Ueberlauf, dann geben wir nichts aus, da wir bei so einem |
| // unsinnigen Massstab sowieso nichts vernuenftiges anzeigen |
| // koennen |
| if ( nMulti < nOldMulti ) |
| { |
| bNoTicks = sal_True; |
| break; |
| } |
| |
| nTick3 = nOrgTick3 * nMulti; |
| aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode ); |
| if ( mnWinStyle & WB_HORZ ) |
| nTickWidth = aPixSize.Width(); |
| else |
| nTickWidth = aPixSize.Height(); |
| } |
| nTickCount = nTick3; |
| } |
| else |
| maVirDev.SetLineColor( GetSettings().GetStyleSettings().GetWindowTextColor() ); |
| |
| if ( !bNoTicks ) |
| { |
| long nTxtWidth2; |
| long nTxtHeight2 = GetTextHeight()/2; |
| while ( ((nStart-n) >= nMin) || ((nStart+n) <= nMax) ) |
| { |
| // Null-Punkt |
| if ( !nTick ) |
| { |
| if ( nStart > nMin ) |
| { |
| // 0 is only painted when Margin1 is not equal to zero |
| if ( (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) || (mpData->nMargin1 != 0) ) |
| { |
| aNumStr = (sal_Unicode)'0'; |
| nTxtWidth2 = maVirDev.GetTextWidth( aNumStr )/2; |
| if ( (mnWinStyle & WB_HORZ)^mpData->bTextRTL ) |
| nX = nStart-nTxtWidth2; |
| else |
| nX = nStart+nTxtWidth2; |
| long n_Y = bVertRight ? nCenter+nTxtHeight2 : nCenter-nTxtHeight2; |
| ImplVDrawText( nX, n_Y, aNumStr ); |
| } |
| } |
| } |
| else |
| { |
| aPixSize = maVirDev.LogicToPixel( Size( nTick, nTick ), maMapMode ); |
| |
| if ( mnWinStyle & WB_HORZ ) |
| n = aPixSize.Width(); |
| else |
| n = aPixSize.Height(); |
| |
| // Tick3 - Output (Text) |
| if ( !(nTick % nTick3) ) |
| { |
| aNumStr = UniString::CreateFromInt32( nTick / aImplRulerUnitTab[mnUnitIndex].nTickUnit ); |
| nTxtWidth2 = GetTextWidth( aNumStr )/2; |
| |
| nX = nStart+n; |
| //different orientation needs a different starting position |
| nY = bVertRight ? nCenter+nTxtHeight2 : nCenter-nTxtHeight2; |
| |
| // Check if we can display full number |
| if ( nX < (nMax-nTxtWidth2) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| nX -= nTxtWidth2; |
| else |
| nX += nTxtWidth2; |
| ImplVDrawText( nX, nY, aNumStr ); |
| } |
| nX = nStart-n; |
| if ( nX > (nMin+nTxtWidth2) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| nX -= nTxtWidth2; |
| else |
| nX += nTxtWidth2; |
| ImplVDrawText( nX, nY, aNumStr ); |
| } |
| } |
| // Tick/Tick2 - Output (Strokes) |
| else |
| { |
| if ( !(nTick % aImplRulerUnitTab[mnUnitIndex].nTick2) ) |
| nTickWidth = RULER_TICK2_WIDTH; |
| else |
| nTickWidth = RULER_TICK1_WIDTH; |
| long nT1 = nCenter-(nTickWidth/2); |
| long nT2 = nT1+nTickWidth-1; |
| long nT; |
| |
| nT = nStart+n; |
| if ( nT < nMax ) |
| ImplVDrawLine( nT, nT1, nT, nT2 ); |
| nT = nStart-n; |
| if ( nT > nMin ) |
| ImplVDrawLine( nT, nT1, nT, nT2 ); |
| } |
| } |
| // #i49017# with some zoom factors the value nTick can overflow |
| if( ((sal_uLong)nTick + (sal_uLong)nTickCount) > (sal_uLong)LONG_MAX) |
| break; |
| nTick += nTickCount; |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawArrows( long nCenter ) |
| { |
| sal_uInt16 i; |
| long n1; |
| long n2; |
| long n3; |
| long n4; |
| long nLogWidth; |
| String aStr; |
| String aStr2; |
| sal_Bool bDrawUnit; |
| long nTxtWidth; |
| long nTxtHeight2 = GetTextHeight()/2; |
| |
| const vcl::I18nHelper& rI18nHelper = GetSettings().GetLocaleI18nHelper(); |
| |
| maVirDev.SetLineColor( GetSettings().GetStyleSettings().GetWindowTextColor() ); |
| for ( i = 0; i < mpData->nArrows; i++ ) |
| { |
| n1 = mpData->pArrows[i].nPos+mpData->nNullVirOff+1; |
| n2 = n1+mpData->pArrows[i].nWidth-2; |
| |
| // Einheit umrechnen |
| nLogWidth = mpData->pArrows[i].nLogWidth; |
| if ( meSourceUnit == MAP_TWIP ) |
| { |
| if ( nLogWidth >= 100000 ) |
| nLogWidth = (nLogWidth*254)/144; |
| else |
| nLogWidth = (nLogWidth*2540)/1440; |
| } |
| if ( nLogWidth >= 1000000 ) |
| nLogWidth = (nLogWidth / aImplRulerUnitTab[mnUnitIndex].n100THMM) * 1000; |
| else |
| nLogWidth = (nLogWidth*1000) / aImplRulerUnitTab[mnUnitIndex].n100THMM; |
| aStr = rI18nHelper.GetNum( nLogWidth, aImplRulerUnitTab[mnUnitIndex].nUnitDigits, sal_True, sal_False ); |
| |
| // Einheit an den String haengen |
| aStr2 = aStr; |
| aStr2.AppendAscii( aImplRulerUnitTab[mnUnitIndex].aUnitStr ); |
| |
| // Textbreite ermitteln |
| bDrawUnit = sal_True; |
| nTxtWidth = GetTextWidth( aStr2 ); |
| if ( nTxtWidth < mpData->pArrows[i].nWidth-10 ) |
| aStr = aStr2; |
| else |
| { |
| nTxtWidth = GetTextWidth( aStr ); |
| if ( nTxtWidth > mpData->pArrows[i].nWidth-10 ) |
| bDrawUnit = sal_False; |
| } |
| |
| // Ist genuegen Platz fuer Einheiten-String vorhanden |
| if ( bDrawUnit ) |
| { |
| n3 = n1 + ((n2-n1)/2) - 1; |
| if ( mnWinStyle & WB_HORZ ) |
| n3 -= nTxtWidth/2; |
| else |
| n3 += nTxtWidth/2; |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| n4 = n3 + nTxtWidth + 2; |
| ImplVDrawLine( n1, nCenter, n3, nCenter ); |
| ImplVDrawLine( n4, nCenter, n2, nCenter ); |
| } |
| else |
| { |
| n4 = n3 - nTxtWidth - 2; |
| ImplVDrawLine( n1, nCenter, n4, nCenter ); |
| ImplVDrawLine( n3, nCenter, n2, nCenter ); |
| } |
| ImplVDrawText( n3, nCenter-nTxtHeight2, aStr ); |
| } |
| else |
| ImplVDrawLine( n1, nCenter, n2, nCenter ); |
| ImplVDrawLine( n1+1, nCenter-1, n1+1, nCenter+1 ); |
| ImplVDrawLine( n1+2, nCenter-2, n1+2, nCenter+2 ); |
| ImplVDrawLine( n2-1, nCenter-1, n2-1, nCenter+1 ); |
| ImplVDrawLine( n2-2, nCenter-2, n2-2, nCenter+2 ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawBorders( long nMin, long nMax, long nVirTop, long nVirBottom ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| long n; |
| long n1; |
| long n2; |
| long nTemp1; |
| long nTemp2; |
| sal_uInt16 i; |
| |
| for ( i = 0; i < mpData->nBorders; i++ ) |
| { |
| if ( mpData->pBorders[i].nStyle & RULER_STYLE_INVISIBLE ) |
| continue; |
| |
| n1 = mpData->pBorders[i].nPos+mpData->nNullVirOff; |
| n2 = n1+mpData->pBorders[i].nWidth; |
| |
| if ( ((n1 >= nMin) && (n1 <= nMax)) || ((n2 >= nMin) && (n2 <= nMax)) ) |
| { |
| if ( (n2-n1) > 3 ) |
| { |
| maVirDev.SetLineColor(); |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); |
| else |
| maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); |
| ImplVDrawRect( n1, nVirTop, n2, nVirBottom ); |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); |
| ImplVDrawLine( n1+1, nVirTop, n1+1, nVirBottom ); |
| ImplVDrawLine( n1, nVirTop, n2, nVirTop ); |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| ImplVDrawLine( n1, nVirTop, n1, nVirBottom ); |
| ImplVDrawLine( n1, nVirBottom, n2, nVirBottom ); |
| ImplVDrawLine( n2-1, nVirTop, n2-1, nVirBottom ); |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| ImplVDrawLine( n2, nVirTop, n2, nVirBottom ); |
| } |
| else |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| ImplVDrawLine( n1, nVirTop, n1, nVirBottom ); |
| ImplVDrawLine( n2, nVirTop, n2, nVirBottom ); |
| } |
| |
| if ( mpData->pBorders[i].nStyle & RULER_BORDER_VARIABLE ) |
| { |
| if ( n2-n1 > RULER_VAR_SIZE+4 ) |
| { |
| nTemp1 = n1 + (((n2-n1+1)-RULER_VAR_SIZE) / 2); |
| nTemp2 = nVirTop + (((nVirBottom-nVirTop+1)-RULER_VAR_SIZE) / 2); |
| long nTemp3 = nTemp1+RULER_VAR_SIZE-1; |
| long nTemp4 = nTemp2+RULER_VAR_SIZE-1; |
| long nTempY = nTemp2; |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); |
| else |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| while ( nTempY <= nTemp4 ) |
| { |
| ImplVDrawLine( nTemp1, nTempY, nTemp3, nTempY ); |
| nTempY += 2; |
| } |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| nTempY = nTemp2+1; |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| while ( nTempY <= nTemp4 ) |
| { |
| ImplVDrawLine( nTemp1, nTempY, nTemp3, nTempY ); |
| nTempY += 2; |
| } |
| } |
| } |
| } |
| |
| if ( mpData->pBorders[i].nStyle & RULER_BORDER_SIZEABLE ) |
| { |
| if ( n2-n1 > RULER_VAR_SIZE+10 ) |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| ImplVDrawLine( n1+4, nVirTop+3, n1+4, nVirBottom-3 ); |
| ImplVDrawLine( n2-5, nVirTop+3, n2-5, nVirBottom-3 ); |
| maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); |
| ImplVDrawLine( n1+5, nVirTop+3, n1+5, nVirBottom-3 ); |
| ImplVDrawLine( n2-4, nVirTop+3, n2-4, nVirBottom-3 ); |
| } |
| else |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| ImplVDrawLine( n1+4, nVirTop+3, n1+4, nVirBottom-3 ); |
| ImplVDrawLine( n2-4, nVirTop+3, n2-4, nVirBottom-3 ); |
| } |
| } |
| } |
| } |
| else |
| { |
| n = n1+((n2-n1)/2); |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| else |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| if ( mpData->pBorders[i].nStyle & RULER_BORDER_SNAP ) |
| ImplVDrawLine( n, nVirTop, n, nVirBottom ); |
| else if ( mpData->pBorders[i].nStyle & RULER_BORDER_MARGIN ) |
| ImplVDrawLine( n, nVirTop, n, nVirBottom ); |
| else |
| { |
| ImplVDrawLine( n-1, nVirTop, n-1, nVirBottom ); |
| ImplVDrawLine( n+1, nVirTop, n+1, nVirBottom ); |
| maVirDev.SetLineColor(); |
| maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); |
| ImplVDrawRect( n, nVirTop, n, nVirBottom ); |
| } |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawIndent( const Polygon& rPoly, sal_uInt16 nStyle ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| Point aPos1; |
| Point aPos2; |
| sal_uInt16 nIndentStyle = nStyle & RULER_INDENT_STYLE; |
| |
| if ( nStyle & RULER_STYLE_INVISIBLE ) |
| return; |
| |
| if ( nStyle & RULER_STYLE_DONTKNOW ) |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); |
| } |
| else |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetDarkShadowColor() ); |
| maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); |
| } |
| |
| maVirDev.DrawPolygon( rPoly ); |
| |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) && !(nStyle & RULER_STYLE_DONTKNOW) ) |
| { |
| if ( nIndentStyle == RULER_INDENT_BOTTOM ) |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); |
| aPos1 = rPoly.GetPoint( 2 ); |
| aPos1.X()++; |
| aPos2 = rPoly.GetPoint( 1 ); |
| aPos2.X()++; |
| maVirDev.DrawLine( aPos2, aPos1 ); |
| aPos2.X()--; |
| aPos2.Y()++; |
| aPos1 = rPoly.GetPoint( 0 ); |
| aPos1.Y()++; |
| maVirDev.DrawLine( aPos2, aPos1 ); |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| aPos2 = rPoly.GetPoint( 4 ); |
| aPos2.Y()++; |
| maVirDev.DrawLine( aPos1, aPos2 ); |
| aPos2.X()--; |
| aPos1 = rPoly.GetPoint( 3 ); |
| aPos1.X()--; |
| maVirDev.DrawLine( aPos2, aPos1 ); |
| aPos1.Y()--; |
| aPos2 = rPoly.GetPoint( 2 ); |
| aPos2.X()++; |
| aPos2.Y()--; |
| maVirDev.DrawLine( aPos2, aPos1 ); |
| } |
| else |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetLightColor() ); |
| aPos1 = rPoly.GetPoint( 2 ); |
| aPos1.X()++; |
| aPos1.Y()++; |
| aPos2 = rPoly.GetPoint( 3 ); |
| aPos2.Y()++; |
| maVirDev.DrawLine( aPos1, aPos2 ); |
| aPos2 = rPoly.GetPoint( 1 ); |
| aPos2.X()++; |
| maVirDev.DrawLine( aPos1, aPos2 ); |
| aPos2.X()--; |
| aPos2.Y()--; |
| aPos1 = rPoly.GetPoint( 0 ); |
| aPos1.Y()--; |
| maVirDev.DrawLine( aPos2, aPos1 ); |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| aPos2 = rPoly.GetPoint( 4 ); |
| aPos2.Y()--; |
| maVirDev.DrawLine( aPos1, aPos2 ); |
| aPos2.X()--; |
| aPos1 = rPoly.GetPoint( 3 ); |
| aPos1.X()--; |
| maVirDev.DrawLine( aPos2, aPos1 ); |
| } |
| |
| maVirDev.SetLineColor( rStyleSettings.GetDarkShadowColor() ); |
| maVirDev.SetFillColor(); |
| maVirDev.DrawPolygon( rPoly ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawIndents( long nMin, long nMax, long nVirTop, long nVirBottom ) |
| { |
| sal_uInt16 j; |
| long n; |
| long nIndentHeight = (mnVirHeight/2) - 1; |
| long nIndentWidth2 = nIndentHeight-3; |
| Polygon aPoly( 5 ); |
| |
| for ( j = 0; j < mpData->nIndents; j++ ) |
| { |
| if ( mpData->pIndents[j].nStyle & RULER_STYLE_INVISIBLE ) |
| continue; |
| |
| sal_uInt16 nStyle = mpData->pIndents[j].nStyle; |
| sal_uInt16 nIndentStyle = nStyle & RULER_INDENT_STYLE; |
| |
| n = mpData->pIndents[j].nPos+mpData->nNullVirOff; |
| |
| if ( (n >= nMin) && (n <= nMax) ) |
| { |
| if(nIndentStyle == RULER_INDENT_BORDER) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| ImplVDrawLine( n, nVirTop, n, nVirBottom ); |
| } |
| else if ( nIndentStyle == RULER_INDENT_BOTTOM ) |
| { |
| aPoly.SetPoint( Point( n+0, nVirBottom-nIndentHeight ), 0 ); |
| aPoly.SetPoint( Point( n-nIndentWidth2, nVirBottom-3 ), 1 ); |
| aPoly.SetPoint( Point( n-nIndentWidth2, nVirBottom ), 2 ); |
| aPoly.SetPoint( Point( n+nIndentWidth2, nVirBottom ), 3 ); |
| aPoly.SetPoint( Point( n+nIndentWidth2, nVirBottom-3 ), 4 ); |
| } |
| else |
| { |
| aPoly.SetPoint( Point( n+0, nVirTop+nIndentHeight ), 0 ); |
| aPoly.SetPoint( Point( n-nIndentWidth2, nVirTop+3 ), 1 ); |
| aPoly.SetPoint( Point( n-nIndentWidth2, nVirTop ), 2 ); |
| aPoly.SetPoint( Point( n+nIndentWidth2, nVirTop ), 3 ); |
| aPoly.SetPoint( Point( n+nIndentWidth2, nVirTop+3 ), 4 ); |
| } |
| |
| if(0 == (mnWinStyle & WB_HORZ)) |
| { |
| Point aTmp; |
| for(sal_uInt16 i = 0; i < 5; i++) |
| { |
| aTmp = aPoly[i]; |
| Point aSet(nVirBottom - aTmp.Y(), aTmp.X()); |
| aPoly[i] = aSet; |
| } |
| } |
| if(RULER_INDENT_BORDER != nIndentStyle) |
| ImplDrawIndent( aPoly, nStyle ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplCenterTabPos( Point& rPos, sal_uInt16 nTabStyle ) |
| { |
| sal_Bool bRTL = 0 != (nTabStyle & RULER_TAB_RTL); |
| nTabStyle &= RULER_TAB_STYLE; |
| rPos.Y() += RULER_TAB_HEIGHT/2; |
| if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||( bRTL && nTabStyle == RULER_TAB_RIGHT)) |
| rPos.X() -= RULER_TAB_WIDTH/2; |
| else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||( bRTL && nTabStyle == RULER_TAB_LEFT)) |
| rPos.X() += RULER_TAB_WIDTH/2; |
| } |
| |
| // ----------------------------------------------------------------------- |
| void lcl_RotateRect_Impl(Rectangle& rRect, const long nReference, sal_Bool bRightAligned) |
| { |
| if(!rRect.IsEmpty()) |
| { |
| Rectangle aTmp(rRect); |
| rRect.Top() = aTmp.Left(); |
| rRect.Bottom() = aTmp.Right(); |
| rRect.Left() = aTmp.Top(); |
| rRect.Right() = aTmp.Bottom(); |
| if(bRightAligned) |
| { |
| long nRef = 2 * nReference; |
| rRect.Left() = nRef - rRect.Left(); |
| rRect.Right() = nRef - rRect.Right(); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------- |
| |
| static void ImplDrawRulerTab( OutputDevice* pDevice, |
| const Point& rPos, sal_uInt16 nStyle, WinBits nWinBits ) |
| { |
| if ( nStyle & RULER_STYLE_INVISIBLE ) |
| return; |
| |
| sal_uInt16 nTabStyle = nStyle & RULER_TAB_STYLE; |
| sal_Bool bRTL = 0 != (nStyle & RULER_TAB_RTL); |
| Rectangle aRect1, aRect2, aRect3; |
| aRect3.SetEmpty(); |
| if ( nTabStyle == RULER_TAB_DEFAULT ) |
| { |
| aRect1.Left() = rPos.X() - RULER_TAB_DWIDTH2 + 1 ; |
| aRect1.Top() = rPos.Y() - RULER_TAB_DHEIGHT2 + 1 ; |
| aRect1.Right() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH ; |
| aRect1.Bottom() = rPos.Y(); |
| aRect2.Left() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH3; |
| aRect2.Top() = rPos.Y() - RULER_TAB_DHEIGHT + 1; |
| aRect2.Right() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH3 + RULER_TAB_DWIDTH4 - 1; |
| aRect2.Bottom() = rPos.Y(); |
| |
| } |
| else if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||( bRTL && nTabStyle == RULER_TAB_RIGHT)) |
| { |
| aRect1.Left() = rPos.X(); |
| aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1; |
| aRect1.Right() = rPos.X() + RULER_TAB_WIDTH - 1; |
| aRect1.Bottom() = rPos.Y(); |
| aRect2.Left() = rPos.X(); |
| aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1; |
| aRect2.Right() = rPos.X() + RULER_TAB_WIDTH2 - 1; |
| aRect2.Bottom() = rPos.Y(); |
| } |
| else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||( bRTL && nTabStyle == RULER_TAB_LEFT)) |
| { |
| aRect1.Left() = rPos.X() - RULER_TAB_WIDTH + 1; |
| aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1; |
| aRect1.Right() = rPos.X(); |
| aRect1.Bottom() = rPos.Y(); |
| aRect2.Left() = rPos.X() - RULER_TAB_WIDTH2 + 1; |
| aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1; |
| aRect2.Right() = rPos.X(); |
| aRect2.Bottom() = rPos.Y(); |
| } |
| else |
| { |
| aRect1.Left() = rPos.X() - RULER_TAB_CWIDTH2 + 1; |
| aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1; |
| aRect1.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH; |
| aRect1.Bottom() = rPos.Y(); |
| aRect2.Left() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH3; |
| aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1; |
| aRect2.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH3 + RULER_TAB_CWIDTH4 - 1; |
| aRect2.Bottom() = rPos.Y(); |
| |
| if ( nTabStyle == RULER_TAB_DECIMAL ) |
| { |
| aRect3.Left() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH - 1; |
| aRect3.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1 + 1; |
| aRect3.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH; |
| aRect3.Bottom()= rPos.Y() - RULER_TAB_HEIGHT + 1 + 2 ; |
| } |
| } |
| if( 0 == (nWinBits&WB_HORZ) ) |
| { |
| sal_Bool bRightAligned = 0 != (nWinBits&WB_RIGHT_ALIGNED); |
| lcl_RotateRect_Impl(aRect1, rPos.Y(), bRightAligned); |
| lcl_RotateRect_Impl(aRect2, rPos.Y(), bRightAligned); |
| lcl_RotateRect_Impl(aRect3, rPos.Y(), bRightAligned); |
| } |
| pDevice->DrawRect( aRect1 ); |
| pDevice->DrawRect( aRect2 ); |
| if(!aRect2.IsEmpty()) |
| pDevice->DrawRect( aRect3 ); |
| |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle ) |
| { |
| if ( nStyle & RULER_STYLE_INVISIBLE ) |
| return; |
| |
| pDevice->SetLineColor(); |
| if ( nStyle & RULER_STYLE_DONTKNOW ) |
| pDevice->SetFillColor( GetSettings().GetStyleSettings().GetFaceColor() ); |
| else |
| pDevice->SetFillColor( GetSettings().GetStyleSettings().GetWindowTextColor() ); |
| |
| if(mpData->bTextRTL) |
| nStyle |= RULER_TAB_RTL; |
| ImplDrawRulerTab( pDevice, rPos, nStyle, GetStyle()); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawTabs( long nMin, long nMax, long nVirTop, long nVirBottom ) |
| { |
| for ( sal_uInt16 i = 0; i < mpData->nTabs; i++ ) |
| { |
| if ( mpData->pTabs[i].nStyle & RULER_STYLE_INVISIBLE ) |
| continue; |
| |
| long n; |
| n = mpData->pTabs[i].nPos; |
| n += +mpData->nNullVirOff; |
| long nTopBottom = GetStyle() & WB_RIGHT_ALIGNED ? nVirTop : nVirBottom; |
| if ( (n >= nMin) && (n <= nMax) ) |
| ImplDrawTab( &maVirDev, Point( n, nTopBottom ), mpData->pTabs[i].nStyle ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplInitSettings( sal_Bool bFont, |
| sal_Bool bForeground, sal_Bool bBackground ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| |
| if ( bFont ) |
| { |
| Font aFont; |
| aFont = rStyleSettings.GetToolFont(); |
| if ( IsControlFont() ) |
| aFont.Merge( GetControlFont() ); |
| SetZoomedPointFont( aFont ); |
| } |
| |
| if ( bForeground || bFont ) |
| { |
| Color aColor; |
| if ( IsControlForeground() ) |
| aColor = GetControlForeground(); |
| else |
| aColor = rStyleSettings.GetWindowTextColor(); |
| SetTextColor( aColor ); |
| SetTextFillColor(); |
| } |
| |
| if ( bBackground ) |
| { |
| Color aColor; |
| if ( IsControlBackground() ) |
| aColor = GetControlBackground(); |
| else |
| aColor = rStyleSettings.GetFaceColor(); |
| SetBackground( aColor ); |
| } |
| |
| maVirDev.SetSettings( GetSettings() ); |
| maVirDev.SetBackground( GetBackground() ); |
| Font aFont = GetFont(); |
| if ( mnWinStyle & WB_VERT ) |
| aFont.SetOrientation( 900 ); |
| maVirDev.SetFont( aFont ); |
| maVirDev.SetTextColor( GetTextColor() ); |
| maVirDev.SetTextFillColor( GetTextFillColor() ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplCalc() |
| { |
| // Offset berechnen |
| mpData->nRulVirOff = mnWinOff + mpData->nPageOff; |
| if ( mpData->nRulVirOff > mnVirOff ) |
| mpData->nRulVirOff -= mnVirOff; |
| else |
| mpData->nRulVirOff = 0; |
| long nRulWinOff = mpData->nRulVirOff+mnVirOff; |
| |
| // Nicht sichtbaren Bereich der Page berechnen |
| long nNotVisPageWidth; |
| if ( mpData->nPageOff < 0 ) |
| { |
| nNotVisPageWidth = -(mpData->nPageOff); |
| if ( nRulWinOff < mnWinOff ) |
| nNotVisPageWidth -= mnWinOff-nRulWinOff; |
| } |
| else |
| nNotVisPageWidth = 0; |
| |
| // Breite berechnen |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| if ( mbAutoWinWidth ) |
| mnWinWidth = mnWidth - mnVirOff; |
| if ( mpData->bAutoPageWidth ) |
| mpData->nPageWidth = mnWinWidth; |
| mpData->nRulWidth = Min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth ); |
| if ( nRulWinOff+mpData->nRulWidth > mnWidth ) |
| mpData->nRulWidth = mnWidth-nRulWinOff; |
| } |
| else |
| { |
| if ( mbAutoWinWidth ) |
| mnWinWidth = mnHeight - mnVirOff; |
| if ( mpData->bAutoPageWidth ) |
| mpData->nPageWidth = mnWinWidth; |
| mpData->nRulWidth = Min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth ); |
| if ( nRulWinOff+mpData->nRulWidth > mnHeight ) |
| mpData->nRulWidth = mnHeight-nRulWinOff; |
| } |
| |
| mbCalc = sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplFormat() |
| { |
| // Wenn schon formatiert ist, brauchen wir es nicht nochmal |
| if ( !mbFormat ) |
| return; |
| |
| // Wenn Fenster noch keine Groesse hat, brauchen wir noch nichts machen |
| if ( !mnVirWidth ) |
| return; |
| |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| long nP1; // Pixel-Position von Page1 |
| long nP2; // Pixel-Position von Page2 |
| long nM1; // Pixel-Position von Margin1 |
| long nM2; // Pixel-Position von Margin2 |
| long nVirTop; // Obere/Linke-Kante bei Ausgabe |
| long nVirBottom; // Untere/Rechte-Kante bei Ausgabe |
| long nVirLeft; // Linke/Obere-Kante bei Ausgabe |
| long nVirRight; // Rechte/Untere-Kante bei Ausgabe |
| long nNullVirOff; // Fuer schnellere Berechnung |
| |
| // Werte berechnen |
| if ( mbCalc ) |
| ImplCalc(); |
| mpData->nNullVirOff = mnWinOff+mpData->nPageOff+mpData->nNullOff-mnVirOff; |
| nNullVirOff = mpData->nNullVirOff; |
| nVirLeft = mpData->nRulVirOff; |
| nVirRight = nVirLeft+mpData->nRulWidth-1; |
| nVirTop = 0; |
| nVirBottom = mnVirHeight-1; |
| |
| if ( !IsReallyVisible() ) |
| return; |
| |
| Size aVirDevSize; |
| sal_Bool b3DLook = !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO); |
| |
| // VirtualDevice initialize |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| aVirDevSize.Width() = mnVirWidth; |
| aVirDevSize.Height() = mnVirHeight; |
| } |
| else |
| { |
| aVirDevSize.Height() = mnVirWidth; |
| aVirDevSize.Width() = mnVirHeight; |
| } |
| if ( aVirDevSize != maVirDev.GetOutputSizePixel() ) |
| maVirDev.SetOutputSizePixel( aVirDevSize, sal_True ); |
| else |
| maVirDev.Erase(); |
| |
| // Raender berechnen |
| if ( !(mpData->nMargin1Style & RULER_STYLE_INVISIBLE) ) |
| { |
| nM1 = mpData->nMargin1+nNullVirOff; |
| if ( mpData->bAutoPageWidth ) |
| { |
| nP1 = nVirLeft; |
| if ( nM1 < nVirLeft ) |
| nP1--; |
| } |
| else |
| nP1 = nNullVirOff-mpData->nNullOff; |
| } |
| else |
| { |
| nM1 = nVirLeft-1; |
| nP1 = nM1; |
| } |
| if ( !(mpData->nMargin2Style & RULER_STYLE_INVISIBLE) ) |
| { |
| nM2 = mpData->nMargin2+nNullVirOff; |
| if ( mpData->bAutoPageWidth ) |
| { |
| nP2 = nVirRight; |
| if ( nM2 > nVirRight ) |
| nP2++; |
| } |
| else |
| nP2 = nNullVirOff-mpData->nNullOff+mpData->nPageWidth; |
| if ( nM2 > nP2 ) |
| nM2 = nP2; |
| } |
| else |
| { |
| nM2 = nVirRight+1; |
| nP2 = nM2; |
| } |
| |
| // Obere/untere Kante ausgeben |
| if ( b3DLook ) |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| else |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| ImplVDrawLine( nVirLeft, nVirTop, nM1 - 1, nVirTop ); //top left line |
| ImplVDrawLine( nM2 +1, nVirTop, nP2 -1, nVirTop ); //top right line |
| |
| // Jetzt wird zwischen dem Schatten ausgegeben |
| nVirTop++; |
| nVirBottom--; |
| |
| // Margin1, Margin2 und Zwischenraum ausgeben |
| maVirDev.SetLineColor(); |
| if ( b3DLook ) |
| maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); |
| else |
| maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); |
| if ( nM1 > nVirLeft ) |
| ImplVDrawRect( nP1, nVirTop, nM1-1, nVirBottom ); //left gray rectangle |
| if ( nM2 < nP2 ) |
| ImplVDrawRect( nM2+1, nVirTop, nP2, nVirBottom ); //right gray rectangle |
| if ( nM2-nM1 > 0 ) |
| { |
| maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); |
| ImplVDrawRect( nM1, nVirTop, nM2-1, nVirBottom ); //center rectangle |
| } |
| if ( b3DLook ) |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetShadowColor() ); |
| if ( nM1 > nVirLeft ) |
| { |
| ImplVDrawLine( nM1-1, nVirTop, nM1-1, nVirBottom );//right line of the left rectangle |
| ImplVDrawLine( nP1, nVirBottom, nM1-1, nVirBottom );//bottom line of the left rectangle |
| if ( nP1 >= nVirLeft ) |
| { |
| ImplVDrawLine( nP1, nVirTop, nP1, nVirBottom );//left line of the left rectangle |
| ImplVDrawLine( nP1, nVirBottom, nP1+1, nVirBottom );//? |
| } |
| } |
| if ( nM2 < nP2 ) |
| { |
| ImplVDrawLine( nM2+1, nVirBottom, nP2-1, nVirBottom );//bottom line of the right rectangle |
| ImplVDrawLine( nM2+1, nVirTop, nM2+1, nVirBottom );//left line of the right rectangle |
| if ( nP2 <= nVirRight+1 ) |
| ImplVDrawLine( nP2-1, nVirTop, nP2-1, nVirBottom );//right line of the right rectangle |
| } |
| } |
| else |
| { |
| maVirDev.SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| if ( nP1 >= nVirLeft ) |
| ImplVDrawLine( nP1, nVirTop, nP1, nVirBottom+1 ); |
| if ( nM1 > nP1 ) |
| ImplVDrawLine( nM1, nVirTop, nM1, nVirBottom ); |
| if ( nM2 < nP2 ) |
| ImplVDrawLine( nM2, nVirTop, nM2, nVirBottom ); |
| if ( nP2 <= nVirRight+1 ) |
| ImplVDrawLine( nP2, nVirTop, nP2, nVirBottom+1 ); |
| } |
| |
| // Lineal-Beschriftung (nur wenn keine Bemassungspfeile) |
| if ( !mpData->pArrows ) |
| { |
| long nMin = nVirLeft; |
| long nMax = nP2; |
| long nStart = mpData->bTextRTL ? mpData->nMargin2 + nNullVirOff : nNullVirOff; |
| long nCenter = nVirTop+((nVirBottom-nVirTop)/2); |
| |
| // Nicht Schatten uebermalen |
| if ( nP1 > nVirLeft ) |
| nMin++; |
| if ( nP2 < nVirRight ) |
| nMax--; |
| |
| // Draw captions |
| ImplDrawTicks( nMin, nMax, nStart, nCenter ); |
| } |
| |
| // Draw borders |
| if ( mpData->pBorders ) |
| ImplDrawBorders( nVirLeft, nP2, nVirTop, nVirBottom ); |
| |
| // Draw indents |
| if ( mpData->pIndents ) |
| ImplDrawIndents( nVirLeft, nP2, nVirTop-1, nVirBottom+1 ); |
| |
| // Tabs |
| if ( mpData->pTabs ) |
| { |
| ImplDrawTabs( nVirLeft, nP2, nVirTop-1, nVirBottom+1 ); |
| } |
| |
| // Bemassungspfeile |
| if ( mpData->pArrows ) |
| ImplDrawArrows( nVirTop+((nVirBottom-nVirTop)/2) ); |
| |
| // Wir haben formatiert |
| mbFormat = sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplInitExtraField( sal_Bool bUpdate ) |
| { |
| // Extra-Field beruecksichtigen |
| if ( mnWinStyle & WB_EXTRAFIELD ) |
| { |
| maExtraRect.Left() = RULER_OFF; |
| maExtraRect.Top() = RULER_OFF; |
| maExtraRect.Right() = RULER_OFF+mnVirHeight-1; |
| maExtraRect.Bottom() = RULER_OFF+mnVirHeight-1; |
| if(mpData->bTextRTL) |
| { |
| Size aWinSize = GetOutputSizePixel(); |
| if(mnWinStyle & WB_HORZ) |
| maExtraRect.Move(aWinSize.Width() - maExtraRect.GetWidth() - maExtraRect.Left(), 0); |
| else |
| maExtraRect.Move(0, aWinSize.Height() - maExtraRect.GetHeight() - maExtraRect.Top()); |
| mnVirOff = 0; |
| } |
| else |
| mnVirOff = maExtraRect.Right()+1; |
| |
| } |
| else |
| { |
| maExtraRect.SetEmpty(); |
| mnVirOff = 0; |
| } |
| |
| if ( bUpdate ) |
| { |
| mbCalc = sal_True; |
| mbFormat = sal_True; |
| Invalidate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDraw() |
| { |
| if ( mbFormat ) |
| ImplFormat(); |
| |
| if ( IsReallyVisible() ) |
| { |
| // Lineal ueber das VirtualDevice ausgeben |
| Point aOffPos; |
| Size aVirDevSize = maVirDev.GetOutputSizePixel(); |
| // Size aVirDevSize2 = maVirDev.GetOutputSizePixel(); |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| aOffPos.X() = mnVirOff; |
| if(mpData->bTextRTL) |
| aVirDevSize.Width() -= maExtraRect.GetWidth(); |
| |
| // else |
| // aVirDevSize.Width() -= mnVirOff; |
| aOffPos.Y() = RULER_OFF; |
| } |
| else |
| { |
| aOffPos.X() = RULER_OFF; |
| aOffPos.Y() = mnVirOff; |
| // else |
| // aVirDevSize.Height() -= mnVirOff; |
| } |
| DrawOutDev( aOffPos, aVirDevSize, Point(), aVirDevSize, maVirDev ); |
| |
| // Positionslinien neu malen |
| ImplInvertLines( sal_True ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrawExtra( sal_Bool bPaint ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| Rectangle aRect = maExtraRect; |
| sal_Bool bEraseRect = sal_False; |
| |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| aRect.Left() += 2; |
| aRect.Top() += 2; |
| aRect.Right() -= 2; |
| aRect.Bottom() -= 2; |
| } |
| else |
| { |
| aRect.Left() += 1; |
| aRect.Top() += 1; |
| aRect.Right() -= 1; |
| aRect.Bottom() -= 1; |
| } |
| |
| if ( !bPaint && !(mnExtraStyle & RULER_STYLE_HIGHLIGHT) ) |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| SetFillColor( rStyleSettings.GetFaceColor() ); |
| else |
| SetFillColor( rStyleSettings.GetWindowColor() ); |
| bEraseRect = sal_True; |
| } |
| else |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) && (mnExtraStyle & RULER_STYLE_HIGHLIGHT) ) |
| { |
| SetFillColor( rStyleSettings.GetCheckedColor() ); |
| bEraseRect = sal_True; |
| } |
| } |
| |
| if ( bEraseRect ) |
| { |
| SetLineColor(); |
| DrawRect( aRect ); |
| } |
| |
| // Inhalt ausgeben |
| if ( meExtraType == RULER_EXTRA_NULLOFFSET ) |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| SetLineColor( rStyleSettings.GetButtonTextColor() ); |
| else |
| SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| DrawLine( Point( aRect.Left()+1, aRect.Top()+4 ), |
| Point( aRect.Right()-1, aRect.Top()+4 ) ); |
| DrawLine( Point( aRect.Left()+4, aRect.Top()+1 ), |
| Point( aRect.Left()+4, aRect.Bottom()-1 ) ); |
| } |
| else if ( meExtraType == RULER_EXTRA_TAB ) |
| { |
| sal_uInt16 nTabStyle = mnExtraStyle & RULER_TAB_STYLE; |
| if(mpData->bTextRTL) |
| nTabStyle |= RULER_TAB_RTL; |
| Point aCenter = aRect.Center(); |
| Point aDraw(aCenter); |
| ImplCenterTabPos( aDraw, nTabStyle ); |
| WinBits nWinBits = GetStyle(); |
| if(0 == (nWinBits&WB_HORZ) ) |
| { |
| if(0 != (nWinBits&WB_RIGHT_ALIGNED)) |
| aDraw.Y() = 2 * aCenter.Y() - aDraw.Y(); |
| if(mpData->bTextRTL) |
| { |
| long nTemp = aDraw.X(); |
| aDraw.X() = aDraw.Y(); |
| aDraw.Y() = nTemp; |
| } |
| } |
| ImplDrawTab( this, aDraw, nTabStyle ); |
| } |
| |
| if ( (rStyleSettings.GetOptions() & STYLE_OPTION_MONO) && (mnExtraStyle & RULER_STYLE_HIGHLIGHT) ) |
| Invert( aRect ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplUpdate( sal_Bool bMustCalc ) |
| { |
| // Hier schon Linien loeschen, damit Sie vor dem Neuberechnen schon |
| // geloscht sind, da danach die alten Positionen nicht mehr bestimmt |
| // werden koennen |
| if ( !mbFormat ) |
| ImplInvertLines(); |
| |
| // Flags setzen |
| if ( bMustCalc ) |
| mbCalc = sal_True; |
| mbFormat = sal_True; |
| |
| // Wenn wir am Draggen sind, wird nach dem Drag-Handler automatisch |
| // das Lineal neu upgedatet |
| if ( mbDrag ) |
| return; |
| |
| // Gegebenenfalls Update ausloesen |
| if ( IsReallyVisible() && IsUpdateMode() ) |
| { |
| mnUpdateFlags |= RULER_UPDATE_DRAW; |
| if ( !mnUpdateEvtId ) |
| mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Ruler::ImplHitTest( const Point& rPos, ImplRulerHitTest* pHitTest, |
| sal_Bool bRequireStyle, sal_uInt16 nRequiredStyle ) const |
| { |
| sal_uInt16 i; |
| sal_uInt16 nStyle; |
| long nHitBottom; |
| long nX; |
| long nY; |
| long n1; |
| long n2; |
| |
| if ( !mbActive ) |
| return sal_False; |
| |
| // Position ermitteln |
| sal_Bool bIsHori = 0 != (mnWinStyle & WB_HORZ); |
| if ( bIsHori ) |
| { |
| nX = rPos.X(); |
| nY = rPos.Y(); |
| } |
| else |
| { |
| nX = rPos.Y(); |
| nY = rPos.X(); |
| } |
| nHitBottom = mnVirHeight+(RULER_OFF*2); |
| |
| // --> FME 2004-08-05 #i32608# |
| pHitTest->nAryPos = 0; |
| pHitTest->mnDragSize = 0; |
| pHitTest->bSize = sal_False; |
| pHitTest->bSizeBar = sal_False; |
| // <-- |
| |
| // Damit ueberstehende Tabs und Einzuege mit beruecksichtigt werden |
| long nXExtraOff; |
| if ( mpData->pTabs || mpData->pIndents ) |
| nXExtraOff = (mnVirHeight/2) - 4; |
| else |
| nXExtraOff = 0; |
| |
| // Test auf ausserhalb |
| nX -= mnVirOff; |
| long nXTemp = nX; |
| if ( (nX < mpData->nRulVirOff-nXExtraOff) || (nX > mpData->nRulVirOff+mpData->nRulWidth+nXExtraOff) || |
| (nY < 0) || (nY > nHitBottom) ) |
| { |
| pHitTest->nPos = 0; |
| pHitTest->eType = RULER_TYPE_OUTSIDE; |
| return sal_False; |
| } |
| |
| nX -= mpData->nNullVirOff; |
| pHitTest->nPos = nX; |
| pHitTest->eType = RULER_TYPE_DONTKNOW; |
| |
| // Zuerst die Tabs testen |
| Rectangle aRect; |
| if ( mpData->pTabs ) |
| { |
| aRect.Bottom() = nHitBottom; |
| aRect.Top() = aRect.Bottom()-RULER_TAB_HEIGHT-RULER_OFF; |
| |
| for ( i = mpData->nTabs; i; i-- ) |
| { |
| nStyle = mpData->pTabs[i-1].nStyle; |
| if ( !(nStyle & RULER_STYLE_INVISIBLE) ) |
| { |
| nStyle &= RULER_TAB_STYLE; |
| |
| // Default-Tabs werden nur angezeigt |
| if ( nStyle != RULER_TAB_DEFAULT ) |
| { |
| n1 = mpData->pTabs[i-1].nPos; |
| |
| if ( nStyle == RULER_TAB_LEFT ) |
| { |
| aRect.Left() = n1; |
| aRect.Right() = n1+RULER_TAB_WIDTH-1; |
| } |
| else if ( nStyle == RULER_TAB_RIGHT ) |
| { |
| aRect.Right() = n1; |
| aRect.Left() = n1-RULER_TAB_WIDTH-1; |
| } |
| else |
| { |
| aRect.Left() = n1-RULER_TAB_CWIDTH2+1; |
| aRect.Right() = n1-RULER_TAB_CWIDTH2+RULER_TAB_CWIDTH; |
| } |
| |
| if ( aRect.IsInside( Point( nX, nY ) ) ) |
| { |
| pHitTest->eType = RULER_TYPE_TAB; |
| pHitTest->nAryPos = i-1; |
| return sal_True; |
| } |
| } |
| } |
| } |
| } |
| |
| // Dann die Einzuege |
| if ( mpData->pIndents ) |
| { |
| long nIndentHeight = (mnVirHeight/2) - 1; |
| long nIndentWidth2 = nIndentHeight-3; |
| |
| for ( i = mpData->nIndents; i; i-- ) |
| { |
| nStyle = mpData->pIndents[i-1].nStyle; |
| if ( (! bRequireStyle || nStyle == nRequiredStyle) && |
| !(nStyle & RULER_STYLE_INVISIBLE) ) |
| { |
| nStyle &= RULER_INDENT_STYLE; |
| n1 = mpData->pIndents[i-1].nPos; |
| |
| if ( (nStyle == RULER_INDENT_BOTTOM) ^ (!bIsHori) ) |
| { |
| aRect.Left() = n1-nIndentWidth2; |
| aRect.Right() = n1+nIndentWidth2; |
| aRect.Top() = nHitBottom-nIndentHeight-RULER_OFF+1; |
| aRect.Bottom() = nHitBottom; |
| } |
| else |
| { |
| aRect.Left() = n1-nIndentWidth2; |
| aRect.Right() = n1+nIndentWidth2; |
| aRect.Top() = 0; |
| aRect.Bottom() = nIndentHeight+RULER_OFF-1; |
| } |
| |
| if ( aRect.IsInside( Point( nX, nY ) ) ) |
| { |
| pHitTest->eType = RULER_TYPE_INDENT; |
| pHitTest->nAryPos = i-1; |
| return sal_True; |
| } |
| } |
| } |
| } |
| |
| // Jetzt zaehlt nichts mehr, was links oder rechts uebersteht |
| if ( (nXTemp < mpData->nRulVirOff) || (nXTemp > mpData->nRulVirOff+mpData->nRulWidth) ) |
| { |
| pHitTest->nPos = 0; |
| pHitTest->eType = RULER_TYPE_OUTSIDE; |
| return sal_False; |
| } |
| |
| // Danach die Spalten testen |
| int nBorderTolerance = 1; |
| if(pHitTest->bExpandTest) |
| { |
| nBorderTolerance++; |
| } |
| |
| for ( i = mpData->nBorders; i; i-- ) |
| { |
| n1 = mpData->pBorders[i-1].nPos; |
| n2 = n1 + mpData->pBorders[i-1].nWidth; |
| |
| // Spalten werden mit mindestens 3 Pixel breite gezeichnet |
| if ( !mpData->pBorders[i-1].nWidth ) |
| { |
| n1 -= nBorderTolerance; |
| n2 += nBorderTolerance; |
| |
| } |
| |
| if ( (nX >= n1) && (nX <= n2) ) |
| { |
| nStyle = mpData->pBorders[i-1].nStyle; |
| if ( !(nStyle & RULER_STYLE_INVISIBLE) ) |
| { |
| pHitTest->eType = RULER_TYPE_BORDER; |
| pHitTest->nAryPos = i-1; |
| |
| if ( !(nStyle & RULER_BORDER_SIZEABLE) ) |
| { |
| if ( nStyle & RULER_BORDER_MOVEABLE ) |
| { |
| pHitTest->bSizeBar = sal_True; |
| pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE; |
| } |
| } |
| else |
| { |
| long nMOff = RULER_MOUSE_BORDERWIDTH; |
| while ( nMOff*2 >= (n2-n1-RULER_MOUSE_BORDERMOVE) ) |
| { |
| if ( nMOff < 2 ) |
| { |
| nMOff = 0; |
| break; |
| } |
| else |
| nMOff--; |
| } |
| |
| if ( nX <= n1+nMOff ) |
| { |
| pHitTest->bSize = sal_True; |
| pHitTest->mnDragSize = RULER_DRAGSIZE_1; |
| } |
| else if ( nX >= n2-nMOff ) |
| { |
| pHitTest->bSize = sal_True; |
| pHitTest->mnDragSize = RULER_DRAGSIZE_2; |
| } |
| else |
| { |
| if ( nStyle & RULER_BORDER_MOVEABLE ) |
| { |
| pHitTest->bSizeBar = sal_True; |
| pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE; |
| } |
| } |
| } |
| |
| return sal_True; |
| } |
| } |
| } |
| |
| // Und zum Schluss die Raender |
| int nMarginTolerance = pHitTest->bExpandTest ? nBorderTolerance : RULER_MOUSE_MARGINWIDTH; |
| |
| if ( (mpData->nMargin1Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE ) |
| { |
| n1 = mpData->nMargin1; |
| if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) ) |
| { |
| pHitTest->eType = RULER_TYPE_MARGIN1; |
| pHitTest->bSize = sal_True; |
| return sal_True; |
| } |
| } |
| if ( (mpData->nMargin2Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE ) |
| { |
| n1 = mpData->nMargin2; |
| if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) ) |
| { |
| pHitTest->eType = RULER_TYPE_MARGIN2; |
| pHitTest->bSize = sal_True; |
| return sal_True; |
| } |
| } |
| |
| // Jetzt nocheinmal die Tabs testen, nur mit etwas mehr spielraum |
| if ( mpData->pTabs ) |
| { |
| aRect.Top() = RULER_OFF; |
| aRect.Bottom() = nHitBottom; |
| |
| for ( i = mpData->nTabs; i; i-- ) |
| { |
| nStyle = mpData->pTabs[i-1].nStyle; |
| if ( !(nStyle & RULER_STYLE_INVISIBLE) ) |
| { |
| nStyle &= RULER_TAB_STYLE; |
| |
| // Default-Tabs werden nur angezeigt |
| if ( nStyle != RULER_TAB_DEFAULT ) |
| { |
| n1 = mpData->pTabs[i-1].nPos; |
| |
| if ( nStyle == RULER_TAB_LEFT ) |
| { |
| aRect.Left() = n1; |
| aRect.Right() = n1+RULER_TAB_WIDTH-1; |
| } |
| else if ( nStyle == RULER_TAB_RIGHT ) |
| { |
| aRect.Right() = n1; |
| aRect.Left() = n1-RULER_TAB_WIDTH-1; |
| } |
| else |
| { |
| aRect.Left() = n1-RULER_TAB_CWIDTH2+1; |
| aRect.Right() = n1-RULER_TAB_CWIDTH2+RULER_TAB_CWIDTH; |
| } |
| |
| aRect.Left()--; |
| aRect.Right()++; |
| |
| if ( aRect.IsInside( Point( nX, nY ) ) ) |
| { |
| pHitTest->eType = RULER_TYPE_TAB; |
| pHitTest->nAryPos = i-1; |
| return sal_True; |
| } |
| } |
| } |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Ruler::ImplDocHitTest( const Point& rPos, RulerType eDragType, |
| ImplRulerHitTest* pHitTest ) const |
| { |
| Point aPos = rPos; |
| sal_Bool bRequiredStyle = sal_False; |
| sal_uInt16 nRequiredStyle = 0; |
| |
| if (eDragType == RULER_TYPE_INDENT) |
| { |
| bRequiredStyle = sal_True; |
| nRequiredStyle = RULER_INDENT_BOTTOM; |
| } |
| |
| if ( mnWinStyle & WB_HORZ ) |
| aPos.X() += mnWinOff; |
| else |
| aPos.Y() += mnWinOff; |
| |
| if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_DONTKNOW) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| aPos.Y() = RULER_OFF+1; |
| else |
| aPos.X() = RULER_OFF+1; |
| |
| // HitTest durchfuehren |
| if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) ) |
| { |
| if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) ) |
| return sal_True; |
| } |
| } |
| |
| if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_TAB) || |
| (eDragType == RULER_TYPE_DONTKNOW) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| aPos.Y() = mnHeight-RULER_OFF-1; |
| else |
| aPos.X() = mnWidth-RULER_OFF-1; |
| |
| // HitTest durchfuehren |
| if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) ) |
| { |
| if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) ) |
| return sal_True; |
| } |
| } |
| |
| if ( (eDragType == RULER_TYPE_MARGIN1) || (eDragType == RULER_TYPE_MARGIN2) || |
| (eDragType == RULER_TYPE_BORDER) || (eDragType == RULER_TYPE_DONTKNOW) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| aPos.Y() = RULER_OFF + (mnVirHeight/2); |
| else |
| aPos.X() = RULER_OFF + (mnVirHeight/2); |
| |
| // HitTest durchfuehren |
| if ( ImplHitTest( aPos, pHitTest ) ) |
| { |
| if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) ) |
| return sal_True; |
| } |
| } |
| |
| // Auf DontKnow setzen |
| pHitTest->eType = RULER_TYPE_DONTKNOW; |
| |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Ruler::ImplStartDrag( ImplRulerHitTest* pHitTest, sal_uInt16 nModifier ) |
| { |
| // Wenn eine Spalte angeklick wurde, die weder verschiebar noch |
| // in der Groesse aenderbar ist, brauchen wir auch kein Drag ausloesen |
| if ( (pHitTest->eType == RULER_TYPE_BORDER) && |
| !pHitTest->bSize && !pHitTest->bSizeBar ) |
| return sal_False; |
| |
| // Dragdaten setzen |
| meDragType = pHitTest->eType; |
| mnDragPos = pHitTest->nPos; |
| mnDragAryPos = pHitTest->nAryPos; |
| mnDragSize = pHitTest->mnDragSize; |
| mnDragModifier = nModifier; |
| *mpDragData = *mpSaveData; |
| mpData = mpDragData; |
| |
| // Handler rufen |
| if ( StartDrag() ) |
| { |
| // Wenn der Handler das Draggen erlaubt, dann das Draggen |
| // initialisieren |
| ImplInvertLines(); |
| mbDrag = sal_True; |
| mnStartDragPos = mnDragPos; |
| StartTracking(); |
| return sal_True; |
| } |
| else |
| { |
| // Ansonsten muessen wir die Daten zuruecksetzen |
| meDragType = RULER_TYPE_DONTKNOW; |
| mnDragPos = 0; |
| mnDragAryPos = 0; |
| mnDragSize = 0; |
| mnDragModifier = 0; |
| mpData = mpSaveData; |
| } |
| |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplDrag( const Point& rPos ) |
| { |
| long nX; |
| long nY; |
| long nOutHeight; |
| |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| nX = rPos.X(); |
| nY = rPos.Y(); |
| nOutHeight = mnHeight; |
| } |
| else |
| { |
| nX = rPos.Y(); |
| nY = rPos.X(); |
| nOutHeight = mnWidth; |
| } |
| |
| // X berechnen und einpassen |
| nX -= mnVirOff; |
| if ( nX < mpData->nRulVirOff ) |
| { |
| nX = mpData->nRulVirOff; |
| mnDragScroll = RULER_SCROLL_1; |
| } |
| else if ( nX > mpData->nRulVirOff+mpData->nRulWidth ) |
| { |
| nX = mpData->nRulVirOff+mpData->nRulWidth; |
| mnDragScroll = RULER_SCROLL_2; |
| } |
| nX -= mpData->nNullVirOff; |
| |
| // Wenn oberhalb oder links vom Lineal, dann alte Werte |
| mbDragDelete = sal_False; |
| if ( nY < 0 ) |
| { |
| if ( !mbDragCanceled ) |
| { |
| // Daten wiederherstellen |
| mbDragCanceled = sal_True; |
| ImplRulerData aTempData; |
| aTempData = *mpDragData; |
| *mpDragData = *mpSaveData; |
| mbCalc = sal_True; |
| mbFormat = sal_True; |
| |
| // Handler rufen |
| mnDragPos = mnStartDragPos; |
| Drag(); |
| |
| // Und neu ausgeben (zeitverzoegert) |
| /* |
| mnUpdateFlags |= RULER_UPDATE_DRAW; |
| if ( mnUpdateEvtId ) |
| Application::RemoveUserEvent( mnUpdateEvtId ); |
| mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); |
| */ |
| ImplDraw(); |
| |
| // Daten wieder wie vor dem Cancel herstellen |
| *mpDragData = aTempData; |
| } |
| } |
| else |
| { |
| mbDragCanceled = sal_False; |
| |
| // +2, damit nicht so schnell die Tabs geloescht werden |
| if ( nY > nOutHeight+2 ) |
| mbDragDelete = sal_True; |
| |
| mnDragPos = nX; |
| |
| // Handler rufen |
| Drag(); |
| |
| // Und neu ausgeben |
| if ( mbFormat ) |
| ImplDraw(); |
| } |
| |
| mnDragScroll = 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ImplEndDrag() |
| { |
| // Werte uebernehmen |
| if ( mbDragCanceled ) |
| *mpDragData = *mpSaveData; |
| else |
| *mpSaveData = *mpDragData; |
| mpData = mpSaveData; |
| mbDrag = sal_False; |
| |
| // Handler rufen |
| EndDrag(); |
| |
| // Drag-Werte zuruecksetzen |
| meDragType = RULER_TYPE_DONTKNOW; |
| mnDragPos = 0; |
| mnDragAryPos = 0; |
| mnDragSize = 0; |
| mbDragCanceled = sal_False; |
| mbDragDelete = sal_False; |
| mnDragModifier = 0; |
| mnDragScroll = 0; |
| mnStartDragPos = 0; |
| |
| // Und neu ausgeben |
| ImplDraw(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( Ruler, ImplUpdateHdl, void*, EMPTYARG ) |
| { |
| mnUpdateEvtId = 0; |
| |
| // Feststellen, was upgedatet werden muss |
| if ( mnUpdateFlags & RULER_UPDATE_DRAW ) |
| { |
| mnUpdateFlags = 0; |
| ImplDraw(); |
| } |
| else if ( mnUpdateFlags & RULER_UPDATE_LINES ) |
| { |
| mnUpdateFlags = 0; |
| ImplInvertLines(); |
| } |
| |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::MouseButtonDown( const MouseEvent& rMEvt ) |
| { |
| if ( rMEvt.IsLeft() && !IsTracking() ) |
| { |
| Point aMousePos = rMEvt.GetPosPixel(); |
| sal_uInt16 nMouseClicks = rMEvt.GetClicks(); |
| sal_uInt16 nMouseModifier = rMEvt.GetModifier(); |
| |
| // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten |
| // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) |
| if ( mbFormat ) |
| { |
| ImplDraw(); |
| mnUpdateFlags &= ~RULER_UPDATE_DRAW; |
| } |
| |
| if ( maExtraRect.IsInside( aMousePos ) ) |
| { |
| mnExtraClicks = nMouseClicks; |
| mnExtraModifier = nMouseModifier; |
| ExtraDown(); |
| mnExtraClicks = 0; |
| mnExtraModifier = 0; |
| } |
| else |
| { |
| ImplRulerHitTest aHitTest; |
| |
| if ( nMouseClicks == 1 ) |
| { |
| if ( ImplHitTest( aMousePos, &aHitTest ) ) |
| ImplStartDrag( &aHitTest, nMouseModifier ); |
| else |
| { |
| // Position innerhalb des Lineal-Bereiches |
| if ( aHitTest.eType == RULER_TYPE_DONTKNOW ) |
| { |
| mnDragPos = aHitTest.nPos; |
| Click(); |
| mnDragPos = 0; |
| |
| // Nocheinmal HitTest durchfuehren, da durch den Click |
| // zum Beispiel ein neuer Tab gesetzt werden konnte |
| if ( ImplHitTest( aMousePos, &aHitTest ) ) |
| ImplStartDrag( &aHitTest, nMouseModifier ); |
| } |
| } |
| } |
| else |
| { |
| if ( ImplHitTest( aMousePos, &aHitTest ) ) |
| { |
| mnDragPos = aHitTest.nPos; |
| mnDragAryPos = aHitTest.nAryPos; |
| } |
| meDragType = aHitTest.eType; |
| |
| DoubleClick(); |
| |
| meDragType = RULER_TYPE_DONTKNOW; |
| mnDragPos = 0; |
| mnDragAryPos = 0; |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::MouseMove( const MouseEvent& rMEvt ) |
| { |
| PointerStyle ePtrStyle = POINTER_ARROW; |
| |
| // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten |
| // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) |
| if ( mbFormat ) |
| { |
| ImplDraw(); |
| mnUpdateFlags &= ~RULER_UPDATE_DRAW; |
| } |
| |
| ImplRulerHitTest aHitTest; |
| if ( ImplHitTest( rMEvt.GetPosPixel(), &aHitTest ) ) |
| { |
| if ( aHitTest.bSize ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| ePtrStyle = POINTER_ESIZE; |
| else |
| ePtrStyle = POINTER_SSIZE; |
| } |
| else if ( aHitTest.bSizeBar ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| ePtrStyle = POINTER_HSIZEBAR; |
| else |
| ePtrStyle = POINTER_VSIZEBAR; |
| } |
| } |
| |
| SetPointer( Pointer( ePtrStyle ) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Tracking( const TrackingEvent& rTEvt ) |
| { |
| if ( rTEvt.IsTrackingEnded() ) |
| { |
| // Bei Abbruch, den alten Status wieder herstellen |
| if ( rTEvt.IsTrackingCanceled() ) |
| { |
| mbDragCanceled = sal_True; |
| mbFormat = sal_True; |
| } |
| |
| ImplEndDrag(); |
| } |
| else |
| ImplDrag( rTEvt.GetMouseEvent().GetPosPixel() ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Paint( const Rectangle& ) |
| { |
| ImplDraw(); |
| |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| |
| // Extra-Field beruecksichtigen |
| if ( mnWinStyle & WB_EXTRAFIELD ) |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| SetLineColor( rStyleSettings.GetShadowColor() ); |
| DrawLine( Point( maExtraRect.Left(), maExtraRect.Top() ), |
| Point( maExtraRect.Right()-1, maExtraRect.Top() ) ); |
| DrawLine( Point( maExtraRect.Left(), maExtraRect.Top() ), |
| Point( maExtraRect.Left(), maExtraRect.Bottom()-1 ) ); |
| DrawLine( Point( maExtraRect.Left(), maExtraRect.Bottom()-1 ), |
| Point( maExtraRect.Right()-1, maExtraRect.Bottom()-1 ) ); |
| DrawLine( Point( maExtraRect.Right()-1, maExtraRect.Top() ), |
| Point( maExtraRect.Right()-1, maExtraRect.Bottom()-1 ) ); |
| SetLineColor( rStyleSettings.GetLightColor() ); |
| DrawLine( Point( maExtraRect.Left()+1, maExtraRect.Top()+1 ), |
| Point( maExtraRect.Right()-2, maExtraRect.Top()+1 ) ); |
| DrawLine( Point( maExtraRect.Left()+1, maExtraRect.Top()+1 ), |
| Point( maExtraRect.Left()+1, maExtraRect.Bottom()-2 ) ); |
| DrawLine( Point( maExtraRect.Left(), maExtraRect.Bottom() ), |
| Point( maExtraRect.Right(), maExtraRect.Bottom() ) ); |
| DrawLine( Point( maExtraRect.Right(), maExtraRect.Top() ), |
| Point( maExtraRect.Right(), maExtraRect.Bottom() ) ); |
| } |
| else |
| { |
| SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| SetFillColor( rStyleSettings.GetWindowColor() ); |
| DrawRect( maExtraRect ); |
| } |
| |
| // Imhalt vom Extrafeld ausgeben |
| ImplDrawExtra( sal_True ); |
| } |
| |
| if ( mnWinStyle & WB_BORDER ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| SetLineColor( rStyleSettings.GetShadowColor() ); |
| DrawLine( Point( mnBorderOff, mnHeight-2 ), |
| Point( mnWidth, mnHeight-2 ) ); |
| if ( mnBorderOff ) |
| { |
| DrawLine( Point( mnBorderOff-1, mnHeight-2 ), |
| Point( mnBorderOff-1, mnHeight-1 ) ); |
| } |
| } |
| SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| DrawLine( Point( mnBorderOff, mnHeight-1 ), |
| Point( mnWidth, mnHeight-1 ) ); |
| } |
| else |
| { |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) |
| { |
| SetLineColor( rStyleSettings.GetShadowColor() ); |
| DrawLine( Point( mnWidth-2, mnBorderOff ), |
| Point( mnWidth-2, mnHeight ) ); |
| if ( mnBorderOff ) |
| { |
| DrawLine( Point( mnWidth-2, mnBorderOff-1 ), |
| Point( mnWidth-1, mnBorderOff-1 ) ); |
| } |
| } |
| SetLineColor( rStyleSettings.GetWindowTextColor() ); |
| DrawLine( Point( mnWidth-1, mnBorderOff ), |
| Point( mnWidth-1, mnHeight ) ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Resize() |
| { |
| Size aWinSize = GetOutputSizePixel(); |
| |
| long nNewHeight; |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| if ( aWinSize.Height() != mnHeight ) |
| nNewHeight = aWinSize.Height(); |
| else |
| nNewHeight = 0; |
| } |
| else |
| { |
| if ( aWinSize.Width() != mnWidth ) |
| nNewHeight = aWinSize.Width(); |
| else |
| nNewHeight = 0; |
| } |
| |
| // Hier schon Linien loeschen |
| sal_Bool bVisible = IsReallyVisible(); |
| if ( bVisible && mpData->nLines ) |
| { |
| ImplInvertLines(); |
| mnUpdateFlags |= RULER_UPDATE_LINES; |
| if ( !mnUpdateEvtId ) |
| mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); |
| } |
| mbFormat = sal_True; |
| |
| // Wenn sich die Hoehe bzw. Breite aendert, dann muessen besimmte Werte |
| // neu berechnet werden |
| //extra field should always be updated |
| ImplInitExtraField( mpData->bTextRTL ); |
| if ( nNewHeight ) |
| { |
| mbCalc = sal_True; |
| mnVirHeight = nNewHeight - mnBorderWidth - (RULER_OFF*2); |
| } |
| else |
| { |
| if ( mpData->bAutoPageWidth ) |
| ImplUpdate( sal_True ); |
| else if ( mbAutoWinWidth ) |
| mbCalc = sal_True; |
| } |
| |
| // Wenn Ruler eine Groesse hat, dann Groesse vom VirtualDevice setzen |
| if ( (mnVirWidth > RULER_MIN_SIZE) || |
| ((aWinSize.Width() > RULER_MIN_SIZE) && (aWinSize.Height() > RULER_MIN_SIZE)) ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| mnVirWidth = aWinSize.Width()-mnVirOff; |
| else |
| mnVirWidth = aWinSize.Height()-mnVirOff; |
| if ( mnVirWidth < RULER_MIN_SIZE ) |
| mnVirWidth = 0; |
| } |
| |
| // Gegebenenfalls ein Teil vom Rand loeschen, da 3D-Effekt/Trennlinie am |
| // Fensterrand |
| if ( bVisible ) |
| { |
| if ( nNewHeight ) |
| Invalidate(); |
| else if ( mpData->bAutoPageWidth ) |
| { |
| // Nur bei AutoPageWidth haben wir rechts einen 3D-Effekt, |
| // der sich der Fensterbreite anpasst und deshalb neu gezeichnet |
| // werden muss |
| Rectangle aRect; |
| |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| if ( mnWidth < aWinSize.Width() ) |
| aRect.Left() = mnWidth-RULER_RESIZE_OFF; |
| else |
| aRect.Left() = aWinSize.Width()-RULER_RESIZE_OFF; |
| aRect.Right() = aRect.Left()+RULER_RESIZE_OFF; |
| aRect.Top() = RULER_OFF; |
| aRect.Bottom() = RULER_OFF+mnVirHeight; |
| } |
| else |
| { |
| if ( mnHeight < aWinSize.Height() ) |
| aRect.Top() = mnHeight-RULER_RESIZE_OFF; |
| else |
| aRect.Top() = aWinSize.Height()-RULER_RESIZE_OFF; |
| aRect.Bottom() = aRect.Top()+RULER_RESIZE_OFF; |
| aRect.Left() = RULER_OFF; |
| aRect.Right() = RULER_OFF+mnVirHeight; |
| } |
| |
| Invalidate( aRect ); |
| } |
| } |
| |
| // Neue Groesse merken |
| mnWidth = aWinSize.Width(); |
| mnHeight = aWinSize.Height(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::StateChanged( StateChangedType nType ) |
| { |
| Window::StateChanged( nType ); |
| |
| if ( nType == STATE_CHANGE_INITSHOW ) |
| ImplFormat(); |
| else if ( nType == STATE_CHANGE_UPDATEMODE ) |
| { |
| if ( IsReallyVisible() && IsUpdateMode() ) |
| ImplDraw(); |
| } |
| else if ( (nType == STATE_CHANGE_ZOOM) || |
| (nType == STATE_CHANGE_CONTROLFONT) ) |
| { |
| ImplInitSettings( sal_True, sal_False, sal_False ); |
| Invalidate(); |
| } |
| else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) |
| { |
| ImplInitSettings( sal_False, sal_True, sal_False ); |
| Invalidate(); |
| } |
| else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) |
| { |
| ImplInitSettings( sal_False, sal_False, sal_True ); |
| Invalidate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| Window::DataChanged( rDCEvt ); |
| |
| if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || |
| (rDCEvt.GetType() == DATACHANGED_DISPLAY) || |
| (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || |
| ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && |
| (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) |
| { |
| mbFormat = sal_True; |
| ImplInitSettings( sal_True, sal_True, sal_True ); |
| Invalidate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| long Ruler::StartDrag() |
| { |
| if ( maStartDragHdl.IsSet() ) |
| return maStartDragHdl.Call( this ); |
| else |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Drag() |
| { |
| maDragHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::EndDrag() |
| { |
| maEndDragHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Click() |
| { |
| maClickHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::DoubleClick() |
| { |
| maDoubleClickHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::ExtraDown() |
| { |
| maExtraDownHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Activate() |
| { |
| mbActive = sal_True; |
| |
| // Positionslinien wieder anzeigen (erst hinter mbActive=sal_True rufen, da |
| // von ImplInvertLines() ausgewertet wird). Das Zeichnen der Linien |
| // wird verzoegert, damit im vermutlich noch nicht gepainteten Zustand |
| // Linien gezeichnet werden. |
| mnUpdateFlags |= RULER_UPDATE_LINES; |
| if ( !mnUpdateEvtId ) |
| mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::Deactivate() |
| { |
| // Positionslinien loeschen (schon vor mbActive=sal_False rufen, da |
| // von ImplInvertLines() ausgewertet wird) |
| ImplInvertLines(); |
| |
| mbActive = sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Ruler::StartDocDrag( const MouseEvent& rMEvt, RulerType eDragType ) |
| { |
| if ( !mbDrag ) |
| { |
| Point aMousePos = rMEvt.GetPosPixel(); |
| sal_uInt16 nMouseClicks = rMEvt.GetClicks(); |
| sal_uInt16 nMouseModifier = rMEvt.GetModifier(); |
| ImplRulerHitTest aHitTest; |
| if(eDragType != RULER_TYPE_DONTKNOW) |
| aHitTest.bExpandTest = sal_True; |
| |
| // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten |
| // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) |
| if ( mbFormat ) |
| { |
| ImplDraw(); |
| mnUpdateFlags &= ~RULER_UPDATE_DRAW; |
| } |
| |
| if ( nMouseClicks == 1 ) |
| { |
| if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) ) |
| { |
| Pointer aPtr; |
| |
| if ( aHitTest.bSize ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| aPtr = Pointer( POINTER_ESIZE ); |
| else |
| aPtr = Pointer( POINTER_SSIZE ); |
| } |
| else if ( aHitTest.bSizeBar ) |
| { |
| if ( mnWinStyle & WB_HORZ ) |
| aPtr = Pointer( POINTER_HSIZEBAR ); |
| else |
| aPtr = Pointer( POINTER_VSIZEBAR ); |
| } |
| SetPointer( aPtr ); |
| return ImplStartDrag( &aHitTest, nMouseModifier ); |
| } |
| } |
| else if ( nMouseClicks == 2 ) |
| { |
| if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) ) |
| { |
| mnDragPos = aHitTest.nPos; |
| mnDragAryPos = aHitTest.nAryPos; |
| } |
| eDragType = aHitTest.eType; |
| |
| DoubleClick(); |
| |
| eDragType = RULER_TYPE_DONTKNOW; |
| mnDragPos = 0; |
| mnDragAryPos = 0; |
| |
| return sal_True; |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| RulerType Ruler::GetDocType( const Point& rPos, RulerType eDragType, |
| sal_uInt16* pAryPos ) const |
| { |
| ImplRulerHitTest aHitTest; |
| |
| // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten |
| // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) |
| if ( IsReallyVisible() && mbFormat ) |
| { |
| ((Ruler*)this)->ImplDraw(); |
| ((Ruler*)this)->mnUpdateFlags &= ~RULER_UPDATE_DRAW; |
| } |
| |
| // HitTest durchfuehren |
| ImplDocHitTest( rPos, eDragType, &aHitTest ); |
| |
| // Werte zurueckgeben |
| if ( pAryPos ) |
| *pAryPos = aHitTest.nAryPos; |
| return aHitTest.eType; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::CancelDrag() |
| { |
| if ( mbDrag ) |
| { |
| ImplDrag( Point( -1, -1 ) ); |
| ImplEndDrag(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| RulerType Ruler::GetType( const Point& rPos, sal_uInt16* pAryPos ) const |
| { |
| ImplRulerHitTest aHitTest; |
| |
| // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten |
| // gearbeitet wird und die Anzeige auch zur Bearbeitung passt) |
| if ( IsReallyVisible() && mbFormat ) |
| { |
| ((Ruler*)this)->ImplDraw(); |
| ((Ruler*)this)->mnUpdateFlags &= ~RULER_UPDATE_DRAW; |
| } |
| |
| // HitTest durchfuehren |
| ImplHitTest( rPos, &aHitTest ); |
| |
| // Werte zurueckgeben |
| if ( pAryPos ) |
| *pAryPos = aHitTest.nAryPos; |
| return aHitTest.eType; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetWinPos( long nNewOff, long nNewWidth ) |
| { |
| // Gegebenenfalls werden die Breiten automatisch berechnet |
| if ( !nNewWidth ) |
| mbAutoWinWidth = sal_True; |
| else |
| mbAutoWinWidth = sal_False; |
| |
| // Werte setzen (werden in ImplFormat gegebenenfalls mitberechnet) |
| mnWinOff = nNewOff; |
| mnWinWidth = nNewWidth; |
| ImplUpdate( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetPagePos( long nNewOff, long nNewWidth ) |
| { |
| // Muessen wir ueberhaupt was machen |
| if ( (mpData->nPageOff == nNewOff) && (mpData->nPageWidth == nNewWidth) ) |
| return; |
| |
| // Gegebenenfalls werden die Breiten automatisch berechnet |
| if ( !nNewWidth ) |
| mpData->bAutoPageWidth = sal_True; |
| else |
| mpData->bAutoPageWidth = sal_False; |
| |
| // Werte setzen (werden in ImplFormat gegebenenfalls mitberechnet) |
| mpData->nPageOff = nNewOff; |
| mpData->nPageWidth = nNewWidth; |
| ImplUpdate( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetBorderPos( long nOff ) |
| { |
| if ( mnWinStyle & WB_BORDER ) |
| { |
| if ( mnBorderOff != nOff ) |
| { |
| mnBorderOff = nOff; |
| |
| if ( IsReallyVisible() && IsUpdateMode() ) |
| Invalidate(); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetUnit( FieldUnit eNewUnit ) |
| { |
| if ( meUnit != eNewUnit ) |
| { |
| meUnit = eNewUnit; |
| switch ( meUnit ) |
| { |
| case FUNIT_MM: |
| mnUnitIndex = RULER_UNIT_MM; |
| break; |
| case FUNIT_CM: |
| mnUnitIndex = RULER_UNIT_CM; |
| break; |
| case FUNIT_M: |
| mnUnitIndex = RULER_UNIT_M; |
| break; |
| case FUNIT_KM: |
| mnUnitIndex = RULER_UNIT_KM; |
| break; |
| case FUNIT_INCH: |
| mnUnitIndex = RULER_UNIT_INCH; |
| break; |
| case FUNIT_FOOT: |
| mnUnitIndex = RULER_UNIT_FOOT; |
| break; |
| case FUNIT_MILE: |
| mnUnitIndex = RULER_UNIT_MILE; |
| break; |
| case FUNIT_POINT: |
| mnUnitIndex = RULER_UNIT_POINT; |
| break; |
| case FUNIT_PICA: |
| mnUnitIndex = RULER_UNIT_PICA; |
| break; |
| default: |
| #ifdef DBG_UTIL |
| DBG_ERRORFILE( "Ruler::SetUnit() - Wrong Unit" ); |
| #endif |
| break; |
| } |
| |
| maMapMode.SetMapUnit( aImplRulerUnitTab[mnUnitIndex].eMapUnit ); |
| ImplUpdate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetZoom( const Fraction& rNewZoom ) |
| { |
| DBG_ASSERT( rNewZoom.GetNumerator(), "Ruler::SetZoom() with scale 0 is not allowed" ); |
| |
| if ( maZoom != rNewZoom ) |
| { |
| maZoom = rNewZoom; |
| maMapMode.SetScaleX( maZoom ); |
| maMapMode.SetScaleY( maZoom ); |
| ImplUpdate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle ) |
| { |
| if ( mnWinStyle & WB_EXTRAFIELD ) |
| { |
| meExtraType = eNewExtraType; |
| mnExtraStyle = nStyle; |
| if ( IsReallyVisible() && IsUpdateMode() ) |
| ImplDrawExtra( sal_False ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetNullOffset( long nPos ) |
| { |
| if ( mpData->nNullOff != nPos ) |
| { |
| mpData->nNullOff = nPos; |
| ImplUpdate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetMargin1( long nPos, sal_uInt16 nMarginStyle ) |
| { |
| if ( (mpData->nMargin1 != nPos) || (mpData->nMargin1Style != nMarginStyle) ) |
| { |
| mpData->nMargin1 = nPos; |
| mpData->nMargin1Style = nMarginStyle; |
| ImplUpdate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetMargin2( long nPos, sal_uInt16 nMarginStyle ) |
| { |
| DBG_ASSERT( (nPos >= mpData->nMargin1) || |
| (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) || |
| (mpData->nMargin2Style & RULER_STYLE_INVISIBLE), |
| "Ruler::SetMargin2() - Margin2 < Margin1" ); |
| |
| if ( (mpData->nMargin2 != nPos) || (mpData->nMargin2Style != nMarginStyle) ) |
| { |
| mpData->nMargin2 = nPos; |
| mpData->nMargin2Style = nMarginStyle; |
| ImplUpdate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetLines( sal_uInt16 n, const RulerLine* pLineAry ) |
| { |
| // To determine if what has changed |
| if ( mpData->nLines == n ) |
| { |
| sal_uInt16 i = n; |
| const RulerLine* pAry1 = mpData->pLines; |
| const RulerLine* pAry2 = pLineAry; |
| while ( i ) |
| { |
| if ( (pAry1->nPos != pAry2->nPos) || |
| (pAry1->nStyle != pAry2->nStyle) ) |
| break; |
| pAry1++; |
| pAry2++; |
| i--; |
| } |
| if ( !i ) |
| return; |
| } |
| |
| // New values and new share issue |
| sal_Bool bMustUpdate; |
| if ( IsReallyVisible() && IsUpdateMode() ) |
| bMustUpdate = sal_True; |
| else |
| bMustUpdate = sal_False; |
| |
| // Delete old lines |
| if ( bMustUpdate ) |
| ImplInvertLines(); |
| |
| // New data set |
| if ( !n || !pLineAry ) |
| { |
| if ( !mpData->pLines ) |
| return; |
| delete[] mpData->pLines; |
| mpData->nLines = 0; |
| mpData->pLines = NULL; |
| } |
| else |
| { |
| if ( mpData->nLines != n ) |
| { |
| delete[] mpData->pLines; |
| mpData->nLines = n; |
| mpData->pLines = new RulerLine[n]; |
| } |
| |
| memcpy( mpData->pLines, pLineAry, n*sizeof( RulerLine ) ); |
| |
| // Linien neu ausgeben |
| if ( bMustUpdate ) |
| ImplInvertLines(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetArrows( sal_uInt16 n, const RulerArrow* pArrowAry ) |
| { |
| if ( !n || !pArrowAry ) |
| { |
| if ( !mpData->pArrows ) |
| return; |
| delete[] mpData->pArrows; |
| mpData->nArrows = 0; |
| mpData->pArrows = NULL; |
| } |
| else |
| { |
| if ( mpData->nArrows != n ) |
| { |
| delete[] mpData->pArrows; |
| mpData->nArrows = n; |
| mpData->pArrows = new RulerArrow[n]; |
| } |
| else |
| { |
| sal_uInt16 i = n; |
| const RulerArrow* pAry1 = mpData->pArrows; |
| const RulerArrow* pAry2 = pArrowAry; |
| while ( i ) |
| { |
| if ( (pAry1->nPos != pAry2->nPos) || |
| (pAry1->nWidth != pAry2->nWidth) || |
| (pAry1->nLogWidth != pAry2->nLogWidth) || |
| (pAry1->nStyle != pAry2->nStyle) ) |
| break; |
| pAry1++; |
| pAry2++; |
| i--; |
| } |
| if ( !i ) |
| return; |
| } |
| |
| memcpy( mpData->pArrows, pArrowAry, n*sizeof( RulerArrow ) ); |
| } |
| |
| ImplUpdate(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetBorders( sal_uInt16 n, const RulerBorder* pBrdAry ) |
| { |
| if ( !n || !pBrdAry ) |
| { |
| if ( !mpData->pBorders ) |
| return; |
| delete[] mpData->pBorders; |
| mpData->nBorders = 0; |
| mpData->pBorders = NULL; |
| } |
| else |
| { |
| if ( mpData->nBorders != n ) |
| { |
| delete[] mpData->pBorders; |
| mpData->nBorders = n; |
| mpData->pBorders = new RulerBorder[n]; |
| } |
| else |
| { |
| sal_uInt16 i = n; |
| const RulerBorder* pAry1 = mpData->pBorders; |
| const RulerBorder* pAry2 = pBrdAry; |
| while ( i ) |
| { |
| if ( (pAry1->nPos != pAry2->nPos) || |
| (pAry1->nWidth != pAry2->nWidth) || |
| (pAry1->nStyle != pAry2->nStyle) ) |
| break; |
| pAry1++; |
| pAry2++; |
| i--; |
| } |
| if ( !i ) |
| return; |
| } |
| |
| memcpy( mpData->pBorders, pBrdAry, n*sizeof( RulerBorder ) ); |
| } |
| |
| ImplUpdate(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetIndents( sal_uInt16 n, const RulerIndent* pIndentAry ) |
| { |
| |
| if ( !n || !pIndentAry ) |
| { |
| if ( !mpData->pIndents ) |
| return; |
| delete[] mpData->pIndents; |
| mpData->nIndents = 0; |
| mpData->pIndents = NULL; |
| } |
| else |
| { |
| if ( mpData->nIndents != n ) |
| { |
| delete[] mpData->pIndents; |
| mpData->nIndents = n; |
| mpData->pIndents = new RulerIndent[n]; |
| } |
| else |
| { |
| sal_uInt16 i = n; |
| const RulerIndent* pAry1 = mpData->pIndents; |
| const RulerIndent* pAry2 = pIndentAry; |
| while ( i ) |
| { |
| if ( (pAry1->nPos != pAry2->nPos) || |
| (pAry1->nStyle != pAry2->nStyle) ) |
| break; |
| pAry1++; |
| pAry2++; |
| i--; |
| } |
| if ( !i ) |
| return; |
| } |
| |
| memcpy( mpData->pIndents, pIndentAry, n*sizeof( RulerIndent ) ); |
| } |
| |
| ImplUpdate(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetTabs( sal_uInt16 n, const RulerTab* pTabAry ) |
| { |
| if ( !n || !pTabAry ) |
| { |
| if ( !mpData->pTabs ) |
| return; |
| delete[] mpData->pTabs; |
| mpData->nTabs = 0; |
| mpData->pTabs = NULL; |
| } |
| else |
| { |
| if ( mpData->nTabs != n ) |
| { |
| delete[] mpData->pTabs; |
| mpData->nTabs = n; |
| mpData->pTabs = new RulerTab[n]; |
| } |
| else |
| { |
| sal_uInt16 i = n; |
| const RulerTab* pAry1 = mpData->pTabs; |
| const RulerTab* pAry2 = pTabAry; |
| while ( i ) |
| { |
| if ( (pAry1->nPos != pAry2->nPos) || |
| (pAry1->nStyle != pAry2->nStyle) ) |
| break; |
| pAry1++; |
| pAry2++; |
| i--; |
| } |
| if ( !i ) |
| return; |
| } |
| |
| memcpy( mpData->pTabs, pTabAry, n*sizeof( RulerTab ) ); |
| } |
| |
| ImplUpdate(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::SetStyle( WinBits nStyle ) |
| { |
| if ( mnWinStyle != nStyle ) |
| { |
| mnWinStyle = nStyle; |
| ImplInitExtraField( sal_True ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Ruler::DrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle ) |
| { |
| /*const StyleSettings& rStyleSettings =*/ pDevice->GetSettings().GetStyleSettings(); |
| Point aPos( rPos ); |
| sal_uInt16 nTabStyle = nStyle & (RULER_TAB_STYLE | RULER_TAB_RTL); |
| |
| pDevice->Push( PUSH_LINECOLOR | PUSH_FILLCOLOR ); |
| pDevice->SetLineColor(); |
| pDevice->SetFillColor( pDevice->GetSettings().GetStyleSettings().GetWindowTextColor() ); |
| ImplCenterTabPos( aPos, nTabStyle ); |
| ImplDrawRulerTab( pDevice, aPos, nTabStyle, nStyle ); |
| pDevice->Pop(); |
| } |
| /* -----------------16.10.2002 15:17----------------- |
| * |
| * --------------------------------------------------*/ |
| void Ruler::SetTextRTL(sal_Bool bRTL) |
| { |
| if(mpData->bTextRTL != bRTL) |
| { |
| mpData->bTextRTL = bRTL; |
| if ( IsReallyVisible() && IsUpdateMode() ) |
| ImplInitExtraField( sal_True ); |
| } |
| |
| } |
| long Ruler::GetPageOffset() const { return mpData->nPageOff; } |
| long Ruler::GetPageWidth() const { return mpData->nPageWidth; } |
| long Ruler::GetNullOffset() const { return mpData->nNullOff; } |
| long Ruler::GetMargin1() const { return mpData->nMargin1; } |
| sal_uInt16 Ruler::GetMargin1Style() const { return mpData->nMargin1Style; } |
| long Ruler::GetMargin2() const { return mpData->nMargin2; } |
| sal_uInt16 Ruler::GetMargin2Style() const { return mpData->nMargin2Style; } |
| sal_uInt16 Ruler::GetLineCount() const { return mpData->nLines; } |
| const RulerLine* Ruler::GetLines() const { return mpData->pLines; } |
| sal_uInt16 Ruler::GetArrowCount() const { return mpData->nArrows; } |
| const RulerArrow* Ruler::GetArrows() const { return mpData->pArrows; } |
| sal_uInt16 Ruler::GetBorderCount() const { return mpData->nBorders; } |
| const RulerBorder* Ruler::GetBorders() const { return mpData->pBorders; } |
| sal_uInt16 Ruler::GetIndentCount() const { return mpData->nIndents; } |
| const RulerIndent* Ruler::GetIndents() const { return mpData->pIndents; } |
| |
| uno::Reference< XAccessible > Ruler::CreateAccessible() |
| { |
| Window* pParent = GetAccessibleParentWindow(); |
| DBG_ASSERT( pParent, "-SvxRuler::CreateAccessible(): No Parent!" ); |
| uno::Reference< XAccessible > xAccParent = pParent->GetAccessible(); |
| if( xAccParent.is() ) |
| { |
| // MT: Fixed compiler issue because the address from a temporary object was used. |
| // BUT: Shoudl it really be a Pointer, instead of const&??? |
| OUString aStr; |
| if ( mnWinStyle & WB_HORZ ) |
| { |
| aStr = OUString(XubString(SvtResId(STR_SVT_ACC_RULER_HORZ_NAME))); |
| } |
| else |
| { |
| aStr = OUString(XubString(SvtResId(STR_SVT_ACC_RULER_VERT_NAME))); |
| } |
| pAccContext = new SvtRulerAccessible( xAccParent, *this, aStr ); |
| pAccContext->acquire(); |
| this->SetAccessible(pAccContext); |
| return pAccContext; |
| } |
| else |
| return uno::Reference< XAccessible >(); |
| } |