remove trailing whitespace

(cherry picked from commit 4a4f2479146aa33e235ed57cde311efda68d3c8f)
2026-01-02 21:48:21 +03:00 · 2016-04-02 22:03:48 +02:00
19 changed files with 204 additions and 647 deletions
--- a/27
+++ b/27
@@ -1,28 +1,25 @@
-#!/usr/bin/env python
-
 Import('env')

 common_haiku = [
-    'os_haiku.cpp',
-    'context_gl_haiku.cpp',
-    'haiku_application.cpp',
-    'haiku_direct_window.cpp',
-    'haiku_gl_view.cpp',
-    'key_mapping_haiku.cpp',
-    'audio_driver_media_kit.cpp'
+	'os_haiku.cpp',
+	'context_gl_haiku.cpp',
+	'haiku_application.cpp',
+	'haiku_direct_window.cpp',
+	'haiku_gl_view.cpp',
+	'key_mapping_haiku.cpp',
+	'audio_driver_media_kit.cpp'
 ]

 target = env.Program(
-    '#bin/godot',
-    ['godot_haiku.cpp'] + common_haiku
+	'#bin/godot',
+	['godot_haiku.cpp'] + common_haiku
 )

 command = env.Command('#bin/godot.rsrc', '#platform/haiku/godot.rdef',
-                      ['rc -o $TARGET $SOURCE'])
+		['rc -o $TARGET $SOURCE'])

-
-def addResourcesAction(target=None, source=None, env=None):
-    return env.Execute('xres -o ' + File(target)[0].path + ' bin/godot.rsrc')
+def addResourcesAction(target = None, source = None, env = None):
+	return env.Execute('xres -o ' + File(target)[0].path + ' bin/godot.rsrc')

 env.AddPostAction(target, addResourcesAction)
 env.Depends(target, command)
--- a/audio_driver_media_kit.cpp
+++ b/audio_driver_media_kit.cpp
@@ -3,10 +3,9 @@
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
+/*                    http://www.godotengine.org                         */
 /*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -33,7 +32,7 @@

 #include "globals.h"

-int32_t *AudioDriverMediaKit::samples_in = NULL;
+int32_t* AudioDriverMediaKit::samples_in = NULL;

 Error AudioDriverMediaKit::init() {
 	active = false;
@@ -43,7 +42,7 @@ Error AudioDriverMediaKit::init() {
 	channels = 2;

 	int latency = GLOBAL_DEF("audio/output_latency", 25);
-	buffer_size = closest_power_of_2(latency * mix_rate / 1000);
+	buffer_size = nearest_power_of_2(latency * mix_rate / 1000);
 	samples_in = memnew_arr(int32_t, buffer_size * channels);

 	media_raw_audio_format format;
@@ -55,11 +54,12 @@ Error AudioDriverMediaKit::init() {
 	format.buffer_size = buffer_size * sizeof(int32_t) * channels;

 	player = new BSoundPlayer(
-			&format,
-			"godot_sound_server",
-			AudioDriverMediaKit::PlayBuffer,
-			NULL,
-			this);
+		&format,
+		"godot_sound_server",
+		AudioDriverMediaKit::PlayBuffer,
+		NULL,
+		this
+	);

 	if (player->InitCheck() != B_OK) {
 		fprintf(stderr, "MediaKit ERR: can not create a BSoundPlayer instance\n");
@@ -72,9 +72,9 @@ Error AudioDriverMediaKit::init() {
 	return OK;
 }

-void AudioDriverMediaKit::PlayBuffer(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format) {
-	AudioDriverMediaKit *ad = (AudioDriverMediaKit *)cookie;
-	int32_t *buf = (int32_t *)buffer;
+void AudioDriverMediaKit::PlayBuffer(void* cookie, void* buffer, size_t size, const media_raw_audio_format& format) {
+	AudioDriverMediaKit* ad = (AudioDriverMediaKit*) cookie;
+	int32_t* buf = (int32_t*) buffer;

 	if (!ad->active) {
 		for (unsigned int i = 0; i < ad->buffer_size * ad->channels; i++) {
@@ -136,6 +136,7 @@ AudioDriverMediaKit::AudioDriverMediaKit() {
 }

 AudioDriverMediaKit::~AudioDriverMediaKit() {
+
 }

 #endif
--- a/audio_driver_media_kit.h
+++ b/audio_driver_media_kit.h
@@ -3,10 +3,9 @@
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
+/*                    http://www.godotengine.org                         */
 /*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -31,19 +30,19 @@

 #ifdef MEDIA_KIT_ENABLED

-#include "core/os/mutex.h"
 #include "core/os/thread.h"
+#include "core/os/mutex.h"

-#include <SoundPlayer.h>
 #include <kernel/image.h> // needed for image_id
+#include <SoundPlayer.h>

 class AudioDriverMediaKit : public AudioDriverSW {
-	Mutex *mutex;
+	Mutex* mutex;

-	BSoundPlayer *player;
-	static int32_t *samples_in;
+	BSoundPlayer* player;
+	static int32_t* samples_in;

-	static void PlayBuffer(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format);
+	static void PlayBuffer(void* cookie, void* buffer, size_t size, const media_raw_audio_format& format);

 	unsigned int mix_rate;
 	OutputFormat output_format;
@@ -53,7 +52,8 @@ class AudioDriverMediaKit : public AudioDriverSW {
 	bool active;

 public:
-	const char *get_name() const {
+
+	const char* get_name() const {
 		return "MediaKit";
 	};

--- a/context_gl_haiku.cpp
+++ b/context_gl_haiku.cpp
@@ -1,43 +1,12 @@
-/*************************************************************************/
-/*  context_gl_haiku.cpp                                                 */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include "context_gl_haiku.h"

 #if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)

