sfx2/source/control/thumbnailview.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
  10 #include <sfx2/thumbnailview.hxx>
  11 #include <sfx2/thumbnailviewitem.hxx>
  12
  13 #include <utility>
  14
  15 #include "thumbnailviewacc.hxx"
  16
  17 #include <basegfx/color/bcolortools.hxx>
  18 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  19 #include <basegfx/range/b2drectangle.hxx>
  20 #include <basegfx/polygon/b2dpolygon.hxx>
  21 #include <basegfx/vector/b2dsize.hxx>
  22 #include <basegfx/vector/b2dvector.hxx>
  23 #include <drawinglayer/attribute/fillbitmapattribute.hxx>
  24 #include <drawinglayer/attribute/fontattribute.hxx>
  25 #include <drawinglayer/primitive2d/fillbitmapprimitive2d.hxx>
  26 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  27 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  28 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  29 #include <drawinglayer/processor2d/baseprocessor2d.hxx>
  30 #include <drawinglayer/processor2d/processorfromoutputdevice.hxx>
  31 #include <rtl/ustring.hxx>
  32 #include <vcl/decoview.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/scrbar.hxx>
  35 #include <vcl/help.hxx>
  36
  37 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  39
  40 using namespace basegfx;
  41 using namespace basegfx::tools;
  42 using namespace drawinglayer::attribute;
  43 using namespace drawinglayer::primitive2d;
  44
  45 enum
  46 {
  47     ITEM_OFFSET = 4,
  48     ITEM_OFFSET_DOUBLE = 6,
  49     NAME_LINE_OFF_X = 2,
  50     NAME_LINE_OFF_Y = 2,
  51     NAME_LINE_HEIGHT = 2,
  52     NAME_OFFSET = 2,
  53     SCROLL_OFFSET = 4
  54 };
  55
  56 ThumbnailView::ThumbnailView (Window *pParent, WinBits nWinStyle, bool bDisableTransientChildren)
  57     : Control( pParent, nWinStyle )
  58 {
  59     ImplInit();
  60     mbIsTransientChildrenDisabled = bDisableTransientChildren;
  61 }
  62
  63 ThumbnailView::ThumbnailView (Window *pParent, const ResId &rResId, bool bDisableTransientChildren)
  64     : Control( pParent, rResId )
  65 {
  66     ImplInit();
  67     mbIsTransientChildrenDisabled = bDisableTransientChildren;
  68 }
  69
  70 ThumbnailView::~ThumbnailView()
  71 {
  72     com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent>
  73             xComponent(GetAccessible(sal_False),
  74                        com::sun::star::uno::UNO_QUERY);
  75
  76     if (xComponent.is())
  77         xComponent->dispose ();
  78
  79     delete mpScrBar;
  80     delete mpItemAttrs;
  81     delete mpProcessor;
  82
  83     ImplDeleteItems();
  84 }
  85
  86 void ThumbnailView::AppendItem(ThumbnailViewItem *pItem)
  87 {
  88     if (maFilterFunc(pItem))
  89     {
  90         // Save current start,end range, iterator might get invalidated
  91         size_t nSelStartPos = 0;
  92         ThumbnailViewItem *pSelStartItem = NULL;
  93
  94         if (mpStartSelRange != mFilteredItemList.end())
  95         {
  96             pSelStartItem = *mpStartSelRange;
  97             nSelStartPos = mpStartSelRange - mFilteredItemList.begin();
  98         }
  99
 100         mFilteredItemList.push_back(pItem);
 101         mpStartSelRange = pSelStartItem != NULL ? mFilteredItemList.begin() + nSelStartPos : mFilteredItemList.end();
 102     }
 103
 104     mItemList.push_back(pItem);
 105 }
 106
 107 void ThumbnailView::ImplInit()
 108 {
 109     mpScrBar            = NULL;
 110     mnHeaderHeight      = 0;
 111     mnItemWidth         = 0;
 112     mnItemHeight        = 0;
 113     mnItemPadding = 0;
 114     mnVisLines          = 0;
 115     mnLines             = 0;
 116     mnFirstLine         = 0;
 117     mnHighItemId        = 0;
 118     mnCols              = 0;
 119     mnSpacing           = 0;
 120     mbScroll            = false;
 121     mbHasVisibleItems   = false;
 122     maFilterFunc = ViewFilterAll();
 123     maColor = GetSettings().GetStyleSettings().GetFieldColor();
 124     mpStartSelRange = mFilteredItemList.end();
 125
 126     // Create the processor and process the primitives
 127     const drawinglayer::geometry::ViewInformation2D aNewViewInfos;
 128     mpProcessor = drawinglayer::processor2d::createBaseProcessor2DFromOutputDevice(*this, aNewViewInfos );
 129
 130     ImplInitSettings( true, true, true );
 131 }
 132
 133 void ThumbnailView::ImplDeleteItems()
 134 {
 135     const size_t n = mItemList.size();
 136
 137     for ( size_t i = 0; i < n; ++i )
 138     {
 139         ThumbnailViewItem *const pItem = mItemList[i];
 140
 141         // deselect all current selected items and fire events
 142         if (pItem->isSelected())
 143         {
 144             pItem->setSelection(false);
 145             maItemStateHdl.Call(pItem);
 146
 147             // fire accessible event???
 148         }
 149
 150         if ( pItem->isVisible() && ImplHasAccessibleListeners() )
 151         {
 152             ::com::sun::star::uno::Any aOldAny, aNewAny;
 153
 154             aOldAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
 155             ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
 156         }
 157
 158         delete pItem;
 159     }
 160
 161     mItemList.clear();
 162     mFilteredItemList.clear();
 163
 164     mpStartSelRange = mFilteredItemList.end();
 165 }
 166
 167 void ThumbnailView::ImplInitSettings( bool bFont, bool bForeground, bool bBackground )
 168 {
 169     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 170
 171     if ( bFont )
 172     {
 173         Font aFont;
 174         aFont = rStyleSettings.GetAppFont();
 175         if ( IsControlFont() )
 176             aFont.Merge( GetControlFont() );
 177         SetZoomedPointFont( aFont );
 178     }
 179
 180     if ( bForeground || bFont )
 181     {
 182         Color aColor;
 183         if ( IsControlForeground() )
 184             aColor = GetControlForeground();
 185         else
 186             aColor = rStyleSettings.GetButtonTextColor();
 187         SetTextColor( aColor );
 188         SetTextFillColor();
 189     }
 190
 191     if ( bBackground )
 192     {
 193         Color aColor = rStyleSettings.GetFieldColor();
 194         SetBackground( aColor );
 195     }
 196
 197
 198     mpItemAttrs = new ThumbnailItemAttributes;
 199     mpItemAttrs->aFillColor = maColor.getBColor();
 200     mpItemAttrs->aHighlightColor = rStyleSettings.GetHighlightColor().getBColor();
 201     mpItemAttrs->aFontAttr = getFontAttributeFromVclFont(mpItemAttrs->aFontSize,GetFont(),false,true);
 202     mpItemAttrs->nMaxTextLenght = -1;
 203 }
 204
 205 void ThumbnailView::ImplInitScrollBar()
 206 {
 207     if ( GetStyle() & WB_VSCROLL )
 208     {
 209         if ( !mpScrBar )
 210         {
 211             mpScrBar = new ScrollBar( this, WB_VSCROLL | WB_DRAG );
 212             mpScrBar->SetScrollHdl( LINK( this, ThumbnailView, ImplScrollHdl ) );
 213         }
 214         else
 215         {
 216             // adapt the width because of the changed settings
 217             long nScrBarWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
 218             mpScrBar->setPosSizePixel( 0, 0, nScrBarWidth, 0, WINDOW_POSSIZE_WIDTH );
 219         }
 220     }
 221 }
 222
 223 void ThumbnailView::DrawItem (ThumbnailViewItem *pItem)
 224 {
 225     if (pItem->isVisible())
 226     {
 227         Rectangle aRect = pItem->getDrawArea();
 228
 229         if ( (aRect.GetHeight() > 0) && (aRect.GetWidth() > 0) )
 230             pItem->Paint(mpProcessor,mpItemAttrs);
 231     }
 232 }
 233
 234 void ThumbnailView::OnItemDblClicked (ThumbnailViewItem*)
 235 {
 236 }
 237
 238 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ThumbnailView::CreateAccessible()
 239 {
 240     return new ThumbnailViewAcc( this, mbIsTransientChildrenDisabled );
 241 }
 242
 243 void ThumbnailView::CalculateItemPositions ()
 244 {
 245     if (!mnItemHeight || !mnItemWidth)
 246         return;
 247
 248     Size        aWinSize = GetOutputSizePixel();
 249     size_t      nItemCount = mFilteredItemList.size();
 250     WinBits     nStyle = GetStyle();
 251     ScrollBar*  pDelScrBar = NULL;
 252
 253     // consider the scrolling
 254     if ( nStyle & WB_VSCROLL )
 255         ImplInitScrollBar();
 256     else
 257     {
 258         if ( mpScrBar )
 259         {
 260             // delete ScrollBar not until later, to prevent recursive calls
 261             pDelScrBar = mpScrBar;
 262             mpScrBar = NULL;
 263         }
 264     }
 265
 266     // calculate ScrollBar width
 267     long nScrBarWidth = 0;
 268     if ( mpScrBar )
 269         nScrBarWidth = mpScrBar->GetSizePixel().Width();
 270
 271     // calculate maximum number of visible columns
 272     mnCols = (sal_uInt16)((aWinSize.Width()-nScrBarWidth) / (mnItemWidth));
 273
 274     if (!mnCols)
 275         mnCols = 1;
 276
 277     // calculate maximum number of visible rows
 278     mnVisLines = (sal_uInt16)((aWinSize.Height()-mnHeaderHeight) / (mnItemHeight));
 279
 280     // calculate empty space
 281     long nHSpace = aWinSize.Width()-nScrBarWidth - mnCols*mnItemWidth;
 282     long nVSpace = aWinSize.Height()-mnHeaderHeight - mnVisLines*mnItemHeight;
 283     long nHItemSpace = nHSpace / (mnCols+1);
 284     long nVItemSpace = nVSpace / (mnVisLines+1);
 285
 286     // calculate maximum number of rows
 287     // Floor( (M+N-1)/N )==Ceiling( M/N )
 288     mnLines = (static_cast<long>(nItemCount)+mnCols-1) / mnCols;
 289
 290     if ( !mnLines )
 291         mnLines = 1;
 292
 293     if ( mnLines <= mnVisLines )
 294         mnFirstLine = 0;
 295     else
 296     {
 297         if ( mnFirstLine > (sal_uInt16)(mnLines-mnVisLines) )
 298             mnFirstLine = (sal_uInt16)(mnLines-mnVisLines);
 299     }
 300
 301     mbHasVisibleItems = true;
 302
 303     // calculate offsets
 304     long nStartX = nHItemSpace;
 305     long nStartY = nVItemSpace + mnHeaderHeight;
 306
 307     // calculate and draw items
 308     long x = nStartX;
 309     long y = nStartY;
 310
 311     // draw items
 312     size_t nFirstItem = mnFirstLine * mnCols;
 313     size_t nLastItem = nFirstItem + (mnVisLines * mnCols);
 314
 315     maItemListRect.Left() = x;
 316     maItemListRect.Top() = y;
 317     maItemListRect.Right() = x + mnCols*(mnItemWidth+nHItemSpace) - nHItemSpace - 1;
 318     maItemListRect.Bottom() = y + mnVisLines*(mnItemHeight+nVItemSpace) - nVItemSpace - 1;
 319
 320     // If want also draw parts of items in the last line,
 321     // then we add one more line if parts of these line are
 322     // visible
 323
 324     size_t nCurCount = 0;
 325     for ( size_t i = 0; i < nItemCount; i++ )
 326     {
 327         ThumbnailViewItem *const pItem = mFilteredItemList[i];
 328
 329         if ((nCurCount >= nFirstItem) && (nCurCount < nLastItem))
 330         {
 331             if( !pItem->isVisible())
 332             {
 333                 if ( ImplHasAccessibleListeners() )
 334                 {
 335                     ::com::sun::star::uno::Any aOldAny, aNewAny;
 336
 337                     aNewAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
 338                     ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
 339                 }
 340
 341                 pItem->show(true);
 342
 343                 maItemStateHdl.Call(pItem);
 344             }
 345
 346             pItem->setDrawArea(Rectangle( Point(x,y), Size(mnItemWidth, mnItemHeight) ));
 347             pItem->calculateItemsPosition(mnThumbnailHeight,mnDisplayHeight,mnItemPadding,mpItemAttrs->nMaxTextLenght,mpItemAttrs);
 348
 349             if ( !((nCurCount+1) % mnCols) )
 350             {
 351                 x = nStartX;
 352                 y += mnItemHeight+nVItemSpace;
 353             }
 354             else
 355                 x += mnItemWidth+nHItemSpace;
 356         }
 357         else
 358         {
 359             if( pItem->isVisible())
 360             {
 361                 if ( ImplHasAccessibleListeners() )
 362                 {
 363                     ::com::sun::star::uno::Any aOldAny, aNewAny;
 364
 365                     aOldAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
 366                     ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
 367                 }
 368
 369                 pItem->show(false);
 370
 371                 maItemStateHdl.Call(pItem);
 372             }
 373
 374         }
 375
 376         ++nCurCount;
 377     }
 378
 379     // arrange ScrollBar, set values and show it
 380     if ( mpScrBar )
 381     {
 382         mnLines = (nCurCount+mnCols-1)/mnCols;
 383
 384         // check if scroll is needed
 385         mbScroll = mnLines > mnVisLines;
 386
 387
 388         Point aPos( aWinSize.Width() - nScrBarWidth, mnHeaderHeight );
 389         Size aSize( nScrBarWidth, aWinSize.Height() - mnHeaderHeight );
 390
 391         mpScrBar->SetPosSizePixel( aPos, aSize );
 392         mpScrBar->SetRangeMax( (nCurCount+mnCols-1)/mnCols);
 393         mpScrBar->SetVisibleSize( mnVisLines );
 394         mpScrBar->SetThumbPos( (long)mnFirstLine );
 395         long nPageSize = mnVisLines;
 396         if ( nPageSize < 1 )
 397             nPageSize = 1;
 398         mpScrBar->SetPageSize( nPageSize );
 399         mpScrBar->Show( mbScroll );
 400     }
 401
 402     // delete ScrollBar
 403     delete pDelScrBar;
 404 }
 405
 406 size_t ThumbnailView::ImplGetItem( const Point& rPos, bool bMove ) const
 407 {
 408     if ( !mbHasVisibleItems )
 409     {
 410         return THUMBNAILVIEW_ITEM_NOTFOUND;
 411     }
 412
 413     if ( maItemListRect.IsInside( rPos ) )
 414     {
 415         for (size_t i = 0; i < mFilteredItemList.size(); ++i)
 416         {
 417             if (mFilteredItemList[i]->isVisible() && mFilteredItemList[i]->getDrawArea().IsInside(rPos))
 418                 return i;
 419         }
 420
 421         // return the previously selected item if spacing is set and
 422         // the mouse hasn't left the window yet
 423         if ( bMove && mnSpacing && mnHighItemId )
 424         {
 425             return GetItemPos( mnHighItemId );
 426         }
 427     }
 428
 429     return THUMBNAILVIEW_ITEM_NOTFOUND;
 430 }
 431
 432 ThumbnailViewItem* ThumbnailView::ImplGetItem( size_t nPos )
 433 {
 434     return ( nPos < mFilteredItemList.size() ) ? mFilteredItemList[nPos] : NULL;
 435 }
 436
 437 sal_uInt16 ThumbnailView::ImplGetVisibleItemCount() const
 438 {
 439     sal_uInt16 nRet = 0;
 440     const size_t nItemCount = mItemList.size();
 441
 442     for ( size_t n = 0; n < nItemCount; ++n )
 443     {
 444         if ( mItemList[n]->isVisible() )
 445             ++nRet;
 446     }
 447
 448     return nRet;
 449 }
 450
 451 ThumbnailViewItem* ThumbnailView::ImplGetVisibleItem( sal_uInt16 nVisiblePos )
 452 {
 453     const size_t nItemCount = mItemList.size();
 454
 455     for ( size_t n = 0; n < nItemCount; ++n )
 456     {
 457         ThumbnailViewItem *const pItem = mItemList[n];
 458
 459         if ( pItem->isVisible() && !nVisiblePos-- )
 460             return pItem;
 461     }
 462
 463     return NULL;
 464 }
 465
 466 void ThumbnailView::ImplFireAccessibleEvent( short nEventId, const ::com::sun::star::uno::Any& rOldValue, const ::com::sun::star::uno::Any& rNewValue )
 467 {
 468     ThumbnailViewAcc* pAcc = ThumbnailViewAcc::getImplementation( GetAccessible( sal_False ) );
 469
 470     if( pAcc )
 471         pAcc->FireAccessibleEvent( nEventId, rOldValue, rNewValue );
 472 }
 473
 474 bool ThumbnailView::ImplHasAccessibleListeners()
 475 {
 476     ThumbnailViewAcc* pAcc = ThumbnailViewAcc::getImplementation( GetAccessible( sal_False ) );
 477     return( pAcc && pAcc->HasAccessibleListeners() );
 478 }
 479
 480 IMPL_LINK( ThumbnailView,ImplScrollHdl, ScrollBar*, pScrollBar )
 481 {
 482     sal_uInt16 nNewFirstLine = mnFirstLine;
 483
 484     if (pScrollBar->GetDelta() > 0)
 485         nNewFirstLine += 1;
 486     else
 487         nNewFirstLine -= 1;
 488
 489     if ( nNewFirstLine != mnFirstLine )
 490     {
 491         mnFirstLine = nNewFirstLine;
 492
 493         CalculateItemPositions();
 494
 495         if ( IsReallyVisible() && IsUpdateMode() )
 496             Invalidate();
 497     }
 498     return 0;
 499 }
 500
 501 IMPL_LINK (ThumbnailView, OnItemSelected, ThumbnailViewItem*, pItem)
 502 {
 503     maItemStateHdl.Call(pItem);
 504     return 0;
 505 }
 506
 507 void ThumbnailView::KeyInput( const KeyEvent& rKEvt )
 508 {
 509     // Get the last selected item in the list
 510     size_t nLastPos = 0;
 511     bool bFoundLast = false;
 512     for ( long i = mFilteredItemList.size() - 1; !bFoundLast && i >= 0; --i )
 513     {
 514         ThumbnailViewItem* pItem = mFilteredItemList[i];
 515         if ( pItem->isSelected() )
 516         {
 517             nLastPos = i;
 518             bFoundLast = true;
 519         }
 520     }
 521
 522     bool bValidRange = false;
 523     bool bHasSelRange = mpStartSelRange != mFilteredItemList.end();
 524     size_t nNextPos = nLastPos;
 525     KeyCode aKeyCode = rKEvt.GetKeyCode();
 526     ThumbnailViewItem* pNext = NULL;
 527
 528     if (aKeyCode.IsShift() && bHasSelRange)
 529     {
 530         //If the last elemented selected is the start range position
 531         //search for the first selected item
 532         size_t nSelPos = mpStartSelRange - mFilteredItemList.begin();
 533
 534         if (nLastPos == nSelPos)
 535         {
 536             while (nLastPos && mFilteredItemList[nLastPos-1]->isSelected())
 537                 --nLastPos;
 538         }
 539     }
 540
 541     switch ( aKeyCode.GetCode() )
 542     {
 543         case KEY_RIGHT:
 544             {
 545                 if ( bFoundLast && nLastPos < mFilteredItemList.size( ) - 1 )
 546                 {
 547                     bValidRange = true;
 548                     nNextPos = nLastPos + 1;
 549                 }
 550
 551                 pNext = mFilteredItemList[nNextPos];
 552             }
 553             break;
 554         case KEY_LEFT:
 555             {
 556                 if ( nLastPos > 0 )
 557                 {
 558                     bValidRange = true;
 559                     nNextPos = nLastPos - 1;
 560                 }
 561
 562                 pNext = mFilteredItemList[nNextPos];
 563             }
 564             break;
 565         case KEY_DOWN:
 566             {
 567                 if ( bFoundLast )
 568                 {
 569                     //If we are in the second last row just go the one in
 570                     //the row below, if theres not row below just go to the
 571                     //last item but for the last row dont do anything.
 572                     if ( nLastPos < mFilteredItemList.size( ) - mnCols )
 573                     {
 574                         bValidRange = true;
 575                         nNextPos = nLastPos + mnCols;
 576                     }
 577                     else
 578                     {
 579                         int curRow = nLastPos/mnCols;
 580
 581                         if (curRow < mnLines-1)
 582                             nNextPos = mFilteredItemList.size()-1;
 583                     }
 584                 }
 585
 586                 pNext = mFilteredItemList[nNextPos];
 587             }
 588             break;
 589         case KEY_UP:
 590             {
 591                 if ( nLastPos >= mnCols )
 592                 {
 593                     bValidRange = true;
 594                     nNextPos = nLastPos - mnCols;
 595                 }
 596
 597                 pNext = mFilteredItemList[nNextPos];
 598             }
 599             break;
 600         case KEY_RETURN:
 601             {
 602                 if ( bFoundLast )
 603                     OnItemDblClicked( mFilteredItemList[nLastPos] );
 604             }
 605         default:
 606             Control::KeyInput( rKEvt );
 607     }
 608
 609     if ( pNext )
 610     {
 611         if (aKeyCode.IsShift() && bValidRange)
 612         {
 613             std::pair<size_t,size_t> aRange;
 614             size_t nSelPos = mpStartSelRange - mFilteredItemList.begin();
 615
 616             if (nLastPos < nSelPos)
 617             {
 618                 if (nNextPos > nLastPos)
 619                 {
 620                     if ( nNextPos > nSelPos)
 621                         aRange = std::make_pair(nLastPos,nNextPos);
 622                     else
 623                         aRange = std::make_pair(nLastPos,nNextPos-1);
 624                 }
 625                 else
 626                     aRange = std::make_pair(nNextPos,nLastPos-1);
 627             }
 628             else if (nLastPos == nSelPos)
 629             {
 630                 if (nNextPos > nLastPos)
 631                     aRange = std::make_pair(nLastPos+1,nNextPos);
 632                 else
 633                     aRange = std::make_pair(nNextPos,nLastPos-1);
 634             }
 635             else
 636             {
 637                 if (nNextPos > nLastPos)
 638                     aRange = std::make_pair(nLastPos+1,nNextPos);
 639                 else
 640                 {
 641                     if ( nNextPos < nSelPos)
 642                         aRange = std::make_pair(nNextPos,nLastPos);
 643                     else
 644                         aRange = std::make_pair(nNextPos+1,nLastPos);
 645                 }
 646             }
 647
 648             for (size_t i = aRange.first; i <= aRange.second; ++i)
 649             {
 650                 if (i != nSelPos)
 651                 {
 652                     ThumbnailViewItem *pCurItem = mFilteredItemList[i];
 653
 654                     pCurItem->setSelection(!pCurItem->isSelected());
 655
 656                     if (pCurItem->isVisible())
 657                         DrawItem(pCurItem);
 658
 659                     maItemStateHdl.Call(pCurItem);
 660                 }
 661             }
 662         }
 663         else if (!aKeyCode.IsShift())
 664         {
 665             deselectItems();
 666             SelectItem(pNext->mnId);
 667
 668             //Mark it as the selection range start position
 669             mpStartSelRange = mFilteredItemList.begin() + nNextPos;
 670         }
 671
 672         MakeItemVisible(pNext->mnId);
 673     }
 674 }
 675
 676 void ThumbnailView::MakeItemVisible( sal_uInt16 nItemId )
 677 {
 678     // Get the item row
 679     size_t nPos = 0;
 680     bool bFound = false;
 681     for ( size_t i = 0; !bFound && i < mFilteredItemList.size(); ++i )
 682     {
 683         ThumbnailViewItem* pItem = mFilteredItemList[i];
 684         if ( pItem->mnId == nItemId )
 685         {
 686             nPos = i;
 687             bFound = true;
 688         }
 689     }
 690     sal_uInt16 nRow = nPos / mnCols;
 691
 692     // Move the visible rows as little as possible to include that one
 693     if ( nRow < mnFirstLine )
 694         mnFirstLine = nRow;
 695     else if ( nRow > mnFirstLine + mnVisLines )
 696         mnFirstLine = nRow - mnVisLines;
 697
 698     CalculateItemPositions();
 699     Invalidate();
 700 }
 701
 702 void ThumbnailView::MouseButtonDown( const MouseEvent& rMEvt )
 703 {
 704     if ( rMEvt.IsLeft() )
 705     {
 706         size_t nPos = ImplGetItem(rMEvt.GetPosPixel());
 707         ThumbnailViewItem* pItem = ImplGetItem(nPos);
 708
 709         if (pItem && pItem->isVisible())
 710         {
 711             if ( rMEvt.GetClicks() == 1 )
 712             {
 713                 if (rMEvt.IsMod1())
 714                 {
 715                     //Keep selected item group state and just invert current desired one state
 716                     pItem->setSelection(!pItem->isSelected());
 717
 718                     //This one becomes the selection range start position if it changes its state to selected otherwise resets it
 719                     mpStartSelRange = pItem->isSelected() ? mFilteredItemList.begin() + nPos : mFilteredItemList.end();
 720                 }
 721                 else if (rMEvt.IsShift() && mpStartSelRange != mFilteredItemList.end())
 722                 {
 723                     std::pair<size_t,size_t> aNewRange;
 724                     aNewRange.first = mpStartSelRange - mFilteredItemList.begin();
 725                     aNewRange.second = nPos;
 726
 727                     if (aNewRange.first > aNewRange.second)
 728                         std::swap(aNewRange.first,aNewRange.second);
 729
 730                     //Deselect the ones outside of it
 731                     for (size_t i = 0, n = mFilteredItemList.size(); i < n; ++i)
 732                     {
 733                         ThumbnailViewItem *pCurItem  = mFilteredItemList[i];
 734
 735                         if (pCurItem->isSelected() && (i < aNewRange.first || i > aNewRange.second))
 736                         {
 737                             pCurItem->setSelection(false);
 738
 739                             if (pCurItem->isVisible())
 740                                 DrawItem(pCurItem);
 741
 742                             maItemStateHdl.Call(pCurItem);
 743                         }
 744                     }
 745
 746                     size_t nSelPos = mpStartSelRange - mFilteredItemList.begin();
 747
 748                     //Select the items between start range and the selected item
 749                     if (nSelPos != nPos)
 750                     {
 751                         int dir = nSelPos < nPos ? 1 : -1;
 752                         size_t nCurPos = nSelPos + dir;
 753
 754                         while (nCurPos != nPos)
 755                         {
 756                             ThumbnailViewItem *pCurItem  = mFilteredItemList[nCurPos];
 757
 758                             if (!pCurItem->isSelected())
 759                             {
 760                                 pCurItem->setSelection(true);
 761
 762                                 if (pCurItem->isVisible())
 763                                     DrawItem(pCurItem);
 764
 765                                 maItemStateHdl.Call(pCurItem);
 766                             }
 767
 768                             nCurPos += dir;
 769                         }
 770                     }
 771
 772                     pItem->setSelection(true);
 773                 }
 774                 else
 775                 {
 776                     //If we got a group of selected items deselect the rest and only keep the desired one
 777                     //mark items as not selected to not fire unnecessary change state events.
 778                     pItem->setSelection(false);
 779                     deselectItems();
 780                     pItem->setSelection(true);
 781
 782                     //Mark as initial selection range position and reset end one
 783                     mpStartSelRange = mFilteredItemList.begin() + nPos;
 784                 }
 785
 786                 if (pItem->isSelected())
 787                 {
 788                     bool bClickOnTitle = pItem->getTextArea().IsInside(rMEvt.GetPosPixel());
 789                     pItem->setEditTitle(bClickOnTitle);
 790                 }
 791
 792                 if (!pItem->isHighlighted())
 793                     DrawItem(pItem);
 794
 795                 maItemStateHdl.Call(pItem);
 796
 797                 //fire accessible event??
 798             }
 799             else if ( rMEvt.GetClicks() == 2 )
 800             {
 801                 Rectangle aRect(pItem->getDrawArea());
 802
 803                 if (aRect.IsInside(rMEvt.GetPosPixel()))
 804                     OnItemDblClicked(pItem);
 805             }
 806
 807             return;
 808         }
 809         else if (!pItem)
 810             deselectItems( );
 811     }
 812
 813     Control::MouseButtonDown( rMEvt );
 814 }
 815
 816 void ThumbnailView::MouseButtonUp( const MouseEvent& rMEvt )
 817 {
 818     Control::MouseButtonUp( rMEvt );
 819 }
 820
 821 void ThumbnailView::Command( const CommandEvent& rCEvt )
 822 {
 823     if ( (rCEvt.GetCommand() == COMMAND_WHEEL) ||
 824          (rCEvt.GetCommand() == COMMAND_STARTAUTOSCROLL) ||
 825          (rCEvt.GetCommand() == COMMAND_AUTOSCROLL) )
 826     {
 827         if ( HandleScrollCommand( rCEvt, NULL, mpScrBar ) )
 828             return;
 829     }
 830
 831     Control::Command( rCEvt );
 832 }
 833
 834 void ThumbnailView::Paint( const Rectangle &aRect)
 835 {
 836     size_t      nItemCount = mItemList.size();
 837
 838     // Draw background
 839     Primitive2DSequence aSeq(1);
 840     aSeq[0] = Primitive2DReference( new PolyPolygonColorPrimitive2D(
 841                                         B2DPolyPolygon(Polygon(aRect,5,5).getB2DPolygon()),
 842                                         maColor.getBColor()));
 843
 844     mpProcessor->process(aSeq);
 845
 846     // draw items
 847     for ( size_t i = 0; i < nItemCount; i++ )
 848     {
 849         ThumbnailViewItem *const pItem = mItemList[i];
 850
 851         if ( pItem->isVisible() )
 852             DrawItem(pItem);
 853     }
 854
 855     if ( mpScrBar && mpScrBar->IsVisible() )
 856         mpScrBar->Paint(aRect);
 857 }
 858
 859 void ThumbnailView::GetFocus()
 860 {
 861     if(GETFOCUS_TAB & GetGetFocusFlags())
 862     {
 863         // Select the first item if nothing selected
 864         int nSelected = -1;
 865         for (size_t i = 0, n = mItemList.size(); i < n && nSelected == -1; ++i)
 866         {
 867             if (mItemList[i]->isSelected())
 868                 nSelected = i;
 869         }
 870
 871         if ( nSelected == -1 && mItemList.size( ) > 0 )
 872         {
 873             SelectItem( 1 );
 874         }
 875     }
 876
 877     // Tell the accessible object that we got the focus.
 878     ThumbnailViewAcc* pAcc = ThumbnailViewAcc::getImplementation( GetAccessible( sal_False ) );
 879     if( pAcc )
 880         pAcc->GetFocus();
 881
 882     Control::GetFocus();
 883 }
 884
 885 void ThumbnailView::LoseFocus()
 886 {
 887     if (mnHighItemId)
 888     {
 889         size_t nPos = GetItemPos(mnHighItemId);
 890
 891         if (nPos != THUMBNAILVIEW_ITEM_NOTFOUND)
 892         {
 893             ThumbnailViewItem *pOld = mItemList[nPos];
 894
 895             pOld->setHighlight(false);
 896
 897             if (!pOld->isSelected())
 898                 DrawItem(pOld);
 899         }
 900
 901         mnHighItemId = 0;
 902     }
 903
 904     Control::LoseFocus();
 905
 906     // Tell the accessible object that we lost the focus.
 907     ThumbnailViewAcc* pAcc = ThumbnailViewAcc::getImplementation( GetAccessible( sal_False ) );
 908     if( pAcc )
 909         pAcc->LoseFocus();
 910 }
 911
 912 void ThumbnailView::Resize()
 913 {
 914     Control::Resize();
 915     CalculateItemPositions();
 916
 917     if ( IsReallyVisible() && IsUpdateMode() )
 918         Invalidate();
 919 }
 920
 921 void ThumbnailView::StateChanged( StateChangedType nType )
 922 {
 923     Control::StateChanged( nType );
 924
 925     if ( nType == STATE_CHANGE_INITSHOW )
 926     {
 927         if ( IsReallyVisible() && IsUpdateMode() )
 928             Invalidate();
 929     }
 930     else if ( nType == STATE_CHANGE_UPDATEMODE )
 931     {
 932         if ( IsReallyVisible() && IsUpdateMode() )
 933             Invalidate();
 934     }
 935     else if ( nType == STATE_CHANGE_TEXT )
 936     {
 937     }
 938     else if ( (nType == STATE_CHANGE_ZOOM) ||
 939               (nType == STATE_CHANGE_CONTROLFONT) )
 940     {
 941         ImplInitSettings( true, false, false );
 942         Invalidate();
 943     }
 944     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 945     {
 946         ImplInitSettings( false, true, false );
 947         Invalidate();
 948     }
 949     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 950     {
 951         ImplInitSettings( false, false, true );
 952         Invalidate();
 953     }
 954     else if ( (nType == STATE_CHANGE_STYLE) || (nType == STATE_CHANGE_ENABLE) )
 955     {
 956         ImplInitSettings( false, false, true );
 957         Invalidate();
 958     }
 959 }
 960
 961 void ThumbnailView::DataChanged( const DataChangedEvent& rDCEvt )
 962 {
 963     Control::DataChanged( rDCEvt );
 964
 965     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
 966          (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
 967          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
 968          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 969           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
 970     {
 971         ImplInitSettings( true, true, true );
 972         Invalidate();
 973     }
 974 }
 975
 976 void ThumbnailView::RemoveItem( sal_uInt16 nItemId )
 977 {
 978     size_t nPos = GetItemPos( nItemId );
 979
 980     if ( nPos == THUMBNAILVIEW_ITEM_NOTFOUND )
 981         return;
 982
 983     if ( nPos < mFilteredItemList.size() ) {
 984
 985         // delete item from the thumbnail list
 986         for (size_t i = 0, n = mItemList.size(); i < n; ++i)
 987         {
 988             if (mItemList[i]->mnId == nItemId)
 989             {
 990                 mItemList.erase(mItemList.begin()+i);
 991                 break;
 992             }
 993         }
 994
 995         // delete item from the filter item list
 996         ValueItemList::iterator it = mFilteredItemList.begin();
 997         ::std::advance( it, nPos );
 998
 999         if ((*it)->isSelected())
1000         {
1001             (*it)->setSelection(false);
1002             maItemStateHdl.Call(*it);
1003         }
1004
1005         delete *it;
1006         mFilteredItemList.erase( it );
1007         mpStartSelRange = mFilteredItemList.end();
1008     }
1009
1010     // reset variables
1011     if ( mnHighItemId == nItemId )
1012     {
1013         mnHighItemId    = 0;
1014     }
1015
1016     CalculateItemPositions();
1017
1018     if ( IsReallyVisible() && IsUpdateMode() )
1019         Invalidate();
1020 }
1021
1022 void ThumbnailView::Clear()
1023 {
1024     ImplDeleteItems();
1025
1026     // reset variables
1027     mnFirstLine     = 0;
1028     mnHighItemId    = 0;
1029
1030     CalculateItemPositions();
1031
1032     if ( IsReallyVisible() && IsUpdateMode() )
1033         Invalidate();
1034 }
1035
1036 void ThumbnailView::updateItems (const std::vector<ThumbnailViewItem*> &items)
1037 {
1038     ImplDeleteItems();
1039
1040     // reset variables
1041     mnFirstLine     = 0;
1042     mnHighItemId    = 0;
1043
1044     mItemList = items;
1045
1046     filterItems(maFilterFunc);
1047 }
1048
1049 size_t ThumbnailView::GetItemPos( sal_uInt16 nItemId ) const
1050 {
1051     for ( size_t i = 0, n = mFilteredItemList.size(); i < n; ++i ) {
1052         if ( mFilteredItemList[i]->mnId == nItemId ) {
1053             return i;
1054         }
1055     }
1056     return THUMBNAILVIEW_ITEM_NOTFOUND;
1057 }
1058
1059 sal_uInt16 ThumbnailView::GetItemId( size_t nPos ) const
1060 {
1061     return ( nPos < mFilteredItemList.size() ) ? mFilteredItemList[nPos]->mnId : 0 ;
1062 }
1063
1064 sal_uInt16 ThumbnailView::GetItemId( const Point& rPos ) const
1065 {
1066     size_t nItemPos = ImplGetItem( rPos );
1067     if ( nItemPos != THUMBNAILVIEW_ITEM_NOTFOUND )
1068         return GetItemId( nItemPos );
1069
1070     return 0;
1071 }
1072
1073 sal_uInt16 ThumbnailView::getNextItemId() const
1074 {
1075     return mItemList.empty() ? 1 : mItemList.back()->mnId + 1;
1076 }
1077
1078 void ThumbnailView::setItemMaxTextLength(sal_uInt32 nLength)
1079 {
1080     mpItemAttrs->nMaxTextLenght = nLength;
1081 }
1082
1083 void ThumbnailView::setItemDimensions(long itemWidth, long thumbnailHeight, long displayHeight, int itemPadding)
1084 {
1085     mnItemWidth = itemWidth + 2*itemPadding;
1086     mnThumbnailHeight = thumbnailHeight;
1087     mnDisplayHeight = displayHeight;
1088     mnItemPadding = itemPadding;
1089     mnItemHeight = mnDisplayHeight + mnThumbnailHeight + 2*itemPadding;
1090 }
1091
1092 void ThumbnailView::SelectItem( sal_uInt16 nItemId )
1093 {
1094     size_t nItemPos = GetItemPos( nItemId );
1095     if ( nItemPos == THUMBNAILVIEW_ITEM_NOTFOUND )
1096         return;
1097
1098     ThumbnailViewItem* pItem = mFilteredItemList[nItemPos];
1099     if (!pItem->isSelected())
1100     {
1101         pItem->setSelection(true);
1102         maItemStateHdl.Call(pItem);
1103
1104         if (IsReallyVisible() && IsUpdateMode())
1105             Invalidate();
1106
1107         bool bNewOut = IsReallyVisible() && IsUpdateMode();
1108
1109         // if necessary scroll to the visible area
1110         if ( mbScroll && nItemId )
1111         {
1112             sal_uInt16 nNewLine = (sal_uInt16)(nItemPos / mnCols);
1113             if ( nNewLine < mnFirstLine )
1114             {
1115                 mnFirstLine = nNewLine;
1116             }
1117             else if ( nNewLine > (sal_uInt16)(mnFirstLine+mnVisLines-1) )
1118             {
1119                 mnFirstLine = (sal_uInt16)(nNewLine-mnVisLines+1);
1120             }
1121         }
1122
1123         if ( bNewOut )
1124         {
1125             if ( IsReallyVisible() && IsUpdateMode() )
1126                 Invalidate();
1127         }
1128
1129         if( ImplHasAccessibleListeners() )
1130         {
1131             // focus event (select)
1132             ThumbnailViewAcc* pItemAcc = ThumbnailViewAcc::getImplementation( pItem->GetAccessible( mbIsTransientChildrenDisabled ) );
1133
1134             if( pItemAcc )
1135             {
1136                 ::com::sun::star::uno::Any aOldAny, aNewAny;
1137                 if( !mbIsTransientChildrenDisabled )
1138                 {
1139                     aNewAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
1140                         static_cast< ::cppu::OWeakObject* >( pItemAcc ));
1141                     ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
1142                 }
1143                 else
1144                 {
1145                     aNewAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
1146                     pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
1147                 }
1148             }
1149
1150             // selection event
1151             ::com::sun::star::uno::Any aOldAny, aNewAny;
1152             ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED, aOldAny, aNewAny );
1153         }
1154     }
1155 }
1156
1157 void ThumbnailView::DeselectItem( sal_uInt16 nItemId )
1158 {
1159     size_t nItemPos = GetItemPos( nItemId );
1160     if ( nItemPos == THUMBNAILVIEW_ITEM_NOTFOUND )
1161         return;
1162
1163     ThumbnailViewItem* pItem = mFilteredItemList[nItemPos];
1164     if (pItem->isSelected())
1165     {
1166         pItem->setSelection(false);
1167         maItemStateHdl.Call(pItem);
1168
1169         if (IsReallyVisible() && IsUpdateMode())
1170             Invalidate();
1171
1172         // TODO Trigger event in accessible object?
1173     }
1174 }
1175
1176 bool ThumbnailView::IsItemSelected( sal_uInt16 nItemId ) const
1177 {
1178     size_t nItemPos = GetItemPos( nItemId );
1179     if ( nItemPos == THUMBNAILVIEW_ITEM_NOTFOUND )
1180         return false;
1181
1182     ThumbnailViewItem* pItem = mFilteredItemList[nItemPos];
1183     return pItem->isSelected();
1184 }
1185
1186 void ThumbnailView::deselectItems()
1187 {
1188     for (size_t i = 0, n = mItemList.size(); i < n; ++i)
1189     {
1190         if (mItemList[i]->isSelected())
1191         {
1192             mItemList[i]->setEditTitle(false);
1193             mItemList[i]->setSelection(false);
1194
1195             maItemStateHdl.Call(mItemList[i]);
1196         }
1197     }
1198
1199     if (IsReallyVisible() && IsUpdateMode())
1200         Invalidate();
1201 }
1202
1203 OUString ThumbnailView::GetItemText( sal_uInt16 nItemId ) const
1204 {
1205     size_t nPos = GetItemPos( nItemId );
1206
1207     if ( nPos != THUMBNAILVIEW_ITEM_NOTFOUND )
1208         return mFilteredItemList[nPos]->maTitle;
1209
1210     return OUString();
1211 }
1212
1213 void ThumbnailView::SetColor( const Color& rColor )
1214 {
1215     maColor = rColor;
1216     mpItemAttrs->aFillColor = rColor.getBColor();
1217
1218     if ( IsReallyVisible() && IsUpdateMode() )
1219         Invalidate();
1220 }
1221
1222 void ThumbnailView::filterItems (const boost::function<bool (const ThumbnailViewItem*) > &func)
1223 {
1224     mnFirstLine = 0;        // start at the top of the list instead of the current position
1225     maFilterFunc = func;
1226
1227     size_t nSelPos = 0;
1228     bool bHasSelRange = false;
1229     ThumbnailViewItem *curSel = mpStartSelRange != mFilteredItemList.end() ? *mpStartSelRange : NULL;
1230
1231     mFilteredItemList.clear();
1232
1233     for (size_t i = 0, n = mItemList.size(); i < n; ++i)
1234     {
1235         ThumbnailViewItem *const pItem = mItemList[i];
1236
1237         if (maFilterFunc(pItem))
1238         {
1239             if (curSel == pItem)
1240             {
1241                 nSelPos = i;
1242                 bHasSelRange = true;
1243             }
1244
1245             mFilteredItemList.push_back(pItem);
1246         }
1247         else
1248         {
1249             if( pItem->isVisible())
1250             {
1251                 if ( ImplHasAccessibleListeners() )
1252                 {
1253                     ::com::sun::star::uno::Any aOldAny, aNewAny;
1254
1255                     aOldAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
1256                     ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
1257                 }
1258
1259                 pItem->show(false);
1260                 pItem->setSelection(false);
1261
1262                 maItemStateHdl.Call(pItem);
1263             }
1264         }
1265     }
1266
1267     mpStartSelRange = bHasSelRange ? mFilteredItemList.begin()  + nSelPos : mFilteredItemList.end();
1268     CalculateItemPositions();
1269
1270     Invalidate();
1271 }
1272
1273 void ThumbnailView::sortItems (const boost::function<bool (const ThumbnailViewItem*, const ThumbnailViewItem*) > &func)
1274 {
1275     std::sort(mItemList.begin(),mItemList.end(),func);
1276
1277     CalculateItemPositions();
1278
1279     Invalidate();
1280 }
1281
1282 bool ThumbnailView::renameItem(ThumbnailViewItem*, OUString)
1283 {
1284     // Do nothing by default
1285     return false;
1286 }
1287
1288 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
1289
1290