Example #1
0
///////////////////////////////////////////////////////////////
//
// DelTree
//
//
//
///////////////////////////////////////////////////////////////
bool SharedUtil::DelTree ( const SString& strPath, const SString& strInsideHere )
{
    // Safety: Make sure strPath is inside strInsideHere
    WString wstrPath = FromUTF8( strPath );
    WString wstrInsideHere = FromUTF8( strInsideHere );
    if ( !wstrPath.BeginsWithI( wstrInsideHere ) )
    {
        assert ( 0 );
        return false;
    }

    DWORD dwBufferSize = ( wstrPath.length() + 3 ) * sizeof( wchar_t );
    wchar_t *szBuffer = static_cast < wchar_t* > ( alloca ( dwBufferSize ) );
    memset ( szBuffer, 0, dwBufferSize );
    wcsncpy ( szBuffer, wstrPath, wstrPath.length() );
    SHFILEOPSTRUCTW sfos;

    sfos.hwnd = NULL;
    sfos.wFunc = FO_DELETE;
    sfos.pFrom = szBuffer;  // Double NULL terminated
    sfos.pTo = NULL;
    sfos.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT | FOF_ALLOWUNDO;

    int status = SHFileOperationW(&sfos);
    return status == 0;
}
Example #2
0
float CBassAudio::GetSoundBPM(void)
{
    if (m_fBPM == 0.0f && !m_bStream)
    {
        float fData = 0.0f;
        // open the same file as played but for bpm decoding detection
        DWORD bpmChan = BASS_StreamCreateFile(false, FromUTF8(m_strPath), 0, 0, BASS_STREAM_DECODE | BASS_UNICODE);
        if (!bpmChan)
        {
            bpmChan = BASS_MusicLoad(false, FromUTF8(m_strPath), 0, 0, BASS_MUSIC_DECODE | BASS_MUSIC_PRESCAN | BASS_UNICODE, 0);
        }
        // detect bpm in background and return progress in GetBPM_ProgressCallback function
        if (bpmChan)
        {
            fData = BASS_FX_BPM_DecodeGet(bpmChan, 0, GetLength(), 0, BASS_FX_FREESOURCE, NULL, NULL);
        }

        if (BASS_ErrorGetCode() != BASS_OK)
        {
            g_pCore->GetConsole()->Printf("BASS ERROR %d in BASS_FX_BPM_DecodeGet  path:%s  3d:%d  loop:%d", BASS_ErrorGetCode(), *m_strPath, m_b3D, m_bLoop);
        }
        else
        {
            m_fBPM = floor(fData);
        }
        BASS_FX_BPM_BeatFree(bpmChan);
    }
    return m_fBPM;
}
Example #3
0
int SharedUtil::File::Rename(const char* szOldFilename, const char* szNewFilename)
{
#ifdef WIN32
    return _wrename(FromUTF8(szOldFilename), FromUTF8(szNewFilename));
#else
    return rename(szOldFilename, szNewFilename);
#endif
}
Example #4
0
FILE* SharedUtil::File::Fopen(const char* szFilename, const char* szMode)
{
#ifdef WIN32
    return _wfsopen(FromUTF8(szFilename), FromUTF8(szMode), _SH_DENYNO);
#else
    return fopen(szFilename, szMode);
#endif
}
 BOOL
 WINAPI
 MyMoveFileA(
     __in LPCSTR lpExistingFileName,
     __in LPCSTR lpNewFileName
     )
 {
     return MoveFileW( FromUTF8( lpExistingFileName ), FromUTF8( lpNewFileName ) );
 }
 BOOL
 WINAPI
 MyCopyFileA(
     __in LPCSTR lpExistingFileName,
     __in LPCSTR lpNewFileName,
     __in BOOL bFailIfExists
     )
 {
     return CopyFileW( FromUTF8( lpExistingFileName ), FromUTF8( lpNewFileName ), bFailIfExists );
 }
