提交: 95a1138b2c84848686b704a4f0939e77733b2ae2 - MG (git)

milligram

Commit MetaInfo

• 修订版: 95a1138b2c84848686b704a4f0939e77733b2ae2 (tree)
• 时间: 2011-03-17 17:12:25
• 作者: beru <berupon@gmai...>
• Commiter: beru

Log Message

implemented part of BitBlt function

更改概述

• add: ReadImage/File.cpp
• add: ReadImage/File.h
• add: ReadImage/IFile.h
• add: ReadImage/ReadImage.cpp
• add: ReadImage/ReadImage.h
• add: common/winutil.cpp
• add: common/winutil.h
• modified: main_plus.cpp
• modified: mg.vcproj
• modified: mg/bitmap.cpp
• modified: mg/bitmap.h
• modified: mg/element.cpp
• modified: mg/element.h
• modified: mg/rectangle.cpp
• modified: mg/rectangle.h

差异

--- /dev/null
+++ b/ReadImage/File.cpp
@@ -0,0 +1,60 @@
+#include "stdafx.h"
+#include "File.h"
+
+#include <io.h>
+#include <assert.h>
+#include <memory.h>
+#include <stdio.h>
+
+#include <windows.h>
+
+File::File(HANDLE hFile)
+	:
+	hFile_(hFile)
+{
+}
+
+File::File(FILE* pFile)
+{
+	hFile_ = (HANDLE) _get_osfhandle(_fileno(pFile));
+}
+
+bool File::Read(void* pBuffer, size_t nNumberOfBytesToRead, size_t& nNumberOfBytesRead)
+{
+	return ReadFile(hFile_, pBuffer, nNumberOfBytesToRead, (LPDWORD)&nNumberOfBytesRead, NULL);
+}
+
+bool File::Write(const void* pBuffer, size_t nNumberOfBytesToWrite, size_t& nNumberOfBytesWritten)
+{
+	return WriteFile(hFile_, pBuffer, nNumberOfBytesToWrite, (LPDWORD)&nNumberOfBytesWritten, NULL);
+}
+
+size_t File::Seek(long lDistanceToMove, size_t dwMoveMethod)
+{
+	return SetFilePointer(hFile_, lDistanceToMove, NULL, dwMoveMethod);
+}
+
+size_t File::Tell() const
+{
+	/*
+		-- Reference --
+		http://nukz.net/reference/fileio/hh/winbase/filesio_3vhu.htm
+	*/
+	return SetFilePointer(
+		hFile_, // must have GENERIC_READ and/or GENERIC_WRITE 
+		0,     // do not move pointer 
+		NULL,  // hFile is not large enough to need this pointer 
+		FILE_CURRENT
+	);  // provides offset from current position 
+}
+
+size_t File::Size() const
+{
+	return GetFileSize(hFile_, NULL);
+}
+
+bool File::Flush()
+{
+	return FlushFileBuffers(hFile_);
+}
+

--- /dev/null
+++ b/ReadImage/File.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "IFile.h"
+
+#include <windows.h>
+#include <stdio.h>
+
+class File : public IFile
+{
+public:
+	File(HANDLE hFile);
+
+	File(FILE* pFile);
+
+	bool Read(void* pBuffer, size_t nNumberOfBytesToRead, size_t& nNumberOfBytesRead);
+	
+	bool Write(const void* pBuffer, size_t nNumberOfBytesToWrite, size_t& nNumberOfBytesWritten);
+	
+	size_t Seek(long lDistanceToMove, size_t dwMoveMethod);
+	
+	size_t Tell() const;
+	
+	size_t Size() const;
+	
+	bool Flush();
+	
+	bool HasBuffer() const { return false; }
+	virtual const void* GetBuffer() const { return 0; }
+	
+private:
+	HANDLE hFile_;
+};
+

