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));
}
