---

winDressing.cpp

Go to the documentation of this file.

// winDressing.cpp : Defines the entry point for the application.


#include "stdafx.h"
#include "resource.h"

// Local Header Files
#include "BitmapScreen.h"
#include "MousePipe.h"
#include "ScreenPipe.h"
#include "UpdateHandler.h"

#define DEFAULTNAME     TEXT("Client")
#define DEFAULTCAPTURE  TEXT("ScreenCap_")

// Global Variables:
HINSTANCE hInst;        
CHString titleBarText;  
CHString windowClass;   

BitmapScreen *virtualScreen;    
UpdateHandler *updater = NULL;  

MousePipe *mouseServer = NULL;  
ScreenPipe *screenServer = NULL;    

DIBitmap mainBkGnd; 

TString clientName( DEFAULTNAME );          

TString captureName( DEFAULTCAPTURE );  
int captureFrequency = 1;               
int captureLimit = 0;                   
bool doCapture = false;                 

// Foward declarations of major functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    Name(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    Connect(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    Options(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     PWSTR     lpCmdLine,
                     int       nCmdShow)
{
    chWindows9xNotAllowed(); // Check that OS is NT based
    
    MSG msg;
    HACCEL hAccelTable;

    // Initialize global resource strings
    titleBarText.LoadString(IDS_APP_TITLE);
    windowClass.LoadString(IDC_WINDRESSING);

    // Perform application initialization:

    MyRegisterClass(hInstance);

    if (!InitInstance (hInstance, nCmdShow)) {
        return false;
    }

    hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_WINDRESSING);

    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0)) {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return msg.wParam;
}


ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX); 

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = (WNDPROC)WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, (LPCTSTR)IDI_WINDRESSING);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = NULL;
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_WINDRESSING);
    wcex.lpszClassName  = windowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

    return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // Store instance handle in our global variable

   hWnd = CreateWindowEx(
        0, 
        windowClass, 
        (LPCWSTR)titleBarText + TString(TEXT(" - Disconnected")), 
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        CW_USEDEFAULT,
        0, 
        CW_USEDEFAULT,
        0,
        NULL, 
        NULL, 
        hInstance, 
        NULL);

   if (!hWnd)
   {
      return false;
   }

   ShowWindow(hWnd, nCmdShow);

   return true;
}

// Mouse Message Handling Functions

bool downOnScreen = false;

bool registerMouse(bool down)
{
    static bool downLastSeen = false;

    if( down ){
        if ( !downLastSeen ){
            if( !mouseServer->queueMessage(virtualScreen->getScreenX(), virtualScreen->getScreenY(), 0) )
                return false;
        } else {
            if( !mouseServer->queueMessage(virtualScreen->getScreenX(), virtualScreen->getScreenY(), 1))
                return false;
            downLastSeen = false; // successfully sent the missing up message

            if( !mouseServer->queueMessage(virtualScreen->getScreenX(), virtualScreen->getScreenY(), 0))
                return false;
        }
    } else {
        if ( downLastSeen ){
            if( !mouseServer->queueMessage(virtualScreen->getScreenX(), virtualScreen->getScreenY(), 1))
                return false;
        } else {
            mouseServer->queueMessage(virtualScreen->getScreenX(), virtualScreen->getScreenY(), 0);
            downLastSeen = true; // successfully sent the missing down message

            if( !mouseServer->queueMessage(virtualScreen->getScreenX(), virtualScreen->getScreenY(), 1))
                return false;

        }
    }

    downLastSeen = down;
    return true;
}

void Cls_OnLButtonUp(HWND hWnd, int x, int y, UINT)
{   
    if( mouseServer == NULL )
        return;
    
    if( !downOnScreen ) // Didn't click on screen so don't bother sending an up
        return;
    
    virtualScreen->PointOnScreen(x,y); // sets the point iff it is on the screen
        
    int command = IDRETRY;

    while( !registerMouse(false) && command == IDRETRY ){
        if( !mouseServer->isConnected() )
            return;

        command = MessageBox(hWnd, 
                    TEXT("VCC has too many mouse messages or \nis no longer connected.\n\nPress Cancel to disconnect."), 
                    TEXT("Couldn't Queue Message"), 
                    MB_RETRYCANCEL | MB_ICONWARNING | MB_APPLMODAL);
        
        if( command == IDCANCEL ){
            SendNotifyMessage(hWnd, WM_COMMAND, IDM_DISCONNECT, 0);
        }   
    }   
    downOnScreen = false;   // Need to click on screen
}

