console.c File Reference

#include "console.h"
#include <debug.h>

Include dependency graph for console.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
INT_PTR CALLBACK	OptionsProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	FontProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	LayoutProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	ColorsProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	InitPropSheetPage (PROPSHEETPAGEW *psp, WORD idDlg, DLGPROC DlgProc)
static VOID	InitDefaultConsoleInfo (PCONSOLE_STATE_INFO pConInfo)
static INT_PTR CALLBACK	ApplyProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
VOID	ApplyConsoleInfo (HWND hwndDlg)
static int CALLBACK	PropSheetProc (HWND hwndDlg, UINT uMsg, LPARAM lParam)
static LONG APIENTRY	InitApplet (HANDLE hSectionOrWnd)
LONG CALLBACK	CPlApplet (HWND hwndCPl, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
INT WINAPI	DllMain (HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpvReserved)

Variables
HINSTANCE	hApplet = NULL
PCONSOLE_STATE_INFO	ConInfo = NULL
static BOOL	SetConsoleInfo = FALSE
static BOOL	SaveConsoleInfo = FALSE

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file console.c.

Function Documentation

ApplyConsoleInfo()

VOID ApplyConsoleInfo

(

HWND

hwndDlg

)

Definition at line 88 of file console.c.

{
    static BOOL ConsoleInfoAlreadySaved = FALSE;
 
    /*
     * We already applied all the console properties (and saved if needed).
     * Nothing more needs to be done.
     */
    if (ConsoleInfoAlreadySaved)
        goto Done;
 
    /*
     * If we are setting the default parameters, just save them,
     * otherwise display the confirmation & apply dialog.
     */
    if (ConInfo->hWnd == NULL)
    {
        SetConsoleInfo  = FALSE;
        SaveConsoleInfo = TRUE;
    }
    else
    {
        INT_PTR res = DialogBoxW(hApplet, MAKEINTRESOURCEW(IDD_APPLYOPTIONS), hwndDlg, ApplyProc);
 
        SetConsoleInfo  = (res != IDCANCEL);
        SaveConsoleInfo = (res == IDC_RADIO_APPLY_ALL);
 
        if (!SetConsoleInfo)
        {
            /* Don't destroy when the user presses cancel */
            SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
            return;
        }
    }
 
    /*
     * We applied all the console properties (and saved if needed).
     * Set the flag so that if this function is called again, we won't
     * need to redo everything again.
     */
    ConsoleInfoAlreadySaved = TRUE;
 
Done:
    /* Options have been applied */
    SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
    return;
}

Referenced by ColorsProc(), FontProc(), and OptionsProc().

ApplyProc()

static INT_PTR CALLBACK ApplyProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 51 of file console.c.

{
    UNREFERENCED_PARAMETER(lParam);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            CheckDlgButton(hwndDlg, IDC_RADIO_APPLY_CURRENT, BST_CHECKED);
            return TRUE;
        }
        case WM_COMMAND:
        {
            if (LOWORD(wParam) == IDOK)
            {
                if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_APPLY_CURRENT) == BST_CHECKED)
                    EndDialog(hwndDlg, IDC_RADIO_APPLY_CURRENT);
                else
                    EndDialog(hwndDlg, IDC_RADIO_APPLY_ALL);
            }
            else if (LOWORD(wParam) == IDCANCEL)
            {
                EndDialog(hwndDlg, IDCANCEL);
            }
            break;
        }
        default:
            break;
    }
 
    return FALSE;
}

Referenced by ApplyConsoleInfo().

ColorsProc()

INT_PTR CALLBACK ColorsProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 37 of file colors.c.

