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