mghtml_part.cpp

monqueror一个很具有参考价值的源玛

		{
			n = n.parentNode();
			next = n.nextSibling();
		}
		n = next;
	}
	return text;
}

bool MGHTMLPart::hasSelection() const
{
	return ( !d->m_selectionStart.isNull() && !d->m_selectionEnd.isNull() );
}

DOM::Range MGHTMLPart::selection() const
{
	return DOM::Range();
}



void MGHTMLPart::slotAutoScroll()
{
    if (d->m_view)
      d->m_view->doAutoScroll();
    else
      stopAutoScroll(); // Safety
}

void MGHTMLPart::slotSaveFrame()
{
    if ( !d->m_activeFrame )
        return; // should never be the case, but one never knows :-)

    KURL srcURL( static_cast<KParts::ReadOnlyPart *>( d->m_activeFrame )->url() );

    if ( srcURL.fileName(false).isEmpty() )
        srcURL.setFileName( "index.html" );

    KHTMLPopupGUIClient::saveURL( d->m_view, i18n( "Save as" ), srcURL, i18n("HTML files|* *.html *.htm") );
}

void MGHTMLPart::slotViewFrameSource()
{
  (void) KRun::runURL( ((KParts::ReadOnlyPart *)partManager()->activePart())->url(), QString::fromLatin1("text/plain") );
}

void MGHTMLPart::slotSaveBackground()
{
  QString relURL = d->m_doc->body()->getAttribute( ATTR_BACKGROUND ).string();

  KURL backgroundURL( m_url, relURL );

  KHTMLPopupGUIClient::saveURL( d->m_view, i18n("Save background image as"), backgroundURL );
}

void MGHTMLPart::slotSaveDocument()
{
  KURL srcURL( m_url );

  if ( srcURL.fileName(false).isEmpty() )
    srcURL.setFileName( "index.html" );

  KHTMLPopupGUIClient::saveURL( d->m_view, i18n( "Save as" ), srcURL, i18n("HTML files|* *.html *.htm"), d->m_cacheId );
}

void MGHTMLPart::khtmlDrawContentsEvent( khtml::DrawContentsEvent * )
{
}

void MGHTMLPart::guiActivateEvent( KParts::GUIActivateEvent *event )
{
  if ( event->activated() )
  {
    emitSelectionChanged();
    emit d->m_extension->enableAction( "print", d->m_doc != 0 );

    if ( !d->m_settings->autoLoadImages() && d->m_paLoadImages )
    {
        QList<KAction> lst;
        lst.append( d->m_paLoadImages );
        plugActionList( "loadImages", lst );
    }
  }
}

void MGHTMLPart::saveState( QDataStream &stream )
{
  stream << m_url << (Q_INT32)d->m_view->contentsX() << (Q_INT32)d->m_view->contentsY();

  // Save the doc's cache id.
  stream << d->m_cacheId;

  // Save the state of the document (Most notably the state of any forms)
  QStringList docState;
  if (d->m_doc)
  {
     docState = d->m_doc->state();
  }
  stream << docState;

  // Save font data
  stream << fontSizes() << d->m_fontBase;

  // Save frame data
  stream << (Q_UINT32)d->m_frames.count();

  QStringList frameNameLst, frameServiceTypeLst, frameServiceNameLst;
  KURL::List frameURLLst;
  QValueList<QByteArray> frameStateBufferLst;

  ConstFrameIt it = d->m_frames.begin();
  ConstFrameIt end = d->m_frames.end();
  for (; it != end; ++it )
  {
    frameNameLst << (*it).m_name;
    frameServiceTypeLst << (*it).m_serviceType;
    frameServiceNameLst << (*it).m_serviceName;
    if ( (*it).m_part )
      frameURLLst << (*it).m_part->url();
    else
      frameURLLst << KURL();

    QByteArray state;
    QDataStream frameStream( state, IO_WriteOnly );

    if ( (*it).m_part && (*it).m_extension )
      (*it).m_extension->saveState( frameStream );

    frameStateBufferLst << state;
  }

  stream << frameNameLst << frameServiceTypeLst << frameServiceNameLst << frameURLLst << frameStateBufferLst;
  stream << *KHTMLFactory::vLinks();
}

