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