interface.c

著名的手机浏览器开源代码

/*
 * Create and show an [OK|Cancel] question dialog
 */
void a_Interface_question_dialog(
        BrowserWindow *bw, gchar *QuestionTxt,
        GtkSignalFunc OkCallback, void *OkCbData,
        GtkSignalFunc CancelCallback, void *CancelCbData)
{
   if (!bw->question_dialog_window) {
      Interface_make_question_dialog(&(bw->question_dialog_window),
         "question_dialog", "Dillo", "Dillo: Question", QuestionTxt,
         OkCallback, OkCbData, CancelCallback, CancelCbData);
   } else {
      gtk_widget_destroy(bw->question_dialog_window);
   }
}

/*
 * Create and show the open URL dialog
 */
void a_Interface_open_dialog(GtkWidget *widget, BrowserWindow *bw)
{
   if (!bw->open_dialog_window) {
      Interface_make_dialog(&(bw->open_dialog_window),
         "open_dialog", "Dillo", "Dillo: Open URL",
         &(bw->open_dialog_entry), "", 1, NULL, NULL,
         "OK", (GtkSignalFunc) a_Interface_entry_open_url, (void *)bw);
      if (prefs.transient_dialogs)
         gtk_window_set_transient_for(GTK_WINDOW(bw->open_dialog_window),
                                      GTK_WINDOW(bw->main_window));
   }

   if (!GTK_WIDGET_VISIBLE(bw->open_dialog_window))
      gtk_widget_show(bw->open_dialog_window);
   else
      gdk_window_raise(bw->open_dialog_window->window);
}

/*
 * Receive data from the cache and save it to a local file
 */
static void Interface_save_callback(int Op, CacheClient_t *Client)
{
   DilloWeb *Web = Client->Web;
   gint Bytes;

   if ( Op ){
      struct stat st;

      fflush(Web->stream);
      fstat(fileno(Web->stream), &st);
      fclose(Web->stream);
      a_Interface_msg(Web->bw, "File saved (%d Bytes)", st.st_size);
   } else {
      if ( (Bytes = Client->BufSize - Web->SavedBytes) > 0 ) {
         Bytes = fwrite(Client->Buf + Web->SavedBytes, 1, Bytes, Web->stream);
         Web->SavedBytes += Bytes;
      }
   }
}

/*
 * Save current page to a local file
 */
static void Interface_file_save_url(GtkWidget *widget, BrowserWindow *bw)
{
   const char *name;
   GtkFileSelection *choosefile;
   GtkEntry *entry_url;
   DilloUrl *url;
   FILE *out;

   choosefile = GTK_FILE_SELECTION(bw->save_dialog_window);
   entry_url = GTK_ENTRY(bw->location);
   name = gtk_file_selection_get_filename(choosefile);
   url = a_Url_dup(a_History_get_url(NAV_TOP(bw)));

   if ( strlen(name) && (out = fopen(name, "w")) != NULL ) {
      DilloWeb *Web = a_Web_new(url);
      Web->bw = bw;
      Web->stream = out;
      Web->flags |= WEB_Download;
      /* todo: keep track of this client */
      a_Capi_open_url(Web, Interface_save_callback, Web);

      g_free(save_dialog_last_dirname);
      save_dialog_last_dirname = g_strdup(name);
   }
   a_Url_free(url);

   gtk_widget_destroy(bw->save_dialog_window);
}

/*
 * Save the link-URL to a local file
 */
static void Interface_file_save_link(GtkWidget *widget, BrowserWindow *bw)
{
   const gchar *name;
   const DilloUrl *url;
   gchar *cmd, *buf;
   FILE *out;
   gint buf_size;

   name = gtk_file_selection_get_filename(
             GTK_FILE_SELECTION(bw->save_link_dialog_window));
   url  = a_Menu_popup_get_url(bw);

   g_free(save_dialog_last_dirname);
   save_dialog_last_dirname = g_strdup(name);

   if (!a_Capi_get_buf(url, &buf, &buf_size)) {
      /* Not cached, ask the downloads server to get it */
      cmd = g_strdup_printf(
               "<dpi cmd='download' url='%s' destination='%s'>\n",
               URL_STR(url), name);
      a_Capi_dpi_send_cmd(NULL, bw, cmd, "downloads", 1);
      g_free(cmd);

   } else {
      /* Cached! Save from the cache */
      if ( strlen(name) && (out = fopen(name, "w")) != NULL ) {
         DilloWeb *Web = a_Web_new(url);
         Web->bw = bw;
         Web->stream = out;
         Web->flags |= WEB_Download;
         /* todo: keep track of this client */
         a_Capi_open_url(Web, Interface_save_callback, Web);
      } else
         g_printerr("Error trying to save: %s\n", name);
   }

   gtk_widget_destroy(bw->save_link_dialog_window);
}

