GASPilot.cpp

Go to the documentation of this file.

/// \file GASPilot.cpp
/// \brief GASPilot game/utility launcher
/// \ingroup GASPilot
///
/// This utility launches games with the various subutilities.
///
/// Copyright (c) 2007-2008 by Michael Ellison.
/// See COPYING.txt for the \ref gaslicense License (MIT License).
///
// $Author: mikeellison $
// $Date: 2008-02-01 03:19:21 -0600 (Fri, 01 Feb 2008) $
// $Revision:   $
// $NoKeywords: $

#include "GASPilot.h"
#include "GASPilotGuiFactory.h"
#include "CATWindow.h"
#include "CATAppButton.h"
#include "CATEventDefs.h"
#include "CATFileSystem.h"

#include <psapi.h>
/// App construct - requires you to specify a runmode in the 
/// constructor.
///
/// \param runMode - current runmode. See CATRunMode
///
GASPilot::GASPilot(CATINSTANCE appInstance, CATRunMode runMode, const CATString& appName) 
: CATApp(appInstance, runMode, appName)
{
    fSteamThread    = 0;
    fControllerMenu = 0;
    fMappingMenu    = 0;
    fWindow         = 0;
    fInjectWindow   = 0;
    fCfgWindow      = 0;
    fMapper = new GASProtoMapper();
}

GASPilot::~GASPilot()
{
    delete fMapper;
}

CATResult GASPilot::OnStart()
{
    CATResult result = CAT_SUCCESS;
    CATString skinPath = this->GetSkinDir();
    skinPath << "Skin.xml";

    CATString skinDir, skinFile;
    this->fGlobalFileSystem->SplitPath(skinPath, skinDir, skinFile);
    this->fGUIFactory = new GASPilotGuiFactory(skinDir,skinPath);

    if (CATFAILED(result = this->LoadSkin(skinPath)))
    {
        return result;
    }

    if (result != CAT_SUCCESS)
    {
        this->DisplayError(result);
    }
        
    result = fSkin->OpenWindow(L"GASPilot", fWindow);
    
    // Snag control ptr's, if available
    if (fWindow)
    {
        fMappingMenu    = (CATMenu*)  fWindow->FindControlAndVerify(L"MappingMenu",   L"Menu");
    }

    this->fMapper->Initialize();

    fCfgWindow = fSkin->GetWindowByName(L"ConfigWindow");
    if (fCfgWindow)
    {
        fControllerMenu = (CATMenu*)fCfgWindow->FindControlAndVerify(L"ControllerMenu",L"Menu");
    }

    // Fill menus
    UpdateMappingMenu();
    UpdateControllerMenu();


    
    return result;
}

CATResult GASPilot::OnEnd(const CATResult& result)
{
    fMapper->Uninitialize();
    return result;
}

CATResult GASPilot::OnEvent(const CATEvent& event, CATInt32& retVal)
{
    if (event.fEventCode == CATEVENT_WINDOW_HIDDEN)
    {
        if ((event.fStringParam1.CompareNoCase(L"ProcessPick") == 0) ||
            (event.fStringParam1.CompareNoCase(L"ConfigWindow") == 0))
        {
            this->fWindow->SetEnabled(true);        
            ::SetForegroundWindow(fWindow->OSGetWnd());
        }
    }
    return CATApp::OnEvent(event, retVal);
}

CATResult GASPilot::MainLoop()
{
    MSG msg;
    CATResult result = CAT_SUCCESS;

    while (::GetMessage(&msg,0,0,0))
    {
        ::TranslateMessage(&msg);
        ::DispatchMessage(&msg);
    }   
    return result;
}


