[sdl_omap.git] / src / video / bwindow / SDL_BWin.h

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/

#ifndef _SDL_BWin_h
#define _SDL_BWin_h

#include "SDL_config.h"

#include <stdio.h>
#include <AppKit.h>
#include <InterfaceKit.h>
#include <be/game/DirectWindow.h>
#if SDL_VIDEO_OPENGL
#include <be/opengl/GLView.h>
#endif
#include <support/UTF8.h>

#include "../../main/beos/SDL_BeApp.h"
#include "SDL_events.h"
#include "SDL_BView.h"

extern "C" {
#include "../../events/SDL_events_c.h"

extern int mouse_relative;
};

class SDL_BWin : public BDirectWindow
{
public:
	SDL_BWin(BRect bounds) :
			BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) {
		last_buttons = 0;
		the_view = NULL;
#if SDL_VIDEO_OPENGL
		SDL_GLView = NULL;
#endif
		SDL_View = NULL;
		Unlock();
		shown = false;
		inhibit_resize = false;
	}

	virtual ~SDL_BWin() {
		Lock();
		if ( the_view ) {
#if SDL_VIDEO_OPENGL
			if ( the_view == SDL_GLView ) {
				SDL_GLView->UnlockGL();
			}
#endif
			RemoveChild(the_view);
			the_view = NULL;
		}
		Unlock();
#if SDL_VIDEO_OPENGL
		if ( SDL_GLView ) {
			delete SDL_GLView;
		}
#endif
		if ( SDL_View ) {
			delete SDL_View;
		}
	}
	

	/* Override the Show() method so we can tell when we've been shown */
	virtual void Show(void) {
		BWindow::Show();
		shown = true;
	}
	virtual bool Shown(void) {
		return (shown);
	}
	/* If called, the next resize event will not be forwarded to SDL. */
	virtual void InhibitResize(void) {
		inhibit_resize=true;
	}
	/* Handle resizing of the window */
	virtual void FrameResized(float width, float height) {
		if(inhibit_resize)
			inhibit_resize = false;
		else 
			SDL_PrivateResize((int)width, (int)height);
	}
	virtual int CreateView(Uint32 flags, Uint32 gl_flags) {
		int retval;

		retval = 0;
		Lock();
		if ( flags & SDL_OPENGL ) {
#if SDL_VIDEO_OPENGL
			if ( SDL_GLView == NULL ) {
				SDL_GLView = new BGLView(Bounds(), "SDL GLView",
					 	B_FOLLOW_ALL_SIDES, (B_WILL_DRAW|B_FRAME_EVENTS),
					 	gl_flags);
				SDL_GLView->EnableDirectMode(true);
			}
			if ( the_view != SDL_GLView ) {
				if ( the_view ) {
					RemoveChild(the_view);
				}
				AddChild(SDL_GLView);
				SDL_GLView->LockGL();
				the_view = SDL_GLView;
			}
#else
			SDL_SetError("OpenGL support not enabled");
			retval = -1;
#endif
		} else {
			if ( SDL_View == NULL ) {
				SDL_View = new SDL_BView(Bounds());
			}
			if ( the_view != SDL_View ) {
				if ( the_view ) {
#if SDL_VIDEO_OPENGL
					if ( the_view == SDL_GLView ) {
						SDL_GLView->UnlockGL();
					}
#endif
					RemoveChild(the_view);
				}
				AddChild(SDL_View);
				the_view = SDL_View;
			}
		}
		Unlock();
		return(retval);
	}
	virtual void SetBitmap(BBitmap *bitmap) {
		SDL_View->SetBitmap(bitmap);
	}
	virtual void SetXYOffset(int x, int y) {
#if SDL_VIDEO_OPENGL
		if ( the_view == SDL_GLView ) {
			return;
		}
#endif
		SDL_View->SetXYOffset(x, y);
	}
	virtual void GetXYOffset(int &x, int &y) {
#if SDL_VIDEO_OPENGL
		if ( the_view == SDL_GLView ) {
			x = 0;
			y = 0;
			return;
		}
#endif
		SDL_View->GetXYOffset(x, y);
	}
	virtual void GetXYOffset(float &x, float &y) {
#if SDL_VIDEO_OPENGL
		if ( the_view == SDL_GLView ) {
			x = 0.0f;
			y = 0.0f;
			return;
		}
#endif
		SDL_View->GetXYOffset(x, y);
	}
	virtual bool BeginDraw(void) {
		return(Lock());
	}
	virtual void DrawAsync(BRect updateRect) {
		SDL_View->DrawAsync(updateRect);
	}
	virtual void EndDraw(void) {
		SDL_View->Sync();
		Unlock();
	}
