winamp/Src/Plugins/Visualization/vis_avs/wnd.cpp

/*
  LICENSE
  -------
Copyright 2005 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 <stdio.h>
#include <windows.h>
#include <windowsx.h>
#include "vis.h"
#include "draw.h"
#include "wnd.h"
#include "cfgwnd.h"
#include "r_defs.h"
#include "resource.h"
#include "render.h"
#include "undo.h"
#include <multimon.h>

#include "avs_eelif.h"

#define WINAMP_NEXT_WINDOW 40063
#include "wa_ipc.h"
#include "ff_ipc.h"
#include "../Agave/Language/api_language.h"

#ifndef WS_EX_LAYERED
#define WS_EX_LAYERED	0x80000
#endif

#ifndef LWA_ALPHA
#define LWA_ALPHA		2
#endif

#define ID_VIS_NEXT                     40382
#define ID_VIS_PREV                     40383
#define ID_VIS_RANDOM                   40384

struct winampVisModule *g_mod;
extern volatile int g_ThreadQuit;
extern int /*g_preset_dirty,*/ config_prompt_save_preset, config_reuseonresize;
int g_saved_preset_dirty;
extern int cfg_cancelfs_on_deactivate;

extern char g_noeffectstr[];
#ifndef WA2_EMBED
static int cfg_x=100, cfg_y=100, cfg_w=400, cfg_h=300;
#endif

#ifndef WA2_EMBED
static HDC hFrameDC;
static HBITMAP hFrameBitmap, hFrameBitmap_old;
#else
embedWindowState myWindowState;
HWND g_hWA2ParentWindow;
#endif

int g_reset_vars_on_recompile=1; // fucko: add config for this


// Wharf integration
int inWharf=0;
int need_redock=0;

extern int cfg_fs_use_overlay;
extern int g_config_seh;


void toggleWharfAmpDock(HWND hwnd);

//-

int g_in_destroy=0,g_minimized=0,g_fakeinit=0;

int g_rnd_cnt;
char g_skin_name[MAX_PATH];

int debug_reg[8];

void GetClientRect_adj(HWND hwnd, RECT *r)
{
  GetClientRect(hwnd,r);
#ifndef WA2_EMBED
  if (!inWharf)
  {
    r->right-=7+6;
    r->bottom-=15+5;
  }
#endif
}

HWND g_hwnd;

HWND hwnd_WinampParent;
extern HWND g_hwndDlg;
extern char last_preset[2048];
char *scanstr_back(char *str, char *toscan, char *defval)
{
	char *s=str+strlen(str)-1;
	if (strlen(str) < 1) return defval;
	if (strlen(toscan) < 1) return defval;
	while (1)
	{
		char *t=toscan;
		while (*t)
			if (*t++ == *s) return s;
		t=CharPrev(str,s);
		if (t==s) return defval;
		s=t;
	}
}	

int LoadPreset(int preset)
{
  char temp[MAX_PATH];
  wsprintf(temp,"%s\\PRESET%02d.APH",g_path,preset);
  if (g_render_transition->LoadPreset(temp,1))
    return 0;
  if (preset < 12) wsprintf(last_preset,"\\F%d.aph",preset+1);
  else if (preset < 22) wsprintf(last_preset,"\\%d.aph",preset-12);
  else if (preset < 32) wsprintf(last_preset,"\\Shift-%d.aph",preset-22);
  return 1;
}

void WritePreset(int preset)
{
  char temp[MAX_PATH];
  wsprintf(temp,"%s\\PRESET%02d.APH",g_path,preset);
  g_render_effects->__SavePreset(temp);
}

void my_getViewport( RECT *r, RECT *sr )
{
    if ( sr )
    {
        HINSTANCE h = LoadLibraryW( L"user32.dll" );
        if ( h )
        {
            HMONITOR( WINAPI * Mfr )( LPCRECT lpcr, DWORD dwFlags ) = ( HMONITOR( WINAPI * )( LPCRECT, DWORD ) ) GetProcAddress( h, "MonitorFromRect" );
            BOOL( WINAPI * Gmi )( HMONITOR mon, LPMONITORINFO lpmi ) = ( BOOL( WINAPI * )( HMONITOR, LPMONITORINFO ) ) GetProcAddress( h, "GetMonitorInfoW" );
            if ( Mfr && Gmi )
            {
                HMONITOR hm;
                hm = Mfr( sr, MONITOR_DEFAULTTONULL );
                if ( hm )
                {
                    MONITORINFOEXW mi;
                    memset( &mi, 0, sizeof( mi ) );
                    mi.cbSize = sizeof( mi );

                    if ( Gmi( hm, &mi ) )
                    {
                        *r = mi.rcWork;
                        return;
                    }
                }
            }
            FreeLibrary( h );
        }
    }
    SystemParametersInfoW( SPI_GETWORKAREA, 0, r, 0 );
}


void SetTransparency(HWND hWnd, int enable, int amount)
{
#ifdef WA2_EMBED
  // disable transparency if hosted in gen_ff
  HWND w = myWindowState.me;
  while (GetWindowLong(w, GWL_STYLE) & WS_CHILD) w = GetParent(w);
  char classname[256];
  GetClassName(w, classname, 255); classname[255] = 0;
  if (!stricmp(classname, "BaseWindow_RootWnd")) return;
  // --
#endif
  
	DWORD dwLong;
	HINSTANCE h;
	void (__stdcall *a)(HWND h, int a, int b, int c);

  hWnd=GetParent(hWnd);

	dwLong = GetWindowLong(hWnd, GWL_EXSTYLE);
	if(amount==255||!enable) {
		if(dwLong&WS_EX_LAYERED)
			SetWindowLong(hWnd, GWL_EXSTYLE, dwLong & ~WS_EX_LAYERED);
	} else {
		if(!(dwLong&WS_EX_LAYERED))
			SetWindowLong(hWnd, GWL_EXSTYLE, dwLong | WS_EX_LAYERED);
		h=LoadLibrary("USER32.DLL");
		if(h!=NULL) {
			a=(void (__stdcall *)(HWND,int,int,int))GetProcAddress(h,"SetLayeredWindowAttributes");
			if(a!=NULL) 
				a(hWnd, RGB(0,0,0), amount, LWA_ALPHA);
			FreeLibrary(h);
		}
	}
}

int readyToLoadPreset(HWND parent, int isnew)
{
  if (config_prompt_save_preset && C_UndoStack::isdirty())
  {
    static int here;
    if (here) return 0;
    here=1;
    
    // strange bugfix, ick
    void Wnd_GoWindowed(HWND hwnd);
    if (DDraw_IsFullScreen()) Wnd_GoWindowed(g_hwnd);

    char title[48];
    int ret=MessageBox(parent,
		       WASABI_API_LNGSTRING(!isnew?IDS_CURRENT_PRESET_EDITED_SAVE_BEFORE_LOAD:
						   IDS_CURRENT_PRESET_EDITED_SAVE_BEFORE_NEW),
		       WASABI_API_LNGSTRING_BUF(IDS_AVS_PRESET_MODIFIED,title,48),MB_YESNOCANCEL);
    here=0;

    if (ret == IDCANCEL)
    {
      return 0;
    }
    if (ret == IDYES)
    {
      int dosavePreset(HWND hwndDlg);
      int r=1;
//      if (last_preset[0])
  //      r=g_render_effects->SavePreset(last_preset);

      if (r) 
      {
        if (dosavePreset(parent)) return 0;
      }
    }
  }
  //C_UndoStack::clear();
  // g_preset_dirty=0;
  return 1;
}

char *extension(char *fn) 
{
  char *s = fn + strlen(fn);
  while (s >= fn && *s != '.' && *s != '\\') s--;
  if (s < fn) return fn;
  if (*s == '\\') return fn;
  return (s+1);
}

static int last_windowed_w, last_windowed_h;
void Wnd_GoWindowed(HWND hwnd)
{
  if (DDraw_IsFullScreen())
  {
#ifdef WA2_EMBED
  SendMessage(g_mod->hwndParent,WM_WA_IPC,0,IPC_SET_VIS_FS_FLAG);
#endif
#if !defined(WA2_EMBED)
		DDraw_SetFullScreen(0,cfg_w-7-6,cfg_h-15-5,cfg_fs_d&2,0);
#else
    SetParent(hwnd,myWindowState.me);
    SetWindowLong(hwnd,GWL_STYLE,WS_VISIBLE|WS_CHILDWINDOW|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_OVERLAPPED);
		DDraw_SetFullScreen(0,last_windowed_w,last_windowed_h,cfg_fs_d&2,0);
    HWND w = myWindowState.me;
    while (GetWindowLong(w, GWL_STYLE) & WS_CHILD) w = GetParent(w);
    ShowWindow(w,SW_SHOWNA);
#endif

		if (cfg_cancelfs_on_deactivate) ShowCursor(TRUE);
    int tm=(GetWindowLong(g_mod->hwndParent,GWL_EXSTYLE)&WS_EX_TOPMOST)==WS_EX_TOPMOST;

#if !defined(WA2_EMBED)
    SetWindowPos(hwnd,tm?HWND_TOPMOST:HWND_NOTOPMOST,cfg_x,cfg_y,cfg_w,cfg_h,SWP_NOACTIVATE);
#else
    PostMessage(GetParent(hwnd),WM_SIZE,0,0);
#endif

		SetTransparency(hwnd,cfg_trans,cfg_trans_amount);

    SetTimer(hwnd,88,100,NULL);
  }
}

