interface.c

嵌入式下基于MiniGUI的Web Browser

    if (bw->docwin == HWND_INVALID) {
        fprintf (stderr, "eDillo: Can not create eDillo Control.\n");
        return NULL;
    }

    viewport = a_Dw_viewport_new (bw->docwin);
    bw->viewport = viewport;


    SetWindowBkColor (hwnd_parent, pixel);
    SetFocus (bw->docwin);

    SetWindowAdditionalData2(bw->docwin, (DWORD)bw);

    return bw;
}

/*
 * Set the title of the browser window to start with "Dillo: "
 * prepended to it.
 */
void a_Interface_set_page_title(BrowserWindow *bw, char *title)
{
   GString *buf;

   g_return_if_fail (bw != NULL && title != NULL);

   buf = g_string_new ("");
   g_string_sprintfa (buf, "%s - Feynman eDillo", title);
   SetWindowCaption (bw->main_window, buf->str);
   g_string_free (buf, TRUE);
}

/*
 * Set location entry's text
 */
void a_Interface_set_location_text(BrowserWindow *bw, char *text)
{
    if (bw->hwnd_location != -1)
        SetWindowText((bw->hwnd_location), text);
}

/*
 * Get location entry's text
 */
gchar *a_Interface_get_location_text(BrowserWindow *bw)
{
    int length;
    gchar *str = NULL;

    if (bw->hwnd_location != -1) {
        length = SendMessage(bw->hwnd_location, MSG_GETTEXTLENGTH, 0, 0);  
        str = (char*)g_malloc0 (length + 1);
        GetWindowText (bw->hwnd_location, str, length);
    }

    return str;
}

/*
 * Reset images and text progress bars
 */
void a_Interface_reset_progress_bars(BrowserWindow *bw)
{
    a_Progressbar_update(bw, "", 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 && bw->hwnd_statusbar != -1) {
      va_start(argp, format);
      vsnprintf(msg, 1024, format, argp);
      va_end(argp);
      SetWindowText(bw->hwnd_statusbar, 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)
{
#if 0
   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);
   }
#endif
}

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


/*
 * 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++)
      DestroyMainWindow(bws[i]->main_window);

   g_free(bws);
}

/*
 * 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
 */
#if 0
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);
}
#endif

/*
 * Get the file URL from the widget and push it to the browser window.
 */
#if 0
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);

   gtk_widget_destroy(bw->openfile_dialog_window);
}
#endif

/* 
 * 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;
}

/*
 * Create and show the "Open File" dialog
 */
void a_Interface_openfile_dialog(BrowserWindow *bw)
{
#if 0
   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 (!GTK_WIDGET_VISIBLE(bw->openfile_dialog_window))
      gtk_widget_show(bw->openfile_dialog_window);
   else
      gdk_window_raise(bw->openfile_dialog_window->window);
#endif
}

/*
 * Make a dialog interface with three buttons, a text entry, and an optional
 * check button.
 */
#if 0
static void
 Interface_make_dialog(GtkWidget **DialogWindow, char *WmName, char *WmClass,
   char *WTitle, GtkWidget **DialogEntry, char *EntryStr,
   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_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);
}
#endif

/*
 * Make a question-dialog with a question, OK and Cancel.
 */
#if 0
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);
}
#endif

/*
 * Create and show an [OK|Cancel] question dialog
 */
#if 0
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);
   }
}
#endif

/*
 * Create and show the open URL dialog
 */
#if 0
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), "", 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);
}
#endif

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