Example #7
0
SString SharedUtil::GetSystemLongPathName( const SString& strPath )
{
    wchar_t szBuffer[32000];
    szBuffer[0] = 0;
    GetLongPathNameW( FromUTF8( strPath ), szBuffer, NUMELMS( szBuffer ) - 1 );
    return ToUTF8( szBuffer );
}
Example #8
0
void MeaXMLParser::StartElementHandler(void *userData, const XML_Char *elementName,
                                        const XML_Char **attrs)
{
    MeaXMLParser *ps = static_cast<MeaXMLParser*>(userData);
    
    if (ps->m_haveDTD) {
        ps->m_validator->StartElement(ps->m_parser, elementName, attrs);
    }

    MeaXMLAttributes attributes(attrs, XML_GetSpecifiedAttributeCount(ps->m_parser));
    CString name(FromUTF8(elementName));
    CString container;
    if (!ps->m_elementStack->empty())
        container = ps->m_elementStack->top();
    ps->m_handler->StartElementHandler(container, name, attributes);
    ps->m_elementStack->push(name);

    if (ps->m_buildDOM) {
        MeaXMLNode* node = new MeaXMLNode(name, attributes);
        if (ps->m_nodeStack->empty()) {
            MeaAssert(ps->m_dom == NULL);
            ps->m_dom = node;
        }
        else {
            ps->m_nodeStack->top()->AddChild(node);
        }
        ps->m_nodeStack->push(node);
    }
}
Example #9
0
int MeaXMLParser::ExternalEntityRefHandler(XML_Parser parser,
                                        const XML_Char* context,
                                        const XML_Char* /*base*/,
                                        const XML_Char* systemId,
                                        const XML_Char* /*publicId*/)
{
    if (systemId != NULL) {
        MeaXMLParser *ps = reinterpret_cast<MeaXMLParser*>(parser);
        CString sysId(FromUTF8(systemId));

        if (sysId.Find(MeaXMLParser::m_homeURL) == 0) {
            TCHAR pathname[_MAX_PATH], drive[_MAX_DRIVE], dir[_MAX_DIR];
            GetModuleFileName(NULL, pathname, _MAX_PATH);
            _tsplitpath_s(pathname, drive, _MAX_DRIVE, dir, _MAX_DIR, NULL, 0, NULL, 0);

            sysId = CString(drive) + CString(dir) + sysId.Mid(_tcslen(MeaXMLParser::m_homeURL));
            sysId.Replace(_T('/'), _T('\\'));

            ps->m_pathnameStack->push(sysId);

            ps->m_context = context;
            ps->m_handler->ParseEntity(*ps, sysId);
            ps->m_context = NULL;

            ps->m_pathnameStack->pop();
        }
    }

    return 1;
}
Example #10
0
void CBassAudio::PlayStreamIntern(void* arguments)
{
    CBassAudio* pBassAudio = LockCallbackId(arguments);
    if (pBassAudio)
    {
        pBassAudio->m_pVars->criticalSection.Lock();
        SString strURL = pBassAudio->m_pVars->strURL;
        long    lFlags = pBassAudio->m_pVars->lFlags;
        pBassAudio->m_pVars->criticalSection.Unlock();
        UnlockCallbackId();

        // This can take a while
        HSTREAM pSound = BASS_StreamCreateURL(FromUTF8(strURL), 0, lFlags | BASS_UNICODE, NULL, NULL);

        CBassAudio* pBassAudio = LockCallbackId(arguments);
        if (pBassAudio)
        {
            pBassAudio->m_pVars->criticalSection.Lock();
            pBassAudio->m_pVars->bStreamCreateResult = true;
            pBassAudio->m_pVars->pSound = pSound;
            pBassAudio->m_pVars->criticalSection.Unlock();
        }
        else
        {
            // Deal with unwanted pSound
            g_pClientGame->GetManager()->GetSoundManager()->QueueChannelStop(pSound);
        }
    }

    UnlockCallbackId();
}
Example #11
0
SString CScreenShot::GetScreenShotPath ( int iNumber )
{
    //Create a search string
    SString strScreenShotName ( "%s\\mta-screen*.png", &szScreenShotPath[0] );
    HANDLE hFind;
    SString strReturn = "";
    WIN32_FIND_DATAW fdFindData;
    int i = 1;
    //Find the first match
    hFind = FindFirstFileW(FromUTF8( strScreenShotName ), &fdFindData);
    //Check if the first match failed
    if ( hFind != INVALID_HANDLE_VALUE) {
        if (iNumber == 1) {
            //We wanted the first file
            strReturn = SString("%s\\%s",&szScreenShotPath[0],fdFindData.cFileName);
        }
        else
        {
            //Loop through and find all occurences of the file
            while (FindNextFileW(hFind, &fdFindData)) { 
                //Keep going until we find the last file
                i++;
                if (iNumber == i) {
                    strReturn = SString("%s\\%s",&szScreenShotPath[0], fdFindData.cFileName);
                    break;
                }
            }
        }
    }
    FindClose(hFind); //Close the file handle
    // Get Return the file directory
    return strReturn;
}
bool CAudioContainerSA::GetRawAudioData ( eAudioLookupIndex lookupIndex, int bankIndex, int audioIndex, uint8*& dataOut, unsigned int& lengthOut, int& iSampleRateOut )
{
    int numBanks = m_pLookupTable->CountIndex ( lookupIndex );
    if ( numBanks == 0 )
        return false;

    // Get archive file size
    std::ifstream archive ( FromUTF8( GetAudioArchiveName ( lookupIndex ) ), std::ios::binary );

    SAudioLookupEntrySA* lookupEntry = m_pLookupTable->GetEntry ( lookupIndex, bankIndex );
    if ( !lookupEntry )
        return false;

    // Read audio archive bank header (an audio archieve has multiple bank headers)
    SAudioBankHeaderSA bankHeader;

    // Seek to the bank offset and read the header
    archive.seekg ( lookupEntry->offset );
    if ( !archive.read ( reinterpret_cast<char*> ( &bankHeader ), sizeof ( SAudioBankHeaderSA ) ) )
        return false;

    // Get offsets to calculate the length
    SAudioEntrySA* audioEntry = &bankHeader.sounds[audioIndex];
    if ( !audioEntry )
        return false;

    unsigned int rawLength;
    if ( audioIndex+1 < bankHeader.numSounds ) // hacky fix: audioIndex starts at 0
    {
        SAudioEntrySA* nextAudioEntry = &bankHeader.sounds[audioIndex+1];
        if ( !nextAudioEntry )
            return false;

        rawLength = nextAudioEntry->offset - audioEntry->offset;
    }
    else if ( audioIndex+1 == bankHeader.numSounds )
    {
        rawLength = lookupEntry->length - audioEntry->offset;
    }
    else
        return false;

    // 2MB check in case of user modification errors (Max length of standard audio files is 560KB)
    if ( rawLength > 2 * 1024 * 1024 )
        return false;

    // Now we are ready to read the audio data :)
    uint8* buffer = new uint8[rawLength];

    dataOut = buffer;
    lengthOut = rawLength;
    iSampleRateOut = audioEntry->sampleRate;

    // Seek to the correct offset and read
    archive.seekg ( lookupEntry->offset + sizeof(SAudioBankHeaderSA) + audioEntry->offset ); // Or just archive.seekg ( archive.tellg() + audioEntry->offset )
    archive.read(reinterpret_cast<char*> ( buffer ), rawLength );

    return !archive.fail();
}
Example #13
0
SString SharedUtil::GetSystemShortPathName(const SString& strPath)
{
    wchar_t szBuffer[32000];
    szBuffer[0] = 0;
    if (!GetShortPathNameW(FromUTF8(strPath), szBuffer, NUMELMS(szBuffer) - 1))
        return strPath;
    return ToUTF8(szBuffer);
}
Example #14
0
int SharedUtil::File::Delete(const char* szFilename)
{
#ifdef WIN32
    return _wremove(FromUTF8(szFilename));
#else
    return remove(szFilename);
#endif
}
 BOOL
 WINAPI
 MySetDllDirectoryA(
     __in_opt LPCSTR lpPathName
     )
 {
     return SetDllDirectoryW( FromUTF8( lpPathName ) );
 }
