vcl/source/control/ctrl.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: ctrl.cxx,v $
  10  * $Revision: 1.25 $
  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_vcl.hxx"
  33
  34 #ifndef _SV_RC_H
  35 #include <tools/rc.h>
  36 #endif
  37 #include <vcl/svdata.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/event.hxx>
  40 #include <vcl/ctrl.hxx>
  41 #include <vcl/decoview.hxx>
  42 #include <vcl/controllayout.hxx>
  43 #include <vcl/salnativewidgets.hxx>
  44
  45
  46
  47 using namespace vcl;
  48
  49 // =======================================================================
  50
  51 void Control::ImplInitControlData()
  52 {
  53     mbHasFocus          = FALSE;
  54     mpLayoutData        = NULL;
  55 }
  56
  57 // -----------------------------------------------------------------------
  58
  59 Control::Control( WindowType nType ) :
  60     Window( nType )
  61 {
  62     ImplInitControlData();
  63 }
  64
  65 // -----------------------------------------------------------------------
  66
  67 Control::Control( Window* pParent, WinBits nStyle ) :
  68     Window( WINDOW_CONTROL )
  69 {
  70     ImplInitControlData();
  71     Window::ImplInit( pParent, nStyle, NULL );
  72 }
  73
  74 // -----------------------------------------------------------------------
  75
  76 Control::Control( Window* pParent, const ResId& rResId ) :
  77     Window( WINDOW_CONTROL )
  78 {
  79     ImplInitControlData();
  80     rResId.SetRT( RSC_CONTROL );
  81     WinBits nStyle = ImplInitRes( rResId );
  82     ImplInit( pParent, nStyle, NULL );
  83     ImplLoadRes( rResId );
  84
  85     if ( !(nStyle & WB_HIDE) )
  86         Show();
  87 }
  88
  89 // -----------------------------------------------------------------------
  90
  91 Control::~Control()
  92 {
  93     delete mpLayoutData, mpLayoutData = NULL;
  94 }
  95
  96 // -----------------------------------------------------------------------
  97
  98 void Control::GetFocus()
  99 {
 100     Window::GetFocus();
 101 }
 102
 103 // -----------------------------------------------------------------------
 104
 105 void Control::LoseFocus()
 106 {
 107     Window::LoseFocus();
 108 }
 109
 110 // -----------------------------------------------------------------------
 111
 112 void Control::Resize()
 113 {
 114     delete mpLayoutData, mpLayoutData = NULL;
 115     Window::Resize();
 116 }
 117
 118 // -----------------------------------------------------------------------
 119
 120 void Control::FillLayoutData() const
 121 {
 122 }
 123
 124 // -----------------------------------------------------------------------
 125
 126 void Control::SetText( const String& rStr )
 127 {
 128     delete mpLayoutData;
 129     mpLayoutData = NULL;
 130     Window::SetText( rStr );
 131 }
 132
 133 // -----------------------------------------------------------------------
 134
 135 Rectangle ControlLayoutData::GetCharacterBounds( long nIndex ) const
 136 {
 137     return (nIndex >= 0 && nIndex < (long) m_aUnicodeBoundRects.size()) ? m_aUnicodeBoundRects[ nIndex ] : Rectangle();
 138 }
 139
 140
 141 // -----------------------------------------------------------------------
 142
 143 Rectangle Control::GetCharacterBounds( long nIndex ) const
 144 {
 145     if( ! mpLayoutData )
 146         FillLayoutData();
 147     return mpLayoutData ? mpLayoutData->GetCharacterBounds( nIndex ) : Rectangle();
 148 }
 149
 150 // -----------------------------------------------------------------------
 151
 152 long ControlLayoutData::GetIndexForPoint( const Point& rPoint ) const
 153 {
 154     long nIndex = -1;
 155     for( long i = m_aUnicodeBoundRects.size()-1; i >= 0; i-- )
 156     {
 157         if( m_aUnicodeBoundRects[ i ].IsInside( rPoint ) )
 158         {
 159             nIndex = i;
 160             break;
 161         }
 162     }
 163     return nIndex;
 164 }
 165
 166 // -----------------------------------------------------------------------
 167
 168 long Control::GetIndexForPoint( const Point& rPoint ) const
 169 {
 170     if( ! mpLayoutData )
 171         FillLayoutData();
 172     return mpLayoutData ? mpLayoutData->GetIndexForPoint( rPoint ) : -1;
 173 }
 174
 175 // -----------------------------------------------------------------------
 176
 177 long ControlLayoutData::GetLineCount() const
 178 {
 179     long nLines = m_aLineIndices.size();
 180     if( nLines == 0 && m_aDisplayText.Len() )
 181         nLines = 1;
 182     return nLines;
 183 }
 184
 185 // -----------------------------------------------------------------------
 186
 187 long Control::GetLineCount() const
 188 {
 189     if( ! mpLayoutData )
 190         FillLayoutData();
 191     return mpLayoutData ? mpLayoutData->GetLineCount() : 0;
 192 }
 193
 194 // -----------------------------------------------------------------------
 195
 196 Pair ControlLayoutData::GetLineStartEnd( long nLine ) const
 197 {
 198     Pair aPair( -1, -1 );
 199
 200     int nDisplayLines = m_aLineIndices.size();
 201     if( nLine >= 0 && nLine < nDisplayLines )
 202     {
 203         aPair.A() = m_aLineIndices[nLine];
 204         if( nLine+1 < nDisplayLines )
 205             aPair.B() = m_aLineIndices[nLine+1]-1;
 206         else
 207             aPair.B() = m_aDisplayText.Len()-1;
 208     }
 209     else if( nLine == 0 && nDisplayLines == 0 && m_aDisplayText.Len() )
 210     {
 211         // special case for single line controls so the implementations
 212         // in that case do not have to fill in the line indices
 213         aPair.A() = 0;
 214         aPair.B() = m_aDisplayText.Len()-1;
 215     }
 216     return aPair;
 217 }
 218
 219 // -----------------------------------------------------------------------
 220
 221 Pair Control::GetLineStartEnd( long nLine ) const
 222 {
 223     if( ! mpLayoutData )
 224         FillLayoutData();
 225     return mpLayoutData ? mpLayoutData->GetLineStartEnd( nLine ) : Pair( -1, -1 );
 226 }
 227
 228 // -----------------------------------------------------------------------
 229
 230 long ControlLayoutData::ToRelativeLineIndex( long nIndex ) const
 231 {
 232     // is the index sensible at all ?
 233     if( nIndex >= 0 && nIndex < m_aDisplayText.Len() )
 234     {
 235         int nDisplayLines = m_aLineIndices.size();
 236         // if only 1 line exists, then absolute and relative index are
 237         // identical -> do nothing
 238         if( nDisplayLines > 1 )
 239         {
 240             int nLine;
 241             for( nLine = nDisplayLines-1; nLine >= 0; nLine-- )
 242             {
 243                 if( m_aLineIndices[nLine] <= nIndex )
 244                 {
 245                     nIndex -= m_aLineIndices[nLine];
 246                     break;
 247                 }
 248             }
 249             if( nLine < 0 )
 250             {
 251                 DBG_ASSERT( nLine >= 0, "ToRelativeLineIndex failed" );
 252                 nIndex = -1;
 253             }
 254         }
 255     }
 256     else
 257         nIndex = -1;
 258
 259     return nIndex;
 260 }
 261
 262 // -----------------------------------------------------------------------
 263
 264 long Control::ToRelativeLineIndex( long nIndex ) const
 265 {
 266     if( ! mpLayoutData )
 267         FillLayoutData();
 268     return mpLayoutData ? mpLayoutData->ToRelativeLineIndex( nIndex ) : -1;
 269 }
 270
 271 // -----------------------------------------------------------------------
 272
 273 String Control::GetDisplayText() const
 274 {
 275     if( ! mpLayoutData )
 276         FillLayoutData();
 277     return mpLayoutData ? mpLayoutData->m_aDisplayText : GetText();
 278 }
 279
 280 // -----------------------------------------------------------------------
 281
 282 long Control::Notify( NotifyEvent& rNEvt )
 283 {
 284     if ( rNEvt.GetType() == EVENT_GETFOCUS )
 285     {
 286         if ( !mbHasFocus )
 287         {
 288             mbHasFocus = TRUE;
 289             if ( ImplCallEventListenersAndHandler( VCLEVENT_CONTROL_GETFOCUS, maGetFocusHdl, this ) )
 290                 // been destroyed within the handler
 291                 return TRUE;
 292         }
 293     }
 294     else
 295     {
 296         if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
 297         {
 298             Window* pFocusWin = Application::GetFocusWindow();
 299             if ( !pFocusWin || !ImplIsWindowOrChild( pFocusWin ) )
 300             {
 301                 mbHasFocus = FALSE;
 302                 if ( ImplCallEventListenersAndHandler( VCLEVENT_CONTROL_LOSEFOCUS, maLoseFocusHdl, this ) )
 303                     // been destroyed within the handler
 304                     return TRUE;
 305             }
 306         }
 307     }
 308
 309     return Window::Notify( rNEvt );
 310 }
 311
 312 // -----------------------------------------------------------------------
 313
 314 void Control::StateChanged( StateChangedType nStateChange )
 315 {
 316     if( nStateChange == STATE_CHANGE_INITSHOW   ||
 317         nStateChange == STATE_CHANGE_VISIBLE    ||
 318         nStateChange == STATE_CHANGE_FORMAT             ||
 319         nStateChange == STATE_CHANGE_ZOOM               ||
 320         nStateChange == STATE_CHANGE_BORDER             ||
 321         nStateChange == STATE_CHANGE_CONTROLFONT
 322         )
 323     {
 324         delete mpLayoutData;
 325         mpLayoutData = NULL;
 326     }
 327     Window::StateChanged( nStateChange );
 328 }
 329
 330 // -----------------------------------------------------------------------
 331
 332 void Control::AppendLayoutData( const Control& rSubControl ) const
 333 {
 334     if( ! rSubControl.mpLayoutData )
 335         rSubControl.FillLayoutData();
 336     if( ! rSubControl.mpLayoutData || ! rSubControl.mpLayoutData->m_aDisplayText.Len() )
 337         return;
 338
 339     long nCurrentIndex = mpLayoutData->m_aDisplayText.Len();
 340     mpLayoutData->m_aDisplayText.Append( rSubControl.mpLayoutData->m_aDisplayText );
 341     int nLines = rSubControl.mpLayoutData->m_aLineIndices.size();
 342     int n;
 343     mpLayoutData->m_aLineIndices.push_back( nCurrentIndex );
 344     for( n = 1; n < nLines; n++ )
 345         mpLayoutData->m_aLineIndices.push_back( rSubControl.mpLayoutData->m_aLineIndices[n] + nCurrentIndex );
 346     int nRectangles = rSubControl.mpLayoutData->m_aUnicodeBoundRects.size();
 347         Rectangle aRel = const_cast<Control&>(rSubControl).GetWindowExtentsRelative( const_cast<Control*>(this) );
 348     for( n = 0; n < nRectangles; n++ )
 349     {
 350         Rectangle aRect = rSubControl.mpLayoutData->m_aUnicodeBoundRects[n];
 351         aRect.Move( aRel.Left(), aRel.Top() );
 352         mpLayoutData->m_aUnicodeBoundRects.push_back( aRect );
 353     }
 354 }
 355
 356 // -----------------------------------------------------------------
 357
 358 BOOL Control::ImplCallEventListenersAndHandler(  ULONG nEvent, const Link& rHandler, void* pCaller )
 359 {
 360     ImplDelData aCheckDelete;
 361     ImplAddDel( &aCheckDelete );
 362
 363     ImplCallEventListeners( nEvent );
 364     if ( !aCheckDelete.IsDelete() )
 365     {
 366         rHandler.Call( pCaller );
 367
 368         if ( !aCheckDelete.IsDelete() )
 369         {
 370             ImplRemoveDel( &aCheckDelete );
 371             return FALSE;
 372         }
 373     }
 374     return TRUE;
 375 }
 376
 377 // -----------------------------------------------------------------
 378
 379 void Control::SetLayoutDataParent( const Control* pParent ) const
 380 {
 381     if( mpLayoutData )
 382         mpLayoutData->m_pParent = pParent;
 383 }
 384
 385 // -----------------------------------------------------------------
 386
 387 void Control::ImplClearLayoutData() const
 388 {
 389     delete mpLayoutData, mpLayoutData = NULL;
 390 }
 391
 392 // -----------------------------------------------------------------------
 393
 394 void Control::ImplDrawFrame( OutputDevice* pDev, Rectangle& rRect )
 395 {
 396     // use a deco view to draw the frame
 397     // However, since there happens a lot of magic there, we need to fake some (style) settings
 398     // on the device
 399     AllSettings aOriginalSettings( pDev->GetSettings() );
 400
 401     AllSettings aNewSettings( aOriginalSettings );
 402     StyleSettings aStyle( aNewSettings.GetStyleSettings() );
 403
 404     // The *only known* clients of the Draw methods of the various VCL-controls are form controls:
 405     // During print preview, and during printing, Draw is called. Thus, drawing always happens with a
 406     // mono (colored) border
 407     aStyle.SetOptions( aStyle.GetOptions() | STYLE_OPTION_MONO );
 408     aStyle.SetMonoColor( GetSettings().GetStyleSettings().GetMonoColor() );
 409
 410     aNewSettings.SetStyleSettings( aStyle );
 411     // #i67023# do not call data changed listeners for this fake
 412     // since they may understandably invalidate on settings changed
 413     pDev->OutputDevice::SetSettings( aNewSettings );
 414
 415     DecorationView aDecoView( pDev );
 416     rRect = aDecoView.DrawFrame( rRect, FRAME_DRAW_WINDOWBORDER );
 417
 418     pDev->OutputDevice::SetSettings( aOriginalSettings );
 419 }
 420
 421 // -----------------------------------------------------------------------
 422
 423 void Control::DataChanged( const DataChangedEvent& rDCEvt)
 424 {
 425     // we don't want to loose some style settings for controls created with the
 426     // toolkit
 427     if ( IsCreatedWithToolkit() &&
 428          (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 429          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 430     {
 431         AllSettings     aSettings = GetSettings();
 432         StyleSettings   aStyleSettings = aSettings.GetStyleSettings();
 433         ULONG           nOldOptions = rDCEvt.GetOldSettings()->GetStyleSettings().GetOptions();
 434         ULONG           nNewOptions = aStyleSettings.GetOptions();
 435
 436         if ( !(nNewOptions & STYLE_OPTION_MONO) && ( nOldOptions & STYLE_OPTION_MONO ) )
 437         {
 438             nNewOptions |= STYLE_OPTION_MONO;
 439             aStyleSettings.SetOptions( nNewOptions );
 440             aStyleSettings.SetMonoColor( rDCEvt.GetOldSettings()->GetStyleSettings().GetMonoColor() );
 441             aSettings.SetStyleSettings( aStyleSettings );
 442             SetSettings( aSettings );
 443         }
 444     }
 445 }
 446
 447 // -----------------------------------------------------------------
 448
 449 ControlLayoutData::~ControlLayoutData()
 450 {
 451     if( m_pParent )
 452         m_pParent->ImplClearLayoutData();
 453 }
 454
 455 // -----------------------------------------------------------------
 456
 457 Size Control::GetOptimalSize(WindowSizeType eType) const
 458 {
 459     switch (eType) {
 460     case WINDOWSIZE_MINIMUM:
 461         return Size( GetTextWidth( GetText() ) + 2 * 12,
 462                      GetTextHeight() + 2 * 6 );
 463     case WINDOWSIZE_PREFERRED:
 464         return GetOptimalSize( WINDOWSIZE_MINIMUM );
 465     case WINDOWSIZE_MAXIMUM:
 466     default:
 467         return Size( LONG_MAX, LONG_MAX );
 468     }
 469 }