add initial examples, replacing the 'Demos/Demos3'. Will make it work cross-platform, OpenGL3/OpenGL2 and add more examples to it.

examples/ExampleBrowser/GwenGUISupport/GraphingTexture.cpp

@@ -0,0 +1,189 @@
+#include "GraphingTexture.h"
+#include "../OpenGLWindow/OpenGLInclude.h"
+#include <assert.h>
+
+GraphingTexture::GraphingTexture()
+:m_textureId(0),
+m_width(0),
+m_height(0)
+{
+}
+
+GraphingTexture::~GraphingTexture()
+{
+	destroy();
+}
+
+void GraphingTexture::destroy()
+{
+	//TODO(erwincoumans) release memory etc...
+	m_width = 0;
+	m_height=0;
+	glDeleteTextures(1,(GLuint*)&m_textureId);
+	m_textureId=0;
+}
+
+bool GraphingTexture::create(int texWidth, int texHeight)
+{
+	m_width = texWidth;
+	m_height = texHeight;
+	glActiveTexture(GL_TEXTURE0);
+	
+	m_imageData.resize(texWidth*texHeight*4);
+	for(int y=0;y<texHeight;++y)
+	{
+		//					const int	t=y>>5;
+		GLubyte*	pi=&m_imageData[y*texWidth*4];
+		for(int x=0;x<texWidth;++x)
+		{
+			if (x>=y)//x<2||y<2||x>253||y>253)
+			{
+				pi[0]=0;
+				pi[1]=0;
+				pi[2]=255;
+				pi[3]=255;
+			} else
+			{
+				pi[0]=255;
+				pi[1]=0;
+				pi[2]=0;
+				pi[3]=255;
+			}
+			
+			pi+=4;
+		}
+	}
+	
+	
+	glGenTextures(1,(GLuint*)&m_textureId);
+	
+	uploadImageData();
+	return true;
+}
+
+void GraphingTexture::uploadImageData()
+{
+	glBindTexture(GL_TEXTURE_2D,m_textureId);
+	assert(glGetError()==GL_NO_ERROR);
+	
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width,m_height,0,GL_RGBA,GL_UNSIGNED_BYTE,&m_imageData[0]);
+	glGenerateMipmap(GL_TEXTURE_2D);
+	
+	assert(glGetError()==GL_NO_ERROR);
+	
+	
+}
+
+#if 0
+//shift the image one pixel
+for(int y=0;y<texHeight;++y)
+{
+	//					const int	t=y>>5;
+	for(int x=1;x<texWidth;++x)
+	{
+		GLubyte*	org=image+(x+y*texWidth)*4;
+		
+		GLubyte*	dst=image+(x-1+y*texWidth)*4;
+		
+		dst[0] = org[0];
+		dst[1] = org[1];
+		dst[2] = org[2];
+		dst[3] = org[3];
+	}
+}
+//render a new row at the right
+for(int y=0;y<texHeight;++y)
+{
+	GLubyte*	pi=image+(texWidth-1+y*texWidth)*4;
+	pi[0]=255;
+	pi[1]=255;
+	pi[2]=255;
+	pi[3]=255;
+	if (y==texHeight*0.5)
+	{
+		pi[0]=200;
+		pi[1]=200;
+		pi[2]=200;
+		pi[3]=255;
+	}
+	
+}
+
+{
+	static float timer = 0.f;
+	static int prevValue=0;
+	timer+= 0.01;
+	float value = 128+100*sinf(timer);
+	MyClamp(value,0.f,float(texHeight-1));
+	GLubyte*	org=image+(texWidth-1+(int)value*texWidth)*4;
+	org[0] = 0;
+	org[1] = 0;
+	org[2] = 0;
+	org[3] = 255;
+	
+	if (prevValue<value)
+	{
+		
+	} else
+	{
+		
+	}
+	
+}
+
+{
+	static float timer = 1.4f;
+	timer+= 0.04;
+	float value = 128+150*sinf(timer);
+	MyClamp(value,0.f,float(texHeight-1));
+	
+	GLubyte*	org=image+(texWidth-1+(int)value*texWidth)*4;
+	org[0] = 0;
+	org[1] = 255;
+	org[2] = 0;
+	org[3] = 255;
+}
+
+{
+	static float timer = 1.4f;
+	timer+= 0.02;
+	float value =256+400*sinf(timer);
+	MyClamp(value,0.f,float(texHeight-1));
+	static int prevValue = 0;
+	
+	GLubyte*	org=image+(texWidth-1+(int)value*texWidth)*4;
+	org[0] = 0;
+	org[1] = 0;
+	org[2] = 255;
+	org[3] = 255;
+	
+	if (prevValue<value)
+	{
+		for (int i=prevValue;i<value;i++)
+		{
+			GLubyte*	org=image+(texHeight-1+(int)i*texWidth)*4;
+			org[0] = 0;
+			org[1] = 0;
+			org[2] = 255;
+			org[3] = 255;
+		}
+	} else
+	{
+		for (int i=value;i<prevValue;i++)
+		{
+			GLubyte*	org=image+(texHeight-1+(int)i*texWidth)*4;
+			org[0] = 0;
+			org[1] = 0;
+			org[2] = 255;
+			org[3] = 255;
+		}
+	}
+	prevValue = value;
+}
+
+
+glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texWidth,texHeight,0,GL_RGBA,GL_UNSIGNED_BYTE,image);
+glGenerateMipmap(GL_TEXTURE_2D);
+
+#endif
+

examples/ExampleBrowser/GwenGUISupport/GraphingTexture.h

@@ -0,0 +1,36 @@
+#ifndef GRAPHING_TEXTURE_H
+#define GRAPHING_TEXTURE_H
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct GraphingTexture
+{
+	int m_textureId;
+	//assume rgba (8 bit per component, total of 32bit per pixel, for m_width*m_height pixels)
+	btAlignedObjectArray<unsigned char> m_imageData;
+	int m_width;
+	int m_height;
+	
+	GraphingTexture();
+	virtual ~GraphingTexture();
+	
+	bool create(int texWidth, int texHeight);
+	void  destroy();
+	
+	void setPixel(int x, int y, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha)
+	{
+		m_imageData[x*4+y*4*m_width+0] = red;
+		m_imageData[x*4+y*4*m_width+1] = green;
+		m_imageData[x*4+y*4*m_width+2] = blue;
+		m_imageData[x*4+y*4*m_width+3] = alpha;
+	}
+	
+	void uploadImageData();
+	
+	int getTextureId()
+	{
+		return m_textureId;
+	}
+};
+
+#endif //GRAPHING_TEXTURE_H
+

examples/ExampleBrowser/GwenGUISupport/GwenParameterInterface.cpp

@@ -0,0 +1,167 @@
+#include "GwenParameterInterface.h"
+#include "gwenInternalData.h"
+
+
+
+template<typename T>
+struct MySliderEventHandler : public Gwen::Event::Handler
+{
+	Gwen::Controls::TextBox* m_label;
+	Gwen::Controls::Slider* m_pSlider;
+	char m_variableName[1024];
+	T* m_targetValue;
+    bool m_showValue;
+
+	MySliderEventHandler(const char* varName, Gwen::Controls::TextBox* label, Gwen::Controls::Slider* pSlider,T* target)
+		:m_label(label),
+		m_pSlider(pSlider),
+		m_targetValue(target),
+        m_showValue(true)
+	{
+		memcpy(m_variableName,varName,strlen(varName)+1);
+	}
+
+
+	void SliderMoved( Gwen::Controls::Base* pControl )
+	{
+		Gwen::Controls::Slider* pSlider = (Gwen::Controls::Slider*)pControl;
+		//printf("value = %f\n", pSlider->GetValue());//UnitPrint( Utility::Format( L"Slider Value: %.2f", pSlider->GetValue() ) );
+		float bla = pSlider->GetValue();
+		T v = T(bla);
+		SetValue(v);
+
+	}
+
+	void	SetValue(T v)
+	{
+		if (v < m_pSlider->GetRangeMin())
+		{
+			printf("?\n");
+		}
+
+		if (v > m_pSlider->GetRangeMax())
+		{
+						printf("?\n");
+
+		}
+		m_pSlider->SetValue(v,true);
+		(*m_targetValue) = v;
+		float val = float(v);//todo: specialize on template type
+        if (m_showValue)
+        {
+            char txt[1024];
+            sprintf(txt,"%s : %.3f", m_variableName,val);
+            m_label->SetText(txt);
+        }
+
+	}
+};
+
+
+struct  GwenParameters
+{
+	b3AlignedObjectArray<MySliderEventHandler<btScalar>*> m_sliderEventHandlers;
+	b3AlignedObjectArray<Gwen::Controls::HorizontalSlider*> m_sliders;
+	b3AlignedObjectArray<Gwen::Controls::TextBox*> m_textLabels;
+	int m_savedYposition;
+};
+
+GwenParameterInterface::GwenParameterInterface(GwenInternalData* gwenInternalData)
+:m_gwenInternalData(gwenInternalData)
+{
+	m_paramInternalData = new GwenParameters;
+	m_paramInternalData->m_savedYposition = m_gwenInternalData->m_curYposition;
+
+}
+
+GwenParameterInterface::~GwenParameterInterface()
+{
+
+	removeAllParameters();
+	delete m_paramInternalData;
+}
+
+
+void GwenParameterInterface::setSliderValue(int sliderIndex, double sliderValue)
+{
+    int sliderCapped = sliderValue+4;
+    sliderCapped /= 8;
+    sliderCapped *= 8;
+    
+    if (sliderIndex>=0 && sliderIndex<m_paramInternalData->m_sliders.size())
+    {
+        m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin();
+        
+        m_paramInternalData->m_sliders[sliderIndex]->GetRangeMax();
+        float mappedValue =m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin()+
+        (m_paramInternalData->m_sliders[sliderIndex]->GetRangeMax()-
+         m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin())*sliderCapped/128.f;
+        printf("mappedValue = %f\n",mappedValue);
+        m_paramInternalData->m_sliders[sliderIndex]->SetValue(mappedValue);
+    }
+}
+
+#include <stdio.h>
+void GwenParameterInterface::registerSliderFloatParameter(SliderParams& params)
+{
+	Gwen::Controls::TextBox* label = new Gwen::Controls::TextBox(m_gwenInternalData->m_demoPage->GetPage());
+	m_paramInternalData->m_textLabels.push_back(label);
+	//m_data->m_myControls.push_back(label);
+	label->SetText( params.m_name);
+	label->SetPos( 10, 10 + 25 );
+	label->SetWidth(110);
+	label->SetPos(10,m_gwenInternalData->m_curYposition);
+	m_gwenInternalData->m_curYposition+=22;
+
+	Gwen::Controls::HorizontalSlider* pSlider = new Gwen::Controls::HorizontalSlider( m_gwenInternalData->m_demoPage->GetPage());
+	m_paramInternalData->m_sliders.push_back(pSlider);
+	//m_data->m_myControls.push_back(pSlider);
+	pSlider->SetPos( 10, m_gwenInternalData->m_curYposition );
+	pSlider->SetSize( 100, 20 );
+	pSlider->SetRange( params.m_minVal, params.m_maxVal);
+	pSlider->SetNotchCount(128);//float(params.m_maxVal-params.m_minVal)/100.f);
+	pSlider->SetClampToNotches( params.m_clampToNotches );
+	pSlider->SetValue( *params.m_paramValuePointer);//dimensions[i] );
+	char labelName[1024];
+	sprintf(labelName,"%s",params.m_name);//axisNames[0]);
+	MySliderEventHandler<btScalar>* handler = new MySliderEventHandler<btScalar>(labelName,label,pSlider,params.m_paramValuePointer);
+    handler->m_showValue = params.m_showValues;
+	m_paramInternalData->m_sliderEventHandlers.push_back(handler);
+
+	pSlider->onValueChanged.Add( handler, &MySliderEventHandler<btScalar>::SliderMoved );
+	handler->SliderMoved(pSlider);
+//	float v = pSlider->GetValue();
+	m_gwenInternalData->m_curYposition+=22;
+}
+
+void GwenParameterInterface::syncParameters()
+{
+	for (int i=0;i<m_paramInternalData->m_sliderEventHandlers.size();i++)
+	{
+		MySliderEventHandler<btScalar>* handler = m_paramInternalData->m_sliderEventHandlers[i];
+		handler->m_pSlider->SetValue(*handler->m_targetValue,true);
+	}
+}
+
+void GwenParameterInterface::removeAllParameters()
+{
+	for (int i=0;i<m_paramInternalData->m_sliders.size();i++)
+	{
+		delete m_paramInternalData->m_sliders[i];
+	}
+	m_paramInternalData->m_sliders.clear();
+
+	for (int i=0;i<m_paramInternalData->m_sliderEventHandlers.size();i++)
+	{
+		delete m_paramInternalData->m_sliderEventHandlers[i];
+	}
+	m_paramInternalData->m_sliderEventHandlers.clear();
+	
+	for (int i=0;i<m_paramInternalData->m_textLabels.size();i++)
+	{
+		delete m_paramInternalData->m_textLabels[i];
+	}
+	m_paramInternalData->m_textLabels.clear();
+	
+	m_gwenInternalData->m_curYposition = this->m_paramInternalData->m_savedYposition;
+}

examples/ExampleBrowser/GwenGUISupport/GwenParameterInterface.h

@@ -0,0 +1,21 @@
+#ifndef GWEN_PARAMETER_INTERFACE_H
+#define GWEN_PARAMETER_INTERFACE_H
+
+#include "../CommonInterfaces/CommonParameterInterface.h"
+
+struct GwenParameterInterface : public CommonParameterInterface
+{
+	struct GwenInternalData* m_gwenInternalData;
+
+	struct GwenParameters*	m_paramInternalData;
+
+	GwenParameterInterface(struct GwenInternalData* gwenInternalData);
+	virtual ~GwenParameterInterface();
+	virtual void registerSliderFloatParameter(SliderParams& params);
+    virtual void setSliderValue(int sliderIndex, double sliderValue);
+	virtual void syncParameters();
+	virtual void removeAllParameters();
+
+};
+
+#endif//GWEN_PARAMETER_INTERFACE_H

examples/ExampleBrowser/GwenGUISupport/GwenProfileWindow.cpp

@@ -0,0 +1,292 @@
+#include "GwenProfileWindow.h"
+#include "gwenUserInterface.h"
+#include "gwenInternalData.h"
+#include "LinearMath/btQuickprof.h"
+
+
+
+
+
+class MyProfileWindow : public Gwen::Controls::WindowControl
+{
+	
+	//		Gwen::Controls::TabControl*	m_TabControl;
+	//Gwen::Controls::ListBox*	m_TextOutput;
+	unsigned int				m_iFrames;
+	float						m_fLastSecond;
+	
+	Gwen::Controls::TreeNode* m_node;
+	Gwen::Controls::TreeControl* m_ctrl;
+	
+	
+protected:
+	
+	void onButtonA( Gwen::Controls::Base* pControl )
+	{
+        //		OpenTissue::glut::toggleIdle();
+	}
+	
+	void SliderMoved(Gwen::Controls::Base* pControl )
+	{
+	//	Gwen::Controls::Slider* pSlider = (Gwen::Controls::Slider*)pControl;
+		//this->m_app->scaleYoungModulus(pSlider->GetValue());
+		//	printf("Slider Value: %.2f", pSlider->GetValue() );
+	}
+	
+	
+	void	OnCheckChangedStiffnessWarping (Gwen::Controls::Base* pControl)
+	{
+	//	Gwen::Controls::CheckBox* labeled = (Gwen::Controls::CheckBox* )pControl;
+//		bool checked = labeled->IsChecked();
+		//m_app->m_stiffness_warp_on  = checked;
+	}
+public:
+	
+  
+	CProfileIterator* profIter;
+	
+	MyProfileWindow (	Gwen::Controls::Base* pParent)
+    : Gwen::Controls::WindowControl( pParent ),
+	profIter(0)
+	{
+		SetTitle( L"Time Profiler" );
+		
+		SetSize( 450, 450 );
+		this->SetPos(10,400);
+		
+        //		this->Dock( Gwen::Pos::Bottom);
+		
+		
+		
+		{
+			m_ctrl = new Gwen::Controls::TreeControl( this );
+			m_node = m_ctrl->AddNode( L"Total Parent Time" );
+			
+			
+			//Gwen::Controls::TreeNode* pNode = ctrl->AddNode( L"Node Two" );
+			//pNode->AddNode( L"Node Two Inside" );
+			//pNode->AddNode( L"Eyes" );
+			//pNode->AddNode( L"Brown" )->AddNode( L"Node Two Inside" )->AddNode( L"Eyes" )->AddNode( L"Brown" );
+			//Gwen::Controls::TreeNode* node = ctrl->AddNode( L"Node Three" );
+			
+			
+			
+			//m_ctrl->Dock(Gwen::Pos::Bottom);
+			
+			m_ctrl->ExpandAll();
+            m_ctrl->SetKeyboardInputEnabled(true);
+			m_ctrl->SetBounds( this->GetInnerBounds().x,this->GetInnerBounds().y,this->GetInnerBounds().w,this->GetInnerBounds().h);
+			
+		}
+		
+		
+		
+	}
+	
+	
+	float	dumpRecursive(CProfileIterator* profileIterator, Gwen::Controls::TreeNode* parentNode)
+	{
+		profileIterator->First();
+		if (profileIterator->Is_Done())
+			return 0.f;
+		
+		float accumulated_time=0,parent_time = profileIterator->Is_Root() ? CProfileManager::Get_Time_Since_Reset() : profileIterator->Get_Current_Parent_Total_Time();
+		int i;
+		int frames_since_reset = CProfileManager::Get_Frame_Count_Since_Reset();
+		
+		//printf("Profiling: %s (total running time: %.3f ms) ---\n",	profileIterator->Get_Current_Parent_Name(), parent_time );
+		float totalTime = 0.f;
+		
+		
+		int numChildren = 0;
+		Gwen::UnicodeString txt;
+		std::vector<Gwen::Controls::TreeNode*> nodes;
+		
+		for (i = 0; !profileIterator->Is_Done(); i++,profileIterator->Next())
+		{
+			numChildren++;
+			float current_total_time = profileIterator->Get_Current_Total_Time();
+			accumulated_time += current_total_time;
+			double fraction = parent_time > SIMD_EPSILON ? (current_total_time / parent_time) * 100 : 0.f;
+			
+			Gwen::String name(profileIterator->Get_Current_Name());
+#ifdef _WIN32
+			Gwen::UnicodeString uname = Gwen::Utility::StringToUnicode(name);
+			
+			txt = Gwen::Utility::Format(L"%s (%.2f %%) :: %.3f ms / frame (%d calls)",uname.c_str(), fraction,(current_total_time / (double)frames_since_reset),profileIterator->Get_Current_Total_Calls());
+			
+#else
+			txt = Gwen::Utility::Format(L"%s (%.2f %%) :: %.3f ms / frame (%d calls)",name.c_str(), fraction,(current_total_time / (double)frames_since_reset),profileIterator->Get_Current_Total_Calls());
+			
+#endif
+			
+			Gwen::Controls::TreeNode* childNode = (Gwen::Controls::TreeNode*)profileIterator->Get_Current_UserPointer();
+			if (!childNode)
+			{
+                childNode = parentNode->AddNode(L"");
+                profileIterator->Set_Current_UserPointer(childNode);
+			}
+			childNode->SetText(txt);
+			nodes.push_back(childNode);
+			
+			totalTime += current_total_time;
+			//recurse into children
+		}
+		
+		for (i=0;i<numChildren;i++)
+		{
+			profileIterator->Enter_Child(i);
+			Gwen::Controls::TreeNode* curNode = nodes[i];
+			
+			dumpRecursive(profileIterator, curNode);
+			
+			profileIterator->Enter_Parent();
+		}
+		return accumulated_time;
+		
+	}
+	
+	void	UpdateText(CProfileIterator*  profileIterator, bool idle)
+	{
+		
+	//	static bool update=true;
+		
+        m_ctrl->SetBounds(0,0,this->GetInnerBounds().w,this->GetInnerBounds().h);
+		
+        //		if (!update)
+        //			return;
+	//	update=false;
+		
+		
+		static int test = 1;
+		test++;
+		
+		static double time_since_reset = 0.f;
+		if (!idle)
+		{
+			time_since_reset = CProfileManager::Get_Time_Since_Reset();
+		}
+		
+		//Gwen::UnicodeString txt = Gwen::Utility::Format( L"FEM Settings  %i fps", test );
+		{
+            //recompute profiling data, and store profile strings
+			
+         //   char blockTime[128];
+			
+           // double totalTime = 0;
+			
+          //  int frames_since_reset = CProfileManager::Get_Frame_Count_Since_Reset();
+			
+            profileIterator->First();
+			
+            double parent_time = profileIterator->Is_Root() ? time_since_reset : profileIterator->Get_Current_Parent_Total_Time();
+			
+			
+         //   Gwen::Controls::TreeNode* curParent = m_node;
+			
+            double accumulated_time = dumpRecursive(profileIterator,m_node);
+			
+            const char* name = profileIterator->Get_Current_Parent_Name();
+#ifdef _WIN32
+            Gwen::UnicodeString uname = Gwen::Utility::StringToUnicode(name);
+            Gwen::UnicodeString txt = Gwen::Utility::Format( L"Profiling: %s total time: %.3f ms, unaccounted %.3f %% :: %.3f ms", uname.c_str(), parent_time ,
+                                                            parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time);
+#else
+            Gwen::UnicodeString txt = Gwen::Utility::Format( L"Profiling: %s total time: %.3f ms, unaccounted %.3f %% :: %.3f ms", name, parent_time ,
+                                                            parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time);
+#endif
+            //sprintf(blockTime,"--- Profiling: %s (total running time: %.3f ms) ---",	profileIterator->Get_Current_Parent_Name(), parent_time );
+            //displayProfileString(xOffset,yStart,blockTime);
+            m_node->SetText(txt);
+			
+			
+			//printf("%s (%.3f %%) :: %.3f ms\n", "Unaccounted:",);
+			
+			
+		}
+		
+		static int counter=10;
+		if (counter)
+		{
+            counter--;
+			m_ctrl->ExpandAll();
+		}
+		
+	}
+	void PrintText( const Gwen::UnicodeString& str )
+	{
+		
+	}
+	
+	void Render( Gwen::Skin::Base* skin )
+	{
+		m_iFrames++;
+		
+		if ( m_fLastSecond < Gwen::Platform::GetTimeInSeconds() )
+		{
+			SetTitle( Gwen::Utility::Format( L"Profiler  %i fps", m_iFrames ) );
+			
+			m_fLastSecond = Gwen::Platform::GetTimeInSeconds() + 1.0f;
+			m_iFrames = 0;
+		}
+		
+		Gwen::Controls::WindowControl::Render( skin );
+		
+	}
+	
+	
+};
+
+class MyMenuItems :  public Gwen::Controls::Base
+{
+	
+public:
+	
+	class MyProfileWindow* m_profWindow;
+    MyMenuItems() :Gwen::Controls::Base(0)
+    {
+    }
+   
+    void MenuItemSelect(Gwen::Controls::Base* pControl)
+    {
+		if (m_profWindow->Hidden())
+		{
+			m_profWindow->SetHidden(false);
+		} else
+		{
+			m_profWindow->SetHidden(true);
+		}
+		
+    }
+};
+
+
+MyProfileWindow* setupProfileWindow(GwenInternalData* data)
+{
+	MyMenuItems* menuItems = new MyMenuItems;
+	MyProfileWindow* profWindow = new MyProfileWindow(data->pCanvas);
+	//profWindow->SetHidden(true);	
+	profWindow->profIter = CProfileManager::Get_Iterator();
+	data->m_viewMenu->GetMenu()->AddItem( L"Profiler", menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::MenuItemSelect);
+	menuItems->m_profWindow = profWindow;
+	return profWindow;
+}
+
+
+void	processProfileData( MyProfileWindow* profWindow, bool idle)
+{
+	if (profWindow)
+	{
+		
+		profWindow->UpdateText(profWindow->profIter, idle);
+	}	
+}
+
+void profileWindowSetVisible(MyProfileWindow* window, bool visible)
+{
+	window->SetHidden(!visible);
+}
+void destroyProfileWindow(MyProfileWindow* window)
+{
+	delete window;
+}