{
    DWORD colorIndex;
    COLORREF color;
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Set the valid range of the colour indicators */
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_COLOR_RED  , UDM_SETRANGE, 0, (LPARAM)MAKELONG(255, 0));
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_COLOR_GREEN, UDM_SETRANGE, 0, (LPARAM)MAKELONG(255, 0));
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_COLOR_BLUE , UDM_SETRANGE, 0, (LPARAM)MAKELONG(255, 0));
 
            /* Select by default the screen background option */
            CheckRadioButton(hDlg, IDC_RADIO_SCREEN_TEXT, IDC_RADIO_POPUP_BACKGROUND, IDC_RADIO_SCREEN_BACKGROUND);
            SendMessageW(hDlg, WM_COMMAND, IDC_RADIO_SCREEN_BACKGROUND, 0);
 
            return TRUE;
        }
 
        case WM_DRAWITEM:
        {
            LPDRAWITEMSTRUCT drawItem = (LPDRAWITEMSTRUCT)lParam;
 
            if (IDC_STATIC_COLOR1 <= drawItem->CtlID && drawItem->CtlID <= IDC_STATIC_COLOR16)
                PaintStaticControls(drawItem, ConInfo);
            else if (drawItem->CtlID == IDC_STATIC_SCREEN_COLOR)
                PaintText(drawItem, ConInfo, Screen);
            else if (drawItem->CtlID == IDC_STATIC_POPUP_COLOR)
                PaintText(drawItem, ConInfo, Popup);
 
            return TRUE;
        }
 
        case WM_NOTIFY:
        {
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_APPLY:
                {
                    ApplyConsoleInfo(hDlg);
                    return TRUE;
                }
 
                case UDN_DELTAPOS:
                {
                    LPNMUPDOWN lpnmud = (LPNMUPDOWN)lParam;
 
                    /* Get the current color */
                    colorIndex = ActiveStaticControl;
                    color = ConInfo->ColorTable[colorIndex];
 
                    if (lpnmud->hdr.idFrom == IDC_UPDOWN_COLOR_RED)
                    {
                        lpnmud->iPos = min(max(lpnmud->iPos + lpnmud->iDelta, 0), 255);
                        color = RGB(lpnmud->iPos, GetGValue(color), GetBValue(color));
                    }
                    else if (lpnmud->hdr.idFrom == IDC_UPDOWN_COLOR_GREEN)
                    {
                        lpnmud->iPos = min(max(lpnmud->iPos + lpnmud->iDelta, 0), 255);
                        color = RGB(GetRValue(color), lpnmud->iPos, GetBValue(color));
                    }
                    else if (lpnmud->hdr.idFrom == IDC_UPDOWN_COLOR_BLUE)
                    {
                        lpnmud->iPos = min(max(lpnmud->iPos + lpnmud->iDelta, 0), 255);
                        color = RGB(GetRValue(color), GetGValue(color), lpnmud->iPos);
                    }
                    else
                    {
                        break;
                    }
 
                    ConInfo->ColorTable[colorIndex] = color;
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_COLOR1 + colorIndex), NULL, TRUE);
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_SCREEN_COLOR), NULL, TRUE);
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_POPUP_COLOR) , NULL, TRUE);
 
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
            }
 
            break;
        }
 
        case WM_COMMAND:
        {
            /* NOTE: both BN_CLICKED and STN_CLICKED == 0 */
            if (HIWORD(wParam) == BN_CLICKED /* || HIWORD(wParam) == STN_CLICKED */)
            {
                WORD ctrlIndex = LOWORD(wParam);
 
                if (ctrlIndex == IDC_RADIO_SCREEN_TEXT       ||
                    ctrlIndex == IDC_RADIO_SCREEN_BACKGROUND ||
                    ctrlIndex == IDC_RADIO_POPUP_TEXT        ||
                    ctrlIndex == IDC_RADIO_POPUP_BACKGROUND)
                {
                    switch (ctrlIndex)
                    {
                    case IDC_RADIO_SCREEN_TEXT:
                        /* Get the colour of the screen foreground */
                        colorIndex = TextAttribFromAttrib(ConInfo->ScreenAttributes);
                        break;
 
                    case IDC_RADIO_SCREEN_BACKGROUND:
                        /* Get the colour of the screen background */
                        colorIndex = BkgdAttribFromAttrib(ConInfo->ScreenAttributes);
                        break;
 
                    case IDC_RADIO_POPUP_TEXT:
                        /* Get the colour of the popup foreground */
                        colorIndex = TextAttribFromAttrib(ConInfo->PopupAttributes);
                        break;
 
                    case IDC_RADIO_POPUP_BACKGROUND:
                        /* Get the colour of the popup background */
                        colorIndex = BkgdAttribFromAttrib(ConInfo->PopupAttributes);
                        break;
                    }
 
                    color = ConInfo->ColorTable[colorIndex];
 
                    /* Set the values of the colour indicators */
                    SetDlgItemInt(hDlg, IDC_EDIT_COLOR_RED  , GetRValue(color), FALSE);
                    SetDlgItemInt(hDlg, IDC_EDIT_COLOR_GREEN, GetGValue(color), FALSE);
                    SetDlgItemInt(hDlg, IDC_EDIT_COLOR_BLUE , GetBValue(color), FALSE);
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_COLOR1 + ActiveStaticControl), NULL, TRUE);
                    ActiveStaticControl = colorIndex;
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_COLOR1 + ActiveStaticControl), NULL, TRUE);
                    break;
                }
                else
                if (IDC_STATIC_COLOR1 <= ctrlIndex && ctrlIndex <= IDC_STATIC_COLOR16)
                {
                    colorIndex = ctrlIndex - IDC_STATIC_COLOR1;
 
                    /* If the same static control was re-clicked, don't take it into account */
                    if (colorIndex == ActiveStaticControl)
                        break;
 
                    color = ConInfo->ColorTable[colorIndex];
 
                    /* Set the values of the colour indicators */
                    SetDlgItemInt(hDlg, IDC_EDIT_COLOR_RED  , GetRValue(color), FALSE);
                    SetDlgItemInt(hDlg, IDC_EDIT_COLOR_GREEN, GetGValue(color), FALSE);
                    SetDlgItemInt(hDlg, IDC_EDIT_COLOR_BLUE , GetBValue(color), FALSE);
 
                    if (IsDlgButtonChecked(hDlg, IDC_RADIO_SCREEN_TEXT))
                    {
                        ConInfo->ScreenAttributes = MakeAttrib(colorIndex, BkgdAttribFromAttrib(ConInfo->ScreenAttributes));
                    }
                    else if (IsDlgButtonChecked(hDlg, IDC_RADIO_SCREEN_BACKGROUND))
                    {
                        ConInfo->ScreenAttributes = MakeAttrib(TextAttribFromAttrib(ConInfo->ScreenAttributes), colorIndex);
                    }
                    else if (IsDlgButtonChecked(hDlg, IDC_RADIO_POPUP_TEXT))
                    {
                        ConInfo->PopupAttributes = MakeAttrib(colorIndex, BkgdAttribFromAttrib(ConInfo->PopupAttributes));
                    }
                    else if (IsDlgButtonChecked(hDlg, IDC_RADIO_POPUP_BACKGROUND))
                    {
                        ConInfo->PopupAttributes = MakeAttrib(TextAttribFromAttrib(ConInfo->PopupAttributes), colorIndex);
                    }
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_COLOR1 + ActiveStaticControl), NULL, TRUE);
                    ActiveStaticControl = colorIndex;
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_COLOR1 + ActiveStaticControl), NULL, TRUE);
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_SCREEN_COLOR), NULL, TRUE);
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_POPUP_COLOR) , NULL, TRUE);
 
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
            }
            else if (HIWORD(wParam) == EN_KILLFOCUS)
            {
                WORD ctrlIndex = LOWORD(wParam);
 
                if (ctrlIndex == IDC_EDIT_COLOR_RED   ||
                    ctrlIndex == IDC_EDIT_COLOR_GREEN ||
                    ctrlIndex == IDC_EDIT_COLOR_BLUE)
                {
                    DWORD value;
 
                    /* Get the current colour */
                    colorIndex = ActiveStaticControl;
                    color = ConInfo->ColorTable[colorIndex];
 
                    /* Modify the colour component */
                    switch (ctrlIndex)
                    {
                    case IDC_EDIT_COLOR_RED:
                        value = GetDlgItemInt(hDlg, IDC_EDIT_COLOR_RED, NULL, FALSE);
                        value = min(max(value, 0), 255);
                        color = RGB(value, GetGValue(color), GetBValue(color));
                        break;
 
                    case IDC_EDIT_COLOR_GREEN:
                        value = GetDlgItemInt(hDlg, IDC_EDIT_COLOR_GREEN, NULL, FALSE);
                        value = min(max(value, 0), 255);
                        color = RGB(GetRValue(color), value, GetBValue(color));
                        break;
 
                    case IDC_EDIT_COLOR_BLUE:
                        value = GetDlgItemInt(hDlg, IDC_EDIT_COLOR_BLUE, NULL, FALSE);
                        value = min(max(value, 0), 255);
                        color = RGB(GetRValue(color), GetGValue(color), value);
                        break;
                    }
 
                    ConInfo->ColorTable[colorIndex] = color;
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_COLOR1 + colorIndex), NULL, TRUE);
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_SCREEN_COLOR), NULL, TRUE);
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_POPUP_COLOR) , NULL, TRUE);
 
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
            }
 
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InitApplet().

