Browse Source

Cleanup of menu and keybindings.

merge-requests/365/head
eidheim 11 years ago
parent
commit
ef6b48e507
  1. 2
      juci/CMakeLists.txt
  2. 24
      juci/api.cc
  3. 2
      juci/api.h
  4. 8
      juci/config.cc
  5. 2
      juci/config.h
  6. 41
      juci/keybindings.cc
  7. 32
      juci/keybindings.h
  8. 98
      juci/menu.cc
  9. 43
      juci/menu.h
  10. 2
      juci/menu.xml
  11. 112
      juci/notebook.cc
  12. 13
      juci/singletons.cc
  13. 9
      juci/singletons.h
  14. 98
      juci/window.cc

2
juci/CMakeLists.txt

@ -101,8 +101,6 @@ add_executable(${project_name}
#list of every needed file to create the executable
juci.h
juci.cc
keybindings.h
keybindings.cc
menu.h
menu.cc
source.h

24
juci/api.cc

@ -2,8 +2,8 @@
#include "logging.h"
#include "singletons.h"
Menu::Controller* PluginApi::menu_;
Notebook::Controller* PluginApi::notebook_;
Menu* PluginApi::menu_=nullptr;
Notebook::Controller* PluginApi::notebook_=nullptr;
/////////////////////////////
//// API ServiceProvider ////
/////////////////////////////
@ -64,8 +64,7 @@ void PluginApi::AddMenuElement(std::string plugin_name) {
DEBUG("Adding menu element for "+plugin_name);
AddMenuXml(plugin_name, "PluginMenu");
std::string plugin_action_name = plugin_name+"Menu";
Singleton::keybindings()->action_group_menu
->add(Gtk::Action::create(plugin_action_name, plugin_name));
Singleton::menu()->action_group->add(Gtk::Action::create(plugin_action_name, plugin_name));
}
void PluginApi::AddSubMenuElement(std::string parent_menu,
@ -74,8 +73,7 @@ void PluginApi::AddSubMenuElement(std::string parent_menu,
std::string plugin_path,
std::string menu_keybinding) {
AddSubMenuXml(menu_func_name, parent_menu);
Singleton::keybindings()->action_group_menu
->add(Gtk::Action::create(menu_func_name,
Singleton::menu()->action_group->add(Gtk::Action::create(menu_func_name,
menu_name),
Gtk::AccelKey(menu_keybinding),
[=]() {
@ -84,9 +82,9 @@ void PluginApi::AddSubMenuElement(std::string parent_menu,
}
void PluginApi::AddMenuXml(std::string plugin_name, std::string parent_menu) {
std::string temp_menu = Singleton::keybindings()->menu_ui_string;
std::string temp_menu = Singleton::menu()->ui;
std::size_t plugin_menu_pos = temp_menu.find(parent_menu);
// +2 gets you outside of the tag:<'menu_name'> ref: keybindings.cc
// +2 gets you outside of the tag:<'menu_name'>
plugin_menu_pos+=parent_menu.size() +2;
std::string menu_prefix = temp_menu.substr(0, plugin_menu_pos);
std::string menu_suffix = temp_menu.substr(plugin_menu_pos);
@ -94,23 +92,21 @@ void PluginApi::AddMenuXml(std::string plugin_name, std::string parent_menu) {
" <menu action='"+plugin_name+"Menu'> "
" </menu> ";
Singleton::keybindings()->menu_ui_string =
menu_prefix + menu_input + menu_suffix;
Singleton::menu()->ui = menu_prefix + menu_input + menu_suffix;
}
void PluginApi::AddSubMenuXml(std::string plugin_name,
std::string parent_menu) {
std::string temp_menu = Singleton::keybindings()->menu_ui_string;
std::string temp_menu = Singleton::menu()->ui;
std::size_t parent_menu_pos = temp_menu.find(parent_menu);
// +2 gets you outside of the tag:<'menu_name'> ref: keybindings.cc
// +2 gets you outside of the tag:<'menu_name'>
parent_menu_pos+=parent_menu.size() +2;
std::string menu_prefix = temp_menu.substr(0, parent_menu_pos);
std::string menu_suffix = temp_menu.substr(parent_menu_pos);
std::string menu_input ="<menuitem action='"+plugin_name+"'/>";
Singleton::keybindings()->menu_ui_string =
menu_prefix + menu_input + menu_suffix;
Singleton::menu()->ui = menu_prefix + menu_input + menu_suffix;
}
///////////////////////

2
juci/api.h

@ -13,7 +13,7 @@
class PluginApi {
public:
PluginApi();
static Menu::Controller* menu_;
static Menu* menu_;
static Notebook::Controller* notebook_;
static void InitPlugins();
static std::string ProjectPath();

8
juci/config.cc

@ -1,6 +1,8 @@
#include "singletons.h"
#include "config.h"
#include "logging.h"
#include <fstream>
#include <string>
MainConfig::MainConfig() {
INFO("Reading config file");
@ -71,17 +73,17 @@ void MainConfig::GenerateTerminalCommands() {
}
void MainConfig::GenerateKeybindings() {
auto keybindings_cfg=Singleton::Config::keybindings();
auto menu=Singleton::menu();
DEBUG("Fetching keybindings");
std::string line;
std::ifstream menu_xml("menu.xml");
if (menu_xml.is_open()) {
while (getline(menu_xml, line))
keybindings_cfg->AppendXml(line);
menu->ui+=line;
}
boost::property_tree::ptree keys_json = cfg_.get_child("keybindings");
for (auto &i : keys_json)
keybindings_cfg->key_map[i.first] = i.second.get_value<std::string>();
menu->key_map[i.first] = i.second.get_value<std::string>();
DEBUG("Keybindings fetched");
}

2
juci/config.h

@ -2,8 +2,6 @@
#define JUCI_CONFIG_H_
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <fstream>
#include <string>
class MainConfig {
public:

41
juci/keybindings.cc

@ -1,41 +0,0 @@
#include "keybindings.h"
#include "singletons.h"
Keybindings::Keybindings() {
menu_ui_string=Singleton::Config::keybindings()->menu_xml;
action_group_menu = Gtk::ActionGroup::create();
ui_manager_menu = Gtk::UIManager::create();
action_group_hidden = Gtk::ActionGroup::create();
ui_manager_hidden = Gtk::UIManager::create();
}
void Keybindings::BuildMenu() {
try {
ui_manager_menu->add_ui_from_string(menu_ui_string);
}
catch (const Glib::Error &ex) {
std::cerr << "building menu failed" << ex.what();
}
ui_manager_menu->insert_action_group(action_group_menu);
}
void Keybindings::BuildHiddenMenu() {
try {
ui_manager_hidden->add_ui_from_string(hidden_ui_string);
}
catch (const Glib::Error &ex) {
std::cerr << "building hidden menu failed" << ex.what();
}
ui_manager_hidden->insert_action_group(action_group_hidden);
}
void Keybindings::Config::AppendXml(std::string &child) {
menu_xml += child;
}
void Keybindings::Config::SetMenu(std::string &menu_xml) {
menu_xml = menu_xml;
}
void Keybindings::Config::SetKeyMap(std::unordered_map<std::string, std::string> &key_map) {
key_map = key_map;
}

32
juci/keybindings.h

@ -1,32 +0,0 @@
//juCi++ class that holds every keybinding.
#ifndef JUCI_KEYBINDINGS_H_
#define JUCI_KEYBINDINGS_H_
#include <gtkmm.h>
#include <iostream>
#include <unordered_map>
class Keybindings {
public:
class Config {
public:
void AppendXml(std::string &child);
void SetMenu(std::string &menu_xml);
void SetKeyMap(std::unordered_map<std::string, std::string> &key_map);
std::unordered_map<std::string, std::string> key_map;
std::string menu_xml;
};//Config
Keybindings();
void BuildMenu();
void BuildHiddenMenu();
std::string menu_ui_string;
std::string hidden_ui_string;
Glib::RefPtr<Gtk::UIManager> ui_manager_menu;
Glib::RefPtr<Gtk::ActionGroup> action_group_menu;
Glib::RefPtr<Gtk::UIManager> ui_manager_hidden;
Glib::RefPtr<Gtk::ActionGroup> action_group_hidden;
};
#endif // JUCI_KEYBINDINGS_H_

98
juci/menu.cc

@ -1,76 +1,36 @@
#include "menu.h"
#include "singletons.h"
#include <iostream>
Menu::View::View(Gtk::Orientation orientation) :
view_(orientation) {
Gtk::MenuBar menutest;
view_.pack_end(menutest);
}
Gtk::Box &Menu::View::view(
Glib::RefPtr<Gtk::UIManager> ui_manager) {
view_.pack_start(*ui_manager->get_widget("/MenuBar"), Gtk::PACK_SHRINK);
return view_;
}
Menu::Menu() : box(Gtk::ORIENTATION_VERTICAL) {
action_group = Gtk::ActionGroup::create();
ui_manager = Gtk::UIManager::create();
Menu::Controller::Controller() : menu_view_(Gtk::ORIENTATION_VERTICAL) {
auto keybindings=Singleton::keybindings();
keybindings->action_group_menu->add(Gtk::Action::create("FileNew",
"New File"));
keybindings->action_group_menu->add(Gtk::Action::create("EditMenu",
Gtk::Stock::EDIT));
keybindings->action_group_menu->add(Gtk::Action::create("WindowMenu",
"_Window"));
keybindings->action_group_menu->add(Gtk::Action::create("WindowSplitWindow",
"Split window"),
Gtk::AccelKey(Singleton::Config::keybindings()
->key_map["split_window"]),//"<control><alt>S"),
[this]() {
OnWindowSplitWindow();
});
keybindings->action_group_menu->add(Gtk::Action::create("ProjectMenu",
"P_roject"));
keybindings->action_group_menu->add(Gtk::Action::create("PluginMenu",
"_Plugins"));
keybindings->action_group_menu->add(Gtk::Action::create("HelpMenu",
Gtk::Stock::HELP));
keybindings->action_group_menu->add(Gtk::Action::create("HelpAbout",
Gtk::Stock::ABOUT),
[this]() {
OnHelpAbout();
});
keybindings->action_group_hidden->add(Gtk::Action::create("Test"),
Gtk::AccelKey("<control><alt>K"),
[this]() {
OnHelpAbout();
});
//keybindings->BuildMenu(); // moved to window.cc
keybindings->BuildHiddenMenu();
} // Controller
Gtk::Box &Menu::Controller::view() {
return menu_view_.view(Singleton::keybindings()->ui_manager_menu);
}
void Menu::Controller::OnPluginAddSnippet() {
//TODO(Forgi add you snippet magic code)
std::cout << "Add snippet" << std::endl;
//juci_api::py::LoadPlugin("snippet");
}
void Menu::Controller::OnFileOpenFile() {
std::cout << "Open file clicked" << std::endl;
//TODO(Oyvang) Legg til funksjon
action_group->add(Gtk::Action::create("FileNew", "New File"));
action_group->add(Gtk::Action::create("EditMenu", Gtk::Stock::EDIT));
action_group->add(Gtk::Action::create("WindowMenu", "_Window"));
action_group->add(Gtk::Action::create("WindowSplitWindow", "Split window"), Gtk::AccelKey(key_map["split_window"]), [this]() {
});
action_group->add(Gtk::Action::create("ProjectMenu", "P_roject"));
action_group->add(Gtk::Action::create("PluginMenu", "_Plugins"));
action_group->add(Gtk::Action::create("HelpMenu", Gtk::Stock::HELP));
action_group->add(Gtk::Action::create("HelpAbout", Gtk::Stock::ABOUT), [this]() {
});
}
void Menu::Controller::OnEditCut() {
std::cout << "Clicked cut" << std::endl;
//TODO(Oyvang) Legg til funksjon
}
void Menu::Controller::OnEditFind() {
std::cout << "Clicked find" << std::endl;
//TODO(Oyvang) Legg til funksjon
Gtk::Widget& Menu::get_widget() {
return *ui_manager->get_widget("/MenuBar");
}
void Menu::Controller::OnWindowSplitWindow() {
std::cout << "Clicked split window" << std::endl;
//TODO(Oyvang) Legg til funksjon
Gtk::Menu& Menu::get_cpp() {
return *(Gtk::Menu*)ui_manager->get_widget("/MenuBar/CppMenu");
}
void Menu::Controller::OnHelpAbout() {
std::cout << "Clicked about" << std::endl;
//TODO(Oyvang) Legg til funksjon
void Menu::build() {
try {
ui_manager->add_ui_from_string(ui);
}
catch (const Glib::Error &ex) {
std::cerr << "building menu failed" << ex.what();
}
ui_manager->insert_action_group(action_group);
}

43
juci/menu.h

@ -1,34 +1,21 @@
#ifndef JUCI_MENU_H_
#define JUCI_MENU_H_
#include <iostream>
#include <string>
#include <unordered_map>
#include <gtkmm.h>
namespace Menu {
class View {
public:
explicit View(Gtk::Orientation orient);
Gtk::Box &view(Glib::RefPtr<Gtk::UIManager> ui_manager);
protected:
Gtk::Box view_;
}; // class View
class Controller {
public:
Controller();
Gtk::Box &view();
View menu_view_;
void OnFileNewEmptyfile();
void OnFileNewCCFile();
void OnFileNewHeaderFile();
void OnFileOpenFile();
void OnFileOpenFolder();
void OnPluginAddSnippet();
void OnWindowCloseTab();
void OnEditCut();
void OnEditFind();
void OnWindowSplitWindow();
void OnHelpAbout();
}; // class Controller
} // namespace Menu
class Menu {
public:
Menu();
Gtk::Widget& get_widget();
Gtk::Menu& get_cpp();
void build();
Gtk::Box box;
std::unordered_map<std::string, std::string> key_map;
std::string ui;
Glib::RefPtr<Gtk::UIManager> ui_manager;
Glib::RefPtr<Gtk::ActionGroup> action_group;
};
#endif // JUCI_MENU_H_

2
juci/menu.xml

@ -16,7 +16,7 @@
<separator/>
<menuitem action='EditFind'/>
<menuitem action='EditUndo'/>
<menuitem action='EditRedo'/>
<menuitem action='EditRedo'/>
</menu>
<menu action='ProjectMenu'>
<menuitem action='ProjectCompileAndRun'/>

112
juci/notebook.cc

@ -21,95 +21,55 @@ Notebook::Controller::Controller() :
void Notebook::Controller::CreateKeybindings() {
auto keybindings=Singleton::keybindings();
auto keybindings_cfg=Singleton::Config::keybindings();
auto menu=Singleton::menu();
INFO("Notebook create signal handlers");
directories.m_TreeView.signal_row_activated()
.connect(sigc::mem_fun(*this,
&Notebook::Controller::OnDirectoryNavigation));
directories.m_TreeView.signal_row_activated().connect(sigc::mem_fun(*this, &Notebook::Controller::OnDirectoryNavigation));
keybindings->action_group_menu->
add(Gtk::Action::create("FileMenu",
Gtk::Stock::FILE));
menu->action_group->add(Gtk::Action::create("FileMenu", Gtk::Stock::FILE));
keybindings->action_group_menu->
add(Gtk::Action::create("FileNewFile",
"New file"),
Gtk::AccelKey(keybindings_cfg->key_map["new_file"]),
[this]() {
OnFileNewFile();
});
keybindings->action_group_menu->
add(Gtk::Action::create("WindowCloseTab",
"Close tab"),
Gtk::AccelKey(keybindings_cfg->key_map["close_tab"]),
[this]() {
OnCloseCurrentPage();
});
keybindings->action_group_menu->
add(Gtk::Action::create("EditFind",
"Find"),
Gtk::AccelKey(keybindings_cfg->key_map["edit_find"]),
[this]() {
menu->action_group->add(Gtk::Action::create("FileNewFile", "New file"), Gtk::AccelKey(menu->key_map["new_file"]), [this]() {
OnFileNewFile();
});
menu->action_group->add(Gtk::Action::create("WindowCloseTab", "Close tab"), Gtk::AccelKey(menu->key_map["close_tab"]), [this]() {
OnCloseCurrentPage();
});
menu->action_group->add(Gtk::Action::create("EditFind", "Find"), Gtk::AccelKey(menu->key_map["edit_find"]), [this]() {
entry.show_search("");
});
keybindings->action_group_menu->
add(Gtk::Action::create("EditCopy",
"Copy"),
Gtk::AccelKey(keybindings_cfg->key_map["edit_copy"]),
[this]() {
if (Pages() != 0) {
CurrentSourceView()->get_buffer()->copy_clipboard(clipboard);
}
});
keybindings->action_group_menu->
add(Gtk::Action::create("EditCut",
"Cut"),
Gtk::AccelKey(keybindings_cfg->key_map["edit_cut"]),
[this]() {
});
menu->action_group->add(Gtk::Action::create("EditCopy", "Copy"), Gtk::AccelKey(menu->key_map["edit_copy"]), [this]() {
if (Pages() != 0) {
CurrentSourceView()->get_buffer()->copy_clipboard(clipboard);
}
});
menu->action_group->add(Gtk::Action::create("EditCut", "Cut"), Gtk::AccelKey(menu->key_map["edit_cut"]), [this]() {
if (Pages() != 0) {
CurrentSourceView()->get_buffer()->cut_clipboard(clipboard);
}
});
keybindings->action_group_menu->
add(Gtk::Action::create("EditPaste",
"Paste"),
Gtk::AccelKey(keybindings_cfg->key_map["edit_paste"]),
[this]() {
});
menu->action_group->add(Gtk::Action::create("EditPaste", "Paste"), Gtk::AccelKey(menu->key_map["edit_paste"]), [this]() {
if (Pages() != 0) {
CurrentSourceView()->get_buffer()->paste_clipboard(clipboard);
}
});
});
keybindings->action_group_menu->
add(Gtk::Action::create("EditUndo",
"Undo"),
Gtk::AccelKey(keybindings_cfg->key_map["edit_undo"]),
[this]() {
menu->action_group->add(Gtk::Action::create("EditUndo", "Undo"), Gtk::AccelKey(menu->key_map["edit_undo"]), [this]() {
INFO("On undo");
Glib::RefPtr<Gsv::UndoManager> undo_manager =
CurrentSourceView()->get_source_buffer()->get_undo_manager();
if (Pages() != 0 && undo_manager->can_undo()) {
undo_manager->undo();
}
INFO("Done undo");
}
);
Glib::RefPtr<Gsv::UndoManager> undo_manager = CurrentSourceView()->get_source_buffer()->get_undo_manager();
if (Pages() != 0 && undo_manager->can_undo()) {
undo_manager->undo();
}
INFO("Done undo");
});
keybindings->action_group_menu->
add(Gtk::Action::create("EditRedo",
"Redo"),
Gtk::AccelKey(keybindings_cfg->key_map["edit_redo"]),
[this]() {
INFO("On Redo");
Glib::RefPtr<Gsv::UndoManager> undo_manager =
CurrentSourceView()->get_source_buffer()->get_undo_manager();
if (Pages() != 0 && undo_manager->can_redo()) {
undo_manager->redo();
}
INFO("Done Redo");
});
menu->action_group->add(Gtk::Action::create("EditRedo", "Redo"), Gtk::AccelKey(menu->key_map["edit_redo"]), [this]() {
INFO("On Redo");
Glib::RefPtr<Gsv::UndoManager> undo_manager =
CurrentSourceView()->get_source_buffer()->get_undo_manager();
if (Pages() != 0 && undo_manager->can_redo()) {
undo_manager->redo();
}
INFO("Done Redo");
});
entry.button_apply_set_filename.signal_clicked().connect([this]() {
std::string filename=entry();

13
juci/singletons.cc

@ -3,29 +3,22 @@
std::unique_ptr<Source::Config> Singleton::Config::source_=std::unique_ptr<Source::Config>(new Source::Config());
std::unique_ptr<Terminal::Config> Singleton::Config::terminal_=std::unique_ptr<Terminal::Config>(new Terminal::Config());
std::unique_ptr<Directories::Config> Singleton::Config::directories_=std::unique_ptr<Directories::Config>(new Directories::Config());
std::unique_ptr<Keybindings::Config> Singleton::Config::keybindings_=std::unique_ptr<Keybindings::Config>(new Keybindings::Config());
std::unique_ptr<Terminal::Controller> Singleton::terminal_=std::unique_ptr<Terminal::Controller>();
std::unique_ptr<Keybindings> Singleton::keybindings_=std::unique_ptr<Keybindings>();
std::unique_ptr<Notebook::Controller> Singleton::notebook_=std::unique_ptr<Notebook::Controller>();
std::unique_ptr<Menu::Controller> Singleton::menu_=std::unique_ptr<Menu::Controller>();
std::unique_ptr<Menu> Singleton::menu_=std::unique_ptr<Menu>();
Terminal::Controller *Singleton::terminal() {
if(!terminal_)
terminal_=std::unique_ptr<Terminal::Controller>(new Terminal::Controller());
return terminal_.get();
}
Keybindings *Singleton::keybindings() {
if(!keybindings_)
keybindings_=std::unique_ptr<Keybindings>(new Keybindings());
return keybindings_.get();
}
Notebook::Controller *Singleton::notebook() {
if(!notebook_)
notebook_=std::unique_ptr<Notebook::Controller>(new Notebook::Controller());
return notebook_.get();
}
Menu::Controller *Singleton::menu() {
Menu *Singleton::menu() {
if(!menu_)
menu_=std::unique_ptr<Menu::Controller>(new Menu::Controller());
menu_=std::unique_ptr<Menu>(new Menu());
return menu_.get();
}

9
juci/singletons.h

@ -1,7 +1,6 @@
#ifndef JUCI_SINGLETONS_H_
#define JUCI_SINGLETONS_H_
#include "keybindings.h"
#include "source.h"
#include "directories.h"
#include "terminal.h"
@ -15,23 +14,19 @@ public:
static Source::Config *source() {return source_.get();}
static Terminal::Config *terminal() {return terminal_.get();}
static Directories::Config *directories() {return directories_.get();}
static Keybindings::Config *keybindings() {return keybindings_.get();}
private:
static std::unique_ptr<Source::Config> source_;
static std::unique_ptr<Terminal::Config> terminal_;
static std::unique_ptr<Directories::Config> directories_;
static std::unique_ptr<Keybindings::Config> keybindings_;
};
static Terminal::Controller *terminal();
static Keybindings *keybindings();
static Notebook::Controller *notebook();
static Menu::Controller *menu();
static Menu *menu();
private:
static std::unique_ptr<Terminal::Controller> terminal_;
static std::unique_ptr<Keybindings> keybindings_;
static std::unique_ptr<Notebook::Controller> notebook_;
static std::unique_ptr<Menu::Controller> menu_;
static std::unique_ptr<Menu> menu_;
};
#endif // JUCI_SINGLETONS_H_

98
juci/window.cc

@ -9,56 +9,25 @@ Window::Window() :
set_default_size(600, 400);
set_events(Gdk::POINTER_MOTION_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::SCROLL_MASK);
add(window_box_);
auto keybindings=Singleton::keybindings();
auto keybindings_cfg=Singleton::Config::keybindings();
keybindings->action_group_menu->add(Gtk::Action::create("FileQuit",
"Quit juCi++"),
Gtk::AccelKey(keybindings_cfg
->key_map["quit"]),
[this]() {
OnWindowHide();
});
keybindings->action_group_menu->add(Gtk::Action::create("FileOpenFile",
"Open file"),
Gtk::AccelKey(keybindings_cfg
->key_map["open_file"]),
[this]() {
OnOpenFile();
});
keybindings->action_group_menu->add(Gtk::Action::create("FileOpenFolder",
"Open folder"),
Gtk::AccelKey(keybindings_cfg
->key_map["open_folder"]),
[this]() {
OnFileOpenFolder();
});
keybindings->
action_group_menu->
add(Gtk::Action::create("FileSaveAs",
"Save as"),
Gtk::AccelKey(keybindings_cfg
->key_map["save_as"]),
[this]() {
auto menu=Singleton::menu();
menu->action_group->add(Gtk::Action::create("FileQuit", "Quit juCi++"), Gtk::AccelKey(menu->key_map["quit"]), [this]() {
OnWindowHide();
});
menu->action_group->add(Gtk::Action::create("FileOpenFile", "Open file"), Gtk::AccelKey(menu->key_map["open_file"]), [this]() {
OnOpenFile();
});
menu->action_group->add(Gtk::Action::create("FileOpenFolder", "Open folder"), Gtk::AccelKey(menu->key_map["open_folder"]), [this]() {
OnFileOpenFolder();
});
menu->action_group->add(Gtk::Action::create("FileSaveAs", "Save as"), Gtk::AccelKey(menu->key_map["save_as"]), [this]() {
SaveFileAs();
});
keybindings->
action_group_menu->
add(Gtk::Action::create("FileSave",
"Save"),
Gtk::AccelKey(keybindings_cfg
->key_map["save"]),
[this]() {
menu->action_group->add(Gtk::Action::create("FileSave", "Save"), Gtk::AccelKey(menu->key_map["save"]), [this]() {
SaveFile();
});
keybindings->
action_group_menu->
add(Gtk::Action::create("ProjectCompileAndRun",
"Compile And Run"),
Gtk::AccelKey(keybindings_cfg
->key_map["compile_and_run"]),
[this]() {
menu->action_group->add(Gtk::Action::create("ProjectCompileAndRun", "Compile And Run"), Gtk::AccelKey(menu->key_map["compile_and_run"]), [this]() {
SaveFile();
if (running.try_lock()) {
std::thread execute([this]() {
@ -78,34 +47,27 @@ Window::Window() :
}
});
keybindings->
action_group_menu->
add(Gtk::Action::create("ProjectCompile",
"Compile"),
Gtk::AccelKey(keybindings_cfg
->key_map["compile"]),
[this]() {
SaveFile();
if (running.try_lock()) {
std::thread execute([this]() {
std::string path = Singleton::notebook()->CurrentSourceView()->file_path;
size_t pos = path.find_last_of("/\\");
if(pos != std::string::npos){
path.erase(path.begin()+pos,path.end());
Singleton::terminal()->SetFolderCommand(path);
}
Singleton::terminal()->Compile();
running.unlock();
});
execute.detach();
menu->action_group->add(Gtk::Action::create("ProjectCompile", "Compile"), Gtk::AccelKey(menu->key_map["compile"]), [this]() {
SaveFile();
if (running.try_lock()) {
std::thread execute([this]() {
std::string path = Singleton::notebook()->CurrentSourceView()->file_path;
size_t pos = path.find_last_of("/\\");
if(pos != std::string::npos){
path.erase(path.begin()+pos,path.end());
Singleton::terminal()->SetFolderCommand(path);
}
Singleton::terminal()->Compile();
running.unlock();
});
execute.detach();
}
});
add_accel_group(keybindings->ui_manager_menu->get_accel_group());
add_accel_group(keybindings->ui_manager_hidden->get_accel_group());
keybindings->BuildMenu();
add_accel_group(menu->ui_manager->get_accel_group());
menu->build();
window_box_.pack_start(Singleton::menu()->view(), Gtk::PACK_SHRINK);
window_box_.pack_start(menu->get_widget(), Gtk::PACK_SHRINK);
window_box_.pack_start(Singleton::notebook()->entry, Gtk::PACK_SHRINK);
paned_.set_position(300);

Loading…
Cancel
Save