gtk-khtml.cc

来自「khtml在gtk上的移植版本」· CC 代码 · 共 1,018 行 · 第 1/2 页

}

void 
gtk_khtml_set_text_multiplier (GtkKHTML* self, gfloat multiplier)
{
    g_return_if_fail (self != NULL);
    g_return_if_fail (GTK_IS_KHTML (self));

    OSB::Root* browser = self->_priv->browser;
    browser->setTextSizeMultiplier(multiplier);
}

gfloat
gtk_khtml_get_text_multiplier (GtkKHTML* self)
{
    g_return_val_if_fail (self != NULL, -1.0);
    g_return_val_if_fail (GTK_IS_KHTML (self), -1.0);

    OSB::Root* browser = self->_priv->browser;
    return browser->textSizeMultiplier();
}

gboolean 
gtk_khtml_find (GtkKHTML* self, const gchar* text, gboolean case_sensitive, gboolean dir_down)
{
    g_return_val_if_fail (self != NULL, FALSE);
    g_return_val_if_fail (GTK_IS_KHTML (self), FALSE);

    return self->_priv->browser->findString(text, case_sensitive, dir_down);
}

const gchar* 
gtk_khtml_get_current_selection_as_text(GtkKHTML* self)
{
    g_return_val_if_fail (self != NULL, NULL);
    g_return_val_if_fail (GTK_IS_KHTML (self), NULL);

    return "";
}

static void 
_gtk_khtml_realize (GtkWidget * widget)
#define PARENT_HANDLER(___widget) \
	{ if(GTK_WIDGET_CLASS(parent_class)->realize) \
		(* GTK_WIDGET_CLASS(parent_class)->realize)(___widget); }
{
	
    
    GdkWindowAttr   attributes;
    gint            attributes_mask;

    g_return_if_fail(widget != NULL);
    
    GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
    
    attributes.window_type = GDK_WINDOW_CHILD;
    attributes.x = widget->allocation.x;
    attributes.y = widget->allocation.y;
    attributes.width = widget->allocation.width;
    attributes.height = widget->allocation.height;
    attributes.wclass = GDK_INPUT_OUTPUT;
    attributes.visual = gtk_widget_get_visual (widget);
    attributes.colormap = gtk_widget_get_colormap (widget);
    attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
    
    attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
    
    widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
				     &attributes, attributes_mask);
    gdk_window_set_user_data (widget->window, widget);
    
    widget->style = gtk_style_attach(widget->style, widget->window);
    
}
#undef PARENT_HANDLER

static void 
_gtk_khtml_map (GtkWidget * widget)
#define PARENT_HANDLER(___widget) \
	{ if(GTK_WIDGET_CLASS(parent_class)->map) \
		(* GTK_WIDGET_CLASS(parent_class)->map)(___widget); }
{
    
    GtkWidget* child;
    g_return_if_fail(widget != NULL);
    g_return_if_fail(GTK_IS_KHTML (widget));
    
    child = GTK_BIN(widget)->child;
    
    GTK_WIDGET_SET_FLAGS(widget, GTK_MAPPED);
    
    //NEEDED? 
    if (GTK_WIDGET_VISIBLE(child))
    {
	if (!GTK_WIDGET_MAPPED (child)){
	    gtk_widget_map(child);
	}
    }
    gdk_window_show(widget->window);
}
#undef PARENT_HANDLER

static gboolean 
_gtk_khtml_expose_event (GtkWidget * widget, GdkEventExpose * event)
#define PARENT_HANDLER(___widget,___event) \
	((GTK_WIDGET_CLASS(parent_class)->expose_event)? \
		(* GTK_WIDGET_CLASS(parent_class)->expose_event)(___widget,___event): \
		((gboolean )0))
{
	
    return PARENT_HANDLER(widget,event);   
}

#undef PARENT_HANDLER

static void 
_gtk_khtml_size_allocate (GtkWidget * widget, GtkAllocation * allocation)
#define PARENT_HANDLER(___widget,___allocation) \
	{ if(GTK_WIDGET_CLASS(parent_class)->size_allocate) \
		(* GTK_WIDGET_CLASS(parent_class)->size_allocate)(___widget,___allocation); }
{
	
    GtkWidget* child;
    g_return_if_fail(widget != NULL);
    g_return_if_fail(GTK_IS_KHTML (widget));
    
    widget->allocation = *allocation;
    
    // NEEDED? Not in Mozilla
    child = GTK_BIN(widget)->child;
    if (child){
	GtkAllocation a;
	GtkRequisition r;
	gtk_widget_size_request(child, &r);
	
	a.x = 0;
	a.y = 0;
	/* a.height = r.height; */
	/* 	a.width = r.width; */
	
	a.width = allocation->width;
	a.height = allocation->height;
	
	gtk_widget_size_allocate(child, &a);
    }
    
    if (GTK_WIDGET_REALIZED(widget))
    {
	gdk_window_move_resize(widget->window,
			       allocation->x, allocation->y,
			       allocation->width, allocation->height);
    }  
}
#undef PARENT_HANDLER

