Merge pull request #18 from cppit/searchandreplace

Wrapping search

juci/CMakeLists.txt

@@ -3,7 +3,7 @@ set(project_name juci)
 set(module juci_to_python_api)
 project (${project_name})
 add_definitions(-DBOOST_LOG_DYN_LINK)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -std=c++11 -pthread")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -std=c++11 -pthread -Wall -Wno-reorder")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules/")
 
 #You are of course using Homebrew:

juci/cmake/Modules/FindLibClang.cmake

@@ -14,7 +14,8 @@
 #               Known LLVM release numbers.
 
 # most recent versions come first
-set(LIBCLANG_KNOWN_LLVM_VERSIONS 3.6
+set(LIBCLANG_KNOWN_LLVM_VERSIONS 3.6.1
+  3.6
   3.5.1
   3.5.0                   #Arch Linux
   3.5                     #LLVM Debian/Ubuntu packages from http://llvm.org/apt/

juci/config.cc

@@ -2,7 +2,7 @@
 #include "logging.h"
 
 MainConfig::MainConfig() :
-  keybindings_cfg_(), source_cfg() {
+  keybindings_cfg(), source_cfg() {
   INFO("Reading config file");
   boost::property_tree::json_parser::read_json("config.json", cfg_);
   INFO("Config file read");
@@ -22,7 +22,7 @@ void MainConfig::GenerateSource() {
   auto visual_json = source_json.get_child("visual");
   for (auto &i : visual_json) {
     if (i.first == "background") {
-	source_cfg.background = i.second.get_value<std::string>();
+	     source_cfg.background = i.second.get_value<std::string>();
     }
     if (i.first == "show_line_numbers") {
       source_cfg.show_line_numbers = i.second.get_value<std::string>() == "1" ? true : false;
@@ -55,10 +55,10 @@ void MainConfig::GenerateTerminalCommands() {
   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>());
+    terminal_cfg.compile_commands.emplace_back(i.second.get_value<std::string>());
   }
   for (auto &i : run_commands_json) {
-    terminal_cfg_.SetRunCommand(i.second.get_value<std::string>());
+    terminal_cfg.run_command=(i.second.get_value<std::string>()); //TODO: run_commands array->one run_command?
   }
 }
 
@@ -68,11 +68,11 @@ void MainConfig::GenerateKeybindings() {
   std::ifstream menu_xml("menu.xml");
   if (menu_xml.is_open()) {
     while (getline(menu_xml, line))
-      keybindings_cfg_.AppendXml(line);   
+      keybindings_cfg.AppendXml(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>();
+    keybindings_cfg.key_map()[i.first] = i.second.get_value<std::string>();
   DEBUG("Keybindings fetched");
 }
 
@@ -82,8 +82,8 @@ void MainConfig::GenerateDirectoryFilter() {
   boost::property_tree::ptree ignore_json = dir_json.get_child("ignore");
   boost::property_tree::ptree except_json = dir_json.get_child("exceptions");
   for ( auto &i : except_json )
-    dir_cfg_.AddException(i.second.get_value<std::string>());
+    dir_cfg.AddException(i.second.get_value<std::string>());
   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");
 }

juci/config.h

@@ -12,10 +12,10 @@
 class MainConfig {
 public:
   Source::Config source_cfg;
+  Terminal::Config terminal_cfg;
+  Keybindings::Config keybindings_cfg;
+  Directories::Config dir_cfg;
   MainConfig();
-  Keybindings::Config& keybindings_cfg() { return keybindings_cfg_; }
-  Directories::Config& dir_cfg() { return dir_cfg_; }
-  Terminal::Config& terminal_cfg() { return terminal_cfg_; }
   void PrintMenu();
   void GenerateSource();
   void GenerateKeybindings();
@@ -24,8 +24,5 @@ public:
 private:
   boost::property_tree::ptree cfg_;
   boost::property_tree::ptree key_tree_;
-  Keybindings::Config keybindings_cfg_;
-  Directories::Config dir_cfg_;
-  Terminal::Config terminal_cfg_;
 };
 #endif

juci/config.json

@@ -2,6 +2,7 @@
     "source": {
         "colors": {
             "text_color": "black",
+            "search": "orange",
             "string": "#CC0000",
             "namespace_ref": "#990099",
             "type": "#0066FF",
@@ -40,8 +41,6 @@
     },
     "keybindings": {
         "new_file": "<control>n",
-        "new_h_file": "<control><alt>h",
-        "new_cc_file": "<control><alt>c",
         "open_folder": "<control><alt>o",
         "open_file": "<control>o",
         "save": "<control>s",

juci/directories.cc

@@ -43,8 +43,6 @@ list_dirs(const boost::filesystem::path& dir_path,
           unsigned row_id) {
   
   boost::filesystem::directory_iterator end_itr;
-  unsigned dir_counter = row_id;
-  unsigned file_counter = 0;
   Gtk::TreeModel::Row child;
   Gtk::TreeModel::Row row;
   DEBUG("");
@@ -82,7 +80,7 @@ list_dirs(const boost::filesystem::path& dir_path,
 
 int Directories::Controller::count(const std::string path) {
   int count = 0;
-  for (int i = 0; i < path.size(); i++)
+  for (size_t i = 0; i < path.size(); i++)
     if (path[i] == '/')
       count++;
   return count;

juci/entry.cc

@@ -1,74 +1,61 @@
 #include "entry.h"
-Entry::View::View() :
-  view_(Gtk::ORIENTATION_HORIZONTAL),
-  button_apply_(Gtk::Stock::APPLY),
-  button_close_(Gtk::Stock::CLOSE),
-  button_next_("Next"),
-  button_prev_("Prev"){
-}
-Gtk::Box& Entry::View::view() {
-  return view_;
-}
-void Entry::View::OnShowSetFilenName(std::string exstension) {
-  entry_.set_max_length(50);
-  entry_.set_text(exstension);
-  view_.pack_start(entry_);
-  view_.pack_end(button_close_, Gtk::PACK_SHRINK);
-  view_.pack_end(button_apply_, Gtk::PACK_SHRINK); 
-}
-void Entry::View::OnShowSearch(std::string current){
-  entry_.set_max_length(50);
-  entry_.set_text(current);
-  view_.pack_start(entry_);
-  view_.pack_start(button_next_, Gtk::PACK_SHRINK);
-  view_.pack_start(button_prev_, Gtk::PACK_SHRINK);
-  view_.pack_end(button_close_, Gtk::PACK_SHRINK);
-}
-void Entry::View::OnHideEntry(bool is_new_file)
-{
-  view_.remove(entry_);
-  view_.remove(button_close_);
-  if(!is_new_file){
-    view_.remove(button_next_);
-    view_.remove(button_prev_);
-  }else{
-    view_.remove(button_apply_);
-  }
-}
 
-Entry::Controller::Controller() {					
-}
-Gtk::Box& Entry::Controller::view() {
-  return view_.view();
-}
-void Entry::Controller::OnShowSetFilenName(std::string exstension) {
-  view_.OnShowSetFilenName(exstension);
-  view_.view().show_all();
-  view_.entry().grab_focus();
-  view_.entry().set_position(0);
-}
-void Entry::Controller::OnShowSearch(std::string current){
-  view_.OnShowSearch(current);
-  view_.view().show_all();
-  view_.entry().grab_focus();
-  view_.entry().set_position(0);
+Entry::Entry() :
+  Gtk::Box(Gtk::ORIENTATION_HORIZONTAL),
+  button_apply_set_filename(Gtk::Stock::APPLY),
+  button_close(Gtk::Stock::CLOSE),
+  button_next("Next"),
+  button_prev("Prev"){
+  entry.signal_activate().connect([this](){
+    if(activate) {
+      activate();
+    }
+  });
+  entry.signal_key_press_event().connect(sigc::mem_fun(*this, &Entry::on_key_press), false);
 }
-void Entry::Controller::OnHideEntries(bool is_new_file){
-  view_.OnHideEntry(is_new_file);
-}
-std::string Entry::Controller::text(){
-  return view_.entry().get_text();
-}
-Gtk::Button& Entry::Controller::button_apply(){
-  return view_.button_apply();
-}
-Gtk::Button& Entry::Controller::button_close(){
-  return view_.button_close();
+
+bool Entry::on_key_press(GdkEventKey* key) {
+  if(key->keyval==GDK_KEY_Escape)
+    hide();
+  return false;
 }
-Gtk::Button& Entry::Controller::button_next(){
-  return view_.button_next();
+
+void Entry::show_set_filename() {
+  hide();
+  entry.set_max_length(50);
+  entry.set_text("");
+  pack_start(entry);
+  pack_end(button_close, Gtk::PACK_SHRINK);
+  pack_end(button_apply_set_filename, Gtk::PACK_SHRINK);
+  show_all();
+  entry.grab_focus();
+  entry.set_position(0);
+  activate=[this](){
+    button_apply_set_filename.clicked();
+  };
 }
-Gtk::Button& Entry::Controller::button_prev(){
-  return view_.button_prev();
+
+void Entry::show_search(const std::string& current){
+  hide();
+  entry.set_max_length(50);
+  entry.set_text(current);
+  pack_start(entry);
+  pack_start(button_next, Gtk::PACK_SHRINK);
+  pack_start(button_prev, Gtk::PACK_SHRINK);
+  pack_end(button_close, Gtk::PACK_SHRINK);
+  show_all();
+  entry.grab_focus();
+  entry.set_position(0);
+  activate=[this](){
+    button_next.clicked();
+  };
+}
+void Entry::hide() {
+  auto widgets=get_children();
+  for(auto &w: widgets)
+    remove(*w);
 }
 
+std::string Entry::operator()() {
+  return entry.get_text();
+}

juci/entry.h

@@ -2,43 +2,21 @@
 #define JUCI_ENTRY_H_
 
 #include <iostream>
+#include <functional>
 #include "gtkmm.h"
-#include "keybindings.h"
-
-namespace Entry {
-  class View  {
-  public:
-    View();
-    Gtk::Box& view();
-    Gtk::Entry& entry(){return entry_;}
-    Gtk::Button& button_apply(){return button_apply_;};
-    Gtk::Button& button_close(){return button_close_;};
-    Gtk::Button& button_next(){return button_next_;};
-    Gtk::Button& button_prev(){return button_prev_;};
-    void OnShowSetFilenName(std::string exstension);
-    void OnShowSearch(std::string current);
-    void OnHideEntry(bool is_new_file);
-  protected:
-    Gtk::Box view_;
-    Gtk::Entry entry_;
-    Gtk::Button button_apply_, button_close_, button_next_, button_prev_;
-  };
-  class Controller {
-  public:
-    Controller();
-    Gtk::Box& view();
-    Gtk::Button& button_apply();
-    Gtk::Button& button_close();
-    Gtk::Button& button_next();
-    Gtk::Button& button_prev();
-    
-    std::string text();
-    void OnShowSetFilenName(std::string exstension);
-    void OnShowSearch(std::string current);
-    void OnHideEntries(bool is_new_file);
-    View view_;
-  };// class controller
-} // namespace notebook
 
+class Entry: public Gtk::Box {
+public:
+  Entry();
+  void show_set_filename();
+  void show_search(const std::string& current);
+  void hide();
+  std::string operator()();
+  Gtk::Entry entry;
+  Gtk::Button button_apply_set_filename, button_close, button_next, button_prev;
+private:
+  bool on_key_press(GdkEventKey* key);
+  std::function<void()> activate;
+};
 
 #endif  // JUCI_ENTRY_H_

juci/juci.cc

@@ -16,7 +16,7 @@ int Juci::on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine> &cmd)
   char **argv = cmd->get_arguments(argc);
   ctx.parse(argc, argv);
   if(argc>=2) {
-    for(size_t c=1;c<argc;c++) {
+    for(int c=1;c<argc;c++) {
       boost::filesystem::path p=boost::filesystem::canonical(argv[c]);
       if(boost::filesystem::exists(p)) {
         if(boost::filesystem::is_regular_file(p))
@@ -35,12 +35,12 @@ void Juci::on_activate() {
   add_window(*window);
   window->show();
   if(directory!="") {
-    //TODO: use the following instead, window->notebook_.open_directory(directory);
-    window->notebook_.project_path=directory;
-    window->notebook_.directories.open_folder(directory);
+    //TODO: use the following instead, window->notebook.open_directory(directory);
+    window->notebook.project_path=directory;
+    window->notebook.directories.open_folder(directory);
   }
   for(auto &f: files)
-    window->notebook_.OnOpenFile(f);
+    window->notebook.OnOpenFile(f);
 }
 
 int main(int argc, char *argv[]) {

juci/menu.xml

@@ -1,11 +1,7 @@
 <ui>                                                   
   <menubar name='MenuBar'>                            
     <menu action='FileMenu'>                        
-      <menu action='FileNew'>                     
-        <menuitem action='FileNewStandard'/>    
-        <menuitem action='FileNewCC'/>          
-        <menuitem action='FileNewH'/>           
-      </menu>                                     
+      <menuitem action='FileNewFile'/>
       <menuitem action='FileOpenFile'/>
       <menuitem action='FileOpenFolder'/>
       <menuitem action='FileSave'/>

juci/notebook.cc

@@ -1,28 +1,24 @@
 #include <fstream>
 #include "notebook.h"
 #include "logging.h"
+#include <gtksourceview/gtksource.h> // c-library
 
-Notebook::Model::Model() {
-  cc_extension_ = ".cpp";
-  h_extension_  = ".hpp";
-  scrollvalue_ = 50;
-}
 
-Notebook::View::View() : notebook_() {
-  view_.pack2(notebook_);
-  view_.set_position(120);
+Notebook::View::View() {
+  pack2(notebook);
+  set_position(120);
 }
 
-Notebook::Controller::Controller(Gtk::Window* window,
-                                 Keybindings::Controller& keybindings,
+Notebook::Controller::Controller(Keybindings::Controller& keybindings,
+                                 Terminal::Controller& terminal,
                                  Source::Config& source_cfg,
                                  Directories::Config& dir_cfg) :
+  terminal(terminal),
   directories(dir_cfg),
   source_config(source_cfg) {
   INFO("Create notebook");
-  window_ = window;
   refClipboard_ = Gtk::Clipboard::get();
-  view().pack1(directories.widget(), true, true);
+  view.pack1(directories.widget(), true, true);
   CreateKeybindings(keybindings);
   INFO("Notebook Controller Success");
 }  // Constructor
@@ -40,31 +36,12 @@ void Notebook::Controller::CreateKeybindings(Keybindings::Controller
                             Gtk::Stock::FILE));
 
   keybindings.action_group_menu()->
-    add(Gtk::Action::create("FileNewStandard",                     
-                            "New empty file"),
+    add(Gtk::Action::create("FileNewFile",                     
+                            "New file"),
         Gtk::AccelKey(keybindings.config_
                       .key_map()["new_file"]),
         [this]() {
-          is_new_file_ = true;
-          OnFileNewEmptyfile();
-        });
-  keybindings.action_group_menu()->
-    add(Gtk::Action::create("FileNewCC",
-                            "New source file"),
-        Gtk::AccelKey(keybindings.config_
-                      .key_map()["new_cc_file"]),
-        [this]() {
-          is_new_file_ = true;
-          OnFileNewCCFile();
-        });
-  keybindings.action_group_menu()->
-    add(Gtk::Action::create("FileNewH",
-                            "New header file"),
-        Gtk::AccelKey(keybindings.config_
-                      .key_map()["new_h_file"]),
-        [this]() {
-          is_new_file_ = true;
-          OnFileNewHeaderFile();
+          OnFileNewFile();
         });
   keybindings.action_group_menu()->
     add(Gtk::Action::create("WindowCloseTab",
@@ -80,9 +57,7 @@ void Notebook::Controller::CreateKeybindings(Keybindings::Controller
         Gtk::AccelKey(keybindings.config_
                       .key_map()["edit_find"]),
         [this]() {
-          is_new_file_ = false;
-          OnEditSearch();
-          // TODO(Oyvang)  Zalox, Forgi)Create function OnEditFind();
+	  entry.show_search("");
         });
   keybindings.action_group_menu()->
     add(Gtk::Action::create("EditCopy",
@@ -91,15 +66,19 @@ void Notebook::Controller::CreateKeybindings(Keybindings::Controller
                       .key_map()["edit_copy"]),
        
         [this]() {
-          OnEditCopy();
+	  if (Pages() != 0) {
+	    CurrentTextView().get_buffer()->copy_clipboard(refClipboard_);
+	  }
         });
   keybindings.action_group_menu()->
     add(Gtk::Action::create("EditCut",
                             "Cut"),
          Gtk::AccelKey(keybindings.config_
-                      .key_map()["edit_cut"]),
+		       .key_map()["edit_cut"]),
         [this]() {
-          OnEditCut();
+	  if (Pages() != 0) {
+	    CurrentTextView().get_buffer()->cut_clipboard(refClipboard_);
+	  }
         });
   keybindings.action_group_menu()->
     add(Gtk::Action::create("EditPaste",
@@ -107,7 +86,9 @@ void Notebook::Controller::CreateKeybindings(Keybindings::Controller
          Gtk::AccelKey(keybindings.config_
                       .key_map()["edit_paste"]),
         [this]() {
-          OnEditPaste();
+	  if (Pages() != 0) {
+	    CurrentTextView().get_buffer()->paste_clipboard(refClipboard_);
+	  }
         });
 
   keybindings.action_group_menu()->
@@ -141,36 +122,44 @@ void Notebook::Controller::CreateKeybindings(Keybindings::Controller
           INFO("Done Redo");
         });
 
-  entry_.view_.entry().signal_activate().
-    connect(
-            [this]() {
-              if (is_new_file_) {
-                //OnNewPage(entry_.text()); //TODO: rewrite new file (the file needs to be created before opened with Source::Controller in order to choose the correct view implementation)
-                entry_.OnHideEntries(is_new_file_);
-              } else {
-                Search(true);
-              }
-            });
-  entry_.button_apply().signal_clicked().
-    connect(
-            [this]() {
-              //OnNewPage(entry_.text()); //TODO: rewrite new file (the file needs to be created before opened with Source::Controller in order to choose the correct view implementation)
-              entry_.OnHideEntries(is_new_file_);
-            });
-  entry_.button_close().signal_clicked().
+  entry.button_apply_set_filename.signal_clicked().connect([this]() {
+    std::string filename=entry();
+    if(filename!="") {
+      if(project_path!="" && !boost::filesystem::path(filename).is_absolute())
+        filename=project_path+"/"+filename;
+      boost::filesystem::path p(filename);
+      if(boost::filesystem::exists(p)) {
+        //TODO: alert user that file already exists
+      }
+      else {
+        std::ofstream f(p.string().c_str());
+        if(f) {
+          OnOpenFile(boost::filesystem::canonical(p).string());
+          if(project_path!="")
+            directories.open_folder(project_path); //TODO: Do refresh instead
+        }
+        else {
+          //TODO: alert user of error creating file
+        }
+        f.close();
+      }
+    }
+    entry.hide();
+  });
+  entry.button_close.signal_clicked().
     connect(
             [this]() {
-              entry_.OnHideEntries(is_new_file_);
+              entry.hide();
             });
-  entry_.button_next().signal_clicked().
+  entry.button_next.signal_clicked().
     connect(
             [this]() {
-              Search(true);
+              search(true);
             });
-  entry_.button_prev().signal_clicked().
+  entry.button_prev.signal_clicked().
     connect(
             [this]() {
-              Search(false);
+              search(false);
             });
   INFO("Notebook signal handlers sucsess");
 }
@@ -181,22 +170,15 @@ Notebook::Controller::~Controller() {
   for (auto &i : scrolledtext_vec_) delete i;
 }
 
-Gtk::Paned& Notebook::Controller::view() {
-  return view_.view();
-}
-Gtk::Box& Notebook::Controller::entry_view() {
-  return entry_.view();
-}
-
 void Notebook::Controller::OnOpenFile(std::string path) {
   INFO("Notebook open file");
   INFO("Notebook create page");
-  text_vec_.emplace_back(new Source::Controller(source_config, path, project_path));
+  text_vec_.emplace_back(new Source::Controller(source_config, path, project_path, terminal));
   scrolledtext_vec_.push_back(new Gtk::ScrolledWindow());
   editor_vec_.push_back(new Gtk::HBox());
   scrolledtext_vec_.back()->add(*text_vec_.back()->view);
   editor_vec_.back()->pack_start(*scrolledtext_vec_.back(), true, true);
-  size_t pos = path.find_last_of("/\\");
+  size_t pos = path.find_last_of("/\\");  // TODO #windows
   std::string filename=path;
   if(pos!=std::string::npos)
     filename=path.substr(pos+1);
@@ -207,7 +189,7 @@ void Notebook::Controller::OnOpenFile(std::string path) {
   //Add star on tab label when the page is not saved:
   text_vec_.back()->buffer()->signal_changed().connect([this]() {
     if(text_vec_.at(CurrentPage())->is_saved) {
-      std::string path=text_vec_.at(CurrentPage())->view->file_path;
+      std::string path=CurrentTextView().file_path;
       size_t pos = path.find_last_of("/\\");
       std::string filename=path;
       if(pos!=std::string::npos)
@@ -233,88 +215,42 @@ void Notebook::Controller::OnCloseCurrentPage() {
     editor_vec_.erase(editor_vec_.begin()+page);
   }
 }
-void Notebook::Controller::OnFileNewEmptyfile() {
-  entry_.OnShowSetFilenName("");
-}
-void Notebook::Controller::OnFileNewCCFile() {
-  entry_.OnShowSetFilenName(model_.cc_extension_);
-}
-void Notebook::Controller::OnFileNewHeaderFile() {
-  entry_.OnShowSetFilenName(model_.h_extension_);
-}
-void Notebook::Controller::OnEditCopy() {
-  if (Pages() != 0) {
-    Buffer(*text_vec_.at(CurrentPage()))->copy_clipboard(refClipboard_);
-  }
-}
-void Notebook::Controller::OnEditPaste() {
-  if (Pages() != 0) {
-    Buffer(*text_vec_.at(CurrentPage()))->paste_clipboard(refClipboard_);
-  }
-}
-void Notebook::Controller::OnEditCut() {
-  if (Pages() != 0) {
-    Buffer(*text_vec_.at(CurrentPage()))->cut_clipboard(refClipboard_);
-  }
+void Notebook::Controller::OnFileNewFile() {
+  entry.show_set_filename();
 }
 
-std::string Notebook::Controller::GetCursorWord() {
-  INFO("Notebook get cursor word");
-  int page = CurrentPage();
-  std::string word;
-  Gtk::TextIter start, end;
-  start = Buffer(*text_vec_.at(page))->get_insert()->get_iter();
-  end = Buffer(*text_vec_.at(page))->get_insert()->get_iter();
-  if (!end.ends_line()) {
-    while (!end.ends_word()) {
-      end.forward_char();
-    }
-  }
-  if (!start.starts_line()) {
-    while (!start.starts_word()) {
-      start.backward_char();
-    }
-  }
-  word = Buffer(*text_vec_.at(page))->get_text(start, end);
-  // TODO(Oyvang) fix selected text
-  return word;
-}
-
-void Notebook::Controller::OnEditSearch() {
-  search_match_end_ =
-    Buffer(*text_vec_.at(CurrentPage()))->get_iter_at_offset(0);
-  entry_.OnShowSearch(GetCursorWord());
-}
-
-void Notebook::Controller::Search(bool forward) {
-    INFO("Notebook search");
-  int page = CurrentPage();
-  std::string search_word;
-  search_word = entry_.text();
-  Gtk::TextIter test;
-
-  if ( !forward ) {
-    if ( search_match_start_ == 0 ||
-         search_match_start_.get_line_offset() == 0) {
-      search_match_start_ = Buffer(*text_vec_.at(CurrentPage()))->end();
-    }
-    search_match_start_.
-      backward_search(search_word,
-                      Gtk::TextSearchFlags::TEXT_SEARCH_TEXT_ONLY |
-                      Gtk::TextSearchFlags::TEXT_SEARCH_VISIBLE_ONLY,
-                      search_match_start_,
-                      search_match_end_);
+void Notebook::Controller::search(bool forward) {
+  INFO("Notebook search");
+  auto start = CurrentTextView().search_start;
+  auto end = CurrentTextView().search_end;
+  // fetch buffer and greate settings
+  auto buffer = CurrentTextView().get_source_buffer();
+  auto settings = gtk_source_search_settings_new();
+  // get search text from entry
+  gtk_source_search_settings_set_search_text(settings, entry().c_str());
+  // make sure the search continues
+  gtk_source_search_settings_set_wrap_around(settings, true);
+  auto context = gtk_source_search_context_new(buffer->gobj(), settings);
+  gtk_source_search_context_set_highlight(context, forward);
+  auto itr = buffer->get_insert()->get_iter();
+  buffer->remove_tag_by_name("search", start ? start : itr, end ? end : itr);
+  if (forward) {
+    DEBUG("Doing forward search");
+    gtk_source_search_context_forward(context,
+				      end ? end.gobj() : itr.gobj(),
+				      start.gobj(),
+				      end.gobj());
   } else {
-    if ( search_match_end_ == 0 ) {
-      search_match_end_ = Buffer(*text_vec_.at(CurrentPage()))->begin();
-    }
-    search_match_end_.
-      forward_search(search_word,
-                     Gtk::TextSearchFlags::TEXT_SEARCH_TEXT_ONLY |
-                     Gtk::TextSearchFlags::TEXT_SEARCH_VISIBLE_ONLY,
-                     search_match_start_,
-                     search_match_end_);
+    DEBUG("Doing backward search");
+    gtk_source_search_context_backward(context,
+				       start ? start.gobj() : itr.gobj(),
+				       start.gobj(),
+				       end.gobj());
   }
+  buffer->apply_tag_by_name("search", start, end);
+  CurrentTextView().scroll_to(end);
+  CurrentTextView().search_start = start;
+  CurrentTextView().search_end = end;
 }
 
 void Notebook::Controller
@@ -348,32 +284,15 @@ int Notebook::Controller::CurrentPage() {
   return Notebook().get_current_page();
 }
 
-Glib::RefPtr<Gtk::TextBuffer>
-Notebook::Controller::Buffer(Source::Controller &source) {
-  return source.view->get_buffer();
-}
-
 int Notebook::Controller::Pages() {
   return Notebook().get_n_pages();
 }
 Gtk::Notebook& Notebook::Controller::Notebook() {
-  return view_.notebook();
-}
-
-void Notebook::Controller::BufferChangeHandler(Glib::RefPtr<Gtk::TextBuffer>
-                                               buffer) {
-  buffer->signal_end_user_action().connect(
-                                   [this]() {                                     
-                                     //UpdateHistory();
-                                   });
-}
-
-std::string Notebook::Controller::CurrentPagePath(){
-  return text_vec_.at(CurrentPage())->view->file_path;
+  return view.notebook;
 }
 
 bool Notebook::Controller:: OnSaveFile() {
-  std::string path=text_vec_.at(CurrentPage())->view->file_path;
+  std::string path=CurrentTextView().file_path;
   return OnSaveFile(path);
 }
 bool Notebook::Controller:: OnSaveFile(std::string path) {
@@ -383,7 +302,7 @@ bool Notebook::Controller:: OnSaveFile(std::string path) {
       file.open (path);
       file << CurrentTextView().get_buffer()->get_text();
       file.close();
-      text_vec_.at(CurrentPage())->view->file_path=path;
+      CurrentTextView().file_path=path;
       size_t pos = path.find_last_of("/\\");
       std::string filename=path;
       if(pos!=std::string::npos)
@@ -398,10 +317,9 @@ bool Notebook::Controller:: OnSaveFile(std::string path) {
 
 std::string Notebook::Controller::OnSaveFileAs(){
   INFO("Notebook save as");
-  Gtk::FileChooserDialog dialog("Please choose a file", 
+  Gtk::FileChooserDialog dialog((Gtk::Window&)(*view.get_toplevel()), "Please choose a file", 
 				Gtk::FILE_CHOOSER_ACTION_SAVE);
   DEBUG("SET TRANSISTEN FPR");
-  dialog.set_transient_for(*window_);
   dialog.set_position(Gtk::WindowPosition::WIN_POS_CENTER_ALWAYS);
   dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
   dialog.add_button("_Save", Gtk::RESPONSE_OK);
@@ -413,8 +331,7 @@ std::string Notebook::Controller::OnSaveFileAs(){
   case(Gtk::RESPONSE_OK): {
     DEBUG("get_filename()");
     std::string path = dialog.get_filename();
-    unsigned pos = path.find_last_of("/\\");
-     return path;
+    return path;
   }
   case(Gtk::RESPONSE_CANCEL): {
     break;
@@ -430,11 +347,11 @@ std::string Notebook::Controller::OnSaveFileAs(){
 void Notebook::Controller::AskToSaveDialog() {
   INFO("AskToSaveDialog");
   DEBUG("AskToSaveDialog: Finding file path");
-  Gtk::MessageDialog dialog(*window_, "Save file!",
+  Gtk::MessageDialog dialog((Gtk::Window&)(*view.get_toplevel()), "Save file!",
 			    false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_YES_NO);
   dialog.set_secondary_text(
           "Do you want to save: " +
-			    text_vec_.at(CurrentPage())->view->file_path+" ?");
+			    CurrentTextView().file_path+" ?");
   DEBUG("AskToSaveDialog: run dialog");
   int result = dialog.run();
 

juci/notebook.h

@@ -11,80 +11,52 @@
 #include <map>
 #include <sigc++/sigc++.h>
 #include "clangmm.h"
+#include "keybindings.h"
+#include "terminal.h"
 
 namespace Notebook {
-  class Model {
-  public:
-    Model();
-    std::string cc_extension_;
-    std::string h_extension_;
-    int scrollvalue_;
-  };
-  class View {
+  class View : public Gtk::Paned {
   public:
     View();
-    Gtk::Paned& view() {return view_;}
-    Gtk::Notebook& notebook() {return notebook_; }
-  protected:
-    Gtk::Paned view_;
-    Gtk::Notebook notebook_;
+    Gtk::Notebook notebook;
   };
   class Controller {
   public:
-    Controller(Gtk::Window* window, Keybindings::Controller& keybindings,
+    Controller(Keybindings::Controller& keybindings,
+               Terminal::Controller& terminal,
                Source::Config& config,
                Directories::Config& dir_cfg);
     ~Controller();
-    Glib::RefPtr<Gtk::TextBuffer> Buffer(Source::Controller &source);
     Source::View& CurrentTextView();
     int CurrentPage();
-    Gtk::Box& entry_view();
     Gtk::Notebook& Notebook();
-    std::string CurrentPagePath();
-    void OnBufferChange();
-    void BufferChangeHandler(Glib::RefPtr<Gtk::TextBuffer>
-                                               buffer);
     void OnCloseCurrentPage();
-    std::string GetCursorWord();
-    void OnEditCopy();
-    void OnEditCut();
-    void OnEditPaste();
-    void OnEditSearch();
-    void OnFileNewCCFile();
-    void OnFileNewEmptyfile();
-    void OnFileNewHeaderFile();
-    void OnFileOpenFolder();
+    void OnFileNewFile();
     bool OnSaveFile();
     bool OnSaveFile(std::string path);
     void OnDirectoryNavigation(const Gtk::TreeModel::Path& path,
                                Gtk::TreeViewColumn* column);
     void OnOpenFile(std::string filename);
-    bool ScrollEventCallback(GdkEventScroll* scroll_event);
     int Pages();
-    Gtk::Paned& view();
-    void Search(bool forward);
+    void search(bool forward);
+    View view;
     std::string OnSaveFileAs();
     std::string project_path;
-    Directories::Controller directories;
+    Directories::Controller directories; //Todo: make private after creating open_directory()
+    Entry entry;
+    std::vector<std::unique_ptr<Source::Controller> > text_vec_;
   private:
     void CreateKeybindings(Keybindings::Controller& keybindings);
     void AskToSaveDialog();
     Glib::RefPtr<Gtk::Builder> m_refBuilder;
     Glib::RefPtr<Gio::SimpleActionGroup> refActionGroup;
+    Terminal::Controller& terminal;
     Source::Config& source_config;
-    View view_;
-    Model model_;
-    bool is_new_file_; //TODO: Remove this
-    Entry::Controller entry_;
 
-    std::vector<std::unique_ptr<Source::Controller> > text_vec_;
     std::vector<Gtk::ScrolledWindow*> scrolledtext_vec_;
     std::vector<Gtk::HBox*> editor_vec_;
     std::list<Gtk::TargetEntry> listTargets_;
-    Gtk::TextIter search_match_end_;
-    Gtk::TextIter search_match_start_;
     Glib::RefPtr<Gtk::Clipboard> refClipboard_;
-    Gtk::Window* window_;
   };  // class controller
 }  // namespace Notebook
 #endif  // JUCI_NOTEBOOK_H_

juci/source.cc

@@ -27,11 +27,11 @@ config(config), file_path(file_path), project_path(project_path) {
   set_smart_home_end(Gsv::SMART_HOME_END_BEFORE);
   set_show_line_numbers(config.show_line_numbers);
   set_highlight_current_line(config.highlight_current_line);
-      
   sourcefile s(file_path);
   get_source_buffer()->get_undo_manager()->begin_not_undoable_action();
   get_source_buffer()->set_text(s.get_content());
   get_source_buffer()->get_undo_manager()->end_not_undoable_action();
+  search_start = search_end = this->get_buffer()->end();
 }
 
 string Source::View::get_line(size_t line_number) {
@@ -132,10 +132,10 @@ bool Source::View::on_key_press(GdkEventKey* key) {
 //////////////////
 //// ClangView ///
 //////////////////
-clang::Index Source::ClangView::clang_index(0, 1);
+clang::Index Source::ClangView::clang_index(0, 0);
 
-Source::ClangView::ClangView(const Source::Config& config, const std::string& file_path, const std::string& project_path):
-Source::View(config, file_path, project_path),
+Source::ClangView::ClangView(const Source::Config& config, const std::string& file_path, const std::string& project_path, Terminal::Controller& terminal):
+Source::View(config, file_path, project_path), terminal(terminal),
 parse_thread_go(true), parse_thread_mapped(false), parse_thread_stop(false) {
   override_font(Pango::FontDescription(config.font));
   override_background_color(Gdk::RGBA(config.background));
@@ -145,11 +145,25 @@ parse_thread_go(true), parse_thread_mapped(false), parse_thread_stop(false) {
   
   int start_offset = get_source_buffer()->begin().get_offset();
   int end_offset = get_source_buffer()->end().get_offset();
-  init_syntax_highlighting(get_buffer_map(),
+  auto buffer_map=get_buffer_map();
+  //Remove includes for first parse for initial syntax highlighting
+  auto& str=buffer_map[file_path];
+  std::size_t pos=0;
+  while((pos=str.find("#include", pos))!=std::string::npos) {
+    auto start_pos=pos;
+    pos=str.find('\n', pos+8);
+    if(pos==std::string::npos)
+      break;
+    if(start_pos==0 || str[start_pos-1]=='\n') {
+      str.replace(start_pos, pos-start_pos, pos-start_pos, ' ');
+    }
+    pos++;
+  }
+  init_syntax_highlighting(buffer_map,
                            start_offset,
                            end_offset,
                            &ClangView::clang_index);
-  update_syntax(extract_tokens(start_offset, end_offset));
+  update_syntax(extract_tokens(0, get_source_buffer()->get_text().size())); //TODO: replace get_source_buffer()->get_text().size()
   
   //GTK-calls must happen in main thread, so the parse_thread
   //sends signals to the main thread that it is to call the following functions:
@@ -162,10 +176,12 @@ parse_thread_go(true), parse_thread_mapped(false), parse_thread_stop(false) {
     parse_thread_go=true;
   });
   
+  parsing_in_progress=this->terminal.print_in_progress("Parsing "+file_path);
   parse_done.connect([this](){
     if(parse_thread_mapped) {
       INFO("Updating syntax");
       update_syntax(extract_tokens(0, get_source_buffer()->get_text().size()));
+      parsing_in_progress->done("done");
       INFO("Syntax updated");
     }
     else {
@@ -203,6 +219,8 @@ parse_thread_go(true), parse_thread_mapped(false), parse_thread_stop(false) {
 }
 
 Source::ClangView::~ClangView() {
+  //TODO: Is it possible to stop the clang-process in progress?
+  parsing_in_progress->cancel("canceled");
   parse_thread_stop=true;
   if(parse_thread.joinable())
     parse_thread.join();
@@ -239,13 +257,15 @@ std::vector<Source::AutoCompleteData> Source::ClangView::
 get_autocomplete_suggestions(int line_number, int column) {
   INFO("Getting auto complete suggestions");
   std::vector<Source::AutoCompleteData> suggestions;
-  auto buffer_map=get_buffer_map();
+  std::map<std::string, std::string> buffer_map;
+  buffer_map[file_path]=get_source_buffer()->get_text(get_source_buffer()->begin(), get_source_buffer()->get_insert()->get_iter());
+  buffer_map[file_path]+="\n";
   parsing_mutex.lock();
   clang::CodeCompleteResults results(tu_.get(),
                                      file_path,
                                      buffer_map,
                                      line_number,
-                                     column);
+                                     column-1);
   for (int i = 0; i < results.size(); i++) {
     const vector<clang::CompletionChunk> chunks_ = results.get(i).get_chunks();
     std::vector<AutoCompleteChunk> chunks;
@@ -268,10 +288,12 @@ get_compilation_commands() {
   std::vector<std::string> arguments;
   for (auto &i : cmds) {
     std::vector<std::string> lol = i.get_command_as_args();
-    for (int a = 1; a < lol.size()-4; a++) {
+    for (size_t a = 1; a < lol.size()-4; a++) {
       arguments.emplace_back(lol[a]);
     }
   }
+  if(boost::filesystem::path(file_path).extension()==".h") //TODO: temporary fix for .h-files (parse as c++)
+    arguments.emplace_back("-xc++");
   return arguments;
 }
 
@@ -439,7 +461,7 @@ bool Source::ClangView::on_key_press(GdkEventKey* key) {
     string line(get_line_before_insert());
     std::smatch sm;
     if(std::regex_match(line, sm, bracket_regex)) {
-      size_t line_nr=get_source_buffer()->get_insert()->get_iter().get_line();
+      int line_nr=get_source_buffer()->get_insert()->get_iter().get_line();
       if((line_nr+1)<get_source_buffer()->get_line_count()) {
         string next_line=get_line(line_nr+1);
         std::smatch sm2;
@@ -518,12 +540,12 @@ bool Source::ClangView::on_key_press(GdkEventKey* key) {
 // Source::Controller::Controller()
 // Constructor for Controller
 Source::Controller::Controller(const Source::Config &config,
-                               const std::string& file_path, std::string project_path) {
+                               const std::string& file_path, std::string project_path, Terminal::Controller& terminal) {
   if(project_path=="") {
     project_path=boost::filesystem::path(file_path).parent_path().string();
   }
   if (config.legal_extension(file_path.substr(file_path.find_last_of(".") + 1)))
-    view=std::unique_ptr<View>(new ClangView(config, file_path, project_path));
+    view=std::unique_ptr<View>(new ClangView(config, file_path, project_path, terminal));
   else
     view=std::unique_ptr<View>(new GenericView(config, file_path, project_path));
   INFO("Source Controller with childs constructed");
@@ -531,4 +553,4 @@ Source::Controller::Controller(const Source::Config &config,
 
 Glib::RefPtr<Gsv::Buffer> Source::Controller::buffer() {
   return view->get_source_buffer();
-}
+}

juci/source.h

@@ -10,6 +10,7 @@
 #include <string>
 #include <atomic>
 #include "gtksourceviewmm.h"
+#include "terminal.h"
 
 namespace Source {
   class Config {
@@ -62,6 +63,7 @@ namespace Source {
     std::string get_line_before_insert();
     std::string file_path;
     std::string project_path;
+    Gtk::TextIter search_start, search_end;
   protected:
     const Source::Config& config;
     bool on_key_press(GdkEventKey* key);
@@ -81,7 +83,7 @@ namespace Source {
   
   class ClangView : public View {
   public:
-    ClangView(const Source::Config& config, const std::string& file_path, const std::string& project_path);
+    ClangView(const Source::Config& config, const std::string& file_path, const std::string& project_path, Terminal::Controller& terminal);
     ~ClangView();
     // inits the syntax highligthing on file open
     void init_syntax_highlighting(const std::map<std::string, std::string>
@@ -107,6 +109,8 @@ namespace Source {
     std::vector<std::string> get_compilation_commands();
     bool on_key_press(GdkEventKey* key);
     bool on_key_release(GdkEventKey* key);
+    Terminal::Controller& terminal;
+    std::shared_ptr<Terminal::InProgress> parsing_in_progress;
     
     Glib::Dispatcher parse_done;
     Glib::Dispatcher parse_start;
@@ -121,7 +125,7 @@ namespace Source {
   class Controller {
   public:
     Controller(const Source::Config &config,
-               const std::string& file_path, std::string project_path);
+               const std::string& file_path, std::string project_path, Terminal::Controller& terminal);
     Glib::RefPtr<Gsv::Buffer> buffer();
     
     bool is_saved = true;

juci/terminal.cc

@@ -1,36 +1,55 @@
 #include "terminal.h"
 #include <iostream>
-#include <thread>
 #include "logging.h"
 
+Terminal::InProgress::InProgress(Controller& terminal, const std::string& start_msg): terminal(terminal), stop(false) {
+  waiting_print.connect([this](){
+    this->terminal.print(line_nr-1, ".");
+  });
+  start(start_msg);
+}
 
-Terminal::Config::Config() {
+Terminal::InProgress::~InProgress() {
+  stop=true;
+  if(wait_thread.joinable())
+    wait_thread.join();
 }
-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::InProgress::start(const std::string& msg) {
+  line_nr=this->terminal.print(msg+"...\n");
+  wait_thread=std::thread([this](){
+    size_t c=0;
+    while(!stop) {
+      if(c%100==0)
+        waiting_print();
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      c++;
+    }
+  });
 }
 
-void Terminal::Config::InsertCompileCommand(std::string command){
-  compile_commands_.push_back(command);
+void Terminal::InProgress::done(const std::string& msg) {
+  if(!stop) {
+    stop=true;
+    this->terminal.print(line_nr-1, msg);
+  }
 }
 
-void Terminal::Config::SetRunCommand(std::string command){
-  run_command_ = command;
+void Terminal::InProgress::cancel(const std::string& msg) {
+  if(!stop) {
+    stop=true;
+    this->terminal.print(line_nr-1, msg);
+  }
 }
 
 Terminal::View::View(){
-  scrolledwindow_.add(textview_);
-  scrolledwindow_.set_size_request(-1,150);
-  view_.add(scrolledwindow_);
-  textview_.set_editable(false);
+  text_view.set_editable(false);
+  scrolled_window.add(text_view);
+  add(scrolled_window);
 }
 
-
 Terminal::Controller::Controller(Terminal::Config& cfg) :
-  config_(cfg) {  
+  config(cfg) {  
   folder_command_ = "";
 }
 
@@ -44,37 +63,51 @@ void Terminal::Controller::SetFolderCommand( boost::filesystem::path
 void Terminal::Controller::Compile(){
   INFO("Terminal: Compile");
 
-  Terminal().get_buffer()->set_text("");
+  view.text_view.get_buffer()->set_text("");
   DEBUG("Terminal: Compile: running cmake command");
-  std::vector<std::string> commands = config().compile_commands();
+  std::vector<std::string> commands = config.compile_commands;
   for (size_t it = 0; it < commands.size(); ++it) {
     ExecuteCommand(commands.at(it), "r");
     
   }
-  PrintMessage("\n");
+  print("\n");
   DEBUG("Terminal: Compile: compile done");
 }
 
 void Terminal::Controller::Run(std::string executable) {
   INFO("Terminal: Run");
-  PrintMessage("juCi++ execute: " + executable + "\n");
+  print("juCi++ execute: " + executable + "\n");
   DEBUG("Terminal: Compile: running run command: ");
   DEBUG_VAR(executable);
-  ExecuteCommand("cd "+config().run_command() + "; ./"+executable, "r");
-  PrintMessage("\n");
+  ExecuteCommand("cd "+config.run_command + "; ./"+executable, "r");
+  print("\n");
 }
 
-void Terminal::Controller::PrintMessage(std::string message){
+int Terminal::Controller::print(std::string message){
   INFO("Terminal: PrintMessage");
-  Terminal().get_buffer()->
-    insert(Terminal().get_buffer()-> end(),"> "+message);
+  view.text_view.get_buffer()->insert(view.text_view.get_buffer()->end(), "> "+message);
+  auto mark_end=view.text_view.get_buffer()->create_mark(view.text_view.get_buffer()->end());
+  view.text_view.scroll_to(mark_end);
+  return mark_end->get_iter().get_line();
 }
 
+void Terminal::Controller::print(int line_nr, std::string message){
+  INFO("Terminal: PrintMessage at line " << line_nr);
+  auto iter=view.text_view.get_buffer()->get_iter_at_line(line_nr);
+  while(!iter.ends_line())
+    iter++;
+  view.text_view.get_buffer()->insert(iter, message);
+}
+
+std::shared_ptr<Terminal::InProgress> Terminal::Controller::print_in_progress(std::string start_msg) {
+  std::shared_ptr<Terminal::InProgress> in_progress=std::shared_ptr<Terminal::InProgress>(new Terminal::InProgress(*this, start_msg));
+  return in_progress;
+}
 
 bool Terminal::Controller::ExistInConsole(std::string string) {
     INFO("Terminal: ExistInConsole");
     DEBUG("Terminal: PrintMessage: finding string in buffer");
-  double pos = Terminal().get_buffer()->
+  double pos = view.text_view.get_buffer()->
     get_text().find(string);
   if (pos == std::string::npos) return false;
   return true;
@@ -88,11 +121,11 @@ void Terminal::Controller::ExecuteCommand(std::string command, std::string mode)
   std::cout << command << std::endl;
   p = popen(command.c_str(), mode.c_str());
   if (p == NULL) {
-    PrintMessage("juCi++ ERROR: Failed to run command" + command + "\n");
+    print("juCi++ ERROR: Failed to run command" + command + "\n");
   }else {
     char buffer[1028];
     while (fgets(buffer, 1028, p) != NULL) {
-      PrintMessage(buffer);
+      print(buffer);
     }
     pclose(p); 
   }

juci/terminal.h

@@ -2,51 +2,59 @@
 #define JUCI_TERMINAL_H_
 
 #include <mutex>
+#include <functional>
 #include "gtkmm.h"
 #include <boost/filesystem.hpp>
+#include <thread>
+#include <atomic>
 
 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_;
+    std::vector<std::string> compile_commands;
+    std::string run_command;
   };
  
-  class View {
+  class View : public Gtk::HBox {
   public:
-    View();   
-    Gtk::HBox& view() {return view_;}
-    Gtk::TextView& textview() {return textview_;}
-  private:
-    Gtk::HBox view_;
-    Gtk::TextView textview_;
-    Gtk::ScrolledWindow scrolledwindow_;
+    View();
+    Gtk::TextView text_view;
+    Gtk::ScrolledWindow scrolled_window;
   };  // class view
   
+  class Controller;
+  
+  //Temporary solution for displaying functions in progress, and when they are done.
+  class InProgress {
+  public:
+    InProgress(Controller& terminal, const std::string& start_msg);
+    ~InProgress();
+    void done(const std::string& msg);
+    void cancel(const std::string& msg);
+  private:
+    void start(const std::string& msg);
+    Controller& terminal;
+    int line_nr;
+    std::atomic<bool> stop;
+    Glib::Dispatcher waiting_print;
+    std::thread wait_thread;
+  };
+  
   class Controller {  
   public:
     Controller(Terminal::Config& cfg);
-    Gtk::HBox& view() {return view_.view();}
-    Gtk::TextView& Terminal(){return view_.textview();}
     void SetFolderCommand(boost::filesystem::path CMake_path);
     void Run(std::string executable);
     void Compile();
-    Terminal::Config& config() { return config_; }
-    void PrintMessage(std::string message);
+    int print(std::string message);
+    void print(int line_nr, std::string message);
+    std::shared_ptr<InProgress> print_in_progress(std::string start_msg);
+    Terminal::View view;
   private:
-    Terminal::Config config_;
+    Terminal::Config& config;
     void ExecuteCommand(std::string command, std::string mode);
     bool OnButtonRealeaseEvent(GdkEventKey* key);
     bool ExistInConsole(std::string string);
-    Terminal::View view_;
     std::string folder_command_;
     std::string path_;
     const std::string cmake_sucsess = "Build files have been written to:";

juci/window.cc

@@ -4,13 +4,13 @@
 Window::Window() :
   window_box_(Gtk::ORIENTATION_VERTICAL),
   main_config_(),
-  keybindings_(main_config_.keybindings_cfg()),
-  terminal_(main_config_.terminal_cfg()),
-  notebook_(this,keybindings(),
+  keybindings_(main_config_.keybindings_cfg),
+  terminal(main_config_.terminal_cfg),
+  notebook(keybindings(), terminal,
             main_config_.source_cfg,
-            main_config_.dir_cfg()),
+            main_config_.dir_cfg),
   menu_(keybindings()),
-  api_(menu_, notebook_) {
+  api_(menu_, notebook) {
   INFO("Create Window");
   set_title("juCi++");
   set_default_size(600, 400);
@@ -66,16 +66,16 @@ Window::Window() :
 	  SaveFile();
 	  if (running.try_lock()) {
 	    std::thread execute([=]() {
-		std::string path = notebook_.CurrentPagePath();
-		int pos = path.find_last_of("/\\");
+		std::string path = notebook.CurrentTextView().file_path;
+		size_t pos = path.find_last_of("/\\");
 		if(pos != std::string::npos) {
 		  path.erase(path.begin()+pos,path.end());
-		  terminal_.SetFolderCommand(path);
+		  terminal.SetFolderCommand(path);
 		}
-		terminal_.Compile();
-		std::string executable = notebook_.directories.
+		terminal.Compile();
+		std::string executable = notebook.directories.
 		  GetCmakeVarValue(path,"add_executable");
-		terminal_.Run(executable);
+		terminal.Run(executable);
                 running.unlock();
 	      });
 	    execute.detach();
@@ -92,13 +92,13 @@ Window::Window() :
           SaveFile();
           if (running.try_lock()) {
             std::thread execute([=]() {		  
-                std::string path =  notebook_.CurrentPagePath();
-                int pos = path.find_last_of("/\\");
+                std::string path =  notebook.CurrentTextView().file_path;
+                size_t pos = path.find_last_of("/\\");
                 if(pos != std::string::npos){
                   path.erase(path.begin()+pos,path.end());
-                  terminal_.SetFolderCommand(path);
+                  terminal.SetFolderCommand(path);
                 }
-                terminal_.Compile();
+                terminal.Compile();
                 running.unlock();
               });
             execute.detach();
@@ -111,16 +111,18 @@ Window::Window() :
 
   window_box_.pack_start(menu_.view(), Gtk::PACK_SHRINK);
 
-  window_box_.pack_start(notebook_.entry_view(), Gtk::PACK_SHRINK);
+  window_box_.pack_start(notebook.entry, Gtk::PACK_SHRINK);
   paned_.set_position(300);
-  paned_.pack1(notebook_.view(), true, false);
-  paned_.pack2(terminal_.view(), true, true);
+  paned_.pack1(notebook.view, true, false);
+  paned_.pack2(terminal.view, true, true);
   window_box_.pack_end(paned_);
   show_all_children();
   INFO("Window created");
 } // Window constructor
 
 void Window::OnWindowHide() {
+  for(size_t c=0;c<notebook.text_vec_.size();c++)
+    notebook.OnCloseCurrentPage(); //TODO: This only works on one page at the momemt. Change to notebook.close_page(page_nr);
   hide();
 }
 void Window::OnFileOpenFolder() {
@@ -139,8 +141,8 @@ void Window::OnFileOpenFolder() {
     case(Gtk::RESPONSE_OK):
       {
         std::string project_path=dialog.get_filename();
-        notebook_.project_path=project_path;
-        notebook_.directories.open_folder(project_path);
+        notebook.project_path=project_path;
+        notebook.directories.open_folder(project_path);
         break;
       }
     case(Gtk::RESPONSE_CANCEL):
@@ -188,7 +190,7 @@ void Window::OnOpenFile() {
   switch (result) {
   case(Gtk::RESPONSE_OK): {
     std::string path = dialog.get_filename();
-    notebook_.OnOpenFile(path);
+    notebook.OnOpenFile(path);
     break;
   }
   case(Gtk::RESPONSE_CANCEL): {
@@ -201,20 +203,20 @@ void Window::OnOpenFile() {
 }
 
 bool Window::SaveFile() {
-  if(notebook_.OnSaveFile()) {
-    terminal_.PrintMessage("File saved to: " +
-			   notebook_.CurrentPagePath()+"\n");
+  if(notebook.OnSaveFile()) {
+    terminal.print("File saved to: " +
+			   notebook.CurrentTextView().file_path+"\n");
     return true;
   }
-  terminal_.PrintMessage("File not saved");
+  terminal.print("File not saved");
   return false;
 }
 bool Window::SaveFileAs() {
-  if(notebook_.OnSaveFile(notebook_.OnSaveFileAs())){
-    terminal_.PrintMessage("File saved to: " +
-			   notebook_.CurrentPagePath()+"\n");
+  if(notebook.OnSaveFile(notebook.OnSaveFileAs())){
+    terminal.print("File saved to: " +
+			   notebook.CurrentTextView().file_path+"\n");
     return true;
   }
-  terminal_.PrintMessage("File not saved");
+  terminal.print("File not saved");
   return false;
 }

juci/window.h

@@ -15,13 +15,11 @@ public:
   Gtk::Box window_box_;
   virtual ~Window() { }
 
-  
-//private:
   MainConfig main_config_;
   Keybindings::Controller keybindings_;
   Menu::Controller menu_;
-  Notebook::Controller notebook_;
-  Terminal::Controller terminal_;
+  Notebook::Controller notebook;
+  Terminal::Controller terminal;
   PluginApi api_;
   
   Keybindings::Controller& keybindings() { return keybindings_; }