Subversion Repositories NedoOS

Rev

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