void
CSVGStroke::
setOpacity(const string &opacity_def)
{
  double opacity = svg_.decodeOpacityString(opacity_def);

  setOpacity(opacity);
}

	void PopUpMenu::logic( double timeElapsed )
	{
		agui::PopUpMenu::logic(timeElapsed);
		if(getOpacity() < 1.0f)
		{
			setOpacity(getOpacity() + m_opacityRate);
		}
	}

MenuItemSprite* ItemWindowLayer::createMenuItemSprite(Color3B color, const ccMenuCallback& callback)
{
    auto rect = Rect(0, 0, 300, 30);
    auto capRect = Rect(0, 0, 300, 30);

    auto pSprite1 = extension::Scale9Sprite::create("menu_button.png", rect, capRect);
    pSprite1->setColor(color);
    pSprite1->setOpacity(192);
    pSprite1->setContentSize(Size(40, 20));
    auto pSprite2 = extension::Scale9Sprite::create("menu_button.png", rect, capRect);
    pSprite2->setColor(color);
    pSprite2->setOpacity(128);
    pSprite2->setContentSize(Size(40, 20));

    // 使用ボタン
    return MenuItemSprite::create(pSprite1, pSprite2, callback);
}

void
MCSkillBarItem::coldTimeDidFinish(CCObject *anObject)
{
    CCProgressTimer *progressTimer = dynamic_cast<CCProgressTimer *>(anObject);
    
    progressTimer->removeFromParentAndCleanup(true);
    setOpacity(kMCSkillBarItemActiveSkillOpacity);
}

 RotationOriginIndicator(QGraphicsItem *parent = 0)
     : QGraphicsItem(parent)
 {
     setFlags(QGraphicsItem::ItemIgnoresTransformations |
              QGraphicsItem::ItemIgnoresParentOpacity);
     setZValue(10000 + 1);
     setOpacity(0.5);
 }