#if SDL_VIDEO_OPENGL
	virtual void SwapBuffers(void) {
		SDL_GLView->UnlockGL();
		SDL_GLView->LockGL();
		SDL_GLView->SwapBuffers();
	}
#endif
	virtual BView *View(void) {
		return(the_view);
	}

	/* Hook functions -- overridden */
	virtual void Minimize(bool minimize) {
		/* This is only called when mimimized, not when restored */
		//SDL_PrivateAppActive(minimize, SDL_APPACTIVE);
		BWindow::Minimize(minimize);
	}
	virtual void WindowActivated(bool active) {
		SDL_PrivateAppActive(active, SDL_APPINPUTFOCUS);
	}
	virtual bool QuitRequested(void) {
		if ( SDL_BeAppActive > 0 ) {
			SDL_PrivateQuit();
			/* We don't ever actually close the window here because
			   the application should respond to the quit request,
			   or ignore it as desired.
			 */
			return(false);
		}
		return(true);	/* Close the app window */
	}
	virtual void Quit() {
		if (!IsLocked())
			Lock();
		BDirectWindow::Quit();
	}

	virtual int16 Translate2Unicode(const char *buf) {
		int32 state, srclen, dstlen;
		unsigned char destbuf[2];
		Uint16 unicode = 0;

		if ((uchar)buf[0] > 127) {
			state = 0;
			srclen = SDL_strlen(buf);
			dstlen = sizeof(destbuf);
			convert_from_utf8(B_UNICODE_CONVERSION, buf, &srclen, (char *)destbuf, &dstlen, &state);
			unicode = destbuf[0];
			unicode <<= 8;
			unicode |= destbuf[1];
		} else
			unicode = buf[0];

		/* For some reason function keys map to control characters */
# define CTRL(X)	((X)-'@')
		switch (unicode) {
		    case CTRL('A'):
		    case CTRL('B'):
		    case CTRL('C'):
		    case CTRL('D'):
		    case CTRL('E'):
		    case CTRL('K'):
		    case CTRL('L'):
		    case CTRL('P'):
			if ( ! (SDL_GetModState() & KMOD_CTRL) )
				unicode = 0;
			break;
			/* Keyboard input maps newline to carriage return */
			case '\n':
				unicode = '\r';
			break;
		    default:
			break;
		}

		return unicode;
	}

	virtual void DispatchMessage(BMessage *msg, BHandler *target);
	
	virtual void DirectConnected(direct_buffer_info *info);

private:
#if SDL_VIDEO_OPENGL
	BGLView *SDL_GLView;
#endif
	SDL_BView *SDL_View;
	BView *the_view;
	bool shown;
	bool inhibit_resize;
	int32 last_buttons;
};

