webcorebridge.cpp

khtml在gtk上的移植版本

    return QString();
}

void WebCoreBridge::reapplyStylesForDeviceType(WebCoreDeviceType deviceType)
{
    _part->setMediaType(deviceType == WebCoreDeviceScreen ? "screen" : "print");
    DocumentImpl *doc = _part->xmlDocImpl();
    if (doc) {
        static QPaintDevice screen;
        static QPrinter printer;
    	doc->setPaintDevice(deviceType == WebCoreDeviceScreen ? &screen : &printer);
        if (deviceType != WebCoreDeviceScreen) {
            doc->setPrintStyleSheet(styleSheetForPrinting(_part));
        }

    }
    _part->reparseConfiguration();
}

static bool nowPrinting(WebCoreBridge *self)
{
    DocumentImpl *doc = self->part()->xmlDocImpl();
    return doc && doc->paintDevice() && doc->paintDevice()->devType() == QInternal::Printer;
}

// Set or unset the printing mode in the view.  We only toy with this if we're printing.
void WebCoreBridge::_setupRootForPrinting(bool onOrOff)
{
    if (nowPrinting(this)) {
        RenderCanvas *root = static_cast<khtml::RenderCanvas *>(_part->xmlDocImpl()->renderer());
        if (root) {
            root->setPrintingMode(onOrOff);
        }
    }
}

void WebCoreBridge::forceLayoutAdjustingViewSize(bool flag)
{
    _setupRootForPrinting(true);
    _part->forceLayout();
    if (flag) {
	adjustViewSize();
    }
    _setupRootForPrinting(false);
}

void WebCoreBridge::forceLayoutWithMinimumPageWidth(float minPageWidth, float maximumPageWidth, float maxPageWidth, bool flag)
{
    _setupRootForPrinting(true);
    _part->forceLayoutWithPageWidthRange(minPageWidth, maxPageWidth);
    if (flag) {
	adjustViewSize();
    }
    _setupRootForPrinting(false);

}

void WebCoreBridge::sendResizeEvent()
{
    _part->sendResizeEvent();
}

void WebCoreBridge::drawRect(GdkRectangle * _rect, QPainter *p)
{
    QRect rect(_rect);
    _setupRootForPrinting(true);
    _part->paint(p, rect);
    _setupRootForPrinting(false);
}

void WebCoreBridge::drawRect(GdkRectangle * rect, CGContextRef gc)
{
    QPainter painter(nowPrinting(this));
    painter.setContext(gc);
    painter.setUsesInactiveTextBackgroundColor(_part->usesInactiveTextBackgroundColor());
#if 0
    painter.setDrawsFocusRing(_part->showsFirstResponder());
#endif

    drawRect(rect, &painter);
}

#if 0
// Used by pagination code called from AppKit when a standalone web page is printed.
-(NSArray*)computePageRectsWithPrintWidth:(float)printWidth printHeight:(float)printHeight
{
    [self _setupRootForPrinting:YES];
    NSMutableArray* pages = [NSMutableArray arrayWithCapacity:5];
	if (printWidth == 0 || printHeight == 0) {
		return pages;
	}
	
    KHTMLView* view = _part->view();
    NSView* documentView = view->getDocumentView();
    if (!documentView)
        return pages;
	
    float currPageHeight = printHeight;
    float docHeight = NSHeight([documentView bounds]);
    float docWidth = NSWidth([documentView bounds]);
    
    // We need to give the part the opportunity to adjust the page height at each step.
    for (float i = 0; i < docHeight; i += currPageHeight) {
        float proposedBottom = kMin(docHeight, i + printHeight);
        _part->adjustPageHeight(&proposedBottom, i, proposedBottom, i);
        currPageHeight = kMax(1.0f, proposedBottom - i);
        for (float j = 0; j < docWidth; j += printWidth) {
            NSValue* val = [NSValue valueWithRect: NSMakeRect(j, i, printWidth, currPageHeight)];
            [pages addObject: val];
        }
    }
    [self _setupRootForPrinting:NO];
    
    return pages;
}
#endif

