sc/source/ui/view/tabvwsh5.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: tabvwsh5.cxx,v $
  10  * $Revision: 1.13.32.1 $
  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 #define _ZFORLIST_DECLARE_TABLE
  38 #include "scitems.hxx"
  39 #include <svtools/smplhint.hxx>
  40 #include <svtools/zforlist.hxx>
  41 #include <svx/numfmtsh.hxx>
  42 #include <svx/numinf.hxx>
  43 #include <svx/svxids.hrc>
  44 #include <sfx2/dispatch.hxx>
  45 #include <sfx2/objsh.hxx>
  46
  47 #include "tabvwsh.hxx"
  48 #include "sc.hrc"
  49 #include "global.hxx"
  50 #include "docsh.hxx"
  51 #include "document.hxx"
  52 #include "cell.hxx"
  53 #include "globstr.hrc"
  54 #include "scmod.hxx"
  55 #include "uiitems.hxx"
  56 #include "editsh.hxx"
  57 #include "hints.hxx"
  58
  59
  60 //==================================================================
  61
  62 void __EXPORT ScTabViewShell::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
  63 {
  64     if (rHint.ISA(SfxSimpleHint))                                               // ohne Parameter
  65     {
  66         ULONG nSlot = ((SfxSimpleHint&)rHint).GetId();
  67         switch ( nSlot )
  68         {
  69             case FID_DATACHANGED:
  70                 UpdateFormulas();
  71                 break;
  72
  73             case FID_REFMODECHANGED:
  74                 {
  75                     BOOL bRefMode = SC_MOD()->IsFormulaMode();
  76                     if (!bRefMode)
  77                         StopRefMode();
  78                     else
  79                     {
  80                         GetSelEngine()->Reset();
  81                         GetFunctionSet()->SetAnchorFlag(TRUE);
  82                         //      AnchorFlag, damit gleich mit Control angehaengt werden kann
  83                     }
  84                 }
  85                 break;
  86
  87             case FID_KILLEDITVIEW:
  88             case FID_KILLEDITVIEW_NOPAINT:
  89                 StopEditShell();
  90                 KillEditView( nSlot == FID_KILLEDITVIEW_NOPAINT );
  91                 break;
  92
  93             case SFX_HINT_DOCCHANGED:
  94                 {
  95                     ScDocument* pDoc = GetViewData()->GetDocument();
  96                     if (!pDoc->HasTable( GetViewData()->GetTabNo() ))
  97                     {
  98                         SetTabNo(0);
  99                     }
 100                 }
 101                 break;
 102
 103             case SC_HINT_DRWLAYER_NEW:
 104                 MakeDrawView();
 105                 break;
 106
 107             case SC_HINT_DOC_SAVED:
 108                 {
 109                     //  beim "Save as" kann ein vorher schreibgeschuetztes Dokument
 110                     //  bearbeitbar werden, deshalb die Layer-Locks neu (#39884#)
 111                     //  (Invalidate etc. passiert schon vom Sfx her)
 112                     //  #42091# bei SID_EDITDOC kommt kein SFX_HINT_TITLECHANGED, darum
 113                     //  der eigene Hint aus DoSaveCompleted
 114                     //! was ist mit SFX_HINT_SAVECOMPLETED ?
 115
 116                     UpdateLayerLocks();
 117
 118                     //  #54891# Design-Modus bei jedem Speichern anzupassen, waere zuviel
 119                     //  (beim Speichern unter gleichem Namen soll er unveraendert bleiben)
 120                     //  Darum nur bei SFX_HINT_MODECHANGED (vom ViewFrame)
 121                 }
 122                 break;
 123
 124             case SFX_HINT_MODECHANGED:
 125                 //      #54891#/#58510# Da man sich nicht mehr darauf verlassen kann, woher
 126                 //      dieser Hint kommt, den Design-Modus immer dann umschalten, wenn der
 127                 //      ReadOnly-Status sich wirklich geaendert hat:
 128
 129                 if ( GetViewData()->GetSfxDocShell()->IsReadOnly() != bReadOnly )
 130                 {
 131                     bReadOnly = GetViewData()->GetSfxDocShell()->IsReadOnly();
 132
 133                     SfxBoolItem aItem( SID_FM_DESIGN_MODE, !bReadOnly);
 134                     GetViewData()->GetDispatcher().Execute( SID_FM_DESIGN_MODE, SFX_CALLMODE_ASYNCHRON,
 135                                                 &aItem, 0L );
 136
 137                     UpdateInputContext();
 138                 }
 139                 break;
 140
 141             case SC_HINT_SHOWRANGEFINDER:
 142                 PaintRangeFinder();
 143                 break;
 144
 145             case SC_HINT_FORCESETTAB:
 146                 SetTabNo( GetViewData()->GetTabNo(), TRUE );
 147                 break;
 148
 149             default:
 150                 break;
 151         }
 152     }
 153     else if (rHint.ISA(ScPaintHint))                                    // neu zeichnen
 154     {
 155         ScPaintHint* pHint = (ScPaintHint*) &rHint;
 156         USHORT nParts = pHint->GetParts();
 157         SCTAB nTab = GetViewData()->GetTabNo();
 158         if (pHint->GetStartTab() <= nTab && pHint->GetEndTab() >= nTab)
 159         {
 160             if (nParts & PAINT_EXTRAS)                  // zuerst, falls Tabelle weg ist !!!
 161                 if (PaintExtras())
 162                     nParts = PAINT_ALL;
 163
 164             // if the current sheet has pending row height updates (sheet links refreshed),
 165             // execute them before invalidating the window
 166             GetViewData()->GetDocShell()->UpdatePendingRowHeights( GetViewData()->GetTabNo() );
 167
 168             if (nParts & PAINT_SIZE)
 169                 RepeatResize();                                         //! InvalidateBorder ???
 170             if (nParts & PAINT_GRID)
 171                 PaintArea( pHint->GetStartCol(), pHint->GetStartRow(),
 172                            pHint->GetEndCol(), pHint->GetEndRow() );
 173             if (nParts & PAINT_MARKS)
 174                 PaintArea( pHint->GetStartCol(), pHint->GetStartRow(),
 175                            pHint->GetEndCol(), pHint->GetEndRow(), SC_UPDATE_MARKS );
 176             if (nParts & PAINT_LEFT)
 177                 PaintLeftArea( pHint->GetStartRow(), pHint->GetEndRow() );
 178             if (nParts & PAINT_TOP)
 179                 PaintTopArea( pHint->GetStartCol(), pHint->GetEndCol() );
 180             if (nParts & PAINT_INVERT)
 181                 InvertBlockMark( pHint->GetStartCol(), pHint->GetStartRow(),
 182                                  pHint->GetEndCol(), pHint->GetEndRow() );
 183
 184             // #i84689# call UpdateAllOverlays here instead of in ScTabView::PaintArea
 185             if (nParts & ( PAINT_LEFT | PAINT_TOP ))    // only if widths or heights changed
 186                 UpdateAllOverlays();
 187
 188             HideNoteMarker();
 189         }
 190     }
 191     else if (rHint.ISA(ScEditViewHint))                                 // Edit-View anlegen
 192     {
 193         //      ScEditViewHint kommt nur an aktiver View an
 194
 195         ScEditViewHint* pHint = (ScEditViewHint*) &rHint;
 196         SCTAB nTab = GetViewData()->GetTabNo();
 197         if ( pHint->GetTab() == nTab )
 198         {
 199             SCCOL nCol = pHint->GetCol();
 200             SCROW nRow = pHint->GetRow();
 201             {
 202                 HideNoteMarker();
 203
 204                 MakeEditView( pHint->GetEngine(), nCol, nRow );
 205
 206                 StopEditShell();                                        // sollte nicht gesetzt sein
 207
 208                 ScSplitPos eActive = GetViewData()->GetActivePart();
 209                 if ( GetViewData()->HasEditView(eActive) )
 210                 {
 211                     //  MakeEditView geht schief, wenn der Cursor ausserhalb des
 212                     //  Bildschirms steht. GetEditView gibt dann eine nicht aktive
 213                     //  View zurueck, darum die Abfrage HasEditView.
 214
 215                     EditView* pView = GetViewData()->GetEditView(eActive);      // ist nicht 0
 216
 217                     SetEditShell(pView ,TRUE);
 218                 }
 219             }
 220         }
 221     }
 222     else if (rHint.ISA(ScTablesHint))                           // Tabelle eingefuegt / geloescht
 223     {
 224             //  aktuelle Tabelle zuerst holen (kann bei DeleteTab an ViewData geaendert werden)
 225         SCTAB nActiveTab = GetViewData()->GetTabNo();
 226
 227         const ScTablesHint& rTabHint = (const ScTablesHint&)rHint;
 228         SCTAB nTab1 = rTabHint.GetTab1();
 229         SCTAB nTab2 = rTabHint.GetTab2();
 230         USHORT nId  = rTabHint.GetId();
 231         switch (nId)
 232         {
 233             case SC_TAB_INSERTED:
 234                 GetViewData()->InsertTab( nTab1 );
 235                 break;
 236             case SC_TAB_DELETED:
 237                 GetViewData()->DeleteTab( nTab1 );
 238                 break;
 239             case SC_TAB_MOVED:
 240                 GetViewData()->MoveTab( nTab1, nTab2 );
 241                 break;
 242             case SC_TAB_COPIED:
 243                 GetViewData()->CopyTab( nTab1, nTab2 );
 244                 break;
 245             case SC_TAB_HIDDEN:
 246                 break;
 247             default:
 248                 DBG_ERROR("unbekannter ScTablesHint");
 249         }
 250
 251         //      hier keine Abfrage auf IsActive() mehr, weil die Aktion von Basic ausgehen
 252         //      kann und dann auch die aktive View umgeschaltet werden muss.
 253
 254         SCTAB nNewTab = nActiveTab;
 255         BOOL bForce = FALSE;
 256         switch (nId)
 257         {
 258             case SC_TAB_INSERTED:
 259                 if ( nTab1 <= nNewTab )                         // vorher eingefuegt
 260                     ++nNewTab;
 261                 break;
 262             case SC_TAB_DELETED:
 263                 if ( nTab1 < nNewTab )                          // vorher geloescht
 264                     --nNewTab;
 265                 else if ( nTab1 == nNewTab )            // aktuelle geloescht
 266                     bForce = TRUE;
 267                 break;
 268             case SC_TAB_MOVED:
 269                 if ( nNewTab == nTab1 )                         // verschobene Tabelle
 270                     nNewTab = nTab2;
 271                 else if ( nTab1 < nTab2 )                       // nach hinten verschoben
 272                 {
 273                     if ( nNewTab > nTab1 && nNewTab <= nTab2 )          // nachrueckender Bereich
 274                         --nNewTab;
 275                 }
 276                 else                                                            // nach vorne verschoben
 277                 {
 278                     if ( nNewTab >= nTab2 && nNewTab < nTab1 )          // nachrueckender Bereich
 279                         ++nNewTab;
 280                 }
 281                 break;
 282             case SC_TAB_COPIED:
 283                 if ( nNewTab >= nTab2 )                         // vorher eingefuegt
 284                     ++nNewTab;
 285                 break;
 286             case SC_TAB_HIDDEN:
 287                 if ( nTab1 == nNewTab )                         // aktuelle ausgeblendet
 288                     bForce = TRUE;
 289                 break;
 290         }
 291
 292         ScDocument* pDoc = GetViewData()->GetDocument();
 293         if ( nNewTab >= pDoc->GetTableCount() )
 294             nNewTab = pDoc->GetTableCount() - 1;
 295
 296         SetTabNo( nNewTab, bForce );
 297     }
 298     else if (rHint.ISA(ScIndexHint))
 299     {
 300         const ScIndexHint& rIndexHint = (const ScIndexHint&)rHint;
 301         USHORT nId = rIndexHint.GetId();
 302         USHORT nIndex = rIndexHint.GetIndex();
 303         switch (nId)
 304         {
 305             case SC_HINT_SHOWRANGEFINDER:
 306                 PaintRangeFinder( nIndex );
 307                 break;
 308         }
 309     }
 310
 311     SfxViewShell::Notify( rBC, rHint );
 312 }
 313
 314 //------------------------------------------------------------------
 315
 316 void ScTabViewShell::MakeNumberInfoItem( ScDocument*             pDoc,
 317                                          ScViewData*             pViewData,
 318                                          SvxNumberInfoItem** ppItem )
 319 {
 320     //------------------------------
 321     // NumberInfo-Item konstruieren:
 322     //------------------------------
 323     ScBaseCell*                 pCell = NULL;
 324     SvxNumberValueType  eValType                = SVX_VALUE_TYPE_UNDEFINED;
 325     double                              nCellValue              = 0;
 326     String                              aCellString;
 327
 328     pDoc->GetCell( pViewData->GetCurX(),
 329                    pViewData->GetCurY(),
 330                    pViewData->GetTabNo(),
 331                    pCell );
 332
 333     if ( pCell )
 334     {
 335         switch ( pCell->GetCellType() )
 336         {
 337             case CELLTYPE_VALUE:
 338                 {
 339                     nCellValue = ((ScValueCell*)pCell)->GetValue();
 340                     eValType = SVX_VALUE_TYPE_NUMBER;
 341                     aCellString.Erase();
 342                 }
 343                 break;
 344
 345             case CELLTYPE_STRING:
 346                 {
 347                     ((ScStringCell*)pCell)->GetString( aCellString );
 348                     eValType = SVX_VALUE_TYPE_STRING;
 349                 }
 350                 break;
 351
 352             case CELLTYPE_FORMULA:
 353                 {
 354                     if ( ((ScFormulaCell*)pCell)->IsValue() )
 355                     {
 356                         nCellValue = ((ScFormulaCell*)pCell)->GetValue();
 357                         eValType = SVX_VALUE_TYPE_NUMBER;
 358                     }
 359                     else
 360                     {
 361                         nCellValue = 0;
 362                         eValType   = SVX_VALUE_TYPE_UNDEFINED;
 363                     }
 364                     aCellString.Erase();
 365                 }
 366                 break;
 367
 368             default:
 369                 nCellValue = 0;
 370                 eValType   = SVX_VALUE_TYPE_UNDEFINED;
 371                 aCellString.Erase();
 372         }
 373     }
 374     else // Zelle noch leer (== nicht erzeugt)
 375     {
 376         nCellValue = 0;
 377         eValType   = SVX_VALUE_TYPE_UNDEFINED;
 378         aCellString.Erase();
 379     }
 380
 381     switch ( eValType )
 382     {
 383         case SVX_VALUE_TYPE_STRING:
 384             *ppItem = new SvxNumberInfoItem(
 385                                 pDoc->GetFormatTable(),
 386                                 aCellString,
 387                                 SID_ATTR_NUMBERFORMAT_INFO );
 388             break;
 389
 390         case SVX_VALUE_TYPE_NUMBER:
 391             *ppItem = new SvxNumberInfoItem(
 392                                 pDoc->GetFormatTable(),
 393                                 nCellValue,
 394                                 SID_ATTR_NUMBERFORMAT_INFO );
 395             break;
 396
 397         case SVX_VALUE_TYPE_UNDEFINED:
 398         default:
 399             *ppItem = new SvxNumberInfoItem(
 400                                 pDoc->GetFormatTable(),
 401                                 (const USHORT)
 402                                 SID_ATTR_NUMBERFORMAT_INFO );
 403     }
 404 }
 405
 406 //------------------------------------------------------------------
 407
 408 void ScTabViewShell::UpdateNumberFormatter(
 409                         ScDocument*                      pDoc,
 410                         const SvxNumberInfoItem& rInfoItem )
 411 {
 412     const sal_uInt32 nDelCount = rInfoItem.GetDelCount();
 413
 414     if ( nDelCount > 0 )
 415     {
 416         const sal_uInt32* pDelArr = rInfoItem.GetDelArray();
 417
 418         for ( USHORT i=0; i<nDelCount; i++ )
 419             rInfoItem.GetNumberFormatter()->DeleteEntry( pDelArr[i] );
 420     }
 421
 422     // sollte besser UpdateNumberFormats() heissen ?
 423     pDoc->DeleteNumberFormat( rInfoItem.GetDelArray(),
 424                               rInfoItem.GetDelCount() );
 425 }
 426
 427
 428
 429
 430
 431