/*
 * Scan Url and return a local-filename suggestion for saving
 */
static char *Interface_make_save_name(const DilloUrl *url)
{
   gchar *FileName, *FilenameWithDir;

   if ((FileName = strrchr(URL_PATH(url), '/')))
      FileName = g_strndup(FileName + 1, MIN(strlen(FileName + 1), 64));
   else
      FileName = g_strdup("");

   if (save_dialog_last_dirname) {
      if (*FileName) {
        gchar *dirpart = g_dirname(save_dialog_last_dirname);
        FilenameWithDir =
           g_strconcat(dirpart, G_DIR_SEPARATOR_S, FileName, NULL);
        g_free(dirpart);
      } else {
        FilenameWithDir = g_strdup(save_dialog_last_dirname);
      }
      g_free(FileName);
      return FilenameWithDir;
   } else
      return FileName;
}

/*
 * Show the dialog interface for saving an URL
 */
void a_Interface_save_dialog(GtkWidget *widget, BrowserWindow *bw)
{
   gchar *SuggestedName;   /* Suggested save name */
   DilloUrl* url;

   if (!bw->save_dialog_window) {
      Interface_make_choose_file_dialog(
         &bw->save_dialog_window,
         "save_dialog", "Dillo", "Dillo: Save URL as File...",
         (GtkSignalFunc) Interface_file_save_url, (void *)bw );
   }
   url = a_Url_new(a_Interface_get_location_text(bw), NULL, 0, 0, 0);
   SuggestedName = Interface_make_save_name(url);
   gtk_file_selection_set_filename(
      GTK_FILE_SELECTION(bw->save_dialog_window), SuggestedName);
   g_free(SuggestedName);
   a_Url_free(url);

   if (!GTK_WIDGET_VISIBLE(bw->save_dialog_window))
      gtk_widget_show(bw->save_dialog_window);
   else
      gdk_window_raise(bw->save_dialog_window->window);
}

/*
 * Show the dialog interface for saving a link
 */
void a_Interface_save_link_dialog(GtkWidget *widget, BrowserWindow *bw)
{
   char *SuggestedName;   /* Suggested save name */

   if (!bw->save_link_dialog_window) {
      Interface_make_choose_file_dialog(
         &bw->save_link_dialog_window,
         "save_link_dialog", "Dillo",
         "Dillo: Save link as File...",
         (GtkSignalFunc) Interface_file_save_link,
         (void *)bw);
   }
   SuggestedName = Interface_make_save_name(a_Menu_popup_get_url(bw));
   gtk_file_selection_set_filename(
      GTK_FILE_SELECTION(bw->save_link_dialog_window), SuggestedName);
   g_free(SuggestedName);

   if (!GTK_WIDGET_VISIBLE(bw->save_link_dialog_window))
      gtk_widget_show(bw->save_link_dialog_window);
   else
      gdk_window_raise(bw->save_link_dialog_window->window);
}

/*
 * Offer the "Save Link As..." dialog for an unhandled MIME type URL.
 */
void a_Interface_offer_link_download(BrowserWindow *bw, const DilloUrl *url)
{
   a_Menu_popup_set_url(bw, url);
   a_Interface_save_link_dialog(NULL, bw);
}

/*
 * Scroll to an occurence of a string in the open page
 */
static void Interface_entry_search(GtkWidget *widget, BrowserWindow* bw)
{
   char *string;
   gboolean case_sens;

   string = gtk_editable_get_chars(GTK_EDITABLE(bw->findtext_dialog_entry),
                                   0, -1);
   case_sens = gtk_toggle_button_get_active
      (GTK_TOGGLE_BUTTON(bw->findtext_dialog_check));
   switch(a_Dw_gtk_scrolled_window_search(GTK_DW_SCROLLED_WINDOW(bw->docwin),
                                          string, case_sens)) {
   case FINDTEXT_RESTART:
      a_Interface_message_window("Dillo: Find text",
                                 "No further occurence of \"%s\". "
                                 "Restarting from the beginning.", string);
      break;
   case FINDTEXT_NOT_FOUND:
      a_Interface_message_window("Dillo: Find text",
                                 "Cannot find \"%s\".", string);
      break;
   }
   g_free(string);
}

/*
 * Show the dialog interface for finding text in a page
 */
