You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
809 lines
23 KiB
809 lines
23 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//=============================================================================// |
|
|
|
|
|
#include <assert.h> |
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <math.h> |
|
#include <sys/mount.h> |
|
#include <sys/stat.h> |
|
#include <sys/param.h> |
|
|
|
#include <vgui/VGUI.h> |
|
#include <vgui/ISystem.h> |
|
#include <KeyValues.h> |
|
#include <vgui/IInputInternal.h> |
|
#include <vgui/ISurface.h> |
|
#include "tier0/vcrmode.h" |
|
#include "tier1/fmtstr.h" |
|
#include "filesystem.h" |
|
|
|
#include "vgui_internal.h" |
|
#include "filesystem_helpers.h" |
|
#include "vgui_key_translation.h" |
|
#include "filesystem.h" |
|
|
|
#ifdef OSX |
|
#include <Carbon/Carbon.h> |
|
#elif defined(LINUX) |
|
#include <sys/vfs.h> |
|
#endif |
|
|
|
#ifdef USE_SDL |
|
#include "SDL_clipboard.h" |
|
#include "SDL_error.h" |
|
#endif |
|
|
|
#define PROTECTED_THINGS_DISABLE |
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include <tier0/memdbgon.h> |
|
|
|
using namespace vgui; |
|
|
|
uint16 System_GetKeyState( int virtualKeyCode ) |
|
{ |
|
#ifndef _XBOX |
|
return g_pVCR->Hook_GetKeyState(virtualKeyCode); |
|
#else |
|
return 0; |
|
#endif |
|
} |
|
|
|
class CSystem : public ISystem |
|
{ |
|
public: |
|
CSystem(); |
|
~CSystem(); |
|
|
|
virtual void Shutdown(); |
|
virtual void RunFrame(); |
|
|
|
virtual long GetTimeMillis(); |
|
|
|
// returns the time at the start of the frame |
|
virtual double GetFrameTime(); |
|
|
|
// returns the current time |
|
virtual double GetCurrentTime(); |
|
|
|
virtual void ShellExecute(const char *command, const char *file); |
|
|
|
virtual int GetClipboardTextCount(); |
|
virtual void SetClipboardText(const char *text, int textLen); |
|
virtual void SetClipboardText(const wchar_t *text, int textLen); |
|
virtual int GetClipboardText(int offset, char *buf, int bufLen); |
|
virtual int GetClipboardText(int offset, wchar_t *buf, int bufLen); |
|
|
|
virtual void SetClipboardImage( void *pWnd, int x1, int y1, int x2, int y2 ); |
|
|
|
virtual bool SetRegistryString(const char *key, const char *value); |
|
virtual bool GetRegistryString(const char *key, char *value, int valueLen); |
|
virtual bool SetRegistryInteger(const char *key, int value); |
|
virtual bool GetRegistryInteger(const char *key, int &value); |
|
virtual bool DeleteRegistryKey(const char *keyName); |
|
|
|
virtual bool SetWatchForComputerUse(bool state); |
|
virtual double GetTimeSinceLastUse(); |
|
virtual int GetAvailableDrives(char *buf, int bufLen); |
|
virtual double GetFreeDiskSpace(const char *path); |
|
|
|
virtual KeyValues *GetUserConfigFileData(const char *dialogName, int dialogID); |
|
virtual void SetUserConfigFile(const char *fileName, const char *pathName); |
|
virtual void SaveUserConfigFile(); |
|
|
|
virtual bool CommandLineParamExists(const char *commandName); |
|
virtual bool GetCommandLineParamValue(const char *paramName, char *value, int valueBufferSize); |
|
virtual const char *GetFullCommandLine(); |
|
virtual bool GetCurrentTimeAndDate(int *year, int *month, int *dayOfWeek, int *day, int *hour, int *minute, int *second); |
|
|
|
// shortcut (.lnk) modification functions |
|
virtual bool CreateShortcut(const char *linkFileName, const char *targetPath, const char *arguments, const char *workingDirectory, const char *iconFile); |
|
virtual bool GetShortcutTarget(const char *linkFileName, char *targetPath, char *arguments, int destBufferSizes); |
|
virtual bool ModifyShortcutTarget(const char *linkFileName, const char *targetPath, const char *arguments, const char *workingDirectory); |
|
|
|
virtual KeyCode KeyCode_VirtualKeyToVGUI( int keyCode ); |
|
virtual int KeyCode_VGUIToVirtualKey( KeyCode keyCode ); |
|
// virtual MouseCode MouseCode_VirtualKeyToVGUI( int keyCode ); |
|
// virtual int MouseCode_VGUIToVirtualKey( MouseCode keyCode ); |
|
virtual const char *GetDesktopFolderPath(); |
|
virtual const char *GetStartMenuFolderPath(); |
|
virtual const char *GetAllUserDesktopFolderPath(); |
|
virtual const char *GetAllUserStartMenuFolderPath(); |
|
|
|
virtual void ShellExecuteEx( const char *command, const char *file, const char *pParams ); |
|
#ifdef DBGFLAG_VALIDATE |
|
virtual void Validate( CValidator &validator, char *pchName ); |
|
#endif |
|
|
|
private: |
|
void SaveRegistryToFile( bool bForce = false ); |
|
bool m_bStaticWatchForComputerUse; |
|
double m_StaticLastComputerUseTime; |
|
int m_iStaticMouseOldX, m_iStaticMouseOldY; |
|
// timer data |
|
double m_flFrameTime; |
|
KeyValues *m_pUserConfigData; |
|
char m_szFileName[MAX_PATH]; |
|
char m_szPathID[MAX_PATH]; |
|
|
|
KeyValues *m_pRegistry; |
|
double m_flRegistrySaveTime; |
|
bool m_bRegistryDirty; |
|
|
|
char m_szRegistryPath[ MAX_PATH ]; |
|
#ifdef OSX |
|
PasteboardRef m_PasteBoardRef; |
|
#endif |
|
|
|
}; |
|
|
|
|
|
CSystem g_System; |
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CSystem, ISystem, VGUI_SYSTEM_INTERFACE_VERSION, g_System); |
|
|
|
namespace vgui |
|
{ |
|
vgui::ISystem *g_pSystem = &g_System; |
|
} |
|
|
|
#define REGISTRY_NAME "cfg/registry.vdf" |
|
#define REGISTRY_SAVE_INTERVAL 30 |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CSystem::CSystem() |
|
{ |
|
m_bStaticWatchForComputerUse = false; |
|
m_flFrameTime = 0.0; |
|
m_flRegistrySaveTime = 0.0; |
|
m_bRegistryDirty = false; |
|
m_pUserConfigData = NULL; |
|
#ifdef OSX |
|
PasteboardCreate( kPasteboardClipboard, &m_PasteBoardRef ); |
|
#endif |
|
|
|
Q_snprintf( m_szRegistryPath, sizeof(m_szRegistryPath), "%s", REGISTRY_NAME ); |
|
|
|
m_pRegistry = new KeyValues( "registry" ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Destructor |
|
//----------------------------------------------------------------------------- |
|
CSystem::~CSystem() |
|
{ |
|
SaveRegistryToFile( true ); |
|
#ifdef OSX |
|
CFRelease( m_PasteBoardRef ); |
|
#endif |
|
} |
|
|
|
void CSystem::SaveRegistryToFile( bool bForce ) |
|
{ |
|
/*if ( m_pRegistry && ( m_bRegistryDirty || bForce ) && g_pFullFileSystem ) |
|
{ |
|
m_pRegistry->SaveToFile( g_pFullFileSystem, m_szRegistryPath, "MOD" ); |
|
}*/ |
|
m_bRegistryDirty = false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CSystem::Shutdown() |
|
{ |
|
if (m_pUserConfigData) |
|
{ |
|
m_pUserConfigData->deleteThis(); |
|
} |
|
SaveRegistryToFile( true ); |
|
if ( m_pRegistry ) |
|
{ |
|
m_pRegistry->deleteThis(); |
|
} |
|
m_pRegistry = NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles all the per frame actions |
|
//----------------------------------------------------------------------------- |
|
void CSystem::RunFrame() |
|
{ |
|
// record the current frame time |
|
m_flFrameTime = GetCurrentTime(); |
|
|
|
if (m_bStaticWatchForComputerUse) |
|
{ |
|
// check for mouse movement |
|
int x, y; |
|
g_pInput->GetCursorPos(x, y); |
|
// allow a little slack for jittery mice, don't reset until it's moved more than fifty pixels |
|
if (abs((x + y) - (m_iStaticMouseOldX + m_iStaticMouseOldY)) > 50) |
|
{ |
|
m_StaticLastComputerUseTime = Plat_MSTime(); |
|
m_iStaticMouseOldX = x; |
|
m_iStaticMouseOldY = y; |
|
} |
|
} |
|
|
|
if ( m_flFrameTime - m_flRegistrySaveTime > REGISTRY_SAVE_INTERVAL ) |
|
{ |
|
m_flRegistrySaveTime = m_flFrameTime; |
|
SaveRegistryToFile(); |
|
// Registry_RunFrame(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the time at the start of the frame |
|
//----------------------------------------------------------------------------- |
|
double CSystem::GetFrameTime() |
|
{ |
|
return m_flFrameTime; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the current time |
|
//----------------------------------------------------------------------------- |
|
double CSystem::GetCurrentTime() |
|
{ |
|
return Plat_FloatTime(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the current time in milliseconds |
|
//----------------------------------------------------------------------------- |
|
long CSystem::GetTimeMillis() |
|
{ |
|
return (long)(Plat_MSTime() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Legacy stub to allow ShellExecute( "open", "file" ) -- doesn't otherwise work |
|
//----------------------------------------------------------------------------- |
|
void CSystem::ShellExecute(const char *command, const char *file) |
|
{ |
|
if ( V_strcmp( command, "open" ) != 0 ) |
|
{ |
|
// Nope |
|
Assert( !"This legacy command is only supported in the form of open <foo>" ); |
|
return; |
|
} |
|
|
|
#ifdef OSX |
|
const char *szCommand = "open"; |
|
#else |
|
const char *szCommand = "xdg-open"; |
|
#endif |
|
|
|
pid_t pid = fork(); |
|
if ( pid == 0 ) |
|
{ |
|
// Child |
|
#ifdef LINUX |
|
// Escape steam runtime if necessary |
|
const char *szSteamRuntime = getenv( "STEAM_RUNTIME" ); |
|
if ( szSteamRuntime ) |
|
{ |
|
unsetenv( "STEAM_RUNTIME" ); |
|
|
|
const char *szSystemLibraryPath = getenv( "SYSTEM_LD_LIBRARY_PATH" ); |
|
const char *szSystemPath = getenv( "SYSTEM_PATH" ); |
|
if ( szSystemLibraryPath ) |
|
{ |
|
setenv( "LD_LIBRARY_PATH", szSystemLibraryPath, 1 ); |
|
} |
|
if ( szSystemPath ) |
|
{ |
|
setenv( "PATH", szSystemPath, 1 ); |
|
} |
|
} |
|
#endif |
|
execlp( szCommand, szCommand, file, (char *)0 ); |
|
Assert( !"execlp failed" ); |
|
} |
|
} |
|
|
|
void CSystem::ShellExecuteEx( const char *command, const char *file, const char *pParams ) |
|
{ |
|
NOTE_UNUSED( pParams ); |
|
ShellExecute( command, file ); |
|
} |
|
|
|
void CSystem::SetClipboardText(const char *text, int textLen) |
|
{ |
|
#ifdef OSX |
|
PasteboardSynchronize( m_PasteBoardRef ); |
|
PasteboardClear( m_PasteBoardRef ); |
|
CFDataRef theData = CFDataCreate( kCFAllocatorDefault, (const UInt8*)text, textLen ); |
|
PasteboardPutItemFlavor( m_PasteBoardRef, (PasteboardItemID)1, CFSTR("public.utf8-plain-text"), theData, 0 ); |
|
CFRelease( theData ); |
|
#elif defined( USE_SDL ) |
|
if ( Q_strlen( text ) <= textLen ) |
|
{ |
|
if ( SDL_SetClipboardText( text ) ) |
|
{ |
|
Msg( "SDL_SetClipboardText failed: %s\n", SDL_GetError() ); |
|
} |
|
} |
|
else |
|
{ |
|
char *ClipText = ( char *)malloc( textLen + 1 ); |
|
if ( ClipText ) |
|
{ |
|
Q_strncpy( ClipText, text, textLen + 1 ); |
|
if ( SDL_SetClipboardText( ClipText ) ) |
|
{ |
|
Msg( "SDL_SetClipboardText failed: %s\n", SDL_GetError() ); |
|
} |
|
free( ClipText ); |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
void CSystem::SetClipboardImage( void *pWnd, int x1, int y1, int x2, int y2 ) |
|
{ |
|
Assert( false ); |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Puts unicode text into the clipboard |
|
//----------------------------------------------------------------------------- |
|
void CSystem::SetClipboardText(const wchar_t *text, int textLen) |
|
{ |
|
char *charStr = (char *)malloc( textLen * 4 ); |
|
|
|
Q_UnicodeToUTF8( text, charStr, textLen*4 ); |
|
|
|
#ifdef OSX |
|
PasteboardSynchronize( m_PasteBoardRef ); |
|
PasteboardClear( m_PasteBoardRef ); |
|
|
|
CFDataRef theData = CFDataCreate( kCFAllocatorDefault, (const UInt8*)charStr, Q_strlen(charStr) ); |
|
PasteboardPutItemFlavor( m_PasteBoardRef, (PasteboardItemID)1, CFSTR("public.utf8-plain-text"), theData, 0 ); |
|
CFRelease( theData ); |
|
#elif defined( USE_SDL ) |
|
SetClipboardText( charStr, Q_strlen( charStr ) ); |
|
#endif |
|
|
|
free( charStr ); |
|
} |
|
|
|
int CSystem::GetClipboardTextCount() |
|
{ |
|
#ifdef OSX |
|
ItemCount count; |
|
PasteboardSynchronize( m_PasteBoardRef ); |
|
|
|
OSStatus err = PasteboardGetItemCount( m_PasteBoardRef, &count ); |
|
if ( err != noErr ) |
|
return 0; |
|
|
|
if ( count <= 0 ) |
|
return 0; |
|
|
|
PasteboardItemID ItemID; |
|
// always use the last item on the clipboard for any cut and paste data |
|
err = PasteboardGetItemIdentifier( m_PasteBoardRef, count, &ItemID ); |
|
if ( err != noErr ) |
|
return 0; |
|
CFDataRef outData; |
|
err = PasteboardCopyItemFlavorData ( m_PasteBoardRef, ItemID, CFSTR ("public.utf8-plain-text"), &outData); |
|
if ( err != noErr ) |
|
return 0; |
|
|
|
int copyLen = CFDataGetLength( outData ); |
|
CFRelease( outData ); |
|
return (int)copyLen + 1; |
|
#elif defined( USE_SDL ) |
|
int Count = 0; |
|
|
|
if ( SDL_HasClipboardText() ) |
|
{ |
|
char *text = SDL_GetClipboardText(); |
|
|
|
if ( text ) |
|
{ |
|
Count = Q_strlen( text ) + 1; |
|
SDL_free( text ); |
|
} |
|
} |
|
|
|
return Count; |
|
#else |
|
return 0; |
|
#endif |
|
} |
|
|
|
int CSystem::GetClipboardText(int offset, char *buf, int bufLen) |
|
{ |
|
Assert( !offset ); |
|
|
|
#ifdef OSX |
|
ItemCount count; |
|
PasteboardSynchronize( m_PasteBoardRef ); |
|
|
|
OSStatus err = PasteboardGetItemCount( m_PasteBoardRef, &count ); |
|
if ( err != noErr ) |
|
return 0; |
|
|
|
char *pchOutData; |
|
PasteboardItemID ItemID; |
|
// pull the last item from the clipboard |
|
err = PasteboardGetItemIdentifier( m_PasteBoardRef, count, &ItemID ); |
|
if ( err != noErr ) |
|
return 0; |
|
CFDataRef outData; |
|
err = PasteboardCopyItemFlavorData ( m_PasteBoardRef, ItemID, CFSTR ("public.utf8-plain-text"), &outData); |
|
if ( err != noErr ) |
|
return 0; |
|
pchOutData = (char *)CFDataGetBytePtr(outData ); |
|
int copyLen = MIN( CFDataGetLength( outData ), bufLen ) ; |
|
if ( pchOutData ) |
|
memcpy( buf, pchOutData, copyLen ); |
|
CFRelease( outData ); |
|
return copyLen; |
|
#elif defined( USE_SDL ) |
|
if( SDL_HasClipboardText() ) |
|
{ |
|
char *text = SDL_GetClipboardText(); |
|
|
|
if ( text ) |
|
{ |
|
Q_strncpy( buf, text, bufLen ); |
|
SDL_free( text ); |
|
return Q_strlen( buf ); |
|
} |
|
} |
|
|
|
return 0; |
|
#else |
|
return 0; |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Retrieves unicode text from the clipboard |
|
//----------------------------------------------------------------------------- |
|
int CSystem::GetClipboardText(int offset, wchar_t *buf, int bufLen) |
|
{ |
|
Assert( !offset ); |
|
|
|
char *outputUTF8 = (char *)malloc( bufLen*4 ); |
|
int ret = GetClipboardText( offset, outputUTF8, bufLen ); |
|
|
|
if ( ret ) |
|
{ |
|
Q_UTF8ToUnicode( outputUTF8, buf, bufLen ); |
|
} |
|
else if( bufLen > 0 ) |
|
{ |
|
buf[ 0 ] = 0; |
|
} |
|
|
|
free( outputUTF8 ); |
|
return ret; |
|
} |
|
|
|
|
|
bool CSystem::SetRegistryString(const char *key, const char *value) |
|
{ |
|
m_bRegistryDirty = true; |
|
m_pRegistry->SetString( key, value ); |
|
return true; |
|
} |
|
|
|
bool CSystem::GetRegistryString(const char *key, char *value, int valueLen) |
|
{ |
|
const char *pchVal = m_pRegistry->GetString( key ); |
|
if ( pchVal ) |
|
Q_strncpy( value, pchVal, valueLen ); |
|
return pchVal != NULL; |
|
} |
|
|
|
bool CSystem::SetRegistryInteger(const char *key, int value) |
|
{ |
|
m_bRegistryDirty = true; |
|
m_pRegistry->SetInt( key, value ); |
|
return false; |
|
} |
|
|
|
bool CSystem::GetRegistryInteger(const char *key, int &value) |
|
{ |
|
value = m_pRegistry->GetInt( key ); |
|
return value != 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: recursively deletes a registry key and all it's subkeys |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::DeleteRegistryKey(const char *key) |
|
{ |
|
Assert( false ); |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: sets whether or not the app watches for global computer use |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::SetWatchForComputerUse(bool state) |
|
{ |
|
if (state == m_bStaticWatchForComputerUse) |
|
return true; |
|
|
|
m_bStaticWatchForComputerUse = state; |
|
|
|
if (m_bStaticWatchForComputerUse) |
|
{ |
|
// enable watching |
|
} |
|
else |
|
{ |
|
// disable watching |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the time, in seconds, since the last computer use. |
|
//----------------------------------------------------------------------------- |
|
double CSystem::GetTimeSinceLastUse() |
|
{ |
|
if (m_bStaticWatchForComputerUse) |
|
{ |
|
return ( Plat_MSTime() - m_StaticLastComputerUseTime ) / 1000.0f; |
|
} |
|
|
|
return 0.0f; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the drives a user has available on thier system |
|
//----------------------------------------------------------------------------- |
|
int CSystem::GetAvailableDrives(char *buf, int bufLen) |
|
{ |
|
Assert( false ); |
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the amount of available disk space, in bytes, on the specified path |
|
//----------------------------------------------------------------------------- |
|
double CSystem::GetFreeDiskSpace(const char *path) |
|
{ |
|
struct statfs64 buf; |
|
int ret = statfs64( path, &buf ); |
|
if ( ret < 0 ) |
|
return 0.0; |
|
return (double) ( buf.f_bsize * buf.f_bfree ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: user config |
|
//----------------------------------------------------------------------------- |
|
KeyValues *CSystem::GetUserConfigFileData(const char *dialogName, int dialogID) |
|
{ |
|
if (!m_pUserConfigData) |
|
return NULL; |
|
|
|
Assert(dialogName && *dialogName); |
|
|
|
if (dialogID) |
|
{ |
|
char buf[256]; |
|
Q_snprintf(buf, sizeof(buf), "%s_%d", dialogName, dialogID); |
|
dialogName = buf; |
|
} |
|
|
|
return m_pUserConfigData->FindKey(dialogName, true); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: sets the name of the config file to save/restore from. Settings are loaded immediately. |
|
//----------------------------------------------------------------------------- |
|
void CSystem::SetUserConfigFile(const char *fileName, const char *pathName) |
|
{ |
|
//m_pRegistry->LoadFromFile( g_pFullFileSystem, m_szRegistryPath, NULL ); |
|
|
|
if (!m_pUserConfigData) |
|
{ |
|
m_pUserConfigData = new KeyValues("UserConfigData"); |
|
} |
|
else |
|
{ |
|
// delete all the existing keys so when we reload from the new file we don't |
|
// get duplicate entries in our key value |
|
m_pUserConfigData->Clear(); |
|
} |
|
|
|
Q_strncpy(m_szFileName, fileName, sizeof(m_szFileName)); |
|
Q_strncpy(m_szPathID, pathName, sizeof(m_szPathID)); |
|
|
|
// open |
|
m_pUserConfigData->UsesEscapeSequences( true ); // VGUI may use this |
|
m_pUserConfigData->LoadFromFile(g_pFullFileSystem, m_szFileName, m_szPathID); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: saves all the current settings to the user config file |
|
//----------------------------------------------------------------------------- |
|
void CSystem::SaveUserConfigFile() |
|
{ |
|
if (m_pUserConfigData) |
|
{ |
|
m_pUserConfigData->SaveToFile(g_pFullFileSystem, m_szFileName, m_szPathID); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns whether or not the parameter was on the command line |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::CommandLineParamExists(const char *paramName) |
|
{ |
|
if ( Q_strstr( Plat_GetCommandLine(), paramName ) ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: gets the string following a command line param |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::GetCommandLineParamValue(const char *paramName, char *value, int valueBufferSize) |
|
{ |
|
Assert( false ); |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the name of the currently running exe |
|
//----------------------------------------------------------------------------- |
|
const char *CSystem::GetFullCommandLine() |
|
{ |
|
return VCRHook_GetCommandLine(); |
|
} |
|
|
|
|
|
KeyCode CSystem::KeyCode_VirtualKeyToVGUI( int keyCode ) |
|
{ |
|
return ::KeyCode_VirtualKeyToVGUI( keyCode ); |
|
} |
|
|
|
int CSystem::KeyCode_VGUIToVirtualKey( KeyCode keyCode ) |
|
{ |
|
return ::KeyCode_VGUIToVirtualKey( keyCode ); |
|
} |
|
|
|
/*MouseCode CSystem::MouseCode_VirtualKeyToVGUI( int keyCode ) |
|
{ |
|
return ::MouseCode_VirtualKeyToVGUI( keyCode ); |
|
} |
|
|
|
int CSystem::MouseCode_VGUIToVirtualKey( MouseCode mouseCode ) |
|
{ |
|
return ::MouseCode_VGUIToVirtualKey( mouseCode ); |
|
}*/ |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the current local time and date |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::GetCurrentTimeAndDate(int *year, int *month, int *dayOfWeek, int *day, int *hour, int *minute, int *second) |
|
{ |
|
time_t t = time( NULL ); |
|
struct tm *now = localtime( &t ); |
|
if ( now ) |
|
{ |
|
if ( year ) *year = now->tm_year + 1900; |
|
if ( month ) *month = now->tm_mon + 1; |
|
if ( dayOfWeek ) *dayOfWeek = now->tm_wday; |
|
if ( day ) *day = now->tm_mday; |
|
if ( hour ) *hour = now->tm_hour; |
|
if ( minute ) *minute = now->tm_min; |
|
if ( second ) *second = now->tm_sec; |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Creates a shortcut file |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::CreateShortcut(const char *linkFileName, const char *targetPath, const char *arguments, const char *workingDirectory, const char *iconFile) |
|
{ |
|
Assert( false ); |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: retrieves shortcut (.lnk) information |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::GetShortcutTarget(const char *linkFileName, char *targetPath, char *arguments, int destBufferSizes) |
|
{ |
|
Assert( false ); |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: sets shortcut (.lnk) information |
|
//----------------------------------------------------------------------------- |
|
bool CSystem::ModifyShortcutTarget(const char *linkFileName, const char *targetPath, const char *arguments, const char *workingDirectory) |
|
{ |
|
Assert( false ); |
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the full path of the current user's desktop folder |
|
//----------------------------------------------------------------------------- |
|
const char *CSystem::GetDesktopFolderPath() |
|
{ |
|
Assert( false ); |
|
return NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the full path of the all user's desktop folder |
|
//----------------------------------------------------------------------------- |
|
const char *CSystem::GetAllUserDesktopFolderPath() |
|
{ |
|
Assert( false ); |
|
return NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the full path of the current user's start->program files |
|
//----------------------------------------------------------------------------- |
|
const char *CSystem::GetStartMenuFolderPath() |
|
{ |
|
Assert( false ); |
|
return NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the full path of the all user's start->program files |
|
//----------------------------------------------------------------------------- |
|
const char *CSystem::GetAllUserStartMenuFolderPath() |
|
{ |
|
Assert( false ); |
|
return NULL; |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Ensure that all of our internal structures are consistent, and |
|
// account for all memory that we've allocated. |
|
// Input: validator - Our global validator object |
|
// pchName - Our name (typically a member var in our container) |
|
//----------------------------------------------------------------------------- |
|
#ifdef DBGFLAG_VALIDATE |
|
void CSystem::Validate( CValidator &validator, char *pchName ) |
|
{ |
|
VALIDATE_SCOPE(); |
|
ValidatePtr( m_pUserConfigData ); |
|
} |
|
|
|
|
|
void Validate_System( CValidator &validator ) |
|
{ |
|
ValidateObj( g_System ); |
|
} |
|
#endif
|
|
|