interface.c

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

   a_Progressbar_update(bw->progress, "", 0);
   a_Progressbar_update(bw->imgprogress, "", 0);
}

/*
 * Set the status string on the bottom of the dillo window.
 */
void a_Interface_msg(BrowserWindow *bw, const char *format, ... )
{
   static char msg[1024];
   va_list argp;

   if ( bw ) {
      va_start(argp, format);
      vsnprintf(msg, 1024, format, argp);
      va_end(argp);
      gtk_label_set_text(GTK_LABEL(bw->status), msg);
      bw->status_is_link = 0;
   }
}

/*
 * Update the bug-meter button for detected page errors.
 */
void a_Interface_bug_meter_update(BrowserWindow *bw, gint num_err)
{
   static char msg[64];
   gpointer label, bug, ok;

   if ( bw ) {
      label = gtk_object_get_data(GTK_OBJECT(bw->status_bug_meter), "label");
      if (num_err < 2) {
         bug = gtk_object_get_data(GTK_OBJECT(bw->status_bug_meter), "bug");
         ok = gtk_object_get_data(GTK_OBJECT(bw->status_bug_meter), "ok");
         if (num_err == 0) {
            gtk_widget_hide(bug);
            gtk_widget_hide(label);
            gtk_widget_show(ok);
         } else {
            gtk_widget_show(bug);
            gtk_widget_show(label);
            gtk_widget_hide(ok);
         }
         gtk_widget_queue_resize (GTK_WIDGET (bw->status_bug_meter));
      }
      g_snprintf(msg, 64, " %d", num_err);
      gtk_label_set_text(GTK_LABEL(label), msg);
   }
}

/*
 * Called from `destroy' callback in Interface_make_*_dialog
 */
static void Interface_destroy_window(GtkWidget *widget, GtkWidget **window)
{
   gtk_widget_destroy(*window);
   *window = NULL;
}


/*
 * Close and free every single browser_window (called at exit time)
 */
void a_Interface_quit_all(void)
{
   BrowserWindow **bws;
   gint i, n_bw;

   n_bw = num_bw;
   bws = g_malloc(sizeof(BrowserWindow *) * n_bw);

   /* we copy into a new list because destroying the main window can
    * modify the browser_window array. */
   for (i = 0; i < n_bw; i++)
      bws[i] = browser_window[i];

   for (i = 0; i < n_bw; i++)
      gtk_widget_destroy(bws[i]->main_window);

   g_free(bws);
   
   g_free(open_dialog_last_dirname);
   g_free(save_dialog_last_dirname);
}

/*
 * Make a dialog for choosing files (by calling
 * gtk_file_selection_*() calls)
 * This can be used for saving, opening, or whatever,
 * just set the correct callbacks
 */
static void
 Interface_make_choose_file_dialog(GtkWidget **DialogWindow,
                                   char *WmName, char *WmClass, char *WTitle,
                                   GtkSignalFunc B1CallBack, void *B1CbData)
{
   GtkAccelGroup *accel_group;

   *DialogWindow = gtk_file_selection_new(WTitle);
   gtk_window_set_modal(GTK_WINDOW(*DialogWindow), FALSE);
   gtk_window_set_wmclass(GTK_WINDOW(*DialogWindow), WmName, WmClass);

   gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(*DialogWindow));
   gtk_signal_connect(
      GTK_OBJECT(*DialogWindow),
      "destroy", (GtkSignalFunc) Interface_destroy_window, DialogWindow);
   gtk_signal_connect(
      GTK_OBJECT(GTK_FILE_SELECTION(*DialogWindow)->ok_button),
      "clicked", (GtkSignalFunc) B1CallBack, B1CbData);
   gtk_signal_connect(
      GTK_OBJECT(GTK_FILE_SELECTION (*DialogWindow)->cancel_button),
      "clicked", (GtkSignalFunc) Interface_destroy_window, DialogWindow);

   /* Make GDK_Escape close the dialog */
   accel_group = gtk_accel_group_new();
   gtk_window_add_accel_group(GTK_WINDOW(*DialogWindow), accel_group);
   gtk_widget_add_accelerator(
      GTK_FILE_SELECTION(*DialogWindow)->cancel_button, "clicked",
      accel_group, GDK_Escape, 0, GTK_ACCEL_LOCKED);
}

/*
 * Get the file URL from the widget and push it to the browser window.
 */
