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