Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Code-style consistency improvement:

Browse Source 
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files.
make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type.
This commit contains no other changes aside from adding and applying clang-format-all.sh
This commit is contained in:
erwincoumans
2018-09-23 14:17:31 -07:00
parent b73b05e9fb
commit ab8f16961e
1773 changed files with 1081087 additions and 474249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
examples/ExampleBrowser/GwenGUISupport/GraphingTexture.cpp
View File

@@ -3,9 +3,9 @@
#include <assert.h>
GraphingTexture::GraphingTexture()
:m_textureId(0),
m_width(0),
m_height(0)
: m_textureId(0),
m_width(0),
m_height(0)
{
}
@@ -18,10 +18,9 @@ void GraphingTexture::destroy()
{
//TODO(erwincoumans) release memory etc...
m_width = 0;
m_height=0;
glDeleteTextures(1,(GLuint*)&m_textureId);
m_textureId=0;
m_height = 0;
glDeleteTextures(1, (GLuint*)&m_textureId);
m_textureId = 0;
}
bool GraphingTexture::create(int texWidth, int texHeight)
@@ -29,50 +28,46 @@ 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)
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)
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)
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[0] = 0;
pi[1] = 0;
pi[2] = 255;
pi[3] = 255;
}
pi+=4;
else
{
pi[0] = 255;
pi[1] = 0;
pi[2] = 0;
pi[3] = 255;
}
pi += 4;
}
}
glGenTextures(1,(GLuint*)&m_textureId);
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]);
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);
assert(glGetError() == GL_NO_ERROR);
}

33
examples/ExampleBrowser/GwenGUISupport/GraphingTexture.h
View File

