bridgeimpl.cpp

khtml在gtk上的移植版本

    GdkEventButton viewportEvent = *event;
    gint x = (gint)event->x, y = (gint)event->y;
    mapToParentWindow(widget->window, event->window, x, y);
    viewportEvent.x = (gdouble)x;
    viewportEvent.y = (gdouble)y;
    mouseUp((GdkEvent*)&viewportEvent);
    return TRUE;
}

gint BridgeImpl::motionNotify(GtkWidget *widget, GdkEventMotion* event)
{
    GdkModifierType state = (GdkModifierType) event->state;
    gint x = (gint) event->x, y = (gint)event->y;

    if (event->is_hint) 
	gdk_window_get_pointer(event->window, &x, &y, &state);

    gint viewportx = x;
    gint viewporty = y;

    // hackish workaround because we want coordinates in viewport coordinates, not layout coordinates 
    GdkEventMotion viewportEvent = *event;
    viewportEvent.state = state;
    mapToParentWindow(widget->window, event->window, viewportx, viewporty);
    viewportEvent.x = (gdouble)viewportx;
    viewportEvent.y = (gdouble)viewporty;
    mouseMoved(&viewportEvent);

    WebCoreElementInfo info;
    memset(&info, 0, sizeof(info));
    elementAtPoint(x, y, &info); 

    emitMouseOverChanged(&info);    

#define FREE_IF_VALID(x) if ((x)) g_free((x));
    FREE_IF_VALID(info.linkTitle);
    FREE_IF_VALID(info.linkLabel);
    FREE_IF_VALID(info.linkURL);
    FREE_IF_VALID(info.linkTarget);
    FREE_IF_VALID(info.imageURL);
    FREE_IF_VALID(info.imageAltText);
#undef FREE_IF_VALID

    return TRUE;
}


gint BridgeImpl::expose(GtkWidget *widget, GdkEventExpose *event)
{
    if (_inexpose) 
	return FALSE;    

    _inexpose = true;

    GdkRectangle exposeRect = event->area;

    if (hasStaticBackground()) {
	GtkAdjustment* ha = gtk_layout_get_hadjustment(GTK_LAYOUT(frameCanvas));
	GtkAdjustment* va = gtk_layout_get_vadjustment(GTK_LAYOUT(frameCanvas));
	GtkAllocation* a = &frameCanvas->allocation;

	fillGdkRectangle(&exposeRect, (int)ha->value, (int)va->value, (int)ha->value + a->width, (int)va->value + a->height);
    }

    if (_shouldReapplyStyles) {
	_shouldReapplyStyles = false;
	reapplyStylesForDeviceType(WebCoreDeviceScreen);
    }

    GdkRegion* paintRegion = gdk_region_rectangle(&exposeRect);    
    gdk_window_begin_paint_region(event->window, paintRegion);

    GdkXftContext gc(this, GTK_LAYOUT(frameCanvas)->bin_window);

    drawRect(&exposeRect, &gc);

    gdk_window_end_paint(event->window);
    gdk_region_destroy(paintRegion);    

    _inexpose = false;
    return TRUE;    
}

extern "C" {
static void _remove_child(GtkWidget* child, gpointer data)
{
    GtkContainer* container = GTK_CONTAINER (data);
    assert(container);
    assert(child); 
    gtk_container_remove(container, child);
#ifdef DEBUG
    g_printerr("removed child %x\n", (int) child);
#endif
}
}

void BridgeImpl::clearFrameContents(bool createView)
{
#ifdef DEBUG
    g_printerr("clear frame contents \n");
#endif
    gtk_container_foreach(GTK_CONTAINER (frameCanvas), _remove_child, GTK_CONTAINER (frameCanvas));
#ifdef DEBUG
    g_printerr("clear frame contents end\n");
#endif
    if (createView)
	createKHTMLViewWithGtkWidget(GTK_WIDGET(frameWidget), 0,0);
}

void BridgeImpl::disconnectFrameContents()
{
    frameCanvas = 0;
}

