]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/threadsgi.cpp
minor tab height bug fix
[wxWidgets.git] / src / gtk / threadsgi.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/threadsgi.cpp
3 // Purpose: wxThread (SGI) Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
5 // Modified by:
6 // Created: 04/22/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #include "wx/thread.h"
16
17 #ifndef WX_PRECOMP
18 #include "wx/log.h"
19 #include "wx/utils.h"
20 #include "wx/module.h"
21 #endif
22
23 #include <stdio.h>
24 #include <unistd.h>
25
26 #include <signal.h>
27 #include <sys/wait.h>
28 #include <sys/prctl.h>
29
30 #include "gdk/gdk.h"
31 #include "gtk/gtk.h"
32
33 enum thread_state
34 {
35 STATE_IDLE = 0,
36 STATE_RUNNING,
37 STATE_CANCELED,
38 STATE_EXITED
39 };
40
41 /////////////////////////////////////////////////////////////////////////////
42 // Static variables
43 /////////////////////////////////////////////////////////////////////////////
44
45 static int p_mainid;
46 wxMutex *wxMainMutex;
47
48 #include "threadgui.inc"
49
50 /////////////////////////////////////////////////////////////////////////////
51 // Unix implementations (SGI threads)
52 /////////////////////////////////////////////////////////////////////////////
53
54 class wxMutexInternal {
55 public:
56 abilock_t p_mutex;
57 };
58
59 wxMutex::wxMutex()
60 {
61 m_locked = 0;
62 p_internal = new wxMutexInternal;
63 init_lock(&(p_internal->p_mutex));
64 }
65
66 wxMutex::~wxMutex()
67 {
68 if (m_locked > 0)
69 wxLogDebug( "wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked );
70 delete p_internal;
71 }
72
73 wxMutexError wxMutex::Lock()
74 {
75 spin_lock(&(p_internal->p_mutex));
76 m_locked++;
77 return wxMUTEX_NO_ERROR;
78 }
79
80 wxMutexError wxMutex::TryLock()
81 {
82 if (acquire_lock(&(p_internal->p_mutex)) != 0)
83 return wxMUTEX_BUSY;
84 m_locked++;
85 return wxMUTEX_NO_ERROR;
86 }
87
88 wxMutexError wxMutex::Unlock()
89 {
90 if (m_locked == 0)
91 return wxMUTEX_UNLOCKED;
92 release_lock(&(p_internal->p_mutex));
93 m_locked--;
94 return wxMUTEX_NO_ERROR;
95 }
96
97 // GL: Don't know how it works on SGI. Wolfram ?
98
99 wxCondition::wxCondition() {}
100 wxCondition::~wxCondition() {}
101 int wxCondition::Wait(wxMutex& WXUNUSED(mutex)) { return 0;}
102 int wxCondition::Wait(wxMutex& WXUNUSED(mutex), unsigned long WXUNUSED(sec),
103 unsigned long WXUNUSED(nsec)) { return 0; }
104 int wxCondition::Signal() { return 0; }
105 int wxCondition::Broadcast() { return 0; }
106
107 class
108 wxThreadPrivate {
109 public:
110 wxThreadPrivate() { thread_id = 0; state = STATE_IDLE; }
111 ~wxThreadPrivate() {}
112 static void SprocStart(void *ptr);
113 static void SignalHandler(int sig);
114 public:
115 int state, thread_id;
116 void* exit_status;
117 };
118
119 void wxThreadPrivate::SprocStart(void *ptr)
120 {
121 void* status;
122
123 wxThread *thr = (wxThread *)ptr;
124
125 thr->p_internal->thread_id = getpid();
126 thr->p_internal->exit_status = 0;
127 status = thr->Entry();
128 thr->Exit(status);
129 }
130
131 void wxThread::Exit(void* status)
132 {
133 wxThread* ptr = this;
134 THREAD_SEND_EXIT_MSG(ptr);
135 p_internal->state = STATE_EXITED;
136 p_internal->exit_status = status;
137 _exit(0);
138 }
139
140 wxThreadError wxThread::Create()
141 {
142 if (p_internal->state != STATE_IDLE)
143 return wxTHREAD_RUNNING;
144 p_internal->state = STATE_RUNNING;
145 if (sproc(p_internal->SprocStart, PR_SALL, this) < 0) {
146 p_internal->state = STATE_IDLE;
147 return wxTHREAD_NO_RESOURCE;
148 }
149 return wxTHREAD_NO_ERROR;
150 }
151
152 wxThreadError wxThread::Destroy()
153 {
154 if (p_internal->state == STATE_RUNNING)
155 p_internal->state = STATE_CANCELED;
156
157 return wxTHREAD_NO_ERROR;
158 }
159
160 wxThreadError wxThread::Pause()
161 {
162 return wxTHREAD_NO_ERROR;
163 }
164
165 wxThreadError wxThread::Resume()
166 {
167 return wxTHREAD_NO_ERROR;
168 }
169
170 void *wxThread::Join()
171 {
172 if (p_internal->state != STATE_IDLE) {
173 bool do_unlock = wxThread::IsMain();
174 int stat;
175
176 if (do_unlock)
177 wxMainMutex->Unlock();
178 waitpid(p_internal->thread_id, &stat, 0);
179 if (do_unlock)
180 wxMainMutex->Lock();
181 if (!WIFEXITED(stat) && !WIFSIGNALED(stat))
182 return 0;
183 p_internal->state = STATE_IDLE;
184 return p_internal->exit_status;
185 }
186 return 0;
187 }
188
189 unsigned long wxThread::GetID() const
190 {
191 return (unsigned long)p_internal->thread_id;
192 }
193
194 void wxThread::TestDestroy()
195 {
196 if (p_internal->state == STATE_CANCELED) {
197 p_internal->exit_status = 0;
198 _exit(0);
199 }
200 }
201
202 void wxThread::SetPriority(int prio)
203 {
204 }
205
206 int wxThread::GetPriority() const
207 {
208 return 0;
209 }
210
211 bool wxThread::IsMain()
212 {
213 return (int)getpid() == main_id;
214 }
215
216 bool wxThread::IsAlive() const
217 {
218 return (p_internal->state == STATE_RUNNING);
219 }
220
221 bool wxThread::IsRunning() const
222 {
223 return (p_internal->state == STATE_RUNNING);
224 }
225
226 wxThread::wxThread()
227 {
228 p_internal = new wxThreadPrivate();
229 }
230
231 wxThread::~wxThread()
232 {
233 Cancel();
234 Join();
235 delete p_internal;
236 }
237
238 // The default callback just joins the thread and throws away the result.
239 void wxThread::OnExit()
240 {
241 Join();
242 }
243
244 // Global initialization
245
246 class wxThreadModule : public wxModule
247 {
248 public:
249 virtual bool OnInit();
250 virtual void OnExit();
251
252 private:
253 DECLARE_DYNAMIC_CLASS(wxThreadModule)
254 };
255
256 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
257
258 bool wxThreadModule::OnInit()
259 {
260 wxMainMutex = new wxMutex();
261 wxThreadGuiInit();
262 p_mainid = (int)getpid();
263 wxMainMutex->Lock();
264 return true;
265 }
266
267 void wxThreadModule::OnExit()
268 {
269 wxMainMutex->Unlock();
270 wxThreadGuiExit();
271 delete wxMainMutex;
272 }