sc/source/ui/dbgui/csvruler.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "csvruler.hxx"
  21 #include "AccessibleCsvControl.hxx"
  22
  23 #include <optutil.hxx>
  24 #include <com/sun/star/uno/Any.hxx>
  25 #include <com/sun/star/uno/Sequence.hxx>
  26 #include <comphelper/string.hxx>
  27 #include <vcl/settings.hxx>
  28 #include "miscuno.hxx"
  29
  30 using namespace com::sun::star::uno;
  31
  32 #define SEP_PATH            "Office.Calc/Dialogs/CSVImport"
  33 #define FIXED_WIDTH_LIST    "FixedWidthList"
  34
  35 static void load_FixedWidthList(ScCsvSplits &rSplits)
  36 {
  37     OUString sSplits;
  38     OUString sFixedWidthLists;
  39
  40     Sequence<Any>aValues;
  41     const Any *pProperties;
  42     Sequence<OUString> aNames(1);
  43     OUString* pNames = aNames.getArray();
  44     ScLinkConfigItem aItem( OUString( SEP_PATH ) );
  45
  46     pNames[0] = FIXED_WIDTH_LIST;
  47     aValues = aItem.GetProperties( aNames );
  48     pProperties = aValues.getConstArray();
  49
  50     if( pProperties[0].hasValue() )
  51     {
  52         rSplits.Clear();
  53         pProperties[0] >>= sFixedWidthLists;
  54
  55         sSplits = sFixedWidthLists;
  56
  57         // String ends with a semi-colon so there is no 'int' after the last one.
  58         sal_Int32 n = comphelper::string::getTokenCount(sSplits, ';') - 1;
  59         for (sal_Int32 i = 0; i < n; ++i)
  60             rSplits.Insert( sSplits.getToken(i, ';').toInt32() );
  61     }
  62 }
  63 static void save_FixedWidthList(const ScCsvSplits& rSplits)
  64 {
  65     OUStringBuffer sSplits;
  66     // Create a semi-colon separated string to save the splits
  67     sal_uInt32 n = rSplits.Count();
  68     for (sal_uInt32 i = 0; i < n; ++i)
  69     {
  70         sSplits.append(OUString::number(rSplits[i]));
  71         sSplits.append(";");
  72     }
  73
  74     OUString sFixedWidthLists = sSplits.makeStringAndClear();
  75     Sequence<Any> aValues;
  76     Any *pProperties;
  77     Sequence<OUString> aNames(1);
  78     OUString* pNames = aNames.getArray();
  79     ScLinkConfigItem aItem( OUString( SEP_PATH ) );
  80
  81     pNames[0] = FIXED_WIDTH_LIST;
  82     aValues = aItem.GetProperties( aNames );
  83     pProperties = aValues.getArray();
  84     pProperties[0] <<= sFixedWidthLists;
  85
  86     aItem.PutProperties(aNames, aValues);
  87 }
  88
  89 ScCsvRuler::ScCsvRuler( ScCsvControl& rParent ) :
  90     ScCsvControl( rParent ),
  91     mnPosCursorLast( 1 )
  92 {
  93     EnableRTL( false ); // RTL
  94     InitColors();
  95     InitSizeData();
  96     maBackgrDev->SetFont( GetFont() );
  97     maRulerDev->SetFont( GetFont() );
  98
  99     load_FixedWidthList( maSplits );
 100 }
 101
 102 ScCsvRuler::~ScCsvRuler()
 103 {
 104     disposeOnce();
 105 }
 106
 107 void ScCsvRuler::dispose()
 108 {
 109     save_FixedWidthList( maSplits );
 110     ScCsvControl::dispose();
 111 }
 112
 113 // common ruler handling ------------------------------------------------------
 114
 115 void ScCsvRuler::setPosSizePixel(
 116         long nX, long nY, long nWidth, long nHeight, PosSizeFlags nFlags )
 117 {
 118     if( nFlags & PosSizeFlags::Height )
 119         nHeight = GetTextHeight() + mnSplitSize + 2;
 120     ScCsvControl::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
 121 }
 122
 123 void ScCsvRuler::ApplyLayout( const ScCsvLayoutData& rOldData )
 124 {
 125     ScCsvDiff nDiff = GetLayoutData().GetDiff( rOldData ) & (CSV_DIFF_HORIZONTAL | CSV_DIFF_RULERCURSOR);
 126     if( nDiff == CSV_DIFF_EQUAL ) return;
 127
 128     DisableRepaint();
 129     if( nDiff & CSV_DIFF_HORIZONTAL )
 130     {
 131         InitSizeData();
 132         if( GetRulerCursorPos() >= GetPosCount() )
 133             MoveCursor( GetPosCount() - 1 );
 134     }
 135     if( nDiff & CSV_DIFF_RULERCURSOR )
 136     {
 137         ImplInvertCursor( rOldData.mnPosCursor );
 138         ImplInvertCursor( GetRulerCursorPos() );
 139     }
 140     EnableRepaint();
 141
 142     if( nDiff & CSV_DIFF_POSOFFSET )
 143         AccSendVisibleEvent();
 144 }
 145
 146 void ScCsvRuler::InitColors()
 147 {
 148     const StyleSettings& rSett = GetSettings().GetStyleSettings();
 149     maBackColor = rSett.GetFaceColor();
 150     maActiveColor = rSett.GetWindowColor();
 151     maTextColor = rSett.GetLabelTextColor();
 152     maSplitColor = maBackColor.IsDark() ? maTextColor : Color( COL_LIGHTRED );
 153     InvalidateGfx();
 154 }
 155
 156 void ScCsvRuler::InitSizeData()
 157 {
 158     maWinSize = GetSizePixel();
 159
 160     mnSplitSize = (GetCharWidth() * 3 / 5) | 1; // make an odd number
 161
 162     sal_Int32 nActiveWidth = std::min( GetWidth() - GetHdrWidth(), GetPosCount() * GetCharWidth() );
 163     sal_Int32 nActiveHeight = GetTextHeight();
 164
 165     maActiveRect.SetPos( Point( GetFirstX(), (GetHeight() - nActiveHeight - 1) / 2 ) );
 166     maActiveRect.SetSize( Size( nActiveWidth, nActiveHeight ) );
 167
 168     maBackgrDev->SetOutputSizePixel( maWinSize );
 169     maRulerDev->SetOutputSizePixel( maWinSize );
 170
 171     InvalidateGfx();
 172 }
 173
 174 void ScCsvRuler::MoveCursor( sal_Int32 nPos, bool bScroll )
 175 {
 176     DisableRepaint();
 177     if( bScroll )
 178         Execute( CSVCMD_MAKEPOSVISIBLE, nPos );
 179     Execute( CSVCMD_MOVERULERCURSOR, IsVisibleSplitPos( nPos ) ? nPos : CSV_POS_INVALID );
 180     EnableRepaint();
 181     AccSendCaretEvent();
 182 }
 183
 184 void ScCsvRuler::MoveCursorRel( ScMoveMode eDir )
 185 {
 186     if( GetRulerCursorPos() != CSV_POS_INVALID )
 187     {
 188         switch( eDir )
 189         {
 190             case MOVE_FIRST:
 191                 MoveCursor( 1 );
 192             break;
 193             case MOVE_LAST:
 194                 MoveCursor( GetPosCount() - 1 );
 195             break;
 196             case MOVE_PREV:
 197                 if( GetRulerCursorPos() > 1 )
 198                     MoveCursor( GetRulerCursorPos() - 1 );
 199             break;
 200             case MOVE_NEXT:
 201                 if( GetRulerCursorPos() < GetPosCount() - 1 )
 202                     MoveCursor( GetRulerCursorPos() + 1 );
 203             break;
 204             default:
 205             {
 206                 // added to avoid warnings
 207             }
 208         }
 209     }
 210 }
 211
 212 void ScCsvRuler::MoveCursorToSplit( ScMoveMode eDir )
 213 {
 214     if( GetRulerCursorPos() != CSV_POS_INVALID )
 215     {
 216         sal_uInt32 nIndex = CSV_VEC_NOTFOUND;
 217         switch( eDir )
 218         {
 219             case MOVE_FIRST:    nIndex = maSplits.LowerBound( 0 );                          break;
 220             case MOVE_LAST:     nIndex = maSplits.UpperBound( GetPosCount() );              break;
 221             case MOVE_PREV:     nIndex = maSplits.UpperBound( GetRulerCursorPos() - 1 );    break;
 222             case MOVE_NEXT:     nIndex = maSplits.LowerBound( GetRulerCursorPos() + 1 );    break;
 223             default:
 224             {
 225                 // added to avoid warnings
 226             }
 227         }
 228         sal_Int32 nPos = maSplits[ nIndex ];
 229         if( nPos != CSV_POS_INVALID )
 230             MoveCursor( nPos );
 231     }
 232 }
 233
 234 void ScCsvRuler::ScrollVertRel( ScMoveMode eDir )
 235 {
 236     sal_Int32 nLine = GetFirstVisLine();
 237     switch( eDir )
 238     {
 239         case MOVE_PREV:     --nLine;                        break;
 240         case MOVE_NEXT:     ++nLine;                        break;
 241         case MOVE_PREVPAGE: nLine -= GetVisLineCount() - 1; break;
 242         case MOVE_NEXTPAGE: nLine += GetVisLineCount() - 1; break;
 243         default:
 244         {
 245             // added to avoid warnings
 246         }
 247     }
 248     Execute( CSVCMD_SETLINEOFFSET, nLine );
 249 }
 250
 251 // split handling -------------------------------------------------------------
 252
 253 sal_Int32 ScCsvRuler::GetNoScrollPos( sal_Int32 nPos ) const
 254 {
 255     sal_Int32 nNewPos = nPos;
 256     if( nNewPos != CSV_POS_INVALID )
 257     {
 258         if( nNewPos < GetFirstVisPos() + CSV_SCROLL_DIST )
 259         {
 260             sal_Int32 nScroll = (GetFirstVisPos() > 0) ? CSV_SCROLL_DIST : 0;
 261             nNewPos = std::max( nPos, GetFirstVisPos() + nScroll );
 262         }
 263         else if( nNewPos > GetLastVisPos() - CSV_SCROLL_DIST - 1L )
 264         {
 265             sal_Int32 nScroll = (GetFirstVisPos() < GetMaxPosOffset()) ? CSV_SCROLL_DIST : 0;
 266             nNewPos = std::min( nNewPos, GetLastVisPos() - nScroll - sal_Int32( 1 ) );
 267         }
 268     }
 269     return nNewPos;
 270 }
 271
 272 void ScCsvRuler::InsertSplit( sal_Int32 nPos )
 273 {
 274     if( maSplits.Insert( nPos ) )
 275     {
 276         ImplDrawSplit( nPos );
 277         Repaint();
 278     }
 279 }
 280
 281 void ScCsvRuler::RemoveSplit( sal_Int32 nPos )
 282 {
 283     if( maSplits.Remove( nPos ) )
 284     {
 285         ImplEraseSplit( nPos );
 286         Repaint();
 287     }
 288 }
 289
 290 void ScCsvRuler::MoveSplit( sal_Int32 nPos, sal_Int32 nNewPos )
 291 {
 292     bool bRemove = maSplits.Remove( nPos );
 293     bool bInsert = maSplits.Insert( nNewPos );
 294     if( bRemove || bInsert )
 295     {
 296         ImplEraseSplit( nPos );
 297         ImplDrawSplit( nNewPos );
 298         Repaint();
 299     }
 300 }
 301
 302 void ScCsvRuler::RemoveAllSplits()
 303 {
 304     maSplits.Clear();
 305     Repaint( true );
 306 }
 307
 308 sal_Int32 ScCsvRuler::FindEmptyPos( sal_Int32 nPos, ScMoveMode eDir ) const
 309 {
 310     sal_Int32 nNewPos = nPos;
 311     if( nNewPos != CSV_POS_INVALID )
 312     {
 313         switch( eDir )
 314         {
 315             case MOVE_FIRST:
 316                 nNewPos = std::min( nPos, FindEmptyPos( 0, MOVE_NEXT ) );
 317             break;
 318             case MOVE_LAST:
 319                 nNewPos = std::max( nPos, FindEmptyPos( GetPosCount(), MOVE_PREV ) );
 320             break;
 321             case MOVE_PREV:
 322                 while( HasSplit( --nNewPos ) ) ;
 323             break;
 324             case MOVE_NEXT:
 325                 while( HasSplit( ++nNewPos ) ) ;
 326             break;
 327             default:
 328             {
 329                 // added to avoid warnings
 330             }
 331         }
 332     }
 333     return IsValidSplitPos( nNewPos ) ? nNewPos : CSV_POS_INVALID;
 334 }
 335
 336 void ScCsvRuler::MoveCurrSplit( sal_Int32 nNewPos )
 337 {
 338     DisableRepaint();
 339     Execute( CSVCMD_MOVESPLIT, GetRulerCursorPos(), nNewPos );
 340     MoveCursor( nNewPos );
 341     EnableRepaint();
 342 }
 343
 344 void ScCsvRuler::MoveCurrSplitRel( ScMoveMode eDir )
 345 {
 346     if( HasSplit( GetRulerCursorPos() ) )
 347     {
 348         sal_Int32 nNewPos = FindEmptyPos( GetRulerCursorPos(), eDir );
 349         if( nNewPos != CSV_POS_INVALID )
 350             MoveCurrSplit( nNewPos );
 351     }
 352 }
 353
 354 // event handling -------------------------------------------------------------
 355
 356 void ScCsvRuler::Resize()
 357 {
 358     ScCsvControl::Resize();
 359     InitSizeData();
 360     Repaint();
 361 }
 362
 363 void ScCsvRuler::GetFocus()
 364 {
 365     ScCsvControl::GetFocus();
 366     DisableRepaint();
 367     if( GetRulerCursorPos() == CSV_POS_INVALID )
 368         MoveCursor( GetNoScrollPos( mnPosCursorLast ) );
 369     EnableRepaint();
 370 }
 371
 372 void ScCsvRuler::LoseFocus()
 373 {
 374     ScCsvControl::LoseFocus();
 375     mnPosCursorLast = GetRulerCursorPos();
 376     MoveCursor( CSV_POS_INVALID );
 377 }
 378
 379 void ScCsvRuler::DataChanged( const DataChangedEvent& rDCEvt )
 380 {
 381     if( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 382     {
 383         InitColors();
 384         Repaint();
 385     }
 386     ScCsvControl::DataChanged( rDCEvt );
 387 }
 388
 389 void ScCsvRuler::MouseButtonDown( const MouseEvent& rMEvt )
 390 {
 391     DisableRepaint();
 392     if( !HasFocus() )
 393         GrabFocus();
 394     if( rMEvt.IsLeft() )
 395     {
 396         sal_Int32 nPos = GetPosFromX( rMEvt.GetPosPixel().X() );
 397         if( IsVisibleSplitPos( nPos ) )
 398             StartMouseTracking( nPos );
 399         ImplSetMousePointer( nPos );
 400     }
 401     EnableRepaint();
 402 }
 403
 404 void ScCsvRuler::MouseMove( const MouseEvent& rMEvt )
 405 {
 406     if( !rMEvt.IsModifierChanged() )
 407     {
 408         sal_Int32 nPos = GetPosFromX( rMEvt.GetPosPixel().X() );
 409         if( IsTracking() )
 410         {
 411             // on mouse tracking: keep position valid
 412             nPos = std::max( std::min( nPos, GetPosCount() - sal_Int32( 1 ) ), sal_Int32( 1 ) );
 413             MoveMouseTracking( nPos );
 414         }
 415         else
 416         {
 417             Point aPoint;
 418             Rectangle aRect( aPoint, maWinSize );
 419             if( !IsVisibleSplitPos( nPos ) || !aRect.IsInside( rMEvt.GetPosPixel() ) )
 420                 // if focused, keep old cursor position for key input
 421                 nPos = HasFocus() ? GetRulerCursorPos() : CSV_POS_INVALID;
 422             MoveCursor( nPos, false );
 423         }
 424         ImplSetMousePointer( nPos );
 425     }
 426 }
 427
 428 void ScCsvRuler::Tracking( const TrackingEvent& rTEvt )
 429 {
 430     if( rTEvt.IsTrackingEnded() || rTEvt.IsTrackingRepeat() )
 431         MouseMove( rTEvt.GetMouseEvent() );
 432     if( rTEvt.IsTrackingEnded() )
 433         EndMouseTracking( !rTEvt.IsTrackingCanceled() );
 434 }
 435
 436 void ScCsvRuler::KeyInput( const KeyEvent& rKEvt )
 437 {
 438     const vcl::KeyCode& rKCode = rKEvt.GetKeyCode();
 439     sal_uInt16 nCode = rKCode.GetCode();
 440     bool bNoMod = !rKCode.GetModifier();
 441     bool bShift = (rKCode.GetModifier() == KEY_SHIFT);
 442     bool bJump = (rKCode.GetModifier() == KEY_MOD1);
 443     bool bMove = (rKCode.GetModifier() == (KEY_MOD1 | KEY_SHIFT));
 444
 445     ScMoveMode eHDir = GetHorzDirection( nCode, true );
 446     ScMoveMode eVDir = GetVertDirection( nCode, false );
 447
 448     if( bNoMod )
 449     {
 450         if( eHDir != MOVE_NONE )
 451             MoveCursorRel( eHDir );
 452         else if( eVDir != MOVE_NONE )
 453             ScrollVertRel( eVDir );
 454         else switch( nCode )
 455         {
 456             case KEY_SPACE:     Execute( CSVCMD_TOGGLESPLIT, GetRulerCursorPos() ); break;
 457             case KEY_INSERT:    Execute( CSVCMD_INSERTSPLIT, GetRulerCursorPos() ); break;
 458             case KEY_DELETE:    Execute( CSVCMD_REMOVESPLIT, GetRulerCursorPos() ); break;
 459         }
 460     }
 461     else if( bJump && (eHDir != MOVE_NONE) )
 462         MoveCursorToSplit( eHDir );
 463     else if( bMove && (eHDir != MOVE_NONE) )
 464         MoveCurrSplitRel( eHDir );
 465     else if( bShift && (nCode == KEY_DELETE) )
 466         Execute( CSVCMD_REMOVEALLSPLITS );
 467
 468     if( rKCode.GetGroup() != KEYGROUP_CURSOR )
 469         ScCsvControl::KeyInput( rKEvt );
 470 }
 471
 472 void ScCsvRuler::StartMouseTracking( sal_Int32 nPos )
 473 {
 474     mnPosMTStart = mnPosMTCurr = nPos;
 475     mbPosMTMoved = false;
 476     maOldSplits = maSplits;
 477     Execute( CSVCMD_INSERTSPLIT, nPos );
 478     if( HasSplit( nPos ) )
 479         StartTracking( STARTTRACK_BUTTONREPEAT );
 480 }
 481
 482 void ScCsvRuler::MoveMouseTracking( sal_Int32 nPos )
 483 {
 484     if( mnPosMTCurr != nPos )
 485     {
 486         DisableRepaint();
 487         MoveCursor( nPos );
 488         if( (mnPosMTCurr != mnPosMTStart) && maOldSplits.HasSplit( mnPosMTCurr ) )
 489             Execute( CSVCMD_INSERTSPLIT, nPos );
 490         else
 491             Execute( CSVCMD_MOVESPLIT, mnPosMTCurr, nPos );
 492         mnPosMTCurr = nPos;
 493         mbPosMTMoved = true;
 494         EnableRepaint();
 495     }
 496 }
 497
 498 void ScCsvRuler::EndMouseTracking( bool bApply )
 499 {
 500     if( bApply )    // tracking finished successfully
 501     {
 502         // remove on simple click on an existing split
 503         if( (mnPosMTCurr == mnPosMTStart) && maOldSplits.HasSplit( mnPosMTCurr ) && !mbPosMTMoved )
 504             Execute( CSVCMD_REMOVESPLIT, mnPosMTCurr );
 505     }
 506     else            // tracking cancelled
 507     {
 508         MoveCursor( mnPosMTStart );
 509         // move split to origin
 510         if( maOldSplits.HasSplit( mnPosMTStart ) )
 511             MoveMouseTracking( mnPosMTStart );
 512         // remove temporarily inserted split
 513         else if( !maOldSplits.HasSplit( mnPosMTCurr ) )
 514             Execute( CSVCMD_REMOVESPLIT, mnPosMTCurr );
 515     }
 516     mnPosMTStart = CSV_POS_INVALID;
 517 }
 518
 519 // painting -------------------------------------------------------------------
 520
 521 void ScCsvRuler::Paint( vcl::RenderContext& /*rRenderContext*/, const Rectangle& )
 522 {
 523     Repaint();
 524 }
 525
 526 void ScCsvRuler::ImplRedraw()
 527 {
 528     if( IsVisible() )
 529     {
 530         if( !IsValidGfx() )
 531         {
 532             ValidateGfx();
 533             ImplDrawBackgrDev();
 534             ImplDrawRulerDev();
 535         }
 536         DrawOutDev( Point(), maWinSize, Point(), maWinSize, *maRulerDev.get() );
 537         ImplDrawTrackingRect();
 538     }
 539 }
 540
 541 void ScCsvRuler::ImplDrawArea( sal_Int32 nPosX, sal_Int32 nWidth )
 542 {
 543     maBackgrDev->SetLineColor();
 544     Rectangle aRect( Point( nPosX, 0 ), Size( nWidth, GetHeight() ) );
 545     maBackgrDev->SetFillColor( maBackColor );
 546     maBackgrDev->DrawRect( aRect );
 547
 548     aRect = maActiveRect;
 549     aRect.Left() = std::max( GetFirstX(), nPosX );
 550     aRect.Right() = std::min( std::min( GetX( GetPosCount() ), GetLastX() ), nPosX + nWidth - sal_Int32( 1 ) );
 551     if( aRect.Left() <= aRect.Right() )
 552     {
 553         maBackgrDev->SetFillColor( maActiveColor );
 554         maBackgrDev->DrawRect( aRect );
 555     }
 556
 557     maBackgrDev->SetLineColor( maTextColor );
 558     sal_Int32 nY = GetHeight() - 1;
 559     maBackgrDev->DrawLine( Point( nPosX, nY ), Point( nPosX + nWidth - 1, nY ) );
 560 }
 561
 562 void ScCsvRuler::ImplDrawBackgrDev()
 563 {
 564     ImplDrawArea( 0, GetWidth() );
 565
 566     // scale
 567     maBackgrDev->SetLineColor( maTextColor );
 568     maBackgrDev->SetFillColor();
 569     sal_Int32 nPos;
 570
 571     sal_Int32 nFirstPos = std::max( GetPosFromX( 0 ) - (sal_Int32)(1L), (sal_Int32)(0L) );
 572     sal_Int32 nLastPos = GetPosFromX( GetWidth() );
 573     sal_Int32 nY = (maActiveRect.Top() + maActiveRect.Bottom()) / 2;
 574     for( nPos = nFirstPos; nPos <= nLastPos; ++nPos )
 575     {
 576         sal_Int32 nX = GetX( nPos );
 577         if( nPos % 5 )
 578             maBackgrDev->DrawPixel( Point( nX, nY ) );
 579         else
 580             maBackgrDev->DrawLine( Point( nX, nY - 1 ), Point( nX, nY + 1 ) );
 581     }
 582
 583     // texts
 584     maBackgrDev->SetTextColor( maTextColor );
 585     maBackgrDev->SetTextFillColor();
 586     for( nPos = ((nFirstPos + 9) / 10) * 10; nPos <= nLastPos; nPos += 10 )
 587     {
 588         OUString aText( OUString::number( nPos ) );
 589         sal_Int32 nTextWidth = maBackgrDev->GetTextWidth( aText );
 590         sal_Int32 nTextX = GetX( nPos ) - nTextWidth / 2;
 591         ImplDrawArea( nTextX - 1, nTextWidth + 2 );
 592         maBackgrDev->DrawText( Point( nTextX, maActiveRect.Top() ), aText );
 593     }
 594 }
 595
 596 void ScCsvRuler::ImplDrawSplit( sal_Int32 nPos )
 597 {
 598     if( IsVisibleSplitPos( nPos ) )
 599     {
 600         Point aPos( GetX( nPos ) - mnSplitSize / 2, GetHeight() - mnSplitSize - 2 );
 601         Size aSize( mnSplitSize, mnSplitSize );
 602         maRulerDev->SetLineColor( maTextColor );
 603         maRulerDev->SetFillColor( maSplitColor );
 604         maRulerDev->DrawEllipse( Rectangle( aPos, aSize ) );
 605         maRulerDev->DrawPixel( Point( GetX( nPos ), GetHeight() - 2 ) );
 606     }
 607 }
 608
 609 void ScCsvRuler::ImplEraseSplit( sal_Int32 nPos )
 610 {
 611     if( IsVisibleSplitPos( nPos ) )
 612     {
 613         ImplInvertCursor( GetRulerCursorPos() );
 614         Point aPos( GetX( nPos ) - mnSplitSize / 2, 0 );
 615         Size aSize( mnSplitSize, GetHeight() );
 616         maRulerDev->DrawOutDev( aPos, aSize, aPos, aSize, *maBackgrDev.get() );
 617         ImplInvertCursor( GetRulerCursorPos() );
 618     }
 619 }
 620
 621 void ScCsvRuler::ImplDrawRulerDev()
 622 {
 623     maRulerDev->DrawOutDev( Point(), maWinSize, Point(), maWinSize, *maBackgrDev.get() );
 624     ImplInvertCursor( GetRulerCursorPos() );
 625
 626     sal_uInt32 nFirst = maSplits.LowerBound( GetFirstVisPos() );
 627     sal_uInt32 nLast = maSplits.UpperBound( GetLastVisPos() );
 628     if( (nFirst != CSV_VEC_NOTFOUND) && (nLast != CSV_VEC_NOTFOUND) )
 629         for( sal_uInt32 nIndex = nFirst; nIndex <= nLast; ++nIndex )
 630             ImplDrawSplit( GetSplitPos( nIndex ) );
 631 }
 632
 633 void ScCsvRuler::ImplInvertCursor( sal_Int32 nPos )
 634 {
 635     if( IsVisibleSplitPos( nPos ) )
 636     {
 637         ImplInvertRect( *maRulerDev.get(), Rectangle( Point( GetX( nPos ) - 1, 0 ), Size( 3, GetHeight() - 1 ) ) );
 638         if( HasSplit( nPos ) )
 639             ImplDrawSplit( nPos );
 640     }
 641 }
 642
 643 void ScCsvRuler::ImplDrawTrackingRect()
 644 {
 645     if( HasFocus() )
 646         InvertTracking( Rectangle( 0, 0, GetWidth() - 1, GetHeight() - 2 ),
 647             SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
 648 }
 649
 650 void ScCsvRuler::ImplSetMousePointer( sal_Int32 nPos )
 651 {
 652     SetPointer( Pointer( HasSplit( nPos ) ? PointerStyle::HSplit : PointerStyle::Arrow ) );
 653 }
 654
 655 // accessibility ==============================================================
 656
 657 ScAccessibleCsvControl* ScCsvRuler::ImplCreateAccessible()
 658 {
 659     return new ScAccessibleCsvRuler( *this );
 660 }
 661
 662 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */