Mercurial > sdl-ios-xcode

comparison src/video/bwindow/SDL_BWin.h @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents e49147870aac
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
36 36
37 #include "../../main/beos/SDL_BeApp.h" 37 #include "../../main/beos/SDL_BeApp.h"
38 #include "SDL_events.h" 38 #include "SDL_events.h"
39 #include "SDL_BView.h" 39 #include "SDL_BView.h"
40 40
41 extern "C" { 41 extern "C"
42 {
42 #include "../../events/SDL_events_c.h" 43 #include "../../events/SDL_events_c.h"
43 }; 44 };
44 45
45 class SDL_BWin : public BDirectWindow 46 class SDL_BWin:public BDirectWindow
46 { 47 {
47 public: 48 public:
48 SDL_BWin(BRect bounds) : 49 SDL_BWin (BRect bounds):BDirectWindow (bounds, "Untitled",
49 BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) { 50 B_TITLED_WINDOW, 0)
50 InitKeyboard(); 51 {
51 last_buttons = 0; 52 InitKeyboard ();
52 53 last_buttons = 0;
53 the_view = NULL; 54
54 #if SDL_VIDEO_OPENGL 55 the_view = NULL;
55 SDL_GLView = NULL; 56 #if SDL_VIDEO_OPENGL
56 #endif 57 SDL_GLView = NULL;
57 SDL_View = NULL; 58 #endif
58 Unlock(); 59 SDL_View = NULL;
59 shown = false; 60 Unlock ();
60 inhibit_resize = false; 61 shown = false;
61 } 62 inhibit_resize = false;
62 63 }
63 virtual ~SDL_BWin() { 64
64 Lock(); 65 virtual ~ SDL_BWin ()
65 if ( the_view ) { 66 {
66 #if SDL_VIDEO_OPENGL 67 Lock ();
67 if ( the_view == SDL_GLView ) { 68 if (the_view) {
68 SDL_GLView->UnlockGL(); 69 #if SDL_VIDEO_OPENGL
69 } 70 if (the_view == SDL_GLView) {
70 #endif 71 SDL_GLView->UnlockGL ();
71 RemoveChild(the_view); 72 }
72 the_view = NULL; 73 #endif
73 } 74 RemoveChild (the_view);
74 Unlock(); 75 the_view = NULL;
75 #if SDL_VIDEO_OPENGL 76 }
76 if ( SDL_GLView ) { 77 Unlock ();
77 delete SDL_GLView; 78 #if SDL_VIDEO_OPENGL
78 } 79 if (SDL_GLView) {
79 #endif 80 delete SDL_GLView;
80 if ( SDL_View ) { 81 }
81 delete SDL_View; 82 #endif
82 } 83 if (SDL_View) {
83 } 84 delete SDL_View;
84 85 }
85 virtual void InitKeyboard(void) { 86 }
86 for ( uint i=0; i<SDL_TABLESIZE(keymap); ++i ) 87
87 keymap[i] = SDLK_UNKNOWN; 88 virtual void InitKeyboard (void)
88 89 {
89 keymap[0x01] = SDLK_ESCAPE; 90 for (uint i = 0; i < SDL_TABLESIZE (keymap); ++i)
90 keymap[B_F1_KEY] = SDLK_F1; 91 keymap[i] = SDLK_UNKNOWN;
91 keymap[B_F2_KEY] = SDLK_F2; 92
92 keymap[B_F3_KEY] = SDLK_F3; 93 keymap[0x01] = SDLK_ESCAPE;
93 keymap[B_F4_KEY] = SDLK_F4; 94 keymap[B_F1_KEY] = SDLK_F1;
94 keymap[B_F5_KEY] = SDLK_F5; 95 keymap[B_F2_KEY] = SDLK_F2;
95 keymap[B_F6_KEY] = SDLK_F6; 96 keymap[B_F3_KEY] = SDLK_F3;
96 keymap[B_F7_KEY] = SDLK_F7; 97 keymap[B_F4_KEY] = SDLK_F4;
97 keymap[B_F8_KEY] = SDLK_F8; 98 keymap[B_F5_KEY] = SDLK_F5;
98 keymap[B_F9_KEY] = SDLK_F9; 99 keymap[B_F6_KEY] = SDLK_F6;
99 keymap[B_F10_KEY] = SDLK_F10; 100 keymap[B_F7_KEY] = SDLK_F7;
100 keymap[B_F11_KEY] = SDLK_F11; 101 keymap[B_F8_KEY] = SDLK_F8;
101 keymap[B_F12_KEY] = SDLK_F12; 102 keymap[B_F9_KEY] = SDLK_F9;
102 keymap[B_PRINT_KEY] = SDLK_PRINT; 103 keymap[B_F10_KEY] = SDLK_F10;
103 keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK; 104 keymap[B_F11_KEY] = SDLK_F11;
104 keymap[B_PAUSE_KEY] = SDLK_PAUSE; 105 keymap[B_F12_KEY] = SDLK_F12;
105 keymap[0x11] = SDLK_BACKQUOTE; 106 keymap[B_PRINT_KEY] = SDLK_PRINT;
106 keymap[0x12] = SDLK_1; 107 keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK;
107 keymap[0x13] = SDLK_2; 108 keymap[B_PAUSE_KEY] = SDLK_PAUSE;
108 keymap[0x14] = SDLK_3; 109 keymap[0x11] = SDLK_BACKQUOTE;
109 keymap[0x15] = SDLK_4; 110 keymap[0x12] = SDLK_1;
110 keymap[0x16] = SDLK_5; 111 keymap[0x13] = SDLK_2;
111 keymap[0x17] = SDLK_6; 112 keymap[0x14] = SDLK_3;
112 keymap[0x18] = SDLK_7; 113 keymap[0x15] = SDLK_4;
113 keymap[0x19] = SDLK_8; 114 keymap[0x16] = SDLK_5;
114 keymap[0x1a] = SDLK_9; 115 keymap[0x17] = SDLK_6;
115 keymap[0x1b] = SDLK_0; 116 keymap[0x18] = SDLK_7;
116 keymap[0x1c] = SDLK_MINUS; 117 keymap[0x19] = SDLK_8;
117 keymap[0x1d] = SDLK_EQUALS; 118 keymap[0x1a] = SDLK_9;
118 keymap[0x1e] = SDLK_BACKSPACE; 119 keymap[0x1b] = SDLK_0;
119 keymap[0x1f] = SDLK_INSERT; 120 keymap[0x1c] = SDLK_MINUS;
120 keymap[0x20] = SDLK_HOME; 121 keymap[0x1d] = SDLK_EQUALS;
121 keymap[0x21] = SDLK_PAGEUP; 122 keymap[0x1e] = SDLK_BACKSPACE;
122 keymap[0x22] = SDLK_NUMLOCK; 123 keymap[0x1f] = SDLK_INSERT;
123 keymap[0x23] = SDLK_KP_DIVIDE; 124 keymap[0x20] = SDLK_HOME;
124 keymap[0x24] = SDLK_KP_MULTIPLY; 125 keymap[0x21] = SDLK_PAGEUP;
125 keymap[0x25] = SDLK_KP_MINUS; 126 keymap[0x22] = SDLK_NUMLOCK;
126 keymap[0x26] = SDLK_TAB; 127 keymap[0x23] = SDLK_KP_DIVIDE;
127 keymap[0x27] = SDLK_q; 128 keymap[0x24] = SDLK_KP_MULTIPLY;
128 keymap[0x28] = SDLK_w; 129 keymap[0x25] = SDLK_KP_MINUS;
129 keymap[0x29] = SDLK_e; 130 keymap[0x26] = SDLK_TAB;
130 keymap[0x2a] = SDLK_r; 131 keymap[0x27] = SDLK_q;
131 keymap[0x2b] = SDLK_t; 132 keymap[0x28] = SDLK_w;
132 keymap[0x2c] = SDLK_y; 133 keymap[0x29] = SDLK_e;
133 keymap[0x2d] = SDLK_u; 134 keymap[0x2a] = SDLK_r;
134 keymap[0x2e] = SDLK_i; 135 keymap[0x2b] = SDLK_t;
135 keymap[0x2f] = SDLK_o; 136 keymap[0x2c] = SDLK_y;
136 keymap[0x30] = SDLK_p; 137 keymap[0x2d] = SDLK_u;
137 keymap[0x31] = SDLK_LEFTBRACKET; 138 keymap[0x2e] = SDLK_i;
138 keymap[0x32] = SDLK_RIGHTBRACKET; 139 keymap[0x2f] = SDLK_o;
139 keymap[0x33] = SDLK_BACKSLASH; 140 keymap[0x30] = SDLK_p;
140 keymap[0x34] = SDLK_DELETE; 141 keymap[0x31] = SDLK_LEFTBRACKET;
141 keymap[0x35] = SDLK_END; 142 keymap[0x32] = SDLK_RIGHTBRACKET;
142 keymap[0x36] = SDLK_PAGEDOWN; 143 keymap[0x33] = SDLK_BACKSLASH;
143 keymap[0x37] = SDLK_KP7; 144 keymap[0x34] = SDLK_DELETE;
144 keymap[0x38] = SDLK_KP8; 145 keymap[0x35] = SDLK_END;
145 keymap[0x39] = SDLK_KP9; 146 keymap[0x36] = SDLK_PAGEDOWN;
146 keymap[0x3a] = SDLK_KP_PLUS; 147 keymap[0x37] = SDLK_KP7;
147 keymap[0x3b] = SDLK_CAPSLOCK; 148 keymap[0x38] = SDLK_KP8;
148 keymap[0x3c] = SDLK_a; 149 keymap[0x39] = SDLK_KP9;
149 keymap[0x3d] = SDLK_s; 150 keymap[0x3a] = SDLK_KP_PLUS;
150 keymap[0x3e] = SDLK_d; 151 keymap[0x3b] = SDLK_CAPSLOCK;
151 keymap[0x3f] = SDLK_f; 152 keymap[0x3c] = SDLK_a;
152 keymap[0x40] = SDLK_g; 153 keymap[0x3d] = SDLK_s;
153 keymap[0x41] = SDLK_h; 154 keymap[0x3e] = SDLK_d;
154 keymap[0x42] = SDLK_j; 155 keymap[0x3f] = SDLK_f;
155 keymap[0x43] = SDLK_k; 156 keymap[0x40] = SDLK_g;
156 keymap[0x44] = SDLK_l; 157 keymap[0x41] = SDLK_h;
157 keymap[0x45] = SDLK_SEMICOLON; 158 keymap[0x42] = SDLK_j;
158 keymap[0x46] = SDLK_QUOTE; 159 keymap[0x43] = SDLK_k;
159 keymap[0x47] = SDLK_RETURN; 160 keymap[0x44] = SDLK_l;
160 keymap[0x48] = SDLK_KP4; 161 keymap[0x45] = SDLK_SEMICOLON;
161 keymap[0x49] = SDLK_KP5; 162 keymap[0x46] = SDLK_QUOTE;
162 keymap[0x4a] = SDLK_KP6; 163 keymap[0x47] = SDLK_RETURN;
163 keymap[0x4b] = SDLK_LSHIFT; 164 keymap[0x48] = SDLK_KP4;
164 keymap[0x4c] = SDLK_z; 165 keymap[0x49] = SDLK_KP5;
165 keymap[0x4d] = SDLK_x; 166 keymap[0x4a] = SDLK_KP6;
166 keymap[0x4e] = SDLK_c; 167 keymap[0x4b] = SDLK_LSHIFT;
167 keymap[0x4f] = SDLK_v; 168 keymap[0x4c] = SDLK_z;
168 keymap[0x50] = SDLK_b; 169 keymap[0x4d] = SDLK_x;
169 keymap[0x51] = SDLK_n; 170 keymap[0x4e] = SDLK_c;
170 keymap[0x52] = SDLK_m; 171 keymap[0x4f] = SDLK_v;
171 keymap[0x53] = SDLK_COMMA; 172 keymap[0x50] = SDLK_b;
172 keymap[0x54] = SDLK_PERIOD; 173 keymap[0x51] = SDLK_n;
173 keymap[0x55] = SDLK_SLASH; 174 keymap[0x52] = SDLK_m;
174 keymap[0x56] = SDLK_RSHIFT; 175 keymap[0x53] = SDLK_COMMA;
175 keymap[0x57] = SDLK_UP; 176 keymap[0x54] = SDLK_PERIOD;
176 keymap[0x58] = SDLK_KP1; 177 keymap[0x55] = SDLK_SLASH;
177 keymap[0x59] = SDLK_KP2; 178 keymap[0x56] = SDLK_RSHIFT;
178 keymap[0x5a] = SDLK_KP3; 179 keymap[0x57] = SDLK_UP;
179 keymap[0x5b] = SDLK_KP_ENTER; 180 keymap[0x58] = SDLK_KP1;
180 keymap[0x5c] = SDLK_LCTRL; 181 keymap[0x59] = SDLK_KP2;
181 keymap[0x5d] = SDLK_LALT; 182 keymap[0x5a] = SDLK_KP3;
182 keymap[0x5e] = SDLK_SPACE; 183 keymap[0x5b] = SDLK_KP_ENTER;
183 keymap[0x5f] = SDLK_RALT; 184 keymap[0x5c] = SDLK_LCTRL;
184 keymap[0x60] = SDLK_RCTRL; 185 keymap[0x5d] = SDLK_LALT;
185 keymap[0x61] = SDLK_LEFT; 186 keymap[0x5e] = SDLK_SPACE;
186 keymap[0x62] = SDLK_DOWN; 187 keymap[0x5f] = SDLK_RALT;
187 keymap[0x63] = SDLK_RIGHT; 188 keymap[0x60] = SDLK_RCTRL;
188 keymap[0x64] = SDLK_KP0; 189 keymap[0x61] = SDLK_LEFT;
189 keymap[0x65] = SDLK_KP_PERIOD; 190 keymap[0x62] = SDLK_DOWN;
190 keymap[0x66] = SDLK_LMETA; 191 keymap[0x63] = SDLK_RIGHT;
191 keymap[0x67] = SDLK_RMETA; 192 keymap[0x64] = SDLK_KP0;
192 keymap[0x68] = SDLK_MENU; 193 keymap[0x65] = SDLK_KP_PERIOD;
193 keymap[0x69] = SDLK_EURO; 194 keymap[0x66] = SDLK_LMETA;
194 keymap[0x6a] = SDLK_KP_EQUALS; 195 keymap[0x67] = SDLK_RMETA;
195 keymap[0x6b] = SDLK_POWER; 196 keymap[0x68] = SDLK_MENU;
196 } 197 keymap[0x69] = SDLK_EURO;
197 198 keymap[0x6a] = SDLK_KP_EQUALS;
198 /* Override the Show() method so we can tell when we've been shown */ 199 keymap[0x6b] = SDLK_POWER;
199 virtual void Show(void) { 200 }
200 BWindow::Show(); 201
201 shown = true; 202 /* Override the Show() method so we can tell when we've been shown */
202 } 203 virtual void Show (void)
203 virtual bool Shown(void) { 204 {
204 return (shown); 205 BWindow::Show ();
205 } 206 shown = true;
206 /* If called, the next resize event will not be forwarded to SDL. */ 207 }
207 virtual void InhibitResize(void) { 208 virtual bool Shown (void)
208 inhibit_resize=true; 209 {
209 } 210 return (shown);
210 /* Handle resizing of the window */ 211 }
211 virtual void FrameResized(float width, float height) { 212 /* If called, the next resize event will not be forwarded to SDL. */
212 if(inhibit_resize) 213 virtual void InhibitResize (void)
213 inhibit_resize = false; 214 {
214 else 215 inhibit_resize = true;
215 SDL_PrivateResize((int)width, (int)height); 216 }
216 } 217 /* Handle resizing of the window */
217 virtual int CreateView(Uint32 flags, Uint32 gl_flags) { 218 virtual void FrameResized (float width, float height)
218 int retval; 219 {
219 220 if (inhibit_resize)
220 retval = 0; 221 inhibit_resize = false;
221 Lock(); 222 else
222 if ( flags & SDL_INTERNALOPENGL ) { 223 SDL_PrivateResize ((int) width, (int) height);
223 #if SDL_VIDEO_OPENGL 224 }
224 if ( SDL_GLView == NULL ) { 225 virtual int CreateView (Uint32 flags, Uint32 gl_flags)
225 SDL_GLView = new BGLView(Bounds(), "SDL GLView", 226 {
226 B_FOLLOW_ALL_SIDES, (B_WILL_DRAW|B_FRAME_EVENTS), 227 int retval;
227 gl_flags); 228
228 } 229 retval = 0;
229 if ( the_view != SDL_GLView ) { 230 Lock ();
230 if ( the_view ) { 231 if (flags & SDL_INTERNALOPENGL) {
231 RemoveChild(the_view); 232 #if SDL_VIDEO_OPENGL
232 } 233 if (SDL_GLView == NULL) {
233 AddChild(SDL_GLView); 234 SDL_GLView = new BGLView (Bounds (), "SDL GLView",
234 SDL_GLView->LockGL(); 235 B_FOLLOW_ALL_SIDES,
235 the_view = SDL_GLView; 236 (B_WILL_DRAW | B_FRAME_EVENTS),
236 } 237 gl_flags);
238 }
239 if (the_view != SDL_GLView) {
240 if (the_view) {
241 RemoveChild (the_view);
242 }
243 AddChild (SDL_GLView);
244 SDL_GLView->LockGL ();
245 the_view = SDL_GLView;
246 }
237 #else 247 #else
238 SDL_SetError("OpenGL support not enabled"); 248 SDL_SetError ("OpenGL support not enabled");
239 retval = -1; 249 retval = -1;
240 #endif 250 #endif
241 } else { 251 } else {
242 if ( SDL_View == NULL ) { 252 if (SDL_View == NULL) {
243 SDL_View = new SDL_BView(Bounds()); 253 SDL_View = new SDL_BView (Bounds ());
244 } 254 }
245 if ( the_view != SDL_View ) { 255 if (the_view != SDL_View) {
246 if ( the_view ) { 256 if (the_view) {
247 #if SDL_VIDEO_OPENGL 257 #if SDL_VIDEO_OPENGL
248 if ( the_view == SDL_GLView ) { 258 if (the_view == SDL_GLView) {
249 SDL_GLView->UnlockGL(); 259 SDL_GLView->UnlockGL ();
250 } 260 }
251 #endif 261 #endif
252 RemoveChild(the_view); 262 RemoveChild (the_view);
253 } 263 }
254 AddChild(SDL_View); 264 AddChild (SDL_View);
255 the_view = SDL_View; 265 the_view = SDL_View;
256 } 266 }
257 } 267 }
258 Unlock(); 268 Unlock ();
259 return(retval); 269 return (retval);
260 } 270 }
261 virtual void SetBitmap(BBitmap *bitmap) { 271 virtual void SetBitmap (BBitmap * bitmap)
262 SDL_View->SetBitmap(bitmap); 272 {
263 } 273 SDL_View->SetBitmap (bitmap);
264 virtual void SetXYOffset(int x, int y) { 274 }
265 #if SDL_VIDEO_OPENGL 275 virtual void SetXYOffset (int x, int y)
266 if ( the_view == SDL_GLView ) { 276 {
267 return; 277 #if SDL_VIDEO_OPENGL
268 } 278 if (the_view == SDL_GLView) {
269 #endif 279 return;
270 SDL_View->SetXYOffset(x, y); 280 }
271 } 281 #endif
272 virtual void GetXYOffset(int &x, int &y) { 282 SDL_View->SetXYOffset (x, y);
273 #if SDL_VIDEO_OPENGL 283 }
274 if ( the_view == SDL_GLView ) { 284 virtual void GetXYOffset (int &x, int &y)
275 x = 0; 285 {
276 y = 0; 286 #if SDL_VIDEO_OPENGL
277 return; 287 if (the_view == SDL_GLView) {
278 } 288 x = 0;
279 #endif 289 y = 0;
280 SDL_View->GetXYOffset(x, y); 290 return;
281 } 291 }
282 virtual bool BeginDraw(void) { 292 #endif
283 return(Lock()); 293 SDL_View->GetXYOffset (x, y);
284 } 294 }
285 virtual void DrawAsync(BRect updateRect) { 295 virtual bool BeginDraw (void)
286 SDL_View->DrawAsync(updateRect); 296 {
287 } 297 return (Lock ());
288 virtual void EndDraw(void) { 298 }
289 SDL_View->Sync(); 299 virtual void DrawAsync (BRect updateRect)
290 Unlock(); 300 {
291 } 301 SDL_View->DrawAsync (updateRect);
292 #if SDL_VIDEO_OPENGL 302 }
293 virtual void SwapBuffers(void) { 303 virtual void EndDraw (void)
294 SDL_GLView->UnlockGL(); 304 {
295 SDL_GLView->LockGL(); 305 SDL_View->Sync ();
296 SDL_GLView->SwapBuffers(); 306 Unlock ();
297 } 307 }
298 #endif 308 #if SDL_VIDEO_OPENGL
299 virtual BView *View(void) { 309 virtual void SwapBuffers (void)
300 return(the_view); 310 {
301 } 311 SDL_GLView->UnlockGL ();
302 312 SDL_GLView->LockGL ();
303 /* Hook functions -- overridden */ 313 SDL_GLView->SwapBuffers ();
304 virtual void Minimize(bool minimize) { 314 }
305 /* This is only called when mimimized, not when restored */ 315 #endif
306 //SDL_PrivateAppActive(minimize, SDL_APPACTIVE); 316 virtual BView *View (void)
307 BWindow::Minimize(minimize); 317 {
308 } 318 return (the_view);
309 virtual void WindowActivated(bool active) { 319 }
310 SDL_PrivateAppActive(active, SDL_APPINPUTFOCUS); 320
311 } 321 /* Hook functions -- overridden */
312 virtual bool QuitRequested(void) { 322 virtual void Minimize (bool minimize)
313 if ( SDL_BeAppActive > 0 ) { 323 {
314 SDL_PrivateQuit(); 324 /* This is only called when mimimized, not when restored */
315 /* We don't ever actually close the window here because 325 //SDL_PrivateAppActive(minimize, SDL_APPACTIVE);
316 the application should respond to the quit request, 326 BWindow::Minimize (minimize);
317 or ignore it as desired. 327 }
318 */ 328 virtual void WindowActivated (bool active)
319 return(false); 329 {
320 } 330 SDL_PrivateAppActive (active, SDL_APPINPUTFOCUS);
321 return(true); /* Close the app window */ 331 }
322 } 332 virtual bool QuitRequested (void)
323 virtual void Quit() { 333 {
324 if (!IsLocked()) 334 if (SDL_BeAppActive > 0) {
325 Lock(); 335 SDL_PrivateQuit ();
326 BDirectWindow::Quit(); 336 /* We don't ever actually close the window here because
327 } 337 the application should respond to the quit request,
328 338 or ignore it as desired.
329 virtual int16 Translate2Unicode(const char *buf) { 339 */
330 int32 state, srclen, dstlen; 340 return (false);
331 unsigned char destbuf[2]; 341 }
332 Uint16 unicode = 0; 342 return (true); /* Close the app window */
333 343 }
334 if ((uchar)buf[0] > 127) { 344 virtual void Quit ()
335 state = 0; 345 {
336 srclen = SDL_strlen(buf); 346 if (!IsLocked ())
337 dstlen = sizeof(destbuf); 347 Lock ();
338 convert_from_utf8(B_UNICODE_CONVERSION, buf, &srclen, (char *)destbuf, &dstlen, &state); 348 BDirectWindow::Quit ();
339 unicode = destbuf[0]; 349 }
340 unicode <<= 8; 350
341 unicode |= destbuf[1]; 351 virtual int16 Translate2Unicode (const char *buf)
342 } else 352 {
343 unicode = buf[0]; 353 int32 state, srclen, dstlen;
344 354 unsigned char destbuf[2];
345 /* For some reason function keys map to control characters */ 355 Uint16 unicode = 0;
356
357 if ((uchar) buf[0] > 127) {
358 state = 0;
359 srclen = SDL_strlen (buf);
360 dstlen = sizeof (destbuf);
361 convert_from_utf8 (B_UNICODE_CONVERSION, buf, &srclen,
362 (char *) destbuf, &dstlen, &state);
363 unicode = destbuf[0];
364 unicode <<= 8;
365 unicode |= destbuf[1];
366 } else
367 unicode = buf[0];
368
369 /* For some reason function keys map to control characters */
346 # define CTRL(X) ((X)-'@') 370 # define CTRL(X) ((X)-'@')
347 switch (unicode) { 371 switch (unicode) {
348 case CTRL('A'): 372 case CTRL ('A'):
349 case CTRL('B'): 373 case CTRL ('B'):
350 case CTRL('C'): 374 case CTRL ('C'):
351 case CTRL('D'): 375 case CTRL ('D'):
352 case CTRL('E'): 376 case CTRL ('E'):
353 case CTRL('K'): 377 case CTRL ('K'):
354 case CTRL('L'): 378 case CTRL ('L'):
355 case CTRL('P'): 379 case CTRL ('P'):
356 if ( ! (SDL_GetModState() & KMOD_CTRL) ) 380 if (!(SDL_GetModState () & KMOD_CTRL))
357 unicode = 0; 381 unicode = 0;
358 break; 382 break;
359 /* Keyboard input maps newline to carriage return */ 383 /* Keyboard input maps newline to carriage return */
360 case '\n': 384 case '\n':
361 unicode = '\r'; 385 unicode = '\r';
362 break; 386 break;
363 default: 387 default:
364 break; 388 break;
365 } 389 }
366 390
367 return unicode; 391 return unicode;
368 } 392 }
369 393
370 virtual void DispatchMessage(BMessage *msg, BHandler *target) { 394 virtual void DispatchMessage (BMessage * msg, BHandler * target)
371 switch (msg->what) { 395 {
372 case B_MOUSE_MOVED: 396 switch (msg->what) {
373 { 397 case B_MOUSE_MOVED:
374 BPoint where; 398 {
375 int32 transit; 399 BPoint where;
376 if (msg->FindPoint("where", &where) == B_OK && msg->FindInt32("be:transit", &transit) == B_OK) { 400 int32 transit;
377 if (transit == B_EXITED_VIEW) { 401 if (msg->FindPoint ("where", &where) == B_OK
378 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) { 402 && msg->FindInt32 ("be:transit", &transit) == B_OK) {
379 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); 403 if (transit == B_EXITED_VIEW) {
380 be_app->SetCursor(B_HAND_CURSOR); 404 if (SDL_GetAppState () & SDL_APPMOUSEFOCUS) {
381 } 405 SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS);
382 } else { 406 be_app->SetCursor (B_HAND_CURSOR);
383 int x, y; 407 }
384 if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) { 408 } else {
385 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); 409 int x, y;
386 SDL_SetCursor(NULL); 410 if (!(SDL_GetAppState () & SDL_APPMOUSEFOCUS)) {
387 } 411 SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS);
388 GetXYOffset(x, y); 412 SDL_SetCursor (NULL);
389 x = (int)where.x - x; 413 }
390 y = (int)where.y - y; 414 GetXYOffset (x, y);
391 SDL_PrivateMouseMotion(0, 0, x, y); 415 x = (int) where.x - x;
392 } 416 y = (int) where.y - y;
393 } 417 SDL_PrivateMouseMotion (0, 0, x, y);
394 break; 418 }
395 } 419 }
396 420 break;
397 case B_MOUSE_DOWN: 421 }
398 { 422
399 /* it looks like mouse down is send only for first clicked 423 case B_MOUSE_DOWN:
400 button, each next is not send while last one is holded */ 424 {
401 int32 buttons; 425 /* it looks like mouse down is send only for first clicked
402 int sdl_buttons = 0; 426 button, each next is not send while last one is holded */
403 if (msg->FindInt32("buttons", &buttons) == B_OK) { 427 int32 buttons;
404 /* Add any mouse button events */ 428 int sdl_buttons = 0;
405 if (buttons & B_PRIMARY_MOUSE_BUTTON) { 429 if (msg->FindInt32 ("buttons", &buttons) == B_OK) {
406 sdl_buttons |= SDL_BUTTON_LEFT; 430 /* Add any mouse button events */
407 } 431 if (buttons & B_PRIMARY_MOUSE_BUTTON) {
408 if (buttons & B_SECONDARY_MOUSE_BUTTON) { 432 sdl_buttons |= SDL_BUTTON_LEFT;
409 sdl_buttons |= SDL_BUTTON_RIGHT; 433 }
410 } 434 if (buttons & B_SECONDARY_MOUSE_BUTTON) {
411 if (buttons & B_TERTIARY_MOUSE_BUTTON) { 435 sdl_buttons |= SDL_BUTTON_RIGHT;
412 sdl_buttons |= SDL_BUTTON_MIDDLE; 436 }
413 } 437 if (buttons & B_TERTIARY_MOUSE_BUTTON) {
414 SDL_PrivateMouseButton(SDL_PRESSED, sdl_buttons, 0, 0); 438 sdl_buttons |= SDL_BUTTON_MIDDLE;
415 439 }
416 last_buttons = buttons; 440 SDL_PrivateMouseButton (SDL_PRESSED, sdl_buttons, 0, 0);
417 } 441
418 break; 442 last_buttons = buttons;
419 } 443 }
420 444 break;
421 case B_MOUSE_UP: 445 }
422 { 446
423 /* mouse up doesn't give which button was released, 447 case B_MOUSE_UP:
424 only state of buttons (after release, so it's always = 0), 448 {
425 which is not what we need ;] 449 /* mouse up doesn't give which button was released,
426 So we need to store button in mouse down, and restore 450 only state of buttons (after release, so it's always = 0),
427 in mouse up :( 451 which is not what we need ;]
428 mouse up is (similarly to mouse down) send only for 452 So we need to store button in mouse down, and restore
429 first button down (ie. it's no send if we click another button 453 in mouse up :(
430 without releasing previous one first) - but that's probably 454 mouse up is (similarly to mouse down) send only for
431 because of how drivers are written?, not BeOS itself. */ 455 first button down (ie. it's no send if we click another button
432 int32 buttons; 456 without releasing previous one first) - but that's probably
433 int sdl_buttons = 0; 457 because of how drivers are written?, not BeOS itself. */
434 if (msg->FindInt32("buttons", &buttons) == B_OK) { 458 int32 buttons;
435 /* Add any mouse button events */ 459 int sdl_buttons = 0;
436 if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) { 460 if (msg->FindInt32 ("buttons", &buttons) == B_OK) {
437 sdl_buttons |= SDL_BUTTON_LEFT; 461 /* Add any mouse button events */
438 } 462 if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) {
439 if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) { 463 sdl_buttons |= SDL_BUTTON_LEFT;
440 sdl_buttons |= SDL_BUTTON_RIGHT; 464 }
441 } 465 if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) {
442 if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) { 466 sdl_buttons |= SDL_BUTTON_RIGHT;
443 sdl_buttons |= SDL_BUTTON_MIDDLE; 467 }
444 } 468 if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) {
445 SDL_PrivateMouseButton(SDL_RELEASED, sdl_buttons, 0, 0); 469 sdl_buttons |= SDL_BUTTON_MIDDLE;
446 470 }
447 last_buttons = buttons; 471 SDL_PrivateMouseButton (SDL_RELEASED, sdl_buttons, 0, 0);
448 } 472
449 break; 473 last_buttons = buttons;
450 } 474 }
451 475 break;
452 case B_MOUSE_WHEEL_CHANGED: 476 }
453 { 477
454 float x, y; 478 case B_MOUSE_WHEEL_CHANGED:
455 x = y = 0; 479 {
456 if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK && msg->FindFloat("be:wheel_delta_y", &y) == B_OK) { 480 float x, y;
457 if (x < 0 || y < 0) { 481 x = y = 0;
458 SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0); 482 if (msg->FindFloat ("be:wheel_delta_x", &x) == B_OK
459 SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0); 483 && msg->FindFloat ("be:wheel_delta_y", &y) == B_OK) {
460 } else if (x > 0 || y > 0) { 484 if (x < 0 || y < 0) {
461 SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0); 485 SDL_PrivateMouseButton (SDL_PRESSED,
462 SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0); 486 SDL_BUTTON_WHEELDOWN, 0, 0);
463 } 487 SDL_PrivateMouseButton (SDL_RELEASED,
464 } 488 SDL_BUTTON_WHEELDOWN, 0, 0);
465 break; 489 } else if (x > 0 || y > 0) {
466 } 490 SDL_PrivateMouseButton (SDL_PRESSED,
467 491 SDL_BUTTON_WHEELUP, 0, 0);
468 case B_KEY_DOWN: 492 SDL_PrivateMouseButton (SDL_RELEASED,
469 case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */ 493 SDL_BUTTON_WHEELUP, 0, 0);
470 { 494 }
471 int32 key; 495 }
472 int32 modifiers; 496 break;
473 int32 key_repeat; 497 }
474 /* Workaround for SDL message queue being filled too fast because of BeOS own key-repeat mechanism */ 498
475 if (msg->FindInt32("be:key_repeat", &key_repeat) == B_OK && key_repeat > 0) 499 case B_KEY_DOWN:
476 break; 500 case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */
477 501 {
478 if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) { 502 int32 key;
479 SDL_keysym keysym; 503 int32 modifiers;
480 keysym.scancode = key; 504 int32 key_repeat;
481 if ((key > 0) && (key < 128)) { 505 /* Workaround for SDL message queue being filled too fast because of BeOS own key-repeat mechanism */
482 keysym.sym = keymap[key]; 506 if (msg->FindInt32 ("be:key_repeat", &key_repeat) == B_OK
483 } else { 507 && key_repeat > 0)
484 keysym.sym = SDLK_UNKNOWN; 508 break;
485 } 509
486 /* FIX THIS? 510 if (msg->FindInt32 ("key", &key) == B_OK
487 it seems SDL_PrivateKeyboard() changes mod value 511 && msg->FindInt32 ("modifiers", &modifiers) == B_OK) {
488 anyway, and doesn't care about what we setup here */ 512 SDL_keysym keysym;
489 keysym.mod = KMOD_NONE; 513 keysym.scancode = key;
490 keysym.unicode = 0; 514 if ((key > 0) && (key < 128)) {
491 if (SDL_TranslateUNICODE) { 515 keysym.sym = keymap[key];
492 const char *bytes; 516 } else {
493 if (msg->FindString("bytes", &bytes) == B_OK) { 517 keysym.sym = SDLK_UNKNOWN;
494 /* FIX THIS? 518 }
495 this cares only about first "letter", 519 /* FIX THIS?
496 so if someone maps some key to print 520 it seems SDL_PrivateKeyboard() changes mod value
497 "BeOS rulez!" only "B" will be used. */ 521 anyway, and doesn't care about what we setup here */
498 keysym.unicode = Translate2Unicode(bytes); 522 keysym.mod = KMOD_NONE;
499 } 523 keysym.unicode = 0;
500 } 524 if (SDL_TranslateUNICODE) {
501 SDL_PrivateKeyboard(SDL_PRESSED, &keysym); 525 const char *bytes;
502 } 526 if (msg->FindString ("bytes", &bytes) == B_OK) {
503 break; 527 /* FIX THIS?
504 } 528 this cares only about first "letter",
505 529 so if someone maps some key to print
506 case B_KEY_UP: 530 "BeOS rulez!" only "B" will be used. */
507 case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */ 531 keysym.unicode = Translate2Unicode (bytes);
508 { 532 }
509 int32 key; 533 }
510 int32 modifiers; 534 SDL_PrivateKeyboard (SDL_PRESSED, &keysym);
511 if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) { 535 }
512 SDL_keysym keysym; 536 break;
513 keysym.scancode = key; 537 }
514 if ((key > 0) && (key < 128)) { 538
515 keysym.sym = keymap[key]; 539 case B_KEY_UP:
516 } else { 540 case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */
517 keysym.sym = SDLK_UNKNOWN; 541 {
518 } 542 int32 key;
519 keysym.mod = KMOD_NONE; /* FIX THIS? */ 543 int32 modifiers;
520 keysym.unicode = 0; 544 if (msg->FindInt32 ("key", &key) == B_OK
521 if (SDL_TranslateUNICODE) { 545 && msg->FindInt32 ("modifiers", &modifiers) == B_OK) {
522 const char *bytes; 546 SDL_keysym keysym;
523 if (msg->FindString("bytes", &bytes) == B_OK) { 547 keysym.scancode = key;
524 keysym.unicode = Translate2Unicode(bytes); 548 if ((key > 0) && (key < 128)) {
525 } 549 keysym.sym = keymap[key];
526 } 550 } else {
527 SDL_PrivateKeyboard(SDL_RELEASED, &keysym); 551 keysym.sym = SDLK_UNKNOWN;
528 } 552 }
529 break; 553 keysym.mod = KMOD_NONE; /* FIX THIS? */
530 } 554 keysym.unicode = 0;
531 555 if (SDL_TranslateUNICODE) {
532 default: 556 const char *bytes;
533 /* move it after switch{} so it's always handled 557 if (msg->FindString ("bytes", &bytes) == B_OK) {
534 that way we keep BeOS feautures like: 558 keysym.unicode = Translate2Unicode (bytes);
535 - CTRL+Q to close window (and other shortcuts) 559 }
536 - PrintScreen to make screenshot into /boot/home 560 }
537 - etc.. */ 561 SDL_PrivateKeyboard (SDL_RELEASED, &keysym);
538 //BDirectWindow::DispatchMessage(msg, target); 562 }
539 break; 563 break;
540 } 564 }
541 BDirectWindow::DispatchMessage(msg, target); 565
542 } 566 default:
543 567 /* move it after switch{} so it's always handled
544 private: 568 that way we keep BeOS feautures like:
545 #if SDL_VIDEO_OPENGL 569 - CTRL+Q to close window (and other shortcuts)
546 BGLView *SDL_GLView; 570 - PrintScreen to make screenshot into /boot/home
547 #endif 571 - etc.. */
548 SDL_BView *SDL_View; 572 //BDirectWindow::DispatchMessage(msg, target);
549 BView *the_view; 573 break;
550 574 }
551 bool shown; 575 BDirectWindow::DispatchMessage (msg, target);
552 bool inhibit_resize; 576 }
553 577
554 int32 last_buttons; 578 private:
555 SDLKey keymap[128]; 579 #if SDL_VIDEO_OPENGL
580 BGLView * SDL_GLView;
581 #endif
582 SDL_BView *SDL_View;
583 BView *the_view;
584
585 bool shown;
586 bool inhibit_resize;
587
588 int32 last_buttons;
589 SDLKey keymap[128];
556 }; 590 };
557 591
558 #endif /* _SDL_BWin_h */ 592 #endif /* _SDL_BWin_h */
593 /* vi: set ts=4 sw=4 expandtab: */