--- /dev/null
+++ b/ReadImage/IFile.h
@@ -0,0 +1,33 @@
+#pragma once
+
+/*!
+
+概要
+	画像の入出力用に仮想的にFileを扱えるようにする
+	
+制限
+	非同期操作には対応しない
+	2GBまで
+	
+備考
+	CxImage by Davide Pizzolato (http://www.xdp.it/cximage.htm)	を参考にしました。
+
+	InterfaceをWindowsAPIのFile関数に似せています
+
+*/
+
+class IFile
+{
+public:
+	virtual bool Read(void* pBuffer, size_t nNumberOfBytesToRead, size_t& nNumberOfBytesRead) = 0;
+	virtual bool Write(const void* pBuffer, size_t nNumberOfBytesToWrite, size_t& nNumberOfBytesWritten) = 0;
+	virtual size_t Seek(long lDistanceToMove, size_t dwMoveMethod) = 0;
+	virtual size_t Tell() const = 0;
+	virtual size_t Size() const = 0;
+	virtual bool IsEof() const { return Tell() == Size(); }
+	virtual bool Flush() = 0;
+
+	virtual bool HasBuffer() const = 0;
+	virtual const void* GetBuffer() const = 0;
+};
+

--- /dev/null
+++ b/ReadImage/ReadImage.cpp
@@ -0,0 +1,126 @@
+#include "stdafx.h"
+
+#include "ReadImage.h"
+#include "arrayutil.h"
+
+//#define TRACE printf
+#define TRACE OutputDebugStringA
+#include <assert.h>
+
+#include <windows.h>
+
+bool Read_BITMAPINFOHEADER(IFile& file, BITMAPINFOHEADER& bmih)
+{
+	size_t fileSize = file.Size();
+	if (fileSize <= 54) {
+		TRACE("file size <= 54 bytes.");
+		return false;
+	}
+	BITMAPFILEHEADER bmpFileHeader;
+	size_t readBytes = 0;
+	file.Read(&bmpFileHeader, 14, readBytes);
+	assert(readBytes == 14);
+	if (bmpFileHeader.bfType != 19778) {
+		TRACE("file hedear bfType != 19778");
+		return false;
+	}
+	
+	file.Read(&bmih, 40, readBytes);
+	if (readBytes != 40) {
+		TRACE("bmih shortage.");
+		return false;
+	}
+	
+	return true;
+}
+
+bool ReadImageInfo_BMP(IFile& file, ImageInfo& info)
+{
+	BITMAPINFOHEADER bmih;
+	if (!Read_BITMAPINFOHEADER(file, bmih)) {
+		return false;
+	}
+	info.width = bmih.biWidth;
+	info.height = bmih.biHeight;
+	switch (bmih.biBitCount) {
+	case 1:
+	case 4:
+	case 8:
+		info.samplesPerPixel = 1;
+		break;
+	case 16:
+	case 24:
+		info.samplesPerPixel = 3;
+		break;
+	case 32:
+		info.samplesPerPixel = 4;
+		break;
+	}
+	info.bitsPerSample = 8;
+	return true;
+}
+
+bool ReadImageData_BMP(IFile& file, unsigned char* dest, int lineOffset, void* palettes)
+{
+	file.Seek(0, FILE_BEGIN);
+	BITMAPINFOHEADER bmih;
+	if (!Read_BITMAPINFOHEADER(file, bmih)) {
+		return false;
+	}
+	size_t bmiColorsLen = 0;
+	switch (bmih.biBitCount) {
+	case 1:
+		bmiColorsLen = 2;
+		break;
+	case 4:
+		bmiColorsLen = 16;
+		break;
+	case 8:
+		bmiColorsLen = 256;
+		break;
+	case 16:
+		TRACE("16 bit BMP not supported.");
+		return false;
+		break;
+	case 32:
+		if (bmih.biCompression == BI_BITFIELDS) {
+			bmiColorsLen = 3;
+		}
+	}
+	size_t readBytes = 0;
+	if (bmiColorsLen) {
+		size_t needBytes = /*sizeof(RGBQUAD)*/4*bmiColorsLen;
+		file.Read(palettes, needBytes, readBytes);
+		if (readBytes != needBytes) {
+			TRACE("bmiColors read failed.");
+			return false;
+		}
+	}
+	const int lineBytes = ((((bmih.biWidth * bmih.biBitCount) + 31) & ~31) >> 3);
+	const int lineIdx = (bmih.biHeight < 0) ? 0 : (bmih.biHeight-1);
+	OffsetPtr(dest, lineOffset * lineIdx);
+	lineOffset *= (bmih.biHeight < 0) ? 1 : -1;
+
+	const size_t height = abs(bmih.biHeight);
+	for (size_t y=0; y<height; ++y) {
+		file.Read(dest, lineBytes, readBytes);
+		if (readBytes != lineBytes) {
+			TRACE("read bytes != lineBytes.");
+			return false;
+		}
+		OffsetPtr(dest, lineOffset);
+	}
+	
+	return true;
+}
+
+bool ReadImageInfo(IFile& file, ImageInfo& info)
+{
+	return ReadImageInfo_BMP(file, info);
+}
+
+bool ReadImageData(IFile& file, unsigned char* dest, int lineOffset, void* palettes)
+{
+	return ReadImageData_BMP(file, dest, lineOffset, palettes);
+}
+

--- /dev/null
+++ b/ReadImage/ReadImage.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "IFile.h"
+
+struct ImageInfo
+{
+	size_t width;
+	size_t height;
+	size_t bitsPerSample;
+	size_t samplesPerPixel;
+};
+
+bool ReadImageInfo(IFile& file, ImageInfo& info);
+bool ReadImageData(IFile& file, unsigned char* dest, int lineOffset, void* palettes);
+

--- /dev/null
+++ b/common/winutil.cpp
@@ -0,0 +1,37 @@
+#include "stdafx.h"
+
+#include "winutil.h"
+
+HBITMAP CreateDIB(int width, int height, int bitsPerPixel, BITMAPINFO& bmi, void*& pBits)
+{
+	assert(bitsPerPixel % 8 == 0);
+	int bytesPerPixel = bitsPerPixel / 8;
+	assert(bytesPerPixel <= 4);
+	if (width % 4) {
+		width += 4 - (width % 4);
+	}
+	assert(width % 4 == 0);
+	BITMAPINFOHEADER& header = bmi.bmiHeader;
+	header.biSize = sizeof(BITMAPINFOHEADER);
+	header.biWidth = width;
+	header.biHeight = height;
+	header.biPlanes = 1;
+	header.biBitCount = bitsPerPixel;
+	header.biCompression = BI_RGB;
+	header.biSizeImage = width * abs(height) * bytesPerPixel;
+	header.biXPelsPerMeter = 0;
+	header.biYPelsPerMeter = 0;
+	header.biClrUsed = 0;
+	header.biClrImportant = 0;
+	
+	return ::CreateDIBSection(
+		(HDC)0,
+		&bmi,
+		DIB_RGB_COLORS,
+		&pBits,
+		NULL,
+		0
+	);
+}
+
+

--- /dev/null
+++ b/common/winutil.h
@@ -0,0 +1,3 @@
+#pragma once
+
+HBITMAP CreateDIB(int width, int height, int bitsPerPixel, BITMAPINFO& bmi, void*& pBits);

--- a/main_plus.cpp
+++ b/main_plus.cpp
@@ -10,6 +10,10 @@
 #include "mg/container.h"
 #include "mg/button.h"
 
+#include "winutil.h"
+#include "ReadImage/File.h"
+#include "ReadImage/ReadImage.h"
+
 namespace {
 
 HWND hWnd;
@@ -26,38 +30,10 @@ MG::Container mg(elements, 128);
 MG::Button button1;
 MG::Button button2;
 
-HBITMAP CreateDIB(int width, int height, int bitsPerPixel, BITMAPINFO& bmi, void*& pBits)
-{
-	assert(bitsPerPixel % 8 == 0);
-	int bytesPerPixel = bitsPerPixel / 8;
-	assert(bytesPerPixel <= 4);
-	if (width % 4) {
-		width += 4 - (width % 4);
-	}
-	assert(width % 4 == 0);
-	BITMAPINFOHEADER& header = bmi.bmiHeader;
-	header.biSize = sizeof(BITMAPINFOHEADER);
-	header.biWidth = width;
-	header.biHeight = height;
-	header.biPlanes = 1;
-	header.biBitCount = bitsPerPixel;
-	header.biCompression = BI_RGB;
-	header.biSizeImage = width * abs(height) * bytesPerPixel;
-	header.biXPelsPerMeter = 0;
-	header.biYPelsPerMeter = 0;
-	header.biClrUsed = 0;
-	header.biClrImportant = 0;
-
-	return ::CreateDIBSection(
-		(HDC)0,
-		&bmi,
-		DIB_RGB_COLORS,
-		&pBits,
-		NULL,
-		0
-	);
-}
-
+std::vector<uint8_t> imageBuffer;
+MG::Bitmap bmpContent;
+MG::Element pic1;
+MG::Element pic2;
 
 } // anonymous namespace
 
