zalox
/
juci-archives
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merged with master

master
oyvang 11 years ago
parent
aac51b73ee 5a41847518
commit
cd72ddef74
6 changed files with 268 additions and 190 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.h
  2. 4
      juci/config.cc
  3. 129
      juci/notebook.cc
  4. 12
      juci/notebook.h
  5. 66
      juci/source.cc
  6. 99
      juci/source.h

4
juci/api.h
Unescape View File

@ -55,9 +55,9 @@ namespace libjuci {
const std::string plugin_path, const std::string plugin_path,
const std::string menu_keybinding); const std::string menu_keybinding);
void AddMenuXml(const std::string plugin_name, void AddMenuXml(const std::string plugin_name,
const string parent_menu); const std::string parent_menu);
void AddSubMenuXml(const std::string plugin_name, void AddSubMenuXml(const std::string plugin_name,
const string parent_menu); const std::string parent_menu);
////////////////////////////// //////////////////////////////
//// Boost.Python methods //// //// Boost.Python methods ////
////////////////////////////// //////////////////////////////

4
juci/config.cc
Unescape View File

@ -17,16 +17,14 @@ void MainConfig::GenerateSource() {
boost::property_tree::ptree colors_json = source_json.get_child("colors"); boost::property_tree::ptree colors_json = source_json.get_child("colors");
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>());
std::cout << "inserting tag, key: " << i.first << " value: " << i.second.get_value<std::string>() << std::endl;
} }
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>());
std::cout << "inserting type, key: " << i.first << " value: " << i.second.get_value<std::string>() << std::endl;
} }
} }
void MainConfig::GenerateKeybindings() { void MainConfig::GenerateKeybindings() {
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)) {

129
juci/notebook.cc
Unescape View File

@ -1,6 +1,5 @@
#include "notebook.h" #include "notebook.h"
#include <fstream> #include <fstream>
#include "clangmm.h"
Notebook::Model::Model() { Notebook::Model::Model() {
cc_extension_ = ".cc"; cc_extension_ = ".cc";
@ -8,7 +7,7 @@ Notebook::Model::Model() {
scrollvalue_ = 50; scrollvalue_ = 50;
} }
Notebook::View::View() { Notebook::View::View() : notebook_() {
view_.pack2(notebook_); view_.pack2(notebook_);
view_.set_position(120); view_.set_position(120);
} }
@ -17,20 +16,14 @@ Notebook::Controller::Controller(Gtk::Window* window, Keybindings::Controller& k
Source::Config& source_cfg, Source::Config& source_cfg,
Directories::Config& dir_cfg) : Directories::Config& dir_cfg) :
source_config_(source_cfg), source_config_(source_cfg),
directories_(dir_cfg) { directories_(dir_cfg),
std::cout << "NOTEBOOK CONTROLLER"<< std::endl; index_(0, 1) {
window_ = window; window_ = window;
std::cout << "1"<< std::endl;
OnNewPage("juCi++"); OnNewPage("juCi++");
std::cout << "2"<< std::endl;
refClipboard_ = Gtk::Clipboard::get(); refClipboard_ = Gtk::Clipboard::get();
std::cout << "3"<< std::endl;
ispopup = false; ispopup = false;
std::cout << "4"<< std::endl;
view().pack1(directories_.widget(), true, true); view().pack1(directories_.widget(), true, true);
std::cout << "5"<< std::endl;
CreateKeybindings(keybindings); CreateKeybindings(keybindings);
std::cout << "FERDIG"<< std::endl;
} // Constructor } // Constructor
@ -147,34 +140,82 @@ bool Notebook::Controller:: OnMouseRelease(GdkEventButton* button){
} }
bool Notebook::Controller::OnKeyRelease(GdkEventKey* key) { bool Notebook::Controller::OnKeyRelease(GdkEventKey* key) {
if(key->keyval==46){ return GeneratePopup(key->keyval);
return GeneratePopup();
}
return false;
} }
bool Notebook::Controller::GeneratePopup(){ bool Notebook::Controller::GeneratePopup(int key_id) {
// 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
std::vector<std::string> items; Gtk::TextIter beg = CurrentTextView().get_buffer()->get_insert()->get_iter();
Gtk::TextIter start = CurrentTextView().get_buffer()->get_insert()->get_iter(); Gtk::TextIter end = CurrentTextView().get_buffer()->get_insert()->get_iter();
text_vec_.at(CurrentPage())->GetAutoCompleteSuggestions(start.get_line()+1, Gtk::TextIter tmp = CurrentTextView().get_buffer()->get_insert()->get_iter();
start.get_line_offset()+2, Gtk::TextIter tmp1 = CurrentTextView().get_buffer()->get_insert()->get_iter();
&items); Gtk::TextIter line =
std::cout << items.size()<< std::endl; CurrentTextView().get_buffer()->get_iter_at_line(tmp.get_line());
if(items.size()>0){ if (end.backward_char() && end.backward_char()) {
bool illegal_chars =
end.backward_search("\"", Gtk::TEXT_SEARCH_VISIBLE_ONLY, tmp, tmp1, line)
||
end.backward_search("//", Gtk::TEXT_SEARCH_VISIBLE_ONLY, tmp, tmp1, line);
if (illegal_chars) {
return false;
}
std::string c = text_vec_[CurrentPage()]->buffer()->get_text(end, beg);
switch (key_id) {
case 46:
break;
case 58:
if (c != "::") return false;
break;
case 60:
if (c != "->") return false;
break;
case 62:
if (c != "->") return false;
break;
default:
return false;
}
} else {
return false;
}
std::vector<Source::AutoCompleteData> acdata;
text_vec_.at(CurrentPage())->
GetAutoCompleteSuggestions(beg.get_line()+1,
beg.get_line_offset()+2,
&acdata);
std::map<std::string, std::string> items;
for (auto &data : acdata) {
std::stringstream ss;
std::string return_value;
for (auto &chunk : data.chunks_) {
switch (chunk.kind()) {
case clang::CompletionChunk_ResultType:
return_value = chunk.chunk();
break;
case clang::CompletionChunk_Informative:
break;
default:
ss << chunk.chunk();
break;
}
}
items[ss.str() + " --> " + return_value] = ss.str();
}
// Replace over with get suggestions from zalox! OVER IS JUST FOR TESTING // Replace over with get suggestions from zalox! OVER IS JUST FOR TESTING
Gtk::ScrolledWindow popup_scroll_; Gtk::ScrolledWindow popup_scroll_;
Gtk::ListViewText listview_(1, false, Gtk::SelectionMode::SELECTION_SINGLE); Gtk::ListViewText listview_(1, false, Gtk::SelectionMode::SELECTION_SINGLE);
popup_scroll_.set_policy(Gtk::PolicyType::POLICY_NEVER, popup_scroll_.set_policy(Gtk::PolicyType::POLICY_NEVER,
Gtk::PolicyType::POLICY_NEVER); Gtk::PolicyType::POLICY_NEVER);
listview_.set_enable_search(false); listview_.set_enable_search(true);
listview_.set_headers_visible(false); listview_.set_headers_visible(false);
listview_.set_hscroll_policy(Gtk::ScrollablePolicy::SCROLL_NATURAL); listview_.set_hscroll_policy(Gtk::ScrollablePolicy::SCROLL_NATURAL);
listview_.set_activate_on_single_click(true); listview_.set_activate_on_single_click(true);
for (auto &i : items) listview_.append(i); if (items.empty()) {
items["No suggestions found..."] = "";
}
for (auto &i : items) {
listview_.append(i.first);
}
popup_scroll_.add(listview_); popup_scroll_.add(listview_);
popup_.get_vbox()->pack_start(popup_scroll_); popup_.get_vbox()->pack_start(popup_scroll_);
popup_.set_transient_for(*window_); popup_.set_transient_for(*window_);
@ -186,15 +227,13 @@ bool Notebook::Controller::GeneratePopup(){
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);
PopupSelectHandler(popup_, listview_); PopupSelectHandler(popup_, listview_, &items);
ispopup = true; ispopup = true;
popup_.run(); popup_.run();
popup_.hide(); popup_.hide();
ispopup = false; ispopup = false;
return true; return true;
} }
return false;
}
bool Notebook::Controller::ScrollEventCallback(GdkEventScroll* scroll_event) { bool Notebook::Controller::ScrollEventCallback(GdkEventScroll* scroll_event) {
int page = CurrentPage(); int page = CurrentPage();
@ -236,6 +275,14 @@ void Notebook::Controller::OnNewPage(std::string name) {
Notebook().set_focus_child(text_vec_.at(Pages()-1)->view()); Notebook().set_focus_child(text_vec_.at(Pages()-1)->view());
} }
void Notebook::Controller::
MapBuffers(std::map<std::string, std::string> *buffers) {
for (auto &buffer : text_vec_) {
buffers->operator[](buffer->model().file_path()) =
buffer->buffer()->get_text().raw();
}
}
void Notebook::Controller::OnOpenFile(std::string path) { void Notebook::Controller::OnOpenFile(std::string path) {
OnCreatePage(); OnCreatePage();
text_vec_.back()->OnOpenFile(path); text_vec_.back()->OnOpenFile(path);
@ -243,16 +290,14 @@ void Notebook::Controller::OnOpenFile(std::string path) {
unsigned pos = path.find_last_of("/\\"); unsigned pos = path.find_last_of("/\\");
Notebook().append_page(*editor_vec_.back(), path.substr(pos+1)); Notebook().append_page(*editor_vec_.back(), path.substr(pos+1));
Notebook().show_all_children(); Notebook().show_all_children();
std::cout << "setting current page"<< std::endl;
Notebook().set_current_page(Pages()-1); Notebook().set_current_page(Pages()-1);
std::cout << "current page set" << std::endl;
Notebook().set_focus_child(text_vec_.back()->view()); Notebook().set_focus_child(text_vec_.back()->view());
OnBufferChange(); OnBufferChange();
} }
void Notebook::Controller::OnCreatePage() { void Notebook::Controller::OnCreatePage() {
text_vec_.push_back(new Source::Controller(source_config())); text_vec_.push_back(new Source::Controller(source_config(), this));
linenumbers_vec_.push_back(new Source::Controller(source_config())); linenumbers_vec_.push_back(new Source::Controller(source_config(), this));
scrolledline_vec_.push_back(new Gtk::ScrolledWindow()); scrolledline_vec_.push_back(new Gtk::ScrolledWindow());
scrolledtext_vec_.push_back(new Gtk::ScrolledWindow()); scrolledtext_vec_.push_back(new Gtk::ScrolledWindow());
editor_vec_.push_back(new Gtk::HBox()); editor_vec_.push_back(new Gtk::HBox());
@ -451,16 +496,17 @@ void Notebook::Controller::TextViewHandlers(Gtk::TextView& textview) {
textview.signal_key_release_event(). textview.signal_key_release_event().
connect(sigc::mem_fun(*this, &Notebook::Controller::OnKeyRelease), false); connect(sigc::mem_fun(*this, &Notebook::Controller::OnKeyRelease), false);
} }
void Notebook::Controller::PopupSelectHandler(Gtk::Dialog &popup, void Notebook::Controller::PopupSelectHandler(Gtk::Dialog &popup,
Gtk::ListViewText &listview){ Gtk::ListViewText &listview,
std::map<std::string, std::string>
*items) {
listview.signal_row_activated(). listview.signal_row_activated().
connect([this, &listview, &popup](const Gtk::TreeModel::Path& path, connect([this, &listview, &popup, items](const Gtk::TreeModel::Path& path,
Gtk::TreeViewColumn*) { Gtk::TreeViewColumn*) {
std::string selected = std::string selected = items->
listview.get_text(listview.get_selected()[0]); at(listview.get_text(listview.get_selected()[0]));
CurrentTextView().get_buffer()->insert_at_cursor(selected); CurrentTextView().get_buffer()->insert_at_cursor(selected);
popup.response(Gtk::RESPONSE_DELETE_EVENT); popup.response(Gtk::RESPONSE_DELETE_EVENT);
}); });
@ -472,7 +518,6 @@ void Notebook::Controller::PopupSetSize(Gtk::ScrolledWindow &scroll,
int textview_y = 150; int textview_y = 150;
bool is_never_scroll_x = true; bool is_never_scroll_x = true;
bool is_never_scroll_y = true; bool is_never_scroll_y = true;
std::cout << textview_x << std::endl;
if (current_x > textview_x) { if (current_x > textview_x) {
current_x = textview_x; current_x = textview_x;
is_never_scroll_x = false; is_never_scroll_x = false;
@ -540,7 +585,7 @@ void Notebook::Controller:: OnSaveFile() {
file.open (path); file.open (path);
file << CurrentTextView().get_buffer()->get_text(); file << CurrentTextView().get_buffer()->get_text();
file.close(); file.close();
text_vec_.at(CurrentPage())->set_path(path); text_vec_.at(CurrentPage())->set_file_path(path);
text_vec_.at(CurrentPage())->set_is_saved(true); text_vec_.at(CurrentPage())->set_is_saved(true);
} }
} }

12
juci/notebook.h
Unescape View File

@ -8,7 +8,9 @@
#include "directories.h" #include "directories.h"
#include <boost/algorithm/string/case_conv.hpp> #include <boost/algorithm/string/case_conv.hpp>
#include <type_traits> #include <type_traits>
#include <map>
#include <sigc++/sigc++.h> #include <sigc++/sigc++.h>
#include "clangmm.h"
namespace Notebook { namespace Notebook {
class Model { class Model {
@ -56,10 +58,12 @@ namespace Notebook {
void OnOpenFile(std::string filename); void OnOpenFile(std::string filename);
void OnCreatePage(); void OnCreatePage();
bool ScrollEventCallback(GdkEventScroll* scroll_event); bool ScrollEventCallback(GdkEventScroll* scroll_event);
void MapBuffers(std::map<std::string, std::string> *buffers);
clang::Index* index() { return &index_; }
int Pages(); int Pages();
Directories::Controller& directories() { return directories_; } Directories::Controller& directories() { return directories_; }
Gtk::Paned& view(); Gtk::Paned& view();
bool GeneratePopup(); bool GeneratePopup(int key);
void Search(bool forward); void Search(bool forward);
const Source::Config& source_config() { return source_config_; } const Source::Config& source_config() { return source_config_; }
bool OnMouseRelease(GdkEventButton* button); bool OnMouseRelease(GdkEventButton* button);
@ -68,7 +72,10 @@ namespace Notebook {
protected: protected:
void TextViewHandlers(Gtk::TextView& textview); void TextViewHandlers(Gtk::TextView& textview);
void PopupSelectHandler(Gtk::Dialog &popup, void PopupSelectHandler(Gtk::Dialog &popup,
Gtk::ListViewText &listview); Gtk::ListViewText &listview,
std::map<std::string, std::string>
*items);
private: private:
void CreateKeybindings(Keybindings::Controller& keybindings); void CreateKeybindings(Keybindings::Controller& keybindings);
void FindPopupPosition(Gtk::TextView& textview, void FindPopupPosition(Gtk::TextView& textview,
@ -97,6 +104,7 @@ namespace Notebook {
bool ispopup; bool ispopup;
Gtk::Dialog popup_; Gtk::Dialog popup_;
Gtk::Window* window_; Gtk::Window* window_;
clang::Index index_;
}; // class controller }; // class controller
} // namespace Notebook } // namespace Notebook
#endif // JUCI_NOTEBOOK_H_ #endif // JUCI_NOTEBOOK_H_

66
juci/source.cc
Unescape View File

@ -4,7 +4,7 @@
#include <boost/property_tree/json_parser.hpp> #include <boost/property_tree/json_parser.hpp>
#include <fstream> #include <fstream>
#include <boost/timer/timer.hpp> #include <boost/timer/timer.hpp>
#include "notebook.h"
#define log( var ) \ #define log( var ) \
std::cout << "source.cc (" << __LINE__ << ") " << #var << std::endl std::cout << "source.cc (" << __LINE__ << ") " << #var << std::endl
@ -102,16 +102,17 @@ Source::Model::Model(const Source::Config &config) :
void Source::Model:: void Source::Model::
InitSyntaxHighlighting(const std::string &filepath, InitSyntaxHighlighting(const std::string &filepath,
const std::string &project_path, const std::string &project_path,
const std::string &text, const std::map<std::string, std::string>
&buffers,
int start_offset, int start_offset,
int end_offset) { int end_offset,
set_file_path(filepath); clang::Index *index) {
set_project_path(project_path); set_project_path(project_path);
std::vector<const char*> arguments = get_compilation_commands(); std::vector<const char*> arguments = get_compilation_commands();
tu_ = clang::TranslationUnit(true, tu_ = clang::TranslationUnit(index,
filepath, filepath,
arguments, arguments,
text); buffers);
} }
// Source::View::UpdateLine // Source::View::UpdateLine
@ -123,7 +124,7 @@ OnLineEdit(const std::vector<Source::Range> &locations,
// Source::Model::UpdateLine // Source::Model::UpdateLine
int Source::Model:: int Source::Model::
ReParse(const std::string &buffer) { ReParse(const std::map<std::string, std::string> &buffer) {
return tu_.ReparseTranslationUnit(file_path(), buffer); return tu_.ReparseTranslationUnit(file_path(), buffer);
} }
@ -135,10 +136,12 @@ void Source::Controller::OnLineEdit() { }
void Source::Controller:: void Source::Controller::
GetAutoCompleteSuggestions(int line_number, GetAutoCompleteSuggestions(int line_number,
int column, int column,
std::vector<std::string> *suggestions) { std::vector<Source::AutoCompleteData>
*suggestions) {
parsing.lock(); parsing.lock();
model().GetAutoCompleteSuggestions(view().get_buffer() std::map<std::string, std::string> buffers;
->get_text().raw(), notebook_->MapBuffers(&buffers);
model().GetAutoCompleteSuggestions(buffers,
line_number, line_number,
column, column,
suggestions); suggestions);
@ -146,22 +149,23 @@ GetAutoCompleteSuggestions(int line_number,
} }
void Source::Model:: void Source::Model::
GetAutoCompleteSuggestions(const std::string& buffer, GetAutoCompleteSuggestions(const std::map<std::string, std::string> &buffers,
int line_number, int line_number,
int column, int column,
std::vector<std::string> *suggestions) { std::vector<Source::AutoCompleteData>
*suggestions) {
clang::CodeCompleteResults results(&tu_, clang::CodeCompleteResults results(&tu_,
file_path(), file_path(),
buffer, buffers,
line_number, line_number,
column); column);
for (int i = 0; i < results.size(); i++) { for (int i = 0; i < results.size(); i++) {
std::stringstream ss; const vector<clang::CompletionChunk> chunks_ = results.get(i).get_chunks();
const vector<clang::CompletionChunk> c = results.get(i).get_chunks(); std::vector<AutoCompleteChunk> chunks;
for (auto &stringchunk : c) { for (auto &chunk : chunks_) {
ss << stringchunk.chunk(); chunks.emplace_back(chunk);
} }
suggestions->emplace_back(ss.str()); suggestions->emplace_back(chunks);
} }
} }
@ -261,9 +265,9 @@ HighlightToken(clang::Token *token,
// Source::Controller::Controller() // Source::Controller::Controller()
// Constructor for Controller // Constructor for Controller
Source::Controller::Controller(const Source::Config &config) : Source::Controller::Controller(const Source::Config &config,
model_(config) { Notebook::Controller *notebook) :
} model_(config), notebook_(notebook) { }
// Source::Controller::view() // Source::Controller::view()
// return shared_ptr to the view // return shared_ptr to the view
@ -282,7 +286,6 @@ void Source::Controller::OnNewEmptyFile() {
model().set_file_path(filename); model().set_file_path(filename);
model().set_project_path(filename); model().set_project_path(filename);
s.save(""); s.save("");
//OnOpenFile(filename); //OYVANG ADDED; REMOVE IF WRONG
} }
string extract_file_path(const std::string &file_path) { string extract_file_path(const std::string &file_path) {
@ -312,7 +315,7 @@ void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges,
Glib::RefPtr<Gtk::TextBuffer> buffer = get_buffer(); Glib::RefPtr<Gtk::TextBuffer> buffer = get_buffer();
buffer->remove_all_tags(buffer->begin(), buffer->end()); buffer->remove_all_tags(buffer->begin(), buffer->end());
for (auto &range : ranges) { for (auto &range : ranges) {
string type = std::to_string(range.kind()); std::string type = std::to_string(range.kind());
try { try {
config.typetable().at(type); config.typetable().at(type);
} catch (std::exception) { } catch (std::exception) {
@ -335,19 +338,22 @@ void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges,
} }
void Source::Controller::OnOpenFile(const string &filepath) { void Source::Controller::OnOpenFile(const string &filepath) {
path_=filepath; set_file_path(filepath);
sourcefile s(filepath); sourcefile s(filepath);
std::map<std::string, std::string> buffers;
notebook_->MapBuffers(&buffers);
buffers[filepath] = s.get_content();
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 (check_extention(filepath)) {
view().ApplyConfig(model().config()); view().ApplyConfig(model().config());
model().InitSyntaxHighlighting(filepath, model().InitSyntaxHighlighting(filepath,
extract_file_path(filepath), extract_file_path(filepath),
buffer()->get_text().raw(), buffers,
start_offset, start_offset,
end_offset); end_offset,
notebook_->index());
view().OnUpdateSyntax(model().ExtractTokens(start_offset, end_offset), view().OnUpdateSyntax(model().ExtractTokens(start_offset, end_offset),
model().config()); model().config());
} }
@ -358,7 +364,10 @@ void Source::Controller::OnOpenFile(const string &filepath) {
if (parsing.try_lock()) { if (parsing.try_lock()) {
while (true) { while (true) {
const std::string raw = buffer()->get_text().raw(); const std::string raw = buffer()->get_text().raw();
if (model().ReParse(raw) == 0 && std::map<std::string, std::string> buffers;
notebook_->MapBuffers(&buffers);
buffers[model().file_path()] = raw;
if (model().ReParse(buffers) == 0 &&
raw == buffer()->get_text().raw()) { raw == buffer()->get_text().raw()) {
syntax.lock(); syntax.lock();
go = true; go = true;
@ -373,7 +382,6 @@ void Source::Controller::OnOpenFile(const string &filepath) {
} }
}); });
buffer()->signal_begin_user_action().connect([this]() { buffer()->signal_begin_user_action().connect([this]() {
if (go) { if (go) {
syntax.lock(); syntax.lock();

99
juci/source.h
Unescape View File

@ -3,31 +3,34 @@
#include <iostream> #include <iostream>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <string>
#include "gtkmm.h" #include "gtkmm.h"
#include "clangmm.h" #include "clangmm.h"
#include <thread> #include <thread>
#include <mutex> #include <mutex>
#include <string>
using std::string; namespace Notebook {
class Controller;
}
namespace Source { namespace Source {
class Config { class Config {
public: public:
Config(const Config &original); Config(const Config &original);
Config(); Config();
const std::unordered_map<string, string>& tagtable() const; const std::unordered_map<std::string, std::string>& tagtable() const;
const std::unordered_map<string, string>& typetable() const; const std::unordered_map<std::string, std::string>& typetable() const;
void SetTagTable(const std::unordered_map<string, string> &tagtable); void SetTagTable(const std::unordered_map<std::string, std::string>
void InsertTag(const string &key, const string &value); &tagtable);
void SetTypeTable(const std::unordered_map<string, string> &tagtable); void InsertTag(const std::string &key, const std::string &value);
void InsertType(const string &key, const string &value); void SetTypeTable(const std::unordered_map<std::string, std::string>
&tagtable);
void InsertType(const std::string &key, const std::string &value);
private: private:
std::unordered_map<string, string> tagtable_; std::unordered_map<std::string, std::string> tagtable_;
std::unordered_map<string, string> typetable_; std::unordered_map<std::string, std::string> typetable_;
string background_; std::string background_;
}; // class Config }; // class Config
class Location { class Location {
@ -48,13 +51,6 @@ namespace Source {
const Location& start() const { return start_; } const Location& start() const { return start_; }
const Location& end() const { return end_; } const Location& end() const { return end_; }
int kind() const { return kind_; } int kind() const { return kind_; }
void to_stream() const {
std::cout << "range: [" << start_.line_number()-1;
std::cout << ", " << end_.line_number()-1 << "] ";
std::cout << "<" << start_.column_offset()-1;
std::cout << ", " << end_.column_offset()-1 << ">";
std::cout << std::endl;
}
private: private:
Location start_; Location start_;
Location end_; Location end_;
@ -71,9 +67,27 @@ namespace Source {
const Config &config); const Config &config);
private: private:
string GetLine(const Gtk::TextIter &begin); std::string GetLine(const Gtk::TextIter &begin);
}; // class View }; // class View
class AutoCompleteChunk {
public:
explicit AutoCompleteChunk(const clang::CompletionChunk &chunk) :
chunk_(chunk.chunk()), kind_(chunk.kind()) { }
const std::string& chunk() const { return chunk_; }
const clang::CompletionChunkKind& kind() const { return kind_; }
private:
std::string chunk_;
enum clang::CompletionChunkKind kind_;
};
class AutoCompleteData {
public:
explicit AutoCompleteData(const std::vector<AutoCompleteChunk> &chunks) :
chunks_(chunks) { }
std::vector<AutoCompleteChunk> chunks_;
};
class Model{ class Model{
public: public:
// constructor for Source::Model // constructor for Source::Model
@ -81,58 +95,63 @@ namespace Source {
// inits the syntax highligthing on file open // inits the syntax highligthing on file open
void InitSyntaxHighlighting(const std::string &filepath, void InitSyntaxHighlighting(const std::string &filepath,
const std::string &project_path, const std::string &project_path,
const std::string &text, const std::map<std::string, std::string>
&buffers,
int start_offset, int start_offset,
int end_offset); int end_offset,
clang::Index *index);
// sets the filepath for this mvc // sets the filepath for this mvc
void set_file_path(const string &file_path); void set_file_path(const std::string &file_path);
// sets the project path for this mvc // sets the project path for this mvc
void set_project_path(const string &project_path); void set_project_path(const std::string &project_path);
// gets the file_path member // gets the file_path member
const string& file_path() const; const std::string& file_path() const;
// gets the project_path member // gets the project_path member
const string& project_path() const; const std::string& project_path() const;
// gets the config member // gets the config member
const Config& config() const; const Config& config() const;
void GetAutoCompleteSuggestions(const std::string& buffer, void GetAutoCompleteSuggestions(const std::map<std::string, std::string>
&buffers,
int line_number, int line_number,
int column, int column,
std::vector<std::string> *suggestions); std::vector<AutoCompleteData>
*suggestions);
~Model() { } ~Model() { }
int ReParse(const std::string &buffer); int ReParse(const std::map<std::string, std::string> &buffers);
std::vector<Range> ExtractTokens(int, int); std::vector<Range> ExtractTokens(int, int);
private: private:
Config config_; Config config_;
string file_path_; std::string file_path_;
string project_path_; std::string project_path_;
clang::TranslationUnit tu_; clang::TranslationUnit tu_;
void HighlightToken(clang::Token *token, void HighlightToken(clang::Token *token,
std::vector<Range> *source_ranges, std::vector<Range> *source_ranges,
int token_kind); int token_kind);
void HighlightCursor(clang::Token *token, void HighlightCursor(clang::Token *token,
std::vector<Range> *source_ranges); std::vector<Range> *source_ranges);
std::vector<const char*> get_compilation_commands(); std::vector<const char*> get_compilation_commands();
}; };
class Controller { class Controller {
public: public:
explicit Controller(const Source::Config &config); Controller(const Source::Config &config,
Notebook::Controller *notebook);
Controller(); Controller();
View& view(); View& view();
Model& model(); Model& model();
void OnNewEmptyFile(); void OnNewEmptyFile();
void OnOpenFile(const string &filename); void OnOpenFile(const std::string &filename);
void GetAutoCompleteSuggestions(int line_number, void GetAutoCompleteSuggestions(int line_number,
int column, int column,
std::vector<std::string> *suggestions); std::vector<AutoCompleteData>
*suggestions);
Glib::RefPtr<Gtk::TextBuffer> buffer(); Glib::RefPtr<Gtk::TextBuffer> buffer();
bool is_saved(){return is_saved_;}; bool is_saved() { return is_saved_; }
std::string path(){return 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_path(std::string path){path_ = path;}; void set_file_path(std::string path) { model().set_file_path(path); }
private: private:
@ -140,13 +159,13 @@ namespace Source {
void OnSaveFile(); void OnSaveFile();
std::mutex syntax; std::mutex syntax;
std::mutex parsing; std::mutex parsing;
std::string path_;
bool go = false; bool go = false;
bool is_saved_ = false; bool is_saved_ = false;
protected: protected:
View view_; View view_;
Model model_; Model model_;
Notebook::Controller *notebook_;
}; // class Controller }; // class Controller
} // namespace Source } // namespace Source
#endif // JUCI_SOURCE_H_ #endif // JUCI_SOURCE_H_

Write Preview
Loading…
Cancel
Save