void a_Interface_findtext_dialog(BrowserWindow *bw)
{
   if (!bw->findtext_dialog_window) {
      Interface_make_dialog(&(bw->findtext_dialog_window),
         "findtext_dialog", "Dillo", "Dillo: Find text in page",
         &(bw->findtext_dialog_entry), "", 1,
         &(bw->findtext_dialog_check), "Case sensitive",
         "Find", (GtkSignalFunc) Interface_entry_search, (void *)bw);
      if (prefs.transient_dialogs)
         gtk_window_set_transient_for(GTK_WINDOW(bw->findtext_dialog_window),
                                      GTK_WINDOW(bw->main_window));
      gtk_signal_connect_object
         (GTK_OBJECT(bw->findtext_dialog_window), "destroy",
          (GtkSignalFunc) a_Dw_gtk_scrolled_window_reset_search,
          (void*)bw->docwin);
      gtk_window_set_position(GTK_WINDOW(bw->findtext_dialog_window),
                              GTK_WIN_POS_NONE);
   }

   a_Interface_set_nice_window_pos(bw->findtext_dialog_window,
                                   bw->main_window);

   if (!GTK_WIDGET_VISIBLE(bw->findtext_dialog_window))
      gtk_widget_show(bw->findtext_dialog_window);
   else
      gdk_window_raise(bw->findtext_dialog_window->window);
}

/*
 * Use the search dialog's entry to feed a web search engine.
 */
static void Interface_search_callback(GtkWidget *widget, BrowserWindow *bw)
{
   gchar *keyw, *url_str;

   keyw = gtk_editable_get_chars(GTK_EDITABLE(bw->search_dialog_entry), 0, -1);
   if (keyw) {
      url_str = Interface_make_search_url(keyw);
      Interface_open_url_string(url_str, bw);
      g_free(url_str);
      g_free(keyw);
   }
   if (bw->search_dialog_window != NULL)
      gtk_widget_hide(bw->search_dialog_window);
}

/*
 * Show the dialog interface for web search engine.
 */
void a_Interface_search_dialog(GtkWidget *widget, BrowserWindow *bw)
{
   if (!bw->search_dialog_window) {
      Interface_make_dialog(&(bw->search_dialog_window),
         "search_dialog", "Dillo", "Dillo: Search the Web",
         &(bw->search_dialog_entry), "", 1, NULL, NULL,
         "Search", (GtkSignalFunc)Interface_search_callback, (void *)bw);
      if (prefs.transient_dialogs)
         gtk_window_set_transient_for(GTK_WINDOW(bw->search_dialog_window),
                                      GTK_WINDOW(bw->main_window));
   }

   if (!GTK_WIDGET_VISIBLE(bw->search_dialog_window))
      gtk_widget_show(bw->search_dialog_window);
   else
      gdk_window_raise(bw->search_dialog_window->window);
}

/*
 * Get and activate a proxy password.
 */
static void Interface_entry_proxy_passwd(GtkWidget *widget, BrowserWindow *bw)
{
   gchar *text;

   text = gtk_editable_get_chars(GTK_EDITABLE(bw->proxy_passwd_dialog_entry),
                                 0, -1);
   a_Http_set_proxy_passwd(text);
   g_free(text);

   if (bw->proxy_passwd_dialog_window != NULL)
      gtk_widget_destroy(bw->proxy_passwd_dialog_window);
}

/*
 * Show the dialog interface for asking proxy password.
 */
void a_Interface_proxy_passwd_dialog(BrowserWindow *bw)
{
   GString *buf = g_string_new("");

   g_string_sprintf(buf, "Dillo: Enter proxy password for '%s'",
                    prefs.http_proxyuser);

   if (!bw->proxy_passwd_dialog_window) {
      Interface_make_dialog(&(bw->proxy_passwd_dialog_window),
         "proxy_passwd_dialog", "Dillo", buf->str,
         &(bw->proxy_passwd_dialog_entry), "", 0, NULL, NULL,
         "OK", (GtkSignalFunc)Interface_entry_proxy_passwd, (void *)bw);
      if (prefs.transient_dialogs)
         gtk_window_set_transient_for(
            GTK_WINDOW(bw->proxy_passwd_dialog_window),
            GTK_WINDOW(bw->main_window));
      gtk_window_set_modal(GTK_WINDOW(bw->proxy_passwd_dialog_window), TRUE);
   }

   if (!GTK_WIDGET_VISIBLE(bw->proxy_passwd_dialog_window))
      gtk_widget_show(bw->proxy_passwd_dialog_window);

   g_string_free(buf, TRUE);
}

/*
 * This signal callback adjusts the position of a menu.
 * It's useful for very long menus.
 */
void a_Interface_scroll_popup(GtkWidget *widget)
{
   /*
    * todo:
    *   1) Scrolling menues should rather be the task of Gtk+. This is
    *      a hack, and I don't know if it does not break anything.
    *   2) It could be improved, e.g. a timeout could be added for
    *      better mouse navigation.
    */
   int y, h, mx, my, sh;

   y = widget->allocation.y;
   h = widget->allocation.height;
   gdk_window_get_geometry (widget->parent->parent->window,
                            &mx, &my, NULL, NULL, NULL);
   sh = gdk_screen_height ();

   if (y + my < 0)
      gdk_window_move (widget->parent->parent->window, mx, - y + 1);
   else if (y + my > sh - h)