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