sc/source/ui/formdlg/dwfunctr.cxx

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