sc/source/ui/view/tabvwsh5.cxx

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