path: root/vgui2/src/system_posix.cpp

//========= 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