osb-browser.c

khtml在gtk上的移植版本

    return -1;
  }
}


/*private*/
void
osb_browser_set_location_icon(OSBBrowser* self, const gchar* path)
{
  GtkWidget *browser_location_icon =
    glade_xml_get_widget(self->_priv->xml, "browser_location_icon");
    
  GError *gerr = NULL;
 
  GdkPixbuf* default_location_pixbuf =
    gdk_pixbuf_new_from_file(path,
			     &gerr);
    
	
  if (default_location_pixbuf) {
    GtkRequisition req;
    GdkPixbuf *scaled_buf;
    gtk_widget_size_request (browser_location_icon, &req);	
    scaled_buf = gdk_pixbuf_scale_simple (default_location_pixbuf,
				      req.width,
				      req.height,
				      GDK_INTERP_BILINEAR);
    g_object_unref (default_location_pixbuf);
	
    gtk_image_set_from_pixbuf (GTK_IMAGE(browser_location_icon),
			       scaled_buf);
    g_object_unref (scaled_buf);
  } else
    g_warning("couldn't load default location icon from path %s", path);
    
}
/*private*/
GtkKHTML*
osb_browser_get_active_engine (OSBBrowser* self)
{
  int curpage = gtk_notebook_get_current_page (self->_priv->tab);
  GtkKHTML *engine = GTK_KHTML (gtk_notebook_get_nth_page (self->_priv->tab, curpage));

  return engine;
}

/*private*/
void
osb_browser_set_location (OSBBrowser* self, const gchar* location)
{
  GtkEntry *entry;
  if (!location) location = "";
  entry = GTK_ENTRY (glade_xml_get_widget (self->_priv->xml, "location"));
  gtk_entry_set_text (entry, location);
}

/*private*/
void
osb_browser_set_title (OSBBrowser* self, const gchar* title)
{
  gchar *clean_title;
  gchar *win_title;
  int len;
  gchar* lf;
  
  if (!title)
    title = "";

  clean_title = g_strdup(title);
  len = strlen(clean_title);
  lf = NULL;

  while ( (lf = g_strstr_len (clean_title, len, "\n"))) {
    *lf = ' ';
  }
  
  clean_title = g_strstrip(clean_title);
  
  win_title = g_strconcat (clean_title,
			   " - ",
			   osb_browser_config_get_string (self, STRING_BROWSER_NAME),
			   NULL);
  g_free (clean_title);
  
  gtk_window_set_title (GTK_WINDOW (self), win_title);
  g_free (win_title); 
}

/*private*/
void
osb_browser_update_ui(OSBBrowser* self, GtkKHTML* engine)
{
  const gchar *title = gtk_khtml_get_title (engine);
  const gchar *loc = gtk_khtml_get_location (engine);
  
  osb_browser_set_location (self, loc);
  if (title)
    osb_browser_set_title (self, title);
  else
    osb_browser_set_title (self, loc);
  
  gtk_widget_set_sensitive (glade_xml_get_widget (self->_priv->xml, "back"),
			    gtk_khtml_can_go_back (engine));
  
  gtk_widget_set_sensitive (glade_xml_get_widget (self->_priv->xml, "go_back"),
			    gtk_khtml_can_go_back (engine));

  
  gtk_widget_set_sensitive (glade_xml_get_widget (self->_priv->xml, "forward"),
			    gtk_khtml_can_go_forward (engine));
  
  gtk_widget_set_sensitive (glade_xml_get_widget (self->_priv->xml, "go_forward"),
			    gtk_khtml_can_go_forward (engine));
    
}

/* private */
void
osb_browser_update_ui_local(OSBBrowser* self, GtkKHTML *engine)
{
  const gchar *title = gtk_khtml_get_title (engine);
  gchar* lf;  
  int max;
  int len;
  gchar *realtitle;
  GtkLabel* label;
  
  if (!title)
    title = gtk_khtml_get_location (engine);

  if (!title)
    title = _("Untitled");
  
  max =  osb_browser_config_get_int (self, INT_TAB_TITLE_LEN);
  realtitle = g_strndup (title, max);
  realtitle[max] = '\0';
  g_strstrip(realtitle);
  
  len = strlen(realtitle);
   lf = NULL;
  while ( (lf = g_strstr_len (realtitle, len, "\n"))) {
    *lf = ' ';
  }
  
  label = GTK_LABEL (gtk_notebook_get_tab_label (self->_priv->tab, GTK_WIDGET (engine)));
  gtk_label_set_text (label, realtitle);
  g_free (realtitle);
}