@@ -9,38 +9,37 @@ struct GraphingTexture
btAlignedObjectArray<unsigned char> m_imageData;
int m_width;
int m_height;
GraphingTexture();
virtual ~GraphingTexture();
bool create(int texWidth, int texHeight);
void destroy();
void destroy();
void setPixel(int x, int y, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha)
{
if (y>=0 && y<m_height && x>=0 && x<m_width)
if (y >= 0 && y < m_height && x >= 0 && x < m_width)
{
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;
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 getPixel(int x, int y, unsigned char& red, unsigned char& green, unsigned char& blue, unsigned char& alpha)
{
red = m_imageData[x*4+y*4*m_width+0];
green = m_imageData[x*4+y*4*m_width+1];
blue = m_imageData[x*4+y*4*m_width+2];
alpha = m_imageData[x*4+y*4*m_width+3];
red = m_imageData[x * 4 + y * 4 * m_width + 0];
green = m_imageData[x * 4 + y * 4 * m_width + 1];
blue = m_imageData[x * 4 + y * 4 * m_width + 2];
alpha = m_imageData[x * 4 + y * 4 * m_width + 3];
}
void uploadImageData();
int getTextureId()
{
return m_textureId;
}
};
#endif //GRAPHING_TEXTURE_H
#endif //GRAPHING_TEXTURE_H

257
examples/ExampleBrowser/GwenGUISupport/GwenParameterInterface.cpp
View File

@@ -3,35 +3,34 @@
struct MyButtonEventHandler : public Gwen::Event::Handler
{
Gwen::Controls::Button* m_buttonControl;
Gwen::Controls::Button* m_buttonControl;
ButtonParamChangedCallback m_callback;
void* m_userPointer;
int m_buttonId;
MyButtonEventHandler(Gwen::Controls::Button* buttonControl, ButtonParamChangedCallback callback, int buttonId, void* userPointer)
:m_buttonControl(buttonControl),
m_callback(callback),
m_userPointer(userPointer),
m_buttonId(buttonId)
: m_buttonControl(buttonControl),
m_callback(callback),
m_userPointer(userPointer),
m_buttonId(buttonId)
{
}
void onButtonPress( Gwen::Controls::Base* pControl )
void onButtonPress(Gwen::Controls::Base* pControl)
{
if (m_callback)
{
bool buttonState = true;
if (m_buttonControl->IsToggle())
{
buttonState = m_buttonControl->GetToggleState();
}
( *m_callback )( m_buttonId, buttonState, m_userPointer );
bool buttonState = true;
if (m_buttonControl->IsToggle())
{
buttonState = m_buttonControl->GetToggleState();
}
(*m_callback)(m_buttonId, buttonState, m_userPointer);
}
}
};
template<typename T>
template <typename T>
struct MySliderEventHandler : public Gwen::Event::Handler
{
SliderParamChangedCallback m_callback;
@@ -40,22 +39,21 @@ struct MySliderEventHandler : public Gwen::Event::Handler
Gwen::Controls::Slider* m_pSlider;
char m_variableName[1024];
T* m_targetValue;
bool m_showValue;
bool m_showValue;
MySliderEventHandler(const char* varName, Gwen::Controls::TextBox* label, Gwen::Controls::Slider* pSlider,T* target, SliderParamChangedCallback callback, void* userPtr)
: m_callback(callback),
m_userPointer(userPtr),
m_label(label),
m_pSlider(pSlider),
m_targetValue(target),
m_showValue(true)
MySliderEventHandler(const char* varName, Gwen::Controls::TextBox* label, Gwen::Controls::Slider* pSlider, T* target, SliderParamChangedCallback callback, void* userPtr)
: m_callback(callback),
m_userPointer(userPtr),
m_label(label),
m_pSlider(pSlider),
m_targetValue(target),
m_showValue(true)
{
memcpy(m_variableName,varName,strlen(varName)+1);
memcpy(m_variableName, varName, strlen(varName) + 1);
}
void SliderMoved( Gwen::Controls::Base* pControl )
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() ) );
@@ -67,10 +65,9 @@ struct MySliderEventHandler : public Gwen::Event::Handler
{
(*m_callback)(v, m_userPointer);
}
}
void SetValue(T v)
void SetValue(T v)
{
if (v < m_pSlider->GetRangeMin())
{
@@ -79,24 +76,21 @@ struct MySliderEventHandler : public Gwen::Event::Handler
if (v > m_pSlider->GetRangeMax())
{
printf("?\n");
printf("?\n");
}
m_pSlider->SetValue(v,true);
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);
}
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
struct GwenParameters
{
b3AlignedObjectArray<MySliderEventHandler<btScalar>*> m_sliderEventHandlers;
b3AlignedObjectArray<Gwen::Controls::HorizontalSlider*> m_sliders;
@@ -108,113 +102,103 @@ struct GwenParameters
};
GwenParameterInterface::GwenParameterInterface(GwenInternalData* gwenInternalData)
:m_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);
}
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::registerButtonParameter(ButtonParams& params)
{
Gwen::Controls::Button* button = new Gwen::Controls::Button(m_gwenInternalData->m_demoPage->GetPage());
MyButtonEventHandler* handler = new MyButtonEventHandler(button, params.m_callback,params.m_buttonId,params.m_userPointer);
MyButtonEventHandler* handler = new MyButtonEventHandler(button, params.m_callback, params.m_buttonId, params.m_userPointer);
button->SetText(params.m_name);
button->onPress.Add( handler, &MyButtonEventHandler::onButtonPress );
button->SetIsToggle(params.m_isTrigger);
button->SetToggleState(params.m_initialState);
button->onPress.Add(handler, &MyButtonEventHandler::onButtonPress);
button->SetIsToggle(params.m_isTrigger);
button->SetToggleState(params.m_initialState);
m_paramInternalData->m_buttons.push_back(button);
m_paramInternalData->m_buttonEventHandlers.push_back(handler);
button->SetPos( 5, m_gwenInternalData->m_curYposition );
button->SetPos(5, m_gwenInternalData->m_curYposition);
button->SetWidth(220);
m_gwenInternalData->m_curYposition+=22;
m_gwenInternalData->m_curYposition += 22;
}
struct MyComboBoxHander2 :public Gwen::Event::Handler
struct MyComboBoxHander2 : public Gwen::Event::Handler
{
GwenInternalData* m_data;
int m_buttonId;
ComboBoxCallback m_callback;
void* m_userPointer;
GwenInternalData* m_data;
int m_buttonId;
ComboBoxCallback m_callback;
void* m_userPointer;
MyComboBoxHander2 (GwenInternalData* data, int buttonId,ComboBoxCallback callback, void* userPointer)
:m_data(data),
m_buttonId(buttonId),
m_callback(callback),
m_userPointer(userPointer)
MyComboBoxHander2(GwenInternalData* data, int buttonId, ComboBoxCallback callback, void* userPointer)
: m_data(data),
m_buttonId(buttonId),
m_callback(callback),
m_userPointer(userPointer)
{
}
void onSelect( Gwen::Controls::Base* pControl )
void onSelect(Gwen::Controls::Base* pControl)
{
Gwen::Controls::ComboBox* but = (Gwen::Controls::ComboBox*) pControl;
Gwen::Controls::ComboBox* but = (Gwen::Controls::ComboBox*)pControl;
Gwen::String str = Gwen::Utility::UnicodeToString( but->GetSelectedItem()->GetText());
Gwen::String str = Gwen::Utility::UnicodeToString(but->GetSelectedItem()->GetText());
if (m_callback)
(*m_callback)(m_buttonId,str.c_str(),m_userPointer);
(*m_callback)(m_buttonId, str.c_str(), m_userPointer);
}
};
void GwenParameterInterface::registerComboBox(ComboBoxParams& params)
{
Gwen::Controls::ComboBox* combobox = new Gwen::Controls::ComboBox(m_gwenInternalData->m_demoPage->GetPage());
m_paramInternalData->m_comboBoxes.push_back(combobox);
MyComboBoxHander2* handler = new MyComboBoxHander2(m_gwenInternalData, params.m_comboboxId,params.m_callback, params.m_userPointer);
MyComboBoxHander2* handler = new MyComboBoxHander2(m_gwenInternalData, params.m_comboboxId, params.m_callback, params.m_userPointer);
m_gwenInternalData->m_handlers.push_back(handler);
combobox->onSelection.Add(handler,&MyComboBoxHander2::onSelect);
combobox->onSelection.Add(handler, &MyComboBoxHander2::onSelect);
int ypos = m_gwenInternalData->m_curYposition;
m_gwenInternalData->m_curYposition+=22;
combobox->SetPos(5, ypos );
combobox->SetWidth( 220 );
m_gwenInternalData->m_curYposition += 22;
combobox->SetPos(5, ypos);
combobox->SetWidth(220);
//box->SetPos(120,130);
for (int i=0;i<params.m_numItems;i++)
for (int i = 0; i < params.m_numItems; i++)
{
Gwen::Controls::MenuItem* item = combobox->AddItem(Gwen::Utility::StringToUnicode(params.m_items[i]));
if (i==params.m_startItem)
if (i == params.m_startItem)
combobox->OnItemSelected(item);
}
}
void GwenParameterInterface::registerSliderFloatParameter(SliderParams& params)
@@ -222,99 +206,94 @@ 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->SetText(params.m_name);
label->SetPos(10, 10 + 25);
label->SetWidth(210);
label->SetPos(10,m_gwenInternalData->m_curYposition);
m_gwenInternalData->m_curYposition+=22;
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());
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( 200, 20 );
pSlider->SetRange( params.m_minVal, params.m_maxVal);
if (params.m_clampToIntegers)
{
pSlider->SetNotchCount( int( params.m_maxVal - params.m_minVal ) );
pSlider->SetClampToNotches( true );
}
else
{
pSlider->SetNotchCount( 16 );//float(params.m_maxVal-params.m_minVal)/100.f);
pSlider->SetClampToNotches( params.m_clampToNotches );
}
pSlider->SetValue( *params.m_paramValuePointer);//dimensions[i] );
pSlider->SetPos(10, m_gwenInternalData->m_curYposition);
pSlider->SetSize(200, 20);
pSlider->SetRange(params.m_minVal, params.m_maxVal);
if (params.m_clampToIntegers)
{
pSlider->SetNotchCount(int(params.m_maxVal - params.m_minVal));
pSlider->SetClampToNotches(true);
}
else
{
pSlider->SetNotchCount(16); //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,params.m_callback, params.m_userPointer);
handler->m_showValue = params.m_showValues;
sprintf(labelName, "%s", params.m_name); //axisNames[0]);
MySliderEventHandler<btScalar>* handler = new MySliderEventHandler<btScalar>(labelName, label, pSlider, params.m_paramValuePointer, params.m_callback, params.m_userPointer);
handler->m_showValue = params.m_showValues;
m_paramInternalData->m_sliderEventHandlers.push_back(handler);
pSlider->onValueChanged.Add( handler, &MySliderEventHandler<btScalar>::SliderMoved );
pSlider->onValueChanged.Add(handler, &MySliderEventHandler<btScalar>::SliderMoved);
handler->SliderMoved(pSlider);
// float v = pSlider->GetValue();
m_gwenInternalData->m_curYposition+=22;
// float v = pSlider->GetValue();
m_gwenInternalData->m_curYposition += 22;
}
void GwenParameterInterface::syncParameters()
{
for (int i=0;i<m_paramInternalData->m_sliderEventHandlers.size();i++)
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);
handler->m_pSlider->SetValue(*handler->m_targetValue, true);
}
}
void GwenParameterInterface::removeAllParameters()
{
for (int i=0;i<m_paramInternalData->m_buttons.size();i++)
for (int i = 0; i < m_paramInternalData->m_buttons.size(); i++)
{
delete m_paramInternalData->m_buttons[i];
}
m_paramInternalData->m_buttons.clear();
for (int i=0;i<m_paramInternalData->m_buttonEventHandlers.size();i++)
for (int i = 0; i < m_paramInternalData->m_buttonEventHandlers.size(); i++)
{
delete m_paramInternalData->m_buttonEventHandlers[i];
}
m_paramInternalData->m_buttonEventHandlers.clear();
m_gwenInternalData->m_curYposition+=22;
for (int i=0;i<m_paramInternalData->m_sliders.size();i++)
m_gwenInternalData->m_curYposition += 22;
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++)
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++)
for (int i = 0; i < m_paramInternalData->m_textLabels.size(); i++)
{
delete m_paramInternalData->m_textLabels[i];
}
m_paramInternalData->m_textLabels.clear();
for (int i=0;i<m_paramInternalData->m_comboBoxes.size();i++)
for (int i = 0; i < m_paramInternalData->m_comboBoxes.size(); i++)
{
delete m_paramInternalData->m_comboBoxes[i];
}
m_paramInternalData->m_comboBoxes.clear();
m_gwenInternalData->m_curYposition = this->m_paramInternalData->m_savedYposition;
for (int i=0;i<m_gwenInternalData->m_handlers.size();i++)
for (int i = 0; i < m_gwenInternalData->m_handlers.size(); i++)
{
delete m_gwenInternalData->m_handlers[i];
}
m_gwenInternalData->m_handlers.clear();
}

9
examples/ExampleBrowser/GwenGUISupport/GwenParameterInterface.h
View File

@@ -7,7 +7,7 @@ struct GwenParameterInterface : public CommonParameterInterface
{
struct GwenInternalData* m_gwenInternalData;
struct GwenParameters* m_paramInternalData;
struct GwenParameters* m_paramInternalData;
GwenParameterInterface(struct GwenInternalData* gwenInternalData);
virtual ~GwenParameterInterface();
@@ -15,12 +15,9 @@ struct GwenParameterInterface : public CommonParameterInterface
virtual void registerButtonParameter(ButtonParams& params);
virtual void registerComboBox(ComboBoxParams& params);
virtual void setSliderValue(int sliderIndex, double sliderValue);
virtual void setSliderValue(int sliderIndex, double sliderValue);
virtual void syncParameters();
virtual void removeAllParameters();
};
#endif//GWEN_PARAMETER_INTERFACE_H
#endif //GWEN_PARAMETER_INTERFACE_H

284
examples/ExampleBrowser/GwenGUISupport/GwenProfileWindow.cpp
View File

@@ -3,293 +3,258 @@
#include "gwenInternalData.h"
#include "LinearMath/btQuickprof.h"
#ifndef BT_NO_PROFILE
#ifndef BT_NO_PROFILE
class MyProfileWindow : public Gwen::Controls::WindowControl
{
// Gwen::Controls::TabControl* m_TabControl;
//Gwen::Controls::ListBox* m_TextOutput;
unsigned int m_iFrames;
float m_fLastSecond;
unsigned int m_iFrames;
float m_fLastSecond;
Gwen::Controls::TreeNode* m_node;
Gwen::Controls::TreeControl* m_ctrl;
protected:
void onButtonA( Gwen::Controls::Base* pControl )
void onButtonA(Gwen::Controls::Base* pControl)
{
// OpenTissue::glut::toggleIdle();
// OpenTissue::glut::toggleIdle();
}
void SliderMoved(Gwen::Controls::Base* pControl )
void SliderMoved(Gwen::Controls::Base* pControl)
{
// Gwen::Controls::Slider* pSlider = (Gwen::Controls::Slider*)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)
void OnCheckChangedStiffnessWarping(Gwen::Controls::Base* pControl)
{
// Gwen::Controls::CheckBox* labeled = (Gwen::Controls::CheckBox* )pControl;
// bool checked = labeled->IsChecked();
// Gwen::Controls::CheckBox* labeled = (Gwen::Controls::CheckBox* )pControl;
// bool checked = labeled->IsChecked();
//m_app->m_stiffness_warp_on = checked;
}
public:
CProfileIterator* profIter;
class MyMenuItems3* m_menuItems;
MyProfileWindow ( Gwen::Controls::Base* pParent)
: Gwen::Controls::WindowControl( pParent ),
profIter(0)
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);
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" );
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);
m_ctrl->SetKeyboardInputEnabled(true);
m_ctrl->SetBounds(this->GetInnerBounds().x, this->GetInnerBounds().y, this->GetInnerBounds().w, this->GetInnerBounds().h);
}
}
virtual ~MyProfileWindow()
{
delete m_node;
delete m_ctrl;
}
float dumpRecursive(CProfileIterator* profileIterator, Gwen::Controls::TreeNode* parentNode)
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();
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();
if (0==frames_since_reset)
if (0 == frames_since_reset)
return 0.f;
//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())
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());
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());
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 = 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++)
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)
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 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;
//recompute profiling data, and store profile strings
// char blockTime[128];
double accumulated_time = dumpRecursive(profileIterator,m_node);
const char* name = profileIterator->Get_Current_Parent_Name();
// 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);
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);
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);
//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;
static int counter = 10;
if (counter)
{
counter--;
counter--;
m_ctrl->ExpandAll();
}
}
void PrintText( const Gwen::UnicodeString& str )
void PrintText(const Gwen::UnicodeString& str)
{
}
void Render( Gwen::Skin::Base* skin )
void Render(Gwen::Skin::Base* skin)
{
m_iFrames++;
if ( m_fLastSecond < Gwen::Platform::GetTimeInSeconds() )
if (m_fLastSecond < Gwen::Platform::GetTimeInSeconds())
{
SetTitle( Gwen::Utility::Format( L"Profiler %i fps", m_iFrames ) );
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 );
Gwen::Controls::WindowControl::Render(skin);
}
};
class MyMenuItems3 : public Gwen::Controls::Base
class MyMenuItems3 : public Gwen::Controls::Base
{
public:
class MyProfileWindow* m_profWindow;
MyMenuItems3() :Gwen::Controls::Base(0)
{
}
virtual ~MyMenuItems3() {}
void MenuItemSelect(Gwen::Controls::Base* pControl)
{
MyMenuItems3() : Gwen::Controls::Base(0)
{
}
virtual ~MyMenuItems3() {}
void MenuItemSelect(Gwen::Controls::Base* pControl)
{
if (m_profWindow->Hidden())
{
m_profWindow->SetHidden(false);
} else
}
else
{
m_profWindow->SetHidden(true);
}
}
}
};
MyProfileWindow* setupProfileWindow(GwenInternalData* data)
{
MyMenuItems3* menuItems = new MyMenuItems3;
MyProfileWindow* profWindow = new MyProfileWindow(data->pCanvas);
//profWindow->SetHidden(true);
//profWindow->SetHidden(true);
profWindow->m_menuItems = menuItems;
profWindow->profIter = CProfileManager::Get_Iterator();
data->m_viewMenu->GetMenu()->AddItem( L"Profiler", menuItems,(Gwen::Event::Handler::Function)&MyMenuItems3::MenuItemSelect);
data->m_viewMenu->GetMenu()->AddItem(L"Profiler", menuItems, (Gwen::Event::Handler::Function)&MyMenuItems3::MenuItemSelect);
menuItems->m_profWindow = profWindow;
return profWindow;
}
void processProfileData( MyProfileWindow* profWindow, bool idle)
void processProfileData(MyProfileWindow* profWindow, bool idle)
{
if (profWindow)
{
@@ -297,7 +262,7 @@ void processProfileData( MyProfileWindow* profWindow, bool idle)
{
profWindow->UpdateText(profWindow->profIter, idle);
}
}
}
}
bool isProfileWindowVisible(MyProfileWindow* window)
@@ -315,7 +280,6 @@ void destroyProfileWindow(MyProfileWindow* window)
delete window->m_menuItems;
delete window;
CProfileManager::CleanupMemory();
}
#endif //BT_NO_PROFILE
#endif //BT_NO_PROFILE

