C++ setLoading函数代码示例

CachedImage::CachedImage(const URL& url, Image* image, SessionID sessionID)
    : CachedResource(ResourceRequest(url), ImageResource, sessionID)
    , m_image(image)
    , m_isManuallyCached(false)
    , m_shouldPaintBrokenImage(true)
{
    setStatus(Cached);
    setLoading(false);
}

    void Engine::SurfaceChanged(int width, int height) {

        DEBUG_LOG_WRITE_D("TAG", "Changed");
        SetShader("shaders/draw", ShaderType::Draw, true);
        this->InitiseRenderer();
        this->SetResolution(Maths::Vector2<int>(width, height));

        setLoading(false);
    }

ImageResource::ImageResource(const ResourceRequest& resourceRequest, blink::Image* image)
    : Resource(resourceRequest, Image)
    , m_image(image)
{
    WTF_LOG(Timers, "new ImageResource(ResourceRequest, Image) %p", this);
    setStatus(Cached);
    setLoading(false);
    setCustomAcceptHeader();
}

void LWJGLVersionList::loadList()
{
	Q_ASSERT_X(!m_loading, "loadList", "list is already loading (m_loading is true)");

	setLoading(true);
	auto worker = MMC->qnam();
	reply = worker->get(QNetworkRequest(QUrl(RSS_URL)));
	connect(reply, SIGNAL(finished()), SLOT(netRequestComplete()));
}

void CachedXSLStyleSheet::finishLoading(SharedBuffer* data)
{
    m_data = data;
    setEncodedSize(data ? data->size() : 0);
    if (data)
        m_sheet = m_decoder->decodeAndFlush(data->data(), encodedSize());
    setLoading(false);
    checkNotify();
}

void CachedImage::load(CachedResourceLoader* cachedResourceLoader)
{
#ifdef ANDROID_BLOCK_NETWORK_IMAGE
    if (!cachedResourceLoader || (cachedResourceLoader->autoLoadImages() && !cachedResourceLoader->shouldBlockNetworkImage(m_url)))
#else
    if (!cachedResourceLoader || cachedResourceLoader->autoLoadImages())
#endif
        CachedResource::load(cachedResourceLoader, true, DoSecurityCheck, true);
    else
        setLoading(false);
}

void CachedImage::error(CachedResource::Status status)
{
    checkShouldPaintBrokenImage();
    clear();
    setStatus(status);
    ASSERT(errorOccurred());
    m_data.clear();
    notifyObservers();
    setLoading(false);
    checkNotify();
}

void DocumentLoader::prepareForLoadStart()
{
    ASSERT(!m_isStopping);
    setPrimaryLoadComplete(false);
    ASSERT(frameLoader());
    clearErrors();
    
    setLoading(true);
    
    frameLoader()->prepareForLoadStart();
}

    void Engine::SurfaceCreated() {

        setLoading(true);

        DEBUG_LOG_WRITE_V("Render", "Surface created");

        Assets::LoadAsset("textures/air_hockey_surface", Assets::TEXTURE);
        Assets::LoadAsset("textures/tilesheet", Assets::AssetType::TEXTURE);
        Assets::LoadAsset("shaders/draw", Assets::SHADER);
        Assets::LoadAsset("shaders/tile", Assets::SHADER);
    }

void DeviceSettingsItem::setDevice(const Device *device)
{
    connect(device, &Device::nameChanged, m_titleLabel, &NormalLabel::setText);
    connect(device, &Device::stateChanged, this, &DeviceSettingsItem::onDeviceStateChanged);
    connect(device, &Device::pairedChanged, this, &DeviceSettingsItem::onDevicePairedChanged);
    connect(device, &Device::connectingChanged, this, &DeviceSettingsItem::setLoading);

    m_titleLabel->setText(device->name());
    setLoading(device->connecting());
    onDeviceStateChanged(device->state());
    onDevicePairedChanged(device->paired());
}

void LWJGLVersionList::loadList()
{
	Q_ASSERT_X(!m_loading, "loadList", "list is already loading (m_loading is true)");

	setLoading(true);
	auto worker = MMC->qnam();
	QNetworkRequest req(QUrl(RSS_URL));
	req.setRawHeader("Accept", "text/xml");
	req.setRawHeader("User-Agent", "MultiMC/5.0 (Uncached)");
	reply = worker->get(req);
	connect(reply, SIGNAL(finished()), SLOT(netRequestComplete()));
}

void CachedImage::load(CachedResourceLoader& loader)
{
    if (loader.shouldPerformImageLoad(url()))
        CachedResource::load(loader);
    else
        setLoading(false);

    if (m_loader) {
        m_allowSubsampling = m_loader->frameLoader()->frame().settings().imageSubsamplingEnabled();
        m_allowAsyncImageDecoding = m_loader->frameLoader()->frame().settings().asyncImageDecodingEnabled();
        m_showDebugBackground = m_loader->frameLoader()->frame().settings().showDebugBorders();
    }
}

void CachedCSSStyleSheet::finishLoading(ResourceBuffer* data)
{
    m_data = data;
    setEncodedSize(m_data.get() ? m_data->size() : 0);
    // Decode the data to find out the encoding and keep the sheet text around during checkNotify()
    if (m_data) {
        m_decodedSheetText = m_decoder->decode(m_data->data(), m_data->size());
        m_decodedSheetText.append(m_decoder->flush());
    }
    setLoading(false);
    checkNotify();
    // Clear the decoded text as it is unlikely to be needed immediately again and is cheap to regenerate.
    m_decodedSheetText = String();
}

void RunModel::load(const QString& search)
{
    if (isLoading())
        return;

    mSearch = search;

    setLoading(true);
    QNetworkReply * reply =  TorrentServerManager::i()->getResultList(mOffset, search);
    connect(reply,SIGNAL(finished()),this,SLOT(loadded()));



}

void CachedXSLStyleSheet::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
    if (!allDataReceived)
        return;

    m_data = data;     
    setEncodedSize(m_data.get() ? m_data->size() : 0);
    if (m_data.get()) {
        m_sheet = String(m_decoder->decode(m_data->data(), encodedSize()));
        m_sheet += m_decoder->flush();
    }
    setLoading(false);
    checkNotify();
}