bridgeimpl.cpp

khtml在gtk上的移植版本

    }

    closeURL();
    
    if (createRequest(URL, referrer, reload, HttpRequest::GET)) {    
	provisionalLoadStarted();
	emitFrameLoadStarted();
	_activeRequest->execute();
    }
}


void BridgeImpl::postWithURL(const gchar* URL, const gchar *referrer,  const gchar* target, 
			     GByteArray* data, const gchar* contentType, 
			     NSEvent *onLoadEvent, NRCit::DOMElement *form, GHashTable *formValues)
{
    WebCoreBridge *targetBridge = this;
    if (!isEmptyString(target)) targetBridge = findFrameNamed(target);
    
    if (targetBridge && targetBridge != this) {
	targetBridge->postWithURL(URL, referrer, target, data,contentType, onLoadEvent, form, formValues);
	return;
    } 

    if (!targetBridge) {
        // unknown windows should open in new window
	// target will have _blank or some custom name
	if (onLoadEvent) {		    
	    // FIXME: implement: settings -> block popups
	    didNotOpenURL(URL); 
	} else { 
	    mainFrame()->createWindowWithURL(URL, target);
	    return;
	}
    }
    _generatedFrameNameId = 0;

    if (createRequest(URL, referrer, false, HttpRequest::POST)) {
        _activeRequest->setPostData(contentType, data);
	provisionalLoadStarted();
	emitFrameLoadStarted();
	_activeRequest->execute();
    }
}


bool BridgeImpl::createRequest(const gchar* URL,  
                               const gchar* referrer,  
                               const bool reload,
                               const HttpRequest::Type method)
{   
    assignToString(&_requestedURL, URL);

    const gchar *pageURL = URL;
#if 0    
    KURL pageURL(URL);
    pageURL.setRef(QString::null);
#endif

    // the page currently viewed shouldn't be in the cache
    PageCacheEntry* cacheEntry = pageCache.take(pageURL);

    if (reload) {
	_isReloading = true;
	delete cacheEntry;
	cacheEntry = 0;
    }
    
    if (isEmptyString(pageURL) || strcmp(pageURL,"about:blank")==0) {
	createKHTMLViewWithGtkWidget(GTK_WIDGET(frameWidget), 0, 0);
	loadEmptyDocumentSynchronously();
	return false;
    }


    if (cacheEntry) { 
	delete cacheEntry;
	// disabled for the moment
#if 0
	emitFrameLoadStarted();

	clearFrameContents(false);	
	openURL(URL, false /*reload*/, "text/html", "", QDateTime(), cacheEntry);
	emitTitleChanged(cacheEntry->title().utf8());
	delete cacheEntry;
	
	installInFrame(GTK_WIDGET (frameWidget));

	loadURLFinished(false);
	return false;
#endif
    }

    if (_activeRequest)  delete _activeRequest;
    HttpRequestListener* listener = new PageLoadListener(this, pageURL);    
    _activeRequest = HttpFactory().createRequest(listener, credentials(), pageURL, method);

    if (_activeRequest) {
	if (!isEmptyString(referrer))
	    _activeRequest->setReferrer(referrer);
	
	if (reload)
	    _activeRequest->setForceReload(true);

        _activeRequest->setUserAgent(userAgentForURL(URL));
        return true;
    }

    g_printerr("%s could not create request for url: %s\n", __PRETTY_FUNCTION__, URL);
    return false;    
}

WebCoreBridge* BridgeImpl::createWindowWithURL(const gchar* URL, const gchar *name)
{

    BridgeImpl* newbridge = createNewRoot(URL);
    
    if (!newbridge) return 0;
        
    if (strcmp(name, "_blank")!=0 && strcmp(name, "_new")!=0)
	newbridge->setName(name);

    return newbridge;
}

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

const gchar* BridgeImpl::userAgentForURL(const gchar* URL)
{
    // FIXME: this should be dynamic. -- psalmi
    // (includes apple webkit for better compliancy with sites
    //  targetted to Apple Safari).
    return "Mozilla/5.0 (X11; U; Linux i686; en-us) AppleWebKit/146.1 (KHTML, like Gecko) GtkWebCore/0.5.0a";
}

void BridgeImpl::setTitle(const gchar* title)
{
    emitTitleChanged(title);
}

void BridgeImpl::setStatusText(const gchar* status)
{
    emitSetStatusText(status);
}


void BridgeImpl::setIconURL(const gchar* URL)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

void BridgeImpl::setIconURL(const gchar* URL, const gchar* name)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}


WebCoreBridge* BridgeImpl::createChildFrameNamed(const gchar* frameName,
						  const gchar* URL, 
						  KHTMLRenderPart *renderPart,
						  bool allowsScrolling, 
						  int marginWidth, 
						  int marginHeight)
{
    assert(renderPart);

    BridgeImpl* newbridge = createChildFrame();

    newbridge->didSetName(frameName);  // name is aready in name list of the caller. Just set our name
    newbridge->createKHTMLViewWithGtkWidget(GTK_WIDGET (frameWidget), marginWidth, marginHeight);

    newbridge->setRenderPart(renderPart);
    newbridge->installInFrame(GTK_WIDGET (newbridge->frameWidget));

    _childFrames = g_list_append(_childFrames, newbridge);

    if (allowsScrolling == false) {
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (newbridge->frameWidget), 
				       GTK_POLICY_NEVER, 
				       GTK_POLICY_NEVER);
    }

    newbridge->loadURL(URL, referrer(), false, false, frameName, 0, 0, 0);
    return newbridge;
}