4
examples/ExampleBrowser/GwenGUISupport/GwenProfileWindow.h
View File

@@ -8,6 +8,4 @@ bool isProfileWindowVisible(MyProfileWindow* window);
void destroyProfileWindow(MyProfileWindow* window);
#endif//GWEN_PROFILE_WINDOW_H
#endif //GWEN_PROFILE_WINDOW_H

80
examples/ExampleBrowser/GwenGUISupport/GwenTextureWindow.cpp
View File

@@ -3,79 +3,70 @@
#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)
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 );
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);
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 );
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->SetImage(texName);
}
m_imgPanel->SetBounds( input.m_borderWidth, input.m_borderWidth,
input.m_width,
input.m_height );
// this->Dock( Gwen::Pos::Bottom);
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
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)
{
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
// if (m_item)
// m_item->SetCheck(false);
}
else
{
m_graphWindow->SetHidden(true);
// if (m_item)
// m_item->SetCheck(true);
// if (m_item)
// m_item->SetCheck(true);
}
}
}
};
MyGraphWindow* setupTextureWindow(const MyGraphInput& input)
@@ -83,13 +74,12 @@ 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);
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)

19
examples/ExampleBrowser/GwenGUISupport/GwenTextureWindow.h
View File

@@ -14,19 +14,18 @@ struct MyGraphInput
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)
: 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
#endif //GWEN_TEXTURE_WINDOW_H

37
examples/ExampleBrowser/GwenGUISupport/gwenInternalData.h
View File

