winamp/Src/Plugins/Visualization/vis_milk2/config.cpp

/*
  LICENSE
  -------
Copyright 2005-2013 Nullsoft, Inc.
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, 
are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer. 

  * Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution. 

  * Neither the name of Nullsoft nor the names of its contributors may be used to 
    endorse or promote products derived from this software without specific prior written permission. 
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "api__vis_milk2.h"
#include "pluginshell.h"
#include "resource.h"
#include "utility.h"
#include "defines.h"
#include "shell_defines.h"
#include "vis.h"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <multimon.h>
#include <commctrl.h>
#include <shellapi.h>
#include <strsafe.h>
#include <assert.h>

#define PREFERRED_FORMAT D3DFMT_X8R8G8B8
#define MAX_PROPERTY_PAGES 8
#define MAX_DISPLAY_ADAPTERS 16
#define MAX_MAX_FPS 120
#define MAX_DISPLAY_MODES 1024

extern winampVisModule mod1;

IDirect3D9* g_lpDX;
HMODULE     g_hmod_d3d9;
HMODULE     g_hmod_d3dx9;
D3DADAPTER_IDENTIFIER9 g_disp_adapter_w[MAX_DISPLAY_ADAPTERS];   // NOTE: indices into this list might not equal the ordinal adapter indices!
D3DADAPTER_IDENTIFIER9 g_disp_adapter_fs[MAX_DISPLAY_ADAPTERS];  // NOTE: indices into this list might not equal the ordinal adapter indices!
D3DADAPTER_IDENTIFIER9 g_disp_adapter_dm[MAX_DISPLAY_ADAPTERS];  // NOTE: indices into this list might not equal the ordinal adapter indices!
D3DDISPLAYMODE         g_disp_mode[MAX_DISPLAY_MODES];
HWND        g_config_hwnd;
HWND        g_subwnd;
int         g_num_disp_modes;
int         g_nTab;
int         g_ignore_clicks;
int         g_zero_display_modes_warning_given;
int         g_proppage_id[MAX_PROPERTY_PAGES];

void GetCurrentDisplayMode(D3DDISPLAYMODE *pMode)
{
    if (!pMode)
        return;

    DEVMODE dm;
    dm.dmSize = sizeof(dm);
    dm.dmDriverExtra = 0;
    if (!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm))
        return;

    pMode->Width  = dm.dmPelsWidth;
    pMode->Height = dm.dmPelsHeight;
    pMode->Format = (dm.dmBitsPerPel==16) ? D3DFMT_R5G6B5 : D3DFMT_X8R8G8B8;
    pMode->RefreshRate = dm.dmDisplayFrequency;
}

bool CPluginShell::InitConfig(HWND hDialogWnd)
{
    // ******* do initialization of global variables HERE *******
    // ******* do initialization of global variables HERE *******
    // ******* do initialization of global variables HERE *******

    g_lpDX = NULL;
    g_hmod_d3d9 = NULL;
	g_hmod_d3dx9 = NULL;
    g_num_disp_modes = 0;
    g_config_hwnd = hDialogWnd;
    g_ignore_clicks = 1;
    g_subwnd = NULL;
    g_nTab   = 0;
    g_zero_display_modes_warning_given = 0;

    g_proppage_id[0] = IDD_PROPPAGE_1;
    g_proppage_id[1] = IDD_PROPPAGE_2;
    g_proppage_id[2] = IDD_PROPPAGE_3;
    g_proppage_id[3] = IDD_PROPPAGE_4;
    g_proppage_id[4] = IDD_PROPPAGE_5;
    g_proppage_id[5] = IDD_PROPPAGE_6;
    g_proppage_id[6] = IDD_PROPPAGE_7;
    g_proppage_id[7] = IDD_PROPPAGE_8;

    // ******* do initialization of global variables HERE *******
    // ******* do initialization of global variables HERE *******
    // ******* do initialization of global variables HERE *******

    return true;
}

void CPluginShell::EndConfig()
{
    SafeRelease(g_lpDX);

    if (g_subwnd)
    {
		DestroyWindow(g_subwnd); 
		g_subwnd = NULL;
    }

    if (g_hmod_d3d9)
    {
        FreeLibrary(g_hmod_d3d9);
        g_hmod_d3d9 = NULL;
    }
		if (g_hmod_d3dx9)
    {
        g_hmod_d3dx9 = NULL;
    }
}

static bool AddButton(int pos, HWND tabctrl, LPWSTR szButtonText) 
{ 
    if (szButtonText && szButtonText[0] && szButtonText[0] != L' ')
    { 
        TCITEMW tie = {0};
        tie.mask = TCIF_TEXT | TCIF_IMAGE;
        tie.iImage = -1;
        tie.pszText = szButtonText;

        if (SendMessageW(tabctrl, TCM_INSERTITEMW, pos, (LPARAM)&tie) == -1)
            return false;
    }
    return true;
}

void CPluginShell::UpdateAdapters(int screenmode)
{
    int i;

    if (!g_lpDX) return;
    
    int nDispAdapters = 0;
    
    HWND ctrl;
    GUID* pGUID = NULL;
    char deviceName[256];
    switch(screenmode)
    {
    case FULLSCREEN: 
        ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_FS);
        pGUID = &m_adapter_guid_fullscreen;
        StringCbCopy(deviceName, sizeof(deviceName), m_adapter_devicename_fullscreen);
        break;
    case WINDOWED: 
        ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_W);
        pGUID = &m_adapter_guid_windowed;
        StringCbCopy(deviceName, sizeof(deviceName), m_adapter_devicename_windowed);
        break;
    /*case FAKE_FULLSCREEN: 
        ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_FFS);
        pGUID = &m_adapter_guid_fake_fullscreen;
        strcpy(deviceName, m_adapter_devicename_fake_fullscreen);
        break;*/
    case DESKTOP: 
        ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_DMS);
        pGUID = &m_adapter_guid_desktop;
        StringCbCopy(deviceName, sizeof(deviceName), m_adapter_devicename_desktop);
        break;
    }

    // clear the combo box
    SendMessage( ctrl, CB_RESETCONTENT, 0, 0);

    // repopulate the combo box with a list of adapters
    {
        char szDesc[1024];
        
        D3DADAPTER_IDENTIFIER9* global_adapter_list;
        switch(screenmode)
        {
        case FULLSCREEN: 
            global_adapter_list = g_disp_adapter_fs; 
            break;
        case WINDOWED: 
            global_adapter_list = g_disp_adapter_w; 
            break;
        /*case FAKE_FULLSCREEN: 
            global_adapter_list = g_disp_adapter_w;     // [sic]
            break;*/
        case DESKTOP: 
            global_adapter_list = g_disp_adapter_dm;
            break;
        }

        int nAdapters = g_lpDX->GetAdapterCount();

        // re-populate it:

        wchar_t szDebugFile[MAX_PATH];
        StringCbCopyW(szDebugFile, sizeof(szDebugFile), m_szConfigIniFile);
        wchar_t* p = wcsrchr(szDebugFile, L'\\');
        if (p)
        {
            lstrcpyW(p+1, ADAPTERSFILE);
            FILE* f = _wfopen(szDebugFile, L"w");
            if (f)
            {
                DWORD winamp_version = SendMessage(GetWinampWindow(),WM_WA_IPC,0,0);
                fprintf(f, "Winamp version = 0x%04X\n", winamp_version);
                fprintf(f, "Plugin long name = \"%s\", version=%d, subversion=%d\n", LONGNAME, INT_VERSION, INT_SUBVERSION);
                fprintf(f, "Enumeration of Display Adapters:\n");
                //fprintf(f, "...this is a temporary debug file created by MilkDrop 2.\n");
                //fprintf(f, "...don't worry - the final release of the plug-in will NOT generate this file.\n");
                for (i=0; i<nAdapters && nDispAdapters<MAX_DISPLAY_ADAPTERS; i++)
                {
                    if (g_lpDX->GetAdapterIdentifier(i, /*D3DENUM_NO_WHQL_LEVEL*/ 0, &global_adapter_list[nDispAdapters]) == D3D_OK)
                    {
                        // Now get the caps, and filter out any graphics cards that can't
                        // do, say, gouraud shading:

                        int adapter_ok = 1;

                        /*
                        D3DCAPS9 caps;
                        if (g_lpDX->GetDeviceCaps(i, D3DDEVTYPE_HAL, &caps)==D3D_OK)
                        {
                            // check the caps here, make sure the device is up to par.  example:
                            if (caps.ShadeCaps & D3DPSHADECAPS_COLORGOURAUDRGB)
                              adapter_ok = 0;
                        }
                        */

                        if (f) {
                            fprintf(f, "%d. Driver=%s\n", nDispAdapters+1, global_adapter_list[nDispAdapters].Driver);
                            fprintf(f, "    Description=%s\n",      global_adapter_list[nDispAdapters].Description);
                            fprintf(f, "    DeviceName=%s\n",       global_adapter_list[nDispAdapters].DeviceName);
                            fprintf(f, "    DriverVersion=0x%08X (%d)\n",global_adapter_list[nDispAdapters].DriverVersion);
                            fprintf(f, "    VendorId=%d\n",         global_adapter_list[nDispAdapters].VendorId);
                            fprintf(f, "    DeviceId=%d\n",         global_adapter_list[nDispAdapters].DeviceId);
                            fprintf(f, "    SubSysId=0x%08X\n",         global_adapter_list[nDispAdapters].SubSysId);
                            fprintf(f, "    Revision=%d\n",         global_adapter_list[nDispAdapters].Revision);
                            //fprintf(f, "    DeviceIdentifier=0x%08X\n", global_adapter_list[nDispAdapters].DeviceIdentifier);
                             char szGuidText[512];
                             GuidToText(&global_adapter_list[nDispAdapters].DeviceIdentifier, szGuidText, sizeof(szGuidText));
                            fprintf(f, "    WHQLLevel=%d\n",        global_adapter_list[nDispAdapters].WHQLLevel);
                            fprintf(f, "    GUID=%s\n", szGuidText);                   
                        }

                        if (adapter_ok)
                        {
                            sprintf(szDesc, "%d. %s   [%s]", nDispAdapters+1, global_adapter_list[nDispAdapters].Description, global_adapter_list[nDispAdapters].Driver);
                            SendMessage( ctrl, CB_ADDSTRING, nDispAdapters, (LPARAM)szDesc);
                            nDispAdapters++;
                        }
                    }
                }    
                fclose(f);
            }
        }

        // set selection(s):
        // find i where global_adapter_list[i].DeviceIdentifier is the same as last time,
        // and select it.
        int found = 0;
        for (i=0; i<nDispAdapters; i++)
        {
            if (!found && 
                memcmp(&global_adapter_list[i].DeviceIdentifier, pGUID, sizeof(GUID))==0 &&
                !strcmp(global_adapter_list[i].DeviceName, deviceName)
                )
            {
                SendMessage( ctrl, CB_SETCURSEL, i, 0);
                found = 1;
            }
        }
        if (!found)
            SendMessage( ctrl, CB_SETCURSEL, 0, 0);
    }

    if (screenmode == FULLSCREEN)
        UpdateFSAdapterDispModes();
    else
        UpdateDispModeMultiSampling(screenmode);
}