void MGHTMLPart::restoreState( QDataStream &stream )
{
  KURL u;
  Q_INT32 xOffset;
  Q_INT32 yOffset;
  Q_UINT32 frameCount;
  QStringList frameNames, frameServiceTypes, docState, frameServiceNames;
  KURL::List frameURLs;
  QValueList<QByteArray> frameStateBuffers;
  QValueList<int> fSizes;
  KURL::List visitedLinks;
  long old_cacheId = d->m_cacheId;

  stream >> u >> xOffset >> yOffset;

  stream >> d->m_cacheId;

  stream >> docState;

  stream >> fSizes >> d->m_fontBase;
  setFontSizes( fSizes );

  stream >> frameCount >> frameNames >> frameServiceTypes >> frameServiceNames
         >> frameURLs >> frameStateBuffers;

  stream >> visitedLinks;

  if ( KHTMLFactory::partList()->count() == 1 )
      *KHTMLFactory::vLinks() = visitedLinks;

  d->m_bComplete = false;

  if (d->m_cacheId == old_cacheId)
  {
    d->m_redirectionTimer.stop();

    FrameIt fIt = d->m_frames.begin();
    FrameIt fEnd = d->m_frames.end();

    for (; fIt != fEnd; ++fIt )
        (*fIt).m_bCompleted = false;

    fIt = d->m_frames.begin();

    QStringList::ConstIterator fNameIt = frameNames.begin();
    QStringList::ConstIterator fServiceTypeIt = frameServiceTypes.begin();
    QStringList::ConstIterator fServiceNameIt = frameServiceNames.begin();
    KURL::List::ConstIterator fURLIt = frameURLs.begin();
    QValueList<QByteArray>::ConstIterator fBufferIt = frameStateBuffers.begin();

    for (; fIt != fEnd; ++fIt, ++fNameIt, ++fServiceTypeIt, ++fServiceNameIt, ++fURLIt, ++fBufferIt )
    {
      khtml::ChildFrame *child = &(*fIt);

      if ( child->m_name != *fNameIt || child->m_serviceType != *fServiceTypeIt )
      {
        child->m_bPreloaded = true;
        child->m_name = *fNameIt;
        child->m_serviceName = *fServiceNameIt;
        processObjectRequest( child, *fURLIt, *fServiceTypeIt );
      }

      if ( child->m_part )
      {
        child->m_bCompleted = false;
        if ( child->m_extension )
        {
          QDataStream frameStream( *fBufferIt, IO_ReadOnly );
          child->m_extension->restoreState( frameStream );
        }
        else
          child->m_part->openURL( *fURLIt );
      }
    }

    KParts::URLArgs args( d->m_extension->urlArgs() );
    args.xOffset = xOffset;
    args.yOffset = yOffset;
    args.docState = docState;
    d->m_extension->setURLArgs( args );

    d->m_view->setContentsPos( xOffset, yOffset );
  }
  else
  {
    closeURL();
    d->m_bCleared = false;
    clear();

    QStringList::ConstIterator fNameIt = frameNames.begin();
    QStringList::ConstIterator fNameEnd = frameNames.end();

    QStringList::ConstIterator fServiceTypeIt = frameServiceTypes.begin();
    QStringList::ConstIterator fServiceNameIt = frameServiceNames.begin();
    KURL::List::ConstIterator fURLIt = frameURLs.begin();
    QValueList<QByteArray>::ConstIterator fBufferIt = frameStateBuffers.begin();

    for (; fNameIt != fNameEnd; ++fNameIt, ++fServiceTypeIt, ++fServiceNameIt, ++fURLIt, ++fBufferIt )
    {
      khtml::ChildFrame newChild;
      newChild.m_bPreloaded = true;
      newChild.m_name = *fNameIt;
      newChild.m_serviceName = *fServiceNameIt;

      FrameIt childFrame = d->m_frames.append( newChild );

      processObjectRequest( &(*childFrame), *fURLIt, *fServiceTypeIt );

      (*childFrame).m_bPreloaded = true;

      if ( (*childFrame).m_part )
      {
        if ( (*childFrame).m_extension )
        {
          QDataStream frameStream( *fBufferIt, IO_ReadOnly );
          (*childFrame).m_extension->restoreState( frameStream );
        }
        else
          (*childFrame).m_part->openURL( *fURLIt );
      }
    }

    KParts::URLArgs args( d->m_extension->urlArgs() );
    args.xOffset = xOffset;
    args.yOffset = yOffset;
    args.docState = docState;
    d->m_extension->setURLArgs( args );
    if (!KHTMLPageCache::self()->isValid(d->m_cacheId))
       openURL( u );
    else
       restoreURL( u );
  }

}

