CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request) { if (Frame* f = frame()) { Settings* settings = f->settings(); if (!f->loader()->client()->allowImages(!settings || settings->areImagesEnabled())) return 0; if (f->loader()->pageDismissalEventBeingDispatched()) { KURL requestURL = request.url(); if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL)) PingLoader::loadImage(f, requestURL); return 0; } } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String())); if (resource) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE resource->setAutoLoadWasPreventedBySettings(!autoLoadImages() || shouldBlockNetworkImage(request.url())); #else resource->setAutoLoadWasPreventedBySettings(!autoLoadImages()); #endif if (autoLoadImages() && resource->stillNeedsLoad()) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE if (shouldBlockNetworkImage(request.url())) { return resource; } #endif resource->setLoading(true); load(resource, true); } } return resource; }
CachedScript* DocLoader::requestScript(const String& url, const String& charset) { // <lab126> KINDLE_PRINT_MODULE(Kindle_Debug_Resources, "Script: %s\n", url.latin1().data()); // </lab126> return static_cast<CachedScript*>(requestResource(CachedResource::Script, url, charset)); }
CachedImage* DocLoader::requestImage(const String& url) { CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) { resource->setLoading(true); cache()->loader()->load(this, resource, true); } return resource; }
void ObjectScene::syncQuad(Kite::KQuadCom *Quad) { auto pixItem = (QGraphicsPixmapItem *)Quad->getSceneItem(); Kite::KRectF32 brect; Quad->getBoundingRect(brect); if (!Quad->getAtlasTextureArray().str.empty()) { Kite::KAtlasTextureArray *tarray = nullptr; emit(tarray = (Kite::KAtlasTextureArray *)requestResource(Quad->getAtlasTextureArray().str.c_str())); if (tarray) { auto atex = tarray->getItem(Quad->getTextureArrayIndex()); if (atex) { Kite::KTexture *tex = atex->getTexture(); if (tex) { Kite::KImage image; tex->getImage(image); QImage qimage(image.getPixelsData(), image.getWidth(), image.getHeight(), QImage::Format::Format_RGBA8888); auto procimgae = qimage.copy(Quad->getAtlasItem().xpos, Quad->getAtlasItem().ypos, Quad->getAtlasItem().width, Quad->getAtlasItem().height) .mirrored(Quad->getAtlasItem().getFlipH(), !Quad->getAtlasItem().getFlipV()) .scaled(Quad->getWidth(), Quad->getHeight()); //blend if (Quad->getBlendColor() != Kite::KColor(Kite::Colors::WHITE)) { QColor col(Quad->getBlendColor().getR(), Quad->getBlendColor().getG(), Quad->getBlendColor().getB(), Quad->getBlendColor().getA()); auto alpha = procimgae.alphaChannel(); for (int x = 0; x != procimgae.width(); ++x) { for (int y(0); y != procimgae.height(); ++y) { if (qAlpha(procimgae.pixel(x, y)) == 0) continue; // transparrent pixels QColor icol(procimgae.pixel(x, y)); icol.setRed(BLEND_Multiply(icol.red(), col.red())); icol.setBlue(BLEND_Multiply(icol.blue(), col.blue())); icol.setGreen(BLEND_Multiply(icol.green(), col.green())); procimgae.setPixel(x, y, icol.rgb()); } } procimgae.setAlphaChannel(alpha); } pixItem->setPixmap(QPixmap::fromImage(procimgae)); pixItem->setOpacity(Quad->getBlendColor().getGLA()); return; } } } } QPixmap pm(Quad->getWidth(), Quad->getHeight()); pm.fill(QColor(Quad->getBlendColor().getR(), Quad->getBlendColor().getG(), Quad->getBlendColor().getB(), Quad->getBlendColor().getA())); pixItem->setPixmap(pm); pixItem->setOpacity(Quad->getBlendColor().getGLA()); }
CachedImage* DocLoader::requestImage(const String& url) { // <lab126> KINDLE_PRINT_MODULE(Kindle_Debug_Resources, "Image Request: %s\n", url.latin1().data()); // </lab126> CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) { resource->setLoading(true); cache()->loader()->load(this, resource, true); } return resource; }
CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request) { if (Frame* f = frame()) { if (f->loader()->pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) { KURL requestURL = request.resourceRequest().url(); if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL)) PingLoader::loadImage(f, requestURL); return 0; } } request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer); return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request).get()); }
CachedImage* DocLoader::requestImage(const String& url) { if (Frame* f = frame()) { Settings* settings = f->settings(); if (!f->loader()->client()->allowImages(!settings || settings->areImagesEnabled())) return 0; } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) { resource->setLoading(true); cache()->loader()->load(this, resource, true); } return resource; }
CachedCSSStyleSheet* DocLoader::requestCSSStyleSheet(const String& url, const String& charset, bool isUserStyleSheet) { // FIXME: Passing true for "skipCanLoadCheck" here in the isUserStyleSheet case won't have any effect // if this resource is already in the cache. It's theoretically possible that what's in the cache already // is a load that failed because of the canLoad check. Probably not an issue in practice. CachedCSSStyleSheet *sheet = static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, url, &charset, isUserStyleSheet, !isUserStyleSheet)); // A user style sheet can outlive its DocLoader so don't store any pointers to it if (sheet && isUserStyleSheet) { sheet->setDocLoader(0); m_docResources.remove(sheet->url()); } return sheet; }
void DocLoader::requestPreload(CachedResource::Type type, const String& url, const String& charset) { String encoding; if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet) encoding = charset.isEmpty() ? m_doc->frame()->loader()->encoding() : charset; CachedResource* resource = requestResource(type, url, encoding, true); if (!resource || m_preloads.contains(resource)) return; resource->increasePreloadCount(); m_preloads.add(resource); #if PRELOAD_DEBUG printf("PRELOADING %s\n", resource->url().latin1().data()); #endif }
CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request) { if (Frame* f = frame()) { if (f->loader()->pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) { KURL requestURL = request.url(); if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL)) PingLoader::loadImage(f, requestURL); return 0; } } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) resource->load(this, defaultCachedResourceOptions()); return resource; }
void AliveResourceInfoUpdater::update() { qDebug()<<"-------------------------------------"; qDebug()<<"Alive Resource Info Updateing...."; qDebug()<<"-------------------------------------"; AliveListRequester *aliverequester\ = new AliveListRequester(alive_list_version \ ,tracker \ ,peer2res_version_map \ ,offline_res_peer_list); connect(aliverequester, SIGNAL(error(QAbstractSocket::SocketError)), \ this, SLOT(errorHandler_for_req_lst(QAbstractSocket::SocketError))); connect(aliverequester, SIGNAL(destroyed()), \ this, SLOT(requestResource())); aliverequester->start(); }
CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request) { if (Frame* f = frame()) { Settings* settings = f->settings(); if (!f->loader()->client()->allowImages(!settings || settings->areImagesEnabled())) return 0; if (f->loader()->pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) { KURL requestURL = request.url(); if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL)) PingLoader::loadImage(f, requestURL); return 0; } } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) resource->load(this); return resource; }
CachedImage* DocLoader::requestImage(const String& url) { if (Frame* f = frame()) { Settings* settings = f->settings(); if (!f->loader()->client()->allowImages(!settings || settings->areImagesEnabled())) return 0; } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE if (shouldBlockNetworkImage(url)) { return resource; } #endif resource->setLoading(true); cache()->loader()->load(this, resource, true); } return resource; }
void CachedResourceLoader::requestPreload(CachedResource::Type type, ResourceRequest& request, const String& charset) { String encoding; if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet) encoding = charset.isEmpty() ? m_document->charset() : charset; CachedResource* resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true); if (!resource || (m_preloads && m_preloads->contains(resource))) return; resource->increasePreloadCount(); if (!m_preloads) m_preloads = adoptPtr(new ListHashSet<CachedResource*>); m_preloads->add(resource); #if PRELOAD_DEBUG printf("PRELOADING %s\n", resource->url().latin1().data()); #endif }
CachedImage* CachedResourceLoader::requestImage(const String& url) { if (Frame* f = frame()) { Settings* settings = f->settings(); if (!f->loader()->client()->allowImages(!settings || settings->areImagesEnabled())) return 0; if (f->loader()->pageDismissalEventBeingDispatched()) { KURL completeURL = m_document->completeURL(url); if (completeURL.isValid() && canRequest(CachedResource::ImageResource, completeURL)) PingLoader::loadImage(f, completeURL); return 0; } } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) { resource->setLoading(true); load(resource, true); } return resource; }
void CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest& request, const String& charset) { String encoding; if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet) encoding = charset.isEmpty() ? m_document->charset() : charset; request.setCharset(encoding); request.setForPreload(true); CachedResourceHandle<CachedResource> resource = requestResource(type, request); if (!resource || (m_preloads && m_preloads->contains(resource.get()))) return; resource->increasePreloadCount(); if (!m_preloads) m_preloads = adoptPtr(new ListHashSet<CachedResource*>); m_preloads->add(resource.get()); #if PRELOAD_DEBUG printf("PRELOADING %s\n", resource->url().latin1().data()); #endif }
CachedCSSStyleSheet* DocLoader::requestCSSStyleSheet(const String& url, const String& charset) { return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, url, charset)); }
CachedRawResource* CachedResourceLoader::requestRawResource(ResourceRequest& request, const ResourceLoaderOptions& options) { return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request, String(), options, ResourceLoadPriorityUnresolved, false)); }
CachedResource* CachedResourceLoader::requestLinkResource(CachedResource::Type type, ResourceRequest& request, ResourceLoadPriority priority) { ASSERT(frame()); ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkPrerender || type == CachedResource::LinkSubresource); return requestResource(type, request, String(), defaultCachedResourceOptions(), priority); }
CachedXSLStyleSheet* CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request) { return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions())); }
CachedScript* CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset) { return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions())); }
CachedCSSStyleSheet* CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority) { return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority)); }
CachedShader* CachedResourceLoader::requestShader(ResourceRequest& request) { return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request, String(), defaultCachedResourceOptions())); }
CachedTextTrack* CachedResourceLoader::requestTextTrack(ResourceRequest& request) { return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request, String(), defaultCachedResourceOptions())); }
CachedFont* CachedResourceLoader::requestFont(ResourceRequest& request) { return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions())); }
CachedXBLDocument* DocLoader::requestXBLDocument(const String& url) { return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XBL, url, String())); }
CachedFont* DocLoader::requestFont(const String& url) { return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, url, String())); }
ResourcePtr<ImageResource> ResourceFetcher::fetchImage(FetchRequest& request) { request.setDefer(clientDefersImage(request.resourceRequest().url()) ? FetchRequest::DeferredByClient : FetchRequest::NoDefer); ResourcePtr<Resource> resource = requestResource(Resource::Image, request); return resource && resource->type() == Resource::Image ? toImageResource(resource) : 0; }
ResourcePtr<FontResource> ResourceFetcher::fetchFont(FetchRequest& request) { ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone); request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextFont); return toFontResource(requestResource(Resource::Font, request)); }
CachedScript* DocLoader::requestScript(const String& url, const String& charset) { return static_cast<CachedScript*>(requestResource(CachedResource::Script, url, charset)); }