void Wnd_GoFullScreen(HWND hwnd)
{
  if (!DDraw_IsFullScreen())
  {

#if 1
#ifdef WA2_EMBED
    if (SendMessage(g_mod->hwndParent,WM_WA_IPC,0,IPC_IS_PLAYING_VIDEO)>1)
    {
      PostMessage(hwnd,WM_USER+1667,1,2);
      return;
    }
#endif
#endif

    extern int cfg_fs_use_overlay;
#ifdef WA2_EMBED
    RECT r;
    GetClientRect(hwnd,&r);
    last_windowed_w=r.right;
    last_windowed_h=r.bottom;
#endif

    if (!DDraw_IsMode(cfg_fs_w,cfg_fs_h,cfg_fs_bpp))
    {
      int DDraw_PickMode(int *w, int *h, int *bpp);
      if (!DDraw_PickMode(&cfg_fs_w,&cfg_fs_h,&cfg_fs_bpp))
        return;
    }

    {
#ifdef WA2_EMBED
      SendMessage(g_mod->hwndParent,WM_WA_IPC,1,IPC_SET_VIS_FS_FLAG);
#endif
      RECT tr;
      if (inWharf) 
      {
        need_redock=1;
        toggleWharfAmpDock(hwnd);
      }
	    SetTransparency(hwnd,0,0);
			if (cfg_cancelfs_on_deactivate) ShowCursor(FALSE);
      GetWindowRect(hwnd,&tr);
      if (cfg_cfgwnd_open) ShowWindow(g_hwndDlg,SW_HIDE);
			if (!cfg_fs_use_overlay) 
      {
#if defined(WA2_EMBED)
        SetWindowLong(hwnd,GWL_STYLE,WS_VISIBLE);
        SetParent(hwnd,NULL);
        HWND w = myWindowState.me;
        while (GetWindowLong(w, GWL_STYLE) & WS_CHILD) w = GetParent(w);
        ShowWindow(w,SW_HIDE);
#endif
        DDraw_SetFullScreen(1,cfg_fs_w,cfg_fs_h,cfg_fs_d&1,cfg_fs_bpp);
        RECT r;
        my_getViewport(&r,&tr);
        SetWindowPos(hwnd,HWND_TOPMOST,r.left,r.top,cfg_fs_w,cfg_fs_h,0);
        SetForegroundWindow(hwnd);
      }
			else 
      {
#if defined(WA2_EMBED)
        SetWindowLong(hwnd,GWL_STYLE,WS_VISIBLE);
        SetParent(hwnd,NULL);
        HWND w = myWindowState.me;
        while (GetWindowLong(w, GWL_STYLE) & WS_CHILD) w = GetParent(w);
        ShowWindow(w,SW_HIDE);
#endif
        DDraw_SetFullScreen(1,cfg_fs_w,cfg_fs_h,cfg_fs_d&1,0);
      }
		}
#if 0
    else 
    {
      if (!cfg_cfgwnd_open) 
      {
			  ShowWindow(g_hwndDlg,SW_SHOWNA);
        CfgWnd_RePopIfNeeded();
        cfg_cfgwnd_open=1;
			}
      SendMessage(g_hwndDlg,WM_COMMAND,IDM_FULLSCREEN,0);
    }
#endif
  }
}

int g_config_smp_mt=2,g_config_smp=0;
static char *INI_FILE;

static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

int cfg_fs_dblclk=1;

int Wnd_Init(struct winampVisModule *this_mod)
{
	WNDCLASS wc={0,};
	g_mod=this_mod;
	wc.style = CS_DBLCLKS|CS_VREDRAW|CS_HREDRAW;
	wc.lpfnWndProc = WndProc;
	wc.hInstance = this_mod->hDllInstance;
	wc.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
	wc.lpszClassName = "avswnd";
	wc.hCursor=LoadCursor(NULL,IDC_ARROW);

  hwnd_WinampParent=this_mod->hwndParent;


	if (!RegisterClass(&wc)) 
	{
//		MessageBox(this_mod->hwndParent,"Error registering window class","Error",MB_OK);
	//	return 1;
	}
	{
#ifndef REAPLAY_PLUGIN
    INI_FILE = (char*)SendMessage(this_mod->hwndParent,WM_WA_IPC,0,IPC_GETINIFILE);
#else
    extern const char *(*get_ini_file)();
    INI_FILE = (char *)get_ini_file();
#endif
#define AVS_SECTION "AVS"
#ifdef LASER
#undef AVS_SECTION
#define AVS_SECTION "AVS_L"
    extern int g_laser_nomessage,g_laser_zones;
    g_laser_nomessage=GetPrivateProfileInt(AVS_SECTION,"laser_nomessage",0,INI_FILE);
    g_laser_zones=GetPrivateProfileInt(AVS_SECTION,"laser_zones",1,INI_FILE);
#else
    g_config_smp=GetPrivateProfileInt(AVS_SECTION,"smp",0,INI_FILE);
    g_config_smp_mt=GetPrivateProfileInt(AVS_SECTION,"smp_mt",2,INI_FILE);
#endif
    need_redock=GetPrivateProfileInt(AVS_SECTION,"cfg_docked",0,INI_FILE);
		cfg_cfgwnd_x=GetPrivateProfileInt(AVS_SECTION,"cfg_cfgwnd_x",cfg_cfgwnd_x,INI_FILE);
		cfg_cfgwnd_y=GetPrivateProfileInt(AVS_SECTION,"cfg_cfgwnd_y",cfg_cfgwnd_y,INI_FILE);
		cfg_cfgwnd_open=GetPrivateProfileInt(AVS_SECTION,"cfg_cfgwnd_open",cfg_cfgwnd_open,INI_FILE);
		cfg_fs_w=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_w",cfg_fs_w,INI_FILE);
		cfg_fs_h=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_h",cfg_fs_h,INI_FILE);
		cfg_fs_bpp=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_bpp",cfg_fs_bpp,INI_FILE);
		cfg_fs_d=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_d",cfg_fs_d,INI_FILE);
    cfg_fs_fps=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_fps",6,INI_FILE);
    cfg_fs_rnd=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_rnd",cfg_fs_rnd,INI_FILE);
    cfg_fs_rnd_time=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_rnd_time",cfg_fs_rnd_time,INI_FILE);
    cfg_fs_dblclk=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_dblclk",cfg_fs_dblclk,INI_FILE);
    cfg_fs_flip=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_flip",cfg_fs_flip,INI_FILE);
    cfg_fs_height=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_height",cfg_fs_height,INI_FILE);
    cfg_fs_use_overlay=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_use_overlay",cfg_fs_use_overlay,INI_FILE);
    cfg_cancelfs_on_deactivate=GetPrivateProfileInt(AVS_SECTION,"cfg_fs_cancelondeactivate",cfg_cancelfs_on_deactivate,INI_FILE);
    cfg_speed=GetPrivateProfileInt(AVS_SECTION,"cfg_speed",cfg_speed,INI_FILE);
    cfg_trans=GetPrivateProfileInt(AVS_SECTION,"cfg_trans",cfg_trans,INI_FILE);
    cfg_dont_min_avs=GetPrivateProfileInt(AVS_SECTION,"cfg_dont_min_avs",cfg_dont_min_avs,INI_FILE);
    cfg_smartbeat=GetPrivateProfileInt(AVS_SECTION,"cfg_smartbeat",cfg_smartbeat,INI_FILE);
    cfg_smartbeatsticky=GetPrivateProfileInt(AVS_SECTION,"cfg_smartbeatsticky",cfg_smartbeatsticky,INI_FILE);
    cfg_smartbeatresetnewsong=GetPrivateProfileInt(AVS_SECTION,"cfg_smartbeatresetnewsong",cfg_smartbeatresetnewsong,INI_FILE);
    cfg_smartbeatonlysticky=GetPrivateProfileInt(AVS_SECTION,"cfg_smartbeatonlysticky",cfg_smartbeatonlysticky,INI_FILE);
    GetPrivateProfileString( AVS_SECTION,"config_pres_subdir","",config_pres_subdir,sizeof(config_pres_subdir),INI_FILE);
    GetPrivateProfileString( AVS_SECTION,"last_preset_name","",last_preset,sizeof(last_preset),INI_FILE);
    cfg_transitions=GetPrivateProfileInt(AVS_SECTION,"cfg_transitions_en",cfg_transitions,INI_FILE);
    cfg_transitions2=GetPrivateProfileInt(AVS_SECTION,"cfg_transitions_preinit",cfg_transitions2,INI_FILE);
    cfg_transitions_speed=GetPrivateProfileInt(AVS_SECTION,"cfg_transitions_speed",cfg_transitions_speed,INI_FILE);
    cfg_transition_mode=GetPrivateProfileInt(AVS_SECTION,"cfg_transitions_mode",cfg_transition_mode,INI_FILE);
    cfg_bkgnd_render=GetPrivateProfileInt(AVS_SECTION,"cfg_bkgnd_render",cfg_bkgnd_render,INI_FILE);
    cfg_bkgnd_render_color=GetPrivateProfileInt(AVS_SECTION,"cfg_bkgnd_render_color",cfg_bkgnd_render_color,INI_FILE);
    cfg_render_prio=GetPrivateProfileInt(AVS_SECTION,"cfg_render_prio",cfg_render_prio,INI_FILE);
    g_saved_preset_dirty=GetPrivateProfileInt(AVS_SECTION,"g_preset_dirty",C_UndoStack::isdirty(),INI_FILE);
    config_prompt_save_preset=GetPrivateProfileInt(AVS_SECTION,"cfg_prompt_save_preset",config_prompt_save_preset,INI_FILE);
    config_reuseonresize=GetPrivateProfileInt(AVS_SECTION,"cfg_reuseonresize",config_reuseonresize,INI_FILE);
    g_log_errors=GetPrivateProfileInt(AVS_SECTION,"cfg_log_errors",g_log_errors,INI_FILE);
    g_reset_vars_on_recompile=GetPrivateProfileInt(AVS_SECTION,"cfg_reset_vars",g_reset_vars_on_recompile,INI_FILE);
    g_config_seh=GetPrivateProfileInt(AVS_SECTION,"cfg_seh",g_config_seh,INI_FILE);

    
#ifdef WA2_EMBED
    memset(&myWindowState,0,sizeof(myWindowState));
    myWindowState.r.left=GetPrivateProfileInt(AVS_SECTION,"wx",32,INI_FILE);
    myWindowState.r.top=GetPrivateProfileInt(AVS_SECTION,"wy",32,INI_FILE);
    myWindowState.r.right = GetPrivateProfileInt(AVS_SECTION,"ww",320,INI_FILE)+myWindowState.r.left;
    myWindowState.r.bottom = GetPrivateProfileInt(AVS_SECTION,"wh",240,INI_FILE)+myWindowState.r.top;
#else
		cfg_x=GetPrivateProfileInt(AVS_SECTION,"cfg_x",cfg_x,INI_FILE);
		cfg_y=GetPrivateProfileInt(AVS_SECTION,"cfg_y",cfg_y,INI_FILE);
		cfg_w=GetPrivateProfileInt(AVS_SECTION,"cfg_w",cfg_w,INI_FILE);
		cfg_h=GetPrivateProfileInt(AVS_SECTION,"cfg_h",cfg_h,INI_FILE);
#endif

    int x;
    for (x = 0; x < 8; x ++)
    {
      char debugreg[32];
      wsprintf(debugreg,"debugreg_%d",x);
		  debug_reg[x]=GetPrivateProfileInt(AVS_SECTION,debugreg,x,INI_FILE);
    }

	}
#ifdef LASER
  cfg_transitions=0;
  cfg_transition_mode=0;
  cfg_transitions2=0;
#endif

	g_in_destroy=0;
#ifndef WA2_EMBED
  {
    RECT ir={cfg_x,cfg_y,cfg_w+cfg_x,cfg_y+cfg_h};
    RECT or;
    my_getViewport(&or,&ir);
    if (cfg_x < or.left) cfg_x=or.left;
    if (cfg_y < or.top) cfg_y=or.top;
    if (cfg_x > or.right-16) cfg_x=or.right-16;
    if (cfg_y > or.bottom-16) cfg_y=or.bottom-16;
    // determine bounding rectangle for window
  }
#endif
#ifndef WA2_EMBED
  int styles=WS_VISIBLE;
  HWND par = g_minimized?NULL:this_mod->hwndParent;
#else
  int styles=WS_CHILDWINDOW|WS_OVERLAPPED|WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
  HWND (*e)(embedWindowState *v) = NULL;
#ifndef REAPLAY_PLUGIN
  *(void**)&e = (void *)SendMessage(this_mod->hwndParent,WM_WA_IPC,(LPARAM)0,IPC_GET_EMBEDIF);
  HWND par=0;
  if (e) par=e(&myWindowState);
  if (par) SetWindowText(par,"AVS");
#else
  HWND par = this_mod->hwndParent;
#endif
  g_hWA2ParentWindow=par;
#endif

#ifndef WA2_EMBED

  CreateWindowEx(WS_EX_ACCEPTFILES,"avswnd","Winamp AVS Display",
		styles,cfg_x,cfg_y,cfg_w,cfg_h,par,NULL,
				this_mod->hDllInstance,0);
#else
	CreateWindowEx(WS_EX_ACCEPTFILES,"avswnd","avs",
	          	styles,0,0,100,100,par,NULL, this_mod->hDllInstance,0);
  SendMessage(this_mod->hwndParent, WM_WA_IPC, (int)g_hwnd, IPC_SETVISWND);
#endif
  if (!g_hwnd)
  {
		char title[32];
		MessageBox(this_mod->hwndParent,WASABI_API_LNGSTRING(IDS_ERROR_CREATING_WINDOW),
			   WASABI_API_LNGSTRING_BUF(IDS_AVS_ERROR,title,32),MB_OK);
		return 1;
  }
#ifndef REAPLAY_PLUGIN
#ifdef WA2_EMBED
  ShowWindow(g_hwnd,SW_SHOWNA);
  ShowWindow(par,SW_SHOWNA);
#endif
#endif
  SetTransparency(g_hwnd,cfg_trans,cfg_trans_amount);
  return 0;
}

static void WriteInt(char *name, int value)
{
  char str[128];
  wsprintf(str,"%d",value);
	WritePrivateProfileString(AVS_SECTION,name,str,INI_FILE);
}

void Wnd_Quit(void)	
{
  extern HWND g_hwndDlg;
  g_in_destroy=1;
#ifdef WA2_EMBED
  SendMessage(g_mod->hwndParent, WM_WA_IPC, 0, IPC_SETVISWND);
  if (myWindowState.me) 
  {
    SetForegroundWindow(g_mod->hwndParent);
    DestroyWindow(myWindowState.me);
  }
	else 
#endif
  if (g_hwnd && IsWindow(g_hwnd)) DestroyWindow(g_hwnd);
	g_hwnd=NULL;
	UnregisterClass("avswnd",g_mod->hDllInstance);
	{
#ifdef LASER
    extern int g_laser_zones,g_laser_nomessage;
    wsprintf(str,"%d",g_laser_zones);
		WriteInt("laser_zones",g_laser_zones);
		WriteInt("laser_nomessage",g_laser_nomessage);
#else
    WriteInt("smp",g_config_smp);
    WriteInt("smp_mt",g_config_smp_mt);
#endif
#ifdef WA2_EMBED
		WriteInt("wx",myWindowState.r.left);
    WriteInt("wy",myWindowState.r.top);
		WriteInt("ww",myWindowState.r.right-myWindowState.r.left);
		WriteInt("wh",myWindowState.r.bottom-myWindowState.r.top);
#else
		WriteInt("cfg_x",cfg_x);
		WriteInt("cfg_y",cfg_y);
		WriteInt("cfg_w",cfg_w);
		WriteInt("cfg_h",cfg_h);
#endif
		WritePrivateProfileString(AVS_SECTION,"config_pres_subdir",config_pres_subdir,INI_FILE);

		WriteInt("cfg_docked",inWharf?1:0);
		WriteInt("cfg_cfgwnd_open",cfg_cfgwnd_open);
		WriteInt("cfg_cfgwnd_x",cfg_cfgwnd_x);
		WriteInt("cfg_cfgwnd_y",cfg_cfgwnd_y);
		WriteInt("cfg_fs_w",cfg_fs_w);
		WriteInt("cfg_fs_h",cfg_fs_h);
		WriteInt("cfg_fs_d",cfg_fs_d);
		WriteInt("cfg_fs_bpp",cfg_fs_bpp);
		WriteInt("cfg_fs_fps",cfg_fs_fps);
		WriteInt("cfg_fs_rnd",cfg_fs_rnd);
		WriteInt("cfg_fs_rnd_time",cfg_fs_rnd_time);    
    WriteInt("cfg_fs_dblclk",cfg_fs_dblclk);
		WriteInt("cfg_fs_flip",cfg_fs_flip);
		WriteInt("cfg_fs_height",cfg_fs_height);
		WriteInt("cfg_fs_use_overlay",cfg_fs_use_overlay);
		WriteInt("cfg_fs_cancelondeactivate",cfg_cancelfs_on_deactivate);
		WriteInt("cfg_speed",cfg_speed);
		WriteInt("cfg_trans",cfg_trans);
		WriteInt("cfg_dont_min_avs",cfg_dont_min_avs);
		WriteInt("cfg_smartbeat",cfg_smartbeat);
		WriteInt("cfg_smartbeatsticky",cfg_smartbeatsticky);
		WriteInt("cfg_smartbeatresetnewsong",cfg_smartbeatresetnewsong);
		WriteInt("cfg_smartbeatonlysticky",cfg_smartbeatonlysticky);
		WriteInt("cfg_transitions_en",cfg_transitions);
		WriteInt("cfg_transitions_preinit",cfg_transitions2);
		WriteInt("cfg_transitions_speed",cfg_transitions_speed);
		WriteInt("cfg_transitions_mode",cfg_transition_mode);
		WriteInt("cfg_bkgnd_render",cfg_bkgnd_render);
		WriteInt("cfg_bkgnd_render_color",cfg_bkgnd_render_color);
		WriteInt("cfg_render_prio",cfg_render_prio);
    WriteInt("g_preset_dirty",C_UndoStack::isdirty());
    WriteInt("cfg_prompt_save_preset",config_prompt_save_preset);
		WritePrivateProfileString(AVS_SECTION,"last_preset_name",last_preset,INI_FILE);
    WriteInt("cfg_reuseonresize",config_reuseonresize);
    WriteInt("cfg_log_errors",g_log_errors);
    WriteInt("cfg_reset_vars",g_reset_vars_on_recompile);
    WriteInt("cfg_seh",g_config_seh);

    int x;
    for (x = 0; x < 8; x ++)
    {
      char debugreg[32];
      wsprintf(debugreg,"debugreg_%d",x);
      WriteInt(debugreg,debug_reg[x]);
    }
	}
}


