void CTerrain::Initialize()
{
	listter.push_back(this);
	nangle = 0;
	setImage("item", type);
	density = true;
	if(_img != NULL)	setDimensions(_img->w, _img->h);
	else				setDimensions(0, 0);
}

void Widget::addHeight(point_type h) {
    if(_coordMode == CM_ABSOLUTE) setDimensions(
        -1.0f,
        -1.0f,
        -1.0f,
        MACRO_WIDGET_H(_verts()) + h
    );

    else setDimensions(-1.0f, -1.0f, -1.0f, _relCoords[3] + h);
}

void Widget::addOrigin(point_type x, point_type y) {
    if(_coordMode == CM_ABSOLUTE) {
        PointArray* verts = _verts();

        setDimensions(
            MACRO_WIDGET_X(verts) + x,
            MACRO_WIDGET_Y(verts) + y
        );
    }

    else setDimensions(_relCoords[0] + x, _relCoords[1] + y);
}

/*!  
 *  Reads meta data of VTU file (grid size, data fields, codex, position of data within file).
 *  Calls setDimension.
 */
void VTKUnstructuredGrid::readMetaData( ){

    std::fstream str;
    std::string line, temp;

    std::fstream::pos_type        position;

    str.open( fh.getPath( ), std::ios::in ) ;

    getline( str, line);
    while( ! bitpit::utils::keywordInString( line, "<VTKFile")){
        getline(str, line);
    };

    if( bitpit::utils::getAfterKeyword( line, "header_type", '\"', temp) ){
        setHeaderType( temp) ;
    };

    while( ! bitpit::utils::keywordInString( line, "<Piece")){
        getline(str, line);
    };

    bitpit::utils::getAfterKeyword( line, "NumberOfPoints", '\"', temp) ;
    bitpit::utils::convertString( temp, nr_points );

    bitpit::utils::getAfterKeyword( line, "NumberOfCells", '\"', temp) ;
    bitpit::utils::convertString( temp, nr_cells );


    position = str.tellg() ;
    readDataHeader( str ) ;


    for( auto &field : geometry ){ 
        str.seekg( position) ;
        if( ! readDataArray( str, *field ) ) {
            std::cout << field->getName() << " DataArray not found" << std::endl ;
        };
    };


    str.close() ;

    if( homogeneousType == VTKElementType::UNDEFINED) {
        setDimensions( nr_cells, nr_points, calcSizeConnectivity() ) ;
    } else {
        setDimensions( nr_cells, nr_points ) ;
    };


    return ;
};

void LightEntityItem::setIsSpotlight(bool value) {
    if (value != _isSpotlight) {
        _isSpotlight = value;

        if (_isSpotlight) {
            const float length = getDimensions().z;
            const float width = length * glm::sin(glm::radians(_cutoff));
            setDimensions(glm::vec3(width, width, length));
        } else {
            float maxDimension = glm::max(getDimensions().x, getDimensions().y, getDimensions().z);
            setDimensions(glm::vec3(maxDimension, maxDimension, maxDimension));
        }
    }
}

void Label::setFontDefinition(const FontDefinition& textDefinition)
{
    _systemFont = textDefinition._fontName;
    _systemFontSize = textDefinition._fontSize;
    _hAlignment = textDefinition._alignment;
    _vAlignment = textDefinition._vertAlignment;
    setDimensions(textDefinition._dimensions.width, textDefinition._dimensions.height);
    Color4B textColor = Color4B(textDefinition._fontFillColor);
    textColor.a = textDefinition._fontAlpha;
    setTextColor(textColor);
    
#if (CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID) && (CC_TARGET_PLATFORM != CC_PLATFORM_IOS)
    if (textDefinition._stroke._strokeEnabled)
    {
        CCLOGERROR("Currently only supported on iOS and Android!");
    }
    _outlineSize = 0.f;
#else
    if (textDefinition._stroke._strokeEnabled && textDefinition._stroke._strokeSize > 0.f)
    {
        Color4B outlineColor = Color4B(textDefinition._stroke._strokeColor);
        outlineColor.a = textDefinition._stroke._strokeAlpha;
        enableOutline(outlineColor, textDefinition._stroke._strokeSize);
    }
#endif

    if (textDefinition._shadow._shadowEnabled)
    {
        enableShadow(Color4B(0, 0, 0, 255 * textDefinition._shadow._shadowOpacity),
            textDefinition._shadow._shadowOffset, textDefinition._shadow._shadowBlur);
    }
}

/*!  
 *  sets the size of the unstructured grid for a homogenous grid.
 *  @param[in]  ncells_     number of cells
 *  @param[in]  npoints_    number of points
 *  @param[in]  type_       typeof element in grid
 */
void VTKUnstructuredGrid::setDimensions( uint64_t ncells_, uint64_t npoints_, VTKElementType type_ ){

    setElementType( type_ );
    setDimensions( ncells_, npoints_ );

    return ;
};