examples/ExampleBrowser/GwenGUISupport/GwenProfileWindow.h

@@ -0,0 +1,11 @@
+#ifndef GWEN_PROFILE_WINDOW_H
+#define GWEN_PROFILE_WINDOW_H
+
+class MyProfileWindow* setupProfileWindow(struct GwenInternalData* data);
+void processProfileData(MyProfileWindow* window, bool idle);
+void profileWindowSetVisible(MyProfileWindow* window, bool visible);
+void destroyProfileWindow(MyProfileWindow* window);
+
+#endif//GWEN_PROFILE_WINDOW_H
+
+

examples/ExampleBrowser/GwenGUISupport/GwenTextureWindow.cpp

@@ -0,0 +1,100 @@
+#include "GwenTextureWindow.h"
+#include "gwenUserInterface.h"
+#include "gwenInternalData.h"
+#include "Gwen/Controls/ImagePanel.h"
+
+
+
+class MyGraphWindow : public Gwen::Controls::WindowControl
+{
+	Gwen::Controls::ImagePanel* m_imgPanel;
+
+public:
+	
+	class MyMenuItems2* m_menuItems;
+	
+	MyGraphWindow (	const MyGraphInput& input)
+    : Gwen::Controls::WindowControl( input.m_data->pCanvas ),
+	m_menuItems(0)
+	{
+		Gwen::UnicodeString str = Gwen::Utility::StringToUnicode(input.m_name);
+		SetTitle( str );
+
+
+		SetPos(input.m_xPos,input.m_yPos);
+		SetSize( 12+input.m_width+2*input.m_borderWidth, 30+input.m_height+2*input.m_borderWidth );
+		
+		m_imgPanel = new Gwen::Controls::ImagePanel( this );
+		if (input.m_texName)
+		{
+			Gwen::UnicodeString texName = Gwen::Utility::StringToUnicode(input.m_texName);
+			m_imgPanel->SetImage( texName );
+		}
+		m_imgPanel->SetBounds( input.m_borderWidth, input.m_borderWidth, 
+							  input.m_width, 
+							  input.m_height );
+        //		this->Dock( Gwen::Pos::Bottom);
+	}
+	virtual ~MyGraphWindow()
+	{
+		delete m_imgPanel;
+	}
+
+
+};
+
+class MyMenuItems2 :  public Gwen::Controls::Base
+{
+	MyGraphWindow* m_graphWindow;
+	
+public:
+	
+	Gwen::Controls::MenuItem* m_item;
+	
+    MyMenuItems2(MyGraphWindow* graphWindow) 
+	:Gwen::Controls::Base(0),
+	m_graphWindow(graphWindow),
+	m_item(0)
+    {
+    }
+	
+    void MenuItemSelect(Gwen::Controls::Base* pControl)
+    {
+		if (m_graphWindow->Hidden())
+		{
+			m_graphWindow->SetHidden(false);
+			//@TODO(erwincoumans) setCheck/SetCheckable drawing is broken, need to see what's wrong
+//			if (m_item)
+//				m_item->SetCheck(false);
+			
+		} else
+		{
+			m_graphWindow->SetHidden(true);
+//			if (m_item)
+//				m_item->SetCheck(true);
+			
+		}
+		
+    }
+};
+
+MyGraphWindow* setupTextureWindow(const MyGraphInput& input)
+{
+	MyGraphWindow* graphWindow = new MyGraphWindow(input);
+	MyMenuItems2* menuItems = new MyMenuItems2(graphWindow);
+	graphWindow->m_menuItems = menuItems;
+	
+	Gwen::UnicodeString str = Gwen::Utility::StringToUnicode(input.m_name);
+	menuItems->m_item = input.m_data->m_viewMenu->GetMenu()->AddItem( str, menuItems,(Gwen::Event::Handler::Function)&MyMenuItems2::MenuItemSelect);
+//	menuItems->m_item->SetCheckable(true);
+
+	return graphWindow;
+	
+}
+
+void destroyTextureWindow(MyGraphWindow* window)
+{
+	delete window->m_menuItems->m_item;
+	delete window->m_menuItems;
+	delete window;
+}

