xref: /aoo41x/main/sd/source/ui/view/sdwindow.cxx (revision 3ea0c3d5)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 
27 #include "Window.hxx"
28 #include <sfx2/dispatch.hxx>
29 #include <sfx2/request.hxx>
30 
31 #include <sfx2/viewfrm.hxx>
32 #include <svx/svxids.hrc>
33 
34 #include <editeng/outliner.hxx>
35 #include <editeng/editview.hxx>
36 
37 #include "app.hrc"
38 #include "helpids.h"
39 #include "ViewShell.hxx"
40 #include "DrawViewShell.hxx"
41 #include "View.hxx"
42 #include "FrameView.hxx"
43 #include "OutlineViewShell.hxx"
44 #include "drawdoc.hxx"
45 #include "AccessibleDrawDocumentView.hxx"
46 #include "WindowUpdater.hxx"
47 
48 #include <vcl/svapp.hxx>
49 
50 namespace sd {
51 
52 #define SCROLL_LINE_FACT   0.05     // Faktor fuer Zeilenscrolling
53 #define SCROLL_PAGE_FACT   0.5      // Faktor fuer Seitenscrolling
54 #define SCROLL_SENSITIVE   20       // Sensitiver Bereich (Pixel)
55 #define ZOOM_MULTIPLICATOR 10000    // Multiplikator um Rundungsfehler zu vermeiden
56 #define MIN_ZOOM	       5        // Minimaler Zoomfaktor
57 #define MAX_ZOOM	       3000	    // Maximaler Zoomfaktor
58 
59 
60 /*************************************************************************
61 |*
62 |* Konstruktor
63 |*
64 \************************************************************************/
65 
Window(::Window * pParent)66 Window::Window(::Window* pParent)
67     : ::Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)),
68 	  DropTargetHelper( this ),
69       mpShareWin(NULL),
70       maWinPos(0, 0),			// vorsichtshalber; die Werte sollten aber
71       maViewOrigin(0, 0),		// vom Besitzer des Fensters neu gesetzt
72       maViewSize(1000, 1000),	// werden
73       mnMinZoom(MIN_ZOOM),
74       mnMaxZoom(MAX_ZOOM),
75 	  mbMinZoomAutoCalc(false),
76       mbCalcMinZoomByMinSide(true),
77       mbCenterAllowed(true),
78       mnTicks (0),
79       mbDraggedFrom(false),
80       mpViewShell(NULL),
81       mbUseDropScroll (true)
82 {
83 	SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS );
84 
85 	MapMode aMap(GetMapMode());
86 	aMap.SetMapUnit(MAP_100TH_MM);
87 	SetMapMode(aMap);
88 
89 	// Damit im Diamodus die ::WindowColor genommen wird
90 	SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetWindowColor() ) );
91 
92 	// adjust contrast mode initially
93 	bool bUseContrast = GetSettings().GetStyleSettings().GetHighContrastMode();
94     SetDrawMode( bUseContrast
95         ? ViewShell::OUTPUT_DRAWMODE_CONTRAST
96         : ViewShell::OUTPUT_DRAWMODE_COLOR );
97 
98 	// Hilfe-ID setzen
99 	// SetHelpId(HID_SD_WIN_DOCUMENT);
100 	SetUniqueId(HID_SD_WIN_DOCUMENT);
101 
102 	// #i78183# Added after discussed with AF
103 	EnableRTL(sal_False);
104 }
105 
106 /*************************************************************************
107 |*
108 |* Destruktor
109 |*
110 \************************************************************************/
111 
~Window(void)112 Window::~Window (void)
113 {
114     if (mpViewShell != NULL)
115     {
116         WindowUpdater* pWindowUpdater = mpViewShell->GetWindowUpdater();
117         if (pWindowUpdater != NULL)
118             pWindowUpdater->UnregisterWindow (this);
119     }
120 }
121 
122 
123 
124 
SetViewShell(ViewShell * pViewSh)125 void Window::SetViewShell (ViewShell* pViewSh)
126 {
127     WindowUpdater* pWindowUpdater = NULL;
128     // Unregister at device updater of old view shell.
129     if (mpViewShell != NULL)
130     {
131         pWindowUpdater = mpViewShell->GetWindowUpdater();
132         if (pWindowUpdater != NULL)
133             pWindowUpdater->UnregisterWindow (this);
134     }
135 
136     mpViewShell = pViewSh;
137 
138     // Register at device updater of new view shell
139     if (mpViewShell != NULL)
140     {
141         pWindowUpdater = mpViewShell->GetWindowUpdater();
142         if (pWindowUpdater != NULL)
143             pWindowUpdater->RegisterWindow (this);
144     }
145 }
146 
CalcMinZoom()147 void Window::CalcMinZoom()
148 {
149     // Are we entitled to change the minimal zoom factor?
150 	if ( mbMinZoomAutoCalc )
151 	{
152         // Get current zoom factor.
153 		long nZoom = GetZoom();
154 
155 		if ( mpShareWin )
156 		{
157 			mpShareWin->CalcMinZoom();
158 			mnMinZoom = mpShareWin->mnMinZoom;
159 		}
160 		else
161 		{
162             // Get the rectangle of the output area in logical coordinates
163             // and calculate the scaling factors that would lead to the view
164             // area (also called application area) to completely fill the
165             // window.
166 			Size aWinSize = PixelToLogic(GetOutputSizePixel());
167 			sal_uLong nX = (sal_uLong) ((double) aWinSize.Width()
168                 * (double) ZOOM_MULTIPLICATOR / (double) maViewSize.Width());
169 			sal_uLong nY = (sal_uLong) ((double) aWinSize.Height()
170                 * (double) ZOOM_MULTIPLICATOR / (double) maViewSize.Height());
171 
172             // Decide whether to take the larger or the smaller factor.
173 			sal_uLong nFact;
174 			if (mbCalcMinZoomByMinSide)
175                 nFact = Min(nX, nY);
176 			else
177                 nFact = Max(nX, nY);
178 
179             // The factor is tansfomed according to the current zoom factor.
180 			nFact = nFact * nZoom / ZOOM_MULTIPLICATOR;
181 			mnMinZoom = Max((sal_uInt16) MIN_ZOOM, (sal_uInt16) nFact);
182 		}
183         // If the current zoom factor is smaller than the calculated minimal
184         // zoom factor then set the new minimal factor as the current zoom
185         // factor.
186 		if ( nZoom < (long) mnMinZoom )
187 			SetZoomFactor(mnMinZoom);
188 	}
189 }
190 
191 
192 
193 
SetMinZoom(long int nMin)194 void Window::SetMinZoom (long int nMin)
195 {
196     mnMinZoom = (sal_uInt16) nMin;
197 }
198 
199 
200 
201 
GetMinZoom(void) const202 long Window::GetMinZoom (void) const
203 {
204     return mnMinZoom;
205 }
206 
207 
208 
209 
SetMaxZoom(long int nMax)210 void Window::SetMaxZoom (long int nMax)
211 {
212     mnMaxZoom = (sal_uInt16) nMax;
213 }
214 
215 
216 
217 
GetMaxZoom(void) const218 long Window::GetMaxZoom (void) const
219 {
220     return mnMaxZoom;
221 }
222 
223 
224 
225 
GetZoom(void) const226 long Window::GetZoom (void) const
227 {
228 	if( GetMapMode().GetScaleX().GetDenominator() )
229 	{
230 		return GetMapMode().GetScaleX().GetNumerator() * 100L
231 			/ GetMapMode().GetScaleX().GetDenominator();
232 	}
233 	else
234 	{
235 		return 0;
236 	}
237 }
238 
239 
240 
241 
242 /*************************************************************************
243 |*
244 |* Resize event
245 |*
246 \************************************************************************/
247 
Resize()248 void Window::Resize()
249 {
250 	::Window::Resize();
251 	CalcMinZoom();
252 
253     if( mpViewShell && mpViewShell->GetViewFrame() )
254         mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
255 }
256 
257 /*************************************************************************
258 |*
259 |* PrePaint event
260 |*
261 \************************************************************************/
262 
PrePaint()263 void Window::PrePaint()
264 {
265 	if ( mpViewShell )
266 		mpViewShell->PrePaint();
267 }
268 
269 /*************************************************************************
270 |*
271 |* Paint event
272 |*
273 \************************************************************************/
274 
Paint(const Rectangle & rRect)275 void Window::Paint(const Rectangle& rRect)
276 {
277 	if ( mpViewShell )
278 		mpViewShell->Paint(rRect, this);
279 }
280 
281 /*************************************************************************
282 |*
283 |* Keyboard event
284 |*
285 \************************************************************************/
286 
KeyInput(const KeyEvent & rKEvt)287 void Window::KeyInput(const KeyEvent& rKEvt)
288 {
289 	if (!(mpViewShell && mpViewShell->KeyInput(rKEvt, this)))
290 	{
291 		if (mpViewShell && rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE)
292 		{
293             mpViewShell->GetViewShell()->Escape();
294 		}
295 		else
296 		{
297 			::Window::KeyInput(rKEvt);
298 		}
299 	}
300 }
301 
302 /*************************************************************************
303 |*
304 |* MouseButtonDown event
305 |*
306 \************************************************************************/
307 
MouseButtonDown(const MouseEvent & rMEvt)308 void Window::MouseButtonDown(const MouseEvent& rMEvt)
309 {
310 	if ( mpViewShell )
311 		mpViewShell->MouseButtonDown(rMEvt, this);
312 }
313 
314 /*************************************************************************
315 |*
316 |* MouseMove event
317 |*
318 \************************************************************************/
319 
MouseMove(const MouseEvent & rMEvt)320 void Window::MouseMove(const MouseEvent& rMEvt)
321 {
322 	if ( mpViewShell )
323 		mpViewShell->MouseMove(rMEvt, this);
324 }
325 
326 /*************************************************************************
327 |*
328 |* MouseButtonUp event
329 |*
330 \************************************************************************/
331 
MouseButtonUp(const MouseEvent & rMEvt)332 void Window::MouseButtonUp(const MouseEvent& rMEvt)
333 {
334 	mnTicks = 0;
335 
336 	if ( mpViewShell )
337 		mpViewShell->MouseButtonUp(rMEvt, this);
338 }
339 
340 /*************************************************************************
341 |*
342 |* Command event
343 |*
344 \************************************************************************/
345 
Command(const CommandEvent & rCEvt)346 void Window::Command(const CommandEvent& rCEvt)
347 {
348 	if ( mpViewShell )
349 		mpViewShell->Command(rCEvt, this);
350 }
351 
Notify(NotifyEvent & rNEvt)352 long Window::Notify( NotifyEvent& rNEvt )
353 {
354     long nResult = sal_False;
355     if ( mpViewShell )
356     {
357         nResult = mpViewShell->Notify(rNEvt, this);
358     }
359     if( !nResult )
360         nResult = ::Window::Notify( rNEvt );
361 
362     return nResult;
363 }
364 
365 
366 /*************************************************************************
367 |*
368 |* RequestHelp event
369 |*
370 \************************************************************************/
371 
RequestHelp(const HelpEvent & rEvt)372 void Window::RequestHelp(const HelpEvent& rEvt)
373 {
374 	if ( mpViewShell )
375 	{
376 		if( !mpViewShell->RequestHelp( rEvt, this) )
377 			::Window::RequestHelp( rEvt );
378 	}
379 	else
380 		::Window::RequestHelp( rEvt );
381 }
382 
383 
384 
385 
GetWinViewPos(void) const386 Point Window::GetWinViewPos (void) const
387 {
388     return maWinPos;
389 }
390 
391 
392 
393 
GetViewOrigin(void) const394 Point Window::GetViewOrigin (void) const
395 {
396     return maViewOrigin;
397 }
398 
399 
400 
401 
GetViewSize(void) const402 Size Window::GetViewSize (void) const
403 {
404     return maViewSize;
405 }
406 
407 
408 
409 
410 /*************************************************************************
411 |*
412 |* Position der linken oberen Ecke des im Fenster sichtbaren Bereichs
413 |* setzen
414 |*
415 \************************************************************************/
416 
SetWinViewPos(const Point & rPnt)417 void Window::SetWinViewPos(const Point& rPnt)
418 {
419 	maWinPos = rPnt;
420 }
421 
422 /*************************************************************************
423 |*
424 |* Ursprung der Darstellung in Bezug zur gesamten Arbeitsflaeche setzen
425 |*
426 \************************************************************************/
427 
SetViewOrigin(const Point & rPnt)428 void Window::SetViewOrigin(const Point& rPnt)
429 {
430 	maViewOrigin = rPnt;
431 }
432 
433 /*************************************************************************
434 |*
435 |* Groesse der gesamten Arbeitsflaeche, die mit dem Fenster betrachtet
436 |* werden kann, setzen
437 |*
438 \************************************************************************/
439 
SetViewSize(const Size & rSize)440 void Window::SetViewSize(const Size& rSize)
441 {
442 	maViewSize = rSize;
443 	CalcMinZoom();
444 }
445 
446 
447 
448 
SetCenterAllowed(bool bIsAllowed)449 void Window::SetCenterAllowed (bool bIsAllowed)
450 {
451     mbCenterAllowed = bIsAllowed;
452 }
453 
454 
455 
456 
SetZoomFactor(long nZoom)457 long Window::SetZoomFactor(long nZoom)
458 {
459     // Clip the zoom factor to the valid range marked by nMinZoom as
460     // calculated by CalcMinZoom() and the constant MAX_ZOOM.
461 	if ( nZoom > MAX_ZOOM )
462         nZoom = MAX_ZOOM;
463 	if ( nZoom < (long) mnMinZoom )
464         nZoom = mnMinZoom;
465 
466     // Set the zoom factor at the window's map mode.
467 	MapMode aMap(GetMapMode());
468 	aMap.SetScaleX(Fraction(nZoom, 100));
469 	aMap.SetScaleY(Fraction(nZoom, 100));
470 	SetMapMode(aMap);
471 
472     // Update the map mode's origin (to what effect?).
473 	UpdateMapOrigin();
474 
475     // Update the view's snapping to the the new zoom factor.
476 	if ( mpViewShell && mpViewShell->ISA(DrawViewShell) )
477 		((DrawViewShell*) mpViewShell)->GetView()->
478 										RecalcLogicSnapMagnetic(*this);
479 
480     // Return the zoom factor just in case it has been changed above to lie
481     // inside the valid range.
482 	return nZoom;
483 }
484 
SetZoomIntegral(long nZoom)485 void Window::SetZoomIntegral(long nZoom)
486 {
487     // Clip the zoom factor to the valid range marked by nMinZoom as
488     // previously calculated by <member>CalcMinZoom()</member> and the
489     // MAX_ZOOM constant.
490 	if ( nZoom > MAX_ZOOM )
491         nZoom = MAX_ZOOM;
492 	if ( nZoom < (long) mnMinZoom )
493         nZoom = mnMinZoom;
494 
495     // Calculate the window's new origin.
496 	Size aSize = PixelToLogic(GetOutputSizePixel());
497 	long nW = aSize.Width()  * GetZoom() / nZoom;
498 	long nH = aSize.Height() * GetZoom() / nZoom;
499 	maWinPos.X() += (aSize.Width()  - nW) / 2;
500 	maWinPos.Y() += (aSize.Height() - nH) / 2;
501 	if ( maWinPos.X() < 0 ) maWinPos.X() = 0;
502 	if ( maWinPos.Y() < 0 ) maWinPos.Y() = 0;
503 
504     // Finally update this window's map mode to the given zoom factor that
505     // has been clipped to the valid range.
506 	SetZoomFactor(nZoom);
507 }
508 
GetZoomForRect(const Rectangle & rZoomRect)509 long Window::GetZoomForRect( const Rectangle& rZoomRect )
510 {
511 	long nRetZoom = 100;
512 
513     if( (rZoomRect.GetWidth() != 0) && (rZoomRect.GetHeight() != 0))
514     {
515         // Calculate the scale factors which will lead to the given
516         // rectangle being fully visible (when translated accordingly) as
517         // large as possible in the output area independently in both
518         // coordinate directions .
519 		sal_uLong nX(0L);
520 		sal_uLong nY(0L);
521 
522         const Size aWinSize( PixelToLogic(GetOutputSizePixel()) );
523 		if(rZoomRect.GetHeight())
524 		{
525 			nX = (sal_uLong) ((double) aWinSize.Height()
526 			   * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetHeight());
527 		}
528 
529 		if(rZoomRect.GetWidth())
530 		{
531 			nY = (sal_uLong) ((double) aWinSize.Width()
532 				* (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetWidth());
533 		}
534 
535         // Use the smaller one of both so that the zoom rectangle will be
536         // fully visible with respect to both coordinate directions.
537 		sal_uLong nFact = Min(nX, nY);
538 
539         // Transform the current zoom factor so that it leads to the desired
540         // scaling.
541 		nRetZoom = nFact * GetZoom() / ZOOM_MULTIPLICATOR;
542 
543         // Calculate the new origin.
544 		if ( nFact == 0 )
545 		{
546             // Don't change anything if the scale factor is degenrate.
547 			nRetZoom = GetZoom();
548 		}
549 		else
550 		{
551             // Clip the zoom factor to the valid range marked by nMinZoom as
552             // previously calculated by <member>CalcMinZoom()</member> and the
553             // MAX_ZOOM constant.
554 	        if ( nRetZoom > MAX_ZOOM )
555                 nRetZoom = MAX_ZOOM;
556 	        if ( nRetZoom < (long) mnMinZoom )
557                 nRetZoom = mnMinZoom;
558        }
559     }
560 
561     return nRetZoom;
562 }
563 
564 /** Recalculate the zoom factor and translation so that the given rectangle
565     is displayed centered and as large as possible while still being fully
566     visible in the window.
567 */
SetZoomRect(const Rectangle & rZoomRect)568 long Window::SetZoomRect (const Rectangle& rZoomRect)
569 {
570 	long nNewZoom = 100;
571 
572 	if (rZoomRect.GetWidth() == 0 || rZoomRect.GetHeight() == 0)
573 	{
574         // The given rectangle is degenerate.  Use the default zoom factor
575         // (above) of 100%.
576 		SetZoomIntegral(nNewZoom);
577 	}
578 	else
579 	{
580 		Point aPos = rZoomRect.TopLeft();
581         // Transform the output area from pixel coordinates into logical
582         // coordinates.
583 		Size aWinSize = PixelToLogic(GetOutputSizePixel());
584         // Paranoia!  The degenerate case of zero width or height has been
585         // taken care of above.
586 		DBG_ASSERT(rZoomRect.GetWidth(), "ZoomRect-Breite = 0!");
587 		DBG_ASSERT(rZoomRect.GetHeight(), "ZoomRect-Hoehe = 0!");
588 
589         // Calculate the scale factors which will lead to the given
590         // rectangle being fully visible (when translated accordingly) as
591         // large as possible in the output area independently in both
592         // coordinate directions .
593 		sal_uLong nX(0L);
594 		sal_uLong nY(0L);
595 
596 		if(rZoomRect.GetHeight())
597 		{
598 			nX = (sal_uLong) ((double) aWinSize.Height()
599 			   * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetHeight());
600 		}
601 
602 		if(rZoomRect.GetWidth())
603 		{
604 			nY = (sal_uLong) ((double) aWinSize.Width()
605 				* (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetWidth());
606 		}
607 
608         // Use the smaller one of both so that the zoom rectangle will be
609         // fully visible with respect to both coordinate directions.
610 		sal_uLong nFact = Min(nX, nY);
611 
612         // Transform the current zoom factor so that it leads to the desired
613         // scaling.
614 		long nZoom = nFact * GetZoom() / ZOOM_MULTIPLICATOR;
615 
616         // Calculate the new origin.
617 		if ( nFact == 0 )
618 		{
619             // Don't change anything if the scale factor is degenrate.
620 			nNewZoom = GetZoom();
621 		}
622 		else
623 		{
624             // Calculate the new window position that centers the given
625             // rectangle on the screen.
626 			if ( nZoom > MAX_ZOOM )
627 				nFact = nFact * MAX_ZOOM / nZoom;
628 
629 			maWinPos = maViewOrigin + aPos;
630 
631 			aWinSize.Width() = (long) ((double) aWinSize.Width() * (double) ZOOM_MULTIPLICATOR / (double) nFact);
632 			maWinPos.X() += (rZoomRect.GetWidth() - aWinSize.Width()) / 2;
633 			aWinSize.Height() = (long) ((double) aWinSize.Height() * (double) ZOOM_MULTIPLICATOR / (double) nFact);
634 			maWinPos.Y() += (rZoomRect.GetHeight() - aWinSize.Height()) / 2;
635 
636 			if ( maWinPos.X() < 0 )	maWinPos.X() = 0;
637 			if ( maWinPos.Y() < 0 )	maWinPos.Y() = 0;
638 
639             // Adapt the window's map mode to the new zoom factor.
640 			nNewZoom = SetZoomFactor(nZoom);
641 		}
642 	}
643 
644 	return(nNewZoom);
645 }
646 
647 
648 
649 
SetMinZoomAutoCalc(bool bAuto)650 void Window::SetMinZoomAutoCalc (bool bAuto)
651 {
652     mbMinZoomAutoCalc = bAuto;
653 }
654 
655 
656 
657 
658 /*************************************************************************
659 |*
660 |* Neuen MapMode-Origin berechnen und setzen; wenn aWinPos.X()/Y()
661 |* gleich -1 ist, wird die entsprechende Position zentriert
662 |* (z.B. fuer Initialisierung)
663 |*
664 \************************************************************************/
665 
UpdateMapOrigin(sal_Bool bInvalidate)666 void Window::UpdateMapOrigin(sal_Bool bInvalidate)
667 {
668 	sal_Bool	bChanged = sal_False;
669 	Size	aWinSize = PixelToLogic(GetOutputSizePixel());
670 
671 	if ( mbCenterAllowed )
672 	{
673 		if ( maWinPos.X() > maViewSize.Width() - aWinSize.Width() )
674 		{
675 			maWinPos.X() = maViewSize.Width() - aWinSize.Width();
676 			bChanged = sal_True;
677 		}
678 		if ( maWinPos.Y() > maViewSize.Height() - aWinSize.Height() )
679 		{
680 			maWinPos.Y() = maViewSize.Height() - aWinSize.Height();
681 			bChanged = sal_True;
682 		}
683 		if ( aWinSize.Width() > maViewSize.Width() || maWinPos.X() < 0 )
684 		{
685 			maWinPos.X() = maViewSize.Width()  / 2 - aWinSize.Width()  / 2;
686 			bChanged = sal_True;
687 		}
688 		if ( aWinSize.Height() > maViewSize.Height() || maWinPos.Y() < 0 )
689 		{
690 			maWinPos.Y() = maViewSize.Height() / 2 - aWinSize.Height() / 2;
691 			bChanged = sal_True;
692 		}
693     }
694 
695     UpdateMapMode ();
696 
697     if (bChanged && bInvalidate)
698         Invalidate();
699 }
700 
701 
702 
703 
UpdateMapMode(void)704 void Window::UpdateMapMode (void)
705 {
706 	Size aWinSize = PixelToLogic(GetOutputSizePixel());
707     maWinPos -= maViewOrigin;
708     Size aPix(maWinPos.X(), maWinPos.Y());
709     aPix = LogicToPixel(aPix);
710     // Groesse muss vielfaches von BRUSH_SIZE sein, damit Muster
711     // richtig dargestellt werden
712     // #i2237#
713     // removed old stuff here which still forced zoom to be
714     // %BRUSH_SIZE which is outdated now
715 
716     if (mpViewShell && mpViewShell->ISA(DrawViewShell))
717     {
718         Size aViewSizePixel = LogicToPixel(maViewSize);
719         Size aWinSizePixel = LogicToPixel(aWinSize);
720 
721         // Seite soll nicht am Fensterrand "kleben"
722         if (aPix.Width() == 0)
723         {
724             // #i2237#
725             // Since BRUSH_SIZE alignment is outdated now, i use the
726             // former constant here directly
727             aPix.Width() -= 8;
728         }
729         if (aPix.Height() == 0)
730         {
731             // #i2237#
732             // Since BRUSH_SIZE alignment is outdated now, i use the
733             // former constant here directly
734             aPix.Height() -= 8;
735         }
736     }
737 
738     aPix = PixelToLogic(aPix);
739     maWinPos.X() = aPix.Width();
740     maWinPos.Y() = aPix.Height();
741 	Point aNewOrigin (-maWinPos.X(), -maWinPos.Y());
742     maWinPos += maViewOrigin;
743 
744 	MapMode aMap(GetMapMode());
745     aMap.SetOrigin(aNewOrigin);
746     SetMapMode(aMap);
747 }
748 
749 
750 
751 
752 /*************************************************************************
753 |*
754 |* X-Position des sichtbaren Bereichs als Bruchteil (< 1)
755 |* der gesamten Arbeitsbereichbreite zuruegeben
756 |*
757 \************************************************************************/
758 
GetVisibleX()759 double Window::GetVisibleX()
760 {
761 	return ((double) maWinPos.X() / maViewSize.Width());
762 }
763 
764 /*************************************************************************
765 |*
766 |* Y-Position des sichtbaren Bereichs als Bruchteil (< 1)
767 |* der gesamten Arbeitsbereichhoehe zuruegeben
768 |*
769 \************************************************************************/
770 
GetVisibleY()771 double Window::GetVisibleY()
772 {
773 	return ((double) maWinPos.Y() / maViewSize.Height());
774 }
775 
776 /*************************************************************************
777 |*
778 |* X- und Y-Position des sichtbaren Bereichs als Bruchteile (< 1)
779 |* der gesamten Arbeitsbereichgroesse setzen
780 |* negative Werte werden ignoriert
781 |*
782 \************************************************************************/
783 
SetVisibleXY(double fX,double fY)784 void Window::SetVisibleXY(double fX, double fY)
785 {
786 	long nOldX = maWinPos.X();
787 	long nOldY = maWinPos.Y();
788 
789 	if ( fX >= 0 )
790 		maWinPos.X() = (long) (fX * maViewSize.Width());
791 	if ( fY >= 0 )
792 		maWinPos.Y() = (long) (fY * maViewSize.Height());
793 	UpdateMapOrigin(sal_False);
794     //	Size sz(nOldX - aWinPos.X(), nOldY - aWinPos.Y());
795     //	sz = LogicToPixel(sz);
796 	Scroll(nOldX - maWinPos.X(), nOldY - maWinPos.Y(), SCROLL_CHILDREN);
797 	Update();
798 }
799 
800 /*************************************************************************
801 |*
802 |* Breite des sichtbaren Bereichs im Verhaeltnis zur
803 |* gesamten Arbeitsbereichbreite zuruegeben
804 |*
805 \************************************************************************/
806 
GetVisibleWidth()807 double Window::GetVisibleWidth()
808 {
809 	Size aWinSize = PixelToLogic(GetOutputSizePixel());
810 	if ( aWinSize.Width() > maViewSize.Width() )
811 		aWinSize.Width() = maViewSize.Width();
812 	return ((double) aWinSize.Width() / maViewSize.Width());
813 }
814 
815 /*************************************************************************
816 |*
817 |* Hoehe des sichtbaren Bereichs im Verhaeltnis zur
818 |* gesamten Arbeitsbereichhoehe zuruegeben
819 |*
820 \************************************************************************/
821 
GetVisibleHeight()822 double Window::GetVisibleHeight()
823 {
824 	Size aWinSize = PixelToLogic(GetOutputSizePixel());
825 	if ( aWinSize.Height() > maViewSize.Height() )
826 		aWinSize.Height() = maViewSize.Height();
827 	return ((double) aWinSize.Height() / maViewSize.Height());
828 }
829 
830 /*************************************************************************
831 |*
832 |* Breite einer Scrollspalte im Verhaeltnis zur gesamten
833 |* Arbeitsbereichbreite zuruegeben
834 |*
835 \************************************************************************/
836 
GetScrlLineWidth()837 double Window::GetScrlLineWidth()
838 {
839 	return (GetVisibleWidth() * SCROLL_LINE_FACT);
840 }
841 
842 /*************************************************************************
843 |*
844 |* Breite einer Scrollspalte im Verhaeltnis zur gesamten
845 |* Arbeitsbereichhoehe zuruegeben
846 |*
847 \************************************************************************/
848 
GetScrlLineHeight()849 double Window::GetScrlLineHeight()
850 {
851 	return (GetVisibleHeight() * SCROLL_LINE_FACT);
852 }
853 
854 /*************************************************************************
855 |*
856 |* Breite einer Scrollpage im Verhaeltnis zur gesamten
857 |* Arbeitsbereichbreite zuruegeben
858 |*
859 \************************************************************************/
860 
GetScrlPageWidth()861 double Window::GetScrlPageWidth()
862 {
863 	return (GetVisibleWidth() * SCROLL_PAGE_FACT);
864 }
865 
866 /*************************************************************************
867 |*
868 |* Breite einer Scrollpage im Verhaeltnis zur gesamten
869 |* Arbeitsbereichhoehe zuruegeben
870 |*
871 \************************************************************************/
872 
GetScrlPageHeight()873 double Window::GetScrlPageHeight()
874 {
875 	return (GetVisibleHeight() * SCROLL_PAGE_FACT);
876 }
877 
878 /*************************************************************************
879 |*
880 |* Fenster deaktivieren
881 |*
882 \************************************************************************/
883 
LoseFocus()884 void Window::LoseFocus()
885 {
886 	mnTicks = 0;
887     ::Window::LoseFocus ();
888 }
889 
890 /*************************************************************************
891 |*
892 |* Fenster aktivieren
893 |*
894 \************************************************************************/
895 
GrabFocus()896 void Window::GrabFocus()
897 {
898 	mnTicks		 = 0;
899     ::Window::GrabFocus ();
900 }
901 
902 
903 /*************************************************************************
904 |*
905 |* DataChanged
906 |*
907 \************************************************************************/
908 
DataChanged(const DataChangedEvent & rDCEvt)909 void Window::DataChanged( const DataChangedEvent& rDCEvt )
910 {
911 	::Window::DataChanged( rDCEvt );
912 
913 	// PRINTER bei allen Dokumenten weglassen, die keinen Printer benutzen.
914 	// FONTS und FONTSUBSTITUTION weglassen, wenn keine Textausgaben
915 	// vorhanden sind, bzw. wenn das Dokument keinen Text zulaesst.
916 
917 	if ( (rDCEvt.GetType() == DATACHANGED_PRINTER) ||
918 		 (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
919 		 (rDCEvt.GetType() == DATACHANGED_FONTS) ||
920 		 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
921 		 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
922 		  (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
923 	{
924 		if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
925 			 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
926 		{
927             // When the screen zoom factor has changed then reset the zoom
928             // factor of the frame to allways display the whole page.
929             const AllSettings* pOldSettings = rDCEvt.GetOldSettings ();
930             const AllSettings& rNewSettings = GetSettings ();
931             if (pOldSettings)
932                 if (pOldSettings->GetStyleSettings().GetScreenZoom()
933                     != rNewSettings.GetStyleSettings().GetScreenZoom())
934                     mpViewShell->GetViewFrame()->GetDispatcher()->
935                         Execute(SID_SIZE_PAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
936 
937 			// ScrollBars neu anordnen bzw. Resize ausloesen, da sich
938 			// ScrollBar-Groesse geaendert haben kann. Dazu muss dann im
939 			// Resize-Handler aber auch die Groesse der ScrollBars aus
940 			// den Settings abgefragt werden.
941 			Resize();
942 
943 			// Daten neu Setzen, die aus den Systemeinstellungen bzw. aus
944 			// den Settings uebernommen werden. Evtl. weitere Daten neu
945 			// berechnen, da sich auch die Aufloesung hierdurch geaendert
946 			// haben kann.
947             if( mpViewShell )
948             {
949 				const StyleSettings&    rStyleSettings = GetSettings().GetStyleSettings();
950 				SvtAccessibilityOptions aAccOptions;
951 		        sal_uLong                   nOutputMode;
952 			    sal_uInt16                  nPreviewSlot;
953 
954 				if( rStyleSettings.GetHighContrastMode() )
955 					nOutputMode = ViewShell::OUTPUT_DRAWMODE_CONTRAST;
956 				else
957 					nOutputMode = ViewShell::OUTPUT_DRAWMODE_COLOR;
958 
959 				if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
960 					nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST;
961 				else
962 					nPreviewSlot = SID_PREVIEW_QUALITY_COLOR;
963 
964                 if( mpViewShell->ISA( DrawViewShell ) )
965                 {
966 			        SetDrawMode( nOutputMode );
967                     mpViewShell->GetFrameView()->SetDrawMode( nOutputMode );
968 // #110094#-7
969 //			        mpViewShell->GetView()->ReleaseMasterPagePaintCache();
970 			        Invalidate();
971                 }
972 
973                 // #103100# Overwrite window color for OutlineView
974                 if( mpViewShell->ISA(OutlineViewShell ) )
975                 {
976                     svtools::ColorConfig aColorConfig;
977                     const Color aDocColor( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor );
978 					SetBackground( Wallpaper( aDocColor ) );
979                 }
980 
981                 SfxRequest aReq( nPreviewSlot, 0, mpViewShell->GetDocSh()->GetDoc()->GetItemPool() );
982                 mpViewShell->ExecReq( aReq );
983 				mpViewShell->Invalidate();
984                 mpViewShell->ArrangeGUIElements();
985 
986 				// #101928# re-create handles to show new outfit
987 				if(mpViewShell->ISA(DrawViewShell))
988 				{
989 					mpViewShell->GetView()->AdjustMarkHdl();
990 				}
991             }
992         }
993 
994 		if ( (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
995 			 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
996 			  (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
997 		{
998 			// Virtuelle Device die auch von der Aufloesung oder von
999 			// Systemeinstellungen abhaengen, sollten geupdatet werden.
1000 			// Ansonsten sollte zumindest bei DATACHANGED_DISPLAY
1001 			// die virtuellen Devices geupdatet werden, da es einige
1002 			// Systeme erlauben die Aufloesung und Farbtiefe waehrend
1003 			// der Laufzeit zu aendern oder eben bei Palettenaenderungen
1004 			// die virtuellen Device geupdatet werden muessen, da bei
1005 			// Ausgaben ein anderes Farbmatching stattfinden kann.
1006 		}
1007 
1008 		if ( rDCEvt.GetType() == DATACHANGED_FONTS )
1009 		{
1010 			// Wenn das Dokument Font-AuswahlBoxen anbietet, muessen
1011 			// diese geupdatet werden. Wie dies genau aussehen muss,
1012 			// weiss ich leider auch nicht. Aber evtl. kann man das
1013 			// ja global handeln. Dies muessten wir evtl. mal
1014 			// mit PB absprechen, aber der ist derzeit leider Krank.
1015 			// Also bevor dies hier gehandelt wird, vorher mit
1016 			// PB und mir absprechen.
1017 		}
1018 
1019 		if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1020 			 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) )
1021 		{
1022 			// Formatierung neu durchfuehren, da Fonts die im Dokument
1023 			// vorkommen, nicht mehr vorhanden sein muessen oder
1024 			// jetzt vorhanden sind oder durch andere ersetzt wurden
1025 			// sind.
1026 			if( mpViewShell )
1027 			{
1028 				DrawDocShell* pDocSh = mpViewShell->GetDocSh();
1029 				if( pDocSh )
1030 					pDocSh->SetPrinter( pDocSh->GetPrinter( sal_True ) );
1031 			}
1032 		}
1033 
1034 		if ( rDCEvt.GetType() == DATACHANGED_PRINTER )
1035 		{
1036 			// Wie hier die Behandlung aussehen soll, weiss ich leider
1037 			// selbst noch nicht. Evtl. mal einen Printer loeschen und
1038 			// schauen was gemacht werden muss. Evtl. muesste ich in
1039 			// VCL dafuer noch etwas einbauen, wenn der benutze Printer
1040 			// geloescht wird. Ansonsten wuerde ich hier evtl. die
1041 			// Formatierung neu berechnen, wenn der aktuelle Drucker
1042 			// zerstoert wurde.
1043 			if( mpViewShell )
1044 			{
1045 				DrawDocShell* pDocSh = mpViewShell->GetDocSh();
1046 				if( pDocSh )
1047 					pDocSh->SetPrinter( pDocSh->GetPrinter( sal_True ) );
1048 			}
1049 		}
1050 
1051 		// Alles neu ausgeben
1052 		Invalidate();
1053 	}
1054 }
1055 
1056 
1057 
1058 
1059 /*************************************************************************
1060 |*
1061 |* DropTargetHelper::AcceptDrop
1062 |*
1063 \************************************************************************/
1064 
AcceptDrop(const AcceptDropEvent & rEvt)1065 sal_Int8 Window::AcceptDrop( const AcceptDropEvent& rEvt )
1066 {
1067 	sal_Int8 nRet = DND_ACTION_NONE;
1068 
1069 	if( mpViewShell && !mpViewShell->GetDocSh()->IsReadOnly() )
1070 	{
1071 		if( mpViewShell )
1072 			nRet = mpViewShell->AcceptDrop( rEvt, *this, this, SDRPAGE_NOTFOUND, SDRLAYER_NOTFOUND );
1073 
1074 		if (mbUseDropScroll && ! mpViewShell->ISA(OutlineViewShell))
1075 			DropScroll( rEvt.maPosPixel );
1076 	}
1077 
1078 	return nRet;
1079 }
1080 
1081 /*************************************************************************
1082 |*
1083 |* DropTargetHelper::ExecuteDrop
1084 |*
1085 \************************************************************************/
1086 
ExecuteDrop(const ExecuteDropEvent & rEvt)1087 sal_Int8 Window::ExecuteDrop( const ExecuteDropEvent& rEvt )
1088 {
1089 	sal_Int8 nRet = DND_ACTION_NONE;
1090 
1091 	if( mpViewShell )
1092 	{
1093 		nRet = mpViewShell->ExecuteDrop( rEvt, *this, this, SDRPAGE_NOTFOUND, SDRLAYER_NOTFOUND );
1094 	}
1095 
1096 	return nRet;
1097 }
1098 
1099 
1100 
1101 
SetUseDropScroll(bool bUseDropScroll)1102 void Window::SetUseDropScroll (bool bUseDropScroll)
1103 {
1104     mbUseDropScroll = bUseDropScroll;
1105 }
1106 
1107 
1108 
1109 
1110 /*************************************************************************
1111 |*
1112 |* Scrolling bei AcceptDrop-Events
1113 |*
1114 \************************************************************************/
1115 
DropScroll(const Point & rMousePos)1116 void Window::DropScroll(const Point& rMousePos)
1117 {
1118 	short nDx = 0;
1119 	short nDy = 0;
1120 
1121 	Size aSize = GetOutputSizePixel();
1122 
1123 	if (aSize.Width() > SCROLL_SENSITIVE * 3)
1124 	{
1125 		if ( rMousePos.X() < SCROLL_SENSITIVE )
1126 		{
1127 			nDx = -1;
1128 		}
1129 
1130 		if ( rMousePos.X() >= aSize.Width() - SCROLL_SENSITIVE )
1131 		{
1132 			nDx = 1;
1133 		}
1134 	}
1135 
1136 	if (aSize.Height() > SCROLL_SENSITIVE * 3)
1137 	{
1138 		if ( rMousePos.Y() < SCROLL_SENSITIVE )
1139 		{
1140 			nDy = -1;
1141 		}
1142 
1143 		if ( rMousePos.Y() >= aSize.Height() - SCROLL_SENSITIVE )
1144 		{
1145 			nDy = 1;
1146 		}
1147 	}
1148 
1149 	if ( (nDx || nDy) && (rMousePos.X()!=0 || rMousePos.Y()!=0 ) )
1150 	{
1151         if (mnTicks > 20)
1152             mpViewShell->ScrollLines(nDx, nDy);
1153 		else
1154             mnTicks ++;
1155 	}
1156 }
1157 
1158 
1159 
1160 
1161 ::com::sun::star::uno::Reference<
1162     ::com::sun::star::accessibility::XAccessible>
CreateAccessible(void)1163     Window::CreateAccessible (void)
1164 {
1165 	// If current viewshell is PresentationViewShell, just return empty because the correct ShowWin will be created later.
1166 	if (mpViewShell && mpViewShell->ISA(PresentationViewShell))
1167 	{
1168 		return ::Window::CreateAccessible ();
1169 	}
1170 	::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc = GetAccessible(sal_False);
1171 	if (xAcc.get())
1172 	{
1173 		return xAcc;
1174 	}
1175     if (mpViewShell != NULL)
1176 	{
1177 		xAcc = mpViewShell->CreateAccessibleDocumentView (this);
1178 		SetAccessible(xAcc);
1179 		return xAcc;
1180 	}
1181     else
1182     {
1183         OSL_TRACE ("::sd::Window::CreateAccessible: no view shell");
1184         return ::Window::CreateAccessible ();
1185     }
1186 }
1187 
1188 // MT: Removed Windows::SwitchView() introduced with IA2 CWS.
1189 // There are other notifications for this when the active view has chnaged, so please update the code to use that event mechanism
SwitchView()1190 void Window::SwitchView()
1191 {
1192 	if (!Application::IsAccessibilityEnabled())
1193 	{
1194 		return ;
1195 	}
1196 	if (mpViewShell)
1197 	{
1198 		mpViewShell->SwitchViewFireFocus(GetAccessible(sal_False));
1199 	}
1200 }
1201 
GetSurroundingText() const1202 XubString Window::GetSurroundingText() const
1203 {
1204     if ( mpViewShell->GetShellType() == ViewShell::ST_OUTLINE )
1205     {
1206     	return XubString();
1207     }
1208     else if ( mpViewShell->GetView()->IsTextEdit() )
1209     {
1210 	    OutlinerView *pOLV = mpViewShell->GetView()->GetTextEditOutlinerView();
1211 	    return pOLV->GetEditView().GetSurroundingText();
1212     }
1213     else
1214     {
1215     	return XubString();
1216     }
1217 }
1218 
GetSurroundingTextSelection() const1219 Selection Window::GetSurroundingTextSelection() const
1220 {
1221     if ( mpViewShell->GetShellType() == ViewShell::ST_OUTLINE )
1222     {
1223 	    return Selection( 0, 0 );
1224     }
1225     else if ( mpViewShell->GetView()->IsTextEdit() )
1226     {
1227 	    OutlinerView *pOLV = mpViewShell->GetView()->GetTextEditOutlinerView();
1228 	    return pOLV->GetEditView().GetSurroundingTextSelection();
1229     }
1230     else
1231     {
1232         return Selection( 0, 0 );
1233     }
1234 }
1235 
1236 } // end of namespace sd
1237