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