void CPluginShell::UpdateFSAdapterDispModes()   // (fullscreen only)
{
    wchar_t szfmt[256], str[256];
    int i;
    HWND hwnd_listbox = GetDlgItem( g_subwnd, IDC_DISP_MODE );

    int nVideoModesTotal = 0;
    if (!g_lpDX) return;
    int nAdapterOrdinal = GetCurrentlySelectedAdapter(FULLSCREEN);
    nVideoModesTotal = g_lpDX->GetAdapterModeCount(nAdapterOrdinal, PREFERRED_FORMAT);

    if (nVideoModesTotal <= 0 && !g_zero_display_modes_warning_given)
    {
        g_zero_display_modes_warning_given = 1;
		wchar_t title[64];
        MessageBoxW(g_config_hwnd, WASABI_API_LNGSTRINGW(IDS_GRAPHICS_SUBSYSTEM_IS_TEMPORARILY_UNSTABLE),
				   WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_WARNING, title, 64),
				   MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);
    }

    // clear the combo box
    SendMessage( hwnd_listbox, CB_RESETCONTENT, 0, 0);

    int nAdded = 0;

    // re-populate it:
    for (i=0; i<nVideoModesTotal; i++)
    {
        if (nAdded >= MAX_DISPLAY_MODES)
            break;

        // get info for display mode into g_disp_mode[nAdded]
        if (g_lpDX->EnumAdapterModes(nAdapterOrdinal, PREFERRED_FORMAT, i, &g_disp_mode[nAdded]) != D3D_OK)
            continue;

        // add to combo box
        int bpp = 0;
        switch(g_disp_mode[nAdded].Format)
        {
        default:
        case D3DFMT_UNKNOWN      : WASABI_API_LNGSTRINGW_BUF(IDS_UNKNOWN, szfmt, 256);   bpp=0;  break;
        case D3DFMT_R8G8B8       : lstrcpynW(szfmt, L"RGB-888", 256);  bpp=32; break;
        case D3DFMT_A8R8G8B8     : lstrcpynW(szfmt, L"ARGB-8888", 256); bpp=32; break;
        case D3DFMT_X8R8G8B8     : lstrcpynW(szfmt, L"XRGB-8888", 256); bpp=32; break;
        case D3DFMT_R5G6B5       : lstrcpynW(szfmt, L"RGB-565", 256);   bpp=16; break;
        case D3DFMT_X1R5G5B5     : lstrcpynW(szfmt, L"XRGB-1555", 256);  bpp=16; break;
        case D3DFMT_A1R5G5B5     : lstrcpynW(szfmt, L"ARGB-1555", 256);  bpp=16; break;
        case D3DFMT_A4R4G4B4     : lstrcpynW(szfmt, L"ARGB-4444", 256);  bpp=16; break;
        case D3DFMT_X4R4G4B4     : lstrcpynW(szfmt, L"XRGB-4444", 256);  bpp=16; break;
        }
        swprintf(str, L" %s,  %4d x %4d,  %3d %s ",
				 szfmt, g_disp_mode[nAdded].Width,
				 g_disp_mode[nAdded].Height,
				 g_disp_mode[nAdded].RefreshRate,
				 WASABI_API_LNGSTRINGW(IDS_HZ));

        /*
        #ifdef DONT_ALLOW_8BIT_FULLSCREEN
            if (bpp==8) continue;
        #endif
        #ifdef DONT_ALLOW_16_24_32_BIT_FULLSCREEN
            if (bpp==16 || bpp==24 || bpp==32) continue;
        #endif
        */

        int nPos = SendMessageW( hwnd_listbox, CB_ADDSTRING, 0, (LPARAM)str);

        // keep a record of the original index, because the combo box SORTS the data:
        SendMessage( hwnd_listbox, CB_SETITEMDATA, nPos, i);

        nAdded++;
    }

    g_num_disp_modes = nAdded;

    // now set selection, based on best match to prev. video mode.  
    int found = 0;
    
    // Fallback order:
    // 0. exact match (4 params)   w,h,r,f
    // 1. ignore refresh rate, but still heed color format
    // 2. heed only w,h, and if desired_mode.Format is UNKNOWN, 
    //        try for a 16-bpp color format and 60 Hz
    // 3. heed only w,h, and if desired_mode.Format is UNKNOWN, 
    //        try for a 16-bpp color format at any Hz
    // 4. heed only w,h.

    D3DDISPLAYMODE desired_mode = m_disp_mode_fs;

    assert(desired_mode.Format != D3DFMT_UNKNOWN);
    // this should never happen anymore, now that we set smarter default FS display mode
    // (to match the current display mode) in PluginShell.cpp's PluginPreInitialize().
    /*if (desired_mode.Format==D3DFMT_UNKNOWN)
    {
        GetCurrentDisplayMode(&desired_mode);

        // first-time config: try to find a video mode that matches our ideal.
		// do many passes until we find one, each time relaxing more constraints.
		// outline of the passes:

		// PASS  MATCH:
        // 0. w,h,r,16bpp
        // 1. w,h,-,16bpp
        // 2. w,h,r,-
        // 3. w,h,-,-
        // 4. -,-,-,-
        for (int rep=0; rep<5; rep++)
        {
            for (i=0; i<g_num_disp_modes && !found; i++)
            {
                // we have to remap here, because the combo box SORTED the data:
                int id = SendMessage( hwnd_listbox, CB_GETITEMDATA, i, 0);

                bool bDesiredBitDepth = (
                                (g_disp_mode[id].Format == D3DFMT_R8G8B8  ) ||
                                (g_disp_mode[id].Format == D3DFMT_A8R8G8B8) ||     
                                (g_disp_mode[id].Format == D3DFMT_X8R8G8B8) 
                                        ); 

                bool bMatch = true;

                if (rep<=3 && desired_mode.Width!=g_disp_mode[id].Width) 
                    bMatch = false;
                if (rep<=3 && desired_mode.Height!=g_disp_mode[id].Height) 
                    bMatch = false;
                if ((rep==0 || rep==2) && desired_mode.RefreshRate!=g_disp_mode[id].RefreshRate) 
                    bMatch = false;
                if (rep<=1 && !bDesiredBitDepth)
                    bMatch = false;

                if (bMatch)
                {
                    SendMessage( hwnd_listbox, CB_SETCURSEL, i, 0);
                    found = 1;
                }
            }
        }

        // if no match could be found, select #0.
        if (!found)
            SendMessage( hwnd_listbox, CB_SETCURSEL, 0, 0);
    }
    else
    */
    {
        // find best match to prev. selection.
		// do many passes until we find one, each time relaxing more constraints.
		// outline of the passes:

        int bpp_desired = 0;
        switch(desired_mode.Format)
        {
        case D3DFMT_R8G8B8  : bpp_desired = 32; break;
        case D3DFMT_A8R8G8B8: bpp_desired = 32; break;
        case D3DFMT_X8R8G8B8: bpp_desired = 32; break;
        case D3DFMT_R5G6B5  : bpp_desired = 16; break;
        case D3DFMT_X1R5G5B5: bpp_desired = 16; break;
        case D3DFMT_A1R5G5B5: bpp_desired = 16; break;
        case D3DFMT_A4R4G4B4: bpp_desired = 16; break;
        case D3DFMT_R3G3B2  : bpp_desired =  8; break;
        case D3DFMT_A8R3G3B2: bpp_desired = 16; break;
        case D3DFMT_X4R4G4B4: bpp_desired = 16; break;
        }

		// rep   MATCH:
		//  0. w,h,r,f
        //  1. w,h,-,f
        //  2. w,h,r,-         pass: 
        //  3. w,h,-,-           -on pass 0, for 'f', match exact format
        //  4. 8,6,r,f           -on pass 1, for 'f', just match # of bits per pixel
        //  5. 8,6,-,f              (more relaxed match)
        //  6. 8,6,r,-
        //  7. 8,6,-,-
        //  8. -,-,r,f
        //  9. -,-,-,f
        // 10. -,-,r,-
        // 11. -,-,-,-
        for (int rep=0; rep<12 && !found; rep++)
        {
            for (int pass=0; pass<2 && !found; pass++)
            {
                for (i=0; i<g_num_disp_modes && !found; i++)
                {
                    // we have to remap here, because the combo box SORTED the data:
                    int id = SendMessage( hwnd_listbox, CB_GETITEMDATA, i, 0);

                    int bpp_this_mode = 0;
                    switch(g_disp_mode[id].Format)
                    {
                    case D3DFMT_R8G8B8  : bpp_this_mode = 32; break;
                    case D3DFMT_A8R8G8B8: bpp_this_mode = 32; break;
                    case D3DFMT_X8R8G8B8: bpp_this_mode = 32; break;
                    case D3DFMT_R5G6B5  : bpp_this_mode = 16; break;
                    case D3DFMT_X1R5G5B5: bpp_this_mode = 16; break;
                    case D3DFMT_A1R5G5B5: bpp_this_mode = 16; break;
                    case D3DFMT_A4R4G4B4: bpp_this_mode = 16; break;
                    case D3DFMT_R3G3B2  : bpp_this_mode =  8; break;
                    case D3DFMT_A8R3G3B2: bpp_this_mode = 16; break;
                    case D3DFMT_X4R4G4B4: bpp_this_mode = 16; break;
                    }

                    bool bMatch = true;

                    if (rep < 4)
                    {
                        if (desired_mode.Width != g_disp_mode[id].Width) 
                            bMatch = false;
                        if (desired_mode.Height != g_disp_mode[id].Height) 
                            bMatch = false;
                    }
                    else if (rep < 8)
                    {
                        if (DEFAULT_FULLSCREEN_WIDTH != g_disp_mode[id].Width) 
                            bMatch = false;
                        if (DEFAULT_FULLSCREEN_HEIGHT != g_disp_mode[id].Height) 
                            bMatch = false;
                    }
        
                    if (((rep/2)%2)==0)
                    {
                        if (pass==0 && desired_mode.Format != g_disp_mode[id].Format)
                            bMatch = false;
                        else if (pass==1 && bpp_desired != bpp_this_mode)
                            bMatch = false;
                    }

                    if (((rep%2)==0) && desired_mode.RefreshRate!=g_disp_mode[id].RefreshRate) 
                    {
                        bMatch = false;
                    }

                    if (bMatch)
                    {
                        SendMessage( hwnd_listbox, CB_SETCURSEL, i, 0);
                        found = 1;
                    }
                }
            }
        }

        // if no match could be found, select #0.
        if (!found)
            SendMessage( hwnd_listbox, CB_SETCURSEL, 0, 0);
    }

    UpdateDispModeMultiSampling(0);
}

