Initial

winmus/FILEHELP.CPP

@@ -0,0 +1,359 @@
+#include <dos.h>
+#include <io.h>
+#include <dir.h>
+#include <string.h>
+#include <common/string.hpp>
+#include <winmus/main.hpp>
+#include <winmus/mididef.hpp>
+#include <winmus/filehelp.hpp>
+
+SelectFile::SelectFile(Window &parentWindow,Mode readWrite)
+: mwFileAttribute((WORD)DefaultAttribute), mhParent(parentWindow),
+  mMode(readWrite), mhInstance(parentWindow.processInstance()),
+  mCommandHandler(this,&SelectFile::commandHandler),
+  mInitDialogHandler(this,&SelectFile::initDialogHandler),
+	mDrawItemHandler(this,&SelectFile::drawItemHandler),
+	mOwnerDraw(OwnerDraw::UseInstance), mhGrayBrush(::CreateSolidBrush(RGB(btnRed,btnGreen,btnBlue)))
+{
+  insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+  insertHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+	insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
+	  mszFileName[0]='\0';
+  ::strcpy(mszDefExt,".DAT");
+  ::strcpy(mszFileSpec,"*.*");
+  mLastDrive=::getdisk();
+  ::getcwd(mszDirectory,sizeof(mszDirectory));
+}
+
+SelectFile::~SelectFile()
+{
+	char Path[132];
+
+  if(mhGrayBrush)::DeleteObject(mhGrayBrush);
+	::wsprintf(Path,"%c:\\",mLastDrive+65);
+  ::setdisk(mLastDrive);
+  ::strcat(Path,mszDirectory);
+	::chdir(Path);
+  removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+  removeHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+	removeHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
+}
+
+int SelectFile::GetFileName(char *szNameBuf,WORD nMaxChars)
+{
+	WORD returnCode;
+
+	returnCode=::DialogBoxParam(mhInstance,(LPSTR)"FileSelect",mhParent,(DLGPROC)DWindow::DialogProcedure,(LONG)((DWindow*)this));
+	if(returnCode)
+		::strncpy(szNameBuf,mszFileName,nMaxChars>sizeof(mszFileName)?sizeof(mszFileName):nMaxChars);
+	return returnCode;
+}
+
+void SelectFile::Initialize()
+{
+  ::SendDlgItemMessage((HWND)*this,IDS_FNAME,EM_LIMITTEXT,80,0L);
+	::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,FALSE,0L);
+  waitCursor(TRUE);
+	::DlgDirList((HWND)*this,mszFileSpec,IDS_FLIST,IDS_FPATH,mwFileAttribute);
+  waitCursor(FALSE);
+	SetExtended();
+  ::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,TRUE,0L);
+  ::SendMessage(GetDlgItem((HWND)*this,IDS_FLIST),LB_GETTEXT,0,(LONG)mszFileName);
+	::SendDlgItemMessage((HWND)*this,IDS_FLIST,LB_SETCURSEL,0,0L);
+#if defined(__FLAT__)
+	if(DlgDirSelectExA((HWND)*this,mszFileName,sizeof(mszFileName),IDS_FLIST))
+#else
+	if(DlgDirSelect((HWND)*this,mszFileName,IDS_FLIST))
+#endif
+	::lstrcat(mszFileName,mszFileSpec);
+	::SetDlgItemText((HWND)*this,IDS_FNAME,mszFileName);
+}
+
+void SelectFile::SelChange()
+{
+#if defined(__FLAT__)
+	if(DlgDirSelectExA((HWND)*this,mszFileName,sizeof(mszFileName),IDS_FLIST))
+#else
+	if(DlgDirSelect((HWND)*this,mszFileName,IDS_FLIST))
+#endif
+	::lstrcat(mszFileName,mszFileSpec);
+	::SetDlgItemText((HWND)*this,IDS_FNAME,mszFileName);
+}
+
+void SelectFile::DoubleClick()
+{
+	waitCursor(TRUE);
+#if defined(__FLAT__)
+	if(DlgDirSelectExA((HWND)*this,mszFileName,sizeof(mszFileName),IDS_FLIST))
+#else
+	if(DlgDirSelect((HWND)*this,mszFileName,IDS_FLIST))
+#endif
+  {
+    ::lstrcat(mszFileName,mszFileSpec);
+    ::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,FALSE,0L);
+	  ::DlgDirList((HWND)*this,mszFileName,IDS_FLIST,IDS_FPATH,mwFileAttribute);
+	  SetExtended();
+	  ::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,TRUE,0L);
+		::SetDlgItemText((HWND)*this,IDS_FNAME,mszFileSpec);
+  }
+  else
+  {
+    ::SetDlgItemText((HWND)*this,IDS_FNAME,mszFileName);
+		::SendMessage((HWND)*this,WM_COMMAND,IDOK,0L);
+	}
+	waitCursor(FALSE);
+}
+
+int SelectFile::CheckFileNameSpec()
+{
+  ::GetDlgItemText((HWND)*this,IDS_FNAME,mszFileName,sizeof(mszFileName));
+  mnEditLen=::lstrlen(mszFileName);
+	mcLastChar=*::AnsiPrev(mszFileName,mszFileName+mnEditLen);
+	if(mcLastChar=='\\'||mcLastChar==':')::lstrcat(mszFileName,mszFileSpec);
+	if(lstrchr(mszFileName,'*')||lstrchr(mszFileName,'?'))
+	{
+		::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,FALSE,0L);
+		waitCursor(TRUE);
+		if(::DlgDirList((HWND)*this,mszFileName,IDS_FLIST,IDS_FPATH,mwFileAttribute))
+    {
+	    SetExtended();
+	    ::strcpy(mszFileSpec,mszFileName);
+			::SetDlgItemText((HWND)*this,IDS_FNAME,mszFileSpec);
+    }
+		else ::MessageBeep(0);
+    waitCursor(FALSE);
+	  ::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,TRUE,0L);
+		return FALSE;
+  }
+  ::lstrcat(lstrcat(mszFileName,"\\"),mszFileSpec);
+	::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,FALSE,0L);
+	waitCursor(TRUE);
+	if(::DlgDirList((HWND)*this,mszFileName,IDS_FLIST,IDS_FPATH,mwFileAttribute))
+	{
+		waitCursor(FALSE);
+		SetExtended();
+		::strcpy(mszFileSpec,mszFileName);
+    ::SetDlgItemText((HWND)*this,IDS_FNAME,mszFileSpec);
+		return FALSE;
+	}
+	waitCursor(FALSE);
+	::SendDlgItemMessage((HWND)*this,IDS_FLIST,WM_SETREDRAW,TRUE,0L);
+  mszFileName[mnEditLen]='\0';
+	if(-1==(mfd=::OpenFile(mszFileName,&mPof,OF_SHARE_COMPAT|OF_EXIST)))
+	{
+		if(Write==mMode)
+		{
+			if(-1==(mfd=::OpenFile(mszFileName,&mPof,OF_WRITE|OF_CREATE)))
+			{
+				::MessageBeep(0);
+				return FALSE;
+			}
+			::_lclose(mfd);
+			::unlink(mszFileName);
+			return TRUE;
+		}
+		::lstrcat(mszFileName,mszDefExt);
+		if(-1==(mfd=::OpenFile(mszFileName,&mPof,OF_SHARE_COMPAT|OF_EXIST)))
+		{
+			::MessageBeep(0);
+			return FALSE;
+		}
+		else ::_lclose(mfd);
+  }
+	else ::_lclose(mfd);
+	::strcpy(mszFileName,mPof.szPathName);
+	::OemToAnsi(mszFileName,mszFileName);
+	if(Write==mMode)
+	{
+		::MessageBeep(0);
+		switch(
+		::MessageBox((HWND)*this,(LPSTR)"Overwrite this file?",(LPSTR)mszFileName,MB_OKCANCEL))
+		{
+			case IDOK :
+				return TRUE;
+			case IDCANCEL :
+        return FALSE;
+		}
+	}
+	return TRUE;
+}
+
+LPSTR SelectFile::lstrchr(LPSTR str,char ch)
+{
+  while(*str)
+  {
+    if(ch==*str)return str;
+    str=::AnsiNext(str);
+  }
+	return NULL;
+}
+
+LPSTR SelectFile::lstrrchr(LPSTR str,char ch)
+{
+	LPSTR strl=str+lstrlen(str);
+
+  do
+  {
+    if(ch==*strl)return strl;
+		strl=::AnsiPrev(str,strl);
+  }while(strl>str);
+  return NULL;
+}
+
+void SelectFile::SetExtended()
+{
+  HCURSOR hCursor;
+  ffblk mffblk;
+  char szBuffer[100];
+  char szFormat[100];
+  char minBuf[5];
+  char hrBuf[5];
+  char moBuf[5];
+  char dayBuf[5];
+	unsigned Year;
+	unsigned Month;
+	unsigned Day;
+	unsigned Hour;
+	unsigned Minute;
+	char cAmPm;
+
+	int nItems=(int)::SendDlgItemMessage((HWND)*this,IDS_FLIST,LB_GETCOUNT,0,0L);
+	if(!nItems)return;
+	hCursor=::SetCursor(::LoadCursor(NULL,IDC_WAIT));
+  ::ShowCursor(TRUE);
+  for(int nIndex=0;nIndex<nItems;nIndex++)
+  {
+	  ::SendDlgItemMessage((HWND)*this,IDS_FLIST,LB_GETTEXT,nIndex,(LPARAM)(LPCSTR)szBuffer);
+	  if(!::findfirst(szBuffer,&mffblk,FA_ARCH))
+	  {
+	    Year=(mffblk.ff_fdate>>9)+1980;
+	    Month=(mffblk.ff_fdate>>5)&0x0F;
+	    Day=mffblk.ff_fdate&0x1F;
+	    Hour=(mffblk.ff_ftime>>11)&0x1F;
+		  Minute=(mffblk.ff_ftime>>5)&0x3F;
+	    if(Hour>=12 && Minute)
+	    {
+		    Hour=Hour==12?1:Hour-12;
+		    if(Hour==12)cAmPm='a';
+			    else cAmPm='p';
+	    }
+	    else
+	    {
+	      if(!Hour)Hour=12;
+	      cAmPm='a';
+		  }
+		  ::wsprintf(minBuf,"%d",Minute);
+	    if(1==::lstrlen(minBuf))
+	    {
+		    minBuf[2]='\0';
+				minBuf[1]=minBuf[0];
+		    minBuf[0]='0';
+	    }
+	    ::wsprintf(hrBuf,"%d",Hour);
+			if(1==::lstrlen(hrBuf))
+	    {
+	      hrBuf[3]='\0';
+	      hrBuf[2]=hrBuf[0];
+		    hrBuf[1]=' ';
+		    hrBuf[0]=' ';
+	    }
+	    ::wsprintf(moBuf,"%d",Month);
+			if(1==::lstrlen(moBuf))
+	    {
+		    moBuf[2]='\0';
+		    moBuf[1]=moBuf[0];
+	      moBuf[0]='0';
+	    }
+			::wsprintf(dayBuf,"%d",Day);
+	    if(1==::lstrlen(dayBuf))
+	    {
+				dayBuf[2]='\0';
+		    dayBuf[1]=dayBuf[0];
+		    dayBuf[0]='0';
+      }
+			::wsprintf(szFormat,"\t%s-%s-%d\t%9ld\t%s:%s%c",
+	     (LPSTR)moBuf,(LPSTR)dayBuf,Year,mffblk.ff_fsize,(LPSTR)hrBuf,(LPSTR)minBuf,cAmPm);
+	    ::lstrcat(szBuffer,szFormat);
+	    ::SendDlgItemMessage((HWND)*this,IDS_FLIST,LB_DELETESTRING,nIndex,0L);
+			::SendDlgItemMessage((HWND)*this,IDS_FLIST,LB_INSERTSTRING,nIndex,(LPARAM)(LPCSTR)szBuffer);
+		}
+  }
+  ::ShowCursor(FALSE);
+	::SetCursor(hCursor);
+}
+
+CallbackData::ReturnType SelectFile::initDialogHandler(CallbackData &/*someCallbackData*/)
+{
+  int TabStopList[3];
+  WORD DlgWidthUnits;
+  String windowText;
+
+  DlgWidthUnits=LOWORD(::GetDialogBaseUnits())/4;
+  mOwnerDraw.associate(IDOK,
+	 String(STRING_BITMAPOKFOCUSUP),
+	 String(STRING_BITMAPOKNOFUP),
+	 String(STRING_BITMAPOKFOCUSDN),OwnerDraw::NOFOCUS);
+  mOwnerDraw.associate(IDCANCEL,
+	 String(STRING_BITMAPCAFOCUSUP),
+	 String(STRING_BITMAPCANOFUP),
+	 String(STRING_BITMAPCAFOCUSDN),OwnerDraw::NOFOCUS);
+  Initialize();
+  TabStopList[0]=DlgWidthUnits*13*2;
+  TabStopList[1]=DlgWidthUnits*28*2;
+  TabStopList[2]=DlgWidthUnits*38*2;
+  ::SendDlgItemMessage((HWND)*this,IDS_FLIST,LB_SETTABSTOPS,3,(LONG)(LPSTR)TabStopList);
+  ::GetDlgItemText((HWND)*this,(Write==mMode?IDS_FILESAVE:IDS_FILEOPEN),windowText,String::MaxString);
+  ::SetWindowText((HWND)*this,windowText);
+  return (CallbackData::ReturnType)TRUE;
+}
+
+CallbackData::ReturnType SelectFile::drawItemHandler(CallbackData &someCallbackData)
+{
+  if(IDOK==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
+	 mOwnerDraw.handleOwnerButton(IDOK,someCallbackData.lParam());
+  else if(IDCANCEL==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
+	 mOwnerDraw.handleOwnerButton(IDCANCEL,someCallbackData.lParam());
+  return (CallbackData::ReturnType)TRUE;
+}
+
+CallbackData::ReturnType SelectFile::commandHandler(CallbackData &someCallbackData)
+{
+	switch(GET_WM_COMMAND_ID(someCallbackData.wParam(),someCallbackData.lParam()))
+  {
+	 case IDS_FLIST :
+	   switch(GET_WM_COMMAND_CMD(someCallbackData.wParam(),someCallbackData.lParam()))
+		{
+		  case LBN_SELCHANGE :
+			 SelChange();
+			 return (CallbackData::ReturnType)TRUE;
+			case LBN_DBLCLK :
+			 DoubleClick();
+			 return (CallbackData::ReturnType)TRUE;
+		}
+		break;
+	 case IDS_FNAME :
+		if(EN_CHANGE==GET_WM_COMMAND_CMD(someCallbackData.wParam(),someCallbackData.lParam()))
+		  ::EnableWindow(::GetDlgItem((HWND)*this,IDOK),(BOOL)
+				::SendMessage(GET_WM_COMMAND_HWND(someCallbackData.wParam(),someCallbackData.lParam()),WM_GETTEXTLENGTH,0,0L));
+		return (CallbackData::ReturnType)TRUE;
+	 case IDOK :
+		if(CheckFileNameSpec())
+		{
+		  mOwnerDraw.freeButton(IDOK);
+			mOwnerDraw.freeButton(IDCANCEL);
+      endDialog(TRUE);
+		}
+		return (CallbackData::ReturnType)TRUE;
+	 case IDCANCEL :
+		 mOwnerDraw.freeButton(IDOK);
+		 mOwnerDraw.freeButton(IDCANCEL);
+     endDialog(FALSE);
+		return (CallbackData::ReturnType)TRUE;
+	 default :
+		 return (CallbackData::ReturnType)FALSE;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+
+

winmus/FILEHELP.HPP

@@ -0,0 +1,77 @@
+#ifndef _FILEHELP_HPP
+#define _FILEHELP_HPP
+#include <string.h>
+#include <common/windows.hpp>
+#include <common/windowsx.hpp>
+#include <common/crsctrl.hpp>
+#include <common/window.hpp>
+#include <common/dwindow.hpp>
+#include <common/owner.hpp>
+
+class SelectFile : public DWindow, private CursorControl
+{
+public:
+  enum Mode{Read,Write};
+  SelectFile(Window &parentWindow,Mode readWrite=Read);
+  ~SelectFile();
+  void SetAttribute(WORD attribute);
+  void SetExtension(const char * extension);
+  void SetFileSpec(const char * fileSpec);
+  int GetFileName(char *buffer,WORD length);
+private:
+  enum {MaxTextLength=96};
+	enum {DefaultAttribute=0x4010};
+  enum {btnRed=192,btnGreen=192,btnBlue=192};
+  CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType initDialogHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType drawItemHandler(CallbackData &someCallbackData);
+	void Initialize();
+  void SelChange();
+  void DoubleClick();
+  void SetExtended();
+  int CheckFileNameSpec();
+  LPSTR lstrrchr(LPSTR,char);
+  LPSTR lstrchr(LPSTR,char);
+
+  Callback<SelectFile> mCommandHandler;
+  Callback<SelectFile> mInitDialogHandler;
+	Callback<SelectFile> mDrawItemHandler;
+	  char mszDefExt[MaxTextLength];
+  char mszFileName[MaxTextLength];
+  char mszFileSpec[MaxTextLength];
+  char mszDirectory[MaxTextLength];
+  char mcLastChar;
+  short mnEditLen;
+  int mLastDrive;
+  WORD mwFileAttribute;
+  OFSTRUCT mPof;
+  HFILE mfd;
+  HWND mhParent;
+  HINSTANCE mhInstance;
+	Mode mMode;
+  HBRUSH mhGrayBrush;
+  OwnerDraw mOwnerDraw;
+};
+
+inline
+void SelectFile::SetAttribute(WORD nAttribute)
+{
+  mwFileAttribute=nAttribute;
+}
+
+inline
+void SelectFile::SetExtension(const char *szExtension)
+{
+  ::strncpy(mszDefExt,szExtension,sizeof(mszDefExt)-1);
+  mszDefExt[sizeof(mszDefExt)-1]='\0';
+}
+
+inline
+void SelectFile::SetFileSpec(const char *szFileSpec)
+{
+  ::strncpy(mszFileSpec,szFileSpec,sizeof(mszFileSpec)-1);
+  mszFileSpec[sizeof(mszFileSpec)-1]='\0';
+}
+#endif
+
+

winmus/INSTR.DAT

@@ -0,0 +1,176 @@
+0;PIANO;Acoustic Grand Piano
+1;PIANO;Bright Acoustic Piano
+2;PIANO;Electric Grand Piano
+3;PIANO;Honky-tonk Piano
+4;PIANO;Rhodes Piano
+5;PIANO;Chorused Piano
+6;PIANO;Harpsichord
+7;PIANO;Clavinet
+8;CHROM PERCUSSION;Celesta
+9;CHROM PERCUSSION;Glockenspiel
+10;CHROM PERCUSSION;Music Box
+11;CHROM PERCUSSION;Vibraphone
+12;CHROM PERCUSSION;Marimba
+13;CHROM PERCUSSION;Xylophone
+14;CHROM PERCUSSION;Tubular-bell
+15;CHROM PERCUSSION;Dulcimer
+16;ORGAN;Hammond Organ
+17;ORGAN;Percussive Organ
+18;ORGAN;Rock Organ
+19;ORGAN;Church Organ
+20;ORGAN;Reed Organ
+21;ORGAN;Accordion
+22;ORGAN;Harmonica
+23;ORGAN;Tango Accordion
+24;GUITAR;Acoustic Guitar(nylon)
+25;GUITAR;Acoustic Guitar(steel)
+26;GUITAR;Electric Guitar(jazz)
+27;GUITAR;Electric Guitar(clean)
+28;GUITAR;Electric Guitar(muted)
+29;GUITAR;Overdriven Guitar
+30;GUITAR;Distortion Guitar
+31;GUITAR;Guitar Harmonics
+32;BASS;Acoustic Bass
+33;BASS;Electric Bass(finger)
+34;BASS;Electric Bass(pick)
+35;BASS;Fretless Bass
+36;BASS;Slap Bass 1
+37;BASS;Slap Bass 2
+38;BASS;Synth Bass 1
+39;BASS;Synth Bass 2
+40;STRINGS;Violin
+41;STRINGS;Viola
+42;STRINGS;Cello
+43;STRINGS;Contrabass
+44;STRINGS;Tremolo Strings
+45;STRINGS;Pizzicato Strings
+46;STRINGS;Orchestral Harp
+47;STRINGS;Timpani
+48;ENSEMBLE;String Ensemble 1
+49;ENSEMBLE;String Ensemble 2
+50;ENSEMBLE;Synth Strings 1
+51;ENSEMBLE;Synth Strings 2
+52;ENSEMBLE;Choir Aahs
+53;ENSEMBLE;Voice Oohs
+54;ENSEMBLE;Synth Voice
+55;ENSEMBLE;Orchestra Hit
+56;BRASS;Trumpet
+57;BRASS;Trombone
+58;BRASS;Tuba
+59;BRASS;Muted Trumpet
+60;BRASS;French Horn
+61;BRASS;Brass Section
+62;BRASS;Synth Brass 1
+63;BRASS;Synth Brass 2
+64;REED;Soprano Sax
+65;REED;Alto Sax
+66;REED;Tenor Sax
+67;REED;Baritone Sax
+68;REED;Oboe
+69;REED;English Horn
+70;REED;Bassoon
+71;REED;Clarinet
+72;PIPE;Piccolo
+73;PIPE;Flute
+74;PIPE;Recorder
+75;PIPE;Pan Flute
+76;PIPE;Bottle Blow
+77;PIPE;Shakuhachi
+78;PIPE;Whistle
+79;PIPE;Ocarina
+80;SYNTH LEAD;Lead 1(square)
+81;SYNTH LEAD;Lead 2(sawtooth)
+82;SYNTH LEAD;Lead 3(calliope)
+83;SYNTH LEAD;Lead 4(chiffer)
+84;SYNTH LEAD;Lead 5(charang)
+85;SYNTH LEAD;Lead 6(voice)
+86;SYNTH LEAD;Lead 7(5th sawtooth)
+87;SYNTH LEAD;Lead 8(bass&lead)
+88;SYNTH PAD;Pad 1(new age)
+89;SYNTH PAD;Pad 2(warm)
+90;SYNTH PAD;Pad 3(polysynth)
+91;SYNTH PAD;Pad 4(choir)
+92;SYNTH PAD;Pad 5(bowed glass)
+93;SYNTH PAD;Pad 6(metal)
+94;SYNTH PAD;Pad 7(halo)
+95;SYNTH PAD;Pad 8(sweep)
+96;SYNTH EFFECTS;FX 1(rain)
+97;SYNTH EFFECTS;FX 2(soundtrack)
+98;SYNTH EFFECTS;FX 3(crystal)
+99;SYNTH EFFECTS;FX 4(atmosphere)
+100;SYNTH EFFECTS;FX 5(brightness)
+101;SYNTH EFFECTS;FX 6(goblin)
+102;SYNTH EFFECTS;FX 7(echo drops)
+103;SYNTH EFFECTS;FX 8(star-theme)
+104;ETHNIC;Sitar
+105;ETHNIC;Banjo
+106;ETHNIC;Shamisen
+107;ETHNIC;Koto
+108;ETHNIC;Kalimba
+109;ETHNIC;Bag Pipe
+110;ETHNIC;Fiddle
+111;ETHNIC;Shanai
+112;PERCUSSIVE;Tinkle Bell
+113;PERCUSSIVE;Agogo
+114;PERCUSSIVE;Steel Drums
+115;PERCUSSIVE;Woodblock
+116;PERCUSSIVE;Taiko Drum
+117;PERCUSSIVE;Melodic Tom
+118;PERCUSSIVE;Synth Drum
+119;PERCUSSIVE;Reverse Cymbal
+120;SOUND EFFECTS;Guitar Fret Noise
+121;SOUND EFFECTS;Breath Noise
+122;SOUND EFFECTS;Seashore
+123;SOUND EFFECTS;Bird Tweet
+124;SOUND EFFECTS;Telephone Ring
+125;SOUND EFFECTS;Helicopter
+126;SOUND EFFECTS;Applause
+127;SOUND EFFECTS;Gun Shot
+135;STANDARD MIDI PERCUSSION;Acoustic Bass Drum
+136;STANDARD MIDI PERCUSSION;Bass Drum
+137;STANDARD MIDI PERCUSSION;Slide Stick
+138;STANDARD MIDI PERCUSSION;Acoustic Snare
+139;STANDARD MIDI PERCUSSION;Hand Clap
+140;STANDARD MIDI PERCUSSION;Electric Snare
+141;STANDARD MIDI PERCUSSION;Low Floor Tom
+142;STANDARD MIDI PERCUSSION;Closed High-Hat
+143;STANDARD MIDI PERCUSSION;High Floor Tom
+144;STANDARD MIDI PERCUSSION;Pedal High Hat
+145;STANDARD MIDI PERCUSSION;Low Tom
+146;STANDARD MIDI PERCUSSION;Open High Hat
+147;STANDARD MIDI PERCUSSION;Low-Mid Tom
+148;STANDARD MIDI PERCUSSION;High-Mid Tom
+149;STANDARD MIDI PERCUSSION;Crash Cymbal 1
+150;STANDARD MIDI PERCUSSION;High Tom
+151;STANDARD MIDI PERCUSSION;Ride Cymbal 1
+152;STANDARD MIDI PERCUSSION;Chinese Cymbal
+153;STANDARD MIDI PERCUSSION;Ride Bell
+154;STANDARD MIDI PERCUSSION;Tambourine
+155;STANDARD MIDI PERCUSSION;Splash Cymbal
+156;STANDARD MIDI PERCUSSION;Cowbell
+157;STANDARD MIDI PERCUSSION;Crash Cymbal 2
+158;STANDARD MIDI PERCUSSION;Vibraslap
+159;STANDARD MIDI PERCUSSION;Ride Cymbal 2
+160;STANDARD MIDI PERCUSSION;High Bongo
+161;STANDARD MIDI PERCUSSION;Low Bongo
+162;STANDARD MIDI PERCUSSION;Mute High Conga
+163;STANDARD MIDI PERCUSSION;Open High Conga
+164;STANDARD MIDI PERCUSSION;Low Conga
+165;STANDARD MIDI PERCUSSION;High Timbale
+166;STANDARD MIDI PERCUSSION;Low Timbale
+167;STANDARD MIDI PERCUSSION;High Agogo
+168;STANDARD MIDI PERCUSSION;Low Agogo
+169;STANDARD MIDI PERCUSSION;Cabasa
+170;STANDARD MIDI PERCUSSION;Maracas
+171;STANDARD MIDI PERCUSSION;Short Whistle
+172;STANDARD MIDI PERCUSSION;Long Whistle
+173;STANDARD MIDI PERCUSSION;Short Guiro
+174;STANDARD MIDI PERCUSSION;Long Guiro
+175;STANDARD MIDI PERCUSSION;Claves
+176;STANDARD MIDI PERCUSSION;High Wood Block
+177;STANDARD MIDI PERCUSSION;Low Wood Block
+178;STANDARD MIDI PERCUSSION;Mute Cuica
+179;STANDARD MIDI PERCUSSION;Open Cuica
+180;STANDARD MIDI PERCUSSION;Mute Triangle
+181;STANDARD MIDI PERCUSSION;Open Triangle
+

winmus/INSTRMNT.CPP

@@ -0,0 +1,74 @@
+#include <stdlib.h>
+#include <midiapp/instrmnt.hpp>
+
+Instruments::Instruments(WORD startOrdinal,WORD endOrdinal)
+{
+  loadInstruments(startOrdinal,endOrdinal);
+}
+
+Instruments::~Instruments()
+{
+}
+
+WORD Instruments::loadInstruments(WORD startOrdinal,WORD endOrdinal)
+{
+	String semicolonString(";");
+  String nullString("\\0");
+	String ordinalString;
+	String categoryString;
+	String nameString;
+	char *lpBuffer;
+	BYTE lineFeed;
+
+	size((endOrdinal-startOrdinal)+1);
+	for(short index=startOrdinal,offset=0;index<=endOrdinal;index++,offset++)
+	{
+		String tempString(index);
+    lpBuffer=tempString;
+		lpBuffer=::strtok(tempString,semicolonString);
+		if(!lpBuffer)continue;
+		ordinalString=lpBuffer;
+		lpBuffer=::strtok(0,semicolonString);
+		if(!lpBuffer)continue;
+		categoryString=lpBuffer;
+		lpBuffer=::strtok(0,nullString);
+		if(!lpBuffer)continue;
+		nameString=lpBuffer;
+    operator[](offset)=PureInstrument(::atoi(ordinalString),categoryString,nameString);
+	}
+	return (WORD)size();
+}
+
+WORD Instruments::getInstruments(PureVector<PureInstrument> &vectoredInstruments)
+{
+	vectoredInstruments.size(0);
+	if(!size())return FALSE;
+	vectoredInstruments.size(size());
+	for(int i=0;i<size();i++)vectoredInstruments[i]=operator[](i);
+  return vectoredInstruments.size();
+}
+
+WORD Instruments::locateInstrument(WORD ordinalValue,PureInstrument &somePureInstrument)
+{
+	short itemIndex;
+
+	if(!binarySearch(ordinalValue,itemIndex))return FALSE;
+	somePureInstrument=operator[](itemIndex);
+	return TRUE;
+}
+
+WORD Instruments::binarySearch(WORD ordinal,short &itemIndex)
+{
+	short lowerBound(0);
+	short upperBound((short)size()-1);
+	short indexItem;
+
+	do{
+		indexItem=(lowerBound+upperBound)/2;
+		if(operator[](indexItem).ordinal()<ordinal)lowerBound=indexItem+1;
+		else upperBound=indexItem-1;
+	}while(operator[](indexItem).ordinal()!=ordinal&&lowerBound<=upperBound);
+	itemIndex=indexItem;
+  return operator[](indexItem).ordinal()==ordinal;
+}
+

winmus/INSTRMNT.HPP

@@ -0,0 +1,20 @@
+#ifndef _INSTRUMENT_HPP_
+#define _INSTRUMENT_HPP_
+#include <common/windows.hpp>
+#include <common/string.hpp>
+#include <common/pvector.hpp>
+#include <midiapp/pureinst.hpp>
+
+class Instruments : public PureVector<PureInstrument>
+{
+public:
+  Instruments(WORD startOrdinal,WORD endOrdinal);
+	~Instruments();
+  WORD getInstruments(PureVector<PureInstrument> &vectoredInstruments);
+	WORD locateInstrument(WORD ordinalValue,PureInstrument &somePureInstrument);
+private:
+  WORD binarySearch(WORD ordinalValue,short &itemIndex);
+	enum {Semicolon=';'};
+	WORD loadInstruments(WORD startOrdinal,WORD endOrdinal);
+};
+#endif

winmus/LED.CPP

@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <midiapp/led.hpp>
+
+void LedDisplay::paint(void)
+{
+	HBITMAP hOldBitmap;
+	HDC hDisplayDC;
+	HDC hMemDC;
+	WORD firstOffset;
+	WORD secondOffset;
+	WORD thirdOffset;
+  WORD fourthOffset;
+
+	hDisplayDC=::GetDC(mhDisplayWindow);
+	hMemDC=::CreateCompatibleDC(hDisplayDC);
+	hOldBitmap=(HBITMAP)::SelectObject(hMemDC,mhFilm);
+	positions(firstOffset,secondOffset,thirdOffset,fourthOffset);
+	::BitBlt(hDisplayDC,mWindowPoint.x(),mWindowPoint.y(),Width,Height,
+		hMemDC,0,firstOffset*Height,SRCCOPY);
+	::BitBlt(hDisplayDC,mWindowPoint.x()+Width,mWindowPoint.y(),Width,Height,
+		hMemDC,0,secondOffset*Height,SRCCOPY);
+	::BitBlt(hDisplayDC,mWindowPoint.x()+(Width*2),mWindowPoint.y(),Width,Height,
+		hMemDC,0,thirdOffset*Height,SRCCOPY);
+	::BitBlt(hDisplayDC,mWindowPoint.x()+(Width*3),mWindowPoint.y(),Width,Height,
+		hMemDC,0,fourthOffset*Height,SRCCOPY);
+	::SelectObject(hMemDC,hOldBitmap);
+	::DeleteObject(hMemDC);
+	::ReleaseDC(mhDisplayWindow,hDisplayDC);
+}
+
+void LedDisplay::positions(WORD &firstOffset,WORD &secondOffset,WORD &thirdOffset,WORD &fourthOffset)const
+{
+	String numberString;
+
+	if(mHasSpecialChar)
+	{
+		if(BlankChar==mCurrentSpecialChar)
+			firstOffset=secondOffset=thirdOffset=fourthOffset=OffsetBlankChar;
+		else
+			firstOffset=secondOffset=thirdOffset=fourthOffset=OffsetDashChar;
+	}
+	else
+  {
+	  ::sprintf(numberString,"%04d",mCurrentNumber);
+	  firstOffset=charPosition(*(numberString));
+	  secondOffset=charPosition(*(numberString+1));
+		thirdOffset=charPosition(*(numberString+2));
+    fourthOffset=charPosition(*(numberString+3));
+	}
+}
+

winmus/LED.HPP

@@ -0,0 +1,71 @@
+#ifndef _LEDDISPLAY_HPP_
+#define _LEDDISPLAY_HPP_
+#include <common/windows.hpp>
+#include <common/string.hpp>
+#include <common/point.hpp>
+
+class LedDisplay
+{
+public:
+	enum SpecialChar{BlankChar,DashChar};
+	LedDisplay(HWND hDisplayWindow,Point windowPoint);
+	virtual ~LedDisplay();
+	void setNumber(short someNumber);
+	void setNumber(SpecialChar specialChar);
+	short getNumber(void)const;
+	void paint(void);
+private:
+	enum {Width=13,Height=23,Frames=12};
+	enum {OffsetDashChar,OffsetBlankChar};
+	WORD charPosition(char someDisplayChar)const;
+	void positions(WORD &firstOffset,WORD &secondOffset,WORD &thirdOffset,WORD &fourthOffset)const;
+	HBITMAP mhFilm;
+	short mCurrentNumber;
+	SpecialChar mCurrentSpecialChar;
+	WORD mHasSpecialChar;
+	Point mWindowPoint;
+	HWND mhDisplayWindow;
+};
+
+inline
+LedDisplay::LedDisplay(HWND hDisplayWindow,Point windowPoint)
+: mWindowPoint(windowPoint), mhDisplayWindow(hDisplayWindow), mCurrentNumber(-1),
+	mHasSpecialChar(TRUE), mCurrentSpecialChar(DashChar),
+	mhFilm(::LoadBitmap((HINSTANCE)::GetWindowWord(hDisplayWindow,GWW_HINSTANCE),"LED"))
+{
+}
+
+inline
+LedDisplay::~LedDisplay()
+{
+	if(mhFilm){::DeleteObject(mhFilm);mhFilm=0;}
+}
+
+inline
+WORD LedDisplay::charPosition(char someChar)const
+{
+	return ((Frames-1)-((int)someChar-'0'));
+}
+
+inline
+short LedDisplay::getNumber(void)const
+{
+	return mCurrentNumber;
+}
+
+inline
+void LedDisplay::setNumber(SpecialChar specialChar)
+{
+	mHasSpecialChar=TRUE;
+	mCurrentSpecialChar=specialChar;
+	paint();
+}
+
+inline
+void LedDisplay::setNumber(short someNumber)
+{
+	mHasSpecialChar=FALSE;
+	mCurrentNumber=someNumber;
+	paint();
+}
+#endif

winmus/MAIN.CPP

@@ -0,0 +1,33 @@
+#include <common/logowin.hpp>
+#include <winmus/mainwnd.hpp>
+#include <winmus/main.hpp>
+
+HINSTANCE Main::smhInstance=0;
+HINSTANCE Main::smhPrevInstance=0;
+int Main::smnCmdShow=0;
+OwnerDraw Main::smhBitmap;
+
+int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR /*lpszCmdLine*/,int nCmdSHow)
+{
+  Main::smhInstance=hInstance;
+  Main::smhPrevInstance=hPrevInstance;
+	Main::smnCmdShow=nCmdSHow;
+
+	if(Main::smhPrevInstance)
+	{
+	 HWND hWnd=::FindWindow(MainWindow::className(),MainWindow::className());
+	 if(!hWnd)
+	 {
+		::MessageBox(::GetFocus(),(LPSTR)"Failed to maximize previous instance",(LPSTR)"Error",MB_ICONSTOP|MB_SYSTEMMODAL);
+	 return 0;
+	 }
+	 ::PostMessage(hWnd,WM_REACTIVATE,0,0L);
+	 return 0;
+	}
+	LogoWindow logoWindow(hInstance,hInstance);
+	logoWindow.showLogo(String("WINMUS"));
+	MainWindow applicationWindow(Main::smhInstance);
+	return applicationWindow.messageLoop();
+}
+
+

winmus/MAIN.HPP

@@ -0,0 +1,29 @@
+#ifndef _MAIN_HPP_
+#define _MAIN_HPP_
+#include <common/windows.hpp>
+#include <common/types.hpp>
+#include <common/owner.hpp>
+
+#define WM_REACTIVATE WM_USER+1
+
+class Main
+{
+public:
+  static HINSTANCE processInstance(void);      
+  static HINSTANCE smhPrevInstance;
+  static int smnCmdShow;
+  static OwnerDraw smhBitmap;
+  static HINSTANCE smhInstance;
+private:
+};
+
+inline
+HINSTANCE Main::processInstance(void)
+{
+  return smhInstance;
+}
+#endif
+
+
+
+

winmus/MAINWND.CPP

@@ -0,0 +1,115 @@
+#include <common/profile.hpp>
+#include <midiwrt/muscnv.hpp>
+#include <winmus/mainwnd.hpp>
+#include <winmus/filehelp.hpp>
+#include <winmus/mididef.hpp>
+#include <winmus/musdlg.hpp>
+
+char MainWindow::szClassName[]="MUS File Converter";
+char MainWindow::szMenuName[]="MUSMENU";
+
+MainWindow::MainWindow(HINSTANCE hInstance)
+: mPaintHandler(this,&MainWindow::paintHandler),
+	mDestroyHandler(this,&MainWindow::destroyHandler),
+	mCommandHandler(this,&MainWindow::commandHandler),
+	mMenuSelectHandler(this,&MainWindow::menuSelectHandler),
+	mhInstance(hInstance)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	insertHandler(VectorHandler::MenuSelectHandler,&mMenuSelectHandler);
+	registerClass();
+	::CreateWindow(szClassName,szClassName,
+		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_SIZEBOX|WS_CLIPCHILDREN,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		NULL,NULL,mhInstance,(LPSTR)this);
+	show(SW_SHOW);
+	update();
+}
+
+MainWindow::~MainWindow()
+{
+	removeHandlers();
+  if((HWND)*this)destroy();
+}
+
+void MainWindow::registerClass(void)const
+{
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(mhInstance,className(),(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WindowWndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(MainWindow*);
+	wndClass.hInstance     =mhInstance;
+	wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+	wndClass.hbrBackground =(HBRUSH)::GetStockObject(WHITE_BRUSH);
+	wndClass.lpszMenuName  =szMenuName;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+	assert(0!=::GetClassInfo(mhInstance,className(),(WNDCLASS FAR*)&wndClass));
+}
+
+CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+	removeHandlers();
+	::PostQuitMessage(0);
+	return (CallbackData::ReturnType)0;
+}
+
+CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
+{
+	switch(GET_WM_COMMAND_ID(someCallbackData.wParam(),someCallbackData.lParam()))
+	{
+		case IDM_OPTIONLOAD :
+      handleLoadRequest();
+      break;
+		case IDM_OPTIONEXIT :
+      destroy();
+			break;
+		default :
+			break;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::menuSelectHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)0;
+}
+
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)0;
+}
+
+void MainWindow::removeHandlers(void)
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	removeHandler(VectorHandler::MenuSelectHandler,&mMenuSelectHandler);
+}
+
+void MainWindow::handleLoadRequest(void)
+{
+	SelectFile selector(*this);
+	String musPathFileName;
+	String midiPathFileName;
+
+	selector.SetFileSpec(String(STRING_ASTERISKDOTMUS));
+	if(selector.GetFileName(musPathFileName,String::MaxString))
+	{
+		midiPathFileName=musPathFileName;
+		midiPathFileName.token(".");
+		midiPathFileName+=".MID";
+		MUSDlg musDlg(*this,midiPathFileName,musPathFileName);
+    musDlg.performDialog();
+	}
+	return;
+}
+