@@ -28,37 +28,34 @@
//#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;
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;
Gwen::Controls::ListBox* m_TextOutput;
Gwen::Controls::Label* m_exampleInfoGroupBox;
Gwen::Controls::ListBox* m_exampleInfoTextOutput;
struct MyTestMenuBar* m_menubar;
Gwen::Controls::TabButton* m_demoPage;
Gwen::Controls::TabButton* m_explorerPage;
Gwen::Controls::TreeControl* m_explorerTreeCtrl;
Gwen::Controls::MenuItem* m_viewMenu;
class MyMenuItems* m_menuItems;
Gwen::Controls::ListBox* m_TextOutput;
Gwen::Controls::Label* m_exampleInfoGroupBox;
Gwen::Controls::ListBox* m_exampleInfoTextOutput;
struct MyTestMenuBar* m_menubar;
Gwen::Controls::StatusBar* m_bar;
Gwen::Controls::ScrollControl* m_windowRight;
Gwen::Controls::TabControl* m_tab;
int m_curYposition;
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;
b3AlignedObjectArray<class Gwen::Event::Handler*> m_handlers;
b3ToggleButtonCallback m_toggleButtonCallback;
b3ComboBoxCallback m_comboBoxCallback;
};
#endif//GWEN_INTERNAL_DATA_H
#endif //GWEN_INTERNAL_DATA_H

446
examples/ExampleBrowser/GwenGUISupport/gwenUserInterface.cpp
View File

