Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1769 | yogev_ezra | 1 | #ifndef __MENUET_H_INCLUDED_ |
2 | #define __MENUET_H_INCLUDED_ |
||
3 | |||
4 | #include |
||
5 | |||
6 | // Menuet interface. |
||
7 | |||
8 | namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
||
9 | { |
||
10 | const char *DebugPrefix = "User program: "; |
||
11 | char CommandLine[257]; |
||
12 | |||
13 | struct TWindowData // Data for drawing a window. |
||
14 | { |
||
15 | unsigned short WindowType, HeaderType; |
||
16 | unsigned long WindowColor, HeaderColor, BorderColor, TitleColor; |
||
17 | const char *Title; |
||
18 | }; |
||
19 | |||
20 | struct TStartData // This structure is used only for MenuetOnStart function. |
||
21 | { |
||
22 | unsigned short Left, Width, Top, Height; // Initial window rectangle. |
||
23 | TWindowData WinData; |
||
24 | }; |
||
25 | |||
26 | typedef void **TThreadData; // Thread data are the fast identifier of thread, contains user dword in |
||
27 | //_ the zero element and stack beginning (or zero if it is unknown) in the first element. |
||
28 | //_ The stack will be deleted from dynamic memory at the finish of the thread if stack beginning is not zero. |
||
29 | |||
30 | struct TMutex; // Simple mutex can be locked only once at a time. |
||
31 | #define MENUET_MUTEX_INIT {} // Simple mutex initializer, cat be redefined in a realization of the library |
||
32 | |||
33 | struct TRecMutex; // Recursive mutex can be locked many times by a single thread at a time. |
||
34 | #define MENUET_REC_MUTEX_INIT {} // Recursive mutex initializer, cat be redefined in a realization of the library |
||
35 | |||
36 | // Some functions have two forms: the fast form with (thread_data) parameter and the form without it. |
||
37 | // Note: pass only thread data of current thread as (thread_data) parameter to these functions. |
||
38 | |||
39 | void Main(); // Main function is called at program startup. |
||
40 | void* ThreadMain(void *user = 0, void *stack_begin = 0); |
||
41 | // Called at thread startup, (user) is placed in thread data as a user dword, |
||
42 | //_ (stack_begin) is placed in thread data as a stack beginning. |
||
43 | //_ Return new value of stack beginning that can be changed in the thread data. |
||
44 | void GetWindowData(TWindowData &win_data); // Write current window data to (win_data). |
||
45 | void GetWindowData(TWindowData &win_data, TThreadData thread_data); |
||
46 | void SetWindowData(const TWindowData &win_data); // Replace current window data by (win_data). |
||
47 | void SetWindowData(const TWindowData &win_data, TThreadData thread_data); |
||
48 | void CloseWindow(); // Close current window when returning to message loop. |
||
49 | void CloseWindow(TThreadData thread_data); |
||
50 | void Redraw(int frame = 0); // Redraw current window immediately, if (frame) is positive redraw the frame too, |
||
51 | void Redraw(int frame, TThreadData thread_data); //_ if (frame) is negative redraw only invalideted window. |
||
52 | void Invalidate(int frame = 0); // Redraw current window when no message will be is the queue, |
||
53 | void Invalidate(int frame, TThreadData thread_data); //_ if (frame) is positive redraw the frame too, |
||
54 | //_ if (frame) is negative do nothing. |
||
55 | void MoveWindow(const int window_rect[/* 4 */]); // Move and resize current window. |
||
56 | |||
57 | void Abort(); // Abnormally terminate a program. |
||
58 | void ExitProcess(); // Exit from the process, don't call any destructors of global varyables |
||
59 | void ExitThread(); // Exit from the current thread |
||
60 | void ExitThread(TThreadData thread_data); |
||
61 | void ReturnMessageLoop(); // Return to the message loop of the thread. Exit from the thread |
||
62 | void ReturnMessageLoop(TThreadData thread_data); //_ if it is called from (MenuetOnStart). |
||
63 | |||
64 | void Delay(unsigned int time); // Delay the execution of the program during (time) hundredth seconds. |
||
65 | unsigned int Clock(); // Return the time from starting of the system to this moment in hundredth of seconds. |
||
66 | int GetPackedTime(); // Return the current time of day in binary-decimal format 0x00SSMMHH. |
||
67 | void GetTime(int t[/* 3 */]); // Write the current time to (t): t[0] = second, t[1] = minute, t[2] = hour. |
||
68 | int GetPackedDate(); // Return the current date in binary-decimal format 0x00YYDDMM. |
||
69 | void GetDate(int d[/* 3 */]); // Write the current date to (d): d[0] = day, d[1] = month, d[2] = year. |
||
70 | void GetTimeDate(int t[/* 6 */]); // Write the current time and date to (t): t[0] = second, |
||
71 | //_ t[1] = minute, t[2] = hour, t[3] = day, t[4] = month, t[5] = year. |
||
72 | void ReadCommonColors(unsigned int colors[/* 10 */]); // Writes standart window colors to (colors). |
||
73 | unsigned int GetProcessInfo(unsigned int *use_cpu, char process_name[/* 13 */], unsigned int *use_memory, |
||
74 | unsigned int *pid, int window_rect[/* 4 */], unsigned int pid_for = -1); |
||
75 | // Write (pid_for) process information to variables parameters points, return |
||
76 | //_ the number of processes. (pid_for) equal to (-1) means current process. |
||
77 | unsigned int GetPid(); // Return the current thread identifier (pid). |
||
78 | unsigned int GetPid(TThreadData thread_data); |
||
79 | TThreadData GetThreadData(); // Return the thread data of the current thread. |
||
80 | TThreadData GetThreadData(unsigned int pid); // Return the thread data of the thread with the given pid. |
||
81 | |||
82 | void* GetPicture(unsigned short &width, unsigned short &height); |
||
83 | void* GetPicture(unsigned short &width, unsigned short &height, TThreadData thread_data); |
||
84 | // Return the picture on the window and write its width and height to (width) and (height). |
||
85 | void SetPicture(void *picture, unsigned short width, unsigned short height); |
||
86 | void SetPicture(void *picture, unsigned short width, unsigned short height, TThreadData thread_data); |
||
87 | // Replace the picture on the window by the given picture with the given width and height. |
||
88 | void GetBorderHeader(unsigned short &border_size, unsigned short &header_size); |
||
89 | void GetBorderHeader(unsigned short &border_size, unsigned short &header_size, TThreadData thread_data); |
||
90 | // Write the border thickness to (border_size) and header height to (header_size). |
||
91 | void GetClientSize(unsigned short &width, unsigned short &height); |
||
92 | void GetClientSize(unsigned short &width, unsigned short &height, TThreadData thread_data); |
||
93 | // Write the client area width and height to (width) and (height) parameters. |
||
94 | void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height); |
||
95 | void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height, TThreadData thread_data); |
||
96 | // Write the client area size of window with the width (win_width) |
||
97 | //_ and height (win_height) to (width) and (height) parameters. |
||
98 | void GetScreenSize(unsigned short &width, unsigned short &height); |
||
99 | // Write the screen width and height to (width) and (height) parameters. |
||
100 | |||
101 | void InitMutex(TMutex *mutex); // Initialize the simple mutex. |
||
102 | void InitRecMutex(TRecMutex *mutex); // Initialize the recursive mutex. |
||
103 | bool TryLock(TMutex *mutex); // Try to lock the mutex without waitting, return true if lock. |
||
104 | bool TryLock(TRecMutex *mutex); |
||
105 | bool TryLock(TRecMutex *mutex, TThreadData thread_data); |
||
106 | bool TryLock(TRecMutex *mutex, unsigned int pid); |
||
107 | void Lock(TMutex *mutex); // Lock mutex and wait for it if this necessary. |
||
108 | void Lock(TRecMutex *mutex); |
||
109 | void Lock(TRecMutex *mutex, TThreadData thread_data); |
||
110 | void Lock(TRecMutex *mutex, unsigned int pid); |
||
111 | bool LockTime(TMutex *mutex, int time); |
||
112 | bool LockTime(TRecMutex *mutex, int time); // Lock mutex and wait for it during (time) hundredth seconds. |
||
113 | bool LockTime(TRecMutex *mutex, int time, TThreadData thread_data); |
||
114 | bool LockTime(TRecMutex *mutex, int time, unsigned int pid); |
||
115 | void UnLock(TMutex *mutex); // Unlock mutex |
||
116 | void UnLock(TRecMutex *mutex); |
||
117 | void UnLock(TRecMutex *mutex, TThreadData thread_data); |
||
118 | void UnLock(TRecMutex *mutex, unsigned int pid); |
||
119 | |||
120 | void DebugPutChar(char c); // Put the character to the debug board. |
||
121 | void DebugPutString(const char *s); // Put the string to the debug board. |
||
122 | int GetKey(); // Return key pressed by user or -1 if no key was pressed. |
||
123 | int GetMouseButton(); // Return buttons pressed: 0 - no buttons, 1 - left button, 2 - right button, 3 - both buttons. |
||
124 | void GetMousePosition(short &x, short &y, bool absolute = false); |
||
125 | // Write mouse position to (x) and (y): absolute if (absolute) is true and relative the window otherwise. |
||
126 | void GetMousePosPicture(short &x, short &y); |
||
127 | |||
128 | int GetThreadNumber(); // Return the number of threads currently executing. |
||
129 | bool WasThreadCreated(); // Return true if there was created at least one thread except the main thred. |
||
130 | unsigned int CreateThread(void *user = 0, unsigned int stack_size = 0, void *stack_end = 0); |
||
131 | // Create a new thread with the user dword (user) and stack pointer (stack_end). |
||
132 | //_ If (stack_end) is zero, create stack in dynamic memory of size (stack_size) or |
||
133 | //_ the same size as the main thread if (stack_size) less that 4096. Set the beginning |
||
134 | //_ of the stack if (stack_end) is zero or (stack_size) is not zero, in this case stack |
||
135 | //_ will be deleted automaticaly from dynamic memory at the finish of the thread. |
||
136 | } |
||
137 | |||
138 | // Function, defined outside. |
||
139 | |||
140 | bool MenuetOnStart(Menuet::TStartData &me_start, Menuet::TThreadData thread_data); |
||
141 | // Window will be created iff return value is true. |
||
142 | bool MenuetOnClose(Menuet::TThreadData thread_data); // Window will be closed iff return value is true. |
||
143 | int MenuetOnIdle(Menuet::TThreadData thread_data); // Return the time to wait next message. |
||
144 | void MenuetOnSize(int window_rect[/* 4 */], Menuet::TThreadData thread_data); // When the window is resized. |
||
145 | void MenuetOnKeyPress(Menuet::TThreadData thread_data); // When user press a key. |
||
146 | void MenuetOnMouse(Menuet::TThreadData thread_data); // When user move a mouse. |
||
147 | |||
148 | #ifdef __MENUET__ |
||
149 | |||
150 | namespace Menuet |
||
151 | { |
||
152 | // Structures. |
||
153 | |||
154 | struct TMutex // Simple mutex can be locked only once at a time. |
||
155 | { |
||
156 | unsigned int mut; |
||
157 | }; |
||
158 | #undef MENUET_MUTEX_INIT |
||
159 | #define MENUET_MUTEX_INIT {0x40} // Simple mutex initializer, cat be redefined in a realization of the library |
||
160 | |||
161 | struct TRecMutex // Recursive mutex can be locked many times by a single thread at a time. |
||
162 | { |
||
163 | unsigned int mut, pid; |
||
164 | }; |
||
165 | #undef MENUET_REC_MUTEX_INIT |
||
166 | #define MENUET_REC_MUTEX_INIT {0x20,-1} // Recursive mutex initializer, cat be redefined in a realization of the library |
||
167 | |||
168 | // Global variables. |
||
169 | |||
170 | volatile TThreadData _ThreadTable[256]; |
||
171 | volatile unsigned int _ThreadScanCount[2] = {0, 0}; |
||
172 | volatile int _ThreadNumber = 1; |
||
173 | volatile int _ExitProcessNow = 0; |
||
174 | TMutex _ThreadMutex = MENUET_MUTEX_INIT; |
||
175 | unsigned int _ThreadSavedBegProc[4]; |
||
176 | |||
177 | // Inline functions. |
||
178 | |||
179 | inline void GetWindowData(TWindowData &win_data) {GetWindowData(win_data, GetThreadData());} |
||
180 | |||
181 | inline void SetWindowData(const TWindowData &win_data) {SetWindowData(win_data, GetThreadData());} |
||
182 | |||
183 | inline void CloseWindow() {CloseWindow(GetThreadData());} |
||
184 | |||
185 | inline void Redraw(int frame) {Redraw(frame, GetThreadData());} |
||
186 | |||
187 | inline void Invalidate(int frame) {Invalidate(frame, GetThreadData());} |
||
188 | |||
189 | inline void* GetPicture(unsigned short &width, unsigned short &height) |
||
190 | { |
||
191 | return GetPicture(width, height, GetThreadData()); |
||
192 | } |
||
193 | |||
194 | inline void SetPicture(void *picture, unsigned short width, unsigned short height) |
||
195 | { |
||
196 | SetPicture(picture, width, height, GetThreadData()); |
||
197 | } |
||
198 | |||
199 | inline void GetBorderHeader(unsigned short &border_size, unsigned short &header_size) |
||
200 | { |
||
201 | GetBorderHeader(border_size, header_size, GetThreadData()); |
||
202 | } |
||
203 | |||
204 | inline void GetClientSize(unsigned short &width, unsigned short &height) |
||
205 | { |
||
206 | unsigned int pid; |
||
207 | int rect[4]; |
||
208 | GetProcessInfo(0, 0, 0, &pid, rect); |
||
209 | GetClientSize(width, height, rect[2], rect[3], GetThreadData(pid)); |
||
210 | } |
||
211 | |||
212 | inline void GetClientSize(unsigned short &width, unsigned short &height, TThreadData thread_data) |
||
213 | { |
||
214 | int rect[4]; |
||
215 | GetProcessInfo(0, 0, 0, 0, rect); |
||
216 | GetClientSize(width, height, rect[2], rect[3], thread_data); |
||
217 | } |
||
218 | |||
219 | inline void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height) |
||
220 | { |
||
221 | GetClientSize(width, height, win_width, win_height, GetThreadData()); |
||
222 | } |
||
223 | |||
224 | inline void GetTimeDate(int t[/* 6 */]) {GetTime(t); GetDate(t + 3);} |
||
225 | |||
226 | inline void InitMutex(TMutex *mutex) {mutex->mut = 0;} |
||
227 | |||
228 | inline void InitRecMutex(TRecMutex *mutex) {mutex->mut = 0; mutex->pid = -1;} |
||
229 | |||
230 | inline bool TryLock(TRecMutex *mutex) {return TryLock(mutex, GetPid());} |
||
231 | |||
232 | inline bool TryLock(TRecMutex *mutex, TThreadData thread_data) {return TryLock(mutex, GetPid(thread_data));} |
||
233 | |||
234 | inline void Lock(TRecMutex *mutex) {Lock(mutex, GetPid());} |
||
235 | |||
236 | inline void Lock(TRecMutex *mutex, TThreadData thread_data) {Lock(mutex, GetPid(thread_data));} |
||
237 | |||
238 | inline bool LockTime(TRecMutex *mutex, int time) {return LockTime(mutex, time, GetPid());} |
||
239 | |||
240 | inline bool LockTime(TRecMutex *mutex, int time, TThreadData thread_data) |
||
241 | {return LockTime(mutex, time, GetPid(thread_data));} |
||
242 | |||
243 | inline void UnLock(TRecMutex *mutex) {UnLock(mutex, GetPid());} |
||
244 | |||
245 | inline void UnLock(TRecMutex *mutex, TThreadData thread_data) {UnLock(mutex, GetPid(thread_data));} |
||
246 | |||
247 | inline int GetThreadNumber() {return _ThreadNumber;} |
||
248 | |||
249 | // Constants from fasm. |
||
250 | |||
251 | #include |
||
252 | |||
253 | // Functions. |
||
254 | |||
255 | unsigned char _HashByte(unsigned int value); |
||
256 | unsigned short _HashWord(unsigned int value); |
||
257 | unsigned int _HashDword(unsigned int value); |
||
258 | |||
259 | void _GetStartData(TStartData &start_data, TThreadData thread_data) |
||
260 | { |
||
261 | start_data.Left = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_X] >> 16); |
||
262 | start_data.Width = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_X]); |
||
263 | start_data.Top = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_Y] >> 16); |
||
264 | start_data.Height = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_Y]); |
||
265 | GetWindowData(start_data.WinData, thread_data); |
||
266 | } |
||
267 | |||
268 | void _SetStartData(const TStartData &start_data, TThreadData thread_data) |
||
269 | { |
||
270 | (unsigned long&)thread_data[MENUET_THREAD_DATA_X] = |
||
271 | ((unsigned int)start_data.Left << 16) | start_data.Width; |
||
272 | (unsigned long&)thread_data[MENUET_THREAD_DATA_Y] = |
||
273 | ((unsigned int)start_data.Top << 16) | start_data.Height; |
||
274 | SetWindowData(start_data.WinData, thread_data); |
||
275 | } |
||
276 | |||
277 | void _ApplyCommonColors(TWindowData &win_data) |
||
278 | { |
||
279 | unsigned int colors[10]; |
||
280 | ReadCommonColors(colors); |
||
281 | win_data.WindowColor = colors[5]; |
||
282 | win_data.HeaderColor = colors[1]; |
||
283 | win_data.BorderColor = colors[0]; |
||
284 | win_data.TitleColor = colors[4]; |
||
285 | } |
||
286 | |||
287 | void _SetValueFunctionPriority(void *beg, int n) |
||
288 | { |
||
289 | int k, i; |
||
290 | unsigned char num[256]; |
||
291 | for (i = 0; i < 256; i++) num[i] = 0; |
||
292 | for (k = 0; k < n; k++) |
||
293 | { |
||
294 | i = ((unsigned char*)beg + 6*k)[1]; |
||
295 | ((unsigned char*)beg + 6*k)[0] = num[i]; |
||
296 | if (num[i] != 255) num[i]++; |
||
297 | } |
||
298 | } |
||
299 | |||
300 | void _CallFunctionPriority(void *beg, void *end, bool reverse = false) |
||
301 | { |
||
302 | struct _Local |
||
303 | { |
||
304 | static int cmp(void *beg, int i, int j) |
||
305 | { |
||
306 | unsigned char *x = (unsigned char*)beg + 6*i; |
||
307 | unsigned char *y = (unsigned char*)beg + 6*j; |
||
308 | if (*(unsigned short*)x < *(unsigned short*)y) return -1; |
||
309 | if (*(unsigned short*)x > *(unsigned short*)y) return 1; |
||
310 | return 0; |
||
311 | } |
||
312 | |||
313 | static void swap(void *beg, int i, int j) |
||
314 | { |
||
315 | unsigned char *x = (unsigned char*)beg + 6*i; |
||
316 | unsigned char *y = (unsigned char*)beg + 6*j; |
||
317 | short s; |
||
318 | int t; |
||
319 | s = *(short*)x; *(short*)x = *(short*)y; *(short*)y = s; |
||
320 | x += 2; y += 2; |
||
321 | t = *(int*)x; *(int*)x = *(int*)y; *(int*)y = t; |
||
322 | } |
||
323 | |||
324 | static void call(void *beg, int i) |
||
325 | { |
||
326 | unsigned char *x = (unsigned char*)beg + 6*i; |
||
327 | (*(void(**)())(x+2))(); |
||
328 | } |
||
329 | }; |
||
330 | |||
331 | if (!beg || !end || end <= beg) return; |
||
332 | int i, j, k, m, n; |
||
333 | n = ((unsigned char*)end - (unsigned char*)beg) / 6; |
||
334 | if (n <= 0) return; |
||
335 | _SetValueFunctionPriority(beg, n); |
||
336 | m = n; k = n; |
||
337 | while (m > 1) |
||
338 | { |
||
339 | if (k > 0) k--; |
||
340 | else _Local::swap(beg, 0, --m); |
||
341 | j = k; |
||
342 | for (;;) |
||
343 | { |
||
344 | i = j; |
||
345 | if (2*i + 1 >= m) break; |
||
346 | if (_Local::cmp(beg, 2*i + 1, j) > 0) j = 2*i + 1; |
||
347 | if (2*i + 2 < m && _Local::cmp(beg, 2*i + 2, j) > 0) j = 2*i + 2; |
||
348 | if (i == j) break; |
||
349 | _Local::swap(beg, i, j); |
||
350 | } |
||
351 | } |
||
352 | if (!reverse) |
||
353 | { |
||
354 | for (k = 0; k < n; k++) _Local::call(beg, k); |
||
355 | } |
||
356 | else |
||
357 | { |
||
358 | for (k = n-1; k >= 0; k--) _Local::call(beg, k); |
||
359 | } |
||
360 | } |
||
361 | |||
362 | bool _CallStart(TThreadData thread_data, void *init = 0, void *init_end = 0) |
||
363 | { |
||
364 | struct _TThreadDataTemplate |
||
365 | { |
||
366 | unsigned int data[12]; |
||
367 | }; |
||
368 | static const _TThreadDataTemplate _ThreadDataTemplate = |
||
369 | {{3, 0x00320100, 0x00320100, 0x03FFFFFF, 0x806060FF, 0x00000000, 0x00FFFF40, 0, 0, 0, -1, -1}}; |
||
370 | |||
371 | unsigned int pid = GetPid(); |
||
372 | volatile TThreadData *thread_table_item; |
||
373 | Lock(&_ThreadMutex); |
||
374 | if (_ExitProcessNow) ExitProcess(); |
||
375 | thread_table_item = &_ThreadTable[_HashByte(pid)]; |
||
376 | thread_data[MENUET_THREAD_DATA_NEXT] = (void*)*thread_table_item; |
||
377 | (unsigned int&)thread_data[MENUET_THREAD_DATA_PID] = pid; |
||
378 | *(_TThreadDataTemplate*)(thread_data + MENUET_THREAD_DATA_FLAG) = _ThreadDataTemplate; |
||
379 | *thread_table_item = thread_data; |
||
380 | UnLock(&_ThreadMutex); |
||
381 | if (_ExitProcessNow) ExitProcess(); |
||
382 | _CallFunctionPriority(init, init_end, false); |
||
383 | TStartData start_data; |
||
384 | _GetStartData(start_data, thread_data); |
||
385 | _ApplyCommonColors(start_data.WinData); |
||
386 | (unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= 0x40000000; |
||
387 | thread_data[MENUET_THREAD_DATA_TITLE] = (void*)(&start_data); |
||
388 | if (!MenuetOnStart(start_data, thread_data)) return false; |
||
389 | (unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] &= ~0x40000000; |
||
390 | _SetStartData(start_data, thread_data); |
||
391 | return true; |
||
392 | } |
||
393 | |||
394 | void _RemoveThreadData(TThreadData thread_data, void *exit = 0, void *exit_end = 0) |
||
395 | { |
||
396 | _CallFunctionPriority(exit, exit_end, true); |
||
397 | volatile TThreadData *thread_table_item; |
||
398 | Lock(&_ThreadMutex); |
||
399 | if (_ExitProcessNow) ExitProcess(); |
||
400 | thread_table_item = &_ThreadTable[_HashByte(GetPid(thread_data))]; |
||
401 | while (*thread_table_item) |
||
402 | { |
||
403 | if (*thread_table_item == thread_data) |
||
404 | { |
||
405 | *thread_table_item = (TThreadData)thread_data[MENUET_THREAD_DATA_NEXT]; |
||
406 | break; |
||
407 | } |
||
408 | thread_table_item = (TThreadData*)(*thread_table_item + MENUET_THREAD_DATA_NEXT); |
||
409 | } |
||
410 | UnLock(&_ThreadMutex); |
||
411 | if (_ExitProcessNow) ExitProcess(); |
||
412 | } |
||
413 | |||
414 | void GetWindowData(TWindowData &win_data, TThreadData thread_data) |
||
415 | { |
||
416 | if ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) |
||
417 | { |
||
418 | win_data = ((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData; |
||
419 | return; |
||
420 | } |
||
421 | win_data.WindowType = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] >> 24); |
||
422 | win_data.HeaderType = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_C_HEADER] >> 24); |
||
423 | win_data.WindowColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] & 0xFFFFFF; |
||
424 | win_data.HeaderColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_HEADER] & 0xFFFFFF; |
||
425 | win_data.BorderColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_BORDER] & 0xFFFFFF; |
||
426 | win_data.TitleColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_TITLE] & 0xFFFFFF; |
||
427 | win_data.Title = (char*)thread_data[MENUET_THREAD_DATA_TITLE]; |
||
428 | } |
||
429 | |||
430 | void SetWindowData(const TWindowData &win_data, TThreadData thread_data) |
||
431 | { |
||
432 | if ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) |
||
433 | { |
||
434 | ((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData = win_data; |
||
435 | return; |
||
436 | } |
||
437 | (unsigned int&)thread_data[MENUET_THREAD_DATA_C_WINDOW] = |
||
438 | ((unsigned int)win_data.WindowType << 24) | (win_data.WindowColor & 0xFFFFFF); |
||
439 | (unsigned int&)thread_data[MENUET_THREAD_DATA_C_HEADER] = |
||
440 | ((unsigned int)win_data.HeaderType << 24) | (win_data.HeaderColor & 0xFFFFFF); |
||
441 | (unsigned int&)thread_data[MENUET_THREAD_DATA_C_BORDER] = win_data.BorderColor & 0xFFFFFF; |
||
442 | (unsigned int&)thread_data[MENUET_THREAD_DATA_C_TITLE] = win_data.TitleColor & 0xFFFFFF; |
||
443 | thread_data[MENUET_THREAD_DATA_TITLE] = (void*)win_data.Title; |
||
444 | Invalidate(1, thread_data); |
||
445 | } |
||
446 | |||
447 | void CloseWindow(TThreadData thread_data) |
||
448 | { |
||
449 | (unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= 0x80000000; |
||
450 | } |
||
451 | |||
452 | void Invalidate(int frame, TThreadData thread_data) |
||
453 | { |
||
454 | if (frame < 0) return; |
||
455 | (unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= (frame ? 3 : 1); |
||
456 | } |
||
457 | |||
458 | void* GetPicture(unsigned short &width, unsigned short &height, TThreadData thread_data) |
||
459 | { |
||
460 | width = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_SZ_PICT] >> 16); |
||
461 | height = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_SZ_PICT]); |
||
462 | return (void*)thread_data[MENUET_THREAD_DATA_PICTURE]; |
||
463 | } |
||
464 | |||
465 | void SetPicture(void *picture, unsigned short width, unsigned short height, TThreadData thread_data) |
||
466 | { |
||
467 | thread_data[MENUET_THREAD_DATA_PICTURE] = (void*)picture; |
||
468 | (unsigned int&)thread_data[MENUET_THREAD_DATA_SZ_PICT] = |
||
469 | (width == 0 || height == 0) ? 0 : (((unsigned int)width << 16) | height); |
||
470 | Invalidate(0, thread_data); |
||
471 | } |
||
472 | |||
473 | int _GetSkinHeader(); |
||
474 | |||
475 | void GetBorderHeader(unsigned short &border_size, unsigned short &header_size, TThreadData thread_data) |
||
476 | { |
||
477 | int win_type = ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) ? |
||
478 | ((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData.WindowType : |
||
479 | ((unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] >> 24); |
||
480 | border_size = MENUET_BORDER_SIZE; |
||
481 | header_size = short(((win_type & 15) == 3) ? _GetSkinHeader() : MENUET_HEADER_SIZE); |
||
482 | } |
||
483 | |||
484 | void GetClientSize(unsigned short &width, unsigned short &height, |
||
485 | int win_width, int win_height, TThreadData thread_data) |
||
486 | { |
||
487 | const int MAX_SIZE = 32767; |
||
488 | unsigned short border_size, header_size; |
||
489 | GetBorderHeader(border_size, header_size, thread_data); |
||
490 | win_width -= 2 * border_size; |
||
491 | win_height -= border_size + header_size; |
||
492 | if (win_width < 0) win_width = 0; |
||
493 | else if (win_width > MAX_SIZE) win_width = MAX_SIZE; |
||
494 | if (win_height < 0) win_height = 0; |
||
495 | else if (win_height > MAX_SIZE) win_height = MAX_SIZE; |
||
496 | width = (unsigned short)win_width; |
||
497 | height = (unsigned short)win_height; |
||
498 | } |
||
499 | |||
500 | void GetMousePosPicture(short &x, short &y) |
||
501 | { |
||
502 | unsigned short dx, dy; |
||
503 | GetMousePosition(x, y); |
||
504 | GetBorderHeader(dx, dy); |
||
505 | x -= dx; y -= dy; |
||
506 | } |
||
507 | } |
||
508 | |||
509 | #else // def __MENUET__ |
||
510 | |||
511 | namespace Menuet |
||
512 | { |
||
513 | struct TMutex |
||
514 | { |
||
515 | unsigned int mut; |
||
516 | |||
517 | TMutex(); |
||
518 | ~TMutex(); |
||
519 | }; |
||
520 | #undef MENUET_MUTEX_INIT |
||
521 | #define MENUET_MUTEX_INIT TMutex() |
||
522 | |||
523 | struct TRecMutex |
||
524 | { |
||
525 | unsigned int mut; |
||
526 | |||
527 | TRecMutex(); |
||
528 | ~TRecMutex(); |
||
529 | }; |
||
530 | #undef MENUET_REC_MUTEX_INIT |
||
531 | #define MENUET_REC_MUTEX_INIT TRecMutex() |
||
532 | } |
||
533 | |||
534 | #endif // else: def __MENUET__ |
||
535 | |||
536 | #endif // ndef __MENUET_H_INCLUDED_>>><>>><>><>>>=>=>>>>><>><> |
||
537 |