static void
 Interface_openfile_ok_callback(GtkWidget *widget, BrowserWindow *bw)
{
   char *fn, *Cfn, *s;
   DilloUrl *url;
   GString *UrlStr = g_string_sized_new(1024);

   fn = gtk_file_selection_get_filename(
           GTK_FILE_SELECTION(bw->openfile_dialog_window));

   Cfn = (s = a_Misc_escape_chars(fn, "% ")) ? s : fn;
   g_string_sprintf(UrlStr, "file:%s", Cfn);
   url = a_Url_new(UrlStr->str, NULL, 0, 0, 0);
   a_Nav_push(bw, url);
   a_Url_free(url);
   g_string_free(UrlStr, TRUE);
   g_free(s);

   g_free(open_dialog_last_dirname);
   open_dialog_last_dirname = g_strdup(fn);

   gtk_widget_destroy(bw->openfile_dialog_window);
}

/*
 * Returns a newly allocated string holding a search url generated from
 * a string of keywords (separarated by blanks) and prefs.search_url.
 * Any '"' or '+' in the keywords are escaped.
 */
static gchar *Interface_make_search_url(const gchar *str)
{
   gchar *p, *keys, *new_str;

   keys = g_new(gchar, 3*strlen(str)+1);

   for (p = keys; *str; str++) {
      switch(*str) {
      case ' ':
         *p++ = '+';
         break;
      case '"':
         *p++ = '%';
         *p++ = '2';
         *p++ = '2';
         break;
      case '+':
         *p++ = '%';
         *p++ = '2';
         *p++ = 'B';
         break;
      default:
         *p++ = *str;
      }
   }
   *p = '\0';

   new_str = g_strdup_printf(prefs.search_url, keys);
   g_free(keys);

   return new_str;
}

/*
 * Open an url string.
 * The URL is not sent "as is", illegal chars are ripped out,
 * then it's fully parsed by a_Url_new().
 */
static void Interface_open_url_string(gchar *text, BrowserWindow *bw)
{
   gchar *new_text;
   DilloUrl *url;

   if (text && *text) {
      /* Filter URL string */
      new_text = a_Url_string_strip_delimiters(text);

      url = a_Url_new(new_text, NULL, 0, 0, 0);
      if (url) {
         a_Nav_push(bw, url);
         a_Url_free(url);
      }
      g_free(new_text);
   }

   /* let the rendered area have focus */
   gtk_widget_grab_focus(GTK_BIN(bw->docwin)->child);
}

/*
 * Open an URL specified in the location entry, or in the open URL dialog.
 */
void a_Interface_entry_open_url(GtkWidget *widget, BrowserWindow *bw)
{
   gchar *text;
   GtkEntry *entry;

   /* entry = { bw->location | bw->open_dialog_entry } */
   entry = GTK_ENTRY(widget == bw->location ? widget : bw->open_dialog_entry);
   text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
   DEBUG_MSG(1, "entry_open_url %s\n", text);
   Interface_open_url_string(text, bw);
   g_free(text);

   if (bw->open_dialog_window != NULL)
      gtk_widget_hide(bw->open_dialog_window);
}

/*
 * Create and show the "Open File" dialog
 */