bool PencilLayer::init()
{
    if (!LayerColor::initWithColor(Color4B::WHITE)) //ÇϾá»ö ¼¼ÆÃ
    {
        return false;
    }
    auto winSize = Director::getInstance()->getWinSize();

    auto background = MenuItemImage::create(
        "Resources/Black.png", 
        "Resources/Black.png", 
        CC_CALLBACK_1(PencilLayer::VoidFunc, this));

    auto menu0 = Menu::create(background, false);
    menu0->setAnchorPoint(Point(0, 0));
    menu0->setPosition(winSize.width / 2, winSize.height / 2);
    menu0->setOpacity(50);
    this->addChild(menu0, 10);

    auto exit = MenuItemImage::create(
        "Resources/Exit.png",
        "Resources/ExitSelected.png",
        CC_CALLBACK_1(PencilLayer::menuCallback, this));
    auto menu = Menu::create(exit, false);
    menu->setPosition(1200, 700);
    this->addChild(menu, 13);

    Sprite* pencil;
    if (Player::getInstance()->IsPencilSharp())
    {
        pencil = Sprite::create("Resources/Pencil2.png");
    }
    else if (Player::getInstance()->GetSharpGauge()>=50)
    {
        pencil = Sprite::create("Resources/Pencil1.png");
    }
    else
    {
        pencil = Sprite::create("Resources/Pencil0.png");
    }
    pencil->setAnchorPoint(Point(0.5, 0));
    pencil->setPosition(640, 0);
    this->addChild(pencil, 11, "pencil");

    auto cuter = Sprite::create("Resources/Cuter.png");
    cuter->setAnchorPoint(Point(0.5, 0.5));
    cuter->setPosition(800, 400);
    this->addChild(cuter,12,"cuter");

    auto mouseListener = EventListenerMouse::create();
    mouseListener->onMouseMove = CC_CALLBACK_1(PencilLayer::OnMouseMove, this);
    mouseListener->onMouseDown = CC_CALLBACK_1(PencilLayer::OnMouseDown, this);
    mouseListener->onMouseUp = CC_CALLBACK_1(PencilLayer::OnMouseUp, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(mouseListener, this);


    return true;
}

void OpacityCommand::readProperties(boost::property_tree::wptree& pt)
{
    AbstractCommand::readProperties(pt);

    if (pt.count(L"opacity") > 0) setOpacity(pt.get<float>(L"opacity"));
    if (pt.count(L"duration") > 0) setDuration(pt.get<int>(L"duration"));
    if (pt.count(L"tween") > 0) setTween(QString::fromStdWString(pt.get<std::wstring>(L"tween")));
    if (pt.count(L"defer") > 0) setDefer(pt.get<bool>(L"defer"));
}

void HelloWorld::addMenu()
{

	Size visibleSize = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

    

	auto menuItem1 = MenuItemLabel::create(Label::createWithTTF(" Play ", "fonts/airstrikecond.ttf", 34), CC_CALLBACK_1(HelloWorld::btnNewScene, this));
	auto menuItem2 = MenuItemLabel::create(Label::createWithTTF(" Setting ", "fonts/airstrikehalf.ttf", 34), CC_CALLBACK_1(HelloWorld::btnNewScene2, this));
    auto menuItem3 = MenuItemLabel::create(Label::createWithTTF(" Records ", "fonts/airstrike3d.ttf", 34), CC_CALLBACK_1(HelloWorld::btnNewScene3, this));
	auto menuItem4 = MenuItemLabel::create(Label::createWithTTF(" Agregar Persona ", "fonts/airstrike3d.ttf", 34), CC_CALLBACK_1(HelloWorld::btnNewScene4, this));
    auto menuItem5 = MenuItemLabel::create(Label::createWithTTF(" ScrollView ", "fonts/airstrike3d.ttf", 34), CC_CALLBACK_1(HelloWorld::btnNewScene5, this));
	auto menuItem6 = MenuItemLabel::create(Label::createWithTTF(" PageView ", "fonts/airstrikecond.ttf", 34), CC_CALLBACK_1(HelloWorld::btnNewScene6, this));
 
	auto menuGral = Menu::create(menuItem1,menuItem2,menuItem3,menuItem4, menuItem5,menuItem6,NULL);
	menuGral->alignItemsVertically();


	auto sprite = Sprite::create("greenChild.jpg");

	sprite->setPosition(Point(origin.x + visibleSize.width / 2, origin.y + visibleSize.height + sprite->getContentSize().height));

	menuGral->setPosition(Point(sprite->getContentSize().width / 2, sprite->getContentSize().height / 2));

	sprite->addChild(menuGral);
    
	sprite->setName("menu");

	sprite->setOpacity(30);

	//MoveBy *accion2 ;

	
	if(i == 0)
	{


	  this->addChild(sprite,2);

	  MoveBy *accion2 = MoveBy::create(1, Point(0, - ((visibleSize.height / 2) + sprite->getContentSize().height)));
  
	  sprite->runAction(accion2);

	  i++;
	    
	}

	else if(i>0)
	{
		this->removeChildByName("menu");

		i = 0;
	}


}

bool CCRectNode::initWithSize(const CCSize& tSize, const ccColor4F& tColor, bool bFill)
{
	setContentSize(tSize);
	setColor(ccc3(tColor.r * 255, tColor.b * 255, tColor.g * 255));
	setOpacity(tColor.a * 255);
	m_bFill = bFill;

	return true;
}

void QgsRasterRenderer::copyCommonProperties( const QgsRasterRenderer* other )
{
    if ( !other )
        return;

    setOpacity( other->opacity() );
    setAlphaBand( other->alphaBand() );
    setRasterTransparency( other->rasterTransparency() ? new QgsRasterTransparency( *other->rasterTransparency() ) : nullptr );
}

bool CCLineNode::initWithPoints(const CCPoint& tBeginPoint, const CCPoint& tEndPoint, const ccColor4F& tColor)
{
	setPosition(tBeginPoint);
	setContentSize(ccpDiff(tEndPoint, tBeginPoint));
	setColor(ccc3(tColor.r * 255, tColor.b * 255, tColor.g * 255));
	setOpacity(tColor.a * 255);

	return true;
}

GraphicsWidgetBase::GraphicsWidgetBase() {
  setFlag(QGraphicsItem::ItemIsMovable, true);
  setFlag(QGraphicsItem::ItemIsSelectable, true);
  setFlag(QGraphicsItem::ItemIsFocusable, true);
  setAcceptHoverEvents(true);
#if(QT_VERSION >= QT_VERSION_CHECK(4,5,0))
  setOpacity(0.8);
#endif
}

void MainScene::initCollisionSprite() {
    CCLOG("CollisionSprite初期化");
    auto collisionSprite = Sprite::create();
    collisionSprite->setAnchorPoint(Point(0, 0));
    collisionSprite->setTextureRect(Rect(0, 0, 640, 100));
    collisionSprite->setOpacity(0);
    collisionSprite->setPosition(0, 0);
    this->addChild(collisionSprite);
}

/** A shadow volume only uses a material when it is to be visible during development. */
void CC3ShadowVolumeMeshNode::checkShadowMaterial()
{
	if ( !_shouldDrawTerminator && isVisible() ) 
	{
		setColor( CCColorRefFromCCC4F(ccc4f(kCC3OneThird, kCC3OneThird, kCC3OneThird, 1.0)) );	// Will lazily init material if needed
		setOpacity( (CCOpacity)(kCCOpacityFull * kCC3OneThird) );
	} else
		setMaterial( NULL );
}

void LongPressSpinner::setGoodPress(bool flag)
{
	setVisible(true);
	setOpacity(1.0);
	prepareGeometryChange();
	m_goodPressFlag = flag;
	m_goodPressTimer.start();
	update();
}

void Explosion::demmarer(QPointF position, double amplitude)
{
    animationExplosion1->setEndValue(amplitude);
    animationExplosion2->setStartValue(amplitude);

    setPos(position - boundingRect().center());
    setOpacity(1);
    animationExplosionRoot->start();
}

void ActiveLabel::show()
{
    QLabel::show();
    setFixedSize(24, 5);
    setOpacity(1);
    m_iconPath = m_openIndicatorIcon;
    update();
    emit sizeChange();
}

QVariant CornerHandle::itemChange(GraphicsItemChange change,
                                  const QVariant &value)
{
    if (change == ItemVisibleHasChanged) {
        if (value.toBool())
            setOpacity(isUnderMouse() ? 1 : 0.5);
    }
    return QGraphicsItem::itemChange(change, value);
}

void TopData::addStep(cocos2d::Node *node, int step, int time)
{
    this->restStep += step;
    
    auto topNode = node->getChildByTag(MAIN_SCENE_TOP_NODE);
    
    auto textLimit = topNode->getChildByName<ui::Text *>("TextLimit");
    textLimit->setString(Value(this->restStep).asString());
    
    auto text = textLimit->clone();
    text->setGlobalZOrder(100);
    text->setOpacity(200);
    topNode->addChild(text);
    
    auto scale = ScaleTo::create(0.5, 2.5);
    auto fade = FadeOut::create(0.5);
    auto callFunc = CallFunc::create([=]{
        text->removeFromParent();
    });
    
    text->runAction(scale);
    text->runAction(Sequence::create(fade, callFunc, NULL));
    
    if(UserData::getInstance()->challenges == 1)
    {
        this->restime += time;
        
        auto textTime = topNode->getChildByName<ui::Text *>("TextTime");
        textTime->setString(Value(this->restime).asString());
        
        auto text1 = textTime->clone();
        text1->setGlobalZOrder(100);
        text1->setOpacity(200);
        topNode->addChild(text1);
        
        auto scale1 = ScaleTo::create(0.5, 2.5);
        auto fade1 = FadeOut::create(0.5);
        auto callFunc1 = CallFunc::create([=]{
            text1->removeFromParent();
        });
        text1->runAction(scale1);
        text1->runAction(Sequence::create(fade1, callFunc1, NULL));
    }
}

ViewProfileDivider::ViewProfileDivider (QGraphicsScene &scene,
                                        QGraphicsView &view,
                                        int sceneWidth,
                                        int sceneHeight,
                                        int yCenter,
                                        bool isLowerBoundary) :
  QGraphicsRectItem (X_INITIAL,
                     0,
                     PADDLE_WIDTH,
                     PADDLE_HEIGHT),
  m_view (view),
  m_yCenter (yCenter),
  m_divider (0),
  m_shadedArea (0),
  m_sceneWidth (sceneWidth),
  m_sceneHeight (sceneHeight),
  m_isLowerBoundary (isLowerBoundary)
{
  // Initial positions will not appear since they are overridden by setX

  // Paddle
  setVisible (true);
  setPen (QPen (DIVIDER_COLOR));
  setBrush (QBrush (QColor (140, 255, 140)));
  setOpacity (1.0);
  scene.addItem (this);
  setFlags (QGraphicsItem::ItemIsMovable |
            QGraphicsItem::ItemSendsGeometryChanges);
  setCursor (Qt::OpenHandCursor);
  setZValue (2.0);

  // Arrow on paddle
  m_arrow = new QGraphicsPolygonItem (this);

  // Shaded area
  m_shadedArea = new QGraphicsRectItem (X_INITIAL,
                                        0,
                                        0,
                                        sceneHeight - 1);
  m_shadedArea->setOpacity (SHADED_AREA_OPACITY);
  m_shadedArea->setBrush (QBrush (SHADED_AREA_COLOR));
  m_shadedArea->setPen (Qt::NoPen);
  m_shadedArea->setZValue (0.0);
  scene.addItem (m_shadedArea);

  // Vertical divider. This is not made a child of the paddle since that will force the divider
  // to always be drawn above the paddle, rather than underneath the paddle as we want. Even setting
  // the z values will not succeed in drawing the divider under the paddle if they are child-parent.
  m_divider = new QGraphicsLineItem (X_INITIAL,
                                     -SLOP,
                                     X_INITIAL,
                                     2 * SLOP + sceneHeight);
  m_divider->setPen (QPen (QBrush (DIVIDER_COLOR), DIVIDER_WIDTH));
  m_divider->setZValue (1.0);
  scene.addItem (m_divider);
}