// OnCommand() is called each time a command is received by the application.
//
// Most often, commands will come up from the Skin from controls. Each time
// a button is clicked or a knob turned, for example.
//
// The commands are a class, primarily containing a command string that the
// application should check to see if it supports. If so, the command should 
// be performed.
//
// \param command - the command to execute
// \param ctrl - the control that sent the command, or 0
// \param wnd - the window of the control, or 0
// \param skin - the skin the command came from, or 0
void GASPilot::OnCommand(    CATCommand& command, 
                             CATControl* ctrl, 
                             CATWindow*  wnd, 
                             CATSkin*    skin)
{
    CATString commandString = command.GetCmdString();
    CATResult result = CAT_SUCCESS;

    if (0 == commandString.Compare(L"GoWebsite"))
    {
        CATExecute(L"http://gameaccess.sourceforge.net",0);
    }
    else if (0 == commandString.Compare(L"Mapping"))
    {
        CATTRACE("Mapping Menu Cmd");
        SetActiveMapping(command.GetStringParam());
    }
    else if (0 == commandString.Compare(L"Controller"))
    {
        CATTRACE("Controller change cmd");
        if (this->fCfgWindow->FindControlAndVerify(L"ControllerSwitch",L"Switch")->GetValue() >= 0.5)
        {
            fMapper->StopMapping();
            fMapper->StartMapping(fControllerMenu->GetString(),this->fMappingMenu->GetString());
        }
    }
    else if (0 == commandString.Compare(L"App"))
    {
        CATTRACE("App Cmd");
        CATString execFile = ctrl->GetAttribute(L"AppPath");
        result = StartGame(execFile);
    }
    else if (0 == commandString.Compare(L"Pick"))
    {
        CATTRACE("Pick Cmd");
        std::vector<CATString> typeList;
        typeList.push_back(L"Executable Files|(*.exe)");

        CATString execFile = L"*.exe";

        if (CATSUCCEEDED(OpenFileDialog(L"Pick the game to execute",typeList,execFile,fWindow)))
        {
            result = StartGame(execFile);
        }
    }
    else if (0 == commandString.Compare(L"AppInject"))
    {
        CATString execFile = ctrl->GetAttribute(L"AppPath");
        CATString execName = execFile.GetFilenameExt();
        CATUInt32 pid = 0;
        if (CATSUCCEEDED(CATDLLInjector::GetProcessId(execName,pid)))
        {
            CATString dllPath = this->GetAppExePath().GetDriveDirectory() << L"GASPilotDLL.dll";
            CATDLLInjector::InjectIntoProcess(dllPath,pid);    

            CATString wndName = ctrl->GetAttribute(L"WndName");
            HWND wnd = ::FindWindow(0,wndName);
            if (wnd)
            {
                ::ShowWindow(wnd,SW_RESTORE);
                ::SetForegroundWindow(wnd);
            }
        }

        this->fWindow->SetEnabled(true);        
        this->fSkin->CloseWindow(L"ProcessPick");
    }
    else if (0 == commandString.Compare(L"Inject"))
    {
        this->fWindow->SetEnabled(false);        
        this->fSkin->OpenWindow(L"ProcessPick",fInjectWindow,fWindow,&fWindow->OSGetWndRect().Origin());        
        if (fInjectWindow)
        {
            /// Enumerate process windows
            fCurBtn = 0;
            EnumWindows(FillInjectWindow,(LPARAM)this);
        }
        else
        {
            this->fWindow->SetEnabled(true);
        }
    }
    else if (0 == commandString.Compare(L"Config"))
    {
        this->fWindow->SetEnabled(false);        
        this->fSkin->OpenWindow(L"ConfigWindow",fCfgWindow,fWindow,&fWindow->OSGetWndRect().Origin());        
        if (fCfgWindow)
        {
            // init?
        }
        else
        {
            this->fWindow->SetEnabled(true);
        }
    }
    else if (0 == commandString.Compare(L"CancelInject"))
    {
        this->fWindow->SetEnabled(true);        
        this->fSkin->CloseWindow(L"ProcessPick");
    }
    else if (0 == commandString.Compare(L"ExitCfg"))
    {
        this->fWindow->SetEnabled(true);        
        this->fSkin->CloseWindow(L"ConfigWindow");
    }
    else if (0 == commandString.Compare(L"Exit"))
    {
        this->fWindow->SetEnabled(true);        
        this->fSkin->CloseWindow(L"GASPilot");
    }    
    else if (0 == commandString.Compare(L"ControllerSwitch"))
    {
        if (command.GetValue() >= 0.5)
        {
            fMapper->StartMapping(fControllerMenu->GetString(),this->fMappingMenu->GetString());
            // Turn off mapping
        }
        else
        {
            fMapper->StopMapping();
            // Turn on mapping
        }
    }
    else
    {
        CATApp::OnCommand(command,ctrl,wnd,skin);
    }

    if (CATFAILED(result))
    {
        DisplayMessage( this->GetString(result),fWindow);
    }
}

