WebSVN – Kolibri OS – Diff – /programs/other/graph/hello.cpp


 
#include "func.h"
#include "parser.h"
#include "kolibri.h"
#include "use_library.h"
 
const char header[] = "Graph";
const char empty_text[] = "No function loaded. Type file name and press Enter. ";
const char er_file_not_found[] = "Cannot open file. ";
const char str_filename[]="Filename:";
const char str_editfile[]="Edit";
 
// íà÷àëüíûå ðàçìåðû
#define WND_W 400
#define WND_H 300
 
#define LIGHTGREEN 0xff0000
#define WHITE 0xffffff
#define BLACK 0x0
#define LIGHTBLUE 0x0000ff
#define LIGHTRED 0xff0000
 
// font colors
#define BIGFONTCOLOR BLACK
#define SMALLFONTCOLOR BLACK
 
#define THREE 3.0
// minimum space: 3 pixels
 
#define BIG_HEIGHT 4.0
#define SMALL_HEIGHT 2.0
#define TEXT_X 15.0
// numeric format for output
#define FORMAT "%f"
// format for two coords
#define FORMAT_COORD "(%f,%f)"
// special value to text if enough space
#define FORMAT_TEST "0.00"
 
#define DELTA_BIG 1.0
#define DELTA_SMALL 0.1
 
double *points;
Dword point_count = 0;
double x1,y1,x2,y2;
char *funct = NULL;
 
char edit_path[1024];
//Dword editbox_y = WND_H - 16, editbox_w = WND_W - 70;
edit_box mybox = {0,9*8-5,WND_H - 16-32,0xffffff,0x6a9480,0,0x808080,0,99,(dword)&edit_path,0};
 
char *full_head;
 
char *HugeBuf = NULL;
 
//char fuck[64] = "$this is a fucking marker$";
// ïàðàìåòðû êîìàíäíîé ñòðîêè
#ifdef AUTOBUILD
extern char params[1024];
char params[1024];
#else
char params[1024] = "_FIND_ME_";
#endif
 
/*
 
  fucking piece of shit
 
  */
 
// constructor of TCoord
TCoord coord(double x, double y)
{
  TCoord r;
  r.x = x;
  r.y = y;
  return r;
}
 
// move and scale mathematical coords to fit screen coords
TCoord mat2Graf(TCoord c, TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax)
{
  TCoord r;
  if (c.x > mMax.x) 
    c.x = mMax.x;
  if (c.x < mMin.x) 
    c.x = mMin.x;
  if (c.y > mMax.y) 
    c.y = mMax.y;
  if (c.y < mMin.y) 
    c.y = mMin.y;
  r.x = (scrMax.x - scrMin.x) / (mMax.x - mMin.x) * (c.x - mMin.x) + scrMin.x;
  r.y = (scrMax.y - scrMin.y) / (mMax.y - mMin.y) * (mMax.y - c.y) + scrMin.y;
 
  return r;
}
 
// double-îáåðòêè
void line_d( double x1, double y1, double x2, double y2)
{
   line(di(x1), di(y1), di(x2), di(y2));
}
 
void outtextxy_d( double x, double y, char * text, int len)
{
   outtextxy(di(x), di(y), text, len);
}
 
// huge function to draw all the stuff except the function itself
void drawAxis( TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax)
{
  TCoord cZero={0.0,0.0},
	   gMin, gMax, gZero, step;
  TCoord from, to;
  double i=0.0;
  int j;
  double xmin, xmin2, ymin, ymin2;
  char buf[30]="";
 
 
// scr means Screen(bounding rect)
// m   means Mathematical
// g   means Graphic(real screen position)
 
  //rtlDebugOutString("draw axis called\n");
 
  //format(debuf, 30, "test: %f,%f,%f,%f\n", 123.45, 1.0, -0.9, 12.57);
  //rtlDebugOutString(debuf);
 
  gMin = mat2Graf(mMin, scrMin, scrMax, mMin, mMax);
  gMax = mat2Graf(mMax, scrMin, scrMax, mMin, mMax);
  gZero = mat2Graf(cZero, scrMin, scrMax, mMin, mMax);
 
  // clear
 // setcolor(WHITE);
 //rectangle(di(gMin.x), di(gMin.y), di(gMax.x), di(gMax.y));
  // ftopku
 
  setcolor(BLACK);
  // osy X
  line_d(gMin.x, gZero.y ,gMax.x, gZero.y);
  // osy Y
  line_d(gZero.x, gMin.y, gZero.x, gMax.y);
  // bounding rect
  line_d(gMin.x, gMin.y, gMax.x, gMin.y);
  line_d(gMin.x, gMax.y, gMax.x, gMax.y);
 
  line_d(gMin.x, gMin.y, gMin.x, gMax.y);
  line_d(gMax.x, gMin.y, gMax.x, gMax.y);
 
  // coords of the rect : lower left
  format(buf, 30, FORMAT_COORD, x1, y1);
  //rtlDebugOutString(buf);
  outtextxy_d(gMin.x, gMin.y + textheight(buf, 20), buf, 20);
  // upper left
  format(buf, 30, FORMAT_COORD, x1, y2);
  outtextxy_d(gMin.x, gMax.y - textheight(buf, 20), buf, 20);
  // lower right
  format(buf, 30, FORMAT_COORD, x2, y1);
  outtextxy_d(gMax.x - textwidth(buf, 20), gMin.y + textheight(buf, 20), buf, 20);
  // upper right
  format(buf, 30, FORMAT_COORD, x2, y2);
  outtextxy_d(gMax.x - textwidth(buf, 20), gMax.y - textheight(buf, 20), buf, 20);
 
  //rtlDebugOutString("some lines painted\n");
 
 
  step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x);
  step.y = (mMax.y - mMin.y) / (scrMax.y - scrMin.y);
 