Example #16
0
// Get drive root from path
SString SharedUtil::GetPathDriveName( const SString& strPath )
{
    wchar_t szDrive[4] = L"";
    int iDriveNumber = PathGetDriveNumberW( FromUTF8( strPath ) );
    if ( iDriveNumber > -1 )
        PathBuildRootW( szDrive, iDriveNumber );
    return ToUTF8( szDrive );
}
Example #17
0
int SharedUtil::File::Mkdir(const char* szPath, int iMode)
{
#ifdef WIN32
    return _wmkdir(FromUTF8(szPath));
#else
    return mkdir(szPath, (mode_t)iMode);
#endif
}
 BOOL
 WINAPI
 MyDeleteFileA(
     __in LPCSTR lpFileName
     )
 {
     return DeleteFileW( FromUTF8( lpFileName ) );
 }
 HMODULE
 WINAPI
 MyLoadLibraryA(
     __in LPCSTR lpLibFileName
     )
 {
     return LoadLibraryW( FromUTF8( lpLibFileName ) );
 }
Example #20
0
int SharedUtil::File::Rmdir(const char* szPath)
{
#ifdef WIN32
    return _wrmdir(FromUTF8(szPath));
#else
    return rmdir(szPath);
#endif
}
 DWORD
 WINAPI
 MyGetFileAttributesA(
     __in LPCSTR lpFileName
     )
 {
     return GetFileAttributesW( FromUTF8( lpFileName ) );
 }
 BOOL
 WINAPI
 MyRemoveDirectoryA(
     __in LPCSTR lpPathName
     )
 {
     return RemoveDirectoryW( FromUTF8( lpPathName ) );
 }
