Rename a number of libraries and executables to avoid conflicts with KDE4

1 files changed, 1025 insertions, 0 deletions

diff --git a/tdehtml/rendering/render_frames.cpp b/tdehtml/rendering/render_frames.cpp
new file mode 100644
index 000000000..03d55fbfd
--- /dev/null
+++ b/tdehtml/rendering/render_frames.cpp
@@ -0,0 +1,1025 @@
+/**
+ * This file is part of the KDE project.
+ *
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ *           (C) 2000 Simon Hausmann <hausmann@kde.org>
+ *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
+ *           (C) 2003 Apple Computer, Inc.
+ *           (C) 2005 Niels Leenheer <niels.leenheer@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+//#define DEBUG_LAYOUT
+
+#include "rendering/render_frames.h"
+#include "rendering/render_canvas.h"
+#include "html/html_baseimpl.h"
+#include "html/html_objectimpl.h"
+#include "html/htmltokenizer.h"
+#include "misc/htmlattrs.h"
+#include "xml/dom2_eventsimpl.h"
+#include "xml/dom_docimpl.h"
+#include "misc/htmltags.h"
+#include "tdehtmlview.h"
+#include "tdehtml_part.h"
+#include "misc/knsplugininstaller.h"
+
+#include <kapplication.h>
+#include <kmessagebox.h>
+#include <kmimetype.h>
+#include <klocale.h>
+#include <kdebug.h>
+#include <tqtimer.h>
+#include <tqpainter.h>
+#include <tqcursor.h>
+
+#include <assert.h>
+
+using namespace tdehtml;
+using namespace DOM;
+
+RenderFrameSet::RenderFrameSet( HTMLFrameSetElementImpl *frameSet)
+    : RenderBox(frameSet)
+{
+  // init RenderObject attributes
+    setInline(false);
+
+  for (int k = 0; k < 2; ++k) {
+      m_gridLen[k] = -1;
+      m_gridDelta[k] = 0;
+      m_gridLayout[k] = 0;
+  }
+
+  m_resizing = m_clientresizing= false;
+
+  m_cursor = Qt::ArrowCursor;
+
+  m_hSplit = -1;
+  m_vSplit = -1;
+
+  m_hSplitVar = 0;
+  m_vSplitVar = 0;
+}
+
+RenderFrameSet::~RenderFrameSet()
+{
+    for (int k = 0; k < 2; ++k) {
+        delete [] m_gridLayout[k];
+        delete [] m_gridDelta[k];
+    }
+    delete [] m_hSplitVar;
+    delete [] m_vSplitVar;
+}
+
+bool RenderFrameSet::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction,  bool inBox)
+{
+    RenderBox::nodeAtPoint(info, _x, _y, _tx, _ty, hitTestAction, inBox);
+
+    bool inside = m_resizing || canResize(_x, _y);
+
+    if ( inside && element() && !element()->noResize() && !info.readonly()) {
+        info.setInnerNode(element());
+        info.setInnerNonSharedNode(element());
+    }
+
+    return inside || m_clientresizing;
+}
+
+void RenderFrameSet::layout( )
+{
+    KHTMLAssert( needsLayout() );
+    KHTMLAssert( minMaxKnown() );
+
+    if ( !parent()->isFrameSet() ) {
+        KHTMLView* view = canvas()->view();
+        m_width = view ? view->visibleWidth() : 0;
+        m_height = view ? view->visibleHeight() : 0;
+    }
+
+#ifdef DEBUG_LAYOUT
+    kdDebug( 6040 ) << renderName() << "(FrameSet)::layout( ) width=" << width() << ", height=" << height() << endl;
+#endif
+
+    int remainingLen[2];
+    remainingLen[1] = m_width - (element()->totalCols()-1)*element()->border();
+    if(remainingLen[1]<0) remainingLen[1]=0;
+    remainingLen[0] = m_height - (element()->totalRows()-1)*element()->border();
+    if(remainingLen[0]<0) remainingLen[0]=0;
+
+    int availableLen[2];
+    availableLen[0] = remainingLen[0];
+    availableLen[1] = remainingLen[1];
+
+    if (m_gridLen[0] != element()->totalRows() || m_gridLen[1] != element()->totalCols()) {
+        // number of rows or cols changed
+        // need to zero out the deltas
+        m_gridLen[0] = element()->totalRows();
+        m_gridLen[1] = element()->totalCols();
+        for (int k = 0; k < 2; ++k) {
+            delete [] m_gridDelta[k];
+            m_gridDelta[k] = new int[m_gridLen[k]];
+            delete [] m_gridLayout[k];
+            m_gridLayout[k] = new int[m_gridLen[k]];
+            for (int i = 0; i < m_gridLen[k]; ++i)
+                m_gridDelta[k][i] = 0;
+        }
+    }
+
+    for (int k = 0; k < 2; ++k) {
+        int totalRelative = 0;
+        int totalFixed = 0;
+        int totalPercent = 0;
+        int countRelative = 0;
+        int countFixed = 0;
+        int countPercent = 0;
+        int gridLen = m_gridLen[k];
+        int* gridDelta = m_gridDelta[k];
+        tdehtml::Length* grid =  k ? element()->m_cols : element()->m_rows;
+        int* gridLayout = m_gridLayout[k];
+
+        if (grid) {
+            // First we need to investigate how many columns of each type we have and
+            // how much space these columns are going to require.
+            for (int i = 0; i < gridLen; ++i) {
+                // Count the total length of all of the fixed columns/rows -> totalFixed
+                // Count the number of columns/rows which are fixed -> countFixed
+                if (grid[i].isFixed()) {
+                    gridLayout[i] = kMax(grid[i].value(), 0);
+                    totalFixed += gridLayout[i];
+                    countFixed++;
+                }
+                
+                // Count the total percentage of all of the percentage columns/rows -> totalPercent
+                // Count the number of columns/rows which are percentages -> countPercent
+                if (grid[i].isPercent()) {
+                    gridLayout[i] = kMax(grid[i].width(availableLen[k]), 0);
+                    totalPercent += gridLayout[i];
+                    countPercent++;
+                }
+
+                // Count the total relative of all the relative columns/rows -> totalRelative
+                // Count the number of columns/rows which are relative -> countRelative
+                if (grid[i].isRelative()) {
+                    totalRelative += kMax(grid[i].value(), 1);
+                    countRelative++;
+                }            
+            }
+
+            // Fixed columns/rows are our first priority. If there is not enough space to fit all fixed
+            // columns/rows we need to proportionally adjust their size. 
+            if (totalFixed > remainingLen[k]) {
+                int remainingFixed = remainingLen[k];
+
+                for (int i = 0; i < gridLen; ++i) {
+                    if (grid[i].isFixed()) {
+                        gridLayout[i] = (gridLayout[i] * remainingFixed) / totalFixed;
+                        remainingLen[k] -= gridLayout[i];
+                    }
+                }
+            } else {
+                remainingLen[k] -= totalFixed;
+            }
+
+            // Percentage columns/rows are our second priority. Divide the remaining space proportionally 
+            // over all percentage columns/rows. IMPORTANT: the size of each column/row is not relative 
+            // to 100%, but to the total percentage. For example, if there are three columns, each of 75%,
+            // and the available space is 300px, each column will become 100px in width.
+            if (totalPercent > remainingLen[k]) {
+                int remainingPercent = remainingLen[k];
+ 
+                for (int i = 0; i < gridLen; ++i) {
+                    if (grid[i].isPercent()) {
+                        gridLayout[i] = (gridLayout[i] * remainingPercent) / totalPercent;
+                        remainingLen[k] -= gridLayout[i];
+                    }
+                }
+            } else {
+                remainingLen[k] -= totalPercent;
+            }
+
+            // Relative columns/rows are our last priority. Divide the remaining space proportionally
+            // over all relative columns/rows. IMPORTANT: the relative value of 0* is treated as 1*.
+            if (countRelative) {
+                int lastRelative = 0;
+                int remainingRelative = remainingLen[k];
+
+                for (int i = 0; i < gridLen; ++i) {
+                    if (grid[i].isRelative()) {
+                        gridLayout[i] = (kMax(grid[i].value(), 1) * remainingRelative) / totalRelative;
+                        remainingLen[k] -= gridLayout[i];
+                        lastRelative = i;
+                    }
+                }
+
+                // If we could not evently distribute the available space of all of the relative  
+                // columns/rows, the remainder will be added to the last column/row.
+                // For example: if we have a space of 100px and three columns (*,*,*), the remainder will
+                // be 1px and will be added to the last column: 33px, 33px, 34px.
+                if (remainingLen[k]) {
+                    gridLayout[lastRelative] += remainingLen[k];
+                    remainingLen[k] = 0;
+                }
+            }
+
+            // If we still have some left over space we need to divide it over the already existing
+            // columns/rows
+            if (remainingLen[k]) {
+                // Our first priority is to spread if over the percentage columns. The remaining
+                // space is spread evenly, for example: if we have a space of 100px, the columns 
+                // definition of 25%,25% used to result in two columns of 25px. After this the 
+                // columns will each be 50px in width. 
+                if (countPercent && totalPercent) {
+                    int remainingPercent = remainingLen[k];
+                    int changePercent = 0;
+
+                    for (int i = 0; i < gridLen; ++i) {
+                        if (grid[i].isPercent()) {
+                            changePercent = (remainingPercent * gridLayout[i]) / totalPercent;
+                            gridLayout[i] += changePercent;
+                            remainingLen[k] -= changePercent;
+                        }
+                    }
+                } else if (totalFixed) {
+                    // Our last priority is to spread the remaining space over the fixed columns.
+                    // For example if we have 100px of space and two column of each 40px, both
+                    // columns will become exactly 50px.
+                    int remainingFixed = remainingLen[k];
+                    int changeFixed = 0;
+
+                    for (int i = 0; i < gridLen; ++i) {
+                        if (grid[i].isFixed()) {
+                            changeFixed = (remainingFixed * gridLayout[i]) / totalFixed;
+                            gridLayout[i] += changeFixed;
+                            remainingLen[k] -= changeFixed;
+                        } 
+                    }
+                }
+            }
+            
+            // If we still have some left over space we probably ended up with a remainder of
+            // a division. We can not spread it evenly anymore. If we have any percentage 
+            // columns/rows simply spread the remainder equally over all available percentage columns, 
+            // regardless of their size.
+            if (remainingLen[k] && countPercent) {
+                int remainingPercent = remainingLen[k];
+                int changePercent = 0;
+
+                for (int i = 0; i < gridLen; ++i) {
+                    if (grid[i].isPercent()) {
+                        changePercent = remainingPercent / countPercent;
+                        gridLayout[i] += changePercent;
+                        remainingLen[k] -= changePercent;
+                    }
+                }
+            } 
+            
+            // If we don't have any percentage columns/rows we only have fixed columns. Spread
+            // the remainder equally over all fixed columns/rows.
+            else if (remainingLen[k] && countFixed) {
+                int remainingFixed = remainingLen[k];
+                int changeFixed = 0;
+                
+                for (int i = 0; i < gridLen; ++i) {
+                    if (grid[i].isFixed()) {
+                        changeFixed = remainingFixed / countFixed;
+                        gridLayout[i] += changeFixed;
+                        remainingLen[k] -= changeFixed;
+                    }
+                }
+            }
+
+            // Still some left over... simply add it to the last column, because it is impossible
+            // spread it evenly or equally.
+            if (remainingLen[k]) {
+                gridLayout[gridLen - 1] += remainingLen[k];
+            }
+
+            // now we have the final layout, distribute the delta over it
+            bool worked = true;
+            for (int i = 0; i < gridLen; ++i) {
+                if (gridLayout[i] && gridLayout[i] + gridDelta[i] <= 0)
+                    worked = false;
+                gridLayout[i] += gridDelta[i];
+            }
+            // now the delta's broke something, undo it and reset deltas
+            if (!worked)
+                for (int i = 0; i < gridLen; ++i) {
+                    gridLayout[i] -= gridDelta[i];
+                    gridDelta[i] = 0;
+                }
+        }
+        else
+            gridLayout[0] = remainingLen[k];
+    }
+
+    positionFrames();
+
+    RenderObject *child = firstChild();
+    if ( !child )
+      goto end2;
+
+    if(!m_hSplitVar && !m_vSplitVar)
+    {
+#ifdef DEBUG_LAYOUT
+        kdDebug( 6031 ) << "calculationg fixed Splitters" << endl;
+#endif
+        if(!m_vSplitVar && element()->totalCols() > 1)
+        {
+            m_vSplitVar = new bool[element()->totalCols()];
+            for(int i = 0; i < element()->totalCols(); i++) m_vSplitVar[i] = true;
+        }
+        if(!m_hSplitVar && element()->totalRows() > 1)
+        {
+            m_hSplitVar = new bool[element()->totalRows()];
+            for(int i = 0; i < element()->totalRows(); i++) m_hSplitVar[i] = true;
+        }
+
+        for(int r = 0; r < element()->totalRows(); r++)
+        {
+            for(int c = 0; c < element()->totalCols(); c++)
+            {
+                bool fixed = false;
+
+                if ( child->isFrameSet() )
+                  fixed = static_cast<RenderFrameSet *>(child)->element()->noResize();
+                else
+                  fixed = static_cast<RenderFrame *>(child)->element()->noResize();
+
+                if(fixed)
+                {
+#ifdef DEBUG_LAYOUT
+                    kdDebug( 6031 ) << "found fixed cell " << r << "/" << c << "!" << endl;
+#endif
+                    if( element()->totalCols() > 1)
+                    {
+                        if(c>0) m_vSplitVar[c-1] = false;
+                        m_vSplitVar[c] = false;
+                    }
+                    if( element()->totalRows() > 1)
+                    {
+                        if(r>0) m_hSplitVar[r-1] = false;
+                        m_hSplitVar[r] = false;
+                    }
+                    child = child->nextSibling();
+                    if(!child) goto end2;
+                }
+#ifdef DEBUG_LAYOUT
+                else
+                    kdDebug( 6031 ) << "not fixed: " << r << "/" << c << "!" << endl;
+#endif
+            }
+        }
+
+    }
+    RenderContainer::layout();
+ end2:
+    setNeedsLayout(false);
+}
+
+void RenderFrameSet::positionFrames()
+{
+  int r;
+  int c;
+
+  RenderObject *child = firstChild();
+  if ( !child )
+    return;
+
+  //  NodeImpl *child = _first;
+  //  if(!child) return;
+
+  int yPos = 0;
+
+  for(r = 0; r < element()->totalRows(); r++)
+  {
+    int xPos = 0;
+    for(c = 0; c < element()->totalCols(); c++)
+    {
+      child->setPos( xPos, yPos );
+#ifdef DEBUG_LAYOUT
+      kdDebug(6040) << "child frame at (" << xPos << "/" << yPos << ") size (" << m_gridLayout[1][c] << "/" << m_gridLayout[0][r] << ")" << endl;
+#endif
+      // has to be resized and itself resize its contents
+      if ((m_gridLayout[1][c] != child->width()) || (m_gridLayout[0][r] != child->height())) {
+          child->setWidth( m_gridLayout[1][c] );
+          child->setHeight( m_gridLayout[0][r] );
+          child->setNeedsLayout(true);
+          child->layout();
+      }
+
+      xPos += m_gridLayout[1][c] + element()->border();
+      child = child->nextSibling();
+
+      if ( !child )
+        return;
+
+    }
+
+    yPos += m_gridLayout[0][r] + element()->border();
+  }
+
+  // all the remaining frames are hidden to avoid ugly
+  // spurious unflowed frames
+  while ( child ) {
+      child->setWidth( 0 );
+      child->setHeight( 0 );
+      child->setNeedsLayout(false);
+
+      child = child->nextSibling();
+  }
+}
+
+bool RenderFrameSet::userResize( MouseEventImpl *evt )
+{
+    if (needsLayout()) return false;
+
+  bool res = false;
+  int _x = evt->clientX();
+  int _y = evt->clientY();
+
+  if ( !m_resizing && evt->id() == EventImpl::MOUSEMOVE_EVENT || evt->id() == EventImpl::MOUSEDOWN_EVENT )
+  {
+#ifdef DEBUG_LAYOUT
+    kdDebug( 6031 ) << "mouseEvent:check" << endl;
+#endif
+
+    m_hSplit = -1;
+    m_vSplit = -1;
+    //bool resizePossible = true;
+
+    // check if we're over a horizontal or vertical boundary
+    int pos = m_gridLayout[1][0] + xPos();
+    for(int c = 1; c < element()->totalCols(); c++)
+    {
+      if(_x >= pos && _x <= pos+element()->border())
+      {
+        if(m_vSplitVar && m_vSplitVar[c-1] == true) m_vSplit = c-1;
+#ifdef DEBUG_LAYOUT
+        kdDebug( 6031 ) << "vsplit!" << endl;
+#endif
+        res = true;
+        break;
+      }
+      pos += m_gridLayout[1][c] + element()->border();
+    }
+
+    pos = m_gridLayout[0][0] + yPos();
+    for(int r = 1; r < element()->totalRows(); r++)
+    {
+      if( _y >= pos && _y <= pos+element()->border())
+      {
+        if(m_hSplitVar && m_hSplitVar[r-1] == true) m_hSplit = r-1;
+#ifdef DEBUG_LAYOUT
+        kdDebug( 6031 ) << "hsplitvar = " << m_hSplitVar << endl;
+        kdDebug( 6031 ) << "hsplit!" << endl;
+#endif
+        res = true;
+        break;
+      }
+      pos += m_gridLayout[0][r] + element()->border();
+    }
+#ifdef DEBUG_LAYOUT
+    kdDebug( 6031 ) << m_hSplit << "/" << m_vSplit << endl;
+#endif
+  }
+
+
+  m_cursor = Qt::ArrowCursor;
+  if(m_hSplit != -1 && m_vSplit != -1)
+      m_cursor = Qt::SizeAllCursor;
+  else if( m_vSplit != -1 )
+      m_cursor = Qt::SizeHorCursor;
+  else if( m_hSplit != -1 )
+      m_cursor = Qt::SizeVerCursor;
+
+  if(!m_resizing && evt->id() == EventImpl::MOUSEDOWN_EVENT)
+  {
+      setResizing(true);
+      TDEApplication::setOverrideCursor(TQCursor(m_cursor));
+      m_vSplitPos = _x;
+      m_hSplitPos = _y;
+      m_oldpos = -1;
+  }
+
+  // ### check the resize is not going out of bounds.
+  if(m_resizing && evt->id() == EventImpl::MOUSEUP_EVENT)
+  {
+    setResizing(false);
+    TDEApplication::restoreOverrideCursor();
+
+    if(m_vSplit != -1 )
+    {
+#ifdef DEBUG_LAYOUT
+      kdDebug( 6031 ) << "split xpos=" << _x << endl;
+#endif
+      int delta = m_vSplitPos - _x;
+      m_gridDelta[1][m_vSplit] -= delta;
+      m_gridDelta[1][m_vSplit+1] += delta;
+    }
+    if(m_hSplit != -1 )
+    {
+#ifdef DEBUG_LAYOUT
+      kdDebug( 6031 ) << "split ypos=" << _y << endl;
+#endif
+      int delta = m_hSplitPos - _y;
+      m_gridDelta[0][m_hSplit] -= delta;
+      m_gridDelta[0][m_hSplit+1] += delta;
+    }
+
+    // this just schedules the relayout
+    // important, otherwise the moving indicator is not correctly erased
+    setNeedsLayout(true);
+  }
+
+  KHTMLView *view = canvas()->view();
+  if ((m_resizing || evt->id() == EventImpl::MOUSEUP_EVENT) && view) {
+      TQPainter paint( view );
+      paint.setPen( Qt::gray );
+      paint.setBrush( Qt::gray );
+      paint.setRasterOp( TQt::XorROP );
+      TQRect r(xPos(), yPos(), width(), height());
+      const int rBord = 3;
+      int sw = element()->border();
+      int p = m_resizing ? (m_vSplit > -1 ? _x : _y) : -1;
+      if (m_vSplit > -1) {
+          if ( m_oldpos >= 0 )
+              paint.drawRect( m_oldpos + sw/2 - rBord , r.y(),
+                              2*rBord, r.height() );
+          if ( p >= 0 )
+              paint.drawRect( p  + sw/2 - rBord, r.y(), 2*rBord, r.height() );
+      } else {
+          if ( m_oldpos >= 0 )
+              paint.drawRect( r.x(), m_oldpos + sw/2 - rBord,
+                              r.width(), 2*rBord );
+          if ( p >= 0 )
+              paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord );
+      }
+      m_oldpos = p;
+  }
+
+  return res;
+}
+
+void RenderFrameSet::setResizing(bool e)
+{
+      m_resizing = e;
+      for (RenderObject* p = parent(); p; p = p->parent())
+          if (p->isFrameSet()) static_cast<RenderFrameSet*>(p)->m_clientresizing = m_resizing;
+}
+
+bool RenderFrameSet::canResize( int _x, int _y )
+{
+    // if we haven't received a layout, then the gridLayout doesn't contain useful data yet
+    if (needsLayout() || !m_gridLayout[0] || !m_gridLayout[1] ) return false;
+
+    // check if we're over a horizontal or vertical boundary
+    int pos = m_gridLayout[1][0];
+    for(int c = 1; c < element()->totalCols(); c++)
+        if(_x >= pos && _x <= pos+element()->border())
+            return true;
+
+    pos = m_gridLayout[0][0];
+    for(int r = 1; r < element()->totalRows(); r++)
+        if( _y >= pos && _y <= pos+element()->border())
+            return true;
+
+    return false;
+}
+
+#ifdef ENABLE_DUMP
+void RenderFrameSet::dump(TQTextStream &stream, const TQString &ind) const
+{
+    RenderBox::dump(stream,ind);
+    stream << " totalrows=" << element()->totalRows();
+    stream << " totalcols=" << element()->totalCols();
+
+    if ( m_hSplitVar )
+        for (uint i = 0; i < (uint)element()->totalRows(); i++) {
+            stream << " hSplitvar(" << i << ")=" << m_hSplitVar[i];
+        }
+
+    if ( m_vSplitVar )
+        for (uint i = 0; i < (uint)element()->totalCols(); i++)
+            stream << " vSplitvar(" << i << ")=" << m_vSplitVar[i];
+}
+#endif
+
+/**************************************************************************************/
+
+RenderPart::RenderPart(DOM::HTMLElementImpl* node)
+    : RenderWidget(node)
+{
+    // init RenderObject attributes
+    setInline(false);
+}
+
+void RenderPart::setWidget( TQWidget *widget )
+{
+#ifdef DEBUG_LAYOUT
+    kdDebug(6031) << "RenderPart::setWidget()" << endl;
+#endif
+
+    setQWidget( widget );
+    widget->setFocusPolicy(TQ_WheelFocus);
+    if(widget->inherits("KHTMLView"))
+        connect( widget, TQT_SIGNAL( cleared() ), this, TQT_SLOT( slotViewCleared() ) );
+
+    setNeedsLayoutAndMinMaxRecalc();
+
+    // make sure the scrollbars are set correctly for restore
+    // ### find better fix
+    slotViewCleared();
+}
+
+bool RenderPart::partLoadingErrorNotify(tdehtml::ChildFrame *, const KURL& , const TQString& )
+{
+    return false;
+}
+
+short RenderPart::intrinsicWidth() const
+{
+    return 300;
+}
+
+int RenderPart::intrinsicHeight() const
+{
+    return 150;
+}
+
+void RenderPart::slotViewCleared()
+{
+}
+
+/***************************************************************************************/
+
+RenderFrame::RenderFrame( DOM::HTMLFrameElementImpl *frame )
+    : RenderPart(frame)
+{
+    setInline( false );
+}
+
+void RenderFrame::slotViewCleared()
+{
+    if(m_widget->inherits(TQSCROLLVIEW_OBJECT_NAME_STRING)) {
+#ifdef DEBUG_LAYOUT
+        kdDebug(6031) << "frame is a scrollview!" << endl;
+#endif
+        TQScrollView *view = static_cast<TQScrollView *>(m_widget);
+        if(!element()->frameBorder || !((static_cast<HTMLFrameSetElementImpl *>(element()->parentNode()))->frameBorder()))
+            view->setFrameStyle(TQFrame::NoFrame);
+	    view->setVScrollBarMode(element()->scrolling );
+	    view->setHScrollBarMode(element()->scrolling );
+        if(view->inherits("KHTMLView")) {
+#ifdef DEBUG_LAYOUT
+            kdDebug(6031) << "frame is a KHTMLview!" << endl;
+#endif
+            KHTMLView *htmlView = static_cast<KHTMLView *>(view);
+            if(element()->marginWidth != -1) htmlView->setMarginWidth(element()->marginWidth);
+            if(element()->marginHeight != -1) htmlView->setMarginHeight(element()->marginHeight);
+        }
+    }
+}
+
+/****************************************************************************************/
+
+RenderPartObject::RenderPartObject( DOM::HTMLElementImpl* element )
+    : RenderPart( element )
+{
+    // init RenderObject attributes
+    setInline(true);
+}
+
+void RenderPartObject::updateWidget()
+{
+  TQString url;
+  KHTMLPart *part = m_view->part();
+
+  setNeedsLayoutAndMinMaxRecalc();
+
+  if (element()->id() == ID_IFRAME) {
+
+      HTMLIFrameElementImpl *o = static_cast<HTMLIFrameElementImpl *>(element());
+      url = o->url.string();
+      if (!o->getDocument()->isURLAllowed(url)) return;
+      part->requestFrame( this, url, o->name.string(), TQStringList(), true );
+  // ### this should be constant true - move iframe to somewhere else
+  } else {
+
+      TQStringList params;
+      HTMLObjectBaseElementImpl * objbase = static_cast<HTMLObjectBaseElementImpl *>(element());
+      url = objbase->url;
+
+      for (NodeImpl* child = element()->firstChild(); child; child=child->nextSibling()) {
+          if ( child->id() == ID_PARAM ) {
+              HTMLParamElementImpl *p = static_cast<HTMLParamElementImpl *>( child );
+
+              TQString aStr = p->name();
+              aStr += TQString::fromLatin1("=\"");
+              aStr += p->value();
+              aStr += TQString::fromLatin1("\"");
+              TQString name_lower = p->name().lower();
+              if (name_lower == TQString::fromLatin1("type") && objbase->id() != ID_APPLET) {
+                  objbase->setServiceType(p->value());
+              } else if (url.isEmpty() &&
+                         (name_lower == TQString::fromLatin1("src") ||
+                          name_lower == TQString::fromLatin1("movie") ||
+                          name_lower == TQString::fromLatin1("code"))) {
+                  url = p->value();
+              }
+              params.append(aStr);
+          }
+      }
+      if (element()->id() != ID_OBJECT) {
+          // add all attributes set on the embed object
+          NamedAttrMapImpl* a = objbase->attributes();
+          if (a) {
+              for (unsigned long i = 0; i < a->length(); ++i) {
+                  NodeImpl::Id id = a->idAt(i);
+                  DOMString value = a->valueAt(i);
+              params.append(objbase->getDocument()->getName(NodeImpl::AttributeId, id).string() + "=\"" + value.string() + "\"");
+              }
+          }
+      }
+      params.append( TQString::fromLatin1("__KHTML__PLUGINEMBED=\"YES\"") );
+      params.append( TQString::fromLatin1("__KHTML__PLUGINBASEURL=\"%1\"").arg(element()->getDocument()->baseURL().url()));
+
+      HTMLEmbedElementImpl *embed = 0;
+      TQString classId;
+      TQString serviceType = objbase->serviceType;
+      if ( element()->id() == ID_EMBED ) {
+
+          embed = static_cast<HTMLEmbedElementImpl *>( objbase );
+
+      }
+      else { // if(element()->id() == ID_OBJECT || element()->id() == ID_APPLET)
+
+          // check for embed child object
+          for (NodeImpl *child = objbase->firstChild(); child; child = child->nextSibling())
+              if ( child->id() == ID_EMBED ) {
+                  embed = static_cast<HTMLEmbedElementImpl *>( child );
+                  break;
+              }
+          classId = objbase->classId;
+
+          params.append( TQString::fromLatin1("__KHTML__CLASSID=\"%1\"").arg( classId ) );
+          params.append( TQString::fromLatin1("__KHTML__CODEBASE=\"%1\"").arg( objbase->getAttribute(ATTR_CODEBASE).string() ) );
+          if (!objbase->getAttribute(ATTR_WIDTH).isEmpty())
+              params.append( TQString::fromLatin1("WIDTH=\"%1\"").arg( objbase->getAttribute(ATTR_WIDTH).string() ) );
+          else if (embed && !embed->getAttribute(ATTR_WIDTH).isEmpty()) {
+              params.append( TQString::fromLatin1("WIDTH=\"%1\"").arg( embed->getAttribute(ATTR_WIDTH).string() ) );
+              objbase->setAttribute(ATTR_WIDTH, embed->getAttribute(ATTR_WIDTH));
+          }
+          if (!objbase->getAttribute(ATTR_HEIGHT).isEmpty())
+              params.append( TQString::fromLatin1("HEIGHT=\"%1\"").arg( objbase->getAttribute(ATTR_HEIGHT).string() ) );
+          else if (embed && !embed->getAttribute(ATTR_HEIGHT).isEmpty()) {
+              params.append( TQString::fromLatin1("HEIGHT=\"%1\"").arg( embed->getAttribute(ATTR_HEIGHT).string() ) );
+              objbase->setAttribute(ATTR_HEIGHT, embed->getAttribute(ATTR_HEIGHT));
+          }
+
+          if ( embed ) {
+              // render embed object
+              url = embed->url;
+              if (!embed->serviceType.isEmpty())
+                  serviceType = embed->serviceType;
+          } else if (url.isEmpty() && objbase->classId.startsWith("java:")) {
+              serviceType = "application/x-java-applet";
+              url = objbase->classId.mid(5);
+          }
+          if ( (serviceType.isEmpty() ||
+                      serviceType == "application/x-oleobject") &&
+                  !objbase->classId.isEmpty())
+          {
+#if 0
+              // We have a clsid, means this is activex (Niko)
+              serviceType = "application/x-activex-handler";
+#endif
+
+              if(classId.find(TQString::fromLatin1("D27CDB6E-AE6D-11cf-96B8-444553540000")) >= 0) {
+                  // It is ActiveX, but the nsplugin system handling
+                  // should also work, that's why we don't override the
+                  // serviceType with application/x-activex-handler
+                  // but let the KTrader in tdehtmlpart::createPart() detect
+                  // the user's preference: launch with activex viewer or
+                  // with nspluginviewer (Niko)
+                  serviceType = "application/x-shockwave-flash";
+              }
+              else if(classId.find(TQString::fromLatin1("CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA")) >= 0)
+                  serviceType = "audio/x-pn-realaudio-plugin";
+              else if(classId.find(TQString::fromLatin1("8AD9C840-044E-11D1-B3E9-00805F499D93")) >= 0 ||
+                      objbase->classId.find(TQString::fromLatin1("CAFEEFAC-0014-0000-0000-ABCDEFFEDCBA")) >= 0)
+                  serviceType = "application/x-java-applet";
+              // http://www.apple.com/quicktime/tools_tips/tutorials/activex.html
+              else if(classId.find(TQString::fromLatin1("02BF25D5-8C17-4B23-BC80-D3488ABDDC6B")) >= 0)
+                  serviceType = "video/quicktime";
+              // http://msdn.microsoft.com/library/en-us/dnwmt/html/adding_windows_media_to_web_pages__etse.asp?frame=true
+              else if(objbase->classId.find(TQString::fromLatin1("6BF52A52-394A-11d3-B153-00C04F79FAA6")) >= 0 ||
+                      classId.find(TQString::fromLatin1("22D6f312-B0F6-11D0-94AB-0080C74C7E95")) >= 0)
+                  serviceType = "video/x-msvideo";
+
+              else
+                  kdDebug(6031) << "ActiveX classId " << objbase->classId << endl;
+
+              // TODO: add more plugins here
+          }
+      }
+      if ((url.isEmpty() && !embed &&
+                  (serviceType.isEmpty() || classId.isEmpty())) ||
+              !document()->isURLAllowed(url) ||
+              !part->requestObject( this, url, serviceType, params ))
+          objbase->renderAlternative();
+  }
+}
+
+// ugly..
+void RenderPartObject::close()
+{
+    RenderPart::close();
+
+    if ( element()->id() != ID_IFRAME )
+        updateWidget();
+    // deleted here
+}
+
+
+bool RenderPartObject::partLoadingErrorNotify( tdehtml::ChildFrame *childFrame, const KURL& url, const TQString& serviceType )
+{
+    KHTMLPart *part = static_cast<KHTMLView *>(m_view)->part();
+    kdDebug(6031) << "RenderPartObject::partLoadingErrorNotify serviceType=" << serviceType << endl;
+    // Check if we just tried with e.g. nsplugin
+    // and fallback to the activexhandler if there is a classid
+    // and a codebase, where we may download the ocx if it's missing
+    if( serviceType != "application/x-activex-handler" && element()->id()==ID_OBJECT ) {
+
+        // check for embed child object
+        HTMLObjectElementImpl *o = static_cast<HTMLObjectElementImpl *>(element());
+        HTMLEmbedElementImpl *embed = 0;
+        NodeImpl *child = o->firstChild();
+        while ( child ) {
+            if ( child->id() == ID_EMBED )
+                embed = static_cast<HTMLEmbedElementImpl *>( child );
+
+            child = child->nextSibling();
+        }
+        if( embed && !o->classId.isEmpty() &&
+            !( static_cast<ElementImpl *>(o)->getAttribute(ATTR_CODEBASE).string() ).isEmpty() )
+        {
+            KParts::URLArgs args;
+            args.serviceType = "application/x-activex-handler";
+            kdDebug(6031) << "set to activex" << endl;
+            if (part->requestObject( childFrame, url, args ))
+                return true; // success
+
+            return false;
+        }
+    }
+    // Dissociate ourselves from the current event loop (to prevent crashes
+    // due to the message box staying up)
+    TQTimer::singleShot( 0, this, TQT_SLOT( slotPartLoadingErrorNotify() ) );
+#if 0
+    Tokenizer *tokenizer = static_cast<DOM::DocumentImpl *>(part->document().handle())->tokenizer();
+    if (tokenizer) tokenizer->setOnHold( true );
+    slotPartLoadingErrorNotify();
+    if (tokenizer) tokenizer->setOnHold( false );
+#endif
+    return false;
+}
+
+void RenderPartObject::slotPartLoadingErrorNotify()
+{
+    // First we need to find out the servicetype - again - this code is too duplicated !
+    HTMLEmbedElementImpl *embed = 0;
+    TQString serviceType;
+    if( element()->id()==ID_OBJECT ) {
+
+        // check for embed child object
+        HTMLObjectElementImpl *o = static_cast<HTMLObjectElementImpl *>(element());
+        serviceType = o->serviceType;
+        NodeImpl *child = o->firstChild();
+        while ( child ) {
+            if ( child->id() == ID_EMBED )
+                embed = static_cast<HTMLEmbedElementImpl *>( child );
+
+            child = child->nextSibling();
+        }
+
+    } else if( element()->id()==ID_EMBED ) {
+        embed = static_cast<HTMLEmbedElementImpl *>(element());
+    }
+    if ( embed )
+	serviceType = embed->serviceType;
+
+    // prepare for the local eventloop in KMessageBox
+    ref();
+
+    KHTMLPart *part = static_cast<KHTMLView *>(m_view)->part();
+    KParts::BrowserExtension *ext = part->browserExtension();
+    if( embed && !embed->pluginPage.isEmpty() && ext ) {
+        // Prepare the mimetype to show in the question (comment if available, name as fallback)
+        TQString mimeName = serviceType;
+        KMimeType::Ptr mime = KMimeType::mimeType(serviceType);
+        if ( mime->name() != KMimeType::defaultMimeType() )
+            mimeName = mime->comment();
+
+        // Check if we already asked the user, for this page
+        if (!mimeName.isEmpty() && part->docImpl() && !part->pluginPageQuestionAsked( serviceType ) )
+        {
+            part->setPluginPageQuestionAsked( serviceType );
+            bool pluginAvailable;
+            pluginAvailable = false;
+            // check if a pluginList file is in the config
+            if(KNSPluginInstallEngine::isActive())
+            {
+                KNSPluginWizard pluginWizard(m_view, "pluginInstaller", mime);
+                if(pluginWizard.pluginAvailable()) {
+                    pluginAvailable = true;
+                    pluginWizard.exec();
+                }
+            } 
+            if(!pluginAvailable) {
+                // Prepare the URL to show in the question (host only if http, to make it short)
+                KURL pluginPageURL( embed->pluginPage );
+                TQString shortURL = pluginPageURL.protocol() == "http" ? pluginPageURL.host() : pluginPageURL.prettyURL();
+                int res = KMessageBox::questionYesNo( m_view,
+                                                      i18n("No plugin found for '%1'.\nDo you want to download one from %2?").arg(mimeName).arg(shortURL),
+                                                      i18n("Missing Plugin"), i18n("Download"), i18n("Do Not Download"), TQString("plugin-")+serviceType);
+                if ( res == KMessageBox::Yes )
+                {
+                    // Display vendor download page
+                    ext->createNewWindow( pluginPageURL );
+                    return;
+                }
+            }
+        }
+    }
+
+    // didn't work, render alternative content.
+    if ( element() && (
+         element()->id() == ID_OBJECT || element()->id() == ID_EMBED || element()->id() == ID_APPLET))
+        static_cast<HTMLObjectBaseElementImpl*>( element() )->renderAlternative();
+
+    deref();
+}
+
+void RenderPartObject::layout( )
+{
+    KHTMLAssert( needsLayout() );
+    KHTMLAssert( minMaxKnown() );
+
+    calcWidth();
+    calcHeight();
+
+    RenderPart::layout();
+
+    setNeedsLayout(false);
+}
+
+void RenderPartObject::slotViewCleared()
+{
+  if(m_widget->inherits(TQSCROLLVIEW_OBJECT_NAME_STRING) ) {
+#ifdef DEBUG_LAYOUT
+      kdDebug(6031) << "iframe is a scrollview!" << endl;
+#endif
+      TQScrollView *view = static_cast<TQScrollView *>(m_widget);
+      int frameStyle = TQFrame::NoFrame;
+      TQScrollView::ScrollBarMode scroll = TQScrollView::Auto;
+      int marginw = -1;
+      int marginh = -1;
+      if ( element()->id() == ID_IFRAME) {
+	  HTMLIFrameElementImpl *frame = static_cast<HTMLIFrameElementImpl *>(element());
+	  if(frame->frameBorder)
+	      frameStyle = TQFrame::Box;
+	  scroll = frame->scrolling;
+	  marginw = frame->marginWidth;
+	  marginh = frame->marginHeight;
+      }
+      view->setFrameStyle(frameStyle);
+      view->setVScrollBarMode(scroll );
+      view->setHScrollBarMode(scroll );
+      if(view->inherits("KHTMLView")) {
+#ifdef DEBUG_LAYOUT
+          kdDebug(6031) << "frame is a KHTMLview!" << endl;
+#endif
+          KHTMLView *htmlView = static_cast<KHTMLView *>(view);
+          htmlView->setIgnoreWheelEvents( element()->id() == ID_IFRAME );
+          if(marginw != -1) htmlView->setMarginWidth(marginw);
+          if(marginh != -1) htmlView->setMarginHeight(marginh);
+        }
+  }
+}
+
+
+#include "render_frames.moc"