API tools faq
paste
Guest User

Untitled

a guest
Aug 12th, 2024
37
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.84 KB | None | 0 0
raw download clone embed print report
  1. #include <gtk/gtk.h>
  2. #include <webkit2/webkit2.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. #define MAX_BOOKMARKS 20
  8. #define BOOKMARKS_FILE "bookmarks.txt"
  9.  
  10. //
  11.  
  12. typedef struct {
  13. char *title;
  14. char *url;
  15. } Bookmark;
  16.  
  17. Bookmark bookmarks[MAX_BOOKMARKS];
  18. int bookmark_count = 0;
  19.  
  20. void save_bookmarks() {
  21. FILE *file = fopen(BOOKMARKS_FILE, "w");
  22. if (file == NULL) {
  23. g_print("Error opening file for writing\n");
  24. return;
  25. }
  26.  
  27. for (int i = 0; i < bookmark_count; i++) {
  28. fprintf(file, "%s\n%s\n", bookmarks[i].title, bookmarks[i].url);
  29. }
  30.  
  31. fclose(file);
  32. }
  33.  
  34. void load_bookmarks() {
  35. FILE *file = fopen(BOOKMARKS_FILE, "r");
  36. if (file == NULL) {
  37. g_print("No bookmarks file found\n");
  38. return;
  39. }
  40.  
  41. char line[256];
  42. while (fgets(line, sizeof(line), file) && bookmark_count < MAX_BOOKMARKS) {
  43. line[strcspn(line, "\n")] = 0;
  44. bookmarks[bookmark_count].title = g_strdup(line);
  45.  
  46. if (fgets(line, sizeof(line), file)) {
  47. line[strcspn(line, "\n")] = 0;
  48. bookmarks[bookmark_count].url = g_strdup(line);
  49. bookmark_count++;
  50. }
  51. }
  52.  
  53. fclose(file);
  54. }
  55.  
  56. void add_current_page_bookmark(GtkWidget *widget, WebKitWebView *view) {
  57. if (bookmark_count >= MAX_BOOKMARKS) {
  58. g_print("Bookmark limit reached\n");
  59. return;
  60. }
  61.  
  62. const gchar *title = webkit_web_view_get_title(view);
  63. const gchar *url = webkit_web_view_get_uri(view);
  64.  
  65. bookmarks[bookmark_count].title = g_strdup(title);
  66. bookmarks[bookmark_count].url = g_strdup(url);
  67. bookmark_count++;
  68.  
  69. save_bookmarks();
  70. g_print("Bookmark added: %s - %s\n", title, url);
  71. }
  72.  
  73. void load_bookmark(GtkWidget *widget, gpointer data) {
  74. Bookmark *mark = (Bookmark *)data;
  75. webkit_web_view_load_uri(WEBKIT_WEB_VIEW(g_object_get_data(G_OBJECT(widget), "web-view")), mark->url);
  76. }
  77.  
  78. void update_bookmarks_menu(GtkWidget *bookmarks_menu, WebKitWebView *web_view) {
  79. gtk_container_foreach(GTK_CONTAINER(bookmarks_menu), (GtkCallback)gtk_widget_destroy, NULL);
  80.  
  81. GtkWidget *add_page_bookmark = gtk_menu_item_new_with_label("Add Current Page");
  82. gtk_menu_shell_append(GTK_MENU_SHELL(bookmarks_menu), add_page_bookmark);
  83. g_signal_connect(add_page_bookmark, "activate", G_CALLBACK(add_current_page_bookmark), web_view);
  84.  
  85. GtkWidget *separator = gtk_separator_menu_item_new();
  86. gtk_menu_shell_append(GTK_MENU_SHELL(bookmarks_menu), separator);
  87.  
  88. for (int i = 0; i < bookmark_count; i++) {
  89. GtkWidget *item = gtk_menu_item_new_with_label(bookmarks[i].title);
  90. gtk_menu_shell_append(GTK_MENU_SHELL(bookmarks_menu), item);
  91. g_object_set_data(G_OBJECT(item), "web-view", web_view);
  92. g_signal_connect(item, "activate", G_CALLBACK(load_bookmark), &bookmarks[i]);
  93. }
  94.  
  95. gtk_widget_show_all(bookmarks_menu);
  96. }
  97.  
  98. //
  99.  
  100. //blxsaearch
  101.  
  102. void perform_search(WebKitWebView *web_view, const char *search_text);
  103. void show_search_dialog(GtkWidget *widget, WebKitWebView *web_view);
  104.  
  105. void show_search_dialog(GtkWidget *widget, WebKitWebView *web_view) {
  106. GtkWidget *dialog, *content_area, *entry;
  107. GtkDialogFlags flags;
  108.  
  109. flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
  110. dialog = gtk_dialog_new_with_buttons("Search", GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(web_view))),
  111. flags,
  112. "_Cancel", GTK_RESPONSE_CANCEL,
  113. "_Search", GTK_RESPONSE_ACCEPT,
  114. NULL);
  115.  
  116. content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  117. entry = gtk_entry_new();
  118. gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
  119. gtk_container_add(GTK_CONTAINER(content_area), entry);
  120. gtk_widget_show_all(dialog);
  121.  
  122. gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
  123.  
  124. gint result = gtk_dialog_run(GTK_DIALOG(dialog));
  125. if (result == GTK_RESPONSE_ACCEPT) {
  126. const char *search_text = gtk_entry_get_text(GTK_ENTRY(entry));
  127. perform_search(web_view, search_text);
  128. }
  129.  
  130. gtk_widget_destroy(dialog);
  131. }
  132.  
  133.  
  134. void perform_search(WebKitWebView *web_view, const char *search_text) {
  135. WebKitFindController *find_controller = webkit_web_view_get_find_controller(web_view);
  136. webkit_find_controller_search(find_controller, search_text, WEBKIT_FIND_OPTIONS_CASE_INSENSITIVE | WEBKIT_FIND_OPTIONS_WRAP_AROUND, G_MAXUINT);
  137. }
  138.  
  139. //blx
  140.  
  141.  
  142. //blxdown
  143. // New structure to hold download information
  144. typedef struct {
  145. WebKitDownload *download;
  146. GtkWidget *progress_bar;
  147. GtkWidget *label;
  148. } DownloadItem;
  149.  
  150. static gchar* remove_extension(const gchar* filename) {
  151. gchar *dot = strrchr(filename, '.');
  152. if(!dot || dot == filename) return g_strdup(filename);
  153. return g_strndup(filename, dot - filename);
  154. }
  155.  
  156. static gchar* get_extension(const gchar* filename) {
  157. gchar *dot = strrchr(filename, '.');
  158. if(!dot || dot == filename) return g_strdup("");
  159. return g_strdup(dot);
  160. }
  161.  
  162. static gchar* ensure_unique_filename(const gchar* filename) {
  163. gchar *unique_name = g_strdup(filename);
  164. int counter = 1;
  165. while (g_file_test(unique_name, G_FILE_TEST_EXISTS)) {
  166. g_free(unique_name);
  167. gchar *basename = g_path_get_basename(filename);
  168. gchar *directory = g_path_get_dirname(filename);
  169. gchar *file_without_ext = remove_extension(basename);
  170. gchar *extension = get_extension(basename);
  171. unique_name = g_strdup_printf("%s/%s (%d)%s", directory, file_without_ext, counter, extension);
  172. g_free(basename);
  173. g_free(directory);
  174. g_free(file_without_ext);
  175. g_free(extension);
  176. counter++;
  177. }
  178. return unique_name;
  179. }
  180.  
  181. // Global variables for download manager
  182. GtkWidget *download_window = NULL;
  183. GtkWidget *download_list = NULL;
  184.  
  185. // New function to update download progress
  186. static void update_download_progress(WebKitDownload *download, GParamSpec *pspec, DownloadItem *item) {
  187. gdouble progress = webkit_download_get_estimated_progress(download);
  188. gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(item->progress_bar), progress);
  189.  
  190. const gchar *destination = webkit_download_get_destination(download);
  191. const gchar *filename = g_path_get_basename(destination);
  192.  
  193. gchar *progress_text = g_strdup_printf("%s - %.1f%%", filename, progress * 100);
  194. gtk_progress_bar_set_text(GTK_PROGRESS_BAR(item->progress_bar), progress_text);
  195. g_free(progress_text);
  196. }
  197.  
  198. // New function to handle download finished event
  199. static void download_finished(WebKitDownload *download, DownloadItem *item) {
  200.  
  201. const gchar *destination = webkit_download_get_destination(download);
  202. const gchar *filename = g_path_get_basename(destination);
  203.  
  204. gchar *finished_text = g_strdup_printf("Downloaded: %s", filename);
  205. gtk_label_set_text(GTK_LABEL(item->label), finished_text);
  206. g_free(finished_text);
  207.  
  208. gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(item->progress_bar), 1.0);
  209. gtk_progress_bar_set_text(GTK_PROGRESS_BAR(item->progress_bar), "100%");
  210. }
  211.  
  212. // Callback function to set download_window to NULL when it's destroyed
  213. static void on_download_window_destroyed(GtkWidget *widget, gpointer user_data) {
  214. download_window = NULL;
  215. download_list = NULL;
  216. }
  217.  
  218.  
  219. static void show_download_manager(GtkWidget *widget, gpointer user_data) {
  220. if (download_window == NULL) {
  221. // Create the download window if it doesn't exist
  222. download_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  223. gtk_window_set_title(GTK_WINDOW(download_window), "Download Manager");
  224. gtk_window_set_default_size(GTK_WINDOW(download_window), 400, 300);
  225.  
  226. download_list = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
  227. GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  228. gtk_container_add(GTK_CONTAINER(scrolled_window), download_list);
  229. gtk_container_add(GTK_CONTAINER(download_window), scrolled_window);
  230.  
  231. // Connect the delete-event to destroy the window instead of hiding it
  232. g_signal_connect(download_window, "delete-event", G_CALLBACK(gtk_widget_destroy), NULL);
  233.  
  234. // Connect a destroy signal to set download_window to NULL when it's destroyed
  235. g_signal_connect(download_window, "destroy", G_CALLBACK(on_download_window_destroyed), NULL);
  236. }
  237.  
  238. // Show the window and bring it to the front
  239. gtk_widget_show_all(download_window);
  240. gtk_window_present(GTK_WINDOW(download_window));
  241. }
  242.  
  243.  
  244. static void download_started(WebKitWebView *web_view, WebKitDownload *download, gpointer user_data) {
  245. g_print("Download started function called\n");
  246.  
  247. show_download_manager(NULL, NULL);
  248.  
  249. const gchar *destination = webkit_download_get_destination(download);
  250. if (destination == NULL) {
  251. g_print("Error: Download destination is NULL\n");
  252.  
  253. // Get the current URI
  254. WebKitURIRequest *request = webkit_download_get_request(download);
  255. const gchar *uri = request ? webkit_uri_request_get_uri(request) : "N/A";
  256. g_print("Download URI: %s\n", uri);
  257.  
  258. // Generate a filename from the URI
  259. gchar *suggested_filename = NULL;
  260. if (uri && uri[0] != '\0') {
  261. gchar *basename = g_path_get_basename(uri);
  262. if (strchr(basename, '.') == NULL) {
  263. // If there's no extension, add a default one
  264. suggested_filename = g_strconcat(basename, ".download", NULL);
  265. g_free(basename);
  266. } else {
  267. suggested_filename = basename;
  268. }
  269. } else {
  270. suggested_filename = g_strdup("download.bin");
  271. }
  272. g_print("Generated filename: %s\n", suggested_filename);
  273.  
  274. // Set a default destination with the generated filename
  275. gchar *default_destination = g_build_filename(g_get_user_special_dir(G_USER_DIRECTORY_DOWNLOAD),
  276. suggested_filename,
  277. NULL);
  278. gchar *unique_destination = ensure_unique_filename(default_destination);
  279. webkit_download_set_destination(download, unique_destination);
  280. g_print("Set default destination: %s\n", default_destination);
  281. g_print("Set unique destination: %s\n", unique_destination);
  282. g_free(suggested_filename);
  283. g_free(default_destination);
  284. g_free(unique_destination);
  285.  
  286. destination = webkit_download_get_destination(download);
  287. if (destination == NULL) {
  288. g_print("Error: Still unable to get download destination\n");
  289. return;
  290. }
  291. }
  292.  
  293. g_print("Download destination: %s\n", destination);
  294.  
  295. // Extract filename from destination path
  296. const gchar *filename = g_path_get_basename(destination);
  297.  
  298. DownloadItem *item = g_new(DownloadItem, 1);
  299. item->download = download;
  300.  
  301. GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
  302.  
  303. // Create a label with the filename
  304. gchar *label_text = g_strdup_printf("Downloading: %s", filename);
  305. item->label = gtk_label_new(label_text);
  306. g_free(label_text);
  307.  
  308. item->progress_bar = gtk_progress_bar_new();
  309. gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(item->progress_bar), TRUE);
  310.  
  311. gtk_box_pack_start(GTK_BOX(hbox), item->label, FALSE, FALSE, 0);
  312. gtk_box_pack_start(GTK_BOX(hbox), item->progress_bar, TRUE, TRUE, 0);
  313.  
  314. gtk_container_add(GTK_CONTAINER(download_list), hbox);
  315. gtk_widget_show_all(download_window);
  316.  
  317. g_signal_connect(download, "notify::estimated-progress", G_CALLBACK(update_download_progress), item);
  318. g_signal_connect(download, "finished", G_CALLBACK(download_finished), item);
  319. }
  320.  
  321.  
  322.  
  323. //BLXdownend
  324.  
  325. static void show_about_dialog(GtkWidget *widget, gpointer data) {
  326. GtkWidget *dialog = gtk_about_dialog_new();
  327. gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(dialog), "Simple Browser");
  328. gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), "1.0");
  329. gtk_about_dialog_set_logo_icon_name(GTK_ABOUT_DIALOG(dialog), "web-browser");
  330. gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), "A simple GTK3 WebKit2 based browser");
  331. gtk_dialog_run(GTK_DIALOG(dialog));
  332. gtk_widget_destroy(dialog);
  333. }
  334.  
  335. static void go_back(GtkWidget *widget, WebKitWebView *web_view) {
  336. g_print("Back button clicked\n");
  337. if (webkit_web_view_can_go_back(web_view)) {
  338. g_print("Going back\n");
  339. webkit_web_view_go_back(web_view);
  340. } else {
  341. g_print("Cannot go back\n");
  342. }
  343. }
  344.  
  345. static void go_forward(GtkWidget *widget, WebKitWebView *web_view) {
  346. g_print("Forward button clicked\n");
  347. if (webkit_web_view_can_go_forward(web_view)) {
  348. g_print("Going forward\n");
  349. webkit_web_view_go_forward(web_view);
  350. } else {
  351. g_print("Cannot go forward\n");
  352. }
  353. }
  354.  
  355. static void zoom_in(GtkWidget *widget, WebKitWebView *web_view) {
  356. gdouble zoom_level = webkit_web_view_get_zoom_level(web_view);
  357. zoom_level += 0.1;
  358. webkit_web_view_set_zoom_level(web_view, zoom_level);
  359. g_print("Zoomed in. New zoom level: %.1f\n", zoom_level);
  360. }
  361.  
  362. static void zoom_out(GtkWidget *widget, WebKitWebView *web_view) {
  363. gdouble zoom_level = webkit_web_view_get_zoom_level(web_view);
  364. zoom_level -= 0.1;
  365. webkit_web_view_set_zoom_level(web_view, zoom_level);
  366. g_print("Zoomed out. New zoom level: %.1f\n", zoom_level);
  367. }
  368.  
  369.  
  370. static void print_web_view(GtkWidget *widget, WebKitWebView *web_view) {
  371. WebKitPrintOperation *print_operation = webkit_print_operation_new(web_view);
  372. webkit_print_operation_run_dialog(print_operation, GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(web_view))));
  373. g_object_unref(print_operation);
  374. }
  375.  
  376. static void save_web_view_callback(GObject *source_object, GAsyncResult *res, gpointer user_data) {
  377. WebKitJavascriptResult *js_result;
  378. GError *error = NULL;
  379.  
  380. js_result = webkit_web_view_run_javascript_finish(WEBKIT_WEB_VIEW(source_object), res, &error);
  381. if (!js_result) {
  382. g_print("Error running JavaScript: %s\n", error->message);
  383. g_error_free(error);
  384. return;
  385. }
  386.  
  387. JSCValue *value = webkit_javascript_result_get_js_value(js_result);
  388. if (jsc_value_is_string(value)) {
  389. gchar *str_value = jsc_value_to_string(value);
  390. gchar *filename = (gchar *)user_data;
  391.  
  392. if (g_file_set_contents(filename, str_value, -1, &error)) {
  393. g_print("File saved successfully: %s\n", filename);
  394. } else {
  395. g_print("Error saving file: %s\n", error->message);
  396. g_error_free(error);
  397. }
  398.  
  399. g_free(str_value);
  400. g_free(filename);
  401. }
  402.  
  403. webkit_javascript_result_unref(js_result);
  404. }
  405.  
  406. static void save_web_view(GtkWidget *widget, WebKitWebView *web_view) {
  407. g_print("Save function called\n");
  408.  
  409. GtkWidget *dialog;
  410. GtkFileChooser *chooser;
  411. GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
  412. gint res;
  413.  
  414. dialog = gtk_file_chooser_dialog_new("Save File",
  415. GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(web_view))),
  416. action,
  417. "_Cancel",
  418. GTK_RESPONSE_CANCEL,
  419. "_Save",
  420. GTK_RESPONSE_ACCEPT,
  421. NULL);
  422. chooser = GTK_FILE_CHOOSER(dialog);
  423.  
  424. gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
  425.  
  426. gtk_file_chooser_set_current_name(chooser, "webpage.html");
  427.  
  428. g_print("File chooser dialog created\n");
  429.  
  430. res = gtk_dialog_run(GTK_DIALOG(dialog));
  431. if (res == GTK_RESPONSE_ACCEPT) {
  432. char *filename;
  433. filename = gtk_file_chooser_get_filename(chooser);
  434. g_print("Selected filename: %s\n", filename);
  435.  
  436. const char *script = "document.documentElement.outerHTML;";
  437. webkit_web_view_run_javascript(web_view, script, NULL, save_web_view_callback, g_strdup(filename));
  438.  
  439. g_print("Save operation initiated\n");
  440. } else {
  441. g_print("Save operation cancelled\n");
  442. }
  443.  
  444. gtk_widget_destroy(dialog);
  445. g_print("Save function completed\n");
  446. }
  447.  
  448. static void update_address_bar(WebKitWebView *web_view, GtkWidget *address_bar) {
  449. const gchar *uri = webkit_web_view_get_uri(web_view);
  450. if (uri) {
  451. gtk_entry_set_text(GTK_ENTRY(address_bar), uri);
  452. }
  453. }
  454.  
  455. static void web_view_load_changed(WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer user_data) {
  456. if (load_event == WEBKIT_LOAD_FINISHED) {
  457. update_address_bar(web_view, GTK_WIDGET(user_data));
  458. }
  459. }
  460.  
  461. static void new_window(GtkWidget *widget, gpointer data) {
  462. // Get the command to run the current executable
  463. gchar *executable = g_file_read_link("/proc/self/exe", NULL);
  464. if (executable == NULL) {
  465. g_print("Error getting executable path\n");
  466. return;
  467. }
  468.  
  469. // Spawn a new process
  470. gchar *argv[] = {executable, NULL};
  471. GError *error = NULL;
  472. if (!g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error)) {
  473. g_print("Error spawning new process: %s\n", error->message);
  474. g_error_free(error);
  475. }
  476.  
  477. g_free(executable);
  478. }
  479.  
  480.  
  481. static void load_url(GtkEntry *entry, gpointer user_data) {
  482. const gchar *url = gtk_entry_get_text(entry);
  483. g_print("Loading URL: %s\n", url);
  484.  
  485. if (g_str_has_prefix(url, "http://") || g_str_has_prefix(url, "https://")) {
  486. webkit_web_view_load_uri(WEBKIT_WEB_VIEW(user_data), url);
  487. } else {
  488. gchar *search_url = g_strdup_printf("https://www.google.com/search?q=%s", url);
  489. webkit_web_view_load_uri(WEBKIT_WEB_VIEW(user_data), search_url);
  490. g_free(search_url);
  491. }
  492. }
  493.  
  494. static void toggle_images_visibility(WebKitSettings *settings) {
  495. gboolean current_setting = webkit_settings_get_auto_load_images(settings);
  496. webkit_settings_set_auto_load_images(settings, !current_setting);
  497. }
  498.  
  499. static void on_show_image_toggled(GtkToggleButton *button, WebKitWebView *web_view) {
  500. WebKitSettings *settings = webkit_web_view_get_settings(web_view);
  501. toggle_images_visibility(settings);
  502. webkit_web_view_reload(web_view);
  503. }
  504.  
  505. static void reload(GtkWidget *widget, WebKitWebView *web_view) {
  506. webkit_web_view_reload(web_view);
  507. }
  508.  
  509.  
  510.  
  511. static void open_inspector(GtkWidget *widget, WebKitWebView *web_view) {
  512. WebKitSettings *settings = webkit_web_view_get_settings(web_view);
  513. webkit_settings_set_enable_developer_extras(settings, TRUE);
  514.  
  515. WebKitWebInspector *inspector = webkit_web_view_get_inspector(web_view);
  516. webkit_web_inspector_show(inspector);
  517. }
  518.  
  519. int main(int argc, char *argv[]) {
  520. gtk_init(&argc, &argv);
  521.  
  522.  
  523. GtkWidget *window;
  524. GtkWidget *vbox;
  525. GtkWidget *menubar;
  526. GtkWidget *filemenu;
  527. GtkWidget *editmenu; // New edit menu
  528. GtkWidget *file;
  529. GtkWidget *new_window_item; // New menu item
  530. GtkWidget *edit; // New edit menu item
  531. GtkWidget *search; // New search menu item
  532.  
  533. GtkWidget *bookmark;
  534. GtkWidget *bookmarkmenu;
  535. GtkWidget *add_bookmark;
  536. GtkWidget *bookmarks_submenu;
  537. GtkWidget *bookmarks_menu_item;
  538.  
  539. GtkWidget *save;
  540. GtkWidget *print;
  541. GtkWidget *quit;
  542. GtkWidget *helpmenu;
  543. GtkWidget *help;
  544. GtkWidget *about;
  545. GtkWidget *toolbar;
  546. GtkToolItem *back_button;
  547. GtkToolItem *forward_button;
  548. GtkToolItem *zoom_in_button;
  549. GtkToolItem *zoom_out_button;
  550. GtkToolItem *image_toggle_button;
  551. GtkToolItem *reload_button;
  552. GtkToolItem *inspector_button;
  553. GtkWidget *address_bar;
  554. GtkWidget *web_view;
  555.  
  556.  
  557.  
  558.  
  559.  
  560.  
  561.  
  562. window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  563. gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
  564. gtk_window_set_title(GTK_WINDOW(window), "Web-Browser");
  565. gtk_window_set_icon_name(GTK_WINDOW(window), "web-browser");
  566.  
  567.  
  568. vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  569. gtk_container_add(GTK_CONTAINER(window), vbox);
  570.  
  571.  
  572. menubar = gtk_menu_bar_new();
  573. filemenu = gtk_menu_new();
  574. helpmenu = gtk_menu_new();
  575. editmenu = gtk_menu_new(); // Create edit menu
  576. bookmarkmenu = gtk_menu_new();
  577.  
  578.  
  579. edit = gtk_menu_item_new_with_label("Edit"); // Create edit menu item
  580. search = gtk_menu_item_new_with_label("Search"); // Create search menu item
  581.  
  582.  
  583. file = gtk_menu_item_new_with_label("File");
  584. save = gtk_menu_item_new_with_label("Save");
  585. new_window_item = gtk_menu_item_new_with_label("New Window"); // New menu item
  586. print = gtk_menu_item_new_with_label("Print");
  587. quit = gtk_menu_item_new_with_label("Quit");
  588. help = gtk_menu_item_new_with_label("Help");
  589. about = gtk_menu_item_new_with_label("About");
  590. bookmark = gtk_menu_item_new_with_label("Bookmark");
  591. GtkWidget *downloads = gtk_menu_item_new_with_label("Downloads");
  592.  
  593. bookmark = gtk_menu_item_new_with_label("Bookmark");
  594. bookmarkmenu = gtk_menu_new();
  595. add_bookmark = gtk_menu_item_new_with_label("Add Bookmark");
  596.  
  597. bookmarks_menu_item = gtk_menu_item_new_with_label("Bookmarks");
  598. bookmarks_submenu = gtk_menu_new();
  599. gtk_menu_item_set_submenu(GTK_MENU_ITEM(bookmarks_menu_item), bookmarks_submenu);
  600.  
  601.  
  602.  
  603. gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
  604. gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), new_window_item); // Add new menu item
  605. gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), save);
  606. gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), print);
  607. gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), downloads);
  608. gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
  609. gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
  610.  
  611. gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), editmenu); // Set submenu for edit
  612. gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), search); // Add search to edit menu
  613. gtk_menu_shell_append(GTK_MENU_SHELL(menubar), edit); // Add edit menu to menubar
  614.  
  615.  
  616.  
  617. gtk_menu_item_set_submenu(GTK_MENU_ITEM(bookmark), bookmarkmenu);
  618. gtk_menu_shell_append(GTK_MENU_SHELL(bookmarkmenu), add_bookmark);
  619. gtk_menu_shell_append(GTK_MENU_SHELL(bookmarkmenu), bookmarks_menu_item);
  620.  
  621. GtkWidget *separator = gtk_separator_menu_item_new();
  622. gtk_menu_shell_append(GTK_MENU_SHELL(bookmarks_submenu), separator);
  623.  
  624. gtk_menu_shell_append(GTK_MENU_SHELL(menubar), bookmark);
  625.  
  626.  
  627.  
  628. gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu);
  629. gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about);
  630. gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
  631.  
  632.  
  633. gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
  634.  
  635.  
  636. toolbar = gtk_toolbar_new();
  637. gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
  638.  
  639.  
  640. back_button = gtk_tool_button_new(gtk_image_new_from_icon_name("go-previous", GTK_ICON_SIZE_SMALL_TOOLBAR), "Back");
  641. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), back_button, -1);
  642.  
  643.  
  644. forward_button = gtk_tool_button_new(gtk_image_new_from_icon_name("go-next", GTK_ICON_SIZE_SMALL_TOOLBAR), "Forward");
  645. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), forward_button, -1);
  646.  
  647.  
  648. zoom_in_button = gtk_tool_button_new(gtk_image_new_from_icon_name("zoom-in", GTK_ICON_SIZE_SMALL_TOOLBAR), "Zoom In");
  649. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), zoom_in_button, -1);
  650.  
  651. zoom_out_button = gtk_tool_button_new(gtk_image_new_from_icon_name("zoom-out", GTK_ICON_SIZE_SMALL_TOOLBAR), "Zoom Out");
  652. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), zoom_out_button, -1);
  653.  
  654. image_toggle_button = gtk_tool_button_new(gtk_image_new_from_icon_name("image", GTK_ICON_SIZE_SMALL_TOOLBAR), "Toggle Image");
  655. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), image_toggle_button, -1);
  656.  
  657. reload_button = gtk_tool_button_new(gtk_image_new_from_icon_name("reload", GTK_ICON_SIZE_SMALL_TOOLBAR), "Reload Page");
  658. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), reload_button, -1);
  659.  
  660. inspector_button = gtk_tool_button_new(gtk_image_new_from_icon_name("utilities-terminal", GTK_ICON_SIZE_SMALL_TOOLBAR), "Inspector");
  661. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), inspector_button, -1);
  662.  
  663.  
  664.  
  665.  
  666. address_bar = gtk_entry_new();
  667. GtkToolItem *address_item = gtk_tool_item_new();
  668. gtk_container_add(GTK_CONTAINER(address_item), address_bar);
  669. gtk_tool_item_set_expand(address_item, TRUE);
  670. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), address_item, -1);
  671.  
  672.  
  673. gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  674.  
  675.  
  676. web_view = webkit_web_view_new();
  677.  
  678.  
  679. gtk_box_pack_start(GTK_BOX(vbox), web_view, TRUE, TRUE, 0);
  680.  
  681.  
  682. g_signal_connect(back_button, "clicked", G_CALLBACK(go_back), web_view);
  683. g_signal_connect(forward_button, "clicked", G_CALLBACK(go_forward), web_view);
  684. g_signal_connect(zoom_in_button, "clicked", G_CALLBACK(zoom_in), web_view);
  685. g_signal_connect(zoom_out_button, "clicked", G_CALLBACK(zoom_out), web_view);
  686. g_signal_connect(image_toggle_button, "clicked", G_CALLBACK(on_show_image_toggled), web_view);
  687. g_signal_connect(reload_button, "clicked", G_CALLBACK(reload), web_view);
  688. g_signal_connect(inspector_button, "clicked", G_CALLBACK(open_inspector), web_view);
  689.  
  690.  
  691. g_signal_connect(address_bar, "activate", G_CALLBACK(load_url), web_view);
  692. g_signal_connect(about, "activate", G_CALLBACK(show_about_dialog), NULL);
  693. g_signal_connect(print, "activate", G_CALLBACK(print_web_view), web_view);
  694. g_signal_connect(save, "activate", G_CALLBACK(save_web_view), web_view);
  695. g_signal_connect(new_window_item, "activate", G_CALLBACK(new_window), NULL); // Connect new window signal
  696. g_signal_connect(quit, "activate", G_CALLBACK(gtk_main_quit), NULL);
  697. g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
  698.  
  699. g_signal_connect(add_bookmark, "activate", G_CALLBACK(add_current_page_bookmark), web_view);
  700.  
  701. g_signal_connect(search, "activate", G_CALLBACK(show_search_dialog), web_view);
  702.  
  703.  
  704. // New signal connections
  705. g_signal_connect(downloads, "activate", G_CALLBACK(show_download_manager), NULL);
  706. g_signal_connect(web_view, "download-started", G_CALLBACK(download_started), NULL);
  707. g_signal_connect(webkit_web_context_get_default(), "download-started", G_CALLBACK(download_started), NULL);
  708.  
  709.  
  710. g_signal_connect(web_view, "load-changed", G_CALLBACK(web_view_load_changed), address_bar);
  711.  
  712. webkit_web_view_load_uri(WEBKIT_WEB_VIEW(web_view), "https://www.google.com");
  713.  
  714. update_address_bar(WEBKIT_WEB_VIEW(web_view), address_bar);
  715.  
  716. gtk_widget_show_all(window);
  717.  
  718. load_bookmarks();
  719. update_bookmarks_menu(bookmarks_submenu, web_view);
  720.  
  721. g_print("Starting GTK main loop\n");
  722. gtk_main();
  723.  
  724. return 0;
  725. }
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!