/*
 *      Copyright (C) 1997-2004 Andrei Los.
 *      This file is part of the lSwitcher source package.
 *      lSwitcher is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published
 *      by the Free Software Foundation, in version 2 as it comes in the
 *      "COPYING" file of the lSwitcher main distribution.
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 */

#include <string.h>
#include <stdio.h>
#include <uconv.h>
#include "prmdlg.h"
#include "settings.h"
#include "lswitch.h"
#include "common.h"
#include "taskbar.h"
#include "lswres.h"

#define BKM_SETNOTEBOOKBUTTONS   0x0375	/* Set common pushbuttons    */
#define STRLISTDIVIDER "}{!@$#%^&*]["

VOID GetIniFileName(UCHAR * ucFName, USHORT usLen)
{

//#ifndef XWORKPLACE
    PPIB ppib;
    UCHAR *p;
    SHORT k;

    DosGetInfoBlocks(NULL, &ppib);

    if ((p =
	 strstr(&ppib->pib_pchcmd[strlen(ppib->pib_pchcmd) + 1],
		"/i")) != NULL
	|| (p =
	    strstr(&ppib->pib_pchcmd[strlen(ppib->pib_pchcmd) + 1],
		   "/I")) != NULL) {
	GetStartupDir(ucFName, usLen);
	for (k = 2; k < strlen(p) && p[k] == ' '; k++) ;	// get rid of leading spaces
	strncat(ucFName, &p[k], usLen - strlen(ucFName) - 1);
    }
    else {
	//strncpy(ucFName, "", usLen);
        //#else
        GetStartupDir(ucFName, usLen);
        strncat(ucFName, DEFINIFNAME, usLen - strlen(ucFName) - 1);
    }
//#endif
}

BOOL CheckSettings(LSWSETTINGS * pSettings)
{
    return (pSettings->ucVerMajor >= LASTINIVERMAJOROK &&
	    pSettings->ucVerMinor >= LASTINIVERMINOROK &&
	    pSettings->ucRevision >= LASTINIREVISIONOK);
}

VOID InitSettings(LSWSETTINGS * pSettings)
{
    CHAR *lang;

    memset(pSettings, 0, sizeof(LSWSETTINGS));
    pSettings->ucVerMajor = VERSIONMAJOR;
    pSettings->ucVerMinor = VERSIONMINOR;
    pSettings->ucRevision = REVISION;
    pSettings->bShowHidden = pSettings->bShowHiddenTskBar = TRUE;
    pSettings->bShowViewer = pSettings->bShowViewerTskBar = TRUE;
    pSettings->bPMSwitcher = TRUE;
    pSettings->bShowInWinList = TRUE;
    pSettings->bShowHints = TRUE;
    pSettings->lBackColor = DEFBACKRGBCOLOR;
    pSettings->lRaisedFrameColor = DEFRAISEDFRAMECOLOR;
    pSettings->lSunkenFrameColor = DEFSUNKENFRAMECOLOR;
    pSettings->lTitleRGBCol = DEFTITLERGBCOLOR;
    pSettings->lHintsRGBCol = DEFHINTSRGBCOLOR;
    pSettings->lBubbleRGBCol = DEFBUBBLERGBCOLOR;
    pSettings->lBubbleTextRGBCol = RGB_BLUE / 2;	//dark blue
    pSettings->bTaskBarOn = TRUE;
    pSettings->bTaskBarAlwaysVisible = TRUE;
    pSettings->bReduceDsk = TRUE;
    pSettings->bFlatButtons = TRUE;
    pSettings->bAllowResize = FALSE;
    pSettings->b3DTaskBar = TRUE;

    pSettings->lTskBarRGBCol3D = DEFTSKBARRGBCOL3D;
    pSettings->lNormalBtnRGBCol3D = pSettings->lNormalHiddenBtnRGBCol3D =
	NORMALBTNRGBCOL3D;
    pSettings->lActiveBtnRGBCol3D = pSettings->lActiveHiddenBtnRGBCol3D =
	ACTIVEBTNRGBCOL3D;
    pSettings->lNormalBtnTitleRGBCol3D = NORMALBTNTITLERGBCOL3D;
    pSettings->lActiveBtnTitleRGBCol3D = ACTIVEBTNTITLERGBCOL3D;
    pSettings->lNormalHiddenBtnTitleRGBCol3D =
	pSettings->lActiveHiddenBtnTitleRGBCol3D = HIDDENBTNTITLERGBCOL3D;

    pSettings->lTskBarRGBCol = DEFTSKBARRGBCOL;
    pSettings->lNormalBtnRGBCol = pSettings->lNormalHiddenBtnRGBCol =
	NORMALBTNRGBCOL;
    pSettings->lActiveBtnRGBCol = pSettings->lActiveHiddenBtnRGBCol =
	ACTIVEBTNRGBCOL;
    pSettings->lNormalBtnTitleRGBCol = NORMALBTNTITLERGBCOL;
    pSettings->lActiveBtnTitleRGBCol = ACTIVEBTNTITLERGBCOL;
    pSettings->lNormalHiddenBtnTitleRGBCol =
	pSettings->lActiveHiddenBtnTitleRGBCol = HIDDENBTNTITLERGBCOL;

    pSettings->sTskBarX = pSettings->sTskBarY = -TSKBARFRAMEWIDTH;
    pSettings->sTskBarCX =
	WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN) + 2 * TSKBARFRAMEWIDTH;
    pSettings->sTskBarCY =
	WinQuerySysValue(HWND_DESKTOP,
			 SV_CYICON) / 2 + 4 + 2 * BUTTONBORDERWIDTH + 2 +
	2 * TSKBARFRAMEWIDTH;
    pSettings->usMaxBtnWid = MAXBUTTONWIDTH;    
    pSettings->usAutoHideDelay = 10;

    pSettings->ucSettingsKey = 'S';
    pSettings->ucSettingsScan = SCAN_SETTINGS;
    pSettings->usSwitchMEvent = WM_BUTTON1CLICK;
    pSettings->usMinMEvent = WM_BUTTON1CLICK;
    pSettings->usCloseMEvent = WM_CHORD;
    pSettings->usScrollDiv = 1;

    lang = getenv("LANG");
    if (lang) {
        if (!strnicmp(lang, "es", 2))
            pSettings->usLanguage = ES;
        else if (!strnicmp(lang, "cs", 2))
            pSettings->usLanguage = CZ;
        else if (!strnicmp(lang, "de", 2))
            pSettings->usLanguage = DE;
        else if (!strnicmp(lang, "ru", 2))
            pSettings->usLanguage = RU;
        else if (!strnicmp(lang, "pl", 2))
            pSettings->usLanguage = PL;
        else
            pSettings->usLanguage = EN;
    }
    else

        pSettings->usLanguage = EN;

    strncpy(pSettings->ucTitleFont, DEFTITLEFONT3,
	    sizeof(pSettings->ucTitleFont));
    strncpy(pSettings->ucHintsFont, DEFHINTSFONT,
	    sizeof(pSettings->ucHintsFont));
    strncpy(pSettings->ucButtonFont, DEFTITLEFONT3,
	    sizeof(pSettings->ucButtonFont));
}

USHORT LoadSettings(HAB hab, PSZ pszFName, LSWSETTINGS * pSettings)
{
    ULONG ulCbBuf, k, ulIndex, ulSize;
    HINI hini;
    BOOL rc;
    BOOL bChangedINI = FALSE;
    BOOL bDividedSettings = FALSE;
    BOOL bIconOnlyToPriority = FALSE;
    UCHAR *pBuf;
    ENTRYNAME SkipStr;
    SKIPLIST *pSkipList;

    if (strlen(pszFName) != 0) {
        if ((hini = PrfOpenProfile(hab, pszFName)) == NULLHANDLE) {
	    return 1;
	}
    }
    else
        return 1; //hini = HINI_USERPROFILE;
    ulSize = sizeof(BOOL);
    rc = PrfQueryProfileData(hini, PRF_APPNAME, "DividedSetting", &bDividedSettings, &ulSize);
    if (!rc || !bDividedSettings) {
        ulCbBuf =
            sizeof(LSWSETTINGS) + 3 * MAXITEMS * sizeof(ENTRYNAME) +
            2 * sizeof(STRLISTDIVIDER);
        if ((pBuf = calloc(1, ulCbBuf)) == NULL)
            return 3;
        rc = PrfQueryProfileData(hini, PRF_APPNAME, PRF_SETTINGS, pBuf, &ulCbBuf);
        if (!rc)  {
            rc = PrfQueryProfileData(HINI_USERPROFILE, PRF_APPNAME, PRF_SETTINGS, pBuf, &ulCbBuf);
            if (pszFName != NULL)
                PrfCloseProfile(hini);
            if (!rc)
                return 2;
            else {
                ulIndex = sizeof(LSWSETTINGS) - 3 * sizeof(pSettings->SkipListPopup);
                memcpy(pSettings, pBuf, ulIndex);
                SaveSettings(hab, pszFName, pSettings);
                PrfWriteProfileData(HINI_USERPROFILE, PRF_APPNAME, NULL, NULL, 0);
                bChangedINI = TRUE;
            }
        }
        if (!bChangedINI) {
            ulIndex = sizeof(LSWSETTINGS) - 3 * sizeof(pSettings->SkipListPopup);
            memcpy(pSettings, pBuf, ulIndex);
            SaveSettings(hab, pszFName, pSettings);
            PrfWriteProfileData(hini, PRF_APPNAME, PRF_SETTINGS, NULL, 0);
        }
    }
    else {
        ulCbBuf = 3 * sizeof(pSettings->SkipListPopup) + 3 * MAXITEMS * sizeof(ENTRYNAME)
            + 2 * sizeof(STRLISTDIVIDER);
        if ((pBuf = calloc(1, ulCbBuf)) == NULL)
            return 3;
        ulSize = sizeof(UCHAR);
        PrfQueryProfileData(hini, PRF_APPNAME, "VerMajor",
                            &pSettings->ucVerMajor, &ulSize);
        ulSize = sizeof(UCHAR);
        PrfQueryProfileData(hini, PRF_APPNAME, "VerMinor",
                            &pSettings->ucVerMinor, &ulSize);
        ulSize = sizeof(UCHAR);
        PrfQueryProfileData(hini, PRF_APPNAME, "Revision",
                            &pSettings->ucRevision, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ShowHidden",
                            &pSettings->bShowHidden, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ShowViewer",
                            &pSettings->bShowViewer, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "PMSwitcher",
                            &pSettings->bPMSwitcher, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "OldPopup",
                            &pSettings->bOldPopup, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "DesktopMinimizes",
                            &pSettings->bDesktopMinimizes, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ScrollItems",
                            &pSettings->bScrollItems, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "PMPopupInFS",
                            &pSettings->bPMPopupInFS, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ShowInWinList",
                            &pSettings->bShowInWinList, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ShowHints",
                            &pSettings->bShowHints, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ChangeZOrder",
                            &pSettings->bChangeZOrder, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "TaskBarOn",
                            &pSettings->bTaskBarOn, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "TaskBarTopScr",
                            &pSettings->bTaskBarTopScr, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "TaskBarAlwaysVisible",
                            &pSettings->bTaskBarAlwaysVisible, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "TaskBarAlwaysTop",
                            &pSettings->bTaskBarAlwaysTop, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "StickyPopup",
                            &pSettings->bStickyPopup, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ShowHiddenTskBar",
                            &pSettings->bShowHiddenTskBar, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ShowViewerTskBar",
                            &pSettings->bShowViewerTskBar, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "IconsOnlyInTskBar",
                            &pSettings->bIconsOnlyInTskBar, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "ReduceDsk",
                            &pSettings->bReduceDsk, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "FlatButtons",
                            &pSettings->bFlatButtons, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "GroupItems",
                            &pSettings->bGroupItems, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "AllowResize",
                            &pSettings->bAllowResize, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "3DTaskBar",
                            &pSettings->b3DTaskBar, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "IconOnlyToPriority",
                            &bIconOnlyToPriority, &ulSize);
        ulSize = sizeof(BOOL);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarGrow",
                            &pSettings->bTskBarGrow, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "BackColor",
                            &pSettings->lBackColor, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "RaisedFrameColor",
                            &pSettings->lRaisedFrameColor, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "SunkenFrameColor",
                            &pSettings->lSunkenFrameColor, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "TitleRGBCol",
                            &pSettings->lTitleRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "HintsRGBCol",
                            &pSettings->lHintsRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarRGBCol",
                            &pSettings->lTskBarRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarRGBCol3D",
                            &pSettings->lTskBarRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalBtnRGBCol",
                            &pSettings->lNormalBtnRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalBtnRGBCol3D",
                            &pSettings->lNormalBtnRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveBtnRGBCol",
                            &pSettings->lActiveBtnRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveBtnRGBCol3D",
                            &pSettings->lActiveBtnRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalHiddenBtnRGBCol",
                            &pSettings->lNormalHiddenBtnRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalHiddenBtnRGBCol3D",
                            &pSettings->lNormalHiddenBtnRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnRGBCol",
                            &pSettings->lActiveHiddenBtnRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnRGBCol3D",
                            &pSettings->lActiveHiddenBtnRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalBtnTitleRGBCol",
                            &pSettings->lNormalBtnTitleRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalBtnTitleRGBCol3D",
                            &pSettings->lNormalBtnTitleRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveBtnTitleRGBCol",
                            &pSettings->lActiveBtnTitleRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveBtnTitleRGBCol3D",
                            &pSettings->lActiveBtnTitleRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalHiddenBtnTitleRGBCol",
                            &pSettings->lNormalHiddenBtnTitleRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "NormalHiddenBtnTitleRGBCol3D",
                            &pSettings->lNormalHiddenBtnTitleRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnTitleRGBCol",
                            &pSettings->lActiveHiddenBtnTitleRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnTitleRGBCol3D",
                            &pSettings->lActiveHiddenBtnTitleRGBCol3D, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "BubbleRGBCol",
                            &pSettings->lBubbleRGBCol, &ulSize);
        ulSize = sizeof(LONG);
        PrfQueryProfileData(hini, PRF_APPNAME, "BubbleTextRGBCol",
                            &pSettings->lBubbleTextRGBCol, &ulSize);
        PrfQueryProfileString(hini, PRF_APPNAME, "TitleFont", DEFTITLEFONT3,
                              &pSettings->ucTitleFont, FACESIZE);
        PrfQueryProfileString(hini, PRF_APPNAME, "HintsFont", DEFHINTSFONT,
                              &pSettings->ucHintsFont, FACESIZE);
        PrfQueryProfileString(hini, PRF_APPNAME, "ButtonFont", DEFTITLEFONT3,
                              &pSettings->ucButtonFont, FACESIZE);
        ulSize = sizeof(UCHAR);
        PrfQueryProfileData(hini, PRF_APPNAME, "SettingsKey",
                            &pSettings->ucSettingsKey, &ulSize);
        ulSize = sizeof(UCHAR);
        PrfQueryProfileData(hini, PRF_APPNAME, "SettingsScan",
                            &pSettings->ucSettingsScan, &ulSize);
        ulSize = sizeof(UCHAR);
        PrfQueryProfileData(hini, PRF_APPNAME, "PopupHotKey",
                            &pSettings->ucPopupHotKey, &ulSize);
        ulSize = sizeof(SHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarX",
                            &pSettings->sTskBarX, &ulSize);
        ulSize = sizeof(SHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarY",
                            &pSettings->sTskBarY, &ulSize);
        ulSize = sizeof(SHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarCX",
                            &pSettings->sTskBarCX, &ulSize);
        ulSize = sizeof(SHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "TskBarCY",
                            &pSettings->sTskBarCY, &ulSize);
        ulSize = sizeof(USHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "MaxBtnWid",
                            &pSettings->usMaxBtnWid, &ulSize);
        ulSize = sizeof(USHORT);
        if (!PrfQueryProfileData(hini, PRF_APPNAME, "AutoHideDelay",
                                 &pSettings->usAutoHideDelay, &ulSize))
            pSettings->usAutoHideDelay = 10;
        ulSize = sizeof(USHORT);                                    
        PrfQueryProfileData(hini, PRF_APPNAME, "SwitchMEvent",
                            &pSettings->usSwitchMEvent, &ulSize);
        ulSize = sizeof(USHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "MinMEvent",
                            &pSettings->usMinMEvent, &ulSize);
        ulSize = sizeof(USHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "CloseMEvent",
                            &pSettings->usCloseMEvent, &ulSize);
        ulSize = sizeof(USHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "ScrollDiv",
                            &pSettings->usScrollDiv, &ulSize);
        ulSize = sizeof(USHORT);
        PrfQueryProfileData(hini, PRF_APPNAME, "Language",
                            &pSettings->usLanguage, &ulSize);
        PrfQueryProfileData(hini, PRF_APPNAME, "SkipLists",
                            pBuf, &ulCbBuf);
        ulIndex = 0;
    }
    if (pszFName != NULL)
	PrfCloseProfile(hini);

    k = 0;
    pSkipList = &pSettings->SkipListPopup;

    while (ulIndex < ulCbBuf) {
	if (sscanf(&pBuf[ulIndex], "%69[^\0]", SkipStr) != 1
	    || strlen(SkipStr) == 0)
	    break;

	ulIndex += strlen(SkipStr) + 1;

	if (strcmp(SkipStr, STRLISTDIVIDER) == 0) {
	    k = 0;
	    if (pSkipList == &pSettings->SkipListPopup)
		pSkipList = &pSettings->SkipListTskBar;
            else {
                if (!bIconOnlyToPriority) {
                    bIconOnlyToPriority  = TRUE;
                    ulSize = sizeof(BOOL);
                    PrfWriteProfileData(hini, PRF_APPNAME, "IconOnlyToPriority",
                                        &bIconOnlyToPriority, ulSize);
                    break;
                }
                else
                    pSkipList = &pSettings->ListPriority;
            }
            continue;
        }
        (*pSkipList)[k++] = strdup(SkipStr);
    }
    if (!bDividedSettings)
        SaveSettings(hab, pszFName, pSettings);
    free(pBuf);

        return 0;
}

USHORT SaveSettings(HAB hab, PSZ pszFName, LSWSETTINGS * pSettings)
{
    USHORT k;
    HINI hini;
    BOOL rc;
    BOOL bDividedSettings = FALSE;
    UCHAR *pBuf;
    ULONG ulCbBuf, ulIndex, ulSize;

    if (strlen(pszFName) != 0) {
	if ((hini = PrfOpenProfile(hab, pszFName)) == NULLHANDLE)
	    return 1;
    }
    else
        return 1;
    ulSize = sizeof(UCHAR);
    PrfWriteProfileData(hini, PRF_APPNAME, "VerMajor", &pSettings->ucVerMajor, ulSize);
    ulSize = sizeof(UCHAR);
    PrfWriteProfileData(hini, PRF_APPNAME, "VerMinor", &pSettings->ucVerMinor, ulSize);
    ulSize = sizeof(UCHAR);
    PrfWriteProfileData(hini, PRF_APPNAME, "Revision", &pSettings->ucRevision, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ShowHidden", &pSettings->bShowHidden, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ShowViewer", &pSettings->bShowViewer, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "PMSwitcher",
                        &pSettings->bPMSwitcher, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "OldPopup",
                        &pSettings->bOldPopup, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "DesktopMinimizes",
                        &pSettings->bDesktopMinimizes, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ScrollItems",
                        &pSettings->bScrollItems, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "PMPopupInFS",
                        &pSettings->bPMPopupInFS, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ShowInWinList",
                        &pSettings->bShowInWinList, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ShowHints",
                        &pSettings->bShowHints, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ChangeZOrder",
                        &pSettings->bChangeZOrder, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "TaskBarOn",
                        &pSettings->bTaskBarOn, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "TaskBarTopScr",
                        &pSettings->bTaskBarTopScr, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "TaskBarAlwaysVisible",
                        &pSettings->bTaskBarAlwaysVisible, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "TaskBarAlwaysTop",
                        &pSettings->bTaskBarAlwaysTop, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "StickyPopup",
                        &pSettings->bStickyPopup, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ShowHiddenTskBar",
                        &pSettings->bShowHiddenTskBar, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ShowViewerTskBar",
                        &pSettings->bShowViewerTskBar, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "IconsOnlyInTskBar",
                        &pSettings->bIconsOnlyInTskBar, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "ReduceDsk",
                        &pSettings->bReduceDsk, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "FlatButtons",
                        &pSettings->bFlatButtons, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "GroupItems",
                        &pSettings->bGroupItems, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "AllowResize",
                        &pSettings->bAllowResize, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "3DTaskBar",
                        &pSettings->b3DTaskBar, ulSize);
    ulSize = sizeof(BOOL);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarGrow",
                        &pSettings->bTskBarGrow, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "BackColor",
                        &pSettings->lBackColor, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "RaisedFrameColor",
                        &pSettings->lRaisedFrameColor, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "SunkenFrameColor",
                        &pSettings->lSunkenFrameColor, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "TitleRGBCol",
                        &pSettings->lTitleRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "HintsRGBCol",
                        &pSettings->lHintsRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarRGBCol",
                        &pSettings->lTskBarRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarRGBCol3D",
                        &pSettings->lTskBarRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalBtnRGBCol",
                        &pSettings->lNormalBtnRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalBtnRGBCol3D",
                        &pSettings->lNormalBtnRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveBtnRGBCol",
                        &pSettings->lActiveBtnRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveBtnRGBCol3D",
                        &pSettings->lActiveBtnRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalHiddenBtnRGBCol",
                        &pSettings->lNormalHiddenBtnRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalHiddenBtnRGBCol3D",
                        &pSettings->lNormalHiddenBtnRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnRGBCol",
                        &pSettings->lActiveHiddenBtnRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnRGBCol3D",
                        &pSettings->lActiveHiddenBtnRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalBtnTitleRGBCol",
                        &pSettings->lNormalBtnTitleRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalBtnTitleRGBCol3D",
                        &pSettings->lNormalBtnTitleRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveBtnTitleRGBCol",
                        &pSettings->lActiveBtnTitleRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveBtnTitleRGBCol3D",
                        &pSettings->lActiveBtnTitleRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalHiddenBtnTitleRGBCol",
                        &pSettings->lNormalHiddenBtnTitleRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "NormalHiddenBtnTitleRGBCol3D",
                        &pSettings->lNormalHiddenBtnTitleRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnTitleRGBCol",
                        &pSettings->lActiveHiddenBtnTitleRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "ActiveHiddenBtnTitleRGBCol3D",
                        &pSettings->lActiveHiddenBtnTitleRGBCol3D, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "BubbleRGBCol",
                        &pSettings->lBubbleRGBCol, ulSize);
    ulSize = sizeof(LONG);
    PrfWriteProfileData(hini, PRF_APPNAME, "BubbleTextRGBCol",
                        &pSettings->lBubbleTextRGBCol, ulSize);
    PrfWriteProfileString(hini, PRF_APPNAME, "TitleFont", pSettings->ucTitleFont);
    PrfWriteProfileString(hini, PRF_APPNAME, "HintsFont", pSettings->ucHintsFont);
    PrfWriteProfileString(hini, PRF_APPNAME, "ButtonFont", pSettings->ucButtonFont);
    ulSize = sizeof(UCHAR);
    PrfWriteProfileData(hini, PRF_APPNAME, "SettingsKey",
                        &pSettings->ucSettingsKey, ulSize);
    ulSize = sizeof(UCHAR);
    PrfWriteProfileData(hini, PRF_APPNAME, "SettingsScan",
                        &pSettings->ucSettingsScan, ulSize);
    ulSize = sizeof(UCHAR);
    PrfWriteProfileData(hini, PRF_APPNAME, "PopupHotKey",
                        &pSettings->ucPopupHotKey, ulSize);
    ulSize = sizeof(SHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarX",
                        &pSettings->sTskBarX, ulSize);
    ulSize = sizeof(SHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarY",
                        &pSettings->sTskBarY, ulSize);
    ulSize = sizeof(SHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarCX",
                        &pSettings->sTskBarCX, ulSize);
    ulSize = sizeof(SHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "TskBarCY",
                        &pSettings->sTskBarCY, ulSize);
    ulSize = sizeof(USHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "MaxBtnWid",
                        &pSettings->usMaxBtnWid, ulSize);
    ulSize = sizeof(USHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "AutoHideDelay",
                        &pSettings->usAutoHideDelay, ulSize);
    ulSize = sizeof(USHORT);                      
    PrfWriteProfileData(hini, PRF_APPNAME, "SwitchMEvent",
                        &pSettings->usSwitchMEvent, ulSize);
    ulSize = sizeof(USHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "MinMEvent",
                        &pSettings->usMinMEvent, ulSize);
    ulSize = sizeof(USHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "CloseMEvent",
                        &pSettings->usCloseMEvent, ulSize);
    ulSize = sizeof(USHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "ScrollDiv",
                        &pSettings->usScrollDiv, ulSize);
    ulSize = sizeof(USHORT);
    PrfWriteProfileData(hini, PRF_APPNAME, "Language",
                        &pSettings->usLanguage, ulSize);
    ulCbBuf = 3 * sizeof(pSettings->SkipListPopup) + 3 * MAXITEMS * sizeof(ENTRYNAME)
        + 2 * sizeof(STRLISTDIVIDER);
    if ((pBuf = calloc(1, ulCbBuf)) == NULL)
	return 3;
    ulIndex = 0;

    for (k = 0; k < MAXITEMS && pSettings->SkipListPopup[k] != NULL; k++) {
	strcat(&pBuf[ulIndex], pSettings->SkipListPopup[k]);
	ulIndex += strlen(pSettings->SkipListPopup[k]) + 1;
    }

    if (pSettings->SkipListTskBar[0] != NULL) {
	strcat(&pBuf[ulIndex], STRLISTDIVIDER);
	ulIndex += strlen(STRLISTDIVIDER) + 1;
	for (k = 0; k < MAXITEMS && pSettings->SkipListTskBar[k] != NULL; k++) {
	    strcat(&pBuf[ulIndex], pSettings->SkipListTskBar[k]);
	    ulIndex += strlen(pSettings->SkipListTskBar[k]) + 1;
	}
    }

    if (pSettings->ListPriority[0] != NULL) {
	strcat(&pBuf[ulIndex], STRLISTDIVIDER);
	ulIndex += strlen(STRLISTDIVIDER) + 1;
	for (k = 0; k < MAXITEMS && pSettings->ListPriority[k] != NULL; k++) {
	    strcat(&pBuf[ulIndex], pSettings->ListPriority[k]);
	    ulIndex += strlen(pSettings->ListPriority[k]) + 1;
	}
    }
    rc = PrfWriteProfileData(hini, PRF_APPNAME, "SkipLists", pBuf, ulIndex);

    free(pBuf);

    if (rc) {
        bDividedSettings = TRUE;
        ulSize = sizeof(BOOL);
        PrfWriteProfileData(hini, PRF_APPNAME, "DividedSetting",
                            &bDividedSettings, ulSize);
        if (pszFName != NULL)
            PrfCloseProfile(hini);
        return 0;
    }
    else
        if (pszFName != NULL)
            PrfCloseProfile(hini);
	return 2;
}

USHORT DeleteSettings(HAB hab, PSZ pszFName)
{
    HINI hini;

    if (strlen(pszFName) != 0) {
	if ((hini = PrfOpenProfile(hab, pszFName)) == NULLHANDLE)
	    return 1;
    }
    else
	hini = HINI_USERPROFILE;

    PrfWriteProfileData(hini, PRF_APPNAME, NULL, NULL, 0);

    if (pszFName != NULL)
	PrfCloseProfile(hini);

    return 0;
}

VOID EditSettings(LSWDATA * plswData)
{
    if (!WinIsWindow(plswData->hab, plswData->hwndParamDlg)) {
	plswData->hwndParamDlg =
	    WinLoadDlg(HWND_DESKTOP, NULLHANDLE, ParmDlgProc,
		       plswData->hmodRes, DLG_PARAMS, plswData);
	if (plswData->hwndParamDlg != NULLHANDLE) {
	    WinSetWindowPos(plswData->hwndParamDlg, HWND_TOP, 0, 0, 0, 0,
			    SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
	    WinProcessDlg(plswData->hwndParamDlg);
	    WinDestroyWindow(plswData->hwndParamDlg);
	}
    }
    else
	WinSetWindowPos(plswData->hwndParamDlg, HWND_TOP, 0, 0, 0, 0,
			SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
}

MRESULT EXPENTRY PopupDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    static BOOL bInit = FALSE;
    LSWDATA *plswData;

    plswData = WinQueryWindowPtr(hwnd, 0);

    switch (msg) {
    case WM_INITDLG:{
        HMQ hmq;
        BOOL bUniCodeFont = FALSE;

            bInit = TRUE;
	    DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
				 PAG_READ | PAG_WRITE);
	    WinSetWindowPtr(hwnd, 0, plswData);

	    WinCheckButton(hwnd,
			   plswData->Settings.ucPopupHotKey ==
			   0 ? RAD_ALTTAB : plswData->Settings.
			   ucPopupHotKey == 1 ? RAD_CTRLTAB : RAD_WINTAB,
			   TRUE);
	    WinCheckButton(hwnd, CHK_PMSWITCHER,
			   plswData->Settings.bPMSwitcher);
	    WinCheckButton(hwnd, CHK_PMPOPUPINFS,
			   plswData->Settings.bPMPopupInFS);
	    WinCheckButton(hwnd, CHK_SCROLL, plswData->Settings.bScrollItems);
	    WinCheckButton(hwnd, CHK_HINTS, plswData->Settings.bShowHints);
	    WinCheckButton(hwnd, CHK_STICKY, plswData->Settings.bStickyPopup);

	    WinEnableControl(hwnd, CHK_PMSWITCHER,
			     (plswData->Settings.ucPopupHotKey == 0));
	    WinEnableControl(hwnd, CHK_SCROLL, !plswData->Settings.bOldPopup);

            if (plswData->Settings.usLanguage == RU) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 866);
                bUniCodeFont = TRUE;
            }
            else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 852);
                bUniCodeFont = TRUE;
            }
            else {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 850);
            }
            SetControlsFont(hwnd, FALSE, bUniCodeFont);
	    DosFreeMem(plswData);
	    bInit = FALSE;
	    return (MRESULT) TRUE;
	}

    case WM_CONTROL:{
	    BOOL bValue;

	    if (bInit)
		break;
	    bValue = WinQueryButtonCheckstate(hwnd, SHORT1FROMMP(mp1));

	    switch (SHORT1FROMMP(mp1)) {

	    case RAD_ALTTAB:
	    case RAD_CTRLTAB:
	    case RAD_WINTAB:{
		    ULONG ulPostCount;

		    if (WinQueryButtonCheckstate(hwnd, RAD_ALTTAB))
			plswData->Settings.ucPopupHotKey = 0;
		    else if (WinQueryButtonCheckstate(hwnd, RAD_CTRLTAB))
			plswData->Settings.ucPopupHotKey = 1;
		    else
			plswData->Settings.ucPopupHotKey = 2;
		    WinEnableControl(hwnd, CHK_PMSWITCHER,
				     (plswData->Settings.ucPopupHotKey == 0));

		    if (plswData->Settings.ucPopupHotKey == 0) {
			DosResetEventSem(plswData->hevCtrlTab, &ulPostCount);
			DosResetEventSem(plswData->hevCtrlTab, &ulPostCount);
		    }
		    else if (plswData->Settings.ucPopupHotKey == 1)
			DosPostEventSem(plswData->hevCtrlTab);
		    else
			DosResetEventSem(plswData->hevCtrlTab, &ulPostCount);

		    break;
		}
	    case CHK_PMSWITCHER:
		plswData->Settings.bPMSwitcher = bValue;
		break;
	    case CHK_SCROLL:
		plswData->Settings.bScrollItems = bValue;
		break;
	    case CHK_HINTS:
		plswData->Settings.bShowHints = bValue;
		break;
	    case CHK_SWDESKTOP:
		plswData->Settings.bDesktopMinimizes = bValue;
		break;
	    case CHK_PMPOPUPINFS:
		plswData->Settings.bPMPopupInFS = bValue;
		break;
	    case CHK_STICKY:
		plswData->Settings.bStickyPopup = bValue;
                break;
	    }

	    break;
	}
    case WM_COMMAND:
	switch (SHORT1FROMMP(mp1)) {
	case DID_OK:
	case DID_CANCEL:
	    WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
	    break;
	default:
	    return WinDefDlgProc(hwnd, msg, mp1, mp2);
	}
	break;

    default:
	return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }
    return 0;
}

MRESULT EXPENTRY ListDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    LSWDATA *plswData;
    SKIPLIST *pSkipList;

    if (msg == WM_INITDLG)
	pSkipList = (SKIPLIST *) PVOIDFROMMP(mp2);
    else {
	plswData = WinQueryWindowPtr(hwnd, 0);
	switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
	case DLG_EXCLUDETSKBAR:
	    pSkipList = &plswData->Settings.SkipListTskBar;
	    break;
	case DLG_EXCLUDEPOPUP:
	    pSkipList = &plswData->Settings.SkipListPopup;
	    break;
	case DLG_PRIORITY:
	    pSkipList = &plswData->Settings.ListPriority;
	    break;
	}
    }

    switch (msg) {
    case WM_INITDLG:{
        HMQ hmq;
        BOOL bUniCodeFont = FALSE;

	    DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
				 PAG_READ | PAG_WRITE);
	    WinSetWindowPtr(hwnd, 0, plswData);
	    WinPostMsg(hwnd, LSWM_UPDATEEXCLUDEDLG,
		       MPFROMSHORT(UPDATEADDEDLIST | UPDATEREMOVEDLIST), 0);
            if (plswData->Settings.usLanguage == RU) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 866);
                bUniCodeFont = TRUE;
            }
            else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 852);
                bUniCodeFont = TRUE;
            }
            else {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 850);
            }
            SetControlsFont(hwnd, FALSE, bUniCodeFont);
	    DosFreeMem(plswData);
            return (MRESULT) TRUE;
	}

    case LSWM_UPDATEEXCLUDEDLG:{
	    PSWBLOCK pswblk;
	    ULONG ulItems, k, j = 0;

	    if (SHORT1FROMMP(mp1) & UPDATEREMOVEDLIST) {
		WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_DELETEALL, 0, 0);
		for (k = 0; (*pSkipList)[k] != NULL; k++)
		    WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_INSERTITEM,
				      MPFROMSHORT(LIT_END),
				      MPFROMP((*pSkipList)[k]));
	    }

	    if (SHORT1FROMMP(mp1) & UPDATEADDEDLIST) {
		WinSendDlgItemMsg(hwnd, LB_ADDED, LM_DELETEALL, 0, 0);
		if ((pswblk =
		     GetSwitchList(WinQueryAnchorBlock(hwnd), TRUE,
                                   &ulItems)) != NULL) {
                    SKIPLIST *pSkipListTemp;

                    pSkipListTemp = calloc(1, sizeof(UCHAR) *  MAXITEMS);
                    if (pSkipListTemp) {
                        for (k = 0; k < ulItems; k++) {
                            if (pswblk->aswentry[k].swctl.uchVisibility ==
                                SWL_VISIBLE
                                && !IsInSkipList(pSkipList,
                                                 pswblk->aswentry[k].swctl.
                                                 szSwtitle)
                                && AddFilter(pSkipListTemp,
                                             pswblk->aswentry[k].swctl.szSwtitle)) {
                                WinSendDlgItemMsg(hwnd, LB_ADDED, LM_INSERTITEM,
                                                  MPFROMSHORT(LIT_END),
                                                  MPFROMP(pswblk->aswentry[k].
                                                          swctl.szSwtitle));
                                j++;
                            }
                        }
                        GetSwitchList(0, FALSE, NULL);
                        for (k = 0; k < j; k++)
                            free((*pSkipListTemp)[k]);
                        free(pSkipListTemp);
                    }
		}
	    }
	    break;
	}

    case WM_COMMAND:{
	    switch (SHORT1FROMMP(mp1)) {
	    case PB_REMOVE:{
		    UCHAR ucName[NAMELEN];
		    SHORT iIndex, k;
		    PSWBLOCK pswblk;
		    ULONG ulItems;

		    if ((pswblk =
			 GetSwitchList(WinQueryAnchorBlock(hwnd), TRUE,
				       &ulItems)) == NULL)
			break;

		    while ((iIndex =
			    (SHORT) WinSendDlgItemMsg(hwnd, LB_REMOVED,
						      LM_QUERYSELECTION,
						      MPFROMSHORT(LIT_FIRST),
						      0)) != LIT_NONE) {
			WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_QUERYITEMTEXT,
					  MPFROM2SHORT(iIndex, NAMELEN),
					  MPFROMP(ucName));
			WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_DELETEITEM,
					  MPFROMSHORT(iIndex), 0);

			for (k = 0; k < ulItems; k++)
			    if (strcmpi
				(ucName,
				 pswblk->aswentry[k].swctl.szSwtitle) == 0
				&& pswblk->aswentry[k].swctl.uchVisibility ==
				SWL_VISIBLE) {

				WinSendDlgItemMsg(hwnd, LB_ADDED,
						  LM_INSERTITEM,
						  MPFROMSHORT(LIT_END),
						  MPFROMP(pswblk->aswentry[k].
							  swctl.szSwtitle));
				break;
			    }
			RemoveFilter(pSkipList, ucName);
		    }
		    GetSwitchList(0, FALSE, NULL);

		    if ((WinQueryWindowUShort(hwnd, QWS_ID) ==
			 DLG_EXCLUDETSKBAR
			 || WinQueryWindowUShort(hwnd,
						 QWS_ID) == DLG_PRIORITY)
			&& plswData->Settings.bTaskBarOn) {

                        WinSendMsg(plswData->hwndTaskBarClient,
                                   LSWM_INITBUTTONS, 0, 0);
		    }

		    break;
		}

	    case PB_ADD:{
		    UCHAR ucName[NAMELEN];
		    SHORT iIndex;

		    WinQueryDlgItemText(hwnd, LB_ADDED, sizeof(ucName),
					MPFROMP(ucName));
		    WinSetDlgItemText(hwnd, LB_ADDED, NULL);

		    if (!AddFilter(pSkipList, ucName))
			break;

		    iIndex =
			(SHORT) WinSendDlgItemMsg(hwnd, LB_ADDED,
						  LM_SEARCHSTRING,
						  MPFROM2SHORT(0, LIT_FIRST),
						  MPFROMP(ucName));
		    if (iIndex != LIT_NONE && iIndex != LIT_ERROR)
			WinSendDlgItemMsg(hwnd, LB_ADDED, LM_DELETEITEM,
					  MPFROMSHORT(iIndex), 0);
		    WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_INSERTITEM,
				      MPFROMSHORT(LIT_END), MPFROMP(ucName));

		    if ((WinQueryWindowUShort(hwnd, QWS_ID) ==
			 DLG_EXCLUDETSKBAR
			 || WinQueryWindowUShort(hwnd,
						 QWS_ID) == DLG_PRIORITY)
			&& plswData->Settings.bTaskBarOn)
			WinPostMsg(plswData->hwndTaskBarClient,
                                   LSWM_INITBUTTONS, 0, 0);

		    break;
		}

	    case DID_OK:
	    case DID_CANCEL:
		WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
                break;
	    default:
		return WinDefDlgProc(hwnd, msg, mp1, mp2);

	    }
	    break;
	}

    case WM_CONTROL:
	if ((SHORT1FROMMP(mp1) == LB_ADDED && SHORT2FROMMP(mp1) == CBN_ENTER)
	    || (SHORT1FROMMP(mp1) == LB_REMOVED
		&& SHORT2FROMMP(mp1) == LN_ENTER))
	    WinPostMsg(hwnd, WM_COMMAND,
		       SHORT1FROMMP(mp1) ==
		       LB_ADDED ? (MPARAM) PB_ADD : (MPARAM) PB_REMOVE,
		       MPFROM2SHORT(CMDSRC_OTHER, FALSE));
	break;

    default:
	return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }

    return (MRESULT) 0;
}
#if 0
MRESULT EXPENTRY PriorityDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    LSWDATA *plswData;
    SKIPLIST *pSkipList;

    if (msg == WM_INITDLG)
	pSkipList = (SKIPLIST *) PVOIDFROMMP(mp2);
    else {
        plswData = WinQueryWindowPtr(hwnd, 0);
        pSkipList = &plswData->Settings.ListPriority;
    }

    switch (msg) {
    case WM_INITDLG:{
        HMQ hmq;
        BOOL bUniCodeFont = FALSE;

	    DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
				 PAG_READ | PAG_WRITE);
	    WinSetWindowPtr(hwnd, 0, plswData);
	    WinPostMsg(hwnd, LSWM_UPDATEEXCLUDEDLG,
		       MPFROMSHORT(UPDATEADDEDLIST | UPDATEREMOVEDLIST), 0);
            if (plswData->Settings.usLanguage == RU) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 866);
                bUniCodeFont = TRUE;
            }
            else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 852);
                bUniCodeFont = TRUE;
            }
            else {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 850);
            }
            SetControlsFont(hwnd, FALSE, bUniCodeFont);
	    DosFreeMem(plswData);
            return (MRESULT) TRUE;
	}

    case LSWM_UPDATEEXCLUDEDLG:{
	    PSWBLOCK pswblk;
	    ULONG ulItems, k, j = 0;

	    if (SHORT1FROMMP(mp1) & UPDATEREMOVEDLIST) {
		WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_DELETEALL, 0, 0);
		for (k = 0; (*pSkipList)[k] != NULL; k++)
		    WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_INSERTITEM,
				      MPFROMSHORT(LIT_END),
				      MPFROMP((*pSkipList)[k]));
	    }

	    if (SHORT1FROMMP(mp1) & UPDATEADDEDLIST) {
		WinSendDlgItemMsg(hwnd, LB_ADDED, LM_DELETEALL, 0, 0);
		if ((pswblk =
		     GetSwitchList(WinQueryAnchorBlock(hwnd), TRUE,
                                   &ulItems)) != NULL) {
                    SKIPLIST *pSkipListTemp;

                    pSkipListTemp = calloc(1, sizeof(UCHAR) *  MAXITEMS);
                    if (pSkipListTemp) {
                        for (k = 0; k < ulItems; k++) {
                            if (pswblk->aswentry[k].swctl.uchVisibility ==
                                SWL_VISIBLE
                                && !IsInSkipList(pSkipList, // Have PID need module name
                                                 pswblk->aswentry[k].swctl.
                                                 szSwtitle)
                                && AddFilter(pSkipListTemp,
                                             pswblk->aswentry[k].swctl.szSwtitle)) {
                                WinSendDlgItemMsg(hwnd, LB_ADDED, LM_INSERTITEM,
                                                  MPFROMSHORT(LIT_END),
                                                  MPFROMP(pswblk->aswentry[k].
                                                          swctl.szSwtitle));
                                j++;
                            }
                        }
                        GetSwitchList(0, FALSE, NULL);
                        for (k = 0; k < j; k++)
                            free((*pSkipListTemp)[k]);
                        free(pSkipListTemp);
                    }
		}
	    }
	    break;
	}

    case WM_COMMAND:{
	    switch (SHORT1FROMMP(mp1)) {
	    case PB_REMOVE:{
		    UCHAR ucName[NAMELEN];
		    SHORT iIndex, k;
		    PSWBLOCK pswblk;
		    ULONG ulItems;

		    if ((pswblk =
			 GetSwitchList(WinQueryAnchorBlock(hwnd), TRUE,
				       &ulItems)) == NULL)
			break;

		    while ((iIndex =
			    (SHORT) WinSendDlgItemMsg(hwnd, LB_REMOVED,
						      LM_QUERYSELECTION,
						      MPFROMSHORT(LIT_FIRST),
						      0)) != LIT_NONE) {
			WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_QUERYITEMTEXT,
					  MPFROM2SHORT(iIndex, NAMELEN),
					  MPFROMP(ucName));
			WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_DELETEITEM,
					  MPFROMSHORT(iIndex), 0);

			for (k = 0; k < ulItems; k++)
			    if (strcmpi
				(ucName,
				 pswblk->aswentry[k].swctl.szSwtitle) == 0
				&& pswblk->aswentry[k].swctl.uchVisibility ==
				SWL_VISIBLE) {

				WinSendDlgItemMsg(hwnd, LB_ADDED,
						  LM_INSERTITEM,
						  MPFROMSHORT(LIT_END),
						  MPFROMP(pswblk->aswentry[k].
							  swctl.szSwtitle));
				break;
			    }
			RemoveFilter(pSkipList, ucName);
		    }
		    GetSwitchList(0, FALSE, NULL);

		    if ((WinQueryWindowUShort(hwnd, QWS_ID) ==
			 DLG_EXCLUDETSKBAR
			 || WinQueryWindowUShort(hwnd,
						 QWS_ID) == DLG_PRIORITY)
			&& plswData->Settings.bTaskBarOn) {

                        WinSendMsg(plswData->hwndTaskBarClient,
                                   LSWM_INITBUTTONS, 0, 0);
		    }

		    break;
		}

	    case PB_ADD:{
		    UCHAR ucName[NAMELEN];
		    SHORT iIndex;

		    WinQueryDlgItemText(hwnd, LB_ADDED, sizeof(ucName),
					MPFROMP(ucName));
		    WinSetDlgItemText(hwnd, LB_ADDED, NULL);

		    if (!AddFilter(pSkipList, ucName))
			break;

		    iIndex =
			(SHORT) WinSendDlgItemMsg(hwnd, LB_ADDED,
						  LM_SEARCHSTRING,
						  MPFROM2SHORT(0, LIT_FIRST),
						  MPFROMP(ucName));
		    if (iIndex != LIT_NONE && iIndex != LIT_ERROR)
			WinSendDlgItemMsg(hwnd, LB_ADDED, LM_DELETEITEM,
					  MPFROMSHORT(iIndex), 0);
		    WinSendDlgItemMsg(hwnd, LB_REMOVED, LM_INSERTITEM,
				      MPFROMSHORT(LIT_END), MPFROMP(ucName));

		    if ((WinQueryWindowUShort(hwnd, QWS_ID) ==
			 DLG_EXCLUDETSKBAR
			 || WinQueryWindowUShort(hwnd,
						 QWS_ID) == DLG_PRIORITY)
			&& plswData->Settings.bTaskBarOn)
			WinPostMsg(plswData->hwndTaskBarClient,
                                   LSWM_INITBUTTONS, 0, 0);

		    break;
		}

	    case DID_OK:
	    case DID_CANCEL:
		WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
                break;
	    default:
		return WinDefDlgProc(hwnd, msg, mp1, mp2);

	    }
	    break;
	}

    case WM_CONTROL:
	if ((SHORT1FROMMP(mp1) == LB_ADDED && SHORT2FROMMP(mp1) == CBN_ENTER)
	    || (SHORT1FROMMP(mp1) == LB_REMOVED
		&& SHORT2FROMMP(mp1) == LN_ENTER))
	    WinPostMsg(hwnd, WM_COMMAND,
		       SHORT1FROMMP(mp1) ==
		       LB_ADDED ? (MPARAM) PB_ADD : (MPARAM) PB_REMOVE,
		       MPFROM2SHORT(CMDSRC_OTHER, FALSE));
	break;

    default:
	return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }

    return (MRESULT) 0;
}
#endif
MRESULT EXPENTRY TaskBarDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    static BOOL bInit = FALSE;
    LSWDATA *plswData;

    plswData = WinQueryWindowPtr(hwnd, 0);

    switch (msg) {
    case WM_INITDLG:{
        HMQ hmq;
        BOOL bUniCodeFont = FALSE;

            bInit = TRUE;

	    DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
				 PAG_READ | PAG_WRITE);
	    WinSetWindowPtr(hwnd, 0, plswData);

#ifndef XWORKPLACE
	    WinCheckButton(hwnd, CHK_TASKBARON,
			   plswData->Settings.bTaskBarOn);
	    WinCheckButton(hwnd, CHK_TASKBARALWAYSVISIBLE,
			   !plswData->Settings.bTaskBarAlwaysVisible);
	    WinCheckButton(hwnd,
			   plswData->Settings.
			   bTaskBarTopScr ? RAD_TOP : RAD_BOTTOM, TRUE);
	    WinCheckButton(hwnd, CHK_REDUCEDSK,
			   plswData->Settings.bReduceDsk);
	    WinCheckButton(hwnd, CHK_FLATBTN,
			   plswData->Settings.bFlatButtons);
	    WinCheckButton(hwnd, CHK_ALLOWRESIZE,
			   plswData->Settings.bAllowResize);
	    WinCheckButton(hwnd, CHK_TSKBARGROW,
			   plswData->Settings.bTskBarGrow);
            if (!plswData->Settings.bTaskBarAlwaysVisible )
                WinEnableControl(hwnd, CHK_REDUCEDSK,FALSE);
            else
                WinEnableControl(hwnd, CHK_REDUCEDSK,TRUE);
            WinEnableControl(hwnd, SPIN_AUTOHIDEDELAY,TRUE);
                            // !plswData->Settings.bTaskBarAlwaysVisible);
#else
	    WinEnableControl(hwnd, CHK_TASKBARON, FALSE);
	    WinEnableControl(hwnd, CHK_TASKBARALWAYSVISIBLE, FALSE);
	    WinEnableControl(hwnd, RAD_TOP, FALSE);
	    WinEnableControl(hwnd, RAD_BOTTOM, FALSE);
	    WinEnableControl(hwnd, CHK_REDUCEDSK, FALSE);
            WinEnableControl(hwnd, CHK_FLATBTN, FALSE);
            WinEnableControl(hwnd, CHK_ALLOWRESIZE, FALSE);
            WinEnableControl(hwnd, CHK_TSKBARGROW, FALSE);
            WinEnableControl(hwnd, SPIN_AUTOHIDEDELAY, FALSE);
#endif
            
	    WinEnableControl(hwnd, SPIN_BTNWID,
                             !plswData->Settings.bIconsOnlyInTskBar);
            if (plswData->Settings.bTskBarGrow)
                WinEnableControl(hwnd, CHK_ALLOWRESIZE, FALSE);

	    WinCheckButton(hwnd, CHK_GROUPITEMS,
			   plswData->Settings.bGroupItems);
	    WinCheckButton(hwnd, CHK_ICONSONLYTSKBAR, plswData->Settings.bIconsOnlyInTskBar);
	    WinCheckButton(hwnd, CHK_3DTASKBAR,
			   plswData->Settings.b3DTaskBar);

	    WinSendDlgItemMsg(hwnd, SPIN_BTNWID, SPBM_SETLIMITS,
                              MPFROMLONG(MAXBUTTONWIDTH > WinQuerySysValue(HWND_DESKTOP,
                                                                           SV_CXSCREEN) ?
                                         WinQuerySysValue(HWND_DESKTOP,SV_CXSCREEN) :
                                         MAXBUTTONWIDTH),
			      MPFROMLONG(WinQuerySysValue
					 (HWND_DESKTOP,
					  SV_CYICON) / 2 +
					 2 * BUTTONBORDERWIDTH + 2 +
                                         2 * TSKBARFRAMEWIDTH));
	    WinSendDlgItemMsg(hwnd, SPIN_BTNWID, SPBM_SETTEXTLIMIT,
                              MPFROMSHORT(3), 0);
	    WinSendDlgItemMsg(hwnd, SPIN_BTNWID, SPBM_SETCURRENTVALUE,
			      MPFROMLONG(plswData->Settings.usMaxBtnWid), 0);
            WinSendDlgItemMsg(hwnd, SPIN_AUTOHIDEDELAY, SPBM_SETLIMITS,
                              MPFROMLONG(50),MPFROMLONG(1));
            WinSendDlgItemMsg(hwnd, SPIN_AUTOHIDEDELAY, SPBM_SETCURRENTVALUE,
                              MPFROMLONG(plswData->Settings.usAutoHideDelay), 0);
            WinSendDlgItemMsg(hwnd, SPIN_AUTOHIDEDELAY, SPBM_SETTEXTLIMIT,
	        	      MPFROMSHORT(3), 0);

            if (plswData->Settings.usLanguage == RU) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 866);
                bUniCodeFont = TRUE;
            }
            else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 852);
                bUniCodeFont = TRUE;
            }
            else {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 850);
            }
	    SetControlsFont(hwnd, FALSE, bUniCodeFont);
	    DosFreeMem(plswData);
	    bInit = FALSE;
	    return (MRESULT) TRUE;
	}
    case WM_CONTROL:{
	    BOOL bValue;

	    if (bInit)
		break;
	    bValue = WinQueryButtonCheckstate(hwnd, SHORT1FROMMP(mp1));

	    switch (SHORT1FROMMP(mp1)) {
	    case SPIN_BTNWID:
		if (SHORT2FROMMP(mp1) == SPBN_CHANGE) {
		    ULONG ulBtnWid;
		    SWP swp;

		    WinSendDlgItemMsg(hwnd, SPIN_BTNWID, SPBM_QUERYVALUE,
				      MPFROMP(&ulBtnWid), MPFROM2SHORT(0,
								       SPBQ_ALWAYSUPDATE));
		    plswData->Settings.usMaxBtnWid = (USHORT) ulBtnWid;
		    WinQueryWindowPos(plswData->hwndTaskBarClient, &swp);
		    WinPostMsg(plswData->hwndTaskBarClient, WM_SIZE,
			       MPFROM2SHORT(swp.cx, swp.cy),
			       MPFROM2SHORT(swp.cx, swp.cy));
		}
		break;
#ifndef XWORKPLACE
	    case SPIN_AUTOHIDEDELAY:
		if (SHORT2FROMMP(mp1) == SPBN_CHANGE) {
		    ULONG ulAutoHideDelay;
		    SWP swp;

		    WinSendDlgItemMsg(hwnd, SPIN_AUTOHIDEDELAY, SPBM_QUERYVALUE,
                                      MPFROMP(&ulAutoHideDelay),
                                      MPFROM2SHORT(0, SPBQ_ALWAYSUPDATE));
                    plswData->Settings.usAutoHideDelay =
                        (USHORT) ulAutoHideDelay;
		}
		break;
	    case CHK_TASKBARON:
		plswData->Settings.bTaskBarOn = bValue;
		if (bValue)
		    InitTaskBar(plswData, NULL, 0);
		else
		    DoneTaskBar(plswData);
		break;
#endif
            case CHK_ICONSONLYTSKBAR:
                plswData->Settings.bIconsOnlyInTskBar = bValue;
                WinSendMsg(plswData->hwndTaskBarClient, LSWM_INITBUTTONS, 0, 0);
                WinEnableControl(hwnd, SPIN_BTNWID,
                                 !plswData->Settings.bIconsOnlyInTskBar);
                break;
#ifndef XWORKPLACE
	    case CHK_TASKBARALWAYSVISIBLE:
		plswData->Settings.bTaskBarAlwaysVisible = !bValue;
                if (!plswData->Settings.bTaskBarAlwaysVisible) {
                    if (plswData->Settings.bReduceDsk)
                        UpdateDesktopWorkarea(plswData, TRUE);
                    WinCheckButton(hwnd, CHK_REDUCEDSK, FALSE);
                    plswData->Settings.bReduceDsk = FALSE;
                }
                WinShowWindow(plswData->hwndTaskBar, !bValue);

		break;

	    case CHK_REDUCEDSK:
                plswData->Settings.bReduceDsk = bValue;
                if (!plswData->Settings.bAllowResize &&
                    !plswData->Settings.bTskBarGrow)
                    UpdateDesktopWorkarea(plswData, !bValue);
                else
                    UpdateDesktopWorkarea(plswData, TRUE);

		break;
 #endif
	    case CHK_FLATBTN:
		plswData->Settings.bFlatButtons = bValue;
		WinInvalidateRect(plswData->hwndTaskBar, NULL, TRUE);
		break;

	    case CHK_3DTASKBAR:
		plswData->Settings.b3DTaskBar = bValue;
		WinInvalidateRect(plswData->hwndTaskBarClient, NULL, TRUE);
		break;

            case CHK_GROUPITEMS:
		plswData->Settings.bGroupItems = bValue;
                WinSendMsg(plswData->hwndTaskBarClient, LSWM_INITBUTTONS, 0, 0);
		break;
#ifndef XWORKPLACE
	    case CHK_ALLOWRESIZE:{
		    ULONG flFrameFlags =
			WinQueryWindowULong(plswData->hwndTaskBar, QWL_STYLE);

                    plswData->Settings.bAllowResize = bValue;
                    if (plswData->Settings.bAllowResize) {
                        //if (plswData->Settings.bReduceDsk)
                            UpdateDesktopWorkarea(plswData, TRUE);
                        /*WinCheckButton(hwnd, CHK_REDUCEDSK, FALSE);
                        plswData->Settings.bReduceDsk = FALSE;*/
                    }
                    else {
                        if (plswData->Settings.bTaskBarAlwaysVisible)
                            UpdateDesktopWorkarea(plswData, FALSE);
                    }
		    if (bValue) {
			flFrameFlags &= ~FS_BORDER;
			flFrameFlags |= FS_SIZEBORDER;
		    }
		    else {
			flFrameFlags &= ~FS_SIZEBORDER;
			flFrameFlags |= FS_BORDER;
		    }
		    WinSetWindowULong(plswData->hwndTaskBar, QWL_STYLE,
				      flFrameFlags);
		    break;
		}
            case CHK_TSKBARGROW:{
                ULONG flFrameFlags =
			WinQueryWindowULong(plswData->hwndTaskBar, QWL_STYLE);
		    plswData->Settings.bTskBarGrow = bValue;
                    WinEnableControl(hwnd, CHK_ALLOWRESIZE, !bValue);
                    //WinCheckButton(hwnd, CHK_ALLOWRESIZE, !bValue);
                    plswData->Settings.bAllowResize = !bValue;
                    if (!bValue) {
			flFrameFlags &= ~FS_BORDER;
			flFrameFlags |= FS_SIZEBORDER;
		    }
		    else {
			flFrameFlags &= ~FS_SIZEBORDER;
			flFrameFlags |= FS_BORDER;
		    }
		    if (bValue) {
                        WinPostMsg(plswData->hwndTaskBarClient, WM_SIZE, 0, 0);
                        //if (plswData->Settings.bReduceDsk)
                            UpdateDesktopWorkarea(plswData, TRUE);
                        /*WinCheckButton(hwnd, CHK_REDUCEDSK, FALSE);
                        plswData->Settings.bReduceDsk = FALSE;*/
		    }
                    else {
			WinSetWindowPos(plswData->hwndTaskBar, 0, 0, 0,
					WinQuerySysValue(HWND_DESKTOP,
							 SV_CXSCREEN) +
					2 * TSKBARFRAMEWIDTH,
					plswData->Settings.sTskBarCY,
                                        SWP_SIZE);
                        if (plswData->Settings.bTaskBarAlwaysVisible)
                            UpdateDesktopWorkarea(plswData, FALSE);
                    }
		    break;
		}
	    case RAD_TOP:
	    case RAD_BOTTOM:
		plswData->Settings.bTaskBarTopScr =
		    WinQueryButtonCheckstate(hwnd, RAD_TOP);
		if (plswData->Settings.bTaskBarTopScr)
		    plswData->Settings.sTskBarY =
			WinQuerySysValue(HWND_DESKTOP,
					 SV_CYSCREEN) -
			plswData->Settings.sTskBarCY + TSKBARFRAMEWIDTH;
		else
		    plswData->Settings.sTskBarY = -TSKBARFRAMEWIDTH;

		WinSetWindowPos(plswData->hwndTaskBar, 0,
				plswData->Settings.sTskBarX,
				plswData->Settings.sTskBarY,
				plswData->Settings.sTskBarCX,
				plswData->Settings.sTskBarCY, SWP_MOVE);
                break;
#endif
            }
#ifndef XWORKPLACE
            if (!plswData->Settings.bTaskBarAlwaysVisible)  {
                WinEnableControl(hwnd, CHK_REDUCEDSK,FALSE);
            }
            else {
                WinEnableControl(hwnd, CHK_REDUCEDSK,TRUE);
            }
#endif
	    break;
	}
    case WM_COMMAND:
	switch (SHORT1FROMMP(mp1)) {
	case DID_OK:
	case DID_CANCEL:
	    WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
	    break;
	default:
	    return WinDefDlgProc(hwnd, msg, mp1, mp2);
	}
	break;

    default:
	return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }
    return 0;
}

MRESULT EXPENTRY MouseDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    static BOOL bInit = FALSE;
    LSWDATA *plswData;

    plswData = WinQueryWindowPtr(hwnd, 0);

    switch (msg) {
    case WM_INITDLG:{
	    ULONG ulMenuEvent;
            USHORT usEvent;
            HMQ hmq;
            BOOL bUniCodeFont = FALSE;

	    bInit = TRUE;

	    DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
				 PAG_READ | PAG_WRITE);
	    WinSetWindowPtr(hwnd, 0, plswData);

	    usEvent = plswData->Settings.usSwitchMEvent;
	    WinCheckButton(hwnd, usEvent == WM_BUTTON1CLICK ? RAD_SWMBTN1 :
			   usEvent == WM_BUTTON2CLICK ? RAD_SWMBTN2 :
			   usEvent ==
			   WM_BUTTON3CLICK ? RAD_SWMBTN3 : RAD_SWMBTN12,
			   TRUE);

	    usEvent = plswData->Settings.usMinMEvent;
	    WinCheckButton(hwnd, usEvent == WM_BUTTON1CLICK ? RAD_MINMBTN1 :
			   usEvent == WM_BUTTON2CLICK ? RAD_MINMBTN2 :
			   usEvent ==
			   WM_BUTTON3CLICK ? RAD_MINMBTN3 : RAD_MINMBTN12,
			   TRUE);

	    usEvent = plswData->Settings.usCloseMEvent;
	    WinCheckButton(hwnd, usEvent == WM_BUTTON1CLICK ? RAD_CLOSEMBTN1 :
			   usEvent == WM_BUTTON2CLICK ? RAD_CLOSEMBTN2 :
			   usEvent ==
			   WM_BUTTON3CLICK ? RAD_CLOSEMBTN3 : RAD_CLOSEMBTN12,
			   TRUE);

	    if (WinQuerySysValue(HWND_DESKTOP, SV_CMOUSEBUTTONS) < 3) {
		WinEnableControl(hwnd, RAD_SWMBTN3, FALSE);
		WinEnableControl(hwnd, RAD_MINMBTN3, FALSE);
		WinEnableControl(hwnd, RAD_CLOSEMBTN3, FALSE);
	    }
	    ulMenuEvent = WinQuerySysValue(HWND_DESKTOP, SV_CONTEXTMENU);
	    if (LOUSHORT(ulMenuEvent) == WM_BUTTON1CLICK
		&& HIUSHORT(ulMenuEvent) == 0) {
		WinEnableControl(hwnd, RAD_SWMBTN1, FALSE);
		WinEnableControl(hwnd, RAD_MINMBTN1, FALSE);
		WinEnableControl(hwnd, RAD_CLOSEMBTN1, FALSE);
	    }
	    else if (LOUSHORT(ulMenuEvent) == WM_BUTTON2CLICK
		     && HIUSHORT(ulMenuEvent) == 0) {
		WinEnableControl(hwnd, RAD_SWMBTN2, FALSE);
		WinEnableControl(hwnd, RAD_MINMBTN2, FALSE);
		WinEnableControl(hwnd, RAD_CLOSEMBTN2, FALSE);
	    }

            if (plswData->Settings.usLanguage == RU) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 866);
                bUniCodeFont = TRUE;
            }
            else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 852);
                bUniCodeFont = TRUE;
            }
            else {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 850);
            }
	    SetControlsFont(hwnd, FALSE, bUniCodeFont);
	    DosFreeMem(plswData);
	    bInit = FALSE;
	    return (MRESULT) TRUE;
	}
    case WM_CONTROL:{

	    if (bInit)
		break;
	    switch (SHORT1FROMMP(mp1)) {
	    case RAD_SWMBTN1:
	    case RAD_SWMBTN2:
	    case RAD_SWMBTN3:
	    case RAD_SWMBTN12:
		plswData->Settings.usSwitchMEvent =
		    (WinQueryButtonCheckstate(hwnd, RAD_SWMBTN1) ?
		     WM_BUTTON1CLICK : WinQueryButtonCheckstate(hwnd,
								RAD_SWMBTN2) ?
		     WM_BUTTON2CLICK : WinQueryButtonCheckstate(hwnd,
								RAD_SWMBTN3) ?
		     WM_BUTTON3CLICK : WM_CHORD);
		break;

	    case RAD_MINMBTN1:
	    case RAD_MINMBTN2:
	    case RAD_MINMBTN3:
	    case RAD_MINMBTN12:
		plswData->Settings.usMinMEvent =
		    (WinQueryButtonCheckstate(hwnd, RAD_MINMBTN1) ?
		     WM_BUTTON1CLICK : WinQueryButtonCheckstate(hwnd,
								RAD_MINMBTN2)
		     ? WM_BUTTON2CLICK : WinQueryButtonCheckstate(hwnd,
								  RAD_MINMBTN3)
		     ? WM_BUTTON3CLICK : WM_CHORD);
		break;

	    case RAD_CLOSEMBTN1:
	    case RAD_CLOSEMBTN2:
	    case RAD_CLOSEMBTN3:
	    case RAD_CLOSEMBTN12:
		plswData->Settings.usCloseMEvent =
		    (WinQueryButtonCheckstate(hwnd, RAD_CLOSEMBTN1) ?
		     WM_BUTTON1CLICK : WinQueryButtonCheckstate(hwnd,
								RAD_CLOSEMBTN2)
		     ? WM_BUTTON2CLICK : WinQueryButtonCheckstate(hwnd,
								  RAD_CLOSEMBTN3)
		     ? WM_BUTTON3CLICK : WM_CHORD);
		break;
	    }

	    break;
	}
    case WM_COMMAND:
	switch (SHORT1FROMMP(mp1)) {
	case DID_OK:
	case DID_CANCEL:
	    WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
	    break;
	default:
	    return WinDefDlgProc(hwnd, msg, mp1, mp2);
	}
	break;

    default:
	return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }
    return 0;
}

