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

Merge branch 'master' of bitbucket.org:cppit/juci

merge-requests/365/head
Jørgen Lien Sellæg 11 years ago
parent
a07b4c9829 b0b2400f5f
commit
5ab30b25e0
19 changed files with 250 additions and 341 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. 1
      .gitignore
  2. 2
      juci/CMakeLists.txt
  3. 157
      juci/api.cc
  4. 88
      juci/api.h
  5. 9
      juci/api_ext.cc
  6. 4
      juci/cmake/Modules/FindTestlcl.cmake
  7. 2
      juci/juci.cc
  8. 8
      juci/menu.cc
  9. 3
      juci/menu.h
  10. 2
      juci/notebook.h
  11. 57
      juci/plugin/CMakeLists.txt
  12. 118
      juci/plugin/plugin.cc
  13. 28
      juci/plugin/plugin.h
  14. 8
      juci/plugin/plugin_ext.cc
  15. 39
      juci/plugin/randomtext.txt
  16. 50
      juci/snippet.py
  17. 4
      juci/source.cc
  18. 10
      juci/window.cc
  19. 7
      juci/window.h

1
.gitignore vendored
Unescape View File

@ -9,3 +9,4 @@
!*.h !*.h
!CMakeLists.txt !CMakeLists.txt
!config.json !config.json
!*.py

2
juci/CMakeLists.txt
Unescape View File