void MGHTMLPart::slotSecurity()
{
  KSSLInfoDlg *kid = new KSSLInfoDlg(d->m_ssl_in_use, widget());
  if (d->m_ssl_in_use) {
    kid->setup(d->m_ssl_peer_cert_subject,
               d->m_ssl_peer_cert_issuer,
               d->m_ssl_peer_ip,
               m_url.url(),
               d->m_ssl_cipher,
               d->m_ssl_cipher_desc,
               d->m_ssl_cipher_version,
               d->m_ssl_cipher_used_bits.toInt(),
               d->m_ssl_cipher_bits.toInt(),
               (KSSLCertificate::KSSLValidation) d->m_ssl_cert_state.toInt(),
               d->m_ssl_good_from, d->m_ssl_good_until);
  }
  kid->show();
}

KParts::PartManager *MGHTMLPart::partManager()
{
  if ( !d->m_manager )
  {
    d->m_manager = new KParts::PartManager( d->m_view->topLevelWidget(), this, "khtml part manager" );
    d->m_manager->setAllowNestedParts( true );
    connect( d->m_manager, SIGNAL( activePartChanged( KParts::Part * ) ),
             this, SLOT( slotActiveFrameChanged( KParts::Part * ) ) );
    connect( d->m_manager, SIGNAL( partRemoved( KParts::Part * ) ),
             this, SLOT( slotPartRemoved( KParts::Part * ) ) );
  }

  return d->m_manager;
}

void MGHTMLPart::reparseConfiguration()
{
  KHTMLSettings *settings = KHTMLFactory::defaultHTMLSettings();
  settings->init();

  settings->setCharset(d->m_settings->charset());

  if ( settings->autoLoadImages() != khtml::Cache::autoloadImages() )
    autoloadImages( settings->autoLoadImages() );

  d->m_bJScriptEnabled = settings->isJavaScriptEnabled();
  d->m_bJavaEnabled = settings->isJavaEnabled();
  delete d->m_settings;
  d->m_settings = new KHTMLSettings(*KHTMLFactory::defaultHTMLSettings());

  QApplication::setOverrideCursor( waitCursor );
  if(d->m_doc) d->m_doc->applyChanges();
  QApplication::restoreOverrideCursor();
}

void MGHTMLPart::emitSelectionChanged()
{
	emit d->m_extension->enableAction( "copy", hasSelection() );
	emit d->m_extension->selectionInfo( selectedText() );
	emit selectionChanged();
}

void MGHTMLPart::slotShowDocument( const QString &url, const QString &target )
{
	khtml::ChildFrame *child = 0;
	KParts::URLArgs args;
	args.frameName = target;

	QString frameName = args.frameName.lower();
	if ( !frameName.isEmpty() )
	{
		if ( frameName == QString::fromLatin1( "_top" ) )
		{
			emit d->m_extension->openURLRequest( url, args );
			return;
		}
		else if ( frameName == QString::fromLatin1( "_blank" ) )
		{
			emit d->m_extension->createNewWindow( url, args );
			return;
		}
		else if ( frameName == QString::fromLatin1( "_parent" ) )
		{
			KParts::URLArgs newArgs( args );
			newArgs.frameName = QString::null;
			emit d->m_extension->openURLRequest( url, newArgs );
			return;
		}
		else if ( frameName != QString::fromLatin1( "_self" ) )
		{
			khtml::ChildFrame *_frame = recursiveFrameRequest( url, args );
			if ( !_frame )
			{
				emit d->m_extension->openURLRequest( url, args );
				return;
			}
			child = _frame;
		}
	}

	if ( url.find( QString::fromLatin1( "javascript:" ), 0, false ) == 0 ) 
	{
		executeScript( url.right( url.length() - 11) );
		return;
	}
	if ( child ) 
	{
		requestObject( child, KURL(url), args );
	}
	else if ( frameName==QString::fromLatin1("_self") ) 
	{
		KParts::URLArgs newArgs( args );
		newArgs.frameName = QString::null;
		emit d->m_extension->openURLRequest( KURL(url), newArgs );
	}
}

