diff --git a/headers/os/game/WindowScreen.h b/headers/os/game/WindowScreen.h
index f8976d2c8f..cab1cecbad 100644
--- a/headers/os/game/WindowScreen.h
+++ b/headers/os/game/WindowScreen.h
@@ -141,7 +141,7 @@ virtual	void        SuspensionHook(bool active);
 		
 virtual status_t	Perform(perform_code d, void *arg);
 
- private:
+private:
 
 		typedef BWindow	inherited;
 
@@ -154,39 +154,39 @@ virtual void        _ReservedWindowScreen4();
 		BWindowScreen(BWindowScreen &);
 		BWindowScreen &operator=(BWindowScreen &);
 					
-		char                  addon_state;
+		char                  fAddonState;
 		char                  space_mode;
 		void                  *io_buffer;
-        bool                  direct_enable;
-		bool                  work_state;
-		bool                  window_state;
-		bool                  activate_state;
-        int32                 lock_state;
-		int32                 screen_index;
+        	bool                  direct_enable;
+		bool                  fWorkState;
+		bool                  fWindowState;
+		bool                  fActivateState;
+        	int32                 fLockState;
+		int32                 fScreenIndex;
 		int32                 memory_area, io_area;
-		display_mode          *old_space;
-		display_mode          *new_space;
+		display_mode          *fOldDisplayMode;
+		display_mode          *fDisplayMode;
 		uint32                space0;
-		sem_id                activate_sem;
-		sem_id                debug_sem;
-		image_id              addon_image;
-		rgb_color             colorList[256];
+		sem_id                fActivateSem;
+		sem_id                fDebugSem;
+		image_id              fAddonImage;
+		rgb_color             fColorList[256];
 		GetAccelerantHook     m_gah;
-        graphics_card_info    card_info;
+        	graphics_card_info    fCardInfo;
 		graphics_card_hook    hooks[B_HOOK_COUNT]; 
 		_direct_screen_info_  info;
-		frame_buffer_info     format_info;
+		frame_buffer_info     fFrameBufferInfo;
 
-		char                  *debug_buffer;
-		bool                  debug_state;
-		bool                  debug_first;
-		int32                 debug_list_count;
-		int32                 debug_workspace;
-	    thread_id             *debug_list;
+		char                  *fDebugBuffer;
+		bool                  fDebugState;
+		bool                  fDebugFirst;
+		int32                 fDebugListCount;
+		int32                 fDebugWorkspace;
+	    	thread_id             *fDebugList;
 
-		uint32				  _attributes;
-		uint32                mode_count;
-		display_mode          *mode_list;
+		uint32		      fAttributes;
+		uint32                fModeCount;
+		display_mode          *fModeList;
 		engine_token          *et;
 		wait_engine_idle      m_wei;
 		acquire_engine        m_ae;
@@ -199,10 +199,10 @@ virtual void        _ReservedWindowScreen4();
 		uint32                _reserved_[21];
 		
 static	BRect		CalcFrame(int32 index, int32 space, display_mode *dmode);
-		int32		SetFullscreen(int32 enable);
+		status_t	SetFullscreen(bool enable);
 		status_t	InitData(uint32 space, uint32 attributes);
-        status_t    SetActiveState(int32 state);
-        status_t    SetLockState(int32 state);
+        	status_t    SetActiveState(int32 state);
+        	status_t    SetLockState(int32 state);
 		void        GetCardInfo();
 		void        Suspend();
 		void    	Resume();
diff --git a/src/kits/game/WindowScreen.cpp b/src/kits/game/WindowScreen.cpp
index c2bb3a347f..0dc63ddcb2 100644
--- a/src/kits/game/WindowScreen.cpp
+++ b/src/kits/game/WindowScreen.cpp
@@ -28,6 +28,7 @@
 using BPrivate::AppServerLink;
 
 
+#define TRACE_WINDOWSCREEN 1
 #if TRACE_WINDOWSCREEN
 #define CALLED() printf("%s\n", __PRETTY_FUNCTION__);
 #else
@@ -285,8 +286,8 @@ set_mouse_position(int32 x, int32 y)
 
 BWindowScreen::BWindowScreen(const char *title, uint32 space,
 	status_t *error, bool debug_enable)
-	: BWindow(BScreen().Frame(), title, B_TITLED_WINDOW,
-		kWindowScreenFlag | B_NOT_MINIMIZABLE | B_NOT_CLOSABLE
+	: BWindow(BScreen().Frame().InsetByCopy(100, 100), title, B_TITLED_WINDOW,
+		kWindowScreenFlag | B_NOT_MINIMIZABLE /*| B_NOT_CLOSABLE*/
 			| B_NOT_ZOOMABLE | B_NOT_MOVABLE | B_NOT_RESIZABLE,
 		B_CURRENT_WORKSPACE)
 {
@@ -303,8 +304,8 @@ BWindowScreen::BWindowScreen(const char *title, uint32 space,
 
 BWindowScreen::BWindowScreen(const char *title, uint32 space,
 	uint32 attributes, status_t *error)
-	: BWindow(BScreen().Frame(), title, B_TITLED_WINDOW, 
-		kWindowScreenFlag | B_NOT_MINIMIZABLE | B_NOT_CLOSABLE
+	: BWindow(BScreen().Frame().InsetByCopy(100, 100), title, B_TITLED_WINDOW, 
+		kWindowScreenFlag | B_NOT_MINIMIZABLE /*| B_NOT_CLOSABLE*/
 			| B_NOT_ZOOMABLE | B_NOT_MOVABLE | B_NOT_RESIZABLE,
 		B_CURRENT_WORKSPACE)
 {
@@ -317,27 +318,29 @@ BWindowScreen::BWindowScreen(const char *title, uint32 space,
 
 BWindowScreen::~BWindowScreen()
 {
+	CALLED();
 	Disconnect();
-	if (addon_state == 1)
-		unload_add_on(addon_image);
+	if (fAddonState == 1)
+		unload_add_on(fAddonImage);
 	
-	SetFullscreen(0);
+	SetFullscreen(false);
 	
-	delete_sem(activate_sem);
-	delete_sem(debug_sem);
+	delete_sem(fActivateSem);
+	delete_sem(fDebugSem);
 	
-	if (debug_state)
-		activate_workspace(debug_workspace);
+	if (fDebugState)
+		activate_workspace(fDebugWorkspace);
 	
-	free(new_space);
-	free(old_space);
-	free(mode_list);
+	free(fDisplayMode);
+	free(fOldDisplayMode);
+	free(fModeList);
 }
 
 
 void
 BWindowScreen::Quit(void)
 {
+	CALLED();
 	Disconnect();
 	BWindow::Quit();
 }
@@ -353,9 +356,10 @@ BWindowScreen::ScreenConnected(bool active)
 void
 BWindowScreen::Disconnect()
 {
-	if (lock_state == 1) {
-		if (debug_state)
-			debug_first = true;
+	CALLED();
+	if (fLockState == 1) {
+		if (fDebugState)
+			fDebugFirst = true;
 		SetActiveState(0);
 	}
 }
@@ -365,8 +369,8 @@ void
 BWindowScreen::WindowActivated(bool active)
 {
 	CALLED();
-	window_state = active;
-	if(active && lock_state == 0 && work_state)
+	fWindowState = active;
+	if(active && fLockState == 0 && fWorkState)
 		SetActiveState(1);
 }
 
@@ -375,19 +379,17 @@ void
 BWindowScreen::WorkspaceActivated(int32 ws, bool state)
 {
 	CALLED();
-	work_state = state;
+	fWorkState = state;
 	if (state) {
-		if (lock_state == 0 && window_state) {
+		if (fLockState == 0 && fWindowState) {
 			SetActiveState(1);
 			if (!IsHidden()) {
 				Activate(true);
 				WindowActivated(true);
 			}
 		}
-	} else {
-		if (lock_state)
-			SetActiveState(0);
-	}
+	} else if (fLockState)
+		SetActiveState(0);
 }
 
 
@@ -401,9 +403,10 @@ BWindowScreen::ScreenChanged(BRect screen_size, color_space depth)
 void
 BWindowScreen::Hide()
 {
-	if (lock_state == 1) {
-		if (debug_state)
-			debug_first = true;
+	CALLED();
+	if (fLockState == 1) {
+		if (fDebugState)
+			fDebugFirst = true;
 		SetActiveState(0);
 	}
 	
@@ -415,9 +418,9 @@ void
 BWindowScreen::Show()
 {
 	BWindow::Show();
-	if (!activate_state) {
-		release_sem(activate_sem);
-		activate_state = true;
+	if (!fActivateState) {
+		release_sem(fActivateSem);
+		fActivateState = true;
 	}
 }
 
@@ -429,16 +432,16 @@ BWindowScreen::SetColorList(rgb_color *list, int32 first_index, int32 last_index
 		return;
 
 	if (Lock()) {
-		if (!activate_state) { 
+		if (!fActivateState) { 
 			//If we aren't active, we just change our local palette
 			for (int32 x = first_index; x <= last_index; x++)
-				colorList[x] = list[x];
+				fColorList[x] = list[x];
 		} else {
 			uint32 colorCount = last_index - first_index + 1;
-			if (addon_state == 1) {
+			if (fAddonState == 1) {
 				set_indexed_colors sic = (set_indexed_colors)m_gah(B_SET_INDEXED_COLORS, NULL);
 				if (sic != NULL)
-					sic(colorCount, first_index, (uint8*)colorList, 0);
+					sic(colorCount, first_index, (uint8 *)fColorList, 0);
 			}
 	
 			BScreen screen(this);
@@ -446,7 +449,7 @@ BWindowScreen::SetColorList(rgb_color *list, int32 first_index, int32 last_index
 			// Update our local palette too. We're doing this between two 
 			// WaitForRetrace() calls so nobody will notice.
 			for (int32 x = first_index; x <= last_index; x++)
-				colorList[x] = list[x];
+				fColorList[x] = list[x];
 		
 			// TODO: Tell the app_server about our changes
 
@@ -472,14 +475,15 @@ BWindowScreen::SetSpace(uint32 space)
 bool
 BWindowScreen::CanControlFrameBuffer()
 {
-	return (addon_state <= 1 && (card_info.flags & B_FRAME_BUFFER_CONTROL));
+	return (fAddonState == 1 && (fCardInfo.flags & B_FRAME_BUFFER_CONTROL));
 }
 
 
 status_t
 BWindowScreen::SetFrameBuffer(int32 width, int32 height)
 {
-	display_mode highMode = *new_space;
+	CALLED();
+	display_mode highMode = *fDisplayMode;
 
 	highMode.virtual_height = (int16)height;
 	highMode.virtual_width = (int16)width;
@@ -502,15 +506,16 @@ BWindowScreen::SetFrameBuffer(int32 width, int32 height)
 status_t
 BWindowScreen::MoveDisplayArea(int32 x, int32 y)
 {
+	CALLED();
 	status_t status = B_ERROR;
 
 	// TODO: Ask app server to move the frame buffer area
 
 	if (status == B_OK) {		
-		format_info.display_x = x;
-		format_info.display_y = y;
-		new_space->h_display_start = x;
-		new_space->v_display_start = y;
+		fFrameBufferInfo.display_x = x;
+		fFrameBufferInfo.display_y = y;
+		fDisplayMode->h_display_start = x;
+		fDisplayMode->v_display_start = y;
 	}
 	return status;
 }
@@ -527,22 +532,22 @@ BWindowScreen::IOBase()
 rgb_color *
 BWindowScreen::ColorList()
 {
-	return colorList;
+	return fColorList;
 }
 
 
 frame_buffer_info *
 BWindowScreen::FrameBufferInfo()
 {
-	return &format_info;
+	return &fFrameBufferInfo;
 }
 
 
 graphics_card_hook
 BWindowScreen::CardHookAt(int32 index)
 {
-	if (addon_state != 1)
-		return 0;
+	if (fAddonState != 1)
+		return NULL;
 	
 	graphics_card_hook hook = NULL;
 	
@@ -591,7 +596,7 @@ BWindowScreen::CardHookAt(int32 index)
 graphics_card_info *
 BWindowScreen::CardInfo()
 {
-	return &card_info;
+	return &fCardInfo;
 }
 
 
@@ -599,13 +604,15 @@ void
 BWindowScreen::RegisterThread(thread_id id)
 {
 	CALLED();
-	while (acquire_sem(debug_sem) == B_INTERRUPTED)
+	while (acquire_sem(fDebugSem) == B_INTERRUPTED)
 		;
-	++debug_list_count;
-	debug_list = (thread_id *)realloc(debug_list, debug_list_count * sizeof(thread_id));		
-	debug_list[debug_list_count - 1] = id;
-
-	release_sem(debug_sem);
+	void *newDebugList = realloc(fDebugList, (fDebugListCount + 1) * sizeof(thread_id));
+	if (newDebugList != NULL) {
+		fDebugList = (thread_id *)newDebugList;	
+		fDebugList[fDebugListCount] = id;
+		fDebugListCount++;
+	}
+	release_sem(fDebugSem);
 }
 
 
@@ -620,14 +627,14 @@ void
 BWindowScreen::Suspend(char *label)
 {
 	CALLED();
-	if (debug_state) {		
+	if (fDebugState) {		
 		fprintf(stderr, "## Debugger(\"%s\").", label);
 		fprintf(stderr, " Press Alt-F%ld or Cmd-F%ld to resume.\n", space0 + 1, space0 + 1);
 		
 		if (IsLocked())
 			Unlock();
 		
-		activate_workspace(debug_workspace);
+		activate_workspace(fDebugWorkspace);
 
 		// Suspend ourself
 		suspend_thread(find_thread(NULL));
@@ -670,10 +677,10 @@ BWindowScreen::CalcFrame(int32 index, int32 space, display_mode *dmode)
 }
 
 
-int32
-BWindowScreen::SetFullscreen(int32 enable)
+status_t
+BWindowScreen::SetFullscreen(bool enable)
 {
-	int32 retval = -1;
+	status_t retval = B_ERROR;
 
 	// TODO: Set fullscreen
 	
@@ -686,44 +693,53 @@ BWindowScreen::InitData(uint32 space, uint32 attributes)
 {
 	CALLED();
 	
-	BScreen screen(this);
-	debug_state = attributes & B_ENABLE_DEBUGGER;
-	debug_list_count = 0;
-	debug_list = 0;
-	debug_first = true;
+	fDebugState = attributes & B_ENABLE_DEBUGGER;
+	fDebugListCount = 0;
+	fDebugList = NULL;
+	fDebugFirst = true;
 	
-	debug_sem = create_sem(1, "WindowScreen debug sem");
-	old_space = (display_mode *)calloc(1, sizeof(display_mode));
-	new_space = (display_mode *)calloc(1, sizeof(display_mode));
-	
-	screen.GetModeList(&mode_list, &mode_count);
-	
-	_attributes = attributes;
-	
-	display_mode *n_space = new_space;
-	screen_index = 0;
-	lock_state = 0;
-	addon_state = 0;
+	fAttributes = attributes;	
+	fScreenIndex = current_workspace();
+	fLockState = 0;
+	fAddonState = 0;
 	direct_enable = 0;
-	window_state = 0;
+	fWindowState = 0;
+	fDebugWorkspace = 0;
+
+	BScreen screen(this);	
+	status_t status = screen.GetModeList(&fModeList, &fModeCount);
+	if (status < B_OK) {
+		printf("BScreen::GetModeList() returned %s\n", strerror(status));
+		return status;
+	}	
 	
+	display_mode newMode;
+	status = GetModeFromSpace(space, &newMode);
+	if (status < B_OK) {
+		printf("GetModeFromSpace() returned %s\n", strerror(status));
+		return status;
+	}
+
 	space_mode = 1;
-	
-	GetModeFromSpace(space, n_space);
-	
 	space0 = 0;
 	
 	SetWorkspaces(B_CURRENT_WORKSPACE);
-	SetFullscreen(1);
+	SetFullscreen(true);
 
-	work_state = 1;
-	debug_workspace = 0;
-	memcpy(colorList, screen.ColorMap()->color_list, 256);
+	memcpy(fColorList, screen.ColorMap()->color_list, 256);
 	
 	GetCardInfo();
 
-	activate_sem = create_sem(0, "WindowScreen start lock");
-	activate_state = 0;
+	fActivateSem = create_sem(0, "WindowScreen start lock");
+	fActivateState = 0;
+	
+	fDebugSem = create_sem(1, "WindowScreen debug sem");
+	fOldDisplayMode = (display_mode *)calloc(1, sizeof(display_mode));
+	fDisplayMode = (display_mode *)calloc(1, sizeof(display_mode));
+	
+	memcpy(fDisplayMode, &newMode, sizeof(newMode));
+	
+	fWorkState = 1;
 		
 	return B_OK;
 }
@@ -735,21 +751,21 @@ BWindowScreen::SetActiveState(int32 state)
 	CALLED();
 	status_t status = B_ERROR;
 	if (state == 1) {
-		be_app->HideCursor();
-		if (be_app->IsCursorHidden() 
-			&& (status = SetLockState(1)) == B_OK) {
-			status = AssertDisplayMode(new_space);			
+		//be_app->HideCursor();
+		if (/*be_app->IsCursorHidden() && */(status = SetLockState(1)) == B_OK) {
+			status = AssertDisplayMode(fDisplayMode);			
+			printf("AssertDisplayMode() returned %s\n", strerror(status));
 			if (status == B_OK) {
-				if (!activate_state) {
-					while (acquire_sem(activate_sem) == B_INTERRUPTED)
+				if (!fActivateState) {
+					while (acquire_sem(fActivateSem) == B_INTERRUPTED)
 						;
 				}
-				SetColorList(colorList);
-				if (debug_state && !debug_first) {
+				SetColorList(fColorList);
+				if (fDebugState && !fDebugFirst) {
 					SuspensionHook(true);
 					Resume();					
 				} else {
-					debug_first = true;
+					fDebugFirst = true;
 					ScreenConnected(true);
 				}
 				if (status == B_OK)
@@ -761,7 +777,7 @@ BWindowScreen::SetActiveState(int32 state)
 			be_app->ShowCursor();
 		} 				
 	} else {
-		if (debug_state && !debug_first) {
+		if (fDebugState && !fDebugFirst) {
 			Suspend();
 			SuspensionHook(false);
 		} else
@@ -770,11 +786,13 @@ BWindowScreen::SetActiveState(int32 state)
 		status = SetLockState(0);
 		if (status == B_OK) {				
 			be_app->ShowCursor();				
-			if (activate_state) {
+			if (fActivateState) {
 				// TODO: Set palette
 			}
 		}
 	}
+	
+	printf("SetActiveState() returning %s\n", strerror(status));
 	return status;
 }
 
@@ -783,7 +801,7 @@ status_t
 BWindowScreen::SetLockState(int32 state)
 {
 	CALLED();
-	if (addon_state == 1 && state == 1) {
+	if (fAddonState == 1 && state == 1) {
 		m_wei();
 		fill_rect_global = NULL;
 		blit_rect_global = NULL;
@@ -795,26 +813,26 @@ BWindowScreen::SetLockState(int32 state)
 		release_engine_global = NULL;
 	}
 
-	status_t status = B_ERROR;
+	status_t status = B_OK;
 
 	// TODO: Set lock state (whatever it means)
 	
 	if (status == B_OK) {
-		lock_state = state;
+		fLockState = state;
 		if (state == 1) {
-			if (addon_state == 0) {
+			if (fAddonState == 0) {
 				status = InitClone();
-				
+				printf("InitClone() returned %s\n", strerror(status));
 				if (status == B_OK) {
-					addon_state = 1;
+					fAddonState = 1;
 					m_wei = (wait_engine_idle)m_gah(B_WAIT_ENGINE_IDLE, NULL);
 					m_re = (release_engine)m_gah(B_RELEASE_ENGINE, NULL);
 					m_ae = (acquire_engine)m_gah(B_ACQUIRE_ENGINE, NULL);
 				} else
-					addon_state = -1;
+					fAddonState = -1;
 			}
 			
-			if (addon_state == 1 && state == 1) {
+			if (fAddonState == 1 && state == 1) {
 				fill_rect_global = fill_rect;
 				blit_rect_global = blit_rect;
 				trans_blit_rect_global = trans_blit_rect;
@@ -842,59 +860,56 @@ BWindowScreen::GetCardInfo()
 	if (screen.GetMode(&mode) < B_OK)
 		return;
 	
-	uint32 bits_per_pixel;
+	uint32 bitsPerPixel;
 	switch(mode.space & 0x0fff) {
 		case B_CMAP8:
-			bits_per_pixel = 8;
+			bitsPerPixel = 8;
 			break;
 		case B_RGB16:
-			bits_per_pixel = 16;
+			bitsPerPixel = 16;
 			break;
 		case B_RGB32:
-			bits_per_pixel = 32;
+			bitsPerPixel = 32;
 			break;
 		default:
-			bits_per_pixel = 0;
+			bitsPerPixel = 0;
 			break;
 	}
 	
-	card_info.version = 2;
-	card_info.id = 0;
-	card_info.bits_per_pixel = bits_per_pixel;
-	card_info.width = mode.virtual_width;
-	card_info.height = mode.virtual_height;
+	fCardInfo.version = 2;
+	fCardInfo.id = 0;
+	fCardInfo.bits_per_pixel = bitsPerPixel;
+	fCardInfo.width = mode.virtual_width;
+	fCardInfo.height = mode.virtual_height;
 	
 	if (mode.space & 0x10)
-		strncpy(card_info.rgba_order, "rgba", 4);
+		strncpy(fCardInfo.rgba_order, "rgba", 4);
 	else
-		strncpy(card_info.rgba_order, "bgra", 4);
+		strncpy(fCardInfo.rgba_order, "bgra", 4);
 	
-	card_info.flags = 0;
+	fCardInfo.flags = 0;
 	
 	if (mode.flags & B_SCROLL)
-		card_info.flags |= B_FRAME_BUFFER_CONTROL;
+		fCardInfo.flags |= B_FRAME_BUFFER_CONTROL;
 	if (mode.flags & B_PARALLEL_ACCESS)
-		card_info.flags |= B_PARALLEL_BUFFER_ACCESS;
-	
-	screen_id id = screen.ID();
+		fCardInfo.flags |= B_PARALLEL_BUFFER_ACCESS;
 	
 	status_t result = B_ERROR;
 	
 	frame_buffer_config config;
-	
 	AppServerLink link;
 	link.StartMessage(AS_GET_FRAME_BUFFER_CONFIG);
-	link.Attach<screen_id>(id);
+	link.Attach<screen_id>(screen.ID());
 	if (link.FlushWithReply(result) == B_OK && result == B_OK)
 		link.Read<frame_buffer_config>(&config);
 	
 	if (result == B_OK) {
-		card_info.id = id.id;
-		card_info.frame_buffer = config.frame_buffer;
-		card_info.bytes_per_row = config.bytes_per_row;
+		fCardInfo.id = screen.ID().id;
+		fCardInfo.frame_buffer = config.frame_buffer;
+		fCardInfo.bytes_per_row = config.bytes_per_row;
 	}
 	
-	memcpy(&card_info_global, &card_info, sizeof(graphics_card_info));
+	memcpy(&card_info_global, &fCardInfo, sizeof(graphics_card_info));
 }
 
 
@@ -903,21 +918,21 @@ BWindowScreen::Suspend()
 {
 	CALLED();
 	
-	while (acquire_sem(debug_sem) == B_INTERRUPTED)
+	while (acquire_sem(fDebugSem) == B_INTERRUPTED)
 		;
 
 	// Suspend all the registered threads
-	for (int i = 0; i < debug_list_count; i++) {
+	for (int32 i = 0; i < fDebugListCount; i++) {
 		snooze(10000);
-		suspend_thread(debug_list[i]);
+		suspend_thread(fDebugList[i]);
 	}
 
 	graphics_card_info *info = CardInfo();
 	size_t fbSize = info->bytes_per_row * info->height; 
 
 	// Save the content of the frame buffer into the local buffer
-	debug_buffer = (char *)malloc(fbSize);
-	memcpy(debug_buffer, info->frame_buffer, fbSize);
+	fDebugBuffer = (char *)malloc(fbSize);
+	memcpy(fDebugBuffer, info->frame_buffer, fbSize);
 }
 
 
@@ -928,14 +943,14 @@ BWindowScreen::Resume()
 	graphics_card_info *info = CardInfo();
 	
 	// Copy the content of the debug_buffer back into the frame buffer.
-	memcpy(info->frame_buffer, debug_buffer, info->bytes_per_row * info->height);
-	free(debug_buffer);
+	memcpy(info->frame_buffer, fDebugBuffer, info->bytes_per_row * info->height);
+	free(fDebugBuffer);
 
 	// Resume all the registered threads
-	for (int i = 0; i < debug_list_count; i++)
-		resume_thread(debug_list[i]);
+	for (int32 i = 0; i < fDebugListCount; i++)
+		resume_thread(fDebugList[i]);
 
-	release_sem(debug_sem);
+	release_sem(fDebugSem);
 }
 
 
@@ -944,24 +959,24 @@ BWindowScreen::GetModeFromSpace(uint32 space, display_mode *dmode)
 {
 	CALLED();
 	
-	uint32 out_space;
+	uint32 destSpace;
 	int32 width, height;
-	status_t ret = B_ERROR;
+	status_t status = B_ERROR;
 	
-	mode2parms(space, &out_space, &width, &height);
+	mode2parms(space, &destSpace, &width, &height);
 	// mode2parms converts the space to actual width, height and color_space, e.g B_8_BIT_640x480
 	
-	for (uint32 i = 0; i < mode_count; i++) {
-		if (mode_list[i].space == out_space && mode_list[i].virtual_width == width
-			&& mode_list[i].virtual_height == height) {
+	for (uint32 i = 0; i < fModeCount; i++) {
+		if (fModeList[i].space == destSpace && fModeList[i].virtual_width == width
+			&& fModeList[i].virtual_height == height) {
 			
-			memcpy(dmode, &mode_list[i], sizeof(display_mode));
-			ret = B_OK;
+			memcpy(dmode, &fModeList[i], sizeof(display_mode));
+			status = B_OK;
 			break;
 		}
 	}
 	
-	return ret;
+	return status;
 }
 
 
@@ -971,7 +986,7 @@ BWindowScreen::InitClone()
 	CALLED();
 	AppServerLink link;
 	link.StartMessage(AS_GET_ACCELERANT_NAME);
-	link.Attach<int32>(screen_index);
+	link.Attach<int32>(fScreenIndex);
 	
 	status_t status = B_ERROR;
 	if (link.FlushWithReply(status) < B_OK || status < B_OK)
@@ -979,28 +994,28 @@ BWindowScreen::InitClone()
 
 	BString accelerantName;
 	link.ReadString(accelerantName);
-	addon_image = load_add_on(accelerantName.String()); 
-	if (addon_image < B_OK)
-		return addon_image;
+	fAddonImage = load_add_on(accelerantName.String()); 
+	if (fAddonImage < B_OK)
+		return fAddonImage;
 
 	
-	status = get_image_symbol(addon_image, "get_accelerant_hook", B_SYMBOL_TYPE_ANY, (void **)&m_gah);
+	status = get_image_symbol(fAddonImage, "get_accelerant_hook", B_SYMBOL_TYPE_ANY, (void **)&m_gah);
 	if (status < B_OK) {
-		unload_add_on(addon_image);
-		addon_image = -1;
+		unload_add_on(fAddonImage);
+		fAddonImage = -1;
 		return status;
 	}
 	
 	clone_accelerant clone = (clone_accelerant)m_gah(B_CLONE_ACCELERANT, 0);
-	if (!clone) {
-		unload_add_on(addon_image);
-		addon_image = -1;
+	if (clone == NULL) {
+		unload_add_on(fAddonImage);
+		fAddonImage = -1;
 		return status;
 	}
 
 	status = B_ERROR;
 	link.StartMessage(AS_GET_DRIVER_NAME);
-	link.Attach<int32>(screen_index);
+	link.Attach<int32>(fScreenIndex);
 	if (link.FlushWithReply(status) == B_OK && status == B_OK) {
 		BString driverName;
 		link.ReadString(driverName);
@@ -1008,8 +1023,8 @@ BWindowScreen::InitClone()
 	}
 	
 	if (status < B_OK) {
-		unload_add_on(addon_image);
-		addon_image = -1;
+		unload_add_on(fAddonImage);
+		fAddonImage = -1;
 	}
 	
 	return status;
@@ -1019,25 +1034,25 @@ BWindowScreen::InitClone()
 status_t
 BWindowScreen::AssertDisplayMode(display_mode *dmode)
 {
-	status_t result = B_ERROR;
+	status_t result = B_OK;
 
 	// TODO: Assert display mode: negotiation with app server
 
-	// if the result is B_OK, we copy the dmode to new_space
 	if (result == B_OK) { 
-		memcpy(new_space, dmode, sizeof(display_mode));
+		memcpy(fDisplayMode, dmode, sizeof(display_mode));
 		space_mode = 1;
 	}
+	
 	GetCardInfo();
 	
-	format_info.bits_per_pixel = card_info.bits_per_pixel;
-	format_info.bytes_per_row = card_info.bytes_per_row;
-	format_info.width = card_info.width;
-	format_info.height = card_info.height;
-	format_info.display_width = card_info.width;
-	format_info.display_height = card_info.height;
-	format_info.display_x = 0;
-	format_info.display_y = 0;
+	fFrameBufferInfo.bits_per_pixel = fCardInfo.bits_per_pixel;
+	fFrameBufferInfo.bytes_per_row = fCardInfo.bytes_per_row;
+	fFrameBufferInfo.width = fCardInfo.width;
+	fFrameBufferInfo.height = fCardInfo.height;
+	fFrameBufferInfo.display_width = fCardInfo.width;
+	fFrameBufferInfo.display_height = fCardInfo.height;
+	fFrameBufferInfo.display_x = 0;
+	fFrameBufferInfo.display_y = 0;
 	
 	return result;
 }