interface.c

基于minigui的浏览器. 这是最新版本.

   gtk_container_add(GTK_CONTAINER(frame), label);
   gtk_widget_show(label);
   gtk_widget_show(frame);
   gtk_box_pack_start(GTK_BOX(box1), frame, TRUE, TRUE, 0);

   /* This struct will save us some code and lots of callback functions.
    * (it looks clumsy, but provides a handy interface for the caller) */
   answer = g_new(DialogAnswer, 6);
   for (i = 0; i < 6; ++i) {
      answer[i].bw = bw;
      answer[i].alt_num = i;
      answer[i].this = answer;
   }
   answer[0].alt_str = NULL; answer[1].alt_str = alt1;
   answer[2].alt_str = alt2; answer[3].alt_str = alt3;
   answer[4].alt_str = alt4; answer[5].alt_str = alt5;
   /* Set the default answer */
   bw->question_dialog_answer = &answer[0];

   /* pack the alternatives */
   box2 = gtk_hbox_new(TRUE, 5);
   for (i = 1; i < 6 && answer[i].alt_str; ++i) {
      button = gtk_button_new_with_label(answer[i].alt_str);
      gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
         (GtkSignalFunc) Interface_question_dialog_set_answer_cb,
         (gpointer)&answer[i]);
      gtk_signal_connect(GTK_OBJECT(button), "clicked",
         (GtkSignalFunc) Interface_destroy_window, DialogWindow);
      gtk_widget_show(button);
      gtk_box_pack_start(GTK_BOX(box2), button, FALSE, TRUE, 0);
   }

   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
   gtk_container_add(GTK_CONTAINER(*DialogWindow), box1);

   gtk_widget_show(box2);
   gtk_widget_show(box1);
   gtk_widget_grab_focus(button);
   gtk_widget_show(*DialogWindow);
}

/*
 * Create and show an [OK|Cancel] question dialog
 */
void a_Interface_question_dialog(
        BrowserWindow *bw, gchar *QuestionTxt, gint modal_flag,
        char *alt1, char *alt2, char *alt3, char *alt4, char *alt5,
        GtkSignalFunc AnswerCallback)
{
   if (!bw->question_dialog_window) {
      Interface_make_question_dialog(
         bw,
         &(bw->question_dialog_window), "question_dialog", "Dillo",
         "Dillo: Question", QuestionTxt, modal_flag,
         alt1, alt2, alt3, alt4, alt5,
         AnswerCallback);
   } else {
      /* should not reach here */
      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 = a_Dpip_build_cmd("cmd=%s url=%s destination=%s",
                             "download", 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)
{
   int i;
   gchar *FileName, *FilenameWithDir, *o, *n;

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

   /* Replace %20 and ' ' with '_' in Filename */
   o = n = FileName;
   for (i = 0; o[i]; i++) {
      *n++ = (o[i] == ' ' || (o[i] == '%' && o[i+1] == '2' && o[i+2] == '0')) ?
             i+=2, '_' : o[i];
   }
   *n = 0;

   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_passw