Subversion Repositories NedoOS

Rev

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

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