#endif /* _SDL_BWin_h */
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22
	23	#ifndef _SDL_BWin_h
	24	#define _SDL_BWin_h
	25
	26	#include "SDL_config.h"
	27
	28	#include <stdio.h>
	29	#include <AppKit.h>
	30	#include <InterfaceKit.h>
	31	#include <be/game/DirectWindow.h>
	32	#if SDL_VIDEO_OPENGL
	33	#include <be/opengl/GLView.h>
	34	#endif
	35	#include <support/UTF8.h>
	36
	37	#include "../../main/beos/SDL_BeApp.h"
	38	#include "SDL_events.h"
	39	#include "SDL_BView.h"
	40
	41	extern "C" {
	42	#include "../../events/SDL_events_c.h"
	43
	44	extern int mouse_relative;
	45	};
	46
	47	class SDL_BWin : public BDirectWindow
	48	{
	49	public:
	50	SDL_BWin(BRect bounds) :
	51	BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) {
	52	last_buttons = 0;
	53	the_view = NULL;
	54	#if SDL_VIDEO_OPENGL
	55	SDL_GLView = NULL;
	56	#endif
	57	SDL_View = NULL;
	58	Unlock();
	59	shown = false;
	60	inhibit_resize = false;
	61	}
	62
	63	virtual ~SDL_BWin() {
	64	Lock();
65	if ( the_view ) {
66	#if SDL_VIDEO_OPENGL
67	if ( the_view == SDL_GLView ) {
68	SDL_GLView->UnlockGL();
69	}
70	#endif
71	RemoveChild(the_view);
72	the_view = NULL;
73	}
74	Unlock();
75	#if SDL_VIDEO_OPENGL
76	if ( SDL_GLView ) {
77	delete SDL_GLView;
78	}
79	#endif
80	if ( SDL_View ) {
81	delete SDL_View;
82	}
83	}
84
85
86	/* Override the Show() method so we can tell when we've been shown */
87	virtual void Show(void) {
88	BWindow::Show();
89	shown = true;
90	}
91	virtual bool Shown(void) {
92	return (shown);
93	}
94	/* If called, the next resize event will not be forwarded to SDL. */
95	virtual void InhibitResize(void) {
96	inhibit_resize=true;
97	}
98	/* Handle resizing of the window */
99	virtual void FrameResized(float width, float height) {
100	if(inhibit_resize)
101	inhibit_resize = false;
102	else
103	SDL_PrivateResize((int)width, (int)height);
104	}
105	virtual int CreateView(Uint32 flags, Uint32 gl_flags) {
106	int retval;
107
108	retval = 0;
109	Lock();
110	if ( flags & SDL_OPENGL ) {
111	#if SDL_VIDEO_OPENGL
112	if ( SDL_GLView == NULL ) {
113	SDL_GLView = new BGLView(Bounds(), "SDL GLView",
114	B_FOLLOW_ALL_SIDES, (B_WILL_DRAW\|B_FRAME_EVENTS),
115	gl_flags);
116	SDL_GLView->EnableDirectMode(true);
117	}
118	if ( the_view != SDL_GLView ) {
119	if ( the_view ) {
120	RemoveChild(the_view);
121	}
122	AddChild(SDL_GLView);
123	SDL_GLView->LockGL();
124	the_view = SDL_GLView;
125	}
126	#else
127	SDL_SetError("OpenGL support not enabled");
128	retval = -1;
129	#endif
130	} else {
131	if ( SDL_View == NULL ) {
132	SDL_View = new SDL_BView(Bounds());
133	}
134	if ( the_view != SDL_View ) {
135	if ( the_view ) {
136	#if SDL_VIDEO_OPENGL
137	if ( the_view == SDL_GLView ) {
138	SDL_GLView->UnlockGL();
139	}
140	#endif
141	RemoveChild(the_view);
142	}
143	AddChild(SDL_View);
144	the_view = SDL_View;
145	}
146	}
147	Unlock();
148	return(retval);
149	}
150	virtual void SetBitmap(BBitmap *bitmap) {
151	SDL_View->SetBitmap(bitmap);
152	}
153	virtual void SetXYOffset(int x, int y) {
154	#if SDL_VIDEO_OPENGL
155	if ( the_view == SDL_GLView ) {
156	return;
157	}
158	#endif
159	SDL_View->SetXYOffset(x, y);
160	}
161	virtual void GetXYOffset(int &x, int &y) {
162	#if SDL_VIDEO_OPENGL
163	if ( the_view == SDL_GLView ) {
164	x = 0;
165	y = 0;
166	return;
167	}
168	#endif
169	SDL_View->GetXYOffset(x, y);
170	}
171	virtual void GetXYOffset(float &x, float &y) {
172	#if SDL_VIDEO_OPENGL
173	if ( the_view == SDL_GLView ) {
174	x = 0.0f;
175	y = 0.0f;
176	return;
177	}
178	#endif
179	SDL_View->GetXYOffset(x, y);
180	}
181	virtual bool BeginDraw(void) {
182	return(Lock());
183	}
184	virtual void DrawAsync(BRect updateRect) {
185	SDL_View->DrawAsync(updateRect);
186	}
187	virtual void EndDraw(void) {
188	SDL_View->Sync();
189	Unlock();
190	}
191	#if SDL_VIDEO_OPENGL
192	virtual void SwapBuffers(void) {
193	SDL_GLView->UnlockGL();
194	SDL_GLView->LockGL();
195	SDL_GLView->SwapBuffers();
196	}
197	#endif
198	virtual BView *View(void) {
199	return(the_view);
200	}
201
202	/* Hook functions -- overridden */
203	virtual void Minimize(bool minimize) {
204	/* This is only called when mimimized, not when restored */
205	//SDL_PrivateAppActive(minimize, SDL_APPACTIVE);
206	BWindow::Minimize(minimize);
207	}
208	virtual void WindowActivated(bool active) {
209	SDL_PrivateAppActive(active, SDL_APPINPUTFOCUS);
210	}
211	virtual bool QuitRequested(void) {
212	if ( SDL_BeAppActive > 0 ) {
213	SDL_PrivateQuit();
214	/* We don't ever actually close the window here because
215	the application should respond to the quit request,
216	or ignore it as desired.
217	*/
218	return(false);
219	}
220	return(true); /* Close the app window */
221	}
222	virtual void Quit() {
223	if (!IsLocked())
224	Lock();
225	BDirectWindow::Quit();
226	}
227
228	virtual int16 Translate2Unicode(const char *buf) {
229	int32 state, srclen, dstlen;
230	unsigned char destbuf[2];
231	Uint16 unicode = 0;
232
233	if ((uchar)buf[0] > 127) {
234	state = 0;
235	srclen = SDL_strlen(buf);
236	dstlen = sizeof(destbuf);
237	convert_from_utf8(B_UNICODE_CONVERSION, buf, &srclen, (char *)destbuf, &dstlen, &state);
238	unicode = destbuf[0];
239	unicode <<= 8;
240	unicode \|= destbuf[1];
241	} else
242	unicode = buf[0];
243
244	/* For some reason function keys map to control characters */
245	# define CTRL(X) ((X)-'@')
246	switch (unicode) {
247	case CTRL('A'):
248	case CTRL('B'):
249	case CTRL('C'):
250	case CTRL('D'):
251	case CTRL('E'):
252	case CTRL('K'):
253	case CTRL('L'):
254	case CTRL('P'):
255	if ( ! (SDL_GetModState() & KMOD_CTRL) )
256	unicode = 0;
257	break;
258	/* Keyboard input maps newline to carriage return */
259	case '\n':
260	unicode = '\r';
261	break;
262	default:
263	break;
264	}
265
266	return unicode;
267	}
268
269	virtual void DispatchMessage(BMessage msg, BHandler target);
270
271	virtual void DirectConnected(direct_buffer_info *info);
272
273	private:
274	#if SDL_VIDEO_OPENGL
275	BGLView *SDL_GLView;
276	#endif
277	SDL_BView *SDL_View;
278	BView *the_view;
279	bool shown;
280	bool inhibit_resize;
281	int32 last_buttons;
282	};
283
284	#endif /* _SDL_BWin_h */