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 <sal/config.h>
21 :
22 : #include "olkact.hxx"
23 : #include "scitems.hxx"
24 : #include <editeng/eeitem.hxx>
25 :
26 : #include <sfx2/app.hxx>
27 : #include <svx/extrusionbar.hxx>
28 : #include <svx/fontworkbar.hxx>
29 : #include <editeng/boxitem.hxx>
30 : #include <svx/fmpage.hxx>
31 : #include <svx/fmshell.hxx>
32 : #include <editeng/sizeitem.hxx>
33 : #include <svx/prtqry.hxx>
34 : #include <svx/sidebar/ContextChangeEventMultiplexer.hxx>
35 : #include <sfx2/request.hxx>
36 : #include <sfx2/printer.hxx>
37 : #include <sfx2/dispatch.hxx>
38 : #include <svl/whiter.hxx>
39 : #include <unotools/moduleoptions.hxx>
40 : #include <tools/urlobj.hxx>
41 : #include <sfx2/docfile.hxx>
42 : #include <vcl/openglwin.hxx>
43 :
44 : #include "tabvwsh.hxx"
45 : #include "sc.hrc"
46 : #include "globstr.hrc"
47 : #include "stlpool.hxx"
48 : #include "stlsheet.hxx"
49 : #include "docsh.hxx"
50 : #include "scmod.hxx"
51 : #include "appoptio.hxx"
52 : #include "rangeutl.hxx"
53 : #include "printfun.hxx"
54 : #include "drawsh.hxx"
55 : #include "drformsh.hxx"
56 : #include "editsh.hxx"
57 : #include "pivotsh.hxx"
58 : #include "auditsh.hxx"
59 : #include "drtxtob.hxx"
60 : #include "inputhdl.hxx"
61 : #include "editutil.hxx"
62 : #include "inputopt.hxx"
63 : #include "inputwin.hxx"
64 : #include "scresid.hxx"
65 : #include "dbdata.hxx"
66 : #include "reffact.hxx"
67 : #include "viewuno.hxx"
68 : #include "dispuno.hxx"
69 : #include "anyrefdg.hxx"
70 : #include "chgtrack.hxx"
71 : #include "cellsh.hxx"
72 : #include "oleobjsh.hxx"
73 : #include "chartsh.hxx"
74 : #include "graphsh.hxx"
75 : #include "mediash.hxx"
76 : #include "pgbrksh.hxx"
77 : #include "dpobject.hxx"
78 : #include "prevwsh.hxx"
79 : #include "tpprint.hxx"
80 : #include "scextopt.hxx"
81 : #include "printopt.hxx"
82 : #include "drawview.hxx"
83 : #include "fupoor.hxx"
84 : #include "navsett.hxx"
85 : #include "scabstdlg.hxx"
86 : #include "externalrefmgr.hxx"
87 : #include "defaultsoptions.hxx"
88 : #include "markdata.hxx"
89 : #include "preview.hxx"
90 : #include "docoptio.hxx"
91 : #include <documentlinkmgr.hxx>
92 : #include <gridwin.hxx>
93 :
94 : #include <com/sun/star/document/XDocumentProperties.hpp>
95 : #include <com/sun/star/chart2/X3DChartWindowProvider.hpp>
96 : #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
97 : #include <com/sun/star/chart2/XCoordinateSystem.hpp>
98 : #include <com/sun/star/chart2/XChartTypeContainer.hpp>
99 : #include <com/sun/star/chart2/XChartType.hpp>
100 :
101 : extern SfxViewShell* pScActiveViewShell; // global.cxx
102 :
103 : using namespace com::sun::star;
104 :
105 : // STATIC DATA -----------------------------------------------------------
106 :
107 : sal_uInt16 ScTabViewShell::nInsertCtrlState = SID_INSERT_GRAPHIC;
108 : sal_uInt16 ScTabViewShell::nInsCellsCtrlState = 0;
109 : sal_uInt16 ScTabViewShell::nInsObjCtrlState = SID_INSERT_DIAGRAM;
110 :
111 338 : void ScTabViewShell::Activate(bool bMDI)
112 : {
113 338 : SfxViewShell::Activate(bMDI);
114 338 : bIsActive = true;
115 : // hier kein GrabFocus, sonst gibt's Probleme wenn etwas inplace editiert wird!
116 :
117 338 : if ( bMDI )
118 : {
119 : // fuer Eingabezeile (ClearCache)
120 338 : ScModule* pScMod = SC_MOD();
121 338 : pScMod->ViewShellChanged();
122 :
123 338 : ActivateView( true, bFirstActivate );
124 :
125 : // AutoCorrect umsetzen, falls der Writer seins neu angelegt hat
126 338 : UpdateDrawTextOutliner();
127 :
128 : // RegisterNewTargetNames gibts nicht mehr
129 :
130 338 : SfxViewFrame* pThisFrame = GetViewFrame();
131 338 : if ( pInputHandler && pThisFrame->HasChildWindow(FID_INPUTLINE_STATUS) )
132 : {
133 : // eigentlich nur beim Reload (letzte Version) noetig:
134 : // Das InputWindow bleibt stehen, aber die View mitsamt InputHandler wird
135 : // neu angelegt, darum muss der InputHandler am InputWindow gesetzt werden.
136 338 : SfxChildWindow* pChild = pThisFrame->GetChildWindow(FID_INPUTLINE_STATUS);
137 338 : if (pChild)
138 : {
139 338 : ScInputWindow* pWin = static_cast<ScInputWindow*>(pChild->GetWindow());
140 338 : if (pWin && pWin->IsVisible())
141 : {
142 :
143 150 : ScInputHandler* pOldHdl=pWin->GetInputHandler();
144 :
145 150 : TypeId aScType = TYPE(ScTabViewShell);
146 :
147 150 : SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
148 305 : while ( pSh!=NULL && pOldHdl!=NULL)
149 : {
150 155 : if (static_cast<ScTabViewShell*>(pSh)->GetInputHandler() == pOldHdl)
151 : {
152 150 : pOldHdl->ResetDelayTimer();
153 150 : break;
154 : }
155 5 : pSh = SfxViewShell::GetNext( *pSh, &aScType );
156 : }
157 :
158 150 : pWin->SetInputHandler( pInputHandler );
159 : }
160 : }
161 : }
162 :
163 338 : UpdateInputHandler( true );
164 :
165 338 : if ( bFirstActivate )
166 : {
167 338 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_NAVIGATOR_UPDATEALL ) );
168 338 : bFirstActivate = false;
169 :
170 : // ReadExtOptions (view settings from Excel import) must also be done
171 : // after the ctor, because of the potential calls to Window::Show.
172 : // Even after a bugfix (Window::Show no longer notifies the access
173 : // bridge, it's done in ImplSetReallyVisible), there are problems if Window::Show
174 : // is called during the ViewShell ctor and reschedules asynchronous calls
175 : // (for example from the FmFormShell ctor).
176 338 : ScExtDocOptions* pExtOpt = GetViewData().GetDocument()->GetExtDocOptions();
177 338 : if ( pExtOpt && pExtOpt->IsChanged() )
178 : {
179 29 : GetViewData().ReadExtOptions(*pExtOpt); // Excel view settings
180 29 : SetTabNo( GetViewData().GetTabNo(), true );
181 29 : pExtOpt->SetChanged( false );
182 : }
183 : }
184 :
185 338 : pScActiveViewShell = this;
186 :
187 338 : ScInputHandler* pHdl = pScMod->GetInputHdl(this);
188 338 : if (pHdl)
189 : {
190 338 : pHdl->SetRefScale( GetViewData().GetZoomX(), GetViewData().GetZoomY() );
191 : }
192 :
193 : // Aenderungs-Dialog aktualisieren
194 :
195 338 : if ( pThisFrame->HasChildWindow(FID_CHG_ACCEPT) )
196 : {
197 0 : SfxChildWindow* pChild = pThisFrame->GetChildWindow(FID_CHG_ACCEPT);
198 0 : if (pChild)
199 : {
200 0 : static_cast<ScAcceptChgDlgWrapper*>(pChild)->ReInitDlg();
201 : }
202 : }
203 :
204 338 : if(pScMod->IsRefDialogOpen())
205 : {
206 0 : sal_uInt16 nModRefDlgId=pScMod->GetCurRefDlgId();
207 0 : SfxChildWindow* pChildWnd = pThisFrame->GetChildWindow( nModRefDlgId );
208 0 : if ( pChildWnd )
209 : {
210 0 : IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
211 : assert(pRefDlg);
212 0 : if(pRefDlg)
213 : {
214 0 : pRefDlg->ViewShellChanged();
215 : }
216 : }
217 : }
218 : }
219 :
220 : // don't call CheckSelectionTransfer here - activating a view should not change the
221 : // primary selection (may be happening just because the mouse was moved over the window)
222 :
223 : // Wenn Referenzeingabe-Tip-Hilfe hier wieder angezeigt werden soll (ShowRefTip),
224 : // muss sie beim Verschieben der View angepasst werden (gibt sonst Probleme unter OS/2
225 : // beim Umschalten zwischen Dokumenten)
226 :
227 : ContextChangeEventMultiplexer::NotifyContextChange(
228 : GetController(),
229 338 : ::sfx2::sidebar::EnumContext::Context_Default);
230 338 : }
231 :
232 336 : void ScTabViewShell::Deactivate(bool bMDI)
233 : {
234 336 : HideTip();
235 :
236 336 : ScDocument* pDoc=GetViewData().GetDocument();
237 :
238 336 : ScChangeTrack* pChanges=pDoc->GetChangeTrack();
239 :
240 336 : if(pChanges!=NULL)
241 : {
242 2 : Link<> aLink;
243 2 : pChanges->SetModifiedLink(aLink);
244 : }
245 :
246 336 : SfxViewShell::Deactivate(bMDI);
247 336 : bIsActive = false;
248 336 : ScInputHandler* pHdl = SC_MOD()->GetInputHdl(this);
249 :
250 336 : if( bMDI )
251 : {
252 : // during shell deactivation, shells must not be switched, or the loop
253 : // through the shell stack (in SfxDispatcher::DoDeactivate_Impl) will not work
254 336 : bool bOldDontSwitch = bDontSwitch;
255 336 : bDontSwitch = true;
256 :
257 336 : ActivateView( false, false );
258 :
259 336 : if ( GetViewFrame()->GetFrame().IsInPlace() ) // inplace
260 0 : GetViewData().GetDocShell()->UpdateOle(&GetViewData(), true);
261 :
262 336 : if ( pHdl )
263 336 : pHdl->NotifyChange( NULL, true ); // Timer-verzoegert wg. Dokumentwechsel
264 :
265 336 : if (pScActiveViewShell == this)
266 336 : pScActiveViewShell = NULL;
267 :
268 336 : bDontSwitch = bOldDontSwitch;
269 : }
270 : else
271 : {
272 0 : HideNoteMarker(); // Notiz-Anzeige
273 :
274 0 : if ( pHdl )
275 0 : pHdl->HideTip(); // Formel-AutoEingabe-Tip abschalten
276 : }
277 336 : }
278 :
279 0 : void ScTabViewShell::SetActive()
280 : {
281 : // Die Sfx-View moechte sich gerne selbst aktivieren, weil dabei noch
282 : // magische Dinge geschehen (z.B. stuerzt sonst evtl. der Gestalter ab)
283 0 : ActiveGrabFocus();
284 0 : }
285 :
286 654 : bool ScTabViewShell::PrepareClose(bool bUI)
287 : {
288 : // Call EnterHandler even in formula mode here,
289 : // so a formula change in an embedded object isn't lost
290 : // (ScDocShell::PrepareClose isn't called then).
291 654 : ScInputHandler* pHdl = SC_MOD()->GetInputHdl( this );
292 654 : if ( pHdl && pHdl->IsInputMode() )
293 0 : pHdl->EnterHandler();
294 :
295 : // draw text edit mode must be closed
296 654 : FuPoor* pPoor = GetDrawFuncPtr();
297 654 : if ( pPoor && ( IsDrawTextShell() || pPoor->GetSlotID() == SID_DRAW_NOTEEDIT ) )
298 : {
299 : // "clean" end of text edit, including note handling, subshells and draw func switching,
300 : // as in FuDraw and ScTabView::DrawDeselectAll
301 0 : GetViewData().GetDispatcher().Execute( pPoor->GetSlotID(), SfxCallMode::SLOT | SfxCallMode::RECORD );
302 : }
303 654 : ScDrawView* pDrView = GetScDrawView();
304 654 : if ( pDrView )
305 : {
306 : // force end of text edit, to be safe
307 : // ScEndTextEdit must always be used, to ensure correct UndoManager
308 654 : pDrView->ScEndTextEdit();
309 : }
310 :
311 654 : if ( pFormShell )
312 : {
313 654 : bool nRet = pFormShell->PrepareClose(bUI);
314 654 : if (!nRet)
315 0 : return nRet;
316 : }
317 654 : return SfxViewShell::PrepareClose(bUI);
318 : }
319 :
320 : // Zoom fuer In-Place berechnen
321 : // aus Verhaeltnis von VisArea und Fenstergroesse des GridWin
322 :
323 0 : void ScTabViewShell::UpdateOleZoom()
324 : {
325 0 : ScDocShell* pDocSh = GetViewData().GetDocShell();
326 0 : if ( pDocSh->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
327 : {
328 : //TODO/LATER: is there a difference between the two GetVisArea methods?
329 0 : Size aObjSize = static_cast<const SfxObjectShell*>(pDocSh)->GetVisArea().GetSize();
330 0 : if ( aObjSize.Width() > 0 && aObjSize.Height() > 0 )
331 : {
332 0 : vcl::Window* pWin = GetActiveWin();
333 0 : Size aWinHMM = pWin->PixelToLogic( pWin->GetOutputSizePixel(), MAP_100TH_MM );
334 0 : SetZoomFactor( Fraction( aWinHMM.Width(),aObjSize.Width() ),
335 0 : Fraction( aWinHMM.Height(),aObjSize.Height() ) );
336 : }
337 : }
338 0 : }
339 :
340 0 : void ScTabViewShell::AdjustPosSizePixel( const Point &rPos, const Size &rSize )
341 : {
342 0 : OuterResizePixel( rPos, rSize );
343 0 : }
344 :
345 0 : void ScTabViewShell::InnerResizePixel( const Point &rOfs, const Size &rSize )
346 : {
347 0 : Size aNewSize( rSize );
348 0 : if ( GetViewFrame()->GetFrame().IsInPlace() )
349 : {
350 0 : SvBorder aBorder;
351 0 : GetBorderSize( aBorder, rSize );
352 0 : SetBorderPixel( aBorder );
353 :
354 0 : Size aObjSize = GetObjectShell()->GetVisArea().GetSize();
355 :
356 0 : Size aSize( rSize );
357 0 : aSize.Width() -= (aBorder.Left() + aBorder.Right());
358 0 : aSize.Height() -= (aBorder.Top() + aBorder.Bottom());
359 :
360 0 : if ( aObjSize.Width() > 0 && aObjSize.Height() > 0 )
361 : {
362 0 : Size aLogicSize = GetWindow()->PixelToLogic( aSize, MAP_100TH_MM );
363 0 : SfxViewShell::SetZoomFactor( Fraction( aLogicSize.Width(),aObjSize.Width() ),
364 0 : Fraction( aLogicSize.Height(),aObjSize.Height() ) );
365 : }
366 :
367 0 : Point aPos( rOfs );
368 0 : aPos.X() += aBorder.Left();
369 0 : aPos.Y() += aBorder.Top();
370 0 : GetWindow()->SetPosSizePixel( aPos, aSize );
371 : }
372 : else
373 : {
374 0 : SvBorder aBorder;
375 0 : GetBorderSize( aBorder, rSize );
376 0 : SetBorderPixel( aBorder );
377 0 : aNewSize.Width() += aBorder.Left() + aBorder.Right();
378 0 : aNewSize.Height() += aBorder.Top() + aBorder.Bottom();
379 : }
380 :
381 0 : DoResize( rOfs, aNewSize, true ); // rSize = Groesse von gridwin
382 :
383 0 : UpdateOleZoom(); // Zoom fuer In-Place berechnen
384 :
385 0 : GetViewData().GetDocShell()->SetDocumentModified();
386 0 : }
387 :
388 1155 : void ScTabViewShell::OuterResizePixel( const Point &rOfs, const Size &rSize )
389 : {
390 1155 : SvBorder aBorder;
391 1155 : GetBorderSize( aBorder, rSize );
392 1155 : SetBorderPixel( aBorder );
393 :
394 1155 : DoResize( rOfs, rSize ); // Position und Groesse von tabview wie uebergeben
395 :
396 : // ForceMove als Ersatz fuer den Sfx-Move-Mechanismus
397 : // (aWinPos muss aktuell gehalten werden, damit ForceMove beim Ole-Deaktivieren klappt)
398 :
399 1155 : ForceMove();
400 1155 : }
401 :
402 0 : void ScTabViewShell::SetZoomFactor( const Fraction &rZoomX, const Fraction &rZoomY )
403 : {
404 : // fuer OLE...
405 :
406 0 : Fraction aFrac20( 1,5 );
407 0 : Fraction aFrac400( 4,1 );
408 :
409 0 : Fraction aNewX( rZoomX );
410 0 : if ( aNewX < aFrac20 )
411 0 : aNewX = aFrac20;
412 0 : if ( aNewX > aFrac400 )
413 0 : aNewX = aFrac400;
414 0 : Fraction aNewY( rZoomY );
415 0 : if ( aNewY < aFrac20 )
416 0 : aNewY = aFrac20;
417 0 : if ( aNewY > aFrac400 )
418 0 : aNewY = aFrac400;
419 :
420 0 : GetViewData().UpdateScreenZoom( aNewX, aNewY );
421 0 : SetZoom( aNewX, aNewY, true );
422 :
423 0 : PaintGrid();
424 0 : PaintTop();
425 0 : PaintLeft();
426 :
427 0 : SfxViewShell::SetZoomFactor( rZoomX, rZoomY );
428 0 : }
429 :
430 0 : void ScTabViewShell::QueryObjAreaPixel( Rectangle& rRect ) const
431 : {
432 : // auf ganze Zellen anpassen (in 1/100 mm)
433 :
434 0 : Size aPixelSize = rRect.GetSize();
435 0 : vcl::Window* pWin = const_cast<ScTabViewShell*>(this)->GetActiveWin();
436 0 : Size aLogicSize = pWin->PixelToLogic( aPixelSize );
437 :
438 0 : const ScViewData& rViewData = GetViewData();
439 0 : ScDocument* pDoc = rViewData.GetDocument();
440 0 : ScSplitPos ePos = rViewData.GetActivePart();
441 0 : SCCOL nCol = rViewData.GetPosX(WhichH(ePos));
442 0 : SCROW nRow = rViewData.GetPosY(WhichV(ePos));
443 0 : SCTAB nTab = rViewData.GetTabNo();
444 0 : bool bNegativePage = pDoc->IsNegativePage( nTab );
445 :
446 0 : Rectangle aLogicRect = pDoc->GetMMRect( nCol, nRow, nCol, nRow, nTab );
447 0 : if ( bNegativePage )
448 : {
449 : // use right edge of aLogicRect, and aLogicSize
450 0 : aLogicRect.Left() = aLogicRect.Right() - aLogicSize.Width() + 1; // Right() is set below
451 : }
452 0 : aLogicRect.SetSize( aLogicSize );
453 :
454 0 : rViewData.GetDocShell()->SnapVisArea( aLogicRect );
455 :
456 0 : rRect.SetSize( pWin->LogicToPixel( aLogicRect.GetSize() ) );
457 0 : }
458 :
459 1155 : void ScTabViewShell::Move()
460 : {
461 1155 : Point aNewPos = GetViewFrame()->GetWindow().OutputToScreenPixel(Point());
462 :
463 1155 : if (aNewPos != aWinPos)
464 : {
465 689 : StopMarking();
466 689 : aWinPos = aNewPos;
467 : }
468 1155 : }
469 :
470 65 : void ScTabViewShell::ShowCursor(bool /* bOn */)
471 : {
472 : /*!!! ShowCursor wird nicht paarweise wie im gridwin gerufen.
473 : Der CursorLockCount am Gridwin muss hier direkt auf 0 gesetzt werden
474 :
475 : if (bOn)
476 : ShowAllCursors();
477 : else
478 : HideAllCursors();
479 : */
480 65 : }
481 :
482 1 : void ScTabViewShell::WriteUserData(OUString& rData, bool /* bBrowse */)
483 : {
484 1 : GetViewData().WriteUserData(rData);
485 1 : }
486 :
487 228 : void ScTabViewShell::WriteUserDataSequence (uno::Sequence < beans::PropertyValue >& rSettings, bool /* bBrowse */ )
488 : {
489 228 : GetViewData().WriteUserDataSequence (rSettings);
490 228 : }
491 :
492 0 : void ScTabViewShell::ReadUserData(const OUString& rData, bool /* bBrowse */)
493 : {
494 0 : if ( !GetViewData().GetDocShell()->IsPreview() )
495 0 : DoReadUserData( rData );
496 0 : }
497 :
498 347 : void ScTabViewShell::ReadUserDataSequence (const uno::Sequence < beans::PropertyValue >& rSettings, bool /* bBrowse */ )
499 : {
500 347 : if ( !GetViewData().GetDocShell()->IsPreview() )
501 347 : DoReadUserDataSequence( rSettings );
502 347 : }
503 :
504 347 : void ScTabViewShell::DoReadUserDataSequence( const uno::Sequence < beans::PropertyValue >& rSettings )
505 : {
506 347 : vcl::Window* pOldWin = GetActiveWin();
507 347 : bool bFocus = pOldWin && pOldWin->HasFocus();
508 :
509 347 : GetViewData().ReadUserDataSequence(rSettings);
510 347 : SetTabNo( GetViewData().GetTabNo(), true );
511 :
512 347 : if ( GetViewData().IsPagebreakMode() )
513 0 : SetCurSubShell( GetCurObjectSelectionType(), true );
514 :
515 347 : vcl::Window* pNewWin = GetActiveWin();
516 347 : if (pNewWin && pNewWin != pOldWin)
517 : {
518 0 : SetWindow( pNewWin ); //! ist diese ViewShell immer aktiv???
519 0 : if (bFocus)
520 0 : pNewWin->GrabFocus();
521 0 : WindowChanged(); // Drawing-Layer (z.B. #56771#)
522 : }
523 :
524 694 : if (GetViewData().GetHSplitMode() == SC_SPLIT_FIX ||
525 347 : GetViewData().GetVSplitMode() == SC_SPLIT_FIX)
526 : {
527 0 : InvalidateSplit();
528 : }
529 :
530 347 : ZoomChanged();
531 :
532 347 : TestHintWindow();
533 :
534 : //! if ViewData has more tables than document, remove tables in ViewData
535 347 : }
536 :
537 : // DoReadUserData is also called from ctor when switching from print preview
538 :
539 0 : void ScTabViewShell::DoReadUserData( const OUString& rData )
540 : {
541 0 : vcl::Window* pOldWin = GetActiveWin();
542 0 : bool bFocus = pOldWin && pOldWin->HasFocus();
543 :
544 0 : GetViewData().ReadUserData(rData);
545 0 : SetTabNo( GetViewData().GetTabNo(), true );
546 :
547 0 : if ( GetViewData().IsPagebreakMode() )
548 0 : SetCurSubShell( GetCurObjectSelectionType(), true );
549 :
550 0 : vcl::Window* pNewWin = GetActiveWin();
551 0 : if (pNewWin && pNewWin != pOldWin)
552 : {
553 0 : SetWindow( pNewWin ); //! ist diese ViewShell immer aktiv???
554 0 : if (bFocus)
555 0 : pNewWin->GrabFocus();
556 0 : WindowChanged(); // Drawing-Layer (z.B. #56771#)
557 : }
558 :
559 0 : if (GetViewData().GetHSplitMode() == SC_SPLIT_FIX ||
560 0 : GetViewData().GetVSplitMode() == SC_SPLIT_FIX)
561 : {
562 0 : InvalidateSplit();
563 : }
564 :
565 0 : ZoomChanged();
566 :
567 0 : TestHintWindow();
568 :
569 : //! if ViewData has more tables than document, remove tables in ViewData
570 0 : }
571 :
572 4 : void ScTabViewShell::UpdateDrawShell()
573 : {
574 : // Called after user interaction that may delete the selected drawing object.
575 : // Remove DrawShell if nothing is selected.
576 :
577 4 : SdrView* pDrView = GetSdrView();
578 4 : if ( pDrView && !pDrView->AreObjectsMarked() && !IsDrawSelMode() )
579 0 : SetDrawShell( false );
580 4 : }
581 :
582 0 : void ScTabViewShell::SetDrawShellOrSub()
583 : {
584 0 : bActiveDrawSh = true;
585 :
586 0 : if(bActiveDrawFormSh)
587 : {
588 0 : SetCurSubShell(OST_DrawForm);
589 : }
590 0 : else if(bActiveGraphicSh)
591 : {
592 0 : SetCurSubShell(OST_Graphic);
593 : }
594 0 : else if(bActiveMediaSh)
595 : {
596 0 : SetCurSubShell(OST_Media);
597 : }
598 0 : else if(bActiveChartSh)
599 : {
600 0 : SetCurSubShell(OST_Chart);
601 : }
602 0 : else if(bActiveOleObjectSh)
603 : {
604 0 : SetCurSubShell(OST_OleObject);
605 : }
606 : else
607 : {
608 : SetCurSubShell(OST_Drawing, true /* force: different toolbars are
609 : visible concerning shape type
610 0 : and shape state */);
611 : }
612 0 : }
613 :
614 1413 : void ScTabViewShell::SetDrawShell( bool bActive )
615 : {
616 1413 : if(bActive)
617 : {
618 : SetCurSubShell(OST_Drawing, true /* force: different toolbars are
619 : visible concerning shape type
620 6 : and shape state */);
621 : }
622 : else
623 : {
624 1407 : if(bActiveDrawFormSh || bActiveDrawSh ||
625 1407 : bActiveGraphicSh || bActiveMediaSh || bActiveOleObjectSh||
626 1407 : bActiveChartSh || bActiveDrawTextSh)
627 : {
628 0 : SetCurSubShell(OST_Cell);
629 : }
630 1407 : bActiveDrawFormSh=false;
631 1407 : bActiveGraphicSh=false;
632 1407 : bActiveMediaSh=false;
633 1407 : bActiveOleObjectSh=false;
634 1407 : bActiveChartSh=false;
635 : }
636 :
637 1413 : bool bWasDraw = bActiveDrawSh || bActiveDrawTextSh;
638 :
639 1413 : bActiveDrawSh = bActive;
640 1413 : bActiveDrawTextSh = false;
641 :
642 1413 : if ( !bActive )
643 : {
644 1407 : ResetDrawDragMode(); // Mirror / Rotate aus
645 :
646 1407 : if (bWasDraw && (GetViewData().GetHSplitMode() == SC_SPLIT_FIX ||
647 0 : GetViewData().GetVSplitMode() == SC_SPLIT_FIX))
648 : {
649 : // Aktiven Teil an Cursor anpassen, etc.
650 0 : MoveCursorAbs( GetViewData().GetCurX(), GetViewData().GetCurY(),
651 0 : SC_FOLLOW_NONE, false, false, true );
652 : }
653 : }
654 1413 : }
655 :
656 0 : void ScTabViewShell::SetDrawTextShell( bool bActive )
657 : {
658 0 : bActiveDrawTextSh = bActive;
659 0 : if ( bActive )
660 : {
661 0 : bActiveDrawFormSh=false;
662 0 : bActiveGraphicSh=false;
663 0 : bActiveMediaSh=false;
664 0 : bActiveOleObjectSh=false;
665 0 : bActiveChartSh=false;
666 0 : bActiveDrawSh = false;
667 0 : SetCurSubShell(OST_DrawText);
668 : }
669 : else
670 0 : SetCurSubShell(OST_Cell);
671 :
672 0 : }
673 :
674 778 : void ScTabViewShell::SetPivotShell( bool bActive )
675 : {
676 778 : bActivePivotSh = bActive;
677 :
678 : // SetPivotShell is called from CursorPosChanged every time
679 : // -> don't change anything except switching between cell and pivot shell
680 :
681 778 : if ( eCurOST == OST_Pivot || eCurOST == OST_Cell )
682 : {
683 778 : if ( bActive )
684 : {
685 1 : bActiveDrawTextSh = bActiveDrawSh = false;
686 1 : bActiveDrawFormSh=false;
687 1 : bActiveGraphicSh=false;
688 1 : bActiveMediaSh=false;
689 1 : bActiveOleObjectSh=false;
690 1 : bActiveChartSh=false;
691 1 : SetCurSubShell(OST_Pivot);
692 : }
693 : else
694 777 : SetCurSubShell(OST_Cell);
695 : }
696 778 : }
697 :
698 0 : void ScTabViewShell::SetAuditShell( bool bActive )
699 : {
700 0 : bActiveAuditingSh = bActive;
701 0 : if ( bActive )
702 : {
703 0 : bActiveDrawTextSh = bActiveDrawSh = false;
704 0 : bActiveDrawFormSh=false;
705 0 : bActiveGraphicSh=false;
706 0 : bActiveMediaSh=false;
707 0 : bActiveOleObjectSh=false;
708 0 : bActiveChartSh=false;
709 0 : SetCurSubShell(OST_Auditing);
710 : }
711 : else
712 0 : SetCurSubShell(OST_Cell);
713 0 : }
714 :
715 0 : void ScTabViewShell::SetDrawFormShell( bool bActive )
716 : {
717 0 : bActiveDrawFormSh = bActive;
718 :
719 0 : if(bActiveDrawFormSh)
720 0 : SetCurSubShell(OST_DrawForm);
721 0 : }
722 0 : void ScTabViewShell::SetChartShell( bool bActive )
723 : {
724 0 : bActiveChartSh = bActive;
725 :
726 0 : if(bActiveChartSh)
727 0 : SetCurSubShell(OST_Chart);
728 0 : }
729 :
730 1 : void ScTabViewShell::SetGraphicShell( bool bActive )
731 : {
732 1 : bActiveGraphicSh = bActive;
733 :
734 1 : if(bActiveGraphicSh)
735 1 : SetCurSubShell(OST_Graphic);
736 1 : }
737 :
738 0 : void ScTabViewShell::SetMediaShell( bool bActive )
739 : {
740 0 : bActiveMediaSh = bActive;
741 :
742 0 : if(bActiveMediaSh)
743 0 : SetCurSubShell(OST_Media);
744 0 : }
745 :
746 0 : void ScTabViewShell::SetOleObjectShell( bool bActive )
747 : {
748 0 : bActiveOleObjectSh = bActive;
749 :
750 0 : if(bActiveOleObjectSh)
751 0 : SetCurSubShell(OST_OleObject);
752 : else
753 0 : SetCurSubShell(OST_Cell);
754 0 : }
755 :
756 0 : void ScTabViewShell::SetEditShell(EditView* pView, bool bActive )
757 : {
758 0 : if(bActive)
759 : {
760 0 : if (pEditShell)
761 0 : pEditShell->SetEditView( pView );
762 : else
763 0 : pEditShell = new ScEditShell( pView, &GetViewData() );
764 :
765 0 : SetCurSubShell(OST_Editing);
766 : }
767 0 : else if(bActiveEditSh)
768 : {
769 0 : SetCurSubShell(OST_Cell);
770 : }
771 0 : bActiveEditSh = bActive;
772 0 : }
773 :
774 1135 : void ScTabViewShell::SetCurSubShell(ObjectSelectionType eOST, bool bForce)
775 : {
776 1135 : ScViewData& rViewData = GetViewData();
777 1135 : ScDocShell* pDocSh = rViewData.GetDocShell();
778 :
779 2270 : if(bDontSwitch) return;
780 :
781 1135 : if(!pCellShell) //Wird eh immer gebraucht.
782 : {
783 348 : pCellShell = new ScCellShell( &GetViewData() );
784 348 : pCellShell->SetRepeatTarget( &aTarget );
785 : }
786 :
787 1135 : bool bPgBrk = rViewData.IsPagebreakMode();
788 :
789 1135 : if(bPgBrk && !pPageBreakShell)
790 : {
791 1 : pPageBreakShell = new ScPageBreakShell( this );
792 1 : pPageBreakShell->SetRepeatTarget( &aTarget );
793 : }
794 :
795 1135 : if ( eOST!=eCurOST || bForce )
796 : {
797 358 : bool bCellBrush = false; // "format paint brush" allowed for cells
798 358 : bool bDrawBrush = false; // "format paint brush" allowed for drawing objects
799 :
800 358 : if(eCurOST!=OST_NONE) RemoveSubShell();
801 :
802 358 : if (pFormShell && !bFormShellAtTop)
803 358 : AddSubShell(*pFormShell); // add below own subshells
804 :
805 358 : switch(eOST)
806 : {
807 : case OST_Cell:
808 : {
809 350 : AddSubShell(*pCellShell);
810 350 : if(bPgBrk) AddSubShell(*pPageBreakShell);
811 350 : bCellBrush = true;
812 : }
813 350 : break;
814 : case OST_Editing:
815 : {
816 0 : AddSubShell(*pCellShell);
817 0 : if(bPgBrk) AddSubShell(*pPageBreakShell);
818 :
819 0 : if(pEditShell)
820 : {
821 0 : AddSubShell(*pEditShell);
822 : }
823 : }
824 0 : break;
825 : case OST_DrawText:
826 : {
827 0 : if ( !pDrawTextShell )
828 : {
829 0 : pDocSh->MakeDrawLayer();
830 0 : pDrawTextShell = new ScDrawTextObjectBar( &GetViewData() );
831 : }
832 0 : AddSubShell(*pDrawTextShell);
833 : }
834 0 : break;
835 : case OST_Drawing:
836 : {
837 6 : if (svx::checkForSelectedCustomShapes(
838 6 : GetScDrawView(), true /* bOnlyExtruded */ )) {
839 0 : if (pExtrusionBarShell == 0)
840 0 : pExtrusionBarShell = new svx::ExtrusionBar(this);
841 0 : AddSubShell( *pExtrusionBarShell );
842 : }
843 6 : sal_uInt32 nCheckStatus = 0;
844 6 : if (svx::checkForSelectedFontWork(
845 6 : GetScDrawView(), nCheckStatus )) {
846 0 : if (pFontworkBarShell == 0)
847 0 : pFontworkBarShell = new svx::FontworkBar(this);
848 0 : AddSubShell( *pFontworkBarShell );
849 : }
850 :
851 6 : if ( !pDrawShell )
852 : {
853 1 : pDocSh->MakeDrawLayer();
854 1 : pDrawShell = new ScDrawShell( &GetViewData() );
855 1 : pDrawShell->SetRepeatTarget( &aTarget );
856 : }
857 6 : AddSubShell(*pDrawShell);
858 6 : bDrawBrush = true;
859 : }
860 6 : break;
861 :
862 : case OST_DrawForm:
863 : {
864 0 : if ( !pDrawFormShell )
865 : {
866 0 : pDocSh->MakeDrawLayer();
867 0 : pDrawFormShell = new ScDrawFormShell( &GetViewData() );
868 0 : pDrawFormShell->SetRepeatTarget( &aTarget );
869 : }
870 0 : AddSubShell(*pDrawFormShell);
871 0 : bDrawBrush = true;
872 : }
873 0 : break;
874 :
875 : case OST_Chart:
876 : {
877 0 : if ( !pChartShell )
878 : {
879 0 : pDocSh->MakeDrawLayer();
880 0 : pChartShell = new ScChartShell( &GetViewData() );
881 0 : pChartShell->SetRepeatTarget( &aTarget );
882 : }
883 0 : AddSubShell(*pChartShell);
884 0 : bDrawBrush = true;
885 : }
886 0 : break;
887 :
888 : case OST_OleObject:
889 : {
890 0 : if ( !pOleObjectShell )
891 : {
892 0 : pDocSh->MakeDrawLayer();
893 0 : pOleObjectShell = new ScOleObjectShell( &GetViewData() );
894 0 : pOleObjectShell->SetRepeatTarget( &aTarget );
895 : }
896 0 : AddSubShell(*pOleObjectShell);
897 0 : bDrawBrush = true;
898 : }
899 0 : break;
900 :
901 : case OST_Graphic:
902 : {
903 1 : if ( !pGraphicShell)
904 : {
905 1 : pDocSh->MakeDrawLayer();
906 1 : pGraphicShell = new ScGraphicShell( &GetViewData() );
907 1 : pGraphicShell->SetRepeatTarget( &aTarget );
908 : }
909 1 : AddSubShell(*pGraphicShell);
910 1 : bDrawBrush = true;
911 : }
912 1 : break;
913 :
914 : case OST_Media:
915 : {
916 0 : if ( !pMediaShell)
917 : {
918 0 : pDocSh->MakeDrawLayer();
919 0 : pMediaShell = new ScMediaShell( &GetViewData() );
920 0 : pMediaShell->SetRepeatTarget( &aTarget );
921 : }
922 0 : AddSubShell(*pMediaShell);
923 : }
924 0 : break;
925 :
926 : case OST_Pivot:
927 : {
928 1 : AddSubShell(*pCellShell);
929 1 : if(bPgBrk) AddSubShell(*pPageBreakShell);
930 :
931 1 : if ( !pPivotShell )
932 : {
933 1 : pPivotShell = new ScPivotShell( this );
934 1 : pPivotShell->SetRepeatTarget( &aTarget );
935 : }
936 1 : AddSubShell(*pPivotShell);
937 1 : bCellBrush = true;
938 : }
939 1 : break;
940 : case OST_Auditing:
941 : {
942 0 : AddSubShell(*pCellShell);
943 0 : if(bPgBrk) AddSubShell(*pPageBreakShell);
944 :
945 0 : if ( !pAuditingShell )
946 : {
947 0 : pDocSh->MakeDrawLayer(); // die Wartezeit lieber jetzt als beim Klick
948 :
949 0 : pAuditingShell = new ScAuditingShell( &GetViewData() );
950 0 : pAuditingShell->SetRepeatTarget( &aTarget );
951 : }
952 0 : AddSubShell(*pAuditingShell);
953 0 : bCellBrush = true;
954 : }
955 0 : break;
956 : default:
957 : OSL_FAIL("Falsche Shell angefordert");
958 0 : break;
959 : }
960 :
961 358 : if (pFormShell && bFormShellAtTop)
962 0 : AddSubShell(*pFormShell); // add on top of own subshells
963 :
964 358 : eCurOST=eOST;
965 :
966 : // abort "format paint brush" when switching to an incompatible shell
967 358 : if ( ( GetBrushDocument() && !bCellBrush ) || ( GetDrawBrushSet() && !bDrawBrush ) )
968 0 : ResetBrushDocument();
969 : }
970 : }
971 :
972 502 : void ScTabViewShell::SetFormShellAtTop( bool bSet )
973 : {
974 502 : if ( pFormShell && !bSet )
975 502 : pFormShell->ForgetActiveControl(); // let the FormShell know it no longer has the focus
976 :
977 502 : if ( bFormShellAtTop != bSet )
978 : {
979 0 : bFormShellAtTop = bSet;
980 0 : SetCurSubShell( GetCurObjectSelectionType(), true );
981 : }
982 502 : }
983 :
984 0 : IMPL_LINK_NOARG(ScTabViewShell, FormControlActivated)
985 : {
986 : // a form control got the focus, so the form shell has to be on top
987 0 : SetFormShellAtTop( true );
988 0 : return 0;
989 : }
990 :
991 : // GetMySubShell / SetMySubShell: altes Verhalten simulieren,
992 : // dass es nur eine SubShell gibt (nur innerhalb der 5 eignenen SubShells)
993 :
994 0 : SfxShell* ScTabViewShell::GetMySubShell() const
995 : {
996 : // GetSubShell() war frueher const, und GetSubShell(sal_uInt16) sollte es auch sein...
997 :
998 0 : sal_uInt16 nPos = 0;
999 0 : SfxShell* pSub = const_cast<ScTabViewShell*>(this)->GetSubShell(nPos);
1000 0 : while (pSub)
1001 : {
1002 0 : if ( pSub == pDrawShell || pSub == pDrawTextShell || pSub == pEditShell ||
1003 0 : pSub == pPivotShell || pSub == pAuditingShell || pSub == pDrawFormShell ||
1004 0 : pSub == pCellShell || pSub == pOleObjectShell|| pSub == pChartShell ||
1005 0 : pSub == pGraphicShell || pSub == pMediaShell || pSub == pPageBreakShell)
1006 0 : return pSub; // gefunden
1007 :
1008 0 : pSub = const_cast<ScTabViewShell*>(this)->GetSubShell(++nPos);
1009 : }
1010 0 : return NULL; // keine von meinen dabei
1011 : }
1012 :
1013 1848 : bool ScTabViewShell::IsDrawTextShell() const
1014 : {
1015 1848 : return ( pDrawTextShell && ( GetMySubShell() == pDrawTextShell ) );
1016 : }
1017 :
1018 0 : bool ScTabViewShell::IsAuditShell() const
1019 : {
1020 0 : return ( pAuditingShell && ( GetMySubShell() == pAuditingShell ) );
1021 : }
1022 :
1023 0 : void ScTabViewShell::SetDrawTextUndo( ::svl::IUndoManager* pNewUndoMgr )
1024 : {
1025 : // Default: Undo-Manager der DocShell
1026 0 : if (!pNewUndoMgr)
1027 0 : pNewUndoMgr = GetViewData().GetDocShell()->GetUndoManager();
1028 :
1029 0 : if (pDrawTextShell)
1030 : {
1031 0 : pDrawTextShell->SetUndoManager(pNewUndoMgr);
1032 0 : ScDocShell* pDocSh = GetViewData().GetDocShell();
1033 0 : if ( pNewUndoMgr == pDocSh->GetUndoManager() &&
1034 0 : !pDocSh->GetDocument().IsUndoEnabled() )
1035 : {
1036 0 : pNewUndoMgr->SetMaxUndoActionCount( 0 );
1037 : }
1038 : }
1039 : else
1040 : {
1041 : OSL_FAIL("SetDrawTextUndo ohne DrawTextShell");
1042 : }
1043 0 : }
1044 :
1045 50321 : ScTabViewShell* ScTabViewShell::GetActiveViewShell()
1046 : {
1047 50321 : return PTR_CAST(ScTabViewShell,Current());
1048 : }
1049 :
1050 1187 : SfxPrinter* ScTabViewShell::GetPrinter( bool bCreate )
1051 : {
1052 : // Drucker ist immer da (wird fuer die FontListe schon beim Starten angelegt)
1053 1187 : return GetViewData().GetDocShell()->GetPrinter(bCreate);
1054 : }
1055 :
1056 0 : sal_uInt16 ScTabViewShell::SetPrinter( SfxPrinter *pNewPrinter, SfxPrinterChangeFlags nDiffFlags, bool )
1057 : {
1058 0 : return GetViewData().GetDocShell()->SetPrinter( pNewPrinter, nDiffFlags );
1059 : }
1060 :
1061 0 : bool ScTabViewShell::HasPrintOptionsPage() const
1062 : {
1063 0 : return true;
1064 : }
1065 :
1066 0 : VclPtr<SfxTabPage> ScTabViewShell::CreatePrintOptionsPage( vcl::Window *pParent, const SfxItemSet &rOptions )
1067 : {
1068 0 : ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
1069 : OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
1070 0 : ::CreateTabPage ScTpPrintOptionsCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_PRINT );
1071 0 : if ( ScTpPrintOptionsCreate )
1072 0 : return ScTpPrintOptionsCreate( pParent, &rOptions );
1073 0 : return VclPtr<SfxTabPage>();
1074 : }
1075 :
1076 2685 : void ScTabViewShell::StopEditShell()
1077 : {
1078 2685 : if ( pEditShell != NULL && !bDontSwitch )
1079 0 : SetEditShell(NULL, false );
1080 2685 : }
1081 :
1082 : // close handler to ensure function of dialog:
1083 :
1084 0 : IMPL_LINK_NOARG(ScTabViewShell, SimpleRefClose)
1085 : {
1086 0 : SfxInPlaceClient* pClient = GetIPClient();
1087 0 : if ( pClient && pClient->IsObjectInPlaceActive() )
1088 : {
1089 : // If range selection was started with an active embedded object,
1090 : // switch back to original sheet (while the dialog is still open).
1091 :
1092 0 : SetTabNo( GetViewData().GetRefTabNo() );
1093 : }
1094 :
1095 0 : ScSimpleRefDlgWrapper::SetAutoReOpen( true );
1096 0 : return 0;
1097 : }
1098 :
1099 : // handlers to call UNO listeners:
1100 :
1101 0 : static ScTabViewObj* lcl_GetViewObj( ScTabViewShell& rShell )
1102 : {
1103 0 : ScTabViewObj* pRet = NULL;
1104 0 : SfxViewFrame* pViewFrame = rShell.GetViewFrame();
1105 0 : if (pViewFrame)
1106 : {
1107 0 : SfxFrame& rFrame = pViewFrame->GetFrame();
1108 0 : uno::Reference<frame::XController> xController = rFrame.GetController();
1109 0 : if (xController.is())
1110 0 : pRet = ScTabViewObj::getImplementation( xController );
1111 : }
1112 0 : return pRet;
1113 : }
1114 :
1115 0 : IMPL_LINK( ScTabViewShell, SimpleRefDone, OUString*, pResult )
1116 : {
1117 0 : ScTabViewObj* pImpObj = lcl_GetViewObj( *this );
1118 0 : if ( pImpObj && pResult )
1119 0 : pImpObj->RangeSelDone( *pResult );
1120 0 : return 0;
1121 : }
1122 :
1123 0 : IMPL_LINK( ScTabViewShell, SimpleRefAborted, OUString*, pResult )
1124 : {
1125 0 : ScTabViewObj* pImpObj = lcl_GetViewObj( *this );
1126 0 : if ( pImpObj && pResult )
1127 0 : pImpObj->RangeSelAborted( *pResult );
1128 0 : return 0;
1129 : }
1130 :
1131 0 : IMPL_LINK( ScTabViewShell, SimpleRefChange, OUString*, pResult )
1132 : {
1133 0 : ScTabViewObj* pImpObj = lcl_GetViewObj( *this );
1134 0 : if ( pImpObj && pResult )
1135 0 : pImpObj->RangeSelChanged( *pResult );
1136 0 : return 0;
1137 : }
1138 :
1139 0 : void ScTabViewShell::StartSimpleRefDialog(
1140 : const OUString& rTitle, const OUString& rInitVal,
1141 : bool bCloseOnButtonUp, bool bSingleCell, bool bMultiSelection )
1142 : {
1143 0 : SfxViewFrame* pViewFrm = GetViewFrame();
1144 :
1145 0 : if ( GetActiveViewShell() != this )
1146 : {
1147 : // #i18833# / #i34499# The API method can be called for a view that's not active.
1148 : // Then the view has to be activated first, the same way as in Execute for SID_CURRENTDOC.
1149 : // Can't use GrabFocus here, because it needs to take effect immediately.
1150 :
1151 0 : pViewFrm->GetFrame().Appear();
1152 : }
1153 :
1154 0 : sal_uInt16 nId = ScSimpleRefDlgWrapper::GetChildWindowId();
1155 :
1156 0 : SC_MOD()->SetRefDialog( nId, true, pViewFrm );
1157 :
1158 0 : ScSimpleRefDlgWrapper* pWnd = static_cast<ScSimpleRefDlgWrapper*>(pViewFrm->GetChildWindow( nId ));
1159 0 : if (pWnd)
1160 : {
1161 0 : pWnd->SetCloseHdl( LINK( this, ScTabViewShell, SimpleRefClose ) );
1162 : pWnd->SetUnoLinks( LINK( this, ScTabViewShell, SimpleRefDone ),
1163 : LINK( this, ScTabViewShell, SimpleRefAborted ),
1164 0 : LINK( this, ScTabViewShell, SimpleRefChange ) );
1165 0 : pWnd->SetRefString( rInitVal );
1166 0 : pWnd->SetFlags( bCloseOnButtonUp, bSingleCell, bMultiSelection );
1167 0 : ScSimpleRefDlgWrapper::SetAutoReOpen( false );
1168 0 : vcl::Window* pWin = pWnd->GetWindow();
1169 0 : pWin->SetText( rTitle );
1170 0 : pWnd->StartRefInput();
1171 : }
1172 0 : }
1173 :
1174 0 : void ScTabViewShell::StopSimpleRefDialog()
1175 : {
1176 0 : SfxViewFrame* pViewFrm = GetViewFrame();
1177 0 : sal_uInt16 nId = ScSimpleRefDlgWrapper::GetChildWindowId();
1178 :
1179 0 : ScSimpleRefDlgWrapper* pWnd = static_cast<ScSimpleRefDlgWrapper*>(pViewFrm->GetChildWindow( nId ));
1180 0 : if (pWnd)
1181 : {
1182 0 : vcl::Window* pWin = pWnd->GetWindow();
1183 0 : if (pWin && pWin->IsSystemWindow())
1184 0 : static_cast<SystemWindow*>(pWin)->Close(); // calls abort handler
1185 : }
1186 0 : }
1187 :
1188 0 : bool ScTabViewShell::TabKeyInput(const KeyEvent& rKEvt)
1189 : {
1190 0 : ScModule* pScMod = SC_MOD();
1191 :
1192 0 : SfxViewFrame* pThisFrame = GetViewFrame();
1193 0 : if ( pThisFrame->GetChildWindow( SID_OPENDLG_FUNCTION ) )
1194 0 : return false;
1195 :
1196 0 : vcl::KeyCode aCode = rKEvt.GetKeyCode();
1197 0 : bool bShift = aCode.IsShift();
1198 0 : bool bControl = aCode.IsMod1();
1199 0 : bool bAlt = aCode.IsMod2();
1200 0 : sal_uInt16 nCode = aCode.GetCode();
1201 0 : bool bUsed = false;
1202 0 : bool bInPlace = pScMod->IsEditMode(); // Editengine bekommt alles
1203 0 : bool bAnyEdit = pScMod->IsInputMode(); // nur Zeichen & Backspace
1204 0 : bool bDraw = IsDrawTextEdit();
1205 :
1206 0 : HideNoteMarker(); // Notiz-Anzeige
1207 :
1208 : // don't do extra HideCursor/ShowCursor calls if EnterHandler will switch to a different sheet
1209 0 : bool bOnRefSheet = ( GetViewData().GetRefTabNo() == GetViewData().GetTabNo() );
1210 0 : bool bHideCursor = ( ( nCode == KEY_RETURN && bInPlace ) || nCode == KEY_TAB ) && bOnRefSheet;
1211 :
1212 0 : if (bHideCursor)
1213 0 : HideAllCursors();
1214 :
1215 0 : ScDocument* pDoc = GetViewData().GetDocument();
1216 0 : if ( pDoc )
1217 0 : pDoc->KeyInput( rKEvt ); // TimerDelays etc.
1218 :
1219 0 : if( bInPlace )
1220 : {
1221 0 : bUsed = pScMod->InputKeyEvent( rKEvt ); // Eingabe
1222 0 : if( !bUsed )
1223 0 : bUsed = SfxViewShell::KeyInput( rKEvt ); // accelerators
1224 : }
1225 0 : else if( bAnyEdit )
1226 : {
1227 0 : bool bIsType = false;
1228 0 : sal_uInt16 nModi = aCode.GetModifier();
1229 0 : sal_uInt16 nGroup = aCode.GetGroup();
1230 :
1231 0 : if ( nGroup == KEYGROUP_NUM || nGroup == KEYGROUP_ALPHA || nGroup == 0 )
1232 0 : if ( !bControl && !bAlt )
1233 0 : bIsType = true;
1234 :
1235 0 : if ( nGroup == KEYGROUP_MISC )
1236 0 : switch ( nCode )
1237 : {
1238 : case KEY_RETURN:
1239 0 : bIsType = bControl && !bAlt; // Control, Shift-Control-Return
1240 0 : if ( !bIsType && nModi == 0 )
1241 : {
1242 : // Will der InputHandler auch ein einfaches Return?
1243 :
1244 0 : ScInputHandler* pHdl = pScMod->GetInputHdl(this);
1245 0 : bIsType = pHdl && pHdl->TakesReturn();
1246 : }
1247 0 : break;
1248 : case KEY_SPACE:
1249 0 : bIsType = !bControl && !bAlt; // ohne Modifier oder Shift-Space
1250 0 : break;
1251 : case KEY_ESCAPE:
1252 0 : bIsType = (nModi == 0); // nur ohne Modifier
1253 0 : break;
1254 : default:
1255 0 : bIsType = true;
1256 : }
1257 :
1258 0 : if( bIsType )
1259 0 : bUsed = pScMod->InputKeyEvent( rKEvt ); // Eingabe
1260 :
1261 0 : if( !bUsed )
1262 0 : bUsed = SfxViewShell::KeyInput( rKEvt ); // accelerators
1263 :
1264 0 : if ( !bUsed && !bIsType && nCode != KEY_RETURN ) // Eingabe nochmal hinterher
1265 0 : bUsed = pScMod->InputKeyEvent( rKEvt );
1266 : }
1267 : else
1268 : {
1269 : // Spezialfall: Copy/Cut bei Mehrfachselektion -> Fehlermeldung
1270 : // (Slot ist disabled, SfxViewShell::KeyInput wuerde also kommentarlos verschluckt)
1271 0 : KeyFuncType eFunc = aCode.GetFunction();
1272 0 : if ( eFunc == KeyFuncType::CUT )
1273 : {
1274 0 : ScRange aDummy;
1275 0 : ScMarkType eMarkType = GetViewData().GetSimpleArea( aDummy );
1276 0 : if (eMarkType != SC_MARK_SIMPLE)
1277 : {
1278 0 : ErrorMessage(STR_NOMULTISELECT);
1279 0 : bUsed = true;
1280 : }
1281 : }
1282 0 : if (!bUsed)
1283 0 : bUsed = SfxViewShell::KeyInput( rKEvt ); // accelerators
1284 :
1285 : // during inplace editing, some slots are handled by the
1286 : // container app and are executed during Window::KeyInput.
1287 : // -> don't pass keys to input handler that would be used there
1288 : // but should call slots instead.
1289 0 : bool bParent = ( GetViewFrame()->GetFrame().IsInPlace() && eFunc != KeyFuncType::DONTKNOW );
1290 :
1291 0 : if( !bUsed && !bDraw && nCode != KEY_RETURN && !bParent )
1292 0 : bUsed = pScMod->InputKeyEvent( rKEvt, true ); // Eingabe
1293 : }
1294 :
1295 0 : if (!bInPlace && !bUsed && !bDraw)
1296 : {
1297 0 : switch (nCode)
1298 : {
1299 : case KEY_RETURN:
1300 : {
1301 0 : bool bNormal = !bControl && !bAlt;
1302 0 : if ( !bAnyEdit && bNormal )
1303 : {
1304 : // je nach Optionen mit Enter in den Edit-Modus schalten
1305 :
1306 0 : const ScInputOptions& rOpt = pScMod->GetInputOptions();
1307 0 : if ( rOpt.GetEnterEdit() )
1308 : {
1309 0 : pScMod->SetInputMode( SC_INPUT_TABLE );
1310 0 : bUsed = true;
1311 : }
1312 : }
1313 :
1314 0 : bool bEditReturn = bControl && !bShift; // An Edit-Engine weiter
1315 0 : if ( !bUsed && !bEditReturn )
1316 : {
1317 0 : if ( bOnRefSheet )
1318 0 : HideAllCursors();
1319 :
1320 0 : sal_uInt8 nMode = SC_ENTER_NORMAL;
1321 0 : if ( bShift && bControl )
1322 0 : nMode = SC_ENTER_MATRIX;
1323 0 : else if ( bAlt )
1324 0 : nMode = SC_ENTER_BLOCK;
1325 0 : pScMod->InputEnterHandler(nMode);
1326 :
1327 0 : if (nMode == SC_ENTER_NORMAL)
1328 : {
1329 0 : if( bShift )
1330 0 : GetViewData().GetDispatcher().Execute( SID_CURSORENTERUP,
1331 0 : SfxCallMode::SLOT | SfxCallMode::RECORD );
1332 : else
1333 0 : GetViewData().GetDispatcher().Execute( SID_CURSORENTERDOWN,
1334 0 : SfxCallMode::SLOT | SfxCallMode::RECORD );
1335 : }
1336 : else
1337 0 : UpdateInputHandler(true);
1338 :
1339 0 : if ( bOnRefSheet )
1340 0 : ShowAllCursors();
1341 :
1342 : // hier kein UpdateInputHandler, weil bei Referenzeingabe auf ein
1343 : // anderes Dokument diese ViewShell nicht die ist, auf der eingegeben
1344 : // wird!
1345 :
1346 0 : bUsed = true;
1347 : }
1348 : }
1349 0 : break;
1350 : }
1351 : }
1352 :
1353 : // Alt-Cursortasten hart codiert, weil Alt nicht konfigurierbar ist
1354 :
1355 0 : if ( !bUsed && bAlt && !bControl )
1356 : {
1357 0 : sal_uInt16 nSlotId = 0;
1358 0 : switch (nCode)
1359 : {
1360 : case KEY_UP:
1361 0 : ModifyCellSize( DIR_TOP, bShift );
1362 0 : bUsed = true;
1363 0 : break;
1364 : case KEY_DOWN:
1365 0 : ModifyCellSize( DIR_BOTTOM, bShift );
1366 0 : bUsed = true;
1367 0 : break;
1368 : case KEY_LEFT:
1369 0 : ModifyCellSize( DIR_LEFT, bShift );
1370 0 : bUsed = true;
1371 0 : break;
1372 : case KEY_RIGHT:
1373 0 : ModifyCellSize( DIR_RIGHT, bShift );
1374 0 : bUsed = true;
1375 0 : break;
1376 : case KEY_PAGEUP:
1377 0 : nSlotId = bShift ? SID_CURSORPAGELEFT_SEL : SID_CURSORPAGELEFT_;
1378 0 : break;
1379 : case KEY_PAGEDOWN:
1380 0 : nSlotId = bShift ? SID_CURSORPAGERIGHT_SEL : SID_CURSORPAGERIGHT_;
1381 0 : break;
1382 : }
1383 0 : if ( nSlotId )
1384 : {
1385 0 : GetViewData().GetDispatcher().Execute( nSlotId, SfxCallMode::SLOT | SfxCallMode::RECORD );
1386 0 : bUsed = true;
1387 : }
1388 : }
1389 :
1390 : // use Ctrl+Alt+Shift+arrow keys to move the cursor in cells
1391 : // while keeping the last selection
1392 0 : if ( !bUsed && bAlt && bControl && bShift)
1393 : {
1394 0 : sal_uInt16 nSlotId = 0;
1395 0 : switch (nCode)
1396 : {
1397 : case KEY_UP:
1398 0 : nSlotId = SID_CURSORUP;
1399 0 : break;
1400 : case KEY_DOWN:
1401 0 : nSlotId = SID_CURSORDOWN;
1402 0 : break;
1403 : case KEY_LEFT:
1404 0 : nSlotId = SID_CURSORLEFT;
1405 0 : break;
1406 : case KEY_RIGHT:
1407 0 : nSlotId = SID_CURSORRIGHT;
1408 0 : break;
1409 : case KEY_PAGEUP:
1410 0 : nSlotId = SID_CURSORPAGEUP;
1411 0 : break;
1412 : case KEY_PAGEDOWN:
1413 0 : nSlotId = SID_CURSORPAGEDOWN;
1414 0 : break;
1415 : case KEY_HOME:
1416 0 : nSlotId = SID_CURSORHOME;
1417 0 : break;
1418 : case KEY_END:
1419 0 : nSlotId = SID_CURSOREND;
1420 0 : break;
1421 : default:
1422 0 : nSlotId = 0;
1423 0 : break;
1424 : }
1425 0 : if ( nSlotId )
1426 : {
1427 0 : sal_uInt16 nMode = GetLockedModifiers();
1428 0 : LockModifiers(KEY_MOD1);
1429 0 : GetViewData().GetDispatcher().Execute( nSlotId, SfxCallMode::SLOT | SfxCallMode::RECORD );
1430 0 : LockModifiers(nMode);
1431 0 : bUsed = true;
1432 : }
1433 : }
1434 0 : if (bHideCursor)
1435 0 : ShowAllCursors();
1436 :
1437 0 : return bUsed;
1438 : }
1439 :
1440 0 : bool ScTabViewShell::SfxKeyInput(const KeyEvent& rKeyEvent)
1441 : {
1442 0 : return SfxViewShell::KeyInput( rKeyEvent );
1443 : }
1444 :
1445 0 : bool ScTabViewShell::KeyInput( const KeyEvent &rKeyEvent )
1446 : {
1447 0 : return TabKeyInput( rKeyEvent );
1448 : }
1449 :
1450 348 : void ScTabViewShell::Construct( TriState nForceDesignMode )
1451 : {
1452 348 : SfxApplication* pSfxApp = SfxGetpApp();
1453 348 : ScDocShell* pDocSh = GetViewData().GetDocShell();
1454 348 : ScDocument& rDoc = pDocSh->GetDocument();
1455 348 : bReadOnly = pDocSh->IsReadOnly();
1456 348 : bIsActive = false;
1457 :
1458 348 : EnableAutoSpell(rDoc.GetDocOptions().IsAutoSpell());
1459 :
1460 348 : SetName(OUString("View")); // fuer SBX
1461 348 : Color aColBlack( COL_BLACK );
1462 348 : SetPool( &SC_MOD()->GetPool() );
1463 348 : SetWindow( GetActiveWin() );
1464 :
1465 : pCurFrameLine = new ::editeng::SvxBorderLine(&aColBlack, 20,
1466 348 : table::BorderLineStyle::SOLID);
1467 348 : pPivotSource = new ScArea;
1468 348 : StartListening(*GetViewData().GetDocShell(),true);
1469 348 : StartListening(*GetViewFrame(),true);
1470 348 : StartListening(*pSfxApp,true); // #i62045# #i62046# application is needed for Calc's own hints
1471 :
1472 348 : SfxViewFrame* pFirst = SfxViewFrame::GetFirst(pDocSh);
1473 : bool bFirstView = !pFirst
1474 348 : || (pFirst == GetViewFrame() && !SfxViewFrame::GetNext(*pFirst,pDocSh));
1475 :
1476 348 : if ( pDocSh->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
1477 : {
1478 : //TODO/LATER: is there a difference between the two GetVisArea methods?
1479 1 : Rectangle aVisArea = static_cast<const SfxObjectShell*>(pDocSh)->GetVisArea();
1480 :
1481 1 : SCTAB nVisTab = rDoc.GetVisibleTab();
1482 1 : if (!rDoc.HasTable(nVisTab))
1483 : {
1484 0 : nVisTab = 0;
1485 0 : rDoc.SetVisibleTab(nVisTab);
1486 : }
1487 1 : SetTabNo( nVisTab );
1488 1 : bool bNegativePage = rDoc.IsNegativePage( nVisTab );
1489 : // show the right cells
1490 1 : GetViewData().SetScreenPos( bNegativePage ? aVisArea.TopRight() : aVisArea.TopLeft() );
1491 :
1492 1 : if ( GetViewFrame()->GetFrame().IsInPlace() ) // inplace
1493 : {
1494 0 : pDocSh->SetInplace( true ); // schon so initialisiert
1495 0 : if (rDoc.IsEmbedded())
1496 0 : rDoc.ResetEmbedded(); // keine blaue Markierung
1497 : }
1498 1 : else if ( bFirstView )
1499 : {
1500 1 : pDocSh->SetInplace( false );
1501 1 : GetViewData().RefreshZoom(); // recalculate PPT
1502 1 : if (!rDoc.IsEmbedded())
1503 1 : rDoc.SetEmbedded( rDoc.GetVisibleTab(), aVisArea ); // VisArea markieren
1504 : }
1505 : }
1506 :
1507 : // ViewInputHandler
1508 : // jeder Task hat neuerdings sein eigenes InputWindow,
1509 : // darum muesste eigentlich entweder jeder Task seinen InputHandler bekommen,
1510 : // oder das InputWindow muesste sich beim App-InputHandler anmelden, wenn der
1511 : // Task aktiv wird, oder das InputWindow muesste sich den InputHandler selbst
1512 : // anlegen (dann immer ueber das InputWindow suchen, und nur wenn das nicht da
1513 : // ist, den InputHandler von der App nehmen).
1514 : // Als Sofortloesung bekommt erstmal jede View ihren Inputhandler, das gibt
1515 : // nur noch Probleme, wenn zwei Views in einem Task-Fenster sind.
1516 :
1517 348 : pInputHandler = new ScInputHandler;
1518 :
1519 : // Alte Version:
1520 : // if ( !GetViewFrame()->ISA(SfxTopViewFrame) ) // OLE oder Plug-In
1521 : // pInputHandler = new ScInputHandler;
1522 :
1523 : // FormShell vor MakeDrawView anlegen, damit die DrawView auf jeden Fall
1524 : // an der FormShell angemeldet werden kann
1525 : // Gepusht wird die FormShell im ersten Activate
1526 348 : pFormShell = new FmFormShell(this);
1527 348 : pFormShell->SetControlActivationHandler( LINK( this, ScTabViewShell, FormControlActivated ) );
1528 :
1529 : // DrawView darf nicht im TabView - ctor angelegt werden,
1530 : // wenn die ViewShell noch nicht kostruiert ist...
1531 348 : if (rDoc.GetDrawLayer())
1532 135 : MakeDrawView( nForceDesignMode );
1533 348 : ViewOptionsHasChanged(false); // legt auch evtl. DrawView an
1534 :
1535 348 : ::svl::IUndoManager* pMgr = pDocSh->GetUndoManager();
1536 348 : SetUndoManager( pMgr );
1537 348 : pFormShell->SetUndoManager( pMgr );
1538 348 : if ( !rDoc.IsUndoEnabled() )
1539 : {
1540 0 : pMgr->SetMaxUndoActionCount( 0 );
1541 : }
1542 348 : SetRepeatTarget( &aTarget );
1543 348 : pFormShell->SetRepeatTarget( &aTarget );
1544 348 : SetHelpId( HID_SCSHELL_TABVWSH );
1545 :
1546 348 : if ( bFirstView ) // first view?
1547 : {
1548 347 : rDoc.SetDocVisible( true ); // used when creating new sheets
1549 347 : if ( pDocSh->IsEmpty() )
1550 : {
1551 : // set first sheet's RTL flag (following will already be initialized because of SetDocVisible)
1552 187 : rDoc.SetLayoutRTL( 0, ScGlobal::IsSystemRTL() );
1553 :
1554 : // append additional sheets (not for OLE object)
1555 187 : if ( pDocSh->GetCreateMode() != SfxObjectCreateMode::EMBEDDED )
1556 : {
1557 : // Get the customized initial tab count
1558 187 : const ScDefaultsOptions& rOpt = SC_MOD()->GetDefaultsOptions();
1559 187 : SCTAB nInitTabCount = rOpt.GetInitTabCount();
1560 :
1561 187 : for (SCTAB i=1; i<nInitTabCount; i++)
1562 0 : rDoc.MakeTable(i,false);
1563 : }
1564 :
1565 187 : pDocSh->SetEmpty( false ); // #i6232# make sure this is done only once
1566 : }
1567 :
1568 : // ReadExtOptions is now in Activate
1569 :
1570 : // Link-Update nicht verschachteln
1571 694 : if ( pDocSh->GetCreateMode() != SfxObjectCreateMode::INTERNAL &&
1572 347 : pDocSh->IsUpdateEnabled() ) // #105575#; update only in the first creation of the ViewShell
1573 : {
1574 : // Check if there are any external data.
1575 347 : bool bLink = rDoc.GetExternalRefManager()->hasExternalData();
1576 347 : if (!bLink)
1577 : {
1578 : // #i100042# sheet links can still exist independently from external formula references
1579 347 : SCTAB nTabCount = rDoc.GetTableCount();
1580 851 : for (SCTAB i=0; i<nTabCount && !bLink; i++)
1581 504 : if (rDoc.IsLinked(i))
1582 0 : bLink = true;
1583 : }
1584 347 : if (!bLink)
1585 : {
1586 347 : const sc::DocumentLinkManager& rMgr = rDoc.GetDocLinkManager();
1587 347 : if (rMgr.hasDdeLinks() || rDoc.HasAreaLinks())
1588 0 : bLink = true;
1589 : }
1590 347 : if (bLink)
1591 : {
1592 0 : if ( !pFirst )
1593 0 : pFirst = GetViewFrame();
1594 :
1595 0 : if(SC_MOD()->GetCurRefDlgId()==0)
1596 : {
1597 : pFirst->GetDispatcher()->Execute( SID_UPDATETABLINKS,
1598 0 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
1599 : }
1600 : }
1601 :
1602 347 : bool bReImport = false; // importierte Daten aktualisieren
1603 347 : ScDBCollection* pDBColl = rDoc.GetDBCollection();
1604 347 : if ( pDBColl )
1605 : {
1606 347 : const ScDBCollection::NamedDBs& rDBs = pDBColl->getNamedDBs();
1607 347 : ScDBCollection::NamedDBs::const_iterator itr = rDBs.begin(), itrEnd = rDBs.end();
1608 354 : for (; itr != itrEnd; ++itr)
1609 : {
1610 7 : if (itr->IsStripData() && itr->HasImportParam() && !itr->HasImportSelection())
1611 : {
1612 0 : bReImport = true;
1613 0 : break;
1614 : }
1615 : }
1616 : }
1617 347 : if (bReImport)
1618 : {
1619 0 : if ( !pFirst )
1620 0 : pFirst = GetViewFrame();
1621 0 : if(SC_MOD()->GetCurRefDlgId()==0)
1622 : {
1623 : pFirst->GetDispatcher()->Execute( SID_REIMPORT_AFTER_LOAD,
1624 0 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
1625 : }
1626 : }
1627 : }
1628 : }
1629 :
1630 348 : UpdateAutoFillMark();
1631 :
1632 : // ScDispatchProviderInterceptor registers itself in ctor
1633 348 : xDisProvInterceptor = new ScDispatchProviderInterceptor( this );
1634 :
1635 348 : bFirstActivate = true; // NavigatorUpdate aufschieben bis Activate()
1636 :
1637 : // #105575#; update only in the first creation of the ViewShell
1638 348 : pDocSh->SetUpdateEnabled(false);
1639 :
1640 348 : if ( GetViewFrame()->GetFrame().IsInPlace() )
1641 0 : UpdateHeaderWidth(); // The implace activation requires headers to be calculated
1642 :
1643 348 : SvBorder aBorder;
1644 348 : GetBorderSize( aBorder, Size() );
1645 348 : SetBorderPixel( aBorder );
1646 348 : }
1647 :
1648 348 : ScTabViewShell::ScTabViewShell( SfxViewFrame* pViewFrame,
1649 : SfxViewShell* pOldSh ) :
1650 696 : SfxViewShell( pViewFrame, SfxViewShellFlags::CAN_PRINT | SfxViewShellFlags::HAS_PRINTOPTIONS ),
1651 348 : ScDBFunc( &pViewFrame->GetWindow(), static_cast<ScDocShell&>(*pViewFrame->GetObjectShell()), this ),
1652 : eCurOST(OST_NONE),
1653 : nDrawSfxId(0),
1654 : nCtrlSfxId(USHRT_MAX),
1655 : nFormSfxId(USHRT_MAX),
1656 : pDrawShell(NULL),
1657 : pDrawTextShell(NULL),
1658 : pEditShell(NULL),
1659 : pPivotShell(NULL),
1660 : pAuditingShell(NULL),
1661 : pDrawFormShell(NULL),
1662 : pCellShell(NULL),
1663 : pOleObjectShell(NULL),
1664 : pChartShell(NULL),
1665 : pGraphicShell(NULL),
1666 : pMediaShell(NULL),
1667 : pPageBreakShell(NULL),
1668 : pExtrusionBarShell(NULL),
1669 : pFontworkBarShell(NULL),
1670 : pFormShell(NULL),
1671 : pInputHandler(NULL),
1672 : pCurFrameLine(NULL),
1673 : aTarget(this),
1674 : pDialogDPObject(NULL),
1675 : pNavSettings(NULL),
1676 : bActiveDrawSh(false),
1677 : bActiveDrawTextSh(false),
1678 : bActivePivotSh(false),
1679 : bActiveAuditingSh(false),
1680 : bActiveDrawFormSh(false),
1681 : bActiveOleObjectSh(false),
1682 : bActiveChartSh(false),
1683 : bActiveGraphicSh(false),
1684 : bActiveMediaSh(false),
1685 : bActiveEditSh(false),
1686 : bFormShellAtTop(false),
1687 : bDontSwitch(false),
1688 : bInFormatDialog(false),
1689 : bPrintSelected(false),
1690 : bReadOnly(false),
1691 : pScSbxObject(NULL),
1692 : bChartAreaValid(false),
1693 : bForceFocusOnCurCell(false),
1694 : nCurRefDlgId(0),
1695 : pAccessibilityBroadcaster(NULL),
1696 696 : mbInSwitch(false)
1697 : {
1698 348 : const ScAppOptions& rAppOpt = SC_MOD()->GetAppOptions();
1699 :
1700 : // if switching back from print preview,
1701 : // restore the view settings that were active when creating the preview
1702 : // ReadUserData must not happen from ctor, because the view's edit window
1703 : // has to be shown by the sfx. ReadUserData is deferred until the first Activate call.
1704 : // old DesignMode state from form layer must be restored, too
1705 :
1706 348 : TriState nForceDesignMode = TRISTATE_INDET;
1707 348 : if ( pOldSh && pOldSh->ISA( ScPreviewShell ) )
1708 : {
1709 0 : ScPreviewShell* pPreviewShell = static_cast<ScPreviewShell*>(pOldSh);
1710 0 : nForceDesignMode = pPreviewShell->GetSourceDesignMode();
1711 0 : ScPreview* p = pPreviewShell->GetPreview();
1712 0 : if (p)
1713 0 : GetViewData().GetMarkData().SetSelectedTabs(p->GetSelectedTabs());
1714 : }
1715 :
1716 348 : Construct( nForceDesignMode );
1717 :
1718 348 : if ( GetViewData().GetDocShell()->IsPreview() )
1719 : {
1720 : // preview for template dialog: always show whole page
1721 0 : SetZoomType( SvxZoomType::WHOLEPAGE, true ); // zoom value is recalculated at next Resize
1722 : }
1723 : else
1724 : {
1725 348 : Fraction aFract( rAppOpt.GetZoom(), 100 );
1726 348 : SetZoom( aFract, aFract, true );
1727 348 : SetZoomType( rAppOpt.GetZoomType(), true );
1728 : }
1729 :
1730 : // make Controller known to SFX
1731 348 : new ScTabViewObj( this );
1732 :
1733 348 : SetCurSubShell(OST_Cell);
1734 348 : SvBorder aBorder;
1735 348 : GetBorderSize( aBorder, Size() );
1736 348 : SetBorderPixel( aBorder );
1737 :
1738 : // #114409#
1739 348 : MakeDrawLayer();
1740 348 : }
1741 :
1742 1035 : ScTabViewShell::~ScTabViewShell()
1743 : {
1744 345 : ScDocShell* pDocSh = GetViewData().GetDocShell();
1745 345 : EndListening(*pDocSh);
1746 345 : EndListening(*GetViewFrame());
1747 345 : EndListening(*SfxGetpApp()); // #i62045# #i62046# needed now - SfxViewShell no longer does it
1748 :
1749 345 : SC_MOD()->ViewShellGone(this);
1750 :
1751 345 : RemoveSubShell(); // alle
1752 345 : SetWindow(0);
1753 :
1754 : // alles auf NULL, falls aus dem TabView-dtor noch darauf zugegriffen wird
1755 : //! (soll eigentlich nicht !??!?!)
1756 :
1757 345 : if (pInputHandler)
1758 345 : pInputHandler->SetDocumentDisposing(true);
1759 :
1760 345 : DELETEZ(pFontworkBarShell);
1761 345 : DELETEZ(pExtrusionBarShell);
1762 345 : DELETEZ(pCellShell);
1763 345 : DELETEZ(pPageBreakShell);
1764 345 : DELETEZ(pDrawShell);
1765 345 : DELETEZ(pDrawFormShell);
1766 345 : DELETEZ(pOleObjectShell);
1767 345 : DELETEZ(pChartShell);
1768 345 : DELETEZ(pGraphicShell);
1769 345 : DELETEZ(pMediaShell);
1770 345 : DELETEZ(pDrawTextShell);
1771 345 : DELETEZ(pEditShell);
1772 345 : DELETEZ(pPivotShell);
1773 345 : DELETEZ(pAuditingShell);
1774 345 : DELETEZ(pCurFrameLine);
1775 345 : DELETEZ(pInputHandler);
1776 345 : DELETEZ(pPivotSource);
1777 345 : DELETEZ(pDialogDPObject);
1778 345 : DELETEZ(pNavSettings);
1779 :
1780 345 : DELETEZ(pFormShell);
1781 345 : DELETEZ(pAccessibilityBroadcaster);
1782 690 : }
1783 :
1784 0 : void ScTabViewShell::SetDialogDPObject( const ScDPObject* pObj )
1785 : {
1786 0 : delete pDialogDPObject;
1787 0 : if (pObj)
1788 0 : pDialogDPObject = new ScDPObject( *pObj );
1789 : else
1790 0 : pDialogDPObject = NULL;
1791 0 : }
1792 :
1793 0 : void ScTabViewShell::FillFieldData( ScHeaderFieldData& rData )
1794 : {
1795 0 : ScDocShell* pDocShell = GetViewData().GetDocShell();
1796 0 : ScDocument& rDoc = pDocShell->GetDocument();
1797 0 : SCTAB nTab = GetViewData().GetTabNo();
1798 0 : OUString aTmp;
1799 0 : rDoc.GetName(nTab, aTmp);
1800 0 : rData.aTabName = aTmp;
1801 :
1802 0 : if( pDocShell->getDocProperties()->getTitle().getLength() != 0 )
1803 0 : rData.aTitle = pDocShell->getDocProperties()->getTitle();
1804 : else
1805 0 : rData.aTitle = pDocShell->GetTitle();
1806 :
1807 0 : const INetURLObject& rURLObj = pDocShell->GetMedium()->GetURLObject();
1808 0 : rData.aLongDocName = rURLObj.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
1809 0 : if ( !rData.aLongDocName.isEmpty() )
1810 0 : rData.aShortDocName = rURLObj.GetName( INetURLObject::DECODE_UNAMBIGUOUS );
1811 : else
1812 0 : rData.aShortDocName = rData.aLongDocName = rData.aTitle;
1813 0 : rData.nPageNo = 1;
1814 0 : rData.nTotalPages = 99;
1815 :
1816 : // eNumType kennt der Dialog selber
1817 0 : }
1818 :
1819 0 : bool ScTabViewShell::GetChartArea( ScRangeListRef& rSource, Rectangle& rDest, SCTAB& rTab ) const
1820 : {
1821 0 : rSource = aChartSource;
1822 0 : rDest = aChartPos;
1823 0 : rTab = nChartDestTab;
1824 0 : return bChartAreaValid;
1825 : }
1826 :
1827 0 : ScNavigatorSettings* ScTabViewShell::GetNavigatorSettings()
1828 : {
1829 0 : if( !pNavSettings )
1830 0 : pNavSettings = new ScNavigatorSettings;
1831 0 : return pNavSettings;
1832 : }
1833 :
1834 0 : void ScTabViewShell::ExecTbx( SfxRequest& rReq )
1835 : {
1836 0 : const SfxItemSet* pReqArgs = rReq.GetArgs();
1837 0 : sal_uInt16 nSlot = rReq.GetSlot();
1838 0 : const SfxPoolItem* pItem = NULL;
1839 0 : if ( pReqArgs )
1840 0 : pReqArgs->GetItemState( nSlot, true, &pItem );
1841 :
1842 0 : switch ( nSlot )
1843 : {
1844 : case SID_TBXCTL_INSERT:
1845 0 : if ( pItem )
1846 0 : nInsertCtrlState = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1847 0 : break;
1848 : case SID_TBXCTL_INSCELLS:
1849 0 : if ( pItem )
1850 0 : nInsCellsCtrlState = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1851 0 : break;
1852 : case SID_TBXCTL_INSOBJ:
1853 0 : if ( pItem )
1854 0 : nInsObjCtrlState = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1855 0 : break;
1856 : default:
1857 : OSL_FAIL("Slot im Wald");
1858 : }
1859 0 : GetViewFrame()->GetBindings().Invalidate( nSlot );
1860 0 : }
1861 :
1862 0 : void ScTabViewShell::GetTbxState( SfxItemSet& rSet )
1863 : {
1864 0 : rSet.Put( SfxUInt16Item( SID_TBXCTL_INSERT, nInsertCtrlState ) );
1865 0 : rSet.Put( SfxUInt16Item( SID_TBXCTL_INSCELLS, nInsCellsCtrlState ) );
1866 :
1867 : // ohne installiertes Chart darf Chart nicht Default sein...
1868 0 : if ( nInsObjCtrlState == SID_DRAW_CHART && !SvtModuleOptions().IsChart() )
1869 0 : nInsObjCtrlState = SID_INSERT_OBJECT;
1870 :
1871 0 : rSet.Put( SfxUInt16Item( SID_TBXCTL_INSOBJ, nInsObjCtrlState ) );
1872 156 : }
1873 :
1874 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