void CPluginShell::UpdateDispModeMultiSampling(int screenmode)
{
    int nSampleTypes = 0;

    HWND hwnd_listbox;
    switch(screenmode)
    {
    case FULLSCREEN:      hwnd_listbox = GetDlgItem(g_subwnd, IDC_FSMS);  break;
    case WINDOWED:        hwnd_listbox = GetDlgItem(g_subwnd, IDC_WMS);   break;
    case DESKTOP:         hwnd_listbox = GetDlgItem(g_subwnd, IDC_DMSMS);  break;
    }

    wchar_t str[256];
    int i;

    if (!g_lpDX)
        return;

    if ((screenmode == WINDOWED && !m_allow_page_tearing_w) ||
        (screenmode == FULLSCREEN && m_fake_fullscreen_mode && !m_allow_page_tearing_fs) ||
        (screenmode == DESKTOP && !m_allow_page_tearing_dm))
    {
        // page tearing not allowed -> disable multisampling!
        SendMessage( hwnd_listbox, CB_RESETCONTENT, 0, 0);
        SendMessageW( hwnd_listbox, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_DISABLED_PAGE_TEARING));
        SendMessage( hwnd_listbox, CB_SETITEMDATA, 0, 0 );
        SendMessage( hwnd_listbox, CB_SETCURSEL, 0, 0);
        EnableWindow( hwnd_listbox, 0 );
    }
    else
    {
        EnableWindow( hwnd_listbox, 1 );

        // figure out which [fullscreen/windowed] adapter is currently selected:
        int nAdapterOrdinal = GetCurrentlySelectedAdapter(screenmode);

        // figure out current format:
        D3DFORMAT format = D3DFMT_UNKNOWN;
        if ((screenmode == WINDOWED) || 
            (screenmode == FULLSCREEN && m_fake_fullscreen_mode) || 
            (screenmode == DESKTOP))
        {
            // ** get it from the current display mode 
            //    of the currently-selected [windowed/fake fullscreen] mode adapter **
            D3DDISPLAYMODE dispmode;
            if (g_lpDX->GetAdapterDisplayMode(nAdapterOrdinal, &dispmode) == D3D_OK)
                format = dispmode.Format;
        }
        else
        {
            // **get it from the currently-selected fullscreen display mode**
            int n = SendMessage( GetDlgItem( g_subwnd, IDC_DISP_MODE ), CB_GETCURSEL, 0, 0);
            if (n != CB_ERR) 
            {
                // since the combobox contents were sorted, we need to look up the original
                // index into g_disp_mode[]:
                n = SendMessage( GetDlgItem( g_subwnd, IDC_DISP_MODE ), CB_GETITEMDATA, n, 0);
                if (n != CB_ERR)
                    format = g_disp_mode[n].Format;
            }
        }

        D3DMULTISAMPLE_TYPE check[16] = {
            D3DMULTISAMPLE_NONE,
            D3DMULTISAMPLE_2_SAMPLES ,
            D3DMULTISAMPLE_3_SAMPLES ,
            D3DMULTISAMPLE_4_SAMPLES ,
            D3DMULTISAMPLE_5_SAMPLES ,
            D3DMULTISAMPLE_6_SAMPLES ,
            D3DMULTISAMPLE_7_SAMPLES ,
            D3DMULTISAMPLE_8_SAMPLES ,
            D3DMULTISAMPLE_9_SAMPLES ,
            D3DMULTISAMPLE_10_SAMPLES,
            D3DMULTISAMPLE_11_SAMPLES,
            D3DMULTISAMPLE_12_SAMPLES,
            D3DMULTISAMPLE_13_SAMPLES,
            D3DMULTISAMPLE_14_SAMPLES,
            D3DMULTISAMPLE_15_SAMPLES,
            D3DMULTISAMPLE_16_SAMPLES,
        };

        // clear the combo box
        SendMessage( hwnd_listbox, CB_RESETCONTENT, 0, 0);

        // re-populate it:
        for (i=0; i<16; i++)
        {
            if (i==0 || SUCCEEDED(g_lpDX->CheckDeviceMultiSampleType(nAdapterOrdinal, D3DDEVTYPE_HAL,
                                                           format, 
                                                           (screenmode==FULLSCREEN) ? 0 : 1,//bWindowed,
                                                           check[i], NULL)))
            {
                // add to listbox
                if (i==0)
                    WASABI_API_LNGSTRINGW_BUF(IDS_NONE, str, 256);
                else
                    StringCbPrintfW(str, sizeof(str), L"%2dX", i+1);

                SendMessage( hwnd_listbox, CB_ADDSTRING, nSampleTypes, (LPARAM)str);

                // set the item data to the D3DMULTISAMPLE_TYPE value:
                SendMessage( hwnd_listbox, CB_SETITEMDATA, nSampleTypes, check[i] );

                nSampleTypes++;
            }
        }

        // set prev. selection
        D3DMULTISAMPLE_TYPE prev_seln;
        switch(screenmode)
        {
        case FULLSCREEN:      prev_seln = m_multisample_fullscreen;      break;
        case WINDOWED:        prev_seln = m_multisample_windowed;        break;
        //case FAKE_FULLSCREEN: prev_seln = m_multisample_fake_fullscreen; break;
        case DESKTOP:         prev_seln = m_multisample_desktop;         break;
        }

        for (i=0; i<nSampleTypes; i++)
        {
            int id = SendMessage( hwnd_listbox, CB_GETITEMDATA, i, 0);
            if (id==prev_seln)
            {
                SendMessage( hwnd_listbox, CB_SETCURSEL, i, 0);
                return;
            }
        }

        SendMessage( hwnd_listbox, CB_SETCURSEL, 0, 0);
    }
}