@ -104,7 +104,7 @@ include_directories(
${Boost_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS}
${PYTHON_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}
${GTKMM_INCLUDE_DIRS} ${GTKMM_INCLUDE_DIRS}
"/home/zalox/bachelor/libclang++/headers/" ${LCL_INCLUDE_DIRS}
) )
link_directories( link_directories(
${GTKMM_LIBRARY_DIRS} ${GTKMM_LIBRARY_DIRS}

157
juci/api.cc
Unescape View File

@ -1,47 +1,134 @@
#include "api.h" #include "api.h"
namespace juci_api{
void cpp::ReplaceWord(const std::string word) { std::shared_ptr<Menu::Controller> libjuci::ApiServiceProvider::menu_;
//TODO implement api::ReplaceWord / change string to iter? std::shared_ptr<Notebook::Controller> libjuci::ApiServiceProvider::notebook_;
//some_namespace::controller::replaceWord(word_*);
std::cout << "unimplemented function: 'api::ReplaceWord()' called"
<< std::endl;
std::cout << "The string: " << g_test_string << std::endl; /////////////////////////////
//// API ServiceProvider ////
/////////////////////////////
libjuci::ApiServiceProvider::ApiServiceProvider( ) {
std::cout << "Apiservice std.ctor" << std::endl;
}
void libjuci::ApiServiceProvider::ReplaceWord(std::string word) {
Glib::RefPtr<Gtk::TextBuffer> buffer = libjuci::BufferFromNotebook();
Gtk::TextIter word_start = libjuci::IterFromNotebook();
Gtk::TextIter word_end = libjuci::IterFromNotebook();
libjuci::IterToWordStart(word_start);
libjuci::IterToWordEnd(word_end);
if(word_start != word_end) {
buffer->erase(word_start, word_end);
Gtk::TextIter current = libjuci::IterFromNotebook();
buffer->insert(current, word);
}
}
void libjuci::ApiServiceProvider::ReplaceLine(std::string line) {
std::cout << "Unimplemented function: ApiServiceProvider::ReplaceLine(string)"
<< std::endl;
}
std::string libjuci::ApiServiceProvider::GetWord() {
Glib::RefPtr<Gtk::TextBuffer> buffer = libjuci::BufferFromNotebook();
Gtk::TextIter word_start = libjuci::IterFromNotebook();
Gtk::TextIter word_end = libjuci::IterFromNotebook();
libjuci::IterToWordStart(word_start);
libjuci::IterToWordEnd(word_end);
std::cout <<"start: " << word_start << std::endl << "end: " << word_end << std::endl;
if(word_start < word_end) {
std::string word = buffer->get_text(word_start, word_end);
return word;
} }
return "";
}
void libjuci::ApiServiceProvider::AddKeybinding() {
libjuci::ApiServiceProvider::menu_->keybindings_.action_group_menu()
->add(Gtk::Action::create("PluginAddSnippet",
"Add snippet"),
Gtk::AccelKey("<control><alt>space"),
[]() {
std::cout << "ctrl alt space" << std::endl;
libjuci::LoadPlugin("snippet");
});
std::cout << "addkeybinding" << std::endl;
}
///////////////////////
//// Api to python ////
///////////////////////
void libjuci::ReplaceWord(const std::string word_) {
libjuci::ApiServiceProvider::ReplaceWord(word_);
}
void cpp::ReplaceLine(const std::string line) { void libjuci::ReplaceLine(const std::string line) {
//TODO implement api::ReplaceLine / change string to iter? //TODO forgie: implement libjuci::ReplaceLine / change string to iter?
//some_namespace::controller::replaceLine(line_); //some_namespace::controller::replaceLine(line_);
std::cout << "unimplemented function: 'api::ReplaceLine()' called" std::cout << "unimplemented function: 'libjuci::ReplaceLine()' called"
<< std::endl; << std::endl;
}
std::string libjuci::GetWord() {
// boost::python::str converted(libjuci::ApiServiceProvider::GetWord() );
return libjuci::ApiServiceProvider::GetWord();
// return converted;
}
//////////////////////////////
//// Boost.Python methods ////
//////////////////////////////
boost::python::api::object libjuci::openPythonScript(const std::string path,
boost::python::api::object python_name_space) {
std::string temp = g_project_root + path + ".py";
boost::python::str the_path(temp);
return boost::python::exec_file(the_path, python_name_space);//, python_name_space);
}
void libjuci::LoadPlugin(const std::string& plugin_name) {
try{
Py_Initialize();
boost::python::api::object main_module = boost::python::import("__main__");
boost::python::api::object main_namespace = main_module.attr("__dict__");
boost::python::api::object ignored2 = openPythonScript(plugin_name, main_namespace);
/* for extracting return value from python: */
//boost::python::object returnValue = boost::python::eval("function_name()", main_namespace);
//std::string return_value = boost::python::extract<std::string>(pySnippet);
//do something with return_value
}catch(boost::python::error_already_set const&) {
PyErr_Print();
} }
}
//helpers ///////////////////////
boost::python::api::object py::openPythonScript(const std::string path, //// Glib wrappers ////
boost::python::api::object python_name_space) { ///////////////////////
std::string temp = g_project_root + path + ".py"; void libjuci::IterToWordStart(Gtk::TextIter &iter) {
boost::python::str the_path(temp); if(!iter.starts_line()) {
return boost::python::exec_file(the_path, python_name_space);//, python_name_space); while(!iter.starts_word()) {
iter.backward_char();
}
} }
}
void py::LoadPlugin(const std::string& plugin_name) { void libjuci::IterToWordEnd(Gtk::TextIter &iter) {
try{ if(!iter.ends_line()) {
/* initialize python interpreter */ while(!iter.ends_word()) {
Py_Initialize(); iter.forward_char();
boost::python::api::object main_module = boost::python::import("__main__");
boost::python::api::object main_namespace = main_module.attr("__dict__");
/* runs script from python */
//boost::python::object ignored1 = setPythonVar("word", word, main_namespace);
boost::python::api::object ignored2 = openPythonScript(plugin_name, main_namespace);
/* extracts desired values */
//boost::python::object pySnippet = boost::python::eval("getSnippet()", main_namespace);
//word = boost::python::extract<std::string>(pySnippet);
/* add snippet to textView */
//TODO add snippet
}catch(boost::python::error_already_set const&) {
PyErr_Print();
} }
} }
} }
Glib::RefPtr<Gtk::TextBuffer> libjuci::BufferFromNotebook() {
return Glib::RefPtr<Gtk::TextBuffer>(libjuci::ApiServiceProvider::notebook_->source_vec_.back()->view().get_buffer());
}
Gtk::TextIter libjuci::IterFromNotebook() {
return libjuci::BufferFromNotebook()->get_insert()->get_iter();
}

88
juci/api.h
Unescape View File

@ -4,44 +4,52 @@
#include <boost/python.hpp> #include <boost/python.hpp>
#include <Python.h> #include <Python.h>
#include <string> #include <string>
#include "notebook.h"
// Plugin API #include "menu.h"
//
const std::string g_project_root("/home/forgie/bachelor/app/juci/"); const std::string g_project_root("/home/forgie/app/juci/");
static std::string g_test_string("test");
namespace juci_api { namespace libjuci {
//
// calls from python to C++ /////////////////////////////
// //// API ServiceProvider ////
namespace cpp { /////////////////////////////
struct ApiServiceProvider {
public:
// Replaceword: static std::shared_ptr<Menu::Controller> menu_;
// replaces a word in the editor with a string static std::shared_ptr<Notebook::Controller> notebook_;
static std::string text;
void ReplaceWord(const std::string word_);
ApiServiceProvider();
// static void AddKeybinding();
// ReplaceLine:
// Replaces a line in the editor with a string //for Python module:
// static std::string GetWord();
void ReplaceLine(const std::string line_); static void ReplaceWord(const std::string word);
static void ReplaceLine(const std::string line);
}//namespace cpp };
// ///////////////////////
// calls from C++ to Python //// Glib wrappers ////
// ///////////////////////
namespace py { void IterToWordStart(Gtk::TextIter &iter);
void IterToWordEnd(Gtk::TextIter &iter);
Gtk::TextIter IterFromNotebook();
//helpers Glib::RefPtr<Gtk::TextBuffer> BufferFromNotebook();
boost::python::api::object openPythonScript(const std::string path,
boost::python::api::object python_name_space); ///////////////////////
//// Api to python ////
//void snippet(std::string& word); ///////////////////////
void ReplaceWord(const std::string word_);
void LoadPlugin(const std::string& plugin_name); void ReplaceLine(const std::string line_);
}// py std::string GetWord();
}//juci_api
//////////////////////////////
//// Boost.Python methods ////
//////////////////////////////
boost::python::api::object openPythonScript(const std::string path,
boost::python::api::object python_name_space);
void LoadPlugin(const std::string& plugin_name);
}//libjuci
#endif // JUCI_API_H #endif // JUCI_API_H

9
juci/api_ext.cc
Unescape View File

@ -1,7 +1,10 @@
#include "api.h" #include "api.h"
BOOST_PYTHON_MODULE(juci_to_python_api) { BOOST_PYTHON_MODULE(juci_to_python_api) {
using namespace boost::python; using namespace boost::python;
// text editing // text editing
def("replaceLine", &juci_api::cpp::ReplaceLine); def("replaceLine", &libjuci::ReplaceLine);
def("replaceWord", &juci_api::cpp::ReplaceWord); def("replaceWord", &libjuci::ReplaceWord);
}// module::juci def("getWord", &libjuci::GetWord);
//something more
}// module::juci_to_python_api

4
juci/cmake/Modules/FindTestlcl.cmake
Unescape View File

@ -10,11 +10,11 @@
find_package(PkgConfig) find_package(PkgConfig)
find_path(LCL_INCLUDE_DIR headers/TranslationUnit.h find_path(LCL_INCLUDE_DIR headers/TranslationUnit.h
HINTS "/home/zalox/bachelor/libclang++/" HINTS "/home/forgie/code/libclangpp/"
) )
find_library(LCL_LIBRARY NAMES testlcl find_library(LCL_LIBRARY NAMES testlcl
HINTS "/home/zalox/bachelor/libclang++/lib") HINTS "/home/forgie/code/libclangpp/lib")
set(LCL_LIBRARIES ${LCL_LIBRARY} ) set(LCL_LIBRARIES ${LCL_LIBRARY} )
set(LCL_INCLUDE_DIRS ${LCL_INCLUDE_DIR} ) set(LCL_INCLUDE_DIRS ${LCL_INCLUDE_DIR} )

2
juci/juci.cc
Unescape View File

@ -7,5 +7,7 @@ int main(int argc, char *argv[]) {
argv, argv,
"no.sout.juci"); "no.sout.juci");
Window window; Window window;
//api::LoadPlugin("juci_api_test");
return app->run(window); return app->run(window);
} }