winmus/MAINWND.HPP

@@ -0,0 +1,36 @@
+#ifndef _MAINWINDOW_HPP_
+#define _MAINWINDOW_HPP_
+#include <common/window.hpp>
+#include <common/string.hpp>
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(HINSTANCE hInstance);
+	~MainWindow();
+	static String className(void);
+private:
+	void registerClass(void)const;
+	void removeHandlers(void);
+  void handleLoadRequest(void);
+
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType menuSelectHandler(CallbackData &someCallbackData);
+
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mMenuSelectHandler;
+	static char szClassName[];
+	static char szMenuName[];
+	HINSTANCE mhInstance;
+};
+
+inline
+String MainWindow::className(void)
+{
+	return String(szClassName);
+}
+#endif

winmus/MIDIAPP.BAK

@@ -0,0 +1,51 @@
+#include <windows.h>
+#include <winmus/mididef.h>
+#include <midiwrt/midiwrt.rc>
+
+OKFOCUSUP BITMAP OKFOCUP.BMP
+OKNOFUP   BITMAP OKNOFUP.BMP
+OKFOCUSDN BITMAP OKFOCDN.BMP 
+CAFOCUSUP BITMAP CAFOCUP.BMP 
+CANOFUP   BITMAP CANOFUP.BMP
+CAFOCUSDN BITMAP CAFOCDN.BMP
+WINMUS    
+
+MUSMENU MENU
+{
+ POPUP "&Options"
+ {
+	 MENUITEM "&Select MUS File",         IDM_OPTIONLOAD
+	 MENUITEM "E&xit",                    IDM_OPTIONEXIT
+ }
+}
+
+FileSelect DIALOG 31, 27, 211, 145
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+FONT 6,"Helv"
+{
+ LISTBOX IDS_FLIST, 5, 53, 201, 88, LBS_STANDARD | LBS_USETABSTOPS | WS_CHILD | WS_VISIBLE | WS_TABSTOP
+ EDITTEXT IDS_FNAME, 42, 6, 84, 12, ES_LEFT | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP
+ CONTROL "Ok", IDOK, "BUTTON", BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 131, 3, 36, 24
+ CONTROL "Cancel", IDCANCEL, "BUTTON", BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 170, 3, 36, 24
+ LTEXT "File Name:", -1, 2, 8, 38, 8
+ LTEXT "Path:", -1, 4, 24, 17, 8
+ LTEXT "", IDS_FPATH, 25, 24, 98, 9, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "File", -1, 20, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "Date", -1, 68, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "Size", -1, 129, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "Time", -1, 159, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "File Save", IDS_FILESAVE, 90, 155, 38, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "File Open", IDS_FILEOPEN, 90, 168, 34, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+}
+
+STRINGTABLE
+{
+	STRING_BITMAPOKFOCUSUP,	      "OKFOCUSUP"
+	STRING_BITMAPOKNOFUP,		      "OKNOFUP"
+	STRING_BITMAPOKFOCUSDN,	      "OKFOCUSDN"
+	STRING_BITMAPCAFOCUSUP,       "CAFOCUSUP"
+	STRING_BITMAPCANOFUP,		      "CANOFUP"
+	STRING_BITMAPCAFOCUSDN,       "CAFOCUSDN"
+	STRING_ASTERISKDOTMUS,        "*.MUS"
+}
+

winmus/MIDIAPP.DEF

@@ -0,0 +1,13 @@
+NAME        WINMUS
+DESCRIPTION 'MUS FILE CONVERTER'
+EXETYPE     WINDOWS
+STUB        'WINSTUB.EXE'
+CODE        PRELOAD MOVEABLE DISCARDABLE
+DATA        PRELOAD MOVEABLE
+HEAPSIZE    8191
+STACKSIZE   24576
+EXPORTS
+
+
+
+

winmus/MIDIAPP.RC

@@ -0,0 +1,51 @@
+#include <windows.h>
+#include <winmus/mididef.h>
+#include <midiwrt/midiwrt.rc>
+
+OKFOCUSUP BITMAP OKFOCUP.BMP
+OKNOFUP   BITMAP OKNOFUP.BMP
+OKFOCUSDN BITMAP OKFOCDN.BMP 
+CAFOCUSUP BITMAP CAFOCUP.BMP 
+CANOFUP   BITMAP CANOFUP.BMP
+CAFOCUSDN BITMAP CAFOCDN.BMP
+WINMUS    BITMAP WINMUS.BMP
+
+MUSMENU MENU
+{
+ POPUP "&Options"
+ {
+	 MENUITEM "&Select MUS File",         IDM_OPTIONLOAD
+	 MENUITEM "E&xit",                    IDM_OPTIONEXIT
+ }
+}
+
+FileSelect DIALOG 31, 27, 211, 145
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+FONT 6,"Helv"
+{
+ LISTBOX IDS_FLIST, 5, 53, 201, 88, LBS_STANDARD | LBS_USETABSTOPS | WS_CHILD | WS_VISIBLE | WS_TABSTOP
+ EDITTEXT IDS_FNAME, 42, 6, 84, 12, ES_LEFT | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP
+ CONTROL "Ok", IDOK, "BUTTON", BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 131, 3, 36, 24
+ CONTROL "Cancel", IDCANCEL, "BUTTON", BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 170, 3, 36, 24
+ LTEXT "File Name:", -1, 2, 8, 38, 8
+ LTEXT "Path:", -1, 4, 24, 17, 8
+ LTEXT "", IDS_FPATH, 25, 24, 98, 9, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "File", -1, 20, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "Date", -1, 68, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "Size", -1, 129, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "Time", -1, 159, 38, 16, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "File Save", IDS_FILESAVE, 90, 155, 38, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+ LTEXT "File Open", IDS_FILEOPEN, 90, 168, 34, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+}
+
+STRINGTABLE
+{
+	STRING_BITMAPOKFOCUSUP,	      "OKFOCUSUP"
+	STRING_BITMAPOKNOFUP,		      "OKNOFUP"
+	STRING_BITMAPOKFOCUSDN,	      "OKFOCUSDN"
+	STRING_BITMAPCAFOCUSUP,       "CAFOCUSUP"
+	STRING_BITMAPCANOFUP,		      "CANOFUP"
+	STRING_BITMAPCAFOCUSDN,       "CAFOCUSDN"
+	STRING_ASTERISKDOTMUS,        "*.MUS"
+}
+

winmus/MIDIDEF.H

@@ -0,0 +1,23 @@
+
+/* defines for main menu */
+#define IDM_OPTIONLOAD  			           101
+#define IDM_OPTIONEXIT  			           102
+
+/* defines for file select dialog */
+#define IDS_FLIST 		                   0x0B
+#define IDS_FNAME 		                   0x0C
+#define IDS_FPATH 		                   0x0D
+#define IDS_FILEOPEN	                   0x0E
+#define IDS_FILESAVE	                   0x0F
+
+
+/* string defines */
+#define	STRING_BITMAPOKFOCUSUP 	         200
+#define	STRING_BITMAPOKNOFUP 		         201
+#define	STRING_BITMAPOKFOCUSDN 	         202
+#define	STRING_BITMAPCAFOCUSUP           203
+#define	STRING_BITMAPCANOFUP 		         204
+#define	STRING_BITMAPCAFOCUSDN           205
+#define	STRING_ASTERISKDOTMUS            206
+
+

winmus/MIDIDEF.HPP

@@ -0,0 +1,4 @@
+#ifndef _MIDIDEF_HPP_
+#define _MIDIDEF_HPP_
+#include <winmus/mididef.h>
+#endif

winmus/MUSDLG.CPP

@@ -0,0 +1,282 @@
+#include <common/purehdc.hpp>
+#include <midiapp/musdlg.hpp>
+#include <midiapp/mididef.hpp>
+#include <midiapp/instrmnt.hpp>
+
+char MUSDlg::szClassName[]={"MUSConverter"};
+char MUSDlg::szMenuName[]={""};
+
+MUSDlg::MUSDlg(Window &parentWindow,String midiPathFileName,String musPathFileName)
+: MUSConverter(midiPathFileName,musPathFileName),
+	mCommandHandler(this,&MUSDlg::commandHandler),
+  mCreateHandler(this,&MUSDlg::createHandler),
+	mDrawItemHandler(this,&MUSDlg::drawItemHandler),
+	mPaintHandler(this,&MUSDlg::paintHandler),
+	mDestroyHandler(this,&MUSDlg::destroyHandler),
+	mCloseHandler(this,&MUSDlg::closeHandler),
+  mControlColorHandler(this,&MUSDlg::controlColorHandler),
+	mParentWindow(parentWindow), mlpLedTrackDisplay(0), mlpLedTempoDisplay(0),
+	mOwnerDraw(OwnerDraw::UseInstance), mhButtonCvtWnd(0), mhButtonUpWnd(0),
+	mhGrayBrush(::CreateSolidBrush(RGB(btnRed,btnGreen,btnBlue))),
+	mhButtonDnWnd(0), mhListBoxWnd(0), mhStaticWnd(0),
+	mLinkedBitmap(0,String("WND"),parentWindow.processInstance()),
+	mOutputPathFileName(midiPathFileName)
+{
+	registerClass();
+	insertHandlers();
+}
+
+MUSDlg::~MUSDlg()
+{
+	if(mlpLedTrackDisplay){delete mlpLedTrackDisplay;mlpLedTrackDisplay=0;}
+	if(mlpLedTempoDisplay){delete mlpLedTempoDisplay;mlpLedTempoDisplay=0;}
+	if(::IsWindow(mhButtonUpWnd))::DestroyWindow(mhButtonUpWnd);
+	if(::IsWindow(mhButtonDnWnd))::DestroyWindow(mhButtonDnWnd);
+  if(::IsWindow(mhButtonCvtWnd))::DestroyWindow(mhButtonCvtWnd);
+	if(::IsWindow(mhListBoxWnd))::DestroyWindow(mhListBoxWnd);
+  if(::IsWindow(mhStaticWnd))::DestroyWindow(mhStaticWnd);
+  if(mhGrayBrush)::DeleteObject(mhGrayBrush);
+	if((HWND)*this)destroy();
+	removeHandlers();
+}
+
+void MUSDlg::registerClass(void)const
+{
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(mParentWindow.processInstance(),szClassName,(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WindowWndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(MUSDlg*);
+	wndClass.hInstance     =mParentWindow.processInstance();
+	wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+	wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH);
+	wndClass.lpszMenuName  =szMenuName;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+	assert(0!=::GetClassInfo(mParentWindow.processInstance(),szClassName,(WNDCLASS FAR*)&wndClass));
+}
+
+WORD MUSDlg::performDialog(void)
+{
+	createDialogControls();
+  loadInstruments();
+	while(::IsWindow((HWND)*this))yieldTask();
+  return FALSE;
+}
+
+void MUSDlg::loadInstruments(void)
+{
+  Instruments midiInstruments(StartOrdinal,EndOrdinal);
+	PureVector<PureInstrument> vectoredInstruments;
+  String itemString;
+
+	midiInstruments.getInstruments(vectoredInstruments);
+  ::SendMessage(mhListBoxWnd,WM_SETREDRAW,FALSE,0L);
+	for(int index=0;index<vectoredInstruments.size();index++)
+	{
+		itemString=vectoredInstruments[index].category();
+		itemString+="-";
+    itemString+=vectoredInstruments[index].name();
+		::SendMessage(::GetDlgItem(*this,MUS_LISTBOX),LB_ADDSTRING,-1,(LPARAM)(LPSTR)itemString);
+	}
+	::SendMessage(mhListBoxWnd,WM_SETREDRAW,TRUE,0L);
+}
+
+void MUSDlg::insertHandlers(void)
+{
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+  insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler);
+}
+
+void MUSDlg::removeHandlers(void)
+{
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+  removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
+  removeHandler(VectorHandler::ControlColorHandler,&mControlColorHandler);
+}
+
+void MUSDlg::createDialogControls(void)
+{
+	String buttonString(STRING_BUTTONSTRING);
+	String listboxString(STRING_LISTBOXSTRING);
+  String staticString(STRING_STATICSTRING);
+
+	PureDevice pureDevice;
+	::CreateWindow(szClassName,szClassName,
+		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_CLIPCHILDREN,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		mLinkedBitmap.width(),mLinkedBitmap.height()+CaptionHeight,
+		NULL,NULL,mParentWindow.processInstance(),(LPSTR)((MUSDlg*)this));
+	mhButtonUpWnd=::CreateWindow(buttonString,"",BS_OWNERDRAW|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,152,45,10,8,*this,(HMENU)MUS_TEMPOBUTTONUP,mParentWindow.processInstance(),0);
+	mhButtonDnWnd=::CreateWindow(buttonString,"",BS_OWNERDRAW|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,152,54,10,8,*this,(HMENU)MUS_TEMPOBUTTONDN,mParentWindow.processInstance(),0);
+	mhButtonCvtWnd=::CreateWindow(buttonString,"",BS_OWNERDRAW|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,167,17,15,15,*this,(HMENU)MUS_CVTBUTTON,mParentWindow.processInstance(),0);
+	mhListBoxWnd=::CreateWindow(listboxString,"",LBS_NOTIFY|WS_VSCROLL|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,19,130,280,62,*this,(HMENU)MUS_LISTBOX,mParentWindow.processInstance(),0);
+	mhStaticWnd=::CreateWindow(staticString,"",WS_CHILD|WS_CLIPSIBLINGS,21,210,275,18,*this,(HMENU)MUS_STATIC,mParentWindow.processInstance(),0);
+	show(SW_SHOW);update();
+  ::ShowWindow(mhStaticWnd,SW_SHOW);
+}
+
+CallbackData::ReturnType MUSDlg::commandHandler(CallbackData &someCallbackData)
+{
+	switch(someCallbackData.wmCommandID())
+	{
+		case MUS_TEMPOBUTTONUP :
+			handleTempoUpEvent();
+			break;
+		case MUS_TEMPOBUTTONDN :
+      handleTempoDnEvent();
+			break;
+		case MUS_CVTBUTTON :
+			::PostMessage(*this,WM_COMMAND,MUS_CONVERTFILE,0L);
+			return FALSE;
+		case MUS_CONVERTFILE :
+      handleConvertFileEvent();
+			break;
+		case IDCANCEL :
+      destroy();
+			break;
+  }
+  return (CallbackData::ReturnType)FALSE;
+}
+
+void MUSDlg::handleTempoUpEvent(void)
+{
+	setTempo(getTempo()+1);
+  mlpLedTempoDisplay->setNumber(getTempo());
+}
+
+void MUSDlg::handleTempoDnEvent(void)
+{
+	setTempo(getTempo()-1);
+  mlpLedTempoDisplay->setNumber(getTempo());
+}
+
+void MUSDlg::handleConvertFileEvent(void)
+{
+	String convertMessageString("writing ");
+
+  convertMessageString+=mOutputPathFileName;
+	setMessage(convertMessageString);
+	if(!convertFile())setMessage("Error converting file...");
+  else setMessage("Complete...");
+}
+
+CallbackData::ReturnType MUSDlg::createHandler(CallbackData &/*someCallbackData*/)
+{
+	mOwnerDraw.associate(MUS_TEMPOBUTTONUP,String(STRING_BITMAPUPARUP),String(STRING_BITMAPUPARUP),String(STRING_BITMAPUPARDN),OwnerDraw::NOFOCUS);
+	mOwnerDraw.associate(MUS_TEMPOBUTTONDN,String(STRING_BITMAPDNARUP),String(STRING_BITMAPDNARUP),String(STRING_BITMAPDNARDN),OwnerDraw::NOFOCUS);
+	mOwnerDraw.associate(MUS_CVTBUTTON,String(STRING_BITMAPCNVTUP),String(STRING_BITMAPCNVTUP),String(STRING_BITMAPCNVTDN),OwnerDraw::NOFOCUS);
+	mlpLedTrackDisplay=new LedDisplay(*this,Point(xTrack,yTrack));
+	mlpLedTempoDisplay=new LedDisplay(*this,Point(xTempo,yTempo));
+  mlpLedTempoDisplay->setNumber(getTempo());
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MUSDlg::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+	mOwnerDraw.freeBitmap(MUS_TEMPOBUTTONUP);
+	mOwnerDraw.freeBitmap(MUS_TEMPOBUTTONDN);
+	mOwnerDraw.freeBitmap(MUS_CVTBUTTON);
+	return (CallbackData::ReturnType)FALSE;  
+}
+
+CallbackData::ReturnType MUSDlg::closeHandler(CallbackData &/*someCallbackData*/)
+{
+  destroy();
+	return (CallbackData::ReturnType)FALSE;  
+}
+
+CallbackData::ReturnType MUSDlg::controlColorHandler(CallbackData &someCallbackData)
+{
+	::SetBkColor((HDC)someCallbackData.wParam(),RGB(btnRed,btnGreen,btnBlue));
+	return (CallbackData::ReturnType)mhGrayBrush;
+}
+
+CallbackData::ReturnType MUSDlg::drawItemHandler(CallbackData &someCallbackData)
+{
+	if(MUS_TEMPOBUTTONUP==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
+		mOwnerDraw.handleOwnerButton(MUS_TEMPOBUTTONUP,someCallbackData.lParam());
+	else if(MUS_TEMPOBUTTONDN==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
+		mOwnerDraw.handleOwnerButton(MUS_TEMPOBUTTONDN,someCallbackData.lParam());
+	else if(MUS_CVTBUTTON==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
+		mOwnerDraw.handleOwnerButton(MUS_CVTBUTTON,someCallbackData.lParam());
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MUSDlg::paintHandler(CallbackData &someCallbackData)
+{
+	RECT windowRect;
+
+	PaintInformation *lpPaintInformation((PaintInformation*)someCallbackData.lParam());
+	::SetRect(&windowRect,0,0,mLinkedBitmap.width(),mLinkedBitmap.height()+CaptionHeight);
+	mLinkedBitmap.drawBitmap((PureDevice)(*lpPaintInformation),windowRect);
+	if(mlpLedTrackDisplay)mlpLedTrackDisplay->paint();
+  if(mlpLedTempoDisplay)mlpLedTempoDisplay->paint();
+	return (CallbackData::ReturnType)0;
+}
+
+void MUSDlg::yieldTask(void)const
+{
+	MSG msg;
+
+	while(::IsWindow((HWND)*this)&&::PeekMessage(&msg,0,0,0,PM_REMOVE))
+	{::TranslateMessage(&msg);::DispatchMessage(&msg);}
+}
+
+WORD MUSDlg::handleScoreStart(void)
+{
+  return MUSConverter::handleScoreStart();
+}
+
+WORD MUSDlg::handleReleaseNote(PureEvent &pureEvent,PureDelay &pureDelay,PureNote &releaseNote,BYTE trackNumber)
+{
+	if(trackNumber!=mlpLedTrackDisplay->getNumber())
+		mlpLedTrackDisplay->setNumber(trackNumber);
+	return MUSConverter::handleReleaseNote(pureEvent,pureDelay,releaseNote,trackNumber);
+}
+
+WORD MUSDlg::handlePlayNote(PureEvent &pureEvent,PureDelay &pureDelay,PureNote &playNote,BYTE trackNumber)
+{
+	if(trackNumber!=mlpLedTrackDisplay->getNumber())
+		mlpLedTrackDisplay->setNumber(trackNumber);
+	return MUSConverter::handlePlayNote(pureEvent,pureDelay,playNote,trackNumber);
+}
+
+WORD MUSDlg::handlePitchBend(PureEvent &pureEvent,PureDelay &pureDelay,BYTE pitchBenderValue,BYTE trackNumber)
+{
+	if(trackNumber!=mlpLedTrackDisplay->getNumber())
+		mlpLedTrackDisplay->setNumber(trackNumber);
+	return MUSConverter::handlePitchBend(pureEvent,pureDelay,pitchBenderValue,trackNumber);
+}
+
+WORD MUSDlg::handleReset(PureEvent &pureEvent,PureDelay &pureDelay,BYTE tempoValue,BYTE trackNumber)
+{
+	if(trackNumber!=mlpLedTrackDisplay->getNumber())
+		mlpLedTrackDisplay->setNumber(trackNumber);
+	return MUSConverter::handleReset(pureEvent,pureDelay,tempoValue,trackNumber);
+}
+
+WORD MUSDlg::handleController(PureEvent &pureEvent,PureDelay &pureDelay,PureController &pureController,BYTE trackNumber)
+{
+	if(trackNumber!=mlpLedTrackDisplay->getNumber())
+		mlpLedTrackDisplay->setNumber(trackNumber);
+	return MUSConverter::handleController(pureEvent,pureDelay,pureController,trackNumber);
+}
+
+WORD MUSDlg::handleScoreEnd(PureDelay &pureDelay)
+{
+	return MUSConverter::handleScoreEnd(pureDelay);
+}
+

winmus/MUSDLG.HPP

@@ -0,0 +1,76 @@
+#ifndef _MUSDIALOG_HPP_
+#define _MUSDIALOG_HPP_
+#include <common/window.hpp>
+#include <common/string.hpp>
+#include <common/owner.hpp>
+#include <common/bitmap.hpp>
+#include <midiwrt/muscnv.hpp>
+#include <winmus/led.hpp>
+
+class MUSDlg :  public Window, private MUSConverter
+{
+public:
+	MUSDlg(Window &parentWindow,String midiPathFileName,String musPathFileName);
+	~MUSDlg();
+	WORD performDialog(void);
+protected:
+	WORD virtual handleScoreStart(void);
+	WORD virtual handleReleaseNote(PureEvent &pureEvent,PureDelay &pureDelay,PureNote &releaseNote,BYTE trackNumber);
+	WORD virtual handlePlayNote(PureEvent &pureEvent,PureDelay &pureDelay,PureNote &playNote,BYTE trackNumber);
+	WORD virtual handlePitchBend(PureEvent &pureEvent,PureDelay &pureDelay,BYTE pitchBenderValue,BYTE trackNumber);
+	WORD virtual handleReset(PureEvent &pureEvent,PureDelay &pureDelay,BYTE tempoValue,BYTE trackNumber);
+	WORD virtual handleController(PureEvent &pureEvent,PureDelay &pureDelay,PureController &pureController,BYTE trackNumber);
+	WORD virtual handleScoreEnd(PureDelay &pureDelay);
+private:
+	enum{xTrack=35,yTrack=40,xTempo=98,yTempo=40};
+	enum{btnRed=192,btnGreen=192,btnBlue=192};
+	enum{CaptionHeight=20,StartOrdinal=500,EndOrdinal=674};
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType drawItemHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType controlColorHandler(CallbackData &someCallbackData);
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(void);
+	void createDialogControls(void);
+	void handleTempoDnEvent(void);
+	void handleTempoUpEvent(void);
+  void handleConvertFileEvent(void);
+  void loadInstruments(void);
+  void setMessage(String messageString)const;
+  void yieldTask(void)const;
+
+	Callback<MUSDlg> mCommandHandler;
+  Callback<MUSDlg> mCreateHandler;
+	Callback<MUSDlg> mDrawItemHandler;
+	Callback<MUSDlg> mPaintHandler;
+	Callback<MUSDlg> mDestroyHandler;
+	Callback<MUSDlg> mCloseHandler;
+  Callback<MUSDlg> mControlColorHandler;
+	Window &mParentWindow;
+	OwnerDraw mOwnerDraw;
+	LedDisplay *mlpLedTrackDisplay;
+	LedDisplay *mlpLedTempoDisplay;
+//	Bitmap mBitmap;
+  LinkedBitmap mLinkedBitmap;
+	HWND mhButtonUpWnd;
+	HWND mhButtonDnWnd;
+  HWND mhButtonCvtWnd;
+	HWND mhListBoxWnd;
+	HWND mhStaticWnd;
+	HBRUSH mhGrayBrush;
+	String mOutputPathFileName;
+	static char szClassName[];
+	static char szMenuName[];
+};
+
+inline
+void MUSDlg::setMessage(String messageString)const
+{
+  ::SendMessage(mhStaticWnd,WM_SETTEXT,0,(LPARAM)(LPSTR)messageString);
+}
+#endif
+

winmus/MUSDL_~1.CPP

@@ -0,0 +1 @@
+E

winmus/PUREINST.CPP

@@ -0,0 +1,3 @@
+#include <midiapp/pureinst.hpp>
+
+

winmus/PUREINST.HPP

@@ -0,0 +1,104 @@
+#ifndef _PUREINSTRUMENT_HPP_
+#define _PUREINSTRUMENT_HPP_
+#include <common/windows.hpp>
+#include <common/string.hpp>
+
+class PureInstrument
+{
+public:
+	PureInstrument(void);
+	PureInstrument(const PureInstrument &somePureInstrument);
+	PureInstrument(WORD ordinal,String category,String name);
+	~PureInstrument();
+	WORD operator==(const PureInstrument &somePureInstrument)const;
+  PureInstrument &operator=(const PureInstrument &somePureInstrument);
+	WORD ordinal(void)const;
+	String category(void)const;
+	String name(void)const;
+	void ordinal(WORD ordinal);
+	void category(String category);
+	void name(String name);
+private:
+  enum {Semicolon=';'};
+	WORD mOrdinal;
+	String mCategory;
+	String mName;
+};
+
+inline
+PureInstrument::PureInstrument(void)
+: mOrdinal(0)
+{
+}
+
+inline
+PureInstrument::PureInstrument(const PureInstrument &somePureInstrument)
+: mOrdinal(somePureInstrument.mOrdinal), mCategory(somePureInstrument.mCategory),
+	mName(somePureInstrument.mName)
+{
+}
+
+inline
+PureInstrument::PureInstrument(WORD ordinal,String category,String name)
+: mOrdinal(ordinal), mCategory(category), mName(name)
+{
+}
+
+inline
+PureInstrument::~PureInstrument()
+{
+}
+
+inline
+WORD PureInstrument::ordinal(void)const
+{
+	return mOrdinal;
+}
+
+inline
+String PureInstrument::category(void)const
+{
+	return mCategory;
+}
+
+inline
+String PureInstrument::name(void)const
+{
+	return mName;
+}
+
+inline
+void PureInstrument::ordinal(WORD ordinal)
+{
+	mOrdinal=ordinal;
+}
+
+inline
+void PureInstrument::category(String category)
+{
+	mCategory=category;
+}
+
+inline
+void PureInstrument::name(String name)
+{
+	mName=name;
+}
+
+inline
+WORD PureInstrument::operator==(const PureInstrument &somePureInstrument)const
+{
+	return (mOrdinal==somePureInstrument.mOrdinal&&
+				 mCategory==somePureInstrument.mCategory&&
+				 mName==somePureInstrument.mName);
+}
+
+inline
+PureInstrument &PureInstrument::operator=(const PureInstrument &somePureInstrument)
+{
+	mOrdinal=somePureInstrument.mOrdinal;
+	mCategory=somePureInstrument.mCategory;
+	mName=somePureInstrument.mName;
+  return *this;
+}
+#endif

winmus/STDTMPL.CPP

@@ -0,0 +1,20 @@
+#define _EXPAND_BLOCK_TEMPLATES_
+#define _EXPAND_VECTOR_TEMPLATES_
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/bmplnk.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/logowin.hpp>
+#include <winmus/filehelp.hpp>
+#include <winmus/mainwnd.hpp>
+
+typedef Callback<MainWindow> a;
+typedef Callback<SelectFile> b;
+typedef Block<CallbackPointer> d;
+typedef Block<LinkedBitmap> e;
+typedef Block<LinkedBitmap> f;
+
+