// This is to support the case where a webview is embedded in the view that's being printed
void WebCoreBridge::adjustPageHeightNew(float *newBottom,float oldTop, float oldBottom, float bottomLimit)
{
    _setupRootForPrinting(true);
    _part->adjustPageHeight(newBottom, oldTop, oldBottom, bottomLimit);
    _setupRootForPrinting(false);
}

#if 0 // dom api not implemented
- (NSObject *)copyDOMNode:(NodeImpl *)node copier:(id <WebCoreDOMTreeCopier>)copier
{
    NSMutableArray *children = [[NSMutableArray alloc] init];
    for (NodeImpl *child = node->firstChild(); child; child = child->nextSibling()) {
        [children addObject:[self copyDOMNode:child copier:copier]];
    }
    NSObject *copiedNode = [copier nodeWithName:node->nodeName().string().getNSString()
                                          value:node->nodeValue().string().getNSString()
                                         source:node->recursive_toHTML(1).getNSString()
                                       children:children];
    [children release];
    return copiedNode;
}

- (NSObject *)copyDOMTree:(id <WebCoreDOMTreeCopier>)copier
{
    DocumentImpl *doc = _part->xmlDocImpl();
    if (!doc) {
        return nil;
    }
    return [self copyDOMNode:doc copier:copier];
}

- (NSObject *)copyRenderNode:(RenderObject *)node copier:(id <WebCoreRenderTreeCopier>)copier
{
    NSMutableArray *children = [[NSMutableArray alloc] init];
    for (RenderObject *child = node->firstChild(); child; child = child->nextSibling()) {
        [children addObject:[self copyRenderNode:child copier:copier]];
    }
          
    NSString *name = [[NSString alloc] initWithUTF8String:node->renderName()];
    
    RenderPart *nodeRenderPart = dynamic_cast<RenderPart *>(node);
    QWidget *widget = nodeRenderPart ? nodeRenderPart->widget() : 0;
    NSView *view = widget ? widget->getView() : nil;
    
    int nx, ny;
    node->absolutePosition(nx,ny);
    NSObject *copiedNode = [copier nodeWithName:name
                                       position:NSMakePoint(nx,ny)
                                           rect:NSMakeRect(node->xPos(), node->yPos(), node->width(), node->height())
                                           view:view
                                       children:children];
    
    [name release];
    [children release];
    
    return copiedNode;
}

- (NSObject *)copyRenderTree:(id <WebCoreRenderTreeCopier>)copier
{
    RenderObject *renderer = _part->renderer();
    if (!renderer) {
        return nil;
    }
    return [self copyRenderNode:renderer copier:copier];
}

#endif

void WebCoreBridge::removeFromFrame()
{
    LOG(KwiqLog, "this: %x, part:%x", this,part());
    _part->setView(0);
}

void WebCoreBridge::installInFrame(GtkWidget *widget)
{
    // If this isn't the main frame, it must have a render _part set, or it
    // won't ever get installed in the view hierarchy.
    ASSERT(this == mainFrame() || _renderPart != NULL);
    
    _part->view()->setGtkWidget(widget);
    if (_renderPart) {
        _renderPart->setWidget(_part->view());
        // Now the render part owns the view, so we don't any more.
    }

    _part->view()->initScrollBars();
}

void WebCoreBridge::mouseDown(GdkEvent *_event)
{
    QMouseEvent event(QEvent::MouseButtonPress, _event);
    _part->mouseDown(&event);
}
void WebCoreBridge::mouseUp(GdkEvent *_event)
{
    QMouseEvent event(QEvent::MouseButtonRelease, _event);
    _part->mouseUp(&event);
}
void WebCoreBridge::mouseDragged(GdkEventMotion *_event)
{
    QMouseEvent event( _event);
    _part->mouseDragged(&event);
}

void WebCoreBridge::mouseMoved(GdkEventMotion *_event)
{
    QMouseEvent event(_event);
    _part->mouseMoved(&event);
}

#if 0
- (BOOL)sendContextMenuEvent:(NSEvent *)event
{
    return _part->sendContextMenuEvent(event);
}