// round values
  xmin = id(di((mMin.x / DELTA_BIG) * DELTA_BIG));
  ymin = id(di((mMin.y / DELTA_BIG) * DELTA_BIG));
 
  // (0,0)
 
  if ((x1 * x2 <= 0.0) && (y1 * y2 <= 0.0))
  {
	  from.x=0.0;
	  from.y=0.0;
	  from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
	  setcolor(BLACK);
	  format(buf, 30, FORMAT, 0.0);
	  outtextxy_d(from.x - textwidth(buf, 20), from.y + textheight(buf, 20), buf, 20);
  }
 
 
  // big marks on X
  //settextstyle(0, 0, 1);
  if (DELTA_BIG / step.x > THREE)
  {
    for (i = xmin; i <= mMax.x; i += DELTA_BIG)
    {
	  if (i != 0.0)
	  {
		  from.x = i;
		  to.x = from.x;
		  from.y = -BIG_HEIGHT * step.y;
		  to.y = BIG_HEIGHT * step.y;
		  from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
		  to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
		  setcolor(BLACK);
		  line_d(from.x, from.y, to.x, to.y);
		  // write number
		  format(buf, 30, FORMAT, i);
		  // if it fits in the GAP, then write it
		  if (from.y > scrMin.y && (DELTA_BIG > (textwidth(buf, 20) + 1.0) * step.x))
		  {
			   setcolor(BIGFONTCOLOR);
			   outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20);
		  }
	  }
    }
  }
  //rtlDebugOutString("big marks x painted\n");
 
  // big marks on Y
  if (DELTA_BIG / step.y > THREE)
  {
    for (i = ymin; i <= mMax.y; i += DELTA_BIG)
    {
	  if (i != 0.0)
	  {
		  from.y = i;
		  to.y = from.y;
		  from.x = -BIG_HEIGHT * step.x;
		  to.x = BIG_HEIGHT * step.x;
		  from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
		  to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
		  setcolor(BLACK);
		  line_d(from.x, from.y, to.x, to.y);
		  format(buf, 30, FORMAT, i);
		  if (from.x > scrMin.x && (DELTA_BIG > textheight(buf, 20) * step.y))
		  {
			   setcolor(BIGFONTCOLOR);
			 outtextxy_d(from.x + TEXT_X, to.y - textheight(buf, 20) / 2.0, buf, 20);
		  }
	  }
    }
  }
 
  xmin2 = id(di(mMin.x / DELTA_SMALL)) * DELTA_SMALL;
  ymin2 = id(di(mMin.y / DELTA_SMALL)) * DELTA_SMALL;
 
  if (DELTA_SMALL / step.x  > THREE)
  {
    j = di((( - xmin + xmin2 ) / DELTA_SMALL));
    for (i = xmin2; i <= mMax.x; i += DELTA_SMALL, j++)
    {
      if (j % 10 == 0)
      {
      // we need to skip every tenth mark, to avoid overwriting big marks
		j = 0;
		continue;
      }
      from.x = i;
      to.x = from.x;
      from.y = -SMALL_HEIGHT * step.y;
      to.y = SMALL_HEIGHT * step.y;
      from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
	  to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
      setcolor(BLACK);
      line_d(from.x, from.y, to.x, to.y);
      format(buf, 30, FORMAT, i);
	  
      if (from.y > scrMin.y && (DELTA_SMALL > textwidth(buf, 20) * step.x))
      {
		setcolor(SMALLFONTCOLOR);
		outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20);
      }
	  
 
    }
      
  }
 
  // finally small marks on Y
  if (DELTA_SMALL / step.y > THREE)
  {
    //rtlDebugOutString("really small marks y painted\n");
    j = di((( - ymin + ymin2) / DELTA_SMALL));
    for (i = ymin2; i <= mMax.y; i += DELTA_SMALL, j++)
    {
      if (j % 10 == 0)
      {
      // we need to skip every tenth, to avoid overwriting
		j = 0;
		continue;
      }
      from.y = i;
      to.y = from.y;
      from.x = -SMALL_HEIGHT * step.x;
      to.x = SMALL_HEIGHT * step.x;
      from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
      to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
      setcolor(BLACK);
      line_d(from.x, from.y, to.x, to.y);
      format(buf, 30, FORMAT, i);
      if (from.x > scrMin.x && (DELTA_SMALL > textheight(buf, 20) * step.y))
      {
       	setcolor(SMALLFONTCOLOR);
       	outtextxy_d(from.x + TEXT_X, from.y - textheight(buf, 20) / 2.0, buf, 20);
      }
    }
  }
 
}
 
/*
  ends fucking piece of shit
*/
 
void drawFunction( function_t fi, TCoord scrMin, TCoord scrMax,
		   TCoord mMin, TCoord mMax, DWORD color)
{
  double x;
  double y;
  int firstPoint = 1;
  TCoord p, p0 = {0.0, 0.0}, step;
 
  drawAxis(scrMin, scrMax, mMin, mMax);
 
  setcolor(color);
  step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x);
 
  for (x = mMin.x; x < mMax.x; x += step.x)
  {
    y = fi(x);
// function is defined here and gets in the range
    if (1) // òóò áûëî óñëîâèå, ÷òî ôóíêöèÿ ïðàâèëüíî âû÷èñëåíà
    {
      if ((y > mMin.y) && (y < mMax.y))
      {
	      p = mat2Graf(coord(x, y), scrMin, scrMax, mMin, mMax);
	// if it's our first point, only remember its coords
	// otherwise, draw a line_d from prev to current
      	if (firstPoint == 0)
        {
      	  line_d(p0.x, p0.y, p.x, p.y);
        }
      	else
    	  firstPoint = 0;
 
     	p0 = p;
      }
      else // too big/small
      {
	      firstPoint = 1;
      }
    }
    else // no value
    {
      firstPoint = 1;
    }
  }
 
}
 
struct kosBDVK 
{
	Dword attrib;
	Dword name_type;
	Dword create_time;
	Dword create_date;
	Dword access_time;
	Dword access_date;
	Dword modify_time;
	Dword modify_date;
	Dword size_low;
	Dword size_high;	
};
 