void BridgeImpl::connectFrameContents()
{
    frameCanvas.connect("expose_event",
			::expose,
			this);
    frameCanvas.connect("motion_notify_event",
			::motion_notify,
			this);

    frameCanvas.connect("button_press_event",
			::button_press,
			this);
    frameCanvas.connect("button_release_event",
			::button_release,
			this);

    frameCanvas.connect("focus",
			::focus,
			this);	
    frameCanvas.connect("focus-in-event",
			::focus_inout_event,
			this);
    frameCanvas.connect("focus-out-event",
		       ::focus_inout_event,
			this);
    frameCanvas.connect("key-press-event",
			::key_press,
			this);
    frameCanvas.connect("key-release-event",
			::key_press,
			this);

    frameCanvas.connect("size_allocate",
			::size_allocate,
			this);

    gtk_widget_hide(GTK_WIDGET (frameWidget));
    gtk_widget_show_all(GTK_WIDGET (frameWidget));
}

void BridgeImpl::setHasBorder(bool hasBorder)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

WebCoreKeyboardUIMode BridgeImpl::keyboardUIMode()
{
    return WebCoreKeyboardUIMode (WebCoreKeyboardAccessFull | WebCoreKeyboardAccessTabsToLinks);
};

void BridgeImpl::didSetName(const gchar* name)
{
    assignToString(&_frameName, name);
    g_warning("%s %s %s", __PRETTY_FUNCTION__, name,_frameName);

}

void BridgeImpl::loadURLFinished(bool hasError)
{  
    delete _activeRequest;
    _activeRequest = 0;

    end();

    _isReloading = false;

    history().unlock();    // unlock the history


    scrollToAnchor(_requestedURL);

}

GtkWidget* BridgeImpl::widgetForPluginWithURL(const gchar* URL,
					      GList* attributesArray,
					      const gchar* baseURLString,
					      const gchar *MIMEType)
{
    
#if 0
    OSB::ContentRepresentationFactory *reprf = closestMatchForMIME(mainFrame()->reprForMIME, MIMEType);

    if (reprf) {
	OSB::ContentRepresentation *repr = reprf->create(MIMEType.latin1());
	return new PluginWidget(reprf, repr);
    }
#endif
    gchar str[100];
    g_snprintf(str, 100, "plugin for mimeType: %s", MIMEType);
    GtkWidget *b = gtk_label_new(str);

    return b;
}

#if 0
const gchar* BridgeImpl::renderTreeString()
{
    return _renderTree_u8 = renderTreeAsExternalRepresentation();
}
#endif

void BridgeImpl::print()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

void BridgeImpl::issueCutCommand()
{
   g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
   assert(0);
}

void BridgeImpl::issueCopyCommand()
{
   g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
   assert(0);
}
void BridgeImpl::issuePasteCommand()
{ 
   g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
   assert(0);
}

void BridgeImpl::respondToChangedSelection()
{
    emitSelectionChanged();
}

void BridgeImpl::respondToChangedContents()
{
   g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}



/** other methods */


GtkWidget* BridgeImpl::widget()
{
    return GTK_WIDGET(frameWidget);
}

void BridgeImpl::saveHistoryItem()
{
  if (!isReloading()) {
    VisitedURLHistory::sharedProvider()->insertVisitedURL(requestedURLString());
    history().pushNew(requestedURLString());
  }
}

SimpleHistory& BridgeImpl::history()
{
    return _history;
}

void BridgeImpl::setFrameName(const gchar* frameName)
{
    
}


const gchar* BridgeImpl::overrideMediaType()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return "";
}
void  BridgeImpl::windowObjectCleared()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

bool BridgeImpl::canGoBack()
{
    return history().pos()>0;
}

bool BridgeImpl::canGoForward()
{
    return history().pos() < (history().length()-1);
}

void BridgeImpl::goForward()
{
    if (canGoForward()) history().next();
    const gchar* url = history().current();
    history().lock();
    loadURL(url,
	    "",			// referer:
	    false,		// reload: 
	    false,		// onLoadEvent: 
	    "_self",		// target:
	    0,		        // triggeringEvent: 
	    0,			// form: 
	    0);			// formValues:
}

