1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef INCLUDED_VCL_INC_SALUSEREVENTLIST_HXX
#define INCLUDED_VCL_INC_SALUSEREVENTLIST_HXX
#include <sal/config.h>
#include <vcl/dllapi.h>
#include <osl/mutex.hxx>
#include <osl/thread.hxx>
#include <assert.h>
#include <list>
#include <unordered_set>
class SalFrame;
enum class SalEvent;
struct SalFrameHash : public std::hash<sal_IntPtr>
{
size_t operator()(const SalFrame* frame) const
{ return std::hash<sal_IntPtr>::operator()( reinterpret_cast<const sal_IntPtr>(frame) ); }
};
typedef std::unordered_set< SalFrame*, SalFrameHash > SalFrameSet;
class VCL_PLUGIN_PUBLIC SalUserEventList
{
public:
struct SalUserEvent
{
SalFrame* m_pFrame;
void* m_pData;
SalEvent m_nEvent;
SalUserEvent( SalFrame* pFrame, void* pData, SalEvent nEvent )
: m_pFrame( pFrame ),
m_pData( pData ),
m_nEvent( nEvent )
{}
bool operator==(const SalUserEvent &aEvent) const
{
return m_pFrame == aEvent.m_pFrame
&& m_pData == aEvent.m_pData
&& m_nEvent== aEvent.m_nEvent;
}
};
protected:
mutable osl::Mutex m_aUserEventsMutex;
std::list< SalUserEvent > m_aUserEvents;
std::list< SalUserEvent > m_aProcessingUserEvents;
bool m_bAllUserEventProcessedSignaled;
SalFrameSet m_aFrames;
oslThreadIdentifier m_aProcessingThread;
virtual void ProcessEvent( SalUserEvent aEvent ) = 0;
virtual void TriggerUserEventProcessing() = 0;
virtual void TriggerAllUserEventsProcessed() {};
public:
SalUserEventList();
virtual ~SalUserEventList();
inline const SalFrameSet& getFrames() const;
inline SalFrame* anyFrame() const;
void insertFrame( SalFrame* pFrame );
void eraseFrame( SalFrame* pFrame );
inline bool isFrameAlive( const SalFrame* pFrame ) const;
void PostEvent( SalFrame* pFrame, void* pData, SalEvent nEvent );
bool RemoveEvent( SalFrame* pFrame, void* pData, SalEvent nEvent );
inline bool HasUserEvents() const;
bool DispatchUserEvents( bool bHandleAllCurrentEvents );
};
inline SalFrame* SalUserEventList::anyFrame() const
{
if ( m_aFrames.empty() )
return nullptr;
return *m_aFrames.begin();
}
inline bool SalUserEventList::isFrameAlive( const SalFrame* pFrame ) const
{
auto it = m_aFrames.find( const_cast<SalFrame*>( pFrame ) );
return it != m_aFrames.end();
}
inline bool SalUserEventList::HasUserEvents() const
{
osl::MutexGuard aGuard( m_aUserEventsMutex );
return !(m_aUserEvents.empty() && m_aProcessingUserEvents.empty());
}
inline void SalUserEventList::PostEvent( SalFrame* pFrame, void* pData, SalEvent nEvent )
{
osl::MutexGuard aGuard( m_aUserEventsMutex );
m_aUserEvents.push_back( SalUserEvent( pFrame, pData, nEvent ) );
m_bAllUserEventProcessedSignaled = false;
TriggerUserEventProcessing();
}
inline const SalFrameSet& SalUserEventList::getFrames() const
{
return m_aFrames;
}
#endif // INCLUDED_VCL_INC_SALUSEREVENTLIST_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
