Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 1398 insertions, 0 deletions

diff --git a/konqueror/konq_view.cpp b/konqueror/konq_view.cpp
new file mode 100644
index 000000000..3a970018b
--- /dev/null
+++ b/konqueror/konq_view.cpp
@@ -0,0 +1,1398 @@
+/*
+   This file is part of the KDE project
+   Copyright (C) 1998-2005 David Faure <faure@kde.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This program 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
+    General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+
+#include "konq_view.h"
+#include "tdeapplication.h"
+#include "KonqViewIface.h"
+#include "konq_settingsxt.h"
+#include "konq_frame.h"
+#include "konq_run.h"
+#include "konq_events.h"
+#include "konq_viewmgr.h"
+#include "konq_tabs.h"
+#include "konq_browseriface.h"
+#include <tdeparts/statusbarextension.h>
+#include <tdeparts/browserextension.h>
+
+#include <konq_historymgr.h>
+#include <konq_pixmapprovider.h>
+
+#include <assert.h>
+#include <kdebug.h>
+#include <kcursor.h>
+#include <kurldrag.h>
+#include <tqscrollview.h>
+
+#include <tqapplication.h>
+#include <tqmetaobject.h>
+#include <tqobjectlist.h>
+#include <config.h>
+#include <tqucomextra_p.h>
+#include <tdemessagebox.h>
+#include <tdelocale.h>
+
+#include <fixx11h.h>
+
+//#define DEBUG_HISTORY
+
+template class TQPtrList<HistoryEntry>;
+
+KonqView::KonqView( KonqViewFactory &viewFactory,
+                    KonqFrame* viewFrame,
+                    KonqMainWindow *mainWindow,
+                    const KService::Ptr &service,
+                    const TDETrader::OfferList &partServiceOffers,
+                    const TDETrader::OfferList &appServiceOffers,
+                    const TQString &serviceType,
+                    bool passiveMode
+                    )
+{
+  m_pKonqFrame = viewFrame;
+  m_pKonqFrame->setView( this );
+
+  m_sLocationBarURL = "";
+  m_pageSecurity = KonqMainWindow::NotCrypted;
+  m_bLockHistory = false;
+  m_doPost = false;
+  m_pMainWindow = mainWindow;
+  m_pRun = 0L;
+  m_pPart = 0L;
+  m_dcopObject = 0L;
+
+  m_randID = TDEApplication::random();
+
+  m_service = service;
+  m_partServiceOffers = partServiceOffers;
+  m_appServiceOffers = appServiceOffers;
+  m_serviceType = serviceType;
+
+  m_bAllowHTML = m_pMainWindow->isHTMLAllowed();
+  m_lstHistory.setAutoDelete( true );
+  m_bLoading = false;
+  m_bPendingRedirection = false;
+  m_bPassiveMode = passiveMode;
+  m_bLockedLocation = false;
+  m_bLinkedView = false;
+  m_bAborted = false;
+  m_bToggleView = false;
+  m_bHierarchicalView = false;
+  m_bDisableScrolling = false;
+  m_bGotIconURL = false;
+  m_bPopupMenuEnabled = true;
+  m_browserIface = new KonqBrowserInterface( this, "browseriface" );
+  m_bBackRightClick = KonqSettings::backRightClick();
+  m_bFollowActive = false;
+  m_bBuiltinView = false;
+  m_bURLDropHandling = false;
+
+  switchView( viewFactory );
+}
+
+KonqView::~KonqView()
+{
+  //kdDebug(1202) << "KonqView::~KonqView : part = " << m_pPart << endl;
+
+  if (KonqMainWindow::s_crashlog_file) {
+     TQString part_url;
+     if (m_pPart)
+        part_url = m_pPart->url().url();
+     if (part_url.isNull())
+        part_url = "";
+     TQCString line;
+     line = ( TQString("close(%1):%2\n").arg(m_randID,0,16).arg(part_url) ).utf8();
+     KonqMainWindow::s_crashlog_file->writeBlock(line, line.length());
+     KonqMainWindow::s_crashlog_file->flush();
+  }
+
+  // We did so ourselves for passive views
+  if (m_pPart != 0L)
+  {
+    finishedWithCurrentURL();
+    if ( isPassiveMode() )
+      disconnect( m_pPart, TQT_SIGNAL( destroyed() ), m_pMainWindow->viewManager(), TQT_SLOT( slotObjectDestroyed() ) );
+
+    delete m_pPart;
+  }
+
+  setRun( 0L );
+  //kdDebug(1202) << "KonqView::~KonqView " << this << " done" << endl;
+}
+
+void KonqView::openURL( const KURL &url, const TQString & locationBarURL,
+                        const TQString & nameFilter, bool tempFile )
+{
+  kdDebug(1202) << "KonqView::openURL url=" << url << " locationBarURL=" << locationBarURL << endl;
+  setServiceTypeInExtension();
+
+  if (KonqMainWindow::s_crashlog_file) {
+     TQString part_url;
+     if (m_pPart)
+        part_url = m_pPart->url().url();
+     if (part_url.isNull())
+        part_url = "";
+
+     TQString url_url = url.url();
+     if (url_url.isNull())
+        url_url = TQString("");
+
+     TQCString line;
+
+     line = ( TQString("closed(%1):%2\n").arg(m_randID,0,16).arg(part_url) ).utf8();
+     KonqMainWindow::s_crashlog_file->writeBlock(line,line.length());
+     line = ( TQString("opened(%3):%4\n").arg(m_randID,0,16).arg(url_url)  ).utf8();
+     KonqMainWindow::s_crashlog_file->writeBlock(line,line.length());
+     KonqMainWindow::s_crashlog_file->flush();
+  }
+
+  KParts::BrowserExtension *ext = browserExtension();
+  KParts::URLArgs args;
+  if ( ext )
+    args = ext->urlArgs();
+
+  // Typing "Enter" again after the URL of an aborted view, triggers a reload.
+  if ( m_bAborted && m_pPart && m_pPart->url() == url && !args.doPost())
+  {
+    if ( !prepareReload( args ) )
+      return;
+    if ( ext )
+      ext->setURLArgs( args );
+  }
+
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "m_bLockedLocation=" << m_bLockedLocation << " args.lockHistory()=" << args.lockHistory() << endl;
+#endif
+  if ( args.lockHistory() )
+    lockHistory();
+
+  if ( !m_bLockHistory )
+  {
+    // Store this new URL in the history, removing any existing forward history.
+    // We do this first so that everything is ready if a part calls completed().
+    createHistoryEntry();
+  } else
+    m_bLockHistory = false;
+
+  callExtensionStringMethod( "setNameFilter(const TQString&)", nameFilter );
+  if ( m_bDisableScrolling )
+    callExtensionMethod( "disableScrolling()" );
+
+  setLocationBarURL( locationBarURL );
+  setPageSecurity(KonqMainWindow::NotCrypted);
+
+  if ( !args.reload )
+  {
+    // Save the POST data that is necessary to open this URL
+    // (so that reload can re-post it)
+    m_doPost = args.doPost();
+    m_postContentType = args.contentType();
+    m_postData = args.postData;
+    // Save the referrer
+    m_pageReferrer = args.metaData()["referrer"];
+  }
+
+  if ( tempFile ) {
+      // Store the path to the tempfile. Yes, we could store a bool only,
+      // but this would be more dangerous. If anything goes wrong in the code,
+      // we might end up deleting a real file.
+      if ( url.isLocalFile() )
+          m_tempFile = url.path();
+      else
+          kdWarning(1202) << "Tempfile option is set, but URL is remote: " << url << endl;
+  }
+
+  aboutToOpenURL( url, args );
+
+  m_pPart->openURL( url );
+
+  updateHistoryEntry(false /* don't save location bar URL yet */);
+  // add pending history entry
+  KonqHistoryManager::kself()->addPending( url, locationBarURL, TQString::null);
+
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "Current position : " << m_lstHistory.at() << endl;
+#endif
+}
+
+void KonqView::switchView( KonqViewFactory &viewFactory )
+{
+  kdDebug(1202) << "KonqView::switchView" << endl;
+  if ( m_pPart )
+    m_pPart->widget()->hide();
+
+  KParts::ReadOnlyPart *oldPart = m_pPart;
+  m_pPart = m_pKonqFrame->attach( viewFactory ); // creates the part
+
+  // Set the statusbar in the BE asap to avoid a TDEMainWindow statusbar being created.
+  KParts::StatusBarExtension* sbext = statusBarExtension();
+  if ( sbext )
+    sbext->setStatusBar( frame()->statusbar() );
+
+  // Activate the new part
+  if ( oldPart )
+  {
+    m_pPart->setName( oldPart->name() );
+    emit sigPartChanged( this, oldPart, m_pPart );
+    delete oldPart;
+  }
+
+  connectPart();
+
+  TQVariant prop;
+
+  prop = m_service->property( "X-TDE-BrowserView-FollowActive");
+  if (prop.isValid() && prop.toBool())
+  {
+    //kdDebug(1202) << "KonqView::switchView X-TDE-BrowserView-FollowActive -> setFollowActive" <<endl;
+    setFollowActive(true);
+  }
+
+  prop = m_service->property( "X-TDE-BrowserView-Built-Into" );
+  m_bBuiltinView = (prop.isValid() && prop.toString() == "konqueror");
+
+  if ( !m_pMainWindow->viewManager()->isLoadingProfile() )
+  {
+    // Honour "non-removeable passive mode" (like the dirtree)
+    prop = m_service->property( "X-TDE-BrowserView-PassiveMode");
+    if ( prop.isValid() && prop.toBool() )
+    {
+      kdDebug(1202) << "KonqView::switchView X-TDE-BrowserView-PassiveMode -> setPassiveMode" << endl;
+      setPassiveMode( true ); // set as passive
+    }
+
+    // Honour "linked view"
+    prop = m_service->property( "X-TDE-BrowserView-LinkedView");
+    if ( prop.isValid() && prop.toBool() )
+    {
+      setLinkedView( true ); // set as linked
+      // Two views : link both
+      if (m_pMainWindow->viewCount() <= 2) // '1' can happen if this view is not yet in the map
+      {
+        KonqView * otherView = m_pMainWindow->otherView( this );
+        if (otherView)
+          otherView->setLinkedView( true );
+      }
+    }
+  }
+
+  prop = m_service->property( "X-TDE-BrowserView-HierarchicalView");
+  if ( prop.isValid() && prop.toBool() )
+  {
+    kdDebug() << "KonqView::switchView X-TDE-BrowserView-HierarchicalView -> setHierarchicalView" << endl;
+    setHierarchicalView( true );  // set as hierarchial
+  }
+  else
+  {
+    setHierarchicalView( false );
+  }
+}
+
+bool KonqView::changeViewMode( const TQString &serviceType,
+                               const TQString &serviceName,
+                               bool forceAutoEmbed )
+{
+  // Caller should call stop first.
+  assert ( !m_bLoading );
+
+  kdDebug(1202) << "changeViewMode: serviceType is " << serviceType
+                << " serviceName is " << serviceName
+                << " current service name is " << m_service->desktopEntryName() << endl;
+
+  if ( KMimeType::mimeType(serviceType)->is(m_serviceType) && (serviceName.isEmpty() || serviceName == m_service->desktopEntryName()) )
+    return true;
+
+  if ( isLockedViewMode() )
+  {
+    //kdDebug(1202) << "This view's mode is locked - can't change" << endl;
+    return false; // we can't do that if our view mode is locked
+  }
+
+  kdDebug(1202) << "Switching view modes..." << endl;
+  TDETrader::OfferList partServiceOffers, appServiceOffers;
+  KService::Ptr service = 0L;
+  KonqViewFactory viewFactory = KonqFactory::createView( serviceType, serviceName, &service, &partServiceOffers, &appServiceOffers, forceAutoEmbed );
+
+  if ( viewFactory.isNull() )
+  {
+    // Revert location bar's URL to the working one
+    if(history().current())
+      setLocationBarURL( history().current()->locationBarURL );
+    return false;
+  }
+
+  m_serviceType = serviceType;
+  m_partServiceOffers = partServiceOffers;
+  m_appServiceOffers = appServiceOffers;
+
+  // Check if that's already the kind of part we have -> no need to recreate it
+  // Note: we should have an operator= for KService...
+  if ( m_service && m_service->desktopEntryPath() == service->desktopEntryPath() )
+  {
+    kdDebug( 1202 ) << "KonqView::changeViewMode. Reusing service. Service type set to " << m_serviceType << endl;
+    if (  m_pMainWindow->currentView() == this )
+      m_pMainWindow->updateViewModeActions();
+  }
+  else
+  {
+    m_service = service;
+
+    switchView( viewFactory );
+  }
+
+  if ( m_pMainWindow->viewManager()->activePart() != m_pPart )
+  {
+    // Make the new part active. Note that we don't do it each time we
+    // open a URL (becomes awful in view-follows-view mode), but we do
+    // each time we change the view mode.
+    // We don't do it in switchView either because it's called from the constructor too,
+    // where the location bar url isn't set yet.
+    //kdDebug(1202) << "Giving focus to new part " << m_pPart << endl;
+    m_pMainWindow->viewManager()->setActivePart( m_pPart );
+  }
+  return true;
+}
+
+void KonqView::connectPart(  )
+{
+  //kdDebug(1202) << "KonqView::connectPart" << endl;
+  connect( m_pPart, TQT_SIGNAL( started( TDEIO::Job * ) ),
+           this, TQT_SLOT( slotStarted( TDEIO::Job * ) ) );
+  connect( m_pPart, TQT_SIGNAL( completed() ),
+           this, TQT_SLOT( slotCompleted() ) );
+  connect( m_pPart, TQT_SIGNAL( completed(bool) ),
+           this, TQT_SLOT( slotCompleted(bool) ) );
+  connect( m_pPart, TQT_SIGNAL( canceled( const TQString & ) ),
+           this, TQT_SLOT( slotCanceled( const TQString & ) ) );
+  connect( m_pPart, TQT_SIGNAL( setWindowCaption( const TQString & ) ),
+           this, TQT_SLOT( setCaption( const TQString & ) ) );
+
+  KParts::BrowserExtension *ext = browserExtension();
+
+  if ( ext )
+  {
+      ext->setBrowserInterface( m_browserIface );
+
+      connect( ext, TQT_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs &) ),
+               m_pMainWindow, TQT_SLOT( slotOpenURLRequest( const KURL &, const KParts::URLArgs & ) ) );
+
+      if ( m_bPopupMenuEnabled )
+      {
+          m_bPopupMenuEnabled = false; // force
+          enablePopupMenu( true );
+      }
+
+      connect( ext, TQT_SIGNAL( setLocationBarURL( const TQString & ) ),
+               this, TQT_SLOT( setLocationBarURL( const TQString & ) ) );
+
+      connect( ext, TQT_SIGNAL( setIconURL( const KURL & ) ),
+               this, TQT_SLOT( setIconURL( const KURL & ) ) );
+
+      connect( ext, TQT_SIGNAL( setPageSecurity( int ) ),
+               this, TQT_SLOT( setPageSecurity( int ) ) );
+
+      connect( ext, TQT_SIGNAL( createNewWindow( const KURL &, const KParts::URLArgs & ) ),
+               m_pMainWindow, TQT_SLOT( slotCreateNewWindow( const KURL &, const KParts::URLArgs & ) ) );
+
+      connect( ext, TQT_SIGNAL( createNewWindow( const KURL &, const KParts::URLArgs &, const KParts::WindowArgs &, KParts::ReadOnlyPart *& ) ),
+               m_pMainWindow, TQT_SLOT( slotCreateNewWindow( const KURL &, const KParts::URLArgs &, const KParts::WindowArgs &, KParts::ReadOnlyPart *& ) ) );
+
+      connect( ext, TQT_SIGNAL( loadingProgress( int ) ),
+               m_pKonqFrame->statusbar(), TQT_SLOT( slotLoadingProgress( int ) ) );
+
+      connect( ext, TQT_SIGNAL( speedProgress( int ) ),
+               m_pKonqFrame->statusbar(), TQT_SLOT( slotSpeedProgress( int ) ) );
+
+      connect( ext, TQT_SIGNAL( selectionInfo( const KFileItemList & ) ),
+               this, TQT_SLOT( slotSelectionInfo( const KFileItemList & ) ) );
+
+      connect( ext, TQT_SIGNAL( mouseOverInfo( const KFileItem * ) ),
+               this, TQT_SLOT( slotMouseOverInfo( const KFileItem * ) ) );
+
+      connect( ext, TQT_SIGNAL( openURLNotify() ),
+               this, TQT_SLOT( slotOpenURLNotify() ) );
+
+      connect( ext, TQT_SIGNAL( enableAction( const char *, bool ) ),
+               this, TQT_SLOT( slotEnableAction( const char *, bool ) ) );
+
+      connect( ext, TQT_SIGNAL( setActionText( const char *, const TQString& ) ),
+               this, TQT_SLOT( slotSetActionText( const char *, const TQString& ) ) );
+
+      connect( ext, TQT_SIGNAL( moveTopLevelWidget( int, int ) ),
+               this, TQT_SLOT( slotMoveTopLevelWidget( int, int ) ) );
+
+      connect( ext, TQT_SIGNAL( resizeTopLevelWidget( int, int ) ),
+               this, TQT_SLOT( slotResizeTopLevelWidget( int, int ) ) );
+
+      connect( ext, TQT_SIGNAL( requestFocus(KParts::ReadOnlyPart *) ),
+               this, TQT_SLOT( slotRequestFocus(KParts::ReadOnlyPart *) ) );
+
+      if (service()->desktopEntryName() != "konq_sidebartng") {
+          connect( ext, TQT_SIGNAL( infoMessage( const TQString & ) ),
+               m_pKonqFrame->statusbar(), TQT_SLOT( message( const TQString & ) ) );
+
+          connect( ext,
+                   TQT_SIGNAL( addWebSideBar(const KURL&, const TQString&) ),
+                   m_pMainWindow,
+                   TQT_SLOT( slotAddWebSideBar(const KURL&, const TQString&) ) );
+      }
+
+      callExtensionBoolMethod( "setSaveViewPropertiesLocally(bool)", m_pMainWindow->saveViewPropertiesLocally() );
+  }
+
+  TQVariant urlDropHandling;
+
+  if ( ext )
+      urlDropHandling = ext->property( "urlDropHandling" );
+  else
+      urlDropHandling = TQVariant( true );
+
+  // Handle url drops if
+  //  a) either the property says "ok"
+  //  or
+  //  b) the part is a plain krop (no BE)
+  m_bURLDropHandling = ( urlDropHandling.type() == TQVariant::Bool &&
+                         urlDropHandling.toBool() );
+
+  m_pPart->widget()->installEventFilter( this );
+
+  if (m_bBackRightClick && m_pPart->widget()->inherits(TQSCROLLVIEW_OBJECT_NAME_STRING) )
+  {
+    (static_cast<TQScrollView *>(m_pPart->widget()))->viewport()->installEventFilter( this );
+  }
+
+  // KonqDirPart signal
+  if ( m_pPart->inherits("KonqDirPart") )
+  {
+      connect( m_pPart, TQT_SIGNAL( findOpen( KonqDirPart * ) ),
+               m_pMainWindow, TQT_SLOT( slotFindOpen( KonqDirPart * ) ) );
+  }
+}
+
+void KonqView::slotEnableAction( const char * name, bool enabled )
+{
+    if ( m_pMainWindow->currentView() == this )
+        m_pMainWindow->enableAction( name, enabled );
+    // Otherwise, we don't have to do anything, the state of the action is
+    // stored inside the browser-extension.
+}
+
+void KonqView::slotSetActionText( const char* name, const TQString& text )
+{
+    if ( m_pMainWindow->currentView() == this )
+        m_pMainWindow->setActionText( name, text );
+    // Otherwise, we don't have to do anything, the state of the action is
+    // stored inside the browser-extension.
+}
+
+void KonqView::slotMoveTopLevelWidget( int x, int y )
+{
+  KonqFrameContainerBase* container = frame()->parentContainer();
+  // If tabs are shown, only accept to move the whole window if there's only one tab.
+  if ( container->frameType() != "Tabs" || static_cast<KonqFrameTabs*>(container)->count() == 1 )
+    m_pMainWindow->move( x, y );
+}
+
+void KonqView::slotResizeTopLevelWidget( int w, int h )
+{
+  KonqFrameContainerBase* container = frame()->parentContainer();
+  // If tabs are shown, only accept to resize the whole window if there's only one tab.
+  // ### Maybe we could store the size requested by each tab and resize the window to the biggest one.
+  if ( container->frameType() != "Tabs" || static_cast<KonqFrameTabs*>(container)->count() == 1 )
+    m_pMainWindow->resize( w, h );
+}
+
+void KonqView::slotStarted( TDEIO::Job * job )
+{
+  //kdDebug(1202) << "KonqView::slotStarted"  << job << endl;
+  setLoading( true );
+
+  if (job)
+  {
+      // Manage passwords properly...
+      if (m_pMainWindow)
+      {
+        kdDebug(7035) << "slotStarted: Window ID = " << m_pMainWindow->topLevelWidget()->winId() << endl;
+        job->setWindow (m_pMainWindow->topLevelWidget ());
+      }
+
+      connect( job, TQT_SIGNAL( percent( TDEIO::Job *, unsigned long ) ), this, TQT_SLOT( slotPercent( TDEIO::Job *, unsigned long ) ) );
+      connect( job, TQT_SIGNAL( speed( TDEIO::Job *, unsigned long ) ), this, TQT_SLOT( slotSpeed( TDEIO::Job *, unsigned long ) ) );
+      connect( job, TQT_SIGNAL( infoMessage( TDEIO::Job *, const TQString & ) ), this, TQT_SLOT( slotInfoMessage( TDEIO::Job *, const TQString & ) ) );
+  }
+}
+
+void KonqView::slotRequestFocus( KParts::ReadOnlyPart * )
+{
+  m_pMainWindow->viewManager()->showTab(this);
+}
+
+void KonqView::setLoading( bool loading, bool hasPending /*= false*/)
+{
+    //kdDebug(1202) << "KonqView::setLoading loading=" << loading << " hasPending=" << hasPending << endl;
+    m_bLoading = loading;
+    m_bPendingRedirection = hasPending;
+    if ( m_pMainWindow->currentView() == this )
+        m_pMainWindow->updateToolBarActions( hasPending );
+
+    m_pMainWindow->viewManager()->setLoading( this, loading || hasPending );
+}
+
+void KonqView::slotPercent( TDEIO::Job *, unsigned long percent )
+{
+  m_pKonqFrame->statusbar()->slotLoadingProgress( percent );
+}
+
+void KonqView::slotSpeed( TDEIO::Job *, unsigned long bytesPerSecond )
+{
+  m_pKonqFrame->statusbar()->slotSpeedProgress( bytesPerSecond );
+}
+
+void KonqView::slotInfoMessage( TDEIO::Job *, const TQString &msg )
+{
+  m_pKonqFrame->statusbar()->message( msg );
+}
+
+void KonqView::slotCompleted()
+{
+   slotCompleted( false );
+}
+
+void KonqView::slotCompleted( bool hasPending )
+{
+  //kdDebug(1202) << "KonqView::slotCompleted hasPending=" << hasPending << endl;
+  m_pKonqFrame->statusbar()->slotLoadingProgress( -1 );
+
+  if ( ! m_bLockHistory )
+  {
+      // Success... update history entry, including location bar URL
+      updateHistoryEntry( true );
+
+      if ( m_bAborted ) // remove the pending entry on error
+          KonqHistoryManager::kself()->removePending( url() );
+      else if ( m_lstHistory.current() ) // register as proper history entry
+          KonqHistoryManager::kself()->confirmPending(url(), typedURL(),
+						      m_lstHistory.current()->title);
+
+      emit viewCompleted( this );
+  }
+  setLoading( false, hasPending );
+
+  if (!m_bGotIconURL && !m_bAborted)
+  {
+    if ( KonqSettings::enableFavicon() == true )
+    {
+      // Try to get /favicon.ico
+      if ( supportsServiceType( "text/html" ) && url().protocol().startsWith( "http" ) )
+          KonqPixmapProvider::downloadHostIcon( url() );
+    }
+  }
+}
+
+void KonqView::slotCanceled( const TQString & errorMsg )
+{
+  kdDebug(1202) << "KonqView::slotCanceled" << endl;
+  // The errorMsg comes from the ReadOnlyPart's job.
+  // It should probably be used in a KMessageBox
+  // Let's use the statusbar for now
+  m_pKonqFrame->statusbar()->message( errorMsg );
+  m_bAborted = true;
+  slotCompleted();
+}
+
+void KonqView::slotSelectionInfo( const KFileItemList &items )
+{
+  KonqFileSelectionEvent ev( items, m_pPart );
+  TQApplication::sendEvent( m_pMainWindow, &ev );
+}
+
+void KonqView::slotMouseOverInfo( const KFileItem *item )
+{
+  KonqFileMouseOverEvent ev( item, m_pPart );
+  TQApplication::sendEvent( m_pMainWindow, &ev );
+}
+
+void KonqView::setLocationBarURL( const KURL& locationBarURL )
+{
+  setLocationBarURL( locationBarURL.pathOrURL() );
+}
+
+void KonqView::setLocationBarURL( const TQString & locationBarURL )
+{
+  //kdDebug(1202) << "KonqView::setLocationBarURL " << locationBarURL << " this=" << this << endl;
+
+  m_sLocationBarURL = locationBarURL;
+  if ( m_pMainWindow->currentView() == this )
+  {
+    //kdDebug(1202) << "is current view " << this << endl;
+    m_pMainWindow->setLocationBarURL( m_sLocationBarURL );
+    m_pMainWindow->setPageSecurity( m_pageSecurity );
+  }
+  if (!m_bPassiveMode) setTabIcon( KURL::fromPathOrURL( m_sLocationBarURL ) );
+}
+
+void KonqView::setIconURL( const KURL & iconURL )
+// This function sets the favIcon in konqui's window if enabled,
+// thus it is responsible for the icon in the taskbar.
+// It does not set the tab's favIcon.
+{
+  kdDebug(1202) << "entering KonqView::setIconURL" << endl;
+  if ( KonqSettings::enableFavicon() )
+  {
+    KonqPixmapProvider::setIconForURL( KURL( m_sLocationBarURL ), iconURL );
+    m_bGotIconURL = true;
+  }
+}
+
+void KonqView::setPageSecurity( int pageSecurity )
+{
+  m_pageSecurity = (KonqMainWindow::PageSecurity)pageSecurity;
+
+  if ( m_pMainWindow->currentView() == this )
+    m_pMainWindow->setPageSecurity( m_pageSecurity );
+}
+
+void KonqView::setTabIcon( const KURL &url )
+{
+  if (!m_bPassiveMode) frame()->setTabIcon( url, 0L );
+}
+
+void KonqView::setCaption( const TQString & caption )
+{
+  if (caption.isEmpty()) return;
+
+  TQString adjustedCaption = caption;
+  // For local URLs we prefer to use only the directory name
+  if (url().isLocalFile())
+  {
+     // Is the caption a URL?  If so, is it local?  If so, only display the filename!
+     KURL url = KURL::fromPathOrURL(caption);
+     if (url.isValid() && url.isLocalFile() && url.fileName() == this->url().fileName())
+        adjustedCaption = url.fileName();
+  }
+
+  m_caption = adjustedCaption;
+  if (!m_bPassiveMode) frame()->setTitle( adjustedCaption , 0L );
+}
+
+void KonqView::slotOpenURLNotify()
+{
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "KonqView::slotOpenURLNotify" << endl;
+#endif
+  updateHistoryEntry(true);
+  createHistoryEntry();
+  if ( m_pMainWindow->currentView() == this )
+    m_pMainWindow->updateToolBarActions();
+}
+
+void KonqView::createHistoryEntry()
+{
+    // First, remove any forward history
+    HistoryEntry * current = m_lstHistory.current();
+    if (current)
+    {
+#ifdef DEBUG_HISTORY
+        kdDebug(1202) << "Truncating history" << endl;
+#endif
+        m_lstHistory.at( m_lstHistory.count() - 1 ); // go to last one
+        for ( ; m_lstHistory.current() != current ; )
+        {
+            if ( !m_lstHistory.removeLast() ) // and remove from the end (faster and easier)
+                assert(0);
+            // go to last one. The documentation says that removeLast()
+            // makes current() null if it's the last item. however in qt2
+            // the behaviour was different than the documentation. this is
+            // changed in qt3 to behave as documented ;-) (Simon)
+            m_lstHistory.at( m_lstHistory.count() - 1 );
+        }
+        // Now current is the current again.
+    }
+    // Append a new entry
+#ifdef DEBUG_HISTORY
+    kdDebug(1202) << "Append a new entry" << endl;
+#endif
+    m_lstHistory.append( new HistoryEntry ); // made current
+#ifdef DEBUG_HISTORY
+    kdDebug(1202) << "at=" << m_lstHistory.at() << " count=" << m_lstHistory.count() << endl;
+#endif
+    assert( m_lstHistory.at() == (int) m_lstHistory.count() - 1 );
+}
+
+void KonqView::updateHistoryEntry( bool saveLocationBarURL )
+{
+  Q_ASSERT( !m_bLockHistory ); // should never happen
+
+  HistoryEntry * current = m_lstHistory.current();
+  if ( !current )
+    return;
+
+  if ( browserExtension() )
+  {
+    current->buffer = TQByteArray(); // Start with empty buffer.
+    TQDataStream stream( current->buffer, IO_WriteOnly );
+
+    browserExtension()->saveState( stream );
+  }
+
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "Saving part URL : " << m_pPart->url() << " in history position " << m_lstHistory.at() << endl;
+#endif
+  current->url = m_pPart->url();
+
+  if (saveLocationBarURL)
+  {
+#ifdef DEBUG_HISTORY
+    kdDebug(1202) << "Saving location bar URL : " << m_sLocationBarURL << " in history position " << m_lstHistory.at() << endl;
+#endif
+    current->locationBarURL = m_sLocationBarURL;
+    current->pageSecurity = m_pageSecurity;
+  }
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "Saving title : " << m_caption << " in history position " << m_lstHistory.at() << endl;
+#endif
+  current->title = m_caption;
+  current->strServiceType = m_serviceType;
+  current->strServiceName = m_service->desktopEntryName();
+
+  current->doPost = m_doPost;
+  current->postData = m_doPost ? m_postData : TQByteArray();
+  current->postContentType = m_doPost ? m_postContentType : TQString::null;
+  current->pageReferrer = m_pageReferrer;
+}
+
+void KonqView::goHistory( int steps )
+{
+  // This is called by KonqBrowserInterface
+  if ( m_pMainWindow->currentView() == this )
+    m_pMainWindow->viewManager()->setActivePart( part() );
+
+  // Delay the go() call (we need to return to the caller first)
+  m_pMainWindow->slotGoHistoryActivated( steps );
+}
+
+void KonqView::go( int steps )
+{
+  if ( !steps ) // [WildFox] i bet there are sites on the net with stupid devs who do that :)
+  {
+#ifdef DEBUG_HISTORY
+      kdDebug(1202) << "KonqView::go(0)" << endl;
+#endif
+      // [David] and you're right. And they expect that it reloads, apparently.
+      // [George] I'm going to make nspluginviewer rely on this too. :-)
+      m_pMainWindow->slotReload();
+      return;
+  }
+
+  int newPos = m_lstHistory.at() + steps;
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "go : steps=" << steps
+                << " newPos=" << newPos
+                << " m_lstHistory.count()=" << m_lstHistory.count()
+                << endl;
+#endif
+  if( newPos < 0 || (uint)newPos >= m_lstHistory.count() )
+    return;
+
+  stop();
+
+  // Yay, we can move there without a loop !
+  HistoryEntry *currentHistoryEntry = m_lstHistory.at( newPos ); // sets current item
+
+  assert( currentHistoryEntry );
+  assert( newPos == m_lstHistory.at() ); // check we moved (i.e. if I understood the docu)
+  assert( currentHistoryEntry == m_lstHistory.current() );
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "New position " << m_lstHistory.at() << endl;
+#endif
+
+  restoreHistory();
+}
+
+void KonqView::restoreHistory()
+{
+  HistoryEntry h( *(m_lstHistory.current()) ); // make a copy of the current history entry, as the data
+                                          // the pointer points to will change with the following calls
+
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "Restoring servicetype/name, and location bar URL from history : " << h.locationBarURL << endl;
+#endif
+  setLocationBarURL( h.locationBarURL );
+  setPageSecurity( h.pageSecurity );
+  m_sTypedURL = TQString::null;
+  if ( ! changeViewMode( h.strServiceType, h.strServiceName ) )
+  {
+    kdWarning(1202) << "Couldn't change view mode to " << h.strServiceType
+                    << " " << h.strServiceName << endl;
+    return /*false*/;
+  }
+
+  setServiceTypeInExtension();
+
+  aboutToOpenURL( h.url );
+
+  if ( browserExtension() )
+  {
+    //kdDebug(1202) << "Restoring view from stream" << endl;
+    TQDataStream stream( h.buffer, IO_ReadOnly );
+
+    browserExtension()->restoreState( stream );
+
+    m_doPost = h.doPost;
+    m_postContentType = h.postContentType;
+    m_postData = h.postData;
+    m_pageReferrer = h.pageReferrer;
+  }
+  else
+    m_pPart->openURL( h.url );
+
+  if ( m_pMainWindow->currentView() == this )
+    m_pMainWindow->updateToolBarActions();
+
+#ifdef DEBUG_HISTORY
+  kdDebug(1202) << "New position (2) " << m_lstHistory.at() << endl;
+#endif
+}
+
+const HistoryEntry * KonqView::historyAt(const int pos)
+{
+    if(pos<0 || pos>=(int)m_lstHistory.count())
+	return 0L;
+    int oldpos = m_lstHistory.at();
+    const HistoryEntry* h = m_lstHistory.at(pos);
+    m_lstHistory.at( oldpos );
+    return h;
+}
+
+void KonqView::copyHistory( KonqView *other )
+{
+    m_lstHistory.clear();
+
+    TQPtrListIterator<HistoryEntry> it( other->m_lstHistory );
+    for (; it.current(); ++it )
+        m_lstHistory.append( new HistoryEntry( *it.current() ) );
+    m_lstHistory.at(other->m_lstHistory.at());
+}
+
+KURL KonqView::url() const
+{
+  assert( m_pPart );
+  return m_pPart->url();
+}
+
+KURL KonqView::upURL() const
+{
+    KURL currentURL;
+    if ( m_pRun )
+	currentURL = m_pRun->url();
+    else
+	currentURL = KURL::fromPathOrURL( m_sLocationBarURL );
+    return currentURL.upURL();
+}
+
+void KonqView::setRun( KonqRun * run )
+{
+  if ( m_pRun )
+  {
+    // Tell the KonqRun to abort, but don't delete it ourselves.
+    // It could be showing a message box right now. It will delete itself anyway.
+    m_pRun->abort();
+    // finish() will be emitted later (when back to event loop)
+    // and we don't want it to call slotRunFinished (which stops the animation and stop button).
+    m_pRun->disconnect( m_pMainWindow );
+    if ( !run )
+        frame()->unsetCursor();
+  }
+  else if ( run )
+      frame()->setCursor( KCursor::workingCursor() );
+  m_pRun = run;
+}
+
+void KonqView::stop()
+{
+  //kdDebug(1202) << "KonqView::stop()" << endl;
+  m_bAborted = false;
+  finishedWithCurrentURL();
+  if ( m_bLoading || m_bPendingRedirection )
+  {
+    // aborted -> confirm the pending url. We might as well remove it, but
+    // we decided to keep it :)
+    KonqHistoryManager::kself()->confirmPending( url(), m_sTypedURL );
+
+    //kdDebug(1202) << "m_pPart->closeURL()" << endl;
+    m_pPart->closeURL();
+    m_bAborted = true;
+    m_pKonqFrame->statusbar()->slotLoadingProgress( -1 );
+    setLoading( false, false );
+  }
+  if ( m_pRun )
+  {
+    // Revert to working URL - unless the URL was typed manually
+    // This is duplicated with KonqMainWindow::slotRunFinished, but we can't call it
+    //   since it relies on sender()...
+    if ( history().current() && m_pRun->typedURL().isEmpty() ) { // not typed
+      setLocationBarURL( history().current()->locationBarURL );
+      setPageSecurity( history().current()->pageSecurity );
+    }
+
+    setRun( 0L );
+    m_pKonqFrame->statusbar()->slotLoadingProgress( -1 );
+  }
+  if ( !m_bLockHistory && m_lstHistory.count() > 0 )
+    updateHistoryEntry(true);
+}
+
+void KonqView::finishedWithCurrentURL()
+{
+  if ( !m_tempFile.isEmpty() )
+  {
+    kdDebug(1202) << "######### Deleting tempfile after use:" << m_tempFile << endl;
+    TQFile::remove( m_tempFile );
+    m_tempFile = TQString::null;
+  }
+}
+
+void KonqView::setPassiveMode( bool mode )
+{
+  // In theory, if m_bPassiveMode is true and mode is false,
+  // the part should be removed from the part manager,
+  // and if the other way round, it should be readded to the part manager...
+  m_bPassiveMode = mode;
+
+  if ( mode && m_pMainWindow->viewCount() > 1 && m_pMainWindow->currentView() == this )
+  {
+   KParts::Part * part = m_pMainWindow->viewManager()->chooseNextView( this )->part(); // switch active part
+   m_pMainWindow->viewManager()->setActivePart( part );
+  }
+
+  // Update statusbar stuff
+  m_pMainWindow->viewManager()->viewCountChanged();
+}
+
+void KonqView::setHierarchicalView( bool mode )
+{
+ m_bHierarchicalView=mode;
+}
+
+
+
+void KonqView::setLinkedView( bool mode )
+{
+  m_bLinkedView = mode;
+  if ( m_pMainWindow->currentView() == this )
+    m_pMainWindow->linkViewAction()->setChecked( mode );
+  frame()->statusbar()->setLinkedView( mode );
+}
+
+void KonqView::setLockedLocation( bool b )
+{
+  m_bLockedLocation = b;
+}
+
+void KonqView::aboutToOpenURL( const KURL &url, const KParts::URLArgs &args )
+{
+  KParts::OpenURLEvent ev( m_pPart, url, args );
+  TQApplication::sendEvent( m_pMainWindow, &ev );
+
+  m_bGotIconURL = false;
+  m_bAborted = false;
+}
+
+void KonqView::setServiceTypeInExtension()
+{
+  KParts::BrowserExtension *ext = browserExtension();
+  if ( !ext )
+    return;
+
+  KParts::URLArgs args( ext->urlArgs() );
+  args.serviceType = m_serviceType;
+  ext->setURLArgs( args );
+}
+
+TQStringList KonqView::frameNames() const
+{
+  return childFrameNames( m_pPart );
+}
+
+TQStringList KonqView::childFrameNames( KParts::ReadOnlyPart *part )
+{
+  TQStringList res;
+
+  KParts::BrowserHostExtension *hostExtension = KParts::BrowserHostExtension::childObject( part );
+
+  if ( !hostExtension )
+    return res;
+
+  res += hostExtension->frameNames();
+
+  const TQPtrList<KParts::ReadOnlyPart> children = hostExtension->frames();
+  TQPtrListIterator<KParts::ReadOnlyPart> it( children );
+  for (; it.current(); ++it )
+    res += childFrameNames( it.current() );
+
+  return res;
+}
+
+KParts::BrowserHostExtension* KonqView::hostExtension( KParts::ReadOnlyPart *part, const TQString &name )
+{
+    KParts::BrowserHostExtension *ext = KParts::BrowserHostExtension::childObject( part );
+
+  if ( !ext )
+    return 0;
+
+  if ( ext->frameNames().contains( name ) )
+    return ext;
+
+  const TQPtrList<KParts::ReadOnlyPart> children = ext->frames();
+  TQPtrListIterator<KParts::ReadOnlyPart> it( children );
+  for (; it.current(); ++it )
+  {
+    KParts::BrowserHostExtension *childHost = hostExtension( it.current(), name );
+    if ( childHost )
+      return childHost;
+  }
+
+  return 0;
+}
+
+bool KonqView::callExtensionMethod( const char *methodName )
+{
+  TQObject *obj = KParts::BrowserExtension::childObject( m_pPart );
+  if ( !obj ) // not all views have a browser extension !
+    return false;
+
+  int id = obj->metaObject()->findSlot( methodName );
+  if ( id == -1 )
+    return false;
+  TQUObject o[ 1 ];
+
+  obj->tqt_invoke( id, o );
+  return true;
+}
+
+bool KonqView::callExtensionBoolMethod( const char *methodName, bool value )
+{
+  TQObject *obj = KParts::BrowserExtension::childObject( m_pPart );
+  if ( !obj ) // not all views have a browser extension !
+    return false;
+
+  int id = obj->metaObject()->findSlot( methodName );
+  if ( id == -1 )
+    return false;
+  TQUObject o[ 2 ];
+
+  static_TQUType_bool.set( o + 1, value );
+
+  obj->tqt_invoke( id, o );
+  return true;
+}
+
+bool KonqView::callExtensionStringMethod( const char *methodName, TQString value )
+{
+  TQObject *obj = KParts::BrowserExtension::childObject( m_pPart );
+  if ( !obj ) // not all views have a browser extension !
+    return false;
+
+  int id = obj->metaObject()->findSlot( methodName );
+  if ( id == -1 )
+    return false;
+  TQUObject o[ 2 ];
+
+  static_TQUType_TQString.set( o + 1, value );
+
+  obj->tqt_invoke( id, o );
+  return true;
+}
+
+bool KonqView::callExtensionURLMethod( const char *methodName, const KURL& value )
+{
+  TQObject *obj = KParts::BrowserExtension::childObject( m_pPart );
+  if ( !obj ) // not all views have a browser extension !
+    return false;
+
+  int id = obj->metaObject()->findSlot( methodName );
+  if ( id == -1 )
+    return false;
+  TQUObject o[ 2 ];
+
+  static_TQUType_ptr.set( o + 1, &value );
+
+  obj->tqt_invoke( id, o );
+  return true;
+}
+
+void KonqView::setViewName( const TQString &name )
+{
+    //kdDebug() << "KonqView::setViewName this=" << this << " name=" << name << endl;
+    if ( m_pPart )
+        m_pPart->setName( name.local8Bit().data() );
+}
+
+TQString KonqView::viewName() const
+{
+    return m_pPart ? TQString::fromLocal8Bit( m_pPart->name() ) : TQString();
+}
+
+void KonqView::enablePopupMenu( bool b )
+{
+  Q_ASSERT( m_pMainWindow );
+
+  KParts::BrowserExtension *ext = browserExtension();
+
+  if ( !ext )
+    return;
+
+  if ( m_bPopupMenuEnabled == b )
+      return;
+
+  // enable context popup
+  if ( b ) {
+    m_bPopupMenuEnabled = true;
+
+    connect( ext, TQT_SIGNAL( popupMenu( const TQPoint &, const KFileItemList & ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( const TQPoint &, const KFileItemList & ) ) );
+
+    connect( ext, TQT_SIGNAL( popupMenu( const TQPoint &, const KURL &, const TQString &, mode_t ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( const TQPoint &, const KURL &, const TQString &, mode_t ) ) );
+
+    connect( ext, TQT_SIGNAL( popupMenu( KXMLGUIClient *, const TQPoint &, const KFileItemList & ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( KXMLGUIClient *, const TQPoint &, const KFileItemList & ) ) );
+
+    connect( ext, TQT_SIGNAL( popupMenu( KXMLGUIClient *, const TQPoint &, const KFileItemList &, const KParts::URLArgs &, KParts::BrowserExtension::PopupFlags ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( KXMLGUIClient *, const TQPoint &, const KFileItemList &, const KParts::URLArgs &, KParts::BrowserExtension::PopupFlags ) ) );
+
+    connect( ext, TQT_SIGNAL( popupMenu( KXMLGUIClient *, const TQPoint &, const KURL &, const TQString &, mode_t ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( KXMLGUIClient *, const TQPoint &, const KURL &, const TQString &, mode_t ) ) );
+
+    connect( ext, TQT_SIGNAL( popupMenu( KXMLGUIClient *, const TQPoint &, const KURL &, const KParts::URLArgs &, KParts::BrowserExtension::PopupFlags, mode_t ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( KXMLGUIClient *, const TQPoint &, const KURL &, const KParts::URLArgs &, KParts::BrowserExtension::PopupFlags, mode_t ) ) );
+  }
+  else // disable context popup
+  {
+    m_bPopupMenuEnabled = false;
+
+    disconnect( ext, TQT_SIGNAL( popupMenu( const TQPoint &, const KFileItemList & ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( const TQPoint &, const KFileItemList & ) ) );
+
+    disconnect( ext, TQT_SIGNAL( popupMenu( const TQPoint &, const KURL &, const TQString &, mode_t ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( const TQPoint &, const KURL &, const TQString &, mode_t ) ) );
+
+    disconnect( ext, TQT_SIGNAL( popupMenu( KXMLGUIClient *, const TQPoint &, const KFileItemList & ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( KXMLGUIClient *, const TQPoint &, const KFileItemList & ) ) );
+
+    disconnect( ext, TQT_SIGNAL( popupMenu( KXMLGUIClient *, const TQPoint &, const KURL &, const TQString &, mode_t ) ),
+             m_pMainWindow, TQT_SLOT( slotPopupMenu( KXMLGUIClient *, const TQPoint &, const KURL &, const TQString &, mode_t ) ) );
+  }
+  enableBackRightClick( m_bBackRightClick );
+}
+
+// caller should ensure that this is called only when b changed, or for new parts
+void KonqView::enableBackRightClick( bool b )
+{
+    m_bBackRightClick = b;
+    if ( b )
+        connect( this, TQT_SIGNAL( backRightClick() ),
+                 m_pMainWindow, TQT_SLOT( slotBack() ) );
+    else
+        disconnect( this, TQT_SIGNAL( backRightClick() ),
+                    m_pMainWindow, TQT_SLOT( slotBack() ) );
+}
+
+void KonqView::reparseConfiguration()
+{
+    callExtensionMethod( "reparseConfiguration()" );
+    bool b = KonqSettings::backRightClick();
+    if ( m_bBackRightClick != b )
+    {
+        if (m_bBackRightClick && m_pPart->widget()->inherits(TQSCROLLVIEW_OBJECT_NAME_STRING) )
+        {
+            (static_cast<TQScrollView *>(m_pPart->widget()))->viewport()->installEventFilter( this );
+        }
+        enableBackRightClick( b );
+    }
+}
+
+void KonqView::disableScrolling()
+{
+  m_bDisableScrolling = true;
+  callExtensionMethod( "disableScrolling()" );
+}
+
+KonqViewIface * KonqView::dcopObject()
+{
+  if ( !m_dcopObject ) {
+    TQCString dcopName = name();
+    if ( dcopName.isEmpty() || dcopName == "unnamed" )
+      dcopName = viewName().utf8();
+    if ( dcopName.isEmpty() || dcopName == "unnamed" ) {
+      TQVariant dcopProperty = part()->property( "dcopObjectId" );
+      if ( dcopProperty.type() == TQVariant::CString )
+        dcopName = dcopProperty.toCString();
+    }
+    dcopName += "-view"; // to avoid having the same name as the part
+    m_dcopObject = new KonqViewIface( this, dcopName );
+  }
+  return m_dcopObject;
+}
+
+bool KonqView::eventFilter( TQObject *obj, TQEvent *e )
+{
+    if ( !m_pPart )
+        return false;
+//  kdDebug() << "--" << obj->className() << "--" << e->type() << "--"  << endl;
+    if ( e->type() == TQEvent::DragEnter && m_bURLDropHandling && TQT_BASE_OBJECT(obj) == TQT_BASE_OBJECT(m_pPart->widget()) )
+    {
+        TQDragEnterEvent *ev = static_cast<TQDragEnterEvent *>( e );
+
+        if ( KURLDrag::canDecode( ev ) )
+        {
+            KURL::List lstDragURLs;
+            bool ok = KURLDrag::decode( ev, lstDragURLs );
+
+            TQObjectList *children = m_pPart->widget()->queryList( TQWIDGET_OBJECT_NAME_STRING );
+
+            if ( ok &&
+                 !lstDragURLs.first().url().contains( "javascript:", false ) && // ### this looks like a hack to me
+                 ev->source() != m_pPart->widget() &&
+                 children &&
+                 children->findRef( TQT_TQOBJECT(ev->source()) ) == -1 )
+                ev->acceptAction();
+
+            delete children;
+        }
+    }
+    else if ( e->type() == TQEvent::Drop && m_bURLDropHandling && TQT_BASE_OBJECT(obj) == TQT_BASE_OBJECT(m_pPart->widget()) )
+    {
+        TQDropEvent *ev = static_cast<TQDropEvent *>( e );
+
+        KURL::List lstDragURLs;
+        bool ok = KURLDrag::decode( ev, lstDragURLs );
+
+        KParts::BrowserExtension *ext = browserExtension();
+        if ( ok && ext && lstDragURLs.first().isValid() )
+            emit ext->openURLRequest( lstDragURLs.first() ); // this will call m_pMainWindow::slotOpenURLRequest delayed
+    }
+
+    if ( m_bBackRightClick )
+    {
+        if ( e->type() == TQEvent::ContextMenu )
+        {
+            TQContextMenuEvent *ev = TQT_TQCONTEXTMENUEVENT( e );
+            if ( ev->reason() == TQContextMenuEvent::Mouse )
+            {
+                return true;
+            }
+        }
+        else if ( e->type() == TQEvent::MouseButtonPress )
+        {
+            TQMouseEvent *ev = TQT_TQMOUSEEVENT( e );
+            if ( ev->button() == Qt::RightButton )
+            {
+                return true;
+            }
+        }
+        else if ( e->type() == TQEvent::MouseButtonRelease )
+        {
+            TQMouseEvent *ev = TQT_TQMOUSEEVENT( e );
+            if ( ev->button() == Qt::RightButton )
+            {
+                emit backRightClick();
+                return true;
+            }
+        }
+        else if ( e->type() == TQEvent::MouseMove )
+        {
+            TQMouseEvent *ev = TQT_TQMOUSEEVENT( e );
+            if ( ev->state() == Qt::RightButton )
+            {
+                obj->removeEventFilter( this );
+                TQMouseEvent me( TQEvent::MouseButtonPress, ev->pos(), 2, 2 );
+                TQApplication::sendEvent( obj, &me );
+                TQContextMenuEvent ce( TQContextMenuEvent::Mouse, ev->pos(), 2 );
+                TQApplication::sendEvent( obj, &ce );
+                obj->installEventFilter( this );
+                return true;
+            }
+        }
+    }
+
+    if ( e->type() == TQEvent::FocusIn )
+    {
+        setActiveInstance();
+    }
+    return false;
+}
+
+void KonqView::setActiveInstance()
+{
+  if ( m_bBuiltinView || !m_pPart->instance() /*never!*/)
+      TDEGlobal::_activeInstance = TDEGlobal::instance();
+  else
+      TDEGlobal::_activeInstance = m_pPart->instance();
+}
+
+bool KonqView::prepareReload( KParts::URLArgs& args )
+{
+    args.reload = true;
+    // Repost form data if this URL is the result of a POST HTML form.
+    if ( m_doPost && !args.redirectedRequest() )
+    {
+        if ( KMessageBox::warningContinueCancel( 0, i18n(
+            "The page you are trying to view is the result of posted form data. "
+            "If you resend the data, any action the form carried out (such as search or online purchase) will be repeated. "),
+            i18n( "Warning" ), i18n( "Resend" ) ) == KMessageBox::Continue )
+        {
+            args.setDoPost( true );
+            args.setContentType( m_postContentType );
+            args.postData = m_postData;
+        }
+        else
+            return false;
+    }
+    // Re-set referrer
+    args.metaData()["referrer"] = m_pageReferrer;
+
+    return true;
+}
+
+KParts::BrowserExtension * KonqView::browserExtension() const
+{
+    return KParts::BrowserExtension::childObject( m_pPart );
+}
+
+KParts::StatusBarExtension * KonqView::statusBarExtension() const
+{
+    return KParts::StatusBarExtension::childObject( m_pPart );
+}
+
+bool KonqView::supportsServiceType( const TQString &serviceType ) const
+{
+    const TQStringList lst = serviceTypes();
+    for( TQStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
+        if ( *it == serviceType )
+            return true;
+        // Maybe we should keep around a list of KServiceType::Ptr?
+        KMimeType::Ptr mime = KMimeType::mimeType( *it );
+        if ( mime && mime->is( serviceType ) ) // respect inheritance
+            return true;
+    }
+    return false;
+}
+
+#include "konq_view.moc"