Subversion Repositories Kolibri OS

Rev

Rev 1114 | Rev 2749 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. //ñâîåâðåìåííîå ðåàãèðîâàíèå íà ñîáûòèÿ ìûøè
  2. //ìèíèìàëüíûå ðàçìåðû îêíà
  3. //óáðàíà ïåðåðèñîâêà çàãîëîâêà îêíà òàì, ãäå îíà íå íóæíà
  4. //óáðàíî "çàïîëçàíèå" ïàíåëè ñíèçó íà ãðàíèöû îêíà
  5. //èñïðàâëåí áàã èç-çà êîòîðîãî ïîñëå äåéñòâèé ìûøêîé óäàëÿëàñü êíîïêà çàêðûòèÿ îêíà
  6.  
  7. //çà÷åì ñòðîêà 450?
  8. //åñëè âûäåëèòü îáëàñòü ÿ÷ååê è ñäâèíóòü êóðñîð ââîäà ñ ïîìîùüþ êëàâèø, "ñëåäû" îñòàíóòüñÿ
  9. //íåëüçÿ ïåðåìåùàòüñÿ ïî áóêâàì â ðåäàêòèðóåìîé ñòðîêå
  10.  
  11. #include "func.h"
  12. #include "parser.h"
  13. #include "calc.h"
  14. #include "use_library.h"
  15.  
  16. #define TABLE_VERSION "0.96"
  17.  
  18. // ñòðîêè, êîòîðûå âûâîäèò ïðîãðàììà
  19. const char *sFileSign = "KolibriTable File\n";
  20. const char sFilename[] = "Filename: ";
  21. const char sSave[] = "Save";
  22. const char sLoad[] = "Load";
  23. const char sNew[] = "New";
  24.  
  25. const char er_file_not_found[] = "Cannot open file. ";
  26. const char er_format[] = "Error: bad format. ";
  27. const char msg_save[] = "File saved. ";
  28. const char msg_load[] = "File loaded. ";
  29. const char msg_new[] = "Memory cleared. ";
  30.  
  31. // ñâîé PID
  32. Dword myPID = -1;
  33.  
  34. // íà÷àëüíûå ðàçìåðû
  35. #define WND_W 550
  36. #define WND_H 400
  37. // íîâûå ðàçìåðû è êîîðäèíàòû
  38. int wi = WND_W, he = WND_H;
  39. int win_x, win_y;
  40.  
  41. // öâåòà ýëåìåíòîâ èíòåðôåéñà
  42. #define GRID_COLOR 0xa0a0a0
  43. #define TEXT_COLOR 0x000000
  44. #define CELL_COLOR 0xffffff
  45. #define SEL_CELL_COLOR 0xe0e0ff
  46. #define FIXED_CELL_COLOR 0xe0e0ff
  47. #define SEL_FIXED_CELL_COLOR 0x758FC1
  48. #define TEXT_SEL_FIXED_COLOR 0xffffff
  49.  
  50. #define SCROLL_BAR_WIDTH 16
  51. #define SCROLL_BAR_HEIGHT 16
  52.  
  53. // ID êíîïîê
  54. #define FILENAME_BUTTON 0x10
  55. #define SAVE_BUTTON 0x11
  56. #define LOAD_BUTTON 0x12
  57. #define NEW_BUTTON 0x13
  58. #define DRAG_BUTTON 0x20
  59.  
  60. #define SCROLL_LEFT_BUTTON 0x21
  61. #define SCROLL_RIGHT_BUTTON 0x22
  62. #define SCROLL_UP_BUTTON 0x23
  63. #define SCROLL_DOWN_BUTTON 0x24
  64. #define SCROLL_WIDTH 0x25
  65. #define SCROLL_HEIGHT 0x26
  66.  
  67. #define COL_BUTTON 0x100
  68. #define ROW_BUTTON (COL_BUTTON + 0x100)
  69. #define COL_HEAD_BUTTON (ROW_BUTTON + 0x100)
  70. #define ROW_HEAD_BUTTON (COL_HEAD_BUTTON + 0x100)
  71. #define CELL_BUTTON (ROW_HEAD_BUTTON + 0x100)
  72.  
  73.  
  74. // íèæíÿÿ ïàíåëü ñ êíîïêàìè è ïîëåì ââîäà
  75. #define MENU_PANEL_HEIGHT 40
  76. Dword panel_y = 0;
  77. Dword mouse_dd;
  78. // äëÿ ïîëÿ ââîäà
  79.  
  80. char edit_text[256] = "";
  81. edit_box cell_box = {0,9*8-5,WND_H - 16-32,0xffffff,0x6a9480,0,0x808080,0,255,(dword)&edit_text,(dword)&mouse_dd,0};
  82.  
  83. // ÿ÷åéêè - èõ ïàðàìåòðû è òåêñò
  84. DWORD def_col_width = 80, def_row_height = 16;
  85. DWORD col_count = 200, row_count = 100;
  86. DWORD *col_width, *row_height;
  87. char ***cells;
  88. char ***values; // çíà÷åíèÿ ôîðìóë, åñëè åñòü
  89.  
  90. bool display_formulas = 0;      // îòîáðàæàòü ëè ôîðìóëû âìåñòî çíà÷åíèé
  91.  
  92. // êîîðäèíàòû îòîáðàæàåìûõ ñòîëáöîâ è ñòðîê
  93. DWORD *col_left, *row_top;
  94.  
  95. // áóôåð îáìåíà
  96. char ***buffer = NULL;
  97. DWORD buf_col, buf_row;
  98. DWORD buf_old_x, buf_old_y;
  99.  
  100. // ýòî êîîðäèíàòû ÿ÷åéêè, îòîáðàæàåìîé â Ë óãëå
  101. DWORD scroll_x = 1, scroll_y = 1;
  102. // ýòî âûäåëåííàÿ ÿ÷åéêà
  103. DWORD sel_x = 1, sel_y = 1;
  104. DWORD prev_x = 0, prev_y = 0;   // ïðåäûäóùàÿ âûäåëåííàÿ
  105. int was_single_selection = 0;
  106.  
  107. // êîíåö âûäåëåíèÿ åñëè âûäåëåíî íåñêîëüêî ÿ÷ååê
  108. DWORD sel_end_x = sel_x, sel_end_y = sel_y;
  109.  
  110. // ôëàã
  111. bool sel_moved = 0;
  112. bool sel_end_move = 0;
  113. bool window_drawall = false;
  114. // ñêîëüêî ÿ÷ååê ïîìåùàåòñÿ â îêíå ïî õ è ó
  115. DWORD nx = 0, ny = 0;
  116.  
  117. // ôëàã ðåàäêòèðîâàíèÿ ÿ÷åéêè
  118. //bool is_edit = 0;
  119. #define ed_focus 2
  120. #define is_edit (cell_box.flags & ed_focus)
  121.  
  122. // ðåäàêòèðîâàíèå èìåíè ôàéëà
  123. bool fn_edit = 0;
  124. char fname[256];
  125. edit_box file_box = {0,9*8-5,WND_H - 16-32,0xffffff,0x6a9480,0,0x808080,0,255,(dword)&fname,(dword)&mouse_dd,0};
  126.  
  127. // èçìåíåíèå ðàçìåðîâ
  128. #define SIZE_X 1 // ñîñòîÿíèå
  129. #define SIZE_Y 2
  130. #define SIZE_SELECT 3
  131. #define SIZE_DRAG 4
  132. int size_mouse_x, size_mouse_y, size_id, size_state = 0;
  133.  
  134. int window_is_dragged = 0; // ñåé÷àñ ïåðåòàñêèâàåòñÿ îêíî
  135.  
  136. // ðàñòàñêèâàíèå ÿ÷åéêè ïðè åå òàùåíèè çà ïðàâûé íèæíèé óãîë, ñ çàïîëíåíèåì ÿ÷ååê
  137. int drag_x, drag_y;
  138. int old_end_x, old_end_y;
  139.  
  140. void draw_window();
  141.  
  142. //edit_box ebox = {250,14,35,0xffffff,0x6f9480,0,0xAABBCC,0,248,0,2,20,20};
  143.  
  144. void kos_DrawRegion(Word x, Word y,Word width, Word height, Dword color1, Word invert)
  145. {
  146.         kos_DrawLine(x,y,x+width-2,y,color1,invert);
  147.         kos_DrawLine(x,y+1,x,y+height-1,color1,invert);
  148.         kos_DrawLine(x+width-1,y,x+width-1,y+height-2,color1,invert);
  149.         kos_DrawLine(x+1,y+height-1,x+width-1,y+height-1,color1,invert);
  150. }
  151.  
  152. void start_edit(int x, int y)
  153. {
  154.  
  155.         int ch = 0;
  156.         if (x < scroll_x || x > nx - 1)
  157.         {
  158.                 scroll_x = x;
  159.                 ch = 1;
  160.         }
  161.         if (y < scroll_y || y > ny - 1)
  162.         {
  163.                 scroll_y = y;
  164.                 ch = 1;
  165.         }
  166.         if (ch)
  167.         {
  168.                 sel_moved = 1;
  169.                 draw_window();
  170.         }
  171.  
  172.         file_box.flags &= ~ed_focus;
  173.  
  174.         cell_box.flags |= ed_focus;
  175.         cell_box.left = col_left[x] + 1;
  176.         cell_box.top = row_top[y] + 1;
  177.         cell_box.width = col_width[x] - 2;
  178.         //cell_box.height= row_height[y];
  179.         memset((Byte*)edit_text, 0, sizeof(edit_text));
  180.         if (cells[x][y])
  181.         {
  182.                 strcpy(edit_text, cells[x][y]);
  183.                 edit_text[strlen(cells[x][y]) - 1] = '\0';
  184.         }
  185.         cell_box.pos = cell_box.offset = 0;
  186.  
  187.         draw_window();
  188. }
  189.  
  190. void stop_edit()
  191. {
  192.         if (is_edit)
  193.         {
  194.                 cell_box.flags &= ~ed_focus;
  195.                 if (cells[sel_x][sel_y])
  196.                         freemem(cells[sel_x][sel_y]);
  197.                 if (strlen(edit_text) > 0)
  198.                 {
  199.                         cells[sel_x][sel_y] = (char*)allocmem(strlen(edit_text)+1);
  200.                         strcpy(cells[sel_x][sel_y], edit_text);
  201.                 }
  202.                 else
  203.                         cells[sel_x][sel_y] = NULL;
  204.                 //memset((Byte*)edit_text,0, 256);
  205.                 calculate_values();
  206.         }
  207. }
  208.  
  209. void cancel_edit()
  210. {
  211.         if (!is_edit)
  212.                 return;
  213.         cell_box.flags &= ~ed_focus;
  214.         memset((Byte*)edit_text,0, 256);
  215.         draw_window();
  216. }
  217.  
  218. void check_sel()
  219. {
  220.         DWORD sx0=scroll_x, sy0=scroll_y;
  221.  
  222.         if (sel_x >= nx - 1  /*&& sel_x < col_count - nx + scroll_x + 1*/)
  223.                 //if (sel_x == nx)
  224.                         scroll_x++;
  225.                 //else
  226.                 //      scroll_x = sel_x;
  227.         if (sel_y >= ny - 1 /*&& sel_y < row_count - ny + scroll_y */)
  228.                 //if (sel_y == ny)
  229.                         scroll_y++;
  230.                 //else
  231.                 //      scroll_y = sel_y;
  232.  
  233.         if (sel_x < scroll_x)
  234.                 scroll_x = sel_x;
  235.         if (sel_y < scroll_y)
  236.                 scroll_y = sel_y;
  237.  
  238.         if (sx0 != scroll_x || sy0 != scroll_y)
  239.                 sel_moved = 0;                  // íàäî ïåðåðèñîâàòü âñå
  240.  
  241. }
  242.  
  243. // ñäâèíóòü âûäåëåíèå
  244. void move_sel(DWORD new_x, DWORD new_y)
  245. {
  246.         sel_moved = 1;
  247.         stop_edit();
  248.         prev_x = sel_x;
  249.         prev_y = sel_y;
  250.         sel_x = new_x;
  251.         if (sel_x < 1)
  252.                 sel_x = 1;
  253.         if (sel_x > col_count - 1)
  254.                 sel_x = col_count - 1;
  255.         sel_end_x = sel_x;
  256.         sel_y = new_y;
  257.         if (sel_y < 1)
  258.                 sel_y = 1;
  259.         if (sel_y > row_count - 1)
  260.                 sel_y = row_count - 1;
  261.         sel_end_y = sel_y;
  262.         check_sel();
  263.         draw_window();
  264. }
  265.  
  266. void draw_custom_button(int x0, int y0, int sx, int sy, int blue_border)
  267. {
  268.         int x1 = x0 + sx;
  269.         int y1 = y0 + sy;
  270.  
  271.         if (blue_border) kos_DrawRegion(x0-1, y0-1, sx+3, sy+3, 0x94aece, 0);
  272.  
  273.         // ñåðûé ïðÿìîóãîëüíèê
  274.  
  275.         kos_DrawBar(x0 + 1, y0 + 1, sx - 1, sy - 1, 0xe4dfe1);
  276.        
  277.         // äâå áåëûå ëèíèè: ñâåðõó è ñëåâà
  278.  
  279.         kos_DrawLine(x0, y0, x1, y0, 0xffffff, 0);
  280.         kos_DrawLine(x0, y0, x0, y1, 0xffffff, 0);
  281.  
  282.         // äâå ñåðûå ëèíèè: ñíèçó è ñïðàâà
  283.         kos_DrawLine(x0, y1, x1, y1, 0xc7c7c7, 0);
  284.         kos_DrawLine(x1, y0, x1, y1, 0xc7c7c7, 0);
  285. }
  286.  
  287. // x - ìåæäó low è high ? - íåîáÿçàòåëüíî low<high
  288. bool is_between(Dword x, Dword low, Dword high)
  289. {
  290.         return ((low<high)?(x >= low && x <= high):(x >= high && x <= low));
  291. }
  292.  
  293. void clear_cell_slow(int px, int py)
  294. {
  295.         int i;
  296.         int x0 = col_width[0];
  297.         for (i = scroll_x; i < px; i++)
  298.         {
  299.                 x0 += col_width[i];
  300.         }
  301.         int x1 = x0;
  302.         x1 += col_width[px];
  303.         int y0 = row_height[0];
  304.         for (i = scroll_y; i < py; i++)
  305.         {
  306.                 y0 += row_height[i];
  307.         }
  308.         int y1 = y0;
  309.         y1 += row_height[py];
  310.         kos_DrawBar(x0 + 1, y0 + 1, x1 - x0 - 1, y1 - y0 - 1, 0xffffff);
  311. }
  312.  
  313. //debug
  314. const int debugcolor[10]={0xff0000,0x00ff00,0x0000ff,0xffff00,0x00ffff,0xff00ff,0x800000,0x008000,0x000080,0x800080};
  315. int debugc=0;
  316.  
  317. // ðèñîâàíèå ÿ÷ååê
  318. #define is_x_changed(v) ((v) == sel_x || (v) == prev_x)
  319. #define is_y_changed(v) ((v) == sel_y || (v) == prev_y)
  320.  
  321. void draw_grid()
  322. {
  323.         int i,j;
  324.         long x0 = 0, y0 = 0, x = 0, y = 0, dx, popravka;
  325.         DWORD text_color;
  326.         //int lx, ly;
  327.  
  328. //      sprintf(debuf, "%U,%U", scroll_x, scroll_y);
  329. //      rtlDebugOutString(debuf);
  330.  
  331.         nx=ny=0;
  332.  
  333.         // î÷èñòèòü îáëàñòü îêîëî âûäåëåííîé ÿ÷åéêè
  334.         if (sel_moved)
  335.         {
  336.                 clear_cell_slow(sel_x, sel_y);
  337.                 clear_cell_slow(prev_x, prev_y);
  338.         }
  339.         else
  340.         {
  341.                 // î÷èñòèòü âñþ îáëàñòü ÿ÷ååê
  342.                 //kos_DrawBar(col_width[0]+1, row_height[0]+1, wi - SCROLL_BAR_WIDTH-col_width[0]-1, he - SCROLL_BAR_HEIGHT-row_height[0]-1, 0xffffff);
  343.         }
  344.  
  345.         col_left[0] = 0;
  346.         // ÿ÷åéêè - çàãîëîâêè ñòîëáöîâ + âåðòèêàëüíûå ëèíèè
  347.         x = col_width[0];
  348.         nx = 1;
  349.         for (i = 1; i < col_count; i++)
  350.         {
  351.                 col_left[i] = -1;
  352.                 if (i >= scroll_x)
  353.                 {
  354.                         {                              
  355.                                 if (!sel_moved || is_x_changed(i))
  356.                                         kos_DrawLine(x-x0, 0, x-x0, row_height[0], GRID_COLOR, 0);
  357.                         // è çàãîëîâîê ÿ÷åéêè ïî õ
  358.                                 text_color = TEXT_COLOR;
  359.                                 dx = (col_width[i]-6)/2;
  360.                                 int dy = (row_height[0] - 8) / 2 + 1;
  361.                                 int cur_width = col_width[i] - 1;
  362.                                 if (cur_width + x - x0 > wi - SCROLL_BAR_WIDTH)
  363.                                         cur_width = wi - SCROLL_BAR_WIDTH - x + x0;
  364.                                 if (!sel_moved || (is_x_changed(i)))
  365.                                         if (is_between(i,sel_x,sel_end_x))     
  366.                                         {
  367.                                                 kos_DrawBar(x - x0 + 1,0,cur_width,row_height[0],SEL_FIXED_CELL_COLOR); //0x0000CC
  368.                                                 text_color = TEXT_SEL_FIXED_COLOR;
  369.                                         }
  370.                                         else
  371.                                         {
  372.                                                 kos_DrawBar(x - x0 + 1,0,cur_width,row_height[0],FIXED_CELL_COLOR);
  373.                                                 text_color = TEXT_COLOR;
  374.                                         }
  375.                                 if (!sel_moved || (is_x_changed(i))) kos_WriteTextToWindow(x-x0+2+dx,dy,0,text_color,cells[i][0],strlen(cells[i][0]));
  376.  
  377.                                 // åñòü êíîïêà ñòîáëöà è åùå êíîïêà èçìåíåíèÿ øèðèíû
  378.                                 if (x - x0 + col_width[i] <= wi - col_width[0])
  379.                                         kos_DefineButton(x-x0+5,0,cur_width - 10,row_height[0]-1,0x60000000+COL_HEAD_BUTTON+i,0);
  380.                                 //kos_DefineButton(x-x0+col_width[i]-10,0,15,row_height[0]-1,0x60000000+COL_SIZE_BUTTON+i,0);
  381.                                 col_left[i] = x - x0;
  382.                         }
  383.                         if (x - x0 > wi - col_width[0])
  384.                         {
  385.                                 x += col_width[i];
  386.                                 nx++;
  387.                                 break;
  388.                         }
  389.                 }
  390.                 else
  391.                 {
  392.                         x0 += col_width[i];
  393.                 }
  394.                 x += col_width[i];
  395.                 nx++;
  396.         }
  397.  
  398.         //kos_DefineButton(0,0,0,0,0x80000000+COL_HEAD_BUTTON+i,0);
  399.  
  400.         for (j = i + 1; j < col_count; j++)
  401.                 col_left[j] = wi;
  402.         //if (!sel_moved || (is_x_changed(nx))) kos_DrawLine(x - x0, 0, x - x0, he, GRID_COLOR, 0);
  403.  
  404.         // ÿ÷åéêè - çàãîëîâêè ñòðîê + ãîðèçîíò. ëèíèè
  405.         y = row_height[0];
  406.         ny = 1;
  407.         row_top[0] = 0;
  408.         for (i = 1; i < row_count && y - y0 < he - 10; i++)
  409.         {
  410.                 row_top[i] = -1;
  411.                 if (i >= scroll_y)
  412.                 {
  413.                         {
  414.                                 if (!sel_moved || (is_y_changed(i)))
  415.                                         kos_DrawLine(0, y - y0, wi - SCROLL_BAR_WIDTH, y - y0, GRID_COLOR, 0);
  416.                                 // è çàãîëîâîê ÿ÷åéêè ïî y
  417.                                 text_color = TEXT_COLOR;
  418.                                 dx = (col_width[0]-6 * strlen(cells[0][i]))/2;  // optimize this, change strlen
  419.                                 int dy = (row_height[i] - 8) / 2 + 1;
  420.                                 if (!sel_moved || (is_y_changed(i)))
  421.                                         if (is_between(i,sel_y,sel_end_y))
  422.                                         {
  423.                                                 kos_DrawBar(0,y-y0+1,col_width[0],row_height[i] - 1,SEL_FIXED_CELL_COLOR);
  424.                                                 text_color = TEXT_SEL_FIXED_COLOR;
  425.                                         }
  426.                                         else
  427.                                         {
  428.                                                 kos_DrawBar(0,y-y0+1,col_width[0],row_height[i] - 1,FIXED_CELL_COLOR);
  429.                                                 text_color = TEXT_COLOR;
  430.                                         }
  431.  
  432.                                 if (!sel_moved || (is_y_changed(i)))
  433.                                         kos_WriteTextToWindow(2+dx,y-y0+dy,0,text_color,cells[0][i],strlen(cells[0][i]));
  434.  
  435.                                 kos_DefineButton(0,y-y0+5,col_width[0]-1,row_height[i]-6,0x60000000+ROW_HEAD_BUTTON+i,0);
  436.                                 //kos_DefineButton(0,y-y0+row_height[i]-5,col_width[0]-1,10,0x60000000+ROW_SIZE_BUTTON+i,0);
  437.                                 row_top[i] = y - y0;
  438.                         }
  439.                 }
  440.                 else
  441.                 {
  442.                         y0 += row_height[i];
  443.                 }
  444.                 y += row_height[i];
  445.                 ny++;
  446.         }
  447.        
  448.         kos_DefineButton(0,0,0,0,0x80000000+ROW_HEAD_BUTTON+ny-1,0);
  449.  
  450.         for (j = i + 1; j < row_count; j++)
  451.                 row_top[j] = he;
  452.         if (!sel_moved || (is_y_changed(ny)))
  453.                 kos_DrawLine(0, y - y0, wi - SCROLL_BAR_WIDTH, y - y0, GRID_COLOR, 0);
  454.  
  455.         if (!sel_moved || (is_x_changed(0) && is_y_changed(0)))
  456.                 kos_DrawBar(0,0,col_width[0],row_height[0],FIXED_CELL_COLOR);
  457.         // Ë ÿ÷åéêà
  458.  
  459.         //sprintf(debuf, "%U, %U; %U, %U", x0, y0, nx, ny);
  460.         //rtlDebugOutString(debuf);
  461.  
  462. //      popravka = (y - y0 < he - 10);
  463.         //sprintf(debuf, "%U, %U", scroll_y, ny);
  464.         //rtlDebugOutString(debuf);
  465.  
  466.        
  467.         // ñàìè ÿ÷åéêè
  468.  
  469.         y = row_height[0];
  470.         for (i = scroll_y; i < ny; i++)
  471.         {
  472.                 x = col_width[0];
  473.                 if (!sel_moved)
  474.                         kos_DrawBar(col_width[0]+1, y+1, wi - SCROLL_BAR_WIDTH-col_width[0]-1, row_height[i]-1, 0xffffff);
  475.                 for (j = scroll_x; j < nx-1; j++)
  476.                 {
  477.                         if (!sel_moved || is_x_changed(j) || is_y_changed(i))
  478.                                 kos_DrawLine(col_left[j], row_top[i], col_left[j], row_height[i], GRID_COLOR, 0);
  479.  
  480.                         // çàãîëîâêè óæå íàðèñîâàíû - ïðîïóñêàåì èõ
  481.                         if (i && j)    
  482.                         {
  483.                                 //kos_DrawBar(x+1, y+1, col_width[i]-1, row_height[i]-1, 0xffffff);
  484.  
  485.                                 //rtlDebugOutString(cap);
  486.                                 //if (j >= sel_x && j <= sel_end_x && i >= sel_y && i <= sel_end_y)
  487.                                 if (is_between(j,sel_x,sel_end_x) && is_between(i, sel_y, sel_end_y)    // (j,i) - âûäåëåíà
  488.                                         && ((!sel_moved) || (is_x_changed(j) && is_y_changed(i))))                      // è åå íóæíî íàðèñîâàòü
  489.                                 {
  490.                                         if (i == sel_y && j == sel_x)           // ðàìêà
  491.                                         {
  492.                                                 kos_DrawBar(x,y,col_width[j],2,TEXT_COLOR);     // up
  493.                                                 kos_DrawBar(x,y,2,row_height[i],TEXT_COLOR);    // left
  494.                                                 kos_DrawBar(x,y+row_height[i]-2,col_width[j]-2-3,2,TEXT_COLOR);                         // bottom
  495.                                                 kos_DrawBar(x+col_width[j]-2,y, 2,row_height[i]-2-3,TEXT_COLOR);                                // right
  496.  
  497.                                                 kos_DrawBar(x+col_width[j]-4,y+row_height[i]-4,4,4,TEXT_COLOR);
  498.                                                 //kos_DefineButton(x+col_width[j]-2,y+row_height[i]-2,4,4,0x60000000+DRAG_BUTTON,0x000000);
  499.                                                 drag_x = x + col_width[j] - 4;
  500.                                                 drag_y = y + row_height[i] - 4;
  501.                                         }
  502.                                         else
  503.                                                 kos_DrawBar(x + 1,y + 1,col_width[j] - 2,row_height[i] - 2,SEL_CELL_COLOR);     //      âûäåëåíà íî íå îñíîâíàÿ(ñåðàÿ)
  504.  
  505.                                 }
  506.                                 //kos_DefineButton(x,y,col_width[j]-1,row_height[i]-1,0x60000000+CELL_BUTTON+((i << 8) + j),0);
  507.  
  508.                                 char *text;
  509.                                 if (values[j][i] && values[j][i][0] == '#')
  510.                                 {
  511.                                         text = cells[j][i];
  512.                                         kos_DrawRegion(x+1, y+1, col_width[j]-1, row_height[i]-1, 0xff0000, 0);
  513.                                 }
  514.                                 else
  515.                                         text = (values[j][i] && !display_formulas ? values[j][i] : cells[j][i]);
  516.  
  517.                                 int dy = (row_height[i] - 8) / 2 + 1;
  518.  
  519.                                 if (text)
  520.                                         if (strlen(text) < col_width[j]/6)
  521.                                                 kos_WriteTextToWindow(x+2,y+dy,0,text_color,text,strlen(text));
  522.                                         else
  523.                                                 kos_WriteTextToWindow(x+2,y+dy,0,text_color,text,col_width[j]/6);
  524.  
  525.                         }
  526.                         if (!sel_moved || is_x_changed(j) || is_y_changed(i))  
  527.                                 kos_DrawLine(col_left[j]+col_width[j], row_top[i], col_left[j]+col_width[j], row_height[i], GRID_COLOR, 0);
  528.                         x += col_width[j];
  529.                 }
  530.                 y += row_height[i];
  531.         }
  532.  
  533.         // Scrolls:
  534.         // horizontal
  535.  
  536.         //if (!sel_moved) kos_DrawBar(0, he - SCROLL_BAR_HEIGHT, wi - SCROLL_BAR_WIDTH, SCROLL_BAR_HEIGHT, FIXED_CELL_COLOR);
  537.         //if (!sel_moved) kos_DrawBar(scroll_x * wi / col_count, he - SCROLL_BAR_HEIGHT, wi / col_count, SCROLL_BAR_HEIGHT, SEL_FIXED_CELL_COLOR);
  538.         if (!sel_moved)
  539.         {
  540.                 // ãîðèçîíòàëü
  541.                 kos_DrawBar(17, he - SCROLL_BAR_HEIGHT, wi - SCROLL_BAR_WIDTH - 32, SCROLL_BAR_HEIGHT, 0xced0d0);
  542.                 // ñèíèå ëèíèè
  543.                 kos_DrawRegion(0, he - SCROLL_BAR_HEIGHT, wi - SCROLL_BAR_WIDTH, SCROLL_BAR_HEIGHT+1, 0x94aece, 0);
  544.                 // ëåâàÿ êíîïêà
  545.                 draw_custom_button(1, he - SCROLL_BAR_HEIGHT + 1, 14, 14, 1);
  546.                 kos_WriteTextToWindow(6, he - SCROLL_BAR_HEIGHT + 5, 0, 0, "\x1B", 1);
  547.                 // ïðàâàÿ
  548.                 draw_custom_button(wi - SCROLL_BAR_WIDTH * 2 + 1, he - SCROLL_BAR_HEIGHT + 1, 14, 14, 1);
  549.                 kos_WriteTextToWindow(wi - SCROLL_BAR_WIDTH * 2 + 6, he - SCROLL_BAR_HEIGHT + 5, 0, 0, "\x1A", 1);
  550.                 // ïîëçóíîê
  551.                 int tmp_w = (nx - scroll_x) * (wi - SCROLL_BAR_WIDTH - 2 * 14 - 14) / (col_count + 1);
  552.                 if (tmp_w < 16)
  553.                         tmp_w = 16;
  554.                 draw_custom_button(17 + (scroll_x - 1) * (wi - SCROLL_BAR_WIDTH - 2 * 14 - 14) / (col_count + 1), he - SCROLL_BAR_HEIGHT + 1,
  555.                         tmp_w, 14, 1);
  556.  
  557. #define sw(x,y) y,x
  558. // íå ïèíàéòå ìåíÿ çà ýòî, áûëî ëåíü ïåðåñòàâëÿòü ðóêàìè...
  559.  
  560.                 // âåðòèêàëü
  561.                 kos_DrawBar(sw(17, wi - SCROLL_BAR_WIDTH), sw(he - SCROLL_BAR_HEIGHT - 33, SCROLL_BAR_WIDTH), 0xced0d0);
  562.                 // ñèíèå ëèíèè
  563.                 kos_DrawRegion(sw(0, wi - SCROLL_BAR_WIDTH), sw(he - SCROLL_BAR_HEIGHT, SCROLL_BAR_WIDTH+1), 0x94aece, 0); // up
  564.  
  565.                 // âåðõíÿÿ êíîïêà
  566.                 draw_custom_button(sw(1, wi - SCROLL_BAR_WIDTH + 1), 14, 14, 1);
  567.                 kos_WriteTextToWindow(sw(5, wi - SCROLL_BAR_WIDTH + 6), 0, 0, "\x18", 1);
  568.                 // íèæíÿÿ
  569.                 draw_custom_button(sw(he - SCROLL_BAR_HEIGHT * 2 + 1, wi - SCROLL_BAR_WIDTH + 1), 14, 14, 1);
  570.                 //draw_custom_button(sw(he - SCROLL_BAR_HEIGHT * 2 + 1, wi - SCROLL_BAR_WIDTH + 1), 14, 14, 1);
  571.                 kos_WriteTextToWindow(sw(he - SCROLL_BAR_HEIGHT * 2 + 5, wi - SCROLL_BAR_WIDTH + 6), 0, 0, "\x19", 1);
  572.                 // ïîëçóíîê
  573.                 int tmp_h = (ny - scroll_y) * (he - SCROLL_BAR_HEIGHT - 2 * 14 - 14) / (row_count + 1);
  574.                 if (tmp_h < 16)
  575.                         tmp_h = 16;
  576.                 draw_custom_button(sw(17 + (scroll_y - 1) * (he - SCROLL_BAR_HEIGHT - 2 * 14 - 14) / (row_count + 1), wi - SCROLL_BAR_WIDTH + 1),
  577.                         sw(tmp_h, 14), 1);
  578.         }
  579. #define NO_DRAW 0x60000000
  580.         kos_DefineButton(1, he - SCROLL_BAR_HEIGHT + 1, 14, 14, NO_DRAW + SCROLL_LEFT_BUTTON,0);
  581.         kos_DefineButton(wi - SCROLL_BAR_WIDTH * 2 + 2, he - SCROLL_BAR_HEIGHT + 1, 14, 14, NO_DRAW + SCROLL_RIGHT_BUTTON,0);
  582.         kos_DefineButton(17, he - SCROLL_BAR_HEIGHT + 1,  (wi - SCROLL_BAR_WIDTH - 2 * 14), 14, NO_DRAW + SCROLL_WIDTH,0);
  583.  
  584.         kos_DefineButton(sw(1, wi - SCROLL_BAR_WIDTH + 1), 14, 14, NO_DRAW + SCROLL_UP_BUTTON,0);
  585.         kos_DefineButton(sw(he - SCROLL_BAR_HEIGHT * 2 + 2, wi - SCROLL_BAR_WIDTH + 1), 14, 14, NO_DRAW + SCROLL_DOWN_BUTTON,0);
  586.         kos_DefineButton(sw(17, wi - SCROLL_BAR_WIDTH + 1),  sw((he - SCROLL_BAR_HEIGHT - 2 * 14), 14), NO_DRAW + SCROLL_HEIGHT,0);
  587.  
  588. }
  589.  
  590. // î÷åíü áûñòðîå ðèñîâàíèå ñåòêè, â ïðîöåññå èçìåíåíèÿ ðàçìåðîâ ÿ÷ååê
  591. void draw_size_grid()
  592. {
  593.         //rtlDebugOutString("draw size grid");
  594.  
  595.         if (size_state == SIZE_X)
  596.         {
  597.                 int x, x0, i;
  598.  
  599.                 x = col_width[0];
  600.                 x0 = 0;
  601.                 for (i = 1; i < col_count && x - x0 + col_width[i] < wi - 10; i++)
  602.                 {
  603.                         if (i >= scroll_x)
  604.                         {
  605.                                 if (i >= size_id)
  606.                                         kos_DrawLine(x - x0, 0, x - x0, he, 0, 1);
  607.                         }
  608.                         else
  609.                                 x0 += col_width[i];
  610.                         x += col_width[i];
  611.                 }
  612.                 kos_DrawLine(x - x0, 0, x - x0, he, 0, 1);
  613.         }
  614.         else
  615.         {
  616.                 int y, y0, i;
  617.  
  618.                 y = row_height[0];
  619.                 y0 = 0;
  620.                 for (i = 1; i < col_count && y - y0 + row_height[i] < he - 10; i++)
  621.                 {
  622.                         if (i >= scroll_y)
  623.                         {
  624.                                 if (i >= size_id)
  625.                                         kos_DrawLine(0, y - y0, wi, y - y0, 0, 1);
  626.                         }
  627.                         else
  628.                                 y0 += row_height[i];
  629.                         y += row_height[i];
  630.                 }
  631.                 kos_DrawLine(0, y - y0, wi, y - y0, 0, 1);
  632.         }
  633.  
  634. }
  635.  
  636.  
  637. // áûñòðîå ðèñîâàíèå âûäåëåííîé îáëàñòè ïðè âûäåëåíèè ìûøüþ
  638. #define DCOLOR 0
  639. //0xff0000
  640. #define DINVERT 1
  641. void draw_drag()
  642. {
  643.         // ñîáñòâåííî, 4 èíâåðñíûå ëèíèè
  644.  
  645.         int k0 = min(sel_x, sel_end_x);
  646.         int k1 = max(sel_x, sel_end_x);
  647.         int n0 = min(sel_y, sel_end_y);
  648.         int n1 = max(sel_y, sel_end_y);
  649.  
  650.         DWORD x0 = col_left[k0] - 1;
  651.         DWORD x1 = col_left[k1] + col_width[k1] + 1;
  652.         DWORD y0 = row_top[n0] - 1;    
  653.         DWORD y1 = row_top[n1] + row_height[n1] + 1;
  654.         if (x0 > wi - 1) x0 = wi - 1;
  655.         if (x1 > wi - 1) x1 = wi - 1;
  656.         if (y0 > he - 1) y0 = he - 1;
  657.         if (y1 > he - 1) y1 = he - 1;
  658.  
  659.         //sprintf(debuf,"drag %U %U %U %U",k0,k1,n0,n1);
  660.         //rtlDebugOutString(debuf);
  661.  
  662.         kos_DrawLine(x0, y0, x0, y1, DCOLOR, DINVERT);
  663.         kos_DrawLine(x0, y0, x1, y0, DCOLOR, DINVERT);
  664.         kos_DrawLine(x1, y0, x1, y1, DCOLOR, DINVERT);
  665.         kos_DrawLine(x0, y1, x1, y1, DCOLOR, DINVERT);
  666. }
  667.  
  668. void draw_window()
  669. {
  670.         int i;
  671.         double xx0=0.0, yy0=0.0;
  672.         sProcessInfo info;
  673.         void *p;
  674.  
  675.         if (sel_end_move)
  676.                 sel_moved = 0;
  677.  
  678.         memset((Byte*)&info, 0, 1024);
  679.  
  680.         kos_ProcessInfo(&info, 0xFFFFFFFF);
  681.  
  682.         p = info.rawData + 42;                  // magic
  683.         wi = *(Dword *)(p);
  684.         he = *(Dword *)((Byte *)p + 4);
  685.         win_x = *(Dword *)((Byte *)p - 8);
  686.         win_y = *(Dword *)((Byte *)p - 4);
  687.  
  688.         myPID = *(Dword*)((Byte *)p - 12);
  689.  
  690.         if (wi == 0)
  691.                 wi = WND_W;
  692.         if (he == 0)
  693.                 he = WND_H;
  694.  
  695.         he -= kos_GetSkinHeight() + MENU_PANEL_HEIGHT; // äîñòóïíàÿ âûñîòà îêíà
  696.         wi -= 10;
  697.  
  698.         //Leency{
  699.         // start redraw
  700.         if (window_drawall==true){
  701.                 kos_WindowRedrawStatus(1);
  702.                 kos_DefineAndDrawWindow(10,40,WND_W,WND_H,0x33,0x40FFFFFF,0,0,(Dword)"Table v" TABLE_VERSION);
  703.  
  704.                 if (he + MENU_PANEL_HEIGHT <= 8) //åñëè îêíî ñâ¸ðíóòî â çàãîëîâîê
  705.                 {
  706.                         kos_WindowRedrawStatus(2);
  707.                         return;
  708.                 }
  709.  
  710.                 if (he < 100) kos_ChangeWindow( -1, -1, -1, 180 );
  711.                 if (wi < 340) kos_ChangeWindow( -1, -1, 350, -1 );
  712.  
  713.         }//}Leency
  714.  
  715. //      edit_box_draw((dword)&ebox);
  716.         int y = he + kos_GetSkinHeight() - 10;
  717.  
  718.         if (!sel_moved)
  719.         {
  720.                 kos_DrawBar(wi-15,he - kos_GetSkinHeight() +7,16,16,0xe4dfe1);
  721.                 kos_DrawBar(0,he - kos_GetSkinHeight() + 23,wi + 1,MENU_PANEL_HEIGHT-5,0xe4dfe1);
  722.                 kos_WriteTextToWindow(3 + 1, y + 3, 0x80 , 0x000000, (char*)sFilename, strlen(sFilename));     
  723.         }
  724.  
  725.         //DWORD fn_line_color = fn_edit ? 0x000000 : 0xc0c0c0;
  726.         //kos_DrawRegion(61, y - 2, 102, 18, fn_line_color, 0);
  727.  
  728.         // äàëüøå editbox width = 100
  729.  
  730.         // border around edit box
  731.         file_box.left = 64;
  732.         file_box.top = y - 1;
  733.         file_box.width = 98;
  734.                 //editbox_h = 18;
  735.  
  736.         // ñîõðàíèòü
  737.         kos_DefineButton(20 + 160, y - 5, 60, 20, SAVE_BUTTON, 0xd0d0d0);
  738.         kos_WriteTextToWindow(22 + 160 + (60 - strlen(sSave) * 6) / 2, y + 2, 0, 0x000000, (char*)sSave, strlen(sSave));
  739.  
  740.         // çàãðóçèòü
  741.         kos_DefineButton(90 + 160, y - 5, 60, 20, LOAD_BUTTON, 0xd0d0d0);
  742.         kos_WriteTextToWindow(92 + 160 + (60 - strlen(sLoad) * 6) / 2, y + 2, 0, 0x000000, (char*)sLoad, strlen(sLoad));
  743.  
  744.         // ñîçäàòü. òîëüêî ýòó êíîïó âîòêíóòü íåêóäà î_Î
  745.         /*
  746.         kos_DefineButton(90 + 160 + 70, y - 5, 60, 20, NEW_BUTTON, 0xd0d0d0);
  747.         kos_WriteTextToWindow(92 + 160 + 10 + 70, y + 2, 0, 0x000000, (char*)sNew, strlen(sNew));
  748.         */
  749.         panel_y = y;
  750.  
  751.         //kos_DefineButton(0,0,WND_W,WND_H,0x60000002,0);
  752.         //if (is_edit) KEdit();
  753.  
  754.         if ((void*)edit_box_draw != NULL)
  755.         {
  756.                 if (is_edit)
  757.                         edit_box_draw((DWORD)&cell_box);
  758.                 edit_box_draw((DWORD)&file_box);
  759.         }      
  760.  
  761.         draw_grid();
  762.         // end redraw
  763.         kos_WindowRedrawStatus(2);
  764.         window_drawall=false;
  765.         sel_moved = 0;
  766. }
  767.  
  768.  
  769. void process_mouse()
  770. {
  771.         Dword mouse_btn, ckeys, shift, ctrl;
  772.         int mouse_x, mouse_y, i, p, dx = 0, dy = 0;
  773.         int redraw = 0;
  774.        
  775.         Dword mySlot = kos_GetSlotByPID(myPID);
  776.         if (kos_GetActiveSlot() != mySlot)
  777.                 return;
  778.  
  779.         edit_box_mouse((dword)&cell_box);
  780.         edit_box_mouse((dword)&file_box);
  781.  
  782.         int vert, hor;
  783.         kos_GetScrollInfo(vert, hor);
  784.  
  785.         //sprintf(debuf, "scroll %U %U", vert, hor);
  786.         //rtlDebugOutString(debuf);
  787.  
  788.         if (vert != 0) //òðóú ïåðåðèñîâêà!
  789.         {
  790.                 move_sel(sel_x, sel_y + vert);
  791.                 //move_sel(sel_x + hor, sel_y);
  792.                 return;
  793.         }
  794.        
  795.         kos_GetMouseState(mouse_btn, mouse_x, mouse_y);
  796.         mouse_x -= 5;
  797.         mouse_y -= kos_GetSkinHeight();
  798.  
  799.         mouse_btn &= 0x0001;
  800.  
  801.         ckeys = kos_GetSpecialKeyState();
  802.         shift = ckeys & 0x3;
  803.  
  804.         if (mouse_y < 0 && mouse_btn)   // ò.ê. ìûøêà íà çàãîëîâêå îêíà
  805.         {
  806.                 window_is_dragged = 1;
  807.                 return;
  808.         }
  809.         if (window_is_dragged)
  810.         {
  811.                 if (mouse_btn)
  812.                         return;
  813.                 else
  814.                         window_is_dragged = 0;
  815.         }
  816.  
  817.         if (!size_state && !mouse_btn)
  818.                 return;
  819.         if (mouse_btn && !size_state)           // LMB down                            
  820.         {
  821.                 //rtlDebugOutString("lmb down and not resize");
  822.  
  823.                 if (mouse_x >= drag_x && mouse_x <= drag_x + 4 && mouse_y >= drag_y && mouse_y <= drag_y + 4)
  824.                 {
  825.                         size_state = SIZE_DRAG;
  826.                         old_end_x = sel_end_x;
  827.                         old_end_y = sel_end_y;
  828.                 }
  829.                 else if (mouse_y <= row_height[0])
  830.                 {
  831.                         //rtlDebugOutString("can resize cols");
  832.                         int kx = -1, i;
  833.                         for (i = 0; i < col_count - 1; i++)
  834.                         if (mouse_x >= col_left[i] + col_width[i] - 5 &&
  835.                                 mouse_x <= col_left[i + 1] + 5)
  836.                         {
  837.                                 kx = i; break;
  838.                         }
  839.                         if (kx != -1)
  840.                         {
  841.                                 //sprintf(debuf,"size x %U",k);
  842.                                 //rtlDebugOutString(debuf);
  843.                                 size_id = kx;
  844.                                 size_state = SIZE_X;
  845.                         }
  846.                 }
  847.                 else if (mouse_x <= col_width[0])
  848.                 {
  849.                         int ky = -1;
  850.                         for (i = 0; i < row_count - 1; i++)
  851.                         if (mouse_y >= row_top[i] + row_height[i] - 5 &&
  852.                                 mouse_y <= row_top[i + 1] + 5)
  853.                         {
  854.                                 ky = i; break;
  855.                         }
  856.                         if (ky != -1)
  857.                         {
  858.                                 size_id = ky;
  859.                                 size_state = SIZE_Y;
  860.                         }
  861.                 }
  862.                 else            // êëèêíóòà ÿ÷åéêà
  863.                 if (mouse_x <= col_left[nx - 1] &&  mouse_y <= row_top[ny - 1])
  864.                 {
  865.                         was_single_selection = sel_x == sel_end_x && sel_y == sel_end_y;
  866.                         int kx = -1, i;
  867.                         for (i = 0; i < col_count - 1; i++)
  868.                         if (mouse_x >= col_left[i] &&
  869.                                 mouse_x <= col_left[i] + col_width[i])
  870.                         {
  871.                                 kx = i; break;
  872.                         }
  873.                         int ky = -1;
  874.                         for (i = 0; i < row_count - 1; i++)
  875.                         if (mouse_y >= row_top[i] &&
  876.                                 mouse_y <= row_top[i] + row_height[i])
  877.                         {
  878.                                 ky = i; break;
  879.                         }
  880.                         if (kx != -1 && ky != -1)
  881.                         {
  882.                                 if (!shift)
  883.                                 {
  884.                                         move_sel(kx, ky);
  885.                                         //return;
  886.                                 }
  887.                                 else
  888.                                 {
  889.                                         sel_end_x = kx;
  890.                                         sel_end_y = ky;
  891.                                 }
  892.                                 size_state = SIZE_SELECT;
  893.                         }
  894.                 }
  895.                 if (size_state)
  896.                 {
  897.                         size_mouse_x = mouse_x;
  898.                         size_mouse_y = mouse_y;
  899.                 }
  900.                 return;
  901.         }
  902.         else if (!mouse_btn && size_state)
  903.         {
  904.                 sel_moved = 0;          // ÷òîáû áûëà òðó ïåðåðèñîâêà
  905.                 //rtlDebugOutString("resize end");
  906.  
  907.                 if (size_state == SIZE_DRAG)
  908.                 {
  909.                         fill_cells(sel_x, sel_y, sel_end_x, sel_end_y, old_end_x, old_end_y);
  910.                 }
  911.  
  912.                 //sel_moved = (size_state == SIZE_SELECT && sel_x == sel_end_x && sel_y == sel_end_y && was_single_selection);
  913.                 size_state = 0;
  914.                 draw_window();          // âñå ñäâèíóëîñü - íàäî îáíîâèòüñÿ
  915.                 return;
  916.         }
  917.         if (size_state == SIZE_X && mouse_x != size_mouse_x)
  918.         {
  919.                 draw_size_grid();
  920.                 col_width[size_id] += mouse_x - size_mouse_x;
  921.                 if (col_width[size_id] < 15)
  922.                         col_width[size_id] = 15;
  923.                 else if (col_width[size_id] > wi / 2)
  924.                         col_width[size_id] = wi / 2;
  925.                 draw_size_grid();
  926.         }
  927.         if (size_state == SIZE_Y && mouse_y != size_mouse_y)
  928.         {
  929.                 draw_size_grid();
  930.                 row_height[size_id] += mouse_y - size_mouse_y;
  931.                 if (row_height[size_id] < 15)
  932.                         row_height[size_id] = 15;
  933.                 else if (row_height[size_id] > he / 2)
  934.                         row_height[size_id] = he / 2;
  935.                 draw_size_grid();
  936.         }
  937.         if ((size_state == SIZE_SELECT || size_state == SIZE_DRAG) && (mouse_x != size_mouse_x || mouse_y != size_mouse_y))
  938.         {
  939.                 draw_drag();
  940.                 int kx = -1, i;
  941.                 for (i = 0; i < col_count - 1; i++)
  942.                         if (mouse_x >= col_left[i] &&
  943.                                 mouse_x <= col_left[i + 1])
  944.                         {
  945.                                 //sprintf(debuf, "yyy %U",col_left[i+1]);
  946.                                 //rtlDebugOutString(debuf);
  947.                                 kx = i; break;
  948.                         }
  949.                 int ky = -1;
  950.                 for (i = 0; i < row_count - 1; i++)
  951.                         if (mouse_y >= row_top[i] &&
  952.                                 mouse_y <= row_top[i + 1])
  953.                         {
  954.                                 ky = i; break;
  955.                         }
  956.                 if (kx != -1) sel_end_x = kx;
  957.                 if (kx != -1) sel_end_y = ky;
  958.                 if (size_state == SIZE_DRAG)
  959.                 {
  960.                         if (abs(sel_end_x - sel_x) > 0)
  961.                         {
  962.                                 sel_end_y = old_end_y;
  963.                         }
  964.                         else if (abs(sel_end_y - sel_y) > 0)
  965.                         {
  966.                                 sel_end_x = old_end_x;
  967.                         }
  968.                 }
  969.                 draw_drag();
  970.         }        
  971.         size_mouse_x = mouse_x;
  972.         size_mouse_y = mouse_y;
  973. }
  974.  
  975. void process_key()
  976. {
  977.         Dword mouse_btn, ckeys, shift, ctrl;
  978.         int mouse_x, mouse_y, i, p, dx = 0, dy = 0;
  979.  
  980.         // key pressed, read it
  981.         Byte keyCode;
  982.         ckeys = kos_GetSpecialKeyState();
  983.         shift = ckeys & 0x3;
  984.         ctrl = ckeys & 0x0c;
  985.         //if (ctrl)
  986.         //      rtlDebugOutString("control pressed!");
  987.         dx = 0, dy = 0;
  988.         sel_moved = 0;
  989.         sel_end_move = 0;
  990.         kos_GetKey(keyCode);
  991.  
  992.         __asm
  993.         {
  994.                 mov ah, keyCode
  995.         }
  996.         edit_box_key((dword)&cell_box);
  997.         edit_box_key((dword)&file_box);
  998.  
  999.  
  1000.         switch (keyCode)
  1001.         {
  1002.                 case 178:                       // ñòðåëêè
  1003.                         //dx = 0;
  1004.                         dy = -1;
  1005.                         break;
  1006.                 case 176:
  1007.                         dx = -1;
  1008.                         //dy = 0;
  1009.                         break;
  1010.                 case 179:
  1011.                         dx = 1;
  1012.                         //dy = 0;
  1013.                         break;
  1014.                 case 177:
  1015.                         //dx = 0;
  1016.                         dy = 1;
  1017.                         break;
  1018.                 /*
  1019.                 case 183:
  1020.                         if (sel_y < row_count-(ny - scroll_y))  // page down
  1021.                                 dy = ny - scroll_y;
  1022.                         else
  1023.                                 dy = row_count-(ny - scroll_y) - sel_y;
  1024.                         dx = 0;
  1025.                         redraw = 1;
  1026.                         break;
  1027.                 case 184:
  1028.                         if (sel_y > ny - scroll_y)              // page up
  1029.                                 dy= - (ny - scroll_y);
  1030.                         else
  1031.                                 dy = - (ny - scroll_y) + sel_y;
  1032.                         dx = 0;
  1033.                         redraw = 1;
  1034.                         break;
  1035.                 */
  1036.                 case 180: //home
  1037.                         dx = -sel_x + 1;
  1038.                         dy = 0;
  1039.                         draw_grid(); //draw_window();
  1040.                         break;
  1041.                 case 181: //end
  1042.                         dx = col_count - (nx - scroll_x) - 1 - sel_x;
  1043.                         dy = 0;
  1044.                         draw_grid(); //draw_window();
  1045.                         break;
  1046.                 case 27:                // escape
  1047.                         cancel_edit();
  1048.                         break;
  1049.                 case 182:                       // delete
  1050.                         {
  1051.                                 int i,j,n0,n1,k0,k1;
  1052.                                 n0 = min(sel_x, sel_end_x);
  1053.                                 n1 = max(sel_x, sel_end_x);
  1054.                                 k0 = min(sel_y, sel_end_y);
  1055.                                 k1 = max(sel_y, sel_end_y);
  1056.  
  1057.                                 for (i = n0; i <= n1; i++)
  1058.                                         for (j = k0; j <= k1; j++)
  1059.                                         {
  1060.                                                 if (cells[i][j])
  1061.                                                 {
  1062.                                                         freemem(cells[i][j]);
  1063.                                                         cells[i][j] = NULL;
  1064.                                                 }
  1065.                                         }
  1066.                                 calculate_values();
  1067.                                 draw_grid();
  1068.                                 break;
  1069.                         }
  1070.                 case 0x0D:                      // enter
  1071.                         if (is_edit)
  1072.                         {
  1073.                                 stop_edit();
  1074.                                 draw_window();
  1075.                         }
  1076.                         break;
  1077.                 //case 0x08:                    // backspace
  1078.                         /*if (is_edit || fn_edit)
  1079.                         {
  1080.                                 if (strlen(edit_text) != 0)
  1081.                                         edit_text[strlen(edit_text) - 1] = '\0';
  1082.                                 KEdit();
  1083.                         }
  1084.                         else if (cells[sel_x][sel_y])
  1085.                         {
  1086.                                 start_edit(sel_x, sel_y);
  1087.                         }
  1088.                         */
  1089.                 //      break;
  1090.                 case 22:        // contol-v
  1091.                         {
  1092.                                 if (ctrl)
  1093.                                 {
  1094.                                         //rtlDebugOutString("control-v!");
  1095.                                         int i, j, x0, y0;
  1096.                                         x0 = min(sel_x, sel_end_x);
  1097.                                         y0 = min(sel_y, sel_end_y);
  1098.                                         int delta_x = x0 - buf_old_x;
  1099.                                         int delta_y = y0 - buf_old_y;
  1100.  
  1101.                                         for (i = 0; i < buf_col; i++)
  1102.                                                 for (j = 0; j < buf_row; j++)
  1103.                                                 {
  1104.                                                         if (i + x0 >= col_count || j + y0 >= row_count)
  1105.                                                                 continue;
  1106.                                                         if (cells[i + x0][j + y0])
  1107.                                                                 freemem(cells[i + x0][j + y0]);
  1108.                                                         if (buffer[i][j])
  1109.                                                         {
  1110.                                                                 cf_x0 = buf_old_x; cf_y0 = buf_old_y;
  1111.                                                                 cf_x1 = buf_old_x + buf_col;
  1112.                                                                 cf_y1 = buf_old_y + buf_row;
  1113.                                                                 cells[i + x0][j + y0] = change_formula(buffer[i][j], delta_x, delta_y);
  1114.                                                                 //cells[i + x0][j + y0] = (char*)allocmem(strlen(buffer[i][j]));
  1115.                                                                 //strcpy(cells[i + x0][j + y0], buffer[i][j]);
  1116.                                                         }
  1117.                                                         else
  1118.                                                                 cells[i + x0][j + y0] = NULL;
  1119.                                                 }
  1120.  
  1121.                                         calculate_values();
  1122.                                         draw_window();
  1123.                                         break;
  1124.                                 }
  1125.                         }
  1126.                         case 24:        // control-x
  1127.                         case 03:        // control-c
  1128.                         {
  1129.                                 if (ctrl)
  1130.                                 {
  1131.                                         //rtlDebugOutString("control-c!");
  1132.                                         int i, j, x0, y0;
  1133.  
  1134.                                         freeBuffer();
  1135.  
  1136.                                         buf_col = abs(sel_end_x - sel_x) + 1;
  1137.                                         buf_row = abs(sel_end_y - sel_y) + 1;
  1138.                                         x0 = min(sel_x, sel_end_x);
  1139.                                         y0 = min(sel_y, sel_end_y);
  1140.                                         buf_old_x = x0;
  1141.                                         buf_old_y = y0;
  1142.  
  1143.                                         //sprintf(debuf, "%U %U %U %U", buf_col, buf_row, x0, y0);
  1144.                                         //rtlDebugOutString(debuf);
  1145.                                
  1146.                                         buffer = (char***)allocmem(buf_col * sizeof(char**));
  1147.                                         for (i = 0; i < buf_col; i++)
  1148.                                         {
  1149.                                                 buffer[i] = (char**)allocmem(buf_row * sizeof(char*));
  1150.                                                 for (j = 0; j < buf_row; j++)
  1151.                                                 {
  1152.                                                         if (cells[i + x0][j + y0])
  1153.                                                         {
  1154.                                                                 if (keyCode == 03)      // ctrl-c
  1155.                                                                 {
  1156.                                                                         buffer[i][j] = (char*)allocmem(strlen(cells[i + x0][j + y0]));
  1157.                                                                         strcpy(buffer[i][j], cells[i + x0][j + y0]);
  1158.                                                                 }
  1159.                                                                 else
  1160.                                                                 {
  1161.                                                                         buffer[i][j] = cells[i + x0][j + y0];
  1162.                                                                         cells[i + x0][j + y0] = NULL;
  1163.                                                                 }
  1164.                                                         }
  1165.                                                         else
  1166.                                                                 buffer[i][j] = NULL;
  1167.                                                 }
  1168.                                         }
  1169.                                         if (keyCode == 24)
  1170.                                                 calculate_values();
  1171.                                         draw_window();
  1172.                                         break;
  1173.                                 }
  1174.                         }
  1175.                 case 06:                // control-f
  1176.                         {
  1177.                                 display_formulas = !display_formulas;
  1178.                                 draw_grid(); //draw_window();
  1179.                                 break;
  1180.                         }
  1181.                 default:
  1182.                        
  1183.                         if (!is_edit && !(file_box.flags & ed_focus))
  1184.                         {
  1185.                                 start_edit(sel_x, sel_y);
  1186.                                 if (keyCode == 8)
  1187.                                 {
  1188.                                         cell_box.pos = strlen(edit_text);
  1189.                                 }
  1190.                                 else
  1191.                                 {
  1192.                                         __asm
  1193.                                         {
  1194.                                                 mov ah, keyCode
  1195.                                         }
  1196.                                         edit_box_key((dword)&cell_box);
  1197.                                 }
  1198.                         }
  1199.                         if (is_edit)
  1200.                                 edit_box_draw((dword)&cell_box);
  1201.                         /*
  1202.                         if (strlen(edit_text)<256)
  1203.                         {
  1204.                                 edit_text[strlen(edit_text)]=keyCode;
  1205.                                 edit_text[strlen(edit_text) + 1]='\0';
  1206.                                 KEdit();
  1207.                         }
  1208.                         */
  1209.                         break;
  1210.         }
  1211.         if (dx != 0)
  1212.         {
  1213.                 if (shift)
  1214.                 {
  1215.                         sel_end_x += dx;
  1216.                         if (sel_end_x <= 1)
  1217.                                 sel_end_x = 1;
  1218.                         else if (sel_end_x >= col_count)
  1219.                                 sel_end_x = col_count - 1;
  1220.                 //      sprintf(debuf,"sel end x change. sel end %U %U",sel_end_x,sel_end_y);
  1221.                 //      rtlDebugOutString(debuf);
  1222.                         sel_moved = sel_end_move = 1;
  1223.                         //stop_edit();
  1224.                         //draw_grid();
  1225.                 }
  1226.                 else
  1227.                 {
  1228.                 }
  1229.         }
  1230.         if (dy != 0)
  1231.         {
  1232.                 if (shift)
  1233.                 {
  1234.                         sel_end_y += dy;
  1235.                         if (sel_end_y <= 1)
  1236.                                 sel_end_y = 1;
  1237.                         else if (sel_end_y >= row_count)
  1238.                                 sel_end_y = row_count - 1;
  1239.                 //      sprintf(debuf,"sel end y change. sel end %U %U",sel_end_x,sel_end_y);
  1240.                 //      rtlDebugOutString(debuf);
  1241.                         sel_moved = sel_end_move = 1;
  1242.                         //stop_edit();
  1243.                         //draw_grid();
  1244.                 }
  1245.         }
  1246.         /*
  1247.         if (sel_end_x < sel_x)
  1248.         {
  1249.                 Dword tmp = sel_end_x; sel_end_x = sel_x; sel_x = tmp;
  1250.         }
  1251.         if (sel_end_y < sel_y)
  1252.         {
  1253.                 Dword tmp = sel_end_y; sel_end_y = sel_y; sel_y = tmp;
  1254.         }
  1255.         */
  1256.         if ((dx || dy))
  1257.         {
  1258.                 if (!shift)
  1259.                 {
  1260.                         move_sel(sel_x + dx, sel_y + dy);
  1261.                 }
  1262.                 else
  1263.                 {
  1264.                         sel_moved = 0;
  1265.                         stop_edit();
  1266.                         draw_grid();
  1267.                 }
  1268.         }
  1269. }
  1270.  
  1271.  
  1272. void process_button()
  1273. {
  1274.         Dword mouse_btn, ckeys, shift, ctrl;
  1275.         int mouse_x, mouse_y, i, p, dx = 0, dy = 0;
  1276.         int redraw = 0;
  1277.  
  1278.         Dword button;
  1279.         kos_GetButtonID(button);
  1280.  
  1281.         /*
  1282.         sprintf(debuf, "button %U", button);
  1283.         rtlDebugOutString(debuf);
  1284.         //*/
  1285.  
  1286.         switch (button)
  1287.         {
  1288.         case 1:
  1289.                 kos_ExitApp();
  1290.  
  1291.         case SCROLL_LEFT_BUTTON:
  1292.                 //rtlDebugOutString("scroll left btn");
  1293.                 stop_edit();
  1294.                 scroll_x--;
  1295.                 if (scroll_x <= 0)
  1296.                         scroll_x = 1;
  1297.                 sel_moved = 0;
  1298.                 /*if (sel_x > nx - 1)
  1299.                 {
  1300.                         nx - 1;
  1301.                         sel_end_x = sel_x;
  1302.                 }*/
  1303.                 draw_window();
  1304.                 return;
  1305.  
  1306.         case SCROLL_RIGHT_BUTTON:
  1307.                 //rtlDebugOutString("scroll right btn");
  1308.                 stop_edit();
  1309.                 scroll_x++;
  1310.                 if (scroll_x >= col_count - 1)
  1311.                         scroll_x = col_count - 1;
  1312.                 sel_moved = 0;/*
  1313.                 if (sel_x < scroll_x)
  1314.                 {
  1315.                         sel_x = scroll_x;
  1316.                         sel_end_x = sel_x;
  1317.                 }*/
  1318.                 draw_window();
  1319.                 return;
  1320.  
  1321.         case SCROLL_WIDTH:
  1322.                 {
  1323.                         //rtlDebugOutString("scroll width btn");
  1324.                         stop_edit();
  1325.                         kos_GetMouseState(mouse_btn, mouse_x, mouse_y);
  1326.                         mouse_x -= 5;
  1327.                         mouse_y -= kos_GetSkinHeight();
  1328.  
  1329.                         // âñåãî: wi - SCROLL_BAR_WIDTH - 2 * 14
  1330.  
  1331.                         int tmp_w = (nx - scroll_x) * (wi - SCROLL_BAR_WIDTH - 3 * 14) / (col_count + 1);
  1332.                         if (tmp_w < 16)
  1333.                                 tmp_w = 16;
  1334.                         scroll_x = (mouse_x - 14 - tmp_w / 2) * (col_count + 1) / (wi - SCROLL_BAR_WIDTH - 3 * 14) + 1;
  1335.                         if (scroll_x <= 0)
  1336.                                 scroll_x = 1;
  1337.                         else if (scroll_x >= col_count - 1)
  1338.                                 scroll_x = col_count - 1;
  1339.                         sel_moved = 0;
  1340.                         draw_window();
  1341.                         return;
  1342.                 }
  1343.  
  1344.         case SCROLL_UP_BUTTON:
  1345.                 stop_edit();
  1346.                 scroll_y--;
  1347.                 if (scroll_y <= 0)
  1348.                         scroll_y = 1;
  1349.                 sel_moved = 0;
  1350.                 //draw_window();
  1351.                 draw_grid();
  1352.                 /*
  1353.                 if (sel_y > ny - 1)
  1354.                 {
  1355.                         sel_y = ny - 1;
  1356.                         sel_end_y = sel_y;
  1357.                 }*/
  1358.                 return;
  1359.  
  1360.         case SCROLL_DOWN_BUTTON:
  1361.                 stop_edit();
  1362.                 scroll_y++;
  1363.                 if (scroll_y >= row_count - 1)
  1364.                         scroll_y = row_count - 1;
  1365.                 sel_moved = 0;/*
  1366.                 if (sel_y < scroll_y)
  1367.                 {
  1368.                         sel_y = scroll_y;
  1369.                         sel_end_y = sel_y;
  1370.                 }*/
  1371.                 draw_grid();
  1372.                 return;
  1373.  
  1374.         case SCROLL_HEIGHT:
  1375.                 {
  1376.                         stop_edit();
  1377.                         kos_GetMouseState(mouse_btn, mouse_x, mouse_y);
  1378.                         mouse_x -= 5;
  1379.                         mouse_y -= kos_GetSkinHeight();
  1380.                         int tmp_h = (ny - scroll_y) * (he - SCROLL_BAR_HEIGHT - 2 * 14) / row_count;
  1381.                         if (tmp_h < 16)
  1382.                                 tmp_h = 16;
  1383.                         scroll_y = (mouse_y - 2 * 14) * (row_count + 1) / (he - SCROLL_BAR_HEIGHT - 3 * 14) + 1;
  1384.                         if (scroll_y <= 0)
  1385.                                 scroll_y = 1;
  1386.                         else if (scroll_y >= row_count - 1)
  1387.                                 scroll_y = row_count - 1;
  1388.                         sel_moved = 0;
  1389.                         draw_grid();
  1390.                         return;
  1391.                 }
  1392.  
  1393.         case NEW_BUTTON:        // clear the table
  1394.                 reinit();
  1395.                 draw_window();
  1396.                 break;
  1397.  
  1398.         case FILENAME_BUTTON:
  1399.                 sel_moved = 1;
  1400.                 stop_edit();
  1401.                 fn_edit = 1;
  1402.                 strcpy(edit_text, fname);
  1403.                 draw_window();
  1404.                 break;
  1405.  
  1406.         case SAVE_BUTTON:
  1407.                 stop_edit();
  1408.                 kos_DrawBar(320, panel_y, wi - 320 - 10, 10, 0xe4dfe1);
  1409.                 if (SaveFile(fname))
  1410.                         kos_WriteTextToWindow(320, panel_y, 0, 0x000000, (char*)msg_save, strlen(msg_save));
  1411.                 break;
  1412.  
  1413.         case LOAD_BUTTON:
  1414.                 stop_edit();
  1415.                 int r = LoadFile(fname);
  1416.                 kos_DrawBar(320, panel_y, wi - 320 - 10, 10, 0xe4dfe1);
  1417.                 if (r > 0)
  1418.                 {
  1419.                         calculate_values();
  1420.                         sel_moved = 0;
  1421.                         draw_window();
  1422.                         kos_WriteTextToWindow(320, panel_y,0,0x000000,(char*)msg_load, strlen(msg_load));
  1423.                 }
  1424.                 else if (r == -1)
  1425.                         kos_WriteTextToWindow(320, panel_y,0,0x000000,(char*)er_file_not_found,strlen(er_file_not_found));
  1426.                 else if (r == -2)
  1427.                         kos_WriteTextToWindow(320, panel_y,0,0x000000,(char*)er_format,strlen(er_format));
  1428.                 break;
  1429.         }
  1430.         if (button >= COL_HEAD_BUTTON && button < ROW_HEAD_BUTTON)
  1431.         {
  1432.                 sel_end_x = sel_x = button - COL_HEAD_BUTTON;
  1433.                 sel_y = 1;
  1434.                 sel_end_y = row_count - 1;
  1435.                 stop_edit();
  1436.                 draw_window();
  1437.                 return;
  1438.         }
  1439.         else if (button >= ROW_HEAD_BUTTON && button < CELL_BUTTON)
  1440.         {
  1441.                 sel_end_y = sel_y = button - ROW_HEAD_BUTTON;
  1442.                 sel_x = 1;
  1443.                 sel_end_x = col_count - 1;
  1444.                 stop_edit();
  1445.                 draw_window();
  1446.                 return;
  1447.         }
  1448.  
  1449. }
  1450.  
  1451. void kos_Main()
  1452. {
  1453.         kos_InitHeap();
  1454.         load_edit_box();
  1455.         init();
  1456.  
  1457.         for (;;)
  1458.         {
  1459.                 switch (kos_CheckForEvent())
  1460.                 {
  1461.                 case 0:
  1462.                         process_mouse();
  1463.                         break;
  1464.                 case 1:
  1465.                         window_drawall=true;
  1466.                         draw_window();
  1467.                         break;
  1468.                 case 2:
  1469.                         process_key();
  1470.                         break;
  1471.                 case 3:
  1472.                         process_button();
  1473.                         break;
  1474.                 //case 6:
  1475.                 //      draw_window();
  1476.                 //      break;
  1477.                 }
  1478.         }
  1479. }
  1480.  
  1481.