#include "stdafx.h"

#include "module1.h"
#include "W3ZMapEditView.h"
#include "Doodad.h"
#include "IDList.h"
#include "DoodadsList.h"
#include "War3TypesAndConstants.h"
/////////////////////////////////////////////////////////////////////////
COLORREF vColorMass[48];		// массив цветов
extern MapCell **ppMap;		// массив карты лабиринта
extern int vWm;				// размер карты лабиринта
extern int vHm;				// размер карты лабиринта
extern WorldMap MapEditable;// редактируемая карта
CW3ZMapEditView MapView;	// виевер карты
int vGenerate;				// Генерация карты
/////////////////////////////////////////////////////////////////////////
// Загрузить данные
int fLoadingData1 ()
{
	vColorMass[0] = 0x000000;	// черный (текст)
	vColorMass[1] = 0x00ff00;	// зеленый (ландшафт)
	vColorMass[2] = 0x777777;	// темно серый (проклятая земля)
	vColorMass[3] = 0x00ffff;	// желтый (база хума)
	vColorMass[4] = 0xff00ff;	// розовый (вал)
	vColorMass[5] = 0xff7777;	// темно синий (денс пул)
	vColorMass[6] = 0x7777ff;	// оранжевый (слаерка)
	vColorMass[7] = 0x77ff77;	// салатовый (телепорт)
	vColorMass[8] = 0xf77777;	//
	vColorMass[9] = 0x7f7777;	//
	vColorMass[10] = 0x77f777;	//
	vColorMass[11] = 0x777f77;	//
	vColorMass[12] = 0x7777f7;	//
	vColorMass[13] = 0x77777f;	//
	vColorMass[14] = 0x007700;	// темно зеленый 1 (деревья)
	vColorMass[15] = 0x0077CC;	// коричневый 1	(срубленные деревья)
	vColorMass[16] = 0x0000ff;	// красный 1 (кровь)
	vColorMass[17] = 0xFF0000;	// синий (глубина)
	vColorMass[18] = 0x00CCCC;	// коричневый 2 (уровень 0)
	vColorMass[19] = 0x00EEFF;	// коричневый 3 (уровень 1)
	vColorMass[20] = 0x00FF66;	// зеленый 2 (уровень 2)
	vColorMass[21] = 0x00EE00;	// зеленый 3 (уровень 3)
	vColorMass[22] = 0x00DD66;	// зеленый 4 (уровень 4)
	vColorMass[23] = 0x00CC66;	// зеленый 5 (уровень 5)
	vColorMass[24] = 0x00BB66;	// зеленый 6 (уровень 6)
	vColorMass[25] = 0x66CCCC;	// коричневый 4 (почва 1)
	vColorMass[26] = 0x6699CC;	// коричневый 5 (грубая почва)
	vColorMass[27] = 0x33CC99;	// коричневый 6 (почва 2)
	vColorMass[28] = 0x00FF66;	// зеленый 2 (трава)
	vColorMass[29] = 0x00BB00;	// темно зеленый 2 (темная трава)
	vColorMass[30] = 0xFFCCFF;	// красный 2 (камень)
	vColorMass[31] = 0x0099CC;	// коричневый 7 (каменистая тропинка)
	vColorMass[32] = 0x777777;	// темно серый (проклятая земля)
	vColorMass[33] = 0xC0C0C0;	// серый (камни объект)
	vColorMass[34] = 0xEBCE87;	// синий 0 (почва1 под водой)
	vColorMass[35] = 0x8B8B00;	// синий 1 (грубая почва под водой)
	vColorMass[36] = 0x99CC66;	// синий 2 (почва2 под водой)
	vColorMass[37] = 0xFFCC66;	// синий 3 (трава под водой)
	vColorMass[38] = 0xFF9966;	// синий 4 (темная трава под водой)
	vColorMass[39] = 0x99CCFF;	// красный 3 (камень под водой)
	vColorMass[40] = 0x009999;	// коричневый 8 (каменистая тропинка под водой)
	vColorMass[41] = 0x8B8B00;	// синий 1 (проклятая земля под водой)
	vColorMass[42] = 0xFF9933;	// синий 5 (флаг)
	vColorMass[43] = 0x00CCFF;	// золотой (обелиск)
	vColorMass[44] = 0xff00ff;	// розовый (пустоты)
	vColorMass[45] = 0x6666FF;	// светло красный (руны)
	vColorMass[46] = 0x77ff77;	// салатовый (портал)
	vColorMass[47] = 0x99FFCC;	// светло зеленый (цветочек)
	return 1;
}
// Обновить поле рисования
int fRefreshFieldDrawing (HWND hWnd, int view, int _FlagR)
{
	char szBuffer[100];
	MapCell vCell;
	RegionMap* pNextRegion;

	RECT rc;
	int _w;
	int _h;
	int _k;
	int vW;
	int vH;

	if ((view == 0 && !ppMap) || (view == 1 && !MapEditable.CheckMapInit()) ||
		vWm <= 0 || vHm <= 0)
		return 0;

	if (view == 0)
	{
		GetClientRect(hWnd, &rc);
		_w = (rc.right - rc.left) / (vWm+2);
		_h = (rc.bottom - rc.top) / (vHm+2);
		//vCell = ppMap[31][19];
		for (int vvi=0;vvi<vWm;vvi++)
		{
			//GetForegroundWindow()
			for (int vvj=0;vvj<vHm;vvj++)
			{
				vCell = ppMap[vvi][vvj];
				/*if(Cell.PeakAttr == true) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[3]);
				if(Cell.PeakAttr == false) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[4]);*/
				if(vCell.Up == false) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_UP,vColorMass[0]);
				if(vCell.Down == false) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_DOWN,vColorMass[0]);
				if(vCell.Right == false) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RIGHT,vColorMass[0]);
				if(vCell.Left == false) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_LEFT,vColorMass[0]);
				//if(Cell.Deadlock == true) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,vRectangle,vColorMass[1]);
				if(vCell.Attribute == BASEHUMAN) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[3]);
				if(vCell.Wall == true) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[4]);
				if(vCell.Attribute == BASEVAMPIRE) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[2]);
				if(vCell.Attribute == DANCEPOOL) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[5]);
				if(vCell.Attribute == SLAYERPLACE) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[6]);
				if(vCell.Attribute == LANDSCAPE) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[1]);
				if(vCell.Attribute == TELEPORT) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[7]);

				if(vCell.Attribute == SHOAL) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[37]);

				if(vCell.CellCountPass == 1) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[0]);
				if(vCell.CellCountPass == 2) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[6]);

				if(vCell.Blood == true) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE,vColorMass[16]);
			}
		}
		for (int vvi=0;vvi<vWm;vvi++)
		{
			for (int vvj=0;vvj<vHm;vvj++)
			{
				vCell = ppMap[vvi][vvj];
				if(vCell.UpT == 1) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_UP2,vColorMass[14]);
				if(vCell.DownT == 1) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_DOWN2,vColorMass[14]);
				if(vCell.RightT == 1) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RIGHT2,vColorMass[14]);
				if(vCell.LeftT == 1) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_LEFT2,vColorMass[14]);
				if(vCell.UpT == 2) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_UP2,vColorMass[16]);
				if(vCell.DownT == 2) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_DOWN2,vColorMass[16]);
				if(vCell.RightT == 2) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RIGHT2,vColorMass[16]);
				if(vCell.LeftT == 2) fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_LEFT2,vColorMass[16]);
			}
		}
		/*for (int vvi=0;vvi<vWm;vvi++)
		{
			for (int vvj=0;vvj<vHm;vvj++)
			{
				vCell = ppMap[vvi][vvj];
				if (vCell.NumPeak != 0)
				{
					sprintf(szBuffer,"%d",vCell.NumPeak);
					fDrawText(hWnd,vvj,vvi,vWm,vHm,_w,_h,szBuffer,vColorMass[0],NULL);
				}
			}
		}*/
		if (_FlagR == 1)
		{
			for (int vvi=0;vvi<vWm;vvi++)
			{
				for (int vvj=0;vvj<vHm;vvj++)
				{
					vCell = ppMap[vvi][vvj];
					if(vCell.NumBase >= 0)
						fDrawObj(hWnd,vvi,vvj,vWm,vHm,_w,_h,_RECTANGLE3,vCell.Color);
				}
			}
		}
		for (int vvi=0;vvi<vWm;vvi++)
		{
			sprintf(szBuffer,"%d",vvi);
			fDrawText(hWnd,vvi,-1,vWm,vHm,_w,_h,szBuffer,vColorMass[0],NULL);
		}
		for (int vvi=0;vvi<vHm;vvi++)
		{
			sprintf(szBuffer,"%d",vvi);
			fDrawText(hWnd,-1,vvi,vWm,vHm,_w,_h,szBuffer,vColorMass[0],NULL);
		}
		for (int vvi=0;vvi<vWm;vvi++)
		{
			for (int vvj=0;vvj<vHm;vvj++)
			{
				vCell = ppMap[vvi][vvj];
				if (vCell.LevelUpland != 0)
				{
					sprintf(szBuffer,"%d",vCell.LevelUpland);
					fDrawText(hWnd,vvi,vvj,vWm,vHm,_w,_h,szBuffer,vColorMass[0],NULL);
				}
			}
		}
	}
	if (view == 1 || view == 2 || view == 3)
	{
		MapView.InvalidateBitmap();
		MapView.OnDraw(hWnd);
		if (_FlagR == 1)
		{
			vW = MapEditable.GetTilePointsTableWidth();
			vH = MapEditable.GetTilePointsTableHeight();
			MapEditable.GoFirstRegion();
			while(pNextRegion = MapEditable.GetNextRegion())
				fDrawRegion(hWnd,pNextRegion->Rect,vWm,vHm,vW,vH,_REGION1,
				pNextRegion->Color,0xff*0.5);
		}
	}
	return 1;
}
// Добавить регион карты в массив
void fAddRegion(RegionMap _Rect)
{
	MapEditable.AddRegion(_Rect);
}
// Редактировать регион карты в массиве
void fEditRegion(RegionMap _Rect)
{
	MapEditable.EditRegion(_Rect);
}
// Удалить регион карты из цепочки по ID
void fDelRegion(int _Id)
{
	MapEditable.DelRegion(_Id);
}
// Взять регион карты из цепочки по ID
void fGetRegion(RegionMap &_Rect, int _Id)
{
	MapEditable.GetRegion(_Rect, _Id);
}
// Удалить все регионы карты из цепочки по типу региона
void fDelRegions(int _Type)
{
	MapEditable.DelRegions(_Type);
}

int fMode (int _Mode)
{
	if (_Mode < 0)
		return 0;
	
	if (_Mode == 1)
	{
		MapView.m_iViewFlags = VFL_LEVELS;
	}
	if (_Mode == 2)
	{
		MapView.m_iViewFlags = VFL_TILES | VFL_DOODADS | VFL_UNITS | VFL_WATER | VFL_BOUNDS | VFL_WEBOUNDS;
	}
	if (_Mode == 3)
	{
		MapView.m_iViewFlags = VFL_TILES | VFL_DOODADS | VFL_UNITS | VFL_WATER | VFL_BOUNDS | VFL_WEBOUNDS;
	}
	return 1;
}
// Инициализировать карту заново
void fOnInitialUpdate()
{
	MapView.OnInitialUpdate();
}
// Добавить объект декораций
void fDoodadWrite(float x, float y, int _Object)
{
	CDoodad newdoodad;
	RECT updRect;

	if (fCreateNewDoodad(newdoodad,x,y,&MapEditable,_Object))
	{
		MapEditable.AddDoodad(newdoodad);
		//pDoc->AddToUndoObj(newdoodad, UNDO_DOOD_ADD);
		//pDoc->SetModifiedFlag();
		updRect.left = updRect.right = (int) (-4 + (newdoodad.x - (MapEditable.GetMapCenterX()-64)) * MapView.m_pBitmapInfo->bV4Width / ((MapEditable.GetMapWidth()+1)*128));
		updRect.top = updRect.bottom = (int) (-4 + -1*((newdoodad.y - (MapEditable.GetMapCenterY()-64)) * MapView.m_pBitmapInfo->bV4Height / ((MapEditable.GetMapHeight()+1)*128) - MapView.m_pBitmapInfo->bV4Height));
		updRect.right += CR_WIDTH;
		updRect.bottom += CR_HEIGHT;
		MapView.InvalidateDoodadsBitmap(updRect);
	}
}
// Удалить объект декораций
void fDoodadRemove(float x, float y)
{
	//CMainFrame *pMainFrame = NULL;
	CDoodad doodad;
	RECT updRect;

	doodad = MapEditable.GetClosestDoodad(x, y);
	//pMainFrame = pTheApp->GetMainFrame();
	//if (pMainFrame) //NULL si pMainFrame n'a pas ete trouve
	//{
	if (MapEditable.GetDistance(x,y,doodad.x,doodad.y) <= TOOL_DOOD_DEFAULT_DIST)
	{
		//pDoc->AddToUndoObj(doodad, UNDO_DOOD_DEL);
		MapEditable.DelDoodad(doodad);
		//pDoc->SetModifiedFlag();
		updRect.left = updRect.right = (int) ((doodad.x - MapEditable.GetMapCenterX()) * MapView.m_pBitmapInfo->bV4Width / (MapEditable.GetMapWidth()*128));
		updRect.top = updRect.bottom = (int) (-1*((doodad.y - MapEditable.GetMapCenterY()) * MapView.m_pBitmapInfo->bV4Height / (MapEditable.GetMapHeight()*128) - MapView.m_pBitmapInfo->bV4Height));
		//updRect.InflateRect(CR_WIDTH,CR_HEIGHT);
		MapView.InvalidateDoodadsBitmap(updRect);
		//pView->InvalidateBitmapRect(updRect);
	}
	//}
}
// Взять координаты центра карты
void fGetMapCoordinatCenter(float &_x, float &_y)
{
	_x = MapView.m_pBitmapInfo->bV4Width;
	_y = MapView.m_pBitmapInfo->bV4Height;
}
// Нарисовать текст на окне
int fDrawText(HWND hwnd,int x, int y, int Wm, int Hm, int width, int height, char *text, COLORREF color, int _Flag)
{
  TCHAR str[100];// = (TCHAR*)text;//TEXT("Hello DrawText !!!");
  HWND wnd = hwnd;
  HDC dc  = GetDC(wnd);
  RECT rc;
  HFONT font;
  HGDIOBJ old;

  int w1;
  int h1;
  int w2;
  int h2;

  int min;
  int vFontSize;
  int vLen;

  swprintf(str, L"%S", text);
 
  if (width < height)
	  min = width;
  else
	  min = height;

  //-8 = 35;
  //-24 = 10;
  //y=0.64*x-30.4
  vFontSize = -min+2; //floor(0.64*min-30.4);
  if (_Flag == 1) vFontSize *= 0.75;
  font = CreateFont(vFontSize, 0, 0, 0, 0, ANSI_CHARSET, 0U, 0U, 0U, 0U, 0U, 0U, 0U, TEXT("Arial"));
  old  = SelectObject(dc, font);
 
  GetClientRect(wnd, &rc);
  h1 = (rc.bottom - rc.top) / (Hm+2);
  h2 = height;
  rc.top = h2 * y + h1;
  rc.bottom = rc.top + h2;
  w1 = (rc.right - rc.left) / (Wm+2);
  w2 = width;
  rc.left = w2 * x + w1;
  rc.right = rc.left + w2;
  SetBkMode(dc, TRANSPARENT); 
  SetTextColor(dc, color);  // цвет текста
 
  // вывести текст по середине(горизонтали)
  DrawText(dc, str, lstrlen(str), &rc, DT_CENTER);
 
  SelectObject(dc, old);
  ReleaseDC(wnd, dc);
  DeleteObject(font);
  getchar();
  return 0;
}
// Взять лист ID регионов
void fGetListIdRegions(int *&pListId, int &_N)
{
	MapEditable.GetListId(pListId,_N);
}
// Нарисовать объект
int fDrawObj(HWND hwnd,int x, int y, int Wm, int Hm, int width, int height, int type_obj, COLORREF color)
{
  RECT rc;
  RECT rect ;

  int w1;
  int h1;
  int w2;
  int h2;

  int x1;
  int x2;
  int y1;
  int y2;
  
  HPEN hpen;
  HBRUSH hbrush;
  POINT op;
  //hwnd //Получаем дескриптор окна консоли
  HDC hdc=GetDC(hwnd); //Получаем контекст устройства по полученному дескриптору

  GetClientRect(hwnd, &rc);
  h1 = (rc.bottom - rc.top) / (Hm+2);
  h2 = height;
  rc.top = h2 * y + h1;
  rc.bottom = rc.top + h2;
  w1 = (rc.right - rc.left) / (Wm+2);
  w2 = width;
  rc.left = w2 * x + w1;
  rc.right = rc.left + w2;
  if (type_obj == _LEFT2 ||
	  type_obj == _UP2 ||
	  type_obj == _RIGHT2 ||
	  type_obj == _DOWN2)
  {
	  rc.left+=2;
	  rc.top+=2;
	  rc.right-=2;
	  rc.bottom-=2;
  }
  switch (type_obj)
  {
	  case _LEFT:	// W
	  case _LEFT2:	// W2
		  x1 = rc.left;
		  y1 = rc.top;
		  x2 = rc.left;
		  y2 = rc.bottom;
		  break;
	  case _UP:		// N
	  case _UP2:	// N2
		  x1 = rc.left;
		  y1 = rc.top;
		  x2 = rc.right;
		  y2 = rc.top;
		  break;
	  case _RIGHT:	// E
	  case _RIGHT2:	// E2
		  x1 = rc.right;
		  y1 = rc.top;
		  x2 = rc.right;
		  y2 = rc.bottom;
		  break;
	  case _DOWN:	// S
	  case _DOWN2:	// S2
		  x1 = rc.left;
		  y1 = rc.bottom;
		  x2 = rc.right;
		  y2 = rc.bottom;
		  break;
	  case _RECTANGLE:	// R
	  case _RECTANGLE2:	// R2
	  case _RECTANGLE3:	// R3
		  x1 = rc.left;
		  y1 = rc.top;
		  x2 = rc.right;
		  y2 = rc.bottom;
		  break;
	  default:
		  x1 = 0;
		  y1 = 0;
		  x2 = 0;
		  y2 = 0;
		  break;
  }

  if ((type_obj > 0 && type_obj < 10) || (type_obj > 0x10 && type_obj < 0x20))
  {
	  hpen = CreatePen(PS_SOLID,1,color);
	  SelectObject(hdc,hpen); //Выбираем перо в контекст
	  MoveToEx(hdc,x1,y1,&op); //Ставим текущую точку в координаты x1, y1
	  LineTo(hdc,x2,y2); //Рисуем линию из текущей точки в точку x2, y2
	  DeleteObject(hpen);
  }
  if (type_obj >= 10 && type_obj <= 11)
  {
	  if (type_obj == 10)
	  {
		  SetRect (&rect, x1 + 2, y1 + 2,
			  x2 - 2, y2 - 2) ;
	  }
	  if (type_obj == 11)
	  {
		  SetRect (&rect, x1, y1,
			  x2, y2) ;
	  }
	  hbrush = CreateSolidBrush(color);
	  FillRect (hdc, &rect, hbrush) ;
	  DeleteObject(hbrush);
  }
  if (type_obj == 12)
  {
	  hpen = CreatePen(PS_SOLID,1,color);
	  SelectObject(hdc,hpen); //Выбираем перо в контекст
	  MoveToEx(hdc,x1,y1,&op); //Ставим текущую точку в координаты x1, y1
	  LineTo(hdc,x2,y1); //Рисуем линию из текущей точки в точку x2, y2
	  MoveToEx(hdc,x2,y1,&op); //Ставим текущую точку в координаты x1, y1
	  LineTo(hdc,x2,y2); //Рисуем линию из текущей точки в точку x2, y2
	  MoveToEx(hdc,x2,y2,&op); //Ставим текущую точку в координаты x1, y1
	  LineTo(hdc,x1,y2); //Рисуем линию из текущей точки в точку x2, y2
	  MoveToEx(hdc,x1,y2,&op); //Ставим текущую точку в координаты x1, y1
	  LineTo(hdc,x1,y1); //Рисуем линию из текущей точки в точку x2, y2
  }
  ReleaseDC(hwnd,hdc); //"Освобождаем" контекст
  return 0;
}
// Нарисовать регион карты
int fDrawRegion(HWND hwnd, RECT Region, int _Wm, int _Hm, int _W, int _H, int type_obj, COLORREF color, BYTE AlphaValue)
{
	RECT rc;
	RECT rect ;
	
	int w1;
	int h1;
	int w2;
	int h2;

	int x1;
	int x2;
	int y1;
	int y2;
  
	HPEN hpen;
	HBRUSH hbrush;
	HDC hdc=GetDC(hwnd); // получаем контекст устройства по полученному дескриптору

	HBITMAP hAlphaBitmap;
	HDC hAlphaDevice;
	BLENDFUNCTION vAlphaBlend;

	GetClientRect(hwnd, &rc);
	w1 = (rc.right - rc.left) / (_Wm+2);
	w2 = (w1*_Wm)/_W;
	rc.left = w1 + w2 * Region.left;
	rc.right = w1 + w2 * Region.right;
	h1 = (rc.bottom - rc.top) / (_Hm+2);
	h2 = (h1*_Hm)/_H;
	rc.top = h1 + h2 * Region.top;
	rc.bottom = h1 + h2 * Region.bottom;

	switch (type_obj)
	{
		case _REGION1:	// R1
		case _REGION2:	// R2
			x1 = rc.left;
			y1 = rc.top;
			x2 = rc.right;
			y2 = rc.bottom;
			break;
		default:
			x1 = 0;
			y1 = 0;
			x2 = 0;
			y2 = 0;
			break;
	}

	if (type_obj == 13 || type_obj == 14)
	{
		hAlphaBitmap = CreateCompatibleBitmap(hdc, 1, 1);
		hAlphaDevice = CreateCompatibleDC(hdc);
		// создаем совместимый графический дескриптор в памяти
		SelectObject(hAlphaDevice, hAlphaBitmap);
		// объединяем их
		SetPixelV(hAlphaDevice, 0, 0, color);
		// заливаем область заданным цветом
		
		memset(&vAlphaBlend, NULL, sizeof(BLENDFUNCTION));
		vAlphaBlend.SourceConstantAlpha = AlphaValue;
		// создаем пустое описание для функции, но указываем уровень заливки (0-255).
		AlphaBlend(hdc,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,
			hAlphaDevice, 0, 0, 1, 1, vAlphaBlend);
		// используем функцию с заданными параметрами
		SelectObject(hAlphaDevice,hAlphaBitmap);
		// разделяем объекты (если этого возможна будет утечка памяти).
		DeleteDC(hAlphaDevice);
		DeleteObject(hAlphaBitmap);
		// удаляем созданные в памяти объекты.
	  /*SetRect (&rect, x1, y1,
		  x2, y2) ;
	  hbrush = CreateSolidBrush(color);
	  FillRect (hdc, &rect, hbrush) ;
	  DeleteObject(hbrush);*/
	}
	if (type_obj == 13)
	{
		hpen = CreatePen(PS_SOLID,1,color);
		SelectObject(hdc,hpen); // выбираем перо в контекст
		MoveToEx(hdc,x1,y1,NULL); // ставим текущую точку в координаты x1, y1
		LineTo(hdc,x2,y1); // рисуем линию из текущей точки в точку с координами x2, y2
		MoveToEx(hdc,x2,y1,NULL); //
		LineTo(hdc,x2,y2); //
		MoveToEx(hdc,x2,y2,NULL); //
		LineTo(hdc,x1,y2); //
		MoveToEx(hdc,x1,y2,NULL); //
		LineTo(hdc,x1,y1); //
		DeleteObject(hpen);// удалить перо
	}
	ReleaseDC(hwnd,hdc); // "Освобождаем" контекст
	return 0;
}
/*
//------------------------------------------------------------------------------
#define SelectObjectF(MAIN,SUBOBJECT) HGDIOBJ hRe##SUBOBJECT = ::SelectObject(MAIN,SUBOBJECT)
#define SelectObjectE(MAIN,SUBOBJECT) ::SelectObject(MAIN,hRe##SUBOBJECT)
// аналог подобных макросов желательно иметь под рукой, если с WinAPI работаете.
//------------------------------------------------------------------------------
void __fastcall FiilRectAlpha(HDC hDestination, TRect Rect, COLORREF AlphaColor, BYTE AlphaValue)
// процедура по добавлению к графическому дескриптору (hDestination) "полу-прозрачной" области (Rect)
// с заданным цветом (AlphaColor) и уровнем прозрачности (AlphaValue)
{
    HBITMAP hAlphaBitmap = ::CreateCompatibleBitmap(hDestination, 1, 1);
    // создаем изображение в памяти с совметимыми параметрами, размером 1х1
    HDC hAlphaDevice = ::CreateCompatibleDC(hDestination);
    // создаем совместимый графический дескриптор в памяти.
    SelectObjectF(hAlphaDevice, hAlphaBitmap);
    // объединяем их.
    ::SetPixelV(hAlphaDevice, 0, 0, AlphaColor);
    // заливаем область заданным цветом.
    
    BLENDFUNCTION hAlphaBlend;
    memset(&hAlphaBlend, NULL, sizeof(BLENDFUNCTION));
    hAlphaBlend.SourceconstantAlpha = AlphaValue;
    // создаем пустое описание для функции, но указываем уровень заливки (0-255).
    
    ::AlphaBlend(hDestination,Rect.Left,Rect.Top,Rect.Right,Rect.Bottom,
        hAlphaDevice, 0, 0, 1, 1, hAplhaBlend);
    // используем функцию с заданными параметрами.
    
    SelectObjectE(hAlphaDevice,hAlphaBitmap);
    // разделяем объекты (если этого возможна будет утечка памяти).
    ::DeleteDC(hAlphaDevice);
    ::DeleteObject(hAlphaBitmap);
    // удаляем созданные в памяти объекты.
}
*/
//------------------------------------------------------------------------------
// Открываем файл
int fOpenFile (char* pFullPath, BYTE* &pTemp, int &Size)
{
	FILE *pInPutF;		// указатель на файл
	int vResult;		// информационная переменная

	if (pFullPath == NULL && pTemp != NULL)
		return 0;
	//---------------------------------------------------
	pInPutF = fopen(pFullPath,"rb");	// открыть файл
	if (pInPutF == NULL) return 0;
	//-------------Запись в массив------------
	Size = filelength(fileno(pInPutF));
	pTemp = new BYTE[Size];
	vResult = fread (pTemp,1,Size,pInPutF);	// считываем массив байтов
	vResult = fclose(pInPutF);	// закрываем файл
	//---------------------------------------------------
	return 1;
}
// Открываем файл ресурсов
int fOpenFileRes (int IdRes, WCHAR *TypeRes, BYTE* &pTemp, int &Size)
{
	HGLOBAL hResource;
	HRSRC resHandler;
	void *res;

	if (IdRes < 0 || TypeRes == NULL || pTemp != NULL)
		return 0;
	//---------------------------------------------------
	resHandler = FindResource(NULL, (LPCWSTR)IdRes, TypeRes);
	if (!resHandler)
		return 0;
	//---------------------------------------------------
	hResource = LoadResource(NULL, resHandler);
	Size = SizeofResource(NULL, resHandler);
	res = LockResource (hResource);
	pTemp = (BYTE *)res;
	FreeResource(hResource);
	//---------------------------------------------------
	return 1;
}
// Обнуляем возврат - каретки
void fResetCarriageReturn (BYTE* pTemp, int Size)
{
	for (int vvi=0;vvi<Size-1;vvi++)
	{
		if(*(pTemp+vvi) == 0x0d && *(pTemp+1+vvi) == 0x0a)
		{
			*(pTemp+vvi) = NULL;
			*(pTemp+1+vvi) = NULL;
		}
	}
}
////////////////////////////////////////////////////////////////////
using namespace System::Runtime::InteropServices;
//System::String^ to char*
int fSysStringToChar(System::String^ Str, char *&pStr) 
{
	if (Str == "")
		return 0;
	pStr = (char*)(void*)Marshal::StringToHGlobalAnsi(Str);
	return 1;
}
////////////////////////////////////////////////////////////////////
// char* to System::String^
int fCharToSysString(char* pStr, System::String^ &Str) 
{
	wchar_t wchr;
	char *chr=new char[]=pStr;
	Str = "";
	for(int vvi=0;chr[vvi]!='\0';vvi++)
	{
		 MultiByteToWideChar(CP_ACP, 0, chr+vvi, - 1, &wchr, 1);
		 Str+=wchr;
	}
	return 1;
}
////////////////////////////////////////////////////////////////////
int fCheckInteger (char *pStr)
{
	//
	char *chr=new char[]=pStr;
	for(int vvi=0;chr[vvi]!='\0';vvi++)
	{
		if (((chr[vvi] < 48 || chr[vvi] > 57) && chr[vvi] != '-') ||
			(chr[vvi] == '-' && vvi != 0) ||
			(chr[vvi] == '-' && chr[vvi+1] == '\0') ||
			(chr[vvi] == '-' && chr[vvi+1] == '0'))
			return 0;
	}
	return 1;
}
////////////////////////////////////////////////////////////////////
int fCheckDouble (char *pStr, char Sep)
{
	//
	char *chr=new char[]=pStr;
	int vFlag;
	if (Sep != '.' && Sep != ',')
		return 0;
	vFlag = 0;
	for(int vvi=0;chr[vvi]!='\0';vvi++)
	{
		if (vFlag == 1 && chr[vvi] == Sep)
			return 0;
		if (vFlag == 0 && chr[vvi] == Sep)
			vFlag = 1;
		if (((chr[vvi] < 48 || chr[vvi] > 57) && chr[vvi] != '-' && chr[vvi] != Sep) ||
			(chr[vvi] == '-' && vvi != 0) ||
			(chr[vvi] == '-' && chr[vvi+1] == '\0') ||
			(chr[vvi] == '-' && chr[vvi+1] == '0') ||
			(chr[vvi] == Sep && chr[vvi+1] == '\0') ||
			(chr[vvi] == '-' && chr[vvi+1] == Sep))
			return 0;
	}
	return 1;
}
////////////////////////////////////////////////////////////////////
int fCheckInteger2 (System::String ^_Str)
{
	//
	int vStrLen;
	if (_Str == "")
		return 0;
	vStrLen = _Str->Length;
	if (_Str->IndexOf("-" + "0") > 0)
		return 0;
	for (int vvi=0;vvi<vStrLen;vvi++)
	{
		if (((_Str[vvi] < 48 || _Str[vvi] > 57) && _Str[vvi] != '-') ||
			(_Str[vvi] == '-' && vvi != 0) ||
			(_Str[vvi] == '-' && vStrLen == 1))
			return 0;
	}
	return 1;
}
////////////////////////////////////////////////////////////////////
int fCheckDouble2 (System::String ^_Str, char Sep)
{
	//
	int vStrLen;
	if (_Str == "")
		return 0;
	vStrLen = _Str->Length;
	int vFlag;
	if (Sep != '.' && Sep != ',')
		return 0;
	if (_Str->IndexOf("-" + "0") > 0 || _Str->IndexOf("-" + Sep) > 0)
		return 0;
	vFlag = 0;
	for (int vvi=0;vvi<vStrLen;vvi++)
	{
		if (vFlag == 1 && _Str[vvi] == Sep)
			return 0;
		if (vFlag == 0 && _Str[vvi] == Sep)
			vFlag = 1;
		if (((_Str[vvi] < 48 || _Str[vvi] > 57) && _Str[vvi] != '-' && _Str[vvi] != Sep) ||
			(_Str[vvi] == '-' && vvi != 0) ||
			(_Str[vvi] == '-' && vStrLen == 1) ||
			(_Str[vvi] == Sep && vvi == vStrLen-1))
			return 0;
	}
	return 1;
}
////////////////////////////////////////////////////////////////////