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