void Cls_OnLButtonDown(HWND hWnd, BOOL, int x, int y, UINT)
{
    if( mouseServer == NULL )
        return;

    if( !virtualScreen->PointOnScreen(x,y) )
        return;

    if( registerMouse(true) ){
        downOnScreen = true;
    } else {
        if( !mouseServer->isConnected() )
            return;
                
        if( IDCANCEL ==  MessageBox(hWnd, 
                TEXT("VCC has too many mouse messages or \nis no longer connected.\n\nPress Cancel to disconnect."), 
                TEXT("Couldn't Queue Message"),
                MB_OKCANCEL | MB_ICONWARNING | MB_APPLMODAL) ){

            SendNotifyMessage(hWnd, WM_COMMAND, IDM_DISCONNECT, 0);
        }

    }
}

// Paint Message Handling Functions

/*! When the background bitmap requires redrawing this handler is called */
bool Cls_OnEraseBkgnd(HWND hWnd, HDC hDC)
{
    SetDIBitsToDevice(
        hDC,
        0, 0,
        mainBkGnd.getPBITMAPINFOHEADER()->biWidth,
        abs(mainBkGnd.getPBITMAPINFOHEADER()->biHeight),
        0, 0,
        0,
        abs(mainBkGnd.getPBITMAPINFOHEADER()->biHeight),
        mainBkGnd.getPBytes(),
        mainBkGnd.getPBITMAPINFO(),
        DIB_RGB_COLORS);
    return true;
}


void Cls_OnPaint(HWND hWnd)
{
    PAINTSTRUCT ps;
    HDC hDC = BeginPaint(hWnd, &ps);

    virtualScreen->paint(hDC);

    EndPaint(hWnd, &ps);
}

// Control etc Handling Functions
/*! Loads the background image and resizes the window */
bool Cls_OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct)
{
    if( !mainBkGnd.loadFile(TEXT("pigi.bmp")) ){
        MessageBox(hWnd, 
            TEXT("Press any key to continue, or any other to quit.\n"), 
            TEXT("Error - Can't find background image \"pigi.bmp\""), 
            MB_OK | MB_ICONERROR | MB_APPLMODAL);
        return false;
    }

    RECT clientArea, windowArea;

    GetClientRect(hWnd, &clientArea);
    GetWindowRect(hWnd, &windowArea);

    SetWindowPos(
        hWnd,
        HWND_TOP,
        0, 0,
        windowArea.right - windowArea.left              // current screen width
            + mainBkGnd.getPBITMAPINFOHEADER()->biWidth // + bitmap width 
            - clientArea.right,                         // - current client width
        windowArea.bottom - windowArea.top              // current screen height
            + mainBkGnd.getPBITMAPINFOHEADER()->biHeight // + bitmap height 
            - clientArea.bottom,                        // - current client height
        SWP_NOMOVE);

    virtualScreen = new BitmapScreen(114, 139, 240, -320);

    // If "initial.bmp" is present it is written to the screen else it remains blank
    DIBitmap *initial = virtualScreen->getWriteBuffer();
    if( !initial->loadFile( TEXT("initial.bmp") ) ){
        virtualScreen->DoneWriting();
    } else {
        virtualScreen->DoneWriting();

        initial = virtualScreen->getWriteBuffer();
        *initial = *virtualScreen->getReadBuffer();
        
        /* Since this is a contrived example and running in a single thread
         * you have to be carefull to call DoneReading before DoneWriting
         * else the thread blocks itself i.e. an idiotic deadlock
         */
        virtualScreen->DoneReading();   
        virtualScreen->DoneWriting();
    }

    UpdateWindow(hWnd); // sends a WM_PAINT message

    return true;
}

void Cls_OnDestroy(HWND)
{
    PostQuitMessage(0);
}

