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 <comphelper/string.hxx>
21 : #include <editeng/editview.hxx>
22 : #include <sfx2/bindings.hxx>
23 : #include <sfx2/dispatch.hxx>
24 : #include <sfx2/objsh.hxx>
25 : #include <sfx2/viewsh.hxx>
26 :
27 : #include "sc.hrc"
28 : #include "global.hxx"
29 : #include "scresid.hxx"
30 : #include "reffact.hxx"
31 : #include "document.hxx"
32 : #include "formulacell.hxx"
33 : #include "scmod.hxx"
34 : #include "inputhdl.hxx"
35 : #include "tabvwsh.hxx"
36 : #include "appoptio.hxx"
37 : #include "compiler.hxx"
38 :
39 : #include "dwfunctr.hrc"
40 : #include "dwfunctr.hxx"
41 :
42 104 : SFX_IMPL_DOCKINGWINDOW_WITHID( ScFunctionChildWindow, FID_FUNCTION_BOX )
43 :
44 : /*************************************************************************
45 : #* Member: ScFunctionChildWindow
46 : #*------------------------------------------------------------------------
47 : #*
48 : #* Klasse: ScFunctionChildWindow
49 : #*
50 : #* Funktion: Konstruktor der Klasse ScFunctionChildWindow
51 : #* Ableitung vom SfxChildWindow als "Behaelter" fuer
52 : #* Funktions- Fenster in Clac
53 : #*
54 : #* Input: ---
55 : #*
56 : #* Output: ---
57 : #*
58 : #************************************************************************/
59 :
60 0 : ScFunctionChildWindow::ScFunctionChildWindow( vcl::Window* pParentP,
61 : sal_uInt16 nId,
62 : SfxBindings* pBindings,
63 : SfxChildWinInfo* pInfo ) :
64 0 : SfxChildWindow( pParentP, nId )
65 : {
66 : VclPtr<ScFunctionDockWin> pWin = VclPtr<ScFunctionDockWin>::Create( pBindings, this,
67 0 : pParentP, ScResId( FID_FUNCTION_BOX ) );
68 0 : pWindow = pWin;
69 :
70 0 : eChildAlignment = SfxChildAlignment::RIGHT;
71 :
72 0 : pWin->Initialize( pInfo );
73 0 : }
74 :
75 : /*************************************************************************
76 : #* Member: ScFunctionDockWin
77 : #*------------------------------------------------------------------------
78 : #*
79 : #* Klasse: ScFunctionDockWin
80 : #*
81 : #* Funktion: Konstruktor der Klasse ScFunctionDockWin
82 : #*
83 : #* Input: Sfx- Verknuepfungen, Fenster, Resource
84 : #*
85 : #* Output: ---
86 : #*
87 : #************************************************************************/
88 :
89 0 : ScFunctionDockWin::ScFunctionDockWin( SfxBindings* pBindingsP,
90 : SfxChildWindow *pCW, vcl::Window* pParent, const ResId& rResId ) :
91 :
92 : SfxDockingWindow( pBindingsP, pCW, pParent, rResId ),
93 0 : aPrivatSplit ( VclPtr<ScPrivatSplit>::Create( this, ResId( FT_SPLIT, *rResId.GetResMgr() ),SC_SPLIT_VERT) ),
94 0 : aCatBox ( VclPtr<ListBox>::Create( this, ResId( CB_CAT, *rResId.GetResMgr() ) ) ),
95 0 : aFuncList ( VclPtr<ListBox>::Create( this, ResId( LB_FUNC, *rResId.GetResMgr() ) ) ),
96 0 : aDDFuncList ( VclPtr<ListBox>::Create( this, ResId( DDLB_FUNC, *rResId.GetResMgr() ) ) ),
97 0 : aInsertButton ( VclPtr<ImageButton>::Create( this, ResId( IMB_INSERT, *rResId.GetResMgr() ) ) ),
98 0 : aFiFuncDesc ( VclPtr<FixedText>::Create( this, ResId( FI_FUNCDESC, *rResId.GetResMgr() ) ) ),
99 : aOldSize (0,0),
100 0 : pFuncDesc (NULL)
101 : {
102 0 : FreeResource();
103 0 : InitLRUList();
104 0 : SetStyle(GetStyle()|WB_CLIPCHILDREN);
105 :
106 0 : aIdle.SetPriority(SchedulerPriority::LOWER);
107 0 : aIdle.SetIdleHdl(LINK( this, ScFunctionDockWin, TimerHdl));
108 :
109 0 : if (pCW != NULL)
110 0 : eSfxNewAlignment=GetAlignment();
111 : else
112 0 : eSfxNewAlignment=SfxChildAlignment::RIGHT;
113 0 : eSfxOldAlignment=eSfxNewAlignment;
114 0 : aFiFuncDesc->SetUpdateMode(true);
115 0 : pAllFuncList=aFuncList.get();
116 0 : aDDFuncList->Disable();
117 0 : aDDFuncList->Hide();
118 0 : nArgs=0;
119 0 : nDockMode=0;
120 0 : bSizeFlag=false;
121 0 : aCatBox->SetDropDownLineCount(9);
122 0 : vcl::Font aFont=aFiFuncDesc->GetFont();
123 0 : aFont.SetColor(Color(COL_BLACK));
124 0 : aFiFuncDesc->SetFont(aFont);
125 0 : aFiFuncDesc->SetBackground( GetBackground() ); //! never transparent?
126 :
127 0 : Link<> aLink=LINK( this, ScFunctionDockWin, SelHdl);
128 0 : aCatBox->SetSelectHdl(aLink);
129 0 : aFuncList->SetSelectHdl(aLink);
130 0 : aDDFuncList->SetSelectHdl(aLink);
131 :
132 0 : Link<> a2Link=LINK( this, ScFunctionDockWin, SetSelectionHdl);
133 0 : aFuncList->SetDoubleClickHdl(a2Link);
134 0 : aDDFuncList->SetSelectHdl(aLink);
135 0 : aInsertButton->SetClickHdl(a2Link);
136 :
137 0 : Link<> a3Link=LINK( this, ScFunctionDockWin, SetSplitHdl);
138 0 : aPrivatSplit->SetCtrModifiedHdl(a3Link);
139 0 : StartListening( *pBindingsP, true );
140 :
141 0 : Point aTopLeft=aCatBox->GetPosPixel();
142 0 : OUString aString("ww");
143 0 : Size aTxtSize( aFiFuncDesc->GetTextWidth(aString), aFiFuncDesc->GetTextHeight() );
144 0 : nMinWidth=aTxtSize.Width()+aTopLeft.X()
145 0 : +2*aFuncList->GetPosPixel().X();
146 0 : nMinHeight=19*aTxtSize.Height();
147 0 : aCatBox->SelectEntryPos(0);
148 :
149 0 : Range aYRange(3*aTxtSize.Height()+aFuncList->GetPosPixel().Y(),
150 0 : GetOutputSizePixel().Height()-2*aTxtSize.Height());
151 0 : aPrivatSplit->SetYRange(aYRange);
152 0 : SelHdl(aCatBox.get());
153 0 : bInit = true;
154 0 : }
155 :
156 : /*************************************************************************
157 : #* Member: ScFunctionDockWin
158 : #*------------------------------------------------------------------------
159 : #*
160 : #* Klasse: ScFunctionDockWin
161 : #*
162 : #* Funktion: Destruktor der Klasse ScFunctionDockWin
163 : #*
164 : #* Input: ---
165 : #*
166 : #* Output: ---
167 : #*
168 : #************************************************************************/
169 :
170 0 : ScFunctionDockWin::~ScFunctionDockWin()
171 : {
172 0 : disposeOnce();
173 0 : }
174 :
175 0 : void ScFunctionDockWin::dispose()
176 : {
177 0 : EndListening( GetBindings() );
178 0 : aPrivatSplit.disposeAndClear();
179 0 : aCatBox.disposeAndClear();
180 0 : aFuncList.disposeAndClear();
181 0 : aDDFuncList.disposeAndClear();
182 0 : aInsertButton.disposeAndClear();
183 0 : aFiFuncDesc.disposeAndClear();
184 0 : pAllFuncList.clear();
185 0 : SfxDockingWindow::dispose();
186 0 : }
187 :
188 : /*************************************************************************
189 : #* Member: UpdateFunctionList
190 : #*------------------------------------------------------------------------
191 : #*
192 : #* Klasse: ScFunctionDockWin
193 : #*
194 : #* Funktion: Aktualisiert die Liste der Funktionen ab-
195 : #* haengig von der eingestellten Kategorie.
196 : #*
197 : #* Input: ---
198 : #*
199 : #* Output: ---
200 : #*
201 : #************************************************************************/
202 :
203 0 : void ScFunctionDockWin::InitLRUList()
204 : {
205 0 : ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr();
206 0 : pFuncMgr->fillLastRecentlyUsedFunctions(aLRUList);
207 :
208 0 : sal_Int32 nSelPos = aCatBox->GetSelectEntryPos();
209 :
210 0 : if(nSelPos == 0)
211 0 : UpdateFunctionList();
212 0 : }
213 :
214 : /*************************************************************************
215 : #* Member: UpdateFunctionList
216 : #*------------------------------------------------------------------------
217 : #*
218 : #* Klasse: ScFunctionDockWin
219 : #*
220 : #* Funktion: Aktualisiert die Liste der zuletzt verwendeten Funktionen.
221 : #*
222 : #* Input: ---
223 : #*
224 : #* Output: ---
225 : #*
226 : #************************************************************************/
227 :
228 0 : void ScFunctionDockWin::UpdateLRUList()
229 : {
230 0 : if (pFuncDesc && pFuncDesc->nFIndex!=0)
231 : {
232 0 : ScModule* pScMod = SC_MOD();
233 0 : pScMod->InsertEntryToLRUList(pFuncDesc->nFIndex);
234 : }
235 0 : }
236 :
237 : /*************************************************************************
238 : #* Member: SetSize
239 : #*------------------------------------------------------------------------
240 : #*
241 : #* Klasse: ScFunctionDockWin
242 : #*
243 : #* Funktion: Groesse fuer die einzelnen Controls einzustellen.
244 : #*
245 : #* Input: ---
246 : #*
247 : #* Output: ---
248 : #*
249 : #************************************************************************/
250 :
251 0 : void ScFunctionDockWin::SetSize()
252 : {
253 0 : sal_Int32 nSelEntry=0;
254 0 : SfxChildAlignment aChildAlign=eSfxOldAlignment;//GetAlignment();
255 : short nNewDockMode;
256 0 : switch(aChildAlign)
257 : {
258 : case SfxChildAlignment::HIGHESTTOP:
259 : case SfxChildAlignment::TOP:
260 : case SfxChildAlignment::LOWESTTOP:
261 : case SfxChildAlignment::LOWESTBOTTOM:
262 : case SfxChildAlignment::BOTTOM:
263 : case SfxChildAlignment::TOOLBOXTOP:
264 : case SfxChildAlignment::TOOLBOXBOTTOM:
265 :
266 0 : nNewDockMode=1;
267 0 : if(nDockMode!=nNewDockMode)
268 : {
269 0 : nDockMode=nNewDockMode;
270 0 : nSelEntry=aFuncList->GetSelectEntryPos();
271 0 : aFuncList->Clear();
272 0 : aFiFuncDesc->SetPosPixel(aFuncList->GetPosPixel());
273 0 : aDDFuncList->Enable();
274 0 : aDDFuncList->Show();
275 0 : aPrivatSplit->Disable();
276 0 : aPrivatSplit->Hide();
277 0 : aFuncList->Disable();
278 0 : aFuncList->Hide();
279 0 : pAllFuncList=aDDFuncList.get();
280 0 : SelHdl(aCatBox.get());
281 0 : aDDFuncList->SelectEntryPos(nSelEntry);
282 : }
283 0 : break;
284 :
285 0 : default: nNewDockMode=0;
286 0 : if(nDockMode!=nNewDockMode)
287 : {
288 0 : nDockMode=nNewDockMode;
289 0 : nSelEntry=aDDFuncList->GetSelectEntryPos();
290 0 : aDDFuncList->Clear();
291 0 : aDDFuncList->Disable();
292 0 : aDDFuncList->Hide();
293 0 : aPrivatSplit->Enable();
294 0 : aPrivatSplit->Show();
295 0 : aFuncList->Enable();
296 0 : aFuncList->Show();
297 0 : pAllFuncList=aFuncList.get();
298 0 : SelHdl(aCatBox.get());
299 0 : aFuncList->SelectEntryPos(nSelEntry);
300 : }
301 0 : break;
302 : }
303 :
304 0 : if(nDockMode==0)
305 : {
306 0 : SetLeftRightSize();
307 : }
308 : else
309 : {
310 0 : SetTopBottonSize();
311 : }
312 0 : }
313 : /*************************************************************************
314 : #* Member: SetLeftRightSize
315 : #*------------------------------------------------------------------------
316 : #*
317 : #* Klasse: ScFunctionDockWin
318 : #*
319 : #* Funktion: Groesse fuer die einzelnen Controls einstellen,
320 : #* wenn Links oder Rechts angedockt wird.
321 : #*
322 : #* Input: ---
323 : #*
324 : #* Output: ---
325 : #*
326 : #************************************************************************/
327 :
328 0 : void ScFunctionDockWin::SetLeftRightSize()
329 : {
330 0 : if(!bSizeFlag)
331 : {
332 0 : bSizeFlag = true;
333 :
334 0 : Size aDiffSize=GetSizePixel();
335 0 : Size aNewSize=GetOutputSizePixel();
336 0 : aDiffSize.Width()-=aNewSize.Width();
337 0 : aDiffSize.Height()-=aNewSize.Height();
338 :
339 0 : OUString aString("ww");
340 0 : Size aTxtSize( aFuncList->GetTextWidth(aString), aFuncList->GetTextHeight() );
341 :
342 0 : Range aYRange(3*aTxtSize.Height()+aFuncList->GetPosPixel().Y(),
343 0 : GetOutputSizePixel().Height()-2*aTxtSize.Height());
344 0 : aPrivatSplit->SetYRange(aYRange);
345 :
346 0 : if(aOldSize.Width()!=aNewSize.Width())
347 0 : SetMyWidthLeRi(aNewSize);
348 :
349 0 : if(aOldSize.Height()!=aNewSize.Height())
350 0 : SetMyHeightLeRi(aNewSize);
351 :
352 0 : aOldSize=aNewSize;
353 0 : aNewSize.Width()+=aDiffSize.Width();
354 0 : aNewSize.Height()+=aDiffSize.Height();
355 0 : bSizeFlag=false;
356 : }
357 :
358 0 : }
359 : /*************************************************************************
360 : #* Member: SetTopBottonSize
361 : #*------------------------------------------------------------------------
362 : #*
363 : #* Klasse: ScFunctionDockWin
364 : #*
365 : #* Funktion: Groesse fuer die einzelnen Controls einzustellen.
366 : #* wenn oben oder unten angedockt wird.
367 : #*
368 : #* Input: ---
369 : #*
370 : #* Output: ---
371 : #*
372 : #************************************************************************/
373 :
374 0 : void ScFunctionDockWin::SetTopBottonSize()
375 : {
376 0 : if(!bSizeFlag)
377 : {
378 0 : bSizeFlag = true;
379 0 : Size aDiffSize=GetSizePixel();
380 0 : Size aNewSize=GetOutputSizePixel();
381 0 : aDiffSize.Width()-=aNewSize.Width();
382 0 : aDiffSize.Height()-=aNewSize.Height();
383 :
384 0 : SetMyWidthToBo(aNewSize);
385 0 : SetMyHeightToBo(aNewSize);
386 :
387 0 : aNewSize.Width()+=aDiffSize.Width();
388 0 : aNewSize.Height()+=aDiffSize.Height();
389 0 : bSizeFlag=false;
390 : }
391 0 : }
392 :
393 : /*************************************************************************
394 : #* Member: SetMyWidthLeRi
395 : #*------------------------------------------------------------------------
396 : #*
397 : #* Klasse: ScFunctionDockWin
398 : #*
399 : #* Funktion: Breite fuer die einzelnen Controls und
400 : #* das Fenster einstellen,wenn Li oder Re
401 : #*
402 : #* Input: neue Fenstergroesse
403 : #*
404 : #* Output: ---
405 : #*
406 : #************************************************************************/
407 :
408 0 : void ScFunctionDockWin::SetMyWidthLeRi(Size &aNewSize)
409 : {
410 0 : if((sal_uLong)aNewSize.Width()<nMinWidth) aNewSize.Width()=nMinWidth;
411 :
412 0 : Size aCDSize=aCatBox->GetSizePixel();
413 0 : Size aFLSize=aFuncList->GetSizePixel();
414 0 : Size aSplitterSize=aPrivatSplit->GetSizePixel();
415 0 : Size aFDSize=aFiFuncDesc->GetSizePixel();
416 :
417 0 : Point aCDTopLeft=aCatBox->GetPosPixel();
418 0 : Point aFLTopLeft=aFuncList->GetPosPixel();
419 :
420 0 : aCDSize.Width()=aNewSize.Width()-aCDTopLeft.X()-aFLTopLeft.X();
421 0 : aFLSize.Width()=aNewSize.Width()-2*aFLTopLeft.X();
422 0 : aFDSize.Width()=aFLSize.Width();
423 0 : aSplitterSize.Width()=aFLSize.Width();
424 :
425 0 : aCatBox->SetSizePixel(aCDSize);
426 0 : aFuncList->SetSizePixel(aFLSize);
427 0 : aPrivatSplit->SetSizePixel(aSplitterSize);
428 0 : aFiFuncDesc->SetSizePixel(aFDSize);
429 0 : }
430 :
431 : /*************************************************************************
432 : #* Member: SetHeight
433 : #*------------------------------------------------------------------------
434 : #*
435 : #* Klasse: ScFunctionDockWin
436 : #*
437 : #* Funktion: Hoehe fuer die einzelnen Controls und
438 : #* das Fenster einstellen bei Li oder Re
439 : #*
440 : #* Input: neue Fenstergroesse
441 : #*
442 : #* Output: ---
443 : #*
444 : #************************************************************************/
445 :
446 0 : void ScFunctionDockWin::SetMyHeightLeRi(Size &aNewSize)
447 : {
448 0 : if((sal_uLong)aNewSize.Height()<nMinHeight) aNewSize.Height()=nMinHeight;
449 :
450 0 : Size aFLSize=aFuncList->GetSizePixel();
451 0 : Size aSplitterSize=aPrivatSplit->GetSizePixel();
452 0 : Size aFDSize=aFiFuncDesc->GetSizePixel();
453 :
454 0 : Point aFLTopLeft=aFuncList->GetPosPixel();
455 0 : Point aSplitterTopLeft=aPrivatSplit->GetPosPixel();
456 0 : Point aFDTopLeft=aFiFuncDesc->GetPosPixel();
457 :
458 0 : long nTxtHeight = aFuncList->GetTextHeight();
459 :
460 : short nY=(short)(3*nTxtHeight+
461 0 : aFuncList->GetPosPixel().Y()+aSplitterSize.Height());
462 :
463 0 : aFDTopLeft.Y()=aNewSize.Height()-aFDSize.Height()-4;
464 0 : if(nY>aFDTopLeft.Y())
465 : {
466 0 : aFDSize.Height()-=nY-aFDTopLeft.Y();
467 0 : aFDTopLeft.Y()=nY;
468 : }
469 0 : aSplitterTopLeft.Y()=aFDTopLeft.Y()-aSplitterSize.Height()-1;
470 0 : aFLSize.Height()=aSplitterTopLeft.Y()-aFLTopLeft.Y()-1;
471 :
472 0 : aFuncList->SetSizePixel(aFLSize);
473 0 : aPrivatSplit->SetPosPixel(aSplitterTopLeft);
474 0 : aFiFuncDesc->SetPosPixel(aFDTopLeft);
475 0 : aFiFuncDesc->SetSizePixel(aFDSize);
476 :
477 0 : }
478 :
479 : /*************************************************************************
480 : #* Member: SetMyWidthToBo
481 : #*------------------------------------------------------------------------
482 : #*
483 : #* Klasse: ScFunctionDockWin
484 : #*
485 : #* Funktion: Breite fuer die einzelnen Controls und
486 : #* das Fenster einstellen, wenn oben oder
487 : #* unten angedockt werden soll.
488 : #*
489 : #* Input: neue Fenstergroesse
490 : #*
491 : #* Output: ---
492 : #*
493 : #************************************************************************/
494 :
495 0 : void ScFunctionDockWin::SetMyWidthToBo(Size &aNewSize)
496 : {
497 0 : if((sal_uLong)aNewSize.Width()<nMinWidth) aNewSize.Width()=nMinWidth;
498 :
499 0 : Size aCDSize=aCatBox->GetSizePixel();
500 0 : Size aDdFLSize=aDDFuncList->GetSizePixel();
501 0 : Size aFDSize=aFiFuncDesc->GetSizePixel();
502 :
503 0 : Point aCDTopLeft=aCatBox->GetPosPixel();
504 0 : Point aDdFLTopLeft=aDDFuncList->GetPosPixel();
505 0 : Point aFDTopLeft=aFiFuncDesc->GetPosPixel();
506 :
507 0 : aCDSize.Width()=aDdFLTopLeft.X()-aFDTopLeft.X()-aCDTopLeft.X();
508 0 : aDdFLTopLeft.X()=aCDSize.Width()+aCDTopLeft.X()+aFDTopLeft.X();
509 :
510 0 : aDdFLSize.Width()=aNewSize.Width()-aDdFLTopLeft.X()-aFDTopLeft.X();
511 :
512 0 : aFDSize.Width()=aNewSize.Width()-2*aFDTopLeft.X();
513 :
514 0 : aDDFuncList->SetPosPixel(aDdFLTopLeft);
515 0 : aDDFuncList->SetSizePixel(aDdFLSize);
516 0 : aCatBox->SetSizePixel(aCDSize);
517 0 : aFiFuncDesc->SetSizePixel(aFDSize);
518 0 : }
519 :
520 : /*************************************************************************
521 : #* Member: SetHeight
522 : #*------------------------------------------------------------------------
523 : #*
524 : #* Klasse: ScFunctionDockWin
525 : #*
526 : #* Funktion: Hoehe fuer die einzelnen Controls und
527 : #* das Fenster einstellen, wenn oben oder
528 : #* unten angedockt werden soll.
529 : #*
530 : #* Input: neue Fenstergroesse
531 : #*
532 : #* Output: ---
533 : #*
534 : #************************************************************************/
535 :
536 0 : void ScFunctionDockWin::SetMyHeightToBo(Size &aNewSize)
537 : {
538 0 : if((sal_uLong)aNewSize.Height()<nMinHeight) aNewSize.Height()=nMinHeight;
539 :
540 0 : Size aFDSize=aFiFuncDesc->GetSizePixel();
541 :
542 0 : Point aFDTopLeft=aFiFuncDesc->GetPosPixel();
543 0 : Point aCBTopLeft=aCatBox->GetPosPixel();
544 0 : aFDSize.Height()=aNewSize.Height()-aFDTopLeft.Y()-aCBTopLeft.Y();
545 0 : aFiFuncDesc->SetSizePixel(aFDSize);
546 :
547 0 : }
548 :
549 : /*************************************************************************
550 : #* Member: SetDescription
551 : #*------------------------------------------------------------------------
552 : #*
553 : #* Klasse: ScFunctionDockWin
554 : #*
555 : #* Funktion: Erklaerungstext fuer die Funktion einstellen.
556 : #*
557 : #* Input: ---
558 : #*
559 : #* Output: ---
560 : #*
561 : #************************************************************************/
562 :
563 0 : void ScFunctionDockWin::SetDescription()
564 : {
565 0 : aFiFuncDesc->SetText( EMPTY_OUSTRING );
566 : const ScFuncDesc* pDesc =
567 : static_cast<const ScFuncDesc*>(pAllFuncList->GetEntryData(
568 0 : pAllFuncList->GetSelectEntryPos() ));
569 0 : if (pDesc)
570 : {
571 0 : pDesc->initArgumentInfo(); // full argument info is needed
572 :
573 0 : OUStringBuffer aBuf(pAllFuncList->GetSelectEntry());
574 0 : if(nDockMode==0)
575 : {
576 0 : aBuf.appendAscii(":\n\n");
577 : }
578 : else
579 : {
580 0 : aBuf.appendAscii(": ");
581 : }
582 :
583 0 : aBuf.append(pDesc->GetParamList());
584 :
585 0 : if(nDockMode==0)
586 : {
587 0 : aBuf.appendAscii("\n\n");
588 : }
589 : else
590 : {
591 0 : aBuf.appendAscii("\n");
592 : }
593 :
594 0 : aBuf.append(*pDesc->pFuncDesc);
595 :
596 0 : aFiFuncDesc->SetText(aBuf.makeStringAndClear());
597 0 : aFiFuncDesc->StateChanged(StateChangedType::Text);
598 0 : aFiFuncDesc->Invalidate();
599 0 : aFiFuncDesc->Update();
600 :
601 : }
602 0 : }
603 :
604 : /// override to set new size of the controls
605 0 : void ScFunctionDockWin::Resizing( Size& rNewSize )
606 : {
607 0 : if((sal_uLong)rNewSize.Width()<nMinWidth) rNewSize.Width()=nMinWidth;
608 0 : if((sal_uLong)rNewSize.Height()<nMinHeight) rNewSize.Height()=nMinHeight;
609 :
610 0 : }
611 :
612 : /*************************************************************************
613 : #* Member: Close
614 : #*------------------------------------------------------------------------
615 : #*
616 : #* Klasse: ScFunctionDockWin
617 : #*
618 : #* Funktion: Schliessen des Fensters
619 : #*
620 : #* Input: ---
621 : #*
622 : #* Output: TRUE
623 : #*
624 : #************************************************************************/
625 :
626 0 : bool ScFunctionDockWin::Close()
627 : {
628 0 : SfxBoolItem aItem( FID_FUNCTION_BOX, false );
629 :
630 0 : GetBindings().GetDispatcher()->Execute( FID_FUNCTION_BOX,
631 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
632 0 : &aItem, 0L );
633 :
634 0 : SfxDockingWindow::Close();
635 :
636 0 : return true;
637 : }
638 :
639 : /*************************************************************************
640 : #* Member: CheckAlignment
641 : #*------------------------------------------------------------------------
642 : #*
643 : #* Klasse: ScFunctionDockWin
644 : #*
645 : #* Funktion: Ueberprueft den Andockmodus und stellt die
646 : #* Groessen dementsprechend ein.
647 : #*
648 : #* Input: Das neue Alignment
649 : #*
650 : #* Output: Das uebergebene Alignment
651 : #*
652 : #************************************************************************/
653 0 : SfxChildAlignment ScFunctionDockWin::CheckAlignment(SfxChildAlignment /* abla */,
654 : SfxChildAlignment aChildAlign)
655 : {
656 0 : OUString aString("ww");
657 0 : Size aTxtSize( aFiFuncDesc->GetTextWidth(aString), aFiFuncDesc->GetTextHeight() );
658 0 : if(!bInit)
659 : {
660 0 : eSfxOldAlignment=eSfxNewAlignment;
661 0 : eSfxNewAlignment=aChildAlign;
662 : }
663 : else
664 : {
665 0 : bInit=false;
666 0 : eSfxOldAlignment=aChildAlign;
667 0 : eSfxNewAlignment=aChildAlign;
668 : }
669 :
670 0 : switch(eSfxOldAlignment)
671 : {
672 : case SfxChildAlignment::HIGHESTTOP:
673 : case SfxChildAlignment::TOP:
674 : case SfxChildAlignment::LOWESTTOP:
675 : case SfxChildAlignment::LOWESTBOTTOM:
676 : case SfxChildAlignment::BOTTOM:
677 : case SfxChildAlignment::TOOLBOXTOP:
678 : case SfxChildAlignment::TOOLBOXBOTTOM:
679 :
680 0 : nMinWidth= 0;
681 0 : nMinHeight=0;
682 :
683 0 : break;
684 :
685 : case SfxChildAlignment::NOALIGNMENT:
686 :
687 0 : aString = aCatBox->GetEntry(0);
688 0 : aString += "www";
689 0 : aTxtSize = Size( aFiFuncDesc->GetTextWidth(aString),
690 0 : aFiFuncDesc->GetTextHeight() );
691 : // fall-through
692 0 : default: Point aTopLeft=aCatBox->GetPosPixel();
693 0 : nMinWidth=aTxtSize.Width()+aTopLeft.X()
694 0 : +2*aFuncList->GetPosPixel().X();
695 0 : nMinHeight=19*aTxtSize.Height();
696 :
697 0 : break;
698 : }
699 :
700 0 : return aChildAlign;
701 : }
702 : /*************************************************************************
703 : #* Member: Close
704 : #*------------------------------------------------------------------------
705 : #*
706 : #* Klasse: ScFunctionDockWin
707 : #*
708 : #* Funktion: Aenderungen erkennen
709 : #*
710 : #* Input: ---
711 : #*
712 : #* Output: TRUE
713 : #*
714 : #************************************************************************/
715 0 : void ScFunctionDockWin::Notify( SfxBroadcaster&, const SfxHint& /* rHint */ )
716 : {
717 0 : }
718 :
719 : /// override to set new size of the controls
720 0 : void ScFunctionDockWin::Resize()
721 : {
722 0 : if ( !IsFloatingMode() ||
723 0 : !GetFloatingWindow()->IsRollUp() )
724 : {
725 0 : Size aQSize=GetOutputSizePixel();
726 0 : Resizing( aQSize);
727 0 : SetSize();
728 : }
729 0 : SfxDockingWindow::Resize();
730 0 : }
731 :
732 : /*************************************************************************
733 : #* Member: UpdateFunctionList
734 : #*------------------------------------------------------------------------
735 : #*
736 : #* Klasse: ScFunctionDockWin
737 : #*
738 : #* Funktion: Aktualisiert die Liste der Funktionen ab-
739 : #* haengig von der eingestellten Kategorie.
740 : #*
741 : #* Input: ---
742 : #*
743 : #* Output: ---
744 : #*
745 : #************************************************************************/
746 :
747 0 : void ScFunctionDockWin::UpdateFunctionList()
748 : {
749 0 : sal_Int32 nSelPos = aCatBox->GetSelectEntryPos();
750 : sal_Int32 nCategory = ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
751 0 : ? (nSelPos-1) : 0;
752 :
753 0 : pAllFuncList->Clear();
754 0 : pAllFuncList->SetUpdateMode( false );
755 :
756 0 : if ( nSelPos > 0 )
757 : {
758 0 : ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr();
759 :
760 0 : const ScFuncDesc* pDesc = pFuncMgr->First( nCategory );
761 0 : while ( pDesc )
762 : {
763 : pAllFuncList->SetEntryData(
764 : pAllFuncList->InsertEntry( *(pDesc->pFuncName) ),
765 0 : const_cast<ScFuncDesc *>(pDesc) );
766 0 : pDesc = pFuncMgr->Next();
767 : }
768 : }
769 : else // LRU-Liste
770 : {
771 0 : for (::std::vector<const formula::IFunctionDescription*>::iterator iter=aLRUList.begin();
772 0 : iter != aLRUList.end(); ++iter)
773 : {
774 0 : const formula::IFunctionDescription* pDesc = *iter;
775 0 : if (pDesc)
776 0 : pAllFuncList->SetEntryData( pAllFuncList->InsertEntry( pDesc->getFunctionName()), const_cast<formula::IFunctionDescription *>(pDesc));
777 : }
778 : }
779 :
780 0 : pAllFuncList->SetUpdateMode( true );
781 :
782 0 : if ( pAllFuncList->GetEntryCount() > 0 )
783 : {
784 0 : pAllFuncList->Enable();
785 0 : pAllFuncList->SelectEntryPos( 0 );
786 : }
787 : else
788 : {
789 0 : pAllFuncList->Disable();
790 : }
791 0 : }
792 :
793 : /*************************************************************************
794 : #* Member: DoEnter
795 : #*------------------------------------------------------------------------
796 : #*
797 : #* Klasse: ScFunctionDockWin
798 : #*
799 : #* Funktion: Eingabe ins Dokument uebernehmen. Wird aufgerufen
800 : #* nach betaetigen der Uebernehmen- Schaltflaeche
801 : #* oder einem Doppelklick in die Funktionsliste.
802 : #*
803 : #* Input: ---
804 : #*
805 : #* Output: ---
806 : #*
807 : #************************************************************************/
808 :
809 0 : void ScFunctionDockWin::DoEnter()
810 : {
811 0 : OUString aFirstArgStr;
812 0 : OUString aArgStr;
813 0 : OUString aString=pAllFuncList->GetSelectEntry();
814 0 : SfxViewShell* pCurSh = SfxViewShell::Current();
815 0 : nArgs=0;
816 :
817 0 : if(!aString.isEmpty())
818 : {
819 :
820 0 : ScModule* pScMod = SC_MOD();
821 0 : ScTabViewShell* pViewSh = PTR_CAST( ScTabViewShell, pCurSh);
822 0 : ScInputHandler* pHdl = pScMod->GetInputHdl( pViewSh );
823 0 : if(!pScMod->IsEditMode())
824 : {
825 0 : pScMod->SetInputMode(SC_INPUT_TABLE);
826 0 : aString = "=";
827 0 : aString += pAllFuncList->GetSelectEntry();
828 0 : if (pHdl)
829 0 : pHdl->ClearText();
830 : }
831 : const ScFuncDesc* pDesc =
832 : static_cast<const ScFuncDesc*>(pAllFuncList->GetEntryData(
833 0 : pAllFuncList->GetSelectEntryPos() ));
834 0 : if (pDesc)
835 : {
836 0 : pFuncDesc=pDesc;
837 0 : UpdateLRUList();
838 0 : nArgs = pDesc->nArgCount;
839 0 : if(nArgs>0)
840 : {
841 : // NOTE: Theoretically the first parameter could have the
842 : // suppress flag as well, but practically it doesn't.
843 0 : aFirstArgStr = pDesc->maDefArgNames[0];
844 0 : aFirstArgStr = comphelper::string::strip(aFirstArgStr, ' ');
845 0 : aFirstArgStr = aFirstArgStr.replaceAll(" ", "_");
846 0 : aArgStr = aFirstArgStr;
847 0 : if ( nArgs != VAR_ARGS && nArgs != PAIRED_VAR_ARGS )
848 : { // no VarArgs or Fix plus VarArgs, but not VarArgs only
849 0 : OUString aArgSep("; ");
850 : sal_uInt16 nFix;
851 0 : if (nArgs >= PAIRED_VAR_ARGS)
852 0 : nFix = nArgs - PAIRED_VAR_ARGS + 2;
853 0 : else if (nArgs >= VAR_ARGS)
854 0 : nFix = nArgs - VAR_ARGS + 1;
855 : else
856 0 : nFix = nArgs;
857 0 : for ( sal_uInt16 nArg = 1;
858 0 : nArg < nFix && !pDesc->pDefArgFlags[nArg].bOptional; nArg++ )
859 : {
860 0 : if (!pDesc->pDefArgFlags[nArg].bSuppress)
861 : {
862 0 : aArgStr += aArgSep;
863 0 : OUString sTmp = pDesc->maDefArgNames[nArg];
864 0 : sTmp = comphelper::string::strip(sTmp, ' ');
865 0 : sTmp = sTmp.replaceAll(" ", "_");
866 0 : aArgStr += sTmp;
867 : }
868 0 : }
869 : }
870 : }
871 : }
872 0 : if (pHdl)
873 : {
874 0 : if (pHdl->GetEditString().isEmpty())
875 : {
876 0 : aString = "=";
877 0 : aString += pAllFuncList->GetSelectEntry();
878 : }
879 0 : EditView *pEdView=pHdl->GetActiveView();
880 0 : if(pEdView!=NULL) // @ Wegen Absturz bei Namen festlegen
881 : {
882 0 : if(nArgs>0)
883 : {
884 0 : pHdl->InsertFunction(aString);
885 0 : pEdView->InsertText(aArgStr,true);
886 0 : ESelection aESel=pEdView->GetSelection();
887 0 : aESel.nEndPos = aESel.nStartPos + aFirstArgStr.getLength();
888 0 : pEdView->SetSelection(aESel);
889 0 : pHdl->DataChanged();
890 : }
891 : else
892 : {
893 0 : aString += "()";
894 0 : pEdView->InsertText(aString,false);
895 0 : pHdl->DataChanged();
896 : }
897 : }
898 : }
899 0 : InitLRUList();
900 : }
901 0 : if ( pCurSh )
902 : {
903 0 : vcl::Window* pShellWnd = pCurSh->GetWindow();
904 :
905 0 : if ( pShellWnd )
906 0 : pShellWnd->GrabFocus();
907 0 : }
908 :
909 0 : }
910 :
911 : /*************************************************************************
912 : #* Handle: SelHdl
913 : #*------------------------------------------------------------------------
914 : #*
915 : #* Klasse: ScFunctionDockWin
916 : #*
917 : #* Funktion: Bei einer Aenderung der Kategorie wird die
918 : #* die Liste der Funktionen aktualisiert.
919 : #*
920 : #* Input: ---
921 : #*
922 : #* Output: ---
923 : #*
924 : #************************************************************************/
925 :
926 0 : IMPL_LINK( ScFunctionDockWin, SelHdl, ListBox*, pLb )
927 : {
928 0 : if ( pLb == aCatBox.get() )
929 : {
930 0 : UpdateFunctionList();
931 0 : SetDescription();
932 : }
933 :
934 0 : if ( pLb == aFuncList.get() || pLb == aDDFuncList.get() )
935 : {
936 0 : SetDescription();
937 : }
938 :
939 : //SetSize();
940 0 : return 0;
941 : }
942 :
943 : /*************************************************************************
944 : #* Handle: SelHdl
945 : #*------------------------------------------------------------------------
946 : #*
947 : #* Klasse: ScFunctionDockWin
948 : #*
949 : #* Funktion: Bei einer Aenderung der Kategorie wird die
950 : #* die Liste der Funktionen aktualisiert.
951 : #*
952 : #* Input: ---
953 : #*
954 : #* Output: ---
955 : #*
956 : #************************************************************************/
957 :
958 0 : IMPL_LINK( ScFunctionDockWin, SetSelectionHdl, void*, pCtrl )
959 : {
960 0 : if (static_cast<ImageButton *>(pCtrl) == aInsertButton.get() ||
961 0 : static_cast<ListBox *>(pCtrl) == aFuncList.get())
962 : {
963 0 : DoEnter(); // Uebernimmt die Eingabe
964 : }
965 :
966 0 : return 0;
967 : }
968 :
969 : /*************************************************************************
970 : #* Handle: SetSplitHdl
971 : #*------------------------------------------------------------------------
972 : #*
973 : #* Klasse: ScFunctionDockWin
974 : #*
975 : #* Funktion: Bei einer Aenderung des Split- Controls werden die
976 : #* einzelnen Controls an die neue Groesse angepasst.
977 : #*
978 : #* Input: Zeiger auf Control
979 : #*
980 : #* Output: ---
981 : #*
982 : #************************************************************************/
983 :
984 0 : IMPL_LINK( ScFunctionDockWin, SetSplitHdl, ScPrivatSplit*, pCtrl )
985 : {
986 0 : if (pCtrl == aPrivatSplit.get())
987 : {
988 0 : short nDeltaY=aPrivatSplit->GetDeltaY();
989 0 : Size aFLSize=aFuncList->GetSizePixel();
990 0 : Size aFDSize=aFiFuncDesc->GetSizePixel();
991 0 : Point aFDTopLeft=aFiFuncDesc->GetPosPixel();
992 :
993 0 : aFLSize.Height()+=nDeltaY;
994 0 : aFDSize.Height()-=nDeltaY;
995 0 : aFDTopLeft.Y()+=nDeltaY;
996 0 : aFuncList->SetSizePixel(aFLSize);
997 0 : aFiFuncDesc->SetPosPixel(aFDTopLeft);
998 0 : aFiFuncDesc->SetSizePixel(aFDSize);
999 : }
1000 :
1001 0 : return 0;
1002 : }
1003 :
1004 0 : void ScFunctionDockWin::ToggleFloatingMode()
1005 : {
1006 0 : aSplitterInitPos = Point();
1007 0 : SfxDockingWindow::ToggleFloatingMode();
1008 :
1009 0 : eSfxNewAlignment=GetAlignment();
1010 0 : eSfxOldAlignment=eSfxNewAlignment;
1011 :
1012 0 : aOldSize.Height()=0;
1013 0 : aOldSize.Width()=0;
1014 0 : aIdle.Start();
1015 0 : }
1016 :
1017 0 : IMPL_LINK_NOARG_TYPED(ScFunctionDockWin, TimerHdl, Idle *, void)
1018 : {
1019 0 : CheckAlignment(eSfxOldAlignment,eSfxNewAlignment);
1020 0 : SetSize();
1021 0 : }
1022 :
1023 0 : void ScFunctionDockWin::Initialize(SfxChildWinInfo *pInfo)
1024 : {
1025 0 : OUString aStr;
1026 0 : if(pInfo!=NULL)
1027 : {
1028 0 : if ( !pInfo->aExtraString.isEmpty() )
1029 : {
1030 0 : sal_Int32 nPos = pInfo->aExtraString.indexOf( "ScFuncList:" );
1031 :
1032 : // Versuche, den Alignment-String "ALIGN:(...)" einzulesen; wenn
1033 : // er nicht vorhanden ist, liegt eine "altere Version vor
1034 0 : if ( nPos != -1 )
1035 : {
1036 0 : sal_Int32 n1 = pInfo->aExtraString.indexOf('(', nPos);
1037 0 : if ( n1 != -1 )
1038 : {
1039 0 : sal_Int32 n2 = pInfo->aExtraString.indexOf(')', n1);
1040 0 : if ( n2 != -1 )
1041 : {
1042 : // Alignment-String herausschneiden
1043 0 : aStr = pInfo->aExtraString.copy(nPos, n2 - nPos + 1);
1044 0 : pInfo->aExtraString = pInfo->aExtraString.replaceAt(nPos, n2 - nPos + 1, "");
1045 0 : aStr = aStr.copy( n1-nPos+1 );
1046 : }
1047 : }
1048 : }
1049 : }
1050 : }
1051 0 : SfxDockingWindow::Initialize(pInfo);
1052 :
1053 0 : if ( !aStr.isEmpty())
1054 : {
1055 0 : aSplitterInitPos = aPrivatSplit->GetPosPixel();
1056 0 : aSplitterInitPos.Y() = (sal_uInt16) aStr.toInt32();
1057 0 : sal_Int32 n1 = aStr.indexOf(';');
1058 0 : aStr = aStr.copy( n1+1 );
1059 0 : sal_Int32 nSelPos = aStr.toInt32();
1060 0 : aCatBox->SelectEntryPos(nSelPos);
1061 0 : SelHdl(aCatBox.get());
1062 :
1063 : // if the window has already been shown (from SfxDockingWindow::Initialize if docked),
1064 : // set the splitter position now, otherwise it is set in StateChanged with type INITSHOW
1065 :
1066 0 : UseSplitterInitPos();
1067 0 : }
1068 0 : }
1069 :
1070 0 : void ScFunctionDockWin::FillInfo(SfxChildWinInfo& rInfo) const
1071 : {
1072 0 : SfxDockingWindow::FillInfo(rInfo);
1073 0 : Point aPoint=aPrivatSplit->GetPosPixel();
1074 0 : rInfo.aExtraString += "ScFuncList:(" +
1075 0 : OUString::number(aPoint.Y()) + ";" +
1076 0 : OUString::number(aCatBox->GetSelectEntryPos()) + ")";
1077 0 : }
1078 :
1079 0 : void ScFunctionDockWin::UseSplitterInitPos()
1080 : {
1081 0 : if ( IsVisible() && aPrivatSplit->IsEnabled() && aSplitterInitPos != Point() )
1082 : {
1083 0 : aPrivatSplit->MoveSplitTo(aSplitterInitPos);
1084 0 : aSplitterInitPos = Point(); // use only once
1085 : }
1086 0 : }
1087 :
1088 0 : void ScFunctionDockWin::StateChanged( StateChangedType nStateChange )
1089 : {
1090 0 : SfxDockingWindow::StateChanged( nStateChange );
1091 :
1092 0 : if (nStateChange == StateChangedType::InitShow)
1093 : {
1094 0 : UseSplitterInitPos(); // set initial splitter position if necessary
1095 : }
1096 156 : }
1097 :
1098 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
