Konsolen-Klasse(2)

[N00Bie]

so, findet jemand Fehler??

#define CONSOLE_HPP

#ifndef _WINDOWS_H
    #include <windows.h>
#endif

class CHANDLE
{
    public:
    CHANDLE ();
    CHANDLE (const CHANDLE & rhs);
    ~CHANDLE ();

    unsigned int itsNumber; 
    HANDLE itsHandle;
    LPDWORD itslpNumberOfCharsWritten;
    LPDWORD itslpNumberOfCharsRead;
};

CHANDLE::CHANDLE ()
{
    itslpNumberOfCharsWritten = new DWORD(0);
    itslpNumberOfCharsRead = new DWORD(0);
}

CHANDLE::CHANDLE (const CHANDLE & rhs)
{
    itsHandle = rhs.itsHandle;
    itslpNumberOfCharsWritten = new DWORD(*(rhs.itslpNumberOfCharsWritten));
    itslpNumberOfCharsRead = new DWORD(*(rhs.itslpNumberOfCharsRead));
}

CHANDLE::~CHANDLE ()
{
    CloseHandle (itsHandle);
    delete itslpNumberOfCharsWritten;
    delete itslpNumberOfCharsRead;
}

class CONSOLE
{
    public:
    CONSOLE();
    ~CONSOLE();

    int CreateScreenBuffer (DWORD, DWORD);
    bool CloseScreenBuffer (unsigned int);
    bool FlushInputBuffer ();
    void FullScreen ();

    bool SetActiveScreenBuffer (unsigned int);
    bool SetCursorPosition (COORD);
    bool SetCursorPosition (unsigned int, unsigned int);
    bool SetCursorInfo (CONSOLE_CURSOR_INFO *);
    bool SetCursorInfo (DWORD, BOOL);
    bool SetTextAttribute (WORD);
    bool SetTitle (char *);

    bool ClearScreen();

    bool Write (char *);
    bool Write (char *, DWORD);

    bool Read (char *, unsigned int);

    bool GetStatus () const { return itsStatus; }

    private:
    bool itsStatus;
    unsigned int bufferCounter;
    CHANDLE * itsCurrentScreenBuffer;
    CHANDLE * itsBufferArray;

};

CONSOLE::CONSOLE():
bufferCounter(0)
{
    itsStatus = AllocConsole ();
}

CONSOLE::~CONSOLE()
{
    if (itsBufferArray == 0)
        delete [] itsBufferArray;

    FreeConsole();
}

int CONSOLE::CreateScreenBuffer (DWORD dwDesiredAccess,
                                 DWORD dwShareMode)
{
    if (bufferCounter < 0)
    {
        return -1;
    }

    if (bufferCounter == 0)
    {
        itsBufferArray = new CHANDLE[1];
        itsBufferArray[0].itsHandle = CreateConsoleScreenBuffer (
                                            dwDesiredAccess,
                                            dwShareMode,
                                            NULL,
                                            CONSOLE_TEXTMODE_BUFFER,
                                            NULL);

        if (itsBufferArray[0].itsHandle == INVALID_HANDLE_VALUE)
            return -1;

        itsCurrentScreenBuffer = &(itsBufferArray[0]);
        ++bufferCounter;
        itsCurrentScreenBuffer->itsNumber = bufferCounter;

        return itsCurrentScreenBuffer->itsNumber;
    }

    if (bufferCounter > 0)
    {
        unsigned int highestNumber = 0;
        unsigned int theNumber = 0;

        for (unsigned int i=0; i<bufferCounter; i++)
        {
            if (itsBufferArray[i].itsNumber > highestNumber)
                highestNumber = itsBufferArray[i].itsNumber;
        }

        for (unsigned int i=0; i<highestNumber; i++)
        {
            for (unsigned int j=0; j < bufferCounter; j++)
            {
                if (itsBufferArray[j].itsNumber != i)
                {
                    theNumber = i;
                    break;
                }
            }

            if (theNumber != 0)
                break;
        }

        CHANDLE * temp = itsBufferArray;
        itsBufferArray = 0;
        itsBufferArray = new CHANDLE[bufferCounter+1];

        for (unsigned int i=0; i<bufferCounter; i++)
        {        
            itsBufferArray[i] = temp[i];
        }

        itsBufferArray[bufferCounter].itsHandle = CreateConsoleScreenBuffer (
                                                        dwDesiredAccess,
                                                        dwShareMode,
                                                        NULL,
                                                        CONSOLE_TEXTMODE_BUFFER,
                                                        NULL);

        if (itsBufferArray[bufferCounter].itsHandle == INVALID_HANDLE_VALUE)
            return -1;

        ++bufferCounter;
        itsBufferArray[bufferCounter-1].itsNumber = theNumber;

        return itsBufferArray[bufferCounter-1].itsNumber;
    }
    return -1;
}

