Subversion Repositories NedoOS

Rev

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