MyRoot::MyRoot(GtkKHTML* agtkkhtml)  
    :listener(this)
    ,gtkkhtml(agtkkhtml)
    ,internal(false)    
{
    setUIDelegate(&listener);
    setFrameLoadDelegate(&listener);
    setResourceLoadDelegate(&listener);
    status = g_new0(GtkKHTMLLoadStatus, 1);
}

MyRoot::~MyRoot()
{
    g_free(status);
}

const GtkKHTMLLoadStatus* MyRoot::myStatus()
{
    return status;
}


const gchar* MyRoot::myLocation()
{
    return mainFrame()->location();
}

const gchar* MyRoot::myTitle()
{
    const gchar* l = listener.title();
    return l;
}

gboolean MyRoot::findString(const gchar* text, gboolean case_sensitive, gboolean dir_down)
{
    return searchFor(text, dir_down, case_sensitive) ? TRUE:FALSE;
}

void MyRoot::internalStatusStart()
{
    if (!internal) return;
    status->status = GTK_KHTML_LOADING_START;
    status->size = 0;
    status->received = 0;
    status->files = 0;
    status->filesWithSize = 0;
    status->ready = 0;
   
    g_signal_emit_by_name(gtkkhtml, "status", status);
}

void MyRoot::internalStatusStop(int statusCode)
{
    if (!internal) return;
    status->status = GTK_KHTML_LOADING_COMPLETE;
    status->statusCode = statusCode;

//    assert(status->ready == status->files);
}

void MyRoot::internalStatusStartItem(const OSB::ResourceStatus * _status)
{
    if (!internal) return;
    status->files++;
    g_signal_emit_by_name(gtkkhtml, "status", status);
}

void MyRoot::internalStatusHeadersItem(const OSB::ResourceStatus * _status)
{
    if (!internal) return;
    if (_status->size()) {
        status->size += _status->size();
        status->totalSize += _status->size(); 
        status->filesWithSize++;
    }
    g_signal_emit_by_name(gtkkhtml, "status", status);
}

void MyRoot::internalStatusProgressItem(const OSB::ResourceStatus * _status)
{
    if (!internal) return;
    status->totalReceived += _status->lastReceived();
    // in case Content-Length -header is not present
    if (!_status->size()) {
        status->totalSize += _status->lastReceived();
    } else {
        status->received += _status->lastReceived();
    }
    g_signal_emit_by_name(gtkkhtml, "status", status);
}

void MyRoot::internalStatusStopItem(const OSB::ResourceStatus * _status)
{
    if (!internal) return;
    
    assert(_status->size() == 0 ||
           _status->error() ||
           _status->size() == _status->received());
    
    status->ready++;
    if (_status->error()) {
        // FIXME: handle errors as well.u
    }

    g_signal_emit_by_name(gtkkhtml, "status", status);
}


MyEventListener::MyEventListener(MyRoot* aroot)
    :root(aroot)
{  
    strSz = 400;
    status = g_new0(gchar, strSz);
    loc = g_new0(gchar, strSz);
    pageTitle = g_new0(gchar, strSz);    
    clearState();
}

MyEventListener::~MyEventListener()
{
    if (status)
	g_free(status);
    if (loc) 
	g_free(loc);
    if (pageTitle)
	g_free(pageTitle);
}

void MyEventListener::clearState()
{
    *status = *loc = *pageTitle = '\0';
}

static gboolean 
_utf8_copy_if_valid_else_set_empty(gchar* dst, const gchar* src, int dstsz)
{
    if (src &&g_utf8_validate(src, -1, NULL)) {
	glong sz = g_utf8_strlen(src, dstsz);
	g_utf8_strncpy(dst, src, sz+1);
	return TRUE;
    } 
    *dst = '\0';
    return FALSE;
}

void MyEventListener::onMouseOverChanged(OSB::Frame* target, OSB::ElementInfo* node)
{ 
    assert(node);
    g_signal_emit_by_name(root->engine(), "mouse-over", 
			  node->linkTitle(), 
			  node->linkLabel(), 
			  node->linkURL(), 
			  node->linkTarget());
}

void MyEventListener::setStatusText(OSB::Frame* target, const gchar* node) 
{ 
    _utf8_copy_if_valid_else_set_empty(status, node, strSz);
    g_signal_emit_by_name(root->engine(), "status", status);
}

void MyEventListener::onTitleChanged(OSB::Frame* frame, const gchar* title) 
{ 
    if (frame == root->mainFrame()) {
	_utf8_copy_if_valid_else_set_empty(pageTitle, title, strSz);
	g_signal_emit_by_name(root->engine(), "title"); 
    }
}

void MyEventListener::onClientRedirectReceived(OSB::Frame* frame,const gchar* to) 
{
    frame = frame;
    to = to;
    /** not used*/
}

void MyEventListener::onServerRedirected(OSB::Frame* frame, const gchar* to) 
{ 
    if (frame == root->mainFrame()) {
	g_signal_emit_by_name(root->engine(), "location"); 
    }
}

void MyEventListener::onCommitLoad(OSB::Frame* frame) 
{
    if (frame == root->mainFrame()) {
	g_signal_emit_by_name(root->engine(), "location"); 
    }
}