static void
on_engine_location(GtkKHTML* engine, gpointer user_data)
{
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML *active = osb_browser_get_active_engine(self);
  if (engine == active) {
    osb_browser_set_location (self, gtk_khtml_get_location (engine));
  }

  osb_browser_update_ui_local(self, engine);  
}

static void
on_engine_title(GtkKHTML* engine, gpointer user_data)
{
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML *active = osb_browser_get_active_engine(self);
  if (engine == active) {
    osb_browser_set_title (self, gtk_khtml_get_title (engine));
  }

  osb_browser_update_ui_local(self, engine);    
}

static void
on_engine_status(GtkKHTML* engine, const GtkKHTMLLoadStatus* status, gpointer user_data)
{  
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML *active = osb_browser_get_active_engine(self);
  if (active == engine) {
    GtkStatusbar *sbar = GTK_STATUSBAR (glade_xml_get_widget (self->_priv->xml, "statusbar"));
    GtkProgressBar *pbar = GTK_PROGRESS_BAR (glade_xml_get_widget (self->_priv->xml, "progressbar"));
    if (sbar){
      const gchar * msg;
      guint cid;
      OSBBrowserGlobal* g = self->_priv->global;
      gchar _msg[400];      
      g_snprintf(_msg, 400, "Received %d of %d bytes, %d/%d files", status->received, status->size, status->ready, status->files);
      osb_browserglobal_set_status(g, _msg);
      msg = osb_browserglobal_get_status(g);
      cid = gtk_statusbar_get_context_id(sbar, "status-text");      
      gtk_statusbar_pop(sbar, cid);
      gtk_statusbar_push(sbar, cid, msg);
    }
    if (pbar && status->size > 0 && status->files > 0) {
      gdouble fraction = 0.0;
      if ( status->filesWithSize < status->files ) {
        gdouble ratio = (gdouble) status->filesWithSize / (gdouble) status->files;      
        fraction += status->received >= status->size ? ratio : ratio * (gdouble) status->received / (gdouble) status->size;
        fraction += status->ready >= status->files ? (1.0 - ratio) : (1.0 - ratio) * (gdouble) (status->ready - status->filesWithSize) / (gdouble) (status->files  - status->filesWithSize);
      } else {
        fraction = (gdouble) status->received / (gdouble) status->size;
      }
      if ( fraction > 1.0 ) {
        fraction = 1.0;
      }
      gtk_progress_bar_set_fraction (pbar, fraction);
    }
  }
  
}

static void
on_engine_mouse_over(GtkKHTML* engine, const gchar* link_title, const gchar* link_label, const gchar* link_url, const gchar* link_target, gpointer user_data)
{
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML *active = osb_browser_get_active_engine(self);
  
  self = self;
  if (active == engine) {
    GtkStatusbar *sbar = GTK_STATUSBAR (glade_xml_get_widget (self->_priv->xml, "statusbar"));
    if (sbar){
      const gchar* msg;
      guint cid;
      cid = gtk_statusbar_get_context_id(sbar, "link-message");      
      gtk_statusbar_pop(sbar, cid);
      msg = link_url;

      if (msg && *msg != '\0')
	gtk_statusbar_push(sbar, cid, msg);
    }
    

  }
}

static void
on_engine_load_start(GtkKHTML* engine, gpointer user_data)
{
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML *active = osb_browser_get_active_engine(self);
  GtkVBox *pbarBox = GTK_VBOX (glade_xml_get_widget (self->_priv->xml, "progressbar_box"));
  GtkProgressBar *pbar = GTK_PROGRESS_BAR (glade_xml_get_widget (self->_priv->xml, "progressbar"));
  gtk_progress_bar_set_fraction (pbar, 0.0);
  gtk_widget_show(GTK_WIDGET(pbarBox));
  
  self = self;
  if (active == engine) {
    /* start animating the icon */
  }
  g_warning("load started");
}

