zalox
/
jucipp
mirror of https://gitlab.com/cppit/jucipp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

merged

merge-requests/365/head
Jørgen Lien Sellæg 11 years ago
parent
3250ecacaf 51eda4318d
commit
1b098cb320
14 changed files with 395 additions and 227 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      juci/api.cc
  2. 15
      juci/api_ext.cc
  3. 35
      juci/config.cc
  4. 9
      juci/config.h
  5. 29
      juci/config.json
  6. 179
      juci/directories.cc
  7. 2
      juci/keybindings.h
  8. 103
      juci/notebook.cc
  9. 4
      juci/notebook.h
  10. 105
      juci/source.cc
  11. 9
      juci/source.h
  12. 58
      juci/terminal.cc
  13. 17
      juci/terminal.h
  14. 53
      juci/window.cc

4
juci/api.cc
Unescape View File

@ -8,9 +8,12 @@ Notebook::Controller* PluginApi::notebook_;
///////////////////////////// /////////////////////////////
PluginApi::PluginApi(Menu::Controller& menu_ctl_, PluginApi::PluginApi(Menu::Controller& menu_ctl_,
Notebook::Controller& notebook_ctl_) { Notebook::Controller& notebook_ctl_) {
DEBUG("Adding pointers for the API");
menu_ = &menu_ctl_; menu_ = &menu_ctl_;
notebook_ = &notebook_ctl_; notebook_ = &notebook_ctl_;
DEBUG("Initiating plugins(from plugins.py)..");
InitPlugins(); InitPlugins();
DEBUG("Plugins initiated..");
} }
PluginApi::~PluginApi() { PluginApi::~PluginApi() {
@ -61,6 +64,7 @@ void PluginApi::InitPlugins() {
} }
void PluginApi::AddMenuElement(std::string plugin_name) { void PluginApi::AddMenuElement(std::string 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";
menu_->keybindings_.action_group_menu() menu_->keybindings_.action_group_menu()

15
juci/api_ext.cc
Unescape View File

@ -1,15 +0,0 @@
#include "api.h"
BOOST_PYTHON_MODULE(juci_to_python_api) {
using namespace boost::python;
// plugin inclusion
def("addMenuElement", &libjuci::AddMenuElement);
def("addSubMenuElement", &libjuci::AddSubMenuElement);
def("loadPlugin", &libjuci::LoadPlugin);
def("initPlugin", &libjuci::InitPlugin);
// text editing
def("replaceLine", &libjuci::ReplaceLine);
def("replaceWord", &libjuci::ReplaceWord);
def("getWord", &libjuci::GetWord);
} // module::juci_to_python_api

35
juci/config.cc
Unescape View File

@ -9,39 +9,55 @@ MainConfig::MainConfig() :
GenerateSource(); GenerateSource();
GenerateKeybindings(); GenerateKeybindings();
GenerateDirectoryFilter(); GenerateDirectoryFilter();
GenerateTerminalCommands();
} }
void MainConfig::GenerateSource() { void MainConfig::GenerateSource() {
INFO("Generating source cfg"); DEBUG("Fetching source cfg");
boost::property_tree::ptree source_json = cfg_.get_child("source"); boost::property_tree::ptree source_json = cfg_.get_child("source");
boost::property_tree::ptree syntax_json = source_json.get_child("syntax"); boost::property_tree::ptree syntax_json = source_json.get_child("syntax");
boost::property_tree::ptree colors_json = source_json.get_child("colors"); boost::property_tree::ptree colors_json = source_json.get_child("colors");
boost::property_tree::ptree extensions_json = source_json.get_child("extensions");
for (auto &i : colors_json) { for (auto &i : colors_json) {
source_cfg_.InsertTag(i.first, i.second.get_value<std::string>()); source_cfg_.InsertTag(i.first, i.second.get_value<std::string>());
} }
for (auto &i : syntax_json) { for (auto &i : syntax_json) {
source_cfg_.InsertType(i.first, i.second.get_value<std::string>()); source_cfg_.InsertType(i.first, i.second.get_value<std::string>());
} }
INFO("Source cfg generated"); for (auto &i : extensions_json) {
source_cfg_.InsertExtension(i.second.get_value<std::string>());
}
DEBUG("Source cfg fetched");
}
void MainConfig::GenerateTerminalCommands() {
boost::property_tree::ptree source_json = cfg_.get_child("project");
boost::property_tree::ptree compile_commands_json = source_json.get_child("compile_commands");
boost::property_tree::ptree run_commands_json = source_json.get_child("run_commands");
for (auto &i : compile_commands_json) {
terminal_cfg_.InsertCompileCommand(i.second.get_value<std::string>());
}
for (auto &i : run_commands_json) {
terminal_cfg_.SetRunCommand(i.second.get_value<std::string>());
}
} }
void MainConfig::GenerateKeybindings() { void MainConfig::GenerateKeybindings() {
INFO("Generating 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); keybindings_cfg_.AppendXml(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>(); keybindings_cfg_.key_map()[i.first] = i.second.get_value<std::string>();
INFO("Keybindings generated"); DEBUG("Keybindings fetched");
} }
void MainConfig::GenerateDirectoryFilter() { void MainConfig::GenerateDirectoryFilter() {
DEBUG("Fetching directory filter");
boost::property_tree::ptree dir_json = cfg_.get_child("directoryfilter"); boost::property_tree::ptree dir_json = cfg_.get_child("directoryfilter");
boost::property_tree::ptree ignore_json = dir_json.get_child("ignore"); boost::property_tree::ptree ignore_json = dir_json.get_child("ignore");
boost::property_tree::ptree except_json = dir_json.get_child("exceptions"); boost::property_tree::ptree except_json = dir_json.get_child("exceptions");
@ -49,6 +65,5 @@ void MainConfig::GenerateDirectoryFilter() {
dir_cfg_.AddException(i.second.get_value<std::string>()); dir_cfg_.AddException(i.second.get_value<std::string>());
for ( auto &i : ignore_json ) for ( auto &i : ignore_json )
dir_cfg_.AddIgnore(i.second.get_value<std::string>()); dir_cfg_.AddIgnore(i.second.get_value<std::string>());
DEBUG("Directory filter fetched");
} }

9
juci/config.h
Unescape View File

@ -1,3 +1,5 @@
#ifndef 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 <fstream>
@ -5,21 +7,26 @@
#include "keybindings.h" #include "keybindings.h"
#include "source.h" #include "source.h"
#include "directories.h" #include "directories.h"
#include "terminal.h"
class MainConfig { class MainConfig {
public: public:
MainConfig(); MainConfig();
Source::Config& source_cfg() { return source_cfg_; } Source::Config& source_cfg() { return source_cfg_; }
Keybindings::Config& keybindings_cfg() { return keybindings_cfg_; } Keybindings::Config& keybindings_cfg() { return keybindings_cfg_; }
Directories::Config& dir_cfg() { return dir_cfg_; } Directories::Config& dir_cfg() { return dir_cfg_; }
Terminal::Config& terminal_cfg() { return terminal_cfg_; }
void PrintMenu(); void PrintMenu();
void GenerateSource(); void GenerateSource();
void GenerateKeybindings(); void GenerateKeybindings();
void GenerateDirectoryFilter(); void GenerateDirectoryFilter();
void GenerateTerminalCommands();
private: private:
boost::property_tree::ptree cfg_; boost::property_tree::ptree cfg_;
boost::property_tree::ptree key_tree_; boost::property_tree::ptree key_tree_;
Source::Config source_cfg_; Source::Config source_cfg_;
Keybindings::Config keybindings_cfg_; Keybindings::Config keybindings_cfg_;
Directories::Config dir_cfg_; Directories::Config dir_cfg_;
Terminal::Config terminal_cfg_;
}; };
#endif

29
juci/config.json
Unescape View File

@ -16,7 +16,19 @@
"702": "keyword", "702": "keyword",
"703": "own", "703": "own",
"705": "comment" "705": "comment"
} },
"extensions": [
"c",
"cc",
"cpp",
"cxx",
"c++",
"h",
"hh",
"hpp",
"hxx",
"h++"
]
}, },
"keybindings": { "keybindings": {
"split_window": "<control><alt>s", "split_window": "<control><alt>s",
@ -27,7 +39,7 @@
"edit_undo": "<control>z", "edit_undo": "<control>z",
"save": "<control>s", "save": "<control>s",
"save_as": "<control><shift>s", "save_as": "<control><shift>s",
"compile_and_run": "<control><alt>r>", "compile_and_run": "<control><alt>r",
"compile": "<control>r" "compile": "<control>r"
}, },
"directoryfilter": { "directoryfilter": {
@ -43,7 +55,18 @@
"cmakelists.txt", "cmakelists.txt",
"in-lowercase.pls" "in-lowercase.pls"
] ]
}, },
"project": {
"run_commands": [
"./.build/"
],
"compile_commands": [
"rm -rf ./.build",
"mkdir ./.build",
"cmake -B./.build -H.",
"cd ./.build/; make"
]
},
"example": { "example": {
"key": "value", "key": "value",
"key2": [ "key2": [

179
juci/directories.cc
Unescape View File

@ -3,6 +3,7 @@
Directories::Controller::Controller(Directories::Config& cfg) : Directories::Controller::Controller(Directories::Config& cfg) :
config_(cfg) { config_(cfg) {
DEBUG("adding treeview to scrolledwindow");
m_ScrolledWindow.add(m_TreeView); m_ScrolledWindow.add(m_TreeView);
m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
} }
@ -13,18 +14,21 @@ open_folder(const boost::filesystem::path& dir_path) {
m_refTreeModel = Gtk::TreeStore::create(view()); m_refTreeModel = Gtk::TreeStore::create(view());
m_TreeView.set_model(m_refTreeModel); m_TreeView.set_model(m_refTreeModel);
m_TreeView.remove_all_columns(); m_TreeView.remove_all_columns();
DEBUG("Getting project name from CMakeLists.txt");
std::string project_name = GetCmakeVarValue(dir_path, "project"); std::string project_name = GetCmakeVarValue(dir_path, "project");
m_TreeView.append_column(project_name, view().m_col_name); m_TreeView.append_column(project_name, view().m_col_name);
int row_id = 0; int row_id = 0;
Gtk::TreeModel::Row row; Gtk::TreeModel::Row row;
DEBUG("Listing directories");
list_dirs(dir_path, row, row_id); list_dirs(dir_path, row, row_id);
DEBUG("Sorting directories");
m_refTreeModel->set_sort_column(0, Gtk::SortType::SORT_ASCENDING); m_refTreeModel->set_sort_column(0, Gtk::SortType::SORT_ASCENDING);
INFO("Folder opened"); DEBUG("Folder opened");
} }
bool Directories::Controller::IsIgnored(std::string path) { bool Directories::Controller::IsIgnored(std::string path) {
DEBUG("Checking if file-/directory is filtered");
std::transform(path.begin(), path.end(), path.begin(), ::tolower); std::transform(path.begin(), path.end(), path.begin(), ::tolower);
// std::cout << "ignored?: " << path << std::endl;
if (config().IsException(path)) { if (config().IsException(path)) {
return false; return false;
} }
@ -36,17 +40,18 @@ bool Directories::Controller::IsIgnored(std::string path) {
void Directories::Controller:: void Directories::Controller::
list_dirs(const boost::filesystem::path& dir_path, list_dirs(const boost::filesystem::path& dir_path,
Gtk::TreeModel::Row &parent, Gtk::TreeModel::Row &parent,
unsigned row_id) { unsigned row_id) {
boost::filesystem::directory_iterator end_itr; boost::filesystem::directory_iterator end_itr;
unsigned dir_counter = row_id; unsigned dir_counter = row_id;
unsigned file_counter = 0; unsigned file_counter = 0;
Gtk::TreeModel::Row child; Gtk::TreeModel::Row child;
Gtk::TreeModel::Row row; Gtk::TreeModel::Row row;
DEBUG("");
// Fill the treeview // Fill the treeview
for ( boost::filesystem::directory_iterator itr( dir_path ); for ( boost::filesystem::directory_iterator itr( dir_path );
itr != end_itr; itr != end_itr;
++itr ) { ++itr ) {
if (!IsIgnored(itr->path().filename().string())) { if (!IsIgnored(itr->path().filename().string())) {
if (boost::filesystem::is_directory(itr->status())) { if (boost::filesystem::is_directory(itr->status())) {
if (count(itr->path().string()) > count(dir_path.string())) { // is child if (count(itr->path().string()) > count(dir_path.string())) { // is child
@ -74,107 +79,109 @@ list_dirs(const boost::filesystem::path& dir_path,
} }
} }
} }
int Directories::Controller::count(const std::string path) { int Directories::Controller::count(const std::string path) {
int count = 0; int count = 0;
for (int i = 0; i < path.size(); i++) for (int i = 0; i < path.size(); i++)
if (path[i] == '/') count++; if (path[i] == '/')
count++;
return count; return count;
} }
std::string Directories::Controller:: std::string Directories::Controller::
GetCmakeVarValue(const boost::filesystem::path& dir_path, std::string command_name) { GetCmakeVarValue(const boost::filesystem::path& dir_path, std::string command_name) {
INFO("fetches cmake variable value for: "+command_name); INFO("fetches cmake variable value for: "+command_name);
std::string project_name; std::string project_name;
std::string project_name_var; std::string project_name_var;
boost::filesystem::directory_iterator end_itr; boost::filesystem::directory_iterator end_itr;
for (boost::filesystem::directory_iterator itr( dir_path ); for (boost::filesystem::directory_iterator itr( dir_path );
itr != end_itr; itr != end_itr;
++itr ) { ++itr ) {
if (itr->path().filename().string() == "CMakeLists.txt") { if (itr->path().filename().string() == "CMakeLists.txt") {
std::ifstream ifs(itr->path().string()); std::ifstream ifs(itr->path().string());
std::string line; std::string line;
while (std::getline(ifs, line)) { while (std::getline(ifs, line)) {
if (line.find(command_name+"(", 0) != std::string::npos if (line.find(command_name+"(", 0) != std::string::npos
|| line.find(command_name+" (", 0) != std::string::npos ) { || line.find(command_name+" (", 0) != std::string::npos ) {
size_t variable_start = line.find("{", 0); size_t variable_start = line.find("{", 0);
size_t variable_end = line.find("}", variable_start); size_t variable_end = line.find("}", variable_start);
project_name_var = line.substr(variable_start+1, project_name_var = line.substr(variable_start+1,
(variable_end)-variable_start-1); (variable_end)-variable_start-1);
boost::algorithm::trim(project_name_var); boost::algorithm::trim(project_name_var);
if (variable_start == std::string::npos) { // not a variabel if (variable_start == std::string::npos) { // not a variabel
variable_start = line.find("(", 0); variable_start = line.find("(", 0);
variable_end = line.find(' ', variable_start); variable_end = line.find(' ', variable_start);
if(variable_end != std::string::npos){ if(variable_end != std::string::npos){
return line.substr(variable_start+1, return line.substr(variable_start+1,
(variable_end)-variable_start-1); (variable_end)-variable_start-1);
} }
variable_end = line.find("#", variable_start); variable_end = line.find("#", variable_start);
if(variable_end != std::string::npos){ if(variable_end != std::string::npos){
return line.substr(variable_start+1, return line.substr(variable_start+1,
(variable_end)-variable_start-1); (variable_end)-variable_start-1);
} }
variable_end = line.find(")", variable_start); variable_end = line.find(")", variable_start);
return line.substr(variable_start+1,
(variable_end)-variable_start-1);
if (variable_start == std::string::npos) { // not a variable
variable_start = line.find("(", 0);
variable_end = line.find(")", variable_start);
INFO("Wasn't a variable, returning value");
return line.substr(variable_start+1, return line.substr(variable_start+1,
(variable_end)-variable_start-1); (variable_end)-variable_start-1);
if (variable_start == std::string::npos) { // not a variable
variable_start = line.find("(", 0);
variable_end = line.find(")", variable_start);
INFO("Wasn't a variable, returning value");
return line.substr(variable_start+1,
(variable_end)-variable_start-1);
} }
break; break;
} }
} }
} }
std::ifstream ifs2(itr->path().string()); std::ifstream ifs2(itr->path().string());
while (std::getline(ifs2, line)) { while (std::getline(ifs2, line)) {
if (line.find("set(", 0) != std::string::npos if (line.find("set(", 0) != std::string::npos
|| line.find("set (", 0) != std::string::npos) { || line.find("set (", 0) != std::string::npos) {
if( line.find(project_name_var, 0) != std::string::npos) { if( line.find(project_name_var, 0) != std::string::npos) {
size_t variable_start = line.find(project_name_var, 0) size_t variable_start = line.find(project_name_var, 0)
+project_name_var.length(); +project_name_var.length();
size_t variable_end = line.find(")", variable_start); size_t variable_end = line.find(")", variable_start);
project_name = line.substr(variable_start+1, project_name = line.substr(variable_start+1,
variable_end-variable_start-1); variable_end-variable_start-1);
boost::algorithm::trim(project_name); boost::algorithm::trim(project_name);
INFO("found variable, returning value"); INFO("found variable, returning value");
return project_name; return project_name;
}
} }
} }
break;
} }
break;
} }
INFO("Couldn't find value in CMakeLists.txt");
return "no project name";
} }
INFO("Couldn't find value in CMakeLists.txt");
return "no project name";
}
Directories::Config::Config() { Directories::Config::Config() {
} }
Directories::Config::Config(Directories::Config& cfg) : Directories::Config::Config(Directories::Config& cfg) :
ignore_list_(cfg.ignore_list()), exception_list_(cfg.exception_list()) { ignore_list_(cfg.ignore_list()), exception_list_(cfg.exception_list()) {
} }
void Directories::Config::AddIgnore(std::string filter) { void Directories::Config::AddIgnore(std::string filter) {
ignore_list_.push_back(filter); ignore_list_.push_back(filter);
} }
void Directories::Config::AddException(std::string filter) { void Directories::Config::AddException(std::string filter) {
exception_list_.push_back(filter); exception_list_.push_back(filter);
} }
bool Directories::Config::IsIgnored(std::string str) { bool Directories::Config::IsIgnored(std::string str) {
for ( auto &i : ignore_list() ) for ( auto &i : ignore_list() )
if (str.find(i, 0) != std::string::npos) if (str.find(i, 0) != std::string::npos)
return true; return true;
return false; return false;
} }
bool Directories::Config::IsException(std::string str) { bool Directories::Config::IsException(std::string str) {
for ( std::string &i : exception_list() ) for ( std::string &i : exception_list() )
if (i == str) if (i == str)
return true; return true;
return false; return false;
} }

2
juci/keybindings.h
Unescape View File

@ -15,7 +15,7 @@ namespace Keybindings {
Config(); Config();
std::string& menu_xml() { return menu_xml_; } std::string& menu_xml() { return menu_xml_; }
std::unordered_map<std::string, std::string>& key_map() { return key_map_; } std::unordered_map<std::string, std::string>& key_map() { return key_map_; }
void AppendXml(std::string &child); void AppendXml(std::string &child);
void SetMenu(std::string &menu_xml); void SetMenu(std::string &menu_xml);
void SetKeyMap(std::unordered_map<std::string, std::string> &key_map); void SetKeyMap(std::unordered_map<std::string, std::string> &key_map);
private: private:

103
juci/notebook.cc
Unescape View File

@ -1,10 +1,10 @@
#include <fstream>
#include "notebook.h" #include "notebook.h"
#include "logging.h" #include "logging.h"
#include <fstream>
Notebook::Model::Model() { Notebook::Model::Model() {
cc_extension_ = ".cc"; cc_extension_ = ".cpp";
h_extension_ = ".h"; h_extension_ = ".hpp";
scrollvalue_ = 50; scrollvalue_ = 50;
} }
@ -13,10 +13,10 @@ Notebook::View::View() : notebook_() {
view_.set_position(120); view_.set_position(120);
} }
Notebook::Controller::Controller(Gtk::Window* window, Keybindings::Controller& keybindings, Notebook::Controller::Controller(Gtk::Window* window,
Keybindings::Controller& keybindings,
Source::Config& source_cfg, Source::Config& source_cfg,
Directories::Config& dir_cfg) : Directories::Config& dir_cfg) :
source_config_(source_cfg),
directories_(dir_cfg), directories_(dir_cfg),
index_(0, 1) { index_(0, 1) {
INFO("Create notebook"); INFO("Create notebook");
@ -25,12 +25,15 @@ Notebook::Controller::Controller(Gtk::Window* window, Keybindings::Controller& k
refClipboard_ = Gtk::Clipboard::get(); refClipboard_ = Gtk::Clipboard::get();
ispopup = false; ispopup = false;
view().pack1(directories_.widget(), true, true); view().pack1(directories_.widget(), true, true);
source_config_ = source_cfg;
CreateKeybindings(keybindings); CreateKeybindings(keybindings);
INFO("Notebook Controller Success");
} // Constructor } // Constructor
void Notebook::Controller::CreateKeybindings(Keybindings::Controller void Notebook::Controller::CreateKeybindings(Keybindings::Controller
&keybindings) { &keybindings) {
INFO("Notebook create signal handlers");
directories().m_TreeView.signal_row_activated() directories().m_TreeView.signal_row_activated()
.connect(sigc::mem_fun(*this, .connect(sigc::mem_fun(*this,
&Notebook::Controller::OnDirectoryNavigation)); &Notebook::Controller::OnDirectoryNavigation));
@ -140,6 +143,7 @@ void Notebook::Controller::CreateKeybindings(Keybindings::Controller
[this]() { [this]() {
Search(false); Search(false);
}); });
INFO("Notebook signal handlers sucsess");
} }
bool Notebook::Controller:: OnMouseRelease(GdkEventButton* button) { bool Notebook::Controller:: OnMouseRelease(GdkEventButton* button) {
@ -155,6 +159,9 @@ bool Notebook::Controller::OnKeyRelease(GdkEventKey* key) {
} }
bool Notebook::Controller::GeneratePopup(int key_id) { bool Notebook::Controller::GeneratePopup(int key_id) {
INFO("Notebook genereate popup, getting iters");
std::string path = text_vec_.at(CurrentPage())->path();
if (!LegalExtension(path.substr(path.find_last_of(".") + 1))) return false;
// Get function to fill popup with suggests item vector under is for testing // Get function to fill popup with suggests item vector under is for testing
Gtk::TextIter beg = CurrentTextView().get_buffer()->get_insert()->get_iter(); Gtk::TextIter beg = CurrentTextView().get_buffer()->get_insert()->get_iter();
Gtk::TextIter end = CurrentTextView().get_buffer()->get_insert()->get_iter(); Gtk::TextIter end = CurrentTextView().get_buffer()->get_insert()->get_iter();
@ -167,6 +174,7 @@ bool Notebook::Controller::GeneratePopup(int key_id) {
end.backward_search("\"", Gtk::TEXT_SEARCH_VISIBLE_ONLY, tmp, tmp1, line) end.backward_search("\"", Gtk::TEXT_SEARCH_VISIBLE_ONLY, tmp, tmp1, line)
|| ||
end.backward_search("//", Gtk::TEXT_SEARCH_VISIBLE_ONLY, tmp, tmp1, line); end.backward_search("//", Gtk::TEXT_SEARCH_VISIBLE_ONLY, tmp, tmp1, line);
INFO("Notebook genereate popup, checking key_id");
if (illegal_chars) { if (illegal_chars) {
return false; return false;
} }
@ -189,6 +197,7 @@ bool Notebook::Controller::GeneratePopup(int key_id) {
} else { } else {
return false; return false;
} }
INFO("Notebook genereate popup, getting autocompletions");
std::vector<Source::AutoCompleteData> acdata; std::vector<Source::AutoCompleteData> acdata;
text_vec_.at(CurrentPage())-> text_vec_.at(CurrentPage())->
GetAutoCompleteSuggestions(beg.get_line()+1, GetAutoCompleteSuggestions(beg.get_line()+1,
@ -229,16 +238,19 @@ bool Notebook::Controller::GeneratePopup(int key_id) {
popup_.get_vbox()->pack_start(popup_scroll_); popup_.get_vbox()->pack_start(popup_scroll_);
popup_.set_transient_for(*window_); popup_.set_transient_for(*window_);
popup_.show_all(); popup_.show_all();
INFO("Notebook genereate popup, moving popup");
int popup_x = popup_.get_width(); int popup_x = popup_.get_width();
int popup_y = items.size() * 20; int popup_y = items.size() * 20;
PopupSetSize(popup_scroll_, popup_x, popup_y); PopupSetSize(popup_scroll_, popup_x, popup_y);
int x, y; int x, y;
FindPopupPosition(CurrentTextView(), popup_x, popup_y, x, y); FindPopupPosition(CurrentTextView(), popup_x, popup_y, x, y);
popup_.move(x, y+15); popup_.move(x, y+15);
INFO("Notebook genereate popup, create handler");
PopupSelectHandler(popup_, listview_, &items); PopupSelectHandler(popup_, listview_, &items);
ispopup = true; ispopup = true;
INFO("Notebook genereate popup, run popup");
popup_.run(); popup_.run();
INFO("Notebook genereate popup, hide popup");
popup_.hide(); popup_.hide();
ispopup = false; ispopup = false;
return true; return true;
@ -261,7 +273,8 @@ bool Notebook::Controller::ScrollEventCallback(GdkEventScroll* scroll_event) {
return true; return true;
} }
Notebook::Controller::~Controller() { Notebook::Controller::~Controller() {
for (auto &i : text_vec_) delete i; INFO("Notebook destructor");
for (auto &i : text_vec_) delete i;
for (auto &i : linenumbers_vec_) delete i; for (auto &i : linenumbers_vec_) delete i;
for (auto &i : editor_vec_) delete i; for (auto &i : editor_vec_) delete i;
for (auto &i : scrolledtext_vec_) delete i; for (auto &i : scrolledtext_vec_) delete i;
@ -276,6 +289,7 @@ Gtk::Box& Notebook::Controller::entry_view() {
} }
void Notebook::Controller::OnNewPage(std::string name) { void Notebook::Controller::OnNewPage(std::string name) {
INFO("Notebook Generate new page");
OnCreatePage(); OnCreatePage();
text_vec_.back()->OnNewEmptyFile(); text_vec_.back()->OnNewEmptyFile();
Notebook().append_page(*editor_vec_.back(), name); Notebook().append_page(*editor_vec_.back(), name);
@ -294,6 +308,7 @@ MapBuffers(std::map<std::string, std::string> *buffers) {
} }
void Notebook::Controller::OnOpenFile(std::string path) { void Notebook::Controller::OnOpenFile(std::string path) {
INFO("Notebook open file");
OnCreatePage(); OnCreatePage();
text_vec_.back()->OnOpenFile(path); text_vec_.back()->OnOpenFile(path);
text_vec_.back()->set_is_saved(true); text_vec_.back()->set_is_saved(true);
@ -303,12 +318,11 @@ void Notebook::Controller::OnOpenFile(std::string path) {
Notebook().set_current_page(Pages()-1); Notebook().set_current_page(Pages()-1);
Notebook().set_focus_child(text_vec_.back()->view()); Notebook().set_focus_child(text_vec_.back()->view());
OnBufferChange(); OnBufferChange();
text_vec_.back()->set_is_changed(false);
} }
void Notebook::Controller::OnCreatePage() { void Notebook::Controller::OnCreatePage() {
INFO("Notebook create page");
text_vec_.push_back(new Source::Controller(source_config(), this)); text_vec_.push_back(new Source::Controller(source_config(), this));
linenumbers_vec_.push_back(new Source::Controller(source_config(), this)); linenumbers_vec_.push_back(new Source::Controller(source_config(), this));
scrolledline_vec_.push_back(new Gtk::ScrolledWindow()); scrolledline_vec_.push_back(new Gtk::ScrolledWindow());
@ -329,9 +343,11 @@ void Notebook::Controller::OnCreatePage() {
} }
void Notebook::Controller::OnCloseCurrentPage() { void Notebook::Controller::OnCloseCurrentPage() {
// TODO(oyvang) zalox, forgi) INFO("Notebook close page");
// Save a temp file, in case you close one you dont want to close?
if (Pages() != 0) { if (Pages() != 0) {
if(text_vec_.back()->is_changed()){
AskToSaveDialog();
}
int page = CurrentPage(); int page = CurrentPage();
Notebook().remove_page(page); Notebook().remove_page(page);
delete text_vec_.at(page); delete text_vec_.at(page);
@ -372,6 +388,7 @@ void Notebook::Controller::OnEditCut() {
} }
std::string Notebook::Controller::GetCursorWord() { std::string Notebook::Controller::GetCursorWord() {
INFO("Notebook get cursor word");
int page = CurrentPage(); int page = CurrentPage();
std::string word; std::string word;
Gtk::TextIter start, end; Gtk::TextIter start, end;
@ -399,6 +416,7 @@ void Notebook::Controller::OnEditSearch() {
} }
void Notebook::Controller::Search(bool forward) { void Notebook::Controller::Search(bool forward) {
INFO("Notebook search");
int page = CurrentPage(); int page = CurrentPage();
std::string search_word; std::string search_word;
search_word = entry_.text(); search_word = entry_.text();
@ -456,10 +474,12 @@ void Notebook::Controller::OnBufferChange() {
ScrollEventCallback(scroll); ScrollEventCallback(scroll);
delete scroll; delete scroll;
} }
text_vec_.at(page)->set_is_changed(true);
} }
void Notebook::Controller void Notebook::Controller
::OnDirectoryNavigation(const Gtk::TreeModel::Path& path, ::OnDirectoryNavigation(const Gtk::TreeModel::Path& path,
Gtk::TreeViewColumn* column) { Gtk::TreeViewColumn* column) {
INFO("Notebook directory navigation");
Gtk::TreeModel::iterator iter = directories().m_refTreeModel->get_iter(path); Gtk::TreeModel::iterator iter = directories().m_refTreeModel->get_iter(path);
if (iter) { if (iter) {
Gtk::TreeModel::Row row = *iter; Gtk::TreeModel::Row row = *iter;
@ -539,6 +559,7 @@ void Notebook::Controller::PopupSelectHandler(Gtk::Dialog &popup,
void Notebook::Controller::PopupSetSize(Gtk::ScrolledWindow &scroll, void Notebook::Controller::PopupSetSize(Gtk::ScrolledWindow &scroll,
int &current_x, int &current_x,
int &current_y) { int &current_y) {
INFO("Notebook popup set size");
int textview_x = CurrentTextView().get_width(); int textview_x = CurrentTextView().get_width();
int textview_y = 150; int textview_y = 150;
bool is_never_scroll_x = true; bool is_never_scroll_x = true;
@ -573,6 +594,7 @@ void Notebook::Controller::FindPopupPosition(Gtk::TextView& textview,
int popup_y, int popup_y,
int &x, int &x,
int &y) { int &y) {
INFO("Notebook popup find position");
Gdk::Rectangle temp1, temp2; Gdk::Rectangle temp1, temp2;
textview.get_cursor_locations( textview.get_cursor_locations(
CurrentTextView(). CurrentTextView().
@ -602,6 +624,7 @@ void Notebook::Controller::FindPopupPosition(Gtk::TextView& textview,
} }
void Notebook::Controller:: OnSaveFile() { void Notebook::Controller:: OnSaveFile() {
INFO("Notebook save file");
if (text_vec_.at(CurrentPage())->is_saved()) { if (text_vec_.at(CurrentPage())->is_saved()) {
std::ofstream file; std::ofstream file;
file.open (text_vec_.at(CurrentPage())->path()); file.open (text_vec_.at(CurrentPage())->path());
@ -622,16 +645,23 @@ void Notebook::Controller:: OnSaveFile() {
std::string Notebook::Controller::OnSaveFileAs(){ std::string Notebook::Controller::OnSaveFileAs(){
Gtk::FileChooserDialog dialog("Please choose a file", INFO("Notebook save as");
Gtk::FileChooserDialog dialog("Please choose a file",
Gtk::FILE_CHOOSER_ACTION_SAVE); Gtk::FILE_CHOOSER_ACTION_SAVE);
DEBUG("SET TRANSISTEN FPR");
dialog.set_transient_for(*window_); dialog.set_transient_for(*window_);
dialog.set_position(Gtk::WindowPosition::WIN_POS_CENTER_ALWAYS); dialog.set_position(Gtk::WindowPosition::WIN_POS_CENTER_ALWAYS);
dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL); dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
dialog.add_button("_Save", Gtk::RESPONSE_OK); dialog.add_button("_Save", Gtk::RESPONSE_OK);
//dialog.set_current_name("Untitled");
DEBUG("RUN DIALOG");
int result = dialog.run(); int result = dialog.run();
DEBUG("DIALOG RUNNING");
switch (result) { switch (result) {
case(Gtk::RESPONSE_OK): { case(Gtk::RESPONSE_OK): {
DEBUG("get_filename()");
std::string path = dialog.get_filename(); std::string path = dialog.get_filename();
DEBUG_VAR(path);
unsigned pos = path.find_last_of("/\\"); unsigned pos = path.find_last_of("/\\");
std::cout << path<< std::endl; std::cout << path<< std::endl;
//notebook_.OnSaveFile(path); //notebook_.OnSaveFile(path);
@ -649,3 +679,50 @@ std::string Notebook::Controller::OnSaveFileAs(){
return ""; return "";
} }
void Notebook::Controller::AskToSaveDialog() {
INFO("AskToSaveDialog");
DEBUG("AskToSaveDialog: Finding file path");
Gtk::MessageDialog dialog(*window_, "Save file!",
false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_YES_NO);
dialog.set_secondary_text(
"Do you want to save: " +
text_vec_.at(CurrentPage())->path()+" ?");
DEBUG("AskToSaveDialog: run dialog");
int result = dialog.run();
//Handle the response:
DEBUG("AskToSaveDialog: switch response");
switch(result)
{
case(Gtk::RESPONSE_YES):
{
DEBUG("AskToSaveDialog: save file: yes, trying to save file");
OnSaveFile();
DEBUG("AskToSaveDialog: save file: yes, saved sucess");
break;
}
case(Gtk::RESPONSE_NO):
{
DEBUG("AskToSaveDialog: save file: no");
break;
}
default:
{
DEBUG("AskToSaveDialog: unexpected action: Default switch");
break;
}
}
}
bool Notebook::Controller::LegalExtension(std::string e) {
std::transform(e.begin(), e.end(),e.begin(), ::tolower);
std::vector<std::string> extensions =
source_config().extensiontable();
if (find(extensions.begin(), extensions.end(), e) != extensions.end()) {
DEBUG("Legal extension");
return true;
}
DEBUG("Ilegal extension");
return false;
}

4
juci/notebook.h
Unescape View File

@ -68,7 +68,7 @@ namespace Notebook {
Gtk::Paned& view(); Gtk::Paned& view();
bool GeneratePopup(int key); bool GeneratePopup(int key);
void Search(bool forward); void Search(bool forward);
const Source::Config& source_config() { return source_config_; } Source::Config& source_config() { return source_config_; }
bool OnMouseRelease(GdkEventButton* button); bool OnMouseRelease(GdkEventButton* button);
bool OnKeyRelease(GdkEventKey* key); bool OnKeyRelease(GdkEventKey* key);
std::string OnSaveFileAs(); std::string OnSaveFileAs();
@ -88,6 +88,8 @@ namespace Notebook {
void PopupSetSize(Gtk::ScrolledWindow& scroll, void PopupSetSize(Gtk::ScrolledWindow& scroll,
int &current_x, int &current_x,
int &current_y); int &current_y);
void AskToSaveDialog();
bool LegalExtension(std::string extension);
Glib::RefPtr<Gtk::Builder> m_refBuilder; Glib::RefPtr<Gtk::Builder> m_refBuilder;
Glib::RefPtr<Gio::SimpleActionGroup> refActionGroup; Glib::RefPtr<Gio::SimpleActionGroup> refActionGroup;
Source::Config source_config_; Source::Config source_config_;

105
juci/source.cc
Unescape View File

@ -70,9 +70,18 @@ const std::unordered_map<string, string>& Source::Config::typetable() const {
return typetable_; return typetable_;
} }
std::vector<string>& Source::Config::extensiontable(){
return extensiontable_;
}
void Source::Config::InsertTag(const string &key, const string &value) { void Source::Config::InsertTag(const string &key, const string &value) {
tagtable_[key] = value; tagtable_[key] = value;
} }
void Source::Config::InsertExtension(const string &ext) {
extensiontable_.push_back(ext);
}
// Source::View::Config::SetTagTable() // Source::View::Config::SetTagTable()
// sets the tagtable for the view // sets the tagtable for the view
void Source::Config:: void Source::Config::
@ -295,21 +304,6 @@ string extract_file_path(const std::string &file_path) {
return file_path.substr(0, file_path.find_last_of('/')); return file_path.substr(0, file_path.find_last_of('/'));
} }
std::vector<std::string> extentions() {
return {".h", ".cc", ".cpp", ".hpp"};
}
bool check_extention(const std::string &file_path) {
std::string extention = file_path.substr(file_path.find_last_of('.'),
file_path.size());
for (auto &ex : extentions()) {
if (extention == ex) {
return true;
}
}
return false;
}
void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges, void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges,
const Source::Config &config) { const Source::Config &config) {
if (ranges.empty() || ranges.size() == 0) { if (ranges.empty() || ranges.size() == 0) {
@ -335,8 +329,8 @@ void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges,
buffer->get_iter_at_line_offset(linum_start, begin); buffer->get_iter_at_line_offset(linum_start, begin);
Gtk::TextIter end_iter = Gtk::TextIter end_iter =
buffer->get_iter_at_line_offset(linum_end, end); buffer->get_iter_at_line_offset(linum_end, end);
buffer->apply_tag_by_name(config.typetable().at(type), buffer->apply_tag_by_name(config.typetable().at(type),
begin_iter, end_iter); begin_iter, end_iter);
} }
} }
@ -349,7 +343,7 @@ void Source::Controller::OnOpenFile(const string &filepath) {
buffer()->set_text(s.get_content()); buffer()->set_text(s.get_content());
int start_offset = buffer()->begin().get_offset(); int start_offset = buffer()->begin().get_offset();
int end_offset = buffer()->end().get_offset(); int end_offset = buffer()->end().get_offset();
if (check_extention(filepath)) { if (!notebook_->LegalExtension(filepath.substr(filepath.find_last_of(".") + 1))) {
view().ApplyConfig(model().config()); view().ApplyConfig(model().config());
model().InitSyntaxHighlighting(filepath, model().InitSyntaxHighlighting(filepath,
extract_file_path(filepath), extract_file_path(filepath),
@ -359,46 +353,45 @@ void Source::Controller::OnOpenFile(const string &filepath) {
notebook_->index()); notebook_->index());
view().OnUpdateSyntax(model().ExtractTokens(start_offset, end_offset), view().OnUpdateSyntax(model().ExtractTokens(start_offset, end_offset),
model().config()); model().config());
buffer()->signal_end_user_action().connect([this]() {
buffer()->signal_end_user_action().connect([this]() { if (!go) {
if (!go) { std::thread parse([this]() {
std::thread parse([this]() { if (parsing.try_lock()) {
if (parsing.try_lock()) { INFO("Starting parsing");
INFO("Starting parsing"); while (true) {
while (true) { const std::string raw = buffer()->get_text().raw();
const std::string raw = buffer()->get_text().raw(); std::map<std::string, std::string> buffers;
std::map<std::string, std::string> buffers; notebook_->MapBuffers(&buffers);
notebook_->MapBuffers(&buffers); buffers[model().file_path()] = raw;
buffers[model().file_path()] = raw; if (model().ReParse(buffers) == 0 &&
if (model().ReParse(buffers) == 0 && raw == buffer()->get_text().raw()) {
raw == buffer()->get_text().raw()) { syntax.lock();
syntax.lock(); go = true;
go = true; syntax.unlock();
syntax.unlock(); break;
break; }
} }
parsing.unlock();
INFO("Parsing completed");
} }
parsing.unlock(); });
INFO("Parsing completed"); parse.detach();
} }
}); });
parse.detach();
} buffer()->signal_begin_user_action().connect([this]() {
}); if (go) {
syntax.lock();
buffer()->signal_begin_user_action().connect([this]() { INFO("Updating syntax");
if (go) { view().
syntax.lock(); OnUpdateSyntax(model().ExtractTokens(0, buffer()->get_text().size()),
INFO("Updating syntax"); model().config());
view(). go = false;
OnUpdateSyntax(model().ExtractTokens(0, buffer()->get_text().size()), INFO("Syntax updated");
model().config()); syntax.unlock();
go = false; }
INFO("Syntax updated"); });
syntax.unlock();
}
});
} }
} }
Glib::RefPtr<Gtk::TextBuffer> Source::Controller::buffer() { Glib::RefPtr<Gtk::TextBuffer> Source::Controller::buffer() {

9
juci/source.h
Unescape View File

@ -20,16 +20,19 @@ namespace Source {
Config(); Config();
const std::unordered_map<std::string, std::string>& tagtable() const; const std::unordered_map<std::string, std::string>& tagtable() const;
const std::unordered_map<std::string, std::string>& typetable() const; const std::unordered_map<std::string, std::string>& typetable() const;
std::vector<std::string>& extensiontable();
void SetTagTable(const std::unordered_map<std::string, std::string> void SetTagTable(const std::unordered_map<std::string, std::string>
&tagtable); &tagtable);
void InsertTag(const std::string &key, const std::string &value); void InsertTag(const std::string &key, const std::string &value);
void SetTypeTable(const std::unordered_map<std::string, std::string> void SetTypeTable(const std::unordered_map<std::string, std::string>
&tagtable); &tagtable);
void InsertType(const std::string &key, const std::string &value); void InsertType(const std::string &key, const std::string &value);
void InsertExtension(const std::string &ext);
std::vector<std::string> extensiontable_;
private: private:
std::unordered_map<std::string, std::string> tagtable_; std::unordered_map<std::string, std::string> tagtable_;
std::unordered_map<std::string, std::string> typetable_; std::unordered_map<std::string, std::string> typetable_;
std::string background_; std::string background_;
}; // class Config }; // class Config
@ -150,10 +153,11 @@ namespace Source {
*suggestions); *suggestions);
Glib::RefPtr<Gtk::TextBuffer> buffer(); Glib::RefPtr<Gtk::TextBuffer> buffer();
bool is_saved() { return is_saved_; } bool is_saved() { return is_saved_; }
bool is_changed() { return is_changed_; }
std::string path() { return model().file_path(); } std::string path() { return model().file_path(); }
void set_is_saved(bool isSaved) { is_saved_ = isSaved; } void set_is_saved(bool isSaved) { is_saved_ = isSaved; }
void set_is_changed(bool isChanged) { is_changed_ = isChanged; }
void set_file_path(std::string path) { model().set_file_path(path); } void set_file_path(std::string path) { model().set_file_path(path); }
private: private:
void OnLineEdit(); void OnLineEdit();
@ -162,6 +166,7 @@ namespace Source {
std::mutex parsing; std::mutex parsing;
bool go = false; bool go = false;
bool is_saved_ = false; bool is_saved_ = false;
bool is_changed_ = false;
protected: protected:
View view_; View view_;

58
juci/terminal.cc
Unescape View File

@ -1,10 +1,26 @@
#include "terminal.h" #include "terminal.h"
#include <iostream> #include <iostream>
#include <thread> #include <thread>
// #include <pstream.h> #include "logging.h"
// #include <string>
Terminal::Config::Config() {
}
Terminal::Config::Config(Terminal::Config& original) :
run_command_(original.run_command_){
for (auto it = 0; it<original.compile_commands().size(); ++it) {
InsertCompileCommand(original.compile_commands().at(it));
}
}
void Terminal::Config::InsertCompileCommand(std::string command){
compile_commands_.push_back(command);
}
void Terminal::Config::SetRunCommand(std::string command){
run_command_ = command;
}
Terminal::View::View(){ Terminal::View::View(){
scrolledwindow_.add(textview_); scrolledwindow_.add(textview_);
scrolledwindow_.set_size_request(-1,150); scrolledwindow_.set_size_request(-1,150);
@ -13,36 +29,51 @@ Terminal::View::View(){
} }
Terminal::Controller::Controller() { Terminal::Controller::Controller(Terminal::Config& cfg) :
config_(cfg) {
folder_command_ = ""; folder_command_ = "";
} }
void Terminal::Controller::SetFolderCommand( boost::filesystem::path void Terminal::Controller::SetFolderCommand( boost::filesystem::path
CMake_path) { CMake_path) {
INFO("Terminal: SetFolderCommand");
path_ = CMake_path.string(); path_ = CMake_path.string();
folder_command_ = "cd "+ path_ + "; "; folder_command_ = "cd "+ path_ + "; ";
} }
void Terminal::Controller::Compile(){ void Terminal::Controller::Compile(){
INFO("Terminal: Compile");
Terminal().get_buffer()->set_text(""); Terminal().get_buffer()->set_text("");
ExecuteCommand("cmake .", "r"); DEBUG("Terminal: Compile: running cmake command");
if (ExistInConsole(cmake_sucsess)){ std::vector<std::string> commands = config().compile_commands();
ExecuteCommand("make", "r"); for (auto it = 0; it < commands.size(); ++it) {
} ExecuteCommand(commands.at(it), "r");
}
PrintMessage("\n");
DEBUG("Terminal: Compile: compile done");
} }
void Terminal::Controller::Run(std::string executable) { void Terminal::Controller::Run(std::string executable) {
INFO("Terminal: Run");
PrintMessage("juCi++ execute: " + executable + "\n"); PrintMessage("juCi++ execute: " + executable + "\n");
ExecuteCommand("./"+executable, "r"); DEBUG("Terminal: Compile: running run command: ");
DEBUG_VAR(executable);
ExecuteCommand("cd "+config().run_command() + "; ./"+executable, "r");
PrintMessage("\n");
} }
void Terminal::Controller::PrintMessage(std::string message){ void Terminal::Controller::PrintMessage(std::string message){
INFO("Terminal: PrintMessage");
Terminal().get_buffer()-> Terminal().get_buffer()->
insert(Terminal().get_buffer()-> end(),"> "+message); insert(Terminal().get_buffer()-> end(),"> "+message);
} }
bool Terminal::Controller::ExistInConsole(std::string string) { bool Terminal::Controller::ExistInConsole(std::string string) {
INFO("Terminal: ExistInConsole");
DEBUG("Terminal: PrintMessage: finding string in buffer");
double pos = Terminal().get_buffer()-> double pos = Terminal().get_buffer()->
get_text().find(string); get_text().find(string);
if (pos == std::string::npos) return false; if (pos == std::string::npos) return false;
@ -50,17 +81,22 @@ bool Terminal::Controller::ExistInConsole(std::string string) {
} }
void Terminal::Controller::ExecuteCommand(std::string command, std::string mode) { void Terminal::Controller::ExecuteCommand(std::string command, std::string mode) {
INFO("Terminal: ExecuteCommand");
command = folder_command_+command; command = folder_command_+command;
std::cout << "EXECUTE COMMAND: "<< command << std::endl; DEBUG("Terminal: PrintMessage: Running command");
FILE* p = popen(command.c_str(), mode.c_str()); FILE* p = NULL;
std::cout << command << std::endl;
p = popen(command.c_str(), mode.c_str());
std::cout << "KJØRTE FINT!" << std::endl;
if (p == NULL) { if (p == NULL) {
PrintMessage("juCi++ ERROR: Failed to run command" + command + "\n"); PrintMessage("juCi++ ERROR: Failed to run command" + command + "\n");
}else { }else {
std::cout << "SKRIVER UT KOMMANDO RESULAT" << std::endl;
char buffer[1028]; char buffer[1028];
while (fgets(buffer, 1028, p) != NULL) { while (fgets(buffer, 1028, p) != NULL) {
PrintMessage(buffer); PrintMessage(buffer);
} }
pclose(p); pclose(p);
} }
} }

17
juci/terminal.h
Unescape View File

@ -7,6 +7,19 @@
namespace Terminal { namespace Terminal {
class Config {
public:
Config ();
Config(Terminal::Config& original);
std::vector<std::string>& compile_commands() { return compile_commands_; }
void InsertCompileCommand(std::string command);
std::string& run_command() { return run_command_; }
void SetRunCommand(std::string command);
private:
std::vector<std::string> compile_commands_;
std::string run_command_;
};
class View { class View {
public: public:
View(); View();
@ -20,13 +33,15 @@ namespace Terminal {
class Controller { class Controller {
public: public:
Controller(); Controller(Terminal::Config& cfg);
Gtk::HBox& view() {return view_.view();} Gtk::HBox& view() {return view_.view();}
Gtk::TextView& Terminal(){return view_.textview();} Gtk::TextView& Terminal(){return view_.textview();}
void SetFolderCommand(boost::filesystem::path CMake_path); void SetFolderCommand(boost::filesystem::path CMake_path);
void Run(std::string executable); void Run(std::string executable);
void Compile(); void Compile();
Terminal::Config& config() { return config_; }
private: private:
Terminal::Config config_;
void ExecuteCommand(std::string command, std::string mode); void ExecuteCommand(std::string command, std::string mode);
bool OnButtonRealeaseEvent(GdkEventKey* key); bool OnButtonRealeaseEvent(GdkEventKey* key);
bool ExistInConsole(std::string string); bool ExistInConsole(std::string string);

53
juci/window.cc
Unescape View File

@ -5,6 +5,7 @@ Window::Window() :
window_box_(Gtk::ORIENTATION_VERTICAL), window_box_(Gtk::ORIENTATION_VERTICAL),
main_config_(), main_config_(),
keybindings_(main_config_.keybindings_cfg()), keybindings_(main_config_.keybindings_cfg()),
terminal_(main_config_.terminal_cfg()),
notebook_(this,keybindings(), notebook_(this,keybindings(),
main_config_.source_cfg(), main_config_.source_cfg(),
main_config_.dir_cfg()), main_config_.dir_cfg()),
@ -49,29 +50,29 @@ Window::Window() :
}); });
keybindings_. keybindings_.
action_group_menu()-> action_group_menu()->
add(Gtk::Action::create("ProjectCompileAndRun", add(Gtk::Action::create("ProjectCompileAndRun",
"Compile And Run"), "Compile And Run"),
Gtk::AccelKey(keybindings_.config_ Gtk::AccelKey(keybindings_.config_
.key_map()["compile_and_run"]), .key_map()["compile_and_run"]),
[this]() { [this]() {
if (running.try_lock()) { notebook_.OnSaveFile();
std::thread execute([=]() { if (running.try_lock()) {
notebook_.OnSaveFile(); std::thread execute([=]() {
std::string path = notebook_.CurrentPagePath(); std::string path = notebook_.CurrentPagePath();
int pos = path.find_last_of("/\\"); int pos = path.find_last_of("/\\");
if(pos != std::string::npos){ if(pos != std::string::npos) {
path.erase(path.begin()+pos,path.end()); path.erase(path.begin()+pos,path.end());
terminal_.SetFolderCommand(path); terminal_.SetFolderCommand(path);
} }
terminal_.Compile(); terminal_.Compile();
std::string executable = notebook_.directories(). std::string executable = notebook_.directories().
GetCmakeVarValue(path,"add_executable"); GetCmakeVarValue(path,"add_executable");
terminal_.Run(executable); terminal_.Run(executable);
}); });
execute.detach(); execute.detach();
running.unlock(); running.unlock();
} }
}); });
keybindings_. keybindings_.
action_group_menu()-> action_group_menu()->
@ -80,9 +81,9 @@ Window::Window() :
Gtk::AccelKey(keybindings_.config_ Gtk::AccelKey(keybindings_.config_
.key_map()["compile"]), .key_map()["compile"]),
[this]() { [this]() {
notebook_.OnSaveFile();
if (running.try_lock()) { if (running.try_lock()) {
std::thread execute([=]() { std::thread execute([=]() {
notebook_.OnSaveFile();
std::string path = notebook_.CurrentPagePath(); std::string path = notebook_.CurrentPagePath();
int pos = path.find_last_of("/\\"); int pos = path.find_last_of("/\\");
if(pos != std::string::npos){ if(pos != std::string::npos){
@ -95,7 +96,6 @@ Window::Window() :
running.unlock(); running.unlock();
} }
}); });
this->signal_button_release_event(). this->signal_button_release_event().
connect(sigc::mem_fun(*this,&Window::OnMouseRelease),false); connect(sigc::mem_fun(*this,&Window::OnMouseRelease),false);
terminal_.Terminal().signal_button_release_event(). terminal_.Terminal().signal_button_release_event().
@ -122,7 +122,6 @@ void Window::OnWindowHide() {
void Window::OnFileOpenFolder() { void Window::OnFileOpenFolder() {
Gtk::FileChooserDialog dialog("Please choose a folder", Gtk::FileChooserDialog dialog("Please choose a folder",
Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER); Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
dialog.set_transient_for(*this); dialog.set_transient_for(*this);
//Add response buttons the the dialog: //Add response buttons the the dialog:
dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL); dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);

Write Preview
Loading…
Cancel
Save