BOOL CALLBACK GASPilot::FillInjectWindow( HWND hwnd,
                                          LPARAM lParam)
{
    GASPilot* gp = (GASPilot*)lParam;
    return gp->OnInjectWindow(hwnd)?TRUE:FALSE;
}

bool GASPilot::OnInjectWindow(HWND hwnd)
{
    if (!this->fInjectWindow)
        return false;

    if (fCurBtn >= 11)
        return false;

    DWORD procId = 0;
    GetWindowThreadProcessId(hwnd,&procId);
    CATString procPath;
    CATString wndName;
    
    // Get the name of the window
    ::GetWindowText(hwnd,wndName.GetUnicodeBuffer(100),99);
    wndName.ReleaseBuffer();

    DWORD style = ::GetWindowLong(hwnd,GWL_STYLE);
    DWORD styleEx = ::GetWindowLong(hwnd,GWL_EXSTYLE);
    if ( (!(style&WS_VISIBLE)) || (style & WS_CHILD) || 
         (style&WS_DISABLED) || (styleEx & WS_EX_TOOLWINDOW) || 
         (styleEx & WS_EX_CONTROLPARENT))
        return true;

    // Don't get empty ones.
    if (wndName.IsEmpty())
        return true;

    ::OutputDebugString(wndName);
    ::OutputDebugString(kCRLF);

    if (procId)
    {
        HANDLE process = ::OpenProcess(PROCESS_QUERY_INFORMATION |PROCESS_VM_READ,FALSE,procId);
        if (process != 0)
        {
            HMODULE hMod;
            DWORD cbNeeded;

            if ( EnumProcessModules( process, &hMod, sizeof(hMod), &cbNeeded) )
            {
                ::GetModuleFileNameEx(process,hMod,procPath.GetUnicodeBuffer(1024),1023);
                procPath.ReleaseBuffer();
            }
        }
    }
    
    if (procPath.IsEmpty())
        return true;

    if (procPath.GetFilenameNoExt().CompareNoCase(L"GASPilot") == 0)
        return true;

    // Got name and full path, now add to appbutton
    CATString btnName;
    btnName.Format(L"AppInject%d",fCurBtn+1);
    CATAppButton* curBtn = (CATAppButton*)fInjectWindow->FindControlAndVerify(btnName,L"AppButton");
    if (!curBtn)
        return false;
    ::OutputDebugString(procPath);
    curBtn->AddAttribute(L"AppPath",procPath);
    curBtn->AddAttribute(L"WndName",wndName);
    curBtn->SetEnabled(true);
    curBtn->ParseAttributes();

    fCurBtn++;

    return true;
}

void GASPilot::UpdateMappingMenu()
{
    // Add in when the mapping object is done
    fMappingMenu->Clear();
    CATMENUITEM* newMenuItem = 0;        
    fMappingMenu->Insert(L"Speed Proto - PageUp/Down",0,newMenuItem,0);
    fMappingMenu->SetCurItem(newMenuItem);
}

void GASPilot::UpdateControllerMenu()
{
    if (!fControllerMenu)
        return;

    CATString oldString = fControllerMenu->GetString();

    fMapper->StopMapping();

    fControllerMenu->Clear();
    std::vector<CATString> ctrlList;
    fMapper->GetControllerList(ctrlList);
    // Add in when the mapping object is done
    CATMENUITEM* newMenuItem = 0;        
    CATMENUITEM* firstMenuItem = 0;        
    CATMENUITEM* oldSel = 0;
    if (ctrlList.size() == 0)
    {
        fControllerMenu->Insert(L"None detected.",0,newMenuItem,0);
        firstMenuItem = newMenuItem;
        fControllerMenu->SetCurItem(newMenuItem);
    }
    else
    {
        for (CATUInt32 i = 0; i < ctrlList.size(); i++)
        {
            fControllerMenu->Insert( ctrlList[i],0,newMenuItem,0);
            if (oldString.Compare(ctrlList[i]) == 0)
                oldSel = newMenuItem;

            if (!firstMenuItem)
                firstMenuItem = newMenuItem;
        }
        if (oldSel)
            fControllerMenu->SetCurItem(oldSel);
        else
            fControllerMenu->SetCurItem(firstMenuItem);

        fMapper->StartMapping(fControllerMenu->GetString(),this->fMappingMenu->GetString());
    }        
}

