C++ source, ASCII text
1
#include "gpanthera.hh"
2
#include <gtkmm.h>
3
#include <glibmm.h>
4
#include <glibmm/ustring.h>
5
#include <iostream>
6
#include <memory>
7
#include <libintl.h>
8
#include <locale.h>
9
#include <gtk/gtk.h>
10
#include <gdk/gdk.h>
11
#include <webkit/webkit.h>
12
#include <fstream>
13
#include <nlohmann/json.hpp>
14
#include <iomanip>
15
#include <sstream>
16
#include <dlfcn.h>
17
#include "plugin_api.h"
18
using plugin_entrypoint_type = void(*)(void);
20
std::string url_encode(const std::string &value) {
22
// Thanks https://stackoverflow.com/a/17708801
23
std::ostringstream escaped;
24
escaped.fill('0');
25
escaped << std::hex;
26
for(char c : value) {
28
// Keep alphanumeric and other accepted characters intact
29
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
30
escaped << c;
31
continue;
32
}
33
// Any other characters are percent-encoded
35
escaped << std::uppercase;
36
escaped << '%' << std::setw(2) << int((unsigned char) c);
37
escaped << std::nouppercase;
38
}
39
return escaped.str();
41
}
42
struct SearchEngine {
44
Glib::ustring name;
45
Glib::ustring url;
46
Glib::ustring get_search_url(const std::string &query) {
47
auto pos = url.find("%s");
48
if(pos == Glib::ustring::npos) {
49
throw std::runtime_error("Invalid search engine URL: missing '%s' placeholder");
50
}
51
auto new_url = url;
52
new_url.replace(pos, 2, url_encode(query));
53
return new_url;
54
}
55
};
56
class PantheraWww : public Gtk::Application {
58
Gtk::Window *window = Gtk::make_managed<Gtk::Window>();
59
protected:
60
std::shared_ptr<gPanthera::LayoutManager> layout_manager;
61
std::shared_ptr<gPanthera::ContentManager> content_manager;
62
Gtk::Entry *url_bar = nullptr;
63
std::string cookie_file = "cookies.txt";
64
std::vector<SearchEngine> search_engines;
65
SearchEngine *default_search_engine = nullptr;
66
static void notify_callback(GObject *object, GParamSpec *pspec, gpointer data) {
68
if(!gtk_widget_get_parent(GTK_WIDGET(object))) {
69
return;
70
}
71
auto parent = gtk_widget_get_parent(gtk_widget_get_parent(GTK_WIDGET(object)));
72
if(auto page = dynamic_cast<gPanthera::ContentPage*>(Glib::wrap(parent))) {
73
if(g_strcmp0(pspec->name, "title") == 0) {
74
if(auto label = dynamic_cast<Gtk::Label*>(page->tab_widget->get_last_child())) {
75
if(strlen(webkit_web_view_get_title(WEBKIT_WEB_VIEW(object))) == 0) {
76
label->set_label("Untitled");
77
} else {
78
label->set_label(webkit_web_view_get_title(WEBKIT_WEB_VIEW(object)));
79
}
80
}
81
} else if(g_strcmp0(pspec->name, "favicon") == 0) {
82
// Update favicons
83
if(auto image = dynamic_cast<Gtk::Image*>(page->tab_widget->get_first_child())) {
84
image->set_from_icon_name("image-loading-symbolic");
85
if(auto favicon = webkit_web_view_get_favicon(WEBKIT_WEB_VIEW(object))) {
86
if(G_IS_OBJECT(favicon)) {
87
if(Glib::RefPtr<Gdk::Texture> texture = Glib::wrap(favicon)) {
88
image->set(texture);
89
}
90
}
91
}
92
}
93
}
94
}
95
}
96
static void notify_focused_callback(GObject *object, GParamSpec *pspec, gpointer data) {
98
if(!gtk_widget_get_parent(GTK_WIDGET(object))) {
99
return;
100
}
101
auto this_ = static_cast<PantheraWww*>(data);
102
auto parent = gtk_widget_get_parent(gtk_widget_get_parent(GTK_WIDGET(object)));
103
if(auto page = dynamic_cast<gPanthera::ContentPage*>(Glib::wrap(parent))) {
104
if(g_strcmp0(pspec->name, "uri") == 0) {
105
this_->url_bar->set_text(webkit_web_view_get_uri(WEBKIT_WEB_VIEW(object)));
106
}
107
}
108
}
109
static void on_back_pressed(GtkGestureClick *gesture, int n_press, double x, double y, gpointer user_data) {
111
WebKitWebView *webview = WEBKIT_WEB_VIEW(user_data);
112
webkit_web_view_go_back(webview);
113
}
114
static void on_forward_pressed(GtkGestureClick *gesture, int n_press, double x, double y, gpointer user_data) {
116
WebKitWebView *webview = WEBKIT_WEB_VIEW(user_data);
117
webkit_web_view_go_forward(webview);
118
}
119
static gboolean on_decide_policy(WebKitWebView *source, WebKitPolicyDecision *decision, WebKitPolicyDecisionType type, gpointer user_data) {
121
// Middle-click opens in a new window
122
if(auto self = static_cast<PantheraWww*>(user_data)) {
123
if(type == WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION) {
124
auto action = webkit_navigation_policy_decision_get_navigation_action(WEBKIT_NAVIGATION_POLICY_DECISION(decision));
125
if(webkit_navigation_action_get_mouse_button(action) == 2) {
126
Glib::ustring url = Glib::ustring(webkit_uri_request_get_uri(webkit_navigation_action_get_request(action)));
127
self->on_new_tab(nullptr, url, false);
128
webkit_policy_decision_ignore(decision);
129
return true;
130
}
131
} else if(type == WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION) {
132
auto action = webkit_navigation_policy_decision_get_navigation_action(WEBKIT_NAVIGATION_POLICY_DECISION(decision));
133
self->on_new_tab(nullptr, webkit_uri_request_get_uri(webkit_navigation_action_get_request(action)), false, true);
134
return true;
135
}
136
}
137
return false;
138
}
139
std::string new_tab_page;
141
void on_new_tab(gPanthera::ContentStack *stack, const Glib::ustring &url = "", bool focus = true, bool new_window = false) {
143
if(!stack) {
144
// Find the current area
145
stack = content_manager->get_last_operated_page()->get_stack();
146
}
147
Glib::ustring url_ = url;
148
if(url.empty()) {
149
url_ = new_tab_page;
150
}
151
WebKitWebView *webview = WEBKIT_WEB_VIEW(webkit_web_view_new());
153
gtk_widget_set_hexpand(GTK_WIDGET(webview), true);
154
gtk_widget_set_vexpand(GTK_WIDGET(webview), true);
155
auto page_content = Gtk::make_managed<Gtk::Box>();
156
gtk_box_append(page_content->gobj(), GTK_WIDGET(webview));
157
auto page_tab = new Gtk::Box();
158
page_tab->set_orientation(Gtk::Orientation::HORIZONTAL);
159
auto initial_icon = Gtk::make_managed<Gtk::Image>(Gio::Icon::create("image-loading-symbolic"));
160
page_tab->append(*initial_icon);
161
page_tab->append(*Gtk::make_managed<Gtk::Label>("Untitled"));
162
page_tab->set_spacing(4);
163
auto page = Gtk::make_managed<gPanthera::ContentPage>(content_manager, stack, page_content, page_tab);
164
g_signal_connect(webview, "notify", G_CALLBACK(notify_callback), page->gobj());
165
g_signal_connect(webview, "decide-policy", G_CALLBACK(on_decide_policy), this);
166
webkit_web_view_load_uri(webview, url_.data());
167
auto cookie_manager = webkit_network_session_get_cookie_manager(webkit_web_view_get_network_session(webview));
168
webkit_cookie_manager_set_persistent_storage(cookie_manager, cookie_file.c_str(), WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT);
169
webkit_cookie_manager_set_accept_policy(cookie_manager, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
170
auto website_data_manager = webkit_network_session_get_website_data_manager(webkit_web_view_get_network_session(webview));
171
webkit_website_data_manager_set_favicons_enabled(website_data_manager, true);
172
GtkEventController *click_controller_back = GTK_EVENT_CONTROLLER(gtk_gesture_click_new());
173
gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(click_controller_back), 8);
174
g_signal_connect(click_controller_back, "pressed", G_CALLBACK(on_back_pressed), webview);
175
gtk_widget_add_controller(GTK_WIDGET(webview), click_controller_back);
176
GtkEventController *click_controller_forward = GTK_EVENT_CONTROLLER(gtk_gesture_click_new());
178
gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(click_controller_forward), 9);
179
g_signal_connect(click_controller_forward, "pressed", G_CALLBACK(on_forward_pressed), webview);
180
gtk_widget_add_controller(GTK_WIDGET(webview), click_controller_forward);
181
stack->add_page(*page);
183
if(focus) {
184
stack->set_visible_child(*page);
185
content_manager->set_last_operated_page(page);
186
}
187
if(new_window) {
188
bool result = stack->signal_detach.emit(page);
189
}
190
}
191
void on_startup() override {
193
Gtk::Application::on_startup();
194
add_window(*window);
195
window->set_default_size(600, 400);
196
layout_manager = std::make_shared<gPanthera::LayoutManager>();
197
auto dock_stack_1 = Gtk::make_managed<gPanthera::DockStack>(layout_manager, "One", "one");
198
auto switcher_1 = Gtk::make_managed<gPanthera::DockStackSwitcher>(dock_stack_1, Gtk::Orientation::HORIZONTAL);
199
auto dock_stack_2 = Gtk::make_managed<gPanthera::DockStack>(layout_manager, "Two", "two");
200
auto switcher_2 = Gtk::make_managed<gPanthera::DockStackSwitcher>(dock_stack_2, Gtk::Orientation::VERTICAL);
201
auto pane_1_content = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
202
auto debug_button = Gtk::make_managed<Gtk::Button>("Debug");
203
pane_1_content->append(*debug_button);
204
auto pane_2_content = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
205
auto test_notebook = Gtk::make_managed<Gtk::Notebook>();
206
test_notebook->append_page(*Gtk::make_managed<Gtk::Label>("Test 1"), *Gtk::make_managed<Gtk::Label>("Test 1"));
207
pane_2_content->append(*test_notebook);
208
auto pane_3_content = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
209
pane_3_content->append(*Gtk::make_managed<Gtk::Label>("Pane 3 content"));
210
auto pane_1_icon = Gtk::make_managed<Gtk::Image>();
211
pane_1_icon->set_from_icon_name("go-home-symbolic");
212
auto pane_2_icon = Gtk::make_managed<Gtk::Image>();
213
pane_2_icon->set_from_icon_name("folder-symbolic");
214
auto pane_3_icon = Gtk::make_managed<Gtk::Image>();
215
pane_3_icon->set_from_icon_name("network-transmit-receive-symbolic");
216
auto pane_1 = Gtk::make_managed<gPanthera::DockablePane>(layout_manager, *pane_1_content, "pane1", "Pane 1", pane_1_icon);
217
auto pane_2 = Gtk::make_managed<gPanthera::DockablePane>(layout_manager, *pane_2_content, "pane2", "Pane 2", pane_2_icon);
218
auto pane_3 = Gtk::make_managed<gPanthera::DockablePane>(layout_manager, *pane_3_content, "pane3", "Pane 3", pane_3_icon);
219
dock_stack_1->set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
221
dock_stack_1->set_transition_duration(125);
222
dock_stack_1->set_expand(true);
223
dock_stack_2->set_transition_type(Gtk::StackTransitionType::SLIDE_UP_DOWN);
224
dock_stack_2->set_transition_duration(125);
225
dock_stack_2->set_expand(true);
226
auto outer_grid = Gtk::make_managed<Gtk::Grid>();
228
outer_grid->attach(*switcher_2, 0, 1, 1, 1);
229
outer_grid->attach(*switcher_1, 1, 2, 1, 1);
230
auto outer_paned = Gtk::make_managed<Gtk::Paned>(Gtk::Orientation::HORIZONTAL);
231
outer_paned->set_start_child(*dock_stack_2);
232
auto inner_paned = Gtk::make_managed<Gtk::Paned>(Gtk::Orientation::VERTICAL);
233
auto content = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
234
content_manager = std::make_shared<gPanthera::ContentManager>();
235
std::function<bool(gPanthera::ContentPage*)> detach_handler;
236
detach_handler = [](gPanthera::ContentPage *widget) {
237
auto new_stack = Gtk::make_managed<gPanthera::ContentStack>(widget->content_manager, widget->get_stack()->get_detach_handler());
238
auto new_switcher = Gtk::make_managed<gPanthera::ContentTabBar>(new_stack, Gtk::Orientation::HORIZONTAL, dynamic_cast<gPanthera::ContentTabBar*>(widget->get_stack()->get_parent()->get_first_child())->get_extra_child_function());
239
auto new_notebook = Gtk::make_managed<gPanthera::ContentNotebook>(new_stack, new_switcher);
240
auto window = new gPanthera::ContentWindow(new_notebook);
241
widget->redock(new_stack);
242
window->present();
243
new_stack->signal_leave_empty.connect([window]() {
244
window->close();
245
delete window;
246
});
247
return true;
248
};
249
auto return_extra_child = [this](gPanthera::ContentTabBar *switcher) {
251
auto new_tab_button = Gtk::make_managed<Gtk::Button>();
252
new_tab_button->set_child(*Gtk::make_managed<Gtk::Image>(Gio::Icon::create("list-add-symbolic")));
253
new_tab_button->set_tooltip_text("New tab");
254
new_tab_button->signal_clicked().connect([this, switcher]() {
255
on_new_tab(switcher->get_stack());
256
});
257
return new_tab_button;
258
};
259
auto content_stack = Gtk::make_managed<gPanthera::ContentStack>(content_manager, detach_handler);
260
auto content_stack_switcher = Gtk::make_managed<gPanthera::ContentTabBar>(content_stack, Gtk::Orientation::HORIZONTAL, return_extra_child);
261
content_manager->add_stack(content_stack);
262
WebKitWebView *webview = WEBKIT_WEB_VIEW(webkit_web_view_new()); // for some reason, this has to be created
263
content->set_name("content_box");
264
auto content_notebook = Gtk::make_managed<gPanthera::ContentNotebook>(content_stack, content_stack_switcher, Gtk::PositionType::TOP);
265
content->append(*content_notebook);
266
inner_paned->set_start_child(*content);
267
inner_paned->set_end_child(*dock_stack_1);
268
outer_paned->set_end_child(*inner_paned);
269
outer_grid->attach(*outer_paned, 1, 1, 1, 1);
270
// Get search engines
272
std::ifstream search_engines_file_in("search_engines.json");
273
if(search_engines_file_in) {
274
std::string search_engines_json((std::istreambuf_iterator<char>(search_engines_file_in)), std::istreambuf_iterator<char>());
275
search_engines_file_in.close();
276
set_search_engines_from_json(search_engines_json);
277
} else {
278
search_engines_file_in.close();
279
auto empty_json = nlohmann::json::array();
280
std::ofstream search_engines_file_out("search_engines.json");
281
search_engines_file_out << empty_json.dump(4);
282
}
283
// Create the toolbar
285
auto main_toolbar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
286
// URL bar
287
url_bar = Gtk::make_managed<Gtk::Entry>();
288
url_bar->set_placeholder_text("Enter URL");
289
url_bar->set_hexpand(true);
290
auto load_url_callback = [this]() {
291
auto page = content_manager->get_last_operated_page();
292
bool has_protocol = url_bar->get_text().find("://") != std::string::npos;
293
if(!has_protocol) {
294
url_bar->set_text("http://" + url_bar->get_text());
295
}
296
if(page) {
297
if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
298
webkit_web_view_load_uri(webview, url_bar->get_text().c_str());
299
}
300
}
301
};
302
// Go
303
auto go_button = Gtk::make_managed<Gtk::Button>("Go");
304
go_button->signal_clicked().connect(load_url_callback);
305
url_bar->signal_activate().connect(load_url_callback);
306
content_manager->signal_page_operated.connect([this](gPanthera::ContentPage *page) {
307
if(!page->get_child()) {
308
return;
309
}
310
if(!page->get_child()->get_first_child()) {
311
return;
312
}
313
url_bar->set_text(webkit_web_view_get_uri(WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())));
314
guint url_update_handler = g_signal_connect(page->get_child()->get_first_child()->gobj(), "notify", G_CALLBACK(notify_focused_callback), this);
315
std::shared_ptr<sigc::connection> control_signal_handler = std::make_shared<sigc::connection>();
316
*control_signal_handler = page->signal_control_status_changed.connect([this, page, control_signal_handler, url_update_handler](bool controlled) {
317
if(!controlled) {
318
control_signal_handler->disconnect();
319
if(page->get_child() && page->get_child()->get_first_child() && WEBKIT_IS_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
320
g_signal_handler_disconnect(page->get_child()->get_first_child()->gobj(), url_update_handler);
321
}
322
}
323
});
324
});
325
// Back, forward, reload
326
auto back_button = Gtk::make_managed<Gtk::Button>();
327
back_button->set_child(*Gtk::make_managed<Gtk::Image>(Gio::Icon::create("go-previous-symbolic")));
328
back_button->set_tooltip_text("Back");
329
auto forward_button = Gtk::make_managed<Gtk::Button>();
330
forward_button->set_child(*Gtk::make_managed<Gtk::Image>(Gio::Icon::create("go-next-symbolic")));
331
forward_button->set_tooltip_text("Forward");
332
auto reload_button = Gtk::make_managed<Gtk::Button>();
333
reload_button->set_child(*Gtk::make_managed<Gtk::Image>(Gio::Icon::create("view-refresh-symbolic")));
334
reload_button->set_tooltip_text("Reload");
335
back_button->signal_clicked().connect([this]() {
336
auto page = content_manager->get_last_operated_page();
337
if(page) {
338
if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
339
webkit_web_view_go_back(webview);
340
}
341
}
342
});
343
forward_button->signal_clicked().connect([this]() {
344
auto page = content_manager->get_last_operated_page();
345
if(page) {
346
if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
347
webkit_web_view_go_forward(webview);
348
}
349
}
350
});
351
reload_button->signal_clicked().connect([this]() {
352
auto page = content_manager->get_last_operated_page();
353
if(page) {
354
if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
355
webkit_web_view_reload(webview);
356
}
357
}
358
});
359
// Search bar
360
// TODO: provide history, provide a menu button with the other engines
361
auto search_bar = Gtk::make_managed<Gtk::Entry>();
362
search_bar->set_placeholder_text("Search");
363
search_bar->set_hexpand(true);
364
if(search_engines.empty()) {
365
search_bar->set_sensitive(false);
366
search_bar->set_placeholder_text("No search");
367
}
368
auto search_callback = [this, search_bar, content_stack]() {
369
// Create a new tab with the search results
370
if(content_manager->get_last_operated_page()) {
371
on_new_tab(nullptr);
372
} else {
373
on_new_tab(content_stack);
374
}
375
auto page = content_manager->get_last_operated_page();
376
if(page) {
377
if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
378
auto search_url = default_search_engine->get_search_url(search_bar->get_text());
379
webkit_web_view_load_uri(webview, search_url.c_str());
380
}
381
}
382
};
383
if(default_search_engine) {
384
search_bar->signal_activate().connect(search_callback);
385
}
386
// Assemble the toolbar
387
main_toolbar->append(*back_button);
388
main_toolbar->append(*forward_button);
389
main_toolbar->append(*reload_button);
390
main_toolbar->append(*url_bar);
391
main_toolbar->append(*go_button);
392
main_toolbar->append(*search_bar);
393
if(default_search_engine) {
394
auto search_button = Gtk::make_managed<Gtk::Button>(default_search_engine->name);
395
search_button->signal_clicked().connect(search_callback);
396
main_toolbar->append(*search_button);
397
}
398
outer_grid->attach(*main_toolbar, 0, 0, 2, 1);
399
window->set_child(*outer_grid);
400
debug_button->signal_clicked().connect([this]() {
401
if(content_manager->get_last_operated_page()) {
402
std::cout << "Last operated page: " << content_manager->get_last_operated_page()->get_name() << std::endl;
403
} else {
404
std::cout << "No page operated!" << std::endl;
405
}
406
});
407
// TODO: Use the last operated page and allow opening tabs next to the last operated page using certain panes
408
// Load the existing layout, if it exists
409
std::ifstream layout_file_in("layout.json");
410
if(layout_file_in) {
411
std::string layout_json((std::istreambuf_iterator<char>(layout_file_in)), std::istreambuf_iterator<char>());
412
layout_file_in.close();
413
layout_manager->restore_json_layout(layout_json);
414
} else {
415
// Create a new layout if the file doesn't exist
416
layout_file_in.close();
417
dock_stack_1->add_pane(*pane_1);
419
dock_stack_1->add_pane(*pane_3);
420
dock_stack_2->add_pane(*pane_2);
421
std::ofstream layout_file_out("layout.json");
423
layout_file_out << layout_manager->get_layout_as_json();
424
layout_file_out.close();
425
}
426
// Save the layout when changed
427
layout_manager->signal_pane_moved.connect([this](gPanthera::DockablePane *pane) {
428
std::ofstream layout_file_out("layout.json");
429
layout_file_out << layout_manager->get_layout_as_json();
430
layout_file_out.close();
431
std::cout << "Layout changed: " << layout_manager->get_layout_as_json() << std::endl;
432
});
433
auto new_tab_action = Gio::SimpleAction::create("new_tab");
435
new_tab_action->signal_activate().connect([this](const Glib::VariantBase&) {
436
on_new_tab(nullptr);
437
});
438
add_action(new_tab_action);
439
set_accels_for_action("app.new_tab", {"<Primary>T"});
440
auto close_tab_action = Gio::SimpleAction::create("close_tab");
441
close_tab_action->signal_activate().connect([this](const Glib::VariantBase&) {
442
auto page = content_manager->get_last_operated_page();
443
if(page) {
444
page->close();
445
}
446
});
447
add_action(close_tab_action);
448
set_accels_for_action("app.close_tab", {"<Primary>W"});
449
// Load settings
451
new_tab_page = "about:blank";
452
std::ifstream settings_file_in("settings.json");
453
if(settings_file_in) {
454
std::string settings_json((std::istreambuf_iterator<char>(settings_file_in)), std::istreambuf_iterator<char>());
455
settings_file_in.close();
456
auto json = nlohmann::json::parse(settings_json);
457
if(json.contains("ntp")) {
458
new_tab_page = json["ntp"].get<std::string>();
459
}
460
} else {
461
settings_file_in.close();
462
auto empty_json = nlohmann::json::object();
463
empty_json["ntp"] = "about:blank";
464
std::ofstream settings_file_out("settings.json");
465
settings_file_out << empty_json.dump(4);
466
settings_file_out.close();
467
}
468
// Load plugins
470
std::ifstream plugin_file_in("plugins.json");
471
if(plugin_file_in) {
472
std::string plugin_json((std::istreambuf_iterator<char>(plugin_file_in)), std::istreambuf_iterator<char>());
473
plugin_file_in.close();
474
auto json = nlohmann::json::parse(plugin_json);
475
for(auto &plugin : json) {
476
auto plugin_path = plugin["path"].get<std::string>();
477
load_plugin(plugin_path);
478
}
479
} else {
480
plugin_file_in.close();
481
auto empty_json = nlohmann::json::array();
482
std::ofstream plugin_file_out("plugins.json");
483
plugin_file_out << empty_json.dump(4);
484
plugin_file_out.close();
485
}
486
}
487
void on_activate() override {
489
window->present();
490
}
491
void set_search_engines_from_json(const std::string &json_string) {
493
auto json = nlohmann::json::parse(json_string);
494
Glib::ustring default_search_engine_name;
495
for(auto &engine : json) {
496
SearchEngine search_engine;
497
search_engine.name = engine["name"].get<std::string>();
498
search_engine.url = engine["url"].get<std::string>();
499
search_engines.push_back(search_engine);
500
if(engine.contains("default") && engine["default"].get<bool>()) {
501
default_search_engine_name = engine["name"].get<std::string>();
502
}
503
}
504
for(auto &search_engine : search_engines) {
505
if(search_engine.name == default_search_engine_name) {
506
default_search_engine = &search_engine;
507
break;
508
}
509
}
510
}
511
public:
512
static Glib::RefPtr<PantheraWww> create() {
513
return Glib::make_refptr_for_instance<PantheraWww>(new PantheraWww());
514
}
515
std::shared_ptr<gPanthera::LayoutManager> get_layout_manager() {
517
return layout_manager;
518
}
519
std::shared_ptr<gPanthera::ContentManager> get_content_manager() {
521
return content_manager;
522
}
523
void load_plugin(const std::string &plugin_path) {
525
void *handle = dlopen(plugin_path.c_str(), RTLD_LAZY | RTLD_GLOBAL);
526
if(!handle) {
527
std::cerr << "Failed to load plugin: " << dlerror() << std::endl;
528
return;
529
}
530
auto entrypoint = (plugin_entrypoint_type)dlsym(handle, "plugin_init");
531
if(!entrypoint) {
532
std::cerr << "Failed to find entrypoint in plugin: " << dlerror() << std::endl;
533
dlclose(handle);
534
return;
535
}
536
entrypoint();
537
}
538
};
539
Glib::RefPtr<PantheraWww> app = nullptr;
541
extern "C" {
543
void panthera_log(const char *message) {
544
std::cerr << message << std::endl;
545
}
546
void panthera_add_pane(const char *id, const char *label, GtkImage *icon, GtkWidget *pane) {
548
auto pane_child = Glib::wrap(pane);
549
auto icon_cc = Glib::wrap(icon);
550
auto label_cc = Glib::ustring(label);
551
auto id_cc = Glib::ustring(id);
552
auto new_pane = Gtk::make_managed<gPanthera::DockablePane>(app->get_layout_manager(), *pane_child, id_cc, label_cc, icon_cc);
553
app->get_layout_manager()->add_pane(new_pane);
554
}
555
}
556
int main(int argc, char *argv[]) {
558
gPanthera::init();
559
app = PantheraWww::create();
560
return app->run(argc, argv);
561
}