void a_Interface_openfile_dialog(BrowserWindow *bw)
{
   if (!bw->openfile_dialog_window) {
      Interface_make_choose_file_dialog(
         &(bw->openfile_dialog_window),
         "openfile_dialog", "Dillo", "Dillo: Open File",
         (GtkSignalFunc) Interface_openfile_ok_callback, (void *)bw);
   }

   if (open_dialog_last_dirname)
      gtk_file_selection_set_filename(
         GTK_FILE_SELECTION(bw->openfile_dialog_window),
         open_dialog_last_dirname);

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

/*
 * Make a dialog interface with three buttons, a text entry, and an optional
 * check button.
 */
static void
 Interface_make_dialog(GtkWidget **DialogWindow, char *WmName, char *WmClass,
   char *WTitle, GtkWidget **DialogEntry, char *EntryStr, gint VisibleEntry,
   GtkWidget **CheckButton, char *CheckButtonText,
   char *B1Label, GtkSignalFunc B1CallBack, void *B1CbData)
{
   GtkWidget *button, *box1, *box2, *entry;
   GtkAccelGroup *accel_group;

   *DialogWindow = gtk_window_new(GTK_WINDOW_DIALOG);
   gtk_window_set_wmclass(GTK_WINDOW(*DialogWindow), WmName, WmClass);
   gtk_window_set_position(GTK_WINDOW(*DialogWindow), GTK_WIN_POS_CENTER);
   gtk_window_set_title(GTK_WINDOW(*DialogWindow), WTitle);
   gtk_signal_connect(GTK_OBJECT(*DialogWindow), "destroy",
                      (GtkSignalFunc) Interface_destroy_window, DialogWindow);

   /* Create and attach an accel group to the dialog window */
   accel_group = gtk_accel_group_new();
   gtk_window_add_accel_group(GTK_WINDOW(*DialogWindow), accel_group);

   gtk_container_border_width(GTK_CONTAINER(*DialogWindow), 5);

   box1 = gtk_vbox_new(FALSE, 5);
   gtk_container_add(GTK_CONTAINER(*DialogWindow), box1);
   gtk_widget_show(box1);

   entry = gtk_entry_new();
   GTK_WIDGET_SET_FLAGS(entry, GTK_HAS_FOCUS);
   gtk_widget_set_usize(entry, 250, 0);
   gtk_entry_set_text(GTK_ENTRY(entry), EntryStr);
   gtk_box_pack_start(GTK_BOX(box1), entry, FALSE, FALSE, 0);
   *DialogEntry = GTK_WIDGET(entry);
   gtk_entry_set_visibility(GTK_ENTRY(entry), VisibleEntry ? TRUE : FALSE);
   gtk_widget_show(entry);

   if (CheckButton && CheckButtonText) {
      *CheckButton = gtk_check_button_new_with_label(CheckButtonText);
      gtk_box_pack_start(GTK_BOX(box1), *CheckButton, FALSE, FALSE, 0);
      gtk_widget_show(*CheckButton);
   }

   gtk_signal_connect(GTK_OBJECT(entry), "activate", B1CallBack, B1CbData);

   box2 = gtk_hbox_new(TRUE, 5);
   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
   gtk_widget_show(box2);

   button = gtk_button_new_with_label(B1Label);
   gtk_signal_connect(GTK_OBJECT(button), "clicked", B1CallBack, B1CbData);
   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
   gtk_box_pack_start(GTK_BOX(box2), button, FALSE, TRUE, 0);
   gtk_widget_grab_default(button);
   gtk_widget_show(button);
   gtk_signal_connect_object(GTK_OBJECT(entry), "focus_in_event",
                             (GtkSignalFunc) gtk_widget_grab_default,
                             GTK_OBJECT(button));

   button = gtk_button_new_with_label("Clear");
   gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                             (GtkSignalFunc) Interface_entry_clear,
                             GTK_OBJECT(entry));
   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
   gtk_box_pack_start(GTK_BOX(box2), button, FALSE, TRUE, 0);
   gtk_widget_show(button);

   button = gtk_button_new_with_label("Cancel");
   gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                             (GtkSignalFunc) gtk_widget_destroy,
                             GTK_OBJECT(*DialogWindow));
   gtk_widget_add_accelerator(button, "clicked", accel_group,
                              GDK_Escape, 0, GTK_ACCEL_LOCKED);
   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
   gtk_box_pack_start(GTK_BOX(box2), button, FALSE, TRUE, 0);
   gtk_widget_show(button);

   gtk_widget_grab_focus(entry);
}

/*
 * Make a question-dialog with a question, OK and Cancel.
 */
static void Interface_make_question_dialog(
        GtkWidget **DialogWindow, char *WmName, char *WmClass,
        char *WTitle, char *Question,
        GtkSignalFunc OkCallback, void *OkCbData,
        GtkSignalFunc CancelCallback, void *CancelCbData)
{
   GtkWidget *frame, *label, *button, *box1, *box2;

   *DialogWindow = gtk_window_new(GTK_WINDOW_DIALOG);
   gtk_window_set_wmclass(GTK_WINDOW(*DialogWindow), WmName, WmClass);
   gtk_window_set_title(GTK_WINDOW(*DialogWindow), WTitle);
   gtk_window_set_position(GTK_WINDOW(*DialogWindow), GTK_WIN_POS_CENTER);
   gtk_container_border_width(GTK_CONTAINER(*DialogWindow), 10);
   gtk_signal_connect(GTK_OBJECT(*DialogWindow), "destroy",
                      (GtkSignalFunc) Interface_destroy_window, DialogWindow);

   box1 = gtk_vbox_new(FALSE, 5);
   frame = gtk_frame_new(NULL);
   gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
   label = gtk_label_new(Question);
   gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_FILL);
   gtk_misc_set_padding(GTK_MISC(label), 20, 20);
   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);

   box2 = gtk_hbox_new(TRUE, 5);
   button = gtk_button_new_with_label("OK");
   gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                             OkCallback, OkCbData);
   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);
   button = gtk_button_new_with_label("Cancel");
   gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                             CancelCallback, CancelCbData);
   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);
}