void MGHTMLPart::autoloadImages( bool enable )
{
	khtml::Cache::autoloadImages( enable );
	unplugActionList( "loadImages" );
	if ( enable )
	{
		if ( d->m_paLoadImages )
			delete d->m_paLoadImages;
		d->m_paLoadImages = 0;
	}
	else if ( !d->m_paLoadImages )
		d->m_paLoadImages = new KAction( i18n( "Display Images on Page" ), "images_display", 0, this, SLOT( slotLoadImages() ), actionCollection(), "loadImages" );
	if ( d->m_paLoadImages )
	{
		QList<KAction> lst;
		lst.append( d->m_paLoadImages );
		plugActionList( "loadImages", lst );
	}
}

void MGHTMLPart::slotRedirect()
{
	QString u = d->m_redirectURL;
	d->m_delayRedirect = 0;
	d->m_redirectURL = QString::null;
	urlSelected( u );
}

void MGHTMLPart::slotRedirection(KIO::Job*, const KURL& url)
{
	emit d->m_extension->setLocationBarURL( url.prettyURL() );
	d->m_workingURL = url;
}

bool MGHTMLPart::setCharset( const QString &name, bool override )
{
	QFont f(settings()->stdFontName());
	KGlobal::charsets()->setQFont(f, KGlobal::charsets()->charsetForEncoding(name) );
	d->m_settings->setCharset( f.charSet() );
	d->keepCharset = override;
	return true;
}

void MGHTMLPart::scheduleRedirection( int delay, const QString &url )
{
	if(d->m_redirectURL.isEmpty() || delay < d->m_delayRedirect)
	{
		d->m_delayRedirect = delay;
		d->m_redirectURL = url;
		if(d->m_bComplete)
			d->m_redirectionTimer.start( 1000 * d->m_delayRedirect, true );
	}
}


void MGHTMLPart::slotViewDocumentSource()
{
	KURL url(m_url);
	if (KHTMLPageCache::self()->isValid(d->m_cacheId))
	{
		KTempFile sourceFile(QString::null, QString::fromLatin1(".html"));
		if (sourceFile.status() == 0)
		{
			KHTMLPageCache::self()->saveData(d->m_cacheId, sourceFile.dataStream());
			url = KURL();
			url.setPath(sourceFile.name());
		}
	}
	(void) KRun::runURL( url, QString::fromLatin1("text/plain") );
}

void MGHTMLPart::setFontBaseInternal( int base, bool absolute )
{
	if ( absolute )
		d->m_fontBase = base;
	else
		d->m_fontBase += base;
	if ( d->m_fontBase < 0 )
		d->m_fontBase = 0;
	d->m_paDecFontSizes->setEnabled( d->m_fontBase > 0 );
	updateFontSize( d->m_fontBase );
}

void MGHTMLPart::slotLoadImages()
{
	khtml::Cache::autoloadImages( !khtml::Cache::autoloadImages() );
	khtml::Cache::autoloadImages( d->m_settings->autoLoadImages() );
}

MGParts::ReadOnlyPart *MGHTMLPart::createPart( QWidget *parentWidget, const char *widgetName,
                                             QObject *parent, const char *name, const QString &mimetype,
                                             QString &serviceName, QStringList &serviceTypes,
                                             const QStringList &params )
{
	QString constr = QString::fromLatin1( "('KParts/ReadOnlyPart' in ServiceTypes)" );
	if ( !serviceName.isEmpty() )
		constr.append( QString::fromLatin1( "and ( Name == '%1' )" ).arg( serviceName ) );
	KTrader::OfferList offers = KTrader::self()->query( mimetype, constr );
	if ( offers.count() == 0 )
		return 0L;
	KService::Ptr service = *offers.begin();
	KLibFactory *factory = KLibLoader::self()->factory( service->library().latin1() );
	if ( !factory )
		return 0L;
	KParts::ReadOnlyPart *res = 0L;
	const char *className = "KParts::ReadOnlyPart";
	if ( service->serviceTypes().contains( "Browser/View" ) )
		className = "Browser/View";
	if ( factory->inherits( "KParts::Factory" ) )
		res = static_cast<KParts::ReadOnlyPart *>(static_cast<KParts::Factory *>( factory )->createPart( parentWidget, widgetName, parent, name, className, params ));
	else
		res = static_cast<KParts::ReadOnlyPart *>(factory->create( parentWidget, widgetName