Exemplo n.º 1
0
bool CFileHelper::createDirs(const char* szDir)
{
    if (szDir == NULL)
    {
        ScutLog("createDirs Error %s %d", szDir, __LINE__);
        return false;
    }

    const char *pBegin = szDir;
    const char *pend = szDir;
    do 	{
        char szBuf[MAX_PATH];
        pend = strchr(pend,FILE_SEP);
        if (NULL != pend)
        {
            ++pend;
            int nSize = pend-pBegin;
            memcpy(szBuf,pBegin,nSize);
            szBuf[nSize] = '\0';
            std::string dir;
            dir = szBuf;
            if (!isDirExists(dir.c_str()))
            {
                if(!createDir(dir.c_str()))
                {
                    ScutLog("createDirs Error %s %d", szDir, __LINE__);
                    break;
                }
            }
        }
    } while (NULL != pend);

    return true;
}
Exemplo n.º 2
0
	int ZipUtils::ccInflateMemory(unsigned char *in, unsigned int inLength, unsigned char **out)
	{
		unsigned int outLength = 0;
		int err = inflateMemory_(in, inLength, out, &outLength);

		if (err != Z_OK || *out == NULL) {
			if (err == Z_MEM_ERROR)
			{
				ScutLog("ScutDataLogic: ZipUtils: Out of memory while decompressing map data!");
			} else 
			if (err == Z_VERSION_ERROR)
			{
				ScutLog("ScutDataLogic: ZipUtils: Incompatible zlib version!\r\n");
			} else 
			if (err == Z_DATA_ERROR)
			{
				ScutLog("ScutDataLogic: ZipUtils: Incorrect zlib compressed data!\r\n");
			}
			else
			{
				ScutLog("ScutDataLogic: ZipUtils: Unknown error while decompressing map data!\r\n");
			}

			delete[] *out;
			*out = NULL;
			outLength = 0;
		}

		return outLength;
	}
Exemplo n.º 3
0
	const char* CScutLuaLan::Get(const char *group, const char *key)
	{
		if (m_curLan.empty())
		{
			ScutLog("current language is empty");
			return "";
		}

		LANINFO_MAP::iterator it = m_mapLanInfo.find(m_curLan);

		if (it == m_mapLanInfo.end())
		{
			ScutLog("cann't find language %s", m_curLan.c_str());
			return "";
		}

		assert(it->second != NULL);
		if (NULL == it->second)
		{
			return "";
		}

		if (NULL == it->second->pIni)
		{
			load_ini(m_curLan.c_str());
		}

		return it->second->pIni->Get(group, key, "");
	}