#if 0
gint
_convert_status(int status)
{
    /* map OSB status to GtkKHTML status*/
    return (gint) status;
}
#endif

void MyEventListener::onFrameLoadStarted(OSB::Frame* frame) 
{
    if (frame == root->mainFrame()) {
	clearState();
	root->internalStatusStart();
	g_signal_emit_by_name(root->engine(), "load-start");
    }
}

void MyEventListener::onFrameLoadFinished(OSB::Frame* frame, int status) 
{
    if (frame == root->mainFrame()) {
	root->internalStatusStop(status);
	g_signal_emit_by_name(root->engine(), "load-stop");
    } 
}

void MyEventListener::onResourceLoadStarted(OSB::Frame* frame, const OSB::ResourceStatus * status) 
{
    root->internalStatusStartItem(status);
}

void MyEventListener::onResourceLoadHeaders(OSB::Frame* frame, const OSB::ResourceStatus * status) 
{
    root->internalStatusHeadersItem(status);
}

void MyEventListener::onResourceLoadStatus(OSB::Frame* frame, const OSB::ResourceStatus * status) 
{
    root->internalStatusProgressItem(status);
}

void MyEventListener::onResourceLoadFinished(OSB::Frame* frame, const OSB::ResourceStatus * status) 
{
    root->internalStatusStopItem(status);
}

OSB::Root*  MyEventListener::createNewRoot(OSB::Frame* frame, const gchar* url)
{
    GtkKHTML* new_engine =  NULL;
    g_signal_emit_by_name (root->engine(), "req-new-window", url, &new_engine);

    if (!new_engine) 
	return 0;

    OSB::Root*  browser = new_engine->_priv->browser;
    return browser;
}

void MyEventListener::alertPanel(OSB::Frame* frame, const gchar *message) 
{ 
    GtkKHTMLPromptArgs args = {GTK_KHTML_ALERT,0,};
    args.msg = message;

    g_signal_emit_by_name (root->engine(), "req-js-prompt", &args);
    
    return; 
}

bool MyEventListener::confirmPanel(OSB::Frame* frame, const gchar *message) 
{ 
    GtkKHTMLPromptArgs args = {GTK_KHTML_CONFIRM,0,};
    args.msg = message;

    g_signal_emit_by_name (root->engine(), "req-js-prompt", &args);

    return (args.out_ok_pressed == TRUE); 
}

bool MyEventListener::textInputPanel(OSB::Frame* frame, const gchar *prompt, const gchar *defaultText, const gchar **result)
{ 
    GtkKHTMLPromptArgs args = {GTK_KHTML_INPUT, 0,};
    args.msg = prompt;
    
    args.default_input = defaultText;

    g_signal_emit_by_name (root->engine(), "req-js-prompt", &args);
    
    /* clear possible old values */
    if (root->engine()->_priv->js_input_text) { 
	g_free (root->engine()->_priv->js_input_text);
	root->engine()->_priv->js_input_text = NULL;
    }

    /* copy new results
     * GtkKHTMLInputArgs::out_input must be allocated with g_new, and will be owned and released by 
     * us */
    if (args.out_input) 	
	root->engine()->_priv->js_input_text = args.out_input; /* no g_strdup() by api convention*/

    /* propagate results to caller. results will be valid until next call to this method */	
    if (result)
	*result = root->engine()->_priv->js_input_text;

    return (args.out_ok_pressed == TRUE); 

}

bool MyEventListener::authPanel(OSB::Frame* frame, const gchar *realm, const gchar **username, const gchar **password) 
{ 
    GtkKHTMLAuthArgs args = {0,};
    GtkKHTMLPrivate *priv = root->engine()->_priv;
    args.realm = realm;
    /* fixme: do we need to pass default usernames/passwords to browser */
    args.out_username = 0;
    args.out_password = 0;

    g_signal_emit_by_name (root->engine(), "req-auth-prompt", &args);

    /* clear possible old values */
    if (priv->auth_username) {
	g_free(priv->auth_username);
	priv->auth_username = NULL;
    }
    if (priv->auth_password) {
	g_free(priv->auth_password);
	priv->auth_password = NULL;
    }

    /* copy new results. 
     * GtkKHTMLAuthArgs::out_{username,password} must be allocated with g_new, and will be owned by
     * and released by us.*/
    if (args.out_username) 
	priv->auth_username = args.out_username; /* no g_strdup() by api convention*/
    
    if (args.out_password) 
	priv->auth_password = args.out_password; /* no g_strdup() by api convention*/    

    /* propagate results to caller. results will be valid until next call to this method */	
    if (username)
	*username = priv->auth_username;
	
    if (password)
        *password = priv->auth_password;
    
    return (args.out_ok_pressed == TRUE); 
}


const gchar *
gtk_khtml_render_tree (GtkKHTML * self)
{
    g_return_val_if_fail (self != NULL, NULL);
    g_return_val_if_fail (GTK_IS_KHTML (self), NULL);
    
    //    self->_priv->browser->aux().renderTreeString();
    return "";
}

/*
  Local Variables:
  c-basic-offset: 4
  End:
 */