CPlApplet()

LONG CALLBACK CPlApplet	(	HWND	hwndCPl,
		UINT	uMsg,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 346 of file console.c.

{
    switch (uMsg)
    {
        case CPL_INIT:
            return TRUE;
 
        case CPL_EXIT:
            // TODO: Free allocated memory
            break;
 
        case CPL_GETCOUNT:
            return 1;
 
        case CPL_INQUIRE:
        {
            CPLINFO *CPlInfo = (CPLINFO*)lParam2;
            CPlInfo->idIcon  = IDC_CPLICON;
            CPlInfo->idName  = IDS_CPLNAME;
            CPlInfo->idInfo  = IDS_CPLDESCRIPTION;
            break;
        }
 
        case CPL_DBLCLK:
            InitApplet((HANDLE)hwndCPl);
            break;
    }
 
    return FALSE;
}

DllMain()

INT WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	dwReason,
		LPVOID	lpvReserved
	)

Definition at line 382 of file console.c.

{
    UNREFERENCED_PARAMETER(lpvReserved);
 
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
            hApplet = hinstDLL;
            DisableThreadLibraryCalls(hinstDLL);
            break;
    }
 
    return TRUE;
}

FontProc()

INT_PTR CALLBACK FontProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 725 of file font.c.

{
    PFONTSIZE_LIST_CTL SizeList;
 
    SizeList = (PFONTSIZE_LIST_CTL)GetWindowLongPtrW(hDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            SizeList = (PFONTSIZE_LIST_CTL)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*SizeList));
            if (!SizeList)
            {
                EndDialog(hDlg, 0);
                return (INT_PTR)TRUE;
            }
            SizeList->RasterSizeList.hWndList = GetDlgItem(hDlg, IDC_LBOX_FONTSIZE);
            SizeList->RasterSizeList.GetCount = RasterSizeList_GetCount;
            SizeList->RasterSizeList.GetData  = RasterSizeList_GetData;
            SizeList->hWndTTSizeList = GetDlgItem(hDlg, IDC_CBOX_FONTSIZE);
            SizeList->bIsTTSizeDirty = FALSE;
            SetWindowLongPtrW(hDlg, DWLP_USER, (LONG_PTR)SizeList);
 
            /* By default show the raster font size list */
            SizeList->UseRasterOrTTList = TRUE;
 
            /* By default show the font sizes in pixel units */
            CheckRadioButton(hDlg, IDC_RADIO_PIXEL_UNIT, IDC_RADIO_POINT_UNIT, IDC_RADIO_PIXEL_UNIT);
            SizeList->TTSizePixelUnit = TRUE;
 
            UpdateFontSizeList(hDlg, SizeList);
 
            DPRINT1("ConInfo->FaceName = '%S'\n", ConInfo->FaceName);
 
            /* Face names list and current font selection will be done during PSN_SETACTIVE notification */
            // CurrentCodePage = INVALID_CP;
 
            return TRUE;
        }
 
        case WM_DESTROY:
        {
            if (SizeList)
                HeapFree(GetProcessHeap(), 0, SizeList);
            return (INT_PTR)TRUE;
        }
 
        case WM_DRAWITEM:
        {
            LPDRAWITEMSTRUCT drawItem = (LPDRAWITEMSTRUCT)lParam;
 
            if (drawItem->CtlID == IDC_STATIC_SELECT_FONT_PREVIEW)
                PaintText(drawItem, ConInfo, Screen);
 
            return TRUE;
        }
 
        case WM_DISPLAYCHANGE:
        {
            /* Retransmit to the preview window */
            SendDlgItemMessageW(hDlg, IDC_STATIC_FONT_WINDOW_PREVIEW,
                                WM_DISPLAYCHANGE, wParam, lParam);
            break;
        }
 
        case WM_FONTCHANGE:
        {
            /* The pool of font resources has changed, re-enumerate the fonts */
            HWND hFontList = GetDlgItem(hDlg, IDC_LBOX_FONTTYPE);
 
            /* Initialize the font list */
            FaceNameList_Initialize(hFontList, ConInfo->CodePage);
 
            /* Select the current font */
            FaceNameList_SelectFont(hDlg, hFontList,
                                    SizeList,
                                    ConInfo->FaceName,
                                    ConInfo->FontFamily,
                                    ConInfo->FontWeight,
                                    ConInfo->FontSize);
 
            /* Refresh everything */
            FontTypeChange(hDlg, SizeList, ConInfo);
            break;
        }
 
        case WM_NOTIFY:
        {
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_APPLY:
                {
                    ApplyConsoleInfo(hDlg);
                    return TRUE;
                }
 
                case PSN_SETACTIVE:
                {
                    /* Check whether the current code page has changed.
                     * If so, re-enumerate the fonts. */
                    if (CurrentCodePage != ConInfo->CodePage)
                    {
                        HWND hFontList;
 
                        /* Save the new code page */
                        CurrentCodePage = ConInfo->CodePage;
 
                        hFontList = GetDlgItem(hDlg, IDC_LBOX_FONTTYPE);
 
                        /* Initialize the font list */
                        FaceNameList_Initialize(hFontList, ConInfo->CodePage);
 
                        /* Select the current font */
                        FaceNameList_SelectFont(hDlg, hFontList,
                                                SizeList,
                                                ConInfo->FaceName,
                                                ConInfo->FontFamily,
                                                ConInfo->FontWeight,
                                                ConInfo->FontSize);
 
                        /* Refresh everything */
                        FontTypeChange(hDlg, SizeList, ConInfo);
                    }
 
                    /* Fall back to default behaviour */
                    break;
                }
            }
 
            break;
        }
 
        case WM_COMMAND:
        {
            if (HIWORD(wParam) == LBN_SELCHANGE /* || CBN_SELCHANGE */)
            {
                switch (LOWORD(wParam))
                {
                    case IDC_LBOX_FONTTYPE:
                    {
                        /* Change the property sheet state only if the font has really changed */
                        if (FontTypeChange(hDlg, SizeList, ConInfo))
                            PropSheet_Changed(GetParent(hDlg), hDlg);
                        break;
                    }
 
                    case IDC_LBOX_FONTSIZE:
                    case IDC_CBOX_FONTSIZE:
                    {
                        /* Change the property sheet state only if the font has really changed */
                        if (FontSizeChange(hDlg, SizeList, ConInfo))
                            PropSheet_Changed(GetParent(hDlg), hDlg);
                        break;
                    }
                }
            }
            /* NOTE: CBN_EDITUPDATE is sent first, and is followed by CBN_EDITCHANGE */
            else if (HIWORD(wParam) == CBN_EDITUPDATE && LOWORD(wParam) == IDC_CBOX_FONTSIZE)
            {
                ULONG FontSize;
                PWCHAR pszNext = NULL;
                WCHAR szFontSize[100];
                WCHAR szMessage[260];
 
                /* Read the ComboBox edit string, as the user has entered a custom size */
                GetWindowTextW(SizeList->hWndTTSizeList, szFontSize, ARRAYSIZE(szFontSize));
 
                /* Validate the font size */
                FontSize = wcstoul(szFontSize, &pszNext, 10);
                if ((FontSize == 0) || (*pszNext))
                {
                    // FIXME: Localize!
                    StringCchPrintfW(szMessage, ARRAYSIZE(szMessage), L"\"%s\" is not a valid font size.", szFontSize);
                    MessageBoxW(hDlg, szMessage, L"Error", MB_ICONINFORMATION | MB_OK);
                }
                SizeList->bIsTTSizeDirty = TRUE;
            }
            else if (HIWORD(wParam) == CBN_KILLFOCUS && LOWORD(wParam) == IDC_CBOX_FONTSIZE)
            {
                /* Change the property sheet state only if the font has really changed */
                if (FontSizeChange(hDlg, SizeList, ConInfo))
                    PropSheet_Changed(GetParent(hDlg), hDlg);
            }
            else
            if (HIWORD(wParam) == BN_CLICKED)
            {
                switch (LOWORD(wParam))
                {
                case IDC_CHECK_BOLD_FONTS:
                {
                    if (IsDlgButtonChecked(hDlg, IDC_CHECK_BOLD_FONTS) == BST_CHECKED)
                        ConInfo->FontWeight = FW_BOLD;
                    else
                        ConInfo->FontWeight = FW_NORMAL;
 
                    FontTypeChange(hDlg, SizeList, ConInfo);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
 
                case IDC_RADIO_PIXEL_UNIT:
                case IDC_RADIO_POINT_UNIT:
                {
                    SizeList->TTSizePixelUnit = (LOWORD(wParam) == IDC_RADIO_PIXEL_UNIT);
 
                    /* The call is valid only for TrueType fonts */
                    if (CurrentFontType != TRUETYPE_FONTTYPE)
                        break;
 
                    /* Change the property sheet state only if the font has really changed */
                    if (FontSizeChange(hDlg, SizeList, ConInfo))
                        PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
                }
            }
 
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InitApplet().

InitApplet()

static LONG APIENTRY InitApplet ( HANDLE  hSectionOrWnd )

static

Definition at line 156 of file console.c.

{
    INT_PTR Result;
    PCONSOLE_STATE_INFO pSharedInfo = NULL;
    WCHAR szTitle[MAX_PATH + 1];
    PROPSHEETPAGEW psp[4];
    PROPSHEETHEADERW psh;
    INT i = 0;
 
    /*
     * Because of Windows compatibility, we need to behave the same concerning
     * information sharing with CONSRV. For some obscure reason the designers
     * decided to use the CPlApplet hWnd parameter as being either a handle to
     * the applet's parent caller's window (in case we ask for displaying
     * the global console settings), or a handle to a shared section holding
     * a CONSOLE_STATE_INFO structure (they don't use the extra l/wParams).
     */
 
    /*
     * Try to open the shared section via the handle parameter. If we succeed,
     * it means we were called by CONSRV for retrieving/setting parameters for
     * a given console. If we fail, it means we are retrieving/setting default
     * global parameters (and we were either called by CONSRV or directly by
     * the user via the Control Panel, etc...)
     */
    pSharedInfo = MapViewOfFile(hSectionOrWnd, FILE_MAP_READ, 0, 0, 0);
    if (pSharedInfo != NULL)
    {
        /*
         * We succeeded. We were called by CONSRV and are retrieving
         * parameters for a given console.
         */
 
        /* Copy the shared data into our allocated buffer */
        DPRINT1("pSharedInfo->cbSize == %lu ; sizeof(CONSOLE_STATE_INFO) == %u\n",
                pSharedInfo->cbSize, sizeof(CONSOLE_STATE_INFO));
        ASSERT(pSharedInfo->cbSize >= sizeof(CONSOLE_STATE_INFO));
 
        /* Allocate a local buffer to hold console information */
        ConInfo = HeapAlloc(GetProcessHeap(),
                            HEAP_ZERO_MEMORY,
                            pSharedInfo->cbSize);
        if (ConInfo)
            RtlCopyMemory(ConInfo, pSharedInfo, pSharedInfo->cbSize);
 
        /* Close the section */
        UnmapViewOfFile(pSharedInfo);
        CloseHandle(hSectionOrWnd);
 
        if (!ConInfo) return 0;
    }
    else
    {
        /*
         * We failed. We are retrieving the default global parameters.
         */
 
        /* Allocate a local buffer to hold console information */
        ConInfo = HeapAlloc(GetProcessHeap(),
                            HEAP_ZERO_MEMORY,
                            sizeof(CONSOLE_STATE_INFO));
        if (!ConInfo) return 0;
 
        /*
         * Setting the console window handle to NULL indicates we are
         * retrieving/setting the default console parameters.
         */
        ConInfo->hWnd = NULL;
        ConInfo->ConsoleTitle[0] = UNICODE_NULL;
 
        /* Use defaults */
        InitDefaultConsoleInfo(ConInfo);
    }
 
    /* Initialize the font support -- additional TrueType font cache and current preview font */
    InitTTFontCache();
    RefreshFontPreview(&FontPreview, ConInfo);
 
    /* Initialize the property sheet structure */
    ZeroMemory(&psh, sizeof(psh));
    psh.dwSize = sizeof(psh);
    psh.dwFlags = PSH_PROPSHEETPAGE | PSH_PROPTITLE | /* PSH_USEHICON | */ PSH_USEICONID | PSH_NOAPPLYNOW | PSH_USECALLBACK;
 
    if (ConInfo->ConsoleTitle[0] != UNICODE_NULL)
    {
        StringCchPrintfW(szTitle, ARRAYSIZE(szTitle), L"\"%s\"", ConInfo->ConsoleTitle);
        psh.pszCaption = szTitle;
    }
    else
    {
        psh.pszCaption = MAKEINTRESOURCEW(IDS_CPLNAME);
    }
 
    if (pSharedInfo != NULL)
    {
        /* We were started from a console window: this is our parent (or ConInfo->hWnd is NULL) */
        psh.hwndParent = ConInfo->hWnd;
    }
    else
    {
        /* We were started in another way (--> default parameters). Caller's window is our parent. */
        psh.hwndParent = (HWND)hSectionOrWnd;
    }
 
    psh.hInstance = hApplet;
    // psh.hIcon = LoadIcon(hApplet, MAKEINTRESOURCEW(IDC_CPLICON));
    psh.pszIcon = MAKEINTRESOURCEW(IDC_CPLICON);
    psh.nPages = ARRAYSIZE(psp);
    psh.nStartPage = 0;
    psh.ppsp = psp;
    psh.pfnCallback = PropSheetProc;
 
    InitPropSheetPage(&psp[i++], IDD_PROPPAGEOPTIONS, OptionsProc);
    InitPropSheetPage(&psp[i++], IDD_PROPPAGEFONT   , FontProc   );
    InitPropSheetPage(&psp[i++], IDD_PROPPAGELAYOUT , LayoutProc );
    InitPropSheetPage(&psp[i++], IDD_PROPPAGECOLORS , ColorsProc );
 
    /* Display the property sheet */
    RegisterWinPrevClass(hApplet);
    Result = PropertySheetW(&psh);
    UnRegisterWinPrevClass(hApplet);
 
    /* Clear the font support */
    ResetFontPreview(&FontPreview);
    ClearTTFontCache();
 
    /* Apply the console settings if necessary */
    if (SetConsoleInfo)
    {
        HANDLE hSection;
 
        /*
         * Create a memory section to share with CONSRV, and map it.
         */
        hSection = CreateFileMappingW(INVALID_HANDLE_VALUE,
                                      NULL,
                                      PAGE_READWRITE,
                                      0,
                                      ConInfo->cbSize,
                                      NULL);
        if (!hSection)
        {
            DPRINT1("Error when creating file mapping, error = %d\n", GetLastError());
            goto Quit;
        }
 
        pSharedInfo = MapViewOfFile(hSection, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        if (!pSharedInfo)
        {
            DPRINT1("Error when mapping view of file, error = %d\n", GetLastError());
            CloseHandle(hSection);
            goto Quit;
        }
 
        /* Copy the console information into the section and unmap it */
        RtlCopyMemory(pSharedInfo, ConInfo, ConInfo->cbSize);
        UnmapViewOfFile(pSharedInfo);
 
        /*
         * Signal to CONSRV that it can apply the new settings.
         *
         * NOTE: SetConsoleInfo set to TRUE by ApplyConsoleInfo()
         * *only* when ConInfo->hWnd != NULL and the user did not
         * press IDCANCEL in the confirmation dialog.
         */
        ASSERT(ConInfo->hWnd);
        SendMessageW(ConInfo->hWnd, WM_SETCONSOLEINFO, (WPARAM)hSection, 0);
 
        /* Close the section and return */
        CloseHandle(hSection);
    }
 
    /* Save the console settings */
    if (SaveConsoleInfo)
    {
        /* Default settings saved when ConInfo->hWnd == NULL */
        ConCfgWriteUserSettings(ConInfo, ConInfo->hWnd == NULL);
    }
 
Quit:
    /* Cleanup */
    HeapFree(GetProcessHeap(), 0, ConInfo);
    ConInfo = NULL;
 
    return (Result != -1);
}

Referenced by CPlApplet().

InitDefaultConsoleInfo()

static VOID InitDefaultConsoleInfo ( PCONSOLE_STATE_INFO  pConInfo )

static

Definition at line 43 of file console.c.

{
    // FIXME: Also retrieve the value of REG_DWORD CurrentPage.
    ConCfgGetDefaultSettings(pConInfo);
}

Referenced by InitApplet().

InitPropSheetPage()

static VOID InitPropSheetPage ( PROPSHEETPAGEW *  psp, WORD  idDlg, DLGPROC  DlgProc  )

static

Definition at line 29 of file console.c.

{
    ZeroMemory(psp, sizeof(*psp));
    psp->dwSize      = sizeof(*psp);
    psp->dwFlags     = PSP_DEFAULT;
    psp->hInstance   = hApplet;
    psp->pszTemplate = MAKEINTRESOURCEW(idDlg);
    psp->pfnDlgProc  = DlgProc;
    psp->lParam      = 0;
}

Referenced by InitApplet().

LayoutProc()

INT_PTR CALLBACK LayoutProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 525 of file layout.c.

{
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Multi-monitor support */
            LONG  xVirtScr,  yVirtScr; // Coordinates of the top-left virtual screen
            LONG cxVirtScr, cyVirtScr; // Width and Height of the virtual screen
            LONG cxFrame  , cyFrame  ; // Thickness of the window frame
 
            xVirtScr  = GetSystemMetrics(SM_XVIRTUALSCREEN);
            yVirtScr  = GetSystemMetrics(SM_YVIRTUALSCREEN);
            cxVirtScr = GetSystemMetrics(SM_CXVIRTUALSCREEN);
            cyVirtScr = GetSystemMetrics(SM_CYVIRTUALSCREEN);
            cxFrame   = GetSystemMetrics(SM_CXFRAME);
            cyFrame   = GetSystemMetrics(SM_CYFRAME);
 
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_SCREEN_BUFFER_HEIGHT, UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_SCREEN_BUFFER_WIDTH , UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_SIZE_HEIGHT, UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_SIZE_WIDTH , UDM_SETRANGE, 0, (LPARAM)MAKELONG(9999, 1));
 
            SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, ConInfo->ScreenBufferSize.Y, FALSE);
            SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH , ConInfo->ScreenBufferSize.X, FALSE);
            SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, ConInfo->WindowSize.Y, FALSE);
            SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH , ConInfo->WindowSize.X, FALSE);
 
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, UDM_SETRANGE, 0,
                                (LPARAM)MAKELONG(xVirtScr + cxVirtScr - cxFrame, xVirtScr - cxFrame));
            SendDlgItemMessageW(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , UDM_SETRANGE, 0,
                                (LPARAM)MAKELONG(yVirtScr + cyVirtScr - cyFrame, yVirtScr - cyFrame));
 
            SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, ConInfo->WindowPosition.x, TRUE);
            SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP , ConInfo->WindowPosition.y, TRUE);
 
            if (ConInfo->AutoPosition)
            {
                EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_LEFT, FALSE);
                EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_TOP , FALSE);
                EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, FALSE);
                EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , FALSE);
            }
            CheckDlgButton(hDlg, IDC_CHECK_SYSTEM_POS_WINDOW,
                           ConInfo->AutoPosition ? BST_CHECKED : BST_UNCHECKED);
 
            return TRUE;
        }
 
        case WM_DISPLAYCHANGE:
        {
            /* Retransmit to the preview window */
            SendDlgItemMessageW(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW,
                                WM_DISPLAYCHANGE, wParam, lParam);
            break;
        }
 
        case WM_NOTIFY:
        {
            LPPSHNOTIFY lppsn = (LPPSHNOTIFY)lParam;
 
            if (lppsn->hdr.code == UDN_DELTAPOS)
            {
                LPNMUPDOWN lpnmud = (LPNMUPDOWN)lParam;
                DWORD wheight, wwidth;
                DWORD sheight, swidth;
                DWORD left, top;
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_WIDTH)
                {
                    wwidth = lpnmud->iPos + lpnmud->iDelta;
                }
                else
                {
                    wwidth = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH, NULL, FALSE);
                }
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_HEIGHT)
                {
                    wheight = lpnmud->iPos + lpnmud->iDelta;
                }
                else
                {
                    wheight = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, NULL, FALSE);
                }
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_WIDTH)
                {
                    swidth = lpnmud->iPos + lpnmud->iDelta;
                }
                else
                {
                    swidth = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, NULL, FALSE);
                }
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_HEIGHT)
                {
                    sheight = lpnmud->iPos + lpnmud->iDelta;
                }
                else
                {
                    sheight = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, NULL, FALSE);
                }
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_POS_LEFT)
                {
                    left = lpnmud->iPos + lpnmud->iDelta;
                }
                else
                {
                    left = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, NULL, TRUE);
                }
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_POS_TOP)
                {
                    top = lpnmud->iPos + lpnmud->iDelta;
                }
                else
                {
                    top = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP, NULL, TRUE);
                }
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_WIDTH || lppsn->hdr.idFrom == IDC_UPDOWN_WINDOW_SIZE_HEIGHT)
                {
                    /* Automatically adjust screen buffer size when window size enlarges */
                    if (wwidth >= swidth)
                    {
                        SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, wwidth, TRUE);
                        swidth = wwidth;
                    }
                    if (wheight >= sheight)
                    {
                        SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, wheight, TRUE);
                        sheight = wheight;
                    }
                }
 
                /* Be sure that the (new) screen buffer sizes are in the correct range */
                swidth  = min(max(swidth , 1), 0xFFFF);
                sheight = min(max(sheight, 1), 0xFFFF);
 
                if (lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_WIDTH || lppsn->hdr.idFrom == IDC_UPDOWN_SCREEN_BUFFER_HEIGHT)
                {
                    /* Automatically adjust window size when screen buffer decreases */
                    if (wwidth > swidth)
                    {
                        SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH, swidth, TRUE);
                        wwidth = swidth;
                    }
                    if (wheight > sheight)
                    {
                        SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, sheight, TRUE);
                        wheight = sheight;
                    }
                }
 
                ConInfo->ScreenBufferSize.X = (SHORT)swidth;
                ConInfo->ScreenBufferSize.Y = (SHORT)sheight;
                ConInfo->WindowSize.X = (SHORT)wwidth;
                ConInfo->WindowSize.Y = (SHORT)wheight;
                ConInfo->WindowPosition.x = left;
                ConInfo->WindowPosition.y = top;
 
                InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                PropSheet_Changed(GetParent(hDlg), hDlg);
            }
            break;
        }
 
        case WM_COMMAND:
        {
            if (HIWORD(wParam) == EN_KILLFOCUS)
            {
                switch (LOWORD(wParam))
                {
                case IDC_EDIT_SCREEN_BUFFER_WIDTH:
                {
                    DWORD swidth, wwidth;
 
                    swidth = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, NULL, FALSE);
                    wwidth = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH  , NULL, FALSE);
 
                    /* Be sure that the (new) screen buffer width is in the correct range */
                    swidth = min(max(swidth, 1), 0xFFFF);
 
                    /* Automatically adjust window size when screen buffer decreases */
                    if (wwidth > swidth)
                    {
                        wwidth = swidth;
                        SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH, wwidth, TRUE);
                    }
 
                    ConInfo->ScreenBufferSize.X = (SHORT)swidth;
                    ConInfo->WindowSize.X       = (SHORT)wwidth;
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
 
                case IDC_EDIT_WINDOW_SIZE_WIDTH:
                {
                    DWORD swidth, wwidth;
 
                    swidth = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, NULL, FALSE);
                    wwidth = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_WIDTH  , NULL, FALSE);
 
                    /* Automatically adjust screen buffer size when window size enlarges */
                    if (wwidth >= swidth)
                    {
                        swidth = wwidth;
 
                        /* Be sure that the (new) screen buffer width is in the correct range */
                        swidth = min(max(swidth, 1), 0xFFFF);
 
                        SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_WIDTH, swidth, TRUE);
                    }
 
                    ConInfo->ScreenBufferSize.X = (SHORT)swidth;
                    ConInfo->WindowSize.X       = (SHORT)wwidth;
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
 
                case IDC_EDIT_SCREEN_BUFFER_HEIGHT:
                {
                    DWORD sheight, wheight;
 
                    sheight = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, NULL, FALSE);
                    wheight = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT  , NULL, FALSE);
 
                    /* Be sure that the (new) screen buffer width is in the correct range */
                    sheight = min(max(sheight, 1), 0xFFFF);
 
                    /* Automatically adjust window size when screen buffer decreases */
                    if (wheight > sheight)
                    {
                        wheight = sheight;
                        SetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT, wheight, TRUE);
                    }
 
                    ConInfo->ScreenBufferSize.Y = (SHORT)sheight;
                    ConInfo->WindowSize.Y       = (SHORT)wheight;
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
 
                case IDC_EDIT_WINDOW_SIZE_HEIGHT:
                {
                    DWORD sheight, wheight;
 
                    sheight = GetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, NULL, FALSE);
                    wheight = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_SIZE_HEIGHT  , NULL, FALSE);
 
                    /* Automatically adjust screen buffer size when window size enlarges */
                    if (wheight >= sheight)
                    {
                        sheight = wheight;
 
                        /* Be sure that the (new) screen buffer width is in the correct range */
                        sheight = min(max(sheight, 1), 0xFFFF);
 
                        SetDlgItemInt(hDlg, IDC_EDIT_SCREEN_BUFFER_HEIGHT, sheight, TRUE);
                    }
 
                    ConInfo->ScreenBufferSize.Y = (SHORT)sheight;
                    ConInfo->WindowSize.Y       = (SHORT)wheight;
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
 
                case IDC_EDIT_WINDOW_POS_LEFT:
                case IDC_EDIT_WINDOW_POS_TOP:
                {
                    ConInfo->WindowPosition.x = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, NULL, TRUE);
                    ConInfo->WindowPosition.y = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP , NULL, TRUE);
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                    break;
                }
                }
            }
            else
            if (HIWORD(wParam) == BN_CLICKED &&
                LOWORD(wParam) == IDC_CHECK_SYSTEM_POS_WINDOW)
            {
                if (IsDlgButtonChecked(hDlg, IDC_CHECK_SYSTEM_POS_WINDOW) == BST_CHECKED)
                {
                    EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_LEFT, FALSE);
                    EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_TOP , FALSE);
                    EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, FALSE);
                    EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , FALSE);
 
                    ConInfo->AutoPosition = TRUE;
                    // Do not touch ConInfo->WindowPosition !!
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                }
                else
                {
                    ULONG left, top;
 
                    left = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_LEFT, NULL, TRUE);
                    top  = GetDlgItemInt(hDlg, IDC_EDIT_WINDOW_POS_TOP , NULL, TRUE);
 
                    EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_LEFT, TRUE);
                    EnableDlgItem(hDlg, IDC_EDIT_WINDOW_POS_TOP , TRUE);
                    EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_LEFT, TRUE);
                    EnableDlgItem(hDlg, IDC_UPDOWN_WINDOW_POS_TOP , TRUE);
 
                    ConInfo->AutoPosition     = FALSE;
                    ConInfo->WindowPosition.x = left;
                    ConInfo->WindowPosition.y = top;
 
                    InvalidateRect(GetDlgItem(hDlg, IDC_STATIC_LAYOUT_WINDOW_PREVIEW), NULL, TRUE);
                    PropSheet_Changed(GetParent(hDlg), hDlg);
                }
            }
 
            break;
        }
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by InitApplet().

