Программы для выполнения лаб 1 и 2 / KALMAN / SOURCE / SOURCE / DRAW

#include <owl\owlpch.h>
#pragma hdrstop

#include <string.h>

#include "firstapp.h"
#include "w-data.h"
#include "tools.h"

int sX, sY, mX, mY, sizeX, startX, sizeY;
double stepX;

void PaintZero(TDC &dc,	TVector &w_x);
double PaintOne(TDC &dc,	TMatrix &w_x, unsigned index);
void PaintTwo(TDC &dc, TPen &penOne, TPen &penTwo,
	TMatrix &w_x, TMatrix &w_y, unsigned index, int doubleflag);
void PaintJ(TDC &dc, TRect drawRect, TMatrix &w_j);

void PaintData(TDC& dc, TRect& rect, BOOL Optimize)
{
		char Msg[SetupTitleLength+12+70+20],
				 AtName[SetupTitleLength+1], GrName[11];
		App->AttemptName->GetText(AtName, SetupTitleLength);

		FirstSetup *p;
		for (p = FirstSetupHistory.Root; p; p = p->Next)
			if (!strcmp(p->Title, AtName))
				break;

		BOOL found = FALSE;

		if (p)
		{
			App->GraphicName->GetText(GrName, 10);
			sprintf(Msg,
				"'%s'",
					AtName);

			found = p->Complete;
		}
		else
			strcpy(Msg, "Нет данных");

		TRect wrect;
		TSize textExtent;

		App->Client->GetWindowRect(wrect);
		if (!Optimize)
		{
			dc.SelectStockObject(GRAY_BRUSH);
			dc.SetTextAlign(TA_CENTER|TA_TOP);
			dc.SetBkMode(TRANSPARENT);
			dc.SetTextColor(TColor::LtRed);
			dc.ExtTextOut((wrect.right-wrect.left)>>1, 3,
										ETO_CLIPPED, &rect, Msg, strlen(Msg));
		}

		TBrush brush(TColor::Gray), whitebrush(TColor::White);
		TPen graypen(TColor::Gray), bluepen(TColor::LtBlue),
			redpen(TColor::LtRed);
		TRect drawRect;
		unsigned mode;

		dc.SelectObject(graypen);

		dc.GetTextExtent(Msg, strlen(Msg), textExtent);
		drawRect.top = 6 + textExtent.cy + 1;
		drawRect.left = 3 + 1;
		drawRect.right = (wrect.right-wrect.left)-3 - 20 - 1;
		drawRect.bottom = (wrect.bottom-wrect.top)-3 - 20 - 1;
		dc.SelectObject(whitebrush);
		dc.Rectangle(drawRect);
		drawRect.InflatedBy(1, 1);
		dc.FrameRect(drawRect, brush);
		mX = ((sizeX = (drawRect.right-(startX=drawRect.left))) * HMagnify) >> 1;
		mY = ((sizeY = (drawRect.bottom-drawRect.top)) * VMagnify) >> 1;
		sX = mX - long(mX)*HShift/HMagnify/5 + drawRect.left;
		sY = mY - long(mY)*VShift/VMagnify/5 + drawRect.top;
		dc.MoveTo(drawRect.left, sY);
		dc.LineTo(drawRect.right, sY);
		dc.MoveTo(drawRect.left, drawRect.top);
		dc.LineTo(drawRect.left, drawRect.bottom);

		if (found)
		{
			dc.IntersectClipRect(drawRect);

			mode = App->GraphicName->GetSelIndex();

			startX -= long(sizeX)*HShift/10;
			stepX = double(sizeX) * HMagnify / w_e.width;

			dc.SelectObject(bluepen);

			switch (mode)
			{
				case 0:
				case 1:
					PaintOne(dc, w_k, mode == 1);
					break;
				case 2:
					PaintZero(dc, w_w);
					break;
				case 3:
				case 5:
					PaintTwo(dc, bluepen, redpen, w_e, w_r, mode == 5, TRUE);
					break;
				case 4:
				case 6:
					{
						double max = PaintOne(dc, w_ne, mode == 6);
						dc.SelectObject(redpen);
						dc.MoveTo(drawRect.left+1, sY-mY/max);
						dc.LineTo(drawRect.right-1, sY-mY/max);
						dc.MoveTo(drawRect.left+1, sY+mY/max);
						dc.LineTo(drawRect.right-1, sY+mY/max);
					}
					break;
				case 7:
				case 8:
					PaintTwo(dc, bluepen, redpen, w_y, w_t, mode == 8, FALSE);
					break;
				default:
					App->Client->MessageBox("Selection not found for GraphicName", "Error", MB_OK|MB_ICONSTOP);
			}

			if (VMagnify == HMagnify && HMagnify == 1)
				PaintJ(dc, drawRect, w_j);

		}
		dc.RestoreObjects();
}