CATResult GASPilot::SetActiveMapping(const CATString& mappingName)
{
    CATString controlName;
 
    //fMapper.StartMapping();
    return CAT_SUCCESS;
}

CATResult GASPilot::StartGame(const CATWChar* executable)
{
    CATResult result = CAT_SUCCESS;

    // Inject DLL and start
    CATString dllPath = this->GetAppExePath().GetDriveDirectory() << L"GASPilotDLL.dll";
    
    CATString appPath = executable;
    CATString appName = appPath.GetFilenameNoExt();
    
    if (0 == appName.CompareNoCase(L"steam"))
    {
        result = CATExecute(executable);

        // Check for an already running thread - if one's zombied, close it out.
        if (fSteamThread != 0)
        {
            if (WAIT_OBJECT_0 == WaitForSingleObject(fSteamThread,1000))
            {
                CloseHandle(fSteamThread);
                fSteamThread = 0;
            }
        }

        // If we don't have an active steam thread, start one.
        if (fSteamThread == 0)
        {
            unsigned int threadId = 0;
            fSteamThread = (HANDLE)_beginthreadex(0,0,SteamWatcher,this,0,&threadId);        
        }
    }
    else
    {
        result = CATDLLInjector::StartDLLWithProcess(dllPath,
                                                     executable,
                                                     executable);
    }
    return result;
}
void GASPilot::SteamWatch()
{
    CATString dllPath = this->GetAppExePath().GetDriveDirectory() << L"GASPilotDLL.dll";
    CATUInt32 goupid  = 0;
    CATUInt32 gouLast = 0;
    CATUInt32 hl2pid  = 0;
    CATUInt32 hl2Last = 0;

    for (;;)
    {
        Sleep(100);
        
        // Check if steam's still running. If not, no need for the thread.
        // We don't inject into steam itself, as it appears to cause it to
        // refuse to login (protection? bug in my code? timing mismatch?)
        CATUInt32 steampid = 0;
        if (CATFAILED(CATDLLInjector::GetProcessId(L"steam.exe",steampid)))
        {
            break;
        }

        // Ok, now watch for HL2.exe
        if (CATSUCCEEDED(CATDLLInjector::GetProcessId(L"hl2.exe",hl2pid)))
        {
            if (hl2pid != hl2Last)
            {
                CATDLLInjector::InjectIntoProcess(dllPath,hl2pid);    
                hl2Last = hl2pid;
            }
        }
                                                   
        if (CATSUCCEEDED(CATDLLInjector::GetProcessId(L"gameoverlayui.exe",goupid)))
        {
            if (goupid != gouLast)
            {
                CATDLLInjector::InjectIntoProcess(dllPath,gouLast);
            }
            gouLast = goupid;
        }
        
        // If we're hooked and running, relax a bit.
        if ((hl2Last != 0) && (hl2pid == hl2Last) && (gouLast != 0) && (goupid == gouLast))
        {
            Sleep(30000);
        }        
    }
}


unsigned int __stdcall GASPilot::SteamWatcher(void *param)
{
    GASPilot* gp = (GASPilot*)param;
    gp->SteamWatch();
    return 0;
}


void GASPilot::OnHelp()
{
    CATString helpPath = this->GetHelpDir();    
    helpPath << L"GASPilot.htm";

    CATResult result = CATExecute(helpPath);
    if (CATFAILED(result))
    {
        this->DisplayError(result,fWindow);        
    }
}

---