OptionsProc()

INT_PTR CALLBACK OptionsProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 860 of file magnifier.c.

{
    UNREFERENCED_PARAMETER(lParam);
 
    switch (message)
    {
        case WM_INITDIALOG:
        {
            /* Add the zoom items */
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("1"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("2"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("3"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("4"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("5"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("6"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("7"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("8"));
            SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("9"));
 
            if (uiZoom >= 1 && uiZoom <= 9)
                SendDlgItemMessage(hDlg, IDC_ZOOM, CB_SETCURSEL, uiZoom - 1, 0);
 
            if (bFollowMouse)
                SendDlgItemMessage(hDlg,IDC_FOLLOWMOUSECHECK,BM_SETCHECK, wParam, 0);
 
            if (bFollowFocus)
                SendDlgItemMessage(hDlg,IDC_FOLLOWKEYBOARDCHECK,BM_SETCHECK, wParam, 0);
 
            if (bFollowCaret)
                SendDlgItemMessage(hDlg,IDC_FOLLOWTEXTEDITINGCHECK,BM_SETCHECK, wParam, 0);
 
            if (bInvertColors)
                SendDlgItemMessage(hDlg,IDC_INVERTCOLORSCHECK,BM_SETCHECK, wParam, 0);
 
            if (bStartMinimized)
                SendDlgItemMessage(hDlg,IDC_STARTMINIMIZEDCHECK,BM_SETCHECK, wParam, 0);
 
            if (bShowMagnifier)
                SendDlgItemMessage(hDlg,IDC_SHOWMAGNIFIERCHECK,BM_SETCHECK, wParam, 0);
 
            return (INT_PTR)TRUE;
        }
 
        case WM_SHOWWINDOW:
            bOptionsDialog = wParam;
            break;
 
        case WM_COMMAND:
        switch (LOWORD(wParam))
        {
            case IDOK:
            case IDCANCEL:
                ShowWindow(hDlg, SW_HIDE);
                return (INT_PTR)TRUE;
 
            case IDC_BUTTON_HELP:
                /* Unimplemented */
                MessageBox(hDlg, TEXT("Magnifier help not available yet!"), TEXT("Help"), MB_OK);
                break;
 
            case IDC_ZOOM:
                if (HIWORD(wParam) == CBN_SELCHANGE)
                {
                    HWND hCombo = GetDlgItem(hDlg,IDC_ZOOM);
                    TCHAR currentZoomValue[2] = TEXT("");
 
                    /* Get index of current selection and the text of that selection */
                    int currentSelectionIndex = ComboBox_GetCurSel(hCombo);
                    ComboBox_GetLBText(hCombo, currentSelectionIndex, currentZoomValue);
                    uiZoom = (UINT)_ttoi(currentZoomValue);
                    /* The zoom factor cannot be smaller than 1 (and not zero) or greater than 9 */
                    if (uiZoom < 1 || uiZoom > 9)
                        uiZoom = 1;
 
                    /* Trigger the Draw function to rezoom (which will be set false automatically after rezooming) */
                    bRecreateOffscreenDC = TRUE;
 
                    /* Update the magnifier UI */
                    Refresh();
                }
                break;
 
            case IDC_INVERTCOLORSCHECK:
                bInvertColors = IsDlgButtonChecked(hDlg, IDC_INVERTCOLORSCHECK);
                Refresh();
                break;
            case IDC_FOLLOWMOUSECHECK:
                bFollowMouse = IsDlgButtonChecked(hDlg, IDC_FOLLOWMOUSECHECK);
                break;
            case IDC_FOLLOWKEYBOARDCHECK:
                bFollowFocus = IsDlgButtonChecked(hDlg, IDC_FOLLOWKEYBOARDCHECK);
                break;
            case IDC_FOLLOWTEXTEDITINGCHECK:
                bFollowCaret = IsDlgButtonChecked(hDlg, IDC_FOLLOWTEXTEDITINGCHECK);
                break;
            case IDC_STARTMINIMIZEDCHECK:
                bStartMinimized = IsDlgButtonChecked(hDlg, IDC_STARTMINIMIZEDCHECK);
                break;
            case IDC_SHOWMAGNIFIER:
                bShowMagnifier = IsDlgButtonChecked(hDlg, IDC_SHOWMAGNIFIERCHECK);
                ShowWindow(hMainWnd, (bShowMagnifier ? SW_SHOW : SW_HIDE));
                break;
        }
    }
 
    return (INT_PTR)FALSE;
}

Referenced by InitApplet(), and InitInstance().

PropSheetProc()

static int CALLBACK PropSheetProc ( HWND  hwndDlg, UINT  uMsg, LPARAM  lParam  )

static

Definition at line 137 of file console.c.

{
    // NOTE: This callback is needed to set large icon correctly.
    HICON hIcon;
    switch (uMsg)
    {
        case PSCB_INITIALIZED:
        {
            hIcon = LoadIconW(hApplet, MAKEINTRESOURCEW(IDC_CPLICON));
            SendMessageW(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
            break;
        }
    }
    return 0;
}

Referenced by InitApplet().

Variable Documentation

ConInfo

PCONSOLE_STATE_INFO ConInfo = NULL

Definition at line 23 of file console.c.

Referenced by ApplyConsoleInfo(), ColorsProc(), FontProc(), InitApplet(), LayoutProc(), OptionsProc(), and WinPrevProc().

hApplet

HINSTANCE hApplet = NULL

Definition at line 20 of file console.c.

Referenced by ApplyConsoleInfo(), DllMain(), InitApplet(), InitPropSheetPage(), and PropSheetProc().

SaveConsoleInfo

BOOL SaveConsoleInfo = FALSE

static

Definition at line 26 of file console.c.

Referenced by ApplyConsoleInfo(), and InitApplet().

SetConsoleInfo

BOOL SetConsoleInfo = FALSE

static

Definition at line 25 of file console.c.

Referenced by ApplyConsoleInfo(), and InitApplet().