WebCore/khtml/rendering/render_replaced.cpp

   1 /**
   2  * This file is part of the HTML widget for KDE.
   3  *
   4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   5  * Copyright (C) 2000 Dirk Mueller (mueller@kde.org)
   6  * Copyright (C) 2004 Apple Computer, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  *
  23  */
  24 #include "render_replaced.h"
  25
  26 #include "render_arena.h"
  27 #include "render_canvas.h"
  28 #include "render_line.h"
  29
  30 #include <assert.h>
  31 #include <qwidget.h>
  32 #include <qpainter.h>
  33 #include <qevent.h>
  34 #include <qapplication.h>
  35
  36 #include "khtml_ext.h"
  37 #include "khtmlview.h"
  38 #include "xml/dom2_eventsimpl.h"
  39 #include "khtml_part.h"
  40 #include "xml/dom_docimpl.h" // ### remove dependency
  41 #include "xml/dom_position.h"
  42 #include <kdebug.h>
  43
  44 using namespace khtml;
  45 using namespace DOM;
  46
  47
  48 RenderReplaced::RenderReplaced(DOM::NodeImpl* node)
  49     : RenderBox(node)
  50 {
  51     // init RenderObject attributes
  52     setReplaced(true);
  53
  54     m_intrinsicWidth = 300;
  55     m_intrinsicHeight = 150;
  56     m_selectionState = SelectionNone;
  57 }
  58
  59 bool RenderReplaced::shouldPaint(PaintInfo& i, int& _tx, int& _ty)
  60 {
  61     if (i.phase != PaintActionForeground && i.phase != PaintActionOutline && i.phase != PaintActionSelection)
  62         return false;
  63
  64     if (!shouldPaintWithinRoot(i))
  65         return false;
  66
  67     // if we're invisible or haven't received a layout yet, then just bail.
  68     if (style()->visibility() != VISIBLE || m_y <=  -500000)  return false;
  69
  70     int tx = _tx + m_x;
  71     int ty = _ty + m_y;
  72
  73     // Early exit if the element touches the edges.
  74     int top = ty;
  75     int bottom = ty + m_height;
  76     if (m_selectionState != SelectionNone && m_inlineBoxWrapper) {
  77         int selTop = _ty + m_inlineBoxWrapper->root()->selectionTop();
  78         int selBottom = _ty + selTop + m_inlineBoxWrapper->root()->selectionHeight();
  79         top = kMin(selTop, top);
  80         bottom = kMax(selBottom, bottom);
  81     }
  82
  83     int os = 2*maximalOutlineSize(i.phase);
  84     if ((tx >= i.r.x() + i.r.width() + os) || (tx + m_width <= i.r.x() - os))
  85         return false;
  86     if ((top >= i.r.y() + i.r.height() + os) || (bottom <= i.r.y() - os))
  87         return false;
  88
  89     return true;
  90 }
  91
  92 void RenderReplaced::calcMinMaxWidth()
  93 {
  94     KHTMLAssert( !minMaxKnown());
  95
  96 #ifdef DEBUG_LAYOUT
  97     kdDebug( 6040 ) << "RenderReplaced::calcMinMaxWidth() known=" << minMaxKnown() << endl;
  98 #endif
  99
 100     int width = calcReplacedWidth() + paddingLeft() + paddingRight() + borderLeft() + borderRight();
 101     if (style()->width().isPercent() || (style()->width().isVariable() && style()->height().isPercent())) {
 102         m_minWidth = 0;
 103         m_maxWidth = width;
 104     }
 105     else
 106         m_minWidth = m_maxWidth = width;
 107
 108     setMinMaxKnown();
 109 }
 110
 111 short RenderReplaced::lineHeight( bool, bool ) const
 112 {
 113     return height()+marginTop()+marginBottom();
 114 }
 115
 116 short RenderReplaced::baselinePosition( bool, bool ) const
 117 {
 118     return height()+marginTop()+marginBottom();
 119 }
 120
 121 long RenderReplaced::caretMinOffset() const
 122 {
 123     return 0;
 124 }
 125
 126 // Returns 1 since a replaced element can have the caret positioned
 127 // at its beginning (0), or at its end (1).
 128 long RenderReplaced::caretMaxOffset() const
 129 {
 130     return 1;
 131 }
 132
 133 unsigned long RenderReplaced::caretMaxRenderedOffset() const
 134 {
 135     return 1;
 136 }
 137
 138 VisiblePosition RenderReplaced::positionForCoordinates(int _x, int _y)
 139 {
 140     InlineBox *box = inlineBoxWrapper();
 141     if (!box)
 142         return VisiblePosition(element(), 0, DOWNSTREAM);
 143
 144     RootInlineBox *root = box->root();
 145
 146     int absx, absy;
 147     containingBlock()->absolutePosition(absx, absy);
 148
 149     int top = absy + root->topOverflow();
 150     int bottom = root->nextRootBox() ? absy + root->nextRootBox()->topOverflow() : absy + root->bottomOverflow();
 151
 152     if (_y < top)
 153         return VisiblePosition(element(), caretMinOffset(), DOWNSTREAM); // coordinates are above
 154
 155     if (_y >= bottom)
 156         return VisiblePosition(element(), caretMaxOffset(), DOWNSTREAM); // coordinates are below
 157
 158     if (element()) {
 159         if (_x <= absx + xPos() + (width() / 2))
 160             return VisiblePosition(element(), 0, DOWNSTREAM);
 161
 162         return VisiblePosition(element(), 1, DOWNSTREAM);
 163     }
 164
 165     return RenderBox::positionForCoordinates(_x, _y);
 166 }
 167
 168 QRect RenderReplaced::selectionRect()
 169 {
 170     if (selectionState() == SelectionNone)
 171         return QRect();
 172     if (!m_inlineBoxWrapper)
 173         // We're a block-level replaced element.  Just return our own dimensions.
 174         return absoluteBoundingBoxRect();
 175
 176     RenderBlock* cb =  containingBlock();
 177     if (!cb)
 178         return QRect();
 179
 180     RootInlineBox* root = m_inlineBoxWrapper->root();
 181     int selectionTop = root->selectionTop();
 182     int selectionHeight = root->selectionHeight();
 183     int selectionLeft = xPos();
 184     int selectionRight = xPos() + width();
 185
 186     int absx, absy;
 187     cb->absolutePosition(absx, absy);
 188
 189     return QRect(selectionLeft + absx, selectionTop + absy, selectionRight - selectionLeft, selectionHeight);
 190 }
 191
 192 void RenderReplaced::setSelectionState(SelectionState s)
 193 {
 194     m_selectionState = s;
 195     if (m_inlineBoxWrapper) {
 196         RootInlineBox* line = m_inlineBoxWrapper->root();
 197         if (line)
 198             line->setHasSelectedChildren(s != SelectionNone);
 199     }
 200
 201     containingBlock()->setSelectionState(s);
 202 }
 203
 204
 205 QColor RenderReplaced::selectionColor(QPainter *p) const
 206 {
 207     QColor color = RenderBox::selectionColor(p);
 208
 209     // Force a 60% alpha so that no user-specified selection color can obscure selected images.
 210     if (qAlpha(color.rgb()) > 153)
 211         color = QColor(qRgba(color.red(), color.green(), color.blue(), 153));
 212
 213     return color;
 214 }
 215
 216 // -----------------------------------------------------------------------------
 217
 218 RenderWidget::RenderWidget(DOM::NodeImpl* node)
 219       : RenderReplaced(node),
 220         m_deleteWidget(false)
 221 {
 222     m_widget = 0;
 223     // a replaced element doesn't support being anonymous
 224     assert(node);
 225     m_view = node->getDocument()->view();
 226
 227     // this is no real reference counting, its just there
 228     // to make sure that we're not deleted while we're recursed
 229     // in an eventFilter of the widget
 230     ref();
 231 }
 232
 233 void RenderWidget::detach()
 234 {
 235     remove();
 236
 237     if ( m_widget ) {
 238         if ( m_view )
 239             m_view->removeChild( m_widget );
 240
 241         m_widget->removeEventFilter( this );
 242         m_widget->setMouseTracking( false );
 243     }
 244
 245     RenderArena* arena = renderArena();
 246     if (m_inlineBoxWrapper) {
 247         if (!documentBeingDestroyed())
 248             m_inlineBoxWrapper->remove();
 249         m_inlineBoxWrapper->detach(arena);
 250         m_inlineBoxWrapper = 0;
 251     }
 252     setNode(0);
 253     deref(arena);
 254 }
 255
 256 RenderWidget::~RenderWidget()
 257 {
 258     KHTMLAssert( refCount() <= 0 );
 259
 260     if (m_deleteWidget) {
 261         delete m_widget;
 262     }
 263 }
 264
 265 void  RenderWidget::resizeWidget( QWidget *widget, int w, int h )
 266 {
 267 #if !APPLE_CHANGES
 268     // ugly hack to limit the maximum size of the widget (as X11 has problems if it's bigger)
 269     h = kMin( h, 3072 );
 270     w = kMin( w, 2000 );
 271 #endif
 272
 273     if (element() && (widget->width() != w || widget->height() != h)) {
 274         RenderArena *arena = ref();
 275         element()->ref();
 276         widget->resize( w, h );
 277         element()->deref();
 278         deref(arena);
 279     }
 280 }
 281
 282 void RenderWidget::setQWidget(QWidget *widget, bool deleteWidget)
 283 {
 284     if (widget != m_widget)
 285     {
 286         if (m_widget) {
 287             m_widget->removeEventFilter(this);
 288             disconnect( m_widget, SIGNAL( destroyed()), this, SLOT( slotWidgetDestructed()));
 289             if (m_deleteWidget) {
 290                 delete m_widget;
 291             }
 292             m_widget = 0;
 293         }
 294         m_widget = widget;
 295         if (m_widget) {
 296             connect( m_widget, SIGNAL( destroyed()), this, SLOT( slotWidgetDestructed()));
 297             m_widget->installEventFilter(this);
 298             // if we've already received a layout, apply the calculated space to the
 299             // widget immediately, but we have to have really been full constructed (with a non-null
 300             // style pointer).
 301             if (!needsLayout() && style()) {
 302                 resizeWidget( m_widget,
 303                               m_width-borderLeft()-borderRight()-paddingLeft()-paddingRight(),
 304                               m_height-borderLeft()-borderRight()-paddingLeft()-paddingRight() );
 305             }
 306             else
 307                 setPos(xPos(), -500000);
 308
 309 #if APPLE_CHANGES
 310             if (style()) {
 311                 if (style()->visibility() != VISIBLE)
 312                     m_widget->hide();
 313                 else
 314                     m_widget->show();
 315             }
 316 #endif
 317         }
 318         m_view->addChild( m_widget, -500000, 0 );
 319     }
 320     m_deleteWidget = deleteWidget;
 321 }
 322
 323 void RenderWidget::layout( )
 324 {
 325     KHTMLAssert( needsLayout() );
 326     KHTMLAssert( minMaxKnown() );
 327 #if !APPLE_CHANGES
 328     if ( m_widget ) {
 329         resizeWidget( m_widget,
 330                       m_width-borderLeft()-borderRight()-paddingLeft()-paddingRight(),
 331                       m_height-borderLeft()-borderRight()-paddingLeft()-paddingRight() );
 332     }
 333 #endif
 334
 335     setNeedsLayout(false);
 336 }
 337
 338 #if APPLE_CHANGES
 339 void RenderWidget::sendConsumedMouseUp(const QPoint &mousePos, int button, int state)
 340 {
 341     RenderArena *arena = ref();
 342     QMouseEvent e( QEvent::MouseButtonRelease, mousePos, button, state);
 343
 344     element()->dispatchMouseEvent(&e, EventImpl::MOUSEUP_EVENT, 0);
 345     deref(arena);
 346 }
 347 #endif
 348
 349 void RenderWidget::slotWidgetDestructed()
 350 {
 351     m_widget = 0;
 352 }
 353
 354 void RenderWidget::setStyle(RenderStyle *_style)
 355 {
 356     RenderReplaced::setStyle(_style);
 357     if (m_widget)
 358     {
 359         m_widget->setFont(style()->font());
 360         if (style()->visibility() != VISIBLE)
 361             m_widget->hide();
 362 #if APPLE_CHANGES
 363         else
 364             m_widget->show();
 365 #endif
 366     }
 367 }
 368
 369 void RenderWidget::paint(PaintInfo& i, int _tx, int _ty)
 370 {
 371     if (!shouldPaint(i, _tx, _ty)) return;
 372
 373     _tx += m_x;
 374     _ty += m_y;
 375
 376     if (shouldPaintBackgroundOrBorder() && i.phase != PaintActionOutline)
 377         paintBoxDecorations(i, _tx, _ty);
 378
 379 #if APPLE_CHANGES
 380     if (!m_widget || !m_view || i.phase != PaintActionForeground ||
 381         style()->visibility() != VISIBLE)
 382         return;
 383
 384     // Move the widget if necessary.  We normally move and resize widgets during layout, but sometimes
 385     // widgets can move without layout occurring (most notably when you scroll a document that
 386     // contains fixed positioned elements).
 387     int newX = _tx + borderLeft() + paddingLeft();
 388     int newY = _ty + borderTop() + paddingTop();
 389     if (m_view->childX(m_widget) != newX || m_view->childY(m_widget) != newY)
 390         m_widget->move(newX, newY);
 391
 392     // Tell the widget to paint now.  This is the only time the widget is allowed
 393     // to paint itself.  That way it will composite properly with z-indexed layers.
 394     m_widget->paint(i.p, i.r);
 395
 396     // Paint a partially transparent wash over selected widgets.
 397     if (m_selectionState != SelectionNone) {
 398         QBrush brush(selectionColor(i.p));
 399         QRect selRect(selectionRect());
 400         i.p->fillRect(selRect.x(), selRect.y(), selRect.width(), selRect.height(), brush);
 401     }
 402
 403 #else
 404     if (!m_widget || !m_view || i.phase != PaintActionForeground)
 405         return;
 406
 407     if (style()->visibility() != VISIBLE) {
 408         m_widget->hide();
 409         return;
 410     }
 411
 412     int xPos = _tx+borderLeft()+paddingLeft();
 413     int yPos = _ty+borderTop()+paddingTop();
 414
 415     int childw = m_widget->width();
 416     int childh = m_widget->height();
 417     if ( (childw == 2000 || childh == 3072) && m_widget->inherits( "KHTMLView" ) ) {
 418         KHTMLView *vw = static_cast<KHTMLView *>(m_widget);
 419         int cy = m_view->contentsY();
 420         int ch = m_view->visibleHeight();
 421
 422
 423         int childx = m_view->childX( m_widget );
 424         int childy = m_view->childY( m_widget );
 425
 426         int xNew = xPos;
 427         int yNew = childy;
 428
 429         //      qDebug("cy=%d, ch=%d, childy=%d, childh=%d", cy, ch, childy, childh );
 430         if ( childh == 3072 ) {
 431             if ( cy + ch > childy + childh ) {
 432                 yNew = cy + ( ch - childh )/2;
 433             } else if ( cy < childy ) {
 434                 yNew = cy + ( ch - childh )/2;
 435             }
 436 //          qDebug("calculated yNew=%d", yNew);
 437         }
 438         yNew = kMin( yNew, yPos + m_height - childh );
 439         yNew = kMax( yNew, yPos );
 440         if ( yNew != childy || xNew != childx ) {
 441             if ( vw->contentsHeight() < yNew - yPos + childh )
 442                 vw->resizeContents( vw->contentsWidth(), yNew - yPos + childh );
 443             vw->setContentsPos( xNew - xPos, yNew - yPos );
 444         }
 445         xPos = xNew;
 446         yPos = yNew;
 447     }
 448
 449     m_view->addChild(m_widget, xPos, yPos );
 450     m_widget->show();
 451 #endif
 452 }
 453
 454 void RenderWidget::handleFocusOut()
 455 {
 456 }
 457
 458 bool RenderWidget::eventFilter(QObject* /*o*/, QEvent* e)
 459 {
 460     if ( !element() ) return true;
 461
 462     RenderArena *arena = ref();
 463     DOM::NodeImpl *elem = element();
 464     elem->ref();
 465
 466     bool filtered = false;
 467
 468     //kdDebug() << "RenderWidget::eventFilter type=" << e->type() << endl;
 469     switch(e->type()) {
 470     case QEvent::FocusOut:
 471        //static const char* const r[] = {"Mouse", "Tab", "Backtab", "ActiveWindow", "Popup", "Shortcut", "Other" };
 472         //kdDebug() << "RenderFormElement::eventFilter FocusOut widget=" << m_widget << " reason:" << r[QFocusEvent::reason()] << endl;
 473         // Don't count popup as a valid reason for losing the focus
 474         // (example: opening the options of a select combobox shouldn't emit onblur)
 475         if ( QFocusEvent::reason() != QFocusEvent::Popup )
 476        {
 477            //kdDebug(6000) << "RenderWidget::eventFilter captures FocusOut" << endl;
 478             if (elem->getDocument()->focusNode() == elem)
 479                 elem->getDocument()->setFocusNode(0);
 480 //             if (  elem->isEditable() ) {
 481 //                 KHTMLPartBrowserExtension *ext = static_cast<KHTMLPartBrowserExtension *>( elem->view->part()->browserExtension() );
 482 //                 if ( ext )  ext->editableWidgetBlurred( m_widget );
 483 //             }
 484             handleFocusOut();
 485         }
 486         break;
 487     case QEvent::FocusIn:
 488         //kdDebug(6000) << "RenderWidget::eventFilter captures FocusIn" << endl;
 489         elem->getDocument()->setFocusNode(elem);
 490 //         if ( isEditable() ) {
 491 //             KHTMLPartBrowserExtension *ext = static_cast<KHTMLPartBrowserExtension *>( elem->view->part()->browserExtension() );
 492 //             if ( ext )  ext->editableWidgetFocused( m_widget );
 493 //         }
 494         break;
 495     case QEvent::MouseButtonPress:
 496 //       handleMousePressed(static_cast<QMouseEvent*>(e));
 497         break;
 498     case QEvent::MouseButtonRelease:
 499 //    {
 500 //         int absX, absY;
 501 //         absolutePosition(absX,absY);
 502 //         QMouseEvent* _e = static_cast<QMouseEvent*>(e);
 503 //         m_button = _e->button();
 504 //         m_state  = _e->state();
 505 //         QMouseEvent e2(e->type(),QPoint(absX,absY)+_e->pos(),_e->button(),_e->state());
 506
 507 //         elem->dispatchMouseEvent(&e2,EventImpl::MOUSEUP_EVENT,m_clickCount);
 508
 509 //         if((m_mousePos - e2.pos()).manhattanLength() <= QApplication::startDragDistance()) {
 510 //             // DOM2 Events section 1.6.2 says that a click is if the mouse was pressed
 511 //             // and released in the "same screen location"
 512 //             // As people usually can't click on the same pixel, we're a bit tolerant here
 513 //             elem->dispatchMouseEvent(&e2,EventImpl::CLICK_EVENT,m_clickCount);
 514 //         }
 515
 516 //         if(!isRenderButton()) {
 517 //             // ### DOMActivate is also dispatched for thigs like selects & textareas -
 518 //             // not sure if this is correct
 519 //             elem->dispatchUIEvent(EventImpl::DOMACTIVATE_EVENT,m_isDoubleClick ? 2 : 1);
 520 //             elem->dispatchMouseEvent(&e2, m_isDoubleClick ? EventImpl::KHTML_DBLCLICK_EVENT : EventImpl::KHTML_CLICK_EVENT, m_clickCount);
 521 //             m_isDoubleClick = false;
 522 //         }
 523 //         else
 524 //             // save position for slotClicked - see below -
 525 //             m_mousePos = e2.pos();
 526 //     }
 527     break;
 528     case QEvent::MouseButtonDblClick:
 529 //     {
 530 //         m_isDoubleClick = true;
 531 //         handleMousePressed(static_cast<QMouseEvent*>(e));
 532 //     }
 533     break;
 534     case QEvent::MouseMove:
 535 //     {
 536 //         int absX, absY;
 537 //         absolutePosition(absX,absY);
 538 //         QMouseEvent* _e = static_cast<QMouseEvent*>(e);
 539 //         QMouseEvent e2(e->type(),QPoint(absX,absY)+_e->pos(),_e->button(),_e->state());
 540 //         elem->dispatchMouseEvent(&e2);
 541 //         // ### change cursor like in KHTMLView?
 542 //     }
 543     break;
 544     case QEvent::KeyPress:
 545     case QEvent::KeyRelease:
 546     {
 547         if (!elem->dispatchKeyEvent(static_cast<QKeyEvent*>(e)))
 548             filtered = true;
 549         break;
 550     }
 551     default: break;
 552     };
 553
 554     elem->deref();
 555
 556     // stop processing if the widget gets deleted, but continue in all other cases
 557     if (hasOneRef())
 558         filtered = true;
 559     deref(arena);
 560
 561     return filtered;
 562 }
 563
 564 void RenderWidget::deref(RenderArena *arena)
 565 {
 566     if (_ref) _ref--;
 567     if (!_ref)
 568         arenaDelete(arena, this);
 569 }
 570
 571 #if APPLE_CHANGES
 572 void RenderWidget::updateWidgetPositions()
 573 {
 574     if (!m_widget)
 575         return;
 576
 577     int x, y, width, height;
 578     absolutePosition(x,y);
 579     x += borderLeft() + paddingLeft();
 580     y += borderTop() + paddingTop();
 581     width = m_width - borderLeft() - borderRight() - paddingLeft() - paddingRight();
 582     height = m_height - borderTop() - borderBottom() - paddingTop() - paddingBottom();
 583     QRect newBounds(x,y,width,height);
 584     QRect oldBounds(m_widget->frameGeometry());
 585     if (newBounds != oldBounds) {
 586         // The widget changed positions.  Update the frame geometry.
 587         if (checkForRepaintDuringLayout()) {
 588             RenderCanvas* c = canvas();
 589             if (!c->printingMode()) {
 590                 c->repaintViewRectangle(oldBounds);
 591                 c->repaintViewRectangle(newBounds);
 592             }
 593         }
 594
 595         RenderArena *arena = ref();
 596         element()->ref();
 597         m_widget->setFrameGeometry(newBounds);
 598         element()->deref();
 599         deref(arena);
 600     }
 601 }
 602 #endif
 603
 604 void RenderWidget::setSelectionState(SelectionState s)
 605 {
 606     if (m_selectionState != s) {
 607         RenderReplaced::setSelectionState(s);
 608         m_selectionState = s;
 609         if (m_widget)
 610             m_widget->setIsSelected(m_selectionState != SelectionNone);
 611     }
 612 }
 613
 614 #include "render_replaced.moc"