void XVWindow::toggleFullscreen() {
int newX, newY, newWidth, newHeight;
Window childWindow;
XWindowAttributes xwattributes;
if (_state.fullscreen) {
// not needed with EWMH fs
if ( ! (_wmType & wm_FULLSCREEN) ) {
newX = _state.oldx;
newY = _state.oldy;
newWidth = _state.oldWidth;
newHeight = _state.oldHeight;
setDecoration(true);
}
// removes fullscreen state if wm supports EWMH
setEWMHFullscreen(_NET_WM_STATE_REMOVE);
} else {
// sets fullscreen state if wm supports EWMH
setEWMHFullscreen(_NET_WM_STATE_ADD);
// not needed with EWMH fs - save window coordinates/size and discover fullscreen window size
if ( ! (_wmType & wm_FULLSCREEN) ) {
newX = 0;
newY = 0;
newWidth = DisplayWidth(_display, DefaultScreen(_display));
newHeight = DisplayHeight(_display, DefaultScreen(_display));
setDecoration(false);
XFlush(_display);
XTranslateCoordinates(_display, _XVWindow, RootWindow(_display, DefaultScreen(_display)),
0,0,&_state.oldx,&_state.oldy, &childWindow);
XGetWindowAttributes(_display, _XVWindow, &xwattributes);
_state.oldWidth = xwattributes.width;
_state.oldHeight = xwattributes.height;
}
}
// not needed with EWMH fs - create a screen-filling window on top and turn of decorations
if (!(_wmType & wm_FULLSCREEN) ) {
setSizeHints(newX, newY, _XVImage->width, _XVImage->height, newWidth, newHeight);
setLayer((!_state.fullscreen) ? 0 : 1);
XMoveResizeWindow(_display, _XVWindow, newX, newY, newWidth, newHeight);
}
/* some WMs lose ontop after fullscreeen */
if ((_state.fullscreen) & _state.ontop) {
setLayer(1);
}
XMapRaised(_display, _XVWindow);
XRaiseWindow(_display, _XVWindow);
XFlush(_display);
_state.fullscreen=!_state.fullscreen;
}
void WrapComponent::render(sf::RenderTarget& target, sf::RenderStates states)
{
setLayer(mRnd->getLayer());
if (!mGrid || !mGrid->getWrapX())
return;
float tsize = static_cast<float>(TILE_SIZE);
sf::Vector2f pos = states.transform.transformPoint(sf::Vector2f());
float currentOffsetX = -mGrid->getSizeX()*tsize;
sf::RenderStates leftStates = states;
while (pos.x+currentOffsetX > target.getView().getCenter().x-target.getView().getSize().x/2)
{
leftStates.transform.translate(-mGrid->getSizeX()*tsize, 0.f);
mRnd->render(target, leftStates);
currentOffsetX -= mGrid->getSizeX()*tsize;
}
currentOffsetX = mGrid->getSizeX()*tsize;
sf::RenderStates rightStates = states;
while (pos.x+currentOffsetX < target.getView().getCenter().x+target.getView().getSize().x/2)
{
rightStates.transform.translate(mGrid->getSizeX()*tsize, 0.f);
mRnd->render(target, rightStates);
currentOffsetX += mGrid->getSizeX()*tsize;
}
}
LayerEditScene::LayerEditScene(Layer *layer, QObject *parent)
: QGraphicsScene(parent),
_layer(layer),
_previewSize(228, 128)
{
setLayer(_layer);
}
void
psdHandle::setLayer(QStringList& p_rStrList,PsdLayers layers, QStringList& p_rImageList, int level)
{
if(NULL == layers)
return;
QString rResult;
vector<shared_ptr<PsdLayer> >::reverse_iterator iter = layers->rbegin(), end = layers->rend();
for (; iter != end; iter++)
{
shared_ptr<PsdLayer> layer = *iter;
if (layer->getType() == PsdLayer::LayerTypeGroup)
{
concate(rResult,layer->getName(),level);
//printf("%*s+ %s(%d)\n", level, "", layer->getName(),level);
p_rStrList << rResult;
setLayer(p_rStrList,((PsdLayerGroup *) layer.get())->getLayers(), p_rImageList,level + 2);
}
else
{
layerImage(layers,p_rImageList);
concate(rResult,layer->getName(),level);
p_rStrList << rResult;
//printf("%*s- %s(%d)\n", level, "", layer->getName(),level);
}
}
}
void Layer::configure( const string name, const int layer, const Color &fillColor, const Color &borderColor, const StippleMask stippleMask ) {
setName( name );
setLayer( layer );
setFillColor( fillColor );
setBorderColor( borderColor );
setStippleMask( stippleMask );
} // end method
/*!
Creates a new QCPLayerable instance.
Since QCPLayerable is an abstract base class, it can't be instantiated directly. Use one of the
derived classes.
If \a plot is provided, it automatically places itself on the layer named \a targetLayer. If \a
targetLayer is an empty string, it places itself on the current layer of the plot (see \ref
QCustomPlot::setCurrentLayer).
It is possible to provide 0 as \a plot. In that case, you should assign a parent plot at a later
time with \ref initializeParentPlot.
The layerable's parent layerable is set to \a parentLayerable, if provided. Direct layerable parents
are mainly used to control visibility in a hierarchy of layerables. This means a layerable is
only drawn, if all its ancestor layerables are also visible. Note that \a parentLayerable does
not become the QObject-parent (for memory management) of this layerable, \a plot does.
*/
QCPLayerable::QCPLayerable(QCustomPlot *plot, QString targetLayer, QCPLayerable *parentLayerable) :
QObject(plot),
mVisible(true),
mParentPlot(plot),
mParentLayerable(parentLayerable),
mLayer(0),
mAntialiased(true)
{
if (mParentPlot)
{
if (targetLayer.isEmpty())
setLayer(mParentPlot->currentLayer());
else if (!setLayer(targetLayer))
qDebug() << Q_FUNC_INFO << "setting QCPlayerable initial layer to" << targetLayer << "failed.";
}
}
RenderObjectPtr
MeshRenderComponent::buildRenderObject(MeshPropertyPtr mesh, RenderBufferPtr buffer) noexcept
{
auto material = this->getMaterial(mesh->getMaterialID());
if (material)
{
auto renderObject = std::make_shared<RenderMesh>();
renderObject->setRenderBuffer(buffer);
renderObject->setBoundingBox(mesh->getBoundingBox());
renderObject->setRenderListener(this);
renderObject->setMaterial(material);
renderObject->setCastShadow(this->getCastShadow());
renderObject->setReceiveShadow(this->getReceiveShadow());
renderObject->setLayer(this->getGameObject()->getLayer());
renderObject->setTransform(this->getGameObject()->getTransform());
renderObject->setTransformInverse(this->getGameObject()->getTransformInverse());
renderObject->setTransformInverseTranspose(this->getGameObject()->getTransformInverseTranspose());
return renderObject;
}
return nullptr;
}
void Chunk::open( const tstring& path )
{
tinyxml2::XMLDocument doc;
if (tinyxml2::XML_SUCCESS != doc.LoadFile(path.c_str()))
{
return;
}
tinyxml2::XMLElement* ele = doc.RootElement();
if (NULL == ele)
{
return;
}
tinyxml2::XMLElement* tex= ele->FirstChildElement("layer");
eTerrainLayer l = eTerrainLayer_0;
while (tex)
{
//
{
const char* n = tex->Attribute("texture");
if (NULL != n)
{
setLayer(l, n);
}
}
tex = tex->NextSiblingElement("layer");
l = (eTerrainLayer)(l + 1);
}
//
tex= ele->FirstChildElement("model");
while(tex)
{
const char* n = tex->Attribute("file");
if (NULL != n)
{
EntityInstance* i = getSceneManager()->addEntityInstance(n);
if (i)
{
Vector3 pos = Vector3::Zero;
tex->QueryVector3Attribute("position", &pos);
i->setPosition(pos);
//
{
Vector3 pos = Vector3::One;
tex->QueryVector3Attribute("setScale", &pos);
i->setScale(pos);
}
//
{
const char* n = tex->Attribute("animation");
if (NULL != n)
{
i->setAnimation(n);
}
}
}
}
tex = tex->NextSiblingElement("model");
}
}
void QgsLabelingWidget::resetSettings()
{
if ( mOldSettings )
{
mLayer->setLabeling( mOldSettings.release() );
}
setLayer( mLayer );
}
void QgsBullsEyeWidget::updateSelectedLayer( QgsMapLayer* layer )
{
QgsBullsEyeLayer* bullsEyeLayer = dynamic_cast<QgsBullsEyeLayer*>( layer );
if ( bullsEyeLayer )
{
setLayer( bullsEyeLayer );
}
}
void QgsFieldExpressionWidget::setLayer( QgsMapLayer *layer )
{
QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer );
if ( vl )
{
setLayer( vl );
}
}
void QgsFieldComboBox::setLayer( QgsMapLayer *layer )
{
QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer );
if ( vl )
{
setLayer( vl );
}
}
void QgsLayerStylingWidget::layerAboutToBeRemoved( QgsMapLayer *layer )
{
if ( layer == mCurrentLayer )
{
mAutoApplyTimer->stop();
setLayer( nullptr );
}
}
void ComponentDock::layerChanged(int Value) {
if (eman != nullptr) {
auto ent = eman->getEntity(currEntity);
if (ent) {
ent->setLayer((unsigned char)Value);
emit(entityLayerChanged(ent));
}
}
}
void CBattleScene::onEnter()
{
GleeCCLayer* layer = (GleeCCLayer *)getLayer();
if(!layer)
{
layer = GleeCore::getCCLayer("LCBattleScene");
setLayer(layer->getCCLayer());
layer->updateCCLayer(NULL);
}
}
HRESULT MainElement::Initialize(UVector2 Size)
{
setName("MainElement");
setLayer(0);
m_elementPos = UVector2(0, 0);
m_elementSize = Size;
return S_OK;
}
// This copy constructor is used for cloning nodes in the tree, and it doesn't make sense
// to clone the relationship pointers, so don't copy that information from the original node.
ScrollingStateNode::ScrollingStateNode(const ScrollingStateNode& stateNode, ScrollingStateTree& adoptiveTree)
: m_nodeType(stateNode.nodeType())
, m_nodeID(stateNode.scrollingNodeID())
, m_changedProperties(stateNode.changedProperties())
, m_scrollingStateTree(adoptiveTree)
, m_parent(nullptr)
{
if (hasChangedProperty(ScrollLayer))
setLayer(stateNode.layer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
scrollingStateTree().addNode(this);
}
void QgsLabelingWidget::resetSettings()
{
if ( mOldSettings.data() )
{
if ( mOldSettings->type() == "simple" )
{
mOldPalSettings.writeToLayer( mLayer );
}
mLayer->setLabeling( mOldSettings.take() );
}
setLayer( mLayer );
}
void QgsSpatialQueryDialog::on_cbReferenceLayer_currentIndexChanged( int index )
{
setLayer( false, index );
evaluateCheckBoxLayer( false );
populateCbOperation();
if ( gbResultQuery->isVisible() )
{
visibleResult( false );
}
} // QgsSpatialQueryDialog::on_cbReferenceLayer_currentIndexChanged(int index);
void QgsBullsEyeWidget::currentLayerChanged( int cur )
{
QgsBullsEyeLayer* layer = dynamic_cast<QgsBullsEyeLayer*>( QgsMapLayerRegistry::instance()->mapLayer( ui.comboBoxLayer->itemData( cur ).toString() ) );
if ( layer )
{
setLayer( layer );
}
else
{
ui.widgetLayerSetup->setEnabled( false );
}
}
ScoreCenter::~ScoreCenter()
{
setLayer(NULL);
if(_dropType) _dropType->removeAllObjects();
if(_dropNum) _dropNum->removeAllObjects();
if(_dropBornX) _dropBornX->removeAllObjects();
if(_dropBornY) _dropBornY->removeAllObjects();
setDropTypes(NULL);
setDropNums(NULL);
setDropBornX(NULL);
setDropBornY(NULL);
}
QgsLabelingWidget::QgsLabelingWidget( QgsVectorLayer *layer, QgsMapCanvas *canvas, QWidget *parent )
: QgsMapLayerConfigWidget( layer, canvas, parent )
, mLayer( layer )
, mCanvas( canvas )
{
setupUi( this );
connect( mEngineSettingsButton, &QAbstractButton::clicked, this, &QgsLabelingWidget::showEngineConfigDialog );
connect( mLabelModeComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLabelingWidget::labelModeChanged );
setLayer( layer );
}
Text::Text( Canvas &canvas, Text &ao )
{
Dout( dc::notice, *this << " Text::Text copy constructor" );
o = evas_object_text_add( canvas.obj() );
init();
setGeometry( ao.getGeometry() );
setLayer( ao.getLayer() );
setText( ao.getText() );
setClip( ao.getClip() );
setFont( ao.getFontName(), getFontSize () );
setColor( ao.getColor() );
setVisible( ao.isVisible() );
}
EvasText::EvasText( EvasText* ao, EvasCanvas* canvas )
{
Dout( dc::notice, *this << " EvasText::EvasText copy constructor" );
o = evas_object_text_add( canvas->obj() );
init( "text" );
setGeometry( ao->geometry() );
setLayer( ao->layer() );
setText( ao->text() );
setClip( ao->clip() );
setFont( ao->font() );
setColor( ao->color() );
setVisible( ao->isVisible() );
}
void QgsSpatialQueryDialog::initGui()
{
mRubberSelectId->setStyle( 250, 0, 0, 2 ); // Same identify
visibleResult( false );
populateTypeItems();
populateCbTargetLayer();
if ( cbTargetLayer->count() > 1 )
{
setLayer( true, 0 );
setSelectedGui();
evaluateCheckBoxLayer( true );
populateCbReferenceLayer();
setLayer( false, 0 );
evaluateCheckBoxLayer( false );
populateCbOperation();
}
else
{
bbMain->button( QDialogButtonBox::Apply )->hide();
}
populateCbResulFor(); // Depend if Target is selected
adjustSize();
} // QgsSpatialQueryDialog::initGui()
bool XmasWidget::LoadWidget(std::string, double _x, double _y, std::string _id)
{
std::string witem = "calaos/widget/xmas";
if (!LoadEdje(witem))
{
return false;
}
setLayer(500);
EdjeObject::Show();
clip = evas_object_rectangle_add(evas);
evas_object_show(clip);
edje_object_part_swallow(edje, "widget.swallow", clip);
Resize(1024, 768);
//create some flakes
for (int i = 0;i < MAX_FLAKE;i++)
{
std::string type;
if (i < MAX_FLAKE / 3) type = "flake_small";
else if (i >= MAX_FLAKE / 3 && i < (MAX_FLAKE / 3) * 2) type = "flake_medium";
else type = "flake_large";
EdjeObject *o = new EdjeObject(theme, evas);
if (!o->LoadEdje("calaos/widget/xmas/" + type))
cError() << "Error loading edje group calaos/widget/xmas/" + type;
o->setLayer(500);
evas_object_clip_set(o->getEvasObject(), clip);
Flake *flake = new Flake(o);
int tx = random() % clipw;
int ty = random() % cliph;
flake->Move(tx + clipx, ty + clipy);
flake->Show();
flake->setStart(ecore_time_get() + (double)(random() % (flake->getHeight() * 10)) / (double)flake->getHeight());
if (type == "flake_small") flake->setSpeed(1);
if (type == "flake_medium") flake->setSpeed(2);
if (type == "flake_large") flake->setSpeed(3);
flakes.push_back(flake);
}
return true;
}
Minimap::Minimap()
{
using res = tank::Resources;
//Nothing to see here please move on
graphicSmall_ = makeGraphic(res::get<tank::Image>("assets/graphics/minimap.png"));
graphicBig_ = makeGraphic(res::get<tank::Image>("assets/graphics/minimap2.png"));
setPos(tank::Game::window()->getSize() - graphicSmall_->getSize());
graphicSmall_->setScale(2);
graphicSmall_->setVisible(false);
graphicBig_->setScale(2);
graphicBig_->setVisible(false);
setLayer(101);
}
Player::Player()
{
controller_num = 0;
jumpVel = 8;
jumpGlide = 18;
setLayer(1);
size->set(.5, .95);
needs_indicator_make = 0;// set it when we get a player num
dir_facing = DIR_RIGHT;// so that we have an initial direction
released_suicide_button = 0;
released_fire_button = 0;
gun_cooldown = .2;
ending_level = 0;// used to do the end level animation
end_level_anim_time = 0;
}
wp_gren_proj::wp_gren_proj(spriteManager* newsm, Player* p) : massObject(newsm), owner(p)
{
#ifdef __MDDEBUG
className = "wp_gren_proj";
macros::debugMessage(className, "constructor");
#endif
gameManager* gm = dynamic_cast<gameManager*>(sm);
setPallete(gm->pickupSprite.palleteID);
//GFX warning!
giveSprite(gm->pickupSprite.spriteData, OBJ_SIZE_16X16, 8, 8, 60);
setBounds(2, 2, 5, -1);
setAnim(26, 27, ANIMSPEED);
setCollision(COL_SOLID);
setCheckCollision(true);
setLayer(2);
}
/*! \overload
Sets the layer of this layerable object by name
Returns true on success, i.e. if \a layerName is a valid layer name.
*/
bool QCPLayerable::setLayer(const QString &layerName)
{
if (!mParentPlot)
{
qDebug() << Q_FUNC_INFO << "no parent QCustomPlot set";
return false;
}
if (QCPLayer *layer = mParentPlot->layer(layerName))
{
return setLayer(layer);
} else
{
qDebug() << Q_FUNC_INFO << "there is no layer with name" << layerName;
return false;
}
}