@@ -7,24 +7,20 @@
class MyGraphWindow* graphWindow = 0;
GwenUserInterface::GwenUserInterface()
{
m_data = new GwenInternalData();
m_data->m_toggleButtonCallback = 0;
m_data->m_comboBoxCallback = 0;
}
class MyMenuItems : public Gwen::Controls::Base
{
public:
b3FileOpenCallback m_fileOpenCallback;
b3QuitCallback m_quitCallback;
MyMenuItems() :Gwen::Controls::Base(0), m_fileOpenCallback(0)
MyMenuItems() : Gwen::Controls::Base(0), m_fileOpenCallback(0)
{
}
void myQuitApp(Gwen::Controls::Base* pControl)
@@ -41,20 +37,16 @@ public:
(*m_fileOpenCallback)();
}
}
};
struct MyTestMenuBar : public Gwen::Controls::MenuStrip
{
Gwen::Controls::MenuItem* m_fileMenu;
Gwen::Controls::MenuItem* m_viewMenu;
MyMenuItems* m_menuItems;
MyMenuItems* m_menuItems;
MyTestMenuBar(Gwen::Controls::Base* pParent)
:Gwen::Controls::MenuStrip(pParent)
: Gwen::Controls::MenuStrip(pParent)
{
// Gwen::Controls::MenuStrip* menu = new Gwen::Controls::MenuStrip( pParent );
{
@@ -67,18 +59,15 @@ struct MyTestMenuBar : public Gwen::Controls::MenuStrip
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");
}
}
virtual ~MyTestMenuBar()
{
delete m_menuItems;
}
};
void GwenUserInterface::exit()
void GwenUserInterface::exit()
{
//m_data->m_menubar->RemoveAllChildren();
delete m_data->m_tab;
@@ -88,7 +77,7 @@ void GwenUserInterface::exit()
delete m_data->m_rightStatusBar;
delete m_data->m_bar;
delete m_data->m_menubar;
m_data->m_menubar = 0;
delete m_data->pCanvas;
m_data->pCanvas = 0;
@@ -96,262 +85,226 @@ void GwenUserInterface::exit()
GwenUserInterface::~GwenUserInterface()
{
for (int i=0;i<m_data->m_handlers.size();i++)
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;
}
void GwenUserInterface::resize(int width, int height)
void GwenUserInterface::resize(int width, int height)
{
m_data->pCanvas->SetSize(width,height);
m_data->pCanvas->SetSize(width, height);
}
struct MyComboBoxHander :public Gwen::Event::Handler
struct MyComboBoxHander : public Gwen::Event::Handler
{
GwenInternalData* m_data;
int m_buttonId;
GwenInternalData* m_data;
int m_buttonId;
MyComboBoxHander (GwenInternalData* data, int buttonId)
:m_data(data),
m_buttonId(buttonId)
MyComboBoxHander(GwenInternalData* data, int buttonId)
: m_data(data),
m_buttonId(buttonId)
{
}
void onSelect( Gwen::Controls::Base* pControl )
void onSelect(Gwen::Controls::Base* pControl)
{
Gwen::Controls::ComboBox* but = (Gwen::Controls::ComboBox*) pControl;
Gwen::Controls::ComboBox* but = (Gwen::Controls::ComboBox*)pControl;
Gwen::String str = Gwen::Utility::UnicodeToString( but->GetSelectedItem()->GetText());
Gwen::String str = Gwen::Utility::UnicodeToString(but->GetSelectedItem()->GetText());
if (m_data->m_comboBoxCallback)
(*m_data->m_comboBoxCallback)(m_buttonId,str.c_str());
(*m_data->m_comboBoxCallback)(m_buttonId, str.c_str());
}
};
struct MyButtonHander :public Gwen::Event::Handler
struct MyButtonHander : public Gwen::Event::Handler
{
GwenInternalData* m_data;
int m_buttonId;
GwenInternalData* m_data;
int m_buttonId;
MyButtonHander (GwenInternalData* data, int buttonId)
:m_data(data),
m_buttonId(buttonId)
MyButtonHander(GwenInternalData* data, int buttonId)
: m_data(data),
m_buttonId(buttonId)
{
}
void onButtonA( Gwen::Controls::Base* pControl )
void onButtonA(Gwen::Controls::Base* pControl)
{
Gwen::Controls::Button* but = (Gwen::Controls::Button*) pControl;
// int dep = but->IsDepressed();
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);
(*m_data->m_toggleButtonCallback)(m_buttonId, tog);
}
};
void GwenUserInterface::textOutput(const char* message)
void GwenUserInterface::textOutput(const char* message)
{
Gwen::UnicodeString msg = Gwen::Utility::StringToUnicode(message);
m_data->m_TextOutput->AddItem( msg );
m_data->m_TextOutput->AddItem(msg);
m_data->m_TextOutput->Scroller()->ScrollToBottom();
}
void GwenUserInterface::setExampleDescription(const char* message)
void GwenUserInterface::setExampleDescription(const char* message)
{
//Gwen apparently doesn't have text/word wrap, so do rudimentary brute-force implementation here.
std::string wrapmessage=message;
std::string wrapmessage = message;
int startPos = 0;
std::string lastFit = "";
bool hasSpace = false;
std::string lastFitSpace = "";
int spacePos = 0;
m_data->m_exampleInfoTextOutput->Clear();
int fixedWidth = m_data->m_exampleInfoTextOutput->GetBounds().w-25;
int fixedWidth = m_data->m_exampleInfoTextOutput->GetBounds().w - 25;
int wrapLen = int(wrapmessage.length());
for (int endPos=0;endPos<=wrapLen;endPos++)
for (int endPos = 0; endPos <= wrapLen; endPos++)
{
std::string sub = wrapmessage.substr(startPos,(endPos-startPos));
Gwen::Point pt = m_data->pRenderer->MeasureText(m_data->pCanvas->GetSkin()->GetDefaultFont(),sub);
std::string sub = wrapmessage.substr(startPos, (endPos - startPos));
Gwen::Point pt = m_data->pRenderer->MeasureText(m_data->pCanvas->GetSkin()->GetDefaultFont(), sub);
if (pt.x <= fixedWidth)
{
lastFit = sub;
if (message[endPos]==' ' ||message[endPos]=='.' || message[endPos]==',' )
if (message[endPos] == ' ' || message[endPos] == '.' || message[endPos] == ',')
{
hasSpace = true;
lastFitSpace = sub;
spacePos = endPos;
}
} else
}
else
{
//submit and
//submit and
if (hasSpace)
{
endPos = spacePos+1;
endPos = spacePos + 1;
hasSpace = false;
lastFit = lastFitSpace;
startPos = endPos;
} else
}
else
{
startPos = endPos-1;
startPos = endPos - 1;
}
Gwen::UnicodeString msg = Gwen::Utility::StringToUnicode(lastFit);
m_data->m_exampleInfoTextOutput->AddItem( msg );
m_data->m_exampleInfoTextOutput->AddItem(msg);
m_data->m_exampleInfoTextOutput->Scroller()->ScrollToBottom();
}
}
if (lastFit.length())
{
Gwen::UnicodeString msg = Gwen::Utility::StringToUnicode(lastFit);
m_data->m_exampleInfoTextOutput->AddItem( msg );
m_data->m_exampleInfoTextOutput->AddItem(msg);
m_data->m_exampleInfoTextOutput->Scroller()->ScrollToBottom();
}
}
void GwenUserInterface::setStatusBarMessage(const char* message, bool isLeft)
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_leftStatusBar->SetText(msg);
}
else
{
m_data->m_rightStatusBar->SetText( msg);
m_data->m_rightStatusBar->SetText(msg);
}
}
void GwenUserInterface::registerFileOpenCallback(b3FileOpenCallback callback)
{
m_data->m_menuItems->m_fileOpenCallback = callback;
m_data->m_menuItems->m_fileOpenCallback = callback;
}
void GwenUserInterface::registerQuitCallback(b3QuitCallback callback)
{
m_data->m_menuItems->m_quitCallback = callback;
m_data->m_menuItems->m_quitCallback = callback;
}
void GwenUserInterface::init(int width, int height,Gwen::Renderer::Base* renderer,float retinaScale)
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->pRenderer = renderer; //new GwenOpenGL3CoreRenderer(m_data->m_primRenderer,stash,width,height,retinaScale);
m_data->skin.SetRender( m_data->pRenderer );
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));
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;
m_data->m_menuItems = menubar->m_menuItems;
m_data->m_menubar = menubar;
Gwen::Controls::StatusBar* bar = new Gwen::Controls::StatusBar(m_data->pCanvas);
m_data->m_bar = bar;
m_data->m_rightStatusBar = new Gwen::Controls::Label( bar );
m_data->m_rightStatusBar->SetWidth(width/2);
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_TextOutput = new Gwen::Controls::ListBox( m_data->pCanvas );
m_data->m_TextOutput->Dock( Gwen::Pos::Bottom );
m_data->m_TextOutput->SetHeight( 100 );
m_data->m_leftStatusBar = new Gwen::Controls::Label( bar );
bar->AddControl(m_data->m_rightStatusBar, true);
m_data->m_TextOutput = new Gwen::Controls::ListBox(m_data->pCanvas);
m_data->m_TextOutput->Dock(Gwen::Pos::Bottom);
m_data->m_TextOutput->SetHeight(100);
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);
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);
Gwen::Controls::ScrollControl* windowRight = new Gwen::Controls::ScrollControl(m_data->pCanvas);
windowRight->Dock(Gwen::Pos::Right);
windowRight->SetWidth(250);
windowRight->SetHeight(250);
windowRight->SetScroll(false,true);
windowRight->SetScroll(false, true);
m_data->m_windowRight = windowRight;
//windowLeft->SetSkin(
Gwen::Controls::TabControl* tab = new Gwen::Controls::TabControl(windowRight);
m_data->m_tab = tab;
//tab->SetHeight(300);
tab->SetWidth(240);
tab->SetHeight(1250);
//tab->Dock(Gwen::Pos::Left);
tab->Dock( Gwen::Pos::Fill );
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 str2(L"OpenCL");
// tab->AddPage(str2);
//Gwen::UnicodeString str3(L"page3");
// tab->AddPage(str3);
// 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);
@@ -359,7 +312,7 @@ void GwenUserInterface::init(int width, int height,Gwen::Renderer::Base* rendere
windowBottom->Dock(Gwen::Pos::Bottom);
windowBottom->SetTitle("bottom");
*/
// Gwen::Controls::Property::Text* prop = new Gwen::Controls::Property::Text(m_data->pCanvas);
// 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);
@@ -381,19 +334,15 @@ void GwenUserInterface::init(int width, int height,Gwen::Renderer::Base* rendere
//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->SetWidth(230);
explorerTab->SetHeight(250);
//tab->Dock(Gwen::Pos::Left);
explorerTab->Dock(Gwen::Pos::Fill);
//m_data->m_exampleInfoTextOutput->SetBounds(2, 10, 236, 400);
//windowRight
@@ -407,16 +356,16 @@ void GwenUserInterface::init(int width, int height,Gwen::Renderer::Base* rendere
//Gwen::Controls::HSVColorPicker* color = new Gwen::Controls::HSVColorPicker(shapes->GetPage());
Gwen::Controls::ColorPicker* color = new Gwen::Controls::ColorPicker(shapes->GetPage());
color->SetKeyboardInputEnabled(true);
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, 300);
m_data->m_exampleInfoGroupBox = new Gwen::Controls::Label( m_data->m_explorerPage->GetPage() );
m_data->m_exampleInfoGroupBox = new Gwen::Controls::Label(m_data->m_explorerPage->GetPage());
m_data->m_exampleInfoGroupBox->SetPos(2, 314);
m_data->m_exampleInfoGroupBox->SetHeight( 15 );
m_data->m_exampleInfoGroupBox->SetHeight(15);
m_data->m_exampleInfoGroupBox->SetWidth(234);
m_data->m_exampleInfoGroupBox->SetText("Example Description");
@@ -424,14 +373,11 @@ void GwenUserInterface::init(int width, int height,Gwen::Renderer::Base* rendere
//m_data->m_exampleInfoTextOutput->Dock( Gwen::Pos::Bottom );
m_data->m_exampleInfoTextOutput->SetPos(2, 332);
m_data->m_exampleInfoTextOutput->SetHeight( 150 );
m_data->m_exampleInfoTextOutput->SetHeight(150);
m_data->m_exampleInfoTextOutput->SetWidth(233);
}
void GwenUserInterface::forceUpdateScrollBars()
void GwenUserInterface::forceUpdateScrollBars()
{
b3Assert(m_data);
b3Assert(m_data->m_explorerTreeCtrl);
@@ -441,7 +387,7 @@ void GwenUserInterface::forceUpdateScrollBars()
}
}
void GwenUserInterface::setFocus()
void GwenUserInterface::setFocus()
{
b3Assert(m_data);
b3Assert(m_data->m_explorerTreeCtrl);
@@ -451,16 +397,16 @@ void GwenUserInterface::setFocus()
}
}
b3ToggleButtonCallback GwenUserInterface::getToggleButtonCallback()
b3ToggleButtonCallback GwenUserInterface::getToggleButtonCallback()
{
return m_data->m_toggleButtonCallback;
}
void GwenUserInterface::setToggleButtonCallback(b3ToggleButtonCallback callback)
void GwenUserInterface::setToggleButtonCallback(b3ToggleButtonCallback callback)
{
m_data->m_toggleButtonCallback = callback;
}
void GwenUserInterface::registerToggleButton2(int buttonId, const char* name)
void GwenUserInterface::registerToggleButton2(int buttonId, const char* name)
{
assert(m_data);
assert(m_data->m_demoPage);
@@ -469,21 +415,20 @@ void GwenUserInterface::registerToggleButton2(int buttonId, const char* name)
///some heuristic to find the button location
int ypos = m_data->m_curYposition;
but->SetPos(10, ypos );
but->SetWidth( 200 );
but->SetPos(10, ypos);
but->SetWidth(200);
//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;
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)
void GwenUserInterface::setComboBoxCallback(b3ComboBoxCallback callback)
{
m_data->m_comboBoxCallback = callback;
}
@@ -492,67 +437,61 @@ b3ComboBoxCallback GwenUserInterface::getComboBoxCallback()
{
return m_data->m_comboBoxCallback;
}
void GwenUserInterface::registerComboBox2(int comboboxId, int numItems, const char** items, int startItem)
void GwenUserInterface::registerComboBox2(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);
combobox->onSelection.Add(handler, &MyComboBoxHander::onSelect);
int ypos = m_data->m_curYposition;
combobox->SetPos(10, ypos );
combobox->SetWidth( 100 );
combobox->SetPos(10, ypos);
combobox->SetWidth(100);
//box->SetPos(120,130);
for (int i=0;i<numItems;i++)
for (int i = 0; i < numItems; i++)
{
Gwen::Controls::MenuItem* item = combobox->AddItem(Gwen::Utility::StringToUnicode(items[i]));
if (i==startItem)
if (i == startItem)
combobox->OnItemSelected(item);
}
m_data->m_curYposition+=22;
m_data->m_curYposition += 22;
}
void GwenUserInterface::draw(int width, int height)
void GwenUserInterface::draw(int width, int height)
{
// printf("width = %d, height=%d\n", width,height);
// printf("width = %d, height=%d\n", width,height);
if (m_data->pCanvas)
{
m_data->pCanvas->SetSize(width,height);
m_data->pCanvas->SetSize(width, height);
//m_data->m_primRenderer->setScreenSize(width,height);
m_data->pRenderer->Resize(width,height);
m_data->pRenderer->Resize(width, height);
m_data->pCanvas->RenderCanvas();
//restoreOpenGLState();
}
}
bool GwenUserInterface::mouseMoveCallback( float x, float y)
bool GwenUserInterface::mouseMoveCallback(float x, float y)
{
bool handled = false;
bool handled = false;
static int m_lastmousepos[2] = {0,0};
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;
m_lastmousepos[0] = x + 1;
m_lastmousepos[1] = y + 1;
}
handled = m_data->pCanvas->InputMouseMoved(x,y,m_lastmousepos[0],m_lastmousepos[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)
bool GwenUserInterface::keyboardCallback(int bulletKey, int state)
{
int gwenKey = -1;
if (m_data->pCanvas)
@@ -560,96 +499,93 @@ bool GwenUserInterface::keyboardCallback(int bulletKey, int state)
//convert 'Bullet' keys into 'Gwen' keys
switch (bulletKey)
{
case B3G_RETURN:
{
gwenKey = Gwen::Key::Return;
break;
}
case B3G_LEFT_ARROW:
{
gwenKey = Gwen::Key::Left;
break;
}
case B3G_RIGHT_ARROW:
{
gwenKey = Gwen::Key::Right;
break;
}
case B3G_UP_ARROW:
{
gwenKey = Gwen::Key::Up;
break;
}
case B3G_DOWN_ARROW:
{
gwenKey = Gwen::Key::Down;
break;
}
case B3G_BACKSPACE:
{
gwenKey = Gwen::Key::Backspace;
break;
}
case B3G_DELETE:
{
gwenKey = Gwen::Key::Delete;
break;
}
case B3G_HOME:
{
gwenKey = Gwen::Key::Home;
break;
}
case B3G_END:
{
gwenKey = Gwen::Key::End;
break;
}
case B3G_SHIFT:
{
gwenKey = Gwen::Key::Shift;
break;
}
case B3G_CONTROL:
{
gwenKey = Gwen::Key::Control;
break;
}
case B3G_RETURN:
{
gwenKey = Gwen::Key::Return;
break;
}
case B3G_LEFT_ARROW:
{
gwenKey = Gwen::Key::Left;
break;
}
case B3G_RIGHT_ARROW:
{
gwenKey = Gwen::Key::Right;
break;
}
case B3G_UP_ARROW:
{
gwenKey = Gwen::Key::Up;
break;
}
case B3G_DOWN_ARROW:
{
gwenKey = Gwen::Key::Down;
break;
}
case B3G_BACKSPACE:
{
gwenKey = Gwen::Key::Backspace;
break;
}
case B3G_DELETE:
{
gwenKey = Gwen::Key::Delete;
break;
}
case B3G_HOME:
{
gwenKey = Gwen::Key::Home;
break;
}
case B3G_END:
{
gwenKey = Gwen::Key::End;
break;
}
case B3G_SHIFT:
{
gwenKey = Gwen::Key::Shift;
break;
}
case B3G_CONTROL:
{
gwenKey = Gwen::Key::Control;
break;
}
default:
{
}
default:
{
}
};
if (gwenKey>=0)
if (gwenKey >= 0)
{
return m_data->pCanvas->InputKey(gwenKey,state==1);
} else
return m_data->pCanvas->InputKey(gwenKey, state == 1);
}
else
{
if (bulletKey<256 && state)
if (bulletKey < 256 && state)
{
Gwen::UnicodeChar c = ( Gwen::UnicodeChar ) bulletKey;
Gwen::UnicodeChar c = (Gwen::UnicodeChar)bulletKey;
return m_data->pCanvas->InputCharacter(c);
}
}
}
return false;
}
bool GwenUserInterface::mouseButtonCallback(int button, int state, float x, float y)
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);
handled = m_data->pCanvas->InputMouseMoved(x, y, x, y);
if (button>=0)
if (button >= 0)
{
handled = m_data->pCanvas->InputMouseButton(button,(bool)state);
handled = m_data->pCanvas->InputMouseButton(button, (bool)state);
if (handled)
{
//if (!state)

83
examples/ExampleBrowser/GwenGUISupport/gwenUserInterface.h
View File

@@ -3,68 +3,61 @@
struct GwenInternalData;
typedef void (*b3ComboBoxCallback) (int combobox, const char* item);
typedef void (*b3ComboBoxCallback)(int combobox, const char* item);
typedef void (*b3ToggleButtonCallback)(int button, int state);
typedef void (*b3FileOpenCallback)();
typedef void (*b3QuitCallback)();
namespace Gwen
{
namespace Renderer
{
class Base;
};
namespace Renderer
{
class Base;
};
}; // namespace Gwen
class GwenUserInterface
{
GwenInternalData* m_data;
GwenInternalData* m_data;
public:
GwenUserInterface();
virtual ~GwenUserInterface();
void init(int width, int height,Gwen::Renderer::Base* gwenRenderer,float retinaScale);
void exit();
void setFocus();
void forceUpdateScrollBars();
void draw(int width, int height);
public:
GwenUserInterface();
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);
virtual ~GwenUserInterface();
void init(int width, int height, Gwen::Renderer::Base* gwenRenderer, float retinaScale);
void exit();
void setFocus();
void forceUpdateScrollBars();
void setToggleButtonCallback(b3ToggleButtonCallback callback);
b3ToggleButtonCallback getToggleButtonCallback();
void draw(int width, int height);
void registerToggleButton2(int buttonId, const char* name);
void resize(int width, int height);
void setComboBoxCallback(b3ComboBoxCallback callback);
b3ComboBoxCallback getComboBoxCallback();
void registerComboBox2(int buttonId, int numItems, const char** items, int startItem = 0);
void setStatusBarMessage(const char* message, bool isLeft=true);
bool mouseMoveCallback(float x, float y);
bool mouseButtonCallback(int button, int state, float x, float y);
bool keyboardCallback(int key, int state);
void textOutput(const char* msg);
void setExampleDescription(const char* msg);
void setToggleButtonCallback(b3ToggleButtonCallback callback);
b3ToggleButtonCallback getToggleButtonCallback();
void registerFileOpenCallback(b3FileOpenCallback callback);
void registerQuitCallback(b3QuitCallback callback);
GwenInternalData* getInternalData()
{
return m_data;
}
void registerToggleButton2(int buttonId, const char* name);
void setComboBoxCallback(b3ComboBoxCallback callback);
b3ComboBoxCallback getComboBoxCallback();
void registerComboBox2(int buttonId, int numItems, const char** items, int startItem = 0);
void setStatusBarMessage(const char* message, bool isLeft = true);
void textOutput(const char* msg);
void setExampleDescription(const char* msg);
void registerFileOpenCallback(b3FileOpenCallback callback);
void registerQuitCallback(b3QuitCallback callback);
GwenInternalData* getInternalData()
{
return m_data;
}
};
#endif //_GWEN_USER_INTERFACE_H
#endif //_GWEN_USER_INTERFACE_H