8
juci/menu.cc
Unescape View File

@ -36,12 +36,12 @@ Menu::Controller::Controller(Keybindings::Controller& keybindings) :
"_Plugins")); "_Plugins"));
keybindings_.action_group_menu()->add(Gtk::Action::create("PluginSnippet", keybindings_.action_group_menu()->add(Gtk::Action::create("PluginSnippet",
"Snippet")); "Snippet"));
keybindings_.action_group_menu()->add(Gtk::Action::create("PluginAddSnippet", /*keybindings_.action_group_menu()->add(Gtk::Action::create("PluginAddSnippet",
"Add snippet"), "Add snippet"),
Gtk::AccelKey("<alt>space"), Gtk::AccelKey("<alt>space"),
[this]() { [this]() {
OnPluginAddSnippet(); OnPluginAddSnippet();
}); });*/
keybindings_.action_group_menu()->add(Gtk::Action::create("HelpMenu", keybindings_.action_group_menu()->add(Gtk::Action::create("HelpMenu",
Gtk::Stock::HELP)); Gtk::Stock::HELP));
keybindings_.action_group_menu()->add(Gtk::Action::create("HelpAbout", keybindings_.action_group_menu()->add(Gtk::Action::create("HelpAbout",
@ -62,8 +62,8 @@ Gtk::Box &Menu::Controller::view() {
} }
void Menu::Controller::OnPluginAddSnippet() { void Menu::Controller::OnPluginAddSnippet() {
//TODO(Forgi add you snippet magic code) //TODO(Forgi add you snippet magic code)
std::cout << "Add snipper" << std::endl; std::cout << "Add snippet" << std::endl;
juci_api::py::LoadPlugin("snippet"); //juci_api::py::LoadPlugin("snippet");
} }
void Menu::Controller::OnFileOpenFile() { void Menu::Controller::OnFileOpenFile() {
std::cout << "Open file clicked" << std::endl; std::cout << "Open file clicked" << std::endl;

3
juci/menu.h
Unescape View File

@ -4,7 +4,6 @@
#include <iostream> #include <iostream>
#include "gtkmm.h" #include "gtkmm.h"
#include "keybindings.h" #include "keybindings.h"
#include "api.h"
namespace Menu { namespace Menu {
class View { class View {
@ -18,7 +17,7 @@ namespace Menu {
public: public:
explicit Controller(Keybindings::Controller& keybindings); explicit Controller(Keybindings::Controller& keybindings);
Gtk::Box &view(); Gtk::Box &view();
private:
Keybindings::Controller &keybindings_; Keybindings::Controller &keybindings_;
View menu_view_; View menu_view_;
void OnFileNewEmptyfile(); void OnFileNewEmptyfile();

2
juci/notebook.h
Unescape View File

@ -24,7 +24,7 @@ namespace Notebook {
void OnNewPage(std::string name); void OnNewPage(std::string name);
void OnCloseCurrentPage(); void OnCloseCurrentPage();
void OnOpenFile(std::string filename); void OnOpenFile(std::string filename);
private: // private:
View view_; View view_;
Entry::Controller entry_; Entry::Controller entry_;
std::vector<Source::Controller*> source_vec_; std::vector<Source::Controller*> source_vec_;

57
juci/plugin/CMakeLists.txt
Unescape View File

@ -1,57 +0,0 @@
cmake_minimum_required (VERSION 2.4)
set(project_name plugin)
project (${project_name})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
include(FindPkgConfig)
#Boost_FOUND - True if headers and requested libraries were found
#Boost_INCLUDE_DIRS - Boost include directories
#Boost_LIBRARY_DIRS - Link directories for Boost libraries
#Boost_LIBRARIES - Boost component libraries to be linked
find_package(Boost 1.55 REQUIRED COMPONENTS python system )
if(!${Boost_FOUND})
message(FATAL_ERROR "Boost libraries not found")
endif()
#GTKMM_FOUND - True if headers and requested libraries were found
#GTKMM_INCLUDE_DIRS - GTKMM include directories
#GTKMM_LIBRARY_DIRS - Link directories for GTKMM libraries
#GTKMM_LIBRARIES - GTKMM component libraries to be linked
pkg_check_modules(GTKMM REQUIRED gtkmm-3.0)
if(!${GTKMM_FOUND})
message(FATAL_ERROR "Gtkmm not found")
endif()
#PYTHONLIBS_FOUND - True if headers and requested libraries were found
#PYTHON_INCLUDE_DIRS - GTKMM include directories
#PYTHON_LIBRARIES - GTKMM component libraries to be linked
#$PYTHONLIBS_VERSION_STRING - ersion string
find_package(PythonLibs 2.7 REQUIRED)
if(!${PYTHONLIBS_FOUND})
message(FATAL_ERROR "Pythonlibs not found")
else()
message("Found python libs ${PYTHONLIBS_VERSION_STRING}")
endif()
ADD_LIBRARY(plugintest_ext MODULE
plugin.h
plugin.cc
plugin_ext.cc
)
set_target_properties(plugintest_ext PROPERTIES PREFIX "")
target_link_libraries(plugintest_ext ${Boost_LIBRARIES})
add_executable(${project_name}
plugin.h
plugin.cc
)
include_directories(${PYTHON_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${GTKMM_INCLUDE_DIRS})
link_directories(${GTKMM_LIBRARY_DIRS} ${Boost_LIBRARY_DIRS} ${PYTHON_LIBRARIES})
target_link_libraries(${project_name} ${Boost_LIBRARIES} ${PYTHON_LIBRARIES} ${GTKMM_LIBRARIES})

118
juci/plugin/plugin.cc
Unescape View File

@ -1,118 +0,0 @@
#include "plugin.h"
////////////////////////////////////////////////////////////////////////////////
//
// setPythonVar:
// initiates a string value (k_var_value) to a declared variable name
// (k_var_name) within a given namespace(python_name_space)
//
////////////////////////////////////////////////////////////////////////////////
bp::object Plugin::setPythonVar(const std::string k_var_name,
const std::string k_var_value,
bp::object python_name_space ) {
std::string temp = k_var_name + " = \"" + k_var_value + "\"";
bp::str the_var(temp);
return bp::exec(the_var, python_name_space);
}
////////////////////////////////////////////////////////////////////////////////
//
// openPythonScript:
// Opens a python plugin script within a file path and a python namespace
//
////////////////////////////////////////////////////////////////////////////////
bp::object Plugin::openPythonScript(const std::string path,
bp::object python_name_space) {
std::string temp = g_project_root + "plugins/" + path + "/" + path + ".py";
bp::str the_path(temp);
return bp::exec_file(the_path, python_name_space);
}
////////////////////////////////////////////////////////////////////////////////
//
// for testing purposes only
//
////////////////////////////////////////////////////////////////////////////////
std::string Plugin::get_test_value2(){
return "STRING FROM WITHIN C++";
}
/* public functions */
////////////////////////////////////////////////////////////////////////////////
//
// snippet:
// takes a std::string and converts it into a matching snippet
// if no matching snippet, returns the same string
//
////////////////////////////////////////////////////////////////////////////////
void Plugin::snippet(std::string& word){
try{
/* initialize python interpreter */
Py_Initialize();
bp::object main_module = bp::import("__main__");
bp::object main_namespace = main_module.attr("__dict__");
/* runs script from python */
bp::object ignored1 = setPythonVar("word", word, main_namespace);
bp::object ignored2 = openPythonScript(__func__, main_namespace);
/* extracts desired values */
bp::object pySnippet = bp::eval("getSnippet()", main_namespace);
word = bp::extract<std::string>(pySnippet);
/* add snippet to textView */
//TODO add snippet
}catch(bp::error_already_set const&){
PyErr_Print();
}
}
////////////////////////////////////////////////////////////////////////////////
//
// get_test_value:
// for testing purposes
// uses a python module generated from c++
// calls c++ function from python
// returns string to c++ from python
// prints the string from python within c++
//
////////////////////////////////////////////////////////////////////////////////
void Plugin::get_test_value(){
try{
/* initialize python interpreter */
Py_Initialize();
bp::object main_module = bp::import("__main__");
bp::object main_namespace = main_module.attr("__dict__");
/* runs script from python */
const std::string path("test");
bp::object ignored2 = openPythonScript(path, main_namespace);
/* extracts desired values */
bp::object pySnippet = bp::eval("get_test_value()", main_namespace);
std::string mword = bp::extract<std::string>(pySnippet);
/* add snippet to textView */
std::cout << mword << std::endl;
//TODO add snippet
}catch(bp::error_already_set const&){
PyErr_Print();
}
}
int main(int argc, char *argv[])
{
std::string word("ifelse");
Plugin::snippet(word);
//Plugin::get_test_value();
std::cout << word << std::endl;
return 0;
}

28
juci/plugin/plugin.h
Unescape View File

@ -1,28 +0,0 @@
#ifndef JUCI_PLUGIN_H_
#define JUCI_PLUGIN_H_
#include <boost/python.hpp>
#include <Python.h>
#include <string>
#include <iostream>
namespace bp = boost::python;
const std::string g_project_root("~/q6/testing/plugin/");
//TODO (forgie) get current working directory..
class Plugin{
public:
static void snippet(std::string& word);
static void get_test_value();
static std::string get_test_value2();
private:
static bp::object setPythonVar(const std::string varName,
const std::string varValue,
bp::object python_name_space);
static bp::object openPythonScript(const std::string path,
bp::object python_name_space);
};
#endif // JUCI_PLUGIN_H_

8
juci/plugin/plugin_ext.cc
Unescape View File

@ -1,8 +0,0 @@
#include "plugin.h"
#include <boost/python.hpp>
using namespace boost::python;
BOOST_PYTHON_MODULE(plugintest_ext)
{
def("get_test_value2", &Plugin::get_test_value2);
}

39
juci/plugin/randomtext.txt
Unescape View File

@ -1,39 +0,0 @@
/*
void theprogram()
{
std::string input;
std::cout << "Enter string to transform: ";
std::getline(std::cin, input);
//std::string inttransformed = CallPythonPlugIn(input);
std::cout << "The transformed string is: " << input << std::endl;
}
int test1()
{
try{
Py_Initialize();
object main_module = import("__main__");
object main_namespace = main_module.attr("__dict__");
object ignored = exec("result = 5 ** 2", main_namespace);
int five_squared = extract<int>(main_namespace["result"]);
printf("%d\n", five_squared);
return five_squared;
}
catch(error_already_set const&){
PyErr_Print();
}
return -1;
}
void test2(int theNum, int &test)
{
int seven = 7;
test = 7+ theNum;
std::cout << theNum << std::endl;
}
*/

50
juci/snippet.py
Unescape View File

@ -0,0 +1,50 @@
#!/usr/bin/python
#snippet plugin
import juci_to_python_api
snippets = {}
snippets["for"] = """\
for(#int i=0; #i<#v.size(); #i++) {
std::cout << v[i] << std::endl;
}
"""
snippets["if"] = """\
if(#) {
#
}
"""
snippets["ifelse"] = """\
if(#) {
#
} else {
#
}
"""
snippets["while"] = """\
while(#) {
#
}
"""
snippets["main"] = """\
int main(int argc, char *argv[]) {
//Do something
}
"""
snippets["hello"] = """\
#include <iostream>
int main(int argc, char *argv[]) {
std::cout << "Hello, world! << std::endl;
}
"""
def getSnippet(word):
try:
output = snippets[word]
except KeyError:
output = word
return output
theWord=juci_to_python_api.getWord()
output=getSnippet(theWord)
juci_to_python_api.replaceWord(output)

4
juci/source.cc
Unescape View File

@ -108,7 +108,7 @@ void Source::Theme::SetTagTable(
//// Model //// //// Model ////
/////////////// ///////////////
Source::Model::Model() : Source::Model::Model() :
theme_() { theme_() {/*
std::cout << "Model constructor run" << std::endl; std::cout << "Model constructor run" << std::endl;
boost::property_tree::ptree pt; boost::property_tree::ptree pt;
boost::property_tree::json_parser::read_json("config.json", pt); boost::property_tree::json_parser::read_json("config.json", pt);
@ -124,7 +124,7 @@ Source::Model::Model() :
// std::cout << "inserting type. " << pi.first << pi.second.get_value<std::string>() << std::endl; // std::cout << "inserting type. " << pi.first << pi.second.get_value<std::string>() << std::endl;
} }
} }
} }*/
} }
Source::Theme& Source::Model::theme() { Source::Theme& Source::Model::theme() {

10
juci/window.cc
Unescape View File

@ -17,6 +17,11 @@ Window::Window() :
[this]() { [this]() {
OnOpenFile(); OnOpenFile();
}); });
libjuci::ApiServiceProvider::menu_ = std::shared_ptr<Menu::Controller>(&menu_);
libjuci::ApiServiceProvider::notebook_ = std::shared_ptr<Notebook::Controller>(&notebook_);
libjuci::ApiServiceProvider::AddKeybinding();
add_accel_group(keybindings_.ui_manager_menu()->get_accel_group()); add_accel_group(keybindings_.ui_manager_menu()->get_accel_group());
add_accel_group(keybindings_.ui_manager_hidden()->get_accel_group()); add_accel_group(keybindings_.ui_manager_hidden()->get_accel_group());
@ -25,7 +30,10 @@ Window::Window() :
window_box_.pack_start(notebook_.view()); window_box_.pack_start(notebook_.view());
show_all_children(); show_all_children();
} // Window constructor } // Window constructor
void Window::OnWindowHide() { void Window::OnWindowHide(){
//TODO forgie: find out how to 'remove' the pointers
libjuci::ApiServiceProvider::notebook_ = std::shared_ptr<Notebook::Controller>(nullptr);
libjuci::ApiServiceProvider::menu_ = std::shared_ptr<Menu::Controller>(nullptr);
hide(); hide();
} }

7
juci/window.h
Unescape View File

@ -3,14 +3,14 @@
#include <iostream> #include <iostream>
#include "gtkmm.h" #include "gtkmm.h"
#include "menu.h" #include "api.h"
#include "notebook.h" #include <cstddef>
class Window : public Gtk::Window { class Window : public Gtk::Window {
public: public:
Window(); Window();
Gtk::Box window_box_; Gtk::Box window_box_;
private: //private:
Keybindings::Controller keybindings_; Keybindings::Controller keybindings_;
Menu::Controller menu_; Menu::Controller menu_;
Notebook::Controller notebook_; Notebook::Controller notebook_;
@ -21,3 +21,4 @@ private:
}; };
#endif // JUCI_WINDOW_H_ #endif // JUCI_WINDOW_H_

Write Preview
Loading…
Cancel
Save