This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_BWin.h
executable file
·636 lines (541 loc) · 17.3 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
BWIN_SET_TITLE,
58
BWIN_SET_BORDERED,
59
BWIN_FULLSCREEN
60
61
};
62
63
class SDL_BWin:public BDirectWindow
64
{
65
public:
66
/* Constructor/Destructor */
67
68
SDL_BWin(BRect bounds, window_look look, uint32 flags)
: BDirectWindow(bounds, "Untitled", look, B_NORMAL_WINDOW_FEEL, flags)
69
{
70
_last_buttons = 0;
71
72
#if SDL_VIDEO_OPENGL
73
_SDL_GLView = NULL;
74
#endif
75
_shown = false;
76
77
78
79
_inhibit_resize = false;
_mouse_focused = false;
_prev_frame = NULL;
80
/* Handle framebuffer stuff */
81
_connected = _connection_disabled = false;
82
_buffer_created = _buffer_dirty = false;
83
_trash_window_buffer = false;
84
_buffer_locker = new BLocker();
85
_bitmap = NULL;
86
#ifdef DRAWTHREAD
87
88
89
_draw_thread_id = spawn_thread(BE_DrawThread, "drawing_thread",
B_NORMAL_PRIORITY, (void*) this);
resume_thread(_draw_thread_id);
90
#endif
91
92
93
94
95
}
virtual ~ SDL_BWin()
{
Lock();
96
_connection_disabled = true;
97
int32 result;
98
99
#if SDL_VIDEO_OPENGL
100
101
if (_SDL_GLView) {
_SDL_GLView->UnlockGL();
102
103
RemoveChild(_SDL_GLView); /* Why was this outside the if
statement before? */
104
}
105
106
#endif
107
Unlock();
108
#if SDL_VIDEO_OPENGL
109
110
if (_SDL_GLView) {
delete _SDL_GLView;
111
}
112
#endif
113
114
/* Clean up framebuffer stuff */
115
_buffer_locker->Lock();
116
#ifdef DRAWTHREAD
117
wait_for_thread(_draw_thread_id, &result);
118
#endif
119
free(_clips);
120
delete _buffer_locker;
121
}
122
123
124
/* * * * * OpenGL functionality * * * * */
125
#if SDL_VIDEO_OPENGL
126
virtual BGLView *CreateGLView(Uint32 gl_flags) {
127
Lock();
128
129
130
131
132
if (_SDL_GLView == NULL) {
_SDL_GLView = new BGLView(Bounds(), "SDL GLView",
B_FOLLOW_ALL_SIDES,
(B_WILL_DRAW | B_FRAME_EVENTS),
gl_flags);
133
}
134
AddChild(_SDL_GLView);
135
_SDL_GLView->EnableDirectMode(true);
136
_SDL_GLView->LockGL(); /* "New" GLViews are created */
137
Unlock();
138
return (_SDL_GLView);
139
}
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
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();
}
155
#endif
156
157
158
/* * * * * Framebuffering* * * * */
virtual void DirectConnected(direct_buffer_info *info) {
159
if(!_connected && _connection_disabled) {
160
161
return;
}
162
163
164
165
/* Determine if the pixel buffer is usable after this update */
_trash_window_buffer = _trash_window_buffer
|| ((info->buffer_state & B_BUFFER_RESIZED)
166
167
|| (info->buffer_state & B_BUFFER_RESET)
|| (info->driver_state == B_MODE_CHANGED));
168
LockBuffer();
169
170
171
172
173
174
175
176
177
178
179
switch(info->buffer_state & B_DIRECT_MODE_MASK) {
case B_DIRECT_START:
_connected = true;
case B_DIRECT_MODIFY:
if(_clips) {
free(_clips);
_clips = NULL;
}
180
181
_num_clips = info->clip_list_count;
_clips = (clipping_rect *)malloc(_num_clips*sizeof(clipping_rect));
182
183
if(_clips) {
memcpy(_clips, info->clip_list,
184
_num_clips*sizeof(clipping_rect));
185
186
_bits = (uint8*) info->bits;
187
_row_bytes = info->bytes_per_row;
188
_bounds = info->window_bounds;
189
_bytes_per_px = info->bits_per_pixel / 8;
190
_buffer_dirty = true;
191
192
193
194
195
196
197
}
break;
case B_DIRECT_STOP:
_connected = false;
break;
}
198
199
200
201
202
#if SDL_VIDEO_OPENGL
if(_SDL_GLView) {
_SDL_GLView->DirectConnected(info);
}
#endif
203
204
205
206
207
/* Call the base object directconnected */
BDirectWindow::DirectConnected(info);
208
UnlockBuffer();
209
210
211
212
}
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/* * * * * 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);
231
232
msg.AddInt32("window-w", (int)width + 1);
233
msg.AddInt32("window-h", (int)height + 1);
234
235
236
237
238
239
240
241
242
_PostWindowEvent(msg);
/* Perform normal hook operations */
BDirectWindow::FrameResized(width, height);
}
virtual bool QuitRequested() {
BMessage msg(BAPP_WINDOW_CLOSE_REQUESTED);
_PostWindowEvent(msg);
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
/* 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 */
260
261
if( !_prev_frame )
_prev_frame = new BRect(Frame());
262
263
264
265
266
267
268
/* Perform normal hook operations */
BDirectWindow::Zoom(origin, width, height);
}
/* Member functions */
virtual void Show() {
269
270
271
while(IsHidden()) {
BDirectWindow::Show();
}
272
_shown = true;
273
274
275
276
277
278
279
280
BMessage msg(BAPP_SHOW);
_PostWindowEvent(msg);
}
virtual void Hide() {
BDirectWindow::Hide();
_shown = false;
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
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)
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
358
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;
}
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
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;
376
377
378
case BWIN_SET_BORDERED:
_SetBordered(message);
break;
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
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;
}
403
}
404
405
406
407
408
409
/* Accessor methods */
bool IsShown() { return _shown; }
int32 GetID() { return _id; }
410
uint32 GetRowBytes() { return _row_bytes; }
411
412
int32 GetFbX() { return _bounds.left; }
int32 GetFbY() { return _bounds.top; }
413
bool ConnectionEnabled() { return !_connection_disabled; }
414
415
bool Connected() { return _connected; }
clipping_rect *GetClips() { return _clips; }
416
int32 GetNumClips() { return _num_clips; }
417
uint8* GetBufferPx() { return _bits; }
418
int32 GetBytesPerPx() { return _bytes_per_px; }
419
bool CanTrashWindowBuffer() { return _trash_window_buffer; }
420
421
bool BufferExists() { return _buffer_created; }
bool BufferIsDirty() { return _buffer_dirty; }
422
BBitmap *GetBitmap() { return _bitmap; }
423
424
425
#if SDL_VIDEO_OPENGL
BGLView *GetGLView() { return _SDL_GLView; }
#endif
426
427
428
/* Setter methods */
void SetID(int32 id) { _id = id; }
429
void SetBufferExists(bool bufferExists) { _buffer_created = bufferExists; }
430
431
432
void LockBuffer() { _buffer_locker->Lock(); }
void UnlockBuffer() { _buffer_locker->Unlock(); }
void SetBufferDirty(bool bufferDirty) { _buffer_dirty = bufferDirty; }
433
void SetTrashBuffer(bool trash) { _trash_window_buffer = trash; }
434
void SetBitmap(BBitmap *bitmap) { _bitmap = bitmap; }
435
436
437
438
439
440
441
private:
/* Event redirection */
void _MouseMotionEvent(BPoint &where, int32 transit) {
if(transit == B_EXITED_VIEW) {
/* Change mouse focus */
442
if(_mouse_focused) {
443
444
445
446
_MouseFocusEvent(false);
}
} else {
/* Change mouse focus */
447
if (!_mouse_focused) {
448
449
450
_MouseFocusEvent(true);
}
BMessage msg(BAPP_MOUSE_MOVED);
451
452
453
msg.AddInt32("x", (int)where.x);
msg.AddInt32("y", (int)where.y);
454
455
_PostWindowEvent(msg);
}
456
}
457
458
void _MouseFocusEvent(bool focusGained) {
459
_mouse_focused = focusGained;
460
461
462
463
464
465
466
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);
467
}
468
469
void _MouseButtonEvent(int32 buttons) {
470
int32 buttonStateChange = buttons ^ _last_buttons;
471
472
473
474
475
476
477
478
/* Make sure at least one button has changed state */
if( !(buttonStateChange) ) {
return;
}
/* Add any mouse button events */
if(buttonStateChange & B_PRIMARY_MOUSE_BUTTON) {
479
480
_SendMouseButton(SDL_BUTTON_LEFT, buttons &
B_PRIMARY_MOUSE_BUTTON);
481
482
}
if(buttonStateChange & B_SECONDARY_MOUSE_BUTTON) {
483
484
_SendMouseButton(SDL_BUTTON_RIGHT, buttons &
B_PRIMARY_MOUSE_BUTTON);
485
486
}
if(buttonStateChange & B_TERTIARY_MOUSE_BUTTON) {
487
488
_SendMouseButton(SDL_BUTTON_MIDDLE, buttons &
B_PRIMARY_MOUSE_BUTTON);
489
490
}
491
_last_buttons = buttons;
492
}
493
494
495
496
497
498
void _SendMouseButton(int32 button, int32 state) {
BMessage msg(BAPP_MOUSE_BUTTON);
msg.AddInt32("button-id", button);
msg.AddInt32("button-state", state);
_PostWindowEvent(msg);
499
}
500
501
502
503
504
505
506
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);
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
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);
}
560
561
562
563
564
565
566
567
568
void _SetBordered(BMessage *msg) {
bool bEnabled;
if(msg->FindInt32("window-border", &bEnabled) != B_OK) {
return;
}
SetLook(bEnabled ? B_BORDERED_WINDOW_LOOK : B_NO_BORDER_WINDOW_LOOK);
}
569
570
571
572
573
void _Restore() {
if(IsMinimized()) {
Minimize(false);
} else if(IsHidden()) {
Show();
574
575
576
} else if(_prev_frame != NULL) { /* Zoomed */
MoveTo(_prev_frame->left, _prev_frame->top);
ResizeTo(_prev_frame->Width(), _prev_frame->Height());
577
}
578
579
}
580
581
582
583
584
585
586
587
588
589
590
void _SetFullScreen(BMessage *msg) {
bool fullscreen;
if(
msg->FindBool("fullscreen", &fullscreen) != B_OK
) {
return;
}
SetFullScreen(fullscreen);
}
/* Members */
591
#if SDL_VIDEO_OPENGL
592
BGLView * _SDL_GLView;
593
#endif
594
595
int32 _last_buttons;
596
int32 _id; /* Window id used by SDL_BApp */
597
598
599
bool _mouse_focused; /* Does this window have mouse focus? */
bool _shown;
bool _inhibit_resize;
600
601
BRect *_prev_frame; /* Previous position and size of the window */
602
603
/* Framebuffer members */
604
605
606
bool _connected,
_connection_disabled,
_buffer_created,
607
608
_buffer_dirty,
_trash_window_buffer;
609
610
uint8 *_bits;
uint32 _row_bytes;
611
clipping_rect _bounds;
612
613
614
615
BLocker *_buffer_locker;
clipping_rect *_clips;
int32 _num_clips;
int32 _bytes_per_px;
616
thread_id _draw_thread_id;
617
618
BBitmap *_bitmap;
619
620
};
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
/* 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.
*/
636
#endif