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