Initial

mixer/ChannelCtrlMgr.cpp

@@ -0,0 +1,103 @@
+#include <mixer/ChannelCtrlMgr.hpp>
+#include <common/odlstalt.hpp>
+
+char ChannelControlManager::szClassName[]="ChannelControlManager";
+
+ChannelControlManager::ChannelControlManager(GUIWindow &parentWindow,const Rect &creationRect,UINT controlID)
+{
+
+  mPaintHandler.setCallback(this,&ChannelControlManager::paintHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+  registerClass();
+	createWindow(parentWindow,creationRect,controlID);
+	mListBox=new OwnerDrawListControl(*this,Rect(0,0,parentWindow.width()-4,parentWindow.height()-4),110);
+	mListBox->show(SW_SHOW);
+	mListBox->insertString(" ");
+}
+
+ChannelControlManager::~ChannelControlManager()
+{
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+}
+
+void ChannelControlManager::registerClass()
+{
+	HINSTANCE hInstance(processInstance());
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(hInstance,szClassName,(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(ChannelControlManager*);
+	wndClass.hInstance     =hInstance;
+	wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+  wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH);
+	wndClass.lpszMenuName  =0;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+}
+
+void ChannelControlManager::createWindow(GUIWindow &parentWindow,const Rect &creationRect,UINT controlID)
+{
+	::CreateWindow(szClassName,szClassName,WS_CHILDWINDOW|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,creationRect.left(),creationRect.top(),creationRect.width(),creationRect.height(),parentWindow,NULL,processInstance(),(LPSTR)this);
+}
+
+CallbackData::ReturnType ChannelControlManager::paintHandler(CallbackData &someCallbackData)
+{
+//  Rect winRect;
+//  if(!mBitmapBkGnd.isOkay())return (CallbackData::ReturnType)FALSE;
+//	windowRect(winRect);
+//	mDIBitmapBkGnd->copyBits(mBitmapBkGnd->ptrData(),mBitmapBkGnd->imageExtent());
+//	mDIBitmapBkGnd->usePalette(*mPureDevice,TRUE);
+//	mDIBitmapBkGnd->stretchBlt(*mPureDevice,Rect(0,0,(winRect.right()-winRect.left())+mxBorder,height()-mStatusBar->statusBarHeight()));
+//	mDIBitmapBkGnd->stretchBlt(*mPureDevice,Rect(0,0,(winRect.right()-winRect.left())+mxBorder,height()));
+//	mDIBitmapBkGnd->usePalette(*mPureDevice,FALSE);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+// *******************************************************************************************************************
+
+#include <common/purehdc.hpp>
+#include <common/drawitem.hpp>
+#include <common/resbmp.hpp>
+#include <jpgimg/dib24.hpp>
+
+OwnerDrawListControl::OwnerDrawListControl(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,DWORD style)
+: OwnerDrawList(parentWnd,initRect,controlID,style)
+{
+  mButtonUp=new ResBitmap("BUTTONUP");
+	mButtonUp.disposition(PointerDisposition::Delete);
+	mButtonDown=new ResBitmap("BUTTONDN");
+	mButtonDown.disposition(PointerDisposition::Delete);
+	mSelectOff=new ResBitmap("SELOFF");
+	mSelectOff.disposition(PointerDisposition::Delete);
+	mSelectOn=new ResBitmap("SELON");
+	mSelectOn.disposition(PointerDisposition::Delete);
+	mMaxHeight=mSelectOff->height();
+}
+
+OwnerDrawListControl::~OwnerDrawListControl()
+{
+}
+
+
+void OwnerDrawListControl::drawEntire(const DrawItem &drawItem)
+{
+  int xLoc=0;
+  PureDevice pureDevice(drawItem.deviceContext());
+	Rect rectItem(drawItem.rectItem());
+  DIBitmap bitmap(pureDevice,rectItem.width(),mMaxHeight,*mSelectOff);
+/*	bitmap.overlay(*mButtonUp,Point(xLoc,0));
+	xLoc+=mButtonUp->width()+1; */
+  bitmap.overlay(*mSelectOff,Point(xLoc,0));
+	xLoc+=mSelectOff->width()+1;
+/*  bitmap.overlay(*mSelectOff,Point(xLoc,0));
+	xLoc+=mSelectOff->width()+1;
+  bitmap.overlay(*mSelectOff,Point(xLoc,0));
+	xLoc+=mSelectOff->width()+1;
+  bitmap.overlay(*mSelectOff,Point(xLoc,0));
+	xLoc+=mSelectOff->width()+1; */
+	bitmap.stretchBlt(pureDevice,rectItem);
+}

mixer/ChannelCtrlMgr.hpp

@@ -0,0 +1,44 @@
+#ifndef _MIXER_CHANNELCTRLMGR_HPP_
+#define _MIXER_CHANNELCTRLMGR_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_OWNERDRAWLIST_HPP_
+#include <common/odlist.hpp>
+#endif
+
+class ResBitmap;
+
+class OwnerDrawListControl : public OwnerDrawList
+{
+public:
+  OwnerDrawListControl(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,DWORD style=LBS_NOTIFY|LBS_HASSTRINGS|LBS_USETABSTOPS|LBS_OWNERDRAWFIXED|WS_VSCROLL|WS_HSCROLL|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_DLGFRAME);
+	virtual ~OwnerDrawListControl();
+protected:
+  virtual void drawEntire(const DrawItem &drawItem);
+private:
+  SmartPointer<ResBitmap> mButtonUp;
+	SmartPointer<ResBitmap> mButtonDown;
+	SmartPointer<ResBitmap> mSelectOn;
+	SmartPointer<ResBitmap> mSelectOff;
+	int mMaxHeight;
+};
+
+class ChannelControlManager : public Window
+{
+public:
+  ChannelControlManager(GUIWindow &parentWindow,const Rect &creationRect,UINT controlID);
+	virtual ~ChannelControlManager();
+private:
+	void createWindow(GUIWindow &parentWindow,const Rect &creationRect,UINT controlID);
+  CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+  void registerClass();
+
+  static char szClassName[];
+	Callback<ChannelControlManager> mPaintHandler;
+	SmartPointer<OwnerDrawListControl> mListBox;
+};
+#endif

mixer/Graphic.cpp

@@ -0,0 +1,134 @@
+#include <mixer/graphic.hpp>
+#include <common/resbmp.hpp>
+#include <common/dib.hpp>
+
+char Graphic::szClassName[]="Graphic";
+
+Graphic::Graphic(GUIWindow &parentWnd,const String &strBitmapName,UINT controlID,UINT extraStyles,const Rect &initRect,const Font &bannerFont)
+: mBannerFont(bannerFont), mParentWnd(parentWnd), mxIndent(Indent), 
+  myBorder(::GetSystemMetrics(SM_CYDLGFRAME)<<1), mInitRect(initRect)
+{
+	mRibbonBitmap=new ResBitmap(strBitmapName);
+	mRibbonBitmap.disposition(PointerDisposition::Delete);
+  mPaintHandler.setCallback(this,&Graphic::paintHandler);
+	mCreateHandler.setCallback(this,&Graphic::createHandler);
+	mDestroyHandler.setCallback(this,&Graphic::destroyHandler);
+	mSizeHandler.setCallback(this,&Graphic::sizeHandler);
+	mEraseBackgroundHandler.setCallback(this,&Graphic::eraseBackgroundHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::EraseBackgroundHandler,&mEraseBackgroundHandler);
+	mParentWnd.insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	registerClass();
+	createWindow(parentWnd,controlID,extraStyles);
+}
+
+Graphic::~Graphic()
+{
+  removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::EraseBackgroundHandler,&mEraseBackgroundHandler);
+	mParentWnd.removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
+}
+
+Graphic &Graphic::operator=(const Graphic &/*someGraphic*/)
+{ // private implementation
+  return *this;
+}
+
+void Graphic::registerClass(void)
+{
+	HINSTANCE hProcessInstance(processInstance());
+  WNDCLASS wndClass;
+
+	if(::GetClassInfo(hProcessInstance,szClassName,(WNDCLASS FAR *)&wndClass))return;
+	wndClass.style	       =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC;
+	wndClass.lpfnWndProc	 =(WNDPROC)Window::WndProc;
+	wndClass.cbClsExtra	   =0;
+	wndClass.cbWndExtra	   =sizeof(Graphic*);
+	wndClass.hInstance	   =hProcessInstance;
+	wndClass.hIcon	       =0;
+	wndClass.hCursor	     =::LoadCursor(NULL,IDC_ARROW);
+	wndClass.hbrBackground =(HBRUSH)::GetStockObject(BLACK_BRUSH);
+	wndClass.lpszMenuName  =0;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+}
+
+void Graphic::createWindow(GUIWindow &parentWindow,UINT controlID,UINT extraStyles)
+{
+  if(!mInitRect.right())mInitRect.right(mRibbonBitmap->width());
+	if(!mInitRect.bottom())mInitRect.bottom(mRibbonBitmap->height());
+  ::CreateWindowEx(0,(LPSTR)szClassName,(LPSTR)0,
+	WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|extraStyles,mInitRect.left(),mInitRect.top(),mInitRect.right(),mInitRect.bottom(),
+
+
+	parentWindow,(HMENU)controlID,processInstance(),(LPSTR)(Window*)this);
+}
+
+CallbackData::ReturnType Graphic::createHandler(CallbackData &someCallbackData)
+{
+	if(!mRibbonBitmap->isOkay())return (CallbackData::ReturnType)FALSE;
+	myIndent=mBannerFont.charHeight()/4;
+  mPureDevice=new PureDevice(*this);
+	mPureDevice.disposition(PointerDisposition::Delete);
+	mDIBitmap=new DIBitmap(*mPureDevice,*mRibbonBitmap,*mRibbonBitmap);
+	mDIBitmap.disposition(PointerDisposition::Delete);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType Graphic::destroyHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType Graphic::eraseBackgroundHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)TRUE;
+}
+
+CallbackData::ReturnType Graphic::sizeHandler(CallbackData &someCallbackData)
+{
+  if(!mInitRect.right())width(mParentWnd.width());
+	myIndent=mBannerFont.charHeight()/4; 
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType Graphic::paintHandler(CallbackData &someCallbackData)
+{
+  if(!mRibbonBitmap.isOkay())return (CallbackData::ReturnType)FALSE;
+  PaintInformation *pPaintInfo=(PaintInformation*)someCallbackData.lParam();
+  mDIBitmap->copyBits(mRibbonBitmap->ptrData(),mRibbonBitmap->imageExtent());  
+	mDIBitmap->usePalette(*mPureDevice,TRUE);
+	mDIBitmap->stretchBlt(*mPureDevice,Rect(0,0,width(),height()));
+	mDIBitmap->usePalette(*mPureDevice,FALSE);
+	mPureDevice->select((GDIObj)mBannerFont,TRUE);
+	mPureDevice->setTextColor(RGBColor(255,255,255));
+	mPureDevice->setBkMode(PureDevice::Transparent);
+	mPureDevice->textOut(indent(),myIndent,mCaptionString);
+	mPureDevice->select((GDIObj)mBannerFont,FALSE);
+	postPaint(*mPureDevice);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+BOOL Graphic::setCaption(const String &captionString)
+{
+  mCaptionString=captionString;
+	invalidate(FALSE);
+	return TRUE;
+}
+
+const String &Graphic::getCaption(void)const
+{
+  return mCaptionString;
+}
+
+// **************************************************************************************************
+// virtuals
+
+void Graphic::postPaint(PureDevice &pureDevice)
+{
+}
+

mixer/Graphic.hpp

@@ -0,0 +1,85 @@
+#ifndef _MIXER_GRAPHIC_HPP_
+#define _MIXER_GRAPHIC_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_FONT_HPP_
+#include <common/font.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+
+class ResBitmap;
+class DIBitmap;
+class PureDevice;
+
+class Graphic : public Window
+{
+public:
+  Graphic(GUIWindow &parentWnd,const String &strBitmapName,UINT controlID,UINT extraStyles=0,const Rect &initRect=Rect(1,1,0,0),const Font &bannerFont=Font("Times New Roman",20,Font::PitchVariable|Font::FamilySwiss,Font::WeightNormal));
+	virtual ~Graphic();
+	BOOL setCaption(const String &captionString);
+  const String &getCaption(void)const;
+	WORD indent(void)const;
+	void indent(WORD indent);
+	const Rect &initRect(void)const;
+	GUIWindow &getParent(void);
+protected:
+  virtual void postPaint(PureDevice &pureDevice);
+private:
+  enum {Indent=15};
+	Graphic &operator=(const Graphic &someGraphic);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType eraseBackgroundHandler(CallbackData &someCallbackData);
+  void registerClass(void);
+	void createWindow(GUIWindow &parentWindow,UINT controlID,UINT extraStyles);
+
+  static char szClassName[];
+	Callback<Graphic> mCreateHandler;
+	Callback<Graphic> mPaintHandler;
+	Callback<Graphic> mDestroyHandler;
+	Callback<Graphic> mSizeHandler;
+	Callback<Graphic> mEraseBackgroundHandler;
+	SmartPointer<ResBitmap> mRibbonBitmap;
+	SmartPointer<DIBitmap> mDIBitmap;
+	SmartPointer<PureDevice> mPureDevice;
+	GUIWindow &mParentWnd;
+	String mCaptionString;
+	Font mBannerFont;
+	Rect mInitRect;
+	WORD mxIndent;
+	WORD myIndent;
+	WORD myBorder;
+};
+
+inline
+WORD Graphic::indent(void)const
+{
+  return mxIndent;
+}
+
+inline
+void Graphic::indent(WORD indent)
+{
+  mxIndent=indent;
+}
+
+inline
+GUIWindow &Graphic::getParent(void)
+{
+  return mParentWnd;
+}
+
+inline
+const Rect &Graphic::initRect(void)const
+{
+  return mInitRect;
+}
+#endif

mixer/Main.cpp

@@ -0,0 +1,274 @@
+#include <common/windows.hpp>
+#include <mixer/mainwnd.hpp>
+
+#include <sample/wave.hpp>
+
+
+
+/*
+//#include <mixer/SampleDataInterface.hpp>
+//#include <mixer/SampleDataImpl.hpp>
+//#include <mixer/SampleData.hpp>
+
+typedef struct _SAMPLE_DATA
+{
+  union
+	{
+	  int b4:4;
+		int b8:8;
+		int b16:16;
+		int b32:32;
+	};
+}SAMPLE_DATA;
+
+typedef SAMPLE_DATA SampleData;
+
+class PureSampleEx
+{
+public:  
+  typedef enum BitsPerSample{Bit4=4,Bit8=8,Bit16=16,Bit32=32};
+	enum{BitsPerByte=8};
+	PureSampleEx();
+	virtual ~PureSampleEx();
+  PureSampleEx &operator=(const PureSampleEx &pureSampleEx);
+	bool operator==(const PureSampleEx &pureSampleEx);
+  bool convert(BitsPerSample bitsPerSample);
+  bool convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample);
+  bool initialize(BitsPerSample bitsPerSample,int numSamples);
+	bool getAt(int sampleIndex,SampleData &sampleData);
+	bool setAt(int sampleIndex,SampleData &sampleData);
+	bool isOkay(void)const;
+	DWORD getSizeBytes(void)const;
+	DWORD getNumSamples(void)const;
+private:
+  static int getRequiredLength(BitsPerSample bitsPerSample,int numSamples);
+  static void translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample);
+
+  Array<BYTE> mSampleData;
+	BitsPerSample mBitsPerSample;
+	DWORD mNumSamples;
+};
+
+inline
+PureSampleEx::PureSampleEx()
+: mBitsPerSample(Bit8), mNumSamples(0)
+{
+}
+
+inline
+PureSampleEx::~PureSampleEx()
+{
+}
+
+inline
+bool PureSampleEx::initialize(BitsPerSample bitsPerSample,int numSamples)
+{
+  mBitsPerSample=bitsPerSample;
+	mNumSamples=numSamples;
+	mSampleData.size(getRequiredLength(bitsPerSample,numSamples));
+	return true;
+}
+
+inline
+int PureSampleEx::getRequiredLength(BitsPerSample bitsPerSample,int numSamples)
+{
+  return ((float)bitsPerSample/(float)BitsPerByte)*numSamples;
+}
+
+inline
+PureSampleEx &PureSampleEx::operator=(const PureSampleEx &pureSampleEx)
+{
+  mSampleData=pureSampleEx.mSampleData;
+	mBitsPerSample=pureSampleEx.mBitsPerSample;
+  mNumSamples=pureSampleEx.mNumSamples;
+	return *this;
+}
+
+inline
+bool PureSampleEx::operator==(const PureSampleEx &pureSampleEx)
+{
+  if(mBitsPerSample!=pureSampleEx.mBitsPerSample || mNumSamples!=pureSampleEx.mNumSamples)return false;
+	return mSampleData==pureSampleEx.mSampleData;
+}
+
+bool PureSampleEx::convert(BitsPerSample bitsPerSample)
+{
+  PureSampleEx pureSampleEx;
+  
+	convert(pureSampleEx,bitsPerSample);
+	*this=pureSampleEx;
+	return true;
+}
+
+bool PureSampleEx::convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample)
+{
+	SampleData srcData;
+	SampleData dstData;
+
+	if(!isOkay())return false;
+	pureSampleEx.initialize(bitsPerSample,getNumSamples());
+	for(int index=0;index<getNumSamples();index++)
+	{
+	  getAt(index,srcData);
+		translate(srcData,mBitsPerSample,dstData,bitsPerSample);
+		pureSampleEx.setAt(index,dstData);
+	}
+	return pureSampleEx.isOkay();
+}
+
+void PureSampleEx::translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample)
+{
+  if(Bit4==srcBitsPerSample)
+	{
+	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b4;
+		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b4;
+		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b4;
+		else dstData.b32=srcData.b4;
+	}
+	else if(Bit8==srcBitsPerSample)
+	{
+	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b8;
+		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b8;
+		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b8;
+		else dstData.b32=srcData.b8;
+	}
+	else if(Bit16==srcBitsPerSample)
+	{
+	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b16;
+		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b16;
+		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b16;
+		else dstData.b32=srcData.b16;
+	}
+	else
+	{
+	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b32;
+		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b32;
+		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b32;
+		else dstData.b32=srcData.b32;
+	}
+}
+
+inline
+bool PureSampleEx::getAt(int sampleIndex,SampleData &sampleData)
+{
+  float index;
+	int byteIndex;
+
+  if(sampleIndex>=mNumSamples)return false;
+	index=((float)mBitsPerSample/(float)BitsPerByte)*(float)sampleIndex;
+  byteIndex=index;
+	if(Bit4==mBitsPerSample)
+	{
+	  BYTE b=mSampleData[byteIndex];
+		if(0.00==(float)byteIndex-index)sampleData.b4=b;
+		else sampleData.b4=(b>>4);
+	}
+	else if(Bit8==mBitsPerSample)
+	{
+	  sampleData.b8=mSampleData[byteIndex];
+	}
+	else if(Bit16==mBitsPerSample)
+	{
+	  sampleData.b16=*((WORD*)&mSampleData[byteIndex]);
+	}
+	else if(Bit32==mBitsPerSample)
+	{
+	  sampleData.b32=*((DWORD*)&mSampleData[byteIndex]);
+	}
+	return true;
+}
+
+inline
+bool PureSampleEx::setAt(int sampleIndex,SampleData &sampleData)
+{
+  float index;
+	int byteIndex;
+
+  if(sampleIndex>=mNumSamples)return false;
+	index=((float)mBitsPerSample/(float)BitsPerByte)*(float)sampleIndex;
+  byteIndex=index;
+	if(Bit4==mBitsPerSample)
+	{
+	  BYTE b=mSampleData[byteIndex];
+		if(0.00==(float)byteIndex-index)mSampleData[byteIndex]=(b&0xF0)|sampleData.b4;
+		else mSampleData[byteIndex]=(b&0x0F)|(((BYTE)sampleData.b4)<<4);
+	}
+	else if(Bit8==mBitsPerSample)
+	{
+	  mSampleData[byteIndex]=sampleData.b8;
+	}
+	else if(Bit16==mBitsPerSample)
+	{
+	  *((WORD*)&mSampleData[byteIndex])=sampleData.b16;
+	}
+	else if(Bit32==mBitsPerSample)
+	{
+	  *((DWORD*)&mSampleData[byteIndex])=sampleData.b32;
+	}
+	return true;
+}
+
+inline
+DWORD PureSampleEx::getSizeBytes(void)const
+{
+  return getRequiredLength(mBitsPerSample,getNumSamples());
+}
+
+inline
+DWORD PureSampleEx::getNumSamples(void)const
+{
+  return mNumSamples;
+}
+
+inline
+bool PureSampleEx::isOkay(void)const
+{
+  return mNumSamples?true:false;
+}
+*/
+
+// *************************************************************************************************
+
+
+/*
+  PureSampleEx bm;
+  PureSampleEx bm2;
+	PureSampleEx bm3;
+	SampleData sampleData;
+
+  bm.initialize(PureSampleEx::Bit4,1000000);
+	for(int index=0;index<bm.getNumSamples();index++)
+	{
+	  sampleData.b4=index;
+		bm.setAt(index,sampleData);
+	}
+	bm.getAt(1,sampleData);
+	bm.convert(bm2,PureSampleEx::Bit16);
+	bm3=bm2;
+	if(bm3==bm2)::OutputDebugString("Equal\n");
+	else ::OutputDebugString("Not Equal\n");
+*/
+
+/*  WaveForm wave;
+	SmartPointer<SampleData> sample;
+
+	if(!wave.open("D:\\Program Files\\FruityLoops3\\Samples\\Packs\\Basic\\Kicks\\Kick.wav"))return 0;
+  FormatChunk &formatChunk=wave.getFormatChunk();
+	PureSample &pureSample=wave.getPureSample();
+
+	if(16==formatChunk.bitsPerSample())
+	{
+	  UHUGE *sampleData=pureSample.sampleData();
+	}
+	else if(8==formatChunk.bitsPerSample())
+	{
+	  UHUGE *sampleData=pureSample.sampleData();
+	}
+*/
+
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR lpszCmdLine,int /*nCmdShow*/)
+{
+  MainWindow mainWindow;
+	return mainWindow.messageLoop();
+}

mixer/Mainwnd.cpp

@@ -0,0 +1,185 @@
+#include <mixer/mainwnd.hpp>
+#include <mixer/MixerScope.hpp>
+#include <mixer/mixer.hpp>
+
+#include <mixer/ChannelCtrlMgr.hpp>
+
+#include <sample/wave.hpp>
+#include <common/odlstalt.hpp>
+#include <common/pointer.hpp>
+#include <common/resbmp.hpp>
+#include <common/dib.hpp>
+#include <common/puredwrd.hpp>
+#include <common/opendlg.hpp>
+
+char MainWindow::szClassName[]="Mixer  [v1.00]";
+char MainWindow::szMenuName[]="Mixer";
+
+MainWindow::MainWindow(void)
+: mxBorder(0)
+{
+  mPaintHandler.setCallback(this,&MainWindow::paintHandler);
+	mDestroyHandler.setCallback(this,&MainWindow::destroyHandler);
+	mCommandHandler.setCallback(this,&MainWindow::commandHandler);
+	mKeyDownHandler.setCallback(this,&MainWindow::keyDownHandler);
+	mSizeHandler.setCallback(this,&MainWindow::sizeHandler);
+	mCreateHandler.setCallback(this,&MainWindow::createHandler);
+	mUserHandler.setCallback(this,&MainWindow::userHandler);
+	mEraseBackgroundHandler.setCallback(this,&MainWindow::eraseBackgroundHandler);
+	insertHandlers();
+	registerClass();
+//	::CreateWindow(szClassName,szClassName,WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_DLGFRAME,CW_USEDEFAULT,CW_USEDEFAULT,InitialWidth,InitialHeight,NULL,NULL,processInstance(),(LPSTR)this);
+	::CreateWindow(szClassName,szClassName,WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_CLIPCHILDREN|WS_MINIMIZEBOX|WS_CLIPSIBLINGS|WS_DLGFRAME,CW_USEDEFAULT,CW_USEDEFAULT,InitialWidth,InitialHeight,NULL,NULL,processInstance(),(LPSTR)this);
+	mStatusBar=new StatusBar(*this);
+	mStatusBar.disposition(PointerDisposition::Delete);
+	show(SW_SHOW);
+  update();
+}
+
+MainWindow::~MainWindow()
+{
+	destroy();
+}
+
+void MainWindow::insertHandlers(void)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::EraseBackgroundHandler,&mEraseBackgroundHandler);
+	insertHandler(VectorHandler::UserHandler,&mUserHandler);
+}
+
+void MainWindow::removeHandlers(void)
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::EraseBackgroundHandler,&mEraseBackgroundHandler);
+	removeHandler(VectorHandler::UserHandler,&mUserHandler);
+}
+
+void MainWindow::registerClass(void)
+{
+	HINSTANCE hInstance(processInstance());
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(hInstance,className(),(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(MainWindow*);
+	wndClass.hInstance     =hInstance;
+	wndClass.hIcon         =::LoadIcon(processInstance(),"MIXER");
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+  wndClass.hbrBackground =(HBRUSH)::GetStockObject(NULL_BRUSH);
+	wndClass.lpszMenuName  =szMenuName;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+}
+
+CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+  removeHandlers();
+  ::PostQuitMessage(0);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::sizeHandler(CallbackData &someCallbackData)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::eraseBackgroundHandler(CallbackData &someCallbackData)
+{
+	return (CallbackData::ReturnType)TRUE;
+}
+
+CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
+{
+	switch(someCallbackData.wParam())
+	{
+	  case MIXERMENU_FILE_OPEN :
+		  handleFileOpen();
+		  break;
+		case MIXERMENU_FILE_EXIT :
+		  sendMessage(WM_CLOSE,0,0L);
+		  break;
+		default :
+      break;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::keyDownHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+	Block<PureDWORD> stopArray;
+
+  mxBorder=::GetSystemMetrics(SM_CXDLGFRAME)<<1;
+  mBitmapBkGnd=new ResBitmap("BACKGROUND");
+	mBitmapBkGnd.disposition(PointerDisposition::Delete);
+	if(!mBitmapBkGnd.isOkay())return (CallbackData::ReturnType)FALSE;
+  mPureDevice=new PureDevice(*this);
+	mPureDevice.disposition(PointerDisposition::Delete);
+	mDIBitmapBkGnd=new DIBitmap(*mPureDevice,*mBitmapBkGnd,*mBitmapBkGnd);
+	mDIBitmapBkGnd.disposition(PointerDisposition::Delete);
+
+  mMixerScope=new MixerScope(*this,Scope1ID,0,Rect(xBorder,Scope1y,300,130),Font("Times New Roman",10,Font::PitchVariable|Font::FamilySwiss,Font::WeightNormal));
+	mMixerScope.disposition(PointerDisposition::Delete);
+  mMixerScope->show(SW_SHOW);
+	mMixerScope->update();
+	mMixerScope->bringWindowToTop();
+
+  mChannelControlManager=new ChannelControlManager(*this,Rect(xBorder,140,625,400),110);
+  mChannelControlManager.disposition(PointerDisposition::Delete);
+	mChannelControlManager->show(SW_SHOW);
+	mChannelControlManager->update();
+
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &someCallbackData)
+{
+  Rect winRect;
+  if(!mBitmapBkGnd.isOkay())return (CallbackData::ReturnType)FALSE;
+	windowRect(winRect);
+	mDIBitmapBkGnd->copyBits(mBitmapBkGnd->ptrData(),mBitmapBkGnd->imageExtent());
+	mDIBitmapBkGnd->usePalette(*mPureDevice,TRUE);
+	mDIBitmapBkGnd->stretchBlt(*mPureDevice,Rect(0,0,(winRect.right()-winRect.left())+mxBorder,height()-mStatusBar->statusBarHeight()));
+	mDIBitmapBkGnd->usePalette(*mPureDevice,FALSE);
+
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::userHandler(CallbackData &someCallbackData)
+{
+/*  switch(someCallbackData.wParam())
+	{
+	  case WM_USER +1 :
+		  modifyPayment();
+			break;
+	}  */
+	return (CallbackData::ReturnType)FALSE;
+}
+
+void MainWindow::handleFileOpen()
+{
+  OpenDialog openDialog;
+  String strPathFileName;
+
+	if(!openDialog.getOpenFileName(*this,"*.wav","Open File","*.wav",strPathFileName))return;
+	mMixerScope->setData(WaveForm(strPathFileName));
+}
+
+

mixer/Mainwnd.hpp

@@ -0,0 +1,75 @@
+#ifndef _MIXER_MAINWINDOW_HPP_
+#define _MIXER_MAINWINDOW_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _STATBAR_STATBAR_HPP_
+#include <statbar/statbar.hpp>
+#endif
+
+class ResBitmap;
+class DIBitmap;
+class MixerScope;
+class ChannelControlManager;
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(void);
+	virtual ~MainWindow();
+	static String className(void);
+private:
+	enum{InitialWidth=640,InitialHeight=480};
+  enum{xBorder=5,Scope1y=5};
+	enum{Scope1ID=101};
+
+  void insertHandlers(void);
+  void removeHandlers(void);
+  void registerClass(void);
+	void handleFileOpen(void);
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType setFocusHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType eraseBackgroundHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType userHandler(CallbackData &someCallbackData);
+
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mKeyDownHandler;
+	Callback<MainWindow> mSizeHandler;
+	Callback<MainWindow> mCreateHandler;
+  Callback<MainWindow> mEraseBackgroundHandler;
+	Callback<MainWindow> mUserHandler;
+	SmartPointer<ResBitmap> mBitmapBkGnd;
+	SmartPointer<DIBitmap> mDIBitmapBkGnd;
+	SmartPointer<PureDevice> mPureDevice;
+
+	SmartPointer<MixerScope> mMixerScope;
+	SmartPointer<ChannelControlManager> mChannelControlManager;
+
+	SmartPointer<StatusBar> mStatusBar;
+	WORD mxBorder;
+	static char szClassName[];
+	static char szMenuName[];
+};
+
+inline
+String MainWindow::className(void)
+{
+  return String(szClassName);
+}
+#endif

mixer/MixerScope.cpp

@@ -0,0 +1,54 @@
+#include <mixer/MixerScope.hpp>
+#include <sample/puresmpl.hpp>
+#include <common/array.hpp>
+#include <common/purehdc.hpp>
+
+MixerScope::MixerScope(GUIWindow &parentWnd,UINT controlID,UINT extraStyles,const Rect &initRect,const Font &bannerFont)
+: Graphic(parentWnd,"SCOPE",controlID,extraStyles,initRect,bannerFont)
+{
+}
+
+MixerScope::~MixerScope()
+{
+}
+
+bool MixerScope::setData(WaveForm &waveForm)
+{
+  mWaveForm=waveForm;
+  FormatChunk &formatChunk=mWaveForm.getFormatChunk();
+  String strCaption=String("Ch:")+String().fromInt(formatChunk.channels())+String(" Bps:")+String().fromInt(formatChunk.bitsPerSample())+String(" Sps:")+String().fromInt(formatChunk.samplesPerSecond());
+	setCaption(strCaption);
+	invalidate(true);
+	return true;
+}
+
+// **************************************************************************************************
+// virtuals 
+
+void MixerScope::postPaint(PureDevice &pureDevice)
+{
+  int penWidth=2;
+  PureSampleEx &pureSampleEx=mWaveForm.getPureSample();
+	Pen pen(RGBColor(0,128,0));
+	Pen outlinePen(RGBColor(255,255,255),Pen::PSolid,penWidth);
+	int max=0;
+	float factor;
+	int x=0;
+
+  SampleData sample;
+	for(int index=0;index<pureSampleEx.getNumSamples();index++)
+	{
+	  pureSampleEx.getAt(index,sample);
+		if(sample.b16>max)max=sample.b16;
+	}
+	factor=(float)height()/(float)max;
+ 	for(index=0;index<pureSampleEx.getNumSamples();index++)
+	{
+	  pureSampleEx.getAt(index,sample);
+		Point p1(x,height());
+		Point p2(x,height()-(sample.b16*factor));
+		pureDevice.line(p1,p2,pen);
+		x++;
+	}
+	pureDevice.outlineRect(Rect(0,0,width(),height()),outlinePen);
+}

mixer/MixerScope.hpp

@@ -0,0 +1,21 @@
+#ifndef _MIXER_MIXERSCOPE_HPP_
+#define _MIXER_MIXERSCOPE_HPP_
+#ifndef _MIXER_GRAPHIC_HPP_
+#include <mixer/graphic.hpp>
+#endif
+#ifndef _SAMPLE_WAVEFORM_HPP_
+#include <sample/wave.hpp>
+#endif
+
+class MixerScope : public Graphic
+{
+public:
+  MixerScope(GUIWindow &parentWnd,UINT controlID,UINT extraStyles=0,const Rect &initRect=Rect(1,1,0,0),const Font &bannerFont=Font("Times New Roman",20,Font::PitchVariable|Font::FamilySwiss,Font::WeightNormal));
+	virtual ~MixerScope();
+  bool setData(WaveForm &waveForm);
+protected:
+  virtual void postPaint(PureDevice &pureDevice);
+private:
+  WaveForm mWaveForm;
+};
+#endif

mixer/SampleData.hpp

@@ -0,0 +1,50 @@
+#ifndef _MIXER_SAMPLEDATA_HPP_
+#define _MIXER_SAMPLEDATA_HPP_
+#ifndef _COMMON_ARRAY_HPP_
+#include <common/array.hpp>
+#endif
+
+class SampleData : protected Array<BYTE>
+{
+public:
+  friend class SampleDataByte;
+	friend class SampleDataWord;
+  typedef enum BitsPerSample{Bit16=16,Bit8=8};
+	BitsPerSample getBitsPerSample(void)const;
+	void setNumSamples(int numSamples);
+	int getNumSamples(void)const;
+	virtual ~SampleData();
+private:
+  SampleData(BitsPerSample bitsPerSample=Bit16);
+  BitsPerSample mBitsPerSample;
+};
+
+inline
+SampleData::SampleData(BitsPerSample bitsPerSample)
+: mBitsPerSample(bitsPerSample)
+{
+}
+
+inline
+SampleData::~SampleData()
+{
+}
+
+inline
+SampleData::BitsPerSample SampleData::getBitsPerSample(void)const
+{
+  return mBitsPerSample;
+}
+
+inline
+void SampleData::setNumSamples(int numSamples)
+{
+  size(numSamples*(mBitsPerSample>>3));
+}
+
+inline
+int SampleData::getNumSamples(void)const
+{
+  return size()/(mBitsPerSample>>3);
+}
+#endif

mixer/SampleDataImpl.hpp

@@ -0,0 +1,78 @@
+#ifndef _MIXER_SAMPLEDATAIMPL_HPP_
+#define _MIXER_SAMPLEDATAIMPL_HPP_
+#ifndef _MIXER_SAMPLEDATA_HPP_
+#include <mixer/SampleData.hpp>
+#endif
+#ifndef _MIXER_SAMPLEDATAINTERFACE_HPP_
+#include <mixer/SampleDataInterface.hpp>
+#endif
+
+class SampleDataByte : public SampleDataInterface<BYTE>, public SampleData
+{
+public:
+  SampleDataByte();
+	virtual ~SampleDataByte();
+  virtual void setAt(DWORD index,BYTE sample);
+	virtual BYTE getAt(DWORD index);
+private:
+};
+
+inline
+SampleDataByte::SampleDataByte()
+: SampleData((SampleData::BitsPerSample)SampleDataInterface<BYTE>::getBitsPerSample())
+{
+}
+
+inline
+SampleDataByte::~SampleDataByte()
+{
+}
+
+inline
+void SampleDataByte::setAt(DWORD index,BYTE sample)
+{
+  operator[](index)=sample;
+}
+
+inline
+BYTE SampleDataByte::getAt(DWORD index)
+{
+  return operator[](index);
+}
+
+// ***************************************************************************************************
+// ***************************************************************************************************
+class SampleDataWord : public SampleDataInterface<WORD>, public SampleData
+{
+public:
+  SampleDataWord();
+	virtual ~SampleDataWord();
+  virtual void setAt(DWORD index,WORD sample);
+	virtual WORD getAt(DWORD index);
+private:
+};
+
+inline
+SampleDataWord::SampleDataWord()
+: SampleData((SampleData::BitsPerSample)SampleDataInterface<WORD>::getBitsPerSample())
+{
+}
+
+inline
+SampleDataWord::~SampleDataWord()
+{
+}
+
+inline
+void SampleDataWord::setAt(DWORD index,WORD sample)
+{
+  ((WORD*)&operator[](0))[index]=sample;
+}
+
+inline
+WORD SampleDataWord::getAt(DWORD index)
+{
+  return ((WORD*)&operator[](0))[index];
+}
+
+#endif

mixer/SampleDataInterface.hpp

@@ -0,0 +1,39 @@
+#ifndef _MIXER_SAMPLEDATAINTERFACE_HPP_
+#define _MIXER_SAMPLEDATAINTERFACE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+template <class T>
+class SampleDataInterface
+{
+public:
+  SampleDataInterface();
+	virtual ~SampleDataInterface();
+	static int getBitsPerSample(void);
+protected:
+  virtual void setAt(DWORD index,T sample)=0;
+	virtual T getAt(DWORD index)=0;
+private:
+};
+
+template <class T>
+inline
+SampleDataInterface<T>::SampleDataInterface()
+{
+}
+
+template <class T>
+inline
+SampleDataInterface<T>::~SampleDataInterface()
+{
+}
+
+template <class T>
+inline
+int SampleDataInterface<T>::getBitsPerSample(void)
+{
+  return sizeof(T)*8;
+}
+
+#endif

mixer/mixer.dsp

@@ -0,0 +1,133 @@
+# Microsoft Developer Studio Project File - Name="mixer" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=mixer - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "mixer.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mixer.mak" CFG="mixer - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mixer - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "mixer - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "mixer - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF  "$(CFG)" == "mixer - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "STRICT" /D "__FLAT__" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "mixer - Win32 Release"
+# Name "mixer - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\ChannelCtrlMgr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Graphic.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Mainwnd.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mixer.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\MixerScope.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# Begin Source File
+
+SOURCE=.\buttondn.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Texture.bmp
+# End Source File
+# End Group
+# End Target
+# End Project

mixer/mixer.dsw

@@ -0,0 +1,104 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "bsptree"=..\bsptree\bsptree.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "common"=..\common\common.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "jpgimg"=..\jpgimg\jpgimg.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "mixer"=.\mixer.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name common
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name bsptree
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name sample
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name statbar
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name jpgimg
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "sample"=..\sample\sample.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "statbar"=..\statbar\Statbar.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

mixer/mixer.h

@@ -0,0 +1,9 @@
+#ifndef _MIXER_MIXER_H_
+#define _MIXER_MIXER_H_
+
+#define MIXERMENU_FILE_OPEN 1000
+#define MIXERMENU_FILE_EXIT 1001
+
+#endif
+
+

mixer/mixer.hpp

@@ -0,0 +1,4 @@
+#ifndef _MIXER_MIXER_HPP_
+#define _MIXER_MIXER_HPP_
+#include <mixer/mixer.h>
+#endif

mixer/mixer.plg

@@ -0,0 +1,42 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: mixer - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\DOCUME~1\sean\LOCALS~1\Temp\RSP50.tmp" with contents
+[
+/nologo /Gz /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "STRICT" /D "__FLAT__" /Fp"Debug/mixer.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c 
+"D:\work\mixer\ChannelCtrlMgr.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\sean\LOCALS~1\Temp\RSP50.tmp" 
+Creating temporary file "C:\DOCUME~1\sean\LOCALS~1\Temp\RSP51.tmp" with contents
+[
+kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /incremental:yes /pdb:"Debug/mixer.pdb" /debug /machine:I386 /out:"Debug/mixer.exe" /pdbtype:sept 
+.\Debug\ChannelCtrlMgr.obj
+.\Debug\Graphic.obj
+.\Debug\Main.obj
+.\Debug\Mainwnd.obj
+.\Debug\MixerScope.obj
+.\Debug\mixer.res
+\work\exe\mscommon.lib
+\work\exe\msbsp.lib
+\work\exe\sample.lib
+\work\exe\statbar.lib
+\work\exe\jpgimg.lib
+]
+Creating command line "link.exe @C:\DOCUME~1\sean\LOCALS~1\Temp\RSP51.tmp"
+<h3>Output Window</h3>
+Compiling...
+ChannelCtrlMgr.cpp
+Linking...
+
+
+
+<h3>Results</h3>
+mixer.exe - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

mixer/mixer.rc

@@ -0,0 +1,24 @@
+
+
+
+BACKGROUND BITMAP  "TEXTURE.BMP"
+SCOPE      BITMAP "SCOPEBACK.BMP"
+SSPRVIEW   BITMAP "SSPRVIEW.BMP"
+BUTTONUP   BITMAP "BUTTONUP.BMP"
+BUTTONDN   BITMAP "BUTTONDN.BMP"
+SELON      BITMAP "SELON.BMP"
+SELOFF     BITMAP "SELOFF.BMP"
+
+
+#include <windows.h>
+#include <mixer.h>
+
+MIXER MENU 
+{
+ POPUP "&File"
+ {
+   MENUITEM "&Open...", MIXERMENU_FILE_OPEN
+   MENUITEM "E&xit",    MIXERMENU_FILE_EXIT
+ }
+}
+

mixer/scraps.txt

@@ -0,0 +1,129 @@
+/*
+  Block<SmartPointer<SampleData> > samples;
+ 
+  samples.insert(&SmartPointer<SampleData>());
+	samples.insert(&SmartPointer<SampleData>());
+	samples[0]=new SampleDataWord();
+	samples[0].disposition(PointerDisposition::Delete);
+	samples[1]=new SampleDataByte();
+	samples[1].disposition(PointerDisposition::Delete);
+
+	for(int index=0;index<samples.size();index++)
+	{
+	  samples[index]->setNumSamples(2);
+
+	  SampleData &sampleData=*samples[index];
+	  ::OutputDebugString(String("BitsPerSample=")+String().fromInt(sampleData.getBitsPerSample())+String("\n"));
+		if(SampleData::Bit8==sampleData.getBitsPerSample())
+		{
+		  SampleDataByte &sampleDataByte=(SampleDataByte&)sampleData;
+			int numSamples=sampleDataByte.getNumSamples();
+			::OutputDebugString(String("NumSamples=")+String().fromInt(numSamples)+String("\n"));
+			BYTE sample;
+			for(int index=0;index<numSamples;index++)
+			{
+			  sample=sampleDataByte.getAt(index);
+			}
+		}
+		else
+		{
+		  SampleDataWord &sampleDataWord=(SampleDataWord&)sampleData;
+			int numSamples=sampleDataWord.getNumSamples();
+			::OutputDebugString(String("NumSamples=")+String().fromInt(numSamples)+String("\n"));
+			WORD sample;
+			for(int index=0;index<numSamples;index++)
+			{
+			  sample=sampleDataWord.getAt(index);
+			}
+		}
+	}
+  return false;
+  MainWindow mainWindow;
+	return mainWindow.messageLoop();
+}
+*/
+
+
+
+/*
+  Block<SmartPointer<SampleData> > samples;
+ 
+  samples.insert(&SmartPointer<SampleData>());
+	samples.insert(&SmartPointer<SampleData>());
+	samples[0]=new SampleDataWord();
+	samples[0].disposition(PointerDisposition::Delete);
+	samples[1]=new SampleDataByte();
+	samples[1].disposition(PointerDisposition::Delete);
+
+	for(int index=0;index<samples.size();index++)
+	{
+	  samples[index]->setNumSamples(2);
+
+	  SampleData &sampleData=*samples[index];
+	  ::OutputDebugString(String("BitsPerSample=")+String().fromInt(sampleData.getBitsPerSample())+String("\n"));
+		if(SampleData::Bit8==sampleData.getBitsPerSample())
+		{
+		  SampleDataByte &sampleDataByte=(SampleDataByte&)sampleData;
+			int numSamples=sampleDataByte.getNumSamples();
+			::OutputDebugString(String("NumSamples=")+String().fromInt(numSamples)+String("\n"));
+			BYTE sample;
+			for(int index=0;index<numSamples;index++)
+			{
+			  sample=sampleDataByte.getAt(index);
+			}
+		}
+		else
+		{
+		  SampleDataWord &sampleDataWord=(SampleDataWord&)sampleData;
+			int numSamples=sampleDataWord.getNumSamples();
+			::OutputDebugString(String("NumSamples=")+String().fromInt(numSamples)+String("\n"));
+			WORD sample;
+			for(int index=0;index<numSamples;index++)
+			{
+			  sample=sampleDataWord.getAt(index);
+			}
+		}
+	}
+  return false;
+  MainWindow mainWindow;
+	return mainWindow.messageLoop();
+}
+*/
+
+
+
+/*
+		case DropID :
+		  handleDrop();
+		  break;
+		case PickID :
+		  handlePick();
+		  break;
+		case AddPayment :
+		  handleAddPayment();
+			break;
+		case AddAccount :
+		  handleAddAccount();
+			break;
+		case FileExit :
+		  sendMessage(WM_CLOSE,0,0L);
+		  break;
+		case Refresh :
+		  handleRefresh();
+		  break;
+		case Recalc :
+		  handleRecalc();
+		  break;
+		case AutoRecalc :
+		  handleAutoRecalc();
+			break;
+		case ViewAccounts :
+		  handleViewAccounts();
+			break;
+		case Graph :
+		  handleGraph();
+			break;
+		case BalanceSheet :
+		  handleBalanceSheet();
+			break;
+*/