Exemplo n.º 4
0
//如果NETWORK 传入的包大小与包前两个字节的值不一样,返回FALSE。
bool CNetStreamExport::pushNetStream(char* pdataStream,int wSize)
{
    m_pDataStream = pdataStream;
    m_nSize = wSize;
    m_nStreamPos = 0;

    ////特殊编译给陈波
    //return true;
    ////end

    //m_nRecoredSize = 0;
    //m_nRecoredReadSize = 0;
    assert(m_RecordStack.empty());
    while(!m_RecordStack.empty())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        delete pInfo;
        m_RecordStack.pop();
    }
    int nStreamSize = getInt();
    if(nStreamSize != wSize)
    {
        ScutLog(" Failed: CNetStreamExport: pushNetStream , wSize error ");
        return false;
    }

    //跳过包大小
    m_pDataStream = pdataStream + 4;
    m_nStreamPos = 0;
    //m_nRecoredReadSize = 0;

    return true;
}
Exemplo n.º 5
0
//在LUA中分配字符内存,传到C中设置内容
bool	CNetStreamExport::getString(char* psz, int nLength)
{
    if(!psz)
        return 0;

    if(!m_pDataStream)
        return 0;

    if(m_nStreamPos + nLength > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getString");
        return 0;
    }

    char ch;
    int i;
    for ( i= 0; i < nLength; i = i+1)
    {
        ch = *( m_pDataStream + m_nStreamPos + i );
        *(psz + i) = ch;
    }
    *(psz + i) = '\0';

    m_nStreamPos = m_nStreamPos + nLength;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += nLength;
    }
    //m_nRecoredReadSize += nLength;
    return 1;
}
Exemplo n.º 6
0
//备用接口,在C中分配内存
const char*	CNetStreamExport::getString(/*const  char* pData,*/int nLength)
{
    if(m_nStreamPos + nLength > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getString");
        return NULL;
    }

    m_szRet = (char*)malloc(nLength+1);

    if (m_szRet == NULL)
    {
        return NULL;
    }

    memcpy(m_szRet, m_pDataStream + m_nStreamPos, nLength);
    m_szRet[nLength] = '\0';

    m_nStreamPos = m_nStreamPos + nLength;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += nLength;
    }
    return m_szRet;

}
Exemplo n.º 7
0
	bool CScutLuaLan::Add(const char* pszLan, const char* pszPath)
	{
		std::string path = LANPATH_DIR;
		path += FILE_SEP;
		path += pszPath;
		path = ScutDataLogic::CFileHelper::getWritablePath(path.c_str());

		if (!ScutSystem::CPathUtility::IsFileExists(path.c_str()))
		{
			std::string dir = CPlatformProcedure::ProcessDir(LANPATH_DIR, pszPath);
			if (!dir.empty())
			{
				if (ScutSystem::CPathUtility::IsFileExists(dir.c_str()))
				{
					path = dir;
				}else
				{
					ScutLog("can not open file: %s", dir.c_str());
					return false;
				}
			}else
			{
				ScutLog("can not open file: %s", path.c_str());
				return false;
			}
		}

		LANINFO_MAP::iterator itfind = m_mapLanInfo.find(std::string(pszLan));
		bool bSame = false;
		if (itfind != m_mapLanInfo.end())
		{
			bSame = (itfind->second->strName == path);

			if (!bSame)
			{
				Remove(pszLan);
			}
		}

		if (!bSame)
		{
			add_node(pszLan, path.c_str());
		}


		return true;
	}
Exemplo n.º 8
0
int CIniFile::Load(const char *filename)
{

	// open the model file
	FILE *fp = fopen(filename, "rb");


	//FILE *fp = fopen(filename, "r");

	if (fp == NULL) {
		ScutLog("error cannot load ini file %s\n", filename);
		return 1;
	}

	// if we already have a file loaded, free it first
	if (Valid()) {
		FreeAllTheStuff();
	}
//------------------->lrb
	//char str[256], section[256];
	 char str[300], section[256];
//<-------------------lrb
	section[0] = '\0';

	while (fgets(str, 300, fp)) {//while (fgets(str, 256, fp)) {
		trim(str); // trim all the blanks or linefeeds

		// skip all comment lines or empty lines
		if (!str[0] || str[0] == ';' || str[0] == '/' || str[0] == '#')
			continue;

		int length = strlen(str);
		char *p;
//-------------->lrb

//<--------------lrb
		// check if this is a session line (e.g., [SECTION])
		if (str[0] == '[' && str[length - 1] == ']') {
			strcpy(section, &str[1]);
			section[length - 2] = 0; // remove the ]

			trim(section); // trim section name after removing []
		} else if ((p = strchr(str, '=')) != NULL) {
			*(p++) = '\0';
			trim(str);
// /<--------------------lrb
// 			while((rt = strchr(p,'\\')) != NULL )
// 			{
// 				*rt='\n';
// 			}
// -------------------->lrb
			trim(p);
			Set(section, str, p);
		}
	}

	fclose(fp); // load completed; close the file
	return 0;
}
Exemplo n.º 9
0
	bool CLuaIni::Load(const char *filename)
	{
		if (filename == NULL)
		{
			return false;
		}
		if (m_pIni->Load(initSavePath(filename).c_str()) != 0)
		{
			ScutLog("Load Ini file Error %s\r\n", initSavePath(filename).c_str());
			return false;
		}		
		return true;
	}