-ContextGL_Haiku::ContextGL_Haiku(HaikuDirectWindow *p_window) {
+ContextGL_Haiku::ContextGL_Haiku(HaikuDirectWindow* p_window) {
 	window = p_window;

 	uint32 type = BGL_RGB | BGL_DOUBLE | BGL_DEPTH;
 	view = new HaikuGLView(window->Bounds(), type);
-
-	use_vsync = false;
 }

 ContextGL_Haiku::~ContextGL_Haiku() {
@@ -60,7 +29,7 @@ void ContextGL_Haiku::make_current() {
 }

 void ContextGL_Haiku::swap_buffers() {
-	view->SwapBuffers(use_vsync);
+	view->SwapBuffers();
 }

 int ContextGL_Haiku::get_window_width() {
@@ -71,12 +40,4 @@ int ContextGL_Haiku::get_window_height() {
 	return window->Bounds().IntegerHeight();
 }

-void ContextGL_Haiku::set_use_vsync(bool p_use) {
-	use_vsync = p_use;
-}
-
-bool ContextGL_Haiku::is_using_vsync() const {
-	return use_vsync;
-}
-
 #endif
--- a/context_gl_haiku.h
+++ b/context_gl_haiku.h
@@ -1,32 +1,3 @@
-/*************************************************************************/
-/*  context_gl_haiku.h                                                   */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #ifndef CONTEXT_GL_HAIKU_H
 #define CONTEXT_GL_HAIKU_H

@@ -39,13 +10,11 @@

 class ContextGL_Haiku : public ContextGL {
 private:
-	HaikuGLView *view;
-	HaikuDirectWindow *window;
-
-	bool use_vsync;
+	HaikuGLView* view;
+	HaikuDirectWindow* window;

 public:
-	ContextGL_Haiku(HaikuDirectWindow *p_window);
+	ContextGL_Haiku(HaikuDirectWindow* p_window);
 	~ContextGL_Haiku();

 	virtual Error initialize();
@@ -54,9 +23,6 @@ public:
 	virtual void swap_buffers();
 	virtual int get_window_width();
 	virtual int get_window_height();
-
-	virtual void set_use_vsync(bool p_use);
-	virtual bool is_using_vsync() const;
 };

 #endif
--- a/detect.py
+++ b/detect.py
@@ -1,67 +1,62 @@
 import os
 import sys

-
 def is_active():
-    return True
-
+	return True

 def get_name():
-    return "Haiku"
-
+	return "Haiku"

 def can_build():
-    if (os.name != "posix"):
-        return False
+	if (os.name != "posix"):
+		return False

-    if (sys.platform == "darwin"):
-        return False
-
-    return True
+	if (sys.platform == "darwin"):
+		return False

+	return True

 def get_opts():
-    return [
-        ('debug_release', 'Add debug symbols to release version', 'no')
-    ]
-
+	return [
+		('debug_release', 'Add debug symbols to release version','no')
+	]

 def get_flags():
-    return [
-    ]
-
+	return [
+		('builtin_zlib', 'no')
+	]

 def configure(env):
-    is64 = sys.maxsize > 2**32
+	is64 = sys.maxsize > 2**32

-    if (env["bits"] == "default"):
-        if (is64):
-            env["bits"] = "64"
-        else:
-            env["bits"] = "32"
+	if (env["bits"]=="default"):
+		if (is64):
+			env["bits"]="64"
+		else:
+			env["bits"]="32"

-    env.Append(CPPPATH=['#platform/haiku'])
+	env.Append(CPPPATH = ['#platform/haiku'])

-    env["CC"] = "gcc-x86"
-    env["CXX"] = "g++-x86"
+	env["CC"] = "gcc"
+	env["CXX"] = "g++"

-    if (env["target"] == "release"):
-        if (env["debug_release"] == "yes"):
-            env.Append(CCFLAGS=['-g2'])
-        else:
-            env.Append(CCFLAGS=['-O3', '-ffast-math'])
-    elif (env["target"] == "release_debug"):
-        env.Append(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED'])
-    elif (env["target"] == "debug"):
-        env.Append(CCFLAGS=['-g2', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED'])
+	if (env["target"]=="release"):
+		if (env["debug_release"]=="yes"):
+			env.Append(CCFLAGS=['-g2'])
+		else:
+			env.Append(CCFLAGS=['-O3','-ffast-math'])
+	elif (env["target"]=="release_debug"):
+		env.Append(CCFLAGS=['-O2','-ffast-math','-DDEBUG_ENABLED'])
+	elif (env["target"]=="debug"):
+		env.Append(CCFLAGS=['-g2', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])

-    # env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
-    env.Append(CPPFLAGS=['-DPTHREAD_NO_RENAME'])  # TODO: enable when we have pthread_setname_np
-    env.Append(CPPFLAGS=['-DOPENGL_ENABLED', '-DMEDIA_KIT_ENABLED'])
-    env.Append(CPPFLAGS=['-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DGLES_OVER_GL'])
-    env.Append(LIBS=['be', 'game', 'media', 'network', 'bnetapi', 'z', 'GL'])
+	#env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
+	env.Append(CPPFLAGS = ['-DPTHREAD_NO_RENAME']) # TODO: enable when we have pthread_setname_np
+	env.Append(CPPFLAGS = ['-DGLEW_ENABLED', '-DOPENGL_ENABLED', '-DMEDIA_KIT_ENABLED'])
+	env.Append(CPPFLAGS = ['-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DGLES_OVER_GL'])
+	env.Append(LIBS = ['be', 'game', 'media', 'network', 'bnetapi', 'z', 'GL', 'GLEW'])

-    import methods
-    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.gen.h', src_suffix='.glsl')})
-    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.gen.h', src_suffix='.glsl')})
-    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.gen.h', src_suffix='.glsl')})
+	import methods
+	env.Append(BUILDERS = {'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl')})
+	env.Append(BUILDERS = {'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl')})
+	env.Append(BUILDERS = {'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl')})
--- a/godot_haiku.cpp
+++ b/godot_haiku.cpp
@@ -1,39 +1,10 @@
-/*************************************************************************/
-/*  godot_haiku.cpp                                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include "main/main.h"
 #include "os_haiku.h"

-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
 	OS_Haiku os;

-	Error error = Main::setup(argv[0], argc - 1, &argv[1]);
+	Error error = Main::setup(argv[0], argc-1, &argv[1]);
 	if (error != OK) {
 		return 255;
 	}
--- a/haiku_application.cpp
+++ b/haiku_application.cpp
@@ -1,34 +1,7 @@
-/*************************************************************************/
-/*  haiku_application.cpp                                                */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include "haiku_application.h"

 HaikuApplication::HaikuApplication()
-	: BApplication("application/x-vnd.godot") {
+   : BApplication("application/x-vnd.godot")
+{
+
 }
--- a/haiku_application.h
+++ b/haiku_application.h
@@ -1,41 +1,13 @@
-/*************************************************************************/
-/*  haiku_application.h                                                  */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #ifndef HAIKU_APPLICATION_H
 #define HAIKU_APPLICATION_H

-#include <Application.h>
 #include <kernel/image.h> // needed for image_id
+#include <Application.h>

-class HaikuApplication : public BApplication {
+class HaikuApplication : public BApplication
+{
 public:
-	HaikuApplication();
+   HaikuApplication();
 };

 #endif
--- a/haiku_direct_window.cpp
+++ b/haiku_direct_window.cpp
@@ -1,69 +1,42 @@
-/*************************************************************************/
-/*  haiku_direct_window.cpp                                              */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include <UnicodeChar.h>

-#include "haiku_direct_window.h"
-#include "key_mapping_haiku.h"
 #include "main/main.h"
 #include "os/keyboard.h"
+#include "haiku_direct_window.h"
+#include "key_mapping_haiku.h"

 HaikuDirectWindow::HaikuDirectWindow(BRect p_frame)
-	: BDirectWindow(p_frame, "Godot", B_TITLED_WINDOW, B_QUIT_ON_WINDOW_CLOSE) {
+   : BDirectWindow(p_frame, "Godot", B_TITLED_WINDOW, B_QUIT_ON_WINDOW_CLOSE)
+{
 	last_mouse_pos_valid = false;
 	last_buttons_state = 0;
 	last_button_mask = 0;
 	last_key_modifier_state = 0;
 }

+
 HaikuDirectWindow::~HaikuDirectWindow() {
 	delete update_runner;
 }

-void HaikuDirectWindow::SetHaikuGLView(HaikuGLView *p_view) {
+void HaikuDirectWindow::SetHaikuGLView(HaikuGLView* p_view) {
 	view = p_view;
 }

 void HaikuDirectWindow::StartMessageRunner() {
 	update_runner = new BMessageRunner(BMessenger(this),
-			new BMessage(REDRAW_MSG), 1000000 / 30 /* 30 fps */);
+		new BMessage(REDRAW_MSG), 1000000/30 /* 30 fps */);
 }

 void HaikuDirectWindow::StopMessageRunner() {
 	delete update_runner;
 }

-void HaikuDirectWindow::SetInput(InputDefault *p_input) {
+void HaikuDirectWindow::SetInput(InputDefault* p_input) {
 	input = p_input;
 }

-void HaikuDirectWindow::SetMainLoop(MainLoop *p_main_loop) {
+void HaikuDirectWindow::SetMainLoop(MainLoop* p_main_loop) {
 	main_loop = p_main_loop;
 }

@@ -72,12 +45,12 @@ bool HaikuDirectWindow::QuitRequested() {
 	return false;
 }

-void HaikuDirectWindow::DirectConnected(direct_buffer_info *info) {
+void HaikuDirectWindow::DirectConnected(direct_buffer_info* info) {
 	view->DirectConnected(info);
 	view->EnableDirectMode(true);
 }

-void HaikuDirectWindow::MessageReceived(BMessage *message) {
+void HaikuDirectWindow::MessageReceived(BMessage* message) {
 	switch (message->what) {
 		case REDRAW_MSG:
 			if (Main::iteration() == true) {
@@ -91,7 +64,7 @@ void HaikuDirectWindow::MessageReceived(BMessage *message) {
 	}
 }

-void HaikuDirectWindow::DispatchMessage(BMessage *message, BHandler *handler) {
+void HaikuDirectWindow::DispatchMessage(BMessage* message, BHandler* handler) {
 	switch (message->what) {
 		case B_MOUSE_DOWN:
 		case B_MOUSE_UP:
@@ -132,7 +105,7 @@ void HaikuDirectWindow::DispatchMessage(BMessage *message, BHandler *handler) {
 	}
 }

-void HaikuDirectWindow::HandleMouseButton(BMessage *message) {
+void HaikuDirectWindow::HandleMouseButton(BMessage* message) {
 	BPoint where;
 	if (message->FindPoint("where", &where) != B_OK) {
 		return;
@@ -182,14 +155,14 @@ void HaikuDirectWindow::HandleMouseButton(BMessage *message) {
 		int32 clicks = message->FindInt32("clicks");

 		if (clicks > 1) {
-			mouse_event.mouse_button.doubleclick = true;
+			mouse_event.mouse_button.doubleclick=true;
 		}
 	}

 	input->parse_input_event(mouse_event);
 }

-void HaikuDirectWindow::HandleMouseMoved(BMessage *message) {
+void HaikuDirectWindow::HandleMouseMoved(BMessage* message) {
 	BPoint where;
 	if (message->FindPoint("where", &where) != B_OK) {
 		return;
@@ -229,7 +202,7 @@ void HaikuDirectWindow::HandleMouseMoved(BMessage *message) {
 	input->parse_input_event(motion_event);
 }

-void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) {
+void HaikuDirectWindow::HandleMouseWheelChanged(BMessage* message) {
 	float wheel_delta_y = 0;
 	if (message->FindFloat("be:wheel_delta_y", &wheel_delta_y) != B_OK) {
 		return;
@@ -256,7 +229,7 @@ void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) {
 	input->parse_input_event(mouse_event);
 }

-void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) {
+void HaikuDirectWindow::HandleKeyboardEvent(BMessage* message) {
 	int32 raw_char = 0;
 	int32 key = 0;
 	int32 modifiers = 0;
@@ -283,21 +256,21 @@ void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) {
 	event.key.echo = message->HasInt32("be:key_repeat");
 	event.key.unicode = 0;

-	const char *bytes = NULL;
+	const char* bytes = NULL;
 	if (message->FindString("bytes", &bytes) == B_OK) {
 		event.key.unicode = BUnicodeChar::FromUTF8(&bytes);
 	}

 	//make it consistent accross platforms.
-	if (event.key.scancode == KEY_BACKTAB) {
-		event.key.scancode = KEY_TAB;
-		event.key.mod.shift = true;
+	if (event.key.scancode==KEY_BACKTAB) {
+		event.key.scancode=KEY_TAB;
+		event.key.mod.shift=true;
 	}

 	input->parse_input_event(event);
 }

-void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage *message) {
+void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage* message) {
 	int32 old_modifiers = 0;
 	int32 modifiers = 0;

@@ -324,7 +297,7 @@ void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage *message) {
 	input->parse_input_event(event);
 }

-void HaikuDirectWindow::HandleWindowResized(BMessage *message) {
+void HaikuDirectWindow::HandleWindowResized(BMessage* message) {
 	int32 width = 0;
 	int32 height = 0;

--- a/haiku_direct_window.h
+++ b/haiku_direct_window.h
@@ -1,37 +1,8 @@
-/*************************************************************************/
-/*  haiku_direct_window.h                                                */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #ifndef HAIKU_DIRECT_WINDOW_H
 #define HAIKU_DIRECT_WINDOW_H

-#include <DirectWindow.h>
 #include <kernel/image.h> // needed for image_id
+#include <DirectWindow.h>

 #include "core/os/os.h"
 #include "main/input_default.h"
@@ -42,7 +13,8 @@
 #define LOCKGL_MSG 'glck'
 #define UNLOCKGL_MSG 'ulck'

-class HaikuDirectWindow : public BDirectWindow {
+class HaikuDirectWindow : public BDirectWindow
+{
 private:
 	unsigned int event_id;
 	Point2i last_mouse_position;
@@ -50,19 +22,19 @@ private:
 	uint32 last_buttons_state;
 	uint32 last_key_modifier_state;
 	int last_button_mask;
-	OS::VideoMode *current_video_mode;
+	OS::VideoMode* current_video_mode;

-	MainLoop *main_loop;
-	InputDefault *input;
-	HaikuGLView *view;
-	BMessageRunner *update_runner;
+	MainLoop* main_loop;
+	InputDefault* input;
+	HaikuGLView* view;
+	BMessageRunner* update_runner;

-	void HandleMouseButton(BMessage *message);
-	void HandleMouseMoved(BMessage *message);
-	void HandleMouseWheelChanged(BMessage *message);
-	void HandleWindowResized(BMessage *message);
-	void HandleKeyboardEvent(BMessage *message);
-	void HandleKeyboardModifierEvent(BMessage *message);
+	void HandleMouseButton(BMessage* message);
+	void HandleMouseMoved(BMessage* message);
+	void HandleMouseWheelChanged(BMessage* message);
+	void HandleWindowResized(BMessage* message);
+	void HandleKeyboardEvent(BMessage* message);
+	void HandleKeyboardModifierEvent(BMessage* message);
 	inline InputModifierState GetKeyModifierState(uint32 p_state);
 	inline int GetMouseButtonState(uint32 p_state);

@@ -70,16 +42,16 @@ public:
 	HaikuDirectWindow(BRect p_frame);
 	~HaikuDirectWindow();

-	void SetHaikuGLView(HaikuGLView *p_view);
+	void SetHaikuGLView(HaikuGLView* p_view);
 	void StartMessageRunner();
 	void StopMessageRunner();
-	void SetInput(InputDefault *p_input);
-	void SetMainLoop(MainLoop *p_main_loop);
-	inline void SetVideoMode(OS::VideoMode *video_mode) { current_video_mode = video_mode; };
+	void SetInput(InputDefault* p_input);
+	void SetMainLoop(MainLoop* p_main_loop);
+	inline void SetVideoMode(OS::VideoMode* video_mode) { current_video_mode = video_mode; };
 	virtual bool QuitRequested();
-	virtual void DirectConnected(direct_buffer_info *info);
-	virtual void MessageReceived(BMessage *message);
-	virtual void DispatchMessage(BMessage *message, BHandler *handler);
+	virtual void DirectConnected(direct_buffer_info* info);
+	virtual void MessageReceived(BMessage* message);
+	virtual void DispatchMessage(BMessage* message, BHandler* handler);

 	inline Point2i GetLastMousePosition() { return last_mouse_position; };
 	inline int GetLastButtonMask() { return last_button_mask; };
--- a/haiku_gl_view.cpp
+++ b/haiku_gl_view.cpp
@@ -1,37 +1,9 @@
-/*************************************************************************/
-/*  haiku_gl_view.cpp                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#include "haiku_gl_view.h"
 #include "main/main.h"
+#include "haiku_gl_view.h"

 HaikuGLView::HaikuGLView(BRect frame, uint32 type)
-	: BGLView(frame, "GodotGLView", B_FOLLOW_ALL_SIDES, 0, type) {
+   : BGLView(frame, "GodotGLView", B_FOLLOW_ALL_SIDES, 0, type)
+{
 }

 void HaikuGLView::AttachedToWindow(void) {
--- a/haiku_gl_view.h
+++ b/haiku_gl_view.h
@@ -1,39 +1,11 @@
-/*************************************************************************/
-/*  haiku_gl_view.h                                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #ifndef HAIKU_GL_VIEW_H
 #define HAIKU_GL_VIEW_H

-#include <GLView.h>
 #include <kernel/image.h> // needed for image_id
+#include <GLView.h>

-class HaikuGLView : public BGLView {
+class HaikuGLView : public BGLView
+{
 public:
 	HaikuGLView(BRect frame, uint32 type);
 	virtual void AttachedToWindow(void);
--- a/key_mapping_haiku.cpp
+++ b/key_mapping_haiku.cpp
@@ -1,32 +1,3 @@
-/*************************************************************************/
-/*  key_mapping_haiku.cpp                                                */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include <InterfaceDefs.h>

 #include "key_mapping_haiku.h"
@@ -137,7 +108,7 @@ static _HaikuTranslatePair _hb_to_keycode[] = {
 	{ KEY_Y, (0x79) },
 	{ KEY_Z, (0x7A) },

-	/*
+/*
 { KEY_PLAY, VK_PLAY},// (0xFA)
 { KEY_STANDBY,VK_SLEEP },//(0x5F)
 { KEY_BACK,VK_BROWSER_BACK},// (0xA6)
@@ -178,48 +149,22 @@ static _HaikuTranslatePair _hb_to_keycode[] = {
 };

 unsigned int KeyMappingHaiku::get_keysym(int32 raw_char, int32 key) {
-	if (raw_char == B_INSERT && key == 0x64) {
-		return KEY_KP_0;
-	}
-	if (raw_char == B_END && key == 0x58) {
-		return KEY_KP_1;
-	}
-	if (raw_char == B_DOWN_ARROW && key == 0x59) {
-		return KEY_KP_2;
-	}
-	if (raw_char == B_PAGE_DOWN && key == 0x5A) {
-		return KEY_KP_3;
-	}
-	if (raw_char == B_LEFT_ARROW && key == 0x48) {
-		return KEY_KP_4;
-	}
-	if (raw_char == 0x35 && key == 0x49) {
-		return KEY_KP_5;
-	}
-	if (raw_char == B_RIGHT_ARROW && key == 0x4A) {
-		return KEY_KP_6;
-	}
-	if (raw_char == B_HOME && key == 0x37) {
-		return KEY_KP_7;
-	}
-	if (raw_char == B_UP_ARROW && key == 0x38) {
-		return KEY_KP_8;
-	}
-	if (raw_char == B_PAGE_UP && key == 0x39) {
-		return KEY_KP_9;
-	}
-	if (raw_char == 0x2F && key == 0x23) {
-		return KEY_KP_DIVIDE;
-	}
-	if (raw_char == 0x2D && key == 0x25) {
-		return KEY_KP_SUBTRACT;
-	}
-	if (raw_char == B_DELETE && key == 0x65) {
-		return KEY_KP_PERIOD;
-	}
+	if (raw_char == B_INSERT && key == 0x64) { return KEY_KP_0; }
+	if (raw_char == B_END && key == 0x58) { return KEY_KP_1; }
+	if (raw_char == B_DOWN_ARROW && key == 0x59) { return KEY_KP_2; }
+	if (raw_char == B_PAGE_DOWN && key == 0x5A) { return KEY_KP_3; }
+	if (raw_char == B_LEFT_ARROW && key == 0x48) { return KEY_KP_4; }
+	if (raw_char == 0x35 && key == 0x49) { return KEY_KP_5; }
+	if (raw_char == B_RIGHT_ARROW && key == 0x4A) { return KEY_KP_6; }
+	if (raw_char == B_HOME && key == 0x37) { return KEY_KP_7; }
+	if (raw_char == B_UP_ARROW && key == 0x38) { return KEY_KP_8; }
+	if (raw_char == B_PAGE_UP && key == 0x39) { return KEY_KP_9; }
+	if (raw_char == 0x2F && key == 0x23) { return KEY_KP_DIVIDE; }
+	if (raw_char == 0x2D && key == 0x25) { return KEY_KP_SUBTRACT; }
+	if (raw_char == B_DELETE && key == 0x65) { return KEY_KP_PERIOD; }

 	if (raw_char == 0x10) {
-		for (int i = 0; _fn_to_keycode[i].keysym != KEY_UNKNOWN; i++) {
+		for(int i = 0; _fn_to_keycode[i].keysym != KEY_UNKNOWN; i++) {
 			if (_fn_to_keycode[i].keycode == key) {
 				return _fn_to_keycode[i].keysym;
 			}
@@ -228,7 +173,7 @@ unsigned int KeyMappingHaiku::get_keysym(int32 raw_char, int32 key) {
 		return KEY_UNKNOWN;
 	}

-	for (int i = 0; _hb_to_keycode[i].keysym != KEY_UNKNOWN; i++) {
+	for(int i = 0; _hb_to_keycode[i].keysym != KEY_UNKNOWN; i++) {
 		if (_hb_to_keycode[i].keycode == raw_char) {
 			return _hb_to_keycode[i].keysym;
 		}
@@ -238,7 +183,7 @@ unsigned int KeyMappingHaiku::get_keysym(int32 raw_char, int32 key) {
 }

 unsigned int KeyMappingHaiku::get_modifier_keysym(int32 key) {
-	for (int i = 0; _mod_to_keycode[i].keysym != KEY_UNKNOWN; i++) {
+	for(int i = 0; _mod_to_keycode[i].keysym != KEY_UNKNOWN; i++) {
 		if ((_mod_to_keycode[i].keycode & key) != 0) {
 			return _mod_to_keycode[i].keysym;
 		}
--- a/key_mapping_haiku.h
+++ b/key_mapping_haiku.h
@@ -1,37 +1,9 @@
-/*************************************************************************/
-/*  key_mapping_haiku.h                                                  */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #ifndef KEY_MAPPING_HAIKU_H
 #define KEY_MAPPING_HAIKU_H

-class KeyMappingHaiku {
-	KeyMappingHaiku(){};
+class KeyMappingHaiku
+{
+	KeyMappingHaiku() {};

 public:
 	static unsigned int get_keysym(int32 raw_char, int32 key);
--- a/logo.png
+++ b/logo.png
--- a/os_haiku.cpp
+++ b/os_haiku.cpp
@@ -1,43 +1,15 @@
-/*************************************************************************/
-/*  os_haiku.cpp                                                         */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include <Screen.h>

-#include "drivers/gles2/rasterizer_gles2.h"
-#include "servers/physics/physics_server_sw.h"
 #include "servers/visual/visual_server_raster.h"
 #include "servers/visual/visual_server_wrap_mt.h"
+#include "drivers/gles2/rasterizer_gles2.h"
+#include "servers/physics/physics_server_sw.h"
 //#include "servers/physics_2d/physics_2d_server_wrap_mt.h"
 #include "main/main.h"

 #include "os_haiku.h"

+
 OS_Haiku::OS_Haiku() {
 #ifdef MEDIA_KIT_ENABLED
 	AudioDriverManagerSW::add_driver(&driver_media_kit);
@@ -53,8 +25,8 @@ void OS_Haiku::run() {
 	context_gl->release_current();

 	// TODO: clean up
-	BMessenger *bms = new BMessenger(window);
-	BMessage *msg = new BMessage();
+	BMessenger* bms = new BMessenger(window);
+	BMessage* msg = new BMessage();
 	bms->SendMessage(LOCKGL_MSG, msg);

 	window->StartMessageRunner();
@@ -76,7 +48,7 @@ int OS_Haiku::get_video_driver_count() const {
 	return 1;
 }

-const char *OS_Haiku::get_video_driver_name(int p_driver) const {
+const char* OS_Haiku::get_video_driver_name(int p_driver) const {
 	return "GLES2";
 }

@@ -84,7 +56,7 @@ OS::VideoMode OS_Haiku::get_default_video_mode() const {
 	return OS::VideoMode(800, 600, false);
 }

-void OS_Haiku::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
+void OS_Haiku::initialize(const VideoMode& p_desired, int p_video_driver, int p_audio_driver) {
 	main_loop = NULL;
 	current_video_mode = p_desired;

@@ -187,13 +159,13 @@ void OS_Haiku::finalize() {
 #endif
 }

-void OS_Haiku::set_main_loop(MainLoop *p_main_loop) {
+void OS_Haiku::set_main_loop(MainLoop* p_main_loop) {
 	main_loop = p_main_loop;
 	input->set_main_loop(p_main_loop);
 	window->SetMainLoop(p_main_loop);
 }

-MainLoop *OS_Haiku::get_main_loop() const {
+MainLoop* OS_Haiku::get_main_loop() const {
 	return main_loop;
 }

@@ -251,7 +223,7 @@ void OS_Haiku::set_current_screen(int p_screen) {

 Point2 OS_Haiku::get_screen_position(int p_screen) const {
 	// TODO: make this work with the p_screen parameter
-	BScreen *screen = new BScreen(window);
+	BScreen* screen = new BScreen(window);
 	BRect frame = screen->Frame();
 	delete screen;
 	return Point2i(frame.left, frame.top);
@@ -259,13 +231,13 @@ Point2 OS_Haiku::get_screen_position(int p_screen) const {

 Size2 OS_Haiku::get_screen_size(int p_screen) const {
 	// TODO: make this work with the p_screen parameter
-	BScreen *screen = new BScreen(window);
+	BScreen* screen = new BScreen(window);
 	BRect frame = screen->Frame();
 	delete screen;
 	return Size2i(frame.IntegerWidth() + 1, frame.IntegerHeight() + 1);
 }

-void OS_Haiku::set_window_title(const String &p_title) {
+void OS_Haiku::set_window_title(const String& p_title) {
 	window->SetTitle(p_title.utf8().get_data());
 }

@@ -285,7 +257,7 @@ Point2 OS_Haiku::get_window_position() const {
 	return Point2i(point.x, point.y);
 }

-void OS_Haiku::set_window_position(const Point2 &p_position) {
+void OS_Haiku::set_window_position(const Point2& p_position) {
 	window->MoveTo(p_position.x, p_position.y);
 }

@@ -332,7 +304,7 @@ bool OS_Haiku::is_window_maximized() const {
 	return !window->IsMinimized();
 }

-void OS_Haiku::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
+void OS_Haiku::set_video_mode(const VideoMode& p_video_mode, int p_screen) {
 	ERR_PRINT("set_video_mode() NOT IMPLEMENTED");
 }

--- a/os_haiku.h
+++ b/os_haiku.h
@@ -1,86 +1,58 @@
-/*************************************************************************/
-/*  os_haiku.h                                                           */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #ifndef OS_HAIKU_H
 #define OS_HAIKU_H

 #include "drivers/unix/os_unix.h"
-#include "main/input_default.h"
+#include "servers/visual_server.h"
+#include "servers/visual/rasterizer.h"
+#include "servers/physics_server.h"
+#include "servers/physics_2d/physics_2d_server_sw.h"
 #include "servers/audio/audio_server_sw.h"
 #include "servers/audio/sample_manager_sw.h"
-#include "servers/physics_2d/physics_2d_server_sw.h"
-#include "servers/physics_server.h"
 #include "servers/spatial_sound/spatial_sound_server_sw.h"
 #include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h"
-#include "servers/visual/rasterizer.h"
-#include "servers/visual_server.h"
+#include "main/input_default.h"

 #include "audio_driver_media_kit.h"
 #include "context_gl_haiku.h"
 #include "haiku_application.h"
 #include "haiku_direct_window.h"

+
 class OS_Haiku : public OS_Unix {
 private:
-	HaikuApplication *app;
-	HaikuDirectWindow *window;
-	MainLoop *main_loop;
-	InputDefault *input;
-	Rasterizer *rasterizer;
-	VisualServer *visual_server;
+	HaikuApplication* app;
+	HaikuDirectWindow* window;
+	MainLoop* main_loop;
+	InputDefault* input;
+	Rasterizer* rasterizer;
+	VisualServer* visual_server;
 	VideoMode current_video_mode;
-	PhysicsServer *physics_server;
-	Physics2DServer *physics_2d_server;
-	AudioServerSW *audio_server;
-	SampleManagerMallocSW *sample_manager;
-	SpatialSoundServerSW *spatial_sound_server;
-	SpatialSound2DServerSW *spatial_sound_2d_server;
+	PhysicsServer* physics_server;
+	Physics2DServer* physics_2d_server;
+	AudioServerSW* audio_server;
+	SampleManagerMallocSW* sample_manager;
+	SpatialSoundServerSW* spatial_sound_server;
+	SpatialSound2DServerSW* spatial_sound_2d_server;

 #ifdef MEDIA_KIT_ENABLED
 	AudioDriverMediaKit driver_media_kit;
 #endif

 #if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
-	ContextGL_Haiku *context_gl;
+	ContextGL_Haiku* context_gl;
 #endif

 	virtual void delete_main_loop();

 protected:
 	virtual int get_video_driver_count() const;
-	virtual const char *get_video_driver_name(int p_driver) const;
+	virtual const char* get_video_driver_name(int p_driver) const;
 	virtual VideoMode get_default_video_mode() const;

-	virtual void initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver);
+	virtual void initialize(const VideoMode& p_desired, int p_video_driver, int p_audio_driver);
 	virtual void finalize();

-	virtual void set_main_loop(MainLoop *p_main_loop);
+	virtual void set_main_loop(MainLoop* p_main_loop);

 public:
 	OS_Haiku();
@@ -88,7 +60,7 @@ public:

 	virtual String get_name();

-	virtual MainLoop *get_main_loop() const;
+	virtual MainLoop* get_main_loop() const;

 	virtual bool can_draw() const;
 	virtual void release_rendering_thread();
@@ -102,13 +74,13 @@ public:
 	virtual int get_screen_count() const;
 	virtual int get_current_screen() const;
 	virtual void set_current_screen(int p_screen);
-	virtual Point2 get_screen_position(int p_screen = 0) const;
-	virtual Size2 get_screen_size(int p_screen = 0) const;
-	virtual void set_window_title(const String &p_title);
+	virtual Point2 get_screen_position(int p_screen=0) const;
+	virtual Size2 get_screen_size(int p_screen=0) const;
+	virtual void set_window_title(const String& p_title);
 	virtual Size2 get_window_size() const;
 	virtual void set_window_size(const Size2 p_size);
 	virtual Point2 get_window_position() const;
-	virtual void set_window_position(const Point2 &p_position);
+	virtual void set_window_position(const Point2& p_position);
 	virtual void set_window_fullscreen(bool p_enabled);
 	virtual bool is_window_fullscreen() const;
 	virtual void set_window_resizable(bool p_enabled);
@@ -118,9 +90,9 @@ public:
 	virtual void set_window_maximized(bool p_enabled);
 	virtual bool is_window_maximized() const;

-	virtual void set_video_mode(const VideoMode &p_video_mode, int p_screen = 0);
-	virtual VideoMode get_video_mode(int p_screen = 0) const;
-	virtual void get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen = 0) const;
+	virtual void set_video_mode(const VideoMode& p_video_mode, int p_screen=0);
+	virtual VideoMode get_video_mode(int p_screen=0) const;
+	virtual void get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen=0) const;
 	virtual String get_executable_path() const;
 };

--- a/platform_config.h
+++ b/platform_config.h
@@ -1,32 +1,3 @@
-/*************************************************************************/
-/*  platform_config.h                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
 #include <alloca.h>

 // for ifaddrs.h needed in drivers/unix/ip_unix.cpp