bool CONSOLE::CloseScreenBuffer (unsigned int bufferToClose)
{
    if (bufferCounter <= 0)
    {
        return false;
    }

    for (unsigned int i=0; i < bufferCounter; i++)
    {
        if (itsBufferArray[i].itsNumber == bufferToClose)
        {
            break;
        }
        if (i == bufferCounter - 1 && 
            itsBufferArray[i].itsNumber != bufferToClose)
        {
            return  false;
        }
    }

    if (itsCurrentScreenBuffer->itsNumber == bufferToClose)
    {
        itsCurrentScreenBuffer = 0;
    }

    if (bufferCounter == 1 && itsBufferArray[0].itsNumber == bufferToClose)
    {
        delete [] itsBufferArray;
        itsBufferArray = 0;
        return true;
    }    
    if (bufferCounter > 1)
    {   

        CHANDLE * temp = itsBufferArray;
        itsBufferArray = 0;
        itsBufferArray = new CHANDLE[bufferCounter - 1];    

        for (unsigned int i=0, j=0; i<bufferCounter; i++, j++)
        {        
            if (temp[i].itsNumber != bufferToClose)
            {
                itsBufferArray[j] = temp[i];
            }
            else
            {
                CloseHandle (temp[i].itsHandle); 
                --j;
            }
            if (itsCurrentScreenBuffer == &(temp[i]))
            {
                itsCurrentScreenBuffer = &(itsBufferArray[j]);
            }
        }

        --bufferCounter;
        delete [] temp;
        temp = 0;
        return true;
    }

    return false;
}

bool CONSOLE::FlushInputBuffer()
{
    return FlushConsoleInputBuffer (itsCurrentScreenBuffer->itsHandle);
}

void CONSOLE::FullScreen ()
{
    keybd_event ( VK_MENU , 0x38 , 0 , 0 );
    keybd_event ( VK_RETURN , 0x1c , 0 , 0 );
    keybd_event ( VK_RETURN , 0x1c , KEYEVENTF_KEYUP , 0 );
    keybd_event ( VK_MENU , 0x38 , KEYEVENTF_KEYUP , 0 );
}

bool CONSOLE::SetActiveScreenBuffer(unsigned int bufferToActivate)
{
    for (int i=0; i < bufferCounter; i++)
    {   
        if (itsBufferArray[i].itsNumber == bufferToActivate)
        {
            itsCurrentScreenBuffer = &(itsBufferArray[i]);
            break;
        }
        if (itsBufferArray[i].itsNumber == bufferToActivate && 
            i == bufferCounter - 1)
        {
            return false;
        }
    }    

    return SetConsoleActiveScreenBuffer(itsCurrentScreenBuffer->itsHandle);
}

bool CONSOLE::SetCursorPosition (COORD c)
{
    return SetConsoleCursorPosition (itsCurrentScreenBuffer->itsHandle, c);
}

bool CONSOLE::SetCursorPosition (unsigned int x, unsigned int y)
{
    COORD c;
    c.X = x;
    c.Y = y;

    return SetConsoleCursorPosition (itsCurrentScreenBuffer->itsHandle, c);
}

bool CONSOLE::SetCursorInfo (CONSOLE_CURSOR_INFO * lpConsoleCursorInfo)
{
    return SetConsoleCursorInfo (itsCurrentScreenBuffer->itsHandle,
                                     lpConsoleCursorInfo);
}

bool CONSOLE::SetCursorInfo (DWORD dwSize, BOOL bVisible)
{
    CONSOLE_CURSOR_INFO c;
    c.dwSize = dwSize;
    c.bVisible = bVisible;

    return SetConsoleCursorInfo (itsCurrentScreenBuffer->itsHandle, &c);
}

bool CONSOLE::SetTextAttribute (WORD wAttributes)
{
    return SetConsoleTextAttribute (itsCurrentScreenBuffer->itsHandle,
                                         wAttributes);
}

bool CONSOLE::SetTitle(char * pArray)
{
    return SetConsoleTitle (pArray);
}

bool CONSOLE::ClearScreen()
{

    char ch = ' ';
    COORD c;
    c.X = 0;
    c.Y = 0;

    return FillConsoleOutputCharacter (itsCurrentScreenBuffer->itsHandle,
                                            ch,
                                            1840,
                                            c,
                            itsCurrentScreenBuffer->itslpNumberOfCharsWritten);
}

bool CONSOLE::Write (char * pArray)
{
    return WriteConsole (itsCurrentScreenBuffer->itsHandle,
                              pArray,
                              strlen(pArray),
                              itsCurrentScreenBuffer->itslpNumberOfCharsWritten,
                              NULL);
}

bool CONSOLE::Write (char * pArray, DWORD nNumberOfCharsToWrite)
{
    return WriteConsole (itsCurrentScreenBuffer->itsHandle,
                              pArray,
                              nNumberOfCharsToWrite,
                              itsCurrentScreenBuffer->itslpNumberOfCharsWritten,
                              NULL);
}

bool CONSOLE::Read (char * cArray, unsigned int x)
{
    delete cArray;
    cArray = new char(x);

    return ReadConsole (itsCurrentScreenBuffer->itsHandle,
                             cArray,
                             x,
                             itsCurrentScreenBuffer->itslpNumberOfCharsRead,
                             NULL);
}

[SideWinder]

Schön und Gut nur den Sinn hab ich nicht verstanden :D. Ist das so eine Art erweiterte Improved Console?

MfG SideWinder

[N00Bie]

eigentlich hab ich nur die die Konsole betreffenden Befehle der WinApi in ne Klasse gepackt. sind fehler drin (bios auf dass noch befehle fehlen)?

[donpasquale]

ich habe die klasse grade eingebunden und wollte mal damit etwas arbeiten.

Bin noch relativ neu in c++,

kannst du mir vielleicht ein beispiel geben wie ich in der console schreibe und das geschriebene dann ausführe? wäre sauper,

danke

Pascal