Example #23
0
bool CWebCore::Initialise ()
{
    CefMainArgs mainArgs;
    void* sandboxInfo = nullptr;
    CefRefPtr<CCefApp> app { new CCefApp };

#if CEF_ENABLE_SANDBOX
    CefScopedSandboxInfo scopedSandbox;
    sandboxInfo = scopedSandbox.sandbox_info();
#endif

    if ( CefExecuteProcess ( mainArgs, app, sandboxInfo ) >= 0 )
        return false;

    CefSettings settings;
#if !CEF_ENABLE_SANDBOX
    settings.no_sandbox = true;
#endif

    // Specifiy sub process executable path
#ifndef MTA_DEBUG
    CefString ( &settings.browser_subprocess_path ).FromWString( FromUTF8( CalcMTASAPath ( "MTA\\CEF\\CEFLauncher.exe" ) ) );
#else
    CefString ( &settings.browser_subprocess_path ).FromWString( FromUTF8( CalcMTASAPath ( "MTA\\CEF\\CEFLauncher_d.exe" ) ) );
#endif
    CefString ( &settings.resources_dir_path ).FromWString ( FromUTF8( CalcMTASAPath( "MTA\\CEF") ) );
    CefString ( &settings.locales_dir_path ).FromWString( FromUTF8( CalcMTASAPath( "MTA\\CEF\\locales" ) ) );
    CefString ( &settings.log_file ).FromWString ( FromUTF8( CalcMTASAPath ( "MTA\\CEF\\cefdebug.txt" ) ) );
#ifdef MTA_DEBUG
    settings.log_severity = cef_log_severity_t::LOGSEVERITY_INFO;
#else
    settings.log_severity = cef_log_severity_t::LOGSEVERITY_WARNING;
#endif

    settings.multi_threaded_message_loop = true;
    settings.windowless_rendering_enabled = true;

    bool state = CefInitialize ( mainArgs, settings, app, sandboxInfo );
    
    // Register custom scheme handler factory
    CefRegisterSchemeHandlerFactory ( "mtalocal", "", app );
    CefRegisterSchemeHandlerFactory ( "http", "mta", app );

    return state;
}
 BOOL
 WINAPI
 MySetFileAttributesA(
     __in LPCSTR lpFileName,
     __in DWORD dwFileAttributes
     )
 {
     return SetFileAttributesW( FromUTF8( lpFileName ), dwFileAttributes );
 }
Example #25
0
std::auto_ptr<std::istream>
UnixFileSystem::open_file(const std::string& filename)
{
#ifdef WIN32
  return std::auto_ptr<std::istream>(new std::ifstream(FromUTF8(filename.c_str())));
#else
  return std::auto_ptr<std::istream>(new std::ifstream(filename.c_str()));
#endif
}
Example #26
0
 std::wstring const FromDouble(double const value, size_t const prec) {
     char format[16] = {0};
     //sprintf_s(format, 16, "%%.%df", prec);
     sprintf(format, "%%.%df", (int)prec);
     char stringValue[64] = {0};
     //sprintf_s(stringValue, 64, format, value);
     sprintf(stringValue, format, value);
     return FromUTF8(stringValue);
 }
 HMODULE
 WINAPI
 MyGetModuleHandleA(
     __in_opt LPCSTR lpModuleName
     )
 {
     if ( !lpModuleName )
         return GetModuleHandleW( NULL );
     return GetModuleHandleW( FromUTF8( lpModuleName ) );
 }
Example #28
0
size_t
BUnicodeChar::UTF8StringLength(const char *str, size_t maxLength)
{
	size_t len = 0;
	while (len < maxLength && *str) {
		FromUTF8(&str);
		len++;
	}
	return len;
}
 HMODULE
 WINAPI
 MyLoadLibraryExA(
     __in       LPCSTR lpLibFileName,
     __reserved HANDLE hFile,
     __in       DWORD dwFlags
     )
 {
     return LoadLibraryExW( FromUTF8( lpLibFileName ), hFile, dwFlags );
 }
 BOOL
 WINAPI
 MyGetDiskFreeSpaceExA(
     __in_opt  LPCSTR lpDirectoryName,
     __out_opt PULARGE_INTEGER lpFreeBytesAvailableToCaller,
     __out_opt PULARGE_INTEGER lpTotalNumberOfBytes,
     __out_opt PULARGE_INTEGER lpTotalNumberOfFreeBytes
     )
 {
     return GetDiskFreeSpaceExW( FromUTF8( lpDirectoryName ), lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes );
 }