// set the identity matrix of dimension n
void Matrix::setIdentityMatrix( int n )		
{
    assert( n > 0 );
    setDimensions( n, n );	
    setZero();
    for ( int i = 0; i < n; i++ ) setElement( i, i, 1.0 );
}

void Text::setText(std::string text){
  myText = text;
  int n = 0;
  std::vector<std::string> textLines;
  std::string substring = text;
  while(n != std::string::npos){
    n = substring.find('\n', 0);
      textLines.push_back(substring.substr(0, n));
      substring = substring.substr(n + 1, std::string::npos);
  }
  numLines = textLines.size();
  image.clear();
  for(unsigned int i = 0; i < textLines.size(); i++)
    image.push_back(TTF_RenderText_Blended(font, textLines.at(i).c_str(), color));
  int wtemp, w = 0;
  for(unsigned int i = 0; i < textLines.size(); i++){
    TTF_SizeText(this->font, textLines.at(i).c_str(), &wtemp, NULL);
    if(wtemp > w)
      w = wtemp;
	}
  int h = 10;
  lineSkip = TTF_FontLineSkip(font);
  h = (textLines.size() - 1) * lineSkip + h;
  setDimensions(w, h);
}

void CImgLayerRAMLoader::updateRepresentation(std::shared_ptr<DataRepresentation> dest) const {
    auto layerDst = std::static_pointer_cast<LayerRAM>(dest);

    if (layerDisk_->getDimensions() != layerDst->getDimensions()) {
        layerDst->setDimensions(layerDisk_->getDimensions());
    }

    uvec2 dimensions = layerDisk_->getDimensions();
    DataFormatId formatId = DataFormatId::NotSpecialized;

    std::string filePath = layerDisk_->getSourceFile();

    if (!filesystem::fileExists(filePath)) {
        std::string newPath = filesystem::addBasePath(filePath);

        if (filesystem::fileExists(newPath)) {
            filePath = newPath;
        } else {
            throw DataReaderException("Error could not find input file: " + filePath, IvwContext);
        }
    }

    if (dimensions != uvec2(0)) {
        // Load and rescale to input dimensions
        CImgUtils::loadLayerData(layerDst->getData(), filePath, dimensions, formatId, true);
    } else {
        // Load to original dimensions
        CImgUtils::loadLayerData(layerDst->getData(), filePath, dimensions, formatId, false);
        layerDisk_->setDimensions(dimensions);
    }

    layerDisk_->updateDataFormat(DataFormatBase::get(formatId));
}

 Grid::Grid(const IntVector& dimensions)
  : dimensions_(0),
    offsets_(0),
    size_(0)
 {
    setDimensions(dimensions); 
 }

//------------------------------------------------
void guiTypeMultiToggle::setup(string multiToggleName, string xmlNameIn, int defaultBox, vector <string> boxNames){
	bNames = boxNames;
	value.addValue( (int)defaultBox, 0, bNames.size()-1);
	name = multiToggleName;
	xmlName = xmlNameIn;

	float lineHeight = 0;
	for(unsigned int i = 0; i < bNames.size(); i++){
		float lineWidth = boxSpacing + boxSize + displayText.stringWidth(bNames[i]);

		if( lineWidth > hitArea.width ){
			hitArea.width       += lineWidth-hitArea.width;
			boundingBox.width   += lineWidth-hitArea.width;
		}

		lineHeight += displayText.stringHeight(bNames[i]);
	}

	if(lineHeight > hitArea.height){
		hitArea.height      += lineHeight-hitArea.height;
		boundingBox.height  += lineHeight-hitArea.height;
	}

	setDimensions(180, bNames.size()*(guiTypeMultiToggle::boxSize + guiTypeMultiToggle::boxSpacing) + 2);
}

GPURGB2YUVFilter::GPURGB2YUVFilter(const IntPoint& size)
    : GPUFilter(SHADERID, false, false)
{
    ObjectCounter::get()->incRef(&typeid(*this));

    setDimensions(size);
}

bool TextFieldTTF::initWithPlaceHolder(const std::string& placeholder, const Size& dimensions, TextHAlignment alignment, const std::string& fontName, float fontSize)
{
    setDimensions(dimensions.width, dimensions.height);
    setAlignment(alignment, TextVAlignment::CENTER);

    return initWithPlaceHolder(placeholder, fontName, fontSize);
}

void CButton::Initialize()
{
	image_state = getType();
	setImage("button", image_state);
	UpdateImage();
	setDimensions(_img->w, _img->h);
}

