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