static void
on_engine_load_stop(GtkKHTML* engine, gpointer user_data)
{
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML *active = osb_browser_get_active_engine(self);
  GtkVBox *pbar =  GTK_VBOX (glade_xml_get_widget (self->_priv->xml, "progressbar_box"));
  
  gtk_widget_hide(GTK_WIDGET(pbar));
  
  self = self;
  if (active == engine) {    
    GtkStatusbar *sbar = GTK_STATUSBAR (glade_xml_get_widget (self->_priv->xml, "statusbar"));

    osb_browser_update_ui (self, engine);

    if (sbar) {
      const gchar * msg;
      guint cid;
      OSBBrowserGlobal* g = self->_priv->global;
      osb_browserglobal_set_status(self->_priv->global, "");

      msg = osb_browserglobal_get_status(g);
      cid = gtk_statusbar_get_context_id(sbar, "status-text");      
      gtk_statusbar_pop(sbar, cid);
      gtk_statusbar_push(sbar, cid, msg);
    }    
  }

  osb_browser_update_ui_local (self,engine);
  if (self->_priv->global->renderOnly) {
    osb_browser_print_render_tree(self);
    /* close the ui. */
    gtk_widget_destroy (GTK_WIDGET (self));
  }

  
  
  g_warning("load stopped");  
}

static GtkKHTML*
on_engine_req_new_window(GtkKHTML* engine, const gchar* url, gpointer user_data)
{
  OSBBrowser* new_browser;
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkKHTML* new_engine;
  const gchar* group;
  
  new_browser = OSB_BROWSER (osb_browser_new (self->_priv->global));

  new_engine = osb_browser_get_active_engine (new_browser);
  group = gtk_khtml_get_group(engine);
  gtk_khtml_set_group(GTK_KHTML(new_engine), group);
  
  gtk_khtml_load_url(new_engine, url);
  
  gtk_widget_show (GTK_WIDGET (new_browser)); /* this should actually be off */
  
  
  return new_engine;
}

static void
on_engine_req_js_prompt(GtkKHTML* engine, GtkKHTMLPromptArgs* args, gpointer user_data)
{
  OSBBrowser* self = OSB_BROWSER (user_data);
  GtkDialog* dialog;
  gchar* title;
  gint response;
  
  if (args->type == GTK_KHTML_ALERT){
    dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW (self),
					        GTK_DIALOG_DESTROY_WITH_PARENT,
					        GTK_MESSAGE_WARNING,
					        GTK_BUTTONS_CLOSE,
					        args->msg));
    
    gtk_dialog_set_has_separator(dialog, FALSE);

    title = g_strconcat(_("JavaScript "), _("Alert"), NULL);
    gtk_window_set_title(GTK_WINDOW(dialog), title);    
    g_free(title);
    gtk_dialog_set_default_response (dialog, GTK_RESPONSE_CLOSE);
    response = gtk_dialog_run (dialog);
    gtk_widget_destroy (GTK_WIDGET (dialog));
    /** setup return parameters */
    if (response == GTK_RESPONSE_YES)
      args->out_ok_pressed = TRUE;
    else
      args->out_ok_pressed = FALSE;
  } else if (args->type == GTK_KHTML_CONFIRM) {
    dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW (self),
						GTK_DIALOG_DESTROY_WITH_PARENT,
						GTK_MESSAGE_WARNING,
						GTK_BUTTONS_YES_NO,
						args->msg));
    
    gtk_dialog_set_has_separator(dialog, FALSE);
    
    title = g_strconcat(_("JavaScript "), _("Confirm"), NULL);
    gtk_window_set_title(GTK_WINDOW(dialog), title);    
    g_free(title);
    
    gtk_dialog_set_default_response (dialog, GTK_RESPONSE_NO);
    response = gtk_dialog_run (dialog);
    gtk_widget_destroy (GTK_WIDGET (dialog));
    /** setup return parameters */
    if (response == GTK_RESPONSE_YES)
      args->out_ok_pressed = TRUE;
    else
      args->out_ok_pressed = FALSE;

  } else if (args->type == GTK_KHTML_INPUT) {
    /* no input supported atm,  */   
    dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW (self),
						GTK_DIALOG_DESTROY_WITH_PARENT,
						GTK_MESSAGE_WARNING,
						GTK_BUTTONS_YES_NO,
						args->msg));
    
    gtk_dialog_set_has_separator(dialog, FALSE);
    
    title = g_strconcat(_("JavaScript "), _("Input"), NULL);
    gtk_window_set_title(GTK_WINDOW(dialog), title);    
    g_free(title);
    
    gtk_dialog_set_default_response (dialog, GTK_RESPONSE_NO);
    response = gtk_dialog_run (dialog);
    gtk_widget_destroy(GTK_WIDGET(dialog));
    /** setup return parameters */
    args->out_input = g_strdup("not implemented");
    if (response == GTK_RESPONSE_YES)
      args->out_ok_pressed = TRUE;
    else
      args->out_ok_pressed = FALSE;
    
  } else {
    args->out_ok_pressed = FALSE;
  }

}

