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