Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / core / view / viewsh.cxx
blob: fed3a7e353c1c0e97ad445a366c104e713f92ddd [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"
#define _SVX_PARAITEM_HXX
#define _SVX_TEXTITEM_HXX
#include <com/sun/star/accessibility/XAccessible.hpp>
#include <sfx2/viewfrm.hxx>
#include <sfx2/progress.hxx>
#include <svx/srchdlg.hxx>
#include <svx/svdobj.hxx>
#include <sfx2/viewsh.hxx>
#include <swwait.hxx>
#include <swmodule.hxx>
#include <fesh.hxx>
#include <doc.hxx>
#include <rootfrm.hxx>
#include <pagefrm.hxx>
#include <cntfrm.hxx>
#include <viewimp.hxx>
#include <frmtool.hxx>
#include <viewopt.hxx>
#include <dview.hxx>
#include <swregion.hxx>
#include <hints.hxx>
#include <fmtfsize.hxx>
#include <docufld.hxx>
#include <txtfrm.hxx>
#include <layact.hxx>
#include <mdiexp.hxx>
#include <fntcache.hxx>
#include <ptqueue.hxx>
#include <tabfrm.hxx>
#include <docsh.hxx>
#include <pagedesc.hxx>
#include <ndole.hxx>
#include <ndindex.hxx>
#include <accmap.hxx>
#include <svtools/colorcfg.hxx>
#include <svtools/accessibilityoptions.hxx>
#include <accessibilityoptions.hxx>
#include <statstr.hrc>
#include <comcore.hrc>
#include <pagepreviewlayout.hxx>
#include <sortedobjs.hxx>
#include <anchoredobject.hxx>
#include "../../ui/inc/view.hxx"
#include <PostItMgr.hxx>
#include <vcl/virdev.hxx>
#include <vcl/svapp.hxx>
#include <svx/sdrpaintwindow.hxx>
#include <vcl/dibtools.hxx>
sal_Bool ViewShell::bLstAct = sal_False;
ShellResource *ViewShell::pShellRes = 0;
Window *ViewShell::pCareWindow = 0;
BitmapEx* ViewShell::pErrorBmp = NULL;
BitmapEx* ViewShell::pReplaceBmp = NULL;
sal_Bool bInSizeNotify = sal_False;
DBG_NAME(LayoutIdle)
TYPEINIT0(ViewShell);
using namespace ::com::sun::star;
//////////////////////////////////////////////////////////////////////////////
// #i72754# 2nd set of Pre/PostPaints
// This time it uses the lock counter mnPrePostPaintCount to allow only one activation
// and deactivation and mpPrePostOutDev to remember the OutDev from the BeginDrawLayers
// call. That way, all places where paint take place can be handled the same way, even
// when calling other paint methods. This is the case at the places where SW paints
// buffered into VDevs to avoid flicker. Tis is in general problematic and should be
// solved once using the BufferedOutput functionality of the DrawView.
void ViewShell::PrePaint()
{
// forward PrePaint event from VCL Window to DrawingLayer
if(HasDrawView())
{
Imp()->GetDrawView()->PrePaint();
}
}
void ViewShell::DLPrePaint2(const Region& rRegion)
{
if(0L == mnPrePostPaintCount)
{
// #i75172# ensure DrawView to use DrawingLayer bufferings
if ( !HasDrawView() )
MakeDrawView();
// Prefer window; if tot available, get pOut (e.g. printer)
mpPrePostOutDev = (GetWin() ? GetWin() : GetOut());
// #i74769# use SdrPaintWindow now direct
mpTargetPaintWindow = Imp()->GetDrawView()->BeginDrawLayers(mpPrePostOutDev, rRegion);
OSL_ENSURE(mpTargetPaintWindow, "BeginDrawLayers: Got no SdrPaintWindow (!)");
// #i74769# if prerender, save OutDev and redirect to PreRenderDevice
if(mpTargetPaintWindow->GetPreRenderDevice())
{
mpBufferedOut = pOut;
pOut = &(mpTargetPaintWindow->GetTargetOutputDevice());
}
// remember original paint MapMode for wrapped FlyFrame paints
maPrePostMapMode = pOut->GetMapMode();
}
mnPrePostPaintCount++;
}
void ViewShell::DLPostPaint2(bool bPaintFormLayer)
{
OSL_ENSURE(mnPrePostPaintCount > 0L, "ViewShell::DLPostPaint2: Pre/PostPaint encapsulation broken (!)");
mnPrePostPaintCount--;
if((0L == mnPrePostPaintCount) && (0 != mpTargetPaintWindow))
{
// #i74769# restore buffered OutDev
if(mpTargetPaintWindow->GetPreRenderDevice())
{
pOut = mpBufferedOut;
}
// #i74769# use SdrPaintWindow now direct
Imp()->GetDrawView()->EndDrawLayers(*mpTargetPaintWindow, bPaintFormLayer);
mpTargetPaintWindow = 0;
}
}
//////////////////////////////////////////////////////////////////////////////
/******************************************************************************
|*
|* ViewShell::ImplEndAction()
|*
|* Letzte Aenderung MA 04. Sep. 96
|*
******************************************************************************/
void ViewShell::ImplEndAction( const sal_Bool bIdleEnd )
{
//Fuer den Drucker gibt es hier nichts zu tun.
if ( !GetWin() || IsPreView() )
{
bPaintWorks = sal_True;
UISizeNotify();
return;
}
bInEndAction = sal_True;
//Laeuft hiermit das EndAction der Letzten Shell im Ring?
ViewShell::bLstAct = sal_True;
ViewShell *pSh = (ViewShell*)this->GetNext();
while ( pSh != this )
{ if ( pSh->ActionPend() )
{ ViewShell::bLstAct = sal_False;
pSh = this;
}
else
pSh = (ViewShell*)pSh->GetNext();
}
const bool bIsShellForCheckViewLayout = ( this == GetLayout()->GetCurrShell() );
SET_CURR_SHELL( this );
if ( Imp()->HasDrawView() && !Imp()->GetDrawView()->areMarkHandlesHidden() )
Imp()->StartAction();
if ( Imp()->GetRegion() && Imp()->GetRegion()->GetOrigin() != VisArea() )
Imp()->DelRegion();
const sal_Bool bExtraData = ::IsExtraData( GetDoc() );
if ( !bIdleEnd )
{
SwLayAction aAction( GetLayout(), Imp() );
aAction.SetComplete( sal_False );
if ( nLockPaint )
aAction.SetPaint( sal_False );
aAction.SetInputType( INPUT_KEYBOARD );
aAction.Action();
}
if ( bIsShellForCheckViewLayout )
GetLayout()->CheckViewLayout( GetViewOptions(), &aVisArea );
//Wenn wir selbst keine Paints erzeugen, so warten wir auf das Paint
//vom System. Dann ist das Clipping korrekt gesetzt; Beispiel: verschieben
//eines DrawObjektes.
if ( Imp()->GetRegion() ||
aInvalidRect.HasArea() ||
bExtraData )
{
if ( !nLockPaint )
{
sal_Bool bPaintsFromSystem = aInvalidRect.HasArea();
GetWin()->Update();
if ( aInvalidRect.HasArea() )
{
if ( bPaintsFromSystem )
Imp()->AddPaintRect( aInvalidRect );
ResetInvalidRect();
bPaintsFromSystem = sal_True;
}
bPaintWorks = sal_True;
SwRegionRects *pRegion = Imp()->GetRegion();
//JP 27.11.97: wer die Selection hided, muss sie aber auch
// wieder Showen. Sonst gibt es Paintfehler!
// z.B.: addional Mode, Seite vertikal hab zu sehen, in der
// Mitte eine Selektion und mit einem anderen Cursor an linken
// rechten Rand springen. Ohne ShowCrsr verschwindet die
// Selektion
sal_Bool bShowCrsr = pRegion && IsA( TYPE(SwCrsrShell) );
if( bShowCrsr )
((SwCrsrShell*)this)->HideCrsrs();
if ( pRegion )
{
SwRootFrm* pCurrentLayout = GetLayout();
Imp()->pRegion = NULL;
//Erst Invert dann Compress, niemals andersherum!
pRegion->Invert();
pRegion->Compress();
VirtualDevice *pVout = 0;
while ( pRegion->Count() )
{
SwRect aRect( (*pRegion)[ pRegion->Count() - 1 ] );
pRegion->Remove( pRegion->Count() - 1 );
sal_Bool bPaint = sal_True;
if ( IsEndActionByVirDev() )
{
//virtuelles device erzeugen und einstellen.
if ( !pVout )
pVout = new VirtualDevice( *GetOut() );
MapMode aMapMode( GetOut()->GetMapMode() );
pVout->SetMapMode( aMapMode );
sal_Bool bSizeOK = sal_True;
Rectangle aTmp1( aRect.SVRect() );
aTmp1 = GetOut()->LogicToPixel( aTmp1 );
Rectangle aTmp2( GetOut()->PixelToLogic( aTmp1 ) );
if ( aTmp2.Left() > aRect.Left() )
aTmp1.Left() = Max( 0L, aTmp1.Left() - 1L );
if ( aTmp2.Top() > aRect.Top() )
aTmp1.Top() = Max( 0L, aTmp1.Top() - 1L );
aTmp1.Right() += 1;
aTmp1.Bottom() += 1;
aTmp1 = GetOut()->PixelToLogic( aTmp1 );
aRect = SwRect( aTmp1 );
const Size aTmp( pVout->GetOutputSize() );
if ( aTmp.Height() < aRect.Height() ||
aTmp.Width() < aRect.Width() )
{
bSizeOK = pVout->SetOutputSize( aRect.SSize() );
}
if ( bSizeOK )
{
bPaint = sal_False;
// --> OD 2007-07-26 #i79947#
// #i72754# start Pre/PostPaint encapsulation before pOut is changed to the buffering VDev
const Region aRepaintRegion(aRect.SVRect());
DLPrePaint2(aRepaintRegion);
// <--
OutputDevice *pOld = GetOut();
pVout->SetLineColor( pOld->GetLineColor() );
pVout->SetFillColor( pOld->GetFillColor() );
Point aOrigin( aRect.Pos() );
aOrigin.X() = -aOrigin.X(); aOrigin.Y() = -aOrigin.Y();
aMapMode.SetOrigin( aOrigin );
pVout->SetMapMode( aMapMode );
pOut = pVout;
if ( bPaintsFromSystem )
PaintDesktop( aRect );
pCurrentLayout->Paint( aRect );
pOld->DrawOutDev( aRect.Pos(), aRect.SSize(),
aRect.Pos(), aRect.SSize(), *pVout );
pOut = pOld;
// #i72754# end Pre/PostPaint encapsulation when pOut is back and content is painted
DLPostPaint2(true);
}
}
if ( bPaint )
{
// #i75172# begin DrawingLayer paint
// need to do begin/end DrawingLayer preparation for each single rectangle of the
// repaint region. I already tried to prepare only once for the whole Region. This
// seems to work (and does technically) but fails with transparent objects. Since the
// region given to BeginDarwLayers() defines the clip region for DrawingLayer paint,
// transparent objects in the single rectangles will indeed be painted multiple times.
DLPrePaint2(Region(aRect.SVRect()));
if ( bPaintsFromSystem )
PaintDesktop( aRect );
pCurrentLayout->Paint( aRect );
// #i75172# end DrawingLayer paint
DLPostPaint2(true);
}
// --> OD 2009-12-03 #i107365#
// Direct paint has been performed. Thus, take care of
// transparent child windows.
if ( GetWin() )
{
Window& rWindow = *(GetWin());
if(rWindow.IsChildTransparentModeEnabled() && rWindow.GetChildCount())
{
const Rectangle aRectanglePixel(rWindow.LogicToPixel(aRect.SVRect()));
for ( sal_uInt16 a(0); a < rWindow.GetChildCount(); a++ )
{
Window* pCandidate = rWindow.GetChild(a);
if ( pCandidate && pCandidate->IsPaintTransparent() )
{
const Rectangle aCandidatePosSizePixel(
pCandidate->GetPosPixel(),
pCandidate->GetSizePixel());
if ( aCandidatePosSizePixel.IsOver(aRectanglePixel) )
{
pCandidate->Invalidate( INVALIDATE_NOTRANSPARENT|INVALIDATE_CHILDREN );
pCandidate->Update();
}
}
}
}
}
// <--
}
delete pVout;
delete pRegion;
Imp()->DelRegion();
}
if( bShowCrsr )
((SwCrsrShell*)this)->ShowCrsrs( sal_True );
}
else
{
Imp()->DelRegion();
bPaintWorks = sal_True;
}
}
else
bPaintWorks = sal_True;
bInEndAction = sal_False;
ViewShell::bLstAct = sal_False;
Imp()->EndAction();
//Damit sich die automatischen Scrollbars auch richtig anordnen k?nnen
//muessen wir die Aktion hier kuenstlich beenden (EndAction loesst ein
//Notify aus, und das muss Start-/EndAction rufen um die Scrollbars
//klarzubekommen.
--nStartAction;
UISizeNotify();
++nStartAction;
if( Imp()->IsAccessible() )
Imp()->FireAccessibleEvents();
}
/******************************************************************************
|*
|* ViewShell::ImplStartAction()
|*
|* Ersterstellung MA 25. Jul. 94
|* Letzte Aenderung MA 25. Jul. 94
|*
******************************************************************************/
void ViewShell::ImplStartAction()
{
bPaintWorks = sal_False;
Imp()->StartAction();
}
/******************************************************************************
|*
|* ViewShell::ImplLockPaint(), ImplUnlockPaint()
|*
|* Ersterstellung MA 11. Jun. 96
|* Letzte Aenderung MA 11. Jun. 96
|*
******************************************************************************/
void ViewShell::ImplLockPaint()
{
if ( GetWin() && GetWin()->IsVisible() )
GetWin()->EnablePaint( sal_False ); //Auch die Controls abklemmen.
Imp()->LockPaint();
}
void ViewShell::ImplUnlockPaint( sal_Bool bVirDev )
{
SET_CURR_SHELL( this );
if ( GetWin() && GetWin()->IsVisible() )
{
if ( (bInSizeNotify || bVirDev ) && VisArea().HasArea() )
{
//Refresh mit virtuellem Device um das Flackern zu verhindern.
VirtualDevice *pVout = new VirtualDevice( *pOut );
pVout->SetMapMode( pOut->GetMapMode() );
Size aSize( VisArea().SSize() );
aSize.Width() += 20;
aSize.Height()+= 20;
if( pVout->SetOutputSize( aSize ) )
{
GetWin()->EnablePaint( sal_True );
GetWin()->Validate();
Imp()->UnlockPaint();
pVout->SetLineColor( pOut->GetLineColor() );
pVout->SetFillColor( pOut->GetFillColor() );
// #i72754# start Pre/PostPaint encapsulation before pOut is changed to the buffering VDev
const Region aRepaintRegion(VisArea().SVRect());
DLPrePaint2(aRepaintRegion);
OutputDevice *pOld = pOut;
pOut = pVout;
Paint( VisArea().SVRect() );
pOut = pOld;
pOut->DrawOutDev( VisArea().Pos(), aSize,
VisArea().Pos(), aSize, *pVout );
// #i72754# end Pre/PostPaint encapsulation when pOut is back and content is painted
DLPostPaint2(true);
}
else
{
Imp()->UnlockPaint();
GetWin()->EnablePaint( sal_True );
GetWin()->Invalidate( INVALIDATE_CHILDREN );
}
delete pVout;
}
else
{
Imp()->UnlockPaint();
GetWin()->EnablePaint( sal_True );
GetWin()->Invalidate( INVALIDATE_CHILDREN );
}
}
else
Imp()->UnlockPaint();
}
/******************************************************************************
|*
|* ViewShell::AddPaintRect()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 09. Feb. 97
|*
******************************************************************************/
sal_Bool ViewShell::AddPaintRect( const SwRect & rRect )
{
sal_Bool bRet = sal_False;
ViewShell *pSh = this;
do
{
if( pSh->Imp() )
{
if ( pSh->IsPreView() && pSh->GetWin() )
::RepaintPagePreview( pSh, rRect );
else
bRet |= pSh->Imp()->AddPaintRect( rRect );//swmod 080111
}
pSh = (ViewShell*)pSh->GetNext();
} while ( pSh != this );
return bRet;
}
/******************************************************************************
|*
|* ViewShell::InvalidateWindows()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 09. Feb. 97
|*
******************************************************************************/
void ViewShell::InvalidateWindows( const SwRect &rRect )
{
if ( !Imp()->IsCalcLayoutProgress() )
{
ViewShell *pSh = this;
do
{
if ( pSh->GetWin() )
{
if ( pSh->IsPreView() )
::RepaintPagePreview( pSh, rRect );
else if ( pSh->VisArea().IsOver( rRect ) )
pSh->GetWin()->Invalidate( rRect.SVRect() );
}
pSh = (ViewShell*)pSh->GetNext();
} while ( pSh != this );
}
}
/******************************************************************************
|*
|* ViewShell::MakeVisible()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung AMA 10. Okt. 95
|*
******************************************************************************/
void ViewShell::MakeVisible( const SwRect &rRect )
{
if ( !VisArea().IsInside( rRect ) || IsScrollMDI( this, rRect ) || GetCareWin(*this) )
{
if ( !IsViewLocked() )
{
if( pWin )
{
const SwFrm* pRoot = GetLayout();
int nLoopCnt = 3;
long nOldH;
do{
nOldH = pRoot->Frm().Height();
StartAction();
ScrollMDI( this, rRect, USHRT_MAX, USHRT_MAX );
EndAction();
} while( nOldH != pRoot->Frm().Height() && nLoopCnt-- ); //swmod 071108//swmod 071225
}
#ifdef DBG_UTIL
else
{
//MA: 04. Nov. 94, braucht doch keiner oder??
ASSERT( !this, "MakeVisible fuer Drucker wird doch gebraucht?" );
}
#endif
}
}
}
/******************************************************************************
|*
|* ViewShell::CareChildWindow()
|*
|* Ersterstellung AMA 10. Okt. 95
|* Letzte Aenderung AMA 10. Okt. 95
|*
******************************************************************************/
Window* ViewShell::CareChildWin(ViewShell& rVSh)
{
if(rVSh.pSfxViewShell)
{
const sal_uInt16 nId = SvxSearchDialogWrapper::GetChildWindowId();
SfxViewFrame* pVFrame = rVSh.pSfxViewShell->GetViewFrame();
const SfxChildWindow* pChWin = pVFrame->GetChildWindow( nId );
Window *pWin = pChWin ? pChWin->GetWindow() : NULL;
if ( pWin && pWin->IsVisible() )
return pWin;
}
return NULL;
}
/******************************************************************************
|*
|* ViewShell::GetPagePos()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 04. Aug. 93
|*
******************************************************************************/
Point ViewShell::GetPagePos( sal_uInt16 nPageNum ) const
{
return GetLayout()->GetPagePos( nPageNum );
}
/******************************************************************************
|*
|* ViewShell::GetNumPages()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 20. Apr. 94
|*
******************************************************************************/
sal_uInt16 ViewShell::GetNumPages()
{
//Es kann sein, das noch kein Layout existiert weil die Methode vom
//Root-Ctor gerufen wird.
return GetLayout() ? GetLayout()->GetPageNum() : 0;
}
sal_Bool ViewShell::IsDummyPage( sal_uInt16 nPageNum ) const
{
return GetLayout() ? GetLayout()->IsDummyPage( nPageNum ) : 0;
}
/*************************************************************************
|*
|* ViewShell::UpdateFlds()
|*
|* Ersterstellung BP 04.05.92
|* Beschreibung erzwingt ein Update fuer jedes Feld
|*
|* UpdateFlds benachrichtigt alle Felder mit pNewHt.
|* Wenn pNewHt == 0 ist (default), wird der Feldtyp verschickt.
|*
*************************************************************************/
void ViewShell::UpdateFlds(sal_Bool bCloseDB)
{
SET_CURR_SHELL( this );
sal_Bool bCrsr = ISA(SwCrsrShell);
if ( bCrsr )
((SwCrsrShell*)this)->StartAction();
else
StartAction();
GetDoc()->UpdateFlds(0, bCloseDB);
if ( bCrsr )
((SwCrsrShell*)this)->EndAction();
else
EndAction();
}
// update all charts, for that exists any table
void ViewShell::UpdateAllCharts()
{
SET_CURR_SHELL( this );
// Start-/EndAction handled in the SwDoc-Method!
GetDoc()->UpdateAllCharts();
}
sal_Bool ViewShell::HasCharts() const
{
sal_Bool bRet = sal_False;
const SwStartNode *pStNd;
SwNodeIndex aIdx( *GetDoc()->GetNodes().GetEndOfAutotext().
StartOfSectionNode(), 1 );
while ( 0 != (pStNd = aIdx.GetNode().GetStartNode()) )
{
aIdx++;
const SwOLENode *pNd = aIdx.GetNode().GetOLENode();
if( pNd && pNd->GetChartTblName().Len() )
{
bRet = sal_True;
break;
}
}
return bRet;
}
/*************************************************************************
|*
|* ViewShell::LayoutIdle()
|*
|* Ersterstellung MA 26. May. 92
|* Letzte Aenderung OG 19. Mar. 96
|*
*************************************************************************/
void ViewShell::LayoutIdle()
{
#ifdef TCOVER
//fuer TCV-Version: Ende der Startphase des Programmes
TCovCall::Idle();
#endif
if( !pOpt->IsIdle() || !GetWin() ||
( Imp()->HasDrawView() && Imp()->GetDrawView()->IsDragObj() ) )
return;
//Kein Idle wenn gerade gedruckt wird.
ViewShell *pSh = this;
do
{ if ( !pSh->GetWin() )
return;
pSh = (ViewShell*)pSh->GetNext();
} while ( pSh != this );
SET_CURR_SHELL( this );
#ifdef DBG_UTIL
// Wenn Test5 gedrueckt ist, wird der IdleFormatierer abgeknipst.
if( pOpt->IsTest5() )
return;
#endif
{
DBG_PROFSTART( LayoutIdle );
//Cache vorbereiten und restaurieren, damit er nicht versaut wird.
SwSaveSetLRUOfst aSave( *SwTxtFrm::GetTxtCache(),
SwTxtFrm::GetTxtCache()->GetCurMax() - 50 );
// #125243# there are lots of stacktraces indicating that Imp() returns NULL
// this ViewShell seems to be invalid - but it's not clear why
// this return is only a workaround!
DBG_ASSERT(Imp(), "ViewShell already deleted?");
if(!Imp())
return;
SwLayIdle aIdle( GetLayout(), Imp() );
DBG_PROFSTOP( LayoutIdle );
}
}
/*************************************************************************
|*
|* DOCUMENT COMPATIBILITY FLAGS
|*
*************************************************************************/
void lcl_InvalidateAllCntnt( ViewShell& rSh, sal_uInt8 nInv )
{
sal_Bool bCrsr = rSh.ISA(SwCrsrShell);
if ( bCrsr )
((SwCrsrShell&)rSh).StartAction();
else
rSh.StartAction();
rSh.GetLayout()->InvalidateAllCntnt( nInv );
if ( bCrsr )
((SwCrsrShell&)rSh).EndAction();
else
rSh.EndAction();
rSh.GetDoc()->SetModified();
}
/** local method to invalidate/re-calculate positions of floating screen
objects (Writer fly frame and drawing objects), which are anchored
to paragraph or to character.
OD 2004-03-16 #i11860#
@author OD
*/
void lcl_InvalidateAllObjPos( ViewShell &_rSh )
{
const bool bIsCrsrShell = _rSh.ISA(SwCrsrShell);
if ( bIsCrsrShell )
static_cast<SwCrsrShell&>(_rSh).StartAction();
else
_rSh.StartAction();
_rSh.GetLayout()->InvalidateAllObjPos();
if ( bIsCrsrShell )
static_cast<SwCrsrShell&>(_rSh).EndAction();
else
_rSh.EndAction();
_rSh.GetDoc()->SetModified();
}
void ViewShell::SetParaSpaceMax( bool bNew )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if( pIDSA->get(IDocumentSettingAccess::PARA_SPACE_MAX) != bNew )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::PARA_SPACE_MAX, bNew );
const sal_uInt8 nInv = INV_PRTAREA | INV_TABLE | INV_SECTION;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
void ViewShell::SetParaSpaceMaxAtPages( bool bNew )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if( pIDSA->get(IDocumentSettingAccess::PARA_SPACE_MAX_AT_PAGES) != bNew )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::PARA_SPACE_MAX_AT_PAGES, bNew );
const sal_uInt8 nInv = INV_PRTAREA | INV_TABLE | INV_SECTION;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
void ViewShell::SetTabCompat( bool bNew )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if( pIDSA->get(IDocumentSettingAccess::TAB_COMPAT) != bNew )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::TAB_COMPAT, bNew );
const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
void ViewShell::SetAddExtLeading( bool bNew )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::ADD_EXT_LEADING) != bNew )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::ADD_EXT_LEADING, bNew );
SdrModel* pTmpDrawModel = getIDocumentDrawModelAccess()->GetDrawModel();
if ( pTmpDrawModel )
pTmpDrawModel->SetAddExtLeading( bNew );
const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
void ViewShell::SetUseVirDev( bool bNewVirtual )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::USE_VIRTUAL_DEVICE) != bNewVirtual )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
// this sets the flag at the document and calls PrtDataChanged
IDocumentDeviceAccess* pIDDA = getIDocumentDeviceAccess();
pIDDA->setReferenceDeviceType( bNewVirtual, true );
}
}
// OD 2004-02-16 #106629# - control, if paragraph and table spacing is added
// at bottom of table cells
void ViewShell::SetAddParaSpacingToTableCells( bool _bAddParaSpacingToTableCells )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::ADD_PARA_SPACING_TO_TABLE_CELLS) != _bAddParaSpacingToTableCells )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::ADD_PARA_SPACING_TO_TABLE_CELLS, _bAddParaSpacingToTableCells );
const sal_uInt8 nInv = INV_PRTAREA;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
// OD 06.01.2004 #i11859# - control, if former formatting of text lines with
// proportional line spacing is used or not.
void ViewShell::SetUseFormerLineSpacing( bool _bUseFormerLineSpacing )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::OLD_LINE_SPACING) != _bUseFormerLineSpacing )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::OLD_LINE_SPACING, _bUseFormerLineSpacing );
const sal_uInt8 nInv = INV_PRTAREA;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
// OD 2004-03-12 #i11860# - control, if former object positioning is used or not.
void ViewShell::SetUseFormerObjectPositioning( bool _bUseFormerObjPos )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::USE_FORMER_OBJECT_POS) != _bUseFormerObjPos )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::USE_FORMER_OBJECT_POS, _bUseFormerObjPos );
lcl_InvalidateAllObjPos( *this );
}
}
// OD 2004-05-05 #i28701#
void ViewShell::SetConsiderWrapOnObjPos( bool _bConsiderWrapOnObjPos )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION) != _bConsiderWrapOnObjPos )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION, _bConsiderWrapOnObjPos );
lcl_InvalidateAllObjPos( *this );
}
}
// --> FME #108724#
void ViewShell::SetUseFormerTextWrapping( bool _bUseFormerTextWrapping )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING) != _bUseFormerTextWrapping )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING, _bUseFormerTextWrapping );
const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
// <--
// -> PB 2007-06-11 #i45491#
void ViewShell::SetDoNotJustifyLinesWithManualBreak( bool _bDoNotJustifyLinesWithManualBreak )
{
IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess();
if ( pIDSA->get(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK) != _bDoNotJustifyLinesWithManualBreak )
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
pIDSA->set(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK, _bDoNotJustifyLinesWithManualBreak );
const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION;
lcl_InvalidateAllCntnt( *this, nInv );
}
}
// <--
/******************************************************************************
|*
|* ViewShell::Reformat
|*
|* Ersterstellung BP ???
|* Letzte Aenderung MA 13. Feb. 98
|*
******************************************************************************/
void ViewShell::Reformat()
{
SwWait aWait( *GetDoc()->GetDocShell(), true );
// Wir gehen auf Nummer sicher:
// Wir muessen die alten Fontinformationen wegschmeissen,
// wenn die Druckeraufloesung oder der Zoomfaktor sich aendert.
// Init() und Reformat() sind die sichersten Stellen.
#ifdef FNTMET
aFntMetList.Flush();
#else
pFntCache->Flush( );
#endif
if( GetLayout()->IsCallbackActionEnabled() )
{
StartAction();
GetLayout()->InvalidateAllCntnt( INV_SIZE | INV_POS | INV_PRTAREA );
EndAction();
}
}
void ViewShell::ChgNumberDigits()
{
SdrModel* pTmpDrawModel = getIDocumentDrawModelAccess()->GetDrawModel();
if ( pTmpDrawModel )
pTmpDrawModel->ReformatAllTextObjects();
Reformat();
}
/******************************************************************************
|*
|* ViewShell::CalcLayout()
|* Vollstaendige Formatierung von Layout und Inhalt.
|*
|* Ersterstellung MA 31. Jan. 94
|* Letzte Aenderung MA 08. Oct. 96
|*
******************************************************************************/
void ViewShell::CalcLayout()
{
SET_CURR_SHELL( this );
SwWait aWait( *GetDoc()->GetDocShell(), true );
//Cache vorbereiten und restaurieren, damit er nicht versaut wird.
SwSaveSetLRUOfst aSaveLRU( *SwTxtFrm::GetTxtCache(),
SwTxtFrm::GetTxtCache()->GetCurMax() - 50 );
//Progress einschalten wenn noch keiner Lauft.
const sal_Bool bEndProgress = SfxProgress::GetActiveProgress( GetDoc()->GetDocShell() ) == 0;
if ( bEndProgress )
{
sal_uInt16 nEndPage = GetLayout()->GetPageNum();
nEndPage += nEndPage * 10 / 100;
::StartProgress( STR_STATSTR_REFORMAT, 0, nEndPage, GetDoc()->GetDocShell() );
}
SwLayAction aAction( GetLayout(), Imp() );
aAction.SetPaint( sal_False );
aAction.SetStatBar( sal_True );
aAction.SetCalcLayout( sal_True );
aAction.SetReschedule( sal_True );
GetDoc()->LockExpFlds();
aAction.Action();
GetDoc()->UnlockExpFlds();
//Das SetNewFldLst() am Doc wurde unterbunden und muss nachgeholt
//werden (siehe flowfrm.cxx, txtfld.cxx)
if ( aAction.IsExpFlds() )
{
aAction.Reset();
aAction.SetPaint( sal_False );
aAction.SetStatBar( sal_True );
aAction.SetReschedule( sal_True );
SwDocPosUpdate aMsgHnt( 0 );
GetDoc()->UpdatePageFlds( &aMsgHnt );
GetDoc()->UpdateExpFlds(NULL, true);
aAction.Action();
}
if ( VisArea().HasArea() )
InvalidateWindows( VisArea() );
if ( bEndProgress )
::EndProgress( GetDoc()->GetDocShell() );
}
/******************************************************************************
|*
|* ViewShell::SetFirstVisPageInvalid()
|*
|* Ersterstellung MA 19. May. 94
|* Letzte Aenderung MA 19. May. 94
|*
******************************************************************************/
void ViewShell::SetFirstVisPageInvalid()
{
ViewShell *pSh = this;
do
{ pSh->Imp()->SetFirstVisPageInvalid();
pSh = (ViewShell*)pSh->GetNext();
} while ( pSh != this );
}
/******************************************************************************
|*
|* ViewShell::SizeChgNotify()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 17. Sep. 96
|*
******************************************************************************/
void ViewShell::SizeChgNotify()
{
if ( !pWin )
bDocSizeChgd = sal_True;
else if( ActionPend() || Imp()->IsCalcLayoutProgress() || bPaintInProgress )
{
bDocSizeChgd = sal_True;
if ( !Imp()->IsCalcLayoutProgress() && ISA( SwCrsrShell ) )
{
const SwFrm *pCnt = ((SwCrsrShell*)this)->GetCurrFrm( sal_False );
const SwPageFrm *pPage;
if ( pCnt && 0 != (pPage = pCnt->FindPageFrm()) )
{
sal_uInt16 nVirtNum = pPage->GetVirtPageNum();
const SvxNumberType& rNum = pPage->GetPageDesc()->GetNumType();
String sDisplay = rNum.GetNumStr( nVirtNum );
PageNumNotify( this, pCnt->GetPhyPageNum(), nVirtNum, sDisplay );
}
}
}
else
{
bDocSizeChgd = sal_False;
::SizeNotify( this, GetDocSize() );
}
}
/******************************************************************************
|*
|* ViewShell::VisPortChgd()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 22. Jul. 96
|*
******************************************************************************/
void ViewShell::VisPortChgd( const SwRect &rRect)
{
ASSERT( GetWin(), "VisPortChgd ohne Window." );
if ( rRect == VisArea() )
return;
#ifdef DBG_UTIL
if ( bInEndAction )
{
//Da Rescheduled doch schon wieder irgendwo einer?
ASSERT( !this, "Scroll waehrend einer EndAction." );
}
#endif
//Ersteinmal die alte sichtbare Seite holen, dann braucht nacher nicht
//lange gesucht werden.
const SwFrm *pOldPage = Imp()->GetFirstVisPage();
const SwRect aPrevArea( VisArea() );
const sal_Bool bFull = aPrevArea.IsEmpty();
aVisArea = rRect;
SetFirstVisPageInvalid();
//Wenn noch eine PaintRegion herumsteht und sich die VisArea geaendert hat,
//so ist die PaintRegion spaetestens jetzt obsolete. Die PaintRegion kann
//vom RootFrm::Paint erzeugt worden sein.
if ( !bInEndAction &&
Imp()->GetRegion() && Imp()->GetRegion()->GetOrigin() != VisArea() )
Imp()->DelRegion();
SET_CURR_SHELL( this );
bool bScrolled = false;
SwPostItMgr* pPostItMgr = GetPostItMgr();
if ( bFull )
GetWin()->Invalidate();
else
{
// Betrag ausrechnen, um den gescrolled werden muss.
const long nXDiff = aPrevArea.Left() - VisArea().Left();
const long nYDiff = aPrevArea.Top() - VisArea().Top();
if( !nXDiff && !GetViewOptions()->getBrowseMode() &&
(!Imp()->HasDrawView() || !Imp()->GetDrawView()->IsGridVisible() ) )
{
//Falls moeglich die Wiese nicht mit Scrollen.
//Also linke und rechte Kante des Scrollbereiches auf die
//Seiten begrenzen.
const SwPageFrm *pPage = (SwPageFrm*)GetLayout()->Lower(); //swmod 071108//swmod 071225
if ( pPage->Frm().Top() > pOldPage->Frm().Top() )
pPage = (SwPageFrm*)pOldPage;
SwRect aBoth( VisArea() );
aBoth.Union( aPrevArea );
const SwTwips nBottom = aBoth.Bottom();
SwTwips nMinLeft = LONG_MAX;
SwTwips nMaxRight= 0;
const SwTwips nSidebarWidth = pPostItMgr && pPostItMgr->ShowNotes() && pPostItMgr->HasNotes() ?
pPostItMgr->GetSidebarWidth() + pPostItMgr->GetSidebarBorderWidth() :
0;
const bool bBookMode = GetViewOptions()->IsViewLayoutBookMode();
while ( pPage && pPage->Frm().Top() <= nBottom )
{
SwRect aPageRect( pPage->Frm() );
if ( bBookMode )
{
const SwPageFrm& rFormatPage = static_cast<const SwPageFrm*>(pPage)->GetFormatPage();
aPageRect.SSize() = rFormatPage.Frm().SSize();
}
if ( aPageRect.IsOver( aBoth ) )
{
// OD 12.02.2003 #i9719#, #105645# - consider new border
// and shadow width
const SwTwips nBorderWidth =
GetOut()->PixelToLogic( Size( pPage->BorderPxWidth(), 0 ) ).Width();
const SwTwips nShadowWidth =
GetOut()->PixelToLogic( Size( pPage->ShadowPxWidth(), 0 ) ).Width();
SwTwips nPageLeft = 0;
SwTwips nPageRight = 0;
switch ( pPage->SidebarPosition() )
{
case sw::sidebarwindows::SIDEBAR_LEFT:
{
nPageLeft = aPageRect.Left() - nBorderWidth - nSidebarWidth;
nPageRight = aPageRect.Right() + nBorderWidth + nShadowWidth;
}
break;
case sw::sidebarwindows::SIDEBAR_RIGHT:
{
nPageLeft = aPageRect.Left() - nBorderWidth;
nPageRight = aPageRect.Right() + nBorderWidth + nShadowWidth + nSidebarWidth;
}
break;
case sw::sidebarwindows::SIDEBAR_NONE:
// nothing to do
break;
}
if( nPageLeft < nMinLeft )
nMinLeft = nPageLeft;
if( nPageRight > nMaxRight )
nMaxRight = nPageRight;
//Zus. auf die Zeichenobjekte abgleichen.
//Einen Ofst beruecksichtigen, weil die Objekte u.U.
//selektiert sind und die Henkel dann hinausstehen.
if ( pPage->GetSortedObjs() )
{
const long nOfst = GetOut()->PixelToLogic(
Size(Imp()->GetDrawView()->GetMarkHdlSizePixel()/2,0)).Width();
for ( sal_uInt16 i = 0;
i < pPage->GetSortedObjs()->Count(); ++i )
{
SwAnchoredObject* pObj = (*pPage->GetSortedObjs())[i];
const Rectangle &rBound = pObj->GetObjRect().SVRect();
// OD 03.03.2003 #107927# - use correct datatype
const SwTwips nL = Max( 0L, rBound.Left() - nOfst );
if ( nL < nMinLeft )
nMinLeft = nL;
if( rBound.Right() + nOfst > nMaxRight )
nMaxRight = rBound.Right() + nOfst;
}
}
}
pPage = (SwPageFrm*)pPage->GetNext();
}
Rectangle aRect( aPrevArea.SVRect() );
aRect.Left() = nMinLeft;
aRect.Right() = nMaxRight;
if( VisArea().IsOver( aPrevArea ) && !nLockPaint )
{
bScrolled = true;
aVisArea.Pos() = aPrevArea.Pos();
if ( SmoothScroll( nXDiff, nYDiff, &aRect ) )
return;
aVisArea.Pos() = rRect.Pos();
}
else
GetWin()->Invalidate( aRect );
}
else if ( !nLockPaint ) //Wird im UnLock erledigt
{
if( VisArea().IsOver( aPrevArea ) )
{
bScrolled = true;
aVisArea.Pos() = aPrevArea.Pos();
if ( SmoothScroll( nXDiff, nYDiff, 0 ) )
return;
aVisArea.Pos() = rRect.Pos();
}
else
GetWin()->Invalidate();
}
}
Point aPt( VisArea().Pos() );
aPt.X() = -aPt.X(); aPt.Y() = -aPt.Y();
MapMode aMapMode( GetWin()->GetMapMode() );
aMapMode.SetOrigin( aPt );
GetWin()->SetMapMode( aMapMode );
if ( HasDrawView() )
{
Imp()->GetDrawView()->VisAreaChanged( GetWin() );
Imp()->GetDrawView()->SetActualWin( GetWin() );
}
GetWin()->Update();
// --> OD 2010-02-11 #i88070#
if ( pPostItMgr )
{
pPostItMgr->Rescale();
pPostItMgr->CalcRects();
pPostItMgr->LayoutPostIts();
}
// <--
if ( !bScrolled && pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() )
pPostItMgr->CorrectPositions();
if( Imp()->IsAccessible() )
Imp()->UpdateAccessible();
}
/******************************************************************************
|*
|* ViewShell::SmoothScroll()
|*
|* Ersterstellung MA 04. Jul. 96
|* Letzte Aenderung MA 25. Mar. 97
|*
******************************************************************************/
sal_Bool ViewShell::SmoothScroll( long lXDiff, long lYDiff, const Rectangle *pRect )
{
const sal_uLong nColCnt = pOut->GetColorCount();
long lMult = 1, lMax = LONG_MAX;
if ( nColCnt == 65536 )
{
lMax = 7000;
lMult = 2;
}
if ( nColCnt == 16777216 )
{
lMax = 5000;
lMult = 6;
}
else if ( nColCnt == 1 )
{
lMax = 3000;
lMult = 12;
}
// #i75172# isolated static conditions
const bool bOnlyYScroll(!lXDiff && Abs(lYDiff) != 0 && Abs(lYDiff) < lMax);
const bool bAllowedWithChildWindows(GetWin()->GetWindowClipRegionPixel(WINDOW_GETCLIPREGION_NOCHILDREN|WINDOW_GETCLIPREGION_NULL).IsNull());
// --> OD 2009-08-12 #i98766# - disable smooth scrolling for Mac port builds
#ifdef QUARTZ
const bool bSmoothScrollAllowed(false);
(void) bOnlyYScroll;
(void) bAllowedWithChildWindows;
#else
const bool bSmoothScrollAllowed(bOnlyYScroll && bEnableSmooth && GetViewOptions()->IsSmoothScroll() && bAllowedWithChildWindows);
#endif
// <-
const bool bIAmCursorShell(ISA(SwCrsrShell));
(void) bIAmCursorShell;
// #i75172# with selection on overlay, smooth scroll should be allowed with it
const bool bAllowedForSelection(true || (bIAmCursorShell && !((SwCrsrShell*)this)->HasSelection()));
// #i75172# with cursors on overlay, smooth scroll should be allowed with it
const bool bAllowedForMultipleCursors(true || (bIAmCursorShell && ((SwCrsrShell*)this)->GetCrsrCnt() < 2));
if(bSmoothScrollAllowed && bAllowedForSelection && bAllowedForMultipleCursors)
{
Imp()->bStopSmooth = sal_False;
const SwRect aOldVis( VisArea() );
//Virtuelles Device erzeugen und einstellen.
const Size aPixSz = GetWin()->PixelToLogic(Size(1,1));
VirtualDevice *pVout = new VirtualDevice( *GetWin() );
pVout->SetLineColor( GetWin()->GetLineColor() );
pVout->SetFillColor( GetWin()->GetFillColor() );
MapMode aMapMode( GetWin()->GetMapMode() );
pVout->SetMapMode( aMapMode );
Size aSize( aVisArea.Width()+2*aPixSz.Width(), Abs(lYDiff)+(2*aPixSz.Height()) );
if ( pRect )
aSize.Width() = Min(aSize.Width(), pRect->GetWidth()+2*aPixSz.Width());
if ( pVout->SetOutputSize( aSize ) )
{
nLockPaint++;
//Ersteinmal alles neue in das VirDev Painten.
SwRect aRect( VisArea() );
aRect.Height( aSize.Height() );
if ( pRect )
{
aRect.Pos().X() = Max(aRect.Left(),pRect->Left()-aPixSz.Width());
aRect.Right( Min(aRect.Right()+2*aPixSz.Width(), pRect->Right()+aPixSz.Width()));
}
else
aRect.SSize().Width() += 2*aPixSz.Width();
aRect.Pos().Y() = lYDiff < 0 ? aOldVis.Bottom() - aPixSz.Height()
: aRect.Top() - aSize.Height() + aPixSz.Height();
aRect.Pos().X() = Max( 0L, aRect.Left()-aPixSz.Width() );
aRect.Pos() = GetWin()->PixelToLogic( GetWin()->LogicToPixel( aRect.Pos()));
aRect.SSize()= GetWin()->PixelToLogic( GetWin()->LogicToPixel( aRect.SSize()));
aVisArea = aRect;
const Point aPt( -aRect.Left(), -aRect.Top() );
aMapMode.SetOrigin( aPt );
pVout->SetMapMode( aMapMode );
OutputDevice *pOld = pOut;
pOut = pVout;
{
// #i75172# To get a clean repaint, a new ObjectContact is needed here. Without, the
// repaint would not be correct since it would use the wrong DrawPage visible region.
// This repaint IS about painting something currently outside the visible part (!).
// For that purpose, AddWindowToPaintView is used which creates a new SdrPageViewWindow
// and all the necessary stuff. It's not cheap, but necessary here. Alone because repaint
// target really is NOT the current window.
// Also will automatically NOT use PreRendering and overlay (since target is VirtualDevice)
if(!HasDrawView())
MakeDrawView();
SdrView* pDrawView = GetDrawView();
pDrawView->AddWindowToPaintView(pVout);
// clear pWin during DLPrePaint2 to get paint preparation for pOut, but set it again
// immediately afterwards. There are many decisions in SW which imply that Printing
// is used when pWin == 0 (wrong but widely used).
Window* pOldWin = pWin;
pWin = 0;
DLPrePaint2(Region(aRect.SVRect()));
pWin = pOldWin;
// SW paint stuff
PaintDesktop( aRect );
ViewShell::bLstAct = sal_True;
GetLayout()->Paint( aRect );
ViewShell::bLstAct = sal_False;
// end paint and destroy ObjectContact again
DLPostPaint2(true);
pDrawView->DeleteWindowFromPaintView(pVout);
// temporary debug paint checking...
static bool bDoSaveForVisualControl(false);
if(bDoSaveForVisualControl)
{
const bool bMapModeWasEnabledVDev(pVout->IsMapModeEnabled());
pVout->EnableMapMode(false);
const Bitmap aBitmap(pVout->GetBitmap(Point(), pVout->GetOutputSizePixel()));
const String aTmpString(ByteString( "c:\\test.bmp" ), RTL_TEXTENCODING_UTF8);
SvFileStream aNew(aTmpString, STREAM_WRITE|STREAM_TRUNC);
WriteDIB(aBitmap, aNew, false, true);
pVout->EnableMapMode(bMapModeWasEnabledVDev);
}
}
pOut = pOld;
aVisArea = aOldVis;
//Jetzt Stueckchenweise schieben und die neuen Pixel aus dem
//VirDev kopieren.
// ??????????????????????
// or is it better to get the scrollfactor from the User
// as option?
// ??????????????????????
long lMaDelta = aPixSz.Height();
if ( Abs(lYDiff) > ( aVisArea.Height() / 3 ) )
lMaDelta *= 6;
else
lMaDelta *= 2;
lMaDelta *= lMult;
if ( lYDiff < 0 )
lMaDelta = -lMaDelta;
long lDiff = lYDiff;
while ( lDiff )
{
long lScroll;
if ( Imp()->bStopSmooth || Abs(lDiff) <= Abs(lMaDelta) )
{
lScroll = lDiff;
lDiff = 0;
}
else
{
lScroll = lMaDelta;
lDiff -= lMaDelta;
}
const SwRect aTmpOldVis = VisArea();
aVisArea.Pos().Y() -= lScroll;
aVisArea.Pos() = GetWin()->PixelToLogic( GetWin()->LogicToPixel( VisArea().Pos()));
lScroll = aTmpOldVis.Top() - VisArea().Top();
if ( pRect )
{
Rectangle aTmp( aTmpOldVis.SVRect() );
aTmp.Left() = pRect->Left();
aTmp.Right()= pRect->Right();
GetWin()->Scroll( 0, lScroll, aTmp, SCROLL_CHILDREN);
}
else
GetWin()->Scroll( 0, lScroll, SCROLL_CHILDREN );
const Point aTmpPt( -VisArea().Left(), -VisArea().Top() );
MapMode aTmpMapMode( GetWin()->GetMapMode() );
aTmpMapMode.SetOrigin( aTmpPt );
GetWin()->SetMapMode( aTmpMapMode );
if ( Imp()->HasDrawView() )
Imp()->GetDrawView()->VisAreaChanged( GetWin() );
SetFirstVisPageInvalid();
if ( !Imp()->bStopSmooth )
{
const bool bScrollDirectionIsUp(lScroll > 0);
Imp()->aSmoothRect = VisArea();
if(bScrollDirectionIsUp)
{
Imp()->aSmoothRect.Bottom( VisArea().Top() + lScroll + aPixSz.Height());
}
else
{
Imp()->aSmoothRect.Top( VisArea().Bottom() + lScroll - aPixSz.Height());
}
Imp()->bSmoothUpdate = sal_True;
GetWin()->Update();
Imp()->bSmoothUpdate = sal_False;
if(!Imp()->bStopSmooth)
{
static bool bDoItOnPixels(true);
if(bDoItOnPixels)
{
// start paint on logic base
const Rectangle aTargetLogic(Imp()->aSmoothRect.SVRect());
DLPrePaint2(Region(aTargetLogic));
// get target rectangle in discrete pixels
OutputDevice& rTargetDevice = mpTargetPaintWindow->GetTargetOutputDevice();
const Rectangle aTargetPixel(rTargetDevice.LogicToPixel(aTargetLogic));
// get source top-left in discrete pixels
const Point aSourceTopLeft(pVout->LogicToPixel(aTargetLogic.TopLeft()));
// switch off MapModes
const bool bMapModeWasEnabledDest(rTargetDevice.IsMapModeEnabled());
const bool bMapModeWasEnabledSource(pVout->IsMapModeEnabled());
rTargetDevice.EnableMapMode(false);
pVout->EnableMapMode(false);
// copy content
static bool bTestDirectToWindowPaint(false);
if(bTestDirectToWindowPaint)
{
const bool bMapModeWasEnabledWin(GetWin()->IsMapModeEnabled());
GetWin()->EnableMapMode(false);
GetWin()->DrawOutDev(
aTargetPixel.TopLeft(), aTargetPixel.GetSize(), // dest
aSourceTopLeft, aTargetPixel.GetSize(), // source
*pVout);
GetWin()->EnableMapMode(bMapModeWasEnabledWin);
}
rTargetDevice.DrawOutDev(
aTargetPixel.TopLeft(), aTargetPixel.GetSize(), // dest
aSourceTopLeft, aTargetPixel.GetSize(), // source
*pVout);
// restore MapModes
rTargetDevice.EnableMapMode(bMapModeWasEnabledDest);
pVout->EnableMapMode(bMapModeWasEnabledSource);
// end paint on logoc base
DLPostPaint2(true);
}
else
{
Rectangle aRectangle(Imp()->aSmoothRect.SVRect());
aRectangle.Left() -= aPixSz.Width();
aRectangle.Right() += aPixSz.Width();
aRectangle.Top() -= aPixSz.Height();
aRectangle.Bottom() += aPixSz.Height();
const Point aUpdateTopLeft(aRectangle.TopLeft());
const Size aUpdateSize(aRectangle.GetSize());
// #i75172# the part getting visible needs to be handled like a repaint.
// For that, start with DLPrePaint2 and the correct Rectangle
DLPrePaint2(Region(aRectangle));
static bool bTestDirectToWindowPaint(false);
if(bTestDirectToWindowPaint)
{
GetWin()->DrawOutDev(aUpdateTopLeft, aUpdateSize, aUpdateTopLeft, aUpdateSize, *pVout);
}
mpTargetPaintWindow->GetTargetOutputDevice().DrawOutDev(aUpdateTopLeft, aUpdateSize, aUpdateTopLeft, aUpdateSize, *pVout);
// #i75172# Corret repaint end
// Note: This also correcty creates the overlay, thus smooth scroll will
// also be allowed now wth selection (see big IF above)
DLPostPaint2(true);
}
}
else
--nLockPaint;
}
}
delete pVout;
GetWin()->Update();
if ( !Imp()->bStopSmooth )
--nLockPaint;
SetFirstVisPageInvalid();
return sal_True;
}
delete pVout;
}
aVisArea.Pos().X() -= lXDiff;
aVisArea.Pos().Y() -= lYDiff;
if ( pRect )
GetWin()->Scroll( lXDiff, lYDiff, *pRect, SCROLL_CHILDREN);
else
GetWin()->Scroll( lXDiff, lYDiff, SCROLL_CHILDREN);
return sal_False;
}
/******************************************************************************
|*
|* ViewShell::PaintDesktop()
|*
|* Ersterstellung MA 16. Dec. 93
|* Letzte Aenderung MA 30. Nov. 95
|*
******************************************************************************/
void ViewShell::PaintDesktop( const SwRect &rRect )
{
if ( !GetWin() && !GetOut()->GetConnectMetaFile() )
return; //Fuer den Drucker tun wir hier nix
//Sonderfaelle abfangen, damit es nicht gar so ueberraschend aussieht.
//Kann z.B. waehrend des Idle'ns zwischenzeitlich auftreten.
//Die Rechtecke neben den Seiten muessen wir leider auf jedenfall Painten,
//den diese werden spaeter beim VisPortChgd ausgespart.
sal_Bool bBorderOnly = sal_False;
const SwRootFrm *pRoot = GetLayout();//swmod 080305
if ( rRect.Top() > pRoot->Frm().Bottom() )
{
const SwFrm *pPg = pRoot->Lower();
while ( pPg && pPg->GetNext() )
pPg = pPg->GetNext();
if ( !pPg || !pPg->Frm().IsOver( VisArea() ) )
bBorderOnly = sal_True;
}
const bool bBookMode = GetViewOptions()->IsViewLayoutBookMode();
SwRegionRects aRegion( rRect );
//mod #i6193: remove sidebar area to avoid flickering
const SwPostItMgr* pPostItMgr = GetPostItMgr();
const SwTwips nSidebarWidth = pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() ?
pPostItMgr->GetSidebarWidth() + pPostItMgr->GetSidebarBorderWidth() :
0;
if ( bBorderOnly )
{
const SwFrm *pPage =pRoot->Lower(); //swmod 071108//swmod 071225
SwRect aLeft( rRect ), aRight( rRect );
while ( pPage )
{
long nTmp = pPage->Frm().Left();
if ( nTmp < aLeft.Right() )
aLeft.Right( nTmp );
nTmp = pPage->Frm().Right();
if ( nTmp > aRight.Left() )
{
aRight.Left( nTmp + nSidebarWidth );
}
pPage = pPage->GetNext();
}
aRegion.Remove( 0, aRegion.Count() );
if ( aLeft.HasArea() )
aRegion.Insert( aLeft, 0 );
if ( aRight.HasArea() )
aRegion.Insert( aRight, 1 );
}
else
{
const SwFrm *pPage = Imp()->GetFirstVisPage();
const SwTwips nBottom = rRect.Bottom();
//const SwTwips nRight = rRect.Right();
while ( pPage && aRegion.Count() &&
(pPage->Frm().Top() <= nBottom) ) // PAGES01 && (pPage->Frm().Left() <= nRight))
{
SwRect aPageRect( pPage->Frm() );
if ( bBookMode )
{
const SwPageFrm& rFormatPage = static_cast<const SwPageFrm*>(pPage)->GetFormatPage();
aPageRect.SSize() = rFormatPage.Frm().SSize();
}
const bool bSidebarRight =
static_cast<const SwPageFrm*>(pPage)->SidebarPosition() == sw::sidebarwindows::SIDEBAR_RIGHT;
aPageRect.Pos().X() -= bSidebarRight ? 0 : nSidebarWidth;
aPageRect.SSize().Width() += nSidebarWidth;
if ( aPageRect.IsOver( rRect ) )
aRegion -= aPageRect;
pPage = pPage->GetNext();
}
}
if ( aRegion.Count() )
_PaintDesktop( aRegion );
}
// PaintDesktop gesplittet, dieser Teil wird auch von PreViewPage benutzt
void ViewShell::_PaintDesktop( const SwRegionRects &rRegion )
{
// OD 2004-04-23 #116347#
GetOut()->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
GetOut()->SetLineColor();
for ( sal_uInt16 i = 0; i < rRegion.Count(); ++i )
{
const Rectangle aRectangle(rRegion[i].SVRect());
// #i93170#
// Here we have a real Problem. On the one hand we have the buffering for paint
// and overlay which needs an embracing pair of DLPrePaint2/DLPostPaint2 calls,
// on the other hand the MapMode is not set correctly when this code is executed.
// This is done in the users of this method, for each SWpage before painting it.
// Since the MapMode is not correct here, the call to DLPostPaint2 will paint
// existing FormControls due to the current MapMode.
//
// There are basically three solutions for this:
//
// (1) Set the MapMode correct, move the background painting to the users of
// this code
//
// (2) Do no DLPrePaint2/DLPostPaint2 here; no SdrObjects are allowed to lie in
// the desktop region. Disadvantage: the desktop will not be part of the
// buffers, e.g. overlay. Thus, as soon as overlay will be used over the
// desktop, it will not work.
//
// (3) expand DLPostPaint2 with a flag to signal if FormControl paints shall
// be done or not
//
// Currently, (3) will be the best possible solution. It will keep overlay and
// buffering intact and work without MapMode for single pages. In the medium
// to long run, (1) will need to be used and the bool bPaintFormLayer needs
// to be removed again
// #i68597# inform Drawinglayer about display change
DLPrePaint2(Region(aRectangle));
// #i75172# needed to move line/Fill color setters into loop since DLPrePaint2
// may exchange GetOut(), that's it's purpose. This happens e.g. at print preview.
GetOut()->SetFillColor( SwViewOption::GetAppBackgroundColor());
GetOut()->SetLineColor();
GetOut()->DrawRect(aRectangle);
DLPostPaint2(false);
}
GetOut()->Pop();
}
/******************************************************************************
|*
|* ViewShell::CheckInvalidForPaint()
|*
|* Ersterstellung MA 19. May. 94
|* Letzte Aenderung MA 09. Jun. 94
|*
******************************************************************************/
sal_Bool ViewShell::CheckInvalidForPaint( const SwRect &rRect )
{
if ( !GetWin() )
return sal_False;
const SwPageFrm *pPage = Imp()->GetFirstVisPage();
const SwTwips nBottom = VisArea().Bottom();
const SwTwips nRight = VisArea().Right();
sal_Bool bRet = sal_False;
while ( !bRet && pPage && !((pPage->Frm().Top() > nBottom) ||
(pPage->Frm().Left() > nRight)))
{
if ( pPage->IsInvalid() || pPage->IsInvalidFly() )
bRet = sal_True;
pPage = (SwPageFrm*)pPage->GetNext();
}
if ( bRet )
{
//Start/EndAction wuerden hier leider nix helfen, weil das Paint vom
//GUI 'reinkam und somit ein Clipping gesetzt ist gegen das wir nicht
//nicht ankommen.
//Ergo: Alles selbst machen (siehe ImplEndAction())
if ( Imp()->GetRegion() && Imp()->GetRegion()->GetOrigin() != VisArea())
Imp()->DelRegion();
SwLayAction aAction( GetLayout(), Imp() );
aAction.SetComplete( sal_False );
// We increment the action counter to avoid a recursive call of actions
// e.g. from a SwFEShell::RequestObjectResize(..) in bug 95829.
// A recursive call of actions is no good idea because the inner action
// can't format frames which are locked by the outer action. This may
// cause and endless loop.
++nStartAction;
aAction.Action();
--nStartAction;
SwRegionRects *pRegion = Imp()->GetRegion();
if ( pRegion && aAction.IsBrowseActionStop() )
{
//Nur dann interessant, wenn sich im sichtbaren Bereich etwas
//veraendert hat.
sal_Bool bStop = sal_True;
for ( sal_uInt16 i = 0; i < pRegion->Count(); ++i )
{
const SwRect &rTmp = (*pRegion)[i];
if ( sal_False == (bStop = rTmp.IsOver( VisArea() )) )
break;
}
if ( bStop )
{
Imp()->DelRegion();
pRegion = 0;
}
}
if ( pRegion )
{
//Erst Invert dann Compress, niemals andersherum!
pRegion->Invert();
pRegion->Compress();
bRet = sal_False;
if ( pRegion->Count() )
{
SwRegionRects aRegion( rRect );
for ( sal_uInt16 i = 0; i < pRegion->Count(); ++i )
{ const SwRect &rTmp = (*pRegion)[i];
if ( !rRect.IsInside( rTmp ) )
{
InvalidateWindows( rTmp );
if ( rTmp.IsOver( VisArea() ) )
{ aRegion -= rTmp;
bRet = sal_True;
}
}
}
if ( bRet )
{
for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
GetWin()->Invalidate( aRegion[i].SVRect() );
if ( rRect != VisArea() )
{
//rRect == VisArea ist der spezialfall fuer neu bzw.
//Shift-Ctrl-R, dafuer sollte es nicht notwendig sein
//das Rechteck nocheinmal in Dokumentkoordinaten v
//vorzuhalten.
if ( aInvalidRect.IsEmpty() )
aInvalidRect = rRect;
else
aInvalidRect.Union( rRect );
}
}
}
else
bRet = sal_False;
Imp()->DelRegion();
}
else
bRet = sal_False;
}
return bRet;
}
/******************************************************************************
|*
|* ViewShell::Paint()
|*
|* Ersterstellung MA ??
|* Letzte Aenderung MA 17. Sep. 96
|*
******************************************************************************/
void ViewShell::Paint(const Rectangle &rRect)
{
if ( nLockPaint )
{
if ( Imp()->bSmoothUpdate )
{
SwRect aTmp( rRect );
if ( !Imp()->aSmoothRect.IsInside( aTmp ) )
Imp()->bStopSmooth = sal_True;
else
{
Imp()->aSmoothRect = aTmp;
return;
}
}
else
return;
}
if ( SwRootFrm::IsInPaint() )
{
//Waehrend der Ausgabe einer Seite beim Druckvorgang wird das
//Paint gepuffert.
SwPaintQueue::Add( this, SwRect( rRect ) );
return;
}
//MA 30. Jul. 95: fix(16787): mit !nStartAction versuche ich mal mich gegen
//fehlerhaften Code an anderen Stellen zu wehren. Hoffentlich fuehrt das
//nicht zu Problemen!?
if ( bPaintWorks && !nStartAction )
{
if( GetWin() && GetWin()->IsVisible() )
{
SwRect aRect( rRect );
if ( bPaintInProgress ) //Schutz gegen doppelte Paints!
{
GetWin()->Invalidate( rRect );
return;
}
bPaintInProgress = sal_True;
SET_CURR_SHELL( this );
SwRootFrm::SetNoVirDev( sal_True );
//Wir wollen nicht staendig hin und her Clippen, wir verlassen
//uns darauf, das sich alle auf das Rechteck beschraeken und
//brauchen das Clipping hier nur einmalig einkalkulieren. Das
//ClipRect wird hier einmal entfernt und nicht Restauriert, denn
//von aussen braucht es sowieso keiner mehr.
//Nicht wenn wir ein MetaFile aufzeichnen.
if( !GetOut()->GetConnectMetaFile() && GetOut()->IsClipRegion())
GetOut()->SetClipRegion();
if ( IsPreView() )
{
//Falls sinnvoll gleich das alte InvalidRect verarbeiten bzw.
//vernichten.
if ( aRect.IsInside( aInvalidRect ) )
ResetInvalidRect();
ViewShell::bLstAct = sal_True;
GetLayout()->Paint( aRect );
ViewShell::bLstAct = sal_False;
}
else
{
//SwSaveHdl *pSaveHdl = 0;
//if ( Imp()->HasDrawView() )
// pSaveHdl = new SwSaveHdl( Imp() );
//Wenn eine der sichtbaren Seiten noch irgendetwas zum Repaint
//angemeldet hat, so muessen Repaints ausgeloest werden.
if ( !CheckInvalidForPaint( aRect ) )
{
// --> OD 2009-08-12 #i101192#
// start Pre/PostPaint encapsulation to avoid screen blinking
const Region aRepaintRegion(aRect.SVRect());
DLPrePaint2(aRepaintRegion);
// <--
PaintDesktop( aRect );
//Falls sinnvoll gleich das alte InvalidRect verarbeiten bzw.
//vernichten.
if ( aRect.IsInside( aInvalidRect ) )
ResetInvalidRect();
ViewShell::bLstAct = sal_True;
GetLayout()->Paint( aRect );
ViewShell::bLstAct = sal_False;
// --> OD 2009-08-12 #i101192#
// end Pre/PostPaint encapsulation
DLPostPaint2(true);
// <--
}
//delete pSaveHdl;
}
SwRootFrm::SetNoVirDev( sal_False );
bPaintInProgress = sal_False;
UISizeNotify();
}
}
else
{
if ( aInvalidRect.IsEmpty() )
aInvalidRect = SwRect( rRect );
else
aInvalidRect.Union( SwRect( rRect ) );
if ( bInEndAction && GetWin() )
{
const Region aRegion(GetWin()->GetPaintRegion());
RectangleVector aRectangles;
aRegion.GetRegionRectangles(aRectangles);
for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
{
Imp()->AddPaintRect(*aRectIter);
}
//RegionHandle hHdl( aRegion.BeginEnumRects() );
//Rectangle aRect;
//while ( aRegion.GetEnumRects( hHdl, aRect ) )
// Imp()->AddPaintRect( aRect );
//aRegion.EndEnumRects( hHdl );
}
else if ( SfxProgress::GetActiveProgress( GetDoc()->GetDocShell() ) &&
GetOut() == GetWin() )
{
// #i68597#
const Region aDLRegion(rRect);
DLPrePaint2(aDLRegion);
// OD 2004-04-23 #116347#
pOut->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
pOut->SetFillColor( Imp()->GetRetoucheColor() );
pOut->SetLineColor();
pOut->DrawRect( rRect );
pOut->Pop();
// #i68597#
DLPostPaint2(true);
}
}
}
/******************************************************************************
|*
|* ViewShell::SetBrowseBorder()
|*
|* Ersterstellung AMA 20. Aug. 96
|* Letzte Aenderung AMA 20. Aug. 96
|*
******************************************************************************/
void ViewShell::SetBrowseBorder( const Size& rNew )
{
if( rNew != aBrowseBorder )
{
aBrowseBorder = rNew;
if ( aVisArea.HasArea() )
CheckBrowseView( sal_False );
}
}
const Size& ViewShell::GetBrowseBorder() const
{
return aBrowseBorder;
}
sal_Int32 ViewShell::GetBrowseWidth() const
{
const SwPostItMgr* pPostItMgr = GetPostItMgr();
if ( pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() )
{
Size aBorder( aBrowseBorder );
aBorder.Width() += aBrowseBorder.Width();
aBorder.Width() += pPostItMgr->GetSidebarWidth(true) + pPostItMgr->GetSidebarBorderWidth(true);
return aVisArea.Width() - GetOut()->PixelToLogic(aBorder).Width();
}
else
return aVisArea.Width() - 2 * GetOut()->PixelToLogic(aBrowseBorder).Width();
}
/******************************************************************************
|*
|* ViewShell::CheckBrowseView()
|*
|* Ersterstellung MA 04. Mar. 96
|* Letzte Aenderung MA 04. Jul. 96
|*
******************************************************************************/
void ViewShell::CheckBrowseView( sal_Bool bBrowseChgd )
{
if ( !bBrowseChgd && !GetViewOptions()->getBrowseMode() )
return;
SET_CURR_SHELL( this );
ASSERT( GetLayout(), "Layout not ready" );
// Wenn das Layout noch nicht einmal eine Hoehe hat,
// ist sowieso nichts formatiert.
// Dann eruebrigt sich die Invalidierung
// Falsch, z.B. beim Anlegen einer neuen View wird der Inhalt eingef?gt
// und formatiert (trotz einer leeren VisArea). Hier muessen deshalb
// die Seiten zur Formatierung angeregt werden.
if( !GetLayout()->Frm().Height() )
{
SwFrm* pPage = GetLayout()->Lower();
while( pPage )
{
pPage->_InvalidateSize();
pPage = pPage->GetNext();
}
return;
}
LockPaint();
StartAction();
SwPageFrm *pPg = (SwPageFrm*)GetLayout()->Lower();
do
{ pPg->InvalidateSize();
pPg->_InvalidatePrt();
pPg->InvaPercentLowers();
if ( bBrowseChgd )
{
pPg->PrepareHeader();
pPg->PrepareFooter();
}
pPg = (SwPageFrm*)pPg->GetNext();
} while ( pPg );
// Wenn sich die Groessenverhaeltnise im BrowseModus aendern,
// muss die Position und PrtArea der Cntnt- und Tab-Frames invalidiert werden.
sal_uInt8 nInv = INV_PRTAREA | INV_TABLE | INV_POS;
// Beim BrowseModus-Wechsel benoetigen die CntntFrms
// wg. der Drucker/Bildschirmformatierung eine Size-Invalidierung
if( bBrowseChgd )
nInv |= INV_SIZE | INV_DIRECTION;
GetLayout()->InvalidateAllCntnt( nInv );
SwFrm::CheckPageDescs( (SwPageFrm*)GetLayout()->Lower() );
EndAction();
UnlockPaint();
}
/*************************************************************************
|*
|* ViewShell::GetLayout()
|* ViewShell::GetNodes()
|*
|* Ersterstellung OK 26. May. 92
|* Letzte Aenderung MA 16. Sep. 93
|*
*************************************************************************/
SwRootFrm *ViewShell::GetLayout() const
{
return pLayout.get(); //swmod 080116
}
/***********************************************************************/
OutputDevice& ViewShell::GetRefDev() const
{
OutputDevice* pTmpOut = 0;
if ( GetWin() &&
GetViewOptions()->getBrowseMode() &&
!GetViewOptions()->IsPrtFormat() )
pTmpOut = GetWin();
else if ( 0 != mpTmpRef )
pTmpOut = mpTmpRef;
else
pTmpOut = GetDoc()->getReferenceDevice( true );
return *pTmpOut;
}
const SwNodes& ViewShell::GetNodes() const
{
return pDoc->GetNodes();
}
void ViewShell::DrawSelChanged()
{
}
Size ViewShell::GetDocSize() const
{
Size aSz;
const SwRootFrm* pRoot = GetLayout();
if( pRoot )
aSz = pRoot->Frm().SSize();
return aSz;
}
SfxItemPool& ViewShell::GetAttrPool()
{
return GetDoc()->GetAttrPool();
}
/******************************************************************************
|*
|* ViewShell::ApplyViewOptions(), ImplApplyViewOptions()
|*
|* Ersterstellung ??
|* Letzte Aenderung MA 03. Mar. 98
|*
******************************************************************************/
void ViewShell::ApplyViewOptions( const SwViewOption &rOpt )
{
ViewShell *pSh = this;
do
{ pSh->StartAction();
pSh = (ViewShell*)pSh->GetNext();
} while ( pSh != this );
ImplApplyViewOptions( rOpt );
// swmod 080115
// With one layout per view it is not longer necessary
// to sync these "layout related" view options
// But as long as we have to disable "multiple layout"
pSh = (ViewShell*)this->GetNext();
while ( pSh != this )
{
SwViewOption aOpt( *pSh->GetViewOptions() );
aOpt.SetFldName( rOpt.IsFldName() );
aOpt.SetShowHiddenField( rOpt.IsShowHiddenField() );
aOpt.SetShowHiddenPara( rOpt.IsShowHiddenPara() );
aOpt.SetShowHiddenChar( rOpt.IsShowHiddenChar() );
aOpt.SetViewLayoutBookMode( rOpt.IsViewLayoutBookMode() );
aOpt.SetViewLayoutColumns( rOpt.GetViewLayoutColumns() );
aOpt.SetPostIts(rOpt.IsPostIts());
if ( !(aOpt == *pSh->GetViewOptions()) )
pSh->ImplApplyViewOptions( aOpt );
pSh = (ViewShell*)pSh->GetNext();
}
// End of disabled multiple window
pSh = this;
do
{ pSh->EndAction();
pSh = (ViewShell*)pSh->GetNext();
} while ( pSh != this );
}
void ViewShell::ImplApplyViewOptions( const SwViewOption &rOpt )
{
if (*pOpt == rOpt)
return;
Window *pMyWin = GetWin();
if( !pMyWin )
{
ASSERT( pMyWin, "ViewShell::ApplyViewOptions: no window" );
return;
}
SET_CURR_SHELL( this );
sal_Bool bReformat = sal_False;
if( pOpt->IsShowHiddenField() != rOpt.IsShowHiddenField() )
{
((SwHiddenTxtFieldType*)pDoc->GetSysFldType( RES_HIDDENTXTFLD ))->
SetHiddenFlag( !rOpt.IsShowHiddenField() );
bReformat = sal_True;
}
if ( pOpt->IsShowHiddenPara() != rOpt.IsShowHiddenPara() )
{
SwHiddenParaFieldType* pFldType = (SwHiddenParaFieldType*)GetDoc()->
GetSysFldType(RES_HIDDENPARAFLD);
if( pFldType && pFldType->GetDepends() )
{
SwMsgPoolItem aHnt( RES_HIDDENPARA_PRINT );
pFldType->ModifyNotification( &aHnt, 0);
}
bReformat = sal_True;
}
if ( !bReformat && pOpt->IsShowHiddenChar() != rOpt.IsShowHiddenChar() )
{
bReformat = GetDoc()->ContainsHiddenChars();
}
// bReformat wird sal_True, wenn ...
// - Feldnamen anzeigen oder nicht ...
// ( - SwEndPortion muessen _nicht_ mehr generiert werden. )
// - Das Window ist natuerlich was ganz anderes als der Drucker...
bReformat = bReformat || pOpt->IsFldName() != rOpt.IsFldName();
// Der Mapmode wird veraendert, Minima/Maxima werden von der UI beachtet
if( pOpt->GetZoom() != rOpt.GetZoom() && !IsPreView() )
{
MapMode aMode( pMyWin->GetMapMode() );
Fraction aNewFactor( rOpt.GetZoom(), 100 );
aMode.SetScaleX( aNewFactor );
aMode.SetScaleY( aNewFactor );
pMyWin->SetMapMode( aMode );
// Wenn kein ReferenzDevice (Drucker) zum Formatieren benutzt wird,
// sondern der Bildschirm, muss bei Zoomfaktoraenderung neu formatiert
// werden.
if( pOpt->getBrowseMode() )
bReformat = sal_True;
}
bool bBrowseModeChanged = false;
if( pOpt->getBrowseMode() != rOpt.getBrowseMode() )
{
bBrowseModeChanged = true;
bReformat = sal_True;
}
else if( pOpt->getBrowseMode() && pOpt->IsPrtFormat() != rOpt.IsPrtFormat() )
bReformat = sal_True;
if ( HasDrawView() || rOpt.IsGridVisible() )
{
if ( !HasDrawView() )
MakeDrawView();
SwDrawView *pDView = Imp()->GetDrawView();
if ( pDView->IsDragStripes() != rOpt.IsCrossHair() )
pDView->SetDragStripes( rOpt.IsCrossHair() );
if ( pDView->IsGridSnap() != rOpt.IsSnap() )
pDView->SetGridSnap( rOpt.IsSnap() );
if ( pDView->IsGridVisible() != rOpt.IsGridVisible() )
pDView->SetGridVisible( rOpt.IsGridVisible() );
const Size &rSz = rOpt.GetSnapSize();
pDView->SetGridCoarse( rSz );
const Size aFSize
( rSz.Width() ? rSz.Width() / (rOpt.GetDivisionX()+1) : 0,
rSz.Height()? rSz.Height()/ (rOpt.GetDivisionY()+1) : 0);
pDView->SetGridFine( aFSize );
Fraction aSnGrWdtX(rSz.Width(), rOpt.GetDivisionX() + 1);
Fraction aSnGrWdtY(rSz.Height(), rOpt.GetDivisionY() + 1);
pDView->SetSnapGridWidth( aSnGrWdtX, aSnGrWdtY );
if ( pOpt->IsSolidMarkHdl() != rOpt.IsSolidMarkHdl() )
pDView->SetSolidMarkHdl( rOpt.IsSolidMarkHdl() );
// it's a JOE interface !
if ( pOpt->IsBigMarkHdl() != rOpt.IsBigMarkHdl() )
pDView->SetMarkHdlSizePixel(rOpt.IsBigMarkHdl() ? 9 : 7);
}
sal_Bool bOnlineSpellChgd = pOpt->IsOnlineSpell() != rOpt.IsOnlineSpell();
*pOpt = rOpt; // Erst jetzt werden die Options uebernommen.
pOpt->SetUIOptions(rOpt);
pDoc->set(IDocumentSettingAccess::HTML_MODE, 0 != ::GetHtmlMode(pDoc->GetDocShell()));
if( bBrowseModeChanged )
{
// --> FME 2005-03-16 #i44963# Good occasion to check if page sizes in
// page descriptions are still set to (LONG_MAX, LONG_MAX) (html import)
pDoc->CheckDefaultPageFmt();
// <--
CheckBrowseView( sal_True );
}
pMyWin->Invalidate();
if ( bReformat )
{
// Es hilft alles nichts, wir muessen an alle CntntFrms ein
// Prepare verschicken, wir formatieren neu:
StartAction();
Reformat();
EndAction();
}
if( bOnlineSpellChgd )
{
ViewShell *pSh = (ViewShell*)this->GetNext();
sal_Bool bOnlineSpl = rOpt.IsOnlineSpell();
while( pSh != this )
{ pSh->pOpt->SetOnlineSpell( bOnlineSpl );
Window *pTmpWin = pSh->GetWin();
if( pTmpWin )
pTmpWin->Invalidate();
pSh = (ViewShell*)pSh->GetNext();
}
}
}
/******************************************************************************
|*
|* ViewShell::SetUIOptions()
|*
|* Ersterstellung OS 29.07.96
|* Letzte Aenderung OS 29.07.96
|*
******************************************************************************/
void ViewShell::SetUIOptions( const SwViewOption &rOpt )
{
pOpt->SetUIOptions(rOpt);
//the API-Flag of the view options is set but never reset
//it is required to set scroll bars in readonly documents
if(rOpt.IsStarOneSetting())
pOpt->SetStarOneSetting(sal_True);
pOpt->SetSymbolFont(rOpt.GetSymbolFont());
}
/******************************************************************************
|*
|* ViewShell::SetReadonly()
|*
|* Ersterstellung OS 05.09.96
|* Letzte Aenderung MA 12. Feb. 97
|*
******************************************************************************/
void ViewShell::SetReadonlyOption(sal_Bool bSet)
{
//JP 01.02.99: bei ReadOnly Flag richtig abfragen und ggfs. neu
// formatieren; Bug 61335
// Schalten wir gerade von Readonly auf Bearbeiten um?
if( bSet != pOpt->IsReadonly() )
{
// damit die Flags richtig erfragt werden koennen.
pOpt->SetReadonly( sal_False );
sal_Bool bReformat = pOpt->IsFldName();
pOpt->SetReadonly( bSet );
if( bReformat )
{
StartAction();
Reformat();
if ( GetWin() )
GetWin()->Invalidate();
EndAction();
}
else if ( GetWin() )
GetWin()->Invalidate();
if( Imp()->IsAccessible() )
Imp()->InvalidateAccessibleEditableState( sal_False );
}
}
/* -----------------28.08.2003 15:45-----------------
--------------------------------------------------*/
void ViewShell::SetPDFExportOption(sal_Bool bSet)
{
if( bSet != pOpt->IsPDFExport() )
{
if( bSet && pOpt->getBrowseMode() )
pOpt->SetPrtFormat( sal_True );
pOpt->SetPDFExport(bSet);
}
}
/* -----------------------------2002/07/31 17:06------------------------------
---------------------------------------------------------------------------*/
void ViewShell::SetReadonlySelectionOption(sal_Bool bSet)
{
if( bSet != pOpt->IsSelectionInReadonly() )
{
pOpt->SetSelectionInReadonly(bSet);
}
}
/******************************************************************************
|*
|* ViewShell::SetPrtFormatOption()
|*
|* Ersterstellung AMA 10. Sep. 97
|* Letzte Aenderung AMA 10. Sep. 97
|*
******************************************************************************/
void ViewShell::SetPrtFormatOption( sal_Bool bSet )
{
pOpt->SetPrtFormat( bSet );
}
/******************************************************************************
|*
|* ViewShell::UISizeNotify()
|*
|* Ersterstellung MA 14. Jan. 97
|* Letzte Aenderung MA 14. Jan. 97
|*
******************************************************************************/
void ViewShell::UISizeNotify()
{
if ( bDocSizeChgd )
{
bDocSizeChgd = sal_False;
sal_Bool bOld = bInSizeNotify;
bInSizeNotify = sal_True;
::SizeNotify( this, GetDocSize() );
bInSizeNotify = bOld;
}
}
void ViewShell::SetRestoreActions(sal_uInt16 nSet)
{
DBG_ASSERT(!GetRestoreActions()||!nSet, "mehrfaches Restore der Actions ?");
Imp()->SetRestoreActions(nSet);
}
sal_uInt16 ViewShell::GetRestoreActions() const
{
return Imp()->GetRestoreActions();
}
sal_Bool ViewShell::IsNewLayout() const
{
return GetLayout()->IsNewLayout();
}
uno::Reference< ::com::sun::star::accessibility::XAccessible > ViewShell::CreateAccessible()
{
uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc;
// We require a layout and an XModel to be accessible.
ASSERT( pLayout, "no layout, no access" );
ASSERT( GetWin(), "no window, no access" );
if( pDoc->GetCurrentViewShell() && GetWin() ) //swmod 071108
xAcc = Imp()->GetAccessibleMap().GetDocumentView();
return xAcc;
}
uno::Reference< ::com::sun::star::accessibility::XAccessible >
ViewShell::CreateAccessiblePreview()
{
DBG_ASSERT( IsPreView(),
"Can't create accessible preview for non-preview ViewShell" );
// We require a layout and an XModel to be accessible.
ASSERT( pLayout, "no layout, no access" );
ASSERT( GetWin(), "no window, no access" );
// OD 15.01.2003 #103492# - add condition <IsPreView()>
if ( IsPreView() && GetLayout()&& GetWin() )
{
// OD 14.01.2003 #103492# - adjustment for new method signature
return Imp()->GetAccessibleMap().GetDocumentPreview(
PagePreviewLayout()->maPrevwPages,
GetWin()->GetMapMode().GetScaleX(),
GetLayout()->GetPageByPageNum( PagePreviewLayout()->mnSelectedPageNum ),
PagePreviewLayout()->maWinSize ); //swmod 080305
}
return NULL;
}
void ViewShell::InvalidateAccessibleFocus()
{
if( Imp()->IsAccessible() )
Imp()->GetAccessibleMap().InvalidateFocus();
}
/** invalidate CONTENT_FLOWS_FROM/_TO relation for paragraphs
OD 2005-12-01 #i27138#
@author OD
*/
void ViewShell::InvalidateAccessibleParaFlowRelation( const SwTxtFrm* _pFromTxtFrm,
const SwTxtFrm* _pToTxtFrm )
{
if ( GetLayout() && GetLayout()->IsAnyShellAccessible() )
{
Imp()->_InvalidateAccessibleParaFlowRelation( _pFromTxtFrm, _pToTxtFrm );
}
}
/** invalidate text selection for paragraphs
OD 2005-12-12 #i27301#
@author OD
*/
void ViewShell::InvalidateAccessibleParaTextSelection()
{
if ( GetLayout() && GetLayout()->IsAnyShellAccessible() )
{
Imp()->_InvalidateAccessibleParaTextSelection();
}
}
/** invalidate attributes for paragraphs
OD 2009-01-06 #i88069#
@author OD
*/
void ViewShell::InvalidateAccessibleParaAttrs( const SwTxtFrm& rTxtFrm )
{
if ( GetLayout() && GetLayout()->IsAnyShellAccessible() )
{
Imp()->_InvalidateAccessibleParaAttrs( rTxtFrm );
}
}
SwAccessibleMap* ViewShell::GetAccessibleMap()
{
if ( Imp()->IsAccessible() )
{
return &(Imp()->GetAccessibleMap());
}
return 0;
}
/* -----------------------------06.05.2002 13:23------------------------------
---------------------------------------------------------------------------*/
void ViewShell::ApplyAccessiblityOptions(SvtAccessibilityOptions& rAccessibilityOptions)
{
if(pOpt->IsPagePreview() && !rAccessibilityOptions.GetIsForPagePreviews())
{
pAccOptions->SetAlwaysAutoColor(sal_False);
pAccOptions->SetStopAnimatedGraphics(sal_False);
pAccOptions->SetStopAnimatedText(sal_False);
}
else
{
pAccOptions->SetAlwaysAutoColor(rAccessibilityOptions.GetIsAutomaticFontColor());
pAccOptions->SetStopAnimatedGraphics(! rAccessibilityOptions.GetIsAllowAnimatedGraphics());
pAccOptions->SetStopAnimatedText(! rAccessibilityOptions.GetIsAllowAnimatedText());
// --> FME 2004-06-29 #114856# Formular view
// Always set this option, not only if document is read-only:
pOpt->SetSelectionInReadonly(rAccessibilityOptions.IsSelectionInReadonly());
}
}
ShellResource* ViewShell::GetShellRes()
{
return pShellRes;
}
void ViewShell::SetCareWin( Window* pNew )
{
pCareWindow = pNew;
}
sal_uInt16 ViewShell::GetPageCount() const
{
return GetLayout() ? GetLayout()->GetPageNum() : 1;
}
const Size ViewShell::GetPageSize( sal_uInt16 nPageNum, bool bSkipEmptyPages ) const
{
Size aSize;
const SwRootFrm* pTmpRoot = GetLayout();
if( pTmpRoot && nPageNum )
{
const SwPageFrm* pPage = static_cast<const SwPageFrm*>
(pTmpRoot->Lower());
while( --nPageNum && pPage->GetNext() )
pPage = static_cast<const SwPageFrm*>( pPage->GetNext() );
if( !bSkipEmptyPages && pPage->IsEmptyPage() && pPage->GetNext() )
pPage = static_cast<const SwPageFrm*>( pPage->GetNext() );
aSize = pPage->Frm().SSize();
}
return aSize;
}
// --> FME 2004-06-15 #i12836# enhanced pdf export
sal_Int32 ViewShell::GetPageNumAndSetOffsetForPDF( OutputDevice& rOut, const SwRect& rRect ) const
{
ASSERT( GetLayout(), "GetPageNumAndSetOffsetForPDF assumes presence of layout" )
sal_Int32 nRet = -1;
// --> FME 2005-01-07 #i40059# Position out of bounds:
SwRect aRect( rRect );
aRect.Pos().X() = Max( aRect.Left(), GetLayout()->Frm().Left() );
// <--
const SwPageFrm* pPage = GetLayout()->GetPageAtPos( aRect.Center() );
if ( pPage )
{
ASSERT( pPage, "GetPageNumAndSetOffsetForPDF: No page found" )
Point aOffset( pPage->Frm().Pos() );
aOffset.X() = -aOffset.X();
aOffset.Y() = -aOffset.Y();
MapMode aMapMode( rOut.GetMapMode() );
aMapMode.SetOrigin( aOffset );
rOut.SetMapMode( aMapMode );
nRet = pPage->GetPhyPageNum() - 1;
}
return nRet;
}
// <--
// --> PB 2007-05-30 #146850#
const BitmapEx& ViewShell::GetReplacementBitmap( bool bIsErrorState )
{
BitmapEx** ppRet;
sal_uInt16 nResId = 0, nHCResId = 0;
if( bIsErrorState )
{
ppRet = &pErrorBmp;
nResId = RID_GRAPHIC_ERRORBMP;
nHCResId = RID_GRAPHIC_ERRORBMP_HC;
}
else
{
ppRet = &pReplaceBmp;
nResId = RID_GRAPHIC_REPLACEBMP;
nHCResId = RID_GRAPHIC_REPLACEBMP_HC;
}
if( !*ppRet )
{
sal_uInt16 nBmpResId =
Application::GetSettings().GetStyleSettings().GetHighContrastMode()
? nHCResId : nResId;
*ppRet = new BitmapEx( SW_RES( nBmpResId ) );
}
return **ppRet;
}
void ViewShell::DeleteReplacementBitmaps()
{
DELETEZ( pErrorBmp );
DELETEZ( pReplaceBmp );
}
// <--
SwPostItMgr* ViewShell::GetPostItMgr()
{
SwView* pView = GetDoc()->GetDocShell() ? GetDoc()->GetDocShell()->GetView() : 0;
if ( pView )
return pView->GetPostItMgr();
return 0;
}
/*
* Document Interface Access
*/
const IDocumentSettingAccess* ViewShell::getIDocumentSettingAccess() const { return pDoc; }
IDocumentSettingAccess* ViewShell::getIDocumentSettingAccess() { return pDoc; }
const IDocumentDeviceAccess* ViewShell::getIDocumentDeviceAccess() const { return pDoc; }
IDocumentDeviceAccess* ViewShell::getIDocumentDeviceAccess() { return pDoc; }
const IDocumentMarkAccess* ViewShell::getIDocumentMarkAccess() const { return pDoc->getIDocumentMarkAccess(); }
IDocumentMarkAccess* ViewShell::getIDocumentMarkAccess() { return pDoc->getIDocumentMarkAccess(); }
const IDocumentDrawModelAccess* ViewShell::getIDocumentDrawModelAccess() const { return pDoc; }
IDocumentDrawModelAccess* ViewShell::getIDocumentDrawModelAccess() { return pDoc; }
const IDocumentRedlineAccess* ViewShell::getIDocumentRedlineAccess() const { return pDoc; }
IDocumentRedlineAccess* ViewShell::getIDocumentRedlineAccess() { return pDoc; }
const IDocumentLayoutAccess* ViewShell::getIDocumentLayoutAccess() const { return pDoc; }
IDocumentLayoutAccess* ViewShell::getIDocumentLayoutAccess() { return pDoc; }
const IDocumentFieldsAccess* ViewShell::getIDocumentFieldsAccess() const { return pDoc; }
IDocumentContentOperations* ViewShell::getIDocumentContentOperations() { return pDoc; }
IDocumentStylePoolAccess* ViewShell::getIDocumentStylePoolAccess() { return pDoc; }
const IDocumentStatistics* ViewShell::getIDocumentStatistics() const { return pDoc; }
IDocumentUndoRedo & ViewShell::GetIDocumentUndoRedo()
{ return pDoc->GetIDocumentUndoRedo(); }
IDocumentUndoRedo const& ViewShell::GetIDocumentUndoRedo() const
{ return pDoc->GetIDocumentUndoRedo(); }
// --> OD 2007-11-14 #i83479#
const IDocumentListItems* ViewShell::getIDocumentListItemsAccess() const
{
return pDoc;
}
const IDocumentOutlineNodes* ViewShell::getIDocumentOutlineNodesAccess() const
{
return pDoc;
}
// <--