Exemplo n.º 10
0
	bool CLuaIni::APLoad(const char *filename)
	{
		if (filename == NULL)
		{
			return false;
		}
		if (m_pIni->Load(filename) != 0)
		{
			ScutLog("Load Ini file Error %s\r\n", filename);
			return false;
		}		
		return true;
	}
Exemplo n.º 11
0
	bool CLuaIni::Save(const char *filename)
	{
		if (filename == NULL)
		{
			return false;
		}
		if (m_pIni->Save(initSavePath(filename).c_str()) != 0)
		{
			ScutLog("Save Ini file Error %s", initSavePath(filename).c_str());
			return false;
		}

		return true;
	}
Exemplo n.º 12
0
unsigned long long CNetStreamExport::getInt64()
{

    if(m_nStreamPos + 8 > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getInt64");
        return 0;
    }

    unsigned long long value;
    memcpy(&value, m_pDataStream + m_nStreamPos, sizeof(unsigned long long));
    m_nStreamPos = m_nStreamPos + 8;
    //m_nRecoredReadSize += 8;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += 8;
    }
    return value;
}
Exemplo n.º 13
0
int CNetStreamExport::getInt(void)
{
    if(m_nStreamPos + 4 > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getInt");
        return 0;
    }

    //int dw = *( (int*)(m_pDataStream + m_nStreamPos) );
    int dw;
    memcpy(&dw, m_pDataStream + m_nStreamPos, sizeof(int));
    m_nStreamPos=m_nStreamPos+4;
    //m_nRecoredReadSize +=4;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += 4;
    }
    return dw;
}
Exemplo n.º 14
0
char	CNetStreamExport::getCHAR(void)
{

    if(m_nStreamPos + 1> m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getCHAR ");
        return 0;
    }

    //char by = *( (char*)(m_pDataStream + m_nStreamPos) );
    char by;
    memcpy(&by, m_pDataStream + m_nStreamPos, sizeof(char));
    m_nStreamPos=m_nStreamPos+1;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += 1;
    }
    return by;
}
Exemplo n.º 15
0
short	CNetStreamExport::getSHORT(void)
{
    if(m_nStreamPos + 2 > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getSHORT ");
        return 0;
    }

    //short w = *( (short*)(m_pDataStream + m_nStreamPos) );
    short w;
    memcpy(&w, m_pDataStream + m_nStreamPos, sizeof(short));
    m_nStreamPos=m_nStreamPos+2;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += 2;
    }
    return w;

}
Exemplo n.º 16
0
unsigned char* CFileHelper::getFileData(const char* pszFileName, const char* pszMode, unsigned long *pSize)
{
    unsigned char * pBuffer = NULL;
    *pSize = 0;
#ifdef SCUT_ANDROID
    do
    {
        // read the file from hardware
        FILE *fp = fopen(pszFileName, pszMode);
        if(!fp)break;

        fseek(fp,0,SEEK_END);
        *pSize = ftell(fp);
        fseek(fp,0,SEEK_SET);
        pBuffer = new unsigned char[*pSize];
        *pSize = fread(pBuffer,sizeof(unsigned char), *pSize,fp);
        fclose(fp);
    } while (0);
    if (pBuffer == NULL)
    {
        ScutLog("getFileData Error fileName=%s", pszFileName);
    }

#else
    do
    {
        // read the file from hardware
        FILE *fp = fopen(pszFileName, pszMode);
        if(!fp)break;

        fseek(fp,0,SEEK_END);
        *pSize = ftell(fp);
        fseek(fp,0,SEEK_SET);
        pBuffer = new unsigned char[*pSize];
        *pSize = fread(pBuffer,sizeof(unsigned char), *pSize,fp);
        fclose(fp);
    } while (0);
#endif

    return pBuffer;
}
Exemplo n.º 17
0
double	CNetStreamExport::getDouble(void)
{

    if(m_nStreamPos + 8 > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getDouble");
        return 0;
    }

    //double dw = *( (double*)(m_pDataStream + m_nStreamPos) );
    double dw;
    memcpy(&dw, m_pDataStream + m_nStreamPos, sizeof(double));
    m_nStreamPos = m_nStreamPos+8;
    //m_nRecoredReadSize +=8;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += 8;
    }
    return dw;
}
Exemplo n.º 18
0
float	CNetStreamExport::getFloat(void)
{
    if(m_nStreamPos + 4 > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: getFloat");
        return 0;
    }

    //float f = *( (float*)(m_pDataStream + m_nStreamPos) );

    float f;
    memcpy(&f, m_pDataStream + m_nStreamPos, sizeof(float));

    m_nStreamPos=m_nStreamPos+4;
    //m_nRecoredReadSize +=4;
    if (m_RecordStack.size())
    {
        RECORDINFO* pInfo = m_RecordStack.top();
        pInfo->nRecordReadSize += 4;
    }
    return f;
}
Exemplo n.º 19
0
bool CNetStreamExport::recordBegin()
{

    if(m_nStreamPos + 4 > m_nSize )
    {
        ScutLog(" Failed: 长度越界 CNetStreamExport: recordBegin ");
        return false;
    }

    //m_nRecoredReadSize = 0;
    int nRecoredSize = getInt();

    RECORDINFO *pinfo = new RECORDINFO(nRecoredSize, 4);
    m_RecordStack.push(pinfo);


    if(nRecoredSize > 4)
        return true;
    else
        return false;

}
Exemplo n.º 20
0
	int ZipUtils::inflateMemory_(unsigned char *in, unsigned int inLength, unsigned char **out, unsigned int *outLength)
	{
		/* ret value */
		int err = Z_OK;

		/* 256k initial decompress buffer */		
		int bufferSize = 256 * 1024;
		if (inLength * 8 > 256 * 1024)
		{
			bufferSize = 8 * inLength;
		}
		*out = new unsigned char[bufferSize];

		z_stream d_stream; /* decompression stream */	
		d_stream.zalloc = (alloc_func)0;
		d_stream.zfree = (free_func)0;
		d_stream.opaque = (voidpf)0;

		d_stream.next_in  = in;
		d_stream.avail_in = inLength;
		d_stream.next_out = *out;
		d_stream.avail_out = bufferSize;

		/* window size to hold 256k */
		if( (err = inflateInit2(&d_stream, 15 + 32)) != Z_OK )
		{
			return err;
		}

		for (;;) {
			err = inflate(&d_stream, Z_NO_FLUSH);

			if (err == Z_STREAM_END)
			{
				break;
			}

			switch (err) {
			case Z_NEED_DICT:
				err = Z_DATA_ERROR;
			case Z_DATA_ERROR:
			case Z_MEM_ERROR:
				inflateEnd(&d_stream);
				return err;
			}

			// not enough memory ?
			if (err != Z_STREAM_END) 
			{
				delete [] *out;
				*out = new unsigned char[bufferSize * BUFFER_INC_FACTOR];

				/* not enough memory, ouch */
				if (! *out ) 
				{
					ScutLog("ScutDataLogic: ZipUtils: realloc failed");
					inflateEnd(&d_stream);
					return Z_MEM_ERROR;
				}

				d_stream.next_out = *out + bufferSize;
				d_stream.avail_out = bufferSize;
				bufferSize *= BUFFER_INC_FACTOR;
			}
		}


		*outLength = bufferSize - d_stream.avail_out;
		err = inflateEnd(&d_stream);
		return err;
	}
