Subversion Repositories NedoOS

Rev

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