Will this Work?

#pragma once
#define MC_ITEMY(index)  (Y+(index*I_SPC)+T_SPC+5)
#define MC_ITEMY1(index) (Y+(index*I_SPC)+T_SPC+(FS_SPC*1)+10)
#define MC_ITEMY2(index) (Y+(index*I_SPC)+T_SPC+(FS_SPC*2)+15)
#define MC_ITEMY3(index) (Y+(index*I_SPC)+T_SPC+(FS_SPC*3)+20)
//____________________Mousefix prevents bugs____________________________\\
#define mousefix_L  if(GetAsyncKeyState(VK_LBUTTON)){GetAsyncKeyState(VK_RBUTTON);}
#define mousefix_R  if(GetAsyncKeyState(VK_RBUTTON)){GetAsyncKeyState(VK_LBUTTON);}
//____________________Define Colors here____________________________\\
#define C_OFF  D3DCOLOR_ARGB( 255, 200, 200, 200 )
#define C_OFF2  D3DCOLOR_ARGB( 255, 255,   0,   0 )
#define C_ON  D3DCOLOR_ARGB( 255, 255, 255, 255 )
#define C_ON2  D3DCOLOR_ARGB( 255,   0, 255,   0 )
#define C_CAT  D3DCOLOR_ARGB( 250, 255,   0,  40 )
#define C_CURBOX D3DCOLOR_ARGB( 140, 120,  60,  55 )
#define C_TITLE  D3DCOLOR_ARGB( 250, 255,   0,  40 )
#define C_Menu  D3DCOLOR_ARGB(  90,   0,   0,   0 )
#define C_Border D3DCOLOR_ARGB( 190,  60,   0,   0 )
//____________________Menu Class____________________________\\
class cMenu{
public:
 D3DCOLOR Pixelscan;
 POINT mpos;
 CD3DFont *cFont;
 char dllpath[255];
 bool
  FontCreated,
  firstInit
 ;
 void  InitalizeFont(LPDIRECT3DDEVICE9 pDevice);
 void  PostReset(LPDIRECT3DDEVICE9 pDevice);
 void  PreReset(void);
 char* GetFile(char *file);
 bool  MouseIsOver(int x, int y, int w, int h);
 void  GetCurrentPixelColor(LPDIRECT3DDEVICE9 pDevice, int x, int y);
 void  DrawBox(LPDIRECT3DDEVICE9 pDevice, int x, int y, int w, int h, D3DCOLOR Color);
 void  DrawBorder(LPDIRECT3DDEVICE9 device, int x, int y, int w, int h, int s, DWORD Color);
 void  Mouse(int x, int y, LPDIRECT3DDEVICE9 pDevice );
 void  CreateGUI(LPDIRECT3DDEVICE9 pDevice);
private:
 //Privat Members
  int
  NO,
  X,Y,
  Current,
  Width,
  I_OFS,S_OFS,G_OFS,
  I_SPC,T_SPC,FS_SPC,FB_SPC
 ;
 bool
  Show,
  Init
 ;
 struct sitem
 {
  char title[50];
  char state[50];
  int  type;
  int  max;
  int  no;
  int  *val;
 }
 items[50];
 enum I_TYPES
 {
  T_TEXT = 0,
  T_ITEM = 1,
  T_CAT  = 2
 };
 void  InitializeMenu();
 void  Header(LPDIRECT3DDEVICE9 pDevice);
 void  MenuBG(LPDIRECT3DDEVICE9 pDevice);
 void  SL(LPDIRECT3DDEVICE9 pDevice);
 void  Date_Time(LPDIRECT3DDEVICE9 pDevice);
 void  Winamp_Remote(LPDIRECT3DDEVICE9 pDevice);
 void  Winamp_StatusBar(LPDIRECT3DDEVICE9 pDevice);
 void  Side_Boxes(LPDIRECT3DDEVICE9 pDevice);
 void  TrackIndex(LPDIRECT3DDEVICE9 pDevice);
 void  InitializeGUI(LPDIRECT3DDEVICE9 pDevice);
 void  Save(char* szSection, char* szKey, int iValue,LPCSTR file);
 int   Load(char* szSection, char* szKey, int iDefaultValue,LPCSTR file);
 void  additem(char *title, char *states,int type, int *var, int show, int when);
 void  Group(char *title, char *states,int *var);
 void  Item(char *title, char *states,int *var,int show,int when);
 void  Text(char *title, char *states);
 int   nofields(char *str);
 void  getfield(char *str,char *dst,int no);
};
extern cMenu Menu;
//____________________Item struct____________________________\\
struct Items
{
 int
  stamina,
  chams,
  text,
  save,
  load
  ;
};
extern Items item;
//____________________Group struct____________________________\\
struct Groups
{
 int 
  Player,
  D3D,
  Menu
 ;
};

#include "D3D Base.h"
#include "cMenu.h"
#include "cWinamp.h"
#include <windows.h>
#include <time.h>
#include <iostream>
#include "stdio.h"
#pragma warning(disable: 4101 4244 4996 4018)

