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. 94
      juci/menu.cc
  9. 41
      juci/menu.h
  10. 66
      juci/notebook.cc
  11. 13
      juci/singletons.cc
  12. 9
      juci/singletons.h
  13. 60
      juci/window.cc

2
juci/CMakeLists.txt

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

24
juci/api.cc

@ -2,8 +2,8 @@
#include "logging.h" #include "logging.h"
#include "singletons.h" #include "singletons.h"
Menu::Controller* PluginApi::menu_; Menu* PluginApi::menu_=nullptr;
Notebook::Controller* PluginApi::notebook_; Notebook::Controller* PluginApi::notebook_=nullptr;
///////////////////////////// /////////////////////////////
//// API ServiceProvider //// //// API ServiceProvider ////
///////////////////////////// /////////////////////////////
@ -64,8 +64,7 @@ void PluginApi::AddMenuElement(std::string plugin_name) {
DEBUG("Adding menu element for "+plugin_name); DEBUG("Adding menu element for "+plugin_name);
AddMenuXml(plugin_name, "PluginMenu"); AddMenuXml(plugin_name, "PluginMenu");
std::string plugin_action_name = plugin_name+"Menu"; std::string plugin_action_name = plugin_name+"Menu";
Singleton::keybindings()->action_group_menu Singleton::menu()->action_group->add(Gtk::Action::create(plugin_action_name, plugin_name));
->add(Gtk::Action::create(plugin_action_name, plugin_name));
} }
void PluginApi::AddSubMenuElement(std::string parent_menu, void PluginApi::AddSubMenuElement(std::string parent_menu,
@ -74,8 +73,7 @@ void PluginApi::AddSubMenuElement(std::string parent_menu,
std::string plugin_path, std::string plugin_path,
std::string menu_keybinding) { std::string menu_keybinding) {
AddSubMenuXml(menu_func_name, parent_menu); AddSubMenuXml(menu_func_name, parent_menu);
Singleton::keybindings()->action_group_menu Singleton::menu()->action_group->add(Gtk::Action::create(menu_func_name,
->add(Gtk::Action::create(menu_func_name,
menu_name), menu_name),
Gtk::AccelKey(menu_keybinding), 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) { 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); 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; plugin_menu_pos+=parent_menu.size() +2;
std::string menu_prefix = temp_menu.substr(0, plugin_menu_pos); std::string menu_prefix = temp_menu.substr(0, plugin_menu_pos);
std::string menu_suffix = temp_menu.substr(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 action='"+plugin_name+"Menu'> "
" </menu> "; " </menu> ";
Singleton::keybindings()->menu_ui_string = Singleton::menu()->ui = menu_prefix + menu_input + menu_suffix;
menu_prefix + menu_input + menu_suffix;
} }
void PluginApi::AddSubMenuXml(std::string plugin_name, void PluginApi::AddSubMenuXml(std::string plugin_name,
std::string parent_menu) { 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); 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; parent_menu_pos+=parent_menu.size() +2;
std::string menu_prefix = temp_menu.substr(0, parent_menu_pos); std::string menu_prefix = temp_menu.substr(0, parent_menu_pos);
std::string menu_suffix = temp_menu.substr(parent_menu_pos); std::string menu_suffix = temp_menu.substr(parent_menu_pos);
std::string menu_input ="<menuitem action='"+plugin_name+"'/>"; std::string menu_input ="<menuitem action='"+plugin_name+"'/>";
Singleton::keybindings()->menu_ui_string = Singleton::menu()->ui = menu_prefix + menu_input + menu_suffix;
menu_prefix + menu_input + menu_suffix;
} }
/////////////////////// ///////////////////////

2
juci/api.h

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

8
juci/config.cc

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

2
juci/config.h

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

94
juci/menu.cc

@ -1,76 +1,36 @@
#include "menu.h" #include "menu.h"
#include "singletons.h" #include <iostream>
Menu::View::View(Gtk::Orientation orientation) : Menu::Menu() : box(Gtk::ORIENTATION_VERTICAL) {
view_(orientation) { action_group = Gtk::ActionGroup::create();
Gtk::MenuBar menutest; ui_manager = Gtk::UIManager::create();
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::Controller::Controller() : menu_view_(Gtk::ORIENTATION_VERTICAL) { action_group->add(Gtk::Action::create("FileNew", "New File"));
auto keybindings=Singleton::keybindings(); action_group->add(Gtk::Action::create("EditMenu", Gtk::Stock::EDIT));
keybindings->action_group_menu->add(Gtk::Action::create("FileNew", action_group->add(Gtk::Action::create("WindowMenu", "_Window"));
"New File")); action_group->add(Gtk::Action::create("WindowSplitWindow", "Split window"), Gtk::AccelKey(key_map["split_window"]), [this]() {
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"), action_group->add(Gtk::Action::create("ProjectMenu", "P_roject"));
Gtk::AccelKey("<control><alt>K"), action_group->add(Gtk::Action::create("PluginMenu", "_Plugins"));
[this]() { action_group->add(Gtk::Action::create("HelpMenu", Gtk::Stock::HELP));
OnHelpAbout(); action_group->add(Gtk::Action::create("HelpAbout", Gtk::Stock::ABOUT), [this]() {
}); });
//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
} }
void Menu::Controller::OnEditCut() {
std::cout << "Clicked cut" << std::endl; Gtk::Widget& Menu::get_widget() {
//TODO(Oyvang) Legg til funksjon return *ui_manager->get_widget("/MenuBar");
}
void Menu::Controller::OnEditFind() {
std::cout << "Clicked find" << std::endl;
//TODO(Oyvang) Legg til funksjon
} }
void Menu::Controller::OnWindowSplitWindow() {
std::cout << "Clicked split window" << std::endl; Gtk::Menu& Menu::get_cpp() {
//TODO(Oyvang) Legg til funksjon return *(Gtk::Menu*)ui_manager->get_widget("/MenuBar/CppMenu");
} }
void Menu::Controller::OnHelpAbout() {
std::cout << "Clicked about" << std::endl; void Menu::build() {
//TODO(Oyvang) Legg til funksjon 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);
} }

41
juci/menu.h

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

66
juci/notebook.cc

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

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<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<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<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<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<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() { Terminal::Controller *Singleton::terminal() {
if(!terminal_) if(!terminal_)
terminal_=std::unique_ptr<Terminal::Controller>(new Terminal::Controller()); terminal_=std::unique_ptr<Terminal::Controller>(new Terminal::Controller());
return terminal_.get(); return terminal_.get();
} }
Keybindings *Singleton::keybindings() {
if(!keybindings_)
keybindings_=std::unique_ptr<Keybindings>(new Keybindings());
return keybindings_.get();
}
Notebook::Controller *Singleton::notebook() { Notebook::Controller *Singleton::notebook() {
if(!notebook_) if(!notebook_)
notebook_=std::unique_ptr<Notebook::Controller>(new Notebook::Controller()); notebook_=std::unique_ptr<Notebook::Controller>(new Notebook::Controller());
return notebook_.get(); return notebook_.get();
} }
Menu::Controller *Singleton::menu() { Menu *Singleton::menu() {
if(!menu_) if(!menu_)
menu_=std::unique_ptr<Menu::Controller>(new Menu::Controller()); menu_=std::unique_ptr<Menu>(new Menu());
return menu_.get(); return menu_.get();
} }

9
juci/singletons.h

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

60
juci/window.cc

@ -9,56 +9,25 @@ Window::Window() :
set_default_size(600, 400); set_default_size(600, 400);
set_events(Gdk::POINTER_MOTION_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::SCROLL_MASK); set_events(Gdk::POINTER_MOTION_MASK|Gdk::FOCUS_CHANGE_MASK|Gdk::SCROLL_MASK);
add(window_box_); add(window_box_);
auto keybindings=Singleton::keybindings(); auto menu=Singleton::menu();
auto keybindings_cfg=Singleton::Config::keybindings(); menu->action_group->add(Gtk::Action::create("FileQuit", "Quit juCi++"), Gtk::AccelKey(menu->key_map["quit"]), [this]() {
keybindings->action_group_menu->add(Gtk::Action::create("FileQuit",
"Quit juCi++"),
Gtk::AccelKey(keybindings_cfg
->key_map["quit"]),
[this]() {
OnWindowHide(); OnWindowHide();
}); });
keybindings->action_group_menu->add(Gtk::Action::create("FileOpenFile", menu->action_group->add(Gtk::Action::create("FileOpenFile", "Open file"), Gtk::AccelKey(menu->key_map["open_file"]), [this]() {
"Open file"),
Gtk::AccelKey(keybindings_cfg
->key_map["open_file"]),
[this]() {
OnOpenFile(); OnOpenFile();
}); });
keybindings->action_group_menu->add(Gtk::Action::create("FileOpenFolder", menu->action_group->add(Gtk::Action::create("FileOpenFolder", "Open folder"), Gtk::AccelKey(menu->key_map["open_folder"]), [this]() {
"Open folder"),
Gtk::AccelKey(keybindings_cfg
->key_map["open_folder"]),
[this]() {
OnFileOpenFolder(); OnFileOpenFolder();
}); });
keybindings-> menu->action_group->add(Gtk::Action::create("FileSaveAs", "Save as"), Gtk::AccelKey(menu->key_map["save_as"]), [this]() {
action_group_menu->
add(Gtk::Action::create("FileSaveAs",
"Save as"),
Gtk::AccelKey(keybindings_cfg
->key_map["save_as"]),
[this]() {
SaveFileAs(); SaveFileAs();
}); });
keybindings-> menu->action_group->add(Gtk::Action::create("FileSave", "Save"), Gtk::AccelKey(menu->key_map["save"]), [this]() {
action_group_menu->
add(Gtk::Action::create("FileSave",
"Save"),
Gtk::AccelKey(keybindings_cfg
->key_map["save"]),
[this]() {
SaveFile(); SaveFile();
}); });
keybindings-> menu->action_group->add(Gtk::Action::create("ProjectCompileAndRun", "Compile And Run"), Gtk::AccelKey(menu->key_map["compile_and_run"]), [this]() {
action_group_menu->
add(Gtk::Action::create("ProjectCompileAndRun",
"Compile And Run"),
Gtk::AccelKey(keybindings_cfg
->key_map["compile_and_run"]),
[this]() {
SaveFile(); SaveFile();
if (running.try_lock()) { if (running.try_lock()) {
std::thread execute([this]() { std::thread execute([this]() {
@ -78,13 +47,7 @@ Window::Window() :
} }
}); });
keybindings-> menu->action_group->add(Gtk::Action::create("ProjectCompile", "Compile"), Gtk::AccelKey(menu->key_map["compile"]), [this]() {
action_group_menu->
add(Gtk::Action::create("ProjectCompile",
"Compile"),
Gtk::AccelKey(keybindings_cfg
->key_map["compile"]),
[this]() {
SaveFile(); SaveFile();
if (running.try_lock()) { if (running.try_lock()) {
std::thread execute([this]() { std::thread execute([this]() {
@ -101,11 +64,10 @@ Window::Window() :
} }
}); });
add_accel_group(keybindings->ui_manager_menu->get_accel_group()); add_accel_group(menu->ui_manager->get_accel_group());
add_accel_group(keybindings->ui_manager_hidden->get_accel_group()); menu->build();
keybindings->BuildMenu();
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); window_box_.pack_start(Singleton::notebook()->entry, Gtk::PACK_SHRINK);
paned_.set_position(300); paned_.set_position(300);

Loading…
Cancel
Save