void CPluginShell::UpdateMaxFps(int screenmode)
{
    // initialize sleep combo boxes
    HWND ctrl;
    switch(screenmode)
    {
    case FULLSCREEN:      ctrl = GetDlgItem(g_subwnd, IDC_FS_MAXFPS ); break;
    case WINDOWED:        ctrl = GetDlgItem(g_subwnd, IDC_W_MAXFPS  ); break;
    //case FAKE_FULLSCREEN: ctrl = GetDlgItem(g_subwnd, IDC_FFS_MAXFPS); break;
    case DESKTOP:         ctrl = GetDlgItem(g_subwnd, IDC_DMS_MAXFPS); break;
    }

    SendMessage( ctrl, CB_RESETCONTENT, 0, 0);
    for (int j=0; j<=MAX_MAX_FPS; j++)
    {
        wchar_t buf[256];
        if (j==0)
			WASABI_API_LNGSTRINGW_BUF(IDS_UNLIMITED, buf, 256);
        else 
			swprintf(buf, WASABI_API_LNGSTRINGW(IDS_X_FRAME_SEC), (j<MAX_MAX_FPS)?(MAX_MAX_FPS+1-j):(MAX_MAX_FPS+1-j));

        SendMessageW( ctrl, CB_ADDSTRING, j, (LPARAM)buf);
    }

    // set prev. selection
    int max_fps;
    switch(screenmode)
    {
    case FULLSCREEN:      max_fps = m_max_fps_fs; break;
    case WINDOWED:        max_fps = m_max_fps_w;  break;
    //case FAKE_FULLSCREEN: max_fps = m_max_fps_fake_fs; break;
    case DESKTOP:         max_fps = m_max_fps_dm; break;
    }
    if (max_fps == 0)
        SendMessage(ctrl, CB_SETCURSEL, 0,  0);
    else
        SendMessage(ctrl, CB_SETCURSEL, MAX_MAX_FPS-max_fps+1,  0);
}

int CPluginShell::GetCurrentlySelectedAdapter(int screenmode)
{
    // returns the ordinal adapter #.
    HWND ctrl;
    switch(screenmode)
    {
    case FULLSCREEN:      ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_FS ); break;
    case WINDOWED:        ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_W  ); break;
    //case FAKE_FULLSCREEN: ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_FFS); break;
    case DESKTOP:         ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_DMS); break;
    }

    int n = SendMessage(ctrl, CB_GETCURSEL, 0, 0);
    //if (n != CB_ERR) 
    //    n = SendMessage(ctrl, CB_GETITEMDATA, n, 0);
    if (n != CB_ERR) 
        return n;
    else
        return D3DADAPTER_DEFAULT;
}

void CPluginShell::SaveDisplayMode()
{
    //if (m_fake_fullscreen_mode)
    //    return;

    // read fullscreen display mode
    int n = SendMessage( GetDlgItem( g_subwnd, IDC_DISP_MODE ), CB_GETCURSEL, 0, 0);
    if (n != CB_ERR) 
    {
        // since the combobox contents were sorted, we need to look up the original
        // index into g_disp_mode[]:
        n = SendMessage( GetDlgItem( g_subwnd, IDC_DISP_MODE ), CB_GETITEMDATA, n, 0);
        if (n != CB_ERR)
            m_disp_mode_fs = g_disp_mode[n];
    }
}

void CPluginShell::SaveMultiSamp(int screenmode)
{
    HWND ctrl;
    switch(screenmode)
    {
    case FULLSCREEN:      ctrl = GetDlgItem(g_subwnd, IDC_FSMS);  break;
    case WINDOWED:        ctrl = GetDlgItem(g_subwnd, IDC_WMS);   break;
    //case FAKE_FULLSCREEN: ctrl = GetDlgItem(g_subwnd, IDC_FFSMS); break;
    case DESKTOP:         ctrl = GetDlgItem(g_subwnd, IDC_DMSMS); break;
    }

    // if page tearing is disabled, then multisampling must be disabled, 
    // so ignore multisample selection
    if (g_subwnd && g_nTab==0)
    {
        if (screenmode == WINDOWED && !m_allow_page_tearing_w)
            return;
        if (screenmode == DESKTOP && !m_allow_page_tearing_dm)
            return;
        if (screenmode == FULLSCREEN && m_fake_fullscreen_mode && !m_allow_page_tearing_fs)
            return;
    }

    // read windowed & fullscreen multisampling settings:
    int n = SendMessage(ctrl , CB_GETCURSEL, 0, 0);
    if (n != CB_ERR) 
    {
        n = SendMessage( ctrl, CB_GETITEMDATA, n, 0);
        if (n != CB_ERR)
        {
            switch(screenmode)
            {
            case FULLSCREEN:      m_multisample_fullscreen      = (D3DMULTISAMPLE_TYPE)n; break;
            case WINDOWED:        m_multisample_windowed        = (D3DMULTISAMPLE_TYPE)n; break;
            //case FAKE_FULLSCREEN: m_multisample_fake_fullscreen = (D3DMULTISAMPLE_TYPE)n; break;
            case DESKTOP:         m_multisample_desktop         = (D3DMULTISAMPLE_TYPE)n; break;
            }
        }
    }
}