// èòîãîâàÿ âåðñèÿ ÷èòàëêè òåêñòîâûõ ôàéëîâ
int load_points3()
{
	kosFileInfo fileInfo;
	kosBDVK bdvk;
	int filePointer = 0;
 
 
	int i,j,k;
	double d;
	Dword filesize, num_number;
 
	double *p2;
 
	if (edit_path[0] == '\0')
		return 0;
 
	// get file size
	strcpy(fileInfo.fileURL,edit_path);
	fileInfo.OffsetLow = 0;
	fileInfo.OffsetHigh = 0;
	fileInfo.dataCount = 0;
	fileInfo.rwMode = 5;
	fileInfo.bufferPtr = (Byte *)&bdvk;
	Dword rr = kos_FileSystemAccess( &(fileInfo) ); // â CKosFile íåò îïðåäåëåíèÿ ðàçìåðà
	sprintf(debuf, "getsize: %U\n", rr);
	rtlDebugOutString(debuf);
	if (rr != 0)
	{
		kos_WriteTextToWindow(10,10,0,0x00,(char*)er_file_not_found,strlen(er_file_not_found));
		return 0;
	}
 
	filesize = bdvk.size_low;
	num_number = filesize / 2;
 
	HugeBuf = (char *)allocmem(filesize + 1); // ðàçáèðàåì êàê ñòðîêó, îòñþäà òåðìèíàòîð \0
 
	for (i=0;i
		HugeBuf[i] = 0;
 
	strcpy(fileInfo.fileURL,edit_path);
	fileInfo.OffsetLow = 0;
 
	fileInfo.OffsetHigh = 0;
	fileInfo.dataCount = filesize;
	fileInfo.rwMode = 0;
	fileInfo.bufferPtr = (Byte *)HugeBuf;
	rr = kos_FileSystemAccess( &(fileInfo) );	// êàêàÿ-òî ïðîáëåìà ñ hands.dll, CKosFile íå ðàáîòàë
		
	sprintf(debuf, "read3: %U\n", rr);
	rtlDebugOutString(debuf);
 
	strcpy(full_head, header);
	strcpy(full_head+strlen(full_head), " - ");
	strcpy(full_head+strlen(full_head), edit_path);		// bad code
 
	// à òåïåðü ðàçîáðàòüñÿ â ýòîì
 
	i=0;
	k=0;
	while (i < filesize)
	{
 
		while (isalpha(HugeBuf[i]) && i
		if (i == filesize) break;
		if (k==4 && HugeBuf[i] == '=')
		{
			//sprintf(debuf,"function: %S",HugeBuf + i);
			//rtlDebugOutString(debuf);
			// we have a function here
			//HugeBuf[0] = ' ';
			funct = HugeBuf + i + 1;
			strcpy(full_head+strlen(full_head), ". Function y=");
			strcpy(full_head+strlen(full_head), funct);
			return 1;
		}
 
		d = convert(HugeBuf+i, &j);
		if (d == ERROR)
		{
			sprintf(debuf, "Error in input file, byte %U, count %U\n", i, k);
			rtlDebugOutString(debuf);
			kos_WriteTextToWindow(10, 10, 0, 0x00, (char*)debuf, strlen(debuf));
			return 0;
		}
		if (d == ERROR_END)
		{
			rtlDebugOutString("EOF :)!\n");
			break;
		}
		
		i+=j;
		switch (k)
		{
		case 0:
			x1=d;
			break;
		case 1:
			x2=d;
			break;
		case 2:
			y1=d;
			break;
		case 3:
			y2=d;
			break;
		default:
			{
				if (p2 == NULL)
					p2 = (double *)allocmem(num_number * 8);
				p2[k-4]=d;
			}
		}
		k++;
	}
//	format(debuf, 30, "(%f,%f)-(%f,%f)",x1,y1,x2,y2);
//	rtlDebugOutString(debuf);
	point_count=(k - 4)/2;
 
	//
	points = (double *)allocmem(point_count * 2 * 8);
	for (i = 0; i < point_count * 2; i++)
		points[i] = p2[i];
	freemem(p2);
//	sprintf(debuf, "count: %U\n", point_count);
//	rtlDebugOutString(debuf);
	sprintf(debuf, ". Number of points: %U.", point_count);
	strcpy(full_head+strlen(full_head), debuf);
	freemem(HugeBuf);
	HugeBuf = NULL;
	return 1;
}
 
void LaunchTinypad()
{
	kosFileInfo fileInfo;
 
	strcpy(fileInfo.fileURL,"/sys/tinypad");
	fileInfo.OffsetLow = 0;
	fileInfo.OffsetHigh = (Dword)edit_path;
	fileInfo.rwMode = 7;	// launch
	kos_FileSystemAccess(&fileInfo);
 
}
 
// âû÷èñëèòü çàäàííóþ ôóíêöèþ èëè êóñî÷íî-ëèíåéíóþ ìåæäó òî÷êàìè
double fu(double x)
{
	int i;
	double res;
 
	
	if (funct)
	{
		set_exp(funct,x); 
		get_exp(&res);		// ïàðñèòü äëÿ êàæäîãî çíà÷åíèÿ õ? äà ÿ ñ óìà ñîøåë.
		return res;
	}
 
	if (point_count == 0)
	{
		return 0.0;
	}
 
	if (x <= points[0]) 
		return points[1];
	if (x >= points[(point_count-1) * 2])
		return points[(point_count-1) * 2 + 1];
 
	for (i = 0; i < point_count; i++)
	{
		if ((x >= points[2 * i]) && (x < points[2 * (i + 1)]))
			break;
	}
 
	return (x - points[2 * i]) / (points[2 * (i + 1)] - points[2 * i])
		* (points[2 * (i + 1) + 1] - points[2 * i + 1]) + points[2 * i + 1];
 
}
 
void draw_window(void)
{
 
 
	double xx0=0.0, yy0=0.0;
	sProcessInfo info;
	Dword wi, he;
	void *p;
 
	for (int i = 0; i < 1024; i++)
		info.rawData[i] = 0;
	kos_ProcessInfo(&info, 0xFFFFFFFF);
 
	p = info.rawData + 42;			// magic
	wi = *(Dword *)(p);
	he = *(Dword *)((Byte *)p + 4);
 
	if (wi == 0) 
		wi = WND_W;
	if (he == 0)
		he = WND_H;
 
	mybox.top = he - 45;
	mybox.width = wi - mybox.left - 80;
 
 
	kos_WindowRedrawStatus(1);
	kos_DefineAndDrawWindow(10,40,WND_W,WND_H, 0x33,0xFFFFFF,0,0,(Dword)full_head);
	kos_WindowRedrawStatus(2);
 
	if (info.rawData[70]&0x04) return; //íè÷åãî íå äåëàòü åñëè îêíî ñõëîïíóòî â çàãîëîâîê
 
	if (point_count == 0 && funct == NULL)
	{
		kos_WriteTextToWindow((wi - 6 * strlen(empty_text))/2,he/2,0,0x000000,(char *)empty_text,strlen(empty_text));
	}
	else
	{
		drawFunction(&fu, coord(10, 20), coord(id(wi - 20), id(he - 70)),
							coord(x1,y1), coord(x2,y2), 0x00ff0000);
 
	}
 
	kos_WriteTextToWindow(4, mybox.top + 4, 0, 0, (char*)str_filename, strlen(str_filename));
 
	if ((void*)edit_box_draw != NULL)
		edit_box_draw((DWORD)&mybox);
 
	kos_DefineButton(wi - 70, mybox.top, 50, 12, 5, 0xc0c0c0);
	kos_WriteTextToWindow(wi - 58, mybox.top + 4, 0, 0, (char*)str_editfile, strlen(str_editfile));
 
 
 
}
 
void kos_Main()
{
	kos_InitHeap();
	full_head = (char*)allocmem(300);
	strcpy(full_head, "Graph");
	load_edit_box();
	if (params[0]) // fuck[0] for debug
	{
		rtlDebugOutString("launched with params");
		rtlDebugOutString((char*)params);
		strcpy(edit_path, params);
		//rtlDebugOutString((char*)edit_path);
		load_points3();
	}
	rtlDebugOutString("data loaded.\n");
	draw_window();
	for (;;)
	{
		edit_box_mouse((dword)&mybox);
		switch (kos_WaitForEvent())
		{
		case 1:
			draw_window();
			break;
		case 2:
			// key pressed, read it
			Byte keyCode;
			kos_GetKey(keyCode);
 
			switch (keyCode)
				{
					case 0x0D:
							if (HugeBuf!=NULL)
							{
								//sprintf(debuf, "freemem: HugeBuf = %X", HugeBuf);
								//rtlDebugOutString(debuf);
								freemem((void*)HugeBuf);		// ÷òî çà áàã - ïîíÿòü íå ìîãó.
								HugeBuf = NULL;
								funct = NULL;
							}
							if (points!=NULL)
							{
								//sprintf(debuf, "freemem: points = %X", points);
								//rtlDebugOutString(debuf);
								freemem((void*)points);		// è òóò. íó íå îáðàùàþñü ÿ ê ýòîìó óêàçàòåëþ, òîëüêî ïàìÿòü â íåãî
														// ïîòîì ñíîâà âûäåëÿþ
								points = NULL;
							}
							point_count = 0;
							kos_DrawBar(10,10,200,20,0xFFFFFF); // ôîí äëÿ ñîîáùåíèé îá îøèáêàõ
							if (load_points3())
								draw_window();
							break;
					default:
						{
							__asm
							{
								mov ah, keyCode
							}
							edit_box_key((dword)&mybox);
						}
				}
			break;
 
 
		case 3:
			// button pressed; we have only one button, close
			Dword button;
			kos_GetButtonID(button);
			if (button == 1)
				kos_ExitApp();
			if (button == 5)
 
				LaunchTinypad();
		}
 
	}
}
>

Rev 1764	Rev 2870
1	#include "func.h"	-
2	#include "parser.h"	1	#include "func.h"
3	#include "kolibri.h"	2	#include "parser.h"
4	#include "use_library.h"	3	#include "kolibri.h"
5		4	#include "use_library.h"
6	const char header[] = "Graph";	5
7	const char empty_text[] = "No function loaded. Type file name and press Enter. ";	6	const char header[] = "Graph";
8	const char er_file_not_found[] = "Cannot open file. ";	7	const char empty_text[] = "No function loaded. Type file name and press Enter. ";
9	const char str_filename[]="Filename:";	8	const char er_file_not_found[] = "Cannot open file. ";
10	const char str_editfile[]="Edit";	9	const char str_filename[]="Filename:";
11		10	const char str_editfile[]="Edit";
12	// íà÷àëüíûå ðàçìåðû	11
13	#define WND_W 400	12	// íà÷àëüíûå ðàçìåðû
14	#define WND_H 300	13	#define WND_W 400
15		14	#define WND_H 300
16	#define LIGHTGREEN 0xff0000	15
17	#define WHITE 0xffffff	16	#define LIGHTGREEN 0xff0000
18	#define BLACK 0x0	17	#define WHITE 0xffffff
19	#define LIGHTBLUE 0x0000ff	18	#define BLACK 0x0
20	#define LIGHTRED 0xff0000	19	#define LIGHTBLUE 0x0000ff
21		20	#define LIGHTRED 0xff0000
22	// font colors	21
23	#define BIGFONTCOLOR BLACK	22	// font colors
24	#define SMALLFONTCOLOR BLACK	23	#define BIGFONTCOLOR BLACK
25		24	#define SMALLFONTCOLOR BLACK
26	#define THREE 3.0	25
27	// minimum space: 3 pixels	26	#define THREE 3.0
28		27	// minimum space: 3 pixels
29	#define BIG_HEIGHT 4.0	28
30	#define SMALL_HEIGHT 2.0	29	#define BIG_HEIGHT 4.0
31	#define TEXT_X 15.0	30	#define SMALL_HEIGHT 2.0
32	// numeric format for output	31	#define TEXT_X 15.0
33	#define FORMAT "%f"	32	// numeric format for output
34	// format for two coords	33	#define FORMAT "%f"
35	#define FORMAT_COORD "(%f,%f)"	34	// format for two coords
36	// special value to text if enough space	35	#define FORMAT_COORD "(%f,%f)"
37	#define FORMAT_TEST "0.00"	36	// special value to text if enough space
38		37	#define FORMAT_TEST "0.00"
39	#define DELTA_BIG 1.0	38
40	#define DELTA_SMALL 0.1	39	#define DELTA_BIG 1.0
41		40	#define DELTA_SMALL 0.1
42	double *points;	41
43	Dword point_count = 0;	42	double *points;
44	double x1,y1,x2,y2;	43	Dword point_count = 0;
45	char *funct = NULL;	44	double x1,y1,x2,y2;
46		45	char *funct = NULL;
47	char edit_path[256];	46
48	//Dword editbox_y = WND_H - 16, editbox_w = WND_W - 70;	47	char edit_path[1024];
49	edit_box mybox = {0,9*8-5,WND_H - 16-32,0xffffff,0x6a9480,0,0x808080,0,99,(dword)&edit_path,0};	48	//Dword editbox_y = WND_H - 16, editbox_w = WND_W - 70;
50		49	edit_box mybox = {0,9*8-5,WND_H - 16-32,0xffffff,0x6a9480,0,0x808080,0,99,(dword)&edit_path,0};
51	char *full_head;	50
52		51	char *full_head;
53	char *HugeBuf = NULL;	52
54		53	char *HugeBuf = NULL;
55	//char fuck[64] = "$this is a fucking marker$";	54
56	// ïàðàìåòðû êîìàíäíîé ñòðîêè	55	//char fuck[64] = "$this is a fucking marker$";
57	#ifdef AUTOBUILD	56	// ïàðàìåòðû êîìàíäíîé ñòðîêè
58	extern char params[1024];	57	#ifdef AUTOBUILD
59	char params[1024];	58	extern char params[1024];
60	#else	59	char params[1024];
61	char params[1024] = "_FIND_ME_";	60	#else
62	#endif	61	char params[1024] = "_FIND_ME_";
63		62	#endif
64	/*	63
65		64	/*
66	fucking piece of shit	65
67		66	fucking piece of shit
68	*/	67
69		68	*/
70	// constructor of TCoord	69
71	TCoord coord(double x, double y)	70	// constructor of TCoord
72	{	71	TCoord coord(double x, double y)
73	TCoord r;	72	{
74	r.x = x;	73	TCoord r;
75	r.y = y;	74	r.x = x;
76	return r;	75	r.y = y;
77	}	76	return r;
78		77	}
79	// move and scale mathematical coords to fit screen coords	78
80	TCoord mat2Graf(TCoord c, TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax)	79	// move and scale mathematical coords to fit screen coords
81	{	80	TCoord mat2Graf(TCoord c, TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax)
82	TCoord r;	81	{
83	if (c.x > mMax.x)	82	TCoord r;
84	c.x = mMax.x;	83	if (c.x > mMax.x)
85	if (c.x < mMin.x)	84	c.x = mMax.x;
86	c.x = mMin.x;	85	if (c.x < mMin.x)
87	if (c.y > mMax.y)	86	c.x = mMin.x;
88	c.y = mMax.y;	87	if (c.y > mMax.y)
89	if (c.y < mMin.y)	88	c.y = mMax.y;
90	c.y = mMin.y;	89	if (c.y < mMin.y)
91	r.x = (scrMax.x - scrMin.x) / (mMax.x - mMin.x) * (c.x - mMin.x) + scrMin.x;	90	c.y = mMin.y;
92	r.y = (scrMax.y - scrMin.y) / (mMax.y - mMin.y) * (mMax.y - c.y) + scrMin.y;	91	r.x = (scrMax.x - scrMin.x) / (mMax.x - mMin.x) * (c.x - mMin.x) + scrMin.x;
93		92	r.y = (scrMax.y - scrMin.y) / (mMax.y - mMin.y) * (mMax.y - c.y) + scrMin.y;
94	return r;	93
95	}	94	return r;
96		95	}
97	// double-îáåðòêè	96
98	void line_d( double x1, double y1, double x2, double y2)	97	// double-îáåðòêè
99	{	98	void line_d( double x1, double y1, double x2, double y2)
100	line(di(x1), di(y1), di(x2), di(y2));	99	{
101	}	100	line(di(x1), di(y1), di(x2), di(y2));
102		101	}
103	void outtextxy_d( double x, double y, char * text, int len)	102
104	{	103	void outtextxy_d( double x, double y, char * text, int len)
105	outtextxy(di(x), di(y), text, len);	104	{
106	}	105	outtextxy(di(x), di(y), text, len);
107		106	}
108	// huge function to draw all the stuff except the function itself	107
109	void drawAxis( TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax)	108	// huge function to draw all the stuff except the function itself
110	{	109	void drawAxis( TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax)
111	TCoord cZero={0.0,0.0},	110	{
112	gMin, gMax, gZero, step;	111	TCoord cZero={0.0,0.0},
113	TCoord from, to;	112	gMin, gMax, gZero, step;
114	double i=0.0;	113	TCoord from, to;
115	int j;	114	double i=0.0;
116	double xmin, xmin2, ymin, ymin2;	115	int j;
117	char buf[30]="";	116	double xmin, xmin2, ymin, ymin2;
118		117	char buf[30]="";
119		118
120	// scr means Screen(bounding rect)	119
121	// m means Mathematical	120	// scr means Screen(bounding rect)
122	// g means Graphic(real screen position)	121	// m means Mathematical
123		122	// g means Graphic(real screen position)
124	//rtlDebugOutString("draw axis called\n");	123
125		124	//rtlDebugOutString("draw axis called\n");
126	//format(debuf, 30, "test: %f,%f,%f,%f\n", 123.45, 1.0, -0.9, 12.57);	125
127	//rtlDebugOutString(debuf);	126	//format(debuf, 30, "test: %f,%f,%f,%f\n", 123.45, 1.0, -0.9, 12.57);
128		127	//rtlDebugOutString(debuf);
129	gMin = mat2Graf(mMin, scrMin, scrMax, mMin, mMax);	128
130	gMax = mat2Graf(mMax, scrMin, scrMax, mMin, mMax);	129	gMin = mat2Graf(mMin, scrMin, scrMax, mMin, mMax);
131	gZero = mat2Graf(cZero, scrMin, scrMax, mMin, mMax);	130	gMax = mat2Graf(mMax, scrMin, scrMax, mMin, mMax);
132		131	gZero = mat2Graf(cZero, scrMin, scrMax, mMin, mMax);
133	// clear	132
134	// setcolor(WHITE);	133	// clear
135	//rectangle(di(gMin.x), di(gMin.y), di(gMax.x), di(gMax.y));	134	// setcolor(WHITE);
136	// ftopku	135	//rectangle(di(gMin.x), di(gMin.y), di(gMax.x), di(gMax.y));
137		136	// ftopku
138	setcolor(BLACK);	137
139	// osy X	138	setcolor(BLACK);
140	line_d(gMin.x, gZero.y ,gMax.x, gZero.y);	139	// osy X
141	// osy Y	140	line_d(gMin.x, gZero.y ,gMax.x, gZero.y);
142	line_d(gZero.x, gMin.y, gZero.x, gMax.y);	141	// osy Y
143	// bounding rect	142	line_d(gZero.x, gMin.y, gZero.x, gMax.y);
144	line_d(gMin.x, gMin.y, gMax.x, gMin.y);	143	// bounding rect
145	line_d(gMin.x, gMax.y, gMax.x, gMax.y);	144	line_d(gMin.x, gMin.y, gMax.x, gMin.y);
146		145	line_d(gMin.x, gMax.y, gMax.x, gMax.y);
147	line_d(gMin.x, gMin.y, gMin.x, gMax.y);	146
148	line_d(gMax.x, gMin.y, gMax.x, gMax.y);	147	line_d(gMin.x, gMin.y, gMin.x, gMax.y);
149		148	line_d(gMax.x, gMin.y, gMax.x, gMax.y);
150	// coords of the rect : lower left	149
151	format(buf, 30, FORMAT_COORD, x1, y1);	150	// coords of the rect : lower left
152	//rtlDebugOutString(buf);	151	format(buf, 30, FORMAT_COORD, x1, y1);
153	outtextxy_d(gMin.x, gMin.y + textheight(buf, 20), buf, 20);	152	//rtlDebugOutString(buf);
154	// upper left	153	outtextxy_d(gMin.x, gMin.y + textheight(buf, 20), buf, 20);
155	format(buf, 30, FORMAT_COORD, x1, y2);	154	// upper left
156	outtextxy_d(gMin.x, gMax.y - textheight(buf, 20), buf, 20);	155	format(buf, 30, FORMAT_COORD, x1, y2);
157	// lower right	156	outtextxy_d(gMin.x, gMax.y - textheight(buf, 20), buf, 20);
158	format(buf, 30, FORMAT_COORD, x2, y1);	157	// lower right
159	outtextxy_d(gMax.x - textwidth(buf, 20), gMin.y + textheight(buf, 20), buf, 20);	158	format(buf, 30, FORMAT_COORD, x2, y1);
160	// upper right	159	outtextxy_d(gMax.x - textwidth(buf, 20), gMin.y + textheight(buf, 20), buf, 20);
161	format(buf, 30, FORMAT_COORD, x2, y2);	160	// upper right
162	outtextxy_d(gMax.x - textwidth(buf, 20), gMax.y - textheight(buf, 20), buf, 20);	161	format(buf, 30, FORMAT_COORD, x2, y2);
163		162	outtextxy_d(gMax.x - textwidth(buf, 20), gMax.y - textheight(buf, 20), buf, 20);
164	//rtlDebugOutString("some lines painted\n");	163
165		164	//rtlDebugOutString("some lines painted\n");
166		165
167	step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x);	166
168	step.y = (mMax.y - mMin.y) / (scrMax.y - scrMin.y);	167	step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x);
169		168	step.y = (mMax.y - mMin.y) / (scrMax.y - scrMin.y);
170	// round values	169
171	xmin = id(di((mMin.x / DELTA_BIG) * DELTA_BIG));	170	// round values
172	ymin = id(di((mMin.y / DELTA_BIG) * DELTA_BIG));	171	xmin = id(di((mMin.x / DELTA_BIG) * DELTA_BIG));
173		172	ymin = id(di((mMin.y / DELTA_BIG) * DELTA_BIG));
174	// (0,0)	173
175		174	// (0,0)
176	if ((x1 * x2 <= 0.0) && (y1 * y2 <= 0.0))	175
177	{	176	if ((x1 * x2 <= 0.0) && (y1 * y2 <= 0.0))
178	from.x=0.0;	177	{
179	from.y=0.0;	178	from.x=0.0;
180	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);	179	from.y=0.0;
181	setcolor(BLACK);	180	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
182	format(buf, 30, FORMAT, 0.0);	181	setcolor(BLACK);
183	outtextxy_d(from.x - textwidth(buf, 20), from.y + textheight(buf, 20), buf, 20);	182	format(buf, 30, FORMAT, 0.0);
184	}	183	outtextxy_d(from.x - textwidth(buf, 20), from.y + textheight(buf, 20), buf, 20);
185		184	}
186		185
187	// big marks on X	186
188	//settextstyle(0, 0, 1);	187	// big marks on X
189	if (DELTA_BIG / step.x > THREE)	188	//settextstyle(0, 0, 1);
190	{	189	if (DELTA_BIG / step.x > THREE)
191	for (i = xmin; i <= mMax.x; i += DELTA_BIG)	190	{
192	{	191	for (i = xmin; i <= mMax.x; i += DELTA_BIG)
193	if (i != 0.0)	192	{
194	{	193	if (i != 0.0)
195	from.x = i;	194	{
196	to.x = from.x;	195	from.x = i;
197	from.y = -BIG_HEIGHT * step.y;	196	to.x = from.x;
198	to.y = BIG_HEIGHT * step.y;	197	from.y = -BIG_HEIGHT * step.y;
199	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);	198	to.y = BIG_HEIGHT * step.y;
200	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);	199	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
201	setcolor(BLACK);	200	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
202	line_d(from.x, from.y, to.x, to.y);	201	setcolor(BLACK);
203	// write number	202	line_d(from.x, from.y, to.x, to.y);
204	format(buf, 30, FORMAT, i);	203	// write number
205	// if it fits in the GAP, then write it	204	format(buf, 30, FORMAT, i);
206	if (from.y > scrMin.y && (DELTA_BIG > (textwidth(buf, 20) + 1.0) * step.x))	205	// if it fits in the GAP, then write it
207	{	206	if (from.y > scrMin.y && (DELTA_BIG > (textwidth(buf, 20) + 1.0) * step.x))
208	setcolor(BIGFONTCOLOR);	207	{
209	outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20);	208	setcolor(BIGFONTCOLOR);
210	}	209	outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20);
211	}	210	}
212	}	211	}
213	}	212	}
214	//rtlDebugOutString("big marks x painted\n");	213	}
215		214	//rtlDebugOutString("big marks x painted\n");
216	// big marks on Y	215
217	if (DELTA_BIG / step.y > THREE)	216	// big marks on Y
218	{	217	if (DELTA_BIG / step.y > THREE)
219	for (i = ymin; i <= mMax.y; i += DELTA_BIG)	218	{
220	{	219	for (i = ymin; i <= mMax.y; i += DELTA_BIG)
221	if (i != 0.0)	220	{
222	{	221	if (i != 0.0)
223	from.y = i;	222	{
224	to.y = from.y;	223	from.y = i;
225	from.x = -BIG_HEIGHT * step.x;	224	to.y = from.y;
226	to.x = BIG_HEIGHT * step.x;	225	from.x = -BIG_HEIGHT * step.x;
227	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);	226	to.x = BIG_HEIGHT * step.x;
228	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);	227	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
229	setcolor(BLACK);	228	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
230	line_d(from.x, from.y, to.x, to.y);	229	setcolor(BLACK);
231	format(buf, 30, FORMAT, i);	230	line_d(from.x, from.y, to.x, to.y);
232	if (from.x > scrMin.x && (DELTA_BIG > textheight(buf, 20) * step.y))	231	format(buf, 30, FORMAT, i);
233	{	232	if (from.x > scrMin.x && (DELTA_BIG > textheight(buf, 20) * step.y))
234	setcolor(BIGFONTCOLOR);	233	{
235	outtextxy_d(from.x + TEXT_X, to.y - textheight(buf, 20) / 2.0, buf, 20);	234	setcolor(BIGFONTCOLOR);
236	}	235	outtextxy_d(from.x + TEXT_X, to.y - textheight(buf, 20) / 2.0, buf, 20);
237	}	236	}
238	}	237	}
239	}	238	}
240		239	}
241	xmin2 = id(di(mMin.x / DELTA_SMALL)) * DELTA_SMALL;	240
242	ymin2 = id(di(mMin.y / DELTA_SMALL)) * DELTA_SMALL;	241	xmin2 = id(di(mMin.x / DELTA_SMALL)) * DELTA_SMALL;
243		242	ymin2 = id(di(mMin.y / DELTA_SMALL)) * DELTA_SMALL;
244	if (DELTA_SMALL / step.x > THREE)	243
245	{	244	if (DELTA_SMALL / step.x > THREE)
246	j = di((( - xmin + xmin2 ) / DELTA_SMALL));	245	{
247	for (i = xmin2; i <= mMax.x; i += DELTA_SMALL, j++)	246	j = di((( - xmin + xmin2 ) / DELTA_SMALL));
248	{	247	for (i = xmin2; i <= mMax.x; i += DELTA_SMALL, j++)
249	if (j % 10 == 0)	248	{
250	{	249	if (j % 10 == 0)
251	// we need to skip every tenth mark, to avoid overwriting big marks	250	{
252	j = 0;	251	// we need to skip every tenth mark, to avoid overwriting big marks
253	continue;	252	j = 0;
254	}	253	continue;
255	from.x = i;	254	}
256	to.x = from.x;	255	from.x = i;
257	from.y = -SMALL_HEIGHT * step.y;	256	to.x = from.x;
258	to.y = SMALL_HEIGHT * step.y;	257	from.y = -SMALL_HEIGHT * step.y;
259	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);	258	to.y = SMALL_HEIGHT * step.y;
260	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);	259	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
261	setcolor(BLACK);	260	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
262	line_d(from.x, from.y, to.x, to.y);	261	setcolor(BLACK);
263	format(buf, 30, FORMAT, i);	262	line_d(from.x, from.y, to.x, to.y);
264		263	format(buf, 30, FORMAT, i);
265	if (from.y > scrMin.y && (DELTA_SMALL > textwidth(buf, 20) * step.x))	264
266	{	265	if (from.y > scrMin.y && (DELTA_SMALL > textwidth(buf, 20) * step.x))
267	setcolor(SMALLFONTCOLOR);	266	{
268	outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20);	267	setcolor(SMALLFONTCOLOR);
269	}	268	outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20);
270		269	}
271		270
272	}	271
273		272	}
274	}	273
275		274	}
276	// finally small marks on Y	275
277	if (DELTA_SMALL / step.y > THREE)	276	// finally small marks on Y
278	{	277	if (DELTA_SMALL / step.y > THREE)
279	//rtlDebugOutString("really small marks y painted\n");	278	{
280	j = di((( - ymin + ymin2) / DELTA_SMALL));	279	//rtlDebugOutString("really small marks y painted\n");
281	for (i = ymin2; i <= mMax.y; i += DELTA_SMALL, j++)	280	j = di((( - ymin + ymin2) / DELTA_SMALL));
282	{	281	for (i = ymin2; i <= mMax.y; i += DELTA_SMALL, j++)
283	if (j % 10 == 0)	282	{
284	{	283	if (j % 10 == 0)
285	// we need to skip every tenth, to avoid overwriting	284	{
286	j = 0;	285	// we need to skip every tenth, to avoid overwriting
287	continue;	286	j = 0;
288	}	287	continue;
289	from.y = i;	288	}
290	to.y = from.y;	289	from.y = i;
291	from.x = -SMALL_HEIGHT * step.x;	290	to.y = from.y;
292	to.x = SMALL_HEIGHT * step.x;	291	from.x = -SMALL_HEIGHT * step.x;
293	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);	292	to.x = SMALL_HEIGHT * step.x;
294	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);	293	from = mat2Graf(from, scrMin, scrMax, mMin, mMax);
295	setcolor(BLACK);	294	to = mat2Graf(to, scrMin, scrMax, mMin, mMax);
296	line_d(from.x, from.y, to.x, to.y);	295	setcolor(BLACK);
297	format(buf, 30, FORMAT, i);	296	line_d(from.x, from.y, to.x, to.y);
298	if (from.x > scrMin.x && (DELTA_SMALL > textheight(buf, 20) * step.y))	297	format(buf, 30, FORMAT, i);
299	{	298	if (from.x > scrMin.x && (DELTA_SMALL > textheight(buf, 20) * step.y))
300	setcolor(SMALLFONTCOLOR);	299	{
301	outtextxy_d(from.x + TEXT_X, from.y - textheight(buf, 20) / 2.0, buf, 20);	300	setcolor(SMALLFONTCOLOR);
302	}	301	outtextxy_d(from.x + TEXT_X, from.y - textheight(buf, 20) / 2.0, buf, 20);
303	}	302	}
304	}	303	}
305		304	}
306	}	305
307		306	}
308	/*	307
309	ends fucking piece of shit	308	/*
310	*/	309	ends fucking piece of shit
311		310	*/
312	void drawFunction( function_t fi, TCoord scrMin, TCoord scrMax,	311
313	TCoord mMin, TCoord mMax, DWORD color)	312	void drawFunction( function_t fi, TCoord scrMin, TCoord scrMax,
314	{	313	TCoord mMin, TCoord mMax, DWORD color)
315	double x;	314	{
316	double y;	315	double x;
317	int firstPoint = 1;	316	double y;
318	TCoord p, p0 = {0.0, 0.0}, step;	317	int firstPoint = 1;
319		318	TCoord p, p0 = {0.0, 0.0}, step;
320	drawAxis(scrMin, scrMax, mMin, mMax);	319
321		320	drawAxis(scrMin, scrMax, mMin, mMax);
322	setcolor(color);	321
323	step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x);	322	setcolor(color);
324		323	step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x);
325	for (x = mMin.x; x < mMax.x; x += step.x)	324
326	{	325	for (x = mMin.x; x < mMax.x; x += step.x)
327	y = fi(x);	326	{
328	// function is defined here and gets in the range	327	y = fi(x);
329	if (1) // òóò áûëî óñëîâèå, ÷òî ôóíêöèÿ ïðàâèëüíî âû÷èñëåíà	328	// function is defined here and gets in the range
330	{	329	if (1) // òóò áûëî óñëîâèå, ÷òî ôóíêöèÿ ïðàâèëüíî âû÷èñëåíà
331	if ((y > mMin.y) && (y < mMax.y))	330	{
332	{	331	if ((y > mMin.y) && (y < mMax.y))
333	p = mat2Graf(coord(x, y), scrMin, scrMax, mMin, mMax);	332	{
334	// if it's our first point, only remember its coords	333	p = mat2Graf(coord(x, y), scrMin, scrMax, mMin, mMax);
335	// otherwise, draw a line_d from prev to current	334	// if it's our first point, only remember its coords
336	if (firstPoint == 0)	335	// otherwise, draw a line_d from prev to current
337	{	336	if (firstPoint == 0)
338	line_d(p0.x, p0.y, p.x, p.y);	337	{
339	}	338	line_d(p0.x, p0.y, p.x, p.y);
340	else	339	}
341	firstPoint = 0;	340	else
342		341	firstPoint = 0;
343	p0 = p;	342
344	}	343	p0 = p;
345	else // too big/small	344	}
346	{	345	else // too big/small
347	firstPoint = 1;	346	{
348	}	347	firstPoint = 1;
349	}	348	}
350	else // no value	349	}
351	{	350	else // no value
352	firstPoint = 1;	351	{
353	}	352	firstPoint = 1;
354	}	353	}
355		354	}
356	}	355
357		356	}
358	struct kosBDVK	357
359	{	358	struct kosBDVK
360	Dword attrib;	359	{
361	Dword name_type;	360	Dword attrib;
362	Dword create_time;	361	Dword name_type;
363	Dword create_date;	362	Dword create_time;
364	Dword access_time;	363	Dword create_date;
365	Dword access_date;	364	Dword access_time;
366	Dword modify_time;	365	Dword access_date;
367	Dword modify_date;	366	Dword modify_time;
368	Dword size_low;	367	Dword modify_date;
369	Dword size_high;	368	Dword size_low;
370	};	369	Dword size_high;
371		370	};
372	// èòîãîâàÿ âåðñèÿ ÷èòàëêè òåêñòîâûõ ôàéëîâ	371
373	int load_points3()	372	// èòîãîâàÿ âåðñèÿ ÷èòàëêè òåêñòîâûõ ôàéëîâ
374	{	373	int load_points3()
375	kosFileInfo fileInfo;	374	{
376	kosBDVK bdvk;	375	kosFileInfo fileInfo;
377	int filePointer = 0;	376	kosBDVK bdvk;
378		377	int filePointer = 0;
379	Dword count;	-
380	int i,j,k;	378
381	double d;	379	int i,j,k;
382	Dword filesize, num_number;	380	double d;
383		381	Dword filesize, num_number;
384	double *p2;	382
385		383	double *p2;
386	if (edit_path[0] == '\0')	384
387	return 0;	385	if (edit_path[0] == '\0')
388		386	return 0;
389	// get file size	387
390	strcpy(fileInfo.fileURL,edit_path);	388	// get file size
391	fileInfo.OffsetLow = 0;	389	strcpy(fileInfo.fileURL,edit_path);
392	fileInfo.OffsetHigh = 0;	390	fileInfo.OffsetLow = 0;
393	fileInfo.dataCount = 0;	391	fileInfo.OffsetHigh = 0;
394	fileInfo.rwMode = 5;	392	fileInfo.dataCount = 0;
395	fileInfo.bufferPtr = (Byte *)&bdvk;	393	fileInfo.rwMode = 5;
396	Dword rr = kos_FileSystemAccess( &(fileInfo) ); // â CKosFile íåò îïðåäåëåíèÿ ðàçìåðà	394	fileInfo.bufferPtr = (Byte *)&bdvk;
397	sprintf(debuf, "getsize: %U\n", rr);	395	Dword rr = kos_FileSystemAccess( &(fileInfo) ); // â CKosFile íåò îïðåäåëåíèÿ ðàçìåðà
398	rtlDebugOutString(debuf);	396	sprintf(debuf, "getsize: %U\n", rr);
399	if (rr != 0)	397	rtlDebugOutString(debuf);
400	{	398	if (rr != 0)
401	kos_WriteTextToWindow(10,10,0,0x00,(char*)er_file_not_found,strlen(er_file_not_found));	399	{
402	return 0;	400	kos_WriteTextToWindow(10,10,0,0x00,(char*)er_file_not_found,strlen(er_file_not_found));
403	}	401	return 0;
404		402	}
405	filesize = bdvk.size_low;	403
406	num_number = filesize / 2;	404	filesize = bdvk.size_low;
407		405	num_number = filesize / 2;
408	HugeBuf = (char *)allocmem(filesize + 1); // ðàçáèðàåì êàê ñòðîêó, îòñþäà òåðìèíàòîð \0	406
409		407	HugeBuf = (char *)allocmem(filesize + 1); // ðàçáèðàåì êàê ñòðîêó, îòñþäà òåðìèíàòîð \0
410	for (i=0;i	408
411	HugeBuf[i] = 0;	409	for (i=0;i
412		410	HugeBuf[i] = 0;
413	strcpy(fileInfo.fileURL,edit_path);	411
414	fileInfo.OffsetLow = 0;	412	strcpy(fileInfo.fileURL,edit_path);
415		413	fileInfo.OffsetLow = 0;
416	fileInfo.OffsetHigh = 0;	414
417	fileInfo.dataCount = filesize;	415	fileInfo.OffsetHigh = 0;
418	fileInfo.rwMode = 0;	416	fileInfo.dataCount = filesize;
419	fileInfo.bufferPtr = (Byte *)HugeBuf;	417	fileInfo.rwMode = 0;
420	rr = kos_FileSystemAccess( &(fileInfo) ); // êàêàÿ-òî ïðîáëåìà ñ hands.dll, CKosFile íå ðàáîòàë	418	fileInfo.bufferPtr = (Byte *)HugeBuf;
421		419	rr = kos_FileSystemAccess( &(fileInfo) ); // êàêàÿ-òî ïðîáëåìà ñ hands.dll, CKosFile íå ðàáîòàë
422	sprintf(debuf, "read3: %U\n", rr);	420
423	rtlDebugOutString(debuf);	421	sprintf(debuf, "read3: %U\n", rr);
424		422	rtlDebugOutString(debuf);
425	strcpy(full_head, header);	423
426	strcpy(full_head+strlen(full_head), " - ");	424	strcpy(full_head, header);
427	strcpy(full_head+strlen(full_head), edit_path); // bad code	425	strcpy(full_head+strlen(full_head), " - ");
428		426	strcpy(full_head+strlen(full_head), edit_path); // bad code
429	// à òåïåðü ðàçîáðàòüñÿ â ýòîì	427
430		428	// à òåïåðü ðàçîáðàòüñÿ â ýòîì
431	i=0;	429
432	k=0;	430	i=0;
433	while (i < filesize)	431	k=0;
434	{	432	while (i < filesize)
435		433	{
436	while (isalpha(HugeBuf[i]) && i	434
437	if (i == filesize) break;	435	while (isalpha(HugeBuf[i]) && i
438	if (k==4 && HugeBuf[i] == '=')	436	if (i == filesize) break;
439	{	437	if (k==4 && HugeBuf[i] == '=')
440	//sprintf(debuf,"function: %S",HugeBuf + i);	438	{
441	//rtlDebugOutString(debuf);	439	//sprintf(debuf,"function: %S",HugeBuf + i);
442	// we have a function here	440	//rtlDebugOutString(debuf);
443	//HugeBuf[0] = ' ';	441	// we have a function here
444	funct = HugeBuf + i + 1;	442	//HugeBuf[0] = ' ';
445	strcpy(full_head+strlen(full_head), ". Function y=");	443	funct = HugeBuf + i + 1;
446	strcpy(full_head+strlen(full_head), funct);	444	strcpy(full_head+strlen(full_head), ". Function y=");
447	return 1;	445	strcpy(full_head+strlen(full_head), funct);
448	}	446	return 1;
449		447	}
450	d = convert(HugeBuf+i, &j);	448
451	if (d == ERROR)	449	d = convert(HugeBuf+i, &j);
452	{	450	if (d == ERROR)
453	sprintf(debuf, "Error in input file, byte %U, count %U\n", i, k);	451	{
454	rtlDebugOutString(debuf);	452	sprintf(debuf, "Error in input file, byte %U, count %U\n", i, k);
455	kos_WriteTextToWindow(10, 10, 0, 0x00, (char*)debuf, strlen(debuf));	453	rtlDebugOutString(debuf);
456	return 0;	454	kos_WriteTextToWindow(10, 10, 0, 0x00, (char*)debuf, strlen(debuf));
457	}	455	return 0;
458	if (d == ERROR_END)	456	}
459	{	457	if (d == ERROR_END)
460	rtlDebugOutString("EOF :)!\n");	458	{
461	break;	459	rtlDebugOutString("EOF :)!\n");
462	}	460	break;
463		461	}
464	i+=j;	462
465	switch (k)	463	i+=j;
466	{	464	switch (k)
467	case 0:	465	{
468	x1=d;	466	case 0:
469	break;	467	x1=d;
470	case 1:	468	break;
471	x2=d;	469	case 1:
472	break;	470	x2=d;
473	case 2:	471	break;
474	y1=d;	472	case 2:
475	break;	473	y1=d;
476	case 3:	474	break;
477	y2=d;	475	case 3:
478	break;	476	y2=d;
479	default:	477	break;
480	{	478	default:
481	if (p2 == NULL)	479	{
482	p2 = (double )allocmem(num_number 8);	480	if (p2 == NULL)
483	p2[k-4]=d;	481	p2 = (double )allocmem(num_number 8);
484	}	482	p2[k-4]=d;
485	}	483	}
486	k++;	484	}
487	}	485	k++;
488	// format(debuf, 30, "(%f,%f)-(%f,%f)",x1,y1,x2,y2);	486	}
489	// rtlDebugOutString(debuf);	487	// format(debuf, 30, "(%f,%f)-(%f,%f)",x1,y1,x2,y2);
490	point_count=(k - 4)/2;	488	// rtlDebugOutString(debuf);
491		489	point_count=(k - 4)/2;
492	//	490
493	points = (double )allocmem(point_count 2 * 8);	491	//
494	for (i = 0; i < point_count * 2; i++)	492	points = (double )allocmem(point_count 2 * 8);
495	points[i] = p2[i];	493	for (i = 0; i < point_count * 2; i++)
496	freemem(p2);	494	points[i] = p2[i];
497	// sprintf(debuf, "count: %U\n", point_count);	495	freemem(p2);
498	// rtlDebugOutString(debuf);	496	// sprintf(debuf, "count: %U\n", point_count);
499	sprintf(debuf, ". Number of points: %U.", point_count);	497	// rtlDebugOutString(debuf);
500	strcpy(full_head+strlen(full_head), debuf);	498	sprintf(debuf, ". Number of points: %U.", point_count);

Subversion Repositories Kolibri OS

(root)/programs/other/graph/hello.cpp @ 7648 – Rev 1764 → 2870