?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 4.3-4
[LibreOffice.git] / sc / source / ui / app / inputwin.cxx
blobc547a9eafb6ae5c759c8170db7a4941e0cc6ef78
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
21 #include <algorithm>
22
23 #include "scitems.hxx"
24 #include <editeng/eeitem.hxx>
25
26 #include <sfx2/app.hxx>
27 #include <editeng/adjustitem.hxx>
28 #include <editeng/editview.hxx>
29 #include <editeng/editstat.hxx>
30 #include <editeng/frmdiritem.hxx>
31 #include <editeng/lspcitem.hxx>
32 #include <sfx2/bindings.hxx>
33 #include <sfx2/viewfrm.hxx>
34 #include <sfx2/dispatch.hxx>
35 #include <sfx2/event.hxx>
36 #include <sfx2/imgmgr.hxx>
37 #include <stdlib.h>
38 #include <editeng/scriptspaceitem.hxx>
39 #include <editeng/scripttypeitem.hxx>
40 #include <vcl/cursor.hxx>
41 #include <vcl/help.hxx>
42 #include <vcl/settings.hxx>
43 #include <svl/stritem.hxx>
44 #include <stdio.h>
45
46 #include "inputwin.hxx"
47 #include "scmod.hxx"
48 #include "uiitems.hxx"
49 #include "global.hxx"
50 #include "scresid.hxx"
51 #include "sc.hrc"
52 #include "globstr.hrc"
53 #include "reffact.hxx"
54 #include "editutil.hxx"
55 #include "inputhdl.hxx"
56 #include "tabvwsh.hxx"
57 #include "document.hxx"
58 #include "docsh.hxx"
59 #include "appoptio.hxx"
60 #include "rangenam.hxx"
61 #include <formula/compiler.hrc>
62 #include "dbdata.hxx"
63 #include "rangeutl.hxx"
64 #include "docfunc.hxx"
65 #include "funcdesc.hxx"
66 #include "markdata.hxx"
67 #include <editeng/fontitem.hxx>
68 #include <com/sun/star/accessibility/XAccessible.hpp>
69 #include "AccessibleEditObject.hxx"
70 #include "AccessibleText.hxx"
71 #include <svtools/miscopt.hxx>
72 #include <comphelper/string.hxx>
73 #include <com/sun/star/frame/XLayoutManager.hpp>
74 #include <com/sun/star/frame/XModel.hpp>
75 #include <com/sun/star/frame/XController.hpp>
76
77 #define THESIZE 1000000 //!!! langt... :-)
78 #define TBX_WINDOW_HEIGHT 22 // in Pixeln - fuer alle Systeme gleich?
79 #define LEFT_OFFSET 5
80 #define INPUTWIN_MULTILINES 6
81 const long BUTTON_OFFSET = 2; ///< space between input line and the button to expand / collapse
82 const long ADDITIONAL_BORDER = 1; ///< height of the line at the bottom
83 const long ADDITIONAL_SPACE = 4; ///< additional vertical space when the multiline edit has more lines
84
85 using com::sun::star::uno::Reference;
86 using com::sun::star::uno::UNO_QUERY;
87
88 using com::sun::star::frame::XLayoutManager;
89 using com::sun::star::frame::XModel;
90 using com::sun::star::frame::XFrame;
91 using com::sun::star::frame::XController;
92 using com::sun::star::beans::XPropertySet;
93
94
95 enum ScNameInputType
96 {
97 SC_NAME_INPUT_CELL,
98 SC_NAME_INPUT_RANGE,
99 SC_NAME_INPUT_NAMEDRANGE,
100 SC_NAME_INPUT_DATABASE,
101 SC_NAME_INPUT_ROW,
102 SC_NAME_INPUT_SHEET,
103 SC_NAME_INPUT_DEFINE,
104 SC_NAME_INPUT_BAD_NAME,
105 SC_NAME_INPUT_BAD_SELECTION,
106 SC_MANAGE_NAMES
107 };
108
109
110 ScTextWndBase::ScTextWndBase( Window* pParent, WinBits nStyle )
111 : Window ( pParent, nStyle )
112 {
113 if ( IsNativeControlSupported( CTRL_EDITBOX, PART_ENTIRE_CONTROL ) )
114 {
115 SetType( WINDOW_CALCINPUTLINE );
116 SetBorderStyle( WINDOW_BORDER_NWF );
117 }
118 }
119
120
121 // class ScInputWindowWrapper
122
123
124 SFX_IMPL_CHILDWINDOW_WITHID(ScInputWindowWrapper,FID_INPUTLINE_STATUS)
125
126 ScInputWindowWrapper::ScInputWindowWrapper( Window* pParentP,
127 sal_uInt16 nId,
128 SfxBindings* pBindings,
129 SfxChildWinInfo* /* pInfo */ )
130 : SfxChildWindow( pParentP, nId )
131 {
132 ScInputWindow* pWin=new ScInputWindow( pParentP, pBindings );
133 pWindow = pWin;
134
135 pWin->Show();
136
137 pWin->SetSizePixel( pWin->CalcWindowSizePixel() );
138
139 eChildAlignment = SFX_ALIGN_LOWESTTOP;
140 pBindings->Invalidate( FID_TOGGLEINPUTLINE );
141 }
142
143 // GetInfo fliegt wieder raus, wenn es ein SFX_IMPL_TOOLBOX gibt !!!!
144
145 SfxChildWinInfo ScInputWindowWrapper::GetInfo() const
146 {
147 SfxChildWinInfo aInfo = SfxChildWindow::GetInfo();
148 return aInfo;
149 }
150
151 #define IMAGE(id) pImgMgr->SeekImage(id)
152 static bool lcl_isExperimentalMode()
153 {
154 // make inputbar feature on by default, leave the switch for the
155 // moment in case we need to back it out easily
156 return true;
157 }
158
159
160 // class ScInputWindow
161
162
163 static ScTextWndBase* lcl_chooseRuntimeImpl( Window* pParent, SfxBindings* pBind )
164 {
165 ScTabViewShell* pViewSh = NULL;
166 SfxDispatcher* pDisp = pBind->GetDispatcher();
167 if ( pDisp )
168 {
169 SfxViewFrame* pViewFrm = pDisp->GetFrame();
170 if ( pViewFrm )
171 pViewSh = PTR_CAST( ScTabViewShell, pViewFrm->GetViewShell() );
172 }
173
174 if ( !lcl_isExperimentalMode() )
175 return new ScTextWnd( pParent, pViewSh );
176 return new ScInputBarGroup( pParent, pViewSh );
177 }
178
179 ScInputWindow::ScInputWindow( Window* pParent, SfxBindings* pBind ) :
180 // mit WB_CLIPCHILDREN, sonst Flicker
181 ToolBox ( pParent, WinBits(WB_CLIPCHILDREN) ),
182 aWndPos ( this ),
183 pRuntimeWindow ( lcl_chooseRuntimeImpl( this, pBind ) ),
184 aTextWindow ( *pRuntimeWindow ),
185 pInputHdl ( NULL ),
186 aTextOk ( ScResId( SCSTR_QHELP_BTNOK ) ), // nicht immer neu aus Resource
187 aTextCancel ( ScResId( SCSTR_QHELP_BTNCANCEL ) ),
188 aTextSum ( ScResId( SCSTR_QHELP_BTNSUM ) ),
189 aTextEqual ( ScResId( SCSTR_QHELP_BTNEQUAL ) ),
190 mnMaxY (0),
191 bIsOkCancelMode ( false ),
192 bInResize ( false ),
193 mbIsMultiLine ( lcl_isExperimentalMode() )
194 {
195 ScModule* pScMod = SC_MOD();
196 SfxImageManager* pImgMgr = SfxImageManager::GetImageManager( pScMod );
197
198 // #i73615# don't rely on SfxViewShell::Current while constructing the input line
199 // (also for GetInputHdl below)
200 ScTabViewShell* pViewSh = NULL;
201 SfxDispatcher* pDisp = pBind->GetDispatcher();
202 if ( pDisp )
203 {
204 SfxViewFrame* pViewFrm = pDisp->GetFrame();
205 if ( pViewFrm )
206 pViewSh = PTR_CAST( ScTabViewShell, pViewFrm->GetViewShell() );
207 }
208 OSL_ENSURE( pViewSh, "no view shell for input window" );
209
210 // Position window, 3 buttons, input window
211 InsertWindow ( 1, &aWndPos, 0, 0 );
212 InsertSeparator ( 1 );
213 InsertItem ( SID_INPUT_FUNCTION, IMAGE( SID_INPUT_FUNCTION ), 0, 2 );
214 InsertItem ( SID_INPUT_SUM, IMAGE( SID_INPUT_SUM ), 0, 3 );
215 InsertItem ( SID_INPUT_EQUAL, IMAGE( SID_INPUT_EQUAL ), 0, 4 );
216 InsertSeparator ( 5 );
217 InsertWindow ( 7, &aTextWindow, 0, 6 );
218
219 aWndPos .SetQuickHelpText( ScResId( SCSTR_QHELP_POSWND ) );
220 aWndPos .SetHelpId ( HID_INSWIN_POS );
221 aTextWindow.SetQuickHelpText( ScResId( SCSTR_QHELP_INPUTWND ) );
222 aTextWindow.SetHelpId ( HID_INSWIN_INPUT );
223
224 // kein SetHelpText, die Hilfetexte kommen aus der Hilfe
225
226 SetItemText ( SID_INPUT_FUNCTION, ScResId( SCSTR_QHELP_BTNCALC ) );
227 SetHelpId ( SID_INPUT_FUNCTION, HID_INSWIN_CALC );
228
229 SetItemText ( SID_INPUT_SUM, aTextSum );
230 SetHelpId ( SID_INPUT_SUM, HID_INSWIN_SUMME );
231
232 SetItemText ( SID_INPUT_EQUAL, aTextEqual );
233 SetHelpId ( SID_INPUT_EQUAL, HID_INSWIN_FUNC );
234
235 SetHelpId( HID_SC_INPUTWIN ); // fuer die ganze Eingabezeile
236
237 aWndPos .Show();
238 aTextWindow.Show();
239
240 pInputHdl = SC_MOD()->GetInputHdl( pViewSh, false ); // use own handler even if ref-handler is set
241 if (pInputHdl)
242 pInputHdl->SetInputWindow( this );
243
244 if (pInputHdl && !pInputHdl->GetFormString().isEmpty())
245 {
246 // Umschalten waehrend der Funktionsautopilot aktiv ist
247 // -> Inhalt des Funktionsautopiloten wieder anzeigen
248 //! auch Selektion (am InputHdl gemerkt) wieder anzeigen
249
250 aTextWindow.SetTextString( pInputHdl->GetFormString() );
251 }
252 else if ( pInputHdl && pInputHdl->IsInputMode() )
253 {
254 // wenn waehrend des Editierens die Eingabezeile weg war
255 // (Editieren einer Formel, dann umschalten zu fremdem Dokument/Hilfe),
256 // wieder den gerade editierten Text aus dem InputHandler anzeigen
257
258 aTextWindow.SetTextString( pInputHdl->GetEditString() ); // Text anzeigen
259 if ( pInputHdl->IsTopMode() )
260 pInputHdl->SetMode( SC_INPUT_TABLE ); // Focus kommt eh nach unten
261 }
262 else if ( pViewSh )
263 pViewSh->UpdateInputHandler( true ); // unbedingtes Update
264
265 pImgMgr->RegisterToolBox( this );
266 SetAccessibleName(ScResId(STR_ACC_TOOLBAR_FORMULA));
267 }
268
269 ScInputWindow::~ScInputWindow()
270 {
271 bool bDown = ( ScGlobal::pSysLocale == NULL ); // after Clear?
272
273 // if any view's input handler has a pointer to this input window, reset it
274 // (may be several ones, #74522#)
275 // member pInputHdl is not used here
276
277 if ( !bDown )
278 {
279 TypeId aScType = TYPE(ScTabViewShell);
280 SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
281 while ( pSh )
282 {
283 ScInputHandler* pHdl = ((ScTabViewShell*)pSh)->GetInputHandler();
284 if ( pHdl && pHdl->GetInputWindow() == this )
285 {
286 pHdl->SetInputWindow( NULL );
287 pHdl->StopInputWinEngine( false ); // reset pTopView pointer
288 }
289 pSh = SfxViewShell::GetNext( *pSh, &aScType );
290 }
291 }
292
293 SfxImageManager::GetImageManager( SC_MOD() )->ReleaseToolBox( this );
294 }
295
296 void ScInputWindow::SetInputHandler( ScInputHandler* pNew )
297 {
298 // wird im Activate der View gerufen...
299
300 if ( pNew != pInputHdl )
301 {
302 // Bei Reload (letzte Version) ist pInputHdl der Input-Handler der alten,
303 // geloeschten ViewShell, darum hier auf keinen Fall anfassen!
304
305 pInputHdl = pNew;
306 if (pInputHdl)
307 pInputHdl->SetInputWindow( this );
308 }
309 }
310
311 bool ScInputWindow::UseSubTotal(ScRangeList* pRangeList) const
312 {
313 bool bSubTotal = false;
314 ScTabViewShell* pViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
315 if ( pViewSh )
316 {
317 ScDocument* pDoc = pViewSh->GetViewData()->GetDocument();
318 size_t nRangeCount (pRangeList->size());
319 size_t nRangeIndex (0);
320 while (!bSubTotal && nRangeIndex < nRangeCount)
321 {
322 const ScRange* pRange = (*pRangeList)[nRangeIndex];
323 if( pRange )
324 {
325 SCTAB nTabEnd(pRange->aEnd.Tab());
326 SCTAB nTab(pRange->aStart.Tab());
327 while (!bSubTotal && nTab <= nTabEnd)
328 {
329 SCROW nRowEnd(pRange->aEnd.Row());
330 SCROW nRow(pRange->aStart.Row());
331 while (!bSubTotal && nRow <= nRowEnd)
332 {
333 if (pDoc->RowFiltered(nRow, nTab))
334 bSubTotal = true;
335 else
336 ++nRow;
337 }
338 ++nTab;
339 }
340 }
341 ++nRangeIndex;
342 }
343
344 const ScDBCollection::NamedDBs& rDBs = pDoc->GetDBCollection()->getNamedDBs();
345 ScDBCollection::NamedDBs::const_iterator itr = rDBs.begin(), itrEnd = rDBs.end();
346 for (; !bSubTotal && itr != itrEnd; ++itr)
347 {
348 const ScDBData& rDB = *itr;
349 if (!rDB.HasAutoFilter())
350 continue;
351
352 nRangeIndex = 0;
353 while (!bSubTotal && nRangeIndex < nRangeCount)
354 {
355 const ScRange* pRange = (*pRangeList)[nRangeIndex];
356 if( pRange )
357 {
358 ScRange aDBArea;
359 rDB.GetArea(aDBArea);
360 if (aDBArea.Intersects(*pRange))
361 bSubTotal = true;
362 }
363 ++nRangeIndex;
364 }
365 }
366 }
367 return bSubTotal;
368 }
369
370 void ScInputWindow::Select()
371 {
372 ScModule* pScMod = SC_MOD();
373 ToolBox::Select();
374
375 switch ( GetCurItemId() )
376 {
377 case SID_INPUT_FUNCTION:
378 {
379 //! new method at ScModule to query if function autopilot is open
380 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
381 if ( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) )
382 {
383 pViewFrm->GetDispatcher()->Execute( SID_OPENDLG_FUNCTION,
384 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD );
385
386 // die Toolbox wird sowieso disabled, also braucht auch nicht umgeschaltet
387 // zu werden, egal ob's geklappt hat oder nicht
388 // SetOkCancelMode();
389 }
390 }
391 break;
392
393 case SID_INPUT_CANCEL:
394 pScMod->InputCancelHandler();
395 SetSumAssignMode();
396 break;
397
398 case SID_INPUT_OK:
399 pScMod->InputEnterHandler();
400 SetSumAssignMode();
401 aTextWindow.Invalidate(); // sonst bleibt Selektion stehen
402 break;
403
404 case SID_INPUT_SUM:
405 {
406 ScTabViewShell* pViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
407 if ( pViewSh )
408 {
409 const ScMarkData& rMark = pViewSh->GetViewData()->GetMarkData();
410 if ( rMark.IsMarked() || rMark.IsMultiMarked() )
411 {
412 ScRangeList aMarkRangeList;
413 rMark.FillRangeListWithMarks( &aMarkRangeList, false );
414 ScDocument* pDoc = pViewSh->GetViewData()->GetDocument();
415
416 // check if one of the marked ranges is empty
417 bool bEmpty = false;
418 const size_t nCount = aMarkRangeList.size();
419 for ( size_t i = 0; i < nCount; ++i )
420 {
421 const ScRange aRange( *aMarkRangeList[i] );
422 if ( pDoc->IsBlockEmpty( aRange.aStart.Tab(),
423 aRange.aStart.Col(), aRange.aStart.Row(),
424 aRange.aEnd.Col(), aRange.aEnd.Row() ) )
425 {
426 bEmpty = true;
427 break;
428 }
429 }
430
431 if ( bEmpty )
432 {
433 ScRangeList aRangeList;
434 const bool bDataFound = pViewSh->GetAutoSumArea( aRangeList );
435 if ( bDataFound )
436 {
437 ScAddress aAddr = aRangeList.back()->aEnd;
438 aAddr.IncRow();
439 const bool bSubTotal( UseSubTotal( &aRangeList ) );
440 pViewSh->EnterAutoSum( aRangeList, bSubTotal, aAddr );
441 }
442 }
443 else
444 {
445 const bool bSubTotal( UseSubTotal( &aMarkRangeList ) );
446 for ( size_t i = 0; i < nCount; ++i )
447 {
448 const ScRange aRange( *aMarkRangeList[i] );
449 const bool bSetCursor = ( i == nCount - 1 );
450 const bool bContinue = ( i != 0 );
451 if ( !pViewSh->AutoSum( aRange, bSubTotal, bSetCursor, bContinue ) )
452 {
453 pViewSh->MarkRange( aRange, false, false );
454 pViewSh->SetCursor( aRange.aEnd.Col(), aRange.aEnd.Row() );
455 const ScRangeList aRangeList;
456 ScAddress aAddr = aRange.aEnd;
457 aAddr.IncRow();
458 const OUString aFormula = pViewSh->GetAutoSumFormula(
459 aRangeList, bSubTotal, aAddr );
460 SetFuncString( aFormula );
461 break;
462 }
463 }
464 }
465 }
466 else // nur in Eingabezeile einfuegen
467 {
468 ScRangeList aRangeList;
469 const bool bDataFound = pViewSh->GetAutoSumArea( aRangeList );
470 const bool bSubTotal( UseSubTotal( &aRangeList ) );
471 ScAddress aAddr = pViewSh->GetViewData()->GetCurPos();
472 const OUString aFormula = pViewSh->GetAutoSumFormula( aRangeList, bSubTotal, aAddr );
473 SetFuncString( aFormula );
474
475 if ( bDataFound && pScMod->IsEditMode() )
476 {
477 ScInputHandler* pHdl = pScMod->GetInputHdl( pViewSh );
478 if ( pHdl )
479 {
480 pHdl->InitRangeFinder( aFormula );
481
482 //! SetSelection am InputHandler ???
483 //! bSelIsRef setzen ???
484 const sal_Int32 nOpen = aFormula.indexOf('(');
485 const sal_Int32 nLen = aFormula.getLength();
486 if ( nOpen != -1 && nLen > nOpen )
487 {
488 sal_uInt8 nAdd(1);
489 if (bSubTotal)
490 nAdd = 3;
491 ESelection aSel(0,nOpen+nAdd,0,nLen-1);
492 EditView* pTableView = pHdl->GetTableView();
493 if (pTableView)
494 pTableView->SetSelection(aSel);
495 EditView* pTopView = pHdl->GetTopView();
496 if (pTopView)
497 pTopView->SetSelection(aSel);
498 }
499 }
500 }
501 }
502 }
503 }
504 break;
505
506 case SID_INPUT_EQUAL:
507 {
508 aTextWindow.StartEditEngine();
509 if ( pScMod->IsEditMode() ) // nicht, wenn z.B. geschuetzt
510 {
511 aTextWindow.StartEditEngine();
512
513 sal_Int32 nStartPos = 1;
514 sal_Int32 nEndPos = 1;
515
516 ScTabViewShell* pViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
517 if ( pViewSh )
518 {
519 const OUString& rString = aTextWindow.GetTextString();
520 const sal_Int32 nLen = rString.getLength();
521
522 ScDocument* pDoc = pViewSh->GetViewData()->GetDocument();
523 CellType eCellType = pDoc->GetCellType( pViewSh->GetViewData()->GetCurPos() );
524 switch ( eCellType )
525 {
526 case CELLTYPE_VALUE:
527 {
528 nEndPos = nLen + 1;
529 aTextWindow.SetTextString("=" + rString);
530 break;
531 }
532 case CELLTYPE_STRING:
533 case CELLTYPE_EDIT:
534 nStartPos = 0;
535 nEndPos = nLen;
536 break;
537 case CELLTYPE_FORMULA:
538 nEndPos = nLen;
539 break;
540 default:
541 aTextWindow.SetTextString("=");
542 break;
543 }
544 }
545
546 EditView* pView = aTextWindow.GetEditView();
547 if (pView)
548 {
549 pView->SetSelection( ESelection(0, nStartPos, 0, nEndPos) );
550 pScMod->InputChanged(pView);
551 SetOkCancelMode();
552 pView->SetEditEngineUpdateMode(true);
553 }
554 }
555 break;
556 }
557 }
558 }
559
560 void ScInputWindow::Paint( const Rectangle& rRect )
561 {
562 ToolBox::Paint( rRect );
563
564 // draw a line at the bottom to distinguish that from the grid
565 // (we have space for that thanks to ADDITIONAL_BORDER)
566 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
567 SetLineColor( rStyleSettings.GetShadowColor() );
568
569 Size aSize = GetSizePixel();
570 DrawLine( Point( 0, aSize.Height() - 1 ), Point( aSize.Width() - 1, aSize.Height() - 1 ) );
571 }
572
573 void ScInputWindow::Resize()
574 {
575 ToolBox::Resize();
576 if ( mbIsMultiLine )
577 {
578 aTextWindow.Resize();
579 Size aSize = GetSizePixel();
580 aSize.Height() = CalcWindowSizePixel().Height() + ADDITIONAL_BORDER;
581 ScInputBarGroup* pGroupBar = dynamic_cast< ScInputBarGroup* > ( pRuntimeWindow.get() );
582 if ( pGroupBar )
583 {
584 // To ensure smooth display and prevent the items in the toolbar being
585 // repositioned ( vertically ) we lock the vertical positioning of the toolbox
586 // items when we are displaying > 1 line.
587 // So, we need to adjust the height of the toolbox accordingly. If we don't
588 // then the largest item ( e.g. the GroupBar window ) will actually be
589 // positioned such that the toolbar will cut off the bottom of that item
590 if ( pGroupBar->GetNumLines() > 1 )
591 aSize.Height() += pGroupBar->GetVertOffset() + ADDITIONAL_SPACE;
592 }
593 SetSizePixel(aSize);
594 Invalidate();
595 }
596 else
597 {
598 long nWidth = GetSizePixel().Width();
599 long nLeft = aTextWindow.GetPosPixel().X();
600 Size aSize = aTextWindow.GetSizePixel();
601
602 aSize.Width() = std::max( ((long)(nWidth - nLeft - 5)), (long)0 );
603
604 aTextWindow.SetSizePixel( aSize );
605 aTextWindow.Invalidate();
606 }
607 }
608
609 void ScInputWindow::SetFuncString( const OUString& rString, bool bDoEdit )
610 {
611 //! new method at ScModule to query if function autopilot is open
612 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
613 EnableButtons( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) );
614 aTextWindow.StartEditEngine();
615
616 ScModule* pScMod = SC_MOD();
617 if ( pScMod->IsEditMode() )
618 {
619 if ( bDoEdit )
620 aTextWindow.GrabFocus();
621 aTextWindow.SetTextString( rString );
622 EditView* pView = aTextWindow.GetEditView();
623 if (pView)
624 {
625 sal_Int32 nLen = rString.getLength();
626
627 if ( nLen > 0 )
628 {
629 nLen--;
630 pView->SetSelection( ESelection( 0, nLen, 0, nLen ) );
631 }
632
633 pScMod->InputChanged(pView);
634 if ( bDoEdit )
635 SetOkCancelMode(); // nicht, wenn gleich hinterher Enter/Cancel
636
637 pView->SetEditEngineUpdateMode(true);
638 }
639 }
640 }
641
642 void ScInputWindow::SetPosString( const OUString& rStr )
643 {
644 aWndPos.SetPos( rStr );
645 }
646
647 void ScInputWindow::SetTextString( const OUString& rString )
648 {
649 if (rString.getLength() <= 32767)
650 aTextWindow.SetTextString(rString);
651 else
652 aTextWindow.SetTextString(rString.copy(0, 32767));
653 }
654
655 void ScInputWindow::SetOkCancelMode()
656 {
657 //! new method at ScModule to query if function autopilot is open
658 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
659 EnableButtons( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) );
660
661 ScModule* pScMod = SC_MOD();
662 SfxImageManager* pImgMgr = SfxImageManager::GetImageManager( pScMod );
663 if (!bIsOkCancelMode)
664 {
665 RemoveItem( 3 ); // SID_INPUT_SUM und SID_INPUT_EQUAL entfernen
666 RemoveItem( 3 );
667 InsertItem( SID_INPUT_CANCEL, IMAGE( SID_INPUT_CANCEL ), 0, 3 );
668 InsertItem( SID_INPUT_OK, IMAGE( SID_INPUT_OK ), 0, 4 );
669 SetItemText ( SID_INPUT_CANCEL, aTextCancel );
670 SetHelpId ( SID_INPUT_CANCEL, HID_INSWIN_CANCEL );
671 SetItemText ( SID_INPUT_OK, aTextOk );
672 SetHelpId ( SID_INPUT_OK, HID_INSWIN_OK );
673 bIsOkCancelMode = true;
674 }
675 }
676
677 void ScInputWindow::SetSumAssignMode()
678 {
679 //! new method at ScModule to query if function autopilot is open
680 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
681 EnableButtons( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) );
682
683 ScModule* pScMod = SC_MOD();
684 SfxImageManager* pImgMgr = SfxImageManager::GetImageManager( pScMod );
685 if (bIsOkCancelMode)
686 {
687 // SID_INPUT_CANCEL, und SID_INPUT_OK entfernen
688 RemoveItem( 3 );
689 RemoveItem( 3 );
690 InsertItem( SID_INPUT_SUM, IMAGE( SID_INPUT_SUM ), 0, 3 );
691 InsertItem( SID_INPUT_EQUAL, IMAGE( SID_INPUT_EQUAL ), 0, 4 );
692 SetItemText ( SID_INPUT_SUM, aTextSum );
693 SetHelpId ( SID_INPUT_SUM, HID_INSWIN_SUMME );
694 SetItemText ( SID_INPUT_EQUAL, aTextEqual );
695 SetHelpId ( SID_INPUT_EQUAL, HID_INSWIN_FUNC );
696 bIsOkCancelMode = false;
697
698 SetFormulaMode(false); // kein editieren -> keine Formel
699 }
700 }
701
702 void ScInputWindow::SetFormulaMode( bool bSet )
703 {
704 aWndPos.SetFormulaMode(bSet);
705 aTextWindow.SetFormulaMode(bSet);
706 }
707
708 void ScInputWindow::SetText( const OUString& rString )
709 {
710 ToolBox::SetText(rString);
711 }
712
713 OUString ScInputWindow::GetText() const
714 {
715 return ToolBox::GetText();
716 }
717
718 bool ScInputWindow::IsInputActive()
719 {
720 return aTextWindow.IsInputActive();
721 }
722
723 EditView* ScInputWindow::GetEditView()
724 {
725 return aTextWindow.GetEditView();
726 }
727
728 void ScInputWindow::MakeDialogEditView()
729 {
730 aTextWindow.MakeDialogEditView();
731 }
732
733 void ScInputWindow::StopEditEngine( bool bAll )
734 {
735 aTextWindow.StopEditEngine( bAll );
736 }
737
738 void ScInputWindow::TextGrabFocus()
739 {
740 aTextWindow.TextGrabFocus();
741 }
742
743 void ScInputWindow::TextInvalidate()
744 {
745 aTextWindow.Invalidate();
746 }
747
748 void ScInputWindow::SwitchToTextWin()
749 {
750 // used for shift-ctrl-F2
751
752 aTextWindow.StartEditEngine();
753 if ( SC_MOD()->IsEditMode() )
754 {
755 aTextWindow.TextGrabFocus();
756 EditView* pView = aTextWindow.GetEditView();
757 if (pView)
758 {
759 sal_Int32 nPara = pView->GetEditEngine()->GetParagraphCount() ? ( pView->GetEditEngine()->GetParagraphCount() - 1 ) : 0;
760 sal_Int32 nLen = pView->GetEditEngine()->GetTextLen( nPara );
761 ESelection aSel( nPara, nLen, nPara, nLen );
762 pView->SetSelection( aSel ); // set cursor to end of text
763 }
764 }
765 }
766
767 void ScInputWindow::PosGrabFocus()
768 {
769 aWndPos.GrabFocus();
770 }
771
772 void ScInputWindow::EnableButtons( bool bEnable )
773 {
774 // when enabling buttons, always also enable the input window itself
775 if ( bEnable && !IsEnabled() )
776 Enable();
777
778 EnableItem( SID_INPUT_FUNCTION, bEnable );
779 EnableItem( bIsOkCancelMode ? SID_INPUT_CANCEL : SID_INPUT_SUM, bEnable );
780 EnableItem( bIsOkCancelMode ? SID_INPUT_OK : SID_INPUT_EQUAL, bEnable );
781 // Invalidate();
782 }
783
784 void ScInputWindow::StateChanged( StateChangedType nType )
785 {
786 ToolBox::StateChanged( nType );
787
788 if ( nType == STATE_CHANGE_INITSHOW ) Resize();
789 }
790
791 void ScInputWindow::DataChanged( const DataChangedEvent& rDCEvt )
792 {
793 if ( rDCEvt.GetType() == DATACHANGED_SETTINGS && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
794 {
795 // update item images
796 ScModule* pScMod = SC_MOD();
797 SfxImageManager* pImgMgr = SfxImageManager::GetImageManager( pScMod );
798 // IMAGE macro uses pScMod, pImgMg
799
800 SetItemImage( SID_INPUT_FUNCTION, IMAGE( SID_INPUT_FUNCTION ) );
801 if ( bIsOkCancelMode )
802 {
803 SetItemImage( SID_INPUT_CANCEL, IMAGE( SID_INPUT_CANCEL ) );
804 SetItemImage( SID_INPUT_OK, IMAGE( SID_INPUT_OK ) );
805 }
806 else
807 {
808 SetItemImage( SID_INPUT_SUM, IMAGE( SID_INPUT_SUM ) );
809 SetItemImage( SID_INPUT_EQUAL, IMAGE( SID_INPUT_EQUAL ) );
810 }
811 }
812
813 ToolBox::DataChanged( rDCEvt );
814 }
815
816 bool ScInputWindow::IsPointerAtResizePos()
817 {
818 if ( GetOutputSizePixel().Height() - GetPointerPosPixel().Y() <= 4 )
819 return true;
820 else
821 return false;
822 }
823
824 void ScInputWindow::MouseMove( const MouseEvent& rMEvt )
825 {
826 if ( mbIsMultiLine )
827 {
828 Point aPosPixel = GetPointerPosPixel();
829
830 ScInputBarGroup* pGroupBar = dynamic_cast< ScInputBarGroup* > ( pRuntimeWindow.get() );
831
832 if ( bInResize || IsPointerAtResizePos() )
833 SetPointer( Pointer( POINTER_WINDOW_SSIZE ) );
834 else
835 SetPointer( Pointer( POINTER_ARROW ) );
836
837 if ( bInResize )
838 {
839 // detect direction
840 long nResizeThreshold = ( (long)TBX_WINDOW_HEIGHT * 0.7 );
841 bool bResetPointerPos = false;
842
843 // Detect attempt to expand toolbar too much
844 if ( aPosPixel.Y() >= mnMaxY )
845 {
846 bResetPointerPos = true;
847 aPosPixel.Y() = mnMaxY;
848 } // or expanding down
849 else if ( GetOutputSizePixel().Height() - aPosPixel.Y() < -nResizeThreshold )
850 {
851 pGroupBar->IncrementVerticalSize();
852 bResetPointerPos = true;
853 } // or shrinking up
854 else if ( ( GetOutputSizePixel().Height() - aPosPixel.Y() ) > nResizeThreshold )
855 {
856 bResetPointerPos = true;
857 pGroupBar->DecrementVerticalSize();
858 }
859
860 if ( bResetPointerPos )
861 {
862 aPosPixel.Y() = GetOutputSizePixel().Height();
863 SetPointerPosPixel( aPosPixel );
864 }
865 }
866 }
867 ToolBox::MouseMove( rMEvt );
868 }
869
870 void ScInputWindow::MouseButtonDown( const MouseEvent& rMEvt )
871 {
872 if ( mbIsMultiLine )
873 {
874 if ( rMEvt.IsLeft() )
875 {
876 if ( IsPointerAtResizePos() )
877 {
878 // Don't leave the mouse pointer leave *this* window
879 CaptureMouse();
880 bInResize = true;
881 // find the height of the gridwin, we don't wan't to be
882 // able to expand the toolbar too far so we need to
883 // caculate an upper limit
884 // I'd prefer to leave at least a single column header and a
885 // row but I don't know how to get that value in pixels.
886 // Use TBX_WINDOW_HEIGHT for the moment
887 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
888 mnMaxY = GetOutputSizePixel().Height() + ( pViewSh->GetGridHeight(SC_SPLIT_TOP) + pViewSh->GetGridHeight(SC_SPLIT_BOTTOM) ) - TBX_WINDOW_HEIGHT;
889 }
890 }
891 }
892 ToolBox::MouseButtonDown( rMEvt );
893 }
894 void ScInputWindow::MouseButtonUp( const MouseEvent& rMEvt )
895 {
896 if ( mbIsMultiLine )
897 {
898 ReleaseMouse();
899 if ( rMEvt.IsLeft() )
900 {
901 bInResize = false;
902 mnMaxY = 0;
903 }
904 }
905 ToolBox::MouseButtonUp( rMEvt );
906 }
907
908 // ScInputBarGroup
909
910
911 ScInputBarGroup::ScInputBarGroup(Window* pParent, ScTabViewShell* pViewSh)
912 : ScTextWndBase ( pParent, WinBits(WB_HIDE | WB_TABSTOP ) ),
913 aMultiTextWnd ( this, pViewSh ),
914 aButton ( this, WB_TABSTOP | WB_RECTSTYLE | WB_SMALLSTYLE ),
915 aScrollBar ( this, WB_TABSTOP | WB_VERT | WB_DRAG ),
916 nVertOffset ( 0 )
917 {
918 aMultiTextWnd.Show();
919 aMultiTextWnd.SetQuickHelpText( ScResId( SCSTR_QHELP_INPUTWND ) );
920 aMultiTextWnd.SetHelpId( HID_INSWIN_INPUT );
921
922 Size aSize( GetSettings().GetStyleSettings().GetScrollBarSize(), aMultiTextWnd.GetPixelHeightForLines(1) );
923
924 aButton.SetClickHdl( LINK( this, ScInputBarGroup, ClickHdl ) );
925 aButton.SetSizePixel( aSize );
926 aButton.Enable();
927 aButton.SetSymbol( SYMBOL_SPIN_DOWN );
928 aButton.SetQuickHelpText( ScResId( SCSTR_QHELP_EXPAND_FORMULA ) );
929 aButton.Show();
930
931 aScrollBar.SetSizePixel( aSize );
932 aScrollBar.SetScrollHdl( LINK( this, ScInputBarGroup, Impl_ScrollHdl ) );
933 }
934
935 ScInputBarGroup::~ScInputBarGroup()
936 {
937
938 }
939
940 void
941 ScInputBarGroup::InsertAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
942 {
943 aMultiTextWnd.InsertAccessibleTextData( rTextData );
944 }
945
946 void
947 ScInputBarGroup::RemoveAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
948 {
949 aMultiTextWnd.RemoveAccessibleTextData( rTextData );
950 }
951
952 const OUString&
953 ScInputBarGroup::GetTextString() const
954 {
955 return aMultiTextWnd.GetTextString();
956 }
957
958 void ScInputBarGroup::SetTextString( const OUString& rString )
959 {
960 aMultiTextWnd.SetTextString(rString);
961 }
962
963 void ScInputBarGroup::Resize()
964 {
965 Window *w=GetParent();
966 ScInputWindow *pParent;
967 pParent=dynamic_cast<ScInputWindow*>(w);
968
969 if(pParent==NULL)
970 {
971 OSL_FAIL("The parent window pointer pParent is null");
972 return;
973 }
974
975 long nWidth = pParent->GetSizePixel().Width();
976 long nLeft = GetPosPixel().X();
977
978 Size aSize = GetSizePixel();
979 aSize.Width() = std::max( ((long)(nWidth - nLeft - LEFT_OFFSET)), (long)0 );
980
981 aScrollBar.SetPosPixel(Point( aSize.Width() - aButton.GetSizePixel().Width(), aButton.GetSizePixel().Height() ) );
982
983 Size aTmpSize( aSize );
984 aTmpSize.Width() = aTmpSize.Width() - aButton.GetSizePixel().Width() - BUTTON_OFFSET;
985 aMultiTextWnd.SetSizePixel(aTmpSize);
986
987 aMultiTextWnd.Resize();
988
989 aSize.Height() = aMultiTextWnd.GetSizePixel().Height();
990
991 SetSizePixel(aSize);
992
993 if( aMultiTextWnd.GetNumLines() > 1 )
994 {
995 aButton.SetSymbol( SYMBOL_SPIN_UP );
996 aButton.SetQuickHelpText( ScResId( SCSTR_QHELP_COLLAPSE_FORMULA ) );
997 Size scrollSize = aButton.GetSizePixel();
998 scrollSize.Height() = aMultiTextWnd.GetSizePixel().Height() - aButton.GetSizePixel().Height();
999 aScrollBar.SetSizePixel( scrollSize );
1000
1001 Size aOutSz = aMultiTextWnd.GetOutputSize();
1002
1003 aScrollBar.SetVisibleSize( aOutSz.Height() );
1004 aScrollBar.SetPageSize( aOutSz.Height() );
1005 aScrollBar.SetLineSize( aMultiTextWnd.GetTextHeight() );
1006 aScrollBar.SetRange( Range( 0, aMultiTextWnd.GetEditEngTxtHeight() ) );
1007
1008 aScrollBar.Resize();
1009 aScrollBar.Show();
1010 }
1011 else
1012 {
1013 aButton.SetSymbol( SYMBOL_SPIN_DOWN );
1014 aButton.SetQuickHelpText( ScResId( SCSTR_QHELP_EXPAND_FORMULA ) );
1015 aScrollBar.Hide();
1016 }
1017
1018 aButton.SetPosPixel(Point(aSize.Width() - aButton.GetSizePixel().Width(), 0));
1019
1020 Invalidate();
1021 }
1022
1023 void ScInputBarGroup::StopEditEngine( bool bAll )
1024 {
1025 aMultiTextWnd.StopEditEngine( bAll );
1026 }
1027
1028 void ScInputBarGroup::StartEditEngine()
1029 {
1030 aMultiTextWnd.StartEditEngine();
1031 }
1032
1033
1034 void ScInputBarGroup::MakeDialogEditView()
1035 {
1036 aMultiTextWnd.MakeDialogEditView();
1037 }
1038
1039
1040 EditView* ScInputBarGroup::GetEditView()
1041 {
1042 return aMultiTextWnd.GetEditView();
1043 }
1044
1045 bool ScInputBarGroup::IsInputActive()
1046 {
1047 return aMultiTextWnd.IsInputActive();
1048 }
1049
1050 void ScInputBarGroup::SetFormulaMode(bool bSet)
1051 {
1052 aMultiTextWnd.SetFormulaMode(bSet);
1053 }
1054
1055 void ScInputBarGroup::IncrementVerticalSize()
1056 {
1057 aMultiTextWnd.SetNumLines( aMultiTextWnd.GetNumLines() + 1 );
1058 TriggerToolboxLayout();
1059 }
1060
1061 void ScInputBarGroup::DecrementVerticalSize()
1062 {
1063 if ( aMultiTextWnd.GetNumLines() > 1 )
1064 {
1065 aMultiTextWnd.SetNumLines( aMultiTextWnd.GetNumLines() - 1 );
1066 TriggerToolboxLayout();
1067 }
1068 }
1069
1070 IMPL_LINK_NOARG(ScInputBarGroup, ClickHdl)
1071 {
1072 Window *w=GetParent();
1073 ScInputWindow *pParent;
1074 pParent=dynamic_cast<ScInputWindow*>(w);
1075
1076 if(pParent==NULL)
1077 {
1078 OSL_FAIL("The parent window pointer pParent is null");
1079 return 1;
1080 }
1081 if( aMultiTextWnd.GetNumLines() > 1 )
1082 {
1083 aMultiTextWnd.SetNumLines( 1 );
1084 }
1085 else
1086 {
1087 aMultiTextWnd.SetNumLines( aMultiTextWnd.GetLastNumExpandedLines() );
1088 }
1089 TriggerToolboxLayout();
1090 // Restore focus to input line(s) if necessary
1091 if ( SC_MOD()->GetInputHdl()->IsTopMode() )
1092 aMultiTextWnd.GrabFocus();
1093 return 0;
1094 }
1095
1096 void ScInputBarGroup::TriggerToolboxLayout()
1097 {
1098 Window *w=GetParent();
1099 ScInputWindow *pParent;
1100 pParent=dynamic_cast<ScInputWindow*>(w);
1101 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1102
1103 // Capture the vertical position of this window in the toolbar, when we increase
1104 // the size of the toolbar to accomadate expanded line input we need to take this
1105 // into account
1106 if ( !nVertOffset )
1107 nVertOffset = pParent->GetItemPosRect( pParent->GetItemCount() - 1 ).Top();
1108
1109 if ( pViewFrm )
1110 {
1111 Reference< com::sun::star::beans::XPropertySet > xPropSet( pViewFrm->GetFrame().GetFrameInterface(), UNO_QUERY );
1112 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
1113
1114 if ( xPropSet.is() )
1115 {
1116 com::sun::star::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
1117 aValue >>= xLayoutManager;
1118 }
1119
1120 if ( xLayoutManager.is() )
1121 {
1122 if ( aMultiTextWnd.GetNumLines() > 1)
1123 pParent->SetToolbarLayoutMode( TBX_LAYOUT_LOCKVERT );
1124 else
1125 pParent->SetToolbarLayoutMode( TBX_LAYOUT_NORMAL );
1126 xLayoutManager->lock();
1127 DataChangedEvent aFakeUpdate( DATACHANGED_SETTINGS, NULL, SETTINGS_STYLE );
1128 // this basically will trigger the reposititioning of the
1129 // items in the toolbar from ImplFormat ( which is controlled by
1130 // mnWinHeight ) which in turn is updated in ImplCalcItem which is
1131 // controlled by mbCalc. Additionally the ImplFormat above is
1132 // controlled via mbFormat. It seems the easiest way to get these
1133 // booleans set is to send in the fake event below.
1134 pParent->DataChanged( aFakeUpdate);
1135 // highest item in toolbar will have been calculated via the
1136 // event above. Call resize on InputBar to pick up the height
1137 // change
1138 pParent->Resize();
1139 // unlock relayouts the toolbars in the 4 quadrants
1140 xLayoutManager->unlock();
1141 }
1142 }
1143 }
1144
1145 IMPL_LINK_NOARG(ScInputBarGroup, Impl_ScrollHdl)
1146 {
1147 aMultiTextWnd.DoScroll();
1148 return 0;
1149 }
1150
1151 void ScInputBarGroup::TextGrabFocus()
1152 {
1153 aMultiTextWnd.TextGrabFocus();
1154 }
1155
1156
1157 // ScMultiTextWnd
1158
1159
1160 ScMultiTextWnd::ScMultiTextWnd( ScInputBarGroup* pParen, ScTabViewShell* pViewSh )
1161 :
1162 ScTextWnd( pParen, pViewSh ),
1163 mrGroupBar(* pParen ),
1164 mnLines( 1 ),
1165 mnLastExpandedLines( INPUTWIN_MULTILINES ),
1166 mbInvalidate( false )
1167 {
1168 Size aBorder;
1169 aBorder = CalcWindowSize( aBorder);
1170 mnBorderHeight = aBorder.Height();
1171 }
1172
1173 ScMultiTextWnd::~ScMultiTextWnd()
1174 {
1175 }
1176
1177 void ScMultiTextWnd::Paint( const Rectangle& rRect )
1178 {
1179 EditView* pView = GetEditView();
1180 if ( pView )
1181 {
1182 if ( mbInvalidate )
1183 {
1184 pView->Invalidate();
1185 mbInvalidate = false;
1186 }
1187 pEditView->Paint( rRect );
1188 }
1189 }
1190
1191 EditView* ScMultiTextWnd::GetEditView()
1192 {
1193 if ( !pEditView )
1194 InitEditEngine();
1195 return pEditView;
1196 }
1197
1198 long ScMultiTextWnd::GetPixelHeightForLines( long nLines )
1199 {
1200 // add padding ( for the borders of the window )
1201 return ( nLines * LogicToPixel( Size( 0, GetTextHeight() ) ).Height() ) + mnBorderHeight;
1202 }
1203
1204 void ScMultiTextWnd::SetNumLines( long nLines )
1205 {
1206 mnLines = nLines;
1207 if ( nLines > 1 )
1208 {
1209 mnLastExpandedLines = nLines;
1210 Resize();
1211 }
1212 }
1213
1214 void ScMultiTextWnd::Resize()
1215 {
1216 // Only Height is recalculated here, Width is applied from
1217 // parent/container window
1218 Size aTextBoxSize = GetSizePixel();
1219
1220 aTextBoxSize.Height() = GetPixelHeightForLines( mnLines );
1221 SetSizePixel( aTextBoxSize );
1222
1223 if(pEditView)
1224 {
1225 Size aOutputSize = GetOutputSizePixel();
1226 Rectangle aOutputArea = PixelToLogic( Rectangle( Point(), aOutputSize ));
1227 pEditView->SetOutputArea( aOutputArea );
1228
1229 // Don't leave an empty area at the bottom if we can move the text down.
1230 long nMaxVisAreaTop = pEditEngine->GetTextHeight() - aOutputArea.GetHeight();
1231 if (pEditView->GetVisArea().Top() > nMaxVisAreaTop)
1232 {
1233 pEditView->Scroll(0, pEditView->GetVisArea().Top() - nMaxVisAreaTop);
1234 }
1235
1236 pEditEngine->SetPaperSize( PixelToLogic( Size( aOutputSize.Width(), 10000 ) ) );
1237 }
1238
1239 SetScrollBarRange();
1240 }
1241
1242 IMPL_LINK(ScMultiTextWnd, ModifyHdl, EENotify*, pNotify)
1243 {
1244 ScTextWnd::NotifyHdl( pNotify );
1245 return 0;
1246 }
1247
1248 IMPL_LINK(ScMultiTextWnd, NotifyHdl, EENotify*, pNotify)
1249 {
1250 // need to process EE_NOTIFY_TEXTVIEWSCROLLED here
1251 // sometimes we don't seem to get EE_NOTIFY_TEXTVIEWSCROLLED e.g. when
1252 // we insert text at the beginning of the text so the cursor never moves
1253 // down to generate a scroll event
1254
1255 if ( pNotify && ( pNotify->eNotificationType == EE_NOTIFY_TEXTVIEWSCROLLED
1256 || pNotify->eNotificationType == EE_NOTIFY_TEXTHEIGHTCHANGED ) )
1257 SetScrollBarRange();
1258 return 0;
1259 }
1260
1261 long ScMultiTextWnd::GetEditEngTxtHeight()
1262 {
1263 return pEditView ? pEditView->GetEditEngine()->GetTextHeight() : 0;
1264 }
1265
1266 void ScMultiTextWnd::SetScrollBarRange()
1267 {
1268 if ( pEditView )
1269 {
1270 ScrollBar& rVBar = mrGroupBar.GetScrollBar();
1271 rVBar.SetRange( Range( 0, GetEditEngTxtHeight() ) );
1272 long currentDocPos = pEditView->GetVisArea().TopLeft().Y();
1273 rVBar.SetThumbPos( currentDocPos );
1274 }
1275 }
1276
1277 void
1278 ScMultiTextWnd::DoScroll()
1279 {
1280 if ( pEditView )
1281 {
1282 ScrollBar& rVBar = mrGroupBar.GetScrollBar();
1283 long currentDocPos = pEditView->GetVisArea().TopLeft().Y();
1284 long nDiff = currentDocPos - rVBar.GetThumbPos();
1285 pEditView->Scroll( 0, nDiff );
1286 currentDocPos = pEditView->GetVisArea().TopLeft().Y();
1287 rVBar.SetThumbPos( currentDocPos );
1288 }
1289 }
1290
1291 void ScMultiTextWnd::StartEditEngine()
1292 {
1293 // Bei "eigener Modalitaet" (Doc-modale Dialoge) nicht aktivieren
1294 SfxObjectShell* pObjSh = SfxObjectShell::Current();
1295 if ( pObjSh && pObjSh->IsInModalMode() )
1296 return;
1297
1298 if ( !pEditView || !pEditEngine )
1299 {
1300 InitEditEngine();
1301 }
1302
1303 SC_MOD()->SetInputMode( SC_INPUT_TOP );
1304
1305 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1306 if (pViewFrm)
1307 pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERT );
1308 }
1309
1310 static void lcl_ExtendEditFontAttribs( SfxItemSet& rSet )
1311 {
1312 const SfxPoolItem& rFontItem = rSet.Get( EE_CHAR_FONTINFO );
1313 rSet.Put( rFontItem, EE_CHAR_FONTINFO_CJK );
1314 rSet.Put( rFontItem, EE_CHAR_FONTINFO_CTL );
1315 const SfxPoolItem& rHeightItem = rSet.Get( EE_CHAR_FONTHEIGHT );
1316 rSet.Put( rHeightItem, EE_CHAR_FONTHEIGHT_CJK );
1317 rSet.Put( rHeightItem, EE_CHAR_FONTHEIGHT_CTL );
1318 const SfxPoolItem& rWeightItem = rSet.Get( EE_CHAR_WEIGHT );
1319 rSet.Put( rWeightItem, EE_CHAR_WEIGHT_CJK );
1320 rSet.Put( rWeightItem, EE_CHAR_WEIGHT_CTL );
1321 const SfxPoolItem& rItalicItem = rSet.Get( EE_CHAR_ITALIC );
1322 rSet.Put( rItalicItem, EE_CHAR_ITALIC_CJK );
1323 rSet.Put( rItalicItem, EE_CHAR_ITALIC_CTL );
1324 const SfxPoolItem& rLangItem = rSet.Get( EE_CHAR_LANGUAGE );
1325 rSet.Put( rLangItem, EE_CHAR_LANGUAGE_CJK );
1326 rSet.Put( rLangItem, EE_CHAR_LANGUAGE_CTL );
1327 }
1328
1329 static void lcl_ModifyRTLDefaults( SfxItemSet& rSet )
1330 {
1331 rSet.Put( SvxAdjustItem( SVX_ADJUST_RIGHT, EE_PARA_JUST ) );
1332
1333 // always using rtl writing direction would break formulas
1334 //rSet.Put( SvxFrameDirectionItem( FRMDIR_HORI_RIGHT_TOP, EE_PARA_WRITINGDIR ) );
1335
1336 // PaperSize width is limited to USHRT_MAX in RTL mode (because of EditEngine's
1337 // sal_uInt16 values in EditLine), so the text may be wrapped and line spacing must be
1338 // increased to not see the beginning of the next line.
1339 SvxLineSpacingItem aItem( SVX_LINESPACE_TWO_LINES, EE_PARA_SBL );
1340 aItem.SetPropLineSpace( 200 );
1341 rSet.Put( aItem );
1342 }
1343
1344 static void lcl_ModifyRTLVisArea( EditView* pEditView )
1345 {
1346 Rectangle aVisArea = pEditView->GetVisArea();
1347 Size aPaper = pEditView->GetEditEngine()->GetPaperSize();
1348 long nDiff = aPaper.Width() - aVisArea.Right();
1349 aVisArea.Left() += nDiff;
1350 aVisArea.Right() += nDiff;
1351 pEditView->SetVisArea(aVisArea);
1352 }
1353
1354
1355 void ScMultiTextWnd::InitEditEngine()
1356 {
1357 ScFieldEditEngine* pNew;
1358 ScTabViewShell* pViewSh = GetViewShell();
1359 ScDocShell* pDocSh = NULL;
1360 if ( pViewSh )
1361 {
1362 pDocSh = pViewSh->GetViewData()->GetDocShell();
1363 ScDocument* pDoc = pViewSh->GetViewData()->GetDocument();
1364 pNew = new ScFieldEditEngine(pDoc, pDoc->GetEnginePool(), pDoc->GetEditPool());
1365 }
1366 else
1367 pNew = new ScFieldEditEngine(NULL, EditEngine::CreatePool(), NULL, true);
1368 pNew->SetExecuteURL( false );
1369 pEditEngine = pNew;
1370
1371 Size barSize=GetSizePixel();
1372 pEditEngine->SetUpdateMode( false );
1373 pEditEngine->SetPaperSize( PixelToLogic(Size(barSize.Width(),10000)) );
1374 pEditEngine->SetWordDelimiters(
1375 ScEditUtil::ModifyDelimiters( pEditEngine->GetWordDelimiters() ) );
1376
1377 UpdateAutoCorrFlag();
1378
1379 {
1380 SfxItemSet* pSet = new SfxItemSet( pEditEngine->GetEmptyItemSet() );
1381 pEditEngine->SetFontInfoInItemSet( *pSet, aTextFont );
1382 lcl_ExtendEditFontAttribs( *pSet );
1383 // turn off script spacing to match DrawText output
1384 pSet->Put( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
1385 if ( bIsRTL )
1386 lcl_ModifyRTLDefaults( *pSet );
1387 pEditEngine->SetDefaults( pSet );
1388 }
1389
1390 // Wenn in der Zelle URL-Felder enthalten sind, muessen die auch in
1391 // die Eingabezeile uebernommen werden, weil sonst die Positionen nicht stimmen.
1392
1393 bool bFilled = false;
1394 ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
1395 if ( pHdl ) //! Testen, ob's der richtige InputHdl ist?
1396 bFilled = pHdl->GetTextAndFields( *pEditEngine );
1397
1398 pEditEngine->SetUpdateMode( true );
1399
1400 // aString ist die Wahrheit...
1401 if (bFilled && pEditEngine->GetText() == aString)
1402 Invalidate(); // Repaint fuer (hinterlegte) Felder
1403 else
1404 pEditEngine->SetText(aString); // dann wenigstens den richtigen Text
1405
1406 pEditView = new EditView( pEditEngine, this );
1407 pEditView->SetInsertMode(bIsInsertMode);
1408
1409 // Text aus Clipboard wird als ASCII einzeilig uebernommen
1410 sal_uLong n = pEditView->GetControlWord();
1411 pEditView->SetControlWord( n | EV_CNTRL_SINGLELINEPASTE );
1412
1413 pEditEngine->InsertView( pEditView, EE_APPEND );
1414
1415 Resize();
1416
1417 if ( bIsRTL )
1418 lcl_ModifyRTLVisArea( pEditView );
1419
1420 pEditEngine->SetModifyHdl(LINK(this, ScMultiTextWnd, ModifyHdl));
1421 pEditEngine->SetNotifyHdl(LINK(this, ScMultiTextWnd, NotifyHdl));
1422
1423 if (!maAccTextDatas.empty())
1424 maAccTextDatas.back()->StartEdit();
1425
1426 // as long as EditEngine and DrawText sometimes differ for CTL text,
1427 // repaint now to have the EditEngine's version visible
1428 if (pDocSh)
1429 {
1430 ScDocument* pDoc = pDocSh->GetDocument(); // any document
1431 sal_uInt8 nScript = pDoc->GetStringScriptType( aString );
1432 if ( nScript & SCRIPTTYPE_COMPLEX )
1433 Invalidate();
1434 }
1435 }
1436
1437 void ScMultiTextWnd::StopEditEngine( bool bAll )
1438 {
1439 if ( pEditEngine )
1440 pEditEngine->SetNotifyHdl(Link());
1441 ScTextWnd::StopEditEngine( bAll );
1442 }
1443
1444 void ScMultiTextWnd::SetTextString( const OUString& rNewString )
1445 {
1446 // Ideally it would be best to create on demand the EditEngine/EditView here, but... for
1447 // the initialisation scenario where a cell is first clicked on we end up with the text in the
1448 // inputbar window scrolled to the bottom if we do that here ( because the tableview and topview
1449 // are synced I guess ).
1450 // should fix that I suppose :-/ need to look a bit further into that
1451 mbInvalidate = true; // ensure next Paint ( that uses editengine ) call will call Invalidate first
1452 ScTextWnd::SetTextString( rNewString );
1453 SetScrollBarRange();
1454 DoScroll();
1455 }
1456
1457 // ScTextWnd
1458
1459
1460 ScTextWnd::ScTextWnd( Window* pParent, ScTabViewShell* pViewSh )
1461 : ScTextWndBase ( pParent, WinBits(WB_HIDE | WB_BORDER) ),
1462 DragSourceHelper( this ),
1463 pEditEngine ( NULL ),
1464 pEditView ( NULL ),
1465 bIsInsertMode( true ),
1466 bFormulaMode ( false ),
1467 bInputMode ( false ),
1468 mpViewShell(pViewSh)
1469 {
1470 EnableRTL( false ); // EditEngine can't be used with VCL EnableRTL
1471
1472 bIsRTL = GetSettings().GetLayoutRTL();
1473
1474 // always use application font, so a font with cjk chars can be installed
1475 Font aAppFont = GetFont();
1476 aTextFont = aAppFont;
1477 aTextFont.SetSize( PixelToLogic( aAppFont.GetSize(), MAP_TWIP ) ); // AppFont ist in Pixeln
1478
1479 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1480
1481 Color aBgColor= rStyleSettings.GetWindowColor();
1482 Color aTxtColor= rStyleSettings.GetWindowTextColor();
1483
1484 aTextFont.SetTransparent ( true );
1485 aTextFont.SetFillColor ( aBgColor );
1486 //aTextFont.SetColor ( COL_FIELDTEXT );
1487 aTextFont.SetColor (aTxtColor);
1488 aTextFont.SetWeight ( WEIGHT_NORMAL );
1489
1490 Size aSize(1,TBX_WINDOW_HEIGHT);
1491 Size aMinEditSize( Edit::GetMinimumEditSize() );
1492 if( aMinEditSize.Height() > aSize.Height() )
1493 aSize.Height() = aMinEditSize.Height();
1494 SetSizePixel ( aSize );
1495 SetBackground ( aBgColor );
1496 SetLineColor ( COL_BLACK );
1497 SetMapMode ( MAP_TWIP );
1498 SetPointer ( POINTER_TEXT );
1499 SetFont( aTextFont );
1500 }
1501
1502 ScTextWnd::~ScTextWnd()
1503 {
1504 while (!maAccTextDatas.empty()) {
1505 maAccTextDatas.back()->Dispose();
1506 }
1507 delete pEditView;
1508 delete pEditEngine;
1509 }
1510
1511 void ScTextWnd::Paint( const Rectangle& rRect )
1512 {
1513 if (pEditView)
1514 pEditView->Paint( rRect );
1515 else
1516 {
1517 SetFont( aTextFont );
1518
1519 long nDiff = GetOutputSizePixel().Height()
1520 - LogicToPixel( Size( 0, GetTextHeight() ) ).Height();
1521 // if (nDiff<2) nDiff=2; // mind. 1 Pixel
1522
1523 long nStartPos = 0;
1524 if ( bIsRTL )
1525 {
1526 // right-align
1527 nStartPos += GetOutputSizePixel().Width() -
1528 LogicToPixel( Size( GetTextWidth( aString ), 0 ) ).Width();
1529
1530 // LayoutMode isn't changed as long as ModifyRTLDefaults doesn't include SvxFrameDirectionItem
1531 }
1532
1533 DrawText( PixelToLogic( Point( nStartPos, nDiff/2 ) ), aString );
1534 }
1535 }
1536
1537 void ScTextWnd::Resize()
1538 {
1539 if (pEditView)
1540 {
1541 Size aSize = GetOutputSizePixel();
1542 long nDiff = aSize.Height()
1543 - LogicToPixel( Size( 0, GetTextHeight() ) ).Height();
1544
1545 pEditView->SetOutputArea(
1546 PixelToLogic( Rectangle( Point( 0, (nDiff > 0) ? nDiff/2 : 1 ),
1547 aSize ) ) );
1548 }
1549 }
1550
1551 void ScTextWnd::MouseMove( const MouseEvent& rMEvt )
1552 {
1553 if (pEditView)
1554 pEditView->MouseMove( rMEvt );
1555 }
1556
1557 void ScTextWnd::MouseButtonDown( const MouseEvent& rMEvt )
1558 {
1559 if (!HasFocus())
1560 {
1561 StartEditEngine();
1562 if ( SC_MOD()->IsEditMode() )
1563 GrabFocus();
1564 }
1565
1566 if (pEditView)
1567 {
1568 pEditView->SetEditEngineUpdateMode( true );
1569 pEditView->MouseButtonDown( rMEvt );
1570 }
1571 }
1572
1573 void ScTextWnd::MouseButtonUp( const MouseEvent& rMEvt )
1574 {
1575 if (pEditView)
1576 if (pEditView->MouseButtonUp( rMEvt ))
1577 {
1578 if ( rMEvt.IsMiddle() &&
1579 GetSettings().GetMouseSettings().GetMiddleButtonAction() == MOUSE_MIDDLE_PASTESELECTION )
1580 {
1581 // EditView may have pasted from selection
1582 SC_MOD()->InputChanged( pEditView );
1583 }
1584 else
1585 SC_MOD()->InputSelection( pEditView );
1586 }
1587 }
1588
1589 void ScTextWnd::Command( const CommandEvent& rCEvt )
1590 {
1591 bInputMode = true;
1592 sal_uInt16 nCommand = rCEvt.GetCommand();
1593 if ( pEditView /* && nCommand == COMMAND_STARTDRAG */ )
1594 {
1595 ScModule* pScMod = SC_MOD();
1596 ScTabViewShell* pStartViewSh = ScTabViewShell::GetActiveViewShell();
1597
1598 // don't modify the font defaults here - the right defaults are
1599 // already set in StartEditEngine when the EditEngine is created
1600
1601 // verhindern, dass die EditView beim View-Umschalten wegkommt
1602 pScMod->SetInEditCommand( true );
1603 pEditView->Command( rCEvt );
1604 pScMod->SetInEditCommand( false );
1605
1606 // COMMAND_STARTDRAG heiss noch lange nicht, dass der Inhalt geaendert wurde
1607 // darum in dem Fall kein InputChanged
1608 //! erkennen, ob mit Move gedraggt wurde, oder Drag&Move irgendwie verbieten
1609
1610 if ( nCommand == COMMAND_STARTDRAG )
1611 {
1612 // ist auf eine andere View gedraggt worden?
1613 ScTabViewShell* pEndViewSh = ScTabViewShell::GetActiveViewShell();
1614 if ( pEndViewSh != pStartViewSh && pStartViewSh != NULL )
1615 {
1616 ScViewData* pViewData = pStartViewSh->GetViewData();
1617 ScInputHandler* pHdl = pScMod->GetInputHdl( pStartViewSh );
1618 if ( pHdl && pViewData->HasEditView( pViewData->GetActivePart() ) )
1619 {
1620 pHdl->CancelHandler();
1621 pViewData->GetView()->ShowCursor(); // fehlt bei KillEditView, weil nicht aktiv
1622 }
1623 }
1624 }
1625 else if ( nCommand == COMMAND_CURSORPOS )
1626 {
1627 // don't call InputChanged for COMMAND_CURSORPOS
1628 }
1629 else if ( nCommand == COMMAND_INPUTLANGUAGECHANGE )
1630 {
1631 // #i55929# Font and font size state depends on input language if nothing is selected,
1632 // so the slots have to be invalidated when the input language is changed.
1633
1634 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1635 if (pViewFrm)
1636 {
1637 SfxBindings& rBindings = pViewFrm->GetBindings();
1638 rBindings.Invalidate( SID_ATTR_CHAR_FONT );
1639 rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
1640 }
1641 }
1642 else if ( nCommand == COMMAND_WHEEL )
1643 {
1644 //don't call InputChanged for COMMAND_WHEEL
1645 }
1646 else
1647 SC_MOD()->InputChanged( pEditView );
1648 }
1649 else
1650 Window::Command(rCEvt); // sonst soll sich die Basisklasse drum kuemmern...
1651
1652 bInputMode = false;
1653 }
1654
1655 void ScTextWnd::StartDrag( sal_Int8 /* nAction */, const Point& rPosPixel )
1656 {
1657 if ( pEditView )
1658 {
1659 CommandEvent aDragEvent( rPosPixel, COMMAND_STARTDRAG, true );
1660 pEditView->Command( aDragEvent );
1661
1662 // handling of d&d to different view (CancelHandler) can't be done here,
1663 // because the call returns before d&d is complete.
1664 }
1665 }
1666
1667 void ScTextWnd::KeyInput(const KeyEvent& rKEvt)
1668 {
1669 bInputMode = true;
1670 if (!SC_MOD()->InputKeyEvent( rKEvt ))
1671 {
1672 bool bUsed = false;
1673 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
1674 if ( pViewSh )
1675 bUsed = pViewSh->SfxKeyInput(rKEvt); // nur Acceleratoren, keine Eingabe
1676 if (!bUsed)
1677 Window::KeyInput( rKEvt );
1678 }
1679 bInputMode = false;
1680 }
1681
1682 void ScTextWnd::GetFocus()
1683 {
1684 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
1685 if ( pViewSh )
1686 pViewSh->SetFormShellAtTop( false ); // focus in input line -> FormShell no longer on top
1687 }
1688
1689 void ScTextWnd::LoseFocus()
1690 {
1691 }
1692
1693 OUString ScTextWnd::GetText() const
1694 {
1695 // ueberladen, um per Testtool an den Text heranzukommen
1696
1697 if ( pEditEngine )
1698 return pEditEngine->GetText();
1699 else
1700 return GetTextString();
1701 }
1702
1703 void ScTextWnd::SetFormulaMode( bool bSet )
1704 {
1705 if ( bSet != bFormulaMode )
1706 {
1707 bFormulaMode = bSet;
1708 UpdateAutoCorrFlag();
1709 }
1710 }
1711
1712 void ScTextWnd::UpdateAutoCorrFlag()
1713 {
1714 if ( pEditEngine )
1715 {
1716 sal_uLong nControl = pEditEngine->GetControlWord();
1717 sal_uLong nOld = nControl;
1718 if ( bFormulaMode )
1719 nControl &= ~EE_CNTRL_AUTOCORRECT; // keine Autokorrektur in Formeln
1720 else
1721 nControl |= EE_CNTRL_AUTOCORRECT; // sonst schon
1722 if ( nControl != nOld )
1723 pEditEngine->SetControlWord( nControl );
1724 }
1725 }
1726
1727 ScTabViewShell* ScTextWnd::GetViewShell()
1728 {
1729 return mpViewShell;
1730 }
1731
1732 void ScTextWnd::StartEditEngine()
1733 {
1734 // Bei "eigener Modalitaet" (Doc-modale Dialoge) nicht aktivieren
1735 SfxObjectShell* pObjSh = SfxObjectShell::Current();
1736 if ( pObjSh && pObjSh->IsInModalMode() )
1737 return;
1738
1739 if ( !pEditView || !pEditEngine )
1740 {
1741 ScFieldEditEngine* pNew;
1742 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
1743 if ( pViewSh )
1744 {
1745 ScDocument* pDoc = pViewSh->GetViewData()->GetDocument();
1746 pNew = new ScFieldEditEngine(pDoc, pDoc->GetEnginePool(), pDoc->GetEditPool());
1747 }
1748 else
1749 pNew = new ScFieldEditEngine(NULL, EditEngine::CreatePool(), NULL, true);
1750 pNew->SetExecuteURL( false );
1751 pEditEngine = pNew;
1752
1753 pEditEngine->SetUpdateMode( false );
1754 pEditEngine->SetPaperSize( Size( bIsRTL ? USHRT_MAX : THESIZE, 300 ) );
1755 pEditEngine->SetWordDelimiters(
1756 ScEditUtil::ModifyDelimiters( pEditEngine->GetWordDelimiters() ) );
1757
1758 UpdateAutoCorrFlag();
1759
1760 {
1761 SfxItemSet* pSet = new SfxItemSet( pEditEngine->GetEmptyItemSet() );
1762 pEditEngine->SetFontInfoInItemSet( *pSet, aTextFont );
1763 lcl_ExtendEditFontAttribs( *pSet );
1764 // turn off script spacing to match DrawText output
1765 pSet->Put( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
1766 if ( bIsRTL )
1767 lcl_ModifyRTLDefaults( *pSet );
1768 pEditEngine->SetDefaults( pSet );
1769 }
1770
1771 // Wenn in der Zelle URL-Felder enthalten sind, muessen die auch in
1772 // die Eingabezeile uebernommen werden, weil sonst die Positionen nicht stimmen.
1773
1774 bool bFilled = false;
1775 ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
1776 if ( pHdl ) //! Testen, ob's der richtige InputHdl ist?
1777 bFilled = pHdl->GetTextAndFields( *pEditEngine );
1778
1779 pEditEngine->SetUpdateMode( true );
1780
1781 // aString ist die Wahrheit...
1782 if (bFilled && pEditEngine->GetText() == aString)
1783 Invalidate(); // Repaint fuer (hinterlegte) Felder
1784 else
1785 pEditEngine->SetText(aString); // dann wenigstens den richtigen Text
1786
1787 pEditView = new EditView( pEditEngine, this );
1788 pEditView->SetInsertMode(bIsInsertMode);
1789
1790 // Text aus Clipboard wird als ASCII einzeilig uebernommen
1791 sal_uLong n = pEditView->GetControlWord();
1792 pEditView->SetControlWord( n | EV_CNTRL_SINGLELINEPASTE );
1793
1794 pEditEngine->InsertView( pEditView, EE_APPEND );
1795
1796 Resize();
1797
1798 if ( bIsRTL )
1799 lcl_ModifyRTLVisArea( pEditView );
1800
1801 pEditEngine->SetModifyHdl(LINK(this, ScTextWnd, NotifyHdl));
1802
1803 if (!maAccTextDatas.empty())
1804 maAccTextDatas.back()->StartEdit();
1805
1806 // as long as EditEngine and DrawText sometimes differ for CTL text,
1807 // repaint now to have the EditEngine's version visible
1808 // SfxObjectShell* pObjSh = SfxObjectShell::Current();
1809 if ( pObjSh && pObjSh->ISA(ScDocShell) )
1810 {
1811 ScDocument* pDoc = ((ScDocShell*)pObjSh)->GetDocument(); // any document
1812 sal_uInt8 nScript = pDoc->GetStringScriptType( aString );
1813 if ( nScript & SCRIPTTYPE_COMPLEX )
1814 Invalidate();
1815 }
1816 }
1817
1818 SC_MOD()->SetInputMode( SC_INPUT_TOP );
1819
1820 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1821 if (pViewFrm)
1822 pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERT );
1823 }
1824
1825 IMPL_LINK_NOARG(ScTextWnd, NotifyHdl)
1826 {
1827 if (pEditView && !bInputMode)
1828 {
1829 ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
1830
1831 // Use the InputHandler's InOwnChange flag to prevent calling InputChanged
1832 // while an InputHandler method is modifying the EditEngine content
1833
1834 if ( pHdl && !pHdl->IsInOwnChange() )
1835 pHdl->InputChanged( pEditView, true ); // #i20282# InputChanged must know if called from modify handler
1836 }
1837
1838 return 0;
1839 }
1840
1841 void ScTextWnd::StopEditEngine( bool bAll )
1842 {
1843 if (pEditView)
1844 {
1845 if (!maAccTextDatas.empty())
1846 maAccTextDatas.back()->EndEdit();
1847
1848 ScModule* pScMod = SC_MOD();
1849
1850 if (!bAll)
1851 pScMod->InputSelection( pEditView );
1852 aString = pEditEngine->GetText();
1853 bIsInsertMode = pEditView->IsInsertMode();
1854 bool bSelection = pEditView->HasSelection();
1855 pEditEngine->SetModifyHdl(Link());
1856 DELETEZ(pEditView);
1857 DELETEZ(pEditEngine);
1858
1859 if ( pScMod->IsEditMode() && !bAll )
1860 pScMod->SetInputMode(SC_INPUT_TABLE);
1861
1862 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1863 if (pViewFrm)
1864 pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERT );
1865
1866 if (bSelection)
1867 Invalidate(); // damit Selektion nicht stehenbleibt
1868 }
1869 }
1870
1871 static sal_Int32 findFirstNonMatchingChar(const OUString& rStr1, const OUString& rStr2)
1872 {
1873 // Search the string for unmatching chars
1874 const sal_Unicode* pStr1 = rStr1.getStr();
1875 const sal_Unicode* pStr2 = rStr2.getStr();
1876 sal_Int32 i = 0;
1877 while ( i < rStr1.getLength() )
1878 {
1879 // Abort on the first unmatching char
1880 if ( *pStr1 != *pStr2 )
1881 return i;
1882 ++pStr1,
1883 ++pStr2,
1884 ++i;
1885 }
1886
1887 return i;
1888 }
1889
1890 void ScTextWnd::SetTextString( const OUString& rNewString )
1891 {
1892 if ( rNewString != aString )
1893 {
1894 bInputMode = true;
1895
1896 // Position der Aenderung suchen, nur Rest painten
1897
1898 if (!pEditEngine)
1899 {
1900 bool bPaintAll;
1901 if ( bIsRTL )
1902 bPaintAll = true;
1903 else
1904 {
1905 // test if CTL script type is involved
1906 sal_uInt8 nOldScript = 0;
1907 sal_uInt8 nNewScript = 0;
1908 SfxObjectShell* pObjSh = SfxObjectShell::Current();
1909 if ( pObjSh && pObjSh->ISA(ScDocShell) )
1910 {
1911 // any document can be used (used only for its break iterator)
1912 ScDocument* pDoc = ((ScDocShell*)pObjSh)->GetDocument();
1913 nOldScript = pDoc->GetStringScriptType( aString );
1914 nNewScript = pDoc->GetStringScriptType( rNewString );
1915 }
1916 bPaintAll = ( nOldScript & SCRIPTTYPE_COMPLEX ) || ( nNewScript & SCRIPTTYPE_COMPLEX );
1917 }
1918
1919 if ( bPaintAll )
1920 {
1921 // if CTL is involved, the whole text has to be redrawn
1922 Invalidate();
1923 }
1924 else
1925 {
1926 long nTextSize = 0;
1927 sal_Int32 nDifPos;
1928 if (rNewString.getLength() > aString.getLength())
1929 nDifPos = findFirstNonMatchingChar(rNewString, aString);
1930 else
1931 nDifPos = findFirstNonMatchingChar(aString, rNewString);
1932
1933 long nSize1 = GetTextWidth(aString);
1934 long nSize2 = GetTextWidth(rNewString);
1935 if ( nSize1>0 && nSize2>0 )
1936 nTextSize = std::max( nSize1, nSize2 );
1937 else
1938 nTextSize = GetOutputSize().Width(); // Ueberlauf
1939
1940 Point aLogicStart = PixelToLogic(Point(0,0));
1941 long nStartPos = aLogicStart.X();
1942 long nInvPos = nStartPos;
1943 if (nDifPos)
1944 nInvPos += GetTextWidth(aString,0,nDifPos);
1945
1946 sal_uInt16 nFlags = 0;
1947 if ( nDifPos == aString.getLength() ) // only new characters appended
1948 nFlags = INVALIDATE_NOERASE; // then background is already clear
1949 Invalidate( Rectangle( nInvPos, 0,
1950 nStartPos+nTextSize, GetOutputSize().Height()-1 ),
1951 nFlags );
1952 }
1953 }
1954 else
1955 {
1956 pEditEngine->SetText(rNewString);
1957 }
1958
1959 aString = rNewString;
1960
1961 if (!maAccTextDatas.empty())
1962 maAccTextDatas.back()->TextChanged();
1963
1964 bInputMode = false;
1965 }
1966 }
1967
1968 const OUString& ScTextWnd::GetTextString() const
1969 {
1970 return aString;
1971 }
1972
1973 bool ScTextWnd::IsInputActive()
1974 {
1975 return HasFocus();
1976 }
1977
1978 EditView* ScTextWnd::GetEditView()
1979 {
1980 return pEditView;
1981 }
1982
1983 void ScTextWnd::MakeDialogEditView()
1984 {
1985 if ( pEditView ) return;
1986
1987 ScFieldEditEngine* pNew;
1988 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
1989 if ( pViewSh )
1990 {
1991 ScDocument* pDoc = pViewSh->GetViewData()->GetDocument();
1992 pNew = new ScFieldEditEngine(pDoc, pDoc->GetEnginePool(), pDoc->GetEditPool());
1993 }
1994 else
1995 pNew = new ScFieldEditEngine(NULL, EditEngine::CreatePool(), NULL, true);
1996 pNew->SetExecuteURL( false );
1997 pEditEngine = pNew;
1998
1999 pEditEngine->SetUpdateMode( false );
2000 pEditEngine->SetWordDelimiters( pEditEngine->GetWordDelimiters() + "=" );
2001 pEditEngine->SetPaperSize( Size( bIsRTL ? USHRT_MAX : THESIZE, 300 ) );
2002
2003 SfxItemSet* pSet = new SfxItemSet( pEditEngine->GetEmptyItemSet() );
2004 pEditEngine->SetFontInfoInItemSet( *pSet, aTextFont );
2005 lcl_ExtendEditFontAttribs( *pSet );
2006 if ( bIsRTL )
2007 lcl_ModifyRTLDefaults( *pSet );
2008 pEditEngine->SetDefaults( pSet );
2009 pEditEngine->SetUpdateMode( true );
2010
2011 pEditView = new EditView( pEditEngine, this );
2012 pEditEngine->InsertView( pEditView, EE_APPEND );
2013
2014 Resize();
2015
2016 if ( bIsRTL )
2017 lcl_ModifyRTLVisArea( pEditView );
2018
2019 if (!maAccTextDatas.empty())
2020 maAccTextDatas.back()->StartEdit();
2021 }
2022
2023 void ScTextWnd::ImplInitSettings()
2024 {
2025 bIsRTL = GetSettings().GetLayoutRTL();
2026
2027 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2028
2029 Color aBgColor= rStyleSettings.GetWindowColor();
2030 Color aTxtColor= rStyleSettings.GetWindowTextColor();
2031
2032 aTextFont.SetFillColor ( aBgColor );
2033 aTextFont.SetColor (aTxtColor);
2034 SetBackground ( aBgColor );
2035 Invalidate();
2036 }
2037
2038 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ScTextWnd::CreateAccessible()
2039 {
2040 return new ScAccessibleEditObject(GetAccessibleParentWindow()->GetAccessible(), NULL, this,
2041 OUString(ScResId(STR_ACC_EDITLINE_NAME)),
2042 OUString(ScResId(STR_ACC_EDITLINE_DESCR)), ScAccessibleEditObject::EditLine);
2043 }
2044
2045 void ScTextWnd::InsertAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
2046 {
2047 OSL_ENSURE( ::std::find( maAccTextDatas.begin(), maAccTextDatas.end(), &rTextData ) == maAccTextDatas.end(),
2048 "ScTextWnd::InsertAccessibleTextData - passed object already registered" );
2049 maAccTextDatas.push_back( &rTextData );
2050 }
2051
2052 void ScTextWnd::RemoveAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
2053 {
2054 AccTextDataVector::iterator aEnd = maAccTextDatas.end();
2055 AccTextDataVector::iterator aIt = ::std::find( maAccTextDatas.begin(), aEnd, &rTextData );
2056 OSL_ENSURE( aIt != aEnd, "ScTextWnd::RemoveAccessibleTextData - passed object not registered" );
2057 if( aIt != aEnd )
2058 maAccTextDatas.erase( aIt );
2059 }
2060
2061 void ScTextWnd::DataChanged( const DataChangedEvent& rDCEvt )
2062 {
2063 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
2064 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
2065 {
2066 ImplInitSettings();
2067 Invalidate();
2068 }
2069 else
2070 Window::DataChanged( rDCEvt );
2071 }
2072
2073 void ScTextWnd::TextGrabFocus()
2074 {
2075 GrabFocus();
2076 }
2077
2078
2079 // Positionsfenster
2080
2081
2082 ScPosWnd::ScPosWnd( Window* pParent ) :
2083 ComboBox ( pParent, WinBits(WB_HIDE | WB_DROPDOWN) ),
2084 pAccel ( NULL ),
2085 nTipVisible ( 0 ),
2086 bFormulaMode( false )
2087 {
2088 Size aSize( GetTextWidth( OUString("GW99999:GW99999") ),
2089 GetTextHeight() );
2090 aSize.Width() += 25; // ??
2091 aSize.Height() = CalcWindowSizePixel(11); // Funktionen: 10 MRU + "andere..."
2092 SetSizePixel( aSize );
2093
2094 FillRangeNames();
2095
2096 StartListening( *SFX_APP() ); // fuer Navigator-Bereichsnamen-Updates
2097 }
2098
2099 ScPosWnd::~ScPosWnd()
2100 {
2101 EndListening( *SFX_APP() );
2102
2103 HideTip();
2104
2105 delete pAccel;
2106 }
2107
2108 void ScPosWnd::SetFormulaMode( bool bSet )
2109 {
2110 if ( bSet != bFormulaMode )
2111 {
2112 bFormulaMode = bSet;
2113
2114 if ( bSet )
2115 FillFunctions();
2116 else
2117 FillRangeNames();
2118
2119 HideTip();
2120 }
2121 }
2122
2123 void ScPosWnd::SetPos( const OUString& rPosStr )
2124 {
2125 if ( aPosStr != rPosStr )
2126 {
2127 aPosStr = rPosStr;
2128 SetText(aPosStr);
2129 }
2130 }
2131
2132 namespace {
2133
2134 OUString createLocalRangeName(const OUString& rName, const OUString& rTableName)
2135 {
2136 OUStringBuffer aString (rName);
2137 aString.append(" (");
2138 aString.append(rTableName);
2139 aString.append(")");
2140 return aString.makeStringAndClear();
2141 }
2142
2143 }
2144
2145 void ScPosWnd::FillRangeNames()
2146 {
2147 Clear();
2148
2149 SfxObjectShell* pObjSh = SfxObjectShell::Current();
2150 if ( pObjSh && pObjSh->ISA(ScDocShell) )
2151 {
2152 ScDocument* pDoc = ((ScDocShell*)pObjSh)->GetDocument();
2153
2154 InsertEntry(ScGlobal::GetRscString( STR_MANAGE_NAMES ));
2155 SetSeparatorPos(0);
2156
2157 ScRange aDummy;
2158 std::set<OUString> aSet;
2159 ScRangeName* pRangeNames = pDoc->GetRangeName();
2160 if (!pRangeNames->empty())
2161 {
2162 ScRangeName::const_iterator itrBeg = pRangeNames->begin(), itrEnd = pRangeNames->end();
2163 for (ScRangeName::const_iterator itr = itrBeg; itr != itrEnd; ++itr)
2164 {
2165 if (itr->second->IsValidReference(aDummy))
2166 aSet.insert(itr->second->GetName());
2167 }
2168 }
2169 for (SCTAB i = 0; i < pDoc->GetTableCount(); ++i)
2170 {
2171 ScRangeName* pLocalRangeName = pDoc->GetRangeName(i);
2172 if (pLocalRangeName && !pLocalRangeName->empty())
2173 {
2174 OUString aTableName;
2175 pDoc->GetName(i, aTableName);
2176 for (ScRangeName::const_iterator itr = pLocalRangeName->begin(); itr != pLocalRangeName->end(); ++itr)
2177 {
2178 if (itr->second->IsValidReference(aDummy))
2179 aSet.insert(createLocalRangeName(itr->second->GetName(), aTableName));
2180 }
2181 }
2182 }
2183
2184 if (!aSet.empty())
2185 {
2186 for (std::set<OUString>::iterator itr = aSet.begin();
2187 itr != aSet.end(); ++itr)
2188 {
2189 InsertEntry(*itr);
2190 }
2191 }
2192 }
2193 SetText(aPosStr);
2194 }
2195
2196 void ScPosWnd::FillFunctions()
2197 {
2198 Clear();
2199
2200 OUString aFirstName;
2201 const ScAppOptions& rOpt = SC_MOD()->GetAppOptions();
2202 sal_uInt16 nMRUCount = rOpt.GetLRUFuncListCount();
2203 const sal_uInt16* pMRUList = rOpt.GetLRUFuncList();
2204 if (pMRUList)
2205 {
2206 const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
2207 sal_uLong nListCount = pFuncList->GetCount();
2208 for (sal_uInt16 i=0; i<nMRUCount; i++)
2209 {
2210 sal_uInt16 nId = pMRUList[i];
2211 for (sal_uLong j=0; j<nListCount; j++)
2212 {
2213 const ScFuncDesc* pDesc = pFuncList->GetFunction( j );
2214 if ( pDesc->nFIndex == nId && pDesc->pFuncName )
2215 {
2216 InsertEntry( *pDesc->pFuncName );
2217 if (aFirstName.isEmpty())
2218 aFirstName = *pDesc->pFuncName;
2219 break; // nicht weitersuchen
2220 }
2221 }
2222 }
2223 }
2224
2225 //! Eintrag "Andere..." fuer Funktions-Autopilot wieder aufnehmen,
2226 //! wenn der Funktions-Autopilot mit dem bisher eingegebenen Text arbeiten kann!
2227
2228 // InsertEntry( ScGlobal::GetRscString(STR_FUNCTIONLIST_MORE) );
2229
2230 SetText(aFirstName);
2231 }
2232
2233 void ScPosWnd::Notify( SfxBroadcaster&, const SfxHint& rHint )
2234 {
2235 if ( !bFormulaMode )
2236 {
2237 // muss die Liste der Bereichsnamen updgedated werden?
2238
2239 if ( rHint.ISA(SfxSimpleHint) )
2240 {
2241 sal_uLong nHintId = ((SfxSimpleHint&)rHint).GetId();
2242 if ( nHintId == SC_HINT_AREAS_CHANGED || nHintId == SC_HINT_NAVIGATOR_UPDATEALL)
2243 FillRangeNames();
2244 }
2245 else if ( rHint.ISA(SfxEventHint) )
2246 {
2247 sal_uLong nEventId = ((SfxEventHint&)rHint).GetEventId();
2248 if ( nEventId == SFX_EVENT_ACTIVATEDOC )
2249 FillRangeNames();
2250 }
2251 }
2252 }
2253
2254 void ScPosWnd::HideTip()
2255 {
2256 if ( nTipVisible )
2257 {
2258 Help::HideTip( nTipVisible );
2259 nTipVisible = 0;
2260 }
2261 }
2262
2263 static ScNameInputType lcl_GetInputType( const OUString& rText )
2264 {
2265 ScNameInputType eRet = SC_NAME_INPUT_BAD_NAME; // the more general error
2266
2267 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
2268 if ( pViewSh )
2269 {
2270 ScViewData* pViewData = pViewSh->GetViewData();
2271 ScDocument* pDoc = pViewData->GetDocument();
2272 SCTAB nTab = pViewData->GetTabNo();
2273 formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
2274
2275 // test in same order as in SID_CURRENTCELL execute
2276
2277 ScRange aRange;
2278 ScAddress aAddress;
2279 ScRangeUtil aRangeUtil;
2280 SCTAB nNameTab;
2281 sal_Int32 nNumeric;
2282
2283 if (rText == ScGlobal::GetRscString(STR_MANAGE_NAMES))
2284 eRet = SC_MANAGE_NAMES;
2285 else if ( aRange.Parse( rText, pDoc, eConv ) & SCA_VALID )
2286 eRet = SC_NAME_INPUT_RANGE;
2287 else if ( aAddress.Parse( rText, pDoc, eConv ) & SCA_VALID )
2288 eRet = SC_NAME_INPUT_CELL;
2289 else if ( aRangeUtil.MakeRangeFromName( rText, pDoc, nTab, aRange, RUTL_NAMES, eConv ) )
2290 eRet = SC_NAME_INPUT_NAMEDRANGE;
2291 else if ( aRangeUtil.MakeRangeFromName( rText, pDoc, nTab, aRange, RUTL_DBASE, eConv ) )
2292 eRet = SC_NAME_INPUT_DATABASE;
2293 else if ( comphelper::string::isdigitAsciiString( rText ) &&
2294 ( nNumeric = rText.toInt32() ) > 0 && nNumeric <= MAXROW+1 )
2295 eRet = SC_NAME_INPUT_ROW;
2296 else if ( pDoc->GetTable( rText, nNameTab ) )
2297 eRet = SC_NAME_INPUT_SHEET;
2298 else if ( ScRangeData::IsNameValid( rText, pDoc ) ) // nothing found, create new range?
2299 {
2300 if ( pViewData->GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
2301 eRet = SC_NAME_INPUT_DEFINE;
2302 else
2303 eRet = SC_NAME_INPUT_BAD_SELECTION;
2304 }
2305 else
2306 eRet = SC_NAME_INPUT_BAD_NAME;
2307 }
2308
2309 return eRet;
2310 }
2311
2312 void ScPosWnd::Modify()
2313 {
2314 ComboBox::Modify();
2315
2316 HideTip();
2317
2318 if ( !IsTravelSelect() && !bFormulaMode )
2319 {
2320 // determine the action that would be taken for the current input
2321
2322 ScNameInputType eType = lcl_GetInputType( GetText() ); // uses current view
2323 sal_uInt16 nStrId = 0;
2324 switch ( eType )
2325 {
2326 case SC_NAME_INPUT_CELL:
2327 nStrId = STR_NAME_INPUT_CELL;
2328 break;
2329 case SC_NAME_INPUT_RANGE:
2330 case SC_NAME_INPUT_NAMEDRANGE:
2331 nStrId = STR_NAME_INPUT_RANGE; // named range or range reference
2332 break;
2333 case SC_NAME_INPUT_DATABASE:
2334 nStrId = STR_NAME_INPUT_DBRANGE;
2335 break;
2336 case SC_NAME_INPUT_ROW:
2337 nStrId = STR_NAME_INPUT_ROW;
2338 break;
2339 case SC_NAME_INPUT_SHEET:
2340 nStrId = STR_NAME_INPUT_SHEET;
2341 break;
2342 case SC_NAME_INPUT_DEFINE:
2343 nStrId = STR_NAME_INPUT_DEFINE;
2344 break;
2345 default:
2346 // other cases (error): no tip help
2347 break;
2348 }
2349
2350 if ( nStrId )
2351 {
2352 // show the help tip at the text cursor position
2353
2354 Window* pWin = GetSubEdit();
2355 if (!pWin)
2356 pWin = this;
2357 Point aPos;
2358 Cursor* pCur = pWin->GetCursor();
2359 if (pCur)
2360 aPos = pWin->LogicToPixel( pCur->GetPos() );
2361 aPos = pWin->OutputToScreenPixel( aPos );
2362 Rectangle aRect( aPos, aPos );
2363
2364 OUString aText = ScGlobal::GetRscString( nStrId );
2365 sal_uInt16 nAlign = QUICKHELP_LEFT|QUICKHELP_BOTTOM;
2366 nTipVisible = Help::ShowTip(pWin, aRect, aText, nAlign);
2367 }
2368 }
2369 }
2370
2371 void ScPosWnd::Select()
2372 {
2373 ComboBox::Select(); // in VCL gibt GetText() erst danach den ausgewaehlten Eintrag
2374
2375 HideTip();
2376
2377 if (!IsTravelSelect())
2378 DoEnter();
2379 }
2380
2381 void ScPosWnd::DoEnter()
2382 {
2383 OUString aText = GetText();
2384 if ( !aText.isEmpty() )
2385 {
2386 if ( bFormulaMode )
2387 {
2388 ScModule* pScMod = SC_MOD();
2389 if ( aText == ScGlobal::GetRscString(STR_FUNCTIONLIST_MORE) )
2390 {
2391 // Funktions-Autopilot
2392 //! mit dem bisher eingegebenen Text weiterarbeiten !!!
2393
2394 //! new method at ScModule to query if function autopilot is open
2395 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
2396 if ( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) )
2397 pViewFrm->GetDispatcher()->Execute( SID_OPENDLG_FUNCTION,
2398 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD );
2399 }
2400 else
2401 {
2402 ScTabViewShell* pViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
2403 ScInputHandler* pHdl = pScMod->GetInputHdl( pViewSh );
2404 if (pHdl)
2405 pHdl->InsertFunction( aText );
2406 }
2407 }
2408 else
2409 {
2410 // depending on the input, select something or create a new named range
2411
2412 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
2413 if ( pViewSh )
2414 {
2415 ScViewData* pViewData = pViewSh->GetViewData();
2416 ScDocShell* pDocShell = pViewData->GetDocShell();
2417 ScDocument* pDoc = pDocShell->GetDocument();
2418
2419 ScNameInputType eType = lcl_GetInputType( aText );
2420 if ( eType == SC_NAME_INPUT_BAD_NAME || eType == SC_NAME_INPUT_BAD_SELECTION )
2421 {
2422 sal_uInt16 nId = ( eType == SC_NAME_INPUT_BAD_NAME ) ? STR_NAME_ERROR_NAME : STR_NAME_ERROR_SELECTION;
2423 pViewSh->ErrorMessage( nId );
2424 }
2425 else if ( eType == SC_NAME_INPUT_DEFINE )
2426 {
2427 ScRangeName* pNames = pDoc->GetRangeName();
2428 ScRange aSelection;
2429 if ( pNames && !pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aText)) &&
2430 (pViewData->GetSimpleArea( aSelection ) == SC_MARK_SIMPLE) )
2431 {
2432 ScRangeName aNewRanges( *pNames );
2433 ScAddress aCursor( pViewData->GetCurX(), pViewData->GetCurY(), pViewData->GetTabNo() );
2434 OUString aContent(aSelection.Format(SCR_ABS_3D, pDoc, pDoc->GetAddressConvention()));
2435 ScRangeData* pNew = new ScRangeData( pDoc, aText, aContent, aCursor );
2436 if ( aNewRanges.insert(pNew) )
2437 {
2438 pDocShell->GetDocFunc().ModifyRangeNames( aNewRanges );
2439 pViewSh->UpdateInputHandler(true);
2440 }
2441 }
2442 }
2443 else if (eType == SC_MANAGE_NAMES)
2444 {
2445 sal_uInt16 nId = ScNameDlgWrapper::GetChildWindowId();
2446 SfxViewFrame* pViewFrm = pViewSh->GetViewFrame();
2447 SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );
2448
2449 SC_MOD()->SetRefDialog( nId, pWnd ? false : sal_True );
2450 }
2451 else
2452 {
2453 // for all selection types, excecute the SID_CURRENTCELL slot.
2454 if (eType == SC_NAME_INPUT_CELL || eType == SC_NAME_INPUT_RANGE)
2455 {
2456 // Note that SID_CURRENTCELL always expects address to
2457 // be in Calc A1 format. Convert the text.
2458 ScRange aRange(0,0,pViewData->GetTabNo());
2459 aRange.ParseAny(aText, pDoc, pDoc->GetAddressConvention());
2460 aText = aRange.Format(SCR_ABS_3D, pDoc, ::formula::FormulaGrammar::CONV_OOO);
2461 }
2462
2463 SfxStringItem aPosItem( SID_CURRENTCELL, aText );
2464 SfxBoolItem aUnmarkItem( FN_PARAM_1, true ); // remove existing selection
2465
2466 pViewSh->GetViewData()->GetDispatcher().Execute( SID_CURRENTCELL,
2467 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD,
2468 &aPosItem, &aUnmarkItem, 0L );
2469 }
2470 }
2471 }
2472 }
2473 else
2474 SetText( aPosStr );
2475
2476 ReleaseFocus_Impl();
2477 }
2478
2479 bool ScPosWnd::Notify( NotifyEvent& rNEvt )
2480 {
2481 bool bHandled = true;
2482
2483 switch (rNEvt.GetType())
2484 {
2485 case EVENT_KEYINPUT:
2486 {
2487 const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
2488
2489 switch ( pKEvt->GetKeyCode().GetCode() )
2490 {
2491 case KEY_RETURN:
2492 DoEnter();
2493 break;
2494
2495 case KEY_ESCAPE:
2496 if (nTipVisible)
2497 {
2498 // escape when the tip help is shown: only hide the tip
2499 HideTip();
2500 }
2501 else
2502 {
2503 if (!bFormulaMode)
2504 SetText( aPosStr );
2505 ReleaseFocus_Impl();
2506 }
2507 break;
2508 }
2509 }
2510 break;
2511 case EVENT_GETFOCUS:
2512 {
2513 // Select the whole text upon focus.
2514 OUString aStr = GetText();
2515 SetSelection(Selection(0, aStr.getLength()));
2516 }
2517 break;
2518 case EVENT_LOSEFOCUS:
2519 HideTip();
2520 bHandled = false;
2521 break;
2522 default:
2523 bHandled = false;
2524 }
2525
2526 if (!bHandled)
2527 bHandled = ComboBox::Notify(rNEvt);
2528
2529 return bHandled;
2530 }
2531
2532 void ScPosWnd::ReleaseFocus_Impl()
2533 {
2534 HideTip();
2535
2536 SfxViewShell* pCurSh = SfxViewShell::Current();
2537 ScInputHandler* pHdl = SC_MOD()->GetInputHdl( PTR_CAST( ScTabViewShell, pCurSh ) );
2538 if ( pHdl && pHdl->IsTopMode() )
2539 {
2540 // Focus wieder in die Eingabezeile?
2541
2542 ScInputWindow* pInputWin = pHdl->GetInputWindow();
2543 if (pInputWin)
2544 {
2545 pInputWin->TextGrabFocus();
2546 return;
2547 }
2548 }
2549
2550 // Focus auf die aktive View
2551
2552 if ( pCurSh )
2553 {
2554 Window* pShellWnd = pCurSh->GetWindow();
2555
2556 if ( pShellWnd )
2557 pShellWnd->GrabFocus();
2558 }
2559 }
2560
2561
2562
2563
2564 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE