sc/source/ui/formdlg/privsplt.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: privsplt.cxx,v $
  10  * $Revision: 1.4 $
  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_sc.hxx"
  33
  34
  35
  36 #include "privsplt.hxx"
  37
  38 /*************************************************************************
  39 #*      Member:         ScPrivatSplit                                                           Datum:13.10.97
  40 #*------------------------------------------------------------------------
  41 #*
  42 #*  Klasse:             MD_Test
  43 #*
  44 #*  Funktion:   Konstruktor der Klasse ScPrivatSplit
  45 #*
  46 #*  Input:              ---
  47 #*
  48 #*      Output:         ---
  49 #*
  50 #************************************************************************/
  51
  52 ScPrivatSplit::ScPrivatSplit( Window* pParent, const ResId& rResId,
  53                                                          SC_SPLIT_DIRECTION eSplit):
  54                                                 Control( pParent, rResId )
  55 {
  56         Point aPos=GetPosPixel();
  57         nOldX=(short)aPos.X();
  58         nOldY=(short)aPos.Y();
  59         nNewX=(short)aPos.X();
  60         nNewY=(short)aPos.Y();
  61         eScSplit=eSplit;
  62         aXMovingRange.Min()=nNewX;
  63         aXMovingRange.Max()=nNewX;
  64         aYMovingRange.Min()=nNewY;
  65         aYMovingRange.Max()=nNewY;
  66
  67         aWinPointer=GetPointer();
  68
  69         aMovingFlag=FALSE;
  70         if(eScSplit==SC_SPLIT_HORZ)
  71         {
  72                 aWinPointer=Pointer(POINTER_HSPLIT);
  73         }
  74         else
  75         {
  76                 aWinPointer=Pointer(POINTER_VSPLIT);
  77         }
  78         SetPointer(aWinPointer);
  79 }
  80
  81
  82 /*************************************************************************
  83 #*      Member:         MouseButtonDown                                                 Datum:13.10.97
  84 #*------------------------------------------------------------------------
  85 #*
  86 #*  Klasse:             ScPrivatSplit
  87 #*
  88 #*  Funktion:   Reagiert auf einen einzelnen Mouse-Event. Nach Aufruf
  89 #*                              werden alle Mauseingaben an dieses Control weitergeleitet.
  90 #*
  91 #*  Input:              ---
  92 #*
  93 #*      Output:         ---
  94 #*
  95 #************************************************************************/
  96
  97 void ScPrivatSplit::MouseButtonDown( const MouseEvent& rMEvt )
  98 {
  99         Point aPos=LogicToPixel(rMEvt.GetPosPixel());
 100
 101         nOldX=(short)aPos.X();
 102         nOldY=(short)aPos.Y();
 103
 104         CaptureMouse();
 105 }
 106
 107 /*************************************************************************
 108 #*      Member:         MouseButtonUp                                                   Datum:13.10.97
 109 #*------------------------------------------------------------------------
 110 #*
 111 #*  Klasse:             ScPrivatSplit
 112 #*
 113 #*  Funktion:   Ende einer Benutzeraktion mit der Maus. Es werden
 114 #*                              die aktuelle Maus- Koordinaten ermittelt und fuer
 115 #*                              die Verschiebung des Fensters verwendet.
 116 #*
 117 #*  Input:              ---
 118 #*
 119 #*      Output:         ---
 120 #*
 121 #************************************************************************/
 122
 123 void ScPrivatSplit::MouseButtonUp( const MouseEvent& rMEvt )
 124 {
 125         ReleaseMouse();
 126
 127         Point aPos=LogicToPixel(rMEvt.GetPosPixel());
 128         Point a2Pos=GetPosPixel();
 129         Point a3Pos=a2Pos;
 130
 131         if(eScSplit==SC_SPLIT_HORZ)
 132         {
 133                 nNewX=(short)aPos.X();
 134                 nDeltaX=nNewX-nOldX;
 135                 a2Pos.X()+=nDeltaX;
 136                 if(a2Pos.X()<aXMovingRange.Min())
 137                 {
 138                         nDeltaX=(short)(aXMovingRange.Min()-a3Pos.X());
 139                         a2Pos.X()=aXMovingRange.Min();
 140                 }
 141                 else if(a2Pos.X()>aXMovingRange.Max())
 142                 {
 143                         nDeltaX=(short)(aXMovingRange.Max()-a3Pos.X());
 144                         a2Pos.X()=aXMovingRange.Max();
 145                 }
 146         }
 147         else
 148         {
 149                 nNewY=(short)aPos.Y();
 150                 nDeltaY=nNewY-nOldY;
 151                 a2Pos.Y()+=nDeltaY;
 152                 if(a2Pos.Y()<aYMovingRange.Min())
 153                 {
 154                         nDeltaY=(short)(aYMovingRange.Min()-a3Pos.Y());
 155                         a2Pos.Y()=aYMovingRange.Min();
 156                 }
 157                 else if(a2Pos.Y()>aYMovingRange.Max())
 158                 {
 159                         nDeltaY=(short)(aYMovingRange.Max()-a3Pos.Y());
 160                         a2Pos.Y()=aYMovingRange.Max();
 161                 }
 162         }
 163         SetPosPixel(a2Pos);
 164         Invalidate();
 165         Update();
 166         CtrModified();
 167 }
 168
 169 /*************************************************************************
 170 #*      Member:         MouseMove                                                                       Datum:13.10.97
 171 #*------------------------------------------------------------------------
 172 #*
 173 #*  Klasse:             ScPrivatSplit
 174 #*
 175 #*  Funktion:   Reagiert kontinuierlich auf Mausbewegungen. Es werden
 176 #*                              die aktuelle Maus- Koordinaten ermittelt und fuer
 177 #*                              die Verschiebung des Fensters verwendet.
 178 #*
 179 #*  Input:              ---
 180 #*
 181 #*      Output:         ---
 182 #*
 183 #************************************************************************/
 184
 185 void ScPrivatSplit::MouseMove( const MouseEvent& rMEvt )
 186 {
 187         Point aPos=LogicToPixel(rMEvt.GetPosPixel());
 188         Point a2Pos=GetPosPixel();
 189         Point a3Pos=a2Pos;
 190         if(rMEvt.IsLeft())
 191         {
 192                 if(eScSplit==SC_SPLIT_HORZ)
 193                 {
 194                         nNewX=(short)aPos.X();
 195                         nDeltaX=nNewX-nOldX;
 196                         a2Pos.X()+=nDeltaX;
 197
 198                         if(a2Pos.X()<aXMovingRange.Min())
 199                         {
 200                                 nDeltaX=(short)(aXMovingRange.Min()-a3Pos.X());
 201                                 a2Pos.X()=aXMovingRange.Min();
 202                         }
 203                         else if(a2Pos.X()>aXMovingRange.Max())
 204                         {
 205                                 nDeltaX=(short)(aXMovingRange.Max()-a3Pos.X());
 206                                 a2Pos.X()=aXMovingRange.Max();
 207                         }
 208                 }
 209                 else
 210                 {
 211                         nNewY=(short)aPos.Y();
 212                         nDeltaY=nNewY-nOldY;
 213                         a2Pos.Y()+=nDeltaY;
 214                         if(a2Pos.Y()<aYMovingRange.Min())
 215                         {
 216                                 nDeltaY=(short)(aYMovingRange.Min()-a3Pos.Y());
 217                                 a2Pos.Y()=aYMovingRange.Min();
 218                         }
 219                         else if(a2Pos.Y()>aYMovingRange.Max())
 220                         {
 221                                 nDeltaY=(short)(aYMovingRange.Max()-a3Pos.Y());
 222                                 a2Pos.Y()=aYMovingRange.Max();
 223                         }
 224                 }
 225
 226                 SetPosPixel(a2Pos);
 227
 228                 CtrModified();
 229                 Invalidate();
 230                 Update();
 231         }
 232 }
 233
 234 /*************************************************************************
 235 #*      Member:         SetXRange                                                                       Datum:14.10.97
 236 #*------------------------------------------------------------------------
 237 #*
 238 #*  Klasse:             ScPrivatSplit
 239 #*
 240 #*  Funktion:   Setzt den Range fuer die X- Verschiebung
 241 #*
 242 #*  Input:              neuer Bereich
 243 #*
 244 #*      Output:         ---
 245 #*
 246 #************************************************************************/
 247 void ScPrivatSplit::SetXRange(Range cRgeX)
 248 {
 249         aXMovingRange=cRgeX;
 250 }
 251
 252 /*************************************************************************
 253 #*      Member:         SetYRange                                                                       Datum:14.10.97
 254 #*------------------------------------------------------------------------
 255 #*
 256 #*  Klasse:             ScPrivatSplit
 257 #*
 258 #*  Funktion:   Setzt den Range fuer die Y- Verschiebung
 259 #*
 260 #*  Input:              neuer Bereich
 261 #*
 262 #*      Output:         ---
 263 #*
 264 #************************************************************************/
 265 void ScPrivatSplit::SetYRange(Range cRgeY)
 266 {
 267         aYMovingRange=cRgeY;
 268 }
 269
 270
 271
 272 /*************************************************************************
 273 #*      Member:         GetDeltaY                                                                       Datum:13.10.97
 274 #*------------------------------------------------------------------------
 275 #*
 276 #*  Klasse:             ScPrivatSplit
 277 #*
 278 #*  Funktion:   Liefert die relative x-Verschiebung zurueck
 279 #*
 280 #*  Input:              ---
 281 #*
 282 #*      Output:         ---
 283 #*
 284 #************************************************************************/
 285 short ScPrivatSplit::GetDeltaX()
 286 {
 287         return nDeltaX;
 288 }
 289
 290 /*************************************************************************
 291 #*      Member:         GetDeltaY                                                                       Datum:13.10.97
 292 #*------------------------------------------------------------------------
 293 #*
 294 #*  Klasse:             ScPrivatSplit
 295 #*
 296 #*  Funktion:   Liefert die relative y-Verschiebung zurueck
 297 #*
 298 #*  Input:              ---
 299 #*
 300 #*      Output:         ---
 301 #*
 302 #************************************************************************/
 303 short ScPrivatSplit::GetDeltaY()
 304 {
 305         return nDeltaY;
 306 }
 307
 308 /*************************************************************************
 309 #*      Member:         CtrModified                                                                     Datum:13.10.97
 310 #*------------------------------------------------------------------------
 311 #*
 312 #*  Klasse:             ScPrivatSplit
 313 #*
 314 #*  Funktion:   Teilt einem installierten Handler mit, dass
 315 #*                              eine Veraenderung eingetreten ist.
 316 #*
 317 #*  Input:              ---
 318 #*
 319 #*      Output:         ---
 320 #*
 321 #************************************************************************/
 322 void ScPrivatSplit::CtrModified()
 323 {
 324         aCtrModifiedLink.Call( this );
 325 }
 326
 327 void ScPrivatSplit::MoveSplitTo(Point aPos)
 328 {
 329         Point a2Pos=GetPosPixel();
 330         nOldX=(short)a2Pos.X();
 331         nOldY=(short)a2Pos.Y();
 332         Point a3Pos=a2Pos;
 333
 334         if(eScSplit==SC_SPLIT_HORZ)
 335         {
 336                 nNewX=(short)aPos.X();
 337                 nDeltaX=nNewX-nOldX;
 338                 a2Pos.X()+=nDeltaX;
 339                 if(a2Pos.X()<aXMovingRange.Min())
 340                 {
 341                         nDeltaX=(short)(aXMovingRange.Min()-a3Pos.X());
 342                         a2Pos.X()=aXMovingRange.Min();
 343                 }
 344                 else if(a2Pos.X()>aXMovingRange.Max())
 345                 {
 346                         nDeltaX=(short)(aXMovingRange.Max()-a3Pos.X());
 347                         a2Pos.X()=aXMovingRange.Max();
 348                 }
 349         }
 350         else
 351         {
 352                 nNewY=(short)aPos.Y();
 353                 nDeltaY=nNewY-nOldY;
 354                 a2Pos.Y()+=nDeltaY;
 355                 if(a2Pos.Y()<aYMovingRange.Min())
 356                 {
 357                         nDeltaY=(short)(aYMovingRange.Min()-a3Pos.Y());
 358                         a2Pos.Y()=aYMovingRange.Min();
 359                 }
 360                 else if(a2Pos.Y()>aYMovingRange.Max())
 361                 {
 362                         nDeltaY=(short)(aYMovingRange.Max()-a3Pos.Y());
 363                         a2Pos.Y()=aYMovingRange.Max();
 364                 }
 365         }
 366         SetPosPixel(a2Pos);
 367         Invalidate();
 368         Update();
 369         CtrModified();
 370 }
 371
 372
 373 void ScPrivatSplit::ImplInitSettings( BOOL bFont, BOOL bForeground, BOOL bBackground )
 374 {
 375         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 376
 377         if ( bFont )
 378         {
 379                 Font aFont = rStyleSettings.GetAppFont();
 380                 if ( IsControlFont() )
 381                         aFont.Merge( GetControlFont() );
 382                 SetFont( aFont );
 383         }
 384
 385         if ( bFont || bForeground )
 386         {
 387                 Color aTextColor = rStyleSettings.GetButtonTextColor();
 388                 if ( IsControlForeground() )
 389                         aTextColor = GetControlForeground();
 390                 SetTextColor( aTextColor );
 391         }
 392
 393         if ( bBackground )
 394         {
 395                 SetBackground( rStyleSettings.GetFaceColor());
 396         }
 397         if ( IsBackground() )
 398         {
 399                 SetFillColor( GetBackground().GetColor() );
 400                 SetBackground();
 401         }
 402         Invalidate();
 403 }
 404
 405 // -----------------------------------------------------------------------
 406
 407 void ScPrivatSplit::StateChanged( StateChangedType nType )
 408 {
 409         if ( (nType == STATE_CHANGE_ZOOM) ||
 410                  (nType == STATE_CHANGE_CONTROLFONT) )
 411         {
 412                 ImplInitSettings( TRUE, FALSE, FALSE );
 413                 Invalidate();
 414         }
 415         if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 416         {
 417                 ImplInitSettings( FALSE, TRUE, FALSE );
 418                 Invalidate();
 419         }
 420         else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 421         {
 422                 ImplInitSettings( FALSE, FALSE, TRUE );
 423                 Invalidate();
 424         }
 425
 426         Control::StateChanged( nType );
 427 }
 428
 429 // -----------------------------------------------------------------------
 430
 431 void ScPrivatSplit::DataChanged( const DataChangedEvent& rDCEvt )
 432 {
 433         if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 434                  (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 435         {
 436                 ImplInitSettings( TRUE, TRUE, TRUE );
 437                 Invalidate();
 438         }
 439         else
 440                 Window::DataChanged( rDCEvt );
 441 }
 442
 443