MRESULT EXPENTRY HotkeyWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    switch (msg) {
    case WM_CHAR:
	if (SHORT1FROMMP(mp1) & KC_CHAR)
	    WinSendMsg(WinQueryWindow(hwnd, QW_OWNER), WM_CONTROL,
		       MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID),
				    EN_SCANCODE),
		       MPFROMCHAR(CHAR4FROMMP(mp1)));
    default:
	return (((PFNWP) WinQueryWindowPtr(hwnd, 0)) (hwnd, msg, mp1, mp2));
    }
}

MRESULT EXPENTRY MiscDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    static BOOL bInit;
    LSWDATA *plswData;
    static USHORT usLangArr[128];

    plswData = WinQueryWindowPtr(hwnd, 0);

    switch (msg) {
    case WM_INITDLG:{
	    static UCHAR ucDllName[_MAX_PATH], ucLangStr[300];
            USHORT usLang;
            HMQ hmq;
            BOOL indexstarted = FALSE;
#if 1
            UniChar     target[300];
            UconvObject     uconv_object866 = NULL;
            UconvObject     uconv_object852 = NULL;
            UconvObject     uconv_object1207 = NULL;
            UconvObject     uconv_object850 = NULL;
            int result;
            int i;
            HAB hab;
#endif
	    bInit = TRUE;
	    SetControlsFont(hwnd, FALSE, TRUE);
	    DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
				 PAG_READ | PAG_WRITE);
	    WinSetWindowPtr(hwnd, 0, plswData);

	    WinCheckButton(hwnd, CHK_SWDESKTOP,
			   plswData->Settings.bDesktopMinimizes);
#ifndef XWORKPLACE
	    WinCheckButton(hwnd, CHK_SHOWINWINLIST,
			   plswData->Settings.bShowInWinList);
#else
	    WinEnableControl(hwnd, CHK_SHOWINWINLIST, FALSE);
#endif
	    WinCheckButton(hwnd, CHK_ZORDER,
			   plswData->Settings.bChangeZOrder);

	    WinSendDlgItemMsg(hwnd, EF_HOTKEY, EM_SETTEXTLIMIT,
			      MPFROMSHORT(1), 0);
	    WinSetDlgItemText(hwnd, EF_HOTKEY,
			      &plswData->Settings.ucSettingsKey);
#if 1
            hmq = WinQueryWindowULong( WinWindowFromID(hwnd, COMBO_LANG), QWL_HMQ);
            WinSetCp(hmq, 1207); // UPF-8 Unicode
            result = UniCreateUconvObject((UniChar *)L"IBM-852", &uconv_object852);
            result = UniCreateUconvObject((UniChar *)L"IBM-850", &uconv_object850);
            result = UniCreateUconvObject((UniChar *)L"IBM-866", &uconv_object866);
            UniCreateUconvObject((UniChar *)L"IBM-1207", &uconv_object1207);
            for (i = 0; i < CHK_END - 300; i++) {
                WinLoadString(hab, plswData->hmodRes, MSC_HOTKEY + i, sizeof(ucLangStr), ucLangStr);
                if (plswData->Settings.usLanguage == CZ ||
                    plswData->Settings.usLanguage == PL)
                    UniStrToUcs( uconv_object852, target, ucLangStr, 299);
                else if (plswData->Settings.usLanguage == RU)
                    UniStrToUcs( uconv_object866, target, ucLangStr, 299);
                else
                    UniStrToUcs( uconv_object850, target, ucLangStr, 299);
                UniStrFromUcs( uconv_object1207, ucLangStr, target, 300);
                WinSetDlgItemText(hwnd, CHK_HOTKEY + i, ucLangStr);
            }
#endif
	    WinSetWindowPtr(WinWindowFromID(hwnd, EF_HOTKEY), 0,
			    (VOID *)
			    WinSubclassWindow(WinWindowFromID
					      (hwnd, EF_HOTKEY),
					      HotkeyWndProc));

            while (FindResDll(ucDllName, sizeof(ucDllName), &usLang,
                              ucLangStr, sizeof(ucLangStr)))
		if (usLang != 0) {
		    SHORT sIndex;
#if 1
                    if  (usLang == RU || usLang == CZ || usLang == ES || usLang == PL) {

                        if (usLang == CZ || usLang == PL) {
                            UniStrToUcs( uconv_object852, target, ucLangStr, 299);
                        }
                        if (usLang == ES) {
                            UniStrToUcs( uconv_object850, target, ucLangStr, 299);
                        }
                        if (usLang == RU) {
                            UniStrToUcs( uconv_object866, target, ucLangStr, 299);
                        }
                        UniStrFromUcs( uconv_object1207, ucLangStr, target, 300);
                    }
#endif
		    sIndex =
			(SHORT) WinSendDlgItemMsg(hwnd, COMBO_LANG,
						  LM_INSERTITEM,
						  MPFROMSHORT(LIT_END),
                                                  MPFROMP(ucLangStr));
                    if (sIndex != LIT_ERROR) {
                        if (!(sIndex == 0 && indexstarted))
                            usLangArr[sIndex] = usLang;
			if (usLang == plswData->Settings.usLanguage)
			    WinSendDlgItemMsg(hwnd, COMBO_LANG, LM_SELECTITEM,
					      MPFROMSHORT(sIndex),
					      MPFROMSHORT(TRUE));
                        if (sIndex == 0)
                            indexstarted = TRUE;
		    }
                }
            if (uconv_object866)
                UniFreeUconvObject(uconv_object866);
            if (uconv_object852)
                UniFreeUconvObject(uconv_object852);
            if (uconv_object850)
                UniFreeUconvObject(uconv_object850);
            if (uconv_object1207)
                UniFreeUconvObject(uconv_object1207);
	    DosFreeMem(plswData);
            bInit = FALSE;
	    return (MRESULT) TRUE;
	}

    case WM_CONTROL:
	if (bInit)
	    break;

	switch (SHORT1FROMMP(mp1)) {
	case COMBO_LANG:
	    if (SHORT2FROMMP(mp1) == CBN_EFCHANGE) {
		SHORT sIndex;

		sIndex =
		    (SHORT) WinSendDlgItemMsg(hwnd, COMBO_LANG,
					      LM_QUERYSELECTION,
					      MPFROMSHORT(LIT_FIRST), 0);
                if (sIndex >= 0
		    && usLangArr[sIndex] != plswData->Settings.usLanguage) {
		    WinDestroyAccelTable(plswData->haccAlt);
		    WinDestroyAccelTable(plswData->haccCtrl);
		    WinDestroyAccelTable(plswData->haccNoAlt);
		    DosFreeModule(plswData->hmodRes);

		    if ((plswData->hmodRes =
			 LoadResource(usLangArr[sIndex], plswData,
				      FALSE)) == 0) {
			plswData->hmodRes =
			    LoadResource(plswData->Settings.usLanguage,
					 plswData, TRUE);
			WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
				      "Could not load resource DLL or resource DLL invalid",
				      PGMNAME, 0, MB_ERROR | MB_CANCEL);
                    }
                    else {
                        UCHAR ucFont[30];
                        HMQ hmq;

                        plswData->Settings.usLanguage = usLangArr[sIndex];
                        if (plswData->Settings.usLanguage == RU ||
                            plswData->Settings.usLanguage == CZ ||
                            plswData->Settings.usLanguage == PL) {
                            strcpy(ucFont, "10.Times New Roman MT 30");
                            WinSetPresParam(plswData->hwndMenu, PP_FONTNAMESIZE, strlen(ucFont), ucFont);
                        }
                        else
                            WinRemovePresParam(plswData->hwndMenu, PP_FONTNAMESIZE);

                        if (plswData->Settings.usLanguage == RU) {
                            hmq = WinQueryWindowULong( plswData->hwndPopup, QWL_HMQ);
                            WinSetCp(hmq, 866);
                        }
                        else if (plswData->Settings.usLanguage == CZ ||
                                 plswData->Settings.usLanguage == PL) {
                            hmq = WinQueryWindowULong( plswData->hwndPopup, QWL_HMQ);
                            WinSetCp(hmq, 852);
                        }
                        else {
                            hmq = WinQueryWindowULong( plswData->hwndPopup, QWL_HMQ);
                            WinSetCp(hmq, 850);
                        }
#ifdef XWORKPLACE
                       if (WgtQueryXWPWidgetBasePath (szHelpFile)) {
                           CHAR cHelpFName[CCHMAXPATH];
           
                           if (plswData->Settings.usLanguage == ES)
                               strcpy(cHelpFName, "\\lswitch_es.hlp");
                           else
                               strcpy(cHelpFName, "\\lswitch.hlp");
                           strcat(szHelpFile, cHelpFName);
                           plswData->pWidget->pcszHelpLibrary = szHelpFile;
                           plswData->pWidget->ulHelpPanelID   = 30004;
                       }
#endif
                    }
		}
	    }
	    break;

	case EF_HOTKEY:
	    if (SHORT2FROMMP(mp1) == EN_CHANGE) {
		UCHAR buf[3];

		WinQueryDlgItemText(hwnd, EF_HOTKEY, sizeof(buf), buf);
		plswData->Settings.ucSettingsKey = buf[0];
	    }
	    else if (SHORT2FROMMP(mp1) == EN_SCANCODE) {
		plswData->Settings.ucSettingsScan = CHAR1FROMMP(mp2);
	    }
	    break;

	case CHK_ZORDER:
	    plswData->Settings.bChangeZOrder =
		WinQueryButtonCheckstate(hwnd, CHK_ZORDER);
	    break;

	case CHK_SWDESKTOP:
	    plswData->Settings.bDesktopMinimizes =
		WinQueryButtonCheckstate(hwnd, CHK_SWDESKTOP);
	    break;