void PaintText(TDC &dc, double val)
{
	double y = (long(val * 97))*0.01;
	unsigned ly, hy;
	char buffer[22];
	TPen blackpen(TColor::Black);

	dc.SetBkMode(TRANSPARENT);
	sprintf(buffer, " %6.2lf", y);
	ly = sY-mY*y/val;
	dc.SetTextAlign(TA_TOP|TA_LEFT);
	dc.TextOut(startX+5, sY-mY+2, buffer);
	sprintf(buffer, "%6.2lf", -y);
	hy = sY+mY*y/val;
	dc.SetTextAlign(TA_BOTTOM|TA_LEFT);
	dc.TextOut(startX+5, sY+mY-2, buffer);
	dc.SelectObject(blackpen);
	dc.MoveTo(startX-3, ly); dc.LineTo(startX+3, ly);
	dc.MoveTo(startX-3, hy); dc.LineTo(startX+3, hy);
}

void PaintZero(TDC &dc,
	TVector &w_x)
{
	double max = w_x.getmax();

	dc.MoveTo(startX, sY-mY*w_x[0]/max);
	for (unsigned x = 1; x < w_x.length; x++)
		dc.LineTo(startX+stepX*x, sY-mY*w_x[x]/max);

	PaintText(dc, max);
}

double PaintOne(TDC &dc,
	TMatrix &w_x, unsigned index)
{
	TVector max = w_x.getmmax();

	dc.MoveTo(startX, sY-mY*w_x[0][index]/max[index]);
	for (unsigned x = 1; x < w_x.width; x++)
		dc.LineTo(startX+stepX*x, sY-mY*w_x[x][index]/max[index]);

	PaintText(dc, max[index]);

	return max[index];
}

void PaintTwo(TDC &dc, TPen &penOne, TPen &penTwo,
	TMatrix &w_x, TMatrix &w_y, unsigned index, int doubleflag)
{
	TVector max_x = w_x.getmmax(),
					max_y = w_y.getmmax();
	double max;
	if (max_x[index] < max_y[index])
		max = max_y[index];
	else
		max = max_x[index];

	dc.SelectObject(penTwo);

	dc.MoveTo(startX, sY-mY*w_y[0][index]/max);
	for (unsigned x = 1; x < w_y.width-1; x++)
		dc.LineTo(startX+stepX*x, sY-mY*w_y[x][index]/max);
	if (doubleflag)
	{
		dc.MoveTo(startX, sY+mY*w_r[0][index]/max);
		for (x = 1; x < w_y.width-1; x++)
			dc.LineTo(startX+stepX*x, sY+mY*w_y[x][index]/max);
	}

	dc.SelectObject(penOne);

	dc.MoveTo(startX, sY-mY*w_x[0][index]/max);
	for (x = 1; x < w_x.width; x++)
		dc.LineTo(startX+stepX*x, sY-mY*w_x[x][index]/max);

	PaintText(dc, max);
}

void PaintJ(TDC &dc, TRect drawRect, TMatrix &w_j)
{
	unsigned x, y, width, height;
	char buffer[2][54];
	TSize s[2];
	TBrush graybrush(TColor::Gray);

	for (x = 0; x < 2; x++)
	{
		sprintf(buffer[x], "J%d[1] = %6.2lf, J%d[2] = %6.2lf",
			x+1, w_j[0][x], x+1, w_j[1][x]);
		s[x] = dc.GetTextExtent(buffer[x], strlen(buffer[x]));
	}

	width = max(s[0].cx, s[1].cx);
	height = s[0].cy + s[1].cy;

	drawRect.left = drawRect.right - width - 20;
	drawRect.top = drawRect.bottom - height - 15;
	drawRect.right -= 10;
	drawRect.bottom -= 7;
	dc.FrameRect(drawRect, graybrush);

	for (y = drawRect.top; y <= drawRect.bottom; y++)
		for (x = drawRect.left + (y & 1); x <= drawRect.right; x += 2)
			dc.SetPixel(x, y, TColor::White);

	dc.SetTextColor(TColor::Gray);
	dc.SetTextAlign(TA_LEFT|TA_TOP);
	dc.TextOut(drawRect.left+5, drawRect.top+3, buffer[0]);
	dc.TextOut(drawRect.left+5, drawRect.top+s[0].cy+5, buffer[1]);
}

void PaintDataOnly(TWindow *parent)
{
	HWND hwnd = parent->HWindow;
	HDC hdc = GetDC(hwnd);
	TRect rect;

	parent->GetWindowRect(rect);

	PaintData(hdc, rect, TRUE);

	ReleaseDC(hwnd, hdc);
}