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