Items item;
Groups group;
cWinamp Winamp;
void cMenu::InitalizeFont(LPDIRECT3DDEVICE9 pDevice)
{
    Menu.cFont = new CD3DFont("Tahoma", 7, D3DFONT_BOLD);
    Menu.cFont->InitDeviceObjects(pDevice);
    Menu.cFont->RestoreDeviceObjects();
    FontCreated = true;
    firstInit = true;
} 
void cMenu::PostReset(LPDIRECT3DDEVICE9 pDevice)
{
    if(Menu.cFont == NULL)
    {
        Menu.cFont = new CD3DFont("Tahoma", 7, D3DFONT_BOLD);
        Menu.cFont->InitDeviceObjects(pDevice);
        Menu.cFont->RestoreDeviceObjects();
        FontCreated = true;
    }
}
void cMenu::PreReset( void )
{
    if(Menu.cFont)
    {
        Menu.cFont->InvalidateDeviceObjects();
        Menu.cFont->DeleteDeviceObjects();
        Menu.cFont = NULL;
        FontCreated = false;
    }
}
char* cMenu::GetFile(char *file)
{
 static char path[320];
 for(int i= 0;i<strlen(path);i++)
  path[i]=0;
 strcpy(path, Menu.dllpath);
 strcat(path, file);
 return path;
}
bool cMenu::MouseIsOver(int x, int y, int w, int h)
{ 
    bool bover; 
    if(Menu.mpos.x >= x && Menu.mpos.x <= x + w && Menu.mpos.y >= y && Menu.mpos.y <= y + h)
 { 
  bover = true; 
 }else{ 
  bover = false; 
 } 
    return bover;
}
void cMenu::InitializeMenu()
{
 if(!Init){
  X=15;//X Start of the Menu
  Y=40;//Y Start of the Menu
  Width=180;//Dont change this
  I_OFS=15;//Item space from X
  G_OFS=5;//Group space from X
  S_OFS=(Width/2)+40;//State space from X
  T_SPC=15;//Titel Box
  FS_SPC=15;//Small Footer
  FB_SPC=30;//Big Footer
  I_SPC=15;//Size of each Menuitem
  Show=false;
  Init=true;
 }
}
void cMenu::GetCurrentPixelColor(LPDIRECT3DDEVICE9 pDevice, int x, int y)
{
 //Try yourself ;)
}
//Box with Primitives
void cMenu::DrawBox(LPDIRECT3DDEVICE9 pDevice, int x, int y, int w, int h, D3DCOLOR Color)
{
 struct Vertex 
 {
  float x,y,z,ht;
  DWORD Color;
 }
 
 V[4] = 
 {
  {(float)x,(float)(y+h), 0.0f, 0.0f, Color},
  {(float)x,(float)y, 0.0f, 0.0f, Color},
  {(float)(x+w),(float)(y+h), 0.0f, 0.0f, Color},
  {(float)(x+w),(float)y, 0.0f, 0.0f, Color}
 };
 pDevice->SetTexture(0, NULL);
 pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
 pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
 pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,V,sizeof(Vertex));
}
void cMenu::DrawBorder(LPDIRECT3DDEVICE9 device, int x, int y, int w, int h, int s, DWORD Color)
{
    DrawBox(device, x, y-1, w, s, Color );
    DrawBox(device, x-1, y, s, h, Color );
    DrawBox(device, (x+w), y, s, h, Color );
    DrawBox(device, x, (y+h), w, s, Color );
}
//Credzis
void cMenu::Mouse(int x, int y, LPDIRECT3DDEVICE9 pDevice)
{
    #ifndef OUTLINE
    #define OUTLINE D3DCOLOR_RGBA(3, 6, 26, 215)
    #endif
    DrawBox(pDevice, x + 1,  y, 1, 17, OUTLINE);
    for(int i = 0; i < 11; i++)
    DrawBox(pDevice, x + 2 + i, y + 1 + i, 1, 1, OUTLINE);
    DrawBox(pDevice, x + 8,  y + 12, 5, 1, OUTLINE);
    DrawBox(pDevice, x + 8,  y + 13, 1, 1, OUTLINE);
    DrawBox(pDevice, x + 9,  y + 14, 1, 2, OUTLINE);
 DrawBox(pDevice, x + 10,  y + 16, 1, 2, OUTLINE);
    DrawBox(pDevice, x + 8,  y + 18, 2, 1, OUTLINE);
    DrawBox(pDevice, x + 7,  y + 16, 1, 2, OUTLINE);
    DrawBox(pDevice, x + 6,  y + 14, 1, 2, OUTLINE);
    DrawBox(pDevice, x + 5,  y + 13, 1, 1, OUTLINE);
    DrawBox(pDevice, x + 4,  y + 14, 1, 1, OUTLINE);
    DrawBox(pDevice, x + 3,  y + 15, 1, 1, OUTLINE);
    DrawBox(pDevice, x + 2,  y + 16, 1, 1, OUTLINE);
    for(int i = 0; i < 4; i++)
    DrawBox(pDevice, x + 2 + i, y + 2 + i, 1, 14 - (i * 2), D3DCOLOR_RGBA(255 - (i * 4), 255 - (i * 4), 255 - (i * 4), 255));
    DrawBox(pDevice, x + 6,    y + 6, 1, 8,  D3DCOLOR_RGBA(235, 235, 235, 255));
    DrawBox(pDevice, x + 7,    y + 7, 1, 9,  D3DCOLOR_RGBA(231, 231, 231, 255));
    for(int i = 0; i < 4; i++)
    DrawBox(pDevice, x + 8 + i, y + 8 + i, 1, 4 - i,  D3DCOLOR_RGBA(227 - (i * 4), 227 - (i * 4), 227 - (i * 4), 255));
    DrawBox(pDevice, x + 8,    y + 14, 1, 4,  D3DCOLOR_RGBA(207, 207, 207, 255));
    DrawBox(pDevice, x + 9,    y + 16, 1, 2,  D3DCOLOR_RGBA(203, 203, 203, 255));
}
//Header of the Menu
void cMenu::Header(LPDIRECT3DDEVICE9 pDevice)
{
 DrawBox(pDevice,X,Y,Width,T_SPC,C_Menu);
 DrawBorder(pDevice,X,Y,Width,T_SPC,1,C_Border);
 cFont->DrawText((X+(X+Width)/2),Y+2,C_TITLE,"Hybrid GUI",D3DFONT_CENTER|D3DFONT_SHADOW);
}
//The Background of the Menu; Main Box
void cMenu::MenuBG(LPDIRECT3DDEVICE9 pDevice)
{
 DrawBox(pDevice,X,(Y+T_SPC+5),Width,(NO*I_SPC),C_Menu);
 DrawBorder(pDevice,X,(Y+T_SPC+5),Width,(NO*I_SPC),1,C_Border);
}
//Save and Load Box
void cMenu::SL(LPDIRECT3DDEVICE9 pDevice)
{
 //Save
 DrawBox(pDevice,X,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC),C_Menu);
 DrawBorder(pDevice,X,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC),1,C_Border);
 if(MouseIsOver(X,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC)))
 {
  DrawBox(pDevice,X,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1){item.save=1;}else{mousefix_L}
 }
 cFont->DrawText(X+(Width)/4,MC_ITEMY(NO)+(FS_SPC)/2,C_TITLE,"Save",D3DFONT_CENTER|D3DFONT_SHADOW);
 //Load
 DrawBox(pDevice,X+(Width)/2,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC),C_Menu);
 DrawBorder(pDevice,X+(Width)/2,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC),1,C_Border);
 if(MouseIsOver(X+(Width)/2,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC)))
 {
  DrawBox(pDevice,X+(Width)/2,MC_ITEMY(NO)+5,(Width)/2,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1){item.load=1;}else{mousefix_L}
 }
 cFont->DrawText(X+((Width)/4)*3,MC_ITEMY(NO)+(FS_SPC)/2,C_TITLE,"Load",D3DFONT_CENTER|D3DFONT_SHADOW);
}
//Date and Time Box
void cMenu::Date_Time(LPDIRECT3DDEVICE9 pDevice)
{
 struct tm * current_tm;
 time_t current_time;time (&current_time);
 current_tm = localtime (&current_time);
 char *month []={"January","February","March","April","Mai","June","July","August","September","October","November","December"};
 char *logbuf = new char[ 256 ];
 sprintf( logbuf, "%02dth %s %d [%02d:%02d:%02d]",current_tm->tm_mday,month[current_tm->tm_mon],current_tm->tm_year-100, current_tm->tm_hour, current_tm->tm_min, current_tm->tm_sec);
 DrawBox(pDevice,X,MC_ITEMY1(NO)+5,Width,(FS_SPC),C_Menu);
 DrawBorder(pDevice,X,MC_ITEMY1(NO)+5,Width,(FS_SPC),1,C_Border);
 cFont->DrawText(((X+(X+Width))/2),MC_ITEMY1(NO)+7,C_TITLE,logbuf,D3DFONT_CENTER|D3DFONT_SHADOW);
}
//Box with Winamp remote Buttons
void cMenu::Winamp_Remote(LPDIRECT3DDEVICE9 pDevice)
{
 //Background
 DrawBox(pDevice,X,MC_ITEMY2(NO)+5,Width,(FS_SPC),C_Menu);
 DrawBorder(pDevice,X,MC_ITEMY2(NO)+5,Width,(FS_SPC),1,C_Border);
 //Fast Rewind
 DrawBorder(pDevice,X,MC_ITEMY2(NO)+5,30,(FS_SPC),1,C_Border);
 if(MouseIsOver(X,MC_ITEMY2(NO)+5,30,(FS_SPC)))
 {
  DrawBox(pDevice,X,MC_ITEMY2(NO)+5,30,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1)
  {
   Winamp.FastRewind();
  }else{mousefix_L}
 }
 cFont->DrawText(X+((Width/6)*1)-((Width/6)/2),MC_ITEMY2(NO)+7,C_TITLE,"<<",D3DFONT_CENTER|D3DFONT_SHADOW|D3DFONT_BOLD);
 
 //Previous Track
 DrawBorder(pDevice,X+30,MC_ITEMY2(NO)+5,30,(FS_SPC),1,C_Border);
 if(MouseIsOver(X+30,MC_ITEMY2(NO)+5,30,(FS_SPC)))
 {
  DrawBox(pDevice,X+30,MC_ITEMY2(NO)+5,30,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1)
  {
   Winamp.Previous_Track();
  }else{mousefix_L}
 }
 cFont->DrawText(X+((Width/6)*2)-((Width/6)/2),MC_ITEMY2(NO)+7,C_TITLE,"<",D3DFONT_CENTER|D3DFONT_SHADOW|D3DFONT_BOLD);
 //Play
 DrawBorder(pDevice,X+60,MC_ITEMY2(NO)+5,30,(FS_SPC),1,C_Border);
 if(MouseIsOver(X+60,MC_ITEMY2(NO)+5,30,(FS_SPC)))
 {
  DrawBox(pDevice,X+60,MC_ITEMY2(NO)+5,30,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1)
  {
   Winamp.Play();
  }else{mousefix_L}
 }
 cFont->DrawText(X+((Width/6)*3)-((Width/6)/2),MC_ITEMY2(NO)+7,C_TITLE,"|>",D3DFONT_CENTER|D3DFONT_SHADOW|D3DFONT_BOLD);
 //Pause
 DrawBorder(pDevice,X+90,MC_ITEMY2(NO)+5,30,(FS_SPC),1,C_Border);
 if(MouseIsOver(X+90,MC_ITEMY2(NO)+5,30,(FS_SPC)))
 {
  DrawBox(pDevice,X+90,MC_ITEMY2(NO)+5,30,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1)
  {
   Winamp.Pause();
  }else{mousefix_L}
 }
 cFont->DrawText(X+((Width/6)*4)-((Width/6)/2),MC_ITEMY2(NO)+7,C_TITLE,"||",D3DFONT_CENTER|D3DFONT_SHADOW|D3DFONT_BOLD);
 //Next Track
 DrawBorder(pDevice,X+120,MC_ITEMY2(NO)+5,30,(FS_SPC),1,C_Border);
 if(MouseIsOver(X+120,MC_ITEMY2(NO)+5,30,(FS_SPC)))
 {
  DrawBox(pDevice,X+120,MC_ITEMY2(NO)+5,30,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON) &1)
  {
   Winamp.Next_Track();
  }else{mousefix_L}
 }
 cFont->DrawText(X+((Width/6)*5)-((Width/6)/2),MC_ITEMY2(NO)+7,C_TITLE,">",D3DFONT_CENTER|D3DFONT_SHADOW|D3DFONT_BOLD);
 //Fast Forward
 DrawBorder(pDevice,X+150,MC_ITEMY2(NO)+5,30,(FS_SPC),1,C_Border);
 if(MouseIsOver(X+150,MC_ITEMY2(NO)+5,30,(FS_SPC)))
 {
  DrawBox(pDevice,X+150,MC_ITEMY2(NO)+5,30,(FS_SPC),C_CURBOX);
  if(GetAsyncKeyState(VK_LBUTTON))
  {
   Winamp.FastForward();
  }else{mousefix_L}
 }
 cFont->DrawText(X+((Width/6)*6)-((Width/6)/2),MC_ITEMY2(NO)+7,C_TITLE,">>",D3DFONT_CENTER|D3DFONT_SHADOW|D3DFONT_BOLD);
}
//TrackStatus Bar
void cMenu::Winamp_StatusBar( LPDIRECT3DDEVICE9 pDevice)
{
 float Percent = Winamp.GetSongCompletedPercentage();
 float Status = ( Percent == 0 ) ? 0 : ( (Width-10) * Percent ) / 100;
 if(Percent > 100)Winamp.Next_Track();//Prevents Bugs
 //Menu Box
 DrawBox(pDevice,X,MC_ITEMY3(NO)+5,Width,(FS_SPC),C_Menu);
 DrawBorder(pDevice,X,MC_ITEMY3(NO)+5,Width,(FS_SPC),1,C_Border);
 //StatusBox
 DrawBox(pDevice,X+5,MC_ITEMY3(NO)+10,Width-10,(FS_SPC)-10,D3DCOLOR_ARGB(80,20,20,20));
 DrawBox(pDevice,X+5,MC_ITEMY3(NO)+10,(FLOAT)Status,(FS_SPC)-10,D3DCOLOR_ARGB(250,255,0,40));
 DrawBorder(pDevice,X+5,MC_ITEMY3(NO)+10,Width-10,(FS_SPC)-10,1,D3DCOLOR_ARGB(80,255,0,40));
 //TODO: Seek_Track_Position using mouseover
}
//Two lidl Boxes on the left and right side
void cMenu::Side_Boxes(LPDIRECT3DDEVICE9 pDevice)
{
 //Left
 DrawBox(pDevice,X-10,Y,5,(NO*I_SPC)+T_SPC+(FS_SPC*4)+(FB_SPC*0)+25,C_Menu);
 DrawBorder(pDevice,X-10,Y,5,(NO*I_SPC)+T_SPC+(FS_SPC*4)+(FB_SPC*0)+25,1,C_Border);
 //Right
 DrawBox(pDevice,X+Width+5,Y,5,(NO*I_SPC)+T_SPC+(FS_SPC*4)+(FB_SPC*0)+25,C_Menu);
 DrawBorder(pDevice,X+Width+5,Y,5,(NO*I_SPC)+T_SPC+(FS_SPC*4)+(FB_SPC*0)+25,1,C_Border);
}
//Current and Next Song
void cMenu::TrackIndex(LPDIRECT3DDEVICE9 pDevice)
{
 char *Track = new char[ 256 ];
 DrawBox(pDevice, 2, 7, 1, 10, D3DCOLOR_ARGB(255,255,0,0));
 DrawBox(pDevice, 2, 17, 10, 1, D3DCOLOR_ARGB(255,255,0,0));
    if( Winamp.IsProcessRunning() == false )
 {
  cFont->DrawText(5,5,C_TITLE,"Winamp is not running",DT_LEFT|D3DFONT_SHADOW);
 }
    else if( Winamp.GetNumberOfTracksOnPlaylist() == 0 )
 {
  cFont->DrawText(5,5,C_TITLE,"No Track to display",DT_LEFT|D3DFONT_SHADOW);
 }
 else
 {
  sprintf( Track, "Current Track: %s", Winamp.GetPlaylistTitleByIndex(Winamp.GetCurrentTrackIndex()).c_str());
  cFont->DrawText(5,5,C_TITLE,Track,DT_LEFT|D3DFONT_SHADOW);
  sprintf( Track, "Next Track: %s", Winamp.GetPlaylistTitleByIndex(Winamp.GetNextTrackIndex()).c_str());
  cFont->DrawText(5,20,C_TITLE,Track,DT_LEFT|D3DFONT_SHADOW);
  DrawBox(pDevice, 2, 22, 1, 10, D3DCOLOR_ARGB(255,255,0,0));
  DrawBox(pDevice, 2, 32, 10, 1, D3DCOLOR_ARGB(255,255,0,0));
 } 
}
//Initialize the GUI
void cMenu::InitializeGUI(LPDIRECT3DDEVICE9 pDevice)
{
 Header(pDevice);
 MenuBG(pDevice);
 SL(pDevice);
 Date_Time(pDevice);
 Winamp_Remote(pDevice);
 Winamp_StatusBar(pDevice);
 Side_Boxes(pDevice);
 TrackIndex(pDevice);
}
//Build the GUI
void cMenu::CreateGUI(LPDIRECT3DDEVICE9 pDevice)
{
 GetCursorPos(&mpos);//X and Y of the curser
 ScreenToClient(GetForegroundWindow(),&mpos);
 InitializeMenu();
 InitalizeFont(pDevice);
 if(GetAsyncKeyState(VK_INSERT)&1) Show=(!Show);
 if(Show){
  InitializeGUI(pDevice);
  NO=0;
  Group("Player Related","+|-",&group.Player);//This is the group
   Item("Want Stamina?","Nope ;)|Gimme!",&item.stamina,group.Player,1);//and this one member of this group
  Group("Direct3D Stuff","+|-",&group.D3D);//same
   Item("Chams0r the Enemies?","No|YEHA!",&item.chams,group.D3D,1);

  item.save=0;
  item.load=0;
  //Render the Menu
  for(int no=0; no<NO; no++)
  { 
   D3DCOLOR text;
   D3DCOLOR text2;
   text=(*(items[no].val)>0)?C_ON:C_OFF;
   text2=(*(items[no].val)>0)?C_ON2:C_OFF2;
   if(items[no].type==T_CAT)
    text=C_CAT;
   if(mpos.x>X && mpos.x<(X+Width) && mpos.y>MC_ITEMY(no) && mpos.y<MC_ITEMY(no)+I_SPC)
    DrawBox(pDevice,X+1,MC_ITEMY(no),Width-1,I_SPC,C_CURBOX);//Lil Box on every Item
   if(items[no].type==T_CAT)
    cFont->DrawText(X+G_OFS,MC_ITEMY(no)+2,text,items[no].title,D3DFONT_SHADOW);
   else 
    cFont->DrawText(X+I_OFS,MC_ITEMY(no)+2,text,items[no].title,D3DFONT_SHADOW);
   cFont->DrawText(X+S_OFS,MC_ITEMY(no)+2,text2,items[no].state,DT_LEFT|D3DFONT_SHADOW);
   if(items[no].type!=T_CAT)
    DrawBox(pDevice, X+5, MC_ITEMY(no)+5, 5, 5, text2);
  }
  int mno=999;
  if(MouseIsOver(X, Y, Width, MC_ITEMY(NO)))
   mno = ((mpos.y-T_SPC)>Y)?((mpos.y - Y - T_SPC - (T_SPC/2)) / I_SPC):(999);
  //If Right Mousebutton is klicked once..
  if(mno!=999 && GetAsyncKeyState(VK_RBUTTON)&1 && (*items[mno].val)>0)
  {
   (*items[mno].val)-=1;
  }else{mousefix_R}
  //if Left Mousebutton is klicked once..
  if(mno!=999 && GetAsyncKeyState(VK_LBUTTON)&1 && (*items[mno].val)<(items[mno].max-1))
  {
   (*items[mno].val)+=1;
  }else{mousefix_L}
  if(Current>NO)Current=NO-1;
  //Draw a Curser; Full credits to Credzis
  Mouse(mpos.x, mpos.y, pDevice);
 }
}
//____________________Some cool stuff from Pheno____________________________\\
void cMenu::Save(char* szSection, char* szKey, int iValue,LPCSTR file)
{
 char szValue[255];
 sprintf(szValue, "%d", iValue);
 WritePrivateProfileString(szSection,  szKey, szValue, file); 
}
int cMenu::Load(char* szSection, char* szKey, int iDefaultValue,LPCSTR file)
{
 int iResult = GetPrivateProfileInt(szSection,  szKey, iDefaultValue, file); 
 return iResult;
}
void cMenu::additem(char *title, char *states,int type, int *var, int show, int when)
{
 if(show==when)
 {
  strcpy(items[NO].title,title);
  getfield(states,items[NO].state,*var+1);
  items[NO].type=type;
  items[NO].max=nofields(states);
  items[NO].val=var;
  NO++;
 }
 if(type!=T_TEXT)
 {
  if (item.load)
   *var = Load("Menu", title, *var,GetFile("penis"));
  if (item.save)
   Save("Menu", title, *var,GetFile("bla"));// Not nessesary cause we save it in Registery ;D
 }
}
void cMenu::Group(char *title, char *states,int *var)
{
 additem(title,states,T_CAT,var,0,0);
}
void cMenu::Item(char *title, char *states,int *var,int show,int when)
{
 additem(title,states,T_ITEM,var,show,when);
}
void cMenu::Text(char *title, char *states)
{ 
 additem(title,states,T_TEXT,&item.text,1,1);
}
int cMenu::nofields(char *str)
{
 char *ptr;
 int  no;
 for(no=1; (ptr=strchr(str,(char)'|'))!=NULL; no++)str=ptr+1;
 return no;
}
void cMenu::getfield(char *str,char *dst,int no)
{
 char *ptr;  
 int  i;
 for(i=1; (ptr=strchr(str,(char)'|'))!=NULL ; i++) 
 {
  if(i==no) break;
  str=ptr+1;
 }
 if(ptr)
 {
  i=(int)(ptr-str);
  strncpy(dst,str,i);
  dst[i]=0;
 }
 else
  strcpy(dst,str);
}

#ifndef __CWINAMP_H__
#define __CWINAMP_H__
#pragma warning(disable: 4530)
#include <string>
#include <windows.h>
#include "wa_ipc.h"
#include "License.h"
//defines
#define WINAMP_BUTTON_REPEAT    40022
#define WINAMP_BUTTON_SHUFFLE    40023
#define MAX_SONG_LEN            765
typedef struct
{
    char *szCurrentHours;
    char *szCurrentMinutes;
    char *szCurrentSeconds;
    char *sz******ours;
    char *szTotalMinutes;
    char *szTotalSeconds;
} tracktime_s;
typedef enum
{
    WINAMP_STOP = 0,
    WINAMP_PLAY = 1,
    WINAMP_PAUSE = 3,
    WINAMP_UNKNOWN = -1
} playstatus_s;
class cWinamp
{
public:
    //-------------------------------------------------
    //class related
    cWinamp( );
    ~cWinamp( );
    void        Cleanup( void );
    bool        IsProcessRunning( void );
    bool        ExecuteWinamp( const char *szPath );
    bool        TerminateWinampProcess( void );
    //-------------------------------------------------
    //information functions
    int            GetTrackPlayed( void );
    int            GetTrackLength( void );
    int            GetCurrentVolume( void ){ return Request_Command( IPC_CB_MISC_VOLUME, IPC_CB_MISC ); }
    bool        IsRepeating( void ){ return ( ( Request_Command( 0, IPC_GET_REPEAT ) == 0 ) ? false : true ); }
    bool        IsShuffling( void ){ return ( ( Request_Command( 0, IPC_GET_SHUFFLE ) == 0 ) ? false : true ); }
    int            GetSongCompletedPercentage( void );
    int            GetCurrentTrackIndex( void );
    int            GetNextTrackIndex( void );
    int            GetNumberOfTracksOnPlaylist( void );
    int            GetPlaylistPosition( void );
    std::string GetPlaylistTitleByIndex( int index );
    tracktime_s GetTrackTimeInformation( void );
    playstatus_s GetPlayingStatus( void );
    char*        GetPlaystatusString( playstatus_s status );
    //-------------------------------------------------
    //control functions
    void        Play( void ){ Send_Command( WINAMP_BUTTON2 ); }
    void        Pause( void ){ Send_Command( WINAMP_BUTTON3 ); }
    void        Stop( void ){ Send_Command( WINAMP_BUTTON4 ); }
    void        Next_Track( void ){ Send_Command( WINAMP_BUTTON5 ); }
    void        Previous_Track( void ){ Send_Command( WINAMP_BUTTON1 ); }
    void        Repeat_Toggle( void ){ Send_Command( WINAMP_BUTTON_REPEAT ); }
    void        Shuffle_Toggle( void ){ Send_Command( WINAMP_BUTTON_SHUFFLE ); }
    void        Seek_Track_Position( int m_iPosition ){ Request_Command( m_iPosition, IPC_JUMPTOTIME ); }
    void        SetVolume( int m_iVolume ){ Request_Command( m_iVolume, IPC_SETVOLUME ); }
    void        IncreaseVolume( void ){ Send_Command( WINAMP_VOLUMEUP ); }
    void        DecreaseVolume( void ){ Send_Command( WINAMP_VOLUMEDOWN ); }
    void        Goto_Track_Begin( void ){ Send_Command( WINAMP_BUTTON1_CTRL ); }
    void        Goto_Track_End( void ){ Send_Command( WINAMP_BUTTON5_CTRL ); }
    void        Goto_TrackByIndex( int index ){ Request_Command( index - 1,IPC_SETPLAYLISTPOS ); }
    void        FastForward( void ){ Send_Command( WINAMP_FFWD5S ); }
    void        FastRewind( void ){ Send_Command( WINAMP_REW5S ); }
    void        LoadPlaylist( char *m_szDirectory, char *m_szFile );
    
    //-------------------------------------------------
    //functionality
    int            Request_Command( int m_iData, int m_iCmd );
    void        Send_Command( int m_iCmd );
private:
        HWND    m_hWindow;
        DWORD   m_dwProcessId;
        HANDLE  m_hProcess;
};
extern cWinamp Winamp;
#endif

include <windows.h>
#include <shellapi.h>
#include "cWinamp.h"
#include "wa_ipc.h"
//_________________Credits: ****** and nullsoft___________________
//int/char conversion
#pragma warning( disable : 4312 )
cWinamp GWinamp;
char *GSZTimeStrings[] = 
{
    "00", "01", "02", "03", "04", "05", "06", "07", "08", "09",
    "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
    "20", "21", "22", "23", "24", "25", "26", "27", "28", "29",
    "30", "31", "32", "33", "34", "35", "36", "37", "38", "39",
    "40", "41", "42", "43", "44", "45", "46", "47", "48", "49",
    "50", "51", "52", "53", "54", "55", "56", "57", "58", "59"
};
//======================================================================================
cWinamp::cWinamp( )
{
    Cleanup( );
}
cWinamp::~cWinamp( )
{
    if( m_hProcess )
        CloseHandle( m_hProcess );
    Cleanup( );
}
//======================================================================================
void cWinamp::Cleanup( void )
{
    ZeroMemory( &m_hProcess,    sizeof( HANDLE ) );
    ZeroMemory( &m_hWindow,        sizeof( HWND ) );
    ZeroMemory( &m_dwProcessId, sizeof( DWORD ) );
}
bool cWinamp::IsProcessRunning( void )
{
    if( m_hWindow || m_hProcess )
        return true;
    m_hWindow = FindWindowA( "Winamp v1.x", 0 );
    if( m_hWindow )
    {
        GetWindowThreadProcessId( m_hWindow, &m_dwProcessId );
        if( m_dwProcessId )
        {
            m_hProcess = OpenProcess( PROCESS_ALL_ACCESS, false, m_dwProcessId );
            if( m_hProcess )
            {
                return true;
            }
        }
    }
    return false;
}
void cWinamp::Send_Command( int m_iCmd )
{
    if( !IsProcessRunning( ) )
        return;
    PostMessage( m_hWindow, WM_COMMAND, m_iCmd, 0 );
}
int cWinamp::Request_Command( int m_iData, int m_iCmd )
{
    if( !IsProcessRunning( ) )
        return -1;
    return ( int )SendMessage( m_hWindow, WM_WA_IPC, m_iData, m_iCmd );
}
bool cWinamp::ExecuteWinamp( const char *szPath )
{
    if( !IsProcessRunning( ) )
        return false;
    BOOL m_bSuccess = FALSE;
    STARTUPINFOA SI;
    PROCESS_INFORMATION PI;
    ZeroMemory( &SI, sizeof( STARTUPINFOA ) );
    ZeroMemory( &PI, sizeof( PROCESS_INFORMATION ) );
    SI.cb = sizeof( STARTUPINFOA );
    m_bSuccess = CreateProcessA( szPath, 0, 0, 0, false, 0, 0, 0, &SI, &PI );
    if( m_bSuccess == TRUE )
    {
        m_dwProcessId = PI.dwProcessId;
        return true;
    }
    return false;
}
bool cWinamp::TerminateWinampProcess( void )
{
    if( !IsProcessRunning( ) )
        return false;
    return ( bool )( TerminateProcess( m_hProcess, 0 ) ? true : false );
}
//======================================================================================
int cWinamp::GetTrackPlayed( void )
{
    if( !IsProcessRunning( ) )
        return 0;
    //seconds
    int m_iMessage = Request_Command( 0, IPC_GETOUTPUTTIME );
    return ( m_iMessage / 1000 );
}
int cWinamp::GetTrackLength( void )
{
    if( !IsProcessRunning( ) )
        return 0;
    //seconds
    return Request_Command( 1, IPC_GETOUTPUTTIME );
}
int cWinamp::GetCurrentTrackIndex( void )
{
    return Request_Command( 0, IPC_GETLISTPOS );
}
int cWinamp::GetNextTrackIndex( void )
{
    if( !IsProcessRunning( ) )
        return 0;
    int m_iAllTracks = GetNumberOfTracksOnPlaylist( );
    if( m_iAllTracks == 0 )
        return 0;
    int m_iCurrent_Index = GetCurrentTrackIndex( );
    if( m_iCurrent_Index >= m_iAllTracks )
    {
        m_iCurrent_Index = 0;
        goto return_index;
    }
    m_iCurrent_Index++;
return_index:
    return m_iCurrent_Index;
}
int cWinamp::GetSongCompletedPercentage( void )
{
    if( !IsProcessRunning( ) )
        return 0;
    float m_iTrackPlayed = ( float )GetTrackPlayed( );
    float m_iTotalTrack = ( float )GetTrackLength( );
    if( m_iTotalTrack == 0 || m_iTrackPlayed == 0 )
        return 0;
    float m_fTrackFraction = ( m_iTrackPlayed / m_iTotalTrack );
    m_fTrackFraction *= 100.0f;
    return ( int )( m_fTrackFraction );
}
int cWinamp::GetNumberOfTracksOnPlaylist( void )
{
    if( !IsProcessRunning( ) )
        return 0;
    return ( Request_Command( 0, IPC_GETLISTLENGTH ) - 1 );
}
int cWinamp::GetPlaylistPosition( void )
{
    if( !IsProcessRunning( ) )
        return 0;
    return Request_Command( 0, IPC_GETLISTPOS );
}
std::string cWinamp::GetPlaylistTitleByIndex( int index )
{
    if( !IsProcessRunning( ) )
        return 0;
    DWORD m_dwReadBytes = 0;
    char m_szTrackName[ MAX_SONG_LEN ] = { '\0' };
    char *m_szName = ( char* )Request_Command( index, IPC_GETPLAYLISTTITLE );
    ReadProcessMemory( m_hProcess, m_szName, m_szTrackName, MAX_SONG_LEN, &m_dwReadBytes );
    return ( std::string )m_szTrackName;
}
tracktime_s cWinamp::GetTrackTimeInformation( void )
{
    tracktime_s tmp;
    if( IsProcessRunning( ) )
    {
        int seconds = ( int )( ( float )Request_Command( 0, IPC_GETOUTPUTTIME ) * 0.001f );
        int hours = seconds / 3600;
        int minutes = ( seconds - hours * 3600 ) / 60;
        seconds = seconds % 60;
        tmp.szCurrentHours = GSZTimeStrings[ hours ];
        tmp.szCurrentMinutes = GSZTimeStrings[ minutes ];
        tmp.szCurrentSeconds = GSZTimeStrings[ seconds ];
        seconds = Request_Command( 1, IPC_GETOUTPUTTIME );
        hours = seconds / 3600;
        minutes = ( seconds - hours * 3600 ) / 60;
        seconds = seconds % 60;
        tmp.sz******ours = GSZTimeStrings[ hours ];
        tmp.szTotalMinutes = GSZTimeStrings[ minutes ];
        tmp.szTotalSeconds = GSZTimeStrings[ seconds ];
    }
    return tmp;
}
void cWinamp::LoadPlaylist( char *m_szDirectory, char *m_szFile )
{
    ShellExecuteA( NULL, NULL, m_szFile, NULL, m_szDirectory, SW_SHOWNA );
}
playstatus_s cWinamp::GetPlayingStatus( void )
{
    if( !IsProcessRunning( ) )
    {
        goto return_unknown;
    }
    return ( playstatus_s )Request_Command( 0, IPC_ISPLAYING );
return_unknown:
    return WINAMP_UNKNOWN;
}
char *cWinamp::GetPlaystatusString( playstatus_s status )
{
    if( IsProcessRunning( ) )
    {
        switch( status )
        {
        case WINAMP_STOP:return "Stopped";
        case WINAMP_PLAY:return "Playing";
        case WINAMP_PAUSE:return "Paused";
        }
    }
    return "Winamp inactive";
}

#pragma once
#include <windows.h>
#include <d3d9.h>
#include "d3dfont9.h"
#include "License.h"
#pragma comment (lib, "d3d9.lib")

#define RESET  16
#define BEGINSCENE  41
#define ENDSCENE 42
#define DRAWINDEXEDPRIMITIVE 82
#define SETRENDERSTATE 50

typedef HRESULT (WINAPI* oEndScene)             ( LPDIRECT3DDEVICE9 pDevice);
typedef HRESULT (WINAPI* oBeginScene)   ( LPDIRECT3DDEVICE9 pDevice);
typedef HRESULT (WINAPI* oReset)                ( LPDIRECT3DDEVICE9 pDevice,D3DPRESENT_PARAMETERS* pPresentationParameters);
typedef HRESULT (WINAPI* oDrawIndexedPrimitive) ( LPDIRECT3DDEVICE9 pDevice,D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount );
typedef HRESULT (WINAPI* oSetRenderState )  ( LPDIRECT3DDEVICE9 pDevice, D3DRENDERSTATETYPE State, DWORD Value, UINT NumVertices, UINT startIndex, UINT primCount, UINT m_Stride );

#include "d3dfont9.cpp"
#include "d3d9types.h"
#include "D3D Base.h"
#include "cMenu.h"
cMenu Menu;
oReset pReset;
oEndScene pEndScene;
oDrawIndexedPrimitive pDrawIndexedPrimitive;
UINT m_Stride; 
HRESULT WINAPI Reset ( LPDIRECT3DDEVICE9 pDevice, D3DPRESENT_PARAMETERS* pPresentationParameters )
{
 if(Menu.FontCreated && Menu.firstInit)
  Menu.PreReset();
 if(!Menu.FontCreated && Menu.firstInit)
  Menu.PostReset(pDevice);
 return pReset( pDevice, pPresentationParameters );
}
HRESULT WINAPI EndScene (LPDIRECT3DDEVICE9 pDevice)
{
 Menu.CreateGUI(pDevice);//Call the Menu
 return pEndScene(pDevice);
}
HRESULT WINAPI DrawIndexedPrimitive(LPDIRECT3DDEVICE9 pDevice, D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
 //Chams or w.e here
 return pDrawIndexedPrimitive(pDevice, Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}
bool bCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
 for(;*szMask;++szMask,++pData,++bMask)
 {
  if(*szMask=='x' && *pData!=*bMask)   
   return 0;
 }
 return (*szMask) == NULL;
}
DWORD FindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask)
{
 for(DWORD i=0; i<dwLen; i++)
  if (bCompare((BYTE*)(dwAddress+i),bMask,szMask))  return (DWORD)(dwAddress+i);
 return 0;
}
void *DetourCreate(BYTE *src, const BYTE *dst, const int len)
{
 BYTE *jmp = (BYTE*)malloc(len+5);
 DWORD dwBack;
 VirtualProtect(src, len, PAGE_EXECUTE_READWRITE, &dwBack);
 memcpy(jmp, src, len); 
 jmp += len;
 jmp[0] = 0xE9;
 *(DWORD*)(jmp+1) = (DWORD)(src+len - jmp) - 5;
 src[0] = 0xE9;
 *(DWORD*)(src+1) = (DWORD)(dst - src) - 5;
 for (int i=5; i<len; i++)  src[i]=0x90;
 VirtualProtect(src, len, dwBack, &dwBack);
 return (jmp-len);
}
int Initialize(void)
{
 DWORD  hD3D, adr, *vtbl;
 hD3D=0;
 do {
  hD3D = (DWORD)GetModuleHandle("d3d9.dll");
  Sleep(10);
 } while(!hD3D);
 adr = FindPattern(hD3D, 0x128000, (PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86", "xx????xx????xx");
 if (adr) {
  memcpy(&vtbl,(void *)(adr+2),4);
  pReset   = (oReset) DetourCreate((PBYTE)vtbl[RESET]   , (PBYTE)Reset   ,5);
  pEndScene = (oEndScene) DetourCreate((PBYTE)vtbl[ENDSCENE], (PBYTE)EndScene,5);
  pDrawIndexedPrimitive = (oDrawIndexedPrimitive) DetourCreate((PBYTE)vtbl[DRAWINDEXEDPRIMITIVE], (PBYTE)DrawIndexedPrimitive,5);
  }
 return 0;
}
BOOL WINAPI DllMain(HMODULE hDll, DWORD dwReason, LPVOID lpReserved)
{
 switch(dwReason)
 {
  case DLL_PROCESS_ATTACH:
   CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Initialize, NULL, NULL, NULL);
   break;
  case DLL_PROCESS_DETACH:
   break;
 }
 return TRUE;
}

//-----------------------------------------------------------------------------
// File: D3DFont.h
// Desc: Texture-based font class
// Copyright (c)  Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#ifndef D3DFONT_H
#define D3DFONT_H
#include <tchar.h>
#include <D3D9.h>


// Font creation flags
#define D3DFONT_BOLD        0x0001
#define D3DFONT_ITALIC      0x0002
#define D3DFONT_ZENABLE     0x0004

// Font rendering flags
#define D3DFONT_CENTER      0x0001
#define D3DFONT_TWOSIDED    0x0002
#define D3DFONT_FILTERED    0x0004
#define D3DFONT_RIGHT       0x0008			// non standard feature
#define D3DFONT_SHADOW      0x0010			// non standard feature



//-----------------------------------------------------------------------------
// Name: class CD3DFont
// Desc: Texture-based font class for doing text in a 3D scene.
//-----------------------------------------------------------------------------
class CD3DFont
{
    TCHAR   m_strFontName[80];            // Font properties
    DWORD   m_dwFontHeight;
    DWORD   m_dwFontFlags;

    LPDIRECT3DDEVICE9       m_pd3dDevice; // A D3DDevice used for rendering
    LPDIRECT3DTEXTURE9      m_pTexture;   // The d3d texture for this font
    LPDIRECT3DVERTEXBUFFER9 m_pVB;        // VertexBuffer for rendering text
    DWORD   m_dwTexWidth;                 // Texture dimensions
    DWORD   m_dwTexHeight;
    FLOAT   m_fTextScale;
    FLOAT   m_fTexCoords[128-32][4];
    DWORD   m_dwSpacing;                  // Character pixel spacing per side

    // Stateblocks for setting and restoring render states
    LPDIRECT3DSTATEBLOCK9 m_pStateBlockSaved;
    LPDIRECT3DSTATEBLOCK9 m_pStateBlockDrawText;

public:
    // 2D and 3D text drawing functions
    HRESULT DrawText( FLOAT x, FLOAT y, DWORD dwColor, 
                      const TCHAR* strText, DWORD dwFlags=0L );
    HRESULT DrawTextScaled( FLOAT x, FLOAT y, FLOAT z, 
                            FLOAT fXScale, FLOAT fYScale, DWORD dwColor, 
                            const TCHAR* strText, DWORD dwFlags=0L );
    HRESULT Render3DText( const TCHAR* strText, DWORD dwFlags=0L );
    
    // Function to get extent of text
    HRESULT GetTextExtent( const TCHAR* strText, SIZE* pSize );

    // Initializing and destroying device-dependent objects
    HRESULT InitDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice );
    HRESULT RestoreDeviceObjects();
    HRESULT InvalidateDeviceObjects();
    HRESULT DeleteDeviceObjects();

    // Constructor / destructor
    CD3DFont( const TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags=0L );
    ~CD3DFont();
};




#endif

// -----------------------------------------------------------------------------
// File: D3DFont.cpp
// Desc: Texture-based font class
// Copyright (c) 1999-2001 Microsoft Corporation. All rights reserved.
//
// Changes by Hans211
// - Added D3D_FONT_RIGHT
// - Stripped not needed functions
// -----------------------------------------------------------------------------
#include <stdio.h>
#include <tchar.h>
#include <D3DX9.h>
#include "D3DFont9.h"
#pragma warning(disable: 4996)
//-----------------------------------------------------------------------------
// Custom vertex types for rendering text
//-----------------------------------------------------------------------------
#define MAX_NUM_VERTICES 50*6
struct FONT2DVERTEX { D3DXVECTOR4 p;   DWORD color;     FLOAT tu, tv; };
struct FONT3DVERTEX { D3DXVECTOR3 p;   D3DXVECTOR3 n;   FLOAT tu, tv; };
#define D3DFVF_FONT2DVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1)
#define D3DFVF_FONT3DVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)
inline FONT2DVERTEX InitFont2DVertex( const D3DXVECTOR4& p, D3DCOLOR color,
                                      FLOAT tu, FLOAT tv )
{
    FONT2DVERTEX v;   v.p = p;   v.color = color;   v.tu = tu;   v.tv = tv;
    return v;
}
inline FONT3DVERTEX InitFont3DVertex( const D3DXVECTOR3& p, const D3DXVECTOR3& n,
                                      FLOAT tu, FLOAT tv )
{
    FONT3DVERTEX v;   v.p = p;   v.n = n;   v.tu = tu;   v.tv = tv;
    return v;
}
 

//-----------------------------------------------------------------------------
// Name: CD3DFont()
// Desc: Font class constructor
//-----------------------------------------------------------------------------
CD3DFont::CD3DFont( const TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags )
{
    _***ncpy( m_strFontName, strFontName, sizeof(m_strFontName) / sizeof(TCHAR) );
    m_strFontName[sizeof(m_strFontName) / sizeof(TCHAR) - 1] = _T('\0');
    m_dwFontHeight         = dwHeight;
    m_dwFontFlags          = dwFlags;
    m_dwSpacing            = 0;
    m_pd3dDevice           = NULL;
    m_pTexture             = NULL;
    m_pVB                  = NULL;
    m_pStateBlockSaved     = NULL;
    m_pStateBlockDrawText  = NULL;
}
 

//-----------------------------------------------------------------------------
// Name: ~CD3DFont()
// Desc: Font class destructor
//-----------------------------------------------------------------------------
CD3DFont::~CD3DFont()
{
    InvalidateDeviceObjects();
    DeleteDeviceObjects();
}
 

//-----------------------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: Initializes device-dependent objects, including the vertex buffer used
//       for rendering text and the texture map which stores the font image.
//-----------------------------------------------------------------------------
HRESULT CD3DFont::InitDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice )
{
    HRESULT hr;
    // Keep a local copy of the device
    m_pd3dDevice = pd3dDevice;
    // Establish the font and texture size
    m_fTextScale  = 1.0f; // Draw fonts into texture without scaling
    // Large fonts need larger textures
    if( m_dwFontHeight > 60 )
        m_dwTexWidth = m_dwTexHeight = 2048;
    else if( m_dwFontHeight > 30 )
        m_dwTexWidth = m_dwTexHeight = 1024;
    else if( m_dwFontHeight > 15 )
        m_dwTexWidth = m_dwTexHeight = 512;
    else
        m_dwTexWidth  = m_dwTexHeight = 256;
    // If requested texture is too big, use a smaller texture and smaller font,
    // and scale up when rendering.
    D3DCAPS9 d3dCaps;
    m_pd3dDevice->GetDeviceCaps( &d3dCaps );
    if( m_dwTexWidth > d3dCaps.MaxTextureWidth )
    {
        m_fTextScale = (FLOAT)d3dCaps.MaxTextureWidth / (FLOAT)m_dwTexWidth;
        m_dwTexWidth = m_dwTexHeight = d3dCaps.MaxTextureWidth;
    }
    // Create a new texture for the font
    hr = m_pd3dDevice->CreateTexture( m_dwTexWidth, m_dwTexHeight, 1,
                                      0, D3DFMT_A4R4G4B4,
                                      D3DPOOL_MANAGED, &m_pTexture, NULL );
    if( FAILED(hr) )
        return hr;
    // Prepare to create a bitmap
    DWORD*      pBitmapBits;
    BITMAPINFO bmi;
    ZeroMemory( &bmi.bmiHeader,  sizeof(BITMAPINFOHEADER) );
    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth       =  (int)m_dwTexWidth;
    bmi.bmiHeader.biHeight      = -(int)m_dwTexHeight;
    bmi.bmiHeader.biPlanes      = 1;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biBitCount    = 32;
    // Create a DC and a bitmap for the font
    HDC     hDC       = CreateCompatibleDC( NULL );
    HBITMAP hbmBitmap = CreateDIBSection( hDC, &bmi, DIB_RGB_COLORS,
                                          (void**)&pBitmapBits, NULL, 0 );
    SetMapMode( hDC, MM_TEXT );
    // Create a font.  By specifying ANTIALIASED_QUALITY, we might get an
    // antialiased font, but this is not guaranteed.
    INT nHeight    = -MulDiv( m_dwFontHeight, 
        (INT)(GetDeviceCaps(hDC, LOGPIXELSY) * m_fTextScale), 72 );
    DWORD dwBold   = (m_dwFontFlags&D3DFONT_BOLD)   ? FW_BOLD : FW_NORMAL;
    DWORD dwItalic = (m_dwFontFlags&D3DFONT_ITALIC) ? TRUE    : FALSE;
    HFONT hFont    = CreateFont( nHeight, 0, 0, 0, dwBold, dwItalic,
                          FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
                          CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
                          VARIABLE_PITCH, m_strFontName );
    if( NULL==hFont )
        return E_FAIL;
    SelectObject( hDC, hbmBitmap );
    SelectObject( hDC, hFont );
    // Set text properties
    SetTextColor( hDC, RGB(255,255,255) );
    SetBkColor(   hDC, 0x00000000 );
    SetTextAlign( hDC, TA_TOP );
    // Loop through all printable character and output them to the bitmap..
    // Meanwhile, keep track of the corresponding tex coords for each character.
    DWORD x = 0;
    DWORD y = 0;
    TCHAR str[2] = _T("x");
    SIZE size;
    // Calculate the spacing between characters based on line height
    GetTextExtentPoint32( hDC, TEXT(" "), 1, &size );
    x = m_dwSpacing = (DWORD) ceil(size.cy * 0.3f);
    for( TCHAR c=32; c<127; c++ )
    {
        str[0] = c;
        GetTextExtentPoint32( hDC, str, 1, &size );
        if( (DWORD)(x + size.cx + m_dwSpacing) > m_dwTexWidth )
        {
            x  = m_dwSpacing;
            y += size.cy+1;
        }
        ExtTextOut( hDC, x+0, y+0, ETO_OPAQUE, NULL, str, 1, NULL );
        m_fTexCoords[c-32][0] = ((FLOAT)(x + 0       - m_dwSpacing))/m_dwTexWidth;
        m_fTexCoords[c-32][1] = ((FLOAT)(y + 0       + 0          ))/m_dwTexHeight;
        m_fTexCoords[c-32][2] = ((FLOAT)(x + size.cx + m_dwSpacing))/m_dwTexWidth;
        m_fTexCoords[c-32][3] = ((FLOAT)(y + size.cy + 0          ))/m_dwTexHeight;
        x += size.cx + (2 * m_dwSpacing);
    }
    // Lock the surface and write the alpha values for the set pixels
    D3DLOCKED_RECT d3dlr;
    m_pTexture->LockRect( 0, &d3dlr, 0, 0 );
    BYTE* pDstRow = (BYTE*)d3dlr.pBits;
    WORD* pDst16;
    BYTE bAlpha; // 4-bit measure of pixel intensity
    for( y=0; y < m_dwTexHeight; y++ )
    {
        pDst16 = (WORD*)pDstRow;
        for( x=0; x < m_dwTexWidth; x++ )
        {
            bAlpha = (BYTE)((pBitmapBits[m_dwTexWidth*y + x] & 0xff) >> 4);
            if (bAlpha > 0)
            {
                *pDst16++ = (WORD) ((bAlpha << 12) | 0x0fff);
            }
            else
            {
                *pDst16++ = 0x0000;
            }
        }
        pDstRow += d3dlr.Pitch;
    }
    // Done updating texture, so clean up used objects
    m_pTexture->UnlockRect(0);
    DeleteObject( hbmBitmap );
    DeleteDC( hDC );
    DeleteObject( hFont );
    return S_OK;
}
 

//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DFont::RestoreDeviceObjects()
{
    HRESULT hr;
    // Create vertex buffer for the letters
    int vertexSize = max( sizeof(FONT2DVERTEX), sizeof(FONT3DVERTEX ) );
    if( FAILED( hr = m_pd3dDevice->CreateVertexBuffer( MAX_NUM_VERTICES * vertexSize,
                                                       D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0,
                                                       D3DPOOL_DEFAULT, &m_pVB, NULL ) ) )
    {
        return hr;
    }
    // Create the state blocks for rendering text
    for( UINT which=0; which<2; which++ )
    {
        m_pd3dDevice->BeginStateBlock();
        m_pd3dDevice->SetTexture( 0, m_pTexture );
        if ( D3DFONT_ZENABLE & m_dwFontFlags )
            m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
        else
            m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
        m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,   D3DBLEND_SRCALPHA );
        m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND,  D3DBLEND_INVSRCALPHA );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE,  TRUE );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHAREF,         0x08 );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC,  D3DCMP_GREATEREQUAL );
        m_pd3dDevice->SetRenderState( D3DRS_FILLMODE,   D3DFILL_SOLID );
        m_pd3dDevice->SetRenderState( D3DRS_CULLMODE,   D3DCULL_CCW );
        m_pd3dDevice->SetRenderState( D3DRS_STENCILENABLE,    FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_CLIPPING,         TRUE );
        m_pd3dDevice->SetRenderState( D3DRS_CLIPPLANEENABLE,  FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_VERTEXBLEND,      D3DVBF_DISABLE );
        m_pd3dDevice->SetRenderState( D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_FOGENABLE,        FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_COLORWRITEENABLE,
            D3DCOLORWRITEENABLE_RED  | D3DCOLORWRITEENABLE_GREEN |
            D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
        m_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE );
        m_pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
        if( which==0 )
            m_pd3dDevice->EndStateBlock( &m_pStateBlockSaved );
        else
            m_pd3dDevice->EndStateBlock( &m_pStateBlockDrawText );
    }
    return S_OK;
}

#define SAFE_RELEASE(p) if (p)  { free(p); p=NULL; }
//-----------------------------------------------------------------------------
// Name: InvalidateDeviceObjects()
// Desc: Destroys all device-dependent objects
//-----------------------------------------------------------------------------
HRESULT CD3DFont::InvalidateDeviceObjects()
{
    SAFE_RELEASE( m_pVB );
    SAFE_RELEASE( m_pStateBlockSaved );
    SAFE_RELEASE( m_pStateBlockDrawText );
    return S_OK;
}

//-----------------------------------------------------------------------------
// Name: DeleteDeviceObjects()
// Desc: Destroys all device-dependent objects
//-----------------------------------------------------------------------------
HRESULT CD3DFont::DeleteDeviceObjects()
{
    SAFE_RELEASE( m_pTexture );
    m_pd3dDevice = NULL;
    return S_OK;
}

//-----------------------------------------------------------------------------
// Name: GetTextExtent()
// Desc: Get the dimensions of a text string
//-----------------------------------------------------------------------------
HRESULT CD3DFont::GetTextExtent( const TCHAR* strText, SIZE* pSize )
{
    if( NULL==strText || NULL==pSize )
        return E_FAIL;
    FLOAT fRowWidth  = 0.0f;
    FLOAT fRowHeight = (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight;
    FLOAT fWidth     = 0.0f;
    FLOAT fHeight    = fRowHeight;
    while( *strText )
    {
        TCHAR c = *strText++;
        if( c == _T('\n') )
        {
            fRowWidth = 0.0f;
            fHeight  += fRowHeight;
        }
        if( (c-32) < 0 || (c-32) >= 128-32 )
            continue;
        FLOAT tx1 = m_fTexCoords[c-32][0];
        FLOAT tx2 = m_fTexCoords[c-32][2];
        fRowWidth += (tx2-tx1)*m_dwTexWidth - 2*m_dwSpacing;
        if( fRowWidth > fWidth )
            fWidth = fRowWidth;
    }
    pSize->cx = (int)fWidth;
    pSize->cy = (int)fHeight;
    return S_OK;
}

//-----------------------------------------------------------------------------
// Name: DrawText()
// Desc: Draws 2D text. Note that sx and sy are in pixels
//-----------------------------------------------------------------------------
HRESULT CD3DFont::DrawText( FLOAT sx, FLOAT sy, DWORD dwColor,
                            const TCHAR* strText, DWORD dwFlags )
{
    if( m_pd3dDevice == NULL )
        return E_FAIL;
    // Setup renderstate
    m_pStateBlockSaved->Capture();
    m_pStateBlockDrawText->Apply();
    m_pd3dDevice->SetFVF( D3DFVF_FONT2DVERTEX );
    m_pd3dDevice->SetPixelShader( NULL );
    m_pd3dDevice->SetStreamSource( 0, m_pVB, 0, sizeof(FONT2DVERTEX) );
    // Set filter states
    if( dwFlags & D3DFONT_FILTERED )
    {
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
    }
    if( dwFlags & D3DFONT_RIGHT ) {
        SIZE sz;
        GetTextExtent( strText, &sz );
        sx -= (FLOAT)sz.cx;
    } else if( dwFlags & D3DFONT_CENTER ) {
        SIZE sz;
        GetTextExtent( strText, &sz );
        sx -= (FLOAT)sz.cx/2.0f;
    }
    // Adjust for character spacing
    sx -= m_dwSpacing;
    FLOAT fStartX = sx;
    // Fill vertex buffer
    FONT2DVERTEX* pVertices = NULL;
    DWORD         dwNumTriangles = 0;
    m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD );
    while( *strText )
    {
        TCHAR c = *strText++;
        if( c == _T('\n') )
        {
            sx = fStartX;
            sy += (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight;
        }
        if( (c-32) < 0 || (c-32) >= 128-32 )
            continue;
        FLOAT tx1 = m_fTexCoords[c-32][0];
        FLOAT ty1 = m_fTexCoords[c-32][1];
        FLOAT tx2 = m_fTexCoords[c-32][2];
        FLOAT ty2 = m_fTexCoords[c-32][3];
        FLOAT w = (tx2-tx1) *  m_dwTexWidth / m_fTextScale;
        FLOAT h = (ty2-ty1) * m_dwTexHeight / m_fTextScale;
        if( c != _T(' ') )
        {
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx1, ty2 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx1, ty1 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx2, ty2 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx2, ty1 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx2, ty2 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx1, ty1 );
            dwNumTriangles += 2;
            if( dwNumTriangles*3 > (MAX_NUM_VERTICES-6) )
            {
                // Unlock, render, and relock the vertex buffer
                m_pVB->Unlock();
                m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
                pVertices = NULL;
                m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD );
                dwNumTriangles = 0L;
            }
        }
        sx += w - (2 * m_dwSpacing);
    }
    // Unlock and render the vertex buffer
    m_pVB->Unlock();
    if( dwNumTriangles > 0 )
        m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
    // Restore the modified renderstates
    m_pStateBlockSaved->Apply();
    return S_OK;
}

/*
** Copyright (C) 2003 Nullsoft, Inc.
**
** This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held 
** liable for any damages arising from the use of this software. 
**
** Permission is granted to anyone to use this software for any purpose, including commercial applications, and to 
** alter it and redistribute it freely, subject to the following restrictions:
**
**   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. 
**      If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
**
**   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
**
**   3. This notice may not be removed or altered from any source distribution.
**
*/
#include <windows.h>
#ifndef _WA_IPC_H_
#define _WA_IPC_H_
/*
** This is the modern replacement for the classic 'frontend.h'. Most of these 
** updates are designed for in-process use, i.e. from a plugin.
**
*/
/* message used to sent many messages to winamp's main window. 
** most all of the IPC_* messages involve sending the message in the form of:
**   result = SendMessage(hwnd_winamp,WM_WA_IPC,(parameter),IPC_*);
*/
#define WM_WA_IPC WM_USER
/* but some of them use WM_COPYDATA. be afraid.
*/
#define IPC_GETVERSION 0
/* int version = SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETVERSION);
**
** Version will be 0x20yx for winamp 2.yx. versions previous to Winamp 2.0
** typically (but not always) use 0x1zyx for 1.zx versions. Weird, I know.
*/
#define IPC_GETREGISTEREDVERSION 770

typedef struct {
  char *filename;
  char *title;
  int length;
} enqueueFileWithMetaStruct; // send this to a IPC_PLAYFILE in a non WM_COPYDATA, 
// and you get the nice desired result. if title is NULL, it is treated as a "thing",
// otherwise it's assumed to be a file (for speed)
#define IPC_PLAYFILE 100  // dont be fooled, this is really the same as enque*****
#define IPC_ENQUEUEFILE 100 
/* sent as a WM_COPYDATA, with IPC_PLAYFILE as the dwData, and the string to play
** as the lpData. Just enqueues, does not clear the playlist or change the playback
** state.
*/

#define IPC_DELETE 101
#define IPC_DELETE_INT 1101 // don't use this, it's used internally by winamp when 
                            // dealing with some lame explorer issues.
/* SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_DELETE);
** Use IPC_DELETE to clear Winamp's internal playlist.
*/

#define IPC_STARTPLAY 102   // starts playback. almost like hitting play in Winamp.
#define IPC_STARTPLAY_INT 1102 // used internally, don't bother using it (won't be any fun)

#define IPC_CHDIR 103
/* sent as a WM_COPYDATA, with IPC_CHDIR as the dwData, and the directory to change to
** as the lpData. 
*/

#define IPC_ISPLAYING 104
/* int res = SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_ISPLAYING);
** If it returns 1, it is playing. if it returns 3, it is paused, 
** if it returns 0, it is not playing.
*/

#define IPC_GETOUTPUTTIME 105
/* int res = SendMessage(hwnd_winamp,WM_WA_IPC,mode,IPC_GETOUTPUTTIME);
** returns the position in milliseconds of the current track (mode = 0), 
** or the track length, in seconds (mode = 1). Returns -1 if not playing or error.
*/

#define IPC_JUMPTOTIME 106
/* (requires Winamp 1.60+)
** SendMessage(hwnd_winamp,WM_WA_IPC,ms,IPC_JUMPTOTIME);
** IPC_JUMPTOTIME sets the position in milliseconds of the 
** current song (approximately).
** Returns -1 if not playing, 1 on eof, or 0 if successful
*/
#define IPC_GETMODULENAME 109
#define IPC_EX_ISRIGHTEXE 666
/* usually shouldnt bother using these, but here goes:
** send a WM_COPYDATA with IPC_GETMODULENAME, and an internal
** flag gets set, which if you send a normal WM_WA_IPC message with
** IPC_EX_ISRIGHTEXE, it returns whether or not that filename
** matches. lame, I know.
*/
#define IPC_WRITEPLAYLIST 120
/* (requires Winamp 1.666+)
** SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_WRITEPLAYLIST);
**
** IPC_WRITEPLAYLIST writes the current playlist to <winampdir>\\Winamp.m3u,
** and returns the current playlist position.
** Kinda obsoleted by some of the 2.x new stuff, but still good for when
** using a front-end (instead of a plug-in)
*/

#define IPC_SETPLAYLISTPOS 121
/* (requires Winamp 2.0+)
** SendMessage(hwnd_winamp,WM_WA_IPC,position,IPC_SETPLAYLISTPOS)
** IPC_SETPLAYLISTPOS sets the playlist position to 'position'. It
** does not change playback or anything, it just sets position, and
** updates the view if necessary
*/

#define IPC_SETVOLUME 122
/* (requires Winamp 2.0+)
** SendMessage(hwnd_winamp,WM_WA_IPC,volume,IPC_SETVOLUME);
** IPC_SETVOLUME sets the volume of Winamp (from 0-255).
*/

#define IPC_SETPANNING 123
/* (requires Winamp 2.0+)
** SendMessage(hwnd_winamp,WM_WA_IPC,panning,IPC_SETPANNING);
** IPC_SETPANNING sets the panning of Winamp (from 0 (left) to 255 (right)).
*/

#define IPC_GETLISTLENGTH 124
/* (requires Winamp 2.0+)
** int length = SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETLISTLENGTH);
** IPC_GETLISTLENGTH returns the length of the current playlist, in
** tracks.
*/

#define IPC_GETLISTPOS 125
/* (requires Winamp 2.05+)
** int pos=SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETLISTPOS);
** IPC_GETLISTPOS returns the playlist position. A lot like IPC_WRITEPLAYLIST
** only faster since it doesn't have to write out the list. Heh, silly me.
*/

#define IPC_GETINFO 126
/* (requires Winamp 2.05+)
** int inf=SendMessage(hwnd_winamp,WM_WA_IPC,mode,IPC_GETINFO);
** IPC_GETINFO returns info about the current playing song. The value
** it returns depends on the value of 'mode'.
** Mode      Meaning
** ------------------
** 0         Samplerate (i.e. 44100)
** 1         Bitrate  (i.e. 128)
** 2         Channels (i.e. 2)
** 3 (5+)    Video LOWORD=w HIWORD=h
** 4 (5+)    > 65536, string (video description)
*/

#define IPC_GETEQDATA 127
/* (requires Winamp 2.05+)
** int data=SendMessage(hwnd_winamp,WM_WA_IPC,pos,IPC_GETEQDATA);
** IPC_GETEQDATA queries the status of the EQ. 
** The value returned depends on what 'pos' is set to:
** Value      Meaning
** ------------------
** 0-9        The 10 bands of EQ data. 0-63 (+20db - -20db)
** 10         The preamp value. 0-63 (+20db - -20db)
** 11         Enabled. zero if disabled, nonzero if enabled.
** 12         Autoload. zero if disabled, nonzero if enabled.
*/

#define IPC_SETEQDATA 128
/* (requires Winamp 2.05+)
** SendMessage(hwnd_winamp,WM_WA_IPC,pos,IPC_GETEQDATA);
** SendMessage(hwnd_winamp,WM_WA_IPC,value,IPC_SETEQDATA);
** IPC_SETEQDATA sets the value of the last position retrieved
** by IPC_GETEQDATA. This is pretty lame, and we should provide
** an extended version that lets you do a MAKELPARAM(pos,value).
** someday...
  new (2.92+): 
    if the high byte is set to 0xDB, then the third byte specifies
    which band, and the bottom word specifies the value.
*/
#define IPC_ADDBOOKMARK 129
/* (requires Winamp 2.4+)
** Sent as a WM_COPYDATA, using IPC_ADDBOOKMARK, adds the specified
** file/url to the Winamp bookmark list.
*/
/*
In winamp 5+, we use this as a normal WM_WA_IPC and the string:
  "filename\0title\0"
  to notify the library/bookmark editor that a bookmark
was added. Note that using this message in this context does not
actually add the bookmark.
do not use :)
*/

#define IPC_INSTALLPLUGIN 130
/* not implemented, but if it was you could do a WM_COPYDATA with 
** a path to a .wpz, and it would install it.
*/

#define IPC_RESTARTWINAMP 135
/* (requires Winamp 2.2+)
** SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_RESTARTWINAMP);
** IPC_RESTARTWINAMP will restart Winamp (isn't that obvious ? :)
*/

#define IPC_ISFULLSTOP 400
/* (requires winamp 2.7+ I think)
** ret=SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_ISFULLSTOP);
** useful for when you're an output plugin, and you want to see
** if the stop/close is a full stop, or just between tracks.
** returns nonzero if it's full, zero if it's just a new track.
*/

#define IPC_INETAVAILABLE 242
/* (requires Winamp 2.05+)
** val=SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_INETAVAILABLE);
** IPC_INETAVAILABLE will return 1 if the Internet connection is available for Winamp.
*/

#define IPC_UPDTITLE 243
/* (requires Winamp 2.2+)
** SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_UPDTITLE);
** IPC_UPDTITLE will ask Winamp to update the informations about the current title.
*/

#define IPC_REFRESHPLCACHE 247
/* (requires Winamp 2.2+)
** SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_REFRESHPLCACHE);
** IPC_REFRESHPLCACHE will flush the playlist cache buffer.
** (send this if you want it to go refetch titles for tracks)
*/

#define IPC_GET_SHUFFLE 250
/* (requires Winamp 2.4+)
** val=SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GET_SHUFFLE);
**
** IPC_GET_SHUFFLE returns the status of the Shuffle option (1 if set)
*/

#define IPC_GET_REPEAT 251
/* (requires Winamp 2.4+)
** val=SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GET_REPEAT);
**
** IPC_GET_REPEAT returns the status of the Repeat option (1 if set)
*/

#define IPC_SET_SHUFFLE 252
/* (requires Winamp 2.4+)
** SendMessage(hwnd_winamp,WM_WA_IPC,value,IPC_SET_SHUFFLE);
**
** IPC_SET_SHUFFLE sets the status of the Shuffle option (1 to turn it on)
*/

#define IPC_SET_REPEAT 253
/* (requires Winamp 2.4+)
** SendMessage(hwnd_winamp,WM_WA_IPC,value,IPC_SET_REPEAT);
**
** IPC_SET_REPEAT sets the status of the Repeat option (1 to turn it on)
*/

#define IPC_ENABLEDISABLE_ALL_WINDOWS 259 // 0xdeadbeef to disable
/* (requires Winamp 2.9+)
** SendMessage(hwnd_winamp,WM_WA_IPC,enable?0:0xdeadbeef,IPC_MBOPENREAL);
** sending with 0xdeadbeef as the param disables all winamp windows, 
** any other values will enable all winamp windows.
*/

#define IPC_GETWND 260
/* (requires Winamp 2.9+)
** HWND h=SendMessage(hwnd_winamp,WM_WA_IPC,IPC_GETWND_xxx,IPC_GETWND);
** returns the HWND of the window specified.
*/
  #define IPC_GETWND_EQ 0 // use one of these for the param
  #define IPC_GETWND_PE 1
  #define IPC_GETWND_MB 2
  #define IPC_GETWND_VIDEO 3
#define IPC_ISWNDVISIBLE 261 // same param as IPC_GETWND
 

/************************************************************************
***************** in-process only (WE LOVE PLUGINS)
************************************************************************/

#define IPC_SETSKIN 200
/* (requires Winamp 2.04+, only usable from plug-ins (not external apps))
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)"skinname",IPC_SETSKIN);
** IPC_SETSKIN sets the current skin to "skinname". Note that skinname 
** can be the name of a skin, a skin .zip file, with or without path. 
** If path isn't specified, the default search path is the winamp skins 
** directory.
*/

#define IPC_GETSKIN 201
/* (requires Winamp 2.04+, only usable from plug-ins (not external apps))
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)skinname_buffer,IPC_GETSKIN);
** IPC_GETSKIN puts the directory where skin bitmaps can be found 
** into  skinname_buffer.
** skinname_buffer must be MAX_PATH characters in length.
** When using a .zip'd skin file, it'll return a temporary directory
** where the ZIP was decompressed.
*/

#define IPC_EXECPLUG 202
/* (requires Winamp 2.04+, only usable from plug-ins (not external apps))
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)"vis_file.dll",IPC_EXECPLUG);
** IPC_EXECPLUG executes a visualization plug-in pointed to by WPARAM.
** the format of this string can be:
** "vis_whatever.dll"
** "vis_whatever.dll,0" // (first mod, file in winamp plug-in dir)
** "C:\\dir\\vis_whatever.dll,1" 
*/

#define IPC_GETPLAYLISTFILE 211
/* (requires Winamp 2.04+, only usable from plug-ins (not external apps))
** char *name=SendMessage(hwnd_winamp,WM_WA_IPC,index,IPC_GETPLAYLISTFILE);
** IPC_GETPLAYLISTFILE gets the filename of the playlist entry [index].
** returns a pointer to it. returns NULL on error.
*/

#define IPC_GETPLAYLISTTITLE 212
/* (requires Winamp 2.04+, only usable from plug-ins (not external apps))
** char *name=SendMessage(hwnd_winamp,WM_WA_IPC,index,IPC_GETPLAYLISTTITLE);
**
** IPC_GETPLAYLISTTITLE gets the title of the playlist entry [index].
** returns a pointer to it. returns NULL on error.
*/

#define IPC_GETHTTPGETTER 240
/* retrieves a function pointer to a HTTP retrieval function.
** if this is unsupported, returns 1 or 0.
** the function should be:
** int (*httpRetrieveFile)(HWND hwnd, char *url, char *file, char *dlgtitle);
** if you call this function, with a parent window, a URL, an output file, and a dialog title,
** it will return 0 on successful download, 1 on error.
*/

#define IPC_MBOPEN 241
/* (requires Winamp 2.05+)
** SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_MBOPEN);
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)url,IPC_MBOPEN);
** IPC_MBOPEN will open a new URL in the minibrowser. if url is NULL, it will open the Minibrowser window.
*/
 
#define IPC_CHANGECURRENTFILE 245
/* (requires Winamp 2.05+)
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)file,IPC_CHANGECURRENTFILE);
** IPC_CHANGECURRENTFILE will set the current playlist item.
*/

#define IPC_GETMBURL 246
/* (requires Winamp 2.2+)
** char buffer[4096]; // Urls can be VERY long
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)buffer,IPC_GETMBURL);
** IPC_GETMBURL will retrieve the current Minibrowser URL into buffer.
** buffer must be at least 4096 bytes long.
*/

#define IPC_MBBLOCK 248
/* (requires Winamp 2.4+)
** SendMessage(hwnd_winamp,WM_WA_IPC,value,IPC_MBBLOCK);
**
** IPC_MBBLOCK will block the Minibrowser from updates if value is set to 1
*/
#define IPC_MBOPENREAL 249
/* (requires Winamp 2.4+)
** SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)url,IPC_MBOPENREAL);
**
** IPC_MBOPENREAL works the same as IPC_MBOPEN except that it will works even if 
** IPC_MBBLOCK has been set to 1
*/
#define IPC_ADJUST_OPTIONSMENUPOS 280
/* (requires Winamp 2.9+)
** int newpos=SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)adjust_offset,IPC_ADJUST_OPTIONSMENUPOS);
** moves where winamp expects the Options menu in the main menu. Useful if you wish to insert a
** menu item above the options/skins/vis menus.
*/
#define IPC_GET_HMENU 281
/* (requires Winamp 2.9+)
** HMENU hMenu=SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)0,IPC_GET_HMENU);
** values for data:
** 0 : main popup menu 
** 1 : main menubar file menu
** 2 : main menubar options menu
** 3 : main menubar windows menu
** 4 : main menubar help menu
** other values will return NULL.
*/
#define IPC_GET_EXTENDED_FILE_INFO 290 //pass a pointer to the following struct in wParam
#define IPC_GET_EXTENDED_FILE_INFO_HOOKABLE 296
/* (requires Winamp 2.9+)
** to use, create an extendedFileInfoStruct, point the values filename and metadata to the
** filename and metadata field you wish to query, and ret to a buffer, with retlen to the
** length of that buffer, and then SendMessage(hwnd_winamp,WM_WA_IPC,&struct,IPC_GET_EXTENDED_FILE_INFO);
** the results should be in the buffer pointed to by ret.
** returns 1 if the decoder supports a getExtendedFileInfo method
*/
typedef struct {
  char *filename;
  char *metadata;
  char *ret;
  int retlen;
} extendedFileInfoStruct;
#define IPC_GET_BASIC_FILE_INFO 291 //pass a pointer to the following struct in wParam
typedef struct {
  char *filename;
  int quickCheck; // set to 0 to always get, 1 for quick, 2 for default (if 2, quickCheck will be set to 0 if quick wasnot used)
  // filled in by winamp
  int length;
  char *title;
  int titlelen;
} basicFileInfoStruct;
#define IPC_GET_EXTLIST 292 //returns doublenull delimited. GlobalFree() it when done. if data is 0, returns raw extlist, if 1, returns something suitable for getopenfilename
#define IPC_INFOBOX 293
typedef struct {
  HWND parent;
  char *filename;
} infoBoxParam;
#define IPC_SET_EXTENDED_FILE_INFO 294 //pass a pointer to the a extendedFileInfoStruct in wParam
/* (requires Winamp 2.9+)
** to use, create an extendedFileInfoStruct, point the values filename and metadata to the
** filename and metadata field you wish to write in ret. (retlen is not used). and then 
** SendMessage(hwnd_winamp,WM_WA_IPC,&struct,IPC_SET_EXTENDED_FILE_INFO);
** returns 1 if the metadata is supported
** Call IPC_WRITE_EXTENDED_FILE_INFO once you're done setting all the metadata you want to update
*/
#define IPC_WRITE_EXTENDED_FILE_INFO 295 
/* (requires Winamp 2.9+)
** writes all the metadata set thru IPC_SET_EXTENDED_FILE_INFO to the file
** returns 1 if the file has been successfully updated, 0 if error
*/
#define IPC_FORMAT_TITLE 297
typedef struct 
{
  char *spec; // NULL=default winamp spec
  void *p;
  char *out;
  int out_len;
  char * (*TAGFUNC)(char * tag, void * p); //return 0 if not found
  void (*TAGFREEFUNC)(char * tag,void * p);
} waFormatTitle;
#define IPC_GETUNCOMPRESSINTERFACE 331
/* returns a function pointer to uncompress().
** int (*uncompress)(unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long sourceLen);
** right out of zlib, useful for decompressing zlibbed data.
** if you pass the parm of 0x10100000, it will return a wa_inflate_struct * to an inflate API.
*/
typedef struct {
  int (*inflateReset)(void *strm);
  int (*inflateInit_)(void *strm,const char *version, int stream_size);
  int (*inflate)(void *strm, int flush);
  int (*inflateEnd)(void *strm);
  unsigned long (*crc32)(unsigned long crc, const unsigned  char *buf, unsigned int len);
} wa_inflate_struct;

#define IPC_ADD_PREFS_DLG 332
#define IPC_REMOVE_PREFS_DLG 333
/* (requires Winamp 2.9+)
** to use, allocate a prefsDlgRec structure (either on the heap or some global
** data, but NOT on the stack), initialze the members:
** hInst to the DLL instance where the resource is located
** dlgID to the ID of the dialog,
** proc to the window procedure for the dialog
** name to the name of the prefs page in the prefs.
** where to 0 (eventually we may add more options)
** then, SendMessage(hwnd_winamp,WM_WA_IPC,&prefsRec,IPC_ADD_PREFS_DLG);
**
** you can also IPC_REMOVE_PREFS_DLG with the address of the same prefsRec,
** but you shouldn't really ever have to.
**
*/
#define IPC_OPENPREFSTOPAGE 380 // pass an id of a builtin page, or a &prefsDlgRec of prefs page to open
typedef struct _prefsDlgRec {
  HINSTANCE hInst;
  int dlgID;
  void *proc;
  char *name;
  int where; // 0 for options, 1 for plugins, 2 for skins, 3 for bookmarks, 4 for prefs

  int _id;
  struct _prefsDlgRec *next;
} prefsDlgRec;

#define IPC_GETINIFILE 334 // returns a pointer to winamp.ini
#define IPC_GETINIDIRECTORY 335 // returns a pointer to the directory to put config files in (if you dont want to use winamp.ini)
#define IPC_SPAWNBUTTONPOPUP 361 // param =
// 0 = eject
// 1 = previous
// 2 = next
// 3 = pause
// 4 = play
// 5 = stop
#define IPC_OPENURLBOX 360 // pass a HWND to a parent, returns a HGLOBAL that needs to be freed with GlobalFree(), if successful
#define IPC_OPENFILEBOX 362 // pass a HWND to a parent
#define IPC_OPENDIRBOX 363 // pass a HWND to a parent
// pass an HWND to a parent. call this if you take over the whole UI so that the dialogs are not appearing on the
// bottom right of the screen since the main winamp window is at 3000x3000, call again with NULL to reset
#define IPC_SETDIALOGBOXPARENT 364 
 
// pass 0 for a copy of the skin HBITMAP
// pass 1 for name of font to use for playlist editor likeness
// pass 2 for font charset
// pass 3 for font size
#define IPC_GET_GENSKINBITMAP 503

#define IPC_GET_EMBEDIF 505 // pass an embedWindowState
// returns an HWND embedWindow(embedWindowState *); if the data is NULL, otherwise returns the HWND directly
typedef struct
{
  HWND me; //hwnd of the window
  int flags;
  RECT r;
  void *user_ptr; // for application use
  int extra_data[64]; // for internal winamp use
} embedWindowState;
#define EMBED_FLAGS_NORESIZE 1 // set this bit in embedWindowState.flags to keep window from being resizable
#define EMBED_FLAGS_NOTRANSPARENCY 2 // set this bit in embedWindowState.flags to make gen_ff turn transparency off for this wnd

#define IPC_EMBED_ENUM 532
typedef struct embedEnumStruct
{
  int (*enumProc)(embedWindowState *ws, struct embedEnumStruct *param); // return 1 to abort
  int user_data; // or more :)
} embedEnumStruct;
  // pass 
#define IPC_EMBED_ISVALID 533
#define IPC_CONVERTFILE 506
/* (requires Winamp 2.92+)
** Converts a given file to a different format (PCM, MP3, etc...)
** To use, pass a pointer to a waFileConvertStruct struct
** This struct can be either on the heap or some global
** data, but NOT on the stack. At least, until the conversion is done.
**
** eg: SendMessage(hwnd_winamp,WM_WA_IPC,&myConvertStruct,IPC_CONVERTFILE);
**
** Return value:
** 0: Can't start the conversion. Look at myConvertStruct->error for details.
** 1: Conversion started. Status messages will be sent to the specified callbackhwnd.
**    Be sure to call IPC_CONVERTFILE_END when your callback window receives the
**    IPC_CB_CONVERT_DONE message.
*/
typedef struct 
{
  char *sourcefile;  // "c:\\source.mp3"
  char *destfile;    // "c:\\dest.pcm"
  int destformat[8]; // like 'PCM ',srate,nch,bps
  HWND callbackhwnd; // window that will receive the IPC_CB_CONVERT notification messages
  
  //filled in by winamp.exe
  char *error;        //if IPC_CONVERTFILE returns 0, the reason will be here
  int bytes_done;     //you can look at both of these values for speed statistics
  int bytes_total;
  int bytes_out;
  int killswitch;     // don't set it manually, use IPC_CONVERTFILE_END
  int extra_data[64]; // for internal winamp use
} convertFileStruct;
#define IPC_CONVERTFILE_END 507
/* (requires Winamp 2.92+)
** Stop/ends a convert process started from IPC_CONVERTFILE
** You need to call this when you receive the IPC_CB_CONVERTDONE message or when you
** want to abort a conversion process
**
** eg: SendMessage(hwnd_winamp,WM_WA_IPC,&myConvertStruct,IPC_CONVERTFILE_END);
**
** No return value
*/
typedef struct {
  HWND hwndParent;
  int format;
  //filled in by winamp.exe
  HWND hwndConfig;
  int extra_data[8];
} convertConfigStruct;
#define IPC_CONVERT_CONFIG 508
#define IPC_CONVERT_CONFIG_END 509
typedef struct
{
  void (*enumProc)(int user_data, const char *desc, int fourcc);
  int user_data;
} converterEnumFmtStruct;
#define IPC_CONVERT_CONFIG_ENUMFMTS 510
/* (requires Winamp 2.92+)
*/

typedef struct
{
  char cdletter;
  char *playlist_file;
  HWND callback_hwnd;
  //filled in by winamp.exe
  char *error;
} burnCDStruct;
#define IPC_BURN_CD 511
/* (requires Winamp 5.0+)
*/
typedef struct
{
  convertFileStruct *cfs;
  int priority;
} convertSetPriority;
#define IPC_CONVERT_SET_PRIORITY 512
typedef struct
{
  char *filename;
  char *title; // 2048 bytes
  int length;
  int force_useformatting; // can set this to 1 if you want to force a url to use title formatting shit
} waHookTitleStruct;
// return TRUE if you hook this
#define IPC_HOOK_TITLES 850
#define IPC_GETSADATAFUNC 800 
// 0: returns a char *export_sa_get() that returns 150 bytes of data
// 1: returns a export_sa_setreq(int want);
#define IPC_ISMAINWNDVISIBLE 900

#define IPC_SETPLEDITCOLORS 920
typedef struct
{
  int numElems;
  int *elems;
  HBITMAP bm; // set if you want to override
} waSetPlColorsStruct;

// the following IPC use waSpawnMenuParms as parameter
#define IPC_SPAWNEQPRESETMENU 933
#define IPC_SPAWN******NU 934 //menubar
#define IPC_SPAWNOPTIONSMENU 935 //menubar
#define IPC_SPAWNWINDOWSMENU 936 //menubar
#define IPC_SPAWNHELPMENU 937 //menubar
#define IPC_SPAWNPLAYMENU 938 //menubar
#define IPC_SPAWNPE******NU 939 //menubar
#define IPC_SPAWNPEPLAYLISTMENU 940 //menubar
#define IPC_SPAWNPESORTMENU 941 //menubar
#define IPC_SPAWNPEHELPMENU 942 //menubar
#define IPC_SPAWNML******NU 943 //menubar
#define IPC_SPAWNMLVIEWMENU 944 //menubar
#define IPC_SPAWNMLHELPMENU 945 //menubar
#define IPC_SPAWNPELISTOFPLAYLISTS 946
typedef struct
{
  HWND wnd;
  int xpos; // in screen coordinates
  int ypos;
} waSpawnMenuParms;
// waSpawnMenuParms2 is used by the menubar submenus
typedef struct
{
  HWND wnd;
  int xpos; // in screen coordinates
  int ypos;
  int width;
  int height;
} waSpawnMenuParms2;

// system tray sends this (you might want to simulate it)
#define WM_WA_SYSTRAY WM_USER+1
// input plugins send this when they are done playing back
#define WM_WA_MPEG_EOF WM_USER+2
 
//// video stuff
#define IPC_IS_PLAYING_VIDEO 501 // returns >1 if playing, 0 if not, 1 if old version (so who knows):)
#define IPC_GET_IVIDEOOUTPUT 500 // see below for IVideoOutput interface
#define VIDEO_MAKETYPE(A,B,C,D) ((A) | ((B)<<8) | ((C)<<16) | ((D)<<24))
#define VIDUSER_SET_INFOSTRING 0x1000
#define VIDUSER_GET_VIDEOHWND  0x1001
#define VIDUSER_SET_VFLIP      0x1002
#ifndef NO_IVIDEO_DECLARE
#ifdef __cplusplus
class VideoOutput;
class SubsItem;
typedef struct {
 unsigned char* baseAddr;
 long   rowBytes;
} YV12_PLANE;
typedef struct {
 YV12_PLANE y;
 YV12_PLANE u;
 YV12_PLANE v;
} YV12_PLANES;
class IVideoOutput
{
  public:
    virtual ~IVideoOutput() { }
    virtual int open(int w, int h, int vflip, double aspectratio, unsigned int fmt)=0;
    virtual void setcallback(LRESULT (*msgcallback)(void *token, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam), void *token) { }
    virtual void close()=0;
    virtual void draw(void *frame)=0;
    virtual void drawSubtitle(SubsItem *item) { }
    virtual void showStatusMsg(const char *text) { }
    virtual int get_latency() { return 0; }
    virtual void notifyBufferState(int bufferstate) { } /* 0-255*/
    virtual int extended(int param1, int param2, int param3) { return 0; } // Dispatchable, eat this!
};
#endif //cplusplus
#endif//NO_IVIDEO_DECLARE
// these messages are callbacks that you can grab by subclassing the winamp window
// wParam = 
#define IPC_CB_WND_EQ 0 // use one of these for the param
#define IPC_CB_WND_PE 1
#define IPC_CB_WND_MB 2
#define IPC_CB_WND_VIDEO 3
#define IPC_CB_WND_MAIN 4
#define IPC_CB_ONSHOWWND 600 
#define IPC_CB_ONHIDEWND 601 
#define IPC_CB_GETTOOLTIP 602
#define IPC_CB_MISC 603
    #define IPC_CB_MISC_TITLE 0
    #define IPC_CB_MISC_VOLUME 1 // volume/pan
    #define IPC_CB_MISC_STATUS 2
    #define IPC_CB_MISC_EQ 3
    #define IPC_CB_MISC_INFO 4
    #define IPC_CB_MISC_VIDEOINFO 5
#define IPC_CB_CONVERT_STATUS 604 // param value goes from 0 to 100 (percent)
#define IPC_CB_CONVERT_DONE   605
#define IPC_ADJUST_FFWINDOWSMENUPOS 606
/* (requires Winamp 2.9+)
** int newpos=SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)adjust_offset,IPC_ADJUST_FFWINDOWSMENUPOS);
** moves where winamp expects the freeform windows in the menubar windows main menu. Useful if you wish to insert a
** menu item above extra freeform windows.
*/
#define IPC_ISDOUBLESIZE 608
#define IPC_ADJUST_FFOPTIONSMENUPOS 609
/* (requires Winamp 2.9+)
** int newpos=SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)adjust_offset,IPC_ADJUST_FFOPTIONSMENUPOS);
** moves where winamp expects the freeform preferences item in the menubar windows main menu. Useful if you wish to insert a
** menu item above preferences item.
*/
#define IPC_GETTIMEDISPLAYMODE 610 // returns 0 if displaying elapsed time or 1 if displaying remaining time
#define IPC_SETVISWND 611 // param is hwnd, setting this allows you to receive ID_VIS_NEXT/PREVOUS/RANDOM/FS wm_commands
#define ID_VIS_NEXT                     40382
#define ID_VIS_PREV                     40383
#define ID_VIS_RANDOM                   40384
#define ID_VIS_FS                       40389
#define ID_VIS_CFG                      40390
#define ID_VIS_MENU                     40391
#define IPC_GETVISWND 612 // returns the vis cmd handler hwnd
#define IPC_ISVISRUNNING 613
#define IPC_CB_VISRANDOM 628 // param is status of random
#define IPC_SETIDEALVIDEOSIZE 614 // sent by winamp to winamp, trap it if you need it. width=HIWORD(param), height=LOWORD(param)
#define IPC_GETSTOPONVIDEOCLOSE 615
#define IPC_SETSTOPONVIDEOCLOSE 616
typedef struct {
  HWND hwnd;
  int uMsg;
  int wParam;
  int lParam;
} transAccelStruct;
#define IPC_TRANSLATEACCELERATOR 617
typedef struct {
  int cmd;
  int x;
  int y;
  int align;
} windowCommand; // send this as param to an IPC_PLCMD, IPC_MBCMD, IPC_VIDCMD
#define IPC_CB_ONTOGGLEAOT 618 
#define IPC_GETPREFSWND 619
#define IPC_SET_PE_WIDTHHEIGHT 620 // data is a pointer to a POINT structure that holds width & height
#define IPC_GETLANGUAGEPACKINSTANCE 621
#define IPC_CB_PEINFOTEXT 622 // data is a string, ie: "04:21/45:02"
#define IPC_CB_OUTPUTCHANGED 623 // output plugin was changed in config
#define IPC_GETOUTPUTPLUGIN 625
#define IPC_SETDRAWBORDERS 626
#define IPC_DISABLESKINCURSORS 627
#define IPC_CB_RESETFONT 629
#define IPC_IS_FULLSCREEN 630 // returns 1 if video or vis is in fullscreen mode
#define IPC_SET_VIS_FS_FLAG 631 // a vis should send this message with 1/as param to notify winamp that it has gone to or has come back from fullscreen mode
#define IPC_SHOW_NOTIFICATION 632
#define IPC_GETSKININFO 633
// >>>>>>>>>>> Next is 634
#define IPC_PLCMD  1000 
#define PLCMD_ADD  0
#define PLCMD_REM  1
#define PLCMD_SEL  2
#define PLCMD_MISC 3
#define PLCMD_LIST 4
#define IPC_MBCMD  1001 
#define MBCMD_BACK    0
#define MBCMD_FORWARD 1
#define MBCMD_STOP    2
#define MBCMD_RELOAD  3
#define MBCMD_MISC  4
#define IPC_VIDCMD 1002 
#define VIDCMD_FULLSCREEN 0
#define VIDCMD_1X         1
#define VIDCMD_2X         2
#define VIDCMD_LIB        3
#define VIDPOPUP_MISC     4
#define IPC_MBURL       1003 //sets the URL
#define IPC_MBGETCURURL 1004 //copies the current URL into wParam (have a 4096 buffer ready)
#define IPC_MBGETDESC   1005 //copies the current URL description into wParam (have a 4096 buffer ready)
#define IPC_MBCHECKLOCFILE 1006 //checks that the link file is up to date (otherwise updates it). wParam=parent HWND
#define IPC_MBREFRESH   1007 //refreshes the "now playing" view in the library
#define IPC_MBGETDEFURL 1008 //copies the default URL into wParam (have a 4096 buffer ready)
#define IPC_STATS_LIBRARY_ITEMCNT 1300 // updates library count status
// IPC 2000-3000 reserved for freeform messages, see gen_ff/ff_ipc.h
#define IPC_FF_FIRST 2000
#define IPC_FF_LAST  3000
#define IPC_GETDROPTARGET 3001
#define IPC_PLAYLIST_MODIFIED 3002 // sent to main wnd whenever the playlist is modified
#define IPC_PLAYING_FILE 3003 // sent to main wnd with the file as parm whenever a file is played
#define IPC_FILE_TAG_MAY_HAVE_UPDATED 3004 // sent to main wnd with the file as parm whenever a file tag might be updated

#define IPC_ALLOW_PLAYTRACKING 3007
// send nonzero to allow, zero to disallow
#define IPC_HOOK_OKTOQUIT 3010 // return 0 to abort a quit, nonzero if quit is OK
#define IPC_WRITECONFIG 3011 // pass 2 to write all, 1 to write playlist + common, 0 to write common+less common
// pass a string to be the name to register, and returns a value > 65536, which is a unique value you can use
// for custom WM_WA_IPC messages. 
#define IPC_REGISTER_WINAMP_IPCMESSAGE 65536 
/**************************************************************************/
/*
** Finally there are some WM_COMMAND messages that you can use to send 
** Winamp misc commands.
** 
** To send these, use:
**
** SendMessage(hwnd_winamp, WM_COMMAND,command_name,0);
*/
#define WINAMP_OPTIONS_EQ               40036 // toggles the EQ window
#define WINAMP_OPTIONS_PLEDIT           40040 // toggles the playlist window
#define WINAMP_VOLUMEUP                 40058 // turns the volume up a little
#define WINAMP_VOLUMEDOWN               40059 // turns the volume down a little
#define WINAMP_FFWD5S                   40060 // fast forwards 5 seconds
#define WINAMP_REW5S                    40061 // rewinds 5 seconds
// the following are the five main control buttons, with optionally shift 
// or control pressed
// (for the exact functions of each, just try it out)
#define WINAMP_BUTTON1                  40044
#define WINAMP_BUTTON2                  40045
#define WINAMP_BUTTON3                  40046
#define WINAMP_BUTTON4                  40047
#define WINAMP_BUTTON5                  40048
#define WINAMP_BUTTON1_SHIFT            40144
#define WINAMP_BUTTON2_SHIFT            40145
#define WINAMP_BUTTON3_SHIFT            40146
#define WINAMP_BUTTON4_SHIFT            40147
#define WINAMP_BUTTON5_SHIFT            40148
#define WINAMP_BUTTON1_CTRL             40154
#define WINAMP_BUTTON2_CTRL             40155
#define WINAMP_BUTTON3_CTRL             40156
#define WINAMP_BUTTON4_CTRL             40157
#define WINAMP_BUTTON5_CTRL             40158
#define WINAMP_FILE_PLAY                40029 // pops up the load file(s) box
#define WINAMP_FILE_DIR                 40187 // pops up the load directory box
#define WINAMP_OPTIONS_PREFS            40012 // pops up the preferences
#define WINAMP_OPTIONS_AOT              40019 // toggles always on top
#define WINAMP_HELP_ABOUT               40041 // pops up the about box :)
#define ID_MAIN_PLAY_AUDIOCD1           40323 // starts playing the audio CD in the first CD reader
#define ID_MAIN_PLAY_AUDIOCD2           40323 // plays the 2nd
#define ID_MAIN_PLAY_AUDIOCD3           40323 // plays the 3nd
#define ID_MAIN_PLAY_AUDIOCD4           40323 // plays the 4nd
// IDs 42000 to 45000 are reserved for gen_ff
// IDs from 45000 to 57000 are reserved for library 
#endif//_WA_IPC_H_
/*
** EOF.. Enjoy.
*/