#ifndef XWORKPLACE
	case CHK_SHOWINWINLIST:{
		SHORT iIndex;
		SWCNTRL swctl;
		PID pidPid;
		TID tidTid;

		WinQueryWindowProcess(hwnd, &pidPid, &tidTid);
		WinQuerySwitchEntry(WinQuerySwitchHandle(0, pidPid), &swctl);

		plswData->Settings.bShowInWinList =
		    WinQueryButtonCheckstate(hwnd, CHK_SHOWINWINLIST);
		WinQuerySwitchEntry(plswData->hswitch, &swctl);
		swctl.uchVisibility =
		    plswData->Settings.
		    bShowInWinList ? SWL_VISIBLE : SWL_INVISIBLE;
		WinChangeSwitchEntry(plswData->hswitch, &swctl);

		if ((SHORT)
		    (WinSendDlgItemMsg
		     (hwnd, LB_REMOVED, LM_SEARCHSTRING,
		      MPFROM2SHORT(LSS_CASESENSITIVE, LIT_FIRST),
		      MPFROMP(swctl.szSwtitle))) == LIT_NONE) {
		    iIndex =
			(SHORT) (WinSendDlgItemMsg
				 (hwnd, LB_ADDED, LM_SEARCHSTRING,
				  MPFROM2SHORT(LSS_CASESENSITIVE, LIT_FIRST),
				  MPFROMP(swctl.szSwtitle)));
		    if (plswData->Settings.bShowInWinList
			&& iIndex == LIT_NONE)
			WinSendDlgItemMsg(hwnd, LB_ADDED, LM_INSERTITEM,
					  MPFROMSHORT(LIT_END),
					  MPFROMP(swctl.szSwtitle));
		    else if (!plswData->Settings.bShowInWinList
			     && iIndex != LIT_ERROR && iIndex != LIT_NONE)
			WinSendDlgItemMsg(hwnd, LB_ADDED, LM_DELETEITEM,
					  MPFROMSHORT(iIndex), 0);
                }
                break;
            }
#endif
        }
	break;

    case WM_COMMAND:
	switch (SHORT1FROMMP(mp1)) {
	case DID_OK:
	case DID_CANCEL:
	    WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
	    break;
	default:
	    return WinDefDlgProc(hwnd, msg, mp1, mp2);
	}
	break;
    default:
	return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }
    return 0;
}

MRESULT EXPENTRY ParmNBWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    switch (msg) {
    case WM_CHAR:
	if ((SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
	    && SHORT2FROMMP(mp2) == VK_ESC)
	    WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), WM_COMMAND,
		       MPFROMSHORT(DID_CANCEL),
		       MPFROM2SHORT(CMDSRC_PUSHBUTTON, FALSE));
    default:
	return (((PFNWP) WinQueryWindowPtr(hwnd, 0)) (hwnd, msg, mp1, mp2));
    }
}

MRESULT EXPENTRY AboutWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{

    switch (msg) {
    case WM_INITDLG:{
        LSWDATA *plswData;
        HMQ hmq;
        BOOL bUniCodeFont = FALSE;

        DosGetNamedSharedMem((PVOID *) & plswData, SHAREMEM_NAME,
                             PAG_READ | PAG_WRITE);
        if (plswData->Settings.usLanguage == RU) {
            hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
            WinSetCp(hmq, 866);
            bUniCodeFont = TRUE;
        }
        else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
            hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
            WinSetCp(hmq, 852);
            bUniCodeFont = TRUE;
        }
        else {
            hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
            WinSetCp(hmq, 850);
        }
        SetControlsFont(hwnd, FALSE, bUniCodeFont);
        DosFreeMem(plswData);
        return (MRESULT) TRUE;
    }
    case WM_COMMAND:
	switch (SHORT1FROMMP(mp1)) {
	case DID_OK:
	case DID_CANCEL:
	    WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), msg, mp1, mp2);
	    break;
	default:
	    return WinDefDlgProc(hwnd, msg, mp1, mp2);
	}
	break;
    default:
        return WinDefDlgProc(hwnd, msg, mp1, mp2);
    }
    return 0;
}