Exemplo n.º 21
0
	int ZipUtils::ccInflateGZipFile(const char *path, unsigned char **out)
	{
		int len;
		unsigned int offset = 0;

		assert( out );
		assert( &*out );

		gzFile inFile = gzopen(path, "rb");
		if( inFile == NULL ) {
			ScutLog("ScutDataLogic: ZipUtils: error open gzip file: %s", path);
			return -1;
		}

		/* 512k initial decompress buffer */
		unsigned int bufferSize = 512 * 1024;
		unsigned int totalBufferSize = bufferSize;

		*out = (unsigned char*)malloc( bufferSize );
		if( ! out ) 
		{
			ScutLog("ScutDataLogic: ZipUtils: out of memory");
			return -1;
		}

		for (;;) {
			len = gzread(inFile, *out + offset, bufferSize);
			if (len < 0) 
			{
				ScutLog("ScutDataLogic: ZipUtils: error in gzread");
				free( *out );
				*out = NULL;
				return -1;
			}
			if (len == 0)
			{
				break;
			}

			offset += len;

			// finish reading the file
			if( (unsigned int)len < bufferSize )
			{
				break;
			}

			bufferSize *= BUFFER_INC_FACTOR;
			totalBufferSize += bufferSize;
			unsigned char *tmp = (unsigned char*)realloc(*out, totalBufferSize );

			if( ! tmp ) 
			{
				ScutLog("ScutDataLogic: ZipUtils: out of memory");
				free( *out );
				*out = NULL;
				return -1;
			}

			*out = tmp;
		}

		if (gzclose(inFile) != Z_OK)
		{
			ScutLog("ScutDataLogic: ZipUtils: gzclose failed");
		}

		return offset;
	}