void CPluginShell::SaveMaxFps(int screenmode)
{
    HWND ctrl;
    switch(screenmode)
    {
    case FULLSCREEN:      ctrl = GetDlgItem(g_subwnd, IDC_FS_MAXFPS);  break;
    case WINDOWED:        ctrl = GetDlgItem(g_subwnd, IDC_W_MAXFPS);   break;
    //case FAKE_FULLSCREEN: ctrl = GetDlgItem(g_subwnd, IDC_FFS_MAXFPS); break;
    case DESKTOP:         ctrl = GetDlgItem(g_subwnd, IDC_DMS_MAXFPS); break;
    }

    // read max fps settings
    int n = SendMessage(ctrl, CB_GETCURSEL, 0, 0);
    if (n != CB_ERR) 
    {
        if (n > 0)
            n = MAX_MAX_FPS+1 - n;

        switch(screenmode)
        {
        case FULLSCREEN:      m_max_fps_fs = n; break;
        case WINDOWED:        m_max_fps_w  = n; break;
        //case FAKE_FULLSCREEN: m_max_fps_fake_fs = n; break;
        case DESKTOP:         m_max_fps_dm = n; break;
        }
    }
}

void CPluginShell::SaveAdapter(int screenmode)
{
    HWND ctrl;
    switch(screenmode)
    {
    case FULLSCREEN:      ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_FS);  break;
    case WINDOWED:        ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_W);   break;
    //case FAKE_FULLSCREEN: ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_FFS); break;
    case DESKTOP:         ctrl = GetDlgItem(g_subwnd, IDC_ADAPTER_DMS); break;
    }

    // save windowed/fullscreen adapter
    int n = SendMessage( ctrl, CB_GETCURSEL, 0, 0);
    if (n != CB_ERR) 
    {
        switch(screenmode)
        {
        case FULLSCREEN:      
            m_adapter_guid_fullscreen      = g_disp_adapter_fs[n].DeviceIdentifier; 
            StringCbCopy(m_adapter_devicename_fullscreen, sizeof(m_adapter_devicename_fullscreen), g_disp_adapter_fs[n].DeviceName);
            //strcpy(m_adapter_desc_fullscreen, g_disp_adapter_fs[n].Description);
            break;
        case WINDOWED:        
            m_adapter_guid_windowed        = g_disp_adapter_w[n].DeviceIdentifier;  
            StringCbCopy(m_adapter_devicename_windowed, sizeof(m_adapter_devicename_windowed), g_disp_adapter_fs[n].DeviceName);
            //strcpy(m_adapter_desc_windowed, g_disp_adapter_fs[n].Description);
            break;
        //case FAKE_FULLSCREEN: 
            //m_adapter_guid_fake_fullscreen = g_disp_adapter_w[n].DeviceIdentifier;  
            //strcpy(m_adapter_desc_fake_fullscreen, g_disp_adapter_fs[n].Description);
            //break; // [sic]
        case DESKTOP:         
            m_adapter_guid_desktop         = g_disp_adapter_dm[n].DeviceIdentifier;  
            StringCbCopy(m_adapter_devicename_desktop, sizeof(m_adapter_devicename_desktop), g_disp_adapter_fs[n].DeviceName);
            //strcpy(m_adapter_desc_desktop, g_disp_adapter_fs[n].Description);
            break; 
        }
    }
}

/*
BOOL CALLBACK GenericTabCtrlProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
    return 0;
}
*/

// OnTabChanged - processes the TCN_SELCHANGE notification. 
void CPluginShell::OnTabChanged(int nNewTab) 
{ 
    if (g_subwnd)
    {
        DestroyWindow(g_subwnd);
        g_subwnd = NULL;
    }

    g_nTab = nNewTab;

    if (g_nTab >= 0 && g_nTab < MAX_PROPERTY_PAGES)
    {
		HWND h = WASABI_API_CREATEDIALOGPARAMW(g_proppage_id[g_nTab], g_config_hwnd, this->TabCtrlProc, (LPARAM)this);
		// NOTE: CreateDialogParam will call TabCtrlProc with WM_INITDIALOG,
        // which is where 'g_subwnd' will get set.

        // do this here to ensure that the current prefs page is correctly themed
        if(!SendMessage(this->m_hWndWinamp,WM_WA_IPC,IPC_ISWINTHEMEPRESENT,IPC_USE_UXTHEME_FUNC))
        {
            SendMessage(this->m_hWndWinamp,WM_WA_IPC,(WPARAM)h,IPC_USE_UXTHEME_FUNC);
        }
    }
}

INT_PTR CALLBACK CPluginShell::TabCtrlProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
    if (msg==WM_INITDIALOG && lParam > 0 && GetWindowLongPtr(hwnd,GWLP_USERDATA)==0)
        SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);

    CPluginShell* p = (CPluginShell*)GetWindowLongPtr(hwnd,GWLP_USERDATA);

    if (p && g_nTab >= 0 && g_nTab < MAX_PROPERTY_PAGES)
    {
        if (msg==WM_INITDIALOG)
            g_subwnd = hwnd;

        if (g_nTab==0)
            p->PluginShellConfigTab1Proc(hwnd, msg, wParam, lParam);
        p->MyConfigTabProc(g_nTab+1, hwnd, msg, wParam, lParam);
        
        if (msg==WM_INITDIALOG)
        {
            // once it has been initialized, reposition the subdialog:
            RECT r;
		    GetWindowRect(GetDlgItem(g_config_hwnd,IDC_RECT),&r);
		    ScreenToClient(g_config_hwnd,(LPPOINT)&r);
		    SetWindowPos(g_subwnd,0,r.left,r.top,0,0,SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
	        ShowWindow(g_subwnd,SW_SHOWNA);
        }
    }

	const int controls[] = 
	{
		IDC_BRIGHT_SLIDER,
		IDC_HARDCUT_LOUDNESS,
	};
	if (FALSE != WASABI_API_APP->DirectMouseWheel_ProcessDialogMessage(hwnd, msg, wParam, lParam, controls, ARRAYSIZE(controls)))
	{
		return TRUE;
	}

    return FALSE;
}

