?login_element?

Subversion Repositories NedoOS

Rev

Rev 2214 | Blame | Compare with Previous | Last modification | View Log | Download

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <intrz80.h>
  4. #include <stdlib.h>
  5. #include <oscalls.h>
  6. #include <../common/terminal.c>
  7. #include <tcp.h>
  8. #include <osfs.h>
  9. #include <graphic.h>
  10. #include <ctype.h>
  11. #include <math.h>
  12.  
  13. #define true 1
  14. #define false 0
  15. #define screenHeight 23
  16. #define screenWidth 80
  17.  
  18. unsigned int RBR_THR = 0xf8ef;
  19. unsigned int IER = 0xf9ef;
  20. unsigned int IIR_FCR = 0xfaef;
  21. unsigned int LCR = 0xfbef;
  22. unsigned int MCR = 0xfcef;
  23. unsigned int LSR = 0xfdef;
  24. unsigned int MSR = 0xfeef;
  25. unsigned int SR = 0xffef;
  26. unsigned int divider = 1;
  27. unsigned char comType = 0;
  28. unsigned int espType = 32;
  29. unsigned char netDriver = 0;
  30.  
  31. unsigned char uVer[] = "00.97";
  32. unsigned char curPath[128];
  33. unsigned char cmd[128];
  34. unsigned int pageOffsets[128];
  35. unsigned long volumeOffsets[16];
  36. unsigned char crlf[2] = {13, 10};
  37. unsigned char heap[1500];
  38.  
  39. const unsigned char gotWiFi[] = "WIFI GOT IP";
  40.  
  41. struct sockaddr_in targetadr;
  42. struct readstructure readStruct;
  43. struct sockaddr_in dnsaddress;
  44.  
  45. struct linkStruct
  46. {
  47.         unsigned char type;
  48.         unsigned long size;
  49.         unsigned char nexType;
  50.         unsigned char path[512];
  51.         unsigned char host[256];
  52.         unsigned char prevHost[256];
  53.         unsigned int port;
  54. } link;
  55.  
  56. struct mouseStruct
  57. {
  58.         char lmb;
  59.         char rmb;
  60.         char mmb;
  61.         char wheel;
  62.         char prevWheel;
  63.         char mouseXpos;
  64.         char mouseYpos;
  65.         char prevMouseXpos;
  66.         char prevMouseYpos;
  67.         int cursXpos;
  68.         int cursYpos;
  69.         unsigned int prevMouseButtons;
  70.         char prevMouseMove;
  71.         char oldAtr;
  72.         char classic;
  73.         char divider;
  74. } mouse;
  75.  
  76. struct navigationStruct
  77. {
  78.         unsigned int page;
  79.         unsigned int volume;
  80.         unsigned int maxVolume;
  81.         unsigned int maxPage;
  82.         unsigned int linePage;
  83.         unsigned int lineSelect;
  84.         unsigned int lastLine;
  85.         unsigned int prevLineSelect;
  86.         unsigned int bufPos;
  87.         unsigned int nextBufPos;
  88.         unsigned int history;
  89.         unsigned int saveAs;
  90.         unsigned char fileName[128];
  91. } navi;
  92.  
  93. struct window
  94. {
  95.         unsigned char x;
  96.         unsigned char y;
  97.         unsigned char w;
  98.         unsigned char h;
  99.         unsigned char text;
  100.         unsigned char back;
  101.         unsigned char tittle[80];
  102. } curWin;
  103.  
  104. unsigned char nvext[1024];
  105.  
  106. unsigned char netbuf[32768];
  107.  
  108. void spaces(unsigned char number)
  109. {
  110.         while (number > 0)
  111.         {
  112.                 putchar(' ');
  113.                 number--;
  114.         }
  115. }
  116.  
  117. void waitKey(void)
  118. {
  119.         do
  120.         {
  121.                 YIELD();
  122.         } while (OS_GETKEY() == 0);
  123. }
  124.  
  125. void clearStatus(void)
  126. {
  127.         OS_SETCOLOR(5);
  128.         OS_SETXY(0, 24);
  129.         spaces(79);
  130.         putchar('\r');
  131. }
  132.  
  133. void printTable(void)
  134. {
  135.         unsigned int cycle;
  136.  
  137.         for (cycle = 1; cycle < 256; cycle++)
  138.         {
  139.                 OS_SETCOLOR(7);
  140.                 printf("%03u:", cycle);
  141.                 OS_SETCOLOR(71);
  142.                 putchar(cycle);
  143.                 OS_SETCOLOR(7);
  144.                 printf(" ");
  145.                 if (cycle % 12 == 0)
  146.                 {
  147.                         printf("\r\n");
  148.                 }
  149.         }
  150. }
  151.  
  152. void delay(unsigned long counter)
  153. {
  154.         unsigned long start, finish;
  155.         counter = counter / 20;
  156.         if (counter < 1)
  157.         {
  158.                 counter = 1;
  159.         }
  160.         start = time();
  161.         finish = start + counter;
  162.  
  163.         while (start < finish)
  164.         {
  165.                 start = time();
  166.         }
  167. }
  168.  
  169. ///////////////////////////
  170. #include <../common/esp-com.c>
  171. #include <../common/network.c>
  172. //////////////////////////
  173.  
  174. void clearNetbuf(void)
  175. {
  176.         unsigned int counter;
  177.         for (counter = 0; counter < sizeof(netbuf); counter++)
  178.         {
  179.                 netbuf[counter] = 0;
  180.         }
  181. }
  182.  
  183. unsigned char saveBuf(unsigned char *fileNamePtr, unsigned char operation, unsigned int sizeOfBuf)
  184. {
  185.  
  186.         FILE *fp2;
  187.         if (operation == 00)
  188.         {
  189.                 fp2 = OS_CREATEHANDLE(fileNamePtr, 0x80);
  190.                 if (((int)fp2) & 0xff)
  191.                 {
  192.                         clearStatus();
  193.                         printf("%s  creating error.", fileNamePtr);
  194.                         waitKey();
  195.                         exit(0);
  196.                 }
  197.                 OS_CLOSEHANDLE(fp2);
  198.                 return 0;
  199.         }
  200.  
  201.         if (operation == 01)
  202.         {
  203.                 long fileSize;
  204.                 fp2 = OS_OPENHANDLE(fileNamePtr, 0x80);
  205.                 if (((int)fp2) & 0xff)
  206.                 {
  207.                         clearStatus();
  208.                         printf("%s", fileNamePtr);
  209.                         printf(" opening error. ");
  210.                         waitKey();
  211.                         exit(0);
  212.                 }
  213.                 fileSize = OS_GETFILESIZE(fp2);
  214.                 OS_SEEKHANDLE(fp2, fileSize);
  215.                 OS_WRITEHANDLE(netbuf, fp2, sizeOfBuf);
  216.                 OS_CLOSEHANDLE(fp2);
  217.                 return 0;
  218.         }
  219.  
  220.         if (operation == 02)
  221.         {
  222.                 OS_CLOSEHANDLE(fp2);
  223.                 return 0;
  224.         }
  225.         return 0;
  226. }
  227.  
  228. void drawClock(void)
  229. {
  230.         unsigned long dosTime;
  231.         unsigned int hours, minutes;
  232.         dosTime = OS_GETTIME();
  233.         hours = dosTime >> 11 & 31;        // 0b00011111
  234.         minutes = (dosTime >> 5) & 63; // 0b00111111
  235.  
  236.         OS_SETXY(73, 0);
  237.         printf("[%02u:%02u]", hours, minutes);
  238. }
  239.  
  240. void mainWinDraw(void)
  241. {
  242.         OS_SETCOLOR(207);
  243.         OS_SETXY(0, 0);
  244.         spaces(80);
  245.         OS_SETXY(0, 0);
  246.         printf("NedoGopher %s", uVer);
  247.  
  248.         OS_SETXY(39 - strlen(link.host) / 2, 0);
  249.         printf("%s", link.host);
  250.  
  251.         OS_SETXY(55, 0);
  252.  
  253.         if (netDriver)
  254.         {
  255.                 printf("[ESP-COM]");
  256.         }
  257.         else
  258.         {
  259.                 printf("[NEDONET]");
  260.         }
  261.         OS_SETXY(64, 0);
  262.         if (navi.saveAs)
  263.         {
  264.                 printf("[Save As]");
  265.         }
  266.         else
  267.         {
  268.                 printf("[Play It]");
  269.         }
  270.  
  271.         drawClock();
  272. }
  273.  
  274. void initMouse(void)
  275. {
  276.         unsigned long mouseRaw;
  277.         unsigned int mouseButtons;
  278.         mouseRaw = OS_GETMOUSE();
  279.         mouseButtons = mouseRaw;
  280.         mouse.wheel = (mouseButtons >> 4) & 15;
  281.         mouse.prevWheel = mouse.wheel;
  282.         mouse.classic = 0;
  283. }
  284.  
  285. unsigned char OS_SHELL(const char *command)
  286. {
  287.         unsigned char fileName[] = "term.com";
  288.         unsigned char appCmd[128] = "term.com ";
  289.         unsigned int shellSize, loop;
  290.         unsigned char pgbak;
  291.         union APP_PAGES shell_pg;
  292.         union APP_PAGES main_pg;
  293.         FILE *fp3;
  294.         main_pg.l = OS_GETMAINPAGES();
  295.         pgbak = main_pg.pgs.window_3;
  296.         OS_GETPATH((unsigned int)&curPath);
  297.         OS_SETSYSDRV();
  298.         strcat(appCmd, command);
  299.  
  300.         fp3 = OS_OPENHANDLE(fileName, 0x80);
  301.         if (((int)fp3) & 0xff)
  302.         {
  303.                 clearStatus();
  304.                 printf("%s", fileName);
  305.                 printf(" not found.");
  306.                 do
  307.                 {
  308.                         YIELD();
  309.                 } while (_low_level_get() == 0);
  310.                 exit(0);
  311.         }
  312.  
  313.         shellSize = OS_GETFILESIZE(fp3);
  314.  
  315.         OS_CHDIR(curPath);
  316.  
  317.         OS_NEWAPP((unsigned int)&shell_pg);
  318.         shell_pg.l = OS_GETAPPMAINPAGES(shell_pg.pgs.pId);
  319.         SETPG32KHIGH(shell_pg.pgs.window_0);
  320.         memcpy((unsigned char *)(0xC080), (unsigned char *)(&appCmd), strlen(appCmd) + 1);
  321.  
  322.         loop = 0;
  323.         while (loop < shellSize)
  324.         {
  325.                 unsigned int loaded, adr;
  326.                 loaded = OS_READHANDLE(cmd, fp3, sizeof(cmd) - 1);
  327.                 adr = 0xC100 + loop;
  328.                 memcpy((unsigned char *)(adr), &cmd, loaded);
  329.                 loop = loop + loaded;
  330.         }
  331.         OS_CLOSEHANDLE(fp3);
  332.         SETPG32KHIGH(pgbak);
  333.         OS_RUNAPP(shell_pg.pgs.pId);
  334.         return shell_pg.pgs.pId;
  335. }
  336.  
  337. char loadPageFromDisk(unsigned char *filepath, unsigned int volume)
  338. {
  339.         unsigned int todo = 0;
  340.         unsigned long clean = 0, loaded = 0;
  341.         FILE *fp1;
  342.  
  343.         fp1 = OS_OPENHANDLE(filepath, 0x80);
  344.         if (((int)fp1) & 0xff)
  345.         {
  346.                 clearStatus();
  347.                 printf("%s opening error. ", filepath);
  348.                 return false;
  349.         }
  350.  
  351.         OS_SEEKHANDLE(fp1, volumeOffsets[volume]);
  352.         do
  353.         {
  354.                 if ((sizeof(netbuf) - loaded) < 513)
  355.                 {
  356.                         // clearStatus();
  357.                         // printf("Файл слишком большой, будет загружаться частями (%ld kb)...", link.size / 1024);
  358.                         break;
  359.                 }
  360.  
  361.                 todo = OS_READHANDLE(netbuf + loaded, fp1, 512);
  362.                 loaded = loaded + todo;
  363.  
  364.         } while (todo != 0 && errno == 0);
  365.         OS_CLOSEHANDLE(fp1);
  366.         netbuf[loaded + 1] = 0;
  367.  
  368.         if (todo == 0 && errno == 0)
  369.         {
  370.                 navi.maxVolume = volume;
  371.         }
  372.         volumeOffsets[volume + 1] = volumeOffsets[volume] + loaded;
  373.  
  374.         clean = loaded + 128;
  375.         do
  376.         {
  377.                 netbuf[loaded] = 0;
  378.                 loaded++;
  379.         } while (loaded < clean);
  380.  
  381.         return true;
  382. }
  383.  
  384. void loadNVext(void)
  385. {
  386.         FILE *nvf;
  387.         unsigned int nvextSize, loop = 0, loaded;
  388.         OS_SETSYSDRV();
  389.         nvf = OS_OPENHANDLE("nv.ext", 0x80);
  390.         if (((int)nvf) & 0xff)
  391.         {
  392.                 clearStatus();
  393.                 printf("nv.ext not found.\r\n");
  394.                 exit(0);
  395.         }
  396.         nvextSize = OS_GETFILESIZE(nvf);
  397.         do
  398.         {
  399.                 loaded = OS_READHANDLE(nvext + loop, nvf, sizeof(nvext) - 1);
  400.                 loop = loop + loaded;
  401.         } while (loop < nvextSize);
  402.  
  403.         OS_CLOSEHANDLE(nvf);
  404.         nvext[loop + 1] = 0;
  405. }
  406.  
  407. void init(void)
  408. {
  409.         targetadr.family = AF_INET;
  410.         targetadr.porth = 00;
  411.         targetadr.portl = 70;
  412.         targetadr.b1 = 0;
  413.         targetadr.b2 = 0;
  414.         targetadr.b3 = 0;
  415.         targetadr.b4 = 0;
  416.         mouse.oldAtr = 79;
  417.         navi.lineSelect = 1;
  418.         navi.prevLineSelect = 2;
  419.         navi.nextBufPos = 0;
  420.         navi.page = 0;
  421.         navi.maxPage = 32767;
  422.         navi.maxVolume = 32767;
  423.         navi.volume = 0;
  424.         volumeOffsets[0] = 0;
  425.         navi.saveAs = true;
  426.         mouse.divider = 0;
  427.         mouse.prevMouseButtons = 0;
  428.         navi.history = 0;
  429.         link.type = '1';
  430.         link.size = 0;
  431.         link.nexType = '1';
  432.         strcpy(link.path, "HOMEPAGE");
  433.         strcpy(link.host, "HOMEPAGE");
  434.         strcpy(link.prevHost, "HOMEPAGE");
  435.         link.port = 70;
  436.         OS_SETSYSDRV();
  437.         OS_DELETE("browser/ng_hist.dat");
  438.         get_dns();
  439.         loadNVext();
  440.         loadEspConfig();
  441.         initMouse();
  442. }
  443. void newPage(void)
  444. {
  445.         navi.page = 0;
  446.         navi.maxPage = 32767;
  447.         navi.maxVolume = 32767;
  448.         navi.linePage = 0;
  449.         navi.lineSelect = 1;
  450.         navi.prevLineSelect = 2;
  451.         navi.bufPos = 0;
  452.         navi.nextBufPos = 0;
  453.         volumeOffsets[0] = 0;
  454.         navi.lastLine = 0;
  455. }
  456.  
  457. void renderType(unsigned char linkType)
  458. {
  459.         OS_SETCOLOR(70);
  460.  
  461.         switch (linkType)
  462.         {
  463.         case 'i':
  464.                 putchar(' ');
  465.                 break;
  466.         case '0':
  467.                 putchar(21); // plain text
  468.                 putchar(' ');
  469.                 break;
  470.         case '1':
  471.                 putchar(16); // directory
  472.                 putchar(' ');
  473.                 break;
  474.         case '3':
  475.                 putchar(15); // error link
  476.                 putchar(' ');
  477.                 break;
  478.         case '5': // Dos zip
  479.                 putchar('Z');
  480.                 putchar(' ');
  481.                 break;
  482.         case '6': // uuencoded file
  483.                 putchar('Z');
  484.                 putchar(' ');
  485.                 break;
  486.         case '7': // search input
  487.                 putchar(253);
  488.                 putchar(' ');
  489.                 break;
  490.         case '8': // Telnet session
  491.                 putchar('T');
  492.                 putchar(' ');
  493.                 break;
  494.         case '9': // binary (pt3/scr)
  495.                 putchar(8);
  496.                 putchar(' ');
  497.                 break;
  498.         case 'g': // gif pic
  499.                 putchar(2);
  500.                 putchar(' ');
  501.                 break;
  502.         case 'I': // image
  503.                 putchar(2);
  504.                 putchar(' ');
  505.                 break;
  506.         case 's': // sound
  507.                 putchar(14);
  508.                 putchar(' ');
  509.                 break;
  510.         default:
  511.                 putchar(linkType);
  512.                 break;
  513.         }
  514.         OS_SETCOLOR(7);
  515. }
  516.  
  517. unsigned int renderPlain(unsigned int bufPos)
  518. {
  519.         unsigned int counter = 0, colCount = 0;
  520.         unsigned int flag = true;
  521.  
  522.         link.type = '0';
  523.  
  524.         OS_CLS(0);
  525.         mainWinDraw();
  526.         OS_SETCOLOR(7);
  527.         OS_SETXY(0, 1);
  528.  
  529.         counter = 0;
  530.         do
  531.         {
  532.                 unsigned int byte;
  533.                 byte = netbuf[bufPos];
  534.                 if (byte == 0)
  535.                 {
  536.                         navi.maxPage = navi.page;
  537.                         return bufPos;
  538.                 }
  539.  
  540.                 if (colCount == 80)
  541.                 {
  542.                         counter++;
  543.                         colCount = 0;
  544.                 }
  545.  
  546.                 if (byte == 0xd)
  547.                 {
  548.                         if (colCount != 80)
  549.                         {
  550.                                 putchar('\r');
  551.                                 flag = true;
  552.                         }
  553.                         else
  554.                         {
  555.                                 flag = false;
  556.                         }
  557.  
  558.                         bufPos++;
  559.                         colCount = 0;
  560.                         continue;
  561.                 }
  562.  
  563.                 if (byte == 0xa)
  564.                 {
  565.                         if (flag)
  566.                         {
  567.                                 putchar('\n');
  568.                         }
  569.  
  570.                         bufPos++;
  571.                         counter++;
  572.                         flag = true;
  573.                         continue;
  574.                 }
  575.  
  576.                 putchar(byte);
  577.  
  578.                 colCount++;
  579.                 bufPos++;
  580.  
  581.         } while (counter < screenHeight);
  582.         return bufPos;
  583. }
  584.  
  585. unsigned int renderPage(unsigned int bufPos)
  586. {
  587.         unsigned char counter = 0, colCount = 0;
  588.         unsigned char byte = 0;
  589.  
  590.         link.type = '1';
  591.  
  592.         OS_CLS(0);
  593.         mainWinDraw();
  594.         OS_SETXY(0, 1);
  595.  
  596.         byte = netbuf[bufPos];
  597.         renderType(byte);
  598.  
  599.         OS_SETCOLOR(7);
  600.         do
  601.         {
  602.                 while (42)
  603.                 {
  604.                         bufPos++;
  605.  
  606.                         byte = netbuf[bufPos];
  607.  
  608.                         if (byte == 9)
  609.                         {
  610.                                 putchar('\r');
  611.                                 putchar('\n');
  612.                                 break;
  613.                         }
  614.  
  615.                         if (byte == 0)
  616.                         {
  617.                                 navi.maxPage = navi.page;
  618.                                 navi.lastLine = counter;
  619.                                 return bufPos;
  620.                         }
  621.                         colCount++;
  622.                         if (colCount < 78)
  623.                         {
  624.                                 putchar(byte);
  625.                         }
  626.                 }
  627.                 while (42)
  628.                 {
  629.                         bufPos++;
  630.                         if (netbuf[bufPos] == 10)
  631.                         {
  632.                                 colCount = 0;
  633.                                 counter++;
  634.                                 bufPos++;
  635.                                 if (netbuf[bufPos] == '.')
  636.                                 {
  637.                                         navi.maxPage = navi.page;
  638.                                         navi.lastLine = counter;
  639.                                         return bufPos;
  640.                                 }
  641.                                 if (counter < screenHeight)
  642.                                 {
  643.                                         renderType(netbuf[bufPos]);
  644.                                 }
  645.                                 break;
  646.                         }
  647.                 }
  648.         } while (counter < screenHeight);
  649.         navi.lastLine = counter;
  650.         return bufPos;
  651. }
  652.  
  653. void reDraw(void)
  654. {
  655.         if (link.type == '0')
  656.         {
  657.                 navi.nextBufPos = renderPlain(pageOffsets[navi.page]);
  658.         }
  659.         else
  660.         {
  661.                 if (link.type == '1')
  662.                 {
  663.                         navi.nextBufPos = renderPage(pageOffsets[navi.page]);
  664.                 }
  665.         }
  666. }
  667.  
  668. void errorBox(struct window w, const char *message)
  669. {
  670.         unsigned char wcount, tempx, tittleStart;
  671.  
  672.         w.h++;
  673.         OS_SETXY(w.x, w.y - 1);
  674.         BDBOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  675.         OS_SETXY(w.x, w.y);
  676.         OS_SETCOLOR(w.text);
  677.         putchar(201);
  678.         for (wcount = 0; wcount < w.w; wcount++)
  679.         {
  680.                 putchar(205);
  681.         }
  682.         putchar(187);
  683.         OS_SETXY(w.x, w.y + w.h);
  684.         putchar(200);
  685.         for (wcount = 0; wcount < w.w; wcount++)
  686.         {
  687.                 putchar(205);
  688.         }
  689.         putchar(188);
  690.  
  691.         tempx = w.x + w.w + 1;
  692.         for (wcount = 1; wcount < w.h; wcount++)
  693.         {
  694.                 OS_SETXY(w.x, w.y + wcount);
  695.                 putchar(186);
  696.                 OS_SETXY(tempx, w.y + wcount);
  697.                 putchar(186);
  698.         }
  699.         tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  700.         OS_SETXY(tittleStart, w.y);
  701.         printf("[%s]", w.tittle);
  702.         OS_SETXY(w.x + 1, w.y + 1);
  703.         OS_SETCOLOR(w.back);
  704.         tittleStart = w.x + (w.w / 2) - (strlen(message) / 2);
  705.         OS_SETXY(tittleStart, w.y + 1);
  706.         printf("%s", message);
  707. }
  708.  
  709. unsigned char inputBox(struct window w, const char *prefilled)
  710. {
  711.         unsigned char wcount, tempx, tittleStart;
  712.         unsigned char byte, counter;
  713.         w.h++;
  714.         OS_SETXY(w.x, w.y - 1);
  715.         BDBOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  716.         OS_SETXY(w.x, w.y);
  717.         OS_SETCOLOR(w.text);
  718.         putchar(201);
  719.         for (wcount = 0; wcount < w.w; wcount++)
  720.         {
  721.                 putchar(205);
  722.         }
  723.         putchar(187);
  724.         OS_SETXY(w.x, w.y + w.h);
  725.         putchar(200);
  726.         for (wcount = 0; wcount < w.w; wcount++)
  727.         {
  728.                 putchar(205);
  729.         }
  730.         putchar(188);
  731.  
  732.         tempx = w.x + w.w + 1;
  733.         for (wcount = 1; wcount < w.h; wcount++)
  734.         {
  735.                 OS_SETXY(w.x, w.y + wcount);
  736.                 putchar(186);
  737.                 OS_SETXY(tempx, w.y + wcount);
  738.                 putchar(186);
  739.         }
  740.         tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  741.         OS_SETXY(tittleStart, w.y);
  742.         printf("[%s]", w.tittle);
  743.         OS_SETXY(w.x + 1, w.y + 1);
  744.         OS_SETCOLOR(w.back);
  745.         putchar(219);
  746.  
  747.         cmd[0] = 0;
  748.  
  749.         counter = strlen(prefilled);
  750.         if (counter != 0)
  751.         {
  752.                 strcpy(cmd, prefilled);
  753.                 goto skipKeys;
  754.         }
  755.  
  756.         do
  757.         {
  758.                 byte = OS_GETKEY();
  759.                 if (byte != 0)
  760.                 {
  761.                         switch (byte)
  762.                         {
  763.                         case 0x08:
  764.                                 if (counter > 0)
  765.                                 {
  766.                                         counter--;
  767.                                         cmd[counter] = 0;
  768.                                 }
  769.                                 break;
  770.                         case 0x0d:
  771.  
  772.                                 if (counter == 0)
  773.                                 {
  774.                                         return false;
  775.                                 }
  776.                                 else
  777.                                 {
  778.                                         return true;
  779.                                 }
  780.  
  781.                         case 31:
  782.                                 break;
  783.                         case 250:
  784.                                 break;
  785.                         case 249:
  786.                                 break;
  787.                         case 248:
  788.                                 break;
  789.                         case 251: // Right
  790.                                 break;
  791.                         case 252: // Del
  792.                                 OS_SETXY(w.x + 1, w.y + 1);
  793.                                 spaces(counter + 1);
  794.                                 cmd[0] = 0;
  795.                                 counter = 0;
  796.                                 break;
  797.                         case 27:
  798.                                 cmd[0] = 0;
  799.                                 return false;
  800.                         default:
  801.                                 if (counter < w.w - 1)
  802.                                 {
  803.                                         cmd[counter] = byte;
  804.                                         counter++;
  805.                                         cmd[counter] = 0;
  806.                                 }
  807.                                 break;
  808.                         }
  809.                 skipKeys:
  810.                         OS_SETXY(w.x + 1, w.y + 1);
  811.                         printf("%s", cmd);
  812.                         putchar(219);
  813.                         if (byte == 0x08)
  814.                         {
  815.                                 putchar(' ');
  816.                         }
  817.                 }
  818.                 YIELD();
  819.         } while (42);
  820.         return false;
  821. }
  822.  
  823. void pusHistory(void)
  824. {
  825.         FILE *hf;
  826.         unsigned int structSize, filePos;
  827.         if (link.type == '7')
  828.         {
  829.                 return;
  830.         }
  831.  
  832.         navi.history++;
  833.         structSize = sizeof(struct linkStruct);
  834.         filePos = structSize * (navi.history - 1);
  835.  
  836.         OS_SETSYSDRV();
  837.  
  838.         hf = OS_CREATEHANDLE("browser/ng_hist.dat", 0x80);
  839.         if (((int)hf) & 0xff)
  840.         {
  841.                 clearStatus();
  842.                 printf("browser/ng_hist.dat creating error.");
  843.                 exit(0);
  844.         }
  845.         OS_CLOSEHANDLE(hf);
  846.  
  847.         hf = OS_OPENHANDLE("browser/ng_hist.dat", 0x80);
  848.         if (((int)hf) & 0xff)
  849.         {
  850.                 clearStatus();
  851.                 printf("browser/ng_hist.dat opening error.");
  852.                 exit(0);
  853.         }
  854.         OS_SEEKHANDLE(hf, filePos);
  855.         memcpy(&heap, &link, structSize);
  856.         OS_WRITEHANDLE(heap, hf, structSize);
  857.         OS_CLOSEHANDLE(hf);
  858. }
  859.  
  860. void popHistory(void)
  861. {
  862.         FILE *hf;
  863.         unsigned int structSize, filePos;
  864.         navi.history--;
  865.         structSize = sizeof(struct linkStruct);
  866.         filePos = structSize * (navi.history - 1);
  867.         OS_SETSYSDRV();
  868.         hf = OS_OPENHANDLE("browser/ng_hist.dat", 0x80);
  869.         if (((int)hf) & 0xff)
  870.         {
  871.                 clearStatus();
  872.                 printf("browser/ng_hist.dat opening error.");
  873.                 exit(0);
  874.         }
  875.         OS_SEEKHANDLE(hf, filePos);
  876.         OS_READHANDLE(netbuf, hf, structSize);
  877.  
  878.         memcpy(&link, netbuf, structSize);
  879. }
  880.  
  881. void goHome(void)
  882. {
  883.         OS_SETSYSDRV();
  884.         if (loadPageFromDisk("browser/nedogoph.gph", 0))
  885.         {
  886.                 newPage();
  887.                 link.type = '1';
  888.                 strcpy(link.host, "HOMEPAGE");
  889.                 pusHistory();
  890.                 navi.nextBufPos = renderPage(navi.nextBufPos);
  891.         }
  892.         else
  893.         {
  894.                 newPage();
  895.                 clearNetbuf();
  896.                 OS_CLS(0);
  897.                 mainWinDraw();
  898.         }
  899. }
  900.  
  901. void errNoConnect(void)
  902. {
  903.  
  904.         if (strcmp(link.host, "HOMEPAGE") == 0)
  905.         {
  906.                 goHome();
  907.                 return;
  908.         }
  909.  
  910.         curWin.w = 50;
  911.         curWin.x = 80 / 2 - curWin.w / 2 - 1;
  912.         curWin.y = 10;
  913.         curWin.h = 1;
  914.         curWin.text = 215;
  915.         curWin.back = 215;
  916.         strcpy(curWin.tittle, "Ошибка открытия страницы");
  917.         strcpy(cmd, "Нет соединения с ");
  918.         strcat(cmd, link.host);
  919.         errorBox(curWin, cmd);
  920.         strcpy(link.host, link.prevHost);
  921.         waitKey();
  922.         /*
  923.                 if (strcmp(link.prevHost, "HOMEPAGE") == 0)
  924.                 {
  925.                         goHome();
  926.                         return;
  927.                 }
  928.         */
  929.         switch (link.type)
  930.         {
  931.         case '0':
  932.                 OS_SETSYSDRV();
  933.                 loadPageFromDisk("browser/current.txt", 0);
  934.                 navi.nextBufPos = renderPlain(pageOffsets[navi.page]);
  935.                 break;
  936.         case '1':
  937.                 OS_SETSYSDRV();
  938.                 loadPageFromDisk("browser/current.gph", 0);
  939.                 navi.nextBufPos = renderPage(pageOffsets[navi.page]);
  940.                 break;
  941.         default:
  942.                 OS_SETSYSDRV();
  943.                 loadPageFromDisk("browser/current.gph", 0);
  944.                 navi.nextBufPos = renderPage(pageOffsets[navi.page]);
  945.                 break;
  946.         }
  947. }
  948.  
  949. char getFileEsp(unsigned char *fileNamePtr)
  950. {
  951.         int todo;
  952.         unsigned char *count1;
  953.         unsigned char byte;
  954.         unsigned long downloaded = 0;
  955.         unsigned int count;
  956.         const unsigned char sendOk[] = "SEND OK";
  957.  
  958.         if ((strlen(link.path) == 1 && link.path[0] == '/') || strlen(link.path) == 0)
  959.         {
  960.                 strcpy(link.path, "\r\n");
  961.         }
  962.         else
  963.         {
  964.                 strcat(link.path, "\r\n");
  965.         }
  966.  
  967.         sprintf(cmd, "AT+CIPSTART=\"TCP\",\"%s\",%u", link.host, link.port);
  968.         sendcommand(cmd);
  969.         do
  970.         {
  971.                 getAnswer2(); // CONNECT or ERROR or link is not valid
  972.                 count1 = strstr(netbuf, "CONNECT");
  973.                 if (strstr(netbuf, "ERROR") != NULL)
  974.                 {
  975.                         return false;
  976.                 }
  977.         } while (count1 == NULL);
  978.  
  979.         getAnswer2(); // OK
  980.  
  981.         sprintf(cmd, "AT+CIPSEND=%u", strlen(link.path)); // second CRLF in send command
  982.         sendcommand(cmd);
  983.         getAnswer2();
  984.  
  985.         do
  986.         {
  987.                 byte = uart_readBlock();
  988.         } while (byte != '>');
  989.  
  990.         sendcommandNrn(link.path);
  991.  
  992.         count = 0;
  993.         do
  994.         {
  995.                 byte = uart_readBlock();
  996.                 if (byte == sendOk[count])
  997.                 {
  998.                         count++;
  999.                         // putchar(byte);
  1000.                 }
  1001.                 else
  1002.                 {
  1003.                         count = 0;
  1004.                 }
  1005.         } while (count < strlen(sendOk));
  1006.  
  1007.         uart_readBlock(); // CR
  1008.         uart_readBlock(); // LF
  1009.  
  1010.         OS_DELETE(fileNamePtr);
  1011.         saveBuf(fileNamePtr, 00, 0);
  1012.         clearStatus();
  1013.         do
  1014.         {
  1015.                 todo = recvHead();
  1016.                 getdataEsp(todo);
  1017.                 downloaded = downloaded + todo;
  1018.                 printf("%lu kb  \r", downloaded / 1024);
  1019.                 saveBuf(fileNamePtr, 01, todo);
  1020.         } while (todo != 0);
  1021.         //  getAnswer2(); // OK
  1022.         link.size = downloaded;
  1023.         clearStatus();
  1024.         if (downloaded == 0)
  1025.         {
  1026.                 return false;
  1027.         }
  1028.         return true;
  1029. }
  1030.  
  1031. char getFileNet(unsigned char *fileNamePtr)
  1032. {
  1033.         int todo;
  1034.         int socket;
  1035.         unsigned long downloaded = 0;
  1036.  
  1037.         if (!dnsResolve(link.host))
  1038.         {
  1039.                 clearStatus();
  1040.                 printf("Ошибка определения адреса '%s'", link.host);
  1041.                 return false;
  1042.         }
  1043.         targetadr.porth = 00;
  1044.         targetadr.portl = link.port;
  1045.  
  1046.         // clearStatus();
  1047.         // printf("File:%s", fileNamePtr);
  1048.         // printf("\r\nAddress:%u.%u.%u.%u:%u\r\n", targetadr.b1, targetadr.b2, targetadr.b3, targetadr.b4, targetadr.porth * 256 + targetadr.portl);
  1049.         // waitKey();
  1050.  
  1051.         if ((strlen(link.path) == 1 && link.path[0] == '/') || strlen(link.path) == 0)
  1052.         {
  1053.                 strcpy(link.path, crlf);
  1054.         }
  1055.         else
  1056.         {
  1057.                 strcat(link.path, crlf);
  1058.         }
  1059.         socket = OpenSock(AF_INET, SOCK_STREAM);
  1060.         if (socket < 0)
  1061.         {
  1062.                 return false;
  1063.         }
  1064.         todo = netConnect(socket, 1);
  1065.         if (socket < 0)
  1066.         {
  1067.                 return false;
  1068.         }
  1069.         todo = tcpSend(socket, (unsigned int)&link.path, strlen(link.path), 1);
  1070.         if (socket < 0)
  1071.         {
  1072.                 return false;
  1073.         }
  1074.         saveBuf(fileNamePtr, 00, 0);
  1075.         clearStatus();
  1076.         do
  1077.         {
  1078.                 todo = tcpRead(socket, 3);
  1079.                 if (todo < 1)
  1080.                 {
  1081.                         break;
  1082.                 }
  1083.  
  1084.                 downloaded = downloaded + todo;
  1085.                 printf("%lu kb   \r", downloaded / 1024);
  1086.                 saveBuf(fileNamePtr, 01, todo);
  1087.         } while (42);
  1088.         clearStatus();
  1089.         netShutDown(socket, 0);
  1090.         link.size = downloaded;
  1091.         if (downloaded == 0)
  1092.         {
  1093.                 clearStatus();
  1094.                 printf("Ошибка получения данных от '%s' (%u.%u.%u.%u:%u)", link.host, targetadr.b1, targetadr.b2, targetadr.b3, targetadr.b4, targetadr.porth * 256 + targetadr.portl);
  1095.                 return false;
  1096.         }
  1097.         return true;
  1098. }
  1099.  
  1100. char getFile(unsigned char *fileNamePtr)
  1101. {
  1102.         int result;
  1103.         switch (netDriver)
  1104.         {
  1105.         case 0:
  1106.                 result = getFileNet(fileNamePtr);
  1107.                 break;
  1108.         case 1:
  1109.                 do
  1110.                 {
  1111.                         result = getFileEsp(fileNamePtr);
  1112.                 } while (result == 0);
  1113.                 break;
  1114.  
  1115.         default:
  1116.                 break;
  1117.         }
  1118.         return result;
  1119. }
  1120.  
  1121. unsigned char selectorProcessor(void)
  1122. {
  1123.         unsigned int startSearch = 0, lineSearch = 0, SelectedPos, counter1 = 0;
  1124.         unsigned char byte;
  1125.  
  1126.         if (link.type == '0' || navi.lineSelect > navi.lastLine) // Если текущая страница текстовая, нечего по ней тыкать или тыкнули ниже низа.
  1127.         {
  1128.                 // clearStatus();
  1129.                 // printf("[%c]Cтраница текстовая или [%u>%u]тыкнули ниже низа.", link.type, navi.lineSelect, navi.lastLine);
  1130.                 return false;
  1131.         }
  1132.  
  1133.         startSearch = pageOffsets[navi.page];
  1134.  
  1135.         do
  1136.         {
  1137.                 byte = netbuf[startSearch + counter1];
  1138.  
  1139.                 if (byte == 0x0a)
  1140.                 {
  1141.                         lineSearch++;
  1142.                 }
  1143.                 counter1++;
  1144.  
  1145.         } while (lineSearch < navi.lineSelect - 1);
  1146.  
  1147.         if (counter1 == 1)
  1148.         {
  1149.                 counter1 = 0;
  1150.         }
  1151.         SelectedPos = startSearch + counter1;
  1152.  
  1153.         strcpy(link.prevHost, link.host);
  1154.         link.nexType = link.type;
  1155.         link.type = netbuf[SelectedPos];
  1156.  
  1157.         if (link.type == 'i' || link.type == '.' || link.type == 0)
  1158.         {
  1159.                 link.type = link.nexType;
  1160.                 return false;
  1161.         }
  1162.  
  1163.         counter1 = 1; // Пропускаем  заголовок селектора
  1164.         do
  1165.         {
  1166.                 byte = netbuf[SelectedPos + counter1];
  1167.                 counter1++;
  1168.         } while (byte != 9);
  1169.  
  1170.         SelectedPos = SelectedPos + counter1;
  1171.         counter1 = 0; // Извлекаем путь к селектору
  1172.  
  1173.         while (netbuf[SelectedPos + counter1] != 9)
  1174.         {
  1175.                 link.path[counter1] = netbuf[SelectedPos + counter1];
  1176.                 counter1++;
  1177.         }
  1178.         link.path[counter1] = 0;
  1179.  
  1180.         SelectedPos = SelectedPos + counter1 + 1;
  1181.         counter1 = 0; // Извлекаем хост селектора
  1182.         do
  1183.         {
  1184.                 link.host[counter1] = netbuf[SelectedPos + counter1];
  1185.                 counter1++;
  1186.         } while (netbuf[SelectedPos + counter1] != 9);
  1187.         link.host[counter1] = 0;
  1188.  
  1189.         SelectedPos = SelectedPos + counter1 + 1;
  1190.         link.port = atoi(netbuf + SelectedPos);
  1191.         return true;
  1192. }
  1193.  
  1194. char extractName(void)
  1195. {
  1196.         unsigned int counter, counter2 = 0, lng, byte, source;
  1197.         unsigned char ext2[128];
  1198.         unsigned char *count1;
  1199.  
  1200.         lng = strlen(link.path);
  1201.  
  1202.         for (counter = lng - 1; counter != 0; counter--)
  1203.         {
  1204.                 byte = link.path[counter];
  1205.                 if (byte == '/' || byte == ':')
  1206.                 {
  1207.                         break;
  1208.                 }
  1209.  
  1210.                 counter2++;
  1211.         }
  1212.         source = lng - counter2;
  1213.  
  1214.         for (counter = 0; counter < counter2; counter++)
  1215.         {
  1216.                 navi.fileName[counter] = link.path[source + counter];
  1217.         }
  1218.         navi.fileName[counter2] = 0;
  1219.  
  1220.         if (navi.saveAs)
  1221.         {
  1222.                 curWin.w = 61;
  1223.                 curWin.x = 80 / 2 - curWin.w / 2 - 1;
  1224.                 curWin.y = 10;
  1225.                 curWin.h = 1;
  1226.                 curWin.text = 103;
  1227.                 curWin.back = 103;
  1228.                 strcpy(curWin.tittle, "Введите имя файла");
  1229.  
  1230.                 // navi.fileName[64] = 0;
  1231.  
  1232.                 if (inputBox(curWin, navi.fileName))
  1233.                 {
  1234.                         strcpy(navi.fileName, cmd);
  1235.                 }
  1236.                 else
  1237.                 {
  1238.                         return false;
  1239.                 }
  1240.         }
  1241.         else // Play It
  1242.         {
  1243.                 count1 = strstr(navi.fileName, ".");
  1244.                 if (count1 == NULL)
  1245.                 {
  1246.                         clearStatus();
  1247.                         printf("Ошибка определения типа файла, не найдено расширение. [%s]", navi.fileName);
  1248.                         waitKey();
  1249.                         return false;
  1250.                 }
  1251.                 else
  1252.                 {
  1253.                         strcpy(ext2, count1 + 1);
  1254.                         strcpy(navi.fileName, "current.");
  1255.                         strcat(navi.fileName, ext2);
  1256.                 }
  1257.         }
  1258.         return true;
  1259. }
  1260.  
  1261. int pos(unsigned char *s, unsigned char *c, unsigned int n, unsigned int startPos)
  1262. {
  1263.         unsigned int i, j;
  1264.         unsigned int lenC, lenS;
  1265.  
  1266.         for (lenC = 0; c[lenC]; lenC++)
  1267.                 ;
  1268.         for (lenS = 0; s[lenS]; lenS++)
  1269.                 ;
  1270.  
  1271.         for (i = startPos; i <= lenS - lenC; i++)
  1272.         {
  1273.                 for (j = 0; s[i + j] == c[j]; j++)
  1274.                         ;
  1275.  
  1276.                 if (j - lenC == 1 && i == lenS - lenC && !(n - 1))
  1277.                         return i;
  1278.                 if (j == lenC)
  1279.                         if (n - 1)
  1280.                                 n--;
  1281.                         else
  1282.                                 return i;
  1283.         }
  1284.         return -1;
  1285. }
  1286.  
  1287. unsigned char mediaProcessorExt(void)
  1288. {
  1289.         // unsigned char ext[65];
  1290.         unsigned char extLow[4];
  1291.         unsigned char extUp[4];
  1292.         unsigned char byte;
  1293.         unsigned char *count1;
  1294.         unsigned int counter, counter2, next, curPosition;
  1295.         int n;
  1296.  
  1297.         count1 = strstr(navi.fileName, ".");
  1298.         if (count1 == NULL)
  1299.         {
  1300.                 clearStatus();
  1301.                 printf("Ошибка определения типа файла, не найдено расширение. [%s]", navi.fileName);
  1302.                 waitKey();
  1303.         }
  1304.  
  1305.         counter = strlen(navi.fileName);
  1306.         do
  1307.         {
  1308.                 counter--;
  1309.                 if (navi.fileName[counter] == '.')
  1310.                 {
  1311.  
  1312.                         for (counter2 = 0; counter2 < 3; counter2++)
  1313.                         {
  1314.                                 extLow[counter2] = tolower(navi.fileName[counter + counter2 + 1]);
  1315.                                 extUp[counter2] = toupper(navi.fileName[counter + counter2 + 1]);
  1316.                         }
  1317.                         extUp[3] = 0;
  1318.                         extLow[3] = 0;
  1319.                         // printf("[%s]\r\n[%s]\r\n", extLow, extUp);
  1320.                         break;
  1321.                 }
  1322.  
  1323.         } while (counter != 0);
  1324.  
  1325.         next = 1;
  1326.         curPosition = 0;
  1327.         do
  1328.         {
  1329.                 n = -1;
  1330.                 n = pos(nvext, extLow, next, curPosition);
  1331.                 curPosition = n;
  1332.                 if (n == -1)
  1333.                 {
  1334.                         curPosition = 0;
  1335.                         n = pos(nvext, extUp, next, curPosition);
  1336.                         curPosition = n;
  1337.                         if (n == -1)
  1338.                         {
  1339.                                 clearStatus();
  1340.                                 printf("[ext]не найдено соответствие к расширению [%s][%s]", extLow, extUp);
  1341.                                 waitKey();
  1342.                                 return false;
  1343.                         }
  1344.                 }
  1345.                 else
  1346.                 {
  1347.                         counter = 0;
  1348.                         do
  1349.                         {
  1350.                                 byte = nvext[n + counter];
  1351.                                 if (byte == 0x0d)
  1352.                                 {
  1353.                                         next++;
  1354.                                         break;
  1355.                                 }
  1356.  
  1357.                                 if (byte == ':')
  1358.                                 {
  1359.                                         counter++;
  1360.                                         counter2 = 0;
  1361.  
  1362.                                         while (nvext[n + counter] == ' ')
  1363.                                         {
  1364.                                                 counter++;
  1365.                                         }
  1366.  
  1367.                                         do
  1368.                                         {
  1369.                                                 byte = nvext[n + counter];
  1370.                                                 cmd[counter2] = byte;
  1371.                                                 counter++;
  1372.                                                 counter2++;
  1373.                                         } while (byte != 0x0d);
  1374.                                         cmd[counter2 - 1] = ' ';
  1375.                                         cmd[counter2] = 0;
  1376.                                         strcat(cmd, " ");
  1377.                                         strcat(cmd, curPath);
  1378.                                         strcat(cmd, "/current.");
  1379.                                         strcat(cmd, extLow);
  1380.                                         return true;
  1381.                                 }
  1382.                                 counter++;
  1383.                         } while (42);
  1384.                 }
  1385.         } while (42);
  1386.         return false;
  1387. }
  1388.  
  1389. void doLink(char backSpace)
  1390. {
  1391.         if (strcmp(link.host, "HOMEPAGE") == 0)
  1392.         {
  1393.                 goHome();
  1394.                 return;
  1395.         }
  1396.  
  1397.         switch (link.type) // Тут уже новый элемент
  1398.         {
  1399.         case 'i':
  1400.                 link.type = link.nexType; // так-как мы остались на странице, восстановим тип, хотя можно просто ставить 1 (пока других нет)
  1401.                 return;
  1402.         case '0': // plain texts
  1403.                 if (getFile("browser/current.txt"))
  1404.                 {
  1405.                         newPage();
  1406.                         OS_SETSYSDRV();
  1407.                         loadPageFromDisk("browser/current.txt", 0);
  1408.                         if (!backSpace)
  1409.                         {
  1410.                                 pusHistory();
  1411.                         }
  1412.                         navi.nextBufPos = renderPlain(navi.nextBufPos);
  1413.                 }
  1414.                 else
  1415.                 {
  1416.                         errNoConnect();
  1417.                         // goHome();
  1418.                 }
  1419.                 return;
  1420.         case '1': // gopher page
  1421.                 if (getFile("browser/current.gph"))
  1422.                 {
  1423.                         newPage();
  1424.                         OS_SETSYSDRV();
  1425.                         loadPageFromDisk("browser/current.gph", 0);
  1426.                         if (!backSpace)
  1427.                         {
  1428.                                 pusHistory();
  1429.                         }
  1430.                         navi.nextBufPos = renderPage(navi.nextBufPos);
  1431.                 }
  1432.                 else
  1433.                 {
  1434.  
  1435.                         errNoConnect();
  1436.                         // goHome();
  1437.                 }
  1438.                 return;
  1439.         case '7': // search input
  1440.                 curWin.w = 40;
  1441.                 curWin.x = 80 / 2 - curWin.w / 2 - 1;
  1442.                 curWin.y = 10;
  1443.                 curWin.h = 1;
  1444.                 curWin.text = 95;
  1445.                 curWin.back = 95;
  1446.                 strcpy(curWin.tittle, "Введите поисковый запрос");
  1447.                 if (inputBox(curWin, ""))
  1448.                 {
  1449.                         strcat(link.path, "\t");
  1450.                         strcat(link.path, cmd);
  1451.                         if (getFile("browser/current.gph"))
  1452.                         {
  1453.                                 newPage();
  1454.                                 OS_SETSYSDRV();
  1455.                                 loadPageFromDisk("browser/current.gph", 0);
  1456.                                 navi.nextBufPos = renderPage(navi.nextBufPos);
  1457.                                 link.type = '1';
  1458.                         }
  1459.                         else
  1460.                         {
  1461.                                 reDraw();
  1462.                                 errNoConnect();
  1463.                         }
  1464.                 }
  1465.                 else
  1466.                 {
  1467.                         link.type = '1';
  1468.                         reDraw();
  1469.                         return;
  1470.                 }
  1471.                 return;
  1472.         case 'g': // gif pic
  1473.         case 'I': // image
  1474.         case 's': // sound
  1475.         case '9': // binary (pt3/scr)
  1476.         case '8':
  1477.         case '6':
  1478.         case '5':
  1479.         case '4':
  1480.                 if (!extractName())
  1481.                 {
  1482.                         link.type = '1';
  1483.                         reDraw();
  1484.                         return;
  1485.                 }
  1486.                 OS_CHDIR("/");
  1487.                 OS_CHDIR("downloads");
  1488.                 OS_GETPATH((unsigned int)&curPath);
  1489.  
  1490.                 if (getFile(navi.fileName))
  1491.                 {
  1492.                         OS_SETSYSDRV();
  1493.                         loadPageFromDisk("browser/current.gph", 0);
  1494.                         navi.nextBufPos = renderPage(pageOffsets[navi.page]);
  1495.                         if (!navi.saveAs)
  1496.                         {
  1497.                                 if (mediaProcessorExt())
  1498.                                 {
  1499.                                         OS_CHDIR("/");
  1500.                                         OS_CHDIR("downloads");
  1501.                                         clearStatus();
  1502.                                         printf("cmd:[%s]", cmd);
  1503.                                         OS_SHELL(cmd);
  1504.                                         OS_SETSYSDRV();
  1505.                                 }
  1506.                         }
  1507.                 }
  1508.                 else
  1509.                 {
  1510.                         errNoConnect();
  1511.                 }
  1512.                 return;
  1513.         default:
  1514.                 clearStatus();
  1515.                 printf("Неизвестный селектор:[%u]lineselect[%u]linelast[%u]", link.type, navi.lineSelect, navi.lastLine);
  1516.                 link.type = link.nexType;
  1517.                 return;
  1518.         }
  1519. }
  1520.  
  1521. void activate(void)
  1522. {
  1523.         if (!selectorProcessor())
  1524.         {
  1525.                 return;
  1526.         }
  1527.         doLink(false);
  1528. }
  1529.  
  1530. void enterDomain(void)
  1531. {
  1532.         curWin.w = 40;
  1533.         curWin.x = 80 / 2 - curWin.w / 2 - 1;
  1534.         curWin.y = 10;
  1535.         curWin.h = 1;
  1536.         curWin.text = 207;
  1537.         curWin.back = 207;
  1538.         strcpy(curWin.tittle, "Введите адрес Gopher сервера");
  1539.  
  1540.         if (inputBox(curWin, ""))
  1541.         {
  1542.                 strcpy(link.prevHost, link.host);
  1543.                 link.type = '1';
  1544.                 strcpy(link.host, cmd);
  1545.                 strcpy(link.path, "/");
  1546.                 link.port = 70;
  1547.                 doLink(false);
  1548.         }
  1549.         else
  1550.         {
  1551.                 reDraw();
  1552.         }
  1553. }
  1554.  
  1555. void navigationPage(char keypress)
  1556. {
  1557.         unsigned char counter;
  1558.  
  1559.         switch (keypress)
  1560.         {
  1561.         case 250: // Up
  1562.                 navi.prevLineSelect = navi.lineSelect;
  1563.                 navi.lineSelect--;
  1564.  
  1565.                 if (navi.lineSelect < 1 && navi.page == 0)
  1566.                 {
  1567.                         navi.lineSelect = screenHeight;
  1568.                         break;
  1569.                 }
  1570.  
  1571.                 if (navi.page != 0 && navi.lineSelect == 0)
  1572.                 {
  1573.                         navi.page--;
  1574.                         navi.nextBufPos = pageOffsets[navi.page];
  1575.                         navi.nextBufPos = renderPage(navi.nextBufPos);
  1576.                         navi.lineSelect = screenHeight;
  1577.                 }
  1578.                 break;
  1579.         case 249: // down
  1580.                 navi.prevLineSelect = navi.lineSelect;
  1581.                 navi.lineSelect++;
  1582.                 if (navi.lineSelect > screenHeight && navi.page == navi.maxPage)
  1583.                 {
  1584.                         navi.lineSelect = 1;
  1585.                         break;
  1586.                 }
  1587.                 if (navi.page != navi.maxPage && navi.lineSelect > screenHeight)
  1588.                 {
  1589.                         navi.page++;
  1590.                         pageOffsets[navi.page] = navi.nextBufPos;
  1591.                         navi.nextBufPos = renderPage(navi.nextBufPos);
  1592.                         navi.lineSelect = 1;
  1593.                 }
  1594.                 break;
  1595.         case 248: // Left
  1596.                 if (navi.page == 0)
  1597.                 {
  1598.                         break;
  1599.                 }
  1600.                 navi.page--;
  1601.                 navi.nextBufPos = pageOffsets[navi.page];
  1602.                 navi.nextBufPos = renderPage(navi.nextBufPos);
  1603.                 navi.lineSelect = screenHeight;
  1604.                 break;
  1605.         case 251: // Right
  1606.                 if (navi.page == navi.maxPage)
  1607.                 {
  1608.                         break;
  1609.                 }
  1610.                 navi.page++;
  1611.                 pageOffsets[navi.page] = navi.nextBufPos;
  1612.  
  1613.                 navi.nextBufPos = renderPage(navi.nextBufPos);
  1614.                 navi.lineSelect = 1;
  1615.                 break;
  1616.         case 0x0d:
  1617.                 activate();
  1618.                 break;
  1619.         case 0x08: // BS
  1620.                 if (navi.history > 1)
  1621.                 {
  1622.                         popHistory();
  1623.                         doLink(true);
  1624.                 }
  1625.                 break;
  1626.         case 31: // screen redraw
  1627.                 renderPage(pageOffsets[navi.page]);
  1628.                 break;
  1629.         case 'h':
  1630.         case 'H':
  1631.                 goHome();
  1632.                 break;
  1633.         case 'd':
  1634.         case 'D':
  1635.                 enterDomain();
  1636.                 break;
  1637.         case 's':
  1638.         case 'S':
  1639.                 navi.saveAs = !navi.saveAs;
  1640.                 mainWinDraw();
  1641.                 break;
  1642.         case 'i':
  1643.         case 'I':
  1644.                 netDriver = !netDriver;
  1645.                 mainWinDraw();
  1646.                 if (netDriver)
  1647.                 {
  1648.                         uart_init(divider);
  1649.                         espReBoot();
  1650.                 }
  1651.                 break;
  1652.         case 'm':
  1653.         case 'M':
  1654.                 mouse.classic = !mouse.classic;
  1655.                 break;
  1656.         }
  1657.  
  1658.         if (link.type == '1')
  1659.         {
  1660.                 for (counter = 1; counter < 79; counter++)
  1661.                 {
  1662.                         OS_SETXY(counter, navi.prevLineSelect);
  1663.                         OS_PRATTR(7);
  1664.                 }
  1665.  
  1666.                 if (mouse.cursYpos == navi.prevLineSelect)
  1667.                 {
  1668.                         OS_SETXY(mouse.cursXpos, mouse.cursYpos);
  1669.                         mouse.oldAtr = OS_GETATTR();
  1670.                 }
  1671.                 for (counter = 1; counter < 79; counter++)
  1672.                 {
  1673.                         OS_SETXY(counter, navi.lineSelect);
  1674.                         OS_PRATTR(15);
  1675.                 }
  1676.         }
  1677. }
  1678.  
  1679. void navigationPlain(char keypress)
  1680. {
  1681.         switch (keypress)
  1682.         {
  1683.         case 248: // Left
  1684.         case 250: // Up
  1685.  
  1686.                 if (navi.page == 0)
  1687.                 {
  1688.                         if (navi.volume == 0)
  1689.                         {
  1690.                                 break;
  1691.                         }
  1692.                         navi.volume--;
  1693.                         newPage();
  1694.                         OS_SETSYSDRV();
  1695.                         loadPageFromDisk("browser/current.txt", navi.volume);
  1696.                         navi.nextBufPos = renderPlain(navi.nextBufPos);
  1697.                         break;
  1698.                 }
  1699.                 navi.page--;
  1700.                 navi.nextBufPos = pageOffsets[navi.page];
  1701.                 navi.lineSelect = screenHeight;
  1702.                 navi.nextBufPos = renderPlain(navi.nextBufPos);
  1703.                 break;
  1704.         case 251: // Right
  1705.         case 249: // down
  1706.                 if (navi.page == navi.maxPage)
  1707.                 {
  1708.                         if (navi.volume == navi.maxVolume)
  1709.                         {
  1710.                                 break;
  1711.                         }
  1712.                         navi.volume++;
  1713.                         newPage();
  1714.                         OS_SETSYSDRV();
  1715.                         loadPageFromDisk("browser/current.txt", navi.volume);
  1716.                         navi.nextBufPos = renderPlain(navi.nextBufPos);
  1717.                         break;
  1718.                 }
  1719.                 navi.page++;
  1720.                 pageOffsets[navi.page] = navi.nextBufPos;
  1721.                 navi.lineSelect = 1;
  1722.                 navi.nextBufPos = renderPlain(navi.nextBufPos);
  1723.                 break;
  1724.         case 0x08: // BS
  1725.                 if (navi.history > 1)
  1726.                 {
  1727.                         popHistory();
  1728.                         doLink(true);
  1729.                 }
  1730.                 break;
  1731.         case 31: // screen redraw
  1732.                 renderPlain(pageOffsets[navi.page]);
  1733.                 break;
  1734.         case 'h':
  1735.         case 'H':
  1736.                 goHome();
  1737.                 break;
  1738.         case 'd':
  1739.         case 'D':
  1740.                 enterDomain();
  1741.                 break;
  1742.         case 's':
  1743.         case 'S':
  1744.                 navi.saveAs = !navi.saveAs;
  1745.                 mainWinDraw();
  1746.                 break;
  1747.         case 'i':
  1748.         case 'I':
  1749.                 netDriver = !netDriver;
  1750.                 mainWinDraw();
  1751.                 if (netDriver)
  1752.                 {
  1753.                         uart_init(divider);
  1754.                         espReBoot();
  1755.                 }
  1756.                 break;
  1757.         case 'm':
  1758.         case 'M':
  1759.                 mouse.classic = !mouse.classic;
  1760.                 break;
  1761.         }
  1762.  
  1763.         if (mouse.cursYpos == navi.prevLineSelect)
  1764.         {
  1765.                 OS_SETXY(mouse.cursXpos, mouse.cursYpos);
  1766.                 mouse.oldAtr = OS_GETATTR();
  1767.         }
  1768. }
  1769.  
  1770. void navigation(unsigned char keypress)
  1771. {
  1772.  
  1773.         switch (link.type)
  1774.         {
  1775.         case '0':
  1776.                 navigationPlain(keypress);
  1777.                 break;
  1778.         case '1':
  1779.                 navigationPage(keypress);
  1780.                 break;
  1781.         default:
  1782.                 clearStatus();
  1783.                 printf("Unknown link.type, [%d]", link.type);
  1784.                 waitKey();
  1785.                 break;
  1786.         }
  1787. }
  1788.  
  1789. unsigned char getMouse(void)
  1790. {
  1791.         unsigned long mouseRaw;
  1792.         unsigned int mouseMove;
  1793.         unsigned int mouseButtons;
  1794.         int mouseScroll = 0;
  1795.         int mouseXpos;
  1796.         int mouseYpos;
  1797.         int dx, dy;
  1798.         mouseRaw = OS_GETMOUSE();
  1799.  
  1800.         mouseMove = mouseRaw >> 16;
  1801.         mouseButtons = mouseRaw;
  1802.  
  1803.         if (mouseMove != mouse.prevMouseMove)
  1804.         {
  1805.                 OS_SETXY(mouse.cursXpos, mouse.cursYpos);
  1806.                 OS_PRATTR(mouse.oldAtr);
  1807.                 mouse.prevMouseMove = mouseMove;
  1808.  
  1809.                 mouse.prevMouseXpos = mouse.mouseXpos;
  1810.                 mouse.prevMouseYpos = mouse.mouseYpos;
  1811.  
  1812.                 mouse.mouseXpos = mouseRaw >> 16;
  1813.                 mouse.mouseYpos = mouseRaw >> 24;
  1814.  
  1815.                 if (mouse.classic)
  1816.                 {
  1817.                         mouse.cursXpos = mouse.mouseXpos / 3;
  1818.                         mouse.cursYpos = 25 - mouse.mouseYpos / 10;
  1819.                 }
  1820.                 else
  1821.                 {
  1822.                         mouseXpos = mouse.mouseXpos - mouse.prevMouseXpos;
  1823.                         mouseYpos = mouse.mouseYpos - mouse.prevMouseYpos;
  1824.  
  1825.                         dx = abs(mouseXpos / 2);
  1826.                         dy = abs(mouseYpos / 2);
  1827.  
  1828.                         if (dx == 0)
  1829.                                 dx = 1;
  1830.                         if (dy == 0)
  1831.                                 dy = 1;
  1832.                         if (dx > 3)
  1833.                                 dx = 3;
  1834.                         if (dy > 2)
  1835.                                 dy = 2;
  1836.  
  1837.                         if (mouseXpos < -250)
  1838.                         {
  1839.                                 mouseXpos = 1;
  1840.                         }
  1841.                         else if (mouseXpos > 250)
  1842.                         {
  1843.                                 mouseXpos = -1;
  1844.                         }
  1845.  
  1846.                         if (mouseYpos < -254)
  1847.                         {
  1848.                                 mouseYpos = 1;
  1849.                         }
  1850.                         else if (mouseYpos > 254)
  1851.                         {
  1852.                                 mouseYpos = -1;
  1853.                         }
  1854.  
  1855.                         if (mouseXpos < 0)
  1856.                         {
  1857.                                 mouse.cursXpos = mouse.cursXpos - dx;
  1858.                         }
  1859.                         else if (mouseXpos > 0)
  1860.                         {
  1861.                                 mouse.cursXpos = mouse.cursXpos + dx;
  1862.                         }
  1863.  
  1864.                         if (mouse.divider == 0)
  1865.                         {
  1866.                                 if (mouseYpos > 0)
  1867.                                 {
  1868.                                         mouse.cursYpos = mouse.cursYpos - dy;
  1869.                                 }
  1870.                                 else if (mouseYpos < 0)
  1871.                                 {
  1872.                                         mouse.cursYpos = mouse.cursYpos + dy;
  1873.                                 }
  1874.                                 mouse.divider = 2;
  1875.                         }
  1876.                         mouse.divider--;
  1877.                         // clearStatus();
  1878.                         // printf("dx=%d dy=%d X=%d Y=%d", dx, dy, mouse.mouseXpos, mouse.mouseYpos);
  1879.  
  1880.                         if (mouse.cursXpos > 79)
  1881.                         {
  1882.                                 mouse.cursXpos = 79;
  1883.                         }
  1884.                         if (mouse.cursYpos > 24)
  1885.                         {
  1886.                                 mouse.cursYpos = 24;
  1887.                         }
  1888.  
  1889.                         if (mouse.cursXpos < 0)
  1890.                         {
  1891.                                 mouse.cursXpos = 0;
  1892.                         }
  1893.                         if (mouse.cursYpos < 0)
  1894.                         {
  1895.                                 mouse.cursYpos = 0;
  1896.                         }
  1897.                 }
  1898.                 OS_SETXY(mouse.cursXpos, mouse.cursYpos);
  1899.                 mouse.oldAtr = OS_GETATTR();
  1900.                 OS_PRATTR(215);
  1901.         }
  1902.  
  1903.         if (mouseButtons != mouse.prevMouseButtons)
  1904.         {
  1905.  
  1906.                 mouse.prevWheel = mouse.wheel;
  1907.                 mouse.wheel = (mouseButtons >> 4) & 15;
  1908.                 mouse.mmb = (mouseButtons >> 2) & 1;
  1909.                 mouse.rmb = (mouseButtons >> 1) & 1;
  1910.                 mouse.lmb = mouseButtons & 1;
  1911.         }
  1912.  
  1913.         // clearStatus();
  1914.         // printf("lmb:[%d] rmb:[%d] mmb:[%d] wheel:[%02d] X:[%03d] Y:[%03d] cursX:[%02d] cursY:[%02d]", mouse.lmb, mouse.rmb, mouse.mmb, mouse.wheel, mouse.mouseXpos, mouse.mouseYpos, mouse.cursXpos, mouse.cursYpos);
  1915.  
  1916.         OS_SETXY(mouse.cursXpos, mouse.cursYpos);
  1917.  
  1918.         mouseScroll = mouse.wheel - mouse.prevWheel;
  1919.  
  1920.         if (mouseScroll < -12)
  1921.         {
  1922.                 mouseScroll = 1;
  1923.         }
  1924.         else if (mouseScroll > 12)
  1925.         {
  1926.                 mouseScroll = -1;
  1927.         }
  1928.  
  1929.         if (mouseScroll < 0)
  1930.         {
  1931.                 navigation(248); // Left
  1932.         }
  1933.         else if (mouseScroll > 0)
  1934.         {
  1935.                 navigation(251); // Right
  1936.         }
  1937.         mouse.prevWheel = mouse.wheel;
  1938.  
  1939.         return mouseButtons >> 8;
  1940. }
  1941.  
  1942. C_task main(int argc, char *argv[])
  1943. {
  1944.         unsigned char keypress;
  1945.         unsigned int start, finish = 0;
  1946.         OS_HIDEFROMPARENT();
  1947.         OS_SETGFX(0x86);
  1948.         OS_CLS(0);
  1949.         OS_SETSYSDRV();
  1950.         init();
  1951.         // printTable();
  1952.         // waitKey();
  1953.  
  1954.         goHome();
  1955.  
  1956.         start = 0;
  1957.         do
  1958.         {
  1959.                 keypress = getMouse();
  1960.                 if (mouse.lmb == 0)
  1961.                 {
  1962.                         if (mouse.cursYpos > 0 && mouse.cursYpos < screenHeight + 1)
  1963.                         {
  1964.                                 navi.prevLineSelect = navi.lineSelect;
  1965.                                 navi.lineSelect = mouse.cursYpos;
  1966.                                 activate();
  1967.                                 OS_SETXY(mouse.cursXpos, mouse.cursYpos);
  1968.                                 OS_PRATTR(215);
  1969.                         }
  1970.                         else
  1971.                         {
  1972.                                 if (mouse.cursYpos == 0)
  1973.                                 {
  1974.                                         enterDomain();
  1975.                                 }
  1976.                         }
  1977.                 }
  1978.                 else if (mouse.rmb == 0)
  1979.                 {
  1980.                         popHistory();
  1981.                         doLink(true);
  1982.                 }
  1983.  
  1984.                 if (keypress != 0)
  1985.                 {
  1986.                         navigation(keypress);
  1987.  
  1988.                         //      printf("keypress [%d]", keypress);
  1989.                 }
  1990.  
  1991.                 finish++;
  1992.                 if ((finish - start) > 10000)
  1993.                 {
  1994.                         // mainWinDraw();
  1995.                         OS_SETCOLOR(207);
  1996.                         drawClock();
  1997.                         finish = 0;
  1998.                 }
  1999.                 YIELD();
  2000.         } while (keypress != 27);
  2001.         OS_DELETE("browser/current.gph");
  2002.         OS_DELETE("browser/current.txt");
  2003.         OS_DELETE("browser/ng_hist.dat");
  2004. }
  2005.