examples/ExampleBrowser/GwenGUISupport/GwenTextureWindow.h

@@ -0,0 +1,32 @@
+
+
+#ifndef GWEN_TEXTURE_WINDOW_H
+#define GWEN_TEXTURE_WINDOW_H
+
+struct MyGraphInput
+{
+	struct GwenInternalData* m_data;
+	int m_xPos;
+	int m_yPos;
+	int m_width;
+	int m_height;
+	int m_borderWidth;
+	const char* m_name;
+	const char* m_texName;
+	MyGraphInput(struct GwenInternalData* data)
+	:m_data(data),
+	m_xPos(0),
+	m_yPos(0),
+	m_width(400),
+	m_height(400),
+	m_borderWidth(0),
+	m_name("GraphWindow"),
+	m_texName(0)
+	{
+	}
+};
+class MyGraphWindow* setupTextureWindow(const MyGraphInput& input);
+void destroyTextureWindow(MyGraphWindow* window);
+
+
+#endif //GWEN_TEXTURE_WINDOW_H

examples/ExampleBrowser/GwenGUISupport/gwenInternalData.h

@@ -0,0 +1,57 @@
+#ifndef GWEN_INTERNAL_DATA_H
+#define GWEN_INTERNAL_DATA_H
+
+#include "../OpenGLWindow/GwenOpenGL3CoreRenderer.h"
+#include "../OpenGLWindow/GLPrimitiveRenderer.h"
+#include "Gwen/Platform.h"
+#include "Gwen/Controls/TreeControl.h"
+#include "Gwen/Controls/RadioButtonController.h"
+#include "Gwen/Controls/VerticalSlider.h"
+#include "Gwen/Controls/HorizontalSlider.h"
+#include "Gwen/Controls/GroupBox.h"
+#include "Gwen/Controls/CheckBox.h"
+#include "Gwen/Controls/StatusBar.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/ComboBox.h"
+#include "Gwen/Controls/MenuStrip.h"
+#include "Gwen/Controls/Slider.h"
+#include "Gwen/Controls/Property/Text.h"
+#include "Gwen/Controls/SplitterBar.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Align.h"
+#include "Gwen/Utility.h"
+#include "Gwen/Controls/WindowControl.h"
+#include "Gwen/Controls/TabControl.h"
+#include "Gwen/Controls/ListBox.h"
+#include "Gwen/Skins/Simple.h"
+//#include "Gwen/Skins/TexturedBase.h"
+#include "gwenUserInterface.h"
+
+
+struct GwenInternalData
+{
+	//struct sth_stash;
+	//class GwenOpenGL3CoreRenderer*	pRenderer;
+	Gwen::Renderer::Base*			pRenderer;
+	Gwen::Skin::Simple				skin;
+	Gwen::Controls::Canvas*			pCanvas;
+	//GLPrimitiveRenderer* m_primRenderer;
+	Gwen::Controls::TabButton*		m_demoPage;
+	Gwen::Controls::TabButton*		m_explorerPage;
+	Gwen::Controls::TreeControl*	m_explorerTreeCtrl;
+	Gwen::Controls::MenuItem*		m_viewMenu;
+    class MyMenuItems*                    m_menuItems;
+
+	int		m_curYposition;
+
+	Gwen::Controls::Label* m_rightStatusBar;
+	Gwen::Controls::Label* m_leftStatusBar;
+	b3AlignedObjectArray<class Gwen::Event::Handler*>	m_handlers;
+	b3ToggleButtonCallback			m_toggleButtonCallback;
+	b3ComboBoxCallback				m_comboBoxCallback;
+	
+
+};
+
+#endif//GWEN_INTERNAL_DATA_H

