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