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