MRESULT EXPENTRY ParmDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    LSWDATA *plswData;

    plswData = WinQueryWindowPtr(hwnd, 0);

    switch (msg) {
    case WM_INITDLG:{
	    HWND hwndPage, hwndNB;
	    ULONG ulPageId;
	    BOOKPAGEINFO pi;
	    RECTL rcl;
	    UCHAR ucBuf1[32], ucBuf2[32], ucBuf3[32], ucBuf4[32], ucBuf5[64];
	    BOOL bMajorPage;
	    SWP swp;
            USHORT k, usNameID, usTabID;
            static HACCEL haccelCfg = NULLHANDLE;
            HMQ hmq;
            BOOL bUniCodeFont = FALSE;

	    plswData = (PLSWDATA) PVOIDFROMMP(mp2);
            WinSetWindowPtr(hwnd, 0, plswData);
            if (plswData->Settings.usLanguage == RU) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 866);
                bUniCodeFont = TRUE;
            }
            else if (plswData->Settings.usLanguage == CZ ||
                     plswData->Settings.usLanguage == PL) {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 852);
                bUniCodeFont = TRUE;
            }
            else {
                hmq = WinQueryWindowULong( hwnd, QWL_HMQ);
                WinSetCp(hmq, 850);
            }
            SetControlsFont(hwnd, FALSE, bUniCodeFont);
            if (haccelCfg == NULLHANDLE)
                haccelCfg = WinLoadAccelTable(plswData->hab, plswData->hmodRes,
                                              ID_SETTINGHELPTABLE);
            if (haccelCfg != NULLHANDLE)
                WinSetAccelTable(plswData->hab, haccelCfg, plswData->hwndParamDlg);

	    hwndNB = WinWindowFromID(hwnd, NB_PARAMS);

	    WinSendMsg(hwndNB, BKM_SETNOTEBOOKCOLORS,
		       MPFROMLONG(SYSCLR_FIELDBACKGROUND),
		       MPFROMSHORT(BKA_BACKGROUNDPAGECOLORINDEX));

	    for (k = 0; k < 7; k++) {
		bMajorPage = (k == 0 || k == 2 || k == 5 || k == 6);
		ulPageId = (LONG) WinSendMsg(hwndNB, BKM_INSERTPAGE, 0,
					     MPFROM2SHORT(BKA_AUTOPAGESIZE |
							  (bMajorPage ?
							   BKA_MAJOR :
							   BKA_MINOR) |
							  BKA_STATUSTEXTON,
							  BKA_LAST));

		memset(&pi, 0, sizeof(pi));
		pi.cb = sizeof(pi);
		pi.fl =
		    BFA_PAGEFROMDLGRES | BFA_STATUSLINE | (bMajorPage ?
							   BFA_MAJORTABTEXT :
							   0) | (k < 7 ?
								 BFA_MINORTABTEXT
								 : 0);
		pi.bLoadDlg = TRUE;
		pi.hmodPageDlg = plswData->hmodRes;

		switch (k) {
		case 0:
		    pi.idPageDlg = usTabID = DLG_POPUP;
		    usNameID = DLG_GENERAL;
                    pi.pfnPageDlgProc = (PFN) PopupDlgProc;
		    break;
		case 1:
		    pi.idPageDlg = DLG_EXCLUDE;
		    usNameID = DLG_EXCLUDEPOPUP;
		    pi.pfnPageDlgProc = (PFN) ListDlgProc;
		    pi.pPageDlgCreateParams =
			&plswData->Settings.SkipListPopup;
		    break;
		case 2:
		    pi.idPageDlg = usTabID = DLG_TASKBAR;
		    usNameID = DLG_GENERAL;
                    pi.pfnPageDlgProc = (PFN) TaskBarDlgProc;
		    break;
		case 3:
		    pi.idPageDlg = DLG_MOUSE;
		    usNameID = DLG_MOUSE;
		    pi.pfnPageDlgProc = (PFN) MouseDlgProc;
		    break;
		case 4:
		    pi.idPageDlg = DLG_EXCLUDE;
		    usNameID = DLG_EXCLUDETSKBAR;
		    pi.pfnPageDlgProc = (PFN) ListDlgProc;
		    pi.pPageDlgCreateParams =
			&plswData->Settings.SkipListTskBar;
		    break;
		case 5:
		    pi.idPageDlg = usTabID = DLG_MISC;
		    usNameID = DLG_BLANK;
		    pi.pfnPageDlgProc = (PFN) MiscDlgProc;
		    break;
		/*case 6:
		    pi.idPageDlg = DLG_EXCLUDE;
		    usTabID = DLG_MISC;
		    usNameID = DLG_PRIORITY;
		    pi.pfnPageDlgProc = (PFN) ListDlgProc;
		    pi.pPageDlgCreateParams =
			&plswData->Settings.ListPriority;
		    break;*/
		case 6:
		    pi.idPageDlg = usTabID = DLG_ABOUT;
		    usNameID = DLG_BLANK;
		    pi.pfnPageDlgProc = (PFN) AboutWndProc;
		    break;
		}

		WinLoadString(WinQueryAnchorBlock(hwnd), plswData->hmodRes,
			      usTabID, sizeof(ucBuf1), ucBuf1);
		WinLoadString(WinQueryAnchorBlock(hwnd), plswData->hmodRes,
			      usNameID, sizeof(ucBuf2), ucBuf2);
		WinLoadString(WinQueryAnchorBlock(hwnd), plswData->hmodRes,
			      STR_DLGPAGE, sizeof(ucBuf3), ucBuf3);
		pi.cbMajorTab = strlen(ucBuf1);
		pi.pszMajorTab = ucBuf1;
		sprintf(ucBuf5, "%s: %s", ucBuf1, ucBuf2);
		pi.cbMinorTab = strlen(ucBuf2);
		pi.pszMinorTab = ucBuf2;
		sprintf(ucBuf4, ucBuf3,
                        k == 6 ? 1 : k == 5 ? 1 : k < 2 ?
                        k % 2 + 1 : (k - 2) % 4 + 1,
                        k > 4 ? 1 :
                        k < 2 ? 2 : 3);

		pi.cbStatusLine = strlen(ucBuf4);
		pi.pszStatusLine = ucBuf4;

		WinSendMsg(hwndNB, BKM_SETPAGEINFO, MPFROMLONG(ulPageId),
			   MPFROMP(&pi));

		hwndPage =
		    (HWND) WinSendMsg(hwndNB, BKM_QUERYPAGEWINDOWHWND,
				      MPFROMLONG(ulPageId), 0);
		if (k == 1) {
		    WinQueryWindowRect(hwndPage, &rcl);
		    WinSendMsg(hwndNB, BKM_CALCPAGERECT, MPFROMP(&rcl),
			       MPFROMSHORT(FALSE));
		    WinQueryWindowPos(WinWindowFromID(hwnd, DID_OK), &swp);
		    WinSetWindowPos(hwnd, 0, 0, 0, rcl.xRight - rcl.xLeft + 8,
				    rcl.yTop - rcl.yBottom + swp.y + swp.cy +
				    swp.cy / 2 +
				    2 * WinQuerySysValue(HWND_DESKTOP,
							 SV_CYTITLEBAR),
				    SWP_SIZE);
		    WinSetWindowUShort(hwndPage, QWS_ID, DLG_EXCLUDEPOPUP);
		}
		else if (k == 4)
		    WinSetWindowUShort(hwndPage, QWS_ID, DLG_EXCLUDETSKBAR);
		//else if (k == 6)
                //    WinSetWindowUShort(hwndPage, QWS_ID, DLG_PRIORITY);
                else
                    WinSetWindowUShort(hwndPage, QWS_ID, pi.idPageDlg);
	    }

	    WinSetWindowPtr(hwndNB, 0,
			    (VOID *) WinSubclassWindow(hwndNB,
						       ParmNBWndProc));

	    WinQueryWindowPos(hwnd, &swp);
	    WinSetWindowPos(hwnd, 0,
			    (WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN) -
			     swp.cx) / 2, (WinQuerySysValue(HWND_DESKTOP,
							    SV_CYSCREEN) -
					   swp.cy) / 2, 0, 0, SWP_MOVE);
	    WinSetFocus(HWND_DESKTOP, hwndNB);
	    return (MRESULT) TRUE;
	}

    case WM_ADJUSTWINDOWPOS:{
	    PSWP pswp;
	    SWP swp;

	    pswp = PVOIDFROMMP(mp1);
	    if (pswp->fl & SWP_SIZE) {
		WinQueryWindowPos(WinWindowFromID(hwnd, DID_OK), &swp);
		WinSetWindowPos(WinWindowFromID(hwnd, NB_PARAMS), 0, 4,
				swp.y + swp.cy + swp.cy / 2, pswp->cx - 8,
				pswp->cy - swp.y - swp.cy - swp.cy / 2 -
				2 * WinQuerySysValue(HWND_DESKTOP,
						     SV_CYTITLEBAR),
				SWP_SIZE | SWP_MOVE);
	    }
	    return (WinDefDlgProc(hwnd, msg, mp1, mp2));
	}

    case WM_COMMAND:
	switch (SHORT1FROMMP(mp1)) {
        case CMD_HELP:{
            HWND hwndPage;
            USHORT usDlgId;
            ULONG ulPageId =
		(ULONG) WinSendMsg(WinWindowFromID(hwnd, NB_PARAMS),
				   BKM_QUERYPAGEID, 0, MPFROM2SHORT(BKA_TOP,
                                                                    0));
            hwndPage =
                LONGFROMMP(WinSendMsg
                           (WinWindowFromID(hwnd, NB_PARAMS),
                            BKM_QUERYPAGEWINDOWHWND, MPFROMLONG(ulPageId),
                            0));
            usDlgId = WinQueryWindowUShort(hwndPage, QWS_ID);
            if (usDlgId == DLG_EXCLUDEPOPUP)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30101, 0), MPFROMSHORT(HM_RESOURCEID));
            else if (usDlgId == DLG_POPUP)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30007, 0), MPFROMSHORT(HM_RESOURCEID));
            else if (usDlgId == DLG_TASKBAR)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30102, 0), MPFROMSHORT(HM_RESOURCEID));
            else if (usDlgId == DLG_EXCLUDETSKBAR)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30105, 0), MPFROMSHORT(HM_RESOURCEID));
            else if (usDlgId == DLG_MISC)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30106, 0), MPFROMSHORT(HM_RESOURCEID));
            else if (usDlgId == DLG_MOUSE)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30104, 0), MPFROMSHORT(HM_RESOURCEID));
            else if (usDlgId == DLG_ABOUT)
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                           MPFROM2SHORT(30034, 0), MPFROMSHORT(HM_RESOURCEID));
            else
                WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
                       MPFROM2SHORT(30005, 0), MPFROMSHORT(HM_RESOURCEID));
            break;
        }
        /*case DID_CANCEL: { 
            static UCHAR ucFName[CCHMAXPATH];

            GetIniFileName(ucFName, sizeof(ucFName));
            LoadSettings(WinQueryAnchorBlock(hwnd), ucFName,
                         &plswData->Settings);
            // If I want this to work I need to create ApplySettings by
            // extracting the code for applying each setting from the page procs
            return WinDefDlgProc(hwnd, msg, mp1, mp2);
        } */

	case DID_OK:{
             USHORT rc;
             static UCHAR ucErrMsg[100], ucFName[CCHMAXPATH],
                 ucBuf[100 + CCHMAXPATH];
 
             GetIniFileName(ucFName, sizeof(ucFName));
 
             if ((rc =
                  SaveSettings(WinQueryAnchorBlock(hwnd), ucFName,
                               &plswData->Settings)) != 0) {
                 WinLoadString(WinQueryAnchorBlock(hwnd), NULLHANDLE,
                               rc == 1 ? MSG_CANTOPEN : MSG_CANTSAVE,
                               sizeof(ucErrMsg), ucErrMsg);
                 sprintf(ucBuf, ucErrMsg, ucFName);
                 WinAlarm(HWND_DESKTOP, WA_ERROR);
                 WinMessageBox(HWND_DESKTOP, hwnd, ucBuf, PGMNAME, 0,
                               MB_ERROR | MB_CANCEL);
             }
        } //fall through
	default:
	    return WinDefDlgProc(hwnd, msg, mp1, mp2);
	}

	break;

    case LSWM_UPDATEEXCLUDEDLG:
    case LSWM_SWITCHLISTCHANGED:{
	    HWND hwndPage;
	    ULONG ulPageId =
		(ULONG) WinSendMsg(WinWindowFromID(hwnd, NB_PARAMS),
				   BKM_QUERYPAGEID, 0, MPFROM2SHORT(BKA_FIRST,
								    0));
	    USHORT usDlgId;

	    while (ulPageId > 0) {
		hwndPage =
		    LONGFROMMP(WinSendMsg
			       (WinWindowFromID(hwnd, NB_PARAMS),
				BKM_QUERYPAGEWINDOWHWND, MPFROMLONG(ulPageId),
				0));
		usDlgId = WinQueryWindowUShort(hwndPage, QWS_ID);
		if (((usDlgId == DLG_EXCLUDEPOPUP
		      || usDlgId == DLG_EXCLUDETSKBAR
		      || usDlgId == DLG_PRIORITY)
		     && msg == LSWM_SWITCHLISTCHANGED)
		    || (msg == LSWM_UPDATEEXCLUDEDLG
			&& SHORT1FROMMP(mp2) == UPDATEPOPUPLIST
			&& usDlgId == DLG_EXCLUDEPOPUP)
		    || (msg == LSWM_UPDATEEXCLUDEDLG
			&& SHORT1FROMMP(mp2) == UPDATETSKBARLIST
			&& usDlgId == DLG_EXCLUDETSKBAR)
		    || (msg == LSWM_UPDATEEXCLUDEDLG
			&& SHORT1FROMMP(mp2) == UPDATEICONSONLYLIST
			&& usDlgId == DLG_PRIORITY)
		    )
		    WinPostMsg(hwndPage, LSWM_UPDATEEXCLUDEDLG,
			       MPFROMSHORT(UPDATEADDEDLIST |
					   (msg ==
					    LSWM_UPDATEEXCLUDEDLG ?
					    UPDATEREMOVEDLIST : 0)), 0);
		ulPageId =
		    (LONG) WinSendMsg(WinWindowFromID(hwnd, NB_PARAMS),
				      BKM_QUERYPAGEID, MPFROMLONG(ulPageId),
				      MPFROM2SHORT(BKA_NEXT, 0));
	    }
	}

    default:
	return (WinDefDlgProc(hwnd, msg, mp1, mp2));
    }
    return 0;
}
