diff options
Diffstat (limited to 'khtml/misc/loader.cpp')
| -rw-r--r-- | khtml/misc/loader.cpp | 1679 |
1 files changed, 1679 insertions, 0 deletions
diff --git a/khtml/misc/loader.cpp b/khtml/misc/loader.cpp new file mode 100644 index 000000000..8f7ae246f --- /dev/null +++ b/khtml/misc/loader.cpp @@ -0,0 +1,1679 @@ +/* + This file is part of the KDE libraries + + Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de) + Copyright (C) 2001-2003 Dirk Mueller (mueller@kde.org) + Copyright (C) 2002 Waldo Bastian (bastian@kde.org) + Copyright (C) 2003 Apple Computer, Inc. + + 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. + + This class provides all functionality needed for loading images, style sheets and html + pages from the web. It has a memory cache for these objects. + + // regarding the LRU: + // http://www.is.kyusan-u.ac.jp/~chengk/pub/papers/compsac00_A07-07.pdf +*/ + +#undef CACHE_DEBUG +//#define CACHE_DEBUG + +#ifdef CACHE_DEBUG +#define CDEBUG kdDebug(6060) +#else +#define CDEBUG kndDebug() +#endif + +#undef LOADER_DEBUG +//#define LOADER_DEBUG + +#include <assert.h> + +#include "misc/loader.h" +#include "misc/seed.h" + +// default cache size +#define DEFCACHESIZE 2096*1024 +#define MAX_JOB_COUNT 32 + +#include <qasyncio.h> +#include <qasyncimageio.h> +#include <qpainter.h> +#include <qbitmap.h> +#include <qmovie.h> +#include <qwidget.h> + +#include <kapplication.h> +#include <kio/job.h> +#include <kio/jobclasses.h> +#include <kglobal.h> +#include <kimageio.h> +#include <kcharsets.h> +#include <kiconloader.h> +#include <scheduler.h> +#include <kdebug.h> +#include "khtml_factory.h" +#include "khtml_part.h" + +#ifdef IMAGE_TITLES +#include <qfile.h> +#include <kfilemetainfo.h> +#include <ktempfile.h> +#endif + +#include "html/html_documentimpl.h" +#include "css/css_stylesheetimpl.h" +#include "xml/dom_docimpl.h" + +#include "blocked_icon.cpp" + +using namespace khtml; +using namespace DOM; + +#define MAX_LRU_LISTS 20 +struct LRUList { + CachedObject* m_head; + CachedObject* m_tail; + + LRUList() : m_head(0), m_tail(0) {} +}; + +static LRUList m_LRULists[MAX_LRU_LISTS]; +static LRUList* getLRUListFor(CachedObject* o); + +CachedObjectClient::~CachedObjectClient() +{ +} + +CachedObject::~CachedObject() +{ + Cache::removeFromLRUList(this); +} + +void CachedObject::finish() +{ + m_status = Cached; +} + +bool CachedObject::isExpired() const +{ + if (!m_expireDate) return false; + time_t now = time(0); + return (difftime(now, m_expireDate) >= 0); +} + +void CachedObject::setRequest(Request *_request) +{ + if ( _request && !m_request ) + m_status = Pending; + + if ( allowInLRUList() ) + Cache::removeFromLRUList( this ); + + m_request = _request; + + if ( allowInLRUList() ) + Cache::insertInLRUList( this ); +} + +void CachedObject::ref(CachedObjectClient *c) +{ + // unfortunately we can be ref'ed multiple times from the + // same object, because it uses e.g. the same foreground + // and the same background picture. so deal with it. + m_clients.insert(c,c); + Cache::removeFromLRUList(this); + m_accessCount++; +} + +void CachedObject::deref(CachedObjectClient *c) +{ + assert( c ); + assert( m_clients.count() ); + assert( !canDelete() ); + assert( m_clients.find( c ) ); + + Cache::flush(); + + m_clients.remove(c); + + if (allowInLRUList()) + Cache::insertInLRUList(this); +} + +void CachedObject::setSize(int size) +{ + bool sizeChanged; + + if ( !m_next && !m_prev && getLRUListFor(this)->m_head != this ) + sizeChanged = false; + else + sizeChanged = ( size - m_size ) != 0; + + // The object must now be moved to a different queue, + // since its size has been changed. + if ( sizeChanged && allowInLRUList()) + Cache::removeFromLRUList(this); + + m_size = size; + + if ( sizeChanged && allowInLRUList()) + Cache::insertInLRUList(this); +} + +QTextCodec* CachedObject::codecForBuffer( const QString& charset, const QByteArray& buffer ) const +{ + // we don't use heuristicContentMatch here since it is a) far too slow and + // b) having too much functionality for our case. + + uchar* d = ( uchar* ) buffer.data(); + int s = buffer.size(); + + // BOM + if ( s >= 3 && + d[0] == 0xef && d[1] == 0xbb && d[2] == 0xbf) + return QTextCodec::codecForMib( 106 ); // UTF-8 + + if ( s >= 2 && ((d[0] == 0xff && d[1] == 0xfe) || + (d[0] == 0xfe && d[1] == 0xff))) + return QTextCodec::codecForMib( 1000 ); // UCS-2 + + // Link or @charset + if(!charset.isEmpty()) + { + QTextCodec* c = KGlobal::charsets()->codecForName(charset); + if(c->mibEnum() == 11) { + // iso8859-8 (visually ordered) + c = QTextCodec::codecForName("iso8859-8-i"); + } + return c; + } + + // Default + return QTextCodec::codecForMib( 4 ); // latin 1 +} + +// ------------------------------------------------------------------------------------------- + +CachedCSSStyleSheet::CachedCSSStyleSheet(DocLoader* dl, const DOMString &url, KIO::CacheControl _cachePolicy, + const char *accept) + : CachedObject(url, CSSStyleSheet, _cachePolicy, 0) +{ + // Set the type we want (probably css or xml) + QString ah = QString::fromLatin1( accept ); + if ( !ah.isEmpty() ) + ah += ","; + ah += "*/*;q=0.1"; + setAccept( ah ); + m_hadError = false; + m_wasBlocked = false; + m_err = 0; + // load the file + Cache::loader()->load(dl, this, false); + m_loading = true; +} + +CachedCSSStyleSheet::CachedCSSStyleSheet(const DOMString &url, const QString &stylesheet_data) + : CachedObject(url, CSSStyleSheet, KIO::CC_Verify, stylesheet_data.length()) +{ + m_loading = false; + m_status = Persistent; + m_sheet = DOMString(stylesheet_data); +} + + +void CachedCSSStyleSheet::ref(CachedObjectClient *c) +{ + CachedObject::ref(c); + + if (!m_loading) { + if (m_hadError) + c->error( m_err, m_errText ); + else + c->setStyleSheet( m_url, m_sheet, m_charset ); + } +} + +void CachedCSSStyleSheet::data( QBuffer &buffer, bool eof ) +{ + if(!eof) return; + buffer.close(); + setSize(buffer.buffer().size()); + +// QString charset = checkCharset( buffer.buffer() ); + QTextCodec* c = 0; + if (!m_charset.isEmpty()) { + c = KGlobal::charsets()->codecForName(m_charset); + if(c->mibEnum() == 11) c = QTextCodec::codecForName("iso8859-8-i"); + } + else { + c = codecForBuffer( m_charsetHint, buffer.buffer() ); + m_charset = c->name(); + } + QString data = c->toUnicode( buffer.buffer().data(), m_size ); + // workaround Qt bugs + m_sheet = static_cast<QChar>(data[0]) == QChar::byteOrderMark ? DOMString(data.mid( 1 ) ) : DOMString(data); + m_loading = false; + + checkNotify(); +} + +void CachedCSSStyleSheet::checkNotify() +{ + if(m_loading || m_hadError) return; + + CDEBUG << "CachedCSSStyleSheet:: finishedLoading " << m_url.string() << endl; + + // it() first increments, then returnes the current item. + // this avoids skipping an item when setStyleSheet deletes the "current" one. + for (QPtrDictIterator<CachedObjectClient> it( m_clients ); it.current();) + it()->setStyleSheet( m_url, m_sheet, m_charset ); +} + + +void CachedCSSStyleSheet::error( int err, const char* text ) +{ + m_hadError = true; + m_err = err; + m_errText = text; + m_loading = false; + + // it() first increments, then returnes the current item. + // this avoids skipping an item when setStyleSheet deletes the "current" one. + for (QPtrDictIterator<CachedObjectClient> it( m_clients ); it.current();) + it()->error( m_err, m_errText ); +} + +#if 0 +QString CachedCSSStyleSheet::checkCharset(const QByteArray& buffer ) const +{ + int s = buffer.size(); + if (s <= 12) return m_charset; + + // @charset has to be first or directly after BOM. + // CSS 2.1 says @charset should win over BOM, but since more browsers support BOM + // than @charset, we default to that. + const char* d = (const char*) buffer.data(); + if (strncmp(d, "@charset \"",10) == 0) + { + // the string until "; is the charset name + char *p = strchr(d+10, '"'); + if (p == 0) return m_charset; + QString charset = QString::fromAscii(d+10, p-(d+10)); + return charset; + } + return m_charset; +} +#endif + +// ------------------------------------------------------------------------------------------- + +CachedScript::CachedScript(DocLoader* dl, const DOMString &url, KIO::CacheControl _cachePolicy, const char*) + : CachedObject(url, Script, _cachePolicy, 0) +{ + // It's javascript we want. + // But some websites think their scripts are <some wrong mimetype here> + // and refuse to serve them if we only accept application/x-javascript. + setAccept( QString::fromLatin1("*/*") ); + // load the file + Cache::loader()->load(dl, this, false); + m_loading = true; +} + +CachedScript::CachedScript(const DOMString &url, const QString &script_data) + : CachedObject(url, Script, KIO::CC_Verify, script_data.length()) +{ + m_loading = false; + m_status = Persistent; + m_script = DOMString(script_data); +} + +void CachedScript::ref(CachedObjectClient *c) +{ + CachedObject::ref(c); + + if(!m_loading) c->notifyFinished(this); +} + +void CachedScript::data( QBuffer &buffer, bool eof ) +{ + if(!eof) return; + buffer.close(); + setSize(buffer.buffer().size()); + + QTextCodec* c = codecForBuffer( m_charset, buffer.buffer() ); + QString data = c->toUnicode( buffer.buffer().data(), m_size ); + m_script = static_cast<QChar>(data[0]) == QChar::byteOrderMark ? DOMString(data.mid( 1 ) ) : DOMString(data); + m_loading = false; + checkNotify(); +} + +void CachedScript::checkNotify() +{ + if(m_loading) return; + + for (QPtrDictIterator<CachedObjectClient> it( m_clients); it.current();) + it()->notifyFinished(this); +} + +void CachedScript::error( int /*err*/, const char* /*text*/ ) +{ + m_loading = false; + checkNotify(); +} + +// ------------------------------------------------------------------------------------------ + +namespace khtml +{ + +class ImageSource : public QDataSource +{ +public: + ImageSource(QByteArray buf) + : buffer( buf ), pos( 0 ), eof( false ), rew(false ), rewable( true ) + {} + + int readyToSend() + { + if(eof && pos == buffer.size()) + return -1; + + return buffer.size() - pos; + } + + void sendTo(QDataSink* sink, int n) + { + sink->receive((const uchar*)&buffer.at(pos), n); + + pos += n; + + // buffer is no longer needed + if(eof && pos == buffer.size() && !rewable) + { + buffer.resize(0); + pos = 0; + } + } + + /** + * Sets the EOF state. + */ + void setEOF( bool state ) { eof = state; } + + bool rewindable() const { return rewable; } + void enableRewind(bool on) { rew = on; } + + /* + Calls reset() on the QIODevice. + */ + void rewind() + { + pos = 0; + if (!rew) { + QDataSource::rewind(); + } else + ready(); + } + + /* + Indicates that the buffered data is no longer + needed. + */ + void cleanBuffer() + { + // if we need to be able to rewind, buffer is needed + if(rew) + return; + + rewable = false; + + // buffer is no longer needed + if(eof && pos == buffer.size()) + { + buffer.resize(0); + pos = 0; + } + } + + QByteArray buffer; + unsigned int pos; +private: + bool eof : 1; + bool rew : 1; + bool rewable : 1; +}; + +} // end namespace + +static QString buildAcceptHeader() +{ + return "image/png, image/jpeg, video/x-mng, image/jp2, image/gif;q=0.5,*/*;q=0.1"; +} + +// ------------------------------------------------------------------------------------- + +CachedImage::CachedImage(DocLoader* dl, const DOMString &url, KIO::CacheControl _cachePolicy, const char*) + : QObject(), CachedObject(url, Image, _cachePolicy, 0) +{ + static const QString &acceptHeader = KGlobal::staticQString( buildAcceptHeader() ); + + m = 0; + p = 0; + pixPart = 0; + bg = 0; + scaled = 0; + bgColor = qRgba( 0, 0, 0, 0xFF ); + typeChecked = false; + isFullyTransparent = false; + monochrome = false; + formatType = 0; + m_status = Unknown; + imgSource = 0; + setAccept( acceptHeader ); + m_showAnimations = dl->showAnimations(); + + if ( KHTMLFactory::defaultHTMLSettings()->isAdFiltered( url.string() ) ) { + m_wasBlocked = true; + CachedObject::finish(); + } +} + +CachedImage::~CachedImage() +{ + clear(); +} + +void CachedImage::ref( CachedObjectClient *c ) +{ + CachedObject::ref(c); + + if( m ) { + m->unpause(); + if( m->finished() || m_clients.count() == 1 ) + m->restart(); + } + + // for mouseovers, dynamic changes + if ( m_status >= Persistent && !valid_rect().isNull() ) { + c->setPixmap( pixmap(), valid_rect(), this); + c->notifyFinished( this ); + } +} + +void CachedImage::deref( CachedObjectClient *c ) +{ + CachedObject::deref(c); + if(m && m_clients.isEmpty() && m->running()) + m->pause(); +} + +#define BGMINWIDTH 32 +#define BGMINHEIGHT 32 + +const QPixmap &CachedImage::tiled_pixmap(const QColor& newc, int xWidth, int xHeight) +{ + static QRgb bgTransparent = qRgba( 0, 0, 0, 0xFF ); + + QSize s(pixmap_size()); + int w = xWidth; + int h = xHeight; + if (w == -1) xWidth = w = s.width(); + if (h == -1) xHeight = h = s.height(); + + if ( ( (bgColor != bgTransparent) && (bgColor != newc.rgb()) ) || + ( bgSize != QSize(xWidth, xHeight)) ) + { + delete bg; bg = 0; + } + + if (bg) + return *bg; + + const QPixmap &r = pixmap(); + + if (r.isNull()) return r; + + // no error indication for background images + if(m_hadError||m_wasBlocked) return *Cache::nullPixmap; + + bool isvalid = newc.isValid(); + + const QPixmap* src; //source for pretiling, if any + + //See whether we should scale + if (xWidth != s.width() || xHeight != s.height()) { + src = &scaled_pixmap(xWidth, xHeight); + } else { + src = &r; + } + + bgSize = QSize(xWidth, xHeight); + + //See whether we can - and should - pre-blend + if (isvalid && (r.hasAlphaChannel() || r.mask() )) { + bg = new QPixmap(xWidth, xHeight, r.depth()); + bg->fill(newc); + bitBlt(bg, 0, 0, src); + bgColor = newc.rgb(); + src = bg; + } else { + bgColor = bgTransparent; + } + + //See whether to pre-tile. + if ( w*h < 8192 ) + { + if ( r.width() < BGMINWIDTH ) + w = ((BGMINWIDTH-1) / xWidth + 1) * xWidth; + if ( r.height() < BGMINHEIGHT ) + h = ((BGMINHEIGHT-1) / xHeight + 1) * xHeight; + } + if ( w != xWidth || h != xHeight ) + { +// kdDebug() << "pre-tiling " << s.width() << "," << s.height() << " to " << w << "," << h << endl; + QPixmap* oldbg = bg; + bg = new QPixmap(w, h, r.depth()); + + //Tile horizontally on the first stripe + for (int x = 0; x < w; x += xWidth) + copyBlt(bg, x, 0, src, 0, 0, xWidth, xHeight); + + //Copy first stripe down + for (int y = xHeight; y < h; y += xHeight) + copyBlt(bg, 0, y, bg, 0, 0, w, xHeight); + + if ( src == oldbg ) + delete oldbg; + } + + if (bg) + return *bg; + + return *src; +} + +const QPixmap &CachedImage::scaled_pixmap( int xWidth, int xHeight ) +{ + if (scaled) { + if (scaled->width() == xWidth && scaled->height() == xHeight) + return *scaled; + delete scaled; + } + const QPixmap &r = pixmap(); + if (r.isNull()) return r; + +// kdDebug() << "scaling " << r.width() << "," << r.height() << " to " << xWidth << "," << xHeight << endl; + + QImage image = r.convertToImage().smoothScale(xWidth, xHeight); + + scaled = new QPixmap(xWidth, xHeight, r.depth()); + scaled->convertFromImage(image); + + return *scaled; +} + + +const QPixmap &CachedImage::pixmap( ) const +{ + if(m_hadError) + return *Cache::brokenPixmap; + + if(m_wasBlocked) + return *Cache::blockedPixmap; + + if(m) + { + if(m->framePixmap().size() != m->getValidRect().size()) + { + // pixmap is not yet completely loaded, so we + // return a clipped version. asserting here + // that the valid rect is always from 0/0 to fullwidth/ someheight + if(!pixPart) pixPart = new QPixmap(); + + (*pixPart) = m->framePixmap(); + if (m->getValidRect().size().isValid()) + pixPart->resize(m->getValidRect().size()); + else + pixPart->resize(0, 0); + return *pixPart; + } + else + return m->framePixmap(); + } + else if(p) + return *p; + + return *Cache::nullPixmap; +} + + +QSize CachedImage::pixmap_size() const +{ + if (m_wasBlocked) return Cache::blockedPixmap->size(); + return (m_hadError ? Cache::brokenPixmap->size() : m ? m->framePixmap().size() : ( p ? p->size() : QSize())); +} + + +QRect CachedImage::valid_rect() const +{ + if (m_wasBlocked) return Cache::blockedPixmap->rect(); + return (m_hadError ? Cache::brokenPixmap->rect() : m ? m->getValidRect() : ( p ? p->rect() : QRect()) ); +} + + +void CachedImage::do_notify(const QPixmap& p, const QRect& r) +{ + for (QPtrDictIterator<CachedObjectClient> it( m_clients ); it.current();) + it()->setPixmap( p, r, this); +} + + +void CachedImage::movieUpdated( const QRect& r ) +{ +#ifdef LOADER_DEBUG + qDebug("movie updated %d/%d/%d/%d, pixmap size %d/%d", r.x(), r.y(), r.right(), r.bottom(), + m->framePixmap().size().width(), m->framePixmap().size().height()); +#endif + + do_notify(m->framePixmap(), r); +} + +void CachedImage::movieStatus(int status) +{ +#ifdef LOADER_DEBUG + qDebug("movieStatus(%d)", status); +#endif + + // ### the html image objects are supposed to send the load event after every frame (according to + // netscape). We have a problem though where an image is present, and js code creates a new Image object, + // which uses the same CachedImage, the one in the document is not supposed to be notified + + // just another Qt 2.2.0 bug. we cannot call + // QMovie::frameImage if we're after QMovie::EndOfMovie + if(status == QMovie::EndOfFrame) + { + const QImage& im = m->frameImage(); + monochrome = ( ( im.depth() <= 8 ) && ( im.numColors() - int( im.hasAlphaBuffer() ) <= 2 ) ); + for (int i = 0; monochrome && i < im.numColors(); ++i) + if (im.colorTable()[i] != qRgb(0xff, 0xff, 0xff) && + im.colorTable()[i] != qRgb(0x00, 0x00, 0x00)) + monochrome = false; + if( (im.width() < 5 || im.height() < 5) && im.hasAlphaBuffer()) // only evaluate for small images + { + QImage am = im.createAlphaMask(); + if(am.depth() == 1) + { + bool solid = false; + for(int y = 0; y < am.height(); y++) + for(int x = 0; x < am.width(); x++) + if(am.pixelIndex(x, y)) { + solid = true; + break; + } + isFullyTransparent = (!solid); + } + } + + // we have to delete our tiled bg variant here + // because the frame has changed (in order to keep it in sync) + delete bg; + bg = 0; + } + + if((status == QMovie::EndOfMovie && (!m || m->frameNumber() <= 1)) || + ((status == QMovie::EndOfLoop) && (m_showAnimations == KHTMLSettings::KAnimationLoopOnce)) || + ((status == QMovie::EndOfFrame) && (m_showAnimations == KHTMLSettings::KAnimationDisabled)) + ) + { + if(imgSource) + { + setShowAnimations( KHTMLSettings::KAnimationDisabled ); + + // monochrome alphamasked images are usually about 10000 times + // faster to draw, so this is worth the hack + if (p && monochrome && p->depth() > 1) + { + QPixmap* pix = new QPixmap; + pix->convertFromImage( p->convertToImage().convertDepth( 1 ), MonoOnly|AvoidDither ); + if ( p->mask() ) + pix->setMask( *p->mask() ); + delete p; + p = pix; + monochrome = false; + } + } + for (QPtrDictIterator<CachedObjectClient> it( m_clients ); it.current();) + it()->notifyFinished( this ); + m_status = Cached; //all done + } + +#if 0 + if((status == QMovie::EndOfFrame) || (status == QMovie::EndOfMovie)) + { +#ifdef LOADER_DEBUG + QRect r(valid_rect()); + qDebug("movie Status frame update %d/%d/%d/%d, pixmap size %d/%d", r.x(), r.y(), r.right(), r.bottom(), + pixmap().size().width(), pixmap().size().height()); +#endif + do_notify(pixmap(), valid_rect()); + } +#endif +} + +void CachedImage::movieResize(const QSize& /*s*/) +{ + do_notify(m->framePixmap(), QRect()); +} + +void CachedImage::setShowAnimations( KHTMLSettings::KAnimationAdvice showAnimations ) +{ + m_showAnimations = showAnimations; + if ( (m_showAnimations == KHTMLSettings::KAnimationDisabled) && imgSource ) { + imgSource->cleanBuffer(); + delete p; + p = new QPixmap(m->framePixmap()); + m->disconnectUpdate( this, SLOT( movieUpdated( const QRect &) )); + m->disconnectStatus( this, SLOT( movieStatus( int ) )); + m->disconnectResize( this, SLOT( movieResize( const QSize& ) ) ); + QTimer::singleShot(0, this, SLOT( deleteMovie())); + imgSource = 0; + } +} + +void CachedImage::pauseAnimations() +{ + if ( m ) m->pause(); +} + +void CachedImage::resumeAnimations() +{ + if ( m ) m->unpause(); +} + + +void CachedImage::deleteMovie() +{ + delete m; m = 0; +} + +void CachedImage::clear() +{ + delete m; m = 0; + delete p; p = 0; + delete bg; bg = 0; + delete scaled; scaled = 0; + bgColor = qRgba( 0, 0, 0, 0xff ); + bgSize = QSize(-1,-1); + delete pixPart; pixPart = 0; + + formatType = 0; + typeChecked = false; + setSize(0); + + // No need to delete imageSource - QMovie does it for us + imgSource = 0; +} + +void CachedImage::data ( QBuffer &_buffer, bool eof ) +{ +#ifdef LOADER_DEBUG + kdDebug( 6060 ) << this << "in CachedImage::data(buffersize " << _buffer.buffer().size() <<", eof=" << eof << endl; +#endif + if ( !typeChecked ) + { + // don't attempt incremental loading if we have all the data already + if (!eof) + { + formatType = QImageDecoder::formatName( (const uchar*)_buffer.buffer().data(), _buffer.size()); + if ( formatType && strcmp( formatType, "PNG" ) == 0 ) + formatType = 0; // Some png files contain multiple images, we want to show only the first one + } + + typeChecked = true; + + if ( formatType ) // movie format exists + { + imgSource = new ImageSource( _buffer.buffer()); + m = new QMovie( imgSource, 8192 ); + m->connectUpdate( this, SLOT( movieUpdated( const QRect &) )); + m->connectStatus( this, SLOT( movieStatus(int))); + m->connectResize( this, SLOT( movieResize( const QSize& ) ) ); + } + } + + if ( imgSource ) + { + imgSource->setEOF(eof); + imgSource->maybeReady(); + } + + if(eof) + { + // QMovie currently doesn't support all kinds of image formats + // so we need to use a QPixmap here when we finished loading the complete + // picture and display it then all at once. + if(typeChecked && !formatType) + { +#ifdef CACHE_DEBUG + kdDebug(6060) << "CachedImage::data(): reloading as pixmap:" << endl; +#endif + p = new QPixmap; + { + QBuffer buffer(_buffer.buffer()); + buffer.open(IO_ReadOnly); + QImageIO io( &buffer, 0 ); + io.setGamma(2.2); // hardcoded "reasonable value" + bool result = io.read(); + if (result) p->convertFromImage(io.image(), 0); + } + + // set size of image. +#ifdef CACHE_DEBUG + kdDebug(6060) << "CachedImage::data(): image is null: " << p->isNull() << endl; +#endif + if(p->isNull()) + { + m_hadError = true; + do_notify(pixmap(), QRect(0, 0, 16, 16)); // load "broken image" icon + } + else + do_notify(*p, p->rect()); + + for (QPtrDictIterator<CachedObjectClient> it( m_clients ); it.current();) + it()->notifyFinished( this ); + m_status = Cached; //all done + } + } +} + +void CachedImage::finish() +{ + Status oldStatus = m_status; + CachedObject::finish(); + if ( oldStatus != m_status ) { + const QPixmap &pm = pixmap(); + do_notify( pm, pm.rect() ); + } + QSize s = pixmap_size(); + setSize( s.width() * s.height() * 2); +} + + +void CachedImage::error( int /*err*/, const char* /*text*/ ) +{ + clear(); + typeChecked = true; + m_hadError = true; + m_loading = false; + do_notify(pixmap(), QRect(0, 0, 16, 16)); + for (QPtrDictIterator<CachedObjectClient> it( m_clients ); it.current();) + it()->notifyFinished(this); +} + +// ------------------------------------------------------------------------------------------ + +Request::Request(DocLoader* dl, CachedObject *_object, bool _incremental) +{ + object = _object; + object->setRequest(this); + incremental = _incremental; + m_docLoader = dl; +} + +Request::~Request() +{ + object->setRequest(0); +} + +// ------------------------------------------------------------------------------------------ + +DocLoader::DocLoader(KHTMLPart* part, DocumentImpl* doc) +{ + m_cachePolicy = KIO::CC_Verify; + m_expireDate = 0; + m_creationDate = time(0); + m_bautoloadImages = true; + m_showAnimations = KHTMLSettings::KAnimationEnabled; + m_part = part; + m_doc = doc; + + Cache::docloader->append( this ); +} + +DocLoader::~DocLoader() +{ + Cache::loader()->cancelRequests( this ); + Cache::docloader->remove( this ); +} + +void DocLoader::setCacheCreationDate(time_t _creationDate) +{ + if (_creationDate) + m_creationDate = _creationDate; + else + m_creationDate = time(0); // Now +} + +void DocLoader::setExpireDate(time_t _expireDate, bool relative) +{ + if (relative) + m_expireDate = _expireDate + m_creationDate; // Relative date + else + m_expireDate = _expireDate; // Absolute date +#ifdef CACHE_DEBUG + kdDebug(6061) << "docLoader: " << m_expireDate - time(0) << " seconds left until reload required.\n"; +#endif +} + +void DocLoader::insertCachedObject( CachedObject* o ) const +{ + if ( m_docObjects.find(o) ) + return; + m_docObjects.insert( o, o ); + if ( m_docObjects.count() > 3 * m_docObjects.size() ) + m_docObjects.resize(khtml::nextSeed( m_docObjects.size() ) ); +} + +bool DocLoader::needReload(CachedObject *existing, const QString& fullURL) +{ + bool reload = false; + if (m_cachePolicy == KIO::CC_Verify) + { + if (!m_reloadedURLs.contains(fullURL)) + { + if (existing && existing->isExpired()) + { + Cache::removeCacheEntry(existing); + m_reloadedURLs.append(fullURL); + reload = true; + } + } + } + else if ((m_cachePolicy == KIO::CC_Reload) || (m_cachePolicy == KIO::CC_Refresh)) + { + if (!m_reloadedURLs.contains(fullURL)) + { + if (existing) + { + Cache::removeCacheEntry(existing); + } + m_reloadedURLs.append(fullURL); + reload = true; + } + } + return reload; +} + +#define DOCLOADER_SECCHECK(doRedirectCheck) \ + KURL fullURL (m_doc->completeURL( url.string() )); \ + if ( !fullURL.isValid() || \ + ( m_part && m_part->onlyLocalReferences() && fullURL.protocol() != "file" && fullURL.protocol() != "data") || \ + doRedirectCheck && ( kapp && m_doc && !kapp->authorizeURLAction("redirect", m_doc->URL(), fullURL))) \ + return 0L; + +CachedImage *DocLoader::requestImage( const DOM::DOMString &url) +{ + DOCLOADER_SECCHECK(true); + + CachedImage* i = Cache::requestObject<CachedImage, CachedObject::Image>( this, fullURL, 0); + + if (i && i->status() == CachedObject::Unknown && autoloadImages()) + Cache::loader()->load(this, i, true); + + return i; +} + +CachedCSSStyleSheet *DocLoader::requestStyleSheet( const DOM::DOMString &url, const QString& charset, + const char *accept, bool userSheet ) +{ + DOCLOADER_SECCHECK(!userSheet); + + CachedCSSStyleSheet* s = Cache::requestObject<CachedCSSStyleSheet, CachedObject::CSSStyleSheet>( this, fullURL, accept ); + if ( s && !charset.isEmpty() ) { + s->setCharsetHint( charset ); + } + return s; +} + +CachedScript *DocLoader::requestScript( const DOM::DOMString &url, const QString& charset) +{ + DOCLOADER_SECCHECK(true); + if ( ! KHTMLFactory::defaultHTMLSettings()->isJavaScriptEnabled(fullURL.host()) || + KHTMLFactory::defaultHTMLSettings()->isAdFiltered(fullURL.url())) + return 0L; + + CachedScript* s = Cache::requestObject<CachedScript, CachedObject::Script>( this, fullURL, 0 ); + if ( s && !charset.isEmpty() ) + s->setCharset( charset ); + return s; +} + +#undef DOCLOADER_SECCHECK + +void DocLoader::setAutoloadImages( bool enable ) +{ + if ( enable == m_bautoloadImages ) + return; + + m_bautoloadImages = enable; + + if ( !m_bautoloadImages ) return; + + for ( QPtrDictIterator<CachedObject> it( m_docObjects ); it.current(); ++it ) + if ( it.current()->type() == CachedObject::Image ) + { + CachedImage *img = const_cast<CachedImage*>( static_cast<const CachedImage *>( it.current()) ); + + CachedObject::Status status = img->status(); + if ( status != CachedObject::Unknown ) + continue; + + Cache::loader()->load(this, img, true); + } +} + +void DocLoader::setShowAnimations( KHTMLSettings::KAnimationAdvice showAnimations ) +{ + if ( showAnimations == m_showAnimations ) return; + m_showAnimations = showAnimations; + + for ( QPtrDictIterator<CachedObject> it( m_docObjects ); it.current(); ++it ) + if ( it.current()->type() == CachedObject::Image ) + { + CachedImage *img = const_cast<CachedImage*>( static_cast<const CachedImage *>( it.current() ) ); + + img->setShowAnimations( m_showAnimations ); + } +} + +void DocLoader::pauseAnimations() +{ + for ( QPtrDictIterator<CachedObject> it( m_docObjects ); it.current(); ++it ) + if ( it.current()->type() == CachedObject::Image ) + { + CachedImage *img = const_cast<CachedImage*>( static_cast<const CachedImage *>( it.current() ) ); + + img->pauseAnimations(); + } +} + +void DocLoader::resumeAnimations() +{ + for ( QPtrDictIterator<CachedObject> it( m_docObjects ); it.current(); ++it ) + if ( it.current()->type() == CachedObject::Image ) + { + CachedImage *img = const_cast<CachedImage*>( static_cast<const CachedImage *>( it.current() ) ); + + img->resumeAnimations(); + } +} + +// ------------------------------------------------------------------------------------------ + +Loader::Loader() : QObject() +{ + m_requestsPending.setAutoDelete( true ); + m_requestsLoading.setAutoDelete( true ); + connect(&m_timer, SIGNAL(timeout()), this, SLOT( servePendingRequests() ) ); +} + +void Loader::load(DocLoader* dl, CachedObject *object, bool incremental) +{ + Request *req = new Request(dl, object, incremental); + m_requestsPending.append(req); + + emit requestStarted( req->m_docLoader, req->object ); + + m_timer.start(0, true); +} + +void Loader::servePendingRequests() +{ + while ( (m_requestsPending.count() != 0) && (m_requestsLoading.count() < MAX_JOB_COUNT) ) + { + // get the first pending request + Request *req = m_requestsPending.take(0); + +#ifdef LOADER_DEBUG + kdDebug( 6060 ) << "starting Loader url=" << req->object->url().string() << endl; +#endif + + KURL u(req->object->url().string()); + KIO::TransferJob* job = KIO::get( u, false, false /*no GUI*/); + + job->addMetaData("cache", KIO::getCacheControlString(req->object->cachePolicy())); + if (!req->object->accept().isEmpty()) + job->addMetaData("accept", req->object->accept()); + if ( req->m_docLoader ) + { + job->addMetaData( "referrer", req->m_docLoader->doc()->URL().url() ); + + KHTMLPart *part = req->m_docLoader->part(); + if (part ) + { + job->addMetaData( "cross-domain", part->toplevelURL().url() ); + if (part->widget()) + job->setWindow (part->widget()->topLevelWidget()); + } + } + + connect( job, SIGNAL( result( KIO::Job * ) ), this, SLOT( slotFinished( KIO::Job * ) ) ); + connect( job, SIGNAL( data( KIO::Job*, const QByteArray &)), + SLOT( slotData( KIO::Job*, const QByteArray &))); + + if ( req->object->schedule() ) + KIO::Scheduler::scheduleJob( job ); + + m_requestsLoading.insert(job, req); + } +} + +void Loader::slotFinished( KIO::Job* job ) +{ + Request *r = m_requestsLoading.take( job ); + KIO::TransferJob* j = static_cast<KIO::TransferJob*>(job); + + if ( !r ) + return; + + if (j->error() || j->isErrorPage()) + { +#ifdef LOADER_DEBUG + kdDebug(6060) << "Loader::slotFinished, with error. job->error()= " << j->error() << " job->isErrorPage()=" << j->isErrorPage() << endl; +#endif + r->object->error( job->error(), job->errorText().ascii() ); + emit requestFailed( r->m_docLoader, r->object ); + } + else + { + QString cs = j->queryMetaData("charset"); + if (!cs.isEmpty()) r->object->setCharset(cs); + r->object->data(r->m_buffer, true); + emit requestDone( r->m_docLoader, r->object ); + time_t expireDate = j->queryMetaData("expire-date").toLong(); +#ifdef LOADER_DEBUG + kdDebug(6060) << "Loader::slotFinished, url = " << j->url().url() << endl; +#endif + r->object->setExpireDate( expireDate ); + + if ( r->object->type() == CachedObject::Image ) { + QString fn = j->queryMetaData("content-disposition"); + static_cast<CachedImage*>( r->object )->setSuggestedFilename(fn); +#ifdef IMAGE_TITLES + static_cast<CachedImage*>( r->object )->setSuggestedTitle(fn); + KTempFile tf; + tf.setAutoDelete(true); + tf.file()->writeBlock((const char*)r->m_buffer.buffer().data(), r->m_buffer.size()); + tf.sync(); + KFileMetaInfo kfmi(tf.name()); + if (!kfmi.isEmpty()) { + KFileMetaInfoItem i = kfmi.item("Name"); + if (i.isValid()) { + static_cast<CachedImage*>(r->object)->setSuggestedTitle(i.string()); + } else { + i = kfmi.item("Title"); + if (i.isValid()) { + static_cast<CachedImage*>(r->object)->setSuggestedTitle(i.string()); + } + } + } +#endif + } + } + + r->object->finish(); + +#ifdef LOADER_DEBUG + kdDebug( 6060 ) << "Loader:: JOB FINISHED " << r->object << ": " << r->object->url().string() << endl; +#endif + + delete r; + + if ( (m_requestsPending.count() != 0) && (m_requestsLoading.count() < MAX_JOB_COUNT / 2) ) + m_timer.start(0, true); +} + +void Loader::slotData( KIO::Job*job, const QByteArray &data ) +{ + Request *r = m_requestsLoading[job]; + if(!r) { + kdDebug( 6060 ) << "got data for unknown request!" << endl; + return; + } + + if ( !r->m_buffer.isOpen() ) + r->m_buffer.open( IO_WriteOnly ); + + r->m_buffer.writeBlock( data.data(), data.size() ); + + if(r->incremental) + r->object->data( r->m_buffer, false ); +} + +int Loader::numRequests( DocLoader* dl ) const +{ + int res = 0; + + QPtrListIterator<Request> pIt( m_requestsPending ); + for (; pIt.current(); ++pIt ) + if ( pIt.current()->m_docLoader == dl ) + res++; + + QPtrDictIterator<Request> lIt( m_requestsLoading ); + for (; lIt.current(); ++lIt ) + if ( lIt.current()->m_docLoader == dl ) + res++; + + return res; +} + +void Loader::cancelRequests( DocLoader* dl ) +{ + QPtrListIterator<Request> pIt( m_requestsPending ); + while ( pIt.current() ) { + if ( pIt.current()->m_docLoader == dl ) + { + CDEBUG << "canceling pending request for " << pIt.current()->object->url().string() << endl; + Cache::removeCacheEntry( pIt.current()->object ); + m_requestsPending.remove( pIt ); + } + else + ++pIt; + } + + //kdDebug( 6060 ) << "got " << m_requestsLoading.count() << "loading requests" << endl; + + QPtrDictIterator<Request> lIt( m_requestsLoading ); + while ( lIt.current() ) + { + if ( lIt.current()->m_docLoader == dl ) + { + //kdDebug( 6060 ) << "canceling loading request for " << lIt.current()->object->url().string() << endl; + KIO::Job *job = static_cast<KIO::Job *>( lIt.currentKey() ); + Cache::removeCacheEntry( lIt.current()->object ); + m_requestsLoading.remove( lIt.currentKey() ); + job->kill(); + //emit requestFailed( dl, pIt.current()->object ); + } + else + ++lIt; + } +} + +KIO::Job *Loader::jobForRequest( const DOM::DOMString &url ) const +{ + QPtrDictIterator<Request> it( m_requestsLoading ); + + for (; it.current(); ++it ) + { + CachedObject *obj = it.current()->object; + + if ( obj && obj->url() == url ) + return static_cast<KIO::Job *>( it.currentKey() ); + } + + return 0; +} + +// ---------------------------------------------------------------------------- + + +QDict<CachedObject> *Cache::cache = 0; +QPtrList<DocLoader>* Cache::docloader = 0; +QPtrList<CachedObject> *Cache::freeList = 0; +Loader *Cache::m_loader = 0; + +int Cache::maxSize = DEFCACHESIZE; +int Cache::totalSizeOfLRU; + +QPixmap *Cache::nullPixmap = 0; +QPixmap *Cache::brokenPixmap = 0; +QPixmap *Cache::blockedPixmap = 0; + +void Cache::init() +{ + if ( !cache ) + cache = new QDict<CachedObject>(401, true); + + if ( !docloader ) + docloader = new QPtrList<DocLoader>; + + if ( !nullPixmap ) + nullPixmap = new QPixmap; + + if ( !brokenPixmap ) + brokenPixmap = new QPixmap(KHTMLFactory::instance()->iconLoader()->loadIcon("file_broken", KIcon::Desktop, 16, KIcon::DisabledState)); + + if ( !blockedPixmap ) { + blockedPixmap = new QPixmap(); + blockedPixmap->loadFromData(blocked_icon_data, blocked_icon_len); + } + + if ( !m_loader ) + m_loader = new Loader(); + + if ( !freeList ) { + freeList = new QPtrList<CachedObject>; + freeList->setAutoDelete(true); + } +} + +void Cache::clear() +{ + if ( !cache ) return; +#ifdef CACHE_DEBUG + kdDebug( 6060 ) << "Cache: CLEAR!" << endl; + statistics(); +#endif + cache->setAutoDelete( true ); + +#ifndef NDEBUG + bool crash = false; + for (QDictIterator<CachedObject> it(*cache); it.current(); ++it) { + if (!it.current()->canDelete()) { + kdDebug( 6060 ) << " Object in cache still linked to" << endl; + kdDebug( 6060 ) << " -> URL: " << it.current()->url() << endl; + kdDebug( 6060 ) << " -> #clients: " << it.current()->count() << endl; + crash = true; +// assert(it.current()->canDelete()); + } + } + for (freeList->first(); freeList->current(); freeList->next()) { + if (!freeList->current()->canDelete()) { + kdDebug( 6060 ) << " Object in freelist still linked to" << endl; + kdDebug( 6060 ) << " -> URL: " << freeList->current()->url() << endl; + kdDebug( 6060 ) << " -> #clients: " << freeList->current()->count() << endl; + crash = true; + /* + QPtrDictIterator<CachedObjectClient> it(freeList->current()->m_clients); + for(;it.current(); ++it) { + if (dynamic_cast<RenderObject*>(it.current())) { + kdDebug( 6060 ) << " --> RenderObject" << endl; + } else + kdDebug( 6060 ) << " --> Something else" << endl; + }*/ + } +// assert(freeList->current()->canDelete()); + } + assert(!crash); +#endif + + delete cache; cache = 0; + delete nullPixmap; nullPixmap = 0; + delete brokenPixmap; brokenPixmap = 0; + delete blockedPixmap; blockedPixmap = 0; + delete m_loader; m_loader = 0; + delete docloader; docloader = 0; + delete freeList; freeList = 0; +} + +template<typename CachedObjectType, enum CachedObject::Type CachedType> +CachedObjectType* Cache::requestObject( DocLoader* dl, const KURL& kurl, const char* accept ) +{ + KIO::CacheControl cachePolicy = dl ? dl->cachePolicy() : KIO::CC_Verify; + + QString url = kurl.url(); + CachedObject* o = cache->find(url); + + if ( o && o->type() != CachedType ) { + removeCacheEntry( o ); + o = 0; + } + + if ( o && dl->needReload( o, url ) ) { + o = 0; + assert( cache->find( url ) == 0 ); + } + + if(!o) + { +#ifdef CACHE_DEBUG + kdDebug( 6060 ) << "Cache: new: " << kurl.url() << endl; +#endif + CachedObjectType* cot = new CachedObjectType(dl, url, cachePolicy, accept); + cache->insert( url, cot ); + if ( cot->allowInLRUList() ) + insertInLRUList( cot ); + o = cot; + } +#ifdef CACHE_DEBUG + else { + kdDebug( 6060 ) << "Cache: using pending/cached: " << kurl.url() << endl; + } +#endif + + + dl->insertCachedObject( o ); + + return static_cast<CachedObjectType *>(o); +} + +void Cache::preloadStyleSheet( const QString &url, const QString &stylesheet_data) +{ + CachedObject *o = cache->find(url); + if(o) + removeCacheEntry(o); + + CachedCSSStyleSheet *stylesheet = new CachedCSSStyleSheet(url, stylesheet_data); + cache->insert( url, stylesheet ); +} + +void Cache::preloadScript( const QString &url, const QString &script_data) +{ + CachedObject *o = cache->find(url); + if(o) + removeCacheEntry(o); + + CachedScript *script = new CachedScript(url, script_data); + cache->insert( url, script ); +} + +void Cache::flush(bool force) +{ + init(); + + if ( force || totalSizeOfLRU > maxSize + maxSize/4) { + for ( int i = MAX_LRU_LISTS-1; i >= 0 && totalSizeOfLRU > maxSize; --i ) + while ( totalSizeOfLRU > maxSize && m_LRULists[i].m_tail ) + removeCacheEntry( m_LRULists[i].m_tail ); + +#ifdef CACHE_DEBUG + statistics(); +#endif + } + + for ( freeList->first(); freeList->current(); ) { + CachedObject* p = freeList->current(); + if ( p->canDelete() ) + freeList->remove(); + else + freeList->next(); + } + +} + +void Cache::setSize( int bytes ) +{ + maxSize = bytes; + flush(true /* force */); +} + +void Cache::statistics() +{ + CachedObject *o; + // this function is for debugging purposes only + init(); + + int size = 0; + int msize = 0; + int movie = 0; + int images = 0; + int scripts = 0; + int stylesheets = 0; + QDictIterator<CachedObject> it(*cache); + for(it.toFirst(); it.current(); ++it) + { + o = it.current(); + switch(o->type()) { + case CachedObject::Image: + { + CachedImage *im = static_cast<CachedImage *>(o); + images++; + if(im->m != 0) + { + movie++; + msize += im->size(); + } + break; + } + case CachedObject::CSSStyleSheet: + stylesheets++; + break; + case CachedObject::Script: + scripts++; + break; + } + size += o->size(); + } + size /= 1024; + + kdDebug( 6060 ) << "------------------------- image cache statistics -------------------" << endl; + kdDebug( 6060 ) << "Number of items in cache: " << cache->count() << endl; + kdDebug( 6060 ) << "Number of cached images: " << images << endl; + kdDebug( 6060 ) << "Number of cached movies: " << movie << endl; + kdDebug( 6060 ) << "Number of cached scripts: " << scripts << endl; + kdDebug( 6060 ) << "Number of cached stylesheets: " << stylesheets << endl; + kdDebug( 6060 ) << "pixmaps: allocated space approx. " << size << " kB" << endl; + kdDebug( 6060 ) << "movies : allocated space approx. " << msize/1024 << " kB" << endl; + kdDebug( 6060 ) << "--------------------------------------------------------------------" << endl; +} + +void Cache::removeCacheEntry( CachedObject *object ) +{ + QString key = object->url().string(); + + cache->remove( key ); + removeFromLRUList( object ); + + for (const DocLoader* dl=docloader->first(); dl; dl=docloader->next() ) + dl->removeCachedObject( object ); + + if ( !object->free() ) { + Cache::freeList->append( object ); + object->m_free = true; + } +} + +static inline int FastLog2(unsigned int j) +{ + unsigned int log2; + log2 = 0; + if (j & (j-1)) + log2 += 1; + if (j >> 16) + log2 += 16, j >>= 16; + if (j >> 8) + log2 += 8, j >>= 8; + if (j >> 4) + log2 += 4, j >>= 4; + if (j >> 2) + log2 += 2, j >>= 2; + if (j >> 1) + log2 += 1; + + return log2; +} + +static LRUList* getLRUListFor(CachedObject* o) +{ + int accessCount = o->accessCount(); + int queueIndex; + if (accessCount == 0) { + queueIndex = 0; + } else { + int sizeLog = FastLog2(o->size()); + queueIndex = sizeLog/o->accessCount() - 1; + if (queueIndex < 0) + queueIndex = 0; + if (queueIndex >= MAX_LRU_LISTS) + queueIndex = MAX_LRU_LISTS-1; + } + return &m_LRULists[queueIndex]; +} + +void Cache::removeFromLRUList(CachedObject *object) +{ + CachedObject *next = object->m_next; + CachedObject *prev = object->m_prev; + + LRUList* list = getLRUListFor(object); + CachedObject *&head = getLRUListFor(object)->m_head; + + if (next == 0 && prev == 0 && head != object) { + return; + } + + object->m_next = 0; + object->m_prev = 0; + + if (next) + next->m_prev = prev; + else if (list->m_tail == object) + list->m_tail = prev; + + if (prev) + prev->m_next = next; + else if (head == object) + head = next; + + totalSizeOfLRU -= object->size(); +} + +void Cache::insertInLRUList(CachedObject *object) +{ + removeFromLRUList(object); + + assert( object ); + assert( !object->free() ); + assert( object->canDelete() ); + assert( object->allowInLRUList() ); + + LRUList* list = getLRUListFor(object); + + CachedObject *&head = list->m_head; + + object->m_next = head; + if (head) + head->m_prev = object; + head = object; + + if (object->m_next == 0) + list->m_tail = object; + + totalSizeOfLRU += object->size(); +} + +// -------------------------------------- + +void CachedObjectClient::setPixmap(const QPixmap &, const QRect&, CachedImage *) {} +void CachedObjectClient::setStyleSheet(const DOM::DOMString &/*url*/, const DOM::DOMString &/*sheet*/, const DOM::DOMString &/*charset*/) {} +void CachedObjectClient::notifyFinished(CachedObject * /*finishedObj*/) {} +void CachedObjectClient::error(int /*err*/, const QString &/*text*/) {} + +#undef CDEBUG + +#include "loader.moc" |