Add search engines

panthera-www.cc

@@ -10,9 +10,44 @@

                                
                                
                                
                            
                                
                                    
                                        
                                            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  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        14 -
                                        class WebPage : public Gtk::Box {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        17 +
                                        std::string url_encode(const std::string &value) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        18 +
                                            // Thanks https://stackoverflow.com/a/17708801
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        19 +
                                            std::ostringstream escaped;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        20 +
                                            escaped.fill('0');
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        21 +
                                            escaped << std::hex;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            22  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        23 +
                                            for(char c : value) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        24 +
                                                // Keep alphanumeric and other accepted characters intact
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        25 +
                                                if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        26 +
                                                    escaped << c;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        27 +
                                                    continue;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        28 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        29 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        30 +
                                                // Any other characters are percent-encoded
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        31 +
                                                escaped << std::uppercase;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        32 +
                                                escaped << '%' << std::setw(2) << int((unsigned char) c);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        33 +
                                                escaped << std::nouppercase;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        34 +
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        35 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        36 +
                                            return escaped.str();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        37 +
                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        38 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        39 +
                                        struct SearchEngine {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        40 +
                                            Glib::ustring name;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        41 +
                                            Glib::ustring url;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        42 +
                                            Glib::ustring get_search_url(const std::string &query) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        43 +
                                                auto pos = url.find("%s");
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        44 +
                                                if(pos == Glib::ustring::npos) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        45 +
                                                    throw std::runtime_error("Invalid search engine URL: missing '%s' placeholder");
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        46 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        47 +
                                                auto new_url = url.substr(0, pos);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        48 +
                                                new_url.replace(pos, 2, url_encode(query));
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        49 +
                                                return new_url;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        50 +
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            51  
                                            };
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            52  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            53  
                                            class PantheraWww : public Gtk::Application {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -22,6 +57,8 @@ protected:

                                
                                
                                
                            
                                
                                    
                                        
                                            57  
                                                std::shared_ptr<gPanthera::ContentManager> content_manager;
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            58  
                                                Gtk::Entry *url_bar = nullptr;
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            59  
                                                std::string cookie_file = "cookies.txt";
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        60 +
                                            std::vector<SearchEngine> search_engines;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        61 +
                                            SearchEngine *default_search_engine = nullptr;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            62  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            63  
                                                static void notify_callback(GObject *object, GParamSpec *pspec, gpointer data) {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            64  
                                                    if(!gtk_widget_get_parent(GTK_WIDGET(object))) {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -171,11 +208,56 @@ protected:

                                
                                
                                
                            
                                
                                    
                                        
                                            208  
                                                    inner_paned->set_end_child(*dock_stack_1);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            209  
                                                    outer_paned->set_end_child(*inner_paned);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            210  
                                                    outer_grid->attach(*outer_paned, 1, 1, 1, 1);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        211 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        212 +
                                                // Get search engines
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        213 +
                                                std::ifstream search_engines_file_in("search_engines.json");
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        214 +
                                                if(search_engines_file_in) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        215 +
                                                    std::string search_engines_json((std::istreambuf_iterator<char>(search_engines_file_in)), std::istreambuf_iterator<char>());
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        216 +
                                                    search_engines_file_in.close();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        217 +
                                                    set_search_engines_from_json(search_engines_json);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        218 +
                                                } else {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        219 +
                                                    search_engines_file_in.close();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        220 +
                                                    auto empty_json = nlohmann::json::array();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        221 +
                                                    std::ofstream search_engines_file_out("search_engines.json");
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        222 +
                                                    search_engines_file_out << empty_json.dump(4);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        223 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        224 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        225 +
                                                // Create the toolbar
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            226  
                                                    auto main_toolbar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        227 +
                                                // URL bar
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            228  
                                                    url_bar = Gtk::make_managed<Gtk::Entry>();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            229  
                                                    url_bar->set_placeholder_text("Enter URL");
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            230  
                                                    url_bar->set_hexpand(true);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        231 +
                                                auto load_url_callback = [this]() {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        232 +
                                                    auto page = content_manager->get_last_operated_page();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        233 +
                                                    if(page) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        234 +
                                                        if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        235 +
                                                            webkit_web_view_load_uri(webview, url_bar->get_text().c_str());
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        236 +
                                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        237 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        238 +
                                                };
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        239 +
                                                // Go
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            240  
                                                    auto go_button = Gtk::make_managed<Gtk::Button>("Go");
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        241 +
                                                go_button->signal_clicked().connect(load_url_callback);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        242 +
                                                url_bar->signal_activate().connect(load_url_callback);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        243 +
                                                content_manager->signal_page_operated.connect([this](gPanthera::ContentPage *page) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        244 +
                                                    if(!page->get_child()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        245 +
                                                        return;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        246 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        247 +
                                                    if(!page->get_child()->get_first_child()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        248 +
                                                        return;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        249 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        250 +
                                                    url_bar->set_text(webkit_web_view_get_uri(WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())));
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        251 +
                                                    guint url_update_handler = g_signal_connect(page->get_child()->get_first_child()->gobj(), "notify", G_CALLBACK(notify_focused_callback), this);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        252 +
                                                    std::shared_ptr<sigc::connection> control_signal_handler = std::make_shared<sigc::connection>();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        253 +
                                                    *control_signal_handler = page->signal_control_status_changed.connect([this, page, control_signal_handler, url_update_handler](bool controlled) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        254 +
                                                        if(!controlled) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        255 +
                                                            control_signal_handler->disconnect();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        256 +
                                                            g_signal_handler_disconnect(page->get_child()->get_first_child()->gobj(), url_update_handler);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        257 +
                                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        258 +
                                                    });
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        259 +
                                                });
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        260 +
                                                // Back, forward, reload
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            261  
                                                    auto back_button = Gtk::make_managed<Gtk::Button>();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            262  
                                                    back_button->set_child(*Gtk::make_managed<Gtk::Image>(Gio::Icon::create("go-previous-symbolic")));
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            263  
                                                    back_button->set_tooltip_text("Back");
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -209,39 +291,46 @@ protected:

                                
                                
                                
                            
                                
                                    
                                        
                                            291  
                                                            }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            292  
                                                        }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            293  
                                                    });
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        212 -
                                                main_toolbar->append(*back_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        213 -
                                                main_toolbar->append(*forward_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        214 -
                                                main_toolbar->append(*reload_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        215 -
                                                main_toolbar->append(*url_bar);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        216 -
                                                main_toolbar->append(*go_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        217 -
                                                outer_grid->attach(*main_toolbar, 0, 0, 2, 1);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        218 -
                                                auto load_url_callback = [this]() {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        294 +
                                                // Search bar
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        295 +
                                                // TODO: provide history, provide a menu button with the other engines
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        296 +
                                                auto search_bar = Gtk::make_managed<Gtk::Entry>();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        297 +
                                                search_bar->set_placeholder_text("Search");
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        298 +
                                                search_bar->set_hexpand(true);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        299 +
                                                if(search_engines.empty()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        300 +
                                                    search_bar->set_sensitive(false);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        301 +
                                                    search_bar->set_placeholder_text("No search");
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        302 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        303 +
                                                auto search_callback = [this, search_bar, content_stack]() {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        304 +
                                                    // Create a new tab with the search results
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        305 +
                                                    if(content_manager->get_last_operated_page()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        306 +
                                                        on_new_tab(nullptr);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        307 +
                                                    } else {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        308 +
                                                        on_new_tab(content_stack);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        309 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            310  
                                                        auto page = content_manager->get_last_operated_page();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            311  
                                                        if(page) {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            312  
                                                            if(auto webview = WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())) {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        222 -
                                                            webkit_web_view_load_uri(webview, url_bar->get_text().c_str());
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        313 +
                                                            auto search_url = default_search_engine->get_search_url(search_bar->get_text());
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        314 +
                                                            webkit_web_view_load_uri(webview, search_url.c_str());
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            315  
                                                            }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            316  
                                                        }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            317  
                                                    };
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        226 -
                                                go_button->signal_clicked().connect(load_url_callback);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        227 -
                                                url_bar->signal_activate().connect(load_url_callback);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        228 -
                                                content_manager->signal_page_operated.connect([this](gPanthera::ContentPage *page) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        229 -
                                                    if(!page->get_child()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        230 -
                                                        return;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        231 -
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        232 -
                                                    if(!page->get_child()->get_first_child()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        233 -
                                                        return;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        234 -
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        235 -
                                                    url_bar->set_text(webkit_web_view_get_uri(WEBKIT_WEB_VIEW(page->get_child()->get_first_child()->gobj())));
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        236 -
                                                    guint url_update_handler = g_signal_connect(page->get_child()->get_first_child()->gobj(), "notify", G_CALLBACK(notify_focused_callback), this);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        237 -
                                                    std::shared_ptr<sigc::connection> control_signal_handler = std::make_shared<sigc::connection>();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        238 -
                                                    *control_signal_handler = page->signal_control_status_changed.connect([this, page, control_signal_handler, url_update_handler](bool controlled) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        239 -
                                                        if(!controlled) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        240 -
                                                            control_signal_handler->disconnect();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        241 -
                                                            g_signal_handler_disconnect(page->get_child()->get_first_child()->gobj(), url_update_handler);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        242 -
                                                        }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        243 -
                                                    });
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        244 -
                                                });
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        318 +
                                                if(default_search_engine) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        319 +
                                                    search_bar->signal_activate().connect(search_callback);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        320 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        321 +
                                                // Assemble the toolbar
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        322 +
                                                main_toolbar->append(*back_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        323 +
                                                main_toolbar->append(*forward_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        324 +
                                                main_toolbar->append(*reload_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        325 +
                                                main_toolbar->append(*url_bar);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        326 +
                                                main_toolbar->append(*go_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        327 +
                                                main_toolbar->append(*search_bar);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        328 +
                                                if(default_search_engine) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        329 +
                                                    auto search_button = Gtk::make_managed<Gtk::Button>(default_search_engine->name);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        330 +
                                                    search_button->signal_clicked().connect(search_callback);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        331 +
                                                    main_toolbar->append(*search_button);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        332 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        333 +
                                                outer_grid->attach(*main_toolbar, 0, 0, 2, 1);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            334  
                                                    window->set_child(*outer_grid);
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            335  
                                                    debug_button->signal_clicked().connect([this]() {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            336  
                                                        if(content_manager->get_last_operated_page()) {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -297,6 +386,26 @@ protected:

                                
                                
                                
                            
                                
                                    
                                        
                                            386  
                                                void on_activate() override {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            387  
                                                    window->present();
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            388  
                                                }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        389 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        390 +
                                            void set_search_engines_from_json(const std::string &json_string) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        391 +
                                                auto json = nlohmann::json::parse(json_string);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        392 +
                                                Glib::ustring default_search_engine_name;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        393 +
                                                for(auto &engine : json) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        394 +
                                                    SearchEngine search_engine;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        395 +
                                                    search_engine.name = engine["name"].get<std::string>();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        396 +
                                                    search_engine.url = engine["url"].get<std::string>();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        397 +
                                                    search_engines.push_back(search_engine);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        398 +
                                                    if(engine.contains("default") && engine["default"].get<bool>()) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        399 +
                                                        default_search_engine_name = engine["name"].get<std::string>();
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        400 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        401 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        402 +
                                                for(auto &search_engine : search_engines) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        403 +
                                                    if(search_engine.name == default_search_engine_name) {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        404 +
                                                        default_search_engine = &search_engine;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        405 +
                                                        break;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        406 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        407 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        408 +
                                            }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            409  
                                            public:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            410  
                                                static Glib::RefPtr<PantheraWww> create() {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            411  
                                                    return Glib::make_refptr_for_instance<PantheraWww>(new PantheraWww());