vcl/headless/svpinst.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 <unistd.h>
  21 #include <fcntl.h>
  22 #include <sys/time.h>
  23 #include <sys/poll.h>
  24
  25 #include <sal/types.h>
  26
  27 #include <vcl/apptypes.hxx>
  28
  29 #include "headless/svpinst.hxx"
  30 #include "headless/svpframe.hxx"
  31 #include "headless/svpdummies.hxx"
  32 #include "headless/svpvd.hxx"
  33 #ifdef IOS
  34 #include "headless/svpgdi.hxx"
  35 #include "quartz/salbmp.h"
  36 #include "quartz/salgdi.h"
  37 #include "quartz/salvd.h"
  38 #endif
  39 #include "headless/svpbmp.hxx"
  40
  41 #include <salframe.hxx>
  42 #include <svdata.hxx>
  43 #include <generic/gendata.hxx>
  44 #include <basebmp/scanlineformats.hxx>
  45 // FIXME: remove when we re-work the svp mainloop
  46 #include <unx/salunxtime.h>
  47
  48 using namespace basebmp;
  49
  50 bool SvpSalInstance::isFrameAlive( const SalFrame* pFrame ) const
  51 {
  52     for( std::list< SalFrame* >::const_iterator it = m_aFrames.begin();
  53          it != m_aFrames.end(); ++it )
  54     {
  55         if( *it == pFrame )
  56         {
  57             return true;
  58         }
  59     }
  60     return false;
  61 }
  62
  63 SvpSalInstance* SvpSalInstance::s_pDefaultInstance = NULL;
  64
  65 SvpSalInstance::SvpSalInstance( SalYieldMutex *pMutex ) :
  66     SalGenericInstance( pMutex )
  67 {
  68     m_aTimeout.tv_sec       = 0;
  69     m_aTimeout.tv_usec      = 0;
  70     m_nTimeoutMS            = 0;
  71
  72     m_pTimeoutFDS[0] = m_pTimeoutFDS[1] = -1;
  73     if (pipe (m_pTimeoutFDS) != -1)
  74     {
  75         // initialize 'wakeup' pipe.
  76         int flags;
  77
  78         // set close-on-exec descriptor flag.
  79         if ((flags = fcntl (m_pTimeoutFDS[0], F_GETFD)) != -1)
  80         {
  81             flags |= FD_CLOEXEC;
  82             (void)fcntl(m_pTimeoutFDS[0], F_SETFD, flags);
  83         }
  84         if ((flags = fcntl (m_pTimeoutFDS[1], F_GETFD)) != -1)
  85         {
  86             flags |= FD_CLOEXEC;
  87             (void)fcntl(m_pTimeoutFDS[1], F_SETFD, flags);
  88         }
  89
  90         // set non-blocking I/O flag.
  91         if ((flags = fcntl(m_pTimeoutFDS[0], F_GETFL)) != -1)
  92         {
  93             flags |= O_NONBLOCK;
  94             (void)fcntl(m_pTimeoutFDS[0], F_SETFL, flags);
  95         }
  96         if ((flags = fcntl(m_pTimeoutFDS[1], F_GETFL)) != -1)
  97         {
  98             flags |= O_NONBLOCK;
  99             (void)fcntl(m_pTimeoutFDS[1], F_SETFL, flags);
 100         }
 101     }
 102     m_aEventGuard = osl_createMutex();
 103     if( s_pDefaultInstance == NULL )
 104         s_pDefaultInstance = this;
 105 }
 106
 107 SvpSalInstance::~SvpSalInstance()
 108 {
 109     if( s_pDefaultInstance == this )
 110         s_pDefaultInstance = NULL;
 111
 112     // close 'wakeup' pipe.
 113     close (m_pTimeoutFDS[0]);
 114     close (m_pTimeoutFDS[1]);
 115     osl_destroyMutex( m_aEventGuard );
 116 }
 117
 118 void SvpSalInstance::PostEvent( const SalFrame* pFrame, void* pData, sal_uInt16 nEvent )
 119 {
 120     if( osl_acquireMutex( m_aEventGuard ) )
 121     {
 122         m_aUserEvents.push_back( SalUserEvent( pFrame, pData, nEvent ) );
 123         osl_releaseMutex( m_aEventGuard );
 124     }
 125     Wakeup();
 126 }
 127
 128 bool SvpSalInstance::PostedEventsInQueue()
 129 {
 130     bool result = false;
 131     if( osl_acquireMutex( m_aEventGuard ) )
 132     {
 133         result = m_aUserEvents.size() > 0;
 134         osl_releaseMutex( m_aEventGuard );
 135     }
 136     return result;
 137 }
 138
 139 void SvpSalInstance::deregisterFrame( SalFrame* pFrame )
 140 {
 141     m_aFrames.remove( pFrame );
 142
 143     if( osl_acquireMutex( m_aEventGuard ) )
 144     {
 145         // cancel outstanding events for this frame
 146         if( ! m_aUserEvents.empty() )
 147         {
 148             std::list< SalUserEvent >::iterator it = m_aUserEvents.begin();
 149             do
 150             {
 151                 if( it->m_pFrame    == pFrame )
 152                 {
 153                     it = m_aUserEvents.erase( it );
 154                 }
 155                 else
 156                     ++it;
 157             } while( it != m_aUserEvents.end() );
 158         }
 159         osl_releaseMutex( m_aEventGuard );
 160     }
 161 }
 162
 163 void SvpSalInstance::Wakeup()
 164 {
 165     OSL_VERIFY(write (m_pTimeoutFDS[1], "", 1) == 1);
 166 }
 167
 168 bool SvpSalInstance::CheckTimeout( bool bExecuteTimers )
 169 {
 170     bool bRet = false;
 171     if( m_aTimeout.tv_sec ) // timer is started
 172     {
 173         timeval aTimeOfDay;
 174         gettimeofday( &aTimeOfDay, 0 );
 175         if( aTimeOfDay >= m_aTimeout )
 176         {
 177             bRet = true;
 178             if( bExecuteTimers )
 179             {
 180                 // timed out, update timeout
 181                 m_aTimeout = aTimeOfDay;
 182                 m_aTimeout += m_nTimeoutMS;
 183
 184                 osl::Guard< comphelper::SolarMutex > aGuard( mpSalYieldMutex );
 185
 186                 // notify
 187                 ImplSVData* pSVData = ImplGetSVData();
 188                 if( pSVData->mpSalTimer )
 189                 {
 190                     bool idle = true; // TODO
 191                     pSVData->mpSalTimer->CallCallback( idle );
 192                 }
 193             }
 194         }
 195     }
 196     return bRet;
 197 }
 198
 199 SalFrame* SvpSalInstance::CreateChildFrame( SystemParentData* pParent, sal_uLong nStyle )
 200 {
 201     return new SvpSalFrame( this, NULL, nStyle, false, SVP_DEFAULT_BITMAP_FORMAT, pParent );
 202 }
 203
 204 SalFrame* SvpSalInstance::CreateFrame( SalFrame* pParent, sal_uLong nStyle )
 205 {
 206     return new SvpSalFrame( this, pParent, nStyle, false, SVP_DEFAULT_BITMAP_FORMAT );
 207 }
 208
 209 void SvpSalInstance::DestroyFrame( SalFrame* pFrame )
 210 {
 211     delete pFrame;
 212 }
 213
 214 SalObject* SvpSalInstance::CreateObject( SalFrame*, SystemWindowData*, bool )
 215 {
 216     return new SvpSalObject();
 217 }
 218
 219 void SvpSalInstance::DestroyObject( SalObject* pObject )
 220 {
 221     delete pObject;
 222 }
 223
 224 #ifndef IOS
 225
 226 SalVirtualDevice* SvpSalInstance::CreateVirtualDevice( SalGraphics* /* pGraphics */,
 227                                                        long &nDX, long &nDY,
 228                                                        sal_uInt16 nBitCount,
 229                                                        const SystemGraphicsData* /* pData */ )
 230 {
 231     SvpSalVirtualDevice* pNew = new SvpSalVirtualDevice( nBitCount );
 232     pNew->SetSize( nDX, nDY );
 233     return pNew;
 234 }
 235
 236 #endif
 237
 238 SalTimer* SvpSalInstance::CreateSalTimer()
 239 {
 240     return new SvpSalTimer( this );
 241 }
 242
 243 SalI18NImeStatus* SvpSalInstance::CreateI18NImeStatus()
 244 {
 245     return new SvpImeStatus();
 246 }
 247
 248 SalSystem* SvpSalInstance::CreateSalSystem()
 249 {
 250     return new SvpSalSystem();
 251 }
 252
 253 SalBitmap* SvpSalInstance::CreateSalBitmap()
 254 {
 255 #ifdef IOS
 256     return new QuartzSalBitmap();
 257 #else
 258     return new SvpSalBitmap();
 259 #endif
 260 }
 261
 262 void SvpSalInstance::Yield( bool bWait, bool bHandleAllCurrentEvents )
 263 {
 264     // first, check for already queued events.
 265
 266     // release yield mutex
 267     std::list< SalUserEvent > aEvents;
 268     sal_uLong nAcquireCount = ReleaseYieldMutex();
 269     if( osl_acquireMutex( m_aEventGuard ) )
 270     {
 271         if( ! m_aUserEvents.empty() )
 272         {
 273             if( bHandleAllCurrentEvents )
 274             {
 275                 aEvents = m_aUserEvents;
 276                 m_aUserEvents.clear();
 277             }
 278             else
 279             {
 280                 aEvents.push_back( m_aUserEvents.front() );
 281                 m_aUserEvents.pop_front();
 282             }
 283         }
 284         osl_releaseMutex( m_aEventGuard );
 285     }
 286     // acquire yield mutex again
 287     AcquireYieldMutex( nAcquireCount );
 288
 289     bool bEvent = !aEvents.empty();
 290     if( bEvent )
 291     {
 292         for( std::list<SalUserEvent>::const_iterator it = aEvents.begin(); it != aEvents.end(); ++it )
 293         {
 294             if ( isFrameAlive( it->m_pFrame ) )
 295             {
 296                 it->m_pFrame->CallCallback( it->m_nEvent, it->m_pData );
 297                 if( it->m_nEvent == SALEVENT_RESIZE )
 298                 {
 299                     // this would be a good time to post a paint
 300                     const SvpSalFrame* pSvpFrame = static_cast<const SvpSalFrame*>(it->m_pFrame);
 301                     pSvpFrame->PostPaint(false);
 302                 }
 303             }
 304         }
 305     }
 306
 307     bEvent = CheckTimeout() || bEvent;
 308
 309     if (bWait && ! bEvent )
 310     {
 311         int nTimeoutMS = 0;
 312         if (m_aTimeout.tv_sec) // Timer is started.
 313         {
 314             timeval Timeout;
 315             // determine remaining timeout.
 316             gettimeofday (&Timeout, 0);
 317             nTimeoutMS = (m_aTimeout.tv_sec - Timeout.tv_sec) * 1000
 318                          + m_aTimeout.tv_usec/1000 - Timeout.tv_usec/1000;
 319             if( nTimeoutMS < 0 )
 320                 nTimeoutMS = 0;
 321         }
 322         else
 323             nTimeoutMS = -1; // wait until something happens
 324
 325         DoReleaseYield(nTimeoutMS);
 326     }
 327 }
 328
 329 void SvpSalInstance::DoReleaseYield( int nTimeoutMS )
 330 {
 331     // poll
 332     struct pollfd aPoll;
 333     aPoll.fd = m_pTimeoutFDS[0];
 334     aPoll.events = POLLIN;
 335     aPoll.revents = 0;
 336
 337     // release yield mutex
 338     sal_uLong nAcquireCount = ReleaseYieldMutex();
 339
 340     (void)poll( &aPoll, 1, nTimeoutMS );
 341
 342     // acquire yield mutex again
 343     AcquireYieldMutex( nAcquireCount );
 344
 345     // clean up pipe
 346     if( (aPoll.revents & POLLIN) != 0 )
 347     {
 348         int buffer;
 349         while (read (m_pTimeoutFDS[0], &buffer, sizeof(buffer)) > 0)
 350             continue;
 351     }
 352 }
 353
 354 bool SvpSalInstance::AnyInput( VclInputFlags nType )
 355 {
 356     if( nType & VclInputFlags::TIMER )
 357         return CheckTimeout( false );
 358     return false;
 359 }
 360
 361 SalSession* SvpSalInstance::CreateSalSession()
 362 {
 363     return NULL;
 364 }
 365
 366 void* SvpSalInstance::GetConnectionIdentifier( ConnectionIdentifierType& rReturnedType, int& rReturnedBytes )
 367 {
 368     rReturnedBytes  = 1;
 369     rReturnedType   = AsciiCString;
 370     return const_cast<char*>("");
 371 }
 372
 373 void SvpSalInstance::StopTimer()
 374 {
 375     m_aTimeout.tv_sec   = 0;
 376     m_aTimeout.tv_usec  = 0;
 377     m_nTimeoutMS        = 0;
 378 }
 379
 380 void SvpSalInstance::StartTimer( sal_uLong nMS )
 381 {
 382     timeval aPrevTimeout (m_aTimeout);
 383     gettimeofday (&m_aTimeout, 0);
 384
 385     m_nTimeoutMS  = nMS;
 386     m_aTimeout    += m_nTimeoutMS;
 387
 388     if ((aPrevTimeout > m_aTimeout) || (aPrevTimeout.tv_sec == 0))
 389     {
 390         // Wakeup from previous timeout (or stopped timer).
 391         Wakeup();
 392     }
 393 }
 394
 395 void SvpSalInstance::AddToRecentDocumentList(const OUString&, const OUString&, const OUString&)
 396 {
 397 }
 398
 399 SvpSalTimer::~SvpSalTimer()
 400 {
 401 }
 402
 403 void SvpSalTimer::Stop()
 404 {
 405     m_pInstance->StopTimer();
 406 }
 407
 408 void SvpSalTimer::Start( sal_uLong nMS )
 409 {
 410     m_pInstance->StartTimer( nMS );
 411 }
 412
 413 void SvpSalInstance::setBitCountFormatMapping( sal_uInt16 nBitCount,
 414                                             Format aFormat )
 415 {
 416     m_aBitCountFormatMap[nBitCount] = aFormat;
 417 }
 418
 419 Format SvpSalInstance::getFormatForBitCount( sal_uInt16 nBitCount )
 420 {
 421     BitCountFormatMap::iterator aIt;
 422     if ( (aIt = m_aBitCountFormatMap.find( nBitCount )) != m_aBitCountFormatMap.end() )
 423     {
 424         return aIt->second;
 425     }
 426
 427     switch( nBitCount )
 428     {
 429         case 1:
 430             return FORMAT_ONE_BIT_MSB_PAL;
 431         case 4:
 432             return FORMAT_FOUR_BIT_MSB_PAL;
 433         case 8:
 434             return FORMAT_EIGHT_BIT_PAL;
 435         case 16:
 436 #ifdef OSL_BIGENDIAN
 437             return FORMAT_SIXTEEN_BIT_MSB_TC_MASK;
 438 #else
 439             return FORMAT_SIXTEEN_BIT_LSB_TC_MASK;
 440 #endif
 441         case 24:
 442             return FORMAT_THIRTYTWO_BIT_TC_MASK_BGRX;
 443         case 32:
 444             return FORMAT_THIRTYTWO_BIT_TC_MASK_BGRA;
 445         case 0:
 446 #ifdef ANDROID
 447             return FORMAT_THIRTYTWO_BIT_TC_MASK_RGBA;
 448 #else
 449             return FORMAT_THIRTYTWO_BIT_TC_MASK_BGRX;
 450 #endif
 451         default:
 452             return SVP_DEFAULT_BITMAP_FORMAT;
 453      }
 454
 455 }
 456 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */