Initial

wave/MAIN.CPP

@@ -0,0 +1,39 @@
+#include <common/windows.hpp>
+#include <wave/main.hpp>
+#include <wave/mainwnd.hpp>
+
+HINSTANCE Main::smhInstance=0;
+HINSTANCE Main::smhPrevInstance=0;
+
+int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR /*lpszCmdLine*/,int nCmdShow)
+{
+	Main::processInstance(hInstance);
+	Main::previousProcessInstance(hPrevInstance);
+	Main::cmdShow(nCmdShow);
+	MainWindow applicationWindow(Main::processInstance());
+	return applicationWindow.messageLoop();
+}
+
+#if 0
+#include <common/stdio.hpp>
+#include <common/openfile.hpp>
+#include <common/windows.hpp>
+#include <common/string.hpp>
+#include <common/pvector.hpp>
+#include <common/fileio.hpp>
+#include <sample/puresmpl.hpp>
+#include <sample/wave.hpp>               
+#include <sample/purewave.hpp>
+
+int PASCAL WinMain(HINSTANCE hProcessInstance,HINSTANCE /*hPrevInstance*/,LPSTR lpszCmdLine,int /*nCmdShow*/)
+{
+	if(!lpszCmdLine||!*lpszCmdLine)lpszCmdLine="C:\\WORK\\SCENE\\MEDIA\\WAV\\AL1.WAV";
+	PureWave pureWave(hProcessInstance);
+	WaveForm waveForm(lpszCmdLine);
+  if(!waveForm.isOkay())return FALSE;
+	((FormatChunk&)waveForm).samplesPerSecond(((FormatChunk&)waveForm).samplesPerSecond()/2);
+  ((FormatChunk&)waveForm).averageBytesPerSecond(((FormatChunk&)waveForm).averageBytesPerSecond()/2);
+	pureWave.play(waveForm,DeviceHandler::Wait);
+	return FALSE;
+}
+#endif

wave/MAIN.HPP

@@ -0,0 +1,65 @@
+#ifndef _WAVE_MAIN_HPP_
+#define _WAVE_MAIN_HPP_
+#include <common/windows.hpp>
+
+class Main
+{
+public:
+  static HINSTANCE processInstance(HWND hWnd);
+  static HINSTANCE processInstance(void);
+  static HINSTANCE previousProcessInstance(void);
+  static void processInstance(HINSTANCE processInstance);
+  static void previousProcessInstance(HINSTANCE previousProcessInstance);
+  static void cmdShow(int nCmdShow);
+private:
+  static HINSTANCE smhInstance;
+  static HINSTANCE smhPrevInstance;
+  static int smnCmdShow;
+};
+
+inline
+void Main::processInstance(HINSTANCE hProcessInstance)
+{
+  smhInstance=hProcessInstance;
+}
+
+inline
+void Main::previousProcessInstance(HINSTANCE previousProcessInstance)
+{
+  smhPrevInstance=previousProcessInstance;
+}
+
+inline
+void Main::cmdShow(int nCmdShow)
+{
+}
+
+inline
+HINSTANCE Main::processInstance(void)
+{
+  return smhInstance;
+}
+
+inline
+HINSTANCE Main::previousProcessInstance(void)
+{
+  return smhPrevInstance;
+}
+
+#if defined(__FLAT__)
+inline
+HINSTANCE Main::processInstance(HWND hWnd)
+{
+  return (HINSTANCE)::GetWindowLong(hWnd,GWL_HINSTANCE);
+}
+#else
+inline
+HINSTANCE Main::processInstance(HWND hWnd)
+{
+  return (HINSTANCE)::GetWindowWord(hWnd,GWW_HINSTANCE);
+}
+#endif
+#define WM_REACTIVATE WM_USER+1
+#endif
+
+

wave/MAINWND.CPP

@@ -0,0 +1,194 @@
+#include <wave/mainwnd.hpp>
+#include <wave/wave.hpp>
+#include <common/opendlg.hpp>
+#include <common/pen.hpp>
+#include <common/purehdc.hpp>
+
+#include <sample/puresmpl.hpp>
+#include <sample/wave.hpp>               
+#include <sample/purewave.hpp>
+
+char MainWindow::szClassName[]="WaveUtil";
+char MainWindow::szMenuName[]="WaveMenu";
+
+MainWindow::MainWindow(HINSTANCE hInstance)
+: mPaintHandler(this,&MainWindow::paintHandler),
+	mDestroyHandler(this,&MainWindow::destroyHandler),
+	mCommandHandler(this,&MainWindow::commandHandler),
+	mKeyDownHandler(this,&MainWindow::keyDownHandler),
+	mSizeHandler(this,&MainWindow::sizeHandler),
+	mCreateHandler(this,&MainWindow::createHandler),
+	mTimerHandler(this,&MainWindow::timerHandler),
+  mDrawItemHandler(this,&MainWindow::drawItemHandler),	
+	mNotifyHandler(this,&MainWindow::notifyHandler),
+	mhInstance(hInstance), mOwnerDraw(OwnerDraw::UseInstance)
+{
+	insertHandlers();
+	registerClass();
+	createWindow(WS_EX_ACCEPTFILES|WS_EX_WINDOWEDGE|WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR,szClassName,szClassName,
+	  WS_VISIBLE|WS_CLIPSIBLINGS|WS_BORDER|WS_CLIPCHILDREN|WS_BORDER|WS_DLGFRAME|WS_SYSMENU|WS_THICKFRAME|WS_GROUP,
+		Rect(CW_USEDEFAULT,CW_USEDEFAULT,InitialWidth,InitialHeight),
+		NULL,NULL,mhInstance,(LPSTR)this);
+	show(SW_SHOW);
+	update();
+  if(!mTrackBar.createTrackBar(*this,Rect(10,12,348,30),TrackBarID,TRUE))::MessageBeep(0);
+	mTrackBar.setRange(1,100);
+	mTrackBar.setPos(1);
+	mTrackBar.insertHandler(TrackBar::NotifyEndTrack,&mNotifyHandler);
+	mControl.createControl("BUTTON","",WS_VISIBLE|WS_DISABLED|BS_OWNERDRAW,Rect(10,42,16,16),*this,PlayID);
+}
+
+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::TimerHandler,&mTimerHandler);
+	insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
+}
+
+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::TimerHandler,&mTimerHandler);
+	removeHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler);
+}
+
+void MainWindow::registerClass(void)const
+{
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(mhInstance,className(),(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_VREDRAW|CS_HREDRAW||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(LTGRAY_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)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::sizeHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::keyDownHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &someCallbackData)
+{
+	Rect winRect;
+  Pen whitePen(RGBColor(255,255,255));
+  PaintInformation &paintInformation=(*((PaintInformation*)someCallbackData.lParam()));
+	windowRect(winRect);
+  ((PureDevice&)paintInformation).line(Point(1,5),Point(winRect.right(),5),whitePen);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::timerHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::drawItemHandler(CallbackData &someCallbackData)
+{
+	if(PlayID==((LPDRAWITEMSTRUCT)someCallbackData.lParam())->CtlID)
+		mOwnerDraw.handleOwnerButton(PlayID,someCallbackData.lParam());
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+	mOwnerDraw.associate(PlayID,String("PLAY"),String("PLAY"),String("PLAYDN"),String("PLAYDA"),OwnerDraw::NOFOCUS);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::notifyHandler(CallbackData &someCallbackData)
+{
+  int sliderPos(mTrackBar.getPos());
+	if(!sliderPos)return (CallbackData::ReturnType)sliderPos;
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
+{
+  switch(someCallbackData.wmCommandID())
+	{
+	  case WAVEMENU_OPEN :
+		  handleFileOpenEvent();
+		  break;
+		case WAVEMENU_EXIT :
+		  postMessage(*this,WM_CLOSE,0,0L);
+		  break;
+	  case PlayID :
+		 handlePlay();
+			break;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+void MainWindow::handleFileOpenEvent(void)
+{
+	String fileHeading("FILES");
+	String exeSection("WAV");
+	OpenDialog openFileName;
+
+	openFileName.owner(0);
+	openFileName.instance(processInstance());
+	openFileName.filter("Wav");
+	openFileName.filterPattern("*.wav");
+	openFileName.fileName("*.WAV");
+	openFileName.fileTitle("FOO");
+	openFileName.initialDirectory(".");
+	openFileName.title("Open File");
+	openFileName.creationFlags(OpenDialog::EXPLORER);
+	if(!openFileName.getOpenFileName())return;
+	PureWave pureWave(processInstance());
+	WaveForm waveForm(openFileName.fileName());
+  if(!waveForm.isOkay())
+	{
+	  ::MessageBox(*this,openFileName.fileName(),(LPSTR)"Unknown format",MB_OK);
+		return;
+	}
+	mPathFileName=openFileName.fileName();
+	::EnableWindow(mControl,TRUE);
+}
+
+void MainWindow::handlePlay(void)
+{
+  if(mPathFileName.isNull())return;
+	PureWave pureWave(processInstance());
+	WaveForm waveForm(mPathFileName);
+	if(!waveForm.isOkay())return;
+	((FormatChunk&)waveForm).samplesPerSecond(((FormatChunk&)waveForm).samplesPerSecond()/2);
+  ((FormatChunk&)waveForm).averageBytesPerSecond(((FormatChunk&)waveForm).averageBytesPerSecond()/2);
+	pureWave.play(waveForm,DeviceHandler::Wait);
+}

wave/MAINWND.HPP

@@ -0,0 +1,68 @@
+#ifndef _WAVE_MAINWINDOW_HPP_
+#define _WAVE_MAINWINDOW_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _WAVE_TRACKBAR_HPP_
+#include <wave/trackbar.hpp>
+#endif
+#ifndef _COMMON_ELASTICCONTROL_HPP_
+#include <common/elastic.hpp>
+#endif
+#ifndef _COMMON_OWNER_HPP_
+#include <common/owner.hpp>
+#endif
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(HINSTANCE hInstance);
+	virtual ~MainWindow();
+	static String className(void);
+private:
+  enum{InitialWidth=400,InitialHeight=120};
+	enum{PlayID=101,TrackBarID=102};
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(void);
+  void handleFileOpenEvent(void);
+  void handlePlay(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 timerHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType notifyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType drawItemHandler(CallbackData &someCallbackData);
+
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mKeyDownHandler;
+	Callback<MainWindow> mSizeHandler;
+	Callback<MainWindow> mTimerHandler;
+	Callback<MainWindow> mCreateHandler;
+	Callback<MainWindow> mDrawItemHandler;
+	Callback<MainWindow> mNotifyHandler;
+	static char szClassName[];
+	static char szMenuName[];
+	HINSTANCE mhInstance;
+  TrackBar mTrackBar;
+	OwnerDraw mOwnerDraw;
+	ElasticControl mControl;
+	String mPathFileName;
+};
+
+inline
+String MainWindow::className(void)
+{
+	return String(szClassName);
+}
+#endif
+
+

wave/STDTMPL.CPP

@@ -0,0 +1,17 @@
+#define _EXPAND_VECTOR_TEMPLATES_
+#define _EXPAND_BLOCK_TEMPLATES_
+#include <common/catmull.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/string.hpp>
+
+class MainWindow;
+
+typedef PureVector<FloatPairs> a;
+typedef Block<String> b;
+typedef Callback<MainWindow> c;
+

wave/TBBUTTON.HPP

@@ -0,0 +1,192 @@
+#ifndef _WAVE_TRACKBARBUTTON_HPP_
+#define _WAVE_TRACKBARBUTTON_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class TrackBarButton : private TBBUTTON
+{
+public:
+  TrackBarButton(void);
+	TrackBarButton(const TrackBarButton &someTrackBarButton);
+	TrackBarButton(const TBBUTTON &someTBBUTTON);
+	virtual ~TrackBarButton(void);
+	TrackBarButton &operator=(const TrackBarButton &someTrackBarButton);
+	TrackBarButton &operator=(const TBBUTTON &someTBBUTTON);
+	WORD operator==(const TrackBarButton &someTrackBarButton)const;
+	WORD operator==(const TBBUTTON &someTBBUTTON)const;
+  operator TBBUTTON &(void);
+	int bmIndex(void)const;
+	void bmIndex(int bmIndex);
+	int cmdID(void)const;
+	void cmdID(int cmdID);
+	BYTE state(void)const;
+	void state(BYTE state);
+	BYTE style(void)const;
+	void style(BYTE style);
+	DWORD appData(void)const;
+	void appData(DWORD appData);
+	int strIndex(void)const;
+	void strIndex(int strIndex);
+private:
+  void setZero(void);
+};
+
+inline
+TrackBarButton::TrackBarButton(void)
+{
+  setZero();
+}
+
+inline
+TrackBarButton::TrackBarButton(const TrackBarButton &someTrackBarButton)
+{
+  *this=someTrackBarButton;
+}
+
+inline
+TrackBarButton::TrackBarButton(const TBBUTTON &someTBBUTTON)
+{
+  *this=someTBBUTTON;
+}
+
+inline
+TrackBarButton::~TrackBarButton(void)
+{
+}
+
+inline
+TrackBarButton &TrackBarButton::operator=(const TrackBarButton &someTrackBarButton)
+{
+  bmIndex(someTrackBarButton.bmIndex());
+	cmdID(someTrackBarButton.cmdID());
+	state(someTrackBarButton.state());
+	style(someTrackBarButton.style());
+	appData(someTrackBarButton.appData());
+	strIndex(someTrackBarButton.strIndex());
+	return *this;
+}
+
+inline
+TrackBarButton &TrackBarButton::operator=(const TBBUTTON &someTBBUTTON)
+{
+  bmIndex(someTBBUTTON.iBitmap);
+	cmdID(someTBBUTTON.idCommand);
+	state(someTBBUTTON.fsState);
+	style(someTBBUTTON.fsStyle);
+	appData(someTBBUTTON.dwData);
+	strIndex(someTBBUTTON.iString);
+	return *this;
+}
+
+inline
+WORD TrackBarButton::operator==(const TrackBarButton &someTrackBarButton)const
+{
+  return (bmIndex()==someTrackBarButton.bmIndex()&&
+	        cmdID()==someTrackBarButton.cmdID()&&
+					state()==someTrackBarButton.state()&&
+					style()==someTrackBarButton.style()&&
+					appData()==someTrackBarButton.appData()&&
+					strIndex()==someTrackBarButton.strIndex());
+}
+
+inline
+WORD TrackBarButton::operator==(const TBBUTTON &someTBBUTTON)const
+{
+  return (bmIndex()==someTBBUTTON.iBitmap&&
+	        cmdID()==someTBBUTTON.idCommand&&
+	        state()==someTBBUTTON.fsState&&
+	        style()==someTBBUTTON.fsStyle&&
+	        appData()==someTBBUTTON.dwData&&
+	        strIndex()==someTBBUTTON.iString);
+}
+
+inline
+TrackBarButton::operator TBBUTTON &(void)
+{
+  return *this;
+}
+
+inline
+int TrackBarButton::bmIndex(void)const
+{
+  return TBBUTTON::iBitmap;
+}
+
+inline
+void TrackBarButton::bmIndex(int bmIndex)
+{
+  TBBUTTON::iBitmap=bmIndex;
+}
+
+inline
+int TrackBarButton::cmdID(void)const
+{
+  return TBBUTTON::idCommand;
+}
+
+inline
+void TrackBarButton::cmdID(int cmdID)
+{
+  TBBUTTON::idCommand=cmdID;
+}
+
+inline
+BYTE TrackBarButton::state(void)const
+{
+  return TBBUTTON::fsState;
+}
+
+inline
+void TrackBarButton::state(BYTE state)
+{
+  TBBUTTON::fsState=state;
+}
+
+inline
+BYTE TrackBarButton::style(void)const
+{
+  return TBBUTTON::fsStyle;
+}
+
+inline
+void TrackBarButton::style(BYTE style)
+{
+  TBBUTTON::fsStyle=style;
+}
+
+inline
+DWORD TrackBarButton::appData(void)const
+{
+  return TBBUTTON::dwData;
+}
+
+inline
+void TrackBarButton::appData(DWORD appData)
+{
+  TBBUTTON::dwData=appData;
+}
+
+inline
+int TrackBarButton::strIndex(void)const
+{
+  return TBBUTTON::iString;
+}
+
+inline
+void TrackBarButton::strIndex(int strIndex)
+{
+  TBBUTTON::iString=strIndex;
+}
+
+inline
+void TrackBarButton::setZero(void)
+{
+  bmIndex(0);
+	cmdID(0);
+	state(0);
+	style(0);
+	appData(0);
+	strIndex(0);
+}
+#endif

wave/TRACKBAR.CPP

@@ -0,0 +1,122 @@
+#include <wave/trackbar.hpp>
+#include <common/instance.hpp>
+
+TrackBar::TrackBar(void)
+: mHorizontalScrollHandler(this,&TrackBar::horizontalScrollHandler),
+  mVerticalScrollHandler(this,&TrackBar::verticalScrollHandler),
+	mSizeHandler(this,&TrackBar::sizeHandler),
+	mlpParentWindow(0)
+{
+  for(short itemIndex=0;itemIndex<HandlerCount;itemIndex++)
+    mNotificationHandlers.insert(&CallbackPointer());
+}
+
+TrackBar::~TrackBar()
+{
+  if(!mlpParentWindow)return;
+	mlpParentWindow->removeHandler(VectorHandler::HorizontalScrollHandler,&mHorizontalScrollHandler);
+	mlpParentWindow->removeHandler(VectorHandler::VerticalScrollHandler,&mVerticalScrollHandler);
+	mlpParentWindow->removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
+}
+
+WORD TrackBar::createTrackBar(Window &parentWindow,Rect winRect,int itemID,WORD rubberControl)
+{
+  String className(String(TRACKBAR_CLASSA));
+
+  if(mTrackBar.isValid())return FALSE;
+	::InitCommonControls();
+  mlpParentWindow=&parentWindow;
+	mlpParentWindow->insertHandler(VectorHandler::HorizontalScrollHandler,&mHorizontalScrollHandler);
+	mlpParentWindow->insertHandler(VectorHandler::VerticalScrollHandler,&mVerticalScrollHandler);
+	if(rubberControl)mlpParentWindow->insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
+  if(!winRect.right()||!winRect.bottom())winRect=Rect(CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT);
+  mTrackBar=::CreateWindowEx(WS_EX_CLIENTEDGE|WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR,
+	  className,"",WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_TABSTOP|TBSAutoTicks|TBSBottom|TBSRight|TBSHorz|TBSEnableSelRange,
+		winRect.left(),winRect.top(),winRect.right(),winRect.bottom(),
+		parentWindow,(HMENU)itemID,parentWindow.processInstance(),0);
+	if(!mTrackBar.isValid())return FALSE;
+	initControl(parentWindow);
+	return TRUE;
+}
+
+CallbackData::ReturnType TrackBar::verticalScrollHandler(CallbackData &someCallbackData)
+{
+  switch(LOWORD(someCallbackData.wParam()))
+	{
+	  case TB_BOTTOM :
+		  mNotificationHandlers[NotifyBottom].callback(someCallbackData);
+			break;
+		case TB_ENDTRACK :
+		  mNotificationHandlers[NotifyEndTrack].callback(someCallbackData);
+			break;
+		case TB_LINEDOWN :
+		  mNotificationHandlers[NotifyLineDown].callback(someCallbackData);
+			break;
+		case TB_LINEUP :
+		  mNotificationHandlers[NotifyLineUp].callback(someCallbackData);
+			break;
+		case TB_PAGEDOWN :
+		  mNotificationHandlers[NotifyPageDown].callback(someCallbackData);
+			break;
+		case TB_PAGEUP :
+		  mNotificationHandlers[NotifyPageUp].callback(someCallbackData);
+			break;
+		case TB_THUMBPOSITION :
+		  mNotificationHandlers[NotifyThumbPosition].callback(someCallbackData);
+			break;
+		case TB_THUMBTRACK :
+		  mNotificationHandlers[NotifyThumbTrack].callback(someCallbackData);
+			break;
+		case TB_TOP :
+		  mNotificationHandlers[NotifyTop].callback(someCallbackData);
+			break;
+	}
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType TrackBar::horizontalScrollHandler(CallbackData &someCallbackData)
+{
+  switch(LOWORD(someCallbackData.wParam()))
+	{
+	  case TB_BOTTOM :
+		  mNotificationHandlers[NotifyBottom].callback(someCallbackData);
+			break;
+		case TB_ENDTRACK :
+		  mNotificationHandlers[NotifyEndTrack].callback(someCallbackData);
+			break;
+		case TB_LINEDOWN :
+		  mNotificationHandlers[NotifyLineDown].callback(someCallbackData);
+			break;
+		case TB_LINEUP :
+		  mNotificationHandlers[NotifyLineUp].callback(someCallbackData);
+			break;
+		case TB_PAGEDOWN :
+		  mNotificationHandlers[NotifyPageDown].callback(someCallbackData);
+			break;
+		case TB_PAGEUP :
+		  mNotificationHandlers[NotifyPageUp].callback(someCallbackData);
+			break;
+		case TB_THUMBPOSITION :
+		  mNotificationHandlers[NotifyThumbPosition].callback(someCallbackData);
+			break;
+		case TB_THUMBTRACK :
+		  mNotificationHandlers[NotifyThumbTrack].callback(someCallbackData);
+			break;
+		case TB_TOP :
+		  mNotificationHandlers[NotifyTop].callback(someCallbackData);
+			break;
+	}
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType TrackBar::sizeHandler(CallbackData &someCallbackData)
+{
+  if(!mlpParentWindow)return (CallbackData::ReturnType)FALSE;
+  moveControl(*mlpParentWindow,someCallbackData.loWord(),someCallbackData.hiWord());
+	return (CallbackData::ReturnType)FALSE;
+}
+
+Window &TrackBar::controlWindow(void)
+{
+  return mTrackBar;
+}

wave/TRACKBAR.HPP

@@ -0,0 +1,278 @@
+#ifndef _WAVE_TRACKBAR_HPP_
+#define _WAVE_TRACKBAR_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_RUBBERCONTROL_HPP_
+#include <common/rubber.hpp>
+#endif
+
+class TrackBar : private RubberControl
+{
+public:
+	enum {TBSAutoTicks=TBS_AUTOTICKS,TBSVert=TBS_VERT,TBSHorz=TBS_HORZ,TBSTop=TBS_TOP,
+	      TBSBottom=TBS_BOTTOM,TBSLeft=TBS_LEFT,TBSRight=TBS_RIGHT,TBSBoth=TBS_BOTH,
+				TBSNoTicks=TBS_NOTICKS,TBSEnableSelRange=TBS_ENABLESELRANGE,
+				TBSFixedLength=TBS_FIXEDLENGTH,TBSNoThumb=TBS_NOTHUMB};
+	enum HandlerType{NotifyBottom,NotifyEndTrack,NotifyLineDown,NotifyLineUp,NotifyTop,
+	                 NotifyPageDown,NotifyPageUp,NotifyThumbPosition,NotifyThumbTrack,HandlerCount};
+	TrackBar(void);
+	virtual ~TrackBar();
+	WORD createTrackBar(Window &parentWindow,Rect winRect=Rect(),int itemID=-1,WORD rubberControl=FALSE);
+	void clearSel(WORD redraw=TRUE)const;
+	void clearTics(WORD redraw=TRUE)const;
+	void getChannelRect(Rect &channelRect)const;
+	DWORD getLineSize(void)const;
+	DWORD getNumTics(void)const;
+	DWORD getPageSize(void)const;
+	DWORD getPos(void)const;
+	DWORD getPtrTics(void)const;
+	DWORD getRangeMax(void)const;
+	DWORD getRangeMin(void)const;
+	DWORD getSelEnd(void)const;
+	DWORD getSelStart(void)const;
+	DWORD getThumbLength(void)const;
+	void getThumbRect(Rect &thumbRect)const;
+	int getTic(WORD indexTic)const;
+	int getTicPos(WORD indexTic)const;
+	void setLineSize(LONG lineSize)const;
+	LONG setPageSize(LONG pageSize)const;
+	void setPos(LONG newPosition,WORD control=TRUE)const;
+	void setRange(WORD minPos,WORD maxPos,WORD redraw=TRUE)const;
+	void setRangeMax(LONG maxRange,WORD redraw=TRUE)const;
+	void setRangeMin(LONG minRange,WORD redraw=TRUE)const;
+	void setSel(WORD startPos,WORD endPos,WORD redraw=TRUE)const;
+  void setSelEnd(LONG endPos,WORD redraw=TRUE)const;
+	void setSelStart(LONG endPos,WORD redraw=TRUE)const;
+  void setThumbLength(UINT thumbLength)const;
+	WORD setTic(LONG position)const;
+	void setTicFreq(WORD frequency,LONG position)const;
+	WORD isOkay(void)const;
+	void insertHandler(HandlerType typeHandler,PureCallback *lpCallback);
+protected:
+  Window &controlWindow(void);
+private:
+  TrackBar(const TrackBar &someTrackBar);
+	TrackBar &operator=(const TrackBar &someTrackBar);
+	CallbackData::ReturnType verticalScrollHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType horizontalScrollHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+
+	Callback<TrackBar> mHorizontalScrollHandler;
+	Callback<TrackBar> mVerticalScrollHandler;
+	Callback<TrackBar> mSizeHandler;
+	Block<CallbackPointer> mNotificationHandlers;
+	Window mTrackBar;
+	Window *mlpParentWindow;
+};
+
+inline
+TrackBar::TrackBar(const TrackBar &/*someTrackBar*/)
+{
+}
+
+inline
+TrackBar &TrackBar::operator=(const TrackBar &/*someTrackBar*/)
+{
+  return *this;
+}
+
+inline
+void TrackBar::clearSel(WORD redraw)const
+{
+  if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_CLEARSEL,(WPARAM)redraw,0L);
+}
+
+inline
+void TrackBar::clearTics(WORD redraw)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_CLEARTICS,(WPARAM)redraw,0L);
+}
+
+inline
+void TrackBar::getChannelRect(Rect &channelRect)const
+{
+  if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_GETCHANNELRECT,0,(LPARAM)&((RECT&)channelRect));
+}
+
+inline
+DWORD TrackBar::getLineSize(void)const
+{
+  if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETLINESIZE,0,0L);
+}
+
+inline
+DWORD TrackBar::getNumTics(void)const
+{
+  if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETNUMTICS,0,0L);
+}
+
+inline
+DWORD TrackBar::getPos(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETPOS,0,0L);
+}
+
+inline
+DWORD TrackBar::getPtrTics(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETPTICS,0,0L);
+}
+
+inline
+DWORD TrackBar::getRangeMax(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETRANGEMAX,0,0L);
+}
+
+inline
+DWORD TrackBar::getRangeMin(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETRANGEMIN,0,0L);
+}
+
+inline
+DWORD TrackBar::getSelEnd(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETSELEND,0,0L);
+}
+
+inline
+DWORD TrackBar::getSelStart(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETSELSTART,0,0L);
+}
+
+inline
+DWORD TrackBar::getThumbLength(void)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_GETTHUMBLENGTH,0,0L);
+}
+
+inline
+void TrackBar::getThumbRect(Rect &thumbRect)const
+{
+  if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_GETTHUMBRECT,0,(LPARAM)&((RECT&)thumbRect));
+}
+
+inline
+int TrackBar::getTic(WORD indexTic)const
+{
+	if(!isOkay())return -1;
+	return mTrackBar.sendMessage(TBM_GETTIC,(WPARAM)indexTic,0L);
+}
+
+inline
+int TrackBar::getTicPos(WORD indexTic)const
+{
+  if(!isOkay())return -1;
+	return mTrackBar.sendMessage(TBM_GETTICPOS,(WPARAM)indexTic,0L);
+}
+
+inline
+void TrackBar::setLineSize(LONG lineSize)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETLINESIZE,0,lineSize);
+}
+
+inline
+LONG TrackBar::setPageSize(LONG pageSize)const
+{
+  if(!isOkay())return -1;
+	return mTrackBar.sendMessage(TBM_SETPAGESIZE,0,pageSize);
+}
+
+inline
+void TrackBar::setPos(LONG newPosition,WORD control)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETPOS,(WPARAM)control,(LPARAM)newPosition);
+}
+
+inline
+void TrackBar::setRange(WORD minPos,WORD maxPos,WORD redraw)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETRANGE,(WPARAM)redraw,(LPARAM)MAKELONG(minPos,maxPos));
+}
+
+inline
+void TrackBar::setRangeMax(LONG maxRange,WORD redraw)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETRANGEMAX,(WPARAM)redraw,maxRange);
+}
+
+inline
+void TrackBar::setSel(WORD startPos,WORD endPos,WORD redraw)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETSEL,(WPARAM)redraw,(LPARAM)MAKELONG(startPos,endPos));
+}
+
+inline
+void TrackBar::setSelEnd(LONG endPos,WORD redraw)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETSELEND,(WPARAM)redraw,(LPARAM)endPos);
+}
+
+inline
+void TrackBar::setSelStart(LONG startPos,WORD redraw)const
+{
+	if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETSELSTART,(WPARAM)redraw,(LPARAM)startPos);
+}
+
+inline
+void TrackBar::setThumbLength(UINT thumbLength)const
+{                                                    
+  if(!isOkay())return;
+	mTrackBar.sendMessage(TBM_SETTHUMBLENGTH,(WPARAM)thumbLength,0L);
+}
+
+inline
+WORD TrackBar::setTic(LONG position)const
+{
+	if(!isOkay())return FALSE;
+	return mTrackBar.sendMessage(TBM_SETTIC,(WPARAM)0,(LPARAM)position);
+}
+
+inline
+void TrackBar::insertHandler(HandlerType typeHandler,PureCallback *lpCallback)
+{
+  mNotificationHandlers[typeHandler]=CallbackPointer(lpCallback);
+}
+
+inline
+WORD TrackBar::isOkay(void)const
+{
+  return mTrackBar.isValid();
+}
+#endif

wave/WAVE.HPP

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

wave/WAVUTIL.DSW

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Wavutil"=.\Wavutil.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

wave/Wavutil.001

@@ -0,0 +1,84 @@
+# Microsoft Developer Studio Project File - Name="Wavutil" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) External Target" 0x0106
+
+CFG=Wavutil - 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 "Wavutil.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 "Wavutil.mak" CFG="Wavutil - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Wavutil - Win32 Release" (based on "Win32 (x86) External Target")
+!MESSAGE "Wavutil - Win32 Debug" (based on "Win32 (x86) External Target")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+
+!IF  "$(CFG)" == "Wavutil - Win32 Release"
+
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP BASE Rebuild_Opt "/a"
+# PROP BASE Target_File "Wavutil.exe"
+# PROP BASE Bsc_Name "Wavutil.bsc"
+# PROP BASE Target_Dir ""
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP Rebuild_Opt "/a"
+# PROP Target_File "Wavutil.exe"
+# PROP Bsc_Name "Wavutil.bsc"
+# PROP Target_Dir ""
+
+!ELSEIF  "$(CFG)" == "Wavutil - Win32 Debug"
+
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP BASE Rebuild_Opt "/a"
+# PROP BASE Target_File "Wavutil.exe"
+# PROP BASE Bsc_Name "Wavutil.bsc"
+# PROP BASE Target_Dir ""
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP Rebuild_Opt "/a"
+# PROP Target_File "Wavutil.exe"
+# PROP Bsc_Name "Wavutil.bsc"
+# PROP Target_Dir ""
+
+!ENDIF 
+
+# Begin Target
+
+# Name "Wavutil - Win32 Release"
+# Name "Wavutil - Win32 Debug"
+
+!IF  "$(CFG)" == "Wavutil - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "Wavutil - Win32 Debug"
+
+!ENDIF 
+
+# Begin Source File
+
+SOURCE=.\Wavutil.dsw
+# End Source File
+# End Target
+# End Project

wave/Wavutil.dsp

@@ -0,0 +1,85 @@
+# Microsoft Developer Studio Project File - Name="Wavutil" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) External Target" 0x0106
+
+CFG=Wavutil - 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 "Wavutil.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 "Wavutil.mak" CFG="Wavutil - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Wavutil - Win32 Release" (based on "Win32 (x86) External Target")
+!MESSAGE "Wavutil - Win32 Debug" (based on "Win32 (x86) External Target")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+
+!IF  "$(CFG)" == "Wavutil - Win32 Release"
+
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP BASE Rebuild_Opt "/a"
+# PROP BASE Target_File "Wavutil.exe"
+# PROP BASE Bsc_Name "Wavutil.bsc"
+# PROP BASE Target_Dir ""
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP Rebuild_Opt "/a"
+# PROP Target_File "Wavutil.exe"
+# PROP Bsc_Name "Wavutil.bsc"
+# PROP Target_Dir ""
+
+!ELSEIF  "$(CFG)" == "Wavutil - Win32 Debug"
+
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP BASE Rebuild_Opt "/a"
+# PROP BASE Target_File "Wavutil.exe"
+# PROP BASE Bsc_Name "Wavutil.bsc"
+# PROP BASE Target_Dir ""
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Cmd_Line "NMAKE /f Wavutil.mak"
+# PROP Rebuild_Opt "/a"
+# PROP Target_File "Wavutil.exe"
+# PROP Bsc_Name "Wavutil.bsc"
+# PROP Target_Dir ""
+
+!ENDIF 
+
+# Begin Target
+
+# Name "Wavutil - Win32 Release"
+# Name "Wavutil - Win32 Debug"
+
+!IF  "$(CFG)" == "Wavutil - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "Wavutil - Win32 Debug"
+
+!ENDIF 
+
+# Begin Source File
+
+SOURCE=.\Wavutil.dsw
+# End Source File
+# End Target
+# End Project