PushButton* Menu::_addButton( int startPic, bool pushBtn, int yMul,
int id, bool haveSubmenu, int midPic,
const std::string& ident, const Rect& rect )
{
Point offset( 1, 32 );
int dy = 35;
MenuButton* ret = new MenuButton( this, Point( 0, 0 ), -1, -1, startPic, pushBtn );
ret->setID( id | ( haveSubmenu ? BuildMenu::subMenuCreateIdHigh : 0 ) );
Point temp = offset + Point( 0, dy * yMul );
if( _d->koeff != 1 )
{
temp.setX( ceil( temp.x() * _d->koeff) );
temp.setY( temp.y() * _d->koeff );
ret->setWidth( ceil( ret->width() * _d->koeff ) );
ret->setHeight( ceil( ret->height() * _d->koeff ) );
}
ret->setPosition( temp );
ret->setTooltipText( _( "##extm_"+ident+"_tlp##" ) );
ret->setSound( "extm_" + ident );
ret->setMidPicId( midPic );
if( rect.width() > 0 )
_setChildGeometry( ret, rect );
return ret;
}
void BubbleMenuButtonGeometry::updateGeometry()
{
MenuButton * button = dynamic_cast<MenuButton*>(_item);
if(!button)
{
return;
}
if(_geode->getNumDrawables())
{
osgText::Text * text = dynamic_cast<osgText::Text*>(_geode->getDrawable(
0));
if(text)
{
if(text->getText().createUTF8EncodedString() != button->getText())
{
text->setText(button->getText());
osg::BoundingBox bb = text->getBound();
_width = bb.xMax() - bb.xMin() + _iconHeight + _border;
text = dynamic_cast<osgText::Text*>(_geodeSelected->getDrawable(
0));
if(text)
{
text->setText(button->getText());
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Message map
//-----------------------------------------------------------------------------
void MenuBar::OnCursorEnteredMenuButton(int VPanel)
{
VPANEL menuButton = (VPANEL)VPanel;
// see if we had a menu open
for ( int i = 0; i < m_pMenuButtons.Count(); i++)
{
// one of our buttons was pressed.
if (m_pMenuButtons[i]->IsDepressed())
{
int oldbutton = i;
// now see if menuButton is one of ours.
for ( int j = 0; j < m_pMenuButtons.Count(); j++)
{
MenuButton *button = static_cast<MenuButton *>(ipanel()->GetPanel(menuButton, GetModuleName()));
// it is one of ours.
if ( button == m_pMenuButtons[j])
{
// if its a different button than the one we already had open,
if (j != oldbutton)
{
// close this menu and open the one we just entered
m_pMenuButtons[oldbutton]->DoClick();
button->DoClick();
}
}
}
}
}
}
void Screen_Base::CreateMenuItems(int numitems, MenuItemDefinition* menuitems)
{
for( int i=0; i<numitems; i++ )
{
switch( menuitems[i].type )
{
case MIT_Sprite:
{
MenuSprite* pMenuSprite = CreateMenuSprite( i );
pMenuSprite->SetName( menuitems[i].name );
MySprite* pSprite = g_pGame->m_pResources->m_pSprites[menuitems[i].spriteindex];
pMenuSprite->SetSprites( pSprite, pSprite );
pMenuSprite->m_BGColor = menuitems[i].BGColor;
}
break;
case MIT_Text:
{
MenuText* pText = CreateMenuText( i, menuitems[i].maxletters );
pText->SetName( menuitems[i].name );
pText->m_pFont = menuitems[i].font;
if( menuitems[i].string1 )
pText->SetString( menuitems[i].string1 );
}
break;
case MIT_Button:
{
MenuButton* pButton = CreateMenuButton( i, menuitems[i].maxletters );
pButton->SetName( menuitems[i].name );
MySprite* pSprite = g_pGame->m_pResources->m_pSprites[menuitems[i].spriteindex];
pButton->SetSprites( pSprite, pSprite, pSprite, 0, pSprite );
pButton->m_BGColor = menuitems[i].BGColor;
pButton->m_pFont = menuitems[i].font;
if( menuitems[i].string1 || menuitems[i].string2 || menuitems[i].string3 )
pButton->SetString( menuitems[i].string1, menuitems[i].string2, menuitems[i].string3 );
pButton->m_ButtonAction = menuitems[i].buttonaction;
}
break;
case MIT_Base:
case MIT_InputBox:
case MIT_ScrollingText:
case MIT_ScrollBox:
case MIT_CheckBox:
case MIT_NumMenuItemTypes:
break;
}
}
}
int main(int argc, char **argv) {
AppWindow* win = new AppWindow(215, 144);
win->begin();
MenuBar* o = new MenuBar(0, 0, 215, 25);
o->menu(menu_);
Fl_Image* img1 = (Fl_Image*)IconLoader::get("document-new", ICON_SIZE_TINY);
Fl_Image* img2 = (Fl_Image*)IconLoader::get("document-save", ICON_SIZE_SMALL);
Fl_Image* img3 = (Fl_Image*)IconLoader::get("system-log-out", ICON_SIZE_TINY);
menu_[1].image(img1);
menu_[1].tooltip("Tooltip for First Item");
menu_[2].image(img2);
menu_[8].image(img3);
MenuButton* b = new MenuButton(65, 80, 90, 25, "menu");
b->menu(menu_menu);
Fl_Image* img4 = (Fl_Image*)IconLoader::get("folder", ICON_SIZE_TINY);
menu_menu[0].image(img4);
menu_menu[0].tooltip("This should be some folder");
win->end();
win->show(argc, argv);
return Fl::run();
}
void GameOverState::setCallbacks(const std::vector<Callback>& callbacks) {
for (int i = 0; i < m_gameObjects.size(); i++) {
if (dynamic_cast<MenuButton*>(m_gameObjects[i])) {
MenuButton* pButton = dynamic_cast<MenuButton*>(m_gameObjects[i]);
pButton->setCallback(callbacks[pButton->getCallbackID()]);
}
}
}
TileSetEditor::TileSetEditor(EditorNode *p_editor) {
Panel *panel = memnew(Panel);
panel->set_area_as_parent_rect();
add_child(panel);
MenuButton *options = memnew(MenuButton);
panel->add_child(options);
options->set_position(Point2(1, 1));
options->set_text("Theme");
options->get_popup()->add_item(TTR("Add Item"), MENU_OPTION_ADD_ITEM);
options->get_popup()->add_item(TTR("Remove Item"), MENU_OPTION_REMOVE_ITEM);
options->get_popup()->add_separator();
options->get_popup()->add_item(TTR("Create from Scene"), MENU_OPTION_CREATE_FROM_SCENE);
options->get_popup()->add_item(TTR("Merge from Scene"), MENU_OPTION_MERGE_FROM_SCENE);
options->get_popup()->connect("id_pressed", this, "_menu_cbk");
editor = p_editor;
cd = memnew(ConfirmationDialog);
add_child(cd);
cd->get_ok()->connect("pressed", this, "_menu_confirm");
nd = memnew(EditorNameDialog);
add_child(nd);
nd->set_hide_on_ok(true);
nd->get_line_edit()->set_margin(MARGIN_TOP, 28);
nd->connect("name_confirmed", this, "_name_dialog_confirm");
err_dialog = memnew(AcceptDialog);
add_child(err_dialog);
err_dialog->set_title(TTR("Error"));
}
MenuButton* MenuButton::create(const char *normalImage, const char *selectedImage, cocos2d::CCObject *target, SEL_MenuHandler selector, const char* textOnButton, float fontSize){
MenuButton * button = new MenuButton();
if (button && button->init(normalImage,selectedImage,target,selector,textOnButton, fontSize)) {
button->autorelease();
return button;
}
CC_SAFE_DELETE(button);
return NULL;
}
void PlayState::setCallbacks()
{
for (int i = 0; i < m_gObjects.size(); i++)
{
if (dynamic_cast<MenuButton*>(m_gObjects[i]))
{
MenuButton* pButton = dynamic_cast<MenuButton*>(m_gObjects[i]);
pButton->setCallbacks(m_callbacksID[pButton->getCallbackID()]);
}
}
}
void MenuState::setCallbacks(const std::vector<Callback>&callbacks){
// go through the game objects
for (int i = 0; i < m_gameObjectsMenuState.size(); i++)
{
// if they are of type MenuButton then assign a callback based on the id passed in from the file
if (dynamic_cast<MenuButton*>(m_gameObjectsMenuState[i]))
{
MenuButton* pButton = dynamic_cast<MenuButton*>(m_gameObjectsMenuState[i]);
pButton->setCallback(callbacks[pButton->getCallbackID()]);
}
}
}
bool OsgMovie::init()
{
std::cerr << "OsgMovie init\n";
//osg::setNotifyLevel( osg::INFO );
_loadMenu = new SubMenu("OsgMovie");
_loadMenu->setCallback(this);
MenuSystem::instance()->addMenuItem(_loadMenu);
string configBase = "Plugin.OsgMovie";
std::vector<std::string> list;
ConfigManager::getChildren(configBase, list);
for(int i = 0; i < list.size(); i++)
{
MenuButton * button = new MenuButton(list[i]);
button->setCallback(this);
_loadMenu->addItem(button);
_loadButtons.push_back(button);
}
configPath = ConfigManager::getEntry("Plugin.OsgMovie.ConfigDir");
ifstream cfile;
cfile.open((configPath + "/Init.cfg").c_str(), ios::in);
if(!cfile.fail())
{
string line;
while(!cfile.eof())
{
Matrix m;
char name[150];
int stereo;
cfile >> name;
if(cfile.eof())
{
break;
}
cfile >> stereo;
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 4; j++)
{
cfile >> m(i, j);
}
}
_configMap[string(name)] = std::pair<int, osg::Matrix> (stereo,m);
}
}
void PopUpMenu::add_check_item(BitmapID p_icon, String p_text, const Method1<bool>& p_method, bool p_checked) {
MenuButton *mb = vbc->add( GUI_NEW(MenuButton(p_text,p_icon,true)), 0 );
mb->set_id( id_count++ );
mb->toggled_signal.connect( p_method );
mb->set_checked(p_checked);
vbc->adjust_minimum_size();
mb->menubutton_toggled_signal.connect( this, &PopUpMenu::menu_button_toggled );
}
void PopUpMenu::add_check_item(String p_text, bool p_checked,void *p_userdata) {
MenuButton *mb = vbc->add( GUI_NEW(MenuButton(p_text,-1,true)), 0 );
mb->set_id( id_count++ );
mb->set_userdata( p_userdata );
mb->set_checked(p_checked);
vbc->adjust_minimum_size();
mb->menubutton_toggled_signal.connect( this, &PopUpMenu::menu_button_toggled );
}
void PopUpMenu::add_item(String p_text, const Method& p_method,int p_shortcut,bool p_shortcut_active) {
MenuButton *mb = vbc->add( GUI_NEW(MenuButton(p_text)), 0 );
mb->set_id( id_count++ );
mb->pressed_signal.connect( p_method );
mb->set_shurtcut( p_shortcut, p_shortcut_active );
vbc->adjust_minimum_size();
mb->menubutton_pressed_signal.connect( this, &PopUpMenu::menu_button_selected );
}
void PopUpMenu::add_item(String p_text, int p_ID, void *p_userdata,int p_shortcut,bool p_shortcut_active) {
MenuButton *mb = vbc->add( GUI_NEW(MenuButton(p_text)), 0 );
mb->set_id( p_ID );
mb->set_userdata( p_userdata );
mb->set_shurtcut( p_shortcut, p_shortcut_active );
id_count=p_ID+1;
vbc->adjust_minimum_size();
mb->menubutton_pressed_signal.connect( this, &PopUpMenu::menu_button_selected );
}
void OrionCallbacks::saveLoadCancelFn(DialogView *view, MenuObject *item) {
OrionMenuView *vw = (OrionMenuView *) view;
if (view->_selectedSlot != -1) {
// Pressed cancel with a save selected, so revert back to no selection
// Re-enable all the other slots
for (int index = 0; index < SL_NUM_VISIBLE_SLOTS; ++index) {
if (index != view->_selectedSlot) {
MenuSaveLoadText *currentItem = (MenuSaveLoadText *) view->getItem(SLTAG_SLOTS_START + index);
currentItem->setState(OS_NORMAL);
}
}
// Show the previously hidden slot again
MenuSaveLoadText *slot = (MenuSaveLoadText *) view->getItem(SLTAG_SLOTS_START + view->_selectedSlot);
slot->setVisible(true);
slot->setState(OS_NORMAL);
// Remove the text selection
MenuTextField *textField = (MenuTextField *) view->getItem(SLTAG_TEXTFIELD);
delete textField;
vw->items().remove(textField);
// Set button enablement
MenuButton *btn = (MenuButton *) view->getItem(SLTAG_SAVELOAD);
btn->setState(OS_GREYED);
btn = (MenuButton *) view->getItem(SLTAG_CANCEL);
btn->setState(OS_NORMAL);
// Re-enable the slider
MenuVertSlider *slider = (MenuVertSlider *) view->getItem(SLTAG_VSLIDER);
slider->setState(OS_NORMAL);
view->_selectedSlot = -1;
} else {
// Close the dialog
if (vw->_loadSaveFromHotkey)
// Since dialog was called from hotkey, return directly to the game
closeMenuFn(view, item);
else {
// Return to the game menu
view->vm()->loadMenu(GAME_MENU);
view->close();
}
}
}
bool ExtentMenu::onEvent(const NEvent& event)
{
if( event.EventType == sEventGui && event.gui.type == guiButtonClicked )
{
MenuButton* btn = safety_cast< MenuButton* >( event.gui.caller );
if( btn )
{
int picId = btn->midPicId() > 0 ? btn->midPicId() : ResourceMenu::emptyMidPicId;
_d->middleLabel->setPicture( Picture( ResourceGroup::menuMiddleIcons, picId ) );
}
}
return Menu::onEvent( event );
}
void PopUpMenu::add_check_item(BitmapID p_icon, String p_text, int p_ID, bool p_checked,void *p_userdata) {
MenuButton *mb = vbc->add( GUI_NEW(MenuButton(p_text,p_icon,true)), 0 );
mb->set_id( p_ID );
mb->set_userdata( p_userdata );
mb->set_checked(p_checked);
id_count=p_ID+1;
vbc->adjust_minimum_size();
mb->menubutton_toggled_signal.connect( this, &PopUpMenu::menu_button_toggled );
}
void BoardMenuButtonGeometry::createGeometry(MenuItem * item)
{
_node = new osg::MatrixTransform();
_geode = new osg::Geode();
_geodeSelected = new osg::Geode();
_intersect = new osg::Geode();
_node->addChild(_intersect);
_node->addChild(_geode);
_item = item;
MenuButton * mb = dynamic_cast<MenuButton*>(item);
osgText::Text * textNode = makeText(mb->getText(),_textSize,
osg::Vec3(_iconHeight + _border,-2,-_iconHeight / 2.0),_textColor);
/*osgText::Text * textNode = new osgText::Text();
textNode->setCharacterSize(_textSize);
textNode->setAlignment(osgText::Text::LEFT_CENTER);
textNode->setPosition(osg::Vec3(_iconHeight + _border, -2, -_iconHeight
/ 2.0));
textNode->setColor(_textColor);
textNode->setBackdropColor(osg::Vec4(0, 0, 0, 0));
textNode->setAxisAlignment(osgText::Text::XZ_PLANE);
textNode->setText(mb->getText());*/
osg::BoundingBox bb = textNode->getBound();
_width = bb.xMax() - bb.xMin() + _iconHeight + _border;
//mg->height = bb.zMax() - bb.zMin();
_height = _iconHeight;
_geode->addDrawable(textNode);
textNode = makeText(mb->getText(),_textSize,
osg::Vec3(_iconHeight + _border,-2,-_iconHeight / 2.0),
_textColorSelected);
/*textNode = new osgText::Text();
textNode->setCharacterSize(_textSize);
textNode->setAlignment(osgText::Text::LEFT_CENTER);
textNode->setPosition(osg::Vec3(_iconHeight + _border, -2, -_iconHeight
/ 2.0));
textNode->setColor(_textColorSelected);
textNode->setBackdropColor(osg::Vec4(0, 0, 0, 0));
textNode->setAxisAlignment(osgText::Text::XZ_PLANE);
textNode->setText(mb->getText());*/
_geodeSelected->addDrawable(textNode);
}
void State_Menu::Update()
{
if (CurrentMenu)
{
MenuButton *clickedButton = nullptr;
for (auto &button : CurrentMenu->buttons)
{
button->Update();
if (button->WasClicked()) clickedButton = button;
}
if (clickedButton)
{
clickedButton->SetWasClickedToFalse();
clickedButton->UseFunction();
}
}
}
bool MainMenuLayer::init()
{
bool ret = false;
MenuButton * button;
do
{
CC_BREAK_IF( ! PARENT( MainMenuLayer )::init() );
BackGroundLayer * layer_bg = BackGroundLayer::create();
CC_BREAK_IF( ! layer_bg );
this->addChild( layer_bg );
auto menu = CCMenu::create();
CC_BREAK_IF( ! menu );
auto size = CCDirector::sharedDirector()->getWinSize();
menu->setAnchorPoint( ccp( 0.5, 0.5 ) );
menu->setPosition( ccp( size.width / 2, size.height / 2 ) );
addChild( menu );
button = MenuButton::create( "New game", this, menu_selector( MainMenuLayer::menuNewGameCallback ) );
CC_BREAK_IF( button == NULL );
button->setPositionY( 80.0 );
menu->addChild( button );
button = MenuButton::create( "Settings", this, menu_selector( MainMenuLayer::menuSettingsCallback ) );
CC_BREAK_IF( button == NULL );
button->setPositionY( 0.0 );
menu->addChild( button );
button = MenuButton::create( "Exit", this, menu_selector( MainMenuLayer::menuExitCallback ) );
CC_BREAK_IF( button == NULL );
button->setPositionY( -80.0 );
menu->addChild( button );
ret = true;
} while ( false );
return ret;
}
//-----------------------------------------------------------------------------
// Purpose: Handle key presses, Activate shortcuts
//-----------------------------------------------------------------------------
void MenuBar::OnKeyCodeTyped(KeyCode code)
{
switch(code)
{
case KEY_RIGHT:
{
// iterate the menu items looking for one that is open
// if we find one open, open the one to the right
for (int i = 0; i < m_pMenuButtons.Count() - 1; i++)
{
MenuButton *panel = m_pMenuButtons[i];
if (panel->IsDepressed())
{
m_pMenuButtons[i]->DoClick();
m_pMenuButtons[i+1]->DoClick();
break;
}
}
break;
}
case KEY_LEFT:
{
// iterate the menu items looking for one that is open
// if we find one open, open the one to the left
for (int i = 1; i < m_pMenuButtons.Count(); i++)
{
MenuButton *panel = m_pMenuButtons[i];
if (panel->IsDepressed())
{
m_pMenuButtons[i]->DoClick();
m_pMenuButtons[i-1]->DoClick();
break;
}
}
break;
}
default:
{
break;
}
}
// don't chain back
}
void OrionCallbacks::saveLoadSlotFn(DialogView *view, MenuObject *item) {
OrionMenuView *vw = (OrionMenuView *) view;
MenuSaveLoadText *button = (MenuSaveLoadText *) item;
view->_selectedSlot = button->getIndex();
view->_deleteSaveDesc = true;
// Disable all the slots except the selected one
for (int index = 0; index < SL_NUM_VISIBLE_SLOTS; ++index) {
MenuSaveLoadText *currentItem = (MenuSaveLoadText *) view->getItem(SLTAG_SLOTS_START + index);
if (currentItem->getIndex() != button->getIndex()) {
currentItem->setState(OS_GREYED);
}
}
// Get a copy of the slot bounds
Common::Rect slotBounds = button->getBounds();
if (view->getMenuType() == SAVE_MENU) {
// Add in a text field for entry of the savegame name
vw->items().push_back(new MenuTextField(view, SLTAG_TEXTFIELD,
slotBounds.left, slotBounds.top, slotBounds.width(), slotBounds.height(), false,
saveLoadSaveFn, (button->getText() == EmptySaveString) ? NULL : button->getText(),
button->getIndex() + 1));
} else {
vw->items().push_back(new MenuTextField(view, SLTAG_TEXTFIELD,
slotBounds.left, slotBounds.top, slotBounds.width(), slotBounds.height(), true,
saveLoadLoadFn, button->getText(), button->getIndex() + 1));
}
// Hide the existing slot
button->setVisible(false);
// Disable the slider
MenuVertSlider *slider = (MenuVertSlider *) view->getItem(SLTAG_VSLIDER);
slider->setState(OS_GREYED);
// Enable the save/load button
MenuButton *btn = (MenuButton *) view->getItem(SLTAG_SAVELOAD);
btn->setState(OS_NORMAL);
}
bool ImageSequence::init()
{
_isMenu = new SubMenu("ImageSequence");
PluginHelper::addRootMenuItem(_isMenu);
_loadMenu = new SubMenu("Load");
_isMenu->addItem(_loadMenu);
std::vector<std::string> tags;
ConfigManager::getChildren("Plugin.ImageSequence.Files",tags);
for(int i = 0; i < tags.size(); ++i)
{
MenuButton * button = new MenuButton(tags[i]);
button->setCallback(this);
_loadMenu->addItem(button);
_loadButtons.push_back(button);
SequenceSet * ss = new SequenceSet;
ss->path = ConfigManager::getEntry("path",std::string("Plugin.ImageSequence.Files.") + tags[i],"");
ss->start = ConfigManager::getInt("start",std::string("Plugin.ImageSequence.Files.") + tags[i],0);
ss->frames = ConfigManager::getInt("frames",std::string("Plugin.ImageSequence.Files.") + tags[i],0);
_sets.push_back(ss);
}
int index = ConfigManager::getInt("value","Plugin.ImageSequence.AutoStart",-1);
if(index >=0 && index < _sets.size())
{
_autoStart = true;
_autoStartIndex = index;
}
else
{
_autoStart = false;
}
_removeButton = new MenuButton("Remove");
_removeButton->setCallback(this);
_isMenu->addItem(_removeButton);
return true;
}
void TextInputPanel::addCustomRow(std::vector<std::string> & row)
{
MenuItemGroup * mig = new MenuItemGroup(MenuItemGroup::ROW_LAYOUT);
for(int i = 0; i < row.size(); ++i)
{
MenuButton * mb = new MenuButton(row[i],false);
mb->setCallback(this);
mig->addItem(mb);
}
int pos = _rootMenu->getItemPosition(_rowGroup);
if(pos >= 0)
{
_rootMenu->addItem(mig,pos+1);
}
else
{
_rootMenu->addItem(mig);
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle key presses, Activate shortcuts
// Input : code -
//-----------------------------------------------------------------------------
void MenuBar::OnKeyTyped(wchar_t unichar)
{
if (unichar)
{
// iterate the menu items looking for one with the matching hotkey
for (int i = 0; i < m_pMenuButtons.Count(); i++)
{
MenuButton *panel = m_pMenuButtons[i];
if (panel->IsVisible())
{
Panel *hot = panel->HasHotkey(unichar);
if (hot)
{
// post a message to the menuitem telling it it's hotkey was pressed
PostMessage(hot, new KeyValues("Hotkey"));
return;
}
}
}
}
// don't chain back
}
MeshLibraryEditor::MeshLibraryEditor(EditorNode *p_editor) {
file = memnew( EditorFileDialog );
file->set_mode(EditorFileDialog::MODE_OPEN_FILE);
//not for now?
List<String> extensions;
ResourceLoader::get_recognized_extensions_for_type("PackedScene",&extensions);
file->clear_filters();
file->set_title("Import Scene");
for(int i=0;i<extensions.size();i++) {
file->add_filter("*."+extensions[i]+" ; "+extensions[i].to_upper());
}
add_child(file);
file->connect("file_selected",this,"_import_scene_cbk");
Panel *panel = memnew( Panel );
panel->set_area_as_parent_rect();
add_child(panel);
MenuButton * options = memnew( MenuButton );
panel->add_child(options);
options->set_pos(Point2(1,1));
options->set_text("Theme");
options->get_popup()->add_item("Add Item",MENU_OPTION_ADD_ITEM);
options->get_popup()->add_item("Remove Selected Item",MENU_OPTION_REMOVE_ITEM);
options->get_popup()->add_separator();
options->get_popup()->add_item("Import from Scene",MENU_OPTION_IMPORT_FROM_SCENE);
options->get_popup()->add_item("Update from Scene",MENU_OPTION_UPDATE_FROM_SCENE);
options->get_popup()->set_item_disabled(options->get_popup()->get_item_index(MENU_OPTION_UPDATE_FROM_SCENE),true);
options->get_popup()->connect("item_pressed", this,"_menu_cbk");
menu=options;
editor=p_editor;
cd = memnew(ConfirmationDialog);
add_child(cd);
cd->get_ok()->connect("pressed", this,"_menu_confirm");
}
TileSetEditor::TileSetEditor(EditorNode *p_editor) {
Panel *panel = memnew( Panel );
panel->set_area_as_parent_rect();
add_child(panel);
MenuButton * options = memnew( MenuButton );
panel->add_child(options);
options->set_pos(Point2(1,1));
options->set_text("Theme");
options->get_popup()->add_item("Add Item",MENU_OPTION_ADD_ITEM);
options->get_popup()->add_item("Remove Selected Item",MENU_OPTION_REMOVE_ITEM);
options->get_popup()->add_separator();
options->get_popup()->add_item("Create from Scene",MENU_OPTION_CREATE_FROM_SCENE);
options->get_popup()->add_item("Merge from Scene",MENU_OPTION_MERGE_FROM_SCENE);
options->get_popup()->connect("item_pressed", this,"_menu_cbk");
editor=p_editor;
cd = memnew(ConfirmationDialog);
add_child(cd);
cd->get_ok()->connect("pressed", this,"_menu_confirm");
}
bool PauseState::onEnter() {
if (!TheTextureManager::Instance()->load("assets/resume.png", "resume",
TheGame::instance()->getRenderer())) {
return false;
}
if (!TheTextureManager::Instance()->load("assets/main.png", "main",
TheGame::instance()->getRenderer())) {
return false;
}
MenuButton *resumeButton = new MenuButton();
resumeButton->load(new LoaderParams(100, 100, 200, 100, "resume"));
resumeButton->setCallBack(s_pauseToMain);
MenuButton *mainButton = new MenuButton();
mainButton->load(new LoaderParams(100, 200, 200, 100, "main"));
mainButton->setCallBack(s_resumeToPlay);
m_gameObjects.push_back(resumeButton);
m_gameObjects.push_back(mainButton);
return true;
}
//
// DU_MenuRun
//
void DU_MenuRun(Menu *menu)
{
int msgid = BASE_MSGID;
// Read buttons.
int buttons = ACS_GetPlayerInput(-1, INPUT_BUTTONS);
int buttonsOld = ACS_GetPlayerInput(-1, INPUT_OLDBUTTONS);
int buttonsNew = buttons & ~buttonsOld;
// Poll and cap cursor movement.
accum inputX = ACS_GetPlayerInputFixed(-1, INPUT_YAW);
accum inputY = ACS_GetPlayerInputFixed(-1, INPUT_PITCH);
if(ACS_GetCVar(s"invertmouse"))
inputY = -inputY;
menu->x -= inputX * menu->w * 2;
menu->y -= inputY * menu->h * 2;
if(menu->x < 0) menu->x = 0;
if(menu->x > menu->w) menu->x = menu->w;
if(menu->y < 0) menu->y = 0;
if(menu->y > menu->h) menu->y = menu->h;
if(menu->run)
menu->run(menu);
// Draw cursor.
DU_MenuHudImage(menu, msgid++, s"CURSOR", (int)menu->x+0.1k, (int)menu->y+0.1k);
// Draw buttons.
for(MenuButton *button = menu->buttons; button; button = button->next)
{
if(button->run)
button->run(button);
int x = button->x + button->w/2;
int y = button->y + button->h/2;
DU_MenuHudText(menu, msgid++, button->txt, button->color, x, y);
if(button->img[0])
DU_MenuHudImage(menu, msgid++, button->img, x, y);
else
DU_MenuHudClear(menu, msgid++);
}
// Draw labels.
for(MenuLabel *label = menu->labels; label; label = label->next)
{
if(label->run)
label->run(label);
int x = label->x + label->w/2;
int y = label->y + label->h/2;
DU_MenuHudText(menu, msgid++, label->txt, label->color, x, y);
if(label->img[0])
DU_MenuHudImage(menu, msgid++, label->img, x, y);
else
DU_MenuHudClear(menu, msgid++);
}
// Draw texts.
for(MenuText *text = menu->texts; text; text = text->next)
{
if(text->run)
text->run(text);
accum x = (int)text->x + 0.1;
accum y = (int)text->y + 0.1;
DU_MenuHudText(menu, msgid++, text->txt, text->color, x, y);
}
// Mouse-over events.
for(MenuButton *button = menu->buttons; button; button = button->next)
{
if(button->hover &&
menu->x >= button->x && menu->x < button->x + button->w &&
menu->y >= button->y && menu->y < button->y + button->h)
{
button->hover(button);
}
}
// Click events.
if(buttonsNew & BT_ATTACK)
{
for(MenuButton *button = menu->buttons; button; button = button->next)
{
if(button->click &&
menu->x >= button->x && menu->x < button->x + button->w &&
menu->y >= button->y && menu->y < button->y + button->h)
{
button->click(button);
}
}
}
}