examples/ExampleBrowser/GwenGUISupport/gwenUserInterface.cpp

@@ -0,0 +1,463 @@
+
+#include "gwenUserInterface.h"
+#include "gwenInternalData.h"
+#include "Gwen/Controls/ImagePanel.h"
+
+class MyGraphWindow* graphWindow = 0;
+
+
+
+GwenUserInterface::GwenUserInterface()
+{
+	m_data = new GwenInternalData();
+	m_data->m_toggleButtonCallback = 0;
+	m_data->m_comboBoxCallback = 0;
+
+}
+
+GwenUserInterface::~GwenUserInterface()
+{
+	for (int i=0;i<m_data->m_handlers.size();i++)
+	{
+		delete m_data->m_handlers[i];
+	}
+
+	m_data->m_handlers.clear();
+
+
+	delete m_data->pCanvas;
+
+
+	delete m_data;
+
+
+
+}
+
+
+
+
+class MyMenuItems :  public Gwen::Controls::Base
+{
+public:
+
+    b3FileOpenCallback m_fileOpenCallback;
+    
+    MyMenuItems() :Gwen::Controls::Base(0),m_fileOpenCallback(0)
+    {
+    }
+    void myQuitApp( Gwen::Controls::Base* pControl )
+    {
+        exit(0);
+    }
+    void fileOpen( Gwen::Controls::Base* pControl )
+    {
+        if (m_fileOpenCallback)
+        {
+            (*m_fileOpenCallback)();
+        }
+    }
+    
+};
+
+struct MyTestMenuBar : public Gwen::Controls::MenuStrip
+{
+
+	Gwen::Controls::MenuItem* m_fileMenu;
+	Gwen::Controls::MenuItem* m_viewMenu;
+    MyMenuItems*                m_menuItems;
+
+	MyTestMenuBar(Gwen::Controls::Base* pParent)
+		:Gwen::Controls::MenuStrip(pParent)
+	{
+//		Gwen::Controls::MenuStrip* menu = new Gwen::Controls::MenuStrip( pParent );
+		{
+			m_menuItems = new MyMenuItems();
+            m_menuItems->m_fileOpenCallback = 0;
+
+			m_fileMenu = AddItem( L"File" );
+			
+            m_fileMenu->GetMenu()->AddItem(L"Open",m_menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::fileOpen);
+            m_fileMenu->GetMenu()->AddItem(L"Quit",m_menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::myQuitApp);
+            m_viewMenu = AddItem( L"View" );
+			
+		}
+	}
+
+};
+
+void	GwenUserInterface::resize(int width, int height)
+{
+	m_data->pCanvas->SetSize(width,height);
+}
+
+
+struct MyComboBoxHander   :public Gwen::Event::Handler
+{
+	GwenInternalData*	m_data;
+	int					m_buttonId;
+
+	MyComboBoxHander  (GwenInternalData* data, int buttonId)
+		:m_data(data),
+		m_buttonId(buttonId)
+	{
+	}
+
+	void onSelect( Gwen::Controls::Base* pControl )
+	{
+		Gwen::Controls::ComboBox* but = (Gwen::Controls::ComboBox*) pControl;
+
+
+
+		Gwen::String str = Gwen::Utility::UnicodeToString(	but->GetSelectedItem()->GetText());
+
+		if (m_data->m_comboBoxCallback)
+			(*m_data->m_comboBoxCallback)(m_buttonId,str.c_str());
+	}
+
+};
+
+struct MyButtonHander   :public Gwen::Event::Handler
+{
+	GwenInternalData*	m_data;
+	int					m_buttonId;
+
+	MyButtonHander  (GwenInternalData* data, int buttonId)
+		:m_data(data),
+		m_buttonId(buttonId)
+	{
+	}
+
+	void onButtonA( Gwen::Controls::Base* pControl )
+	{
+		Gwen::Controls::Button* but = (Gwen::Controls::Button*) pControl;
+//		int dep = but->IsDepressed();
+		int tog = but->GetToggleState();
+		if (m_data->m_toggleButtonCallback)
+			(*m_data->m_toggleButtonCallback)(m_buttonId,tog);
+	}
+
+};
+
+
+void	GwenUserInterface::setStatusBarMessage(const char* message, bool isLeft)
+{
+	Gwen::UnicodeString msg = Gwen::Utility::StringToUnicode(message);
+	if (isLeft)
+	{
+		m_data->m_leftStatusBar->SetText( msg);
+	} else
+	{
+		m_data->m_rightStatusBar->SetText( msg);
+
+	}
+}
+
+void GwenUserInterface::registerFileOpenCallback(b3FileOpenCallback callback)
+{
+    m_data->m_menuItems->m_fileOpenCallback = callback;
+}
+
+void	GwenUserInterface::init(int width, int height,Gwen::Renderer::Base* renderer,float retinaScale)
+{
+	m_data->m_curYposition = 20;
+	//m_data->m_primRenderer = new GLPrimitiveRenderer(width,height);
+	m_data->pRenderer = renderer;//new GwenOpenGL3CoreRenderer(m_data->m_primRenderer,stash,width,height,retinaScale);
+
+	m_data->skin.SetRender( m_data->pRenderer );
+
+	m_data->pCanvas= new Gwen::Controls::Canvas( &m_data->skin );
+	m_data->pCanvas->SetSize( width,height);
+	m_data->pCanvas->SetDrawBackground( false);
+	m_data->pCanvas->SetBackgroundColor( Gwen::Color( 150, 170, 170, 255 ) );
+
+	MyTestMenuBar* menubar = new MyTestMenuBar(m_data->pCanvas);
+	m_data->m_viewMenu = menubar->m_viewMenu;
+    m_data->m_menuItems = menubar->m_menuItems;
+    
+    
+    
+	Gwen::Controls::StatusBar* bar = new Gwen::Controls::StatusBar(m_data->pCanvas);
+	m_data->m_rightStatusBar = new Gwen::Controls::Label( bar );
+	m_data->m_rightStatusBar->SetWidth(width/2);
+	//m_data->m_rightStatusBar->SetText( L"Label Added to Right" );
+	bar->AddControl( m_data->m_rightStatusBar, true );
+
+	m_data->m_leftStatusBar = new Gwen::Controls::Label( bar );
+	//m_data->m_leftStatusBar->SetText( L"Label Added to Left" );
+	m_data->m_leftStatusBar->SetWidth(width/2);
+	bar->AddControl( m_data->m_leftStatusBar,false);
+	//Gwen::KeyboardFocus
+	/*Gwen::Controls::GroupBox* box = new Gwen::Controls::GroupBox(m_data->pCanvas);
+	box->SetText("text");
+	box->SetName("name");
+	box->SetHeight(500);
+	*/
+	Gwen::Controls::ScrollControl* windowRight= new Gwen::Controls::ScrollControl(m_data->pCanvas);
+	windowRight->Dock(Gwen::Pos::Right);
+	windowRight->SetWidth(150);
+	windowRight->SetHeight(250);
+	windowRight->SetScroll(false,true);
+
+
+
+	//windowLeft->SetSkin(
+	Gwen::Controls::TabControl* tab = new Gwen::Controls::TabControl(windowRight);
+
+	//tab->SetHeight(300);
+	tab->SetWidth(140);
+	tab->SetHeight(250);
+	//tab->Dock(Gwen::Pos::Left);
+	tab->Dock( Gwen::Pos::Fill );
+	//tab->SetMargin( Gwen::Margin( 2, 2, 2, 2 ) );
+
+	Gwen::UnicodeString str1(L"Params");
+	m_data->m_demoPage = tab->AddPage(str1);
+
+
+
+
+//	Gwen::UnicodeString str2(L"OpenCL");
+//	tab->AddPage(str2);
+	//Gwen::UnicodeString str3(L"page3");
+//	tab->AddPage(str3);
+
+
+
+	//but->onPress.Add(handler, &MyHander::onButtonA);
+
+
+
+	//box->Dock(Gwen::Pos::Left);
+
+	/*Gwen::Controls::WindowControl* windowBottom = new Gwen::Controls::WindowControl(m_data->pCanvas);
+	windowBottom->SetHeight(100);
+	windowBottom->Dock(Gwen::Pos::Bottom);
+	windowBottom->SetTitle("bottom");
+	*/
+//	Gwen::Controls::Property::Text* prop = new Gwen::Controls::Property::Text(m_data->pCanvas);
+	//prop->Dock(Gwen::Pos::Bottom);
+	/*Gwen::Controls::SplitterBar* split = new Gwen::Controls::SplitterBar(m_data->pCanvas);
+	split->Dock(Gwen::Pos::Center);
+	split->SetHeight(300);
+	split->SetWidth(300);
+	*/
+	/*
+
+
+	*/
+
+	Gwen::Controls::ScrollControl* windowLeft = new Gwen::Controls::ScrollControl(m_data->pCanvas);
+	windowLeft->Dock(Gwen::Pos::Left);
+	//	windowLeft->SetTitle("title");
+	windowLeft->SetScroll(false, false);
+	windowLeft->SetWidth(250);
+	windowLeft->SetPos(50, 50);
+	windowLeft->SetHeight(500);
+	//windowLeft->SetClosable(false);
+	//	windowLeft->SetShouldDrawBackground(true);
+	windowLeft->SetTabable(true);
+
+	Gwen::Controls::TabControl* explorerTab = new Gwen::Controls::TabControl(windowLeft);
+
+	//tab->SetHeight(300);
+//	explorerTab->SetWidth(230);
+	explorerTab->SetHeight(250);
+	//tab->Dock(Gwen::Pos::Left);
+	explorerTab->Dock(Gwen::Pos::Fill);
+
+	Gwen::UnicodeString explorerStr1(L"Explorer");
+	m_data->m_explorerPage = explorerTab->AddPage(explorerStr1);
+	Gwen::UnicodeString shapesStr1(L"Shapes");
+	explorerTab->AddPage(shapesStr1);
+	Gwen::UnicodeString testStr1(L"Test");
+	explorerTab->AddPage(testStr1);
+
+	Gwen::Controls::TreeControl* ctrl = new Gwen::Controls::TreeControl(m_data->m_explorerPage->GetPage());
+	m_data->m_explorerTreeCtrl = ctrl;
+	ctrl->SetKeyboardInputEnabled(true);
+	ctrl->Focus();
+	ctrl->SetBounds(2, 10, 236, 400);
+
+   
+}
+
+void	GwenUserInterface::forceUpdateScrollBars()
+{
+	b3Assert(m_data);
+	b3Assert(m_data->m_explorerTreeCtrl);
+	if (m_data && m_data->m_explorerTreeCtrl)
+	{
+		m_data->m_explorerTreeCtrl->ForceUpdateScrollBars();
+	}
+}
+
+void	GwenUserInterface::setFocus()
+{
+	b3Assert(m_data);
+	b3Assert(m_data->m_explorerTreeCtrl);
+	if (m_data && m_data->m_explorerTreeCtrl)
+	{
+		m_data->m_explorerTreeCtrl->Focus();
+	}
+}
+
+b3ToggleButtonCallback	GwenUserInterface::getToggleButtonCallback()
+{
+	return m_data->m_toggleButtonCallback;
+}
+
+void	GwenUserInterface::setToggleButtonCallback(b3ToggleButtonCallback callback)
+{
+	m_data->m_toggleButtonCallback = callback;
+}
+void	GwenUserInterface::registerToggleButton(int buttonId, const char* name)
+{
+	assert(m_data);
+	assert(m_data->m_demoPage);
+
+	Gwen::Controls::Button* but = new Gwen::Controls::Button(m_data->m_demoPage->GetPage());
+
+	///some heuristic to find the button location
+	int ypos = m_data->m_curYposition;
+	but->SetPos(10, ypos );
+	but->SetWidth( 100 );
+	//but->SetBounds( 200, 30, 300, 200 );
+
+	MyButtonHander* handler = new MyButtonHander(m_data, buttonId);
+	m_data->m_handlers.push_back(handler);
+	m_data->m_curYposition+=22;
+	but->onToggle.Add(handler, &MyButtonHander::onButtonA);
+	but->SetIsToggle(true);
+	but->SetToggleState(false);
+	but->SetText(name);
+
+}
+
+void	GwenUserInterface::setComboBoxCallback(b3ComboBoxCallback callback)
+{
+	m_data->m_comboBoxCallback = callback;
+}
+
+b3ComboBoxCallback GwenUserInterface::getComboBoxCallback()
+{
+	return m_data->m_comboBoxCallback;
+}
+void	GwenUserInterface::registerComboBox(int comboboxId, int numItems, const char** items, int startItem)
+{
+	Gwen::Controls::ComboBox* combobox = new Gwen::Controls::ComboBox(m_data->m_demoPage->GetPage());
+	MyComboBoxHander* handler = new MyComboBoxHander(m_data, comboboxId);
+	m_data->m_handlers.push_back(handler);
+
+	combobox->onSelection.Add(handler,&MyComboBoxHander::onSelect);
+	int ypos = m_data->m_curYposition;
+	combobox->SetPos(10, ypos );
+	combobox->SetWidth( 100 );
+	//box->SetPos(120,130);
+	for (int i=0;i<numItems;i++)
+	{
+		Gwen::Controls::MenuItem* item = combobox->AddItem(Gwen::Utility::StringToUnicode(items[i]));
+		if (i==startItem)
+			combobox->OnItemSelected(item);
+	}
+
+	m_data->m_curYposition+=22;
+
+
+
+}
+
+void	GwenUserInterface::draw(int width, int height)
+{
+
+//	printf("width = %d, height=%d\n", width,height);
+	if (m_data->pCanvas)
+	{
+		m_data->pCanvas->SetSize(width,height);
+		//m_data->m_primRenderer->setScreenSize(width,height);
+		m_data->pRenderer->Resize(width,height);
+		m_data->pCanvas->RenderCanvas();
+		//restoreOpenGLState();
+	}
+
+}
+
+bool	GwenUserInterface::mouseMoveCallback( float x, float y)
+{
+	bool handled  = false;
+
+	static int m_lastmousepos[2] = {0,0};
+	static bool isInitialized = false;
+	if (m_data->pCanvas)
+	{
+		if (!isInitialized)
+		{
+			isInitialized = true;
+			m_lastmousepos[0] = x+1;
+			m_lastmousepos[1] = y+1;
+		}
+		handled = m_data->pCanvas->InputMouseMoved(x,y,m_lastmousepos[0],m_lastmousepos[1]);
+	}
+	return handled;
+
+}
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+bool	GwenUserInterface::keyboardCallback(int bulletKey, int state)
+{
+	int key = -1;
+	if (m_data->pCanvas)
+	{
+		//convert 'Bullet' keys into 'Gwen' keys
+		switch (bulletKey)
+		{
+		case B3G_RETURN:
+		{
+				   key = Gwen::Key::Return;
+				   break;
+		}
+		case 	B3G_LEFT_ARROW:
+			key = Gwen::Key::Left;
+			break;
+		case B3G_RIGHT_ARROW:
+			key = Gwen::Key::Right;
+			break;
+
+		case	B3G_UP_ARROW:
+			key = Gwen::Key::Up;
+			break;
+		case B3G_DOWN_ARROW:
+			key = Gwen::Key::Down;
+			break;
+		default:
+		{
+
+		}
+		};
+		bool bDown = (state == 1);
+
+		return m_data->pCanvas->InputKey(key, bDown);
+	}
+	return false;
+}
+
+
+bool	GwenUserInterface::mouseButtonCallback(int button, int state, float x, float y)
+{
+	bool handled = false;
+	if (m_data->pCanvas)
+	{
+		handled = m_data->pCanvas->InputMouseMoved(x,y,x, y);
+
+		if (button>=0)
+		{
+			handled = m_data->pCanvas->InputMouseButton(button,(bool)state);
+			if (handled)
+			{
+				//if (!state)
+				//	return false;
+			}
+		}
+	}
+	return handled;
+}

