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