C++ PageView::setContentSize方法代码示例

void TeachingLayer::testPageView()
{
	// Create the page view
	PageView* pageView = PageView::create();
	auto winSize = Director::getInstance()->getWinSize();
	pageView->setContentSize(winSize);
	pageView->setPosition(Vec2::ZERO);
	pageView->setBackGroundColor(Color3B::GREEN);
	pageView->setBackGroundColorType(Layout::BackGroundColorType::SOLID);

	pageView->removeAllPages();

	int pageCount = 4;
	for (int i = 0; i < pageCount; ++i)
	{
		Layout* layout = Layout::create();
		layout->setContentSize(winSize);
		auto bg = Sprite::create("teaching0.png");
		bg->setPosition(Vec2(layout->getContentSize().width/2,layout->getContentSize().height/2));
		layout->addChild(bg);
		
		pageView->insertPage(layout,i);
	}

	//pageView->removePageAtIndex(0);
	//pageView->scrollToPage(pageCount-2);

	//pageView->addEventListener(CC_CALLBACK_2(UIPageViewTest::pageViewEvent, this));

	this->addChild(pageView);
}

//.........这里部分代码省略.........
        
        
        bool fileExist = false;
        std::string errorFilePath = "";
        auto imageFileNameDic = options->backGroundImageData();
        int imageFileNameType = imageFileNameDic->resourceType();
        std::string imageFileName = imageFileNameDic->path()->c_str();
        if (imageFileName != "")
        {
            switch (imageFileNameType)
            {
                case 0:
                {
                    if (FileUtils::getInstance()->isFileExist(imageFileName))
                    {
                        fileExist = true;
                    }
                    else
                    {
                        errorFilePath = imageFileName;
                        fileExist = false;
                    }
                    break;
                }
                    
                case 1:
                {
                    std::string plist = imageFileNameDic->plistFile()->c_str();
                    SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
                    if (spriteFrame)
                    {
                        fileExist = true;
                    }
                    else
                    {
                        if (FileUtils::getInstance()->isFileExist(plist))
                        {
                            ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
                            ValueMap metadata = value["metadata"].asValueMap();
                            std::string textureFileName = metadata["textureFileName"].asString();
                            if (!FileUtils::getInstance()->isFileExist(textureFileName))
                            {
                                errorFilePath = textureFileName;
                            }
                        }
                        else
                        {
                            errorFilePath = plist;
                        }
                        fileExist = false;
                    }
                    break;
                }
                    
                default:
                    break;
            }
            if (fileExist)
            {
                pageView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
            }
//            else
//            {
//                auto label = Label::create();
//                label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
//                pageView->addChild(label);
//            }
        }
        
        auto widgetOptions = options->widgetOptions();
        auto f_color = widgetOptions->color();
        Color3B color(f_color->r(), f_color->g(), f_color->b());
        pageView->setColor(color);
        
        int opacity = widgetOptions->alpha();
        pageView->setOpacity(opacity);
        
        
        auto widgetReader = WidgetReader::getInstance();
        widgetReader->setPropsWithFlatBuffers(node, (Table*)options->widgetOptions());
        
        if (backGroundScale9Enabled)
        {
            auto f_capInsets = options->capInsets();
            Rect capInsets(f_capInsets->x(), f_capInsets->y(), f_capInsets->width(), f_capInsets->height());
            pageView->setBackGroundImageCapInsets(capInsets);
            
            auto f_scale9Size = options->scale9Size();
            Size scale9Size(f_scale9Size->width(), f_scale9Size->height());
            pageView->setContentSize(scale9Size);
        }
        else
        {
            if (!pageView->isIgnoreContentAdaptWithSize())
            {
                Size contentSize(widgetOptions->size()->width(), widgetOptions->size()->height());
                pageView->setContentSize(contentSize);
            }
        }
    }

 void PageViewReader::setPropsWithFlatBuffers(cocos2d::Node *node, const flatbuffers::Table *pageViewOptions)
 {
     PageView* pageView = static_cast<PageView*>(node);
     auto options = (PageViewOptions*)pageViewOptions;
     
     bool clipEnabled = options->clipEnabled();
     pageView->setClippingEnabled(clipEnabled);
     
     bool backGroundScale9Enabled = options->backGroundScale9Enabled();
     pageView->setBackGroundImageScale9Enabled(backGroundScale9Enabled);
     
     
     auto f_bgColor = options->bgColor();
     Color3B bgColor(f_bgColor->r(), f_bgColor->g(), f_bgColor->b());
     auto f_bgStartColor = options->bgStartColor();
     Color3B bgStartColor(f_bgStartColor->r(), f_bgStartColor->g(), f_bgStartColor->b());
     auto f_bgEndColor = options->bgEndColor();
     Color3B bgEndColor(f_bgEndColor->r(), f_bgEndColor->g(), f_bgEndColor->b());
     
     auto f_colorVecor = options->colorVector();
     Vec2 colorVector(f_colorVecor->vectorX(), f_colorVecor->vectorY());
     pageView->setBackGroundColorVector(colorVector);
     
     int bgColorOpacity = options->bgColorOpacity();
     
     int colorType = options->colorType();
     pageView->setBackGroundColorType(Layout::BackGroundColorType(colorType));
     
     pageView->setBackGroundColor(bgStartColor, bgEndColor);
     pageView->setBackGroundColor(bgColor);
     pageView->setBackGroundColorOpacity(bgColorOpacity);
     
     
     auto imageFileNameDic = options->backGroundImageData();
     int imageFileNameType = imageFileNameDic->resourceType();
     std::string imageFileName = imageFileNameDic->path()->c_str();
     pageView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
     
     
     auto widgetOptions = options->widgetOptions();
     auto f_color = widgetOptions->color();
     Color3B color(f_color->r(), f_color->g(), f_color->b());
     pageView->setColor(color);
     
     int opacity = widgetOptions->alpha();
     pageView->setOpacity(opacity);
     
     
     auto widgetReader = WidgetReader::getInstance();
     widgetReader->setPropsWithFlatBuffers(node, (Table*)options->widgetOptions());
     
     if (backGroundScale9Enabled)
     {
         auto f_capInsets = options->capInsets();
         Rect capInsets(f_capInsets->x(), f_capInsets->y(), f_capInsets->width(), f_capInsets->height());
         pageView->setBackGroundImageCapInsets(capInsets);
         
         auto f_scale9Size = options->scale9Size();
         Size scale9Size(f_scale9Size->width(), f_scale9Size->height());
         pageView->setContentSize(scale9Size);
     }
     else
     {
         if (!pageView->isIgnoreContentAdaptWithSize())
         {
             Size contentSize(widgetOptions->size()->width(), widgetOptions->size()->height());
             pageView->setContentSize(contentSize);
         }
     }
 }

    void PageViewReader::setPropsFromProtocolBuffers(ui::Widget *widget, const protocolbuffers::NodeTree &nodeTree)
    {
        WidgetReader::setPropsFromProtocolBuffers(widget, nodeTree);
        
        
        PageView* pageView = static_cast<PageView*>(widget);
        const protocolbuffers::PageViewOptions& options = nodeTree.pageviewoptions();

		std::string protocolBuffersPath = GUIReader::getInstance()->getFilePath();
        
        CCLOG("options.clipable() = %d", options.clipable());
        pageView->setClippingEnabled(options.clipable());
        
        bool backGroundScale9Enable = options.backgroundscale9enable();
        pageView->setBackGroundImageScale9Enabled(backGroundScale9Enable);
        
        
        int cr;
        int cg;
        int cb;
        int scr;
        int scg;
        int scb;
        int ecr;
        int ecg;
        int ecb;
        
        cr = options.has_bgcolorr() ? options.bgcolorr() : 150;
        cg = options.has_bgcolorg() ? options.bgcolorg() : 150;
        cb = options.has_bgcolorb() ? options.bgcolorb() : 150;
        
        scr = options.has_bgstartcolorr() ? options.bgstartcolorr() : 255;
        scg = options.has_bgstartcolorg() ? options.bgstartcolorg() : 255;
        scb = options.has_bgstartcolorb() ? options.bgstartcolorb() : 255;
        
        ecr = options.has_bgendcolorr() ? options.bgendcolorr() : 255;
        ecg = options.has_bgendcolorg() ? options.bgendcolorg() : 150;
        ecb = options.has_bgendcolorb() ? options.bgendcolorb() : 100;
        
		float bgcv1 = 0.0f;
        float bgcv2 = -0.5f;
		if(options.has_vectorx())
		{
			bgcv1 = options.vectorx();
		}
		if(options.has_vectory())
		{
			bgcv2 = options.vectory();
		}
        pageView->setBackGroundColorVector(Vec2(bgcv1, bgcv2));
        
        int co = options.has_bgcoloropacity() ? options.bgcoloropacity() : 100;
        
        int colorType = options.has_colortype() ? options.colortype() : 1;
        pageView->setBackGroundColorType(Layout::BackGroundColorType(colorType));
        
        pageView->setBackGroundColor(Color3B(scr, scg, scb),Color3B(ecr, ecg, ecb));
        pageView->setBackGroundColor(Color3B(cr, cg, cb));
        pageView->setBackGroundColorOpacity(co);
        
        
		const protocolbuffers::ResourceData& imageFileNameDic = options.backgroundimagedata();
        int imageFileNameType = imageFileNameDic.resourcetype();
        std::string imageFileName = this->getResourcePath(imageFileNameDic.path(), (Widget::TextureResType)imageFileNameType);
        pageView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
        
        
        if (backGroundScale9Enable)
        {
            float cx = options.capinsetsx();
            float cy = options.capinsetsy();
            float cw = options.has_capinsetswidth() ? options.capinsetswidth() : 1;
            float ch = options.has_capinsetsheight() ? options.capinsetsheight() : 1;
            pageView->setBackGroundImageCapInsets(Rect(cx, cy, cw, ch));
            bool sw = options.has_scale9width();
            bool sh = options.has_scale9height();
            if (sw && sh)
            {
                float swf = options.scale9width();
                float shf = options.scale9height();
                pageView->setContentSize(Size(swf, shf));
            }
        }
        
        const protocolbuffers::WidgetOptions& widgetOptions = nodeTree.widgetoptions();
        
        int red = widgetOptions.has_colorr() ? widgetOptions.colorr() : 255;
        int green = widgetOptions.has_colorg() ? widgetOptions.colorg() : 255;
        int blue = widgetOptions.has_colorb() ? widgetOptions.colorb() : 255;
        pageView->setColor(Color3B(red, green, blue));
        
        int opacity = widgetOptions.has_alpha() ? widgetOptions.alpha() : 255;
        pageView->setOpacity(opacity);
        
        
        // other commonly protperties
        setAnchorPointForWidget(widget, nodeTree);
        
        bool flipX = widgetOptions.flipx();
        bool flipY = widgetOptions.flipy();
//.........这里部分代码省略.........

//.........这里部分代码省略.........
         {
             attribute = child->FirstAttribute();
             while (attribute)
             {
                 name = attribute->Name();
                 std::string value = attribute->Value();
                 
                 if (name == "ScaleX")
                 {
                     vector_color_x = atof(value.c_str());
                 }
                 else if (name == "ScaleY")
                 {
                     vector_color_y = atof(value.c_str());
                 }
                 
                 attribute = attribute->Next();
             }
         }
         else if (name == "FileData")
         {
             attribute = child->FirstAttribute();
             
             while (attribute)
             {
                 name = attribute->Name();
                 std::string value = attribute->Value();
                 
                 if (name == "Path")
                 {
                     path = value;
                 }
                 else if (name == "Type")
                 {
                     resourceType = (value == "Normal" || value == "Default" || value == "MarkedSubImage") ? 0 : 1;
                 }
                 else if (name == "Plist")
                 {
                     plistFile = value;
                 }
                 
                 attribute = attribute->Next();
             }
         }
         
         child = child->NextSiblingElement();
     }
     
     pageView->setColor(Color3B(red, green, blue));
     pageView->setOpacity(opacity);
     
     pageView->setBackGroundColorType(colorType);
     switch (colorType)
     {
         case Layout::BackGroundColorType::SOLID:
             pageView->setBackGroundColor(Color3B(singleRed, singleGreen, singleBlue));
             break;
             
         case Layout::BackGroundColorType::GRADIENT:
             pageView->setBackGroundColor(Color3B(start_red, start_green, start_blue),
                                          Color3B(end_red, end_green, end_blue));
             pageView->setBackGroundColorVector(Vec2(vector_color_x, vector_color_y));
             break;
             
         default:
             break;
     }
     
     pageView->setBackGroundColorOpacity(color_opacity);
     
     switch (resourceType)
     {
         case 0:
         {
             pageView->setBackGroundImage(xmlPath + path, Widget::TextureResType::LOCAL);
             break;
         }
             
         case 1:
         {
             SpriteFrameCache::getInstance()->addSpriteFramesWithFile(xmlPath + plistFile);
             pageView->setBackGroundImage(path, Widget::TextureResType::PLIST);
             break;
         }
             
         default:
             break;
     }
     
     if (path != "")
     {
         if (scale9Enabled)
         {
             pageView->setBackGroundImageScale9Enabled(scale9Enabled);
             pageView->setBackGroundImageCapInsets(Rect(cx, cy, cw, ch));
             pageView->setContentSize(Size(width, height));
         }
     }        
     
 }