- (id <WebDOMElement>)elementForView:(NSView *)view
{
    // FIXME: implemented currently for only a subset of the KWQ widgets
    if ([view conformsToProtocol:@protocol(KWQWidgetHolder)]) {
        NSView <KWQWidgetHolder> *widgetHolder = view;
        QWidget *widget = [widgetHolder widget];
        if (widget != nil) {
            NodeImpl *node = static_cast<const RenderWidget *>(widget->eventFilterObject())->element();
            return [WebCoreDOMElement elementWithImpl:static_cast<ElementImpl *>(node)];
        }
    }
    return nil;
}

static NSView *viewForElement(DOM::ElementImpl *elementImpl)
{
    RenderObject *renderer = elementImpl->renderer();
    if (renderer && renderer->isWidget()) {
        QWidget *widget = static_cast<const RenderWidget *>(renderer)->widget();
        if (widget) {
            return widget->getView();
        }
    }
    return nil;
}

static HTMLInputElementImpl *inputElementFromDOMElement(id <WebDOMElement>element)
{
    ASSERT([(NSObject *)element isKindOfClass:[WebCoreDOMElement class]]);
    DOM::ElementImpl *domElement = [(WebCoreDOMElement *)element elementImpl];
    if (domElement && idFromNode(domElement) == ID_INPUT) {
        return static_cast<HTMLInputElementImpl *>(domElement);
    }
    return nil;
}

static HTMLFormElementImpl *formElementFromDOMElement(id <WebDOMElement>element)
{
    ASSERT([(NSObject *)element isKindOfClass:[WebCoreDOMElement class]]);
    DOM::ElementImpl *domElement = [(WebCoreDOMElement *)element elementImpl];
    if (domElement && idFromNode(domElement) == ID_FORM) {
        return static_cast<HTMLFormElementImpl *>(domElement);
    }
    return nil;
}

- (id <WebDOMElement>)elementWithName:(NSString *)name inForm:(id <WebDOMElement>)form
{
    HTMLFormElementImpl *formElement = formElementFromDOMElement(form);
    if (formElement) {
        QPtrList<HTMLGenericFormElementImpl> elements = formElement->formElements;
        QString targetName = QString::fromNSString(name);
        for (unsigned int i = 0; i < elements.count(); i++) {
            HTMLGenericFormElementImpl *elt = elements.at(i);
            // Skip option elements, other duds
            if (elt->name() == targetName) {
                return [WebCoreDOMElement elementWithImpl:elt];
            }
        }
    }
    return nil;
}

- (BOOL)elementDoesAutoComplete:(id <WebDOMElement>)element
{
    HTMLInputElementImpl *inputElement = inputElementFromDOMElement(element);
    return inputElement != nil
        && inputElement->inputType() == HTMLInputElementImpl::TEXT
        && inputElement->autoComplete();
}

- (BOOL)elementIsPassword:(id <WebDOMElement>)element
{
    HTMLInputElementImpl *inputElement = inputElementFromDOMElement(element);
    return inputElement != nil
        && inputElement->inputType() == HTMLInputElementImpl::PASSWORD;
}

- (id <WebDOMElement>)formForElement:(id <WebDOMElement>)element;
{
    HTMLInputElementImpl *inputElement = inputElementFromDOMElement(element);
    if (inputElement) {
        HTMLFormElementImpl *formElement = inputElement->form();
        if (formElement) {
            return [WebCoreDOMElement elementWithImpl:formElement];
        }
    }
    return nil;
}

- (id <WebDOMElement>)currentForm
{
    HTMLFormElementImpl *formElement = _part->currentForm();
    return formElement ? [WebCoreDOMElement elementWithImpl:formElement] : nil;
}

- (NSArray *)controlsInForm:(id <WebDOMElement>)form
{
    NSMutableArray *results = nil;
    HTMLFormElementImpl *formElement = formElementFromDOMElement(form);
    if (formElement) {
        QPtrList<HTMLGenericFormElementImpl> elements = formElement->formElements;
        for (unsigned int i = 0; i < elements.count(); i++) {
            if (elements.at(i)->isEnumeratable()) {		// Skip option elements, other duds
                NSView *view = viewForElement(elements.at(i));
                if (view) {
                    if (!results) {
                        results = [NSMutableArray arrayWithObject:view];
                    } else {
                        [results addObject:view];
                    }
                }
            }
        }
    }
    return results;
}

