Initial

imagelst/BCCW32.CFG

@@ -0,0 +1,25 @@
+-R
+-v
+-vi
+-H
+-H=propsht.csm
+-R-
+-H-
+-4
+-Jgx
+-x-
+-xd-
+-RT-
+-Og
+-Ot
+-Z
+-O
+-Oe
+-Ol
+-Ob
+-OW
+-Om
+-Op
+-Oi
+-Ov
+-W

imagelst/DRAGINFO.HPP

@@ -0,0 +1,82 @@
+#ifndef _IMAGELIST_DRAGINFO_HPP_
+#define _IMAGELIST_DRAGINFO_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+
+class DragInfo
+{
+public:
+	DragInfo(void);
+	DragInfo(const DragInfo &someDragInfo);
+	~DragInfo();
+	DragInfo &operator=(const DragInfo &someDragInfo);
+  WORD operator==(const DragInfo &someDragInfo)const;
+	WORD isInDrag(void)const;
+	void isInDrag(WORD isInDrag);
+	TreeViewItem dragItem(void)const;
+	void dragItem(const TreeViewItem &someTreeViewItem);
+private:
+	WORD mIsInDrag;
+	TreeViewItem mDragItem;
+};
+
+inline
+DragInfo::DragInfo(void)
+: mIsInDrag(FALSE)
+{
+}
+
+inline
+DragInfo::DragInfo(const DragInfo &someDragInfo)
+{
+	*this=someDragInfo;
+}
+
+inline
+DragInfo::~DragInfo()
+{
+}
+
+inline
+DragInfo &DragInfo::operator=(const DragInfo &someDragInfo)
+{
+	isInDrag(someDragInfo.isInDrag());
+	dragItem(someDragInfo.dragItem());
+  return *this;
+}
+
+inline
+WORD DragInfo::operator==(const DragInfo &someDragInfo)const
+{
+	return (isInDrag()==someDragInfo.isInDrag()&&
+          dragItem()==someDragInfo.dragItem());
+}
+
+inline
+WORD DragInfo::isInDrag(void)const
+{
+	return  mIsInDrag;
+}
+
+inline
+void DragInfo::isInDrag(WORD isInDrag)
+{
+	mIsInDrag=isInDrag;
+}
+
+inline
+TreeViewItem DragInfo::dragItem(void)const
+{
+	return mDragItem;
+}
+
+inline
+void DragInfo::dragItem(const TreeViewItem &someTreeViewItem)
+{
+  mDragItem=someTreeViewItem;
+}
+#endif

imagelst/FTREE.BAK

@@ -0,0 +1,54 @@
+#ifndef _IMAGELIST_FOLDERTREE_HPP_
+#define _IMAGELIST_FOLDERTREE_HPP_
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+#ifndef _COMMON_RGBCOLOR_HPP_
+#include <common/rgbcolor.hpp>
+#endif
+#ifndef _COMMON_CALLBACKPOINTER_HPP_
+#include <common/cbptr.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEW_HPP_
+#include <imagelst/treeview.hpp>
+#endif
+#ifndef _IMAGELIST_IMAGELIST_HPP_
+#include <imagelst/imagelst.hpp>
+#endif
+
+class TreeViewMessageHeader;
+class TreeViewDisplayInfo;
+class Rect;
+
+class FolderTree : public TreeView, public ImageList
+{
+public:
+	enum{FolderOpen=0,FolderClosed=2};
+	enum HandlerType{SelChangedHandler,SelChangingHandler,ItemExpandingHandler,ItemExpandedHandler,BeginDragHandler};
+	FolderTree(GUIWindow &parentWindow,const Rect &winRect=Rect(1,1,320,200),int controlID=101,RGBColor bkColor=RGBColor(::GetSysColor(COLOR_WINDOW)));
+	virtual ~FolderTree();
+	void insertHandler(HandlerType handlerType,PureCallback *lpCallback);
+	void removeHandler(HandlerType handlerType);
+protected:
+	virtual WORD tvnSelChanging(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnSelChanged(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnGetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnSetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnItemExpanding(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnItemExpanded(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginDrag(const TreeViewMessageHeader &TreeViewMessageHeader);
+	virtual WORD tvnBeginRDrag(const TreeViewMessageHeader &TreeViewMessageHeader);
+	virtual WORD tvnDeleteItem(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnEndLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnKeyDown(const TreeViewMessageHeader &treeViewMessageHeader);
+private:
+  void callHandler(HandlerType handlerType,CallbackData &someCallbackData);
+	void initHandlers(void);
+
+	Block<CallbackPointer> mEventHandlers;
+};
+#endif

imagelst/FTREE.CPP

@@ -0,0 +1,122 @@
+#include <imagelst/ftree.hpp>
+#include <imagelst/tvmsghdr.hpp>
+#include <imagelst/tvdisp.hpp>
+#include <imagelst/tvkey.hpp>
+#include <common/window.hpp>
+#include <common/dwindow.hpp>
+#include <common/rect.hpp>
+
+FolderTree::FolderTree(GUIWindow &parentWindow,const Rect &winRect,int controlID,RGBColor bkColor)
+: TreeView(parentWindow,winRect,controlID,TreeView::TreeHasLines|TreeView::TreeHasButtons|TreeView::TreeLinesAtRoot|TreeView::TreeShowSelAlways),
+	ImageList(parentWindow.processInstance(),"LIST",16,RGBColor(0,0,255))
+{
+	setBkColor(bkColor);
+	setImageList(*this);
+	initHandlers();
+}
+
+FolderTree::~FolderTree()
+{
+}
+
+void FolderTree::insertHandler(HandlerType handlerType,PureCallback *lpCallback)
+{
+  mEventHandlers[(int)handlerType]=CallbackPointer(lpCallback);
+}
+
+void FolderTree::removeHandler(HandlerType handlerType)
+{
+  mEventHandlers[(int)handlerType]=CallbackPointer();
+}
+
+void FolderTree::callHandler(HandlerType handlerType,CallbackData &someCallbackData)
+{
+  mEventHandlers[(int)handlerType].callback(someCallbackData);
+}
+
+void FolderTree::initHandlers(void)
+{
+  for(int handlerIndex=0;handlerIndex<=KeyDownHandler;handlerIndex++)
+	  mEventHandlers.insert(&CallbackPointer());
+}
+
+// virual overloads
+
+WORD FolderTree::tvnSelChanging(const TreeViewMessageHeader &treeViewMessageHeader)
+{
+  CallbackData callbackData(0,treeViewMessageHeader.itemOld().lParam());
+	callHandler(SelChangingHandler,callbackData);
+	return FALSE;
+}
+
+WORD FolderTree::tvnSelChanged(const TreeViewMessageHeader &treeViewMessageHeader)
+{
+	CallbackData callbackData(0,treeViewMessageHeader.itemNew().lParam());
+	callHandler(SelChangedHandler,callbackData);
+	return FALSE;
+}
+
+WORD FolderTree::tvnItemExpanding(const TreeViewMessageHeader &treeViewMessageHeader)
+{
+  CallbackData callbackData(0,(LPARAM)&treeViewMessageHeader);
+	callHandler(ItemExpandingHandler,callbackData);
+  return FALSE;
+}
+
+WORD FolderTree::tvnItemExpanded(const TreeViewMessageHeader &treeViewMessageHeader)
+{
+  CallbackData callbackData(0,(LPARAM)&treeViewMessageHeader);
+	callHandler(ItemExpandedHandler,callbackData);
+  return FALSE;
+}
+
+WORD FolderTree::tvnGetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo)
+{
+  TreeViewItem tvItem(treeViewDisplayInfo.item());
+
+  if(treeViewDisplayInfo.item().state()&TVIS_EXPANDED)
+	  {tvItem.image(FolderOpen);tvItem.selectedImage(FolderOpen);}
+	else
+	  {tvItem.image(FolderClosed);tvItem.selectedImage(FolderClosed);}
+	treeViewDisplayInfo.item(tvItem);
+	return TRUE;
+}
+
+WORD FolderTree::tvnSetDispInfo(TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD FolderTree::tvnBeginDrag(const TreeViewMessageHeader &treeViewMessageHeader)
+{
+  CallbackData callbackData(0,(LPARAM)&treeViewMessageHeader);
+	callHandler(BeginDragHandler,callbackData);
+  return FALSE;
+}
+
+WORD FolderTree::tvnBeginRDrag(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD FolderTree::tvnDeleteItem(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD FolderTree::tvnBeginLabelEdit(const TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD FolderTree::tvnEndLabelEdit(const TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD FolderTree::tvnKeyDown(const TreeViewKeyDown &treeViewKeyDown)
+{
+  CallbackData callbackData(0,(LPARAM)&treeViewKeyDown);
+	callHandler(KeyDownHandler,callbackData);
+  return FALSE;
+}

imagelst/FTREE.HPP

@@ -0,0 +1,56 @@
+#ifndef _IMAGELIST_FOLDERTREE_HPP_
+#define _IMAGELIST_FOLDERTREE_HPP_
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+#ifndef _COMMON_RGBCOLOR_HPP_
+#include <common/rgbcolor.hpp>
+#endif
+#ifndef _COMMON_CALLBACKPOINTER_HPP_
+#include <common/cbptr.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEW_HPP_
+#include <imagelst/treeview.hpp>
+#endif
+#ifndef _IMAGELIST_IMAGELIST_HPP_
+#include <imagelst/imagelst.hpp>
+#endif
+
+class TreeViewMessageHeader;
+class TreeViewDisplayInfo;
+class TreeViewKeyDown;
+class Rect;
+
+class FolderTree : public TreeView, public ImageList
+{
+public:
+	enum{FolderOpen=0,FolderClosed=2};
+	enum HandlerType{SelChangedHandler,SelChangingHandler,ItemExpandingHandler,
+	  ItemExpandedHandler,BeginDragHandler,KeyDownHandler};
+	FolderTree(GUIWindow &parentWindow,const Rect &winRect=Rect(1,1,320,200),int controlID=101,RGBColor bkColor=RGBColor(GetSysColor(COLOR_WINDOW)));
+	virtual ~FolderTree();
+	void insertHandler(HandlerType handlerType,PureCallback *lpCallback);
+	void removeHandler(HandlerType handlerType);
+protected:
+	virtual WORD tvnSelChanging(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnSelChanged(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnGetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnSetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnItemExpanding(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnItemExpanded(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginDrag(const TreeViewMessageHeader &TreeViewMessageHeader);
+	virtual WORD tvnBeginRDrag(const TreeViewMessageHeader &TreeViewMessageHeader);
+	virtual WORD tvnDeleteItem(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnEndLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnKeyDown(const TreeViewKeyDown &treeViewKeyDown);
+private:
+  void callHandler(HandlerType handlerType,CallbackData &someCallbackData);
+	void initHandlers(void);
+
+	Block<CallbackPointer> mEventHandlers;
+};
+#endif

imagelst/FTREE.MAK

@@ -0,0 +1,208 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+!IF "$(CFG)" == ""
+CFG=Ftree - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to Ftree - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "Ftree - Win32 Release" && "$(CFG)" != "Ftree - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Ftree.mak" CFG="Ftree - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Ftree - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Ftree - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "Ftree - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+OUTDIR=.
+INTDIR=.
+
+ALL : "$(OUTDIR)\Ftree.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Ftree.obj"
+	-@erase "$(OUTDIR)\Ftree.exe"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\
+ /Fp"Ftree.pch" /YX /c 
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Ftree.bsc" 
+BSC32_SBRS= \
+	
+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:console /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:console /machine:I386
+LINK32_FLAGS=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:console /incremental:no\
+ /pdb:"$(OUTDIR)/Ftree.pdb" /machine:I386 /out:"$(OUTDIR)/Ftree.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\Ftree.obj"
+
+"$(OUTDIR)\Ftree.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "Ftree - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+OUTDIR=.
+INTDIR=.
+
+ALL : "$(OUTDIR)\Ftree.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Ftree.obj"
+	-@erase "$(INTDIR)\vc40.idb"
+	-@erase "$(INTDIR)\vc40.pdb"
+	-@erase "$(OUTDIR)\Ftree.exe"
+	-@erase "$(OUTDIR)\Ftree.ilk"
+	-@erase "$(OUTDIR)\Ftree.pdb"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MLd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE"\
+ /Fp"Ftree.pch" /YX /c 
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Ftree.bsc" 
+BSC32_SBRS= \
+	
+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:console /debug /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:console /debug /machine:I386
+LINK32_FLAGS=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:console /incremental:yes\
+ /pdb:"$(OUTDIR)/Ftree.pdb" /debug /machine:I386 /out:"$(OUTDIR)/Ftree.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\Ftree.obj"
+
+"$(OUTDIR)\Ftree.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "Ftree - Win32 Release"
+# Name "Ftree - Win32 Debug"
+
+!IF  "$(CFG)" == "Ftree - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "Ftree - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Ftree.cpp
+DEP_CPP_FTREE=\
+	{$(INCLUDE)}"\.\draginfo.hpp"\
+	{$(INCLUDE)}"\.\ftree.hpp"\
+	{$(INCLUDE)}"\.\hittest.hpp"\
+	{$(INCLUDE)}"\.\imagelst.hpp"\
+	{$(INCLUDE)}"\.\treeview.hpp"\
+	{$(INCLUDE)}"\.\tvinsert.hpp"\
+	{$(INCLUDE)}"\.\tvitem.hpp"\
+	{$(INCLUDE)}"\common\assert.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\commctrl.hpp"\
+	{$(INCLUDE)}"\common\dwindow.hpp"\
+	{$(INCLUDE)}"\common\fixup.hpp"\
+	{$(INCLUDE)}"\common\gdata.hpp"\
+	{$(INCLUDE)}"\common\gdata.tpp"\
+	{$(INCLUDE)}"\common\gdiobj.hpp"\
+	{$(INCLUDE)}"\common\iconinfo.hpp"\
+	{$(INCLUDE)}"\common\instance.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\common\pen.hpp"\
+	{$(INCLUDE)}"\common\point.hpp"\
+	{$(INCLUDE)}"\common\purebmp.hpp"\
+	{$(INCLUDE)}"\common\purehdc.hpp"\
+	{$(INCLUDE)}"\common\pureicon.hpp"\
+	{$(INCLUDE)}"\common\pvector.hpp"\
+	{$(INCLUDE)}"\common\pvector.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\types.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\common\window.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	
+
+"$(INTDIR)\Ftree.obj" : $(SOURCE) $(DEP_CPP_FTREE) "$(INTDIR)"
+
+
+# End Source File
+# End Target
+# End Project
+################################################################################

imagelst/HITTEST.HPP

@@ -0,0 +1,115 @@
+#ifndef _IMAGELIST_HITTEST_HPP_
+#define _IMAGELIST_HITTEST_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _COMMON_GDIPOINT_HPP_
+#include <common/gdipoint.hpp>
+#endif
+
+class HitTestInfo : private TV_HITTESTINFO
+{
+public:
+  enum{HitTestAbove=TVHT_ABOVE,HitTestBelow=TVHT_BELOW,HitTestNoWhere=TVHT_NOWHERE,
+	     HitTestOnItem=TVHT_ONITEM,HitTestOnItemButton=TVHT_ONITEMBUTTON,
+			 HitTestOnItemIcon=TVHT_ONITEMICON,HitTestOnItemIndent=TVHT_ONITEMINDENT,
+			 HitTestOnItemLabel=TVHT_ONITEMLABEL,HitTestOnItemRight=TVHT_ONITEMRIGHT,
+			 HitTestToLeft=TVHT_TOLEFT,HitTestToRight=TVHT_TORIGHT};
+	HitTestInfo(void);
+	HitTestInfo(const HitTestInfo &someHitTestInfo);
+	~HitTestInfo();
+	HitTestInfo &operator=(const HitTestInfo &someHitTestInfo);
+	WORD operator==(const HitTestInfo &someHitTestInfo);
+  operator TV_HITTESTINFO&(void);
+	GDIPoint point(void)const;
+	void point(const GDIPoint &somePoint);
+	UINT flags(void)const;
+	void flags(UINT flags);
+	HTREEITEM item(void)const;
+	void item(HTREEITEM item);
+private:
+};
+
+inline
+HitTestInfo::HitTestInfo(void)
+{
+	point(GDIPoint(0,0));
+	flags(0);
+  item(0);
+}
+
+inline
+HitTestInfo::HitTestInfo(const HitTestInfo &someHitTestInfo)
+{
+	*this=someHitTestInfo;
+}
+
+inline
+HitTestInfo::~HitTestInfo()
+{
+}
+
+inline
+HitTestInfo &HitTestInfo::operator=(const HitTestInfo &someHitTestInfo)
+{
+	point(someHitTestInfo.point());
+	flags(someHitTestInfo.flags());
+	item(someHitTestInfo.item());
+	return *this;
+}
+
+inline
+WORD HitTestInfo::operator==(const HitTestInfo &someHitTestInfo)
+{
+	return (point()==someHitTestInfo.point()&&
+					flags()==someHitTestInfo.flags()&&
+					item()==someHitTestInfo.item());
+}
+
+inline
+HitTestInfo::operator TV_HITTESTINFO&(void)
+{
+	return *this;
+}
+
+inline
+GDIPoint HitTestInfo::point(void)const
+{
+	return GDIPoint(TV_HITTESTINFO::pt.x,TV_HITTESTINFO::pt.y);
+}
+
+inline
+void HitTestInfo::point(const GDIPoint &somePoint)
+{
+	TV_HITTESTINFO::pt.x=somePoint.x();
+  TV_HITTESTINFO::pt.y=somePoint.y();
+}
+
+inline
+UINT HitTestInfo::flags(void)const
+{
+	return TV_HITTESTINFO::flags;
+}
+
+inline
+void HitTestInfo::flags(UINT flags)
+{
+	TV_HITTESTINFO::flags=flags;
+}
+
+inline
+HTREEITEM HitTestInfo::item(void)const
+{
+	return TV_HITTESTINFO::hItem;
+}
+
+inline
+void HitTestInfo::item(HTREEITEM item)
+{
+	TV_HITTESTINFO::hItem=item;
+}
+#endif
+

imagelst/IMAGELST.BAK

@@ -0,0 +1,128 @@
+#include <imagelst/imagelst.hpp>
+#include <imagelst/imgeinfo.hpp>
+#include <common/gdipoint.hpp>
+#include <common/point.hpp>
+#include <common/purebmp.hpp>
+#include <common/pureicon.hpp>
+
+ImageList::ImageList(HINSTANCE hProcessInstance,const String &bitmapName,DWORD widthImage,RGBColor maskColor,DWORD growthFactor)
+: mhImageList(0), mhProcessInstance(hProcessInstance)
+{
+	mhImageList=::ImageList_LoadBitmap(hProcessInstance,bitmapName,widthImage,growthFactor,maskColor);
+}
+
+ImageList &ImageList::operator=(HIMAGELIST hImageList)
+{
+  destroyImageList();
+	mhImageList=hImageList;
+	return *this;
+}
+
+ImageList &ImageList::operator=(const ImageList &someImageList)
+{
+	DWORD sourceImageListEntries;
+	Point imageDimensions;
+	ImageType imageType;
+
+	if(!mhProcessInstance)return *this;
+	if(someImageList.isOkay()&&(0!=(sourceImageListEntries=someImageList.size())))
+	{
+		someImageList.imageDimensions(imageDimensions);
+		imageType=someImageList.imageType();
+		if(createImageList(imageDimensions.x(),imageDimensions.y(),imageType))
+		{
+			for(DWORD itemIndex=0;itemIndex<sourceImageListEntries;itemIndex++)
+				insertImage(PureIcon(someImageList.extractIcon(itemIndex)));
+		}
+	}
+	return *this;
+}
+
+WORD ImageList::drawImage(PureDevice &somePureDevice,const Point &xyPoint,DWORD itemIndex,DrawFlag drawFlag)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_Draw(mhImageList,itemIndex,somePureDevice,xyPoint.x(),xyPoint.y(),(UINT)drawFlag);
+}
+
+WORD ImageList::imageDimensions(Point &imageDimensions)const
+{
+	int cxDimension;
+	int cyDimension;
+  WORD returnCode;
+
+	if(!isOkay())return FALSE;
+	returnCode=::ImageList_GetIconSize(mhImageList,&cxDimension,&cyDimension);
+	imageDimensions.x(cxDimension);
+	imageDimensions.y(cyDimension);
+	return returnCode;
+}
+
+BOOL ImageList::beginDrag(DWORD itemIndex,const GDIPoint &dragPoint)const
+{
+  if(!isOkay())return FALSE;
+  return ImageList_BeginDrag(mhImageList,itemIndex,dragPoint.x(),dragPoint.y());
+}
+
+BOOL ImageList::dragMove(const GDIPoint &dragPoint)const
+{
+  return ImageList_DragMove(dragPoint.x(),dragPoint.y());
+}
+
+BOOL ImageList::dragEnter(HWND hwndLock,const GDIPoint &imagePoint)const
+{
+  return ImageList_DragEnter(hwndLock,imagePoint.x(),imagePoint.y());
+}
+
+BOOL ImageList::dragLeave(HWND hwndLock)const
+{
+  return ImageList_DragLeave(hwndLock);
+}
+
+BOOL ImageList::setDragCursorImage(int itemIndex,const GDIPoint &hotSpot)
+{
+  if(!isOkay())return FALSE;
+	return ImageList_SetDragCursorImage(mhImageList,itemIndex,hotSpot.x(),hotSpot.y());
+}
+
+WORD ImageList::insertImage(const PureBitmap &colorBitmap)
+{
+	return insertImage(colorBitmap,PureBitmap());
+}
+
+WORD ImageList::insertImage(const PureBitmap &colorBitmap,const PureBitmap &maskBitmap)
+{
+	if(!isOkay())return FALSE;
+	if(maskBitmap.isOkay())return ::ImageList_Add(mhImageList,colorBitmap,maskBitmap);
+	return ::ImageList_Add(mhImageList,colorBitmap,0);
+}
+
+WORD ImageList::insertImage(const PureBitmap &colorBitmap,const RGBColor &maskColor)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_AddMasked(mhImageList,colorBitmap,(COLORREF)maskColor);
+}
+
+WORD ImageList::replaceImage(DWORD itemIndex,const PureBitmap &colorBitmap,const PureBitmap &maskBitmap)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_Replace(mhImageList,itemIndex,colorBitmap,maskBitmap);
+}
+
+WORD ImageList::insertImage(PureIcon &somePureIcon)
+{
+	if(!isOkay())return FALSE;
+	return !::ImageList_AddIcon(mhImageList,(HICON)somePureIcon);
+}
+
+WORD ImageList::replaceImage(DWORD itemIndex,PureIcon &somePureIcon)
+{
+  if(!isOkay())return FALSE;
+	return ::ImageList_ReplaceIcon(mhImageList,itemIndex,(HICON)somePureIcon);
+}
+
+BOOL ImageList::imageInfo(int itemIndex,ImageInfo &imageInfo)
+{
+  if(!isOkay())return FALSE;
+	return ::ImageList_GetImageInfo(mhImageList,itemIndex,&((_IMAGEINFO&)imageInfo));
+}
+

imagelst/IMAGELST.CPP

@@ -0,0 +1,128 @@
+#include <imagelst/imagelst.hpp>
+#include <imagelst/imgeinfo.hpp>
+#include <common/gdipoint.hpp>
+#include <common/point.hpp>
+#include <common/purebmp.hpp>
+#include <common/pureicon.hpp>
+
+ImageList::ImageList(HINSTANCE hProcessInstance,const String &bitmapName,DWORD widthImage,RGBColor maskColor,DWORD growthFactor)
+: mhImageList(0), mhProcessInstance(hProcessInstance)
+{
+	mhImageList=::ImageList_LoadBitmap(hProcessInstance,bitmapName,widthImage,growthFactor,maskColor);
+}
+
+ImageList &ImageList::operator=(HIMAGELIST hImageList)
+{
+  destroyImageList();
+	mhImageList=hImageList;
+	return *this;
+}
+
+ImageList &ImageList::operator=(const ImageList &someImageList)
+{
+	DWORD sourceImageListEntries;
+	Point imageDimensions;
+	ImageType imageType;
+
+	if(!mhProcessInstance)return *this;
+	if(someImageList.isOkay()&&(0!=(sourceImageListEntries=someImageList.size())))
+	{
+		someImageList.imageDimensions(imageDimensions);
+		imageType=someImageList.imageType();
+		if(createImageList(imageDimensions.x(),imageDimensions.y(),imageType))
+		{
+			for(DWORD itemIndex=0;itemIndex<sourceImageListEntries;itemIndex++)
+				insertImage(PureIcon(someImageList.extractIcon(itemIndex)));
+		}
+	}
+	return *this;
+}
+
+WORD ImageList::drawImage(PureDevice &somePureDevice,const Point &xyPoint,DWORD itemIndex,DrawFlag drawFlag)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_Draw(mhImageList,itemIndex,somePureDevice,xyPoint.x(),xyPoint.y(),(UINT)drawFlag);
+}
+
+WORD ImageList::imageDimensions(Point &imageDimensions)const
+{
+	int cxDimension;
+	int cyDimension;
+  WORD returnCode;
+
+	if(!isOkay())return FALSE;
+	returnCode=::ImageList_GetIconSize(mhImageList,&cxDimension,&cyDimension);
+	imageDimensions.x(cxDimension);
+	imageDimensions.y(cyDimension);
+	return returnCode;
+}
+
+BOOL ImageList::beginDrag(DWORD itemIndex,const GDIPoint &dragPoint)const
+{
+  if(!isOkay())return FALSE;
+  return ImageList_BeginDrag(mhImageList,itemIndex,dragPoint.x(),dragPoint.y());
+}
+
+BOOL ImageList::dragMove(const GDIPoint &dragPoint)const
+{
+  return ImageList_DragMove(dragPoint.x(),dragPoint.y());
+}
+
+BOOL ImageList::dragEnter(HWND hwndLock,const GDIPoint &imagePoint)const
+{
+  return ImageList_DragEnter(hwndLock,imagePoint.x(),imagePoint.y());
+}
+
+BOOL ImageList::dragLeave(HWND hwndLock)const
+{
+  return ImageList_DragLeave(hwndLock);
+}
+
+BOOL ImageList::setDragCursorImage(int itemIndex,const GDIPoint &hotSpot)
+{
+  if(!isOkay())return FALSE;
+	return ImageList_SetDragCursorImage(mhImageList,itemIndex,hotSpot.x(),hotSpot.y());
+}
+
+WORD ImageList::insertImage(const PureBitmap &colorBitmap)
+{
+	return insertImage(colorBitmap,PureBitmap());
+}
+
+WORD ImageList::insertImage(const PureBitmap &colorBitmap,const PureBitmap &maskBitmap)
+{
+	if(!isOkay())return FALSE;
+	if(maskBitmap.isOkay())return ::ImageList_Add(mhImageList,colorBitmap,maskBitmap);
+	return ::ImageList_Add(mhImageList,colorBitmap,0);
+}
+
+WORD ImageList::insertImage(const PureBitmap &colorBitmap,const RGBColor &maskColor)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_AddMasked(mhImageList,colorBitmap,(COLORREF)maskColor);
+}
+
+WORD ImageList::replaceImage(DWORD itemIndex,const PureBitmap &colorBitmap,const PureBitmap &maskBitmap)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_Replace(mhImageList,itemIndex,colorBitmap,maskBitmap);
+}
+
+WORD ImageList::insertImage(PureIcon &somePureIcon)
+{
+	if(!isOkay())return FALSE;
+	return !::ImageList_AddIcon(mhImageList,(HICON)somePureIcon);
+}
+
+WORD ImageList::replaceImage(DWORD itemIndex,PureIcon &somePureIcon)
+{
+  if(!isOkay())return FALSE;
+	return ::ImageList_ReplaceIcon(mhImageList,itemIndex,(HICON)somePureIcon);
+}
+
+BOOL ImageList::imageInfo(int itemIndex,ImageInfo &imageInfo)
+{
+  if(!isOkay())return FALSE;
+	return ::ImageList_GetImageInfo(mhImageList,itemIndex,&((_IMAGEINFO&)imageInfo));
+}
+

imagelst/IMAGELST.DSW

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

imagelst/IMAGELST.HPP

@@ -0,0 +1,205 @@
+#ifndef _IMAGELIST_IMAGELIST_HPP_
+#define _IMAGELIST_IMAGELIST_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _COMMON_RGBCOLOR_HPP_
+#include <common/rgbcolor.hpp>
+#endif
+
+class GDIPoint;
+class Point;
+class PureBitmap;
+class PureDevice;
+class PureIcon;
+class String;
+class ImageInfo;
+
+class ImageList
+{
+public:
+	enum ImageType{ImageMasked=0x0000,ImageUnMasked=0x0001};
+	enum DrawFlag{DrawNormal=ILD_NORMAL,DrawTransparent=ILD_TRANSPARENT,DrawMask=ILD_MASK,
+								DrawImage=ILD_IMAGE,DrawBlend25=ILD_BLEND25,DrawBlend50=ILD_BLEND50,
+								DrawOverlayMask=ILD_OVERLAYMASK};
+	ImageList(HINSTANCE hProcessInstance=(HINSTANCE)0);       
+	ImageList(HIMAGELIST hImageList,HINSTANCE hProcessInstance=(HINSTANCE)0,ImageType imageType=ImageUnMasked);
+	ImageList(const ImageList &someImageList);
+	ImageList(HINSTANCE hProcessInstance,const String &bitmapName,DWORD widthImage,RGBColor maskColor=RGBColor(),DWORD growthFactor=1);
+	ImageList(HINSTANCE hProcessInstance,DWORD widthImage,DWORD heightImage,ImageType imageType=ImageUnMasked,DWORD initialCount=0,DWORD growthFactor=1);
+	virtual ~ImageList();
+	ImageList &operator=(const ImageList &someImageList);
+	ImageList &operator=(HIMAGELIST hImageList);
+	WORD operator==(const ImageList &someImageList);
+	operator HIMAGELIST(void);
+  WORD insertImage(HBITMAP hBitmap);
+	WORD insertImage(const PureBitmap &colorBitmap);
+	WORD insertImage(const PureBitmap &colorBitmap,const PureBitmap &maskBitmap);
+	WORD insertImage(const PureBitmap &colorBitmap,const RGBColor &maskColor);
+	WORD insertImage(PureIcon &somePureIcon);
+	WORD removeImage(DWORD itemIndex);
+	WORD replaceImage(DWORD itemIndex,const PureBitmap &colorBitmap,const PureBitmap &maskBitmap);
+	WORD replaceImage(DWORD itemIndex,PureIcon &somePureIcon);
+	BOOL beginDrag(DWORD itemIndex,const GDIPoint &dragPoint)const;
+	BOOL dragMove(const GDIPoint &dragPoint)const;
+	BOOL dragEnter(HWND hwndLock,const GDIPoint &imagePoint)const;
+	BOOL dragLeave(HWND hwndLock)const;
+	BOOL dragShowNoLock(BOOL showFlag)const;
+  BOOL setDragCursorImage(int itemIndex,const GDIPoint &hotSpot);
+	void endDrag(void)const;
+	DWORD size(void)const;
+	RGBColor setBkColor(RGBColor bkGndColor=RGBColor((COLORREF)CLR_NONE));
+	RGBColor getBkColor(void)const;
+	WORD drawImage(PureDevice &somePureDevice,const Point &xyPoint,DWORD itemIndex,DrawFlag drawFlag=DrawNormal);
+	WORD setOverlayImage(DWORD itemIndex,DrawFlag drawFlag);
+	BOOL imageInfo(int itemIndex,ImageInfo &imageInfo);
+	WORD isOkay(void)const;
+private:
+	ImageType imageType(void)const;
+	WORD imageDimensions(Point &imageDimensions)const;
+	HICON extractIcon(DWORD itemIndex)const;
+	void destroyImageList(void);
+	WORD createImageList(DWORD widthImage,DWORD heightImage,ImageType imageType=ImageUnMasked,DWORD initialCount=0,DWORD growthFactor=1);
+
+	HIMAGELIST mhImageList;
+	HINSTANCE mhProcessInstance;
+	ImageType mImageType;
+};
+
+inline
+ImageList::ImageList(HINSTANCE hProcessInstance)
+: mhImageList(0), mImageType(ImageUnMasked), mhProcessInstance(hProcessInstance)
+{
+}
+
+inline
+ImageList::ImageList(HIMAGELIST hImageList,HINSTANCE hProcessInstance,ImageType imageType)
+: mhImageList(hImageList), mhProcessInstance(hProcessInstance), mImageType(imageType)
+{
+}
+
+inline
+ImageList::ImageList(HINSTANCE hProcessInstance,DWORD widthImage,DWORD heightImage,ImageType imageType,DWORD initialCount,DWORD growthFactor)
+: mhImageList(0), mImageType(ImageUnMasked), mhProcessInstance(hProcessInstance)
+{
+	createImageList(widthImage,heightImage,imageType,initialCount,growthFactor);
+}
+
+inline
+ImageList::ImageList(const ImageList &someImageList)
+{
+	*this=someImageList;
+}
+
+inline
+ImageList::~ImageList()
+{
+	destroyImageList();
+}
+
+inline
+WORD ImageList::operator==(const ImageList &/*someImageList*/)
+{
+	return FALSE;
+}
+
+inline
+WORD ImageList::createImageList(DWORD widthImage,DWORD heightImage,ImageType imageType,DWORD initialCount,DWORD growthFactor)
+{
+	destroyImageList();
+	mhImageList=::ImageList_Create(widthImage,heightImage,imageType,initialCount,growthFactor);
+	return isOkay();
+}
+
+inline
+void ImageList::destroyImageList(void)
+{
+	if(!isOkay())return;
+	::ImageList_Destroy(mhImageList);
+	mhImageList=0;
+}
+
+inline
+ImageList::operator HIMAGELIST(void)
+{
+	return mhImageList;
+}
+
+inline
+WORD ImageList::insertImage(HBITMAP hBitmap)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_Add(mhImageList,hBitmap,0);
+}
+
+inline
+WORD ImageList::removeImage(DWORD itemIndex)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_Remove(mhImageList,itemIndex);
+}
+
+inline
+DWORD ImageList::size(void)const
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_GetImageCount(mhImageList);
+}
+
+inline
+RGBColor ImageList::setBkColor(RGBColor bkGndColor)
+{
+	if(!isOkay())return RGBColor((COLORREF)0);
+	return RGBColor(::ImageList_SetBkColor(mhImageList,(COLORREF)bkGndColor));
+}
+
+inline
+RGBColor ImageList::getBkColor(void)const
+{
+	if(!isOkay())return RGBColor((COLORREF)0);
+	return RGBColor(::ImageList_GetBkColor(mhImageList));
+}
+
+inline
+WORD ImageList::setOverlayImage(DWORD itemIndex,DrawFlag drawFlag)
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_SetOverlayImage(mhImageList,itemIndex,(int)drawFlag);
+}
+
+inline
+ImageList::ImageType ImageList::imageType(void)const
+{
+	return mImageType;
+}
+
+inline
+HICON ImageList::extractIcon(DWORD itemIndex)const
+{
+	if(!isOkay())return FALSE;
+	return ::ImageList_ExtractIcon(mhProcessInstance,mhImageList,itemIndex);
+}
+
+inline
+void ImageList::endDrag(void)const
+{
+  if(!isOkay())return;
+  ::ImageList_EndDrag();
+}
+
+inline
+BOOL ImageList::dragShowNoLock(BOOL showFlag)const
+{
+  if(!isOkay())return FALSE;
+	return ::ImageList_DragShowNolock(showFlag);
+}
+
+inline
+WORD ImageList::isOkay(void)const
+{
+	return (mhImageList?TRUE:FALSE);
+}
+#endif

imagelst/IMAGELST.MAK

@@ -0,0 +1,449 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=imagelst - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to imagelst - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "imagelst - Win32 Release" && "$(CFG)" !=\
+ "imagelst - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Imagelst.mak" CFG="imagelst - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "imagelst - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "imagelst - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "imagelst - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "imagelst - 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 ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\Imagelst.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Ftree.obj"
+	-@erase "$(INTDIR)\Imagelst.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(INTDIR)\Treeview.obj"
+	-@erase "$(OUTDIR)\Imagelst.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/Imagelst.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Imagelst.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/Imagelst.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Ftree.obj" \
+	"$(INTDIR)\Imagelst.obj" \
+	"$(INTDIR)\Stdtmpl.obj" \
+	"$(INTDIR)\Treeview.obj"
+
+"$(OUTDIR)\Imagelst.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "imagelst - 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 "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "..\exe\msimglst.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Ftree.obj"
+	-@erase "$(INTDIR)\Imagelst.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(INTDIR)\Treeview.obj"
+	-@erase "..\exe\msimglst.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /YX /c
+CPP_PROJ=/nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D\
+ "__FLAT__" /D "STRICT" /Fp"$(INTDIR)/Imagelst.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Imagelst.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msimglst.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msimglst.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Ftree.obj" \
+	"$(INTDIR)\Imagelst.obj" \
+	"$(INTDIR)\Stdtmpl.obj" \
+	"$(INTDIR)\Treeview.obj"
+
+"..\exe\msimglst.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "imagelst - Win32 Release"
+# Name "imagelst - Win32 Debug"
+
+!IF  "$(CFG)" == "imagelst - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "imagelst - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Treeview.cpp
+
+!IF  "$(CFG)" == "imagelst - Win32 Release"
+
+DEP_CPP_TREEV=\
+	{$(INCLUDE)}"\.\Hittest.hpp"\
+	{$(INCLUDE)}"\.\Imagelst.hpp"\
+	{$(INCLUDE)}"\.\Treeview.hpp"\
+	{$(INCLUDE)}"\.\Tvdisp.hpp"\
+	{$(INCLUDE)}"\.\Tvinsert.hpp"\
+	{$(INCLUDE)}"\.\Tvitem.hpp"\
+	{$(INCLUDE)}"\.\Tvkey.hpp"\
+	{$(INCLUDE)}"\.\Tvmsghdr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbdatahk.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Commctrl.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Hookproc.hpp"\
+	{$(INCLUDE)}"\Common\Notify.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Treeview.obj" : $(SOURCE) $(DEP_CPP_TREEV) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "imagelst - Win32 Debug"
+
+DEP_CPP_TREEV=\
+	{$(INCLUDE)}"\.\Hittest.hpp"\
+	{$(INCLUDE)}"\.\Treeview.hpp"\
+	{$(INCLUDE)}"\.\Tvdisp.hpp"\
+	{$(INCLUDE)}"\.\Tvitem.hpp"\
+	{$(INCLUDE)}"\.\Tvkey.hpp"\
+	{$(INCLUDE)}"\.\Tvmsghdr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Commctrl.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Notify.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Treeview.obj" : $(SOURCE) $(DEP_CPP_TREEV) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Imagelst.cpp
+DEP_CPP_IMAGE=\
+	{$(INCLUDE)}"\.\Imagelst.hpp"\
+	{$(INCLUDE)}"\.\Imgeinfo.hpp"\
+	{$(INCLUDE)}"\common\assert.hpp"\
+	{$(INCLUDE)}"\Common\Commctrl.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Iconinfo.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pureicon.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Imagelst.obj" : $(SOURCE) $(DEP_CPP_IMAGE) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+
+!IF  "$(CFG)" == "imagelst - Win32 Release"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Imagelst.hpp"\
+	{$(INCLUDE)}"\.\Treeview.hpp"\
+	{$(INCLUDE)}"\.\Tvinsert.hpp"\
+	{$(INCLUDE)}"\.\Tvitem.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbdatahk.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Commctrl.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Hookproc.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "imagelst - Win32 Debug"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Treeview.hpp"\
+	{$(INCLUDE)}"\.\Tvitem.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Ftree.cpp
+
+!IF  "$(CFG)" == "imagelst - Win32 Release"
+
+DEP_CPP_FTREE=\
+	{$(INCLUDE)}"\.\Ftree.hpp"\
+	{$(INCLUDE)}"\.\Imagelst.hpp"\
+	{$(INCLUDE)}"\.\Treeview.hpp"\
+	{$(INCLUDE)}"\.\Tvdisp.hpp"\
+	{$(INCLUDE)}"\.\Tvinsert.hpp"\
+	{$(INCLUDE)}"\.\Tvitem.hpp"\
+	{$(INCLUDE)}"\.\Tvkey.hpp"\
+	{$(INCLUDE)}"\.\Tvmsghdr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbdatahk.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Commctrl.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Hookproc.hpp"\
+	{$(INCLUDE)}"\Common\Notify.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Ftree.obj" : $(SOURCE) $(DEP_CPP_FTREE) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "imagelst - Win32 Debug"
+
+DEP_CPP_FTREE=\
+	{$(INCLUDE)}"\.\Ftree.hpp"\
+	{$(INCLUDE)}"\.\Tvdisp.hpp"\
+	{$(INCLUDE)}"\.\Tvitem.hpp"\
+	{$(INCLUDE)}"\.\Tvkey.hpp"\
+	{$(INCLUDE)}"\.\Tvmsghdr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Notify.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Ftree.obj" : $(SOURCE) $(DEP_CPP_FTREE) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

imagelst/IMAGELST.PLG

@@ -0,0 +1,31 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: imagelst - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\WINNT\Profiles\sean\LOCALS~1\Temp\RSP2.tmp" with contents
+[
+/nologo /MTd /GX /ZI /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp".\msvcobj/imagelst.pch" /YX /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c 
+"D:\work\imagelst\Ftree.cpp"
+"D:\work\imagelst\Imagelst.cpp"
+"D:\work\imagelst\Treeview.cpp"
+]
+Creating command line "cl.exe @C:\WINNT\Profiles\sean\LOCALS~1\Temp\RSP2.tmp" 
+Creating command line "link.exe -lib /nologo /out:"..\exe\imagelst.lib"  .\msvcobj\Ftree.obj .\msvcobj\Imagelst.obj .\msvcobj\Stdtmpl.obj .\msvcobj\Treeview.obj "
+<h3>Output Window</h3>
+Compiling...
+Ftree.cpp
+Imagelst.cpp
+Treeview.cpp
+Creating library...
+
+
+
+<h3>Results</h3>
+imagelst.lib - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

imagelst/IMAGETST.RC

@@ -0,0 +1,14 @@
+LIST   BITMAP "STRIP.BMP"
+CHIP3  BITMAP "CHIP.BMP"
+CHIP   ICON "CHIP.ICO"
+HDD    ICON "HDD.ICO"
+FDD    ICON "FDD.ICO"
+MMEDIA ICON "MMEDIA.ICO"
+CD     ICON "CD.ICO"
+BOLT   ICON "BOLT.ICO"
+SYSTEM ICON "SYSTEM.ICO"
+DRILL  ICON "DRILL.ICO"
+DEVICE ICON "DEVICE.ICO"
+CDROM  ICON "CDROM.ICO"
+CA     ICON "CA.ICO"
+

imagelst/IMGEINFO.HPP

@@ -0,0 +1,145 @@
+#ifndef _IMAGELIST_IMAGEINFO_HPP_
+#define _IMAGELIST_IMAGEINFO_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+
+class ImageInfo : private _IMAGEINFO
+{
+public:
+	ImageInfo(void);
+	ImageInfo(const ImageInfo &someImageInfo);
+	~ImageInfo();
+	ImageInfo &operator=(const ImageInfo &someImageInfo);
+	WORD operator==(const ImageInfo &someImageInfo)const;
+  operator _IMAGEINFO&(void);
+	HBITMAP colorBitmap(void)const;
+	HBITMAP maskBitmap(void)const;
+	DWORD planes(void)const;
+	DWORD bitsPerPixel(void)const;
+  Rect boundingRect(void)const;
+private:
+	void colorBitmap(HBITMAP hbmColorBitmap);
+	void maskBitmap(HBITMAP hbmMaskBitmap);
+	void planes(DWORD planes);
+	void bitsPerPixel(DWORD bitsPerPixel);
+	void boundingRect(const Rect &boundingRect);
+};
+
+inline
+ImageInfo::ImageInfo(void)
+{
+	colorBitmap(0);
+	maskBitmap(0);
+	planes(0);
+	bitsPerPixel(0);
+	boundingRect(Rect());
+}
+
+inline
+ImageInfo::ImageInfo(const ImageInfo &someImageInfo)
+{
+	*this=someImageInfo;
+}
+
+inline
+ImageInfo::~ImageInfo()
+{
+}
+
+inline
+ImageInfo &ImageInfo::operator=(const ImageInfo &someImageInfo)
+{
+	colorBitmap(someImageInfo.colorBitmap());
+	maskBitmap(someImageInfo.maskBitmap());
+	planes(someImageInfo.planes());
+	bitsPerPixel(someImageInfo.bitsPerPixel());
+	boundingRect(someImageInfo.boundingRect());
+	return *this;
+}
+
+inline
+WORD ImageInfo::operator==(const ImageInfo &someImageInfo)const
+{
+	return (colorBitmap()==someImageInfo.colorBitmap()&&
+					maskBitmap()==someImageInfo.maskBitmap()&&
+					planes()==someImageInfo.planes()&&
+					bitsPerPixel()==someImageInfo.bitsPerPixel()&&
+					boundingRect()==someImageInfo.boundingRect());
+}
+
+inline
+ImageInfo::operator _IMAGEINFO&(void)
+{
+  return *this;
+}
+
+inline
+HBITMAP ImageInfo::colorBitmap(void)const
+{
+	return _IMAGEINFO::hbmImage;
+}
+
+inline
+void ImageInfo::colorBitmap(HBITMAP hbmColorBitmap)
+{
+	_IMAGEINFO::hbmImage=hbmColorBitmap;
+}
+
+inline
+HBITMAP ImageInfo::maskBitmap(void)const
+{
+	return _IMAGEINFO::hbmMask;
+}
+
+inline
+void ImageInfo::maskBitmap(HBITMAP hbmMaskBitmap)
+{
+	_IMAGEINFO::hbmMask=hbmMaskBitmap;
+}
+
+inline
+DWORD ImageInfo::planes(void)const
+{
+	return _IMAGEINFO::Unused1;
+}
+
+inline
+void ImageInfo::planes(DWORD planes)
+{
+	_IMAGEINFO::Unused1=planes;
+}
+
+inline
+DWORD ImageInfo::bitsPerPixel(void)const
+{
+	return _IMAGEINFO::Unused2;
+}
+
+inline
+void ImageInfo::bitsPerPixel(DWORD bitsPerPixel)
+{
+	_IMAGEINFO::Unused2=bitsPerPixel;
+}
+
+inline
+Rect ImageInfo::boundingRect(void)const
+{
+	return Rect(_IMAGEINFO::rcImage);
+}
+
+inline
+void ImageInfo::boundingRect(const Rect &boundingRect)
+{
+	_IMAGEINFO::rcImage.left=boundingRect.left();
+	_IMAGEINFO::rcImage.top=boundingRect.top();
+	_IMAGEINFO::rcImage.right=boundingRect.right();
+	_IMAGEINFO::rcImage.bottom=boundingRect.bottom();
+}
+#endif

imagelst/MAIN.CPP

@@ -0,0 +1,30 @@
+#include <common/windows.hpp>
+#include <imagelst/main.hpp>
+#include <imagelst/mainwnd.hpp>
+#include <imagelst/tvitem.hpp>
+
+HINSTANCE Main::smhInstance=0;
+HINSTANCE Main::smhPrevInstance=0;
+int Main::smnCmdShow=0;
+
+int PASCAL WinMain(HINSTANCE hProcessInstance,HINSTANCE hPrevInstance,LPSTR /*lpszCmdLine*/,int nCmdShow)
+{
+	Main::processInstance(hProcessInstance);
+	Main::previousProcessInstance(hPrevInstance);
+	Main::cmdShow(nCmdShow);
+
+	if(Main::previousProcessInstance())
+	{
+		HWND hWnd=::FindWindow(MainWindow::className(),MainWindow::className());
+		if(!hWnd)
+		{
+			::MessageBox(::GetFocus(),(LPSTR)"Failed to maximize previous instance",(LPSTR)"Error",MB_ICONSTOP|MB_SYSTEMMODAL);
+			return FALSE;
+		}
+		::PostMessage(hWnd,WM_REACTIVATE,0,0L);
+		return FALSE;
+	}
+	MainWindow applicationWindow(Main::processInstance());
+	return applicationWindow.messageLoop();
+}
+

imagelst/MAIN.HPP

@@ -0,0 +1,67 @@
+#ifndef _IMAGELIST_MAIN_HPP_
+#define _IMAGELIST_MAIN_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+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
+
+

imagelst/MAINWND.BAK

@@ -0,0 +1,51 @@
+#ifndef _IMAGELIST_MAINWINDOW_HPP_
+#define _IMAGELIST_MAINWINDOW_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _IMAGELIST_FOLDERTREE_HPP_
+#include <imagelst/ftree.hpp>
+#endif
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(HINSTANCE hInstance);
+	~MainWindow();
+	static String className(void);
+private:
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(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);
+
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mKeyDownHandler;
+	Callback<MainWindow> mSizeHandler;
+	Callback<MainWindow> mTimerHandler;
+	Callback<MainWindow> mCreateHandler;
+	static char szClassName[];
+	static char szMenuName[];
+	HINSTANCE mhInstance;
+  FolderTree *mlpFolderTree;
+};
+
+inline
+String MainWindow::className(void)
+{
+	return String(szClassName);
+}
+#endif
+
+

imagelst/MAINWND.CPP

@@ -0,0 +1,124 @@
+#include <stdio.h>
+#include <common/purehdc.hpp>
+#include <common/profile.hpp>
+#include <common/commctrl.hpp>
+#include <common/pointer.hpp>
+#include <imagelst/mainwnd.hpp>
+#include <imagelst/treeview.hpp>
+
+char MainWindow::szClassName[]="Proto";
+char MainWindow::szMenuName[]="";
+
+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),
+	mhInstance(hInstance), mlpFolderTree(0)
+{
+	insertHandlers();
+	registerClass();
+	::CreateWindow(szClassName,szClassName,
+		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_DLGFRAME|WS_SIZEBOX|WS_CLIPCHILDREN,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		NULL,NULL,mhInstance,(LPSTR)this);
+	show(SW_SHOW);                       
+	update();
+}
+
+MainWindow::~MainWindow()
+{
+  if(mlpFolderTree){delete mlpFolderTree;mlpFolderTree=0;}
+	destroy();
+}
+
+void MainWindow::insertHandlers(void)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::TimerHandler,&mTimerHandler);
+}
+
+void MainWindow::removeHandlers(void)
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::TimerHandler,&mTimerHandler);
+}
+
+void MainWindow::registerClass(void)const
+{
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(mhInstance,className(),(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+	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)(COLOR_WINDOW+1);
+	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::commandHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::keyDownHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+#define makeItemID(nodeType,itemID) MAKELPARAM(itemID,nodeType)
+
+CallbackData::ReturnType MainWindow::timerHandler(CallbackData &/*someCallbackData*/)
+{
+  enum {RootID=0x0000};
+	enum NodeType{NullNode=0x0000,ImportTerminalNode=0x0001,ExportTerminalNode=0x0002,
+				 CodeTerminalNode=0x0003,DataTerminalNode=0x0004};
+
+	killTimer(0);
+  mlpFolderTree=new FolderTree(*this);
+	mlpFolderTree->addRootNode(FolderTree::FolderClosed,"Image Sections",makeItemID(NullNode,RootID));
+  TreeViewItem firstItem(0,0,0,0,"foo",3,FolderTree::FolderClosed,FolderTree::FolderOpen,0,makeItemID(ImportTerminalNode,1));
+  mlpFolderTree->addNode(TreeView::NodeChild,firstItem,"Image Sections");
+	mlpFolderTree->appendNode(TreeView::NodeSibling,0,"section(foo)",0);
+	mlpFolderTree->appendNode(TreeView::NodeSibling,0,"section(bar)",0);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+  setTimer(0,250);
+	return (CallbackData::ReturnType)FALSE;
+}
+

imagelst/MAINWND.HPP

@@ -0,0 +1,51 @@
+#ifndef _IMAGELIST_MAINWINDOW_HPP_
+#define _IMAGELIST_MAINWINDOW_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _IMAGELIST_FOLDERTREE_HPP_
+#include <imagelst/ftree.hpp>
+#endif
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(HINSTANCE hInstance);
+	~MainWindow();
+	static String className(void);
+private:
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(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);
+
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mKeyDownHandler;
+	Callback<MainWindow> mSizeHandler;
+	Callback<MainWindow> mTimerHandler;
+	Callback<MainWindow> mCreateHandler;
+	static char szClassName[];
+	static char szMenuName[];
+	HINSTANCE mhInstance;
+  FolderTree *mlpFolderTree;
+};
+
+inline
+String MainWindow::className(void)
+{
+	return String(szClassName);
+}
+#endif
+
+

imagelst/NOTIFY.HPP

@@ -0,0 +1,132 @@
+#ifndef _IMAGELIST_NOTIFYMESSAGEHEADER_HPP_
+#define _IMAGELIST_NOTIFYMESSAGEHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+
+class NotifyMessageHeader : private NMHDR
+{
+public:
+	NotifyMessageHeader(void);
+  NotifyMessageHeader(const NotifyMessageHeader &someNotifyMessageHeader);
+	NotifyMessageHeader(const NMHDR &someNMHDR);
+	virtual ~NotifyMessageHeader();
+	NotifyMessageHeader &operator=(const NotifyMessageHeader &someNotifyMessageHeader);
+	NotifyMessageHeader &operator=(const NMHDR &someNMHDR);
+	WORD operator==(const NotifyMessageHeader &someNotifyMessageHeader)const;
+	WORD operator==(const NMHDR &someNMHDR)const;
+  operator NMHDR&(void);
+	HWND hwndFrom(void)const;
+	void hwndFrom(HWND hwndFrom);
+	UINT idFrom(void)const;
+	void idFrom(UINT idFrom);
+	UINT code(void)const;
+  void code(UINT code);
+private:
+};
+
+inline
+NotifyMessageHeader::NotifyMessageHeader(void)
+{
+	hwndFrom(0);
+	idFrom(0);
+  code(0);
+}
+
+inline
+NotifyMessageHeader::NotifyMessageHeader(const NotifyMessageHeader &someNotifyMessageHeader)
+{
+  *this=someNotifyMessageHeader;
+}
+
+inline
+NotifyMessageHeader::NotifyMessageHeader(const NMHDR &someNMHDR)
+{
+  *this=someNMHDR;
+}
+
+inline
+NotifyMessageHeader::~NotifyMessageHeader()
+{
+}
+
+inline
+NotifyMessageHeader &NotifyMessageHeader::operator=(const NotifyMessageHeader &someNotifyMessageHeader)
+{
+	hwndFrom(someNotifyMessageHeader.hwndFrom());
+	idFrom(someNotifyMessageHeader.idFrom());
+	code(someNotifyMessageHeader.code());
+  return *this;
+}
+
+inline
+NotifyMessageHeader &NotifyMessageHeader::operator=(const NMHDR &someNMHDR)
+{
+  hwndFrom(someNMHDR.hwndFrom);
+	idFrom(someNMHDR.idFrom);
+	code(someNMHDR.code);
+	return *this;
+}
+
+inline
+WORD NotifyMessageHeader::operator==(const NotifyMessageHeader &someNotifyMessageHeader)const
+{
+	return (hwndFrom()==someNotifyMessageHeader.hwndFrom()&&
+					idFrom()==someNotifyMessageHeader.idFrom()&&
+          code()==someNotifyMessageHeader.code());
+}
+
+inline
+WORD NotifyMessageHeader::operator==(const NMHDR &someNMHDR)const
+{
+  return (hwndFrom()==someNMHDR.hwndFrom&&
+	  			idFrom()==someNMHDR.idFrom&&
+					code()==someNMHDR.code);
+}
+
+inline
+NotifyMessageHeader::operator NMHDR&(void)
+{
+  return *this;
+}
+
+inline
+HWND NotifyMessageHeader::hwndFrom(void)const
+{
+	return NMHDR::hwndFrom;
+}
+
+inline
+void NotifyMessageHeader::hwndFrom(HWND hwndFrom)
+{
+	NMHDR::hwndFrom=hwndFrom;
+}
+
+inline
+UINT NotifyMessageHeader::idFrom(void)const
+{
+	return NMHDR::idFrom;
+}
+
+inline
+void NotifyMessageHeader::idFrom(UINT idFrom)
+{
+  NMHDR::idFrom=idFrom;
+}
+
+inline
+UINT NotifyMessageHeader::code(void)const
+{
+  return NMHDR::code;
+}
+
+inline
+void NotifyMessageHeader::code(UINT code)
+{
+  NMHDR::code=code;
+}
+#endif
+

imagelst/RELATION.HPP

@@ -0,0 +1,47 @@
+#ifndef _IMAGELST_RELATION_HPP_
+#define _IMAGELST_RELATION_HPP_
+
+#ifdef _EXPAND_RELATION_TEMPLATES_
+#pragma option -Jgd
+#endif
+
+template <class T>
+class RContainer
+{
+	friend class Relation<T>;
+	public:
+		T *item(void);
+		void item(T *lpItem);
+		RContainer<T> *sibling(void);
+		void sibling(RContainer<T> *lpSibling);
+		RContainer<T> *parent(void);
+		void parent(RContainer<T> *lpParent);
+		RContainer<T> *child(void);
+		void child(RContainer<T> *lpChild);
+	private:
+		RContainer *mlpSibling;
+		RContainer *mlpParent;
+    RContainer *mlpChild;
+		T *mlpItem;
+		RContainer(void);
+		~RContainer();
+};
+
+template <class T>
+class Relation
+{
+public:
+	Relation(void);
+	Relation(const Relation<T> &someRelation);
+	virtual ~Relation(void);
+	void insert(const T &someItem,const T &insertAfter);
+	void remove(const T &someItem);
+	WORD find(T &someItem);
+	Relation<T> &operator=(const Relation<T> &someRelation);
+	WORD operator==(const Relation<T> &someRelation)const;
+private:
+	RContainer<T> *Relation<T>::searchChildDescend(RContainer<T> *lpRContainer,T &someItem);
+	RContainer<T> *Relation<T>::searchSiblingDescend(RContainer<T> *lpRContainer,T &someItem);
+	RContainer<T> *mlpRContainer;
+};
+#endif

imagelst/RELATION.TPP

@@ -0,0 +1,156 @@
+#ifndef _IMAGELST_RELATION_HPP_
+#error relation.hpp must precede relation.tpp
+#endif
+
+template <class T>
+Relation<T>::Relation(void)
+: mlpRContainer(0)
+{
+}
+
+template <class T>
+Relation<T>::Relation(const Relation<T> &someRelation)
+{
+}
+
+template <class T>
+Relation<T>::~Relation()
+{
+	if(mlpRContainer){delete mlpRContainer;mlpRContainer=0;}
+}
+
+template <class T>
+void Relation<T>::insert(const T &someItem,const T &insertAfter)
+{
+}
+
+template <class T>
+void Relation<T>::remove(const T &someItem)
+{
+}
+
+template <class T>
+WORD Relation<T>::find(T &someItem)
+{
+	if(!mlpRContainer)return FALSE;
+	RContainer<T> *lpParentNode(mlpRContainer);
+
+	while(lpParentNode)
+	{
+    if(searchChildDescend(lpParentNode,someItem))return TRUE;
+		lpParentNode=lpParentNode->sibling();
+	}
+  return FALSE;
+
+}
+
+template <class T>
+Relation<T> &Relation<T>::operator=(const Relation<T> &someRelation)
+{
+}
+
+template <class T>
+WORD Relation<T>::operator==(const Relation<T> &someRelation)const
+{
+}
+
+template <class T>
+RContainer<T> *Relation<T>::searchChildDescend(RContainer<T> *lpRContainer,T &someItem)
+{
+	RContainer<T> *lpParentNode(lpRContainer);
+	RContainer<T> *lpSiblingNode(0);
+
+	while(lpRContainer)
+	{
+		if(someItem==*(lpRContainer->item())){someItem=*lpRContainer->item();return lpRContainer;}
+		lpRContainer=lpRContainer->child();
+		if(lpRContainer->sibling())
+		{
+			lpSiblingNode=searchSiblingDescend(lpRContainer->sibling(),someItem);
+			if(lpSiblingNode)return lpSiblingNode;
+		}
+	}
+	return lpSiblingNode;
+}
+
+template <class T>
+RContainer<T> *Relation<T>::searchSiblingDescend(RContainer<T> *lpRContainer,T &someItem)
+{
+	RContainer<T> *lpParentNode(lpRContainer);
+	RContainer<T> *lpChildNode(0);
+
+	while(lpRContainer)
+	{
+		if(someItem==*(lpRContainer->item())){someItem=*(lpRContainer->item());return lpRContainer;}
+		lpRContainer=lpRContainer->sibling();
+		if(lpRContainer->child())
+		{
+			lpChildNode=searchChildDescend(lpRContainer->child(),someItem);
+			if(lpChildNode)return lpChildNode;
+		}
+	}
+	return lpChildNode;
+}
+
+// Container methods
+
+template <class T>
+RContainer<T>::RContainer(void)
+: mlpSibling(0), mlpParent(0), mlpChild(0), mlpItem(0)
+{
+}
+
+template <class T>
+RContainer<T>::~RContainer()
+{
+	if(mlpItem){delete mlpItem;mlpItem=0;}
+}
+
+
+template <class T>
+RContainer<T> *RContainer<T>::sibling(void)
+{
+	return mlpSibling;
+}
+
+template <class T>
+void RContainer<T>::sibling(RContainer<T> *lpSibling)
+{
+	mlpSibling=lpSibling;
+}
+
+template <class T>
+RContainer<T> *RContainer<T>::parent(void)
+{
+	return mlpParent;
+}
+
+template <class T>
+void RContainer<T>::parent(RContainer<T> *lpParent)
+{
+	mlpParent=lpParent;
+}
+
+template <class T>
+RContainer<T> *RContainer<T>::child(void)
+{
+	return mlpChild;
+}
+
+template <class T>
+void RContainer<T>::child(RContainer<T> *lpChild)
+{
+	mlpChild=lpChild;
+}
+
+template <class T>
+T *RContainer<T>::item(void)
+{
+  return mlpItem;
+}
+
+template <class T>
+void RContainer<T>::item(T *lpItem)
+{
+	mlpItem=lpItem;
+}

imagelst/SCRAPS.TXT

@@ -0,0 +1,499 @@
+
+	WORD addChildNode(const TreeViewItem &someTreeViewItem,const String &parentString);
+	WORD addSiblingNode(const TreeViewItem &someTreeViewItem,const String &parentString);
+
+WORD TreeView::addChildNode(const TreeViewItem &someTreeViewItem,const String &parentString)
+{
+	HTREEITEM hParent(0);
+	HTREEITEM hTreeItem;
+	HTREEITEM hPrevItem;
+	HTREEITEM hChildItem;
+	String bufferString;
+	TreeViewInsert viewInsert;
+	TreeViewItem viewItem;
+
+	bufferString.length(255);
+	hTreeItem=getChild(TVGN_ROOT);
+	while(hTreeItem)
+	{
+		hChildItem=getChild(hTreeItem);
+		if(hChildItem&&searchInsertChild(someTreeViewItem,viewInsert,parentString,hChildItem))
+		{
+			insertItem(viewInsert);
+			return TRUE;
+		}
+		else
+		{
+			viewItem.mask(TreeViewItem::MaskText);
+			viewItem.item(hTreeItem);
+			viewItem.text(bufferString);
+			getItem(viewItem);
+			if(parentString==viewItem.text())
+			{
+				hParent=hTreeItem;
+				viewItem=TreeViewItem();
+				viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+				viewItem.text(someTreeViewItem.text());
+				viewItem.image(someTreeViewItem.image());
+				viewItem.selectedImage(someTreeViewItem.selectedImage());
+				viewItem.lParam(someTreeViewItem.lParam());
+				viewInsert.parent(hParent);
+				viewInsert.insertAfter(hPrevItem);
+				viewInsert.viewItem(viewItem);
+				insertItem(viewInsert);
+				return TRUE;
+			}
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return TRUE;
+}
+
+WORD TreeView::addSiblingNode(const TreeViewItem &someTreeViewItem,const String &parentString)
+{
+	HTREEITEM hParent(0);
+	HTREEITEM hTreeItem;
+	HTREEITEM hPrevItem;
+	HTREEITEM hChildItem;
+	String bufferString;
+	TreeViewInsert viewInsert;
+	TreeViewItem viewItem;
+
+	bufferString.length(255);
+	hTreeItem=getChild(TVGN_ROOT);
+	while(hTreeItem)
+	{
+		hChildItem=getChild(hTreeItem);
+		if(hChildItem&&searchInsertSibling(someTreeViewItem,viewInsert,parentString,hTreeItem,hChildItem))
+		{
+			insertItem(viewInsert);
+			return TRUE;
+		}
+		else
+		{
+			viewItem.mask(TreeViewItem::MaskText);
+			viewItem.item(hTreeItem);
+			viewItem.text(bufferString);
+			getItem(viewItem);
+			if(parentString==viewItem.text())
+			{
+				hParent=hTreeItem;
+				viewItem=TreeViewItem();
+				viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+				viewItem.text(someTreeViewItem.text());
+				viewItem.image(someTreeViewItem.image());
+				viewItem.selectedImage(someTreeViewItem.selectedImage());
+				viewItem.lParam(someTreeViewItem.lParam());
+				viewInsert.parent(hParent);
+				viewInsert.insertAfter(hPrevItem);
+				viewInsert.viewItem(viewItem);
+				insertItem(viewInsert);
+				return TRUE;
+			}
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return TRUE;
+}
+
+
+
+
+
+
+
+
+
+
+WORD TreeView::searchInsertChild(TreeViewItem &viewItem,TreeViewInsert &viewInsert,const String &parentString,HTREEITEM hParent)
+{
+	WORD searchResult(FALSE);
+	HTREEITEM hPrevItem(FALSE);
+	HTREEITEM hTreeItem(hParent);
+	HTREEITEM hChildItem;
+	TreeViewItem searchItem;
+	String bufferString;
+
+	bufferString.length(String::MaxString);
+	while(hTreeItem)
+	{
+		hChildItem=getChild(hTreeItem);
+		if(hChildItem&&searchInsertChild(viewItem,viewInsert,parentString,hChildItem))
+		{
+			searchResult=TRUE;
+			break;
+		}
+		searchItem.mask(TreeViewItem::MaskText);
+		searchItem.item(hTreeItem);
+		searchItem.text(bufferString);
+		getItem(searchItem);
+		if(searchItem.text()==parentString)
+		{
+			viewInsert.parent(hTreeItem);
+			viewInsert.insertAfter(hPrevItem);
+			viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+			viewInsert.viewItem(viewItem);
+			searchResult=TRUE;
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return searchResult;
+}
+
+
+WORD TreeView::searchInsertSibling(TreeViewItem &viewItem,TreeViewInsert &viewInsert,const String &parentString,HTREEITEM hParent,HTREEITEM hChildItem)
+{
+	WORD searchResult(FALSE);
+	HTREEITEM hPrevItem(FALSE);
+	HTREEITEM hTreeItem(hChildItem);
+	HTREEITEM hChildNode;
+	TreeViewItem searchItem;
+	String bufferString;
+
+	bufferString.length(String::MaxString);
+	while(hTreeItem)
+	{
+		hChildNode=getChild(hTreeItem);
+		if(hChildNode&&searchInsertSibling(viewItem,viewInsert,parentString,hTreeItem,hChildNode))
+		{
+			searchResult=TRUE;
+      break;
+		}
+		searchItem.mask(TreeViewItem::MaskText);
+		searchItem.item(hTreeItem);
+		searchItem.text(bufferString);
+		getItem(searchItem);
+		if(searchItem.text()==parentString)
+		{
+			viewInsert.parent(hParent);
+			viewInsert.insertAfter(hPrevItem);
+			viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+			viewInsert.viewItem(viewItem);
+			searchResult=TRUE;
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return searchResult;
+}
+
+
+
+
+
+
+
+
+//	mhTreeViewWnd=::CreateWindow("SysTreeView32","",WS_VISIBLE|WS_BORDER|WS_CHILD|viewFlags,
+//								 winRect.left(),winRect.top(),winRect.right(),winRect.bottom(),
+//								 parentWindow(),(HMENU)TreeViewID,TreeView::processInstance(),0);
+//		mhTreeViewWnd=::CreateWindowEx(WS_EX_CLIENTEDGE|WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR,
+//			"SysTreeView32","",WS_CHILD|WS_VISIBLE|TVS_HASBUTTONS|TVS_HASLINES|TVS_EDITLABELS,
+//			winRect.left(),winRect.top(),winRect.right(),winRect.bottom(),
+//			parentWindow(),(HMENU)TreeViewID,TreeView::processInstance(),0);
+//	::UpdateWindow(mhTreeViewWnd);
+
+
+WORD TreeView::addChildNode(const TreeViewItem &someTreeViewItem,const String &parentString)
+{
+	HTREEITEM hParent(0);
+	HTREEITEM hTreeItem;
+	HTREEITEM hPrevItem;
+	String bufferString;
+
+	bufferString.length(255);
+	hTreeItem=getChild(TVGN_ROOT);
+	while(hTreeItem)
+	{
+		TreeViewItem viewItem;
+
+		viewItem.mask(TreeViewItem::MaskText);
+		viewItem.item(hTreeItem);
+		viewItem.text(bufferString);
+		getItem(viewItem);
+
+
+
+		if(parentString==viewItem.text())
+		{
+			hParent=hTreeItem;
+			while(hTreeItem){hPrevItem=hTreeItem;hTreeItem=getChild(hTreeItem);}
+			TreeViewInsert viewInsert;
+			viewItem=TreeViewItem();
+			viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+			viewItem.text(someTreeViewItem.text());
+			viewItem.image(someTreeViewItem.image());
+			viewItem.selectedImage(someTreeViewItem.selectedImage());
+			viewItem.lParam(someTreeViewItem.lParam());
+			viewInsert.parent(hParent);
+			viewInsert.insertAfter(hPrevItem);
+			viewInsert.viewItem(viewItem);
+			insertItem(viewInsert);
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return TRUE;
+}
+
+
+WORD TreeView::searchInsert(const TreeItem &viewItem,TreeViewInsert &viewInsert,const String &parentString,HTREEITEM hParent)
+{
+	WORD searchResult(FALSE);
+	HTREEITEM hPrevItem(FALSE);
+	HTREEITEM hTreeItem(hParent);
+	TreeViewItem searchItem;
+	String bufferString;
+
+	bufferString.length(String::MaxString);
+	while(hTreeItem)
+	{
+		searchItem.mask(TreeViewItem::MaskText);
+		searchItem.item(hTreeItem);
+		searchItem.text(bufferString);
+		getItem(searchItem);
+		if(searchItem.text()==parentString)
+		{
+			viewInsert.parent(hParent);
+			viewInsert.insertAfter(hPrevItem);
+			viewInsert.viewItem(viewItem);
+			searchResult=TRUE;
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+  return searchResult;
+}
+
+
+
+
+#if 0
+WORD TreeView::addChildNode(DWORD indexImage,const String &textString,const String &parentString,DWORD userData)
+{
+			treeViewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+			treeViewItem.text(textString);
+			treeViewItem.image(indexImage);
+			treeViewItem.selectedImage(I_IMAGECALLBACK);
+			treeViewItem.lParam(userData);
+			treeViewInsert.parent(hParent);
+			treeViewInsert.insertAfter(hPrevItem);
+			treeViewInsert.viewItem(treeViewItem);
+			insertItem(treeViewInsert);
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return TRUE;
+}
+#endif
+
+#if 0
+WORD TreeView::addChildNode(DWORD indexImage,const String &textString,const String &parentString,DWORD userData)
+{
+	HTREEITEM hParent(0);
+	HTREEITEM hTreeItem;
+	HTREEITEM hPrevItem;
+	String bufferString;
+
+	bufferString.length(255);
+	hTreeItem=getChild(TVGN_ROOT);
+	while(hTreeItem)
+	{
+		TreeViewItem treeViewItem;
+
+		treeViewItem.mask(TVIF_TEXT);
+		treeViewItem.item(hTreeItem);
+		treeViewItem.text(bufferString);
+		getItem(treeViewItem);
+		if(parentString==treeViewItem.text())
+		{
+			hParent=hTreeItem;
+			while(hTreeItem)
+			{
+				hPrevItem=hTreeItem;
+				hTreeItem=getChild(hTreeItem);
+			}
+			TreeViewInsert treeViewInsert;
+			TreeViewItem treeViewItem;
+			treeViewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+			treeViewItem.text(textString);
+			treeViewItem.image(indexImage);
+			treeViewItem.selectedImage(I_IMAGECALLBACK);
+			treeViewItem.lParam(userData);
+			treeViewInsert.parent(hParent);
+			treeViewInsert.insertAfter(hPrevItem);
+			treeViewInsert.viewItem(treeViewItem);
+			insertItem(treeViewInsert);
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return TRUE;
+}
+#endif
+
+
+
+
+#if 0
+HTREEITEM FindOrAddTreeViewItem(HWND hWndTV,HTREEITEM hParent,int iImage,int iSelectedImage,LPSTR szText,LPARAM lParam)
+{
+	TV_ITEM tvItem;        // Temporary item
+	HTREEITEM hItem;         // Handle to item
+	HTREEITEM hPrevItem;     // Handle to previous item
+	char szBuffer[256]; // Temporary buffer
+
+  // Get the first child of the passed in parent
+  hItem=TreeView_GetChild(hWndTV,hParent);
+	// Loop through all children, looking for an already existing child.
+	while(hItem)
+	{
+		tvItem.mask= TVIF_TEXT;        // We want the text
+		tvItem.hItem= hItem;            // Indicate the item to fetch
+		tvItem.pszText=szBuffer;         // Indicate the buffer
+		tvItem.cchTextMax=sizeof(szBuffer); // Indicate buffer's size
+		::TreeView_GetItem(hWndTV,&tvItem); // Fetch, Rover!
+
+		if(!lstrcmpi(tvItem.pszText,szText))return hItem;
+		hPrevItem=hItem; // Remember the last item, since the next line
+											 // of code will eventually put a NULL in the
+											 // hItem variable, and we want to know the
+											 // last item under the parent in case we need
+											 // to add a new item.
+
+		// Get the next sibling item in the TreeView, if any.
+		hItem=::TreeView_GetNextSibling(hWndTV,hItem);
+	}
+
+	// If we made it here, then the item needs to be added onto the end of the list
+	return AddTreeViewItem ( hWndTV,        // Handle of TreeView
+													 hParent,       // Parent item
+													 hPrevItem,     // Last child in list (from above loop)
+													 iImage,        // These are the parameters
+													 iSelectedImage,// passed into this
+													 szText,        // function.
+													 lParam         //
+												 );
+}
+#endif
+#if 0
+
+	 if (hWndTreeView)
+		 {
+		 TreeView_SetImageList ( hWndTreeView, hCoasterImageList, 0 );
+		 ImageList_SetBkColor  ( hCoasterImageList, GetSysColor ( COLOR_WINDOW ));
+		 FillTreeView ( hWndTreeView );
+		 }
+}
+#endif
+
+//	enum StateFlags{StateFocused=TVIS_FOCUSED,StateSelected=TVIS_SELECTED,
+//			 StateCut=TVIS_CUT,StateDropHilited=TVIS_DROPHILITED,StateBold=TVIS_BOLD,
+//			 StateExpanded=TVIS_EXPANDED,StateExpandedOnce=TVIS_EXPANDEDONCE};
+
+
+
+#if 0
+	TreeViewInfo &treeViewInfo=((TreeViewInfo&)*((TreeViewInfo*)someCallbackData.lParam()));
+	TreeViewNotify &treeViewNotify=(*((TreeViewNotify*)someCallbackData.lParam()));
+
+	if(TreeViewID==((NotifyMessageHeader&)treeViewInfo).idFrom())
+	{
+		switch(((NotifyMessageHeader&)treeViewInfo).code())
+		{
+			case TVN_SELCHANGING :
+				return tvnSelChanging(treeViewNotify);
+			case TVN_SELCHANGED :
+				return tvnSelChanged(treeViewNotify);
+			case TVN_GETDISPINFO :
+				return tvnGetDispInfo(treeViewInfo);
+			case TVN_SETDISPINFO :
+				return tvnSetDispInfo(treeViewInfo);
+			case TVN_ITEMEXPANDING :
+				return tvnItemExpanding(treeViewInfo);
+			case TVN_BEGINDRAG :
+				return tvnBeginDrag(treeViewNotify);
+			case TVN_BEGINRDRAG :
+				return tvnBeginRDrag(treeViewNotify);
+			case TVN_DELETEITEM :
+				return tvnDeleteItem(treeViewInfo);
+			case TVN_BEGINLABELEDIT :
+				return tvnBeginLabelEdit(treeViewInfo);
+			case TVN_ENDLABELEDIT :
+				return tvnEndLabelEdit(treeViewInfo);
+			case TVN_KEYDOWN :
+				return tvnKeyDown(treeViewInfo);
+		}
+	}
+#endif
+
+
+	if(((TreeViewItem&)treeViewInfo).state()&TVIS_EXPANDED)
+	{
+		((TreeViewItem&)treeViewInfo).image(FolderOpen);
+		((TreeViewItem&)treeViewInfo).selectedImage(FolderOpen);
+	}
+	else
+	{
+		((TreeViewItem&)treeViewInfo).image(FolderClosed);
+		((TreeViewItem&)treeViewInfo).selectedImage(FolderClosed);
+	}
+
+
+WNDPROC sOrigProc;
+void subClass(HINSTANCE hProcessInstance);
+__declspec(dllexport) LONG FAR PASCAL windowProcedure(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
+// ********************************************************************************
+
+void subClass(HINSTANCE hProcessInstance)
+{
+  WNDCLASS wndClass;
+	::GetClassInfo(0,"SysTreeView32",&wndClass);
+	wndClass.lpszClassName="SysTreeView32Sk";
+	sOrigProc=wndClass.lpfnWndProc;
+	wndClass.lpfnWndProc=(WNDPROC)windowProcedure;
+	wndClass.hInstance=hProcessInstance;
+	::RegisterClass(&wndClass);
+}
+
+long FAR PASCAL windowProcedure(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
+{
+  if(WM_RBUTTONUP==message)::MessageBeep(0);
+  return sOrigProc(hWnd,message,wParam,lParam);
+}
+
+
+
+WORD TreeView::appendNode(NodeType nodeType,DWORD itemIndex,const String &text,DWORD userData,WORD selected)
+{
+  HTREEITEM hInsertItem;
+	TreeViewItem treeViewItem;
+	TreeViewInsert treeViewInsert;
+//	String workString;
+
+//	workString=text;
+	treeViewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+	treeViewItem.text((LPSTR)(String&)text);
+	treeViewItem.maxText(text.length());
+	treeViewItem.image(itemIndex);
+	treeViewItem.selectedImage(I_IMAGECALLBACK);
+	treeViewItem.lParam(userData);
+	if(NodeChild==nodeType)treeViewInsert.parent(mLastInsert.insertAfter());
+	else treeViewInsert.parent(mLastInsert.parent());
+	treeViewInsert.insertAfter(mLastInsert.insertAfter());
+	treeViewInsert.viewItem(treeViewItem);
+	hInsertItem=insertItem(treeViewInsert);
+	if(!hInsertItem)return FALSE;
+	if(selected)selectItem(hInsertItem);
+	return (hInsertItem?TRUE:FALSE);
+}

imagelst/STATE.TXT

@@ -0,0 +1,14 @@
+Table 3. Tree View Item States
+  
+Item State	Meaning
+
+TVIS_CUT	The item is marked.
+TVIS_DISABLED	The item is disabled and is drawn using the standard disabled style and color.
+TVIS_DROPHILITED	The item is highlighted as a drag-and-drop target.
+TVIS_EXPANDED	The item's list of child items is currently expanded.
+TVIS_EXPANDEDONCE	The item's list of child items has been expanded at least once.
+TVIS_FOCUSED	The item has the focus and is drawn with the standard focus rectangle.
+TVIS_OVERLAYMASK	An overlay image is used as a mask with the item image.
+TVIS_SELECTED	The item is selected.
+TVIS_USERMASK	A user-defined mask is set. If you set the image to be a state image list, this mask will specify the indexes into the state image list and draw another image next to the normal item image. For example, you can use this state to put a check mark next to a tree view item image.
+At any given time, the parent it

imagelst/STDTMPL.BAK

@@ -0,0 +1,25 @@
+#ifndef _MSC_VER
+#define _EXPAND_VECTOR_TEMPLATES_
+#define _EXPAND_BLOCK_TEMPLATES_
+#define _EXPAND_RELATION_TEMPLATES_
+#include <common/point.hpp>
+#include <common/rgbcolor.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/gdata.hpp>
+#include <common/gdata.tpp>
+#include <common/string.hpp>
+#include <imagelst/treeview.hpp>
+#include <imagelst/tvitem.hpp>
+
+typedef PureVector<Point> a;
+typedef PureVector<RGBColor> b;
+typedef Block<String> c;
+typedef GlobalData<BYTE> e;
+typedef Block<CallbackPointer> f;
+typedef Callback<TreeView> h;
+#endif

imagelst/STDTMPL.CPP

@@ -0,0 +1,25 @@
+#ifndef _MSC_VER
+#define _EXPAND_VECTOR_TEMPLATES_
+#define _EXPAND_BLOCK_TEMPLATES_
+#define _EXPAND_RELATION_TEMPLATES_
+#include <common/point.hpp>
+#include <common/rgbcolor.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/gdata.hpp>
+#include <common/gdata.tpp>
+#include <common/string.hpp>
+#include <imagelst/treeview.hpp>
+#include <imagelst/tvitem.hpp>
+
+typedef PureVector<Point> a;
+typedef PureVector<RGBColor> b;
+typedef Block<String> c;
+typedef GlobalData<BYTE> e;
+typedef Block<CallbackPointer> f;
+typedef Callback<TreeView> h;
+#endif

imagelst/TREEITEM.HPP

@@ -0,0 +1,12 @@
+#ifndef _IMAGELIST_HANDLETREE_HPP_
+#define _IMAGELIST_HANDLETREE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+
+typedef HTREEITEM HandleTreeItem;
+
+#endif

imagelst/TREEVIEW.BAK

@@ -0,0 +1,453 @@
+#ifndef _IMAGELIST_TREEVIEW_HPP_
+#define _IMAGELIST_TREEVIEW_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+#ifndef _IMAGELIST_IMAGELIST_HPP_
+#include <imagelst/imagelst.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWINSERT_HPP_
+#include <imagelst/tvinsert.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+#ifndef _COMMON_HOOKPROC_HPP_
+#include <common/hookproc.hpp>
+#endif
+
+class TreeViewMessageHeader;
+class TreeViewDisplayInfo;
+class GUIWindow;
+class HitTestInfo;
+
+class TreeView : public WinHookProc
+{
+public:
+	enum{ControlID=101};
+	enum TreeFlags{TreeHasButtons=TVS_HASBUTTONS,TreeHasLines=TVS_HASLINES,
+		TreeLinesAtRoot=TVS_LINESATROOT,TreeEditLabels=TVS_EDITLABELS,
+		TreeDisableDragDrop=TVS_DISABLEDRAGDROP,TreeShowSelAlways=TVS_SHOWSELALWAYS};
+	enum TreeExpand{Collapse=TVE_COLLAPSE,CollapseReset=TVE_COLLAPSERESET,
+	  Expand=TVE_EXPAND,Toggle=TVE_TOGGLE};
+	enum NodeType{NodeChild=0,NodeSibling=1};
+	enum ListType{Normal=TVSIL_NORMAL,State=TVSIL_STATE};
+	TreeView(GUIWindow &parentWindow,DWORD viewFlags=TreeHasLines,const Rect &winRect=Rect(1,1,320,200),int controlID=ControlID);
+	virtual ~TreeView();
+	HIMAGELIST setImageList(ImageList &someImageList,WORD itemIndex=0);
+	HIMAGELIST createDragImage(HTREEITEM hTreeItem);
+	HTREEITEM addRootNode(DWORD indexImage,const String &textString,DWORD userData);
+	HWND getControlWnd(void)const;
+	HWND getEditControl(void)const;
+	String currentSelection(void)const;
+	String currentParentSelection(void)const;
+	String getRootItemText(void)const;
+	UINT getCount(void)const;
+	int controlID(void)const;
+	HTREEITEM getChild(HTREEITEM hTreeItem)const;
+	HTREEITEM getNextSibling(HTREEITEM hTreeItem)const;
+	HTREEITEM getParent(HTREEITEM hTreeItem)const;
+	HTREEITEM hitTest(HitTestInfo &someHitTestInfo)const;
+	HTREEITEM selectItem(HTREEITEM hTreeItem)const;
+	HTREEITEM selectDropTarget(HTREEITEM hTreeItem)const;
+	HTREEITEM insertItem(TreeViewInsert &someTreeViewInsert);
+	HIMAGELIST getImageList(ListType listType=Normal);
+	const TreeViewInsert &lastInsert(void)const;
+	WORD addNode(NodeType nodeType,TreeViewItem &insertTreeViewItem,const String &parentString,WORD selected=FALSE,BYTE delimeter=0);
+	WORD appendNode(NodeType nodeType,DWORD itemIndex,const String &text,DWORD userData,WORD selected=FALSE);
+  WORD moveTree(int left,int top,int right,int bottom,WORD repaint=TRUE)const;
+	WORD getItemRect(Rect &itemRect,BOOL boundingText=TRUE)const;
+	WORD getItemRect(Rect &itemRect,HTREEITEM hTreeItem,BOOL boundingText=TRUE)const;
+  WORD getItem(TreeViewItem &someTreeViewItem)const;
+	WORD setItem(const TreeViewItem &someTreeViewItem)const;
+  WORD remove(HTREEITEM hTreeItem)const;
+	WORD remove(const String &nodeName)const;
+	WORD setRedraw(WORD redrawFlag)const;
+	WORD setFocus(void)const;
+	WORD remove(void)const;
+  BOOL update(void)const;
+	BOOL invalidate(void)const;
+	WORD isOkay(void)const;
+protected:
+	HTREEITEM getRoot(void)const;
+	virtual WORD tvnSelChanging(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnSelChanged(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnGetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnSetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnItemExpanding(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnItemExpanded(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginDrag(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginRDrag(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnDeleteItem(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnEndLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnKeyDown(const TreeViewMessageHeader &treeViewMessageHeader);
+private:
+	CallbackData::ReturnType notifyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType rightButtonUpHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType rightButtonDownHandler(CallbackData &someCallbackData);
+	WORD handleGetDisplayInfo(CallbackData &someCallackData);
+	void createTreeView(const Rect &winRect,DWORD viewFlags,int controlID);
+	HTREEITEM selectSetFirstVisible(HTREEITEM hTreeItem);
+	HTREEITEM getDropHilight(void);
+	HTREEITEM getSelection(void)const;
+  HTREEITEM searchItem(const String &searchString,HTREEITEM hDescendItem=(HTREEITEM)0)const;
+	HTREEITEM getFirstVisible(void);
+	HTREEITEM select(HTREEITEM hTreeItem,WPARAM code)const;
+	HTREEITEM getNextItem(HTREEITEM hTreeItem,WPARAM code)const;
+	HTREEITEM getPrevSibling(HTREEITEM hTreeItem);
+	HTREEITEM getNextVisible(HTREEITEM hTreeItem);
+	HTREEITEM getPrevVisible(HTREEITEM hTreeItem);
+
+	WORD sortChildren(HTREEITEM hTreeItem,WPARAM recurse);
+	WORD expand(HTREEITEM hTreeItem,WPARAM code);
+	WORD getISearchString(String &searchString);
+	WORD searchInsert(NodeType nodeType,TreeViewItem &viewItem,TreeViewInsert &viewInsert,const String &parentString,HTREEITEM hParentItem,HTREEITEM hChildItem,BYTE delimeter=0);
+	WORD ensureVisible(HTREEITEM hTreeItem);
+	WORD endEditLabelNow(WPARAM cancel);
+	WORD setIndent(WORD indent);
+	HWND getEditLabel(HTREEITEM hTreeItem);
+	UINT getVisibleCount(void);
+	UINT getIndent(void);
+	UINT indent(void);
+	void indent(UINT indent);
+
+	Callback<TreeView> mNotifyHandler;
+	GUIWindow &mParentWindow;
+	HWND mhTreeViewWnd;
+	int mControlID;
+  TreeViewInsert mLastInsert;
+};
+
+inline
+UINT TreeView::indent(void)
+{
+	if(!isOkay())return FALSE;
+	return (UINT)::SendMessage(mhTreeViewWnd,TVM_GETINDENT,0,0L);
+}
+
+inline
+void TreeView::indent(UINT indent)
+{
+	if(!isOkay())return;
+	::SendMessage(mhTreeViewWnd,TVM_SETINDENT,(WPARAM)indent,0L);
+}
+
+inline
+HTREEITEM TreeView::insertItem(TreeViewInsert &someTreeViewInsert)
+{
+  HTREEITEM hTreeItem;
+	if(!isOkay())return FALSE;
+	hTreeItem=(HTREEITEM)::SendMessage(mhTreeViewWnd,TVM_INSERTITEM,0,(LPARAM)&((TV_INSERTSTRUCT&)someTreeViewInsert));
+	if(hTreeItem){mLastInsert=someTreeViewInsert;mLastInsert.insertAfter(hTreeItem);}
+  return hTreeItem;
+}
+
+inline
+WORD TreeView::remove(HTREEITEM hTreeItem)const
+{
+	if(!isOkay())return FALSE;
+	return ::SendMessage(mhTreeViewWnd,TVM_DELETEITEM,0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::expand(HTREEITEM hTreeItem,WPARAM code)
+{
+	if(!isOkay())return FALSE;
+	return ::SendMessage(mhTreeViewWnd,TVM_EXPAND,(WPARAM)code,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+UINT TreeView::getCount(void)const
+{
+	if(!isOkay())return FALSE;
+	return (UINT)::SendMessage(mhTreeViewWnd,TVM_GETCOUNT,0,0L);
+}
+
+inline
+UINT TreeView::getIndent(void)
+{
+	if(!isOkay())return FALSE;
+	return (UINT)::SendMessage(mhTreeViewWnd,TVM_GETINDENT,0,0L);
+}
+
+inline
+WORD TreeView::setIndent(WORD indent)
+{
+	if(!isOkay())return FALSE;
+	return (WORD)::SendMessage(mhTreeViewWnd,TVM_SETINDENT,(WPARAM)indent,0L);
+}
+
+inline
+HIMAGELIST TreeView::getImageList(ListType listType)
+{
+	if(!isOkay())return FALSE;
+	return (HIMAGELIST)::SendMessage(mhTreeViewWnd,TVM_GETIMAGELIST,(WPARAM)listType,0L);
+}
+
+inline
+HIMAGELIST TreeView::setImageList(ImageList &someImageList,WORD indexImage)
+{
+	if(!isOkay()||!someImageList.isOkay())return FALSE;
+	return (HIMAGELIST)::SendMessage(mhTreeViewWnd,TVM_SETIMAGELIST,indexImage,(LPARAM)(HIMAGELIST)someImageList);
+}
+
+inline
+HTREEITEM TreeView::getNextItem(HTREEITEM hTreeItem,WPARAM code)const
+{
+	if(!isOkay())return FALSE;
+	return (HTREEITEM)::SendMessage(mhTreeViewWnd,TVM_GETNEXTITEM,(WPARAM)code,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+HTREEITEM TreeView::getChild(HTREEITEM hTreeItem)const
+{
+	return getNextItem(hTreeItem,TVGN_CHILD);
+}
+
+inline
+HTREEITEM TreeView::getNextSibling(HTREEITEM hTreeItem)const
+{
+	return getNextItem(hTreeItem,TVGN_NEXT);
+}
+
+inline
+HTREEITEM TreeView::getPrevSibling(HTREEITEM hTreeItem)
+{
+	return getNextItem(hTreeItem,TVGN_PREVIOUS);
+}
+
+inline
+HTREEITEM TreeView::getParent(HTREEITEM hTreeItem)const
+{
+	return getNextItem(hTreeItem,TVGN_PARENT);
+}
+
+inline
+HTREEITEM TreeView::getFirstVisible(void)
+{
+	return getNextItem(0,TVGN_FIRSTVISIBLE);
+}
+
+inline
+HTREEITEM TreeView::getNextVisible(HTREEITEM hTreeItem)
+{
+	return getNextItem(hTreeItem,TVGN_NEXTVISIBLE);
+}
+
+inline
+HTREEITEM TreeView::getPrevVisible(HTREEITEM hTreeItem)
+{
+	return getNextItem(hTreeItem,TVGN_PREVIOUSVISIBLE);
+}
+
+inline
+HTREEITEM TreeView::getSelection(void)const
+{
+	return getNextItem(0,TVGN_CARET);
+}
+
+inline
+HTREEITEM TreeView::getDropHilight(void)
+{
+	return getNextItem(0,TVGN_DROPHILITE);
+}
+
+inline
+HTREEITEM TreeView::getRoot(void)const
+{
+	return getNextItem(0,TVGN_ROOT);
+}
+
+inline
+HTREEITEM TreeView::select(HTREEITEM hTreeItem,WPARAM code)const
+{
+	if(!isOkay())return FALSE;
+	return (HTREEITEM)::SendMessage(mhTreeViewWnd,TVM_SELECTITEM,(WPARAM)code,(LPARAM)(HTREEITEM)(hTreeItem));
+}
+
+inline
+HTREEITEM TreeView::selectItem(HTREEITEM hTreeItem)const
+{
+	return select(hTreeItem,TVGN_CARET);
+}
+
+inline
+HTREEITEM TreeView::selectDropTarget(HTREEITEM hTreeItem)const
+{
+	return select(hTreeItem,TVGN_DROPHILITE);
+}
+
+inline
+HTREEITEM TreeView::selectSetFirstVisible(HTREEITEM hTreeItem)
+{
+	return select(hTreeItem,TVGN_FIRSTVISIBLE);
+}
+
+inline
+WORD TreeView::getItem(TreeViewItem &someTreeViewItem)const
+{
+	if(!isOkay())return FALSE;
+	return (WORD)::SendMessage(mhTreeViewWnd,TVM_GETITEM,0,(LPARAM)&((TV_ITEM&)someTreeViewItem));
+}
+
+inline
+WORD TreeView::setItem(const TreeViewItem &someTreeViewItem)const
+{
+	if(!isOkay())return FALSE;
+	return (WORD)::SendMessage(mhTreeViewWnd,TVM_SETITEM,0,(LPARAM)&((TV_ITEM&)(TreeViewItem&)someTreeViewItem));
+}
+
+inline
+HWND TreeView::getEditLabel(HTREEITEM hTreeItem)
+{
+	if(!isOkay())return FALSE;
+	return (HWND)::SendMessage(mhTreeViewWnd,TVM_EDITLABEL,0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+HWND TreeView::getEditControl(void)const
+{
+	if(!isOkay())return FALSE;
+	return (HWND)::SendMessage(mhTreeViewWnd,TVM_GETEDITCONTROL,0,0L);
+}
+
+inline
+UINT TreeView::getVisibleCount(void)
+{
+	if(!isOkay())return FALSE;
+	return (UINT)::SendMessage(mhTreeViewWnd,TVM_GETVISIBLECOUNT,0,0L);
+}
+
+inline
+HIMAGELIST TreeView::createDragImage(HTREEITEM hTreeItem)
+{
+	if(!isOkay())return FALSE;
+	return (HIMAGELIST)::SendMessage(mhTreeViewWnd,TVM_CREATEDRAGIMAGE,0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::sortChildren(HTREEITEM hTreeItem,WPARAM recurse)
+{
+	if(!isOkay())return FALSE;
+	return ::SendMessage(mhTreeViewWnd,TVM_SORTCHILDREN,(WPARAM)recurse,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::ensureVisible(HTREEITEM hTreeItem)
+{
+	if(!isOkay())return FALSE;
+	return ::SendMessage(mhTreeViewWnd,TVM_ENSUREVISIBLE,(WPARAM)0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::endEditLabelNow(WPARAM cancel)
+{
+	if(!isOkay())return FALSE;
+	return ::SendMessage(mhTreeViewWnd,TVM_ENDEDITLABELNOW,(WPARAM)cancel,0L);
+}
+
+inline
+WORD TreeView::getISearchString(String &searchString)
+{
+	if(!isOkay())return FALSE;
+	return (WORD)::SendMessage(mhTreeViewWnd,TVM_GETISEARCHSTRING,0,(LPARAM)(LPSTR)searchString);
+}
+
+inline
+WORD TreeView::getItemRect(Rect &itemRect,BOOL boundingText)const
+{
+  if(!isOkay())return FALSE;
+  *((HTREEITEM*)&((RECT&)itemRect))=getSelection();
+	return (WORD)::SendMessage(mhTreeViewWnd,TVM_GETITEMRECT,boundingText,(LPARAM)&((RECT&)itemRect));
+}
+
+inline
+WORD TreeView::getItemRect(Rect &itemRect,HTREEITEM hTreeItem,BOOL boundingText)const
+{
+  if(!isOkay())return FALSE;
+  *((HTREEITEM*)&((RECT&)itemRect))=hTreeItem;
+	return (WORD)::SendMessage(mhTreeViewWnd,TVM_GETITEMRECT,boundingText,(LPARAM)&((RECT&)itemRect));
+}
+
+inline
+WORD TreeView::setRedraw(WORD redrawFlag)const
+{
+  if(!isOkay())return FALSE;
+	return (WORD)::SendMessage(mhTreeViewWnd,WM_SETREDRAW,redrawFlag,0L);
+}
+
+inline
+BOOL TreeView::update(void)const
+{
+  if(!isOkay())return FALSE;
+  return ::UpdateWindow(mhTreeViewWnd);
+}
+
+inline 
+BOOL TreeView::invalidate(void)const
+{
+  if(!isOkay())return FALSE;
+	return ::InvalidateRect(mhTreeViewWnd,0,FALSE);
+}
+
+inline
+WORD TreeView::moveTree(int left,int top,int right,int bottom,WORD repaint)const
+{
+  if(!isOkay())return FALSE;
+	return ::MoveWindow(mhTreeViewWnd,left,top,right,bottom,repaint);
+}
+
+inline
+WORD TreeView::setFocus(void)const
+{
+  if(!isOkay())return FALSE;
+	::SetFocus(mhTreeViewWnd);
+	return TRUE;
+}
+
+inline
+WORD TreeView::remove(const String &nodeName)const
+{
+  if(!isOkay())return FALSE;
+  HTREEITEM hTreeItem(searchItem(nodeName));
+	if(!hTreeItem)return FALSE;
+	return remove(hTreeItem);
+}
+
+inline
+const TreeViewInsert &TreeView::lastInsert(void)const
+{
+  return mLastInsert;
+}
+
+inline
+HWND TreeView::getControlWnd(void)const
+{
+  return mhTreeViewWnd;
+}
+
+inline
+int TreeView::controlID(void)const
+{
+  return mControlID;
+}
+
+inline
+WORD TreeView::isOkay(void)const
+{
+	return (mhTreeViewWnd?TRUE:FALSE);
+}
+#endif

imagelst/TREEVIEW.CPP

@@ -0,0 +1,361 @@
+#include <imagelst/tvdisp.hpp>
+#include <imagelst/tvkey.hpp>
+#include <imagelst/treeview.hpp>
+#include <imagelst/tvmsghdr.hpp>
+#include <imagelst/hittest.hpp>
+#include <common/guiwnd.hpp>
+
+TreeView::TreeView(GUIWindow &parentWindow,const Rect &winRect,int controlID,DWORD viewFlags)
+:	mParentWindow(parentWindow) //, mControlID(controlID)
+{
+  mNotifyHandler.setCallback(this,&TreeView::notifyHandler);
+	::InitCommonControls();
+  mParentWindow.insertHandler(VectorHandler::NotifyHandler,&mNotifyHandler);
+	createTreeView(winRect,viewFlags,controlID);
+}
+
+TreeView::~TreeView()
+{
+  destroy();
+	mParentWindow.removeHandler(VectorHandler::NotifyHandler,&mNotifyHandler);
+}
+
+
+void TreeView::createTreeView(const Rect &winRect,DWORD viewFlags,int controlID)
+{
+  createControl(WS_EX_LEFT|WS_EX_LTRREADING|WS_EX_RIGHTSCROLLBAR|WS_EX_CLIENTEDGE,WC_TREEVIEW,"",WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_VISIBLE|viewFlags,winRect,mParentWindow,controlID);
+}
+
+HTREEITEM TreeView::hitTest(HitTestInfo &someHitTestInfo)const
+{
+	if(!isOkay())return FALSE;
+	return (HTREEITEM)sendMessage(TVM_HITTEST,0,(LPARAM)&((TV_HITTESTINFO&)someHitTestInfo));
+}
+
+WORD TreeView::remove(void)const
+{
+	if(!isOkay())return FALSE;
+	if(!getCount())return TRUE;
+	sendMessage(TVM_DELETEITEM,0,(LPARAM)TVI_ROOT);
+  return !getCount();
+}
+
+CallbackData::ReturnType TreeView::rightButtonDownHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)TRUE;
+}
+
+CallbackData::ReturnType TreeView::rightButtonUpHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType TreeView::notifyHandler(CallbackData &someCallbackData)
+{
+  NotifyMessageHeader nmHeader(*(((NMHDR*)someCallbackData.lParam())));
+	if(controlID()==nmHeader.idFrom())
+	{
+	  switch(nmHeader.code())
+		{
+			case TVN_SELCHANGING :
+				  return tvnSelChanging(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_SELCHANGED :
+  		  return tvnSelChanged(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_GETDISPINFO : 
+			  return handleGetDisplayInfo(someCallbackData);
+			case TVN_SETDISPINFO : 
+				return tvnSetDispInfo(TreeViewDisplayInfo(*(((TV_DISPINFO*)someCallbackData.lParam()))));
+			case TVN_ITEMEXPANDING :
+				return tvnItemExpanding(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_ITEMEXPANDED :
+			  return tvnItemExpanded(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_BEGINDRAG :
+				return tvnBeginDrag(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_BEGINRDRAG :
+				return tvnBeginRDrag(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_DELETEITEM :
+				return tvnDeleteItem(TreeViewMessageHeader(*(((NM_TREEVIEW*)someCallbackData.lParam()))));
+			case TVN_BEGINLABELEDIT :
+			  return tvnBeginLabelEdit(TreeViewDisplayInfo(*(((TV_DISPINFO*)someCallbackData.lParam()))));
+			case TVN_ENDLABELEDIT :
+				return tvnEndLabelEdit(TreeViewDisplayInfo(*(((TV_DISPINFO*)someCallbackData.lParam()))));
+			case TVN_KEYDOWN :	
+				return tvnKeyDown(TreeViewKeyDown(*(((TV_KEYDOWN*)someCallbackData.lParam()))));
+		}
+	}
+	return (CallbackData::ReturnType)::DefWindowProc(someCallbackData.hwndFrom(),WM_NOTIFY,someCallbackData.wParam(),someCallbackData.lParam());
+}
+
+HTREEITEM TreeView::addRootNode(DWORD itemIndex,const String &text,DWORD userData)
+{
+	TreeViewItem treeViewItem;
+	TreeViewInsert treeViewInsert;
+
+	treeViewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+	treeViewItem.text((LPSTR)(String&)text);
+	treeViewItem.maxText(text.length());
+	treeViewItem.image(itemIndex);
+	treeViewItem.selectedImage(I_IMAGECALLBACK);
+	treeViewItem.lParam(userData);
+	treeViewInsert.parent(TVGN_ROOT);
+	treeViewInsert.insertAfter(TVGN_ROOT);
+	treeViewInsert.viewItem(treeViewItem);
+	return insertItem(treeViewInsert);
+}
+
+WORD TreeView::appendNode(NodeType nodeType,DWORD itemIndex,const String &text,DWORD userData,WORD selected)
+{
+  HTREEITEM hInsertItem;
+	TreeViewItem treeViewItem;
+	TreeViewInsert treeViewInsert;
+
+	treeViewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+	treeViewItem.text((LPSTR)(String&)text);
+	treeViewItem.maxText(text.length());
+	treeViewItem.image(itemIndex);
+	treeViewItem.selectedImage(I_IMAGECALLBACK);
+	treeViewItem.lParam(userData);
+	if(NodeChild==nodeType)treeViewInsert.parent(mLastInsert.insertAfter());
+	else treeViewInsert.parent(mLastInsert.parent());
+	treeViewInsert.insertAfter(mLastInsert.insertAfter());
+	treeViewInsert.viewItem(treeViewItem);
+	hInsertItem=insertItem(treeViewInsert);
+	if(!hInsertItem)return FALSE;
+	if(selected)selectItem(hInsertItem);
+	return (hInsertItem?TRUE:FALSE);
+}
+
+WORD TreeView::addNode(NodeType nodeType,TreeViewItem &insertTreeViewItem,const String &parentString,WORD selected,BYTE delimeter)
+{
+	HTREEITEM hTreeItem;
+	HTREEITEM hPrevItem;
+	HTREEITEM hChildItem;													
+	String workString;
+	TreeViewInsert viewInsert;
+	TreeViewItem viewItem;
+
+	workString.length(String::MaxString);
+	viewItem.maxText(workString.length());
+	hTreeItem=getChild((HTREEITEM)TreeViewInsert::GetRoot);
+	while(hTreeItem)
+	{
+		hChildItem=getChild(hTreeItem);
+		if(hChildItem&&searchInsert(nodeType,insertTreeViewItem,viewInsert,parentString,hTreeItem,hChildItem,delimeter))
+		{
+			HTREEITEM hInsertItem(insertItem(viewInsert));
+			if(!hInsertItem)return FALSE;
+			if(selected)selectItem(hInsertItem);
+			return TRUE;
+		}
+		else
+		{
+			viewItem.mask(TreeViewItem::MaskText);
+			viewItem.item(hTreeItem);
+			viewItem.text((LPSTR)workString);
+			getItem(viewItem);
+			if(parentString==String(viewItem.text()).betweenString(0,delimeter))
+			{
+        String workString(insertTreeViewItem.text());
+				viewItem=TreeViewItem();
+				viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+				viewItem.text((LPSTR)workString);
+				viewItem.maxText(workString.length());
+				viewItem.image(insertTreeViewItem.image());
+				viewItem.selectedImage(I_IMAGECALLBACK);
+				viewItem.lParam(insertTreeViewItem.lParam());
+				viewInsert.parent(hTreeItem);
+				viewInsert.insertAfter(hPrevItem);
+				viewInsert.viewItem(viewItem);
+				HTREEITEM hInsertItem(insertItem(viewInsert));
+				if(!hInsertItem)return FALSE;
+				if(selected)selectItem(hInsertItem);
+				return TRUE;
+			}
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return FALSE;
+}
+
+HTREEITEM TreeView::searchItem(const String &searchString,HTREEITEM hDescendItem)const
+{
+  TreeViewItem viewItem;
+  String workString;
+  HTREEITEM hTreeItem;
+	HTREEITEM hChildItem;
+
+	workString.length(String::MaxString);
+	viewItem.maxText(workString.length());
+	if(!hDescendItem)hTreeItem=getChild((HTREEITEM)TreeViewInsert::GetRoot);
+	else hTreeItem=hDescendItem;
+	while(hTreeItem)
+	{
+	  hChildItem=getChild(hTreeItem);
+	  if(hChildItem)
+		{
+		  HTREEITEM hFoundItem(searchItem(searchString,hChildItem));
+			if(hFoundItem)return hFoundItem;
+		}
+		viewItem.mask(TreeViewItem::MaskText);
+		viewItem.item(hTreeItem);
+		viewItem.text((LPSTR)workString);
+		getItem(viewItem);
+		if(searchString==viewItem.text())return hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+	return (HTREEITEM)0;
+}
+
+WORD TreeView::searchInsert(NodeType nodeType,TreeViewItem &viewItem,TreeViewInsert &viewInsert,const String &parentString,HTREEITEM hParentItem,HTREEITEM hChildItem,BYTE delimeter)
+{
+	WORD searchResult(FALSE);
+	HTREEITEM hPrevItem(FALSE);
+	HTREEITEM hTreeItem(hChildItem);
+	HTREEITEM hChildNode;
+	TreeViewItem searchItem;
+	String bufferString;
+
+	bufferString.length(String::MaxString);
+	searchItem.maxText(bufferString.length());
+	while(hTreeItem)
+	{
+		hChildNode=getChild(hTreeItem);
+		if(hChildNode&&searchInsert(nodeType,viewItem,viewInsert,parentString,hTreeItem,hChildNode,delimeter))
+		{
+			searchResult=TRUE;
+			break;
+		}
+		searchItem.mask(TreeViewItem::MaskText);
+		searchItem.item(hTreeItem);
+		searchItem.text((LPSTR)bufferString);
+		getItem(searchItem);
+    if(parentString==delimeter?String(searchItem.text()).betweenString(0,delimeter):String(searchItem.text()))
+		{
+			viewItem.mask(TreeViewItem::MaskText|TreeViewItem::MaskImage|TreeViewItem::MaskSelectedImage|TreeViewItem::MaskParam);
+      viewItem.selectedImage(I_IMAGECALLBACK);
+			if(NodeChild==nodeType)viewInsert.parent(hTreeItem);
+			else viewInsert.parent(hParentItem);
+			viewInsert.insertAfter(hPrevItem);
+			viewInsert.viewItem(viewItem);
+			searchResult=TRUE;
+			break;
+		}
+		hPrevItem=hTreeItem;
+		hTreeItem=getNextSibling(hTreeItem);
+	}
+  return searchResult;
+}
+
+String TreeView::getRootItemText(void)const
+{
+	TreeViewItem viewItem;
+	String rootText;
+
+	viewItem.maxText(String::MaxString);
+	viewItem.mask(TreeViewItem::MaskText);
+	viewItem.item(getRoot());
+	viewItem.text((LPSTR)rootText);
+	getItem(viewItem);
+	return rootText;
+}
+
+String TreeView::currentSelection(void)const
+{
+	TreeViewItem viewItem;
+	String workString;
+
+	workString.length(String::MaxString);
+	viewItem.mask(TreeViewItem::MaskText);
+	viewItem.item(getSelection());
+	viewItem.text(workString);
+	viewItem.maxText(workString.length());
+	getItem(viewItem);
+	return (const char*)viewItem.text();
+}
+
+String TreeView::currentParentSelection(void)const
+{
+	TreeViewItem viewItem;
+	String workString;
+
+	workString.length(String::MaxString);
+	viewItem.mask(TreeViewItem::MaskText);
+	viewItem.item(getParent(getSelection()));
+	viewItem.text(workString);
+	viewItem.maxText(workString.length());
+  getItem(viewItem);
+	return (const char *)viewItem.text();
+}
+
+WORD TreeView::handleGetDisplayInfo(CallbackData &someCallbackData)
+{
+  WORD returnCode;
+  TreeViewDisplayInfo tvDispInfo(*((TV_DISPINFO*)someCallbackData.lParam()));
+	returnCode=tvnGetDispInfo(tvDispInfo);
+	*((TV_DISPINFO*)someCallbackData.lParam())=(TV_DISPINFO&)tvDispInfo;
+	return returnCode;
+}
+
+// *******virtuals
+
+WORD TreeView::tvnSelChanging(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnSelChanged(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnGetDispInfo(TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnSetDispInfo(TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnItemExpanding(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnItemExpanded(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+  return FALSE;
+}
+
+WORD TreeView::tvnBeginDrag(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnBeginRDrag(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnDeleteItem(const TreeViewMessageHeader &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnBeginLabelEdit(const TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnEndLabelEdit(const TreeViewDisplayInfo &/*treeViewDisplayInfo*/)
+{
+	return FALSE;
+}
+
+WORD TreeView::tvnKeyDown(const TreeViewKeyDown &/*treeViewMessageHeader*/)
+{
+	return FALSE;
+}
+

imagelst/TREEVIEW.HPP

@@ -0,0 +1,428 @@
+#ifndef _IMAGELIST_TREEVIEW_HPP_
+#define _IMAGELIST_TREEVIEW_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+#ifndef _COMMON_HOOKPROC_HPP_
+#include <common/hookproc.hpp>
+#endif
+#ifndef _COMMON_CONTROL_HPP_
+#include <common/control.hpp>
+#endif
+#ifndef _IMAGELIST_IMAGELIST_HPP_
+#include <imagelst/imagelst.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWINSERT_HPP_
+#include <imagelst/tvinsert.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+
+class TreeViewMessageHeader;
+class TreeViewDisplayInfo;
+class TreeViewKeyDown;
+class GUIWindow;
+class HitTestInfo;
+
+class TreeView : public Control
+{
+public:
+	enum TreeFlags{TreeHasButtons=TVS_HASBUTTONS,TreeHasLines=TVS_HASLINES,TreeLinesAtRoot=TVS_LINESATROOT,TreeEditLabels=TVS_EDITLABELS,TreeDisableDragDrop=TVS_DISABLEDRAGDROP,TreeShowSelAlways=TVS_SHOWSELALWAYS};
+	enum TreeExpand{Collapse=TVE_COLLAPSE,CollapseReset=TVE_COLLAPSERESET,Expand=TVE_EXPAND,Toggle=TVE_TOGGLE};
+	enum NodeType{NodeChild=0,NodeSibling=1};
+	enum ListType{Normal=TVSIL_NORMAL,State=TVSIL_STATE};
+	TreeView(GUIWindow &parentWindow,const Rect &winRect,int controlID,DWORD viewFlags=TreeHasLines);
+	virtual ~TreeView();
+	HIMAGELIST setImageList(ImageList &someImageList,WORD itemIndex=0);
+	HIMAGELIST createDragImage(HTREEITEM hTreeItem);
+	HTREEITEM addRootNode(DWORD indexImage,const String &textString,DWORD userData);
+	HWND getEditControl(void)const;
+	String currentSelection(void)const;
+	String currentParentSelection(void)const;
+	String getRootItemText(void)const;
+	UINT getCount(void)const;
+	HTREEITEM getRoot(void)const;
+	HTREEITEM getChild(HTREEITEM hTreeItem)const;
+	HTREEITEM getNextSibling(HTREEITEM hTreeItem)const;
+	HTREEITEM getParent(HTREEITEM hTreeItem)const;
+	HTREEITEM hitTest(HitTestInfo &someHitTestInfo)const;
+	HTREEITEM selectItem(HTREEITEM hTreeItem)const;
+	HTREEITEM selectRoot(void)const;
+	HTREEITEM selectDropTarget(HTREEITEM hTreeItem)const;
+	HTREEITEM insertItem(TreeViewInsert &someTreeViewInsert);
+  HTREEITEM searchItem(const String &searchString,HTREEITEM hDescendItem=(HTREEITEM)0)const;
+	HIMAGELIST getImageList(ListType listType=Normal);
+	const TreeViewInsert &lastInsert(void)const;
+	WORD addNode(NodeType nodeType,TreeViewItem &insertTreeViewItem,const String &parentString,WORD selected=FALSE,BYTE delimeter=0);
+	WORD appendNode(NodeType nodeType,DWORD itemIndex,const String &text,DWORD userData,WORD selected=FALSE);
+  WORD moveTree(int left,int top,int right,int bottom,WORD repaint=TRUE)const;
+	WORD getItemRect(Rect &itemRect,BOOL boundingText=TRUE)const;
+	WORD getItemRect(Rect &itemRect,HTREEITEM hTreeItem,BOOL boundingText=TRUE)const;
+  WORD getItem(TreeViewItem &someTreeViewItem)const;
+	WORD setItem(const TreeViewItem &someTreeViewItem)const;
+  WORD remove(HTREEITEM hTreeItem)const;
+	WORD remove(const String &nodeName)const;
+	WORD setRedraw(WORD redrawFlag)const;
+	WORD setFocus(void)const;
+	WORD remove(void)const;
+	WORD isOkay(void)const;
+protected:
+	virtual WORD tvnSelChanging(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnSelChanged(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnGetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnSetDispInfo(TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnItemExpanding(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnItemExpanded(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginDrag(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginRDrag(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnDeleteItem(const TreeViewMessageHeader &treeViewMessageHeader);
+	virtual WORD tvnBeginLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnEndLabelEdit(const TreeViewDisplayInfo &treeViewDisplayInfo);
+	virtual WORD tvnKeyDown(const TreeViewKeyDown &treeViewKeyDown);
+private:
+	CallbackData::ReturnType notifyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType rightButtonUpHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType rightButtonDownHandler(CallbackData &someCallbackData);
+	WORD handleGetDisplayInfo(CallbackData &someCallackData);
+	void createTreeView(const Rect &winRect,DWORD viewFlags,int controlID);
+	HTREEITEM selectSetFirstVisible(HTREEITEM hTreeItem);
+	HTREEITEM getDropHilight(void);
+	HTREEITEM getSelection(void)const;
+	HTREEITEM getFirstVisible(void);
+	HTREEITEM select(HTREEITEM hTreeItem,WPARAM code)const;
+	HTREEITEM getNextItem(HTREEITEM hTreeItem,WPARAM code)const;
+	HTREEITEM getPrevSibling(HTREEITEM hTreeItem);
+	HTREEITEM getNextVisible(HTREEITEM hTreeItem);
+	HTREEITEM getPrevVisible(HTREEITEM hTreeItem);
+
+	WORD sortChildren(HTREEITEM hTreeItem,WPARAM recurse);
+	WORD expand(HTREEITEM hTreeItem,WPARAM code);
+	WORD getISearchString(String &searchString);
+	WORD searchInsert(NodeType nodeType,TreeViewItem &viewItem,TreeViewInsert &viewInsert,const String &parentString,HTREEITEM hParentItem,HTREEITEM hChildItem,BYTE delimeter=0);
+	WORD ensureVisible(HTREEITEM hTreeItem);
+	WORD endEditLabelNow(WPARAM cancel);
+	WORD setIndent(WORD indent);
+	HWND getEditLabel(HTREEITEM hTreeItem);
+	UINT getVisibleCount(void);
+	UINT getIndent(void);
+	UINT indent(void);
+	void indent(UINT indent);
+
+	Callback<TreeView> mNotifyHandler;
+	GUIWindow &mParentWindow;
+  TreeViewInsert mLastInsert;
+};
+
+inline
+UINT TreeView::indent(void)
+{
+	if(!isOkay())return FALSE;
+	return (UINT)sendMessage(TVM_GETINDENT,0,0L);
+}
+
+inline
+void TreeView::indent(UINT indent)
+{
+	if(!isOkay())return;
+	sendMessage(TVM_SETINDENT,(WPARAM)indent,0L);
+}
+
+inline
+HTREEITEM TreeView::insertItem(TreeViewInsert &someTreeViewInsert)
+{
+  HTREEITEM hTreeItem;
+	if(!isOkay())return FALSE;
+  hTreeItem=(HTREEITEM)sendMessage(TVM_INSERTITEM,0,(LPARAM)&((TV_INSERTSTRUCT&)someTreeViewInsert));
+	if(hTreeItem){mLastInsert=someTreeViewInsert;mLastInsert.insertAfter(hTreeItem);}
+  return hTreeItem;
+}
+
+inline
+WORD TreeView::remove(HTREEITEM hTreeItem)const
+{
+	if(!isOkay())return FALSE;
+	return sendMessage(TVM_DELETEITEM,0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::expand(HTREEITEM hTreeItem,WPARAM code)
+{
+	if(!isOkay())return FALSE;
+	return sendMessage(TVM_EXPAND,(WPARAM)code,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+UINT TreeView::getCount(void)const
+{
+	if(!isOkay())return FALSE;
+	return (UINT)sendMessage(TVM_GETCOUNT,0,0L);
+}
+
+inline
+UINT TreeView::getIndent(void)
+{
+	if(!isOkay())return FALSE;
+	return (UINT)sendMessage(TVM_GETINDENT,0,0L);
+}
+
+inline
+WORD TreeView::setIndent(WORD indent)
+{
+	if(!isOkay())return FALSE;
+	return (WORD)sendMessage(TVM_SETINDENT,(WPARAM)indent,0L);
+}
+
+inline
+HIMAGELIST TreeView::getImageList(ListType listType)
+{
+	if(!isOkay())return FALSE;
+	return (HIMAGELIST)sendMessage(TVM_GETIMAGELIST,(WPARAM)listType,0L);
+}
+
+inline
+HIMAGELIST TreeView::setImageList(ImageList &someImageList,WORD indexImage)
+{
+	if(!isOkay()||!someImageList.isOkay())return FALSE;
+	return (HIMAGELIST)sendMessage(TVM_SETIMAGELIST,indexImage,(LPARAM)(HIMAGELIST)someImageList);
+}
+
+inline
+HTREEITEM TreeView::getNextItem(HTREEITEM hTreeItem,WPARAM code)const
+{
+	if(!isOkay())return FALSE;
+	return (HTREEITEM)sendMessage(TVM_GETNEXTITEM,(WPARAM)code,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+HTREEITEM TreeView::getChild(HTREEITEM hTreeItem)const
+{
+	return getNextItem(hTreeItem,TVGN_CHILD);
+}
+
+inline
+HTREEITEM TreeView::getNextSibling(HTREEITEM hTreeItem)const
+{
+	return getNextItem(hTreeItem,TVGN_NEXT);
+}
+
+inline
+HTREEITEM TreeView::getPrevSibling(HTREEITEM hTreeItem)
+{
+	return getNextItem(hTreeItem,TVGN_PREVIOUS);
+}
+
+inline
+HTREEITEM TreeView::getParent(HTREEITEM hTreeItem)const
+{
+	return getNextItem(hTreeItem,TVGN_PARENT);
+}
+
+inline
+HTREEITEM TreeView::getFirstVisible(void)
+{
+	return getNextItem(0,TVGN_FIRSTVISIBLE);
+}
+
+inline
+HTREEITEM TreeView::getNextVisible(HTREEITEM hTreeItem)
+{
+	return getNextItem(hTreeItem,TVGN_NEXTVISIBLE);
+}
+
+inline
+HTREEITEM TreeView::getPrevVisible(HTREEITEM hTreeItem)
+{
+	return getNextItem(hTreeItem,TVGN_PREVIOUSVISIBLE);
+}
+
+inline
+HTREEITEM TreeView::getSelection(void)const
+{
+	return getNextItem(0,TVGN_CARET);
+}
+
+inline
+HTREEITEM TreeView::getDropHilight(void)
+{
+	return getNextItem(0,TVGN_DROPHILITE);
+}
+
+inline
+HTREEITEM TreeView::getRoot(void)const
+{
+	return getNextItem(0,TVGN_ROOT);
+}
+
+inline
+HTREEITEM TreeView::select(HTREEITEM hTreeItem,WPARAM code)const
+{
+	if(!isOkay())return FALSE;
+	return (HTREEITEM)sendMessage(TVM_SELECTITEM,(WPARAM)code,(LPARAM)(HTREEITEM)(hTreeItem));
+}
+
+inline
+HTREEITEM TreeView::selectItem(HTREEITEM hTreeItem)const
+{
+	return select(hTreeItem,TVGN_CARET);
+}
+
+inline
+HTREEITEM TreeView::selectRoot(void)const
+{
+  return selectItem(getRoot());
+}
+
+inline
+HTREEITEM TreeView::selectDropTarget(HTREEITEM hTreeItem)const
+{
+	return select(hTreeItem,TVGN_DROPHILITE);
+}
+
+inline
+HTREEITEM TreeView::selectSetFirstVisible(HTREEITEM hTreeItem)
+{
+	return select(hTreeItem,TVGN_FIRSTVISIBLE);
+}
+
+inline
+WORD TreeView::getItem(TreeViewItem &someTreeViewItem)const
+{
+	if(!isOkay())return FALSE;
+	return (WORD)sendMessage(TVM_GETITEM,0,(LPARAM)&((TV_ITEM&)someTreeViewItem));
+}
+
+inline
+WORD TreeView::setItem(const TreeViewItem &someTreeViewItem)const
+{
+	if(!isOkay())return FALSE;
+	return (WORD)sendMessage(TVM_SETITEM,0,(LPARAM)&((TV_ITEM&)(TreeViewItem&)someTreeViewItem));
+}
+
+inline
+HWND TreeView::getEditLabel(HTREEITEM hTreeItem)
+{
+	if(!isOkay())return FALSE;
+	return (HWND)sendMessage(TVM_EDITLABEL,0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+HWND TreeView::getEditControl(void)const
+{
+	if(!isOkay())return FALSE;
+	return (HWND)sendMessage(TVM_GETEDITCONTROL,0,0L);
+}
+
+inline
+UINT TreeView::getVisibleCount(void)
+{
+	if(!isOkay())return FALSE;
+	return (UINT)sendMessage(TVM_GETVISIBLECOUNT,0,0L);
+}
+
+inline
+HIMAGELIST TreeView::createDragImage(HTREEITEM hTreeItem)
+{
+	if(!isOkay())return FALSE;
+	return (HIMAGELIST)sendMessage(TVM_CREATEDRAGIMAGE,0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::sortChildren(HTREEITEM hTreeItem,WPARAM recurse)
+{
+	if(!isOkay())return FALSE;
+	return sendMessage(TVM_SORTCHILDREN,(WPARAM)recurse,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::ensureVisible(HTREEITEM hTreeItem)
+{
+	if(!isOkay())return FALSE;
+	return sendMessage(TVM_ENSUREVISIBLE,(WPARAM)0,(LPARAM)(HTREEITEM)hTreeItem);
+}
+
+inline
+WORD TreeView::endEditLabelNow(WPARAM cancel)
+{
+	if(!isOkay())return FALSE;
+	return sendMessage(TVM_ENDEDITLABELNOW,(WPARAM)cancel,0L);
+}
+
+inline
+WORD TreeView::getISearchString(String &searchString)
+{
+	if(!isOkay())return FALSE;
+	return (WORD)sendMessage(TVM_GETISEARCHSTRING,0,(LPARAM)(LPSTR)searchString);
+}
+
+inline
+WORD TreeView::getItemRect(Rect &itemRect,BOOL boundingText)const
+{
+  if(!isOkay())return FALSE;
+  *((HTREEITEM*)&((RECT&)itemRect))=getSelection();
+	return (WORD)sendMessage(TVM_GETITEMRECT,boundingText,(LPARAM)&((RECT&)itemRect));
+}
+
+inline
+WORD TreeView::getItemRect(Rect &itemRect,HTREEITEM hTreeItem,BOOL boundingText)const
+{
+  if(!isOkay())return FALSE;
+  *((HTREEITEM*)&((RECT&)itemRect))=hTreeItem;
+	return (WORD)sendMessage(TVM_GETITEMRECT,boundingText,(LPARAM)&((RECT&)itemRect));
+}
+
+inline
+WORD TreeView::setRedraw(WORD redrawFlag)const
+{
+  if(!isOkay())return FALSE;
+	return (WORD)sendMessage(WM_SETREDRAW,redrawFlag,0L);
+}
+
+inline
+WORD TreeView::moveTree(int left,int top,int right,int bottom,WORD repaint)const
+{
+  if(!isOkay())return FALSE;
+	return moveWindow(left,top,right,bottom,repaint);
+}
+
+inline
+WORD TreeView::setFocus(void)const
+{
+  if(!isOkay())return FALSE;
+	setFocus();
+	return TRUE;
+}
+
+inline
+WORD TreeView::remove(const String &nodeName)const
+{
+  if(!isOkay())return FALSE;
+  HTREEITEM hTreeItem(searchItem(nodeName));
+	if(!hTreeItem)return FALSE;
+	return remove(hTreeItem);
+}
+
+inline
+const TreeViewInsert &TreeView::lastInsert(void)const
+{
+  return mLastInsert;
+}
+
+inline
+WORD TreeView::isOkay(void)const
+{
+  return isValid();
+}
+#endif

imagelst/TVDISP.HPP

@@ -0,0 +1,117 @@
+#ifndef _IMAGELIST_TREEVIEWDISPLAYINFO_HPP_
+#define _IMAGELIST_TREEVIEWDISPLAYINFO_HPP_
+#ifndef _COMMON_NOTIFYMESSAGEHEADER_HPP_
+#include <common/notify.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+
+class TreeViewDisplayInfo : private TV_DISPINFO
+{
+public:
+  TreeViewDisplayInfo(void);
+	TreeViewDisplayInfo(const TreeViewDisplayInfo &someTreeViewDisplayInfo);
+	TreeViewDisplayInfo(const TV_DISPINFO &someTVDISPINFO);
+	virtual ~TreeViewDisplayInfo();
+	TreeViewDisplayInfo &operator=(const TreeViewDisplayInfo &someTreeViewDisplayInfo);
+	TreeViewDisplayInfo &operator=(const TV_DISPINFO &someTVDISPINFO);
+	WORD operator==(const TreeViewDisplayInfo &someTreeViewDisplayInfo)const;
+	WORD operator==(const TV_DISPINFO &someTVDISPINFO)const;
+	operator TV_DISPINFO &(void);
+	NotifyMessageHeader nmHeader(void)const;
+	void nmHeader(const NotifyMessageHeader &someNotifyMessageHeader);
+	TreeViewItem item(void)const;
+	void item(const TreeViewItem &someTreeViewItem);
+private:
+  void init(void);
+};
+
+inline
+TreeViewDisplayInfo::TreeViewDisplayInfo(void)
+{
+  init();
+}
+
+inline
+TreeViewDisplayInfo::TreeViewDisplayInfo(const TreeViewDisplayInfo &someTreeViewDisplayInfo)
+{
+  *this=someTreeViewDisplayInfo;
+}
+
+inline
+TreeViewDisplayInfo::TreeViewDisplayInfo(const TV_DISPINFO &someTVDISPINFO)
+{
+  *this=someTVDISPINFO;
+}
+
+inline
+TreeViewDisplayInfo::~TreeViewDisplayInfo()
+{
+}
+
+inline
+TreeViewDisplayInfo &TreeViewDisplayInfo::operator=(const TreeViewDisplayInfo &someTreeViewDisplayInfo)
+{
+  nmHeader(someTreeViewDisplayInfo.nmHeader());
+	item(someTreeViewDisplayInfo.item());
+	return *this;
+}
+
+inline
+TreeViewDisplayInfo &TreeViewDisplayInfo::operator=(const TV_DISPINFO &someTVDISPINFO)
+{
+  (TV_DISPINFO&)*this=someTVDISPINFO;
+	return *this;
+}
+
+inline
+WORD TreeViewDisplayInfo::operator==(const TreeViewDisplayInfo &someTreeViewDisplayInfo)const
+{
+  return (nmHeader()==someTreeViewDisplayInfo.nmHeader()&&
+	        item()==someTreeViewDisplayInfo.item());
+}
+
+inline
+WORD TreeViewDisplayInfo::operator==(const TV_DISPINFO &someTVDISPINFO)const
+{
+  return (nmHeader()==NotifyMessageHeader(someTVDISPINFO.hdr)&&
+	        item()==TreeViewItem(someTVDISPINFO.item));
+}
+
+inline
+TreeViewDisplayInfo::operator TV_DISPINFO &(void)
+{
+  return *this;
+}
+
+inline
+NotifyMessageHeader TreeViewDisplayInfo::nmHeader(void)const
+{
+  return TV_DISPINFO::hdr;
+}
+
+inline
+void TreeViewDisplayInfo::nmHeader(const NotifyMessageHeader &someNotifyMessageHeader)
+{
+  TV_DISPINFO::hdr=(NMHDR&)someNotifyMessageHeader;
+}
+
+inline
+TreeViewItem TreeViewDisplayInfo::item(void)const
+{
+  return TV_DISPINFO::item;
+}
+
+inline
+void TreeViewDisplayInfo::item(const TreeViewItem &someTreeViewItem)
+{
+  TV_DISPINFO::item=(TV_ITEM&)someTreeViewItem;
+}
+
+inline
+void TreeViewDisplayInfo::init(void)
+{
+  ::memset(&((TV_DISPINFO&)*this),0,sizeof(TV_DISPINFO));
+}
+#endif

imagelst/TVINFO.HPP

@@ -0,0 +1,59 @@
+#ifndef _IMAGELST_TREEVIEWINFO_HPP_
+#define _IMAGELST_TREEVIEWINFO_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _IMAGELIST_NOTIFYMESSAGEHEADER_HPP_
+#include <imagelst/notify.hpp>
+#endif
+#ifndef _IMAGELST_TREEVIEWINFO_HPP_
+#include <imagelst/tvinfo.hpp>
+#endif
+
+class TreeViewInfo : public NotifyMessageHeader, public TreeViewItem
+{
+public:
+	TreeViewInfo(void);
+	TreeViewInfo(const TreeViewInfo &someTreeViewInfo);
+	~TreeViewInfo();
+	TreeViewInfo &operator=(const TreeViewInfo &someTreeViewInfo);
+	WORD operator==(const TreeViewInfo &someTreeViewInfo)const;
+private:
+};
+
+inline
+TreeViewInfo::TreeViewInfo(void)
+{
+}
+
+inline
+TreeViewInfo::TreeViewInfo(const TreeViewInfo &someTreeViewInfo)
+{
+	*this=someTreeViewInfo;
+}
+
+inline
+TreeViewInfo::~TreeViewInfo()
+{
+}
+
+inline
+TreeViewInfo &TreeViewInfo::operator=(const TreeViewInfo &someTreeViewInfo)
+{
+	(NotifyMessageHeader&)*this=(NotifyMessageHeader&)someTreeViewInfo;
+	(TreeViewItem&)*this=(TreeViewItem&)someTreeViewInfo;
+	return *this;
+}
+
+inline
+WORD TreeViewInfo::operator==(const TreeViewInfo &someTreeViewInfo)const
+{
+	return ((NotifyMessageHeader&)*this==(NotifyMessageHeader&)someTreeViewInfo&&
+					(TreeViewItem&)*this==(TreeViewItem&)someTreeViewInfo);
+}
+#endif
+
+

imagelst/TVINSERT.HPP

@@ -0,0 +1,109 @@
+#ifndef _IMAGELIST_TREEVIEWINSERT_HPP_
+#define _IMAGELIST_TREEVIEWINSERT_HPP_
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+
+class TreeViewInsert : private TV_INSERTSTRUCT
+{
+public:
+	enum InsertFlags{InsertRoot=(int)TVI_ROOT,InsertFirst=(int)TVI_FIRST,
+			 InsertLast=(int)TVI_LAST,InsertSort=(int)TVI_SORT};
+	enum GetFlags{GetRoot=TVGN_ROOT,GetNext=TVGN_NEXT,GetPrevious=TVGN_PREVIOUS,
+			 GetParent=TVGN_PARENT,GetChild=TVGN_CHILD,GetFirstVisible=TVGN_FIRSTVISIBLE,
+			 GetNextVisible=TVGN_NEXTVISIBLE,GetPreviousVisible=TVGN_PREVIOUSVISIBLE,
+			 GetDropHilite=TVGN_DROPHILITE,GetCaret=TVGN_CARET}; 
+	TreeViewInsert(void);
+	TreeViewInsert(const TreeViewInsert &someTreeViewInsert);
+	virtual ~TreeViewInsert();
+	operator TV_INSERTSTRUCT&(void);
+	TreeViewInsert &operator=(const TreeViewInsert &someTreeViewInsert);
+	HTREEITEM parent(void)const;
+	void parent(HTREEITEM hParent);
+	HTREEITEM insertAfter(void)const;
+	void insertAfter(HTREEITEM hInsertAfter);
+	void insertAfter(InsertFlags insertFlags);
+	TreeViewItem viewItem(void)const;
+	void viewItem(const TreeViewItem &someTreeViewItem);
+private:
+};
+
+inline
+TreeViewInsert::TreeViewInsert(void)
+{
+	parent(0);
+	insertAfter(0);
+	viewItem(TreeViewItem());
+}
+
+inline
+TreeViewInsert::TreeViewInsert(const TreeViewInsert &someTreeViewInsert)
+{
+  *this=someTreeViewInsert;
+}
+
+inline
+TreeViewInsert::~TreeViewInsert()
+{
+}
+
+inline
+TreeViewInsert &TreeViewInsert::operator=(const TreeViewInsert &someTreeViewInsert)
+{
+	parent(someTreeViewInsert.parent());
+	insertAfter(someTreeViewInsert.insertAfter());
+	viewItem(someTreeViewInsert.viewItem());
+	return *this;
+}
+
+inline
+TreeViewInsert::operator TV_INSERTSTRUCT&(void)
+{
+	return *this;
+}
+
+inline
+HTREEITEM TreeViewInsert::parent(void)const
+{
+	return TV_INSERTSTRUCT::hParent;
+}
+
+inline
+void TreeViewInsert::parent(HTREEITEM hParent)
+{
+	TV_INSERTSTRUCT::hParent=hParent;
+}
+
+inline
+HTREEITEM TreeViewInsert::insertAfter(void)const
+{
+	return TV_INSERTSTRUCT::hInsertAfter;
+}
+
+inline
+void TreeViewInsert::insertAfter(HTREEITEM hInsertAfter)
+{
+	TV_INSERTSTRUCT::hInsertAfter=hInsertAfter;
+}
+
+inline
+void TreeViewInsert::insertAfter(InsertFlags insertFlags)
+{
+  TV_INSERTSTRUCT::hInsertAfter=((HTREEITEM)insertFlags);
+}
+
+inline
+TreeViewItem TreeViewInsert::viewItem(void)const
+{
+	return TreeViewItem(TV_INSERTSTRUCT::item);
+}
+
+inline
+void TreeViewInsert::viewItem(const TreeViewItem &someTreeViewItem)
+{
+	::memcpy((char*)&item,(char*)&((TV_ITEM&)someTreeViewItem),sizeof(TV_ITEM));
+}
+#endif

imagelst/TVITEM.HPP

@@ -0,0 +1,300 @@
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#define _IMAGELIST_TREEVIEWITEM_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_COMMCTRL_HPP_
+#include <common/commctrl.hpp>
+#endif
+
+class TreeViewItem : private TV_ITEM
+{
+public:
+	enum ItemFlags{MaskText=TVIF_TEXT,MaskImage=TVIF_IMAGE,MaskParam=TVIF_PARAM,
+			 MaskState=TVIF_STATE,MaskHandle=TVIF_HANDLE,MaskSelectedImage=TVIF_SELECTEDIMAGE,
+			 MaskChildren=TVIF_CHILDREN};
+	enum StateFlags{StateSelected=TVIS_SELECTED,StateCut=TVIS_CUT,
+	  StateDropHilited=TVIS_DROPHILITED,StateBold=TVIS_BOLD,
+		StateExpanded=TVIS_EXPANDED,StateExpandedOnce=TVIS_EXPANDEDONCE};
+	TreeViewItem(void);
+	TreeViewItem(const TreeViewItem &someTreeViewItem);
+	TreeViewItem(const TV_ITEM &someTVITEM);
+	TreeViewItem(UINT maskParam,HTREEITEM itemParam,UINT stateParam,UINT stateMask,LPSTR pszTextParam,DWORD maxTextParam,DWORD imageParam,DWORD selectedImageParam,DWORD childrenParam,DWORD lParam);
+	virtual ~TreeViewItem();
+	TreeViewItem &operator=(const TreeViewItem &someTreeViewItem);
+	TreeViewItem &operator=(const TV_ITEM &someTVITEM);
+	WORD operator==(const TreeViewItem &someTreeViewItem)const;
+	WORD operator==(const TV_ITEM &someTVITEM)const;
+	operator TV_ITEM&(void);
+	UINT mask(void)const;
+	void mask(UINT mask);
+	HTREEITEM item(void)const;
+	void item(HTREEITEM item);
+	UINT state(void)const;
+	void state(UINT state);
+	UINT stateMask(void)const;
+	void stateMask(UINT stateMask);
+	LPSTR text(void)const;
+	void text(LPSTR pszText);
+	DWORD maxText(void)const;
+	void maxText(DWORD maxText);
+	DWORD image(void)const;
+	void image(DWORD image);
+	DWORD selectedImage(void)const;
+	void selectedImage(DWORD selectedImage);
+	DWORD children(void)const;
+	void children(DWORD children);
+	LPARAM lParam(void)const;
+	void lParam(LPARAM lParam);
+private:
+	void clearData(void);
+};
+
+inline
+TreeViewItem::TreeViewItem(void)
+{
+  clearData();
+}
+
+inline
+TreeViewItem::TreeViewItem(const TreeViewItem &someTreeViewItem)
+{
+	clearData();
+	*this=someTreeViewItem;
+}
+
+inline
+TreeViewItem::TreeViewItem(const TV_ITEM &someTVITEM)
+{
+  *this=someTVITEM;
+}
+
+inline
+TreeViewItem::TreeViewItem(UINT maskParam,HTREEITEM itemParam,UINT stateParam,UINT stateMaskParam,LPSTR pszTextParam,DWORD maxTextParam,DWORD imageParam,DWORD selectedImageParam,DWORD childrenParam,DWORD lParamParam)
+{
+	clearData();
+	mask(maskParam);
+	item(itemParam);
+	state(stateParam);
+	stateMask(stateMaskParam);
+	text(pszTextParam);
+	maxText(maxTextParam);
+	image(imageParam);
+	selectedImage(selectedImageParam);
+	children(childrenParam);
+	lParam(lParamParam);
+}
+
+inline
+TreeViewItem::~TreeViewItem()
+{
+}
+
+inline
+TreeViewItem::operator TV_ITEM &(void)
+{
+	return *this;
+}
+
+inline
+TreeViewItem &TreeViewItem::operator=(const TreeViewItem &someTreeViewItem)
+{
+	mask(someTreeViewItem.mask());
+	item(someTreeViewItem.item());
+	state(someTreeViewItem.state());
+	stateMask(someTreeViewItem.stateMask());
+	text(someTreeViewItem.text());
+	maxText(someTreeViewItem.maxText());
+	image(someTreeViewItem.image());
+	selectedImage(someTreeViewItem.selectedImage());
+	children(someTreeViewItem.children());
+	lParam(someTreeViewItem.lParam());
+	return *this;
+}
+
+inline
+TreeViewItem &TreeViewItem::operator=(const TV_ITEM &someTVITEM)
+{
+	mask(someTVITEM.mask);
+	item(someTVITEM.hItem);
+	state(someTVITEM.state);
+	stateMask(someTVITEM.stateMask);
+	text(someTVITEM.pszText);
+	maxText(someTVITEM.cchTextMax);
+	image(someTVITEM.iImage);
+	selectedImage(someTVITEM.iSelectedImage);
+	children(someTVITEM.cChildren);
+	lParam(someTVITEM.lParam);
+	return *this;
+}
+
+inline
+WORD TreeViewItem::operator==(const TreeViewItem &someTreeViewItem)const
+{
+	return (mask()==someTreeViewItem.mask()&&
+					item()==someTreeViewItem.item()&&
+					state()==someTreeViewItem.state()&&
+					stateMask()==someTreeViewItem.stateMask()&&
+					text()==someTreeViewItem.text()&&
+					maxText()==someTreeViewItem.maxText()&&
+					image()==someTreeViewItem.image()&&
+					selectedImage()==someTreeViewItem.selectedImage()&&
+					children()==someTreeViewItem.children()&&
+					lParam()==someTreeViewItem.lParam());
+}
+
+inline
+WORD TreeViewItem::operator==(const TV_ITEM &someTVITEM)const
+{
+  return (TV_ITEM::mask==someTVITEM.mask&&
+          TV_ITEM::hItem==someTVITEM.hItem&&
+          TV_ITEM::state==someTVITEM.state&&
+          TV_ITEM::stateMask==someTVITEM.stateMask&&
+          TV_ITEM::pszText==someTVITEM.pszText&&
+          TV_ITEM::cchTextMax==someTVITEM.cchTextMax&&
+          TV_ITEM::iImage==someTVITEM.iImage&&
+          TV_ITEM::iSelectedImage==someTVITEM.iSelectedImage&&
+          TV_ITEM::cChildren==someTVITEM.cChildren&&
+          TV_ITEM::lParam==someTVITEM.lParam);
+}
+
+inline
+void TreeViewItem::clearData(void)
+{
+  TV_ITEM::mask=0;
+  TV_ITEM::hItem=0;
+  TV_ITEM::state=0;
+  TV_ITEM::stateMask=0;
+  TV_ITEM::pszText=0;
+  TV_ITEM::cchTextMax=0;
+  TV_ITEM::iImage=0;
+  TV_ITEM::iSelectedImage=0;
+  TV_ITEM::cChildren=0;
+  TV_ITEM::lParam=0;
+}
+
+inline
+UINT TreeViewItem::mask(void)const
+{
+	return TV_ITEM::mask;
+}
+
+inline
+void TreeViewItem::mask(UINT mask)
+{
+	TV_ITEM::mask=mask;
+}
+
+inline
+HTREEITEM TreeViewItem::item(void)const
+{
+	return TV_ITEM::hItem;
+}
+
+inline
+void TreeViewItem::item(HTREEITEM hItem)
+{
+	TV_ITEM::hItem=hItem;
+}
+
+inline
+UINT TreeViewItem::state(void)const
+{
+	return TV_ITEM::state;
+}
+
+inline
+void TreeViewItem::state(UINT state)
+{
+	TV_ITEM::state=state;
+}
+
+inline
+UINT TreeViewItem::stateMask(void)const
+{
+	return TV_ITEM::stateMask;
+}
+
+inline
+void TreeViewItem::stateMask(UINT stateMask)
+{
+	TV_ITEM::stateMask=stateMask;
+}
+
+inline
+LPSTR TreeViewItem::text(void)const
+{
+	return TV_ITEM::pszText;
+}
+
+inline
+void TreeViewItem::text(LPSTR pszText)
+{
+  TV_ITEM::pszText=pszText;
+}
+
+inline
+DWORD TreeViewItem::maxText(void)const
+{
+  return TV_ITEM::cchTextMax;
+}
+
+inline
+void TreeViewItem::maxText(DWORD maxText)
+{
+	TV_ITEM::cchTextMax=maxText;
+}
+
+inline
+DWORD TreeViewItem::image(void)const
+{
+	return TV_ITEM::iImage;
+}
+
+inline
+void TreeViewItem::image(DWORD image)
+{
+	TV_ITEM::iImage=image;
+}
+
+inline
+DWORD TreeViewItem::selectedImage(void)const
+{
+	return TV_ITEM::iSelectedImage;
+}
+
+inline
+void TreeViewItem::selectedImage(DWORD selectedImage)
+{
+	TV_ITEM::iSelectedImage=selectedImage;
+}
+
+inline
+DWORD TreeViewItem::children(void)const
+{
+	return TV_ITEM::cChildren;
+}
+
+inline
+void TreeViewItem::children(DWORD children)
+{
+	TV_ITEM::cChildren=children;
+}
+
+inline
+LPARAM TreeViewItem::lParam(void)const
+{
+	return TV_ITEM::lParam;
+}
+
+inline
+void TreeViewItem::lParam(LPARAM lParam)
+{
+	TV_ITEM::lParam=lParam;
+}
+#endif
+
+
+
+
+

imagelst/TVITEMEX.HPP

@@ -0,0 +1,72 @@
+#ifndef _IMAGELST_TREEVIEWITEMEX_HPP_
+#define _IMAGELST_TREEVIEWITEMEX_HPP_
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+
+class TreeViewItemEx : public TreeViewItem
+{
+public:
+	TreeViewItemEx(void);
+	TreeViewItemEx(const TreeViewItemEx &someTreeViewItemEx);
+	TreeViewItemEx(const TreeViewItem &someTreeViewItem);
+	~TreeViewItemEx();
+	TreeViewItemEx &operator=(const TreeViewItemEx &someTreeViewItemEx);
+	WORD operator==(const TreeViewItemEx &someTreeViewItemEx);
+	HTREEITEM parent(void)const;
+	void parent(HTREEITEM parent);
+private:
+	HTREEITEM mhParent;
+};
+
+inline
+TreeViewItemEx::TreeViewItemEx(void)
+: mhParent(0)
+{
+}
+
+inline
+TreeViewItemEx::TreeViewItemEx(const TreeViewItemEx &someTreeViewItemEx)
+{
+	*this=someTreeViewItemEx;
+}
+
+inline
+TreeViewItemEx::TreeViewItemEx(const TreeViewItem &someTreeViewItem)
+: mhParent(0), TreeViewItem(someTreeViewItem)
+{
+}
+
+inline
+TreeViewItemEx::~TreeViewItemEx()
+{
+}
+
+inline
+TreeViewItemEx &TreeViewItemEx::operator=(const TreeViewItemEx &someTreeViewItemEx)
+{
+	(TreeViewItem&)*this=(TreeViewItem&)someTreeViewItemEx;
+	parent(someTreeViewItemEx.parent());
+	return *this;
+}
+
+inline
+WORD TreeViewItemEx::operator==(const TreeViewItemEx &someTreeViewItemEx)
+{
+	return ((TreeViewItem&)*this==(TreeViewItem&)someTreeViewItemEx&&
+          parent()==someTreeViewItemEx.parent());
+}
+
+inline
+HTREEITEM TreeViewItemEx::parent(void)const
+{
+	return mhParent;
+}
+
+inline
+void TreeViewItemEx::parent(HTREEITEM hParent)
+{
+  mhParent=hParent;
+}
+#endif
+

imagelst/TVKEY.HPP

@@ -0,0 +1,134 @@
+#ifndef _IMAGELIST_TREEVIEWKEYDOWN_HPP_
+#define _IMAGELIST_TREEVIEWKEYDOWN_HPP_
+#ifndef _COMMON_NOTIFYMESSAGEHEADER_HPP_
+#include <common/notify.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+
+class TreeViewKeyDown : private TV_KEYDOWN
+{
+public:
+  TreeViewKeyDown(void);
+	TreeViewKeyDown(const TreeViewKeyDown &someTreeViewKeyDown);
+	TreeViewKeyDown(const TV_KEYDOWN &someTVKEYDOWN);
+	virtual ~TreeViewKeyDown();
+	TreeViewKeyDown &operator=(const TreeViewKeyDown &someTreeViewKeyDown);
+	TreeViewKeyDown &operator=(const TV_KEYDOWN &someTVKEYDOWN);
+	BOOL operator==(const TreeViewKeyDown &someTreeViewKeyDown)const;
+	BOOL operator==(const TV_KEYDOWN &someTVKEYDOWN)const;
+	operator TV_KEYDOWN &(void);
+	NotifyMessageHeader nmHeader(void)const;
+	void nmHeader(const NotifyMessageHeader &someNotifyMessageHeader);
+	WORD virtualKey(void)const;
+	void virtualKey(WORD virtualKey);
+	UINT flags(void)const;
+	void flags(UINT flags);
+private:
+  void init(void);
+};
+
+inline
+TreeViewKeyDown::TreeViewKeyDown(void)
+{
+  init();
+}
+
+inline
+TreeViewKeyDown::TreeViewKeyDown(const TreeViewKeyDown &someTreeViewKeyDown)
+{
+  *this=someTreeViewKeyDown;
+}
+
+inline
+TreeViewKeyDown::TreeViewKeyDown(const TV_KEYDOWN &someTVKEYDOWN)
+{
+  *this=someTVKEYDOWN;
+}
+
+inline
+TreeViewKeyDown::~TreeViewKeyDown()
+{
+}
+
+inline
+TreeViewKeyDown &TreeViewKeyDown::operator=(const TreeViewKeyDown &someTreeViewKeyDown)
+{
+  nmHeader(someTreeViewKeyDown.nmHeader());
+	virtualKey(someTreeViewKeyDown.virtualKey());
+	flags(someTreeViewKeyDown.flags());
+	return *this;
+}
+
+inline
+TreeViewKeyDown &TreeViewKeyDown::operator=(const TV_KEYDOWN &someTVKEYDOWN)
+{
+  (TV_KEYDOWN&)*this=someTVKEYDOWN;
+	return *this;
+}
+
+inline
+BOOL TreeViewKeyDown::operator==(const TreeViewKeyDown &someTreeViewKeyDown)const
+{
+  return (nmHeader()==someTreeViewKeyDown.nmHeader()&&
+	        virtualKey()==someTreeViewKeyDown.virtualKey()&&
+					flags()==someTreeViewKeyDown.flags());
+}
+
+inline
+BOOL TreeViewKeyDown::operator==(const TV_KEYDOWN &someTVKEYDOWN)const
+{
+  return (nmHeader()==NotifyMessageHeader(someTVKEYDOWN.hdr)&&
+	        virtualKey()==someTVKEYDOWN.wVKey&&
+					flags()==someTVKEYDOWN.flags);
+}
+
+inline
+TreeViewKeyDown::operator TV_KEYDOWN &(void)
+{
+  return *this;
+}
+
+inline
+NotifyMessageHeader TreeViewKeyDown::nmHeader(void)const
+{
+  return TV_KEYDOWN::hdr;
+}
+
+inline
+void TreeViewKeyDown::nmHeader(const NotifyMessageHeader &someNotifyMessageHeader)
+{
+  TV_KEYDOWN::hdr=(NMHDR&)someNotifyMessageHeader;
+}
+
+inline
+WORD TreeViewKeyDown::virtualKey(void)const
+{
+  return TV_KEYDOWN::wVKey;
+}
+
+inline
+void TreeViewKeyDown::virtualKey(WORD virtualKey)
+{
+  TV_KEYDOWN::wVKey=virtualKey;
+}
+
+inline
+UINT TreeViewKeyDown::flags(void)const
+{
+  return TV_KEYDOWN::flags;
+}
+
+inline
+void TreeViewKeyDown::flags(UINT flags)
+{
+  TV_KEYDOWN::flags=flags;
+}
+
+inline
+void TreeViewKeyDown::init(void)
+{
+  ::memset(&((TV_KEYDOWN&)*this),0,sizeof(TV_KEYDOWN));
+}
+#endif

imagelst/TVMSGHDR.HPP

@@ -0,0 +1,173 @@
+#ifndef _IMAGELIST_TREEVIEWMESSAGEHEADER_HPP_
+#define _IMAGELIST_TREEVIEWMESSAGEHEADER_HPP_
+#ifndef _COMMON_NOTIFYMESSAGEHEADER_HPP_
+#include <common/notify.hpp>
+#endif
+#ifndef _IMAGELIST_TREEVIEWITEM_HPP_
+#include <imagelst/tvitem.hpp>
+#endif
+#ifndef _COMMON_GDIPOINT_HPP_
+#include <common/gdipoint.hpp>
+#endif
+
+class TreeViewMessageHeader : private NM_TREEVIEW
+{
+public:
+  TreeViewMessageHeader(void);
+  TreeViewMessageHeader(const TreeViewMessageHeader &someTreeViewMessageHeader);
+	TreeViewMessageHeader(const NM_TREEVIEW &someNMTREEVIEW);
+	virtual ~TreeViewMessageHeader();
+	TreeViewMessageHeader &operator=(const TreeViewMessageHeader &someTreeViewMessageHeader);
+	TreeViewMessageHeader &operator=(const NM_TREEVIEW &someNMTREEVIEW);
+	WORD operator==(const TreeViewMessageHeader &someTreeViewMessageHeader)const;
+	WORD operator==(const NM_TREEVIEW &someNMTREEVIEW)const;
+	NotifyMessageHeader nmHeader(void)const;
+	UINT action(void)const;
+	TreeViewItem itemOld(void)const;
+	TreeViewItem itemNew(void)const;
+	GDIPoint pointDrag(void)const;
+private:
+  void init(void);
+	void nmHeader(NotifyMessageHeader &tvMessageHeader);
+	void action(UINT tvAction);
+	void itemOld(const TreeViewItem &tvItemOld);
+	void itemNew(const TreeViewItem &tvItemNew);
+	void pointDrag(const GDIPoint &tvDrawPoint);
+};
+
+inline
+TreeViewMessageHeader::TreeViewMessageHeader(void)
+{
+  init();
+}
+
+inline
+TreeViewMessageHeader::TreeViewMessageHeader(const TreeViewMessageHeader &someTreeViewMessageHeader)
+{
+  *this=someTreeViewMessageHeader;
+}
+
+inline
+TreeViewMessageHeader::TreeViewMessageHeader(const NM_TREEVIEW &someNMTREEVIEW)
+{
+  *this=someNMTREEVIEW;
+}
+
+inline
+TreeViewMessageHeader::~TreeViewMessageHeader()
+{
+}
+
+inline
+TreeViewMessageHeader &TreeViewMessageHeader::operator=(const TreeViewMessageHeader &someTreeViewMessageHeader)
+{
+  nmHeader(someTreeViewMessageHeader.nmHeader());
+	action(someTreeViewMessageHeader.action());
+	itemOld(someTreeViewMessageHeader.itemOld());
+	itemNew(someTreeViewMessageHeader.itemNew());
+	pointDrag(someTreeViewMessageHeader.pointDrag());
+	return *this;
+}
+
+inline
+TreeViewMessageHeader &TreeViewMessageHeader::operator=(const NM_TREEVIEW &someNMTREEVIEW)
+{
+  NM_TREEVIEW::hdr=someNMTREEVIEW.hdr;
+	NM_TREEVIEW::action=someNMTREEVIEW.action;
+	NM_TREEVIEW::itemOld=someNMTREEVIEW.itemOld;
+	NM_TREEVIEW::itemNew=someNMTREEVIEW.itemNew;
+	NM_TREEVIEW::ptDrag=someNMTREEVIEW.ptDrag;
+	return *this;
+}
+
+inline
+WORD TreeViewMessageHeader::operator==(const TreeViewMessageHeader &someTreeViewMessageHeader)const
+{
+  return (nmHeader()==someTreeViewMessageHeader.nmHeader()&&
+	  action()==someTreeViewMessageHeader.action()&&
+	  itemOld()==someTreeViewMessageHeader.itemOld()&&
+	  itemNew()==someTreeViewMessageHeader.itemNew()&&
+	  pointDrag()==someTreeViewMessageHeader.pointDrag());
+}
+
+inline
+WORD TreeViewMessageHeader::operator==(const NM_TREEVIEW &someNMTREEVIEW)const
+{
+  return (NotifyMessageHeader(NM_TREEVIEW::hdr)==NotifyMessageHeader(someNMTREEVIEW.hdr)&&
+	  NM_TREEVIEW::action==someNMTREEVIEW.action&&
+	  TreeViewItem(NM_TREEVIEW::itemOld)==TreeViewItem(someNMTREEVIEW.itemOld)&&
+	  TreeViewItem(NM_TREEVIEW::itemNew)==TreeViewItem(someNMTREEVIEW.itemNew)&&
+	  NM_TREEVIEW::ptDrag.x==someNMTREEVIEW.ptDrag.x&&
+		NM_TREEVIEW::ptDrag.y==someNMTREEVIEW.ptDrag.y);
+}
+
+inline
+NotifyMessageHeader TreeViewMessageHeader::nmHeader(void)const
+{
+  return NM_TREEVIEW::hdr;
+}
+
+inline
+void TreeViewMessageHeader::nmHeader(NotifyMessageHeader &tvMessageHeader)
+{
+  NM_TREEVIEW::hdr=(NMHDR&)tvMessageHeader;
+}
+
+inline
+UINT TreeViewMessageHeader::action(void)const
+{
+  return NM_TREEVIEW::action;
+}
+
+inline
+void TreeViewMessageHeader::action(UINT tvAction)
+{
+  NM_TREEVIEW::action=tvAction;
+}
+
+inline
+TreeViewItem TreeViewMessageHeader::itemOld(void)const
+{
+  return NM_TREEVIEW::itemOld;
+}
+
+inline
+void TreeViewMessageHeader::itemOld(const TreeViewItem &tvItemOld)
+{
+  NM_TREEVIEW::itemOld=(TV_ITEM&)tvItemOld;
+}
+
+inline
+TreeViewItem TreeViewMessageHeader::itemNew(void)const
+{
+  return NM_TREEVIEW::itemNew;
+}
+
+inline
+void TreeViewMessageHeader::itemNew(const TreeViewItem &tvItemNew)
+{
+  NM_TREEVIEW::itemOld=(TV_ITEM&)tvItemNew;
+}
+
+inline
+GDIPoint TreeViewMessageHeader::pointDrag(void)const
+{
+  GDIPoint dragPoint;
+
+	dragPoint.x(NM_TREEVIEW::ptDrag.x);
+  dragPoint.y(NM_TREEVIEW::ptDrag.y);
+	return dragPoint;
+}
+
+inline
+void TreeViewMessageHeader::pointDrag(const GDIPoint &tvDrawPoint)
+{
+  NM_TREEVIEW::ptDrag=(POINT&)tvDrawPoint;
+}
+
+inline
+void TreeViewMessageHeader::init(void)
+{
+  ::memset(&((NM_TREEVIEW&)*this),0,sizeof(NM_TREEVIEW));
+}
+#endif

imagelst/TVNOTIFY.HPP

@@ -0,0 +1,139 @@
+#ifndef _IMAGELIST_TREEVIEWNOTIFY_HPP_
+#define _IMAGELIST_TREEVIEWNOTIFY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_GDIPOINT_HPP_
+#include <common/gdipoint.hpp>
+#endif
+#ifndef _IMAGELIST_NOTIFYMESSAGEHEADER_HPP_
+#include <imagelst/notify.hpp>
+#endif
+
+class TreeViewNotify : private NM_TREEVIEW
+{
+public:
+	TreeViewNotify(void);
+	TreeViewNotify(const TreeViewNotify &someTreeViewNotify);
+	~TreeViewNotify();
+	NotifyMessageHeader &hdr(void);
+	UINT action(void)const;
+	TreeViewItem &itemOld(void);
+	TreeViewItem &itemNew(void);
+	GDIPoint &dragPoint(void);
+private:
+	TreeViewNotify &operator=(const TreeViewNotify &someTreeViewNotify);
+	WORD operator==(const TreeViewNotify &someTreeViewNotify)const;
+	void hdr(const NotifyMessageHeader &someNotifyMessageHeader);
+	void itemOld(const TreeViewItem &someTreeViewItem);
+	void itemNew(const TreeViewItem &someTreeViewItem);
+	void dragPoint(const GDIPoint &someGDIPoint);
+	void action(UINT action);
+	void clearData(void);
+};
+
+inline
+TreeViewNotify::TreeViewNotify(void)
+{
+  clearData();
+}
+
+inline
+TreeViewNotify::TreeViewNotify(const TreeViewNotify &someTreeViewNotify)
+{
+	clearData();
+	*this=someTreeViewNotify;
+}
+
+inline
+TreeViewNotify::~TreeViewNotify()
+{
+}
+
+inline
+TreeViewNotify &TreeViewNotify::operator=(const TreeViewNotify &someTreeViewNotify)
+{
+	hdr(((TreeViewNotify&)someTreeViewNotify).hdr());
+	itemOld(((TreeViewNotify&)someTreeViewNotify).itemOld());
+	itemNew(((TreeViewNotify&)someTreeViewNotify).itemNew());
+	dragPoint(((TreeViewNotify&)someTreeViewNotify).dragPoint());
+	action(((TreeViewNotify&)someTreeViewNotify).action());
+	return *this;
+}
+
+inline
+WORD TreeViewNotify::operator==(const TreeViewNotify &someTreeViewNotify)const
+{
+	return (((TreeViewNotify&)*this).hdr()==((TreeViewNotify&)someTreeViewNotify).hdr()&&
+					((TreeViewNotify&)*this).itemOld()==((TreeViewNotify&)someTreeViewNotify).itemOld()&&
+					((TreeViewNotify&)*this).itemNew()==((TreeViewNotify&)someTreeViewNotify).itemNew()&&
+					((TreeViewNotify&)*this).dragPoint()==((TreeViewNotify&)someTreeViewNotify).dragPoint()&&
+					((TreeViewNotify&)*this).action()==((TreeViewNotify&)someTreeViewNotify).action());
+}
+
+inline
+NotifyMessageHeader &TreeViewNotify::hdr(void)
+{
+	return (NotifyMessageHeader&)NM_TREEVIEW::hdr;
+}
+
+inline
+void TreeViewNotify::hdr(const NotifyMessageHeader &someNotifyMessageHeader)
+{
+  ((NotifyMessageHeader&)NM_TREEVIEW::hdr)=someNotifyMessageHeader;
+}
+
+inline
+UINT TreeViewNotify::action(void)const
+{
+	return NM_TREEVIEW::action;
+}
+
+inline
+void TreeViewNotify::action(UINT action)
+{
+  NM_TREEVIEW::action=action;
+}
+
+inline
+TreeViewItem &TreeViewNotify::itemOld(void)
+{
+	return (TreeViewItem&)NM_TREEVIEW::itemOld;
+}
+
+inline
+void TreeViewNotify::itemOld(const TreeViewItem &someTreeViewItem)
+{
+	(TreeViewItem&)NM_TREEVIEW::itemOld=someTreeViewItem;
+}
+
+inline
+TreeViewItem &TreeViewNotify::itemNew(void)
+{
+  return (TreeViewItem&)NM_TREEVIEW::itemNew;
+}
+
+inline
+void TreeViewNotify::itemNew(const TreeViewItem &someTreeViewItem)
+{
+  (TreeViewItem&)NM_TREEVIEW::itemNew=someTreeViewItem;
+}
+
+inline
+GDIPoint &TreeViewNotify::dragPoint(void)
+{
+  return (GDIPoint&)NM_TREEVIEW::ptDrag;
+}
+
+inline
+void TreeViewNotify::dragPoint(const GDIPoint &someGDIPoint)
+{
+  (GDIPoint&)NM_TREEVIEW::ptDrag=someGDIPoint;
+}
+
+inline
+void TreeViewNotify::clearData(void)
+{
+	::memset((char*)&((NM_TREEVIEW&)*this),0,sizeof(NM_TREEVIEW));
+}
+#endif

imagelst/imagelst.001

@@ -0,0 +1,142 @@
+# Microsoft Developer Studio Project File - Name="imagelst" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=imagelst - Win32 Release
+!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 "imagelst.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 "imagelst.mak" CFG="imagelst - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "imagelst - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "imagelst - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "imagelst - 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 "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Zi /Od /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\imagelst.lib"
+
+!ELSEIF  "$(CFG)" == "imagelst - 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 ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Zi /Od /Ob2 /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\imagelst.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "imagelst - Win32 Release"
+# Name "imagelst - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Ftree.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagelst.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Treeview.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Ftree.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Hittest.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagelst.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imgeinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Treeview.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvdisp.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvitem.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvkey.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvmsghdr.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

imagelst/imagelst.dsp

@@ -0,0 +1,148 @@
+# Microsoft Developer Studio Project File - Name="imagelst" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=imagelst - Win32 Release
+!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 "imagelst.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 "imagelst.mak" CFG="imagelst - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "imagelst - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "imagelst - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "imagelst - 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 "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /ZI /Od /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\imagelst.lib"
+
+!ELSEIF  "$(CFG)" == "imagelst - 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 ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp8 /MTd /GX /ZI /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\imagelst.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "imagelst - Win32 Release"
+# Name "imagelst - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Ftree.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagelst.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Treeview.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Ftree.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Hittest.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagelst.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imgeinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Treeview.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvdisp.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvitem.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvkey.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tvmsghdr.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project