static void
on_engine_req_auth_prompt(GtkKHTML* engine, GtkKHTMLAuthArgs* args, gpointer user_data)
{
  OSBBrowser *self = OSB_BROWSER (user_data);
  GtkDialog *dialog;
  GtkEntry *entry;
  gchar *realmText = NULL;
  gint response;

  dialog = GTK_DIALOG (glade_xml_get_widget (self->_priv->xml, "authentication"));

  realmText = g_strdup_printf ("Authentication required for %s", args->realm);
  gtk_label_set_text (GTK_LABEL (glade_xml_get_widget (self->_priv->xml, "auth_label")), realmText);
  gtk_entry_set_text (GTK_ENTRY (glade_xml_get_widget (self->_priv->xml, "username")), "");
  gtk_entry_set_text (GTK_ENTRY (glade_xml_get_widget (self->_priv->xml, "password")), "");
    
  response = gtk_dialog_run (dialog);

  gtk_widget_hide (GTK_WIDGET (dialog));
  
  entry = GTK_ENTRY (glade_xml_get_widget (self->_priv->xml, "username"));
  args->out_username = g_strdup (gtk_entry_get_text (entry));
  entry = GTK_ENTRY (glade_xml_get_widget (self->_priv->xml, "password"));
  args->out_password = g_strdup (gtk_entry_get_text (entry));
  
  switch (response) { 
  case GTK_RESPONSE_OK:
    args->out_ok_pressed = TRUE;
    break;
  case GTK_RESPONSE_CANCEL:
    /* fallthrough */
  case GTK_RESPONSE_NONE:
    /* fallthrough */
  default:
    args->out_ok_pressed = FALSE;
    break;
  }    
}


/*private*/
void
osb_browser_connect_engine_signals(OSBBrowser* self, GtkKHTML *engine)
{
#define CONNECT_WITH_DATA(__o, __s, __h, __d)\
  g_signal_connect (__o, __s, G_CALLBACK( __h), __d);

  
  CONNECT_WITH_DATA (engine, "location", on_engine_location, self);
  CONNECT_WITH_DATA (engine, "title", on_engine_title, self);
  CONNECT_WITH_DATA (engine, "status", on_engine_status, self);
  CONNECT_WITH_DATA (engine, "req-js-prompt", on_engine_req_js_prompt, self);
  CONNECT_WITH_DATA (engine, "req-auth-prompt", on_engine_req_auth_prompt, self);
  CONNECT_WITH_DATA (engine, "req-new-window", on_engine_req_new_window, self);
  CONNECT_WITH_DATA (engine, "load-start", on_engine_load_start, self);
  CONNECT_WITH_DATA (engine, "load-stop", on_engine_load_stop, self);
  CONNECT_WITH_DATA (engine, "mouse-over", on_engine_mouse_over, self);
		    
#undef CONNECT_WITH_DATA  
}

void
osb_browser_print_render_tree(OSBBrowser* self) {
  GtkKHTML *engine = osb_browser_get_active_engine(self);
  const gchar* rt = gtk_khtml_render_tree (engine);
  g_printf("%s\n", rt);
}

gchar *
normalize_filename(const gchar* file)
{
  if (file) {
    const int len = strlen(file);       
    if (len > 0 && file[0] == '/') {
      /* pad url with necessary "file://" */
      gchar * fullName = g_strconcat ("file://", file, NULL);        
      return fullName;
    }
    if (((len > 1 && file[1] == '/') || len == 1) &&
        (file[0] == '.' || file[0] == '~')) {
      switch (file[0]) {
      case '.': /* case current directory */
      {
        gchar * curdir = g_get_current_dir ();       
        gchar * fullName = g_strconcat ("file://", curdir, file+1, NULL);
        g_free (curdir);
        return fullName;
      }
      case '~': /* case home directory */
      {
        gchar* fullName = g_strconcat ("file://", g_get_home_dir(), file+1, NULL);
        return fullName;
      }
      }
    }
  }

  /* I guess it is a valid URL then. */
  return g_strdup(file);
}