Exemplo n.º 22
0
std::string CFileHelper::getPath(const char* szPath, bool bOnly2X)
{
    if (szPath == NULL)
    {
        ScutLog("getPath Input parameter == Null");
        return std::string();
    }
    if (szPath[0] == '/') {
        return std::string(szPath);
    }

#ifdef SCUT_ANDROID
    if (strstr(szPath, "resource/")) {
        return std::string(szPath);
    }
#endif
    std::string strDirPath = "";
    strDirPath += getResourceDir(szPath);

    // prevent getPath(getPath(imageName));  "icon/head.png" will become "resource/resource/head.png"
    std::string strTempPath(szPath);

    if (strDirPath.length() > 0 && strTempPath.find(strDirPath) == 0)
    {
        strDirPath = "";
    }

    if (strDirPath.size())
    {
        strDirPath += FILE_SEP;

        float fScale = cocos2d::Director::getInstance()->getContentScaleFactor();
        if (fScale > 1 || !(s_width == 480 && s_height == 320 || s_height == 320&& s_width == 480 || s_width
                            < 480 && s_height <480))
        {
            bool bTmx = false;
            const char* pPos = strstr(szPath, ".jpg");
            if (pPos == NULL)	//yubo image
            {
                pPos = strstr(szPath, ".ndj");
            }
            if (pPos == NULL)
            {
                pPos = strstr(szPath, ".png");
            }
            /*
            if (pPos == NULL)
            {
            	pPos = strstr(szPath, ".pnx");
            }
            */
            if (pPos == NULL)	//yubo image
            {
                pPos = strstr(szPath, ".ndp");
            }
            if (pPos == NULL)
            {
                pPos = strstr(szPath, ".tmx");
                bTmx = true;
            }
            if (pPos == NULL)
            {
                pPos = strstr(szPath, ".pvr");
                bTmx = true;
            }
            if (pPos == NULL)
            {
                pPos = strstr(szPath, ".ccz");
                bTmx = true;
            }
            if (pPos == NULL)
            {
                pPos = strstr(szPath, ".plist");
                bTmx = true;
            }
            if(pPos == NULL)
            {
                pPos = strstr(szPath, ".dat");
            }
            if (pPos != NULL)
            {
                char szTmp[256] = {0};
                char szFileName[256] = {0};
                memcpy(szFileName, szPath, pPos - szPath);
                if (bTmx && ((s_width == 1024 && s_height == 768) || (s_height == 1024&& s_width == 768)))
                {
                    if (bOnly2X)
                    {
                        sprintf(szTmp, "%s@2x%s", szFileName, pPos);
                    }
                    else
                        sprintf(szTmp, "%s@2x-ipad%s", szFileName, pPos);
                }
#if (defined SCUT_MAC || defined SCUT_WIN32)
                else if (bTmx && ((s_width == 960 && s_height == 640) || (s_height == 960 && s_width == 640)))
                {
                    if (bOnly2X)
                    {
                        sprintf(szTmp, "%s@2x%s", szFileName, pPos);
                    }
                    else
                        sprintf(szTmp, "%s@2x-ipad%s", szFileName, pPos);
                }
#endif
                else
                {
                    sprintf(szTmp, "%s@2x%s", szFileName, pPos);
                }

                strDirPath += szTmp;
            }
            else
            {
                strDirPath += szPath;
            }
        }
        else
        {
            strDirPath += szPath;
        }

    }
    else
    {
        strDirPath = szPath;
    }
#if defined(SCUT_IPHONE) || defined(SCUT_MAC)
    if (s_strIPhoneBundleID.size() == 0)
    {
        s_strIPhoneBundleID = ScutDataLogic::getBundleID();
    }

    std::string strRelativePath = s_strIPhoneBundleID;
    strRelativePath += FILE_SEP;
    strRelativePath += strDirPath;
    std::string strFilePath = ScutDataLogic::getDocumentFilePathByFileName(strRelativePath.c_str());
    struct stat st;
    if (true && stat(strFilePath.c_str(), &st) != 0)//cocos2d::CCImage::getIsScaleEnabled()
    {
        if (strFilePath.rfind("@2x") == std::string::npos)
        {
            strTempPath = strFilePath;
            int t = strTempPath.rfind(".");
            if (t != std::string::npos)
            {
                strTempPath.insert(t, "@2x");
                if (stat(strTempPath.c_str(), &st) == 0)
                {
                    return strFilePath;
                }
            }
        }

//			if (strDirPath.rfind("@2x") == std::string::npos)
//			{
//				int t = strDirPath.rfind(".");
//				if (t != std::string::npos)
//				{
//					strDirPath.insert(t, "@2x");
//				}
//			}
    }

    if (stat(strFilePath.c_str(), &st) == 0)
    {
        return strFilePath;
    }
    else
    {
        if (strFilePath.rfind(".png") != std::string::npos)
        {
            strTempPath = strFilePath;
            string_replace(strTempPath, ".png", ".pnx");
            if (stat(strTempPath.c_str(), &st) == 0)
            {
                return strTempPath;
            }
        }

        std::string retPath = std::string(appFullPathFromRelativePath(strDirPath.c_str()));
        if (retPath == strDirPath)
        {
            strTempPath = strDirPath;
            string_replace(strTempPath, ".png", ".pnx");
            retPath = std::string(appFullPathFromRelativePath(strTempPath.c_str()));
            if (retPath == strTempPath)
            {
                return strDirPath;
            }
            else
                return retPath;
        }

        return retPath;
    }
#endif

#ifdef SCUT_ANDROID
    if (s_strAndroidSDPath.size())
    {
        std::string strFilePath = s_strAndroidSDPath + strDirPath;
        struct stat st;

        if (true && stat(strFilePath.c_str(), &st) != 0)
        {
            if (strFilePath.rfind("@2x") == std::string::npos)
            {
                strTempPath = strFilePath;
                int t = strTempPath.rfind(".");
                if (t != std::string::npos)
                {
                    strTempPath.insert(t, "@2x");
                    if (stat(strTempPath.c_str(), &st) == 0)
                    {
                        return strFilePath;
                    }
                }
            }
        }

        if (stat(strFilePath.c_str(), &st) == 0)
        {
            return strFilePath;
        }
        else
        {
            if (strFilePath.rfind(".png") != std::string::npos)
            {
                strTempPath = strFilePath;
                string_replace(strTempPath, ".png", ".pnx");
                if (stat(strTempPath.c_str(), &st) == 0)
                {
                    return strTempPath;
                }
            }
        }
    }

    return std::string(strDirPath);
#endif

#ifdef SCUT_WIN32
    std::string ret= ScutExt::getResRootDir();
    ret += strDirPath;

    struct stat st;
    if (ret.rfind(".png") != std::string::npos && stat(ret.c_str(), &st) != 0)
    {
        strTempPath = ret;
        string_replace(strTempPath, ".png", ".pnx");
        if (stat(strTempPath.c_str(), &st) == 0)
        {
            return strTempPath;
        }
    }
    return ret;
#endif
}