BOOL CPluginShell::PluginShellConfigTab1Proc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
    #ifdef _DEBUG
        OutputDebugMessage("   Tab1Proc: ", hwnd, msg, wParam, lParam);
    #endif

    switch (msg)
    {
    case WM_INITDIALOG:
        {
            // pre-checks
            if (m_start_fullscreen && m_start_desktop)
                m_start_desktop = 0;
            if (!mod1.hwndParent || SendMessage(mod1.hwndParent,WM_WA_IPC,0,0) < 0x2900)
            {
                m_skin = 0;
                EnableWindow(GetDlgItem(hwnd,IDC_CB_SKIN), 0);
                char buf[256];
                buf[0] = 0;
                GetWindowText(GetDlgItem(hwnd,IDC_CB_SKIN), buf, 255);
                StringCbCat(buf, sizeof(buf), " 2.90+");
                SetWindowText(GetDlgItem(hwnd,IDC_CB_SKIN), buf);
            }

            // set checkboxes
            CheckDlgButton(hwnd, IDC_CB_FS,  m_start_fullscreen);
            CheckDlgButton(hwnd, IDC_CB_DMS,  m_start_desktop);
            CheckDlgButton(hwnd, IDC_CB_FAKE, m_fake_fullscreen_mode);
            CheckDlgButton(hwnd, IDC_CB_PRESS_F1_MSG, m_show_press_f1_msg);
            CheckDlgButton(hwnd, IDC_CB_WPT, m_allow_page_tearing_w);
            CheckDlgButton(hwnd, IDC_CB_FSPT, m_allow_page_tearing_fs);
            CheckDlgButton(hwnd, IDC_CB_DMSPT, m_allow_page_tearing_dm);
            CheckDlgButton(hwnd, IDC_CB_MIN, m_minimize_winamp);
            CheckDlgButton(hwnd, IDC_CB_SAVE_CPU, m_save_cpu);
            CheckDlgButton(hwnd, IDC_CB_SKIN, m_skin);
			CheckDlgButton(hwnd, IDC_CB_FIXSLOWTEXT, m_fix_slow_text);
            CheckDlgButton(hwnd, IDC_CB_VJMODE, m_vj_mode);

            // Enumerate available adapters.
            UpdateAdapters(0);    // fullscreen
              //-calls UpdateFSAdapterDispModes()
              //-which then calls UpdateDispModeMultiSampling(0).
            UpdateAdapters(1);    // windowed
              //-skips UpdateFSAdapterDispModes() (not necessary for windowed mode)
              //-then calls UpdateDispModeMultiSampling(1).
            UpdateAdapters(3);    // desktop
              //-skips UpdateFSAdapterDispModes() (not necessary for fake fullscreen mode)
              //-then calls UpdateDispModeMultiSampling(2).
            UpdateMaxFps(0);
            UpdateMaxFps(1);
            UpdateMaxFps(3); // desktop

            // disable a few things if fake fullscreen mode enabled:
            EnableWindow(GetDlgItem(hwnd, IDC_DISP_MODE), !m_fake_fullscreen_mode);
            //EnableWindow(GetDlgItem(hwnd, IDC_FSMS), !m_fake_fullscreen_mode);
        }        
        break;

    case WM_DESTROY:
        {
            // read checkboxes
            m_start_fullscreen     = DlgItemIsChecked(hwnd, IDC_CB_FS   );
            m_start_desktop        = DlgItemIsChecked(hwnd, IDC_CB_DMS  );
            m_fake_fullscreen_mode = DlgItemIsChecked(hwnd, IDC_CB_FAKE );
            m_show_press_f1_msg    = DlgItemIsChecked(hwnd, IDC_CB_PRESS_F1_MSG);
            m_allow_page_tearing_w = DlgItemIsChecked(hwnd, IDC_CB_WPT  );
            m_allow_page_tearing_fs= DlgItemIsChecked(hwnd, IDC_CB_FSPT  );
            m_allow_page_tearing_dm= DlgItemIsChecked(hwnd, IDC_CB_DMSPT);
            m_minimize_winamp      = DlgItemIsChecked(hwnd, IDC_CB_MIN  );
            m_save_cpu             = DlgItemIsChecked(hwnd, IDC_CB_SAVE_CPU );
            m_fix_slow_text        = DlgItemIsChecked(hwnd, IDC_CB_FIXSLOWTEXT);
            m_vj_mode              = DlgItemIsChecked(hwnd, IDC_CB_VJMODE);
            
            if (mod1.hwndParent && SendMessage(mod1.hwndParent,WM_WA_IPC,0,0) >= 0x2900)
                m_skin             = DlgItemIsChecked(hwnd, IDC_CB_SKIN );

            // read all 3 adapters
            SaveAdapter(0);
            SaveAdapter(1);
            SaveAdapter(3);

            // read fullscreen display mode
            SaveDisplayMode();

            // read all 3 multisampling settings:
            SaveMultiSamp(0);
            SaveMultiSamp(1);
            SaveMultiSamp(3);

            // read all 3 max fps settings
            SaveMaxFps(0);
            SaveMaxFps(1);
            SaveMaxFps(3);
        }
        break;

    case WM_COMMAND:
        if (!g_ignore_clicks)
        {
            int id = LOWORD(wParam);
            g_ignore_clicks = 1;
            switch(id)
            {
			case ID_FONTS:
                WASABI_API_DIALOGBOXPARAMW(IDD_FONTDIALOG, hwnd, FontDialogProc, (LPARAM)this);
                break;

			case ID_DM_MORE:
                WASABI_API_DIALOGBOXPARAMW(IDD_DESKTOPMODE, hwnd, DesktopOptionsDialogProc, (LPARAM)this);
                break;

			case ID_DUALHEAD:
                WASABI_API_DIALOGBOXPARAMW(IDD_DUALHEAD, hwnd, DualheadDialogProc, (LPARAM)this);
                break;

            case IDC_ADAPTER_FS:
                SaveDisplayMode();
                SaveMultiSamp(FULLSCREEN);
                SaveAdapter(0);
                UpdateFSAdapterDispModes();
                break;

            case IDC_ADAPTER_W:
                SaveMultiSamp(WINDOWED);
                UpdateDispModeMultiSampling(WINDOWED);
                break;

                /*
            case IDC_ADAPTER_FFS:
                SaveMultiSamp(FAKE_FULLSCREEN);
                UpdateDispModeMultiSampling(FAKE_FULLSCREEN);
                break;
                */

            case IDC_ADAPTER_DMS:
                SaveMultiSamp(DESKTOP);
                UpdateDispModeMultiSampling(DESKTOP);
                break;
                
            case IDC_DISP_MODE:
                SaveMultiSamp(FULLSCREEN);
                UpdateDispModeMultiSampling(FULLSCREEN);
                break;

            case IDC_CB_WPT:
                SaveMultiSamp(WINDOWED);
                m_allow_page_tearing_w = DlgItemIsChecked(hwnd, IDC_CB_WPT);
                UpdateDispModeMultiSampling(WINDOWED);
                break;

            case IDC_CB_FSPT:
                SaveMultiSamp(FULLSCREEN);
                m_allow_page_tearing_fs = DlgItemIsChecked(hwnd, IDC_CB_FSPT);
                UpdateDispModeMultiSampling(FULLSCREEN);
                break;

            case IDC_CB_DMSPT:
                SaveMultiSamp(DESKTOP);
                m_allow_page_tearing_dm = DlgItemIsChecked(hwnd, IDC_CB_DMSPT);
                UpdateDispModeMultiSampling(DESKTOP);
                break;

            case IDC_CB_FS:
                m_start_fullscreen     = DlgItemIsChecked(hwnd, IDC_CB_FS   );
                if (m_start_fullscreen && m_start_desktop)
                {
                    m_start_desktop = 0;
                    CheckDlgButton(hwnd, IDC_CB_DMS,  m_start_desktop);
                }
                break;
            
            case IDC_CB_DMS:
                m_start_desktop        = DlgItemIsChecked(hwnd, IDC_CB_DMS  );
                if (m_start_fullscreen && m_start_desktop)
                {
                    m_start_fullscreen = 0;
                    CheckDlgButton(hwnd, IDC_CB_FS,  m_start_fullscreen);
                }
                break;

            case IDC_CB_FAKE:
                SaveMultiSamp(FULLSCREEN);
                m_fake_fullscreen_mode = DlgItemIsChecked(hwnd, IDC_CB_FAKE );
                EnableWindow(GetDlgItem(hwnd, IDC_DISP_MODE), !m_fake_fullscreen_mode);
                CheckDlgButton(hwnd, IDC_CB_FSPT, m_fake_fullscreen_mode ? m_allow_page_tearing_fs : 0);
                EnableWindow(GetDlgItem(hwnd, IDC_CB_FSPT), m_fake_fullscreen_mode ? 1 : 0);
                UpdateDispModeMultiSampling(FULLSCREEN);
                break;

                /*
            case IDC_CB_FFSPT:
                SaveMultiSamp(FAKE_FULLSCREEN);
                m_allow_page_tearing_fake_fs = DlgItemIsChecked(hwnd, IDC_CB_FFSPT);
                UpdateDispModeMultiSampling(FAKE_FULLSCREEN);
                break;
                */
            }
            g_ignore_clicks = 0;
        }
        break;  // case WM_COMMAND

    case WM_HELP:
        if (lParam)
        {
            HELPINFO *ph = (HELPINFO*)lParam;
            wchar_t title[1024];
            wchar_t buf[2048];
            wchar_t ctrl_name[1024];
            GetWindowTextW(GetDlgItem(hwnd, ph->iCtrlId), ctrl_name, sizeof(ctrl_name)/sizeof(*ctrl_name));
            RemoveSingleAmpersands(ctrl_name);
            buf[0] = 0;
            
            switch(ph->iCtrlId)
            {
            case ID_FONTS:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
                WASABI_API_LNGSTRINGW_BUF(IDS_FONTS_HELP, buf, 2048);
                break;

            case ID_DUALHEAD:
				StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
                WASABI_API_LNGSTRINGW_BUF(IDS_DUAL_HEAD_HELP, buf, 2048);
                break;

            case IDC_W_MULTISAMPLING_CAPTION:
            case IDC_FS_MULTISAMPLING_CAPTION:
            case IDC_DMS_MULTISAMPLING_CAPTION:
            //case IDC_FFS_MULTISAMPLING_CAPTION:
            case IDC_WMS:
            case IDC_FSMS:
            case IDC_DMSMS:
            //case IDC_FFSMS:
                WASABI_API_LNGSTRINGW_BUF(IDS_MULTI_SAMPLING, title, 1024);
                WASABI_API_LNGSTRINGW_BUF(IDS_MULTI_SAMPLING_HELP, buf, 2048);
                break;

            case IDC_W_MAXFPS:
            case IDC_FS_MAXFPS:
            case IDC_DMS_MAXFPS:
            //case IDC_FFS_MAXFPS:
            case IDC_W_MAXFPS_CAPTION:
            case IDC_FS_MAXFPS_CAPTION:
            case IDC_DMS_MAXFPS_CAPTION:
            //case IDC_FFS_MAXFPS_CAPTION:
                WASABI_API_LNGSTRINGW_BUF(IDS_MAX_FRAMERATE, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_MAX_FRAMERATE_HELP, buf, 2048);
                break;

            case IDC_CB_FAKE:
                WASABI_API_LNGSTRINGW_BUF(IDS_FAKE_FULLSCREEN, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_FAKE_FULLSCREEN_HELP, buf, 2048);
                break;

            case IDC_ADAPTER_FS:
            case IDC_FS_ADAPTER_CAPTION:
                WASABI_API_LNGSTRINGW_BUF(IDS_FULLSCREEN_ADAPTER, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_FULLSCREEN_ADAPTER_HELP, buf, 2048);
                break;

            case IDC_ADAPTER_W:
            case IDC_W_ADAPTER_CAPTION:
				WASABI_API_LNGSTRINGW_BUF(IDS_WINDOWED_ADPATER, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_WINDOWED_ADPATER_HELP, buf, 2048);
                break;

            case IDC_ADAPTER_DMS:
            case IDC_DMS_ADAPTER_CAPTION:
				WASABI_API_LNGSTRINGW_BUF(IDS_DESKTOP_ADAPTER, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_DESKTOP_ADAPTER_HELP, buf, 2048);
                break;

            case IDC_DISP_MODE:
            case IDC_DISP_MODE_CAPTION:
                WASABI_API_LNGSTRINGW_BUF(IDS_FS_DISPLAY_MODE, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_FS_DISPLAY_MODE_HELP, buf, 2048);
                break;

            case IDC_CB_WPT:
            case IDC_CB_FSPT:
            case IDC_CB_DMSPT:
            //case IDC_CB_FFSPT:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_CHECKBOX), ctrl_name);
				WASABI_API_LNGSTRINGW_BUF(IDS_HELP_ON_X_CHECKBOX_HELP, buf, 2048);
                break;

            case IDC_CB_FS:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_CHECKBOX), ctrl_name);
                WASABI_API_LNGSTRINGW_BUF(IDS_FORCE_INTO_FS_MODE_HELP, buf, 2048);
                break;

            case IDC_CB_DMS:
				StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_CHECKBOX), ctrl_name);
                WASABI_API_LNGSTRINGW_BUF(IDS_FORCE_INTO_DESKTOP_MODE_HELP, buf, 2048);
                break;

            case IDC_CB_PRESS_F1_MSG:
                WASABI_API_LNGSTRINGW_BUF(IDS_HELP_ON_F1, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_HELP_ON_F1_HELP, buf, 2048);
                break;

            case IDC_CB_SKIN:
				StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_CHECKBOX), ctrl_name);
				WASABI_API_LNGSTRINGW_BUF(IDS_CB_SKIN_HELP, buf, 2048);
                break;

            case IDC_CB_SAVE_CPU:
                WASABI_API_LNGSTRINGW_BUF(IDS_SAVE_CPU_CHECKBOX, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_SAVE_CPU_CHECKBOX_HELP, buf, 2048);
                break;

            case IDC_CB_MIN:
                WASABI_API_LNGSTRINGW_BUF(IDS_HELP_MINIMIZE_WINAMP, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_HELP_MINIMIZE_WINAMP_HELP, buf, 2048);
                break;

            case IDC_CB_FIXSLOWTEXT:
                WASABI_API_LNGSTRINGW_BUF(IDS_TRY_TO_FIX_SLOW_TEXT, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_TRY_TO_FIX_SLOW_TEXT_HELP, buf, 2048);
                break;

            case IDC_CB_VJMODE:
                WASABI_API_LNGSTRINGW_BUF(IDS_VJ_MODE, title, 1024);
				WASABI_API_LNGSTRINGW_BUF(IDS_VJ_MODE_HELP, buf, 2048);
                break;

            case IDC_DMS_LABEL:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X), ctrl_name);
				WASABI_API_LNGSTRINGW_BUF(IDS_DMS_LABEL_HELP, buf, 2048);
                break;

            case IDC_FS_LABEL:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X), ctrl_name);
				WASABI_API_LNGSTRINGW_BUF(IDS_FS_LABEL_HELP, buf, 2048);
                break;
                
            case IDC_W_LABEL:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X), ctrl_name);
				WASABI_API_LNGSTRINGW_BUF(IDS_W_LABEL_HELP, buf, 2048);
                break;

            case ID_DM_MORE:
                StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X), ctrl_name);
				WASABI_API_LNGSTRINGW_BUF(IDS_DM_MORE_HELP, buf, 2048);
                break;
            }

            if (buf[0])
                MessageBoxW(hwnd, buf, title, MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);

        }
        break;  // case WM_HELP
    }

    return 0;
}