void BridgeImpl::goBack()
{
    if (canGoBack()) history().prev();
    const gchar* url = history().current();
    history().lock();

    loadURL(url,
	    "",			// referer
	    false,		// reload:
	    false,		// onLoadEvent:
	    "_self",		// target: 
	    0,		        // triggeringEvent: 
	    0,			// form: 
	    0);			// formValues:
}

void BridgeImpl::addContentRepresentation(OSB::ContentRepresentationFactory* reprf, const char* mimeType)
{
    
}

void BridgeImpl::regionExpiresAt(GTimeVal* moment, GdkRectangle* rect, CGContext* caller)
{
    // use this for animations
}

void BridgeImpl::redirection(const gchar* url)
{
    assignToString(&_currentURL, url);
    emitServerRedirected(_currentURL);
}

void BridgeImpl::changeSettingsDescendingToChildren(WebCoreSettings* s)
{
    assert(s);
    initializeSettings(s);
    GList* iter = g_list_first(_childFrames);
    BridgeImpl* child;
    while (iter) {
	child = static_cast<BridgeImpl*>(iter->data);
	assert(child);	
	child->initializeSettings(s);
	iter= g_list_next(iter);
    }
}

GList* BridgeImpl::childFrames()
{
    return _childFrames;
}

extern "C" {
static void
size_allocate( GtkWidget *widget, GtkAllocation *allocation, gpointer data)
{
#if DEBUG
    g_printerr("%s widget:%x, data:%x new_dim:(%d,%d;%d,%d)\n", 
	       __PRETTY_FUNCTION__, 
	       (int)widget,
	       (int)data,
	       allocation->x, allocation->y, allocation->width, allocation->height);

#endif

    BridgeImpl* self = static_cast<BridgeImpl*>(data);
    assert(self);

    self->sizeAllocate(widget, allocation);
}

static int
expose(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
#if DEBUG
    g_printerr("%s widget:%x event:%x, data:%x (window %x, x:%d,y:%d,w:%d,h:%d)\n",
	   __PRETTY_FUNCTION__, 
	       (int)widget,
	       (int)event,
	       (int)data,
	       (int)event->window,
	       event->area.x,
	       event->area.y,
	       event->area.width,
	       event->area.height);    
#endif

    BridgeImpl *bridge = static_cast<BridgeImpl*>(data);
    return bridge->expose(widget, event);
}



static gint 
motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
    BridgeImpl *self = static_cast<BridgeImpl*>(data);
    return self->motionNotify(widget, event);
}

static gint
button_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    BridgeImpl *self = static_cast<BridgeImpl*>(data);
    return self->buttonPress(widget, event);
}

static gint
button_release(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    BridgeImpl *self = static_cast<BridgeImpl*>(data);
    return self->buttonRelease(widget, event);
}

static gboolean
focus(GtkWidget *widget, GtkDirectionType dir, gpointer data)
{
#if DEBUG
    g_printerr("%s: widget:%x dir:%x data:%x \n",
	       __PRETTY_FUNCTION__,
	       (int)widget,
	       (int)dir,
	       (int)data);
#endif
    return FALSE;
}

static  gboolean
focus_inout_event(GtkWidget *widget, GdkEventFocus *event, gpointer data)
{
#if DEBUG
    g_printerr("%s: widget:%x event:%x data:%x \n",
	   __PRETTY_FUNCTION__,
	       (int)widget,
	       (int)event,
	       (int)data);
#endif
    
    return FALSE;
}

static gboolean
key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
#if DEBUG
    g_printerr("%s: widget %x, data:%x, event->keyval %d",
	       __PRETTY_FUNCTION__, 
	       (int)widget, 
	       (int)data, 
	       (int)event->keyval);
#endif

    return FALSE;
}

}

static 
void mapToParentWindow(GdkWindow* parent, GdkWindow* child, int&x, int&y)
{
    int nx, ny;
    while (child != parent) {
	gdk_window_get_position (child, &nx, &ny);
	x += nx;
	y += ny;
	child = gdk_window_get_parent (child);
	assert(child);
    }    
}


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