svtools/source/brwbox/editbrowsebox.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: editbrowsebox.cxx,v $
  10  * $Revision: 1.33 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33 #include <svtools/editbrowsebox.hxx>
  34
  35 #ifndef _SVTOOLS_EDITBROWSEBOX_HRC_
  36 #include "editbrowsebox.hrc"
  37 #endif
  38
  39 #ifndef _APP_HXX //autogen
  40 #include <vcl/svapp.hxx>
  41 #endif
  42 #include <tools/debug.hxx>
  43 #include <vcl/window.hxx>
  44
  45 #ifndef _EDIT_HXX //autogen
  46 #include <vcl/edit.hxx>
  47 #endif
  48 #include <tools/resid.hxx>
  49 #include <vcl/spinfld.hxx>
  50 #include <svtools/svtdata.hxx>
  51
  52 #ifndef _SVTOOLS_HRC
  53 #include <svtools/svtools.hrc>
  54 #endif
  55
  56 #include <algorithm>
  57 #include <tools/multisel.hxx>
  58 #include "editbrowseboximpl.hxx"
  59 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  60 #include <com/sun/star/accessibility/XAccessible.hpp>
  61 #include <comphelper/types.hxx>
  62
  63 // .......................................................................
  64 namespace svt
  65 {
  66 // .......................................................................
  67     namespace
  68     {
  69         //..............................................................
  70         sal_Bool isHiContrast(Window* _pWindow)
  71         {
  72             OSL_ENSURE(_pWindow,"Window must be not null!");
  73             Window* pIter = _pWindow;
  74             //  while( pIter &&  pIter->GetBackground().GetColor().GetColor() == COL_TRANSPARENT )
  75             while( pIter )
  76             {
  77                 const Color& aColor = pIter->GetBackground().GetColor();
  78                 if ( aColor.GetColor() == COL_TRANSPARENT )
  79                     pIter = pIter->GetParent();
  80                 else
  81                     break;
  82             }
  83             return pIter && pIter->GetBackground().GetColor().IsDark();
  84         }
  85
  86         //..............................................................
  87         sal_uInt16 getRealGetFocusFlags( Window* _pWindow )
  88         {
  89             sal_uInt16 nFlags = 0;
  90             while ( _pWindow && !nFlags )
  91             {
  92                 nFlags = _pWindow->GetGetFocusFlags( );
  93                 _pWindow = _pWindow->GetParent();
  94             }
  95             return nFlags;
  96         }
  97     }
  98
  99     using namespace ::com::sun::star::uno;
 100     using namespace com::sun::star::accessibility::AccessibleEventId;
 101     using  com::sun::star::accessibility::XAccessible;
 102     //==================================================================
 103
 104     #define HANDLE_ID   0
 105
 106     //==================================================================
 107     //= EditBrowserHeader
 108     //==================================================================
 109     //------------------------------------------------------------------------------
 110     void EditBrowserHeader::DoubleClick()
 111     {
 112         sal_uInt16 nColId = GetCurItemId();
 113         if (nColId)
 114         {
 115             sal_uInt32 nAutoWidth = ((EditBrowseBox*)GetParent())->GetAutoColumnWidth(nColId);
 116             if (nAutoWidth != ((EditBrowseBox*)GetParent())->GetColumnWidth(nColId))
 117             {
 118                 ((EditBrowseBox*)GetParent())->SetColumnWidth(nColId, nAutoWidth);
 119                 ((EditBrowseBox*)GetParent())->ColumnResized(nColId);
 120             }
 121         }
 122     }
 123
 124
 125     //==================================================================
 126     //= EditBrowseBox
 127     //==================================================================
 128     //------------------------------------------------------------------------------
 129     void EditBrowseBox::BrowserMouseEventPtr::Clear()
 130     {
 131         DELETEZ(pEvent);
 132     }
 133
 134     //------------------------------------------------------------------------------
 135     void EditBrowseBox::BrowserMouseEventPtr::Set(const BrowserMouseEvent* pEvt, sal_Bool bIsDown)
 136     {
 137         if (pEvt == pEvent)
 138         {
 139             bDown = bIsDown;
 140             return;
 141         }
 142         Clear();
 143         if (pEvt)
 144         {
 145             pEvent = new BrowserMouseEvent(pEvt->GetWindow(),
 146                                            *pEvt,
 147                                            pEvt->GetRow(),
 148                                            pEvt->GetColumn(),
 149                                            pEvt->GetColumnId(),
 150                                            pEvt->GetRect());
 151             bDown = bIsDown;
 152         }
 153     }
 154
 155     //------------------------------------------------------------------------------
 156     DBG_NAME(EditBrowseBox);
 157     void EditBrowseBox::impl_construct()
 158     {
 159         m_aImpl = ::std::auto_ptr<EditBrowseBoxImpl>(new EditBrowseBoxImpl());
 160         m_aImpl->m_bHiContrast = isHiContrast(&GetDataWindow());
 161
 162         SetCompoundControl(sal_True);
 163         SetGridLineColor( Color( COL_LIGHTGRAY ) );
 164
 165         ImplInitSettings(sal_True, sal_True, sal_True);
 166
 167         pCheckBoxPaint = new CheckBoxControl(&GetDataWindow());
 168         pCheckBoxPaint->SetPaintTransparent( sal_True );
 169         pCheckBoxPaint->SetBackground();
 170     }
 171
 172     //------------------------------------------------------------------------------
 173     EditBrowseBox::EditBrowseBox(Window* pParent, const ResId& rId, sal_Int32 nBrowserFlags, BrowserMode _nMode )
 174                   :BrowseBox( pParent, rId, _nMode )
 175                   ,nStartEvent(0)
 176                   ,nEndEvent(0)
 177                   ,nCellModifiedEvent(0)
 178                   ,nPaintRow(-1)
 179                   ,nEditRow(-1)
 180                   ,nOldEditRow(-1)
 181                   ,nEditCol(0)
 182                   ,nOldEditCol(0)
 183                   ,bHasFocus(sal_False)
 184                   ,bPaintStatus(sal_True)
 185                   ,bActiveBeforeTracking( sal_False )
 186                   ,m_nBrowserFlags(nBrowserFlags)
 187     {
 188         DBG_CTOR(EditBrowseBox,NULL);
 189
 190         impl_construct();
 191     }
 192
 193     //==================================================================
 194     EditBrowseBox::EditBrowseBox( Window* pParent, sal_Int32 nBrowserFlags, WinBits nBits, BrowserMode _nMode )
 195                   :BrowseBox( pParent, nBits, _nMode )
 196                   ,nStartEvent(0)
 197                   ,nEndEvent(0)
 198                   ,nCellModifiedEvent(0)
 199                   ,nPaintRow(-1)
 200                   ,nEditRow(-1)
 201                   ,nOldEditRow(-1)
 202                   ,nEditCol(0)
 203                   ,nOldEditCol(0)
 204                   ,bHasFocus(sal_False)
 205                   ,bPaintStatus(sal_True)
 206                   ,bActiveBeforeTracking( sal_False )
 207                   ,m_nBrowserFlags(nBrowserFlags)
 208                   ,pHeader(NULL)
 209     {
 210         DBG_CTOR(EditBrowseBox,NULL);
 211
 212         impl_construct();
 213     }
 214
 215     //------------------------------------------------------------------------------
 216     void EditBrowseBox::Init()
 217     {
 218         // spaetes Construieren,
 219     }
 220
 221     //------------------------------------------------------------------------------
 222     EditBrowseBox::~EditBrowseBox()
 223     {
 224         if (nStartEvent)
 225             Application::RemoveUserEvent(nStartEvent);
 226         if (nEndEvent)
 227             Application::RemoveUserEvent(nEndEvent);
 228         if (nCellModifiedEvent)
 229             Application::RemoveUserEvent(nCellModifiedEvent);
 230
 231         delete pCheckBoxPaint;
 232
 233         DBG_DTOR(EditBrowseBox,NULL);
 234     }
 235
 236     //------------------------------------------------------------------------------
 237     void EditBrowseBox::RemoveRows()
 238     {
 239         BrowseBox::Clear();
 240         nOldEditRow = nEditRow = nPaintRow = -1;
 241         nEditCol = nOldEditCol = 0;
 242     }
 243
 244     //------------------------------------------------------------------------------
 245     BrowserHeader* EditBrowseBox::CreateHeaderBar(BrowseBox* pParent)
 246     {
 247         pHeader = imp_CreateHeaderBar(pParent);
 248         if (!IsUpdateMode())
 249             pHeader->SetUpdateMode(sal_False);
 250         return pHeader;
 251     }
 252
 253     //------------------------------------------------------------------------------
 254     BrowserHeader* EditBrowseBox::imp_CreateHeaderBar(BrowseBox* pParent)
 255     {
 256         return new EditBrowserHeader(pParent);
 257     }
 258
 259     //------------------------------------------------------------------------------
 260     void EditBrowseBox::LoseFocus()
 261     {
 262         BrowseBox::LoseFocus();
 263         DetermineFocus( 0 );
 264     }
 265
 266     //------------------------------------------------------------------------------
 267     void EditBrowseBox::GetFocus()
 268     {
 269         BrowseBox::GetFocus();
 270
 271         // This should handle the case that the BrowseBox (or one of it's children)
 272         // gets the focus from outside by pressing Tab
 273         if (IsEditing() && Controller()->GetWindow().IsVisible())
 274             Controller()->GetWindow().GrabFocus();
 275
 276         DetermineFocus( getRealGetFocusFlags( this ) );
 277     }
 278
 279     //------------------------------------------------------------------------------
 280     sal_Bool EditBrowseBox::SeekRow(long nRow)
 281     {
 282         nPaintRow = nRow;
 283         return sal_True;
 284     }
 285
 286     //------------------------------------------------------------------------------
 287     IMPL_LINK(EditBrowseBox, StartEditHdl, void*, EMPTYARG)
 288     {
 289         nStartEvent = 0;
 290         if (IsEditing())
 291         {
 292             EnableAndShow();
 293             if (!aController->GetWindow().HasFocus() && (m_pFocusWhileRequest == Application::GetFocusWindow()))
 294                 aController->GetWindow().GrabFocus();
 295         }
 296         return 0;
 297     }
 298
 299     //------------------------------------------------------------------------------
 300     void EditBrowseBox::PaintField( OutputDevice& rDev, const Rectangle& rRect,
 301                                     sal_uInt16 nColumnId ) const
 302     {
 303         if (nColumnId == HANDLE_ID)
 304         {
 305              if (bPaintStatus)
 306                 PaintStatusCell(rDev, rRect);
 307         }
 308         else
 309         {
 310             // don't paint the current cell
 311             if (&rDev == &GetDataWindow())
 312                 // but only if we're painting onto our data win (which is the usual painting)
 313                 if (nPaintRow == nEditRow)
 314                 {
 315                     if (IsEditing() && nEditCol == nColumnId && aController->GetWindow().IsVisible())
 316                         return;
 317                 }
 318             PaintCell(rDev, rRect, nColumnId);
 319         }
 320     }
 321
 322     //------------------------------------------------------------------------------
 323     Image EditBrowseBox::GetImage(RowStatus eStatus) const
 324     {
 325         sal_Bool bHiContrast = isHiContrast(&GetDataWindow());
 326         if ( !m_aStatusImages.GetImageCount() || (bHiContrast != m_aImpl->m_bHiContrast) )
 327         {
 328             m_aImpl->m_bHiContrast = bHiContrast;
 329             const_cast<EditBrowseBox*>(this)->m_aStatusImages = ImageList(SvtResId(bHiContrast ? RID_SVTOOLS_IMAGELIST_EDITBWSEBOX_H : RID_SVTOOLS_IMAGELIST_EDITBROWSEBOX));
 330         }
 331
 332         Image aImage;
 333         bool bNeedMirror = IsRTLEnabled();
 334         switch (eStatus)
 335         {
 336             case CURRENT:
 337                 aImage = m_aStatusImages.GetImage(IMG_EBB_CURRENT);
 338                 break;
 339             case CURRENTNEW:
 340                 aImage = m_aStatusImages.GetImage(IMG_EBB_CURRENTNEW);
 341                 break;
 342             case MODIFIED:
 343                 aImage = m_aStatusImages.GetImage(IMG_EBB_MODIFIED);
 344                 bNeedMirror = false;    // the pen is not mirrored
 345                 break;
 346             case NEW:
 347                 aImage = m_aStatusImages.GetImage(IMG_EBB_NEW);
 348                 break;
 349             case DELETED:
 350                 aImage = m_aStatusImages.GetImage(IMG_EBB_DELETED);
 351                 break;
 352             case PRIMARYKEY:
 353                 aImage = m_aStatusImages.GetImage(IMG_EBB_PRIMARYKEY);
 354                 break;
 355             case CURRENT_PRIMARYKEY:
 356                 aImage = m_aStatusImages.GetImage(IMG_EBB_CURRENT_PRIMARYKEY);
 357                 break;
 358             case FILTER:
 359                 aImage = m_aStatusImages.GetImage(IMG_EBB_FILTER);
 360                 break;
 361             case HEADERFOOTER:
 362                 aImage = m_aStatusImages.GetImage(IMG_EBB_HEADERFOOTER);
 363                 break;
 364             case CLEAN:
 365                 break;
 366         }
 367         if ( bNeedMirror )
 368         {
 369             BitmapEx aBitmap( aImage.GetBitmapEx() );
 370             aBitmap.Mirror( BMP_MIRROR_HORZ );
 371             aImage = Image( aBitmap );
 372         }
 373         return aImage;
 374     }
 375
 376     //------------------------------------------------------------------------------
 377     void EditBrowseBox::PaintStatusCell(OutputDevice& rDev, const Rectangle& rRect) const
 378     {
 379         if (nPaintRow < 0)
 380             return;
 381
 382         RowStatus eStatus = GetRowStatus( nPaintRow );
 383         sal_Int32 nBrowserFlags = GetBrowserFlags();
 384
 385         if (nBrowserFlags & EBBF_NO_HANDLE_COLUMN_CONTENT)
 386             return;
 387
 388         // draw the text of the header column
 389         if (nBrowserFlags & EBBF_HANDLE_COLUMN_TEXT )
 390         {
 391             rDev.DrawText( rRect, GetCellText( nPaintRow, 0 ),
 392                            TEXT_DRAW_CENTER | TEXT_DRAW_VCENTER | TEXT_DRAW_CLIP );
 393         }
 394         // draw an image
 395         else if (eStatus != CLEAN && rDev.GetOutDevType() == OUTDEV_WINDOW)
 396         {
 397             Image aImage(GetImage(eStatus));
 398             // calc the image position
 399             Size aImageSize(aImage.GetSizePixel());
 400             aImageSize.Width() = CalcZoom(aImageSize.Width());
 401             aImageSize.Height() = CalcZoom(aImageSize.Height());
 402             Point aPos( rRect.TopLeft() );
 403
 404             if ( ( aImageSize.Width() > rRect.GetWidth() ) || ( aImageSize.Height() > rRect.GetHeight() ) )
 405                 rDev.SetClipRegion(rRect);
 406
 407             if ( aImageSize.Width() < rRect.GetWidth() )
 408                 aPos.X() += ( rRect.GetWidth() - aImageSize.Width() ) / 2;
 409
 410             if ( aImageSize.Height() < rRect.GetHeight() )
 411                 aPos.Y() += ( rRect.GetHeight() - aImageSize.Height() ) / 2;
 412
 413             if ( IsZoom() )
 414                 rDev.DrawImage( aPos, aImageSize, aImage, 0 );
 415             else
 416                 rDev.DrawImage( aPos, aImage, 0 );
 417
 418             if (rDev.IsClipRegion())
 419                 rDev.SetClipRegion();
 420         }
 421     }
 422
 423     //------------------------------------------------------------------------------
 424     void EditBrowseBox::ImplStartTracking()
 425     {
 426         bActiveBeforeTracking = IsEditing();
 427         if ( bActiveBeforeTracking )
 428         {
 429             DeactivateCell();
 430             Update();
 431         }
 432
 433         BrowseBox::ImplStartTracking();
 434     }
 435
 436     //------------------------------------------------------------------------------
 437     void EditBrowseBox::ImplTracking()
 438     {
 439         BrowseBox::ImplTracking();
 440     }
 441
 442     //------------------------------------------------------------------------------
 443     void EditBrowseBox::ImplEndTracking()
 444     {
 445         if ( bActiveBeforeTracking )
 446             ActivateCell();
 447         bActiveBeforeTracking = sal_False;
 448
 449         BrowseBox::ImplEndTracking();
 450     }
 451
 452     //------------------------------------------------------------------------------
 453     void EditBrowseBox::RowHeightChanged()
 454     {
 455         if ( IsEditing() )
 456         {
 457             Rectangle aRect( GetCellRect( nEditRow, nEditCol, sal_False ) );
 458             CellControllerRef aCellController( Controller() );
 459             ResizeController( aCellController, aRect );
 460             aCellController->GetWindow().GrabFocus();
 461         }
 462
 463         BrowseBox::RowHeightChanged();
 464     }
 465
 466     //------------------------------------------------------------------------------
 467     EditBrowseBox::RowStatus EditBrowseBox::GetRowStatus(long) const
 468     {
 469         return CLEAN;
 470     }
 471
 472     //------------------------------------------------------------------------------
 473     void EditBrowseBox::KeyInput( const KeyEvent& rEvt )
 474     {
 475         sal_uInt16 nCode = rEvt.GetKeyCode().GetCode();
 476         sal_Bool   bShift = rEvt.GetKeyCode().IsShift();
 477         sal_Bool   bCtrl = rEvt.GetKeyCode().IsMod1();
 478
 479         switch (nCode)
 480         {
 481             case KEY_RETURN:
 482                 if (!bCtrl && !bShift && IsTabAllowed(sal_True))
 483                 {
 484                     Dispatch(BROWSER_CURSORRIGHT);
 485                 }
 486                 else
 487                     BrowseBox::KeyInput(rEvt);
 488                 return;
 489             case KEY_TAB:
 490                 if (!bCtrl && !bShift)
 491                 {
 492                     if (IsTabAllowed(sal_True))
 493                         Dispatch(BROWSER_CURSORRIGHT);
 494                     else
 495                         // do NOT call BrowseBox::KeyInput : this would handle the tab, but we already now
 496                         // that tab isn't allowed here. So give the Control class a chance
 497                         Control::KeyInput(rEvt);
 498                     return;
 499                 }
 500                 else if (!bCtrl && bShift)
 501                 {
 502                     if (IsTabAllowed(sal_False))
 503                         Dispatch(BROWSER_CURSORLEFT);
 504                     else
 505                         // do NOT call BrowseBox::KeyInput : this would handle the tab, but we already now
 506                         // that tab isn't allowed here. So give the Control class a chance
 507                         Control::KeyInput(rEvt);
 508                     return;
 509                 }
 510             default:
 511                 BrowseBox::KeyInput(rEvt);
 512         }
 513     }
 514
 515     //------------------------------------------------------------------------------
 516     void EditBrowseBox::MouseButtonDown(const BrowserMouseEvent& rEvt)
 517     {
 518         sal_uInt16  nColPos = GetColumnPos( rEvt.GetColumnId() );
 519         long    nRow    = rEvt.GetRow();
 520
 521         // absorb double clicks
 522         if (rEvt.GetClicks() > 1 && rEvt.GetRow() >= 0)
 523             return;
 524
 525         // change to a new position
 526         if (IsEditing() && (nColPos != nEditCol || nRow != nEditRow) && (nColPos != BROWSER_INVALIDID) && (nRow < GetRowCount()))
 527         {
 528             CellControllerRef aCellController(Controller());
 529             HideAndDisable(aCellController);
 530         }
 531
 532         // we are about to leave the current cell. If there is a "this cell has been modified" notification
 533         // pending (asynchronously), this may be deadly -> do it synchronously
 534         // 95826 - 2002-10-14 - fs@openoffice.org
 535         if ( nCellModifiedEvent )
 536         {
 537             Application::RemoveUserEvent( nCellModifiedEvent );
 538             nCellModifiedEvent = 0;
 539             LINK( this, EditBrowseBox, CellModifiedHdl ).Call( NULL );
 540         }
 541
 542         if (0 == rEvt.GetColumnId())
 543         {       // it was the handle column. save the current cell content if necessary
 544             // (clicking on the handle column results in selecting the current row)
 545             // 23.01.2001 - 82797 - FS
 546             if (IsEditing() && aController->IsModified())
 547                 SaveModified();
 548         }
 549
 550         aMouseEvent.Set(&rEvt,sal_True);
 551         BrowseBox::MouseButtonDown(rEvt);
 552         aMouseEvent.Clear();
 553
 554         if (0 != (m_nBrowserFlags & EBBF_ACTIVATE_ON_BUTTONDOWN))
 555         {
 556             // the base class does not travel upon MouseButtonDown, but implActivateCellOnMouseEvent assumes we traveled ...
 557             GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
 558             if (rEvt.GetRow() >= 0)
 559                 implActivateCellOnMouseEvent(rEvt, sal_False);
 560         }
 561     }
 562
 563     //------------------------------------------------------------------------------
 564     void EditBrowseBox::MouseButtonUp( const BrowserMouseEvent& rEvt )
 565     {
 566         // absorb double clicks
 567         if (rEvt.GetClicks() > 1 && rEvt.GetRow() >= 0)
 568             return;
 569
 570         aMouseEvent.Set(&rEvt,sal_False);
 571         BrowseBox::MouseButtonUp(rEvt);
 572         aMouseEvent.Clear();
 573
 574         if (0 == (m_nBrowserFlags & EBBF_ACTIVATE_ON_BUTTONDOWN))
 575             if (rEvt.GetRow() >= 0)
 576                 implActivateCellOnMouseEvent(rEvt, sal_True);
 577     }
 578
 579     //------------------------------------------------------------------------------
 580     void EditBrowseBox::implActivateCellOnMouseEvent(const BrowserMouseEvent& _rEvt, sal_Bool _bUp)
 581     {
 582         if (!IsEditing())
 583             ActivateCell();
 584         else if (IsEditing() && !aController->GetWindow().IsEnabled())
 585             DeactivateCell();
 586         else if (IsEditing() && !aController->GetWindow().HasChildPathFocus())
 587             AsynchGetFocus();
 588
 589         if (IsEditing() && aController->GetWindow().IsEnabled() && aController->WantMouseEvent())
 590         {       // forwards the event to the control
 591
 592             // If the field has been moved previously, we have to adjust the position
 593
 594             aController->GetWindow().GrabFocus();
 595
 596             // the position of the event relative to the controller's window
 597             Point aPos = _rEvt.GetPosPixel() - _rEvt.GetRect().TopLeft();
 598             // the (child) window which should really get the event
 599             Window* pRealHandler = aController->GetWindow().FindWindow(aPos);
 600             if (pRealHandler)
 601                 // the coords relative to this real handler
 602                 aPos -= pRealHandler->GetPosPixel();
 603             else
 604                 pRealHandler = &aController->GetWindow();
 605
 606             // the faked event
 607             MouseEvent aEvent(aPos, _rEvt.GetClicks(), _rEvt.GetMode(),
 608                               _rEvt.GetButtons(),
 609                               _rEvt.GetModifier());
 610
 611             pRealHandler->MouseButtonDown(aEvent);
 612             if (_bUp)
 613                 pRealHandler->MouseButtonUp(aEvent);
 614
 615             Window *pWin = &aController->GetWindow();
 616             if (!pWin->IsTracking())
 617             {
 618                 for (pWin = pWin->GetWindow(WINDOW_FIRSTCHILD);
 619                      pWin && !pWin->IsTracking();
 620                      pWin = pWin->GetWindow(WINDOW_NEXT))
 621                 {
 622                 }
 623             }
 624             if (pWin && pWin->IsTracking())
 625                 pWin->EndTracking();
 626         }
 627     }
 628
 629     //------------------------------------------------------------------------------
 630     void EditBrowseBox::Dispatch( sal_uInt16 _nId )
 631     {
 632         if ( _nId == BROWSER_ENHANCESELECTION )
 633         {       // this is a workaround for the bug in the base class:
 634             // if the row selection is to be extended (which is what BROWSER_ENHANCESELECTION tells us)
 635             // then the base class does not revert any column selections, while, for doing a "simple"
 636             // selection (BROWSER_SELECT), it does. In fact, it does not only revert the col selection then,
 637             // but also any current row selections.
 638             // This clearly tells me that the both ids are for row selection only - there this behaviour does
 639             // make sense.
 640             // But here, where we have column selection, too, we take care of this ourself.
 641             if ( GetSelectColumnCount( ) )
 642             {
 643                 while ( GetSelectColumnCount( ) )
 644                     SelectColumnPos(
 645                         sal::static_int_cast< USHORT >(FirstSelectedColumn()),
 646                         sal_False );
 647                 Select();
 648             }
 649         }
 650         BrowseBox::Dispatch( _nId );
 651     }
 652
 653     //------------------------------------------------------------------------------
 654     long EditBrowseBox::PreNotify(NotifyEvent& rEvt)
 655     {
 656         switch (rEvt.GetType())
 657         {
 658             case EVENT_KEYINPUT:
 659                 if      (       (IsEditing() && Controller()->GetWindow().HasChildPathFocus())
 660                     ||  rEvt.GetWindow() == &GetDataWindow()
 661                     ||  (!IsEditing() && HasChildPathFocus())
 662                     )
 663                 {
 664                     const KeyEvent* pKeyEvent = rEvt.GetKeyEvent();
 665                     sal_uInt16 nCode  = pKeyEvent->GetKeyCode().GetCode();
 666                     sal_Bool   bShift = pKeyEvent->GetKeyCode().IsShift();
 667                     sal_Bool   bCtrl  = pKeyEvent->GetKeyCode().IsMod1();
 668                     sal_Bool   bAlt =   pKeyEvent->GetKeyCode().IsMod2();
 669                     sal_Bool   bLocalSelect=    sal_False;
 670                     sal_Bool   bNonEditOnly =   sal_False;
 671                     sal_uInt16 nId = BROWSER_NONE;
 672
 673                     if (!bAlt && !bCtrl && !bShift )
 674                         switch ( nCode )
 675                         {
 676                             case KEY_DOWN:          nId = BROWSER_CURSORDOWN; break;
 677                             case KEY_UP:            nId = BROWSER_CURSORUP; break;
 678                             case KEY_PAGEDOWN:      nId = BROWSER_CURSORPAGEDOWN; break;
 679                             case KEY_PAGEUP:        nId = BROWSER_CURSORPAGEUP; break;
 680                             case KEY_HOME:          nId = BROWSER_CURSORHOME; break;
 681                             case KEY_END:           nId = BROWSER_CURSOREND; break;
 682
 683                             case KEY_TAB:
 684                                 // ask if traveling to the next cell is allowed
 685                                 if (IsTabAllowed(sal_True))
 686                                     nId = BROWSER_CURSORRIGHT;
 687                                 break;
 688
 689                             case KEY_RETURN:
 690                                 // save the cell content (if necessary)
 691                                 if (IsEditing() && aController->IsModified() && !((EditBrowseBox *) this)->SaveModified())
 692                                 {
 693                                     // maybe we're not visible ...
 694                                     EnableAndShow();
 695                                     aController->GetWindow().GrabFocus();
 696                                     return 1;
 697                                 }
 698                                 // ask if traveling to the next cell is allowed
 699                                 if (IsTabAllowed(sal_True))
 700                                     nId = BROWSER_CURSORRIGHT;
 701
 702                                 break;
 703                             case KEY_RIGHT:         nId = BROWSER_CURSORRIGHT; break;
 704                             case KEY_LEFT:          nId = BROWSER_CURSORLEFT; break;
 705                             case KEY_SPACE:         nId = BROWSER_SELECT; bNonEditOnly = bLocalSelect = sal_True;break;
 706                         }
 707
 708                     if ( !bAlt && !bCtrl && bShift )
 709                         switch ( nCode )
 710                         {
 711                             case KEY_DOWN:          nId = BROWSER_SELECTDOWN; bLocalSelect = sal_True;break;
 712                             case KEY_UP:            nId = BROWSER_SELECTUP; bLocalSelect = sal_True;break;
 713                             case KEY_HOME:          nId = BROWSER_SELECTHOME; bLocalSelect = sal_True;break;
 714                             case KEY_END:           nId = BROWSER_SELECTEND; bLocalSelect = sal_True;break;
 715                             case KEY_TAB:
 716                                 if (IsTabAllowed(sal_False))
 717                                     nId = BROWSER_CURSORLEFT;
 718                                 break;
 719                         }
 720
 721                     if ( !bAlt && bCtrl && bShift )
 722                         switch ( nCode )
 723                         {
 724                             case KEY_SPACE:                     nId = BROWSER_SELECTCOLUMN; bLocalSelect = sal_True; break;
 725                         }
 726
 727
 728                     if ( !bAlt && bCtrl && !bShift )
 729                         switch ( nCode )
 730                         {
 731                             case KEY_DOWN:          nId = BROWSER_SCROLLUP; break;
 732                             case KEY_UP:            nId = BROWSER_SCROLLDOWN; break;
 733                             case KEY_PAGEDOWN:      nId = BROWSER_CURSORENDOFFILE; break;
 734                             case KEY_PAGEUP:        nId = BROWSER_CURSORTOPOFFILE; break;
 735                             case KEY_HOME:          nId = BROWSER_CURSORTOPOFSCREEN; break;
 736                             case KEY_END:           nId = BROWSER_CURSORENDOFSCREEN; break;
 737                             case KEY_SPACE:         nId = BROWSER_ENHANCESELECTION; bLocalSelect = sal_True;break;
 738                         }
 739
 740
 741                     if  (       ( nId != BROWSER_NONE )
 742                         &&      (       !IsEditing()
 743                             ||  (       !bNonEditOnly
 744                                 &&      aController->MoveAllowed( *pKeyEvent )
 745                                 )
 746                             )
 747                         )
 748                     {
 749                         if (nId == BROWSER_SELECT || BROWSER_SELECTCOLUMN == nId )
 750                         {
 751                             // save the cell content (if necessary)
 752                             if (IsEditing() && aController->IsModified() && !((EditBrowseBox *) this)->SaveModified())
 753                             {
 754                                 // maybe we're not visible ...
 755                                 EnableAndShow();
 756                                 aController->GetWindow().GrabFocus();
 757                                 return 1;
 758                             }
 759                         }
 760
 761                         Dispatch(nId);
 762
 763                         if (bLocalSelect && (GetSelectRowCount() || GetSelection() != NULL))
 764                             DeactivateCell();
 765                         return 1;
 766                     }
 767                 }
 768         }
 769         return BrowseBox::PreNotify(rEvt);
 770     }
 771
 772     //------------------------------------------------------------------------------
 773     sal_Bool EditBrowseBox::IsTabAllowed(sal_Bool) const
 774     {
 775         return sal_True;
 776     }
 777
 778     //------------------------------------------------------------------------------
 779     long EditBrowseBox::Notify(NotifyEvent& rEvt)
 780     {
 781         switch (rEvt.GetType())
 782         {
 783             case EVENT_GETFOCUS:
 784                 DetermineFocus( getRealGetFocusFlags( this ) );
 785                 break;
 786
 787             case EVENT_LOSEFOCUS:
 788                 DetermineFocus( 0 );
 789                 break;
 790         }
 791         return BrowseBox::Notify(rEvt);
 792     }
 793
 794     //------------------------------------------------------------------------------
 795     void EditBrowseBox::StateChanged( StateChangedType nType )
 796     {
 797         BrowseBox::StateChanged( nType );
 798
 799         bool bNeedCellReActivation = false;
 800         if ( nType == STATE_CHANGE_MIRRORING )
 801         {
 802             bNeedCellReActivation = true;
 803         }
 804         else if ( nType == STATE_CHANGE_ZOOM )
 805         {
 806             ImplInitSettings( sal_True, sal_False, sal_False );
 807             bNeedCellReActivation = true;
 808         }
 809         else if ( nType == STATE_CHANGE_CONTROLFONT )
 810         {
 811             ImplInitSettings( sal_True, sal_False, sal_False );
 812             Invalidate();
 813         }
 814         else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 815         {
 816             ImplInitSettings( sal_False, sal_True, sal_False );
 817             Invalidate();
 818         }
 819         else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 820         {
 821             ImplInitSettings( sal_False, sal_False, sal_True );
 822             Invalidate();
 823         }
 824         else if (nType == STATE_CHANGE_STYLE)
 825         {
 826             WinBits nStyle = GetStyle();
 827             if (!(nStyle & WB_NOTABSTOP) )
 828                 nStyle |= WB_TABSTOP;
 829
 830             SetStyle(nStyle);
 831         }
 832         if ( bNeedCellReActivation )
 833         {
 834             if ( IsEditing() )
 835             {
 836                 DeactivateCell();
 837                 ActivateCell();
 838             }
 839         }
 840     }
 841
 842     //------------------------------------------------------------------------------
 843     void EditBrowseBox::DataChanged( const DataChangedEvent& rDCEvt )
 844     {
 845         BrowseBox::DataChanged( rDCEvt );
 846
 847         if ((( rDCEvt.GetType() == DATACHANGED_SETTINGS )       ||
 848             ( rDCEvt.GetType() == DATACHANGED_DISPLAY   ))      &&
 849             ( rDCEvt.GetFlags() & SETTINGS_STYLE                ))
 850         {
 851             ImplInitSettings( sal_True, sal_True, sal_True );
 852             Invalidate();
 853         }
 854     }
 855
 856     //------------------------------------------------------------------------------
 857     void EditBrowseBox::ImplInitSettings( sal_Bool bFont, sal_Bool bForeground, sal_Bool bBackground )
 858     {
 859         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 860
 861         if (bFont)
 862         {
 863             Font aFont = rStyleSettings.GetFieldFont();
 864             if (IsControlFont())
 865             {
 866                 GetDataWindow().SetControlFont(GetControlFont());
 867                 aFont.Merge(GetControlFont());
 868             }
 869             else
 870                 GetDataWindow().SetControlFont();
 871
 872             GetDataWindow().SetZoomedPointFont(aFont);
 873         }
 874
 875         if ( bFont || bForeground )
 876         {
 877             Color aTextColor = rStyleSettings.GetFieldTextColor();
 878             if (IsControlForeground())
 879             {
 880                 aTextColor = GetControlForeground();
 881                 GetDataWindow().SetControlForeground(aTextColor);
 882             }
 883             else
 884                 GetDataWindow().SetControlForeground();
 885
 886             GetDataWindow().SetTextColor( aTextColor );
 887         }
 888
 889         if ( bBackground )
 890         {
 891             if (GetDataWindow().IsControlBackground())
 892             {
 893                 GetDataWindow().SetControlBackground(GetControlBackground());
 894                 GetDataWindow().SetBackground(GetDataWindow().GetControlBackground());
 895                 GetDataWindow().SetFillColor(GetDataWindow().GetControlBackground());
 896             }
 897             else
 898             {
 899                 GetDataWindow().SetControlBackground();
 900                 GetDataWindow().SetBackground( rStyleSettings.GetFieldColor() );
 901                 GetDataWindow().SetFillColor( rStyleSettings.GetFieldColor() );
 902             }
 903         }
 904     }
 905
 906     //------------------------------------------------------------------------------
 907     sal_Bool EditBrowseBox::IsCursorMoveAllowed(long nNewRow, sal_uInt16 nNewColId) const
 908     {
 909         sal_uInt16 nInfo = 0;
 910
 911         if (GetSelectColumnCount() || (aMouseEvent.Is() && aMouseEvent->GetRow() < 0))
 912             nInfo |= COLSELECT;
 913         if ((GetSelection() != NULL && GetSelectRowCount()) ||
 914             (aMouseEvent.Is() && aMouseEvent->GetColumnId() == HANDLE_ID))
 915             nInfo |= ROWSELECT;
 916         if (!nInfo && nNewRow != nEditRow)
 917             nInfo |= ROWCHANGE;
 918         if (!nInfo && nNewColId != nEditCol)
 919             nInfo |= COLCHANGE;
 920
 921         if (nInfo == 0)   // nothing happened
 922             return sal_True;
 923
 924         // save the cell content
 925         if (IsEditing() && aController->IsModified() && !((EditBrowseBox *) this)->SaveModified())
 926         {
 927             // maybe we're not visible ...
 928             EnableAndShow();
 929             aController->GetWindow().GrabFocus();
 930             return sal_False;
 931         }
 932
 933         EditBrowseBox * pTHIS = (EditBrowseBox *) this;
 934
 935         // save the cell content if
 936         // a) a selection is beeing made
 937         // b) the row is changing
 938         if (IsModified() && (nInfo & (ROWCHANGE | COLSELECT | ROWSELECT)) &&
 939             !pTHIS->SaveRow())
 940         {
 941             if (nInfo & COLSELECT ||
 942                 nInfo & ROWSELECT)
 943             {
 944                 // cancel selected
 945                 pTHIS->SetNoSelection();
 946             }
 947
 948             if (IsEditing())
 949             {
 950                 if (!Controller()->GetWindow().IsVisible())
 951                 {
 952                     EnableAndShow();
 953                 }
 954                 aController->GetWindow().GrabFocus();
 955             }
 956             return sal_False;
 957         }
 958
 959         if (nNewRow != nEditRow)
 960         {
 961             Window& rWindow = GetDataWindow();
 962             // don't paint too much
 963             // update the status immediatly if possible
 964             if ((nEditRow >= 0) && (GetBrowserFlags() & EBBF_NO_HANDLE_COLUMN_CONTENT) == 0)
 965             {
 966                 Rectangle aRect = GetFieldRectPixel(nEditRow, 0, sal_False );
 967                 // status cell should be painted if and only if text is displayed
 968                 // note: bPaintStatus is mutable, but Solaris has problems with assigning
 969                 // probably because it is part of a bitfield
 970                 pTHIS->bPaintStatus = static_cast< sal_Bool >
 971                     (( GetBrowserFlags() & EBBF_HANDLE_COLUMN_TEXT ) == EBBF_HANDLE_COLUMN_TEXT );
 972                 rWindow.Paint(aRect);
 973                 pTHIS->bPaintStatus = sal_True;
 974             }
 975
 976             // don't paint during row change
 977             rWindow.EnablePaint(sal_False);
 978
 979             // the last veto chance for derived classes
 980             if (!pTHIS->CursorMoving(nNewRow, nNewColId))
 981             {
 982                 pTHIS->InvalidateStatusCell(nEditRow);
 983                 rWindow.EnablePaint(sal_True);
 984                 return sal_False;
 985             }
 986             else
 987             {
 988                 rWindow.EnablePaint(sal_True);
 989                 return sal_True;
 990             }
 991         }
 992         else
 993             return pTHIS->CursorMoving(nNewRow, nNewColId);
 994     }
 995
 996     //------------------------------------------------------------------------------
 997     void EditBrowseBox::ColumnMoved(sal_uInt16 nId)
 998     {
 999         BrowseBox::ColumnMoved(nId);
1000         if (IsEditing())
1001         {
1002             Rectangle aRect( GetCellRect(nEditRow, nEditCol, sal_False));
1003             CellControllerRef aControllerRef = Controller();
1004             ResizeController(aControllerRef, aRect);
1005             Controller()->GetWindow().GrabFocus();
1006         }
1007     }
1008
1009     //------------------------------------------------------------------------------
1010     sal_Bool EditBrowseBox::SaveRow()
1011     {
1012         return sal_True;
1013     }
1014
1015     //------------------------------------------------------------------------------
1016     sal_Bool EditBrowseBox::CursorMoving(long, sal_uInt16)
1017     {
1018         ((EditBrowseBox *) this)->DeactivateCell(sal_False);
1019         return sal_True;
1020     }
1021
1022     //------------------------------------------------------------------------------
1023     void EditBrowseBox::CursorMoved()
1024     {
1025         long nNewRow = GetCurRow();
1026         if (nEditRow != nNewRow)
1027         {
1028             if ((GetBrowserFlags() & EBBF_NO_HANDLE_COLUMN_CONTENT) == 0)
1029                 InvalidateStatusCell(nNewRow);
1030             nEditRow = nNewRow;
1031         }
1032         ActivateCell();
1033         GetDataWindow().EnablePaint(sal_True);
1034         // should not be called here because the descant event is not needed here
1035         //BrowseBox::CursorMoved();
1036     }
1037
1038     //------------------------------------------------------------------------------
1039     void EditBrowseBox::EndScroll()
1040     {
1041         if (IsEditing())
1042         {
1043             Rectangle aRect = GetCellRect(nEditRow, nEditCol, sal_False);
1044             ResizeController(aController,aRect);
1045             AsynchGetFocus();
1046         }
1047         BrowseBox::EndScroll();
1048     }
1049
1050     //------------------------------------------------------------------------------
1051     void EditBrowseBox::ActivateCell(long nRow, sal_uInt16 nCol, sal_Bool bCellFocus)
1052     {
1053         if (IsEditing())
1054             return;
1055
1056         nEditCol = nCol;
1057
1058         if ((GetSelectRowCount() && GetSelection() != NULL) || GetSelectColumnCount() ||
1059             (aMouseEvent.Is() && (aMouseEvent.IsDown() || aMouseEvent->GetClicks() > 1))) // bei MouseDown passiert noch nichts
1060         {
1061             return;
1062         }
1063
1064         if (nEditRow >= 0 && nEditCol > HANDLE_ID)
1065         {
1066             aController = GetController(nRow, nCol);
1067             if (aController.Is())
1068             {
1069                 Rectangle aRect( GetCellRect(nEditRow, nEditCol, sal_False));
1070                 ResizeController(aController, aRect);
1071
1072                 InitController(aController, nEditRow, nEditCol);
1073
1074                 aController->ClearModified();
1075                 aController->SetModifyHdl(LINK(this,EditBrowseBox,ModifyHdl));
1076                 EnableAndShow();
1077
1078                 if ( isAccessibleAlive() )
1079                     implCreateActiveAccessible();
1080
1081                 // activate the cell only of the browser has the focus
1082                 if ( bHasFocus && bCellFocus )
1083                     AsynchGetFocus();
1084             }
1085             else
1086             {
1087                 // no controller -> we have a new "active descendant"
1088                 if ( isAccessibleAlive() && HasFocus() )
1089                 {
1090                     commitTableEvent(
1091                         ACTIVE_DESCENDANT_CHANGED,
1092                         makeAny( CreateAccessibleCell( nRow, GetColumnPos( nCol ) ) ),
1093                         Any()
1094                     );
1095                 }
1096             }
1097         }
1098     }
1099
1100     //------------------------------------------------------------------------------
1101     void EditBrowseBox::DeactivateCell(sal_Bool bUpdate)
1102     {
1103         if (IsEditing())
1104         {
1105             if ( isAccessibleAlive() )
1106             {
1107                 commitBrowseBoxEvent( CHILD, Any(), makeAny( m_aImpl->m_xActiveCell ) );
1108                 m_aImpl->clearActiveCell();
1109             }
1110
1111             aOldController = aController;
1112             aController.Clear();
1113
1114             // reset the modify handler
1115             aOldController->SetModifyHdl(Link());
1116
1117             if (bHasFocus)
1118                 GrabFocus(); // ensure that we have (and keep) the focus
1119
1120             HideAndDisable(aOldController);
1121
1122             // update if requested
1123             if (bUpdate)
1124                 Update();
1125
1126             nOldEditCol = nEditCol;
1127             nOldEditRow = nEditRow;
1128
1129             // release the controller (asynchronously)
1130             if (nEndEvent)
1131                 Application::RemoveUserEvent(nEndEvent);
1132             nEndEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,EndEditHdl));
1133         }
1134     }
1135
1136     //------------------------------------------------------------------------------
1137     Rectangle EditBrowseBox::GetCellRect(long nRow, sal_uInt16 nColId, sal_Bool bRel) const
1138     {
1139         Rectangle aRect( GetFieldRectPixel(nRow, nColId, bRel));
1140         if ((GetMode()  & BROWSER_CURSOR_WO_FOCUS) == BROWSER_CURSOR_WO_FOCUS)
1141         {
1142             aRect.Top() += 1;
1143             aRect.Bottom() -= 1;
1144         }
1145         return aRect;
1146     }
1147
1148     //------------------------------------------------------------------------------
1149     IMPL_LINK(EditBrowseBox, EndEditHdl, void*, EMPTYARG)
1150     {
1151         nEndEvent = 0;
1152         ReleaseController(aOldController, nOldEditRow, nOldEditCol);
1153
1154         aOldController  = CellControllerRef();
1155         nOldEditRow             = -1;
1156         nOldEditCol             =  0;
1157
1158         return 0;
1159     }
1160
1161     //------------------------------------------------------------------------------
1162     IMPL_LINK(EditBrowseBox, ModifyHdl, void*, EMPTYARG)
1163     {
1164         if (nCellModifiedEvent)
1165             Application::RemoveUserEvent(nCellModifiedEvent);
1166         nCellModifiedEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,CellModifiedHdl));
1167         return 0;
1168     }
1169
1170     //------------------------------------------------------------------------------
1171     IMPL_LINK(EditBrowseBox, CellModifiedHdl, void*, EMPTYARG)
1172     {
1173         nCellModifiedEvent = 0;
1174         CellModified();
1175         return 0;
1176     }
1177
1178     //------------------------------------------------------------------------------
1179     void EditBrowseBox::ColumnResized( sal_uInt16 )
1180     {
1181         if (IsEditing())
1182         {
1183             Rectangle aRect( GetCellRect(nEditRow, nEditCol, sal_False));
1184             CellControllerRef aControllerRef = Controller();
1185             ResizeController(aControllerRef, aRect);
1186             Controller()->GetWindow().GrabFocus();
1187         }
1188     }
1189
1190     //------------------------------------------------------------------------------
1191     sal_uInt16 EditBrowseBox::AppendColumn(const String& rName, sal_uInt16 nWidth, sal_uInt16 nPos, sal_uInt16 nId)
1192     {
1193         if (nId == (sal_uInt16)-1)
1194         {
1195             // look for the next free id
1196             for (nId = ColCount(); nId > 0 && GetColumnPos(nId) != BROWSER_INVALIDID; nId--)
1197                 ;
1198
1199             if (!nId)
1200             {
1201                 // if there is no handle column
1202                 // increment the id
1203                 if (!ColCount() || GetColumnId(0))
1204                     nId = ColCount() + 1;
1205             }
1206         }
1207
1208         DBG_ASSERT(nId, "EditBrowseBox::AppendColumn: invalid id!");
1209
1210         long w = nWidth;
1211         if (!w)
1212             w = GetDefaultColumnWidth(rName);
1213
1214         InsertDataColumn(nId, rName, w, (HIB_CENTER | HIB_VCENTER | HIB_CLICKABLE), nPos);
1215         return nId;
1216     }
1217
1218     //------------------------------------------------------------------------------
1219     void EditBrowseBox::Resize()
1220     {
1221         BrowseBox::Resize();
1222
1223         // if the window is smaller than "title line height" + "control area",
1224         // do nothing
1225         if (GetOutputSizePixel().Height() <
1226            (GetControlArea().GetHeight() + GetDataWindow().GetPosPixel().Y()))
1227             return;
1228
1229         // the size of the control area
1230         Point aPoint(GetControlArea().TopLeft());
1231         sal_uInt16 nX = (sal_uInt16)aPoint.X();
1232
1233         ArrangeControls(nX, (sal_uInt16)aPoint.Y());
1234
1235         if (!nX)
1236             nX = USHRT_MAX;
1237         ReserveControlArea((sal_uInt16)nX);
1238     }
1239
1240     //------------------------------------------------------------------------------
1241     void EditBrowseBox::ArrangeControls(sal_uInt16&, sal_uInt16)
1242     {
1243     }
1244
1245     //------------------------------------------------------------------------------
1246     CellController* EditBrowseBox::GetController(long, sal_uInt16)
1247     {
1248         return NULL;
1249     }
1250
1251     //-----------------------------------------------------------------------------
1252     void EditBrowseBox::ResizeController(CellControllerRef& rController, const Rectangle& rRect)
1253     {
1254         rController->GetWindow().SetPosSizePixel(rRect.TopLeft(), rRect.GetSize());
1255     }
1256
1257     //------------------------------------------------------------------------------
1258     void EditBrowseBox::InitController(CellControllerRef&, long, sal_uInt16)
1259     {
1260     }
1261
1262     //------------------------------------------------------------------------------
1263     void EditBrowseBox::ReleaseController(CellControllerRef&, long, sal_uInt16)
1264     {
1265     }
1266
1267     //------------------------------------------------------------------------------
1268     void EditBrowseBox::CellModified()
1269     {
1270     }
1271
1272
1273     //------------------------------------------------------------------------------
1274     sal_Bool EditBrowseBox::SaveModified()
1275     {
1276         return sal_True;
1277     }
1278
1279     //------------------------------------------------------------------------------
1280     void EditBrowseBox::DoubleClick(const BrowserMouseEvent& rEvt)
1281     {
1282         // when double clicking on the column, the optimum size will be calculated
1283         sal_uInt16 nColId = rEvt.GetColumnId();
1284         if (nColId != HANDLE_ID)
1285             SetColumnWidth(nColId, GetAutoColumnWidth(nColId));
1286     }
1287
1288     //------------------------------------------------------------------------------
1289     sal_uInt32 EditBrowseBox::GetAutoColumnWidth(sal_uInt16 nColId)
1290     {
1291         sal_uInt32 nCurColWidth  = GetColumnWidth(nColId);
1292         sal_uInt32 nMinColWidth = CalcZoom(20); // minimum
1293         sal_uInt32 nNewColWidth = nMinColWidth;
1294         long nMaxRows      = Min(long(GetVisibleRows()), GetRowCount());
1295         long nLastVisRow   = GetTopRow() + nMaxRows - 1;
1296
1297         if (GetTopRow() <= nLastVisRow) // calc the column with using the cell contents
1298         {
1299             for (long i = GetTopRow(); i <= nLastVisRow; ++i)
1300                 nNewColWidth = std::max(nNewColWidth,GetTotalCellWidth(i,nColId) + 12);
1301
1302             if (nNewColWidth == nCurColWidth)   // size has not changed
1303                 nNewColWidth = GetDefaultColumnWidth(GetColumnTitle(nColId));
1304         }
1305         else
1306             nNewColWidth = GetDefaultColumnWidth(GetColumnTitle(nColId));
1307         return nNewColWidth;
1308     }
1309
1310     //------------------------------------------------------------------------------
1311     sal_uInt32 EditBrowseBox::GetTotalCellWidth(long, sal_uInt16)
1312     {
1313         return 0;
1314     }
1315
1316     //------------------------------------------------------------------------------
1317     void EditBrowseBox::InvalidateHandleColumn()
1318     {
1319         Rectangle aHdlFieldRect( GetFieldRectPixel( 0, 0 ));
1320         Rectangle aInvalidRect( Point(0,0), GetOutputSizePixel() );
1321         aInvalidRect.Right() = aHdlFieldRect.Right();
1322         Invalidate( aInvalidRect );
1323     }
1324
1325     //------------------------------------------------------------------------------
1326     void EditBrowseBox::PaintTristate(OutputDevice&, const Rectangle& rRect,const TriState& eState,sal_Bool _bEnabled) const
1327     {
1328         pCheckBoxPaint->GetBox().SetState(eState);
1329         pCheckBoxPaint->SetPosSizePixel(rRect.TopLeft(), rRect.GetSize());
1330
1331         // First update the parent, preventing that while painting this window
1332         // an update for the parent is done (because it's in the queue already)
1333         // which may lead to hiding this window immediately
1334 // #95598# comment out OJ
1335 /*              if (pCheckBoxPaint->GetParent())
1336             pCheckBoxPaint->GetParent()->Update();
1337 */
1338         pCheckBoxPaint->GetBox().Enable(_bEnabled);
1339         pCheckBoxPaint->Show();
1340         pCheckBoxPaint->SetParentUpdateMode( sal_False );
1341         pCheckBoxPaint->Update();
1342         pCheckBoxPaint->Hide();
1343         pCheckBoxPaint->SetParentUpdateMode( sal_True );
1344     }
1345
1346     //------------------------------------------------------------------------------
1347     void EditBrowseBox::AsynchGetFocus()
1348     {
1349         if (nStartEvent)
1350             Application::RemoveUserEvent(nStartEvent);
1351
1352         m_pFocusWhileRequest = Application::GetFocusWindow();
1353         nStartEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,StartEditHdl));
1354     }
1355
1356     //------------------------------------------------------------------------------
1357     void EditBrowseBox::SetBrowserFlags(sal_Int32 nFlags)
1358     {
1359         if (m_nBrowserFlags == nFlags)
1360             return;
1361
1362         sal_Bool RowPicturesChanges = ((m_nBrowserFlags & EBBF_NO_HANDLE_COLUMN_CONTENT) !=
1363                                        (nFlags & EBBF_NO_HANDLE_COLUMN_CONTENT));
1364         m_nBrowserFlags = nFlags;
1365
1366         if (RowPicturesChanges)
1367             InvalidateStatusCell(GetCurRow());
1368     }
1369     //------------------------------------------------------------------------------
1370     inline void EditBrowseBox::HideAndDisable(CellControllerRef& rController)
1371     {
1372         rController->suspend();
1373     }
1374     //------------------------------------------------------------------------------
1375     inline void EditBrowseBox::EnableAndShow() const
1376     {
1377         Controller()->resume();
1378     }
1379     //===============================================================================
1380
1381     DBG_NAME(CellController);
1382     //------------------------------------------------------------------------------
1383     CellController::CellController(Control* pW)
1384                    :pWindow( pW )
1385                    ,bSuspended( sal_True )
1386     {
1387         DBG_CTOR(CellController,NULL);
1388
1389         DBG_ASSERT(pWindow, "CellController::CellController: missing the window!");
1390         DBG_ASSERT(!pWindow->IsVisible(), "CellController::CellController: window should not be visible!");
1391     }
1392
1393     //-----------------------------------------------------------------------------
1394     CellController::~CellController()
1395     {
1396
1397         DBG_DTOR(CellController,NULL);
1398     }
1399
1400     //-----------------------------------------------------------------------------
1401     void CellController::suspend( )
1402     {
1403         DBG_ASSERT( bSuspended == !GetWindow().IsVisible(), "CellController::suspend: inconsistence!" );
1404         if ( !isSuspended( ) )
1405         {
1406             CommitModifications();
1407             GetWindow().Hide( );
1408             GetWindow().Disable( );
1409             bSuspended = sal_True;
1410         }
1411     }
1412
1413     //-----------------------------------------------------------------------------
1414     void CellController::resume( )
1415     {
1416         DBG_ASSERT( bSuspended == !GetWindow().IsVisible(), "CellController::resume: inconsistence!" );
1417         if ( isSuspended( ) )
1418         {
1419             GetWindow().Enable( );
1420             GetWindow().Show( );
1421             bSuspended = sal_False;
1422         }
1423     }
1424
1425     //-----------------------------------------------------------------------------
1426     void CellController::CommitModifications()
1427     {
1428         // nothing to do in this base class
1429     }
1430
1431     //-----------------------------------------------------------------------------
1432     sal_Bool CellController::WantMouseEvent() const
1433     {
1434         return sal_False;
1435     }
1436
1437     //-----------------------------------------------------------------------------
1438     void CellController::SetModified()
1439     {
1440     }
1441
1442     //-----------------------------------------------------------------------------
1443     sal_Bool CellController::MoveAllowed(const KeyEvent&) const
1444     {
1445         return sal_True;
1446     }
1447 // .......................................................................
1448 }       // namespace svt
1449 // .......................................................................
1450