start with libgame.so

git-svn-id: file:///srv/svn/repos/haiku/trunk/current@695 a95241bf-73f2-0310-859d-f6bbb57e9c96
2002-08-11 00:34:01 +00:00
parent 2e54c16421
commit 0b4a36abc9
8 changed files with 2208 additions and 0 deletions
@@ -0,0 +1,290 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <DirectWindow.h>
+
+BDirectWindow::BDirectWindow(BRect frame,
+							 const char *title,
+							 window_type type,
+							 uint32 flags,
+							 uint32 workspace)
+ : 	BWindow(frame, title, type, flags, workspace)
+{
+}
+
+
+BDirectWindow::BDirectWindow(BRect frame,
+							 const char *title,
+							 window_look look,
+							 window_feel feel,
+							 uint32 flags,
+							 uint32 workspace)
+ : 	BWindow(frame, title, look, feel, flags, workspace)
+{
+}
+
+
+BDirectWindow::~BDirectWindow()
+{
+}
+
+
+BArchivable *
+BDirectWindow::Instantiate(BMessage *data)
+{
+	return NULL;
+}
+
+
+status_t
+BDirectWindow::Archive(BMessage *data,
+					   bool deep) const
+{
+	return B_ERROR;
+}
+
+
+void
+BDirectWindow::Quit(void)
+{
+}
+
+
+void
+BDirectWindow::DispatchMessage(BMessage *message,
+							   BHandler *handler)
+{
+}
+
+
+void
+BDirectWindow::MessageReceived(BMessage *message)
+{
+}
+
+
+void
+BDirectWindow::FrameMoved(BPoint new_position)
+{
+}
+
+
+void
+BDirectWindow::WorkspacesChanged(uint32 old_ws,
+								 uint32 new_ws)
+{
+}
+
+
+void
+BDirectWindow::WorkspaceActivated(int32 ws,
+								  bool state)
+{
+}
+
+
+void
+BDirectWindow::FrameResized(float new_width,
+							float new_height)
+{
+}
+
+
+void
+BDirectWindow::Minimize(bool minimize)
+{
+}
+
+
+void
+BDirectWindow::Zoom(BPoint rec_position,
+					float rec_width,
+					float rec_height)
+{
+}
+
+
+void
+BDirectWindow::ScreenChanged(BRect screen_size,
+							 color_space depth)
+{
+}
+
+
+void
+BDirectWindow::MenusBeginning()
+{
+}
+
+
+void
+BDirectWindow::MenusEnded()
+{
+}
+
+
+void
+BDirectWindow::WindowActivated(bool state)
+{
+}
+
+
+void
+BDirectWindow::Show()
+{
+}
+
+
+void
+BDirectWindow::Hide()
+{
+}
+
+
+BHandler *
+BDirectWindow::ResolveSpecifier(BMessage *msg,
+								int32 index,
+								BMessage *specifier,
+								int32 form,
+								const char *property)
+{
+	return NULL;
+}
+
+
+status_t
+BDirectWindow::GetSupportedSuites(BMessage *data)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BDirectWindow::Perform(perform_code d,
+					   void *arg)
+{
+	return B_ERROR;
+}
+
+
+void
+BDirectWindow::task_looper()
+{
+}
+
+
+BMessage *
+BDirectWindow::ConvertToMessage(void *raw,
+								int32 code)
+{
+	return NULL;
+}
+
+
+void
+BDirectWindow::DirectConnected(direct_buffer_info *info)
+{
+}
+
+
+status_t
+BDirectWindow::GetClippingRegion(BRegion *region,
+								 BPoint *origin) const
+{
+	return B_ERROR;
+}
+
+
+status_t
+BDirectWindow::SetFullScreen(bool enable)
+{
+	return B_ERROR;
+}
+
+
+bool
+BDirectWindow::IsFullScreen() const
+{
+	return false;
+}
+
+
+bool
+BDirectWindow::SupportsWindowMode(screen_id)
+{
+	return false;
+}
+
+
+void
+BDirectWindow::_ReservedDirectWindow1()
+{
+}
+
+
+void
+BDirectWindow::_ReservedDirectWindow2()
+{
+}
+
+
+void
+BDirectWindow::_ReservedDirectWindow3()
+{
+}
+
+
+void
+BDirectWindow::_ReservedDirectWindow4()
+{
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BDirectWindow::BDirectWindow()
+ * BDirectWindow::BDirectWindow(BDirectWindow &)
+ * BDirectWindow &BDirectWindow::operator=(BDirectWindow &)
+ */
+
+int32
+BDirectWindow::DirectDeamonFunc(void *arg)
+{
+	return 0;
+}
+
+
+bool
+BDirectWindow::LockDirect() const
+{
+	return false;
+}
+
+
+void
+BDirectWindow::UnlockDirect() const
+{
+}
+
+
+void
+BDirectWindow::InitData()
+{
+}
+
+
+void
+BDirectWindow::DisposeData()
+{
+}
+
+
+status_t
+BDirectWindow::DriverSetup() const
+{
+	return B_ERROR;
+}
+
+
@@ -0,0 +1,294 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <FileGameSound.h>
+
+static const size_t default_in_buffer_frame_count = 4096; // XXX change this
+static const gs_audio_format default_format = {}; // XXX change this
+static const size_t default_in_buffer_count = 2; // XXX change this
+
+BFileGameSound::BFileGameSound(const entry_ref *file,
+							   bool looping,
+							   BGameSoundDevice *device)
+ :	BStreamingGameSound(default_in_buffer_frame_count, &default_format, default_in_buffer_count, device)
+{
+}
+
+
+BFileGameSound::BFileGameSound(const char *file,
+							   bool looping,
+							   BGameSoundDevice *device)
+ :	BStreamingGameSound(default_in_buffer_frame_count, &default_format, default_in_buffer_count, device)
+{
+}
+
+
+BFileGameSound::~BFileGameSound()
+{
+}
+
+
+BGameSound *
+BFileGameSound::Clone() const
+{
+	return NULL;
+}
+
+
+status_t
+BFileGameSound::StartPlaying()
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::StopPlaying()
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::Preload()
+{
+	return B_ERROR;
+}
+
+
+void
+BFileGameSound::FillBuffer(void *inBuffer,
+						   size_t inByteCount)
+{
+}
+
+
+status_t
+BFileGameSound::Perform(int32 selector,
+						void *data)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::SetPaused(bool isPaused,
+						  bigtime_t rampTime)
+{
+	return B_ERROR;
+}
+
+
+int32
+BFileGameSound::IsPaused()
+{
+	return 0;
+}
+
+
+status_t
+BFileGameSound::stream_thread(void *that)
+{
+	return B_ERROR;
+}
+
+
+void
+BFileGameSound::LoadFunc()
+{
+}
+
+
+size_t
+BFileGameSound::Load(size_t &offset,
+					 size_t bytes)
+{
+	return 0;
+}
+
+
+void
+BFileGameSound::read_data(char *dest,
+						  size_t bytes)
+{
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BFileGameSound::BFileGameSound()
+ * BFileGameSound::BFileGameSound(const BFileGameSound &)
+ * BFileGameSound &BFileGameSound::operator=(const BFileGameSound &)
+ */
+ 
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_0(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_1(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_2(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_3(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_4(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_5(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_6(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_7(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_8(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_9(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_10(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_11(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_12(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_13(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_14(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_15(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_16(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_17(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_18(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_19(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_20(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_21(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_22(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BFileGameSound::_Reserved_BFileGameSound_23(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
@@ -0,0 +1,520 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <GameSound.h>
+
+BGameSound::BGameSound(BGameSoundDevice *device)
+{
+}
+
+
+BGameSound::~BGameSound()
+{
+}
+
+
+status_t
+BGameSound::InitCheck() const
+{
+	return B_ERROR;
+}
+
+
+BGameSoundDevice *
+BGameSound::Device() const
+{
+	return NULL;
+}
+
+
+gs_id
+BGameSound::ID() const
+{
+	return 0;
+}
+
+
+const gs_audio_format &
+BGameSound::Format() const
+{
+}
+
+
+status_t
+BGameSound::StartPlaying()
+{
+	return B_ERROR;
+}
+
+
+bool
+BGameSound::IsPlaying()
+{
+	return false;
+}
+
+
+status_t
+BGameSound::StopPlaying()
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::SetGain(float gain,
+					bigtime_t duration)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::SetPan(float pan,
+				   bigtime_t duration)
+{
+	return B_ERROR;
+}
+
+
+float
+BGameSound::Gain()
+{
+	return 0.0f;
+}
+
+
+float
+BGameSound::Pan()
+{
+	return 0.0f;
+}
+
+
+status_t
+BGameSound::SetAttributes(gs_attribute *inAttributes,
+						  size_t inAttributeCount)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::GetAttributes(gs_attribute *outAttributes,
+						  size_t inAttributeCount)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::Perform(int32 selector,
+					void *data)
+{
+	return B_ERROR;
+}
+
+
+void *
+BGameSound::operator new(size_t size)
+{
+	return NULL;
+}
+
+
+void
+BGameSound::operator delete(void *ptr)
+{
+}
+
+
+status_t
+BGameSound::SetMemoryPoolSize(size_t in_poolSize)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::LockMemoryPool(bool in_lockInCore)
+{
+	return B_ERROR;
+}
+
+
+int32
+BGameSound::SetMaxSoundCount(int32 in_maxCount)
+{
+	return 0;
+}
+
+
+status_t
+BGameSound::SetInitError(status_t in_initError)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::Init(gs_id handle)
+{
+	return B_ERROR;
+}
+
+
+BGameSound::BGameSound(const BGameSound &other)
+{
+}
+
+
+BGameSound &
+BGameSound::operator=(const BGameSound &other)
+{
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BGameSound::BGameSound()
+ */
+ 
+
+status_t
+BGameSound::_Reserved_BGameSound_0(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_1(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_2(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_3(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_4(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_5(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_6(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_7(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_8(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_9(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_10(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_11(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_12(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_13(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_14(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_15(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_16(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_17(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_18(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_19(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_20(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_21(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_22(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_23(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_24(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_25(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_26(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_27(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_28(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_29(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_30(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_31(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_32(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_33(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_34(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_35(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_36(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_37(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_38(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_39(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_40(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_41(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_42(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_43(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_44(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_45(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_46(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BGameSound::_Reserved_BGameSound_47(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
@@ -0,0 +1,18 @@
+SubDir OBOS_TOP src kits game ;
+
+UsePublicHeaders game ;
+
+SharedLibrary game :
+	DirectWindow.cpp
+	WindowScreen.cpp
+	GameSound.cpp
+	SimpleGameSound.cpp
+	FileGameSound.cpp
+	PushGameSound.cpp
+	StreamingGameSound.cpp
+;
+
+LinkSharedOSLibs libgame.so :
+	be
+;
+
@@ -0,0 +1,277 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <PushGameSound.h>
+
+static const size_t default_in_buffer_frame_count = 4096; // XXX change this
+static const gs_audio_format default_format = {}; // XXX change this
+static const size_t default_in_buffer_count = 2; // XXX change this
+
+BPushGameSound::BPushGameSound(size_t inBufferFrameCount,
+							   const gs_audio_format *format,
+							   size_t inBufferCount,
+							   BGameSoundDevice *device)
+ :	BStreamingGameSound(default_in_buffer_frame_count, &default_format, default_in_buffer_count, device)
+{
+}
+
+
+BPushGameSound::~BPushGameSound()
+{
+}
+
+
+BPushGameSound::lock_status
+BPushGameSound::LockNextPage(void **out_pagePtr,
+							 size_t *out_pageSize)
+{
+	return lock_failed;
+}
+
+
+status_t
+BPushGameSound::UnlockPage(void *in_pagePtr)
+{
+	return B_ERROR;
+}
+
+
+BPushGameSound::lock_status
+BPushGameSound::LockForCyclic(void **out_basePtr,
+							  size_t *out_size)
+{
+	return lock_failed;
+}
+
+
+status_t
+BPushGameSound::UnlockCyclic()
+{
+	return B_ERROR;
+}
+
+
+size_t
+BPushGameSound::CurrentPosition()
+{
+	return 0;
+}
+
+
+BGameSound *
+BPushGameSound::Clone() const
+{
+	return NULL;
+}
+
+
+status_t
+BPushGameSound::Perform(int32 selector,
+						void *data)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::SetParameters(size_t inBufferFrameCount,
+							  const gs_audio_format *format,
+							  size_t inBufferCount)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::SetStreamHook(void (*hook)(void * inCookie, void * inBuffer, size_t inByteCount, BStreamingGameSound * me),
+							  void * cookie)
+{
+	return B_ERROR;
+}
+
+
+void
+BPushGameSound::FillBuffer(void *inBuffer,
+						   size_t inByteCount)
+{
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BPushGameSound::BPushGameSound()
+ * BPushGameSound::BPushGameSound(const BPushGameSound &)
+ * BPushGameSound &BPushGameSound::operator=(const BPushGameSound &)
+ */
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_0(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_1(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_2(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_3(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_4(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_5(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_6(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_7(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_8(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_9(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_10(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_11(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_12(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_13(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_14(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_15(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_16(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_17(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_18(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_19(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_20(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_21(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_22(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BPushGameSound::_Reserved_BPushGameSound_23(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
@@ -0,0 +1,245 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <SimpleGameSound.h>
+
+BSimpleGameSound::BSimpleGameSound(const entry_ref *inFile,
+								   BGameSoundDevice *device)
+ :	BGameSound(device)
+{
+}
+
+
+BSimpleGameSound::BSimpleGameSound(const char *inFile,
+								   BGameSoundDevice *device)
+ :	BGameSound(device)
+{
+}
+
+
+BSimpleGameSound::BSimpleGameSound(const void *inData,
+								   size_t inFrameCount,
+								   const gs_audio_format *format,
+								   BGameSoundDevice *device)
+ :	BGameSound(device)
+{
+}
+
+
+BSimpleGameSound::BSimpleGameSound(const BSimpleGameSound &other)
+ :	BGameSound(other.Device())
+{
+}
+
+
+BSimpleGameSound::~BSimpleGameSound()
+{
+}
+
+
+BGameSound *
+BSimpleGameSound::Clone() const
+{
+	return NULL;
+}
+
+
+status_t
+BSimpleGameSound::Perform(int32 selector,
+						  void *data)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::SetIsLooping(bool looping)
+{
+	return B_ERROR;
+}
+
+
+bool
+BSimpleGameSound::IsLooping() const
+{
+	return false;
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BSimpleGameSound::BSimpleGameSound()
+ * BSimpleGameSound &BSimpleGameSound::operator=(const BSimpleGameSound &)
+ */
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_0(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_1(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_2(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_3(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_4(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_5(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_6(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_7(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_8(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_9(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_10(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_11(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_12(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_13(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_14(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_15(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_16(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_17(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_18(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_19(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_20(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_21(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_22(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BSimpleGameSound::_Reserved_BSimpleGameSound_23(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
@@ -0,0 +1,274 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <StreamingGameSound.h>
+
+BStreamingGameSound::BStreamingGameSound(size_t inBufferFrameCount,
+										 const gs_audio_format *format,
+										 size_t inBufferCount,
+										 BGameSoundDevice *device)
+ :	BGameSound(device)
+{
+}
+
+
+BStreamingGameSound::~BStreamingGameSound()
+{
+}
+
+
+BGameSound *
+BStreamingGameSound::Clone() const
+{
+	return NULL;
+}
+
+
+status_t
+BStreamingGameSound::SetStreamHook(void (*hook)(void * inCookie, void * inBuffer, size_t inByteCount, BStreamingGameSound * me),
+								   void * cookie)
+{
+	return B_ERROR;
+}
+
+
+void
+BStreamingGameSound::FillBuffer(void *inBuffer,
+								size_t inByteCount)
+{
+}
+
+
+status_t
+BStreamingGameSound::SetAttributes(gs_attribute *inAttributes,
+								   size_t inAttributeCount)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::Perform(int32 selector,
+							 void *data)
+{
+	return B_ERROR;
+}
+
+
+BStreamingGameSound::BStreamingGameSound(BGameSoundDevice *device)
+ :	BGameSound(device)
+{
+}
+
+
+status_t
+BStreamingGameSound::SetParameters(size_t inBufferFrameCount,
+								   const gs_audio_format *format,
+								   size_t inBufferCount)
+{
+	return B_ERROR;
+}
+
+
+bool
+BStreamingGameSound::Lock()
+{
+	return false;
+}
+
+
+void
+BStreamingGameSound::Unlock()
+{
+}
+
+
+void
+BStreamingGameSound::stream_callback(void *cookie,
+									 gs_id handle,
+									 void *buffer,
+									 int32 offset,
+									 int32 size,
+									 size_t bufSize)
+{
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BStreamingGameSound::BStreamingGameSound()
+ * BStreamingGameSound::BStreamingGameSound(const BStreamingGameSound &)
+ * BStreamingGameSound &BStreamingGameSound::operator=(const BStreamingGameSound &)
+ */
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_0(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_1(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_2(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_3(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_4(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_5(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_6(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_7(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_8(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_9(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_10(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_11(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_12(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_13(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_14(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_15(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_16(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_17(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_18(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_19(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_20(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_21(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_22(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BStreamingGameSound::_Reserved_BStreamingGameSound_23(int32 arg, ...)
+{
+	return B_ERROR;
+}
+
+
@@ -0,0 +1,290 @@
+/* 
+ * Copyright 2002, Marcus Overhagen. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <WindowScreen.h>
+
+BWindowScreen::BWindowScreen(const char *title,
+							 uint32 space,
+							 status_t *error,
+							 bool debug_enable)
+ :	BWindow(BRect(0,0,0,0), title, B_UNTYPED_WINDOW, B_ASYNCHRONOUS_CONTROLS, B_CURRENT_WORKSPACE) // XXX this needs to be fixed
+{
+}
+
+
+BWindowScreen::BWindowScreen(const char *title,
+							 uint32 space,
+							 uint32 attributes,
+							 status_t *error)
+ :	BWindow(BRect(0,0,0,0), title, B_UNTYPED_WINDOW, B_ASYNCHRONOUS_CONTROLS, B_CURRENT_WORKSPACE) // XXX this needs to be fixed
+{
+}
+
+
+BWindowScreen::~BWindowScreen()
+{
+}
+
+
+void
+BWindowScreen::Quit(void)
+{
+}
+
+
+void
+BWindowScreen::ScreenConnected(bool active)
+{
+}
+
+
+void
+BWindowScreen::Disconnect()
+{
+}
+
+
+void
+BWindowScreen::WindowActivated(bool active)
+{
+}
+
+
+void
+BWindowScreen::WorkspaceActivated(int32 ws,
+								  bool state)
+{
+}
+
+
+void
+BWindowScreen::ScreenChanged(BRect screen_size,
+							 color_space depth)
+{
+}
+
+
+void
+BWindowScreen::Hide()
+{
+}
+
+
+void
+BWindowScreen::Show()
+{
+}
+
+
+void
+BWindowScreen::SetColorList(rgb_color *list,
+							int32 first_index,
+							int32 last_index)
+{
+}
+
+
+status_t
+BWindowScreen::SetSpace(uint32 space)
+{
+	return B_ERROR;
+}
+
+
+bool
+BWindowScreen::CanControlFrameBuffer()
+{
+	return false;
+}
+
+
+status_t
+BWindowScreen::SetFrameBuffer(int32 width,
+							  int32 height)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BWindowScreen::MoveDisplayArea(int32 x,
+							   int32 y)
+{
+	return B_ERROR;
+}
+
+
+void *
+BWindowScreen::IOBase()
+{
+	return NULL;
+}
+
+
+rgb_color *
+BWindowScreen::ColorList()
+{
+	return NULL;
+}
+
+
+frame_buffer_info *
+BWindowScreen::FrameBufferInfo()
+{
+	return NULL;
+}
+
+
+graphics_card_hook
+BWindowScreen::CardHookAt(int32 index)
+{
+	return 0;
+}
+
+
+graphics_card_info *
+BWindowScreen::CardInfo()
+{
+	return NULL;
+}
+
+
+void
+BWindowScreen::RegisterThread(thread_id id)
+{
+}
+
+
+void
+BWindowScreen::SuspensionHook(bool active)
+{
+}
+
+
+void
+BWindowScreen::Suspend(char *label)
+{
+}
+
+
+status_t
+BWindowScreen::Perform(perform_code d,
+					   void *arg)
+{
+	return B_ERROR;
+}
+
+
+void
+BWindowScreen::_ReservedWindowScreen1()
+{
+}
+
+
+void
+BWindowScreen::_ReservedWindowScreen2()
+{
+}
+
+
+void
+BWindowScreen::_ReservedWindowScreen3()
+{
+}
+
+
+void
+BWindowScreen::_ReservedWindowScreen4()
+{
+}
+
+
+/* unimplemented for protection of the user:
+ *
+ * BWindowScreen::BWindowScreen()
+ * BWindowScreen::BWindowScreen(BWindowScreen &)
+ * BWindowScreen &BWindowScreen::operator=(BWindowScreen &)
+ */
+
+
+BRect
+BWindowScreen::CalcFrame(int32 index,
+						 int32 space,
+						 display_mode *dmode)
+{
+	BRect dummy;
+	return dummy;
+}
+
+
+int32
+BWindowScreen::SetFullscreen(int32 enable)
+{
+	return 0;
+}
+
+
+status_t
+BWindowScreen::InitData(uint32 space,
+						uint32 attributes)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BWindowScreen::SetActiveState(int32 state)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BWindowScreen::SetLockState(int32 state)
+{
+	return B_ERROR;
+}
+
+
+void
+BWindowScreen::GetCardInfo()
+{
+}
+
+
+void
+BWindowScreen::Suspend()
+{
+}
+
+
+void
+BWindowScreen::Resume()
+{
+}
+
+
+status_t
+BWindowScreen::GetModeFromSpace(uint32 space,
+								display_mode *dmode)
+{
+	return B_ERROR;
+}
+
+
+status_t
+BWindowScreen::InitClone()
+{
+	return B_ERROR;
+}
+
+
+status_t
+BWindowScreen::AssertDisplayMode(display_mode *dmode)
+{
+	return B_ERROR;
+}
+
+