/************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2000, 2010 Oracle and/or its affiliates. * * OpenOffice.org - a multi-platform office productivity suite * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sd.hxx" #include "Window.hxx" #include #include #include #include #include #include #include "app.hrc" #include "helpids.h" #include "ViewShell.hxx" #include "DrawViewShell.hxx" #include "View.hxx" #include "FrameView.hxx" #include "OutlineViewShell.hxx" #include "drawdoc.hxx" #include "AccessibleDrawDocumentView.hxx" #include "WindowUpdater.hxx" namespace sd { #define SCROLL_LINE_FACT 0.05 // Faktor fuer Zeilenscrolling #define SCROLL_PAGE_FACT 0.5 // Faktor fuer Seitenscrolling #define SCROLL_SENSITIVE 20 // Sensitiver Bereich (Pixel) #define ZOOM_MULTIPLICATOR 10000 // Multiplikator um Rundungsfehler zu vermeiden #define MIN_ZOOM 5 // Minimaler Zoomfaktor #define MAX_ZOOM 3000 // Maximaler Zoomfaktor /************************************************************************* |* |* Konstruktor |* \************************************************************************/ Window::Window(::Window* pParent) : ::Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)), DropTargetHelper( this ), mpShareWin(NULL), maWinPos(0, 0), // vorsichtshalber; die Werte sollten aber maViewOrigin(0, 0), // vom Besitzer des Fensters neu gesetzt maViewSize(1000, 1000), // werden mnMinZoom(MIN_ZOOM), mnMaxZoom(MAX_ZOOM), mbMinZoomAutoCalc(false), mbCalcMinZoomByMinSide(true), mbCenterAllowed(true), mnTicks (0), mbDraggedFrom(false), mpViewShell(NULL), mbUseDropScroll (true) { SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS ); MapMode aMap(GetMapMode()); aMap.SetMapUnit(MAP_100TH_MM); SetMapMode(aMap); // Damit im Diamodus die ::WindowColor genommen wird SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetWindowColor() ) ); // adjust contrast mode initially bool bUseContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); SetDrawMode( bUseContrast ? ViewShell::OUTPUT_DRAWMODE_CONTRAST : ViewShell::OUTPUT_DRAWMODE_COLOR ); // Hilfe-ID setzen // SetHelpId(HID_SD_WIN_DOCUMENT); SetUniqueId(HID_SD_WIN_DOCUMENT); // #i78183# Added after discussed with AF EnableRTL(sal_False); } /************************************************************************* |* |* Destruktor |* \************************************************************************/ Window::~Window (void) { if (mpViewShell != NULL) { WindowUpdater* pWindowUpdater = mpViewShell->GetWindowUpdater(); if (pWindowUpdater != NULL) pWindowUpdater->UnregisterWindow (this); } } void Window::SetViewShell (ViewShell* pViewSh) { WindowUpdater* pWindowUpdater = NULL; // Unregister at device updater of old view shell. if (mpViewShell != NULL) { pWindowUpdater = mpViewShell->GetWindowUpdater(); if (pWindowUpdater != NULL) pWindowUpdater->UnregisterWindow (this); } mpViewShell = pViewSh; // Register at device updater of new view shell if (mpViewShell != NULL) { pWindowUpdater = mpViewShell->GetWindowUpdater(); if (pWindowUpdater != NULL) pWindowUpdater->RegisterWindow (this); } } void Window::CalcMinZoom() { // Are we entitled to change the minimal zoom factor? if ( mbMinZoomAutoCalc ) { // Get current zoom factor. long nZoom = GetZoom(); if ( mpShareWin ) { mpShareWin->CalcMinZoom(); mnMinZoom = mpShareWin->mnMinZoom; } else { // Get the rectangle of the output area in logical coordinates // and calculate the scaling factors that would lead to the view // area (also called application area) to completely fill the // window. Size aWinSize = PixelToLogic(GetOutputSizePixel()); sal_uLong nX = (sal_uLong) ((double) aWinSize.Width() * (double) ZOOM_MULTIPLICATOR / (double) maViewSize.Width()); sal_uLong nY = (sal_uLong) ((double) aWinSize.Height() * (double) ZOOM_MULTIPLICATOR / (double) maViewSize.Height()); // Decide whether to take the larger or the smaller factor. sal_uLong nFact; if (mbCalcMinZoomByMinSide) nFact = Min(nX, nY); else nFact = Max(nX, nY); // The factor is tansfomed according to the current zoom factor. nFact = nFact * nZoom / ZOOM_MULTIPLICATOR; mnMinZoom = Max((sal_uInt16) MIN_ZOOM, (sal_uInt16) nFact); } // If the current zoom factor is smaller than the calculated minimal // zoom factor then set the new minimal factor as the current zoom // factor. if ( nZoom < (long) mnMinZoom ) SetZoomFactor(mnMinZoom); } } void Window::SetMinZoom (long int nMin) { mnMinZoom = (sal_uInt16) nMin; } long Window::GetMinZoom (void) const { return mnMinZoom; } void Window::SetMaxZoom (long int nMax) { mnMaxZoom = (sal_uInt16) nMax; } long Window::GetMaxZoom (void) const { return mnMaxZoom; } long Window::GetZoom (void) const { if( GetMapMode().GetScaleX().GetDenominator() ) { return GetMapMode().GetScaleX().GetNumerator() * 100L / GetMapMode().GetScaleX().GetDenominator(); } else { return 0; } } /************************************************************************* |* |* Resize event |* \************************************************************************/ void Window::Resize() { ::Window::Resize(); CalcMinZoom(); if( mpViewShell && mpViewShell->GetViewFrame() ) mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); } /************************************************************************* |* |* PrePaint event |* \************************************************************************/ void Window::PrePaint() { if ( mpViewShell ) mpViewShell->PrePaint(); } /************************************************************************* |* |* Paint event |* \************************************************************************/ void Window::Paint(const Rectangle& rRect) { if ( mpViewShell ) mpViewShell->Paint(rRect, this); } /************************************************************************* |* |* Keyboard event |* \************************************************************************/ void Window::KeyInput(const KeyEvent& rKEvt) { if (!(mpViewShell && mpViewShell->KeyInput(rKEvt, this))) { if (mpViewShell && rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE) { mpViewShell->GetViewShell()->Escape(); } else { ::Window::KeyInput(rKEvt); } } } /************************************************************************* |* |* MouseButtonDown event |* \************************************************************************/ void Window::MouseButtonDown(const MouseEvent& rMEvt) { if ( mpViewShell ) mpViewShell->MouseButtonDown(rMEvt, this); } /************************************************************************* |* |* MouseMove event |* \************************************************************************/ void Window::MouseMove(const MouseEvent& rMEvt) { if ( mpViewShell ) mpViewShell->MouseMove(rMEvt, this); } /************************************************************************* |* |* MouseButtonUp event |* \************************************************************************/ void Window::MouseButtonUp(const MouseEvent& rMEvt) { mnTicks = 0; if ( mpViewShell ) mpViewShell->MouseButtonUp(rMEvt, this); } /************************************************************************* |* |* Command event |* \************************************************************************/ void Window::Command(const CommandEvent& rCEvt) { if ( mpViewShell ) mpViewShell->Command(rCEvt, this); } long Window::Notify( NotifyEvent& rNEvt ) { long nResult = sal_False; if ( mpViewShell ) { nResult = mpViewShell->Notify(rNEvt, this); } if( !nResult ) nResult = ::Window::Notify( rNEvt ); return nResult; } /************************************************************************* |* |* RequestHelp event |* \************************************************************************/ void Window::RequestHelp(const HelpEvent& rEvt) { if ( mpViewShell ) { if( !mpViewShell->RequestHelp( rEvt, this) ) ::Window::RequestHelp( rEvt ); } else ::Window::RequestHelp( rEvt ); } Point Window::GetWinViewPos (void) const { return maWinPos; } Point Window::GetViewOrigin (void) const { return maViewOrigin; } Size Window::GetViewSize (void) const { return maViewSize; } /************************************************************************* |* |* Position der linken oberen Ecke des im Fenster sichtbaren Bereichs |* setzen |* \************************************************************************/ void Window::SetWinViewPos(const Point& rPnt) { maWinPos = rPnt; } /************************************************************************* |* |* Ursprung der Darstellung in Bezug zur gesamten Arbeitsflaeche setzen |* \************************************************************************/ void Window::SetViewOrigin(const Point& rPnt) { maViewOrigin = rPnt; } /************************************************************************* |* |* Groesse der gesamten Arbeitsflaeche, die mit dem Fenster betrachtet |* werden kann, setzen |* \************************************************************************/ void Window::SetViewSize(const Size& rSize) { maViewSize = rSize; CalcMinZoom(); } void Window::SetCenterAllowed (bool bIsAllowed) { mbCenterAllowed = bIsAllowed; } long Window::SetZoomFactor(long nZoom) { // Clip the zoom factor to the valid range marked by nMinZoom as // calculated by CalcMinZoom() and the constant MAX_ZOOM. if ( nZoom > MAX_ZOOM ) nZoom = MAX_ZOOM; if ( nZoom < (long) mnMinZoom ) nZoom = mnMinZoom; // Set the zoom factor at the window's map mode. MapMode aMap(GetMapMode()); aMap.SetScaleX(Fraction(nZoom, 100)); aMap.SetScaleY(Fraction(nZoom, 100)); SetMapMode(aMap); // Update the map mode's origin (to what effect?). UpdateMapOrigin(); // Update the view's snapping to the the new zoom factor. if ( mpViewShell && mpViewShell->ISA(DrawViewShell) ) ((DrawViewShell*) mpViewShell)->GetView()-> RecalcLogicSnapMagnetic(*this); // Return the zoom factor just in case it has been changed above to lie // inside the valid range. return nZoom; } void Window::SetZoomIntegral(long nZoom) { // Clip the zoom factor to the valid range marked by nMinZoom as // previously calculated by CalcMinZoom() and the // MAX_ZOOM constant. if ( nZoom > MAX_ZOOM ) nZoom = MAX_ZOOM; if ( nZoom < (long) mnMinZoom ) nZoom = mnMinZoom; // Calculate the window's new origin. Size aSize = PixelToLogic(GetOutputSizePixel()); long nW = aSize.Width() * GetZoom() / nZoom; long nH = aSize.Height() * GetZoom() / nZoom; maWinPos.X() += (aSize.Width() - nW) / 2; maWinPos.Y() += (aSize.Height() - nH) / 2; if ( maWinPos.X() < 0 ) maWinPos.X() = 0; if ( maWinPos.Y() < 0 ) maWinPos.Y() = 0; // Finally update this window's map mode to the given zoom factor that // has been clipped to the valid range. SetZoomFactor(nZoom); } long Window::GetZoomForRect( const Rectangle& rZoomRect ) { long nRetZoom = 100; if( (rZoomRect.GetWidth() != 0) && (rZoomRect.GetHeight() != 0)) { // Calculate the scale factors which will lead to the given // rectangle being fully visible (when translated accordingly) as // large as possible in the output area independently in both // coordinate directions . sal_uLong nX(0L); sal_uLong nY(0L); const Size aWinSize( PixelToLogic(GetOutputSizePixel()) ); if(rZoomRect.GetHeight()) { nX = (sal_uLong) ((double) aWinSize.Height() * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetHeight()); } if(rZoomRect.GetWidth()) { nY = (sal_uLong) ((double) aWinSize.Width() * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetWidth()); } // Use the smaller one of both so that the zoom rectangle will be // fully visible with respect to both coordinate directions. sal_uLong nFact = Min(nX, nY); // Transform the current zoom factor so that it leads to the desired // scaling. nRetZoom = nFact * GetZoom() / ZOOM_MULTIPLICATOR; // Calculate the new origin. if ( nFact == 0 ) { // Don't change anything if the scale factor is degenrate. nRetZoom = GetZoom(); } else { // Clip the zoom factor to the valid range marked by nMinZoom as // previously calculated by CalcMinZoom() and the // MAX_ZOOM constant. if ( nRetZoom > MAX_ZOOM ) nRetZoom = MAX_ZOOM; if ( nRetZoom < (long) mnMinZoom ) nRetZoom = mnMinZoom; } } return nRetZoom; } /** Recalculate the zoom factor and translation so that the given rectangle is displayed centered and as large as possible while still being fully visible in the window. */ long Window::SetZoomRect (const Rectangle& rZoomRect) { long nNewZoom = 100; if (rZoomRect.GetWidth() == 0 || rZoomRect.GetHeight() == 0) { // The given rectangle is degenerate. Use the default zoom factor // (above) of 100%. SetZoomIntegral(nNewZoom); } else { Point aPos = rZoomRect.TopLeft(); // Transform the output area from pixel coordinates into logical // coordinates. Size aWinSize = PixelToLogic(GetOutputSizePixel()); // Paranoia! The degenerate case of zero width or height has been // taken care of above. DBG_ASSERT(rZoomRect.GetWidth(), "ZoomRect-Breite = 0!"); DBG_ASSERT(rZoomRect.GetHeight(), "ZoomRect-Hoehe = 0!"); // Calculate the scale factors which will lead to the given // rectangle being fully visible (when translated accordingly) as // large as possible in the output area independently in both // coordinate directions . sal_uLong nX(0L); sal_uLong nY(0L); if(rZoomRect.GetHeight()) { nX = (sal_uLong) ((double) aWinSize.Height() * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetHeight()); } if(rZoomRect.GetWidth()) { nY = (sal_uLong) ((double) aWinSize.Width() * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetWidth()); } // Use the smaller one of both so that the zoom rectangle will be // fully visible with respect to both coordinate directions. sal_uLong nFact = Min(nX, nY); // Transform the current zoom factor so that it leads to the desired // scaling. long nZoom = nFact * GetZoom() / ZOOM_MULTIPLICATOR; // Calculate the new origin. if ( nFact == 0 ) { // Don't change anything if the scale factor is degenrate. nNewZoom = GetZoom(); } else { // Calculate the new window position that centers the given // rectangle on the screen. if ( nZoom > MAX_ZOOM ) nFact = nFact * MAX_ZOOM / nZoom; maWinPos = maViewOrigin + aPos; aWinSize.Width() = (long) ((double) aWinSize.Width() * (double) ZOOM_MULTIPLICATOR / (double) nFact); maWinPos.X() += (rZoomRect.GetWidth() - aWinSize.Width()) / 2; aWinSize.Height() = (long) ((double) aWinSize.Height() * (double) ZOOM_MULTIPLICATOR / (double) nFact); maWinPos.Y() += (rZoomRect.GetHeight() - aWinSize.Height()) / 2; if ( maWinPos.X() < 0 ) maWinPos.X() = 0; if ( maWinPos.Y() < 0 ) maWinPos.Y() = 0; // Adapt the window's map mode to the new zoom factor. nNewZoom = SetZoomFactor(nZoom); } } return(nNewZoom); } void Window::SetMinZoomAutoCalc (bool bAuto) { mbMinZoomAutoCalc = bAuto; } /************************************************************************* |* |* Neuen MapMode-Origin berechnen und setzen; wenn aWinPos.X()/Y() |* gleich -1 ist, wird die entsprechende Position zentriert |* (z.B. fuer Initialisierung) |* \************************************************************************/ void Window::UpdateMapOrigin(sal_Bool bInvalidate) { sal_Bool bChanged = sal_False; Size aWinSize = PixelToLogic(GetOutputSizePixel()); if ( mbCenterAllowed ) { if ( maWinPos.X() > maViewSize.Width() - aWinSize.Width() ) { maWinPos.X() = maViewSize.Width() - aWinSize.Width(); bChanged = sal_True; } if ( maWinPos.Y() > maViewSize.Height() - aWinSize.Height() ) { maWinPos.Y() = maViewSize.Height() - aWinSize.Height(); bChanged = sal_True; } if ( aWinSize.Width() > maViewSize.Width() || maWinPos.X() < 0 ) { maWinPos.X() = maViewSize.Width() / 2 - aWinSize.Width() / 2; bChanged = sal_True; } if ( aWinSize.Height() > maViewSize.Height() || maWinPos.Y() < 0 ) { maWinPos.Y() = maViewSize.Height() / 2 - aWinSize.Height() / 2; bChanged = sal_True; } } UpdateMapMode (); if (bChanged && bInvalidate) Invalidate(); } void Window::UpdateMapMode (void) { Size aWinSize = PixelToLogic(GetOutputSizePixel()); maWinPos -= maViewOrigin; Size aPix(maWinPos.X(), maWinPos.Y()); aPix = LogicToPixel(aPix); // Groesse muss vielfaches von BRUSH_SIZE sein, damit Muster // richtig dargestellt werden // #i2237# // removed old stuff here which still forced zoom to be // %BRUSH_SIZE which is outdated now if (mpViewShell && mpViewShell->ISA(DrawViewShell)) { Size aViewSizePixel = LogicToPixel(maViewSize); Size aWinSizePixel = LogicToPixel(aWinSize); // Seite soll nicht am Fensterrand "kleben" if (aPix.Width() == 0) { // #i2237# // Since BRUSH_SIZE alignment is outdated now, i use the // former constant here directly aPix.Width() -= 8; } if (aPix.Height() == 0) { // #i2237# // Since BRUSH_SIZE alignment is outdated now, i use the // former constant here directly aPix.Height() -= 8; } } aPix = PixelToLogic(aPix); maWinPos.X() = aPix.Width(); maWinPos.Y() = aPix.Height(); Point aNewOrigin (-maWinPos.X(), -maWinPos.Y()); maWinPos += maViewOrigin; MapMode aMap(GetMapMode()); aMap.SetOrigin(aNewOrigin); SetMapMode(aMap); } /************************************************************************* |* |* X-Position des sichtbaren Bereichs als Bruchteil (< 1) |* der gesamten Arbeitsbereichbreite zuruegeben |* \************************************************************************/ double Window::GetVisibleX() { return ((double) maWinPos.X() / maViewSize.Width()); } /************************************************************************* |* |* Y-Position des sichtbaren Bereichs als Bruchteil (< 1) |* der gesamten Arbeitsbereichhoehe zuruegeben |* \************************************************************************/ double Window::GetVisibleY() { return ((double) maWinPos.Y() / maViewSize.Height()); } /************************************************************************* |* |* X- und Y-Position des sichtbaren Bereichs als Bruchteile (< 1) |* der gesamten Arbeitsbereichgroesse setzen |* negative Werte werden ignoriert |* \************************************************************************/ void Window::SetVisibleXY(double fX, double fY) { long nOldX = maWinPos.X(); long nOldY = maWinPos.Y(); if ( fX >= 0 ) maWinPos.X() = (long) (fX * maViewSize.Width()); if ( fY >= 0 ) maWinPos.Y() = (long) (fY * maViewSize.Height()); UpdateMapOrigin(sal_False); // Size sz(nOldX - aWinPos.X(), nOldY - aWinPos.Y()); // sz = LogicToPixel(sz); Scroll(nOldX - maWinPos.X(), nOldY - maWinPos.Y(), SCROLL_CHILDREN); Update(); } /************************************************************************* |* |* Breite des sichtbaren Bereichs im Verhaeltnis zur |* gesamten Arbeitsbereichbreite zuruegeben |* \************************************************************************/ double Window::GetVisibleWidth() { Size aWinSize = PixelToLogic(GetOutputSizePixel()); if ( aWinSize.Width() > maViewSize.Width() ) aWinSize.Width() = maViewSize.Width(); return ((double) aWinSize.Width() / maViewSize.Width()); } /************************************************************************* |* |* Hoehe des sichtbaren Bereichs im Verhaeltnis zur |* gesamten Arbeitsbereichhoehe zuruegeben |* \************************************************************************/ double Window::GetVisibleHeight() { Size aWinSize = PixelToLogic(GetOutputSizePixel()); if ( aWinSize.Height() > maViewSize.Height() ) aWinSize.Height() = maViewSize.Height(); return ((double) aWinSize.Height() / maViewSize.Height()); } /************************************************************************* |* |* Breite einer Scrollspalte im Verhaeltnis zur gesamten |* Arbeitsbereichbreite zuruegeben |* \************************************************************************/ double Window::GetScrlLineWidth() { return (GetVisibleWidth() * SCROLL_LINE_FACT); } /************************************************************************* |* |* Breite einer Scrollspalte im Verhaeltnis zur gesamten |* Arbeitsbereichhoehe zuruegeben |* \************************************************************************/ double Window::GetScrlLineHeight() { return (GetVisibleHeight() * SCROLL_LINE_FACT); } /************************************************************************* |* |* Breite einer Scrollpage im Verhaeltnis zur gesamten |* Arbeitsbereichbreite zuruegeben |* \************************************************************************/ double Window::GetScrlPageWidth() { return (GetVisibleWidth() * SCROLL_PAGE_FACT); } /************************************************************************* |* |* Breite einer Scrollpage im Verhaeltnis zur gesamten |* Arbeitsbereichhoehe zuruegeben |* \************************************************************************/ double Window::GetScrlPageHeight() { return (GetVisibleHeight() * SCROLL_PAGE_FACT); } /************************************************************************* |* |* Fenster deaktivieren |* \************************************************************************/ void Window::LoseFocus() { mnTicks = 0; ::Window::LoseFocus (); } /************************************************************************* |* |* Fenster aktivieren |* \************************************************************************/ void Window::GrabFocus() { mnTicks = 0; ::Window::GrabFocus (); } /************************************************************************* |* |* DataChanged |* \************************************************************************/ void Window::DataChanged( const DataChangedEvent& rDCEvt ) { ::Window::DataChanged( rDCEvt ); // PRINTER bei allen Dokumenten weglassen, die keinen Printer benutzen. // FONTS und FONTSUBSTITUTION weglassen, wenn keine Textausgaben // vorhanden sind, bzw. wenn das Dokument keinen Text zulaesst. if ( (rDCEvt.GetType() == DATACHANGED_PRINTER) || (rDCEvt.GetType() == DATACHANGED_DISPLAY) || (rDCEvt.GetType() == DATACHANGED_FONTS) || (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) { if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) ) { // When the screen zoom factor has changed then reset the zoom // factor of the frame to allways display the whole page. const AllSettings* pOldSettings = rDCEvt.GetOldSettings (); const AllSettings& rNewSettings = GetSettings (); if (pOldSettings) if (pOldSettings->GetStyleSettings().GetScreenZoom() != rNewSettings.GetStyleSettings().GetScreenZoom()) mpViewShell->GetViewFrame()->GetDispatcher()-> Execute(SID_SIZE_PAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); // ScrollBars neu anordnen bzw. Resize ausloesen, da sich // ScrollBar-Groesse geaendert haben kann. Dazu muss dann im // Resize-Handler aber auch die Groesse der ScrollBars aus // den Settings abgefragt werden. Resize(); // Daten neu Setzen, die aus den Systemeinstellungen bzw. aus // den Settings uebernommen werden. Evtl. weitere Daten neu // berechnen, da sich auch die Aufloesung hierdurch geaendert // haben kann. if( mpViewShell ) { const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); SvtAccessibilityOptions aAccOptions; sal_uLong nOutputMode; sal_uInt16 nPreviewSlot; if( rStyleSettings.GetHighContrastMode() ) nOutputMode = ViewShell::OUTPUT_DRAWMODE_CONTRAST; else nOutputMode = ViewShell::OUTPUT_DRAWMODE_COLOR; if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() ) nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST; else nPreviewSlot = SID_PREVIEW_QUALITY_COLOR; if( mpViewShell->ISA( DrawViewShell ) ) { SetDrawMode( nOutputMode ); mpViewShell->GetFrameView()->SetDrawMode( nOutputMode ); // #110094#-7 // mpViewShell->GetView()->ReleaseMasterPagePaintCache(); Invalidate(); } // #103100# Overwrite window color for OutlineView if( mpViewShell->ISA(OutlineViewShell ) ) { svtools::ColorConfig aColorConfig; const Color aDocColor( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor ); SetBackground( Wallpaper( aDocColor ) ); } SfxRequest aReq( nPreviewSlot, 0, mpViewShell->GetDocSh()->GetDoc()->GetItemPool() ); mpViewShell->ExecReq( aReq ); mpViewShell->Invalidate(); mpViewShell->ArrangeGUIElements(); // #101928# re-create handles to show new outfit if(mpViewShell->ISA(DrawViewShell)) { mpViewShell->GetView()->AdjustMarkHdl(); } } } if ( (rDCEvt.GetType() == DATACHANGED_DISPLAY) || ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) { // Virtuelle Device die auch von der Aufloesung oder von // Systemeinstellungen abhaengen, sollten geupdatet werden. // Ansonsten sollte zumindest bei DATACHANGED_DISPLAY // die virtuellen Devices geupdatet werden, da es einige // Systeme erlauben die Aufloesung und Farbtiefe waehrend // der Laufzeit zu aendern oder eben bei Palettenaenderungen // die virtuellen Device geupdatet werden muessen, da bei // Ausgaben ein anderes Farbmatching stattfinden kann. } if ( rDCEvt.GetType() == DATACHANGED_FONTS ) { // Wenn das Dokument Font-AuswahlBoxen anbietet, muessen // diese geupdatet werden. Wie dies genau aussehen muss, // weiss ich leider auch nicht. Aber evtl. kann man das // ja global handeln. Dies muessten wir evtl. mal // mit PB absprechen, aber der ist derzeit leider Krank. // Also bevor dies hier gehandelt wird, vorher mit // PB und mir absprechen. } if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ) { // Formatierung neu durchfuehren, da Fonts die im Dokument // vorkommen, nicht mehr vorhanden sein muessen oder // jetzt vorhanden sind oder durch andere ersetzt wurden // sind. if( mpViewShell ) { DrawDocShell* pDocSh = mpViewShell->GetDocSh(); if( pDocSh ) pDocSh->SetPrinter( pDocSh->GetPrinter( sal_True ) ); } } if ( rDCEvt.GetType() == DATACHANGED_PRINTER ) { // Wie hier die Behandlung aussehen soll, weiss ich leider // selbst noch nicht. Evtl. mal einen Printer loeschen und // schauen was gemacht werden muss. Evtl. muesste ich in // VCL dafuer noch etwas einbauen, wenn der benutze Printer // geloescht wird. Ansonsten wuerde ich hier evtl. die // Formatierung neu berechnen, wenn der aktuelle Drucker // zerstoert wurde. if( mpViewShell ) { DrawDocShell* pDocSh = mpViewShell->GetDocSh(); if( pDocSh ) pDocSh->SetPrinter( pDocSh->GetPrinter( sal_True ) ); } } // Alles neu ausgeben Invalidate(); } } /************************************************************************* |* |* DropTargetHelper::AcceptDrop |* \************************************************************************/ sal_Int8 Window::AcceptDrop( const AcceptDropEvent& rEvt ) { sal_Int8 nRet = DND_ACTION_NONE; if( mpViewShell && !mpViewShell->GetDocSh()->IsReadOnly() ) { if( mpViewShell ) nRet = mpViewShell->AcceptDrop( rEvt, *this, this, SDRPAGE_NOTFOUND, SDRLAYER_NOTFOUND ); if (mbUseDropScroll && ! mpViewShell->ISA(OutlineViewShell)) DropScroll( rEvt.maPosPixel ); } return nRet; } /************************************************************************* |* |* DropTargetHelper::ExecuteDrop |* \************************************************************************/ sal_Int8 Window::ExecuteDrop( const ExecuteDropEvent& rEvt ) { sal_Int8 nRet = DND_ACTION_NONE; if( mpViewShell ) { nRet = mpViewShell->ExecuteDrop( rEvt, *this, this, SDRPAGE_NOTFOUND, SDRLAYER_NOTFOUND ); } return nRet; } void Window::SetUseDropScroll (bool bUseDropScroll) { mbUseDropScroll = bUseDropScroll; } /************************************************************************* |* |* Scrolling bei AcceptDrop-Events |* \************************************************************************/ void Window::DropScroll(const Point& rMousePos) { short nDx = 0; short nDy = 0; Size aSize = GetOutputSizePixel(); if (aSize.Width() > SCROLL_SENSITIVE * 3) { if ( rMousePos.X() < SCROLL_SENSITIVE ) { nDx = -1; } if ( rMousePos.X() >= aSize.Width() - SCROLL_SENSITIVE ) { nDx = 1; } } if (aSize.Height() > SCROLL_SENSITIVE * 3) { if ( rMousePos.Y() < SCROLL_SENSITIVE ) { nDy = -1; } if ( rMousePos.Y() >= aSize.Height() - SCROLL_SENSITIVE ) { nDy = 1; } } if ( (nDx || nDy) && (rMousePos.X()!=0 || rMousePos.Y()!=0 ) ) { if (mnTicks > 20) mpViewShell->ScrollLines(nDx, nDy); else mnTicks ++; } } ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible> Window::CreateAccessible (void) { if (mpViewShell != NULL) return mpViewShell->CreateAccessibleDocumentView (this); else { OSL_TRACE ("::sd::Window::CreateAccessible: no view shell"); return ::Window::CreateAccessible (); } } XubString Window::GetSurroundingText() const { if ( mpViewShell->GetShellType() == ViewShell::ST_OUTLINE ) { return XubString(); } else if ( mpViewShell->GetView()->IsTextEdit() ) { OutlinerView *pOLV = mpViewShell->GetView()->GetTextEditOutlinerView(); return pOLV->GetEditView().GetSurroundingText(); } else { return XubString(); } } Selection Window::GetSurroundingTextSelection() const { if ( mpViewShell->GetShellType() == ViewShell::ST_OUTLINE ) { return Selection( 0, 0 ); } else if ( mpViewShell->GetView()->IsTextEdit() ) { OutlinerView *pOLV = mpViewShell->GetView()->GetTextEditOutlinerView(); return pOLV->GetEditView().GetSurroundingTextSelection(); } else { return Selection( 0, 0 ); } } } // end of namespace sd