examples/ExampleBrowser/GwenGUISupport/gwenUserInterface.h

@@ -0,0 +1,63 @@
+#ifndef _GWEN_USER_INTERFACE_H
+#define _GWEN_USER_INTERFACE_H
+
+struct GwenInternalData;
+
+typedef void (*b3ComboBoxCallback) (int combobox, const char* item);
+typedef void (*b3ToggleButtonCallback)(int button, int state);
+typedef void (*b3FileOpenCallback)();
+
+namespace Gwen
+{
+	namespace Renderer
+	{
+		class Base;
+	};
+};
+class GwenUserInterface
+{
+	GwenInternalData*	m_data;
+
+	public:
+		
+		GwenUserInterface();
+		
+		virtual ~GwenUserInterface();
+		
+		void	init(int width, int height,Gwen::Renderer::Base* gwenRenderer,float retinaScale);
+		void	setFocus();
+		void	forceUpdateScrollBars();
+		
+		void	draw(int width, int height);
+
+		void	resize(int width, int height);
+				
+		bool	mouseMoveCallback( float x, float y);
+		bool	mouseButtonCallback(int button, int state, float x, float y);
+		bool	keyboardCallback(int key, int state);
+
+
+		void	setToggleButtonCallback(b3ToggleButtonCallback callback);
+		b3ToggleButtonCallback getToggleButtonCallback();
+
+		void	registerToggleButton(int buttonId, const char* name);
+
+		void	setComboBoxCallback(b3ComboBoxCallback callback);
+		b3ComboBoxCallback getComboBoxCallback();
+		void	registerComboBox(int buttonId, int numItems, const char** items, int startItem = 0);
+		
+		void	setStatusBarMessage(const char* message, bool isLeft=true);
+
+        void    registerFileOpenCallback(b3FileOpenCallback callback);
+    
+		GwenInternalData* getInternalData()
+		{
+			return m_data;
+		}
+
+};
+
+
+
+#endif //_GWEN_USER_INTERFACE_H
+