D:/Zythum/DinoKod/Common/Console.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : Console.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 07/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "Common/Console.h"

#include <richedit.h>

#define WINDOW_CLASSNAME        "DinoConsoleWindow"

KConsole                g_Console;

//---------------------------------------------------------------------------------------------------------------------
KConsole::KConsole()
{
        m_hConsole              = 0;
        m_hLogFile              = 0;
        m_hParent               = NULL;
        m_CurrentType   = KCMT_NORMAL;

        m_bGraphic              = false;
        m_hWnd                  = NULL;
        m_hEdit                 = NULL;

        m_bNewLine              = true;

        m_hModuleRichEdit        = NULL;
}

//---------------------------------------------------------------------------------------------------------------------
bool KConsole::Create( char* pName, bool bGraphic, HINSTANCE hInstance, HWND hFather, bool bCreateWindow )
{
        m_bGraphic      = bGraphic;
        m_hParent       = hFather;

        if( m_bGraphic )
        {
                // Console Graphique
                if( !CreateGraphic( hInstance, hFather, bCreateWindow ) )
                        return false;
        }
        else
        {
                // Console Texte
                AllocConsole();
                
                m_hConsole = CreateFile( "CONOUT$",
                                        GENERIC_READ | GENERIC_WRITE,
                                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                                        NULL,
                                        OPEN_EXISTING,
                                        0,
                                        NULL );
/*              m_hConsole = CreateConsoleScreenBuffer( GENERIC_WRITE,
                                                                                                FILE_SHARE_WRITE,
                                                                                                NULL,
                                                                                                CONSOLE_TEXTMODE_BUFFER,
                                                                                                NULL );

                SetConsoleActiveScreenBuffer( m_hConsole );
*/
                if ( m_hConsole == INVALID_HANDLE_VALUE )
                        return false;
        }

        //
        //      fichier .log
        //
        char    pFileName[1024];

        sprintf( pFileName, "%s.log", pName ? pName : "Console" );

        m_hLogFile = CreateFile(        pFileName,
                                                                GENERIC_WRITE,
                                                                FILE_SHARE_READ,
                                                                NULL,
                                                                CREATE_ALWAYS,
                                                                FILE_ATTRIBUTE_NORMAL,
                                                                NULL );
                                                                
        if ( m_hLogFile == INVALID_HANDLE_VALUE )
                return false;

        // Titre
        if( pName )
                SetTitle( pName );

        *this << "Console V1.0 - Build : " << __DATE__ << KENDL;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::SetTitle( char* pTitle )
{
        SetConsoleTitle( pTitle );
}
/*
//---------------------------------------------------------------------------------------------------------------------
void KConsole::Error( const char* text, ... )
{
        LPVOID  lpMsgBuf = NULL;
        char    buf[1024];
        char    buf2[1024];
        va_list arg_ptr;

        va_start(arg_ptr, text);
        wvsprintf(buf, text, arg_ptr);

        FormatMessage(  FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                                        FORMAT_MESSAGE_FROM_SYSTEM | 
                                        FORMAT_MESSAGE_IGNORE_INSERTS,
                                        NULL,
                                        GetLastError(),
                                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                        (LPTSTR) &lpMsgBuf,
                                        0,
                                        NULL );

        if ( lpMsgBuf )
                wsprintf( buf2, "%s\n%s", buf, lpMsgBuf );
        else
                strcpy(buf2, buf);

        Printf( "%s", buf2 );
//      MessageBox( NULL, buf2, "Error", MB_OK | MB_ICONINFORMATION );

        LocalFree( lpMsgBuf );


}
*/
//---------------------------------------------------------------------------------------------------------------------
bool KConsole::Close()
{
        if( m_hModuleRichEdit )
        {
                FreeLibrary( m_hModuleRichEdit );
                m_hModuleRichEdit = NULL;
        }

        CloseHandle( m_hConsole );
        CloseHandle( m_hLogFile );

        if ( !FreeConsole() )
                return false;

        m_hConsole = NULL;
        m_hLogFile = NULL;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::SetTextAttribut( s16 Attribut )
{
        SetConsoleTextAttribute( m_hConsole, Attribut );
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::SetCursorPos( u16 x, u16 y )
{
        COORD   Pos;

        Pos.X = x;
        Pos.Y = y;
        SetConsoleCursorPosition( m_hConsole, Pos );    
}

//---------------------------------------------------------------------------------------------------------------------
KPt KConsole::GetCursorPos()
{
        CONSOLE_SCREEN_BUFFER_INFO              ConsoleScreenBufferInfo;
        GetConsoleScreenBufferInfo( m_hConsole, &ConsoleScreenBufferInfo );

        return KPt( ConsoleScreenBufferInfo.dwCursorPosition.X, ConsoleScreenBufferInfo.dwCursorPosition.Y );
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::Printf( u16 x, u16 y, u16 Attribut, const char *text, ...)
{
        CONSOLE_SCREEN_BUFFER_INFO              ConsoleScreenBufferInfo;

        GetConsoleScreenBufferInfo( m_hConsole, &ConsoleScreenBufferInfo );
        
        SetCursorPos( x, y );
        SetTextAttribut( Attribut );
        
        DWORD   Length;
        char    buf[1024];
        va_list arg_ptr;

        if( !m_hConsole )
                return;

        char    pSpace[81];
        strcpy( pSpace, "                                                                                " );

        va_start(arg_ptr, text);
        wvsprintf(buf, text, arg_ptr);
        strcat( buf, &pSpace[MIN(strlen(buf),80)] );

        WriteFile(      m_hConsole,
                                buf,
                                (DWORD)strlen( buf ),
                                &Length,
                                NULL );

        SetCursorPos( ConsoleScreenBufferInfo.dwCursorPosition.X, ConsoleScreenBufferInfo.dwCursorPosition.Y );
        SetTextAttribut( ConsoleScreenBufferInfo.wAttributes );
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::Printf(const char *text, ...)
{
        char    pBuffer[1024];
        va_list arg_ptr;

        va_start( arg_ptr, text );
        wvsprintf( pBuffer, text, arg_ptr );
        strcat( pBuffer,"\n");

        Write( pBuffer );
}

//---------------------------------------------------------------------------------------------------------------------
KConsole& KConsole::operator <<( KStr sString )
{
        if( sString == KStr( KENDL ) )
                m_CurrentType = KCMT_NORMAL;

        Write( sString.GetpString(), m_CurrentType );

        return *this;
}

//---------------------------------------------------------------------------------------------------------------------
KConsole& KConsole::operator <<( int Value )
{
        char    pBuffer[256];

        sprintf( pBuffer, "%i", Value );
        Write( pBuffer, m_CurrentType );

        return *this;
}

//---------------------------------------------------------------------------------------------------------------------
KConsole& KConsole::operator <<( unsigned int Value )
{
        char    pBuffer[256];

        sprintf( pBuffer, "%i", Value );
        Write( pBuffer, m_CurrentType );

        return *this;
}

//---------------------------------------------------------------------------------------------------------------------
KConsole& KConsole::operator <<( float Value )
{
        char    pBuffer[256];

        sprintf( pBuffer, "%.3f", Value );
        Write( pBuffer, m_CurrentType );

        return *this;
}

//---------------------------------------------------------------------------------------------------------------------
KConsole& KConsole::operator <<( KCMESSAGETYPE Type )
{
        m_CurrentType = Type;
        
        return *this;
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::Write( char* pString, KCMESSAGETYPE Type )
{
        DWORD   Length;
        
        char*   pNewString = NULL;

        // Rajoute la date
        if( m_bNewLine )
        {
                struct tm* newtime;
                __time64_t long_time;

                _time64( &long_time );
                newtime = _localtime64( &long_time );

                char    pBufferDate[256];
                sprintf( pBufferDate, "%.2i\\%.2i\\%.4i %.2i:%.2i:%.2i> ", newtime->tm_mday, 1 + newtime->tm_mon, 1900 + newtime->tm_year, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );

                s32 Size = (s32)strlen( pBufferDate ) + (s32)strlen( pString ) + 1;
                pNewString = (char*)malloc( Size );
                strcpy( pNewString, pBufferDate );
                strcat( pNewString, pString );

                pString = pNewString;

                m_bNewLine = false;
        }

        // Affiche la date la prochaine fois
        if( !strcmp( pString, KENDL ) )
        {
                m_bNewLine = true;
        }

        // Display
        if( m_bGraphic )
        {
                CHARFORMAT      Format;
                memset( &Format, 0, sizeof( Format ) );
                Format.cbSize           = sizeof( Format );
                Format.dwMask           = CFM_COLOR | CFM_SIZE | CFM_FACE;
                Format.yHeight          = 170;
                strcpy( Format.szFaceName, "Tahoma" );

                switch( Type )
                {
                case KCMT_NORMAL:
                        Format.crTextColor      = RGB( 255, 255, 255 );
                        break;
                case KCMT_WARNING:
                        Format.crTextColor      = RGB( 255, 200, 0 );
                        break;
                case KCMT_ERROR:
                        Format.crTextColor      = RGB( 255, 0, 0 );
                        break;
                }
/*
                int     Size = (int)SendMessage( m_hEdit, WM_GETTEXTLENGTH, 0, 0 );
                char* pText = new char[Size+strlen(pString)+1];
                
                SendMessage( m_hEdit, WM_GETTEXT, Size + 1, (LPARAM)pText );
                strcat( pText, pString );
                SendMessage( m_hEdit, WM_SETTEXT, 0, (LPARAM)pText );
                
                Deletep( pText );
*/
                int     Size = (int)SendMessage( m_hEdit, WM_GETTEXTLENGTH, 0, 0 );
                SendMessage( m_hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM)-1 );
                SendMessage( m_hEdit, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&Format );
                SendMessage( m_hEdit, EM_REPLACESEL, (WPARAM)FALSE, (LPARAM)pString );
                SendMessage( m_hEdit, EM_SCROLL, SB_PAGEDOWN, 0 );
                

/*              SendMessage( m_hEdit, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&Format );
                SendMessage( m_hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM)-1 );
                SendMessage( m_hEdit, EM_REPLACESEL, (WPARAM)FALSE, (LPARAM)pString );*/
        }
        else
        {
                if( m_hConsole )
                        WriteFile(      m_hConsole,
                                                pString,
                                                (DWORD)strlen( pString ),
                                                &Length,
                                                NULL );
        }

        if( m_hLogFile )
                WriteFile(      m_hLogFile,
                                        pString,
                                        (DWORD)strlen( pString ),
                                        &Length,
                                        NULL );
    
        KOutputConsole* pConsole;
        
        for( pConsole = m_OutputConsole.GetFirst(); pConsole; pConsole = m_OutputConsole.GetNext( pConsole ) )
        {
                pConsole->Write( pString );
        }

        SafeFreep( pNewString );
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::RegisterConsole( KOutputConsole* pConsole )
{
        m_OutputConsole.Add( pConsole );
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::UnregisterConsole( KOutputConsole* pConsole )
{
        m_OutputConsole.Remove( pConsole );
}

//---------------------------------------------------------------------------------------------------------------------
bool KConsole::CreateGraphic( HINSTANCE hInstance, HWND hFather, bool bCreateWindow )
{
        HWND    hEditFather = NULL;

        if( bCreateWindow )
        {
                //
                // Creation de la fenetre
                //
                WNDCLASS        WndClass;

                memset( &WndClass, 0, sizeof( WndClass ) );
                WndClass.style                  = CS_HREDRAW | CS_VREDRAW;
                WndClass.lpfnWndProc    = WindowProc;
                WndClass.hInstance              = hInstance;
                WndClass.hIcon                  = NULL;//LoadIcon( m_hInstance, MAKEINTRESOURCE(IDI_ICON_APP));
                WndClass.hCursor                = NULL;
                WndClass.hbrBackground  = (HBRUSH)GetStockObject(BLACK_BRUSH);
                WndClass.lpszMenuName   = NULL;
                WndClass.lpszClassName  = WINDOW_CLASSNAME;

                if( !RegisterClass( &WndClass ) )
                        return false;

                RECT    Rect = { 0, 0, 400, 300 };

                if( hFather )
                {
                        GetWindowRect( hFather, &Rect );
                        Rect.left       = Rect.right;
                        Rect.right      = Rect.left + 400;
                        Rect.bottom     = Rect.top + 300;
                }

                DWORD   Style = /*WS_CAPTION | */WS_SYSMENU | WS_SIZEBOX | WS_MINIMIZEBOX;// | WS_POPUP;// | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
                m_hWnd = CreateWindowEx(        WS_EX_APPWINDOW,//WS_EX_TOOLWINDOW,
                                                                        WINDOW_CLASSNAME,
                                                                        "Console",
                                                                        Style,
                                                                        Rect.left,
                                                                        Rect.top,
                                                                        Rect.right - Rect.left,
                                                                        Rect.bottom - Rect.top,
                                                                        hFather,
                                                                        NULL,
                                                                        hInstance,
                                                                        NULL );

                if ( !m_hWnd )
                        return false;

                ShowWindow( m_hWnd, SW_NORMAL );

                hEditFather = m_hWnd;
        }
        else
        {
                hEditFather = hFather;
        }

        //
        // Creation de l'édit
        //
        m_hModuleRichEdit = LoadLibrary( "RICHED20.DLL" );
        if( !m_hModuleRichEdit )
                return false;

        m_hEdit = CreateWindowEx(       WS_EX_STATICEDGE,
                                                                RICHEDIT_CLASS,
                                                                NULL,
                                                                WS_CHILD | //WS_BORDER |
                                                                WS_HSCROLL | WS_VSCROLL | ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_MULTILINE/* | ES_NOHIDESEL /* | ES_SAVESEL | ES_SELECTIONBAR */| ES_READONLY,
                                                                0,
                                                                0,
                                                                100,
                                                                100,
                                                                hEditFather,
                                                                NULL,
                                                                hInstance,
                                                                NULL );

        if ( !m_hEdit )
                return false;

        SetBackGroundColor( KRGB( 64, 64, 64 ) );

        ShowWindow( m_hEdit, SW_SHOWMAXIMIZED );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::SetBackGroundColor( KCOLOR Color )
{
        SendMessage( m_hEdit, EM_SETBKGNDCOLOR, (WPARAM)0, (LPARAM)RGB( KGETR( Color), KGETG( Color ), KGETB( Color ) ) );
}

//---------------------------------------------------------------------------------------------------------------------
LRESULT CALLBACK KConsole::WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
        switch( uMsg )
        {
        case WM_CREATE:
                break;
        
        case WM_CLOSE:
                PostQuitMessage( 0 );
                break;
        case WM_SIZING:
                {
                        RECT    Rect;
                        GetClientRect( hWnd, &Rect );
                        MoveWindow( g_Console.m_hEdit, 0, 0, Rect.right, Rect.bottom, TRUE );
                }
                break;
        }

        return DefWindowProc( hWnd, uMsg, wParam, lParam);
}

//---------------------------------------------------------------------------------------------------------------------
void KConsole::SetParentWindow( HWND hWnd )
{
        KASSERT( 0 );   
        // TODO : Bug pere-fils
        SetParent( m_hWnd, hWnd );
        LONG    Style = GetWindowLong( m_hWnd, GWL_STYLE );
        Style &= ~WS_CHILD;
        Style |= WS_POPUP;
        SetWindowLong( m_hWnd, GWL_STYLE, Style );
}

---