vcl/headless/svpframe.cxx

   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 #include <string.h>
  21 #include "vcl/syswin.hxx"
  22 #include "headless/svpframe.hxx"
  23 #include "headless/svpinst.hxx"
  24 #include "headless/svpgdi.hxx"
  25
  26 #include <basebmp/bitmapdevice.hxx>
  27 #include <basebmp/scanlineformats.hxx>
  28 #include <basegfx/vector/b2ivector.hxx>
  29
  30 using namespace basebmp;
  31 using namespace basegfx;
  32
  33 SvpSalFrame* SvpSalFrame::s_pFocusFrame = NULL;
  34
  35 namespace {
  36     /// Decouple SalFrame lifetime from damagetracker lifetime
  37     struct DamageTracker : public basebmp::IBitmapDeviceDamageTracker
  38     {
  39         DamageTracker( SvpSalFrame& rFrame ) : m_rFrame( rFrame ) {}
  40         virtual ~DamageTracker() {}
  41         virtual void damaged( const basegfx::B2IBox& rDamageRect ) const
  42         {
  43             m_rFrame.damaged( rDamageRect );
  44         }
  45         SvpSalFrame& m_rFrame;
  46     };
  47 }
  48
  49 void SvpSalFrame::enableDamageTracker( bool bOn )
  50 {
  51     if( m_bDamageTracking == bOn )
  52         return;
  53     if( m_aFrame.get() )
  54     {
  55         if( m_bDamageTracking )
  56             m_aFrame->setDamageTracker( basebmp::IBitmapDeviceDamageTrackerSharedPtr() );
  57         else
  58             m_aFrame->setDamageTracker(
  59                 basebmp::IBitmapDeviceDamageTrackerSharedPtr( new DamageTracker( *this ) ) );
  60     }
  61     m_bDamageTracking = bOn;
  62 }
  63
  64 SvpSalFrame::SvpSalFrame( SvpSalInstance* pInstance,
  65                           SalFrame* pParent,
  66                           sal_uLong nSalFrameStyle,
  67                           bool      bTopDown,
  68                           basebmp::Format nScanlineFormat,
  69                           SystemParentData* ) :
  70     m_pInstance( pInstance ),
  71     m_pParent( static_cast<SvpSalFrame*>(pParent) ),
  72     m_nStyle( nSalFrameStyle ),
  73     m_bVisible( false ),
  74     m_bDamageTracking( false ),
  75     m_bTopDown( bTopDown ),
  76     m_nScanlineFormat( nScanlineFormat ),
  77     m_nMinWidth( 0 ),
  78     m_nMinHeight( 0 ),
  79     m_nMaxWidth( 0 ),
  80     m_nMaxHeight( 0 )
  81 {
  82     // SAL_DEBUG("SvpSalFrame::SvpSalFrame: " << this);
  83     // fast and easy cross-platform wiping of the data
  84     memset( (void *)&m_aSystemChildData, 0, sizeof( SystemEnvData ) );
  85     m_aSystemChildData.nSize        = sizeof( SystemEnvData );
  86 #ifdef IOS
  87     // Nothing
  88 #elif defined ANDROID
  89     // Nothing
  90 #else
  91     m_aSystemChildData.pSalFrame    = this;
  92     m_aSystemChildData.nDepth       = 24;
  93 #endif
  94
  95     if( m_pParent )
  96         m_pParent->m_aChildren.push_back( this );
  97
  98     if( m_pInstance )
  99         m_pInstance->registerFrame( this );
 100
 101     SetPosSize( 0, 0, 800, 600, SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
 102 }
 103
 104 SvpSalFrame::~SvpSalFrame()
 105 {
 106     if( m_pInstance )
 107         m_pInstance->deregisterFrame( this );
 108
 109     std::list<SvpSalFrame*> Children = m_aChildren;
 110     for( std::list<SvpSalFrame*>::iterator it = Children.begin();
 111          it != Children.end(); ++it )
 112          (*it)->SetParent( m_pParent );
 113     if( m_pParent )
 114         m_pParent->m_aChildren.remove( this );
 115
 116     if( s_pFocusFrame == this )
 117     {
 118         // SAL_DEBUG("SvpSalFrame::~SvpSalFrame: losing focus: " << this);
 119         s_pFocusFrame = NULL;
 120         // call directly here, else an event for a destroyed frame would be dispatched
 121         CallCallback( SALEVENT_LOSEFOCUS, NULL );
 122         // if the handler has not set a new focus frame
 123         // pass focus to another frame, preferably a document style window
 124         if( s_pFocusFrame == NULL )
 125         {
 126             const std::list< SalFrame* >& rFrames( m_pInstance->getFrames() );
 127             for( std::list< SalFrame* >::const_iterator it = rFrames.begin(); it != rFrames.end(); ++it )
 128             {
 129                 SvpSalFrame* pFrame = const_cast<SvpSalFrame*>(static_cast<const SvpSalFrame*>(*it));
 130                 if( pFrame->m_bVisible        &&
 131                     pFrame->m_pParent == NULL &&
 132                     (pFrame->m_nStyle & (SAL_FRAME_STYLE_MOVEABLE |
 133                                          SAL_FRAME_STYLE_SIZEABLE |
 134                                          SAL_FRAME_STYLE_CLOSEABLE) ) != 0
 135                     )
 136                 {
 137                     pFrame->GetFocus();
 138                     break;
 139                 }
 140             }
 141         }
 142     }
 143 }
 144
 145 void SvpSalFrame::GetFocus()
 146 {
 147     if( s_pFocusFrame == this )
 148         return;
 149
 150     if( (m_nStyle & (SAL_FRAME_STYLE_OWNERDRAWDECORATION | SAL_FRAME_STYLE_FLOAT)) == 0 )
 151     {
 152         if( s_pFocusFrame )
 153             s_pFocusFrame->LoseFocus();
 154         // SAL_DEBUG("SvpSalFrame::GetFocus(): " << this);
 155         s_pFocusFrame = this;
 156         m_pInstance->PostEvent( this, NULL, SALEVENT_GETFOCUS );
 157     }
 158 }
 159
 160 void SvpSalFrame::LoseFocus()
 161 {
 162     if( s_pFocusFrame == this )
 163     {
 164         // SAL_DEBUG("SvpSalFrame::LoseFocus: " << this);
 165         m_pInstance->PostEvent( this, NULL, SALEVENT_LOSEFOCUS );
 166         s_pFocusFrame = NULL;
 167     }
 168 }
 169
 170 SalGraphics* SvpSalFrame::GetGraphics()
 171 {
 172     SvpSalGraphics* pGraphics = new SvpSalGraphics();
 173     pGraphics->setDevice( m_aFrame );
 174     m_aGraphics.push_back( pGraphics );
 175     return pGraphics;
 176 }
 177
 178 void SvpSalFrame::ReleaseGraphics( SalGraphics* pGraphics )
 179 {
 180     SvpSalGraphics* pSvpGraphics = dynamic_cast<SvpSalGraphics*>(pGraphics);
 181     m_aGraphics.remove( pSvpGraphics );
 182     delete pSvpGraphics;
 183 }
 184
 185 sal_Bool SvpSalFrame::PostEvent( void* pData )
 186 {
 187     m_pInstance->PostEvent( this, pData, SALEVENT_USEREVENT );
 188     return sal_True;
 189 }
 190
 191 void SvpSalFrame::PostPaint(bool bImmediate) const
 192 {
 193     if( m_bVisible )
 194     {
 195         SalPaintEvent aPEvt(0, 0, maGeometry.nWidth, maGeometry.nHeight);
 196         aPEvt.mbImmediateUpdate = bImmediate;
 197         CallCallback( SALEVENT_PAINT, &aPEvt );
 198     }
 199 }
 200
 201 void SvpSalFrame::SetTitle( const OUString& )
 202 {
 203 }
 204
 205 void SvpSalFrame::SetIcon( sal_uInt16 )
 206 {
 207 }
 208
 209 void SvpSalFrame::SetMenu( SalMenu* )
 210 {
 211 }
 212
 213 void SvpSalFrame::DrawMenuBar()
 214 {
 215 }
 216
 217 void SvpSalFrame::SetExtendedFrameStyle( SalExtStyle )
 218 {
 219 }
 220
 221 void SvpSalFrame::Show( sal_Bool bVisible, sal_Bool bNoActivate )
 222 {
 223     if( bVisible && ! m_bVisible )
 224     {
 225         // SAL_DEBUG("SvpSalFrame::Show: showing: " << this);
 226         m_bVisible = true;
 227         m_pInstance->PostEvent( this, NULL, SALEVENT_RESIZE );
 228         if( ! bNoActivate )
 229             GetFocus();
 230     }
 231     else if( ! bVisible && m_bVisible )
 232     {
 233         // SAL_DEBUG("SvpSalFrame::Show: hiding: " << this);
 234         m_bVisible = false;
 235         m_pInstance->PostEvent( this, NULL, SALEVENT_RESIZE );
 236         LoseFocus();
 237     }
 238     else
 239     {
 240         // SAL_DEBUG("SvpSalFrame::Show: nothihg: " << this);
 241     }
 242 }
 243
 244 void SvpSalFrame::Enable( sal_Bool )
 245 {
 246 }
 247
 248 void SvpSalFrame::SetMinClientSize( long nWidth, long nHeight )
 249 {
 250     m_nMinWidth = nWidth;
 251     m_nMinHeight = nHeight;
 252 }
 253
 254 void SvpSalFrame::SetMaxClientSize( long nWidth, long nHeight )
 255 {
 256     m_nMaxWidth = nWidth;
 257     m_nMaxHeight = nHeight;
 258 }
 259
 260 void SvpSalFrame::SetPosSize( long nX, long nY, long nWidth, long nHeight, sal_uInt16 nFlags )
 261 {
 262     if( (nFlags & SAL_FRAME_POSSIZE_X) != 0 )
 263         maGeometry.nX = nX;
 264     if( (nFlags & SAL_FRAME_POSSIZE_Y) != 0 )
 265         maGeometry.nY = nY;
 266     if( (nFlags & SAL_FRAME_POSSIZE_WIDTH) != 0 )
 267     {
 268         maGeometry.nWidth = nWidth;
 269         if( m_nMaxWidth > 0 && maGeometry.nWidth > (unsigned int)m_nMaxWidth )
 270             maGeometry.nWidth = m_nMaxWidth;
 271         if( m_nMinWidth > 0 && maGeometry.nWidth < (unsigned int)m_nMinWidth )
 272             maGeometry.nWidth = m_nMinWidth;
 273     }
 274     if( (nFlags & SAL_FRAME_POSSIZE_HEIGHT) != 0 )
 275     {
 276         maGeometry.nHeight = nHeight;
 277         if( m_nMaxHeight > 0 && maGeometry.nHeight > (unsigned int)m_nMaxHeight )
 278             maGeometry.nHeight = m_nMaxHeight;
 279         if( m_nMinHeight > 0 && maGeometry.nHeight < (unsigned int)m_nMinHeight )
 280             maGeometry.nHeight = m_nMinHeight;
 281     }
 282     B2IVector aFrameSize( maGeometry.nWidth, maGeometry.nHeight );
 283     if( ! m_aFrame.get() || m_aFrame->getSize() != aFrameSize )
 284     {
 285         if( aFrameSize.getX() == 0 )
 286             aFrameSize.setX( 1 );
 287         if( aFrameSize.getY() == 0 )
 288             aFrameSize.setY( 1 );
 289         m_aFrame = createBitmapDevice( aFrameSize, m_bTopDown, m_nScanlineFormat );
 290         if (m_bDamageTracking)
 291             m_aFrame->setDamageTracker(
 292                 basebmp::IBitmapDeviceDamageTrackerSharedPtr( new DamageTracker( *this ) ) );
 293         // update device in existing graphics
 294         for( std::list< SvpSalGraphics* >::iterator it = m_aGraphics.begin();
 295              it != m_aGraphics.end(); ++it )
 296              (*it)->setDevice( m_aFrame );
 297     }
 298     if( m_bVisible )
 299         m_pInstance->PostEvent( this, NULL, SALEVENT_RESIZE );
 300 }
 301
 302 void SvpSalFrame::GetClientSize( long& rWidth, long& rHeight )
 303 {
 304     if( m_bVisible )
 305     {
 306         rWidth = maGeometry.nWidth;
 307         rHeight = maGeometry.nHeight;
 308     }
 309     else
 310         rWidth = rHeight = 0;
 311 }
 312
 313 void SvpSalFrame::GetWorkArea( Rectangle& rRect )
 314 {
 315     rRect = Rectangle( Point( 0, 0 ),
 316                        Size( VIRTUAL_DESKTOP_WIDTH, VIRTUAL_DESKTOP_HEIGHT ) );
 317 }
 318
 319 SalFrame* SvpSalFrame::GetParent() const
 320 {
 321     return m_pParent;
 322 }
 323
 324 #define _FRAMESTATE_MASK_GEOMETRY \
 325      (WINDOWSTATE_MASK_X     | WINDOWSTATE_MASK_Y |   \
 326       WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT)
 327
 328 void SvpSalFrame::SetWindowState( const SalFrameState *pState )
 329 {
 330     if (pState == NULL)
 331         return;
 332
 333     // Request for position or size change
 334     if (pState->mnMask & _FRAMESTATE_MASK_GEOMETRY)
 335     {
 336         long nX = maGeometry.nX;
 337         long nY = maGeometry.nY;
 338         long nWidth = maGeometry.nWidth;
 339         long nHeight = maGeometry.nHeight;
 340
 341         // change requested properties
 342         if (pState->mnMask & WINDOWSTATE_MASK_X)
 343             nX = pState->mnX;
 344         if (pState->mnMask & WINDOWSTATE_MASK_Y)
 345             nY = pState->mnY;
 346         if (pState->mnMask & WINDOWSTATE_MASK_WIDTH)
 347             nWidth = pState->mnWidth;
 348         if (pState->mnMask & WINDOWSTATE_MASK_HEIGHT)
 349             nHeight = pState->mnHeight;
 350
 351         SetPosSize( nX, nY, nWidth, nHeight,
 352                     SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y |
 353                     SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
 354     }
 355 }
 356
 357 sal_Bool SvpSalFrame::GetWindowState( SalFrameState* pState )
 358 {
 359     pState->mnState = WINDOWSTATE_STATE_NORMAL;
 360     pState->mnX      = maGeometry.nX;
 361     pState->mnY      = maGeometry.nY;
 362     pState->mnWidth  = maGeometry.nWidth;
 363     pState->mnHeight = maGeometry.nHeight;
 364     pState->mnMask   = _FRAMESTATE_MASK_GEOMETRY | WINDOWSTATE_MASK_STATE;
 365
 366     return sal_True;
 367 }
 368
 369 void SvpSalFrame::ShowFullScreen( sal_Bool, sal_Int32 )
 370 {
 371     SetPosSize( 0, 0, VIRTUAL_DESKTOP_WIDTH, VIRTUAL_DESKTOP_HEIGHT,
 372                 SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
 373 }
 374
 375 void SvpSalFrame::StartPresentation( sal_Bool )
 376 {
 377 }
 378
 379 void SvpSalFrame::SetAlwaysOnTop( sal_Bool )
 380 {
 381 }
 382
 383 void SvpSalFrame::ToTop( sal_uInt16 )
 384 {
 385     GetFocus();
 386 }
 387
 388 void SvpSalFrame::SetPointer( PointerStyle )
 389 {
 390 }
 391
 392 void SvpSalFrame::CaptureMouse( sal_Bool )
 393 {
 394 }
 395
 396 void SvpSalFrame::SetPointerPos( long, long )
 397 {
 398 }
 399
 400 void SvpSalFrame::Flush()
 401 {
 402 }
 403
 404 void SvpSalFrame::Sync()
 405 {
 406 }
 407
 408 void SvpSalFrame::SetInputContext( SalInputContext* )
 409 {
 410 }
 411
 412 void SvpSalFrame::EndExtTextInput( sal_uInt16 )
 413 {
 414 }
 415
 416 OUString SvpSalFrame::GetKeyName( sal_uInt16 )
 417 {
 418     return OUString();
 419 }
 420
 421 sal_Bool SvpSalFrame::MapUnicodeToKeyCode( sal_Unicode, LanguageType, KeyCode& )
 422 {
 423     return sal_False;
 424 }
 425
 426 LanguageType SvpSalFrame::GetInputLanguage()
 427 {
 428     return LANGUAGE_DONTKNOW;
 429 }
 430
 431 void SvpSalFrame::UpdateSettings( AllSettings& )
 432 {
 433 }
 434
 435 void SvpSalFrame::Beep()
 436 {
 437 }
 438
 439 const SystemEnvData* SvpSalFrame::GetSystemData() const
 440 {
 441     return &m_aSystemChildData;
 442 }
 443
 444 SalFrame::SalPointerState SvpSalFrame::GetPointerState()
 445 {
 446     SalPointerState aState;
 447     aState.mnState = 0;
 448     return aState;
 449 }
 450
 451 SalFrame::SalIndicatorState SvpSalFrame::GetIndicatorState()
 452 {
 453     SalIndicatorState aState;
 454     aState.mnState = 0;
 455     return aState;
 456 }
 457
 458 void SvpSalFrame::SimulateKeyPress( sal_uInt16 /*nKeyCode*/ )
 459 {
 460 }
 461
 462 void SvpSalFrame::SetParent( SalFrame* pNewParent )
 463 {
 464     if( m_pParent )
 465         m_pParent->m_aChildren.remove( this );
 466     m_pParent = static_cast<SvpSalFrame*>(pNewParent);
 467 }
 468
 469 bool SvpSalFrame::SetPluginParent( SystemParentData* )
 470 {
 471     return true;
 472 }
 473
 474 void SvpSalFrame::ResetClipRegion()
 475 {
 476 }
 477
 478 void SvpSalFrame::BeginSetClipRegion( sal_uLong )
 479 {
 480 }
 481
 482 void SvpSalFrame::UnionClipRegion( long, long, long, long )
 483 {
 484 }
 485
 486 void SvpSalFrame::EndSetClipRegion()
 487 {
 488 }
 489
 490 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */