console.c File Reference

#include "precomp.h"
#include <shellapi.h>
#include <stdlib.h>
#include <strsafe.h>
#include "resource.h"
#include <debug.h>

Include dependency graph for console.c:

Go to the source code of this file.

Classes
struct	_CONSOLE_MAINFRAME_WND
struct	_CONSOLE_CHILDFRM_WND

Macros
#define	NDEBUG

Typedefs
typedef struct _CONSOLE_MAINFRAME_WND	CONSOLE_MAINFRAME_WND
typedef struct _CONSOLE_MAINFRAME_WND *	PCONSOLE_MAINFRAME_WND
typedef struct _CONSOLE_CHILDFRM_WND	CONSOLE_CHILDFRM_WND
typedef struct _CONSOLE_CHILDFRM_WND *	PCONSOLE_CHILDFRM_WND

Functions
PCONSOLE_CHILDFRM_WND	GetActiveChildInfo (VOID)
static LPTSTR	CreateNewConsoleTitle (VOID)
HWND	CreateNewMDIChild (PCONSOLE_MAINFRAME_WND Info, HWND hwndMDIClient)
static LRESULT	FrameOnCreate (HWND hwnd, LPARAM lParam)
static VOID	SetFileName (PCONSOLE_CHILDFRM_WND Info, PWSTR pFileName)
static BOOL	DoSaveFileAs (HWND hWnd, PCONSOLE_CHILDFRM_WND pChildInfo)
static BOOL	DoSaveFile (HWND hWnd, PCONSOLE_CHILDFRM_WND pChildInfo)
static BOOL	FrameOnSave (HWND hWnd)
static BOOL	FrameOnSaveAs (HWND hWnd)
static VOID	FrameOnCommand (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	FrameOnSize (HWND hMainWnd, WORD cx, WORD cy)
static LRESULT CALLBACK	ConsoleMainFrameWndProc (IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
static LRESULT CALLBACK	ConsoleChildFrmProc (IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
BOOL	RegisterMMCWndClasses (VOID)
VOID	UnregisterMMCWndClasses (VOID)
HWND	CreateConsoleWindow (IN LPCTSTR lpFileName OPTIONAL, int nCmdShow)

Variables
static const TCHAR	szMMCMainFrame [] = TEXT("MMCMainFrame")
static const TCHAR	szMMCChildFrm [] = TEXT("MMCChildFrm")
static ULONG	NewConsoleCount = 0

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 27 of file console.c.

Typedef Documentation

CONSOLE_CHILDFRM_WND

typedef struct _CONSOLE_CHILDFRM_WND CONSOLE_CHILDFRM_WND

CONSOLE_MAINFRAME_WND

typedef struct _CONSOLE_MAINFRAME_WND CONSOLE_MAINFRAME_WND

PCONSOLE_CHILDFRM_WND

typedef struct _CONSOLE_CHILDFRM_WND * PCONSOLE_CHILDFRM_WND

PCONSOLE_MAINFRAME_WND

typedef struct _CONSOLE_MAINFRAME_WND * PCONSOLE_MAINFRAME_WND

Function Documentation

ConsoleChildFrmProc()

static LRESULT CALLBACK ConsoleChildFrmProc ( IN HWND  hwnd, IN UINT  uMsg, IN WPARAM  wParam, IN LPARAM  lParam  )

static

Definition at line 479 of file console.c.

{
    PCONSOLE_CHILDFRM_WND Info;

    Info = (PCONSOLE_CHILDFRM_WND)GetWindowLongPtr(hwnd,
                                                   0);

    switch (uMsg)
    {
        case WM_CREATE:
            Info = HeapAlloc(hAppHeap,
                             HEAP_ZERO_MEMORY,
                             sizeof(CONSOLE_CHILDFRM_WND));
            if (Info != NULL)
            {
                Info->hwnd = hwnd;

                SetWindowLongPtr(hwnd,
                                 0,
                                 (LONG_PTR)Info);
            }
            break;

       case WM_DESTROY:
           if (Info != NULL)
           {
               if (Info->pFileName)
                   HeapFree(hAppHeap, 0, Info->pFileName);

               HeapFree(hAppHeap, 0, Info);
           }

           PostMessage(hwndMainConsole, WM_USER_CLOSE_CHILD, 0, 0);
           break;

       default:
            return DefMDIChildProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

Referenced by RegisterMMCWndClasses().

ConsoleMainFrameWndProc()

static LRESULT CALLBACK ConsoleMainFrameWndProc ( IN HWND  hwnd, IN UINT  uMsg, IN WPARAM  wParam, IN LPARAM  lParam  )

static

Definition at line 398 of file console.c.

{
    PCONSOLE_MAINFRAME_WND Info;

    Info = (PCONSOLE_MAINFRAME_WND)GetWindowLongPtr(hwnd,
                                                    0);

    switch (uMsg)
    {
        case WM_CREATE:
            return FrameOnCreate(hwnd,
                                 lParam);

        case WM_COMMAND:
            FrameOnCommand(hwnd,
                           uMsg,
                           wParam,
                           lParam);
            break;

        case WM_SIZE:
            FrameOnSize(hwnd,
                        LOWORD(lParam),
                        HIWORD(lParam));
            break;

        case WM_CLOSE:
            DestroyWindow(hwnd);
            break;

        case WM_DESTROY:
            if (Info != NULL)
            {
                SetMenu(Info->hwnd,
                        NULL);

                if (Info->hMenuConsoleSmall != NULL)
                {
                    DestroyMenu(Info->hMenuConsoleSmall);
                    Info->hMenuConsoleSmall = NULL;
                }

                if (Info->hMenuConsoleLarge != NULL)
                {
                    DestroyMenu(Info->hMenuConsoleLarge);
                    Info->hMenuConsoleLarge = NULL;
                }

                HeapFree(hAppHeap,
                         0,
                         Info);
            }

            PostQuitMessage(0);
            break;

        case WM_USER_CLOSE_CHILD:
            Info->nConsoleCount--;
            if (Info->nConsoleCount == 0)
            {
                SetMenu(Info->hwnd,
                        Info->hMenuConsoleSmall);
            }
            break;

        default:
            return DefFrameProc(hwnd,
                                hwndMDIClient,
                                uMsg,
                                wParam,
                                lParam);
    }

    return 0;
}

Referenced by RegisterMMCWndClasses().

CreateConsoleWindow()

HWND CreateConsoleWindow	(	IN LPCTSTR lpFileName	OPTIONAL,
		int	nCmdShow
	)

Definition at line 585 of file console.c.

{
    HWND hWndConsole;
    LONG_PTR FileName = (LONG_PTR)lpFileName;

    hWndConsole = CreateWindowEx(WS_EX_WINDOWEDGE,
                                 szMMCMainFrame,
                                 NULL,
                                 WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                                 CW_USEDEFAULT,
                                 CW_USEDEFAULT,
                                 CW_USEDEFAULT,
                                 CW_USEDEFAULT,
                                 NULL,
                                 NULL,
                                 hAppInstance,
                                 (PVOID)FileName);

    if (hWndConsole != NULL)
    {
        ShowWindow(hWndConsole, nCmdShow);
    }

    return hWndConsole;
}

Referenced by _tWinMain().

CreateNewConsoleTitle()

static LPTSTR CreateNewConsoleTitle ( VOID  )

static

Definition at line 74 of file console.c.

{
    LPTSTR lpTitle;

    if (LoadAndFormatString(hAppInstance,
                            IDS_CONSOLETITLE,
                            &lpTitle,
                            ++NewConsoleCount) == 0)
    {
        lpTitle = NULL;
    }

    return lpTitle;
}

Referenced by CreateNewMDIChild().

CreateNewMDIChild()

HWND CreateNewMDIChild	(	PCONSOLE_MAINFRAME_WND	Info,
		HWND	hwndMDIClient
	)

Definition at line 90 of file console.c.

{
    MDICREATESTRUCT mcs;
    HWND hChild;

    mcs.szTitle = CreateNewConsoleTitle();
    mcs.szClass = szMMCChildFrm;
    mcs.hOwner  = GetModuleHandle(NULL);
    mcs.x = mcs.cx = CW_USEDEFAULT;
    mcs.y = mcs.cy = CW_USEDEFAULT;
    mcs.style = MDIS_ALLCHILDSTYLES;

    hChild = (HWND)SendMessage(hwndMDIClient, WM_MDICREATE, 0, (LPARAM)&mcs);
    if (hChild)
    {
        Info->nConsoleCount++;
    }

    return hChild;
}

Referenced by FrameOnCommand().

DoSaveFile()

static BOOL DoSaveFile ( HWND  hWnd, PCONSOLE_CHILDFRM_WND  pChildInfo  )

static

Definition at line 208 of file console.c.

{
    DPRINT1("pChildInfo %p\n", pChildInfo);

    DPRINT1("FileName %S\n", pChildInfo->pFileName);

    if (pChildInfo->pFileName == NULL)
        return DoSaveFileAs(hWnd, pChildInfo);

    /* FIXME: Save the console here! */

    return TRUE;
}

Referenced by DoFileSave(), DoSaveFileAs(), and FrameOnSave().

DoSaveFileAs()

static BOOL DoSaveFileAs ( HWND  hWnd, PCONSOLE_CHILDFRM_WND  pChildInfo  )

static

Definition at line 225 of file console.c.

{
    OPENFILENAME saveas;
    TCHAR szPath[MAX_PATH];

    DPRINT1("pChildInfo %p\n", pChildInfo);
    DPRINT1("FileName %S\n", pChildInfo->pFileName);

    ZeroMemory(&saveas, sizeof(saveas));

    if (pChildInfo->pFileName != NULL)
    {
        StringCbCopy(szPath, sizeof(szPath), pChildInfo->pFileName);
    }
    else
    {
        GetWindowText(pChildInfo->hwnd, szPath, _countof(szPath));
        StringCbCat(szPath, sizeof(szPath), TEXT(".msc"));
    }

    saveas.lStructSize = sizeof(OPENFILENAME);
    saveas.hwndOwner = hWnd;
    saveas.hInstance = hAppInstance;
    saveas.lpstrFilter = L"MSC Files\0*.msc\0";
    saveas.lpstrFile = szPath;
    saveas.nMaxFile = MAX_PATH;
    saveas.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
    saveas.lpstrDefExt = L"msc";

    if (GetSaveFileName(&saveas))
    {
        /* HACK: Because in ROS, Save-As boxes don't check the validity
         * of file names and thus, here, szPath can be invalid !! We only
         * see its validity when we call DoSaveFile()... */
        SetFileName(pChildInfo, szPath);

        if (DoSaveFile(hWnd, pChildInfo))
        {
//            UpdateWindowCaption();
            return TRUE;
        }
        else
        {
            SetFileName(pChildInfo, NULL);
            return FALSE;
        }
    }
    else
    {
        return FALSE;
    }
}

Referenced by DoSaveFile(), and FrameOnSaveAs().

FrameOnCommand()

static VOID FrameOnCommand ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 308 of file console.c.

{
    PCONSOLE_MAINFRAME_WND Info;
    HWND hChild;
    LPTSTR lpTitle;

    Info = (PCONSOLE_MAINFRAME_WND)GetWindowLongPtr(hwnd, 0);

    switch (LOWORD(wParam))
    {
        case IDM_FILE_NEW:
            CreateNewMDIChild(Info, hwndMDIClient);
            SetMenu(Info->hwnd,
                    Info->hMenuConsoleLarge);
            break;

        case IDM_FILE_SAVE:
            FrameOnSave(hwnd);
            break;

        case IDM_FILE_SAVEAS:
            FrameOnSaveAs(hwnd);
            break;

        case IDM_FILE_EXIT:
            PostMessage(hwnd, WM_CLOSE, 0, 0);
            break;

        case IDM_HELP_ABOUT:
            if (AllocAndLoadString(&lpTitle, hAppInstance, IDS_APPTITLE))
            {
                ShellAbout(hwnd, lpTitle, NULL,
                           LoadIcon(hAppInstance, MAKEINTRESOURCE(IDI_MAINAPP)));
                LocalFree(lpTitle);
            }
            break;

        default:
            if (LOWORD(wParam) >= IDM_MDI_FIRSTCHILD)
            {
                DefFrameProc(hwnd, hwndMDIClient, uMsg, wParam, lParam);
            }
            else
            {
                hChild = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0);
                if (hChild)
                {
                    SendMessage(hChild, WM_COMMAND, wParam, lParam);
                }
            }
            break;
    }
}

Referenced by ConsoleMainFrameWndProc().

FrameOnCreate()

static LRESULT FrameOnCreate ( HWND  hwnd, LPARAM  lParam  )

static

Definition at line 114 of file console.c.

{
    PCONSOLE_MAINFRAME_WND Info;
    CLIENTCREATESTRUCT ccs;
    LPCTSTR lpFileName = (LPCTSTR)(((LPCREATESTRUCT)lParam)->lpCreateParams);

    Info = HeapAlloc(hAppHeap,
                     HEAP_ZERO_MEMORY,
                     sizeof(CONSOLE_MAINFRAME_WND));
    if (Info == NULL)
        return -1;

    Info->hwnd = hwnd;

    SetWindowLongPtr(hwnd,
                     0,
                     (LONG_PTR)Info);

    Info->hMenuConsoleSmall = LoadMenu(hAppInstance,
                                       MAKEINTRESOURCE(IDM_CONSOLE_SMALL));

    Info->hMenuConsoleLarge = LoadMenu(hAppInstance,
                                       MAKEINTRESOURCE(IDM_CONSOLE_LARGE));

    if (lpFileName == NULL)
    {
        /* FIXME */
        Info->AppAuthorMode = TRUE;
//        Info->lpConsoleTitle = TEXT("ReactOS Management Console");
    }
    else
    {
        Info->AppAuthorMode = TRUE;
//        Info->lpConsoleTitle = CreateNewConsoleTitle();
    }

    SetMenu(Info->hwnd,
            Info->hMenuConsoleSmall);

    SetWindowText(Info->hwnd, TEXT("ReactOS Management Console"));

    ccs.hWindowMenu = GetSubMenu(Info->hMenuConsoleLarge, 1);
    ccs.idFirstChild = IDM_MDI_FIRSTCHILD;

    /* Create the MDI client window */
    hwndMDIClient = CreateWindowEx(WS_EX_CLIENTEDGE,
                                   L"MDICLIENT",
                                   (LPCTSTR)NULL,
                                   WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE | WS_BORDER,
                                   CW_USEDEFAULT,
                                   CW_USEDEFAULT,
                                   CW_USEDEFAULT,
                                   CW_USEDEFAULT,
                                   hwnd,
                                   (HMENU)0xCAC,
                                   hAppInstance,
                                   (LPVOID)&ccs);

    ShowWindow(Info->hwndMDIClient, SW_SHOW);

    return 0;
}

Referenced by ConsoleMainFrameWndProc().

FrameOnSave()

static BOOL FrameOnSave ( HWND  hWnd )

static

Definition at line 281 of file console.c.

{
    PCONSOLE_CHILDFRM_WND pChildInfo;

    pChildInfo = GetActiveChildInfo();
    if (pChildInfo == NULL)
        return FALSE;

    return DoSaveFile(hWnd, pChildInfo);
}

Referenced by FrameOnCommand().

FrameOnSaveAs()

static BOOL FrameOnSaveAs ( HWND  hWnd )

static

Definition at line 295 of file console.c.

{
    PCONSOLE_CHILDFRM_WND pChildInfo;

    pChildInfo = GetActiveChildInfo();
    if (pChildInfo == NULL)
        return FALSE;

    return DoSaveFileAs(hWnd, pChildInfo);
}

Referenced by FrameOnCommand().

FrameOnSize()

static VOID FrameOnSize ( HWND  hMainWnd, WORD  cx, WORD  cy  )

static

Definition at line 367 of file console.c.

{
    RECT rcClient; //, rcTool, rcStatus;
//    int lvHeight, iToolHeight, iStatusHeight;

    /* Size toolbar and get height */
//    SendMessage(Info->hTool, TB_AUTOSIZE, 0, 0);
//    GetWindowRect(Info->hTool, &rcTool);
//    iToolHeight = rcTool.bottom - rcTool.top;

    /* Size status bar and get height */
//    SendMessage(Info->hStatus, WM_SIZE, 0, 0);
//    GetWindowRect(Info->hStatus, &rcStatus);
//    iStatusHeight = rcStatus.bottom - rcStatus.top;

    /* Calculate remaining height and size list view */
    GetClientRect(hMainWnd, &rcClient);
//    lvHeight = rcClient.bottom - iToolHeight - iStatusHeight;
    SetWindowPos(hwndMDIClient, //Info->hTreeView,
                 NULL,
                 0,
                 0, //iToolHeight,
                 rcClient.right,
                 rcClient.bottom, //lvHeight,
                 SWP_NOZORDER);
}

Referenced by ConsoleMainFrameWndProc().

GetActiveChildInfo()

PCONSOLE_CHILDFRM_WND GetActiveChildInfo

(

VOID

)

Definition at line 61 of file console.c.

{
    HWND hWndMDIChild;

    hWndMDIChild = (HWND)SendMessageW(hwndMDIClient, WM_MDIGETACTIVE, 0, 0);
    if (hWndMDIChild == NULL)
        return NULL;

    return (PCONSOLE_CHILDFRM_WND)GetWindowLongPtr(hWndMDIChild, 0);
}

Referenced by FrameOnSave(), and FrameOnSaveAs().

RegisterMMCWndClasses()

BOOL RegisterMMCWndClasses

(

VOID

)

Definition at line 526 of file console.c.

{
    WNDCLASSEX wc = {0};
    BOOL Ret;

    /* Register the MMCMainFrame window class */
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = 0;
    wc.lpfnWndProc = ConsoleMainFrameWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = sizeof(PCONSOLE_MAINFRAME_WND);
    wc.hInstance = hAppInstance;
    wc.hIcon = LoadIcon(hAppInstance,
                        MAKEINTRESOURCE(IDI_MAINAPP));
    wc.hCursor = LoadCursor(NULL,
                            MAKEINTRESOURCE(IDC_ARROW));
    wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = szMMCMainFrame;

    Ret = (RegisterClassEx(&wc) != (ATOM)0);

    if (Ret)
    {
        /* Register the MMCChildFrm window class */
        wc.cbSize = sizeof(WNDCLASSEX);
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = ConsoleChildFrmProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = sizeof(PCONSOLE_CHILDFRM_WND);
        wc.hInstance = hAppInstance;
        wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
        wc.lpszMenuName = NULL;
        wc.lpszClassName = szMMCChildFrm;
        wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

        Ret = (RegisterClassEx(&wc) != (ATOM)0);
        if (!Ret)
        {
            UnregisterClass(szMMCMainFrame,
                            hAppInstance);
        }
    }

    return Ret;
}

Referenced by _tWinMain().

SetFileName()

static VOID SetFileName ( PCONSOLE_CHILDFRM_WND  Info, PWSTR  pFileName  )

static

Definition at line 180 of file console.c.

{
    DPRINT1("SetFileName(&p \'%S\')\n", Info, pFileName);

    if (Info->pFileName != NULL)
    {
        HeapFree(GetProcessHeap(), 0, Info->pFileName);
        Info->pFileName = NULL;
    }

    if (pFileName != NULL)
    {
        Info->pFileName = HeapAlloc(GetProcessHeap(),
                                    0,
                                    (_tcslen(pFileName) + 1) * sizeof(TCHAR));
        if (Info->pFileName != NULL)
            _tcscpy(Info->pFileName, pFileName);
    }
}

Referenced by DIALOG_FileSaveAs(), DoCloseFile(), DoOpenFile(), DoSaveFile(), and DoSaveFileAs().

UnregisterMMCWndClasses()

VOID UnregisterMMCWndClasses

(

VOID

)

Definition at line 576 of file console.c.

{
    UnregisterClass(szMMCChildFrm,
                    hAppInstance);
    UnregisterClass(szMMCMainFrame,
                    hAppInstance);
}

Referenced by _tWinMain().

Variable Documentation

NewConsoleCount

ULONG NewConsoleCount = 0

static

Definition at line 58 of file console.c.

Referenced by CreateNewConsoleTitle().

szMMCChildFrm

const TCHAR szMMCChildFrm[] = TEXT("MMCChildFrm")

static

Definition at line 56 of file console.c.

Referenced by CreateNewMDIChild(), RegisterMMCWndClasses(), and UnregisterMMCWndClasses().

szMMCMainFrame

const TCHAR szMMCMainFrame[] = TEXT("MMCMainFrame")

static

Definition at line 55 of file console.c.

Referenced by CreateConsoleWindow(), RegisterMMCWndClasses(), and UnregisterMMCWndClasses().