void QSGPainterNode::setContentsScale(qreal s) { if (s == m_contentsScale) return; m_contentsScale = s; markDirty(DirtyMaterial); }
void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time) { QHash<QString, QVariant> data = all_data.value(hash).toHash(); if (!data.contains("add_date")) { data["add_date"] = time; all_data[hash] = data; markDirty(); } }
void QSGNinePatchNode::setTexture(QSGTexture *texture) { if (texture == m_material.texture()) return; m_material.setTexture(texture); m_materialO.setTexture(texture); markDirty(DirtyMaterial); }
void QSGPainterNode::updateTexture() { m_texture->setHasAlphaChannel(!m_opaquePainting); m_material.setTexture(m_texture); m_materialO.setTexture(m_texture); markDirty(DirtyMaterial); }
void QSGPainterNode::setFillColor(const QColor &c) { if (c == m_fillColor) return; m_fillColor = c; markDirty(DirtyMaterial); }
void ImageLayerNode::updateYPos(const qreal pos) { QSGSimpleMaterial<ImageLayerState> *m = static_cast<QSGSimpleMaterial<ImageLayerState> *>(material()); m->state()->yPos = -(pos / m_height); markDirty(QSGNode::DirtyMaterial); }
/*! Sets the target rect of this texture node to \a r. */ void QSGSimpleTextureNode::setRect(const QRectF &r) { if (m_rect == r) return; m_rect = r; qsgsimpletexturenode_update(&m_geometry, texture(), m_rect); markDirty(DirtyGeometry); }
void DGSPictureLayer::setTexture( DResourcePtr tex ) { if (tex->getAs<DTexture>(false) != NULL) { mTexture = tex; markDirty(); } }
/*! Sets the method used to generate texture coordinates to \a mode. This can be used to obtain correct orientation of the texture. This is commonly needed when using a third party OpenGL library to render to texture as OpenGL has an inverted y-axis relative to Qt Quick. \sa textureCoordinatesTransform() */ void QSGSimpleTextureNode::setTextureCoordinatesTransform(QSGSimpleTextureNode::TextureCoordinatesTransformMode mode) { Q_D(QSGSimpleTextureNode); if (d->m_texCoordMode == mode) return; d->m_texCoordMode = mode; qsgsimpletexturenode_update(&m_geometry, texture(), m_rect, d->m_texCoordMode); markDirty(DirtyMaterial); }
/*! Sets the filtering to be used for this texture node to \a filtering. For smooth scaling, use QSGTexture::Linear; for normal scaling, use QSGTexture::Nearest. */ void QSGSimpleTextureNode::setFiltering(QSGTexture::Filtering filtering) { if (m_material.filtering() == filtering) return; m_material.setFiltering(filtering); m_opaque_material.setFiltering(filtering); markDirty(DirtyMaterial); }
void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h) { QHash<QString, QVariant> data = all_data[h.hash()].toHash(); bool was_seed = data.value("seed", false).toBool(); if (was_seed != h.is_seed()) { data["seed"] = !was_seed; all_data[h.hash()] = data; markDirty(); } }
void TorrentPersistentData::saveSavePath(const QString &hash, const QString &save_path) { Q_ASSERT(!hash.isEmpty()); qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path)); QHash<QString, QVariant> data = all_data.value(hash).toHash(); data["save_path"] = save_path; all_data[hash] = data; markDirty(); qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash)); }
void updateOperationDetails(RM_TableData *rel, recordTableInfo *rec, BM_PageHandle *pageHandle, int recordId) { char *data; recordId = 0; markDirty(rec->bufferManager, pageHandle); unpinPage(rec->bufferManager, pageHandle); forcePage(rec->bufferManager, pageHandle); tableInfoDetailsToFileData(rel->name, data, rec); }
void QSGAbstractSoftwareRenderer::setBackgroundRect(const QRect &rect) { if (m_background->rect().toRect() == rect) return; m_background->setRect(rect); renderableNode(m_background)->markGeometryDirty(); // Invalidate the whole scene when the background is resized markDirty(); }
void OgreNode::setSize(const QSize &size) { if (size == mSize) return; mSize = size; mDirtyFBO = true; markDirty(DirtyGeometry); }
void EnumParameter::setIndex(size_type value, bool forceNotification) { if ((m_index != value || forceNotification) && value < size()) { m_index = value; setIndexImpl(value, forceNotification); markDirty(ParameterField::Value | (forceNotification ? ParameterField::ForceUpdate : 0), true); } }
void DGSPictureLayer::setScalable( bool flag ) { if (mbScalable == flag) { return; } mbScalable = flag; markDirty(); }
void DGSPictureLayer::setRenderSize( const DGSize& size ) { if (mRenderSize == size) { return; } mRenderSize = size; markDirty(); }
void DGSPictureLayer::setWorldTransform( const DMatrix4& mat ) { if (mWorldTransform == mat) { return; } mWorldTransform = mat; markDirty(); }
void QSGNinePatchNode::setFiltering(QSGTexture::Filtering filtering) { if (m_material.filtering() == filtering) return; m_material.setFiltering(filtering); m_materialO.setFiltering(filtering); markDirty(DirtyMaterial); }
void ShaderEffectItem::disconnectPropertySignals() { disconnect(this, 0, this, SLOT(markDirty())); for (int i = 0; i < m_sources.size(); ++i) { SourceData &source = m_sources[i]; disconnect(this, 0, source.mapper, 0); disconnect(source.mapper, 0, this, 0); } }
void SceneNode::setScale(const Vector3& scale) { if (scale.x_ == 0.0f || scale.y_ == 0.0f || scale.z_ == 0.0f) return; scale_ = scale; markDirty(); }
void InputLayoutCache::clear() { for (InputLayoutMap::iterator i = mInputLayoutMap.begin(); i != mInputLayoutMap.end(); i++) { SafeRelease(i->second.inputLayout); } mInputLayoutMap.clear(); markDirty(); }
void SceneNode::setTransform( Vec3f trans, Vec3f rot, Vec3f scale ) { _relTrans = Matrix4f(); _relTrans.scale( scale.x, scale.y, scale.z ); _relTrans.rotate( degToRad( rot.x ), degToRad( rot.y ), degToRad( rot.z ) ); _relTrans.translate( trans.x, trans.y, trans.z ); markDirty(); }
void IntegerParameter::setValue(value_type value, bool forceNotification) { if (m_value != value || forceNotification) { m_value = value; setValueImpl(value, forceNotification); markDirty(ParameterField::Value | (forceNotification ? ParameterField::ForceUpdate : 0), true); } }
/*! Sets the texture of this texture node to \a texture. \warning A texture node must have a texture before being added to the scenegraph to be rendered. */ void QSGSimpleTextureNode::setTexture(QSGTexture *texture) { if (m_material.texture() == texture) return; m_material.setTexture(texture); m_opaque_material.setTexture(texture); qsgsimpletexturenode_update(&m_geometry, texture, m_rect); markDirty(DirtyMaterial); }
void removeFromMiddle(TableManager *tableManager, Pager *dp, int pageno){ BM_PageHandle pageHandler2; BM_PageHandle pageHandler; Pager *pagerData; Pager *tmp_dp2; pinPage(&tableManager->pool, &pageHandler, (PageNumber)dp->prev); pinPage(&tableManager->pool, &pageHandler2, (PageNumber)dp->next); pagerData= (Pager*) pageHandler.data; tmp_dp2= (Pager*) pageHandler2.data; markDirty(&tableManager->pool, &pageHandler); markDirty(&tableManager->pool, &pageHandler2); pagerData->next= dp->next; tmp_dp2->prev= dp->prev; unpinPage(&tableManager->pool, &pageHandler); unpinPage(&tableManager->pool, &pageHandler2); dp->next=dp->prev= 0; }
void MapNode::setSize(const QSize &size) { if (size == m_size) return; m_size = size; m_dirtyFBO = true; m_initialized = false; markDirty(DirtyGeometry); }
/*! Sets the source rect of this texture node to \a r. \since 5.5 */ void QSGSimpleTextureNode::setSourceRect(const QRectF &r) { Q_D(QSGSimpleTextureNode); if (d->sourceRect == r) return; d->sourceRect = r; qsgsimpletexturenode_update(&m_geometry, texture(), m_rect, d->sourceRect, d->texCoordMode); markDirty(DirtyGeometry); }
void QSGNode::setFlag(Flag f, bool enabled) { if (bool(m_nodeFlags & f) == enabled) return; m_nodeFlags ^= f; Q_ASSERT(int(UsePreprocess) == int(DirtyUsePreprocess)); int changedFlag = f & UsePreprocess; if (changedFlag) markDirty(DirtyState(changedFlag)); }