void TPinterface::initGUI()
{
// Check CGFinterface.h and GLUI documentation for the types of controls available
//GLUI_Panel *varPanel= addPanel("Group", 1);
//addSpinnerToPanel(varPanel, "Val 1(interface)", 2, &testVar, 1);
// You could also pass a reference to a variable from the scene class, if public
//addSpinnerToPanel(varPanel, "Val 2(scene)", 2, &(((LightingScene*) scene)->sceneVar), 2);
//addColumn ();
GLUI_Panel *varLuz= addPanel("Luzes", 2);
addCheckboxToPanel(varLuz, "Luz 1",&((LightingScene *) scene)->state1,NULL);
addCheckboxToPanel(varLuz, "Luz 2",&((LightingScene *) scene)->state2,NULL);
addCheckboxToPanel(varLuz, "Luz 3",&((LightingScene *) scene)->state3,NULL);
addCheckboxToPanel(varLuz, "Luz 4",&((LightingScene *) scene)->state4,NULL);
addColumn ();
GLUI_Panel *varClock= addPanel("Relogio", 3);
addStaticText("Relógio");
addButton ("Pause/Start",1);
addColumn ();
GLUI_Panel *vartext= addPanel("Texturas",4);
GLUI_Listbox *textvar =addListboxToPanel(vartext,"Texturas",&((LightingScene *) scene)->statetext,NULL);
textvar->add_item (1, "Default");
textvar->add_item (2, "Sky");
textvar->add_item (3, "Space");
textvar->set_int_val (3);
addColumn();
GLUI_Panel *varwire= addPanel("Wireframe",5);
GLUI_RadioGroup *group=addRadioGroupToPanel(varwire,&((LightingScene *) scene)->wire);
addRadioButtonToGroup(group,"Normal");
addRadioButtonToGroup(group,"Wireframe");
addColumn();
}
CodeEdit::CodeEdit(QWidget *parent): QObject(parent), QCodeEdit(parent)
{
static QFormatFactory *ff;
static QLanguageFactory *lang;
static bool doit = true;
if (doit)
{
doit = false;
ff = new QFormatFactory("qxs/formats.qxf"); //Memory leak, ff se nikdy nedealokuje
QDocument::setFormatFactory(ff);
QLineMarksInfoCenter::instance()->loadMarkTypes("qxs/marks.qxm");
lang = new QLanguageFactory(ff); //Memory leak
lang->addDefinitionPath("qxs");
}
l = lang;
addPanel(new QLineMarkPanel, QCodeEdit::West);
addPanel(new QLineNumberPanel, QCodeEdit::West);
addPanel(new QFoldPanel, QCodeEdit::West);
addPanel(new QStatusPanel, QCodeEdit::South);
addPanel(new QSearchReplacePanel, QCodeEdit::South);
lang->setLanguage(editor(), QString("x.cpp"));
editor()->document()->setFont(QFont("Courier New", 10));
}
void GameInterface::initGUI()
{
int* option= &((XMLScene*) scene)->option;
GLUI_Panel* viewPanel= addPanel("View Points",1);
viewPanel->set_alignment(1);
GLUI_RadioGroup* group = addRadioGroupToPanel(viewPanel,&((XMLScene*) scene)->viewPoint,16);
addRadioButtonToGroup(group,"Lateral");
addRadioButtonToGroup(group,"Upper");
GLUI_Panel *gameModePanel = addPanel("Game", 1);
gameModePanel->set_alignment(0);
GLUI_Listbox* themeListBox =addListboxToPanel(gameModePanel,"Theme: ",option,8);
themeListBox->add_item (0, "Classic");
themeListBox->add_item (1, "Minecraft");
themeListBox->add_item (2, "Dragon Ball");
GLUI_Button* undo = addButtonToPanel(gameModePanel,"Undo",12);
addColumnToPanel(gameModePanel);
GLUI_Listbox* gameModeListbox=addListboxToPanel(gameModePanel,"Game Mode", &((XMLScene*) scene)->data->newGameMode,9);
gameModeListbox->add_item(1,"PVP");
gameModeListbox->add_item(2,"Player vs PC");
gameModeListbox->add_item(3,"PC vs PC");
GLUI_Button* redo = addButtonToPanel(gameModePanel,"Redo",13);
addColumnToPanel(gameModePanel);
GLUI_Panel* difficultiesPanel=addPanelToPanel(gameModePanel,"Difficulties",1);
difficultiesPanel->set_alignment(0);
GLUI_Listbox* difficulty1Listbox=addListboxToPanel(difficultiesPanel,"Computer 1", &((XMLScene*) scene)->data->newDifficulties[0],10);
difficulty1Listbox->add_item(1,"Normal");
difficulty1Listbox->add_item(2,"Hard");
GLUI_Button* restart = addButtonToPanel(gameModePanel,"Restart",14);
GLUI_Listbox* difficulty2Listbox=addListboxToPanel(difficultiesPanel,"Computer 2", &((XMLScene*) scene)->data->newDifficulties[1],11);
difficulty2Listbox->add_item(1,"Normal");
difficulty2Listbox->add_item(2,"Hard");
GLUI_Button* gameMovie = addButtonToPanel(gameModePanel,"Game Movie",15);
}
void Interface::initGUI()
{
Scene * scene = ((Scene *)this->scene);
std::vector<Light *> sceneLights = scene->getLights();
lightsState = new int[sceneLights.size()];
GLUI_Panel * panelLights = addPanel("Lights: ", 1);
int * lightvalue;
unsigned i = 0;
for(std::vector<Light *>::iterator it = sceneLights.begin(); it != sceneLights.end() ;it++,i++){
lights.push_back(*it);
lightsState[i] = ((*it)->isEnabled() ? 1 : 0);
addCheckboxToPanel (panelLights,(char *)((*it)->getIdTitle()).c_str(),&lightsState[i], i + LIGHTS_BASE_ID);
}
addColumn();
activeCameraPosition = scene->getActiveCameraPosition();
GLUI_Panel * cameraPanel = addPanel("Cameras: ", 1);
GLUI_RadioGroup * rgCameras = addRadioGroupToPanel(cameraPanel,&activeCameraPosition, CAMERAS_ID);
std::vector<Camera *> cameras = scene->getCameras();
unsigned size = i + cameras.size();
std::vector<Camera *>::iterator it = cameras.begin();
for(; it != cameras.end() ;it++){
addRadioButtonToGroup (rgCameras, (char *)(*it)->getTitle().c_str());
}
addColumn();
drawingMode = scene->getDrawingMode();
GLUI_Panel * drawingModePanel = addPanel("Drawing mode: ", 1);
GLUI_RadioGroup * rgDrawingMode = addRadioGroupToPanel(drawingModePanel,&drawingMode, DRAWINGMODE_ID);
addRadioButtonToGroup (rgDrawingMode, "Fill");
addRadioButtonToGroup (rgDrawingMode, "Line");
addRadioButtonToGroup (rgDrawingMode, "Point");
addColumn();
shaddingMode = scene->getShaddingMode();
GLUI_Panel * shaddingModePanel = addPanel("Shadding mode: ", 1);
GLUI_RadioGroup * rgShaddingMode = addRadioGroupToPanel(shaddingModePanel,&shaddingMode, SHADDINGMODE_ID);
addRadioButtonToGroup (rgShaddingMode, "Flat");
addRadioButtonToGroup (rgShaddingMode, "Gouraud");
addColumn();
GLUI_Panel * axisModePanel = addPanel("Axis: ", 1);
GLUI_RadioGroup * rgAxisMode = addRadioGroupToPanel(axisModePanel,&scene->showAxis, SHOWAXIS_ID);
addRadioButtonToGroup (rgAxisMode, "Show");
addRadioButtonToGroup (rgAxisMode, "Hide");
}
void CInputDocView::populatePanels()
{
int iSelectedTab = m_tabCtrl.GetCurSel();
removePanels();
CInputDoc* pDoc = (CInputDoc*) GetDocument();
// add the base file (which will be:
// source file for a parsing operation
// ana or ptext for a transfer or synthesis operation
//CResultStream* pBaseStream = pDoc->getBaseStream();
#ifndef rde270
// the first panel (i.e. the file we're processing), should be synchronously streamed in
// (the meaning of the 3rd parameter), since it has to be closed (finished loading into
// the control) by the time we try to process it.
addPanel(m_pBaseStream, kBasePanelID+0, true);
#else
addPanel(m_pBaseStream, kBasePanelID+0);
#endif
//delete pBaseStream;
// add the various result panels
CProcessStatus* pResults = pDoc->getProcessResults();
if(pResults)
{
CPrefsInputDocDisplay* pPrefs = pDoc->getDisplayPrefs();
int iPanelCount=1; // one for the input file
for (int i =0; i< pResults->m_pResultStreams.GetSize(); i++)
{
CResultStreamDescriptor* pD =pResults->m_pResultStreams[i]->getDescriptor() ;
if( pPrefs->getShowPanel(pD))
{
iPanelCount++;
addPanel(pResults->m_pResultStreams[i], kBasePanelID+i+1/*id 0 is the basestream */);
}
}
// try to reselect the tab the user had before
// this is simplistic, and could be redone to store the descriptor
// they had chosen and reselect that.
if(iPanelCount > iSelectedTab) // iSelectedTab is zero-based
{
m_tabCtrl.SetCurSel(iSelectedTab);
tabSelected(iSelectedTab); // don't know why this isn't triggered
}
else
{
m_tabCtrl.SetCurSel(0); // should always at least be the source panel
tabSelected(0); // don't know why this isn't triggered
}
}
}
void ramControlPanel::setup(bool usePresetScenes)
{
addPanel(presetTab);
addPanel(preferencesTab);
mSceneTabs.addSpacer();
presetTab.setup(usePresetScenes);
ofAddListener(ofEvents().update, this, &ramControlPanel::update);
ofAddListener(mSceneTabs.newGUIEvent, this, &ramControlPanel::guiEvent);
}
void TPinterface::initGUI()
{
GLUI_Panel *lights= addPanel("Luzes", 1);
addCheckboxToPanel(lights,"Light0", NULL,100)->set_int_val(1);
addCheckboxToPanel(lights,"Light1", NULL,101)->set_int_val(1);
addCheckboxToPanel(lights,"Light2", NULL,102)->set_int_val(1);
addCheckboxToPanel(lights,"Light3", NULL,103)->set_int_val(1);
GLUI_Panel *clock= addPanel("Clock", 1);
clockbt=addButtonToPanel(clock,"Stop",104);
}
void TPinterface::initGUI()
{
GLUI_Panel *lightPanel= addPanel("Lights",1);
for(unsigned int i=0;i<((LightingScene*) scene)->lightState.size();i++){
char name[30]="";
std::string s = ((LightingScene*) scene)->lights[i]->getID();
sprintf(name, "%s", s.c_str());
addCheckboxToPanel(lightPanel,name,&(((LightingScene*) scene)->lightState[i]),0);
}
addColumn();
GLUI_Panel *cameraPanel= addPanel("Cameras",1);
if(((LightingScene*) scene)->cameras.size()<5){
GLUI_RadioGroup *radioCameras=addRadioGroupToPanel(cameraPanel,&((LightingScene*) scene)->camera,1);
for(unsigned int i=0;i<((LightingScene*) scene)->cameras.size();i++){
char name[30]="";
std::string s =((LightingScene*) scene)->cameras[i]->getID();
sprintf(name, "%s", s.c_str());
addRadioButtonToGroup(radioCameras,name);
}
}
else{
GLUI_Listbox *listbox = addListboxToPanel(cameraPanel,"Cameras",&((LightingScene*) scene)->camera,2);
for(unsigned int i=0;i<2;i++){
char name[30]="";
std::string s =((LightingScene*) scene)->cameras[i]->getID();
sprintf(name, "%s", s.c_str());
listbox->add_item(i,name);
((LightingScene*) scene)->camera= listbox->get_int_val();
}
}
addColumn();
GLUI_Panel *drawmodePanel= addPanel("Drawmode",1);
GLUI_RadioGroup *radioDrawmode=addRadioGroupToPanel(drawmodePanel,&((LightingScene*) scene)->drawmode,3);
addRadioButtonToGroup(radioDrawmode,"Point");
addRadioButtonToGroup(radioDrawmode,"Line");
addRadioButtonToGroup(radioDrawmode,"Fill");
addColumn();
GLUI_Panel *themesPanel= addPanel("Themes",1);
GLUI_Listbox *themeslistbox = addListboxToPanel(themesPanel,"Themes",&((LightingScene*) scene)->app,4);
themeslistbox->add_item(0, "classic");
themeslistbox->add_item(1, "mario");
themeslistbox->add_item(2, "dragon ball");
themeslistbox->add_item(3, "angry birds");
}
void GuiManager::setup( int fW, int fH )
{
frameWidth = fW;
frameHeight = fH;
Settings* settings = Settings::getInstance();
ofxAutoControlPanel::setup(250, 500);
addPanel("calcOpticalFlowFarneback");
addSlider("gridSize", 5, 2, 30, true);
addSlider("pyrScale", .5, 0, 1);
addSlider("levels", 4, 1, 8, true);
addSlider("winsize", 8, 4, 64, true);
addSlider("iterations", 2, 1, 8, true);
addSlider("polyN", 7, 5, 10, true);
addSlider("polySigma", 1.5, 1.1, 2);
addToggle("FARNEBACK_GAUSSIAN", true);
addPanel("calcOpticalFlowPyrLK");
addSlider("winSize", 32, 4, 64, true);
addSlider("maxLevel", 3, 0, 8, true);
addSlider("maxFeatures", 200, 1, 1000);
addSlider("qualityLevel", 0.01, 0.001, .02);
addSlider("minDistance", 4, 1, 16);
settings->quadWarpOriginal[0].set(0, 0);
settings->quadWarpOriginal[1].set(frameWidth, 0);
settings->quadWarpOriginal[2].set(frameWidth, frameHeight);
settings->quadWarpOriginal[3].set(0, frameHeight);
settings->quadWarpScaled[0].set(0, 0);
settings->quadWarpScaled[1].set(frameWidth, 0);
settings->quadWarpScaled[2].set(frameWidth, frameHeight);
settings->quadWarpScaled[3].set(0, frameHeight);
quadGui.setup("undist");
quadGui.width = frameWidth;
quadGui.height = frameHeight;
quadGui.disableAppEvents();
ofPoint quadSrc[4];
quadSrc[0].set(0, 0);
quadSrc[1].set(frameWidth, 0);
quadSrc[2].set(frameWidth, frameHeight);
quadSrc[3].set(0, frameHeight);
quadGui.setQuadPoints(quadSrc);
quadGui.bCameraView = true;
}
void ProcessPanel::doCreation()
{
/* create buttons */
m_buttons.resize(10);
m_panels.resize(10);
addPanel(tr("FilterPanel"), Filter, new FilterPanel());
addPanel(tr("FiltersPanel"), Filters, new FiltersPanel());
addPanel(tr("TransformPanel"), Transform, new TransformPanel(800, 600));
addPanel(tr("Point Operator Panel"), PointOperator,
new PointOperatorPanel());
addPanel(tr("Contrast Panel"), Contrast, new ContrastPanel());
/* create panels */
}
void TPinterface::initGUI() {
// Check CGFinterface.h and GLUI documentation for the types of controls available
GLUI_Panel *varPanel = addPanel("Lights", 1);
// You could also pass a reference to a variable from the scene class, if public
addCheckboxToPanel(varPanel, "light0", &on0, 0);
addCheckboxToPanel(varPanel, "light1", &on1, 1);
addCheckboxToPanel(varPanel, "light2", &on2, 2);
addCheckboxToPanel(varPanel, "light3", &on3, 3);
addCheckboxToPanel(varPanel, "light4", &on4, 4);
addButtonToPanel(varPanel, "Clock", 5);
GLUI_RadioGroup* wireframeGroup = addRadioGroupToPanel(varPanel,&radioStatus, 6);
addRadioButtonToGroup(wireframeGroup, "Textured");
addRadioButtonToGroup(wireframeGroup, "Wireframed");
GLUI_Listbox* listBox = addListboxToPanel(varPanel,"Textures",&listStatus, 7);
listBox->add_item(0, "Default");
listBox->add_item(1, "Earth");
}
void CtrlrManager::openPanelInternal(const ValueTree &panelTree)
{
if (panelTree.isValid())
{
addPanel(panelTree, true);
}
}
bool GUITabbedPanel::loadXMLSettings(XMLElement *element)
{
if(!element || element->getName() != "TabbedPanel")
{
LOG_PRINT("Need a TabbedPanel node in the xml file");
return false;
}
XMLElement *child = 0,
*subChild = 0;
D3DXFROMWINEVECTOR3 bordersColor = upperPanel->getBordersColor();
D3DXFROMWINEVECTOR4 bgColor = upperPanel->getBGColor();
int count = 0;
if(child = element->getChildByName("hScale"))
fontScales.y = child->getValuef();
if(child = element->getChildByName("wScale"))
fontScales.x = child->getValuef();
if(child = element->getChildByName("TabButtonsBordersColor"))
XMLElement::loadRX_GY_BZf(*child, tabButtonsBordersColor);
if(child = element->getChildByName("TabButtonsColor"))
XMLElement::loadRX_GY_BZf(*child, tabButtonsColor);
if(child = element->getChildByName("BordersColor"))
XMLElement::loadRX_GY_BZf(*child, bordersColor);
if(child = element->getChildByName("BGColor"))
XMLElement::loadRX_GY_BZ_AWf(*child, bgColor);
if(child = element->getChildByName("fontIndex"))
fontIndex = clampNS(child->getValuei(), 0, 50);
setFontScales(fontScales);
for(size_t i = 0; i < element->getChildrenCount(); i++)
{
if(!(child = element->getChild(i)))
continue;
const NSString &childName = child->getName();
if(childName == "Panel")
{
GUIPanel *panel = new GUIPanel();
if(!panel->loadXMLSettings(child) || !addPanel(panel))
deleteObject(panel);
continue;
}
}
mainPanel->setBordersColor(bordersColor);
mainPanel->setBGColor(bgColor);
return GUIRectangle::loadXMLSettings(element) && lowerPanel->getWidgets().size();
}
void kitchenFrame::fillPanels()
{
int pages = Notebook1->GetPageCount()-1;
for(int t = pages; t > 0; --t) //deleting unnecessary pages
{
Notebook1->RemovePage(t);
}
OrderPanels.Clear();
wxDateTime current = wxDateTime::Now();
mysqlpp::Query query = conn->query();
query << "SELECT `id`, `number` FROM `orders` WHERE `time` > '"<< wx2std(current.FormatISODate(), wxConvUI) <<"' AND `status` = 3";
mysqlpp::StoreQueryResult res = query.store();
if (res)
{
if(res.num_rows() != 0)
{
mysqlpp::Row row;
mysqlpp::StoreQueryResult::size_type i;
wxString panTitle;
wxArrayInt orderIds;
for (i = 0; i < res.num_rows(); ++i)
{
row = res[i];
if(i % 3 == 0 && i != 0)
{
addPanel(panTitle, orderIds);
panTitle.Clear();
orderIds.Clear();
panTitle << std2wx(std::string(row["number"]), wxConvUI);
orderIds.Add(int(row["id"]));
}
else
{
wxString delim;
if(i != 0) delim = _T(" - ");
panTitle << delim << std2wx(std::string(row["number"]), wxConvUI);
orderIds.Add(int(row["id"]));
}
}
addPanel(panTitle, orderIds);
}
}
}
void GraphSceneUI::initAnimationsPanel() {
char* text = new char[256];
strcpy(text, "Animations");
GLUI_Panel* animationsPanel = addPanel(text);
strcpy(text, "Restart");
addButtonToPanel(animationsPanel, text, ANIMATIONS_RESET_BUTTON);
}
bool ofxGui::buildFromXml(string file)
{
if(!mXmlDone)
return false;
if(!mGlobals->mXml.loadFile(file))
return false;
int numberOfTags = mGlobals->mXml.getNumTags("UI");
if(numberOfTags != 1)
return false;
mObjects.clear();
mXmlDone = false;
mGlobals->mXmlfile = file;
mGlobals->mXml.pushTag("UI", 0);
mIsActive = mGlobals->mXml.getValue("ISACTIVE", 0);
mDoUpdate = mGlobals->mXml.getValue("DOUPDATE", 0);
mGlobals->buildFromXml();
numberOfTags = mGlobals->mXml.getNumTags("OBJECT");
if(numberOfTags > 0)
{
for(int i = 0; i < numberOfTags; i++)
{
mGlobals->mXml.pushTag("OBJECT", i);
int id = mGlobals->mXml.getValue("ID", 0);
string type = mGlobals->mXml.getValue("TYPE", "");
string name = mGlobals->mXml.getValue("NAME", "");
int x = mGlobals->mXml.getValue("LEFT", 0);
int y = mGlobals->mXml.getValue("TOP", 0);
int border = mGlobals->mXml.getValue("BORDER", 0);
int spacing = mGlobals->mXml.getValue("SPACING", 0);
if(type == "PANEL")
{
ofxGuiPanel* panel = addPanel(id, name, x, y, border, spacing);
panel->buildFromXml();
}
mGlobals->mXml.popTag();
}
}
mGlobals->mXml.popTag();
mXmlDone = true;
return true;
}
void GraphSceneUI::initShadersPanel() {
char* text = new char[256];
strcpy(text, "Shaders");
GLUI_Panel* shadersPanel = addPanel(text);
strcpy(text, "Wind");
addSpinnerToPanel(shadersPanel, text, 2, &GraphScene::WIND, WIND_SPINNER);
}
void DemoInterface::initGUI()
{
// Check CGFinterface.h and GLUI documentation for the types of controls available
GLUI_Panel *varPanel= addPanel("Teapot Shader", 1);
addSpinnerToPanel(varPanel, "normScale", 2,NULL, 1);
addColumn();
varPanel= addPanel("Display List", 1);
addCheckboxToPanel(varPanel, "Use", &(((DemoScene*) scene)->myDLObj->usingDL), 2);
addColumn();
varPanel= addPanel("Animations", 1);
addButtonToPanel(varPanel, "Reset", 3);
addColumn();
addCheckbox( "Wireframe", &(((DemoScene*) scene)->wireframe), 4);
}
void TPinterface::initGUI()
{
pgraph = &(((LightingScene*) scene)->pgraph);
int* wire = &(((LightingScene*) scene)->wire);
int* wind = &(((LightingScene*) scene)->wind);
int * cam = &(((LightingScene*) scene)->activCam);
// Check CGFinterface.h and GLUI documentation for the types of controls available
GLUI_Panel *varPanel= addPanel("Settings:", 1);
GLUI_Panel *modepanel = addPanelToPanel(varPanel, "Mode", 1);
GLUI_RadioGroup* wireFrameGroup = addRadioGroupToPanel(modepanel,wire);
addRadioButtonToGroup(wireFrameGroup, "\tFill");
addRadioButtonToGroup(wireFrameGroup, "\tWire");
addRadioButtonToGroup(wireFrameGroup, "\tPoint");
addColumnToPanel(varPanel);
GLUI_Panel *cammodel = addPanelToPanel(varPanel, "Camera", 1);
GLUI_RadioGroup* camerasGroup = addRadioGroupToPanel(cammodel,cam);
for(int i = 0; i < cameras.size();i++)
{
addRadioButtonToGroup(camerasGroup, (char *)cameras[i].c_str());
}
addRadioButtonToGroup(camerasGroup, "Free Camera");
addColumnToPanel(varPanel);
GLUI_Panel *lightspanel = addPanelToPanel(varPanel, "Lights", 1);
for(int i = 0; i < pgraph->getLights().size();i++)
{
if (pgraph->getLights()[i].enabled)
addCheckboxToPanel(lightspanel,
(char*)pgraph->getLights()[i].id.c_str(), NULL, i)->set_int_val(
1);
else
addCheckboxToPanel(lightspanel,
(char*)pgraph->getLights()[i].id.c_str(), NULL, i)->set_int_val(
0);
}
addColumnToPanel(varPanel);
GLUI_Panel *windpanel = addPanelToPanel(varPanel, "Wind", 1);
GLUI_Spinner *spin= addSpinnerToPanel(windpanel,"wind",GLUI_SPINNER_INT,wind,11);
spin->set_int_limits(0,11,GLUI_LIMIT_WRAP);
}
void CtrlrManager::restoreState (const ValueTree &savedTree)
{
if (savedTree.isValid())
{
ctrlrManagerRestoring = true;
restoreProperties (savedTree, managerTree);
if (owner->getOverrides().isValid())
{
for (int i=0; i<owner->getOverrides().getNumProperties(); i++)
{
setProperty (owner->getOverrides().getPropertyName(i), owner->getOverrides().getPropertyAsValue(owner->getOverrides().getPropertyName(i), 0));
}
}
managerTree.removeAllChildren (0);
managerTree.addChild (ctrlrMidiDeviceManager.getManagerTree(), -1, 0);
managerTree.addChild (ctrlrWindowManager.getManagerTree(), -1, 0);
if (savedTree.getChildWithName(Ids::midiDeviceManager).isValid())
{
ctrlrMidiDeviceManager.restoreState (savedTree.getChildWithName(Ids::midiDeviceManager));
}
if (savedTree.getChildWithName(Ids::uiWindowManager).isValid())
{
ctrlrWindowManager.restoreState (savedTree.getChildWithName(Ids::uiWindowManager));
}
if (getInstanceMode() != InstanceMulti && savedTree.hasType (Ids::panelState))
{
restoreInstanceState (savedTree);
return;
}
for (int i=0; i<savedTree.getNumChildren(); i++)
{
if (savedTree.getChild(i).hasType (Ids::panel))
{
addPanel (savedTree.getChild(i));
}
}
if (ctrlrEditor)
{
restoreEditorState();
}
ctrlrManagerRestoring = false;
}
}
void TPinterface::initGUI() {
// Check CGFinterface.h and GLUI documentation for the types of controls available
GLUI_Panel *varPanel1 = addPanel("LIGHTS", 1);
addColumn();
GLUI_Panel *varPanel2 = addPanel("CLOCK", 1);
addColumn();
GLUI_Panel *varPanel3 = addPanel("Robot Textures", 1);
addColumn();
GLUI_Panel *varPanel4 = addPanel("Robot Mode", 1);
//light0
addCheckboxToPanel(varPanel1, "light 0", &l0en, 1);
//light1
addCheckboxToPanel(varPanel1, "light 1", &l1en, 2);
//light2
addCheckboxToPanel(varPanel1, "light 2", &l2en, 3);
//light3
addCheckboxToPanel(varPanel1, "light 3", &l3en, 4);
/*
//Clock
addButtonToPanel(varPanel2, "Pause/Restart", 5);
//Textures listbox
GLUI_Listbox *listbox = addListboxToPanel(varPanel3, "Textures ", &robotText, 6);
listbox->add_item(0, "Basic");
listbox->add_item(1, "Serpentine");
listbox->add_item(2, "Aco");
listbox->add_item(3, "Robot");
//Texture and wireframe
GLUI_RadioGroup *rButton = addRadioGroupToPanel(varPanel4, &robotMode, 7);
addRadioButtonToGroup(rButton, "Textured");
addRadioButtonToGroup(rButton, "Wireframe");*/
}
RazorPanelApplication::RazorPanelApplication(int& argc, char** argv, const QString &configFile)
: RazorApplication(argc, argv)
{
if (configFile.isEmpty())
mSettings = new RazorSettings("panel", this);
else
mSettings = new RazorSettings(configFile, QSettings::IniFormat, this);
QStringList panels = mSettings->value("panels").toStringList();
Q_FOREACH(QString i, panels)
{
addPanel(i);
}
void GraphSceneUI::initShadingModePanel() {
char* text = new char[256];
strcpy(text, "Shading Mode");
GLUI_Panel* shadingModePanel = addPanel(text);
GLUI_RadioGroup* shadingModeGroup = addRadioGroupToPanel(shadingModePanel,
&shadingModeRadioGroupSelectedItemID, SHADING_MODE_RADIO_GROUP);
strcpy(text, "Flat");
addRadioButtonToGroup(shadingModeGroup, text);
strcpy(text, "Gouraud");
addRadioButtonToGroup(shadingModeGroup, text);
}
void GraphSceneUI::initLightsPanel() {
char* text = new char[256];
strcpy(text, "Lights");
GLUI_Panel* lightsPanel = addPanel(text);
vector<Light*>* lights = ((GraphScene*) scene)->getLights()->getLights();
for (unsigned int i = 0; i < lights->size(); i++) {
Light* light = (*lights)[i];
strcpy(text, light->getStrID().c_str());
addCheckboxToPanel(lightsPanel, text, light->getEnabled());
}
}
void GameInterface::initGUI()
{
int* option= &((XMLScene*) scene)->option;
/*
GLUI_Panel *varPanel1 = addPanel("Cameras", 1);
int* camera = &((XMLScene*) scene)->camera;
GLUI_Listbox *texturesListbox =addListboxToPanel(varPanel1,"Camera: ",camera,7);
unsigned int size=((XMLScene*) scene)->file->sceneCameras.size();
for(unsigned int i = 0;i<size;i++)
{
texturesListbox->add_item (i, ((XMLScene*) scene)->file->sceneCameras[i].first);
}
//addColumn();
GLUI_Panel *varPanel2 = addPanel("Draw Mode", 1);
varPanel2->set_alignment(0);
GLUI_RadioGroup* radioGroup = addRadioGroupToPanel(varPanel2,&((XMLScene*) scene)->drawmode,3);
addRadioButtonToGroup(radioGroup,"Fill");
addRadioButtonToGroup(radioGroup,"Line");
addRadioButtonToGroup(radioGroup,"Point");
addColumn();
*/
GLUI_Panel *gameModePanel = addPanel("Game", 1);
gameModePanel->set_alignment(0);
GLUI_Listbox* themeListBox =addListboxToPanel(gameModePanel,"Theme: ",option,8);
themeListBox->add_item (0, "Classic");
themeListBox->add_item (1, "Minecraft");
GLUI_Button* undo = addButtonToPanel(gameModePanel,"Undo",12);
addColumnToPanel(gameModePanel);
GLUI_Listbox* gameModeListbox=addListboxToPanel(gameModePanel,"Game Mode", &((XMLScene*) scene)->data->gameMode,9);
gameModeListbox->add_item(1,"PVP");
gameModeListbox->add_item(2,"Player vs PC");
gameModeListbox->add_item(3,"PC vs PC");
GLUI_Button* redo = addButtonToPanel(gameModePanel,"Redo",13);
addColumnToPanel(gameModePanel);
GLUI_Panel* difficultiesPanel=addPanelToPanel(gameModePanel,"Difficulties",1);;
difficultiesPanel->set_alignment(0);
GLUI_Listbox* difficulty1Listbox=addListboxToPanel(difficultiesPanel,"Computer 1", &((XMLScene*) scene)->data->difficulties[0],10);
difficulty1Listbox->add_item(1,"Normal");
difficulty1Listbox->add_item(2,"Hard");
GLUI_Button* restart = addButtonToPanel(gameModePanel,"Restart",14);
GLUI_Listbox* difficulty2Listbox=addListboxToPanel(difficultiesPanel,"Computer 2", &((XMLScene*) scene)->data->difficulties[1],11);
difficulty2Listbox->add_item(1,"Normal");
difficulty2Listbox->add_item(2,"Hard");
GLUI_Button* gameFilm = addButtonToPanel(gameModePanel,"Game Film",15);
}
void GraphSceneUI::initDrawingModePanel() {
char* text = new char[256];
strcpy(text, "Drawing Mode");
GLUI_Panel* drawingModePanel = addPanel(text);
GLUI_RadioGroup* drawingModeGroup = addRadioGroupToPanel(drawingModePanel,
&drawingModeRadioGroupSelectedItemID, DRAWING_MODE_RADIO_GROUP);
strcpy(text, "Point");
addRadioButtonToGroup(drawingModeGroup, text);
strcpy(text, "Line");
addRadioButtonToGroup(drawingModeGroup, text);
strcpy(text, "Fill");
addRadioButtonToGroup(drawingModeGroup, text);
}
CtrlrPanel *CtrlrManager::addPanel(const ValueTree &savedState, const bool showUI)
{
CtrlrPanel *panel = new CtrlrPanel(*this, getUniquePanelName("Ctrlr Panel"), ctrlrPanels.size());
ctrlrPanels.add (panel);
panel->restoreState (savedState);
managerTree.addChild (panel->getPanelTree(), -1, 0);
if (showUI)
{
addPanel (panel->getEditor(true));
}
organizePanels();
return (panel);
}
void GraphSceneUI::initCamerasPanel() {
char* text = new char[256];
strcpy(text, "Cameras");
GLUI_Panel* camerasPanel = addPanel(text);
GLUI_RadioGroup* camerasGroup = addRadioGroupToPanel(camerasPanel,
&activeCameraRadioGroupSelectedItemID, ACTIVE_CAMERA_RADIO_GROUP);
map<string, Camera*>* cameras =
((GraphScene*) scene)->getCameras()->getCameras();
map<string, Camera*>::iterator it;
for (it = cameras->begin(); it != cameras->end(); it++) {
strcpy(text, it->second->getId().c_str());
addRadioButtonToGroup(camerasGroup, text);
}
}
void CtrlrManager::openPanelInternal(const File &fileToOpen)
{
setProperty(Ids::lastBrowsedPanelDir, fileToOpen.getParentDirectory().getFullPathName());
ValueTree panelTree;
if (fileToOpen.getFileExtension().startsWith(".b"))
{
panelTree = CtrlrPanel::openBinPanel(fileToOpen);
}
else
{
panelTree = CtrlrPanel::openXmlPanel(fileToOpen);
}
if (panelTree.isValid())
{
addPanel(panelTree, true);
}
}
//--------------------------------------------------------------
void MidiController::addPanel(ofxGuiGroup* panel){
for (int i = 0; i < panel->getNumControls(); i++) {
ofxBaseGui* control = panel->getControl(i);
bool isGroup = control->getParameter().type() == typeid(ofParameterGroup).name();
if(isGroup){
ofxGuiGroup& group = panel->getGroup(control->getName());
addPanel(&group); // recursion
}
else{
if(isMappeable(control->getParameter())){
// store control (avoid duplicate keys)
// TODO: we still can have duplicated names when the panels are nested
// eg: when we have subgroups of parameters
string uniqueName = ofToString(panels.size()) + "-" + control->getName();
controls[uniqueName] = control;
}
}
}
panels.push_back(panel);
}