sd/source/ui/view/sdwindow.cxx

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