commit ca445435a0f5b239b8edfa59d693bb303351cf57 Author: Sean Kessler (Europa) Date: Wed Aug 7 09:09:36 2024 -0400 Initial Commit diff --git a/common/#FILEIO.CPP b/common/#FILEIO.CPP new file mode 100644 index 0000000..ba0b16e --- /dev/null +++ b/common/#FILEIO.CPP @@ -0,0 +1,185 @@ +#include + +FileIO::FileIO(void) +: mFileDescriptor(InvalidFile), mByteOrder(LittleEndian), mInputBuffer(MaxInputBuffer), + mOpenMode(ReadOnly) +{ +} + +FileIO::FileIO(String pathFileName,ByteOrder byteOrder,Mode openMode) +: mFileDescriptor(InvalidFile), mByteOrder(byteOrder), mInputBuffer(MaxInputBuffer), + mOpenMode(openMode) +{ + if(!mInputBuffer.lpBuffer())return; + open(pathFileName); +} + +FileIO::~FileIO() +{ + close(); +} + +WORD FileIO::close(void) +{ + if(InvalidFile==mFileDescriptor)return FALSE; + ::close(mFileDescriptor); + mFileDescriptor=InvalidFile; + return TRUE; +} + +WORD FileIO::open(String pathFileName,Mode openMode,CreationFlags creationFlags) +{ + close(); + mOpenMode=openMode; + if(ReadOnly==mOpenMode)mFileDescriptor=::open(pathFileName,O_RDONLY|O_BINARY,S_IREAD); + else mFileDescriptor=::open(pathFileName,O_RDWR|O_BINARY|creationFlags,S_IREAD|S_IWRITE); + if(InvalidFile==mFileDescriptor)return FALSE; + return TRUE; +} + +WORD FileIO::read(BYTE &value) +{ + if(!isOkay())return FALSE; + if(ReadOnly==mOpenMode) + { + if(!mInputBuffer.bufferIndex()) + { + mInputBuffer.bufferIndex(::read(mFileDescriptor,mInputBuffer.lpBuffer(),MaxInputBuffer)); + if(!mInputBuffer.bufferIndex())return FALSE; + } + value=*(mInputBuffer.lpBufferPointer()); + ++mInputBuffer; + } + else if(0>=::read(mFileDescriptor,&value,1))return FALSE; + return TRUE; +} + +WORD FileIO::read(WORD &value) +{ + BYTE byteValue; + + if(!isOkay())return FALSE; + if(!read(byteValue))return FALSE; + value=byteValue; + if(!read(byteValue))return FALSE; + value|=((WORD)byteValue)<<8; + if(BigEndian==mByteOrder)value=mIntelData.intelData(value); + return TRUE; +} + +WORD FileIO::read(DWORD &value) +{ + WORD wordValue; + + if(!isOkay())return FALSE; + if(!read(wordValue))return FALSE; + value=wordValue; + if(!read(wordValue))return FALSE; + value|=((DWORD)wordValue)<<16; + if(BigEndian==mByteOrder)value=mIntelData.intelData(value); + return TRUE; +} + +WORD FileIO::read(char *lpBuffer,WORD lengthData) +{ + BYTE byteValue; + + if(!isOkay())return FALSE; + for(WORD index=0;index>8); + if(!write(byteValue))return FALSE; + return TRUE; +} + +WORD FileIO::write(DWORD value) +{ + WORD wordValue; + + if(!isOkay())return FALSE; + if(BigEndian==mByteOrder) + { + WORD hiWord(HIWORD(value)); + WORD loWord(LOWORD(value)); + + value=((DWORD)mIntelData.intelData(loWord))<<16; + value|=mIntelData.intelData(hiWord); + write((char*)&value,sizeof(value)); + return TRUE; + } + wordValue=(WORD)(value&0xFFFF); + write(wordValue); + wordValue=(WORD)(value>>16); + write(wordValue); + return TRUE; +} + +WORD FileIO::write(char *lpBuffer,WORD lengthData) +{ + if(!isOkay())return FALSE; + if(!lengthData)return TRUE; + if(-1==::write(mFileDescriptor,lpBuffer,lengthData))return FALSE; + return TRUE; +} + +FileIO &FileIO::operator++(void) +{ + seek(1L,SeekCurrent); + + return *this; +} + +FileIO &FileIO::operator--(void) +{ + seek(-1L,SeekCurrent); + return *this; +} + +WORD FileIO::seek(LONG seekOffset,SeekFrom seekFrom) +{ + if(!isOkay())return FALSE; + if(-1==::lseek(mFileDescriptor,seekOffset,seekFrom))return FALSE; + mInputBuffer.bufferIndex(0); + return TRUE; +} + +WORD FileIO::rewind(void) +{ + if(!isOkay())return FALSE; + if(!seek(0L,SeekBeginning))return FALSE; + return TRUE; +} + + + + + diff --git a/common/ARRAY.HPP b/common/ARRAY.HPP new file mode 100644 index 0000000..75ddacb --- /dev/null +++ b/common/ARRAY.HPP @@ -0,0 +1,129 @@ +#ifndef _COMMON_ARRAY_HPP_ +#define _COMMON_ARRAY_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif + +template +class Array +{ +public: + Array(void); + Array(const Array &someArray); + virtual ~Array(); + T &operator[](DWORD index); + T &elementAt(DWORD index); + Array &operator=(const Array &someArray); + bool operator==(const Array &someArray)const; + DWORD size(void)const; + void size(DWORD size); + DWORD sizeBytes(void)const; +private: + void destroy(void); + void create(DWORD elements); + + T *mpArray; + DWORD mElements; +}; + +template +inline +Array::Array(void) +: mpArray(0), mElements(0) +{ +} + +template +inline +Array::Array(const Array &someArray) +: mpArray(0), mElements(0) +{ + *this=someArray; +} + +template +inline +Array::~Array() +{ + destroy(); +} + +template +inline +T &Array::operator[](DWORD index) +{ + if(index>mElements)throw ArrayIndexOutOfBoundsException(); + return mpArray[index]; +} + +template +inline +Array &Array::operator=(const Array &someArray) +{ + destroy(); + if(!someArray.size())return *this; + size(someArray.size()); + for(unsigned index=0;index&)someArray)[index]; + return *this; +} + +template +inline +bool Array::operator==(const Array &someArray)const +{ + if(!someArray.size()||(size()!=someArray.size()))return FALSE; + for(int index=0;index&)*this).operator[](index)==((Array&)someArray)[index]))return FALSE; + return TRUE; +} + +template +inline +DWORD Array::sizeBytes(void)const +{ + return mElements*sizeof(T); +} + +template +DWORD Array::size(void)const +{ + return mElements; +} + +template +void Array::size(DWORD size) +{ + create(size); +} + +template +inline +void Array::destroy(void) +{ + if(!mpArray)return; + delete[] mpArray; + mpArray=0; + mElements=0; +} + +template +inline +void Array::create(DWORD elements) +{ + destroy(); + if(!elements)return; + mpArray=new T[elements]; + if(0==mpArray)throw(NullError()); + mElements=elements; +} + +template +inline +T &Array::elementAt(DWORD index) +{ + if(index>mElements)throw ArrayIndexOutOfBoundsException(); + return mpArray[index]; +} +#endif diff --git a/common/ASSERT.HPP b/common/ASSERT.HPP new file mode 100644 index 0000000..1aa19a9 --- /dev/null +++ b/common/ASSERT.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_ASSERT_HPP_ +#define _COMMON_ASSERT_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/AVICAP.HPP b/common/AVICAP.HPP new file mode 100644 index 0000000..755daf9 --- /dev/null +++ b/common/AVICAP.HPP @@ -0,0 +1,13 @@ +#ifndef _COMMON_AVICAP_HPP_ +#define _COMMON_AVICAP_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_MMSYSTEM_HPP_ +#include +#endif +#ifndef _COMMON_VFW_HPP_ +#include +#endif +#endif + diff --git a/common/Accelerator.hpp b/common/Accelerator.hpp new file mode 100644 index 0000000..a172af7 --- /dev/null +++ b/common/Accelerator.hpp @@ -0,0 +1,29 @@ +#ifndef _COMMON_ACCELERATOR_HPP_ +#define _COMMON_ACCELERATOR_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class GUIWindow; + +class Accelerator +{ +public: + Accelerator(); + Accelerator(const String &strTableName,HINSTANCE hInstance=GetModuleHandle(0)); + Accelerator(UINT resID,HINSTANCE hInstance=GetModuleHandle(0)); + virtual ~Accelerator(); + bool loadAccelerators(const String &strTableName,HINSTANCE hInstance=GetModuleHandle(0)); + bool loadAccelerators(UINT resID,HINSTANCE hInstance=GetModuleHandle(0)); + bool translate(const GUIWindow &parent,MSG &msg)const; + bool translateMDISysAccelerator(const GUIWindow &parent,MSG &msg)const; + void destroy(void); + bool isOkay(void)const; +private: + Accelerator &operator=(const Accelerator &accelerator); + HACCEL mhAccelerator; +}; +#endif diff --git a/common/BINARRAY.HPP b/common/BINARRAY.HPP new file mode 100644 index 0000000..bc80189 --- /dev/null +++ b/common/BINARRAY.HPP @@ -0,0 +1,47 @@ +#ifndef _COMMON_BINARYSEARCHARRAY_HPP_ +#define _COMMON_BINARYSEARCHARRAY_HPP_ +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif + +template +class BinarySearchArray +{ +public: + BinarySearchArray(Array &sortedVector); + virtual ~BinarySearchArray(); + WORD searchItem(const T &desiredItem,T &foundItem); + WORD searchItem(const T &desiredItem,Block &foundItems); +private: + WORD searchItem(const T &desiredItem,T &foundItem,LONG &foundIndex); + DWORD itemCount(void)const; + Array &mSortedVector; + DWORD mItemCount; +}; + +template +inline +BinarySearchArray::BinarySearchArray(Array &sortedVector) +: mSortedVector(sortedVector), mItemCount(mSortedVector.size()) +{ +} + +template +inline +BinarySearchArray::~BinarySearchArray(void) +{ +} + +template +inline +DWORD BinarySearchArray::itemCount(void)const +{ + return mItemCount; +} +#if defined(_MSC_VER) +#include +#endif +#endif diff --git a/common/BINARRAY.TPP b/common/BINARRAY.TPP new file mode 100644 index 0000000..a8579c1 --- /dev/null +++ b/common/BINARRAY.TPP @@ -0,0 +1,57 @@ +#ifndef _COMMON_BINARYSEARCHARRAY_TPP_ +#define _COMMON_BINARYSEARCHARRAY_TPP_ + +template +WORD BinarySearchArray::searchItem(const T &desiredItem,T &foundItem) +{ + LONG itemIndex; + return searchItem(desiredItem,foundItem,itemIndex); +} + +template +WORD BinarySearchArray::searchItem(const T &desiredItem,Block &foundItems) +{ + LONG foundIndex; + LONG startIndex; + LONG endIndex; + T foundItem; + + foundItems.remove(); + if(!searchItem(desiredItem,foundItem,foundIndex))return FALSE; + startIndex=endIndex=foundIndex; + for(;startIndex>=0&&foundItem==mSortedVector[startIndex];startIndex--); + startIndex++; + for(;endIndex +WORD BinarySearchArray::searchItem(const T &desiredItem,T &foundItem,LONG &foundIndex) +{ + LONG lowerBound; + LONG upperBound; + LONG itemIndex; + WORD returnCode(FALSE); + + if(!itemCount())return FALSE; + lowerBound=0L; + upperBound=mItemCount-1L; + while(TRUE) + { + itemIndex=(lowerBound+upperBound)/2L; + if(desiredItem>mSortedVector[itemIndex])lowerBound=itemIndex+1L; + else upperBound=itemIndex-1; + if(mSortedVector[itemIndex]==desiredItem) + { + foundItem=mSortedVector[itemIndex]; + foundIndex=itemIndex; + returnCode=TRUE; + break; + } + if(lowerBound>upperBound)break; + } + return returnCode; +} +#endif diff --git a/common/BINSRCH.HPP b/common/BINSRCH.HPP new file mode 100644 index 0000000..8651fe2 --- /dev/null +++ b/common/BINSRCH.HPP @@ -0,0 +1,47 @@ +#ifndef _COMMON_BINARYSEARCH_HPP_ +#define _COMMON_BINARYSEARCH_HPP_ +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif + +template +class BinarySearch +{ +public: + BinarySearch(Array &sortedVector); + ~BinarySearch(); + WORD searchItem(const T &desiredItem,T &foundItem); + WORD searchItem(const T &desiredItem,Block &foundItems); +private: + WORD searchItem(const T &desiredItem,T &foundItem,LONG &foundIndex); + DWORD itemCount(void)const; + Array &mSortedVector; + DWORD mItemCount; +}; + +template +inline +BinarySearch::BinarySearch(Array &sortedVector) +: mSortedVector(sortedVector), mItemCount(mSortedVector.size()) +{ +} + +template +inline +BinarySearch::~BinarySearch(void) +{ +} + +template +inline +DWORD BinarySearch::itemCount(void)const +{ + return mItemCount; +} +#if defined(_MSC_VER) +#include +#endif +#endif diff --git a/common/BINSRCH.TPP b/common/BINSRCH.TPP new file mode 100644 index 0000000..c0cb824 --- /dev/null +++ b/common/BINSRCH.TPP @@ -0,0 +1,57 @@ +#ifndef _COMMON_BINSRCH_TPP_ +#define _COMMON_BINSRCH_TPP_ + +template +WORD BinarySearch::searchItem(const T &desiredItem,T &foundItem) +{ + LONG itemIndex; + return searchItem(desiredItem,foundItem,itemIndex); +} + +template +WORD BinarySearch::searchItem(const T &desiredItem,Block &foundItems) +{ + LONG foundIndex; + LONG startIndex; + LONG endIndex; + T foundItem; + + foundItems.remove(); + if(!searchItem(desiredItem,foundItem,foundIndex))return FALSE; + startIndex=endIndex=foundIndex; + for(;startIndex>=0&&foundItem==mSortedVector[startIndex];startIndex--); + startIndex++; + for(;endIndex +WORD BinarySearch::searchItem(const T &desiredItem,T &foundItem,LONG &foundIndex) +{ + LONG lowerBound; + LONG upperBound; + LONG itemIndex; + WORD returnCode(FALSE); + + if(!itemCount())return FALSE; + lowerBound=0L; + upperBound=mItemCount-1L; + while(TRUE) + { + itemIndex=(lowerBound+upperBound)/2L; + if(desiredItem>mSortedVector[itemIndex])lowerBound=itemIndex+1L; + else upperBound=itemIndex-1; + if(mSortedVector[itemIndex]==desiredItem) + { + foundItem=mSortedVector[itemIndex]; + foundIndex=itemIndex; + returnCode=TRUE; + break; + } + if(lowerBound>upperBound)break; + } + return returnCode; +} +#endif diff --git a/common/BITMAP.CPP b/common/BITMAP.CPP new file mode 100644 index 0000000..37a4cb4 --- /dev/null +++ b/common/BITMAP.CPP @@ -0,0 +1,544 @@ +#include +#include +#include +#include +#include +#define MaxBlock 64000L + +Bitmap::Bitmap(void) +: mhFile(HFILE_ERROR), mCurrentMode(Idle), mMaxColors(0), mImageExtent(0), + mBlockSize(MaxBlock), mWidth(0), mHeight(0) +{ +} + +Bitmap::Bitmap(const Bitmap &someBitmap) +: mMaxColors(someBitmap.mMaxColors), mFileName(someBitmap.mFileName), + mImageExtent(someBitmap.mImageExtent), mBlockSize(someBitmap.mBlockSize), + mhFile(HFILE_ERROR), mCurrentMode(Write), mWidth(0), mHeight(0) +{ + if(!someBitmap.isOkay())return; + copyBitmap(someBitmap); +} + +Bitmap::Bitmap(const String &pathFileName) +: mhFile(HFILE_ERROR), mMaxColors(0), mCurrentMode(Read), mImageExtent(0), + mBlockSize(MaxBlock), mWidth(0), mHeight(0) +{ + processBitmap(pathFileName); +} + +Bitmap::Bitmap(const String &pathFileName,HGLOBAL hGlobalImage,HGLOBAL hGlobalBitmapInfo) +: mhFile(HFILE_ERROR), mMaxColors(0), mCurrentMode(Write), mImageExtent(0), + mBlockSize(MaxBlock), mWidth(0), mHeight(0) +{ + DWORD sizeBitmapInfo; + DWORD sizeBitmapImage; + BITMAPINFO FAR *lpSourceBitmapInfo; + UHUGE *lpSourceImage; + + if(!hGlobalImage||!hGlobalBitmapInfo)return; + if(pathFileName.isNull())return; + mFileName=pathFileName; + sizeBitmapInfo=::GlobalSize(hGlobalBitmapInfo); + sizeBitmapImage=::GlobalSize(hGlobalImage); + reserveInfo(sizeBitmapInfo); + lpSourceBitmapInfo=(BITMAPINFO FAR*)::GlobalLock(hGlobalBitmapInfo); + copyBits((UHUGE*)getInfoPtr(),(UHUGE*)lpSourceBitmapInfo,sizeBitmapInfo); + ::GlobalUnlock(hGlobalBitmapInfo); + mImageExtent=imageExtent(); + if(mImageExtent!=sizeBitmapImage)mImageExtent=sizeBitmapImage; + reserveData(mImageExtent); + lpSourceImage=(UHUGE*)::GlobalLock(hGlobalImage); + copyBits(getDataPtr(),lpSourceImage,mImageExtent); + ::GlobalUnlock(hGlobalImage); + if(!(mMaxColors=(WORD)getInfoPtr()->bmiHeader.biClrUsed))mMaxColors=1<bmiHeader.biBitCount; + mWidth=getInfoPtr()->bmiHeader.biWidth; + mHeight=getInfoPtr()->bmiHeader.biHeight; + setPalette(); +} + +Bitmap::Bitmap(const String &pathFileName,BitmapInfo &infoData,GlobalData &imageData) +: mhFile(HFILE_ERROR), mMaxColors(0), mCurrentMode(Write), mImageExtent(0), + mBlockSize(MaxBlock), mWidth(0), mHeight(0) +{ + DWORD sizeBitmapInfo; + DWORD sizeBitmapImage; + BITMAPINFO FAR *lpSourceBitmapInfo; + UHUGE *lpSourceImage; + + if(!imageData.size())return; + if(pathFileName.isNull())return; + mFileName=pathFileName; + sizeBitmapInfo=(sizeof(BITMAPINFO)-sizeof(RGBQUAD))+(infoData.rgbColors()*sizeof(RGBQUAD)); + sizeBitmapImage=imageData.size(); + reserveInfo(sizeBitmapInfo); + copyBits((UHUGE*)getInfoPtr(),(UHUGE*)((BITMAPINFO*)infoData),sizeBitmapInfo); + mImageExtent=imageExtent(); + if(mImageExtent!=sizeBitmapImage)mImageExtent=sizeBitmapImage; + reserveData(mImageExtent); + copyBits(getDataPtr(),(BYTE*)&imageData[0],mImageExtent); + if(BitmapInfo::Bit8==getInfoPtr()->bmiHeader.biBitCount&&!(mMaxColors=(WORD)getInfoPtr()->bmiHeader.biClrUsed))mMaxColors=1<bmiHeader.biBitCount; + mWidth=getInfoPtr()->bmiHeader.biWidth; + mHeight=getInfoPtr()->bmiHeader.biHeight; + if(BitmapInfo::Bit8==getInfoPtr()->bmiHeader.biBitCount)setPalette(); +} + +Bitmap::Bitmap(const String &pathFileName,WORD bitmapWidth,WORD bitmapHeight,WORD bitmapColors,WORD bitCount) +: mhFile(HFILE_ERROR), mMaxColors(bitmapColors), mCurrentMode(Write), + mImageExtent(0), mBlockSize(MaxBlock), mWidth(0), mHeight(0) +{ + BITMAPINFOHEADER bitmapInfoHeader; + LONG rgbQuadBytes(bitmapColors*sizeof(RGBQUAD)); + UHUGE *lpPtr; + + if(!bitmapWidth||!bitmapHeight||!bitmapColors||pathFileName.isNull())return; + getRequiredWidth(bitmapWidth,bitmapHeight); + mFileName=pathFileName; + bitmapInfoHeader.biSize=sizeof(BITMAPINFOHEADER); + mWidth=bitmapInfoHeader.biWidth=bitmapWidth; + mHeight=bitmapInfoHeader.biHeight=bitmapHeight; + bitmapInfoHeader.biPlanes=Planes; + bitmapInfoHeader.biBitCount=bitCount; + bitmapInfoHeader.biCompression=BI_RGB; + bitmapInfoHeader.biSizeImage=0; + bitmapInfoHeader.biXPelsPerMeter=0; + bitmapInfoHeader.biYPelsPerMeter=0; + bitmapInfoHeader.biClrUsed=bitmapColors; + bitmapInfoHeader.biClrImportant=bitmapColors; + reserveInfo(0,bitmapColors); + copyBits((UHUGE*)getInfoPtr(),(UHUGE*)&bitmapInfoHeader,sizeof(BITMAPINFOHEADER)); + lpPtr=((UHUGE*)getInfoPtr())+sizeof(BITMAPINFOHEADER); + setBits(lpPtr,0,rgbQuadBytes); + mImageExtent=imageExtent(); + lpPtr=reserveData(mImageExtent); + setBits(lpPtr,0,mImageExtent); +} + +Bitmap::~Bitmap() +{ + closeFile(); +} + +WORD Bitmap::operator+=(const BitmapOverlay &someBitmapOverlay) +{ + Bitmap &sourceBitmap=((BitmapOverlay&)someBitmapOverlay).bitmap(); + Point placementPoint(((BitmapOverlay&)someBitmapOverlay).placementPoint()); + UHUGE *lpSrcData; + UHUGE *lpDstData; + UHUGE *lpSrcPtr; + UHUGE *lpDstPtr; + LONG srcWidth; + LONG srcHeight; + LONG dstWidth; + LONG dstHeight; + LONG copyRows; + LONG copyCols; + + if(!isOkay()||!sourceBitmap.isOkay())return FALSE; + mCurrentMode=Write; + srcWidth=copyCols=sourceBitmap.getInfoPtr()->bmiHeader.biWidth; + srcHeight=copyRows=sourceBitmap.getInfoPtr()->bmiHeader.biHeight; + dstWidth=getInfoPtr()->bmiHeader.biWidth; + dstHeight=getInfoPtr()->bmiHeader.biHeight; + if(placementPoint.x()<0)placementPoint.x(0); + if(placementPoint.y()<0)placementPoint.y(0); + if(placementPoint.x()>=dstWidth)return FALSE; + if(placementPoint.y()>=dstHeight)return FALSE; + if((LONG)placementPoint.x()+srcWidth>dstWidth)copyCols=dstWidth-placementPoint.x(); + if((LONG)placementPoint.y()+srcHeight>dstHeight)copyRows=dstHeight-placementPoint.y(); + upsideDown(); + sourceBitmap.upsideDown(); + lpSrcData=sourceBitmap.getDataPtr(); + lpDstData=getDataPtr(); + for(LONG srcRow=0;srcRowbmiHeader.biWidth); + LONG height(getInfoPtr()->bmiHeader.biHeight); + UHUGE *lpSrc=getDataPtr(); + UHUGE *lpDst; + HGLOBAL hGlobalTemp; + + hGlobalTemp=::GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,width*height); + lpDst=(UHUGE*)::GlobalLock(hGlobalTemp); + for(LONG rowIndex=0;rowIndexbmiHeader.biWidth; + mHeight=getInfoPtr()->bmiHeader.biHeight; + mBitmapPalette=someBitmap.getPalette(); +} + +WORD Bitmap::operator=(const String &pathFileName) +{ + int returnCode; + + mCurrentMode=Read; + returnCode=processBitmap(pathFileName); + return returnCode; +} + +Bitmap &Bitmap::operator=(const Bitmap &someBitmap) +{ + if(!someBitmap.isOkay())return *this; + if(getDataType()==BitmapData::Keep)return *this; + mCurrentMode=someBitmap.mCurrentMode; + mMaxColors=someBitmap.mMaxColors; + mFileName=someBitmap.mFileName; + mImageExtent=someBitmap.mImageExtent; + copyBitmap(someBitmap); + return *this; +} + +WORD Bitmap::processBitmap(const String &pathFileName) +{ + OFSTRUCT ofStruct; + + mFileName=pathFileName; + if(HFILE_ERROR==(mhFile=::OpenFile(pathFileName,&ofStruct,OF_READ)))return FALSE; + ::_lread(mhFile,&mBitmapFileHeader,sizeof(BITMAPFILEHEADER)); + if(Signature!=mBitmapFileHeader.bfType){closeFile();return FALSE;} + readPalette(); + decodeImage(); + closeFile(); + return TRUE; +} + +BOOL Bitmap::isValidBitmap(const String &pathFileName)const +{ + HFILE hFile; + OFSTRUCT ofStruct; + BITMAPFILEHEADER bitmapFileHeader; + + if(pathFileName.isNull())return FALSE; + if(HFILE_ERROR==(hFile=::OpenFile(pathFileName,&ofStruct,OF_READ)))return FALSE; + ::_lread(hFile,&bitmapFileHeader,sizeof(BITMAPFILEHEADER)); + ::_lclose(hFile); + if(Signature!=bitmapFileHeader.bfType)return FALSE; + return TRUE; +} + +HPALETTE Bitmap::getPalette(void)const +{ + return mBitmapPalette.getPalette(); +} + +WORD Bitmap::setPalette(HPALETTE hPalette,WORD remapBitmap) +{ + BITMAPINFOHEADER bitmapInfoHeader; + + if(!isOkay()||!hPalette)return FALSE; + PurePalette purePalette(hPalette); + if(mBitmapPalette==purePalette)return FALSE; + if(remapBitmap)mapPalette(purePalette); + mBitmapPalette=purePalette; + mMaxColors=mBitmapPalette.paletteEntries(); + ::memcpy(&bitmapInfoHeader,getInfoPtr(),sizeof(BITMAPINFOHEADER)); + reserveInfo(0,mMaxColors); + ::memcpy(getInfoPtr(),&bitmapInfoHeader,sizeof(BITMAPINFOHEADER)); + getInfoPtr()->bmiHeader.biClrUsed=0; + getInfoPtr()->bmiHeader.biClrImportant=0; + for(int itemIndex=0;itemIndexbmiColors[itemIndex].rgbRed=mBitmapPalette[itemIndex].red(); + getInfoPtr()->bmiColors[itemIndex].rgbGreen=mBitmapPalette[itemIndex].green(); + getInfoPtr()->bmiColors[itemIndex].rgbBlue=mBitmapPalette[itemIndex].blue(); + getInfoPtr()->bmiColors[itemIndex].rgbReserved=0; + } + return TRUE; +} + +void Bitmap::mapPalette(PurePalette &purePalette) +{ + Array rgbIndexVector; + WORD paletteEntries; + RGBTree paletteTree; + RGBColor rgbColor; + RGBIndex rgbIndex; + + paletteEntries=purePalette.paletteEntries(); + rgbIndexVector.size(paletteEntries); + for(int paletteIndex=0;paletteIndexbmiColors[paletteIndex].rgbRed); + rgbColor.green(getInfoPtr()->bmiColors[paletteIndex].rgbGreen); + rgbColor.blue(getInfoPtr()->bmiColors[paletteIndex].rgbBlue); + mBitmapPalette.setPaletteColor(paletteIndex,rgbColor,PaletteEntry::NullFlag); + } + return; +} + +void Bitmap::readPalette(void) +{ + RGBQUAD FAR *lpRGBQuad; + BITMAPINFOHEADER bitmapInfoHeader; + + if(HFILE_ERROR==mhFile||Read!=mCurrentMode)return; + ::_lread(mhFile,&bitmapInfoHeader,sizeof(BITMAPINFOHEADER)); + if(!(mMaxColors=(WORD)bitmapInfoHeader.biClrUsed))mMaxColors=1<bmiHeader.biWidth; + mHeight=getInfoPtr()->bmiHeader.biHeight; + getRequiredWidth(mWidth,mHeight); + + for(int i=0;ibmiColors[i]); + ::_lread(mhFile,lpRGBQuad,sizeof(RGBQUAD)); + mBitmapPalette.setPaletteColor(i,RGBColor(lpRGBQuad->rgbRed,lpRGBQuad->rgbGreen,lpRGBQuad->rgbBlue),PaletteEntry::NullFlag); + } +} + +void Bitmap::decodeImage(void) +{ + switch(getInfoPtr()->bmiHeader.biCompression) + { + case BI_RGB : + mImageExtent=imageExtent(); + reserveData(mImageExtent); + ::_llseek(mhFile,(mBitmapFileHeader.bfOffBits),0); + ::_hread(mhFile,getDataPtr(),mImageExtent); + break; + case BI_RLE4 : + closeFile(); + ::MessageBox(::GetFocus(),(LPSTR)"BI_RLE4 is not supported at this time.\nPlease try an uncompressed bitmap.",(LPSTR)"ERROR",MB_ICONEXCLAMATION); + break; + case BI_RLE8 : + closeFile(); + ::MessageBox(::GetFocus(),(LPSTR)"BI_RLE8 is not supported at this time.\nPlease try an uncompressed bitmap.",(LPSTR)"ERROR",MB_ICONEXCLAMATION); + break; + } +} + +HBITMAP Bitmap::createBitmap(PureDevice &somePureDevice) +{ + HBITMAP hBitmap; + + if(!isOkay())return FALSE; + hBitmap=::CreateDIBitmap(somePureDevice,(BITMAPINFOHEADER FAR*)getInfoPtr(), + CBM_INIT,getDataPtr(),(BITMAPINFO FAR*)getInfoPtr(),DIB_RGB_COLORS); + return hBitmap; +} + +WORD Bitmap::displayBitmap(HWND hDisplayWindow,HDC hDC,int isActive,int conforming)const +{ + RECT windowRect; + HPALETTE hOldPalette; + WORD windowWidth; + WORD windowHeight; + int suppliedDC; + + if(!isOkay()||!::IsWindow(hDisplayWindow))return FALSE; + ::GetClientRect(hDisplayWindow,(RECT FAR *)&windowRect); + windowWidth=windowRect.right; + windowHeight=windowRect.bottom; + if(!hDC){suppliedDC=FALSE;hDC=::GetDC(hDisplayWindow);} + if(isActive)hOldPalette=::SelectPalette(hDC,mBitmapPalette.getPalette(),FALSE); + else hOldPalette=::SelectPalette(hDC,mBitmapPalette.getPalette(),TRUE); + ::RealizePalette(hDC); + if(conforming)::StretchDIBits(hDC,0,0,windowRect.right,windowRect.bottom,0,0, + width(),height(),getDataPtr(),(BITMAPINFO *)getInfoPtr(),DIB_RGB_COLORS,SRCCOPY); + else + { + ::StretchDIBits(hDC,0,0,width()>windowWidth?windowWidth:width(), + height()>windowHeight?windowHeight:height(),0,0,width(),height(), + getDataPtr(),(BITMAPINFO *)getInfoPtr(),DIB_RGB_COLORS,SRCCOPY); + } + if(isActive)::SelectPalette(hDC,hOldPalette,FALSE); + else ::SelectPalette(hDC,hOldPalette,TRUE); + if(!suppliedDC)::ReleaseDC(hDisplayWindow,hDC); + return TRUE; +} + +BOOL Bitmap::draw(PureDevice &pureDevice,const Rect &dstRect,const Point &srcPoint) +{ + if(!isOkay())return FALSE; + ::StretchDIBits(pureDevice,dstRect.left(),dstRect.top(),dstRect.right(),dstRect.bottom(),srcPoint.x(),srcPoint.y(),dstRect.right(),dstRect.bottom(),getDataPtr(),(BITMAPINFO *)getInfoPtr(),DIB_RGB_COLORS,SRCCOPY); + return TRUE; +} + +bool Bitmap::saveBitmap(void) +{ + BITMAPFILEHEADER bitmapFileHeader; + OFSTRUCT ofStruct; + + if(!isOkay())return false; + if((HFILE_ERROR==mhFile)&&(HFILE_ERROR==(mhFile=::OpenFile(mFileName,&ofStruct,OF_WRITE|OF_CREATE))))return false; + ::memset(&bitmapFileHeader,0,sizeof(BITMAPFILEHEADER)); + bitmapFileHeader.bfType=Signature; + bitmapFileHeader.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1))+mImageExtent; + bitmapFileHeader.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1)); + ::_lwrite(mhFile,(char*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER)); + ::_lwrite(mhFile,(char*)getInfoPtr(),sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1))); + ::_hwrite(mhFile,(char*)getDataPtr(),mImageExtent); + closeFile(); + return true; +} + +bool Bitmap::saveBitmap(MemFile &memFile) +{ + BITMAPFILEHEADER bitmapFileHeader; + OFSTRUCT ofStruct; + + if(!isOkay())return false; + if((HFILE_ERROR==mhFile)&&(HFILE_ERROR==(mhFile=::OpenFile(mFileName,&ofStruct,OF_WRITE|OF_CREATE))))return false; + ::memset(&bitmapFileHeader,0,sizeof(BITMAPFILEHEADER)); + bitmapFileHeader.bfType=Signature; + bitmapFileHeader.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1))+mImageExtent; + bitmapFileHeader.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1)); + if(!memFile.write((char*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER)))return false; + if(!memFile.write((char*)getInfoPtr(),sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1))))return false; + if(!memFile.write((char*)getDataPtr(),mImageExtent))return false; + return true; +} + +bool Bitmap::saveBitmap(const String &pathFileName) +{ + if(!isOkay())return false; + mFileName=pathFileName; + return saveBitmap(); +} + +void Bitmap::copyBits(UHUGE *destination,UHUGE *source,unsigned long length)const +{ + for(unsigned long count=0;count>3)*(LONG)desiredHeight; + if(imageExtent==(LONG)desiredWidth*(LONG)desiredHeight)return; + desiredWidth=(WORD)(imageExtent/(LONG)desiredHeight); +} + +void Bitmap::getRequiredWidth(DWORD &desiredWidth,DWORD desiredHeight) +{ + DWORD imageExtent; + + imageExtent=(((((LONG)desiredWidth*8)+31)&~31)>>3)*(LONG)desiredHeight; + if(imageExtent==(LONG)desiredWidth*(LONG)desiredHeight)return; + desiredWidth=(WORD)(imageExtent/(LONG)desiredHeight); +} + +Bitmap &Bitmap::rotateRight(void) +{ + Bitmap tempBitmap(mFileName,height(),width()); + + tempBitmap.setPalette(getPalette(),FALSE); + for(int rowIndex=0;rowIndex=height()||!lpRowData)return FALSE; + UHUGE *lpImage=getDataPtr()+mImageExtent; + copyBits((UHUGE*)lpRowData,(lpImage-(((LONG)row*(LONG)width())+(LONG)width())),width()); + return TRUE; +} + +WORD Bitmap::setRow(WORD row,char FAR *lpRowData) +{ + if(!isOkay()||row>=height()||!lpRowData)return FALSE; + UHUGE *lpImage=getDataPtr()+mImageExtent; + copyBits((UHUGE*)(lpImage-(((LONG)row*(LONG)width())+(LONG)width())),(UHUGE*)lpRowData,width()); + return TRUE; +} + +WORD Bitmap::getCol(WORD col,char FAR *lpColData) +{ + if(!isOkay()||col>=width()||!lpColData)return FALSE; + UHUGE *lpImage=getDataPtr()+mImageExtent; + lpImage=(lpImage-(LONG)width())+(LONG)col; + for(short rowIndex=0;rowIndex=width()||!lpColData)return FALSE; + UHUGE *lpImage=getDataPtr()+mImageExtent; + lpImage=(lpImage-(LONG)width())+(LONG)col; + for(short rowIndex=0;rowIndex +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_TYPES_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_BITMAPDATA_HPP_ +#include +#endif +#ifndef _COMMON_PUREPALETTE_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif +#ifndef _COMMON_BITMAPINFO_HPP_ +#include +#endif +#ifndef _COMMON_BITMAPOVERLAY_HPP_ +#include +#endif + +class MemFile; + +class Bitmap : public BitmapData +{ +public: + enum {MaxColors=256,BitCount=8,Planes=1}; + Bitmap(void); + Bitmap(const Bitmap &someBitmap); + Bitmap(const String &pathFileName); + Bitmap(const String &pathFileName,HGLOBAL hGlobalImage,HGLOBAL hGlobalBitmapInfo); + Bitmap(const String &pathFileName,WORD bitmapWidth,WORD bitmapHeight,WORD bitmapColors=MaxColors,WORD bitCount=BitCount); + Bitmap(const String &pathFileName,BitmapInfo &infoData,GlobalData &imageData); + ~Bitmap(); + Bitmap &rotateRight(void); + Bitmap &rotateLeft(void); + WORD operator=(const String &pathFileName); + Bitmap &operator=(const Bitmap &someBitmap); + WORD operator+=(const BitmapOverlay &someBitmapOverlay); + WORD operator==(const Bitmap &someBitmap)const; + WORD width(void)const; + WORD height(void)const; + WORD planes(void)const; + WORD bitCount(void)const; + DWORD getImageExtent(void)const; + void setByte(WORD row,WORD col,BYTE byteValue); + BYTE getByte(WORD row,WORD col)const; + WORD getRow(WORD row,char FAR *lpRowData); + WORD setRow(WORD row,char FAR *lpRowData); + WORD getCol(WORD col,char FAR *lpColData); + WORD setCol(WORD col,char FAR *lpColData); + void setBits(BYTE byteValue); + WORD displayBitmap(HWND hDisplayWindow,HDC hDC=(HDC)0,int isActive=FALSE,int conforming=FALSE)const; + BOOL draw(PureDevice &pureDevice,const Rect &dstRect,const Point &srcPoint); + bool saveBitmap(void); + bool saveBitmap(MemFile &memFile); + bool saveBitmap(const String &pathFileName); + HBITMAP createBitmap(PureDevice &somePureDevice); + WORD setPalette(HPALETTE hPalette,WORD remapBitmap=TRUE); + HPALETTE getPalette(void)const; + BOOL isValidBitmap(const String &pathFileName)const; + WORD isOkay(void)const; + void *ptrData(void); + void upsideDown(void); + HGLOBAL lockedImageData(void)const; + HGLOBAL lockedBitmapInfo(void)const; +private: + enum Mode{Read,Write,Idle}; + enum {Signature=0x4D42}; + void mapPalette(PurePalette &purePalette); + void closeFile(void); + void readPalette(void); + void setPalette(void); + void decodeImage(void); + void getRequiredWidth(WORD &desiredWidth,WORD desiredHeight); + void getRequiredWidth(DWORD &desiredWidth,DWORD desiredHeight); + void copyBitmap(const Bitmap &someBitmap); + void copyBits(UHUGE *destination,UHUGE *source,unsigned long length)const; + void setBits(UHUGE *lpChar,unsigned char charValue,unsigned long length)const; + DWORD imageExtent(void)const; + WORD processBitmap(const String &pathFileName); + + String mFileName; + WORD mMaxColors; + Mode mCurrentMode; + BITMAPFILEHEADER mBitmapFileHeader; + PurePalette mBitmapPalette; + const LONG mBlockSize; + HFILE mhFile; + DWORD mImageExtent; + DWORD mWidth; + DWORD mHeight; +}; + +inline +DWORD Bitmap::imageExtent(void)const +{ + BITMAPINFO *lpBitmapInfo=getInfoPtr(); + return (((((lpBitmapInfo->bmiHeader.biWidth*lpBitmapInfo->bmiHeader.biBitCount)+31)&~31)>>3)*lpBitmapInfo->bmiHeader.biHeight); +} + +inline +DWORD Bitmap::getImageExtent(void)const +{ + return mImageExtent; +} + +inline +WORD Bitmap::isOkay(void)const +{ + return BitmapData::isOkay(); +} + +inline +HGLOBAL Bitmap::lockedImageData(void)const +{ + return getDataHnd(); +} + +inline +HGLOBAL Bitmap::lockedBitmapInfo(void)const +{ + return getInfoHnd(); +} + +inline +WORD Bitmap::operator==(const Bitmap &someBitmap)const +{ + return mFileName==someBitmap.mFileName; +} + +inline +WORD Bitmap::width(void)const +{ + return (WORD)mWidth; +} + +inline +WORD Bitmap::height(void)const +{ + return (WORD)mHeight; +} + +inline +void Bitmap::closeFile(void) +{ + if(HFILE_ERROR!=mhFile){::_lclose(mhFile);mhFile=HFILE_ERROR;} +} + +inline +void Bitmap::setBits(BYTE byteValue) +{ + setBits(getDataPtr(),byteValue,(LONG)width()*(LONG)height()); +} + +inline +BYTE Bitmap::getByte(WORD row,WORD col)const +{ + UHUGE *lpBitmapData; + lpBitmapData=getDataPtr(); + if(row>=height()||col>=width())return FALSE; + UHUGE *lpImage; + lpImage=(lpBitmapData+((LONG)width()*(LONG)height())); + return *((lpImage-(((LONG)row*(LONG)width())+(LONG)width()))+(LONG)col); +} + +inline +void Bitmap::setByte(WORD row,WORD col,BYTE byteValue) +{ + UHUGE *lpBitmapData; + lpBitmapData=getDataPtr(); + if(row>=height()||col>=width())return; + UHUGE *lpImage; + lpImage=(lpBitmapData+((LONG)width()*(LONG)height())); + *((lpImage-(((LONG)row*(LONG)width())+(LONG)width()))+(LONG)col)=byteValue; +} + +inline +WORD Bitmap::planes(void)const +{ + if(!isOkay())return FALSE; + return getInfoPtr()->bmiHeader.biPlanes; +} + +inline +WORD Bitmap::bitCount(void)const +{ + if(!isOkay())return FALSE; + return getInfoPtr()->bmiHeader.biBitCount; +} + +inline +void *Bitmap::ptrData(void) +{ + return getDataPtr(); +} +#endif + diff --git a/common/BLOCK.HPP b/common/BLOCK.HPP new file mode 100644 index 0000000..f6d924d --- /dev/null +++ b/common/BLOCK.HPP @@ -0,0 +1,172 @@ +#ifndef _COMMON_BLOCK_HPP_ +#define _COMMON_BLOCK_HPP_ +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _MSC_VER +#ifdef _EXPAND_BLOCK_TEMPLATES_ +#pragma option -Jgd +#endif +#endif + +template +class Block; + +template +class Container +{ +friend class Block; +public: + Container *next(); + void next(Container *nextItem); + Container *prev(); + void prev(Container *prevItem); +private: + Container *mNext; + Container *mPrev; + T *mItem; + Container(void); + virtual ~Container(); +}; + +template +class Block +{ +public: + class BlockBoundary{}; + typedef LONG Index; + Block(void); + Block(const Block &someBlock); + virtual ~Block(void); + LONG size(void)const; + void insert(const T *item); + bool insertAfter(Index itemIndex,const T *item); + void insert(Block &newBlock); + void remove(void); + void remove(const T *item); + void remove(Block &removeBlock); + void remove(Index itemIndex); + void toArray(Array &array); + Block &operator=(const Block &someBlock); + WORD operator==(const Block &someBlock)const; + T &operator[](LONG itemIndex); + Block &operator+=(const Block &someBlock); +private: + T &find(LONG itemIndex); + LONG mSize; + LONG mLastIndexReferenced; + Container *mLastObjectReferenced; + Container *mLastObjectInserted; + Container *mContainer; +}; + +template +inline +Block::Block(void) +: mContainer(0), mSize(0), mLastIndexReferenced(-1), + mLastObjectReferenced(0), mLastObjectInserted(0) +{ +} + +template +inline +Block::Block(const Block &someBlock) +: mContainer(0), mSize(0), mLastIndexReferenced(-1), + mLastObjectReferenced(0), mLastObjectInserted(0) +{ + *this=someBlock; +} + +template +inline +Block::~Block() +{ + remove(); +} + +template +inline +LONG Block::size(void)const +{ + return mSize; +} + +template +inline +T & Block::operator [](LONG itemIndex) +{ + if(itemIndex>=mSize)throw(BoundaryError()); + if(!mContainer)return *((T*)0); + else if(itemIndex==mLastIndexReferenced&&-1!=mLastIndexReferenced&&mLastObjectReferenced)return *mLastObjectReferenced->mItem; + else if(itemIndex==mLastIndexReferenced+1&&-1!=mLastIndexReferenced) + { + mLastIndexReferenced++; + mLastObjectReferenced=mLastObjectReferenced->next(); + return *mLastObjectReferenced->mItem; + } + return find(itemIndex); +} + +template +inline +void Block::toArray(Array &array) +{ + array.size(size()); + for(int index=0;index +inline +Container::Container() +: mNext(0), mPrev(0), mItem(0) +{ +} + +template +inline +Container::~Container() +{ + if(mItem)delete mItem; +} + +template +inline +Container *Container::next(void) +{ + return mNext; +} + +template +inline +void Container::next(Container *nextItem) +{ + mNext=nextItem; +} + +template +inline +Container *Container::prev(void) +{ + return mPrev; +} + +template +inline +void Container::prev(Container *prevItem) +{ + mPrev=prevItem; +} +#if defined(_MSC_VER) +#include +#endif +#endif + diff --git a/common/BLOCK.TPP b/common/BLOCK.TPP new file mode 100644 index 0000000..6a2a213 --- /dev/null +++ b/common/BLOCK.TPP @@ -0,0 +1,178 @@ +#ifndef _COMMON_BLOCK_TPP_ +#define _COMMON_BLOCK_TPP_ + +template +void Block::remove(void) +{ + if(!mContainer)return; + Container *Cursor=mContainer; + Container *Thumb; + while(Cursor) + { + Thumb=Cursor; + Cursor=Cursor->next(); + ::delete Thumb; + } + mContainer=0; + mLastIndexReferenced=-1L; + mLastObjectReferenced=0; + mLastObjectInserted=0; + mSize=0; +} + +template +T &Block::find(LONG itemIndex) +{ + Container *lpCursor=mContainer; + for(Index i=0;inext(); + if(i==itemIndex) + { + mLastIndexReferenced=i; + mLastObjectReferenced=lpCursor; + return *lpCursor->mItem; + } + return *((T*)0); +} + +template +Block &Block::operator+=(const Block &someBlock) +{ + size_t blockSize(someBlock.size()); + + if(!blockSize)return *this; + for(int itemIndex=0;itemIndex&)someBlock)[itemIndex]); + return *this; +} + +template +bool Block::insertAfter(Index itemIndex,const T *item) +{ + if(itemIndex>=mSize)return false; + mLastObjectInserted->next(::new Container); + mLastObjectInserted->next()->prev(mLastObjectInserted); + mLastObjectInserted=mLastObjectInserted->next(); + mLastObjectInserted->mItem=::new T(); + mSize++; + for(int index=mSize-1;index>itemIndex+1;index--) + { + operator[](index)=operator[](index-1); + } + operator[](itemIndex+1)=*item; + return true; +} + +template +void Block::insert(Block &newBlock) +{ + LONG size(newBlock.size()); + for(Index i=0;i +void Block::insert(const T *item) +{ + if(!mContainer) + { + mContainer=::new Container; + mContainer->mItem=::new T(*item); + mLastObjectInserted=mContainer; + mSize++; + } + else + { + mLastObjectInserted->next(::new Container); + mLastObjectInserted->next()->prev(mLastObjectInserted); + mLastObjectInserted=mLastObjectInserted->next(); + mLastObjectInserted->mItem=::new T(*item); + mSize++; + } +} + +template +void Block::remove(Block &removeBlock) +{ + LONG size(removeBlock.size()); + + if(!size)return; + for(long itemIndex=size-1;itemIndex>=0;itemIndex--)remove(&removeBlock[itemIndex]); +} + +template +void Block::remove(const T *item) +{ + Container *lpThumb=mContainer; + + if(!lpThumb)return; + if(*item==*(mLastObjectInserted->mItem))lpThumb=mLastObjectInserted; + else while(lpThumb){if(*item==*(lpThumb->mItem))break;lpThumb=lpThumb->next();} + if(!lpThumb)return; + if(lpThumb==mContainer) + { + if(lpThumb->next()){mContainer=lpThumb->next();mContainer->prev(0);} + else {mContainer=0;mLastObjectInserted=0;} + } + else + { + if(lpThumb->next()){lpThumb->prev()->next(lpThumb->next());lpThumb->next()->prev(lpThumb->prev());} + else {lpThumb->prev()->next(0);mLastObjectInserted=lpThumb->prev();} + } + ::delete lpThumb; + mSize--; + mLastIndexReferenced=-1; + mLastObjectReferenced=0; +} + +template +void Block::remove(LONG itemIndex) +{ + Container *lpThumb=mContainer; + + if(!lpThumb||itemIndex>=mSize)return; + if(itemIndex==mSize-1)lpThumb=mLastObjectInserted; + else + { + for(Index i=0;inext(); + } + if(!lpThumb)return; + } + if(lpThumb==mContainer) + { + if(lpThumb->next()){mContainer=lpThumb->next();mContainer->prev(0);} + else {mContainer=0;mLastObjectInserted=0;} + } + else + { + if(lpThumb->next()){lpThumb->prev()->next(lpThumb->next());lpThumb->next()->prev(lpThumb->prev());} + else {lpThumb->prev()->next(0);mLastObjectInserted=lpThumb->prev();} + } + ::delete lpThumb; + mSize--; + mLastIndexReferenced=-1; + mLastObjectReferenced=0; +} + +template +Block &Block::operator=(const Block &someBlock) +{ + LONG itemCount(someBlock.size()); + + remove(); + if(!itemCount)return *this; + for(LONG itemIndex=0;itemIndex&)someBlock)[itemIndex])); + return *this; +} + +template +WORD Block::operator==(const Block &someBlock)const +{ + LONG itemCount(size()); + + if(itemCount!=someBlock.size())return FALSE; + for(LONG itemIndex=0;itemIndex&)*this).operator[](itemIndex)==((Block&)someBlock)[itemIndex]))return FALSE; + return TRUE; +} +#endif diff --git a/common/BMDATA.CPP b/common/BMDATA.CPP new file mode 100644 index 0000000..545a675 --- /dev/null +++ b/common/BMDATA.CPP @@ -0,0 +1,74 @@ +#include + +void BitmapData::cleanupData(void) +{ + if(mhGlobalBitmapData&&Delete==mDataDisposition) + { + ::GlobalUnlock(mhGlobalBitmapData); + ::GlobalFree(mhGlobalBitmapData); + } + mhGlobalBitmapData=0; + mlpBitmapData=0; +} + +void BitmapData::cleanupInfo(void) +{ + if(mhGlobalBitmapInfo&&Delete==mInfoDisposition) + { + ::GlobalUnlock(mhGlobalBitmapInfo); + ::GlobalFree(mhGlobalBitmapInfo); + } + mhGlobalBitmapInfo=0; + mlpBitmapInfo=0; +} + +UHUGE *BitmapData::reserveData(LONG sizeData) +{ + cleanupData(); + if(!sizeData)return 0; + mhGlobalBitmapData=::GlobalAlloc(GMEM_FIXED,sizeData); + if(!mhGlobalBitmapData)return 0; + mlpBitmapData=(UHUGE*)::GlobalLock(mhGlobalBitmapData); + mDataDisposition=Delete; + return mlpBitmapData; +} + +BITMAPINFO *BitmapData::reserveInfo(LONG sizeInfo,WORD numColors) +{ + cleanupInfo(); + if(!sizeInfo)mhGlobalBitmapInfo=::GlobalAlloc(GMEM_FIXED,sizeof(BITMAPINFO)+(sizeof(RGBQUAD)*(numColors-1))); + else mhGlobalBitmapInfo=::GlobalAlloc(GMEM_FIXED,sizeInfo); + if(!mhGlobalBitmapInfo)return 0; + mlpBitmapInfo=(BITMAPINFO FAR*)::GlobalLock(mhGlobalBitmapInfo); + mInfoDisposition=Delete; + return mlpBitmapInfo; +} + +WORD BitmapData::setData(UHUGE *lpBitmapData) +{ + cleanupData(); + if(!lpBitmapData)return FALSE; + mlpBitmapData=lpBitmapData; + mDataDisposition=Keep; + return TRUE; +} + +WORD BitmapData::setData(HGLOBAL hGlobalData,UHUGE *lpBitmapData) +{ + cleanupData(); + if(!hGlobalData||!lpBitmapData)return 0; + mlpBitmapData=lpBitmapData; + mhGlobalBitmapData=hGlobalData; + mDataDisposition=Delete; + return TRUE; +} + +WORD BitmapData::setInfo(BITMAPINFO FAR*lpBitmapInfo) +{ + cleanupInfo(); + if(!lpBitmapInfo)return FALSE; + mlpBitmapInfo=lpBitmapInfo; + mInfoDisposition=Keep; + return TRUE; +} + diff --git a/common/BMDATA.HPP b/common/BMDATA.HPP new file mode 100644 index 0000000..af7c5bb --- /dev/null +++ b/common/BMDATA.HPP @@ -0,0 +1,94 @@ +#ifndef _COMMON_BITMAPDATA_HPP_ +#define _COMMON_BITMAPDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_TYPES_HPP_ +#include +#endif + +class BitmapData +{ +public: + typedef enum Disposition{Keep,Delete}; + BitmapData(void); + ~BitmapData(); + Disposition getInfoType(void)const; + Disposition getDataType(void)const; + UHUGE *reserveData(LONG sizeData); + BITMAPINFO *reserveInfo(LONG sizeInfo=0,WORD numColors=0); + WORD setData(HGLOBAL hGlobalData,UHUGE *lpBitmapData); + WORD setData(UHUGE *lpBitmapData); + WORD setInfo(BITMAPINFO FAR *lpBitmapInfo); + HGLOBAL getInfoHnd(void)const; + HGLOBAL getDataHnd(void)const; + BITMAPINFO *getInfoPtr(void)const; + UHUGE *getDataPtr(void)const; + WORD isOkay(void)const; +private: + void cleanupData(void); + void cleanupInfo(void); + HGLOBAL mhGlobalBitmapData; + HGLOBAL mhGlobalBitmapInfo; + UHUGE *mlpBitmapData; + BITMAPINFO *mlpBitmapInfo; + Disposition mInfoDisposition; + Disposition mDataDisposition; +}; + +inline +BitmapData::BitmapData(void) +: mhGlobalBitmapData(0), mhGlobalBitmapInfo(0), mlpBitmapData(0), mlpBitmapInfo(0), + mInfoDisposition(Delete), mDataDisposition(Delete) +{ +} + +inline +BitmapData::~BitmapData() +{ + cleanupData(); + cleanupInfo(); +} + +inline +BITMAPINFO *BitmapData::getInfoPtr(void)const +{ + return mlpBitmapInfo; +} + +inline +UHUGE *BitmapData::getDataPtr(void)const +{ + return mlpBitmapData; +} + +inline +HGLOBAL BitmapData::getInfoHnd(void)const +{ + return mhGlobalBitmapInfo; +} + +inline +HGLOBAL BitmapData::getDataHnd(void)const +{ + return mhGlobalBitmapData; +} + +inline +WORD BitmapData::isOkay(void)const +{ + return (mlpBitmapData&&mlpBitmapInfo); +} + +inline +BitmapData::Disposition BitmapData::getInfoType(void)const +{ + return mInfoDisposition; +} + +inline +BitmapData::Disposition BitmapData::getDataType(void)const +{ + return mDataDisposition; +} +#endif diff --git a/common/BMINFO.CPP b/common/BMINFO.CPP new file mode 100644 index 0000000..de3b1cc --- /dev/null +++ b/common/BMINFO.CPP @@ -0,0 +1,167 @@ +#include +#include + +BitmapInfo &BitmapInfo::operator=(const BitmapInfo &someBitmapInfo) +{ + createInfo(someBitmapInfo.rgbColors()); + planes(someBitmapInfo.planes()); + width(someBitmapInfo.width()); + height(someBitmapInfo.height()); + bitCount(someBitmapInfo.bitCount()); + compression(someBitmapInfo.compression()); + sizeImage(someBitmapInfo.sizeImage()); + xPelsPerMeter(someBitmapInfo.xPelsPerMeter()); + yPelsPerMeter(someBitmapInfo.yPelsPerMeter()); + colorUsed(someBitmapInfo.colorUsed()); + colorImportant(someBitmapInfo.colorImportant()); + for(int itemIndex=0;itemIndexbmiColors[paletteIndex].rgbRed=paletteEntry.red(); + mlpBitmapInfo->bmiColors[paletteIndex].rgbGreen=paletteEntry.green(); + mlpBitmapInfo->bmiColors[paletteIndex].rgbBlue=paletteEntry.blue(); + mlpBitmapInfo->bmiColors[paletteIndex].rgbReserved=0; + } + return *this; +} + +WORD BitmapInfo::operator==(const BitmapInfo &someBitmapInfo)const +{ + if(rgbColors()!=someBitmapInfo.rgbColors())return FALSE; + if (!(planes()==someBitmapInfo.planes())|| + !(width()==someBitmapInfo.width())|| + !(height()==someBitmapInfo.height())|| + !(bitCount()==someBitmapInfo.bitCount())|| + !(compression()==someBitmapInfo.compression())|| + !(sizeImage()==someBitmapInfo.sizeImage())|| + !(xPelsPerMeter()==someBitmapInfo.xPelsPerMeter())|| + !(yPelsPerMeter()==someBitmapInfo.yPelsPerMeter())|| + !(colorUsed()==someBitmapInfo.colorUsed())|| + !(colorImportant()==someBitmapInfo.colorImportant()))return FALSE; + for(int itemIndex=0;itemIndexbmiHeader.biSize=sizeof(BITMAPINFOHEADER); + bitCount(BitsPerPixel(DefaultBitCount)); + compression(BiRGB); + planes(DefaultPlanes); + colorUsed(rgbColors); + colorImportant(rgbColors); + mRGBColors=rgbColors; +} + +void BitmapInfo::destroyInfo(void) +{ + if(!mhGlobalHandle)return; + ::GlobalUnlock(mhGlobalHandle); + ::GlobalFree(mhGlobalHandle); + mhGlobalHandle=0; + mlpBitmapInfo=0; + mRGBColors=0; +} + +void BitmapInfo::verifyDimensions(void) +{ + DWORD desiredHeight(height()<0?-height():height()); + DWORD desiredWidth(width()); + DWORD imageExtent; + + imageExtent=(((((LONG)desiredWidth*8)+31)&~31)>>3)*(LONG)desiredHeight; + if(imageExtent==(LONG)desiredWidth*(LONG)desiredHeight)return; + else desiredWidth=(WORD)(imageExtent/(LONG)desiredHeight); + width(desiredWidth); +} + +String BitmapInfo::toString(void)const +{ + String strCompression; + String str; + str+=String("[BitmapInfo::toString]planes=")+String().fromInt(planes())+String("\n"); + str+=String("[BitmapInfo::toString]width=")+String().fromInt(width())+String("\n"); + str+=String("[BitmapInfo::toString]height=")+String().fromInt(height())+String("\n"); + str+=String("[BitmapInfo::toString]bitCount=")+String().fromInt(bitCount())+String("\n"); + if(BiRGB==compression())strCompression="BI_RGB"; + else if(BiBitFields==compression())strCompression="BI_BITFIELDS"; + else if(BiRLE8==compression())strCompression="BI_RLE8"; + else if(BiRLE4==compression())strCompression="BI_RLE4"; + else strCompression=makeCompressionString(); + str+=String("[BitmapInfo::toString]compression=")+strCompression+String("\n"); + str+=String("[BitmapInfo::toString]sizeImage=")+String().fromInt(sizeImage())+String("\n"); + str+=String("[BitmapInfo::toString]xPelsPerMeter=")+String().fromInt(xPelsPerMeter())+String("\n"); + str+=String("[BitmapInfo::toString]yPelsPerMeter=")+String().fromInt(yPelsPerMeter())+String("\n"); + str+=String("[BitmapInfo::toString]colorUsed=")+String().fromInt(colorUsed())+String("\n"); + str+=String("[BitmapInfo::toString]colorImportant=")+String().fromInt(colorImportant())+String("\n"); + return str; +} + +String BitmapInfo::makeCompressionString(void)const +{ + String strCompression; + + strCompression.reserve(5); + ((char*)strCompression)[0]=(BYTE)(compression()&0xFF); + ((char*)strCompression)[1]=(BYTE)((compression()>>0x08)&0xFF); + ((char*)strCompression)[2]=(BYTE)((compression()>>0x10)&0xFF); + ((char*)strCompression)[3]=(BYTE)((compression()>>0x18)&0xFF); + return strCompression; +} + diff --git a/common/BMINFO.HPP b/common/BMINFO.HPP new file mode 100644 index 0000000..97231c7 --- /dev/null +++ b/common/BMINFO.HPP @@ -0,0 +1,289 @@ +#ifndef _COMMON_BITMAPINFO_HPP_ +#define _COMMON_BITMAPINFO_HPP_ +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_RGBQUAD_HPP_ +#include +#endif + +class PurePalette; + +class BitmapInfo +{ +public: + enum BitsPerPixel{Bit8=8,Bit16=16,Bit24=24,TrueColor=24,Bit32=32}; + enum BiCompression{BiRGB=BI_RGB,BiBitFields=BI_BITFIELDS,BiRLE8=BI_RLE8,BiRLE4=BI_RLE4}; + BitmapInfo(void); + BitmapInfo(const BitmapInfo &someBitmapInfo); + BitmapInfo(const BITMAPINFO &someBITMAPINFO); + virtual ~BitmapInfo(); + BitmapInfo &operator=(const BitmapInfo &someBitmapInfo); + BitmapInfo &operator=(const BITMAPINFO &someBITMAPINFO); + BitmapInfo &operator=(const PurePalette &somePurePalette); + WORD operator==(const BitmapInfo &someBitmapInfo)const; + RGBQuad &operator[](int itemIndex); + operator BITMAPINFO&(void); + operator BITMAPINFO*(void); + operator BITMAPINFOHEADER*(void); + operator BITMAPINFOHEADER&(void); + operator RGBQUAD*(void); + WORD planes(void)const; + void planes(WORD planes); + LONG width(void)const; + void width(LONG width); + LONG height(void)const; + void height(LONG height); + BitsPerPixel bitCount(void)const; + void bitCount(BitsPerPixel bitCount); + BiCompression compression(void)const; + void compression(BiCompression compression); + void compression(DWORD compression); + DWORD sizeImage(void)const; + void sizeImage(DWORD sizeImage); + LONG xPelsPerMeter(void)const; + void xPelsPerMeter(LONG xPelsPerMeter); + LONG yPelsPerMeter(void)const; + void yPelsPerMeter(LONG yPelsPerMeter); + DWORD colorUsed(void)const; + void colorUsed(DWORD colorUsed); + DWORD colorImportant(void)const; + void colorImportant(DWORD colorImportant); + DWORD rgbColors(void)const; + void rgbColors(DWORD rgbColors); + DWORD imageExtent(void)const; + void verifyDimensions(void); + String toString(void)const; + BITMAPINFO &getBITMAPINFO(void); + BITMAPINFOHEADER &getBITMAPINFOHEADER(void); +private: + enum {DefaultColors=0x100,DefaultCompression=BI_RGB,DefaultBitCount=Bit8,DefaultPlanes=0x01}; + void createInfo(DWORD rgbColors); + void destroyInfo(void); + String makeCompressionString(void)const; + + BITMAPINFO *mlpBitmapInfo; + HGLOBAL mhGlobalHandle; + DWORD mRGBColors; +}; + +inline +BitmapInfo::BitmapInfo(void) +: mlpBitmapInfo(0), mhGlobalHandle(0), mRGBColors(0) +{ + createInfo(DefaultColors); +} + +inline +BitmapInfo::BitmapInfo(const BitmapInfo &someBitmapInfo) +: mlpBitmapInfo(0), mhGlobalHandle(0), mRGBColors(0) +{ + *this=someBitmapInfo; +} + +inline +BitmapInfo::BitmapInfo(const BITMAPINFO &someBITMAPINFO) +: mlpBitmapInfo(0), mhGlobalHandle(0), mRGBColors(0) +{ + *this=someBITMAPINFO; +} + +inline +BitmapInfo::~BitmapInfo() +{ + destroyInfo(); +} + +inline +BitmapInfo::operator BITMAPINFO&(void) +{ + return *mlpBitmapInfo; +} + +inline +BitmapInfo::operator BITMAPINFO*(void) +{ + return mlpBitmapInfo; +} + +inline +BitmapInfo::operator BITMAPINFOHEADER&(void) +{ + return mlpBitmapInfo->bmiHeader; +} + +inline +BitmapInfo::operator BITMAPINFOHEADER*(void) +{ + return &mlpBitmapInfo->bmiHeader; +} + +inline +BitmapInfo::operator RGBQUAD*(void) +{ + return mlpBitmapInfo->bmiColors; +} + +inline +RGBQuad &BitmapInfo::operator[](int itemIndex) +{ + if(!(itemIndexbmiColors[itemIndex]; +} + +inline +BITMAPINFO &BitmapInfo::getBITMAPINFO(void) +{ + return *mlpBitmapInfo; +} + +inline +BITMAPINFOHEADER &BitmapInfo::getBITMAPINFOHEADER(void) +{ + return mlpBitmapInfo->bmiHeader; +} + +inline +WORD BitmapInfo::planes(void)const +{ + return mlpBitmapInfo->bmiHeader.biPlanes; +} + +inline +void BitmapInfo::planes(WORD planes) +{ + mlpBitmapInfo->bmiHeader.biPlanes=planes; +} + +inline +LONG BitmapInfo::width(void)const +{ + return mlpBitmapInfo->bmiHeader.biWidth; +} + +inline +void BitmapInfo::width(LONG width) +{ + mlpBitmapInfo->bmiHeader.biWidth=width; + sizeImage(imageExtent()); +} + +inline +LONG BitmapInfo::height(void)const +{ + return mlpBitmapInfo->bmiHeader.biHeight; +} + +inline +void BitmapInfo::height(LONG height) +{ + mlpBitmapInfo->bmiHeader.biHeight=height; + sizeImage(imageExtent()); +} + +inline +BitmapInfo::BitsPerPixel BitmapInfo::bitCount(void)const +{ + return BitsPerPixel(mlpBitmapInfo->bmiHeader.biBitCount); +} + +inline +void BitmapInfo::bitCount(BitsPerPixel bitCount) +{ + mlpBitmapInfo->bmiHeader.biBitCount=int(bitCount); + sizeImage(imageExtent()); +} + +inline +BitmapInfo::BiCompression BitmapInfo::compression(void)const +{ + return BiCompression(mlpBitmapInfo->bmiHeader.biCompression); +} + +inline +void BitmapInfo::compression(BiCompression compression) +{ + mlpBitmapInfo->bmiHeader.biCompression=compression; +} + +inline +void BitmapInfo::compression(DWORD compression) // backward compatibility +{ + mlpBitmapInfo->bmiHeader.biCompression=compression; +} + +inline +DWORD BitmapInfo::sizeImage(void)const +{ + return mlpBitmapInfo->bmiHeader.biSizeImage; +} + +inline +void BitmapInfo::sizeImage(DWORD sizeImage) +{ + mlpBitmapInfo->bmiHeader.biSizeImage=sizeImage; +} + +inline +LONG BitmapInfo::xPelsPerMeter(void)const +{ + return mlpBitmapInfo->bmiHeader.biXPelsPerMeter; +} + +inline +void BitmapInfo::xPelsPerMeter(LONG xPelsPerMeter) +{ + mlpBitmapInfo->bmiHeader.biXPelsPerMeter=xPelsPerMeter; +} + +inline +LONG BitmapInfo::yPelsPerMeter(void)const +{ + return mlpBitmapInfo->bmiHeader.biYPelsPerMeter; +} + +inline +void BitmapInfo::yPelsPerMeter(LONG yPelsPerMeter) +{ + mlpBitmapInfo->bmiHeader.biYPelsPerMeter=yPelsPerMeter; +} + +inline +DWORD BitmapInfo::colorUsed(void)const +{ + return mlpBitmapInfo->bmiHeader.biClrUsed; +} + +inline +void BitmapInfo::colorUsed(DWORD colorUsed) +{ + mlpBitmapInfo->bmiHeader.biClrUsed=colorUsed; +} + +inline +DWORD BitmapInfo::colorImportant(void)const +{ + return mlpBitmapInfo->bmiHeader.biClrImportant; +} + +inline +void BitmapInfo::colorImportant(DWORD colorImportant) +{ + mlpBitmapInfo->bmiHeader.biClrImportant=colorImportant; +} + +inline +DWORD BitmapInfo::rgbColors(void)const +{ + return mRGBColors; +} + +inline +DWORD BitmapInfo::imageExtent(void)const +{ + return (((((width()*(long)bitCount())+31)&~31)>>3)*height()); +} +#endif diff --git a/common/BMPLNK.CPP b/common/BMPLNK.CPP new file mode 100644 index 0000000..5ea1388 --- /dev/null +++ b/common/BMPLNK.CPP @@ -0,0 +1,46 @@ +#include + +LinkedBitmap::LinkedBitmap(void) +: mCtlID(0), mhBitmap(0), mReferenceCount(0), mhLibrary(0) +{ + ::memset(&mBitmapInfo,0,sizeof(BITMAP)); +} + +LinkedBitmap::LinkedBitmap(int ctlID,String &bitmapName,HINSTANCE hLibrary) +: mCtlID(ctlID), mReferenceCount(1), mhLibrary(hLibrary), mBitmapName(bitmapName) +{ + ::memset(&mBitmapInfo,0,sizeof(BITMAP)); + loadBitmap(bitmapName,hLibrary); +} + +LinkedBitmap::LinkedBitmap(const LinkedBitmap &someLinkedBitmap) +: mCtlID(someLinkedBitmap.mCtlID), mReferenceCount(someLinkedBitmap.mReferenceCount), + mhLibrary(someLinkedBitmap.mhLibrary), mBitmapName(someLinkedBitmap.mBitmapName) +{ + ::memset(&mBitmapInfo,0,sizeof(BITMAP)); + loadBitmap(someLinkedBitmap.mBitmapName,someLinkedBitmap.mhLibrary); +} + +LinkedBitmap::~LinkedBitmap() +{ + destroy(); +} + +void LinkedBitmap::destroy(void) +{ + if(!isOkay())return; + ::DeleteObject(mhBitmap); + mhBitmap=0; +} + +WORD LinkedBitmap::drawBitmap(HDC hDC,RECT locationRect) +{ + DrawBitmap::drawBitmap(hDC,mhBitmap,locationRect); + return TRUE; +} + +WORD LinkedBitmap::drawBitmap(void) +{ + DrawBitmap::drawBitmap(mhBitmap); + return TRUE; +} diff --git a/common/BMPLNK.HPP b/common/BMPLNK.HPP new file mode 100644 index 0000000..6477385 --- /dev/null +++ b/common/BMPLNK.HPP @@ -0,0 +1,103 @@ +#ifndef _COMMON_LINKEDBITMAP_HPP_ +#define _COMMON_LINKEDBITMAP_HPP_ +#ifndef _COMMON_DRAWBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class LinkedBitmap : public DrawBitmap +{ +public: + LinkedBitmap(void); + LinkedBitmap(int ctlID,String &bitmapName,HINSTANCE hLibrary); + LinkedBitmap(const LinkedBitmap &someLinkedBitmap); + virtual ~LinkedBitmap(); + WORD drawBitmap(HDC hDC,RECT locationRect); + WORD drawBitmap(void); + int referenceCount(void)const; + void referenceCount(int newCount); + bool operator==(const LinkedBitmap &someLinkedBitmap)const; + bool operator==(int ctlID)const; + DWORD width(void)const; + DWORD height(void)const; + HBITMAP getHBITMAP(void)const; + bool isOkay(void)const; + bool loadBitmap(const String &strBitmapName,HINSTANCE hInstance=::GetModuleHandle(0)); +private: + void getBitmapInfo(void); + void destroy(void); + + int mCtlID; + HBITMAP mhBitmap; + BITMAP mBitmapInfo; + String mBitmapName; + int mReferenceCount; + HINSTANCE mhLibrary; +}; + +inline +int LinkedBitmap::referenceCount(void)const +{ + return mReferenceCount; +} + +inline +void LinkedBitmap::referenceCount(int newCount) +{ + mReferenceCount=newCount; +} + +inline +bool LinkedBitmap::operator==(const LinkedBitmap &someLinkedBitmap)const +{ + return (mCtlID==someLinkedBitmap.mCtlID); +} + +inline +bool LinkedBitmap::operator==(int ctlID)const +{ + return mCtlID==ctlID; +} + +inline +bool LinkedBitmap::loadBitmap(const String &strBitmapName,HINSTANCE hInstance) +{ + destroy(); + mhBitmap=::LoadBitmap(hInstance,strBitmapName.str()); + if(!mhBitmap)return false; + getBitmapInfo(); + return true; +} + +inline +void LinkedBitmap::getBitmapInfo(void) +{ + ::GetObject(mhBitmap,sizeof(BITMAP),(LPSTR)&mBitmapInfo); +} + +inline +DWORD LinkedBitmap::width(void)const +{ + return mBitmapInfo.bmWidth; +} + +inline +DWORD LinkedBitmap::height(void)const +{ + return mBitmapInfo.bmHeight; +} + +inline +HBITMAP LinkedBitmap::getHBITMAP(void)const +{ + return mhBitmap; +} + +inline +bool LinkedBitmap::isOkay(void)const +{ + return mhBitmap?true:false; +} +#endif diff --git a/common/BOVERLAY.HPP b/common/BOVERLAY.HPP new file mode 100644 index 0000000..6cd06e5 --- /dev/null +++ b/common/BOVERLAY.HPP @@ -0,0 +1,44 @@ +#ifndef _COMMON_BITMAPOVERLAY_HPP_ +#define _COMMON_BITMAPOVERLAY_HPP_ +#ifndef _COMMON_POINT_HPP_ +#include +#endif + +class Bitmap; + +class BitmapOverlay +{ +public: + BitmapOverlay(Bitmap &someBitmap,const Point &placementPoint); + virtual ~BitmapOverlay(); + Bitmap &bitmap(void); + const Point &placementPoint(void)const; +private: + Bitmap &mBitmap; + Point mPlacementPoint; +}; + +inline +BitmapOverlay::BitmapOverlay(Bitmap &someBitmap,const Point &placementPoint) +: mBitmap(someBitmap), mPlacementPoint(placementPoint) +{ +} + +inline +BitmapOverlay::~BitmapOverlay() +{ +} + +inline +Bitmap &BitmapOverlay::bitmap(void) +{ + return mBitmap; +} + +inline +const Point &BitmapOverlay::placementPoint(void)const +{ + return mPlacementPoint; +} +#endif + diff --git a/common/BRUSH.CPP b/common/BRUSH.CPP new file mode 100644 index 0000000..4e7697a --- /dev/null +++ b/common/BRUSH.CPP @@ -0,0 +1,36 @@ +#include +#include +#include + +Brush::Brush(PureBitmap &pureBitmap) +: mhBrush(0) +{ + if(!pureBitmap.isOkay())return; + mhBrush=::CreatePatternBrush(pureBitmap); +} + +Brush::Brush(ResBitmap &resBitmap) +: mhBrush(0) +{ + if(!resBitmap.isOkay())return; + mhBrush=::CreateDIBPatternBrushPt((BITMAPINFO*)(char*)(ResData&)resBitmap,DIB_RGB_COLORS); +} + +bool Brush::createPatternBrush(PureBitmap &pureBitmap) +{ + destroy(); + if(!pureBitmap.isOkay())return FALSE; + mhBrush=::CreatePatternBrush(pureBitmap.getBitmap()); + return isOkay(); +} + +bool Brush::createHatchBrush(HatchStyle hatchStyle,const RGBColor &color) +{ + destroy(); + mBrushColor=color; + mhBrush=::CreateHatchBrush(int(hatchStyle),color.getCOLORREF()); + return isOkay(); +} + + + diff --git a/common/BRUSH.HPP b/common/BRUSH.HPP new file mode 100644 index 0000000..94928ad --- /dev/null +++ b/common/BRUSH.HPP @@ -0,0 +1,128 @@ +#ifndef _COMMON_BRUSH_HPP_ +#define _COMMON_BRUSH_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_GDIOBJ_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif + +class PureBitmap; +class ResBitmap; + +class Brush +{ +public: + enum HatchStyle{HDiag=HS_BDIAGONAL,HCross=HS_CROSS,HDiagCross=HS_DIAGCROSS,HFDiag=HS_FDIAGONAL,HHoriz=HS_HORIZONTAL,HVert=HS_VERTICAL}; + Brush(void); + Brush(RGBColor rgbColor); + Brush(int red,int green,int blue); + Brush(PureBitmap &pureBitmap); + Brush(ResBitmap &resBitmap); + virtual ~Brush(); + operator GDIObj(void); + bool createBrush(const RGBColor &rgbColor); + bool createNullBrush(void); + bool createPatternBrush(PureBitmap &pureBitmap); + bool createHatchBrush(HatchStyle hatchStyle,const RGBColor &rgbColor); + bool isOkay(void)const; + HBRUSH getBrush(void)const; + const RGBColor &getColor(void)const; +private: + Brush(const Brush &someBrush); + Brush &operator=(const Brush &someBrush); + void destroy(void); + HBRUSH mhBrush; + RGBColor mBrushColor; +}; + +inline +Brush::Brush(void) +: mhBrush(0) +{ +} + +inline +Brush::Brush(const Brush &/*someBrush*/) +: mhBrush(0) +{ // private implementation +} + +inline +Brush::Brush(int red,int green,int blue) +: mhBrush(0) +{ + mhBrush=::CreateSolidBrush((COLORREF)RGBColor(red,green,blue)); +} + +inline +Brush::Brush(RGBColor rgbColor) +: mhBrush(0) +{ + mBrushColor=rgbColor; + mhBrush=::CreateSolidBrush((COLORREF)rgbColor); +} + +inline +Brush::~Brush() +{ + destroy(); +} + +inline +Brush &Brush::operator=(const Brush &/*someBrush*/) +{ // private implementation + return *this; +} + +inline +Brush::operator GDIObj(void) +{ + return (GDIObj)mhBrush; +} + +inline +void Brush::destroy(void) +{ + if(mhBrush){::DeleteObject(mhBrush);mhBrush=0;} +} + +inline +bool Brush::createBrush(const RGBColor &rgbColor) +{ + destroy(); + mBrushColor=rgbColor; + mhBrush=::CreateSolidBrush((COLORREF)rgbColor); + return isOkay(); +} + +inline +bool Brush::createNullBrush(void) +{ + destroy(); + mhBrush=(HBRUSH)::GetStockObject(NULL_BRUSH); + return isOkay(); +} + +inline +const RGBColor &Brush::getColor(void)const +{ + return mBrushColor; +} + +inline +HBRUSH Brush::getBrush(void)const +{ + return mhBrush; +} + +inline +bool Brush::isOkay(void)const +{ + return (mhBrush?TRUE:FALSE); +} +#endif + diff --git a/common/BTNLNK.CPP b/common/BTNLNK.CPP new file mode 100644 index 0000000..a226ee3 --- /dev/null +++ b/common/BTNLNK.CPP @@ -0,0 +1,87 @@ +#include +#include + +LinkedButton::LinkedButton(void) +: mCtlID(0), mFocus(Focus), mlpBitmapDefault(0), mReferenceCount(0), mhInstance(0) +{ +} + +LinkedButton::LinkedButton(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,String &noFocusDisabled,HINSTANCE hInstance,FocusItem focusItem) +: mCtlID(ctlID), mReferenceCount(1), mFocus(focusItem), + mBitmapFocusUp(focusUp,hInstance), mBitmapNoFocusUp(noFocusUp,hInstance), + mBitmapFocusDown(focusDown,hInstance), mBitmapDisabled(noFocusDisabled,hInstance), + mFocusUpString(focusUp), mNoFocusUpString(noFocusUp), mFocusDownString(focusDown), + mNoFocusDisabledString(noFocusDisabled), mhInstance(hInstance) +{ + setBitmapDefault(); +} + +LinkedButton::LinkedButton(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,HINSTANCE hInstance,FocusItem focusItem) +: mCtlID(ctlID), mReferenceCount(1), mFocus(focusItem), + mBitmapFocusUp(focusUp,hInstance), mBitmapNoFocusUp(noFocusUp,hInstance), + mBitmapFocusDown(focusDown,hInstance), mBitmapDisabled(noFocusUp,hInstance), + mFocusUpString(focusUp), mNoFocusUpString(noFocusUp), mFocusDownString(focusDown), + mNoFocusDisabledString(noFocusUp), mhInstance(hInstance) +{ + setBitmapDefault(); +} + +LinkedButton::LinkedButton(const LinkedButton &someLinkedButton) +: mCtlID(someLinkedButton.mCtlID), mReferenceCount(someLinkedButton.mReferenceCount), + mFocus(someLinkedButton.mFocus), mhInstance(someLinkedButton.instance()), + mBitmapFocusUp(someLinkedButton.mFocusUpString,someLinkedButton.instance()), + mBitmapNoFocusUp(someLinkedButton.mNoFocusUpString,someLinkedButton.instance()), + mBitmapFocusDown(someLinkedButton.mFocusDownString,someLinkedButton.instance()), + mBitmapDisabled(someLinkedButton.mNoFocusDisabledString,someLinkedButton.instance()), + mFocusUpString(someLinkedButton.mFocusUpString), + mNoFocusUpString(someLinkedButton.mNoFocusUpString), + mFocusDownString(someLinkedButton.mFocusDownString), + mNoFocusDisabledString(someLinkedButton.mNoFocusDisabledString) +{ + setBitmapDefault(); +} + +LinkedButton::~LinkedButton() +{ +} + +WORD LinkedButton::drawButton(LPDRAWITEMSTRUCT lpControlData) +{ + int retCode(TRUE); + + switch(lpControlData->itemAction) + { + case ODA_DRAWENTIRE : + if(lpControlData->itemState&ODS_SELECTED)drawBitmap(lpControlData,mBitmapFocusDown); + else if(lpControlData->itemState&ODS_FOCUS)drawBitmap(lpControlData,*mlpBitmapDefault); + else if(lpControlData->itemState&ODS_DISABLED)drawBitmap(lpControlData,mBitmapDisabled); + else drawBitmap(lpControlData,mBitmapNoFocusUp); + break; + case ODA_SELECT : + if(lpControlData->itemState&ODS_SELECTED)drawBitmap(lpControlData,mBitmapFocusDown); + else + { + drawBitmap(lpControlData,mBitmapFocusUp); + retCode=FALSE; + } + break; + case ODA_FOCUS : + if(lpControlData->itemState&ODS_FOCUS)drawBitmap(lpControlData,mBitmapFocusUp); + else drawBitmap(lpControlData,mBitmapNoFocusUp); + break; + } + return retCode; +} + +void LinkedButton::drawBitmap(const LPDRAWITEMSTRUCT lpControlData,PureBitmap &pureBitmap) +{ + RECT controlRect; + + if(!pureBitmap.isOkay())return; + PureDevice displayDevice(lpControlData->hDC); + PureDevice memDevice(displayDevice); + ::GetClientRect(lpControlData->hwndItem,&controlRect); + memDevice.select((HBITMAP)pureBitmap); + displayDevice.stretchBlt(controlRect,memDevice,Rect(0,0,pureBitmap.width(),pureBitmap.height()),PureDevice::SourceCopy); + memDevice.select((HBITMAP)pureBitmap,FALSE); +} diff --git a/common/BTNLNK.HPP b/common/BTNLNK.HPP new file mode 100644 index 0000000..428a217 --- /dev/null +++ b/common/BTNLNK.HPP @@ -0,0 +1,89 @@ +#ifndef _COMMON_LINKEDBUTTON_HPP_ +#define _COMMON_LINKEDBUTTON_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_PUREBITMAP_HPP_ +#include +#endif + +class LinkedButton +{ +public: + enum FocusItem{Focus,NoFocus}; + LinkedButton(void); + LinkedButton(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,HINSTANCE hLibrary,FocusItem focusItem=Focus); + LinkedButton(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,String &noFocusDisabled,HINSTANCE hLibrary,FocusItem focusItem=Focus); + LinkedButton(const LinkedButton &someLinkedButton); + virtual ~LinkedButton(); + WORD drawButton(LPDRAWITEMSTRUCT lpControlData); + int referenceCount(void)const; + void referenceCount(int newCount); + WORD operator==(const LinkedButton &someLinkedButton)const; + WORD operator==(int ctlID)const; + HINSTANCE instance(void)const; +private: + void instance(HINSTANCE hInstance); + void setBitmapDefault(void); + void loadButtons(void); + void drawBitmap(const LPDRAWITEMSTRUCT lpControlData,PureBitmap &pureBitmap); + + int mCtlID; + PureBitmap mBitmapFocusUp; + PureBitmap mBitmapNoFocusUp; + PureBitmap mBitmapFocusDown; + PureBitmap mBitmapDisabled; + PureBitmap *mlpBitmapDefault; + String mFocusUpString; + String mNoFocusUpString; + String mFocusDownString; + String mNoFocusDisabledString; + int mReferenceCount; + FocusItem mFocus; + HINSTANCE mhInstance; +}; + +inline +int LinkedButton::referenceCount(void)const +{ + return mReferenceCount; +} + +inline +void LinkedButton::referenceCount(int newCount) +{ + mReferenceCount=newCount; +} + +inline +WORD LinkedButton::operator==(const LinkedButton &someLinkedButton)const +{ + return (mCtlID==someLinkedButton.mCtlID); +} + +inline +WORD LinkedButton::operator==(int ctlID)const +{ + return mCtlID==ctlID; +} + +inline +HINSTANCE LinkedButton::instance(void)const +{ + return mhInstance; +} + +inline +void LinkedButton::instance(HINSTANCE hInstance) +{ + mhInstance=hInstance; +} + +inline +void LinkedButton::setBitmapDefault(void) +{ + if(Focus==mFocus)mlpBitmapDefault=&mBitmapFocusUp; + else mlpBitmapDefault=&mBitmapNoFocusUp; +} +#endif + diff --git a/common/CALLBACK.TPP b/common/CALLBACK.TPP new file mode 100644 index 0000000..c977a78 --- /dev/null +++ b/common/CALLBACK.TPP @@ -0,0 +1,76 @@ +#ifndef _COMMON_CALLBACK_TPP_ +#define _COMMON_CALLBACK_TPP_ + +template +Callback::Callback(void) +: mlpObject(0), mlpMethod(0) +{ +} + +template +Callback::Callback(const Callback &someCallback) +: mlpObject(someCallback.mlpObject), mlpMethod(someCallback.mlpMethod) +{ +} + + +template +Callback::Callback(T *lpObject,PFNMETHOD lpMethod) +: mlpObject(lpObject), mlpMethod(lpMethod) +{ +} + +template +Callback::~Callback() +{ +} + +template +WORD Callback::operator==(const Callback &someCallback)const +{ + return (mlpObject==someCallback.mlpObject && mlpMethod==someCallback.mlpMethod); +} + +template +void Callback::operator=(const Callback &someCallback) +{ + mlpObject=someCallback.mlpObject; + mlpMethod=someCallback.mlpMethod; +} + +template +void Callback::setObject(T *lpObject) +{ + mlpObject=lpObject; +} + +template +void Callback::setMethod(PFNMETHOD lpMethod) +{ + mlpMethod=lpMethod; +} + + +//template +//void Callback::setMethod(CallbackData::ReturnType (T::*lpMethod)(CallbackData &someCallbackData)) +//{ +// mlpMethod=lpMethod; +//} + +template +void Callback::setCallback(T *lpObject,PFNMETHOD lpMethod) +{ + mlpObject=lpObject; + mlpMethod=lpMethod; +} + +//template +//void Callback::setCallback(T *lpObject,LONG (T::*lpMethod)(CallbackData &someCallbackData)) +//{ +// mlpObject=lpObject; +// mlpMethod=lpMethod; +//} + + + +#endif diff --git a/common/CATMULL.CPP b/common/CATMULL.CPP new file mode 100644 index 0000000..a5fc1db --- /dev/null +++ b/common/CATMULL.CPP @@ -0,0 +1,66 @@ +// SOURCE: CATMULL-ROM CUBIC SPLINE +// AUTHOR: SEAN M. KESSLER +// DATE: 12/28/1993 +#include + +WORD CatmullRom::performSpline(Array &sourcePairs,Array &destPairs) +{ + double a0,a1,a2,a3; + double dx,dx1,dx2; + double dy,dy1,dy2; + double endPointOne,endPointTwo,resamplingPos; + double xPoint; + short clampOne,clampTwo; + short direction; + short destSize((short)destPairs.size()); + short sourceSize((short)sourcePairs.size()); + short inputIndex,index; + + if(sourceSize<2||destSize<2)return FALSE; + if(sourcePairs[0].column()sourcePairs[sourceSize-1].column()) + direction=0; + else direction=1; + } + else + { + if(destPairs[0].column()>sourcePairs[0].column()|| + destPairs[destSize-1].column()endPointTwo)|| + (-1==direction&&resamplingPossourcePairs[inputIndex].column();inputIndex++); + if(resamplingPos +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif + +class FloatPairs +{ +public: + FloatPairs(void); + FloatPairs(const FloatPairs &someFloatPairs); + FloatPairs(double column,double row); + virtual ~FloatPairs(); + FloatPairs &operator=(const FloatPairs &someFloatPairs); + WORD operator==(const FloatPairs &someFloatPair)const; + double column(void)const; + void column(double newColumn); + double row(void)const; + void row(double newRow); + void setPairs(double newColumn,double newRow); + void setPairs(int newColumn,int newRow); + static int fpmax(int firstVal,int secondVal); + static int fpmin(int firstVal,int secondVal); +private: + double mColumn; + double mRow; +}; + +inline +FloatPairs::FloatPairs(void) +: mColumn(0.00), mRow(0.00) +{ +} + +inline +FloatPairs::FloatPairs(const FloatPairs &someFloatPairs) +{ + *this=someFloatPairs; +} + +inline +FloatPairs::FloatPairs(double column,double row) +: mColumn(column), mRow(row) +{ +} + +inline +FloatPairs::~FloatPairs() +{ +} + +inline +WORD FloatPairs::operator==(const FloatPairs &someFloatPair)const +{ + return (mColumn==someFloatPair.mColumn && mRow==someFloatPair.mRow); +} + +inline +FloatPairs &FloatPairs::operator=(const FloatPairs &someFloatPairs) +{ + column(someFloatPairs.column()); + row(someFloatPairs.row()); + return *this; +} + +inline +double FloatPairs::column(void)const +{ + return mColumn; +} + +inline +void FloatPairs::column(double newColumn) +{ + mColumn=newColumn; +} + +inline +double FloatPairs::row(void)const +{ + return mRow; +} + +inline +void FloatPairs::row(double newRow) +{ + mRow=newRow; +} + +inline +void FloatPairs::setPairs(double newColumn,double newRow) +{ + mColumn=newColumn; + mRow=newRow; +} + +inline +void FloatPairs::setPairs(int newColumn,int newRow) +{ + mColumn=(double)newColumn; + mRow=(double)newRow; +} + +inline +int FloatPairs::fpmax(int firstVal,int secondVal) +{ + return (firstVal>secondVal?firstVal:secondVal); +} + +inline +int FloatPairs::fpmin(int firstVal,int secondVal) +{ + return (firstVal srcPairs; +// Array dstPairs; +// srcPairs[0]=FloatPairs(1.00,25); +// srcPairs[1]=FloatPairs(4.00,50); +// dstPairs[0]=FloatPairs(1.00,0.00); +// dstPairs[1]=FloatPairs(2.00,0.00); +// dstPairs[2]=FloatPairs(3.00,0.00); +// dstPairs[3]=FloatPairs(4.00,0.00); +// splineGen.performSpline(srcPairs,dstPairs); +// ... dstPairs contains interpolation of 25-50 across four points + +class CatmullRom +{ +public: + CatmullRom(void); + virtual ~CatmullRom(); + WORD performSpline(Array &sourcePoints,Array &destPoints); +private: + CatmullRom(const CatmullRom &someCatmullRom); + CatmullRom &operator=(const CatmullRom &someCatmullRom); +}; + +inline +CatmullRom::CatmullRom(void) +{ +} + +inline +CatmullRom::CatmullRom(const CatmullRom &someCatmullRom) +{ // no implementation + *this=someCatmullRom; +} + +inline +CatmullRom::~CatmullRom() +{ +} + +inline +CatmullRom &CatmullRom::operator=(const CatmullRom &/*someCatmullRom*/) +{ // no implementation + return *this; +} +#endif diff --git a/common/CBDATA.CPP b/common/CBDATA.CPP new file mode 100644 index 0000000..e28dd4c --- /dev/null +++ b/common/CBDATA.CPP @@ -0,0 +1,19 @@ +#include +#include + +PaintInformation::PaintInformation(const PureDevice &paintDevice) +: mlpPaintDevice(new PureDevice((HDC)paintDevice)) +{ +} + +PaintInformation::~PaintInformation() +{ + if(mlpPaintDevice)delete mlpPaintDevice; +} + +PaintInformation::operator PureDevice&(void)const +{ + return *mlpPaintDevice; +} + + \ No newline at end of file diff --git a/common/CBDATAHK.CPP b/common/CBDATAHK.CPP new file mode 100644 index 0000000..fa9fb3a --- /dev/null +++ b/common/CBDATAHK.CPP @@ -0,0 +1,42 @@ +#include + +CallbackDataHook::CallbackDataHook(void) +: mHookReturnCode((CallbackData::ReturnType)FALSE) +{ +} + +CallbackDataHook::CallbackDataHook(const CallbackDataHook &someCallbackDataHook) +{ + *this=someCallbackDataHook; +} + +CallbackDataHook::CallbackDataHook(const CallbackData &someCallbackData) +: mHookReturnCode((CallbackData::ReturnType)FALSE), CallbackData(someCallbackData) +{ +} + +CallbackDataHook::CallbackDataHook(WPARAM wParam,LPARAM lParam,HWND hWndFrom) +: mHookReturnCode((CallbackData::ReturnType)FALSE), CallbackData(wParam,lParam,hWndFrom) +{ +} + +CallbackDataHook::~CallbackDataHook() +{ +} + +CallbackDataHook &CallbackDataHook::operator=(const CallbackDataHook &someCallbackDataHook) +{ + (CallbackData&)*this=(CallbackData&)someCallbackDataHook; + hookReturnCode(someCallbackDataHook.hookReturnCode()); + return *this; +} + +CallbackData::ReturnType CallbackDataHook::hookReturnCode(void)const +{ + return mHookReturnCode; +} + +void CallbackDataHook::hookReturnCode(CallbackData::ReturnType hookReturnCode) +{ + mHookReturnCode=hookReturnCode; +} diff --git a/common/CBDATAHK.HPP b/common/CBDATAHK.HPP new file mode 100644 index 0000000..3a34ad8 --- /dev/null +++ b/common/CBDATAHK.HPP @@ -0,0 +1,21 @@ +#ifndef _COMMON_CALLBACKDATAHOOK_HPP_ +#define _COMMON_CALLBACKDATAHOOK_HPP_ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#include +#endif + +class CallbackDataHook : public CallbackData +{ +public: + CallbackDataHook(void); + CallbackDataHook(const CallbackDataHook &someCallbackDataHook); + CallbackDataHook(const CallbackData &someCallbackData); + CallbackDataHook(WPARAM wParam,LPARAM lParam,HWND hWndFrom=0); + virtual ~CallbackDataHook(); + CallbackDataHook &operator=(const CallbackDataHook &someCallbackDataHook); + CallbackData::ReturnType hookReturnCode(void)const; + void hookReturnCode(CallbackData::ReturnType hookReturnCode); +private: + CallbackData::ReturnType mHookReturnCode; +}; +#endif diff --git a/common/CBPTR.HPP b/common/CBPTR.HPP new file mode 100644 index 0000000..7cae45d --- /dev/null +++ b/common/CBPTR.HPP @@ -0,0 +1,72 @@ +#ifndef _COMMON_CALLBACKPOINTER_HPP_ +#define _COMMON_CALLBACKPOINTER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PURECALLBACK_HPP_ +#include +#endif + +class CallbackPointer +{ +public: + CallbackPointer(void); + CallbackPointer(PureCallback *lpCallback); + CallbackPointer(const CallbackPointer &someCallbackPointer); + virtual ~CallbackPointer(); + void operator=(CallbackPointer &someCallbackPointer); + WORD operator==(const CallbackPointer &someCallbackPointer)const; + CallbackData::ReturnType callback(CallbackData &someCallbackData); + bool isOkay(void)const; +private: + PureCallback *mlpCallback; +}; + +inline +CallbackPointer::CallbackPointer(void) +: mlpCallback(0) +{ +} + +inline +CallbackPointer::CallbackPointer(PureCallback *lpCallback) +: mlpCallback(lpCallback) +{ +} + +inline +CallbackPointer::CallbackPointer(const CallbackPointer &someCallbackPointer) +: mlpCallback(someCallbackPointer.mlpCallback) +{ +} + +inline +CallbackPointer::~CallbackPointer() +{ +} + +inline +void CallbackPointer::operator=(CallbackPointer &someCallbackPointer) +{ + mlpCallback=someCallbackPointer.mlpCallback; +} + +inline +WORD CallbackPointer::operator==(const CallbackPointer &someCallbackPointer)const +{ + return (mlpCallback==someCallbackPointer.mlpCallback); +} + +inline +CallbackData::ReturnType CallbackPointer::callback(CallbackData &someCallbackData) +{ + if(!mlpCallback)return (CallbackData::ReturnType)0; + return mlpCallback->operator*(someCallbackData); +} + +inline +bool CallbackPointer::isOkay(void)const +{ + return mlpCallback?true:false; +} +#endif \ No newline at end of file diff --git a/common/CFLAGS.HPP b/common/CFLAGS.HPP new file mode 100644 index 0000000..7e69a79 --- /dev/null +++ b/common/CFLAGS.HPP @@ -0,0 +1,79 @@ +#if defined(__FLAT__) +#ifndef _COMMON_CREATIONFLAGS_HPP_ +#define _COMMON_CREATIONFLAGS_HPP_ +class CreationFlags +{ +public: + enum Flags{DefaultErrorMode=CREATE_DEFAULT_ERROR_MODE, + NewConsole=CREATE_NEW_CONSOLE, + NewProcessGroup=CREATE_NEW_PROCESS_GROUP, + SeperateWOWVDM=CREATE_SEPARATE_WOW_VDM, + Suspended=CREATE_SUSPENDED, + UnicodeEnvironment=CREATE_UNICODE_ENVIRONMENT, + DebugProcess=DEBUG_PROCESS, + DebugOnlyThisProcess=DEBUG_ONLY_THIS_PROCESS, + DetachedProcess=DETACHED_PROCESS, + NormalPriorityClass=NORMAL_PRIORITY_CLASS, + IdlePriorityClass=IDLE_PRIORITY_CLASS, + HighPriorityClass=HIGH_PRIORITY_CLASS, + RealtimePriorityClass=REALTIME_PRIORITY_CLASS}; + CreationFlags(Flags creationFlags=NormalPriorityClass); + CreationFlags(const CreationFlags &someCreationFlags); + virtual ~CreationFlags(); + CreationFlags &operator=(const CreationFlags &someCreationFlags); + WORD operator==(const CreationFlags &someCreationFlags); + CreationFlags &operator+=(Flags creationFlags); + operator DWORD(void)const; +private: + DWORD mCreationFlags; +}; + +inline +CreationFlags::CreationFlags(Flags creationFlags) +: mCreationFlags(creationFlags) +{ +} + +inline +CreationFlags::CreationFlags(const CreationFlags &someCreationFlags) +{ + *this=someCreationFlags; +} + +inline +CreationFlags::~CreationFlags() +{ +} + +inline +CreationFlags &CreationFlags::operator=(const CreationFlags &someCreationFlags) +{ + mCreationFlags=someCreationFlags.mCreationFlags; + return *this; +} + +inline +WORD CreationFlags::operator==(const CreationFlags &someCreationFlags) +{ + return mCreationFlags==someCreationFlags.mCreationFlags; +} + +inline +CreationFlags &CreationFlags::operator+=(Flags creationFlags) +{ + mCreationFlags|=(DWORD)creationFlags; + return *this; +} + +inline +CreationFlags::operator DWORD(void)const +{ + return mCreationFlags; +} +#endif +#endif + + + + + diff --git a/common/CHARFORM.HPP b/common/CHARFORM.HPP new file mode 100644 index 0000000..6d59aa1 --- /dev/null +++ b/common/CHARFORM.HPP @@ -0,0 +1,220 @@ +#ifndef _COMMON_CHARFORMAT_HPP_ +#define _COMMON_CHARFORMAT_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_RICHEDIT_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif + +class CharFormat : private CHARFORMAT +{ +public: + enum Mask{MaskBold=CFM_BOLD,MaskCharSet=CFM_CHARSET,MaskColor=CFM_COLOR,MaskFace=CFM_FACE, + MaskItalic=CFM_ITALIC,MaskOffset=CFM_OFFSET,MaskProtected=CFM_PROTECTED, + MaskSize=CFM_SIZE,MaskStrikeout=CFM_STRIKEOUT,MaskUnderline=CFM_UNDERLINE}; + enum Effects{EffectAutoColor=CFE_AUTOCOLOR,EffectBold=CFE_BOLD,EffectItalic=CFE_ITALIC, + EffectStrikeout=CFE_STRIKEOUT,EffectUnderline=CFE_UNDERLINE,EffectProtected=CFE_PROTECTED}; + CharFormat(void); + CharFormat(const CharFormat &someCharFormat); + virtual ~CharFormat(); + CharFormat &operator=(const CharFormat &someCharFormat); + BOOL operator==(const CharFormat &someCharFormat)const; + operator CHARFORMAT &(void); + DWORD mask(void)const; + void mask(DWORD mask); + DWORD effects(void)const; + void effects(DWORD effects); + LONG yHeight(void)const; + void yHeight(LONG height); + LONG yOffset(void)const; + void yOffset(LONG offset); + RGBColor textColor(void)const; + void textColor(RGBColor textColor); + BYTE charSet(void)const; + void charSet(BYTE charSet); + BYTE pitchAndFamily(void)const; + void pitchAndFamily(BYTE pitchAndFamily); + String faceName(void)const; + void faceName(const String &faceName); +private: + void setZero(void); + void initLength(void); +}; +#endif + +inline +CharFormat::CharFormat(void) +{ + setZero(); +} + +inline +CharFormat::CharFormat(const CharFormat &someCharFormat) +{ + initLength(); + *this=someCharFormat; +} + +inline +CharFormat::~CharFormat() +{ +} + +inline +CharFormat &CharFormat::operator=(const CharFormat &someCharFormat) +{ + mask(someCharFormat.mask()); + effects(someCharFormat.effects()); + yHeight(someCharFormat.yHeight()); + yOffset(someCharFormat.yOffset()); + textColor(someCharFormat.textColor()); + charSet(someCharFormat.charSet()); + pitchAndFamily(someCharFormat.pitchAndFamily()); + faceName(someCharFormat.faceName()); + return *this; +} + +inline +BOOL CharFormat::operator==(const CharFormat &someCharFormat)const +{ + return (mask()==someCharFormat.mask()&& + effects()==someCharFormat.effects()&& + yHeight()==someCharFormat.yHeight()&& + yOffset()==someCharFormat.yOffset()&& + textColor()==someCharFormat.textColor()&& + charSet()==someCharFormat.charSet()&& + pitchAndFamily()&&someCharFormat.pitchAndFamily()&& + faceName()==someCharFormat.faceName()); +} + +inline +CharFormat::operator CHARFORMAT &(void) +{ + return *this; +} + +inline +DWORD CharFormat::mask(void)const +{ + return CHARFORMAT::dwMask; +} + +inline +void CharFormat::mask(DWORD mask) +{ + CHARFORMAT::dwMask=mask; +} + +inline +DWORD CharFormat::effects(void)const +{ + return CHARFORMAT::dwEffects; +} + +inline +void CharFormat::effects(DWORD effects) +{ + CHARFORMAT::dwEffects=effects; +} + +inline +LONG CharFormat::yHeight(void)const +{ + return CHARFORMAT::yHeight; +} + +inline +void CharFormat::yHeight(LONG height) +{ + CHARFORMAT::yHeight=height; +} + +inline +LONG CharFormat::yOffset(void)const +{ + return CHARFORMAT::yOffset; +} + +inline +void CharFormat::yOffset(LONG yOffset) +{ + CHARFORMAT::yOffset=yOffset; +} + +inline +RGBColor CharFormat::textColor(void)const +{ + return CHARFORMAT::crTextColor; +} + +inline +void CharFormat::textColor(RGBColor textColor) +{ + CHARFORMAT::crTextColor=(COLORREF)textColor; +} + +inline +BYTE CharFormat::charSet(void)const +{ + return CHARFORMAT::bCharSet; +} + +inline +void CharFormat::charSet(BYTE charSet) +{ + CHARFORMAT::bCharSet=charSet; +} + +inline +BYTE CharFormat::pitchAndFamily(void)const +{ + return CHARFORMAT::bPitchAndFamily; +} + +inline +void CharFormat::pitchAndFamily(BYTE pitchAndFamily) +{ + CHARFORMAT::bPitchAndFamily=pitchAndFamily; +} + +inline +String CharFormat::faceName(void)const +{ + return CHARFORMAT::szFaceName; +} + +inline +void CharFormat::faceName(const String &faceName) +{ + WORD strLength(faceName.length()); + if(faceName.isNull()||strLength>=LF_FACESIZE)return; + ::memcpy(szFaceName,(char*)(String&)faceName,strLength); + szFaceName[strLength]=0; +} + +inline +void CharFormat::setZero(void) +{ + initLength(); + mask(0); + effects(0); + yHeight(0); + yOffset(0); + textColor(RGBColor(0,0,0)); + charSet(0); + pitchAndFamily(0); + faceName("Arial"); +} + +inline +void CharFormat::initLength(void) +{ + CHARFORMAT::cbSize=sizeof(CHARFORMAT); +} diff --git a/common/CHRRANGE.HPP b/common/CHRRANGE.HPP new file mode 100644 index 0000000..814e8f0 --- /dev/null +++ b/common/CHRRANGE.HPP @@ -0,0 +1,85 @@ +#ifndef _COMMON_CHARRANGE_HPP_ +#define _COMMON_CHARRANGE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class CharRange : private CHARRANGE +{ +public: + CharRange(void); + CharRange(const CharRange &someCharRange); + virtual ~CharRange(); + CharRange &operator=(const CharRange &someCharRange); + BOOL operator==(const CharRange &someCharRange)const; + LONG cpMin(void)const; + void cpMin(LONG cpMin); + LONG cpMax(void)const; + void cpMax(LONG cpMax); + CHARRANGE &getCHARRANGE(void); +private: +}; + +inline +CharRange::CharRange(void) +{ + cpMin(0); + cpMax(0); +} + +inline +CharRange::CharRange(const CharRange &someCharRange) +{ + *this=someCharRange; +} + +inline +CharRange::~CharRange() +{ +} + +inline +CharRange &CharRange::operator=(const CharRange &someCharRange) +{ + cpMin(someCharRange.cpMin()); + cpMax(someCharRange.cpMax()); + return *this; +} + +inline +BOOL CharRange::operator==(const CharRange &someCharRange)const +{ + return (cpMin()==someCharRange.cpMin()&& + cpMax()==someCharRange.cpMax()); +} + +inline +LONG CharRange::cpMin(void)const +{ + return CHARRANGE::cpMin; +} + +inline +void CharRange::cpMin(LONG cpMin) +{ + CHARRANGE::cpMin=cpMin; +} + +inline +LONG CharRange::cpMax(void)const +{ + return CHARRANGE::cpMax; +} + +inline +void CharRange::cpMax(LONG cpMax) +{ + CHARRANGE::cpMax=cpMax;; +} + +inline +CHARRANGE &CharRange::getCHARRANGE(void) +{ + return *this; +} +#endif \ No newline at end of file diff --git a/common/CLIPBRD.CPP b/common/CLIPBRD.CPP new file mode 100644 index 0000000..9cec979 --- /dev/null +++ b/common/CLIPBRD.CPP @@ -0,0 +1,156 @@ +#include +#include + +Clipboard::Clipboard(GUIWindow &parentWindow) +: mParentWindow(parentWindow), mhNextViewerWnd(0) +{ + if(!parentWindow.isValid())return; + mChangeCBChainHandler.setCallback(this,&Clipboard::changeCBChainHandler); + mDrawClipboardHandler.setCallback(this,&Clipboard::drawClipboardHandler); + mDestroyHandler.setCallback(this,&Clipboard::destroyHandler); + mParentWindow.insertHandler(VectorHandler::ChangeCBChainHandler,&mChangeCBChainHandler); + mParentWindow.insertHandler(VectorHandler::DrawClipboardHandler,&mDrawClipboardHandler); + mParentWindow.insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler); + mhNextViewerWnd=::SetClipboardViewer(mParentWindow); +} + +Clipboard::~Clipboard() +{ + removeCBChain(); + mParentWindow.removeHandler(VectorHandler::DrawClipboardHandler,&mDrawClipboardHandler); + mParentWindow.removeHandler(VectorHandler::ChangeCBChainHandler,&mChangeCBChainHandler); + mParentWindow.removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler); +} + +void Clipboard::setDrawDataHandler(PureCallback *pCallback) +{ + mDrawDataHandler=CallbackPointer(pCallback); +} + +bool Clipboard::isOkay(void)const +{ + return mParentWindow.isValid(); +} + +CallbackData::ReturnType Clipboard::destroyHandler(CallbackData &someCallbackData) +{ + removeCBChain(); + return (CallbackData::ReturnType)false; +} + +CallbackData::ReturnType Clipboard::changeCBChainHandler(CallbackData &someCallbackData) +{ + if(!isOkay())return (CallbackData::ReturnType)false; + if((HWND)someCallbackData.wParam()==mhNextViewerWnd)mhNextViewerWnd=(HWND)someCallbackData.loWord(); + else ::SendMessage(mhNextViewerWnd,WM_CHANGECBCHAIN,someCallbackData.wParam(),someCallbackData.lParam()); + return (CallbackData::ReturnType)false; +} + +CallbackData::ReturnType Clipboard::drawClipboardHandler(CallbackData &someCallbackData) +{ + if(!isOkay())return (CallbackData::ReturnType)false; + ::SendMessage(mhNextViewerWnd,WM_DRAWCLIPBOARD,someCallbackData.wParam(),someCallbackData.lParam()); + if(::OpenClipboard(mParentWindow)){drawClipboard();::CloseClipboard();} + return (CallbackData::ReturnType)false; +} + +void Clipboard::removeCBChain(void) +{ + if(!isOkay())return; + ::ChangeClipboardChain(mParentWindow,mhNextViewerWnd); +} + +bool Clipboard::setClipboard(Format format,HANDLE hData) +{ + bool returnCode(false); + + if(!isOkay()||!hData)return returnCode; + if(!::OpenClipboard(mParentWindow))return returnCode; + emptyClipboard(); + returnCode=(hData==::SetClipboardData(format,hData)); + ::CloseClipboard(); + return returnCode; +} + +bool Clipboard::setClipboard(const String &strText) +{ + bool returnCode(false); + + if(!isOkay()||strText.isNull()||!::OpenClipboard(mParentWindow))return returnCode; + emptyClipboard(); + int strLen(strText.length()); + char *ptrData=(char*)::GlobalAlloc(GMEM_FIXED,strLen+1); + if(!ptrData){::CloseClipboard();return returnCode;} + ::memset(ptrData,0,strLen+1); + ::memcpy(ptrData,(char*)(String&)strText,strLen); + returnCode=ptrData==::SetClipboardData(CF_TEXT,(HANDLE)ptrData); + ::CloseClipboard(); + return true; +} + +bool Clipboard::setClipboard(UINT format,const String &strText) +{ + bool returnCode(false); + + if(!isOkay()||strText.isNull()||!::OpenClipboard(mParentWindow))return returnCode; + emptyClipboard(); + int strLen(strText.length()); + char *ptrData=(char*)::GlobalAlloc(GMEM_FIXED,strLen+1); + if(!ptrData){::CloseClipboard();return returnCode;} + ::memset(ptrData,0,strLen+1); + ::memcpy(ptrData,(char*)(String&)strText,strLen); + returnCode=ptrData==::SetClipboardData(format,(HANDLE)ptrData); + ::CloseClipboard(); + return true; +} + +bool Clipboard::getClipboard(String &strText)const +{ + bool returnCode(false); + HANDLE handle=0; + + if(!isOkay()||!::OpenClipboard(mParentWindow))return returnCode; + if(0==(handle=::GetClipboardData(CF_TEXT))){::CloseClipboard();return false;} + strText=(LPSTR)::GlobalLock(handle); + ::GlobalUnlock(handle); + ::CloseClipboard(); + return true; +} + +bool Clipboard::getClipboard(UINT format,String &strText)const +{ + bool returnCode(false); + HANDLE handle=0; + + if(!isOkay()||!::OpenClipboard(mParentWindow))return returnCode; + if(0==(handle=::GetClipboardData(format))){::CloseClipboard();return false;} + strText=(LPSTR)::GlobalLock(handle); + ::GlobalUnlock(handle); + ::CloseClipboard(); + return true; +} + +UINT Clipboard::registerClipboardFormat(const String &strFormatName) +{ + return ::RegisterClipboardFormat(strFormatName.str()); +} + +bool Clipboard::hasData(Format format) +{ + return ::IsClipboardFormatAvailable(format); +} + +bool Clipboard::hasData(UINT format) +{ + return ::IsClipboardFormatAvailable(format); +} + +// virtuals + +void Clipboard::drawClipboard(void) +{ + mDrawDataHandler.callback(CallbackData()); +} + +// (ie) HANDLE hData=::GetClipboardData(CF_DIB); + diff --git a/common/CLIPBRD.HPP b/common/CLIPBRD.HPP new file mode 100644 index 0000000..5271d87 --- /dev/null +++ b/common/CLIPBRD.HPP @@ -0,0 +1,52 @@ +#ifndef _COMMON_CLIPBOARD_HPP_ +#define _COMMON_CLIPBOARD_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_GUIWINDOW_HPP_ +#include +#endif + +class Clipboard +{ +public: + typedef enum Format{Bitmap=CF_BITMAP,Dib=CF_DIB,EnhMetaFile=CF_ENHMETAFILE,MetFilePict=CF_METAFILEPICT, + OemText=CF_OEMTEXT,Text=CF_TEXT,UnicodeText=CF_UNICODETEXT}; + Clipboard(GUIWindow &parentWindow); + virtual ~Clipboard(); + bool isOkay(void)const; + bool emptyClipboard(void)const; + bool setClipboard(Format format,HANDLE hData); + bool setClipboard(const String &strText); + bool setClipboard(UINT format,const String &strText); + void setDrawDataHandler(PureCallback *pCallback); + bool getClipboard(String &strText)const; + bool getClipboard(UINT format,String &strText)const; + static UINT registerClipboardFormat(const String &strFormatName); + static bool hasData(Format format); + static bool hasData(UINT format); +protected: + virtual void drawClipboard(void); +private: + CallbackData::ReturnType changeCBChainHandler(CallbackData &someCallbackData); + CallbackData::ReturnType drawClipboardHandler(CallbackData &someCallbackData); + CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData); + void removeCBChain(void); + + Callback mChangeCBChainHandler; + Callback mDrawClipboardHandler; + Callback mDestroyHandler; + + CallbackPointer mDrawDataHandler; + GUIWindow &mParentWindow; + HWND mhNextViewerWnd; +}; + +inline +bool Clipboard::emptyClipboard(void)const +{ + return ::EmptyClipboard(); +} +#endif // macro guards + + diff --git a/common/CODEGEN.HPP b/common/CODEGEN.HPP new file mode 100644 index 0000000..a285af6 --- /dev/null +++ b/common/CODEGEN.HPP @@ -0,0 +1,918 @@ +#ifndef _COMMON_CODEGEN_HPP_ +#define _COMMON_CODEGEN_HPP_ +#include +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_FILEMAP_HPP_ +#include +#endif +#ifndef _COMMON_PUREVIEWOFFILE_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif + +#if defined(_MSC_VER) +#pragma warning(disable:4355) +#endif + +class CodeGen : public FileMap, public PureViewOfFile +{ +public: + CodeGen(DWORD maxExtent=100000L); + virtual ~CodeGen(); + void breakPoint(void); + void nop(void); + void pushDS(void); + void popDS(void); + void pushCS(void); + void movEAXOFFSETDS(int dsOffset); + void movOFFSETDSEAX(int dsOffset); + void pushad(void); + void popad(void); + void pushOFFSETCS(int csOffset); + void pushEAX(void); + void pushECX(void); + void pushEBP(void); + void pushESP(void); + void pushEDI(void); + void pushESI(void); + void push(int value); + void popEBP(void); + void popESP(void); + void popESI(void); + void popEDI(void); + void popAX(void); + void popEAX(void); + void popEBX(void); + void popECX(void); + void pushEBX(void); + void subEDI(BYTE byteCount); + void subESP(BYTE byteCount); + void movDHDL(void); + void movEDIDX(void); + void movAXCS(void); + void movEAXEBX(void); + void movEBXEAX(void); + void movEBPESP(void); + void movECXESI(void); + void movECXEDI(void); + void movESIEBP(BYTE stackIndex); + void movEDIEBP(BYTE stackIndex); + void movEAXEBP(BYTE stackIndex); + void movEAXESP(BYTE stackIndex); + void movEAXEBP(void); + void movEAXESP(void); + void movAXEBP(BYTE stackIndex); + void movBXEBP(BYTE stackIndex); + void movCXEBP(BYTE stackIndex); + void movDXEBP(BYTE stackIndex); + void movALESI(LONG sourceIndex); + void movESIAL(LONG sourceIndex); + void movDLESI(DWORD sourceIndex); + void movEDIDX(LONG offset); + void movEDIDL(LONG offset); + void movEDIAL(LONG offset); + void movEDIDL(void); + void movCLEBP(BYTE stackIndex); + void movOFFSETESI(BYTE offset,BYTE charByte); + void movEAXOFFSETCS(int csOffset); + void movECXOFFSETCS(int csOffset); + void movEAXOFFSETSS(int offset); + void movOFFSETSSEAX(int offset); + void movEAXESPOFFSET(int offset); + void movEAXEBPOFFSET(int offset); + void movESPOFFSETEAX(int offset); + void movESPOFFSETEBX(int offset); + void movDEREFEAXEBX(void); + void leaESIEBP(BYTE offset); + void addEDIEAX(void); + void addEDIEBP(BYTE stackIndex); + void addESP(int value); + void addEAX(int value); + void addEBP(int value); + void subEAX(int value); + void xorEAXEAX(void); + void call(int offset); + void callEBP(BYTE offset); + void callEAX(void); + void callEBX(void); + void callECX(void); + void je(BYTE jumpCount); + void jmp(BYTE jumpBytes); + void jnl(BYTE jumpCount); + void cmpALCL(void); + void decEDI(void); + void movEAX(int value); + void movECX(int value); + void pushEBPEAXPLUS(int eaxAdditive); + void decEAX(void); + void cmpEAX(int value); + void pushFSOFFSET(WORD offset); + void movFSOFFSETESP(WORD offset); + void movFSOFFSETEAX(int offset); + void retn(void); + void retn(short stackLength); + void retf(void); + void intno(BYTE intno); + void encodeDD(int value=0); + void encodeDB(BYTE value=0); + void wait(void); + void finit(void); + void execute(void); + void debugExecute(void); +private: + String entryName(void)const; +}; + +inline +CodeGen::CodeGen(DWORD maxExtent) +: FileMap(entryName(),0L,1024), PureViewOfFile((FileMap&)*this) +{ +} + +inline +CodeGen::~CodeGen() +{ +} + +inline +void CodeGen::breakPoint(void) +{ + write((BYTE)(0xCC)); +} + +inline +void CodeGen::pushOFFSETCS(int csOffset) +{ + write((BYTE)(0x2E)); + write((BYTE)(0xFF)); + write((BYTE)(0x35)); + write(csOffset); +} + +inline +void CodeGen::pushad(void) +{ + write((BYTE)(0x60)); +} + +inline +void CodeGen::popad(void) +{ + write((BYTE)(0x61)); +} + +inline +void CodeGen::pushEAX(void) +{ + write((BYTE)(0x50)); +} + +inline +void CodeGen::pushECX(void) +{ + write((BYTE)(0x51)); +} + +inline +void CodeGen::popECX(void) +{ + write((BYTE)(0x59)); +} + +inline +void CodeGen::pushEBP(void) +{ + write((BYTE)(0x55)); +} + +inline +void CodeGen::pushESP(void) +{ + write((BYTE)(0x54)); +} + +inline +void CodeGen::pushEDI(void) +{ + write((BYTE)(0x57)); +} + +inline +void CodeGen::pushESI(void) +{ + write((BYTE)(0x56)); +} + +inline +void CodeGen::popEBP(void) +{ + write((BYTE)(0x5D)); +} + +inline +void CodeGen::popESP(void) +{ + write((BYTE)(0x5C)); +} + +inline +void CodeGen::popESI(void) +{ + write((BYTE)(0x5E)); +} + +inline +void CodeGen::popEDI(void) +{ + write((BYTE)(0x5F)); +} + +inline +void CodeGen::popAX(void) +{ + write((BYTE)(0x66)); + write((BYTE)(0x58)); +} + +inline +void CodeGen::movEBPESP(void) +{ + write((BYTE)(0x8B)); + write((BYTE)(0xEC)); +} + +inline +void CodeGen::movESIEBP(BYTE stackIndex) +{ + write((BYTE)(0x8B)); + write((BYTE)(0x75)); + write(stackIndex); +} + +inline +void CodeGen::movEDIEBP(BYTE stackIndex) +{ + write((BYTE)(0x8B)); + write((BYTE)(0x7D)); + write(stackIndex); +} + +inline +void CodeGen::movEAXEBP(BYTE stackIndex) +{ + write((BYTE)(0x8B)); + write((BYTE)(0x45)); + write(stackIndex); +} + +inline +void CodeGen::movEAXESP(BYTE stackIndex) +{ + write((BYTE)(0x8B)); + write((BYTE)(0x44)); + write((BYTE)(0x24)); + write(stackIndex); +} + +inline +void CodeGen::movEAXEBP(void) +{ + write((BYTE)(0x8B)); + write((BYTE)(0xC5)); +} + +inline +void CodeGen::movEDIDL(void) +{ + write((BYTE)(0x88)); + write((BYTE)(0x17)); +} + +inline +void CodeGen::decEDI(void) +{ + write((BYTE)(0x4F)); +} + +inline +void CodeGen::addEDIEAX(void) +{ + write((BYTE)(0x03)); + write((BYTE)(0xF8)); +} + +inline +void CodeGen::addEDIEBP(BYTE stackIndex) +{ + write((BYTE)(0x03)); + write((BYTE)(0x7D)); + write(stackIndex); +} + +inline +void CodeGen::retn(void) +{ + write((BYTE)(0xC3)); +} + +inline +void CodeGen::retn(short stackLength) +{ + write((BYTE)(0xC2)); + write(stackLength); +} + +inline +void CodeGen::retf(void) +{ + write((BYTE)(0xCB)); +} + +inline +void CodeGen::movDLESI(DWORD sourceIndex) +{ + write((BYTE)(0x8A)); + write((BYTE)(0x96)); + write((BYTE)(sourceIndex&0x000000FF)); + write((BYTE)((sourceIndex&0x0000FF00)>>0x08)); + write((BYTE)((sourceIndex&0x00FF0000)>>0x10)); + write((BYTE)((sourceIndex&0xFF000000)>>0x18)); +} + +inline +void CodeGen::movDHDL(void) +{ + write((BYTE)(0x8A)); + write((BYTE)(0xF2)); +} + +inline +void CodeGen::movOFFSETESI(BYTE offset,BYTE charByte) +{ + write((BYTE)(0xC6)); + write((BYTE)(0x46)); + write(offset); + write(charByte); +} + +inline +void CodeGen::subEDI(BYTE byteCount) +{ + write((BYTE)(0x83)); + write((BYTE)(0xEF)); + write(byteCount); +} + +inline +void CodeGen::subESP(BYTE byteCount) +{ + write((BYTE)(0x83)); + write((BYTE)(0xEC)); + write(byteCount); +} + +inline +void CodeGen::movEDIDX(void) +{ + write((BYTE)(0x66)); + write((BYTE)(0x89)); + write((BYTE)(0x17)); +} + +inline +void CodeGen::movEDIDX(LONG sourceIndex) +{ + write((BYTE)(0x66)); + write((BYTE)(0x89)); + write((BYTE)(0x97)); + write((BYTE)(sourceIndex&0x000000FF)); + write((BYTE)((sourceIndex&0x0000FF00)>>0x08)); + write((BYTE)((sourceIndex&0x00FF0000)>>0x10)); + write((BYTE)((sourceIndex&0xFF000000)>>0x18)); +} + +inline +void CodeGen::movEDIDL(LONG sourceIndex) +{ + write((BYTE)(0x88)); + write((BYTE)(0x97)); + write((BYTE)(sourceIndex&0x000000FF)); + write((BYTE)((sourceIndex&0x0000FF00)>>0x08)); + write((BYTE)((sourceIndex&0x00FF0000)>>0x10)); + write((BYTE)((sourceIndex&0xFF000000)>>0x18)); +} + +inline +void CodeGen::movALESI(LONG sourceIndex) +{ + write((BYTE)(0x8A)); + write((BYTE)(0x86)); + write((BYTE)(sourceIndex&0x000000FF)); + write((BYTE)((sourceIndex&0x0000FF00)>>0x08)); + write((BYTE)((sourceIndex&0x00FF0000)>>0x10)); + write((BYTE)((sourceIndex&0xFF000000)>>0x18)); +} + +inline +void CodeGen::movESIAL(LONG sourceIndex) +{ + write((BYTE)(0x88)); + write((BYTE)(0x86)); + write((BYTE)(sourceIndex&0x000000FF)); + write((BYTE)((sourceIndex&0x0000FF00)>>0x08)); + write((BYTE)((sourceIndex&0x00FF0000)>>0x10)); + write((BYTE)((sourceIndex&0xFF000000)>>0x18)); +} + +inline +void CodeGen::movEDIAL(LONG sourceIndex) +{ + write((BYTE)(0x88)); + write((BYTE)(0x87)); + write((BYTE)(sourceIndex&0x000000FF)); + write((BYTE)((sourceIndex&0x0000FF00)>>0x08)); + write((BYTE)((sourceIndex&0x00FF0000)>>0x10)); + write((BYTE)((sourceIndex&0xFF000000)>>0x18)); +} + +inline +void CodeGen::movAXCS(void) +{ + write((BYTE)(0x66)); + write((BYTE)(0x8C)); + write((BYTE)(0xC8)); +} + +inline +void CodeGen::movCLEBP(BYTE stackIndex) +{ + write((BYTE)(0x8A)); + write((BYTE)(0x4D)); + write(stackIndex); +} + +inline +void CodeGen::leaESIEBP(BYTE offset) +{ + write((BYTE)(0x8D)); + write((BYTE)(0x75)); + write(offset); +} + +inline +void CodeGen::cmpALCL(void) +{ + write((BYTE)(0x3A)); + write((BYTE)(0xC1)); +} + +inline +void CodeGen::call(int offset) +{ + write((BYTE)(0xE8)); + write(offset); +} + +inline +void CodeGen::callEBP(BYTE offset) +{ + write((BYTE)(0xFF)); + write((BYTE)(0x55)); + write(offset); +} + +inline +void CodeGen::callEAX(void) +{ + write((BYTE)(0xFF)); + write((BYTE)(0xD0)); +} + +inline +void CodeGen::callEBX(void) +{ + write((BYTE)(0xFF)); + write((BYTE)(0xD3)); +} + +inline +void CodeGen::callECX(void) +{ + write((BYTE)(0xFF)); + write((BYTE)(0xD1)); +} + +inline +void CodeGen::je(BYTE jumpCount) +{ + write((BYTE)(0x74)); + write(jumpCount); +} + +inline +void CodeGen::jmp(BYTE jumpCount) +{ + write((BYTE)(0xEB)); + write(jumpCount); +} + +inline +void CodeGen::jnl(BYTE jumpCount) +{ + write((BYTE)(0x7D)); + write(jumpCount); +} + +inline +void CodeGen::intno(BYTE intno) +{ + write((BYTE)(0xCD)); + write(intno); +} + +inline +void CodeGen::movAXEBP(BYTE stackIndex) +{ + write((BYTE)(0x66)); + write((BYTE)(0x8B)); + write((BYTE)(0x45)); + write(stackIndex); +} + +inline +void CodeGen::movBXEBP(BYTE stackIndex) +{ + write((BYTE)(0x66)); + write((BYTE)(0x8B)); + write((BYTE)(0x5D)); + write(stackIndex); +} + +inline +void CodeGen::movCXEBP(BYTE stackIndex) +{ + write((BYTE)(0x66)); + write((BYTE)(0x8B)); + write((BYTE)(0x4D)); + write(stackIndex); +} + +inline +void CodeGen::movDXEBP(BYTE stackIndex) +{ + write((BYTE)(0x66)); + write((BYTE)(0x8B)); + write((BYTE)(0x55)); + write(stackIndex); +} + +inline +void CodeGen::xorEAXEAX(void) +{ + write((BYTE)(0x33)); + write((BYTE)(0xC0)); +} + +inline +void CodeGen::push(int value) +{ + write((BYTE)(0x68)); + write(value); +} + +inline +void CodeGen::popEAX(void) +{ + write((BYTE)(0x58)); +} + +inline +void CodeGen::addESP(int value) +{ + write((BYTE)(0x81)); + write((BYTE)(0xC4)); + write(value); +} + +inline +void CodeGen::addEAX(int value) +{ + write((BYTE)(0x05)); + write(value); +} + +inline +void CodeGen::subEAX(int value) +{ + write((BYTE)(0x2D)); + write(value); +} + +inline +void CodeGen::encodeDD(int value) +{ + write(value); +} + +inline +void CodeGen::encodeDB(BYTE value) +{ + write(value); +} + +inline +void CodeGen::execute(void) +{ + (*((FARPROC)((BYTE*)base())))(); +} + +inline +void CodeGen::debugExecute(void) +{ + GlobalData code; + code.size(tell()+1); + ::memcpy((BYTE*)&code[0],(BYTE*)base(),tell()+1); + (*((FARPROC)((BYTE*)&code[0])))(); +} + +inline +String CodeGen::entryName(void)const +{ + String entryPointName; + ::sprintf(entryPointName,"CODE%08lx.BIN",(DWORD)this); + return entryPointName; +} + +inline +void CodeGen::movEAXOFFSETCS(int csOffset) // mov eax,cs:[csOffset] +{ + write((BYTE)(0x2E)); + write((BYTE)(0xA1)); + write(csOffset); +} + +inline +void CodeGen::movECXOFFSETCS(int csOffset) // mov ecx,cs:[csOffset] +{ + write((BYTE)(0x2E)); + write((BYTE)(0x8B)); + write((BYTE)(0x0D)); + write(csOffset); +} + +inline +void CodeGen::pushDS(void) +{ + write((BYTE)(0x1E)); +} + +inline +void CodeGen::popDS(void) +{ + write((BYTE)(0x1F)); +} + +inline +void CodeGen::pushCS(void) +{ + write((BYTE)(0x0E)); +} + +inline +void CodeGen::movEAXOFFSETDS(int dsOffset) +{ + write((BYTE)(0xA1)); + write(dsOffset); +} + +inline +void CodeGen::movOFFSETDSEAX(int dsOffset) +{ + write((BYTE)(0xA3)); + write(dsOffset); +} + +inline +void CodeGen::nop(void) +{ + write((BYTE)(0x90)); +} + +inline +void CodeGen::movEAXEBX(void) // mov eax,ebx +{ + write((BYTE)(0x8B)); + write((BYTE)(0xC3)); +} + +inline +void CodeGen::movEBXEAX(void) // mov ebx,eax +{ + write((BYTE)(0x8B)); + write((BYTE)(0xD8)); +} + +inline +void CodeGen::popEBX(void) +{ + write((BYTE)(0x5B)); +} + +inline +void CodeGen::pushEBX(void) +{ + write((BYTE)(0x53)); +} + +inline +void CodeGen::movEAX(int value) +{ + write((BYTE)(0xB8)); + write(value); +} + +inline +void CodeGen::pushEBPEAXPLUS(int eaxAdditive) +{ + write((BYTE)(0xFF)); + write((BYTE)(0xB4)); + write((BYTE)(0x05)); + write(eaxAdditive); +} + +inline +void CodeGen::decEAX(void) +{ + write((BYTE)(0x48)); +} + +inline +void CodeGen::cmpEAX(int value) +{ + write((BYTE)(0x3D)); + write(value); +} + +inline +void CodeGen::addEBP(int value) +{ + write((BYTE)(0x81)); + write((BYTE)(0xC5)); + write(value); +} + +inline +void CodeGen::movECXESI(void) +{ + write((BYTE)(0x8B)); + write((BYTE)(0xCE)); +} + +inline +void CodeGen::movECXEDI(void) +{ + write((BYTE)(0x8B)); + write((BYTE)(0xCF)); +} + +inline +void CodeGen::movECX(int value) +{ + write((BYTE)(0xB9)); + write(value); +} + +inline +void CodeGen::movEAXESP(void) +{ + write((BYTE)(0x8B)); + write((BYTE)(0xC4)); +} + +inline +void CodeGen::pushFSOFFSET(WORD offset) +{ + write((BYTE)(0x64)); + write((BYTE)(0x67)); + write((BYTE)(0xFF)); + write((BYTE)(0X36)); + write((BYTE)(offset&0x00FF)); + write((BYTE)(offset>>0x08)); +} + +inline +void CodeGen::movFSOFFSETESP(WORD offset) +{ + write((BYTE)(0x64)); + write((BYTE)(0x67)); + write((BYTE)(0x89)); + write((BYTE)(0x26)); + write((BYTE)(offset&0x00FF)); + write((BYTE)(offset>>0x08)); +} + +inline +void CodeGen::movEAXOFFSETSS(int offset) +{ + write((BYTE)(0x36)); + write((BYTE)(0xA1)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movOFFSETSSEAX(int offset) +{ + write((BYTE)(0x36)); + write((BYTE)(0xA3)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movEAXESPOFFSET(int offset) +{ + write((BYTE)(0x8B)); + write((BYTE)(0x84)); + write((BYTE)(0x24)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movEAXEBPOFFSET(int offset) +{ + write((BYTE)(0x8B)); + write((BYTE)(0x85)); + write((BYTE)(0x56)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movESPOFFSETEAX(int offset) +{ + write((BYTE)(0x89)); + write((BYTE)(0x84)); + write((BYTE)(0x24)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movFSOFFSETEAX(int offset) +{ + write((BYTE)(0x64)); + write((BYTE)(0xA3)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movESPOFFSETEBX(int offset) +{ + write((BYTE)(0x89)); + write((BYTE)(0x9C)); + write((BYTE)(0x24)); + write((BYTE)(offset)); + write((BYTE)(offset>>0x08)); + write((BYTE)(offset>>0x10)); + write((BYTE)(offset>>0x18)); +} + +inline +void CodeGen::movDEREFEAXEBX(void) +{ + write((BYTE)(0x89)); + write((BYTE)(0x18)); +} + +inline +void CodeGen::wait(void) +{ + write((BYTE)0x9B); +} + +inline +void CodeGen::finit(void) +{ + write((BYTE)0xDB); + write((BYTE)0xE3); +} +#endif diff --git a/common/COMCTLEX.HPP b/common/COMCTLEX.HPP new file mode 100644 index 0000000..ad733b6 --- /dev/null +++ b/common/COMCTLEX.HPP @@ -0,0 +1,109 @@ +#ifndef _COMMON_COMMONCONTROLSEX_HPP_ +#define _COMMON_COMMONCONTROLSEX_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_COMMCTRL_HPP_ +#include +#endif + +class CommonControlsEx : private tagINITCOMMONCONTROLSEX +{ +public: + enum InitFlags{InitListView=ICC_LISTVIEW_CLASSES,InitTreeView=ICC_TREEVIEW_CLASSES, + InitBar=ICC_BAR_CLASSES,InitTab=ICC_TAB_CLASSES,InitUpDown=ICC_UPDOWN_CLASS, + InitProgress=ICC_PROGRESS_CLASS,InitHotKey=ICC_HOTKEY_CLASS,InitAnimate=ICC_ANIMATE_CLASS, + InitWin95=ICC_WIN95_CLASSES,InitDate=ICC_DATE_CLASSES,InitUserEx=ICC_USEREX_CLASSES, + InitCoolBar=ICC_COOL_CLASSES}; + CommonControlsEx(void); + CommonControlsEx(const CommonControlsEx &someCommonControlsEx); + CommonControlsEx(const tagINITCOMMONCONTROLSEX &sometagINITCOMMONCONTROLSEX); + virtual ~CommonControlsEx(); + CommonControlsEx &operator=(const CommonControlsEx &someCommonControlsEx); + CommonControlsEx &operator=(const tagINITCOMMONCONTROLSEX &sometagINITCOMMONCONTROLSEX); + DWORD flags(void)const; + void flags(DWORD flags); + BOOL initCommonControlsEx(void); + tagINITCOMMONCONTROLSEX &getINITCOMMONCONTROLSEX(void); +private: + DWORD size(void)const; + void size(DWORD size); +}; + +inline +CommonControlsEx::CommonControlsEx(void) +{ + size(sizeof(tagINITCOMMONCONTROLSEX)); + flags(0); +} + +inline +CommonControlsEx::CommonControlsEx(const CommonControlsEx &someCommonControlsEx) +{ + size(sizeof(tagINITCOMMONCONTROLSEX)); + *this=someCommonControlsEx; +} + +inline +CommonControlsEx::CommonControlsEx(const tagINITCOMMONCONTROLSEX &sometagINITCOMMONCONTROLSEX) +{ + size(sizeof(tagINITCOMMONCONTROLSEX)); + *this=sometagINITCOMMONCONTROLSEX; +} + +inline +CommonControlsEx::~CommonControlsEx() +{ +} + +inline +CommonControlsEx &CommonControlsEx::operator=(const CommonControlsEx &someCommonControlsEx) +{ + flags(someCommonControlsEx.flags()); + return *this; +} + +inline +CommonControlsEx &CommonControlsEx::operator=(const tagINITCOMMONCONTROLSEX &sometagINITCOMMONCONTROLSEX) +{ + flags(sometagINITCOMMONCONTROLSEX.dwICC); + return *this; +} + +inline +DWORD CommonControlsEx::flags(void)const +{ + return tagINITCOMMONCONTROLSEX::dwICC; +} + +inline +void CommonControlsEx::flags(DWORD flags) +{ + tagINITCOMMONCONTROLSEX::dwICC=flags; +} + +inline +DWORD CommonControlsEx::size(void)const +{ + return tagINITCOMMONCONTROLSEX::dwSize; +} + +inline +void CommonControlsEx::size(DWORD size) +{ + tagINITCOMMONCONTROLSEX::dwSize=size; +} + +inline +tagINITCOMMONCONTROLSEX &CommonControlsEx::getINITCOMMONCONTROLSEX(void) +{ + return (tagINITCOMMONCONTROLSEX&)*this; +} + +inline +BOOL CommonControlsEx::initCommonControlsEx(void) +{ + if(!flags())return FALSE; + return ::InitCommonControlsEx(&getINITCOMMONCONTROLSEX()); +} +#endif diff --git a/common/COMMCTRL.HPP b/common/COMMCTRL.HPP new file mode 100644 index 0000000..91b70c7 --- /dev/null +++ b/common/COMMCTRL.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_COMMCTRL_HPP_ +#define _COMMON_COMMCTRL_HPP_ +#include +#endif diff --git a/common/COMMDLG.HPP b/common/COMMDLG.HPP new file mode 100644 index 0000000..b468be7 --- /dev/null +++ b/common/COMMDLG.HPP @@ -0,0 +1,5 @@ +#ifndef _COMMON_COMMDLG_HPP_ +#define _COMMON_COMMDLG_HPP_ +#undef STDMETHOD +#include +#endif diff --git a/common/COMMON16.IDE b/common/COMMON16.IDE new file mode 100644 index 0000000..fd7c6b3 Binary files /dev/null and b/common/COMMON16.IDE differ diff --git a/common/COMMON16.OBR b/common/COMMON16.OBR new file mode 100644 index 0000000..57125c5 Binary files /dev/null and b/common/COMMON16.OBR differ diff --git a/common/COMMON16.~DE b/common/COMMON16.~DE new file mode 100644 index 0000000..5bbf7ac Binary files /dev/null and b/common/COMMON16.~DE differ diff --git a/common/COMMON32.IDE b/common/COMMON32.IDE new file mode 100644 index 0000000..1fbb948 Binary files /dev/null and b/common/COMMON32.IDE differ diff --git a/common/COMMON32.MBT b/common/COMMON32.MBT new file mode 100644 index 0000000..b2a3433 Binary files /dev/null and b/common/COMMON32.MBT differ diff --git a/common/COMMON32.MRT b/common/COMMON32.MRT new file mode 100644 index 0000000..b2a3433 Binary files /dev/null and b/common/COMMON32.MRT differ diff --git a/common/COMMON32.OBR b/common/COMMON32.OBR new file mode 100644 index 0000000..9ff8a6f Binary files /dev/null and b/common/COMMON32.OBR differ diff --git a/common/COMMON32.~DE b/common/COMMON32.~DE new file mode 100644 index 0000000..1f08df7 Binary files /dev/null and b/common/COMMON32.~DE differ diff --git a/common/COMMONM.INC b/common/COMMONM.INC new file mode 100644 index 0000000..a32be08 --- /dev/null +++ b/common/COMMONM.INC @@ -0,0 +1,86 @@ +; ************************************************************************** +; FILE:COMMON.INC +; FUNCTION: COMMON ASSEMBLER INCLUDE FILE +; AUTHOR: SEAN M. KESSLER +;**************************************************************************** +INCLUDE WINDOWS.INC + +LPDWORD TYPEDEF NEAR PTR DWORD +NPDWORD TYPEDEF FAR PTR DWORD +NPBYTE TYPEDEF PTR BYTE + +String STRUC + String@@mnpStr NPDWORD ? + String@@mLengthBytes DD ? +String ENDS + +Point STRUC + Point@@x DW ? + Point@@y DW ? +Point ENDS + +Point3D STRUC + Point3D@@xyPoint Point <> + Point3D@@Point@@z DW ? +Point3D ENDS + +PurePalette STRUC + PurePalette@@mhPalette HANDLE <> + PurePalette@@mhOldPalette HANDLE <> + PurePalette@@mPaletteData PALETTEENTRY 100h DUP (<>) + PurePalette@@mIsInUse DW ? +PurePalette ENDS + +BitmapData STRUC + BitmapData@@mhGlobalBitmapData HANDLE <> + BitmapData@@mhGlobalBitmapInfo HANDLE <> + BitmapData@@mlpBitmapData LPDWORD ? + BitmapData@@mlpBitmapInfo PBITMAPINFO ? + BitmapData@@mInfoDisposition DD ? + BitmapData@@mDataDisposition DD ? +BitmapData ENDS + +Bitmap STRUC +PBitmap TYPEDEF FAR PTR Bitmap +PPBitmap TYPEDEF FAR PTR PBitmap + Bitmap@@mBitmapData BitmapData <> + Bitmap@@mFileName String <> + Bitmap@@mMaxColors DW ? + Bitmap@@mCurrentMode DD ? + Bitmap@@mBitmapFileHeader BITMAPFILEHEADER <> + Bitmap@@mPaletteData PurePalette <> + Bitmap@@mBlockSize DD ? + Bitmap@@mhFile HANDLE <> + Bitmap@@mImageExtent DD ? + Bitmap@@mWidth DD ? + Bitmap@@mHeight DD ? +Bitmap ENDS + +PureVectorBitmap STRUC +PPureVectorBitmap TYPEDEF FAR PTR PureVectorBitmap + PureVectorBitmap@@mhGlobalMemPool DD ? + PureVectorBitmap@@mhGlobalVectorTable DD ? + PureVectorBitmap@@mEntries DD ? + PureVectorBitmap@@mlpVectorTable PPBitmap ? + PureVectorBitmap@@mlpMemPool PBitmap ? +PureVectorBitmap ENDS + +getBitmapPtr MACRO npPureVector,itemIndex +LOCAL @@boundFail,@@return + push edi ; save destination index register + mov edi,npPureVector ; move npPureVector to edi register + movzx eax,itemIndex ; move itemIndex to eax register + cmp eax,[PureVectorBitmap ptr[edi]].PureVectorBitmap@@mEntries ; check index boundary + jge @@boundFail ; handle out of bounds condition + shl eax,02h ; multiply eax by sizeof(PTR) + mov edi,[PureVectorBitmap ptr[edi]].PureVectorBitmap@@mlpVectorTable ; dereference vector table to edi + add edi,eax ; add in itemIndex + mov eax,[edi] ; dereference pointer to eax + jmp @@return ; return +@@boundFail: ; boundary error sync address + xor eax,eax ; error clears eax register +@@return: ; return sync address + pop edi ; restore detination index register +ENDM + + diff --git a/common/COMP.RSP b/common/COMP.RSP new file mode 100644 index 0000000..f967b36 --- /dev/null +++ b/common/COMP.RSP @@ -0,0 +1,15 @@ +/G4 +/YX +/D__FLAT__ +/DSTRICT +/G4 +/GA +/J +/Yd +/Zi +/IC:\PARTS\MSVC\INCLUDE +/I.. +/I..\..\PARTS +/c +/FoMSVCOBJ\MATH.OBJ +MATH.CPP diff --git a/common/CONSOLE.CPP b/common/CONSOLE.CPP new file mode 100644 index 0000000..a30b782 --- /dev/null +++ b/common/CONSOLE.CPP @@ -0,0 +1,90 @@ +#if defined(__FLAT__) +#include +#include +#include + +Console::Console() +: mhConsole(0), mHasConsole(FALSE), mIsSystemConsole(TRUE) +{ + mhConsole=::GetStdHandle(STD_OUTPUT_HANDLE); + if(mhConsole)mHasConsole=true; +} + +Console::Console(ConsoleType consoleType,bool forceCreate) +: mhConsole(0), mHasConsole(FALSE), mIsSystemConsole(FALSE) +{ + if(!mhConsole&&!::AllocConsole()) + { + if(!forceCreate)return; + ::FreeConsole(); + if(!AllocConsole())return; + } + mHasConsole=TRUE; + if(0==(mhConsole=::CreateConsoleScreenBuffer(consoleType,FILE_SHARE_READ|FILE_SHARE_WRITE,(LPSECURITY_ATTRIBUTES)0,CONSOLE_TEXTMODE_BUFFER,0))) + { + ::FreeConsole(); + mHasConsole=FALSE; + return; + } + ::SetConsoleActiveScreenBuffer(mhConsole); + ::GetConsoleScreenBufferInfo(mhConsole,&((CONSOLE_SCREEN_BUFFER_INFO&)mConsoleScreenBufferInfo)); + setConsoleMode(ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT); +} + +Console::~Console() +{ + if(mIsSystemConsole)return; + if(mhConsole){::CloseHandle(mhConsole);mhConsole=0;} + if(mHasConsole){::FreeConsole();mHasConsole=FALSE;} +} + +Console::operator HANDLE(void) +{ + return mhConsole; +} + +WORD Console::read(void) +{ + String consoleString; + return read(consoleString); +} + +WORD Console::read(String &consoleString) +{ + String consoleInputString; + DWORD bytesRead; + HANDLE mhConsoleInput; + + if(!mhConsole)return FALSE; + if(!::ReadConsole(::GetStdHandle(STD_INPUT_HANDLE),(LPSTR)consoleInputString,String::MaxString-1,&bytesRead,0))return FALSE; + consoleString=consoleInputString; + return TRUE; +} + +BOOL Console::readBufferLine(int row,String &lineString) +{ + Coord coord(0,row); + DWORD bytesRead; + + if(!mhConsole)return FALSE; + const ConsoleScreenBufferInfo &consoleScreenBufferInfo=getConsoleScreenBufferInfo(); + lineString.reserve(consoleScreenBufferInfo.maxWinRect().x()); + return ::ReadConsoleOutputCharacter(*this,lineString,consoleScreenBufferInfo.maxWinRect().x(),(COORD&)coord,&bytesRead); +} + +WORD Console::fillConsoleOutputAttribute(WORD colorAttr,DWORD numChars,const Coord &writeCoord) +{ + DWORD cellsWritten; + + if(!mhConsole)return FALSE; + return ::FillConsoleOutputAttribute(mhConsole,colorAttr,numChars,(COORD&)(Coord&)writeCoord,&cellsWritten); +} + +WORD Console::fillConsoleOutputCharacter(TCHAR outChar,DWORD nLength,const Coord &writeCoord) +{ + DWORD cellsWritten; + + if(!mhConsole)return FALSE; + return ::FillConsoleOutputCharacter(mhConsole,outChar,nLength,(COORD&)(Coord&)writeCoord,&cellsWritten); +} +#endif diff --git a/common/CONSOLE.HPP b/common/CONSOLE.HPP new file mode 100644 index 0000000..deab356 --- /dev/null +++ b/common/CONSOLE.HPP @@ -0,0 +1,89 @@ +#if defined(__FLAT__) +#ifndef _COMMON_CONSOLE_HPP_ +#define _COMMON_CONSOLE_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_SCREENBUFFERINFO_HPP_ +#include +#endif + +class Coord; + +class Console +{ +public: + enum Attribute{ForegroundBlue=FOREGROUND_BLUE,ForegroundGreen=FOREGROUND_GREEN, + ForegroundRed=FOREGROUND_RED,ForegroundIntensity=FOREGROUND_INTENSITY, + BackgroundBlue=BACKGROUND_BLUE,BackgroundGreen=BACKGROUND_GREEN, + BackgroundRed=BACKGROUND_RED,BackgroundIntensity=BACKGROUND_INTENSITY}; + enum ConsoleType{Read=GENERIC_READ,Write=GENERIC_WRITE,ReadWrite=GENERIC_READ|GENERIC_WRITE}; +// Console(ConsoleType consoleType=(ConsoleType)((int)Write|(int)Read),bool forceCreate=false); + Console(); + Console(ConsoleType consoleType,bool forceCreate); + virtual ~Console(); + WORD write(const String &consoleString); + WORD write(const BYTE consoleBYTE); + WORD writeLine(const String &consoleString); + WORD read(void); + WORD read(String &consoleString); + BOOL readBufferLine(int row,String &lineString); + WORD setConsoleMode(DWORD consoleMode); + WORD setConsoleAttribute(WORD consoleAttributes); + WORD fillConsoleOutputAttribute(WORD colorAttr,DWORD numChars,const Coord &writeCoord); + WORD fillConsoleOutputCharacter(TCHAR outChar,DWORD nLength,const Coord &writeCoord); + const ConsoleScreenBufferInfo &getConsoleScreenBufferInfo(void)const; + operator HANDLE(void); +private: + HANDLE mhConsole; + WORD mHasConsole; + DWORD mGenericResult; + ConsoleScreenBufferInfo mConsoleScreenBufferInfo; + bool mIsSystemConsole; +}; + +inline +WORD Console::write(const String &consoleString) +{ + if(!mhConsole)return FALSE; + if(consoleString.isNull())return FALSE; + ::WriteConsole(mhConsole,consoleString,consoleString.length(),&mGenericResult,0); + return TRUE; +} + +inline +WORD Console::write(const BYTE consoleBYTE) +{ + if(!mhConsole)return FALSE; + ::WriteConsole(mhConsole,&consoleBYTE,sizeof(consoleBYTE),&mGenericResult,0); + return TRUE; +} + +inline +WORD Console::writeLine(const String &consoleString) +{ + if(!write(consoleString))return FALSE; + return write("\n"); +} + +inline +WORD Console::setConsoleMode(DWORD consoleMode) +{ + if(!mhConsole)return FALSE; + return ::SetConsoleMode(mhConsole,consoleMode); +} + +inline +WORD Console::setConsoleAttribute(WORD consoleAttributes) +{ + if(!mhConsole)return FALSE; + return ::SetConsoleTextAttribute(mhConsole,consoleAttributes); +} + +inline +const ConsoleScreenBufferInfo &Console::getConsoleScreenBufferInfo(void)const +{ + return mConsoleScreenBufferInfo; +} +#endif +#endif diff --git a/common/CONTROL.CPP b/common/CONTROL.CPP new file mode 100644 index 0000000..ea378a0 --- /dev/null +++ b/common/CONTROL.CPP @@ -0,0 +1,55 @@ +#include + +Control::~Control() +{ +} + +HWND Control::createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); + createWindow(className,windowName,dwStyle,initRect,hParentWnd,(HMENU)controlID,(HINSTANCE)processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); + createWindow(extendedStyle,className,windowName,dwStyle,initRect,hParentWnd,(HMENU)controlID,(HINSTANCE)processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,Window &parentWindow,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); + createWindow(className,windowName,dwStyle,initRect,parentWindow,(HMENU)controlID,parentWindow.processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,Window &parentWindow,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); + createWindow(extendedStyle,className,windowName,dwStyle,initRect,parentWindow,(HMENU)controlID,parentWindow.processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::assumeControl(HWND hControlWnd,UINT controlID,BOOL destroyWindow) +{ + if(isValid())return *this; + this->controlID(controlID); + setHandle(hControlWnd); + disposition((destroyWindow?GUIWindow::AssumeAndDestroy:GUIWindow::Assume)); + return *this; +} + diff --git a/common/CONTROL.HPP b/common/CONTROL.HPP new file mode 100644 index 0000000..abb9280 --- /dev/null +++ b/common/CONTROL.HPP @@ -0,0 +1,115 @@ +#ifndef _COMMON_CONTROL_HPP_ +#define _COMMON_CONTROL_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_WINDOW_HPP_ +#include +#endif +#ifndef _COMMON_RECTANGLE_HPP_ +#include +#endif + +class Control : public Window +{ +public: + Control(void); + Control(HWND hControlWnd,UINT controlID,BOOL destroyWindow=TRUE); + virtual ~Control(); + BOOL operator==(const Control &someControl)const; + WORD width(void)const; + void width(WORD width); + WORD height(void)const; + void height(WORD height); + UINT controlID(void)const; + virtual HWND createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID); + virtual HWND createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID); + virtual HWND createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,Window &parentWindow,int controlID); + virtual HWND createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,Window &parentWindow,int controlID); + virtual HWND assumeControl(HWND hControlWnd,UINT controlID,BOOL destroyWindow=FALSE); +private: + Control(const Control &someControl); + Control &operator=(const GUIWindow &someGUIWindow); + Control &operator=(const Control &someControl); + void controlID(UINT controlID); + UINT mControlID; +}; + +inline +Control::Control(void) +{ +} + +inline +Control::Control(HWND hControlWnd,UINT controlID,BOOL destroyWindow) +{ + assumeControl(hControlWnd,controlID,destroyWindow); +} + +inline +Control::Control(const Control &someControl) +{ // private implementation +} + +inline +BOOL Control::operator==(const Control &someControl)const +{ + return ((HWND)*this==(HWND)someControl); +} + +inline +Control &Control::operator=(const Control &someControl) +{ // private implementation + return *this; +} + +inline +Control &Control::operator=(const GUIWindow &someGUIWindow) +{ // private implementation + return *this; +} + +inline +UINT Control::controlID(void)const +{ + return mControlID; +} + +inline +void Control::controlID(UINT controlID) +{ + mControlID=controlID; +} + +inline +WORD Control::width(void)const +{ + Rect winRect; + windowRect(winRect); + return winRect.right()-winRect.left(); +} + +inline +void Control::width(WORD width) +{ + Rect winRect; + windowRect(winRect); + ::SetWindowPos(*this,HWND_BOTTOM,0,0,width,winRect.bottom()-winRect.top(),SWP_NOMOVE|SWP_NOZORDER); +} + +inline +WORD Control::height(void)const +{ + Rect winRect; + windowRect(winRect); + return winRect.bottom()-winRect.top(); +} + +inline +void Control::height(WORD height) +{ + Rect winRect; + windowRect(winRect); + ::SetWindowPos(*this,HWND_BOTTOM,0,0,winRect.right()-winRect.left(),height,SWP_NOMOVE|SWP_NOZORDER); +} +#endif diff --git a/common/COORD.HPP b/common/COORD.HPP new file mode 100644 index 0000000..f3afa31 --- /dev/null +++ b/common/COORD.HPP @@ -0,0 +1,93 @@ +#ifndef _COMMON_COORD_HPP_ +#define _COMMON_COORD_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class Coord : private COORD +{ +public: + Coord(void); + Coord(const Coord &someCoord); + Coord(short x,short y); + virtual ~Coord(); + Coord &operator=(const Coord &someCoord); + WORD operator==(const Coord &someCoord)const; + operator COORD&(void); + short x(void)const; + void x(short x); + short y(void)const; + void y(short y); +private: +}; + +inline +Coord::Coord(void) +{ + COORD::X=0; + COORD::Y=0; +} + +inline +Coord::Coord(const Coord &someCoord) +{ + *this=someCoord; +} + +inline +Coord::Coord(short x,short y) +{ + COORD::X=x; + COORD::Y=y; +} + +inline +Coord::~Coord() +{ +} + +inline +Coord &Coord::operator=(const Coord &someCoord) +{ + x(someCoord.x()); + y(someCoord.y()); + return *this; +} + +inline +WORD Coord::operator==(const Coord &someCoord)const +{ + return (x()==someCoord.x()&& + y()==someCoord.y()); +} + +inline +Coord::operator COORD&(void) +{ + return *this; +} + +inline +short Coord::x(void)const +{ + return COORD::X; +} + +inline +void Coord::x(short x) +{ + COORD::X=x; +} + +inline +short Coord::y(void)const +{ + return COORD::Y; +} + +inline +void Coord::y(short y) +{ + COORD::Y=y; +} +#endif diff --git a/common/CRSCTRL.CPP b/common/CRSCTRL.CPP new file mode 100644 index 0000000..c291e5f --- /dev/null +++ b/common/CRSCTRL.CPP @@ -0,0 +1,20 @@ +#include + +void CursorControl::setCursor(int setState,CursorID cursorID) +{ + if(setState) + { + if(!mhCursor)mhCursor=::SetCursor(::LoadCursor(NULL,(const char*)(int)cursorID)); + ::ShowCursor(TRUE); + } + else + { + if(mhCursor) + { + ::ShowCursor(FALSE); + ::SetCursor(mhCursor); + ::ShowCursor(TRUE); + mhCursor=FALSE; + } + } +} diff --git a/common/CRSCTRL.HPP b/common/CRSCTRL.HPP new file mode 100644 index 0000000..b7be0ae --- /dev/null +++ b/common/CRSCTRL.HPP @@ -0,0 +1,46 @@ +#ifndef _COMMON_CURSORCONTROL_HPP_ +#define _COMMON_CURSORCONTROL_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class CursorControl +{ +public: + enum CursorID{Arrow=IDC_ARROW,IBeam=IDC_IBEAM,Wait=IDC_WAIT,Cross=IDC_CROSS, + UpArrow=IDC_UPARROW,Size=IDC_SIZE,Icon=IDC_ICON,SizeNWSE=IDC_SIZENWSE, + SizeNESW=IDC_SIZENESW,SizeWE=IDC_SIZEWE,SizeNS=IDC_SIZENS, + SizeAll=IDC_SIZEALL,No=IDC_NO,AppStarting=IDC_APPSTARTING,Help=IDC_HELP}; + CursorControl(void); + virtual ~CursorControl(); + void waitCursor(int setState); + void setCursor(int setState,CursorID cursorID=Wait); + static int showCursor(BOOL show); +private: + HCURSOR mhCursor; +}; + +inline +CursorControl::CursorControl(void) +: mhCursor(0) +{ +} + +inline +CursorControl::~CursorControl() +{ + waitCursor(FALSE); +} + +inline +void CursorControl::waitCursor(int setState) +{ + setCursor(setState,Wait); +} + +inline +int CursorControl::showCursor(BOOL show) +{ + return ::ShowCursor(show); +} +#endif \ No newline at end of file diff --git a/common/Callback.hpp b/common/Callback.hpp new file mode 100644 index 0000000..dcc1878 --- /dev/null +++ b/common/Callback.hpp @@ -0,0 +1,58 @@ +#ifndef _COMMON_CALLBACK_HPP_ +#define _COMMON_CALLBACK_HPP_ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#include +#endif +#ifndef _COMMON_PURECALLBACK_HPP_ +#include +#endif +#ifndef _COMMON_CALLBACKPOINTER_HPP_ +#include +#endif + +#if defined(_MSC_VER) +#pragma warning(disable:4355) +#endif + +template +class Callback : public PureCallback +{ +public: + typedef CallbackData::ReturnType (T::*PFNMETHOD)(CallbackData &callbackData); + Callback(void); + Callback(const Callback &someCallback); + Callback(T *lpObject,PFNMETHOD lpMethod); + virtual ~Callback(); + void setObject(T *lpObject); + void setMethod(PFNMETHOD lpMethod); + void setCallback(T *lpObject,PFNMETHOD lpMethod); + WORD operator==(const Callback &someCallback)const; + void operator=(const Callback &someCallback); + CallbackData::ReturnType operator*(CallbackData &someCallbackData); +private: + T *mlpObject; + CallbackData::ReturnType (T::*mlpMethod)(CallbackData &someCallbackData); +}; + +#ifndef _MSC_VER +template +inline +CallbackData::ReturnType Callback::operator*(CallbackData &someCallbackData) +{ + if((!mlpObject)||(!mlpMethod))return (CallbackData::ReturnType)0; + return (mlpObject->*mlpMethod)(someCallbackData); +} +#else // the rocket scientists at microsoft have problems compiling the preceeding, must do the following... +template +inline +CallbackData::ReturnType Callback::operator*(CallbackData &someCallbackData) +{ + CallbackData::ReturnType (T::*lpMethod)(CallbackData &someCallbackData)=0; + if((lpMethod==mlpMethod)||!mlpObject)return (CallbackData::ReturnType)0; + return (mlpObject->*mlpMethod)(someCallbackData); +} +#endif +#if defined(_MSC_VER) // the rocket scientists at microsoft have trouble expanding templates +#include +#endif +#endif diff --git a/common/Cbdata.hpp b/common/Cbdata.hpp new file mode 100644 index 0000000..90fff76 --- /dev/null +++ b/common/Cbdata.hpp @@ -0,0 +1,242 @@ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#define _COMMON_CALLBACKDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWSX_HPP_ +#include +#endif +#ifndef _COMMON_RECTANGLE_HPP_ +#include +#endif + +class PureDevice; + +class PaintInformation : public PAINTSTRUCT +{ +public: + PaintInformation(const PureDevice &somePureDevice); + ~PaintInformation(); + operator PureDevice&(void)const; + Rect paintRect(void)const; +private: + PureDevice *mlpPaintDevice; +}; + +inline +Rect PaintInformation::paintRect(void)const +{ + return Rect(PAINTSTRUCT::rcPaint.left,PAINTSTRUCT::rcPaint.top,PAINTSTRUCT::rcPaint.right,PAINTSTRUCT::rcPaint.bottom); +} + +class CallbackData +{ +public: + typedef LONG ReturnType; + CallbackData(void); + CallbackData(const CallbackData &someCallbackData); + CallbackData(WPARAM wParam,LPARAM lParam,HWND hWndFrom=0); + virtual ~CallbackData(); + CallbackData &operator=(const CallbackData &someCallbackData); + WORD operator==(const CallbackData &someCallbackData)const; + HWND hwndFrom(void)const; + void hwndFrom(HWND hwndFrom); + WPARAM wParam(void)const; + void wParam(WPARAM wParam); + LPARAM lParam(void)const; + void lParam(LPARAM lParam); + WORD loWord(void)const; + WORD hiWord(void)const; + WPARAM wmCommandID(void)const; // specialized WM_COMMAND interpreter + HWND wmCommandWindow(void)const; // "" + WORD wmCommandCommand(void)const; // "" + WPARAM menuSelectID(void)const; // specialized WM_MENUSELECT interpreter + WPARAM menuSelectFlags(void)const; // "" + HMENU menuSelectMenu(void)const; // "" + HMENU menuSelectIDPopup(void)const; // "" + UINT controlID(void)const; // specialized control handling + HWND controlWindow(void)const; // "" + WORD controlNotification(void)const; // "" +private: + WPARAM mwParam; + LPARAM mlParam; + HWND mhWndFrom; +}; + +inline +CallbackData::CallbackData(void) +: mwParam(0), mlParam(0), mhWndFrom(0) +{ +} + +inline +CallbackData::CallbackData(WPARAM wParam,LPARAM lParam,HWND hWndFrom) +: mwParam(wParam), mlParam(lParam), mhWndFrom(hWndFrom) +{ +} + +inline +CallbackData::CallbackData(const CallbackData &someCallbackData) +{ + *this=someCallbackData; +} + +inline +CallbackData::~CallbackData() +{ +} + +inline +CallbackData &CallbackData::operator=(const CallbackData &someCallbackData) +{ + wParam(someCallbackData.wParam()); + lParam(someCallbackData.lParam()); + hwndFrom(someCallbackData.hwndFrom()); + return *this; +} + +inline +WORD CallbackData::operator==(const CallbackData &someCallbackData)const +{ + return (wParam()==someCallbackData.wParam()&& + lParam()==someCallbackData.lParam()&& + hwndFrom()==someCallbackData.hwndFrom()); +} + +inline +WPARAM CallbackData::wmCommandID(void)const +{ + return (WPARAM)(GET_WM_COMMAND_ID(mwParam,mlParam)); +} + +inline +HWND CallbackData::wmCommandWindow(void)const +{ + return GET_WM_COMMAND_HWND(mwParam,mlParam); +} + +inline +WORD CallbackData::wmCommandCommand(void)const +{ + return GET_WM_COMMAND_CMD(mwParam,mlParam); +} + +inline +WPARAM CallbackData::menuSelectID(void)const +{ +#ifdef __FLAT__ + return LOWORD(mwParam); +#else + return mwParam; +#endif +} + +inline +WPARAM CallbackData::menuSelectFlags(void)const +{ +#ifdef __FLAT__ + return HIWORD(mwParam); +#else + return LOWORD(mlParam); +#endif +} + +inline +HMENU CallbackData::menuSelectMenu(void)const +{ +#ifdef __FLAT__ + return (HMENU)mlParam; +#else + return (HMENU)HIWORD(mlParam); +#endif +} + +inline +HMENU CallbackData::menuSelectIDPopup(void)const +{ + if(!(menuSelectFlags()&MF_POPUP))return (HMENU)0; +#ifdef __FLAT__ + return ::GetSubMenu(menuSelectMenu(),menuSelectID()); +#else + return (HMENU)menuSelectID(); +#endif +} + +inline +UINT CallbackData::controlID(void)const +{ +#ifdef __FLAT__ + return LOWORD(mwParam); +#else + return mwParam; +#endif +} + +inline +HWND CallbackData::controlWindow(void)const +{ +#ifdef __FLAT__ + return (HWND)mlParam; +#else + return (HWND)LOWORD(mlParam); +#endif +} + +inline +WORD CallbackData::controlNotification(void)const +{ +#ifdef __FLAT__ + return HIWORD(mwParam); +#else + return HIWORD(mlParam); +#endif +} + +inline +HWND CallbackData::hwndFrom(void)const +{ + return mhWndFrom; +} + +inline +void CallbackData::hwndFrom(HWND hwndFrom) +{ + mhWndFrom=hwndFrom; +} + +inline +WPARAM CallbackData::wParam(void)const +{ + return mwParam; +} + +inline +void CallbackData::wParam(WPARAM wParam) +{ + mwParam=wParam; +} + +inline +LPARAM CallbackData::lParam(void)const +{ + return mlParam; +} + +inline +void CallbackData::lParam(LPARAM lParam) +{ + mlParam=lParam; +} + +inline +WORD CallbackData::loWord(void)const +{ + return LOWORD(mlParam); +} + +inline +WORD CallbackData::hiWord(void)const +{ + return HIWORD(mlParam); +} +#endif diff --git a/common/Common.inc b/common/Common.inc new file mode 100644 index 0000000..e4be746 --- /dev/null +++ b/common/Common.inc @@ -0,0 +1,80 @@ +; ************************************************************************** +; FILE:COMMON.INC +; FUNCTION: COMMON ASSEMBLER INCLUDE FILE +; AUTHOR: SEAN M. KESSLER +;**************************************************************************** +INCLUDE ..\COMMON\WINDOWS.INC + +LPDWORD TYPEDEF NEAR PTR DWORD +NPDWORD TYPEDEF FAR PTR DWORD +NPBYTE TYPEDEF PTR BYTE + +String STRUC + String@@mnpStr NPDWORD ? + String@@mLengthBytes DD ? +String ENDS + +Point STRUC + Point@@x DW ? + Point@@y DW ? +Point ENDS + +PurePalette STRUC + PurePalette@@mhPalette HANDLE <> + PurePalette@@mhOldPalette HANDLE <> + PurePalette@@mPaletteData PALETTEENTRY 100h DUP (<>) + PurePalette@@mIsInUse DW ? +PurePalette ENDS + +BitmapData STRUC + BitmapData@@mhGlobalBitmapData HANDLE <> + BitmapData@@mhGlobalBitmapInfo HANDLE <> + BitmapData@@mlpBitmapData LPDWORD ? + BitmapData@@mlpBitmapInfo PBITMAPINFO ? + BitmapData@@mInfoDisposition DD ? + BitmapData@@mDataDisposition DD ? +BitmapData ENDS + +Bitmap STRUC +PBitmap TYPEDEF NEAR PTR Bitmap +PPBitmap TYPEDEF NEAR PTR PBitmap + Bitmap@@mBitmapData BitmapData <> + Bitmap@@mFileName String <> + Bitmap@@mMaxColors DW ? + Bitmap@@mCurrentMode DD ? + Bitmap@@mBitmapFileHeader BITMAPFILEHEADER <> + Bitmap@@mPaletteData PurePalette <> + Bitmap@@mBlockSize DD ? + Bitmap@@mhFile HANDLE <> + Bitmap@@mImageExtent DD ? + Bitmap@@mWidth DD ? + Bitmap@@mHeight DD ? +Bitmap ENDS + +PureVectorBitmap STRUC +PPureVectorBitmap TYPEDEF FAR PTR PureVectorBitmap + PureVectorBitmap@@mhGlobalMemPool DD ? + PureVectorBitmap@@mhGlobalVectorTable DD ? + PureVectorBitmap@@mEntries DD ? + PureVectorBitmap@@mlpVectorTable PPBitmap ? + PureVectorBitmap@@mlpMemPool PBitmap ? +PureVectorBitmap ENDS + +getBitmapPtr MACRO npPureVector,itemIndex +LOCAL @@boundFail,@@return + push edi ; save destination index register + mov edi,npPureVector ; move npPureVector to edi register + movzx eax,itemIndex ; move itemIndex to eax register + cmp eax,[edi].PureVectorBitmap@@mEntries ; check index boundary + jge @@boundFail ; handle out of bounds condition + shl eax,02h ; multiply eax by sizeof(PTR) + mov edi,[edi].PureVectorBitmap@@mlpVectorTable ; dereference vector table to edi + add edi,eax ; add in itemIndex + mov eax,[edi] ; dereference pointer to eax + jmp @@return ; return +@@boundFail: ; boundary error sync address + xor eax,eax ; error clears eax register +@@return: ; return sync address + pop edi ; restore detination index register +ENDM + diff --git a/common/DDE.HPP b/common/DDE.HPP new file mode 100644 index 0000000..2a31d8a --- /dev/null +++ b/common/DDE.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_DDE_HPP_ +#define _COMMON_DDE_HPP_ +#include +#endif diff --git a/common/DDEACK.HPP b/common/DDEACK.HPP new file mode 100644 index 0000000..f3dc5a4 --- /dev/null +++ b/common/DDEACK.HPP @@ -0,0 +1,111 @@ +#ifndef _COMMON_DDEACK_HPP_ +#define _COMMON_DDEACK_HPP_ +#ifndef _COMMON_DDE_HPP_ +#include +#endif + +class DDEAck : private DDEACK +{ +public: + DDEAck(void); + DDEAck(WORD appReturnCode,WORD busy,WORD ack); + DDEAck(const DDEAck &someDDEAck); + ~DDEAck(); + DDEAck &operator=(const DDEAck &someDDEAck); + WORD operator==(const DDEAck &someDDEAck); + WORD returnCode(void)const; + void returnCode(WORD returnCode); + WORD busy(void)const; + void busy(WORD busy); + WORD ack(void)const; + void ack(WORD ack); + operator WORD(void)const; +private: +}; + +inline +DDEAck::DDEAck(void) +{ + returnCode(FALSE); + busy(FALSE); + ack(TRUE); +} + +inline +DDEAck::DDEAck(WORD appReturnCode,WORD busyFlag,WORD ackFlag) +{ + returnCode(appReturnCode); + busy(busyFlag); + ack(ackFlag); +} + +inline +DDEAck::DDEAck(const DDEAck &someDDEAck) +{ + *this=someDDEAck; +} + +inline +DDEAck::~DDEAck() +{ +} + +inline +DDEAck &DDEAck::operator=(const DDEAck &someDDEAck) +{ + returnCode(someDDEAck.returnCode()); + busy(someDDEAck.busy()); + ack(someDDEAck.ack()); + return *this; +} + +inline +WORD DDEAck::operator==(const DDEAck &someDDEAck) +{ + return(returnCode()==someDDEAck.returnCode()&& + busy()==someDDEAck.busy()&& + ack()==someDDEAck.ack()); +} + +inline +WORD DDEAck::returnCode(void)const +{ + return DDEACK::bAppReturnCode; +} + +inline +void DDEAck::returnCode(WORD returnCode) +{ + DDEACK::bAppReturnCode=returnCode; +} + +inline +WORD DDEAck::busy(void)const +{ + return DDEACK::fBusy; +} + +inline +void DDEAck::busy(WORD busy) +{ + DDEACK::fBusy=busy; +} + +inline +WORD DDEAck::ack(void)const +{ + return DDEACK::fAck; +} + +inline +void DDEAck::ack(WORD ack) +{ + DDEACK::fAck=ack; +} + +inline +DDEAck::operator WORD(void)const +{ + return *((WORD*)((DDEACK*)this)); +} +#endif \ No newline at end of file diff --git a/common/DDEDATA.HPP b/common/DDEDATA.HPP new file mode 100644 index 0000000..9412076 --- /dev/null +++ b/common/DDEDATA.HPP @@ -0,0 +1,105 @@ +#ifndef _COMMON_DDEDATA_HPP_ +#define _COMMON_DDEDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_DDE_HPP_ +#include +#endif + +class DDEData : public DDEDATA +{ +public: + DDEData(void); + ~DDEData(); + WORD mustRespond(void)const; + void mustRespond(WORD mustRespond); + WORD mustRelease(void)const; + void mustRelease(WORD mustRelease); + WORD isResponseForRequest(void)const; + void isResponseForRequest(WORD isResponseForRequest); + short getFormat(void)const; + void setFormat(short format); + WORD setData(char FAR *npDDEData,DWORD sizeData); + char FAR *getData(void); +private: +}; + +inline +DDEData::DDEData(void) +{ + DDEDATA::fResponse=0; + DDEDATA::fRelease=0; + DDEDATA::fAckReq=0; + DDEDATA::cfFormat=0; + DDEDATA::Value[0]=0; +} + +inline +DDEData::~DDEData() +{ +} + +inline +WORD DDEData::mustRespond(void)const +{ + return DDEDATA::fResponse; +} + +inline +void DDEData::mustRespond(WORD mustRespond) +{ + DDEDATA::fResponse=mustRespond; +} + +inline +WORD DDEData::mustRelease(void)const +{ + return DDEDATA::fRelease; +} + +inline +void DDEData::mustRelease(WORD mustRelease) +{ + DDEDATA::fRelease=mustRelease; +} + +inline +WORD DDEData::isResponseForRequest(void)const +{ + return DDEDATA::fAckReq; +} + +inline +void DDEData::isResponseForRequest(WORD isResponseForRequest) +{ + DDEDATA::fAckReq=isResponseForRequest; +} + +inline +short DDEData::getFormat(void)const +{ + return DDEDATA::cfFormat; +} + +inline +void DDEData::setFormat(short format) +{ + DDEDATA::cfFormat=format; +} + +inline +WORD DDEData::setData(char FAR *npLinkData,DWORD sizeData) +{ + if(!npLinkData)return FALSE; + ::memcpy(DDEDATA::Value,npLinkData,sizeData); + return TRUE; +} + +inline +char FAR *DDEData::getData(void) +{ + return (char FAR *)DDEData::Value; +} +#endif + diff --git a/common/DDEMSG.CPP b/common/DDEMSG.CPP new file mode 100644 index 0000000..83b483b --- /dev/null +++ b/common/DDEMSG.CPP @@ -0,0 +1,274 @@ +#include +#include + +HGLOBAL DDEMessage::buildDDEDataHandle(HGLOBAL hGlobalData) +{ + DDEData *npDDEData; + DWORD sizeData(::GlobalSize(hGlobalData)); + char *npLinkData; + + HGLOBAL hGlobalDDEData=::GlobalAlloc(GMEM_DDESHARE|GHND,sizeof(DDEData)+sizeData-1L); + npDDEData=(DDEData FAR*)::GlobalLock(hGlobalDDEData); + npLinkData=(char FAR*)::GlobalLock(hGlobalData); + npDDEData->mustRespond(TRUE); + npDDEData->mustRelease(FALSE); + npDDEData->isResponseForRequest(TRUE); + npDDEData->setFormat(TextFormat); + npDDEData->setData(npLinkData,sizeData); + ::GlobalUnlock(hGlobalData); + ::GlobalFree(hGlobalData); + ::GlobalUnlock(hGlobalDDEData); + return hGlobalDDEData; +} + +HGLOBAL DDEMessage::copyDDEDataHandle(HGLOBAL hGlobalDDEData) +{ + int sizeData; + HGLOBAL hGlobalData; + DDEData FAR *npDDEData; + char *pReturnData; + + if(!hGlobalDDEData)return (HGLOBAL)FALSE; + npDDEData=(DDEData FAR*)::GlobalLock(hGlobalDDEData); + if(!npDDEData)return (HGLOBAL)FALSE; + sizeData=::GlobalSize(hGlobalDDEData)-(sizeof(DDEDATA)-1); + if(sizeData<=0)return (HGLOBAL)FALSE; + hGlobalData=::GlobalAlloc(GMEM_FIXED,sizeData); + pReturnData=(char FAR*)::GlobalLock(hGlobalData); + ::memcpy(pReturnData,npDDEData->getData(),sizeData); + ::GlobalUnlock(hGlobalDDEData); + ::GlobalUnlock(hGlobalData); + return hGlobalData; +} + +WORD DDEMessage::sendInitiate(String applicationString,String topicString) +{ + LRESULT returnCode(FALSE); + + if(applicationString.isNull()||topicString.isNull())return returnCode; + ATOM atomApplication(::GlobalAddAtom(applicationString)); + ATOM atomTopic(::GlobalAddAtom(topicString)); + mLastDDEMessage=WM_DDE_INITIATE; + returnCode=::SendMessage(HWND_BROADCAST,WM_DDE_INITIATE,(WPARAM)mhClientWnd,MAKELPARAM(atomApplication,atomTopic)); + ::GlobalDeleteAtom(atomApplication); + ::GlobalDeleteAtom(atomTopic); + return returnCode; +} + +WORD DDEMessage::acceptInitiate(String applicationString,String topicString) +{ + if(applicationString.isNull())return FALSE; + if(topicString.isNull())return FALSE; + ATOM atomApplication(::GlobalAddAtom(applicationString)); + ATOM atomTopic(::GlobalAddAtom(topicString)); + mLastDDEMessage=WM_DDE_ACK; + return ::SendMessage(mhServerWnd,WM_DDE_ACK,(WPARAM)mhClientWnd,MAKELPARAM(atomApplication,atomTopic)); +} + +void DDEMessage::cleanup(void) +{ + if(!mhGlobalLastDDEData)return; + ::GlobalUnlock(mhGlobalLastDDEData); + ::GlobalFree(mhGlobalLastDDEData); + mhGlobalLastDDEData=0; +} + +#if defined(__FLAT__) +WORD DDEMessage::postRequest(String requestString) +{ + if(requestString.isNull()||!isValid())return FALSE; + ATOM atomDescription(::GlobalAddAtom(requestString)); + mLastDDEMessage=WM_DDE_REQUEST; + return ::PostMessage(mhServerWnd,WM_DDE_REQUEST,(WPARAM)mhClientWnd,MAKELPARAM(TextFormat,atomDescription)); +} + +WORD DDEMessage::receiveRequest(CallbackData &someCallbackData,String &receiveString) +{ + WORD returnCode(FALSE); + + mLastCallbackData=someCallbackData; + if(!someCallbackData.hiWord())receiveString=mStringUnset; + else + { + receiveString.reserve(MaxLength); + ::GlobalGetAtomName(someCallbackData.hiWord(),receiveString,MaxLength-1); + ::GlobalDeleteAtom(someCallbackData.hiWord()); + returnCode=TRUE; + } + return returnCode; +} + +WORD DDEMessage::postAcknowledge(void) +{ + String ackDescription(mStringUnset); + DDEAck ddeAck; + + return postAcknowledge(ddeAck,ackDescription); +} + +WORD DDEMessage::postAcknowledge(DDEAck someDDEAck,String ackDescription) +{ + if(ackDescription.isNull()||!isValid())return FALSE; + ATOM atomDescription(::GlobalAddAtom(ackDescription)); + LONG packedParam(::PackDDElParam(WM_DDE_ACK,(WORD)someDDEAck,atomDescription)); + if(!packedParam){::GlobalDeleteAtom(atomDescription);return FALSE;} + mLastDDEMessage=WM_DDE_ACK; + return ::PostMessage(mhServerWnd,WM_DDE_ACK,(WPARAM)mhClientWnd,(LPARAM)packedParam); +} + +WORD DDEMessage::receiveAcknowledge(CallbackData &someCallbackData) +{ + UINT packedParamLo(0); + UINT packedParamHi(0); + String stringOne; + String stringTwo; + + mLastCallbackData=someCallbackData; + if(WM_DDE_INITIATE==lastDDEMessage()) + { + if(someCallbackData.loWord())::GlobalDeleteAtom(someCallbackData.loWord()); + if(someCallbackData.hiWord())::GlobalDeleteAtom(someCallbackData.hiWord()); + return TRUE; + } + else + { + stringOne.reserve(MaxLength); + stringTwo.reserve(MaxLength); + ::UnpackDDElParam(WM_DDE_ACK,someCallbackData.lParam(),&packedParamLo,&packedParamHi); + if(packedParamHi) + { + ::GlobalGetAtomName(packedParamHi,stringTwo,MaxLength-1); + if(!stringTwo.isNull())::GlobalDeleteAtom(packedParamHi); + } + ::FreeDDElParam(WM_DDE_ACK,someCallbackData.lParam()); + } + return TRUE; +} + +WORD DDEMessage::postData(HGLOBAL hGlobalData,String stringDescription) +{ + if(!hGlobalData||!isValid())return FALSE; + if(stringDescription.isNull())stringDescription=mStringUnset; + cleanup(); + mhGlobalLastDDEData=buildDDEDataHandle(hGlobalData); + if(!mhGlobalLastDDEData)return FALSE; + ATOM atomDescription(::GlobalAddAtom(stringDescription)); + LPARAM packedParam(::PackDDElParam(WM_DDE_DATA,(UINT)mhGlobalLastDDEData,atomDescription)); + if(!packedParam){::GlobalDeleteAtom(atomDescription);return FALSE;} + mLastDDEMessage=WM_DDE_DATA; + return ::PostMessage(mhServerWnd,WM_DDE_DATA,(WPARAM)mhClientWnd,packedParam); +} + +HGLOBAL DDEMessage::receiveData(CallbackData &someCallbackData) +{ + UINT packedParamLo; + UINT packedParamHi; + HGLOBAL hGlobalDDEData; + + mLastCallbackData=someCallbackData; + ::UnpackDDElParam(WM_DDE_DATA,someCallbackData.lParam(),&packedParamLo,&packedParamHi); + if(packedParamHi)::GlobalDeleteAtom(packedParamHi); + if(packedParamLo)hGlobalDDEData=(HGLOBAL)packedParamLo; + else hGlobalDDEData=(HGLOBAL)FALSE; + ::FreeDDElParam(WM_DDE_DATA,someCallbackData.lParam()); + if(hGlobalDDEData)mhGlobalLastDDEData=copyDDEDataHandle(hGlobalDDEData); + return mhGlobalLastDDEData; +} +#else +WORD DDEMessage::postRequest(String requestorString) +{ + if(requestorString.isNull()||!isValid())return FALSE; + ATOM atomDescription(::GlobalAddAtom(requestorString)); + mLastDDEMessage=WM_DDE_REQUEST; + return ::PostMessage(mhServerWnd,WM_DDE_REQUEST,(WPARAM)mhClientWnd,MAKELPARAM(TextFormat,atomDescription)); +} + +WORD DDEMessage::receiveRequest(CallbackData &someCallbackData,String &receiveString) +{ + WORD returnCode(FALSE); + + mLastCallbackData=someCallbackData; + if(!someCallbackData.hiWord())receiveString=mStringUnset; + else + { + receiveString.reserve(MaxLength); + ::GlobalGetAtomName(someCallbackData.hiWord(),receiveString,MaxLength-1); + ::GlobalDeleteAtom(someCallbackData.hiWord()); + returnCode=TRUE; + } + return returnCode; +} + +WORD DDEMessage::postAcknowledge(void) +{ + String ackDescription(mStringUnset); + DDEAck ddeAck; + + return postAcknowledge(ddeAck,ackDescription); +} + +WORD DDEMessage::postAcknowledge(DDEAck someDDEAck,String ackDescription) +{ + if(ackDescription.isNull())ackDescription=mStringUnset; + ATOM ackAtom(::GlobalAddAtom(ackDescription)); + mLastDDEMessage=WM_DDE_ACK; + return ::PostMessage(mhServerWnd,WM_DDE_ACK,(WPARAM)mhClientWnd,MAKELPARAM((WORD)someDDEAck,ackAtom)); +} + +WORD DDEMessage::receiveAcknowledge(CallbackData &someCallbackData) +{ + String stringOne; + String stringTwo; + UINT packedParamLo; + UINT packedParamHi; + + if(!isValid())return FALSE; + mLastCallbackData=someCallbackData; + if(WM_DDE_INITIATE==lastDDEMessage()) + { + if(someCallbackData.loWord())::GlobalDeleteAtom(someCallbackData.loWord()); + if(someCallbackData.hiWord())::GlobalDeleteAtom(someCallbackData.hiWord()); + return TRUE; + } + stringOne.reserve(MaxLength); + stringTwo.reserve(MaxLength); + if(someCallbackData.loWord()) + { + ::GlobalGetAtomName(someCallbackData.loWord(),stringOne,MaxLength-1); + if(!stringOne.isNull())::GlobalDeleteAtom(someCallbackData.loWord()); + } + if(someCallbackData.hiWord()) + { + ::GlobalGetAtomName(someCallbackData.hiWord(),stringTwo,MaxLength-1); + if(!stringTwo.isNull())::GlobalDeleteAtom(someCallbackData.hiWord()); + } + return TRUE; +} + +WORD DDEMessage::postData(HGLOBAL hGlobalData,String stringDescription) +{ + cleanup(); + if(!hGlobalData||!isValid())return FALSE; + if(stringDescription.isNull())stringDescription=mStringUnset; + cleanup(); + mhGlobalLastDDEData=buildDDEDataHandle(hGlobalData); + if(!mhGlobalLastDDEData)return FALSE; + ATOM atomDescription(::GlobalAddAtom(stringDescription)); + mLastDDEMessage=WM_DDE_DATA; + return ::PostMessage(mhServerWnd,WM_DDE_DATA,(WPARAM)mhClientWnd,MAKELPARAM(mhGlobalLastDDEData,atomDescription)); +} + +HGLOBAL DDEMessage::receiveData(CallbackData &someCallbackData) +{ + HGLOBAL hGlobalDDEData; + + cleanup(); + mLastCallbackData=someCallbackData; + if(someCallbackData.hiWord())::GlobalDeleteAtom(someCallbackData.hiWord()); + if(someCallbackData.loWord())hGlobalDDEData=(HGLOBAL)someCallbackData.loWord(); + else hGlobalDDEData=(HGLOBAL)FALSE; + if(!hGlobalDDEData)return hGlobalDDEData; + return copyDDEDataHandle(hGlobalDDEData); +} +#endif + diff --git a/common/DDEMSG.HPP b/common/DDEMSG.HPP new file mode 100644 index 0000000..512fd31 --- /dev/null +++ b/common/DDEMSG.HPP @@ -0,0 +1,131 @@ +#ifndef _COMMON_DDEMESSAGE_HPP_ +#define _COMMON_DDEMESSAGE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_DDE_HPP_ +#include +#endif +#ifndef _COMMON_DDEACK_HPP_ +#include +#endif +#ifndef _COMMON_DDEDATA_HPP_ +#include +#endif +#ifndef _COMMON_CALLBACK_HPP_ +#include +#endif + +class DDEMessage +{ +public: + DDEMessage(void); + DDEMessage(HWND hClientWnd,HWND hServerWnd); + ~DDEMessage(); + void setClient(HWND hClientWnd); + void setServer(HWND hServerWnd); + WORD postTerminate(void); + WORD receiveTerminate(CallbackData &someCallbackData); + WORD sendInitiate(String applicationString,String topicString); + WORD acceptInitiate(String applicationString,String topicString); + WORD postRequest(String requestString); + WORD receiveRequest(CallbackData &someCallbackData,String &requestString); + WORD postAcknowledge(void); + WORD postAcknowledge(DDEAck someDDEAck,String ackDescription); + WORD receiveAcknowledge(CallbackData &someCallbackData); + WORD postData(HGLOBAL hGlobalData,String stringDescription=String()); + HGLOBAL receiveData(CallbackData &someCallbackData); + DWORD lastDDEMessage(void)const; + CallbackData lastCallbackData(void)const; +private: + enum {MaxLength=250}; + enum Format{TextFormat=CF_TEXT}; + enum Mode{Receive,Send,Post}; + DDEMessage(const DDEMessage &someDDEMessage); + void cleanup(void); + WORD isValid(void)const; + HGLOBAL buildDDEDataHandle(HGLOBAL hGlobalData); + HGLOBAL copyDDEDataHandle(HGLOBAL hGlobalDDEData); + void examineDDEData(HGLOBAL hGlobalDDEData); + + String mStringUnset; + HWND mhServerWnd; + HWND mhClientWnd; + DWORD mLastDDEMessage; + HGLOBAL mhGlobalLastDDEData; + CallbackData mLastCallbackData; +}; + +inline +DDEMessage::DDEMessage(void) +: mhServerWnd(0), mhClientWnd(0), mLastDDEMessage(0L), mhGlobalLastDDEData(0), + mStringUnset("UNSET") +{ +} + +inline +DDEMessage::DDEMessage(HWND hServerWnd,HWND hClientWnd) +: mhServerWnd(hServerWnd), mhClientWnd(hClientWnd), mLastDDEMessage(0L), + mhGlobalLastDDEData(0), mStringUnset("UNSET") +{ +} + +inline +DDEMessage::DDEMessage(const DDEMessage &/*someDDEMessage*/) +{ +} + +inline +DDEMessage::~DDEMessage() +{ + cleanup(); +} + +inline +WORD DDEMessage::isValid(void)const +{ + if(!::IsWindow(mhClientWnd))return FALSE; + if(!::IsWindow(mhServerWnd))return FALSE; + return TRUE; +} + +inline +void DDEMessage::setClient(HWND hClientWnd) +{ + mhClientWnd=hClientWnd; +} + +inline +void DDEMessage::setServer(HWND hServerWnd) +{ + mhServerWnd=hServerWnd; +} + +inline +DWORD DDEMessage::lastDDEMessage(void)const +{ + return mLastDDEMessage; +} + +inline +CallbackData DDEMessage::lastCallbackData(void)const +{ + return mLastCallbackData; +} + +inline +WORD DDEMessage::postTerminate(void) +{ + mLastDDEMessage=WM_DDE_TERMINATE; + return ::PostMessage(mhServerWnd,WM_DDE_TERMINATE,(WPARAM)mhClientWnd,0L); +} + +inline +WORD DDEMessage::receiveTerminate(CallbackData &/*someCallbackData*/) +{ + return TRUE; +} +#endif diff --git a/common/DISKINFO.CPP b/common/DISKINFO.CPP new file mode 100644 index 0000000..ab1453e --- /dev/null +++ b/common/DISKINFO.CPP @@ -0,0 +1,69 @@ +#include + +WORD DiskInfo::getLogicalDrives(Block &driveStrings)const +{ + DWORD driveMask(::GetLogicalDrives()); + BYTE driveChar('A'); + DWORD maskValue(1); + + driveStrings.remove(); + if(!driveMask)return driveMask; + for(DWORD itemIndex=0;itemIndex &driveStrings)const +{ + DWORD driveMask(::GetLogicalDrives()); + BYTE driveChar('A'); + DWORD maskValue(1); + + driveStrings.remove(); + if(!driveMask)return driveMask; + for(DWORD itemIndex=0;itemIndex +#undef enable +#endif + diff --git a/common/DRAWBMP.CPP b/common/DRAWBMP.CPP new file mode 100644 index 0000000..526ded2 --- /dev/null +++ b/common/DRAWBMP.CPP @@ -0,0 +1,68 @@ +#include + +DrawBitmap::DrawBitmap(void) +{ +} + +DrawBitmap::~DrawBitmap() +{ +} + +void DrawBitmap::drawBitmap(HBITMAP hBitmap)const +{ + if(!hBitmap)return; + HWND hFocusWnd(::GetDesktopWindow()); + drawBitmap(hFocusWnd,hBitmap); +} + +void DrawBitmap::drawBitmap(HWND hDrawWindow,HBITMAP hBitmap)const +{ + HDC hDC; + RECT windowRect; + BITMAP bm; + + if(!hBitmap||!hDrawWindow)return; + hDC=::GetDC(hDrawWindow); + ::GetObject(hBitmap,sizeof(BITMAP),(LPSTR)&bm); + ::GetWindowRect(hDrawWindow,(RECT FAR *)&windowRect); + windowRect.left=(((windowRect.right-windowRect.left))/2)-(bm.bmWidth/2)-1; + windowRect.top=(((windowRect.bottom-windowRect.top))/2)-(bm.bmHeight/2)-1; + windowRect.right=bm.bmWidth; + windowRect.bottom=bm.bmHeight; + drawBitmap(hDC,hBitmap,windowRect,FALSE); + ::ReleaseDC(hDrawWindow,hDC); +} + +void DrawBitmap::drawBitmap(HDC hDC,HBITMAP hBitmap,RECT &drawRect,int initRect)const +{ + HDC hMemDC; + + if(!hBitmap)return; + if(initRect) + { + BITMAP bm; + ::GetObject(hBitmap,sizeof(BITMAP),(LPSTR)&bm); + drawRect.left=0; + drawRect.top=0; + drawRect.right=bm.bmWidth; + drawRect.bottom=bm.bmHeight; + } + hMemDC=::CreateCompatibleDC(hDC); + ::SelectObject(hMemDC,hBitmap); + ::BitBlt(hDC,drawRect.left,drawRect.top,drawRect.right,drawRect.bottom,hMemDC,0,0,SRCCOPY); + ::DeleteDC(hMemDC); + return; +} + +void DrawBitmap::centerRect(HBITMAP hBitmap,RECT &windowRect)const +{ + BITMAP bm; + + if(!hBitmap)return; + ::GetObject(hBitmap,sizeof(bm),(LPSTR)&bm); + ::GetWindowRect(::GetDesktopWindow(),(RECT FAR *)&windowRect); + windowRect.left=(((windowRect.right-windowRect.left))/2)-(bm.bmWidth/2)-1; + windowRect.top=(((windowRect.bottom-windowRect.top))/2)-(bm.bmHeight/2)-1; + windowRect.right=bm.bmWidth+2; + windowRect.bottom=bm.bmHeight+2; +} diff --git a/common/DRAWBMP.HPP b/common/DRAWBMP.HPP new file mode 100644 index 0000000..a56272d --- /dev/null +++ b/common/DRAWBMP.HPP @@ -0,0 +1,18 @@ +#ifndef _COMMON_DRAWBITMAP_HPP_ +#define _COMMON_DRAWBITMAP_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class DrawBitmap +{ +public: + DrawBitmap(void); + virtual ~DrawBitmap(); + void drawBitmap(HBITMAP hBitmap)const; + void drawBitmap(HWND hWnd,HBITMAP hBitmap)const; + void drawBitmap(HDC hDC,HBITMAP hBitmap,RECT &drawRect,int initRect=TRUE)const; + void centerRect(HBITMAP hBitmap,RECT &bitmapRect)const; +private: +}; +#endif diff --git a/common/DRAWITEM.HPP b/common/DRAWITEM.HPP new file mode 100644 index 0000000..a978fa4 --- /dev/null +++ b/common/DRAWITEM.HPP @@ -0,0 +1,227 @@ +#ifndef _COMMON_DRAWITEM_HPP_ +#define _COMMON_DRAWITEM_HPP_ +#ifndef _COMMON_STDLIB_HPP_ +#include +#endif +#ifndef _COMMON_COMMCTRL_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_RECTANGLE_HPP_ +#include +#endif + +class DrawItem : private DRAWITEMSTRUCT +{ +public: + enum ItemAction{Select=ODA_SELECT,DrawEntire=ODA_DRAWENTIRE,Focus=ODA_FOCUS}; + enum ControlType{Button=ODT_BUTTON,ComboBox=ODT_COMBOBOX,ListBox=ODT_LISTBOX,ListView=ODT_LISTVIEW,Menu=ODT_MENU,Static=ODT_STATIC,Tab=ODT_TAB}; + DrawItem(void); + DrawItem(const DrawItem &someDrawItem); + DrawItem(const DRAWITEMSTRUCT &someDRAWITEMSTRUCT); + virtual ~DrawItem(); + DrawItem &operator=(const DrawItem &someDrawItem); + DrawItem &operator=(const DRAWITEMSTRUCT &someDRAWITEMSTRUCT); + WORD operator==(const DrawItem &someDrawItem); + ControlType controlType(void)const; + void controlType(ControlType controlType); + UINT controlID(void)const; + void controlID(UINT controlID); + UINT itemID(void)const; + void itemID(UINT itemID); + ItemAction itemAction(void)const; + void itemAction(ItemAction itemAction); + UINT itemState(void)const; + void itemState(UINT itemState); + HWND hwndItem(void)const; + void hwndItem(HWND hwndItem); + HDC deviceContext(void)const; + void deviceContext(HDC hDeviceContext); + Rect rectItem(void)const; + void rectItem(const Rect &rectItem); + DWORD itemData(void)const; + void itemData(DWORD itemData); +private: + void setZero(void); +}; + +inline +DrawItem::DrawItem(void) +{ + setZero(); +} + +inline +DrawItem::DrawItem(const DrawItem &someDrawItem) +{ + *this=someDrawItem; +} + + +inline +DrawItem::DrawItem(const DRAWITEMSTRUCT &someDRAWITEMSTRUCT) +{ + *this=someDRAWITEMSTRUCT; +} + +inline +DrawItem::~DrawItem() +{ +} + +inline +DrawItem &DrawItem::operator=(const DrawItem &someDrawItem) +{ + controlType(someDrawItem.controlType()); + controlID(someDrawItem.controlID()); + itemID(someDrawItem.itemID()); + itemAction(someDrawItem.itemAction()); + itemState(someDrawItem.itemState()); + hwndItem(someDrawItem.hwndItem()); + deviceContext(someDrawItem.deviceContext()); + rectItem(someDrawItem.rectItem()); + itemData(someDrawItem.itemData()); + return *this; +} + +inline +DrawItem &DrawItem::operator=(const DRAWITEMSTRUCT &someDRAWITEMSTRUCT) +{ + ::memcpy(&((DRAWITEMSTRUCT&)*this),&someDRAWITEMSTRUCT,sizeof(DRAWITEMSTRUCT)); + return *this; +} + +inline +WORD DrawItem::operator==(const DrawItem &someDrawItem) +{ + return (controlType()==someDrawItem.controlType()&& + controlID()==someDrawItem.controlID()&& + itemID()==someDrawItem.itemID()&& + itemAction()==someDrawItem.itemAction()&& + itemState()==someDrawItem.itemState()&& + hwndItem()==someDrawItem.hwndItem()&& + deviceContext()==someDrawItem.deviceContext()&& + rectItem()==someDrawItem.rectItem()&& + itemData()==someDrawItem.itemData()); +} + + +inline +DrawItem::ControlType DrawItem::controlType(void)const +{ + return (ControlType)DRAWITEMSTRUCT::CtlType; +} + +inline +void DrawItem::controlType(ControlType controlType) +{ + DRAWITEMSTRUCT::CtlType=(ControlType)controlType; +} + +inline +UINT DrawItem::controlID(void)const +{ + return DRAWITEMSTRUCT::CtlID; +} + +inline +void DrawItem::controlID(UINT controlID) +{ + DRAWITEMSTRUCT::CtlID=controlID; +} + +inline +UINT DrawItem::itemID(void)const +{ + return DRAWITEMSTRUCT::itemID; +} + +inline +void DrawItem::itemID(UINT itemID) +{ + DRAWITEMSTRUCT::itemID; +} + +inline +DrawItem::ItemAction DrawItem::itemAction(void)const +{ + return (ItemAction)DRAWITEMSTRUCT::itemAction; +} + +inline +void DrawItem::itemAction(ItemAction itemAction) +{ + DRAWITEMSTRUCT::itemAction=(UINT)itemAction; +} + +inline +UINT DrawItem::itemState(void)const +{ + return DRAWITEMSTRUCT::itemState; +} + +inline +void DrawItem::itemState(UINT itemState) +{ + DRAWITEMSTRUCT::itemState=itemState; +} + +inline +HWND DrawItem::hwndItem(void)const +{ + return DRAWITEMSTRUCT::hwndItem; +} + +inline +void DrawItem::hwndItem(HWND hwndItem) +{ + DRAWITEMSTRUCT::hwndItem=hwndItem; +} + +inline +HDC DrawItem::deviceContext(void)const +{ + return DRAWITEMSTRUCT::hDC; +} + +inline +void DrawItem::deviceContext(HDC hDeviceContext) +{ + DRAWITEMSTRUCT::hDC=hDeviceContext; +} + +inline +Rect DrawItem::rectItem(void)const +{ + return DRAWITEMSTRUCT::rcItem; +} + +inline +void DrawItem::rectItem(const Rect &rectItem) +{ + DRAWITEMSTRUCT::rcItem.left=rectItem.left(); + DRAWITEMSTRUCT::rcItem.top=rectItem.top(); + DRAWITEMSTRUCT::rcItem.right=rectItem.right(); + DRAWITEMSTRUCT::rcItem.bottom=rectItem.bottom(); +} + +inline +DWORD DrawItem::itemData(void)const +{ + return DRAWITEMSTRUCT::itemData; +} + +inline +void DrawItem::itemData(DWORD itemData) +{ + DRAWITEMSTRUCT::itemData=itemData; +} + +inline +void DrawItem::setZero(void) +{ + ::memset(&(DRAWITEMSTRUCT&)*this,0,sizeof(DRAWITEMSTRUCT)); +} +#endif diff --git a/common/DWINDOW.CPP b/common/DWINDOW.CPP new file mode 100644 index 0000000..7d300d0 --- /dev/null +++ b/common/DWINDOW.CPP @@ -0,0 +1,209 @@ +#include +#include +#include +#include +#include + +DWindow::~DWindow() +{ +} + +bool DWindow::createDialogParam(GUIWindow &frameWindow,GUIWindow &parentWindow,const String &strTemplate,LPARAM param) +{ + if(isValid()||!frameWindow.isValid()||!parentWindow.isValid()||strTemplate.isNull())return false; + mFrameWindow=&frameWindow; + mFrameWindow.disposition(PointerDisposition::Assume); + setHandle(::CreateDialogParam(parentWindow.processInstance(),(LPSTR)(String&)strTemplate,parentWindow,DWindow::DlgProc,param)); + if(!isValid())return false; + mFrameWindow->insertModelessDialog(*this); + return true; +} + +bool DWindow::createDialogParam(GUIWindow &parentWindow,const String &strTemplate,LPARAM param) +{ + if(isValid()||!parentWindow.isValid()||strTemplate.isNull())return false; + mFrameWindow=&parentWindow; + mFrameWindow.disposition(PointerDisposition::Assume); + setHandle(::CreateDialogParam(parentWindow.processInstance(),(LPSTR)(String&)strTemplate,parentWindow,DWindow::DlgProc,param)); + if(!isValid())return false; + mFrameWindow->insertModelessDialog(*this); + return true; +} + +String DWindow::getText(UINT controlID)const +{ + String strText; + getText(controlID,strText); + return strText; +} + +WORD DWindow::getText(UINT controlID,String &textString)const +{ + WORD returnCode(FALSE); + String workString; + + if(!isValid())return returnCode; + returnCode=::GetDlgItemText(*this,controlID,workString,String::MaxString); + textString=workString; + return returnCode; +} + +void DWindow::setText(UINT controlID,const String &setText)const +{ + if(!isValid())return; + ::SetDlgItemText(*this,controlID,(LPCTSTR)(LPSTR)((String&)setText)); +} + +BOOL DWindow::setInt(UINT controlID,int value)const +{ + if(!isValid())return FALSE; + return ::SetDlgItemInt(*this,controlID,value,TRUE); +} + +BOOL DWindow::getInt(UINT controlID,int &value)const +{ + BOOL returnCode(FALSE); + + if(!isValid())return returnCode; + value=::GetDlgItemInt(*this,controlID,&returnCode,TRUE); + return returnCode; +} + +int DWindow::windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam) +{ + if(message>=WM_USER&&message<=0x7FFF)return (int)callHandlers(VectorHandler::UserHandler,CallbackData(message,lParam,hWnd)); + switch(message) + { + case WM_CLOSE : + return (int)callHandlers(VectorHandler::CloseHandler,CallbackData(wParam,lParam,hWnd)); + case WM_TIMER : + return (int)callHandlers(VectorHandler::TimerHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHANGECBCHAIN : + return (int)callHandlers(VectorHandler::ChangeCBChainHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWCLIPBOARD : + return (int)callHandlers(VectorHandler::DrawClipboardHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMMAND : + return callHandlers(VectorHandler::CommandHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMPACTING : + return callHandlers(VectorHandler::CompactingHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ERASEBKGND : + return callHandlers(VectorHandler::EraseBackgroundHandler,CallbackData(wParam,lParam,hWnd)); + case WM_WININICHANGE : + return callHandlers(VectorHandler::WinIniChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SYSCOLORCHANGE : + return callHandlers(VectorHandler::SysColorChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDBLCLK : + return callHandlers(VectorHandler::LeftButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDOWN : + return callHandlers(VectorHandler::LeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONUP : + return callHandlers(VectorHandler::LeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDBLCLK : + return callHandlers(VectorHandler::RightButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDOWN : + return callHandlers(VectorHandler::RightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONUP : + return callHandlers(VectorHandler::RightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONUP : + return callHandlers(VectorHandler::NCLeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONDOWN : + return callHandlers(VectorHandler::NCLeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONUP : + return callHandlers(VectorHandler::NCRightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONDOWN : + return callHandlers(VectorHandler::NCRightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFOCUS : + return callHandlers(VectorHandler::SetFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFONT : + return callHandlers(VectorHandler::SetFontHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KILLFOCUS : + return callHandlers(VectorHandler::KillFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOR : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORMSGBOX : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOREDIT : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORLISTBOX : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORBTN : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORDLG : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSCROLLBAR : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSTATIC : + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYUP : + return callHandlers(VectorHandler::KeyUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYDOWN : + return callHandlers(VectorHandler::KeyDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETMINMAXINFO : + return callHandlers(VectorHandler::MinMaxHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ENTERIDLE : + return callHandlers(VectorHandler::EnterIdleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MENUSELECT : + return callHandlers(VectorHandler::MenuSelectHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ACTIVATEAPP : + return callHandlers(VectorHandler::ActivateAppHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DISPLAYCHANGE : + return callHandlers(VectorHandler::DisplayChangeHandler,CallbackData(wParam,lParam,hWnd)); +#if defined(__FLAT__) + case WM_NOTIFY : + return callHandlers(VectorHandler::NotifyHandler,CallbackData(wParam,lParam,hWnd)); +#endif + case WM_SIZE : + return callHandlers(VectorHandler::SizeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PAINT : + return handlePaintMessage(hWnd,message,wParam,lParam); + case WM_DRAWITEM : + return callHandlers(VectorHandler::DrawItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHAR : + return callHandlers(VectorHandler::CharHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_INITIATE : + return callHandlers(VectorHandler::DDEInitiateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_ACK : + return callHandlers(VectorHandler::DDEAckHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_REQUEST : + return callHandlers(VectorHandler::DDERequestHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_TERMINATE : + return callHandlers(VectorHandler::DDETerminateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_DATA : + return callHandlers(VectorHandler::DDEDataHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_OPEN : + return callHandlers(VectorHandler::MMOpenHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_CLOSE : + return callHandlers(VectorHandler::MMCloseHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_DONE : + return callHandlers(VectorHandler::MMDoneHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MOUSEMOVE : + return callHandlers(VectorHandler::MouseMoveHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETDLGCODE : + return callHandlers(VectorHandler::DialogCodeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MEASUREITEM : + return callHandlers(VectorHandler::MeasureItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_HSCROLL : + return callHandlers(VectorHandler::HorizontalScrollHandler,CallbackData(wParam,lParam,hWnd)); + case WM_VSCROLL : + return callHandlers(VectorHandler::VerticalScrollHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DROPFILES : + return callHandlers(VectorHandler::DropFilesHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MDIACTIVATE : + return callHandlers(VectorHandler::MDIActivateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SHOWWINDOW : + return callHandlers(VectorHandler::ShowWindowHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CAPTURECHANGED : + return callHandlers(VectorHandler::CaptureChangedHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DEVICECHANGE : + return callHandlers(VectorHandler::DeviceChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DESTROY : + callHandlers(VectorHandler::DestroyHandler,CallbackData(wParam,lParam,hWnd)); + InstanceData::removeInstanceData(hWnd); + if(mFrameWindow.isOkay())mFrameWindow->removeModelessDialog(*this); + setHandle(0); + return FALSE; + case WM_NCDESTROY : + default : + return FALSE; + } +} diff --git a/common/Dib.cpp b/common/Dib.cpp new file mode 100644 index 0000000..5e4995d --- /dev/null +++ b/common/Dib.cpp @@ -0,0 +1,310 @@ +#include +#include +#include +#include +#include +#include + +void DIBitmap::createBitmap(const PureDevice &somePureDevice) +{ + destroyBitmap(); + mhBitmap=::CreateDIBSection(somePureDevice,(BITMAPINFO*)(static_cast(*this)),DIB_RGB_COLORS,&mlpBmBits,(HANDLE)0,0L); + if(!mhBitmap)::GetLastError(); + if(mhBitmap)mImageExtent=BitmapInfo::imageExtent(); +} + +void DIBitmap::createBitmap(void) +{ + destroyBitmap(); + mhBitmap=::CreateDIBSection((HDC)0,(BITMAPINFO*)(static_cast(*this)),DIB_RGB_COLORS,&mlpBmBits,(HANDLE)0,0L); + if(mhBitmap)mImageExtent=BitmapInfo::imageExtent(); +} + +WORD DIBitmap::size(DWORD newWidth,DWORD newHeight) +{ + if(!isOkay())return FALSE; + verifyDimensions(newWidth,newHeight); + width(newWidth); + height(newHeight); + createBitmap(mBitmapDevice); + mBitmapDevice.select(mhBitmap); + return isOkay(); +} + +void DIBitmap::verifyDimensions(DWORD &desiredWidth,DWORD desiredHeight)const +{ + DWORD imageExtent; + + imageExtent=(((((LONG)desiredWidth*8)+31)&~31)>>3)*(LONG)desiredHeight; + if(imageExtent==(LONG)desiredWidth*(LONG)desiredHeight)return; + desiredWidth=(WORD)(imageExtent/(LONG)desiredHeight); +} + +void DIBitmap::setBits(BYTE charByte) +{ + if(!charByte)clearBits(); + BYTE *lpImagePtr=(BYTE*)mlpBmBits; + for(DWORD ptrIndex=0;ptrIndex>2; + DWORD numBytes=0; + int *ptrSrcDataInt=0; + int *ptrDstDataInt=0; + char *ptrSrcDataChar; + char *ptrDstDataChar; + + if(!writeExtent)return false; + numBytes=(writeExtent%writeExtent); + ptrSrcDataInt=(int*)ptrDataChar; + ptrDstDataInt=(int*)mlpBmBits; + for(DWORD count=0;count &bitmap,const Rect &areaRect) +{ + bitmap.destroy(); + bitmap=::new DIBitmap(getDevice(),areaRect.width(),areaRect.height(),getPalette()); + bitmap.disposition(PointerDisposition::Delete); + for(int col=areaRect.left(),dstCol=0;col<=areaRect.right();col++,dstCol++) + { + for(int row=areaRect.top(),dstRow=0;row<=areaRect.bottom();row++,dstRow++) + { + bitmap->setByte(dstRow,dstCol,getByte(row,col)); + } + } + return true; +} + +bool DIBitmap::overlay(Bitmap &bitmap,const Point &placementPoint) +{ + return overlay(placementPoint,bitmap.width(),bitmap.height(),bitmap.getDataPtr()); +} + +bool DIBitmap::overlay(ResBitmap &resBitmap,const Point &placementPoint) +{ + return overlay(placementPoint,resBitmap.width(),resBitmap.height(),resBitmap.ptrData()); +} + +bool DIBitmap::overlay(DIBitmap &bitmap,const Point &placementPoint) +{ + return overlay(placementPoint,bitmap.width(),bitmap.height(),(unsigned char*)bitmap.ptrData()); +} + +bool DIBitmap::overlay(const Point &placementPoint,int srcWidth,int srcHeight,UCHAR *pBmBits) +{ + DWORD newSrcY; + DWORD newDstY; + DWORD srcIndex; + DWORD dstIndex; + UINT srcRow; + UINT srcCol; + + if(!isOkay())return false; + if(srcWidth>width())srcWidth=width(); + if(srcHeight>height())srcHeight=height(); + for(srcRow=0;srcRow>0x10,xRunning>>0x10,byteValue); + xRunning-=xDelta; + yRunning-=yDelta; + } + } + else if(-1==xDir&&1==yDir) + { + for(short stepIndex=0;stepIndex>0x10,xRunning>>0x10,byteValue); + xRunning-=xDelta; + yRunning+=yDelta; + } + } + else if(1==xDir&&-1==yDir) + { + for(short itemIndex=0;itemIndex>0x10,xRunning>>0x10,byteValue); + xRunning+=xDelta; + yRunning-=yDelta; + } + } + else if(1==xDir&&1==yDir) + { + for(short itemIndex=0;itemIndex>0x10,xRunning>>0x10,byteValue); + xRunning+=xDelta; + yRunning+=yDelta; + } + } +} + +WORD DIBitmap::square(const Point ¢erPoint,WORD lineLength,BYTE palIndex) +{ + WORD halfLength(lineLength>>0x01); + Point topLeft; + Point topRight; + Point bottomLeft; + Point bottomRight; + + if(!isOkay())return FALSE; + topLeft.x(centerPoint.x()-halfLength); + topLeft.y(centerPoint.y()-halfLength); + topRight.x(centerPoint.x()+halfLength); + topRight.y(centerPoint.y()-halfLength); + bottomRight.x(centerPoint.x()+halfLength); + bottomRight.y(centerPoint.y()+halfLength); + bottomLeft.x(centerPoint.x()-halfLength); + bottomLeft.y(centerPoint.y()+halfLength); + line(topLeft,topRight,palIndex); + line(topRight,bottomRight,palIndex); + line(bottomRight,bottomLeft,palIndex); + line(bottomLeft,topLeft,palIndex); + return TRUE; +} + +WORD DIBitmap::circle(WORD aspectValue,const Point &xyPoint,WORD radius,WORD palIndex) +{ + int a(radius); + int af; + int bf; + int b(0); + int target(1); + int radiusSquared(radius*radius); + + if(!isOkay())return FALSE; + while(a>=b) + { + b=(int)(Math::sqrt(radiusSquared-(a*a))+.50); + int temp(target); + target=b; + b=temp; + while(b +#endif +#ifndef _COMMON_BITMAPINFO_HPP_ +#include +#endif +#ifndef _COMMON_PUREPALETTE_HPP_ +#include +#endif +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif +#ifndef _COMMON_SMARTPOINTER_HPP_ +#include +#endif + +class BitmapOverlay; +class Bitmap; +class ResBitmap; +class Vector2D; +class Point; + +class DIBitmap : public BitmapInfo +{ +public: + DIBitmap(const PureDevice &pureDevice,DWORD bmWidth,DWORD bmHeight,const PurePalette &purePalette); + DIBitmap(const PureDevice &pureDevice,const BitmapInfo &someBitmapInfo,const PurePalette &purePalette); + DIBitmap(const BitmapInfo &someBitmapInfo); + DIBitmap(const DIBitmap &someDIBitmap); + virtual ~DIBitmap(); + DIBitmap &operator=(const DIBitmap &someDIBitmap); + DIBitmap &operator+=(BitmapOverlay &someBitmapOverlay); + bool overlay(Bitmap &bitmap,const Point &placementPoint); + bool overlay(ResBitmap &resBitmap,const Point &placementPoint); + bool overlay(DIBitmap &bitmap,const Point &placementPoint); + bool getAt(SmartPointer &bitmap,const Rect &areaRect); + void setByte(WORD row,WORD col,BYTE byteValue); + BYTE getByte(WORD row,WORD col)const; + void line(const Point &firstPoint,const Point &secondPoint,BYTE byteValue); + void outlineRect(const Rect &outlineRect,BYTE byteValue=0); + void colorRect(const Rect &rect,BYTE byteValue=0); + WORD square(const Point ¢erPoint,WORD lineLength,const RGBColor &lineColor); + WORD square(const Point ¢erPoint,WORD lineLength,BYTE indexColor); + WORD circle(WORD aspectValue,const Point &xyPoint,WORD radius,WORD palIndex); + WORD bitBlt(PureDevice &displayDevice,PureDevice::BltMode ropCode=PureDevice::SourceCopy); + WORD bitBlt(PureDevice &displayDevice,const Rect &dstRect,const Point &srcPoint,PureDevice::BltMode ropCode=PureDevice::SourceCopy); + WORD bitBlt(PureDevice &displayDevice,const Point &srcPoint,PureDevice::BltMode ropCode=PureDevice::SourceCopy); + BOOL stretchBlt(PureDevice &displayDevice,const Rect &dstRect,PureDevice::BltMode ropCode=PureDevice::SourceCopy); + void setBits(BYTE charByte); + bool copyBits(unsigned char *ptrData,DWORD length); + void clearBits(void); + WORD size(DWORD newWidth,DWORD newHeight); + void *ptrData(void); + DWORD imageExtent(void)const; + BOOL usePalette(BOOL usage); + BOOL usePalette(PureDevice &pureDevice,BOOL usage); + WORD isOkay(void)const; + PurePalette &getPalette(void); + PureDevice &getDevice(void); + HBITMAP getBitmap(void); +private: + bool overlay(const Point &placementPoint,int srcWidth,int srcHeight,UCHAR *pBmBits); + void copyBits(unsigned char *lpDstPtr,unsigned char *lpSrcPtr,DWORD length)const; + void createBitmap(const PureDevice &somePureDevice); + void createBitmap(void); + void destroyBitmap(void); + void verifyDimensions(DWORD &desiredWidth,DWORD desiredHeight)const; + + HBITMAP mhBitmap; + void *mlpBmBits; + DWORD mImageExtent; + PureDevice mBitmapDevice; + PurePalette mBitmapPalette; +}; + +inline +DIBitmap::DIBitmap(const DIBitmap &someDIBitmap) +: mhBitmap(0), mImageExtent(0), mlpBmBits(0) +{ + *this=someDIBitmap; +} + +inline +DIBitmap::DIBitmap(const PureDevice &somePureDevice,DWORD bmWidth,DWORD bmHeight,const PurePalette &purePalette) +: mhBitmap(0), mImageExtent(0), mlpBmBits(0) +{ + verifyDimensions(bmWidth,bmHeight); + width(bmWidth); + height(bmHeight); + static_cast(*this)=purePalette; + mBitmapPalette=purePalette; + createBitmap(somePureDevice); + if(!isOkay())return; + mBitmapDevice.compatibleDevice(somePureDevice); + mBitmapDevice.select(mhBitmap); +} + +inline +DIBitmap::DIBitmap(const PureDevice &somePureDevice,const BitmapInfo &someBitmapInfo,const PurePalette &purePalette) +: mhBitmap(0), mImageExtent(0), mlpBmBits(0), BitmapInfo(someBitmapInfo) +{ + DWORD bmWidth(width()); + DWORD bmHeight(height()); + verifyDimensions(bmWidth,bmHeight); + width(bmWidth); + height(bmHeight); + static_cast(*this)=purePalette; + mBitmapPalette=purePalette; + createBitmap(somePureDevice); + if(!isOkay())return; + mBitmapDevice.compatibleDevice(somePureDevice); + mBitmapDevice.select(mhBitmap); +} + +inline +DIBitmap::DIBitmap(const BitmapInfo &someBitmapInfo) +: mhBitmap(0), mImageExtent(0), mlpBmBits(0), BitmapInfo(someBitmapInfo) +{ + DWORD bmWidth(width()); + DWORD bmHeight(height()); + verifyDimensions(bmWidth,bmHeight); + width(bmWidth); + height(bmHeight); + createBitmap(); + if(!isOkay())return; +} + +inline +DIBitmap::~DIBitmap() +{ + if(isOkay())mBitmapDevice.select(mhBitmap,FALSE); + destroyBitmap(); +} + +inline +DIBitmap &DIBitmap::operator=(const DIBitmap &someDIBitmap) +{ + destroyBitmap(); + (BitmapInfo&)*this=(BitmapInfo&)someDIBitmap; + mBitmapPalette=((DIBitmap&)someDIBitmap).getPalette(); + createBitmap(someDIBitmap.mBitmapDevice); + if(!isOkay())return *this; + copyBits((unsigned char*)ptrData(),(unsigned char*)((DIBitmap&)someDIBitmap).ptrData(),imageExtent()); + mBitmapDevice.compatibleDevice(someDIBitmap.mBitmapDevice); + mBitmapDevice.select(mhBitmap); + return *this; +} + +inline +void DIBitmap::destroyBitmap(void) +{ + if(!mhBitmap)return; + mBitmapDevice.select(mhBitmap,FALSE); + ::DeleteObject(mhBitmap); + mhBitmap=0; + mlpBmBits=0; + mImageExtent=0; +} + +inline +void DIBitmap::setByte(WORD row,WORD col,BYTE byteValue) +{ + if(!isOkay()||row>=height()||col>=width())return; + BYTE *lpImage=(BYTE*)mlpBmBits+width()*height(); + *((lpImage-((LONG)row*width()+width()))+(LONG)col)=byteValue; +} + +inline +BYTE DIBitmap::getByte(WORD row,WORD col)const +{ + if(!isOkay()||row>=height()||col>=width())return (BYTE)FALSE; + BYTE *lpImage=(BYTE*)mlpBmBits+width()*height(); + return *((lpImage-((LONG)row*width()+width()))+(LONG)col); +} + +inline +WORD DIBitmap::bitBlt(PureDevice &displayDevice,PureDevice::BltMode ropCode) +{ + if(!isOkay())return FALSE; + return ::BitBlt(displayDevice,0,0,width(),height(),mBitmapDevice,0,0,ropCode); +} + +inline +WORD DIBitmap::bitBlt(PureDevice &displayDevice,const Point &srcPoint,PureDevice::BltMode ropCode) +{ + if(!isOkay())return FALSE; + return ::BitBlt(displayDevice,0,0,width(),height(),mBitmapDevice,srcPoint.x(),srcPoint.y(),ropCode); +} + +inline +WORD DIBitmap::bitBlt(PureDevice &displayDevice,const Rect &dstRect,const Point &srcPoint,PureDevice::BltMode ropCode) +{ + if(!isOkay())return FALSE; + return ::BitBlt(displayDevice,dstRect.left(),dstRect.top(),dstRect.right(),dstRect.bottom(),mBitmapDevice,srcPoint.x(),srcPoint.y(),ropCode); +} + +inline +BOOL DIBitmap::stretchBlt(PureDevice &displayDevice,const Rect &dstRect,PureDevice::BltMode ropCode) +{ + if(!isOkay())return FALSE; + return ::StretchBlt(displayDevice,dstRect.left(),dstRect.top(),dstRect.right(),dstRect.bottom(),mBitmapDevice,0,0,width(),height(),ropCode); +} + +inline +void *DIBitmap::ptrData(void) +{ + if(!mlpBmBits)throw(NullError()); + return mlpBmBits; +} + +inline +DWORD DIBitmap::imageExtent(void)const +{ + return mImageExtent; +} + +inline +WORD DIBitmap::square(const Point ¢erPoint,WORD lineLength,const RGBColor &lineColor) +{ + return square(centerPoint,lineLength,mBitmapPalette.paletteIndex(lineColor)); +} + +inline +WORD DIBitmap::isOkay(void)const +{ + return (mhBitmap?TRUE:FALSE); +} + +inline +PurePalette &DIBitmap::getPalette(void) +{ + return mBitmapPalette; +} + +inline +PureDevice &DIBitmap::getDevice(void) +{ + return mBitmapDevice; +} + +inline +HBITMAP DIBitmap::getBitmap(void) +{ + return mhBitmap; +} + +inline +BOOL DIBitmap::usePalette(BOOL usage) +{ + if(!isOkay()||!mBitmapDevice.isOkay())return FALSE; + mBitmapPalette.usePalette(mBitmapDevice,usage); + return TRUE; +} + +inline +BOOL DIBitmap::usePalette(PureDevice &pureDevice,BOOL usage) +{ + if(!isOkay())return FALSE; + mBitmapPalette.usePalette(pureDevice,usage); + return TRUE; +} +#endif diff --git a/common/Diskinfo.hpp b/common/Diskinfo.hpp new file mode 100644 index 0000000..9bf043c --- /dev/null +++ b/common/Diskinfo.hpp @@ -0,0 +1,112 @@ +#ifndef _COMMON_DISKINFO_HPP_ +#define _COMMON_DISKINFO_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_FINDDATA_HPP_ +#include +#endif + +class DiskInfo : public FindData +{ +public: + enum DriveType{DriveUnknown=0,DriveNoRoot=1,DriveRemovable=DRIVE_REMOVABLE,DriveFixed=DRIVE_FIXED,DriveRemote=DRIVE_REMOTE,DriveCDROM=DRIVE_CDROM,DriveRamDisk=DRIVE_RAMDISK}; + DiskInfo(void); + virtual ~DiskInfo(); + DWORD getDiskFreeSpace(String pathFileName=String())const; + DWORD getDiskUsage(String pathFileName=String())const; + DWORD getCurrentDirectory(String ¤tDirectory)const; + DWORD setCurrentDirectory(const String ¤tDirectory)const; + WORD createDirectory(const String &pathDirectoryName)const; + WORD getLogicalDrives(Block &driveStrings)const; + WORD getFixedLogicalDrives(Block &driveStrings)const; + DriveType getDriveType(String pathFileName=String())const; + bool unlink(const String &pathFileName)const; + BOOL copyFile(const String &strExistingFile,const String &strNewFile,BOOL overwrite=TRUE); + BOOL rename(const String &strExistingFileName,const String &strNewFile); +private: + String rootPath(String pathFileName)const; +}; + +inline +DiskInfo::DiskInfo(void) +{ +} + +inline +DiskInfo::~DiskInfo() +{ +} + +inline +DWORD DiskInfo::getDiskFreeSpace(String pathFileName)const +{ + DWORD sectorsPerCluster; + DWORD bytesPerSector; + DWORD freeClusters; + DWORD totalClusters; + + pathFileName=rootPath(pathFileName); + if(!::GetDiskFreeSpace((pathFileName.isNull()?(LPSTR)0:(LPSTR)pathFileName),§orsPerCluster,&bytesPerSector,&freeClusters,&totalClusters))return FALSE; + return freeClusters*sectorsPerCluster*bytesPerSector; +} + +inline +DWORD DiskInfo::getDiskUsage(String pathFileName)const +{ + DWORD sectorsPerCluster; + DWORD bytesPerSector; + DWORD freeClusters; + DWORD totalClusters; + + pathFileName=rootPath(pathFileName); + if(!::GetDiskFreeSpace((pathFileName.isNull()?(LPSTR)0:(LPSTR)pathFileName),§orsPerCluster,&bytesPerSector,&freeClusters,&totalClusters))return FALSE; + return (totalClusters*sectorsPerCluster*bytesPerSector)-(freeClusters*sectorsPerCluster*bytesPerSector); +} + +inline +DWORD DiskInfo::setCurrentDirectory(const String ¤tDirectory)const +{ + if(currentDirectory.isNull())return FALSE; + return ::SetCurrentDirectory((LPSTR)currentDirectory); +} + +inline +WORD DiskInfo::createDirectory(const String &pathDirectoryName)const +{ + if(pathDirectoryName.isNull())return FALSE; + return ::CreateDirectory(pathDirectoryName,(LPSECURITY_ATTRIBUTES)0); +} + +inline +String DiskInfo::rootPath(String pathFileName)const +{ + String rootPath; + + if(pathFileName.isNull())return rootPath; + rootPath=pathFileName.betweenString(0,'\\'); + rootPath+="\\"; + return rootPath; +} + +inline +DiskInfo::DriveType DiskInfo::getDriveType(String pathFileName)const +{ + pathFileName=rootPath(pathFileName); + return (DriveType)::GetDriveType((pathFileName.isNull()?(LPSTR)0:(LPSTR)pathFileName)); +} + +inline +bool DiskInfo::unlink(const String &pathFileName)const +{ + if(pathFileName.isNull())return false; + if(DriveCDROM==getDriveType(pathFileName))return false; + return ::DeleteFile(pathFileName); +} +#endif diff --git a/common/Dwindow.hpp b/common/Dwindow.hpp new file mode 100644 index 0000000..5bfb2a0 --- /dev/null +++ b/common/Dwindow.hpp @@ -0,0 +1,106 @@ +#ifndef _COMMON_DWINDOW_HPP_ +#define _COMMON_DWINDOW_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_SMARTPOINTER_HPP_ +#include +#endif +#ifndef _COMMON_GUIWINDOW_HPP_ +#include +#endif + +class Rect; +class String; + +class DWindow : public GUIWindow +{ +public: + DWindow(void); + virtual ~DWindow(); + bool createDialogParam(GUIWindow &frameWindow,GUIWindow &parentWindow,const String &strTemplate,LPARAM param); + bool createDialogParam(GUIWindow &parentWindow,const String &strTemplate,LPARAM param); + HWND getItem(int controlID)const; + LRESULT sendMessage(DWORD controlID,UINT message,WPARAM wParam,LPARAM lParam)const; + LRESULT postMessage(DWORD controlID,UINT message,WPARAM wParam,LPARAM lParam)const; + void setText(UINT controlID,const String &setText)const; + WORD getText(UINT controlID,String &textString)const; + String getText(UINT controlID)const; + BOOL setInt(UINT controlID,int value)const; + BOOL getInt(UINT controlID,int &value)const; + WORD enable(UINT controlID,WORD isEnabled)const; + void setFocus(UINT controlID)const; + bool show(UINT controlID,int nCmdShow=SW_SHOW)const; +protected: + void endDialog(WORD returnCode); + virtual int windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam); +private: + DWindow(const DWindow &someDWindow); + DWindow &operator=(const DWindow &someDWindow); + + SmartPointer mFrameWindow; +}; + +inline +DWindow::DWindow(void) +{ +} + +inline +DWindow::DWindow(const DWindow &someDWindow) +: GUIWindow(someDWindow) // private implementation +{ +} + +inline +DWindow &DWindow::operator=(const DWindow &someDWindow) +{ // private implementation + return *this; +} + +inline +HWND DWindow::getItem(int controlID)const +{ + if(!isValid())return FALSE; + return ::GetDlgItem(*this,controlID); +} + +inline +void DWindow::setFocus(UINT controlID)const +{ + ::SetFocus(getItem(controlID)); +} + +inline +bool DWindow::show(UINT controlID,int nCmdShow)const +{ + return ::ShowWindow(getItem(controlID),nCmdShow); +} + +inline +LRESULT DWindow::sendMessage(DWORD controlID,UINT message,WPARAM wParam,LPARAM lParam)const +{ + if(!isValid())return FALSE; + return ::SendMessage(getItem(controlID),message,wParam,lParam); +} + +inline +LRESULT DWindow::postMessage(DWORD controlID,UINT message,WPARAM wParam,LPARAM lParam)const +{ + if(!isValid())return FALSE; + return ::PostMessage(::GetDlgItem(*this,controlID),message,wParam,lParam); +} + +inline +WORD DWindow::enable(UINT controlID,WORD isEnabled)const +{ + return ::EnableWindow(::GetDlgItem(*this,controlID),isEnabled); +} + +inline +void DWindow::endDialog(WORD returnCode) +{ + if(isValid())::EndDialog((HWND)*this,returnCode); +} +#endif + diff --git a/common/ELASTIC.CPP b/common/ELASTIC.CPP new file mode 100644 index 0000000..bf30bd7 --- /dev/null +++ b/common/ELASTIC.CPP @@ -0,0 +1,47 @@ +#include + +GUIWindow &ElasticControl::controlWindow(void) +{ + return *this; +} + +HWND ElasticControl::createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,GUIWindow &parentWindow,int controlID) +{ + ElasticControl::createControl(0,className,windowName,dwStyle,initRect,parentWindow,controlID); + return *this; +} + +HWND ElasticControl::createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,GUIWindow &parentWindow,int controlID) +{ + mlpParentWindow=&parentWindow; + parentWindow.insertHandler(VectorHandler::SizeHandler,&mSizeHandler); + Control::createControl(extendedStyle,className,windowName,dwStyle,initRect,parentWindow,controlID); + initControl(parentWindow); + return *this; +} + +HWND ElasticControl::assumeControl(GUIWindow &parentWindow,HWND hControlWnd,UINT controlID) +{ + mlpParentWindow=&parentWindow; + parentWindow.insertHandler(VectorHandler::SizeHandler,&mSizeHandler); + Control::assumeControl(hControlWnd,controlID); + initControl(parentWindow); + return *this; +} + +HWND ElasticControl::createControl(DWORD /*extendedStyle*/,const String &/*className*/,const String &/*windowName*/,DWORD /*dwStyle*/,const Rect &/*initRect*/,HWND /*hParent*/,int /*controlID*/) +{ // no implementation + return (HWND)0; +} + +HWND ElasticControl::createControl(const String &/*className*/,const String &/*windowName*/,DWORD /*dwStyle*/,const Rect &/*initRect*/,HWND /*hParentWnd*/,int /*controlID*/) +{ // no implementation + return (HWND)0; +} + +CallbackData::ReturnType ElasticControl::sizeHandler(CallbackData &someCallbackData) +{ + if(!mlpParentWindow)return (CallbackData::ReturnType)FALSE; + moveControl(*mlpParentWindow,someCallbackData.loWord(),someCallbackData.hiWord()); + return (CallbackData::ReturnType)FALSE; +} diff --git a/common/ELASTIC.HPP b/common/ELASTIC.HPP new file mode 100644 index 0000000..69868a0 --- /dev/null +++ b/common/ELASTIC.HPP @@ -0,0 +1,53 @@ +#ifndef _COMMON_ELASTICCONTROL_HPP_ +#define _COMMON_ELASTICCONTROL_HPP_ +#ifndef _COMMON_RUBBERCONTROL_HPP_ +#include +#endif +#ifndef _COMMON_CONTROL_HPP_ +#include +#endif + +class ElasticControl : public Control, private RubberControl +{ +public: + ElasticControl(void); + virtual ~ElasticControl(); + virtual HWND createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,GUIWindow &parentWindow,int controlID); + virtual HWND createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,GUIWindow &parentWindow,int controlID); + virtual HWND assumeControl(GUIWindow &parentWindow,HWND hControlWnd,UINT controlID); +protected: + virtual GUIWindow &controlWindow(void); +private: + ElasticControl(const ElasticControl &someElasticControl); + ElasticControl &operator=(const ElasticControl &someElasticControl); + HWND createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID); + HWND createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParent,int controlID); + CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData); + + Callback mSizeHandler; + GUIWindow *mlpParentWindow; +}; + +inline +ElasticControl::ElasticControl(void) +: mlpParentWindow(0) +{ + mSizeHandler.setCallback(this,&ElasticControl::sizeHandler); +} + +inline +ElasticControl::ElasticControl(const ElasticControl &/*someElasticControl*/) +{ // no implementation +} + +inline +ElasticControl::~ElasticControl() +{ +} + +inline +ElasticControl &ElasticControl::operator=(const ElasticControl &/*someElasticControl*/) +{ // no implementation + return *this; +} +#endif \ No newline at end of file diff --git a/common/ENUM.TXT b/common/ENUM.TXT new file mode 100644 index 0000000..8d2f93f --- /dev/null +++ b/common/ENUM.TXT @@ -0,0 +1,16 @@ +inline +WORD RegKey::enumValue(DWORD index,const String &valueName,DWORD &longData) +{ + LONG keyResult; + DWORD nameLength; + DWORD valueLength; + DWORD typeCode(REG_DWORD); + + if(!isOkay())return FALSE; + valueName.GetBufferSetLength(MaxDataLength); + nameLength=MaxDataLength; + valueLength=sizeof(DWORD); + keyResult=::RegEnumValue((HKEY)*this,index,(LPSTR)(LPCTSTR)nameValue,&nameLength,0,&typeCode,(LPBYTE)&longData,&valueLength); + if(ERROR_SUCCESS!=keyReturn||REG_DWORD!=valueType)return FALSE; + return TRUE; +} diff --git a/common/EXCEPT.HPP b/common/EXCEPT.HPP new file mode 100644 index 0000000..a345999 --- /dev/null +++ b/common/EXCEPT.HPP @@ -0,0 +1,50 @@ +#ifndef _COMMON_EXCEPTION_HPP_ +#define _COMMON_EXCEPTION_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class Exception +{ +public: + Exception(){mReason="";} + Exception(const String &reason){mReason=reason;} + virtual ~Exception(){;} + virtual String toString(){return mReason;} + const String &getReason(void)const{return mReason;}; +private: + String mReason; +}; + +class BoundaryError : public Exception +{ +public : + String toString(){return "BoundaryError";} +}; + +class NullError : public Exception +{ +public : + String toString(){return "NullError";} +}; + +class ArrayIndexOutOfBoundsException : public Exception +{ +public : + String toString(){return "ArrayIndexOutOfBounds";} +}; + +class LibraryNotFoundException : public Exception +{ +public: + LibraryNotFoundException(const String &reason="LibraryNotFoundException"):Exception(reason){;} + String toString(){return getReason();} +}; + +class InvalidStateException : public Exception +{ +public: + InvalidStateException(const String &reason="InvalidStateException"):Exception(reason){;} + String toString(){return getReason();} +}; +#endif diff --git a/common/EXCPT.HPP b/common/EXCPT.HPP new file mode 100644 index 0000000..f3a3edf --- /dev/null +++ b/common/EXCPT.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_EXCEPTION_HPP_ +#define _COMMON_EXCEPTION_HPP_ +#include +#endif diff --git a/common/FILE.CPP b/common/FILE.CPP new file mode 100644 index 0000000..652c7f5 --- /dev/null +++ b/common/FILE.CPP @@ -0,0 +1,309 @@ +#include + +File::File(void) +: mpFilePointer(0) +{ +} + +File::File(String pathFileName,String access) + : mpFilePointer(0) +{ + open(pathFileName,access); +} + +File::File(const File &someFile) + : mpFilePointer(0) +{ + *this=someFile; +} + +File::~File() +{ + close(); +} + +File &File::operator=(const File &someFile) +{ + open(someFile.pathFileName(),someFile.access()); + return *this; +} + +bool File::operator==(const File &someFile) +{ + return (pathFileName()==someFile.pathFileName()); +} + +bool File::open(String pathFileName,String access) +{ + close(); + if(pathFileName.isNull())return false; + mpFilePointer=::fopen(pathFileName,access); + if(!mpFilePointer)return FALSE; + mPathFileName=pathFileName; + mAccess=access; + return TRUE; +} + +bool File::close(void) +{ + if(!mpFilePointer)return FALSE; + ::fclose(mpFilePointer); + mpFilePointer=0; + return TRUE; +} + +const String &File::pathFileName(void)const +{ + return mPathFileName; +} + +const String &File::access(void)const +{ + return mAccess; +} + +bool File::isOkay(void)const +{ + return (mpFilePointer?TRUE:FALSE); +} + +bool File::write(const String &string) +{ + return write(string.str(),string.length()); +} + +bool File::write(void *pData,DWORD extent) +{ + if(!isOkay()||!pData||!extent)return FALSE; + if(!::fwrite(pData,extent,1,mpFilePointer))return FALSE; + return TRUE; +} + +DWORD File::write(BYTE value) +{ + return write((void*)&value,sizeof(value)); +} + +DWORD File::write(WORD value) +{ + return write((void*)&value,sizeof(value)); +} + +DWORD File::write(DWORD value) +{ + return write((void*)&value,sizeof(value)); +} + +DWORD File::write(int value) +{ + return write((void*)&value,sizeof(value)); +} + +DWORD File::write(double value) +{ + return write((void*)&value,sizeof(value)); +} + +DWORD File::write(const void *lpBuffer,DWORD lengthData) +{ + return write((void*)lpBuffer,lengthData); +} + +bool File::writeLine(const String &lineString) +{ + char crlf[2]={'\r','\n'}; + if(!isOkay()||lineString.isNull())return FALSE; + if(!::fwrite((char*)((String&)lineString),lineString.length(),1,mpFilePointer))return FALSE; + if(!::fwrite(crlf,sizeof(crlf),1,mpFilePointer))return FALSE; + return TRUE; +} + +bool File::flush(void) +{ + if(!isOkay())return false; + ::fflush(mpFilePointer); + return true; +} + +DWORD File::length(void)const +{ + DWORD currentPosition; + DWORD length; + + if(!isOkay())return 0; + currentPosition=tell(); + seek(0,SeekEnd); + length=tell(); + seek(currentPosition,SeekSet); + return length; +} + +DWORD File::tell(void)const +{ + fpos_t pos; + if(!isOkay())return FALSE; + if(::fgetpos(mpFilePointer,&pos))return FALSE; + return pos; +} + +bool File::eof(void)const +{ + if(!isOkay())return FALSE; + return feof(mpFilePointer); +} + +bool File::rewind(void) +{ + if(!isOkay())return FALSE; + ::rewind(mpFilePointer); + return TRUE; +} + +bool File::seek(long pos,SeekMethod seekMethod)const +{ + if(!isOkay())return FALSE; + if(-1==::fseek(mpFilePointer,pos,seekMethod))return FALSE; + return TRUE; +} + +DWORD File::read(int &value) +{ + return read((void*)&value,sizeof(int)); +} + +DWORD File::read(double &value) +{ + return read((void*)&value,sizeof(double)); +} + +DWORD File::read(void *pData,int extent) +{ + if(!isOkay()||!pData||!extent)return 0; + return ::fread((char*)pData,1,extent,mpFilePointer); +} + +DWORD File::read(BYTE &value) +{ + return read((void*)&value,sizeof(BYTE)); +} + +DWORD File::read(WORD &value) +{ + return read((void*)&value,sizeof(WORD)); +} + +DWORD File::read(DWORD &value) +{ + return read((void*)&value,sizeof(DWORD)); +} + +DWORD File::read(char *lpBuffer,WORD lengthData,int stopChar) +{ + BYTE tempChar; + + for(int bytesRead=0;bytesRead=blockLength-1) + { + *ptrLine=0; + String tmpString(lineString); + int nextIndex(ptrLine-(BYTE*)(char*)lineString); + lineString.reserve(blockLength+granularity); + ::memcpy((char*)lineString,(char*)tmpString,blockLength); + blockLength+=granularity; + ptrLine=(BYTE*)(char*)lineString+nextIndex; + } + if(CarriageReturn==charByte) + { + if(!read(charByte))break; + if(LineFeed==charByte) + { + *ptrLine=0; + return TRUE; + } + } + else if(LineFeed==charByte) + { + *ptrLine=0; + return TRUE; + } + else if(NullChar==charByte) + { + *ptrLine++=0; + return bytesRead; + } + else if(TabChar==charByte) + { + *ptrLine++=' '; + bytesRead++; + continue; + } + else + { + *ptrLine++=charByte; + bytesRead++; + } + } + return bytesRead; +} + +bool File::operator+=(DWORD sizeIncrement) +{ + if(!isOkay())return false; + return seek(sizeIncrement,SeekCur); +} + +bool File::operator++(void) +{ + if(!isOkay())return false; + return seek(1,SeekCur); +} + +bool File::operator++(int postFixDummy) // postfix works the same as prefix +{ + if(!isOkay())return false; + return seek(1,SeekCur); +} + +bool File::operator-=(DWORD sizeDecrement) +{ + if(!isOkay())return false; + return seek(-((int)sizeDecrement),SeekCur); +} + +bool File::operator--(void) +{ + if(!isOkay())return false; + return seek(-1,SeekCur); +} + +bool File::operator--(int postFixDummy) // postfix works the same as prefix +{ + if(!isOkay())return false; + return seek(-1,SeekCur); +} + + + diff --git a/common/FILE.HPP b/common/FILE.HPP new file mode 100644 index 0000000..0bf0c56 --- /dev/null +++ b/common/FILE.HPP @@ -0,0 +1,102 @@ +#ifndef _COMMON_FILE_HPP_ +#define _COMMON_FILE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STDIO_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class File +{ +public: + enum SeekMethod{SeekSet=SEEK_SET,SeekCur=SEEK_CUR,SeekEnd=SEEK_END}; + File(void); + File(String pathFileName,String access="rb"); + File(const File &someFile); + virtual ~File(); + File &operator=(const File &someFile); + bool operator==(const File &someFile); + bool open(String pathFileName,String access="rb"); + bool close(void); + bool rewind(void); + bool seek(long pos,SeekMethod seekMethod=SeekSet)const; + DWORD tell(void)const; + DWORD length(void)const; + const String &pathFileName(void)const; + const String &access(void)const; + DWORD readLine(String &lineString); + DWORD read(void *pData,int extent); + DWORD read(BYTE &value); + DWORD read(WORD &value); + DWORD read(DWORD &value); + DWORD read(int &value); + DWORD read(double &value); + DWORD read(char *lpBuffer,WORD lengthData,int stopChar); + DWORD write(int value); + DWORD write(double value); + DWORD write(BYTE value); + DWORD write(WORD value); + DWORD write(DWORD value); + bool write(const String &string); + DWORD write(const void *lpBuffer,DWORD lengthData); + bool write(void *pData,DWORD extent); + bool writeLine(const String &lineString); + bool operator+=(DWORD sizeIncrement); + bool operator++(void); + bool operator++(int postFixDummy); + bool operator-=(DWORD sizeDecrement); + bool operator--(void); + bool operator--(int postFixDummy); + bool flush(void); + bool eof(void)const; + bool isOkay(void)const; + FILE *getFile(void); + private: + enum {CarriageReturn=0x0D,LineFeed=0x0A,TabChar=0x09,NullChar=0x00}; + FILE *mpFilePointer; + String mPathFileName; + String mAccess; +}; + +inline +FILE *File::getFile(void) +{ + return mpFilePointer; +} +#endif + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/common/FILEMAP.CPP b/common/FILEMAP.CPP new file mode 100644 index 0000000..7e21d41 --- /dev/null +++ b/common/FILEMAP.CPP @@ -0,0 +1,64 @@ +#if defined(__FLAT__) +#include +#include + +FileMap::FileMap(void) +: mMaxExtentHigh(0L), mMaxExtentLow(0L), + mPaging(ReadOnly), mProtection(Image), mhFileHandle(0) +{ +} + +FileMap::FileMap(const FileMap &/*someFileMap*/) +: mMaxExtentHigh(0L), mMaxExtentLow(0L), + mPaging(ReadOnly), mProtection(Image), mhFileHandle(0) +{ +} + +FileMap::FileMap(String mapName,DWORD maxExtentHigh,DWORD maxExtentLow,Paging paging,Protection protection) +: mMaxExtentHigh(maxExtentHigh), mMaxExtentLow(maxExtentLow), mPaging(paging), + mProtection(protection), mhFileHandle(0) +{ + create(mapName,maxExtentHigh,maxExtentLow,paging,protection); +} + +FileMap::FileMap(const FileHandle &someFileHandle) +: mMaxExtentHigh(0L), mMaxExtentLow(0), mhFileHandle(0) +{ + maxExtentHigh(0L); + maxExtentLow(someFileHandle.size()); + create(someFileHandle); +} + +WORD FileMap::create(const FileHandle &someFileHandle) +{ + if(FileHandle::Read==someFileHandle.access())mPaging=ReadOnly; + else if(FileHandle::Write==someFileHandle.access())mPaging=WriteCopy; + else if(FileHandle::ReadWrite==someFileHandle.access())mPaging=ReadWrite; + else mPaging=ReadOnly; + mProtection=Commit; + return create(String(""),0L,someFileHandle.size(),mPaging,mProtection,(HANDLE)someFileHandle); +} + +WORD FileMap::create(String mapName,DWORD maxExtentHigh,DWORD maxExtentLow,Paging paging,Protection protection,HANDLE hMapFile) +{ + mMaxExtentHigh=maxExtentHigh; + mMaxExtentLow=maxExtentLow; + mPaging=paging; + mProtection=protection; + destroyMap(); + mhFileHandle=::CreateFileMapping((HANDLE)hMapFile,(LPSECURITY_ATTRIBUTES)0,paging|protection,maxExtentHigh,maxExtentLow,mapName); + return isOkay(); +} + +BOOL FileMap::open(const String &strName,DWORD maxExtentHigh,DWORD maxExtentLow,Paging paging,Protection protection,DWORD access,BOOL inherit) +{ + destroyMap(); + if(strName.isNull())return FALSE; + mhFileHandle=::OpenFileMapping(access,inherit,(LPSTR)(String&)strName); + mMaxExtentHigh=maxExtentHigh; + mMaxExtentLow=maxExtentLow; + mPaging=paging; + mProtection=protection; + return isOkay(); +} +#endif diff --git a/common/FILEMAP.HPP b/common/FILEMAP.HPP new file mode 100644 index 0000000..6be8e16 --- /dev/null +++ b/common/FILEMAP.HPP @@ -0,0 +1,112 @@ +#if defined(__FLAT__) +#ifndef _COMMON_FILEMAP_HPP_ +#define _COMMON_FILEMAP_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class FileHandle; + +class FileMap +{ +public: + friend class PureViewOfFile; + enum MapMessage{ShutDown=0x02}; + enum Paging{ReadOnly=PAGE_READONLY,ReadWrite=PAGE_READWRITE,WriteCopy=PAGE_WRITECOPY}; + enum Protection{Commit=SEC_COMMIT,Image=SEC_IMAGE,NoCache=SEC_NOCACHE,Reserve=SEC_RESERVE}; + FileMap(void); + FileMap(String mapFileName,DWORD maxExtentHigh,DWORD maxExtentLow,Paging paging=ReadWrite,Protection protection=Commit); + FileMap(const FileHandle &someFileHandle); + virtual ~FileMap(); + WORD create(const FileHandle &someFileHandle); + WORD create(String mapName,DWORD maxExtentHigh,DWORD maxExtentLow,Paging paging,Protection protection,HANDLE hMapFile=(HANDLE)0xFFFFFFFF); + BOOL open(const String &strName,DWORD maxExtentHigh,DWORD maxExtentLow,Paging paging=ReadWrite,Protection protection=Commit,DWORD access=FILE_MAP_ALL_ACCESS,BOOL inherit=TRUE); + DWORD maxExtentLow(void)const; + DWORD maxExtentHigh(void)const; + Paging paging(void)const; + Protection protection(void)const; + HANDLE getHandle(void)const; + WORD isOkay(void)const; +private: + FileMap(const FileMap &someFileMap); + operator HANDLE(void)const; + void destroyMap(void); + void maxExtentLow(DWORD maxExtentLow); + void maxExtentHigh(DWORD maxExtentHigh); + + Paging mPaging; + Protection mProtection; + DWORD mMaxExtentHigh; + DWORD mMaxExtentLow; + HANDLE mhFileHandle; +}; + +inline +WORD FileMap::isOkay(void)const +{ + return (mhFileHandle?TRUE:FALSE); +} + +inline +FileMap::operator HANDLE(void)const +{ + return mhFileHandle; +} + +inline +DWORD FileMap::maxExtentLow(void)const +{ + return mMaxExtentLow; +} + +inline +void FileMap::maxExtentLow(DWORD maxExtentLow) +{ + mMaxExtentLow=maxExtentLow; +} + +inline +DWORD FileMap::maxExtentHigh(void)const +{ + return mMaxExtentHigh; +} + +inline +void FileMap::maxExtentHigh(DWORD maxExtentHigh) +{ + mMaxExtentHigh=maxExtentHigh; +} + +inline +FileMap::Paging FileMap::paging(void)const +{ + return mPaging; +} + +inline +FileMap::Protection FileMap::protection(void)const +{ + return mProtection; +} + +inline +FileMap::~FileMap() +{ + destroyMap(); +} + +inline +HANDLE FileMap::getHandle(void)const +{ + return mhFileHandle; +} + +inline +void FileMap::destroyMap(void) +{ + if(!mhFileHandle)return; + ::CloseHandle(mhFileHandle); + mhFileHandle=0; +} +#endif +#endif \ No newline at end of file diff --git a/common/FILETIME.HPP b/common/FILETIME.HPP new file mode 100644 index 0000000..cf8c956 --- /dev/null +++ b/common/FILETIME.HPP @@ -0,0 +1,140 @@ +#if defined(_WIN32) +#ifndef _COMMON_FILETIME_HPP_ +#define _COMMON_FILETIME_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class SystemTime; + +class FileTime : private FILETIME +{ +public: + FileTime(void); + FileTime(const FileTime &someFileTime); + FileTime(const SystemTime &someSystemTime); + FileTime(const FILETIME &fileTime); + virtual ~FileTime(); + FileTime &operator=(const FileTime &someFileTime); + FileTime &operator=(const SystemTime &someSystemTime); + FileTime &operator=(const FILETIME &someFileTime); + WORD operator==(const FileTime &someFileTime)const; + WORD operator>(const FileTime &someFileTime)const; + WORD operator<(const FileTime &someFileTime)const; + DWORD lowDateTime(void)const; + void lowDateTime(DWORD lowDateTime); + DWORD highDateTime(void)const; + void highDateTime(DWORD highDateTime); + FILETIME &getFILETIME(void); +private: + void zeroInit(void); +}; + +inline +FileTime::FileTime(void) +{ + zeroInit(); +} + +inline +FileTime::FileTime(const FileTime &someFileTime) +{ + *this=someFileTime; +} + +inline +FileTime::FileTime(const SystemTime &someSystemTime) +{ + *this=someSystemTime; +} + +inline +FileTime::FileTime(const FILETIME &fileTime) +{ + *this=fileTime; +} + +inline +FileTime::~FileTime() +{ +} + +inline +FILETIME &FileTime::getFILETIME(void) +{ + return *this; +} + +inline +FileTime &FileTime::operator=(const FileTime &someFileTime) +{ + lowDateTime(someFileTime.lowDateTime()); + highDateTime(someFileTime.highDateTime()); + return *this; +} + +inline +FileTime &FileTime::operator=(const SystemTime &someSystemTime) +{ + ::SystemTimeToFileTime(&((SYSTEMTIME&)((SystemTime&)someSystemTime)),&((FILETIME&)*this)); + return *this; +} + +inline +FileTime &FileTime::operator=(const FILETIME &someFileTime) +{ + FILETIME::dwLowDateTime=someFileTime.dwLowDateTime; + FILETIME::dwHighDateTime=someFileTime.dwHighDateTime; + return *this; +} + +inline +WORD FileTime::operator==(const FileTime &someFileTime)const +{ + return (0==::CompareFileTime(&((FILETIME&)*this),&((FILETIME&)someFileTime))); +} + +inline +WORD FileTime::operator>(const FileTime &someFileTime)const +{ + return (1==::CompareFileTime(&((FILETIME&)*this),&((FILETIME&)someFileTime))); +} + +inline +WORD FileTime::operator<(const FileTime &someFileTime)const +{ + return (-1==::CompareFileTime(&((FILETIME&)*this),&((FILETIME&)someFileTime))); +} + +inline +DWORD FileTime::lowDateTime(void)const +{ + return FILETIME::dwLowDateTime; +} + +inline +void FileTime::lowDateTime(DWORD lowDateTime) +{ + FILETIME::dwLowDateTime=lowDateTime; +} + +inline +DWORD FileTime::highDateTime(void)const +{ + return FILETIME::dwHighDateTime; +} + +inline +void FileTime::highDateTime(DWORD highDateTime) +{ + FILETIME::dwHighDateTime=highDateTime; +} + +inline +void FileTime::zeroInit(void) +{ + FILETIME::dwLowDateTime=0L; + FILETIME::dwHighDateTime=0L; +} +#endif +#endif \ No newline at end of file diff --git a/common/FINDDATA.CPP b/common/FINDDATA.CPP new file mode 100644 index 0000000..a2e9b5a --- /dev/null +++ b/common/FINDDATA.CPP @@ -0,0 +1,55 @@ +#include + +void FindData::destroyFind(void) +{ + if(INVALID_HANDLE_VALUE==mhFindHandle)return; + ::FindClose(mhFindHandle); + mhFindHandle=INVALID_HANDLE_VALUE; +} + +WORD FindData::findFirst(const String &searchFileName,DWORD searchAttributes) +{ + destroyFind(); + zeroInit(); + if(searchFileName.isNull())return FALSE; + fileName(searchFileName); + attributes(searchAttributes); + if(INVALID_HANDLE_VALUE==(mhFindHandle=::FindFirstFile((LPSTR)searchFileName,&((WIN32_FIND_DATA&)*this))))return FALSE; + return TRUE; +} + +void FindData::altFileName(String altFileName) +{ + WORD nameLength(altFileName.length()); + + if(altFileName.isNull())return; + if(nameLength>=sizeof(WIN32_FIND_DATA::cAlternateFileName))altFileName.length(sizeof(WIN32_FIND_DATA::cAlternateFileName)-1); + ::strcpy(WIN32_FIND_DATA::cAlternateFileName,(LPSTR)altFileName); +} + +FindData &FindData::operator=(const FindData &someFindData) +{ + attributes(someFindData.attributes()); + creationTime(someFindData.creationTime()); + lastAccessTime(someFindData.lastAccessTime()); + lastModifyTime(someFindData.lastModifyTime()); + sizeHigh(someFindData.sizeHigh()); + sizeLow(someFindData.sizeLow()); + fileName(someFindData.fileName()); + altFileName(someFindData.altFileName()); + return *this; +} + +WORD FindData::operator==(const FindData &someFindData)const +{ + return (attributes()==someFindData.attributes()&& + creationTime()==someFindData.creationTime()&& + lastAccessTime()==someFindData.lastAccessTime()&& + sizeHigh()==someFindData.sizeHigh()&& + fileName()==someFindData.fileName()&& + altFileName()==someFindData.altFileName()); +} + + + + diff --git a/common/FINDDATA.HPP b/common/FINDDATA.HPP new file mode 100644 index 0000000..1fd80d7 --- /dev/null +++ b/common/FINDDATA.HPP @@ -0,0 +1,185 @@ +#ifndef _COMMON_FINDDATA_HPP_ +#define _COMMON_FINDDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_SYSTEMTIME_HPP_ +#include +#endif +#ifndef _COMMON_FILETIME_HPP_ +#include +#endif + +class FindData : private WIN32_FIND_DATA +{ +public: + enum FileAttributes{FileArchive=FILE_ATTRIBUTE_ARCHIVE,FileDirectory=FILE_ATTRIBUTE_DIRECTORY, + FileHidden=FILE_ATTRIBUTE_HIDDEN,FileNormal=FILE_ATTRIBUTE_NORMAL, + FileReadOnly=FILE_ATTRIBUTE_READONLY,FileSystem=FILE_ATTRIBUTE_SYSTEM, + FileTemporary=FILE_ATTRIBUTE_TEMPORARY}; + FindData(void); + FindData(const FindData &someFindData); + virtual ~FindData(); + WORD findFirst(const String &searchFileName,DWORD attributes=(DWORD)FileArchive); + WORD findNext(void); + FindData &operator=(const FindData &someFindData); + WORD operator==(const FindData &someFindData)const; + operator WIN32_FIND_DATA &(void); + DWORD attributes(void)const; + void attributes(DWORD attributes); + SystemTime creationTime(void)const; + void creationTime(const SystemTime &creationTime); + SystemTime lastAccessTime(void)const; + void lastAccessTime(const SystemTime &lastAccessTime); + SystemTime lastModifyTime(void)const; + void lastModifyTime(const SystemTime &lastModifyTime); + DWORD sizeHigh(void)const; + void sizeHigh(DWORD sizeHigh); + DWORD sizeLow(void)const; + void sizeLow(DWORD sizeLow); + String fileName(void)const; + void fileName(String fileName); + String altFileName(void)const; + void altFileName(String altFileName); +private: + void zeroInit(void); + void destroyFind(void); + HANDLE mhFindHandle; +}; + +inline +FindData::FindData(void) +: mhFindHandle(INVALID_HANDLE_VALUE) +{ + zeroInit(); +} + +inline +FindData::FindData(const FindData &someFindData) +: mhFindHandle(INVALID_HANDLE_VALUE) +{ + *this=someFindData; +} + +inline +FindData::~FindData() +{ + destroyFind(); +} + +inline +FindData::operator WIN32_FIND_DATA &(void) +{ + return *this; +} + +inline +DWORD FindData::attributes(void)const +{ + return WIN32_FIND_DATA::dwFileAttributes; +} + +inline +void FindData::attributes(DWORD attributes) +{ + WIN32_FIND_DATA::dwFileAttributes=attributes; +} + +inline +SystemTime FindData::creationTime(void)const +{ + return (FileTime&)WIN32_FIND_DATA::ftCreationTime; +} + +inline +void FindData::creationTime(const SystemTime &creationTime) +{ + (FileTime&)WIN32_FIND_DATA::ftCreationTime=creationTime; +} + +inline +SystemTime FindData::lastAccessTime(void)const +{ + return (FileTime&)WIN32_FIND_DATA::ftLastAccessTime; +} + +inline +void FindData::lastAccessTime(const SystemTime &lastAccessTime) +{ + (FileTime&)WIN32_FIND_DATA::ftLastAccessTime=lastAccessTime; +} + +inline +SystemTime FindData::lastModifyTime(void)const +{ + return (FileTime&)WIN32_FIND_DATA::ftLastWriteTime; +} + +inline +void FindData::lastModifyTime(const SystemTime &lastModifyTime) +{ + (FileTime&)WIN32_FIND_DATA::ftLastWriteTime=lastModifyTime; +} + +inline +DWORD FindData::sizeHigh(void)const +{ + return WIN32_FIND_DATA::nFileSizeHigh; +} + +inline +void FindData::sizeHigh(DWORD sizeHigh) +{ + WIN32_FIND_DATA::nFileSizeHigh=sizeHigh; +} + +inline +DWORD FindData::sizeLow(void)const +{ + return WIN32_FIND_DATA::nFileSizeLow; +} + +inline +void FindData::sizeLow(DWORD sizeLow) +{ + WIN32_FIND_DATA::nFileSizeLow=sizeLow; +} + +inline +String FindData::fileName(void)const +{ + return WIN32_FIND_DATA::cFileName; +} + +inline +void FindData::fileName(String fileName) +{ + WORD nameLength(fileName.length()); + + if(fileName.isNull())return; + if(nameLength>=sizeof(WIN32_FIND_DATA::cFileName))fileName.length(sizeof(WIN32_FIND_DATA::cFileName)-1); + ::strcpy(WIN32_FIND_DATA::cFileName,(LPSTR)fileName); +} + +inline +String FindData::altFileName(void)const +{ + return WIN32_FIND_DATA::cAlternateFileName; +} + +inline +WORD FindData::findNext(void) +{ + if(INVALID_HANDLE_VALUE==mhFindHandle)return FALSE; + return ::FindNextFile(mhFindHandle,&((WIN32_FIND_DATA&)*this)); +} + +inline +void FindData::zeroInit(void) +{ + ::memset(&((WIN32_FIND_DATA&)*this),0,sizeof(WIN32_FIND_DATA)); +} +#endif diff --git a/common/FIXUP.HPP b/common/FIXUP.HPP new file mode 100644 index 0000000..faa8901 --- /dev/null +++ b/common/FIXUP.HPP @@ -0,0 +1,8 @@ +#ifndef _COMMON_FIXUP_HPP_ +#define _COMMON_FIXUP_HPP_ +extern "C" +{ + extern void push0002(void); + extern void pop0002(void); +} +#endif diff --git a/common/FNDTEXTX.HPP b/common/FNDTEXTX.HPP new file mode 100644 index 0000000..c8fb449 --- /dev/null +++ b/common/FNDTEXTX.HPP @@ -0,0 +1,125 @@ +#ifndef _COMMON_FINDTEXTEX_HPP_ +#define _COMMON_FINDTEXTEX_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_CHARRANGE_HPP_ +#include +#endif + +class FindTextEx : private FINDTEXTEX +{ +public: + FindTextEx(void); + FindTextEx(const FindTextEx &findTextEx); + FindTextEx(const CharRange &charRange,const String &strFind); + virtual ~FindTextEx(); + FindTextEx &operator=(const FindTextEx &findTextEx); + BOOL operator==(const FindTextEx &findTextEx)const; + CharRange searchRange(void)const; + void searchRange(const CharRange &searchRange); + const String &strFind(void)const; + void strFind(const String &strFind); + CharRange foundRange(void)const; + void foundRange(const CharRange &foundRange); + FINDTEXTEX &findTextEx(void); +private: + String mStrInternal; +}; + +inline +FindTextEx::FindTextEx(void) +{ + FINDTEXTEX::chrg.cpMin=0; + FINDTEXTEX::chrg.cpMax=0; + FINDTEXTEX::lpstrText=0; + FINDTEXTEX::chrgText.cpMin=0; + FINDTEXTEX::chrgText.cpMax=0; +} + +inline +FindTextEx::FindTextEx(const FindTextEx &findTextEx) +{ + *this=findTextEx; +} + +inline +FindTextEx::FindTextEx(const CharRange &charRange,const String &strFind) +{ + mStrInternal=strFind; + FINDTEXTEX::chrg.cpMin=charRange.posMin(); + FINDTEXTEX::chrg.cpMax=charRange.posMax(); + FINDTEXTEX::lpstrText=(char*)mStrInternal; +} + +inline +FindTextEx::~FindTextEx() +{ +} + +inline +FindTextEx &FindTextEx::operator=(const FindTextEx &findTextEx) +{ + searchRange(findTextEx.searchRange()); + strFind(findTextEx.strFind()); + foundRange(findTextEx.foundRange()); + return *this; +} + +inline +BOOL FindTextEx::operator==(const FindTextEx &findTextEx)const +{ + return (searchRange()==findTextEx.searchRange()&& + foundRange()==findTextEx.foundRange()&& + strFind()==findTextEx.strFind()); +} + +inline +CharRange FindTextEx::searchRange(void)const +{ + return CharRange(FINDTEXTEX::chrg.cpMin,FINDTEXTEX::chrg.cpMax); +} + +inline +void FindTextEx::searchRange(const CharRange &searchRange) +{ + FINDTEXTEX::chrg.cpMin=searchRange.posMin(); + FINDTEXTEX::chrg.cpMax=searchRange.posMax(); +} + +inline +const String &FindTextEx::strFind(void)const +{ + return mStrInternal; +} + +inline +void FindTextEx::strFind(const String &strFind) +{ + mStrInternal=strFind; + FINDTEXTEX::lpstrText=(char*)mStrInternal; +} + +inline +CharRange FindTextEx::foundRange(void)const +{ + return CharRange(FINDTEXTEX::chrgText.cpMin,FINDTEXTEX::chrgText.cpMax); +} + +inline +void FindTextEx::foundRange(const CharRange &foundRange) +{ + FINDTEXTEX::chrgText.cpMin=foundRange.posMin(); + FINDTEXTEX::chrgText.cpMax=foundRange.posMax(); +} + +inline +FINDTEXTEX &FindTextEx::findTextEx(void) +{ + return *this; +} +#endif + diff --git a/common/FONT.CPP b/common/FONT.CPP new file mode 100644 index 0000000..4a0d668 --- /dev/null +++ b/common/FONT.CPP @@ -0,0 +1,37 @@ +#include +#include + +Font &Font::operator=(const Font &someFont) +{ + if(someFont.isOkay()) + { + mPitchAndFamily=someFont.mPitchAndFamily; + mWeight=someFont.mWeight; + mFontStyle=someFont.mFontStyle; + mFontSize=someFont.mFontSize; + mCharSet=someFont.mCharSet; + createFont(); + } + return *this; +} + +void Font::createFont(void) +{ + PureDevice screenDevice; + TEXTMETRIC tm; + int fontHeight; + + destroyFont(); + screenDevice.screenDevice(); + fontHeight=::MulDiv(((short)mFontSize),::GetDeviceCaps(screenDevice,LOGPIXELSY),72); + mhFont=::CreateFont(fontHeight,0,0,0,mWeight,0,0,0, + mCharSet,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS, + DEFAULT_QUALITY,mPitchAndFamily,mFontStyle.str()); + screenDevice.select(mhFont); + ::GetTextMetrics(screenDevice,&tm); + charHeight(tm.tmHeight+tm.tmExternalLeading); + pureHeight(tm.tmHeight); + avgCharWidth(tm.tmAveCharWidth); + maxCharWidth(tm.tmMaxCharWidth); +} + diff --git a/common/FONT.HPP b/common/FONT.HPP new file mode 100644 index 0000000..8b72ed4 --- /dev/null +++ b/common/FONT.HPP @@ -0,0 +1,249 @@ +#ifndef _COMMON_FONT_HPP_ +#define _COMMON_FONT_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_GDIOBJ_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class Font +{ +public: + enum{PitchDefault=DEFAULT_PITCH,PitchFixed=FIXED_PITCH,PitchVariable=VARIABLE_PITCH}; + enum{FamilyDecorative=FF_DECORATIVE,FamilyDontCare=FF_DONTCARE, + FamilyModern=FF_MODERN,FamilyRoman=FF_ROMAN,FamilyScript=FF_SCRIPT, + FamilySwiss=FF_SWISS}; + enum{WeightDontCare=FW_DONTCARE,WeightThin=FW_THIN,WeightExtraLight=FW_EXTRALIGHT, + WeightUltraLight=FW_ULTRALIGHT,WeightLight=FW_LIGHT,WeightNormal=FW_NORMAL, + WeightRegular=FW_REGULAR,WeightMedium=FW_MEDIUM,WeightSemiBold=FW_SEMIBOLD, + WeightDemiBold=FW_DEMIBOLD,WeightBold=FW_BOLD,WeightExtraBold=FW_EXTRABOLD, + WeightUltraBold=FW_ULTRABOLD,WeightHeavy=FW_HEAVY,WeightBlack=FW_BLACK}; + enum CharSet{AnsiCharSet=ANSI_CHARSET,OemCharSet=OEM_CHARSET,DefaultCharSet=DEFAULT_CHARSET, + SymbolCharSet=SYMBOL_CHARSET,RussianCharSet=RUSSIAN_CHARSET}; + Font(void); + Font(const Font &someFont); + Font(const String &fontStyle,WORD sizeFont=8,DWORD pitchAndFamily=PitchVariable|FamilySwiss,DWORD weight=WeightNormal,CharSet charSet=AnsiCharSet); + virtual ~Font(); + operator HFONT(void)const; + operator GDIObj(void)const; + Font &operator=(const Font &someFont); + WORD operator==(const Font &someFont)const; + String fontStyle(void)const; + void fontStyle(const String &someFontStyle); + DWORD pitchAndFamily(void)const; + void pitchAndFamily(DWORD pitchAndFamily); + DWORD weight(void)const; + void weight(DWORD weight); + WORD sizeFont(void)const; + void sizeFont(WORD sizeFont); + WORD charHeight(void)const; + WORD avgCharWidth(void)const; + WORD maxCharWidth(void)const; + WORD pureHeight(void)const; + CharSet charSet(void)const; + void charSet(CharSet charSet); + WORD isOkay(void)const; +private: + void pureHeight(WORD pureHeight); + void charHeight(WORD charHeight); + void avgCharWidth(WORD avgCharWidth); + void maxCharWidth(WORD maxCharWidth); + void createFont(void); + void destroyFont(void); + + HFONT mhFont; + WORD mPureHeight; + WORD mCharHeight; + WORD mAvgCharWidth; + WORD mMaxCharWidth; + WORD mFontSize; + CharSet mCharSet; + String mFontStyle; + DWORD mPitchAndFamily; + DWORD mWeight; +}; + +inline +Font::Font(void) +: mCharHeight(0), mhFont(0), mFontStyle("Arial"), + mPitchAndFamily(PitchVariable|FamilySwiss), mFontSize(8), mPureHeight(0), + mWeight(WeightNormal), mCharSet(AnsiCharSet) +{ + createFont(); +} + +inline +Font::Font(const String &fontStyle,WORD sizeFont,DWORD pitchAndFamily,DWORD weight,CharSet charSet) +: mCharHeight(0), mhFont(0), mFontStyle(fontStyle), mPitchAndFamily(pitchAndFamily), + mFontSize(sizeFont), mPureHeight(0), mWeight(weight), mCharSet(charSet) +{ + createFont(); +} + +inline +Font::Font(const Font &someFont) +{ + *this=someFont; +} + +inline +Font::~Font() +{ + destroyFont(); +} + +inline +Font::operator GDIObj(void)const +{ + return (GDIObj)mhFont; +} + +inline +Font::operator HFONT(void)const +{ + return mhFont; +} + +inline +WORD Font::operator==(const Font &someFont)const +{ + return (fontStyle()==someFont.fontStyle()&& + pitchAndFamily()==someFont.pitchAndFamily()&& + weight()==someFont.weight()&& + sizeFont()==someFont.sizeFont()&& + charHeight()==someFont.charHeight()&& + avgCharWidth()==someFont.avgCharWidth()&& + maxCharWidth()==someFont.maxCharWidth()&& + charSet()==someFont.charSet()); +} + +inline +String Font::fontStyle(void)const +{ + return mFontStyle; +} + +inline +void Font::fontStyle(const String &someFontStyle) +{ + mFontStyle=someFontStyle; + createFont(); +} + +inline +WORD Font::charHeight(void)const +{ + return mCharHeight; +} + +inline +void Font::charHeight(WORD charHeight) +{ + mCharHeight=charHeight; +} + +inline +WORD Font::avgCharWidth(void)const +{ + return mAvgCharWidth; +} + +inline +void Font::avgCharWidth(WORD avgCharWidth) +{ + mAvgCharWidth=avgCharWidth; +} + +inline +WORD Font::maxCharWidth(void)const +{ + return mMaxCharWidth; +} + +inline +void Font::maxCharWidth(WORD maxCharWidth) +{ + mMaxCharWidth=maxCharWidth; +} + +inline +DWORD Font::pitchAndFamily(void)const +{ + return mPitchAndFamily; +} + +inline +void Font::pitchAndFamily(DWORD pitchAndFamily) +{ + mPitchAndFamily=pitchAndFamily; + createFont(); +} + +inline +DWORD Font::weight(void)const +{ + return mWeight; +} + +inline +void Font::weight(DWORD weight) +{ + mWeight=weight; + createFont(); +} + +inline +WORD Font::sizeFont(void)const +{ + return mFontSize; +} + +inline +void Font::sizeFont(WORD sizeFont) +{ + mFontSize=sizeFont; + createFont(); +} + +inline +void Font::pureHeight(WORD pureHeight) +{ + mPureHeight=pureHeight; +} + +inline +WORD Font::pureHeight(void)const +{ + return mPureHeight; +} + +inline +Font::CharSet Font::charSet(void)const +{ + return mCharSet; +} + +inline +void Font::charSet(CharSet charSet) +{ + mCharSet=charSet; +} + +inline +void Font::destroyFont(void) +{ + if(!mhFont)return; + ::DeleteObject(mhFont); + mhFont=0; +} + +inline +WORD Font::isOkay(void)const +{ + return (mhFont?TRUE:FALSE); +} +#endif diff --git a/common/Fileio.cpp b/common/Fileio.cpp new file mode 100644 index 0000000..2fd4661 --- /dev/null +++ b/common/Fileio.cpp @@ -0,0 +1,226 @@ +#include + +FileIO::FileIO(void) +: mlpFilePointer(0), mByteOrder(LittleEndian) +{ +} + +FileIO::FileIO(String pathFileName,ByteOrder byteOrder,Mode openMode,CreationFlags creationFlags) +: mlpFilePointer(0) , mByteOrder(byteOrder) +{ + open(pathFileName,byteOrder,openMode,creationFlags); +} + +FileIO::~FileIO() +{ + close(); +} + +bool FileIO::close(void) +{ + if(!mlpFilePointer)return false; + ::fclose(mlpFilePointer); + mlpFilePointer=0; + return true; +} + +bool FileIO::open(String pathFileName,ByteOrder byteOrder,Mode openMode,CreationFlags creationFlags) +{ + close(); + if(pathFileName.isNull())return false; + mByteOrder=byteOrder; + if(ReadOnly==openMode)mlpFilePointer=::fopen(pathFileName,"rb"); + else + { + if(CreateAlways==creationFlags)mlpFilePointer=::fopen(pathFileName,"w+b"); + else if(Create==creationFlags)mlpFilePointer=::fopen(pathFileName,"a+b"); + else mlpFilePointer=::fopen(pathFileName,"r+b"); + } + if(!mlpFilePointer)return false; + return true; +} + +bool FileIO::peek(BYTE &value) +{ + if(!isOkay())return false; + read(value); + seek(tell()-1,SeekCurrent); + return true; +} + +bool FileIO::read(BYTE &value) +{ + if(!isOkay())return false; + return (sizeof(value)==::fread(&value,1,1,mlpFilePointer)?true:false); +} + +bool FileIO::read(WORD &value) +{ + BYTE byteValue; + + if(!isOkay())return false; + if(!read(byteValue))return false; + value=byteValue; + if(!read(byteValue))return false; + value|=((WORD)byteValue)<<8; + if(BigEndian==mByteOrder)value=Intel::intelData(value); + return true; +} + +bool FileIO::read(DWORD &value) +{ + WORD wordValue; + + if(!isOkay())return false; + if(!read(wordValue))return false; + value=wordValue; + if(!read(wordValue))return false; + value|=((DWORD)wordValue)<<16; + if(BigEndian==mByteOrder)value=Intel::intelData(value); + return true; +} + +bool FileIO::read(char *lpBuffer,DWORD lengthData) +{ + BYTE byteValue; + + if(!isOkay()||!lpBuffer)return false; + return (1==::fread(lpBuffer,lengthData,1,mlpFilePointer)); +} + +bool FileIO::read(char *lpBuffer,DWORD lengthData,int stopChar) +{ + BYTE tempChar; + int bytesRead; + + if(!isOkay()||!lpBuffer||!lengthData)return false; + for(bytesRead=0;bytesRead=blockLength-1) + { + *ptrLine=0; + String tmpString(lineString); + int nextIndex(ptrLine-(BYTE*)(char*)lineString); + lineString.reserve(blockLength+granularity); + ::memcpy((char*)lineString,(char*)tmpString,blockLength); + blockLength+=granularity; + ptrLine=(BYTE*)(char*)lineString+nextIndex; + } + if(CarriageReturn==charByte) + { + if(!read(charByte))break; + if(LineFeed==charByte) + { + *ptrLine=0; + return true; + } + } + else if(NullChar==charByte) + { + *ptrLine++=0; + return bytesRead; + } + else + { + *ptrLine++=charByte; + bytesRead++; + } + } + return bytesRead; +} + +bool FileIO::write(WORD value) +{ + BYTE byteValue; + + if(!isOkay())return false; + if(BigEndian==mByteOrder)value=Intel::intelData(value); + byteValue=(BYTE)(value&0x00FF); + if(!write(byteValue))return false; + byteValue=(BYTE)(value>>8); + if(!write(byteValue))return false; + return true; +} + +bool FileIO::write(DWORD value) +{ + WORD wordValue; + + if(!isOkay())return false; + if(BigEndian==mByteOrder) + { + WORD hiWord(HIWORD(value)); + WORD loWord(LOWORD(value)); + + value=((DWORD)Intel::intelData(loWord))<<16; + value|=Intel::intelData(hiWord); + if(!write((char*)&value,sizeof(value)))return false; + return true; + } + wordValue=(WORD)(value&0xFFFF); + if(!write(wordValue))return false; + wordValue=(WORD)(value>>16); + if(!write(wordValue))return false; + return true; +} + +bool FileIO::writeLine(const String &strLine) +{ + if(!isOkay()||strLine.isNull())return false; + if(!write((char*)(String&)strLine,strLine.length()))return false; + return write("\r\n",2); +} + +bool FileIO::write(char *lpBuffer,DWORD lengthData) +{ + if(!isOkay()||!lpBuffer||!lengthData)return false; + if(1!=::fwrite(lpBuffer,1,lengthData,mlpFilePointer))return false; + return true; +} + +bool FileIO::rewind(void) +{ + if(!isOkay())return false; + return (!::fseek(mlpFilePointer,0,SEEK_SET)); +} + +FileIO &FileIO::operator++(void) +{ + seek(1L,SeekCurrent); + return *this; +} + +FileIO &FileIO::operator--(void) +{ + seek(-1L,SeekCurrent); + return *this; +} + +bool FileIO::seek(LONG seekOffset,SeekFrom seekFrom) +{ + if(!isOkay())return false; + return 0==::fseek(mlpFilePointer,seekOffset,seekFrom)?true:false; +} + diff --git a/common/Fileio.hpp b/common/Fileio.hpp new file mode 100644 index 0000000..59b3d67 --- /dev/null +++ b/common/Fileio.hpp @@ -0,0 +1,93 @@ +#ifndef _COMMON_FILEIO_HPP_ +#define _COMMON_FILEIO_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_STDIO_HPP_ +#include +#endif +#ifndef _COMMON_INTEL_HPP_ +#include +#endif + +class FileIO +{ +public: + enum Mode{ReadOnly,ReadWrite}; + enum ByteOrder{BigEndian,LittleEndian}; + enum SeekFrom{SeekCurrent=SEEK_CUR,SeekEnd=SEEK_END,SeekBeginning=SEEK_SET}; + enum CreationFlags{Create,CreateAlways,None}; + FileIO(void); + FileIO(String pathFileName,ByteOrder byteOrder=LittleEndian,Mode openMode=ReadOnly,CreationFlags creationFlags=None); + virtual ~FileIO(); + bool open(String pathFileName,ByteOrder byteOrder=LittleEndian,Mode openMode=ReadOnly,CreationFlags creationFlags=None); + bool close(void); + bool rewind(void); + bool peek(BYTE &value); + bool read(BYTE &value); + bool read(WORD &value); + bool read(DWORD &value); + bool read(char *lpBuffer,DWORD lengthData); + bool read(BYTE *lpBuffer,DWORD lengthData); + bool read(char *lpBuffer,DWORD lengthData,int stopChar); + bool write(BYTE value); + bool write(WORD value); + bool write(DWORD value); + bool write(char *lpBuffer,DWORD lengthData); + FileIO &operator++(void); + FileIO &operator--(void); + bool seek(LONG seekOffset,SeekFrom seekFrom); + DWORD readLine(String &lineString); + bool writeLine(const String &strLine); + bool isOkay(void)const; + DWORD tell(void)const; + ByteOrder getByteOrder(void)const; + void setByteOrder(ByteOrder byteOrder); +private: + enum {CarriageReturn=0x0D,LineFeed=0x0A,NullChar=0x00}; + FILE *mlpFilePointer; + ByteOrder mByteOrder; +}; + +inline +bool FileIO::isOkay(void)const +{ + return (mlpFilePointer?true:false); +} + +inline +DWORD FileIO::tell(void)const +{ + if(!isOkay())return false; + return ::ftell(mlpFilePointer); +} + +inline +bool FileIO::read(BYTE *lpBuffer,DWORD lengthData) +{ + return read((char*)lpBuffer,lengthData); +} + +inline +bool FileIO::write(BYTE value) +{ + if(!isOkay())return false; + if(1!=::fwrite(&value,1,1,mlpFilePointer))return false; + return true; +} + +inline +FileIO::ByteOrder FileIO::getByteOrder(void)const +{ + return mByteOrder; +} + +inline +void FileIO::setByteOrder(ByteOrder byteOrder) +{ + mByteOrder=byteOrder; +} +#endif diff --git a/common/GDATA.HPP b/common/GDATA.HPP new file mode 100644 index 0000000..87d2afc --- /dev/null +++ b/common/GDATA.HPP @@ -0,0 +1,151 @@ +#ifndef _COMMON_GLOBALDATA_HPP_ +#define _COMMON_GLOBALDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_TYPES_HPP_ +#include +#endif +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif + +template +class GlobalData +{ +public: + GlobalData(void); + GlobalData(const GlobalData &someGlobalData); + GlobalData(DWORD sizeData,UINT globalFlags=GMEM_FIXED); + virtual ~GlobalData(); + DWORD size(void)const; + WORD size(DWORD sizeData,UINT globalFlags=GMEM_FIXED); + UINT globalFlags(void)const; + void globalFlags(UINT globalFlags); + T &operator[](DWORD itemIndex); + WORD operator==(const GlobalData &someGlobalData)const; + GlobalData &operator=(const GlobalData &someGlobalData); + bool setZero(void); + HANDLE getHandle(void)const; + WORD isOkay(void)const; +private: + void destroyGlobalData(void); + WORD createGlobalData(void); + T HUGE *mlpGlobalData; + HGLOBAL mhGlobalData; + UINT mGlobalFlags; + DWORD mSizeData; +}; + +template +inline +GlobalData::GlobalData(void) +: mlpGlobalData(0), mGlobalFlags(GMEM_FIXED), mSizeData(0), mhGlobalData(0) +{ +} + +template +inline +GlobalData::GlobalData(const GlobalData &someGlobalData) +: mlpGlobalData(0), mGlobalFlags(GMEM_FIXED), mSizeData(0), mhGlobalData(0) +{ + *this=someGlobalData; +} + +template +inline +GlobalData::GlobalData(DWORD sizeData,UINT globalFlags) +: mlpGlobalData(0), mGlobalFlags(globalFlags), mSizeData(sizeData), mhGlobalData(0) +{ + createGlobalData(); +} + +template +inline +GlobalData::~GlobalData() +{ + destroyGlobalData(); +} + +template +inline +DWORD GlobalData::size(void)const +{ + return mSizeData; +} + +template +inline +WORD GlobalData::size(DWORD sizeData,UINT globalFlags) +{ + mGlobalFlags=globalFlags; + mSizeData=sizeData; + if(createGlobalData())return TRUE; + mSizeData=0; + mGlobalFlags=GMEM_FIXED; + return FALSE; +} + +template +inline +UINT GlobalData::globalFlags(void)const +{ + return mGlobalFlags; +} + +template +inline +void GlobalData::globalFlags(UINT globalFlags) +{ + mGlobalFlags=globalFlags; +} + +template +inline +T &GlobalData::operator[](DWORD itemIndex) +{ + if(itemIndex>=mSizeData)throw(BoundaryError()); + return *(mlpGlobalData+itemIndex); +} + +template +inline +WORD GlobalData::createGlobalData(void) +{ + destroyGlobalData(); + if(!mSizeData)return FALSE; + mhGlobalData=::GlobalAlloc(mGlobalFlags,mSizeData*sizeof(T)); + if(!mhGlobalData)return FALSE; + mlpGlobalData=(T HUGE*)::GlobalLock(mhGlobalData); + return TRUE; +} + +template +inline +void GlobalData::destroyGlobalData(void) +{ + if(!mlpGlobalData)return; + ::GlobalUnlock(mhGlobalData); + ::GlobalFree(mhGlobalData); + mhGlobalData=0; + mlpGlobalData=0; +} + +template +inline +HANDLE GlobalData::getHandle(void)const +{ + return ::GlobalHandle(mlpGlobalData); +} + +template +inline +WORD GlobalData::isOkay(void)const +{ + return (mlpGlobalData?TRUE:FALSE); +} +#if defined(_MSC_VER) +#include +#endif +#endif + diff --git a/common/GDATA.TPP b/common/GDATA.TPP new file mode 100644 index 0000000..eae3f93 --- /dev/null +++ b/common/GDATA.TPP @@ -0,0 +1,34 @@ +#ifndef _COMMON_GLOBALDATA_TPP_ +#define _COMMON_GLOBALDATA_TPP_ + +template +WORD GlobalData::operator==(const GlobalData &someGlobalData)const +{ + DWORD itemCount(size()); + + if(itemCount!=someGlobalData.size())return FALSE; + for(DWORD itemIndex=0;itemIndex&)*this).operator[](itemIndex)==((GlobalData&)someGlobalData)[itemIndex]))return FALSE; + return TRUE; +} + +template +GlobalData &GlobalData::operator=(const GlobalData &someGlobalData) +{ + DWORD itemCount(someGlobalData.size()); + + size(someGlobalData.size()); + if(!size())return *this; + for(DWORD itemIndex=0;itemIndex&)someGlobalData)[itemIndex]; + return *this; +} + +template +bool GlobalData::setZero(void) +{ + if(!isOkay())return false; + ::memset(mlpGlobalData,0,size()*sizeof(T)); + return true; +} +#endif \ No newline at end of file diff --git a/common/GDIOBJ.HPP b/common/GDIOBJ.HPP new file mode 100644 index 0000000..e95f842 --- /dev/null +++ b/common/GDIOBJ.HPP @@ -0,0 +1,7 @@ +#ifndef _COMMON_GDIOBJ_HPP_ +#define _COMMON_GDIOBJ_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +typedef HGDIOBJ GDIObj; +#endif diff --git a/common/GDIPOINT.CPP b/common/GDIPOINT.CPP new file mode 100644 index 0000000..a67dcf1 --- /dev/null +++ b/common/GDIPOINT.CPP @@ -0,0 +1,30 @@ +#include + +GDIPoint &GDIPoint::operator--(void) +{ + x(x()-1); + y(y()-1); + return *this; +} + +GDIPoint GDIPoint::operator--(int /*prefixDummy*/) +{ + GDIPoint prePoint(*this); + --(*this); + return prePoint; +} + +GDIPoint GDIPoint::operator++(int /*prefixDummy*/) +{ + GDIPoint prePoint(*this); + ++(*this); + return prePoint; +} + +GDIPoint GDIPoint::operator+(const GDIPoint &someGDIPoint)const +{ + GDIPoint tmpPoint(*this); + tmpPoint+=someGDIPoint; + return tmpPoint; +} + diff --git a/common/GDIPOINT.HPP b/common/GDIPOINT.HPP new file mode 100644 index 0000000..7467a80 --- /dev/null +++ b/common/GDIPOINT.HPP @@ -0,0 +1,149 @@ +#ifndef _COMMON_GDIPOINT_HPP_ +#define _COMMON_GDIPOINT_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class GDIPoint : private POINT +{ +public: + GDIPoint(void); + GDIPoint(int x,int y); + GDIPoint(const GDIPoint &someGDIPoint); + virtual ~GDIPoint(); + WORD operator==(const GDIPoint &someGDIPoint)const; + GDIPoint operator+(const GDIPoint &someGDIPoint)const; + GDIPoint &operator=(const GDIPoint &someGDIPoint); + GDIPoint &operator-=(const GDIPoint &someGDIPoint); + GDIPoint &operator+=(const GDIPoint &someGDIPoint); + GDIPoint &operator++(void); + GDIPoint operator++(int prefixDummy); + GDIPoint &operator--(void); + GDIPoint operator--(int prefixDummy); + operator POINT&(void); + int x(void)const; + void x(int newx); + int y(void)const; + void y(int newy); + void setPoint(int newx,int newy); + int distance(const GDIPoint &someGDIPoint)const; + POINT &getPOINT(void); +private: +}; + +inline +GDIPoint::GDIPoint(void) +{ + POINT::x=0; + POINT::y=0; +} + +inline +GDIPoint::GDIPoint(int x,int y) +{ + POINT::x=x; + POINT::y=y; +} + +inline +GDIPoint::GDIPoint(const GDIPoint &someGDIPoint) +{ + *this=someGDIPoint; +} + +inline +GDIPoint::~GDIPoint() +{ +} + +inline +int GDIPoint::x(void)const +{ + return POINT::x; +} + +inline +void GDIPoint::x(int newx) +{ + POINT::x=newx; +} + +inline +int GDIPoint::y(void)const +{ + return POINT::y; +} + +inline +void GDIPoint::y(int newy) +{ + POINT::y=newy; +} + +inline +void GDIPoint::setPoint(int newx,int newy) +{ + POINT::x=newx; + POINT::y=newy; +} + +inline +WORD GDIPoint::operator==(const GDIPoint &someGDIPoint)const +{ + return (x()==someGDIPoint.x()&& + y()==someGDIPoint.y()); +} + +inline +GDIPoint &GDIPoint::operator=(const GDIPoint &someGDIPoint) +{ + x(someGDIPoint.x()); + y(someGDIPoint.y()); + return *this; +} + +inline +GDIPoint &GDIPoint::operator-=(const GDIPoint &someGDIPoint) +{ + x(x()-someGDIPoint.x()); + y(y()-someGDIPoint.y()); + return *this; + return *this; +} + +inline +GDIPoint &GDIPoint::operator+=(const GDIPoint &someGDIPoint) +{ + x(x()+someGDIPoint.x()); + y(y()+someGDIPoint.y()); + return *this; +} + +inline +GDIPoint &GDIPoint::operator++(void) +{ + x(x()+1); + y(y()+1); + return *this; +} + +inline +GDIPoint::operator POINT&(void) +{ + return *this; +} + +inline +int GDIPoint::distance(const GDIPoint &someGDIPoint)const +{ + int xDiff(someGDIPoint.x()-x()); + int yDiff(someGDIPoint.y()-y()); + return (xDiff*xDiff)+(yDiff*yDiff); +} + +inline +POINT &GDIPoint::getPOINT(void) +{ + return *this; +} +#endif diff --git a/common/GL.HPP b/common/GL.HPP new file mode 100644 index 0000000..de46b31 --- /dev/null +++ b/common/GL.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_GL_HPP_ +#define _COMMON_GL_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/GUIWND.CPP b/common/GUIWND.CPP new file mode 100644 index 0000000..eaf253a --- /dev/null +++ b/common/GUIWND.CPP @@ -0,0 +1,501 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +GUIWindow::~GUIWindow() +{ + destroy(); +} + +bool GUIWindow::insertModelessDialog(GUIWindow &modelessDialog) +{ + if(!isValid()||!modelessDialog.isValid())return false; + mModelessDialogs.insert(&WindowPointer(&modelessDialog)); + return true; +} + +void GUIWindow::removeModelessDialog(GUIWindow &modelessDialog) +{ + if(!isValid())return; + mModelessDialogs.remove(&WindowPointer(&modelessDialog)); +} + +GUIWindow &GUIWindow::operator=(const GUIWindow &/*someGUIWindow*/) +{ // private implementation + return *this; +} + +GUIWindow &GUIWindow::operator=(HWND /*hWnd*/) +{ // private implementation + return *this; +} + +BOOL GUIWindow::validate(const Rect &validRect) +{ + if(!isValid())return FALSE; + return ::ValidateRect(mhWnd,(RECT*)((Rect&)validRect)); +} + +WORD GUIWindow::width(void)const +{ + Rect winRect; + clientRect(winRect); + return winRect.right(); +} + +WORD GUIWindow::height(void)const +{ + Rect winRect; + clientRect(winRect); + return winRect.bottom(); +} + +void GUIWindow::windowRect(Rect &windowRect)const +{ + if(!isValid())return; + ::GetWindowRect(*this,(RECT FAR*)windowRect); +} + +void GUIWindow::clientRect(Rect &clientRect)const +{ + if(!isValid())return; + ::GetClientRect(*this,(RECT FAR*)clientRect); +} + +void GUIWindow::setFont(const Font &someFont,BOOL redraw)const +{ + if(!isValid())return; + sendMessage(WM_SETFONT,(WPARAM)(HFONT)someFont,MAKELPARAM(redraw,0)); +} + +WORD GUIWindow::moveWindow(const Rect &winRect,WORD repaint)const +{ + if(!isValid())return FALSE; + return ::MoveWindow(mhWnd,winRect.left(),winRect.top(),(winRect.right()-winRect.left())+1,(winRect.bottom()-winRect.top())+1,repaint); +} + +WORD GUIWindow::moveWindow(int left,int top,int right,int bottom,WORD repaint)const +{ + if(!isValid())return FALSE; + return ::MoveWindow(mhWnd,left,top,right,bottom,repaint); +} + +void GUIWindow::move(const GDIPoint &topLeftPoint,bool repaint) +{ + move(Point(topLeftPoint.x(),topLeftPoint.y()),repaint); +} + +void GUIWindow::move(const Point &topLeftPoint,bool repaint) +{ + RECT windowRect; + + if(!(HWND)*this)return; + ::GetWindowRect(*this,&windowRect); + WORD windowWidth((windowRect.right-windowRect.left)); + WORD windowHeight((windowRect.bottom-windowRect.top)); + ::MoveWindow(*this,topLeftPoint.x(),topLeftPoint.y(),windowWidth,windowHeight,TRUE); + if(repaint)::UpdateWindow(*this); +} + +void GUIWindow::size(const Point &dimensionPoint) +{ + Rect windowRect; + + if(!isValid())return; + ::GetWindowRect(*this,(RECT FAR *)windowRect); + ::MoveWindow(*this,windowRect.left(),windowRect.top(),dimensionPoint.x(),dimensionPoint.y(),FALSE); +} + +BOOL GUIWindow::setCaption(const String &captionString)const +{ + if(!isValid())return FALSE; + return ::SetWindowText(*this,(LPSTR)captionString); +} + +BOOL GUIWindow::setWindowPos(const GDIPoint &startPos,int width,int height)const +{ + if(!isValid())return FALSE; + return ::SetWindowPos(*this,HWND_BOTTOM,startPos.x(),startPos.y(),width,height,SWP_NOZORDER); +} + +int GUIWindow::windowText(String &strText)const +{ + if(!isValid())return FALSE; + strText.reserve(String::MaxString*2); + return ::GetWindowText(*this,strText,String::MaxString*2); +} + +WORD GUIWindow::clientToScreen(Rect &clientRect)const +{ + GDIPoint screenPoint; + + if(!isValid())return FALSE; + screenPoint.x(clientRect.left()); + screenPoint.y(clientRect.top()); + ::ClientToScreen(mhWnd,&((POINT&)screenPoint)); + clientRect.left(screenPoint.x()); + clientRect.top(screenPoint.y()); + screenPoint.x(clientRect.right()); + screenPoint.y(clientRect.bottom()); + ::ClientToScreen(mhWnd,&((POINT&)screenPoint)); + clientRect.right(screenPoint.x()); + clientRect.bottom(screenPoint.y()); + return TRUE; +} + +WORD GUIWindow::screenToClient(Rect &clientRect)const +{ + GDIPoint screenPoint; + + if(!isValid())return FALSE; + screenPoint.x(clientRect.left()); + screenPoint.y(clientRect.top()); + ::ScreenToClient(mhWnd,&((POINT&)screenPoint)); + clientRect.left(screenPoint.x()); + clientRect.top(screenPoint.y()); + screenPoint.x(clientRect.right()); + screenPoint.y(clientRect.bottom()); + ::ScreenToClient(mhWnd,&((POINT&)screenPoint)); + clientRect.right(screenPoint.x()); + clientRect.bottom(screenPoint.y()); + return TRUE; +} + +BOOL GUIWindow::screenToClient(GDIPoint &somePoint)const +{ + if(!isValid())return FALSE; + return ::ScreenToClient(mhWnd,&((POINT&)somePoint)); +} + +BOOL GUIWindow::clientToScreen(GDIPoint &somePoint)const +{ + if(!isValid())return FALSE; + return ::ClientToScreen(mhWnd,&((POINT&)somePoint)); +} + +WORD GUIWindow::killTimer(WORD timerIdentifier) +{ + if(!isValidHandler(VectorHandler::TimerHandler,timerIdentifier))return FALSE; + ::KillTimer((HWND)*this,timerIdentifier); + return FALSE; +} + +void GUIWindow::destroy(void) +{ + if(!isValid())return; + if(disposition()&Destroy)::DestroyWindow((HWND)*this); + setHandle(0); +} + +void GUIWindow::postQuitMessage(int exitCode)const +{ + ::PostQuitMessage(exitCode); +} + +void GUIWindow::yieldTask(void)const +{ + bool isDialogMessage; + MSG msg; + + if(::PeekMessage(&msg,0,0,0,PM_REMOVE)) + { + isDialogMessage=false; + for(int mindex=0;mindexlpCreateParams; + if(!lpGUIWindow)return ::DefWindowProc(hWnd,message,wParam,lParam); + InstanceData::setInstanceData(hWnd,(void FAR*)lpGUIWindow); + lpGUIWindow->setHandle(hWnd); + lpGUIWindow->disposition(Destroy); + return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); + } + else if(WM_INITDIALOG==message) + { + lpGUIWindow=(GUIWindow*)lParam; + if(!lpGUIWindow)return FALSE; + InstanceData::setInstanceData(hWnd,(void FAR*)lpGUIWindow); + lpGUIWindow->setHandle(hWnd); + lpGUIWindow->disposition(Destroy); + return (int)lpGUIWindow->callHandlers(VectorHandler::InitDialogHandler,CallbackData(wParam,lParam,hWnd)); + } + else if(WM_NCDESTROY==message)return ::DefWindowProc(hWnd,message,wParam,lParam); + else return ::DefWindowProc(hWnd,message,wParam,lParam); + } + switch(message) + { + case WM_CREATE : + { + Rect sizeRect; + lpGUIWindow->clientRect(sizeRect); + } + break; + case WM_SIZE : + break; + } + return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); +} + +#if defined(_MSC_VER) +int FAR PASCAL GUIWindow::DlgProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#else +int FAR PASCAL _export GUIWindow::DlgProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#endif +{ + GUIWindow *lpGUIWindow=(GUIWindow*)InstanceData::getInstanceData(hWnd); + if(0==lpGUIWindow) + { + if(WM_INITDIALOG==message) + { + lpGUIWindow=(GUIWindow*)lParam; + if(!lpGUIWindow)return FALSE; + InstanceData::setInstanceData(hWnd,(void FAR*)lpGUIWindow); + lpGUIWindow->setHandle(hWnd); + lpGUIWindow->disposition(Destroy); + return (int)lpGUIWindow->callHandlers(VectorHandler::InitDialogHandler,CallbackData(wParam,lParam,hWnd)); + } + return FALSE; + } + return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); +} + +#if defined(_MSC_VER) +UINT FAR PASCAL GUIWindow::OFHookProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#else +UINT FAR PASCAL _export GUIWindow::OFHookProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#endif +{ + GUIWindow *lpGUIWindow=(GUIWindow*)InstanceData::getInstanceData(hWnd); + if(0==lpGUIWindow) + { + if(WM_INITDIALOG==message) + { + OPENFILENAME *lpOPENFILENAME=(OPENFILENAME*)lParam; + if(!lpOPENFILENAME)return FALSE; + lpGUIWindow=(GUIWindow*)lpOPENFILENAME->lCustData; + if(!lpGUIWindow)return FALSE; + InstanceData::setInstanceData(hWnd,(void FAR*)lpGUIWindow); + lpGUIWindow->setHandle(hWnd); + lpGUIWindow->disposition(Destroy); + return (int)lpGUIWindow->callHandlers(VectorHandler::InitDialogHandler,CallbackData(wParam,lParam,hWnd)); + } + return FALSE; + } + return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); +} + +#if defined(_MSC_VER) +LONG FAR PASCAL GUIWindow::FrameProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#else +LONG FAR PASCAL _export GUIWindow::FrameProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#endif +{ + GUIWindow *lpGUIWindow=(GUIWindow*)InstanceData::getInstanceData(hWnd); + if(lpGUIWindow==0) + { + if(WM_CREATE==message) + { + ::DefFrameProc(hWnd,(HWND)0,message,wParam,lParam); + LPCREATESTRUCT lpcs=(LPCREATESTRUCT)lParam; + lpGUIWindow=(GUIWindow *)lpcs->lpCreateParams; + InstanceData::setInstanceData(hWnd,(void FAR*)lpGUIWindow); + lpGUIWindow->setHandle(hWnd); + lpGUIWindow->disposition(Destroy); + return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); + } + else if(WM_CREATE==message)return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); + else return ::DefFrameProc(hWnd,(HWND)0,message,wParam,lParam); + } + else return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); +} + +#if defined(_MSC_VER) +LONG FAR PASCAL GUIWindow::MDIProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#else +LONG FAR PASCAL _export GUIWindow::MDIProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +#endif +{ + GUIWindow *lpGUIWindow=(GUIWindow*)InstanceData::getInstanceData(hWnd); + + if(lpGUIWindow==0) + { + if(WM_NCCREATE==message) + { + ::DefMDIChildProc(hWnd,message,wParam,lParam); + LPCREATESTRUCT lpcs=(LPCREATESTRUCT)lParam; + LPMDICREATESTRUCT lpcm=(LPMDICREATESTRUCT)lpcs->lpCreateParams; + lpGUIWindow=(GUIWindow *)lpcm->lParam; + if(!lpGUIWindow)return FALSE; + InstanceData::setInstanceData(hWnd,(void FAR*)lpGUIWindow); + lpGUIWindow->setHandle(hWnd); + lpGUIWindow->disposition(Destroy); + return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); + } + else if(WM_CREATE==message)return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); + else return ::DefMDIChildProc(hWnd,message,wParam,lParam); + } + else return lpGUIWindow->windowProcedure(hWnd,message,wParam,lParam); +} diff --git a/common/Guiwnd.hpp b/common/Guiwnd.hpp new file mode 100644 index 0000000..263c079 --- /dev/null +++ b/common/Guiwnd.hpp @@ -0,0 +1,401 @@ +#ifndef _COMMON_GUIWINDOW_HPP_ +#define _COMMON_GUIWINDOW_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_VECTORHANDLER_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_SMARTPOINTER_HPP_ +#include +#endif +#ifndef _COMMON_ACCELERATOR_HPP_ +#include +#endif + +class String; +class Rect; +class PureMenu; +class Control; +class Font; +class Point; +class GDIPoint; + +#ifndef _MSC_VER +#ifdef enable +#undef enable +#endif +#endif +class GUIWindow : public VectorHandler +{ +friend class Control; +public: + GUIWindow(void); + virtual ~GUIWindow(); + WORD operator==(const GUIWindow &someGUIWindow)const; + operator HWND(void)const; + bool loadAccelerators(const String &strAcceleratorTable); + bool loadAccelerators(UINT resID); + WORD enable(WORD isEnabled)const; + void setFocus(void)const; + void setFocus(GUIWindow &someGUIWindow)const; + BOOL setCaption(const String &captionString)const; + int show(int nCmdShow=SW_SHOW)const; + void update(void)const; + void clear(void)const; + void invalidate(WORD eraseBackground=TRUE)const; + void invalidate(const Rect &invalidRect,BOOL eraseBackground=TRUE)const; + BOOL validate(const Rect &validRect); + void clientRect(Rect &clientRect)const; + void windowRect(Rect &windowRect)const; + int windowText(String &strText)const; + WORD clientToScreen(Rect &clientRect)const; + WORD screenToClient(Rect &clientRect)const; + BOOL screenToClient(GDIPoint &somePoint)const; + BOOL clientToScreen(GDIPoint &somePoint)const; + void size(const Point &dimensionPoint); + WORD moveWindow(const Rect &winRect,WORD repaint=TRUE)const; + WORD moveWindow(int left,int top,int right,int bottom,WORD repaint=TRUE)const; + WORD top(void)const; + void move(const Point &topLeftPoint,bool repaint=TRUE); + void move(const GDIPoint &topleftPoint,bool repaint=true); + WORD setTimer(WORD timerIdentifier,UINT timeOut); + HINSTANCE processInstance(void)const; + HWND findWindow(const String &strWindowName)const; + HWND createWindow(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,HMENU hMenu,HINSTANCE hInstance=0,void FAR *lpInstanceData=0); + HWND createWindow(DWORD dwExStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,HMENU hMenu,HINSTANCE hInstance=0,void FAR *lpInstanceData=0); + LRESULT postMessage(HWND hPostWindow,UINT message,WPARAM wParam,LPARAM lParam)const; + LRESULT sendMessage(HWND hPostWindow,UINT message,WPARAM wParam,LPARAM lParam)const; + LRESULT sendMessage(UINT message,WPARAM wParam,LPARAM lParam)const; + void setFont(const Font &someFont,BOOL redraw=TRUE)const; + WORD killTimer(WORD timerIdentifier); + WORD width(void)const; + BOOL width(WORD width); + WORD height(void)const; + bool hasChildren(void)const; + HWND getChild(void)const; + BOOL height(WORD height); + BOOL setWindowPos(int width,int height)const; + BOOL setWindowPos(const GDIPoint &startPoint,int width,int height)const; + void destroy(void); + void close(void); + void postQuitMessage(int exitCode=0)const; + WORD isVisible(void)const; + WORD isIconic(void)const; + HWND parent(void)const; + HWND setCapture(void)const; + bool hasCapture(void)const; + BOOL setRedraw(BOOL redrawFlag)const; + BOOL setMenu(const PureMenu &somePureMenu)const; + BOOL setIcon(const String &strResIcon); + BOOL drawMenuBar(void)const; + BOOL releaseCapture(void)const; + BOOL bringWindowToTop(void)const; + BOOL isWindowVisible(void)const; + String getClassName(void)const; + WORD isValid(void)const; + bool flash(BOOL invert)const; + bool insertModelessDialog(GUIWindow &modelessDialog); + void removeModelessDialog(GUIWindow &modelessDialog); + HMENU getMenu(void)const; + virtual int messageLoop(void)const; + virtual void yieldTask(void)const; + HWND getHandle(void)const; +protected: + enum Disposition{Destroy=0x01,Assume=0x02,AssumeAndDestroy=0x03}; + GUIWindow(HWND hWnd); + GUIWindow(const GUIWindow &someGUIWindow); + GUIWindow &operator=(const GUIWindow &someGUIWindow); + GUIWindow &operator=(HWND hWnd); + void setHandle(HWND hWnd); + LONG handlePaintMessage(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam); + virtual int windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam); +#if defined(_MSC_VER) + __declspec(dllexport) static LONG FAR PASCAL WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + __declspec(dllexport) static BOOL FAR PASCAL DlgProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + __declspec(dllexport) static UINT FAR PASCAL OFHookProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + __declspec(dllexport) static LONG FAR PASCAL FrameProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + __declspec(dllexport) static LONG FAR PASCAL MDIProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); +#else + static LONG FAR PASCAL _export WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + static int FAR PASCAL _export DlgProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + static UINT FAR PASCAL OFHookProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + static LONG FAR PASCAL _export FrameProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + static LONG FAR PASCAL _export MDIProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); +#endif +private: + typedef SmartPointer WindowPointer; + typedef Block WindowPointerList; + Disposition disposition(void)const; + void disposition(Disposition disposition); + + Disposition mDisposition; + WindowPointerList mModelessDialogs; + Accelerator mAccelerator; + HWND mhWnd; +}; + +inline +GUIWindow::GUIWindow(void) +: mhWnd(0), mDisposition(Destroy) +{ +} + +inline +GUIWindow::GUIWindow(HWND hWnd) +: mhWnd(0), mDisposition(Assume) +{ // private implementation + *this=hWnd; +} + +inline +GUIWindow::GUIWindow(const GUIWindow &someGUIWindow) +: mhWnd(0), mDisposition(Assume) +{ // private implementation + *this=someGUIWindow; +} + +inline +GUIWindow::operator HWND(void)const +{ + return (isValid()?mhWnd:0); +} + +inline +HMENU GUIWindow::getMenu(void)const +{ + return (isValid()?::GetMenu(mhWnd):0); +} + +inline +void GUIWindow::setHandle(HWND hWnd) +{ + mhWnd=hWnd; +} + +inline +WORD GUIWindow::operator==(const GUIWindow &someGUIWindow)const +{ + return (HWND)*this==(HWND)someGUIWindow; +} + +inline +BOOL GUIWindow::width(WORD width) +{ + return setWindowPos(width,height()); +} + +inline +BOOL GUIWindow::height(WORD height) +{ + return setWindowPos(width(),height); +} + +inline +BOOL GUIWindow::setWindowPos(int width,int height)const +{ + if(!isValid())return FALSE; + return ::SetWindowPos(*this,HWND_BOTTOM,0,0,width,height,SWP_NOMOVE|SWP_NOZORDER); +} + +inline +WORD GUIWindow::enable(WORD isEnabled)const +{ + if(!isValid())return FALSE; + return ::EnableWindow(mhWnd,isEnabled); +} + +inline +void GUIWindow::setFocus(void)const +{ + if(isValid())::SetFocus(mhWnd); +} + +inline +void GUIWindow::setFocus(GUIWindow &someGUIWindow)const +{ + if(!isValid()||!someGUIWindow.isValid())return; + ::SetFocus(someGUIWindow); +} + +inline +WORD GUIWindow::top(void)const +{ + if(!isValid())return FALSE; + return ::BringWindowToTop(mhWnd); +} + +inline +int GUIWindow::show(int nCmdShow)const +{ + if(isValid())return ::ShowWindow(mhWnd,nCmdShow); + return FALSE; +} + +inline +void GUIWindow::update(void)const +{ + if(isValid())::UpdateWindow(mhWnd); +} + +inline +void GUIWindow::clear(void)const +{ + if(!isValid())return; + ::InvalidateRect(mhWnd,0,TRUE); + ::UpdateWindow(mhWnd); +} + +inline +void GUIWindow::invalidate(WORD eraseBackGround)const +{ + if(!isValid())return; + ::InvalidateRect(mhWnd,0,eraseBackGround); +} + +inline +void GUIWindow::invalidate(const Rect &invalidRect,BOOL eraseBackground)const +{ + if(!isValid())return; +// ::InvalidateRect(mhWnd,&(RECT&)invalidRect,eraseBackground); + ::InvalidateRect(mhWnd,&((Rect&)invalidRect).getRect(),eraseBackground); +} + +inline +void GUIWindow::close(void) +{ + if(!isValid())return; + sendMessage(*this,WM_CLOSE,0,0L); +} + +inline +WORD GUIWindow::setTimer(WORD timerIdentifier,UINT timeOut) +{ + if(!isValidHandler(VectorHandler::TimerHandler,timerIdentifier))return FALSE; + ::SetTimer((HWND)*this,timerIdentifier,timeOut,0); + return TRUE; +} + +inline +GUIWindow::Disposition GUIWindow::disposition(void)const +{ + return mDisposition; +} + +inline +void GUIWindow::disposition(Disposition disposition) +{ + mDisposition=disposition; +} + +inline +WORD GUIWindow::isVisible(void)const +{ + if(!isValid())return FALSE; + return ::IsWindowVisible(mhWnd); +} + +inline +WORD GUIWindow::isIconic(void)const +{ + if(!isValid())return FALSE; + return ::IsIconic(mhWnd); +} + +inline +HWND GUIWindow::parent(void)const +{ + if(!isValid())return (HWND)0; + return ::GetParent(mhWnd); +} + +inline +BOOL GUIWindow::releaseCapture(void)const +{ + return ::ReleaseCapture(); +} + +inline +HWND GUIWindow::setCapture(void)const +{ + if(!isValid())return FALSE; + return ::SetCapture(mhWnd); +} + +inline +bool GUIWindow::hasCapture(void)const +{ + if(!isValid())return false; + return mhWnd==::GetCapture(); +} + +inline +BOOL GUIWindow::setRedraw(BOOL redrawFlag)const +{ + if(!isValid())return FALSE; + sendMessage(WM_SETREDRAW,redrawFlag,0L); + return TRUE; +} + +inline +BOOL GUIWindow::bringWindowToTop(void)const +{ + if(!isValid())return FALSE; + return ::BringWindowToTop(mhWnd); +} + +inline +BOOL GUIWindow::isWindowVisible(void)const +{ + if(!isValid())return FALSE; + return ::IsWindowVisible(mhWnd); +} + +inline +bool GUIWindow::hasChildren(void)const +{ + if(!isValid())return false; + return (::GetWindow(mhWnd,GW_CHILD)?true:false); +} + +inline +HWND GUIWindow::getChild(void)const +{ + if(!isValid())return (HWND)0; + return ::GetWindow(mhWnd,GW_CHILD); +} + +inline +bool GUIWindow::flash(BOOL invert)const +{ + if(!isValid())return false; + return ::FlashWindow(mhWnd,invert); +} + +inline +bool GUIWindow::loadAccelerators(const String &strAcceleratorTable) +{ + return mAccelerator.loadAccelerators(strAcceleratorTable); +} + +inline +bool GUIWindow::loadAccelerators(UINT resID) +{ + return mAccelerator.loadAccelerators(resID); +} + +inline +HWND GUIWindow::getHandle(void)const +{ + return mhWnd; +} + +inline +WORD GUIWindow::isValid(void)const +{ + return (mhWnd&&::IsWindow(mhWnd)); +} +#endif diff --git a/common/HEAP.HPP b/common/HEAP.HPP new file mode 100644 index 0000000..36207a8 --- /dev/null +++ b/common/HEAP.HPP @@ -0,0 +1,66 @@ +#ifndef _COMMON_HEAP_HPP_ +#define _COMMON_HEAP_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class Heap +{ +public: + Heap(void); + Heap(DWORD initialSize); + virtual ~Heap(); + LPVOID heapAlloc(DWORD allocLength); + BOOL heapFree(LPVOID pHeapData); + void heapDestroy(void); +private: + enum {PageLength=4096}; + Heap(const Heap& someHeap); + HANDLE mhHeap; +}; + +inline +Heap::Heap(void) +: mhHeap(::HeapCreate(0,PageLength,0)) +{ +} + +inline +Heap::Heap(DWORD initialSize) +: mhHeap(::HeapCreate(0,initialSize,0)) +{ +} + +inline +Heap::~Heap() +{ + heapDestroy(); +} + +inline +LPVOID Heap::heapAlloc(DWORD allocLength) +{ + if(!mhHeap)return FALSE; + return ::HeapAlloc(mhHeap,0,allocLength); +} + +inline +BOOL Heap::heapFree(LPVOID pHeapData) +{ + if(!pHeapData||!mhHeap)return FALSE; + return ::HeapFree(mhHeap,0,pHeapData); +} + +inline +Heap::Heap(const Heap &/*someHeap*/) +{ +} + +inline +void Heap::heapDestroy(void) +{ + if(!mhHeap)return; + ::HeapDestroy(mhHeap); + mhHeap=0; +} +#endif diff --git a/common/HEAPNEW.HPP b/common/HEAPNEW.HPP new file mode 100644 index 0000000..e2e4df9 --- /dev/null +++ b/common/HEAPNEW.HPP @@ -0,0 +1,20 @@ +#ifndef _COMMON_HEAPNEW_HPP_ +#define _COMMON_HEAPNEW_HPP_ +#if defined(_FASTHEAP_) +#include + +Heap &globalHeap(void); + +inline +void *operator new(size_t size) +{ + return globalHeap().heapAlloc(size); +} + +inline +void operator delete(void *pData) +{ + globalHeap().heapFree(pData); +} +#endif +#endif \ No newline at end of file diff --git a/common/HOOKPROC.CPP b/common/HOOKPROC.CPP new file mode 100644 index 0000000..965d061 --- /dev/null +++ b/common/HOOKPROC.CPP @@ -0,0 +1,290 @@ +#include +#include +#include + +WinHookProc::WinHookProc(HookType hookType) +: mPrevHook(0), mhHookWnd(0), mHookType(hookType) +{ +} + +WinHookProc::~WinHookProc() +{ + unhookWin(); +} + +BOOL WinHookProc::hookWin(HWND hWnd) +{ + unhookWin(); + windowHandle(hWnd); + if(!windowHandle())return FALSE; + ::SetProp(windowHandle(),(LPSTR)"INSTANCEDATA@@NEARPTR",(HANDLE)((void*)this)); + prevHook((WNDPROC)::SetWindowLong(windowHandle(),winID(),(DWORD)hookProc)); + return TRUE; +} + +BOOL WinHookProc::unhookWin(void) +{ + if(!isOkay()||!prevHook())return FALSE; + ::SetWindowLong(windowHandle(),winID(),(DWORD)prevHook()); + ::RemoveProp(windowHandle(),(LPSTR)"INSTANCEDATA@@NEARPTR"); + prevHook(0); + windowHandle(0); + return TRUE; +} + +DWORD WinHookProc::winID(void)const +{ + return GWL_WNDPROC; +} + +BOOL WinHookProc::isOkay(void)const +{ + return (windowHandle()?TRUE:FALSE); +} + +LRESULT CALLBACK WinHookProc::hookProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) +{ + LRESULT callResult; + WinHookProc *pWinHookProc=(WinHookProc*)::GetProp(hWnd,"INSTANCEDATA@@NEARPTR"); + if(!pWinHookProc)return ::DefWindowProc(hWnd,msg,wParam,lParam); + + if(WinHookProc::HookBefore==pWinHookProc->hookType()) + { + CallbackDataHook callbackDataHook(pWinHookProc->windowProcedure(hWnd,msg,wParam,lParam)); + if(!callbackDataHook.hookReturnCode())callResult=::CallWindowProc(pWinHookProc->mPrevHook,hWnd,msg,wParam,lParam); + else callResult=callbackDataHook.hookReturnCode(); + } + else + { + callResult=::CallWindowProc(pWinHookProc->mPrevHook,hWnd,msg,wParam,lParam); + pWinHookProc->windowProcedure(hWnd,msg,wParam,lParam); + } + if(WM_NCDESTROY==msg)pWinHookProc->unhookWin(); + return callResult; +} + +CallbackDataHook WinHookProc::windowProcedure(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) +{ + CallbackDataHook callbackData(wParam,lParam,hWnd); + switch(message) + { + case WM_NCCREATE : + if(!installedHandlers(VectorHandler::NCCreateHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::NCCreateHandler,callbackData)); + break; + case WM_CREATE : + if(!installedHandlers(VectorHandler::CreateHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::CreateHandler,callbackData)); + break; + case WM_PAINT : + if(!installedHandlers(VectorHandler::PaintHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::PaintHandler,callbackData)); + break; + case WM_DRAWITEM : + if(!installedHandlers(VectorHandler::DrawItemHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DrawItemHandler,callbackData)); + break; + case WM_TIMER : + if(!installedHandlers(VectorHandler::TimerHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::TimerHandler,callbackData)); + break; + case WM_CHAR : + if(!installedHandlers(VectorHandler::CharHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::CharHandler,callbackData)); + break; + case WM_COMMAND : + if(!installedHandlers(VectorHandler::CommandHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::CommandHandler,callbackData)); + break; + case WM_COMPACTING : + if(!installedHandlers(VectorHandler::CompactingHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::CompactingHandler,callbackData)); + break; + case WM_WININICHANGE : + if(!installedHandlers(VectorHandler::WinIniChangeHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::WinIniChangeHandler,callbackData)); + break; + case WM_SYSCOLORCHANGE : + if(!installedHandlers(VectorHandler::SysColorChangeHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::SysColorChangeHandler,callbackData)); + case WM_CTLCOLOR : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLORMSGBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLOREDIT : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLORLISTBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLORBTN : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLORDLG : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLORSCROLLBAR : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_CTLCOLORSTATIC : + if(!installedHandlers(VectorHandler::ControlColorHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::ControlColorHandler,callbackData)); + break; + case WM_DDE_INITIATE : + if(!installedHandlers(VectorHandler::DDEInitiateHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DDEInitiateHandler,callbackData)); + break; + case WM_DDE_ACK : + if(!installedHandlers(VectorHandler::DDEAckHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DDEAckHandler,callbackData)); + break; + case WM_DDE_REQUEST : + if(!installedHandlers(VectorHandler::DDERequestHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DDERequestHandler,callbackData)); + break; + case WM_DDE_TERMINATE : + if(!installedHandlers(VectorHandler::DDETerminateHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DDETerminateHandler,callbackData)); + break; + case WM_DDE_DATA : + if(!installedHandlers(VectorHandler::DDEDataHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DDEDataHandler,callbackData)); + break; + case MM_WOM_OPEN : + if(!installedHandlers(VectorHandler::MMOpenHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MMOpenHandler,callbackData)); + break; + case MM_WOM_CLOSE : + if(!installedHandlers(VectorHandler::MMCloseHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MMCloseHandler,callbackData)); + break; + case MM_WOM_DONE : + if(!installedHandlers(VectorHandler::MMDoneHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MMDoneHandler,callbackData)); + break; + case WM_LBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::LeftButtonDoubleHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::LeftButtonDoubleHandler,callbackData)); + break; + case WM_LBUTTONDOWN : + if(!installedHandlers(VectorHandler::LeftButtonDownHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::LeftButtonDownHandler,callbackData)); + break; + case WM_LBUTTONUP : + if(!installedHandlers(VectorHandler::LeftButtonUpHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::LeftButtonUpHandler,callbackData)); + break; + case WM_RBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::RightButtonDoubleHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::RightButtonDoubleHandler,callbackData)); + break; + case WM_RBUTTONDOWN : + if(!installedHandlers(VectorHandler::RightButtonDownHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::RightButtonDownHandler,callbackData)); + break; + case WM_RBUTTONUP : + if(!installedHandlers(VectorHandler::RightButtonUpHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::RightButtonUpHandler,callbackData)); + break; + case WM_NCLBUTTONUP : + if(!installedHandlers(VectorHandler::NCLeftButtonUpHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::NCLeftButtonUpHandler,callbackData)); + break; + case WM_NCLBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCLeftButtonDownHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::NCLeftButtonDownHandler,callbackData)); + break; + case WM_NCRBUTTONUP : + if(!installedHandlers(VectorHandler::NCRightButtonUpHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::NCRightButtonUpHandler,callbackData)); + break; + case WM_NCRBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCRightButtonDownHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::NCRightButtonDownHandler,callbackData)); + break; + case WM_MOUSEMOVE : + if(!installedHandlers(VectorHandler::MouseMoveHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MouseMoveHandler,callbackData)); + break; + case WM_SETFOCUS : + if(!installedHandlers(VectorHandler::SetFocusHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::SetFocusHandler,callbackData)); + break; + case WM_SETFONT : + if(!installedHandlers(VectorHandler::SetFontHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::SetFontHandler,callbackData)); + break; + case WM_KILLFOCUS : + if(!installedHandlers(VectorHandler::KillFocusHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::KillFocusHandler,callbackData)); + break; + case WM_KEYUP : + if(!installedHandlers(VectorHandler::KeyUpHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::KeyUpHandler,callbackData)); + break; + case WM_KEYDOWN : + if(!installedHandlers(VectorHandler::KeyDownHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::KeyDownHandler,callbackData)); + break; + case WM_GETMINMAXINFO : + if(!installedHandlers(VectorHandler::MinMaxHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MinMaxHandler,callbackData)); + break; + case WM_ENTERIDLE : + if(!installedHandlers(VectorHandler::EnterIdleHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::EnterIdleHandler,callbackData)); + break; + case WM_MENUSELECT : + if(!installedHandlers(VectorHandler::MenuSelectHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MenuSelectHandler,callbackData)); + break; + case WM_GETDLGCODE : + if(!installedHandlers(VectorHandler::DialogCodeHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DialogCodeHandler,callbackData)); + break; + case WM_MEASUREITEM : + if(!installedHandlers(VectorHandler::MeasureItemHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::MeasureItemHandler,callbackData)); + break; + case WM_VSCROLL : + if(!installedHandlers(VectorHandler::VerticalScrollHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::VerticalScrollHandler,callbackData)); + break; + case WM_HSCROLL : + if(!installedHandlers(VectorHandler::HorizontalScrollHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::HorizontalScrollHandler,callbackData)); + break; +#if defined(__FLAT__) + case WM_NOTIFY : + if(!installedHandlers(VectorHandler::NotifyHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::NotifyHandler,callbackData)); + break; +#endif + case WM_SIZE : + if(!installedHandlers(VectorHandler::SizeHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::SizeHandler,callbackData)); + break; + case WM_DROPFILES : + if(!installedHandlers(VectorHandler::DropFilesHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DropFilesHandler,callbackData)); + break; + case WM_DESTROY : + if(!installedHandlers(VectorHandler::DestroyHandler))break; + callbackData.hookReturnCode(callHandlers(VectorHandler::DestroyHandler,callbackData)); + break; + case WM_NCDESTROY : + default : + callbackData.hookReturnCode(FALSE); + break; + } + return callbackData; +} diff --git a/common/HOOKPROC.HPP b/common/HOOKPROC.HPP new file mode 100644 index 0000000..9981b3b --- /dev/null +++ b/common/HOOKPROC.HPP @@ -0,0 +1,75 @@ +#ifndef _COMMON_HOOKPROC_HPP_ +#define _COMMON_HOOKPROC_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_VECTORHANDLER_HPP_ +#include +#endif +#ifndef _COMMON_CALLBACKDATAHOOK_HPP_ +#include +#endif + + + +class WinHookProc : public VectorHandler +{ +public: + enum HookType{HookBefore,HookAfter}; + WinHookProc(HookType hookType=HookBefore); + virtual ~WinHookProc(); + BOOL hookWin(HWND hWnd); + BOOL unhookWin(void); + HookType hookType(void)const; + void hookType(HookType hookType); + BOOL isOkay(void)const; +protected: + virtual DWORD winID(void)const; + CallbackDataHook windowProcedure(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam); + WNDPROC prevHook(void)const; + void prevHook(WNDPROC prevHook); + HWND windowHandle(void)const; + void windowHandle(HWND windowHandle); +private: + static LRESULT CALLBACK hookProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam); + WNDPROC mPrevHook; + HWND mhHookWnd; + HookType mHookType; +}; + +inline +WinHookProc::HookType WinHookProc::hookType(void)const +{ + return mHookType; +} + +inline +void WinHookProc::hookType(HookType hookType) +{ + mHookType=hookType; +} + +inline +WNDPROC WinHookProc::prevHook(void)const +{ + return mPrevHook; +} + +inline +void WinHookProc::prevHook(WNDPROC prevHook) +{ + mPrevHook=prevHook; +} + +inline +HWND WinHookProc::windowHandle(void)const +{ + return mhHookWnd; +} + +inline +void WinHookProc::windowHandle(HWND windowHandle) +{ + mhHookWnd=windowHandle; +} +#endif diff --git a/common/ICONBMP.HPP b/common/ICONBMP.HPP new file mode 100644 index 0000000..68155ce --- /dev/null +++ b/common/ICONBMP.HPP @@ -0,0 +1,86 @@ +#ifndef _COMMON_ICONBITMAP_HPP_ +#define _COMMON_ICONBITMAP_HPP_ +#ifndef _COMMON_PUREBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_PUREICON_HPP_ +#include +#endif + +class IconBitmap +{ +public: + IconBitmap(void); + IconBitmap(const PureIcon &somePureIcon); + IconBitmap(const IconBitmap &someIconBitmap); + virtual ~IconBitmap(); + IconBitmap &operator=(const IconBitmap &someIconBitmap); + IconBitmap &operator=(const PureIcon &somePureIcon); + WORD operator==(const IconBitmap &someIconBitmap)const; + PureBitmap &maskBitmap(void); + PureBitmap &colorBitmap(void); +private: + PureBitmap mMaskBitmap; + PureBitmap mColorBitmap; +}; + +inline +IconBitmap::IconBitmap(void) +{ +} + +inline +IconBitmap::IconBitmap(const PureIcon &somePureIcon) +{ + *this=somePureIcon; +} + +inline +IconBitmap::IconBitmap(const IconBitmap &someIconBitmap) +{ + *this=someIconBitmap; +} + +inline +IconBitmap::~IconBitmap() +{ +} + +inline +IconBitmap &IconBitmap::operator=(const IconBitmap &someIconBitmap) +{ + mMaskBitmap=someIconBitmap.mMaskBitmap; + mColorBitmap=someIconBitmap.mColorBitmap; + return *this; +} + +inline +IconBitmap &IconBitmap::operator=(const PureIcon &somePureIcon) +{ + if(somePureIcon.isOkay()) + { + mMaskBitmap=somePureIcon.maskBitmap(); + mColorBitmap=somePureIcon.colorBitmap(); + } + return *this; +} + +inline +WORD IconBitmap::operator==(const IconBitmap &someIconBitmap)const +{ + return (mMaskBitmap==someIconBitmap.mMaskBitmap&& + mColorBitmap==someIconBitmap.mMaskBitmap); +} + +inline +PureBitmap &IconBitmap::maskBitmap(void) +{ + return mMaskBitmap; +} + +inline +PureBitmap &IconBitmap::colorBitmap(void) +{ + return mColorBitmap; +} +#endif diff --git a/common/ICONFRM.CPP b/common/ICONFRM.CPP new file mode 100644 index 0000000..442c3fc --- /dev/null +++ b/common/ICONFRM.CPP @@ -0,0 +1,26 @@ +#include + +void IconFrame::drawFrame(PureDevice &displayDevice,IconBitmap &someIconBitmap,const Point &xyPoint) +{ + PureDevice bkCurrDevice; + PureDevice srcDevice; + PureDevice maskDevice; + + srcDevice.compatibleDevice(displayDevice); + maskDevice.compatibleDevice(displayDevice); + bkCurrDevice.compatibleDevice(displayDevice); + if(!mBitmapBkGnd.isOkay()||!(mCurrentPoint==xyPoint)) + { + if(mBitmapBkGnd.isOkay())displayDevice.bitBlt(Rect(mCurrentPoint.x(),mCurrentPoint.y(),someIconBitmap.colorBitmap().width(),someIconBitmap.colorBitmap().height()),bkCurrDevice,Point(0,0),PureDevice::SourceCopy); + mCurrentPoint=xyPoint; + mBitmapBkGnd.compatibleBitmap(displayDevice,someIconBitmap.colorBitmap().width(),someIconBitmap.colorBitmap().height()); + bkCurrDevice.select(mBitmapBkGnd); + bkCurrDevice.bitBlt(Rect(0,0,someIconBitmap.colorBitmap().width(),someIconBitmap.colorBitmap().height()),displayDevice,Point(mCurrentPoint.x(),mCurrentPoint.y()),PureDevice::SourceCopy); + } + else bkCurrDevice.select(mBitmapBkGnd); + displayDevice.bitBlt(Rect(mCurrentPoint.x(),mCurrentPoint.y(),someIconBitmap.colorBitmap().width(),someIconBitmap.colorBitmap().height()),bkCurrDevice,Point(0,0),PureDevice::SourceCopy); + srcDevice.select(someIconBitmap.colorBitmap()); + maskDevice.select(someIconBitmap.maskBitmap()); + displayDevice.bitBlt(Rect(mCurrentPoint.x(),mCurrentPoint.y(),someIconBitmap.colorBitmap().width(),someIconBitmap.colorBitmap().height()),maskDevice,Point(0,0),PureDevice::SourceAnd); + displayDevice.bitBlt(Rect(mCurrentPoint.x(),mCurrentPoint.y(),someIconBitmap.colorBitmap().width(),someIconBitmap.colorBitmap().height()),srcDevice,Point(0,0),PureDevice::SourcePaint); +} diff --git a/common/ICONFRM.HPP b/common/ICONFRM.HPP new file mode 100644 index 0000000..74e0687 --- /dev/null +++ b/common/ICONFRM.HPP @@ -0,0 +1,84 @@ +#ifndef _COMMON_ICONFRAME_HPP_ +#define _COMMON_ICONFRAME_HPP_ +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_PUREICON_HPP_ +#include +#endif +#ifndef _COMMON_ICONBITMAP_HPP_ +#include +#endif + +class IconFrame : public Block +{ +public: + IconFrame(void); + IconFrame(const IconFrame &someIconFrame); + virtual ~IconFrame(); + IconFrame &operator+=(const PureIcon &somePureIcon); + IconFrame &operator=(const IconFrame &someIconFrame); + WORD operator==(const IconFrame &someIconFrame)const; + WORD drawIcon(PureDevice &somePureDevice,const Point &xyPoint); + void remove(void); +private: + void drawFrame(PureDevice &displayDevice,IconBitmap &someIconBitmap,const Point &xyPoint); + + Point mCurrentPoint; + WORD mCurrentFrame; + PureBitmap mBitmapBkGnd; +}; + +inline +IconFrame::IconFrame(void) +: mCurrentFrame(0) +{ +} + +inline +IconFrame::IconFrame(const IconFrame &someIconFrame) +{ + *this=someIconFrame; +} + +inline +IconFrame::~IconFrame() +{ +} + +inline +IconFrame &IconFrame::operator+=(const PureIcon &somePureIcon) +{ + if(somePureIcon.isOkay())insert(&IconBitmap(somePureIcon)); + return *this; +} + +inline +IconFrame &IconFrame::operator=(const IconFrame &someIconFrame) +{ + (Block&)*this=(Block&)someIconFrame; + return *this; +} + +inline +WORD IconFrame::operator==(const IconFrame &someIconFrame)const +{ + return (Block&)*this==(Block&)someIconFrame; +} + +inline +void IconFrame::remove(void) +{ + Block::remove(); +} + +inline +WORD IconFrame::drawIcon(PureDevice &somePureDevice,const Point &xyPoint) +{ + if(!size())return FALSE; + if(mCurrentFrame>=size())mCurrentFrame=0; + drawFrame(somePureDevice,operator[](mCurrentFrame),xyPoint); + mCurrentFrame++; + return TRUE; +} +#endif diff --git a/common/ICONINFO.HPP b/common/ICONINFO.HPP new file mode 100644 index 0000000..1e0cc74 --- /dev/null +++ b/common/ICONINFO.HPP @@ -0,0 +1,138 @@ +#ifndef _COMMON_ICONINFO_HPP_ +#define _COMMON_ICONINFO_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class IconInfo : private _ICONINFO +{ +public: + enum IconType{TypeIcon=0x0000,TypeCursor=0x0001}; + IconInfo(void); + IconInfo(const IconInfo &someIconInfo); + ~IconInfo(); + operator _ICONINFO&(void); + IconInfo &operator=(const IconInfo &someIconInfo); + WORD operator==(const IconInfo &someIconInfo); + IconType iconType(void)const; + DWORD xHotSpot(void)const; + DWORD yHotSpot(void)const; + HBITMAP maskBitmap(void)const; + HBITMAP colorBitmap(void)const; +protected: + void maskBitmap(HBITMAP hMaskBitmap); + void colorBitmap(HBITMAP hColorBitmap); +private: + void iconType(IconType iconType); + void xHotSpot(DWORD xHotSpot); + void yHotSpot(DWORD yHotSpot); +}; + +inline +IconInfo::IconInfo(void) +{ + iconType(TypeIcon); + xHotSpot(0); + yHotSpot(0); + maskBitmap(0); + colorBitmap(0); +} + +inline +IconInfo::IconInfo(const IconInfo &someIconInfo) +{ + *this=someIconInfo; +} + +inline +IconInfo::~IconInfo() +{ +} + +inline +IconInfo::operator _ICONINFO&(void) +{ + return *this; +} + +inline +IconInfo &IconInfo::operator=(const IconInfo &someIconInfo) +{ + iconType(someIconInfo.iconType()); + xHotSpot(someIconInfo.xHotSpot()); + yHotSpot(someIconInfo.yHotSpot()); + maskBitmap(someIconInfo.maskBitmap()); + colorBitmap(someIconInfo.colorBitmap()); + return *this; +} + +inline +WORD IconInfo::operator==(const IconInfo &someIconInfo) +{ + return (iconType()==someIconInfo.iconType()&& + xHotSpot()==someIconInfo.xHotSpot()&& + yHotSpot()==someIconInfo.yHotSpot()&& + maskBitmap()==someIconInfo.maskBitmap()&& + colorBitmap()==someIconInfo.colorBitmap()); +} + +inline +IconInfo::IconType IconInfo::iconType(void)const +{ + return (IconType)_ICONINFO::fIcon; +} + +inline +void IconInfo::iconType(IconType iconType) +{ + _ICONINFO::fIcon=(WORD)iconType; +} + +inline +DWORD IconInfo::xHotSpot(void)const +{ + return _ICONINFO::xHotspot; +} + +inline +void IconInfo::xHotSpot(DWORD xHotSpot) +{ + _ICONINFO::xHotspot=xHotSpot; +} + +inline +DWORD IconInfo::yHotSpot(void)const +{ + return _ICONINFO::yHotspot; +} + +inline +void IconInfo::yHotSpot(DWORD yHotSpot) +{ + _ICONINFO::yHotspot=yHotSpot; +} + +inline +HBITMAP IconInfo::maskBitmap(void)const +{ + return _ICONINFO::hbmMask; +} + +inline +void IconInfo::maskBitmap(HBITMAP hMaskBitmap) +{ + _ICONINFO::hbmMask=hMaskBitmap; +} + +inline +HBITMAP IconInfo::colorBitmap(void)const +{ + return _ICONINFO::hbmColor; +} + +inline +void IconInfo::colorBitmap(HBITMAP hColorBitmap) +{ + _ICONINFO::hbmColor=hColorBitmap; +} +#endif diff --git a/common/INFOWIN.CPP b/common/INFOWIN.CPP new file mode 100644 index 0000000..0d17aaf --- /dev/null +++ b/common/INFOWIN.CPP @@ -0,0 +1,264 @@ +#include +#include + +char InfoWindow::smszClassName[]={"InfoWin"}; + +InfoWindow::InfoWindow(Window &parentWindow,WORD windowWidth,WORD windowHeight) +: mCreateHandler(this,&InfoWindow::createHandler), + mPaintHandler(this,&InfoWindow::paintHandler), + mDestroyHandler(this,&InfoWindow::destroyHandler), + mCloseHandler(this,&InfoWindow::closeHandler), + mIsDestroyed(FALSE), mParentWindow(parentWindow), + mhInfoFont(0), mCharHeight(0), mWindowWidth(windowWidth), + mWindowHeight(windowHeight) +{ + createInfoFont(); +#ifdef __FLAT__ + mhInstance=(HINSTANCE)::GetWindowLong(mParentWindow,GWL_HINSTANCE); +#else + mhInstance=(HINSTANCE)::GetWindowWord(mParentWindow,GWW_HINSTANCE); +#endif + insertHandler(VectorHandler::CreateHandler,&mCreateHandler); + insertHandler(VectorHandler::PaintHandler,&mPaintHandler); + insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler); + insertHandler(VectorHandler::CloseHandler,&mCloseHandler); + registerClass(); + createInfoWindow(); +} + +void InfoWindow::setCaption(String captionString) +{ + if(!captionString.isNull())::SetWindowText(*this,captionString); +} + +void InfoWindow::createInfoFont() +{ + TEXTMETRIC tm; + HFONT hOldFont; + int fontHeight; + HDC hDC(::GetDC(0)); + + fontHeight=::MulDiv(-10,::GetDeviceCaps(hDC,LOGPIXELSY),72); + mhInfoFont=::CreateFont(fontHeight,0,0,0,FW_BOLD,0,0,0, + ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS, + DEFAULT_QUALITY,VARIABLE_PITCH|FF_SWISS,"Helv"); + hOldFont=(HFONT)::SelectObject(hDC,mhInfoFont); + ::GetTextMetrics(hDC,&tm); + ::SelectObject(hDC,hOldFont); + ::ReleaseDC(NULL,hDC); + mCharHeight=tm.tmHeight+tm.tmExternalLeading; +} + +void InfoWindow::createInfoWindow(void) +{ + RECT windowRect; + + ::SetRect(&windowRect,mTopLeftPoint.x(),mTopLeftPoint.y(),mWindowWidth,mWindowHeight); + ::CreateWindow((LPSTR)smszClassName,(LPSTR)smszClassName,WS_CAPTION|WS_CHILD, + windowRect.left,windowRect.top,windowRect.right,windowRect.bottom, + mParentWindow,0x00,mhInstance,(LPSTR)(Window*)this); + return; +} + +void InfoWindow::show(int showWindow) +{ + if(showWindow){Window::show(SW_SHOW);update();} + else Window::show(SW_HIDE); +} + +InfoWindow::~InfoWindow() +{ + if(::IsWindow(*this))::DestroyWindow(*this); + if(mhInfoFont)::DeleteObject(mhInfoFont); + removeHandlers(); +} + +void InfoWindow::removeHandlers(void) +{ + removeHandler(VectorHandler::CreateHandler,&mCreateHandler); + removeHandler(VectorHandler::PaintHandler,&mPaintHandler); + removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler); + removeHandler(VectorHandler::CloseHandler,&mCloseHandler); +} + +void InfoWindow::registerClass(void) +{ + WNDCLASS wndClass; + + if(::GetClassInfo(mhInstance,smszClassName,(WNDCLASS FAR *)&wndClass))return; + wndClass.style =CS_HREDRAW|CS_VREDRAW; + wndClass.lpfnWndProc =(WNDPROC)Window::WndProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(InfoWindow*); + wndClass.hInstance =mhInstance; + wndClass.hIcon =0; + wndClass.hCursor =(HCURSOR)::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH); + wndClass.lpszMenuName =0; + wndClass.lpszClassName =smszClassName; + ::RegisterClass(&wndClass); +} + +CallbackData::ReturnType InfoWindow::createHandler(CallbackData &/*someCallbackData*/) +{ + ::SendMessage(*this,WM_NCACTIVATE,TRUE,0L); + return (CallbackData::ReturnType)TRUE; +} + +CallbackData::ReturnType InfoWindow::paintHandler(CallbackData &someCallbackData) +{ + PaintInformation *lpPaintInformation=(PaintInformation*)someCallbackData.lParam(); + + paint((PureDevice)*(lpPaintInformation)); + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType InfoWindow::destroyHandler(CallbackData &/*someCallbackData*/) +{ + mIsDestroyed=TRUE; + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType InfoWindow::closeHandler(CallbackData &/*someCallbackData*/) +{ + ::DestroyWindow(*this); + mIsDestroyed=TRUE; + return (CallbackData::ReturnType)FALSE; +} + +void InfoWindow::paint(PureDevice &windowDevice) +{ + RECT clientRect; + RECT tempRect; + HBRUSH hTempBrush; + + ::GetClientRect(*this,(RECT FAR *)&clientRect); + hTempBrush=::CreateSolidBrush(::GetSysColor(COLOR_BTNFACE)); + ::FillRect((HDC)windowDevice,(RECT FAR*)&clientRect,hTempBrush); + ::DeleteObject(hTempBrush); + + hTempBrush=::CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW)); + tempRect=clientRect; + tempRect.top+=HeightBorderValue; + tempRect.left+=WidthBorderValue; + tempRect.right-=WidthBorderValue; + tempRect.bottom=tempRect.top+1; + ::FillRect((HDC)windowDevice,(RECT FAR*)&tempRect,hTempBrush); + + tempRect=clientRect; + tempRect.left+=WidthBorderValue; + tempRect.right=tempRect.left+1; + tempRect.top+=HeightBorderValue; + tempRect.bottom-=HeightBorderValue; + ::FillRect((HDC)windowDevice,(RECT FAR*)&tempRect,hTempBrush); + ::DeleteObject(hTempBrush); + + hTempBrush=::CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT)); + tempRect=clientRect; + tempRect.bottom-=HeightBorderValue; + tempRect.top=tempRect.bottom-1; + tempRect.left+=WidthBorderValue; + tempRect.right-=WidthBorderValue; + ::FillRect((HDC)windowDevice,(RECT FAR*)&tempRect,hTempBrush); + + tempRect=clientRect; + tempRect.bottom-=HeightBorderValue; + tempRect.top+=HeightBorderValue; + tempRect.right-=WidthBorderValue; + tempRect.left=tempRect.right-1; + ::FillRect((HDC)windowDevice,(RECT FAR*)&tempRect,hTempBrush); + ::DeleteObject(hTempBrush); + combineLabelText(); +} + +void InfoWindow::makeBorderOffsetRect(RECT &borderRect,RECT &clientRect)const +{ + borderRect=clientRect; + borderRect.top+=(HeightBorderValue+TextVertBorderOffset); + borderRect.bottom-=(HeightBorderValue+TextVertBorderOffset); + borderRect.left+=(WidthBorderValue+TextHorzBorderOffset); + borderRect.right-=(WidthBorderValue+TextHorzBorderOffset); +} + +void InfoWindow::setLineText(WORD lineNumber,String lineText) +{ + String tempString; + + if(lineText.isNull()||!lineNumber)return; + --lineNumber; + if(lineNumber>=mLineText.size())return; + mLineText[lineNumber]=lineText; + if(lineNumber &lineText,WORD refreshDisplay) +{ + size_t numLines((size_t)lineText.size()); + + mLineText.remove(); + if(!numLines)return; + for(int itemIndex=0;itemIndex &labelText,WORD refreshDisplay) +{ + size_t numLabels((size_t)labelText.size()); + + mLabelText.remove(); + if(!numLabels)return; + for(int itemIndex=0;itemIndexnumLabels?numLines:numLabels); + + for(int itemIndex=0;itemIndex +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_POINT_HPP_ +#include +#endif + +class InfoWindow : public Window +{ +public: + enum{WindowWidth=200,WindowHeight=135}; + InfoWindow(Window &parentWindow,WORD windowWidth=WindowWidth,WORD windowHeight=WindowHeight); + virtual ~InfoWindow(); + void show(int showWindow); + void setLocation(const Point &topLeftPoint); + void setCaption(String captionString); + void setLineText(WORD lineNumber,String lineText); + void setLineText(Block &lineText,WORD refreshDisplay=TRUE); + void setLabelText(Block &labelText,WORD refreshDisplay=TRUE); + WORD widthBorder(void)const; + WORD heightBorder(void)const; + WORD windowWidth(void)const; + WORD windowHeight(void)const; + HFONT windowFont(void)const; +private: + enum {OffsetCaption=20}; + enum {WidthBorderValue=10,HeightBorderValue=15}; + enum {TextHorzBorderOffset=4,TextVertBorderOffset=1}; + static char smszClassName[]; + CallbackData::ReturnType createHandler(CallbackData &someCallbackData); + CallbackData::ReturnType paintHandler(CallbackData &someCallbackData); + CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData); + CallbackData::ReturnType closeHandler(CallbackData &someCallbackData); + void makeBorderOffsetRect(RECT &borderRect,RECT &clientRect)const; + void drawText(WORD lineNumber,String lineText); + void createInfoWindow(void); + void combineLabelText(void); + void createInfoFont(void); + void registerClass(void); + void removeHandlers(void); + void paint(PureDevice &windowDevice); + + Callback mCreateHandler; + Callback mPaintHandler; + Callback mDestroyHandler; + Callback mCloseHandler; + Block mLabelText; + Block mLineText; + HINSTANCE mhInstance; + HFONT mhInfoFont; + Window &mParentWindow; + WORD mIsDestroyed; + WORD mCharHeight; + WORD mWindowWidth; + WORD mWindowHeight; + Point mTopLeftPoint; +}; + +inline +WORD InfoWindow::widthBorder(void)const +{ + return WidthBorderValue; +} + +inline +WORD InfoWindow::heightBorder(void)const +{ + return HeightBorderValue; +} + +inline +WORD InfoWindow::windowWidth(void)const +{ + return mWindowWidth; +} + +inline +WORD InfoWindow::windowHeight(void)const +{ + return mWindowHeight; +} + +inline +HFONT InfoWindow::windowFont(void)const +{ + return mhInfoFont; +} +#endif diff --git a/common/INSTANCE.HPP b/common/INSTANCE.HPP new file mode 100644 index 0000000..0bf3624 --- /dev/null +++ b/common/INSTANCE.HPP @@ -0,0 +1,92 @@ +#ifndef _COMMON_INSTANCEDATA_HPP_ +#define _COMMON_INSTANCEDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class InstanceData +{ +public: + InstanceData(void); + ~InstanceData(); + static void FAR *getInstanceData(HWND hPropertyWnd); + static void setInstanceData(HWND hPropertyWnd,void FAR *lpPointer); + static void removeInstanceData(HWND hPropertyWnd); +private: + InstanceData(const InstanceData &someInstanceData); +}; + +inline +InstanceData::InstanceData(void) +{ + return; +} + +inline +InstanceData::InstanceData(const InstanceData &/*someProperty*/) +{ + return; +} + +inline +InstanceData::~InstanceData() +{ + return; +} + +#ifdef __FLAT__ +inline +void FAR *InstanceData::getInstanceData(HWND hPropertyWnd) +{ + if(!::IsWindow(hPropertyWnd))return (void FAR*)0; + return (void FAR*)::GetProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@NEARPTR"); +} + +inline +void InstanceData::setInstanceData(HWND hPropertyWnd,void FAR *lpPointer) +{ + if(!::IsWindow(hPropertyWnd))return; + ::SetProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@NEARPTR",(HANDLE)lpPointer); + return; +} + +inline +void InstanceData::removeInstanceData(HWND hPropertyWnd) +{ + if(!::IsWindow(hPropertyWnd))return; + ::RemoveProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@NEARPTR"); + return; +} +#else +inline +void FAR *InstanceData::getInstanceData(HWND hPropertyWnd) +{ + HANDLE handleSegment; + HANDLE handleOffset; + + if(!::IsWindow(hPropertyWnd))return (void FAR*)0; + handleSegment=::GetProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@HIWORD"); + handleOffset=::GetProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@LOWORD"); + return (void FAR*)(MK_FP(handleSegment,handleOffset)); +} + +inline +void InstanceData::setInstanceData(HWND hPropertyWnd,void FAR *lpPointer) +{ + if(!::IsWindow(hPropertyWnd))return; + ::SetProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@HIWORD",(HANDLE)FP_SEG(lpPointer)); + ::SetProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@LOWORD",(HANDLE)FP_OFF(lpPointer)); + return; +} + +inline +void InstanceData::removeInstanceData(HWND hPropertyWnd) +{ + if(!::IsWindow(hPropertyWnd))return; + ::RemoveProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@HIWORD"); + ::RemoveProp(hPropertyWnd,(LPSTR)"INSTANCEDATA@@LOWORD"); + return; +} +#endif +#endif + diff --git a/common/INTEL.CPP b/common/INTEL.CPP new file mode 100644 index 0000000..0dabef5 --- /dev/null +++ b/common/INTEL.CPP @@ -0,0 +1,21 @@ +#include + +WORD Intel::intelData(WORD someData) +{ + WORD tempData(someData); + + someData>>=8; + someData+=tempData<<8; + return someData; +} + +DWORD Intel::intelData(DWORD someData) +{ + WORD tempDataHi(HIWORD(someData)); + WORD tempDataLo(LOWORD(someData)); + + someData=tempDataLo; + someData<<=16; + someData|=tempDataHi; + return someData; +} diff --git a/common/INTEL.HPP b/common/INTEL.HPP new file mode 100644 index 0000000..0bd0e2a --- /dev/null +++ b/common/INTEL.HPP @@ -0,0 +1,26 @@ +#ifndef _COMMON_INTEL_HPP_ +#define _COMMON_INTEL_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class Intel +{ +public: + Intel(void); + virtual ~Intel(); + static WORD intelData(WORD someData); + static DWORD intelData(DWORD someData); +private: +}; + +inline +Intel::Intel(void) +{ +} + +inline +Intel::~Intel() +{ +} +#endif diff --git a/common/IOBUFF.CPP b/common/IOBUFF.CPP new file mode 100644 index 0000000..31cc7f0 --- /dev/null +++ b/common/IOBUFF.CPP @@ -0,0 +1,19 @@ +#include + +void IOBuffer::destroyBuffer(void) +{ + if(!mhGlobalBuffer)return; + ::GlobalUnlock(mhGlobalBuffer); + ::GlobalFree(mhGlobalBuffer); + mhGlobalBuffer=0; +} + +WORD IOBuffer::createBuffer(DWORD lengthBuffer) +{ + destroyBuffer(); + mhGlobalBuffer=::GlobalAlloc(GMEM_FIXED,lengthBuffer); + if(!mhGlobalBuffer)return FALSE; + mlpBuffer=(BYTE FAR *)::GlobalLock(mhGlobalBuffer); + return TRUE; +} + diff --git a/common/IOBUFF.HPP b/common/IOBUFF.HPP new file mode 100644 index 0000000..cad521c --- /dev/null +++ b/common/IOBUFF.HPP @@ -0,0 +1,76 @@ +#ifndef _COMMON_IOBUFFER_HPP_ +#define _COMMON_IOBUFFER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class IOBuffer +{ +public: + IOBuffer(DWORD lengthBuffer); + virtual ~IOBuffer(); + BYTE FAR *lpBufferPointer(void); + BYTE FAR *lpBuffer(void); + IOBuffer &operator++(void); + BOOL operator+=(int offset); + BOOL operator-=(int offset); + DWORD bufferIndex(void)const; + void bufferIndex(DWORD bufferIndex); +private: + void destroyBuffer(void); + WORD createBuffer(DWORD lengthBuffer); + + HGLOBAL mhGlobalBuffer; + BYTE FAR *mlpBuffer; + BYTE FAR *mlpBufferPointer; + DWORD mBufferIndex; +}; + +inline +IOBuffer::IOBuffer(DWORD lengthBuffer) +: mhGlobalBuffer(0), mlpBuffer(0), mlpBufferPointer(0), mBufferIndex(0) +{ + createBuffer(lengthBuffer); +} + +inline +IOBuffer::~IOBuffer() +{ + destroyBuffer(); +} + +class IOBufferBounds{}; + +inline +IOBuffer &IOBuffer::operator++(void) +{ + mlpBufferPointer++; + mBufferIndex--; + return *this; +} + +inline +DWORD IOBuffer::bufferIndex(void)const +{ + return mBufferIndex; +} + +inline +void IOBuffer::bufferIndex(DWORD bufferIndex) +{ + mBufferIndex=bufferIndex; + mlpBufferPointer=mlpBuffer; +} + +inline +BYTE FAR *IOBuffer::lpBuffer(void) +{ + return mlpBuffer; +} + +inline +BYTE FAR *IOBuffer::lpBufferPointer(void) +{ + return mlpBufferPointer; +} +#endif diff --git a/common/Keydata.hpp b/common/Keydata.hpp new file mode 100644 index 0000000..f5ae2a7 --- /dev/null +++ b/common/Keydata.hpp @@ -0,0 +1,143 @@ +#ifndef _COMMON_KEYDATA_HPP_ +#define _COMMON_KEYDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class KeyData +{ +public: + KeyData(void); + KeyData(WPARAM virtualKey,LPARAM keyData); + KeyData(const KeyData &someKeyData); + KeyData(const CallbackData &someCallbackData); + virtual ~KeyData(); + KeyData &operator=(const KeyData &someKeyData); + BOOL operator==(const KeyData &someKeyData)const; + int virtualKey(void)const; + int repeatCount(void)const; + int scanCode(void)const; + BOOL isExtendedKey(void)const; + BOOL isEnterKey(void)const; + BOOL isEscapeKey(void)const; + BOOL contextCode(void)const; + BOOL prevKeyUp(void)const; + BOOL transitionState(void)const; + static bool shiftKeyPressed(void); + static bool controlKeyPressed(void); +private: + enum {EnterKey=0x0D,EscapeKey=0x1B}; + WPARAM mVirtualKey; + LPARAM mKeyData; +}; + +inline +KeyData::KeyData(void) +: mVirtualKey(0), mKeyData(0) +{ +} + +inline +KeyData::KeyData(const KeyData &someKeyData) +{ + *this=someKeyData; +} + +inline +KeyData::KeyData(WPARAM virtualKey,LPARAM keyData) +: mVirtualKey(virtualKey), mKeyData(keyData) +{ +} + +inline +KeyData::KeyData(const CallbackData &someCallbackData) +: mVirtualKey(someCallbackData.wParam()), mKeyData(someCallbackData.lParam()) +{ +} + +inline +KeyData::~KeyData() +{ +} + +inline +KeyData &KeyData::operator=(const KeyData &someKeyData) +{ + mVirtualKey=someKeyData.mVirtualKey; + mKeyData=someKeyData.mKeyData; + return *this; +} + +inline +BOOL KeyData::operator==(const KeyData &someKeyData)const +{ + return mVirtualKey==someKeyData.mVirtualKey&& + mKeyData==someKeyData.mKeyData; +} + +inline +int KeyData::virtualKey(void)const +{ + return mVirtualKey; +} + +inline +int KeyData::repeatCount(void)const +{ + return mKeyData&0xFFFF; +} + +inline +int KeyData::scanCode(void)const +{ + return (mKeyData&0xFF00)>>16; +} + +inline +BOOL KeyData::isExtendedKey(void)const +{ + return mKeyData&0x100000; +} + +inline +BOOL KeyData::isEnterKey(void)const +{ + return virtualKey()==EnterKey; +} + +inline +BOOL KeyData::isEscapeKey(void)const +{ + return virtualKey()==EscapeKey; +} + +inline +BOOL KeyData::contextCode(void)const +{ + return mKeyData&0x20000000; +} + +inline +BOOL KeyData::prevKeyUp(void)const +{ + return mKeyData&0x40000000; +} + +inline +BOOL KeyData::transitionState(void)const +{ + return mKeyData&0x80000000; +} + +inline +bool KeyData::shiftKeyPressed(void) +{ + return ::GetKeyState(VK_SHIFT)&0x8000; +} + +inline +bool KeyData::controlKeyPressed(void) +{ + return ::GetKeyState(VK_CONTROL)&0x8000; +} +#endif \ No newline at end of file diff --git a/common/LIB.RSP b/common/LIB.RSP new file mode 100644 index 0000000..6929dd9 --- /dev/null +++ b/common/LIB.RSP @@ -0,0 +1,54 @@ +/DEBUGTYPE:BOTH +/OUT:C:\WORK\COMMON\MSVCOBJ\MSCOMMON.LIB +/MACHINE:IX86 +/SUBSYSTEM:WINDOWS +MSVCOBJ\MSFIX32.OBJ +MSVCOBJ\BITMAP.OBJ +MSVCOBJ\BMDATA.OBJ +MSVCOBJ\BMINFO.OBJ +MSVCOBJ\BMPLNK.OBJ +MSVCOBJ\BTNLNK.OBJ +MSVCOBJ\CATMULL.OBJ +MSVCOBJ\CBDATA.OBJ +MSVCOBJ\CONSOLE.OBJ +MSVCOBJ\CRSCTRL.OBJ +MSVCOBJ\DDEMSG.OBJ +MSVCOBJ\DISKINFO.OBJ +MSVCOBJ\DRAWBMP.OBJ +MSVCOBJ\DWINDOW.OBJ +MSVCOBJ\FILEIO.OBJ +MSVCOBJ\FILEMAP.OBJ +MSVCOBJ\FONT.OBJ +MSVCOBJ\GDIPOINT.OBJ +MSVCOBJ\ICONFRM.OBJ +MSVCOBJ\INFOWIN.OBJ +MSVCOBJ\INTEL.OBJ +MSVCOBJ\IOBUFF.OBJ +MSVCOBJ\LOGOWIN.OBJ +MSVCOBJ\MACRO.OBJ +MSVCOBJ\MATH.OBJ +MSVCOBJ\MEMFILE.OBJ +MSVCOBJ\MMTIMER.OBJ +MSVCOBJ\OPENFILE.OBJ +MSVCOBJ\OWNER.OBJ +MSVCOBJ\PATHFND.OBJ +MSVCOBJ\POINT.OBJ +MSVCOBJ\PROCESS.OBJ +MSVCOBJ\PROFILE.OBJ +MSVCOBJ\PROGRESS.OBJ +MSVCOBJ\PUREBMP.OBJ +MSVCOBJ\PUREBYTE.OBJ +MSVCOBJ\PUREDWRD.OBJ +MSVCOBJ\PUREHDC.OBJ +MSVCOBJ\PUREMENU.OBJ +MSVCOBJ\PUREPAL.OBJ +MSVCOBJ\PUREWRD.OBJ +MSVCOBJ\PVIEW.OBJ +MSVCOBJ\SMRTSTRM.OBJ +MSVCOBJ\STRING.OBJ +MSVCOBJ\SYSTIME.OBJ +MSVCOBJ\VHANDLER.OBJ +MSVCOBJ\WIDESTR.OBJ +MSVCOBJ\WINDOW.OBJ +MSVCOBJ\WINGBLT.OBJ +MSVCOBJ\WINTIMER.OBJ diff --git a/common/LIBRARY.HPP b/common/LIBRARY.HPP new file mode 100644 index 0000000..c1cd2bc --- /dev/null +++ b/common/LIBRARY.HPP @@ -0,0 +1,104 @@ +#ifndef _COMMON_LIBRARY_HPP_ +#define _COMMON_LIBRARY_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class Library +{ +public: + Library(void); + Library(const String &strPathLibrary); + virtual ~Library(); + Library &operator=(const String &strPathLibrary); + FARPROC procAddress(const String &strMethod)const; + BOOL procIn(const String &strMethod)const; + String strPathLibrary(void)const; + HINSTANCE getInstance(void)const; + BOOL isOkay(void)const; +private: + enum {MaxString=256}; + void load(const String &strPathLibrary); + void free(void); + HINSTANCE mhInstance; + String mStrPathLibrary; +}; + +inline +Library::Library(void) +: mhInstance(0) +{ + mStrPathLibrary.reserve(MaxString); +} + +inline +Library::Library(const String &strPathLibrary) +: mhInstance(0) +{ + load(strPathLibrary); +} + +inline +Library::~Library() +{ + free(); +} + +inline +Library &Library::operator=(const String &strPathLibrary) +{ + load(strPathLibrary); + return *this; +} + +inline +FARPROC Library::procAddress(const String &strMethod)const +{ + if(!isOkay())return FALSE; + return ::GetProcAddress(mhInstance,strMethod); +} + +inline +BOOL Library::procIn(const String &strMethod)const +{ + return procAddress(strMethod)?TRUE:FALSE;; +} + +inline +void Library::load(const String &strPathLibrary) +{ + free(); + mhInstance=::LoadLibrary(strPathLibrary); + if(isOkay())::GetModuleFileName(mhInstance,mStrPathLibrary,MaxString); +} + +inline +void Library::free(void) +{ + if(!isOkay())return; + ::FreeLibrary(mhInstance); + mhInstance=0; +} + +inline +String Library::strPathLibrary(void)const +{ + if(!isOkay())return String(); + return mStrPathLibrary; +} + +inline +HINSTANCE Library::getInstance(void)const +{ + return mhInstance; +} + +inline +BOOL Library::isOkay(void)const +{ + return (mhInstance + +char LogoWindow::smszClassName[]={"NepalNight"}; + +LogoWindow::LogoWindow(HINSTANCE hInstance,HINSTANCE hLibrary) +: mhInstance(hInstance), mhLibrary(hLibrary), mIsDestroyed(FALSE), mhBitmap(0) +{ + mCreateHandler.setCallback(this,&LogoWindow::createHandler); + mTimerHandler.setCallback(this,&LogoWindow::timerHandler); + mPaintHandler.setCallback(this,&LogoWindow::paintHandler); + mDestroyHandler.setCallback(this,&LogoWindow::destroyHandler); + mCloseHandler.setCallback(this,&LogoWindow::closeHandler); + insertHandler(VectorHandler::CreateHandler,&mCreateHandler); + insertHandler(VectorHandler::TimerHandler,&mTimerHandler); + insertHandler(VectorHandler::PaintHandler,&mPaintHandler); + insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler); + insertHandler(VectorHandler::CloseHandler,&mCloseHandler); + registerClass(); +} + +LogoWindow::~LogoWindow() +{ + if(mhBitmap)::DeleteObject(mhBitmap); + if(::IsWindow(*this))::DestroyWindow(*this); + removeHandlers(); +} + +void LogoWindow::removeHandlers(void) +{ + removeHandler(VectorHandler::CreateHandler,&mCreateHandler); + removeHandler(VectorHandler::TimerHandler,&mTimerHandler); + removeHandler(VectorHandler::PaintHandler,&mPaintHandler); + removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler); + removeHandler(VectorHandler::CloseHandler,&mCloseHandler); +} + +WORD LogoWindow::showLogo(String &bitmapName) +{ + RECT windowRect; + HWND hCaptureWindow(::GetCapture()); + + if(mhLibrary)mhBitmap=::LoadBitmap(mhLibrary,bitmapName); + else mhBitmap=::LoadBitmap(mhInstance,bitmapName); + if(!mhBitmap) + { + mIsDestroyed=TRUE; + return FALSE; + } + centerRect(mhBitmap,windowRect); + ::CreateWindow((LPSTR)smszClassName,0,WS_POPUP|WS_BORDER, + windowRect.left,windowRect.top,windowRect.right,windowRect.bottom, + 0x00,0x00,mhInstance,(LPSTR)(Window*)this); + show(SW_SHOW); + update(); + ::SetCapture(*this); + waitCursor(TRUE); + while(!mIsDestroyed)messageLoop(); + waitCursor(FALSE); + ::SetCapture(hCaptureWindow); + return TRUE; +} + +void LogoWindow::registerClass(void) +{ + WNDCLASS wndClass; + + if(::GetClassInfo(mhInstance,smszClassName,(WNDCLASS FAR *)&wndClass))return; + wndClass.style =CS_HREDRAW|CS_VREDRAW; + wndClass.lpfnWndProc =(WNDPROC)Window::WndProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(LogoWindow*); + wndClass.hInstance =mhInstance; + wndClass.hIcon =0; + wndClass.hCursor =::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH); + wndClass.lpszMenuName =0; + wndClass.lpszClassName =smszClassName; + ::RegisterClass(&wndClass); +} + +void LogoWindow::messageLoop(void) +{ + MSG msg; + + while(!mIsDestroyed) + { + while(::PeekMessage(&msg,0,0,0,PM_REMOVE)) + { + ::TranslateMessage(&msg); + ::DispatchMessage(&msg); + } + } +} + +CallbackData::ReturnType LogoWindow::createHandler(CallbackData &/*someCallbackData*/) +{ + setTimer(TimerID,TimeOut); + return (CallbackData::ReturnType)TRUE; +} + +CallbackData::ReturnType LogoWindow::timerHandler(CallbackData &/*someCallbackData*/) +{ + killTimer(TimerID); + ::PostMessage(*this,WM_CLOSE,0,0L); + return (CallbackData::ReturnType)0; +} + +CallbackData::ReturnType LogoWindow::paintHandler(CallbackData &/*someCallbackData*/) +{ + paint(); + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType LogoWindow::destroyHandler(CallbackData &/*someCallbackData*/) +{ + mIsDestroyed=TRUE; + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType LogoWindow::closeHandler(CallbackData &/*someCallbackData*/) +{ + ::DestroyWindow(*this); + mIsDestroyed=TRUE; + return (CallbackData::ReturnType)FALSE; +} + +void LogoWindow::paint()const +{ + drawBitmap(*this,mhBitmap); +} diff --git a/common/LOGOWIN.HPP b/common/LOGOWIN.HPP new file mode 100644 index 0000000..9e7488e --- /dev/null +++ b/common/LOGOWIN.HPP @@ -0,0 +1,45 @@ +#ifndef _COMMON_LOGOWINDOW_HPP_ +#define _COMMON_LOGOWINDOW_HPP_ +#ifndef _COMMON_WINDOW_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_DRAWBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_CURSORCONTROL_HPP_ +#include +#endif + +class LogoWindow : public Window, public DrawBitmap, public CursorControl +{ +public: + LogoWindow(HINSTANCE hInstance,HINSTANCE hLibrary); + virtual ~LogoWindow(); + WORD showLogo(String &logoBitmapName); +private: + enum{TimerID=0x00,TimeOut=3000}; + static char smszClassName[]; + CallbackData::ReturnType createHandler(CallbackData &someCallbackData); + CallbackData::ReturnType timerHandler(CallbackData &someCallbackData); + CallbackData::ReturnType paintHandler(CallbackData &someCallbackData); + CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData); + CallbackData::ReturnType closeHandler(CallbackData &someCallbackData); + void registerClass(void); + void paint()const; + void messageLoop(void); + void removeHandlers(void); + + Callback mCreateHandler; + Callback mTimerHandler; + Callback mPaintHandler; + Callback mDestroyHandler; + Callback mCloseHandler; + HINSTANCE mhInstance; + HINSTANCE mhLibrary; + HBITMAP mhBitmap; + WORD mIsDestroyed; +}; +#endif \ No newline at end of file diff --git a/common/MACRO.CPP b/common/MACRO.CPP new file mode 100644 index 0000000..4970739 --- /dev/null +++ b/common/MACRO.CPP @@ -0,0 +1,155 @@ +#include +#include +#include +#include + +WORD SymbolTable::isInSymbols(char symbol) +{ + for(int i=0;i macroStrings; + char *startPosition=mlpPtrString; + WORD offsetPosition; + + pushSymbol(EnvMacroMid); + pushSymbol(EnvMacroEnd); + pushSymbol(EnvMacroSync); + pushSymbol(EnvMacroStart); + if(!expect(EnvMacroStart))return; + if(!expect(EnvMacroSync))return; + popSymbol(2); + extractString(macroString); + macroStrings.insert(¯oString); + popSymbol(1); + while(isInSymbols(*mlpPtrString)) + { + pushSymbol(EnvMacroEnd); + if(!expect(*mlpPtrString))return; + extractString(macroString); + macroStrings.insert(¯oString); + popSymbol(1); + } + popSymbol(1); + pushSymbol(EnvMacroEnd); + if(!expect(*mlpPtrString))return; + popSymbol(1); + *startPosition=0; + tempString=mInputString; + macroString=locateFirstEnvironmentString(macroStrings); + tempString+=macroString; + offsetPosition=::strlen(mInputString)+::strlen(macroString); + tempString+=mlpPtrString; + mInputString=tempString; + mlpPtrString=((LPSTR)mInputString+offsetPosition); +} + +void Macro::extractString(String ¯oString) +{ + String tempString; + BYTE counter(0); + + while(0!=*mlpPtrString&&!isInSymbols(*mlpPtrString)) + { + *((LPSTR)tempString+counter++)=*mlpPtrString; + mlpPtrString++; + } + *((LPSTR)tempString+counter)=0; + macroString=tempString; +} + +WORD Macro::expect(char symbol) +{ + if(*mlpPtrString==symbol) + { + mlpPtrString++; + return TRUE; + } + while(0!=*mlpPtrString&&!isInSymbols(*mlpPtrString))mlpPtrString++; + return FALSE; +} + +String Macro::locateFirstEnvironmentString(Block &varStrings) +{ + size_t size(varStrings.size()); + char *envPtr; + + for(int i=0;i +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class SymbolTable +{ +public: + SymbolTable(); + ~SymbolTable(); + void pushSymbol(char symbol); + void popSymbol(char &symbol); + void popSymbol(void); + void popSymbol(int numSymbols); + WORD isInSymbols(char symbol); +private: + enum {DefaultTableSize=256}; + String mSymbolTable; + int mCurrentSymbols; + int mTableSize; +}; + +inline +SymbolTable::SymbolTable() +: mCurrentSymbols(0), mTableSize(DefaultTableSize) +{ + mSymbolTable.reserve(DefaultTableSize); +} + +inline +SymbolTable::~SymbolTable() +{ +} + +inline +void SymbolTable::pushSymbol(char symbol) +{ + if(mCurrentSymbols>=mTableSize)return; + *((LPSTR)mSymbolTable+mCurrentSymbols)=symbol; + mCurrentSymbols++; +} + +inline +void SymbolTable::popSymbol(char &symbol) +{ + if(!mCurrentSymbols)return; + --mCurrentSymbols; + symbol=*((LPSTR)mSymbolTable+mCurrentSymbols); +} + +inline +void SymbolTable::popSymbol(void) +{ + if(!mCurrentSymbols)return; + --mCurrentSymbols; +} + +inline +void SymbolTable::popSymbol(int numSymbols) +{ + if(mCurrentSymbols-numSymbols<0)return; + mCurrentSymbols-=numSymbols; +} + +// ********************************************************************************** + +class Macro : public SymbolTable +{ +public: + Macro(void); + ~Macro(); + void processEmbeddedMacro(String &someString); +private: + enum Symbols{EnvMacroStart='$',EnvMacroSync='(',EnvMacroMid=',',EnvMacroEnd=')'}; + void expandEmbeddedMacro(void); + void extractString(String ¯oString); + String locateFirstEnvironmentString(Block &envStrings); + WORD expandFunction(String &atFunction)const; + WORD expandLiteral(String &literalString)const; + WORD expect(char symbol); + + String mUnsetString; + String mInputString; + char *mlpPtrString; +}; +#endif + diff --git a/common/MAKE.RSP b/common/MAKE.RSP new file mode 100644 index 0000000..167c121 --- /dev/null +++ b/common/MAKE.RSP @@ -0,0 +1,66 @@ +/D__FLAT__ +/DSTRICT +/DWIN32 +/D_WINDOWS +/Od +/GD +/G4 +/Zi +/Yd +/YX +/IC:\PARTS\MSVC\INCLUDE +/I.. +/I..\..\PARTS +/c +/nologo +/FoMSVCOBJ\ +BITMAP.CPP +BMDATA.CPP +BMINFO.CPP +BMPLNK.CPP +BTNLNK.CPP +CATMULL.CPP +CBDATA.CPP +CONSOLE.CPP +CRSCTRL.CPP +DDEMSG.CPP +DISKINFO.CPP +DRAWBMP.CPP +DWINDOW.CPP +FILEIO.CPP +FILEMAP.CPP +FONT.CPP +GDIPOINT.CPP +ICONFRM.CPP +INFOWIN.CPP +INTEL.CPP +IOBUFF.CPP +LOGOWIN.CPP +MACRO.CPP +MATH.CPP +MEMFILE.CPP +MMTIMER.CPP +OPENFILE.CPP +OWNER.CPP +PATHFND.CPP +POINT.CPP +PROCESS.CPP +PROFILE.CPP +PROGRESS.CPP +PUREBMP.CPP +PUREBYTE.CPP +PUREDWRD.CPP +PUREHDC.CPP +PUREMENU.CPP +PUREPAL.CPP +PUREWRD.CPP +PVIEW.CPP +SMRTSTRM.CPP +STRING.CPP +SYSTIME.CPP +VHANDLER.CPP +WIDESTR.CPP +WINDOW.CPP +WINGBLT.CPP +WINTIMER.CPP + diff --git a/common/MATH.CPP b/common/MATH.CPP new file mode 100644 index 0000000..24cf430 --- /dev/null +++ b/common/MATH.CPP @@ -0,0 +1,36 @@ +#include + +const double Math::mscPI=3.14159265358979323846; +const double Math::msc2PI=3.14159265358979323846*2.00; +const double Math::mscLN10=2.30258509299405E+000; +const double Math::mscOneOverLN10=0.43429448190325E+000; +const double Math::mscPIOver180=1.74532925199433E-002; +const double Math::mscPIUnder180=5.72957795130823E+001; + +float Math::power(float powerBase,int exponent) +{ + float basePower(1.00); + + if(!exponent)return 1.00; + for(int count=0;count>1; + if(square(firstSqrt)-firstSqrt+1>oldArg)return firstSqrt+1; + return firstSqrt; +} + +long Math::factorial(long nDegree) +{ + if(nDegree)return nDegree*factorial(nDegree-1); + else return 1L; +} + diff --git a/common/MATH.HPP b/common/MATH.HPP new file mode 100644 index 0000000..6dca360 --- /dev/null +++ b/common/MATH.HPP @@ -0,0 +1,262 @@ +#ifndef _COMMON_MATH_HPP_ +#define _COMMON_MATH_HPP_ +#include +#ifdef _MSC_VER +#if defined(min) +#undef min +#endif +#if defined(max) +#undef max +#endif +#endif +class Math +{ +public: + Math(void); + virtual ~Math(); + static int round(double someDouble); + static int truncate(double someDouble); + static float fraction(double someDouble); + static float square(float someFloat); + static int square(int someInt); + static float radians(float someAngleDegrees); + static float degrees(float someAngleRadians); + static float cosDegrees(float someAngleDegrees); + static float sinDegrees(float someAngleDegrees); + static float tanDegrees(float someAngleDegrees); + static double cos(double angleRadians); + static double sin(double angleRadians); + static double tan(double angleRadians); + static float power(float powerBase,int exponent); + static double power(double powerBase,double exponent); + static int power(int powerBase,int exponent); + static float log(float someFloat); + static float exp10(float someFloat); + static float sign(float someFloat); + static int sign(int someInt); + static int sqrt(int someInt); + static float sqrt(float someFloat); + static double sqrt(double someDouble); + static float min(float floatOne,float floatTwo); + static float max(float floatOne,float floatTwo); + static float min(float floatOne,float floatTwo,float floatThree); + static float max(float floatOne,float floatTwo,float floatThree); + static float min(float floatOne,float floatTwo,float floatThree,float floatFour); + static float max(float floatOne,float floatTwo,float floatThree,float floatFour); + static long factorial(long nDegree); + static float pi(void); + static float pi2(void); + static double piOver180(); + static int abs(int value); +private: + static const double mscPI; + static const double msc2PI; + static const double mscLN10; + static const double mscOneOverLN10; + static const double mscPIOver180; + static const double mscPIUnder180; +}; + +inline +Math::Math(void) +{ +} + +inline +Math::~Math() +{ +} + +inline +int Math::round(double someDouble) +{ + return (int)(someDouble+0.5); +} + +inline +int Math::truncate(double someDouble) +{ + return (int)someDouble; +} + +inline +float Math::fraction(double someDouble) +{ + int wholeNumber((int)someDouble); + return someDouble-(float)wholeNumber; +} + +inline +float Math::square(float someFloat) +{ + return someFloat*someFloat; +} + +inline +int Math::square(int someInt) +{ + return someInt*someInt; +} + +inline +float Math::radians(float someAngleDegrees) +{ + return (someAngleDegrees*mscPIOver180); +} + +inline +float Math::degrees(float someAngleRadians) +{ + return (someAngleRadians*mscPIUnder180); +} + +inline +float Math::cosDegrees(float someAngleDegrees) +{ + return (::cos(radians(someAngleDegrees))); +} + +inline +float Math::sinDegrees(float someAngleDegrees) +{ + return (::sin(radians(someAngleDegrees))); +} + +inline +float Math::tanDegrees(float someAngleDegrees) +{ + return (::tan(radians(someAngleDegrees))); +} + +inline +float Math::log(float someFloat) +{ + return (::log(someFloat)*mscOneOverLN10); +} + +inline +float Math::exp10(float someFloat) +{ + return (::exp(someFloat*mscLN10)); +} + +inline +float Math::sign(float someFloat) +{ + if(0.00>someFloat)return -1.00; + else if(1.00someInt)return -1; + else if(1 32767, increment eax + db 7Eh ; the next two bytes comprise "jle +2" (ie) + db 01h ; jump passed the increment esx insruction + inc eax ; increment value in eax +ENDM + +absolute MACRO varOne +LOCAL @@return + cmp varOne,00h ; check varOne with zero + jge @@return ; if it's greater than or equal then return + neg varOne ; otherwise make it positive +@@return: +ENDM + +multiply MACRO varOne,varTwo + mov eax,varOne ; move varOne into eax register + mov edx,varTwo ; move varTwo into edx register + imul eax,edx ; perform multiply, result to eax +ENDM + +mulshort MACRO varOne,varTwo ; multiply r/m16->eax + mov ax,varOne ; move varOne into ax register + mov dx,varTwo ; move varTwo into dx register + and eax,0FFFFh ; clear out high word of eax register + and edx,0FFFFh ; clear out high word of edx register + imul eax,edx ; perform multiply, result to eax +ENDM + +divide MACRO varOne,varTwo ; divide MACRO varOne,varTwo + mov eax,varOne ; move varOne into eax register + mov ebx,varTwo ; move varTwo into ebx register + cdq ; convert doubleword in eax to quadword at edx:eax + idiv ebx ; divide eax/ebx result to eax, remainder to edx +ENDM + +divshort MACRO varOne,varTwo ; divide r/m16->eax + mov ax,varOne ; move varOne into ax register + mov bx,varTwo ; move varTwo into bx register + and eax,0FFFFh ; clear out high word of eax register + and ebx,0FFFFh ; clear out high word of ebx register + cdq ; convert doubleword in eax to quadword at edx:eax + idiv ebx ; divide eax/ebx result to eax, remainder to edx +ENDM + diff --git a/common/MDIWIN.CPP b/common/MDIWIN.CPP new file mode 100644 index 0000000..552788d --- /dev/null +++ b/common/MDIWIN.CPP @@ -0,0 +1,300 @@ +#include +#include +#include +#include +#include +#include +#include + +MDIWindow::MDIWindow(void) +{ +} + +MDIWindow::~MDIWindow() +{ +} + +BOOL MDIWindow::createWindow(FrameWindow &frameWindow,const String &className,const String &windowName,const String &menuName,const String &iconName) +{ + HINSTANCE hInstance(processInstance()); + mFrameWindow=&frameWindow; + mViewMenu=menuName; + mClassName=className; + registerClass(hInstance,className,menuName,iconName); + return createWindow(hInstance,className,windowName,menuName); +} + +BOOL MDIWindow::createWindow(HINSTANCE hInstance,const String &className,const String &windowName,const String &menuName) +{ + MDICREATESTRUCT createStruct; + + createStruct.szClass=(char*)(String&)className; + createStruct.szTitle=(char*)(String&)windowName; + createStruct.hOwner=hInstance; + createStruct.x=CW_USEDEFAULT; + createStruct.y=CW_USEDEFAULT; + createStruct.cx=CW_USEDEFAULT; + createStruct.cy=CW_USEDEFAULT; + createStruct.style=WS_SYSMENU|WS_CAPTION|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS; + createStruct.lParam=(LONG)this; + preCreate(createStruct); + if(!mFrameWindow->getClient().sendMessage(WM_MDICREATE,0,(LONG)(LPMDICREATESTRUCT)&createStruct))return FALSE; + if(createStruct.style&WS_VISIBLE)show(SW_SHOW); + update(); + return TRUE; +} + +void MDIWindow::registerClass(HINSTANCE hInstance,const String &className,const String &menuName,const String &iconName) +{ + WNDCLASS wndClass; + HICON hIcon; + + if(::GetClassInfo(hInstance,(char*)(String&)className,&wndClass))return; + if(iconName.isNull())hIcon=::LoadIcon(NULL,IDI_APPLICATION); + else hIcon=::LoadIcon(processInstance(),iconName); + wndClass.style =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC; + wndClass.lpfnWndProc =(WNDPROC)GUIWindow::MDIProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(MDIWindow*); + wndClass.hInstance =hInstance; + wndClass.hIcon =hIcon; + wndClass.hCursor =::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)::GetStockObject(WHITE_BRUSH); + wndClass.lpszMenuName =(char*)(String&)menuName; + wndClass.lpszClassName =(char*)(String&)className; + preRegister(wndClass); + ::RegisterClass(&wndClass); +} + +void MDIWindow::mdiActivate(CallbackData &someCallbackData) +{ + if(!someCallbackData.lParam())mFrameWindow->getClient().sendMessage(WM_MDISETMENU,(WPARAM)(HMENU)mFrameWindow->getFrameMenu(),(LPARAM)0); + else + { + PureMenu subMenu; + mViewMenu.getSubMenu(mViewMenu.menuItemStringPos("Window"),subMenu); + mFrameWindow->getClient().sendMessage(WM_MDISETMENU,(WPARAM)(HMENU)mViewMenu,(LPARAM)(HMENU)subMenu); + } + mFrameWindow->sendMessage(WM_MDIACTIVATE,someCallbackData.wParam(),someCallbackData.lParam()); + mFrameWindow->drawMenuBar(); +} + +// *** virtuals + +int MDIWindow::windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam) +{ + if(message>=WM_USER&&message<=0x7FFF) + { + if(!installedHandlers(VectorHandler::UserHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::UserHandler,CallbackData(message,lParam,hWnd)); + } + switch(message) + { + case WM_NCCREATE : + if(!installedHandlers(VectorHandler::NCCreateHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCCreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CREATE : + if(!installedHandlers(VectorHandler::CreateHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PAINT : + if(!installedHandlers(VectorHandler::PaintHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return handlePaintMessage(hWnd,message,wParam,lParam); + case WM_CLOSE : + if(!installedHandlers(VectorHandler::CloseHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + if(!callHandlers(VectorHandler::CloseHandler,CallbackData(wParam,lParam,hWnd)))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return TRUE; + case WM_ERASEBKGND : + if(!installedHandlers(VectorHandler::EraseBackgroundHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EraseBackgroundHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PALETTECHANGED : + if(!installedHandlers(VectorHandler::PaletteChangedHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::PaletteChangedHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWITEM : + if(!installedHandlers(VectorHandler::DrawItemHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_TIMER : + if(!installedHandlers(VectorHandler::TimerHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::TimerHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHAR : + if(!installedHandlers(VectorHandler::CharHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CharHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMMAND : + if(!installedHandlers(VectorHandler::CommandHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CommandHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMPACTING : + if(!installedHandlers(VectorHandler::CompactingHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CompactingHandler,CallbackData(wParam,lParam,hWnd)); + case WM_WININICHANGE : + if(!installedHandlers(VectorHandler::WinIniChangeHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::WinIniChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SYSCOLORCHANGE : + if(!installedHandlers(VectorHandler::SysColorChangeHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SysColorChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORMSGBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOREDIT : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORLISTBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORBTN : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORDLG : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSCROLLBAR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSTATIC : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_INITIATE : + if(!installedHandlers(VectorHandler::DDEInitiateHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEInitiateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_ACK : + if(!installedHandlers(VectorHandler::DDEAckHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEAckHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_REQUEST : + if(!installedHandlers(VectorHandler::DDERequestHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDERequestHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_TERMINATE : + if(!installedHandlers(VectorHandler::DDETerminateHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDETerminateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_DATA : + if(!installedHandlers(VectorHandler::DDEDataHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEDataHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_OPEN : + if(!installedHandlers(VectorHandler::MMOpenHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMOpenHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_CLOSE : + if(!installedHandlers(VectorHandler::MMCloseHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMCloseHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_DONE : + if(!installedHandlers(VectorHandler::MMDoneHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMDoneHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::LeftButtonDoubleHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDOWN : + if(!installedHandlers(VectorHandler::LeftButtonDownHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONUP : + if(!installedHandlers(VectorHandler::LeftButtonUpHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::RightButtonDoubleHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDOWN : + if(!installedHandlers(VectorHandler::RightButtonDownHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONUP : + if(!installedHandlers(VectorHandler::RightButtonUpHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONUP : + if(!installedHandlers(VectorHandler::NCLeftButtonUpHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCLeftButtonDownHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONUP : + if(!installedHandlers(VectorHandler::NCRightButtonUpHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCRightButtonDownHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MOUSEMOVE : + if(!installedHandlers(VectorHandler::MouseMoveHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MouseMoveHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFOCUS : + if(!installedHandlers(VectorHandler::SetFocusHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFONT : + if(!installedHandlers(VectorHandler::SetFontHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFontHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KILLFOCUS : + if(!installedHandlers(VectorHandler::KillFocusHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KillFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYUP : + if(!installedHandlers(VectorHandler::KeyUpHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYDOWN : + if(!installedHandlers(VectorHandler::KeyDownHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETMINMAXINFO : + if(!installedHandlers(VectorHandler::MinMaxHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MinMaxHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ENTERIDLE : + if(!installedHandlers(VectorHandler::EnterIdleHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EnterIdleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MENUSELECT : + if(!installedHandlers(VectorHandler::MenuSelectHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MenuSelectHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETDLGCODE : + if(!installedHandlers(VectorHandler::DialogCodeHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DialogCodeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MEASUREITEM : + if(!installedHandlers(VectorHandler::MeasureItemHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MeasureItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_VSCROLL : + if(!installedHandlers(VectorHandler::VerticalScrollHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::VerticalScrollHandler,CallbackData(wParam,lParam,hWnd)); + case WM_HSCROLL : + if(!installedHandlers(VectorHandler::HorizontalScrollHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::HorizontalScrollHandler,CallbackData(wParam,lParam,hWnd)); +#if defined(__FLAT__) + case WM_NOTIFY : + if(!installedHandlers(VectorHandler::NotifyHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NotifyHandler,CallbackData(wParam,lParam,hWnd)); +#endif + case WM_SIZE : + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + callHandlers(VectorHandler::SizeHandler,CallbackData(wParam,lParam,hWnd)); + return ::DefMDIChildProc(hWnd,message,wParam,lParam); + case WM_DROPFILES : + if(!installedHandlers(VectorHandler::DropFilesHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DropFilesHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DESTROY : + callHandlers(VectorHandler::DestroyHandler,CallbackData(wParam,lParam,hWnd)); + InstanceData::removeInstanceData(hWnd); + setHandle(0); + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return FALSE; + case WM_MDIACTIVATE : + mdiActivate(CallbackData(wParam,lParam,hWnd)); + if(!installedHandlers(VectorHandler::MDIActivateHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MDIActivateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ACTIVATEAPP : + if(!installedHandlers(VectorHandler::ActivateAppHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ActivateAppHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DISPLAYCHANGE : + if(!installedHandlers(VectorHandler::DisplayChangeHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DisplayChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_QUERYENDSESSION : + if(!installedHandlers(VectorHandler::QueryEndSessionHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::QueryEndSessionHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SHOWWINDOW : + if(!installedHandlers(VectorHandler::ShowWindowHandler))return ::DefMDIChildProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ShowWindowHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCDESTROY : + default : + return ::DefMDIChildProc(hWnd,message,wParam,lParam); + } +} + +// *** virtuals + +void MDIWindow::preRegister(WNDCLASS &/*wndClass*/) +{ + return; +} + +void MDIWindow::preCreate(MDICREATESTRUCT &/*createStruct*/) +{ + return; +} diff --git a/common/MEASURE.HPP b/common/MEASURE.HPP new file mode 100644 index 0000000..4537959 --- /dev/null +++ b/common/MEASURE.HPP @@ -0,0 +1,185 @@ +#ifndef _COMMON_MEASUREITEM_HPP_ +#define _COMMON_MEASUREITEM_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class MeasureItem : private MEASUREITEMSTRUCT +{ +public: + MeasureItem(void); + MeasureItem(const MeasureItem &someMeasureItem); + MeasureItem(const MEASUREITEMSTRUCT &someMEASUREITEMSTRUCT); + virtual ~MeasureItem(); + MeasureItem &operator=(const MeasureItem &someMeasureItem); + MeasureItem &operator=(const MEASUREITEMSTRUCT &someMEASUREITEMSTRUCT); + BOOL operator==(const MeasureItem &someMeasureItem)const; + BOOL operator==(const MEASUREITEMSTRUCT &someMEASUREITEMSTRUCT)const; + UINT ctlType(void)const; + void ctlType(UINT ctlType); + UINT ctlID(void)const; + void ctlID(UINT ctlID); + UINT itemID(void)const; + void itemID(UINT itemID); + UINT itemWidth(void)const; + void itemWidth(UINT itemWidth); + UINT itemHeight(void)const; + void itemHeight(UINT itemHeight); + DWORD itemData(void)const; + void itemData(DWORD itemData); +private: + void zeroInit(void); +}; + +inline +MeasureItem::MeasureItem(void) +{ + zeroInit(); +} + +inline +MeasureItem::MeasureItem(const MeasureItem &someMeasureItem) +{ + *this=someMeasureItem; +} + +inline +MeasureItem::MeasureItem(const MEASUREITEMSTRUCT &someMEASUREITEMSTRUCT) +{ + *this=someMEASUREITEMSTRUCT; +} + +inline +MeasureItem::~MeasureItem() +{ +} + +inline +MeasureItem &MeasureItem::operator=(const MeasureItem &someMeasureItem) +{ + ctlType(someMeasureItem.ctlType()); + ctlID(someMeasureItem.ctlID()); + itemID(someMeasureItem.itemID()); + itemWidth(someMeasureItem.itemWidth()); + itemHeight(someMeasureItem.itemHeight()); + itemData(someMeasureItem.itemData()); + return *this; +} + +inline +MeasureItem &MeasureItem::operator=(const MEASUREITEMSTRUCT &someMEASUREITEMSTRUCT) +{ + ctlType(someMEASUREITEMSTRUCT.CtlType); + ctlID(someMEASUREITEMSTRUCT.CtlID); + itemID(someMEASUREITEMSTRUCT.itemID); + itemWidth(someMEASUREITEMSTRUCT.itemWidth); + itemHeight(someMEASUREITEMSTRUCT.itemHeight); + itemData(someMEASUREITEMSTRUCT.itemData); + return *this; +} + +inline +BOOL MeasureItem::operator==(const MeasureItem &someMeasureItem)const +{ + return (ctlType()==someMeasureItem.ctlType()&& + ctlID()==someMeasureItem.ctlID()&& + itemID()==someMeasureItem.itemID()&& + itemWidth()==someMeasureItem.itemWidth()&& + itemHeight()==someMeasureItem.itemHeight()&& + itemData()==someMeasureItem.itemData()); +} + +inline +BOOL MeasureItem::operator==(const MEASUREITEMSTRUCT &someMEASUREITEMSTRUCT)const +{ + return (MEASUREITEMSTRUCT::CtlType==someMEASUREITEMSTRUCT.CtlType&& + MEASUREITEMSTRUCT::CtlID==someMEASUREITEMSTRUCT.CtlID&& + MEASUREITEMSTRUCT::itemID==someMEASUREITEMSTRUCT.itemID&& + MEASUREITEMSTRUCT::itemWidth==someMEASUREITEMSTRUCT.itemWidth&& + MEASUREITEMSTRUCT::itemHeight==someMEASUREITEMSTRUCT.itemHeight&& + MEASUREITEMSTRUCT::itemData==someMEASUREITEMSTRUCT.itemData); +} + +inline +UINT MeasureItem::ctlType(void)const +{ + return MEASUREITEMSTRUCT::CtlType; +} + +inline +void MeasureItem::ctlType(UINT ctlType) +{ + MEASUREITEMSTRUCT::CtlType=ctlType; +} + +inline +UINT MeasureItem::ctlID(void)const +{ + return MEASUREITEMSTRUCT::CtlID; +} + +inline +void MeasureItem::ctlID(UINT ctlID) +{ + MEASUREITEMSTRUCT::CtlID=ctlID; +} + +inline +UINT MeasureItem::itemID(void)const +{ + return MEASUREITEMSTRUCT::itemID; +} + +inline +void MeasureItem::itemID(UINT itemID) +{ + MEASUREITEMSTRUCT::itemID=itemID; +} + +inline +UINT MeasureItem::itemWidth(void)const +{ + return MEASUREITEMSTRUCT::itemWidth; +} + +inline +void MeasureItem::itemWidth(UINT itemWidth) +{ + MEASUREITEMSTRUCT::itemWidth=itemWidth; +} + +inline +UINT MeasureItem::itemHeight(void)const +{ + return MEASUREITEMSTRUCT::itemHeight; +} + +inline +void MeasureItem::itemHeight(UINT itemHeight) +{ + MEASUREITEMSTRUCT::itemHeight=itemHeight; +} + +inline +DWORD MeasureItem::itemData(void)const +{ + return MEASUREITEMSTRUCT::itemData; +} + +inline +void MeasureItem::itemData(DWORD itemData) +{ + MEASUREITEMSTRUCT::itemData=itemData; +} + +inline +void MeasureItem::zeroInit(void) +{ + MEASUREITEMSTRUCT::CtlType=0; + MEASUREITEMSTRUCT::CtlID=0; + MEASUREITEMSTRUCT::itemID=0; + MEASUREITEMSTRUCT::itemWidth=0; + MEASUREITEMSTRUCT::itemHeight=0; + MEASUREITEMSTRUCT::itemData=0; +} +#endif \ No newline at end of file diff --git a/common/MEMFILE.CPP b/common/MEMFILE.CPP new file mode 100644 index 0000000..810539c --- /dev/null +++ b/common/MEMFILE.CPP @@ -0,0 +1,177 @@ +#include + +bool MemFile::createBuffer(DWORD lengthBuffer) +{ + destroyBuffer(); + mhGlobalBuffer=::GlobalAlloc(GMEM_FIXED,lengthBuffer); + if(!mhGlobalBuffer)return false; + mlpBuffer=(UHUGE*)::GlobalLock(mhGlobalBuffer); + mlpBufferPointer=mlpBuffer; + mBufferLength=lengthBuffer; + return true; +} + +bool MemFile::destroyBuffer(void) +{ + if(!mhGlobalBuffer)return false; + ::GlobalUnlock(mhGlobalBuffer); + ::GlobalFree(mhGlobalBuffer); + mlpBuffer=mlpBufferPointer=0; + mhGlobalBuffer=0; + mlpBufferPointer=0; + mIsDirty=false; + mBufferLength=0; + mMaxExtent=0; + return true; +} + +bool MemFile::rewind(void) +{ + if(!isOkay())return false; + mlpBufferPointer=mlpBuffer; + return true; +} + +DWORD MemFile::read(char *lpBuffer,DWORD lengthData) +{ + BYTE byteValue; + int bytesRead; + + bytesRead=0; + if(!isOkay())return bytesRead; + for(;bytesRead>16); + write(wordValue); + return true; +} + +bool MemFile::write(char *lpBuffer,DWORD lengthData) +{ + if(!isOkay())return FALSE; + if(!lengthData)return TRUE; + for(DWORD index=0;indexseekOffset)break; + if(seekOffset>mMaxExtent)break; + mlpBufferPointer=mlpBuffer+seekOffset; + returnCode=true; + break; + case SeekCurrent : + if(mlpBufferPointer+seekOffsetmlpBuffer+mBufferLength)break; + mlpBufferPointer+=seekOffset; + returnCode=true; + break; + } + return returnCode; +} + +bool MemFile::flushBuffer(void) +{ + OFSTRUCT ofStruct; + HFILE hOutputFile; + + if(!isOkay()||!mMaxExtent||mPathFileName.isNull())return false; + if(HFILE_ERROR==(hOutputFile=::OpenFile(mPathFileName,&ofStruct,OF_WRITE|OF_CREATE)))return false; + if(-1==::_hwrite(hOutputFile,(LPCSTR)mlpBuffer,mMaxExtent))return false; + ::_lclose(hOutputFile); + mIsDirty=false; + return true; +} + +DWORD MemFile::captureBuffer(GlobalData &memoryBuffer,bool clearDirty) +{ + if(!isOkay()||!mMaxExtent)return FALSE; + memoryBuffer.size(mMaxExtent); + for(DWORD itemIndex=0;itemIndex +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_TYPES_HPP_ +#include +#endif +#ifndef _COMMON_INTEL_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif + +class MemFile +{ +public: + enum SeekFrom{SeekBeginning,SeekCurrent}; + enum ByteOrder{BigEndian,LittleEndian}; + enum {BufferLength=16384}; + MemFile(const String &pathFileName,DWORD lengthBuffer=BufferLength,ByteOrder byteOrder=LittleEndian); + MemFile(DWORD lengthBuffer,ByteOrder byteOrder=LittleEndian); + virtual ~MemFile(); + bool rewind(void); + bool read(BYTE &value); + bool read(WORD &value); + bool read(int &value); + bool read(DWORD &value); + DWORD read(char *lpBuffer,DWORD lengthData); + DWORD read(char *lpBuffer,DWORD lengthData,int stopChar); + DWORD getLine(String &lineString); + bool write(BYTE value); + bool write(WORD value); + bool write(DWORD value); + bool write(int value); + bool write(char *lpBuffer,DWORD lengthData); + bool write(char *lpBuffer); + bool flushBuffer(void); + DWORD captureBuffer(GlobalData &memoryBuffer,bool clearDirty); + DWORD tell(void)const; + bool seek(LONG offset,SeekFrom seekFrom); + bool open(DWORD lengthBuffer,ByteOrder byteOrder=LittleEndian); + void close(void); + DWORD size(void)const; + DWORD extent(void)const; + bool isOkay(void)const; +private: + enum {CarriageReturn=0x0D,LineFeed=0x0A,NullChar=0x00}; + bool createBuffer(DWORD lengthBuffer); + bool destroyBuffer(void); + + HGLOBAL mhGlobalBuffer; + UHUGE *mlpBuffer; + UHUGE *mlpBufferPointer; + ByteOrder mByteOrder; + bool mIsDirty; + DWORD mMaxExtent; + DWORD mBufferLength; + String mPathFileName; + Intel mIntelData; +}; + +inline +MemFile::MemFile(const String &pathFileName,DWORD lengthBuffer,ByteOrder byteOrder) +: mPathFileName(pathFileName), mlpBuffer(0), mlpBufferPointer(0), mByteOrder(byteOrder), + mIsDirty(false), mMaxExtent(0), mBufferLength(0), mhGlobalBuffer(0) +{ + createBuffer(lengthBuffer); +} + +inline +MemFile::MemFile(DWORD lengthBuffer,ByteOrder byteOrder) +: mlpBuffer(0), mlpBufferPointer(0), mByteOrder(byteOrder), mIsDirty(false), + mMaxExtent(0), mBufferLength(0), mhGlobalBuffer(0) +{ + createBuffer(lengthBuffer); +} + +inline +MemFile::~MemFile() +{ + close(); +} + +inline +bool MemFile::open(DWORD lengthBuffer,ByteOrder byteOrder) +{ + close(); + mByteOrder=byteOrder; + return createBuffer(lengthBuffer); +} + +inline +void MemFile::close() +{ + if(mIsDirty)flushBuffer(); + destroyBuffer(); + if(!mPathFileName.isNull())mPathFileName=String(""); +} + +inline +bool MemFile::isOkay(void)const +{ + return (mhGlobalBuffer?true:false); +} + +inline +DWORD MemFile::tell(void)const +{ + if(!isOkay())return FALSE; + return mlpBufferPointer-mlpBuffer; +} + +inline +bool MemFile::read(BYTE &value) +{ + if(!isOkay())return false; + if(mlpBufferPointer-mlpBuffer>=mMaxExtent)return false; + value=*(mlpBufferPointer++); + return true; +} + +inline +bool MemFile::read(WORD &value) +{ + BYTE byteValue; + + if(!isOkay())return false; + if(!read(byteValue))return false; + value=byteValue; + if(!read(byteValue))return false; + value|=((WORD)byteValue)<<8; + if(BigEndian==mByteOrder)value=mIntelData.intelData(value); + return true; +} + +inline +bool MemFile::read(int &value) +{ + return read((DWORD&)value); +} + +inline +bool MemFile::read(DWORD &value) +{ + WORD wordValue; + + if(!isOkay())return false; + if(!read(wordValue))return false; + value=wordValue; + if(!read(wordValue))return false; + value|=((DWORD)wordValue)<<16; + if(BigEndian==mByteOrder)value=mIntelData.intelData(value); + return true; +} + +inline +bool MemFile::write(BYTE value) +{ + if(!isOkay())return false; + + if(mMaxExtent>=mBufferLength)return false; + *(mlpBufferPointer++)=value; + if(mlpBufferPointer-mlpBuffer>mMaxExtent)mMaxExtent=mlpBufferPointer-mlpBuffer; + mIsDirty=true; + return true; +} + +inline +bool MemFile::write(WORD value) +{ + BYTE byteValue; + + if(!isOkay())return false; + if(BigEndian==mByteOrder)value=mIntelData.intelData(value); + byteValue=(BYTE)(value&0x00FF); + if(!write(byteValue))return false; + byteValue=(BYTE)(value>>8); + if(!write(byteValue))return false; + return true; +} + +inline +bool MemFile::write(int value) +{ + return write((DWORD)value); +} + +inline +bool MemFile::write(char *lpBuffer) +{ + if(!lpBuffer)return false; + return write(lpBuffer,::strlen(lpBuffer)); +} + +inline +DWORD MemFile::size(void)const +{ + return (mlpBufferPointer-mlpBuffer); +} + +inline +DWORD MemFile::extent(void)const +{ + return mMaxExtent; +} + + +#endif diff --git a/common/MEMORY.HPP b/common/MEMORY.HPP new file mode 100644 index 0000000..e372505 --- /dev/null +++ b/common/MEMORY.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_MEMORY_HPP_ +#define _COMMON_MEMORY_HPP_ +#include +#endif diff --git a/common/MENUITEM.HPP b/common/MENUITEM.HPP new file mode 100644 index 0000000..ab06d89 --- /dev/null +++ b/common/MENUITEM.HPP @@ -0,0 +1,83 @@ +#ifndef _COMMON_MENUITEM_HPP_ +#define _COMMON_MENUITEM_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class MenuItem +{ +public: + MenuItem(void); + MenuItem(const String &itemString,UINT itemID); + MenuItem(const MenuItem &someMenuItem); + MenuItem &operator=(const MenuItem &someMenuItem); + WORD operator==(const MenuItem &someMenuItem)const; + String itemString(void)const; + void itemString(const String &itemString); + UINT itemID(void)const; + void itemID(UINT itemID); +private: + String mItemString; + UINT mItemID; +}; + +inline +MenuItem::MenuItem(void) +: mItemID(0) +{ +} + +inline +MenuItem::MenuItem(const String &itemString,UINT itemID) +: mItemString(itemString), mItemID(itemID) +{ +} + +inline +MenuItem::MenuItem(const MenuItem &someMenuItem) +{ + *this=someMenuItem; +} + +inline +MenuItem &MenuItem::operator=(const MenuItem &someMenuItem) +{ + itemString(someMenuItem.itemString()); + itemID(someMenuItem.itemID()); + return *this; +} + +inline +WORD MenuItem::operator==(const MenuItem &someMenuItem)const +{ + return (itemString()==someMenuItem.itemString()&& + itemID()==someMenuItem.itemID()); +} + +inline +String MenuItem::itemString(void)const +{ + return mItemString; +} + +inline +void MenuItem::itemString(const String &itemString) +{ + mItemString=itemString; +} + +inline +UINT MenuItem::itemID(void)const +{ + return mItemID; +} + +inline +void MenuItem::itemID(UINT itemID) +{ + mItemID=itemID; +} +#endif diff --git a/common/MMSYSTEM.HPP b/common/MMSYSTEM.HPP new file mode 100644 index 0000000..9821f6e --- /dev/null +++ b/common/MMSYSTEM.HPP @@ -0,0 +1,9 @@ +#ifndef _COMMON_MMSYSTEM_HPP_ +#define _COMMON_MMSYSTEM_HPP_ +#include +typedef UINT MMVERSION; +typedef UINT MMRESULT; +#endif + + + \ No newline at end of file diff --git a/common/MMTIMER.CPP b/common/MMTIMER.CPP new file mode 100644 index 0000000..fba7f8f --- /dev/null +++ b/common/MMTIMER.CPP @@ -0,0 +1,76 @@ +#include + +MMTimer::MMTimer(void) +: mMinResolution(0), mIsOkay(FALSE), mHasTimedEvent(FALSE), mTimerID(0), mIsFirstBreak(TRUE) +{ + if(::timeGetDevCaps(&mTimerCapability,sizeof(TIMECAPS)))return; + mMinResolution=mTimerCapability.wPeriodMin; + if(::timeBeginPeriod(mMinResolution))return; + mIsOkay=TRUE; +} + +MMTimer::MMTimer(WORD minResolution) +: mMinResolution(minResolution), mIsOkay(FALSE), mHasTimedEvent(FALSE), mTimerID(0), mIsFirstBreak(TRUE) +{ + if(::timeGetDevCaps(&mTimerCapability,sizeof(TIMECAPS)))return; + if(mMinResolutionisFirstBreak()) + { + ((MMTimer*)dwUser)->isFirstBreak(FALSE); + ((MMTimer*)dwUser)->timerStarted(); + } + if(((CallbackData::ReturnType)FALSE)==((MMTimer*)dwUser)->mCallbackPointer.callback(callbackData)) + { + ((MMTimer*)dwUser)->timerStopped(); + ((MMTimer*)dwUser)->stopTimer(); + } + return; +} + +// virtuals + +void MMTimer::timerStarted(void) +{ + return; +} + +void MMTimer::timerStopped(void) +{ + return; +} diff --git a/common/MMTIMER.HPP b/common/MMTIMER.HPP new file mode 100644 index 0000000..ec4c4ff --- /dev/null +++ b/common/MMTIMER.HPP @@ -0,0 +1,77 @@ +#ifndef _COMMON_MMTIMER_HPP_ +#define _COMMON_MMTIMER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_CALLBACK_HPP_ +#include +#endif +#ifndef _COMMON_MMSYSTEM_HPP_ +#include +#endif + +class MMTimer +{ +public: + MMTimer(void); + MMTimer(WORD minResolution); + virtual ~MMTimer(); + static DWORD getSystemTime(void); + bool startTimer(UINT deltaTime); + bool stopTimer(void); + bool isRunning(void)const; + void insertHandler(PureCallback *lpCallback); + void removeHandler(void); +protected: + virtual void timerStarted(void); + virtual void timerStopped(void); +private: + static void CALLBACK timerProc(UINT wTimerID,UINT mMsg,DWORD dwUser,DWORD dummyOne,DWORD dummyTwo); + bool isFirstBreak(void)const; + void isFirstBreak(bool isFirstBreak); + + TIMECAPS mTimerCapability; + WORD mMinResolution; + bool mIsOkay; + bool mHasTimedEvent; + bool mIsFirstBreak; + UINT mTimerID; + CallbackPointer mCallbackPointer; +}; + +inline +DWORD MMTimer::getSystemTime(void) +{ + return ::timeGetTime(); +} + +inline +bool MMTimer::isRunning(void)const +{ + return mHasTimedEvent; +} + +inline +void MMTimer::insertHandler(PureCallback *lpCallback) +{ + mCallbackPointer=CallbackPointer(lpCallback); +} + +inline +void MMTimer::removeHandler(void) +{ + mCallbackPointer=CallbackPointer(); +} + +inline +bool MMTimer::isFirstBreak(void)const +{ + return mIsFirstBreak; +} + +inline +void MMTimer::isFirstBreak(bool isFirstBreak) +{ + mIsFirstBreak=isFirstBreak; +} +#endif diff --git a/common/MSCOMMON.IDE b/common/MSCOMMON.IDE new file mode 100644 index 0000000..4ba550d Binary files /dev/null and b/common/MSCOMMON.IDE differ diff --git a/common/MSVCOBJ/Bitmap.obj b/common/MSVCOBJ/Bitmap.obj new file mode 100644 index 0000000..d0b10f8 Binary files /dev/null and b/common/MSVCOBJ/Bitmap.obj differ diff --git a/common/MSVCOBJ/Bitmap.sbr b/common/MSVCOBJ/Bitmap.sbr new file mode 100644 index 0000000..4675a77 Binary files /dev/null and b/common/MSVCOBJ/Bitmap.sbr differ diff --git a/common/MSVCOBJ/Bmdata.obj b/common/MSVCOBJ/Bmdata.obj new file mode 100644 index 0000000..b34eed1 Binary files /dev/null and b/common/MSVCOBJ/Bmdata.obj differ diff --git a/common/MSVCOBJ/Bmdata.sbr b/common/MSVCOBJ/Bmdata.sbr new file mode 100644 index 0000000..20f846f Binary files /dev/null and b/common/MSVCOBJ/Bmdata.sbr differ diff --git a/common/MSVCOBJ/Bminfo.obj b/common/MSVCOBJ/Bminfo.obj new file mode 100644 index 0000000..57fc8f3 Binary files /dev/null and b/common/MSVCOBJ/Bminfo.obj differ diff --git a/common/MSVCOBJ/Bminfo.sbr b/common/MSVCOBJ/Bminfo.sbr new file mode 100644 index 0000000..1ef58dd Binary files /dev/null and b/common/MSVCOBJ/Bminfo.sbr differ diff --git a/common/MSVCOBJ/Bmplnk.obj b/common/MSVCOBJ/Bmplnk.obj new file mode 100644 index 0000000..34d4a08 Binary files /dev/null and b/common/MSVCOBJ/Bmplnk.obj differ diff --git a/common/MSVCOBJ/Bmplnk.sbr b/common/MSVCOBJ/Bmplnk.sbr new file mode 100644 index 0000000..e955992 Binary files /dev/null and b/common/MSVCOBJ/Bmplnk.sbr differ diff --git a/common/MSVCOBJ/Brush.obj b/common/MSVCOBJ/Brush.obj new file mode 100644 index 0000000..72d23cd Binary files /dev/null and b/common/MSVCOBJ/Brush.obj differ diff --git a/common/MSVCOBJ/Brush.sbr b/common/MSVCOBJ/Brush.sbr new file mode 100644 index 0000000..b333c79 Binary files /dev/null and b/common/MSVCOBJ/Brush.sbr differ diff --git a/common/MSVCOBJ/Btnlnk.obj b/common/MSVCOBJ/Btnlnk.obj new file mode 100644 index 0000000..691b525 Binary files /dev/null and b/common/MSVCOBJ/Btnlnk.obj differ diff --git a/common/MSVCOBJ/Btnlnk.sbr b/common/MSVCOBJ/Btnlnk.sbr new file mode 100644 index 0000000..146a385 Binary files /dev/null and b/common/MSVCOBJ/Btnlnk.sbr differ diff --git a/common/MSVCOBJ/Catmull.obj b/common/MSVCOBJ/Catmull.obj new file mode 100644 index 0000000..047e9e8 Binary files /dev/null and b/common/MSVCOBJ/Catmull.obj differ diff --git a/common/MSVCOBJ/Catmull.sbr b/common/MSVCOBJ/Catmull.sbr new file mode 100644 index 0000000..e29079d Binary files /dev/null and b/common/MSVCOBJ/Catmull.sbr differ diff --git a/common/MSVCOBJ/Cbdata.obj b/common/MSVCOBJ/Cbdata.obj new file mode 100644 index 0000000..667f10c Binary files /dev/null and b/common/MSVCOBJ/Cbdata.obj differ diff --git a/common/MSVCOBJ/Cbdata.sbr b/common/MSVCOBJ/Cbdata.sbr new file mode 100644 index 0000000..4dc8c99 Binary files /dev/null and b/common/MSVCOBJ/Cbdata.sbr differ diff --git a/common/MSVCOBJ/Cbdatahk.obj b/common/MSVCOBJ/Cbdatahk.obj new file mode 100644 index 0000000..b86518a Binary files /dev/null and b/common/MSVCOBJ/Cbdatahk.obj differ diff --git a/common/MSVCOBJ/Cbdatahk.sbr b/common/MSVCOBJ/Cbdatahk.sbr new file mode 100644 index 0000000..79546a8 Binary files /dev/null and b/common/MSVCOBJ/Cbdatahk.sbr differ diff --git a/common/MSVCOBJ/Clipbrd.obj b/common/MSVCOBJ/Clipbrd.obj new file mode 100644 index 0000000..78f202c Binary files /dev/null and b/common/MSVCOBJ/Clipbrd.obj differ diff --git a/common/MSVCOBJ/Clipbrd.sbr b/common/MSVCOBJ/Clipbrd.sbr new file mode 100644 index 0000000..32fe11a Binary files /dev/null and b/common/MSVCOBJ/Clipbrd.sbr differ diff --git a/common/MSVCOBJ/Console.obj b/common/MSVCOBJ/Console.obj new file mode 100644 index 0000000..fd60014 Binary files /dev/null and b/common/MSVCOBJ/Console.obj differ diff --git a/common/MSVCOBJ/Console.sbr b/common/MSVCOBJ/Console.sbr new file mode 100644 index 0000000..491ecc8 Binary files /dev/null and b/common/MSVCOBJ/Console.sbr differ diff --git a/common/MSVCOBJ/Control.obj b/common/MSVCOBJ/Control.obj new file mode 100644 index 0000000..2900308 Binary files /dev/null and b/common/MSVCOBJ/Control.obj differ diff --git a/common/MSVCOBJ/Control.sbr b/common/MSVCOBJ/Control.sbr new file mode 100644 index 0000000..d3d2e09 Binary files /dev/null and b/common/MSVCOBJ/Control.sbr differ diff --git a/common/MSVCOBJ/Crsctrl.obj b/common/MSVCOBJ/Crsctrl.obj new file mode 100644 index 0000000..2b42b55 Binary files /dev/null and b/common/MSVCOBJ/Crsctrl.obj differ diff --git a/common/MSVCOBJ/Crsctrl.sbr b/common/MSVCOBJ/Crsctrl.sbr new file mode 100644 index 0000000..f16584e Binary files /dev/null and b/common/MSVCOBJ/Crsctrl.sbr differ diff --git a/common/MSVCOBJ/Ddemsg.obj b/common/MSVCOBJ/Ddemsg.obj new file mode 100644 index 0000000..5926a75 Binary files /dev/null and b/common/MSVCOBJ/Ddemsg.obj differ diff --git a/common/MSVCOBJ/Ddemsg.sbr b/common/MSVCOBJ/Ddemsg.sbr new file mode 100644 index 0000000..958e8e8 Binary files /dev/null and b/common/MSVCOBJ/Ddemsg.sbr differ diff --git a/common/MSVCOBJ/Dib.obj b/common/MSVCOBJ/Dib.obj new file mode 100644 index 0000000..0484786 Binary files /dev/null and b/common/MSVCOBJ/Dib.obj differ diff --git a/common/MSVCOBJ/Dib.sbr b/common/MSVCOBJ/Dib.sbr new file mode 100644 index 0000000..52ca0a3 Binary files /dev/null and b/common/MSVCOBJ/Dib.sbr differ diff --git a/common/MSVCOBJ/Diskinfo.obj b/common/MSVCOBJ/Diskinfo.obj new file mode 100644 index 0000000..7c713a1 Binary files /dev/null and b/common/MSVCOBJ/Diskinfo.obj differ diff --git a/common/MSVCOBJ/Diskinfo.sbr b/common/MSVCOBJ/Diskinfo.sbr new file mode 100644 index 0000000..1e62c40 Binary files /dev/null and b/common/MSVCOBJ/Diskinfo.sbr differ diff --git a/common/MSVCOBJ/Drawbmp.obj b/common/MSVCOBJ/Drawbmp.obj new file mode 100644 index 0000000..e7175ec Binary files /dev/null and b/common/MSVCOBJ/Drawbmp.obj differ diff --git a/common/MSVCOBJ/Drawbmp.sbr b/common/MSVCOBJ/Drawbmp.sbr new file mode 100644 index 0000000..020f23f Binary files /dev/null and b/common/MSVCOBJ/Drawbmp.sbr differ diff --git a/common/MSVCOBJ/Dwindow.obj b/common/MSVCOBJ/Dwindow.obj new file mode 100644 index 0000000..54b98de Binary files /dev/null and b/common/MSVCOBJ/Dwindow.obj differ diff --git a/common/MSVCOBJ/Dwindow.sbr b/common/MSVCOBJ/Dwindow.sbr new file mode 100644 index 0000000..d42aac2 Binary files /dev/null and b/common/MSVCOBJ/Dwindow.sbr differ diff --git a/common/MSVCOBJ/File.obj b/common/MSVCOBJ/File.obj new file mode 100644 index 0000000..b82ac29 Binary files /dev/null and b/common/MSVCOBJ/File.obj differ diff --git a/common/MSVCOBJ/File.sbr b/common/MSVCOBJ/File.sbr new file mode 100644 index 0000000..52a961a Binary files /dev/null and b/common/MSVCOBJ/File.sbr differ diff --git a/common/MSVCOBJ/Fileio.obj b/common/MSVCOBJ/Fileio.obj new file mode 100644 index 0000000..7e6b515 Binary files /dev/null and b/common/MSVCOBJ/Fileio.obj differ diff --git a/common/MSVCOBJ/Fileio.sbr b/common/MSVCOBJ/Fileio.sbr new file mode 100644 index 0000000..283ef07 Binary files /dev/null and b/common/MSVCOBJ/Fileio.sbr differ diff --git a/common/MSVCOBJ/Filemap.obj b/common/MSVCOBJ/Filemap.obj new file mode 100644 index 0000000..2f9c408 Binary files /dev/null and b/common/MSVCOBJ/Filemap.obj differ diff --git a/common/MSVCOBJ/Filemap.sbr b/common/MSVCOBJ/Filemap.sbr new file mode 100644 index 0000000..9146070 Binary files /dev/null and b/common/MSVCOBJ/Filemap.sbr differ diff --git a/common/MSVCOBJ/Finddata.obj b/common/MSVCOBJ/Finddata.obj new file mode 100644 index 0000000..1e9f748 Binary files /dev/null and b/common/MSVCOBJ/Finddata.obj differ diff --git a/common/MSVCOBJ/Finddata.sbr b/common/MSVCOBJ/Finddata.sbr new file mode 100644 index 0000000..6cb2ec1 Binary files /dev/null and b/common/MSVCOBJ/Finddata.sbr differ diff --git a/common/MSVCOBJ/Font.obj b/common/MSVCOBJ/Font.obj new file mode 100644 index 0000000..1cba1d9 Binary files /dev/null and b/common/MSVCOBJ/Font.obj differ diff --git a/common/MSVCOBJ/Font.sbr b/common/MSVCOBJ/Font.sbr new file mode 100644 index 0000000..a718a87 Binary files /dev/null and b/common/MSVCOBJ/Font.sbr differ diff --git a/common/MSVCOBJ/Guiwnd.obj b/common/MSVCOBJ/Guiwnd.obj new file mode 100644 index 0000000..f1406e1 Binary files /dev/null and b/common/MSVCOBJ/Guiwnd.obj differ diff --git a/common/MSVCOBJ/Guiwnd.sbr b/common/MSVCOBJ/Guiwnd.sbr new file mode 100644 index 0000000..d86fd7d Binary files /dev/null and b/common/MSVCOBJ/Guiwnd.sbr differ diff --git a/common/MSVCOBJ/Hookproc.obj b/common/MSVCOBJ/Hookproc.obj new file mode 100644 index 0000000..b4748af Binary files /dev/null and b/common/MSVCOBJ/Hookproc.obj differ diff --git a/common/MSVCOBJ/Hookproc.sbr b/common/MSVCOBJ/Hookproc.sbr new file mode 100644 index 0000000..89644d4 Binary files /dev/null and b/common/MSVCOBJ/Hookproc.sbr differ diff --git a/common/MSVCOBJ/Iconfrm.obj b/common/MSVCOBJ/Iconfrm.obj new file mode 100644 index 0000000..20d6dbe Binary files /dev/null and b/common/MSVCOBJ/Iconfrm.obj differ diff --git a/common/MSVCOBJ/Iconfrm.sbr b/common/MSVCOBJ/Iconfrm.sbr new file mode 100644 index 0000000..e8e41c4 Binary files /dev/null and b/common/MSVCOBJ/Iconfrm.sbr differ diff --git a/common/MSVCOBJ/Infowin.obj b/common/MSVCOBJ/Infowin.obj new file mode 100644 index 0000000..4f82165 Binary files /dev/null and b/common/MSVCOBJ/Infowin.obj differ diff --git a/common/MSVCOBJ/Infowin.sbr b/common/MSVCOBJ/Infowin.sbr new file mode 100644 index 0000000..cd5c661 Binary files /dev/null and b/common/MSVCOBJ/Infowin.sbr differ diff --git a/common/MSVCOBJ/Intel.obj b/common/MSVCOBJ/Intel.obj new file mode 100644 index 0000000..89cf495 Binary files /dev/null and b/common/MSVCOBJ/Intel.obj differ diff --git a/common/MSVCOBJ/Intel.sbr b/common/MSVCOBJ/Intel.sbr new file mode 100644 index 0000000..7d93561 Binary files /dev/null and b/common/MSVCOBJ/Intel.sbr differ diff --git a/common/MSVCOBJ/Iobuff.obj b/common/MSVCOBJ/Iobuff.obj new file mode 100644 index 0000000..1f47f99 Binary files /dev/null and b/common/MSVCOBJ/Iobuff.obj differ diff --git a/common/MSVCOBJ/Iobuff.sbr b/common/MSVCOBJ/Iobuff.sbr new file mode 100644 index 0000000..6be9da7 Binary files /dev/null and b/common/MSVCOBJ/Iobuff.sbr differ diff --git a/common/MSVCOBJ/Logowin.obj b/common/MSVCOBJ/Logowin.obj new file mode 100644 index 0000000..44498e6 Binary files /dev/null and b/common/MSVCOBJ/Logowin.obj differ diff --git a/common/MSVCOBJ/Logowin.sbr b/common/MSVCOBJ/Logowin.sbr new file mode 100644 index 0000000..d663193 Binary files /dev/null and b/common/MSVCOBJ/Logowin.sbr differ diff --git a/common/MSVCOBJ/Macro.obj b/common/MSVCOBJ/Macro.obj new file mode 100644 index 0000000..3957e6d Binary files /dev/null and b/common/MSVCOBJ/Macro.obj differ diff --git a/common/MSVCOBJ/Macro.sbr b/common/MSVCOBJ/Macro.sbr new file mode 100644 index 0000000..0653068 Binary files /dev/null and b/common/MSVCOBJ/Macro.sbr differ diff --git a/common/MSVCOBJ/Math.obj b/common/MSVCOBJ/Math.obj new file mode 100644 index 0000000..d02b2a5 Binary files /dev/null and b/common/MSVCOBJ/Math.obj differ diff --git a/common/MSVCOBJ/Math.sbr b/common/MSVCOBJ/Math.sbr new file mode 100644 index 0000000..6cd0774 Binary files /dev/null and b/common/MSVCOBJ/Math.sbr differ diff --git a/common/MSVCOBJ/Mdifrm.obj b/common/MSVCOBJ/Mdifrm.obj new file mode 100644 index 0000000..b84c089 Binary files /dev/null and b/common/MSVCOBJ/Mdifrm.obj differ diff --git a/common/MSVCOBJ/Mdifrm.sbr b/common/MSVCOBJ/Mdifrm.sbr new file mode 100644 index 0000000..abd9e14 Binary files /dev/null and b/common/MSVCOBJ/Mdifrm.sbr differ diff --git a/common/MSVCOBJ/Mdiwin.obj b/common/MSVCOBJ/Mdiwin.obj new file mode 100644 index 0000000..69a6cf7 Binary files /dev/null and b/common/MSVCOBJ/Mdiwin.obj differ diff --git a/common/MSVCOBJ/Mdiwin.sbr b/common/MSVCOBJ/Mdiwin.sbr new file mode 100644 index 0000000..533f374 Binary files /dev/null and b/common/MSVCOBJ/Mdiwin.sbr differ diff --git a/common/MSVCOBJ/Memfile.obj b/common/MSVCOBJ/Memfile.obj new file mode 100644 index 0000000..2530e8b Binary files /dev/null and b/common/MSVCOBJ/Memfile.obj differ diff --git a/common/MSVCOBJ/Memfile.sbr b/common/MSVCOBJ/Memfile.sbr new file mode 100644 index 0000000..58db227 Binary files /dev/null and b/common/MSVCOBJ/Memfile.sbr differ diff --git a/common/MSVCOBJ/Mmtimer.obj b/common/MSVCOBJ/Mmtimer.obj new file mode 100644 index 0000000..5541c70 Binary files /dev/null and b/common/MSVCOBJ/Mmtimer.obj differ diff --git a/common/MSVCOBJ/Mmtimer.sbr b/common/MSVCOBJ/Mmtimer.sbr new file mode 100644 index 0000000..7141467 Binary files /dev/null and b/common/MSVCOBJ/Mmtimer.sbr differ diff --git a/common/MSVCOBJ/Odbutton.obj b/common/MSVCOBJ/Odbutton.obj new file mode 100644 index 0000000..d65009b Binary files /dev/null and b/common/MSVCOBJ/Odbutton.obj differ diff --git a/common/MSVCOBJ/Odbutton.sbr b/common/MSVCOBJ/Odbutton.sbr new file mode 100644 index 0000000..8a4e616 Binary files /dev/null and b/common/MSVCOBJ/Odbutton.sbr differ diff --git a/common/MSVCOBJ/Odlist.obj b/common/MSVCOBJ/Odlist.obj new file mode 100644 index 0000000..94322a3 Binary files /dev/null and b/common/MSVCOBJ/Odlist.obj differ diff --git a/common/MSVCOBJ/Odlist.sbr b/common/MSVCOBJ/Odlist.sbr new file mode 100644 index 0000000..1037e63 Binary files /dev/null and b/common/MSVCOBJ/Odlist.sbr differ diff --git a/common/MSVCOBJ/Odlstalt.obj b/common/MSVCOBJ/Odlstalt.obj new file mode 100644 index 0000000..f7c7fc2 Binary files /dev/null and b/common/MSVCOBJ/Odlstalt.obj differ diff --git a/common/MSVCOBJ/Odlstalt.sbr b/common/MSVCOBJ/Odlstalt.sbr new file mode 100644 index 0000000..1cd8dea Binary files /dev/null and b/common/MSVCOBJ/Odlstalt.sbr differ diff --git a/common/MSVCOBJ/Odlstchk.obj b/common/MSVCOBJ/Odlstchk.obj new file mode 100644 index 0000000..0c5ff79 Binary files /dev/null and b/common/MSVCOBJ/Odlstchk.obj differ diff --git a/common/MSVCOBJ/Odlstchk.sbr b/common/MSVCOBJ/Odlstchk.sbr new file mode 100644 index 0000000..dd9cb4f Binary files /dev/null and b/common/MSVCOBJ/Odlstchk.sbr differ diff --git a/common/MSVCOBJ/Openfile.obj b/common/MSVCOBJ/Openfile.obj new file mode 100644 index 0000000..27234bb Binary files /dev/null and b/common/MSVCOBJ/Openfile.obj differ diff --git a/common/MSVCOBJ/Openfile.sbr b/common/MSVCOBJ/Openfile.sbr new file mode 100644 index 0000000..dcc9977 Binary files /dev/null and b/common/MSVCOBJ/Openfile.sbr differ diff --git a/common/MSVCOBJ/Owner.obj b/common/MSVCOBJ/Owner.obj new file mode 100644 index 0000000..aa197f4 Binary files /dev/null and b/common/MSVCOBJ/Owner.obj differ diff --git a/common/MSVCOBJ/Owner.sbr b/common/MSVCOBJ/Owner.sbr new file mode 100644 index 0000000..f4dc26f Binary files /dev/null and b/common/MSVCOBJ/Owner.sbr differ diff --git a/common/MSVCOBJ/Pathfnd.obj b/common/MSVCOBJ/Pathfnd.obj new file mode 100644 index 0000000..9498021 Binary files /dev/null and b/common/MSVCOBJ/Pathfnd.obj differ diff --git a/common/MSVCOBJ/Pathfnd.sbr b/common/MSVCOBJ/Pathfnd.sbr new file mode 100644 index 0000000..10922f1 Binary files /dev/null and b/common/MSVCOBJ/Pathfnd.sbr differ diff --git a/common/MSVCOBJ/Point.obj b/common/MSVCOBJ/Point.obj new file mode 100644 index 0000000..dd6e434 Binary files /dev/null and b/common/MSVCOBJ/Point.obj differ diff --git a/common/MSVCOBJ/Point.sbr b/common/MSVCOBJ/Point.sbr new file mode 100644 index 0000000..e7de9b5 Binary files /dev/null and b/common/MSVCOBJ/Point.sbr differ diff --git a/common/MSVCOBJ/Process.obj b/common/MSVCOBJ/Process.obj new file mode 100644 index 0000000..9f36547 Binary files /dev/null and b/common/MSVCOBJ/Process.obj differ diff --git a/common/MSVCOBJ/Process.sbr b/common/MSVCOBJ/Process.sbr new file mode 100644 index 0000000..0f766b8 Binary files /dev/null and b/common/MSVCOBJ/Process.sbr differ diff --git a/common/MSVCOBJ/Profile.obj b/common/MSVCOBJ/Profile.obj new file mode 100644 index 0000000..01a281c Binary files /dev/null and b/common/MSVCOBJ/Profile.obj differ diff --git a/common/MSVCOBJ/Profile.sbr b/common/MSVCOBJ/Profile.sbr new file mode 100644 index 0000000..165c4bc Binary files /dev/null and b/common/MSVCOBJ/Profile.sbr differ diff --git a/common/MSVCOBJ/Progress.obj b/common/MSVCOBJ/Progress.obj new file mode 100644 index 0000000..2c52e55 Binary files /dev/null and b/common/MSVCOBJ/Progress.obj differ diff --git a/common/MSVCOBJ/Progress.sbr b/common/MSVCOBJ/Progress.sbr new file mode 100644 index 0000000..a9676ac Binary files /dev/null and b/common/MSVCOBJ/Progress.sbr differ diff --git a/common/MSVCOBJ/Purebmp.obj b/common/MSVCOBJ/Purebmp.obj new file mode 100644 index 0000000..9027622 Binary files /dev/null and b/common/MSVCOBJ/Purebmp.obj differ diff --git a/common/MSVCOBJ/Purebmp.sbr b/common/MSVCOBJ/Purebmp.sbr new file mode 100644 index 0000000..c65d4d3 Binary files /dev/null and b/common/MSVCOBJ/Purebmp.sbr differ diff --git a/common/MSVCOBJ/Purebyte.obj b/common/MSVCOBJ/Purebyte.obj new file mode 100644 index 0000000..ec41415 Binary files /dev/null and b/common/MSVCOBJ/Purebyte.obj differ diff --git a/common/MSVCOBJ/Purebyte.sbr b/common/MSVCOBJ/Purebyte.sbr new file mode 100644 index 0000000..de84e92 Binary files /dev/null and b/common/MSVCOBJ/Purebyte.sbr differ diff --git a/common/MSVCOBJ/Puredwrd.obj b/common/MSVCOBJ/Puredwrd.obj new file mode 100644 index 0000000..d29f2fe Binary files /dev/null and b/common/MSVCOBJ/Puredwrd.obj differ diff --git a/common/MSVCOBJ/Puredwrd.sbr b/common/MSVCOBJ/Puredwrd.sbr new file mode 100644 index 0000000..795f2f3 Binary files /dev/null and b/common/MSVCOBJ/Puredwrd.sbr differ diff --git a/common/MSVCOBJ/Purehdc.obj b/common/MSVCOBJ/Purehdc.obj new file mode 100644 index 0000000..26aadd0 Binary files /dev/null and b/common/MSVCOBJ/Purehdc.obj differ diff --git a/common/MSVCOBJ/Purehdc.sbr b/common/MSVCOBJ/Purehdc.sbr new file mode 100644 index 0000000..d7928c5 Binary files /dev/null and b/common/MSVCOBJ/Purehdc.sbr differ diff --git a/common/MSVCOBJ/Purepal.obj b/common/MSVCOBJ/Purepal.obj new file mode 100644 index 0000000..65e97b6 Binary files /dev/null and b/common/MSVCOBJ/Purepal.obj differ diff --git a/common/MSVCOBJ/Purepal.sbr b/common/MSVCOBJ/Purepal.sbr new file mode 100644 index 0000000..10220f1 Binary files /dev/null and b/common/MSVCOBJ/Purepal.sbr differ diff --git a/common/MSVCOBJ/Pview.obj b/common/MSVCOBJ/Pview.obj new file mode 100644 index 0000000..fa7520c Binary files /dev/null and b/common/MSVCOBJ/Pview.obj differ diff --git a/common/MSVCOBJ/Pview.sbr b/common/MSVCOBJ/Pview.sbr new file mode 100644 index 0000000..25912b6 Binary files /dev/null and b/common/MSVCOBJ/Pview.sbr differ diff --git a/common/MSVCOBJ/Regkey.obj b/common/MSVCOBJ/Regkey.obj new file mode 100644 index 0000000..66e9b3b Binary files /dev/null and b/common/MSVCOBJ/Regkey.obj differ diff --git a/common/MSVCOBJ/Regkey.sbr b/common/MSVCOBJ/Regkey.sbr new file mode 100644 index 0000000..946d656 Binary files /dev/null and b/common/MSVCOBJ/Regkey.sbr differ diff --git a/common/MSVCOBJ/Richedit.obj b/common/MSVCOBJ/Richedit.obj new file mode 100644 index 0000000..87de777 Binary files /dev/null and b/common/MSVCOBJ/Richedit.obj differ diff --git a/common/MSVCOBJ/Richedit.sbr b/common/MSVCOBJ/Richedit.sbr new file mode 100644 index 0000000..868c3c1 Binary files /dev/null and b/common/MSVCOBJ/Richedit.sbr differ diff --git a/common/MSVCOBJ/Sdate.obj b/common/MSVCOBJ/Sdate.obj new file mode 100644 index 0000000..747ecdd Binary files /dev/null and b/common/MSVCOBJ/Sdate.obj differ diff --git a/common/MSVCOBJ/Sdate.sbr b/common/MSVCOBJ/Sdate.sbr new file mode 100644 index 0000000..845d088 Binary files /dev/null and b/common/MSVCOBJ/Sdate.sbr differ diff --git a/common/MSVCOBJ/Smrtstrm.obj b/common/MSVCOBJ/Smrtstrm.obj new file mode 100644 index 0000000..6b0d523 Binary files /dev/null and b/common/MSVCOBJ/Smrtstrm.obj differ diff --git a/common/MSVCOBJ/Smrtstrm.sbr b/common/MSVCOBJ/Smrtstrm.sbr new file mode 100644 index 0000000..bd5737e Binary files /dev/null and b/common/MSVCOBJ/Smrtstrm.sbr differ diff --git a/common/MSVCOBJ/String.obj b/common/MSVCOBJ/String.obj new file mode 100644 index 0000000..7ccb8b3 Binary files /dev/null and b/common/MSVCOBJ/String.obj differ diff --git a/common/MSVCOBJ/String.sbr b/common/MSVCOBJ/String.sbr new file mode 100644 index 0000000..f9bde44 Binary files /dev/null and b/common/MSVCOBJ/String.sbr differ diff --git a/common/MSVCOBJ/Systime.obj b/common/MSVCOBJ/Systime.obj new file mode 100644 index 0000000..89580a4 Binary files /dev/null and b/common/MSVCOBJ/Systime.obj differ diff --git a/common/MSVCOBJ/Systime.sbr b/common/MSVCOBJ/Systime.sbr new file mode 100644 index 0000000..966f3bb Binary files /dev/null and b/common/MSVCOBJ/Systime.sbr differ diff --git a/common/MSVCOBJ/Vhandler.obj b/common/MSVCOBJ/Vhandler.obj new file mode 100644 index 0000000..5bc9dc4 Binary files /dev/null and b/common/MSVCOBJ/Vhandler.obj differ diff --git a/common/MSVCOBJ/Vhandler.sbr b/common/MSVCOBJ/Vhandler.sbr new file mode 100644 index 0000000..f8d7e80 Binary files /dev/null and b/common/MSVCOBJ/Vhandler.sbr differ diff --git a/common/MSVCOBJ/Vxdctrl.obj b/common/MSVCOBJ/Vxdctrl.obj new file mode 100644 index 0000000..14c27b2 Binary files /dev/null and b/common/MSVCOBJ/Vxdctrl.obj differ diff --git a/common/MSVCOBJ/Vxdctrl.sbr b/common/MSVCOBJ/Vxdctrl.sbr new file mode 100644 index 0000000..c099e94 Binary files /dev/null and b/common/MSVCOBJ/Vxdctrl.sbr differ diff --git a/common/MSVCOBJ/Window.obj b/common/MSVCOBJ/Window.obj new file mode 100644 index 0000000..d2766c7 Binary files /dev/null and b/common/MSVCOBJ/Window.obj differ diff --git a/common/MSVCOBJ/Window.sbr b/common/MSVCOBJ/Window.sbr new file mode 100644 index 0000000..2d366dc Binary files /dev/null and b/common/MSVCOBJ/Window.sbr differ diff --git a/common/MSVCOBJ/Wintimer.obj b/common/MSVCOBJ/Wintimer.obj new file mode 100644 index 0000000..9e05d46 Binary files /dev/null and b/common/MSVCOBJ/Wintimer.obj differ diff --git a/common/MSVCOBJ/Wintimer.sbr b/common/MSVCOBJ/Wintimer.sbr new file mode 100644 index 0000000..cc02972 Binary files /dev/null and b/common/MSVCOBJ/Wintimer.sbr differ diff --git a/common/MSVCOBJ/accelerator.obj b/common/MSVCOBJ/accelerator.obj new file mode 100644 index 0000000..68026ba Binary files /dev/null and b/common/MSVCOBJ/accelerator.obj differ diff --git a/common/MSVCOBJ/accelerator.sbr b/common/MSVCOBJ/accelerator.sbr new file mode 100644 index 0000000..65cfc8b Binary files /dev/null and b/common/MSVCOBJ/accelerator.sbr differ diff --git a/common/MSVCOBJ/calendar.obj b/common/MSVCOBJ/calendar.obj new file mode 100644 index 0000000..deacc1a Binary files /dev/null and b/common/MSVCOBJ/calendar.obj differ diff --git a/common/MSVCOBJ/calendar.sbr b/common/MSVCOBJ/calendar.sbr new file mode 100644 index 0000000..4ff8d1b Binary files /dev/null and b/common/MSVCOBJ/calendar.sbr differ diff --git a/common/MSVCOBJ/common.pch b/common/MSVCOBJ/common.pch new file mode 100644 index 0000000..46d9e97 Binary files /dev/null and b/common/MSVCOBJ/common.pch differ diff --git a/common/MSVCOBJ/elastic.obj b/common/MSVCOBJ/elastic.obj new file mode 100644 index 0000000..a2e9e7e Binary files /dev/null and b/common/MSVCOBJ/elastic.obj differ diff --git a/common/MSVCOBJ/elastic.sbr b/common/MSVCOBJ/elastic.sbr new file mode 100644 index 0000000..c9290e0 Binary files /dev/null and b/common/MSVCOBJ/elastic.sbr differ diff --git a/common/MSVCOBJ/errormsg.obj b/common/MSVCOBJ/errormsg.obj new file mode 100644 index 0000000..c742dc3 Binary files /dev/null and b/common/MSVCOBJ/errormsg.obj differ diff --git a/common/MSVCOBJ/errormsg.sbr b/common/MSVCOBJ/errormsg.sbr new file mode 100644 index 0000000..db6cf41 Binary files /dev/null and b/common/MSVCOBJ/errormsg.sbr differ diff --git a/common/MSVCOBJ/gdipoint.obj b/common/MSVCOBJ/gdipoint.obj new file mode 100644 index 0000000..ec5beab Binary files /dev/null and b/common/MSVCOBJ/gdipoint.obj differ diff --git a/common/MSVCOBJ/gdipoint.sbr b/common/MSVCOBJ/gdipoint.sbr new file mode 100644 index 0000000..b601043 Binary files /dev/null and b/common/MSVCOBJ/gdipoint.sbr differ diff --git a/common/MSVCOBJ/opendlg.obj b/common/MSVCOBJ/opendlg.obj new file mode 100644 index 0000000..30696b0 Binary files /dev/null and b/common/MSVCOBJ/opendlg.obj differ diff --git a/common/MSVCOBJ/opendlg.sbr b/common/MSVCOBJ/opendlg.sbr new file mode 100644 index 0000000..4ef9f91 Binary files /dev/null and b/common/MSVCOBJ/opendlg.sbr differ diff --git a/common/MSVCOBJ/opndlgex.obj b/common/MSVCOBJ/opndlgex.obj new file mode 100644 index 0000000..1944b77 Binary files /dev/null and b/common/MSVCOBJ/opndlgex.obj differ diff --git a/common/MSVCOBJ/opndlgex.sbr b/common/MSVCOBJ/opndlgex.sbr new file mode 100644 index 0000000..284f2bc Binary files /dev/null and b/common/MSVCOBJ/opndlgex.sbr differ diff --git a/common/MSVCOBJ/puredbl.obj b/common/MSVCOBJ/puredbl.obj new file mode 100644 index 0000000..e8b3cc2 Binary files /dev/null and b/common/MSVCOBJ/puredbl.obj differ diff --git a/common/MSVCOBJ/puredbl.sbr b/common/MSVCOBJ/puredbl.sbr new file mode 100644 index 0000000..a0205f6 Binary files /dev/null and b/common/MSVCOBJ/puredbl.sbr differ diff --git a/common/MSVCOBJ/puremenu.obj b/common/MSVCOBJ/puremenu.obj new file mode 100644 index 0000000..2f748aa Binary files /dev/null and b/common/MSVCOBJ/puremenu.obj differ diff --git a/common/MSVCOBJ/puremenu.sbr b/common/MSVCOBJ/puremenu.sbr new file mode 100644 index 0000000..61143b6 Binary files /dev/null and b/common/MSVCOBJ/puremenu.sbr differ diff --git a/common/MSVCOBJ/purewrd.obj b/common/MSVCOBJ/purewrd.obj new file mode 100644 index 0000000..f669063 Binary files /dev/null and b/common/MSVCOBJ/purewrd.obj differ diff --git a/common/MSVCOBJ/purewrd.sbr b/common/MSVCOBJ/purewrd.sbr new file mode 100644 index 0000000..00dde8b Binary files /dev/null and b/common/MSVCOBJ/purewrd.sbr differ diff --git a/common/MSVCOBJ/resbmp.obj b/common/MSVCOBJ/resbmp.obj new file mode 100644 index 0000000..1815967 Binary files /dev/null and b/common/MSVCOBJ/resbmp.obj differ diff --git a/common/MSVCOBJ/resbmp.sbr b/common/MSVCOBJ/resbmp.sbr new file mode 100644 index 0000000..59bb7bf Binary files /dev/null and b/common/MSVCOBJ/resbmp.sbr differ diff --git a/common/MSVCOBJ/rubber.obj b/common/MSVCOBJ/rubber.obj new file mode 100644 index 0000000..60abb46 Binary files /dev/null and b/common/MSVCOBJ/rubber.obj differ diff --git a/common/MSVCOBJ/rubber.sbr b/common/MSVCOBJ/rubber.sbr new file mode 100644 index 0000000..345d71a Binary files /dev/null and b/common/MSVCOBJ/rubber.sbr differ diff --git a/common/MSVCOBJ/snapshot.obj b/common/MSVCOBJ/snapshot.obj new file mode 100644 index 0000000..33265f3 Binary files /dev/null and b/common/MSVCOBJ/snapshot.obj differ diff --git a/common/MSVCOBJ/snapshot.sbr b/common/MSVCOBJ/snapshot.sbr new file mode 100644 index 0000000..b0da669 Binary files /dev/null and b/common/MSVCOBJ/snapshot.sbr differ diff --git a/common/MSVCOBJ/static.obj b/common/MSVCOBJ/static.obj new file mode 100644 index 0000000..0723d39 Binary files /dev/null and b/common/MSVCOBJ/static.obj differ diff --git a/common/MSVCOBJ/static.sbr b/common/MSVCOBJ/static.sbr new file mode 100644 index 0000000..2cff4d3 Binary files /dev/null and b/common/MSVCOBJ/static.sbr differ diff --git a/common/MSVCOBJ/vc50.idb b/common/MSVCOBJ/vc50.idb new file mode 100644 index 0000000..119ea31 Binary files /dev/null and b/common/MSVCOBJ/vc50.idb differ diff --git a/common/MSVCOBJ/vc60.idb b/common/MSVCOBJ/vc60.idb new file mode 100644 index 0000000..14abc17 Binary files /dev/null and b/common/MSVCOBJ/vc60.idb differ diff --git a/common/MSVCOBJ/vc60.pdb b/common/MSVCOBJ/vc60.pdb new file mode 100644 index 0000000..272041e Binary files /dev/null and b/common/MSVCOBJ/vc60.pdb differ diff --git a/common/MSVCOBJ/widestr.obj b/common/MSVCOBJ/widestr.obj new file mode 100644 index 0000000..c1e4c25 Binary files /dev/null and b/common/MSVCOBJ/widestr.obj differ diff --git a/common/MSVCOBJ/widestr.sbr b/common/MSVCOBJ/widestr.sbr new file mode 100644 index 0000000..2c7b366 Binary files /dev/null and b/common/MSVCOBJ/widestr.sbr differ diff --git a/common/Mdifrm.cpp b/common/Mdifrm.cpp new file mode 100644 index 0000000..90b3432 --- /dev/null +++ b/common/Mdifrm.cpp @@ -0,0 +1,491 @@ +#include +#include +#include +#include +#include +#include +#include + +FrameWindow::FrameWindow(void) +{ + mDestroyHandler.setCallback(this,&FrameWindow::destroyHandler); + mMDIActivateHandler.setCallback(this,&FrameWindow::mdiActivateHandler); + mCommandHandler.setCallback(this,&FrameWindow::commandHandler); + insertHandler(VectorHandler::MDIActivateHandler,&mMDIActivateHandler); + insertHandler(VectorHandler::CommandHandler,&mCommandHandler); +} + +FrameWindow::FrameWindow(const FrameWindow &frameWindow) +{ // private implementation + *this=frameWindow; + mDestroyHandler.setCallback(this,&FrameWindow::destroyHandler); + mMDIActivateHandler.setCallback(this,&FrameWindow::mdiActivateHandler); + mCommandHandler.setCallback(this,&FrameWindow::commandHandler); + insertHandler(VectorHandler::MDIActivateHandler,&mMDIActivateHandler); + insertHandler(VectorHandler::CommandHandler,&mCommandHandler); +} + +FrameWindow::~FrameWindow() +{ + removeHandler(VectorHandler::MDIActivateHandler,&mMDIActivateHandler); + removeHandler(VectorHandler::CommandHandler,&mCommandHandler); +} + +FrameWindow &FrameWindow::operator=(const FrameWindow &/*frameWindow*/) +{ // private implentation + return *this; +} + +void FrameWindow::createWindow(const String &className,const String &windowName,const String &menuName,const String &iconName) +{ + HINSTANCE hInstance(processInstance()); + mFrameMenu=menuName; + registerClass(hInstance,className,iconName); +// GUIWindow::createWindow(className,windowName,WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN,Rect(CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT),0,mFrameMenu,hInstance,(LPSTR)this); + GUIWindow::createWindow(className,windowName,WS_OVERLAPPEDWINDOW,Rect(CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT),0,mFrameMenu,hInstance,(LPSTR)this); + show(SW_SHOW); + update(); +} + +void FrameWindow::registerClass(HINSTANCE hInstance,const String &className,const String &iconName) +{ + WNDCLASS wndClass; + + if(::GetClassInfo(hInstance,(char*)(String&)className,&wndClass))return; + wndClass.style =CS_HREDRAW|CS_VREDRAW; + wndClass.lpfnWndProc =(WNDPROC)FrameWindow::FrameProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(FrameWindow*); + wndClass.hInstance =hInstance; + wndClass.hIcon =::LoadIcon(hInstance,iconName); + wndClass.hCursor =::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)(COLOR_WINDOWFRAME); + wndClass.lpszMenuName =0; + wndClass.lpszClassName =(char*)(String&)className; + preRegister(wndClass); + ::RegisterClass(&wndClass); +} + +void FrameWindow::createMDIClientWindow(void) +{ + CLIENTCREATESTRUCT clientCreate; + PureMenu subMenu; + + clientCreate.hWindowMenu=(HMENU)subMenu; + clientCreate.idFirstChild=IDFirstMDIChild; + mClientWnd.createWindow("MDICLIENT",String(),WS_CHILD|WS_CLIPCHILDREN|WS_VISIBLE|MDIS_ALLCHILDSTYLES,Rect(0,0,0,0),*this,(HMENU)0,processInstance(),(CLIENTCREATESTRUCT *)&clientCreate); +} + +void FrameWindow::insert(MDIWindow &mdiWindow) +{ + mDocuments.insert(&SmartPointer(&mdiWindow)); + mDocuments[mDocuments.size()-1].disposition(PointerDisposition::Delete); + mDocuments[mDocuments.size()-1]->insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler); +} + +MDIWindow &FrameWindow::operator[](int itemIndex) +{ + return *(mDocuments[itemIndex]); +} + +int FrameWindow::size(void)const +{ + return mDocuments.size(); +} + +int FrameWindow::windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam) +{ + watchDocumentWindows(); + if(message>=WM_USER&&message<=0x7FFF) + { + if(!installedHandlers(VectorHandler::UserHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::UserHandler,CallbackData(message,lParam,hWnd)); + } + switch(message) + { + case WM_CLOSE : + if(!installedHandlers(VectorHandler::CloseHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CloseHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCCREATE : + if(!installedHandlers(VectorHandler::NCCreateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCCreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHANGECBCHAIN : + if(!installedHandlers(VectorHandler::ChangeCBChainHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ChangeCBChainHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWCLIPBOARD : + if(!installedHandlers(VectorHandler::DrawClipboardHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawClipboardHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CREATE : + createMDIClientWindow(); + if(!installedHandlers(VectorHandler::CreateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PAINT : + if(!installedHandlers(VectorHandler::PaintHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return handlePaintMessage(hWnd,message,wParam,lParam); + case WM_ERASEBKGND : + if(!installedHandlers(VectorHandler::EraseBackgroundHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EraseBackgroundHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PALETTECHANGED : + if(!installedHandlers(VectorHandler::PaletteChangedHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::PaletteChangedHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWITEM : + if(!installedHandlers(VectorHandler::DrawItemHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_TIMER : + if(!installedHandlers(VectorHandler::TimerHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::TimerHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHAR : + if(!installedHandlers(VectorHandler::CharHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CharHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMMAND : + if(!installedHandlers(VectorHandler::CommandHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + callHandlers(VectorHandler::CommandHandler,CallbackData(wParam,lParam,hWnd)); + return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + case WM_COMPACTING : + if(!installedHandlers(VectorHandler::CompactingHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CompactingHandler,CallbackData(wParam,lParam,hWnd)); + case WM_WININICHANGE : + if(!installedHandlers(VectorHandler::WinIniChangeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::WinIniChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SYSCOLORCHANGE : + if(!installedHandlers(VectorHandler::SysColorChangeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SysColorChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORMSGBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOREDIT : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORLISTBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORBTN : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORDLG : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSCROLLBAR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSTATIC : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_INITIATE : + if(!installedHandlers(VectorHandler::DDEInitiateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEInitiateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_ACK : + if(!installedHandlers(VectorHandler::DDEAckHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEAckHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_REQUEST : + if(!installedHandlers(VectorHandler::DDERequestHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDERequestHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_TERMINATE : + if(!installedHandlers(VectorHandler::DDETerminateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDETerminateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_DATA : + if(!installedHandlers(VectorHandler::DDEDataHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEDataHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_OPEN : + if(!installedHandlers(VectorHandler::MMOpenHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMOpenHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_CLOSE : + if(!installedHandlers(VectorHandler::MMCloseHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMCloseHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_DONE : + if(!installedHandlers(VectorHandler::MMDoneHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMDoneHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::LeftButtonDoubleHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDOWN : + if(!installedHandlers(VectorHandler::LeftButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONUP : + if(!installedHandlers(VectorHandler::LeftButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::RightButtonDoubleHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDOWN : + if(!installedHandlers(VectorHandler::RightButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONUP : + if(!installedHandlers(VectorHandler::RightButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONUP : + if(!installedHandlers(VectorHandler::NCLeftButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCLeftButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONUP : + if(!installedHandlers(VectorHandler::NCRightButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCRightButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MOUSEMOVE : + if(!installedHandlers(VectorHandler::MouseMoveHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MouseMoveHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFOCUS : + if(!installedHandlers(VectorHandler::SetFocusHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFONT : + if(!installedHandlers(VectorHandler::SetFontHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFontHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KILLFOCUS : + if(!installedHandlers(VectorHandler::KillFocusHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KillFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYUP : + if(!installedHandlers(VectorHandler::KeyUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYDOWN : + if(!installedHandlers(VectorHandler::KeyDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETMINMAXINFO : + if(!installedHandlers(VectorHandler::MinMaxHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MinMaxHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ENTERIDLE : + if(!installedHandlers(VectorHandler::EnterIdleHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EnterIdleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MENUSELECT : + if(!installedHandlers(VectorHandler::MenuSelectHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MenuSelectHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETDLGCODE : + if(!installedHandlers(VectorHandler::DialogCodeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DialogCodeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MEASUREITEM : + if(!installedHandlers(VectorHandler::MeasureItemHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MeasureItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_VSCROLL : + if(!installedHandlers(VectorHandler::VerticalScrollHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::VerticalScrollHandler,CallbackData(wParam,lParam,hWnd)); + case WM_HSCROLL : + if(!installedHandlers(VectorHandler::HorizontalScrollHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::HorizontalScrollHandler,CallbackData(wParam,lParam,hWnd)); +#if defined(__FLAT__) + case WM_NOTIFY : + if(!installedHandlers(VectorHandler::NotifyHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NotifyHandler,CallbackData(wParam,lParam,hWnd)); +#endif + case WM_SIZE : + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SizeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DROPFILES : + if(!installedHandlers(VectorHandler::DropFilesHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DropFilesHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DESTROY : + if(!installedHandlers(VectorHandler::DestroyHandler))postQuitMessage(); + callHandlers(VectorHandler::DestroyHandler,CallbackData(wParam,lParam,hWnd)); + InstanceData::removeInstanceData(hWnd); + setHandle(0); + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return FALSE; + case WM_MDIACTIVATE : + if(!installedHandlers(VectorHandler::MDIActivateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MDIActivateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ACTIVATEAPP : + if(!installedHandlers(VectorHandler::ActivateAppHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ActivateAppHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DISPLAYCHANGE : + if(!installedHandlers(VectorHandler::DisplayChangeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DisplayChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SHOWWINDOW : + if(!installedHandlers(VectorHandler::ShowWindowHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ShowWindowHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MDIDESTROY : + return FALSE; + case WM_NCDESTROY : + default : + return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + } +} + +#if defined(_MSC_VER) +int FAR PASCAL FrameWindow::enumerateProcedure(HWND hWnd,LPARAM lParam) +#else +int FAR PASCAL _export FrameWindow::enumerateProcedure(HWND hWnd,LPARAM lParam) +#endif +{ + if(::GetWindow(hWnd,GW_OWNER))return 1; + switch(LOWORD(lParam)) + { + case MDICloseAll : + if(!::SendMessage(hWnd,WM_QUERYENDSESSION,0,0L))return 1; + ::SendMessage(::GetParent(hWnd),WM_MDIDESTROY,(WPARAM)hWnd,0L); + break; + case MDIRestoreAll : + if(::IsIconic(hWnd)||::IsZoomed(hWnd)) + ::SendMessage(::GetParent(hWnd),WM_MDIRESTORE,(WPARAM)hWnd,0L); + break; + case MDIMinimizeAll : + if(!::IsIconic(hWnd))::ShowWindow(hWnd,SW_SHOWMINNOACTIVE); + break; + } + return 1; +} + +void FrameWindow::watchDocumentWindows(void) +{ + WORD size(mDocuments.size()); + for(int itemIndex=0;itemIndexisValid()) + { + mDocuments.remove(itemIndex); + size=mDocuments.size(); + itemIndex=-1; + } + } +} + +bool FrameWindow::getActive(SmartPointer &mdiWindow) +{ + HWND hMDIChild(0); + + if(!mClientWnd.isValid())return false; + if((HWND)0==(hMDIChild=(HWND)mClientWnd.sendMessage(WM_MDIGETACTIVE,0,0L)))return false; + for(int itemIndex=0;itemIndex &mdiWindow) +{ + HWND hMDIChild; + + if(!mClientWnd.isValid())return false; + if((HWND)0==(hMDIChild=mClientWnd.findWindow(strWindowName)))return false; + for(int itemIndex=0;itemIndex > &mdiWindows) +{ + mdiWindows.size(mDocuments.size()); + if(!mdiWindows.size())return false; + for(int index=0;index &mdiWindow) +{ + Array > mdiWindows; + if(!getDocuments(mdiWindows))return false; + for(int index=0;indexclassName()==strClassName) + { + mdiWindow=mdiWindows[index]; + return true; + } + } + return false; +} + +void FrameWindow::enableMenuItems(UINT menuIndex,UINT itemID,PureMenu::PositionFlags positionFlags,PureMenu::InsertFlags insertFlags) +{ + SmartPointer mdiWindow; + Array > mdiWindows; + PureMenu subMenu; + + if(!getDocuments(mdiWindows))return; + getFrameMenu().getSubMenu(menuIndex,subMenu); + subMenu.enableMenuItem(itemID,positionFlags,insertFlags); + drawMenuBar(); + for(int index=0;indexgetMenu().getSubMenu(menuIndex,subMenu); + subMenu.enableMenuItem(itemID,positionFlags,insertFlags); + mdiWindow->drawMenuBar(); + } +} + +CallbackData::ReturnType FrameWindow::destroyHandler(CallbackData &someCallbackData) +{ + for(int itemIndex=0;itemIndex=mDocuments.size())return FALSE; + mClientWnd.sendMessage(WM_MDIACTIVATE,(WPARAM)(HWND)*mDocuments[childIndex],0L); + mDocuments[childIndex]->show(SW_SHOWNORMAL); + return TRUE; +} + +void FrameWindow::destroy(void) +{ + SmartPointer mdiWindow; + Array > mdiWindows; + + getDocuments(mdiWindows); + for(int index=0;index +#endif +#ifndef _COMMON_PUREMENU_HPP_ +#include +#endif +#ifndef _COMMON_GUIWINDOW_HPP_ +#include +#endif +#ifndef _COMMON_SMARTPOINTER_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif + +class MDIWindow; + +class FrameWindow : public GUIWindow +{ +public: + FrameWindow(void); + virtual ~FrameWindow(); + void createWindow(const String &className,const String &windowName=String(),const String &menuName=String(),const String &iconName=String()); + Window &getClient(void); + bool getActive(SmartPointer &mdiWindow); + bool getDocument(const String &strWindowName,SmartPointer &mdiWindow); + bool getDocuments(Array > &mdiWindows); + bool getDocumentClass(const String &strClassName,SmartPointer &mdiWindow); + void enableMenuItems(UINT menuIndex,UINT itemID,PureMenu::PositionFlags positionFlags,PureMenu::InsertFlags insertFlags); + PureMenu &getFrameMenu(void); + void insert(MDIWindow &mdiWindow); + MDIWindow &operator[](int winIndex); + void destroy(void); + int size(void)const; + void cascade(void)const; + void tile(void)const; + void arrange(void)const; + void closeAll(void)const; + void restoreAll(void)const; + void minimizeAll(void)const; + BOOL activate(UINT childIndex); +protected: + virtual bool preDestroy(MDIWindow &mdiWindow); + virtual void preRegister(WNDCLASS &wndClass); + virtual void mdiDestroy(MDIWindow &mdiWindow); + virtual void mdiDeactivate(MDIWindow &mdiWindow); + virtual void mdiActivate(MDIWindow &mdiWindow); + virtual void moreWindows(void); +private: + enum{IDFirstMDIChild=100}; + enum{MDICloseAll,MDIRestoreAll,MDIMinimizeAll}; + CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData); + CallbackData::ReturnType mdiActivateHandler(CallbackData &someCallackData); + CallbackData::ReturnType commandHandler(CallbackData &someCallbackData); + FrameWindow(const FrameWindow &frameWindow); + FrameWindow &operator=(const FrameWindow &frameWindow); + int windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam); + void registerClass(HINSTANCE hInstance,const String &className,const String &iconName); + void createMDIClientWindow(void); + void watchDocumentWindows(void); +#if defined(_MSC_VER) + __declspec(dllexport) static int FAR PASCAL enumerateProcedure(HWND hWnd,LPARAM lParam); +#else + static int FAR PASCAL _export enumerateProcedure(HWND hWnd,LPARAM lParam); +#endif + + PureMenu mFrameMenu; + Window mClientWnd; + Callback mDestroyHandler; + Callback mMDIActivateHandler; + Callback mCommandHandler; + Block > mDocuments; +}; + +inline +Window &FrameWindow::getClient(void) +{ + return mClientWnd; +} + +inline +PureMenu &FrameWindow::getFrameMenu(void) +{ + return mFrameMenu; +} + +inline +void FrameWindow::cascade(void)const +{ + if(!mClientWnd.isValid())return; + mClientWnd.sendMessage(WM_MDICASCADE,0,0L); +} + +inline +void FrameWindow::tile(void)const +{ + if(!mClientWnd.isValid())return; + mClientWnd.sendMessage(WM_MDITILE,0,0L); +} + +inline +void FrameWindow::arrange(void)const +{ + if(!mClientWnd.isValid())return; + mClientWnd.sendMessage(WM_MDIICONARRANGE,0,0L); +} + +inline +void FrameWindow::closeAll(void)const +{ + ::EnumChildWindows(mClientWnd,(WNDENUMPROC)enumerateProcedure,MAKELONG(MDICloseAll,0)); +} + +inline +void FrameWindow::minimizeAll(void)const +{ + ::EnumChildWindows(mClientWnd,(WNDENUMPROC)enumerateProcedure,MAKELONG(MDIMinimizeAll,0)); + mClientWnd.sendMessage(WM_MDIICONARRANGE,0,0L); +} + +inline +void FrameWindow::restoreAll(void)const +{ + ::EnumChildWindows(mClientWnd,(WNDENUMPROC)enumerateProcedure,MAKELONG(MDIRestoreAll,0)); + mClientWnd.sendMessage(WM_MDICASCADE,0,0L); +} +#endif diff --git a/common/Mdiwin.hpp b/common/Mdiwin.hpp new file mode 100644 index 0000000..3f22038 --- /dev/null +++ b/common/Mdiwin.hpp @@ -0,0 +1,58 @@ +#ifndef _COMMON_MDIWIN_HPP_ +#define _COMMON_MDIWIN_HPP_ +#ifndef _COMMON_GUIWINDOW_HPP_ +#include +#endif +#ifndef _COMMON_SMARTPOINTER_HPP_ +#include +#endif +#ifndef _COMMON_PUREMENU_HPP_ +#include +#endif + +class FrameWindow; +class MDIWindow; + +typedef SmartPointer PMDIWindow; + +class MDIWindow : public GUIWindow +{ +public: + MDIWindow(void); + virtual ~MDIWindow(); + BOOL createWindow(FrameWindow &frameWindow,const String &className,const String &windowName=String(),const String &menuName=String(),const String &iconName=String()); + PureMenu &getMenu(void); + const String &className(void)const; + SmartPointer getFrame(void)const; +protected: + virtual void preRegister(WNDCLASS &wndClass); + virtual void preCreate(MDICREATESTRUCT &createStruct); +private: + int windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam); + void registerClass(HINSTANCE hInstance,const String &className,const String &menuName,const String &iconName); + BOOL createWindow(HINSTANCE hInstance,const String &className,const String &windowName,const String &menuName); + void mdiActivate(CallbackData &someCallbackData); + + SmartPointer mFrameWindow; + PureMenu mViewMenu; + String mClassName; +}; + +inline +PureMenu &MDIWindow::getMenu(void) +{ + return mViewMenu; +} + +inline +const String &MDIWindow::className(void)const +{ + return mClassName; +} + +inline +SmartPointer MDIWindow::getFrame(void)const +{ + return mFrameWindow; +} +#endif diff --git a/common/NOTIFY.HPP b/common/NOTIFY.HPP new file mode 100644 index 0000000..1b1ee89 --- /dev/null +++ b/common/NOTIFY.HPP @@ -0,0 +1,132 @@ +#ifndef _COMMON_NOTIFYMESSAGEHEADER_HPP_ +#define _COMMON_NOTIFYMESSAGEHEADER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_COMMCTRL_HPP_ +#include +#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 + diff --git a/common/ODBUTTON.CPP b/common/ODBUTTON.CPP new file mode 100644 index 0000000..76e6b2e --- /dev/null +++ b/common/ODBUTTON.CPP @@ -0,0 +1,178 @@ +#include +#include +#include +#include +#include +#include + +OwnerDrawButton::OwnerDrawButton(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID,const String &strBmFocusUp,const String &strBmFocusDown,const String &strBmNoFocusUp,const String &strBmDisabled,BOOL hasButtonLines,Font textFont) +: mParentWnd(parentWnd), Control(hControlWnd,controlID), mTextColor(0,0,0), + mBmFocusUp(strBmFocusUp), mBmFocusDown(strBmFocusDown), mBmNoFocusUp(strBmNoFocusUp), + mBmDisabled(strBmDisabled), mhBkGndBrush((HBRUSH)::GetStockObject(NULL_BRUSH)), + mTextFont(textFont), mHasButtonLines(hasButtonLines) +{ + PureDevice pureDevice(parentWnd); + mDIBitmap=new DIBitmap(pureDevice,mBmFocusUp.width(),mBmFocusUp.height(),mBmFocusUp); + mDIBitmap.disposition(PointerDisposition::Delete); + mDrawItemHandler.setCallback(this,&OwnerDrawButton::drawItemHandler); + mControlColorHandler.setCallback(this,&OwnerDrawButton::controlColorHandler); + mParentWnd.insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); +} + +OwnerDrawButton::OwnerDrawButton(GUIWindow &parentWnd,const Point &initPoint,UINT controlID,const String &strBmFocusUp,const String &strBmFocusDown,const String &strBmNoFocusUp,const String &strBmDisabled,BOOL hasButtonLines,const String &strLabel,Font textFont,DWORD style) +: mParentWnd(parentWnd), mBmFocusUp(strBmFocusUp), mTextColor(0,0,0), + mBmFocusDown(strBmFocusDown), mBmNoFocusUp(strBmNoFocusUp), + mBmDisabled(strBmDisabled), mhBkGndBrush((HBRUSH)::GetStockObject(NULL_BRUSH)), + mInitPoint(initPoint), mTextFont(textFont), mHasButtonLines(hasButtonLines) +{ + PureDevice pureDevice(parentWnd); + mDIBitmap=new DIBitmap(pureDevice,mBmFocusUp.width(),mBmFocusUp.height(),mBmFocusUp); + mDIBitmap.disposition(PointerDisposition::Delete); + mDrawItemHandler.setCallback(this,&OwnerDrawButton::drawItemHandler); + mControlColorHandler.setCallback(this,&OwnerDrawButton::controlColorHandler); + mParentWnd.insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + createControl("BUTTON",strLabel,style,Rect(initPoint.x(),initPoint.y(),mBmFocusUp.width(),mBmFocusUp.height()),parentWnd,controlID); + show(SW_SHOW); + update(); +} + +OwnerDrawButton::OwnerDrawButton(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,const String &strBmFocusUp,const String &strBmFocusDown,const String &strBmNoFocusUp,const String &strBmDisabled,BOOL hasButtonLines,const String &strLabel,Font textFont,DWORD style) +: mParentWnd(parentWnd), mBmFocusUp(strBmFocusUp), mTextColor(0,0,0), + mBmFocusDown(strBmFocusDown), mBmNoFocusUp(strBmNoFocusUp), + mBmDisabled(strBmDisabled), mhBkGndBrush((HBRUSH)::GetStockObject(NULL_BRUSH)), + mInitPoint(initRect.left(),initRect.top()), mTextFont(textFont), mHasButtonLines(hasButtonLines) +{ + PureDevice pureDevice(parentWnd); + mDIBitmap=new DIBitmap(pureDevice,initRect.right(),initRect.bottom(),mBmFocusUp); + mDIBitmap.disposition(PointerDisposition::Delete); + mDrawItemHandler.setCallback(this,&OwnerDrawButton::drawItemHandler); + mControlColorHandler.setCallback(this,&OwnerDrawButton::controlColorHandler); + mParentWnd.insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + createControl("BUTTON",strLabel,style,Rect(initRect.left(),initRect.top(),initRect.right(),initRect.bottom()),parentWnd,controlID); + show(SW_SHOW); + update(); +} + +OwnerDrawButton::~OwnerDrawButton() +{ + mParentWnd.removeHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.removeHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + if(mhBkGndBrush)::DeleteObject(mhBkGndBrush); +} + +CallbackData::ReturnType OwnerDrawButton::drawItemHandler(CallbackData &someCallbackData) +{ + DrawItem drawItem(*((LPDRAWITEMSTRUCT)someCallbackData.lParam())); + if(drawItem.controlID()!=controlID())return (CallbackData::ReturnType)TRUE; + return handleDraw(drawItem); +} + +CallbackData::ReturnType OwnerDrawButton::controlColorHandler(CallbackData &someCallbackData) +{ + Control wndButton((HWND)someCallbackData.lParam(),::GetDlgCtrlID((HWND)someCallbackData.lParam()),FALSE); + if(!(*this==wndButton))return (CallbackData::ReturnType)FALSE; + PureDevice pureDevice((HDC)someCallbackData.wParam()); + return handleControlColor(pureDevice,wndButton); +} + +void OwnerDrawButton::drawBitmap(const DrawItem &drawItem,ResBitmap &resBitmap) +{ + if(!resBitmap.isOkay())return; + PureDevice displayDevice(drawItem.deviceContext()); + mDIBitmap->copyBits(resBitmap.ptrData(),resBitmap.imageExtent()); + mDIBitmap->usePalette(displayDevice,TRUE); + mDIBitmap->stretchBlt(displayDevice,Rect(0,0,width(),height())); + mDIBitmap->usePalette(displayDevice,FALSE); +} + +// *************** virtuals + +WORD OwnerDrawButton::handleDraw(const DrawItem &drawItem) +{ + WORD retCode(TRUE); + + switch(drawItem.itemAction()) + { + case ODA_DRAWENTIRE : + drawEntire(drawItem); + break; + case ODA_SELECT : + retCode=drawSelect(drawItem); + break; + case ODA_FOCUS : + drawFocus(drawItem); + break; + } + return retCode; +} + +WORD OwnerDrawButton::handleMeasureItem(MeasureItem &/*measureItem*/) +{ + return TRUE; +} + +LPARAM OwnerDrawButton::handleControlColor(PureDevice &/*pureDevice*/,Control &/*wndButton*/) +{ + return (CallbackData::ReturnType)mhBkGndBrush; +} + +void OwnerDrawButton::drawEntire(const DrawItem &drawItem) +{ + if(drawItem.itemState()&ODS_SELECTED)drawBitmap(drawItem,mBmFocusDown); + else if(drawItem.itemState()&ODS_FOCUS)drawBitmap(drawItem,mBmFocusUp); + else if(drawItem.itemState()&ODS_DISABLED)drawBitmap(drawItem,mBmDisabled); + else drawBitmap(drawItem,mBmNoFocusUp); + drawButtonText(drawItem); + drawButtonLines(drawItem); + return; +} + +WORD OwnerDrawButton::drawSelect(const DrawItem &drawItem) +{ + WORD retCode(TRUE); + if(drawItem.itemState()&ODS_SELECTED)drawBitmap(drawItem,mBmFocusDown); + else {drawBitmap(drawItem,mBmFocusUp);retCode=FALSE;} + drawButtonText(drawItem); + drawButtonLines(drawItem); + return retCode; +} + +void OwnerDrawButton::drawFocus(const DrawItem &drawItem) +{ + if(drawItem.itemState()&ODS_FOCUS)drawBitmap(drawItem,mBmFocusUp); + else drawBitmap(drawItem,mBmNoFocusUp); + drawButtonText(drawItem); + drawButtonLines(drawItem); + return; +} + +void OwnerDrawButton::drawButtonText(const DrawItem &drawItem) +{ + TEXTMETRIC textMetric; + Rect drawRect; + String strText; + PureDevice controlDevice(drawItem.deviceContext()); + + windowText(strText); + if(strText.isNull())return; + controlDevice.setBkMode(PureDevice::Transparent); + controlDevice.select((GDIObj)mTextFont,TRUE); + controlDevice.setTextColor(textColor()); + ::GetTextMetrics(drawItem.deviceContext(),&textMetric); + drawRect=drawItem.rectItem(); + controlDevice.textOut(0,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,strText); + controlDevice.select((GDIObj)mTextFont,FALSE); +} + +void OwnerDrawButton::drawButtonLines(const DrawItem &drawItem) +{ + if(!hasButtonLines())return; + PureDevice controlDevice(drawItem.deviceContext()); + controlDevice.line(Point(0,0),Point(width(),0),RGBColor(255,255,255)); + controlDevice.line(Point(0,0),Point(0,height()),RGBColor(255,255,255)); + controlDevice.line(Point(0,height()-1),Point(width(),height()-1),RGBColor(0,0,0)); + controlDevice.line(Point(width(),height()-1),Point(width()-1,0),RGBColor(0,0,0)); +} diff --git a/common/ODBUTTON.HPP b/common/ODBUTTON.HPP new file mode 100644 index 0000000..bd48747 --- /dev/null +++ b/common/ODBUTTON.HPP @@ -0,0 +1,99 @@ +#ifndef _COMMON_OWNERDRAWBUTTON_HPP_ +#define _COMMON_OWNERDRAWBUTTON_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_CONTROL_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_RESBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_SMARTPOINTER_HPP_ +#include +#endif +#ifndef _COMMON_FONT_HPP_ +#include +#endif + +class DrawItem; +class MeasureItem; +class PureDevice; +class DIBitmap; + +class OwnerDrawButton : public Control +{ +public: + OwnerDrawButton(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID,const String &strBmFocusUp,const String &strBmFocusDown,const String &strBmNoFocusUp,const String &strBmDisabled,BOOL hasButtonLines=TRUE,Font textFont=Font("MS Sans Serif",8,Font::FamilySwiss|Font::PitchVariable,Font::WeightBold)); + OwnerDrawButton(GUIWindow &parentWnd,const Point &initPoint,UINT controlID,const String &strBmFocusUp,const String &strBmFocusDown,const String &strBmNoFocusUp,const String &strBmDisabled,BOOL hasButtonLines=TRUE,const String &strLabel=String(),Font textFont=Font("MS Sans Serif",8,Font::FamilySwiss|Font::PitchVariable,Font::WeightBold),DWORD style=BS_OWNERDRAW|WS_CLIPCHILDREN|WS_CLIPSIBLINGS); + OwnerDrawButton(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,const String &strBmFocusUp,const String &strBmFocusDown,const String &strBmNoFocusUp,const String &strBmDisabled,BOOL hasButtonLines=TRUE,const String &strLabel=String(),Font textFont=Font("MS Sans Serif",8,Font::FamilySwiss|Font::PitchVariable,Font::WeightBold),DWORD style=BS_OWNERDRAW|WS_CLIPCHILDREN|WS_CLIPSIBLINGS); + virtual ~OwnerDrawButton(); + OwnerDrawButton &operator=(const OwnerDrawButton &someOwnerDrawButton); + const Point &initPoint(void)const; + BOOL hasButtonLines(void)const; + void hasButtonLines(BOOL hasButtonLines); + void textColor(const RGBColor &rgbColor); + RGBColor textColor(void)const; +protected: + virtual WORD handleDraw(const DrawItem &drawItem); + virtual WORD handleMeasureItem(MeasureItem &measureItem); + virtual LPARAM handleControlColor(PureDevice &pureDevice,Control &wndButton); + virtual void drawEntire(const DrawItem &drawItem); + virtual WORD drawSelect(const DrawItem &drawItem); + virtual void drawFocus(const DrawItem &drawItem); + virtual void drawButtonText(const DrawItem &drawItem); + virtual void drawButtonLines(const DrawItem &drawItem); +private: + void drawBitmap(const DrawItem &drawItem,ResBitmap &resBitmap); + CallbackData::ReturnType drawItemHandler(CallbackData &someCallbackData); + CallbackData::ReturnType controlColorHandler(CallbackData &someCallbackData); + + Callback mDrawItemHandler; + Callback mMeasureItemHandler; + Callback mControlColorHandler; + SmartPointer mDIBitmap; + ResBitmap mBmFocusDown; + ResBitmap mBmNoFocusUp; + ResBitmap mBmDisabled; + ResBitmap mBmFocusUp; + GUIWindow &mParentWnd; + Point mInitPoint; + HBRUSH mhBkGndBrush; + RGBColor mTextColor; + BOOL mHasButtonLines; + Font mTextFont; +}; + +inline +const Point &OwnerDrawButton::initPoint(void)const +{ + return mInitPoint; +} + +inline +void OwnerDrawButton::textColor(const RGBColor &rgbColor) +{ + mTextColor=rgbColor; +} + +inline +RGBColor OwnerDrawButton::textColor(void)const +{ + return mTextColor; +} + +inline +BOOL OwnerDrawButton::hasButtonLines(void)const +{ + return mHasButtonLines; +} + +inline +void OwnerDrawButton::hasButtonLines(BOOL hasButtonLines) +{ + mHasButtonLines=hasButtonLines; +} +#endif diff --git a/common/ODLSTALT.CPP b/common/ODLSTALT.CPP new file mode 100644 index 0000000..5af39e5 --- /dev/null +++ b/common/ODLSTALT.CPP @@ -0,0 +1,85 @@ +#include +#include +#include +#include +#include + +OwnerDrawListAltColor::OwnerDrawListAltColor(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID,const RGBColor &primColor,const RGBColor &altColor,const RGBColor &bkGndSelColor) +: OwnerDrawList(parentWnd,hControlWnd,controlID), myIndent(0), mPrimColor(primColor), mAltColor(altColor), + mBkGndSelColor(bkGndSelColor), mBkGndSelBrush(mBkGndSelColor), mPrimBrush(mPrimColor), mAltBrush(mAltColor) +{ +} + +OwnerDrawListAltColor::OwnerDrawListAltColor(GUIWindow &parentWnd,const Rect &initRect,int controlID,const RGBColor &primColor,const RGBColor &altColor,const RGBColor &bkGndSelColor) +: OwnerDrawList(parentWnd,initRect,controlID), mPrimColor(primColor), mAltColor(altColor), mBkGndSelColor(bkGndSelColor), mBkGndSelBrush(mBkGndSelColor), + mPrimBrush(mPrimColor), mAltBrush(mAltColor) +{ + yIndent(parentWnd.width()-initRect.right()); +} + +OwnerDrawListAltColor::~OwnerDrawListAltColor() +{ +} + +OwnerDrawListAltColor &OwnerDrawListAltColor::operator=(const OwnerDrawListAltColor &someOwnerDrawListAltColor) +{ // private implementation + return *this; +} + +// virtual overloads + +void OwnerDrawListAltColor::handleResize(WORD /*width*/,WORD /*height*/) +{ +} + +WORD OwnerDrawListAltColor::handleDraw(const DrawItem &drawItem) +{ + switch(drawItem.itemAction()) + { + case DrawItem::Select : + case DrawItem::DrawEntire : + case DrawItem::Focus : + drawEntire(drawItem); + break; + } + return TRUE; +} + +WORD OwnerDrawListAltColor::handleMeasureItem(MeasureItem &measureItem) +{ + return TRUE; +} + +LPARAM OwnerDrawListAltColor::handleControlColor(PureDevice &pureDevice,Control &wndListBox) +{ + return FALSE; +} + +void OwnerDrawListAltColor::drawEntire(const DrawItem &drawItem) +{ + String stringData; + + if(!isOkay())return; + sendMessage(drawItem.hwndItem(),LB_GETTEXT,drawItem.itemID(),(LPARAM)(LPSTR)stringData); + PureDevice controlDevice(drawItem.deviceContext()); + if((((UINT)drawItem.itemState())&ODS_SELECTED)) + { + controlDevice.setBkColor(mBkGndSelColor); + controlDevice.fillRect(drawItem.rectItem(),mBkGndSelBrush); + } + else + { + if(drawItem.itemID()%2) + { + controlDevice.setBkColor(mAltColor); + controlDevice.fillRect(drawItem.rectItem(),mAltBrush); + } + else + { + controlDevice.setBkColor(mPrimColor); + controlDevice.fillRect(drawItem.rectItem(),mPrimBrush); + } + } + textOut(drawItem,stringData); + return; +} diff --git a/common/ODLSTALT.HPP b/common/ODLSTALT.HPP new file mode 100644 index 0000000..006d996 --- /dev/null +++ b/common/ODLSTALT.HPP @@ -0,0 +1,89 @@ +#ifndef _COMMON_OWNERDRAWLISTALTCOLOR_HPP_ +#define _COMMON_OWNERDRAWLISTALTCOLOR_HPP_ +#ifndef _COMMON_OWNERDRAWLIST_HPP_ +#include +#endif +#ifndef _COMMON_BRUSH_HPP_ +#include +#endif + +class OwnerDrawListAltColor : public OwnerDrawList +{ +public: + OwnerDrawListAltColor(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID,const RGBColor &primColor=RGBColor(255,255,255),const RGBColor &altColor=RGBColor(192,220,192),const RGBColor &bkGndSelColor=RGBColor(128,192,255)); + OwnerDrawListAltColor(GUIWindow &parentWnd,const Rect &initRect,int controlID,const RGBColor &primColor=RGBColor(255,255,255),const RGBColor &altColor=RGBColor(192,220,192),const RGBColor &bkGndSelColor=RGBColor(128,192,255)); + virtual ~OwnerDrawListAltColor(); + const RGBColor &bkGndSelColor(void)const; + void bkGndSelColor(const RGBColor &bkGndSelColor); + const RGBColor &primColor(void)const; + void primColor(const RGBColor &selColor); + const RGBColor &altColor(void)const; + void altColor(const RGBColor &altColor); +protected: + virtual WORD handleDraw(const DrawItem &drawItem); + virtual WORD handleMeasureItem(MeasureItem &measureItem); + virtual LPARAM handleControlColor(PureDevice &pureDevice,Control &wndListBox); + virtual void drawEntire(const DrawItem &drawItem); + virtual void handleResize(WORD width,WORD height); +private: + OwnerDrawListAltColor &operator=(const OwnerDrawListAltColor &someOwnerDrawListAltColor); + WORD yIndent(void)const; + void yIndent(WORD yIndent); + + RGBColor mBkGndSelColor; + RGBColor mPrimColor; + RGBColor mAltColor; + Brush mBkGndSelBrush; + Brush mPrimBrush; + Brush mAltBrush; + WORD myIndent; +}; + +inline +WORD OwnerDrawListAltColor::yIndent(void)const +{ + return myIndent; +} + +inline +void OwnerDrawListAltColor::yIndent(WORD yIndent) +{ + myIndent=yIndent; +} + +inline +const RGBColor &OwnerDrawListAltColor::bkGndSelColor(void)const +{ + return mBkGndSelColor; +} + +inline +void OwnerDrawListAltColor::bkGndSelColor(const RGBColor &bkGndSelColor) +{ + mBkGndSelColor=bkGndSelColor; +} + +inline +const RGBColor &OwnerDrawListAltColor::primColor(void)const +{ + return mPrimColor; +} + +inline +void OwnerDrawListAltColor::primColor(const RGBColor &primColor) +{ + mPrimColor=primColor; +} + +inline +const RGBColor &OwnerDrawListAltColor::altColor(void)const +{ + return mAltColor; +} + +inline +void OwnerDrawListAltColor::altColor(const RGBColor &altColor) +{ + mAltColor=altColor; +} +#endif diff --git a/common/ODLSTCHK.CPP b/common/ODLSTCHK.CPP new file mode 100644 index 0000000..fc5261c --- /dev/null +++ b/common/ODLSTCHK.CPP @@ -0,0 +1,106 @@ +#include +#include +#include +#include + +OwnerDrawListCheck::OwnerDrawListCheck(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID,const PureBitmap &selected,const PureBitmap &unselected) +: OwnerDrawList(parentWnd,hControlWnd,controlID), mRGBGray(192,192,192), mGrayBrush(mRGBGray), + mDisabledBrush(RGBColor(128,128,128)) +{ + mPureBitmaps.insert(&selected); + mPureBitmaps.insert(&unselected); +} + +OwnerDrawListCheck::OwnerDrawListCheck(GUIWindow &parentWnd,const Rect &initRect,int controlID,const PureBitmap &selected,const PureBitmap &unselected,DWORD style) +: OwnerDrawList(parentWnd,initRect,controlID,style), mRGBGray(192,192,192), mGrayBrush(mRGBGray), + mDisabledBrush(RGBColor(128,128,128)) +{ + mPureBitmaps.insert(&selected); + mPureBitmaps.insert(&unselected); +} + +OwnerDrawListCheck::~OwnerDrawListCheck() +{ +} + +OwnerDrawListCheck &OwnerDrawListCheck::operator=(const OwnerDrawListCheck &/*someOwnerDrawListCheck*/) +{ // private implementation + return *this; +} + +// **** virtuals + +LPARAM OwnerDrawListCheck::handleControlColor(PureDevice &/*pureDevice*/,Control &/*wndListBox*/) +{ + return (LPARAM)(GDIObj)mGrayBrush; +} + +WORD OwnerDrawListCheck::handleDraw(const DrawItem &drawItem) +{ + if(!isOkay()||-1==drawItem.itemID()||DrawItem::ListBox!=drawItem.controlType())return FALSE; + PureDevice pureDevice(drawItem.deviceContext()); + pureDevice.setBkColor(mRGBGray); + switch(drawItem.itemAction()) + { + case DrawItem::Select : + case DrawItem::DrawEntire : + case DrawItem::Focus : + drawEntire(drawItem); + break; + } + return TRUE; +} + +WORD OwnerDrawListCheck::handleMeasureItem(MeasureItem &measureItem) +{ + measureItem.itemHeight(20); + return TRUE; +} + +void OwnerDrawListCheck::drawEntire(const DrawItem &drawItem) +{ + PureDevice pureDevice(drawItem.deviceContext()); + PureDevice memDevice; + String stringData; + TEXTMETRIC textMetric; + Rect drawRect; + SIZE sizeExtent; + + if(!isOkay())return; + stringData.reserve(256); + drawRect=drawItem.rectItem(); + memDevice.compatibleDevice(pureDevice); + PureBitmap &pureBitmap=(((UINT)drawItem.itemState())&ODS_SELECTED?mPureBitmaps[BmSel]:mPureBitmaps[BmUnSel]); + sendMessage(drawItem.hwndItem(),LB_GETTEXT,drawItem.itemID(),(LPARAM)(LPSTR)stringData); + if(stringData.isNull())::MessageBeep(0); + ::GetTextMetrics(drawItem.deviceContext(),&textMetric); + ::GetTextExtentPoint32(drawItem.deviceContext(),(LPSTR)stringData,stringData.length(),&sizeExtent); + if(drawItem.itemState()&ODS_DISABLED) + { + ::GrayString(drawItem.deviceContext(),(HBRUSH)(GDIObj)mDisabledBrush,(GRAYSTRINGPROC)0,(LPARAM)(LPSTR)stringData,stringData.length(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,0,0); + memDevice.select(pureBitmap,TRUE); + Rect stretchRect(drawRect); + stretchRect.right(pureBitmap.width()); + stretchRect.bottom(sizeExtent.cy); + pureDevice.stretchBlt(stretchRect,memDevice,Rect(0,0,pureBitmap.width(),pureBitmap.height()),PureDevice::MergeCopy); + memDevice.select(pureBitmap,FALSE); + } + else + { + ::TextOut(drawItem.deviceContext(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,(LPSTR)stringData,stringData.length()); + memDevice.select(pureBitmap,TRUE); + Rect stretchRect(drawRect); + stretchRect.right(pureBitmap.width()); + stretchRect.bottom(sizeExtent.cy); + pureDevice.stretchBlt(stretchRect,memDevice,Rect(0,0,pureBitmap.width(),pureBitmap.height()),PureDevice::MergeCopy); + memDevice.select(pureBitmap,FALSE); + } + if((((UINT)drawItem.itemState())&ODS_FOCUS)) + { + Rect bmpRect(drawRect); + bmpRect.right(bmpRect.left()+pureBitmap.width()); + bmpRect.bottom(bmpRect.top()+sizeExtent.cy); + ::DrawFocusRect(drawItem.deviceContext(),(RECT*)&bmpRect); + } +} + diff --git a/common/OLE2.HPP b/common/OLE2.HPP new file mode 100644 index 0000000..424ef1b --- /dev/null +++ b/common/OLE2.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_OLE2_HPP_ +#define _COMMON_OLE2_HPP_ +#include +#endif diff --git a/common/OPENDLG.CPP b/common/OPENDLG.CPP new file mode 100644 index 0000000..a9f47d4 --- /dev/null +++ b/common/OPENDLG.CPP @@ -0,0 +1,458 @@ +#include +#include +#include + +OpenDialog::OpenDialog(void) +{ + setZero(); + setLength(); +} + +OpenDialog::OpenDialog(const OpenDialog &someOpenDialog) +{ + setLength(); + *this=someOpenDialog; +} + +OpenDialog::~OpenDialog() +{ +} + +OpenDialog &OpenDialog::operator=(const OpenDialog &someOpenDialog) +{ + owner(someOpenDialog.owner()); + instance(someOpenDialog.instance()); + filter(someOpenDialog.filter()); + filterPattern(someOpenDialog.filterPattern()); + customFilter(someOpenDialog.customFilter()); + filterIndex(someOpenDialog.filterIndex()); + fileName(someOpenDialog.fileName()); + fileTitle(someOpenDialog.fileTitle()); + initialDirectory(someOpenDialog.initialDirectory()); + title(someOpenDialog.title()); + creationFlags(someOpenDialog.creationFlags()); + defaultExtension(someOpenDialog.defaultExtension()); + return *this; +} + +BOOL OpenDialog::operator==(const OpenDialog &someOpenDialog)const +{ + return (owner()==someOpenDialog.owner()&& + instance()==someOpenDialog.instance()&& + filter()==someOpenDialog.filter()&& + filterPattern()==someOpenDialog.filterPattern()&& + customFilter()==someOpenDialog.customFilter()&& + filterIndex()==someOpenDialog.filterIndex()&& + fileName()==someOpenDialog.fileName()&& + fileTitle()==someOpenDialog.fileTitle()&& + initialDirectory()==someOpenDialog.initialDirectory()&& + title()==someOpenDialog.title()&& + creationFlags()==someOpenDialog.creationFlags()&& + defaultExtension()==someOpenDialog.defaultExtension()); +} + +HWND OpenDialog::owner(void)const +{ + return OPENFILENAME::hwndOwner; +} + +void OpenDialog::owner(HWND hwndOwner) +{ + OPENFILENAME::hwndOwner=hwndOwner; +} + +HINSTANCE OpenDialog::instance(void)const +{ + return OPENFILENAME::hInstance; +} + +void OpenDialog::instance(HINSTANCE hInstance) +{ + OPENFILENAME::hInstance=hInstance; +} + +const String &OpenDialog::filter(void)const +{ + return mFilter; +} + +void OpenDialog::filter(const String &filter) +{ + mFilter=filter; +} + +const String &OpenDialog::filterPattern(void)const +{ + return mFilterPattern; +} + +void OpenDialog::filterPattern(const String &filterPattern) +{ + mFilterPattern=filterPattern; +} + +const String &OpenDialog::customFilter(void)const +{ + return mCustomFilter; +} + +void OpenDialog::customFilter(const String &customFilter) +{ + mCustomFilter=customFilter; +} + +DWORD OpenDialog::filterIndex(void)const +{ + return OPENFILENAME::nFilterIndex; +} + +void OpenDialog::filterIndex(DWORD filterIndex) +{ + OPENFILENAME::nFilterIndex=filterIndex; +} + +const String &OpenDialog::fileName(void)const +{ + return mFileName; +} + +void OpenDialog::fileName(const String &fileName) +{ + mFileName=fileName; +} + +const String &OpenDialog::fileTitle(void)const +{ + return mFileTitle; +} + +void OpenDialog::fileTitle(const String &fileTitle) +{ + mFileTitle=fileTitle; +} + +const String &OpenDialog::initialDirectory(void)const +{ + return mInitialDirectory; +} + +void OpenDialog::initialDirectory(const String &initialDirectory) +{ + mInitialDirectory=initialDirectory; +} + +const String &OpenDialog::title(void)const +{ + return mTitle; +} + +void OpenDialog::title(const String &title) +{ + mTitle=title; +} + +DWORD OpenDialog::creationFlags(void)const +{ + return OPENFILENAME::Flags; +} + +void OpenDialog::creationFlags(DWORD creationFlags) +{ + OPENFILENAME::Flags=creationFlags; +} + +const String &OpenDialog::defaultExtension(void)const +{ + return mDefaultExtension; +} + +void OpenDialog::defaultExtension(const String &defaultExtension) +{ + mDefaultExtension=defaultExtension; +} + +const String &OpenDialog::templateName(void)const +{ + return mTemplateName; +} + +void OpenDialog::templateName(const String &templateName) +{ + if(templateName.isNull())return; + mTemplateName=templateName; + OPENFILENAME::lpTemplateName=(char*)mTemplateName; +} + +LPOFNHOOKPROC OpenDialog::hookProc(void)const +{ + return OPENFILENAME::lpfnHook; +} + +void OpenDialog::hookProc(LPOFNHOOKPROC pHookProc) +{ + OPENFILENAME::lpfnHook=pHookProc; +} + +DWORD OpenDialog::customData(void)const +{ + return OPENFILENAME::lCustData; +} + +void OpenDialog::customData(DWORD customData) +{ + OPENFILENAME::lCustData=customData; +} + +void OpenDialog::setZero(void) +{ + ::memset(&((OPENFILENAME&)*this),0,sizeof(OPENFILENAME)); +} + +void OpenDialog::setLength(void) +{ + OPENFILENAME::lStructSize=sizeof(OPENFILENAME); +} + +BOOL OpenDialog::getSaveFileName(GUIWindow &parentWindow,const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName) +{ + owner(parentWindow); + return getSaveFileName(filterPatternString,titleString,fileTitleString,pathFileName); +} + +BOOL OpenDialog::getOpenFileName(GUIWindow &parentWindow,const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName) +{ + owner(parentWindow); + return getOpenFileName(filterPatternString,titleString,fileTitleString,pathFileName); +} + +BOOL OpenDialog::getSaveFileName(const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName) +{ + String filterString; + + if(filterPatternString.isNull()||titleString.isNull())return FALSE; + filter(filterPatternString); + if(filterString.isNull()){filterString=fileTitleString.betweenString('.',0);filterString.insert("*.");} + filterPattern(filterString); + instance((HINSTANCE)0); + hookProc(0); + customData(0); + if(fileTitleString.isNull())fileName(filterPatternString); + else fileName(fileTitleString); + title(titleString); + fileTitle(titleString); + creationFlags(OpenDialog::EXPLORER|OpenDialog::OVERWRITEPROMPT|OpenDialog::PATHMUSTEXIST); + if(!getSaveFileName())return FALSE; + pathFileName=fileName(); + return TRUE; +} + +BOOL OpenDialog::getOpenFileName(const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName) +{ + String filterString; + + if(filterPatternString.isNull()||titleString.isNull())return FALSE; + filterString=filterPatternString.betweenString('.',0); + instance((HINSTANCE)0); + hookProc(0); + customData(0); + filter(filterString); + filterPattern(filterPatternString); + if(fileTitleString.isNull())fileName(filterPatternString); + else fileName(fileTitleString); + title(titleString); + fileTitle(titleString); + creationFlags(creationFlags()|OpenDialog::EXPLORER|OpenDialog::PATHMUSTEXIST|OpenDialog::FILEMUSTEXIST); + if(!getOpenFileName())return FALSE; + pathFileName=fileName(); + return TRUE; +} + +BOOL OpenDialog::getOpenFileName(const String &filterPatternString,const String &titleString,const String &fileTitleString,Block &strFileNames) +{ + String filterString; + String strPath; + String strPathFileName; + char *ptrString; + + strFileNames.remove(); + if(filterPatternString.isNull()||titleString.isNull())return FALSE; + filterString=filterPatternString.betweenString('.',0); + instance((HINSTANCE)0); + hookProc(0); + customData(0); + filter(filterString); + filterPattern(filterPatternString); + if(fileTitleString.isNull())fileName(filterPatternString); + else fileName(fileTitleString); + title(titleString); + fileTitle(titleString); + creationFlags(OpenDialog::ALLOWMULTISELECT|OpenDialog::EXPLORER|OpenDialog::PATHMUSTEXIST); + mFileNameBuffer.reserve(MaxMultiSelect); + if(!getOpenFileName())return FALSE; + ptrString=mFileNameBuffer; + if(!ptrString)return FALSE; + strPath=ptrString; + if(strPath.strstr(".")){strFileNames.insert(&strPath);return TRUE;} + while(TRUE) + { + while(*ptrString)ptrString++; + if(!*(++ptrString))break; + strPathFileName=strPath+String("\\"); + strPathFileName+=ptrString; + strFileNames.insert(&strPathFileName); + } + return (strFileNames.size()?TRUE:FALSE); +} + +BOOL OpenDialog::getOpenFileName(void) +{ + String filterPattern; + WORD returnCode; + + mFileNameBuffer.reserve(MaxLength); + mFileTitleBuffer.reserve(MaxTitle); + if(mFilter.isNull()||mFilterPattern.isNull())OPENFILENAME::lpstrFilter=0; + else + { + long lengthFilter(mFilter.length()); + long lengthPattern(mFilterPattern.length()); + filterPattern.reserve(lengthFilter+lengthPattern+3); + ::memcpy((LPSTR)filterPattern,(LPSTR)mFilter,lengthFilter); + ((LPSTR)filterPattern)[lengthFilter]=0; + ::memcpy(((LPSTR)filterPattern)+lengthFilter+1,(LPSTR)mFilterPattern,lengthPattern); + ((LPSTR)filterPattern)[lengthFilter+lengthPattern+1]=0; + ((LPSTR)filterPattern)[lengthFilter+lengthPattern+2]=0; + OPENFILENAME::lpstrFilter=(LPSTR)filterPattern; + } + OPENFILENAME::lpstrCustomFilter=0; + OPENFILENAME::nMaxCustFilter=0; + if(OPENFILENAME::lpstrFilter)OPENFILENAME::nFilterIndex=1; + else OPENFILENAME::nFilterIndex=0; + ::memcpy((LPSTR)mFileNameBuffer,(LPSTR)mFileName,mFileName.length()); + OPENFILENAME::lpstrFile=(LPSTR)mFileNameBuffer; + OPENFILENAME::nMaxFile=mFileNameBuffer.lengthBytes(); + ::memcpy((LPSTR)mFileTitleBuffer,(LPSTR)mFileTitle,mFileTitle.length()); + OPENFILENAME::lpstrFileTitle=(LPSTR)mFileTitleBuffer; + OPENFILENAME::nMaxFileTitle=mFileTitleBuffer.lengthBytes(); + if(mInitialDirectory.isNull())OPENFILENAME::lpstrInitialDir=0; + else OPENFILENAME::lpstrInitialDir=(LPSTR)mInitialDirectory; + if(mTitle.isNull())OPENFILENAME::lpstrTitle=0; + else OPENFILENAME::lpstrTitle=(LPSTR)mTitle; + OPENFILENAME::Flags=creationFlags(); + if(!mFileNameBuffer.isNull()) + { + int stringPos(mFileNameBuffer.strpos(".")); + OPENFILENAME::nFileExtension=stringPos-1; + char *lpStr=(LPSTR)mFileNameBuffer; + while(lpStr[stringPos]!='\\'&&lpStr[stringPos]!='/'&&lpStr[stringPos]!=':'&&stringPos>=0)stringPos--; + OPENFILENAME::nFileOffset=stringPos+1; + } + if(!mDefaultExtension.isNull())OPENFILENAME::lpstrDefExt=(LPSTR)mDefaultExtension; + else OPENFILENAME::lpstrDefExt=0; + returnCode=::GetOpenFileName(&((OPENFILENAME&)*this)); + if(returnCode) + { + parseFileNames(mFileNameBuffer,mFileNames); + if(mFileNames.size())mFileName=mFileNames[0]; + mFileTitle=mFileTitleBuffer; + } + return returnCode; +} + +BOOL OpenDialog::getSaveFileName(void) +{ + String filterPattern; + String fileName; + String fileTitle; + WORD returnCode; + + fileName.reserve(MaxSaveLength); + fileTitle.reserve(MaxTitle); + if(mFilter.isNull()||mFilterPattern.isNull())OPENFILENAME::lpstrFilter=0; + else + { + long lengthFilter(mFilter.length()); + long lengthPattern(mFilterPattern.length()); + filterPattern.reserve(lengthFilter+lengthPattern+3); + ::memcpy((LPSTR)filterPattern,(LPSTR)mFilter,lengthFilter); + ((LPSTR)filterPattern)[lengthFilter]=0; + ::memcpy(((LPSTR)filterPattern)+lengthFilter+1,(LPSTR)mFilterPattern,lengthPattern); + ((LPSTR)filterPattern)[lengthFilter+lengthPattern+1]=0; + ((LPSTR)filterPattern)[lengthFilter+lengthPattern+2]=0; + OPENFILENAME::lpstrFilter=(LPSTR)filterPattern; + } + OPENFILENAME::lpstrCustomFilter=0; + OPENFILENAME::nMaxCustFilter=0; + if(OPENFILENAME::lpstrFilter)OPENFILENAME::nFilterIndex=1; + else OPENFILENAME::nFilterIndex=0; + ::memcpy((LPSTR)fileName,(LPSTR)mFileName,mFileName.length()); + OPENFILENAME::lpstrFile=(LPSTR)fileName; + OPENFILENAME::nMaxFile=MaxSaveLength; + ::memcpy((LPSTR)fileTitle,(LPSTR)mFileTitle,mFileTitle.length()); + OPENFILENAME::lpstrFileTitle=(LPSTR)fileTitle; + OPENFILENAME::nMaxFileTitle=MaxTitle; + if(mInitialDirectory.isNull())OPENFILENAME::lpstrInitialDir=0; + else OPENFILENAME::lpstrInitialDir=(LPSTR)mInitialDirectory; + if(mTitle.isNull())OPENFILENAME::lpstrTitle=0; + else OPENFILENAME::lpstrTitle=(LPSTR)mTitle; + OPENFILENAME::Flags=creationFlags(); + if(!fileName.isNull()) + { + int stringPos(fileName.strpos(".")); + OPENFILENAME::nFileExtension=stringPos-1; + char *lpStr=(LPSTR)fileName; + while(lpStr[stringPos]!='\\'&&lpStr[stringPos]!='/'&&lpStr[stringPos]!=':'&&stringPos>=0)stringPos--; + OPENFILENAME::nFileOffset=stringPos+1; + } + if(!mDefaultExtension.isNull())OPENFILENAME::lpstrDefExt=(LPSTR)mDefaultExtension; + else OPENFILENAME::lpstrDefExt=0; + OPENFILENAME::lpfnHook=0; + returnCode=::GetSaveFileName(&((OPENFILENAME&)*this)); + if(returnCode) + { + mFileName=fileName; + mFileTitle=fileTitle; + } + return returnCode; +} + +void OpenDialog::parseFileNames(const String &nameBuffer,Block &fileNames) +{ + String directoryName; + String item; + int index; + bool isFirst; + + index=0; + isFirst=true; + fileNames.remove(); + if(!(creationFlags()&ALLOWMULTISELECT)) + { + fileNames.insert(&nameBuffer); + return; + } + while(true) + { + item=parseLine(index,nameBuffer); + if(item.isNull())break; + if(isFirst) + { + isFirst=false; + directoryName=item; + } + else fileNames.insert(&String(directoryName+"\\"+item)); + } + if(!fileNames.size())fileNames.insert(&directoryName); +} + +String OpenDialog::parseLine(int &index,const String &strLine) +{ + StringBuffer sb; + while(strLine[index]!=0) + { + sb.append(strLine[index]); + index++; + } + index++; + return sb.toString(); +} diff --git a/common/OPENFILE.CPP b/common/OPENFILE.CPP new file mode 100644 index 0000000..911965c --- /dev/null +++ b/common/OPENFILE.CPP @@ -0,0 +1,129 @@ +#include + +FileHandle::~FileHandle() +{ + close(); +} + +SystemTime FileHandle::creationTime(void)const +{ + FileTime creationTimeDate; + ::GetFileTime(mhFileHandle,&((FILETIME&)creationTimeDate),0,0); + return creationTimeDate; +} + +SystemTime FileHandle::lastAccessTime(void)const +{ + FileTime lastAccessTimeDate; + ::GetFileTime(mhFileHandle,0,&((FILETIME&)lastAccessTimeDate),0); + return lastAccessTimeDate; +} + +SystemTime FileHandle::lastModifyTime(void)const +{ + FileTime lastModifyTimeDate; + ::GetFileTime(mhFileHandle,0,0,&((FILETIME&)lastModifyTimeDate)); + return lastModifyTimeDate; +} + +DWORD FileHandle::getLine(String &lineString)const +{ + int granularity(1024); + int blockLength(granularity); + BYTE charByte; + BYTE *ptrLine; + WORD bytesRead(0); + + lineString.reserve(blockLength); + ptrLine=(BYTE*)(char*)lineString; + while(TRUE) + { + if(!read(charByte))break; + if(bytesRead>=blockLength-1) + { + *ptrLine=0; + String tmpString(lineString); + int nextIndex(ptrLine-(BYTE*)(char*)lineString); + lineString.reserve(blockLength+granularity); + ::memcpy((char*)lineString,(char*)tmpString,blockLength); + blockLength+=granularity; + ptrLine=(BYTE*)(char*)lineString+nextIndex; + } + if(CarriageReturn==charByte) + { + if(!read(charByte))break; + if(LineFeed==charByte) + { + *ptrLine=0; + return TRUE; + } + } + else if(LineFeed==charByte) + { + *ptrLine=0; + return TRUE; + } + else if(NullChar==charByte) + { + *ptrLine++=0; + return bytesRead; + } + else if(TabChar==charByte)continue; + else + { + *ptrLine++=charByte; + bytesRead++; + } + } + return bytesRead; +} + +/* +DWORD FileHandle::getLine(String &lineString)const +{ + int granularity(1024); + int blockLength(granularity); + BYTE charByte; + BYTE *ptrLine; + WORD bytesRead(0); + + lineString.reserve(blockLength); + ptrLine=(BYTE*)(char*)lineString; + while(TRUE) + { + if(!read(charByte))break; + if(bytesRead>=blockLength-1) + { + *ptrLine=0; + String tmpString(lineString); + int nextIndex(ptrLine-(BYTE*)(char*)lineString); + lineString.reserve(blockLength+granularity); + ::memcpy((char*)lineString,(char*)tmpString,blockLength); + blockLength+=granularity; + ptrLine=(BYTE*)(char*)lineString+nextIndex; + } + if(CarriageReturn==charByte) + { + if(!read(charByte))break; + bytesRead++; + if(LineFeed==charByte) + { + bytesRead++; + *ptrLine=0; + return bytesRead; + } + } + else if(NullChar==charByte) + { + *ptrLine++=0; + return bytesRead; + } + else + { + *ptrLine++=charByte; + bytesRead++; + } + } + return bytesRead; +} +*/ diff --git a/common/OPNDLGEX.CPP b/common/OPNDLGEX.CPP new file mode 100644 index 0000000..aef3390 --- /dev/null +++ b/common/OPNDLGEX.CPP @@ -0,0 +1,219 @@ +#include +#include +#include + +CustomOpenDialog::CustomOpenDialog(void) +{ + mInitHandler.setCallback(this,&CustomOpenDialog::initHandler); + mCommandHandler.setCallback(this,&CustomOpenDialog::commandHandler); + mNotifyHandler.setCallback(this,&CustomOpenDialog::notifyHandler); + insertHandler(VectorHandler::InitDialogHandler,&mInitHandler); + insertHandler(VectorHandler::CommandHandler,&mCommandHandler); + insertHandler(VectorHandler::NotifyHandler,&mNotifyHandler); +} + +CustomOpenDialog::CustomOpenDialog(const CustomOpenDialog &someCustomOpenDialog) +{ // private implementation + *this=someCustomOpenDialog; +} + +CustomOpenDialog::~CustomOpenDialog() +{ + removeHandler(VectorHandler::InitDialogHandler,&mInitHandler); + removeHandler(VectorHandler::CommandHandler,&mCommandHandler); + removeHandler(VectorHandler::NotifyHandler,&mNotifyHandler); +} + +CustomOpenDialog &CustomOpenDialog::operator=(const CustomOpenDialog &someCustomOpenDialog) +{ // private implementation + return *this; +} + +const String &CustomOpenDialog::openFileName(void) +{ + return mOpenFileNameString; +} + +void CustomOpenDialog::setFilterPattern(const String &strFilterPattern) +{ + mFilterPatternString=strFilterPattern; +} + +void CustomOpenDialog::setTitle(const String &strTitle) +{ + mTitleString=strTitle; +} + +void CustomOpenDialog::setFileTitle(const String &strFileTitle) +{ + mFileTitleString=strFileTitle; +} + +BOOL CustomOpenDialog::perform(GUIWindow &parentWindow,const String &strTemplateName) +{ + String filterString; + + if(strTemplateName.isNull())return FALSE; + if(mFilterPatternString.isNull()||mTitleString.isNull())return FALSE; + filterString=mFilterPatternString.betweenString('.',0); + mOpenDialog.instance(parentWindow.processInstance()); + mOpenDialog.templateName(strTemplateName); + mOpenDialog.filter(filterString); + mOpenDialog.filterPattern(mFilterPatternString); + if(mFileTitleString.isNull())mOpenDialog.fileName(mFilterPatternString); + else mOpenDialog.fileName(mFileTitleString); + mOpenDialog.title(mTitleString); + mOpenDialog.fileTitle(mTitleString); + mOpenDialog.creationFlags(OpenDialog::Flags(OpenDialog::EXPLORER|OpenDialog::PATHMUSTEXIST|OpenDialog::ENABLEHOOK|OpenDialog::ENABLETEMPLATE)); + mOpenDialog.hookProc((LPOFNHOOKPROC)&DWindow::OFHookProc); + mOpenDialog.customData((DWORD)(GUIWindow*)(DWindow*)this); + mOpenDialog.owner(parentWindow); + if(!mOpenDialog.getOpenFileName())return FALSE; + mOpenFileNameString=mOpenDialog.fileName(); + return TRUE; +} + +CallbackData::ReturnType CustomOpenDialog::commandHandler(CallbackData &someCallbackData) +{ + return handleCommand(someCallbackData); +} + +CallbackData::ReturnType CustomOpenDialog::initHandler(CallbackData &someCallbackData) +{ + return handleInit(someCallbackData); +} + +CallbackData::ReturnType CustomOpenDialog::notifyHandler(CallbackData &someCallbackData) +{ + NotifyMessageHeader notifyMessageHeader; + OFNOTIFY *pOFNOTIFY=(OFNOTIFY*)someCallbackData.lParam(); + if(!pOFNOTIFY)return FALSE; + notifyMessageHeader=pOFNOTIFY->hdr; + switch(notifyMessageHeader.code()) + { + case CDN_FILEOK : + if(handleFileOk(notifyMessageHeader)){::SetWindowLong(*this,DWL_MSGRESULT,TRUE);return TRUE;} + return FALSE; + case CDN_FOLDERCHANGE : + return handleFolderChange(notifyMessageHeader); + case CDN_HELP : + return handleHelp(notifyMessageHeader); + case CDN_INITDONE : + return handleInitDone(notifyMessageHeader); + case CDN_SELCHANGE : + return handleSelChange(notifyMessageHeader); + case CDN_SHAREVIOLATION : + return handleShareViolation(notifyMessageHeader); + case CDN_TYPECHANGE : + return handleTypeChange(notifyMessageHeader); + } + return FALSE; +} + +BOOL CustomOpenDialog::getFilePath(String &strFilePath)const +{ + String svFilePath; + + if(!isValid())return FALSE; + if(0>GUIWindow::sendMessage(parent(),CDM_GETFILEPATH,String::MaxString,(LPARAM)(LPSTR)svFilePath))return FALSE; + strFilePath=svFilePath; + return TRUE; +} + +BOOL CustomOpenDialog::setDefaultExtension(const String &strDefExt)const +{ + if(!isValid()||strDefExt.isNull())return FALSE; + GUIWindow::sendMessage(parent(),CDM_SETDEFEXT,0,(LPARAM)(LPSTR)(String&)strDefExt); + return TRUE; +} + +BOOL CustomOpenDialog::getFolderIDList(Array &arrayList)const +{ + DWORD requiredBytes; + + if(!isValid())return FALSE; + requiredBytes=GUIWindow::sendMessage(parent(),CDM_GETFOLDERIDLIST,0,0L); + arrayList.size(requiredBytes); + return arrayList.size()==GUIWindow::sendMessage(parent(),CDM_GETFOLDERIDLIST,requiredBytes,(LPARAM)(LPSTR)&arrayList[0]); +} + +BOOL CustomOpenDialog::getFolderPath(String &strFolderPath)const +{ + String svFolderPath; + + if(!isValid())return FALSE; + if(0>GUIWindow::sendMessage(parent(),CDM_GETFOLDERPATH,String::MaxString,(LPARAM)(LPSTR)svFolderPath))return FALSE; + strFolderPath=svFolderPath; + return TRUE; +} + +BOOL CustomOpenDialog::getSpec(String &strFileSpec)const +{ + String svFileSpec; + + if(!isValid())return FALSE; + if(0>GUIWindow::sendMessage(parent(),CDM_GETSPEC,String::MaxString,(LPARAM)(LPSTR)svFileSpec))return FALSE; + strFileSpec=svFileSpec; + return TRUE; +} + +BOOL CustomOpenDialog::hideControl(UINT controlID)const +{ + if(!isValid())return FALSE; + GUIWindow::sendMessage(parent(),CDM_HIDECONTROL,(WPARAM)controlID,0L); + return TRUE; +} + +BOOL CustomOpenDialog::setControlText(UINT controlID,const String &strControlText)const +{ + if(!isValid()||strControlText.isNull())return FALSE; + GUIWindow::sendMessage(parent(),CDM_SETCONTROLTEXT,(WPARAM)controlID,(LPARAM)(LPSTR)(String&)strControlText); + return TRUE; +} + +// **** virtuals + +BOOL CustomOpenDialog::handleFileOk(const NotifyMessageHeader &/*notifyMessageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleFolderChange(const NotifyMessageHeader &/*notifyMessageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleHelp(const NotifyMessageHeader &/*notifyMessageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleInitDone(const NotifyMessageHeader &/*notifyMesageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleSelChange(const NotifyMessageHeader &/*notifyMessageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleShareViolation(const NotifyMessageHeader &/*notifyMessageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleTypeChange(const NotifyMessageHeader &/*notifyMessageHeader*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleCommand(CallbackData &/*someCallbackData*/) +{ + return FALSE; +} + +BOOL CustomOpenDialog::handleInit(CallbackData &/*someCallbackData*/) +{ + return TRUE; +} diff --git a/common/OPNDLGEX.HPP b/common/OPNDLGEX.HPP new file mode 100644 index 0000000..db8b116 --- /dev/null +++ b/common/OPNDLGEX.HPP @@ -0,0 +1,57 @@ +#ifndef _COMMON_CUSTOMOPENDIALOG_HPP_ +#define _COMMON_CUSTOMOPENDIALOG_HPP_ +#ifndef _COMMON_DWINDOW_HPP_ +#include +#endif +#ifndef _COMMON_OPENDIALOG_HPP_ +#include +#endif + +template +class Array; +class NotifyMessageHeader; + +class CustomOpenDialog : public DWindow +{ +public: + CustomOpenDialog(void); + virtual ~CustomOpenDialog(); + const String &openFileName(void); + void setFilterPattern(const String &strFilterPattern); + void setTitle(const String &strTitle); + void setFileTitle(const String &strFileTitle); + BOOL perform(GUIWindow &parentWindow,const String &strTemplateName); +protected: + virtual BOOL handleCommand(CallbackData &someCallbackData); + virtual BOOL handleInit(CallbackData &someCallbackData); + virtual BOOL handleFileOk(const NotifyMessageHeader ¬ifyMessageHeader); + virtual BOOL handleFolderChange(const NotifyMessageHeader ¬ifyMessageHeader); + virtual BOOL handleHelp(const NotifyMessageHeader ¬ifyMessageHeader); + virtual BOOL handleInitDone(const NotifyMessageHeader ¬ifyMesageHeader); + virtual BOOL handleSelChange(const NotifyMessageHeader ¬ifyMessageHeader); + virtual BOOL handleShareViolation(const NotifyMessageHeader ¬ifyMessageHeader); + virtual BOOL handleTypeChange(const NotifyMessageHeader ¬ifyMessageHeader); + BOOL setControlText(UINT controlID,const String &strControlText)const; + BOOL setDefaultExtension(const String &strDefExt)const; + BOOL getFolderIDList(Array &arrayList)const; + BOOL getFolderPath(String &strFolderPath)const; + BOOL getFilePath(String &strFilePath)const; + BOOL getSpec(String &strFileSpec)const; + BOOL hideControl(UINT controlID)const; +private: + CustomOpenDialog(const CustomOpenDialog &someCustomOpenDialog); + CustomOpenDialog &operator=(const CustomOpenDialog &someCustomOpenDialog); + CallbackData::ReturnType initHandler(CallbackData &someCallbackData); + CallbackData::ReturnType commandHandler(CallbackData &someCallbackData); + CallbackData::ReturnType notifyHandler(CallbackData &someCallbackData); + + Callback mInitHandler; + Callback mCommandHandler; + Callback mNotifyHandler; + OpenDialog mOpenDialog; + String mFilterPatternString; + String mTitleString; + String mFileTitleString; + String mOpenFileNameString; +}; +#endif diff --git a/common/OVERLAP.HPP b/common/OVERLAP.HPP new file mode 100644 index 0000000..029d1d4 --- /dev/null +++ b/common/OVERLAP.HPP @@ -0,0 +1,106 @@ +#ifndef _COMMON_OVERLAPPED_HPP_ +#define _COMMON_OVERLAPPED_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class Overlapped : private _OVERLAPPED +{ +public: + Overlapped(void); + virtual ~Overlapped(); + DWORD offsetLow(void)const; + void offsetLow(DWORD offsetLow); + DWORD offsetHigh(void)const; + void offsetHigh(DWORD offsetHigh); + HANDLE event(void)const; + void event(HANDLE event); + _OVERLAPPED &getOverlapped(void); +private: + Overlapped(const Overlapped &someOverlapped); + Overlapped &operator=(const Overlapped &someOverlapped); + BOOL operator==(const Overlapped &someOverlapped)const; + void zeroInit(void); +}; + +inline +Overlapped::Overlapped(void) +{ + zeroInit(); +} + +inline +Overlapped::Overlapped(const Overlapped &someOverlapped) +{ // private implementation + *this=someOverlapped; +} + +inline +Overlapped::~Overlapped() +{ +} + +inline +Overlapped &Overlapped::operator=(const Overlapped &/*someOverlapped*/) +{ // private implementation + return *this; +} + +inline +BOOL Overlapped::operator==(const Overlapped &/*someOverlapped*/)const +{ + return FALSE; +} + +inline +DWORD Overlapped::offsetLow(void)const +{ + return _OVERLAPPED::Offset; +} + +inline +void Overlapped::offsetLow(DWORD offsetLow) +{ + _OVERLAPPED::Offset=offsetLow; +} + +inline +DWORD Overlapped::offsetHigh(void)const +{ + return _OVERLAPPED::OffsetHigh; +} + +inline +void Overlapped::offsetHigh(DWORD offsetHigh) +{ + _OVERLAPPED::OffsetHigh=offsetHigh; +} + +inline +HANDLE Overlapped::event(void)const +{ + return _OVERLAPPED::hEvent; +} + +inline +void Overlapped::event(HANDLE hEvent) +{ + _OVERLAPPED::hEvent=hEvent; +} + +inline +_OVERLAPPED &Overlapped::getOverlapped(void) +{ + return *this; +} + +inline +void Overlapped::zeroInit(void) +{ + _OVERLAPPED::Internal=0; + _OVERLAPPED::InternalHigh=0; + _OVERLAPPED::Offset=0; + _OVERLAPPED::OffsetHigh=0; + _OVERLAPPED::hEvent=0; +} +#endif diff --git a/common/OWNER.CPP b/common/OWNER.CPP new file mode 100644 index 0000000..b9033d8 --- /dev/null +++ b/common/OWNER.CPP @@ -0,0 +1,136 @@ +#include +#include +#include +#include +#include + +OwnerDraw::OwnerDraw(OwnerDraw::Usage sourceResource) +: mhLibrary(0), mhInstance(0) +{ + String dllPathFileName; + + mhInstance=instanceData(); + if(OwnerDraw::UseLibrary==sourceResource) + { + ::GetWindowsDirectory(dllPathFileName,String::MaxString-1); +#if defined(__FLAT__) + dllPathFileName+="\\RESLIB32.DLL"; +#else + dllPathFileName+="\\RESLIB16.DLL"; +#endif + mhLibrary=::LoadLibrary(dllPathFileName); + if((UINT)mhLibrary<32)mhLibrary=0; + } + return; +} + +OwnerDraw::~OwnerDraw() +{ + if(0!=mhLibrary)::FreeLibrary(mhLibrary); +} + +int OwnerDraw::associate(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,FocusItem focusItem) +{ + int itemIndex; + + if(!(itemIndex=locateLinkedButton(ctlID)))mLinkedButtons.insert(&LinkedButton(ctlID,focusUp,noFocusUp,focusDown,mhLibrary?mhLibrary:mhInstance,(LinkedButton::FocusItem)focusItem)); + else + { + itemIndex--; + mLinkedButtons[itemIndex].referenceCount(mLinkedButtons[itemIndex].referenceCount()+1); + } + return TRUE; +} + +int OwnerDraw::associate(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,String &noFocusDisabled,FocusItem focusItem) +{ + int itemIndex; + + if(!(itemIndex=locateLinkedButton(ctlID)))mLinkedButtons.insert(&LinkedButton(ctlID,focusUp,noFocusUp,focusDown,noFocusDisabled,mhLibrary?mhLibrary:mhInstance,(LinkedButton::FocusItem)focusItem)); + else + { + itemIndex--; + mLinkedButtons[itemIndex].referenceCount(mLinkedButtons[itemIndex].referenceCount()+1); + } + return TRUE; +} + +int OwnerDraw::handleOwnerButton(int ctlID,LPARAM lParam) +{ + int itemIndex; + LPDRAWITEMSTRUCT lpControlData((LPDRAWITEMSTRUCT)lParam); + + if(!(itemIndex=locateLinkedButton(ctlID)))return FALSE; + return mLinkedButtons[--itemIndex].drawButton(lpControlData); +} + +void OwnerDraw::freeButton(int ctlID) +{ + int itemIndex; + + if(!(itemIndex=locateLinkedButton(ctlID)))return; + --itemIndex; + if(mLinkedButtons[itemIndex].referenceCount()-1<=0)mLinkedButtons.remove(itemIndex); + else mLinkedButtons[itemIndex].referenceCount(mLinkedButtons[itemIndex].referenceCount()-1); +} + +int OwnerDraw::locateLinkedButton(int ctlID) +{ + size_t size((int)mLinkedButtons.size()); + + for(int i=0;i +#endif +#ifndef _COMMON_LINKEDBUTTON_HPP_ +#include +#endif +#ifndef _COMMON_LINKEDBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class OwnerDraw +{ +public: + enum FocusItem{FOCUS,NOFOCUS}; + enum Usage{UseLibrary,UseInstance}; + OwnerDraw(Usage sourceResource=UseLibrary); + virtual ~OwnerDraw(); + operator HINSTANCE(void)const; + int associate(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,FocusItem focusItem); + int associate(int ctlID,String &focusUp,String &noFocusUp,String &focusDown,String &noFocusDisabled,FocusItem focusItem); + int handleOwnerButton(int ctlID,LPARAM lParam); + void freeButton(int ctlID); + int associate(int ctlID,String &bitmapName); + void drawBitmap(int ctlID,HWND hWnd,RECT locationRect); + void drawBitmap(int ctlID); + void freeBitmap(int ctlID); +private: + HINSTANCE instanceData(void); + int locateLinkedButton(int ctlID); + int locateLinkedBitmap(int ctlID); + + HINSTANCE mhLibrary; + HINSTANCE mhInstance; + Block mLinkedButtons; + Block mLinkedBitmaps; +}; + +inline +OwnerDraw::operator HINSTANCE(void)const +{ + return mhLibrary; +} + +inline +HINSTANCE OwnerDraw::instanceData(void) +{ +#ifdef __FLAT__ + return ::GetModuleHandle(0); +#else + return ((HINSTANCE)(_DS-1)); +#endif +} +#endif + + \ No newline at end of file diff --git a/common/Odlist.cpp b/common/Odlist.cpp new file mode 100644 index 0000000..017f2c3 --- /dev/null +++ b/common/Odlist.cpp @@ -0,0 +1,286 @@ +#include +#include +#include +#include +#include +#include +#include + +OwnerDrawList::OwnerDrawList(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID) +: mParentWnd(parentWnd), Control(hControlWnd,controlID), + mDlgWidthUnits((LOWORD(::GetDialogBaseUnits())/4)*2) +{ + mDrawItemHandler.setCallback(this,&OwnerDrawList::drawItemHandler); + mMeasureItemHandler.setCallback(this,&OwnerDrawList::measureItemHandler); + mControlColorHandler.setCallback(this,&OwnerDrawList::controlColorHandler); + mSizeHandler.setCallback(this,&OwnerDrawList::sizeHandler); + mParentWnd.insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.insertHandler(VectorHandler::MeasureItemHandler,&mMeasureItemHandler); + mParentWnd.insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + mParentWnd.insertHandler(VectorHandler::SizeHandler,&mSizeHandler); +} + +OwnerDrawList::OwnerDrawList(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,DWORD style) +: mParentWnd(parentWnd), mDlgWidthUnits((LOWORD(::GetDialogBaseUnits())/4)*2) +{ + mDrawItemHandler.setCallback(this,&OwnerDrawList::drawItemHandler); + mMeasureItemHandler.setCallback(this,&OwnerDrawList::measureItemHandler); + mControlColorHandler.setCallback(this,&OwnerDrawList::controlColorHandler); + mSizeHandler.setCallback(this,&OwnerDrawList::sizeHandler); + mParentWnd.insertHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.insertHandler(VectorHandler::MeasureItemHandler,&mMeasureItemHandler); + mParentWnd.insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + mParentWnd.insertHandler(VectorHandler::SizeHandler,&mSizeHandler); + createControl("LISTBOX","",style,initRect,parentWnd,controlID); +} + +OwnerDrawList::~OwnerDrawList() +{ + mParentWnd.removeHandler(VectorHandler::DrawItemHandler,&mDrawItemHandler); + mParentWnd.removeHandler(VectorHandler::MeasureItemHandler,&mMeasureItemHandler); + mParentWnd.removeHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + mParentWnd.removeHandler(VectorHandler::SizeHandler,&mSizeHandler); +} + +CallbackData::ReturnType OwnerDrawList::controlColorHandler(CallbackData &someCallbackData) +{ + PureDevice pureDevice((HDC)someCallbackData.wParam()); + Control wndListBox((HWND)someCallbackData.lParam(),::GetDlgCtrlID((HWND)someCallbackData.lParam()),FALSE); + if(!(*this==wndListBox))return (CallbackData::ReturnType)TRUE; + return handleControlColor(pureDevice,wndListBox); +} + +CallbackData::ReturnType OwnerDrawList::drawItemHandler(CallbackData &someCallbackData) +{ + DrawItem drawItem(*((LPDRAWITEMSTRUCT)someCallbackData.lParam())); + if(drawItem.controlID()!=controlID())return (CallbackData::ReturnType)TRUE; + handleDraw(drawItem); + return (CallbackData::ReturnType)TRUE; +} + +CallbackData::ReturnType OwnerDrawList::measureItemHandler(CallbackData &someCallbackData) +{ + if(controlID()!=someCallbackData.wParam())return (CallbackData::ReturnType)TRUE; + LPMEASUREITEMSTRUCT pMeasureItemStruct=(LPMEASUREITEMSTRUCT)someCallbackData.lParam(); + MeasureItem measureItem(*pMeasureItemStruct); + handleMeasureItem(measureItem); + pMeasureItemStruct->CtlType=measureItem.ctlType(); + pMeasureItemStruct->CtlID=measureItem.ctlID(); + pMeasureItemStruct->itemID=measureItem.itemID(); + pMeasureItemStruct->itemWidth=measureItem.itemWidth(); + pMeasureItemStruct->itemHeight=measureItem.itemHeight(); + pMeasureItemStruct->itemData=measureItem.itemData(); + return (CallbackData::ReturnType)TRUE; +} + +CallbackData::ReturnType OwnerDrawList::sizeHandler(CallbackData &someCallbackData) +{ + handleResize(someCallbackData.loWord(),someCallbackData.hiWord()); + return (CallbackData::ReturnType)FALSE; +} + +BOOL OwnerDrawList::setTabStops(Block &tabStops) +{ + if(!isOkay())return FALSE; + mTabStopArray.size(tabStops.size()); + if(!mTabStopArray.size())return FALSE; + int *pIntArray=(int*)&mTabStopArray[0]; + for(int itemIndex=0;itemIndex &selectedItems) +{ + GlobalData selItems; + LONG itemCount; + + if(!isOkay())return LB_ERR; + selItems.size(MaxItems); + itemCount=sendMessage(LB_GETSELITEMS,selItems.size(),(LPARAM)((DWORD*)&selItems[0])); + if(LB_ERR==itemCount)return LB_ERR; + selectedItems.size(itemCount); + for(DWORD itemIndex=0;itemIndex +#endif +#ifndef _COMMON_RUBBERCONTROL_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif +#ifndef _COMMON_FONT_HPP_ +#include +#endif + +class Rect; +class GDIPoint; +class DrawItem; +class MeasureItem; +class PureDWORD; +class RGBColor; +class Font; +template +class Block; + +class OwnerDrawList : public Control, public RubberControl +{ +public: + OwnerDrawList(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID); + OwnerDrawList(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,DWORD style=LBS_NOTIFY|LBS_HASSTRINGS|LBS_USETABSTOPS|LBS_OWNERDRAWFIXED|WS_VSCROLL|WS_HSCROLL|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_DLGFRAME); + virtual ~OwnerDrawList(); + OwnerDrawList &operator=(const OwnerDrawList &someOwnerDrawList); + BOOL setTabStops(Block &tabStops); + LONG addString(const String &stringData); + LONG insertString(const String &stringData,int insertPos=-1); + LONG insertStringAndMakeCurrent(const String &stringData); + LONG deleteString(DWORD itemIndex); + WORD setCurrent(WORD itemIndex); + LONG getCurrent(void); + LONG getCount(void); + LONG setSelection(UINT itemIndex,WORD selectionState); + LONG getText(String &stringData,DWORD itemIndex=0L); + LONG getSelItems(GlobalData &selectedItems); + LONG getSelCount(void); + LONG getSel(UINT itemIndex); + LONG getCursorItem(void); + LONG getItemRect(UINT itemIndex,Rect &someRect); + LONG findStringExact(const String &itemString,int startIndex=-1)const; + LONG findString(const String &itemString,int startIndex=-1)const; + LONG setCaretIndex(int itemIndex,BOOL scrollIntoView)const; + LONG selItemRange(UINT rangeFirst,UINT rangeLast,BOOL select=TRUE)const; + LONG itemFromPoint(const GDIPoint &somePoint); + void setRedraw(WORD isInDraw); + void resetContent(void); + LONG textOut(const DrawItem &drawItem,const String &strData,int xLocation=0); + GUIWindow &getParent(void); + int dlgWidthUnits(void)const; + BOOL isOkay(void)const; +protected: + virtual WORD handleDraw(const DrawItem &drawItem); + virtual WORD handleMeasureItem(MeasureItem &measureItem); + virtual LPARAM handleControlColor(PureDevice &pureDevice,Control &wndListBox); + virtual void drawEntire(const DrawItem &drawItem); + virtual void handleResize(WORD width,WORD height); + virtual GUIWindow &controlWindow(void); +private: + enum {MaxItems=32767}; + CallbackData::ReturnType drawItemHandler(CallbackData &someCallbackData); + CallbackData::ReturnType measureItemHandler(CallbackData &someCallbackData); + CallbackData::ReturnType controlColorHandler(CallbackData &someCallbackData); + CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData); + + Callback mDrawItemHandler; + Callback mMeasureItemHandler; + Callback mControlColorHandler; + Callback mSizeHandler; + GUIWindow &mParentWnd; + GlobalData mTabStopArray; + int mDlgWidthUnits; +}; + +inline +OwnerDrawList &OwnerDrawList::operator=(const OwnerDrawList &/*someOwnerDrawList*/) +{ // private implementation + return *this; +} + +inline +void OwnerDrawList::setRedraw(WORD isInDraw) +{ + if(!isOkay())return; + sendMessage(WM_SETREDRAW,isInDraw,0L); +} + +inline +void OwnerDrawList::resetContent(void) +{ + if(!isOkay())return; + setRedraw(FALSE); + sendMessage(LB_RESETCONTENT,0,0L); + setRedraw(TRUE); +} + +inline +GUIWindow &OwnerDrawList::getParent(void) +{ + return mParentWnd; +} + +inline +int OwnerDrawList::dlgWidthUnits(void)const +{ + return mDlgWidthUnits; +} + +inline +BOOL OwnerDrawList::isOkay(void)const +{ + return isValid(); +} +#endif diff --git a/common/Odlstchk.hpp b/common/Odlstchk.hpp new file mode 100644 index 0000000..cf45971 --- /dev/null +++ b/common/Odlstchk.hpp @@ -0,0 +1,34 @@ +#ifndef _COMMON_OWNERDRAWLISTCHECK_HPP_ +#define _COMMON_OWNERDRAWLISTCHECK_HPP_ +#ifndef _COMMON_BRUSH_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_OWNERDRAWLIST_HPP_ +#include +#endif + +class PureBitmap; + +class OwnerDrawListCheck : public OwnerDrawList +{ +public: + OwnerDrawListCheck(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID,const PureBitmap &selected,const PureBitmap &unselected); + OwnerDrawListCheck(GUIWindow &parentWnd,const Rect &initRect,int controlID,const PureBitmap &selected,const PureBitmap &unselected,DWORD style=LBS_NOTIFY|WS_BORDER|LBS_HASSTRINGS|WS_VSCROLL|LBS_OWNERDRAWFIXED|WS_CLIPCHILDREN|WS_CLIPSIBLINGS); + virtual ~OwnerDrawListCheck(); + OwnerDrawListCheck &operator=(const OwnerDrawListCheck &someOwnerDrawListCheck); +protected: + virtual WORD handleDraw(const DrawItem &drawItem); + virtual WORD handleMeasureItem(MeasureItem &measureItem); + virtual LPARAM handleControlColor(PureDevice &pureDevice,Control &wndListBox); + virtual void drawEntire(const DrawItem &drawItem); +private: + enum {BmSel=0,BmUnSel=1}; + Block mPureBitmaps; + RGBColor mRGBGray; + Brush mGrayBrush; + Brush mDisabledBrush; +}; +#endif \ No newline at end of file diff --git a/common/Opendlg.hpp b/common/Opendlg.hpp new file mode 100644 index 0000000..b7772c9 --- /dev/null +++ b/common/Opendlg.hpp @@ -0,0 +1,120 @@ +#ifndef _COMMON_OPENDIALOG_HPP_ +#define _COMMON_OPENDIALOG_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_COMMDLG_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif + +class GUIWindow; + +class OpenDialog : private OPENFILENAME +{ +public: + enum Flags{ALLOWMULTISELECT=OFN_ALLOWMULTISELECT, + CREATEPROMPT=OFN_CREATEPROMPT, + ENABLEHOOK=OFN_ENABLEHOOK, + ENABLETEMPLATE=OFN_ENABLETEMPLATE, + ENABLETEMPLATEHANDLE=OFN_ENABLETEMPLATEHANDLE, + EXPLORER=OFN_EXPLORER, + EXTENSIONDIFFERENT=OFN_EXTENSIONDIFFERENT, + FILEMUSTEXIST=OFN_FILEMUSTEXIST, + HIDEREADONLY=OFN_HIDEREADONLY, + LONGNAMES=OFN_LONGNAMES, + NOCHANGEDIR=OFN_NOCHANGEDIR, + NODEREFERENCELINKS=OFN_NODEREFERENCELINKS, + NOLONGNAMES=OFN_NOLONGNAMES, + NONETWORKBUTTON=OFN_NONETWORKBUTTON, + NOREADONLYRETURN=OFN_NOREADONLYRETURN, + NOTESTFILECREATE=OFN_NOTESTFILECREATE, + NOVALIDATE=OFN_NOVALIDATE, + OVERWRITEPROMPT=OFN_OVERWRITEPROMPT, + PATHMUSTEXIST=OFN_PATHMUSTEXIST, + READONLY=OFN_READONLY, + SHAREAWARE=OFN_SHAREAWARE, + SHOWHELP=OFN_SHOWHELP}; + OpenDialog(void); + OpenDialog(const OpenDialog &someOpenDialog); + virtual ~OpenDialog(); + OpenDialog &operator=(const OpenDialog &someOpenDialog); + BOOL operator==(const OpenDialog &someOpenDialog)const; + BOOL getOpenFileName(GUIWindow &parentWindow,const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName); + BOOL getSaveFileName(GUIWindow &parentWindow,const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName); + BOOL getOpenFileName(const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName); + BOOL getOpenFileName(const String &filterPatternString,const String &titleString,const String &fileTitleString,Block &strFileNames); + BOOL getSaveFileName(const String &filterPatternString,const String &titleString,const String &fileTitleString,String &pathFileName); + BOOL getSaveFileName(void); + BOOL getOpenFileName(void); + HWND owner(void)const; + void owner(HWND hwndOwner); + HINSTANCE instance(void)const; + void instance(HINSTANCE hInstance); + const String &filter(void)const; + void filter(const String &filter); + const String &filterPattern(void)const; + void filterPattern(const String &filterPattern); + const String &customFilter(void)const; + void customFilter(const String &customFilter); + DWORD filterIndex(void)const; + void filterIndex(DWORD filterIndex); + const String &fileName(void)const; + void fileName(const String &fileName); + const String &fileTitle(void)const; + void fileTitle(const String &fileTitle); + const String &initialDirectory(void)const; + void initialDirectory(const String &initialDirectory); + const String &title(void)const; + void title(const String &title); + DWORD creationFlags(void)const; + void creationFlags(DWORD creationFlags); + const String &defaultExtension(void)const; + void defaultExtension(const String &defaultExtension); + const String &templateName(void)const; + void templateName(const String &templateName); + LPOFNHOOKPROC hookProc(void)const; + void hookProc(LPOFNHOOKPROC pHookProc); + DWORD customData(void)const; + void customData(DWORD customData); + int size(void)const; + const String &operator[](int index); +private: + enum {MaxLength=32768,MaxMultiSelect=65536,MaxTitle=512,MaxSaveLength=512}; + void setZero(void); + void setLength(void); + void parseFileNames(const String &nameBuffer,Block &fileNames); + String parseLine(int &index,const String &strLine); + + String mFilter; + String mFilterPattern; + String mCustomFilter; + String mFileName; + String mFileTitle; + String mTitle; + String mInitialDirectory; + String mDefaultExtension; + String mTemplateName; + String mFileNameBuffer; + String mFileTitleBuffer; + Block mFileNames; +}; + +inline +int OpenDialog::size(void)const +{ + return mFileNames.size(); +} + +inline +const String &OpenDialog::operator[](int index) +{ + return mFileNames[index]; +} +#endif + diff --git a/common/Openfile.hpp b/common/Openfile.hpp new file mode 100644 index 0000000..b764466 --- /dev/null +++ b/common/Openfile.hpp @@ -0,0 +1,383 @@ +#if defined(__FLAT__) +#ifndef _COMMON_OPENFILE_HPP_ +#define _COMMON_OPENFILE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_FILETIME_HPP_ +#include +#endif +#ifndef _COMMON_SYSTEMTIME_HPP_ +#include +#endif +#ifndef _COMMON_OVERLAPPED_HPP_ +#include +#endif + +class Overlapped; + +class FileHandle +{ +public: + enum {ErrorReturn=0xFFFFFFFF}; + enum Method{SeekBegin=FILE_BEGIN,SeekCurrent=FILE_CURRENT,SeekEnd=FILE_END}; + enum Mode{Create=CREATE_NEW,Overwrite=CREATE_ALWAYS,Open=OPEN_EXISTING}; + enum Share{ShareNone=0,ShareRead=FILE_SHARE_READ,ShareWrite=FILE_SHARE_WRITE,ShareReadWrite=FILE_SHARE_READ|FILE_SHARE_WRITE}; + enum Access{Read=GENERIC_READ,Write=GENERIC_WRITE,ReadWrite=GENERIC_READ|GENERIC_WRITE,Query=0}; + enum Disposition{CloseHandle,AssumedHandle,InvalidHandle}; + enum Attribute{Normal=FILE_ATTRIBUTE_NORMAL,Archive=FILE_ATTRIBUTE_ARCHIVE, + Hidden=FILE_ATTRIBUTE_HIDDEN,ReadOnly=FILE_ATTRIBUTE_READONLY, + System=FILE_ATTRIBUTE_SYSTEM,Temporary=FILE_ATTRIBUTE_TEMPORARY, + FlagDeleteOnClose=FILE_FLAG_DELETE_ON_CLOSE,FlagOverlapped=FILE_FLAG_OVERLAPPED}; + FileHandle(void); + FileHandle(const String &pathFileName,Access access=ReadWrite,Share share=ShareRead,Mode open=Open,Attribute attribute=Normal); + FileHandle(const FileHandle &someFileHandle); + FileHandle(HANDLE hFile); + virtual ~FileHandle(); + operator HANDLE(void)const; + FileHandle &operator=(const FileHandle &someFileHandle); + FileHandle &operator=(HANDLE hFile); + WORD open(const String &pathFileName,Access access=ReadWrite,Share share=ShareNone,Mode open=Open,Attribute attribute=Normal); + void close(void); + WORD isOkay(void)const; + DWORD seek(long offset,Method seekMethod); + DWORD tell(void)const; + DWORD rewind(void)const; + WORD read(BYTE &someByte)const; + WORD read(BYTE *lpBytePtr,DWORD dwExtent)const; + WORD read(DWORD &someDWORD)const; + BOOL read(BYTE &someByte,Overlapped &overlapped)const; + BOOL read(BYTE *lpBytePtr,DWORD dwExtent,Overlapped &overlapped)const; + BOOL read(DWORD &someDWORD,Overlapped &overlapped)const; + DWORD getLine(String &lineString)const; + WORD write(const BYTE &someByte)const; + DWORD write(const String &someString)const; + DWORD writeLine(const String &someString)const; + WORD write(BYTE *lpBytePtr,DWORD dwExtent)const; + WORD write(const DWORD &someDWORD)const; + WORD write(const WORD &someWORD)const; + WORD flush(void)const; + BOOL getOverlappedResult(Overlapped &overlapped,BOOL wait=FALSE)const; + DWORD size(void)const; + String pathFileName(void)const; + Share share(void)const; + Access access(void)const; + SystemTime creationTime(void)const; + SystemTime lastAccessTime(void)const; + SystemTime lastModifyTime(void)const; + void disposition(Disposition disposition); +private: +// enum {CarriageReturn=0x0D,LineFeed=0x0A,NullChar=0x00}; + enum {CarriageReturn=0x0D,LineFeed=0x0A,TabChar=0x09,NullChar=0x00}; + Disposition disposition(void)const; + void pathFileName(const String &pathFileName); + void share(Share share); + void access(Access access); + HANDLE mhFileHandle; + Disposition mDisposition; + String mPathFileName; + Share mShare; + Access mAccess; +}; + +inline +FileHandle::FileHandle(void) +: mhFileHandle(INVALID_HANDLE_VALUE), mDisposition(InvalidHandle), + mShare(ShareNone), mAccess(ReadWrite) +{ +} + +inline +FileHandle::FileHandle(HANDLE hFile) +{ + *this=hFile; +} + +inline +FileHandle::FileHandle(const String &pathFileName,Access access,Share share,Mode open,Attribute attribute) +: mhFileHandle(INVALID_HANDLE_VALUE), mDisposition(InvalidHandle), mPathFileName(pathFileName), mShare(share), + mAccess(access) +{ + if(mPathFileName.isNull())return; + mhFileHandle=::CreateFile(mPathFileName,access,share,(LPSECURITY_ATTRIBUTES)0,open,attribute,(HANDLE)0); + if(INVALID_HANDLE_VALUE!=mhFileHandle)mDisposition=CloseHandle; +} + +inline +FileHandle::FileHandle(const FileHandle &someFileHandle) +{ + *this=someFileHandle; +} + +inline +FileHandle::operator HANDLE(void)const +{ + return mhFileHandle; +} + +inline +FileHandle &FileHandle::operator=(const FileHandle &someFileHandle) +{ + mhFileHandle=(HANDLE)someFileHandle; + pathFileName(someFileHandle.pathFileName()); + share(someFileHandle.share()); + access(someFileHandle.access()); + disposition(AssumedHandle); + return *this; +} + +inline +FileHandle &FileHandle::operator=(HANDLE hFile) +{ + mhFileHandle=hFile; + disposition(AssumedHandle); + share(ShareReadWrite); + access(ReadWrite); + return *this; +} + +inline +WORD FileHandle::open(const String &pathFileName,Access access,Share share,Mode open,Attribute attribute) +{ + close(); + mPathFileName=pathFileName; + mShare=share; + mAccess=access; + if(mPathFileName.isNull())return FALSE; + mhFileHandle=::CreateFile(mPathFileName,access,share,(LPSECURITY_ATTRIBUTES)0,open,attribute,(HANDLE)0); + if(INVALID_HANDLE_VALUE!=mhFileHandle)mDisposition=CloseHandle; + return isOkay(); +} + +inline +DWORD FileHandle::seek(long offset,Method seekMethod) +{ + if(!isOkay())return FALSE; + return ::SetFilePointer((HANDLE)*this,offset,(PLONG)0,seekMethod); +} + +inline +DWORD FileHandle::tell(void)const +{ + if(!isOkay())return FALSE; + return ::SetFilePointer((HANDLE)*this,0L,(PLONG)0,SeekCurrent); +} + +inline +DWORD FileHandle::rewind(void)const +{ + if(!isOkay())return FALSE; + return ::SetFilePointer((HANDLE)*this,0L,(PLONG)0,SeekBegin); +} + +inline +BOOL FileHandle::getOverlappedResult(Overlapped &overlapped,BOOL wait)const +{ + DWORD bytesReadThusFar; + if(!isOkay())return FALSE; + return ::GetOverlappedResult(mhFileHandle,&overlapped.getOverlapped(),&bytesReadThusFar,wait); +} + +inline +BOOL FileHandle::read(BYTE &someByte,Overlapped &overlapped)const +{ + DWORD bytesRead; + + if(!isOkay())return FALSE; + return ::ReadFile((HANDLE)*this,&someByte,sizeof(BYTE),&bytesRead,&overlapped.getOverlapped()); +} + +inline +BOOL FileHandle::read(BYTE *lpBytePtr,DWORD dwExtent,Overlapped &overlapped)const +{ + DWORD bytesRead; + + if(!isOkay())return FALSE; + return ::ReadFile((HANDLE)*this,lpBytePtr,dwExtent,&bytesRead,&overlapped.getOverlapped()); +} + +inline +BOOL FileHandle::read(DWORD &someDWORD,Overlapped &overlapped)const +{ + DWORD bytesRead; + + if(!isOkay())return FALSE; + return ::ReadFile((HANDLE)*this,&someDWORD,sizeof(DWORD),&bytesRead,&overlapped.getOverlapped()); +} + +inline +WORD FileHandle::read(BYTE &someByte)const +{ + DWORD bytesRead; + + if(!isOkay())return FALSE; + ::ReadFile((HANDLE)*this,&someByte,sizeof(BYTE),&bytesRead,(LPOVERLAPPED)0); + return sizeof(BYTE)==bytesRead; +} + +inline +WORD FileHandle::read(BYTE *lpBytePtr,DWORD dwExtent)const +{ + DWORD bytesRead; + + if(!isOkay())return FALSE; + ::ReadFile((HANDLE)*this,lpBytePtr,dwExtent,&bytesRead,(LPOVERLAPPED)0); + return bytesRead==dwExtent; +} + +inline +WORD FileHandle::read(DWORD &someDWORD)const +{ + DWORD bytesRead; + + if(!isOkay())return FALSE; + ::ReadFile((HANDLE)*this,&someDWORD,sizeof(DWORD),&bytesRead,(LPOVERLAPPED)0); + return sizeof(DWORD)==bytesRead; +} + +inline +WORD FileHandle::write(const BYTE &someByte)const +{ + DWORD bytesWritten; + + if(!isOkay())return FALSE; + ::WriteFile((HANDLE)*this,&someByte,sizeof(BYTE),&bytesWritten,(LPOVERLAPPED)0); + return sizeof(BYTE)==bytesWritten; +} + +inline +WORD FileHandle::write(const DWORD &someDWORD)const +{ + DWORD bytesWritten; + + if(!isOkay())return FALSE; + ::WriteFile((HANDLE)*this,&someDWORD,sizeof(DWORD),&bytesWritten,(LPOVERLAPPED)0); + return sizeof(DWORD)==bytesWritten; +} + +inline +WORD FileHandle::write(const WORD &someWORD)const +{ + DWORD bytesWritten; + + if(!isOkay())return FALSE; + ::WriteFile((HANDLE)*this,&someWORD,sizeof(WORD),&bytesWritten,(LPOVERLAPPED)0); + return sizeof(WORD)==bytesWritten; +} + +inline +WORD FileHandle::write(BYTE *lpBytePtr,DWORD dwExtent)const +{ + DWORD bytesWritten; + + if(!isOkay())return FALSE; + ::WriteFile((HANDLE)*this,lpBytePtr,dwExtent,&bytesWritten,(LPOVERLAPPED)0); + return dwExtent==bytesWritten; +} + +inline +DWORD FileHandle::write(const String &someString)const +{ + WORD stringLength(someString.length()); + DWORD bytesWritten; + + if(!isOkay())return FALSE; + ::WriteFile((HANDLE)*this,(char*)someString,stringLength,&bytesWritten,(LPOVERLAPPED)0); + return bytesWritten; +} + +inline +DWORD FileHandle::writeLine(const String &someString)const +{ + String lineString(someString); + WORD stringLength; + DWORD bytesWritten; + + if(!isOkay())return FALSE; + lineString+=(BYTE)CarriageReturn; + lineString+=(BYTE)LineFeed; + stringLength=lineString.length(); + ::WriteFile((HANDLE)*this,(char*)lineString,stringLength,&bytesWritten,(LPOVERLAPPED)0); + return bytesWritten; +} + +inline +WORD FileHandle::flush(void)const +{ + if(!isOkay())return FALSE; + return ::FlushFileBuffers((HANDLE)*this); +} + +inline +String FileHandle::pathFileName(void)const +{ + return mPathFileName; +} + +inline +void FileHandle::pathFileName(const String &pathFileName) +{ + mPathFileName=pathFileName; +} + +inline +FileHandle::Share FileHandle::share(void)const +{ + return mShare; +} + +inline +void FileHandle::share(Share share) +{ + mShare=share; +} + +inline +FileHandle::Access FileHandle::access(void)const +{ + return mAccess; +} + +inline +void FileHandle::access(Access access) +{ + mAccess=access; +} + +inline +void FileHandle::disposition(Disposition disposition) +{ + mDisposition=disposition; +} + +inline +FileHandle::Disposition FileHandle::disposition(void)const +{ + return mDisposition; +} + +inline +WORD FileHandle::isOkay(void)const +{ + return (INVALID_HANDLE_VALUE==mhFileHandle?FALSE:TRUE); +} + +inline +DWORD FileHandle::size(void)const +{ + if(!isOkay())return FALSE; + return ::GetFileSize((HANDLE)*this,0); +} + +inline +void FileHandle::close(void) +{ + if(INVALID_HANDLE_VALUE==mhFileHandle)return; + if(CloseHandle==mDisposition)::CloseHandle(mhFileHandle); + mhFileHandle=INVALID_HANDLE_VALUE; +} +#endif +#endif \ No newline at end of file diff --git a/common/PALENTRY.HPP b/common/PALENTRY.HPP new file mode 100644 index 0000000..d768a9d --- /dev/null +++ b/common/PALENTRY.HPP @@ -0,0 +1,161 @@ +#ifndef _COMMON_PALETTEENTRY_HPP_ +#define _COMMON_PALETTEENTRY_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif + +class PaletteEntry : private tagPALETTEENTRY +{ +public: + enum PaletteFlags{NoCollapse=PC_NOCOLLAPSE,Explicit=PC_EXPLICIT,Reserved=PC_RESERVED,NullFlag=0}; + PaletteEntry(void); + PaletteEntry(const PaletteEntry &somePaletteEntry); + PaletteEntry(const RGBColor &someRGBColor); + ~PaletteEntry(); // destructor must not be virtual + PaletteEntry &operator=(const PaletteEntry &somePaletteEntry); + PaletteEntry &operator=(const RGBColor &someRGBColor); + WORD operator==(const PaletteEntry &somePaletteEntry)const; + WORD operator==(const RGBColor &someRGBColor)const; + BYTE red(void)const; + BYTE green(void)const; + BYTE blue(void)const; + PaletteFlags flags(void)const; + void red(BYTE peRed); + void green(BYTE peGreen); + void blue(BYTE peBlue); + void flags(PaletteFlags peFlags); + operator PALETTEENTRY&(void); + operator RGBColor(void)const; +private: +}; + +inline +PaletteEntry::PaletteEntry(void) +{ + red(0); + green(0); + blue(0); + flags(NullFlag); +} + +inline +PaletteEntry::PaletteEntry(const PaletteEntry &somePaletteEntry) +{ + red(somePaletteEntry.red()); + green(somePaletteEntry.green()); + blue(somePaletteEntry.blue()); +} + +inline +PaletteEntry::PaletteEntry(const RGBColor &someRGBColor) +{ + red(someRGBColor.red()); + green(someRGBColor.green()); + blue(someRGBColor.blue()); + flags(NullFlag); +} + +inline +PaletteEntry::~PaletteEntry() +{ +} + +inline +PaletteEntry &PaletteEntry::operator=(const PaletteEntry &somePaletteEntry) +{ + red(somePaletteEntry.red()); + green(somePaletteEntry.green()); + blue(somePaletteEntry.blue()); + flags(somePaletteEntry.flags()); + return *this; +} + +inline +PaletteEntry &PaletteEntry::operator=(const RGBColor &someRGBColor) +{ + red(someRGBColor.red()); + green(someRGBColor.green()); + blue(someRGBColor.blue()); + return *this; +} + +inline +WORD PaletteEntry::operator==(const PaletteEntry &somePaletteEntry)const +{ + return(red()==somePaletteEntry.red()&& + green()==somePaletteEntry.green()&& + blue()==somePaletteEntry.blue()&& + flags()==somePaletteEntry.flags()); +} + +inline +WORD PaletteEntry::operator==(const RGBColor &someRGBColor)const +{ + return(red()==someRGBColor.red()&& + green()==someRGBColor.green()&& + blue()==someRGBColor.blue()); +} + +inline +BYTE PaletteEntry::red(void)const +{ + return tagPALETTEENTRY::peRed; +} + +inline +BYTE PaletteEntry::green(void)const +{ + return tagPALETTEENTRY::peGreen; +} + +inline +BYTE PaletteEntry::blue(void)const +{ + return tagPALETTEENTRY::peBlue; +} + +inline +PaletteEntry::PaletteFlags PaletteEntry::flags(void)const +{ + return (PaletteFlags)tagPALETTEENTRY::peFlags; +} + +inline +void PaletteEntry::red(BYTE peRed) +{ + tagPALETTEENTRY::peRed=peRed; +} + +inline +void PaletteEntry::green(BYTE peGreen) +{ + tagPALETTEENTRY::peGreen=peGreen; +} + +inline +void PaletteEntry::blue(BYTE peBlue) +{ + tagPALETTEENTRY::peBlue=peBlue; +} + +inline +void PaletteEntry::flags(PaletteEntry::PaletteFlags peFlags) +{ + tagPALETTEENTRY::peFlags=(BYTE)peFlags; +} + +inline +PaletteEntry::operator PALETTEENTRY&(void) +{ + return *this; +} + +inline +PaletteEntry::operator RGBColor(void)const +{ + return RGBColor(red(),green(),blue()); +} +#endif diff --git a/common/PATHFND.CPP b/common/PATHFND.CPP new file mode 100644 index 0000000..8e633ff --- /dev/null +++ b/common/PATHFND.CPP @@ -0,0 +1,379 @@ +#include +#include +#include +#include + +PathFind::PathFind(void) +: mIsOkay(FALSE) +{ + mUpDirString=".."; + mCurrDirString="."; + mBackSlashString="\\"; + mStarDotStarString="*.*"; + mPathString="PATH"; + mSemicolonString=";"; + mWinDirString="windir"; + getPathBlock(); +} + +PathFind::~PathFind() +{ +} + +WORD PathFind::isFile(const String &pathFileName) +{ + return mFindData.findFirst(pathFileName); +} + +BOOL PathFind::hasWildCard(String &pathFileSpec)const +{ + if(-1==pathFileSpec.strpos("*")&&-1==pathFileSpec.strpos("?"))return FALSE; + return TRUE; +} + +BOOL PathFind::hasPath(String &pathFileSpec)const +{ + if(-1==pathFileSpec.strpos(":"))return FALSE; + return TRUE; +} + +WORD PathFind::dirList(String pathEntry,Block &subDirList) +{ + subDirList.remove(); + if(pathEntry.isNull())getWinDir(pathEntry); + if(pathEntry.strstr("*"))getDirEntries(pathEntry,subDirList); + else getPathTranscend(pathEntry,subDirList); + return subDirList.size(); +} + +WORD PathFind::fileList(String pathFileSpec,Block &entryList) +{ + int strLength(pathFileSpec.length()); + entryList.remove(); + if(pathFileSpec.isNull())return FALSE; + if(!hasPath(pathFileSpec))insertPath(pathFileSpec); + if(!hasWildCard(pathFileSpec)) + { + if(pathFileSpec.operator[](strLength-1)=='\\'||pathFileSpec.operator[](strLength-1)=='/')pathFileSpec+=mStarDotStarString; + else pathFileSpec+=mBackSlashString+mStarDotStarString; + } + if(!mFindData.findFirst(pathFileSpec,FindData::FileArchive))return FALSE; + if(mFindData.attributes()&FindData::FileArchive)entryList.insert(&mFindData.fileName()); + while(mFindData.findNext())if(mFindData.attributes()&FindData::FileArchive)entryList.insert(&mFindData.fileName()); + return (entryList.size()?TRUE:FALSE); +} + +WORD PathFind::findFile(const String &pureFileName,String &pathFileName) +{ + String searchDir; + + if(!mIsOkay)return FALSE; + if(pureFileName.isNull())return FALSE; + if(isFile(pureFileName)) + { + pathFileName=pureFileName; + return TRUE; + } + size_t numEntries((size_t)mPathEntry.size()); + for(int itemIndex=0;itemIndex subDirList; + String searchFileName; + String transcendPath; + + if(pathEntry.isNull())return FALSE; + fixupPathName(pathEntry); + searchFileName=pathEntry; + searchFileName+=pureFileName; + if(isFile(searchFileName)){pathFileName=searchFileName;return TRUE;} + return FALSE; +} + +WORD PathFind::searchPathTranscend(String pathEntry,String pureFileName,String &pathFileName) +{ + if(pathEntry.isNull())return FALSE; + Block subDirList; + String searchFileName; + String transcendPath; + + if(pathEntry.isNull())return FALSE; + if(!canTranscend(pathEntry)) + { + searchFileName=pathEntry; + searchFileName+=mBackSlashString; + searchFileName+=pureFileName; + if(isFile(searchFileName)){pathFileName=searchFileName;return TRUE;} + return FALSE; + } + searchFileName=pathEntry; + searchFileName+=mBackSlashString; + searchFileName+=pureFileName; + if(isFile(searchFileName)){pathFileName=searchFileName;return TRUE;} + subList(subDirList,pathEntry); + WORD itemCount((size_t)subDirList.size()); + for(int itemIndex=0;itemIndex &pathFileName) +{ + if(pathEntry.isNull())return FALSE; + Block subDirList; + String searchFileName; + String transcendPath; + String pathEntryExtension; + + if(pathEntry.isNull())return FALSE; + if(!canTranscend(pathEntry)) + { + searchFileName=pathEntry; + searchFileName+=mBackSlashString; + searchFileName+=mStarDotStarString; + return getDirectoryFileEntries(searchFileName,pathFileName); + } + searchFileName=pathEntry; + searchFileName+=mBackSlashString; + searchFileName+=mStarDotStarString; + getDirectoryFileEntries(searchFileName,pathFileName); + subList(subDirList,pathEntry); + WORD itemCount((size_t)subDirList.size()); + for(int itemIndex=0;itemIndex &entryStrings) +{ + Profile iniProfile; + WORD specEntries(0); + String pathEntrySpec; + String pathFileName; + + if(pathEntryFileSpec.isNull())return specEntries; + pathEntrySpec=pathEntryFileSpec; + iniProfile.makeDirectoryName(pathEntrySpec); + pathEntrySpec+=mBackSlashString; + if(mFindData.findFirst(pathEntryFileSpec)) + { + pathFileName=pathEntrySpec; + pathFileName+=mFindData.fileName(); + pathFileName.lower(); + entryStrings.insert(&pathFileName); + specEntries++; + while(mFindData.findNext()) + { + pathFileName=pathEntrySpec; + pathFileName+=mFindData.fileName(); + pathFileName.lower(); + entryStrings.insert(&pathFileName); + specEntries++; + } + } + return specEntries; +} + +WORD PathFind::getDirEntries(String pathEntryFileSpec,Block &entryStrings) +{ + Profile iniProfile; + WORD specEntries(0); + String pathFileName; + String dirName; + FindData findData; + + if(pathEntryFileSpec.isNull())return specEntries; + dirName=pathEntryFileSpec; + if(!iniProfile.makeDirectoryName(dirName))dirName=String(); + if(!findData.findFirst(pathEntryFileSpec)) + { + pathFileName=dirName; + if(!pathFileName.isNull())pathFileName+="/"; + pathFileName+=findData.fileName(); + pathFileName.lower(); + entryStrings.insert(&pathFileName); + specEntries++; + while(!findData.findNext()) + { + pathFileName=dirName; + if(!pathFileName.isNull())pathFileName+="/"; + pathFileName+=findData.fileName(); + pathFileName.lower(); + entryStrings.insert(&pathFileName); + specEntries++; + } + } + return specEntries; +} + +void PathFind::subList(Block &subDirList,String pathEntry) +{ + subDirList.remove(); + String entryString; + + pathEntry+=mBackSlashString; + pathEntry+=mStarDotStarString; + if(mFindData.findFirst(pathEntry,FindData::FileDirectory)) + { + entryString=mFindData.fileName(); + if(isDirectory(mFindData)){entryString.lower();subDirList.insert(&entryString);} + while(mFindData.findNext()) + { + entryString=mFindData.fileName(); + if(isDirectory(mFindData)){entryString.lower();subDirList.insert(&entryString);} + } + } +} + +WORD PathFind::canTranscend(String &pathEntry) +{ + FindData findData; + char *lpStr; + + if(!findData.findFirst(pathEntry)||findData.attributes()&FindData::FileDirectory) + { + String tempString(pathEntry); + if(*((char*)tempString+tempString.length())!=BackSlash&&*((char*)tempString+tempString.length())!=ForwardSlash)tempString+=mBackSlashString; + tempString+=mStarDotStarString; + if(mFindData.findFirst(tempString,FindData::FileDirectory)) + { + if(isDirectory(mFindData))return TRUE; + while(mFindData.findNext())if(isDirectory(mFindData))return TRUE; + } + return FALSE; + } + lpStr=::strchr(pathEntry,Dot); + *lpStr=BackSlash; + return FALSE; +} + +void PathFind::fixupPathName(String &pathEntry) +{ + char *lpStr; + if(0==(lpStr=::strchr(pathEntry,Dot))) + { + if(*((char*)pathEntry+pathEntry.length())!=BackSlash&&*((char*)pathEntry+pathEntry.length())!=ForwardSlash)pathEntry+=mBackSlashString; + return; + } + *lpStr=BackSlash; + return; +} + +void PathFind::insertPath(String &pathFileSpec)const +{ + String currentDirectory; + DiskInfo diskInfo; + diskInfo.getCurrentDirectory(currentDirectory); + currentDirectory+=mBackSlashString; + pathFileSpec.insert(currentDirectory); +} + +WORD PathFind::isDirectory(FindData &findData) +{ + String tempString; + + if(FindData::FileDirectory&findData.attributes()) + { + tempString=findData.fileName(); + if(!(tempString==mUpDirString)&&!(tempString==mCurrDirString))return TRUE; + } + return FALSE; +} + +WORD PathFind::getPathBlock(void) +{ + String strCopyPath; + char *lpPath; + char *lpTemp; + + strCopyPath=::getenv((LPSTR)mPathString); + if(strCopyPath.isNull())return FALSE; + lpPath=(char*)strCopyPath; + if(0==(lpTemp=::strtok(lpPath,mSemicolonString)))return FALSE; + mPathEntry.remove(); + while(TRUE) + { + mPathEntry.insert(&String(lpTemp)); + if(0==(lpTemp=::strtok(0,mSemicolonString)))break; + } + return (mIsOkay=TRUE); +} + +WORD PathFind::getWinDir(String &winDirString) +{ + char *lpPath; + + if(0==(lpPath=::getenv((LPSTR)mWinDirString))) + { + mWinDirString.upper(); + if(0==(lpPath=::getenv((LPSTR)mWinDirString)))return FALSE; + mWinDirString.lower(); + } + winDirString=lpPath; + return TRUE; +} + +WORD PathFind::getCurrDir(String &currDirString) +{ + DiskInfo diskInfo; + return diskInfo.getCurrentDirectory(currDirString); +} + +WORD PathFind::getWindowsDirectory(String &windowsDirectoryString) +{ + String windowsDirString; + + if(FALSE==(::GetWindowsDirectory(windowsDirString,String::MaxString)))return FALSE; + windowsDirectoryString=windowsDirString; + return TRUE; +} + +WORD PathFind::getSystemDirectory(String &systemDirectoryString) +{ + String systemDirString; + + if(FALSE==(::GetSystemDirectory(systemDirString,String::MaxString)))return FALSE; + systemDirectoryString=systemDirString; + return TRUE; +} + +BOOL PathFind::getWindowsTempDirectory(String &windowsTempDirectory) +{ + String windowsTempDir; + + if(FALSE==(::GetTempPath(String::MaxString,(char*)windowsTempDir)))return FALSE; + windowsTempDirectory=windowsTempDir; + return TRUE; +} + +BOOL PathFind::getTempFileName(String &strPathTempFileName,const String &strPrefix) +{ + String strPathTempDir; + + getWindowsTempDirectory(strPathTempDir); + strPathTempFileName=::_tempnam(strPathTempDir,strPrefix.isNull()?0:(char*)(String&)strPrefix); + return !(strPathTempFileName.isNull()); +} + + + + diff --git a/common/PCALLBCK.HPP b/common/PCALLBCK.HPP new file mode 100644 index 0000000..a2b3c4d --- /dev/null +++ b/common/PCALLBCK.HPP @@ -0,0 +1,31 @@ +#ifndef _COMMON_PURECALLBACK_HPP_ +#define _COMMON_PURECALLBACK_HPP_ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#include +#endif + +class PureCallback +{ +public: + PureCallback(void); + virtual ~PureCallback(); + virtual CallbackData::ReturnType operator*(CallbackData &someCallbackData)=0; +private: +}; + +inline +PureCallback::PureCallback(void) +{ +} + +inline +PureCallback::~PureCallback() +{ +} + +inline +CallbackData::ReturnType PureCallback::operator*(CallbackData &/*someCallbackData*/) +{ + return 0; +} +#endif \ No newline at end of file diff --git a/common/PEN.HPP b/common/PEN.HPP new file mode 100644 index 0000000..2086197 --- /dev/null +++ b/common/PEN.HPP @@ -0,0 +1,104 @@ +#ifndef _COMMON_PEN_HPP_ +#define _COMMON_PEN_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif + +class Pen +{ +public: + enum{DefaultWidth=1}; + enum PenStyle{PSolid=PS_SOLID,PDash=PS_DASH,PDot=PS_DOT,PDashDot=PS_DASHDOT,PDashDotDot=PS_DASHDOTDOT,PNull=PS_NULL,PInsideFrame=PS_INSIDEFRAME}; + Pen(void); + Pen(HPEN somePen); + Pen(const Pen &somePen); + Pen(const RGBColor &someRGBColor,PenStyle penStyle=PSolid,short penWidth=DefaultWidth); + Pen(const RGBColor &someRGBColor,short penWidth); + ~Pen(); + void color(const RGBColor &someRGBColor); + const RGBColor &color(void)const; + operator HPEN(void)const; +private: + enum Disposition{DeletePen,AssumePen,InvalidPen}; + Pen &operator=(const Pen &somePen); + WORD operator==(const Pen &somePen); + HPEN mhPen; + RGBColor mColor; + Disposition mDisposition; +}; + +inline +Pen::Pen(void) +: mhPen(::CreatePen(PS_SOLID,DefaultWidth,RGBColor(0,0,0))), mDisposition(DeletePen) +{ +} + +inline +Pen::Pen(HPEN somePen) +: mhPen(somePen), mDisposition(AssumePen) +{ +} + +inline +Pen::Pen(const Pen &somePen) +: mhPen(::CreatePen(PS_SOLID,DefaultWidth,somePen.mColor)), mColor(somePen.mColor), + mDisposition(DeletePen) +{ +} + +inline +Pen::Pen(const RGBColor &someRGBColor,PenStyle penStyle,short penWidth) +: mhPen(::CreatePen(penStyle,penWidth,(COLORREF)someRGBColor)), mColor(someRGBColor), + mDisposition(DeletePen) +{ +} + +inline +Pen::Pen(const RGBColor &someRGBColor,short penWidth) +: mhPen(::CreatePen(PSolid,penWidth,(COLORREF)someRGBColor)), mColor(someRGBColor), + mDisposition(DeletePen) +{ +} + +inline +Pen::~Pen() +{ + if(mhPen&&DeletePen==mDisposition)::DeleteObject(mhPen); +} + +inline +void Pen::color(const RGBColor &someRGBColor) +{ + if(mhPen)::DeleteObject(mhPen); + mhPen=::CreatePen(PS_SOLID,DefaultWidth,(COLORREF)someRGBColor); + mDisposition=DeletePen; + mColor=someRGBColor; +} + +inline +const RGBColor &Pen::color(void)const +{ + return mColor; +} + +inline +Pen::operator HPEN(void)const +{ + return mhPen; +} + +inline +Pen &Pen::operator=(const Pen &/*somePen*/) +{ + return *this; +} + +inline +WORD Pen::operator==(const Pen &/*somePen*/) +{ + return FALSE; +} +#endif diff --git a/common/PENTRY.HPP b/common/PENTRY.HPP new file mode 100644 index 0000000..3ac71ba --- /dev/null +++ b/common/PENTRY.HPP @@ -0,0 +1,254 @@ +#ifndef _COMMON_PROCESSENTRY_HPP_ +#define _COMMON_PROCESSENTRY_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_TOOLHELP32_HPP_ +#include +#endif + +class ProcessEntry : private PROCESSENTRY32 +{ +public: + ProcessEntry(void); + ProcessEntry(const ProcessEntry &processEntry); + ProcessEntry(const PROCESSENTRY32 &processEntry32); + virtual ~ProcessEntry(); + ProcessEntry &operator=(const ProcessEntry &processEntry); + ProcessEntry &operator=(const PROCESSENTRY32 &processEntry32); + BOOL operator==(const ProcessEntry &processEntry)const; + BOOL operator==(const PROCESSENTRY32 &processEntry32)const; + DWORD referenceCount(void)const; + DWORD processID(void)const; + DWORD heapID(void)const; + DWORD moduleID(void)const; + DWORD threads(void)const; + DWORD parentProcessID(void)const; + LONG priorityClassBase(void)const; + DWORD flags(void)const; + String strExeFile(void)const; + PROCESSENTRY32 &getProcessEntry(void); +private: + void referenceCount(DWORD referenceCount); + void processID(DWORD processID); + void heapID(DWORD heapID); + void moduleID(DWORD moduleID); + void threads(DWORD threads); + void parentProcessID(DWORD parentProcessID); + void priorityClassBase(LONG priorityClassBase); + void flags(DWORD flags); + void strExeFile(const String &strExeFile); + void setZero(void); +}; + +inline +ProcessEntry::ProcessEntry(void) +{ + setZero(); +} + +inline +ProcessEntry::ProcessEntry(const ProcessEntry &processEntry) +{ + *this=processEntry; +} + +inline +ProcessEntry::ProcessEntry(const PROCESSENTRY32 &processEntry32) +{ + *this=processEntry32; +} + +inline +ProcessEntry::~ProcessEntry() +{ +} + +inline +ProcessEntry &ProcessEntry::operator=(const ProcessEntry &processEntry) +{ + referenceCount(processEntry.referenceCount()); + processID(processEntry.processID()); + heapID(processEntry.heapID()); + moduleID(processEntry.moduleID()); + threads(processEntry.threads()); + parentProcessID(processEntry.parentProcessID()); + priorityClassBase(processEntry.priorityClassBase()); + flags(processEntry.flags()); + strExeFile(processEntry.strExeFile()); + return *this; +} + +inline +ProcessEntry &ProcessEntry::operator=(const PROCESSENTRY32 &processEntry32) +{ + referenceCount(processEntry32.cntUsage); + processID(processEntry32.th32ProcessID); + heapID(processEntry32.th32DefaultHeapID); + moduleID(processEntry32.th32ModuleID); + threads(processEntry32.cntThreads); + parentProcessID(processEntry32.th32ParentProcessID); + priorityClassBase(processEntry32.pcPriClassBase); + flags(processEntry32.dwFlags); + strExeFile(processEntry32.szExeFile); + return *this; +} + +inline +BOOL ProcessEntry::operator==(const ProcessEntry &processEntry)const +{ + return (referenceCount()==processEntry.referenceCount()&& + processID()==processEntry.processID()&& + heapID()==processEntry.heapID()&& + moduleID()==processEntry.moduleID()&& + threads()==processEntry.threads()&& + parentProcessID()==processEntry.parentProcessID()&& + priorityClassBase()==processEntry.priorityClassBase()&& + flags()==processEntry.flags()&& + strExeFile()==processEntry.strExeFile()); +} + +inline +BOOL ProcessEntry::operator==(const PROCESSENTRY32 &processEntry32)const +{ + return (referenceCount()==processEntry32.cntUsage&& + processID()==processEntry32.th32ProcessID&& + heapID()==processEntry32.th32DefaultHeapID&& + moduleID()==processEntry32.th32ModuleID&& + threads()==processEntry32.cntThreads&& + parentProcessID()==processEntry32.th32ParentProcessID&& + priorityClassBase()==processEntry32.pcPriClassBase&& + flags()==processEntry32.dwFlags&& + strExeFile()==processEntry32.szExeFile); +} + +inline +DWORD ProcessEntry::referenceCount(void)const +{ + return PROCESSENTRY32::cntUsage; +} + +inline +void ProcessEntry::referenceCount(DWORD referenceCount) +{ + PROCESSENTRY32::cntUsage=referenceCount; +} + +inline +DWORD ProcessEntry::processID(void)const +{ + return PROCESSENTRY32::th32ProcessID; +} + +inline +void ProcessEntry::processID(DWORD processID) +{ + PROCESSENTRY32::th32ProcessID=processID; +} + +inline +DWORD ProcessEntry::heapID(void)const +{ + return PROCESSENTRY32::th32DefaultHeapID; +} + +inline +void ProcessEntry::heapID(DWORD heapID) +{ + PROCESSENTRY32::th32DefaultHeapID=heapID; +} + +inline +DWORD ProcessEntry::moduleID(void)const +{ + return PROCESSENTRY32::th32ModuleID; +} + +inline +void ProcessEntry::moduleID(DWORD moduleID) +{ + PROCESSENTRY32::th32ModuleID=moduleID; +} + +inline +DWORD ProcessEntry::threads(void)const +{ + return PROCESSENTRY32::cntThreads; +} + +inline +void ProcessEntry::threads(DWORD threads) +{ + PROCESSENTRY32::cntThreads=threads; +} + +inline +DWORD ProcessEntry::parentProcessID(void)const +{ + return PROCESSENTRY32::th32ParentProcessID; +} + +inline +void ProcessEntry::parentProcessID(DWORD parentProcessID) +{ + PROCESSENTRY32::th32ParentProcessID=parentProcessID; +} + +inline +LONG ProcessEntry::priorityClassBase(void)const +{ + return PROCESSENTRY32::pcPriClassBase; +} + +inline +void ProcessEntry::priorityClassBase(LONG priorityClassBase) +{ + PROCESSENTRY32::pcPriClassBase=priorityClassBase; +} + +inline +DWORD ProcessEntry::flags(void)const +{ + return PROCESSENTRY32::dwFlags; +} + +inline +void ProcessEntry::flags(DWORD flags) +{ + PROCESSENTRY32::dwFlags=flags; +} + +inline +String ProcessEntry::strExeFile(void)const +{ + return PROCESSENTRY32::szExeFile; +} + +inline +void ProcessEntry::strExeFile(const String &strExeFile) +{ + if(strExeFile.length()>=sizeof(PROCESSENTRY32::szExeFile))return; + ::strcpy(PROCESSENTRY32::szExeFile,(char*)(String&)strExeFile); +} + +inline +void ProcessEntry::setZero(void) +{ + PROCESSENTRY32::dwSize=sizeof(PROCESSENTRY32); + PROCESSENTRY32::cntUsage=0; + PROCESSENTRY32::th32ProcessID=0; + PROCESSENTRY32::th32DefaultHeapID=0; + PROCESSENTRY32::th32ModuleID=0; + PROCESSENTRY32::cntThreads=0; + PROCESSENTRY32::th32ParentProcessID=0; + PROCESSENTRY32::pcPriClassBase=0; + PROCESSENTRY32::dwFlags=0; + PROCESSENTRY32::szExeFile[0]=0; +} + +inline +PROCESSENTRY32 &ProcessEntry::getProcessEntry(void) +{ + return (PROCESSENTRY32&)*this; +} +#endif diff --git a/common/POINT.CPP b/common/POINT.CPP new file mode 100644 index 0000000..cb43a5c --- /dev/null +++ b/common/POINT.CPP @@ -0,0 +1,30 @@ +#include + +Point &Point::operator--(void) +{ + COMMONPOINT::x--; + COMMONPOINT::y--; + return *this; +} + +Point Point::operator--(int /*prefixDummy*/) +{ + Point prePoint(*this); + --(*this); + return prePoint; +} + +Point Point::operator++(int /*prefixDummy*/) +{ + Point prePoint(*this); + ++(*this); + return prePoint; +} + +Point Point::operator+(const Point &somePoint)const +{ + Point tmpPoint(*this); + tmpPoint+=somePoint; + return tmpPoint; +} + diff --git a/common/POINT.HPP b/common/POINT.HPP new file mode 100644 index 0000000..4db3d14 --- /dev/null +++ b/common/POINT.HPP @@ -0,0 +1,191 @@ +#ifndef _COMMON_POINT_HPP_ +#define _COMMON_POINT_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_STDIO_HPP_ +#include +#endif + +#if defined(_MSC_VER) +#pragma warning(disable:4244) +#endif + +typedef struct COMMONPOINT +{ + short x; + short y; +}CommonPoint; + +class Point : public COMMONPOINT +{ +public: + Point(void); + Point(short x,short y); + Point(const Point &somePoint); + ~Point(); + short x(void)const; + void x(short newx); + short y(void)const; + void y(short newy); + void setPoint(short x,short y); + BOOL operator==(const Point &somePoint)const; + BOOL operator<(const Point &somePoint)const; + BOOL operator>(const Point &somePoint)const; + Point operator+(const Point &somePoint)const; + Point &operator=(const Point &somePoint); + Point &operator-=(const Point &somePoint); + Point &operator+=(const Point &somePoint); + Point &operator++(void); + Point operator++(int prefixDummy); + Point &operator--(void); + Point operator--(int prefixDummy); + Point midPoint(const Point &somePoint)const; + DWORD dsqr(const Point &somePoint)const; + operator POINT(void)const; + String toString(void)const; +private: +}; + +inline +Point::Point(void) +{ + COMMONPOINT::x=0; + COMMONPOINT::y=0; +} + +inline +Point::Point(short x,short y) +{ + COMMONPOINT::x=x; + COMMONPOINT::y=y; +} + +inline +Point::Point(const Point &somePoint) +{ + COMMONPOINT::x=((COMMONPOINT&)somePoint).x; + COMMONPOINT::y=((COMMONPOINT&)somePoint).y; +} + +inline +Point::~Point() +{ +} + +inline +short Point::x(void)const +{ + return COMMONPOINT::x; +} + +inline +void Point::x(short newx) +{ + COMMONPOINT::x=newx; +} + +inline +short Point::y(void)const +{ + return COMMONPOINT::y; +} + +inline +void Point::y(short newy) +{ + COMMONPOINT::y=newy; +} + +inline +BOOL Point::operator==(const Point &somePoint)const +{ + return (COMMONPOINT::x==((COMMONPOINT&)somePoint).x&&COMMONPOINT::y==((COMMONPOINT&)somePoint).y); +} + +inline +BOOL Point::operator<(const Point &somePoint)const +{ + return (int(x())*int(x())+int(y())*int(y()))<(int(somePoint.x())*int(somePoint.x())+int(somePoint.y())*int(somePoint.y())); +} + +inline +BOOL Point::operator>(const Point &somePoint)const +{ + return (int(x())*int(x())+int(y())*int(y()))>(int(somePoint.x())*int(somePoint.x())+int(somePoint.y())*int(somePoint.y())); +} + +inline +Point &Point::operator=(const Point &somePoint) +{ + COMMONPOINT::x=((COMMONPOINT&)somePoint).x; + COMMONPOINT::y=((COMMONPOINT&)somePoint).y; + return *this; +} + +inline +Point &Point::operator-=(const Point &somePoint) +{ + COMMONPOINT::x-=((COMMONPOINT&)somePoint).x; + COMMONPOINT::y-=((COMMONPOINT&)somePoint).y; + return *this; +} + +inline +Point &Point::operator+=(const Point &somePoint) +{ + COMMONPOINT::x+=((COMMONPOINT&)somePoint).x; + COMMONPOINT::y+=((COMMONPOINT&)somePoint).y; + return *this; +} + +inline +Point &Point::operator++(void) +{ + COMMONPOINT::x++; + COMMONPOINT::y++; + return *this; +} + +inline +Point::operator POINT(void)const +{ + POINT somePoint; + + somePoint.x=COMMONPOINT::x; + somePoint.y=COMMONPOINT::y; + return somePoint; +} + +inline +Point Point::midPoint(const Point &somePoint)const +{ + return Point((((float)x()+(float)somePoint.x())/2.00)+.50,(((float)y()+(float)somePoint.y())/2.00)+.50); +} + +inline +void Point::setPoint(short x,short y) +{ + COMMONPOINT::x=x; + COMMONPOINT::y=y; +} + +inline +DWORD Point::dsqr(const Point &somePoint)const +{ + int xDiff(somePoint.x()-x()); + int yDiff(somePoint.y()-y()); + return (xDiff*xDiff)+(yDiff*yDiff); +} + +inline +String Point::toString(void)const +{ + String strPoint; + ::sprintf(strPoint.str(),"(%d,%d)",x(),y()); + return strPoint; +} +#endif diff --git a/common/POINTER.TPP b/common/POINTER.TPP new file mode 100644 index 0000000..34a72e3 --- /dev/null +++ b/common/POINTER.TPP @@ -0,0 +1,5 @@ +#ifndef _COMMON_SMARTPOINTER_TPP_ +#define _COMMON_SMARTPOINTER_TPP_ + + +#endif \ No newline at end of file diff --git a/common/PROCESS.CPP b/common/PROCESS.CPP new file mode 100644 index 0000000..364cab1 --- /dev/null +++ b/common/PROCESS.CPP @@ -0,0 +1,184 @@ +#include +#include +#include +#include + +Process::~Process() +{ + closeHandle(); +} + +#if defined(WIN32) +Process::Process(void) +: mIsOkay(FALSE), mDisposition(None) +{ + ::GetStartupInfo(&mStartupInfo); +} + +Process::Process(HANDLE hProcess) +: mIsOkay(FALSE), mDisposition(AssumeHandle) +{ + *this=hProcess; +} + +Process &Process::operator=(HANDLE hProcess) +{ + closeHandle(); + ::GetStartupInfo(&mStartupInfo); + mDisposition=AssumeHandle; + if(!hProcess)return *this; + setProcess(hProcess); + mIsOkay=TRUE; + return *this; +} + +BOOL Process::openProcess(DWORD processID,AccessFlags accessFlags,BOOL inheritHandles) +{ + closeHandle(); + mDisposition=FreeHandle; + setProcessID(processID); + setProcess(::OpenProcess((DWORD)accessFlags,inheritHandles,processID)); + mIsOkay=getProcess()?TRUE:FALSE; + return isOkay(); +} + +BOOL Process::createProcess(String moduleNameString,bool modNameIsFirstArg,String currentDirectory,String cmdLineString) +{ + return createProcess(moduleNameString,cmdLineString,modNameIsFirstArg,CreationFlags(),SW_SHOWNORMAL,false,currentDirectory); +} + +BOOL Process::createProcess(String moduleNameString,String cmdLineString,bool modNameIsFirstArg,const CreationFlags &creationFlags,WORD showWindow,BOOL inheritHandles,String currentDirectory) +{ + PathFind pathFind; + Profile profile; + String pureFileName; + String pathFileNameString; + String commandLineString; + String startupDirString("."); + String blankString(" "); + + if(isOkay())terminateProcess(); + if(moduleNameString.isNull())return FALSE; + pureFileName=moduleNameString; + if(pathFind.findFile(pureFileName,pathFileNameString)) + { + moduleNameString=pathFileNameString; + if(modNameIsFirstArg)commandLineString+=pathFileNameString+blankString; + } + else if(modNameIsFirstArg)commandLineString=moduleNameString+blankString; + commandLineString+=cmdLineString; + if(SW_SHOWNORMAL!=showWindow){mStartupInfo.dwFlags=STARTF_USESHOWWINDOW;mStartupInfo.wShowWindow=showWindow;} + mIsOkay=(WORD)::CreateProcess(moduleNameString,commandLineString,0,0,inheritHandles,(DWORD)creationFlags,0,currentDirectory.isNull()?0:currentDirectory.str(),&mStartupInfo,(PROCESS_INFORMATION*)((PureProcess*)this)); + if(!mIsOkay)return FALSE; + mDisposition=FreeHandle; + return mIsOkay; +} + +void Process::waitForInputIdle(void) +{ + if(!mIsOkay)return; + ::WaitForInputIdle(getProcess(),INFINITE); +} +#else + +inline +Process::Process(void) +: mIsOkay(FALSE), mDisposition(None) +{ +} + +inline +Process::Process(HANDLE hProcess) +: mIsOkay(FALSE), mDisposition(AssumeHandle) +{ + if(!hProcess)return; + setProcess(hProcess); + mIsOkay=TRUE; +} + +BOOL Process::createProcess(String moduleNameString,String cmdLineString,WORD showWindow) +{ + PathFind pathFind; + Profile profile; + String pureFileName; + String pathFileNameString; + String commandLineString; + String startupDirString("."); + String blankString(" "); + + if(isOkay())terminateProcess(); + if(moduleNameString.isNull())return FALSE; + pureFileName=moduleNameString; + profile.makeFileName(pureFileName); + if(pathFind.findFile(pureFileName,pathFileNameString)) + { + moduleNameString=pathFileNameString; + startupDirString=pathFileNameString; + commandLineString=pathFileNameString; + profile.makeDirectoryName(startupDirString); + commandLineString+=blankString; + } + else commandLineString=moduleNameString; + commandLineString+=blankString; + commandLineString+=cmdLineString; + mIsOkay=(::WinExec(commandLineString,showWindow)<32?FALSE:TRUE); + mDisposition=FreeHandle; + return mIsOkay; +} + +void Process::waitForInputIdle(void) +{ + return; +} +#endif + +void Process::closeHandle(void) +{ + if(FreeHandle==mDisposition) + { + if(getThread()){::CloseHandle(getThread());setThread(0);} + if(getProcess()){::CloseHandle(getProcess());setProcess(0);} + } + mDisposition=None; +} + +BOOL Process::terminateProcess(BOOL waitForProcess) +{ + WORD returnCode(FALSE); + +#if !defined(__FLAT__) + return returnCode; +#else + if(!isOkay())return returnCode; + if(!getProcess())return returnCode; + returnCode=::TerminateProcess(getProcess(),0L); + if(!returnCode)return FALSE; + if(waitForProcess)::WaitForSingleObject(getProcess(),INFINITE); + closeHandle(); + mIsOkay=FALSE; + return returnCode; +#endif +} + +BOOL Process::safeTerminateProcess(BOOL waitForProcess) +{ + HINSTANCE hInstanceKernel(::GetModuleHandle("KERNEL32")); + FARPROC pfnExitProcess((FARPROC)::GetProcAddress(hInstanceKernel,"ExitProcess")); + HANDLE hRemoteThread(INVALID_HANDLE_VALUE); + DWORD dwThreadId(0); + DWORD dwExitCode(0); + UINT uExitCode(0); + WinVersionInfo versionInfo; + + if(!versionInfo.isWinNT())return terminateProcess(waitForProcess); + if(!hInstanceKernel||!pfnExitProcess)return FALSE; + if(!::GetExitCodeProcess(getProcess(),&dwExitCode))return FALSE; + if(STILL_ACTIVE!=dwExitCode)return TRUE; + hRemoteThread=::CreateRemoteThread(getProcess(),NULL,0,(LPTHREAD_START_ROUTINE)pfnExitProcess,(PVOID)&uExitCode,0,&dwThreadId); + if(!hRemoteThread)return terminateProcess(waitForProcess); + if(waitForProcess)::WaitForSingleObject(getProcess(),INFINITE); + ::CloseHandle(hRemoteThread); + return TRUE; +} + + diff --git a/common/PROCESS.HPP b/common/PROCESS.HPP new file mode 100644 index 0000000..675ddd8 --- /dev/null +++ b/common/PROCESS.HPP @@ -0,0 +1,108 @@ +#ifndef _COMMON_PROCESS_HPP_ +#define _COMMON_PROCESS_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_PUREPROCESS_HPP_ +#include +#endif +#ifndef _COMMON_CREATIONFLAGS_HPP_ +#include +#endif + +class Process : public PureProcess +{ +public: +enum AccessFlags{AllAccess=PROCESS_ALL_ACCESS,CreateProcess=PROCESS_CREATE_PROCESS, + CreateThread=PROCESS_CREATE_THREAD,DupHandle=PROCESS_DUP_HANDLE, + QueryInformation=PROCESS_QUERY_INFORMATION,SetInformation=PROCESS_SET_INFORMATION, + Terminate=PROCESS_TERMINATE,VMOperation=PROCESS_VM_OPERATION,VMRead=PROCESS_VM_READ, + VMWrite=PROCESS_VM_WRITE,Synchronize=SYNCHRONIZE}; + Process(void); + Process(HANDLE hProcess); + virtual ~Process(); + Process &operator=(HANDLE hProcess); +#if defined(__FLAT__) + WORD readProcessMemory(LPCVOID lpBaseAddress,LPVOID lpBuffer,DWORD cbRead,LPDWORD lpNumRead)const; + WORD writeProcessMemory(LPVOID lpBaseAddress,LPVOID lpBuffer,DWORD cbWrite,LPDWORD lpNumWritten)const; + BOOL flushInstructionCache(LPCVOID lpvBase,DWORD cbFlush)const; + BOOL createProcess(String moduleNameString,bool modNameIsFirstArg,String currentDirectory,String cmdLineString); + BOOL createProcess(String moduleNameString,String cmdLineString=String(),bool modNameIsFirstArg=TRUE,const CreationFlags &creationFlags=CreationFlags(),WORD showWindow=SW_SHOWNORMAL,BOOL inheritHandles=FALSE,String currentDirectory=String()); + BOOL setPriorityClass(DWORD priority); + DWORD getPriorityClass(void); + void waitForProcess(DWORD waitTime=INFINITE); + BOOL openProcess(DWORD processID,AccessFlags accessFlags=AccessFlags(QueryInformation|VMRead),BOOL ineritHandles=FALSE); +#else + BOOL createProcess(String moduleNameString,String cmdLineString=String(),WORD showWindow=SW_SHOWNORMAL); +#endif + BOOL terminateProcess(BOOL waitForProcess=FALSE); + BOOL safeTerminateProcess(BOOL waitForProcess=FALSE); + void waitForInputIdle(void); + WORD isOkay(void)const; +private: + enum Disposition{FreeHandle,AssumeHandle,None}; + void closeHandle(void); +#if defined(__FLAT__) + STARTUPINFO mStartupInfo; +#endif + Disposition mDisposition; + WORD mIsOkay; +}; + +#if defined(__FLAT__) +inline +WORD Process::readProcessMemory(LPCVOID lpBaseAddress,LPVOID lpBuffer,DWORD cbRead,LPDWORD lpNumRead)const +{ + *lpNumRead=0; + if(!isOkay())return FALSE; + return ::ReadProcessMemory(getProcess(),lpBaseAddress,lpBuffer,cbRead,lpNumRead); +} + +inline +WORD Process::writeProcessMemory(LPVOID lpBaseAddress,LPVOID lpBuffer,DWORD cbWrite,LPDWORD lpNumWritten)const +{ + *lpNumWritten=0; + if(!isOkay())return FALSE; + return ::WriteProcessMemory(getProcess(),lpBaseAddress,lpBuffer,cbWrite,lpNumWritten); +} + +inline +BOOL Process::flushInstructionCache(LPCVOID lpvBase,DWORD cbFlush)const +{ + if(!isOkay())return FALSE; + return ::FlushInstructionCache(getProcess(),lpvBase,cbFlush); +} + +inline +BOOL Process::setPriorityClass(DWORD priority) +{ + if(!isOkay())return FALSE; + return ::SetPriorityClass(getProcess(),priority); +} + +inline +DWORD Process::getPriorityClass(void) +{ + if(!isOkay())return FALSE; + return ::GetPriorityClass(getProcess()); +} + +inline +void Process::waitForProcess(DWORD waitTime) +{ + if(!isOkay())return; + ::WaitForSingleObject(getProcess(),waitTime); +} +#endif + +inline +WORD Process::isOkay(void)const +{ + return mIsOkay; +} +#endif + + diff --git a/common/PROFILE.CPP b/common/PROFILE.CPP new file mode 100644 index 0000000..191da28 --- /dev/null +++ b/common/PROFILE.CPP @@ -0,0 +1,235 @@ +#include +#include +#include + +Profile::Profile(void) +: mIniPathFileName("UNSET"), mStringUnset("UNSET"), mIsOkay(FALSE) +{ +} + +Profile::Profile(String iniFileName,String unsetString) +: mIniPathFileName(iniFileName), mStringUnset(unsetString), mIsOkay(FALSE) +{ + mIsOkay=verifyInitializationFile(iniFileName); +} + +Profile::~Profile() +{ +} + +WORD Profile::readProfileString(const String §ionString,const String &itemString,String &returnString)const +{ + if(!isOkay())return FALSE; + + returnString.reserve(MaxProfileLength+1); + ::GetPrivateProfileString((LPSTR)sectionString,(LPSTR)itemString,(LPSTR)mStringUnset,(LPSTR)returnString,MaxProfileLength,mIniPathFileName); + if(returnString==mStringUnset)return FALSE; + expandEmbeddedMacro(returnString); + return TRUE; +} + +WORD Profile::readProfileBlock(const String §ionString,Block §ionBlock,Statement statementType) +{ + String tempString; + String itemString; + Block tempBlock; + char *ptr; + + sectionBlock.remove(); + if(!readProfileString(sectionString,String((char*)0),tempString))return FALSE; + ptr=(LPSTR)tempString; + while(TRUE) + { + if(!ptr||!*ptr)break; + tempBlock.insert(&String(ptr)); + ptr+=(::strlen(ptr)+1); + } + for(int index=0;index<(int)tempBlock.size();index++) + { + readProfileString(sectionString,tempBlock[index],itemString); + if(Pure==statementType) + { + tempString=tempBlock[index]; + tempString+="="; + tempString+=itemString; + } + else tempString=itemString; + expandEmbeddedMacro(tempString); + sectionBlock.insert(&tempString); + } + return (int)sectionBlock.size(); +} + +WORD Profile::writeProfileString(const String §ionString,const String &itemString,const String &textString) +{ + return ::WritePrivateProfileString((LPSTR)sectionString,(LPSTR)itemString,(LPSTR)textString,mIniPathFileName); +} + +WORD Profile::writeProfileBlock(const String §ionString,Block &itemStrings,Block &textStrings) +{ + WORD blockSize((int)itemStrings.size()); + if(textStrings.size()!=blockSize)return FALSE; + for(int i=0;i §ionNames) +{ + char strBuffer[2048]; + char *ptrBuff; + + sectionNames.remove(); + if(!isOkay())return FALSE; + ::GetPrivateProfileSectionNames(strBuffer,sizeof(strBuffer),mIniPathFileName); + ptrBuff=strBuffer; + while(ptrBuff&&*ptrBuff) + { + sectionNames.insert(&String(ptrBuff)); + ptrBuff+=::strlen(ptrBuff)+1; + } + return sectionNames.size()?TRUE:FALSE; +} + +WORD Profile::setIniFile(String iniFileName) +{ + mIsOkay=verifyInitializationFile(iniFileName); + return mIsOkay; +} + +WORD Profile::verifyInitializationFile(String iniFileName) +{ + PathFind pathFind; + + if(!pathFind.findFile(iniFileName,mIniPathFileName))return FALSE; + return TRUE; +} + +WORD Profile::verifyDirectory(String &pathDirectoryName) +{ + String currentWorkDir; + int resultCode; + + ::getcwd(currentWorkDir,String::MaxString); + resultCode=::chdir(pathDirectoryName); + ::chdir(currentWorkDir); + return !resultCode; +} + +void Profile::makePathFileName(String &fileNameString) +{ + String tempString(fileNameString); + String currentDriveString; + + drivePathName(currentDriveString); + currentDriveString+=fileNameString; + fileNameString=currentDriveString; +} + +String Profile::removeExtension(String strPathFileName) +{ + char *ptr; + + if(strPathFileName.isNull())return String(); + ptr=strPathFileName.str()+(strPathFileName.length()-1); + while(*ptr!='.'&&ptr>=strPathFileName.str())ptr--; + if(*ptr=='.')*ptr=0; + return strPathFileName; +} + +String Profile::getExtension(String strPathFileName) +{ + char *ptr; + + if(strPathFileName.isNull())return String(); + ptr=strPathFileName.str()+(strPathFileName.length()-1); + while(*ptr!='.'&&ptr>=strPathFileName.str())ptr--; + if(ptr4)*(ptr+4)=0; + while(*ptr!='\\'&&*ptr!='/'&&*ptr!=':'&&ptr>=(char*)tempString)ptr--; + if(ptr<(char*)tempString)ptr++; + pathFileName=ptr; + return TRUE; +} + +bool Profile::makeFileName(const String &strPathFileName,String &strFileName) +{ + int strLen; + char *ptr; + + if(strPathFileName.isNull())return false; + strLen=strPathFileName.length(); + ptr=(char*)(String&)strPathFileName+(strLen-1); + while(*ptr!='\\'&&*ptr!='/'&&*ptr!=':'&&ptr>=(char*)(String&)strPathFileName)ptr--; + strFileName=(ptr+1); + return false; +} + +bool Profile::verifyPathFileName(const String &somePathFileName) +{ + FILE *fp; + + fp=::fopen(somePathFileName,"rb"); + if(fp)::fclose(fp); + return (fp?TRUE:FALSE); +} + +bool Profile::makeDirectoryName(String &directoryName) +{ + String tempString(directoryName); + char *ptr; + + if(0!=(ptr=::strchr(tempString,'*'))) + { + if(ptr==(LPSTR)tempString)return false; + *(--ptr)=0; + directoryName=tempString; + return TRUE; + } + ptr=tempString.str()+(tempString.length()-1); + if(!ptr)return false; + while(*ptr!='\\'&&*ptr!='/'&&*ptr!=':'&&ptr>=(char*)tempString)ptr--; + if(ptr<(char*)tempString)return false; + *(ptr)=0; + directoryName=tempString; + return true; +} + +void Profile::expandEmbeddedMacro(String &someString)const +{ + String macroSyncChar("$("); + String macroEndChar(")"); + String macroString; + String tempString; + String resultString; + char *ptr; + char *envPtr; + char tempChar; + + if(someString.isNull())return; + tempString=someString; + ptr=::strstr(tempString,macroSyncChar); + if(!ptr)return; + tempChar=*ptr; + *ptr=0; + resultString=tempString; + *ptr=tempChar; + ptr+=2; + ptr=::strtok(ptr,macroEndChar); + if(!ptr)return; + if(0==(envPtr=::getenv(ptr)))resultString+=mStringUnset; + else resultString+=envPtr; + ptr=::strtok(0,"\0"); + if(ptr)resultString+=ptr; + someString=resultString; +} diff --git a/common/PROFILE.HPP b/common/PROFILE.HPP new file mode 100644 index 0000000..dac1b3c --- /dev/null +++ b/common/PROFILE.HPP @@ -0,0 +1,85 @@ +#ifndef _COMMON_PROFILE_HPP_ +#define _COMMON_PROFILE_HPP_ +#include +#include +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_DISKINFO_HPP_ +#include +#endif + +class Profile +{ +public: + enum Statement{Pure,NoAssign}; + Profile(void); + Profile(String iniFileName,String unsetString); + virtual ~Profile(void); + WORD setIniFile(String iniFileName); + WORD isOkay(void)const; + BOOL readSectionNames(Block §ionNames); + WORD readProfileString(const String §ionString,const String &itemString,String &returnString)const; + WORD readProfileBlock(const String §ionString,Block §ionBlock,Statement=Pure); + WORD writeProfileString(const String §ionString,const String &itemString,const String &textString); + WORD writeProfileBlock(const String §ionString,Block &itemStrings,Block &textStrings); + WORD makeFileName(String &pathFileName); + WORD verifyDirectory(String &pathDirectoryName); + void makePathFileName(String &fileNameString); + WORD getCurrentDirectory(String ¤tDirectory)const; + void drivePathName(String ¤tDriveString,int appendDirConst=TRUE); + static bool makeDirectoryName(String &directoryName); + static String removeExtension(String strPathFileName); + static String getExtension(String strPathFileName); + static bool makeFileName(const String &strPathFileName,String &strFileName); + static bool verifyPathFileName(const String &somePathFileName); +private: + enum{MaxProfileLength=4096}; + WORD verifyInitializationFile(String iniFileName); + void expandEmbeddedMacro(String &someString)const; + + String mStringUnset; + String mIniPathFileName; + WORD mIsOkay; +}; + +inline +WORD Profile::isOkay(void)const +{ + return mIsOkay; +} + +inline +void Profile::drivePathName(String ¤tDriveString,int appendDirConst) +{ + DiskInfo diskInfo; + + diskInfo.getCurrentDirectory(currentDriveString); + if(appendDirConst)currentDriveString+="\\"; +} + +#if defined(__FLAT__) +inline +WORD Profile::getCurrentDirectory(String ¤tDirectory)const +{ + currentDirectory.reserve(String::MaxString+1); + return (WORD)::GetCurrentDirectory(String::MaxString,currentDirectory); +} +#else +inline +WORD Profile::getCurrentDirectory(String ¤tDirectory)const +{ + currentDirectory.reserve(String::MaxString+1); + return (::getcwd(currentDirectory,String::MaxString)?TRUE:FALSE); +} +#endif +#endif diff --git a/common/PRSHT.HPP b/common/PRSHT.HPP new file mode 100644 index 0000000..4417897 --- /dev/null +++ b/common/PRSHT.HPP @@ -0,0 +1,6 @@ +#ifndef _COMMON_PRSHT_HPP_ +#define _COMMON_PRSHT_HPP_ +#if defined(__FLAT__) +#include +#endif +#endif diff --git a/common/PUREBMP.CPP b/common/PUREBMP.CPP new file mode 100644 index 0000000..1eae96f --- /dev/null +++ b/common/PUREBMP.CPP @@ -0,0 +1,285 @@ +#include +#include +#include +#include + +PureBitmap::PureBitmap(const String &strNameBitmap,HINSTANCE hInstance) +: mhBitmap(0) +{ + mhBitmap=::LoadBitmap(hInstance,strNameBitmap); + if(mhBitmap)::GetObject(mhBitmap,sizeof(BITMAP),(LPSTR)&mBitmap); +} + +WORD PureBitmap::operator==(const PureBitmap &somePureBitmap)const +{ + GlobalData bmData; + GlobalData someBmData; + + if((width()!=somePureBitmap.width())||(height()!=somePureBitmap.height()))return FALSE; + getBitmapBits(bmData); + somePureBitmap.getBitmapBits(someBmData); + if(bmData.size()!=someBmData.size())return FALSE; + return bmData==someBmData; +} + +WORD PureBitmap::operator=(const PureBitmap &somePureBitmap) +{ + PureDevice srcDevice; + PureDevice dstDevice; + + if(!somePureBitmap.isOkay())return FALSE; + srcDevice.compatibleDevice(); + dstDevice.compatibleDevice(srcDevice); + srcDevice.select(somePureBitmap); + compatibleBitmap(srcDevice,somePureBitmap); + dstDevice.select(*this); + ::BitBlt((HDC)dstDevice,0,0,somePureBitmap.width(),somePureBitmap.height(),(HDC)srcDevice,0,0,SRCCOPY); + return TRUE; +} + +WORD PureBitmap::operator=(HBITMAP hBitmap) +{ + BITMAP bmBitmap; + PureDevice dstDevice; + PureDevice srcDevice; + + if(!hBitmap)return FALSE; + ::GetObject(hBitmap,sizeof(BITMAP),(LPSTR)&bmBitmap); + srcDevice.compatibleDevice(); + dstDevice.compatibleDevice(srcDevice); + srcDevice.select(hBitmap); + compatibleBitmap(srcDevice,bmBitmap.bmWidth,bmBitmap.bmHeight); + dstDevice.select(*this); + ::BitBlt((HDC)dstDevice,0,0,bmBitmap.bmWidth,bmBitmap.bmHeight,(HDC)srcDevice,0,0,SRCCOPY); + return TRUE; +} + +WORD PureBitmap::loadBitmap(const String &strNameBitmap,HINSTANCE hInstance) +{ + destroyBitmap(); + mhBitmap=::LoadBitmap(hInstance,strNameBitmap); + if(mhBitmap)::GetObject(mhBitmap,sizeof(BITMAP),(LPSTR)&mBitmap); + return isOkay(); +} + +BOOL PureBitmap::createFrom(PureBitmap &sourceBitmap,const Rect &srcRect) +{ + PureDevice srcDevice; + PureDevice dstDevice; + + if(!sourceBitmap.isOkay())return FALSE; + srcDevice.compatibleDevice(); + dstDevice.compatibleDevice(srcDevice); + srcDevice.select(sourceBitmap); + compatibleBitmap(srcDevice,srcRect.right(),srcRect.bottom()); + dstDevice.select(*this); + ::BitBlt((HDC)dstDevice,0,0,srcRect.right(),srcRect.bottom(),(HDC)srcDevice,srcRect.left(),srcRect.top(),SRCCOPY); + return TRUE; +} + +BOOL PureBitmap::setFrom(PureBitmap &sourceBitmap,const Rect &rect)const +{ + PureDevice srcDevice; + PureDevice dstDevice; + + if(!sourceBitmap.isOkay()||!isOkay())return FALSE; + srcDevice.compatibleDevice(); + dstDevice.compatibleDevice(srcDevice); + srcDevice.select(sourceBitmap); + dstDevice.select(*this); + return ::StretchBlt((HDC)dstDevice,rect.left(),rect.top(),rect.right(),rect.bottom(),(HDC)srcDevice,0,0,sourceBitmap.width(),sourceBitmap.height(),SRCCOPY); +} + +BOOL PureBitmap::getInto(PureBitmap &dstBitmap,const Rect &rect)const +{ + PureDevice srcDevice; + PureDevice dstDevice; + + if(!dstBitmap.isOkay()||!isOkay())return FALSE; + srcDevice.compatibleDevice(); + dstDevice.compatibleDevice(srcDevice); + srcDevice.select(*this); + dstDevice.select(dstBitmap); + return ::StretchBlt((HDC)dstDevice,0,0,dstBitmap.width(),dstBitmap.height(),(HDC)srcDevice,rect.left(),rect.top(),width(),height(),SRCCOPY); +} + +WORD PureBitmap::screenBitmap(const Rect &boundingRect) +{ + RECT rect=((Rect&)boundingRect).getRect(); + return screenBitmap(rect); +} + +WORD PureBitmap::screenBitmap(const RECT &boundingRect) +{ + PureDevice screenDevice; + PureDevice memoryDevice; + Point pointOne; + Point pointTwo; + int xPixels; + int yPixels; + + if(::IsRectEmpty((RECT FAR*)&boundingRect))return FALSE; + destroyBitmap(); + screenDevice.displayDevice(); + memoryDevice.compatibleDevice(screenDevice); + pointOne.x(boundingRect.left); + pointOne.y(boundingRect.top); + pointTwo.x(boundingRect.right); + pointTwo.y(boundingRect.bottom); + xPixels=::GetDeviceCaps((HDC)screenDevice,HORZRES); + yPixels=::GetDeviceCaps((HDC)screenDevice,VERTRES); + if(0>pointOne.x())pointOne.x(0); + if(0>pointOne.y())pointOne.y(0); + if(pointTwo.x()>xPixels)pointTwo.x(xPixels); + if(pointTwo.y()>yPixels)pointTwo.y(yPixels); + compatibleBitmap(screenDevice,pointTwo.x()-pointOne.x()+1,pointTwo.y()-pointOne.y()+1); + memoryDevice.select(*this); + ::BitBlt(memoryDevice,0,0,width(),height(),screenDevice,pointOne.x(),pointOne.y(),SRCCOPY); + return isOkay(); +} + +WORD PureBitmap::windowBitmap(HWND hDisplayWindow) +{ + PureDevice displayDevice; + PureDevice memoryDevice; + Rect windowRect; + short windowWidth; + short windowHeight; + + if(!IsWindow(hDisplayWindow))return FALSE; + ::GetClientRect(hDisplayWindow,(RECT FAR*)&windowRect); + if(::IsRectEmpty((RECT FAR*)&windowRect))return FALSE; + destroyBitmap(); + displayDevice=hDisplayWindow; + memoryDevice.compatibleDevice(displayDevice); + windowWidth=windowRect.right(); + windowHeight=windowRect.bottom(); + compatibleBitmap(displayDevice,windowWidth,windowHeight); + memoryDevice.select(*this); + ::BitBlt(memoryDevice,0,0,width(),height(),displayDevice,0,0,SRCCOPY); + return isOkay(); +} + +DWORD PureBitmap::getBitmapBits(GlobalData &bitmapBytes,BitmapInfo::BitsPerPixel bitsPerPixel,BOOL bottomUp)const +{ + PurePalette systemPalette; + PureDevice pureDevice; + BitmapInfo bmInfo; + DWORD scanLines(0); + DWORD scanLineWidth; + WORD scanWidth; + WORD scanHeight; + + if(!isOkay())return scanLines; + scanLineWidth=width(); + if(scanLineWidth%2L)scanLineWidth++; + scanWidth=scanLineWidth; + scanHeight=height(); + bitmapBytes.size(scanLineWidth*(DWORD)height()*(bitsPerPixel/8)); + systemPalette.systemPalette(); + bmInfo.width(width()); + bmInfo.height(height()); + bmInfo.bitCount(bitsPerPixel); + if(bitsPerPixel==BitmapInfo::Bit8){bmInfo.colorUsed(256);bmInfo.colorImportant(256);bmInfo=systemPalette;} + else{bmInfo.colorUsed(0);bmInfo.colorImportant(0);} + pureDevice.displayDevice(); + scanLines=::GetDIBits(pureDevice,*this,0,bottomUp?height():int(height())*-1,(BYTE*)&bitmapBytes[0],(BITMAPINFO*)bmInfo,DIB_RGB_COLORS); + return scanLines; +} + +DWORD PureBitmap::getBitmapBits(GlobalData &bitmapBytes,BitmapInfo::BitsPerPixel bitsPerPixel,PurePalette &purePalette,BOOL bottomUp)const +{ + PureDevice pureDevice; + BitmapInfo bmInfo; + DWORD scanLines(0); + DWORD scanLineWidth; + WORD scanWidth; + WORD scanHeight; + + if(!isOkay())return scanLines; + scanLineWidth=width(); + if(scanLineWidth%2L)scanLineWidth++; + scanWidth=scanLineWidth; + scanHeight=height(); + bitmapBytes.size(scanLineWidth*(DWORD)height()*(bitsPerPixel/8)); + purePalette.systemPalette(); + bmInfo.width(width()); + bmInfo.height(height()); + bmInfo.bitCount(bitsPerPixel); + if(BitmapInfo::Bit8==bitsPerPixel){bmInfo.colorUsed(256);bmInfo.colorImportant(256);} + else{bmInfo.colorUsed(0);bmInfo.colorImportant(0);} + pureDevice.displayDevice(); + scanLines=::GetDIBits(pureDevice,*this,0,bottomUp?height():int(height())*-1,(BYTE*)&bitmapBytes[0],(BITMAPINFO*)bmInfo,DIB_RGB_COLORS); + if(BitmapInfo::Bit8==bitsPerPixel){bmInfo.colorUsed(256);bmInfo.colorImportant(256);purePalette=bmInfo;} + return scanLines; +} + +bool PureBitmap::getBitmapInfo(BitmapInfo &bmInfo) +{ + PureDevice pureDevice; + PurePalette systemPalette; + int scanLines=0; + + if(!isOkay())return scanLines; + systemPalette.systemPalette(); + bmInfo.width(width()); + bmInfo.height(height()); + bmInfo.bitCount(BitmapInfo::BitsPerPixel(bitsPerPixel())); + bmInfo=systemPalette; + pureDevice.displayDevice(); + scanLines=::GetDIBits(pureDevice,*this,0,height(),0,(BITMAPINFO*)bmInfo,DIB_RGB_COLORS); + return scanLines; +} + +DWORD PureBitmap::getBitmapBits(GlobalData &bitmapBytes,BOOL bottomUp)const +{ + PurePalette systemPalette; + PureDevice pureDevice; + BitmapInfo bmInfo; + DWORD scanLines(0); + DWORD scanLineWidth; + WORD scanWidth; + WORD scanHeight; + + if(!isOkay())return scanLines; + scanLineWidth=width(); + if(scanLineWidth%2L)scanLineWidth++; + scanWidth=scanLineWidth; + scanHeight=height(); + bitmapBytes.size(scanLineWidth*(DWORD)height()*(mBitmap.bmBitsPixel/8)); + systemPalette.systemPalette(); + bmInfo.width(width()); + bmInfo.height(height()); + bmInfo.bitCount(BitmapInfo::BitsPerPixel(bitsPerPixel())); + bmInfo=systemPalette; + pureDevice.displayDevice(); + scanLines=::GetDIBits(pureDevice,*this,0,bottomUp?height():int(height())*-1,(BYTE*)&bitmapBytes[0],(BITMAPINFO*)bmInfo,DIB_RGB_COLORS); + return scanLines; +} + +DWORD PureBitmap::setBitmapBits(GlobalData &bitmapBytes,BOOL bottomUp)const +{ + DWORD scanLines(0); + DWORD scanLineWidth; + DWORD scanWidth; + DWORD scanHeight; + PureDevice pureDevice; + BitmapInfo bmInfo; + + if(!isOkay())return scanLines; + scanLineWidth=width(); + if(scanLineWidth%2L)scanLineWidth++; + scanWidth=scanLineWidth; + scanHeight=height(); + bitmapBytes.size(scanLineWidth*(DWORD)height()*(mBitmap.bmBitsPixel/8)); + PurePalette systemPalette; + systemPalette.systemPalette(); + bmInfo.width(width()); + bmInfo.height(height()); + bmInfo.bitCount(BitmapInfo::BitsPerPixel(bitsPerPixel())); + bmInfo=systemPalette; + pureDevice.displayDevice(); + scanLines=::SetDIBits(pureDevice,*this,0,bottomUp?height():int(height())*-1,(BYTE*)&bitmapBytes[0],(BITMAPINFO*)bmInfo,DIB_RGB_COLORS); + if(!scanLines)scanLines=::GetLastError(); + return scanLines; +} diff --git a/common/PUREBYTE.CPP b/common/PUREBYTE.CPP new file mode 100644 index 0000000..80198e6 --- /dev/null +++ b/common/PUREBYTE.CPP @@ -0,0 +1,15 @@ +#include + +PureBYTE PureBYTE::operator++(int /*postFixDummy*/) +{ + PureBYTE postBYTE(*this); + mBYTE++; + return postBYTE; +} + +PureBYTE PureBYTE::operator--(int /*postFixDummy*/) +{ + PureBYTE postBYTE(*this); + mBYTE--; + return postBYTE; +} diff --git a/common/PUREBYTE.HPP b/common/PUREBYTE.HPP new file mode 100644 index 0000000..17d7084 --- /dev/null +++ b/common/PUREBYTE.HPP @@ -0,0 +1,131 @@ +#ifndef _COMMON_PUREBYTE_HPP_ +#define _COMMON_PUREBYTE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class PureBYTE +{ +public: + PureBYTE(void); + PureBYTE(BYTE someBYTE); + PureBYTE(const PureBYTE &somePureBYTE); + virtual ~PureBYTE(); + PureBYTE &operator=(const PureBYTE &somePureBYTE); + WORD operator==(const PureBYTE &somePureBYTE)const; + WORD operator<(const PureBYTE &somePureBYTE)const; + WORD operator<=(const PureBYTE &somePureBYTE)const; + WORD operator>(const PureBYTE &somePureBYTE)const; + WORD operator>=(const PureBYTE &somePureBYTE)const; + PureBYTE &operator+=(const PureBYTE &somePureBYTE); + PureBYTE &operator-=(const PureBYTE &somePureBYTE); + PureBYTE &operator++(void); + PureBYTE &operator--(void); + PureBYTE operator++(int postFixDummy); + PureBYTE operator--(int postFixDummy); + operator BYTE(void); + BYTE value(void)const; +private: + BYTE mBYTE; +}; + +inline +PureBYTE::PureBYTE(void) +: mBYTE(0L) +{ +} + +inline +PureBYTE::PureBYTE(BYTE someBYTE) +: mBYTE(someBYTE) +{ +} + +inline +PureBYTE::PureBYTE(const PureBYTE &somePureBYTE) +{ + *this=somePureBYTE; +} + +inline +PureBYTE::~PureBYTE() +{ +} + +inline +PureBYTE &PureBYTE::operator=(const PureBYTE &somePureBYTE) +{ + mBYTE=somePureBYTE.mBYTE; + return *this; +} + +inline +WORD PureBYTE::operator==(const PureBYTE &somePureBYTE)const +{ + return mBYTE==somePureBYTE.mBYTE; +} + +inline +WORD PureBYTE::operator<(const PureBYTE &somePureBYTE)const +{ + return mBYTE(const PureBYTE &somePureBYTE)const +{ + return mBYTE>somePureBYTE.mBYTE; +} + +inline +WORD PureBYTE::operator>=(const PureBYTE &somePureBYTE)const +{ + return mBYTE>=somePureBYTE.mBYTE; +} + +inline +PureBYTE &PureBYTE::operator++(void) +{ + mBYTE++; + return *this; +} + +inline +PureBYTE &PureBYTE::operator+=(const PureBYTE &somePureBYTE) +{ + mBYTE+=somePureBYTE.mBYTE; + return *this; +} + +inline +PureBYTE &PureBYTE::operator-=(const PureBYTE &somePureBYTE) +{ + mBYTE-=somePureBYTE.mBYTE; + return *this; +} + +inline +PureBYTE &PureBYTE::operator--(void) +{ + mBYTE--; + return *this; +} + +inline +BYTE PureBYTE::value(void)const +{ + return mBYTE; +} + +inline +PureBYTE::operator BYTE (void) +{ + return mBYTE; +} +#endif \ No newline at end of file diff --git a/common/PUREDBL.CPP b/common/PUREDBL.CPP new file mode 100644 index 0000000..a16a2e6 --- /dev/null +++ b/common/PUREDBL.CPP @@ -0,0 +1,16 @@ +#include + +PureDOUBLE PureDOUBLE::operator++(int /*postFixDummy*/) +{ + PureDOUBLE postDOUBLE(*this); + mDOUBLE++; + return postDOUBLE; +} + +PureDOUBLE PureDOUBLE::operator--(int /*postFixDummy*/) +{ + PureDOUBLE postDOUBLE(*this); + mDOUBLE--; + return postDOUBLE; +} + diff --git a/common/PUREDBL.HPP b/common/PUREDBL.HPP new file mode 100644 index 0000000..d2ad90b --- /dev/null +++ b/common/PUREDBL.HPP @@ -0,0 +1,132 @@ +#ifndef _COMMON_PUREDOUBLE_HPP_ +#define _COMMON_PUREDOUBLE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class PureDOUBLE +{ +public: + PureDOUBLE(void); + PureDOUBLE(double someDOUBLE); + PureDOUBLE(const PureDOUBLE &somePureDOUBLE); + virtual ~PureDOUBLE(); + PureDOUBLE &operator=(const PureDOUBLE &somePureDOUBLE); + PureDOUBLE &operator=(double someDOUBLE); + BOOL operator==(const PureDOUBLE &somePureDOUBLE)const; + BOOL operator<(const PureDOUBLE &somePureDOUBLE)const; + BOOL operator<=(const PureDOUBLE &somePureDOUBLE)const; + BOOL operator>(const PureDOUBLE &somePureDOUBLE)const; + BOOL operator>=(const PureDOUBLE &somePureDOUBLE)const; + PureDOUBLE &operator+=(const PureDOUBLE &somePureDOUBLE); + PureDOUBLE &operator-=(const PureDOUBLE &somePureDOUBLE); + PureDOUBLE &operator++(void); + PureDOUBLE &operator--(void); + PureDOUBLE operator++(int postFixDummy); + PureDOUBLE operator--(int postFixDummy); + operator double(void); +private: + double mDOUBLE; +}; + +inline +PureDOUBLE::PureDOUBLE(void) +: mDOUBLE(0.00) +{ +} + +inline +PureDOUBLE::PureDOUBLE(double someDOUBLE) +: mDOUBLE(someDOUBLE) +{ +} + +inline +PureDOUBLE::PureDOUBLE(const PureDOUBLE &somePureDOUBLE) +{ + *this=somePureDOUBLE; +} + +inline +PureDOUBLE::~PureDOUBLE() +{ +} + +inline +PureDOUBLE &PureDOUBLE::operator=(const PureDOUBLE &somePureDOUBLE) +{ + mDOUBLE=somePureDOUBLE.mDOUBLE; + return *this; +} + +inline +PureDOUBLE &PureDOUBLE::operator=(double someDOUBLE) +{ + mDOUBLE=someDOUBLE; + return *this; +} + +inline +BOOL PureDOUBLE::operator==(const PureDOUBLE &somePureDOUBLE)const +{ + return mDOUBLE==somePureDOUBLE.mDOUBLE; +} + +inline +BOOL PureDOUBLE::operator<(const PureDOUBLE &somePureDOUBLE)const +{ + return mDOUBLE(const PureDOUBLE &somePureDOUBLE)const +{ + return mDOUBLE>somePureDOUBLE.mDOUBLE; +} + +inline +BOOL PureDOUBLE::operator>=(const PureDOUBLE &somePureDOUBLE)const +{ + return mDOUBLE>=somePureDOUBLE.mDOUBLE; +} + +inline +PureDOUBLE &PureDOUBLE::operator++(void) +{ + mDOUBLE++; + return *this; +} + +inline +PureDOUBLE &PureDOUBLE::operator--(void) +{ + mDOUBLE--; + return *this; +} + +inline +PureDOUBLE &PureDOUBLE::operator+=(const PureDOUBLE &somePureDOUBLE) +{ + mDOUBLE+=somePureDOUBLE.mDOUBLE; + return *this; +} + +inline +PureDOUBLE &PureDOUBLE::operator-=(const PureDOUBLE &somePureDOUBLE) +{ + mDOUBLE-=somePureDOUBLE.mDOUBLE; + return *this; +} + +inline +PureDOUBLE::operator double (void) +{ + return mDOUBLE; +} +#endif diff --git a/common/PUREDWRD.CPP b/common/PUREDWRD.CPP new file mode 100644 index 0000000..4c6ed07 --- /dev/null +++ b/common/PUREDWRD.CPP @@ -0,0 +1,16 @@ +#include + +PureDWORD PureDWORD::operator++(int /*postFixDummy*/) +{ + PureDWORD postDWORD(*this); + mDWORD++; + return postDWORD; +} + +PureDWORD PureDWORD::operator--(int /*postFixDummy*/) +{ + PureDWORD postDWORD(*this); + mDWORD--; + return postDWORD; +} + diff --git a/common/PUREDWRD.HPP b/common/PUREDWRD.HPP new file mode 100644 index 0000000..cff71d0 --- /dev/null +++ b/common/PUREDWRD.HPP @@ -0,0 +1,139 @@ +#ifndef _COMMON_PUREDWORD_HPP_ +#define _COMMON_PUREDWORD_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class PureDWORD +{ +public: + PureDWORD(void); + PureDWORD(DWORD someDWORD); + PureDWORD(const PureDWORD &somePureDWORD); + virtual ~PureDWORD(); + PureDWORD &operator=(const PureDWORD &somePureDWORD); + PureDWORD &operator=(DWORD someDWORD); + WORD operator==(const PureDWORD &somePureDWORD)const; + WORD operator<(const PureDWORD &somePureDWORD)const; + WORD operator<=(const PureDWORD &somePureDWORD)const; + WORD operator>(const PureDWORD &somePureDWORD)const; + WORD operator>=(const PureDWORD &somePureDWORD)const; + PureDWORD &operator+=(const PureDWORD &somePureDWORD); + PureDWORD &operator-=(const PureDWORD &somePureDWORD); + PureDWORD &operator++(void); + PureDWORD &operator--(void); + PureDWORD operator++(int postFixDummy); + PureDWORD operator--(int postFixDummy); + DWORD getValue(void)const; + void setValue(DWORD value); +private: + DWORD mDWORD; +}; + +inline +PureDWORD::PureDWORD(void) +: mDWORD(0L) +{ +} + +inline +PureDWORD::PureDWORD(DWORD someDWORD) +: mDWORD(someDWORD) +{ +} + +inline +PureDWORD::PureDWORD(const PureDWORD &somePureDWORD) +{ + *this=somePureDWORD; +} + +inline +PureDWORD::~PureDWORD() +{ +} + +inline +PureDWORD &PureDWORD::operator=(const PureDWORD &somePureDWORD) +{ + mDWORD=somePureDWORD.mDWORD; + return *this; +} + +inline +PureDWORD &PureDWORD::operator=(DWORD someDWORD) +{ + mDWORD=someDWORD; + return *this; +} + +inline +WORD PureDWORD::operator==(const PureDWORD &somePureDWORD)const +{ + return mDWORD==somePureDWORD.mDWORD; +} + +inline +WORD PureDWORD::operator<(const PureDWORD &somePureDWORD)const +{ + return mDWORD(const PureDWORD &somePureDWORD)const +{ + return mDWORD>somePureDWORD.mDWORD; +} + +inline +WORD PureDWORD::operator>=(const PureDWORD &somePureDWORD)const +{ + return mDWORD>=somePureDWORD.mDWORD; +} + +inline +PureDWORD &PureDWORD::operator++(void) +{ + mDWORD++; + return *this; +} + +inline +PureDWORD &PureDWORD::operator--(void) +{ + mDWORD--; + return *this; +} + +inline +PureDWORD &PureDWORD::operator+=(const PureDWORD &somePureDWORD) +{ + mDWORD+=somePureDWORD.mDWORD; + return *this; +} + +inline +PureDWORD &PureDWORD::operator-=(const PureDWORD &somePureDWORD) +{ + mDWORD-=somePureDWORD.mDWORD; + return *this; +} + +inline +DWORD PureDWORD::getValue(void)const +{ + return mDWORD; +} + +inline +void PureDWORD::setValue(DWORD value) +{ + mDWORD=value; +} +#endif diff --git a/common/PUREHDC.CPP b/common/PUREHDC.CPP new file mode 100644 index 0000000..a1368b2 --- /dev/null +++ b/common/PUREHDC.CPP @@ -0,0 +1,436 @@ +#include +#include +#include +#include + +PureDevice::PureDevice(const Window &someWindow) +: mhDC(0), mhParent((HWND)someWindow), mDisposition(ReleaseDC), mGDIObjPrev(0), mPrevDrawMode(INVALIDROP) +{ + if(!mhParent||!::IsWindow(mhParent))return; + mhDC=::GetDC(mhParent); +} + +PureDevice::~PureDevice() +{ + unselect(); + destroyDevice(); +} + +WORD PureDevice::isOkay(void)const +{ + switch(mDisposition) + { + case DeleteDC : + case AssumedDC : + return (mhDC?TRUE:FALSE); + case ReleaseDC : + return (mhDC&&(mhParent?::IsWindow(mhParent):TRUE)); + case InvalidDC : + default : + return FALSE; + } +} + +void PureDevice::destroyDevice(void) +{ + if(mhDC) + { + setDrawMode(INVALIDROP); + if(DeleteDC==mDisposition&&isOkay())::DeleteDC(mhDC); + else if(ReleaseDC==mDisposition&&isOkay())::ReleaseDC(mhParent,mhDC); + mhDC=0; + mhParent=0; + mDisposition=InvalidDC; + } +} + +WORD PureDevice::select(const GDIObj someGDIObj,WORD selState) +{ + if(!isOkay()||!someGDIObj)return FALSE; + if(selState) + { + if(mGDIObjPrev)::SelectObject(mhDC,mGDIObjPrev); + mGDIObjPrev=::SelectObject(mhDC,someGDIObj); + return TRUE; + } + if(!mGDIObjPrev)return FALSE; + ::SelectObject(mhDC,mGDIObjPrev); + mGDIObjPrev=0; + return TRUE; +} + +WORD PureDevice::compatibleDevice(const PureDevice &somePureDevice) +{ + if(!somePureDevice.isOkay())return FALSE; + destroyDevice(); + mhDC=::CreateCompatibleDC((HDC)somePureDevice); + mDisposition=DeleteDC; + return isOkay(); +} + +WORD PureDevice::compatibleDevice(void) +{ + destroyDevice(); + mhDC=::CreateCompatibleDC(0); + mDisposition=DeleteDC; + return isOkay(); +} + +WORD PureDevice::displayDevice(void) +{ + destroyDevice(); + mhDC=::CreateDC("DISPLAY",0,0,0); + mDisposition=DeleteDC; + return isOkay(); +} + +WORD PureDevice::screenDevice(void) +{ + destroyDevice(); + mhDC=::GetDC(0); + mDisposition=ReleaseDC; + return isOkay(); +} + +WORD PureDevice::roundRectangle(const Point ¢erPoint,int radius) +{ + if(!isOkay())return false; + Point upperLeft; + Point lowerRight; + int diameter; + + diameter=radius*2; + upperLeft.x(centerPoint.x()-radius); + upperLeft.y(centerPoint.y()-radius); + lowerRight.x(centerPoint.x()+radius); + lowerRight.y(centerPoint.y()+radius); + return roundRectangle(upperLeft,lowerRight,diameter,diameter); +} + +WORD PureDevice::floodFill(const Point &xyPoint,const RGBColor &fillColor,const RGBColor &boundaryColor)const +{ + HBRUSH hFillBrush(::CreateSolidBrush(fillColor)); + HBRUSH hPrevBrush((HBRUSH)::SelectObject(mhDC,hFillBrush)); + WORD returnCode; + + returnCode=::FloodFill(mhDC,xyPoint.x(),xyPoint.y(),boundaryColor); + ::SelectObject(mhDC,hPrevBrush); + ::DeleteObject(hFillBrush); + return returnCode; +} + +BOOL PureDevice::fillRect(const Rect &rect,Brush &brush) +{ + if(!isOkay())return FALSE; + return ::FillRect(mhDC,(RECT*)((Rect&)rect),(HBRUSH)(GDIObj)brush); +} + +WORD PureDevice::colorRect(const Rect &rect,const RGBColor &lineColor)const +{ + if(!isOkay())return FALSE; + for(short index=rect.left();index<=rect.right();index++) + line(Point(index,rect.bottom()),Point(index,rect.top()),lineColor); + return TRUE; +} + +WORD PureDevice::circle(Window &displayWindow,const Point &xyPoint,WORD radius,const RGBColor &someRGBColor)const +{ + return circle(aspectValue(displayWindow),xyPoint,radius,someRGBColor); +} + +WORD PureDevice::outlineRect(const Rect &rect,const Pen &pen) +{ + Point p1; + Point p2; + + if(!isOkay())return FALSE; + p1.x(rect.left()); + p1.y(rect.top()); + p2.x(rect.right()); + p2.y(rect.top()); + line(p1,p2,pen); + + p1.x(rect.right()); + p1.y(rect.top()); + p2.x(rect.right()); + p2.y(rect.bottom()); + line(p1,p2,pen); + + p1.x(rect.right()); + p1.y(rect.bottom()); + p2.x(rect.left()); + p2.y(rect.bottom()); + line(p1,p2,pen); + + p1.x(rect.left()); + p1.y(rect.bottom()); + p2.x(rect.left()); + p2.y(rect.top()); + line(p1,p2,pen); + return TRUE; +} + +WORD PureDevice::line(const Point &firstPoint,const Point &secondPoint,const Pen &somePen)const +{ + if(!isOkay())return FALSE; + HPEN hPrevPen((HPEN)::SelectObject(mhDC,(HPEN)somePen)); + lineDraw(firstPoint,secondPoint); + ::SelectObject(mhDC,hPrevPen); + return TRUE; +} + +WORD PureDevice::line(const Point &firstPoint,const Point &secondPoint)const +{ + if(!isOkay())return FALSE; + lineDraw(firstPoint,secondPoint); + return TRUE; +} + +WORD PureDevice::crossHair(const Point &midPoint,WORD sectionLength,const Pen &somePen) +{ + Point leftPoint(midPoint); + Point topPoint(midPoint); + Point rightPoint(midPoint); + Point bottomPoint(midPoint); + HPEN hPrevPen; + + if(!isOkay())return FALSE; + hPrevPen=(HPEN)::SelectObject(mhDC,(HPEN)somePen); + leftPoint.x(leftPoint.x()-sectionLength); + rightPoint.x(rightPoint.x()+sectionLength); + topPoint.y(topPoint.y()-sectionLength); + bottomPoint.y(bottomPoint.y()+sectionLength); + lineDraw(leftPoint,rightPoint); + lineDraw(topPoint,bottomPoint); + ::SelectObject(mhDC,hPrevPen); + return TRUE; +} + +WORD PureDevice::crossHairs(Array &midPoints,WORD sectionLength,const Pen &somePen) +{ + WORD itemCount; + Point leftPoint; + Point topPoint; + Point rightPoint; + Point bottomPoint; + HPEN hPrevPen; + + if(!isOkay()||!(itemCount=midPoints.size()))return FALSE; + hPrevPen=(HPEN)::SelectObject(mhDC,(HPEN)somePen); + for(short itemIndex=0;itemIndex &midPoints,WORD sectionLength,RGBColor rgbColor) +{ + WORD itemCount; + Point leftPoint; + Point topPoint; + Point rightPoint; + Point bottomPoint; + + if(!isOkay()||!(itemCount=midPoints.size()))return FALSE; + for(short itemIndex=0;itemIndex=b) + { + b=(int)(Math::sqrt(radiusSquared-(a*a))+.50); + int temp(target); + target=b; + b=temp; + while(b>0x01); + Point topLeft; + Point topRight; + Point bottomLeft; + Point bottomRight; + + if(!isOkay())return FALSE; + topLeft.x(centerPoint.x()-halfLength); + topLeft.y(centerPoint.y()-halfLength); + topRight.x(centerPoint.x()+halfLength); + topRight.y(centerPoint.y()-halfLength); + bottomRight.x(centerPoint.x()+halfLength); + bottomRight.y(centerPoint.y()+halfLength); + bottomLeft.x(centerPoint.x()-halfLength); + bottomLeft.y(centerPoint.y()+halfLength); + line(topLeft,topRight,rgbColor); + line(topRight,bottomRight,rgbColor); + line(bottomRight,bottomLeft,rgbColor); + line(bottomLeft,topLeft,rgbColor); + return TRUE; +} + +WORD PureDevice::line(const Point &firstPoint,const Point &secondPoint,const RGBColor &rgbColor)const +{ + LONG xRunning(firstPoint.x()); + LONG yRunning(firstPoint.y()); + LONG xDelta; + LONG yDelta; + short xDir(1); + short yDir(1); + short steps; + + if(!isOkay())return FALSE; + xRunning<<=0x10; + yRunning<<=0x10; + if(secondPoint.x()>0x10,yRunning>>0x10),rgbColor); + xRunning-=xDelta; + yRunning-=yDelta; + } + } + else if(-1==xDir&&1==yDir) + { + for(short stepIndex=0;stepIndex>0x10,yRunning>>0x10),rgbColor); + xRunning-=xDelta; + yRunning+=yDelta; + } + } + else if(1==xDir&&-1==yDir) + { + for(short itemIndex=0;itemIndex>0x10,yRunning>>0x10),rgbColor); + xRunning+=xDelta; + yRunning-=yDelta; + } + } + else if(1==xDir&&1==yDir) + { + for(short itemIndex=0;itemIndex>0x10,yRunning>>0x10),rgbColor); + xRunning+=xDelta; + yRunning+=yDelta; + } + } + return TRUE; +} + diff --git a/common/PUREICON.HPP b/common/PUREICON.HPP new file mode 100644 index 0000000..958c4af --- /dev/null +++ b/common/PUREICON.HPP @@ -0,0 +1,123 @@ +#ifndef _COMMON_PUREICON_HPP_ +#define _COMMON_PUREICON_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PUREDEVICE_HPP_ +#include +#endif +#ifndef _COMMON_POINT_HPP_ +#include +#endif +#ifndef _COMMON_ICONINFO_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class PureIcon : public IconInfo +{ +public: + PureIcon(void); + PureIcon(HICON hIcon); + PureIcon(HINSTANCE hProcessInstance,const String &iconName); + PureIcon(const PureIcon &somePureIcon); + virtual ~PureIcon(); + PureIcon &operator=(const PureIcon &somePureIcon); + WORD operator==(const PureIcon &somePureIcon)const; + WORD drawIcon(PureDevice &somePureDevice,const Point &xyPoint); + operator HICON(void)const; + WORD isOkay(void)const; +private: + void getIconInfo(void); + void destroyIconInfo(void); + HICON mhIcon; +}; + +inline +PureIcon::PureIcon(void) +: mhIcon(0) +{ +} + +inline +PureIcon::PureIcon(HICON hIcon) +: mhIcon(hIcon) +{ + getIconInfo(); +} + +inline +PureIcon::PureIcon(HINSTANCE hProcessInstance,const String &iconName) +: mhIcon(0) +{ + if(iconName.isNull())return; + mhIcon=::LoadIcon(hProcessInstance,iconName); + getIconInfo(); + return; +} + +inline +PureIcon::PureIcon(const PureIcon &somePureIcon) +{ + *this=somePureIcon; +} + +inline +PureIcon::~PureIcon() +{ + destroyIconInfo(); +} + +inline +PureIcon &PureIcon::operator=(const PureIcon &somePureIcon) +{ + if(somePureIcon.isOkay()) + { + mhIcon=(HICON)somePureIcon; + getIconInfo(); + } + return *this; +} + +inline +WORD PureIcon::operator==(const PureIcon &somePureIcon)const +{ + return (HICON)*this==(HICON)somePureIcon; +} + +inline +PureIcon::operator HICON(void)const +{ + return mhIcon; +} + +inline +WORD PureIcon::drawIcon(PureDevice &somePureDevice,const Point &xyPoint) +{ + if(!isOkay())return FALSE; + return ::DrawIcon(somePureDevice,xyPoint.x(),xyPoint.y(),mhIcon); +} + +inline +void PureIcon::getIconInfo(void) +{ + if(!isOkay())return; + destroyIconInfo(); + ::GetIconInfo(mhIcon,&((_ICONINFO&)((IconInfo&)*this))); +} + +inline +void PureIcon::destroyIconInfo(void) +{ + if(maskBitmap()){::DeleteObject(maskBitmap());maskBitmap(0);} + if(colorBitmap()){::DeleteObject(colorBitmap());colorBitmap(0);} +} + +inline +WORD PureIcon::isOkay(void)const +{ + return (mhIcon?TRUE:FALSE); +} +#endif diff --git a/common/PUREMENU.CPP b/common/PUREMENU.CPP new file mode 100644 index 0000000..ad27fef --- /dev/null +++ b/common/PUREMENU.CPP @@ -0,0 +1,170 @@ +#include +#include + +PureMenu &PureMenu::operator=(const String &menuName) +{ + destroyMenu(); + mhPureMenu=::LoadMenu(::GetModuleHandle(0),(char*)(String&)menuName); + mDisposition=Delete; + return *this; +} + +PureMenu &PureMenu::operator=(const PureMenu &somePureMenu) +{ + WORD itemEntries; + UINT itemID; + + if(!somePureMenu.isOkay())return *this; + itemEntries=somePureMenu.size(); + mMenuStyle=somePureMenu.mMenuStyle; + createMenu(); + for(short itemIndex=0;itemIndex &menuItems)const +{ + WORD itemCount(menuItems.size()); + + if(!isOkay())return FALSE; + for(short itemIndex=0;itemIndex +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PUREBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_PUREDEVICE_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _COMMON_PALETTEENTRY_HPP_ +#include +#endif +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif + +class BitmapInfo; + +class PurePalette +{ +public: + enum {MaxColors=256}; + enum InitPal{InitSys,InitNone}; + typedef int PaletteIndex; + PurePalette(InitPal initPal=InitNone); + PurePalette(HPALETTE hPalette); + PurePalette(const String &strPathFileName); + PurePalette(const PurePalette &somePurePalette); + PurePalette(const BitmapInfo &someBitmapInfo); + virtual ~PurePalette(); + PurePalette &operator=(const PurePalette &somePurePalette); + PurePalette &operator=(const BitmapInfo &someBitmapInfo); + PurePalette &operator=(HPALETTE hPalette); + PurePalette &operator=(const String &strPathFileName); + PurePalette &operator=(const Array &paletteData); + PaletteEntry &operator[](PaletteIndex paletteIndex); + WORD operator==(const PurePalette &somePurePalette)const; + WORD identityPalette(void); + WORD systemPalette(bool useStandardColors=false); + WORD isIdentityPalette(void)const; + void cyclePalette(void); + PaletteIndex paletteIndex(const RGBColor &someRGBColor)const; + void getPaletteColors(Array &someRGBColors)const; + void setPaletteColors(Array &someRGBColors,PaletteEntry::PaletteFlags paletteFlag=PaletteEntry::NullFlag); + WORD setPaletteColor(short paletteIndex,RGBColor &someRGBColor,PaletteEntry::PaletteFlags paletteFlag=PaletteEntry::NullFlag); + WORD getPaletteColor(short paletteIndex,RGBColor &someRGBColor)const; + void clearPalette(void); + void usePalette(const PureDevice &somePureDevice,short usage); + WORD paletteEntry(PaletteIndex paletteIndex,RGBColor &someRGBColor)const; + RGBColor paletteEntry(PaletteIndex paletteIndex)const; + DWORD paletteEntries(void)const; + void paletteEntries(DWORD palEntries); + WORD isInUse(void)const; + BOOL readPalette(const String &strPathFileName); + BOOL writePalette(const String &strPathFileName); + HPALETTE getPalette(void)const; +private: + enum {SystemStaticColors=20}; + WORD createPalette(void); + void setPaletteColors(void)const; + void destroyPalette(void); + + HPALETTE mhPalette; + HPALETTE mhOldPalette; + Array mPaletteData; + WORD mIsInUse; +}; + +inline +PurePalette::PurePalette(InitPal initPal) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + mPaletteData.size(MaxColors); + if(InitSys==initPal)systemPalette(); + else createPalette(); + return; +} + +inline +PurePalette::~PurePalette() +{ + destroyPalette(); + return; +} + +inline +DWORD PurePalette::paletteEntries(void)const +{ + return mPaletteData.size(); +} + +inline +void PurePalette::paletteEntries(DWORD palEntries) +{ + mPaletteData.size(palEntries); + createPalette(); +} + +inline +void PurePalette::setPaletteColors(void)const +{ + ::SetPaletteEntries(mhPalette,0,paletteEntries(),(PALETTEENTRY FAR*)&((PurePalette&)*this).mPaletteData[0]); +} + +inline +WORD PurePalette::isInUse(void)const +{ + return mIsInUse; +} + +inline +PurePalette::PaletteIndex PurePalette::paletteIndex(const RGBColor &someRGBColor)const +{ + return ::GetNearestPaletteIndex(mhPalette,(COLORREF)someRGBColor); +} + +inline +PaletteEntry &PurePalette::operator[](PaletteIndex paletteIndex) +{ + if(paletteIndex>=paletteEntries())throw(BoundaryError()); + return mPaletteData[paletteIndex]; +} + +inline +HPALETTE PurePalette::getPalette(void)const +{ + return mhPalette; +} +#endif + diff --git a/common/PUREPRCS.HPP b/common/PUREPRCS.HPP new file mode 100644 index 0000000..f8c7120 --- /dev/null +++ b/common/PUREPRCS.HPP @@ -0,0 +1,104 @@ +#ifndef _COMMON_PUREPROCESS_HPP_ +#define _COMMON_PUREPROCESS_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#endif + +#if !defined(__FLAT__) +struct PROCESS_INFORMATION +{ + HANDLE hProcess; + HANDLE hThread; + DWORD dwProcessId; + DWORD dwThreadId; +}; +#endif + +class PureProcess : private PROCESS_INFORMATION +{ +public: + PureProcess(void); + virtual ~PureProcess(); + operator HANDLE(void)const; + HANDLE getThread(void)const; + HANDLE getProcess(void)const; + DWORD getProcessID(void)const; + DWORD getThreadID(void)const; +protected: + void setThread(HANDLE handleThread); + void setProcess(HANDLE handleProcess); + void setProcessID(DWORD processID); + void setThreadID(DWORD threadID); +private: +}; + +inline +PureProcess::PureProcess(void) +{ + PROCESS_INFORMATION::hProcess=0; + PROCESS_INFORMATION::hThread=0; + PROCESS_INFORMATION::dwProcessId=0; + PROCESS_INFORMATION::dwThreadId=0; +} + +inline +PureProcess::~PureProcess() +{ +} + +inline +PureProcess::operator HANDLE(void)const +{ + return hProcess; +} + +inline +HANDLE PureProcess::getThread(void)const +{ + return hThread; +} + +inline +void PureProcess::setThread(HANDLE handleThread) +{ + hThread=handleThread; +} + +inline +HANDLE PureProcess::getProcess(void)const +{ + return hProcess; +} + +inline +void PureProcess::setProcess(HANDLE handleProcess) +{ + hProcess=handleProcess; +} + +inline +DWORD PureProcess::getProcessID(void)const +{ + return dwProcessId; +} + +inline +void PureProcess::setProcessID(DWORD processID) +{ + dwProcessId=processID; +} + +inline +DWORD PureProcess::getThreadID(void)const +{ + return dwThreadId; +} + +inline +void PureProcess::setThreadID(DWORD threadID) +{ + dwThreadId=threadID; +} +#endif diff --git a/common/PUREWRD.CPP b/common/PUREWRD.CPP new file mode 100644 index 0000000..5e62dad --- /dev/null +++ b/common/PUREWRD.CPP @@ -0,0 +1,16 @@ +#include + +PureWORD PureWORD::operator++(int /*postFixDummy*/) +{ + PureWORD postWORD(*this); + mWORD++; + return postWORD; +} + +PureWORD PureWORD::operator--(int /*postFixDummy*/) +{ + PureWORD postWORD(*this); + mWORD--; + return postWORD; +} + diff --git a/common/PUREWRD.HPP b/common/PUREWRD.HPP new file mode 100644 index 0000000..0be8535 --- /dev/null +++ b/common/PUREWRD.HPP @@ -0,0 +1,131 @@ +#ifndef _COMMON_PUREWORD_HPP_ +#define _COMMON_PUREWORD_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class PureWORD +{ +public: + PureWORD(void); + PureWORD(WORD someWORD); + PureWORD(const PureWORD &somePureWORD); + virtual ~PureWORD(); + PureWORD &operator=(const PureWORD &somePureWORD); + WORD operator==(const PureWORD &somePureWORD)const; + WORD operator<(const PureWORD &somePureWORD)const; + WORD operator<=(const PureWORD &somePureWORD)const; + WORD operator>(const PureWORD &somePureWORD)const; + WORD operator>=(const PureWORD &somePureWORD)const; + PureWORD &operator+=(const PureWORD &somePureWORD); + PureWORD &operator-=(const PureWORD &somePureWORD); + PureWORD &operator++(void); + PureWORD &operator--(void); + PureWORD operator++(int postFixDummy); + PureWORD operator--(int postFixDummy); + WORD getValue(void)const; + void setValue(WORD value); +private: + WORD mWORD; +}; + +inline +PureWORD::PureWORD(void) +: mWORD(0L) +{ +} + +inline +PureWORD::PureWORD(WORD someWORD) +: mWORD(someWORD) +{ +} + +inline +PureWORD::PureWORD(const PureWORD &somePureWORD) +{ + *this=somePureWORD; +} + +inline +PureWORD::~PureWORD() +{ +} + +inline +PureWORD &PureWORD::operator=(const PureWORD &somePureWORD) +{ + mWORD=somePureWORD.mWORD; + return *this; +} + +inline +WORD PureWORD::operator==(const PureWORD &somePureWORD)const +{ + return mWORD==somePureWORD.mWORD; +} + +inline +WORD PureWORD::operator<(const PureWORD &somePureWORD)const +{ + return mWORD(const PureWORD &somePureWORD)const +{ + return mWORD>somePureWORD.mWORD; +} + +inline +WORD PureWORD::operator>=(const PureWORD &somePureWORD)const +{ + return mWORD>=somePureWORD.mWORD; +} + +inline +PureWORD &PureWORD::operator++(void) +{ + mWORD++; + return *this; +} + +inline +PureWORD &PureWORD::operator+=(const PureWORD &somePureWORD) +{ + mWORD+=somePureWORD.mWORD; + return *this; +} + +inline +PureWORD &PureWORD::operator-=(const PureWORD &somePureWORD) +{ + mWORD-=somePureWORD.mWORD; + return *this; +} + +inline +PureWORD &PureWORD::operator--(void) +{ + mWORD--; + return *this; +} + +inline +WORD PureWORD::getValue(void)const +{ + return mWORD; +} + +inline +void PureWORD::setValue(WORD value) +{ + mWORD=value; +} +#endif diff --git a/common/PVIEW.CPP b/common/PVIEW.CPP new file mode 100644 index 0000000..3356c47 --- /dev/null +++ b/common/PVIEW.CPP @@ -0,0 +1,191 @@ +#if defined(__FLAT__) +#include + +void PureViewOfFile::createView(const FileMap &someFileMap) +{ + createView(someFileMap,0L,0L,someFileMap.maxExtentLow()); +} + +void PureViewOfFile::createView(const FileMap &someFileMap,DWORD offsetHigh,DWORD offsetLow,DWORD byteCount) +{ + Access accessRights; + SYSTEM_INFO systemInfo; + + destroyView(); + ::GetSystemInfo(&systemInfo); + if(FileMap::ReadOnly==someFileMap.paging())accessRights=Read; + else if(FileMap::ReadWrite==someFileMap.paging())accessRights=Write; + else accessRights=Copy; + if(offsetLow&&(offsetLow%systemInfo.dwAllocationGranularity)) + { + DWORD adjOffset((offsetLow/systemInfo.dwAllocationGranularity)*systemInfo.dwAllocationGranularity); + byteCount+=(offsetLow-adjOffset); + mnpFirstValidAddress=mnpPointer=::MapViewOfFile((HANDLE)someFileMap,accessRights,offsetHigh,adjOffset,byteCount); + mnpCursor=mnpFirstValidAddress; + mnpLastValidAddress=(BYTE*)mnpFirstValidAddress+(byteCount-1L); + seek(offsetLow-adjOffset,PureViewOfFile::SeekSet); + mnpFirstValidAddress=mnpCursor; + } + else + { + mnpFirstValidAddress=mnpPointer=::MapViewOfFile((HANDLE)someFileMap,accessRights,offsetHigh,offsetLow,byteCount); + mnpCursor=mnpFirstValidAddress; + mnpLastValidAddress=(BYTE*)mnpFirstValidAddress+(byteCount-1L); + } +} + +void PureViewOfFile::createView(DWORD byteCount,DWORD baseAddress) +{ + destroyView(); + mDisposition=Keep; + mnpFirstValidAddress=mnpPointer=(void*)baseAddress; + mnpCursor=mnpFirstValidAddress; + mnpLastValidAddress=(BYTE*)mnpFirstValidAddress+(byteCount-1L); +} + +void PureViewOfFile::destroyView(void) +{ + if(!mnpPointer)return; + if(Delete==mDisposition)::UnmapViewOfFile(mnpPointer); + mnpPointer=0; + mnpFirstValidAddress=0; + mnpLastValidAddress=0; + mnpCursor=0; + mDisposition=Delete; +} + +DWORD PureViewOfFile::peek(BYTE *npBuffer,DWORD sizeBuffer) +{ + BYTE *npPeekCursor=(BYTE*)mnpCursor; + + if(!npPeekCursor)return FALSE; + for(DWORD itemIndex=0;itemIndexmnpLastValidAddress)return itemIndex; + *(npBuffer+itemIndex)=*((BYTE*)npPeekCursor); + npPeekCursor=((BYTE*)npPeekCursor+sizeof(BYTE)); + } + return itemIndex; +} + +WORD PureViewOfFile::seek(DWORD seekPos,SeekMethod seekMethod) +{ + WORD returnCode(FALSE); + + switch(seekMethod) + { + case SeekSet : + if((char*)mnpFirstValidAddress+seekPos>mnpLastValidAddress)break; + mnpCursor=(char*)mnpFirstValidAddress+seekPos; + returnCode=TRUE; + break; + case SeekCurr : + if((char*)mnpCursor+seekPos>mnpLastValidAddress)break; + mnpCursor=(char*)mnpCursor+seekPos; + break; + case SeekEnd : + if((char*)mnpCursor-seekPosmnpLastValidAddress)return FALSE; + if(!::memcmp(npCursor,(char*)findString,stringLength)) + {mnpCursor=npCursor;return TRUE;} + } + npCursor++; + } + return FALSE; +} + +WORD PureViewOfFile::write(const String &lineString) +{ + DWORD lineLength(lineString.length()); + if(!lineLength)return FALSE; + for(DWORD colIndex=0;colIndex=blockLength-1) + { + *ptrLine=0; + String tmpString(lineString); + int nextIndex(ptrLine-(BYTE*)(char*)lineString); + lineString.reserve(blockLength+granularity); + ::memcpy((char*)lineString,(char*)tmpString,blockLength); + blockLength+=granularity; + ptrLine=(BYTE*)(char*)lineString+nextIndex; + } + if(CarriageReturn==charByte) + { + if(!read(charByte))break; + if(LineFeed==charByte) + { + *ptrLine=0; + return TRUE; + } + } + else if(NullChar==charByte) + { + *ptrLine++=0; + return bytesRead; + } + else + { + *ptrLine++=charByte; + bytesRead++; + } + } + return bytesRead; +} +#endif + + + diff --git a/common/PVIEW.HPP b/common/PVIEW.HPP new file mode 100644 index 0000000..e6de668 --- /dev/null +++ b/common/PVIEW.HPP @@ -0,0 +1,351 @@ +#if defined(__FLAT__) +#ifndef _COMMON_PUREVIEWOFFILE_HPP_ +#define _COMMON_PUREVIEWOFFILE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_FILEMAP_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_PUREDWORD_HPP_ +#include +#endif + +class PureViewOfFile +{ +public: + enum Access{Write=FILE_MAP_WRITE,Read=FILE_MAP_READ,Copy=FILE_MAP_COPY}; + enum SeekMethod{SeekSet,SeekCurr,SeekEnd}; + enum {CarriageReturn=0x0D,LineFeed=0x0A,NullChar=0x00}; + PureViewOfFile(void); + PureViewOfFile(const FileMap &someFileMap,DWORD offsetHigh,DWORD offsetLow,DWORD byteCount); + PureViewOfFile(const FileMap &someFileMap); + virtual ~PureViewOfFile(); + PureViewOfFile &operator+=(DWORD sizeIncrement); + PureViewOfFile &operator++(void); + PureViewOfFile &operator-=(DWORD sizeDecrement); + PureViewOfFile &operator--(void); + PureViewOfFile &operator--(int postFixDummy); + WORD seek(DWORD location,SeekMethod seekMethod=SeekCurr); + WORD write(BYTE someByte); + WORD write(WORD someWord); + WORD write(short someShort); + WORD write(int someInt); + WORD write(double someDouble); + WORD write(float someFloat); + WORD write(const String &someString); + WORD write(BYTE *npBuffer,DWORD sizeBuffer); + WORD read(BYTE &someByte); + WORD read(WORD &someWORD); + WORD read(DWORD &someDWORD); + WORD read(UINT &someUINT); + WORD read(int &someInt); + WORD read(double &someDouble); + WORD read(float &someFloat); + DWORD read(char *npBuffer,DWORD sizeBuffer); + WORD find(const String &findString); + WORD writeLine(const String &lineString); + DWORD getLine(String &lineString); + DWORD peek(BYTE *npBuffer,DWORD sizeBuffer); + WORD peek(BYTE &someByte); + WORD peek(int &someInt); + DWORD tell(void)const; + WORD push(void); + WORD pop(void); + DWORD base(void)const; + DWORD size(void)const; + WORD rewind(void); + BOOL flush(DWORD extent); + BOOL flush(void); + void destroyView(void); + void createView(const FileMap &someFileMap); + void createView(const FileMap &someFileMap,DWORD offsetHigh,DWORD offsetLow,DWORD byteCount); + void createView(DWORD byteCount,DWORD baseAddress); +protected: + void *getBasePointer(void); +private: + enum Disposition{Keep,Delete}; + PureViewOfFile(const PureViewOfFile &somePureViewOfFile); + void *mnpCursor; + void *mnpFirstValidAddress; + void *mnpLastValidAddress; + void *mnpPointer; + Block mViewPositions; + Disposition mDisposition; +}; + +inline +PureViewOfFile::PureViewOfFile(void) +: mnpCursor(0), mnpPointer(0), mnpFirstValidAddress(0), mnpLastValidAddress(0), mDisposition(Delete) +{ +} + +inline +PureViewOfFile::PureViewOfFile(const FileMap &someFileMap,DWORD offsetHigh,DWORD offsetLow,DWORD byteCount) +: mnpCursor(0), mnpPointer(0), mnpFirstValidAddress(0), mnpLastValidAddress(0), mDisposition(Delete) +{ + createView(someFileMap,offsetHigh,offsetLow,byteCount); +} + +inline +PureViewOfFile::PureViewOfFile(const FileMap &someFileMap) +: mnpCursor(0), mnpPointer(0), mnpFirstValidAddress(0), mnpLastValidAddress(0), mDisposition(Delete) +{ + createView(someFileMap,0L,0L,someFileMap.maxExtentLow()); +} + +inline +PureViewOfFile::~PureViewOfFile() +{ + destroyView(); +} + +inline +PureViewOfFile::PureViewOfFile(const PureViewOfFile &somePureViewOfFile) +: mDisposition(Delete) +{ +} + +inline +PureViewOfFile &PureViewOfFile::operator+=(DWORD sizeIncrement) +{ + if((char*)mnpCursor+sizeIncrement<=mnpLastValidAddress)mnpCursor=(char*)mnpCursor+sizeIncrement; + return *this; +} + +inline +PureViewOfFile &PureViewOfFile::operator++(void) +{ + return operator+=(1L); +} + +inline +PureViewOfFile &PureViewOfFile::operator-=(DWORD sizeDecrement) +{ + if((char*)mnpCursor-sizeDecrement>=mnpFirstValidAddress)mnpCursor=(char*)mnpCursor-sizeDecrement; + return *this; +} + +inline +PureViewOfFile &PureViewOfFile::operator--(void) +{ + return operator-=(1L); +} + +inline +PureViewOfFile &PureViewOfFile::operator--(int /*postFixDummy*/) +{ // postfix works the same as prefix + return operator-=(1L); +} + +inline +WORD PureViewOfFile::write(WORD someWord) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + *((WORD*)mnpCursor)=someWord; + mnpCursor=(char*)mnpCursor+sizeof(WORD); + return TRUE; +} + +inline +WORD PureViewOfFile::write(BYTE someByte) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + *((BYTE*)mnpCursor)=someByte; + mnpCursor=(char*)mnpCursor+sizeof(BYTE); + return TRUE; +} + +inline +WORD PureViewOfFile::write(int someInt) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + *((int*)mnpCursor)=someInt; + mnpCursor=(char*)mnpCursor+sizeof(int); + return TRUE; +} + +inline +WORD PureViewOfFile::write(short someShort) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + *((short*)mnpCursor)=someShort; + mnpCursor=(char*)mnpCursor+sizeof(short); + return TRUE; +} + +inline +WORD PureViewOfFile::write(double someDouble) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + *((double*)mnpCursor)=someDouble; + mnpCursor=(char*)mnpCursor+sizeof(double); + return TRUE; +} + +inline +WORD PureViewOfFile::write(float someFloat) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + *((float*)mnpCursor)=someFloat; + mnpCursor=(char*)mnpCursor+sizeof(float); + return TRUE; +} + +inline +WORD PureViewOfFile::read(BYTE &someBYTE) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + someBYTE=*((BYTE*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(BYTE); + return TRUE; +} + +inline +DWORD PureViewOfFile::read(char *npBuffer,DWORD sizeBuffer) +{ + if(!mnpCursor||mnpCursor>mnpLastValidAddress)return FALSE; + if((char*)mnpCursor+(sizeBuffer-1L)>(char*)mnpLastValidAddress) + sizeBuffer=((char*)mnpLastValidAddress-(char*)mnpCursor)+1L; + ::memcpy(npBuffer,(char*)mnpCursor,sizeBuffer); + mnpCursor=(char*)mnpCursor+sizeBuffer; + return sizeBuffer; +} + +inline +WORD PureViewOfFile::read(WORD &someWORD) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(WORD)>mnpLastValidAddress))return FALSE; + someWORD=*((WORD*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(WORD); + return TRUE; +} + +inline +WORD PureViewOfFile::read(DWORD &someDWORD) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(DWORD)>mnpLastValidAddress))return FALSE; + someDWORD=*((DWORD*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(DWORD); + return TRUE; +} + +inline +WORD PureViewOfFile::read(UINT &someUINT) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(UINT)>mnpLastValidAddress))return FALSE; + someUINT=*((UINT*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(UINT); + return TRUE; +} + +inline +WORD PureViewOfFile::read(int &someInt) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(int)>mnpLastValidAddress))return FALSE; + someInt=*((int*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(int); + return TRUE; +} + +inline +WORD PureViewOfFile::read(double &someDouble) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(double)>mnpLastValidAddress))return FALSE; + someDouble=*((double*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(double); + return TRUE; +} + +inline +WORD PureViewOfFile::read(float &someFloat) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(float)>mnpLastValidAddress))return FALSE; + someFloat=*((float*)mnpCursor); + mnpCursor=(char*)mnpCursor+sizeof(float); + return TRUE; +} + +inline +WORD PureViewOfFile::peek(BYTE &someByte) +{ + if(!mnpCursor||(mnpCursor>mnpLastValidAddress))return FALSE; + someByte=*((BYTE*)mnpCursor); + return TRUE; +} + +inline +WORD PureViewOfFile::peek(int &someInt) +{ + if(!mnpCursor||((char*)mnpCursor+sizeof(int)>mnpLastValidAddress))return FALSE; + someInt=*((int*)mnpCursor); + return TRUE; +} + +inline +WORD PureViewOfFile::rewind(void) +{ + if(!mnpCursor)return FALSE; + mnpCursor=mnpFirstValidAddress; + return TRUE; +} + +inline +DWORD PureViewOfFile::tell(void)const +{ + if(!mnpCursor)return FALSE; + return (DWORD)((char*)mnpCursor-(char*)mnpFirstValidAddress); +} + +inline +DWORD PureViewOfFile::base(void)const +{ + return (DWORD)mnpFirstValidAddress; +} + +inline +DWORD PureViewOfFile::size(void)const +{ + return ((BYTE*)mnpLastValidAddress-(BYTE*)mnpFirstValidAddress)+1L; +} + +inline +BOOL PureViewOfFile::flush(DWORD extent) +{ + return ::FlushViewOfFile(mnpFirstValidAddress,extent); +} + +inline +BOOL PureViewOfFile::flush(void) +{ + return flush(size()); +} + +inline +WORD PureViewOfFile::push(void) +{ + PureDWORD pureDWORD(tell()); + mViewPositions.insert(&pureDWORD); + return TRUE; +} + +inline +WORD PureViewOfFile::pop(void) +{ + if(!mViewPositions.size())return FALSE; + seek((mViewPositions[mViewPositions.size()-1].getValue()),SeekSet); + mViewPositions.remove(mViewPositions.size()-1); + return TRUE; +} + +inline +void *PureViewOfFile::getBasePointer(void) +{ + return mnpFirstValidAddress; +} +#endif +#endif + diff --git a/common/Pathfnd.hpp b/common/Pathfnd.hpp new file mode 100644 index 0000000..0223b28 --- /dev/null +++ b/common/Pathfnd.hpp @@ -0,0 +1,59 @@ +#ifndef _COMMON_PATHFIND_HPP_ +#define _COMMON_PATHFIND_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif +#ifndef _COMMON_FINDDATA_HPP_ +#include +#endif + +class PathFind +{ +public: + PathFind(void); + virtual ~PathFind(); + WORD findFile(const String &pureFileName,String &pathFileName); + WORD dirList(String pathEntry,Block &subDirList); + WORD fileList(String pathFileSpec,Block &entryList); + WORD getWindowsDirectory(String &windowsDirectoryString); + WORD getSystemDirectory(String &systemDirectoryString); + BOOL getWindowsTempDirectory(String &windowsTempDirectory); + BOOL getTempFileName(String &strPathTempFileName,const String &strPrefix=String()); +private: + enum {BackSlash='\\',ForwardSlash='/',Dot='.'}; + WORD getPathBlock(void); + WORD searchPath(String pathEntry,String pureFileName,String &pathFileName); + WORD searchPathTranscend(String pathEntry,String pureFileName,String &pathFileName); + WORD getPathTranscend(String pathEntry,Block &pathFileName); + WORD getDirectoryFileEntries(String pathEntry,Block &entryStrings); + WORD getDirEntries(String pathEntryFileSpec,Block &entryStrings); + WORD canTranscend(String &pathEntry); + void fixupPathName(String &pathEntry); + WORD isFile(const String &pathFileName); + WORD getWinDir(String &winDirString); + WORD getCurrDir(String &currDirString); + void subList(Block &subDirList,String pathEntry); + WORD isDirectory(FindData &findData); + BOOL hasWildCard(String &pathFileSpec)const; + BOOL hasPath(String &pathFileSpec)const; + void insertPath(String &pathFileSpec)const; + + FindData mFindData; + Block mPathEntry; + String mUpDirString; + String mCurrDirString; + String mBackSlashString; + String mStarDotStarString; + String mStarString; + String mPathString; + String mSemicolonString; + String mWinDirString; + WORD mIsOkay; +}; +#endif diff --git a/common/Pointer.hpp b/common/Pointer.hpp new file mode 100644 index 0000000..a2556b5 --- /dev/null +++ b/common/Pointer.hpp @@ -0,0 +1,159 @@ +#ifndef _COMMON_SMARTPOINTER_HPP_ +#define _COMMON_SMARTPOINTER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class PointerDisposition +{ +public: + enum Disposition{Assume,Delete}; +}; + +template +class SmartPointer +{ +public: + SmartPointer(void); + SmartPointer(T FAR *lpSmartPointer,PointerDisposition::Disposition disposition=PointerDisposition::Assume); + SmartPointer(const SmartPointer &someSmartPointer); + virtual ~SmartPointer(); + T FAR *operator->(void); + operator T FAR *(void); + operator LPARAM(void); + SmartPointer &operator=(const SmartPointer &someSmartPointer); + SmartPointer &operator=(T FAR *lpSmartPointer); + WORD operator==(const SmartPointer &someSmartPointer)const; + void disposition(PointerDisposition::Disposition disposition); + PointerDisposition::Disposition disposition(void)const; + void destroy(void); + bool isOkay(void)const; + bool isNull(void)const; +protected: + T **ppt(void); +private: + T FAR *mlpSmartPointer; + PointerDisposition::Disposition mDisposition; +}; + +template +inline +SmartPointer::SmartPointer(void) +: mlpSmartPointer(0), mDisposition(PointerDisposition::Assume) +{ +} + +template +inline +SmartPointer::SmartPointer(T FAR *lpSmartPointer,PointerDisposition::Disposition disposition) +: mlpSmartPointer(lpSmartPointer), mDisposition(disposition) +{ +} + +template +inline +SmartPointer::SmartPointer(const SmartPointer &someSmartPointer) +: mlpSmartPointer(0), mDisposition(PointerDisposition::Assume) +{ + *this=someSmartPointer; +} + +template +inline +SmartPointer::~SmartPointer() +{ + destroy(); +} + +template +inline +SmartPointer::operator T FAR *(void) +{ + return mlpSmartPointer; +} + +template +inline +T **SmartPointer::ppt(void) +{ + return &mlpSmartPointer; +} + +template +inline +SmartPointer::operator LPARAM(void) +{ + return (LPARAM)mlpSmartPointer; +} + +template +inline +T FAR *SmartPointer::operator->(void) +{ + return mlpSmartPointer; +} + +template +inline +SmartPointer &SmartPointer::operator=(const SmartPointer &someSmartPointer) +{ + destroy(); + mlpSmartPointer=someSmartPointer.mlpSmartPointer; + mDisposition=PointerDisposition::Assume; + return *this; +} + +template +inline +SmartPointer &SmartPointer::operator=(T FAR *lpSmartPointer) +{ + destroy(); + mlpSmartPointer=lpSmartPointer; + mDisposition=PointerDisposition::Assume; + return *this; +} + +template +inline +WORD SmartPointer::operator==(const SmartPointer &someSmartPointer)const +{ + return *mlpSmartPointer==*someSmartPointer.mlpSmartPointer; +} + +template +inline +void SmartPointer::destroy(void) +{ + if(!mlpSmartPointer)return; + if(PointerDisposition::Assume==mDisposition)mlpSmartPointer=0; + else {::delete mlpSmartPointer;mlpSmartPointer=0;} +} + +template +inline +void SmartPointer::disposition(PointerDisposition::Disposition disposition) +{ + mDisposition=disposition; +} + +template +inline +PointerDisposition::Disposition SmartPointer::disposition(void)const +{ + return mDisposition; +} + +template +inline +bool SmartPointer::isNull(void)const +{ + return (mlpSmartPointer?FALSE:TRUE); +} + +template +inline +bool SmartPointer::isOkay(void)const +{ + return !isNull(); +} +#endif diff --git a/common/Progress.cpp b/common/Progress.cpp new file mode 100644 index 0000000..8242235 --- /dev/null +++ b/common/Progress.cpp @@ -0,0 +1,285 @@ +#if defined(__FLAT__) +#include +#include +#include + +char Progress::szClassName[]="ProgressControlWindow"; +char Progress::szFontName[]="Helv"; + +Progress::Progress(GUIWindow &parentWindow) +: mhParentWindow((HWND)parentWindow), + mhProcessInstance(parentWindow.processInstance()), + mhProgressControl(0), mhStaticControl(0), mhBrush(0), + mFont(szFontName,8), mItemIndex(0L), mItemCount(0L), mCanCancel(FALSE) +{ + ::InitCommonControls(); + mControlColorHandler.setCallback(this,&Progress::controlColorHandler); + mCreateHandler.setCallback(this,&Progress::createHandler); + mPaintHandler.setCallback(this,&Progress::paintHandler); + mTimerHandler.setCallback(this,&Progress::timerHandler); + mCharHandler.setCallback(this,&Progress::charHandler); + initialPoint(parentWindow); + insertHandlers(); + registerClass(); + createWindow(); + createControls(); +} + +Progress::Progress(GUIWindow &parentWindow,String captionString) +: mhParentWindow((HWND)parentWindow), + mhProcessInstance(parentWindow.processInstance()), + mhProgressControl(0), mhStaticControl(0), mCaptionString(captionString), + mhBrush(0), mFont(szFontName,8), mItemIndex(0L), mItemCount(0L), mCanCancel(FALSE) +{ + ::InitCommonControls(); + mControlColorHandler.setCallback(this,&Progress::controlColorHandler); + mCreateHandler.setCallback(this,&Progress::createHandler); + mPaintHandler.setCallback(this,&Progress::paintHandler); + mTimerHandler.setCallback(this,&Progress::timerHandler); + mCharHandler.setCallback(this,&Progress::charHandler); + initialPoint(parentWindow); + insertHandlers(); + registerClass(); + createWindow(); + createControls(); +} + +Progress::Progress(GUIWindow &parentWindow,String captionString,Block &iconNames) +: mhParentWindow((HWND)parentWindow), + mhProcessInstance(parentWindow.processInstance()), + mhProgressControl(0), mhStaticControl(0), mCaptionString(captionString), + mhBrush(0), mFont(szFontName,8), mItemIndex(0L), mItemCount(0L), mCanCancel(FALSE) +{ + ::InitCommonControls(); + mControlColorHandler.setCallback(this,&Progress::controlColorHandler); + mCreateHandler.setCallback(this,&Progress::createHandler); + mPaintHandler.setCallback(this,&Progress::paintHandler); + mTimerHandler.setCallback(this,&Progress::timerHandler); + mCharHandler.setCallback(this,&Progress::charHandler); + insertIcons(iconNames); + initialPoint(parentWindow); + insertHandlers(); + registerClass(); + createWindow(); + createControls(); +} + +Progress::~Progress() +{ + shutdown(); + removeHandlers(); +} + +void Progress::insertHandlers(void) +{ + MMTimer::insertHandler(&mTimerHandler); + Window::insertHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + Window::insertHandler(VectorHandler::CreateHandler,&mCreateHandler); + Window::insertHandler(VectorHandler::PaintHandler,&mPaintHandler); + Window::insertHandler(VectorHandler::CharHandler,&mCharHandler); +} + +void Progress::removeHandlers(void) +{ + MMTimer::removeHandler(); + Window::removeHandler(VectorHandler::ControlColorHandler,&mControlColorHandler); + Window::removeHandler(VectorHandler::CreateHandler,&mCreateHandler); + Window::removeHandler(VectorHandler::PaintHandler,&mPaintHandler); + Window::removeHandler(VectorHandler::CharHandler,&mCharHandler); +} + +void Progress::insertIcons(Block &iconNames) +{ + WORD iconCount(iconNames.size()); + + mIconFrame.remove(); + for(short itemIndex=0;itemIndexPWcx&&parentWindow.height()>PWcy) + { + parentWindow.windowRect(windowRect); + mInitialPoint.x(windowRect.left()+((parentWindow.width()-PWcx)/2)); + mInitialPoint.y(windowRect.top()+((parentWindow.height()-PWcy)/2)); + } + else + { + mInitialPoint.x(CW_USEDEFAULT); + mInitialPoint.y(CW_USEDEFAULT); + } + } +} + +void Progress::registerClass(void) +{ + WNDCLASS wndClass; + + if(::GetClassInfo(mhProcessInstance,szClassName,(WNDCLASS FAR*)&wndClass))return; + wndClass.style =CS_HREDRAW|CS_VREDRAW; + wndClass.lpfnWndProc =(WNDPROC)Window::WndProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(Progress*); + wndClass.hInstance =mhProcessInstance; + wndClass.hIcon =::LoadIcon(NULL,IDI_APPLICATION); + wndClass.hCursor =::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH); + wndClass.lpszMenuName =0; + wndClass.lpszClassName =szClassName; + ::RegisterClass(&wndClass); + if(0==::GetClassInfo(mhProcessInstance,szClassName,(WNDCLASS FAR*)&wndClass))throw(NullError()); +} + +void Progress::createControls(void) +{ + mhBrush=::CreateSolidBrush(RGB(bkRed,bkGreen,bkBlue)); + mhProgressControl=::CreateWindow("msctls_progress32","",WS_CHILD,PCx,PCy,PCcx,PCcy,(HWND)*this,(HMENU)ProgressBarID,mhProcessInstance,0); + mhStaticControl=::CreateWindow("STATIC","",WS_CHILD|WS_CLIPSIBLINGS|SS_LEFTNOWORDWRAP,SCx,SCy,SCcx,SCcy,(HWND)*this,(HMENU)0,mhProcessInstance,0); + ::SendMessage(mhStaticControl,WM_SETFONT,(WPARAM)(HFONT)mFont,0L); +} + +void Progress::destroyControls(void) +{ + if(mhBrush){::DeleteObject(mhBrush);mhBrush=0;} + if(mhProgressControl){::DestroyWindow(mhProgressControl);mhProgressControl=0;} + if(mhStaticControl){::DestroyWindow(mhStaticControl);mhStaticControl=0;} +} + +void Progress::shutdown(void) +{ + stopTimer(); + destroyControls(); + destroy(); +} + +void Progress::show(WORD onOff) +{ + WORD showState(onOff?SW_SHOW:SW_HIDE); + + if(!isOkay())return; + Window::show(showState); + ::ShowWindow(mhProgressControl,showState); + ::ShowWindow(mhStaticControl,showState); + update(); + ::UpdateWindow(mhProgressControl); + ::UpdateWindow(mhStaticControl); + if(SW_SHOW==showState) + { + mIconFrame.drawIcon(PureDevice(*this),Point(5,5)); + startTimer(750L); + } + else stopTimer(); +} + +WORD Progress::range(DWORD itemCount) +{ + if(!isOkay())return FALSE; + mItemIndex=1L; + mItemCount=itemCount; + progressMessage(SetRange,0,MAKELPARAM(0,FullRange)); + progressMessage(SetPos,0); + return TRUE; +} + +WORD Progress::operator++(void) +{ + if(!isOkay()||!mItemCount)return FALSE; + progressMessage(SetPos,((float)mItemIndex/(float)mItemCount)*(float)FullRange); + mItemIndex++; + return TRUE; +} + +WORD Progress::operator+=(const String &messageString) +{ + if(!isOkay())return FALSE; + operator++(); + if(!messageString.isNull())staticMessage(messageString); + return TRUE; +} + +WORD Progress::setText(const String &messageString) +{ + if(!isOkay()||messageString.isNull())return FALSE; + staticMessage(messageString); + return TRUE; +} + +WORD Progress::getText(String &messageString) +{ + if(!isOkay())return FALSE; + String staticString; + sendMessage(mhStaticControl,WM_GETTEXT,(WPARAM)String::MaxString-1,(LPARAM)(LPSTR)staticString); + messageString=staticString; + return TRUE; +} + +WORD Progress::setPosition(DWORD position) +{ + if(!isOkay()||!mItemCount)return FALSE; + mItemIndex=position; + progressMessage(SetPos,((float)mItemIndex/(float)mItemCount)*(float)FullRange); + return TRUE; +} + +WORD Progress::reset(void) +{ + if(!isOkay())return FALSE; + mItemIndex=1L; + mItemCount=0L; + progressMessage(SetPos,0); + return TRUE; +} + +CallbackData::ReturnType Progress::createHandler(CallbackData &/*someCallbackData*/) +{ + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType Progress::charHandler(CallbackData &someCallbackData) +{ + if(canCancel()&&EscapeKey==someCallbackData.wParam())shutdown(); + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType Progress::paintHandler(CallbackData &/*someCallbackData*/) +{ + return (CallbackData::ReturnType)FALSE; +} + +CallbackData::ReturnType Progress::controlColorHandler(CallbackData &someCallbackData) +{ + ::SetBkColor((HDC)someCallbackData.wParam(),RGB(bkRed,bkGreen,bkBlue)); + return (CallbackData::ReturnType)mhBrush; +} + +CallbackData::ReturnType Progress::timerHandler(CallbackData &/*someCallbackData*/) +{ + if(isOkay())mIconFrame.drawIcon(PureDevice(*this),Point(5,5)); + return (CallbackData::ReturnType)TRUE; +} +#endif + \ No newline at end of file diff --git a/common/Progress.hpp b/common/Progress.hpp new file mode 100644 index 0000000..d4bf360 --- /dev/null +++ b/common/Progress.hpp @@ -0,0 +1,153 @@ +#if defined(__FLAT__) +#ifndef _COMMON_PROGRESS_HPP_ +#define _COMMON_PROGRESS_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_FONT_HPP_ +#include +#endif +#ifndef _COMMON_COMMCTRL_HPP_ +#include +#endif +#ifndef _COMMON_ICONFRAME_HPP_ +#include +#endif +#ifndef _COMMON_MMTIMER_HPP_ +#include +#endif +#ifndef _COMMON_WINDOW_HPP_ +#include +#endif + +class Progress : public Window, private MMTimer +{ +public: + Progress(GUIWindow &parentWindow); + Progress(GUIWindow &parentWindow,String captionString); + Progress(GUIWindow &parentWindow,String captionString,Block &iconNames); + virtual ~Progress(); + WORD operator++(void); + WORD operator++(int postFixDummy); + WORD operator+=(const String &messageString); + WORD setPosition(DWORD position); + WORD setText(const String &messageString); + WORD getText(String &messageString); + WORD setCaption(const String &captionString); + WORD range(DWORD itemCount); + DWORD itemIndex(void)const; + WORD reset(void); + void show(WORD onOff); + WORD canCancel(void)const; + void canCancel(WORD canCancel); + WORD isOkay(void)const; +private: + enum{ProgressBarID=0x10,StaticTextID=0x11}; + enum{bkRed=192,bkGreen=192,bkBlue=192}; + enum{PWcx=280,PWcy=100}; + enum{PCx=5,PCy=40,PCcx=265,PCcy=15}; + enum{SCx=5,SCy=60,SCcx=265,SCcy=18}; + enum{FullRange=100,EscapeKey=27}; + enum MsgType{SetRange=PBM_SETRANGE,SetPos=PBM_SETPOS,DeltaPos=PBM_DELTAPOS,SetStep=PBM_SETSTEP,StepIt=PBM_STEPIT}; + Progress(const Progress &someProgress); + Progress &operator=(const Progress &someProgress); + void progressMessage(MsgType msgType,WPARAM wParam,LPARAM lParam=0L); + void staticMessage(const String &messageString); + void registerClass(void); + void createWindow(void); + void createControls(void); + void destroyControls(void); + void insertHandlers(void); + void removeHandlers(void); + void initialPoint(const GUIWindow &parentWindow); + void insertIcons(Block &iconNames); + void shutdown(void); + CallbackData::ReturnType createHandler(CallbackData &someCallbackData); + CallbackData::ReturnType controlColorHandler(CallbackData &someCallbackData); + CallbackData::ReturnType paintHandler(CallbackData &someCallbackData); + CallbackData::ReturnType timerHandler(CallbackData &someCallbackData); + CallbackData::ReturnType charHandler(CallbackData &someCallbackData); + + static char szClassName[]; + static char szFontName[]; + Callback mControlColorHandler; + Callback mPaintHandler; + Callback mCreateHandler; + Callback mTimerHandler; + Callback mCharHandler; + HWND mhParentWindow; + HINSTANCE mhProcessInstance; + Point mInitialPoint; + String mClassName; + String mCaptionString; + HWND mhProgressControl; + HWND mhStaticControl; + HBRUSH mhBrush; + Font mFont; + DWORD mItemIndex; + DWORD mItemCount; + WORD mCanCancel; + IconFrame mIconFrame; +}; + +inline +Progress::Progress(const Progress &/*someProgress*/) +{ // no implementation +} + +inline +Progress &Progress::operator=(const Progress &/*someProgress*/) +{ // no implementation + return *this; +} + +inline +WORD Progress::operator++(int /*postFixDummy*/) +{ + return ++(*this); +} + +inline +void Progress::progressMessage(MsgType msgType,WPARAM wParam,LPARAM lParam) +{ + ::SendMessage(mhProgressControl,msgType,wParam,lParam); +} + +inline +void Progress::staticMessage(const String &messageString) +{ + sendMessage(mhStaticControl,WM_SETTEXT,0,(LONG)(LPSTR)messageString); +} + +inline +WORD Progress::setCaption(const String &captionString) +{ + return sendMessage(*this,WM_SETTEXT,0,(LONG)(LPSTR)captionString); +} + +inline +DWORD Progress::itemIndex(void)const +{ + return mItemIndex; +} + +inline +WORD Progress::canCancel(void)const +{ + return mCanCancel; +} + +inline +void Progress::canCancel(WORD canCancel) +{ + mCanCancel=canCancel; +} + +inline +WORD Progress::isOkay(void)const +{ + return ((HWND)*this&&mhProgressControl&&mhStaticControl); +} +#endif +#endif + diff --git a/common/Purebmp.hpp b/common/Purebmp.hpp new file mode 100644 index 0000000..5930d33 --- /dev/null +++ b/common/Purebmp.hpp @@ -0,0 +1,185 @@ +#ifndef _COMMON_PUREBITMAP_HPP_ +#define _COMMON_PUREBITMAP_HPP_ +#ifndef _COMMON_ASSERT_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PUREDEVICE_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif +#ifndef _COMMON_BITMAPINFO_HPP_ +#include +#endif + +class PureBitmap +{ +public: + PureBitmap(void); + PureBitmap(const PureBitmap &somePureBitmap); + PureBitmap(const String &strNameBitmap,HINSTANCE hInstance=GetModuleHandle(0)); + PureBitmap(const PureDevice &somePureDevice,const PureBitmap &somePureBitmap); + PureBitmap(HBITMAP hBitmap); + virtual ~PureBitmap(); + WORD loadBitmap(const String &strNameBitmap,HINSTANCE hInstance=::GetModuleHandle(0)); + BOOL compatibleBitmap(const PureDevice &somePureDevice,const PureBitmap &somePureBitmap); + BOOL compatibleBitmap(const PureDevice &somePureDevice,int width,int height); + BOOL compatibleBitmap(int width,int height); + BOOL createFrom(PureBitmap &sourceBitmap,const Rect &srcRect); + BOOL getInto(PureBitmap &dstBitmap,const Rect &rect)const; + BOOL setFrom(PureBitmap &sourceBitmap,const Rect &rect)const; + WORD screenBitmap(const RECT &boundingRect); + WORD screenBitmap(const Rect &boundingRect); + WORD windowBitmap(HWND hDisplayWindow); + WORD operator==(const PureBitmap &somePureBitmap)const; + WORD operator=(const PureBitmap &somePureBitmap); + WORD operator=(HBITMAP hBitmap); + bool getBitmapInfo(BitmapInfo &bmInfo); + DWORD getBitmapBits(GlobalData &bitmapBytes,BOOL bottomUp=FALSE)const; + DWORD getBitmapBits(GlobalData &bitmapBytes,BitmapInfo::BitsPerPixel bitsPerPixel,BOOL bottomUp=FALSE)const; + DWORD getBitmapBits(GlobalData &bitmapBytes,BitmapInfo::BitsPerPixel bitsPerPixel,PurePalette &purePalette,BOOL bottomUp=FALSE)const; + DWORD setBitmapBits(GlobalData &bitmapBytes,BOOL bottomUp=FALSE)const; + WORD isOkay(void)const; + operator HBITMAP(void)const; + WORD width(void)const; + WORD height(void)const; + WORD widthBytes(void)const; + WORD bitsPerPixel(void)const; + HBITMAP getBitmap(void)const; + void destroy(void); +private: + void destroyBitmap(void); + + BITMAP mBitmap; + HBITMAP mhBitmap; +}; + +inline +PureBitmap::PureBitmap(void) +: mhBitmap(0) +{ + ::memset(&mBitmap,0,sizeof(mBitmap)); +} + +inline +PureBitmap::PureBitmap(HBITMAP hBitmap) +: mhBitmap(0) +{ + ::memset(&mBitmap,0,sizeof(mBitmap)); + *this=hBitmap; +} + +inline +PureBitmap::PureBitmap(const PureDevice &somePureDevice,const PureBitmap &somePureBitmap) +: mhBitmap(0) +{ + compatibleBitmap((HDC)somePureDevice,somePureBitmap); +} + +inline +PureBitmap::PureBitmap(const PureBitmap &somePureBitmap) +: mhBitmap(0) +{ + *this=(PureBitmap&)somePureBitmap; +} + +inline +PureBitmap::~PureBitmap() +{ + destroyBitmap(); +} + +inline +PureBitmap::operator HBITMAP(void)const +{ + return mhBitmap; +} + +inline +void PureBitmap::destroyBitmap(void) +{ + if(mhBitmap){::DeleteObject(mhBitmap);mhBitmap=0;} + ::memset(&mBitmap,0,sizeof(mBitmap)); +} + +inline +WORD PureBitmap::isOkay(void)const +{ + return (mhBitmap?TRUE:FALSE); +} + +inline +BOOL PureBitmap::compatibleBitmap(const PureDevice &somePureDevice,const PureBitmap &somePureBitmap) +{ + destroyBitmap(); + if(!somePureBitmap.isOkay())return FALSE; + mhBitmap=::CreateCompatibleBitmap((HDC)somePureDevice,somePureBitmap.width(),somePureBitmap.height()); + if(mhBitmap)::GetObject(mhBitmap,sizeof(BITMAP),(LPSTR)&mBitmap); + return isOkay(); +} + +inline +BOOL PureBitmap::compatibleBitmap(const PureDevice &somePureDevice,int width,int height) +{ + destroyBitmap(); + if(!somePureDevice.isOkay())return FALSE; + mhBitmap=::CreateCompatibleBitmap((HDC)somePureDevice,width,height); + if(mhBitmap)::GetObject(mhBitmap,sizeof(BITMAP),(LPSTR)&mBitmap); + return isOkay(); +} + +inline +BOOL PureBitmap::compatibleBitmap(int width,int height) +{ + PureDevice pureDevice; + pureDevice.displayDevice(); + return compatibleBitmap(pureDevice,width,height); +} + +inline +WORD PureBitmap::width(void)const +{ + if(!isOkay())return FALSE; + return mBitmap.bmWidth; +} + +inline +WORD PureBitmap::widthBytes(void)const +{ + if(!isOkay())return FALSE; + return mBitmap.bmWidthBytes; +} + +inline +WORD PureBitmap::height(void)const +{ + if(!isOkay())return FALSE; + return mBitmap.bmHeight; +} + +inline +WORD PureBitmap::bitsPerPixel(void)const +{ + if(!isOkay())return FALSE; + return mBitmap.bmBitsPixel; +} + +inline +HBITMAP PureBitmap::getBitmap(void)const +{ + return mhBitmap; +} + +inline +void PureBitmap::destroy(void) +{ + destroyBitmap(); +} +#endif diff --git a/common/Purehdc.hpp b/common/Purehdc.hpp new file mode 100644 index 0000000..21cd309 --- /dev/null +++ b/common/Purehdc.hpp @@ -0,0 +1,290 @@ +#ifndef _COMMON_PUREDEVICE_HPP_ +#define _COMMON_PUREDEVICE_HPP_ +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_PEN_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#ifndef _COMMON_POINT_HPP_ +#include +#endif +#ifndef _COMMON_GDIOBJ_HPP_ +#include +#endif +#ifndef _COMMON_RECTANGLE_HPP_ +#include +#endif + +class Window; +class Brush; + +class PureDevice +{ +public: + enum Disposition{DeleteDC,ReleaseDC,AssumedDC,InvalidDC}; + enum DrawMode{INVALIDROP=0,R2BLACK=R2_BLACK,R2WHITE=R2_WHITE,R2NOP=R2_NOP,R2NOT=R2_NOT, + R2COPYPEN=R2_COPYPEN,R2NOTCOPYPEN=R2_NOTCOPYPEN,R2MERGEPENNOT=R2_MERGEPENNOT, + R2MASKPENNOT=R2_MASKPENNOT,R2MERGENOTPEN=R2_MERGENOTPEN,R2MASKNOTPEN=R2_MASKNOTPEN, + R2MERGEPEN=R2_MERGEPEN,R2NOTMERGEPEN=R2_NOTMERGEPEN,R2MASKPEN=R2_MASKPEN, + R2NOTMASKPEN=R2_NOTMASKPEN,R2XORPEN=R2_XORPEN,R2NOTXORPEN=R2_NOTXORPEN}; + enum BltMode{Blackness=BLACKNESS,DstInvert=DSTINVERT,MergeCopy=MERGECOPY,MergePaint=MERGEPAINT, + NotSourceCopy=NOTSRCCOPY,NotSourceErase=NOTSRCERASE,PatternCopy=PATCOPY, + PatternInvert=PATINVERT,PatternPaint=PATPAINT,SourceAnd=SRCAND, + SourceCopy=SRCCOPY,SourceErase=SRCERASE,SourceInvert=SRCINVERT, + SourcePaint=SRCPAINT,White=WHITENESS}; + enum BkMode{Opaque=OPAQUE,Transparent=TRANSPARENT}; + PureDevice(void); + PureDevice(const Window &someWindow); + PureDevice(HWND hWnd); + PureDevice(HDC hDC); + PureDevice(const PureDevice &somePureDevice); + virtual ~PureDevice(); + PureDevice &operator=(const PureDevice &somePureDevice); + PureDevice &operator=(const Window &someWindow); + PureDevice &operator=(HWND hWnd); + operator HDC(void)const; + void destroyDevice(void); + WORD select(const GDIObj someGDIObj,WORD selState=TRUE); + WORD compatibleDevice(const PureDevice &somePureDevice); + WORD compatibleDevice(void); + WORD displayDevice(void); + WORD screenDevice(void); + WORD line(const Point &firstPoint,const Point &secondPoint,const Pen &somePen)const; + WORD line(const Point &firstPoint,const Point &secondPoint,const RGBColor &rgbColor)const; + WORD line(const Point &firstPoint,const Point &secondPoint)const; + WORD move(const Point &movePoint)const; + WORD square(const Point ¢erPoint,WORD lineLength,RGBColor rgbColor); + WORD roundRectangle(const Point &upperLeftPoint,const Point &lowerRightPoint,DWORD width,DWORD height); + WORD roundRectangle(const Point ¢erPoint,int radius); + WORD colorRect(const Rect &rect,const RGBColor &fillColor)const; + WORD outlineRect(const Rect &rect,const Pen &pen); + WORD horizontalResolution(void)const; + WORD verticalResolution(void)const; + WORD aspectValue(const Window &someWindow)const; + WORD isOkay(void)const; + WORD circle(Window &displayWindow,const Point &xyPoint,WORD radius,const RGBColor &someRGBColor)const; + WORD circle(const Point &xyPoint,WORD radius,const RGBColor &someRGBColor)const; + WORD crossHair(const Point &midPoint,WORD sectionlength,const Pen &somePen); + WORD crossHairs(Array &midPoints,WORD sectionLength,const Pen &somePen); + WORD crossHairs(Array &midPoints,WORD sectionLength,RGBColor rgbColor); + WORD floodFill(const Point &xyPoint,const RGBColor &fillColor,const RGBColor &boundaryColor)const; + WORD bitBlt(const Rect &dstRect,const PureDevice &srcDevice,const Point &srcPoint,BltMode bltMode=SourceCopy); + WORD stretchBlt(const Rect &dstRect,const PureDevice &srcDevice,const Rect &srcRect,BltMode bltMode=SourceCopy); + WORD setDrawMode(DrawMode ropCode); + RGBColor setPixel(const Point &somePoint,const RGBColor &paletteColor)const; + BOOL setPixelv(const Point &somePoint,const RGBColor &paletteColor)const; + RGBColor setTextColor(const RGBColor &rgbColor)const; + RGBColor setBkColor(const RGBColor &rgbColor)const; + RGBColor getBkColor(void)const; + BOOL fillRect(const Rect &rect,Brush &brush); + BOOL textOut(int xLoc,int yLoc,const char *lpszString)const; + bool drawText(const Point &point,const String &strText)const; + BOOL getTextExtentPoint32(LPCTSTR lpszString,LPSIZE lpSizeStruct)const; + int setBkMode(BkMode bkMode)const; + RGBColor setPixel(const Point &somePoint,WORD paletteIndex)const; + RGBColor getPixel(const Point &somePoint)const; + Disposition disposition(void)const; + void disposition(Disposition disposition); + HDC getDC(void)const; +private: + enum {DefaultAspect=100}; + void unselect(void); + WORD circle(WORD aspectValue,const Point &xyPoint,WORD radius,const RGBColor &someRGBColor)const; + void lineDraw(const Point &firstPoint,const Point &secondPoint)const; + + HDC mhDC; + HWND mhParent; + GDIObj mGDIObjPrev; + Disposition mDisposition; + int mPrevDrawMode; +}; + +inline +PureDevice::PureDevice(void) +: mhDC(0), mhParent(0), mDisposition(InvalidDC), mGDIObjPrev(0), mPrevDrawMode(INVALIDROP) +{ +} + +inline +PureDevice::PureDevice(HWND hParent) +: mhDC(0), mhParent(hParent), mDisposition(ReleaseDC), mGDIObjPrev(0), mPrevDrawMode(INVALIDROP) +{ + if(!mhParent||!::IsWindow(mhParent))return; + mhDC=::GetDC(mhParent); +} + +inline +PureDevice::PureDevice(const PureDevice &somePureDevice) +: mhDC(0), mhParent(0), mDisposition(DeleteDC), mGDIObjPrev(0), mPrevDrawMode(INVALIDROP) +{ + if(!somePureDevice.mhDC)return; + mhDC=::CreateCompatibleDC(somePureDevice.mhDC); +} + +inline +PureDevice::PureDevice(HDC hDC) +: mhDC(hDC), mhParent(0), mDisposition(AssumedDC), mGDIObjPrev(0), mPrevDrawMode(INVALIDROP) +{ +} + +inline +void PureDevice::unselect(void) +{ + if(!isOkay())return; + if(mGDIObjPrev){::SelectObject(mhDC,mGDIObjPrev);mGDIObjPrev=0;} +} + +inline +RGBColor PureDevice::setPixel(const Point &somePoint,const RGBColor &paletteColor)const +{ + return RGBColor(::SetPixel(mhDC,somePoint.x(),somePoint.y(),paletteColor)); +} + +inline +BOOL PureDevice::setPixelv(const Point &somePoint,const RGBColor &paletteColor)const +{ + return RGBColor(::SetPixelV(mhDC,somePoint.x(),somePoint.y(),paletteColor)); +} + +inline +RGBColor PureDevice::setPixel(const Point &somePoint,WORD paletteIndex)const +{ + return RGBColor(::SetPixel(mhDC,somePoint.x(),somePoint.y(),PALETTEINDEX(paletteIndex))); +} + +inline +RGBColor PureDevice::getPixel(const Point &somePoint)const +{ + return RGBColor(::GetPixel(mhDC,somePoint.x(),somePoint.y())); +} + +inline +PureDevice::operator HDC(void)const +{ + return mhDC; +} + +inline +WORD PureDevice::circle(const Point &xyPoint,WORD radius,const RGBColor &someRGBColor)const +{ + return circle(DefaultAspect,xyPoint,radius,someRGBColor); +} + +inline +void PureDevice::lineDraw(const Point &firstPoint,const Point &secondPoint)const +{ + ::MoveToEx(mhDC,firstPoint.x(),firstPoint.y(),0); + ::LineTo(mhDC,secondPoint.x(),secondPoint.y()); +} + +inline +WORD PureDevice::roundRectangle(const Point &upperLeftPoint,const Point &lowerRightPoint,DWORD width,DWORD height) +{ + if(!isOkay())return FALSE; + return ::RoundRect(*this,upperLeftPoint.x(),upperLeftPoint.y(),lowerRightPoint.x(),lowerRightPoint.y(),width,height); +} + +inline +WORD PureDevice::setDrawMode(DrawMode ropCode) +{ + if(!isOkay())return FALSE; + if(INVALIDROP!=mPrevDrawMode)::SetROP2(*this,mPrevDrawMode); + if(INVALIDROP!=ropCode)mPrevDrawMode=::SetROP2(*this,ropCode); + else mPrevDrawMode=ropCode; + return TRUE; +} + +inline +WORD PureDevice::bitBlt(const Rect &dstRect,const PureDevice &srcDevice,const Point &srcPoint,BltMode bltMode) +{ + if(!isOkay())return FALSE; + return ::BitBlt(*this,dstRect.left(),dstRect.top(),dstRect.right(),dstRect.bottom(),srcDevice,srcPoint.x(),srcPoint.y(),bltMode); +} + +inline +WORD PureDevice::stretchBlt(const Rect &dstRect,const PureDevice &srcDevice,const Rect &srcRect,BltMode bltMode) +{ + if(!isOkay())return FALSE; + return ::StretchBlt(*this,dstRect.left(),dstRect.top(),dstRect.right(),dstRect.bottom(),srcDevice,srcRect.left(),srcRect.top(),srcRect.right(),srcRect.bottom(),bltMode); +} + +inline +RGBColor PureDevice::setBkColor(const RGBColor &rgbColor)const +{ + if(!isOkay())return RGBColor(0,0,0); + return ::SetBkColor(mhDC,rgbColor); +} + +inline +RGBColor PureDevice::getBkColor(void)const +{ + return RGBColor(::GetBkColor(mhDC)); +} + +inline +WORD PureDevice::move(const Point &movePoint)const +{ + if(!isOkay())return FALSE; + return ::MoveToEx(mhDC,movePoint.x(),movePoint.y(),(LPPOINT)0); +} + +inline +RGBColor PureDevice::setTextColor(const RGBColor &rgbColor)const +{ + if(!isOkay())return RGBColor(); + return ::SetTextColor(mhDC,rgbColor); +} + +inline +BOOL PureDevice::textOut(int xLoc,int yLoc,const char *lpszString)const +{ + if(!isOkay()||!lpszString)return FALSE; + return ::TextOut(mhDC,xLoc,yLoc,lpszString,::strlen(lpszString)); +} + +inline +bool PureDevice::drawText(const Point &point,const String &strText)const +{ + if(!isOkay()||strText.isNull())return FALSE; + return ::TextOut(mhDC,point.x(),point.y(),strText.str(),strText.length()); +} + +inline +BOOL PureDevice::getTextExtentPoint32(LPCTSTR lpszString,LPSIZE lpSizeStruct)const +{ + if(!isOkay()||!lpszString)return FALSE; + return ::GetTextExtentPoint32(mhDC,lpszString,::strlen(lpszString),lpSizeStruct); +} + +inline +int PureDevice::setBkMode(BkMode bkMode)const +{ + if(!isOkay())return FALSE; + return ::SetBkMode(mhDC,bkMode); +} + +inline +PureDevice::Disposition PureDevice::disposition(void)const +{ + return mDisposition; +} + +inline +void PureDevice::disposition(Disposition disposition) +{ + mDisposition=disposition; +} + +inline +HDC PureDevice::getDC(void)const +{ + return mhDC; +} +#endif diff --git a/common/Puremenu.hpp b/common/Puremenu.hpp new file mode 100644 index 0000000..54ed774 --- /dev/null +++ b/common/Puremenu.hpp @@ -0,0 +1,183 @@ +#ifndef _COMMON_PUREMENU_HPP_ +#define _COMMON_PUREMENU_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_WINDOW_HPP_ +#include +#endif +#ifndef _COMMON_DWINDOW_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_GDIPOINT_HPP_ +#include +#endif +#ifndef _COMMON_MENUITEM_HPP_ +#include +#endif +#ifndef __FLAT__ +#ifndef TPM_BOTTOMALIGN +#define TPM_BOTTOMALIGN 0x0020 +#endif +#ifndef TPM_TOPALIGN +#define TPM_TOPALIGN 0x0000 +#endif +#ifndef TPM_RETURNCMD +#define TPM_RETURNCMD 0x0100 +#endif +#endif + +class PureBitmap; + +class PureMenu +{ +public: + enum InsertFlags{ItemBitmap=MF_BITMAP,ItemOwnerDraw=MF_OWNERDRAW,ItemString=MF_STRING, + ItemChecked=MF_CHECKED,ItemDisabled=MF_DISABLED,ItemEnabled=MF_ENABLED, + ItemGrayed=MF_GRAYED,ItemMenuBarBreak=MF_MENUBARBREAK,ItemMenuBreak=MF_MENUBREAK, + ItemPopup=MF_POPUP,ItemSeparator=MF_SEPARATOR,ItemUnchecked=MF_UNCHECKED, + ItemMouseSelect=MF_MOUSESELECT,ItemHilite=MF_HILITE,ItemSysMenu=MF_SYSMENU}; + enum PositionFlags{ByCommand=MF_BYCOMMAND,ByPosition=MF_BYPOSITION}; + enum TrackFlags{RightAlign=TPM_RIGHTALIGN,CenterAlign=TPM_CENTERALIGN,LeftAlign=TPM_LEFTALIGN, + BottomAlign=TPM_BOTTOMALIGN,TopAlign=TPM_TOPALIGN,ReturnCommand=TPM_RETURNCMD, + LeftButton=TPM_LEFTBUTTON,RightButton=TPM_RIGHTBUTTON}; + enum MenuType{TypeBitmap=MFT_BITMAP,TypeMenuBarBreak=MFT_MENUBARBREAK,TypeMenuBreak=MFT_MENUBREAK, + TypeOwnerDraw=MFT_OWNERDRAW,TypeRadioCheck=MFT_RADIOCHECK,TypeSeparator=MFT_SEPARATOR, + TypeString=MFT_STRING,TypeRightJustify=MFT_RIGHTJUSTIFY}; + enum MenuStyle{PopupMenu,BarMenu}; + PureMenu(void); + PureMenu(MenuStyle menuStyle); + PureMenu(HMENU hMenu); + PureMenu(const PureMenu &somePureMenu); + virtual ~PureMenu(); + operator HMENU(void)const; + PureMenu &operator=(const PureMenu &somePureMenu); + PureMenu &operator=(const String &menuName); + PureMenu &operator=(HMENU hMenu); + BOOL operator==(const PureMenu &somePureMenu)const; + BOOL getSubMenu(int menuItemPos,PureMenu &subMenu)const; + String menuItemString(UINT menuItem,PositionFlags positionFlags=ByPosition)const; + UINT menuItemStringPos(const String &strMenuHeading)const; + WORD enableMenuItem(UINT menuItem,PositionFlags positionFlags,InsertFlags insertFlags)const; + bool checkMenuItem(UINT menuItem,UINT flags)const; + UINT getMenuState(UINT menuItem,PositionFlags positionFlags)const; + BOOL removeMenu(UINT position,PositionFlags positionFlags)const; + WORD appendMenu(UINT itemID,const String &itemString)const; + WORD appendMenu(Block &menuItems)const; + WORD appendSeparator(void)const; + BOOL insertMenu(UINT position,InsertFlags insertFlags,UINT itemID,const String &itemString)const; + BOOL insertMenu(UINT position,const PureMenu &pureMenu,const String &itemString)const; + BOOL insertMenu(UINT position,const PureMenu &pureMenu,PureBitmap &somePureBitmap)const; + WORD trackPopupMenu(const Window &parentWindow,const GDIPoint &trackPoint,DWORD trackFlags=TopAlign|LeftAlign)const; + WORD trackPopupMenu(const DWindow &parentWindow,const GDIPoint &trackPoint,DWORD trackFlags=TopAlign|LeftAlign)const; + WORD trackPopupMenu(HWND hParentWnd,const GDIPoint &trackPoint,DWORD trackFlags=TopAlign|LeftAlign)const; + WORD isMenuItem(UINT itemID)const; + MenuType getMenuItemType(UINT menuItem,PositionFlags positionFlags)const; + WORD size(void)const; + BOOL isOkay(void)const; +private: + enum Disposition{Keep,Delete,Invalid}; + UINT menuItemID(WORD menuItemIndex)const; + void createMenu(void); + void destroyMenu(void); + + HMENU mhPureMenu; + Disposition mDisposition; + MenuStyle mMenuStyle; +}; + +inline +PureMenu::PureMenu(void) +: mhPureMenu(0), mDisposition(Delete), mMenuStyle(PopupMenu) +{ +} + +inline +PureMenu::PureMenu(MenuStyle menuStyle) +: mhPureMenu(0), mDisposition(Delete), mMenuStyle(menuStyle) +{ + createMenu(); +} + +inline +PureMenu::PureMenu(const PureMenu &somePureMenu) +: mhPureMenu(0), mDisposition(Delete) +{ + *this=somePureMenu; +} + +inline +PureMenu::PureMenu(HMENU hMenu) +: mhPureMenu(hMenu), mDisposition(Keep) +{ +} + +inline +PureMenu::~PureMenu() +{ + destroyMenu(); +} + +inline +PureMenu::operator HMENU(void)const +{ + return mhPureMenu; +} + +inline +BOOL PureMenu::operator==(const PureMenu &somePureMenu)const +{ + return mhPureMenu==somePureMenu.mhPureMenu; +} + +inline +BOOL PureMenu::removeMenu(UINT position,PositionFlags positionFlags)const +{ + if(!isOkay())return FALSE; + return ::RemoveMenu(mhPureMenu,position,(UINT)positionFlags); +} + +inline +WORD PureMenu::appendMenu(UINT itemID,const String &itemString)const +{ + if(!isOkay())return FALSE; + return ::AppendMenu(mhPureMenu,ItemString|ItemEnabled,itemID,(LPSTR)itemString); +} + +inline +WORD PureMenu::appendSeparator(void)const +{ + if(!isOkay())return FALSE; + return ::AppendMenu(mhPureMenu,ItemSeparator,0,""); +} + +inline +UINT PureMenu::menuItemID(WORD menuItemIndex)const +{ + if(!isOkay())return FALSE; + if(!isOkay()||menuItemIndex>=size())return FALSE; + return ::GetMenuItemID(mhPureMenu,menuItemIndex); +} + +inline +WORD PureMenu::trackPopupMenu(const Window &parentWindow,const GDIPoint &trackPoint,DWORD trackFlags)const +{ + return trackPopupMenu((HWND)parentWindow,trackPoint,trackFlags); +} + +inline +WORD PureMenu::trackPopupMenu(const DWindow &parentWindow,const GDIPoint &trackPoint,DWORD trackFlags)const +{ + return trackPopupMenu((HWND)parentWindow,trackPoint,trackFlags); +} + +inline +BOOL PureMenu::isOkay(void)const +{ + return ::IsMenu(mhPureMenu); +} +#endif + diff --git a/common/Purepal.cpp b/common/Purepal.cpp new file mode 100644 index 0000000..ee4076c --- /dev/null +++ b/common/Purepal.cpp @@ -0,0 +1,381 @@ +#include +#include +#include +#include +#include +#include + +PurePalette::PurePalette(const String &strPathFileName) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + readPalette(strPathFileName); +} + +PurePalette::PurePalette(const PurePalette &somePurePalette) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + paletteEntries(somePurePalette.paletteEntries()); + ::GetPaletteEntries(somePurePalette.getPalette(),0,paletteEntries(),(PALETTEENTRY FAR *)&mPaletteData[0]); + createPalette(); +} + +PurePalette::PurePalette(HPALETTE hPalette) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + DWORD palEntries; + + palEntries=::GetPaletteEntries(hPalette,0,0,0); + paletteEntries(palEntries); + ::GetPaletteEntries(hPalette,0,paletteEntries(),(PALETTEENTRY FAR *)&mPaletteData[0]); + createPalette(); +} + +PurePalette::PurePalette(const BitmapInfo &someBitmapInfo) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + *this=someBitmapInfo; +} + +PurePalette &PurePalette::operator=(const PurePalette &somePurePalette) +{ + destroyPalette(); + paletteEntries(somePurePalette.paletteEntries()); + ::GetPaletteEntries(somePurePalette.getPalette(),0,paletteEntries(),(PALETTEENTRY FAR*)&mPaletteData[0]); + createPalette(); + return *this; +} + +PurePalette &PurePalette::operator=(const BitmapInfo &someBitmapInfo) +{ + destroyPalette(); + for(int entryIndex=0;entryIndex &paletteData) +{ + destroyPalette(); + mPaletteData=paletteData; + createPalette(); + return *this; +} + +WORD PurePalette::operator==(const PurePalette &somePurePalette)const +{ + if(paletteEntries()!=somePurePalette.paletteEntries())return FALSE; + for(short paletteIndex=0;paletteIndex=paletteEntries())return FALSE; + someRGBColor=(RGBColor)((PurePalette&)*this).mPaletteData[paletteIndex]; + return TRUE; +} + +RGBColor PurePalette::paletteEntry(PaletteIndex paletteIndex)const +{ + RGBColor tempColor(0,0,0); + + paletteEntry(paletteIndex,tempColor); + return tempColor; +} + +WORD PurePalette::createPalette() +{ + PaletteEntry FAR *lpPaletteEntry; + LOGPALETTE FAR *lpLogPalette; + HGLOBAL hGlobalPalette; + + if(mhPalette){::DeleteObject(mhPalette);mhPalette=0;} + hGlobalPalette=::GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,sizeof(LOGPALETTE)+(paletteEntries()*sizeof(PALETTEENTRY))); + lpLogPalette=(LOGPALETTE FAR *)::GlobalLock(hGlobalPalette); + lpLogPalette->palNumEntries=paletteEntries(); + lpLogPalette->palVersion=0x300; + for(short paletteIndex=0;paletteIndexpalPalEntry[paletteIndex]; + *lpPaletteEntry=mPaletteData[paletteIndex]; + } + mhPalette=::CreatePalette((LOGPALETTE FAR *)lpLogPalette); + ::GlobalUnlock(hGlobalPalette); + ::GlobalFree(hGlobalPalette); + return (mhPalette?TRUE:FALSE); +} + +void PurePalette::usePalette(const PureDevice &somePureDevice,short usage) +{ + if(usage) + { + mhOldPalette=::SelectPalette(somePureDevice,mhPalette,FALSE); + ::RealizePalette(somePureDevice); + mIsInUse=TRUE; + } + else + { + ::SelectPalette(somePureDevice,mhOldPalette,FALSE); + ::RealizePalette(somePureDevice); + mIsInUse=FALSE; + } +} + +WORD PurePalette::getPaletteColor(short paletteIndex,RGBColor &someRGBColor)const +{ + if(paletteIndex>=paletteEntries())return FALSE; + someRGBColor=(RGBColor)((PurePalette&)*this).mPaletteData[paletteIndex]; + return TRUE; +} + +void PurePalette::getPaletteColors(Array &someRGBColors)const +{ + int paletteColors; + + someRGBColors.size(paletteEntries()); + paletteColors=someRGBColors.size(); + for(short paletteIndex=0;paletteIndex &someRGBColors,PaletteEntry::PaletteFlags paletteFlag) +{ + size_t paletteColors((size_t)someRGBColors.size()); + + for(short paletteIndex=0;paletteIndex=paletteEntries())return FALSE; + mPaletteData[paletteIndex]=someRGBColor; + mPaletteData[paletteIndex].flags(paletteFlag); + ::SetPaletteEntries(mhPalette,paletteIndex,1,(PALETTEENTRY FAR*)&mPaletteData[paletteIndex]); + return TRUE; +} + +void PurePalette::clearPalette(void) +{ + short paletteColors(paletteEntries()); + RGBColor nullColor; + + for(short paletteIndex=0;paletteIndex paletteColors; + getPaletteColors(paletteColors); + setPaletteColors(paletteColors,PaletteEntry::NoCollapse); + setPaletteColor(PurePalette::MaxColors-1,RGBColor(255,255,255)); + setPaletteColor(0,RGBColor(0,0,0)); + createPalette(); + return TRUE; + } + if(SystemStaticColors!=(staticColors=::GetDeviceCaps(pureDevice,NUMCOLORS)))return FALSE; + staticColors/=2; + for(int paletteIndex=0;paletteIndex +#endif +#ifndef _COMMON_TYPES_HPP_ +#include +#endif +#ifdef _EXPAND_QSORT_TEMPLATES_ +#pragma option -Jgd +#endif + +template +class Block; +template +class Array; + +template +class QuickSort +{ +public: + QuickSort(void); + virtual ~QuickSort(); + void sortItems(Array &arrayItems,SortOptions::SortOrder sortOrder=SortOptions::Ascending); + void sortItems(Block &someBlock,SortOptions::SortOrder sortOrder=SortOptions::Ascending); +private: + void quickSort(long left,long right); + void quickSortDescending(long left,long right); + void sortBlockAscending(long left,long right); + void sortBlockDescending(long left,long right); + Block *mlpBlockItems; + T HUGE *mlpItemList; +}; +#if defined(_MSC_VER) +#include +#endif +#endif diff --git a/common/QSORT.TPP b/common/QSORT.TPP new file mode 100644 index 0000000..3896b24 --- /dev/null +++ b/common/QSORT.TPP @@ -0,0 +1,140 @@ +#ifndef _COMMON_QUICKSORT_TPP_ +#define _COMMON_QUICKSORT_TPP_ + +template +QuickSort::QuickSort(void) +: mlpItemList(0), mlpBlockItems(0) +{ +} + +template +QuickSort::~QuickSort() +{ +} + +template +void QuickSort::sortItems(Array &arrayItems,SortOptions::SortOrder sortOrder) +{ + if(!arrayItems.size())return; + mlpItemList=&arrayItems[0]; + if(SortOptions::Ascending==sortOrder)quickSort(0,arrayItems.size()-1); + else quickSortDescending(0,arrayItems.size()-1); +} + +template +void QuickSort::sortItems(Block &someBlock,SortOptions::SortOrder sortOrder) +{ + if(!someBlock.size())return; + mlpBlockItems=&someBlock; + if(SortOptions::Ascending==sortOrder)sortBlockAscending(0,someBlock.size()-1L); + else sortBlockDescending(0,someBlock.size()-1L); +} + +template +void QuickSort::quickSort(long left,long right) +{ + long tempLeft(left); + long tempRight(right); + T tempItem; + T swapItem; + + tempItem=*((T FAR*)(mlpItemList+((left+right)/2L))); + do{ + while(*((T FAR*)(mlpItemList+tempLeft))=left)tempRight--; + if(tempLeft>right)tempLeft--; + if(tempRight +void QuickSort::quickSortDescending(long left,long right) +{ + long tempLeft(left); + long tempRight(right); + T tempItem; + T swapItem; + + tempItem=*((T FAR*)(mlpItemList+((left+right)/2L))); + do{ + while(*((T FAR*)(mlpItemList+tempLeft))>tempItem&&tempLeft<=right)tempLeft++; + while(tempItem>*((T FAR*)(mlpItemList+tempRight))&&tempRight>=left)tempRight--; + if(tempLeft>right)tempLeft--; + if(tempRight +void QuickSort::sortBlockAscending(long left,long right) +{ + long tempLeft(left); + long tempRight(right); + T tempItem; + T swapItem; + + tempItem=(*mlpBlockItems)[(left+right)/2L]; + do{ + while((*mlpBlockItems)[tempLeft]=left)tempRight--; + if(tempLeft>right)tempLeft--; + if(tempRight +void QuickSort::sortBlockDescending(long left,long right) +{ + long tempLeft(left); + long tempRight(right); + T tempItem; + T swapItem; + + tempItem=(*mlpBlockItems)[(left+right)/2L]; + do{ + while((*mlpBlockItems)[tempLeft]>tempItem&&tempLeft<=right)tempLeft++; + while(tempItem>(*mlpBlockItems)[tempRight]&&tempRight>=left)tempRight--; + if(tempLeft>right)tempLeft--; + if(tempRight +#endif + +class CharRange : private CHARRANGE +{ +public: + CharRange(void); + CharRange(const CharRange &charRange); + CharRange(LONG posMin,LONG posMax); + virtual ~CharRange(); + CharRange &operator=(const CharRange &charRange); + BOOL operator==(const CharRange &charRange); + CHARRANGE &charRange(void); + LONG posMin(void)const; + void posMin(LONG posMin); + LONG posMax(void)const; + void posMax(LONG posMax); +private: +}; + +inline +CharRange::CharRange(void) +{ + CHARRANGE::cpMin=0; + CHARRANGE::cpMax=0; +} + +inline +CharRange::CharRange(const CharRange &charRange) +{ + *this=charRange; +} + +inline +CharRange::CharRange(LONG posMin,LONG posMax) +{ + CHARRANGE::cpMin=posMin; + CHARRANGE::cpMax=posMax; +} + +inline +CharRange::~CharRange() +{ +} + +inline +CharRange &CharRange::operator=(const CharRange &charRange) +{ + posMin(charRange.posMin()); + posMax(charRange.posMax()); + return *this; +} + +inline +BOOL CharRange::operator==(const CharRange &charRange) +{ + return (posMin()==charRange.posMin()&& + posMax()==charRange.posMax()); +} + +inline +CHARRANGE &CharRange::charRange(void) +{ + return *this; +} + +inline +LONG CharRange::posMin(void)const +{ + return CHARRANGE::cpMin; +} + +inline +void CharRange::posMin(LONG posMin) +{ + CHARRANGE::cpMin=posMin; +} + +inline +LONG CharRange::posMax(void)const +{ + return CHARRANGE::cpMax; +} + +inline +void CharRange::posMax(LONG posMax) +{ + CHARRANGE::cpMax=posMax; +} +#endif diff --git a/common/RAS.HPP b/common/RAS.HPP new file mode 100644 index 0000000..e7affc4 --- /dev/null +++ b/common/RAS.HPP @@ -0,0 +1,7 @@ +#ifndef _COMMON_RAS_HPP_ +#define _COMMON_RAS_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#include +#endif \ No newline at end of file diff --git a/common/RECT.HPP b/common/RECT.HPP new file mode 100644 index 0000000..5d612a8 --- /dev/null +++ b/common/RECT.HPP @@ -0,0 +1,236 @@ +#ifndef _COMMON_RECTANGLE_HPP_ +#define _COMMON_RECTANGLE_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_POINT_HPP_ +#include +#endif +#ifndef _COMMON_GDIPOINT_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_STDIO_HPP_ +#include +#endif + +class Rect : private tagRECT +{ +public: + Rect(void); + Rect(const RECT &someRECT); + Rect(const Rect &someRect); + Rect(LONG left,LONG top,LONG right,LONG bottom); + ~Rect(); + operator RECT &(void); + operator RECT *(void); + Rect &operator=(const Rect &someRect); + WORD operator==(const Rect &someRect)const; + BOOL ptInRect(const Point &point)const; + BOOL ptInRect(const GDIPoint &point)const; + BOOL ptOnRect(const Point &point)const; + BOOL ptOnRect(const GDIPoint &point)const; + LONG left(void)const; + void left(LONG newLeft); + LONG top(void)const; + void top(LONG newTop); + LONG right(void)const; + void right(LONG newRight); + LONG bottom(void)const; + void bottom(LONG newBottom); + LONG width(void)const; + void width(LONG newWidth); + LONG height(void)const; + void height(LONG newHeight); + tagRECT &getRect(void); + String Rect::toString(void)const; +private: +}; + +inline +Rect::Rect(void) +{ + tagRECT::left=0; + tagRECT::top=0; + tagRECT::right=0; + tagRECT::bottom=0; +} + +inline +Rect::Rect(const Rect &someRect) +{ + tagRECT::left=someRect.left(); + tagRECT::top=someRect.top(); + tagRECT::right=someRect.right(); + tagRECT::bottom=someRect.bottom(); +} + +inline +Rect::Rect(const RECT &someRECT) +{ + tagRECT::left=someRECT.left; + tagRECT::top=someRECT.top; + tagRECT::right=someRECT.right; + tagRECT::bottom=someRECT.bottom; +} + +inline +Rect::Rect(LONG left,LONG top,LONG right,LONG bottom) +{ + tagRECT::left=left; + tagRECT::top=top; + tagRECT::right=right; + tagRECT::bottom=bottom; +} + +inline +Rect::~Rect() +{ +} + +inline +Rect::operator RECT &(void) +{ + return *this; +} + +inline +Rect::operator RECT *(void) +{ + return this; +} + +inline +BOOL Rect::ptInRect(const Point &point)const +{ + return ptInRect(GDIPoint(point.x(),point.y())); +} + +inline +BOOL Rect::ptInRect(const GDIPoint &point)const +{ + RECT cRect=*this; + return ::PtInRect(&cRect,((GDIPoint&)point).getPOINT()); +} + +inline +BOOL Rect::ptOnRect(const Point &point)const +{ + return ptOnRect(GDIPoint(point.x(),point.y())); +} + +inline +BOOL Rect::ptOnRect(const GDIPoint &point)const +{ + if(point.x()==left()||point.x()==right())return TRUE; + if(point.y()==top()||point.y()==bottom())return TRUE; + return FALSE; +} + +inline +LONG Rect::left(void)const +{ + return tagRECT::left; +} + +inline +void Rect::left(LONG newLeft) +{ + tagRECT::left=newLeft; +} + +inline +LONG Rect::top(void)const +{ + return tagRECT::top; +} + +inline +void Rect::top(LONG newTop) +{ + tagRECT::top=newTop; +} + +inline +LONG Rect::right(void)const +{ + return tagRECT::right; +} + +inline +void Rect::right(LONG newRight) +{ + tagRECT::right=newRight; +} + +inline +LONG Rect::bottom(void)const +{ + return tagRECT::bottom; +} + +inline +void Rect::bottom(LONG newBottom) +{ + tagRECT::bottom=newBottom; +} + +inline +LONG Rect::width(void)const +{ + return (tagRECT::right-tagRECT::left)+1; +} + +inline +void Rect::width(LONG newWidth) +{ + tagRECT::right=tagRECT::left+newWidth; +} + +inline +LONG Rect::height(void)const +{ + return (tagRECT::bottom-tagRECT::top)+1; +} + +inline +void Rect::height(LONG newHeight) +{ + tagRECT::bottom=tagRECT::top+newHeight; +} + +inline +Rect &Rect::operator=(const Rect &someRect) +{ + tagRECT::left=someRect.left(); + tagRECT::top=someRect.top(); + tagRECT::right=someRect.right(); + tagRECT::bottom=someRect.bottom(); + return *this; +} + +inline +WORD Rect::operator==(const Rect &someRect)const +{ + return(tagRECT::left==someRect.left()&& + tagRECT::top==someRect.top()&& + tagRECT::right==someRect.right()&& + tagRECT::bottom==someRect.bottom()); +} + +inline +tagRECT &Rect::getRect(void) +{ + return *this; +} + +inline +String Rect::toString(void)const +{ + String strRect; + ::sprintf(strRect.str(),"(%d,%d,%d,%d)(%d,%d)",left(),top(),right(),bottom(),width(),height()); + return strRect; +} +#endif diff --git a/common/REGKEY.CPP b/common/REGKEY.CPP new file mode 100644 index 0000000..9e916a1 --- /dev/null +++ b/common/REGKEY.CPP @@ -0,0 +1,290 @@ +#include +#include + +RegKey::RegKey(void) +: mhKey((HKEY)CurrentUser), mIsOpenKey(FALSE), mDisposition(InvalidKey) +{ +} + +RegKey::RegKey(Key regKey) +: mhKey((HKEY)regKey), mIsOpenKey(FALSE), mDisposition(InvalidKey) +{ +} + +RegKey::RegKey(const RegKey &someRegKey) +: mhKey((HKEY)CurrentUser), mIsOpenKey(FALSE), mDisposition(InvalidKey) +{ + *this=someRegKey; +} + +RegKey::~RegKey() +{ + closeKey(); +} + +RegKey &RegKey::operator=(const RegKey &someRegKey) +{ + closeKey(); + mhKey=someRegKey.mhKey; + mDisposition=KeepKey; + isOpenKey(someRegKey.isOpenKey()); + return *this; +} + +WORD RegKey::operator==(const RegKey &someRegKey) +{ + return mhKey==someRegKey.mhKey; +} + +RegKey::operator HKEY(void)const +{ + return mhKey; +} + +WORD RegKey::createKey(const RegKey &openKey,const String &subKey,const String &className,const RegSam ®Sam) +{ + DWORD resData(0L); + DWORD keyDisposition; + long keyReturn; + + if(subKey.isNull())return FALSE; + if(*this==openKey&&isOpenKey())return createDescendKey(subKey,className,regSam); + closeKey(); + keyReturn=::RegCreateKeyEx((HKEY)*this,(LPSTR)subKey,resData,className.isNull()?(LPSTR)0:(LPSTR)className,REG_OPTION_NON_VOLATILE,regSam,(LPSECURITY_ATTRIBUTES)0,&mhKey,&keyDisposition); + if(ERROR_SUCCESS!=keyReturn)return FALSE; + if(REG_OPENED_EXISTING_KEY==keyDisposition)closeKey(); + return TRUE; +} + +WORD RegKey::createKey(const String &subKey,const String &className,const RegSam ®Sam) +{ + DWORD resData(0L); + DWORD keyDisposition; + long keyReturn; + HKEY hKey; + + keyReturn=::RegCreateKeyEx((HKEY)*this,(LPSTR)subKey,resData,(LPSTR)className,REG_OPTION_NON_VOLATILE,regSam,(LPSECURITY_ATTRIBUTES)0,&hKey,&keyDisposition); + if(ERROR_SUCCESS!=keyReturn)return FALSE; + if(REG_OPENED_EXISTING_KEY==keyDisposition)::RegCloseKey(hKey); + return TRUE; +} + +WORD RegKey::createKey(Key regKey,const String &subKey,const RegSam ®Sam) +{ + closeKey(); + mhKey=(HKEY)regKey; + return createKey(*this,subKey,String(""),regSam); +} + +WORD RegKey::openKey(Key regKey,const String &subKey,const RegSam ®Sam) +{ + closeKey(); + mhKey=(HKEY)regKey; + return openKey(subKey,regSam); +} + +WORD RegKey::openKey(const RegKey &openKey,const String &subKey,const RegSam ®Sam) +{ + long keyResult; + + if(*this==openKey&&isOpenKey())return descendKey(openKey,subKey,regSam); + closeKey(); + keyResult=::RegOpenKeyEx((HKEY)openKey,subKey,0L,regSam,&mhKey); + return ERROR_SUCCESS==keyResult; +} + +WORD RegKey::openKey(const String &subKey,const RegSam ®Sam) +{ + long keyResult; + HKEY hKey; + + closeKey(); + keyResult=::RegOpenKeyEx((HKEY)*this,subKey,0L,(DWORD)regSam,&hKey); + if(ERROR_SUCCESS==keyResult){mIsOpenKey=TRUE;mhKey=hKey;mDisposition=CloseKey;} + return ERROR_SUCCESS==keyResult; +} + +void RegKey::closeKey(void) +{ + if(!isOpenKey()||KeepKey==mDisposition)return; + ::RegCloseKey(mhKey); + isOpenKey(FALSE); + mDisposition=InvalidKey; +} + +WORD RegKey::connectRegistry(const String &computerName,const RegKey ®Key) +{ + long keyResult; + closeKey(); + + if((HKEY)regKey!=(HKEY)LocalMachine&&(HKEY)regKey!=(HKEY)Users)return FALSE; + keyResult=::RegConnectRegistry((LPSTR)computerName,regKey,&mhKey); + if(ERROR_SUCCESS!=keyResult)return FALSE; + mDisposition=CloseKey; + mIsOpenKey=TRUE; + return TRUE; +} + +WORD RegKey::deleteKey(const String &subKey) +{ + long keyResult; + + if(!isOkay()||subKey.isNull())return FALSE; + keyResult=::RegDeleteKey((HKEY)*this,(LPSTR)subKey); + if(ERROR_SUCCESS!=keyResult)return FALSE; + return TRUE; +} + +WORD RegKey::deleteValue(const String &namedValue) +{ + long keyResult; + + if(!isOkay()||namedValue.isNull())return FALSE; + keyResult=::RegDeleteValue((HKEY)*this,(LPSTR)namedValue); + if(ERROR_SUCCESS!=keyResult)return FALSE; + return TRUE; +} + +WORD RegKey::descendKey(const RegKey &openKey,const String &subKey,const RegSam ®Sam) +{ + HKEY hKey; + long keyResult; + + if(subKey.isNull())return FALSE; + keyResult=::RegOpenKeyEx((HKEY)openKey,subKey,0L,(DWORD)regSam,&hKey); + closeKey(); + if(ERROR_SUCCESS!=keyResult)return FALSE; + mhKey=hKey; + mDisposition=CloseKey; + mIsOpenKey=TRUE; + return TRUE; +} + +WORD RegKey::createDescendKey(const String &subKey,const String &className,const RegSam ®Sam) +{ + HKEY hKey; + long keyResult; + DWORD resData(0L); + DWORD keyDisposition; + + if(subKey.isNull())return FALSE; + keyResult=::RegCreateKeyEx((HKEY)*this,(LPSTR)subKey,resData,className.isNull()?(LPSTR)0:(LPSTR)className,REG_OPTION_NON_VOLATILE,regSam,(LPSECURITY_ATTRIBUTES)0,&hKey,&keyDisposition); + if(ERROR_SUCCESS!=keyResult)return FALSE; + mhKey=hKey; + if(REG_OPENED_EXISTING_KEY==keyDisposition)closeKey(); + return TRUE; +} + +WORD RegKey::queryValue(const String &valueName,String &stringData)const +{ + BYTE valueData[MaxDataLength]; + DWORD sizeData(sizeof(valueData)); + DWORD valueType(REG_SZ); + long keyReturn; + + if(!isOkay())return FALSE; + ::memset(valueData,0,sizeof(valueData)); + keyReturn=::RegQueryValueEx((HKEY)*this,(LPSTR)valueName,0,&valueType,valueData,&sizeData); + if(ERROR_SUCCESS!=keyReturn||REG_SZ!=valueType)return FALSE; + stringData=(char*)valueData; + return TRUE; +} + +WORD RegKey::queryValue(const String &valueName,DWORD &longData)const +{ + BYTE valueData[MaxDataLength]; + DWORD sizeData(sizeof(valueData)); + DWORD valueType(REG_DWORD); + long keyReturn; + + if(!isOkay()||valueName.isNull())return FALSE; + ::memset(valueData,0,sizeof(valueData)); + keyReturn=::RegQueryValueEx((HKEY)*this,(LPSTR)valueName,0,&valueType,valueData,&sizeData); + if(ERROR_SUCCESS!=keyReturn||REG_DWORD!=valueType)return FALSE; + longData=*((DWORD*)valueData); + return TRUE; +} + +WORD RegKey::setValue(const String &valueName,const String &stringData) +{ + DWORD resData(0); + long keyReturn; + + if(!isOkay()||valueName.isNull())return FALSE; + if(stringData.isNull())keyReturn=::RegSetValueEx((HKEY)*this,valueName.isNull()?0:(LPSTR)valueName,resData,REG_SZ,0,0); + else keyReturn=::RegSetValueEx((HKEY)*this,valueName.isNull()?0:(LPSTR)valueName,resData,REG_SZ,(const unsigned char*)(LPSTR)stringData,stringData.length()+1); + return ERROR_SUCCESS==keyReturn; +} + +WORD RegKey::setValue(const String &valueName,DWORD longData) +{ + DWORD resData(0); + long keyReturn; + + if(!isOkay()||valueName.isNull())return FALSE; + keyReturn=::RegSetValueEx((HKEY)*this,(LPSTR)valueName,resData,REG_DWORD,(const unsigned char*)(LPSTR)&longData,sizeof(DWORD)); + return ERROR_SUCCESS==keyReturn; +} + +WORD RegKey::enumValue(DWORD index,String &nameValue,String &value) +{ + LONG keyResult; + DWORD nameLength; + DWORD valueLength; + DWORD typeCode(REG_SZ); + + if(!isOkay())return FALSE; + nameValue.reserve(MaxDataLength); + value.reserve(MaxDataLength); + nameLength=MaxDataLength; + valueLength=MaxDataLength; + keyResult=::RegEnumValue((HKEY)*this,index,(LPSTR)nameValue,&nameLength,0,&typeCode,(LPBYTE)(LPSTR)value,&valueLength); + return (ERROR_SUCCESS==keyResult); +} + +WORD RegKey::enumValue(DWORD index,String &nameValue,DWORD &longData) +{ + LONG keyResult; + DWORD nameLength; + DWORD valueLength; + DWORD typeCode(REG_DWORD); + + if(!isOkay())return FALSE; + nameValue.reserve(MaxDataLength); + nameLength=MaxDataLength; + valueLength=sizeof(DWORD); + keyResult=::RegEnumValue((HKEY)*this,index,(LPSTR)nameValue,&nameLength,0,&typeCode,(LPBYTE)&longData,&valueLength); + return (ERROR_SUCCESS==keyResult); +} + +WORD RegKey::enumKey(DWORD index,String &strKey) +{ + LONG keyResult; + + if(!isOkay())return FALSE; + strKey.reserve(MaxDataLength); + keyResult=::RegEnumKey((HKEY)*this,index,strKey,MaxDataLength); + return (ERROR_SUCCESS==keyResult); +} + +WORD RegKey::isOpenKey(void)const +{ + return mIsOpenKey; +} + +void RegKey::isOpenKey(WORD isOpenKey) +{ + mIsOpenKey=isOpenKey; +} + +WORD RegKey::isOkay(void)const +{ + if(!isOpenKey()&&isPredefinedKey())return TRUE; + return isOpenKey(); +} + +WORD RegKey::isPredefinedKey(void)const +{ + if(mhKey==(HKEY)ClassesRoot||mhKey==(HKEY)CurrentUser||mhKey==(HKEY)LocalMachine||mhKey==(HKEY)Users)return TRUE; + return FALSE; +} diff --git a/common/REGKEY.HPP b/common/REGKEY.HPP new file mode 100644 index 0000000..155b40c --- /dev/null +++ b/common/REGKEY.HPP @@ -0,0 +1,53 @@ +#ifndef _COMMON_REGKEY_HPP_ +#define _COMMON_REGKEY_HPP_ +#ifndef _COMMON_REGSAM_HPP_ +#include +#endif + +class String; + +class RegKey +{ +public: + enum Key{ClassesRoot=(int)HKEY_CLASSES_ROOT,CurrentUser=(int)HKEY_CURRENT_USER,LocalMachine=(int)HKEY_LOCAL_MACHINE,Users=(int)HKEY_USERS,CurrentConfig=(int)HKEY_CURRENT_CONFIG,DynData=(int)HKEY_DYN_DATA}; + RegKey(void); + RegKey(const RegKey &someRegKey); + RegKey(Key regKey); + virtual ~RegKey(); + RegKey &operator=(const RegKey &someRegKey); + WORD operator==(const RegKey &someRegKey); + operator HKEY(void)const; + WORD openKey(const RegKey &openKey,const String &subKey,const RegSam ®Sam=RegSam()); + WORD openKey(const String &subKey,const RegSam ®Sam=RegSam()); + WORD openKey(Key regKey,const String &subKey,const RegSam ®Sam=RegSam()); + void closeKey(void); + WORD enumValue(DWORD index,String &nameValue,String &value); + WORD enumValue(DWORD index,String &valueName,DWORD &longData); + WORD enumKey(DWORD index,String &strKey); + WORD connectRegistry(const String &computerName,const RegKey ®Key); + WORD deleteKey(const String &subKey); + WORD deleteValue(const String &namedValue); + WORD createKey(Key regKey,const String &subKey,const RegSam ®Sam=RegSam()); + WORD createKey(const RegKey &openKey,const String &subKey,const String &className,const RegSam ®Sam=RegSam()); + WORD createKey(const String &subKey,const String &className,const RegSam ®Sam=RegSam()); + WORD queryValue(const String &valueName,String &stringData)const; + WORD queryValue(const String &valueName,DWORD &longData)const; + WORD setValue(const String &valueName,DWORD longData); + WORD setValue(const String &valueName,const String &stringData); + WORD isOpenKey(void)const; + WORD isOkay(void)const; +private: + enum {MaxDataLength=256}; + enum Disposition{KeepKey,CloseKey,InvalidKey}; + void isOpenKey(WORD isOpenKey); + WORD isPredefinedKey(void)const; + WORD createDescendKey(const String &subKey,const String &className,const RegSam ®Sam); + WORD descendKey(const RegKey &openKey,const String &subKey,const RegSam ®Sam); + + HKEY mhKey; + HKEY mhPrevKey; + WORD mIsOpenKey; + Disposition mDisposition; +}; +#endif + diff --git a/common/REGSAM.HPP b/common/REGSAM.HPP new file mode 100644 index 0000000..e5d3a1b --- /dev/null +++ b/common/REGSAM.HPP @@ -0,0 +1,87 @@ +#ifndef _COMMON_REGSAM_HPP_ +#define _COMMON_REGSAM_HPP_ +#ifndef _COMMON_SHELLAPI_HPP_ +#include +#endif + +class RegSam +{ +public: + enum Sam{AllAccess=KEY_ALL_ACCESS,CreateLink=KEY_CREATE_LINK,CreateSubKey=KEY_CREATE_SUB_KEY, + EnumerateSubKeys=KEY_ENUMERATE_SUB_KEYS,Execute=KEY_EXECUTE,Notify=KEY_NOTIFY, + QueryValue=KEY_QUERY_VALUE,Read=KEY_READ,SetValue=KEY_SET_VALUE,Write=KEY_WRITE}; + RegSam(void); + RegSam(Sam sam); + RegSam(const RegSam &someRegSam); + virtual ~RegSam(); + RegSam &operator=(const RegSam &someRegSam); + RegSam &operator+=(Sam sam); + WORD operator==(const RegSam &someRegSam); + operator DWORD(void)const; + DWORD regSam(void)const; + void regSam(DWORD regSam); +private: + DWORD mRegSam; +}; + +inline +RegSam::RegSam(void) +: mRegSam(AllAccess|Execute|Read|Write) +{ +} + +inline +RegSam::RegSam(Sam sam) +: mRegSam(sam) +{ +} + +inline +RegSam::RegSam(const RegSam &someRegSam) +{ + *this=someRegSam; +} + +inline +RegSam::~RegSam() +{ +} + +inline +RegSam &RegSam::operator=(const RegSam &someRegSam) +{ + regSam(someRegSam.regSam()); + return *this; +} + +inline +RegSam &RegSam::operator+=(Sam sam) +{ + mRegSam|=sam; + return *this; +} + +inline +WORD RegSam::operator==(const RegSam &someRegSam) +{ + return regSam()==someRegSam.regSam(); +} + +inline +RegSam::operator DWORD(void)const +{ + return mRegSam; +} + +inline +DWORD RegSam::regSam(void)const +{ + return mRegSam; +} + +inline +void RegSam::regSam(DWORD regSam) +{ + mRegSam=regSam; +} +#endif \ No newline at end of file diff --git a/common/RESBMP.CPP b/common/RESBMP.CPP new file mode 100644 index 0000000..3e0aef7 --- /dev/null +++ b/common/RESBMP.CPP @@ -0,0 +1,20 @@ +#include + +ResBitmap::ResBitmap(const String &strBitmapName) +: ResData(strBitmapName,ResType::RtBitmap), mpBitmapData(0), mStrBitmapName(strBitmapName) +{ + if(!isOkay())return; + (BitmapInfo&)*this=*((BITMAPINFO*)(unsigned char*)(ResData&)*this); + (PurePalette&)*this=*((BITMAPINFO*)(unsigned char*)(ResData&)*this); + mpBitmapData=(unsigned char*)((ResData&)*this)+sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*colorImportant()); +} + +ResBitmap::ResBitmap(const String &strBitmapName,HMODULE hResModule) +: ResData(strBitmapName,ResType::RtBitmap,hResModule), mpBitmapData(0), mStrBitmapName(strBitmapName) +{ + if(!isOkay())return; + (BitmapInfo&)*this=*((BITMAPINFO*)(unsigned char*)(ResData&)*this); + (PurePalette&)*this=*((BITMAPINFO*)(unsigned char*)(ResData&)*this); + mpBitmapData=(unsigned char*)((ResData&)*this)+sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*colorImportant()); +} + diff --git a/common/RESBMP.HPP b/common/RESBMP.HPP new file mode 100644 index 0000000..42d28a5 --- /dev/null +++ b/common/RESBMP.HPP @@ -0,0 +1,78 @@ +#ifndef _COMMON_RESBITMAP_HPP_ +#define _COMMON_RESBITMAP_HPP_ +#ifndef _COMMON_RESDATA_HPP_ +#include +#endif +#ifndef _COMMON_BITMAPINFO_HPP_ +#include +#endif +#ifndef _COMMON_PUREPALETTE_HPP_ +#include +#endif + +class ResBitmap : public BitmapInfo, public PurePalette, public ResData +{ +public: + ResBitmap(void); + ResBitmap(const String &strBitmapName); + ResBitmap(const String &strBitmapName,HMODULE hResModule); + virtual ~ResBitmap(); + const String &strBitmapName(void)const; + unsigned char *ptrData(void); + BitmapInfo &getBitmapInfo(void); + PurePalette &getPalette(void); +private: + ResBitmap(const ResBitmap &someResBitmap); + ResBitmap &operator=(const ResBitmap &someResBitmap); + + String mStrBitmapName; + unsigned char *mpBitmapData; +}; + +inline +ResBitmap::ResBitmap(void) +: mpBitmapData(0) +{ +} + +inline +ResBitmap::ResBitmap(const ResBitmap &/*someResBitmap*/) +: mpBitmapData(0) +{ // private implementation +} + +inline +ResBitmap::~ResBitmap() +{ +} + +inline +ResBitmap &ResBitmap::operator=(const ResBitmap &/*someResBitmap*/) +{ // private implementation + return *this; +} + +inline +const String &ResBitmap::strBitmapName(void)const +{ + return mStrBitmapName; +} + +inline +unsigned char *ResBitmap::ptrData(void) +{ + return mpBitmapData; +} + +inline +BitmapInfo &ResBitmap::getBitmapInfo(void) +{ + return (BitmapInfo&)*this; +} + +inline +PurePalette &ResBitmap::getPalette(void) +{ + return (PurePalette&)*this; +} +#endif \ No newline at end of file diff --git a/common/RESDATA.HPP b/common/RESDATA.HPP new file mode 100644 index 0000000..4b531bd --- /dev/null +++ b/common/RESDATA.HPP @@ -0,0 +1,182 @@ +#ifndef _COMMON_RESDATA_HPP_ +#define _COMMON_RESDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class ResType +{ +public: + enum Resource{RtAccelerator=RT_ACCELERATOR,RtBitmap=RT_BITMAP,RtDialog=RT_DIALOG, + RtFont=RT_FONT,RtFontDir=RT_FONTDIR,RtMenu=RT_MENU,RtData=RT_RCDATA, + RtString=RT_STRING,RtMessageTable=RT_MESSAGETABLE,RtCursor=RT_CURSOR, + RtGroupCursor=RT_GROUP_CURSOR,RtIcon=RT_ICON,RtGroupIcon=RT_GROUP_ICON, + RtVersion=RT_VERSION}; +}; + +class ResDisposition +{ +public: + enum Disposition{Assume,Delete,Invalid}; +}; + +template +class ResData +{ +public: + ResData(void); + ResData(const ResData &someResData); + ResData(const String &resName,ResType::Resource resType=ResType::RtData,HMODULE hResModule=GetModuleHandle(0)); + virtual ~ResData(); + ResData &operator=(const ResData &someResData); + ResData &operator=(const String &resName); + operator T*(void)const; + WORD isOkay(void)const; +private: + void create(const String &resName,ResType::Resource resType=ResType::RtData,HMODULE hResModule=::GetModuleHandle(0)); + void destroy(void); + HRSRC resHandle(void)const; + void resHandle(HRSRC resHandle); + HGLOBAL resData(void)const; + void resData(HGLOBAL resData); + ResDisposition::Disposition resDisp(void)const; + void resDisp(ResDisposition::Disposition resDisp); + + HRSRC mhResHandle; + HGLOBAL mhResData; + ResDisposition::Disposition mDisposition; +}; + +template +inline +ResData::ResData(void) +: mhResHandle(0), mhResData(0), mDisposition(ResDisposition::Invalid) +{ +} + +template +inline +ResData::ResData(const ResData &someResData) +: mhResHandle(0), mhResData(0), mDisposition(ResDisposition::Invalid) +{ + *this=someResData; +} + +template +inline +ResData::ResData(const String &resName,ResType::Resource resType,HMODULE hResModule) +: mhResHandle(0), mhResData(0), mDisposition(ResDisposition::Delete) +{ + create(resName,resType,hResModule); +} + +template +inline +ResData::~ResData() +{ + destroy(); +} + +template +inline +ResData &ResData::operator=(const ResData &someResData) +{ + if(!someResData.isOkay())return *this; + destroy(); + resData(someResData.resData()); + resHandle(someResData.resHandle()); + resDisp(ResDisposition::Assume); + return *this; +} + +template +inline +ResData &ResData::operator=(const String &resName) +{ + if(resName.isNull())return *this; + destroy(); + create(resName); + return *this; +} + +template +inline +ResData::operator T*(void)const +{ + return (T*)mhResData; +} + +template +inline +void ResData::create(const String &resName,ResType::Resource resType,HMODULE hResModule) +{ + destroy(); + resHandle(::FindResource(hResModule,resName,(const char*)resType)); + if(!resHandle())return; + resData(::LoadResource(hResModule,mhResHandle)); + resDisp(ResDisposition::Delete); +} + +template +inline +void ResData::destroy(void) +{ + if(!resData()||ResDisposition::Assume==resDisp())return; + ::FreeResource(resData()); + resData(0); + resHandle(0); + resDisp(ResDisposition::Invalid); +} + +template +inline +HRSRC ResData::resHandle(void)const +{ + return mhResHandle; +} + +template +inline +void ResData::resHandle(HRSRC resHandle) +{ + mhResHandle=resHandle; +} + +template +inline +HGLOBAL ResData::resData(void)const +{ + return mhResData; +} + +template +inline +void ResData::resData(HGLOBAL resData) +{ + mhResData=resData; +} + +template +inline +ResDisposition::Disposition ResData::resDisp(void)const +{ + return mDisposition; +} + +template +inline +void ResData::resDisp(ResDisposition::Disposition resDisp) +{ + mDisposition=resDisp; +} + +template +inline +WORD ResData::isOkay(void)const +{ + return (resData()&&resHandle()); +} +#endif diff --git a/common/RGBCOLOR.HPP b/common/RGBCOLOR.HPP new file mode 100644 index 0000000..8daf778 --- /dev/null +++ b/common/RGBCOLOR.HPP @@ -0,0 +1,183 @@ +#ifndef _COMMON_RGBCOLOR_HPP_ +#define _COMMON_RGBCOLOR_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class RGBColor +{ +public: + RGBColor(void); + RGBColor(const RGBColor &someRGBColor); + RGBColor(COLORREF someColor); + RGBColor(unsigned char red,unsigned char green,unsigned char blue); + void red(unsigned char red); + unsigned char red(void)const; + void green(unsigned char green); + unsigned char green(void)const; + void blue(unsigned char blue); + unsigned char blue(void)const; + WORD operator==(const RGBColor &someRGBColor)const; + RGBColor &operator=(const RGBColor &someRGBColor); + RGBColor &operator=(COLORREF someColor); + RGBColor &operator+=(unsigned char colorByte); + RGBColor &operator-=(unsigned char colorByte); + WORD operator<(const RGBColor &someRGBColor)const; + LONG operator-(const RGBColor &someRGBColor)const; + operator COLORREF(void)const; + COLORREF getCOLORREF(void)const; +private: + enum {MaxColorByte=255}; + LONG magnitude(void)const; + unsigned char mRed; + unsigned char mGreen; + unsigned char mBlue; +}; + +inline +RGBColor::RGBColor(void) +: mRed(0), mGreen(0), mBlue(0) +{ +} + +inline +RGBColor::RGBColor(const RGBColor &someRGBColor) +{ + *this=someRGBColor; +} + +inline +RGBColor::RGBColor(COLORREF someColor) +{ + *this=someColor; +} + +inline +RGBColor::RGBColor(unsigned char red,unsigned char green,unsigned char blue) +: mRed(red), mGreen(green), mBlue(blue) +{ +} + +inline +void RGBColor::red(unsigned char red) +{ + mRed=red; +} + +inline +unsigned char RGBColor::red(void)const +{ + return mRed; +} + +inline +void RGBColor::green(unsigned char green) +{ + mGreen=green; +} + +inline +unsigned char RGBColor::green(void)const +{ + return mGreen; +} + +inline +void RGBColor::blue(unsigned char blue) +{ + mBlue=blue; +} + +inline +unsigned char RGBColor::blue(void)const +{ + return mBlue; +} + +inline +RGBColor &RGBColor::operator=(const RGBColor &someRGBColor) +{ + red(someRGBColor.red()); + green(someRGBColor.green()); + blue(someRGBColor.blue()); + return *this; +} + +inline +RGBColor &RGBColor::operator=(COLORREF someColor) +{ + red((BYTE)(someColor&0xFF)); + green((BYTE)((someColor>>8)&0xFF)); + blue((BYTE)((someColor>>16)&0xFF)); + return *this; +} + +inline +WORD RGBColor::operator==(const RGBColor &someRGBColor)const +{ + return (red()==someRGBColor.red()&& + green()==someRGBColor.green()&& + blue()==someRGBColor.blue()); +} + +inline +LONG RGBColor::operator-(const RGBColor &someRGBColor)const +{ + LONG redDiff((LONG)mRed-(LONG)someRGBColor.mRed); + LONG greenDiff((LONG)mGreen-(LONG)someRGBColor.mGreen); + LONG blueDiff((LONG)mBlue-(LONG)someRGBColor.mBlue); + return ((redDiff*redDiff)+(greenDiff*greenDiff)+(blueDiff*blueDiff)); +} + +inline +RGBColor &RGBColor::operator+=(unsigned char colorByte) +{ + short tmpColor; + + tmpColor=(short)mRed+(short)colorByte; + mRed=(tmpColor<=MaxColorByte?tmpColor:MaxColorByte); + tmpColor=(short)mGreen+(short)colorByte; + mGreen=(tmpColor<=MaxColorByte?tmpColor:MaxColorByte); + tmpColor=(short)mBlue+(short)colorByte; + mBlue=(tmpColor<=MaxColorByte?tmpColor:MaxColorByte); + return *this; +} + +inline +RGBColor &RGBColor::operator-=(unsigned char colorByte) +{ + mRed-=(colorByte>=mRed?mRed:colorByte); + mGreen-=(colorByte>=mGreen?mGreen:colorByte); + mBlue-=(colorByte>=mBlue?mBlue:colorByte); + return *this; +} + +inline +RGBColor::operator COLORREF(void)const +{ + return getCOLORREF(); +} + +inline +COLORREF RGBColor::getCOLORREF(void)const +{ + COLORREF thisColor; + + thisColor=(COLORREF)(mBlue)<<16; + thisColor+=(COLORREF)(mGreen)<<8; + thisColor+=mRed; + return thisColor; +} + +inline +WORD RGBColor::operator<(const RGBColor &someRGBColor)const +{ + return magnitude() +#endif + +class RGBQuad : private tagRGBQUAD +{ +public: + RGBQuad(void); + RGBQuad(BYTE red,BYTE green,BYTE blue); + RGBQuad(const RGBQuad &someRGBQuad); + RGBQuad(const tagRGBQUAD &someRGBQUAD); + ~RGBQuad(); // destructor cannot be virtual + operator RGBQUAD(void)const; + RGBQuad &operator=(const RGBQuad &someRGBQuad); + RGBQuad &operator=(const RGBQUAD &someRGBQUAD); + WORD operator==(const RGBQuad &someRGBQuad)const; + BYTE red(void)const; + void red(BYTE red); + BYTE green(void)const; + void green(BYTE green); + BYTE blue(void)const; + void blue(BYTE blue); + RGBQUAD getRGBQUAD(void)const; +private: + BYTE reserved(void)const; + void reserved(BYTE reserved); +}; + +inline +RGBQuad::RGBQuad(void) +{ + tagRGBQUAD::rgbRed=0; + tagRGBQUAD::rgbGreen=0; + tagRGBQUAD::rgbBlue=0; + tagRGBQUAD::rgbReserved=0; +} + +inline +RGBQuad::RGBQuad(BYTE red,BYTE green,BYTE blue) +{ + tagRGBQUAD::rgbRed=red; + tagRGBQUAD::rgbGreen=green; + tagRGBQUAD::rgbBlue=blue; + tagRGBQUAD::rgbReserved=0; +} + +inline +RGBQuad::RGBQuad(const tagRGBQUAD &someRGBQUAD) +{ + red(someRGBQUAD.rgbRed); + green(someRGBQUAD.rgbGreen); + blue(someRGBQUAD.rgbBlue); + reserved(someRGBQUAD.rgbReserved); +} + +inline +RGBQuad::RGBQuad(const RGBQuad &someRGBQuad) +{ + *this=someRGBQuad; +} + +inline +RGBQuad::~RGBQuad() +{ +} + +inline +RGBQuad::operator RGBQUAD(void)const +{ + return getRGBQUAD(); +} + +inline +RGBQUAD RGBQuad::getRGBQUAD(void)const +{ + RGBQUAD rgbQuad; + + rgbQuad.rgbRed=red(); + rgbQuad.rgbGreen=green(); + rgbQuad.rgbBlue=blue(); + return rgbQuad; +} + +inline +RGBQuad &RGBQuad::operator=(const RGBQuad &someRGBQuad) +{ + red(someRGBQuad.red()); + green(someRGBQuad.green()); + blue(someRGBQuad.blue()); + return *this; +} + +inline +RGBQuad &RGBQuad::operator=(const RGBQUAD &someRGBQUAD) +{ + red(someRGBQUAD.rgbRed); + green(someRGBQUAD.rgbGreen); + blue(someRGBQUAD.rgbBlue); + return *this; +} + +inline +WORD RGBQuad::operator==(const RGBQuad &someRGBQuad)const +{ + return (red()==someRGBQuad.red()&& + blue()==someRGBQuad.blue()&& + green()==someRGBQuad.green()); +} + +inline +BYTE RGBQuad::red(void)const +{ + return tagRGBQUAD::rgbRed; +} + +inline +void RGBQuad::red(BYTE red) +{ + tagRGBQUAD::rgbRed=red; +} + +inline +BYTE RGBQuad::green(void)const +{ + return tagRGBQUAD::rgbGreen; +} + +inline +void RGBQuad::green(BYTE green) +{ + tagRGBQUAD::rgbGreen=green; +} + +inline +BYTE RGBQuad::blue(void)const +{ + return tagRGBQUAD::rgbBlue; +} + +inline +void RGBQuad::blue(BYTE blue) +{ + tagRGBQUAD::rgbBlue=blue; +} + +inline +BYTE RGBQuad::reserved(void)const +{ + return tagRGBQUAD::rgbReserved; +} + +inline +void RGBQuad::reserved(BYTE reserved) +{ + tagRGBQUAD::rgbReserved=reserved; +} +#endif diff --git a/common/RICHED.HPP b/common/RICHED.HPP new file mode 100644 index 0000000..22ff208 --- /dev/null +++ b/common/RICHED.HPP @@ -0,0 +1,8 @@ +#ifndef _COMMON_RICHED_HPP_ +#define _COMMON_RICHED_HPP_ +typedef long HRESULT; +#ifndef _COMMON_WINUSER_HPP_ +#include +#endif +#include +#endif diff --git a/common/RICHEDIT.HPP b/common/RICHEDIT.HPP new file mode 100644 index 0000000..031357f --- /dev/null +++ b/common/RICHEDIT.HPP @@ -0,0 +1,69 @@ +#ifndef _COMMON_RICHEDIT_HPP_ +#define _COMMON_RICHEDIT_HPP_ +#ifndef _COMMON_CONTROL_HPP_ +#include +#endif +#ifndef _COMMON_RICHED_HPP_ +#include +#endif + +#ifndef _COMMON_FINDTEXTEX_HPP_ +#include +#endif + +class Font; +class RGBColor; + +class RichEditControl : public Control +{ +public: + enum ScrollAction{ScrollLineDown=SB_LINEDOWN,ScrollLineUp=SB_LINEUP,ScrollPageDown=SB_PAGEDOWN,ScrollPageUp=SB_PAGEUP}; + RichEditControl(void); + RichEditControl(HWND hControlWnd,BOOL destroyWindow=TRUE); + virtual ~RichEditControl(); + BOOL createControl(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,UINT styles=0); + BOOL setTextColor(const RGBColor &textColor)const; + BOOL setBkGndColor(const RGBColor &bkGndColor)const; + BOOL wantReturn(BOOL wantReturn)const; + BOOL setFont(const Font &someFont)const; + BOOL setCharFormat(const String faceName,int charHeight)const; + BOOL limitText(DWORD cchMax)const; + BOOL setReadOnly(BOOL isReadOnly)const; + BOOL getLines(Block &strLines); + BOOL getSelectedText(String &strText)const; + BOOL selectLine(int line)const; + BOOL setLine(int line,const String &strLine)const; + BOOL findText(FindTextEx &findTextEx,BOOL matchCase=TRUE,BOOL wholeWord=TRUE); + BOOL scrollCaret(void)const; + BOOL scrollLine(int cyScroll=1)const; + BOOL scroll(ScrollAction scrollAction)const; + BOOL isDirty(void)const; + BOOL replaceSelection(const String &strReplacementText,BOOL canUndo=TRUE)const; + BOOL cutSelection(BOOL canUndo=TRUE)const; + BOOL pasteSpecial(UINT cbFormat)const; + String getLine(int line)const; + String getCurrentLine(void)const; + int lineCount(void)const; + int lineFromCharPos(int charPos); + int currentLine(void)const; + int firstVisibleLine(void)const; + int charFromPos(const GDIPoint &cursorPoint); + int getCaretPosition(void)const; + void isDirty(BOOL isDirty)const; + void setLimitRect(const Rect &limitRect)const; + void getLimitRect(Rect &limitRect)const; + void copyClipboard(void); + void setCaption(Block &codeLines)const; + void setCaption(const String &strCaption)const; +protected: + int lineIndex(int lineIndex=-1)const; +private: + enum {MaxLine=4096,MaxText=128000}; + void loadLibrary(void); + void freeLibrary(void); + void getLogPixelsy(void); + + int mLogPixelsy; + HINSTANCE mhLibInst; +}; +#endif diff --git a/common/RUBBER.CPP b/common/RUBBER.CPP new file mode 100644 index 0000000..3f18cd5 --- /dev/null +++ b/common/RUBBER.CPP @@ -0,0 +1,33 @@ +#include +#include +#include +#include + +RubberControl::~RubberControl() +{ +} + +void RubberControl::calcRatios(GUIWindow &parentWindow) +{ + Rect clientRect; + Rect controlRect; + Point screenPoint; + + if(!controlWindow().isValid()||!parentWindow.isValid())return; + parentWindow.clientRect(clientRect); + controlWindow().clientRect(controlRect); + parentWindow.clientToScreen(clientRect); + controlWindow().clientToScreen(controlRect); + mRatios[Left]=((float)(controlRect.left()-clientRect.left())/(float)parentWindow.width()); + mRatios[Top]=((float)(controlRect.top()-clientRect.top())/(float)parentWindow.height()); + mRatios[Right]=((float)(clientRect.right()-controlRect.right())/(float)parentWindow.width()); + mRatios[Bottom]=((float)(clientRect.bottom()-controlRect.bottom())/(float)parentWindow.height()); + return; +} + +void RubberControl::moveControl(GUIWindow &/*parentWindow*/,int width,int height) +{ + Rect controlRect(mRatios[Left]*width,mRatios[Top]*height,width-(mRatios[Right]*width),height-(mRatios[Bottom]*height)); + controlWindow().moveWindow(controlRect); +} + diff --git a/common/RUBBER.HPP b/common/RUBBER.HPP new file mode 100644 index 0000000..777eaf0 --- /dev/null +++ b/common/RUBBER.HPP @@ -0,0 +1,75 @@ +#ifndef _COMMON_RUBBERCONTROL_HPP_ +#define _COMMON_RUBBERCONTROL_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class GUIWindow; + +class RubberControl +{ +public: + RubberControl(void); + RubberControl(const RubberControl &someRubberControl); + virtual ~RubberControl(); + RubberControl &operator=(const RubberControl &someRubberControl); + void initControl(GUIWindow &parentWindow); + void moveControl(GUIWindow &parentWindow,int width,int height); + void alignControl(GUIWindow &parentWindow); +protected: + virtual GUIWindow &controlWindow(void)=0; +private: + enum{Left,Top,Right,Bottom}; + enum{VectorPoints=4}; + void calcRatios(GUIWindow &parentWindow); + void zeroInit(void); + + float mRatios[VectorPoints]; + int mControlID; +}; + +inline +RubberControl::RubberControl(void) +{ + zeroInit(); +} + +inline +RubberControl::RubberControl(const RubberControl &someRubberControl) +{ + *this=someRubberControl; +} + +inline +RubberControl &RubberControl::operator=(const RubberControl &someRubberControl) +{ + mRatios[Left]=someRubberControl.mRatios[Left]; + mRatios[Top]=someRubberControl.mRatios[Top]; + mRatios[Right]=someRubberControl.mRatios[Right]; + mRatios[Bottom]=someRubberControl.mRatios[Bottom]; + mControlID=someRubberControl.mControlID; + return *this; +} + +inline +void RubberControl::initControl(GUIWindow &parentWindow) +{ + calcRatios(parentWindow); +} + +inline +void RubberControl::alignControl(GUIWindow &parentWindow) +{ + calcRatios(parentWindow); +} + +inline +void RubberControl::zeroInit(void) +{ + mRatios[Left]=0.00; + mRatios[Top]=0.00; + mRatios[Right]=0.00; + mRatios[Bottom]=0.00; + mControlID=-1; +} +#endif diff --git a/common/Release/common.lib b/common/Release/common.lib new file mode 100644 index 0000000..e245784 Binary files /dev/null and b/common/Release/common.lib differ diff --git a/common/Release/vc60.idb b/common/Release/vc60.idb new file mode 100644 index 0000000..9548227 Binary files /dev/null and b/common/Release/vc60.idb differ diff --git a/common/Richedit.cpp b/common/Richedit.cpp new file mode 100644 index 0000000..5e7e961 --- /dev/null +++ b/common/Richedit.cpp @@ -0,0 +1,315 @@ +#include +#include +#include +#include +#include +#include + +RichEditControl::RichEditControl(void) +: mhLibInst(0) +{ + loadLibrary(); + getLogPixelsy(); +} + +RichEditControl::RichEditControl(HWND hControlWnd,BOOL destroyWindow) +: Control(hControlWnd,destroyWindow), mhLibInst(0) +{ + loadLibrary(); + getLogPixelsy(); +} + +RichEditControl::~RichEditControl() +{ + freeLibrary(); +} + +BOOL RichEditControl::createControl(GUIWindow &parentWnd,const Rect &initRect,UINT controlID,UINT styles) +{ + Control::createControl(WS_EX_CLIENTEDGE,"RICHEDIT","",WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|ES_MULTILINE|ES_SUNKEN|ES_SAVESEL|ES_AUTOHSCROLL|ES_AUTOVSCROLL|styles,initRect,parentWnd,controlID); + if(!isValid())return FALSE; + return isValid(); +} + +void RichEditControl::loadLibrary(void) +{ + freeLibrary(); + mhLibInst=::LoadLibrary("RICHED32.DLL"); +} + +void RichEditControl::freeLibrary(void) +{ + if(!mhLibInst)return; + ::FreeLibrary(mhLibInst); +} + +BOOL RichEditControl::setBkGndColor(const RGBColor &bkGndColor)const +{ + if(!isValid())return FALSE; + sendMessage(EM_SETBKGNDCOLOR,0,(COLORREF)bkGndColor); + return TRUE; +} + +BOOL RichEditControl::limitText(DWORD cchMax)const +{ + if(!isValid())return FALSE; + sendMessage(EM_EXLIMITTEXT,0,(LPARAM)cchMax?cchMax:MaxText); + return TRUE; +} + +BOOL RichEditControl::findText(FindTextEx &findTextEx,BOOL matchCase,BOOL wholeWord) +{ + if(!isValid())return FALSE; + if(-1==sendMessage(EM_FINDTEXTEX,0,(LPARAM)&(findTextEx.findTextEx())))return FALSE; + sendMessage(EM_SETSEL,0,0); + setFocus(); + scrollLine(lineFromCharPos(findTextEx.foundRange().posMin())); // getCaretPosition() + sendMessage(EM_SETSEL,findTextEx.foundRange().posMin(),findTextEx.foundRange().posMax()); + return TRUE; +} + +BOOL RichEditControl::setReadOnly(BOOL isReadOnly)const +{ + if(!isValid())return FALSE; + return sendMessage(EM_SETREADONLY,(WPARAM)isReadOnly,0L); +} + +String RichEditControl::getLine(int lineNumber)const +{ + String strControl; + + if(!isValid())return strControl; + strControl.reserve(MaxLine); + *((int*)(char*)strControl)=MaxLine; + sendMessage(EM_GETLINE,(WPARAM)lineNumber,(LPARAM)(LPSTR)strControl); + return strControl; +} + +BOOL RichEditControl::getSelectedText(String &strText)const +{ + LONG charCount; + if(!isValid())return FALSE; + strText.reserve(MaxText); + charCount=sendMessage(EM_GETSELTEXT,(WPARAM)0,(LPARAM)(LPSTR)strText); + return charCount?TRUE:FALSE; +} + +BOOL RichEditControl::pasteSpecial(UINT cbFormat)const +{ + if(!isValid())return FALSE; + sendMessage(EM_PASTESPECIAL,(WPARAM)cbFormat,0); + return TRUE; +} + +BOOL RichEditControl::cutSelection(BOOL canUndo)const +{ + return replaceSelection(String(),canUndo); +} + +BOOL RichEditControl::replaceSelection(const String &strReplacementText,BOOL canUndo)const +{ + if(!isValid())return FALSE; + sendMessage(EM_REPLACESEL,(WPARAM)canUndo,strReplacementText.isNull()?(LPARAM)0:(LPARAM)(LPSTR)(String&)strReplacementText); + return TRUE; +} + +int RichEditControl::lineFromCharPos(int charPos) +{ + if(!isValid())return 0; + return sendMessage(EM_LINEFROMCHAR,(WPARAM)charPos,0); +} + +BOOL RichEditControl::getLines(Block &strLines) +{ + int lines(lineCount()); + + for(int lineIndex=0;lineIndex &codeLines)const +{ + if(!codeLines.size())return; + String strLine; + for(int lineIndex=0;lineIndex +#endif +#ifndef _COMMON_COORD_HPP_ +#include +#endif +#ifndef _COMMON_SMALLRECT_HPP_ +#include +#endif + +class ConsoleScreenBufferInfo : private CONSOLE_SCREEN_BUFFER_INFO +{ +public: + ConsoleScreenBufferInfo(void); + ConsoleScreenBufferInfo(const ConsoleScreenBufferInfo &someConsoleScreenBufferInfo); + virtual ~ConsoleScreenBufferInfo(); + Coord size(void)const; + void size(const Coord &size); + Coord cursorPos(void)const; + void cursorPos(const Coord &cursorPos); + WORD attributes(void)const; + void attributes(WORD attributes); + SmallRect winRect(void)const; + void winRect(const SmallRect &winRect); + Coord maxWinRect(void)const; + void maxWinRect(const Coord &maxWinRect); +private: + void setZero(void); +}; + +inline +ConsoleScreenBufferInfo::ConsoleScreenBufferInfo(void) +{ +} + +inline +ConsoleScreenBufferInfo::ConsoleScreenBufferInfo(const ConsoleScreenBufferInfo &someConsoleScreenBufferInfo) +{ + *this=someConsoleScreenBufferInfo; +} + +inline +ConsoleScreenBufferInfo::~ConsoleScreenBufferInfo() +{ +} + +inline +Coord ConsoleScreenBufferInfo::size(void)const +{ + return Coord(CONSOLE_SCREEN_BUFFER_INFO::dwSize.X,CONSOLE_SCREEN_BUFFER_INFO::dwSize.Y); +} + +inline +void ConsoleScreenBufferInfo::size(const Coord &size) +{ + CONSOLE_SCREEN_BUFFER_INFO::dwSize.X=size.x(); + CONSOLE_SCREEN_BUFFER_INFO::dwSize.Y=size.y(); +} + +inline +Coord ConsoleScreenBufferInfo::cursorPos(void)const +{ + return Coord(CONSOLE_SCREEN_BUFFER_INFO::dwCursorPosition.X,CONSOLE_SCREEN_BUFFER_INFO::dwCursorPosition.Y); +} + +inline +void ConsoleScreenBufferInfo::cursorPos(const Coord &cursorPos) +{ + CONSOLE_SCREEN_BUFFER_INFO::dwCursorPosition.X=cursorPos.x(); + CONSOLE_SCREEN_BUFFER_INFO::dwCursorPosition.Y=cursorPos.y(); +} + +inline +WORD ConsoleScreenBufferInfo::attributes(void)const +{ + return CONSOLE_SCREEN_BUFFER_INFO::wAttributes; +} + +inline +void ConsoleScreenBufferInfo::attributes(WORD attributes) +{ + CONSOLE_SCREEN_BUFFER_INFO::wAttributes=attributes; +} + +inline +SmallRect ConsoleScreenBufferInfo::winRect(void)const +{ + return SmallRect(CONSOLE_SCREEN_BUFFER_INFO::srWindow.Left, + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Top, + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Right, + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Bottom); +} + +inline +void ConsoleScreenBufferInfo::winRect(const SmallRect &winRect) +{ + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Left=winRect.left(); + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Top=winRect.top(); + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Right=winRect.right(); + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Bottom=winRect.bottom(); +} + +inline +Coord ConsoleScreenBufferInfo::maxWinRect(void)const +{ + return Coord(CONSOLE_SCREEN_BUFFER_INFO::dwMaximumWindowSize.X,CONSOLE_SCREEN_BUFFER_INFO::dwMaximumWindowSize.Y); +} + +inline +void ConsoleScreenBufferInfo::maxWinRect(const Coord &maxWinRect) +{ + CONSOLE_SCREEN_BUFFER_INFO::dwMaximumWindowSize.X=maxWinRect.x(); + CONSOLE_SCREEN_BUFFER_INFO::dwMaximumWindowSize.Y=maxWinRect.y(); +} + +inline +void ConsoleScreenBufferInfo::setZero(void) +{ + CONSOLE_SCREEN_BUFFER_INFO::dwSize.X=0; + CONSOLE_SCREEN_BUFFER_INFO::dwSize.Y=0; + CONSOLE_SCREEN_BUFFER_INFO::dwCursorPosition.X=0; + CONSOLE_SCREEN_BUFFER_INFO::dwCursorPosition.Y=0; + CONSOLE_SCREEN_BUFFER_INFO::wAttributes=0; + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Left=0; + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Top=0; + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Right=0; + CONSOLE_SCREEN_BUFFER_INFO::srWindow.Bottom=0; + CONSOLE_SCREEN_BUFFER_INFO::dwMaximumWindowSize.X=0; + CONSOLE_SCREEN_BUFFER_INFO::dwMaximumWindowSize.Y=0; +} +#endif diff --git a/common/SDATE.CPP b/common/SDATE.CPP new file mode 100644 index 0000000..f36cff7 --- /dev/null +++ b/common/SDATE.CPP @@ -0,0 +1,1026 @@ +#include +#include +#include +#include +#include + +SDate::SDate(void) +{ + initArray(); + getTodaysDate(); +} + +SDate::SDate(const CompatibleDate &someDate) +{ + initArray(); + CompatibleDate::Month=someDate.Month; + CompatibleDate::Day=someDate.Day; + CompatibleDate::Year=someDate.Year; +} + +SDate::SDate(long someLongDate) +{ + initArray(); + *this=someLongDate; +} + +SDate::SDate(unsigned char month,unsigned char day,unsigned year) +{ + initArray(); + CompatibleDate::Month=month; + CompatibleDate::Day=day; + CompatibleDate::Year=year; +} + +SDate::SDate(const SDate &someDate) +{ + initArray(); + CompatibleDate::Month=someDate.CompatibleDate::Month; + CompatibleDate::Day=someDate.CompatibleDate::Day; + CompatibleDate::Year=someDate.CompatibleDate::Year; +} + +SDate::SDate(Options dateOptions) +{ + initArray(); + switch(dateOptions) + { + case TodaysDate : + getTodaysDate(); + break; + default : + break; + } +} + +SDate::~SDate() +{ +} + +void SDate::getTodaysDate(void) +{ + struct tm *lpTime; + time_t currTime; + + ::time(&currTime); + lpTime=::localtime(&currTime); + CompatibleDate::Month=lpTime->tm_mon+1; + CompatibleDate::Day=lpTime->tm_mday; + CompatibleDate::Year=lpTime->tm_year+1900; +} + +SDate &SDate::operator=(const CompatibleDate &someDate) +{ + CompatibleDate::Month=(unsigned)someDate.Month; + CompatibleDate::Day=(unsigned)someDate.Day; + CompatibleDate::Year=(unsigned)someDate.Year; + return *this; +} + +SDate &SDate::operator=(long someLongDate) +{ + CompatibleDate::Year=(unsigned)(someLongDate/10000L); + CompatibleDate::Month=(unsigned)((someLongDate/100L)-((long)CompatibleDate::Year*100L)); + CompatibleDate::Day=(unsigned)(someLongDate-(((long)CompatibleDate::Year*10000L)+((long)CompatibleDate::Month*100L))); + return *this; +} + +int SDate::operator<(const CompatibleDate &someDate)const +{ + if (CompatibleDate::YearsomeDate.Year) return FALSE; + if (CompatibleDate::MonthsomeDate.Month) return FALSE; + return(CompatibleDate::Day(const CompatibleDate &someDate)const +{ + if (CompatibleDate::Year>someDate.Year) return TRUE; + if (CompatibleDate::YearsomeDate.Month) return TRUE; + if (CompatibleDate::MonthsomeDate.Day); +} + +int SDate::operator==(const CompatibleDate &someDate)const +{ + return (CompatibleDate::Month==someDate.Month && + CompatibleDate::Day==someDate.Day && + CompatibleDate::Year==someDate.Year + ); +} + +int SDate::operator<=(const CompatibleDate &someDate)const +{ + if(!(operator<(someDate)))return operator==(someDate); + return TRUE; +} + +int SDate::month(void)const +{ + return CompatibleDate::Month; +} + +void SDate::month(int newMonth) +{ + CompatibleDate::Month=newMonth; +} + +int SDate::day(void)const +{ + return CompatibleDate::Day; +} + +void SDate::day(int newDay) +{ + CompatibleDate::Day=newDay; +} + +int SDate::year(void)const +{ + return CompatibleDate::Year; +} + +void SDate::year(int newYear) +{ + CompatibleDate::Year=newYear; +} + +long SDate::makeLong(void)const +{ + return 10000L*CompatibleDate::Year + 100L*CompatibleDate::Month + CompatibleDate::Day; +} + +String SDate::makeString(void)const +{ + String tempString; + + tempString.reserve(String::MaxString); + ::sprintf((LPSTR)tempString,"%02d/%02d/%04d", + CompatibleDate::Month, + CompatibleDate::Day, + CompatibleDate::Year); + return tempString; +} + +SDate SDate::monthYearStringToDate(char *str,short default_day) +{ + SDate null_date; + SDate return_date; + SDate cur_date; + short n_items; + short first_num; + short second_num; + short third_num; + short first_two_digits; + short second_two_digits; + short last_two_digits; + short first_four_digits; + short last_four_digits; + char s[256]; + char s2[80]; + char first[32]; + char second[32]; + char third[32]; + char *ps; + char *ps2; + unsigned short ndays[sizeof(mDayArray)/sizeof(WORD)]; + + ::memcpy(ndays,mDayArray,sizeof ndays); + cur_date=SDate(SDate::TodaysDate); + ::memset(&null_date,0,sizeof(null_date)); + ::memset(first,0,sizeof(first)); + ::memset(second,0,sizeof(second)); + ::memset(third,0,sizeof(third)); + if(!str)return null_date; + + if(::strlen(str)>255)::strncpy(s,str,255); + else ::strcpy(s,str); + ::strupr(s); + for(ps=s,ps2=s2;*ps!='\0';++ps) + { + if(!isalnum(*ps)) + { + *ps=' '; + if(ps2==s2)continue; + } + if(ps2>s2) + { + if(isdigit(*(ps2-1))&&isalpha(*ps)||isalpha(*(ps2-1)) && isdigit(*ps)) + { + *ps2=' '; + ++ps2; + } + else + if(*(ps2-1)==' '&&*ps==' ')continue; + } + *ps2=*ps; + ++ps2; + } + *ps2='\0'; /* Terminating null */ + strcpy(s,s2); + n_items=::sscanf(s," %s %s %s",first,second,third); + if(n_items<=0)return null_date; + if(1==n_items) + { + long single_num; + if(isalpha(first[0])) /* Not a numeric value */ + { + return_date.Month=stringToMonth(first); + if(0==return_date.Month)return null_date; + return_date.Year=cur_date.Year; + if(0==default_day) + { + if(2==return_date.Month&&((short)return_date.Year%4))ndays[2]=28; + default_day=ndays[return_date.Month]; + } + else + if(default_day<1||default_day>ndays[return_date.Month])return null_date; + return_date.Day=default_day; + return return_date; + } + single_num=::atol(first); + if(single_num>1000||(first[0]=='0'&&single_num>=100)) + { + if (single_num>100000) + { + first_two_digits=(first[0]-'0')*10+(first[1]-'0'); + second_two_digits=(first[2]-'0')*10+(first[3]-'0'); + last_two_digits=single_num%100; + } + else + if(single_num>10000) + { + first_four_digits=single_num/10; + last_four_digits=single_num%10000; + if(last_four_digits>=1960&&last_four_digits<=2060) + { + return_date.Year=last_four_digits; + return_date.Month=single_num/10000; + if(0==default_day) + { + if(2==return_date.Month&&((short)return_date.Year%4))ndays[2]=28; + default_day=ndays[return_date.Month]; + } + return_date.Day=default_day; + n_items=0; + } + else + if(first_four_digits>=1960&&first_four_digits<=2060&&(single_num%10)!=0) + { + return_date.Year=first_four_digits; + return_date.Month=single_num%10; + if(0==default_day) + { + if(return_date.Month==2&&((short)return_date.Year%4))ndays[2]=28; + default_day=ndays[return_date.Month]; + } + return_date.Day=default_day; + n_items=0; + } + else + { + first_two_digits=(first[0]-'0')*10+(first[1]-'0'); + last_two_digits=single_num%100; + second_num=single_num/100; + if((second_num % 100) <= 31 && (second_num / 100) != 0) + { + sprintf(second, "%d", second_num / 100); /* Month or day string */ + sprintf(third, "%d", second_num % 100); /* Day or month string */ + return_date=stringToMonthDay(second,third); + return_date.Year = last_two_digits; + n_items = 0; + } + else + if ((second_num % 10) > 0 || (second_num / 10) <= 31) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + return_date = stringToMonthDay(second, third); + return_date.Year = last_two_digits; + n_items = 0; + } + else /* Assume first 2 digits are the year */ + { + second_num = single_num % 1000; /* Assume first 2 digits are yr */ + if ((second_num % 100) <= 31 && (second_num / 100) != 0) + { + sprintf(second, "%d", second_num / 100); /* Month or day string */ + sprintf(third, "%d", second_num % 100); /* Day or month string */ + return_date = stringToMonthDay(second, third); + return_date.Year = first_two_digits; + n_items = 0; + } + else + if ((second_num % 10) > 0 || (second_num / 10) <= 31) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + return_date = stringToMonthDay(second, third); + return_date.Year = first_two_digits; + n_items = 0; + } + else /* Nothing works */ + { + sprintf(second, "%d", second_num / 100); /* Month or day string */ + sprintf(third, "%d", second_num % 100); /* Day or month string */ + return_date = stringToMonthDay(second, third); + return_date.Year = last_two_digits; + n_items = 0; + } + } + } + } + else /* Only 4 digits */ + { + first_two_digits = (first[0] - '0') * 10 + (first[1] - '0'); + last_two_digits = single_num % 100; + + if ((last_two_digits < 1 || last_two_digits > 12) && + first_two_digits >= 1 && first_two_digits <= 12) + { /* Definitely MMYY */ + return_date.Year = last_two_digits; + return_date.Month = first_two_digits; + if (default_day == 0) + { + if (return_date.Month == 2 && ((short)return_date.Year % 4)) + ndays[2] = 28; /* Not a leap year */ + default_day = ndays[return_date.Month]; + } + return_date.Day = default_day; + n_items = 0; + } + else + if ((first_two_digits < 1 || first_two_digits > 12) && + last_two_digits >= 1 && last_two_digits <= 12) + { /* Definitely YYMM */ + return_date.Year = last_two_digits; + return_date.Month = last_two_digits; + if (default_day == 0) + { + if (return_date.Month == 2 && ((short)return_date.Year % 4)) + ndays[2] = 28; /* Not a leap year */ + default_day = ndays[return_date.Month]; + } + return_date.Day = default_day; + n_items = 0; + } + else + if (first_two_digits >= 1 && first_two_digits <= 12) + { /* Qualifies as MMYY */ + return_date.Year = last_two_digits; + return_date.Month = first_two_digits; + if (default_day == 0) + { + if (return_date.Month == 2 && ((short)return_date.Year % 4)) + ndays[2] = 28; /* Not a leap year */ + default_day = ndays[return_date.Month]; + } + return_date.Day = default_day; + n_items = 0; + } + else /* Might be month/day/year combination */ + { + if (first[0] == '0' || first[1] == '0') + { /* First two digits are most likely the year */ + second_two_digits = first[2] - '0'; + last_two_digits = first[3] - '0'; + } + else + if (first[2] == '0' || first[3] == '0') + { /* Last two digits are most likely the year */ + first_two_digits = first[0] - '0'; + second_two_digits = first[1] - '0'; + } + else + if ((last_two_digits < 30 || last_two_digits > 80) && + first_two_digits >= 30 && first_two_digits <= 80) + { /* Last two digits are most likely the year */ + first_two_digits = first[0] - '0'; + second_two_digits = first[1] - '0'; + } + else + if ((first_two_digits < 30 || first_two_digits > 80) && + last_two_digits >= 30 && last_two_digits <= 80) + { /* First two digits are most likely the year */ + second_two_digits = first[2] - '0'; + last_two_digits = first[3] - '0'; + } + else /* Really don't know; assume last two digits are year */ + { /* Last two digits are most likely the year */ + first_two_digits = first[0] - '0'; + second_two_digits = first[1] - '0'; + } + } + } + + if (n_items == 1) + if (last_two_digits == 0 || last_two_digits > 31) + { /* Last two digits are definitely the year */ + if (single_num > 1000000) /* It is a 4-digit year */ + second_num = single_num / 10000; + else /* It is a 2-digit year */ + second_num = single_num / 100; + + sprintf(second, "%d", second_num / 100); /* Month or day string */ + sprintf(third, "%d", second_num % 100); /* Day or month string */ + if ((second_num % 100) > 31 || (second_num / 100) == 0) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + } + return_date = stringToMonthDay(second, third); + return_date.Year = last_two_digits; + n_items = 0; + } + else + if (first_two_digits == 0 || first_two_digits > 31) + { /* First 2 digits are the year */ + second_num = atoi(&first[2]); + sprintf(second, "%d", second_num / 100); + sprintf(third, "%d", second_num % 100); + if ((second_num % 100) > 31 || (second_num / 100) == 0) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + } + return_date = stringToMonthDay(second, third); + return_date.Year = first_two_digits; + n_items = 0; + } + else + if (second_two_digits == 0 || second_two_digits > 31) + { /* Second 2 digits are the year, assume 4-digit year was given */ + second_num = atoi(&first[4]); + sprintf(second, "%d", second_num / 100); + sprintf(third, "%d", second_num % 100); + if ((second_num % 100) > 31 || (second_num / 100) == 0) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + } + return_date = stringToMonthDay(second, third); + return_date.Year = first_two_digits * 100 + second_two_digits; + n_items = 0; + } + else /* Can't tell from looking for 2-digit years; try 4-digit yrs */ + { + short first_four_digits, last_four_digits; + + strncpy(second, first, 4); + second[4] = '\0'; + first_four_digits = atoi(second); + last_four_digits = single_num % 10000; + + if (last_four_digits >= 1960 && last_four_digits <= 2060) + { /* Last 4 digits are definitely the year */ + second_num = single_num / 10000; + sprintf(second, "%d", second_num / 100); + sprintf(third, "%d", second_num % 100); + if ((second_num % 100) > 31 || (second_num / 100) == 0) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + } + return_date = stringToMonthDay(second, third); + return_date.Year = last_four_digits; + n_items = 0; + } + else /* Give up; assume YYMMDD format */ + if (first_four_digits >= 1960 && first_four_digits <= 2060) + { /* First 4 digits are definitely the year */ + second_num = atoi(&first[4]); + sprintf(second, "%d", second_num / 100); + sprintf(third, "%d", second_num % 100); + if ((second_num % 100) > 31 || (second_num / 100) == 0) + { /* Split it differently */ + sprintf(second, "%d", second_num / 10); + sprintf(third, "%d", second_num % 10); + } + return_date = stringToMonthDay(second, third); + return_date.Year = first_four_digits; + n_items = 0; + } + else + { + sprintf(first, "%d", first_two_digits); + sprintf(second, "%d", second_two_digits); + sprintf(third, "%d", last_two_digits); + n_items = 3; + } + } + } + else /* 3 or fewer digits */ + { + return null_date; /* Does not qualify as month/year */ + } + } + + switch (n_items) + { + case 0: /* This means we already parsed the date */ + break; + case 1: /* Only 1 item scanned, assume it is a month */ + return_date.Month = atoi(first); + if (return_date.Month >= 1 && return_date.Month <= 12) + { + return_date.Year = cur_date.Year; + if (default_day == 0) + { + if (return_date.Month == 2 && ((short)return_date.Year % 4)) + ndays[2] = 28; /* Not a leap year */ + default_day = ndays[return_date.Month]; + } + return_date.Day = default_day; + } + else /* Not a valid month number; an error */ + return null_date; + break; + + case 2: /* 2 items scanned, assume month and year */ + { + short n_days; + + return_date=stringToMonthYear(first, second); + + if (*(long *)&return_date) /* It was month/year */ + { + if (default_day == 0) + { + if (return_date.Month == 2 && ((short)return_date.Year % 4)) + ndays[2] = 28; /* Not a leap year */ + if (return_date.Month >= 1 && return_date.Month <= 12) + default_day = ndays[return_date.Month]; + } + return_date.Day = default_day; + } + else /* Not month/year */ + { + return_date = stringToMonthDay(first, second); + return_date.Year = cur_date.Year; + n_days = daysBetweenActual(cur_date, return_date); + if (n_days < -182) /* More than 6 months back */ + ++return_date.Year; /* Assume it's next year */ + else + if (n_days > 182) /* More than 6 months in the future */ + --return_date.Year; /* Assume it's last year */ + } + break; + } + case 3: /* 3 items scanned, assume month, day, and year */ + first_num = atoi(first); + second_num = atoi(second); + third_num = atoi(third); + if (first_num > 31) /* First item is a year */ + { + return_date = stringToMonthDay(second, third); + return_date.Year = first_num; + } + else + if (third_num > 31) /* Third item is a year */ + { + return_date = stringToMonthDay(first, second); + return_date.Year = third_num; + } + else + if (second_num > 31) /* Second item might be a year? */ + { + return_date = stringToMonthDay(first, third); + return_date.Year = second_num; + } + else + if (isalpha(first[0])) /* First item is a month */ + { /* Assume second is day, third is year */ + return_date = stringToMonthDay(first, second); + return_date.Year = third_num; + } + else + if (isalpha(second[0])) /* Second item is a month */ + { /* Assume first is day, third is year */ + return_date = stringToMonthDay(first, second); + return_date.Year = third_num; + } + else + if (isalpha(third[0])) /* Third item might be a month? */ + { /* Assume first is year, second is day */ + return_date = stringToMonthDay(second, third); + return_date.Year = first_num; + } + else /* Assume month, day, year */ + { + return_date = stringToMonthDay(first, second); + return_date.Year = third_num; + } + break; + } /* End of switch */ + + if (return_date.Month < 1 || return_date.Month > 12) + return null_date; /* Month is out of range */ + + if (return_date.Day < 1 || return_date.Day > ndays[return_date.Month]) + { /* Day of month is out of range */ + if (default_day == 0) + { + if (return_date.Month == 2 && ((short)return_date.Year % 4)) + ndays[2] = 28; /* Not a leap year */ + default_day = ndays[return_date.Month]; + } + return_date.Day = default_day; + } + + if (((short)return_date.Year % 4) != 0) /* Not a leap year */ + ndays[2] = 28; + + if (return_date.Year > 1900) + return return_date; /* A valid date */ + + if (return_date.Year >= 100) /* Lotus format date for 21st century */ + { + return_date.Year = 2000 + ((short)return_date.Year % 100); + return return_date; + } + + if (return_date.Year > 60) + return_date.Year += 1900; + else + return_date.Year += 2000; + + return return_date; + +} + +short SDate::stringToMonth(char *szMonth)const /* Converts string to month number */ +{ + String strMonth(szMonth); + char *str; + + if(strMonth.isNull())return FALSE; + strMonth.upper(); + str=(char*)strMonth; + switch (str[0]) /* Look at first character to determine month */ + { + case 'F': /* February */ + return 2; + case 'S': /* September */ + return 9; + case 'O': /* October */ + return 10; + case 'N': /* November */ + return 11; + case 'D': /* December */ + return 12; + case 'J': /* January, June, or July */ + switch (str[1]) /* Look at second character */ + { + case 'A': /* January */ + return 1; + case 'U': /* June or July */ + switch (str[2]) /* Look at third character */ + { + case 'N': /* June */ + return 6; + case 'L': /* July */ + return 7; + } /* End of switch (str[2]) */ + break; + case 'E': /* June */ + return 6; + case 'L': /* July */ + return 7; + } /* End of switch (str[1]) */ + + return 0; /* Cannot determine what month this is */ + + case 'M': /* March or May */ + switch (str[1]) /* Look at second character */ + { + case 'A': /* March or May */ + switch (str[2]) /* Look at third character */ + { + case 'R': /* March */ + return 3; + case 'Y': /* May */ + return 5; + } /* End of switch (str[2]) */ + return 0; /* Cannot determine the month */ + case 'R': /* March */ + return 3; + case 'Y': + return 5; + } /* End of switch (str[1]) */ + + return 0; /* Cannot determine what month this is */ + + case 'A': /* April or August */ + switch (str[1]) /* Look at second character */ + { + case 'P': /* April */ + case 'R': + return 4; + case 'U': /* August */ + case 'G': + return 8; + } /* End of switch (str[1]) */ + + return 0; /* Cannot determine what month this is */ + + default: + return 0; /* Cannot determine what month this is */ + } +} + +SDate SDate::stringToMonthDay(char *first, char *second) +{ + SDate return_date; + short first_num; + short second_num; + + ::memset(&return_date,0,sizeof(return_date)); + if(isalpha(first[0])) + { + return_date.month(stringToMonth(first)); + return_date.day(::atoi(second)); + return return_date; + } + if (isalpha(second[0])) /* Second item is a month */ + { + return_date.month(stringToMonth(second)); + return_date.day(::atoi(first)); + return return_date; + } + first_num=::atoi(first); + second_num=::atoi(second); + if(first_num>12) + { + return_date.day(first_num); + return_date.month(second_num); + return return_date; + } + if(second_num>12) + { + return_date.day(second_num); + return_date.month(first_num); + return return_date; + } + return_date.month(first_num); + return_date.day(second_num); + return return_date; +} + +SDate SDate::stringToMonthYear(char *first, char *second) +{ + SDate return_date; + short first_num, second_num; + + ::memset(&return_date, 0, sizeof return_date); + if(isalpha(first[0])) /* First item is a month */ + { + return_date.month(stringToMonth(first)); + return_date.year(::atoi(second)); + return return_date; + } + if(isalpha(second[0])) /* Second item is a month */ + { + return_date.month(stringToMonth(second)); + return_date.year(::atoi(first)); + return return_date; + } + first_num=::atoi(first); + second_num=::atoi(second); + if((second_num<1||second_num>12)&&first_num>=1&&first_num<=12) + { + return_date.year(second_num); + return_date.month(first_num); + return return_date; + } + else + if((first_num<1||first_num>12)&&second_num>=1&&second_num<=12) + { + return_date.year(first_num); + return_date.month(second_num); + return return_date; + } + else + if(first_num>=1&&first_num<=12) + { + return_date.year(second_num); + return_date.month(first_num); + return return_date; + } + return_date.year(first_num); + return_date.month(second_num); + return return_date; +} + +short SDate::daysBetweenActual(SDate toDate)const +{ + return daysBetweenActual(*this,toDate); +} + +short SDate::daysBetweenActual(SDate fromDate,SDate toDate)const +{ + short fromCount; + short fromDay; + short fromMonth; + short fromYear; + short fromQuad; + short toCount; + short toDay; + short toMonth; + short toYear; + short toQuad; + short daysTo[13]; + + daysTo[0]=0; + daysTo[1]=0; + daysTo[2]=31; + daysTo[3]=59; + daysTo[4]=90; + daysTo[5]=120; + daysTo[6]=151; + daysTo[7]=181; + daysTo[8]=212; + daysTo[9]=243; + daysTo[10]=273; + daysTo[11]=304; + daysTo[12]=334; + + if(fromDate.makeLong()<19010101|| + fromDate.makeLong()>20991231|| + toDate.makeLong()<19010101|| + toDate.makeLong()>20991231)return FALSE; + fromDay=fromDate.day(); + fromMonth=fromDate.month(); + fromYear=((short)fromDate.year()-1)%4; + fromQuad=((short)fromDate.year()-1)/4; + fromCount=fromDay+daysTo[fromMonth]+fromYear*365+fromQuad*((4*365)+1); + if(3==fromYear&&fromMonth>2)++fromCount; + toDay=toDate.day(); + toMonth=toDate.month(); + toYear=((short)toDate.year()-1)%4; + toQuad=((short)toDate.year()-1)/4; + toCount=toDay+daysTo[toMonth]+toYear*365+toQuad*((4*365)+1); + if(3==toYear&&toMonth>2)++toCount; + return toCount-fromCount; +} + +SDate SDate::daysAdd360(short dayCount) +{ + long days; + WORD thirtyOne; + SDate toDate; + + if(!year()&&!day()&&!month())return *this; + if(!dayCount)return *this; + thirtyOne=(31==day()); + if(thirtyOne)day(30); + if(2==month()&&day()>27) + { + int daysInMonth=!(year%4)&&(year%100)||!(year%400)?28:29; + if(day()>=daysInMonth)day(30); + } + days=360*(long)year()+30*(long)month()+(long)day()+dayCount-391; + toDate.day((short)(days%30)+1); + toDate.month((short)(days/30)%12+1); + toDate.year((short)(days/360)+1); + if(!(dayCount%30)&&thirtyOne) + { + switch(toDate.month()) + { + case 1 : + case 3 : + case 5 : + case 7 : + case 8 : + case 10 : + case 12 : + toDate.day(toDate.day()+1); + break; + } + } + return toDate; +} + +SDate SDate::daysAddActual(short actualDays)const +{ + return daysAddActual(*this,actualDays); +} + +SDate SDate::daysAddActual(SDate fromDate,short actualDays)const +{ + short day; + short month; + short year; + short daysInMonth; + short days360; + short dayCount; + SDate date360; + SDate returnDate; + + if(!fromDate.day()&&!fromDate.month()&&!fromDate.year())return fromDate; + days360=((float)actualDays*360.00/365.24)+.5; + +// date360=fromDate.daysAdd360(days360); + date360=SDate(fromDate).daysAdd360(days360); + + dayCount=actualDays-daysBetweenActual(fromDate,date360); + day=date360.day(); + month=date360.month(); + year=date360.year(); + if(dayCount>=0) + { + while(dayCount>0) + { + switch(month) + { + case 2 : + if(!(year%4)&&(year%100)||!(year%400))daysInMonth=29; + else daysInMonth=28; + break; + case 4 : + case 6 : + case 9 : + case 11 : + daysInMonth=30; + break; + case 1: + case 3: + case 5: + case 7: + case 8: + case 10: + case 12: + daysInMonth=31; + break; + } + if(dayCount<=(daysInMonth-day)){day+=dayCount;dayCount=0;} + else + { + dayCount-=daysInMonth-day+1; + month=(month%12)+1; + day=1; + if(1==month)++year; + } + } + } + else + { + while(dayCount<0) + { + if(abs(dayCount)=30) + { + if(toDate.day()>=30)return (short)(360*((long)toDate.year()-(long)fromDate.year())+30*((long)toDate.month()-(long)fromDate.month())); + fromDate.day(30); + } + return (short)(360*((long)toDate.year()-(long)fromDate.year())+30*((long)toDate.month()-(long)fromDate.month())+(long)toDate.day()-(long)fromDate.day()); +} + + diff --git a/common/SDATE.HPP b/common/SDATE.HPP new file mode 100644 index 0000000..4a631f5 --- /dev/null +++ b/common/SDATE.HPP @@ -0,0 +1,132 @@ +#ifndef _COMMON_SDATE_HPP_ +#define _COMMON_SDATE_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +typedef struct CompatibleDate +{ + unsigned Day : 8; + unsigned Month : 8; + unsigned Year : 16; +}COMPATIBLEDATE; + +class SDate : public CompatibleDate +{ +public: + enum Options{TodaysDate}; + SDate(void); + SDate(long someLongDate); + SDate(const SDate &someDate); + SDate(unsigned char month,unsigned char day,unsigned year); + SDate(const CompatibleDate &someDate); + SDate(Options dateOptions); + SDate(const String &someString); + virtual ~SDate(); + SDate &operator=(const CompatibleDate &someCompatibleDate); + SDate &operator=(long someLongDate); + SDate &operator=(const String &someString); + int operator<(const CompatibleDate &someDate)const; + int operator>(const CompatibleDate &someDate)const; + int operator==(const CompatibleDate &someDate)const; + int operator<=(const CompatibleDate &someDate)const; + short operator-(const SDate &someDate); + SDate &operator+=(short dayCount); + String makeString(void)const; + String toString(void)const; + long makeLong(void)const; + int month(void)const; + int day(void)const; + int year(void)const; + void month(int newMonth); + void day(int newDay); + void year(int newYear); + short monthsBetween360(SDate toDate)const; + short daysBetween360(SDate toDate)const; + short daysBetweenActual(SDate toDate)const; + short daysBetweenActual(SDate fromDate,SDate toDate)const; + SDate daysAdd360(short dayCount); + SDate daysAddActual(short actualDays)const; + SDate daysAddActual(SDate fromDate,short actualDays)const; + short stringToMonth(char *str)const; +private: + void initArray(void); + SDate stringToMonthDay(char *first,char *second); + SDate stringToMonthYear(char *first,char *second); + SDate monthYearStringToDate(char *str,short default_day=1); + short monthsBetween360(SDate fromDate,SDate toDate)const; + short daysBetween360(SDate fromDate,SDate toDate)const; + void getTodaysDate(void); + WORD mDayArray[13]; +}; + +inline +SDate::SDate(const String &someString) +{ + initArray(); + *this=monthYearStringToDate((char*)((String&)someString)); +} + +inline +SDate &SDate::operator=(const String &someString) +{ + *this=monthYearStringToDate((char*)((String&)someString)); + return *this; +} + +inline +short SDate::operator-(const SDate &someDate) +{ + return daysBetweenActual(*this,someDate); +} + +inline +SDate &SDate::operator+=(short dayCount) +{ + *this=daysAdd360(dayCount); + return *this; +} + +inline +void SDate::initArray(void) +{ + mDayArray[0]=0; + mDayArray[1]=31; + mDayArray[2]=29; + mDayArray[3]=31; + mDayArray[4]=30; + mDayArray[5]=31; + mDayArray[6]=30; + mDayArray[7]=31; + mDayArray[8]=31; + mDayArray[9]=30; + mDayArray[10]=31; + mDayArray[11]=30; + mDayArray[12]=31; +} + +inline +short SDate::daysBetween360(SDate toDate)const +{ + return daysBetween360(*this,toDate); +} + +inline +short SDate::monthsBetween360(SDate toDate)const +{ + return monthsBetween360(*this,toDate); +} + +inline +short SDate::monthsBetween360(SDate fromDate,SDate toDate)const +{ + return daysBetween360(fromDate,toDate)/30; +} + +inline +String SDate::toString(void)const +{ + return makeString(); +} +#endif + diff --git a/common/SHELLAPI.HPP b/common/SHELLAPI.HPP new file mode 100644 index 0000000..3fb6149 --- /dev/null +++ b/common/SHELLAPI.HPP @@ -0,0 +1,7 @@ +#ifndef _COMMON_SHELLAPI_HPP_ +#define _COMMON_SHELLAPI_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#include +#endif diff --git a/common/SMRECT.HPP b/common/SMRECT.HPP new file mode 100644 index 0000000..f8dea5d --- /dev/null +++ b/common/SMRECT.HPP @@ -0,0 +1,129 @@ +#ifndef _COMMON_SMALLRECT_HPP_ +#define _COMMON_SMALLRECT_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class SmallRect : private SMALL_RECT +{ +public: + SmallRect(void); + SmallRect(const SmallRect &smallRect); + SmallRect(short left,short top,short right,short bottom); + virtual ~SmallRect(); + SmallRect &operator=(const SmallRect &someSmallRect); + WORD operator==(const SmallRect &someSmallRect)const; + operator SMALL_RECT&(void); + short left(void)const; + void left(short left); + short top(void)const; + void top(short top); + short right(void)const; + void right(short right); + short bottom(void)const; + void bottom(short bottom); +private: +}; + +inline +SmallRect::SmallRect(void) +{ + SMALL_RECT::Left=0; + SMALL_RECT::Right=0; + SMALL_RECT::Top=0; + SMALL_RECT::Bottom=0; +} + +inline +SmallRect::SmallRect(const SmallRect &smallRect) +{ + *this=smallRect; +} + +inline +SmallRect::SmallRect(short left,short top,short right,short bottom) +{ + SMALL_RECT::Left=left; + SMALL_RECT::Top=top; + SMALL_RECT::Right=right; + SMALL_RECT::Bottom=bottom; +} + +inline +SmallRect::~SmallRect() +{ +} + +inline +SmallRect &SmallRect::operator=(const SmallRect &someSmallRect) +{ + left(someSmallRect.left()); + top(someSmallRect.top()); + right(someSmallRect.right()); + bottom(someSmallRect.bottom()); + return *this; +} + +inline +WORD SmallRect::operator==(const SmallRect &someSmallRect)const +{ + return (left()==someSmallRect.left()&& + top()==someSmallRect.top()&& + right()==someSmallRect.right()&& + bottom()==someSmallRect.bottom()); +} + +inline +SmallRect::operator SMALL_RECT&(void) +{ + return *this; +} + +inline +short SmallRect::left(void)const +{ + return SMALL_RECT::Left; +} + +inline +void SmallRect::left(short left) +{ + SMALL_RECT::Left=left; +} + +inline +short SmallRect::top(void)const +{ + return SMALL_RECT::Top; +} + +inline +void SmallRect::top(short top) +{ + SMALL_RECT::Top=top; +} + +inline +short SmallRect::right(void)const +{ + return SMALL_RECT::Right; +} + +inline +void SmallRect::right(short right) +{ + SMALL_RECT::Right=right; +} + +inline +short SmallRect::bottom(void)const +{ + return SMALL_RECT::Bottom; +} + +inline +void SmallRect::bottom(short bottom) +{ + SMALL_RECT::Bottom=bottom; +} +#endif \ No newline at end of file diff --git a/common/SMRTSTRM.CPP b/common/SMRTSTRM.CPP new file mode 100644 index 0000000..47c65c8 --- /dev/null +++ b/common/SMRTSTRM.CPP @@ -0,0 +1,8 @@ +#include + +SmartStream &SmartStream::fail(void) +{ + BYTE ch; + while(!strstream::fail())*this>>ch; + return *this; +} \ No newline at end of file diff --git a/common/SMRTSTRM.HPP b/common/SMRTSTRM.HPP new file mode 100644 index 0000000..be6a141 --- /dev/null +++ b/common/SMRTSTRM.HPP @@ -0,0 +1,36 @@ +#ifndef _COMMON_SMARTSTREAM_HPP_ +#define _COMMON_SMARTSTREAM_HPP_ +#include +#include +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class SmartStream : public strstream +{ +public: + enum {Colon=':',Comma=',',DoubleQuote='"',LeftParen='(',RightParen=')'}; + SmartStream(void); + SmartStream(const String &someString); + ~SmartStream(); + SmartStream &fail(void); +private: +}; + +inline +SmartStream::SmartStream(void) +{ +} + +inline +SmartStream::SmartStream(const String &someString) +{ + *this<<(char*)someString< + +Snapshot::Snapshot(void) +: mhSnapshot(0), mKernelLib("KERNEL32"), mpfnCreateToolhelp32Snapshot(0), + mpfnProcess32First(0), mpfnProcess32Next(0) +{ + initialize(); +} + +Snapshot::Snapshot(const Snapshot &snapshot) +: mhSnapshot(0) +{ // private implementation + *this=snapshot; +} + +Snapshot::~Snapshot() +{ + destroy(); +} + +BOOL Snapshot::create(SnapshotFlags snapshotFlags,DWORD processID) +{ + destroy(); + if(!mpfnCreateToolhelp32Snapshot)return FALSE; + mhSnapshot=mpfnCreateToolhelp32Snapshot(snapshotFlags,processID); + return isOkay(); +} + +BOOL Snapshot::process32First(ProcessEntry &processEntry) +{ + if(!isOkay()||!mpfnProcess32First)return FALSE; + return mpfnProcess32First(mhSnapshot,&processEntry.getProcessEntry()); +} + +BOOL Snapshot::process32Next(ProcessEntry &processEntry) +{ + if(!isOkay()||!mpfnProcess32Next)return FALSE; + return mpfnProcess32Next(mhSnapshot,&processEntry.getProcessEntry()); +} + +Snapshot &Snapshot::operator=(const Snapshot &snapshot) +{ // private implementation + return *this; +} + +void Snapshot::destroy(void) +{ + if(!isOkay())return; + ::CloseHandle(mhSnapshot); + mhSnapshot=0; +} + +BOOL Snapshot::initialize(void) +{ + WinVersionInfo winVersion; + + if(winVersion.isWinNT()&&winVersion.majorVersion()<=4)return FALSE; + if(!mKernelLib.isOkay())return FALSE; + mpfnCreateToolhelp32Snapshot=(PFNCREATETOOLHELP32SNAPSHOT)mKernelLib.procAddress("CreateToolhelp32Snapshot"); + if(!mpfnCreateToolhelp32Snapshot)return FALSE; + mpfnProcess32First=(PFNPROCESS32FIRST)mKernelLib.procAddress("Process32First"); + if(!mpfnProcess32First)return FALSE; + mpfnProcess32Next=(PFNPROCESS32NEXT)mKernelLib.procAddress("Process32Next"); + if(!mpfnProcess32Next)return FALSE; + return TRUE; +} + +BOOL Snapshot::isOkay(void)const +{ + return (mpfnCreateToolhelp32Snapshot&&mpfnProcess32First&&mpfnProcess32Next); +} diff --git a/common/SNAPSHOT.HPP b/common/SNAPSHOT.HPP new file mode 100644 index 0000000..8a64588 --- /dev/null +++ b/common/SNAPSHOT.HPP @@ -0,0 +1,38 @@ +#ifndef _COMMON_SNAPSHOT_HPP_ +#define _COMMON_SNAPSHOT_HPP_ +#ifndef _COMMON_VERSIONINFO_HPP_ +#include +#endif +#ifndef _COMMON_LIBRARY_HPP_ +#include +#endif +#ifndef _COMMON_PROCESSENTRY_HPP_ +#include +#endif + +class Snapshot +{ +public: + enum SnapshotFlags{Inherit=TH32CS_INHERIT,SnapAll=TH32CS_SNAPALL,SnapHeapList=TH32CS_SNAPHEAPLIST,SnapModule=TH32CS_SNAPMODULE,SnapProcess=TH32CS_SNAPPROCESS,SnapThread=TH32CS_SNAPTHREAD}; + Snapshot(void); + virtual ~Snapshot(); + BOOL create(SnapshotFlags snapshot,DWORD processID=0); + BOOL process32First(ProcessEntry &processEntry); + BOOL process32Next(ProcessEntry &processEntry); + void destroy(void); + BOOL isOkay(void)const; +private: + typedef HANDLE (PASCAL *PFNCREATETOOLHELP32SNAPSHOT)(DWORD dwFlags,DWORD th32ProcessID); + typedef BOOL (PASCAL *PFNPROCESS32FIRST)(HANDLE hSnapshot,LPPROCESSENTRY32 lppe); + typedef BOOL (PASCAL *PFNPROCESS32NEXT)(HANDLE hSnapshot,LPPROCESSENTRY32 lppe); + Snapshot(const Snapshot &snapshot); + Snapshot &operator=(const Snapshot &snapshot); + BOOL initialize(void); + + Library mKernelLib; + HANDLE mhSnapshot; + PFNCREATETOOLHELP32SNAPSHOT mpfnCreateToolhelp32Snapshot; + PFNPROCESS32FIRST mpfnProcess32First; + PFNPROCESS32NEXT mpfnProcess32Next; +}; +#endif \ No newline at end of file diff --git a/common/SORTOPT.HPP b/common/SORTOPT.HPP new file mode 100644 index 0000000..f2ea21a --- /dev/null +++ b/common/SORTOPT.HPP @@ -0,0 +1,9 @@ +#ifndef _COMMON_SORTOPTIONS_HPP_ +#define _COMMON_SORTOPTIONS_HPP_ + +class SortOptions +{ +public: + enum SortOrder{Ascending,Descending}; +}; +#endif \ No newline at end of file diff --git a/common/STARTI~1.HPP b/common/STARTI~1.HPP new file mode 100644 index 0000000..d65f366 --- /dev/null +++ b/common/STARTI~1.HPP @@ -0,0 +1,151 @@ +#ifndef _COMMON_STARTUPINFO_HPP_ +#define _COMMON_STARTUPINFO_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_RECTANGLE_HPP_ +#include +#endif + +class StartupInfo : private STARTUPINFO +{ +public: + StartupInfo(void); + virtual ~StartupInfo(); + String strDesktop(void)const; + String strTitle(void)const; + Rect initRect(void)const; + DWORD xCountChars(void)const; + DWORD yCountChars(void)const; + DWORD fillAttribute(void)const; + DWORD flags(void)const; + WORD showWindow(void)const; + HANDLE stdInput(void)const; + HANDLE stdOutput(void)const; + HANDLE stdError(void)const; +private: + StartupInfo(const StartupInfo &startupInfo); + StartupInfo &operator=(const StartupInfo &startupInfo); + BOOL operator==(const StartupInfo &startupInfo)const; + void init(void); +}; + +inline +StartupInfo::StartupInfo(void) +{ + init(); + ::GetStartupInfo(&((STARTUPINFO&)*this)); +} + +inline +StartupInfo::StartupInfo(const StartupInfo &startupInfo) +{ // private implementation + *this=startupInfo; +} + +inline +StartupInfo::~StartupInfo() +{ +} + +inline +StartupInfo &StartupInfo::operator=(const StartupInfo &/*startupInfo*/) +{ // private implementation + return *this; +} + +inline +BOOL StartupInfo::operator==(const StartupInfo &startupInfo)const +{ // private implementation + return FALSE; +} + +inline +String StartupInfo::strDesktop(void)const +{ + return STARTUPINFO::lpDesktop; +} + +inline +String StartupInfo::strTitle(void)const +{ + return STARTUPINFO::lpTitle; +} + +inline +Rect StartupInfo::initRect(void)const +{ + return Rect(STARTUPINFO::dwX,STARTUPINFO::dwY,STARTUPINFO::dwXSize,STARTUPINFO::dwYSize); +} + +inline +DWORD StartupInfo::xCountChars(void)const +{ + return STARTUPINFO::dwXCountChars; +} + +inline +DWORD StartupInfo::yCountChars(void)const +{ + return STARTUPINFO::dwYCountChars; +} + +inline +DWORD StartupInfo::fillAttribute(void)const +{ + return STARTUPINFO::dwFillAttribute; +} + +inline +DWORD StartupInfo::flags(void)const +{ + return STARTUPINFO::dwFlags; +} + +inline +WORD StartupInfo::showWindow(void)const +{ + return STARTUPINFO::wShowWindow; +} + +inline +HANDLE StartupInfo::stdInput(void)const +{ + return STARTUPINFO::hStdInput; +} + +inline +HANDLE StartupInfo::stdOutput(void)const +{ + return STARTUPINFO::hStdOutput; +} + +inline +HANDLE StartupInfo::stdError(void)const +{ + return STARTUPINFO::hStdError; +} + +inline +void StartupInfo::init(void) +{ + STARTUPINFO::cb=sizeof(STARTUPINFO); + STARTUPINFO::lpReserved=0; + STARTUPINFO::lpDesktop=0; + STARTUPINFO::lpTitle=0; + STARTUPINFO::dwX=0; + STARTUPINFO::dwY=0; + STARTUPINFO::dwXSize=0; + STARTUPINFO::dwYSize=0; + STARTUPINFO::dwXCountChars=0; + STARTUPINFO::dwYCountChars=0; + STARTUPINFO::dwFillAttribute=0; + STARTUPINFO::dwFlags=0; + STARTUPINFO::wShowWindow=0; + STARTUPINFO::cbReserved2=0; + STARTUPINFO::lpReserved2=0; + STARTUPINFO::hStdInput=0; + STARTUPINFO::hStdOutput=0; + STARTUPINFO::hStdError=0; +} +#endif diff --git a/common/STATIC.CPP b/common/STATIC.CPP new file mode 100644 index 0000000..569a503 --- /dev/null +++ b/common/STATIC.CPP @@ -0,0 +1,10 @@ +//#define _FASTHEAP_ +#if defined(_FASTHEAP_) +#include + +Heap &globalHeap(void) +{ + static Heap sGlobalHeap(16384); + return sGlobalHeap; +} +#endif diff --git a/common/STDIO.HPP b/common/STDIO.HPP new file mode 100644 index 0000000..7f2b6ab --- /dev/null +++ b/common/STDIO.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_STDIO_HPP_ +#define _COMMON_STDIO_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/STDLIB.HPP b/common/STDLIB.HPP new file mode 100644 index 0000000..9d16de9 --- /dev/null +++ b/common/STDLIB.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_STDLIB_HPP_ +#define _COMMON_STDLIB_HPP_ +#include +#endif diff --git a/common/STRING.CPP b/common/STRING.CPP new file mode 100644 index 0000000..7903197 --- /dev/null +++ b/common/STRING.CPP @@ -0,0 +1,666 @@ +#include +#include +#include +#include +#include +#include + +String::String(const char *npStr) +: mnpStr(0), mLengthBytes(0) +{ + DWORD stringLength; + + if(!npStr)return; +#ifndef _MSC_VER + try{stringLength=::strlen(npStr);} + except(0,EXCEPTION_EXECUTE_HANDLER){stringLength=0;} +#else + __try{stringLength=::strlen(npStr);} + __except(0,EXCEPTION_EXECUTE_HANDLER){stringLength=0;} +#endif + if(!stringLength)return; + stringLength++; + reserve(stringLength,FALSE); + ::strcpy(mnpStr,npStr); +} + +String::String(const String &newString) +: mnpStr(0), mLengthBytes(0) +{ + DWORD stringLength; + + if(!newString.mnpStr)return; + if(!(stringLength=newString.length()))return; + stringLength++; + reserve(stringLength,FALSE); + ::strcpy(mnpStr,newString.mnpStr); +} + +String &String::operator=(const String &someString) +{ + int stringLength; + + if(this==&someString)return *this; + if(someString.isNull()){removeData();return *this;} + if(!(stringLength=::strlen(someString.mnpStr)))return *this; + stringLength++; + if(lengthBytes()>=stringLength)::strcpy(mnpStr,someString.mnpStr); + else {reserve(stringLength,FALSE);::strcpy(mnpStr,someString.mnpStr);} + return *this; +} + +int String::operator=(const char *someCharStar) +{ + int stringLength; + + if(!someCharStar)return 0; + if(!(stringLength=::strlen(someCharStar)))return 0; + stringLength++; + if(lengthBytes()>=stringLength)::strcpy(mnpStr,someCharStar); + else {reserve(stringLength,FALSE);::strcpy(mnpStr,someCharStar);} + return 1; +} + +void String::operator+=(char someChar) +{ + DWORD strLength(length()); + if(strLength+2>mLengthBytes) + { + String tmpString(someChar); + *this+=tmpString; + return; + } + *(mnpStr+strLength)=someChar; + *(mnpStr+strLength+1)=0; +} + +int String::operator+=(const String &someString) +{ + char *lpString; + DWORD currLength; + DWORD stringLength; + + if(!someString.mnpStr)return 0; + stringLength=someString.length(); + stringLength++; + if(!mnpStr) + { + reserve(stringLength,FALSE); + ::strcpy(mnpStr,someString.mnpStr); + return 1; + } + currLength=::strlen(mnpStr); + if(lengthBytes()-currLength>=stringLength) + { + ::strcat(mnpStr,someString.mnpStr); + return 1; + } + lpString=mnpStr; + mnpStr=::new char[currLength+stringLength+MaxString]; + mLengthBytes=currLength+stringLength+MaxString; + ::strcpy(mnpStr,lpString); + ::strcpy(mnpStr+currLength,someString.mnpStr); + ::delete[] lpString; + return 1; +} + +int String::operator+=(const char *someStr) +{ + char *lpString; + DWORD currLength; + DWORD stringLength; + + if(!someStr)return 0; + stringLength=::strlen(someStr); + stringLength++; + if(!mnpStr) + { + reserve(stringLength,FALSE); + ::strcpy(mnpStr,someStr); + return 1; + } + currLength=::strlen(mnpStr); + if(lengthBytes()-currLength>=stringLength) + { + ::strcat(mnpStr,someStr); + return 1; + } + lpString=mnpStr; + mnpStr=::new char[currLength+stringLength+MaxString]; + mLengthBytes=currLength+stringLength+MaxString; + ::strcpy(mnpStr,lpString); + ::strcpy(mnpStr+currLength,someStr); + ::delete[] lpString; + return 1; +} + +String String::operator+(const String &someString)const +{ + String tmpString(*this); + tmpString+=someString; + return tmpString; +} + +int String::token(const char *tokenString) +{ + if(!tokenString||!mnpStr)return 0; + if(::strtok(mnpStr,tokenString))return 1; + return 0; +} + +int String::strchr(char someChar)const +{ + int pos; + if(!mnpStr)return -1; + pos=(int)::strchr(mnpStr,someChar); + if(!pos)return -1; + return pos-(int)mnpStr; +} + +int String::strpos(const char *string)const +{ + int stringPosition; + if(!mnpStr)return -1; + stringPosition=(int)::strstr(mnpStr,string); + if(!stringPosition)return -1; + return stringPosition-(int)mnpStr; +} + +int String::strncmp(const char *string)const +{ + int srcLength; + int dstLength; + + if(!mnpStr)return -1; + srcLength=::strlen(string); + dstLength=::strlen(mnpStr); + return ::strncmp(mnpStr,string,srcLength=stringLength)return String(nullString); + if(beginToken) + { + if(0==(lpBegin=::strchr(mnpStr,beginToken)))return String(nullString); + if(++lpBegin-mnpStr>=stringLength)return String(nullString); + } + else lpBegin=mnpStr; + if(0==(lpEnd=::strchr(lpBegin,endToken)))return *this; + if(lpBegin==lpEnd)return String(nullString); + if(sizeof(nullString)<=(lpEnd-lpBegin)+1) + { + String nullString; + nullString.reserve((lpEnd-lpBegin)+1,FALSE); + ::memcpy(nullString,lpBegin,lpEnd-lpBegin); + *((char*)nullString+(lpEnd-lpBegin))=0; + return nullString; + } + ::memcpy(nullString,lpBegin,lpEnd-lpBegin); + *(nullString+(lpEnd-lpBegin))=0; + return String(nullString); +} + +WORD String::makeBlock(Block &receiveStrings,const String &tokenString)const +{ + String stringData(*this); + String workString; + LONG stringPos; + LONG lengthToken; + + receiveStrings.remove(); + if(!(lengthToken=tokenString.length()))return FALSE; + if(stringData.isNull())return FALSE; + while(TRUE) + { + if(-1==(stringPos=stringData.strpos(tokenString))) + { + if(!stringData.isNull())receiveStrings.insert(&stringData); + return receiveStrings.size(); + } + else if(stringData.length()!=stringPos+lengthToken) + { + if(stringPos) + { + workString=stringData.substr(0,stringPos-(lengthToken-1)); + receiveStrings.insert(&workString); + } + stringData=stringData.substr(stringPos+lengthToken,stringData.length()); + } + else stringData.removeTokens(tokenString); + } +} + +String String::extractDigits(void)const +{ + String tempString; + String nullString; + char *lpClampOne; + char *lpClampTwo; + + if(!mnpStr)return nullString; + tempString=mnpStr; + lpClampOne=(char*)tempString; + while(*lpClampOne&&!isdigit(*lpClampOne))lpClampOne++; + if(!*lpClampOne)return nullString; + lpClampTwo=lpClampOne; + while(*lpClampTwo&&isdigit(*lpClampTwo))lpClampTwo++; + *lpClampTwo=0; + return lpClampOne; +} + +String String::extractAlpha(void)const +{ + String tempString; + String nullString; + char *lpClampOne; + char *lpClampTwo; + + if(!mnpStr)return nullString; + tempString=mnpStr; + lpClampOne=(char*)tempString; + while(*lpClampOne&&!isalpha(*lpClampOne))lpClampOne++; + if(!*lpClampOne)return nullString; + lpClampTwo=lpClampOne; + while(*lpClampTwo&&isalpha(*lpClampTwo))lpClampTwo++; + *lpClampTwo=0; + return lpClampOne; +} + +void String::expand(void) +{ + Macro macro; + if(isNull())return; + macro.processEmbeddedMacro(*this); +} + +int String::hex(void)const +{ + String workString(*this); + DWORD stringLength; + DWORD multiplier(0x01); + DWORD value(0L); + char *ptrString; + + if(workString.isNull())return FALSE; + if(workString.strstr(" "))workString.removeTokens(" "); + if(!(stringLength=workString.length()))return FALSE; + workString.upper(); + if(0!=(ptrString=(char*)workString.strstr("0X"))) + { + ptrString+=2; + stringLength=::strlen(ptrString); + ptrString+=(stringLength-1); + } + else if('H'==*((char*)workString+(stringLength-1))) + { + stringLength--; + ptrString=(char*)workString+(stringLength-1); + } + else ptrString=(char*)workString+(stringLength-1); + for(LONG stringIndex=stringLength-1;stringIndex>=0;stringIndex--) + { + switch(*(ptrString--)) + { + case '0' : break; + case '1' : {value+=multiplier;break;} + case '2' : {value+=multiplier*2;break;} + case '3' : {value+=multiplier*3;break;} + case '4' : {value+=multiplier*4;break;} + case '5' : {value+=multiplier*5;break;} + case '6' : {value+=multiplier*6;break;} + case '7' : {value+=multiplier*7;break;} + case '8' : {value+=multiplier*8;break;} + case '9' : {value+=multiplier*9;break;} + case 'A' : {value+=multiplier*10;break;} + case 'B' : {value+=multiplier*11;break;} + case 'C' : {value+=multiplier*12;break;} + case 'D' : {value+=multiplier*13;break;} + case 'E' : {value+=multiplier*14;break;} + case 'F' : {value+=multiplier*15;break;} + case '-' : {value*=-1;break;} + default : return value; + } + multiplier*=16; + } + return value; +} + +void String::spaceTerm(void) +{ + size_t strLen; + + if(isNull()||(0==(strLen=length())))return; + for(short index=0;index=0;index--) + { + if(Blank==*(mnpStr+index))*(mnpStr+index)=0; + else break; + } + return *this; +} + +String &String::trimLeft(void) +{ + size_t strLen; + + if(isNull()||(0==(strLen=length())))return *this; + for(short index=0;indexlength()); + int tokens(someTokens.length()); + String tempString; + + if(!length||!tokens)return; + for(int token=0;tokenlength()); + String tempString; + + if(!length)return; + for(int pos=0;posnewLength) + { + String tempString; + tempString.reserve(newLength+1); + ::memcpy(tempString,*this,newLength); + *this=tempString; + } + else while(length()endPosition)return resultString; + if(endPosition>stringLength)endPosition=stringLength; + resultString.reserve(endPosition-startPosition+2); + ::memcpy(resultString,mnpStr+startPosition,(endPosition-startPosition)+1); + return resultString; +} + +WORD String::insert(const String &insertString,WORD insertPosition) +{ + WORD insertLength(insertString.length()); + + if(!insertLength)return FALSE; + if(!mnpStr) + { + reserve(insertLength+insertPosition+1); + ::memset(mnpStr,Blank,insertLength+insertPosition); + ::memcpy(mnpStr+insertPosition,insertString,insertLength); + } + else + { + WORD currentLength(length()); + String tempString; + + if(insertLength+insertPosition>currentLength) + { + tempString.reserve(insertLength+insertPosition+currentLength+1); + ::memset(tempString,Blank,insertLength+insertPosition+currentLength); + } + else + { + tempString.reserve(currentLength+insertLength+1); + ::memset(tempString,Blank,currentLength+insertLength); + } + ::memcpy(tempString,mnpStr,currentLength); + if(!(insertPosition>currentLength))shiftRight(tempString,insertPosition,currentLength+insertLength-1,insertLength,currentLength); + ::memcpy(((char*)tempString)+insertPosition,insertString,insertLength); + *this=tempString; + } + return TRUE; +} + +WORD String::insert(char *lpInsertString,WORD insertPosition) +{ + WORD insertLength; + + if(!lpInsertString||!(insertLength=::strlen(lpInsertString)))return FALSE; + if(!mnpStr) + { + reserve(insertLength+insertPosition+1); + ::memset(mnpStr,Blank,insertLength+insertPosition); + ::memcpy(mnpStr+insertPosition,lpInsertString,insertLength); + } + else + { + WORD currentLength(length()); + String tempString; + + if(insertLength+insertPosition>currentLength) + { + tempString.reserve(insertLength+insertPosition+currentLength+1); + ::memset(tempString,Blank,insertLength+insertPosition+currentLength); + } + else + { + tempString.reserve(currentLength+insertLength+1); + ::memset(tempString,Blank,currentLength+insertLength); + } + ::memcpy(tempString,mnpStr,currentLength); + if(!(insertPosition>currentLength))shiftRight(tempString,insertPosition,currentLength+insertLength-1,insertLength,currentLength); + ::memcpy(((char*)tempString)+insertPosition,lpInsertString,insertLength); + *this=tempString; + } + return TRUE; +} + +void String::shiftRight(String &shiftString,WORD startPos,WORD endPos,WORD insertLength,WORD originalLength) +{ + WORD shiftLength(originalLength-startPos); + for(WORD shiftIndex=0;shiftIndex>(istream &stream,String &someString) +{ + char charData; + + someString.reserve(String::MaxString); + while(stream.get(charData)) + { + if(charData=='\n') + { + if(someString.length())break; + continue; + } + someString+=charData; + } + someString+='\0'; + return stream; +} + +ostream &operator<<(ostream &stream,const String &someString) +{ + return stream<<(char*)((String&)someString); +} + +String operator+(const char *str,const String &string) +{ + return String(str)+string; +} diff --git a/common/STRING.INC b/common/STRING.INC new file mode 100644 index 0000000..29a4a80 --- /dev/null +++ b/common/STRING.INC @@ -0,0 +1,122 @@ +;************************************************************************************* +; MODULE: STRING.INC DATE: FEBRUARY 2, 1997 +; AUTHOR: SEAN M. KESSLER +; TARGET: 32 BIT FLAT MODEL +; FUNCTION : STRING RELATED MACROS +;************************************************************************************* +STRSTR MACRO szStringOne,szStringTwo + push offset szStringTwo ; save string one + push offset szStringOne ; save string two + call _strstr ; call standard library strstr + add esp,08h ; reset stack frame +ENDM + +STRCHR MACRO szString,charByte + push charByte ; save charByte + push offset szString ; save string + call _strchr ; call standard library strchr + add esp,08h ; reset stack frame +ENDM + +STRCAT MACRO szDstString,szSrcString + push offset szSrcString ; save source string + push offset szDstString ; save destination string + call _strcat ; call standard library strcat + add esp,08h ; reset stack frame +ENDM + +STRLEN MACRO szData + push edi ; save destination index register + push ecx ; save ecx register + mov edi,offset szData ; get string to destination index register + mov ecx,0FFFFh ; move 65535 to ecx register + xor eax,eax ; clear eax register + repnz scasb ; scan string + mov eax,0FFFFh ; move 65535 to eax + sub eax,ecx ; subtract number of bytes scanned + dec eax ; decrement result + pop ecx ; restore ecx register + pop edi ; restore destination index register +ENDM + +MEMCPY MACRO szDstData,szSrcData,lengthCopy + push esi ; save source index register + push edi ; save destination index register + mov esi,offset szSrcData ; move source data to source index register + mov edi,offset szDstData ; move destination data to destination index register + mov ecx,lengthCopy ; move number of bytes to copy to ecx register + rep movsb ; copy data + pop edi ; restore destination index register + pop esi ; restore source index register +ENDM + +MEMSET MACRO szBuffer,setFill,length + push edi ; save destination index register + mov edi,szBuffer ; move szBuffer into edi register + mov eax,setFill ; move value to set into eax register + mov ecx,length ; move count of bytes to ecx register + rep stosb ; set data + pop edi ; restore destination index register +ENDM + +STRCMP MACRO szStringOne,szStringTwo +LOCAL @@STRCMPnotEqual,@@STRCMPequal,@@STRCMPexit + push ecx ; save ecx register + push edi ; save destination index register + push esi ; save source index register + mov edi,offset szStringOne ; move string one to destination index register + mov esi,offset szStringTwo ; move string two to source index register + STRLEN szStringOne ; get length of string one + mov ecx,eax ; save length to ecx register + STRLEN szStringTwo ; get length of string two + cmp ecx,eax ; compare lengths + jne @@STRCMPnotEqual ; if lengths differ, strings are not equal +@@STRCMPloop: ; loop control + mov al,byte ptr[esi] ; get byte from string two + cmp al,byte ptr[edi] ; compare with byte from string one + jne @@STRCMPnotEqual ; if bytes differ then we're done + loop @@STRCMPloop ; iterate through string length +@@STRCMPequal: ; equality control + mov eax,0001h ; set return code + jmp @@STRCMPexit ; we're done +@@STRCMPnotEqual: ; inequality control + xor eax,eax ; set return code +@@STRCMPexit: ; exit sync address + pop esi ; restore source index register + pop edi ; restore destination index register + pop ecx ; restore ecx register +ENDM + +STRNCMP MACRO szStringOne,szStringTwo +LOCAL @@STRNCMPloop,@@STRNCMPequal,@@STRNCMPnotEqual,@@STRNCMPexit + push ecx ; save ecx register + push edi ; save edi register + push esi ; save source index register + mov edi,offset szStringOne ; move string one to destination index register + mov esi,offset szStringTwo ; move string two to source index register + STRLEN szStringOne ; get length of string one + mov ecx,eax ; save length to ecx register + STRLEN szStringTwo ; get length of string two + cmp ecx,eax ; compare the lengths + jle @@STRNCMPloop ; string one is less equal to string two + mov ecx,eax ; string two is less, so use it's length +@@STRNCMPloop: ; loop control + mov al,byte ptr[esi] ; get byte from string one + cmp al,byte ptr[edi] ; compare with byte from string two + jne @@STRNCMPnotEqual ; if byte are unequal, strings are unequal + inc edi ; increment along string two + inc esi ; increment along string one + loop @@STRNCMPloop ; keep going +@@STRNCMPequal: ; string equal sync address + mov eax,0001h ; set return code + jmp @@STRNCMPexit ; we're done +@@STRNCMPnotEqual: ; string unequal sync address + xor eax,eax ; set return code +@@STRNCMPexit: ; exit sync address + pop esi ; restore source index register + pop edi ; restore destination index register + pop ecx ; restore ecx register +ENDM +extrn _strstr:near +extrn _strchr:near +extrn _strcat:near diff --git a/common/Scraps.txt b/common/Scraps.txt new file mode 100644 index 0000000..1456596 --- /dev/null +++ b/common/Scraps.txt @@ -0,0 +1,2882 @@ + if(::strlen(++ptr)>12)return FALSE; + + +template +void QuickSort::sortItems(PureVector &vectorItems,SortOptions::SortOrder sortOrder) +{ + if(!vectorItems.size())return; +// mlpItemList=(T*)vectorItems; + if(SortOptions::Ascending==sortOrder)quickSort(0,vectorItems.size()-1); + else quickSortDescending(0,vectorItems.size()-1); +} + + + +WORD Process::createProcess(String moduleNameString,String cmdLineString,CreationFlags creationFlags,WORD showWindow) +{ + PathFind pathFind; + Profile profile; + String pureFileName; + String pathFileNameString; + String commandLineString; + String startupDirString("."); + String blankString(" "); + + if(isOkay())terminateProcess(); + if(moduleNameString.isNull())return FALSE; + pureFileName=moduleNameString; +// profile.makeFileName(pureFileName); + if(pathFind.findFile(pureFileName,pathFileNameString)) + { + moduleNameString=pathFileNameString; + startupDirString=pathFileNameString; + commandLineString=pathFileNameString; + profile.makeDirectoryName(startupDirString); + commandLineString+=blankString; + } + else + { + commandLineString=moduleNameString; + commandLineString+=blankString; + } + commandLineString+=cmdLineString; + if(SW_SHOWNORMAL!=showWindow){mStartupInfo.dwFlags=STARTF_USESHOWWINDOW;mStartupInfo.wShowWindow=showWindow;} + mIsOkay=(WORD)::CreateProcess(moduleNameString,commandLineString,0,0,0,(DWORD)creationFlags,0,startupDirString,&mStartupInfo,(PROCESS_INFORMATION*)((PureProcess*)this)); + return mIsOkay; +} + + +WORD Process::createProcess(String moduleNameString,String cmdLineString,const CreationFlags &creationFlags,WORD showWindow) +{ + PathFind pathFind; + Profile profile; + String pureFileName; + String pathFileNameString; + String commandLineString; + String startupDirString("."); + String blankString(" "); + + if(isOkay())terminateProcess(); + if(moduleNameString.isNull())return FALSE; + pureFileName=moduleNameString; + if(pathFind.findFile(pureFileName,pathFileNameString)) + { + moduleNameString=pathFileNameString; +// startupDirString=pathFileNameString; + commandLineString=pathFileNameString; +// profile.makeDirectoryName(startupDirString); + commandLineString+=blankString; + } + else + { + commandLineString=moduleNameString; + commandLineString+=blankString; + } + commandLineString+=cmdLineString; + if(SW_SHOWNORMAL!=showWindow){mStartupInfo.dwFlags=STARTF_USESHOWWINDOW;mStartupInfo.wShowWindow=showWindow;} +// mIsOkay=(WORD)::CreateProcess(moduleNameString,commandLineString,0,0,0,(DWORD)creationFlags,0,startupDirString,&mStartupInfo,(PROCESS_INFORMATION*)((PureProcess*)this)); + mIsOkay=(WORD)::CreateProcess(moduleNameString,commandLineString,0,0,0,(DWORD)creationFlags,0,0,&mStartupInfo,(PROCESS_INFORMATION*)((PureProcess*)this)); + return mIsOkay; +} + + + +#if 0 +WORD MemFile::write(DWORD value) +{ + WORD wordValue; + + if(!isOkay())return FALSE; + if(BigEndian==mByteOrder) + { + WORD hiWord(HIWORD(value)); + WORD loWord(LOWORD(value)); + + wordValue=mIntelData.intelData(loWord); + value=((DWORD)wordValue)<<16; + wordValue=mIntelData.intelData(hiWord); + value|=wordValue; + } + wordValue=(WORD)(value&0xFFFF); + write(wordValue); + wordValue=(WORD)(value>>16); + write(wordValue); + return TRUE; +} +#endif + + if(!mMIDIOutDevice.midiEvent(mMIDIEventVector[mPlayIndex]))return closeDevice(); + if(++mPlayIndex>=mMIDIEventVector.size())return closeDevice(); + + + + + +#if 0 +WORD OptionsReg::isInTime(const SystemTime &systemTime)const +{ + if(daily()) + { + if(systemTime.hour()>=hour()&& + systemTime.minute()>=minute()&& + systemTime.second()>=second())return TRUE; + return FALSE; + } + if(systemTime.month()>=month()&& + systemTime.day()>=day()&& + systemTime.year()>=year()&& + systemTime.hour()>=hour()&& + systemTime.minute()>=minute()&& + systemTime.second()>=second())return TRUE; + return FALSE; +} +#endif + + +#if 0 +// systemTime:12:58:01 +// optionsReg:11:57:22 + +//19970101 11 57 22 + +WORD OptionsReg::isGreater(const SystemTime &systemTime) +{ + DWORD sysTime(0); + DWORD optTime(0); + DWORD sysDate(0); + DWORD optDate(0); + + sysTime=((DWORD)systemTime.hour())<<16; + sysTime|=((DWORD)systemTime.minute())<<8; + sysTime|=(DWORD)sysTime.second(); + sysDate=((DWORD)systemTime.year())<<16; + sysDate|=((DWORD)systemTime.month())<<8; + sysDate|=(DWORD)sysTime.day(); + optDate=((DWORD)year())<<16; + optDate|=((DWORD)month())<<8; + optDate|=(DWORD)day(); + optTime=((DWORD)hour())<<16; + optTime|=((DWORD)minute())<<8; + optTime|=(DWORD)second(); + if(daily() + { + if(sysTime>optTime)return TRUE; + return FALSE; + } + else + { + if(sysDate>optDate)return TRUE; + else if(sysDate==optDate&&sysTime>=optTime)return TRUE; + } + return FALSE; +} + + + case IFS_IFSFNDISCONNECT : + handleBox(IFS_IFSFNDISCONNECT); + break; + case IFS_IFSFNCONNECT : + handleBox(IFS_IFSFNCONNECT); + break; + case IFS_IFSFNFINDCLOSE : + handleBox(IFS_IFSFNFINDCLOSE); + break; + case IFS_IFSFNDIR : + handleBox(IFS_IFSFNDIR); + break; + case IFS_IFSFNFILETIMES : + handleBox(IFS_IFSFNFILETIMES); + break; + case IFS_IFSFNFILELOCKS : + handleBox(IFS_IFSFNFILELOCKS); + break; + case IFS_IFSFNCOMMIT : + handleBox(IFS_IFSFNCOMMIT); + break; + case IFS_IFSFNCLOSE : + handleBox(IFS_IFSFNCLOSE); + break; + case IFS_IFSFNSEEK : + handleBox(IFS_IFSFNSEEK); + break; + case IFS_IFSFNFINDNEXT : + handleBox(IFS_IFSFNFINDNEXT); + break; + case IFS_IFSFNWRITE : + handleBox(IFS_IFSFNWRITE); + break; + case IFS_IFSFNREAD : + handleBox(IFS_IFSFNREAD); + break; + + + +void OwnerDrawList::drawEntire(const DrawItem &drawItem) +{ + PureDevice pureDevice(drawItem.deviceContext()); + PureDevice memDevice; + String stringData; + TEXTMETRIC textMetric; + Rect drawRect; + + if(!isOkay())return; + stringData.reserve(256); + drawRect=drawItem.rectItem(); + memDevice.compatibleDevice(pureDevice); + PureBitmap &pureBitmap=(((UINT)drawItem.itemState())&ODS_SELECTED?mPureBitmaps[BmSel]:mPureBitmaps[BmUnSel]); + memDevice.select(pureBitmap,TRUE); + pureDevice.bitBlt(drawRect,memDevice,Point(0,0)); + ::SendMessage(drawItem.hwndItem(),LB_GETTEXT,drawItem.itemID(),(LPARAM)(LPSTR)stringData); + if(stringData.isNull())::MessageBeep(0); + ::GetTextMetrics(drawItem.deviceContext(),&textMetric); + + if(drawItem.itemState()&ODS_DISABLED) + ::GrayString(drawItem.deviceContext(),(HBRUSH)0,(GRAYSTRINGPROC)0, + (LPARAM)(LPSTR)stringData,stringData.length(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,0,0); + else + ::TextOut(drawItem.deviceContext(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,(LPSTR)stringData,stringData.length()); + + if((((UINT)drawItem.itemState())&ODS_FOCUS)) + { + Rect bmpRect(drawRect); + bmpRect.right(bmpRect.left()+pureBitmap.width()); + bmpRect.bottom(bmpRect.top()+pureBitmap.height()); + ::DrawFocusRect(drawItem.deviceContext(),(RECT*)&bmpRect); + } + memDevice.select(pureBitmap,FALSE); +} + + +DWORD DirTree::getDirList(const String &pathDir,Block &dirEntries) +{ + String entryName; + Block dirList; + PathFind pathFind; + FindData findData; + + dirEntries.remove(); + if(pathDir.isNull())return FALSE; + pathFind.dirList(pathDir,dirList); + if(dirList.size()<=2)return FALSE; + if(!makeFileName(dirList[0],entryName))return FALSE; + if(entryName!=mCurrDir)return FALSE; + if(!makeFileName(dirList[1],entryName))return FALSE; + if(entryName!=String(mUpDir))return FALSE; + for(int itemIndex=2;itemIndex +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PUREBITMAP_HPP_ +#include +#endif +#ifndef _COMMON_PUREDEVICE_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif +#ifndef _COMMON_PUREVECTOR_HPP_ +#include +#endif +#ifndef _COMMON_PVECTOR_TPP_ +#include +#endif +#ifndef _COMMON_PALETTEENTRY_HPP_ +#include +#endif + +class PurePalette +{ +public: + enum {MaxColors=256}; + enum InitPal{InitSys,InitNone}; + typedef int PaletteIndex; +// PurePalette(void); + PurePalette(InitPal initPal=InitNone); + PurePalette(HPALETTE hPalette); + PurePalette(const PurePalette &somePurePalette); + ~PurePalette(); + PurePalette &operator=(const PurePalette &somePurePalette); + PurePalette &operator=(HPALETTE hPalette); + PaletteEntry &operator[](PaletteIndex paletteIndex); + WORD operator==(const PurePalette &somePurePalette)const; + WORD identityPalette(void); + WORD systemPalette(void); + WORD isIdentityPalette(void)const; + void cyclePalette(void); + PaletteIndex paletteIndex(const RGBColor &someRGBColor)const; + void getPaletteColors(PureVector &someRGBColors)const; + void setPaletteColors(PureVector &someRGBColors,PaletteEntry::PaletteFlags paletteFlag=PaletteEntry::NullFlag); + WORD setPaletteColor(short paletteIndex,RGBColor &someRGBColor,PaletteEntry::PaletteFlags paletteFlag=PaletteEntry::NullFlag); + WORD getPaletteColor(short paletteIndex,RGBColor &someRGBColor)const; + void clearPalette(void); + void usePalette(const PureDevice &somePureDevice,short usage); + WORD paletteEntry(PaletteIndex paletteIndex,RGBColor &someRGBColor)const; + RGBColor paletteEntry(PaletteIndex paletteIndex)const; + WORD paletteEntries(void)const; + WORD isInUse(void)const; + operator HPALETTE(void)const; +private: + enum {SystemStaticColors=20}; + WORD createPalette(void); + void clearPaletteEntries(void); + void setPaletteColors(void)const; + void destroyPalette(void); + + HPALETTE mhPalette; + HPALETTE mhOldPalette; + PaletteEntry mPaletteData[MaxColors]; + WORD mIsInUse; +}; + +//inline +//PurePalette::PurePalette(void) +//: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +//{ +// clearPaletteEntries(); +// createPalette(); +// return; +//} + +inline +PurePalette::PurePalette(InitPal initPal) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + if(InitSys==initPal)systemPalette(); + else {clearPaletteEntries(),createPalette();} + return; +} + +inline +PurePalette::~PurePalette() +{ + destroyPalette(); + return; +} + +inline +WORD PurePalette::paletteEntries(void)const +{ + return MaxColors; +} + +inline +PurePalette::operator HPALETTE(void)const +{ + return mhPalette; +} + +inline +void PurePalette::clearPaletteEntries(void) +{ + ::memset((void*)&mPaletteData,0,sizeof(mPaletteData)); +} + +inline +void PurePalette::setPaletteColors(void)const +{ + ::SetPaletteEntries(mhPalette,0,MaxColors,(PALETTEENTRY FAR*)&mPaletteData); +} + +inline +WORD PurePalette::isInUse(void)const +{ + return mIsInUse; +} + +inline +PurePalette::PaletteIndex PurePalette::paletteIndex(const RGBColor &someRGBColor)const +{ + return ::GetNearestPaletteIndex(mhPalette,(COLORREF)someRGBColor); +} + +inline +PaletteEntry &PurePalette::operator[](PaletteIndex paletteIndex) +{ + assert(paletteIndex +#include + +PurePalette::PurePalette(const PurePalette &somePurePalette) +: mhPalette(0), mhOldPalette(), mIsInUse(FALSE) +{ + ::GetPaletteEntries(somePurePalette,0,MaxColors,(PALETTEENTRY FAR *)&mPaletteData); + createPalette(); +} + +PurePalette::PurePalette(HPALETTE hPalette) +: mhPalette(0), mhOldPalette(0), mIsInUse(FALSE) +{ + ::GetPaletteEntries(hPalette,0,MaxColors,(PALETTEENTRY FAR *)&mPaletteData); + createPalette(); +} + +PurePalette &PurePalette::operator=(const PurePalette &somePurePalette) +{ + destroyPalette(); + ::GetPaletteEntries(somePurePalette,0,MaxColors,(PALETTEENTRY FAR*)&mPaletteData); + createPalette(); + return *this; +} + +PurePalette &PurePalette::operator=(HPALETTE hPalette) +{ + destroyPalette(); + ::GetPaletteEntries(hPalette,0,MaxColors,(PALETTEENTRY FAR*)&mPaletteData); + createPalette(); + return *this; +} + +WORD PurePalette::operator==(const PurePalette &somePurePalette)const +{ + for(short paletteIndex=0;paletteIndex=paletteEntries())return FALSE; + someRGBColor=(RGBColor)mPaletteData[paletteIndex]; + return TRUE; +} + +RGBColor PurePalette::paletteEntry(PaletteIndex paletteIndex)const +{ + RGBColor tempColor(0,0,0); + + paletteEntry(paletteIndex,tempColor); + return tempColor; +} + +WORD PurePalette::createPalette() +{ + PaletteEntry FAR *lpPaletteEntry; + LOGPALETTE FAR *lpLogPalette; + HGLOBAL hGlobalPalette; + + if(mhPalette){::DeleteObject(mhPalette);mhPalette=0;} + hGlobalPalette=::GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,sizeof(LOGPALETTE)+(MaxColors*sizeof(PALETTEENTRY))); + lpLogPalette=(LOGPALETTE FAR *)::GlobalLock(hGlobalPalette); + lpLogPalette->palNumEntries=MaxColors; + lpLogPalette->palVersion=0x300; + for(short paletteIndex=0;paletteIndexpalPalEntry[paletteIndex]; + *lpPaletteEntry=mPaletteData[paletteIndex]; + } + mhPalette=::CreatePalette((LOGPALETTE FAR *)lpLogPalette); + ::GlobalUnlock(hGlobalPalette); + ::GlobalFree(hGlobalPalette); + return (mhPalette?TRUE:FALSE); +} + +void PurePalette::usePalette(const PureDevice &somePureDevice,short usage) +{ + if(usage) + { + mhOldPalette=::SelectPalette(somePureDevice,mhPalette,FALSE); + ::RealizePalette(somePureDevice); + mIsInUse=TRUE; + } + else + { + ::SelectPalette(somePureDevice,mhOldPalette,FALSE); + ::RealizePalette(somePureDevice); + mIsInUse=FALSE; + } +} + +void PurePalette::getPaletteColors(PureVector &someRGBColors)const +{ + size_t paletteColors((size_t)someRGBColors.size(paletteEntries())); + for(short paletteIndex=0;paletteIndex=paletteEntries())return FALSE; + someRGBColor=(RGBColor)mPaletteData[paletteIndex]; + return TRUE; +} + +void PurePalette::setPaletteColors(PureVector &someRGBColors,PaletteEntry::PaletteFlags paletteFlag) +{ + size_t paletteColors((size_t)someRGBColors.size()); + + for(short paletteIndex=0;paletteIndex=paletteEntries())return FALSE; + mPaletteData[paletteIndex]=someRGBColor; + mPaletteData[paletteIndex].flags(paletteFlag); + ::SetPaletteEntries(mhPalette,paletteIndex,1,(PALETTEENTRY FAR*)&mPaletteData[paletteIndex]); + return TRUE; +} + +void PurePalette::clearPalette(void) +{ + short paletteColors(paletteEntries()); + RGBColor nullColor; + + for(short paletteIndex=0;paletteIndex paletteColors; + getPaletteColors(paletteColors); + setPaletteColors(paletteColors,PaletteEntry::NoCollapse); + setPaletteColor(PurePalette::MaxColors-1,RGBColor(255,255,255)); + setPaletteColor(0,RGBColor(0,0,0)); + createPalette(); + return TRUE; + } + if(SystemStaticColors!=(staticColors=::GetDeviceCaps(pureDevice,NUMCOLORS)))return FALSE; + staticColors/=2; + if(MaxColors!=::GetSystemPaletteEntries(pureDevice,0,MaxColors,(PALETTEENTRY FAR *)&paletteData))return FALSE; + for(short paletteIndex=0;paletteIndex +#endif + +class PointerDisposition +{ +public: + enum Diposition{Assume,Delete}; +}; + +template +class SmartPointer +{ +public: +// enum Disposition{Assume,Delete}; + SmartPointer(void); + SmartPointer(T FAR *lpSmartPointer,Disposition disposition=Assume); + SmartPointer(const SmartPointer &someSmartPointer); + virtual ~SmartPointer(); + T FAR *operator->(void); + operator T FAR *(void); + operator LPARAM(void); + SmartPointer &operator=(const SmartPointer &someSmartPointer); + SmartPointer &operator=(T FAR *lpSmartPointer); + WORD operator==(const SmartPointer &someSmartPointer)const; + void disposition(PointerDisposition::Disposition disposition); + PointerDisposition::Disposition disposition(void)const; +// void disposition(Disposition disposition); +// Disposition disposition(void)const; + WORD isOkay(void)const; +private: + void destroy(void); + T FAR *mlpSmartPointer; + PointerDisposition::Disposition mDisposition; +// Disposition mDisposition; +}; +#if defined(_MSC_VER) +#include +#endif +#endif + + + + +#ifndef _COMMON_SMARTPOINTER_TPP_ +#define _COMMON_SMARTPOINTER_TPP_ + +template +SmartPointer::SmartPointer(void) +: mlpSmartPointer(0), mDisposition(Assume) +{ +} + +template +SmartPointer::SmartPointer(T FAR *lpSmartPointer,Disposition disposition) +: mlpSmartPointer(lpSmartPointer), mDisposition(disposition) +{ +} + +template +SmartPointer::SmartPointer(const SmartPointer &someSmartPointer) +: mlpSmartPointer(0), mDisposition(Assume) +{ + *this=someSmartPointer; +} + +template +SmartPointer::~SmartPointer() +{ + destroy(); +} + +template +SmartPointer::operator T FAR *(void) +{ + return mlpSmartPointer; +} + +template +SmartPointer::operator LPARAM(void) +{ + return (LPARAM)mlpSmartPointer; +} + +template +T FAR *SmartPointer::operator->(void) +{ + return mlpSmartPointer; +} + +template +SmartPointer &SmartPointer::operator=(const SmartPointer &someSmartPointer) +{ + destroy(); + mlpSmartPointer=someSmartPointer.mlpSmartPointer; + mDisposition=Assume; + return *this; +} + +template +SmartPointer &SmartPointer::operator=(T FAR *lpSmartPointer) +{ + destroy(); + mlpSmartPointer=lpSmartPointer; + mDisposition=Assume; + return *this; +} + +template +WORD SmartPointer::operator==(const SmartPointer &someSmartPointer)const +{ + return *mlpSmartPointer==*someSmartPointer.mlpSmartPointer; +} + +template +void SmartPointer::destroy(void) +{ + if(!mlpSmartPointer)return; + if(Assume==mDisposition)mlpSmartPointer=0; + else {delete mlpSmartPointer;mlpSmartPointer=0;} +} + +template +void SmartPointer::disposition(PointerDisposition::Disposition disposition) +{ + mDisposition=disposition; +} + +template +PointerDisposition::Disposition SmartPointer::disposition(void)const +{ + return mDisposition; +} + +//template +//void SmartPointer::disposition(Disposition disposition) +//{ +// mDisposition=disposition; +//} +// +//template +//SmartPointer::Disposition SmartPointer::disposition(void)const +//{ +// return mDisposition; +//} + +template +WORD SmartPointer::isOkay(void)const +{ + return (mlpSmartPointer?TRUE:FALSE); +} +#endif + +#if 0 +inline +void String::operator+=(char someChar) +{ + String tempString(someChar); + (*this)+=tempString; +} +#endif + + + +void Progress::createWindow(void) +{ + ::CreateWindow(szClassName,mCaptionString, + WS_OVERLAPPED|WS_CAPTION|WS_CLIPCHILDREN|0x04L|WS_THICKFRAME, + mInitialPoint.x(),mInitialPoint.y(),PWcx,PWcy, + mhParentWindow,NULL,mhProcessInstance,(LPSTR)this); +} + + + +class DlgHookProc : public WinHookProc +{ +public: + DlgHookProc(); + virtual ~DlgHookProc(); +protected: + virtual DWORD winID(void)const; +private: +}; + +DlgHookProc::DlgHookProc() +{ +} + +DlgHookProc::~DlgHookProc() +{ +} + +DWORD DlgHookProc::winID(void)const +{ + return DWL_DLGPROC; +} + + +//#ifndef _COMMON_OPENFILE_HPP_ +//#include +//#endif + + +removed from block.hpp +//#ifndef _COMMON_STDLIB_HPP_ +//#include +//#endif + + + + +//#ifndef _COMMON_WINDEF_HPP_ +//#include +//#endif +//#ifndef _COMMON_WINDOWS_HPP_ +//#include +//#endif + + +#if 0 + FileHandle decodeFile; + String strLine; + BYTE charByte; + + strLines.remove(); + decodeFile.open(pathFileName); + if(!decodeFile.isOkay())return FALSE; + FileMap decodeMap(decodeFile); + PureViewOfFile decodeView(decodeMap); + while(decodeView.getLine(strLine))strLines.insert(&strLine); + return (strLines.size()?TRUE:FALSE); +#endif + + +BOOL OwnerDrawList::setTabStops(Block &tabStops) +{ + if(!isOkay())return FALSE; + mTabStopArray.size(tabStops.size()); + if(!mTabStopArray.size())return FALSE; + int *pIntArray=(int*)mTabStopArray; + for(int itemIndex=0;itemIndex &someCallbackVector,CallbackData &someCallbackData) +{ + size_t size((size_t)someCallbackVector.size()); + CallbackData::ReturnType returnCode(0); + CallbackData::ReturnType callReturn; + + for(int vectorIndex=0;vectorIndextranslatePoint(vector3D,vector2D); +// ::clearBitmap((DWORD)mDIBitmap->ptrData(),mDIBitmap->imageExtent()); + ::lineWINGBlt((DWORD)mDIBitmap->ptrData(),&vector2D[0],&vector2D[1],mDIBitmap->width(),mDIBitmap->height(),255); + ::lineWINGBlt((DWORD)mDIBitmap->ptrData(),&vector2D[1],&vector2D[2],mDIBitmap->width(),mDIBitmap->height(),255); + ::lineWINGBlt((DWORD)mDIBitmap->ptrData(),&vector2D[2],&vector2D[3],mDIBitmap->width(),mDIBitmap->height(),255); + ::lineWINGBlt((DWORD)mDIBitmap->ptrData(),&vector2D[3],&vector2D[0],mDIBitmap->width(),mDIBitmap->height(),255); +} + + + + +class EIPCursor : PureBitmap +{ +public: + EIPCursor(const String &strBitmap); + virtual EIPCursor(); + WORD currentLine(void)const; + void currentLine(WORD currentLine); + WORD isVisible(void)const; + void isVisible(WORD isVisible); + DWORD eip(void)const; + void eip(DWORD eip); + const Rect &bmRect(void)const; + void bmRect(const Rect &bmRect); +private: + WORD mCurrentLine; + WORD mIsVisible; + DWORD mCurrentEIP; + Rect mEIPRect; +}; + + + +// ********************************************************* + +Process::Process(HANDLE hProcess) +: mIsOkay(FALSE), mDisposition(AssumeHandle) +{ + *this=hProcess; +// ::GetStartupInfo(&mStartupInfo); +// if(!hProcess)return; +// setProcess(hProcess); +// mIsOkay=TRUE; +} + + + +FileMap::FileMap(const FileHandle &someFileHandle) +: mMaxExtentHigh(0L), mMaxExtentLow(0), mhFileHandle(0) +{ + create(someFileHandle); +// if(FileHandle::Read==someFileHandle.access())mPaging=ReadOnly; +// else if(FileHandle::Write==someFileHandle.access())mPaging=WriteCopy; +// else if(FileHandle::ReadWrite==someFileHandle.access())mPaging=ReadWrite; +// else mPaging=ReadOnly; +// mProtection=Commit; +// create(String(""),0L,someFileHandle.size(),mPaging,mProtection,(HANDLE)someFileHandle); +} + +String String::betweenString(char beginToken,char endToken)const +{ + char nullString[MaxString]={0}; + short stringLength; + char *lpBegin; + char *lpEnd; + + if(!mnpStr)return nullString; + stringLength=length(); + if(1>=stringLength)return nullString; + if(beginToken) + { + if(0==(lpBegin=::strchr(mnpStr,beginToken)))return nullString; + if(++lpBegin-mnpStr>=stringLength)return nullString; + } + else lpBegin=mnpStr; + if(0==(lpEnd=::strchr(lpBegin,endToken)))return *this; + if(lpBegin==lpEnd)return nullString; + assert(sizeof(nullString)>(lpEnd-lpBegin)+1); + ::memcpy(nullString,lpBegin,lpEnd-lpBegin); + *(nullString+(lpEnd-lpBegin))=0; + return nullString; +} + + +void PurePalette::readPalette(const String &strPathFileName) +{ + FileHandle palFile(strPathFileName); + FileMap palMap(palFile); + PureViewOfFile palView(palMap); + PaletteEntry paletteEntry; + String strLine; + int palEntries; + char *pLine; + char strTokens[]={' ','\0'}; + + if(!palFile.isOkay())return; + palView.getLine(strLine); + if(!(strLine==String("JASC-PAL")))return; + palView.getLine(strLine); + if(!(strLine==String("0100")))return; + palView.getLine(strLine); + palEntries=::atoi(strLine); + if(palEntries!=MaxColors)return; + for(int palEntry=0;palEntry=stringLength)return nullString; + if(beginToken) + { + if(0==(lpBegin=::strchr(mnpStr,beginToken)))return nullString; + if(++lpBegin-mnpStr>=stringLength)return nullString; + } + else lpBegin=mnpStr; + if(0==(lpEnd=::strchr(lpBegin,endToken)))return *this; + if(lpBegin==lpEnd)return nullString; + nullString.reserve((lpEnd-lpBegin)+1,FALSE); + ::memcpy(nullString,lpBegin,lpEnd-lpBegin); + *((char*)nullString+(lpEnd-lpBegin))=0; + return nullString; +} +#endif + + +void ProfileDebug::handleErrorBreak(const ExceptionRecord &exceptionRecord) +{ + CallbackData cbData(0,(LPARAM)&(ExceptionRecord&)exceptionRecord); + mHandlers[ErrorBreakHandler].callback(cbData); +// context(debugInfo().process(),debugInfo().thread()); +// showCode(debugInfo().process(),(DWORD)exceptionRecord.exceptionAddress(),60); +// violation(String("ExceptionDebugEvent:")+exceptionRecord.exceptionCodeString()); +} + +(mhDC&&::IsWindow(mhParent)?TRUE:FALSE); + + + + +// filterString=filterPatternString.betweenString('(',')'); +// filterString=fileTitleString.betweenString('.',0); +// filterString.insert("."); +// filter(filterString); +// filterPattern(filterPatternString); + + +void DIBitmap::fillRect(Vector2D &vector2D,int paletteIndex) +{ + float xDeltaLeft(vector2D[3].x()-vector2D[0].x()); + float xDeltaRight(vector2D[2].x()-vector2D[1].x()); + float yDeltaLeft(vector2D[3].y()-vector2D[1].y()); + float yDeltaRight(vector2D[2].y()-vector2D[1].y()); + float xLeft(vector2D[0].x()); + float yLeft(vector2D[0].y()); + float xRight(vector2D[1].x()); + float yRight(vector2D[1].y()); + float xLeftIncr; + float xRightIncr; + float dydxLeft; + float dydxRight; + int iterations; + + iterations=(vector2D[0].x()-vector2D[3].x()); + if(!iterations)iterations=vector2D[0].y()-vector2D[3].y(); + if(iterations<0)iterations=-iterations; + if(vector2D[3].x()>vector2D[0].x())xLeftIncr=1.00; + else if(vector2D[3].x()vector2D[1].x())xRightIncr=1.00; + else if(vector2D[2].x() +//#endif +//#ifndef _COMMON_STRING_HPP_ +//#include +//#endif + + +//#include +// VersionInfo versionInfo; +// if(versionInfo.isWinNT()) +// { +// MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,(LPSTR)(String&)ansiString,ansiLength,(WORD*)*this,size()); +// } +// else +// { +// } + + +// resData(::LockResource(::LoadResource(hResModule,mhResHandle))); + + +void OwnerDrawListAltColor::drawEntire(const DrawItem &drawItem) +{ + String stringData; + + if(!isOkay())return; + sendMessage(drawItem.hwndItem(),LB_GETTEXT,drawItem.itemID(),(LPARAM)(LPSTR)stringData); + PureDevice controlDevice(drawItem.deviceContext()); + if((((UINT)drawItem.itemState())&ODS_SELECTED)) + { + controlDevice.setBkColor(mBkGndSelColor); + controlDevice.fillRect(drawItem.rectItem(),mBkGndSelBrush); +// ::SetBkColor(drawItem.deviceContext(),mBkGndSelColor); +// ::FillRect(drawItem.deviceContext(),drawItem.rectItem(),(HBRUSH)(GDIObj)mBkGndSelBrush); + } + else + { + if(drawItem.itemID()%2) + { + controlDevice.setBkColor(mAltColor); + controlDevice.fillRect(drawItem.rectItem(),mAltBrush); +// ::SetBkColor(drawItem.deviceContext(),mAltColor); +// ::FillRect(drawItem.deviceContext(),drawItem.rectItem(),(HBRUSH)(GDIObj)mAltBrush); + } + else + { + controlDevice.setBkColor(mPrimColor); + controlDevice.fillRect(drawItem.rectItem(),mPrimBrush); +// ::SetBkColor(drawItem.deviceContext(),mPrimColor); +// ::FillRect(drawItem.deviceContext(),drawItem.rectItem(),(HBRUSH)(GDIObj)mPrimBrush); + } + } +// stringData.length(128); +// ::FillRect(drawItem.deviceContext(),drawItem.rectItem(),(HBRUSH)(GDIObj)bkGndBrush); + textOut(drawItem,stringData); + return; +} + + +void OwnerDrawListAltColor::handleResize(WORD /*width*/,WORD /*height*/) +{ +// width(getParent().width()-yIndent()); +} + + +#include +FileIO &operator>>(FileIO &stream,WaveForm &waveForm) +{ + initWaveForm(); +// if(!wavePathFileName.strstr(mExtensionString))wavePathFileName+=mExtensionString; +// mWavePathFileName=wavePathFileName; +// FileHandle waveFile(wavePathFileName,FileHandle::Read,FileHandle::ShareReadWrite); + if(!stream.isOkay())return stream; + stream.read((BYTE*)&mHeaderString,sizeof(mHeaderString)); + stream.read((BYTE*)&mLengthData,sizeof(mLengthData)); + stream.read((BYTE*)&mSubHeaderString,sizeof(mSubHeaderString)); + + + waveFile.read((BYTE*)&mHeaderString,sizeof(mHeaderString)); + waveFile.read((BYTE*)&mLengthData,sizeof(mLengthData)); + waveFile.read((BYTE*)&mSubHeaderString,sizeof(mSubHeaderString)); + mFormatChunk< &someGlobalData)const; + GlobalData &operator=(const GlobalData &someGlobalData); + WORD isOkay(void)const; +private: + void destroyGlobalData(void); + WORD createGlobalData(void); + T HUGE *mlpGlobalData; + HGLOBAL mhGlobalData; + UINT mGlobalFlags; + DWORD mSizeData; +}; + +template +inline +GlobalData::GlobalData(void) +: mlpGlobalData(0), mGlobalFlags(GMEM_FIXED), mSizeData(0), mhGlobalData(0) +{ +} + +template +inline +GlobalData::GlobalData(const GlobalData &someGlobalData) +: mlpGlobalData(0), mGlobalFlags(GMEM_FIXED), mSizeData(0), mhGlobalData(0) +{ + *this=someGlobalData; +} + +template +inline +GlobalData::GlobalData(DWORD sizeData,UINT globalFlags) +: mlpGlobalData(0), mGlobalFlags(globalFlags), mSizeData(sizeData), mhGlobalData(0) +{ + createGlobalData(); +} + +template +inline +GlobalData::~GlobalData() +{ + destroyGlobalData(); +} + +template +inline +DWORD GlobalData::size(void)const +{ + return mSizeData; +} + +template +inline +WORD GlobalData::size(DWORD sizeData,UINT globalFlags) +{ + mGlobalFlags=globalFlags; + mSizeData=sizeData; + return createGlobalData(); +} + +template +inline +UINT GlobalData::globalFlags(void)const +{ + return mGlobalFlags; +} + +template +inline +void GlobalData::globalFlags(UINT globalFlags) +{ + mGlobalFlags=globalFlags; +} + +//template +//inline +//GlobalData::operator T HUGE *(void)const +//{ +// assert(0!=mlpGlobalData); +// return mlpGlobalData; +//} + +template +inline +T &GlobalData::operator[](DWORD itemIndex) +{ + assert(itemIndex +inline +WORD GlobalData::createGlobalData(void) +{ + destroyGlobalData(); + if(!mSizeData)return FALSE; + mhGlobalData=::GlobalAlloc(mGlobalFlags,mSizeData*sizeof(T)); + if(!mhGlobalData)return FALSE; + mlpGlobalData=(T HUGE*)::GlobalLock(mhGlobalData); + return TRUE; +} + +template +inline +void GlobalData::destroyGlobalData(void) +{ + if(!mlpGlobalData)return; + ::GlobalUnlock(mhGlobalData); + ::GlobalFree(mhGlobalData); + mhGlobalData=0; + mlpGlobalData=0; +} + +template +inline +WORD GlobalData::isOkay(void)const +{ + return (mlpGlobalData?TRUE:FALSE); +} +#if defined(_MSC_VER) +#include +#endif +#endif + + + + + + + + +_getPECodeSectionCount proc near ; int getPECodeSectionCount(char *strPathFileName) + push ebp ; save previous stack frame + mov ebp,esp ; create new stack frame + pushad ; save all general purpose regs + xor eax,eax + mov smCodeSections,0000h + mov smPESignature,0000h + mov smFileHandle,INVALID_HANDLE + CREATEFILE [ebp+08h],GENERIC_READ,FILE_SHARE_READ,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL ; or GENERIC_WRITE + mov smFileHandle,eax ; move file handle into variable + cmp smFileHandle,INVALID_HANDLE ; examine file handle + je @@Fail ; if the handle is invalid, exit + READFILE smFileHandle,offset smImageDosHeader,size smImageDosHeader ; read IMAGEDOSHEADER + cmp smImageDosHeader.DOSHEADER@@e_magic,IMAGE_DOS_SIGNATURE ; examine the magic number + jne @@Fail ; if it's not equal then end + SEEK smFileHandle,smImageDosHeader.DOSHEADER@@e_lfanew,SEEK_BEGIN ; seek to new header + READFILE smFileHandle,offset smPESignature,size smPESignature ; read in the signature + cmp smPESignature,IMAGE_PE_SIGNATURE ; make sure this is a PE file + jne @@Fail ; if not then we're done here + READFILE smFileHandle,offset smImageFileHeader,size IMAGEFILEHEADER ; read in the file header + READFILE smFileHandle,offset smImageOptionalHeader,size IMAGEOPTIONALHEADER ; read in the optional header + xor eax,eax ; clear out eax register + mov ax,smImageFileHeader.FILEHEADER@@NumberOfSections ; move number of sections into ax + mov bx,size IMAGESECTIONHEADER ; move sizeof(IMAGESECTIONHEADER) to bx + mul bx ; get byte count for all sections + mov smLocalSectionHeaderLength,eax ; store size of all sections + sub esp,smLocalSectionHeaderLength ; make space for sections on stack + mov smpLocalSectionHeaders,esp ; store starting address + READFILE smFileHandle,smpLocalSectionHeaders,smLocalSectionHeaderLength ; read sections onto stack + mov smCodeSections,0000h + xor ecx,ecx ; clear ecx +sectionLoop: ; sectionLoop sync address + cmp cx,smImageFileHeader.FILEHEADER@@NumberOfSections ; did we read all the sections? + jge sectionLoopEnd ; is yes, then we're done here + GETSECTION ecx ; get section indexed by ecx + ISCODE smpImageSection + sectionIsCode smpImageSectionHeader + jz @@NotCode + inc smCodeSections +@@NotCode: + inc cx ; advance ecx + jmp sectionLoop ; keep reading sections +sectionLoopEnd: ; section loop end sync address + add esp,smLocalSectionHeaderLength ; restore sections from stack + jmp @@End +@@Fail: ; failure sync address + CLOSEHANDLE smFileHandle ; close the file + mov smFileHandle,INVALID_HANDLE + jmp @@Done ; jump to exit code +@@End: ; end sync address + CLOSEHANDLE smFileHandle ; close the file + mov smFileHandle,INVALID_HANDLE +@@Done: ; we're all done here + popad ; restore all general purpose regs + mov eax,smCodeSections + pop ebp ; restore previous stack frame + retn ; return near to caller +_getPECodeSectionCount endp + + + +void PureBitmap::upsideDown(WORD width,WORD height,GlobalData &bitmapBits)const +{ + HGLOBAL hGlobalTemp=::GlobalAlloc(GMEM_FIXED,width*height); + BYTE *lpDst; + BYTE *lpSrc; + + lpDst=(BYTE*)::GlobalLock(hGlobalTemp); + lpSrc=(BYTE*)&bitmapBits[0]; + for(LONG rowIndex=0;rowIndex &bitmapBytes,BOOL bottomUp)const +{ + PurePalette systemPalette; + PureDevice pureDevice; + BitmapInfo bmInfo; + DWORD scanLines(0); + DWORD scanLineWidth; + + if(!isOkay())return scanLines; + scanLineWidth=width(); + if(scanLineWidth%2L)scanLineWidth++; + scanWidth=scanLineWidth; + scanHeight=height(); + bitmapBytes.size(scanLineWidth*(DWORD)height()*(mBitmap.bmBitsPixel/8)); + systemPalette.systemPalette(); + bmInfo.width(width()); + bmInfo.height(height()); + bmInfo.bitCount(bitsPerPixel()); + bmInfo=systemPalette; + pureDevice.displayDevice(); + scanLines=::GetDIBits(pureDevice,*this,0,bottomUp?height():int(height())*-1,(BYTE*)&bitmapBytes[0],(BITMAPINFO*)bmInfo,DIB_RGB_COLORS); // bottomUp?int(height())*-1:height() + return scanLines; +} + + +// DWORD bitmapBits(WORD &scanWidth,WORD &scanHeight,GlobalData &bitmapBytes,BOOL bottomUp=FALSE)const; + + + +#if 0 +void OwnerDrawListCheck::drawEntire(const DrawItem &drawItem) +{ + PureDevice pureDevice(drawItem.deviceContext()); + PureDevice memDevice; + String stringData; + TEXTMETRIC textMetric; + Rect drawRect; + + if(!isOkay())return; + stringData.reserve(256); + drawRect=drawItem.rectItem(); + memDevice.compatibleDevice(pureDevice); + PureBitmap &pureBitmap=(((UINT)drawItem.itemState())&ODS_SELECTED?mPureBitmaps[BmSel]:mPureBitmaps[BmUnSel]); + sendMessage(drawItem.hwndItem(),LB_GETTEXT,drawItem.itemID(),(LPARAM)(LPSTR)stringData); + if(stringData.isNull())::MessageBeep(0); + ::GetTextMetrics(drawItem.deviceContext(),&textMetric); + if(drawItem.itemState()&ODS_DISABLED) + { + ::GrayString(drawItem.deviceContext(),(HBRUSH)(GDIObj)mDisabledBrush,(GRAYSTRINGPROC)0,(LPARAM)(LPSTR)stringData,stringData.length(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,0,0); +// ::GrayString(drawItem.deviceContext(),(HBRUSH)(GDIObj)mGrayBrush,(GRAYSTRINGPROC)0,(LPARAM)(LPSTR)stringData,stringData.length(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,0,0); + memDevice.select(pureBitmap,TRUE); + pureDevice.bitBlt(drawRect,memDevice,Point(0,0),PureDevice::MergeCopy); + memDevice.select(pureBitmap,FALSE); + } + else + { + ::TextOut(drawItem.deviceContext(),pureBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,(LPSTR)stringData,stringData.length()); + memDevice.select(pureBitmap,TRUE); + pureDevice.bitBlt(drawRect,memDevice,Point(0,0)); + memDevice.select(pureBitmap,FALSE); + } + if((((UINT)drawItem.itemState())&ODS_FOCUS)) + { + Rect bmpRect(drawRect); + bmpRect.right(bmpRect.left()+pureBitmap.width()); + bmpRect.bottom(bmpRect.top()+pureBitmap.height()); + ::DrawFocusRect(drawItem.deviceContext(),(RECT*)&bmpRect); + } +} +#endif + + + +#if 0 +int RichEditControl::getCaretPosition(void)const +{ + int charPos; + int row; + int col; + + if(!isValid())return 0; + charPos=HIWORD(sendMessage(EM_GETSEL,0,0L)); + row=sendMessage(EM_LINEFROMCHAR,(WPARAM)charPos,0L)+1; + col=(charPos-lineIndex())+1; + return MAKELPARAM(row,col); +} +#endif + + + + + + if(!versionInfo.isWinNT()) + { + for(long index=0;index +typedef unsigned short USHORT; +#ifndef DS_3DLOOK +#define DS_3DLOOK 0x0004L +#endif +#ifndef PFD_GENERIC_ACCELERATED +#define PFD_GENERIC_ACCELERATED 0x00001000 +#endif +#ifndef PFD_SWAP_LAYER_BUFFERS +#define PFD_SWAP_LAYER_BUFFERS 0x00000800 +#endif +#ifndef PFD_DEPTH_DONTCARE +#define PFD_DEPTH_DONTCARE 0x20000000 +#endif +#ifndef EN_MSGFILTER +#define EN_MSGFILTER 0x0700 +#endif +#ifndef EN_REQUESTRESIZE +#define EN_REQUESTRESIZE 0x0701 +#endif +#ifndef EN_SELCHANGE +#define EN_SELCHANGE 0x0702 +#endif +#ifndef EN_DROPFILES +#define EN_DROPFILES 0x0703 +#endif +#ifndef EN_PROTECTED +#define EN_PROTECTED 0x0704 +#endif +#endif +#ifndef IMAGE_DIRECTORY_ENTRY_COPYRIGHT +#define IMAGE_DIRECTORY_ENTRY_COPYRIGHT IMAGE_DIRECTORY_ENTRY_ARCHITECTURE +#endif + + + + +#if 0 +inline +String::operator int(void)const +{ + if(!mnpStr)return 0; + return ::atoi(mnpStr); +} + +inline +String::operator short(void)const +{ + if(!mnpStr)return 0; + return ::atoi(mnpStr); +} + +inline +String::operator float(void)const +{ + if(!mnpStr)return 0.00; + return ::atof(mnpStr); +} + +inline +String::operator long(void)const +{ + if(!mnpStr)return 0L; + return ::atol(mnpStr); +} +#endif + + +// operator int(void)const; +// operator short(void)const; +// operator float(void)const; +// operator long(void)const; + + + +//inline +//FileTime::operator FILETIME &(void) +//{ +// return *this; +//} + + + operator SYSTEMTIME &(void); + operator String(void); + + + +inline +SystemTime::operator SYSTEMTIME &(void) +{ + return *this; +} + + +SystemTime::operator String(void) +{ + return toString(); +} + + + + +WORD Bitmap::saveBitmap(void) +{ + BITMAPFILEHEADER bitmapFileHeader; + OFSTRUCT ofStruct; + + if(!isOkay())return FALSE; + if((HFILE_ERROR==mhFile)&&(HFILE_ERROR==(mhFile=::OpenFile(mFileName,&ofStruct,OF_WRITE|OF_CREATE))))return FALSE; + ::memset(&bitmapFileHeader,0,sizeof(BITMAPFILEHEADER)); + bitmapFileHeader.bfType=Signature; +// bitmapFileHeader.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*mMaxColors)+mImageExtent; +// bitmapFileHeader.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*mMaxColors); +// ::_lwrite(mhFile,(char*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER)); +// ::_lwrite(mhFile,(char*)getInfoPtr(),sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*mMaxColors)); +// ::_hwrite(mhFile,(char*)getDataPtr(),mImageExtent); + bitmapFileHeader.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1))+mImageExtent; + bitmapFileHeader.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1)); + ::_lwrite(mhFile,(char*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER)); + ::_lwrite(mhFile,(char*)getInfoPtr(),sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)+(sizeof(RGBQUAD)*(mMaxColors-1))); + ::_hwrite(mhFile,(char*)getDataPtr(),mImageExtent); + + + closeFile(); + return FALSE; +} + + + +WORD RegKey::setValue(const String &valueName,const String &stringData) +{ + DWORD resData(0); + long keyReturn; + +// if(!isOkay()||stringData.isNull()||valueName.isNull())return FALSE; +// keyReturn=::RegSetValueEx((HKEY)*this,valueName.isNull()?0:(LPSTR)valueName,resData,REG_SZ,(const unsigned char*)(LPSTR)stringData,stringData.length()+1); + if(!isOkay()||valueName.isNull())return FALSE; + if(stringData.isNull())keyReturn=::RegSetValueEx((HKEY)*this,valueName.isNull()?0:(LPSTR)valueName,resData,REG_SZ,0,0); + else keyReturn=::RegSetValueEx((HKEY)*this,valueName.isNull()?0:(LPSTR)valueName,resData,REG_SZ,(const unsigned char*)(LPSTR)stringData,stringData.length()+1); + return ERROR_SUCCESS==keyReturn; +} + + +/* +DWORD MemFile::read(char *lpBuffer,WORD lengthData) +{ + BYTE byteValue; + + if(!isOkay())return FALSE; + for(WORD index=0;indexbmiHeader.biClrUsed))mMaxColors=1<bmiHeader.biBitCount; + for(int itemIndex=0;itemIndexbmiColors[itemIndex]=bmInfo[itemIndex].getRGBQUAD(); + } + mImageExtent=imageExtent(); + lpPtr=reserveData(mImageExtent); + setBits(lpPtr,0,mImageExtent); + mWidth=getInfoPtr()->bmiHeader.biWidth; + mHeight=getInfoPtr()->bmiHeader.biHeight; + setPalette(); + return true; +} + + + +int GUIWindow::messageLoop(void)const +{ + bool isDialogMessage; + MSG msg; + + while(::GetMessage(&msg,NULL,0,0)) + { + isDialogMessage=false; + for(int mindex=0;mindex=strPathFileName.str())ptr--; + if(*ptr=='.')*ptr=0; + return true; +} + + + + + + + +#include +#include +#include +#include +#include +#include +#include + +FrameWindow::FrameWindow(void) +//: mFirstNextIndex(0) +{ + mDestroyHandler.setCallback(this,&FrameWindow::destroyHandler); + mMDIActivateHandler.setCallback(this,&FrameWindow::mdiActivateHandler); + mCommandHandler.setCallback(this,&FrameWindow::commandHandler); + insertHandler(VectorHandler::MDIActivateHandler,&mMDIActivateHandler); + insertHandler(VectorHandler::CommandHandler,&mCommandHandler); +} + +FrameWindow::FrameWindow(const FrameWindow &frameWindow) +//: mFirstNextIndex(0) +{ // private implementation + *this=frameWindow; + mDestroyHandler.setCallback(this,&FrameWindow::destroyHandler); + mMDIActivateHandler.setCallback(this,&FrameWindow::mdiActivateHandler); + mCommandHandler.setCallback(this,&FrameWindow::commandHandler); + insertHandler(VectorHandler::MDIActivateHandler,&mMDIActivateHandler); + insertHandler(VectorHandler::CommandHandler,&mCommandHandler); +} + +FrameWindow::~FrameWindow() +{ + removeHandler(VectorHandler::MDIActivateHandler,&mMDIActivateHandler); + removeHandler(VectorHandler::CommandHandler,&mCommandHandler); +} + +FrameWindow &FrameWindow::operator=(const FrameWindow &/*frameWindow*/) +{ // private implentation + return *this; +} + +void FrameWindow::createWindow(const String &className,const String &windowName,const String &menuName,const String &iconName) +{ + HINSTANCE hInstance(processInstance()); + mFrameMenu=menuName; + registerClass(hInstance,className,iconName); + GUIWindow::createWindow(className,windowName,WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN,Rect(CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT),0,mFrameMenu,hInstance,(LPSTR)this); + show(SW_SHOW); + update(); +} + +void FrameWindow::registerClass(HINSTANCE hInstance,const String &className,const String &iconName) +{ + WNDCLASS wndClass; + + if(::GetClassInfo(hInstance,(char*)(String&)className,&wndClass))return; + wndClass.style =CS_HREDRAW|CS_VREDRAW; + wndClass.lpfnWndProc =(WNDPROC)FrameWindow::FrameProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(FrameWindow*); + wndClass.hInstance =hInstance; + wndClass.hIcon =::LoadIcon(hInstance,iconName); + wndClass.hCursor =::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)(COLOR_WINDOWFRAME); + wndClass.lpszMenuName =0; + wndClass.lpszClassName =(char*)(String&)className; + preRegister(wndClass); + ::RegisterClass(&wndClass); +} + +void FrameWindow::createMDIClientWindow(void) +{ + CLIENTCREATESTRUCT clientCreate; + PureMenu subMenu; + + clientCreate.hWindowMenu=(HMENU)subMenu; + clientCreate.idFirstChild=IDFirstMDIChild; + mClientWnd.createWindow("MDICLIENT",String(),WS_CHILD|WS_CLIPCHILDREN|WS_VISIBLE|MDIS_ALLCHILDSTYLES,Rect(0,0,0,0),*this,(HMENU)0,processInstance(),(CLIENTCREATESTRUCT *)&clientCreate); +} + +void FrameWindow::insert(MDIWindow &mdiWindow) +{ + mDocuments.insert(&SmartPointer(&mdiWindow)); + mDocuments[mDocuments.size()-1].disposition(PointerDisposition::Delete); + mDocuments[mDocuments.size()-1]->insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler); +} + +MDIWindow &FrameWindow::operator[](int itemIndex) +{ + return *(mDocuments[itemIndex]); +} + +int FrameWindow::size(void)const +{ + return mDocuments.size(); +} + +int FrameWindow::windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam) +{ + watchDocumentWindows(); + if(message>=WM_USER&&message<=0x7FFF) + { + if(!installedHandlers(VectorHandler::UserHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::UserHandler,CallbackData(message,lParam,hWnd)); + } + switch(message) + { + case WM_CLOSE : + if(!installedHandlers(VectorHandler::CloseHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CloseHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCCREATE : + if(!installedHandlers(VectorHandler::NCCreateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCCreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHANGECBCHAIN : + if(!installedHandlers(VectorHandler::ChangeCBChainHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ChangeCBChainHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWCLIPBOARD : + if(!installedHandlers(VectorHandler::DrawClipboardHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawClipboardHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CREATE : + createMDIClientWindow(); + if(!installedHandlers(VectorHandler::CreateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PAINT : + if(!installedHandlers(VectorHandler::PaintHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return handlePaintMessage(hWnd,message,wParam,lParam); + case WM_ERASEBKGND : + if(!installedHandlers(VectorHandler::EraseBackgroundHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EraseBackgroundHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PALETTECHANGED : + if(!installedHandlers(VectorHandler::PaletteChangedHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::PaletteChangedHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWITEM : + if(!installedHandlers(VectorHandler::DrawItemHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_TIMER : + if(!installedHandlers(VectorHandler::TimerHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::TimerHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHAR : + if(!installedHandlers(VectorHandler::CharHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CharHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMMAND : + if(!installedHandlers(VectorHandler::CommandHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + callHandlers(VectorHandler::CommandHandler,CallbackData(wParam,lParam,hWnd)); + return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + case WM_COMPACTING : + if(!installedHandlers(VectorHandler::CompactingHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CompactingHandler,CallbackData(wParam,lParam,hWnd)); + case WM_WININICHANGE : + if(!installedHandlers(VectorHandler::WinIniChangeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::WinIniChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SYSCOLORCHANGE : + if(!installedHandlers(VectorHandler::SysColorChangeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SysColorChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORMSGBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOREDIT : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORLISTBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORBTN : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORDLG : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSCROLLBAR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSTATIC : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_INITIATE : + if(!installedHandlers(VectorHandler::DDEInitiateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEInitiateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_ACK : + if(!installedHandlers(VectorHandler::DDEAckHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEAckHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_REQUEST : + if(!installedHandlers(VectorHandler::DDERequestHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDERequestHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_TERMINATE : + if(!installedHandlers(VectorHandler::DDETerminateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDETerminateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_DATA : + if(!installedHandlers(VectorHandler::DDEDataHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEDataHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_OPEN : + if(!installedHandlers(VectorHandler::MMOpenHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMOpenHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_CLOSE : + if(!installedHandlers(VectorHandler::MMCloseHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMCloseHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_DONE : + if(!installedHandlers(VectorHandler::MMDoneHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMDoneHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::LeftButtonDoubleHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDOWN : + if(!installedHandlers(VectorHandler::LeftButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONUP : + if(!installedHandlers(VectorHandler::LeftButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::RightButtonDoubleHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDOWN : + if(!installedHandlers(VectorHandler::RightButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONUP : + if(!installedHandlers(VectorHandler::RightButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONUP : + if(!installedHandlers(VectorHandler::NCLeftButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCLeftButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONUP : + if(!installedHandlers(VectorHandler::NCRightButtonUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCRightButtonDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MOUSEMOVE : + if(!installedHandlers(VectorHandler::MouseMoveHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MouseMoveHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFOCUS : + if(!installedHandlers(VectorHandler::SetFocusHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFONT : + if(!installedHandlers(VectorHandler::SetFontHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFontHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KILLFOCUS : + if(!installedHandlers(VectorHandler::KillFocusHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KillFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYUP : + if(!installedHandlers(VectorHandler::KeyUpHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYDOWN : + if(!installedHandlers(VectorHandler::KeyDownHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETMINMAXINFO : + if(!installedHandlers(VectorHandler::MinMaxHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MinMaxHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ENTERIDLE : + if(!installedHandlers(VectorHandler::EnterIdleHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EnterIdleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MENUSELECT : + if(!installedHandlers(VectorHandler::MenuSelectHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MenuSelectHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETDLGCODE : + if(!installedHandlers(VectorHandler::DialogCodeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DialogCodeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MEASUREITEM : + if(!installedHandlers(VectorHandler::MeasureItemHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MeasureItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_VSCROLL : + if(!installedHandlers(VectorHandler::VerticalScrollHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::VerticalScrollHandler,CallbackData(wParam,lParam,hWnd)); + case WM_HSCROLL : + if(!installedHandlers(VectorHandler::HorizontalScrollHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::HorizontalScrollHandler,CallbackData(wParam,lParam,hWnd)); +#if defined(__FLAT__) + case WM_NOTIFY : + if(!installedHandlers(VectorHandler::NotifyHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NotifyHandler,CallbackData(wParam,lParam,hWnd)); +#endif + case WM_SIZE : + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SizeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DROPFILES : + if(!installedHandlers(VectorHandler::DropFilesHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DropFilesHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DESTROY : + if(!installedHandlers(VectorHandler::DestroyHandler))postQuitMessage(); + callHandlers(VectorHandler::DestroyHandler,CallbackData(wParam,lParam,hWnd)); + InstanceData::removeInstanceData(hWnd); + setHandle(0); + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return FALSE; + case WM_MDIACTIVATE : + if(!installedHandlers(VectorHandler::MDIActivateHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MDIActivateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ACTIVATEAPP : + if(!installedHandlers(VectorHandler::ActivateAppHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ActivateAppHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DISPLAYCHANGE : + if(!installedHandlers(VectorHandler::DisplayChangeHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DisplayChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SHOWWINDOW : + if(!installedHandlers(VectorHandler::ShowWindowHandler))return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ShowWindowHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MDIDESTROY : + return FALSE; + case WM_NCDESTROY : + default : + return ::DefFrameProc(hWnd,mClientWnd,message,wParam,lParam); + } +} + +#if defined(_MSC_VER) +int FAR PASCAL FrameWindow::enumerateProcedure(HWND hWnd,LPARAM lParam) +#else +int FAR PASCAL _export FrameWindow::enumerateProcedure(HWND hWnd,LPARAM lParam) +#endif +{ + if(::GetWindow(hWnd,GW_OWNER))return 1; + switch(LOWORD(lParam)) + { + case MDICloseAll : + if(!::SendMessage(hWnd,WM_QUERYENDSESSION,0,0L))return 1; + ::SendMessage(::GetParent(hWnd),WM_MDIDESTROY,(WPARAM)hWnd,0L); + break; + case MDIRestoreAll : + if(::IsIconic(hWnd)||::IsZoomed(hWnd)) + ::SendMessage(::GetParent(hWnd),WM_MDIRESTORE,(WPARAM)hWnd,0L); + break; + case MDIMinimizeAll : + if(!::IsIconic(hWnd))::ShowWindow(hWnd,SW_SHOWMINNOACTIVE); + break; + } + return 1; +} + +void FrameWindow::watchDocumentWindows(void) +{ + WORD size(mDocuments.size()); + for(int itemIndex=0;itemIndexisValid()) + { + mDocuments.remove(itemIndex); + size=mDocuments.size(); + itemIndex=-1; + } + } +} + +bool FrameWindow::getActive(SmartPointer &mdiWindow) +{ + HWND hMDIChild(0); + + if(!mClientWnd.isValid())return false; + if((HWND)0==(hMDIChild=(HWND)mClientWnd.sendMessage(WM_MDIGETACTIVE,0,0L)))return false; + for(int itemIndex=0;itemIndex &mdiWindow) +{ + HWND hMDIChild; + + if(!mClientWnd.isValid())return false; + if((HWND)0==(hMDIChild=mClientWnd.findWindow(strWindowName)))return false; + for(int itemIndex=0;itemIndex > &mdiWindows) +{ + mdiWindows.size(mDocuments.size()); + if(!mdiWindows.size())return false; + for(int index=0;index &mdiWindow) +{ + Array > mdiWindows; + if(!getDocuments(mdiWindows))return false; + for(int index=0;indexclassName()==strClassName) + { + mdiWindow=mdiWindows[index]; + return true; + } + } + return false; + +// if(getFirstDocument(mdiWindow)) +// { +// if(mdiWindow->className()==strClassName)return true; +// while(getNextDocument(mdiWindow))if(mdiWindow->className()==strClassName)return true; +// } +// return false; +} + +/* +BOOL FrameWindow::getFirstDocument(SmartPointer &mdiWindow) +{ + if(!mDocuments.size())return FALSE; + mdiWindow=mDocuments[mFirstNextIndex=0]; + return TRUE; +} + +BOOL FrameWindow::getNextDocument(SmartPointer &mdiWindow) +{ + if(!mDocuments.size()||mFirstNextIndex+1>=mDocuments.size())return FALSE; + mdiWindow=mDocuments[++mFirstNextIndex]; + return TRUE; +} +*/ + +/* +BOOL FrameWindow::getFirstDocument(SmartPointer &mdiWindow) +{ + if(!mDocuments.size())return FALSE; + + SmartPointer pFirstNextData; + if(!mFirstNextStore.getThreadData(pFirstNextData)) + { + mFirstNextStore.addThreadData(PureDWORD(0)); + mFirstNextStore.getThreadData(pFirstNextData); + } + else pFirstNextData->setValue(0); + if(pFirstNextData->getValue()>=mDocuments.size()) + { + mFirstNextStore.removeThreadData(); + return false; + } + mdiWindow=mDocuments[pFirstNextData->getValue()]; +// mdiWindow=mDocuments[mFirstNextIndex=0]; + return TRUE; +} + +BOOL FrameWindow::getNextDocument(SmartPointer &mdiWindow) +{ + SmartPointer pFirstNextData; + + if(!mFirstNextStore.getThreadData(pFirstNextData))return false; + if(!mDocuments.size()||pFirstNextData->getValue()+1>=mDocuments.size()) + { + mFirstNextStore.removeThreadData(); + return false; + } + pFirstNextData->setValue(pFirstNextData->getValue()+1); + mdiWindow=mDocuments[pFirstNextData->getValue()]; +// if(!mDocuments.size()||mFirstNextIndex+1>=mDocuments.size())return FALSE; +// mdiWindow=mDocuments[++mFirstNextIndex]; + return TRUE; +} +*/ + +void FrameWindow::enableMenuItems(UINT menuIndex,UINT itemID,PureMenu::PositionFlags positionFlags,PureMenu::InsertFlags insertFlags) +{ + SmartPointer mdiWindow; + Array > mdiWindows; + PureMenu subMenu; + + if(!getDocuments(mdiWindows))return; + getFrameMenu().getSubMenu(menuIndex,subMenu); + subMenu.enableMenuItem(itemID,positionFlags,insertFlags); + drawMenuBar(); + for(int index=0;indexgetMenu().getSubMenu(menuIndex,subMenu); + subMenu.enableMenuItem(itemID,positionFlags,insertFlags); + mdiWindow->drawMenuBar(); + } + +// if(getFirstDocument(mdiWindow)) +// { +// mdiWindow->getMenu().getSubMenu(menuIndex,subMenu); +// subMenu.enableMenuItem(itemID,positionFlags,insertFlags); +// mdiWindow->drawMenuBar(); +// while(getNextDocument(mdiWindow)) +// { +// mdiWindow->getMenu().getSubMenu(menuIndex,subMenu); +// subMenu.enableMenuItem(itemID,positionFlags,insertFlags); +// mdiWindow->drawMenuBar(); +// } +// } +} + +CallbackData::ReturnType FrameWindow::destroyHandler(CallbackData &someCallbackData) +{ + for(int itemIndex=0;itemIndex=mDocuments.size())return FALSE; + mClientWnd.sendMessage(WM_MDIACTIVATE,(WPARAM)(HWND)*mDocuments[childIndex],0L); + mDocuments[childIndex]->show(SW_SHOWNORMAL); + return TRUE; +} + +void FrameWindow::destroy(void) +{ + SmartPointer mdiWindow; + Array > mdiWindows; + + getDocuments(mdiWindows); + for(int index=0;indexcontrolID(controlID); +// createWindow(className,windowName,dwStyle,initRect,hParentWnd,(HMENU)controlID,(HINSTANCE)::GetWindowLong(hParentWnd,GWL_HINSTANCE),0); + createWindow(className,windowName,dwStyle,initRect,hParentWnd,(HMENU)controlID,(HINSTANCE)processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); +// createWindow(extendedStyle,className,windowName,dwStyle,initRect,hParentWnd,(HMENU)controlID,(HINSTANCE)::GetWindowLong(hParentWnd,GWL_HINSTANCE),0); + createWindow(extendedStyle,className,windowName,dwStyle,initRect,hParentWnd,(HMENU)controlID,(HINSTANCE)processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::createControl(const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,Window &parentWindow,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); +// createWindow(className,windowName,dwStyle,initRect,parentWindow,(HMENU)controlID,parentWindow.processInstance(),0); + createWindow(className,windowName,dwStyle,initRect,parentWindow,(HMENU)controlID,processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + +HWND Control::createControl(DWORD extendedStyle,const String &className,const String &windowName,DWORD dwStyle,const Rect &initRect,Window &parentWindow,int controlID) +{ + dwStyle|=WS_CHILD; + if(isValid())return *this; + this->controlID(controlID); + createWindow(extendedStyle,className,windowName,dwStyle,initRect,parentWindow,(HMENU)controlID,processInstance(),0); +// createWindow(extendedStyle,className,windowName,dwStyle,initRect,parentWindow,(HMENU)controlID,parentWindow.processInstance(),0); + disposition(GUIWindow::AssumeAndDestroy); + return *this; +} + + + +class FileTime : private FILETIME +{ +public: + FileTime(void); + FileTime(const FileTime &someFileTime); + FileTime(const FILETIME &someFILETIME); + FileTime(const SystemTime &someSystemTime); + virtual ~FileTime(); + FileTime &operator=(const FileTime &someFileTime); + FileTime &operator=(const SystemTime &someSystemTime); diff --git a/common/Status.hpp b/common/Status.hpp new file mode 100644 index 0000000..595374d --- /dev/null +++ b/common/Status.hpp @@ -0,0 +1,153 @@ +#ifndef _COMMON_STATUSWINDOW_HPP_ +#define _COMMON_STATUSWINDOW_HPP_ +#ifndef _COMMON_CONTROL_HPP_ +#include +#endif +#ifndef _COMMON_COMMCTRL_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif + +class StatusControl : public Control +{ +public: + enum DrawType{DrawNormal=0,DrawNoBorders=SBT_NOBORDERS,DrawOwnerDraw=SBT_OWNERDRAW,DrawPopout=SBT_POPOUT,DrawRTLReading=SBT_RTLREADING}; + enum {FirstPart=0,SimplePart=255}; + StatusControl(void); + virtual ~StatusControl(); + HWND createControl(const String &windowName,HWND hParentWnd,UINT controlID); + HWND createControl(const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID); + BOOL getBorders(int &horzBorder,int &vertBorder,int &rectBorder)const; + UINT getParts(GlobalData &rightCoords)const; + BOOL setParts(GlobalData &partsWidths)const; + BOOL getRect(Rect &partRect,UINT partIndex=0)const; + BOOL getText(String &controlText,UINT partIndex=0)const; + UINT getTextLength(UINT partIndex)const; + void setMinHeight(WORD minHeight)const; + BOOL setText(const String &strText,UINT partIndex=FirstPart,DrawType drawType=DrawNormal)const; + BOOL simple(BOOL simple)const; + UINT numParts(void)const; +private: + enum{MaxParts=255}; + StatusControl(const StatusControl &statusControl); + StatusControl &operator=(const StatusControl &statusControl); +}; + +inline +StatusControl::StatusControl(void) +{ + InitCommonControls(); +} + +inline +StatusControl::~StatusControl() +{ +} + +inline +StatusControl::StatusControl(const StatusControl &statusControl) +{ // private implementation + *this=statusControl; +} + +inline +StatusControl &StatusControl::operator=(const StatusControl &statusControl) +{ // private implementation + return *this; +} + +inline +HWND StatusControl::createControl(const String &windowName,DWORD dwStyle,const Rect &initRect,HWND hParentWnd,int controlID) +{ + if(isValid())return FALSE; + return Control::createControl(STATUSCLASSNAME,windowName,dwStyle,initRect,hParentWnd,controlID); +} + +inline +HWND StatusControl::createControl(const String &windowName,HWND hParentWnd,UINT controlID) +{ + if(isValid())return FALSE; + return Control::createControl(STATUSCLASSNAME,windowName,WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,Rect(CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT),hParentWnd,controlID); +} + +inline +UINT StatusControl::numParts(void)const +{ + if(!isValid())return FALSE; + return sendMessage(SB_GETPARTS,0,0); +} + +inline +BOOL StatusControl::getBorders(int &horzBorder,int &vertBorder,int &rectBorder)const +{ + int statBorders[3]; + + if(!isValid()||!sendMessage(SB_GETBORDERS,0,(LPARAM)(LPINT)statBorders))return FALSE; + horzBorder=statBorders[0]; + vertBorder=statBorders[1]; + rectBorder=statBorders[2]; + return TRUE; +} + +inline +UINT StatusControl::getParts(GlobalData &rightCoords)const +{ + if(!isValid())return FALSE; + rightCoords.size(numParts()); + if(!rightCoords.size())return FALSE; + return sendMessage(SB_GETPARTS,rightCoords.size(),(LPARAM)(int*)&rightCoords[0]); +} + +inline +BOOL StatusControl::setParts(GlobalData &partsWidths)const +{ + if(!isValid()||!partsWidths.size()||partsWidths.size()>MaxParts)return FALSE; + return sendMessage(SB_SETPARTS,(WPARAM)partsWidths.size(),(LPARAM)(int*)&partsWidths[0]); +} + +inline +BOOL StatusControl::getRect(Rect &partRect,UINT partIndex)const +{ + if(!isValid())return FALSE; + return sendMessage(SB_GETRECT,(WPARAM)partIndex,(LPARAM)(RECT*)partRect); +} + +inline +BOOL StatusControl::getText(String &controlText,UINT partIndex)const +{ + if(!isValid())return FALSE; + controlText.reserve(getTextLength(partIndex)+1); + sendMessage(SB_GETTEXT,(WPARAM)partIndex,(LPARAM)(char*)controlText); + return controlText.isNull(); +} + +inline +UINT StatusControl::getTextLength(UINT partIndex)const +{ + if(!isValid())return FALSE; + return LOWORD(sendMessage(SB_GETTEXTLENGTH,(WPARAM)partIndex,0L)); +} + +inline +void StatusControl::setMinHeight(WORD minHeight)const +{ + if(!isValid())return; + sendMessage(SB_SETMINHEIGHT,(WPARAM)minHeight,0L); +} + +inline +BOOL StatusControl::setText(const String &strText,UINT partIndex,DrawType drawType)const +{ + if(!isValid()||strText.isNull())return FALSE; + return sendMessage(SB_SETTEXT,(WPARAM)(partIndex|(UINT)drawType),(LPARAM)(char*)(String&)strText); +} + +inline +BOOL StatusControl::simple(BOOL simple)const +{ + if(!isValid())return FALSE; + return sendMessage(SB_SIMPLE,(WPARAM)simple,0L); +} +#endif diff --git a/common/String.hpp b/common/String.hpp new file mode 100644 index 0000000..dbecf7e --- /dev/null +++ b/common/String.hpp @@ -0,0 +1,309 @@ +#ifndef _COMMON_STRING_HPP_ +#define _COMMON_STRING_HPP_ +#include +#ifndef _COMMON_STDLIB_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +template +class Block; +class istream; +class ostream; +class String; + +istream &operator>>(istream &stream,String &someString); +ostream &operator<<(ostream &stream,const String &someString); + +String operator+(const char *str,const String &string); + +class String +{ +public: + enum{MaxString=128}; + String(void); + String(const char *npStr); + String(const String &newString); + String(int resourceStringID); + String(int resourceStringID,HINSTANCE hInstance); + String(char characterItem); + virtual ~String(); + int operator!=(const String &someString)const; + int operator!=(const char *someCharStar)const; + int operator==(const String &someString)const; + int operator==(const char *someCharStar)const; + int operator<(const String &someString)const; + int operator>(const String &someString)const; + String &operator=(const String &someString); + int operator=(const char *someCharStar); + int operator+=(const String &someString); + int operator+=(const char *someStr); + void operator+=(char someChar); + char &operator[](DWORD itemIndex); + char charAt(DWORD itemIndex)const; + String &setAt(DWORD itemIndex,char ch); + friend istream &operator>>(istream &stream,String &someString); + friend ostream &operator<<(ostream &stream,const String &someString); + operator char *(void)const; + String operator+(const String &someString)const; + int reserve(unsigned nBytes,WORD setZero=TRUE); + int token(const char *token); + int isNull(void)const; + void upper(void); + void lower(void); + int length(void)const; + void length(short newLength); + DWORD lengthBytes(void)const; + void removeTokens(String someTokens); + void replaceToken(BYTE tokenFind,BYTE tokenReplace); + int hex(void)const; + void expand(void); + void convert(double doubleValue,const char *formatString); + void convert(int integerValue,const char *formatString); + void convert(long longValue,const char *formatString); + int strstr(const char *string)const; + int strpos(const char *string)const; + int strchr(char someChar)const; + int strncmp(const char *string)const; + String &trimRight(void); + String &trimLeft(void); + void spaceTerm(void); + String betweenString(char beginToken,char endToken)const; + String substr(WORD startPosition,WORD endPosition)const; + String substr(WORD startPosition)const; + String extractDigits(void)const; + String extractAlpha(void)const; + WORD makeBlock(Block &receiveStrings,const String &tokenString)const; + WORD insert(const String &insertString,WORD insertPosition=0); + WORD insert(char *lpInsertString,WORD insertPosition=0); + WORD remove(WORD removePosition=0); + int toInt(void)const; + short toShort(void)const; + float toFloat(void)const; + double toDouble(void)const; + long toLong(void)const; + String &fromInt(int value); + String &fromShort(short value); + String &fromUShort(unsigned short value); + String &fromFloat(float value); + String &fromLong(long value); + String &fromBool(bool value); + String &fromDouble(double value); + bool equals(const String &string)const; + const char *str(void)const; + char *str(void); + String quotes(void)const; +private: + enum{Blank=' '}; + void shiftRight(String &shiftString,WORD startPos,WORD endPos,WORD insertLength,WORD originalLength); + void removeData(void); + HINSTANCE instanceData(void); + + char FAR *mnpStr; + DWORD mLengthBytes; +}; + +inline +String::String(void) +: mnpStr(0), mLengthBytes(0L) +{ + reserve(MaxString); +} + +inline +String::String(int resourceStringID) +: mnpStr(0), mLengthBytes(0L) +{ + reserve(MaxString); + if(!::LoadString(instanceData(),resourceStringID,mnpStr,MaxString-1))::strcpy(mnpStr,"UNSET"); +} + +inline +String::String(int resourceStringID,HINSTANCE hInstance) +: mnpStr(0), mLengthBytes(0L) +{ + reserve(MaxString); + if(!::LoadString(hInstance,resourceStringID,mnpStr,MaxString-1))::strcpy(mnpStr,"UNSET"); +} + +inline +String::String(char characterItem) +: mnpStr(0), mLengthBytes(0) +{ + reserve(sizeof(characterItem)+1); + *mnpStr=characterItem; +} + +inline +String::~String() +{ + removeData(); +} + +inline +String::operator char *(void)const +{ + return mnpStr; +} + +inline +char &String::operator[](DWORD itemIndex) +{ + return *(mnpStr+itemIndex); +} + +inline +String &String::setAt(DWORD itemIndex,char ch) +{ + *(mnpStr+itemIndex)=ch; + return *this; +} + +inline +char String::charAt(DWORD itemIndex)const +{ + return *(mnpStr+itemIndex); +} + +inline +int String::reserve(unsigned nBytes,WORD setZero) +{ + if(!nBytes)return 0; + if(nBytes>mLengthBytes) + { + removeData(); + mnpStr=::new char[nBytes]; + mLengthBytes=nBytes; + } + if(setZero)::memset(mnpStr,0,mLengthBytes); + return 1; +} + +inline +HINSTANCE String::instanceData(void) +{ +#ifdef __FLAT__ + return ::GetModuleHandle(0); +#else + return((HINSTANCE)(_DS-1)); +#endif +} + +inline +String String::substr(WORD startPosition)const +{ + return substr(startPosition,length()); +} + +inline +int String::length(void)const +{ + return (mnpStr?::strlen(mnpStr):0); +} + +inline +void String::removeData(void) +{ + if(!mnpStr)return; + ::delete[] mnpStr; + mnpStr=0; + mLengthBytes=0; +} + +inline +int String::isNull(void)const +{ + if(!mnpStr||!(*mnpStr))return 1; + return 0; +} + +inline +DWORD String::lengthBytes(void)const +{ + return mLengthBytes; +} + +inline +int String::operator==(const String &someString)const +{ + if(!mnpStr&&!someString.mnpStr)return 1; + if(!mnpStr||!someString.mnpStr)return 0; + return (!::strcmp(mnpStr,someString.mnpStr)); +} + +inline +int String::operator!=(const String &someString)const +{ + if(!mnpStr&&!someString.mnpStr)return 0; + if(!mnpStr||!someString.mnpStr)return 1; + return (::strcmp(mnpStr,someString.mnpStr)); +} + +inline +int String::operator!=(const char *someCharStar)const +{ + if(!mnpStr&&!someCharStar)return 0; + if(!mnpStr||!someCharStar)return 1; + return (::strcmp(mnpStr,someCharStar)); +} + +inline +int String::operator==(const char *someCharStar)const +{ + if(!mnpStr&&!someCharStar)return 1; + if(!mnpStr||!someCharStar)return 0; + return (!::strcmp(mnpStr,someCharStar)); +} + +inline +int String::operator<(const String &someString)const +{ + if(isNull()&&someString.isNull())return FALSE; + if(isNull())return TRUE; + return (::strcmp(mnpStr,someString.mnpStr)<0?TRUE:FALSE); +} + +inline +int String::operator>(const String &someString)const +{ + if(isNull()&&someString.isNull())return FALSE; + if(isNull())return FALSE; + return (::strcmp(mnpStr,someString.mnpStr)>0?TRUE:FALSE); +} + +inline +int String::strstr(const char *string)const +{ + if(!mnpStr)return 0; + return (int)::strstr(mnpStr,string); +} + +inline +bool String::equals(const String &string)const +{ + return *this==string?true:false; +} + +inline +const char *String::str(void)const +{ + return mnpStr; +} + +inline +char *String::str(void) +{ + return mnpStr; +} + +inline +String String::quotes(void)const +{ + return String("\"")+*this+String("\""); +} + +typedef String string; + +#endif diff --git a/common/StringBuffer.hpp b/common/StringBuffer.hpp new file mode 100644 index 0000000..155b5c4 --- /dev/null +++ b/common/StringBuffer.hpp @@ -0,0 +1,93 @@ +#ifndef _COMMON_STRINGBUFFER_HPP_ +#define _COMMON_STRINGBUFFER_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif + +class StringBuffer +{ +public: + StringBuffer(); + StringBuffer(DWORD initialSize); + virtual ~StringBuffer(); + StringBuffer &append(const String &string); + StringBuffer &append(const char &ch); + void growBy(DWORD growBy); + String toString(void)const; +private: + enum{GrowBy=2048}; + void preallocate(DWORD items); + Array mInternalRep; + DWORD mItemCount; + DWORD mGrowBy; +}; + + +inline +StringBuffer::StringBuffer() +: mGrowBy(GrowBy), mItemCount(0) +{ + mInternalRep.size(mGrowBy); +} + +inline +StringBuffer::StringBuffer(DWORD initialSize) +: mGrowBy(initialSize?initialSize:GrowBy), mItemCount(0) +{ + mInternalRep.size(mGrowBy); +} + +inline +StringBuffer::~StringBuffer() +{ +} + +inline +StringBuffer &StringBuffer::append(const String &string) +{ + int length(string.length()); + preallocate(length); + ::memcpy(&mInternalRep[mItemCount],string.str(),length); + mItemCount+=length; + return *this; +} + +inline +StringBuffer &StringBuffer::append(const char &ch) +{ + preallocate(1); + mInternalRep[mItemCount]=ch; + mItemCount++; + return *this; +} + +inline +void StringBuffer::preallocate(DWORD items) +{ + if(mInternalRep.size()>mItemCount+items)return; + Array tmpArray; + tmpArray.size(mInternalRep.size()+(mGrowBy>items?mGrowBy:items)); + ::memcpy(&tmpArray[0],&mInternalRep[0],mInternalRep.size()); + mInternalRep.size(tmpArray.size()); + ::memcpy(&mInternalRep[0],&tmpArray[0],mItemCount); +} + +inline +void StringBuffer::growBy(DWORD growBy) +{ + if(growBy)mGrowBy=growBy; +} + +inline +String StringBuffer::toString(void)const +{ + String str; + str.reserve(mItemCount+1); + ::memcpy(str.str(),&((Array&)mInternalRep)[0],mItemCount); + (str.str())[mItemCount]=0; + return str; +} +#endif diff --git a/common/Systime.cpp b/common/Systime.cpp new file mode 100644 index 0000000..fc2c8c6 --- /dev/null +++ b/common/Systime.cpp @@ -0,0 +1,175 @@ +#include + +String SystemTime::toString(void)const +{ + String systemTime; + String dayString; + String monthString; + + getMonth(monthString); + getDay(dayString); + ::sprintf(systemTime,"%s%s %d,%d %02d:%02d:%02d",(LPSTR)dayString,(LPSTR)monthString,day(),year(),hour(),minute(),second()); + return systemTime; +} + +String SystemTime::toStringShort(void)const +{ + String systemTime; + String dayString; + String monthString; + + getMonth(monthString); + getDay(dayString,true); + ::sprintf(systemTime,"%s%s %d,%d %02d:%02d:%02d",(LPSTR)dayString,(LPSTR)monthString,day(),year(),hour(),minute(),second()); + return systemTime; +} + +bool SystemTime::operator>(const SystemTime &someSystemTime)const +{ + if(year()>someSystemTime.year())return TRUE; + else if(year()someSystemTime.month())return TRUE; + else if(month()someSystemTime.day())return TRUE; + else if(day()someSystemTime.hour())return TRUE; + else if(hour()someSystemTime.minute())return TRUE; + else if(minute()someSystemTime.second())return TRUE; + else if(second()someSystemTime.milliseconds())return TRUE; + return FALSE; +} + +bool SystemTime::operator<(const SystemTime &someSystemTime)const +{ + if(*this>someSystemTime)return FALSE; + if(*this==someSystemTime)return FALSE; + return TRUE; +} + +void SystemTime::makeTime(WORD year,WORD month,WORD day,WORD hour,WORD minute,WORD second) +{ + WORD wFatDate; + WORD wFatTime; + FILETIME fileTime; + + wFatDate=day; + wFatDate|=(month<<5); + wFatDate|=((year-1980)<<9); + wFatTime=second/2; + wFatTime|=(minute<<5); + wFatTime|=(hour<<11); + ::DosDateTimeToFileTime(wFatDate,wFatTime,&fileTime); + ::FileTimeToSystemTime(&fileTime,&((SYSTEMTIME&)*this)); +} + +void SystemTime::getMonth(String &monthString)const +{ + switch(month()) + { + case January : + monthString="January"; + break; + case February : + monthString="February"; + break; + case March : + monthString="March"; + break; + case April : + monthString="April"; + break; + case May : + monthString="May"; + break; + case June : + monthString="June"; + break; + case July : + monthString="July"; + break; + case August : + monthString="August"; + break; + case September : + monthString="September"; + break; + case October : + monthString="October"; + break; + case November : + monthString="November"; + break; + case December : + monthString="December"; + break; + } +} + +void SystemTime::getDay(String &dayString,bool shortName)const +{ + switch(dayOfWeek()) + { + case Monday : + if(shortName)dayString="Mon"; + else dayString="Monday"; + break; + case Tuesday : + if(shortName)dayString="Tue"; + else dayString="Tuesday"; + break; + case Wednesday : + if(shortName)dayString="Wed"; + else dayString="Wednesday"; + break; + case Thursday : + if(shortName)dayString="Thu"; + else dayString="Thursday"; + break; + case Friday : + if(shortName)dayString="Fri"; + else dayString="Friday"; + break; + case Saturday : + if(shortName)dayString="Sat"; + else dayString="Saturday"; + break; + case Sunday : + if(shortName)dayString="Sun"; + else dayString="Sunday"; + break; + default : + dayString="unknown"; + break; + } + dayString+=", "; +} + +void SystemTime::daysAdd360(short dayCount) +{ + long totalDays; + WORD isThirtyFirst; + + if(!year()&&!day()&&!month()||!dayCount)return; + isThirtyFirst=LongestDaysInMonth==day(); + if(isThirtyFirst)day(LongestDaysInMonth-1); + totalDays=360*(long)year()+30*(long)month()+(long)day()+dayCount-391; + day((short)(totalDays%30)+1); + month(Month((short)(totalDays/30)%12+1)); + year((short)(totalDays/360)+1); + if(!(dayCount%30)&&isThirtyFirst) + switch(month()) + { + case January : + case March : + case May : + case July : + case August : + case October : + case December : + day(day()+1); + break; + } +} diff --git a/common/Systime.hpp b/common/Systime.hpp new file mode 100644 index 0000000..b2835ad --- /dev/null +++ b/common/Systime.hpp @@ -0,0 +1,267 @@ +#if defined(_WIN32) +#ifndef _COMMON_SYSTEMTIME_HPP_ +#define _COMMON_SYSTEMTIME_HPP_ +#include +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_FILETIME_HPP_ +#include +#endif + +class SystemTime : private SYSTEMTIME +{ +public: + enum Month{None,January,February,March,April,May,June,July,August,September,October, + November,December}; + enum Day{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}; + SystemTime(void); + SystemTime(const SystemTime &someSystemTime); + SystemTime(WORD year,WORD month,WORD day,WORD hour=0,WORD minute=0,WORD second=0); + SystemTime(const FileTime &someFileTime); + SystemTime(const SYSTEMTIME &someSYSTEMTIME); + virtual ~SystemTime(); + SystemTime &operator=(const SystemTime &someSystemTime); + SystemTime &operator=(const SYSTEMTIME &someSYSTEMTIME); + SystemTime &operator=(const FileTime &someFileTime); + bool operator>(const SystemTime &someSystemTime)const; + bool operator<(const SystemTime &someSystemTime)const; + bool operator==(const SystemTime &someSystemTime)const; + bool operator>=(const SystemTime &someSystemTime)const; + WORD year(void)const; + void year(WORD year); + Month month(void)const; + void month(Month month); + Day dayOfWeek(void)const; + void dayOfWeek(Day dayOfWeek); + WORD day(void)const; + void day(WORD day); + WORD hour(void)const; + void hour(WORD hour); + WORD minute(void)const; + void minute(WORD minute); + WORD second(void)const; + void second(WORD second); + WORD milliseconds(void)const; + void milliseconds(WORD milliseconds); + void daysAdd360(short dayCount); + void refresh(void); + void systemTime(void); + void localTime(void); + SYSTEMTIME &getSYSTEMTIME(void); + String toString(void)const; + String toStringShort(void)const; + void makeTime(WORD year,WORD month,WORD day,WORD hour,WORD minute,WORD second); +private: + enum{LongestDaysInMonth=31}; + void getMonth(String &monthString)const; + void getDay(String &dayString,bool shortName=false)const; +}; + +inline +SystemTime::SystemTime(void) +{ + refresh(); +} + +inline +SystemTime::SystemTime(const SystemTime &someSystemTime) +{ + *this=someSystemTime; +} + +inline +SystemTime::SystemTime(const SYSTEMTIME &someSYSTEMTIME) +{ + *this=someSYSTEMTIME; +} + +inline +SystemTime &SystemTime::operator=(const SYSTEMTIME &someSYSTEMTIME) +{ + ::memcpy(&getSYSTEMTIME(),&someSYSTEMTIME,sizeof(SYSTEMTIME)); + return *this; +} + +inline +SystemTime::SystemTime(WORD year,WORD month,WORD day,WORD hour,WORD minute,WORD second) +{ + makeTime(year,month,day,hour,minute,second); +} + +inline +SystemTime::SystemTime(const FileTime &someFileTime) +{ + *this=someFileTime; +} + +inline +SystemTime::~SystemTime() +{ +} + +inline +SystemTime &SystemTime::operator=(const SystemTime &someSystemTime) +{ + year(someSystemTime.year()); + month(someSystemTime.month()); + dayOfWeek(someSystemTime.dayOfWeek()); + day(someSystemTime.day()); + hour(someSystemTime.hour()); + minute(someSystemTime.minute()); + second(someSystemTime.second()); + milliseconds(someSystemTime.milliseconds()); + return *this; +} + +inline +SystemTime &SystemTime::operator=(const FileTime &someFileTime) +{ + ::FileTimeToSystemTime(&((FILETIME&)someFileTime),&((SYSTEMTIME&)*this)); + return *this; +} + +inline +bool SystemTime::operator==(const SystemTime &someSystemTime)const +{ + return (year()==someSystemTime.year()&& + month()==someSystemTime.month()&& + dayOfWeek()==someSystemTime.dayOfWeek()&& + day()==someSystemTime.day()&& + hour()==someSystemTime.hour()&& + minute()==someSystemTime.minute()&& + second()==someSystemTime.second()&& + milliseconds()==someSystemTime.milliseconds()); +} + +inline +bool SystemTime::operator>=(const SystemTime &someSystemTime)const +{ + if(*this>someSystemTime)return true; + return *this==someSystemTime; +} + +inline +WORD SystemTime::year(void)const +{ + return SYSTEMTIME::wYear; +} + +inline +void SystemTime::year(WORD year) +{ + SYSTEMTIME::wYear=year; +} + +inline +SystemTime::Month SystemTime::month(void)const +{ + return (Month)SYSTEMTIME::wMonth; +} + +inline +void SystemTime::month(Month month) +{ + SYSTEMTIME::wMonth=(WORD)month; +} + +inline +SystemTime::Day SystemTime::dayOfWeek(void)const +{ + return (Day)SYSTEMTIME::wDayOfWeek; +} + +inline +void SystemTime::dayOfWeek(Day dayOfWeek) +{ + SYSTEMTIME::wDayOfWeek=(WORD)dayOfWeek; +} + +inline +WORD SystemTime::day(void)const +{ + return SYSTEMTIME::wDay; +} + +inline +void SystemTime::day(WORD day) +{ + SYSTEMTIME::wDay=day; +} + +inline +WORD SystemTime::hour(void)const +{ + return SYSTEMTIME::wHour; +} + +inline +void SystemTime::hour(WORD hour) +{ + SYSTEMTIME::wHour=hour; +} + +inline +WORD SystemTime::minute(void)const +{ + return SYSTEMTIME::wMinute; +} + +inline +void SystemTime::minute(WORD minute) +{ + SYSTEMTIME::wMinute=minute; +} + +inline +WORD SystemTime::second(void)const +{ + return SYSTEMTIME::wSecond; +} + +inline +void SystemTime::second(WORD second) +{ + SYSTEMTIME::wSecond=second; +} + +inline +WORD SystemTime::milliseconds(void)const +{ + return SYSTEMTIME::wMilliseconds; +} + +inline +void SystemTime::milliseconds(WORD milliseconds) +{ + SYSTEMTIME::wMilliseconds=milliseconds; +} + +inline +void SystemTime::refresh(void) +{ + localTime(); +} + +inline +void SystemTime::systemTime(void) +{ + ::GetSystemTime(&((SYSTEMTIME&)*this)); +} + +inline +void SystemTime::localTime(void) +{ + ::GetLocalTime(&((SYSTEMTIME&)*this)); +} + +inline +SYSTEMTIME &SystemTime::getSYSTEMTIME(void) +{ + return *this; +} +#endif +#endif diff --git a/common/TIMER.HPP b/common/TIMER.HPP new file mode 100644 index 0000000..780fa57 --- /dev/null +++ b/common/TIMER.HPP @@ -0,0 +1,46 @@ +#ifndef _COMMON_TIMER_HPP_ +#define _COMMON_TIMER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class Timer +{ +public: + Timer(void); + virtual ~Timer(void); + void startTimer(LONG milliSeconds); + WORD hasExpired(void); +private: + long mStartTime; + long mStopTime; + WORD mHasExpired; +}; + +inline +Timer::Timer() +: mHasExpired(FALSE) +{ +} + +inline +Timer::~Timer() +{ +} + +inline +void Timer::startTimer(LONG milliSeconds) +{ + mStartTime=::GetTickCount(); + mStopTime=mStartTime+milliSeconds; +} + +inline +WORD Timer::hasExpired(void) +{ + if (mStopTime +#endif \ No newline at end of file diff --git a/common/TYPES.HPP b/common/TYPES.HPP new file mode 100644 index 0000000..2e389f4 --- /dev/null +++ b/common/TYPES.HPP @@ -0,0 +1,25 @@ +#ifndef _COMMON_TYPES_HPP_ +#define _COMMON_TYPES_HPP_ +typedef unsigned char UCHAR; +typedef char CHAR; +typedef unsigned short USHORT; +typedef short SHORT; +typedef short Index; +#if defined(__FLAT__) +#define CHUGE char +#define UHUGE unsigned char +#define LHUGE unsigned long +#else +#define CHUGE char huge +#define UHUGE unsigned char huge +#define LHUGE unsigned long huge +#endif +#ifndef HUGE +#if defined(__FLAT__) +#define HUGE FAR +#else +#define HUGE huge +#endif +#endif +#endif + diff --git a/common/Text1.txt b/common/Text1.txt new file mode 100644 index 0000000..1ac63a5 --- /dev/null +++ b/common/Text1.txt @@ -0,0 +1,3 @@ + + +class Connection \ No newline at end of file diff --git a/common/UCINFO.HPP b/common/UCINFO.HPP new file mode 100644 index 0000000..33f9f71 --- /dev/null +++ b/common/UCINFO.HPP @@ -0,0 +1,71 @@ +#ifndef _JDECODE_UNICODEINFO_HPP_ +#define _JDECODE_UNICODEINFO_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PUREVIEWOFFILE_HPP_ +#include +#endif +#ifndef _JDECODE_PUREINFO_HPP_ +#include +#endif + +class UnicodeInfo : public PureInfo +{ +public: + UnicodeInfo(); + virtual ~UnicodeInfo(); + PureViewOfFile &operator<<(PureViewOfFile &classView); + BYTE tag(void)const; + WORD length(void)const; + const Array &bytes(void)const; +private: + BYTE mTag; + WORD mLength; + Array mBytes; // mBytes.size(mLength); +}; + +inline +UnicodeInfo::UnicodeInfo() +: mTag(0), mLength(0) +{ +} + +inline +UnicodeInfo::~UnicodeInfo() +{ +} + +inline +PureViewOfFile &UnicodeInfo::operator<<(PureViewOfFile &classView) +{ + WORD wordItem; + classView.read(mTag); + classView.read(mLength); + mBytes.size(length()); + for(int itemIndex=0;itemIndex &UnicodeInfo::bytes(void)const +{ + return mBytes; +} +#endif \ No newline at end of file diff --git a/common/VARRAY.HPP b/common/VARRAY.HPP new file mode 100644 index 0000000..d7864e1 --- /dev/null +++ b/common/VARRAY.HPP @@ -0,0 +1,166 @@ +#ifndef _COMMON_VARARRAY_HPP_ +#define _COMMON_VARARRAY_HPP_ +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif + +template +class VarArray : public Array +{ +public: + enum{Granularity=64,InitialSize=Granularity}; + VarArray(DWORD initialSize=InitialSize,DWORD granularity=Granularity); + VarArray(const VarArray &someVarArray); + virtual ~VarArray(); + T &operator[](DWORD index); + VarArray &operator=(const VarArray &someVarArray); + BOOL operator==(const VarArray &someVarArray); + BOOL insert(const T &someItem); + DWORD granularity(void)const; + void granularity(DWORD granularity,BOOL clean=FALSE); + DWORD elements(void)const; + void reset(void); + void guarantee(DWORD elements); + void commit(DWORD elements); +private: + void elements(DWORD elements); + DWORD size(void)const; + void size(DWORD size); + + DWORD mGranularity; + DWORD mCacheEntries; +}; + +template +inline +VarArray::VarArray(DWORD initialSize,DWORD granularity) +: mGranularity(granularity), mCacheEntries(0) +{ + size(initialSize); +} + +template +inline +VarArray::VarArray(const VarArray &someVarArray) +{ + *this=cache +} + +template +inline +VarArray::~VarArray() +{ +} + +template +inline +T &VarArray::operator[](DWORD index) +{ + assert(index::operator[](index); +} + +template +inline +VarArray &VarArray::operator=(const VarArray &someVarArray) +{ + elements(someVarArray.elements()); + granularity(someVarArray.granularity()); + Array::size(someVarArray.size()); + for(int index=0;index::operator[](index)=((VarArray&)someVarArray)[index]; + return *this; +} + +template +inline +BOOL VarArray::operator==(const VarArray &someVarArray) +{ + for(int index=0;index::operator[](index)==someVarArray[index]))return FALSE; + return TRUE; +} + +template +inline +BOOL VarArray::insert(const T &someItem) +{ + if(elements()+1>Array::size()) + { + Array copyArray; + copyArray=(Array&)*this; + Array::size(Array::size()+granularity()); + for(int index=0;index::operator[](index)=copyArray[index]; + } + Array::operator[](elements())=someItem; + elements(elements()+1); + return TRUE; +} + +template +inline +DWORD VarArray::granularity(void)const +{ + return mGranularity; +} + +template +inline +void VarArray::granularity(DWORD granularity,BOOL clean) +{ + mGranularity=granularity; + if(!clean)return; + Array::size(VarArray::granularity()); + elements(0); +} + +template +inline +void VarArray::guarantee(DWORD elements) +{ + reset(); + if(elements::size())return; + Array::size(elements); +} + +template +inline +void VarArray::commit(DWORD elements) +{ + guarantee(elements); + this->elements(elements); +} + +template +inline +void VarArray::reset(void) +{ + elements(0); +} + +template +inline +DWORD VarArray::elements(void)const +{ + return mCacheEntries; +} + +template +inline +void VarArray::elements(DWORD elements) +{ + mCacheEntries=elements; +} + +template +inline +DWORD VarArray::size(void)const +{ // private implementation + return Array::size(); +} + +template +inline +void VarArray::size(DWORD size) +{ // private implementation + Array::size(size); +} +#endif \ No newline at end of file diff --git a/common/VECTOR.HPP b/common/VECTOR.HPP new file mode 100644 index 0000000..e99b2a9 --- /dev/null +++ b/common/VECTOR.HPP @@ -0,0 +1,123 @@ +#ifndef _COMMON_VECTOR_HPP_ +#define _COMMON_VECTOR_HPP_ +#ifndef _COMMON_MATH_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class Vector +{ +public: + Vector(void); + Vector(float x,float y,float z); + Vector(const Vector &someVector); + virtual ~Vector(); + float x(void)const; + float y(void)const; + float z(void)const; + void x(float x); + void y(float y); + void z(float z); + WORD operator==(const Vector &someVector)const; + Vector &operator=(const Vector &someVector); + Vector &operator-=(const Vector &someVector); + operator Point3D(void)const; +private: + float mx; + float my; + float mz; +}; + +inline +Vector::Vector(void) +: mx(0.00), my(0.00), mz(0.00) +{ +} + +inline +Vector::Vector(float x,float y,float z) +: mx(x), my(y), mz(z) +{ +} + +inline +Vector::Vector(const Vector &someVector) +: mx(someVector.mx), my(someVector.my), mz(someVector.mz) +{ +} + +inline +Vector::~Vector() +{ +} + +inline +float Vector::x(void)const +{ + return mx; +} + +inline +float Vector::y(void)const +{ + return my; +} + +inline +float Vector::z(void)const +{ + return mz; +} + +inline +void Vector::x(float newz) +{ + mx=newz; +} + +inline +void Vector::y(float newz) +{ + my=newz; +} + +inline +void Vector::z(float newz) +{ + mz=newz; +} + +inline +WORD Vector::operator==(const Vector &someVector)const +{ + return (mx==someVector.mx&& + my==someVector.my&& + mz==someVector.mz); +} + +inline +Vector &Vector::operator=(const Vector &someVector) +{ + mx=someVector.mx; + my=someVector.my; + mz=someVector.mz; + return *this; +} + +inline +Vector &Vector::operator-=(const Vector &someVector) +{ + mx-=someVector.mx; + my-=someVector.my; + mz-=someVector.mz; + return *this; +} + +inline +Vector::operator Point3D(void)const +{ + return Point3D(mx,my,mz); +} +#endif diff --git a/common/VECTOR2D.HPP b/common/VECTOR2D.HPP new file mode 100644 index 0000000..cc1f572 --- /dev/null +++ b/common/VECTOR2D.HPP @@ -0,0 +1,78 @@ +#ifndef _COMMON_VECTOR2D_HPP_ +#define _COMMON_VECTOR2D_HPP_ +#ifndef _COMMON_POINT_HPP_ +#include +#endif +#ifndef _COMMON_EXCEPTION_HPP_ +#include +#endif + +class Vector2D +{ +public: + enum {VectorPoints=4}; + Vector2D(void); + Vector2D(const Vector2D &someVector2D); + Vector2D(const Point &firstPoint,const Point &secondPoint,const Point &thirdPoint,const Point &fourthPoint); + ~Vector2D(); + Vector2D &operator=(const Vector2D &someVector2D); + WORD operator==(const Vector2D &someVector2D); + Point &operator[](WORD vectorIndex); +private: + Point mVector2D[VectorPoints]; +}; + +inline +Vector2D::Vector2D(void) +{ +} + +inline +Vector2D::Vector2D(const Vector2D &someVector2D) +{ + mVector2D[0]=((Vector2D&)someVector2D)[0]; + mVector2D[1]=((Vector2D&)someVector2D)[1]; + mVector2D[2]=((Vector2D&)someVector2D)[2]; + mVector2D[3]=((Vector2D&)someVector2D)[3]; +} + +inline +Vector2D::Vector2D(const Point &firstPoint,const Point &secondPoint,const Point &thirdPoint,const Point &fourthPoint) +{ + mVector2D[0]=firstPoint; + mVector2D[1]=secondPoint; + mVector2D[2]=thirdPoint; + mVector2D[3]=fourthPoint; +} + +inline +Vector2D::~Vector2D() +{ +} + +inline +Vector2D &Vector2D::operator=(const Vector2D &someVector2D) +{ + mVector2D[0]=((Vector2D&)someVector2D)[0]; + mVector2D[1]=((Vector2D&)someVector2D)[1]; + mVector2D[2]=((Vector2D&)someVector2D)[2]; + mVector2D[3]=((Vector2D&)someVector2D)[3]; + return *this; +} + +inline +WORD Vector2D::operator==(const Vector2D &someVector2D) +{ + return (mVector2D[0]==((Vector2D&)someVector2D)[0]&& + mVector2D[1]==((Vector2D&)someVector2D)[1]&& + mVector2D[2]==((Vector2D&)someVector2D)[2]&& + mVector2D[3]==((Vector2D&)someVector2D)[3]); +} + +inline +Point &Vector2D::operator[](WORD vectorIndex) +{ + if(vectorIndex>=VectorPoints)throw(BoundaryError()); + return mVector2D[vectorIndex]; +} +#endif \ No newline at end of file diff --git a/common/VERSION.HPP b/common/VERSION.HPP new file mode 100644 index 0000000..3d0ccb3 --- /dev/null +++ b/common/VERSION.HPP @@ -0,0 +1,113 @@ +#ifndef _COMMON_WINVERSIONINFO_HPP_ +#define _COMMON_WINVERSIONINFO_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class WinVersionInfo : private OSVERSIONINFO +{ +public: + enum Platform{PlatformWin32s=VER_PLATFORM_WIN32s,PlatformWin32Windows=VER_PLATFORM_WIN32_WINDOWS,PlatformWin32NT=VER_PLATFORM_WIN32_NT}; + WinVersionInfo(void); + virtual ~WinVersionInfo(); + DWORD majorVersion(void)const; + DWORD minorVersion(void)const; + DWORD buildNumber(void)const; + Platform platformID(void)const; + BOOL isWinNT(void)const; + BOOL isWin95(void)const; + String additionalInfo(void)const; +private: + WinVersionInfo(const WinVersionInfo &versionInfo); + WinVersionInfo &operator=(const WinVersionInfo &versionInfo); + void init(void); + void getVersionEx(void); +}; + +inline +WinVersionInfo::WinVersionInfo(void) +{ + init(); + getVersionEx(); +} + +inline +WinVersionInfo::WinVersionInfo(const WinVersionInfo &versionInfo) +{ // private implementation + *this=versionInfo; +} + +inline +WinVersionInfo::~WinVersionInfo() +{ +} + +inline +WinVersionInfo &WinVersionInfo::operator=(const WinVersionInfo &/*versionInfo*/) +{ // private implentation + return *this; +} + +inline +DWORD WinVersionInfo::majorVersion(void)const +{ + return OSVERSIONINFO::dwMajorVersion; +} + +inline +DWORD WinVersionInfo::minorVersion(void)const +{ + return OSVERSIONINFO::dwMinorVersion; +} + +inline +DWORD WinVersionInfo::buildNumber(void)const +{ + return OSVERSIONINFO::dwBuildNumber; +} + +inline +WinVersionInfo::Platform WinVersionInfo::platformID(void)const +{ + return Platform(OSVERSIONINFO::dwPlatformId); +} + +inline +BOOL WinVersionInfo::isWinNT(void)const +{ + return PlatformWin32NT==platformID(); +} + +inline +BOOL WinVersionInfo::isWin95(void)const +{ + return PlatformWin32Windows==platformID(); +} + +inline +String WinVersionInfo::additionalInfo(void)const +{ + if(OSVERSIONINFO::szCSDVersion&&*OSVERSIONINFO::szCSDVersion)return String(OSVERSIONINFO::szCSDVersion); + return String(); +} + +inline +void WinVersionInfo::init(void) +{ + OSVERSIONINFO::dwOSVersionInfoSize=sizeof(OSVERSIONINFO); + OSVERSIONINFO::dwMajorVersion=0; + OSVERSIONINFO::dwMinorVersion=0; + OSVERSIONINFO::dwBuildNumber=0; + OSVERSIONINFO::dwPlatformId=0; + OSVERSIONINFO::szCSDVersion[0]=0; +} + +inline +void WinVersionInfo::getVersionEx(void) +{ + ::GetVersionEx(&((OSVERSIONINFO&)*this)); +} +#endif \ No newline at end of file diff --git a/common/VFW.HPP b/common/VFW.HPP new file mode 100644 index 0000000..33ea56b --- /dev/null +++ b/common/VFW.HPP @@ -0,0 +1,14 @@ +#ifndef _COMMON_VFW_HPP_ +#define _COMMON_VFW_HPP_ +#define __inline inline +#if defined(WIN32) && !defined(_WIN32) +#define _WIN32 +#endif +#include + +// The dv.h file that distributes with dxsdk does not contain definition for DVINFO +#include // this is from dxsdk +#include +//#include +#endif + diff --git a/common/VHANDLER.CPP b/common/VHANDLER.CPP new file mode 100644 index 0000000..9a68684 --- /dev/null +++ b/common/VHANDLER.CPP @@ -0,0 +1,786 @@ +#include + +WORD VectorHandler::insertHandler(HandlerType handlerType,PureCallback *lpCallback,CallOrder callOrder) +{ + WORD returnCode; + + switch(handlerType) + { + case ChangeCBChainHandler : + returnCode=insert(mChangeCBChainVector,lpCallback,callOrder); + break; + case DrawClipboardHandler : + returnCode=insert(mDrawClipboardVector,lpCallback,callOrder); + break; + case UserHandler : + returnCode=insert(mUserVector,lpCallback,callOrder); + break; + case NCCreateHandler : + returnCode=insert(mNCCreateVector,lpCallback,callOrder); + break; + case CreateHandler : + returnCode=insert(mCreateVector,lpCallback,callOrder); + break; + case InitDialogHandler : + returnCode=insert(mInitDialogVector,lpCallback,callOrder); + break; + case SetFontHandler : + returnCode=insert(mSetFontVector,lpCallback,callOrder); + break; + case SizeHandler : + returnCode=insert(mSizeVector,lpCallback,callOrder); + break; + case PaintHandler : + returnCode=insert(mPaintVector,lpCallback,callOrder); + break; + case EraseBackgroundHandler : + returnCode=insert(mEraseBackgroundVector,lpCallback,callOrder); + break; + case PaletteChangedHandler : + returnCode=insert(mPaletteChangedVector,lpCallback,callOrder); + break; + case TimerHandler : + returnCode=insert(mTimerVector,lpCallback,callOrder)-1; + break; + case CharHandler : + returnCode=insert(mCharVector,lpCallback,callOrder); + break; + case CommandHandler : + returnCode=insert(mCommandVector,lpCallback,callOrder); + break; + case CompactingHandler : + returnCode=insert(mCompactingVector,lpCallback,callOrder); + break; + case WinIniChangeHandler : + returnCode=insert(mWinIniChangeVector,lpCallback,callOrder); + break; + case LeftButtonDoubleHandler : + returnCode=insert(mLeftButtonDoubleVector,lpCallback,callOrder); + break; + case LeftButtonDownHandler : + returnCode=insert(mLeftButtonDownVector,lpCallback,callOrder); + break; + case LeftButtonUpHandler : + returnCode=insert(mLeftButtonUpVector,lpCallback,callOrder); + break; + case RightButtonDoubleHandler : + returnCode=insert(mRightButtonDoubleVector,lpCallback,callOrder); + break; + case RightButtonDownHandler : + returnCode=insert(mRightButtonDownVector,lpCallback,callOrder); + break; + case RightButtonUpHandler : + returnCode=insert(mRightButtonUpVector,lpCallback,callOrder); + break; + case NCLeftButtonDownHandler : + returnCode=insert(mNCLeftButtonDownVector,lpCallback,callOrder); + break; + case NCLeftButtonUpHandler : + returnCode=insert(mNCLeftButtonUpVector,lpCallback,callOrder); + break; + case NCRightButtonDownHandler : + returnCode=insert(mNCRightButtonDownVector,lpCallback,callOrder); + break; + case NCRightButtonUpHandler : + returnCode=insert(mNCRightButtonUpVector,lpCallback,callOrder); + break; + case SetFocusHandler : + returnCode=insert(mSetFocusVector,lpCallback,callOrder); + break; + case KillFocusHandler : + returnCode=insert(mKillFocusVector,lpCallback,callOrder); + break; + case KeyUpHandler : + returnCode=insert(mKeyUpVector,lpCallback,callOrder); + break; + case KeyDownHandler : + returnCode=insert(mKeyDownVector,lpCallback,callOrder); + break; + case SysKeyDownHandler : + returnCode=insert(mSysKeyDownVector,lpCallback,callOrder); + break; + case SysKeyUpHandler : + returnCode=insert(mSysKeyUpVector,lpCallback,callOrder); + break; + case MinMaxHandler : + returnCode=insert(mMinMaxVector,lpCallback,callOrder); + break; + case EnterIdleHandler : + returnCode=insert(mEnterIdleVector,lpCallback,callOrder); + break; + case MenuSelectHandler : + returnCode=insert(mMenuSelectVector,lpCallback,callOrder); + break; + case DrawItemHandler : + returnCode=insert(mDrawItemVector,lpCallback,callOrder); + break; + case SysColorChangeHandler : + returnCode=insert(mSysColorChangeVector,lpCallback,callOrder); + break; + case CloseHandler : + returnCode=insert(mCloseVector,lpCallback,callOrder); + break; + case MouseMoveHandler : + returnCode=insert(mMouseMoveVector,lpCallback,callOrder); + break; + case ControlColorHandler : + returnCode=insert(mControlColorVector,lpCallback,callOrder); + break; + case NotifyHandler : + returnCode=insert(mNotifyVector,lpCallback,callOrder); + break; + case DDEInitiateHandler : + returnCode=insert(mDDEInitiateVector,lpCallback,callOrder); + break; + case DDEAckHandler : + returnCode=insert(mDDEAckVector,lpCallback,callOrder); + break; + case DDERequestHandler : + returnCode=insert(mDDERequestVector,lpCallback,callOrder); + break; + case DDETerminateHandler : + returnCode=insert(mDDETerminateVector,lpCallback,callOrder); + break; + case DDEDataHandler : + returnCode=insert(mDDEDataVector,lpCallback,callOrder); + break; + case MeasureItemHandler : + returnCode=insert(mMeasureItemVector,lpCallback,callOrder); + break; + case MMOpenHandler : + returnCode=insert(mMMOpenVector,lpCallback,callOrder); + break; + case MMCloseHandler : + returnCode=insert(mMMCloseVector,lpCallback,callOrder); + break; + case MMDoneHandler : + returnCode=insert(mMMDoneVector,lpCallback,callOrder); + break; + case DialogCodeHandler : + returnCode=insert(mDialogCodeVector,lpCallback,callOrder); + break; + case NCDestroyHandler : + returnCode=insert(mNCDestroyVector,lpCallback,callOrder); + break; + case DestroyHandler : + returnCode=insert(mDestroyVector,lpCallback,callOrder); + break; + case VerticalScrollHandler : + returnCode=insert(mVerticalScrollVector,lpCallback,callOrder); + break; + case HorizontalScrollHandler : + returnCode=insert(mHorizontalScrollVector,lpCallback,callOrder); + break; + case DropFilesHandler : + returnCode=insert(mDropFilesVector,lpCallback,callOrder); + break; + case MDIActivateHandler : + returnCode=insert(mMDIActivateVector,lpCallback,callOrder); + break; + case MDIDestroyHandler : + returnCode=insert(mMDIDestroyVector,lpCallback,callOrder); + break; + case QueryEndSessionHandler : + returnCode=insert(mQueryEndSessionVector,lpCallback,callOrder); + break; + case ActivateAppHandler : + returnCode=insert(mActivateAppVector,lpCallback,callOrder); + break; + case DisplayChangeHandler : + returnCode=insert(mDisplayChangeVector,lpCallback,callOrder); + break; + case ShowWindowHandler : + returnCode=insert(mShowWindowVector,lpCallback,callOrder); + break; + case CaptureChangedHandler : + returnCode=insert(mCaptureChangedVector,lpCallback,callOrder); + break; + case DeviceChangeHandler : + returnCode=insert(mDeviceChangeVector,lpCallback,callOrder); + } + return returnCode; +} + +CallbackData::ReturnType VectorHandler::callHandlers(HandlerType handlerType,CallbackData someCallbackData) +{ + CallbackData::ReturnType returnCode; + + switch(handlerType) + { + case ChangeCBChainHandler : + if(!handlers(mChangeCBChainVector))returnCode=TRUE; + else returnCode=callHandler(mChangeCBChainVector,someCallbackData); + break; + case DrawClipboardHandler : + if(!handlers(mDrawClipboardVector))returnCode=TRUE; + else returnCode=callHandler(mDrawClipboardVector,someCallbackData); + break; + case UserHandler : + if(!handlers(mUserVector))returnCode=TRUE; + else returnCode=callHandler(mUserVector,someCallbackData); + break; + case NCCreateHandler : + if(!handlers(mNCCreateVector))returnCode=TRUE; + else returnCode=callHandler(mNCCreateVector,someCallbackData); + break; + case CreateHandler : + returnCode=callHandler(mCreateVector,someCallbackData); + break; + case InitDialogHandler : + returnCode=callHandler(mInitDialogVector,someCallbackData); + break; + case SetFontHandler : + returnCode=callHandler(mSetFontVector,someCallbackData); + break; + case PaintHandler : + returnCode=callHandler(mPaintVector,someCallbackData); + break; + case EraseBackgroundHandler : + returnCode=callHandler(mEraseBackgroundVector,someCallbackData); + break; + case PaletteChangedHandler : + returnCode=callHandler(mPaletteChangedVector,someCallbackData); + break; + case TimerHandler : + returnCode=mTimerVector[someCallbackData.wParam()].callback(someCallbackData); + break; + case CharHandler : + returnCode=callHandler(mCharVector,someCallbackData); + break; + case SizeHandler : + returnCode=callHandler(mSizeVector,someCallbackData); + break; + case CommandHandler : + returnCode=callHandler(mCommandVector,someCallbackData); + break; + case CompactingHandler : + returnCode=callHandler(mCompactingVector,someCallbackData); + break; + case LeftButtonDoubleHandler : + returnCode=callHandler(mLeftButtonDoubleVector,someCallbackData); + break; + case LeftButtonDownHandler : + returnCode=callHandler(mLeftButtonDownVector,someCallbackData); + break; + case LeftButtonUpHandler : + returnCode=callHandler(mLeftButtonUpVector,someCallbackData); + break; + case RightButtonDoubleHandler : + returnCode=callHandler(mRightButtonDoubleVector,someCallbackData); + break; + case RightButtonUpHandler : + returnCode=callHandler(mRightButtonUpVector,someCallbackData); + break; + case RightButtonDownHandler : + returnCode=callHandler(mRightButtonDownVector,someCallbackData); + break; + case NCLeftButtonDownHandler : + returnCode=callHandler(mNCLeftButtonDownVector,someCallbackData); + break; + case NCLeftButtonUpHandler : + returnCode=callHandler(mNCLeftButtonUpVector,someCallbackData); + break; + case NCRightButtonDownHandler : + returnCode=callHandler(mNCRightButtonDownVector,someCallbackData); + break; + case NCRightButtonUpHandler : + returnCode=callHandler(mNCRightButtonUpVector,someCallbackData); + break; + case WinIniChangeHandler : + returnCode=callHandler(mWinIniChangeVector,someCallbackData); + break; + case SysColorChangeHandler : + returnCode=callHandler(mSysColorChangeVector,someCallbackData); + break; + case SetFocusHandler : + returnCode=callHandler(mSetFocusVector,someCallbackData); + break; + case KillFocusHandler : + returnCode=callHandler(mKillFocusVector,someCallbackData); + break; + case KeyUpHandler : + returnCode=callHandler(mKeyUpVector,someCallbackData); + break; + case KeyDownHandler : + returnCode=callHandler(mKeyDownVector,someCallbackData); + break; + case SysKeyDownHandler : + returnCode=callHandler(mSysKeyDownVector,someCallbackData); + break; + case SysKeyUpHandler : + returnCode=callHandler(mSysKeyUpVector,someCallbackData); + break; + case MinMaxHandler : + returnCode=callHandler(mMinMaxVector,someCallbackData); + break; + case EnterIdleHandler : + returnCode=callHandler(mEnterIdleVector,someCallbackData); + break; + case MenuSelectHandler : + returnCode=callHandler(mMenuSelectVector,someCallbackData); + break; + case DrawItemHandler : + returnCode=callHandler(mDrawItemVector,someCallbackData); + break; + case MouseMoveHandler : + returnCode=callHandler(mMouseMoveVector,someCallbackData); + break; + case ControlColorHandler : + returnCode=callHandler(mControlColorVector,someCallbackData); + break; + case NotifyHandler : + returnCode=callHandler(mNotifyVector,someCallbackData); + break; + case MeasureItemHandler : + returnCode=callHandler(mMeasureItemVector,someCallbackData); + break; + case DDEInitiateHandler : + returnCode=callHandler(mDDEInitiateVector,someCallbackData); + break; + case DDEAckHandler : + returnCode=callHandler(mDDEAckVector,someCallbackData); + break; + case DDERequestHandler : + returnCode=callHandler(mDDERequestVector,someCallbackData); + break; + case DDETerminateHandler : + returnCode=callHandler(mDDETerminateVector,someCallbackData); + break; + case DDEDataHandler : + returnCode=callHandler(mDDEDataVector,someCallbackData); + break; + case MMOpenHandler : + returnCode=callHandler(mMMOpenVector,someCallbackData); + break; + case MMCloseHandler : + returnCode=callHandler(mMMCloseVector,someCallbackData); + break; + case MMDoneHandler : + returnCode=callHandler(mMMDoneVector,someCallbackData); + break; + case CloseHandler : + returnCode=callHandler(mCloseVector,someCallbackData); + break; + case DialogCodeHandler : + returnCode=callHandler(mDialogCodeVector,someCallbackData); + break; + case DestroyHandler : + returnCode=callHandler(mDestroyVector,someCallbackData); + break; + case NCDestroyHandler : + returnCode=callHandler(mNCDestroyVector,someCallbackData); + break; + case HorizontalScrollHandler : + returnCode=callHandler(mHorizontalScrollVector,someCallbackData); + break; + case VerticalScrollHandler : + returnCode=callHandler(mVerticalScrollVector,someCallbackData); + break; + case DropFilesHandler : + returnCode=callHandler(mDropFilesVector,someCallbackData); + break; + case MDIActivateHandler : + returnCode=callHandler(mMDIActivateVector,someCallbackData); + break; + case MDIDestroyHandler : + returnCode=callHandler(mMDIDestroyVector,someCallbackData); + break; + case QueryEndSessionHandler : + returnCode=callHandler(mQueryEndSessionVector,someCallbackData); + break; + case ActivateAppHandler : + returnCode=callHandler(mActivateAppVector,someCallbackData); + break; + case DisplayChangeHandler : + returnCode=callHandler(mDisplayChangeVector,someCallbackData); + break; + case ShowWindowHandler : + returnCode=callHandler(mShowWindowVector,someCallbackData); + break; + case CaptureChangedHandler : + returnCode=callHandler(mCaptureChangedVector,someCallbackData); + break; + case DeviceChangeHandler : + returnCode=callHandler(mDeviceChangeVector,someCallbackData); + } + return returnCode; +} + +CallbackData::ReturnType VectorHandler::callHandler(Block &someCallbackVector,CallbackData &someCallbackData) +{ + size_t size((size_t)someCallbackVector.size()); + CallbackData::ReturnType returnCode(0); + CallbackData::ReturnType callReturn; + + for(int vectorIndex=0;vectorIndex &someCallbackVector,CallbackPointer &locatePointer) +{ + size_t size((size_t)someCallbackVector.size()); + + for(int vectorIndex=0;vectorIndex &someHandlerBlock,PureCallback *lpCallback,CallOrder callOrder) +{ + if(FirstHandler==callOrder&&someHandlerBlock.size()) + { + CallbackPointer firstCallback(someHandlerBlock[0]); + someHandlerBlock[0]=CallbackPointer(lpCallback); + someHandlerBlock.insert(&firstCallback); + } + else someHandlerBlock.insert(&CallbackPointer(lpCallback)); + return (WORD)someHandlerBlock.size(); +} + diff --git a/common/VHANDLER.HPP b/common/VHANDLER.HPP new file mode 100644 index 0000000..63281d3 --- /dev/null +++ b/common/VHANDLER.HPP @@ -0,0 +1,128 @@ +#ifndef _COMMON_VECTORHANDLER_HPP_ +#define _COMMON_VECTORHANDLER_HPP_ +#ifndef _COMMON_CALLBACK_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif + +class VectorHandler +{ +public: + enum CallOrder{FirstHandler,NormalHandler}; + enum HandlerType {NCCreateHandler,CreateHandler,InitDialogHandler,SizeHandler,PaintHandler, + EraseBackgroundHandler,CommandHandler,TimerHandler,CompactingHandler,WinIniChangeHandler, + SetFontHandler,SysColorChangeHandler,LeftButtonDoubleHandler,SetFocusHandler,KillFocusHandler, + KeyUpHandler,KeyDownHandler,SysKeyDownHandler,SysKeyUpHandler,MinMaxHandler,EnterIdleHandler, + MenuSelectHandler,DrawItemHandler,CloseHandler,CharHandler,LeftButtonDownHandler,LeftButtonUpHandler, + RightButtonDoubleHandler,RightButtonDownHandler,RightButtonUpHandler,NCLeftButtonDownHandler, + NCLeftButtonUpHandler,NCRightButtonDownHandler,NCRightButtonUpHandler,MouseMoveHandler, + ControlColorHandler,DDEInitiateHandler,DDEAckHandler,DDERequestHandler,DDETerminateHandler, + DDEDataHandler,MMOpenHandler,MMCloseHandler,MMDoneHandler,NCDestroyHandler,DestroyHandler, + NotifyHandler,DialogCodeHandler,MeasureItemHandler,HorizontalScrollHandler,VerticalScrollHandler, + DropFilesHandler,PaletteChangedHandler,MDIActivateHandler,MDIDestroyHandler,QueryEndSessionHandler, + UserHandler,ChangeCBChainHandler,DrawClipboardHandler,ActivateAppHandler,DisplayChangeHandler, + ShowWindowHandler,CaptureChangedHandler,DeviceChangeHandler}; + VectorHandler(void); + virtual ~VectorHandler(); + WORD insertHandler(HandlerType handlerType,PureCallback *lpCallback,CallOrder callOrder=NormalHandler); + void removeHandler(HandlerType handlerType,PureCallback *lpCallback); + CallbackData::ReturnType callHandlers(HandlerType handlerType,CallbackData someCallbackData); +protected: + WORD isValidHandler(HandlerType handlerType,int vectorIndex)const; + WORD installedHandlers(HandlerType handlerType)const; +private: + CallbackData::ReturnType callHandler(Block &someCallbackVector,CallbackData &someCallbackData); + void removeHandler(Block &someCallbackVector,CallbackPointer &locatePointer); + WORD handlers(Block &someCallbackVector)const; + WORD insert(Block &someHandlerBlock,PureCallback *lpCallback,CallOrder callOrder); + + Block mNCCreateVector; + Block mCreateVector; + Block mInitDialogVector; + Block mSizeVector; + Block mPaintVector; + Block mCommandVector; + Block mCompactingVector; + Block mWinIniChangeVector; + Block mSysColorChangeVector; + Block mLeftButtonDoubleVector; + Block mLeftButtonDownVector; + Block mLeftButtonUpVector; + Block mNCLeftButtonDownVector; + Block mNCLeftButtonUpVector; + Block mNCRightButtonDownVector; + Block mNCRightButtonUpVector; + Block mRightButtonDoubleVector; + Block mRightButtonDownVector; + Block mRightButtonUpVector; + Block mTimerVector; + Block mSetFocusVector; + Block mKillFocusVector; + Block mKeyUpVector; + Block mKeyDownVector; + Block mSysKeyDownVector; + Block mSysKeyUpVector; + Block mMinMaxVector; + Block mEnterIdleVector; + Block mMenuSelectVector; + Block mDrawItemVector; + Block mCloseVector; + Block mCharVector; + Block mMouseMoveVector; + Block mNCDestroyVector; + Block mDestroyVector; + Block mControlColorVector; + Block mNotifyVector; + Block mDDEInitiateVector; + Block mDDEAckVector; + Block mDDERequestVector; + Block mDDETerminateVector; + Block mDDEDataVector; + Block mMMOpenVector; + Block mMMCloseVector; + Block mMMDoneVector; + Block mDialogCodeVector; + Block mSetFontVector; + Block mMeasureItemVector; + Block mVerticalScrollVector; + Block mHorizontalScrollVector; + Block mEraseBackgroundVector; + Block mDropFilesVector; + Block mPaletteChangedVector; + Block mMDIActivateVector; + Block mMDIDestroyVector; + Block mQueryEndSessionVector; + Block mUserVector; + Block mChangeCBChainVector; + Block mDrawClipboardVector; + Block mActivateAppVector; + Block mDisplayChangeVector; + Block mShowWindowVector; + Block mCaptureChangedVector; + Block mDeviceChangeVector; +}; + +inline +VectorHandler::VectorHandler(void) +{ +} + +inline +VectorHandler::~VectorHandler() +{ +} + +inline +WORD VectorHandler::handlers(Block &someCallbackVector)const +{ + return (WORD)someCallbackVector.size(); +} + +inline +WORD VectorHandler::isValidHandler(HandlerType handlerType,int vectorIndex)const +{ + return (vectorIndex +#endif + +class VirtualKey +{ +public: + enum KeyType{UpArrow=0x26,DownArrow=0x28,RightArrow=0x27,LeftArrow=0x25, + PageDown=0x22,PageUp=0x21,Home=0x24,End=0x23}; + VirtualKey(void); + VirtualKey(const VirtualKey &someVirtulKey); + VirtualKey(WORD virtualKey,LPARAM keyData=0L); + VirtualKey(KeyType keyType,LPARAM keyData=0L); + virtual ~VirtualKey(); + VirtualKey &operator=(const VirtualKey &someVirtualKey); + WORD operator==(const VirtualKey &someVirtualKey); + KeyType keyType(void)const; + short virtualKey(void)const; + short repeatCount(void)const; + short scanCode(void)const; + short isExtendedKey(void)const; + short contextCode(void)const; + short prevKeyState(void)const; + short transitionState(void)const; +private: + void virtualKey(short virtualKey); + void repeatCount(short repeatCount); + void scanCode(short scanCode); + void isExtendedKey(short isExtendedKey); + void contextCode(short contextCode); + void prevKeyState(short prevKeyState); + void transitionState(short transitionState); + void setKeyData(LPARAM keyData); + short mVirtualKey; + short mRepeatCount; + short mScanCode; + short mIsExtendedKey; + short mContextCode; + short mPrevKeyState; + short mTransitionState; +}; + +inline +VirtualKey::VirtualKey(void) +: mVirtualKey(0), mRepeatCount(0), mScanCode(0), mIsExtendedKey(FALSE), mContextCode(0), + mPrevKeyState(0), mTransitionState(0) +{ +} + +inline +VirtualKey::VirtualKey(const VirtualKey &someVirtualKey) +{ + *this=someVirtualKey; +} + +inline +VirtualKey::VirtualKey(WORD virtualKeyCode,LPARAM keyData) +{ + virtualKey(virtualKeyCode); + setKeyData(keyData); +} + +inline +VirtualKey::VirtualKey(KeyType keyType,LPARAM keyData) +{ + virtualKey((short)keyType); + setKeyData(keyData); +} + +inline +VirtualKey::~VirtualKey() +{ +} + +inline +VirtualKey &VirtualKey::operator=(const VirtualKey &someVirtualKey) +{ + virtualKey(someVirtualKey.virtualKey()); + repeatCount(someVirtualKey.repeatCount()); + scanCode(someVirtualKey.scanCode()); + isExtendedKey(someVirtualKey.isExtendedKey()); + contextCode(someVirtualKey.contextCode()); + prevKeyState(someVirtualKey.prevKeyState()); + transitionState(someVirtualKey.transitionState()); + return *this; +} + +inline +WORD VirtualKey::operator==(const VirtualKey &someVirtualKey) +{ + return (virtualKey()==someVirtualKey.virtualKey()&& + repeatCount()==someVirtualKey.repeatCount()&& + scanCode()==someVirtualKey.scanCode()&& + isExtendedKey()==someVirtualKey.isExtendedKey()&& + prevKeyState()==someVirtualKey.prevKeyState()&& + transitionState()==someVirtualKey.transitionState()); +} + +inline +void VirtualKey::setKeyData(LPARAM keyData) +{ + repeatCount(LOWORD(keyData)); + scanCode((keyData>>0x10)&0x80); + isExtendedKey((keyData>>0x18)&0x01); + contextCode((keyData>>0x1D)&0x01); + prevKeyState((keyData>>0x1E)&0x01); + transitionState((keyData>>0x1F)&0x01); +} + +inline +VirtualKey::KeyType VirtualKey::keyType(void)const +{ + return (KeyType)mVirtualKey; +} + +inline +short VirtualKey::virtualKey(void)const +{ + return mVirtualKey; +} + +inline +short VirtualKey::repeatCount(void)const +{ + return mRepeatCount; +} + +inline +short VirtualKey::scanCode(void)const +{ + return mScanCode; +} + +inline +short VirtualKey::isExtendedKey(void)const +{ + return mIsExtendedKey; +} + +inline +short VirtualKey::contextCode(void)const +{ + return mContextCode; +} + +inline +short VirtualKey::prevKeyState(void)const +{ + return mPrevKeyState; +} + +inline +short VirtualKey::transitionState(void)const +{ + return mTransitionState; +} + +inline +void VirtualKey::virtualKey(short virtualKey) +{ + mVirtualKey=virtualKey; +} + +inline +void VirtualKey::repeatCount(short repeatCount) +{ + mRepeatCount=repeatCount; +} + +inline +void VirtualKey::scanCode(short scanCode) +{ + mScanCode=scanCode; +} + +inline +void VirtualKey::isExtendedKey(short isExtendedKey) +{ + mIsExtendedKey=isExtendedKey; +} + +inline +void VirtualKey::contextCode(short contextCode) +{ + mContextCode=contextCode; +} + +inline +void VirtualKey::prevKeyState(short prevKeyState) +{ + mPrevKeyState=prevKeyState; +} + +inline +void VirtualKey::transitionState(short transitionState) +{ + mTransitionState=transitionState; +} +#endif diff --git a/common/VXDCTRL.CPP b/common/VXDCTRL.CPP new file mode 100644 index 0000000..22030bf --- /dev/null +++ b/common/VXDCTRL.CPP @@ -0,0 +1,15 @@ +#include +#include + +VxDControl::VxDControl(const String &pathFileName) +{ + WinVersionInfo versionInfo; + if(versionInfo.isWinNT())open(pathFileName,FileHandle::ReadWrite,FileHandle::ShareReadWrite,FileHandle::Open,FileHandle::Normal); + else open(pathFileName,FileHandle::Query,FileHandle::ShareNone,FileHandle::Create,FileHandle::FlagDeleteOnClose); +} + +VxDControl::~VxDControl() +{ +} + + diff --git a/common/VXDCTRL.HPP b/common/VXDCTRL.HPP new file mode 100644 index 0000000..759f35a --- /dev/null +++ b/common/VXDCTRL.HPP @@ -0,0 +1,20 @@ +#ifndef _COMMON_VXDCONTROL_HPP_ +#define _COMMON_VXDCONTROL_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_OPENFILE_HPP_ +#include +#endif + +class VxDControl : public FileHandle +{ +public: + VxDControl(const String &pathFileName); + virtual ~VxDControl(); +private: +}; +#endif diff --git a/common/WAVEFRMX.HPP b/common/WAVEFRMX.HPP new file mode 100644 index 0000000..6e57e92 --- /dev/null +++ b/common/WAVEFRMX.HPP @@ -0,0 +1,166 @@ +#ifndef _COMMON_WAVEFORMATEX_HPP_ +#define _COMMON_WAVEFORMATEX_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_MMSYSTEM_HPP_ +#include +#endif + +class WaveFormatEx : private tWAVEFORMATEX +{ +public: + WaveFormatEx(void); + WaveFormatEx(const WaveFormatEx &someWaveFormatEx); + ~WaveFormatEx(); + WaveFormatEx &operator=(const WaveFormatEx &someWaveFormatEx); + WORD operator==(const WaveFormatEx &someWaveFormatEx)const; + WORD formatTag(void)const; + void formatTag(WORD formatTag); + WORD channels(void)const; + void channels(WORD channels); + DWORD samplesPerSecond(void)const; + void samplesPerSecond(WORD samplesPerSecond); + DWORD averageBytesPerSecond(void)const; + void averageBytesPerSecond(WORD averageBytesPerSecond); + WORD blockAlign(void)const; + void blockAlign(WORD blockAlign); + WORD bitsPerSample(void)const; + void bitsPerSample(WORD bitsPerSample); + WORD size(void)const; + void size(WORD size); +private: +}; + +inline +WaveFormatEx::WaveFormatEx(void) +{ + tWAVEFORMATEX::wFormatTag=0; + tWAVEFORMATEX::nChannels=0; + tWAVEFORMATEX::nSamplesPerSec=0; + tWAVEFORMATEX::nAvgBytesPerSec=0; + tWAVEFORMATEX::nBlockAlign=0; + tWAVEFORMATEX::wBitsPerSample=0; + tWAVEFORMATEX::cbSize=0; +} + +inline +WaveFormatEx::WaveFormatEx(const WaveFormatEx &someWaveFormatEx) +{ + *this=someWaveFormatEx; +} + +inline +WaveFormatEx::~WaveFormatEx() +{ +} + +inline +WaveFormatEx &WaveFormatEx::operator=(const WaveFormatEx &someWaveFormatEx) +{ + formatTag(someWaveFormatEx.formatTag()); + channels(someWaveFormatEx.channels()); + samplesPerSecond(someWaveFormatEx.samplesPerSecond()); + averageBytesPerSecond(someWaveFormatEx.averageBytesPerSecond()); + blockAlign(someWaveFormatEx.blockAlign()); + bitsPerSample(someWaveFormatEx.bitsPerSample()); + size(someWaveFormatEx.size()); + return *this; +} + +inline +WORD WaveFormatEx::operator==(const WaveFormatEx &someWaveFormatEx)const +{ + return (formatTag()==someWaveFormatEx.formatTag()&& + channels()==someWaveFormatEx.channels()&& + samplesPerSecond()==someWaveFormatEx.samplesPerSecond()&& + averageBytesPerSecond()==someWaveFormatEx.averageBytesPerSecond()&& + blockAlign()==someWaveFormatEx.blockAlign()&& + bitsPerSample()==someWaveFormatEx.bitsPerSample()&& + size()==someWaveFormatEx.size()); +} + +inline +WORD WaveFormatEx::formatTag(void)const +{ + return tWAVEFORMATEX::wFormatTag; +} + +inline +void WaveFormatEx::formatTag(WORD formatTag) +{ + tWAVEFORMATEX::wFormatTag=formatTag; +} + +inline +WORD WaveFormatEx::channels(void)const +{ + return tWAVEFORMATEX::nChannels; +} + +inline +void WaveFormatEx::channels(WORD channels) +{ + tWAVEFORMATEX::nChannels=channels; +} + +inline +DWORD WaveFormatEx::samplesPerSecond(void)const +{ + return tWAVEFORMATEX::nSamplesPerSec; +} + +inline +void WaveFormatEx::samplesPerSecond(WORD samplesPerSecond) +{ + tWAVEFORMATEX::nSamplesPerSec=samplesPerSecond; +} + +inline +DWORD WaveFormatEx::averageBytesPerSecond(void)const +{ + return tWAVEFORMATEX::nAvgBytesPerSec; +} + +inline +void WaveFormatEx::averageBytesPerSecond(WORD averageBytesPerSecond) +{ + tWAVEFORMATEX::nAvgBytesPerSec=averageBytesPerSecond; +} + +inline +WORD WaveFormatEx::blockAlign(void)const +{ + return tWAVEFORMATEX::nBlockAlign; +} + +inline +void WaveFormatEx::blockAlign(WORD blockAlign) +{ + tWAVEFORMATEX::nBlockAlign=blockAlign; +} + +inline +WORD WaveFormatEx::bitsPerSample(void)const +{ + return tWAVEFORMATEX::wBitsPerSample; +} + +inline +void WaveFormatEx::bitsPerSample(WORD bitsPerSample) +{ + tWAVEFORMATEX::wBitsPerSample=bitsPerSample; +} + +inline +WORD WaveFormatEx::size(void)const +{ + return tWAVEFORMATEX::cbSize; +} + +inline +void WaveFormatEx::size(WORD size) +{ + tWAVEFORMATEX::cbSize=size; +} +#endif diff --git a/common/WINBASE.HPP b/common/WINBASE.HPP new file mode 100644 index 0000000..8d4fb49 --- /dev/null +++ b/common/WINBASE.HPP @@ -0,0 +1,5 @@ +#ifndef _COMMON_WINBASE_HPP_ +#define _COMMON_WINBASE_HPP_ +#include +#endif + \ No newline at end of file diff --git a/common/WINDOW.CPP b/common/WINDOW.CPP new file mode 100644 index 0000000..4f0da42 --- /dev/null +++ b/common/WINDOW.CPP @@ -0,0 +1,224 @@ +#include +#include +#include +#include + +int Window::windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam) +{ + if(message>=WM_USER&&message<=0x7FFF) + { + if(!installedHandlers(VectorHandler::UserHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::UserHandler,CallbackData(message,lParam,hWnd)); + } + switch(message) + { + case WM_NCCREATE : + if(!installedHandlers(VectorHandler::NCCreateHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCCreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CREATE : + if(!installedHandlers(VectorHandler::CreateHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CreateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CLOSE : + if(!installedHandlers(VectorHandler::CloseHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CloseHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHANGECBCHAIN : + if(!installedHandlers(VectorHandler::ChangeCBChainHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ChangeCBChainHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWCLIPBOARD : + if(!installedHandlers(VectorHandler::DrawClipboardHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawClipboardHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PAINT : + if(!installedHandlers(VectorHandler::PaintHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return handlePaintMessage(hWnd,message,wParam,lParam); + case WM_ERASEBKGND : + if(!installedHandlers(VectorHandler::EraseBackgroundHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EraseBackgroundHandler,CallbackData(wParam,lParam,hWnd)); + case WM_PALETTECHANGED : + if(!installedHandlers(VectorHandler::PaletteChangedHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::PaletteChangedHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DRAWITEM : + if(!installedHandlers(VectorHandler::DrawItemHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DrawItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_TIMER : + if(!installedHandlers(VectorHandler::TimerHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::TimerHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CHAR : + if(!installedHandlers(VectorHandler::CharHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CharHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMMAND : + if(!installedHandlers(VectorHandler::CommandHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CommandHandler,CallbackData(wParam,lParam,hWnd)); + case WM_COMPACTING : + if(!installedHandlers(VectorHandler::CompactingHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CompactingHandler,CallbackData(wParam,lParam,hWnd)); + case WM_WININICHANGE : + if(!installedHandlers(VectorHandler::WinIniChangeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::WinIniChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SYSCOLORCHANGE : + if(!installedHandlers(VectorHandler::SysColorChangeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SysColorChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORMSGBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLOREDIT : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORLISTBOX : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORBTN : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORDLG : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSCROLLBAR : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CTLCOLORSTATIC : + if(!installedHandlers(VectorHandler::ControlColorHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ControlColorHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_INITIATE : + if(!installedHandlers(VectorHandler::DDEInitiateHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEInitiateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_ACK : + if(!installedHandlers(VectorHandler::DDEAckHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEAckHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_REQUEST : + if(!installedHandlers(VectorHandler::DDERequestHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDERequestHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_TERMINATE : + if(!installedHandlers(VectorHandler::DDETerminateHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDETerminateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DDE_DATA : + if(!installedHandlers(VectorHandler::DDEDataHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DDEDataHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_OPEN : + if(!installedHandlers(VectorHandler::MMOpenHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMOpenHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_CLOSE : + if(!installedHandlers(VectorHandler::MMCloseHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMCloseHandler,CallbackData(wParam,lParam,hWnd)); + case MM_WOM_DONE : + if(!installedHandlers(VectorHandler::MMDoneHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MMDoneHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::LeftButtonDoubleHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONDOWN : + if(!installedHandlers(VectorHandler::LeftButtonDownHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_LBUTTONUP : + if(!installedHandlers(VectorHandler::LeftButtonUpHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::LeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDBLCLK : + if(!installedHandlers(VectorHandler::RightButtonDoubleHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDoubleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONDOWN : + if(!installedHandlers(VectorHandler::RightButtonDownHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_RBUTTONUP : + if(!installedHandlers(VectorHandler::RightButtonUpHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::RightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONUP : + if(!installedHandlers(VectorHandler::NCLeftButtonUpHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCLBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCLeftButtonDownHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCLeftButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONUP : + if(!installedHandlers(VectorHandler::NCRightButtonUpHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCRBUTTONDOWN : + if(!installedHandlers(VectorHandler::NCRightButtonDownHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NCRightButtonDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MOUSEMOVE : + if(!installedHandlers(VectorHandler::MouseMoveHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MouseMoveHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFOCUS : + if(!installedHandlers(VectorHandler::SetFocusHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SETFONT : + if(!installedHandlers(VectorHandler::SetFontHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SetFontHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KILLFOCUS : + if(!installedHandlers(VectorHandler::KillFocusHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KillFocusHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYUP : + if(!installedHandlers(VectorHandler::KeyUpHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyUpHandler,CallbackData(wParam,lParam,hWnd)); + case WM_KEYDOWN : + if(!installedHandlers(VectorHandler::KeyDownHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::KeyDownHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETMINMAXINFO : + if(!installedHandlers(VectorHandler::MinMaxHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MinMaxHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ENTERIDLE : + if(!installedHandlers(VectorHandler::EnterIdleHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::EnterIdleHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MENUSELECT : + if(!installedHandlers(VectorHandler::MenuSelectHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MenuSelectHandler,CallbackData(wParam,lParam,hWnd)); + case WM_GETDLGCODE : + if(!installedHandlers(VectorHandler::DialogCodeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DialogCodeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MEASUREITEM : + if(!installedHandlers(VectorHandler::MeasureItemHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MeasureItemHandler,CallbackData(wParam,lParam,hWnd)); + case WM_VSCROLL : + if(!installedHandlers(VectorHandler::VerticalScrollHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::VerticalScrollHandler,CallbackData(wParam,lParam,hWnd)); + case WM_HSCROLL : + if(!installedHandlers(VectorHandler::HorizontalScrollHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::HorizontalScrollHandler,CallbackData(wParam,lParam,hWnd)); +#if defined(__FLAT__) + case WM_NOTIFY : + if(!installedHandlers(VectorHandler::NotifyHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::NotifyHandler,CallbackData(wParam,lParam,hWnd)); +#endif + case WM_SIZE : + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::SizeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DROPFILES : + if(!installedHandlers(VectorHandler::DropFilesHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DropFilesHandler,CallbackData(wParam,lParam,hWnd)); + case WM_ACTIVATEAPP : + if(!installedHandlers(VectorHandler::ActivateAppHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ActivateAppHandler,CallbackData(wParam,lParam,hWnd)); + break; + case WM_DISPLAYCHANGE : + if(!installedHandlers(VectorHandler::DisplayChangeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DisplayChangeHandler,CallbackData(wParam,lParam,hWnd)); + break; + case WM_DESTROY : + callHandlers(VectorHandler::DestroyHandler,CallbackData(wParam,lParam,hWnd)); + InstanceData::removeInstanceData(hWnd); + setHandle(0); + if(!installedHandlers(VectorHandler::SizeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return FALSE; + case WM_MDIACTIVATE : + if(!installedHandlers(VectorHandler::MDIActivateHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MDIActivateHandler,CallbackData(wParam,lParam,hWnd)); + case WM_MDIDESTROY : + if(!installedHandlers(VectorHandler::MDIDestroyHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::MDIDestroyHandler,CallbackData(wParam,lParam,hWnd)); + case WM_QUERYENDSESSION : + if(!installedHandlers(VectorHandler::QueryEndSessionHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::QueryEndSessionHandler,CallbackData(wParam,lParam,hWnd)); + case WM_SHOWWINDOW : + if(!installedHandlers(VectorHandler::ShowWindowHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::ShowWindowHandler,CallbackData(wParam,lParam,hWnd)); + case WM_CAPTURECHANGED : + if(!installedHandlers(VectorHandler::CaptureChangedHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::CaptureChangedHandler,CallbackData(wParam,lParam,hWnd)); + case WM_DEVICECHANGE : + if(!installedHandlers(VectorHandler::DeviceChangeHandler))return ::DefWindowProc(hWnd,message,wParam,lParam); + return callHandlers(VectorHandler::DeviceChangeHandler,CallbackData(wParam,lParam,hWnd)); + case WM_NCDESTROY : + default : + return ::DefWindowProc(hWnd,message,wParam,lParam); + } +} diff --git a/common/WINDOW.HPP b/common/WINDOW.HPP new file mode 100644 index 0000000..a361b09 --- /dev/null +++ b/common/WINDOW.HPP @@ -0,0 +1,48 @@ +#ifndef _COMMON_WINDOW_HPP_ +#define _COMMON_WINDOW_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_GUIWINDOW_HPP_ +#include +#endif + +class Window : public GUIWindow +{ +public: + Window(void); + virtual ~Window(); +protected: + virtual int windowProcedure(HWND hWnd,WORD message,WPARAM wParam,LPARAM lParam); +private: + Window(HWND hWnd); + Window(const Window &someWindow); + Window &operator=(const Window &someWindow); +}; + +inline +Window::Window(void) +{ +} + +inline +Window::Window(HWND /*hWnd*/) +{ // private implementation +} + +inline +Window::Window(const Window &/*someWindow*/) +{ // private implementation +} + +inline +Window::~Window() +{ +} + +inline +Window &Window::operator=(const Window &/*someWindow*/) +{ // private implementation + return *this; +} +#endif diff --git a/common/WINDOWS.INC b/common/WINDOWS.INC new file mode 100644 index 0000000..fa734ab --- /dev/null +++ b/common/WINDOWS.INC @@ -0,0 +1,75 @@ +; ************************************************************************** +; FILE:WINDOWS.INC +; FUNCTION: SUBSET OF WINDOWS.INC FROM BORLAND +; AUTHOR: SEAN M. KESSLER +;**************************************************************************** +BITMAPINFOHEADER STRUC +PBITMAPINFOHEADER TYPEDEF FAR PTR BITMAPINFOHEADER + BITMAPINFOHEADER@@mBiSize DD ? + BITMAPINFOHEADER@@mBiWidth DD ? + BITMAPINFOHEADER@@mBiHeight DD ? + BITMAPINFOHEADER@@mBiPlanes DW ? + BITMAPINFOHEADER@@mBiBitCount DW ? + BITMAPINFOHEADER@@mBiCompression DD ? + BITMAPINFOHEADER@@mBiSizeImage DD ? + BITMAPINFOHEADER@@mBiXPelsPerMeter DD ? + BITMAPINFOHEADER@@mBiYPelsPerMeter DD ? + BITMAPINFOHEADER@@mBiClrUsed DD ? + BITMAPINFOHEADER@@mBiClrImportant DD ? +BITMAPINFOHEADER ENDS + +BITMAPFILEHEADER STRUC +PBITMAPFILEHEADER TYPEDEF FAR PTR BITMAPFILEHEADER + BITMAPFILEHEADER@@mBfType DW ? + BITMAPFILEHEADER@@mBfSize DD ? + BITMAPFILEHEADER@@mBfReserved1 DW ? + BITMAPFILEHEADER@@mBfReserved2 DW ? + BITMAPFILEHEADER@@mBfOffBits DD ? +BITMAPFILEHEADER ENDS + +RGBQUAD STRUC +PRGBQUAD TYPEDEF FAR PTR RGBQUAD + RGBQUAD@@mBlue DB ? + RGBQuad@@mGreen DB ? + RGBQuad@@mRed DB ? + RGBQuad@@mReserved DB ? +RGBQUAD ENDS + +BITMAPINFO STRUC +PBITMAPINFO TYPEDEF FAR PTR BITMAPINFO + BITMAPINFO@@mBitmapInfoHeader BITMAPINFOHEADER <> + BITMAPINFO@@mRGBQuad RGBQUAD <> +BITMAPINFO ENDS + +PALETTEENTRY STRUC +PPALETTEENTRY TYPEDEF FAR PTR PALETTEENTRY + PALETTEENTRY@@mPeRed DB ? + PALETTEENTRY@@mPeGreen DB ? + PALETTEENTRY@@mPeBlue DB ? + PALETTEENTRY@@mPeFlags DB ? +PALETTEENTRY ENDS + +HANDLE STRUC +PHANDLE TYPEDEF FAR PTR HANDLE + HANDLE@@mHandle DD ? +HANDLE ENDS + +FILETIME STRUC +PFILETIME TYPEDEF NEAR PTR FILETIME + FILETIME@@dwLowDateTime DD ? + FILETIME@@dwHighDateTime DD ? +FILETIME ENDS + +WIN32FINDDATA STRUC +PWIN32FINDDATA TYPEDEF NEAR PTR + FINDDATA@@dwFileAttributes DD ? + FINDDATA@@ftCreationTime DD ? + FINDDATA@@ftLastAccessTime DD ? + FINDDATA@@ftLastWriteTime DD ? + FINDDATA@@nFileSizeHigh DD ? + FINDDATA@@nFileSizeLow DD ? + FINDDATA@@dwReserved0 DD ? + FINDDATA@@dwReserved1 DD ? + FINDDATA@@cFileName DB 104h DUP(?) + FINDDATA@@cAlternateFileName DB 0Eh DUP(?) +WIN32FINDDATA ENDS diff --git a/common/WINDOWS.PRE b/common/WINDOWS.PRE new file mode 100644 index 0000000..e69de29 diff --git a/common/WINDOWSX.HPP b/common/WINDOWSX.HPP new file mode 100644 index 0000000..56e03a9 --- /dev/null +++ b/common/WINDOWSX.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_WINDOWSX_HPP_ +#define _COMMON_WINDOWSX_HPP_ +#include +#endif diff --git a/common/WINGBLT.CPP b/common/WINGBLT.CPP new file mode 100644 index 0000000..2ab73f1 --- /dev/null +++ b/common/WINGBLT.CPP @@ -0,0 +1,373 @@ +#include +#include +#include + +WINGBlt::WINGBlt(WORD width,WORD height,PurePalette &somePurePalette) +: mhWINGDC(0), mDisposition(InvalidDC), mhWINGBitmap(0), mIsOkay(FALSE), mhLibrary(0), + mlpfnWINGCreateDC(0), mlpfnWINGCreateBitmap(0), mlpWINGData(0), mlpfnWINGBitBlt(0), + mlpfnWINGStretchBlt(0), mOrientation(BottomUp), mWINGBitmapExtent(0L), mhOldBitmap(0) +{ + if(!initWING())return; + getDIBFormat(); + mWINGPalette=somePurePalette; + mWINGPalette.identityPalette(); + mWINGBitmapInfo=mWINGPalette; + createWINGBitmap(width,height); +} + +WINGBlt::~WINGBlt() +{ + destroyBitmap(); + destroyDevice(); + freeLibrary(); +} + +WORD WINGBlt::size(WORD width,WORD height) +{ + if(!isOkay())return FALSE; + return createWINGBitmap(width,height); +} + +void WINGBlt::getDIBFormat(void) +{ + BitmapInfo bitmapInfo; + + (*mlpfnWINGRecommendDIBFormat)(bitmapInfo); + mOrientation=(Orientation)bitmapInfo.height(); +} + +WORD WINGBlt::createWINGBitmap(WORD width,WORD height) +{ + destroyBitmap(); + createDevice(); + getRequiredWidth(width,height); + mWINGBitmapExtent=(DWORD)width*(DWORD)height; + mWINGBitmapInfo.width(width); + mWINGBitmapInfo.height(height*(int)mOrientation); + mhWINGBitmap=(*mlpfnWINGCreateBitmap)(mhWINGDC,mWINGBitmapInfo,(void**)&mlpWINGData); + if(!mhWINGBitmap)return mIsOkay=FALSE; + setBits(mlpWINGData,mWINGBitmapExtent,0); + mhOldBitmap=(HBITMAP)::SelectObject(mhWINGDC,mhWINGBitmap); + return mIsOkay=TRUE; +} + +WINGBlt &WINGBlt::operator+=(BitmapOverlay &someBitmapOverlay) +{ + Point placementPoint; + DWORD newSrcY; + DWORD newDstY; + DWORD srcIndex; + DWORD dstIndex; + UINT srcRow; + UINT srcCol; + + if(!isOkay())return *this; + placementPoint=someBitmapOverlay.placementPoint(); + switch(mOrientation) + { + case TopDown : + for(srcRow=0;srcRow=mWINGBitmapInfo.height()||col>=mWINGBitmapInfo.width())return; + if(TopDown==mOrientation)setByteTopDown(row,col,byteValue); + else setByteBottomUp(row,col,byteValue); +} + +BYTE WINGBlt::getByte(WORD row,WORD col)const +{ + if(!isOkay())return (BYTE)FALSE; + if(row>=mWINGBitmapInfo.height()||col>=mWINGBitmapInfo.width())return (BYTE)FALSE; + if(TopDown==mOrientation)return getByteTopDown(row,col); + else return getByteBottomUp(row,col); +} + +void WINGBlt::line(const Point &firstPoint,const Point &secondPoint,BYTE byteValue) +{ + LONG xRunning((LONG)firstPoint.x()<<0x10); + LONG yRunning((LONG)firstPoint.y()<<0x10); + LONG xDelta; + LONG yDelta; + short xDir(1); + short yDir(1); + short steps; + + if(secondPoint.x()>0x10,xRunning>>0x10,byteValue); + xRunning-=xDelta; + yRunning-=yDelta; + } + } + else if(-1==xDir&&1==yDir) + { + for(short stepIndex=0;stepIndex>0x10,xRunning>>0x10,byteValue); + xRunning-=xDelta; + yRunning+=yDelta; + } + } + else if(1==xDir&&-1==yDir) + { + for(short itemIndex=0;itemIndex>0x10,xRunning>>0x10,byteValue); + xRunning+=xDelta; + yRunning-=yDelta; + } + } + else if(1==xDir&&1==yDir) + { + for(short itemIndex=0;itemIndex>0x10,xRunning>>0x10,byteValue); + xRunning+=xDelta; + yRunning+=yDelta; + } + } +} + +void WINGBlt::setColTopDown(WORD col,WORD row,char FAR *lpColData,WORD wDataLength) +{ + UHUGE *lpImage=mlpWINGData+(LONG)col; + lpImage+=((LONG)row*mWINGBitmapInfo.width()); + for(;(short)row>=0&&wDataLength;row--) + { + *lpImage=*lpColData; + lpImage-=mWINGBitmapInfo.width(); + lpColData--; + wDataLength--; + } + return; +} + +void WINGBlt::setColBottomUp(WORD col,WORD row,char FAR *lpColData,WORD wDataLength) +{ + UHUGE *lpImage=mlpWINGData+(LONG)col; + lpImage+=(mWINGBitmapInfo.width()*((mWINGBitmapInfo.height()-1L)-(LONG)row)); + for(;(short)row>=0&&wDataLength;row--) + { + *lpImage=*lpColData; + lpImage+=mWINGBitmapInfo.width(); + lpColData--; + wDataLength--; + } +} + +void WINGBlt::setColBottomUp(WORD col,char FAR *lpColData) +{ + UHUGE *lpImage=mlpWINGData+mWINGBitmapInfo.width()*mWINGBitmapInfo.height(); + lpImage=(lpImage-mWINGBitmapInfo.width())+(LONG)col; + for(short rowIndex=0;rowIndex>3)*(LONG)desiredHeight; + if(imageExtent==(LONG)desiredWidth*(LONG)desiredHeight)return; + desiredWidth=(WORD)(imageExtent/(LONG)desiredHeight); +} + +#if defined(__FLAT__) +WORD WINGBlt::initWING(void) +{ + String wingDLLFileName("WING32.DLL"); + String wingDLLPathFileName; + DWORD wingBitBltOrdinal(1L); + DWORD wingStretchBltOrdinal(10L); + DWORD wingCreateBitmapOrdinal(2L); + DWORD wingCreateDCOrdinal(3L); + DWORD wingRecommendDIBFormatOrdinal(8); + PathFind pathFind; + + if(!pathFind.findFile(wingDLLFileName,wingDLLPathFileName))return FALSE; + if((mhLibrary=::LoadLibrary(wingDLLPathFileName))<(HINSTANCE)HINSTANCE_ERROR)return FALSE; + mlpfnWINGCreateDC=(LPFNWINGCREATEDC)::GetProcAddress(mhLibrary,(LPCSTR)wingCreateDCOrdinal); + mlpfnWINGCreateBitmap=(LPFNWINGCREATEBITMAP)::GetProcAddress(mhLibrary,(LPCSTR)wingCreateBitmapOrdinal); + mlpfnWINGBitBlt=(LPFNWINGBITBLT)::GetProcAddress(mhLibrary,(LPCSTR)wingBitBltOrdinal); + mlpfnWINGStretchBlt=(LPFNWINGSTRETCHBLT)::GetProcAddress(mhLibrary,(LPCSTR)wingStretchBltOrdinal); + mlpfnWINGRecommendDIBFormat=(LPFNWINGRECOMMENDDIBFORMAT)::GetProcAddress(mhLibrary,(LPCSTR)wingRecommendDIBFormatOrdinal); + if(!mlpfnWINGCreateDC)throw(NullError()); + if(!mlpfnWINGCreateBitmap)throw(NullError()); + if(!mlpfnWINGBitBlt)throw(NullError()); + if(!mlpfnWINGStretchBlt)throw(NullError()); + if(!mlpfnWINGRecommendDIBFormat)throw(NullError()); + return TRUE; +} +#else +WORD WINGBlt::initWING(void) +{ + String wingDLLFileName("WING.DLL"); + String wingDLLPathFileName; + DWORD wingBitBltOrdinal(1010L); + DWORD wingStretchBltOrdinal(1009L); + DWORD wingCreateBitmapOrdinal(1003L); + DWORD wingCreateDCOrdinal(1001L); + DWORD wingRecommendDIBFormatOrdinal(1002); + PathFind pathFind; + + if(!pathFind.findFile(wingDLLFileName,wingDLLPathFileName))return FALSE; + if((mhLibrary=::LoadLibrary(wingDLLPathFileName)) +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PUREDEVICE_HPP_ +#include +#endif +#ifndef _COMMON_BITMAP_HPP_ +#include +#endif +#ifndef _COMMON_BITMAPINFO_HPP_ +#include +#endif + +class WINGBlt +{ +public: + typedef enum Orientation{TopDown=-1,BottomUp=1}; + WINGBlt(WORD width,WORD height,PurePalette &somePurePalette); + ~WINGBlt(); + WORD size(WORD width,WORD height); + operator PurePalette &(void); + WINGBlt &operator=(const WINGBlt &someWINGBlt); + WINGBlt &operator=(Bitmap &someBitmap); + WINGBlt &operator=(PurePalette &somePurePalette); + WINGBlt &operator+=(BitmapOverlay &someBitmapOverlay); + Orientation orientation(void)const; + WORD width(void)const; + WORD height(void)const; + DWORD imageExtent(void)const; + WORD bitBlt(PureDevice &somePureDevice); + void line(const Point &firstPoint,const Point &secondPoint,BYTE byteValue); + void setBitmapBits(BYTE byteValue); + void setByte(WORD row,WORD col,BYTE byteValue); + BYTE getByte(WORD row,WORD col)const; + WORD getRow(WORD row,char FAR *lpRowData)const; + WORD setRow(WORD row,char FAR *lpRowData); + WORD getCol(WORD col,char FAR *lpColData)const; + WORD setCol(WORD col,char FAR *lpColData); + WORD setCol(WORD col,WORD row,char FAR *lpColData,WORD wDataLength); + WORD isOkay(void)const; + UHUGE *getDataPtr(void)const; +private: + typedef enum Disposition{KeepDC,DeleteDC,InvalidDC}; + typedef HDC (WINGAPI *LPFNWINGCREATEDC)(void); + typedef HBITMAP (WINGAPI *LPFNWINGCREATEBITMAP)(HDC WinGDC,BITMAPINFO const FAR *lpBitmapInfo,void FAR FAR *lppBytes); + typedef BOOL (WINGAPI *LPFNWINGBITBLT)(HDC hdcDest,int nXOriginDest,int nYOriginDest,int nWidthDest,int nHeightDest,HDC hdcSrc,int nXOriginSrc,int nYOriginSrc); + typedef BOOL (WINGAPI *LPFNWINGSTRETCHBLT)(HDC hdcDest,int nXOriginDest,int nYOriginDest,int nWidthDest,int nHeightDest,HDC hdcSrc,int nXOriginSrc,int nYOriginSrc,int nWidthSrc,int nHeightSrc); + typedef BOOL (WINGAPI *LPFNWINGRECOMMENDDIBFORMAT)(BITMAPINFO FAR *lpBitmapInfo); + void copyBits(UHUGE *destination,UHUGE *source,DWORD length)const; + void setBits(UHUGE *lpSrcPtr,DWORD srcExtent,BYTE charByte); + void getRequiredWidth(WORD &desiredWidth,WORD desiredHeight); + void setByteBottomUp(WORD row,WORD col,BYTE byteValue); + BYTE getByteBottomUp(WORD row,WORD col)const; + void setByteTopDown(WORD row,WORD col,BYTE byteValue); + BYTE getByteTopDown(WORD row,WORD col)const; + void setColTopDown(WORD col,WORD row,char FAR *lpColData,WORD wDataLength); + void setColBottomUp(WORD col,WORD row,char FAR *lpColData,WORD wDataLength); + void setColBottomUp(WORD col,char FAR *lpColData); + void getColBottomUp(WORD col,char FAR *lpColData)const; + void setRowBottomUp(WORD row,char FAR *lpRowData); + void getRowBottomUp(WORD row,char FAR *lpRowData)const; + void setColTopDown(WORD col,char FAR *lpColData); + void getColTopDown(WORD col,char FAR *lpColData)const; + void setRowTopDown(WORD row,char FAR *lpColData); + void getRowTopDown(WORD row,char FAR *lpColData)const; + void getDIBFormat(void); + void destroyBitmap(void); + void destroyDevice(void); + void freeLibrary(void); + void createDevice(void); + WORD initWING(void); + WORD createWINGBitmap(WORD width,WORD height); + LPFNWINGCREATEDC mlpfnWINGCreateDC; + LPFNWINGCREATEBITMAP mlpfnWINGCreateBitmap; + LPFNWINGSTRETCHBLT mlpfnWINGStretchBlt; + LPFNWINGBITBLT mlpfnWINGBitBlt; + LPFNWINGRECOMMENDDIBFORMAT mlpfnWINGRecommendDIBFormat; + HINSTANCE mhLibrary; + Disposition mDisposition; + PurePalette mWINGPalette; + BitmapInfo mWINGBitmapInfo; + DWORD mWINGBitmapExtent; + Orientation mOrientation; + UHUGE *mlpWINGData; + WORD mIsOkay; + HDC mhWINGDC; + HBITMAP mhWINGBitmap; + HBITMAP mhOldBitmap; +}; + +inline +void WINGBlt::destroyBitmap(void) +{ + if(mhOldBitmap&&mhWINGDC){::SelectObject(mhWINGDC,mhOldBitmap);mhOldBitmap=0;} + if(mhWINGBitmap){::DeleteObject(mhWINGBitmap);mhWINGBitmap=0;mlpWINGData=0;mIsOkay=FALSE;} +} + +inline +void WINGBlt::destroyDevice(void) +{ + if(mhWINGDC&&DeleteDC==mDisposition){::DeleteDC(mhWINGDC);mhWINGDC=0;mDisposition=InvalidDC;} +} + +inline +void WINGBlt::freeLibrary(void) +{ + if(mhLibrary){::FreeLibrary(mhLibrary);mhLibrary=0;} +} + +inline +WORD WINGBlt::isOkay(void)const +{ + return mIsOkay; +} + +inline +WORD WINGBlt::width(void)const +{ + return mWINGBitmapInfo.width(); +} + +inline +WORD WINGBlt::height(void)const +{ + return mWINGBitmapInfo.height(); +} + +inline +DWORD WINGBlt::imageExtent(void)const +{ + return mWINGBitmapExtent; +} + +inline +UHUGE *WINGBlt::getDataPtr(void)const +{ + return mlpWINGData; +} + +inline +WINGBlt::operator PurePalette &(void) +{ + return mWINGPalette; +} + +inline +WINGBlt::Orientation WINGBlt::orientation(void)const +{ + return mOrientation; +} + +inline +WINGBlt &WINGBlt::operator=(const WINGBlt &/*someWINGBlt*/) +{ + return *this; +} + +inline +void WINGBlt::setBitmapBits(BYTE byteValue) +{ + if(!isOkay())return; + setBits(mlpWINGData,mWINGBitmapExtent,byteValue); +} + +inline +void WINGBlt::setByteBottomUp(WORD row,WORD col,BYTE byteValue) +{ + UHUGE *lpImage=mlpWINGData+mWINGBitmapInfo.width()*mWINGBitmapInfo.height(); + *((lpImage-((LONG)row*mWINGBitmapInfo.width()+mWINGBitmapInfo.width()))+(LONG)col)=byteValue; +} + +inline +BYTE WINGBlt::getByteBottomUp(WORD row,WORD col)const +{ + UHUGE *lpImage=mlpWINGData+mWINGBitmapInfo.width()*mWINGBitmapInfo.height(); + return *((lpImage-((LONG)row*mWINGBitmapInfo.width()+mWINGBitmapInfo.width()))+(LONG)col); +} + +inline +void WINGBlt::setByteTopDown(WORD row,WORD col,BYTE byteValue) +{ + *(mlpWINGData+(((LONG)row*mWINGBitmapInfo.width())+(LONG)col))=byteValue; +} + +inline +BYTE WINGBlt::getByteTopDown(WORD row,WORD col)const +{ + return *(mlpWINGData+(((LONG)row*mWINGBitmapInfo.width())+(LONG)col)); +} + +inline +WORD WINGBlt::getRow(WORD row,char FAR *lpRowData)const +{ + if(!isOkay()||row>=mWINGBitmapInfo.height())return FALSE; + if(TopDown==mOrientation)getRowTopDown(row,lpRowData); + else getRowBottomUp(row,lpRowData); + return TRUE; +} + +inline +WORD WINGBlt::setRow(WORD row,char FAR *lpRowData) +{ + if(!isOkay()||row>=mWINGBitmapInfo.height())return FALSE; + if(TopDown==mOrientation)setRowTopDown(row,lpRowData); + else setRowBottomUp(row,lpRowData); + return TRUE; +} + +inline +WORD WINGBlt::getCol(WORD col,char FAR *lpColData)const +{ + if(!isOkay()||col>=mWINGBitmapInfo.width())return FALSE; + if(TopDown==mOrientation)getColTopDown(col,lpColData); + else getColBottomUp(col,lpColData); + return TRUE; +} + +inline +WORD WINGBlt::setCol(WORD col,char FAR *lpColData) +{ + if(!isOkay()||col>=mWINGBitmapInfo.width())return FALSE; + if(TopDown==mOrientation)setColTopDown(col,lpColData); + else setColBottomUp(col,lpColData); + return TRUE; +} + +inline +WORD WINGBlt::setCol(WORD col,WORD row,char FAR *lpColData,WORD wDataLength) +{ + if(!isOkay()||col>=mWINGBitmapInfo.width()||row>=mWINGBitmapInfo.height())return FALSE; + if(TopDown==mOrientation)setColTopDown(col,row,lpColData,wDataLength); + else setColBottomUp(col,row,lpColData,wDataLength); + return TRUE; +} + +inline +WORD WINGBlt::bitBlt(PureDevice &somePureDevice) +{ + if(!isOkay())return FALSE; + (*mlpfnWINGBitBlt)(somePureDevice,0,0,mWINGBitmapInfo.width(),mWINGBitmapInfo.height(),mhWINGDC,0,0); + return TRUE; +} +#endif diff --git a/common/WINMSG.HPP b/common/WINMSG.HPP new file mode 100644 index 0000000..f67a083 --- /dev/null +++ b/common/WINMSG.HPP @@ -0,0 +1,186 @@ +#ifndef _COMMON_WINMSG_HPP_ +#define _COMMON_WINMSG_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_POINT_HPP_ +#include +#endif + +class WinMsg : private MSG +{ +public: + WinMsg(void); + WinMsg(const WinMsg &someWinMsg); + WinMsg(const MSG &someMSG); + ~WinMsg(); + WinMsg &operator=(const WinMsg &someWinMsg); + WinMsg &operator=(const MSG &someMSG); + WORD operator==(const WinMsg &someWinMsg)const; + operator MSG&(void); + HWND hwnd(void)const; + void hwnd(HWND hwnd); + UINT message(void)const; + void message(UINT message); + WPARAM wParam(void)const; + void wParam(WPARAM wParam); + LPARAM lParam(void)const; + void lParam(LPARAM lParam); + DWORD time(void)const; + void time(DWORD time); + Point point(void)const; + void point(const Point &somePoint); +private: + void zeroInit(void); +}; + +inline +WinMsg::WinMsg(void) +{ + zeroInit(); +} + +inline +WinMsg::WinMsg(const WinMsg &someWinMsg) +{ + *this=someWinMsg; +} + +inline +WinMsg::WinMsg(const MSG &someMSG) +{ + *this=someMSG; +} + +inline +WinMsg::~WinMsg() +{ +} + +inline +WinMsg &WinMsg::operator=(const WinMsg &someWinMsg) +{ + hwnd(someWinMsg.hwnd()); + message(someWinMsg.message()); + wParam(someWinMsg.wParam()); + lParam(someWinMsg.lParam()); + time(someWinMsg.time()); + point(someWinMsg.point()); + return *this; +} + +inline +WinMsg &WinMsg::operator=(const MSG &someMSG) +{ + hwnd(someMSG.hwnd); + message(someMSG.message); + wParam(someMSG.wParam); + lParam(someMSG.lParam); + time(someMSG.time); + point(Point(someMSG.pt.x,someMSG.pt.y)); + return *this; + +} + +inline +WORD WinMsg::operator==(const WinMsg &someWinMsg)const +{ + return (hwnd()==someWinMsg.hwnd()&& + message()==someWinMsg.message()&& + wParam()==someWinMsg.wParam()&& + lParam()==someWinMsg.lParam()&& + time()==someWinMsg.time()&& + point()==someWinMsg.point()); +} + +inline +WinMsg::operator MSG&(void) +{ + return *this; +} + +inline +HWND WinMsg::hwnd(void)const +{ + return MSG::hwnd; +} + +inline +void WinMsg::hwnd(HWND hwnd) +{ + MSG::hwnd=hwnd; +} + +inline +UINT WinMsg::message(void)const +{ + return MSG::message; +} + +inline +void WinMsg::message(UINT message) +{ + MSG::message=message; +} + +inline +WPARAM WinMsg::wParam(void)const +{ + return MSG::wParam; +} + +inline +void WinMsg::wParam(WPARAM wParam) +{ + MSG::wParam=wParam; +} + +inline +LPARAM WinMsg::lParam(void)const +{ + return MSG::lParam; +} + +inline +void WinMsg::lParam(LPARAM lParam) +{ + MSG::lParam=lParam; +} + +inline +DWORD WinMsg::time(void)const +{ + return MSG::time; +} + +inline +void WinMsg::time(DWORD time) +{ + MSG::time=time; +} + +inline +Point WinMsg::point(void)const +{ + return Point(MSG::pt.x,MSG::pt.y); +} + +inline +void WinMsg::point(const Point &somePoint) +{ + MSG::pt.x=somePoint.x(); + MSG::pt.y=somePoint.y(); +} + +inline +void WinMsg::zeroInit(void) +{ + MSG::hwnd=0; + MSG::message=0; + MSG::wParam=0; + MSG::lParam=0; + MSG::time=0; + MSG::pt.x=0; + MSG::pt.y=0; +} +#endif diff --git a/common/WINNLS.HPP b/common/WINNLS.HPP new file mode 100644 index 0000000..ad5936b --- /dev/null +++ b/common/WINNLS.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_WINNLS_HPP_ +#define _COMMON_WINNLS_HPP_ +#include +#endif diff --git a/common/WINNT.HPP b/common/WINNT.HPP new file mode 100644 index 0000000..0fa69ed --- /dev/null +++ b/common/WINNT.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_WINNT_HPP_ +#define _COMMON_WINNT_HPP_ +#include +#endif diff --git a/common/WINNT.INC b/common/WINNT.INC new file mode 100644 index 0000000..bfdbaca --- /dev/null +++ b/common/WINNT.INC @@ -0,0 +1,276 @@ +; ****************************************************************************************************** +; FILE:WINNT.INC DATE: MARCH 10, 1999 +; FUNCTION: WIN32 SYSTEM RELATED STRUCTURES AND EQUATES +; AUTHOR: SEAN M. KESSLER (CONVERTED FROM WINNT.H) +;******************************************************************************************************* + +; section characteristics macros +ISCODE MACRO pImageSectionHeader + mov eax,[pImageSectionHeader] + and [IMAGESECTIONHEADER PTR[eax]].SECTIONHEADER@@Characteristics,IMAGE_SCN_CNT_CODE +ENDM + +ISDATA MACRO pImageSectionHeader +LOCAL @@End + ISINITDATA pImageSectionHeader + jne @@End + ISUINITDATA pImageSectionHeader +@@End: +ENDM + +ISINITDATA MACRO pImageSectionHeader + mov eax,[pImageSectionHeader] + and [IMAGESECTIONHEADER PTR[eax]].SECTIONHEADER@@Characteristics,IMAGE_SCN_CNT_INITIALIZED_DATA +ENDM + +ISUINITDATA MACRO pImageSectionHeader + mov eax,[pImageSectionHeader] + and [IMAGESECTIONHEADER PTR[eax]].SECTIONHEADER@@Characteristics,IMAGE_SCN_CNT_UNINITIALIZED_DATA +ENDM + +ISEXECUTABLE MACRO pImageSectionHeader + mov eax[pImageSectionHeader] + and [IMAGESECTIONHEADER PTR[eax]].SECTIONHEADER@@Characteristics,IMAGE_SCN_CNT_MEM_EXECUTE +ENDM + +ISREADABLE MACRO pImageSectionHeader + mov eax,[pImageSectionHeader] + and [IMAGESECTIONHEADER PTR[eax]].SECTIONHEADER@@Characteristics,IMAGE_SCN_MEM_READ +ENDM + +ISWRITEABLE MACRO pImageSectionHeader + mov eax,[pImageSectionHeader] + and [IMAGESECTIONHEADER PTR[eax]].SECTIONHEADER@@Characteristics,IMAGE_SCN_MEM_WRITE +ENDM + +IMAGEDOSHEADER STRUC ; DOS .EXE header +PIMAGEDOSHEADER TYPEDEF NEAR PTR IMAGEDOSHEADER + DOSHEADER@@e_magic DW ? ; magic number + DOSHEADER@@e_cblp DW ? ; bytes on last page of file + DOSHEADER@@e_cp DW ? ; pages in file + DOSHEADER@@e_crlc DW ? ; relocations + DOSHEADER@@e_cparhdr DW ? ; size of header in paragraphs + DOSHEADER@@e_minalloc DW ? ; minimum extra paragraphs needed + DOSHEADER@@e_maxalloc DW ? ; maximum extra paragraphs needed + DOSHEADER@@e_ss DW ? ; initial (relative) ss value + DOSHEADER@@e_sp DW ? ; initial sp value + DOSHEADER@@e_csum DW ? ; checksum + DOSHEADER@@e_ip DW ? ; initial ip value + DOSHEADER@@e_cs DW ? ; initial relative cs value + DOSHEADER@@e_lfarlc DW ? ; file address of relocation table + DOSHEADER@@e_ovno DW ? ; overlay number + DOSHEADER@@e_res DW 04H DUP(?) ; reserved words + DOSHEADER@@e_oemid DW ? ; oem identifier (for e_oeminfo) + DOSHEADER@@e_oeminfo DW ? ; oem information (e_oemid specific) + DOSHEADER@@e_res2 DW 0AH DUP(?) ; reserved words + DOSHEADER@@e_lfanew DD ? ; file address of new exe header +IMAGEDOSHEADER ENDS + +IMAGEFILEHEADER STRUC +PIMAGEFILEHEADER TYPEDEF FAR PTR IMAGEFILEHEADER + FILEHEADER@@Machine DW ? ; required architecture, 0x14C=80386 + FILEHEADER@@NumberOfSections DW ? ; count of sections in file + FILEHEADER@@TimeDateStamp DD ? ; number of seconds after Dec 31,1969 at 4:00 p.m. + FILEHEADER@@PointerToSymbolTable DD ? ; pointer to COFF symbol table + FILEHEADER@@NumberOfSymbols DD ? ; number of COFF symbols + FILEHEADER@@SizeOfOptionalHeader DW ? ; size of optional header that follows + FILEHEADER@@Characteristics DW ? ; 0001h=no relocations, 0002h=EXE, 2000h=DLL +IMAGEFILEHEADER ENDS + +IMAGEDATADIRECTORY STRUC +PIMAGEDATADIRECTORY TYPEDEF FAR PTR IMAGEDATADIRECTORY + DATADIRECTORY@@VirtualAddress DD ? ; location of relevent quantity + DATADIRECTORY@@Size DD ? ; size of the relevent quantity +IMAGEDATADIRECTORY ENDS + +IMAGE_NUMBEROF_DIRECTORY_ENTRIES EQU 10h + +IMAGEOPTIONALHEADER STRUC +PIMAGEOPTIONALHEADER TYPEDEF FAR PTR IMAGEOPTIONALHEADER + OPTIONALHEADER@@Magic DW ? ; always 010Bh + OPTIONALHEADER@@MajorLinkerVersion DB ? ; major linker version of linker that produced file + OPTIONALHEADER@@MinorLinkerVersion DB ? ; minor linker version of linker that produced file + OPTIONALHEADER@@SizeOfCode DD ? ; combined size of all code sections + OPTIONALHEADER@@SizeOfInitializedData DD ? ; combined size of all initialized data sections + OPTIONALHEADER@@SizeOfUnitializedData DD ? ; combined size of all unitialized data sections + OPTIONALHEADER@@AddressOfEntryPoint DD ? ; RVA where code begins execution + OPTIONALHEADER@@BaseOfCode DD ? ; RVA where files code sections begin + OPTIONALHEADER@@BaseOfData DD ? ; RVA where files data sections begin + OPTIONALHEADER@@ImageBase DD ? ; preferred address to load this image + OPTIONALHEADER@@SectionAlignment DD ? ; alignment of sections in memory + OPTIONALHEADER@@FileAlignment DD ? ; alignment of sections in the file + OPTIONALHEADER@@MajorOperatingSystemVersion DW ? ; minimum version of operating system required + OPTIONALHEADER@@MinorOperatingSystemVersion DW ? ; minor version number of above + OPTIONALHEADER@@MajorImageVersion DW ? ; user defineable field + OPTIONALHEADER@@MinorImageVersion DW ? ; user defineable field + OPTIONALHEADER@@MajorSubsystemVersion DW ? ; minimum subsystem version to run exe + OPTIONALHEADER@@MinorSubsystemVersion DW ? ; minimum subsystem version + OPTIONALHEADER@@Win32VersionValue DD ? ; always zero + OPTIONALHEADER@@SizeOfImage DD ? ; total size of the image, rounded up + OPTIONALHEADER@@SizeOfHeaders DD ? ; size of PE header and section table + OPTIONALHEADER@@CheckSum DD ? ; 0, except for trusted services + OPTIONALHEADER@@Subsystem DW ? ; 1=native,2=wingui,3=console,5=OS/2,7=Posix + OPTIONALHEADER@@DllCharacteristics DW ? ; 1=callonload,2=callendthrd,4=callinithtrd,6=calldllexit + OPTIONALHEADER@@SizeOfStackReserve DD ? ; amount of memory to reserve for stack + OPTIONALHEADER@@SizeOfStackCommit DD ? ; amount of committed memory for stack + OPTIONALHEADER@@SizeOfHeapReserve DD ? ; amount of memory to reserve for heap + OPTIONALHEADER@@SizeOfHeapCommit DD ? ; amount of committed memory for heap + OPTIONALHEADER@@LoaderFlags DD ? ; unknown purpose + OPTIONALHEADER@@NumberOfRvaAndSizes DD ? ; number of entries in the data directory + OPTIONALHEADER@@DataDirectory IMAGEDATADIRECTORY IMAGE_NUMBEROF_DIRECTORY_ENTRIES DUP() +IMAGEOPTIONALHEADER ENDS + +IMAGE_SIZEOF_FILE_HEADER EQU 0014h +IMAGE_FILE_RELOCS_STRIPPED EQU 0001h ; Relocation info stripped from file. +IMAGE_FILE_EXECUTABLE_IMAGE EQU 0002h ; File is executable (i.e. no unresolved externel references). +IMAGE_FILE_LINE_NUMS_STRIPPED EQU 0004h ; Line nunbers stripped from file. +IMAGE_FILE_LOCAL_SYMS_STRIPPED EQU 0008h ; Local symbols stripped from file. +IMAGE_FILE_AGGRESIVE_WS_TRIM EQU 0010h ; Agressively trim working set +IMAGE_FILE_BYTES_REVERSED_LO EQU 0080h ; Bytes of machine word are reversed. +IMAGE_FILE_32BIT_MACHINE EQU 0100h ; 32 bit word machine. +IMAGE_FILE_DEBUG_STRIPPED EQU 0200h ; Debugging info stripped from file in .DBG file +IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP EQU 0400h ; If Image is on removable media, copy and run from the swap file. +IMAGE_FILE_NET_RUN_FROM_SWAP EQU 0800h ; If Image is on Net, copy and run from the swap file. +IMAGE_FILE_SYSTEM EQU 1000h ; System File. +IMAGE_FILE_DLL EQU 2000h ; File is a DLL. +IMAGE_FILE_UP_SYSTEM_ONLY EQU 4000h ; File should only be run on a UP machine +IMAGE_FILE_BYTES_REVERSED_HI EQU 8000h ; Bytes of machine word are reversed. +IMAGE_FILE_MACHINE_UNKNOWN EQU 0000h +IMAGE_FILE_MACHINE_I386 EQU 014ch ; Intel 386. +IMAGE_FILE_MACHINE_R3000 EQU 0162h ; MIPS little-endian, 0x160 big-endian +IMAGE_FILE_MACHINE_R4000 EQU 0166h ; MIPS little-endian +IMAGE_FILE_MACHINE_R10000 EQU 0168h ; MIPS little-endian +IMAGE_FILE_MACHINE_ALPHA EQU 0184h ; Alpha_AXP +IMAGE_FILE_MACHINE_POWERPC EQU 01F0h ; IBM PowerPC Little-Endian + +; subsystem +IMAGE_SUBSYSTEM_UNKNOWN EQU 0000h ; Unknown subsystem. +IMAGE_SUBSYSTEM_NATIVE EQU 0001h ; Image doesn't require a subsystem. +IMAGE_SUBSYSTEM_WINDOWS_GUI EQU 0002h ; Image runs in the Windows GUI subsystem. +IMAGE_SUBSYSTEM_WINDOWS_CUI EQU 0003h ; Image runs in the Windows character subsystem. +IMAGE_SUBSYSTEM_OS2_CUI EQU 0005h ; image runs in the OS/2 character subsystem. +IMAGE_SUBSYSTEM_POSIX_CUI EQU 0007h ; image runs in the Posix character subsystem. +IMAGE_SUBSYSTEM_RESERVED8 EQU 0008h ; image runs in the 8 subsystem. + +; directory entries +IMAGE_DIRECTORY_ENTRY_EXPORT EQU 0000h ; Export Directory +IMAGE_DIRECTORY_ENTRY_IMPORT EQU 0001h ; Import Directory +IMAGE_DIRECTORY_ENTRY_RESOURCE EQU 0002h ; Resource Directory +IMAGE_DIRECTORY_ENTRY_EXCEPTION EQU 0003h ; Exception Directory +IMAGE_DIRECTORY_ENTRY_SECURITY EQU 0004h ; Security Directory +IMAGE_DIRECTORY_ENTRY_BASERELOC EQU 0005h ; Base Relocation Table +IMAGE_DIRECTORY_ENTRY_DEBUG EQU 0006h ; Debug Directory +IMAGE_DIRECTORY_ENTRY_COPYRIGHT EQU 0007h ; Description String +IMAGE_DIRECTORY_ENTRY_GLOBALPTR EQU 0008h ; Machine Value (MIPS GP) +IMAGE_DIRECTORY_ENTRY_TLS EQU 0009h ; TLS Directory +IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG EQU 000Ah ; Load Configuration Directory +IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT EQU 000Bh ; Bound Import Directory in headers +IMAGE_DIRECTORY_ENTRY_IAT EQU 000Ch ; Import Address Table + +IMAGE_NUMBEROF_DIRECTORY_ENTRIES EQU 0010h + +IMAGE_DOS_SIGNATURE EQU 5A4Dh ; MZ header signature +IMAGE_PE_SIGNATURE EQU 4550h ; PE signature + +; image section header equates +IMAGE_SIZEOF_SHORT_NAME EQU 0008h +IMAGE_SIZEOF_SECTION_HEADER EQU 0040h + +IMAGESECTIONHEADER STRUC +PIMAGESECTIONHEADER TYPEDEF NEAR PTR IMAGESECTIONHEADER + SECTIONHEADER@@Name DB IMAGE_SIZEOF_SHORT_NAME DUP(?) + SECTIONHEADER@@VirtualSize DD ? ; VirtualSize=PhysicalAddress + SECTIONHEADER@@VirtualAddress DD ? + SECTIONHEADER@@SizeOfRawData DD ? + SECTIONHEADER@@PointerToRawData DD ? + SECTIONHEADER@@PointerToRelocations DD ? + SECTIONHEADER@@PointerToLineNumbers DD ? + SECTIONHEADER@@NumberOfRelocations DW ? + SECTIONHEADER@@NumberOfLineNumbers DW ? + SECTIONHEADER@@Characteristics DD ? +IMAGESECTIONHEADER ENDS + +IMAGE_SCN_TYPE_NO_PAD EQU 00000008h ; Reserved. +IMAGE_SCN_CNT_CODE EQU 00000020h ; Section contains code. +IMAGE_SCN_CNT_INITIALIZED_DATA EQU 00000040h ; Section contains initialized data. +IMAGE_SCN_CNT_UNINITIALIZED_DATA EQU 00000080h ; Section contains uninitialized data. +IMAGE_SCN_LNK_OTHER EQU 00000100h ; Reserved. +IMAGE_SCN_LNK_INFO EQU 00000200h ; Section contains comments or some other type of information. +IMAGE_SCN_LNK_REMOVE EQU 00000800h ; Section contents will not become part of image. +IMAGE_SCN_LNK_COMDAT EQU 00001000h ; Section contents comdat. +IMAGE_SCN_MEM_FARDATA EQU 00008000h +IMAGE_SCN_MEM_PURGEABLE EQU 00020000h +IMAGE_SCN_MEM_16BIT EQU 00020000h +IMAGE_SCN_MEM_LOCKED EQU 00040000h +IMAGE_SCN_MEM_PRELOAD EQU 00080000h +IMAGE_SCN_ALIGN_1BYTES EQU 00100000h ; +IMAGE_SCN_ALIGN_2BYTES EQU 00200000h ; +IMAGE_SCN_ALIGN_4BYTES EQU 00300000h ; +IMAGE_SCN_ALIGN_8BYTES EQU 00400000h ; +IMAGE_SCN_ALIGN_16BYTES EQU 00500000h ; Default alignment if no others are specified. +IMAGE_SCN_ALIGN_32BYTES EQU 00600000h ; +IMAGE_SCN_ALIGN_64BYTES EQU 00700000h ; +IMAGE_SCN_LNK_NRELOC_OVFL EQU 01000000h ; Section contains extended relocations. +IMAGE_SCN_MEM_DISCARDABLE EQU 02000000h ; Section can be discarded. +IMAGE_SCN_MEM_NOT_CACHED EQU 04000000h ; Section is not cachable. +IMAGE_SCN_MEM_NOT_PAGED EQU 08000000h ; Section is not pageable. +IMAGE_SCN_MEM_SHARED EQU 10000000h ; Section is shareable. +IMAGE_SCN_MEM_EXECUTE EQU 20000000h ; Section is executable. +IMAGE_SCN_MEM_READ EQU 40000000h ; Section is readable. +IMAGE_SCN_MEM_WRITE EQU 80000000h ; Section is writeable. + +IMAGE_SCN_SCALE_INDEX EQU 00000001h ; Tls index is scaled +IMAGE_SCN_MEM_FARDATA EQU 00008000h +IMAGE_SCN_MEM_PURGEABLE EQU 00020000h +IMAGE_SCN_MEM_16BIT EQU 00020000h +IMAGE_SCN_MEM_LOCKED EQU 00040000h +IMAGE_SCN_MEM_PRELOAD EQU 00080000h +IMAGE_SCN_ALIGN_1BYTES EQU 00100000h +IMAGE_SCN_ALIGN_2BYTES EQU 00200000h +IMAGE_SCN_ALIGN_4BYTES EQU 00300000h +IMAGE_SCN_ALIGN_8BYTES EQU 00400000h +IMAGE_SCN_ALIGN_16BYTES EQU 00500000h ; Default alignment if no others are specified. +IMAGE_SCN_ALIGN_32BYTES EQU 00600000h +IMAGE_SCN_ALIGN_64BYTES EQU 00700000h +IMAGE_SCN_LNK_NRELOC_OVFL EQU 01000000h ; Section contains extended relocations. +IMAGE_SCN_MEM_DISCARDABLE EQU 02000000h ; Section can be discarded. +IMAGE_SCN_MEM_NOT_CACHED EQU 04000000h ; Section is not cachable. +IMAGE_SCN_MEM_NOT_PAGED EQU 08000000h ; Section is not pageable. +IMAGE_SCN_MEM_SHARED EQU 10000000h ; Section is shareable. +IMAGE_SCN_MEM_EXECUTE EQU 20000000h ; Section is executable. +IMAGE_SCN_MEM_READ EQU 40000000h ; Section is readable. +IMAGE_SCN_MEM_WRITE EQU 80000000h ; Section is writeable. +IMAGE_SCN_SCALE_INDEX EQU 00000001h ; Tls index is scaled + +IMAGE_SCN_TYPE_NO_PAD EQU 00000008h ; Reserved. +IMAGE_SCN_CNT_CODE EQU 00000020h ; Section contains code. +IMAGE_SCN_CNT_INITIALIZED_DATA EQU 00000040h ; Section contains initialized data. +IMAGE_SCN_CNT_UNINITIALIZED_DATA EQU 00000080h ; Section contains uninitialized data. +IMAGE_SCN_LNK_OTHER EQU 00000100h ; Reserved. +IMAGE_SCN_LNK_INFO EQU 00000200h ; Section contains comments or some other type of information. +IMAGE_SCN_LNK_REMOVE EQU 00000800h ; Section contents will not become part of image. +IMAGE_SCN_LNK_COMDAT EQU 00001000h ; Section contents comdat. +IMAGE_SCN_MEM_FARDATA EQU 00008000h +IMAGE_SCN_MEM_PURGEABLE EQU 00020000h +IMAGE_SCN_MEM_16BIT EQU 00020000h +IMAGE_SCN_MEM_LOCKED EQU 00040000h +IMAGE_SCN_MEM_PRELOAD EQU 00080000h +IMAGE_SCN_ALIGN_1BYTES EQU 00100000h ; +IMAGE_SCN_ALIGN_2BYTES EQU 00200000h ; +IMAGE_SCN_ALIGN_4BYTES EQU 00300000h ; +IMAGE_SCN_ALIGN_8BYTES EQU 00400000h ; +IMAGE_SCN_ALIGN_16BYTES EQU 00500000h ; Default alignment if no others are specified. +IMAGE_SCN_ALIGN_32BYTES EQU 00600000h ; +IMAGE_SCN_ALIGN_64BYTES EQU 00700000h ; +IMAGE_SCN_LNK_NRELOC_OVFL EQU 01000000h ; Section contains extended relocations. +IMAGE_SCN_MEM_DISCARDABLE EQU 02000000h ; Section can be discarded. +IMAGE_SCN_MEM_NOT_CACHED EQU 04000000h ; Section is not cachable. +IMAGE_SCN_MEM_NOT_PAGED EQU 08000000h ; Section is not pageable. +IMAGE_SCN_MEM_SHARED EQU 10000000h ; Section is shareable. +IMAGE_SCN_MEM_EXECUTE EQU 20000000h ; Section is executable. +IMAGE_SCN_MEM_READ EQU 40000000h ; Section is readable. +IMAGE_SCN_MEM_WRITE EQU 80000000h ; Section is writeable. + + + + diff --git a/common/WINTIMER.CPP b/common/WINTIMER.CPP new file mode 100644 index 0000000..5322154 --- /dev/null +++ b/common/WINTIMER.CPP @@ -0,0 +1,149 @@ +#include +#include + +char WinTimer::smszClassName[]="WINTIMER"; +char WinTimer::smszMenuName[]=""; + +WinTimer::WinTimer(HINSTANCE hProcessInstance) +: mTimerHandler(this,&WinTimer::timerHandler), + mIsOkay(FALSE), mTimerID(InvalidID), mhInstance(hProcessInstance) +{ + initWinTimer(); +} + +WinTimer::WinTimer(const Window &someWindow) +: mTimerHandler(this,&WinTimer::timerHandler), + mIsOkay(FALSE), mTimerID(InvalidID), mhInstance(someWindow.processInstance()) +{ + initWinTimer(); +} + +void WinTimer::initWinTimer(void) +{ + Window::insertHandler(VectorHandler::TimerHandler,&mTimerHandler); + registerClass(); + createWindow(); + mIsOkay=TRUE; +} + +WinTimer::~WinTimer() +{ + if((HWND)*this){stopTimer();destroy();} + Window::removeHandler(VectorHandler::TimerHandler,&mTimerHandler); +} + +void WinTimer::registerClass(void) +{ + WNDCLASS wndClass; + + if(::GetClassInfo(mhInstance,smszClassName,(WNDCLASS FAR*)&wndClass))return; + wndClass.style =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS; + wndClass.lpfnWndProc =(WNDPROC)Window::WndProc; + wndClass.cbClsExtra =0; + wndClass.cbWndExtra =sizeof(WinTimer*); + wndClass.hInstance =mhInstance; + wndClass.hIcon =::LoadIcon(NULL,IDI_APPLICATION); + wndClass.hCursor =::LoadCursor(NULL,IDC_ARROW); + wndClass.hbrBackground =(HBRUSH)::GetStockObject(BLACK_BRUSH); + wndClass.lpszMenuName =smszMenuName; + wndClass.lpszClassName =smszClassName; + ::RegisterClass(&wndClass); + if(0==::GetClassInfo(mhInstance,smszClassName,(WNDCLASS FAR*)&wndClass))throw(NullError()); +} + +void WinTimer::createWindow(void) +{ + ::CreateWindow(smszClassName,smszMenuName, + WS_OVERLAPPED, + CW_USEDEFAULT,CW_USEDEFAULT, + CW_USEDEFAULT,CW_USEDEFAULT, + NULL,NULL,mhInstance,(LPSTR)this); + show(SW_HIDE); + update(); +} + +WORD WinTimer::startTimer(UINT delayTime) +{ + if(!(HWND)*this)return FALSE; + if(TimerID==mTimerID)return FALSE; + return setTimer(mTimerID=TimerID,delayTime); +} + +WORD WinTimer::stopTimer(void) +{ + WORD returnCode(FALSE); + + if(!(HWND)*this)return returnCode; + if(InvalidID==mTimerID)return returnCode; + returnCode=killTimer(mTimerID); + mTimerID=InvalidID; + return returnCode; +} + +CallbackData::ReturnType WinTimer::timerHandler(CallbackData &someCallbackData) +{ + size_t size(mCallbackVector.size()); + + for(int vectorIndex=0;vectorIndex +#endif +#ifndef _COMMON_WINDOW_HPP_ +#include +#endif +#ifndef _COMMON_BLOCK_HPP_ +#include +#endif + +class WinTimer : public Window +{ +public: + WinTimer(HINSTANCE hProcessInstance); + WinTimer(const Window &someWindow); + ~WinTimer(); + WORD insertHandler(PureCallback *lpCallback); + void removeHandler(PureCallback *lpCallback); + WORD startTimer(UINT delayTime); + WORD stopTimer(void); + DWORD getSystemTime(void)const; +private: + enum {TimerID=0,InvalidID=32767}; + void initWinTimer(void); + void registerClass(void); + void createWindow(void); + + CallbackData::ReturnType timerHandler(CallbackData &someCallbackData); + Callback mTimerHandler; + Block mCallbackVector; + WORD mIsOkay; + UINT mTimerID; + HINSTANCE mhInstance; + static char smszClassName[]; + static char smszMenuName[]; +}; + +inline +DWORD WinTimer::getSystemTime(void)const +{ + return ::GetTickCount(); +} +#endif + + diff --git a/common/WINUSER.HPP b/common/WINUSER.HPP new file mode 100644 index 0000000..8960f2a --- /dev/null +++ b/common/WINUSER.HPP @@ -0,0 +1,4 @@ +#ifndef _COMMON_WINUSER_HPP_ +#define _COMMON_WINUSER_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/Widestr.cpp b/common/Widestr.cpp new file mode 100644 index 0000000..218696b --- /dev/null +++ b/common/Widestr.cpp @@ -0,0 +1,16 @@ +#include +#include +#include + +// Dynamic Dialog depends on this code, if modified make sure that DynamicDialog still works. + +void WideString::ansiToWideString(const String &ansiString) +{ + WinVersionInfo versionInfo; + + if(ansiString.isNull())return; + WORD ansiLength(ansiString.length()); + size(ansiLength+1); + for(long index=0;index +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif + +class WideString : public GlobalData +{ +public: + WideString(void); + WideString(const WideString &someWideString); + WideString(const String &ansiString); + ~WideString(); + WideString &operator=(const WideString &someWideString); + WideString &operator=(const String &ansiString); + WORD operator==(const WideString &someWideString)const; + WORD operator==(const String &ansiString)const; +private: + void ansiToWideString(const String &ansiString); +}; + +inline +WideString::WideString(void) +{ +} + +inline +WideString::WideString(const WideString &someWideString) +{ + *this=someWideString; +} + +inline +WideString::WideString(const String &ansiString) +{ + *this=ansiString; +} + +inline +WideString::~WideString() +{ +} + +inline +WideString &WideString::operator=(const WideString &someWideString) +{ + (GlobalData&)*this=(GlobalData&)someWideString; + return *this; +} + +inline +WideString &WideString::operator=(const String &ansiString) +{ + ansiToWideString(ansiString); + return *this; +} + +inline +WORD WideString::operator==(const WideString &someWideString)const +{ + return (GlobalData&)*this==(GlobalData&)someWideString; +} + +inline +WORD WideString::operator==(const String &ansiString)const +{ + WideString wideChar(ansiString); + return *this==wideChar; +} +#endif diff --git a/common/Windows.hpp b/common/Windows.hpp new file mode 100644 index 0000000..95245b2 --- /dev/null +++ b/common/Windows.hpp @@ -0,0 +1,49 @@ +#ifndef _COMMON_WINDOWS_HPP_ +#define _COMMON_WINDOWS_HPP_ +#define WIN32_LEAN_AND_MEAN +#define NOSERVICE +#define NOKANJI +#define NOCRYPT +#define NOMCX +#define NOLSTRING +#define NODBCS +#define NOMETAFILE +#define NOPROFILER +#define NOLANGUAGE +#define NOLOGERROR +#define NOMCX +#define NOIME +#define NOCOMM +#include +typedef unsigned short USHORT; +#ifndef DS_3DLOOK +#define DS_3DLOOK 0x0004L +#endif +#ifndef PFD_GENERIC_ACCELERATED +#define PFD_GENERIC_ACCELERATED 0x00001000 +#endif +#ifndef PFD_SWAP_LAYER_BUFFERS +#define PFD_SWAP_LAYER_BUFFERS 0x00000800 +#endif +#ifndef PFD_DEPTH_DONTCARE +#define PFD_DEPTH_DONTCARE 0x20000000 +#endif +#ifndef EN_MSGFILTER +#define EN_MSGFILTER 0x0700 +#endif +#ifndef EN_REQUESTRESIZE +#define EN_REQUESTRESIZE 0x0701 +#endif +#ifndef EN_SELCHANGE +#define EN_SELCHANGE 0x0702 +#endif +#ifndef EN_DROPFILES +#define EN_DROPFILES 0x0703 +#endif +#ifndef EN_PROTECTED +#define EN_PROTECTED 0x0704 +#endif +#endif +#ifndef IMAGE_DIRECTORY_ENTRY_COPYRIGHT +#define IMAGE_DIRECTORY_ENTRY_COPYRIGHT IMAGE_DIRECTORY_ENTRY_ARCHITECTURE +#endif diff --git a/common/Winsock.hpp b/common/Winsock.hpp new file mode 100644 index 0000000..9d4a76c --- /dev/null +++ b/common/Winsock.hpp @@ -0,0 +1,11 @@ +#ifndef _COMMON_WINSOCK_HPP_ +#define _COMMON_WINSOCK_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#include +#include +#include +#include +#include +#endif diff --git a/common/accelerator.cpp b/common/accelerator.cpp new file mode 100644 index 0000000..e4c8486 --- /dev/null +++ b/common/accelerator.cpp @@ -0,0 +1,69 @@ +#include +#include + +Accelerator::Accelerator() +: mhAccelerator(0) +{ +} + +Accelerator::Accelerator(const String &strTableName,HINSTANCE hInstance) +: mhAccelerator(0) +{ + mhAccelerator=::LoadAccelerators(hInstance,strTableName); +} + +Accelerator::Accelerator(UINT resID,HINSTANCE hInstance) +: mhAccelerator(0) +{ + mhAccelerator=::LoadAccelerators(hInstance,MAKEINTRESOURCE(resID)); +} + +Accelerator::~Accelerator() +{ + destroy(); +} + +Accelerator &Accelerator::operator=(const Accelerator &/*accelerator*/) +{ + return *this; +} + +bool Accelerator::loadAccelerators(const String &strTableName,HINSTANCE hInstance) +{ + destroy(); + mhAccelerator=::LoadAccelerators(hInstance,strTableName); + return true; +} + +bool Accelerator::loadAccelerators(UINT resID,HINSTANCE hInstance) +{ + destroy(); + mhAccelerator=::LoadAccelerators(hInstance,MAKEINTRESOURCE(resID)); + return true; +} + +bool Accelerator::translate(const GUIWindow &parent,MSG &msg)const +{ + if(!isOkay())return false; + return ::TranslateAccelerator(parent,mhAccelerator,&msg); +} + +bool Accelerator::translateMDISysAccelerator(const GUIWindow &parent,MSG &msg)const +{ + HWND hClient; + if(!isOkay())return false; + hClient=parent.getChild(); + return ::TranslateMDISysAccel(hClient,&msg); +} + +void Accelerator::destroy() +{ + if(!isOkay())return; + ::DestroyAcceleratorTable(mhAccelerator); + mhAccelerator=0; +} + +bool Accelerator::isOkay(void)const +{ + return mhAccelerator?true:false; +} diff --git a/common/calendar.cpp b/common/calendar.cpp new file mode 100644 index 0000000..1e3f8eb --- /dev/null +++ b/common/calendar.cpp @@ -0,0 +1,91 @@ +#include +#include +#include + +CalendarControl::CalendarControl(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID) +: mParentWnd(parentWnd), Control(hControlWnd,controlID) +{ + mNotifyHandler.setCallback(this,&CalendarControl::notifyHandler); + parentWnd.insertHandler(VectorHandler::NotifyHandler,&mNotifyHandler); + CommonControlsEx commonControlsEx; + commonControlsEx.flags(CommonControlsEx::InitDate); + commonControlsEx.initCommonControlsEx(); +} + +CalendarControl::CalendarControl(GUIWindow &parentWnd,UINT controlID,const Rect &initRect,DWORD style,DWORD styleEx) +: mParentWnd(parentWnd) +{ + CommonControlsEx commonControlsEx; + commonControlsEx.flags(CommonControlsEx::InitDate); + commonControlsEx.initCommonControlsEx(); + mNotifyHandler.setCallback(this,&CalendarControl::notifyHandler); + parentWnd.insertHandler(VectorHandler::NotifyHandler,&mNotifyHandler); + createControl(styleEx,MONTHCAL_CLASS,"",style,initRect,parentWnd,controlID); +} + +CalendarControl::~CalendarControl() +{ +} + +bool CalendarControl::resize(void) +{ + Rect minRect; + + if(!isValid())return false; + getMinReqRect(minRect); + width(minRect.right()); + height(minRect.bottom()); + return true; +} + +CallbackData::ReturnType CalendarControl::notifyHandler(CallbackData &someCallbackData) +{ + if(controlID()!=someCallbackData.wParam())return FALSE; + NMHDR *pNotifyHeader=(NMHDR*)someCallbackData.lParam(); + switch(pNotifyHeader->code) + { + case MCN_SELCHANGE : + { + NMSELCHANGE *pSelChange=((NMSELCHANGE*)someCallbackData.lParam()); + handleSelChange(*pSelChange); + mSelChangeHandler.callback(CallbackData(0,(LPARAM)pSelChange)); + } + case MCN_GETDAYSTATE : + { + NMDAYSTATE *pDayState=((NMDAYSTATE*)someCallbackData.lParam()); + handleDayState(*pDayState); + mDayStateHandler.callback(CallbackData(0,(LPARAM)pDayState)); + } + case MCN_SELECT : + { + NMSELCHANGE *pSelChange=((NMSELCHANGE*)someCallbackData.lParam()); + handleSelect(*((NMSELCHANGE*)someCallbackData.lParam())); + mSelectHandler.callback(CallbackData(0,(LPARAM)pSelChange)); + } + case MCN_FIRST : + break; + case MCN_LAST : + break; + + } + return FALSE; +} + +// virtuals + +bool CalendarControl::handleSelChange(NMSELCHANGE &nmSelChange) +{ + return false; +} + +bool CalendarControl::handleDayState(NMDAYSTATE &nmDayState) +{ + return false; +} + +bool CalendarControl::handleSelect(NMSELCHANGE &nmSelChange) +{ + return false; +} + + diff --git a/common/calendar.hpp b/common/calendar.hpp new file mode 100644 index 0000000..0db58ca --- /dev/null +++ b/common/calendar.hpp @@ -0,0 +1,107 @@ +#ifndef _COMMON_CALENDARCONTROL_HPP_ +#define _COMMON_CALENDARCONTROL_HPP_ +#ifndef _COMMON_CONTROL_HPP_ +#include +#endif +#ifndef _COMMON_COMMCTRL_HPP_ +#include +#endif +#ifndef _COMMON_RGBCOLOR_HPP_ +#include +#endif +#ifndef _COMMON_SYSTEMTIME_HPP_ +#include +#endif + +class CalendarControl : public Control +{ +public: + enum CalendarStyles{DayState=MCS_DAYSTATE,MultiSelect=MCS_MULTISELECT,NoToday=MCS_NOTODAY,NoTodayCircle=MCS_NOTODAYCIRCLE,WeekNumbers=MCS_WEEKNUMBERS}; + enum ColorProp{BkGnd=MCSC_BACKGROUND,Text=MCSC_TEXT,BkTitle=MCSC_TITLEBK,FgTitle=MCSC_TITLETEXT,BkMonth=MCSC_MONTHBK,TrailText=MCSC_TRAILINGTEXT}; + CalendarControl(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID); + CalendarControl(GUIWindow &parentWnd,UINT controlID,const Rect &initRect=Rect(),DWORD style=WS_CLIPCHILDREN|WS_CLIPSIBLINGS|MCS_DAYSTATE,DWORD styleEx=0); + virtual ~CalendarControl(); + bool getMinReqRect(Rect &minReqRect)const; + bool setColor(ColorProp colorProp,const RGBColor &color); + bool getDate(SystemTime &systemTime)const; + bool setDate(const SystemTime &systemTime)const; + bool setCurrent(const SystemTime &systemTime)const; + bool getCurrent(SystemTime &systemTime)const; + bool resize(void); + void setSelChangeHandler(PureCallback *pSelChangeHandler); + void setDayStateHandler(PureCallback *pDayStateHandler); + void setSelectHandler(PureCallback *pSelectHandler); +protected: + virtual bool handleSelChange(NMSELCHANGE &nmSelChange); + virtual bool handleDayState(NMDAYSTATE &nmDayState); + virtual bool handleSelect(NMSELCHANGE &nmSelChange); +private: + CallbackData::ReturnType notifyHandler(CallbackData &someCallbackData); + + Callback mNotifyHandler; + CallbackPointer mSelChangeHandler; + CallbackPointer mDayStateHandler; + CallbackPointer mSelectHandler; + GUIWindow &mParentWnd; +}; + +inline +bool CalendarControl::getMinReqRect(Rect &minReqRect)const +{ + if(!isValid())return false; + return sendMessage(MCM_GETMINREQRECT,0,(LPARAM)(LONG)&minReqRect.getRect()); +} + +inline +bool CalendarControl::setColor(ColorProp colorProp,const RGBColor &color) +{ + if(!isValid())return false; + return sendMessage(MCM_SETCOLOR,colorProp,COLORREF(color)); +} + +inline +bool CalendarControl::getDate(SystemTime &systemTime)const +{ + if(!isValid())return false; + return sendMessage(MCM_GETTODAY,0,(LPARAM)(LONG)&systemTime.getSYSTEMTIME()); +} + +inline +bool CalendarControl::setDate(const SystemTime &systemTime)const +{ + if(!isValid())return false; + return sendMessage(MCM_SETTODAY,0,(LPARAM)(LONG)&((SystemTime&)systemTime).getSYSTEMTIME()); +} + +inline +bool CalendarControl::setCurrent(const SystemTime &systemTime)const +{ + if(!isValid())return false; + return sendMessage(MCM_SETCURSEL,0,(LPARAM)(LONG)&((SystemTime&)systemTime).getSYSTEMTIME()); +} + +inline +bool CalendarControl::getCurrent(SystemTime &systemTime)const +{ + if(!isValid())return false; + return sendMessage(MCM_GETCURSEL,0,(LPARAM)(LONG)&systemTime.getSYSTEMTIME()); +} + +inline +void CalendarControl::setSelChangeHandler(PureCallback *pSelChangeHandler) +{ + mSelChangeHandler=CallbackPointer(pSelChangeHandler); +} + +inline +void CalendarControl::setDayStateHandler(PureCallback *pDayStateHandler) +{ + mDayStateHandler=CallbackPointer(pDayStateHandler); +} + +inline +void CalendarControl::setSelectHandler(PureCallback *pSelectHandler) +{ + mSelectHandler=CallbackPointer(pSelectHandler); +} +#endif \ No newline at end of file diff --git a/common/common.001 b/common/common.001 new file mode 100644 index 0000000..ed08396 --- /dev/null +++ b/common/common.001 @@ -0,0 +1,791 @@ +# Microsoft Developer Studio Project File - Name="common" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 5.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Static Library" 0x0104 + +CFG=common - 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 "common.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 "common.mak" CFG="common - Win32 Release" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "common - Win32 Release" (based on "Win32 (x86) Static Library") +!MESSAGE "common - Win32 Debug" (based on "Win32 (x86) Static Library") +!MESSAGE + +# Begin Project +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe + +!IF "$(CFG)" == "common - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir ".\Release" +# PROP BASE Intermediate_Dir ".\Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir ".\Release" +# PROP Intermediate_Dir ".\Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c +# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c +BSC32=bscmake.exe +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ELSEIF "$(CFG)" == "common - 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 /Z7 /Od /I "\work" /I "\parts" /D "WIN32" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /D "_DEBUG" /Fp"\work\exe\msvc42.pch" /YX"windows.h" /FD /I /work" /I /parts" /I /work" /I /parts" " " " " /c +BSC32=bscmake.exe +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo /out:"..\exe\mscommon.lib" + +!ENDIF + +# Begin Target + +# Name "common - Win32 Release" +# Name "common - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" +# Begin Source File + +SOURCE=.\Bitmap.cpp +# End Source File +# Begin Source File + +SOURCE=.\Bmdata.cpp + +!IF "$(CFG)" == "common - Win32 Release" + +!ELSEIF "$(CFG)" == "common - Win32 Debug" + +# ADD CPP /YX + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=.\Bminfo.cpp +# End Source File +# Begin Source File + +SOURCE=.\Bmplnk.cpp +# End Source File +# Begin Source File + +SOURCE=.\Brush.cpp +# End Source File +# Begin Source File + +SOURCE=.\Btnlnk.cpp +# End Source File +# Begin Source File + +SOURCE=.\calendar.cpp +# End Source File +# Begin Source File + +SOURCE=.\Catmull.cpp +# End Source File +# Begin Source File + +SOURCE=.\Cbdata.cpp +# End Source File +# Begin Source File + +SOURCE=.\Cbdatahk.cpp +# End Source File +# Begin Source File + +SOURCE=.\Clipbrd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Console.cpp +# End Source File +# Begin Source File + +SOURCE=.\Control.cpp +# End Source File +# Begin Source File + +SOURCE=.\Crsctrl.cpp +# End Source File +# Begin Source File + +SOURCE=.\Ddemsg.cpp +# End Source File +# Begin Source File + +SOURCE=.\Dib.cpp +# End Source File +# Begin Source File + +SOURCE=.\Diskinfo.cpp +# End Source File +# Begin Source File + +SOURCE=.\Drawbmp.cpp +# End Source File +# Begin Source File + +SOURCE=.\Dwindow.cpp +# End Source File +# Begin Source File + +SOURCE=.\elastic.cpp +# End Source File +# Begin Source File + +SOURCE=.\errormsg.cpp +# End Source File +# Begin Source File + +SOURCE=.\File.cpp +# End Source File +# Begin Source File + +SOURCE=.\Fileio.cpp +# End Source File +# Begin Source File + +SOURCE=.\Filemap.cpp +# End Source File +# Begin Source File + +SOURCE=.\Finddata.cpp +# End Source File +# Begin Source File + +SOURCE=.\Font.cpp +# End Source File +# Begin Source File + +SOURCE=.\gdipoint.cpp +# End Source File +# Begin Source File + +SOURCE=.\Guiwnd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Hookproc.cpp +# End Source File +# Begin Source File + +SOURCE=.\Iconfrm.cpp +# End Source File +# Begin Source File + +SOURCE=.\Infowin.cpp +# End Source File +# Begin Source File + +SOURCE=.\Intel.cpp +# End Source File +# Begin Source File + +SOURCE=.\Iobuff.cpp +# End Source File +# Begin Source File + +SOURCE=.\Logowin.cpp +# End Source File +# Begin Source File + +SOURCE=.\Macro.cpp +# End Source File +# Begin Source File + +SOURCE=.\Math.cpp +# End Source File +# Begin Source File + +SOURCE=.\Mdifrm.cpp +# End Source File +# Begin Source File + +SOURCE=.\Mdiwin.cpp +# End Source File +# Begin Source File + +SOURCE=.\Memfile.cpp +# End Source File +# Begin Source File + +SOURCE=.\Mmtimer.cpp +# End Source File +# Begin Source File + +SOURCE=..\Exe\msbsp.lib +# End Source File +# Begin Source File + +SOURCE=.\msvcobj\msfix32.obj +# End Source File +# Begin Source File + +SOURCE=.\Odbutton.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odlist.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odlstalt.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odlstchk.cpp +# End Source File +# Begin Source File + +SOURCE=.\opendlg.Cpp +# End Source File +# Begin Source File + +SOURCE=.\Openfile.cpp +# End Source File +# Begin Source File + +SOURCE=.\opndlgex.cpp +# End Source File +# Begin Source File + +SOURCE=.\Owner.cpp +# End Source File +# Begin Source File + +SOURCE=.\Pathfnd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Point.cpp +# End Source File +# Begin Source File + +SOURCE=.\Process.cpp +# End Source File +# Begin Source File + +SOURCE=.\Profile.cpp +# End Source File +# Begin Source File + +SOURCE=.\Progress.cpp +# End Source File +# Begin Source File + +SOURCE=.\Purebmp.cpp +# End Source File +# Begin Source File + +SOURCE=.\Purebyte.cpp +# End Source File +# Begin Source File + +SOURCE=.\puredbl.cpp +# End Source File +# Begin Source File + +SOURCE=.\Puredwrd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Purehdc.cpp +# End Source File +# Begin Source File + +SOURCE=.\puremenu.Cpp +# End Source File +# Begin Source File + +SOURCE=.\Purepal.cpp +# End Source File +# Begin Source File + +SOURCE=.\purewrd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Pview.cpp +# End Source File +# Begin Source File + +SOURCE=.\Regkey.cpp +# End Source File +# Begin Source File + +SOURCE=.\resbmp.cpp +# End Source File +# Begin Source File + +SOURCE=.\Richedit.cpp +# End Source File +# Begin Source File + +SOURCE=.\rubber.cpp +# End Source File +# Begin Source File + +SOURCE=.\Sdate.cpp +# End Source File +# Begin Source File + +SOURCE=.\Smrtstrm.cpp +# End Source File +# Begin Source File + +SOURCE=.\snapshot.cpp +# End Source File +# Begin Source File + +SOURCE=.\static.cpp +# End Source File +# Begin Source File + +SOURCE=.\String.cpp +# End Source File +# Begin Source File + +SOURCE=.\Systime.cpp +# End Source File +# Begin Source File + +SOURCE=.\Vhandler.cpp +# End Source File +# Begin Source File + +SOURCE=.\Vxdctrl.cpp +# End Source File +# Begin Source File + +SOURCE=.\widestr.Cpp +# End Source File +# Begin Source File + +SOURCE=.\Window.cpp +# End Source File +# Begin Source File + +SOURCE=.\Wintimer.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" +# Begin Source File + +SOURCE=.\Assert.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bitmap.hpp +# End Source File +# Begin Source File + +SOURCE=.\Block.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bmdata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bminfo.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bmplnk.hpp +# End Source File +# Begin Source File + +SOURCE=.\Boverlay.hpp +# End Source File +# Begin Source File + +SOURCE=.\Btnlnk.hpp +# End Source File +# Begin Source File + +SOURCE=.\Callback.hpp +# End Source File +# Begin Source File + +SOURCE=.\Catmull.hpp +# End Source File +# Begin Source File + +SOURCE=.\Cbdata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Cbptr.hpp +# End Source File +# Begin Source File + +SOURCE=.\Cflags.hpp +# End Source File +# Begin Source File + +SOURCE=.\Commctrl.hpp +# End Source File +# Begin Source File + +SOURCE=.\commdlg.hpp +# End Source File +# Begin Source File + +SOURCE=.\Console.hpp +# End Source File +# Begin Source File + +SOURCE=.\control.hpp +# End Source File +# Begin Source File + +SOURCE=.\crsctrl.hpp +# End Source File +# Begin Source File + +SOURCE=.\Dde.hpp +# End Source File +# Begin Source File + +SOURCE=.\Ddeack.hpp +# End Source File +# Begin Source File + +SOURCE=.\Ddedata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Ddemsg.hpp +# End Source File +# Begin Source File + +SOURCE=.\Dib.hpp +# End Source File +# Begin Source File + +SOURCE=.\diskinfo.hpp +# End Source File +# Begin Source File + +SOURCE=.\Drawbmp.hpp +# End Source File +# Begin Source File + +SOURCE=.\Dwindow.hpp +# End Source File +# Begin Source File + +SOURCE=.\elastic.hpp +# End Source File +# Begin Source File + +SOURCE=.\Fileblck.hpp +# End Source File +# Begin Source File + +SOURCE=.\Fileio.hpp +# End Source File +# Begin Source File + +SOURCE=.\filemap.hpp +# End Source File +# Begin Source File + +SOURCE=.\Filetime.hpp +# End Source File +# Begin Source File + +SOURCE=.\Finddata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Fixup.hpp +# End Source File +# Begin Source File + +SOURCE=.\Font.hpp +# End Source File +# Begin Source File + +SOURCE=.\Gdata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Gdiobj.hpp +# End Source File +# Begin Source File + +SOURCE=.\Gdipoint.hpp +# End Source File +# Begin Source File + +SOURCE=.\Heap.hpp +# End Source File +# Begin Source File + +SOURCE=.\Heapnew.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iconbmp.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iconfrm.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iconinfo.hpp +# End Source File +# Begin Source File + +SOURCE=.\Infowin.hpp +# End Source File +# Begin Source File + +SOURCE=.\Instance.hpp +# End Source File +# Begin Source File + +SOURCE=.\Intel.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iobuff.hpp +# End Source File +# Begin Source File + +SOURCE=.\Logowin.hpp +# End Source File +# Begin Source File + +SOURCE=.\Macro.hpp +# End Source File +# Begin Source File + +SOURCE=.\math.hpp +# End Source File +# Begin Source File + +SOURCE=.\Memfile.hpp +# End Source File +# Begin Source File + +SOURCE=.\Menuitem.hpp +# End Source File +# Begin Source File + +SOURCE=.\Mmsystem.hpp +# End Source File +# Begin Source File + +SOURCE=.\Mmtimer.hpp +# End Source File +# Begin Source File + +SOURCE=.\opendlg.Hpp +# End Source File +# Begin Source File + +SOURCE=.\Openfile.hpp +# End Source File +# Begin Source File + +SOURCE=.\Owner.hpp +# End Source File +# Begin Source File + +SOURCE=.\Palentry.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pathfnd.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pcallbck.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pen.hpp +# End Source File +# Begin Source File + +SOURCE=.\Point.hpp +# End Source File +# Begin Source File + +SOURCE=.\Process.hpp +# End Source File +# Begin Source File + +SOURCE=.\Profile.hpp +# End Source File +# Begin Source File + +SOURCE=.\Progress.hpp +# End Source File +# Begin Source File + +SOURCE=.\Purebmp.hpp +# End Source File +# Begin Source File + +SOURCE=.\purebyte.hpp +# End Source File +# Begin Source File + +SOURCE=.\puredwrd.hpp +# End Source File +# Begin Source File + +SOURCE=.\Purehdc.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pureicon.hpp +# End Source File +# Begin Source File + +SOURCE=.\Puremenu.hpp +# End Source File +# Begin Source File + +SOURCE=.\Purepal.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pureprcs.hpp +# End Source File +# Begin Source File + +SOURCE=.\purewrd.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pvector.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pview.hpp +# End Source File +# Begin Source File + +SOURCE=.\Rect.hpp +# End Source File +# Begin Source File + +SOURCE=.\Rgbcolor.hpp +# End Source File +# Begin Source File + +SOURCE=.\Rgbquad.hpp +# End Source File +# Begin Source File + +SOURCE=.\rubber.hpp +# End Source File +# Begin Source File + +SOURCE=.\smrtstrm.hpp +# End Source File +# Begin Source File + +SOURCE=.\Stdlib.hpp +# End Source File +# Begin Source File + +SOURCE=.\String.hpp +# End Source File +# Begin Source File + +SOURCE=.\Systime.hpp +# End Source File +# Begin Source File + +SOURCE=.\Types.hpp +# End Source File +# Begin Source File + +SOURCE=.\Vhandler.hpp +# End Source File +# Begin Source File + +SOURCE=.\widestr.Hpp +# End Source File +# Begin Source File + +SOURCE=.\Window.hpp +# End Source File +# Begin Source File + +SOURCE=.\Windows.hpp +# End Source File +# Begin Source File + +SOURCE=.\Windowsx.hpp +# End Source File +# Begin Source File + +SOURCE=.\Wingblt.hpp +# End Source File +# Begin Source File + +SOURCE=.\Wintimer.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 +# Begin Source File + +SOURCE=.\Block.tpp +# End Source File +# Begin Source File + +SOURCE=.\Callback.tpp +# End Source File +# Begin Source File + +SOURCE=.\Gdata.tpp +# End Source File +# Begin Source File + +SOURCE=.\Pvector.tpp +# End Source File +# End Target +# End Project diff --git a/common/common.dep b/common/common.dep new file mode 100644 index 0000000..51b4909 --- /dev/null +++ b/common/common.dep @@ -0,0 +1,1614 @@ +# Microsoft Developer Studio Generated Dependency File, included by common.mak + +.\accelerator.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Bitmap.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + "..\bsptree\Btree.hpp"\ + "..\bsptree\Btree.tpp"\ + "..\bsptree\Colorkey.hpp"\ + "..\bsptree\Rgbndx.hpp"\ + "..\bsptree\Rgbstack.hpp"\ + "..\bsptree\Rgbtree.hpp"\ + "..\bsptree\Treendex.hpp"\ + "..\bsptree\Treenode.hpp"\ + "..\bsptree\Treenode.tpp"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bitmap.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bmdata.hpp"\ + ".\Bminfo.hpp"\ + ".\Boverlay.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Intel.hpp"\ + ".\Memfile.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Bmdata.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Bmdata.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Bminfo.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bminfo.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Bmplnk.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Bmplnk.hpp"\ + ".\Drawbmp.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Brush.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bminfo.hpp"\ + ".\brush.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\resbmp.hpp"\ + ".\resdata.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Btnlnk.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bminfo.hpp"\ + ".\Btnlnk.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\calendar.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\calendar.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\comctlex.hpp"\ + ".\Commctrl.hpp"\ + ".\control.hpp"\ + ".\except.hpp"\ + ".\Filetime.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Catmull.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Catmull.hpp"\ + ".\except.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Cbdata.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Cbdata.hpp"\ + ".\except.hpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Cbdatahk.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Cbdata.hpp"\ + ".\cbdatahk.hpp"\ + ".\Gdipoint.hpp"\ + ".\Point.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Clipbrd.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\clipbrd.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Console.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Console.hpp"\ + ".\coord.hpp"\ + ".\scrnbuff.hpp"\ + ".\smrect.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Control.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\control.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Crsctrl.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\crsctrl.hpp"\ + ".\Windows.hpp"\ + + +.\Ddemsg.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Dde.hpp"\ + ".\Ddeack.hpp"\ + ".\Ddedata.hpp"\ + ".\Ddemsg.hpp"\ + ".\Gdipoint.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Dib.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bitmap.hpp"\ + ".\Bmdata.hpp"\ + ".\Bminfo.hpp"\ + ".\Boverlay.hpp"\ + ".\Dib.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\math.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\resbmp.hpp"\ + ".\resdata.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\vector2d.hpp"\ + ".\Windows.hpp"\ + + +.\Diskinfo.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\diskinfo.hpp"\ + ".\except.hpp"\ + ".\Filetime.hpp"\ + ".\Finddata.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Drawbmp.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Drawbmp.hpp"\ + ".\Windows.hpp"\ + + +.\Dwindow.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Dde.hpp"\ + ".\Dwindow.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Instance.hpp"\ + ".\Mmsystem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\elastic.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\control.hpp"\ + ".\elastic.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\rubber.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\errormsg.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\errormsg.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\File.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\file.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Fileio.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Fileio.hpp"\ + ".\Intel.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Filemap.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\filemap.hpp"\ + ".\Filetime.hpp"\ + ".\Openfile.hpp"\ + ".\overlap.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Finddata.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Filetime.hpp"\ + ".\Finddata.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Font.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\gdipoint.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Gdipoint.hpp"\ + ".\Windows.hpp"\ + + +.\Guiwnd.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\commdlg.hpp"\ + ".\Dwindow.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Instance.hpp"\ + ".\Menuitem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purehdc.hpp"\ + ".\Puremenu.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Hookproc.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\cbdatahk.hpp"\ + ".\Cbptr.hpp"\ + ".\Dde.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\hookproc.hpp"\ + ".\Mmsystem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Iconfrm.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Iconbmp.hpp"\ + ".\Iconfrm.hpp"\ + ".\Iconinfo.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Pureicon.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Infowin.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\except.hpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Infowin.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Intel.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Intel.hpp"\ + ".\Windows.hpp"\ + + +.\Iobuff.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Iobuff.hpp"\ + ".\Windows.hpp"\ + + +.\Logowin.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\crsctrl.hpp"\ + ".\Drawbmp.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Logowin.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Macro.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\diskinfo.hpp"\ + ".\except.hpp"\ + ".\Filetime.hpp"\ + ".\Finddata.hpp"\ + ".\Macro.hpp"\ + ".\regkey.hpp"\ + ".\regsam.hpp"\ + ".\shellapi.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Math.cpp : \ + ".\math.hpp"\ + + +.\Mdifrm.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Dde.hpp"\ + ".\Dwindow.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Instance.hpp"\ + ".\mdifrm.hpp"\ + ".\mdiwin.hpp"\ + ".\Menuitem.hpp"\ + ".\Mmsystem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Puremenu.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Mdiwin.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Dde.hpp"\ + ".\Dwindow.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Instance.hpp"\ + ".\mdifrm.hpp"\ + ".\mdiwin.hpp"\ + ".\Menuitem.hpp"\ + ".\Mmsystem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Puremenu.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Memfile.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Intel.hpp"\ + ".\Memfile.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Mmtimer.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Gdipoint.hpp"\ + ".\Mmsystem.hpp"\ + ".\Mmtimer.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Odbutton.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Commctrl.hpp"\ + ".\control.hpp"\ + ".\Dib.hpp"\ + ".\drawitem.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\measure.hpp"\ + ".\odbutton.hpp"\ + ".\Palentry.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\resbmp.hpp"\ + ".\resdata.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Odlist.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Commctrl.hpp"\ + ".\control.hpp"\ + ".\drawitem.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\measure.hpp"\ + ".\odlist.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\puredwrd.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\rubber.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Odlstalt.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\brush.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Commctrl.hpp"\ + ".\control.hpp"\ + ".\drawitem.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\odlist.hpp"\ + ".\odlstalt.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\rubber.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Odlstchk.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\brush.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Commctrl.hpp"\ + ".\control.hpp"\ + ".\drawitem.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\measure.hpp"\ + ".\odlist.hpp"\ + ".\odlstchk.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\rubber.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\opendlg.Cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\commdlg.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\opendlg.Hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Openfile.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Filetime.hpp"\ + ".\Openfile.hpp"\ + ".\overlap.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\opndlgex.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Commctrl.hpp"\ + ".\commdlg.hpp"\ + ".\Dwindow.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\notify.hpp"\ + ".\opendlg.Hpp"\ + ".\opndlgex.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Owner.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\Bmplnk.hpp"\ + ".\Btnlnk.hpp"\ + ".\Drawbmp.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Owner.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Pathfnd.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\diskinfo.hpp"\ + ".\except.hpp"\ + ".\Filetime.hpp"\ + ".\Finddata.hpp"\ + ".\Pathfnd.hpp"\ + ".\Profile.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Point.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Point.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Process.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Cflags.hpp"\ + ".\diskinfo.hpp"\ + ".\except.hpp"\ + ".\Filetime.hpp"\ + ".\Finddata.hpp"\ + ".\Pathfnd.hpp"\ + ".\Process.hpp"\ + ".\Profile.hpp"\ + ".\Pureprcs.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\version.hpp"\ + ".\Windows.hpp"\ + + +.\Profile.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\diskinfo.hpp"\ + ".\except.hpp"\ + ".\Filetime.hpp"\ + ".\Finddata.hpp"\ + ".\Pathfnd.hpp"\ + ".\Profile.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Progress.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Commctrl.hpp"\ + ".\except.hpp"\ + ".\Font.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Iconbmp.hpp"\ + ".\Iconfrm.hpp"\ + ".\Iconinfo.hpp"\ + ".\Mmsystem.hpp"\ + ".\Mmtimer.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Progress.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Pureicon.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Purebmp.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bminfo.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Purebyte.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\purebyte.hpp"\ + ".\Windows.hpp"\ + + +.\puredbl.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\puredbl.hpp"\ + ".\Windows.hpp"\ + + +.\Puredwrd.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\puredwrd.hpp"\ + ".\Windows.hpp"\ + + +.\Purehdc.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\brush.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\except.hpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\math.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purehdc.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\puremenu.Cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Dwindow.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Menuitem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Puremenu.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Purepal.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + "..\bsptree\Btree.hpp"\ + "..\bsptree\Btree.tpp"\ + "..\bsptree\Colorkey.hpp"\ + "..\bsptree\Rgbndx.hpp"\ + "..\bsptree\Rgbstack.hpp"\ + "..\bsptree\Rgbtree.hpp"\ + "..\bsptree\Treendex.hpp"\ + "..\bsptree\Treenode.hpp"\ + "..\bsptree\Treenode.tpp"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Bminfo.hpp"\ + ".\except.hpp"\ + ".\filemap.hpp"\ + ".\Filetime.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Openfile.hpp"\ + ".\overlap.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purebmp.hpp"\ + ".\puredwrd.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Pview.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\purewrd.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\purewrd.hpp"\ + ".\Windows.hpp"\ + + +.\Pview.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\except.hpp"\ + ".\filemap.hpp"\ + ".\puredwrd.hpp"\ + ".\Pview.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Regkey.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\regkey.hpp"\ + ".\regsam.hpp"\ + ".\shellapi.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\resbmp.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\array.hpp"\ + ".\Assert.hpp"\ + ".\Bminfo.hpp"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\Palentry.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\Purebmp.hpp"\ + ".\Purehdc.hpp"\ + ".\Purepal.hpp"\ + ".\Rect.hpp"\ + ".\resbmp.hpp"\ + ".\resdata.hpp"\ + ".\Rgbcolor.hpp"\ + ".\Rgbquad.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\Windows.hpp"\ + + +.\Richedit.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\array.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\charform.hpp"\ + ".\chrrange.hpp"\ + ".\control.hpp"\ + ".\except.hpp"\ + ".\fndtextx.hpp"\ + ".\Font.hpp"\ + ".\Gdiobj.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Pen.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Purehdc.hpp"\ + ".\range.hpp"\ + ".\Rect.hpp"\ + ".\Rgbcolor.hpp"\ + ".\riched.hpp"\ + ".\richedit.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + ".\winuser.hpp"\ + + +.\rubber.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\rubber.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Sdate.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\sdate.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Smrtstrm.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\smrtstrm.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\snapshot.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\library.hpp"\ + ".\pentry.hpp"\ + ".\snapshot.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\tlhelp32.hpp"\ + ".\version.hpp"\ + ".\Windows.hpp"\ + + +.\String.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\except.hpp"\ + ".\Macro.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Windows.hpp"\ + + +.\Systime.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Filetime.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\Windows.hpp"\ + + +.\Vhandler.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Vxdctrl.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\Filetime.hpp"\ + ".\Openfile.hpp"\ + ".\overlap.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Systime.hpp"\ + ".\version.hpp"\ + ".\vxdctrl.hpp"\ + ".\Windows.hpp"\ + + +.\widestr.Cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\except.hpp"\ + ".\Gdata.hpp"\ + ".\Gdata.tpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Types.hpp"\ + ".\version.hpp"\ + ".\widestr.Hpp"\ + ".\Windows.hpp"\ + ".\winnls.hpp"\ + + +.\Window.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\Dde.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Instance.hpp"\ + ".\Mmsystem.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + + +.\Wintimer.cpp : \ + "..\..\parts\mssdk\include\basetsd.h"\ + ".\accelerator.hpp"\ + ".\Block.hpp"\ + ".\Block.tpp"\ + ".\Callback.hpp"\ + ".\Callback.tpp"\ + ".\Cbdata.hpp"\ + ".\Cbptr.hpp"\ + ".\except.hpp"\ + ".\Gdipoint.hpp"\ + ".\guiwnd.hpp"\ + ".\Pcallbck.hpp"\ + ".\Point.hpp"\ + ".\pointer.hpp"\ + ".\Rect.hpp"\ + ".\stdio.hpp"\ + ".\Stdlib.hpp"\ + ".\String.hpp"\ + ".\Vhandler.hpp"\ + ".\Window.hpp"\ + ".\Windows.hpp"\ + ".\Windowsx.hpp"\ + ".\Wintimer.hpp"\ + diff --git a/common/common.dsp b/common/common.dsp new file mode 100644 index 0000000..0edf8ed --- /dev/null +++ b/common/common.dsp @@ -0,0 +1,794 @@ +# Microsoft Developer Studio Project File - Name="common" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Static Library" 0x0104 + +CFG=common - 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 "common.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 "common.mak" CFG="common - Win32 Release" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "common - Win32 Release" (based on "Win32 (x86) Static Library") +!MESSAGE "common - 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)" == "common - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir ".\Release" +# PROP BASE Intermediate_Dir ".\Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir ".\release" +# PROP Intermediate_Dir ".\release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c +# ADD CPP /nologo /Gz /MT /GX /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /YX /FD /c +# ADD BASE RSC /l 0x409 +# ADD RSC /l 0x409 +BSC32=bscmake.exe +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ELSEIF "$(CFG)" == "common - 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 /Gz /MTd /GX /Zi /Od /I "\work" /I "\parts" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /D "WIN32" /FR /FD /I /work" /I /parts" /I /work" /I /parts" " " " " /c +# SUBTRACT CPP /YX +# ADD BASE RSC /l 0x409 +# ADD RSC /l 0x409 +BSC32=bscmake.exe +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo /out:"..\exe\mscommon.lib" + +!ENDIF + +# Begin Target + +# Name "common - Win32 Release" +# Name "common - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" +# Begin Source File + +SOURCE=.\accelerator.cpp +# End Source File +# Begin Source File + +SOURCE=.\Bitmap.cpp +# End Source File +# Begin Source File + +SOURCE=.\Bmdata.cpp + +!IF "$(CFG)" == "common - Win32 Release" + +!ELSEIF "$(CFG)" == "common - Win32 Debug" + +# ADD CPP /YX + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=.\Bminfo.cpp +# End Source File +# Begin Source File + +SOURCE=.\Bmplnk.cpp +# End Source File +# Begin Source File + +SOURCE=.\Brush.cpp +# End Source File +# Begin Source File + +SOURCE=.\Btnlnk.cpp +# End Source File +# Begin Source File + +SOURCE=.\calendar.cpp +# End Source File +# Begin Source File + +SOURCE=.\Catmull.cpp +# End Source File +# Begin Source File + +SOURCE=.\Cbdata.cpp +# End Source File +# Begin Source File + +SOURCE=.\Cbdatahk.cpp +# End Source File +# Begin Source File + +SOURCE=.\Clipbrd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Console.cpp +# End Source File +# Begin Source File + +SOURCE=.\Control.cpp +# End Source File +# Begin Source File + +SOURCE=.\Crsctrl.cpp +# End Source File +# Begin Source File + +SOURCE=.\Ddemsg.cpp +# End Source File +# Begin Source File + +SOURCE=.\Dib.cpp +# End Source File +# Begin Source File + +SOURCE=.\Diskinfo.cpp +# End Source File +# Begin Source File + +SOURCE=.\Drawbmp.cpp +# End Source File +# Begin Source File + +SOURCE=.\Dwindow.cpp +# End Source File +# Begin Source File + +SOURCE=.\elastic.cpp +# End Source File +# Begin Source File + +SOURCE=.\errormsg.cpp +# End Source File +# Begin Source File + +SOURCE=.\File.cpp +# End Source File +# Begin Source File + +SOURCE=.\Fileio.cpp +# End Source File +# Begin Source File + +SOURCE=.\Filemap.cpp +# End Source File +# Begin Source File + +SOURCE=.\Finddata.cpp +# End Source File +# Begin Source File + +SOURCE=.\Font.cpp +# End Source File +# Begin Source File + +SOURCE=.\gdipoint.cpp +# End Source File +# Begin Source File + +SOURCE=.\Guiwnd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Hookproc.cpp +# End Source File +# Begin Source File + +SOURCE=.\Iconfrm.cpp +# End Source File +# Begin Source File + +SOURCE=.\Infowin.cpp +# End Source File +# Begin Source File + +SOURCE=.\Intel.cpp +# End Source File +# Begin Source File + +SOURCE=.\Iobuff.cpp +# End Source File +# Begin Source File + +SOURCE=.\Logowin.cpp +# End Source File +# Begin Source File + +SOURCE=.\Macro.cpp +# End Source File +# Begin Source File + +SOURCE=.\Math.cpp +# End Source File +# Begin Source File + +SOURCE=.\Mdifrm.cpp +# End Source File +# Begin Source File + +SOURCE=.\Mdiwin.cpp +# End Source File +# Begin Source File + +SOURCE=.\Memfile.cpp +# End Source File +# Begin Source File + +SOURCE=.\Mmtimer.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odbutton.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odlist.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odlstalt.cpp +# End Source File +# Begin Source File + +SOURCE=.\Odlstchk.cpp +# End Source File +# Begin Source File + +SOURCE=.\opendlg.Cpp +# End Source File +# Begin Source File + +SOURCE=.\Openfile.cpp +# End Source File +# Begin Source File + +SOURCE=.\opndlgex.cpp +# End Source File +# Begin Source File + +SOURCE=.\Owner.cpp +# End Source File +# Begin Source File + +SOURCE=.\Pathfnd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Point.cpp +# End Source File +# Begin Source File + +SOURCE=.\Process.cpp +# End Source File +# Begin Source File + +SOURCE=.\Profile.cpp +# End Source File +# Begin Source File + +SOURCE=.\Progress.cpp +# End Source File +# Begin Source File + +SOURCE=.\Purebmp.cpp +# End Source File +# Begin Source File + +SOURCE=.\Purebyte.cpp +# End Source File +# Begin Source File + +SOURCE=.\puredbl.cpp +# End Source File +# Begin Source File + +SOURCE=.\Puredwrd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Purehdc.cpp +# End Source File +# Begin Source File + +SOURCE=.\puremenu.Cpp +# End Source File +# Begin Source File + +SOURCE=.\Purepal.cpp +# End Source File +# Begin Source File + +SOURCE=.\purewrd.cpp +# End Source File +# Begin Source File + +SOURCE=.\Pview.cpp +# End Source File +# Begin Source File + +SOURCE=.\Regkey.cpp +# End Source File +# Begin Source File + +SOURCE=.\resbmp.cpp +# End Source File +# Begin Source File + +SOURCE=.\Richedit.cpp +# End Source File +# Begin Source File + +SOURCE=.\rubber.cpp +# End Source File +# Begin Source File + +SOURCE=.\Sdate.cpp +# End Source File +# Begin Source File + +SOURCE=.\Smrtstrm.cpp +# End Source File +# Begin Source File + +SOURCE=.\snapshot.cpp +# End Source File +# Begin Source File + +SOURCE=.\static.cpp +# End Source File +# Begin Source File + +SOURCE=.\String.cpp +# End Source File +# Begin Source File + +SOURCE=.\Systime.cpp +# End Source File +# Begin Source File + +SOURCE=.\Vhandler.cpp +# End Source File +# Begin Source File + +SOURCE=.\Vxdctrl.cpp +# End Source File +# Begin Source File + +SOURCE=.\widestr.Cpp +# End Source File +# Begin Source File + +SOURCE=.\Window.cpp +# End Source File +# Begin Source File + +SOURCE=.\Wintimer.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" +# Begin Source File + +SOURCE=.\Assert.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bitmap.hpp +# End Source File +# Begin Source File + +SOURCE=.\Block.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bmdata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bminfo.hpp +# End Source File +# Begin Source File + +SOURCE=.\Bmplnk.hpp +# End Source File +# Begin Source File + +SOURCE=.\Boverlay.hpp +# End Source File +# Begin Source File + +SOURCE=.\Btnlnk.hpp +# End Source File +# Begin Source File + +SOURCE=.\Callback.hpp +# End Source File +# Begin Source File + +SOURCE=.\Catmull.hpp +# End Source File +# Begin Source File + +SOURCE=.\Cbdata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Cbptr.hpp +# End Source File +# Begin Source File + +SOURCE=.\Cflags.hpp +# End Source File +# Begin Source File + +SOURCE=.\Commctrl.hpp +# End Source File +# Begin Source File + +SOURCE=.\commdlg.hpp +# End Source File +# Begin Source File + +SOURCE=.\Console.hpp +# End Source File +# Begin Source File + +SOURCE=.\control.hpp +# End Source File +# Begin Source File + +SOURCE=.\crsctrl.hpp +# End Source File +# Begin Source File + +SOURCE=.\Dde.hpp +# End Source File +# Begin Source File + +SOURCE=.\Ddeack.hpp +# End Source File +# Begin Source File + +SOURCE=.\Ddedata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Ddemsg.hpp +# End Source File +# Begin Source File + +SOURCE=.\Dib.hpp +# End Source File +# Begin Source File + +SOURCE=.\diskinfo.hpp +# End Source File +# Begin Source File + +SOURCE=.\Drawbmp.hpp +# End Source File +# Begin Source File + +SOURCE=.\Dwindow.hpp +# End Source File +# Begin Source File + +SOURCE=.\elastic.hpp +# End Source File +# Begin Source File + +SOURCE=.\Fileblck.hpp +# End Source File +# Begin Source File + +SOURCE=.\Fileio.hpp +# End Source File +# Begin Source File + +SOURCE=.\filemap.hpp +# End Source File +# Begin Source File + +SOURCE=.\Filetime.hpp +# End Source File +# Begin Source File + +SOURCE=.\Finddata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Fixup.hpp +# End Source File +# Begin Source File + +SOURCE=.\Font.hpp +# End Source File +# Begin Source File + +SOURCE=.\Gdata.hpp +# End Source File +# Begin Source File + +SOURCE=.\Gdiobj.hpp +# End Source File +# Begin Source File + +SOURCE=.\Gdipoint.hpp +# End Source File +# Begin Source File + +SOURCE=.\Heap.hpp +# End Source File +# Begin Source File + +SOURCE=.\Heapnew.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iconbmp.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iconfrm.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iconinfo.hpp +# End Source File +# Begin Source File + +SOURCE=.\Infowin.hpp +# End Source File +# Begin Source File + +SOURCE=.\Instance.hpp +# End Source File +# Begin Source File + +SOURCE=.\Intel.hpp +# End Source File +# Begin Source File + +SOURCE=.\Iobuff.hpp +# End Source File +# Begin Source File + +SOURCE=.\Logowin.hpp +# End Source File +# Begin Source File + +SOURCE=.\Macro.hpp +# End Source File +# Begin Source File + +SOURCE=.\math.hpp +# End Source File +# Begin Source File + +SOURCE=.\Memfile.hpp +# End Source File +# Begin Source File + +SOURCE=.\Menuitem.hpp +# End Source File +# Begin Source File + +SOURCE=.\Mmsystem.hpp +# End Source File +# Begin Source File + +SOURCE=.\Mmtimer.hpp +# End Source File +# Begin Source File + +SOURCE=.\opendlg.Hpp +# End Source File +# Begin Source File + +SOURCE=.\Openfile.hpp +# End Source File +# Begin Source File + +SOURCE=.\Owner.hpp +# End Source File +# Begin Source File + +SOURCE=.\Palentry.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pathfnd.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pcallbck.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pen.hpp +# End Source File +# Begin Source File + +SOURCE=.\Point.hpp +# End Source File +# Begin Source File + +SOURCE=.\Process.hpp +# End Source File +# Begin Source File + +SOURCE=.\Profile.hpp +# End Source File +# Begin Source File + +SOURCE=.\Progress.hpp +# End Source File +# Begin Source File + +SOURCE=.\Purebmp.hpp +# End Source File +# Begin Source File + +SOURCE=.\purebyte.hpp +# End Source File +# Begin Source File + +SOURCE=.\puredwrd.hpp +# End Source File +# Begin Source File + +SOURCE=.\Purehdc.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pureicon.hpp +# End Source File +# Begin Source File + +SOURCE=.\Puremenu.hpp +# End Source File +# Begin Source File + +SOURCE=.\Purepal.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pureprcs.hpp +# End Source File +# Begin Source File + +SOURCE=.\purewrd.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pvector.hpp +# End Source File +# Begin Source File + +SOURCE=.\Pview.hpp +# End Source File +# Begin Source File + +SOURCE=.\Rect.hpp +# End Source File +# Begin Source File + +SOURCE=.\Rgbcolor.hpp +# End Source File +# Begin Source File + +SOURCE=.\Rgbquad.hpp +# End Source File +# Begin Source File + +SOURCE=.\rubber.hpp +# End Source File +# Begin Source File + +SOURCE=.\smrtstrm.hpp +# End Source File +# Begin Source File + +SOURCE=.\Stdlib.hpp +# End Source File +# Begin Source File + +SOURCE=.\String.hpp +# End Source File +# Begin Source File + +SOURCE=.\Systime.hpp +# End Source File +# Begin Source File + +SOURCE=.\Types.hpp +# End Source File +# Begin Source File + +SOURCE=.\Vhandler.hpp +# End Source File +# Begin Source File + +SOURCE=.\widestr.Hpp +# End Source File +# Begin Source File + +SOURCE=.\Window.hpp +# End Source File +# Begin Source File + +SOURCE=.\Windows.hpp +# End Source File +# Begin Source File + +SOURCE=.\Windowsx.hpp +# End Source File +# Begin Source File + +SOURCE=.\Wingblt.hpp +# End Source File +# Begin Source File + +SOURCE=.\Wintimer.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 +# Begin Source File + +SOURCE=.\Block.tpp +# End Source File +# Begin Source File + +SOURCE=.\Callback.tpp +# End Source File +# Begin Source File + +SOURCE=.\Gdata.tpp +# End Source File +# Begin Source File + +SOURCE=.\Pvector.tpp +# End Source File +# End Target +# End Project diff --git a/common/common.dsw b/common/common.dsw new file mode 100644 index 0000000..1dcb5a3 --- /dev/null +++ b/common/common.dsw @@ -0,0 +1,44 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "bsptree"=..\BSPTREE\bsptree.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Project: "common"=.\common.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ + Begin Project Dependency + Project_Dep_Name bsptree + End Project Dependency +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/common/common.mak b/common/common.mak new file mode 100644 index 0000000..fa52fb0 --- /dev/null +++ b/common/common.mak @@ -0,0 +1,859 @@ +# Microsoft Developer Studio Generated NMAKE File, Based on common.dsp +!IF "$(CFG)" == "" +CFG=common - Win32 Release +!MESSAGE No configuration specified. Defaulting to common - Win32 Release. +!ENDIF + +!IF "$(CFG)" != "common - Win32 Release" && "$(CFG)" != "common - Win32 Debug" +!MESSAGE Invalid configuration "$(CFG)" specified. +!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 "common.mak" CFG="common - Win32 Release" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "common - Win32 Release" (based on "Win32 (x86) Static Library") +!MESSAGE "common - 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 + +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "common - Win32 Release" + +OUTDIR=.\Release +INTDIR=.\Release +# Begin Custom Macros +OutDir=.\Release +# End Custom Macros + +ALL : "$(OUTDIR)\common.lib" + + +CLEAN : + -@erase "$(INTDIR)\accelerator.obj" + -@erase "$(INTDIR)\Bitmap.obj" + -@erase "$(INTDIR)\Bmdata.obj" + -@erase "$(INTDIR)\Bminfo.obj" + -@erase "$(INTDIR)\Bmplnk.obj" + -@erase "$(INTDIR)\Brush.obj" + -@erase "$(INTDIR)\Btnlnk.obj" + -@erase "$(INTDIR)\calendar.obj" + -@erase "$(INTDIR)\Catmull.obj" + -@erase "$(INTDIR)\Cbdata.obj" + -@erase "$(INTDIR)\Cbdatahk.obj" + -@erase "$(INTDIR)\Clipbrd.obj" + -@erase "$(INTDIR)\Console.obj" + -@erase "$(INTDIR)\Control.obj" + -@erase "$(INTDIR)\Crsctrl.obj" + -@erase "$(INTDIR)\Ddemsg.obj" + -@erase "$(INTDIR)\Dib.obj" + -@erase "$(INTDIR)\Diskinfo.obj" + -@erase "$(INTDIR)\Drawbmp.obj" + -@erase "$(INTDIR)\Dwindow.obj" + -@erase "$(INTDIR)\elastic.obj" + -@erase "$(INTDIR)\errormsg.obj" + -@erase "$(INTDIR)\File.obj" + -@erase "$(INTDIR)\Fileio.obj" + -@erase "$(INTDIR)\Filemap.obj" + -@erase "$(INTDIR)\Finddata.obj" + -@erase "$(INTDIR)\Font.obj" + -@erase "$(INTDIR)\gdipoint.obj" + -@erase "$(INTDIR)\Guiwnd.obj" + -@erase "$(INTDIR)\Hookproc.obj" + -@erase "$(INTDIR)\Iconfrm.obj" + -@erase "$(INTDIR)\Infowin.obj" + -@erase "$(INTDIR)\Intel.obj" + -@erase "$(INTDIR)\Iobuff.obj" + -@erase "$(INTDIR)\Logowin.obj" + -@erase "$(INTDIR)\Macro.obj" + -@erase "$(INTDIR)\Math.obj" + -@erase "$(INTDIR)\Mdifrm.obj" + -@erase "$(INTDIR)\Mdiwin.obj" + -@erase "$(INTDIR)\Memfile.obj" + -@erase "$(INTDIR)\Mmtimer.obj" + -@erase "$(INTDIR)\Odbutton.obj" + -@erase "$(INTDIR)\Odlist.obj" + -@erase "$(INTDIR)\Odlstalt.obj" + -@erase "$(INTDIR)\Odlstchk.obj" + -@erase "$(INTDIR)\opendlg.obj" + -@erase "$(INTDIR)\Openfile.obj" + -@erase "$(INTDIR)\opndlgex.obj" + -@erase "$(INTDIR)\Owner.obj" + -@erase "$(INTDIR)\Pathfnd.obj" + -@erase "$(INTDIR)\Point.obj" + -@erase "$(INTDIR)\Process.obj" + -@erase "$(INTDIR)\Profile.obj" + -@erase "$(INTDIR)\Progress.obj" + -@erase "$(INTDIR)\Purebmp.obj" + -@erase "$(INTDIR)\Purebyte.obj" + -@erase "$(INTDIR)\puredbl.obj" + -@erase "$(INTDIR)\Puredwrd.obj" + -@erase "$(INTDIR)\Purehdc.obj" + -@erase "$(INTDIR)\puremenu.obj" + -@erase "$(INTDIR)\Purepal.obj" + -@erase "$(INTDIR)\purewrd.obj" + -@erase "$(INTDIR)\Pview.obj" + -@erase "$(INTDIR)\Regkey.obj" + -@erase "$(INTDIR)\resbmp.obj" + -@erase "$(INTDIR)\Richedit.obj" + -@erase "$(INTDIR)\rubber.obj" + -@erase "$(INTDIR)\Sdate.obj" + -@erase "$(INTDIR)\Smrtstrm.obj" + -@erase "$(INTDIR)\snapshot.obj" + -@erase "$(INTDIR)\static.obj" + -@erase "$(INTDIR)\String.obj" + -@erase "$(INTDIR)\Systime.obj" + -@erase "$(INTDIR)\vc60.idb" + -@erase "$(INTDIR)\Vhandler.obj" + -@erase "$(INTDIR)\Vxdctrl.obj" + -@erase "$(INTDIR)\widestr.obj" + -@erase "$(INTDIR)\Window.obj" + -@erase "$(INTDIR)\Wintimer.obj" + -@erase "$(OUTDIR)\common.lib" + +"$(OUTDIR)" : + if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" + +CPP_PROJ=/nologo /MT /GX /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"$(INTDIR)\common.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c +BSC32=bscmake.exe +BSC32_FLAGS=/o"$(OUTDIR)\common.bsc" +BSC32_SBRS= \ + +LIB32=link.exe -lib +LIB32_FLAGS=/nologo /out:"$(OUTDIR)\common.lib" +LIB32_OBJS= \ + "$(INTDIR)\accelerator.obj" \ + "$(INTDIR)\Bitmap.obj" \ + "$(INTDIR)\Bmdata.obj" \ + "$(INTDIR)\Bminfo.obj" \ + "$(INTDIR)\Bmplnk.obj" \ + "$(INTDIR)\Brush.obj" \ + "$(INTDIR)\Btnlnk.obj" \ + "$(INTDIR)\calendar.obj" \ + "$(INTDIR)\Catmull.obj" \ + "$(INTDIR)\Cbdata.obj" \ + "$(INTDIR)\Cbdatahk.obj" \ + "$(INTDIR)\Clipbrd.obj" \ + "$(INTDIR)\Console.obj" \ + "$(INTDIR)\Control.obj" \ + "$(INTDIR)\Crsctrl.obj" \ + "$(INTDIR)\Ddemsg.obj" \ + "$(INTDIR)\Dib.obj" \ + "$(INTDIR)\Diskinfo.obj" \ + "$(INTDIR)\Drawbmp.obj" \ + "$(INTDIR)\Dwindow.obj" \ + "$(INTDIR)\elastic.obj" \ + "$(INTDIR)\errormsg.obj" \ + "$(INTDIR)\File.obj" \ + "$(INTDIR)\Fileio.obj" \ + "$(INTDIR)\Filemap.obj" \ + "$(INTDIR)\Finddata.obj" \ + "$(INTDIR)\Font.obj" \ + "$(INTDIR)\gdipoint.obj" \ + "$(INTDIR)\Guiwnd.obj" \ + "$(INTDIR)\Hookproc.obj" \ + "$(INTDIR)\Iconfrm.obj" \ + "$(INTDIR)\Infowin.obj" \ + "$(INTDIR)\Intel.obj" \ + "$(INTDIR)\Iobuff.obj" \ + "$(INTDIR)\Logowin.obj" \ + "$(INTDIR)\Macro.obj" \ + "$(INTDIR)\Math.obj" \ + "$(INTDIR)\Mdifrm.obj" \ + "$(INTDIR)\Mdiwin.obj" \ + "$(INTDIR)\Memfile.obj" \ + "$(INTDIR)\Mmtimer.obj" \ + "$(INTDIR)\Odbutton.obj" \ + "$(INTDIR)\Odlist.obj" \ + "$(INTDIR)\Odlstalt.obj" \ + "$(INTDIR)\Odlstchk.obj" \ + "$(INTDIR)\opendlg.obj" \ + "$(INTDIR)\Openfile.obj" \ + "$(INTDIR)\opndlgex.obj" \ + "$(INTDIR)\Owner.obj" \ + "$(INTDIR)\Pathfnd.obj" \ + "$(INTDIR)\Point.obj" \ + "$(INTDIR)\Process.obj" \ + "$(INTDIR)\Profile.obj" \ + "$(INTDIR)\Progress.obj" \ + "$(INTDIR)\Purebmp.obj" \ + "$(INTDIR)\Purebyte.obj" \ + "$(INTDIR)\puredbl.obj" \ + "$(INTDIR)\Puredwrd.obj" \ + "$(INTDIR)\Purehdc.obj" \ + "$(INTDIR)\puremenu.obj" \ + "$(INTDIR)\Purepal.obj" \ + "$(INTDIR)\purewrd.obj" \ + "$(INTDIR)\Pview.obj" \ + "$(INTDIR)\Regkey.obj" \ + "$(INTDIR)\resbmp.obj" \ + "$(INTDIR)\Richedit.obj" \ + "$(INTDIR)\rubber.obj" \ + "$(INTDIR)\Sdate.obj" \ + "$(INTDIR)\Smrtstrm.obj" \ + "$(INTDIR)\snapshot.obj" \ + "$(INTDIR)\static.obj" \ + "$(INTDIR)\String.obj" \ + "$(INTDIR)\Systime.obj" \ + "$(INTDIR)\Vhandler.obj" \ + "$(INTDIR)\Vxdctrl.obj" \ + "$(INTDIR)\widestr.obj" \ + "$(INTDIR)\Window.obj" \ + "$(INTDIR)\Wintimer.obj" + +"$(OUTDIR)\common.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS) + $(LIB32) @<< + $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS) +<< + +!ELSEIF "$(CFG)" == "common - Win32 Debug" + +OUTDIR=.\msvcobj +INTDIR=.\msvcobj + +ALL : "..\exe\mscommon.lib" + + +CLEAN : + -@erase "$(INTDIR)\accelerator.obj" + -@erase "$(INTDIR)\Bitmap.obj" + -@erase "$(INTDIR)\Bmdata.obj" + -@erase "$(INTDIR)\Bminfo.obj" + -@erase "$(INTDIR)\Bmplnk.obj" + -@erase "$(INTDIR)\Brush.obj" + -@erase "$(INTDIR)\Btnlnk.obj" + -@erase "$(INTDIR)\calendar.obj" + -@erase "$(INTDIR)\Catmull.obj" + -@erase "$(INTDIR)\Cbdata.obj" + -@erase "$(INTDIR)\Cbdatahk.obj" + -@erase "$(INTDIR)\Clipbrd.obj" + -@erase "$(INTDIR)\Console.obj" + -@erase "$(INTDIR)\Control.obj" + -@erase "$(INTDIR)\Crsctrl.obj" + -@erase "$(INTDIR)\Ddemsg.obj" + -@erase "$(INTDIR)\Dib.obj" + -@erase "$(INTDIR)\Diskinfo.obj" + -@erase "$(INTDIR)\Drawbmp.obj" + -@erase "$(INTDIR)\Dwindow.obj" + -@erase "$(INTDIR)\elastic.obj" + -@erase "$(INTDIR)\errormsg.obj" + -@erase "$(INTDIR)\File.obj" + -@erase "$(INTDIR)\Fileio.obj" + -@erase "$(INTDIR)\Filemap.obj" + -@erase "$(INTDIR)\Finddata.obj" + -@erase "$(INTDIR)\Font.obj" + -@erase "$(INTDIR)\gdipoint.obj" + -@erase "$(INTDIR)\Guiwnd.obj" + -@erase "$(INTDIR)\Hookproc.obj" + -@erase "$(INTDIR)\Iconfrm.obj" + -@erase "$(INTDIR)\Infowin.obj" + -@erase "$(INTDIR)\Intel.obj" + -@erase "$(INTDIR)\Iobuff.obj" + -@erase "$(INTDIR)\Logowin.obj" + -@erase "$(INTDIR)\Macro.obj" + -@erase "$(INTDIR)\Math.obj" + -@erase "$(INTDIR)\Mdifrm.obj" + -@erase "$(INTDIR)\Mdiwin.obj" + -@erase "$(INTDIR)\Memfile.obj" + -@erase "$(INTDIR)\Mmtimer.obj" + -@erase "$(INTDIR)\Odbutton.obj" + -@erase "$(INTDIR)\Odlist.obj" + -@erase "$(INTDIR)\Odlstalt.obj" + -@erase "$(INTDIR)\Odlstchk.obj" + -@erase "$(INTDIR)\opendlg.obj" + -@erase "$(INTDIR)\Openfile.obj" + -@erase "$(INTDIR)\opndlgex.obj" + -@erase "$(INTDIR)\Owner.obj" + -@erase "$(INTDIR)\Pathfnd.obj" + -@erase "$(INTDIR)\Point.obj" + -@erase "$(INTDIR)\Process.obj" + -@erase "$(INTDIR)\Profile.obj" + -@erase "$(INTDIR)\Progress.obj" + -@erase "$(INTDIR)\Purebmp.obj" + -@erase "$(INTDIR)\Purebyte.obj" + -@erase "$(INTDIR)\puredbl.obj" + -@erase "$(INTDIR)\Puredwrd.obj" + -@erase "$(INTDIR)\Purehdc.obj" + -@erase "$(INTDIR)\puremenu.obj" + -@erase "$(INTDIR)\Purepal.obj" + -@erase "$(INTDIR)\purewrd.obj" + -@erase "$(INTDIR)\Pview.obj" + -@erase "$(INTDIR)\Regkey.obj" + -@erase "$(INTDIR)\resbmp.obj" + -@erase "$(INTDIR)\Richedit.obj" + -@erase "$(INTDIR)\rubber.obj" + -@erase "$(INTDIR)\Sdate.obj" + -@erase "$(INTDIR)\Smrtstrm.obj" + -@erase "$(INTDIR)\snapshot.obj" + -@erase "$(INTDIR)\static.obj" + -@erase "$(INTDIR)\String.obj" + -@erase "$(INTDIR)\Systime.obj" + -@erase "$(INTDIR)\vc60.idb" + -@erase "$(INTDIR)\vc60.pdb" + -@erase "$(INTDIR)\Vhandler.obj" + -@erase "$(INTDIR)\Vxdctrl.obj" + -@erase "$(INTDIR)\widestr.obj" + -@erase "$(INTDIR)\Window.obj" + -@erase "$(INTDIR)\Wintimer.obj" + -@erase "..\exe\mscommon.lib" + +"$(OUTDIR)" : + if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" + +CPP_PROJ=/nologo /Gr /MDd /GX /Zi /Od /I "\work" /I "\parts" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /D "WIN32" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /I /work" /I /parts" /I /work" /I /parts" " " " " /c +BSC32=bscmake.exe +BSC32_FLAGS=/o"$(OUTDIR)\common.bsc" +BSC32_SBRS= \ + +LIB32=link.exe -lib +LIB32_FLAGS=/nologo /out:"..\exe\mscommon.lib" +LIB32_OBJS= \ + "$(INTDIR)\accelerator.obj" \ + "$(INTDIR)\Bitmap.obj" \ + "$(INTDIR)\Bmdata.obj" \ + "$(INTDIR)\Bminfo.obj" \ + "$(INTDIR)\Bmplnk.obj" \ + "$(INTDIR)\Brush.obj" \ + "$(INTDIR)\Btnlnk.obj" \ + "$(INTDIR)\calendar.obj" \ + "$(INTDIR)\Catmull.obj" \ + "$(INTDIR)\Cbdata.obj" \ + "$(INTDIR)\Cbdatahk.obj" \ + "$(INTDIR)\Clipbrd.obj" \ + "$(INTDIR)\Console.obj" \ + "$(INTDIR)\Control.obj" \ + "$(INTDIR)\Crsctrl.obj" \ + "$(INTDIR)\Ddemsg.obj" \ + "$(INTDIR)\Dib.obj" \ + "$(INTDIR)\Diskinfo.obj" \ + "$(INTDIR)\Drawbmp.obj" \ + "$(INTDIR)\Dwindow.obj" \ + "$(INTDIR)\elastic.obj" \ + "$(INTDIR)\errormsg.obj" \ + "$(INTDIR)\File.obj" \ + "$(INTDIR)\Fileio.obj" \ + "$(INTDIR)\Filemap.obj" \ + "$(INTDIR)\Finddata.obj" \ + "$(INTDIR)\Font.obj" \ + "$(INTDIR)\gdipoint.obj" \ + "$(INTDIR)\Guiwnd.obj" \ + "$(INTDIR)\Hookproc.obj" \ + "$(INTDIR)\Iconfrm.obj" \ + "$(INTDIR)\Infowin.obj" \ + "$(INTDIR)\Intel.obj" \ + "$(INTDIR)\Iobuff.obj" \ + "$(INTDIR)\Logowin.obj" \ + "$(INTDIR)\Macro.obj" \ + "$(INTDIR)\Math.obj" \ + "$(INTDIR)\Mdifrm.obj" \ + "$(INTDIR)\Mdiwin.obj" \ + "$(INTDIR)\Memfile.obj" \ + "$(INTDIR)\Mmtimer.obj" \ + "$(INTDIR)\Odbutton.obj" \ + "$(INTDIR)\Odlist.obj" \ + "$(INTDIR)\Odlstalt.obj" \ + "$(INTDIR)\Odlstchk.obj" \ + "$(INTDIR)\opendlg.obj" \ + "$(INTDIR)\Openfile.obj" \ + "$(INTDIR)\opndlgex.obj" \ + "$(INTDIR)\Owner.obj" \ + "$(INTDIR)\Pathfnd.obj" \ + "$(INTDIR)\Point.obj" \ + "$(INTDIR)\Process.obj" \ + "$(INTDIR)\Profile.obj" \ + "$(INTDIR)\Progress.obj" \ + "$(INTDIR)\Purebmp.obj" \ + "$(INTDIR)\Purebyte.obj" \ + "$(INTDIR)\puredbl.obj" \ + "$(INTDIR)\Puredwrd.obj" \ + "$(INTDIR)\Purehdc.obj" \ + "$(INTDIR)\puremenu.obj" \ + "$(INTDIR)\Purepal.obj" \ + "$(INTDIR)\purewrd.obj" \ + "$(INTDIR)\Pview.obj" \ + "$(INTDIR)\Regkey.obj" \ + "$(INTDIR)\resbmp.obj" \ + "$(INTDIR)\Richedit.obj" \ + "$(INTDIR)\rubber.obj" \ + "$(INTDIR)\Sdate.obj" \ + "$(INTDIR)\Smrtstrm.obj" \ + "$(INTDIR)\snapshot.obj" \ + "$(INTDIR)\static.obj" \ + "$(INTDIR)\String.obj" \ + "$(INTDIR)\Systime.obj" \ + "$(INTDIR)\Vhandler.obj" \ + "$(INTDIR)\Vxdctrl.obj" \ + "$(INTDIR)\widestr.obj" \ + "$(INTDIR)\Window.obj" \ + "$(INTDIR)\Wintimer.obj" + +"..\exe\mscommon.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS) + $(LIB32) @<< + $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS) +<< + +!ENDIF + +.c{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cpp{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cxx{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.c{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cpp{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cxx{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + + +!IF "$(NO_EXTERNAL_DEPS)" != "1" +!IF EXISTS("common.dep") +!INCLUDE "common.dep" +!ELSE +!MESSAGE Warning: cannot find "common.dep" +!ENDIF +!ENDIF + + +!IF "$(CFG)" == "common - Win32 Release" || "$(CFG)" == "common - Win32 Debug" +SOURCE=.\accelerator.cpp + +"$(INTDIR)\accelerator.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Bitmap.cpp + +"$(INTDIR)\Bitmap.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Bmdata.cpp + +!IF "$(CFG)" == "common - Win32 Release" + +CPP_SWITCHES=/nologo /MT /GX /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"$(INTDIR)\common.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c + +"$(INTDIR)\Bmdata.obj" : $(SOURCE) "$(INTDIR)" + $(CPP) @<< + $(CPP_SWITCHES) $(SOURCE) +<< + + +!ELSEIF "$(CFG)" == "common - Win32 Debug" + +CPP_SWITCHES=/nologo /Gr /MDd /GX /Zi /Od /I "\work" /I "\parts" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /D "WIN32" /Fp"$(INTDIR)\common.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /I /work" /I /parts" /I /work" /I /parts" " " " " /c + +"$(INTDIR)\Bmdata.obj" : $(SOURCE) "$(INTDIR)" + $(CPP) @<< + $(CPP_SWITCHES) $(SOURCE) +<< + + +!ENDIF + +SOURCE=.\Bminfo.cpp + +"$(INTDIR)\Bminfo.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Bmplnk.cpp + +"$(INTDIR)\Bmplnk.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Brush.cpp + +"$(INTDIR)\Brush.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Btnlnk.cpp + +"$(INTDIR)\Btnlnk.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\calendar.cpp + +"$(INTDIR)\calendar.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Catmull.cpp + +"$(INTDIR)\Catmull.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Cbdata.cpp + +"$(INTDIR)\Cbdata.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Cbdatahk.cpp + +"$(INTDIR)\Cbdatahk.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Clipbrd.cpp + +"$(INTDIR)\Clipbrd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Console.cpp + +"$(INTDIR)\Console.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Control.cpp + +"$(INTDIR)\Control.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Crsctrl.cpp + +"$(INTDIR)\Crsctrl.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Ddemsg.cpp + +"$(INTDIR)\Ddemsg.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Dib.cpp + +"$(INTDIR)\Dib.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Diskinfo.cpp + +"$(INTDIR)\Diskinfo.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Drawbmp.cpp + +"$(INTDIR)\Drawbmp.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Dwindow.cpp + +"$(INTDIR)\Dwindow.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\elastic.cpp + +"$(INTDIR)\elastic.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\errormsg.cpp + +"$(INTDIR)\errormsg.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\File.cpp + +"$(INTDIR)\File.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Fileio.cpp + +"$(INTDIR)\Fileio.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Filemap.cpp + +"$(INTDIR)\Filemap.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Finddata.cpp + +"$(INTDIR)\Finddata.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Font.cpp + +"$(INTDIR)\Font.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\gdipoint.cpp + +"$(INTDIR)\gdipoint.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Guiwnd.cpp + +"$(INTDIR)\Guiwnd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Hookproc.cpp + +"$(INTDIR)\Hookproc.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Iconfrm.cpp + +"$(INTDIR)\Iconfrm.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Infowin.cpp + +"$(INTDIR)\Infowin.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Intel.cpp + +"$(INTDIR)\Intel.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Iobuff.cpp + +"$(INTDIR)\Iobuff.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Logowin.cpp + +"$(INTDIR)\Logowin.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Macro.cpp + +"$(INTDIR)\Macro.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Math.cpp + +"$(INTDIR)\Math.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Mdifrm.cpp + +"$(INTDIR)\Mdifrm.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Mdiwin.cpp + +"$(INTDIR)\Mdiwin.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Memfile.cpp + +"$(INTDIR)\Memfile.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Mmtimer.cpp + +"$(INTDIR)\Mmtimer.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Odbutton.cpp + +"$(INTDIR)\Odbutton.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Odlist.cpp + +"$(INTDIR)\Odlist.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Odlstalt.cpp + +"$(INTDIR)\Odlstalt.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Odlstchk.cpp + +"$(INTDIR)\Odlstchk.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\opendlg.Cpp + +"$(INTDIR)\opendlg.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Openfile.cpp + +"$(INTDIR)\Openfile.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\opndlgex.cpp + +"$(INTDIR)\opndlgex.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Owner.cpp + +"$(INTDIR)\Owner.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Pathfnd.cpp + +"$(INTDIR)\Pathfnd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Point.cpp + +"$(INTDIR)\Point.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Process.cpp + +"$(INTDIR)\Process.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Profile.cpp + +"$(INTDIR)\Profile.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Progress.cpp + +"$(INTDIR)\Progress.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Purebmp.cpp + +"$(INTDIR)\Purebmp.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Purebyte.cpp + +"$(INTDIR)\Purebyte.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\puredbl.cpp + +"$(INTDIR)\puredbl.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Puredwrd.cpp + +"$(INTDIR)\Puredwrd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Purehdc.cpp + +"$(INTDIR)\Purehdc.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\puremenu.Cpp + +"$(INTDIR)\puremenu.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Purepal.cpp + +"$(INTDIR)\Purepal.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\purewrd.cpp + +"$(INTDIR)\purewrd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Pview.cpp + +"$(INTDIR)\Pview.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Regkey.cpp + +"$(INTDIR)\Regkey.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\resbmp.cpp + +"$(INTDIR)\resbmp.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Richedit.cpp + +"$(INTDIR)\Richedit.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\rubber.cpp + +"$(INTDIR)\rubber.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Sdate.cpp + +"$(INTDIR)\Sdate.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Smrtstrm.cpp + +"$(INTDIR)\Smrtstrm.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\snapshot.cpp + +"$(INTDIR)\snapshot.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\static.cpp + +"$(INTDIR)\static.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\String.cpp + +"$(INTDIR)\String.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Systime.cpp + +"$(INTDIR)\Systime.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Vhandler.cpp + +"$(INTDIR)\Vhandler.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Vxdctrl.cpp + +"$(INTDIR)\Vxdctrl.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\widestr.Cpp + +"$(INTDIR)\widestr.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Window.cpp + +"$(INTDIR)\Window.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\Wintimer.cpp + +"$(INTDIR)\Wintimer.obj" : $(SOURCE) "$(INTDIR)" + + + +!ENDIF + diff --git a/common/common.mdp b/common/common.mdp new file mode 100644 index 0000000..b1010b8 Binary files /dev/null and b/common/common.mdp differ diff --git a/common/common.ncb b/common/common.ncb new file mode 100644 index 0000000..2063b57 Binary files /dev/null and b/common/common.ncb differ diff --git a/common/common.opt b/common/common.opt new file mode 100644 index 0000000..c036403 Binary files /dev/null and b/common/common.opt differ diff --git a/common/common.plg b/common/common.plg new file mode 100644 index 0000000..9a40326 --- /dev/null +++ b/common/common.plg @@ -0,0 +1,280 @@ + + +
+
Build Log

+

+--------------------Configuration: common - Win32 Debug--------------------
+

+
Command Lines

+Creating temporary file "C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP50F.tmp" with contents
+[
+/nologo /Gz /MTd /GX /Zi /Od /I "\work" /I "\parts" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /D "WIN32" /FR"msvcobj/" /Fo"msvcobj/" /Fd"msvcobj/" /FD /I /work" /I /parts" /I /work" /I /parts" " " " " /c 
+"F:\work\common\accelerator.cpp"
+"F:\work\common\Bitmap.cpp"
+"F:\work\common\Bminfo.cpp"
+"F:\work\common\Bmplnk.cpp"
+"F:\work\common\Brush.cpp"
+"F:\work\common\Btnlnk.cpp"
+"F:\work\common\calendar.cpp"
+"F:\work\common\Catmull.cpp"
+"F:\work\common\Cbdata.cpp"
+"F:\work\common\Cbdatahk.cpp"
+"F:\work\common\Clipbrd.cpp"
+"F:\work\common\Console.cpp"
+"F:\work\common\Control.cpp"
+"F:\work\common\Crsctrl.cpp"
+"F:\work\common\Ddemsg.cpp"
+"F:\work\common\Dib.cpp"
+"F:\work\common\Diskinfo.cpp"
+"F:\work\common\Drawbmp.cpp"
+"F:\work\common\Dwindow.cpp"
+"F:\work\common\elastic.cpp"
+"F:\work\common\errormsg.cpp"
+"F:\work\common\File.cpp"
+"F:\work\common\Fileio.cpp"
+"F:\work\common\Filemap.cpp"
+"F:\work\common\Finddata.cpp"
+"F:\work\common\Font.cpp"
+"F:\work\common\gdipoint.cpp"
+"F:\work\common\Guiwnd.cpp"
+"F:\work\common\Hookproc.cpp"
+"F:\work\common\Iconfrm.cpp"
+"F:\work\common\Infowin.cpp"
+"F:\work\common\Intel.cpp"
+"F:\work\common\Iobuff.cpp"
+"F:\work\common\Logowin.cpp"
+"F:\work\common\Macro.cpp"
+"F:\work\common\Math.cpp"
+"F:\work\common\Mdifrm.cpp"
+"F:\work\common\Mdiwin.cpp"
+"F:\work\common\Memfile.cpp"
+"F:\work\common\Mmtimer.cpp"
+"F:\work\common\Odbutton.cpp"
+"F:\work\common\Odlist.cpp"
+"F:\work\common\Odlstalt.cpp"
+"F:\work\common\Odlstchk.cpp"
+"F:\work\common\opendlg.Cpp"
+"F:\work\common\Openfile.cpp"
+"F:\work\common\opndlgex.cpp"
+"F:\work\common\Owner.cpp"
+"F:\work\common\Pathfnd.cpp"
+"F:\work\common\Point.cpp"
+"F:\work\common\Process.cpp"
+"F:\work\common\Profile.cpp"
+"F:\work\common\Progress.cpp"
+"F:\work\common\Purebmp.cpp"
+"F:\work\common\Purebyte.cpp"
+"F:\work\common\puredbl.cpp"
+"F:\work\common\Puredwrd.cpp"
+"F:\work\common\Purehdc.cpp"
+"F:\work\common\puremenu.Cpp"
+"F:\work\common\Purepal.cpp"
+"F:\work\common\purewrd.cpp"
+"F:\work\common\Pview.cpp"
+"F:\work\common\Regkey.cpp"
+"F:\work\common\resbmp.cpp"
+"F:\work\common\Richedit.cpp"
+"F:\work\common\rubber.cpp"
+"F:\work\common\Sdate.cpp"
+"F:\work\common\Smrtstrm.cpp"
+"F:\work\common\snapshot.cpp"
+"F:\work\common\static.cpp"
+"F:\work\common\String.cpp"
+"F:\work\common\Systime.cpp"
+"F:\work\common\Vhandler.cpp"
+"F:\work\common\Vxdctrl.cpp"
+"F:\work\common\widestr.Cpp"
+"F:\work\common\Window.cpp"
+"F:\work\common\Wintimer.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP50F.tmp" 
+Creating temporary file "C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP510.tmp" with contents
+[
+/nologo /Gz /MTd /GX /Zi /Od /I "\work" /I "\parts" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /D "WIN32" /FR"msvcobj/" /Fp"msvcobj/common.pch" /YX /Fo"msvcobj/" /Fd"msvcobj/" /FD /I /work" /I /parts" /I /work" /I /parts" " " " " /c 
+"F:\work\common\Bmdata.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP510.tmp" 
+Creating temporary file "C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP511.tmp" with contents
+[
+/nologo /out:"..\exe\mscommon.lib" 
+.\msvcobj\accelerator.obj
+.\msvcobj\Bitmap.obj
+.\msvcobj\Bmdata.obj
+.\msvcobj\Bminfo.obj
+.\msvcobj\Bmplnk.obj
+.\msvcobj\Brush.obj
+.\msvcobj\Btnlnk.obj
+.\msvcobj\calendar.obj
+.\msvcobj\Catmull.obj
+.\msvcobj\Cbdata.obj
+.\msvcobj\Cbdatahk.obj
+.\msvcobj\Clipbrd.obj
+.\msvcobj\Console.obj
+.\msvcobj\Control.obj
+.\msvcobj\Crsctrl.obj
+.\msvcobj\Ddemsg.obj
+.\msvcobj\Dib.obj
+.\msvcobj\Diskinfo.obj
+.\msvcobj\Drawbmp.obj
+.\msvcobj\Dwindow.obj
+.\msvcobj\elastic.obj
+.\msvcobj\errormsg.obj
+.\msvcobj\File.obj
+.\msvcobj\Fileio.obj
+.\msvcobj\Filemap.obj
+.\msvcobj\Finddata.obj
+.\msvcobj\Font.obj
+.\msvcobj\gdipoint.obj
+.\msvcobj\Guiwnd.obj
+.\msvcobj\Hookproc.obj
+.\msvcobj\Iconfrm.obj
+.\msvcobj\Infowin.obj
+.\msvcobj\Intel.obj
+.\msvcobj\Iobuff.obj
+.\msvcobj\Logowin.obj
+.\msvcobj\Macro.obj
+.\msvcobj\Math.obj
+.\msvcobj\Mdifrm.obj
+.\msvcobj\Mdiwin.obj
+.\msvcobj\Memfile.obj
+.\msvcobj\Mmtimer.obj
+.\msvcobj\Odbutton.obj
+.\msvcobj\Odlist.obj
+.\msvcobj\Odlstalt.obj
+.\msvcobj\Odlstchk.obj
+.\msvcobj\opendlg.obj
+.\msvcobj\Openfile.obj
+.\msvcobj\opndlgex.obj
+.\msvcobj\Owner.obj
+.\msvcobj\Pathfnd.obj
+.\msvcobj\Point.obj
+.\msvcobj\Process.obj
+.\msvcobj\Profile.obj
+.\msvcobj\Progress.obj
+.\msvcobj\Purebmp.obj
+.\msvcobj\Purebyte.obj
+.\msvcobj\puredbl.obj
+.\msvcobj\Puredwrd.obj
+.\msvcobj\Purehdc.obj
+.\msvcobj\puremenu.obj
+.\msvcobj\Purepal.obj
+.\msvcobj\purewrd.obj
+.\msvcobj\Pview.obj
+.\msvcobj\Regkey.obj
+.\msvcobj\resbmp.obj
+.\msvcobj\Richedit.obj
+.\msvcobj\rubber.obj
+.\msvcobj\Sdate.obj
+.\msvcobj\Smrtstrm.obj
+.\msvcobj\snapshot.obj
+.\msvcobj\static.obj
+.\msvcobj\String.obj
+.\msvcobj\Systime.obj
+.\msvcobj\Vhandler.obj
+.\msvcobj\Vxdctrl.obj
+.\msvcobj\widestr.obj
+.\msvcobj\Window.obj
+.\msvcobj\Wintimer.obj
+]
+Creating command line "link.exe -lib @C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP511.tmp"
+
Output Window

+Compiling...
+accelerator.cpp
+Bitmap.cpp
+Bminfo.cpp
+Bmplnk.cpp
+Brush.cpp
+Btnlnk.cpp
+calendar.cpp
+Catmull.cpp
+Cbdata.cpp
+Cbdatahk.cpp
+Clipbrd.cpp
+Console.cpp
+Control.cpp
+Crsctrl.cpp
+Ddemsg.cpp
+Dib.cpp
+Diskinfo.cpp
+Drawbmp.cpp
+Dwindow.cpp
+elastic.cpp
+Generating Code...
+Compiling...
+errormsg.cpp
+File.cpp
+Fileio.cpp
+Filemap.cpp
+Finddata.cpp
+Font.cpp
+gdipoint.cpp
+Guiwnd.cpp
+Hookproc.cpp
+Iconfrm.cpp
+Infowin.cpp
+Intel.cpp
+Iobuff.cpp
+Logowin.cpp
+Macro.cpp
+Math.cpp
+Mdifrm.cpp
+Mdiwin.cpp
+Memfile.cpp
+Mmtimer.cpp
+Generating Code...
+Compiling...
+Odbutton.cpp
+Odlist.cpp
+Odlstalt.cpp
+Odlstchk.cpp
+opendlg.Cpp
+Openfile.cpp
+opndlgex.cpp
+Owner.cpp
+Pathfnd.cpp
+Point.cpp
+Process.cpp
+Profile.cpp
+Progress.cpp
+Purebmp.cpp
+Purebyte.cpp
+puredbl.cpp
+Puredwrd.cpp
+Purehdc.cpp
+puremenu.Cpp
+Purepal.cpp
+Generating Code...
+Compiling...
+purewrd.cpp
+Pview.cpp
+Regkey.cpp
+resbmp.cpp
+Richedit.cpp
+rubber.cpp
+Sdate.cpp
+Smrtstrm.cpp
+snapshot.cpp
+static.cpp
+String.cpp
+F:\work\common\String.cpp(604) : error C2039: 'fromUShort' : is not a member of 'String'
+        \work\common/string.hpp(23) : see declaration of 'String'
+F:\work\common\String.cpp(606) : error C2065: 'reserve' : undeclared identifier
+F:\work\common\String.cpp(606) : error C2065: 'MaxString' : undeclared identifier
+F:\work\common\String.cpp(607) : error C2065: 'mnpStr' : undeclared identifier
+F:\work\common\String.cpp(608) : error C2673: 'fromUShort' : global functions do not have 'this' pointers
+Systime.cpp
+Vhandler.cpp
+Vxdctrl.cpp
+widestr.Cpp
+Window.cpp
+Wintimer.cpp
+Generating Code...
+Error executing cl.exe.
+
+
+
+
Results

+mscommon.lib - 5 error(s), 0 warning(s)
+
+ + diff --git a/common/dbt.hpp b/common/dbt.hpp new file mode 100644 index 0000000..9324e0a --- /dev/null +++ b/common/dbt.hpp @@ -0,0 +1,4 @@ +#ifndef _COMMON_DBT_HPP_ +#define _COMMON_DBT_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/desktop.hpp b/common/desktop.hpp new file mode 100644 index 0000000..eaf9850 --- /dev/null +++ b/common/desktop.hpp @@ -0,0 +1,105 @@ +#ifndef _COMMON_DESKTOP_HPP_ +#define _COMMON_DESKTOP_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class Desktop +{ +public: + enum Access{AccessCreateMenu=DESKTOP_CREATEMENU,AccessCreateWindow=DESKTOP_CREATEWINDOW,AccessEnumerate=DESKTOP_ENUMERATE, + AccessHookControl=DESKTOP_HOOKCONTROL,AccessJournalPlayback=DESKTOP_JOURNALPLAYBACK,AccessJournalRecord=DESKTOP_JOURNALRECORD, + AccessReadObjects=DESKTOP_READOBJECTS,AccessSwitchDesktop=DESKTOP_SWITCHDESKTOP,AccessWriteObjects=DESKTOP_WRITEOBJECTS}; + enum Flags{None=0,AllowOtherAccountHook=DF_ALLOWOTHERACCOUNTHOOK}; + Desktop(void); + Desktop(const String &strDesktop,bool inheritHandle=false,DWORD desiredAccess=AccessEnumerate,DWORD dwFlags=AllowOtherAccountHook); + virtual ~Desktop(); + bool open(const String &strDesktop,bool inheritHandle=false,DWORD desiredAccess=AccessEnumerate,DWORD dwFlags=AllowOtherAccountHook); + void close(void); + const String &desktopName(void)const; + bool activate(void)const; + HDESK getHandle(void)const; + bool isOkay(void)const; +private: + Desktop(const Desktop &someDesktop); + Desktop &operator=(const Desktop &someDesktop); + + String mStrDesktopName; + HDESK mhDesktop; +}; + +inline +Desktop::Desktop(void) +: mhDesktop(0) +{ +} + +inline +Desktop::Desktop(const String &strDesktop,bool inheritHandle,DWORD desiredAccess,DWORD dwFlags) +: mhDesktop(0) +{ + open(strDesktop,inheritHandle,desiredAccess,dwFlags); +} + +inline +Desktop::Desktop(const Desktop &/*someDesktop*/) +{ // private implementation +} + +inline +Desktop::~Desktop() +{ +} + +inline +Desktop &Desktop::operator=(const Desktop &/*someDesktop*/) +{ // private implementation + return *this; +} + +inline +bool Desktop::open(const String &strDesktop,bool inheritHandle,DWORD desiredAccess,DWORD dwFlags) +{ + close(); + if(strDesktop.isNull())return false; + mStrDesktopName=strDesktop; + mhDesktop=::OpenDesktop(strDesktop,dwFlags,inheritHandle,desiredAccess); + return isOkay(); +} + +inline +void Desktop::close(void) +{ + if(!isOkay())return; + ::CloseDesktop(mhDesktop); + mhDesktop=0; +} + +inline +bool Desktop::activate(void)const +{ + if(!isOkay())return false; + return ::SwitchDesktop(mhDesktop); +} + +inline +const String &Desktop::desktopName(void)const +{ + return mStrDesktopName; +} + +inline +bool Desktop::isOkay(void)const +{ + return mhDesktop?true:false; +} + +inline +HDESK Desktop::getHandle(void)const +{ + return mhDesktop; +} +#endif diff --git a/common/dxsdk.hpp b/common/dxsdk.hpp new file mode 100644 index 0000000..0147b53 --- /dev/null +++ b/common/dxsdk.hpp @@ -0,0 +1,15 @@ +#ifndef _COMMON_DXSDK_HPP_ +#define _COMMON_DXSDK_HPP_ +#ifndef _COM_COM_HPP_ +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif diff --git a/common/errormsg.cpp b/common/errormsg.cpp new file mode 100644 index 0000000..adc8f10 --- /dev/null +++ b/common/errormsg.cpp @@ -0,0 +1,14 @@ +#include + +void ErrorMessage::message(DWORD message) +{ + LPVOID pMessageBuffer; + + ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,message,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPSTR)&pMessageBuffer,0,NULL); + if(!pMessageBuffer)return; + ::MessageBox(::GetFocus(),(LPSTR)pMessageBuffer,(LPSTR)"FormattedMessage",MB_OK); + ::LocalFree(pMessageBuffer); +} + + + diff --git a/common/errormsg.hpp b/common/errormsg.hpp new file mode 100644 index 0000000..2323d76 --- /dev/null +++ b/common/errormsg.hpp @@ -0,0 +1,16 @@ +#ifndef _COMMON_ERRORMESSAGE_HPP_ +#define _COMMON_ERRORMESSAGE_HPP_ +#ifndef _COMMON_STRING_HPP_ +#include +#endif +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +class ErrorMessage +{ +public: + static void message(DWORD message=::GetLastError()); +private: +}; +#endif \ No newline at end of file diff --git a/common/hold/PVECTOR.HPP b/common/hold/PVECTOR.HPP new file mode 100644 index 0000000..0085ab6 --- /dev/null +++ b/common/hold/PVECTOR.HPP @@ -0,0 +1,7 @@ +#ifndef _COMMON_PUREVECTOR_HPP_ +#define _COMMON_PUREVECTOR_HPP_ +#ifndef _COMMON_ARRAY_HPP_ +#include +#endif +#define PureVector Array +#endif diff --git a/common/mmreg.hpp b/common/mmreg.hpp new file mode 100644 index 0000000..d15f95a --- /dev/null +++ b/common/mmreg.hpp @@ -0,0 +1,4 @@ +#ifndef _COMMON_MMREG_HPP_ +#define _COMMON_MMREG_HPP_ +#include +#endif diff --git a/common/pdh.hpp b/common/pdh.hpp new file mode 100644 index 0000000..a788e31 --- /dev/null +++ b/common/pdh.hpp @@ -0,0 +1,4 @@ +#ifndef _COMMON_PDH_HPP_ +#define _COMMON_PDH_HPP_ +#include +#endif diff --git a/common/versioninfo.hpp b/common/versioninfo.hpp new file mode 100644 index 0000000..744e26c --- /dev/null +++ b/common/versioninfo.hpp @@ -0,0 +1,121 @@ +#ifndef _COMMON_VERSIONINFO_HPP_ +#define _COMMON_VERSIONINFO_HPP_ +#ifndef _COMMON_GLOBALDATA_HPP_ +#include +#endif +#ifndef _COMMON_STDIO_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +// reads the VERSIONINFO from the application's resource file. + +class VersionInfo +{ +public: + VersionInfo(); + VersionInfo(const String &strPathModuleName); + virtual ~VersionInfo(); + String getProductNameString(void)const; + String getProductVersionString(void)const; + String getProductVersion(void)const; + bool isOkay(void)const; +private: + bool getVersionInfo(const String &strPathModuleName); + bool getTranslation(void)const; + String mStrPathModuleName; + String mTranslation; + GlobalData mVersionInfo; + bool mHaveVersionInfo; + +}; + +inline +VersionInfo::VersionInfo() +{ + String strPathModuleName; + ::GetModuleFileName(0,strPathModuleName.str(),String::MaxString); + getVersionInfo(strPathModuleName); +} + +inline +VersionInfo::VersionInfo(const String &strPathModuleName) +{ + getVersionInfo(strPathModuleName); +} + +inline +VersionInfo::~VersionInfo() +{ +} + +inline +String VersionInfo::getProductVersionString(void)const +{ + if(!isOkay())return String(); + unsigned int sizeInfo=0; + char *pProductVersion; + ::VerQueryValue(&((GlobalData&)mVersionInfo)[0],String("\\StringFileInfo\\")+mTranslation+String("\\ProductVersion"),(void**)&pProductVersion,&sizeInfo); + return pProductVersion; +} + +inline +String VersionInfo::getProductNameString(void)const +{ + if(!isOkay())return String(); + unsigned int sizeInfo=0; + char *pProductName; + ::VerQueryValue(&((GlobalData&)mVersionInfo)[0],String("\\StringFileInfo\\")+mTranslation+String("\\ProductName"),(void**)&pProductName,&sizeInfo); + return pProductName; +} + +inline +String VersionInfo::getProductVersion(void)const +{ + String strProductVersion; + String strProductVersionMaj; + String strProductVersionMin; + + if(!isOkay())return String(); + strProductVersion=getProductVersionString(); + strProductVersionMaj=strProductVersion.betweenString(0,','); + strProductVersionMin=strProductVersion.betweenString(',',0); + strProductVersionMin.removeTokens(", "); + strProductVersion=String("v")+strProductVersionMaj+String(".")+strProductVersionMin; + return strProductVersion; +} + +inline +bool VersionInfo::getVersionInfo(const String &strPathModuleName) +{ + DWORD sizeInfo; + mHaveVersionInfo=false; + if(!(sizeInfo=::GetFileVersionInfoSize((char*)strPathModuleName.str(),&sizeInfo)))return false; + mVersionInfo.size(sizeInfo); + if(!::GetFileVersionInfo(strPathModuleName,0,sizeInfo,&mVersionInfo[0]))return false; + mHaveVersionInfo=true; + getTranslation(); + return mHaveVersionInfo; +} + +inline +bool VersionInfo::getTranslation(void)const +{ + if(!isOkay())return String(); + unsigned int sizeInfo=0; + DWORD *pTranslation; + ::VerQueryValue(&((GlobalData&)mVersionInfo)[0],TEXT("\\VarFileInfo\\Translation"),(void**)&pTranslation,&sizeInfo); + ::sprintf(mTranslation,"%04x%04x",LOWORD(*pTranslation),HIWORD(*pTranslation)); + return true; +} + +inline +bool VersionInfo::isOkay(void)const +{ + return mHaveVersionInfo; +} + + +#endif \ No newline at end of file diff --git a/common/wininet.hpp b/common/wininet.hpp new file mode 100644 index 0000000..d0bd26c --- /dev/null +++ b/common/wininet.hpp @@ -0,0 +1,7 @@ +#ifndef _COMMON_WININET_HPP_ +#define _COMMON_WININET_HPP_ +#include +#ifndef INTERNET_SERVICE_URL +#define INTERNET_SERVICE_URL 0 +#endif +#endif diff --git a/common/winnetwk.hpp b/common/winnetwk.hpp new file mode 100644 index 0000000..4cf06f3 --- /dev/null +++ b/common/winnetwk.hpp @@ -0,0 +1,4 @@ +#ifndef _COMMON_WINNETWK_HPP_ +#define _COMMON_WINNETWK_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/winsvc.hpp b/common/winsvc.hpp new file mode 100644 index 0000000..22cc9a8 --- /dev/null +++ b/common/winsvc.hpp @@ -0,0 +1,4 @@ +#ifndef _COMMON_WINSVC_HPP_ +#define _COMMON_WINSVC_HPP_ +#include +#endif \ No newline at end of file diff --git a/common/wstation.hpp b/common/wstation.hpp new file mode 100644 index 0000000..f3e4126 --- /dev/null +++ b/common/wstation.hpp @@ -0,0 +1,97 @@ +#ifndef _COMMON_WINDOWSTATION_HPP_ +#define _COMMON_WINDOWSTATION_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_STRING_HPP_ +#include +#endif + +class WindowStation +{ +public: + enum Access{AccessClipboard=WINSTA_ACCESSCLIPBOARD,AccessGlobalAtoms=WINSTA_ACCESSGLOBALATOMS,AccessCreateDesktop=WINSTA_CREATEDESKTOP, + AccessEnumerateDesktops=WINSTA_ENUMDESKTOPS,AccessEnumerate=WINSTA_ENUMERATE,AccessExitWindows=WINSTA_EXITWINDOWS, + AccessReadAttributes=WINSTA_READATTRIBUTES,AccessReadScreen=WINSTA_READSCREEN,AccessWriteAttributes=WINSTA_WRITEATTRIBUTES}; + WindowStation(void); + WindowStation(const String &strWindowStation,DWORD desriredAccess=AccessEnumerateDesktops|AccessEnumerate,bool inheritHandle=false); + virtual ~WindowStation(); + bool open(const String &strWindowStation,DWORD desiredAccess=AccessEnumerateDesktops|AccessEnumerate,bool inheritHandle=false); + void close(void); + const String &windowStation(void)const; + HWINSTA getHandle(void)const; + bool isOkay(void)const; +private: + WindowStation(const WindowStation &someWindowStation); + WindowStation &operator=(const WindowStation &someWindowStation); + + String mStrWindowStation; + HWINSTA mhWindowStation; +}; + +inline +WindowStation::WindowStation(void) +: mhWindowStation(0) +{ +} + +inline +WindowStation::WindowStation(const String &strWindowStation,DWORD desiredAccess,bool inheritHandle) +: mhWindowStation(0) +{ + open(strWindowStation,desiredAccess,inheritHandle); +} + +inline +WindowStation::WindowStation(const WindowStation &/*someWindowStation*/) +{ // private implemnentation +} + +inline +WindowStation::~WindowStation() +{ + close(); +} + +inline +WindowStation &WindowStation::operator=(const WindowStation &/*someWindowStation*/) +{ // private implementation + return *this; +} + +inline +bool WindowStation::isOkay(void)const +{ + return getHandle()?true:false; +} + +inline +bool WindowStation::open(const String &strWindowStation,DWORD desiredAccess,bool inheritHandles) +{ + close(); + if(strWindowStation.isNull())return false; + mStrWindowStation=strWindowStation; + mhWindowStation=::OpenWindowStation((LPSTR)(String&)strWindowStation,inheritHandles,desiredAccess); + return isOkay(); +} + +inline +void WindowStation::close(void) +{ + if(!isOkay())return; + ::CloseWindowStation(mhWindowStation); + mhWindowStation=0; +} + +inline +const String &WindowStation::windowStation(void)const +{ + return mStrWindowStation; +} + +inline +HWINSTA WindowStation::getHandle(void)const +{ + return mhWindowStation; +} +#endif