void toggleWharfAmpDock(HWND hwnd)
{
  if (DDraw_IsFullScreen()) return;
  HWND Wharf=g_hwndDlg?GetDlgItem(g_hwndDlg,IDC_RRECT):NULL;
  if (!Wharf) return;

  if (!inWharf)
	{
	  RECT r,r2;

    // show IDC_RRECT, resize IDC_TREE1 down
    GetWindowRect(GetDlgItem(g_hwndDlg,IDC_RRECT),&r);
    GetWindowRect(GetDlgItem(g_hwndDlg,IDC_TREE1),&r2);
    SetWindowPos(GetDlgItem(g_hwndDlg,IDC_TREE1),NULL,0,0,r2.right-r2.left,r.top - 4 - r2.top,SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
    ShowWindow(GetDlgItem(g_hwndDlg,IDC_RRECT),SW_SHOWNA);

#ifdef WA2_EMBED
    GetClientRect(hwnd,&r);
    last_windowed_w=r.right;
    last_windowed_h=r.bottom;
#endif
    inWharf=1;
	  GetWindowRect(Wharf, &r);
    SetParent(hwnd, Wharf);
#ifndef WA2_EMBED
	  SetWindowLong(hwnd, GWL_STYLE, (GetWindowLong(hwnd,GWL_STYLE)&(~WS_POPUP))|WS_CHILD);
#else
    HWND w = g_hWA2ParentWindow;
    while (GetWindowLong(w, GWL_STYLE) & WS_CHILD) 
    {
      w = GetParent(w);
    }
    if (!SendMessage(g_mod->hwndParent, WM_WA_IPC, (int)w, IPC_FF_ISMAINWND)) ShowWindow(w,SW_HIDE);
    else ShowWindow(g_hWA2ParentWindow,SW_HIDE);
#endif
	  SetWindowPos(hwnd, NULL, 0, 0, r.right-r.left, r.bottom-r.top, SWP_NOZORDER|SWP_NOACTIVATE);
	  DDraw_Resize(r.right-r.left, r.bottom-r.top,cfg_fs_d&2);
	}
  else
	{

	  RECT r,r2;
    // hide IDC_RRECT, resize IDC_TREE1 up
    GetWindowRect(GetDlgItem(g_hwndDlg,IDC_RRECT),&r);
    GetWindowRect(GetDlgItem(g_hwndDlg,IDC_TREE1),&r2);
    ShowWindow(GetDlgItem(g_hwndDlg,IDC_RRECT),SW_HIDE);
    SetWindowPos(GetDlgItem(g_hwndDlg,IDC_TREE1),NULL,0,0,r2.right-r2.left,r.bottom - r2.top - 2,SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);

#ifndef WA2_EMBED
	  SetWindowLong(hwnd, GWL_STYLE, (GetWindowLong(hwnd,GWL_STYLE)&(~(WS_CHILD|WS_VISIBLE)))|WS_POPUP);
	  SetParent(hwnd, NULL);
	  SetWindowPos(hwnd, NULL, cfg_x, cfg_y, cfg_w,cfg_h, SWP_NOZORDER|SWP_NOACTIVATE);
    DDraw_Resize(cfg_w-7-6,cfg_h-15-5,cfg_fs_d&2);
    ShowWindow(hwnd,SW_SHOWNA);
#else
	  SetParent(hwnd, g_hWA2ParentWindow);
    DDraw_Resize(last_windowed_w,last_windowed_h,cfg_fs_d&2);

    HWND w = g_hWA2ParentWindow;
    while (GetWindowLong(w, GWL_STYLE) & WS_CHILD) 
    {
      w = GetParent(w);
    }
    if (SendMessage(g_mod->hwndParent, WM_WA_IPC, (int)w, IPC_FF_ISMAINWND)) 
      w=g_hWA2ParentWindow;

    PostMessage(GetParent(hwnd),WM_SIZE,0,0);

    ShowWindow(w,SW_SHOWNA);

    //SetWindowPos(hwnd,0,0,0,cfg_w,cfg_h,SWP_NOACTIVATE|SWP_NOZORDER);
    //SetTimer(hwnd,66,500,NULL);
#endif
    InvalidateRect(Wharf,NULL,TRUE);
	  inWharf=0;
	}	
}

int findInMenu(HMENU parent, HMENU sub, UINT id, char *buf, int buf_len)
{
  int x,l=GetMenuItemCount(parent);
  char *bufadd=buf+strlen(buf);
  bufadd[0]='\\';
  for (x = 0; x < l; x ++)
  {
    MENUITEMINFO mi={sizeof(mi),MIIM_SUBMENU|MIIM_TYPE|MIIM_ID,};
    mi.dwTypeData=bufadd+1;
    mi.cch=buf_len - (bufadd-buf+2);
    GetMenuItemInfo(parent,x,TRUE,&mi);
    if (mi.hSubMenu)
    {
      if (sub && mi.hSubMenu == sub)
        return 1;
      if (findInMenu(mi.hSubMenu,sub,id,buf,buf_len)) 
        return 1;
    }
    else
    {
      if (!sub && id && mi.wID == id)
        return 1;
    }
  }
  bufadd[0]=0;
  return 0;
}

static int find_preset(char *parent_path, int dir, char *lastpreset, char *newpreset, int *state)
{
	HANDLE h;
	WIN32_FIND_DATA d;
  char dirmask[4096];
  wsprintf(dirmask,"%s\\*.avs",parent_path);
	h = FindFirstFile(dirmask,&d);
	if (h != INVALID_HANDLE_VALUE)
	{
		do 
    {
      if (!(d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
      {
        wsprintf(dirmask,"%s\\%s",parent_path,d.cFileName);
        
        if (lastpreset)
        {
          if (*state)
          {
            strcpy(newpreset,dirmask);
            FindClose(h);
            return 1;
          }
          if (dir > 0)
          {
            if (!newpreset[0]) // save the first one we find, in case we fail (wrap)
              strcpy(newpreset,dirmask);

            if (!stricmp(dirmask,lastpreset)) *state=1;
          }
          if (dir < 0)
          {
            if (!stricmp(dirmask,lastpreset))
            {
              if (newpreset[0]) { // if we find it first, skip it so we can go to the end :)
                FindClose(h);
                return 1;
              }
            }
            strcpy(newpreset,dirmask);
          }
          
        }
        else
        {
          int cnt=++(*state);
          if (cnt < 1) cnt=1;
          int r=((rand()&1023)<<10)|(rand()&1023);
          if (r < (1024*1024)/cnt)
          {
            strcpy(newpreset,dirmask);
          }
        }
      }
		} while (FindNextFile(h,&d));
		FindClose(h);
	}
  wsprintf(dirmask,"%s\\*.*",parent_path);
	h = FindFirstFile(dirmask,&d);
	if (h != INVALID_HANDLE_VALUE)
	{
		do 
    {
      if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && d.cFileName[0] != '.')
      {
        wsprintf(dirmask,"%s\\%s",parent_path,d.cFileName);
        if (find_preset(dirmask,dir,lastpreset,newpreset,state)) {
          FindClose(h);
          return 1;
        }
      }
		} while (FindNextFile(h,&d));
		FindClose(h);
  }
  return 0;
}

void next_preset(HWND hwnd) {
  g_rnd_cnt=0;

  if (readyToLoadPreset(hwnd,0))
  {
    char dirmask[2048];
    char i_path[1024];
    if (config_pres_subdir[0]) wsprintf(i_path,"%s\\%s",g_path,config_pres_subdir);
    else strcpy(i_path,g_path);

    dirmask[0]=0;

    int state=0;
    find_preset(i_path,1,last_preset,dirmask,&state);

    if (dirmask[0] && stricmp(last_preset,dirmask))
    {
      if (g_render_transition->LoadPreset(dirmask,2) != 2)
  	    lstrcpyn(last_preset,dirmask,sizeof(last_preset));
    }
  }
}

void random_preset(HWND hwnd) {
  g_rnd_cnt=0;
  if (readyToLoadPreset(hwnd,0))
  {
    char dirmask[2048];
    char i_path[1024];
    if (config_pres_subdir[0]) wsprintf(i_path,"%s\\%s",g_path,config_pres_subdir);
    else strcpy(i_path,g_path);

    dirmask[0]=0;

    int state=0;
    find_preset(i_path,0,NULL,dirmask,&state);

    if (dirmask[0])
    {  			
      if (g_render_transition->LoadPreset(dirmask,4) != 2)
        lstrcpyn(last_preset,dirmask,sizeof(last_preset));
    }
  }
}

void previous_preset(HWND hwnd) {
  g_rnd_cnt=0;
  if (readyToLoadPreset(hwnd,0))
  {
    char dirmask[2048];
    char i_path[1024];
    if (config_pres_subdir[0]) wsprintf(i_path,"%s\\%s",g_path,config_pres_subdir);
    else strcpy(i_path,g_path);

    dirmask[0]=0;

    int state=0;
    find_preset(i_path,-1,last_preset,dirmask,&state);

    if (dirmask[0] && stricmp(last_preset,dirmask))
    {
      if (g_render_transition->LoadPreset(dirmask,2) != 2)
        lstrcpyn(last_preset,dirmask,sizeof(last_preset));
    }
  }
}

static HMENU presetTreeMenu;
static int presetTreeCount;

void DoPopupMenu() {
  // Winamp3 Bug#331: Don't let the popupmenu pop when in fullscreen.
  if (!DDraw_IsFullScreen())
  {
    void DDraw_NoUpdateScreen(int r);
		HANDLE h;
		WIN32_FIND_DATA d;
		char dirmask[1024];

    if (presetTreeMenu) DestroyMenu(presetTreeMenu);

    POINT p;
    int x;
    int insert_pos=0, directory_pos=0;
    presetTreeMenu=CreatePopupMenu();

    {
      MENUITEMINFO i={sizeof(i),};
      i.fMask=MIIM_TYPE|MIIM_DATA|MIIM_ID;
      i.fType=MFT_STRING;
      i.dwItemData=0;

		  i.wID = 1024;
		  i.dwTypeData=WASABI_API_LNGSTRING(IDS_FULLSCREEN);
		  i.cch=strlen(i.dwTypeData);
		  InsertMenuItem(presetTreeMenu,insert_pos++,TRUE,&i);

      if (!inWharf)
      {
		    i.wID = 256;
		    i.dwTypeData=WASABI_API_LNGSTRING(IDS_AVS_EDITOR);
		    i.cch=strlen(i.dwTypeData);
		    InsertMenuItem(presetTreeMenu,insert_pos++,TRUE,&i);
      }

  	  if (!DDraw_IsFullScreen())
		  {
		    i.wID = 512;
	  		i.dwTypeData=WASABI_API_LNGSTRING(IDS_DOCK_IN_AVS_EDITOR);
		  	i.cch=strlen(i.dwTypeData);
		    InsertMenuItem(presetTreeMenu,insert_pos++,TRUE,&i);
		  }

      i.wID=0;
      i.fType=MFT_SEPARATOR;
      InsertMenuItem(presetTreeMenu,insert_pos++,TRUE,&i);
    }

    GetCursorPos(&p);
    if (DDraw_IsFullScreen())
    {
      CheckMenuItem(presetTreeMenu,1024,MF_CHECKED);
    }
    if (IsWindowVisible(g_hwndDlg)) CheckMenuItem(presetTreeMenu,256,MF_CHECKED);
    if (inWharf) CheckMenuItem(presetTreeMenu,512,MF_CHECKED);
      
    wsprintf(dirmask,"%s\\*.*",g_path);

    directory_pos=insert_pos;

    presetTreeCount=1025;
		h = FindFirstFile(dirmask,&d);
		if (h != INVALID_HANDLE_VALUE)
		{
			do 
      {
        if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && d.cFileName[0] != '.')
        {
          MENUITEMINFO mi={sizeof(mi),MIIM_SUBMENU|MIIM_TYPE,MFT_STRING,MFS_DEFAULT
          };
          mi.hSubMenu=CreatePopupMenu();
          mi.dwTypeData=d.cFileName;
          mi.cch = strlen(d.cFileName);
          InsertMenuItem(presetTreeMenu,directory_pos++,TRUE,&mi);
          insert_pos++;
        }
        else if (!stricmp(extension(d.cFileName),"avs"))
        {
				  extension(d.cFileName)[-1]=0;
          MENUITEMINFO i={sizeof(i),MIIM_TYPE|MIIM_ID,MFT_STRING,MFS_DEFAULT };
				  i.dwTypeData = d.cFileName;
				  i.cch = strlen(d.cFileName);
				  i.wID=presetTreeCount++;
				  InsertMenuItem(presetTreeMenu,insert_pos++,TRUE,&i);
        }
			} while (FindNextFile(h,&d));
			FindClose(h);
		}

    x=TrackPopupMenu(presetTreeMenu,TPM_LEFTALIGN|TPM_TOPALIGN|TPM_RETURNCMD|TPM_RIGHTBUTTON|TPM_LEFTBUTTON,p.x,p.y,0,g_hwnd,NULL);
    if (x == 1024)
    {
      if (DDraw_IsFullScreen())
      {
        if (!cfg_fs_use_overlay) Wnd_GoWindowed(g_hwnd);
      }
  	  else
        Wnd_GoFullScreen(g_hwnd);
    }
    else if (x == 512)
	  {
      if (!inWharf && !cfg_cfgwnd_open)
      {
        cfg_cfgwnd_open=1;
			  ShowWindow(g_hwndDlg,SW_SHOWNA);
        CfgWnd_RePopIfNeeded();
      }
	    toggleWharfAmpDock(g_hwnd);
	  }
    else if (x == 256)
	  {
      SendMessage(g_hwnd,WM_USER+33,0,0);
	  }
    else if (x >= 1025)
    {
      char buf[2048];
      buf[0]=0;
      if (readyToLoadPreset(g_hwnd,0))
      {
        if (findInMenu(presetTreeMenu,0,x,buf,2048))
        {
          char temp[4096];
          wsprintf(temp,"%s%s.avs",g_path,buf);
          if (g_render_transition->LoadPreset(temp,1) != 2)
					  lstrcpyn(last_preset,temp,sizeof(last_preset));
        }
        else
        {
//            g_render_transition->LoadPreset
//          wsprintf(temp,"%s\\%s",g_path,curfilename);
        }
      }
    }

    DestroyMenu(presetTreeMenu);
    presetTreeMenu=0;

  }
}
 
static LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    if ( DDraw_IsFullScreen() &&
         !cfg_fs_use_overlay &&
         ( ( message == WM_KEYDOWN && wParam == VK_ESCAPE ) ||
           message == WM_LBUTTONUP ||
           ( message == WM_NCACTIVATE && !wParam ) ||
           message == WM_KILLFOCUS
           )
         )
    {
        Wnd_GoWindowed( hwnd );
        return 0;
    }
    else if ( message == WM_LBUTTONUP )
    {
        if ( !DDraw_IsFullScreen() )
        {
#ifndef WA2_EMBED
            int x = GET_X_LPARAM( lParam );
            int y = GET_Y_LPARAM( lParam );
            RECT r;
            GetClientRect( hwnd, &r );
            if ( x > r.right - 12 && x < r.right - 3 && y > r.top + 3 && y < r.top + 13 )
            {
                g_in_destroy = 1;
                DestroyWindow( hwnd );
            }
#endif
            /*
          else
          {
            static int lastdblclk;
            if (lastdblclk && GetTickCount()-lastdblclk > 1000 && !inWharf)
              DDraw_SetStatusText("double-click for configuration",600);
            lastdblclk=GetTickCount();
          }
          */
        }
    }
    if ( message == WM_LBUTTONDOWN )
    {
        SetFocus( g_hwnd );
        if ( inWharf ) SetFocus( hwnd );
        SetCapture( hwnd );
        return 0;
    }
    if ( message == WM_LBUTTONUP )
    {
        POINT p;
        RECT r;
        p.x = GET_X_LPARAM( lParam );
        p.y = GET_Y_LPARAM( lParam );
        ClientToScreen( hwnd, &p );
        if ( inWharf )
        {
            GetWindowRect( g_hwndDlg, &r );
            if ( !PtInRect( &r, p ) )
            {
                toggleWharfAmpDock( hwnd );
            }
        }
        else
        {
            RECT r2;
            GetWindowRect( GetDlgItem( g_hwndDlg, IDC_TREE1 ), &r );
            GetWindowRect( hwnd, &r2 );
            if ( PtInRect( &r, p ) && cfg_cfgwnd_open && !PtInRect( &r2, p ) )
            {
                toggleWharfAmpDock( hwnd );
            }
        }
        ReleaseCapture();
        return 0;
    }
    if ( message == WM_LBUTTONDBLCLK && !DDraw_IsFullScreen() )
    {
        if ( cfg_fs_dblclk )
        {
            if ( DDraw_IsFullScreen() )
            {
                if ( !cfg_fs_use_overlay ) Wnd_GoWindowed( hwnd );
            }
            else
                Wnd_GoFullScreen( hwnd );
        }
        else
        {
            if ( inWharf )
            {
                toggleWharfAmpDock( hwnd );
            }
            else if ( IsWindowVisible( g_hwndDlg ) )
            {
                cfg_cfgwnd_open = 0;
                ShowWindow( g_hwndDlg, SW_HIDE );
            }
            else
            {
                cfg_cfgwnd_open = 1;
                ShowWindow( g_hwndDlg, SW_SHOWNA );
                CfgWnd_RePopIfNeeded();
            }
        }
        return 0;
    }

    switch ( message )
    {
        case WM_USER + 1667:
            if ( wParam == 1 && lParam == 2 )
            {
                char title[ 32 ];
                MessageBox( hwnd, WASABI_API_LNGSTRING( IDS_CANNOT_GO_FULLSCREEN_WHEN_VIDEO_PLAYING ),
                            WASABI_API_LNGSTRING_BUF( IDS_AVS_FULLSCREEN, title, 32 ),
                            MB_OK | MB_ICONINFORMATION );
            }
            return 0;
        case WM_USER + 1666:
            if ( wParam == 1 && lParam == 15 )
            {
                if ( DDraw_IsFullScreen() )
                {
                    if ( cfg_fs_use_overlay ) SetFocus( hwnd ); // kill overlay window
                    else Wnd_GoWindowed( hwnd );
                }
            }
            return 0;
        case WM_INITMENUPOPUP:
            if ( HIWORD( lParam ) == 0 && presetTreeMenu && !GetMenuItemCount( (HMENU) wParam ) )
            {
                char buf[ 2048 ];
                buf[ 0 ] = 0;
                if ( findInMenu( presetTreeMenu, (HMENU) wParam, 0, buf, 2048 ) )
                {
                    HANDLE h;
                    WIN32_FIND_DATA d;
                    char dirmask[ 4096 ];
                    wsprintf( dirmask, "%s%s\\*.*", g_path, buf );
                    int directory_pos = 0, insert_pos = 0;
                    // build menu
                    h = FindFirstFile( dirmask, &d );
                    if ( h != INVALID_HANDLE_VALUE )
                    {
                        do
                        {
                            if ( d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && d.cFileName[ 0 ] != '.' )
                            {
                                MENUITEMINFO mi = { sizeof( mi ),MIIM_SUBMENU | MIIM_TYPE,MFT_STRING,MFS_DEFAULT };
                                mi.hSubMenu = CreatePopupMenu();
                                mi.dwTypeData = d.cFileName;
                                mi.cch = strlen( d.cFileName );
                                InsertMenuItem( (HMENU) wParam, directory_pos++, TRUE, &mi );
                                insert_pos++;
                            }
                            else if ( !stricmp( extension( d.cFileName ), "avs" ) )
                            {
                                extension( d.cFileName )[ -1 ] = 0;
                                MENUITEMINFO i = { sizeof( i ),MIIM_TYPE | MIIM_ID,MFT_STRING,MFS_DEFAULT };
                                i.dwTypeData = d.cFileName;
                                i.cch = strlen( d.cFileName );
                                i.wID = presetTreeCount++;
                                InsertMenuItem( (HMENU) wParam, insert_pos++, TRUE, &i );
                            }
                        } while ( FindNextFile( h, &d ) );
                        FindClose( h );
                    }
                }
            }
            return 0;
        case WM_RBUTTONUP:
            DoPopupMenu();
            return 0;
        case WM_USER + 33:
            DDraw_SetStatusText( "", 100 );
            if ( inWharf )
            {
                toggleWharfAmpDock( hwnd );
            }
            else if ( IsWindowVisible( g_hwndDlg ) )
            {
                cfg_cfgwnd_open = 0;
                ShowWindow( g_hwndDlg, SW_HIDE );
            }
            else
            {
                cfg_cfgwnd_open = 1;
                ShowWindow( g_hwndDlg, SW_SHOWNA );
                CfgWnd_RePopIfNeeded();
            }
            return 0;
        case WM_USER + 32:
            Wnd_GoFullScreen( hwnd );
            return 0;
        case WM_SYSKEYDOWN:
        case WM_KEYDOWN:
            if ( ( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) && wParam == VK_F4 )
            {
                SendMessage( hwnd, WM_CLOSE, 0, 0 );
                return 0;
            }
            if ( ( GetAsyncKeyState( VK_MENU ) & 0x8000 ) && wParam == VK_F4 )
            {
                PostMessage( hwnd_WinampParent, message, wParam, lParam );
                break;
            }

            if ( wParam == VK_SPACE )
            {
            do_random:
                random_preset( hwnd );
            }
            else if ( wParam == 0x55 )
            {
                next_preset( hwnd );
            }
            else if ( wParam == 0x59 )
            {
                previous_preset( hwnd );
            }
            else if ( wParam == VK_RETURN )
            {
                if ( GetAsyncKeyState( VK_MENU ) & 0x8000 )
                {
                    if ( DDraw_IsFullScreen() )
                    {
                        if ( !cfg_fs_use_overlay ) Wnd_GoWindowed( hwnd );
                    }
                    else
                        Wnd_GoFullScreen( hwnd );
                }
            }
            else if ( wParam == /* VK_T */ 0x54 )
            {
                extern int draw_title_p;
                draw_title_p = 2;
            }
            else if ( wParam == /* VK_F */ 0x52 + 'F' - 'R' )
            {
                cfg_fs_fps ^= 1;
                DDraw_SetStatusText( WASABI_API_LNGSTRING( cfg_fs_fps & 1 ? IDS_FULLSCREEN_FPS_ON : IDS_FULLSCREEN_FPS_OFF ) );
            }
            else if ( wParam == /* VK_R */ 0x52 )
            {
                cfg_fs_rnd = !cfg_fs_rnd;
                g_rnd_cnt = 0;
                DDraw_SetStatusText( WASABI_API_LNGSTRING( cfg_fs_rnd ? IDS_RANDOM_PRESETS_ON : IDS_RANDOM_PRESETS_OFF ) );
            }
            else if ( wParam >= VK_F1 && wParam <= VK_F12 )
            {
                char s[ 128 ], *st, stBuf[ 48 ];
                if ( GetAsyncKeyState( VK_CONTROL ) & ( 1 << 15 ) )
                {
                    st = WASABI_API_LNGSTRING_BUF( IDS_SAVED_TO, stBuf, 48 );
                    WritePreset( wParam - VK_F1 );
                }
                else
                {
                    if ( !readyToLoadPreset( hwnd, 0 ) ) return 0;

                    if ( LoadPreset( wParam - VK_F1 ) ) st = WASABI_API_LNGSTRING_BUF( IDS_LOADED_FROM, stBuf, 48 );
                    else st = WASABI_API_LNGSTRING_BUF( IDS_ERROR_LOADING_FROM, stBuf, 48 );
                }
                wsprintf( s, "%s F%d", st, wParam - VK_F1 + 1 );
                DDraw_SetStatusText( s );
            }
            else if ( wParam >= '0' && wParam <= '9' )
            {
                int n = 0;
                char s[ 128 ], *st, stBuf[ 48 ];
                if ( GetAsyncKeyState( VK_SHIFT ) & ( 1 << 15 ) )
                    n = 10;
                if ( GetAsyncKeyState( VK_CONTROL ) & ( 1 << 15 ) )
                {
                    st = WASABI_API_LNGSTRING_BUF( IDS_SAVED_TO, stBuf, 48 );
                    WritePreset( wParam - '0' + 12 + n );
                }
                else
                {
                    if ( !readyToLoadPreset( hwnd, 0 ) ) return 0;
                    if ( LoadPreset( wParam - '0' + 12 + n ) ) st = WASABI_API_LNGSTRING_BUF( IDS_LOADED_FROM, stBuf, 48 );
                    else st = WASABI_API_LNGSTRING_BUF( IDS_ERROR_LOADING_FROM, stBuf, 48 );
                }
                wsprintf( s, "%s %s%d", st, n ? WASABI_API_LNGSTRING( IDS_SHIFT_ ) : "", wParam - '0' );
                DDraw_SetStatusText( s );
            }
            else
            {
                if ( wParam == 0x4B && DDraw_IsFullScreen() )
                {
                    if ( !cfg_fs_use_overlay ) Wnd_GoWindowed( hwnd );
                }
                else PostMessage( hwnd_WinampParent, message, wParam, lParam );
            }
            return 0;
        case WM_TIMER:
#ifndef WA2_EMBED
            if ( wParam == 66 )
            {
                KillTimer( hwnd, 66 );
                SetWindowPos( hwnd, 0, 0, 0, cfg_w, cfg_h, SWP_NOACTIVATE | SWP_NOZORDER );
            }
#endif
            if ( wParam == 88 )
            {
                KillTimer( hwnd, 88 );
                if ( cfg_cfgwnd_open )
                {
                    ShowWindow( g_hwndDlg, SW_SHOWNA );
                    UpdateWindow( g_hwndDlg );
                    CfgWnd_RePopIfNeeded();
                }

                if ( need_redock && g_hwndDlg )
                {
                    need_redock = 0;
                    toggleWharfAmpDock( hwnd );
                }
            }
            if ( wParam == 32 )
            {
                DWORD a;

#ifndef REAPLAY_PLUGIN
                if ( SendMessageTimeout( hwnd_WinampParent, WM_USER, (WPARAM) 0, 201, SMTO_BLOCK, 1000, &a ) && a )
                {
                    if ( strcmp( g_skin_name, (char *) a ) )
                    {
                        lstrcpyn( g_skin_name, (char *) a, sizeof( g_skin_name ) );
                        PostMessage( hwnd, WM_DISPLAYCHANGE, 0, 0 );
                    }
                }
#endif

                if ( g_rnd_cnt >= 0 && g_rnd_cnt++ >= max( cfg_fs_rnd_time, 1 ) )
                {
                    g_rnd_cnt = 0;
                    if ( ( !IsWindowVisible( g_hwndDlg ) || DDraw_IsFullScreen() ) && cfg_fs_rnd )
                        goto do_random;
                }
            }
            if ( wParam == 30 )
            {
                KillTimer( hwnd, 30 );
                if ( !DDraw_IsFullScreen() && !inWharf )
                {
                    InvalidateRect( hwnd, NULL, FALSE );
                    int tm = ( GetWindowLong( g_mod->hwndParent, GWL_EXSTYLE ) & WS_EX_TOPMOST ) == WS_EX_TOPMOST;
                    SetWindowPos( hwnd, tm ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
                    RECT r;
                    GetClientRect_adj( hwnd, &r );
                    DDraw_Resize( r.right - r.left, r.bottom - r.top, cfg_fs_d & 2 );
                }
            }
#ifndef WA2_EMBED
            if ( wParam == 29 )
            {
                if ( !IsIconic( hwnd_WinampParent ) )
                {
                    KillTimer( hwnd, 29 );
                    g_mod->Quit( g_mod );
                    g_minimized = 0;
                    g_fakeinit = 1;
                    g_mod->Init( g_mod );
                    g_fakeinit = 0;
                    SetActiveWindow( g_mod->hwndParent );
                }
            }
#endif
            return 0;
        case WM_DROPFILES:
        {
            char temp[ MAX_PATH ];
            HDROP hdrop = (HDROP) wParam;
            DragQueryFile( hdrop, 0, temp, sizeof( temp ) );
            if ( readyToLoadPreset( hwnd, 0 ) )
            {
                if ( !stricmp( extension( temp ), "avs" ) )
                {
                    if ( g_render_transition->LoadPreset( temp, 1 ) != 2 )
                        lstrcpyn( last_preset, temp, sizeof( last_preset ) );
                }
            }
            DragFinish( hdrop );
        }
        return 0;
        case WM_DISPLAYCHANGE:
#ifndef WA2_EMBED
            SelectObject( hFrameDC, hFrameBitmap_old );
            DeleteObject( hFrameBitmap );
            hFrameBitmap = NULL;
            {
                char buf[ MAX_PATH ];
                if ( SendMessage( hwnd_WinampParent, WM_USER, (WPARAM) buf, 201 ) )
                {
                    strcat( buf, "\\avs.bmp" );
                    hFrameBitmap = (HBITMAP) LoadImage( g_hInstance, buf, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE );
                }
                if ( !hFrameBitmap )
                    hFrameBitmap = (HBITMAP) LoadImage( g_hInstance, MAKEINTRESOURCE( IDB_BITMAP1 ), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
            }
            hFrameBitmap_old = (HBITMAP) SelectObject( hFrameDC, hFrameBitmap );
#endif
            InvalidateRect( hwnd, NULL, FALSE );
            return 0;
        case WM_CREATE:
            g_hwnd = hwnd;

            if ( DDraw_Init() )
            {
                return 1;
            }

#ifndef WA2_EMBED

            {
                char buf[ MAX_PATH ];
                int a;
                if ( ( a = SendMessage( hwnd_WinampParent, WM_USER, (WPARAM) buf, 201 ) ) )
                {
                    lstrcpyn( g_skin_name, (char *) a, sizeof( g_skin_name ) );
                    strcat( buf, "\\avs.bmp" );
                    hFrameBitmap = (HBITMAP) LoadImage( g_hInstance, buf, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE );
                }
                if ( !hFrameBitmap )
                    hFrameBitmap = (HBITMAP) LoadImage( g_hInstance, MAKEINTRESOURCE( IDB_BITMAP1 ), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
            }
            hFrameDC = (HDC) CreateCompatibleDC( NULL );
            hFrameBitmap_old = (HBITMAP) SelectObject( hFrameDC, hFrameBitmap );
#endif
            //FG> This totally fucks up a child layered window painting in wa3, i'm not even sure that's a good thing for wa2... basically the child window gets excluded from the layered update and ends up updating behind the layer, on top of the desktop
#ifndef WA2_EMBED
            SetWindowLong( hwnd, GWL_STYLE, 0 );
            SetWindowPos( hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_DRAWFRAME | SWP_NOACTIVATE );
#endif
            SetTimer( hwnd, 32, 1000, NULL );
            return 0;
#ifndef WA2_EMBED
        case WM_NCHITTEST:
        {
            int x = GET_X_LPARAM( lParam );
            int y = GET_Y_LPARAM( lParam );
            RECT r;
            GetWindowRect( hwnd, &r );
            if ( inWharf )
                return HTCLIENT;
            if ( DDraw_IsFullScreen() || ( x > r.right - 12 && x < r.right - 3 && y > r.top + 3 && y < r.top + 13 ) )
                return HTCLIENT;
            if ( x < r.left + 6 && y > r.bottom - 6 ) return HTBOTTOMLEFT;
            if ( x > r.right - 6 && y > r.bottom - 6 ) return HTBOTTOMRIGHT;
            if ( x < r.left + 6 && y < r.top + 6 ) return HTTOPLEFT;
            if ( x > r.right - 6 && y < r.top + 6 ) return HTTOPRIGHT;
            if ( y < r.top + 6 ) return HTTOP;
            if ( y > r.bottom - 6 ) return HTBOTTOM;
            if ( x < r.left + 6 ) return HTLEFT;
            if ( x > r.right - 6 ) return HTRIGHT;
            if ( y < r.top + 15 ) return HTCAPTION;
        }
        return HTCLIENT;
#endif
        case WM_CLOSE:
#ifndef WA2_EMBED
            g_in_destroy = 1;
            DestroyWindow( hwnd );
#else
            g_in_destroy = 1;
            SetForegroundWindow( g_mod->hwndParent );
            DestroyWindow( myWindowState.me );
#endif
            return 0;
        case WM_DESTROY:
#ifndef WA2_EMBED
            SelectObject( hFrameDC, hFrameBitmap_old );
            DeleteObject( hFrameDC );
            DeleteObject( hFrameBitmap );
#endif
            g_ThreadQuit = 1;
            if ( !g_minimized )
            {
                PostQuitMessage( 0 );
            }
            return 0;
        case WM_MOVE:
            if ( !DDraw_IsFullScreen() && !inWharf )
            {
#ifndef WA2_EMBED
                int w;
                RECT r;
                RECT r2;
                int xPos, yPos, f = 0;
                xPos = (int) (short) LOWORD( lParam );    // horizontal position 
                yPos = (int) (short) HIWORD( lParam );    // vertical position 
                GetClientRect( hwnd, &r2 );

                for ( w = 0; w < 5; w++ )
                {
                    HWND hw;
                    if ( w == 0 )
                    {
                        RECT r2;
                        GetWindowRect( hwnd, &r2 );
                        my_getViewport( &r, &r2 );
                    }
                    else if ( w == 1 && IsWindowVisible( hwnd_WinampParent ) )
                        GetWindowRect( hwnd_WinampParent, &r );
                    else if ( w == 2 && ( hw = FindWindowEx( NULL, NULL, "Winamp EQ", NULL ) )
                              && IsWindowVisible( hw ) )
                        GetWindowRect( hw, &r );
                    else if ( w == 3 && ( hw = FindWindowEx( NULL, NULL, "Winamp PE", NULL ) )
                              && IsWindowVisible( hw ) )
                        GetWindowRect( hw, &r );
                    else if ( w == 4 && ( hw = FindWindowEx( NULL, NULL, "Winamp MB", NULL ) )
                              && IsWindowVisible( hw ) )
                        GetWindowRect( hw, &r );
                    else continue;

#define intersect(x1,x2,y1,y2)  \
					(((x1)>(y1)&&(x1)<(y2))||((x2)>(y1)&&(x2)<(y2))||((y1)>(x1)&&(y1)<(x2))||((y2)>(x1)&&(y2)<(x2)))

                    if ( xPos > r.left - 10 && xPos < r.left + 10 && intersect( yPos, yPos + r2.bottom, r.top, r.bottom ) )
                    {
                        xPos = r.left;
                        f++;
                    }
                    if ( yPos > r.top - 10 && yPos < r.top + 10 && intersect( xPos, xPos + r2.right, r.left, r.right ) )
                    {
                        yPos = r.top;
                        f++;
                    }
                    if ( xPos + r2.right > r.right - 10 && xPos + r2.right < r.right + 10 && intersect( yPos, yPos + r2.bottom, r.top, r.bottom ) )
                    {
                        xPos = r.right - r2.right;
                        f++;
                    }
                    if ( yPos + r2.bottom > r.bottom - 10 && yPos + r2.bottom < r.bottom + 10 && intersect( xPos, xPos + r2.right, r.left, r.right ) )
                    {
                        yPos = r.bottom - r2.bottom;
                        f++;
                    }



                    if ( xPos + r2.right > r.left - 10 && xPos + r2.right < r.left + 10 && intersect( yPos, yPos + r2.bottom, r.top, r.bottom ) )
                    {
                        xPos = r.left - r2.right;
                        f++;
                    }
                    if ( yPos + r2.bottom > r.top - 10 && yPos + r2.bottom < r.top + 10 && intersect( xPos, xPos + r2.right, r.left, r.right ) )
                    {
                        yPos = r.top - r2.bottom;
                        f++;
                    }
                    if ( xPos > r.right - 10 && xPos < r.right + 10 && intersect( yPos, yPos + r2.bottom, r.top, r.bottom ) )
                    {
                        xPos = r.right;
                        f++;
                    }
                    if ( yPos > r.bottom - 10 && yPos < r.bottom + 10 && intersect( xPos, xPos + r2.right, r.left, r.right ) )
                    {
                        yPos = r.bottom;
                        f++;
                    }
                }

                if ( f )
                {
                    SetWindowPos( hwnd, NULL, xPos, yPos, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
                }
                {
                    RECT r;
                    GetWindowRect( hwnd, &r );
                    cfg_x = r.left;
                    cfg_y = r.top;
                    cfg_w = r.right - r.left;
                    cfg_h = r.bottom - r.top;
                }
#endif
            }
            return 0;
        case WM_GETMINMAXINFO:
        {
            LPMINMAXINFO mmi = (LPMINMAXINFO) lParam;
            mmi->ptMinTrackSize.x = 80;
            mmi->ptMinTrackSize.y = 40;
        }
        return 0;
        case WM_SETCURSOR:
            if ( DDraw_IsFullScreen() )
            {
                SetCursor( NULL );
                return TRUE;
            }
            break;
        case WM_SIZE:
            if ( wParam != SIZE_MINIMIZED )
            {
                if ( !DDraw_IsFullScreen() )
                {
                    if ( !inWharf )
                    {
#ifndef WA2_EMBED
                        RECT r;
                        GetWindowRect( hwnd, &r );
                        cfg_x = r.left;
                        cfg_y = r.top;
                        cfg_w = r.right - r.left;
                        cfg_h = r.bottom - r.top;
#endif
                        DDraw_BeginResize();
                        KillTimer( hwnd, 30 );
                        SetTimer( hwnd, 30, 33, NULL );
                    }
                }
            }
            break;
        case WM_WINDOWPOSCHANGING:
        {
            LPWINDOWPOS lpwp = (LPWINDOWPOS) lParam;
            if ( cfg_dont_min_avs && !g_in_destroy && lpwp->flags & SWP_HIDEWINDOW && !g_minimized && !inWharf )
            {
#ifndef WA2_EMBED
                g_minimized = 1;
                g_mod->Quit( g_mod );
                g_fakeinit = 1;
                g_mod->Init( g_mod );
                g_fakeinit = 0;
                if ( ( GetWindowLong( g_mod->hwndParent, GWL_EXSTYLE ) & WS_EX_TOPMOST ) == WS_EX_TOPMOST )
                    SetWindowPos( g_hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
                SetTimer( g_hwnd, 29, 500, NULL );
#endif
            }
        }
        return 0;
        case WM_PAINT:
            if ( !DDraw_IsFullScreen() )
            {
                PAINTSTRUCT ps;
                HDC hdc = BeginPaint( hwnd, &ps );
#ifndef WA2_EMBED
                RECT r;
                HDC tempdc = CreateCompatibleDC( hdc );
                GetClientRect( hwnd, &r );
                HBITMAP oldbm, tempbm = CreateCompatibleBitmap( hdc, 7, r.bottom - 20 );
                oldbm = (HBITMAP) SelectObject( tempdc, tempbm );
                if ( !inWharf )
                { // draw window frame 
                    SetStretchBltMode( hdc, COLORONCOLOR );
                    SetStretchBltMode( tempdc, COLORONCOLOR );
                    BitBlt( hdc, 0, 0, 50, 15, hFrameDC, 15, 0, SRCCOPY ); // top left
                    StretchBlt( hdc, 50, 0, r.right - 50 - 16, 15, hFrameDC, 66, 0, 14, 15, SRCCOPY ); // top middle
                    BitBlt( hdc, r.right - 16, 0, 16, 15, hFrameDC, 81, 0, SRCCOPY ); // top right

                    StretchBlt( tempdc, 0, 0, 7, r.bottom - 15 - 5, hFrameDC, 0, 16, 7, 172, SRCCOPY ); // left middle
                    BitBlt( hdc, 0, 15, 7, r.bottom - 15 - 5, tempdc, 0, 0, SRCCOPY );
                    StretchBlt( tempdc, 0, 0, 6, r.bottom - 15 - 5, hFrameDC, 8, 16, 6, 172, SRCCOPY ); // right middle
                    BitBlt( hdc, r.right - 6, 15, 6, r.bottom - 15 - 5, tempdc, 0, 0, SRCCOPY );

                    BitBlt( hdc, 0, r.bottom - 5, 50, 15, hFrameDC, 15, 16, SRCCOPY ); // bottom left
                    StretchBlt( hdc, 50, r.bottom - 5, r.right - 50 - 16, 5, hFrameDC, 66, 16, 14, 5, SRCCOPY ); // bottom middle
                    BitBlt( hdc, r.right - 16, r.bottom - 5, 16, 5, hFrameDC, 81, 16, SRCCOPY ); // bottom right
                }
                SelectObject( tempdc, oldbm );
                DeleteObject( tempbm );
                DeleteObject( tempdc );
#endif
                EndPaint( hwnd, &ps );
                return 0;
            }
            break;
#ifdef WA2_EMBED
        case WM_COMMAND:
        {
            int id = LOWORD( wParam );
            switch ( id )
            {
                case ID_VIS_NEXT: next_preset( hwnd ); break;
                case ID_VIS_PREV: previous_preset( hwnd ); break;
                case ID_VIS_RANDOM:
                {
                    int v = HIWORD( wParam ) ? 1 : 0;
                    if ( wParam >> 16 == 0xFFFF )
                    {
                        SendMessage( g_mod->hwndParent, WM_WA_IPC, cfg_fs_rnd, IPC_CB_VISRANDOM );
                        break;
                    }
                    cfg_fs_rnd = v;
                    if ( cfg_fs_rnd ) random_preset( hwnd );
                    DDraw_SetStatusText( WASABI_API_LNGSTRING( cfg_fs_rnd ? IDS_RANDOM_PRESETS_ON : IDS_RANDOM_PRESETS_OFF ) );
                    break;
                }
                case ID_VIS_FS: Wnd_GoFullScreen( hwnd ); break;
                case ID_VIS_CFG: SendMessage( hwnd, WM_USER + 33, 0, 0 ); break;
                case ID_VIS_MENU: DoPopupMenu(); break;
            }
            break;
        }
#endif
    }
    return DefWindowProc( hwnd, message, wParam, lParam );
}