BOOL CALLBACK CPluginShell::ConfigDialogProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
    if (msg==WM_INITDIALOG && lParam > 0 && GetWindowLongPtr(hwnd,GWLP_USERDATA)==0)
			SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);

    CPluginShell* p = (CPluginShell*)GetWindowLongPtr(hwnd,GWLP_USERDATA);

    if (p)
        return p->PluginShellConfigDialogProc(hwnd, msg, wParam, lParam);
    else
        return FALSE;
}

BOOL CPluginShell::PluginShellConfigDialogProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
    #ifdef _DEBUG
        OutputDebugMessage("CfgDlgProc:  ", hwnd, msg, wParam, lParam);
    #endif

    switch (msg)
    {
    case WM_DESTROY:
        EndConfig();
        return 0;

    case WM_INITDIALOG:
        { 
            // Initialize all config panel global variables:
            if (!InitConfig(hwnd))
            {
				wchar_t title[64];
                MessageBoxW(hwnd, WASABI_API_LNGSTRINGW(IDS_INITCONFIG_FAILED),
						    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
						    MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);
                EndConfig();
                int id=LOWORD(wParam);
                EndDialog(hwnd,id);
                return false;
            }

            // set window caption
            SetWindowText( hwnd, WINDOWCAPTION );

            // Test for DirectX 9 + start it
            // note: if you don't call LoadLibrary here, and you're on a system
            //       where DX9 is missing, Direct3DCreate9() might crash; so call it.
            int d3d9_already_loaded = (GetModuleHandle("d3d9.dll") != NULL) ? 1 : 0;
            if (!d3d9_already_loaded)
                g_hmod_d3d9 = LoadLibrary("d3d9.dll");

            if ( (!d3d9_already_loaded && !g_hmod_d3d9) ||
                 !(g_lpDX = Direct3DCreate9(D3D_SDK_VERSION))
               )
            {
                MissingDirectX(hwnd);

                EndConfig();
                int id=LOWORD(wParam);
                EndDialog(hwnd,id);
                return false;
            }

				    if (!g_hmod_d3dx9)
					    g_hmod_d3dx9 = FindD3DX9(GetWinampWindow());

						if ((!g_hmod_d3dx9))
						{
	 		        MissingDirectX(hwnd);
              EndConfig();
              int id=LOWORD(wParam);
              EndDialog(hwnd,id);
              return false;
						}
                
            // enable the 'view website' button only if plugin author has #defined a URL (in defines.h):
            #ifndef PLUGIN_WEB_URL
                ShowWindow(GetDlgItem(hwnd, ID_WEB), SW_HIDE);
            #else
                if (wcslen(PLUGIN_WEB_URL)==0)
                    ShowWindow(GetDlgItem(hwnd, ID_WEB), SW_HIDE);
            #endif

            // enable the 'view docs' button only if plugin author has #defined a filename (in defines.h):
            #ifndef DOCFILE
                ShowWindow(GetDlgItem(hwnd, ID_DOCS), SW_HIDE);
            #else
                if (wcslen(DOCFILE)==0)
                    ShowWindow(GetDlgItem(hwnd, ID_DOCS), SW_HIDE);
            #endif

            // set contents of IDC_SZ_ABOUT
			wchar_t about[256];
			StringCchPrintfW(about, 256, WASABI_API_LNGSTRINGW(IDS_ABOUT_STRING), LONGNAMEW, AUTHOR_NAME, COPYRIGHT);
            SetDlgItemTextW(hwnd, IDC_SZ_ABOUT, about);

            // initialize tab control:
            {
				HWND tabWnd = GetDlgItem(hwnd,IDC_TABS);
                // Add Tabs:
                if (!AddButton(0, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_1)) ||
                    !AddButton(1, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_2)) ||
                    !AddButton(2, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_3)) ||
                    !AddButton(3, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_4)) ||
                    !AddButton(4, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_5)) ||
                    !AddButton(5, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_6)) ||
                    !AddButton(6, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_7)) ||
                    !AddButton(7, tabWnd, WASABI_API_LNGSTRINGW(IDS_CONFIG_PANEL_BUTTON_8)))
                {
					wchar_t title[64];
                    MessageBoxW(hwnd, WASABI_API_LNGSTRINGW(IDS_UNABLE_TO_LOAD_TABS),
							    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
							    MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);
                    EndConfig();
                    int id=LOWORD(wParam);
                    EndDialog(hwnd,id);
                    return false;
                }

                // Simulate selection of the first tab. 
				int last_tab = GetPrivateProfileIntW(L"settings",L"last_tab",0,m_szConfigIniFile);
				TabCtrl_SetCurSel(tabWnd, last_tab);
                OnTabChanged(last_tab);
            }

            g_ignore_clicks = 0;

            SetFocus(hwnd);
        }
        return 0;

    case WM_NOTIFY: 
        if (!g_ignore_clicks)
        {
            LPNMHDR pnmh = (LPNMHDR)lParam;
            switch(pnmh->code)
            {
            case TCN_SELCHANGE: 
                OnTabChanged(TabCtrl_GetCurSel(GetDlgItem(hwnd,IDC_TABS)));
                break;
            }
        }
        break;

    case WM_COMMAND:
        if (!g_ignore_clicks)
        {
            int id = LOWORD(wParam);
            switch(id)
            {
            case IDOK:
                // kill current tab window, so that its settings get read
				WritePrivateProfileIntW(TabCtrl_GetCurSel(GetDlgItem(hwnd,IDC_TABS)),L"last_tab",m_szConfigIniFile,L"settings");
                OnTabChanged(-1);

                // then save new config
                WriteConfig();

                EndDialog(hwnd,id);
                return 0;
            
            case IDCANCEL:
				WritePrivateProfileIntW(TabCtrl_GetCurSel(GetDlgItem(hwnd,IDC_TABS)),L"last_tab",m_szConfigIniFile,L"settings");
                EndDialog(hwnd,id);
                return 0;

            case ID_DOCS:
                {
                    wchar_t szPath[512], szFile[512];
                    lstrcpyW(szPath, m_szPluginsDirPath);
                    lstrcpyW(szFile, szPath);
                    lstrcatW(szFile, DOCFILE);
					
					intptr_t ret = myOpenURL(0,szFile);
                    if (ret <= 32)
                    {
                        wchar_t buf[1024];
                        switch(ret)
                        {
                        case SE_ERR_FNF:
                        case SE_ERR_PNF:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_DOCUMENTATION_FILE_NOT_FOUND), szFile);
                            break;
                        case SE_ERR_ACCESSDENIED:
                        case SE_ERR_SHARE:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_ACCESS_TO_DOCUMENTATION_FILE_DENIED), szFile);
                            break;
                        case SE_ERR_NOASSOC:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_ACCESS_TO_DOCUMENTATION_FILE_FAILED_DUE_TO_NO_ASSOC), szFile);
                            break;
                        default:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_ACCESS_TO_DOCUMENTATION_FILE_FAILED_CODE_X), szFile, ret);
                            break;
                        }
                        MessageBoxW(hwnd, buf, WASABI_API_LNGSTRINGW(IDS_ERROR_OPENING_DOCUMENTATION), MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);
                    }
                }
                break;

            case ID_WEB:
                {
                    intptr_t ret = myOpenURL(NULL, PLUGIN_WEB_URL);
                    if (ret <= 32)
                    {
                        wchar_t buf[1024];
                        switch(ret)
                        {
                        case SE_ERR_FNF:
                        case SE_ERR_PNF:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_URL_COULD_NOT_OPEN), PLUGIN_WEB_URL);
                            break;
                        case SE_ERR_ACCESSDENIED:
                        case SE_ERR_SHARE:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_ACCESS_TO_URL_WAS_DENIED), PLUGIN_WEB_URL);
                            break;
                        case SE_ERR_NOASSOC:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_ACCESS_TO_URL_FAILED_DUE_TO_NO_ASSOC), PLUGIN_WEB_URL);
                            break;
                        default:
                            StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_ACCESS_TO_URL_FAILED_CODE_X), PLUGIN_WEB_URL, ret);
                            break;
                        }
                        MessageBoxW(hwnd, buf, WASABI_API_LNGSTRINGW(IDS_ERROR_OPENING_URL), MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);
                    }
                }
                break;

            case ID_DEFAULTS:
				wchar_t title[64];
                if (IDYES == MessageBoxW(hwnd, WASABI_API_LNGSTRINGW(IDS_RESTORE_ALL_DEFAULTS),
										 WASABI_API_LNGSTRINGW_BUF(IDS_RESTORE_ALL_DEFAULTS_TITLE, title, 64),
										 MB_YESNO|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL))
                {
                    DeleteFileW(m_szConfigIniFile);
                    Sleep(100);
                    EndDialog(hwnd,id);
                }
                break;

            default:
                return 0;
            }
        }
        break;        // case WM_COMMAND

    case WM_HELP:
        if (lParam)
				{
					HELPINFO *ph = (HELPINFO*)lParam;
					wchar_t title[1024];
					wchar_t buf[2048];
					wchar_t ctrl_name[1024];
					GetWindowTextW(GetDlgItem(hwnd, ph->iCtrlId), ctrl_name, sizeof(ctrl_name)/sizeof(*ctrl_name));
					RemoveSingleAmpersands(ctrl_name);
					buf[0] = 0;
					switch(ph->iCtrlId)
					{
					case IDOK:
						StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
						WASABI_API_LNGSTRINGW_BUF(IDS_OK_HELP, buf, 2048);
						break;

					case IDCANCEL:
						StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
						WASABI_API_LNGSTRINGW_BUF(IDS_CANCEL_HELP, buf, 2048);
						break;

					case ID_DEFAULTS:
						StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
						WASABI_API_LNGSTRINGW_BUF(IDS_RESTORE_DEFAULTS_HELP, buf, 2048);
						break;

					case ID_DOCS:
						StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
						WASABI_API_LNGSTRINGW_BUF(IDS_DOCUMENTATION_BUTTON_HELP, buf, 2048);
						break;

					case ID_WEB:
						StringCbPrintfW(title, sizeof(title), WASABI_API_LNGSTRINGW(IDS_HELP_ON_X_BUTTON), ctrl_name);
						WASABI_API_LNGSTRINGW_BUF(IDS_VIEW_ONLINE_DOCS_HELP, buf, 2048);
						break;

					default:
						return 0;
					}

					if (buf[0])
						MessageBoxW(hwnd, buf, title, MB_OK|MB_SETFOREGROUND|MB_TOPMOST|MB_TASKMODAL);
				}
        break;  // case WM_HELP
    } 

    return 0;
}