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