@@ -115,6 +91,51 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	rect.h = 50;
 	button2.rect = rect;
 	mg.Add(button2);
+
+	// read content
+	{
+		FILE* file = fopen("test.bmp", "r");
+		assert(file);
+		if (!file) {
+			return;
+		}
+		File fileProxy(file);
+		ImageInfo imageInfo;
+		ReadImageInfo(fileProxy, imageInfo);
+		assert(imageInfo.bitsPerSample == 8 && imageInfo.samplesPerPixel == 3);
+		imageBuffer.resize(imageInfo.width * imageInfo.height * imageInfo.samplesPerPixel);
+		int lineOffsetBytes = imageInfo.width * imageInfo.samplesPerPixel;
+		ReadImageData(fileProxy, &imageBuffer[0], lineOffsetBytes, 0);
+		fclose(file);
+		bmpContent.bitsPerPixel = imageInfo.bitsPerSample * imageInfo.samplesPerPixel;
+		bmpContent.width = imageInfo.width;
+		bmpContent.height = imageInfo.height;
+		bmpContent.lineOffsetBytes = lineOffsetBytes;
+		bmpContent.pBits = &imageBuffer[0];
+	}
+	rect.x = 100;
+	rect.y = 300;
+	pic1.rect = rect;
+	MG::Rectangle irec;
+	irec.x = irec.y = 0;
+	irec.w = 400;
+	irec.h = 400;
+	pic1.bg.image.rect = irec;
+	pic1.bg.image.pBitmap = &bmpContent;
+	pic1.needsToDraw = true;
+	mg.Add(pic1);
+	
+	rect.x = 300;
+	rect.y = 200;
+	rect.w = 300;
+	rect.h = 300;
+	pic2.rect = rect;
+	pic2.bg = pic1.bg;
+	irec.x = 510;
+	irec.y = 340;
+	pic2.bg.image.rect = irec;
+	pic2.needsToDraw = true;
+	mg.Add(pic2);
 	
 	HDC hWndDC = ::GetDC(hWnd);
 	hMemDC = ::CreateCompatibleDC(hWndDC);

--- a/mg.vcproj
+++ b/mg.vcproj
@@ -42,7 +42,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="0"
 				AdditionalIncludeDirectories="./;./common/"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_CRT_SECURE_NO_WARNINGS"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
@@ -116,7 +116,7 @@
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
 				AdditionalIncludeDirectories="./;./common/"
-				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_CRT_SECURE_NO_WARNINGS"
 				RuntimeLibrary="2"
 				EnableFunctionLevelLinking="true"
 				UsePrecompiledHeader="2"
@@ -320,6 +320,38 @@
 				RelativePath=".\common\stdint.h"
 				>
 			</File>
+			<File
+				RelativePath=".\common\winutil.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\common\winutil.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="ReadImage"
+			>
+			<File
+				RelativePath=".\ReadImage\File.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\ReadImage\File.h"
+				>
+			</File>
+			<File
+				RelativePath=".\ReadImage\IFile.h"
+				>
+			</File>
+			<File
+				RelativePath=".\ReadImage\ReadImage.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\ReadImage\ReadImage.h"
+				>
+			</File>
 		</Filter>
 		<File
 			RelativePath=".\ReadMe.txt"

--- a/mg/bitmap.cpp
+++ b/mg/bitmap.cpp
@@ -1,6 +1,7 @@
 #include "stdafx.h"
 
 #include "bitmap.h"
+#include "arrayutil.h"
 
 namespace MG {
 
@@ -14,6 +15,63 @@ Rectangle Bitmap::GetRect() const
 	return ret;
 }
 
+void BitBlt_Src8_Dst24(
+	const Bitmap& src, const Rectangle& srcRect,
+	Bitmap& dst, const Rectangle& dstRect
+	)
+{
+}
+
+void BitBlt_Src8_Dst32(
+	const Bitmap& src, const Rectangle& srcRect,
+	Bitmap& dst, const Rectangle& dstRect
+	)
+{
+}
+
+void BitBlt_Src24_Dst24(
+	const Bitmap& src, const Rectangle& srcRect,
+	Bitmap& dst, const Rectangle& dstRect
+	)
+{
+	const uint8_t* pSrc = (const uint8_t*) src.pBits;
+	OffsetPtr(pSrc, src.lineOffsetBytes * srcRect.y);
+	pSrc += 3 * srcRect.x;
+	
+	uint8_t* pDst = (uint8_t*) dst.pBits;
+	OffsetPtr(pDst, dst.lineOffsetBytes * dstRect.y);
+	pDst += 3 * dstRect.x;
+	
+	for (size_t y=0; y<dstRect.h; ++y) {
+		for (size_t x=0; x<dstRect.w * 3; ++x) {
+			pDst[x] = pSrc[x];
+		}
+		OffsetPtr(pSrc, src.lineOffsetBytes);
+		OffsetPtr(pDst, dst.lineOffsetBytes);
+	}
+}
+
+void BitBlt_Src24_Dst32(
+	const Bitmap& src, const Rectangle& srcRect,
+	Bitmap& dst, const Rectangle& dstRect
+	)
+{
+}
+
+void BitBlt_Src32_Dst24(
+	const Bitmap& src, const Rectangle& srcRect,
+	Bitmap& dst, const Rectangle& dstRect
+	)
+{
+}
+
+void BitBlt_Src32_Dst32(
+	const Bitmap& src, const Rectangle& srcRect,
+	Bitmap& dst, const Rectangle& dstRect
+	)
+{
+}
+
 Rectangle BitBlt(
 	const Bitmap& src, const Rectangle& srcRect,
 	Bitmap& dst, const Rectangle& dstRect
@@ -26,24 +84,46 @@ Rectangle BitBlt(
 	Rectangle dbr = dst.GetRect();
 	dbr.Intersect(dstRect);
 	
+	Rectangle sbr2 = sbr;
+	sbr2.x = dbr.x;
+	sbr2.y = dbr.y;
+	dbr.Intersect(sbr2);
+	
 	assert(dst.bitsPerPixel == 24 || dst.bitsPerPixel == 32);
-	if (src.bitsPerPixel == dst.bitsPerPixel) {
-		;
-	}else {
-		switch (src.bitsPerPixel) {
-		case 8:
-			
+	switch (src.bitsPerPixel) {
+	case 8:
+		switch (dst.bitsPerPixel) {
+		case 24:
+			BitBlt_Src8_Dst24(src, sbr, dst, dbr);
+			break;
+		case 32:
+			BitBlt_Src8_Dst32(src, sbr, dst, dbr);
+			break;
+		}
+		break;
+	case 24:
+		switch (dst.bitsPerPixel) {
+		case 24:
+			BitBlt_Src24_Dst24(src, sbr, dst, dbr);
+			break;
+		case 32:
+			BitBlt_Src24_Dst32(src, sbr, dst, dbr);
 			break;
+		}
+		break;
+	case 32:
+		switch (dst.bitsPerPixel) {
 		case 24:
-			
+			BitBlt_Src32_Dst24(src, sbr, dst, dbr);
 			break;
 		case 32:
-			
+			BitBlt_Src32_Dst32(src, sbr, dst, dbr);
 			break;
 		}
+		break;
 	}
 	
-	return ret;
+	return dbr;
 }
 
 

--- a/mg/bitmap.h
+++ b/mg/bitmap.h
@@ -11,8 +11,21 @@ struct Bitmap
 	uint8_t bitsPerPixel;
 	int lineOffsetBytes;
 	void* pBits;
+	
+	Rectangle GetRect() const;	
+};
 
-	Rectangle GetRect() const;
+struct Image {
+	Bitmap* pBitmap;
+	Rectangle rect;
+	
+	Rectangle GetRect() const {
+		if (pBitmap) {
+			return Rectangle::Intersect(pBitmap->GetRect(), rect);
+		}else {
+			return rect;
+		}
+	}
 };
 
 Rectangle BitBlt(

--- a/mg/element.cpp
+++ b/mg/element.cpp
@@ -10,19 +10,14 @@ void Element::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 	Rectangle r = rect;
 	r.x += offsetX;
 	r.y += offsetY;
-
+	
 	if (bg.color) {
 		Color c = *bg.color;
 		renderer.FillRectangle(r, c);
 	}
-	if (bg.pBitmap) {
-		const Bitmap& bmp = *bg.pBitmap;
-		Rectangle sr;
-		sr.x = 0;
-		sr.y = 0;
-		sr.w = bmp.width;
-		sr.h = bmp.height;
-		renderer.DrawBitmap(bmp, sr, r);
+	if (bg.image.pBitmap) {
+		const Bitmap& bmp = *bg.image.pBitmap;
+		renderer.DrawBitmap(bmp, bg.image.GetRect(), r);
 	}
 	
 }

--- a/mg/element.h
+++ b/mg/element.h
@@ -13,7 +13,6 @@ public:
 		needsToDraw(false),
 		bClickable_(false)
 	{
-		bg.pBitmap = NULL;
 		bg.repeatX = true;
 		bg.repeatY = true;
 	}
@@ -27,20 +26,20 @@ public:
 	}
 	
 	virtual void Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer);
-	virtual bool HitTest(int16_t x, int16_t y) const = 0;
-	virtual void OnMouseDown(int16_t x, int16_t y) = 0;
-	virtual void OnMouseUp(int16_t x, int16_t y) = 0;
-	virtual void OnMouseMove(int16_t x, int16_t y) = 0;
+	virtual bool HitTest(int16_t x, int16_t y) const { return false; }
+	virtual void OnMouseDown(int16_t x, int16_t y) {}
+	virtual void OnMouseUp(int16_t x, int16_t y) {}
+	virtual void OnMouseMove(int16_t x, int16_t y) {}
 	
 	Rectangle rect;
 	bool needsToDraw;
-
+	
 	struct Background {
 		optional<Color> color;
-		const Bitmap* pBitmap;
+		Image image;
 		bool repeatX;
 		bool repeatY;
-	}bg;
+	} bg;
 protected:
 	bool bClickable_;
 };

