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