void ChangePhoneBox::EnterCode::prepare() {
	setTitle(langFactory(lng_change_phone_title));

	auto descriptionText = lng_change_phone_code_description(lt_phone, textcmdStartSemibold() + App::formatPhone(_phone) + textcmdStopSemibold());
	auto description = object_ptr<Ui::FlatLabel>(this, descriptionText, Ui::FlatLabel::InitType::Rich, st::changePhoneLabel);
	description->moveToLeft(st::boxPadding.left(), 0);

	auto phoneValue = QString();
	_code.create(this, st::defaultInputField, langFactory(lng_change_phone_code_title), phoneValue);
	_code->setAutoSubmit(_codeLength, [=] { submit(); });
	_code->setChangedCallback([=] { hideError(); });

	_code->resize(st::boxWidth - 2 * st::boxPadding.left(), _code->height());
	_code->moveToLeft(st::boxPadding.left(), description->bottomNoMargins());
	connect(_code, &Ui::InputField::submitted, [=] { submit(); });

	setDimensions(st::boxWidth, countHeight());

	if (_callTimeout > 0) {
		_call.setStatus({ SentCodeCall::State::Waiting, _callTimeout });
		updateCall();
	}

	addButton(langFactory(lng_change_phone_new_submit), [=] { submit(); });
	addButton(langFactory(lng_cancel), [=] { closeBox(); });
}

void BitmapSequence::loadDir(string inDir){
    dir.listDir( inDir );
    dir.sort();
    if( !dir.size() ){
		cout << "BitmapSequence::loadDir::no files in:" << inDir << "\n";
	}
    else{
        int numFiles = dir.size();
        for (int i = 0 ; i < numFiles; i++ ){
            string curFile = dir.getPath( i );
            ofImage* curImage = new ofImage();
            bool loaded = false;
            try {
                 loaded = curImage->loadImage( curFile );
            } catch ( std::exception& e ) {
                cout << "BitmapSequence::loadDir::Error trying to load image from:" << inDir<< "\n";
            }

            if ( loaded ){
                images.push_back(curImage);
            }
            else{
                delete curImage;//since we called new, we have to explicitly destroy
            }
        }
        totalFrames = images.size();
        //cout <<"BitmapSequence::loadDir::filesLoaded:" << totalFrames << "\n";
    }
    setDimensions();
}

GPUBlurFilter::GPUBlurFilter(const IntPoint& size, PixelFormat pfSrc, PixelFormat pfDest,
        float stdDev, bool bClipBorders, bool bStandalone, bool bUseFloatKernel)
    : GPUFilter(pfSrc, pfDest, bStandalone, SHADERID_HORIZ, 2),
      m_bClipBorders(bClipBorders),
      m_bUseFloatKernel(bUseFloatKernel)
{
    ObjectCounter::get()->incRef(&typeid(*this));

    GLContext::getCurrent()->ensureFullShaders("GPUBlurFilter");
#ifndef AVG_ENABLE_EGL
    if (!m_bClipBorders) {
        //TODO: TO_BORDER DOES NOT EXIST IN GLESV2
        m_WrapMode = WrapMode(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_BORDER);
    }
#endif
    setDimensions(size, stdDev);
    GLContextManager* pCM = GLContextManager::get();
    pCM->createShader(SHADERID_VERT);
    setStdDev(stdDev);

    m_pHorizWidthParam = pCM->createShaderParam<float>(SHADERID_HORIZ, "u_Width");
    m_pHorizRadiusParam = pCM->createShaderParam<int>(SHADERID_HORIZ, "u_Radius");
    m_pHorizTextureParam = pCM->createShaderParam<int>(SHADERID_HORIZ, "u_Texture");
    m_pHorizKernelTexParam = pCM->createShaderParam<int>(SHADERID_HORIZ, "u_KernelTex");

    m_pVertWidthParam = pCM->createShaderParam<float>(SHADERID_VERT, "u_Width");
    m_pVertRadiusParam = pCM->createShaderParam<int>(SHADERID_VERT, "u_Radius");
    m_pVertTextureParam = pCM->createShaderParam<int>(SHADERID_VERT, "u_Texture");
    m_pVertKernelTexParam = pCM->createShaderParam<int>(SHADERID_VERT, "u_KernelTex");
}

Label* Label::create(const std::string& text, const std::string& fontName, float fontSize, const Size& dimensions /* = Size::ZERO */, TextHAlignment hAlignment /* = TextHAlignment::LEFT */, TextVAlignment vAlignment /* = TextVAlignment::TOP */)
{
    auto ret = new Label(nullptr,hAlignment,vAlignment);

    if (ret)
    {
        do 
        {
            if (FileUtils::getInstance()->isFileExist(fontName))
            {
                TTFConfig ttfConfig(fontName.c_str(),fontSize,GlyphCollection::DYNAMIC);
                if (ret->setTTFConfig(ttfConfig))
                {
                    break;
                }
            }

            FontDefinition fontDef;
            fontDef._fontName = fontName;
            fontDef._fontSize = fontSize;
            fontDef._dimensions = dimensions;
            fontDef._alignment = hAlignment;
            fontDef._vertAlignment = vAlignment;
            ret->setFontDefinition(fontDef);
        } while (0);

        ret->setDimensions(dimensions.width,dimensions.height);
        ret->setString(text);
        ret->autorelease();
    }   

    return ret;
}

// Constructor with parameters
deskInfo::deskInfo(elementList *element, unsigned int rows, unsigned int columns, unsigned int maxLineLength, string helpText) {
	setElementList(element);
	setDimensions(rows, columns);
	setMaxLineLength(maxLineLength);
	setDrawContinous(false);
	setHelpText(helpText);
}