void Cls_OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify)
{
    static int capNo = 0;
    const DIBitmap* capture;

    // Parse the menu selections:
    switch (id){
    case IDM_ABOUT:
        DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
        break;
    case IDM_SC_OPTIONS:
        if( IDOK == DialogBox(hInst, (LPCTSTR)IDD_OPTIONS, hWnd, (DLGPROC)Options) ){
            ModifyMenu(GetMenu(hWnd), IDM_SC_ACTIVATE, MF_BYCOMMAND | MF_CHECKED, 
                IDM_SC_ACTIVATE, TEXT("Auto Capture"));
            doCapture = true;
            if( updater != NULL )
                updater->enableCapture();
        }
        break;
    case IDM_SC_CAPTURE:
        capture = virtualScreen->getReadBuffer();
        capture->saveFile(TString(TEXT("capture")) + TString(capNo++) + TString(TEXT(".bmp")));
        virtualScreen->DoneReading();
        break;
    case IDM_SC_ACTIVATE:
        if( !doCapture ){
            ModifyMenu(GetMenu(hWnd), IDM_SC_ACTIVATE, MF_BYCOMMAND | MF_CHECKED, 
                IDM_SC_ACTIVATE, TEXT("Auto Capture"));
            doCapture = true;
            if( updater != NULL )
                updater->enableCapture();
        } else {
            ModifyMenu(GetMenu(hWnd), IDM_SC_ACTIVATE, MF_BYCOMMAND | MF_UNCHECKED, 
                IDM_SC_ACTIVATE, TEXT("Auto Capture"));
            doCapture = false;
            if( updater != NULL )
                updater->disableCapture();
        }
        break;
    case IDM_DISCONNECT:
        SetWindowText( hWnd, (LPCWSTR)titleBarText 
                + TString(TEXT(" - Disconnected")) );

        EnableMenuItem(
            GetMenu(hWnd),
            IDM_DISCONNECT,
            MF_GRAYED);
        EnableMenuItem(
            GetMenu(hWnd),
            IDM_CONNECT,
            MF_ENABLED);
        EnableMenuItem(
            GetMenu(hWnd),
            IDM_SC_OPTIONS,
            MF_ENABLED);
        
        // Try to stop updater nicely
        updater->stop(false);
        // Force it to stop
        delete updater;
        updater = NULL;

        delete mouseServer;     // forces disconnect
        mouseServer = NULL;
        delete screenServer;
        screenServer = NULL;

        break;
    case IDM_CONNECT:
        if( DialogBox(hInst, (LPCTSTR)IDD_NAME, hWnd, (DLGPROC)Name) == IDOK ){
            SetWindowText( hWnd, (LPCWSTR)titleBarText 
                    + TString(TEXT(" - ")) + clientName + TString(TEXT(" - Connecting...")) );

            if( DialogBox(hInst, (LPCTSTR)IDD_CONNECT, hWnd, (DLGPROC)Connect) == IDOK ){
                SetWindowText( hWnd, (LPCWSTR)titleBarText 
                        + TString(TEXT(" - ")) + clientName + TString(TEXT(" - Connected")) );

                EnableMenuItem(
                    GetMenu(hWnd),
                    IDM_CONNECT,
                    MF_GRAYED);
                EnableMenuItem(
                    GetMenu(hWnd),
                    IDM_DISCONNECT,
                    MF_ENABLED);
                EnableMenuItem(
                    GetMenu(hWnd),
                    IDM_SC_OPTIONS,
                    MF_GRAYED);

                updater = new UpdateHandler(*screenServer, *virtualScreen, hWnd);
                if( doCapture ){
                    updater->setCaptureName(captureName);
                    updater->setCaptureFrequency(captureFrequency);
                    updater->setCaptureLimit(captureLimit);
                    updater->enableCapture();
                }
                assert( updater->run() );
            } else {
                SetWindowText( hWnd, (LPCWSTR)titleBarText 
                        + TString(TEXT(" - Disconnected")) );
            }
        }
        break;
    case IDM_EXIT:
        DestroyWindow(hWnd);
        break;
    default:
        FORWARD_WM_COMMAND(hWnd, id, hWndCtl, codeNotify, DefWindowProc);
    }
}

// Window Message handling functions

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
        HANDLE_MSG(hWnd, WM_CREATE, Cls_OnCreate);
        HANDLE_MSG(hWnd, WM_COMMAND, Cls_OnCommand);
        HANDLE_MSG(hWnd, WM_LBUTTONDOWN, Cls_OnLButtonDown);
        HANDLE_MSG(hWnd, WM_LBUTTONUP, Cls_OnLButtonUp);
        HANDLE_MSG(hWnd, WM_ERASEBKGND, Cls_OnEraseBkgnd);
        HANDLE_MSG(hWnd, WM_PAINT, Cls_OnPaint);
        HANDLE_MSG(hWnd, WM_DESTROY,  Cls_OnDestroy);
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
   }
}

LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message){
        case WM_INITDIALOG:
            return true;
        case WM_COMMAND:
            if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
                EndDialog(hDlg, LOWORD(wParam));
                return true;
            }
            break;
    }
    return false;
}

