---

UpdateHandler.cpp

Go to the documentation of this file.

// UpdateHandler.cpp: implementation of the UpdateHandler class.


#include "stdafx.h"
#include "UpdateHandler.h"

// Construction/Destruction

UpdateHandler::UpdateHandler(ScreenPipe &s, BitmapScreen& b, HWND h)
:hWnd(h)
{
    pipe = &s;
    screen = &b;
    hUpdateThread = NULL;

    captureName = TEXT("ScreenCap_");
    captureEvery = 1;
    captureLimit = 50;
    capture = false;

    captureMutex = CreateMutex(NULL, false, NULL);
}

UpdateHandler::~UpdateHandler()
{
    stop(true);
    CloseHandle(captureMutex);
    CloseHandle(hUpdateThread);
}

// Member Functions

bool UpdateHandler::run()
{
    DWORD exitCode;
    GetExitCodeThread(hUpdateThread, &exitCode);

    if( exitCode == STILL_ACTIVE )
        return true;

    exit = false;

    CloseHandle(hUpdateThread);

    hUpdateThread = chBEGINTHREADEX(
        NULL,           // Default Security, non inheritable
        0,              // use default stack size  
        &update,        // thread function
        this,           // thread argument
        0,              // use default creation flags 
        NULL);          // don't need thread identifier
    
    if(hUpdateThread == NULL){
        return false;
    }

    return true;
}

void UpdateHandler::stop(const bool force)
{
    exit = true;    // Signal thread to stop

    DWORD exitCode;
    GetExitCodeThread(hUpdateThread, &exitCode);

    // If still active after a second terminate the thread
    if( force && exitCode == STILL_ACTIVE ){
        if( WaitForSingleObject(hUpdateThread, 1000) == WAIT_TIMEOUT )
            TerminateThread(hUpdateThread, 0);
    }

}

DWORD WINAPI UpdateHandler::update(LPVOID param)
{
    UpdateHandler* update = (UpdateHandler*) param;

    WaitForSingleObject(update->captureMutex, INFINITE);

    if( !(!update->captureDir) ){ // not empty
        if( !SetCurrentDirectory(update->captureDir) )
            update->capture = false;
    }

    if( !update->captureName ){ // is empty
        update->capture = false;
    }
    
    int screenNum = -1;  // screenNo incremented before use
    int captureNum = 1;
    bool success;
    ULARGE_INTEGER freeBytes, notNeeded;

    DIBitmap *writeBuffer;
    const DIBitmap *readBuffer;

    DWORD readResult;
    while(!update->exit){

        writeBuffer = update->screen->getWriteBuffer();
        
        readResult = update->pipe->readToDIB(*writeBuffer);

        update->screen->DoneWriting();

        switch(readResult){
            case SP_SUCCESS:
                break;
            case SP_UNKNOWN_ERROR:
            case SP_ERROR_CREATING_BITMAP:
            case SP_NOT_CONNECTED:
            case SP_INVALID_DATA:
            default:
                return false;   // Abandons mutex
        }

        update->screen->invalidate(update->hWnd);
        
        // restart loop if signaled to exit
        if(update->exit)
            continue;
        
        screenNum++;

        // Check that we wish to capture this screen
        if( !update->capture || !((screenNum % update->captureEvery) == 0) )
            continue;
        
        // Check we haven't reached capture limit;
        if( update->captureLimit != 0 && captureNum > update->captureLimit ){
            update->capture = false;
            continue;
        }

        readBuffer = update->screen->getReadBuffer();

        // Write buffer to disk   
        success = readBuffer->saveFile(
            update->captureName + TString(screenNum) + TString(TEXT(".bmp")) ); 
        
        update->screen->DoneReading();

        captureNum++;

        if( !success ){
            GetDiskFreeSpaceEx(NULL, &freeBytes, &notNeeded, NULL);
            if(freeBytes.QuadPart < 1024 * 1024){ // less than a megabyte
                update->capture = false; // Stop capturing
            }
        }

    }

    ReleaseMutex(update->captureMutex);

    return true;
}

bool UpdateHandler::setCapture(
            const TString &name, 
            const TString &directory, 
            const int limit, 
            const int frequency)
{
    bool success = false;

    switch(WaitForSingleObject(captureMutex, 0) ) {
    case  WAIT_OBJECT_0:
        captureName = name;
        captureDir = directory;
        captureLimit = limit;
        captureEvery = frequency;
        success = true;
    case WAIT_ABANDONED:
        ReleaseMutex(captureMutex);
        break;
    default:
        break;
    }

    return success;
}

bool UpdateHandler::setCaptureName(const TString &name)
{
    bool success = false;

    switch(WaitForSingleObject(captureMutex, 0) ) {
    case  WAIT_OBJECT_0:
        captureName = name;
        success = true;
    case WAIT_ABANDONED:
        ReleaseMutex(captureMutex);
        break;
    default:
        break;
    }

    return success;
}

bool UpdateHandler::setCaptureDir(const TString &directory)
{
    bool success = false;

    switch(WaitForSingleObject(captureMutex, 0) ) {
    case  WAIT_OBJECT_0:
        captureDir = directory;
        success = true;
    case WAIT_ABANDONED:
        ReleaseMutex(captureMutex);
        break;
    default:
        break;
    }

    return success;
}

bool UpdateHandler::setCaptureLimit(const int limit)
{
    bool success = false;

    switch(WaitForSingleObject(captureMutex, 0) ) {
    case  WAIT_OBJECT_0:
        captureLimit = limit;
        success = true;
    case WAIT_ABANDONED:
        ReleaseMutex(captureMutex);
        break;
    default:
        break;
    }

    return success;
}

bool UpdateHandler::setCaptureFrequency(const int frequency)
{
    bool success = false;

    switch(WaitForSingleObject(captureMutex, 0) ) {
    case  WAIT_OBJECT_0:
        captureEvery = frequency;
        success = true;
    case WAIT_ABANDONED:
        ReleaseMutex(captureMutex);
        break;
    default:
        break;
    }

    return success;
}

void UpdateHandler::disableCapture()
{
    capture = false;
}

bool UpdateHandler::enableCapture()
{
    if( !(!captureDir) ){ // not empty
        if ( SetCurrentDirectory(captureDir) ){
            capture = true;
        }
    } else {
        capture = true;
    }
    return capture;
}

---