- (NSString *)searchForLabels:(NSArray *)labels beforeElement:(id <WebDOMElement>)element
{
    ASSERT([(NSObject *)element isKindOfClass:[WebCoreDOMElement class]]);
    return _part->searchForLabelsBeforeElement(labels, [(WebCoreDOMElement *)element elementImpl]);
}

- (NSString *)matchLabels:(NSArray *)labels againstElement:(id <WebDOMElement>)element
{
    ASSERT([(NSObject *)element isKindOfClass:[WebCoreDOMElement class]]);
    return _part->matchLabelsAgainstElement(labels, [(WebCoreDOMElement *)element elementImpl]);
}
#endif

void WebCoreBridge::elementAtPoint(int x, int y, WebCoreElementInfo* element)
{
    QPoint point(x,y);

    RenderObject *renderer = _part->renderer();
    if (!renderer) {
        return;
    }
    RenderObject::NodeInfo nodeInfo(true, true);
    renderer->layer()->nodeAtPoint(nodeInfo, (int)point.x(), (int)point.y());
    
    bool issel = _part->isPointInsideSelection((int)point.x(), (int)point.y())? true : false;
    element->isSelected = issel;
                
    // Find the title in the nearest enclosing DOM node.
    // For <area> tags in image maps, walk the tree for the <area>, not the <img> using it.
    for (NodeImpl *titleNode = nodeInfo.innerNode(); titleNode; titleNode = titleNode->parentNode()) {
        if (titleNode->isElementNode()) {
            const DOM::DOMString title = static_cast<DOM::ElementImpl *>(titleNode)->getAttribute(ATTR_TITLE);
            if (!title.isNull()) {
                // We found a node with a title.
                QString titleText(title.string());
                titleText.replace('\\', _part->backslashAsCurrencySymbol());		
                element->linkTitle = g_strdup(titleText.utf8());
                break;
            }
        }
    }

    NodeImpl *URLNode = nodeInfo.URLElement();
    if (URLNode) {
        DOM::ElementImpl *e = static_cast<DOM::ElementImpl *>(URLNode);
        
        DOM::DOMString title = e->getAttribute(ATTR_TITLE);
        if (!title.isEmpty()) {
            QString titleText(title.string());
            titleText.replace('\\', _part->backslashAsCurrencySymbol());
            element->linkTitle = g_strdup(titleText.utf8());
        }
        
        DOM::DOMString link = e->getAttribute(ATTR_HREF);
        if (!link.isNull()) {
            if (e->firstChild()) {
                DOM::Range r(_part->document());
                r.setStartBefore(e->firstChild());
                r.setEndAfter(e->lastChild());
                QString t(_part->text(r));
                if (!t.isEmpty()) {
                    element->linkLabel = g_strdup(t.utf8());
                } 
            }
            element->linkURL = g_strdup(_part->xmlDocImpl()->completeURL(parseURL(link).string()).utf8());
        }
        
        DOM::DOMString target = e->getAttribute(ATTR_TARGET);
        if (target.isEmpty() && _part->xmlDocImpl()) {
            target = _part->xmlDocImpl()->baseTarget();
        }
        if (!target.isEmpty()) {
            element->linkTarget = g_strdup(target.string().utf8());
        }
    }

    NodeImpl *node = nodeInfo.innerNonSharedNode();
    if (node && node->renderer() && node->renderer()->isImage()) {
        RenderImage *r = static_cast<RenderImage *>(node->renderer());
#if 0
        NSImage *image = r->pixmap().image();
#endif
        // Only return image information if there is an image.
        if (!r->pixmap().isNull() /* && !isDisplayingError(&r->pixmap().image())*/) {
#if 0
            element->qpixmap = r->pixmap();
#endif