LRESULT CALLBACK Options(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    TCHAR temp[200];
    int tempInt;

    switch (message){
        case WM_INITDIALOG:
            SetDlgItemText(hDlg, IDC_FILENAME, captureName );
            SetDlgItemText(hDlg, IDC_FREQUENCY_VALUE, TString(captureFrequency));
            if( captureLimit != 0 ){
                SetDlgItemText(hDlg, IDC_LIMIT_VALUE, TString(captureLimit));
                CheckDlgButton(hDlg, IDC_LIMIT_CHECK, BST_CHECKED);
            } else {
                SetDlgItemText(hDlg, IDC_LIMIT_VALUE, TEXT(""));
                CheckDlgButton(hDlg, IDC_LIMIT_CHECK, BST_UNCHECKED);
            }

            return true;
        case WM_COMMAND:
            switch(wParam){
                case IDOK:
                case IDAPPLY:
                    GetDlgItemText(hDlg, IDC_FILENAME, temp, 200);
                    captureName = temp;

                    GetDlgItemText(hDlg, IDC_FREQUENCY_VALUE, temp, 200);
                    swscanf(temp, L"%d", &tempInt);
                    if( tempInt > 0 )
                        captureFrequency = tempInt;

                    if( BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_LIMIT_CHECK) ){
                        GetDlgItemText(hDlg, IDC_LIMIT_VALUE, temp, 200);
                        swscanf(temp, L"%d", &tempInt);
                        if( tempInt > 0 ){
                            captureLimit = tempInt;
                        } else {
                            captureLimit = 0;
                        }
                    }
                    if( wParam == IDAPPLY){
                        SetDlgItemText(hDlg, IDC_FILENAME, captureName );
                        SetDlgItemText(hDlg, IDC_FREQUENCY_VALUE, TString(captureFrequency));
                        if( captureLimit != 0 ){
                            SetDlgItemText(hDlg, IDC_LIMIT_VALUE, TString(captureLimit));
                            CheckDlgButton(hDlg, IDC_LIMIT_CHECK, BST_CHECKED);
                        } else {
                            SetDlgItemText(hDlg, IDC_LIMIT_VALUE, TEXT(""));
                            CheckDlgButton(hDlg, IDC_LIMIT_CHECK, BST_UNCHECKED);
                        }
                        return true;
                    }
                case IDCANCEL:
                    EndDialog(hDlg, LOWORD(wParam));
                    return true;
            }
            break;
    }
    return false;
}

LRESULT CALLBACK Name(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    TCHAR temp[241];

    switch (message){
        case WM_INITDIALOG:
            SetDlgItemText(hDlg, IDC_CLIENT_NAME, clientName );
            return true;
        case WM_COMMAND:
            switch(wParam){
                case IDOK:
                    GetDlgItemText(hDlg, IDC_CLIENT_NAME, temp, 240);
                    clientName = temp;
                case IDCANCEL:
                    EndDialog(hDlg, LOWORD(wParam));
                    return true;
            }
            break;
    }
    return false;
}

VOID WINAPI waitForMouse(PVOID param, bool)
{
    HWND hDlg = (HWND) param;

    CheckDlgButton(hDlg, IDC_MOUSE_OUT, BST_CHECKED);
    
    SendNotifyMessage(hDlg, WM_COMMAND, IDOK, 1);
}

VOID WINAPI waitForScreen(PVOID param, bool)
{
    HWND hDlg = (HWND) param;

    CheckDlgButton(hDlg, IDC_SCRNBUFF_IN, BST_CHECKED);
    
    SendNotifyMessage(hDlg, WM_COMMAND, IDOK, 2);
}



WaitCallback* mouseWait;    
WaitCallback* screenWait;   

LRESULT CALLBACK Connect(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message){
        case WM_INITDIALOG:
            mouseServer = new MousePipe( clientName );
            screenServer = new ScreenPipe( clientName );

            if( !(mouseServer->serve() && screenServer->serve()) ){
                delete mouseServer;
                mouseServer = NULL;
                delete screenServer;
                screenServer = NULL;

                MessageBox(
                    hDlg, 
                    TEXT("Failed to serve pipes.\nCheck for another client with the same name.\n"),
                    TEXT("Can't connect"), 
                    MB_OK);
                EndDialog(hDlg, LOWORD(wParam));
                return true;
            }

            mouseWait = new WaitCallback;
            screenWait = new WaitCallback;
    
            assert(mouseWait->registerWaitForSingleObject(
                mouseServer->getConnectedEventHandle(),
                &waitForMouse,
                hDlg,
                INFINITE,
                true));
                        
            assert(screenWait->registerWaitForSingleObject(
                screenServer->getConnectedEventHandle(),
                &waitForScreen,
                hDlg,
                INFINITE,
                true));

            return true;
            break;
        case WM_COMMAND:
            switch(wParam){
                case IDCANCEL:
                    mouseWait->unregisterWait();
                    screenWait->unregisterWait();
                    delete mouseWait;
                    delete screenWait;

                    delete mouseServer;
                    mouseServer = NULL;
                    delete screenServer;
                    screenServer = NULL;
                case IDOK:
                    switch(lParam){
                        case 2:
                            screenWait->unregisterWait();
                            delete screenWait;
                            screenWait = NULL;
                            if( mouseWait != NULL )
                                return true;
                            break;
                        case 1:
                            mouseWait->unregisterWait();
                            delete mouseWait;
                            mouseWait = NULL;
                            if( screenWait != NULL )
                                return true;
                            break;
                        default:
                            break;
                    }
                    EndDialog(hDlg, LOWORD(wParam));
                    return true;
            }
            break;
    }
    return false;
}

---