bool BridgeImpl::areToolbarsVisible()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);    
    return true;
}
void BridgeImpl::setToolbarsVisible(bool visible)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);    
}
bool BridgeImpl::isStatusBarVisible()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return true;
}

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

bool BridgeImpl::areScrollbarsVisible()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return true;
}

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

#if 0
NSWindow *BridgeImpl::window()
{
}
#endif

void BridgeImpl::setWindowFrame(GdkRectangle* frame)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

void BridgeImpl::windowFrame(GdkRectangle* outFrame)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

void BridgeImpl::setWindowContentRect(GdkRectangle* frame)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}


void BridgeImpl::windowContentRect(GdkRectangle* outRect)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    fillGdkRectangle(outRect, 0, 0, 0, 0);
}

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

bool BridgeImpl::windowIsResizable()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return true;
}

GtkWidget *BridgeImpl::firstResponder()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return 0;
}

void BridgeImpl::makeFirstResponder(GtkWidget *view)
{
    if (!gtk_widget_is_focus(view))
	gtk_widget_grab_focus(view);    
}

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

WebCoreResourceHandle* BridgeImpl::startLoadingResource(WebCoreResourceLoader *loader, 
							const gchar* URL, 
							GHashTable* headers)
{    
    const gchar* realURL = URL;

    ResourceLoadListener* listener = new ResourceLoadListener(this, loader);
    listener->retain(); // fixme: leaks

    HttpRequest *req = HttpFactory().createRequest(listener, credentials(), realURL, HttpRequest::GET);
    req->setUserAgent(userAgentForURL(URL));
    req->execute();


    return listener->handle(req);
}

WebCoreResourceHandle* BridgeImpl::startLoadingResource(WebCoreResourceLoader *loader, 
							const gchar* URL, 
							GHashTable* headers,
							GByteArray* data)
{
    return 0;
}

void BridgeImpl::objectLoadedFromCacheWithURL(const gchar* URL, KWIQResponse* response, unsigned bytes)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

bool BridgeImpl::isReloading()
{
    return _isReloading;
}

void BridgeImpl::reportClientRedirectToURL(const gchar* URL, 
					   double seconds, 
					   GTime date, 
					   bool lockHistory, 
					   bool isJavaScriptFormAction)
{
    emitClientRedirectReceived(URL);
}

void BridgeImpl::reportClientRedirectCancelled(bool cancelWithLoadInProgress)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    emitClientRedirectCancelled("");
}


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

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

GtkWidget* BridgeImpl::nextKeyViewOutsideWebFrameViews()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return 0;
}

GtkWidget* BridgeImpl::previousKeyViewOutsideWebFrameViews()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return 0;
}


bool BridgeImpl::defersLoading()
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return false;
}

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

void BridgeImpl::saveDocumentState(GList* documentState)
{
    freeGListOfStrings(_documentState);
    _documentState = 0;
    GList* iter = documentState;
    while(iter) {
	_documentState = g_list_append(_documentState, g_strdup((gchar*)iter->data));
	iter = g_list_next(iter);
    }
}

GList* BridgeImpl::documentState()
{
    return _documentState;
}

void BridgeImpl::setNeedsReapplyStyles()
{
    _shouldReapplyStyles = true;
}



const gchar* BridgeImpl::requestedURLString()
{
    return _requestedURL;
}


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


bool BridgeImpl::saveDocumentToPageCache(KWIQPageState *documentInfo)
{
    //FIXME: query title from DOM
    pageCache.insertByURL(_currentURL, documentInfo, "");
    return true;
}

int BridgeImpl::getObjectCacheSize()
{
    return 1000;
}

bool BridgeImpl::frameRequiredForMIMEType(const gchar* MIMEType, const gchar* URL)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);    
    return false;
}
	

void BridgeImpl::loadEmptyDocumentSynchronously()
{
    provisionalLoadStarted();
    openURL("about:blank", false, "text/html", "", 0/*timeval*/, 0);
    setEncoding("latin1", true);
    addData(0, 0);
    end();
}

const gchar* BridgeImpl::MIMETypeForPath(const gchar* path)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);    
    return "text/html";
}

void BridgeImpl::handleMouseDragged(NSEvent *event)
{
    g_warning("NotYetImplemented: %s", __PRETTY_FUNCTION__);
}

void BridgeImpl::handleAutoscrollForMouseDragged(NSEvent *event)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
}

bool BridgeImpl::mayStartDragWithMouseDragged(NSEvent *event)
{
    g_warning("NotYetImplemented: %s",__PRETTY_FUNCTION__);
    return false;
}


int BridgeImpl::historyLength()
{
    return history().length();
}

void BridgeImpl::goBackOrForward(int distance)
{
    int to = history().pos() + distance;
    if (to >=0 && to < history().length()) {
	history().setPos(to);
	history().lock();
	const gchar* url = history().current();
	loadURL(url,
		"",		     
		false,  	// reload: NO
		false,          // onLoadEvent: onLoad
		"_self",	// target: nil
		0,		// triggeringEvent: nil
		0,		// form: nil
		0);             // formValues
    }
}

// notice: if we have GtkLayout inside GtkScrollView, the 
// widget == GtkLayout, 
// widget->window == GtkLayout's outer window ("viewport")
// event->window == GtkLayout's inner window (big window, global coords)

gint BridgeImpl::buttonPress(GtkWidget *widget, GdkEventButton *event)
{
    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;
    mouseDown((GdkEvent*)&viewportEvent);
    return TRUE;
}

gint BridgeImpl::buttonRelease(GtkWidget *widget, GdkEventButton *event)
{