conproc.c

Go to the documentation of this file.

/*
Copyright (C) 1997-2001 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
// conproc.c -- support for qhost
#include <stdio.h>
#include <process.h>
#include <windows.h>
#include "conproc.h"
 
#define CCOM_WRITE_TEXT     0x2
// Param1 : Text
 
#define CCOM_GET_TEXT       0x3
// Param1 : Begin line
// Param2 : End line
 
#define CCOM_GET_SCR_LINES  0x4
// No params
 
#define CCOM_SET_SCR_LINES  0x5
// Param1 : Number of lines
 
 
HANDLE  heventDone;
HANDLE  hfileBuffer;
HANDLE  heventChildSend;
HANDLE  heventParentSend;
HANDLE  hStdout;
HANDLE  hStdin;
 
unsigned _stdcall RequestProc (void *arg);
LPVOID GetMappedBuffer (HANDLE hfileBuffer);
void ReleaseMappedBuffer (LPVOID pBuffer);
BOOL GetScreenBufferLines (int *piLines);
BOOL SetScreenBufferLines (int iLines);
BOOL ReadText (LPTSTR pszText, int iBeginLine, int iEndLine);
BOOL WriteText (LPCTSTR szText);
int CharToCode (char c);
BOOL SetConsoleCXCY(HANDLE hStdout, int cx, int cy);
 
int     ccom_argc;
char    **ccom_argv;
 
/*
================
CCheckParm
 
Returns the position (1 to argc-1) in the program's argument list
where the given parameter apears, or 0 if not present
================
*/
int CCheckParm (char *parm)
{
    int             i;
    
    for (i=1 ; i<ccom_argc ; i++)
    {
        if (!ccom_argv[i])
            continue;
        if (!strcmp (parm,ccom_argv[i]))
            return i;
    }
        
    return 0;
}
 
 
void InitConProc (int argc, char **argv)
{
    unsigned    threadAddr;
    HANDLE      hFile;
    HANDLE      heventParent;
    HANDLE      heventChild;
    int         t;
 
    ccom_argc = argc;
    ccom_argv = argv;
 
// give QHOST a chance to hook into the console
    if ((t = CCheckParm ("-HFILE")) > 0)
    {
        if (t < argc)
            hFile = (HANDLE)atoi (ccom_argv[t+1]);
    }
        
    if ((t = CCheckParm ("-HPARENT")) > 0)
    {
        if (t < argc)
            heventParent = (HANDLE)atoi (ccom_argv[t+1]);
    }
        
    if ((t = CCheckParm ("-HCHILD")) > 0)
    {
        if (t < argc)
            heventChild = (HANDLE)atoi (ccom_argv[t+1]);
    }
 
 
// ignore if we don't have all the events.
    if (!hFile || !heventParent || !heventChild)
    {
        printf ("Qhost not present.\n");
        return;
    }
 
    printf ("Initializing for qhost.\n");
 
    hfileBuffer = hFile;
    heventParentSend = heventParent;
    heventChildSend = heventChild;
 
// so we'll know when to go away.
    heventDone = CreateEvent (NULL, FALSE, FALSE, NULL);
 
    if (!heventDone)
    {
        printf ("Couldn't create heventDone\n");
        return;
    }
 
    if (!_beginthreadex (NULL, 0, RequestProc, NULL, 0, &threadAddr))
    {
        CloseHandle (heventDone);
        printf ("Couldn't create QHOST thread\n");
        return;
    }
 
// save off the input/output handles.
    hStdout = GetStdHandle (STD_OUTPUT_HANDLE);
    hStdin = GetStdHandle (STD_INPUT_HANDLE);
 
// force 80 character width, at least 25 character height
    SetConsoleCXCY (hStdout, 80, 25);
}
 
 
void DeinitConProc (void)
{
    if (heventDone)
        SetEvent (heventDone);
}
 
 
unsigned _stdcall RequestProc (void *arg)
{
    int     *pBuffer;
    DWORD   dwRet;
    HANDLE  heventWait[2];
    int     iBeginLine, iEndLine;
    
    heventWait[0] = heventParentSend;
    heventWait[1] = heventDone;
 
    while (1)
    {
        dwRet = WaitForMultipleObjects (2, heventWait, FALSE, INFINITE);
 
    // heventDone fired, so we're exiting.
        if (dwRet == WAIT_OBJECT_0 + 1) 
            break;
 
        pBuffer = (int *) GetMappedBuffer (hfileBuffer);
        
    // hfileBuffer is invalid.  Just leave.
        if (!pBuffer)
        {
            printf ("Invalid hfileBuffer\n");
            break;
        }
 
        switch (pBuffer[0])
        {
            case CCOM_WRITE_TEXT:
            // Param1 : Text
                pBuffer[0] = WriteText ((LPCTSTR) (pBuffer + 1));
                break;
 
            case CCOM_GET_TEXT:
            // Param1 : Begin line
            // Param2 : End line
                iBeginLine = pBuffer[1];
                iEndLine = pBuffer[2];
                pBuffer[0] = ReadText ((LPTSTR) (pBuffer + 1), iBeginLine, 
                                       iEndLine);
                break;
 
            case CCOM_GET_SCR_LINES:
            // No params
                pBuffer[0] = GetScreenBufferLines (&pBuffer[1]);
                break;
 
            case CCOM_SET_SCR_LINES:
            // Param1 : Number of lines
                pBuffer[0] = SetScreenBufferLines (pBuffer[1]);
                break;
        }
 
        ReleaseMappedBuffer (pBuffer);
        SetEvent (heventChildSend);
    }
 
    _endthreadex (0);
    return 0;
}
 
 
LPVOID GetMappedBuffer (HANDLE hfileBuffer)
{
    LPVOID pBuffer;
 
    pBuffer = MapViewOfFile (hfileBuffer,
                            FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 
    return pBuffer;
}
 
 
void ReleaseMappedBuffer (LPVOID pBuffer)
{
    UnmapViewOfFile (pBuffer);
}
 
 
BOOL GetScreenBufferLines (int *piLines)
{
    CONSOLE_SCREEN_BUFFER_INFO  info;                             
    BOOL                        bRet;
 
    bRet = GetConsoleScreenBufferInfo (hStdout, &info);
        
    if (bRet)
        *piLines = info.dwSize.Y;
 
    return bRet;
}
 
 
BOOL SetScreenBufferLines (int iLines)
{
 
    return SetConsoleCXCY (hStdout, 80, iLines);
}
 
 
BOOL ReadText (LPTSTR pszText, int iBeginLine, int iEndLine)
{
    COORD   coord;
    DWORD   dwRead;
    BOOL    bRet;
 
    coord.X = 0;
    coord.Y = iBeginLine;
 
    bRet = ReadConsoleOutputCharacter(
        hStdout,
        pszText,
        80 * (iEndLine - iBeginLine + 1),
        coord,
        &dwRead);
 
    // Make sure it's null terminated.
    if (bRet)
        pszText[dwRead] = '\0';
 
    return bRet;
}
 
 
BOOL WriteText (LPCTSTR szText)
{
    DWORD           dwWritten;
    INPUT_RECORD    rec;
    char            upper, *sz;
 
    sz = (LPTSTR) szText;
 
    while (*sz)
    {
    // 13 is the code for a carriage return (\n) instead of 10.
        if (*sz == 10)
            *sz = 13;
 
        upper = toupper(*sz);
 
        rec.EventType = KEY_EVENT;
        rec.Event.KeyEvent.bKeyDown = TRUE;
        rec.Event.KeyEvent.wRepeatCount = 1;
        rec.Event.KeyEvent.wVirtualKeyCode = upper;
        rec.Event.KeyEvent.wVirtualScanCode = CharToCode (*sz);
        rec.Event.KeyEvent.uChar.AsciiChar = *sz;
        rec.Event.KeyEvent.uChar.UnicodeChar = *sz;
        rec.Event.KeyEvent.dwControlKeyState = isupper(*sz) ? 0x80 : 0x0; 
 
        WriteConsoleInput(
            hStdin,
            &rec,
            1,
            &dwWritten);
 
        rec.Event.KeyEvent.bKeyDown = FALSE;
 
        WriteConsoleInput(
            hStdin,
            &rec,
            1,
            &dwWritten);
 
        sz++;
    }
 
    return TRUE;
}
 
 
int CharToCode (char c)
{
    char upper;
        
    upper = toupper(c);
 
    switch (c)
    {
        case 13:
            return 28;
 
        default:
            break;
    }
 
    if (isalpha(c))
        return (30 + upper - 65); 
 
    if (isdigit(c))
        return (1 + upper - 47);
 
    return c;
}
 
 
BOOL SetConsoleCXCY(HANDLE hStdout, int cx, int cy)
{
    CONSOLE_SCREEN_BUFFER_INFO  info;
    COORD                       coordMax;
 
    coordMax = GetLargestConsoleWindowSize(hStdout);
 
    if (cy > coordMax.Y)
        cy = coordMax.Y;
 
    if (cx > coordMax.X)
        cx = coordMax.X;
 
    if (!GetConsoleScreenBufferInfo(hStdout, &info))
        return FALSE;
 
// height
    info.srWindow.Left = 0;         
    info.srWindow.Right = info.dwSize.X - 1;                
    info.srWindow.Top = 0;
    info.srWindow.Bottom = cy - 1;          
 
    if (cy < info.dwSize.Y)
    {
        if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
            return FALSE;
 
        info.dwSize.Y = cy;
 
        if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
            return FALSE;
    }
    else if (cy > info.dwSize.Y)
    {
        info.dwSize.Y = cy;
 
        if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
            return FALSE;
 
        if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
            return FALSE;
    }
 
    if (!GetConsoleScreenBufferInfo(hStdout, &info))
        return FALSE;
 
// width
    info.srWindow.Left = 0;         
    info.srWindow.Right = cx - 1;
    info.srWindow.Top = 0;
    info.srWindow.Bottom = info.dwSize.Y - 1;               
 
    if (cx < info.dwSize.X)
    {
        if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
            return FALSE;
 
        info.dwSize.X = cx;
    
        if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
            return FALSE;
    }
    else if (cx > info.dwSize.X)
    {
        info.dwSize.X = cx;
 
        if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
            return FALSE;
 
        if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
            return FALSE;
    }
 
    return TRUE;
}