API tools faq
paste
Guest User

claude-browser-2f.c

a guest
Aug 5th, 2024
49
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 19.70 KB | Source Code | 0 0
raw download clone embed print report
  1. #include <gtk/gtk.h>
  2. #include <webkit2/webkit2.h>
  3.  
  4. //blxdown
  5. // New structure to hold download information
  6. typedef struct {
  7.     WebKitDownload *download;
  8.     GtkWidget *progress_bar;
  9.     GtkWidget *label;
  10. } DownloadItem;
  11.  
  12. static gchar* remove_extension(const gchar* filename) {
  13.     gchar *dot = strrchr(filename, '.');
  14.     if(!dot || dot == filename) return g_strdup(filename);
  15.     return g_strndup(filename, dot - filename);
  16. }
  17.  
  18. static gchar* get_extension(const gchar* filename) {
  19.     gchar *dot = strrchr(filename, '.');
  20.     if(!dot || dot == filename) return g_strdup("");
  21.     return g_strdup(dot);
  22. }
  23.  
  24. static gchar* ensure_unique_filename(const gchar* filename) {
  25.     gchar *unique_name = g_strdup(filename);
  26.     int counter = 1;
  27.     while (g_file_test(unique_name, G_FILE_TEST_EXISTS)) {
  28.         g_free(unique_name);
  29.         gchar *basename = g_path_get_basename(filename);
  30.         gchar *directory = g_path_get_dirname(filename);
  31.         gchar *file_without_ext = remove_extension(basename);
  32.         gchar *extension = get_extension(basename);
  33.         unique_name = g_strdup_printf("%s/%s (%d)%s", directory, file_without_ext, counter, extension);
  34.         g_free(basename);
  35.         g_free(directory);
  36.         g_free(file_without_ext);
  37.         g_free(extension);
  38.         counter++;
  39.     }
  40.     return unique_name;
  41. }
  42.  
  43. // Global variables for download manager
  44. GtkWidget *download_window = NULL;
  45. GtkWidget *download_list = NULL;
  46.  
  47. // New function to update download progress
  48. static void update_download_progress(WebKitDownload *download, GParamSpec *pspec, DownloadItem *item) {
  49.     gdouble progress = webkit_download_get_estimated_progress(download);
  50.     gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(item->progress_bar), progress);
  51.  
  52.     const gchar *destination = webkit_download_get_destination(download);
  53.     const gchar *filename = g_path_get_basename(destination);
  54.  
  55.     gchar *progress_text = g_strdup_printf("%s - %.1f%%", filename, progress * 100);
  56.     gtk_progress_bar_set_text(GTK_PROGRESS_BAR(item->progress_bar), progress_text);
  57.     g_free(progress_text);
  58. }
  59.  
  60. // New function to handle download finished event
  61. static void download_finished(WebKitDownload *download, DownloadItem *item) {
  62.    
  63.     const gchar *destination = webkit_download_get_destination(download);
  64.     const gchar *filename = g_path_get_basename(destination);
  65.  
  66.     gchar *finished_text = g_strdup_printf("Downloaded: %s", filename);
  67.     gtk_label_set_text(GTK_LABEL(item->label), finished_text);
  68.     g_free(finished_text);
  69.  
  70.     gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(item->progress_bar), 1.0);
  71.     gtk_progress_bar_set_text(GTK_PROGRESS_BAR(item->progress_bar), "100%");
  72. }
  73.  
  74. // Callback function to set download_window to NULL when it's destroyed
  75. static void on_download_window_destroyed(GtkWidget *widget, gpointer user_data) {
  76.     download_window = NULL;
  77.     download_list = NULL;
  78. }
  79.  
  80.  
  81. static void show_download_manager(GtkWidget *widget, gpointer user_data) {
  82.     if (download_window == NULL) {
  83.         // Create the download window if it doesn't exist
  84.         download_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  85.         gtk_window_set_title(GTK_WINDOW(download_window), "Download Manager");
  86.         gtk_window_set_default_size(GTK_WINDOW(download_window), 400, 300);
  87.  
  88.         download_list = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
  89.         GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  90.         gtk_container_add(GTK_CONTAINER(scrolled_window), download_list);
  91.         gtk_container_add(GTK_CONTAINER(download_window), scrolled_window);
  92.  
  93.         // Connect the delete-event to destroy the window instead of hiding it
  94.         g_signal_connect(download_window, "delete-event", G_CALLBACK(gtk_widget_destroy), NULL);
  95.  
  96.         // Connect a destroy signal to set download_window to NULL when it's destroyed
  97.         g_signal_connect(download_window, "destroy", G_CALLBACK(on_download_window_destroyed), NULL);
  98.     }
  99.  
  100.     // Show the window and bring it to the front
  101.     gtk_widget_show_all(download_window);
  102.     gtk_window_present(GTK_WINDOW(download_window));
  103. }
  104.  
  105.  
  106. static void download_started(WebKitWebView *web_view, WebKitDownload *download, gpointer user_data) {
  107.     g_print("Download started function called\n");
  108.    
  109.     show_download_manager(NULL, NULL);
  110.  
  111.     const gchar *destination = webkit_download_get_destination(download);
  112.     if (destination == NULL) {
  113.         g_print("Error: Download destination is NULL\n");
  114.        
  115.         // Get the current URI
  116.         WebKitURIRequest *request = webkit_download_get_request(download);
  117.         const gchar *uri = request ? webkit_uri_request_get_uri(request) : "N/A";
  118.         g_print("Download URI: %s\n", uri);
  119.  
  120.         // Generate a filename from the URI
  121.         gchar *suggested_filename = NULL;
  122.         if (uri && uri[0] != '\0') {
  123.             gchar *basename = g_path_get_basename(uri);
  124.             if (strchr(basename, '.') == NULL) {
  125.                 // If there's no extension, add a default one
  126.                 suggested_filename = g_strconcat(basename, ".download", NULL);
  127.                 g_free(basename);
  128.             } else {
  129.                 suggested_filename = basename;
  130.             }
  131.         } else {
  132.             suggested_filename = g_strdup("download.bin");
  133.         }
  134.         g_print("Generated filename: %s\n", suggested_filename);
  135.  
  136.         // Set a default destination with the generated filename
  137.         gchar *default_destination = g_build_filename(g_get_user_special_dir(G_USER_DIRECTORY_DOWNLOAD),
  138.                                                       suggested_filename,
  139.                                                       NULL);
  140.         gchar *unique_destination = ensure_unique_filename(default_destination);
  141.         webkit_download_set_destination(download, unique_destination);
  142.         g_print("Set default destination: %s\n", default_destination);
  143.         g_print("Set unique destination: %s\n", unique_destination);
  144.         g_free(suggested_filename);
  145.         g_free(default_destination);
  146.         g_free(unique_destination);
  147.  
  148.         destination = webkit_download_get_destination(download);
  149.         if (destination == NULL) {
  150.             g_print("Error: Still unable to get download destination\n");
  151.             return;
  152.         }
  153.     }
  154.  
  155.     g_print("Download destination: %s\n", destination);
  156.  
  157.     // Extract filename from destination path
  158.     const gchar *filename = g_path_get_basename(destination);
  159.  
  160.     DownloadItem *item = g_new(DownloadItem, 1);
  161.     item->download = download;
  162.  
  163.     GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
  164.    
  165.     // Create a label with the filename
  166.     gchar *label_text = g_strdup_printf("Downloading: %s", filename);
  167.     item->label = gtk_label_new(label_text);
  168.     g_free(label_text);
  169.  
  170.     item->progress_bar = gtk_progress_bar_new();
  171.     gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(item->progress_bar), TRUE);
  172.  
  173.     gtk_box_pack_start(GTK_BOX(hbox), item->label, FALSE, FALSE, 0);
  174.     gtk_box_pack_start(GTK_BOX(hbox), item->progress_bar, TRUE, TRUE, 0);
  175.  
  176.     gtk_container_add(GTK_CONTAINER(download_list), hbox);
  177.     gtk_widget_show_all(download_window);
  178.  
  179.     g_signal_connect(download, "notify::estimated-progress", G_CALLBACK(update_download_progress), item);
  180.     g_signal_connect(download, "finished", G_CALLBACK(download_finished), item);
  181. }
  182.  
  183.  
  184.  
  185. //BLXdownend
  186.  
  187. static void show_about_dialog(GtkWidget *widget, gpointer data) {
  188.     GtkWidget *dialog = gtk_about_dialog_new();
  189.     gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(dialog), "Simple Browser");
  190.     gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), "1.0");
  191. gtk_about_dialog_set_logo_icon_name(GTK_ABOUT_DIALOG(dialog), "web-browser");
  192.     gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), "A simple GTK3 WebKit2 based browser");
  193.     gtk_dialog_run(GTK_DIALOG(dialog));
  194.     gtk_widget_destroy(dialog);
  195. }
  196.  
  197. static void go_back(GtkWidget *widget, WebKitWebView *web_view) {
  198.     g_print("Back button clicked\n");
  199.     if (webkit_web_view_can_go_back(web_view)) {
  200.         g_print("Going back\n");
  201.         webkit_web_view_go_back(web_view);
  202.     } else {
  203.         g_print("Cannot go back\n");
  204.     }
  205. }
  206.  
  207. static void go_forward(GtkWidget *widget, WebKitWebView *web_view) {
  208.     g_print("Forward button clicked\n");
  209.     if (webkit_web_view_can_go_forward(web_view)) {
  210.         g_print("Going forward\n");
  211.         webkit_web_view_go_forward(web_view);
  212.     } else {
  213.         g_print("Cannot go forward\n");
  214.     }
  215. }
  216.  
  217. static void zoom_in(GtkWidget *widget, WebKitWebView *web_view) {
  218.     gdouble zoom_level = webkit_web_view_get_zoom_level(web_view);
  219.    zoom_level += 0.1;
  220.        webkit_web_view_set_zoom_level(web_view, zoom_level);
  221.     g_print("Zoomed in. New zoom level: %.1f\n", zoom_level);
  222. }
  223.  
  224. static void zoom_out(GtkWidget *widget, WebKitWebView *web_view) {
  225.     gdouble zoom_level = webkit_web_view_get_zoom_level(web_view);
  226.     zoom_level -= 0.1;
  227.     webkit_web_view_set_zoom_level(web_view, zoom_level);
  228.     g_print("Zoomed out. New zoom level: %.1f\n", zoom_level);
  229. }
  230.  
  231.  
  232. static void print_web_view(GtkWidget *widget, WebKitWebView *web_view) {
  233.     WebKitPrintOperation *print_operation = webkit_print_operation_new(web_view);
  234.     webkit_print_operation_run_dialog(print_operation, GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(web_view))));
  235.     g_object_unref(print_operation);
  236. }
  237.  
  238. static void save_web_view_callback(GObject *source_object, GAsyncResult *res, gpointer user_data) {
  239.     WebKitJavascriptResult *js_result;
  240.     GError *error = NULL;
  241.  
  242.     js_result = webkit_web_view_run_javascript_finish(WEBKIT_WEB_VIEW(source_object), res, &error);
  243.     if (!js_result) {
  244.         g_print("Error running JavaScript: %s\n", error->message);
  245.         g_error_free(error);
  246.         return;
  247.     }
  248.  
  249.     JSCValue *value = webkit_javascript_result_get_js_value(js_result);
  250.     if (jsc_value_is_string(value)) {
  251.         gchar *str_value = jsc_value_to_string(value);
  252.         gchar *filename = (gchar *)user_data;
  253.  
  254.         if (g_file_set_contents(filename, str_value, -1, &error)) {
  255.             g_print("File saved successfully: %s\n", filename);
  256.         } else {
  257.             g_print("Error saving file: %s\n", error->message);
  258.             g_error_free(error);
  259.         }
  260.  
  261.         g_free(str_value);
  262.         g_free(filename);
  263.     }
  264.  
  265.     webkit_javascript_result_unref(js_result);
  266. }
  267.  
  268. static void save_web_view(GtkWidget *widget, WebKitWebView *web_view) {
  269.     g_print("Save function called\n");
  270.  
  271.     GtkWidget *dialog;
  272.     GtkFileChooser *chooser;
  273.     GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
  274.     gint res;
  275.  
  276.     dialog = gtk_file_chooser_dialog_new("Save File",
  277.                                          GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(web_view))),
  278.                                          action,
  279.                                          "_Cancel",
  280.                                          GTK_RESPONSE_CANCEL,
  281.                                          "_Save",
  282.                                          GTK_RESPONSE_ACCEPT,
  283.                                          NULL);
  284.     chooser = GTK_FILE_CHOOSER(dialog);
  285.  
  286.     gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
  287.  
  288.     gtk_file_chooser_set_current_name(chooser, "webpage.html");
  289.  
  290.     g_print("File chooser dialog created\n");
  291.  
  292.     res = gtk_dialog_run(GTK_DIALOG(dialog));
  293.     if (res == GTK_RESPONSE_ACCEPT) {
  294.         char *filename;
  295.         filename = gtk_file_chooser_get_filename(chooser);
  296.         g_print("Selected filename: %s\n", filename);
  297.  
  298.         const char *script = "document.documentElement.outerHTML;";
  299.         webkit_web_view_run_javascript(web_view, script, NULL, save_web_view_callback, g_strdup(filename));
  300.  
  301.         g_print("Save operation initiated\n");
  302.     } else {
  303.         g_print("Save operation cancelled\n");
  304.     }
  305.  
  306.     gtk_widget_destroy(dialog);
  307.     g_print("Save function completed\n");
  308. }
  309.  
  310. static void update_address_bar(WebKitWebView *web_view, GtkWidget *address_bar) {
  311.     const gchar *uri = webkit_web_view_get_uri(web_view);
  312.     if (uri) {
  313.         gtk_entry_set_text(GTK_ENTRY(address_bar), uri);
  314.     }
  315. }
  316.  
  317. static void web_view_load_changed(WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer user_data) {
  318.     if (load_event == WEBKIT_LOAD_FINISHED) {
  319.         update_address_bar(web_view, GTK_WIDGET(user_data));
  320.     }
  321. }
  322.  
  323. static void new_window(GtkWidget *widget, gpointer data) {
  324.    // Get the command to run the current executable
  325.    gchar *executable = g_file_read_link("/proc/self/exe", NULL);
  326.     if (executable == NULL) {
  327.        g_print("Error getting executable path\n");
  328.        return;
  329.     }
  330.  
  331.     // Spawn a new process
  332.     gchar *argv[] = {executable, NULL};
  333.     GError *error = NULL;
  334.     if (!g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error)) {
  335.         g_print("Error spawning new process: %s\n", error->message);
  336.         g_error_free(error);
  337.     }
  338.  
  339.     g_free(executable);
  340. }
  341.  
  342.  
  343. static void load_url(GtkEntry *entry, gpointer user_data) {
  344.     const gchar *url = gtk_entry_get_text(entry);
  345.     g_print("Loading URL: %s\n", url);
  346.  
  347.     if (g_str_has_prefix(url, "http://") || g_str_has_prefix(url, "https://")) {
  348.         webkit_web_view_load_uri(WEBKIT_WEB_VIEW(user_data), url);
  349.     } else {
  350.         gchar *search_url = g_strdup_printf("https://www.google.com/search?q=%s", url);
  351.         webkit_web_view_load_uri(WEBKIT_WEB_VIEW(user_data), search_url);
  352.         g_free(search_url);
  353.     }
  354. }
  355.  
  356. static void toggle_images_visibility(WebKitSettings *settings) {
  357.     gboolean current_setting = webkit_settings_get_auto_load_images(settings);
  358.     webkit_settings_set_auto_load_images(settings, !current_setting);
  359. }
  360.  
  361. static void on_show_image_toggled(GtkToggleButton *button, WebKitWebView *web_view) {
  362.     WebKitSettings *settings = webkit_web_view_get_settings(web_view);
  363.     toggle_images_visibility(settings);
  364.     webkit_web_view_reload(web_view);
  365. }
  366.  
  367. static void reload(GtkWidget *widget, WebKitWebView *web_view) {
  368.     webkit_web_view_reload(web_view);
  369. }
  370.  
  371.  
  372. int main(int argc, char *argv[]) {
  373.     gtk_init(&argc, &argv);
  374.      
  375.    
  376.     GtkWidget *window;
  377.     GtkWidget *vbox;
  378.     GtkWidget *menubar;
  379.     GtkWidget *filemenu;
  380.     GtkWidget *file;
  381.     GtkWidget *new_window_item;  // New menu item
  382.     GtkWidget *save;
  383.     GtkWidget *print;
  384.     GtkWidget *quit;
  385.     GtkWidget *helpmenu;
  386.     GtkWidget *help;
  387.     GtkWidget *about;
  388.     GtkWidget *toolbar;
  389.     GtkToolItem *back_button;
  390.     GtkToolItem *forward_button;
  391.     GtkToolItem *zoom_in_button;
  392.     GtkToolItem *zoom_out_button;
  393.     GtkToolItem *image_toggle_button;
  394.     GtkToolItem *reload_button;
  395.     GtkWidget *address_bar;
  396.     GtkWidget *web_view;
  397.  
  398.  
  399.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  400.     gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
  401.     gtk_window_set_title(GTK_WINDOW(window), "Web-Browser");
  402.     gtk_window_set_icon_name(GTK_WINDOW(window), "web-browser");
  403.  
  404.  
  405.     vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  406.     gtk_container_add(GTK_CONTAINER(window), vbox);
  407.  
  408.  
  409.     menubar = gtk_menu_bar_new();
  410.     filemenu = gtk_menu_new();
  411.     helpmenu = gtk_menu_new();
  412.  
  413.     file = gtk_menu_item_new_with_label("File");
  414.     save = gtk_menu_item_new_with_label("Save");
  415.     new_window_item = gtk_menu_item_new_with_label("New Window");  // New menu item
  416.     print = gtk_menu_item_new_with_label("Print");
  417.     quit = gtk_menu_item_new_with_label("Quit");
  418.     help = gtk_menu_item_new_with_label("Help");
  419.     about = gtk_menu_item_new_with_label("About");
  420.     GtkWidget *downloads = gtk_menu_item_new_with_label("Downloads");
  421.    
  422.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
  423.     gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), new_window_item);  // Add new menu item
  424.     gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), save);
  425.     gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), print);
  426.         gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), downloads);
  427.     gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
  428.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
  429.  
  430.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu);
  431.     gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about);
  432.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
  433.  
  434.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
  435.  
  436.  
  437.     toolbar = gtk_toolbar_new();
  438.     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
  439.  
  440.  
  441.     back_button = gtk_tool_button_new(gtk_image_new_from_icon_name("go-previous", GTK_ICON_SIZE_SMALL_TOOLBAR), "Back");
  442.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), back_button, -1);
  443.  
  444.  
  445.     forward_button = gtk_tool_button_new(gtk_image_new_from_icon_name("go-next", GTK_ICON_SIZE_SMALL_TOOLBAR), "Forward");
  446.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), forward_button, -1);
  447.    
  448.  
  449.     zoom_in_button = gtk_tool_button_new(gtk_image_new_from_icon_name("zoom-in", GTK_ICON_SIZE_SMALL_TOOLBAR), "Zoom In");
  450.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), zoom_in_button, -1);
  451.  
  452.     zoom_out_button = gtk_tool_button_new(gtk_image_new_from_icon_name("zoom-out", GTK_ICON_SIZE_SMALL_TOOLBAR), "Zoom Out");
  453.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), zoom_out_button, -1);
  454.    
  455.     image_toggle_button = gtk_tool_button_new(gtk_image_new_from_icon_name("image", GTK_ICON_SIZE_SMALL_TOOLBAR), "Toggle Image");
  456.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), image_toggle_button, -1);
  457.    
  458.     reload_button = gtk_tool_button_new(gtk_image_new_from_icon_name("reload", GTK_ICON_SIZE_SMALL_TOOLBAR), "Reload Page");
  459.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), reload_button, -1);
  460.  
  461.  
  462.  
  463.  
  464.     address_bar = gtk_entry_new();
  465.     GtkToolItem *address_item = gtk_tool_item_new();
  466.     gtk_container_add(GTK_CONTAINER(address_item), address_bar);
  467.     gtk_tool_item_set_expand(address_item, TRUE);
  468.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), address_item, -1);
  469.  
  470.  
  471.     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  472.  
  473.  
  474.     web_view = webkit_web_view_new();
  475.  
  476.  
  477.     gtk_box_pack_start(GTK_BOX(vbox), web_view, TRUE, TRUE, 0);
  478.  
  479.  
  480.     g_signal_connect(back_button, "clicked", G_CALLBACK(go_back), web_view);
  481.     g_signal_connect(forward_button, "clicked", G_CALLBACK(go_forward), web_view);
  482.     g_signal_connect(zoom_in_button, "clicked", G_CALLBACK(zoom_in), web_view);
  483.     g_signal_connect(zoom_out_button, "clicked", G_CALLBACK(zoom_out), web_view);
  484.     g_signal_connect(image_toggle_button, "clicked", G_CALLBACK(on_show_image_toggled), web_view);
  485.     g_signal_connect(reload_button, "clicked", G_CALLBACK(reload), web_view);
  486.    
  487.     g_signal_connect(address_bar, "activate", G_CALLBACK(load_url), web_view);
  488.     g_signal_connect(about, "activate", G_CALLBACK(show_about_dialog), NULL);
  489.     g_signal_connect(print, "activate", G_CALLBACK(print_web_view), web_view);
  490.     g_signal_connect(save, "activate", G_CALLBACK(save_web_view), web_view);
  491.     g_signal_connect(new_window_item, "activate", G_CALLBACK(new_window), NULL);  // Connect new window signal
  492.     g_signal_connect(quit, "activate", G_CALLBACK(gtk_main_quit), NULL);
  493.     g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
  494.  
  495.     // New signal connections
  496.     g_signal_connect(downloads, "activate", G_CALLBACK(show_download_manager), NULL);
  497.     g_signal_connect(web_view, "download-started", G_CALLBACK(download_started), NULL);
  498.     g_signal_connect(webkit_web_context_get_default(), "download-started", G_CALLBACK(download_started), NULL);
  499.    
  500.  
  501.     g_signal_connect(web_view, "load-changed", G_CALLBACK(web_view_load_changed), address_bar);
  502.  
  503.     webkit_web_view_load_uri(WEBKIT_WEB_VIEW(web_view), "https://www.google.com");
  504.    
  505.     update_address_bar(WEBKIT_WEB_VIEW(web_view), address_bar);
  506.      
  507.     gtk_widget_show_all(window);  
  508.    
  509.     g_print("Starting GTK main loop\n");
  510.     gtk_main();
  511.  
  512.     return 0;
  513. }
Tags: web browser
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!