This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_BWin.h
executable file
·624 lines (530 loc) · 17 KB
1
/*
2
Simple DirectMedia Layer
3
Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
8
9
10
11
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
12
13
14
15
16
17
18
19
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
22
23
24
*/
#ifndef _SDL_BWin_h
#define _SDL_BWin_h
25
26
27
28
#ifdef __cplusplus
extern "C" {
#endif
29
#include "SDL_config.h"
30
31
#include "SDL.h"
#include "SDL_syswm.h"
32
#include "SDL_bframebuffer.h"
33
34
35
36
#ifdef __cplusplus
}
#endif
37
38
39
40
41
#include <stdio.h>
#include <AppKit.h>
#include <InterfaceKit.h>
#include <be/game/DirectWindow.h>
42
#if SDL_VIDEO_OPENGL
43
44
45
#include <be/opengl/GLView.h>
#endif
#include "SDL_events.h"
46
47
#include "../../main/beos/SDL_BApp.h"
48
49
50
51
52
53
54
55
enum WinCommands {
BWIN_MOVE_WINDOW,
BWIN_RESIZE_WINDOW,
BWIN_SHOW_WINDOW,
BWIN_HIDE_WINDOW,
BWIN_MAXIMIZE_WINDOW,
BWIN_MINIMIZE_WINDOW,
56
BWIN_RESTORE_WINDOW,
57
58
BWIN_SET_TITLE,
BWIN_FULLSCREEN
59
60
};
61
62
class SDL_BWin:public BDirectWindow
63
{
64
public:
65
/* Constructor/Destructor */
66
67
SDL_BWin(BRect bounds, uint32 flags):BDirectWindow(bounds, "Untitled",
B_TITLED_WINDOW, flags)
68
{
69
_last_buttons = 0;
70
71
#if SDL_VIDEO_OPENGL
72
_SDL_GLView = NULL;
73
#endif
74
_shown = false;
75
76
77
78
_inhibit_resize = false;
_mouse_focused = false;
_prev_frame = NULL;
79
/* Handle framebuffer stuff */
80
_connected = _connection_disabled = false;
81
_buffer_created = _buffer_dirty = false;
82
_trash_window_buffer = false;
83
_buffer_locker = new BLocker();
84
_bitmap = NULL;
85
#ifdef DRAWTHREAD
86
87
88
_draw_thread_id = spawn_thread(BE_DrawThread, "drawing_thread",
B_NORMAL_PRIORITY, (void*) this);
resume_thread(_draw_thread_id);
89
#endif
90
91
92
93
94
}
virtual ~ SDL_BWin()
{
Lock();
95
_connection_disabled = true;
96
int32 result;
97
98
#if SDL_VIDEO_OPENGL
99
100
if (_SDL_GLView) {
_SDL_GLView->UnlockGL();
101
102
RemoveChild(_SDL_GLView); /* Why was this outside the if
statement before? */
103
}
104
105
#endif
106
Unlock();
107
#if SDL_VIDEO_OPENGL
108
109
if (_SDL_GLView) {
delete _SDL_GLView;
110
}
111
#endif
112
113
/* Clean up framebuffer stuff */
114
_buffer_locker->Lock();
115
#ifdef DRAWTHREAD
116
wait_for_thread(_draw_thread_id, &result);
117
#endif
118
free(_clips);
119
delete _buffer_locker;
120
}
121
122
123
/* * * * * OpenGL functionality * * * * */
124
#if SDL_VIDEO_OPENGL
125
virtual BGLView *CreateGLView(Uint32 gl_flags) {
126
Lock();
127
128
129
130
131
if (_SDL_GLView == NULL) {
_SDL_GLView = new BGLView(Bounds(), "SDL GLView",
B_FOLLOW_ALL_SIDES,
(B_WILL_DRAW | B_FRAME_EVENTS),
gl_flags);
132
}
133
AddChild(_SDL_GLView);
134
_SDL_GLView->EnableDirectMode(true);
135
_SDL_GLView->LockGL(); /* "New" GLViews are created */
136
Unlock();
137
return (_SDL_GLView);
138
}
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
virtual void RemoveGLView() {
Lock();
if(_SDL_GLView) {
_SDL_GLView->UnlockGL();
RemoveChild(_SDL_GLView);
}
Unlock();
}
virtual void SwapBuffers(void) {
_SDL_GLView->UnlockGL();
_SDL_GLView->LockGL();
_SDL_GLView->SwapBuffers();
}
154
#endif
155
156
157
/* * * * * Framebuffering* * * * */
virtual void DirectConnected(direct_buffer_info *info) {
158
if(!_connected && _connection_disabled) {
159
160
return;
}
161
162
163
164
/* Determine if the pixel buffer is usable after this update */
_trash_window_buffer = _trash_window_buffer
|| ((info->buffer_state & B_BUFFER_RESIZED)
165
166
|| (info->buffer_state & B_BUFFER_RESET)
|| (info->driver_state == B_MODE_CHANGED));
167
LockBuffer();
168
169
170
171
172
173
174
175
176
177
178
switch(info->buffer_state & B_DIRECT_MODE_MASK) {
case B_DIRECT_START:
_connected = true;
case B_DIRECT_MODIFY:
if(_clips) {
free(_clips);
_clips = NULL;
}
179
180
_num_clips = info->clip_list_count;
_clips = (clipping_rect *)malloc(_num_clips*sizeof(clipping_rect));
181
182
if(_clips) {
memcpy(_clips, info->clip_list,
183
_num_clips*sizeof(clipping_rect));
184
185
_bits = (uint8*) info->bits;
186
_row_bytes = info->bytes_per_row;
187
_bounds = info->window_bounds;
188
_bytes_per_px = info->bits_per_pixel / 8;
189
_buffer_dirty = true;
190
191
192
193
194
195
196
}
break;
case B_DIRECT_STOP:
_connected = false;
break;
}
197
198
199
200
201
#if SDL_VIDEO_OPENGL
if(_SDL_GLView) {
_SDL_GLView->DirectConnected(info);
}
#endif
202
203
204
205
206
/* Call the base object directconnected */
BDirectWindow::DirectConnected(info);
207
UnlockBuffer();
208
209
210
211
}
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
/* * * * * Event sending * * * * */
/* Hook functions */
virtual void FrameMoved(BPoint origin) {
/* Post a message to the BApp so that it can handle the window event */
BMessage msg(BAPP_WINDOW_MOVED);
msg.AddInt32("window-x", (int)origin.x);
msg.AddInt32("window-y", (int)origin.y);
_PostWindowEvent(msg);
/* Perform normal hook operations */
BDirectWindow::FrameMoved(origin);
}
virtual void FrameResized(float width, float height) {
/* Post a message to the BApp so that it can handle the window event */
BMessage msg(BAPP_WINDOW_RESIZED);
230
231
msg.AddInt32("window-w", (int)width + 1);
232
msg.AddInt32("window-h", (int)height + 1);
233
234
235
236
237
238
239
240
241
_PostWindowEvent(msg);
/* Perform normal hook operations */
BDirectWindow::FrameResized(width, height);
}
virtual bool QuitRequested() {
BMessage msg(BAPP_WINDOW_CLOSE_REQUESTED);
_PostWindowEvent(msg);
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/* We won't allow a quit unless asked by DestroyWindow() */
return false;
}
virtual void WindowActivated(bool active) {
BMessage msg(BAPP_KEYBOARD_FOCUS); /* Mouse focus sold separately */
_PostWindowEvent(msg);
}
virtual void Zoom(BPoint origin,
float width,
float height) {
BMessage msg(BAPP_MAXIMIZE); /* Closest thing to maximization Haiku has */
_PostWindowEvent(msg);
/* Before the window zooms, record its size */
259
260
if( !_prev_frame )
_prev_frame = new BRect(Frame());
261
262
263
264
265
266
267
/* Perform normal hook operations */
BDirectWindow::Zoom(origin, width, height);
}
/* Member functions */
virtual void Show() {
268
269
270
while(IsHidden()) {
BDirectWindow::Show();
}
271
_shown = true;
272
273
274
275
276
277
278
279
BMessage msg(BAPP_SHOW);
_PostWindowEvent(msg);
}
virtual void Hide() {
BDirectWindow::Hide();
_shown = false;
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
BMessage msg(BAPP_HIDE);
_PostWindowEvent(msg);
}
virtual void Minimize(bool minimize) {
BDirectWindow::Minimize(minimize);
int32 minState = (minimize ? BAPP_MINIMIZE : BAPP_RESTORE);
BMessage msg(minState);
_PostWindowEvent(msg);
}
/* BView message interruption */
virtual void DispatchMessage(BMessage * msg, BHandler * target)
296
{
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
BPoint where; /* Used by mouse moved */
int32 buttons; /* Used for mouse button events */
int32 key; /* Used for key events */
switch (msg->what) {
case B_MOUSE_MOVED:
int32 transit;
if (msg->FindPoint("where", &where) == B_OK
&& msg->FindInt32("be:transit", &transit) == B_OK) {
_MouseMotionEvent(where, transit);
}
/* FIXME: Apparently a button press/release event might be dropped
if made before before a different button is released. Does
B_MOUSE_MOVED have the data needed to check if a mouse button
state has changed? */
if (msg->FindInt32("buttons", &buttons) == B_OK) {
_MouseButtonEvent(buttons);
}
break;
case B_MOUSE_DOWN:
case B_MOUSE_UP:
/* _MouseButtonEvent() detects any and all buttons that may have
changed state, as well as that button's new state */
if (msg->FindInt32("buttons", &buttons) == B_OK) {
_MouseButtonEvent(buttons);
}
break;
case B_MOUSE_WHEEL_CHANGED:
float x, y;
if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK
&& msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {
_MouseWheelEvent((int)x, (int)y);
}
break;
case B_KEY_DOWN:
case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */
if (msg->FindInt32("key", &key) == B_OK) {
_KeyEvent((SDL_Scancode)key, SDL_PRESSED);
}
break;
case B_KEY_UP:
case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */
if (msg->FindInt32("key", &key) == B_OK) {
_KeyEvent(key, SDL_RELEASED);
}
break;
default:
/* move it after switch{} so it's always handled
that way we keep BeOS feautures like:
- CTRL+Q to close window (and other shortcuts)
- PrintScreen to make screenshot into /boot/home
- etc.. */
//BDirectWindow::DispatchMessage(msg, target);
break;
}
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
BDirectWindow::DispatchMessage(msg, target);
}
/* Handle command messages */
virtual void MessageReceived(BMessage* message) {
switch (message->what) {
/* Handle commands from SDL */
case BWIN_SET_TITLE:
_SetTitle(message);
break;
case BWIN_MOVE_WINDOW:
_MoveTo(message);
break;
case BWIN_RESIZE_WINDOW:
_ResizeTo(message);
break;
case BWIN_SHOW_WINDOW:
Show();
break;
case BWIN_HIDE_WINDOW:
Hide();
break;
case BWIN_MAXIMIZE_WINDOW:
BWindow::Zoom();
break;
case BWIN_MINIMIZE_WINDOW:
Minimize(true);
break;
case BWIN_RESTORE_WINDOW:
_Restore();
break;
case BWIN_FULLSCREEN:
_SetFullScreen(message);
break;
default:
/* Perform normal message handling */
BDirectWindow::MessageReceived(message);
break;
}
399
}
400
401
402
403
404
405
/* Accessor methods */
bool IsShown() { return _shown; }
int32 GetID() { return _id; }
406
uint32 GetRowBytes() { return _row_bytes; }
407
408
int32 GetFbX() { return _bounds.left; }
int32 GetFbY() { return _bounds.top; }
409
bool ConnectionEnabled() { return !_connection_disabled; }
410
411
bool Connected() { return _connected; }
clipping_rect *GetClips() { return _clips; }
412
int32 GetNumClips() { return _num_clips; }
413
uint8* GetBufferPx() { return _bits; }
414
int32 GetBytesPerPx() { return _bytes_per_px; }
415
bool CanTrashWindowBuffer() { return _trash_window_buffer; }
416
417
bool BufferExists() { return _buffer_created; }
bool BufferIsDirty() { return _buffer_dirty; }
418
BBitmap *GetBitmap() { return _bitmap; }
419
420
421
#if SDL_VIDEO_OPENGL
BGLView *GetGLView() { return _SDL_GLView; }
#endif
422
423
424
/* Setter methods */
void SetID(int32 id) { _id = id; }
425
void SetBufferExists(bool bufferExists) { _buffer_created = bufferExists; }
426
427
428
void LockBuffer() { _buffer_locker->Lock(); }
void UnlockBuffer() { _buffer_locker->Unlock(); }
void SetBufferDirty(bool bufferDirty) { _buffer_dirty = bufferDirty; }
429
void SetTrashBuffer(bool trash) { _trash_window_buffer = trash; }
430
void SetBitmap(BBitmap *bitmap) { _bitmap = bitmap; }
431
432
433
434
435
436
437
private:
/* Event redirection */
void _MouseMotionEvent(BPoint &where, int32 transit) {
if(transit == B_EXITED_VIEW) {
/* Change mouse focus */
438
if(_mouse_focused) {
439
440
441
442
_MouseFocusEvent(false);
}
} else {
/* Change mouse focus */
443
if (!_mouse_focused) {
444
445
446
_MouseFocusEvent(true);
}
BMessage msg(BAPP_MOUSE_MOVED);
447
448
449
msg.AddInt32("x", (int)where.x);
msg.AddInt32("y", (int)where.y);
450
451
_PostWindowEvent(msg);
}
452
}
453
454
void _MouseFocusEvent(bool focusGained) {
455
_mouse_focused = focusGained;
456
457
458
459
460
461
462
BMessage msg(BAPP_MOUSE_FOCUS);
msg.AddBool("focusGained", focusGained);
_PostWindowEvent(msg);
//FIXME: Why were these here?
// if false: be_app->SetCursor(B_HAND_CURSOR);
// if true: SDL_SetCursor(NULL);
463
}
464
465
void _MouseButtonEvent(int32 buttons) {
466
int32 buttonStateChange = buttons ^ _last_buttons;
467
468
469
470
471
472
473
474
/* Make sure at least one button has changed state */
if( !(buttonStateChange) ) {
return;
}
/* Add any mouse button events */
if(buttonStateChange & B_PRIMARY_MOUSE_BUTTON) {
475
476
_SendMouseButton(SDL_BUTTON_LEFT, buttons &
B_PRIMARY_MOUSE_BUTTON);
477
478
}
if(buttonStateChange & B_SECONDARY_MOUSE_BUTTON) {
479
480
_SendMouseButton(SDL_BUTTON_RIGHT, buttons &
B_PRIMARY_MOUSE_BUTTON);
481
482
}
if(buttonStateChange & B_TERTIARY_MOUSE_BUTTON) {
483
484
_SendMouseButton(SDL_BUTTON_MIDDLE, buttons &
B_PRIMARY_MOUSE_BUTTON);
485
486
}
487
_last_buttons = buttons;
488
}
489
490
491
492
493
494
void _SendMouseButton(int32 button, int32 state) {
BMessage msg(BAPP_MOUSE_BUTTON);
msg.AddInt32("button-id", button);
msg.AddInt32("button-state", state);
_PostWindowEvent(msg);
495
}
496
497
498
499
500
501
502
void _MouseWheelEvent(int32 x, int32 y) {
/* Create a message to pass along to the BeApp thread */
BMessage msg(BAPP_MOUSE_WHEEL);
msg.AddInt32("xticks", x);
msg.AddInt32("yticks", y);
_PostWindowEvent(msg);
503
}
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
void _KeyEvent(int32 keyCode, int32 keyState) {
/* Create a message to pass along to the BeApp thread */
BMessage msg(BAPP_KEY);
msg.AddInt32("key-state", keyState);
msg.AddInt32("key-scancode", keyCode);
be_app->PostMessage(&msg);
/* Apparently SDL only uses the scancode */
}
void _RepaintEvent() {
/* Force a repaint: Call the SDL exposed event */
BMessage msg(BAPP_REPAINT);
_PostWindowEvent(msg);
}
void _PostWindowEvent(BMessage &msg) {
msg.AddInt32("window-id", _id);
be_app->PostMessage(&msg);
}
/* Command methods (functions called upon by SDL) */
void _SetTitle(BMessage *msg) {
const char *title;
if(
msg->FindString("window-title", &title) != B_OK
) {
return;
}
SetTitle(title);
}
void _MoveTo(BMessage *msg) {
int32 x, y;
if(
msg->FindInt32("window-x", &x) != B_OK ||
msg->FindInt32("window-y", &y) != B_OK
) {
return;
}
MoveTo(x, y);
}
void _ResizeTo(BMessage *msg) {
int32 w, h;
if(
msg->FindInt32("window-w", &w) != B_OK ||
msg->FindInt32("window-h", &h) != B_OK
) {
return;
}
ResizeTo(w, h);
}
void _Restore() {
if(IsMinimized()) {
Minimize(false);
} else if(IsHidden()) {
Show();
562
563
564
} else if(_prev_frame != NULL) { /* Zoomed */
MoveTo(_prev_frame->left, _prev_frame->top);
ResizeTo(_prev_frame->Width(), _prev_frame->Height());
565
}
566
567
}
568
569
570
571
572
573
574
575
576
577
578
void _SetFullScreen(BMessage *msg) {
bool fullscreen;
if(
msg->FindBool("fullscreen", &fullscreen) != B_OK
) {
return;
}
SetFullScreen(fullscreen);
}
/* Members */
579
#if SDL_VIDEO_OPENGL
580
BGLView * _SDL_GLView;
581
#endif
582
583
int32 _last_buttons;
584
int32 _id; /* Window id used by SDL_BApp */
585
586
587
bool _mouse_focused; /* Does this window have mouse focus? */
bool _shown;
bool _inhibit_resize;
588
589
BRect *_prev_frame; /* Previous position and size of the window */
590
591
/* Framebuffer members */
592
593
594
bool _connected,
_connection_disabled,
_buffer_created,
595
596
_buffer_dirty,
_trash_window_buffer;
597
598
uint8 *_bits;
uint32 _row_bytes;
599
clipping_rect _bounds;
600
601
602
603
BLocker *_buffer_locker;
clipping_rect *_clips;
int32 _num_clips;
int32 _bytes_per_px;
604
thread_id _draw_thread_id;
605
606
BBitmap *_bitmap;
607
608
};
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
/* FIXME:
* An explanation of framebuffer flags.
*
* _connected - Original variable used to let the drawing thread know
* when changes are being made to the other framebuffer
* members.
* _connection_disabled - Used to signal to the drawing thread that the window
* is closing, and the thread should exit.
* _buffer_created - True if the current buffer is valid
* _buffer_dirty - True if the window should be redrawn.
* _trash_window_buffer - True if the window buffer needs to be trashed partway
* through a draw cycle. Occurs when the previous
* buffer provided by DirectConnected() is invalidated.
*/
624
#endif