--- a/mg/rectangle.cpp
+++ b/mg/rectangle.cpp
@@ -22,10 +22,10 @@ bool Rectangle::Contains(int16_t x, int16_t y)
 {
 	return
 		1
-		&& this->x <= x
-		&& x < this->x + this->w
-		&& this->y <= y
-		&& y < this->y + this->h
+		&& Left() <= x
+		&& x < Right()
+		&& Top() <= y
+		&& y < Bottom()
 	;
 }
 
@@ -36,7 +36,17 @@ bool Rectangle::Contains(const Rectangle& r)
 
 void Rectangle::Intersect(const Rectangle& r)
 {
+	int16_t left = std::max<int16_t>(Left(), r.Left());
+	int16_t right = std::min<int16_t>(Right(), r.Right());
 	
+	int16_t top = std::max<int16_t>(Top(), r.Top());
+	int16_t bottom = std::min<int16_t>(Bottom(), r.Bottom());
+	
+	x = left;
+	w = std::max<int16_t>(0, right-left);
+	
+	y = top;
+	h = std::max<int16_t>(0, bottom-top);
 }
 
 // static

--- a/mg/rectangle.h
+++ b/mg/rectangle.h
@@ -11,6 +11,11 @@ struct Rectangle
 	uint16_t w;
 	uint16_t h;
 	
+	int16_t Left() const { return x; }
+	int16_t Right() const { return x+w; }
+	int16_t Top() const { return y; }
+	int16_t Bottom() const { return y+h; }
+	
 	void Offset(int16_t x, int16_t y);
 	static Rectangle Offset(const Rectangle& r, int16_t x, int16_t y);