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
  25 #include <headless/svpframe.hxx>
  26 #include <headless/svpinst.hxx>
  27 #include <headless/svpgdi.hxx>
  28
  29 #include <basegfx/vector/b2ivector.hxx>
  30
  31 #ifndef IOS
  32 #include <cairo.h>
  33 #endif
  34
  35 SvpSalFrame* SvpSalFrame::s_pFocusFrame = nullptr;
  36
  37 #ifdef IOS
  38 #define SvpSalGraphics AquaSalGraphics
  39 #endif
  40
  41 SvpSalFrame::SvpSalFrame( SvpSalInstance* pInstance,
  42                           SalFrame* pParent,
  43                           SalFrameStyleFlags nSalFrameStyle ) :
  44     m_pInstance( pInstance ),
  45     m_pParent( static_cast<SvpSalFrame*>(pParent) ),
  46     m_nStyle( nSalFrameStyle ),
  47     m_bVisible( false ),
  48 #ifndef IOS
  49     m_pSurface( nullptr ),
  50 #endif
  51     m_nMinWidth( 0 ),
  52     m_nMinHeight( 0 ),
  53     m_nMaxWidth( 0 ),
  54     m_nMaxHeight( 0 )
  55 {
  56     // SAL_DEBUG("SvpSalFrame::SvpSalFrame: " << this);
  57     // fast and easy cross-platform wiping of the data
  58     memset( static_cast<void *>(&m_aSystemChildData), 0, sizeof( SystemEnvData ) );
  59     m_aSystemChildData.nSize        = sizeof( SystemEnvData );
  60 #ifdef IOS
  61     // Nothing
  62 #elif defined ANDROID
  63     // Nothing
  64 #else
  65     m_aSystemChildData.pSalFrame    = this;
  66 #endif
  67
  68     if( m_pParent )
  69         m_pParent->m_aChildren.push_back( this );
  70
  71     if( m_pInstance )
  72         m_pInstance->registerFrame( this );
  73
  74     SetPosSize( 0, 0, 800, 600, SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
  75 }
  76
  77 SvpSalFrame::~SvpSalFrame()
  78 {
  79     if( m_pInstance )
  80         m_pInstance->deregisterFrame( this );
  81
  82     std::list<SvpSalFrame*> Children = m_aChildren;
  83     for( std::list<SvpSalFrame*>::iterator it = Children.begin();
  84          it != Children.end(); ++it )
  85          (*it)->SetParent( m_pParent );
  86     if( m_pParent )
  87         m_pParent->m_aChildren.remove( this );
  88
  89     if( s_pFocusFrame == this )
  90     {
  91         // SAL_DEBUG("SvpSalFrame::~SvpSalFrame: losing focus: " << this);
  92         s_pFocusFrame = nullptr;
  93         // call directly here, else an event for a destroyed frame would be dispatched
  94         CallCallback( SalEvent::LoseFocus, nullptr );
  95         // if the handler has not set a new focus frame
  96         // pass focus to another frame, preferably a document style window
  97         if( s_pFocusFrame == nullptr )
  98         {
  99             for (auto pSalFrame : m_pInstance->getFrames() )
 100             {
 101                 SvpSalFrame* pFrame = static_cast<SvpSalFrame*>( pSalFrame );
 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.erase(std::remove(m_aGraphics.begin(), m_aGraphics.end(), pSvpGraphics), m_aGraphics.end());
 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 > static_cast<unsigned int>(m_nMaxWidth) )
 244             maGeometry.nWidth = m_nMaxWidth;
 245         if( m_nMinWidth > 0 && maGeometry.nWidth < static_cast<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 > static_cast<unsigned int>(m_nMaxHeight) )
 252             maGeometry.nHeight = m_nMaxHeight;
 253         if( m_nMinHeight > 0 && maGeometry.nHeight < static_cast<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 (auto const& graphic : m_aGraphics)
 279         {
 280              graphic->setSurface(m_pSurface, aFrameSize);
 281         }
 282     }
 283     if( m_bVisible )
 284         m_pInstance->PostEvent( this, nullptr, SalEvent::Resize );
 285 #endif
 286 }
 287
 288 void SvpSalFrame::GetClientSize( long& rWidth, long& rHeight )
 289 {
 290     rWidth = maGeometry.nWidth;
 291     rHeight = maGeometry.nHeight;
 292 }
 293
 294 void SvpSalFrame::GetWorkArea( tools::Rectangle& rRect )
 295 {
 296     rRect = tools::Rectangle( Point( 0, 0 ),
 297                        Size( VIRTUAL_DESKTOP_WIDTH, VIRTUAL_DESKTOP_HEIGHT ) );
 298 }
 299
 300 SalFrame* SvpSalFrame::GetParent() const
 301 {
 302     return m_pParent;
 303 }
 304
 305 #define FRAMESTATE_MASK_GEOMETRY \
 306      (WindowStateMask::X     | WindowStateMask::Y |   \
 307       WindowStateMask::Width | WindowStateMask::Height)
 308
 309 void SvpSalFrame::SetWindowState( const SalFrameState *pState )
 310 {
 311     if (pState == nullptr)
 312         return;
 313
 314     // Request for position or size change
 315     if (pState->mnMask & FRAMESTATE_MASK_GEOMETRY)
 316     {
 317         long nX = maGeometry.nX;
 318         long nY = maGeometry.nY;
 319         long nWidth = maGeometry.nWidth;
 320         long nHeight = maGeometry.nHeight;
 321
 322         // change requested properties
 323         if (pState->mnMask & WindowStateMask::X)
 324             nX = pState->mnX;
 325         if (pState->mnMask & WindowStateMask::Y)
 326             nY = pState->mnY;
 327         if (pState->mnMask & WindowStateMask::Width)
 328             nWidth = pState->mnWidth;
 329         if (pState->mnMask & WindowStateMask::Height)
 330             nHeight = pState->mnHeight;
 331
 332         SetPosSize( nX, nY, nWidth, nHeight,
 333                     SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y |
 334                     SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
 335     }
 336 }
 337
 338 bool SvpSalFrame::GetWindowState( SalFrameState* pState )
 339 {
 340     pState->mnState = WindowStateState::Normal;
 341     pState->mnX      = maGeometry.nX;
 342     pState->mnY      = maGeometry.nY;
 343     pState->mnWidth  = maGeometry.nWidth;
 344     pState->mnHeight = maGeometry.nHeight;
 345     pState->mnMask   = FRAMESTATE_MASK_GEOMETRY | WindowStateMask::State;
 346
 347     return true;
 348 }
 349
 350 void SvpSalFrame::ShowFullScreen( bool, sal_Int32 )
 351 {
 352     SetPosSize( 0, 0, VIRTUAL_DESKTOP_WIDTH, VIRTUAL_DESKTOP_HEIGHT,
 353                 SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
 354 }
 355
 356 void SvpSalFrame::StartPresentation( bool )
 357 {
 358 }
 359
 360 void SvpSalFrame::SetAlwaysOnTop( bool )
 361 {
 362 }
 363
 364 void SvpSalFrame::ToTop( SalFrameToTop )
 365 {
 366     GetFocus();
 367 }
 368
 369 void SvpSalFrame::SetPointer( PointerStyle )
 370 {
 371 }
 372
 373 void SvpSalFrame::CaptureMouse( bool )
 374 {
 375 }
 376
 377 void SvpSalFrame::SetPointerPos( long, long )
 378 {
 379 }
 380
 381 void SvpSalFrame::Flush()
 382 {
 383 }
 384
 385 void SvpSalFrame::SetInputContext( SalInputContext* )
 386 {
 387 }
 388
 389 void SvpSalFrame::EndExtTextInput( EndExtTextInputFlags )
 390 {
 391 }
 392
 393 OUString SvpSalFrame::GetKeyName( sal_uInt16 )
 394 {
 395     return OUString();
 396 }
 397
 398 bool SvpSalFrame::MapUnicodeToKeyCode( sal_Unicode, LanguageType, vcl::KeyCode& )
 399 {
 400     return false;
 401 }
 402
 403 LanguageType SvpSalFrame::GetInputLanguage()
 404 {
 405     return LANGUAGE_DONTKNOW;
 406 }
 407
 408 void SvpSalFrame::UpdateSettings( AllSettings& rSettings )
 409 {
 410     StyleSettings aStyleSettings = rSettings.GetStyleSettings();
 411
 412     Color aBackgroundColor( 0xef, 0xef, 0xef );
 413     aStyleSettings.BatchSetBackgrounds( aBackgroundColor, false );
 414     aStyleSettings.SetMenuColor( aBackgroundColor );
 415     aStyleSettings.SetMenuBarColor( aBackgroundColor );
 416
 417     if (comphelper::LibreOfficeKit::isActive()) // TODO: remove this.
 418     {
 419         vcl::Font aStdFont( FAMILY_SWISS, Size( 0, 14 ) );
 420         aStdFont.SetCharSet( osl_getThreadTextEncoding() );
 421         aStdFont.SetWeight( WEIGHT_NORMAL );
 422         aStdFont.SetFamilyName( "Liberation Sans" );
 423         aStyleSettings.BatchSetFonts( aStdFont, aStdFont );
 424
 425         aStdFont.SetFontSize(Size(0, 12));
 426         aStyleSettings.SetMenuFont(aStdFont);
 427     }
 428
 429     rSettings.SetStyleSettings( aStyleSettings );
 430 }
 431
 432 void SvpSalFrame::Beep()
 433 {
 434 }
 435
 436 const SystemEnvData* SvpSalFrame::GetSystemData() const
 437 {
 438     return &m_aSystemChildData;
 439 }
 440
 441 SalFrame::SalPointerState SvpSalFrame::GetPointerState()
 442 {
 443     SalPointerState aState;
 444     aState.mnState = 0;
 445     return aState;
 446 }
 447
 448 KeyIndicatorState SvpSalFrame::GetIndicatorState()
 449 {
 450     return KeyIndicatorState::NONE;
 451 }
 452
 453 void SvpSalFrame::SimulateKeyPress( sal_uInt16 /*nKeyCode*/ )
 454 {
 455 }
 456
 457 void SvpSalFrame::SetParent( SalFrame* pNewParent )
 458 {
 459     if( m_pParent )
 460         m_pParent->m_aChildren.remove( this );
 461     m_pParent = static_cast<SvpSalFrame*>(pNewParent);
 462 }
 463
 464 bool SvpSalFrame::SetPluginParent( SystemParentData* )
 465 {
 466     return true;
 467 }
 468
 469 void SvpSalFrame::ResetClipRegion()
 470 {
 471 }
 472
 473 void SvpSalFrame::BeginSetClipRegion( sal_uLong )
 474 {
 475 }
 476
 477 void SvpSalFrame::UnionClipRegion( long, long, long, long )
 478 {
 479 }
 480
 481 void SvpSalFrame::EndSetClipRegion()
 482 {
 483 }
 484
 485 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */