1*9f62ea84SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*9f62ea84SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*9f62ea84SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*9f62ea84SAndrew Rist * distributed with this work for additional information
6*9f62ea84SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*9f62ea84SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*9f62ea84SAndrew Rist * "License"); you may not use this file except in compliance
9*9f62ea84SAndrew Rist * with the License. You may obtain a copy of the License at
10*9f62ea84SAndrew Rist *
11*9f62ea84SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*9f62ea84SAndrew Rist *
13*9f62ea84SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*9f62ea84SAndrew Rist * software distributed under the License is distributed on an
15*9f62ea84SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*9f62ea84SAndrew Rist * KIND, either express or implied. See the License for the
17*9f62ea84SAndrew Rist * specific language governing permissions and limitations
18*9f62ea84SAndrew Rist * under the License.
19*9f62ea84SAndrew Rist *
20*9f62ea84SAndrew Rist *************************************************************/
21*9f62ea84SAndrew Rist
22*9f62ea84SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir #include <unistd.h>
25cdf0e10cSrcweir #include <fcntl.h>
26cdf0e10cSrcweir #include <sys/time.h>
27cdf0e10cSrcweir #include <sys/poll.h>
28cdf0e10cSrcweir
29cdf0e10cSrcweir #include <sal/types.h>
30cdf0e10cSrcweir
31cdf0e10cSrcweir #include <vcl/apptypes.hxx>
32cdf0e10cSrcweir
33cdf0e10cSrcweir #include "svpinst.hxx"
34cdf0e10cSrcweir #include "svpframe.hxx"
35cdf0e10cSrcweir #include "svpdummies.hxx"
36cdf0e10cSrcweir #include "svpvd.hxx"
37cdf0e10cSrcweir #include "svpbmp.hxx"
38cdf0e10cSrcweir
39cdf0e10cSrcweir #include <salframe.hxx>
40cdf0e10cSrcweir #include <svdata.hxx>
41cdf0e10cSrcweir #include <saldatabasic.hxx>
42cdf0e10cSrcweir
43cdf0e10cSrcweir // plugin factory function
44cdf0e10cSrcweir extern "C"
45cdf0e10cSrcweir {
create_SalInstance()46cdf0e10cSrcweir SAL_DLLPUBLIC_EXPORT SalInstance* create_SalInstance()
47cdf0e10cSrcweir {
48cdf0e10cSrcweir SvpSalInstance* pInstance = new SvpSalInstance();
49cdf0e10cSrcweir SalData* pSalData = new SalData();
50cdf0e10cSrcweir pSalData->m_pInstance = pInstance;
51cdf0e10cSrcweir SetSalData( pSalData );
52cdf0e10cSrcweir return pInstance;
53cdf0e10cSrcweir }
54cdf0e10cSrcweir }
55cdf0e10cSrcweir
isFrameAlive(const SalFrame * pFrame) const56cdf0e10cSrcweir bool SvpSalInstance::isFrameAlive( const SalFrame* pFrame ) const
57cdf0e10cSrcweir {
58cdf0e10cSrcweir for( std::list< SalFrame* >::const_iterator it = m_aFrames.begin();
59cdf0e10cSrcweir it != m_aFrames.end(); ++it )
60cdf0e10cSrcweir {
61cdf0e10cSrcweir if( *it == pFrame )
62cdf0e10cSrcweir {
63cdf0e10cSrcweir return true;
64cdf0e10cSrcweir }
65cdf0e10cSrcweir }
66cdf0e10cSrcweir return false;
67cdf0e10cSrcweir }
68cdf0e10cSrcweir
69cdf0e10cSrcweir SvpSalInstance* SvpSalInstance::s_pDefaultInstance = NULL;
70cdf0e10cSrcweir
SvpSalInstance()71cdf0e10cSrcweir SvpSalInstance::SvpSalInstance()
72cdf0e10cSrcweir {
73cdf0e10cSrcweir m_aTimeout.tv_sec = 0;
74cdf0e10cSrcweir m_aTimeout.tv_usec = 0;
75cdf0e10cSrcweir m_nTimeoutMS = 0;
76cdf0e10cSrcweir
77cdf0e10cSrcweir m_pTimeoutFDS[0] = m_pTimeoutFDS[1] = -1;
78cdf0e10cSrcweir if (pipe (m_pTimeoutFDS) != -1)
79cdf0e10cSrcweir {
80cdf0e10cSrcweir // initialize 'wakeup' pipe.
81cdf0e10cSrcweir int flags;
82cdf0e10cSrcweir
83cdf0e10cSrcweir // set close-on-exec descriptor flag.
84cdf0e10cSrcweir if ((flags = fcntl (m_pTimeoutFDS[0], F_GETFD)) != -1)
85cdf0e10cSrcweir {
86cdf0e10cSrcweir flags |= FD_CLOEXEC;
87cdf0e10cSrcweir fcntl (m_pTimeoutFDS[0], F_SETFD, flags);
88cdf0e10cSrcweir }
89cdf0e10cSrcweir if ((flags = fcntl (m_pTimeoutFDS[1], F_GETFD)) != -1)
90cdf0e10cSrcweir {
91cdf0e10cSrcweir flags |= FD_CLOEXEC;
92cdf0e10cSrcweir fcntl (m_pTimeoutFDS[1], F_SETFD, flags);
93cdf0e10cSrcweir }
94cdf0e10cSrcweir
95cdf0e10cSrcweir // set non-blocking I/O flag.
96cdf0e10cSrcweir if ((flags = fcntl (m_pTimeoutFDS[0], F_GETFL)) != -1)
97cdf0e10cSrcweir {
98cdf0e10cSrcweir flags |= O_NONBLOCK;
99cdf0e10cSrcweir fcntl (m_pTimeoutFDS[0], F_SETFL, flags);
100cdf0e10cSrcweir }
101cdf0e10cSrcweir if ((flags = fcntl (m_pTimeoutFDS[1], F_GETFL)) != -1)
102cdf0e10cSrcweir {
103cdf0e10cSrcweir flags |= O_NONBLOCK;
104cdf0e10cSrcweir fcntl (m_pTimeoutFDS[1], F_SETFL, flags);
105cdf0e10cSrcweir }
106cdf0e10cSrcweir }
107cdf0e10cSrcweir m_aEventGuard = osl_createMutex();
108cdf0e10cSrcweir if( s_pDefaultInstance == NULL )
109cdf0e10cSrcweir s_pDefaultInstance = this;
110cdf0e10cSrcweir }
111cdf0e10cSrcweir
~SvpSalInstance()112cdf0e10cSrcweir SvpSalInstance::~SvpSalInstance()
113cdf0e10cSrcweir {
114cdf0e10cSrcweir if( s_pDefaultInstance == this )
115cdf0e10cSrcweir s_pDefaultInstance = NULL;
116cdf0e10cSrcweir
117cdf0e10cSrcweir // close 'wakeup' pipe.
118cdf0e10cSrcweir close (m_pTimeoutFDS[0]);
119cdf0e10cSrcweir close (m_pTimeoutFDS[1]);
120cdf0e10cSrcweir osl_destroyMutex( m_aEventGuard );
121cdf0e10cSrcweir }
122cdf0e10cSrcweir
PostEvent(const SalFrame * pFrame,void * pData,sal_uInt16 nEvent)123cdf0e10cSrcweir void SvpSalInstance::PostEvent( const SalFrame* pFrame, void* pData, sal_uInt16 nEvent )
124cdf0e10cSrcweir {
125cdf0e10cSrcweir if( osl_acquireMutex( m_aEventGuard ) )
126cdf0e10cSrcweir {
127cdf0e10cSrcweir m_aUserEvents.push_back( SalUserEvent( pFrame, pData, nEvent ) );
128cdf0e10cSrcweir osl_releaseMutex( m_aEventGuard );
129cdf0e10cSrcweir }
130cdf0e10cSrcweir Wakeup();
131cdf0e10cSrcweir }
132cdf0e10cSrcweir
CancelEvent(const SalFrame * pFrame,void * pData,sal_uInt16 nEvent)133cdf0e10cSrcweir void SvpSalInstance::CancelEvent( const SalFrame* pFrame, void* pData, sal_uInt16 nEvent )
134cdf0e10cSrcweir {
135cdf0e10cSrcweir if( osl_acquireMutex( m_aEventGuard ) )
136cdf0e10cSrcweir {
137cdf0e10cSrcweir if( ! m_aUserEvents.empty() )
138cdf0e10cSrcweir {
139cdf0e10cSrcweir std::list< SalUserEvent >::iterator it = m_aUserEvents.begin();
140cdf0e10cSrcweir do
141cdf0e10cSrcweir {
142cdf0e10cSrcweir if( it->m_pFrame == pFrame &&
143cdf0e10cSrcweir it->m_pData == pData &&
144cdf0e10cSrcweir it->m_nEvent == nEvent )
145cdf0e10cSrcweir {
146cdf0e10cSrcweir it = m_aUserEvents.erase( it );
147cdf0e10cSrcweir }
148cdf0e10cSrcweir else
149cdf0e10cSrcweir ++it;
150cdf0e10cSrcweir } while( it != m_aUserEvents.end() );
151cdf0e10cSrcweir }
152cdf0e10cSrcweir osl_releaseMutex( m_aEventGuard );
153cdf0e10cSrcweir }
154cdf0e10cSrcweir }
155cdf0e10cSrcweir
deregisterFrame(SalFrame * pFrame)156cdf0e10cSrcweir void SvpSalInstance::deregisterFrame( SalFrame* pFrame )
157cdf0e10cSrcweir {
158cdf0e10cSrcweir m_aFrames.remove( pFrame );
159cdf0e10cSrcweir
160cdf0e10cSrcweir if( osl_acquireMutex( m_aEventGuard ) )
161cdf0e10cSrcweir {
162cdf0e10cSrcweir // cancel outstanding events for this frame
163cdf0e10cSrcweir if( ! m_aUserEvents.empty() )
164cdf0e10cSrcweir {
165cdf0e10cSrcweir std::list< SalUserEvent >::iterator it = m_aUserEvents.begin();
166cdf0e10cSrcweir do
167cdf0e10cSrcweir {
168cdf0e10cSrcweir if( it->m_pFrame == pFrame )
169cdf0e10cSrcweir {
170cdf0e10cSrcweir it = m_aUserEvents.erase( it );
171cdf0e10cSrcweir }
172cdf0e10cSrcweir else
173cdf0e10cSrcweir ++it;
174cdf0e10cSrcweir } while( it != m_aUserEvents.end() );
175cdf0e10cSrcweir }
176cdf0e10cSrcweir osl_releaseMutex( m_aEventGuard );
177cdf0e10cSrcweir }
178cdf0e10cSrcweir }
179cdf0e10cSrcweir
Wakeup()180cdf0e10cSrcweir void SvpSalInstance::Wakeup()
181cdf0e10cSrcweir {
182cdf0e10cSrcweir write (m_pTimeoutFDS[1], "", 1);
183cdf0e10cSrcweir }
184cdf0e10cSrcweir
185cdf0e10cSrcweir
186cdf0e10cSrcweir // -=-= timeval =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
operator >=(const timeval & t1,const timeval & t2)187cdf0e10cSrcweir inline int operator >= ( const timeval &t1, const timeval &t2 )
188cdf0e10cSrcweir {
189cdf0e10cSrcweir if( t1.tv_sec == t2.tv_sec )
190cdf0e10cSrcweir return t1.tv_usec >= t2.tv_usec;
191cdf0e10cSrcweir return t1.tv_sec > t2.tv_sec;
192cdf0e10cSrcweir }
operator +=(timeval & t1,sal_uLong t2)193cdf0e10cSrcweir inline timeval &operator += ( timeval &t1, sal_uLong t2 )
194cdf0e10cSrcweir {
195cdf0e10cSrcweir t1.tv_sec += t2 / 1000;
196cdf0e10cSrcweir t1.tv_usec += t2 ? (t2 % 1000) * 1000 : 500;
197cdf0e10cSrcweir if( t1.tv_usec > 1000000 )
198cdf0e10cSrcweir {
199cdf0e10cSrcweir t1.tv_sec++;
200cdf0e10cSrcweir t1.tv_usec -= 1000000;
201cdf0e10cSrcweir }
202cdf0e10cSrcweir return t1;
203cdf0e10cSrcweir }
operator >(const timeval & t1,const timeval & t2)204cdf0e10cSrcweir inline int operator > ( const timeval &t1, const timeval &t2 )
205cdf0e10cSrcweir {
206cdf0e10cSrcweir if( t1.tv_sec == t2.tv_sec )
207cdf0e10cSrcweir return t1.tv_usec > t2.tv_usec;
208cdf0e10cSrcweir return t1.tv_sec > t2.tv_sec;
209cdf0e10cSrcweir }
210cdf0e10cSrcweir
CheckTimeout(bool bExecuteTimers)211cdf0e10cSrcweir bool SvpSalInstance::CheckTimeout( bool bExecuteTimers )
212cdf0e10cSrcweir {
213cdf0e10cSrcweir bool bRet = false;
214cdf0e10cSrcweir if( m_aTimeout.tv_sec ) // timer is started
215cdf0e10cSrcweir {
216cdf0e10cSrcweir timeval aTimeOfDay;
217cdf0e10cSrcweir gettimeofday( &aTimeOfDay, 0 );
218cdf0e10cSrcweir if( aTimeOfDay >= m_aTimeout )
219cdf0e10cSrcweir {
220cdf0e10cSrcweir bRet = true;
221cdf0e10cSrcweir if( bExecuteTimers )
222cdf0e10cSrcweir {
223cdf0e10cSrcweir // timed out, update timeout
224cdf0e10cSrcweir m_aTimeout = aTimeOfDay;
225cdf0e10cSrcweir m_aTimeout += m_nTimeoutMS;
226cdf0e10cSrcweir // notify
227cdf0e10cSrcweir ImplSVData* pSVData = ImplGetSVData();
228cdf0e10cSrcweir if( pSVData->mpSalTimer )
229cdf0e10cSrcweir pSVData->mpSalTimer->CallCallback();
230cdf0e10cSrcweir }
231cdf0e10cSrcweir }
232cdf0e10cSrcweir }
233cdf0e10cSrcweir return bRet;
234cdf0e10cSrcweir }
235cdf0e10cSrcweir
CreateChildFrame(SystemParentData * pParent,sal_uLong nStyle)236cdf0e10cSrcweir SalFrame* SvpSalInstance::CreateChildFrame( SystemParentData* pParent, sal_uLong nStyle )
237cdf0e10cSrcweir {
238cdf0e10cSrcweir return new SvpSalFrame( this, NULL, nStyle, pParent );
239cdf0e10cSrcweir }
240cdf0e10cSrcweir
CreateFrame(SalFrame * pParent,sal_uLong nStyle)241cdf0e10cSrcweir SalFrame* SvpSalInstance::CreateFrame( SalFrame* pParent, sal_uLong nStyle )
242cdf0e10cSrcweir {
243cdf0e10cSrcweir return new SvpSalFrame( this, pParent, nStyle );
244cdf0e10cSrcweir }
245cdf0e10cSrcweir
DestroyFrame(SalFrame * pFrame)246cdf0e10cSrcweir void SvpSalInstance::DestroyFrame( SalFrame* pFrame )
247cdf0e10cSrcweir {
248cdf0e10cSrcweir delete pFrame;
249cdf0e10cSrcweir }
250cdf0e10cSrcweir
CreateObject(SalFrame *,SystemWindowData *,sal_Bool)251cdf0e10cSrcweir SalObject* SvpSalInstance::CreateObject( SalFrame*, SystemWindowData*, sal_Bool )
252cdf0e10cSrcweir {
253cdf0e10cSrcweir return new SvpSalObject();
254cdf0e10cSrcweir }
255cdf0e10cSrcweir
DestroyObject(SalObject * pObject)256cdf0e10cSrcweir void SvpSalInstance::DestroyObject( SalObject* pObject )
257cdf0e10cSrcweir {
258cdf0e10cSrcweir delete pObject;
259cdf0e10cSrcweir }
260cdf0e10cSrcweir
CreateVirtualDevice(SalGraphics *,long nDX,long nDY,sal_uInt16 nBitCount,const SystemGraphicsData *)261cdf0e10cSrcweir SalVirtualDevice* SvpSalInstance::CreateVirtualDevice( SalGraphics*,
262cdf0e10cSrcweir long nDX, long nDY,
263cdf0e10cSrcweir sal_uInt16 nBitCount, const SystemGraphicsData* )
264cdf0e10cSrcweir {
265cdf0e10cSrcweir SvpSalVirtualDevice* pNew = new SvpSalVirtualDevice( nBitCount );
266cdf0e10cSrcweir pNew->SetSize( nDX, nDY );
267cdf0e10cSrcweir return pNew;
268cdf0e10cSrcweir }
269cdf0e10cSrcweir
DestroyVirtualDevice(SalVirtualDevice * pDevice)270cdf0e10cSrcweir void SvpSalInstance::DestroyVirtualDevice( SalVirtualDevice* pDevice )
271cdf0e10cSrcweir {
272cdf0e10cSrcweir delete pDevice;
273cdf0e10cSrcweir }
274cdf0e10cSrcweir
CreateSalTimer()275cdf0e10cSrcweir SalTimer* SvpSalInstance::CreateSalTimer()
276cdf0e10cSrcweir {
277cdf0e10cSrcweir return new SvpSalTimer( this );
278cdf0e10cSrcweir }
279cdf0e10cSrcweir
CreateI18NImeStatus()280cdf0e10cSrcweir SalI18NImeStatus* SvpSalInstance::CreateI18NImeStatus()
281cdf0e10cSrcweir {
282cdf0e10cSrcweir return new SvpImeStatus();
283cdf0e10cSrcweir }
284cdf0e10cSrcweir
CreateSalSystem()285cdf0e10cSrcweir SalSystem* SvpSalInstance::CreateSalSystem()
286cdf0e10cSrcweir {
287cdf0e10cSrcweir return new SvpSalSystem();
288cdf0e10cSrcweir }
289cdf0e10cSrcweir
CreateSalBitmap()290cdf0e10cSrcweir SalBitmap* SvpSalInstance::CreateSalBitmap()
291cdf0e10cSrcweir {
292cdf0e10cSrcweir return new SvpSalBitmap();
293cdf0e10cSrcweir }
294cdf0e10cSrcweir
GetYieldMutex()295cdf0e10cSrcweir vos::IMutex* SvpSalInstance::GetYieldMutex()
296cdf0e10cSrcweir {
297cdf0e10cSrcweir return &m_aYieldMutex;
298cdf0e10cSrcweir }
299cdf0e10cSrcweir
ReleaseYieldMutex()300cdf0e10cSrcweir sal_uLong SvpSalInstance::ReleaseYieldMutex()
301cdf0e10cSrcweir {
302cdf0e10cSrcweir if ( m_aYieldMutex.GetThreadId() ==
303cdf0e10cSrcweir vos::OThread::getCurrentIdentifier() )
304cdf0e10cSrcweir {
305cdf0e10cSrcweir sal_uLong nCount = m_aYieldMutex.GetAcquireCount();
306cdf0e10cSrcweir sal_uLong n = nCount;
307cdf0e10cSrcweir while ( n )
308cdf0e10cSrcweir {
309cdf0e10cSrcweir m_aYieldMutex.release();
310cdf0e10cSrcweir n--;
311cdf0e10cSrcweir }
312cdf0e10cSrcweir
313cdf0e10cSrcweir return nCount;
314cdf0e10cSrcweir }
315cdf0e10cSrcweir else
316cdf0e10cSrcweir return 0;
317cdf0e10cSrcweir }
318cdf0e10cSrcweir
AcquireYieldMutex(sal_uLong nCount)319cdf0e10cSrcweir void SvpSalInstance::AcquireYieldMutex( sal_uLong nCount )
320cdf0e10cSrcweir {
321cdf0e10cSrcweir while ( nCount )
322cdf0e10cSrcweir {
323cdf0e10cSrcweir m_aYieldMutex.acquire();
324cdf0e10cSrcweir nCount--;
325cdf0e10cSrcweir }
326cdf0e10cSrcweir }
327cdf0e10cSrcweir
CheckYieldMutex()328cdf0e10cSrcweir bool SvpSalInstance::CheckYieldMutex()
329cdf0e10cSrcweir {
330cdf0e10cSrcweir bool bRet = true;
331cdf0e10cSrcweir
332cdf0e10cSrcweir if ( m_aYieldMutex.GetThreadId() !=
333cdf0e10cSrcweir vos::OThread::getCurrentIdentifier() )
334cdf0e10cSrcweir {
335cdf0e10cSrcweir bRet = false;
336cdf0e10cSrcweir }
337cdf0e10cSrcweir
338cdf0e10cSrcweir return bRet;
339cdf0e10cSrcweir }
340cdf0e10cSrcweir
Yield(bool bWait,bool bHandleAllCurrentEvents)341cdf0e10cSrcweir void SvpSalInstance::Yield( bool bWait, bool bHandleAllCurrentEvents )
342cdf0e10cSrcweir {
343cdf0e10cSrcweir // first, check for already queued events.
344cdf0e10cSrcweir
345cdf0e10cSrcweir // release yield mutex
346cdf0e10cSrcweir std::list< SalUserEvent > aEvents;
347cdf0e10cSrcweir sal_uLong nAcquireCount = ReleaseYieldMutex();
348cdf0e10cSrcweir if( osl_acquireMutex( m_aEventGuard ) )
349cdf0e10cSrcweir {
350cdf0e10cSrcweir if( ! m_aUserEvents.empty() )
351cdf0e10cSrcweir {
352cdf0e10cSrcweir if( bHandleAllCurrentEvents )
353cdf0e10cSrcweir {
354cdf0e10cSrcweir aEvents = m_aUserEvents;
355cdf0e10cSrcweir m_aUserEvents.clear();
356cdf0e10cSrcweir }
357cdf0e10cSrcweir else
358cdf0e10cSrcweir {
359cdf0e10cSrcweir aEvents.push_back( m_aUserEvents.front() );
360cdf0e10cSrcweir m_aUserEvents.pop_front();
361cdf0e10cSrcweir }
362cdf0e10cSrcweir }
363cdf0e10cSrcweir osl_releaseMutex( m_aEventGuard );
364cdf0e10cSrcweir }
365cdf0e10cSrcweir // acquire yield mutex again
366cdf0e10cSrcweir AcquireYieldMutex( nAcquireCount );
367cdf0e10cSrcweir
368cdf0e10cSrcweir bool bEvent = !aEvents.empty();
369cdf0e10cSrcweir if( bEvent )
370cdf0e10cSrcweir {
371cdf0e10cSrcweir for( std::list<SalUserEvent>::const_iterator it = aEvents.begin(); it != aEvents.end(); ++it )
372cdf0e10cSrcweir {
373cdf0e10cSrcweir if ( isFrameAlive( it->m_pFrame ) )
374cdf0e10cSrcweir {
375cdf0e10cSrcweir it->m_pFrame->CallCallback( it->m_nEvent, it->m_pData );
376cdf0e10cSrcweir if( it->m_nEvent == SALEVENT_RESIZE )
377cdf0e10cSrcweir {
378cdf0e10cSrcweir // this would be a good time to post a paint
379cdf0e10cSrcweir const SvpSalFrame* pSvpFrame = static_cast<const SvpSalFrame*>(it->m_pFrame);
380cdf0e10cSrcweir pSvpFrame->PostPaint();
381cdf0e10cSrcweir }
382cdf0e10cSrcweir }
383cdf0e10cSrcweir }
384cdf0e10cSrcweir }
385cdf0e10cSrcweir
386cdf0e10cSrcweir bEvent = CheckTimeout() || bEvent;
387cdf0e10cSrcweir
388cdf0e10cSrcweir if (bWait && ! bEvent )
389cdf0e10cSrcweir {
390cdf0e10cSrcweir int nTimeoutMS = 0;
391cdf0e10cSrcweir if (m_aTimeout.tv_sec) // Timer is started.
392cdf0e10cSrcweir {
393cdf0e10cSrcweir timeval Timeout;
394cdf0e10cSrcweir // determine remaining timeout.
395cdf0e10cSrcweir gettimeofday (&Timeout, 0);
396cdf0e10cSrcweir nTimeoutMS = m_aTimeout.tv_sec*1000 + m_aTimeout.tv_usec/1000
397cdf0e10cSrcweir - Timeout.tv_sec*1000 - Timeout.tv_usec/1000;
398cdf0e10cSrcweir if( nTimeoutMS < 0 )
399cdf0e10cSrcweir nTimeoutMS = 0;
400cdf0e10cSrcweir }
401cdf0e10cSrcweir else
402cdf0e10cSrcweir nTimeoutMS = -1; // wait until something happens
403cdf0e10cSrcweir
404cdf0e10cSrcweir // release yield mutex
405cdf0e10cSrcweir nAcquireCount = ReleaseYieldMutex();
406cdf0e10cSrcweir // poll
407cdf0e10cSrcweir struct pollfd aPoll;
408cdf0e10cSrcweir aPoll.fd = m_pTimeoutFDS[0];
409cdf0e10cSrcweir aPoll.events = POLLIN;
410cdf0e10cSrcweir aPoll.revents = 0;
411cdf0e10cSrcweir poll( &aPoll, 1, nTimeoutMS );
412cdf0e10cSrcweir
413cdf0e10cSrcweir // acquire yield mutex again
414cdf0e10cSrcweir AcquireYieldMutex( nAcquireCount );
415cdf0e10cSrcweir
416cdf0e10cSrcweir // clean up pipe
417cdf0e10cSrcweir if( (aPoll.revents & POLLIN) != 0 )
418cdf0e10cSrcweir {
419cdf0e10cSrcweir int buffer;
420cdf0e10cSrcweir while (read (m_pTimeoutFDS[0], &buffer, sizeof(buffer)) > 0)
421cdf0e10cSrcweir continue;
422cdf0e10cSrcweir }
423cdf0e10cSrcweir }
424cdf0e10cSrcweir }
425cdf0e10cSrcweir
AnyInput(sal_uInt16 nType)426cdf0e10cSrcweir bool SvpSalInstance::AnyInput( sal_uInt16 nType )
427cdf0e10cSrcweir {
428cdf0e10cSrcweir if( (nType & INPUT_TIMER) != 0 )
429cdf0e10cSrcweir return CheckTimeout( false );
430cdf0e10cSrcweir return false;
431cdf0e10cSrcweir }
432cdf0e10cSrcweir
CreateSalSession()433cdf0e10cSrcweir SalSession* SvpSalInstance::CreateSalSession()
434cdf0e10cSrcweir {
435cdf0e10cSrcweir return NULL;
436cdf0e10cSrcweir }
437cdf0e10cSrcweir
GetConnectionIdentifier(ConnectionIdentifierType & rReturnedType,int & rReturnedBytes)438cdf0e10cSrcweir void* SvpSalInstance::GetConnectionIdentifier( ConnectionIdentifierType& rReturnedType, int& rReturnedBytes )
439cdf0e10cSrcweir {
440cdf0e10cSrcweir rReturnedBytes = 1;
441cdf0e10cSrcweir rReturnedType = AsciiCString;
442cdf0e10cSrcweir return const_cast<char*>("");
443cdf0e10cSrcweir }
444cdf0e10cSrcweir
445cdf0e10cSrcweir // -------------------------------------------------------------------------
446cdf0e10cSrcweir //
447cdf0e10cSrcweir // SalYieldMutex
448cdf0e10cSrcweir //
449cdf0e10cSrcweir // -------------------------------------------------------------------------
450cdf0e10cSrcweir
SvpSalYieldMutex()451cdf0e10cSrcweir SvpSalYieldMutex::SvpSalYieldMutex()
452cdf0e10cSrcweir {
453cdf0e10cSrcweir mnCount = 0;
454cdf0e10cSrcweir mnThreadId = 0;
455cdf0e10cSrcweir }
456cdf0e10cSrcweir
acquire()457cdf0e10cSrcweir void SvpSalYieldMutex::acquire()
458cdf0e10cSrcweir {
459cdf0e10cSrcweir OMutex::acquire();
460cdf0e10cSrcweir mnThreadId = vos::OThread::getCurrentIdentifier();
461cdf0e10cSrcweir mnCount++;
462cdf0e10cSrcweir }
463cdf0e10cSrcweir
release()464cdf0e10cSrcweir void SvpSalYieldMutex::release()
465cdf0e10cSrcweir {
466cdf0e10cSrcweir if ( mnThreadId == vos::OThread::getCurrentIdentifier() )
467cdf0e10cSrcweir {
468cdf0e10cSrcweir if ( mnCount == 1 )
469cdf0e10cSrcweir mnThreadId = 0;
470cdf0e10cSrcweir mnCount--;
471cdf0e10cSrcweir }
472cdf0e10cSrcweir OMutex::release();
473cdf0e10cSrcweir }
474cdf0e10cSrcweir
tryToAcquire()475cdf0e10cSrcweir sal_Bool SvpSalYieldMutex::tryToAcquire()
476cdf0e10cSrcweir {
477cdf0e10cSrcweir if ( OMutex::tryToAcquire() )
478cdf0e10cSrcweir {
479cdf0e10cSrcweir mnThreadId = vos::OThread::getCurrentIdentifier();
480cdf0e10cSrcweir mnCount++;
481cdf0e10cSrcweir return sal_True;
482cdf0e10cSrcweir }
483cdf0e10cSrcweir else
484cdf0e10cSrcweir return sal_False;
485cdf0e10cSrcweir }
486cdf0e10cSrcweir
487cdf0e10cSrcweir // ---------------
488cdf0e10cSrcweir // - SalTimer -
489cdf0e10cSrcweir // ---------------
490cdf0e10cSrcweir
StopTimer()491cdf0e10cSrcweir void SvpSalInstance::StopTimer()
492cdf0e10cSrcweir {
493cdf0e10cSrcweir m_aTimeout.tv_sec = 0;
494cdf0e10cSrcweir m_aTimeout.tv_usec = 0;
495cdf0e10cSrcweir m_nTimeoutMS = 0;
496cdf0e10cSrcweir }
497cdf0e10cSrcweir
StartTimer(sal_uLong nMS)498cdf0e10cSrcweir void SvpSalInstance::StartTimer( sal_uLong nMS )
499cdf0e10cSrcweir {
500cdf0e10cSrcweir timeval Timeout (m_aTimeout); // previous timeout.
501cdf0e10cSrcweir gettimeofday (&m_aTimeout, 0);
502cdf0e10cSrcweir
503cdf0e10cSrcweir m_nTimeoutMS = nMS;
504cdf0e10cSrcweir m_aTimeout += m_nTimeoutMS;
505cdf0e10cSrcweir
506cdf0e10cSrcweir if ((Timeout > m_aTimeout) || (Timeout.tv_sec == 0))
507cdf0e10cSrcweir {
508cdf0e10cSrcweir // Wakeup from previous timeout (or stopped timer).
509cdf0e10cSrcweir Wakeup();
510cdf0e10cSrcweir }
511cdf0e10cSrcweir }
512cdf0e10cSrcweir
AddToRecentDocumentList(const rtl::OUString &,const rtl::OUString &)513cdf0e10cSrcweir void SvpSalInstance::AddToRecentDocumentList(const rtl::OUString&, const rtl::OUString&)
514cdf0e10cSrcweir {
515cdf0e10cSrcweir }
516cdf0e10cSrcweir
~SvpSalTimer()517cdf0e10cSrcweir SvpSalTimer::~SvpSalTimer()
518cdf0e10cSrcweir {
519cdf0e10cSrcweir }
520cdf0e10cSrcweir
Stop()521cdf0e10cSrcweir void SvpSalTimer::Stop()
522cdf0e10cSrcweir {
523cdf0e10cSrcweir m_pInstance->StopTimer();
524cdf0e10cSrcweir }
525cdf0e10cSrcweir
Start(sal_uLong nMS)526cdf0e10cSrcweir void SvpSalTimer::Start( sal_uLong nMS )
527cdf0e10cSrcweir {
528cdf0e10cSrcweir m_pInstance->StartTimer( nMS );
529cdf0e10cSrcweir }
530cdf0e10cSrcweir
531