home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / internet / netlite2 / NET / c / WINDOW < prev   
Encoding:
Text File  |  1993-04-12  |  18.5 KB  |  566 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <stdarg.h>
  5. #include <time.h>
  6. #include "akbd.h"
  7. #include "bbc.h"
  8. #include "wimpt.h"
  9. #include "res.h"
  10. #include "colourmenu.h"
  11. #include "resspr.h"
  12. #include "template.h"
  13. #include "dbox.h"
  14. #include "event.h"
  15. #include "flex.h"
  16. #include "heap.h"
  17. #include "baricon.h"
  18. #include "menu.h"
  19. #include "saveas.h"
  20. #include "werr.h"
  21. #include "wimp.h"
  22. #include "win.h"
  23. #include "alarm.h"
  24. #include "global.h"
  25. #include "config.h"
  26. #include "cmdparse.h"
  27. #include "misc.h"
  28. #include "netuser.h"
  29. #include "timer.h"
  30. #include "telnet.h"
  31. #include "ftp.h"
  32. #include "tcp.h"
  33. #include "ip.h"
  34. #include "finger.h"
  35. #include "icmp.h"
  36. #include "session.h"
  37. #include "smtp.h"
  38. #include "domain.h"
  39. #include "window.h"
  40.  
  41. #define XtoWork(x)  ((x) << 1)
  42. #define YtoWork(y)  ((y) << 2)
  43.  
  44. #define Icon_Menu_Info   1
  45. #define Icon_Menu_Ping   2
  46. #define Icon_Menu_SMTP   3
  47. #define Icon_Menu_NNTP   4
  48. #define Icon_Menu_FINGER 5
  49. #define Icon_Menu_FTP    6
  50. #define Icon_Menu_TELNET 7
  51. #define Icon_Menu_Parms  8
  52. #define Icon_Menu_Quit   9
  53.  
  54. #define Parms_Menu_Domain 1
  55. #define Parms_Menu_IP     2
  56. #define Parms_Menu_TCP    3
  57.  
  58. #define SMTP_Menu_Kick   1
  59.  
  60. #define NNTP_Menu_Kick   1
  61.  
  62. #define Window_Menu_Info    1
  63. #define Window_Menu_Colours 2
  64. #define Window_Menu_Kick    3
  65. #define Window_Menu_Reset   4
  66. #define Window_Menu_Close   5
  67.  
  68. #define Window_Colours_NormalF  1
  69. #define Window_Colours_NormalB  2
  70. #define Window_Colours_ReverseF 3
  71. #define Window_Colours_ReverseB 4
  72. #define Window_Colours_BoldF    5
  73. #define Window_Colours_BoldB    6
  74. #define Window_Colours_UnderF   7
  75. #define Window_Colours_UnderB   8
  76. #define Window_Colours_BlinkF   9
  77. #define Window_Colours_BlinkB   10
  78.  
  79. static menu Icon_Menu;
  80. static menu SMTP_Menu;
  81. static menu NNTP_Menu;
  82. static menu Parms_Menu;
  83. static menu Window_Menu;
  84.  
  85. static int defaultf[NATTR] = {0, 7, 9, 10, 11};
  86. static int defaultb[NATTR] = {8, 0, 8, 8,  8};
  87.  
  88. static void Initialise(void);
  89. static void Icon_ClickProc(wimp_i);
  90. static void Icon_MenuProc(void *, char *);
  91. static void Alarm_Handler(int, void *);
  92. static void Window_Proc(wimp_eventstr *, void *);
  93. static void Window_MenuProc(void *, char *);
  94. static int  keyboard(struct Window_Struct *, int);
  95. static void Open_Window(struct Window_Struct *, wimp_openstr *);
  96. static void Redraw_Window(struct Window_Struct *, wimp_w);
  97. static void Redo_Window(struct Window_Struct *, wimp_redrawstr, BOOL);
  98.  
  99. int docolour(int argc, char **argv)
  100. {
  101.         if (argc < 3) return(0);
  102.  
  103.         if (strncmp("normalfore", argv[1], strlen(argv[1])) == 0)
  104.                defaultf[ATTR_NORMAL] = atoi(argv[2]);
  105.         if (strncmp("normalback", argv[1], strlen(argv[1])) == 0)
  106.                defaultb[ATTR_NORMAL] = atoi(argv[2]);
  107.         if (strncmp("reversefore", argv[1], strlen(argv[1])) == 0)
  108.                defaultf[ATTR_REVERSE] = atoi(argv[2]);
  109.         if (strncmp("reverseback", argv[1], strlen(argv[1])) == 0)
  110.                defaultb[ATTR_REVERSE] = atoi(argv[2]);
  111.         if (strncmp("boldfore", argv[1], strlen(argv[1])) == 0)
  112.                defaultf[ATTR_BOLD] = atoi(argv[2]);
  113.         if (strncmp("boldback", argv[1], strlen(argv[1])) == 0)
  114.                defaultb[ATTR_BOLD] = atoi(argv[2]);
  115.         if (strncmp("underfore", argv[1], strlen(argv[1])) == 0)
  116.                defaultf[ATTR_UNDER] = atoi(argv[2]);
  117.         if (strncmp("underback", argv[1], strlen(argv[1])) == 0)
  118.                defaultb[ATTR_UNDER] = atoi(argv[2]);
  119.         if (strncmp("blinkfore", argv[1], strlen(argv[1])) == 0)
  120.                defaultf[ATTR_BLINK] = atoi(argv[2]);
  121.         if (strncmp("blinkback", argv[1], strlen(argv[1])) == 0)
  122.                defaultb[ATTR_BLINK] = atoi(argv[2]);
  123.  
  124.         return(0);
  125. }
  126.  
  127. int main(int argc, char **argv)
  128. {
  129.         argc = argc;
  130.         argv = argv;
  131.  
  132.         Initialise();
  133.  
  134.         event_setmask(wimp_EMPTRENTER | wimp_EMPTRLEAVE);
  135.  
  136.         alarm_set(alarm_timenow() + 1, Alarm_Handler, 0);
  137.  
  138.         while (TRUE)
  139.                 event_process();
  140.  
  141.         return(0);
  142. }
  143.  
  144. static void Initialise(void)
  145. {
  146.         menu menu1;
  147.         menu menu2;
  148.  
  149.         wimpt_init("NETLITE");
  150.         res_init("NETLITE");
  151.         resspr_init();
  152.         template_init();
  153.         dbox_init();
  154.         alarm_init();
  155.         flex_init();
  156.         heap_init(FALSE);
  157.  
  158.         baricon("!netlite", (int)resspr_area(), Icon_ClickProc);
  159.  
  160.         Icon_Menu = menu_new("NETLITE", ">Info,>Ping,SMTP,NNTP,>Finger,>FTP,>TELNET,Parms,Quit");
  161.         SMTP_Menu   = menu_new("SMTP", "Kick");
  162.         NNTP_Menu   = menu_new("NNTP", "Kick");
  163.         Parms_Menu  = menu_new("Parms", ">Domain,>IP,>TCP");
  164.         Window_Menu = menu_new("Session", ">Info,Colours,Kick,Reset,Close");
  165.         menu1 = menu_new("Colours", "Normal fg,Normal bg,Reverse fg,Reverse bg,Bold fg,Bold bg,Under fg,Under bg,Blink fg, Blink bg");
  166.         menu2 = colourmenu_make("Colour", FALSE);
  167.  
  168.         menu_submenu(Icon_Menu, Icon_Menu_SMTP,  SMTP_Menu);
  169.         menu_submenu(Icon_Menu, Icon_Menu_NNTP,  NNTP_Menu);
  170.         menu_submenu(Icon_Menu, Icon_Menu_Parms, Parms_Menu);
  171.         menu_submenu(menu1, Window_Colours_NormalF,  menu2);
  172.         menu_submenu(menu1, Window_Colours_NormalB,  menu2);
  173.         menu_submenu(menu1, Window_Colours_ReverseF, menu2);
  174.         menu_submenu(menu1, Window_Colours_ReverseB, menu2);
  175.         menu_submenu(menu1, Window_Colours_BoldF,    menu2);
  176.         menu_submenu(menu1, Window_Colours_BoldB,    menu2);
  177.         menu_submenu(menu1, Window_Colours_UnderF,   menu2);
  178.         menu_submenu(menu1, Window_Colours_UnderB,   menu2);
  179.         menu_submenu(menu1, Window_Colours_BlinkF,   menu2);
  180.         menu_submenu(menu1, Window_Colours_BlinkB,   menu2);
  181.         menu_submenu(Window_Menu, Window_Menu_Colours, menu1);
  182.  
  183.         event_attachmenu(win_ICONBAR, Icon_Menu, Icon_MenuProc, 0);
  184.  
  185.         net_init();
  186. }
  187.  
  188. static void Icon_ClickProc(wimp_i Icon)
  189. {
  190.         Icon = Icon;
  191. }
  192.  
  193. static void Icon_MenuProc(void *Handle, char *Hit)
  194. {
  195.         dbox d;
  196.  
  197.         Handle = Handle;
  198.  
  199.         switch (Hit[0])
  200.         {
  201.                 case Icon_Menu_Info:
  202.                         if ((d = dbox_new("progInfo")) == NULL)
  203.                                 return;
  204.                         dbox_show(d);
  205.                         dbox_fillin(d);
  206.                         dbox_dispose(&d);
  207.                         break;
  208.                 case Icon_Menu_Ping:
  209.                         start_ping();
  210.                         break;
  211.                 case Icon_Menu_SMTP:
  212.                         switch (Hit[1])
  213.                         {
  214.                                 case SMTP_Menu_Kick:
  215.                                        smtptick();
  216.                                        break;
  217.                                 default:
  218.                                        break;
  219.                         }
  220.                         break;
  221.                 case Icon_Menu_FTP:
  222.                         start_ftp();
  223.                         break;
  224.                 case Icon_Menu_TELNET:
  225.                         start_telnet();
  226.                         break;
  227.                 case Icon_Menu_FINGER:
  228.                         start_finger();
  229.                         break;
  230.                 case Icon_Menu_Parms:
  231.                         switch (Hit[1])
  232.                         {
  233.                                 case Parms_Menu_Domain:
  234.                                          domain_parms();
  235.                                          break;
  236.                                 case Parms_Menu_IP:
  237.                                          ip_parms();
  238.                                          break;
  239.                                 case Parms_Menu_TCP:
  240.                                          tcp_parms();
  241.                                          break;
  242.                                 default:
  243.                                          break;
  244.                         }
  245.                         break;
  246.                 case Icon_Menu_Quit:
  247.                         iostop();
  248.                         exit(0);
  249.                 default:
  250.                         break;
  251.         }
  252. }
  253.  
  254. static void Alarm_Handler(int Time, void *Handle)
  255. {
  256.         Handle = Handle;
  257.         Time   = Time;
  258.  
  259.         net_poll();
  260.  
  261.         alarm_set(alarm_timenow() + 1, Alarm_Handler, 0);
  262. }
  263.  
  264. void *Window_Open(void *Sess, char *Description)
  265. {
  266.         struct Window_Struct *Window;
  267.         int Save_Area_Size;
  268.         sprite_ptr Pointer;
  269.         sprite_state sprite_state;
  270.         wimp_wstate window_state;
  271.         wimp_redrawstr r;
  272.         template *t;
  273.         int i;
  274.  
  275.         if ((Window = (struct Window_Struct *)heap_alloc(sizeof(struct Window_Struct))) == NULL)
  276.                 return(NULL);
  277.  
  278.         memset(Window, 0, sizeof(struct Window_Struct));
  279.  
  280.         if ((Window->Sprite.Area = (sprite_area *)heap_alloc(SPRITE_SIZE)) == NULL)
  281.         {
  282.                 heap_free(Window);
  283.                 return(NULL);
  284.         }
  285.  
  286.         sprite_area_initialise(Window->Sprite.Area, SPRITE_SIZE);
  287.  
  288.         sprite_create(Window->Sprite.Area, "screendump", sprite_nopalette, SPRITE_WIDTH, SPRITE_HEIGHT, SPRITE_MODE);
  289.  
  290.         Window->Sprite.id.tag    = sprite_id_name;
  291.         Window->Sprite.id.s.name = "screendump";
  292.  
  293.         sprite_select_rp(Window->Sprite.Area, &Window->Sprite.id, &Pointer);
  294.  
  295.         Window->Sprite.id.tag    = sprite_id_addr;
  296.         Window->Sprite.id.s.addr = Pointer;
  297.  
  298.         sprite_sizeof_spritecontext(Window->Sprite.Area, &Window->Sprite.id, &Save_Area_Size);
  299.  
  300.         if ((Window->Save_Area = (int *)heap_alloc(Save_Area_Size)) == NULL)
  301.         {
  302.                 heap_free(Window->Sprite.Area);
  303.                 heap_free(Window);
  304.                 return(NULL);
  305.         }
  306.  
  307.         t = template_copy(template_find("Window"));
  308.         wimp_create_wind(&t->window, &Window->Window_Handle);
  309.  
  310.         win_settitle(Window->Window_Handle, Description);
  311.  
  312.         win_register_event_handler(Window->Window_Handle, Window_Proc, (void *)Window);
  313.  
  314.         event_attachmenu(Window->Window_Handle, Window_Menu, Window_MenuProc, (void *)Window);
  315.  
  316.         Window->Save_Area[0] = 0;
  317.  
  318.         for (i = 0; i < NATTR; i++)
  319.         {
  320.                 Window->Foreground[i] = defaultf[i];
  321.                 Window->Background[i] = defaultb[i];
  322.         }
  323.  
  324.         sprite_outputtosprite(Window->Sprite.Area, &Window->Sprite.id, Window->Save_Area, &sprite_state);
  325.  
  326.         Window_Reset(Window);
  327.  
  328.         sprite_restorestate(sprite_state);
  329.  
  330.         Window->Session  = (struct session *)Sess;
  331.         Window->Session->keypad = 0;
  332.  
  333.         wimp_get_wind_state(Window->Window_Handle, &window_state);
  334.         window_state.o.behind = -1;
  335.         Open_Window(Window, &window_state.o);
  336.  
  337.         r.w      = Window->Window_Handle;
  338.         r.box.x0 =  0;
  339.         r.box.x1 =  XtoWork(SPRITE_WIDTH);
  340.         r.box.y0 = -YtoWork(SPRITE_HEIGHT);
  341.         r.box.y1 =  0;
  342.         wimp_force_redraw(&r);
  343.  
  344.         return((void *)Window);
  345. }
  346.  
  347. void Window_Close(void *w)
  348. {
  349.         struct Window_Struct *Window = (struct Window_Struct *)w;   
  350.  
  351.         wimp_close_wind(Window->Window_Handle);
  352.  
  353.         if (Window->Record != NULL) fclose(Window->Record);
  354.  
  355.         heap_free(Window->Sprite.Area);
  356.         heap_free(Window->Save_Area);
  357.         heap_free(Window);
  358. }
  359.  
  360. static void Window_MenuProc(void *Handle, char *Hit)
  361. {
  362.         struct Window_Struct *Window = (struct Window_Struct *)Handle;
  363.  
  364.         switch (Hit[0])
  365.         {
  366.                 case Window_Menu_Info:
  367.                         session_info(Window->Session);
  368.                         break;
  369.                 case Window_Menu_Colours:
  370.                         switch (Hit[1])
  371.                         {
  372.                               case Window_Colours_NormalF:
  373.                                      Window->Foreground[ATTR_NORMAL] = Hit[2] - 1;
  374.                                      break;
  375.                               case Window_Colours_NormalB:
  376.                                      Window->Background[ATTR_NORMAL] = Hit[2] - 1;
  377.                                      break;
  378.                               case Window_Colours_ReverseF:
  379.                                      Window->Foreground[ATTR_REVERSE] = Hit[2] - 1;
  380.                                      break;
  381.                               case Window_Colours_ReverseB:
  382.                                      Window->Background[ATTR_REVERSE] = Hit[2] - 1;
  383.                                      break;
  384.                               case Window_Colours_BoldF:
  385.                                      Window->Foreground[ATTR_BOLD] = Hit[2] - 1;
  386.                                      break;
  387.                               case Window_Colours_BoldB:
  388.                                      Window->Background[ATTR_BOLD] = Hit[2] - 1;
  389.                                      break;
  390.                               case Window_Colours_UnderF:
  391.                                      Window->Foreground[ATTR_UNDER] = Hit[2] - 1;
  392.                                      break;
  393.                               case Window_Colours_UnderB:
  394.                                      Window->Background[ATTR_UNDER] = Hit[2] - 1;
  395.                                      break;
  396.                               case Window_Colours_BlinkF:
  397.                                      Window->Foreground[ATTR_BLINK] = Hit[2] - 1;
  398.                                      break;
  399.                               case Window_Colours_BlinkB:
  400.                                      Window->Background[ATTR_BLINK] = Hit[2] - 1;
  401.                                      break;
  402.                               default:
  403.                                      break;
  404.                         }
  405.                         break;
  406.                 case Window_Menu_Kick:
  407.                         session_kick(Window->Session);
  408.                         break;
  409.                 case Window_Menu_Reset:
  410.                         session_reset(Window->Session);
  411.                         break;
  412.                 case Window_Menu_Close:
  413.                         session_close(Window->Session);
  414.                         break;
  415.                 default:
  416.                         break;
  417.         }
  418. }
  419.  
  420. static void Window_Proc(wimp_eventstr *Event, void *Handle)
  421. {
  422.         int  c;
  423.         wimp_caretstr wc;
  424.         struct Window_Struct *Window = (struct Window_Struct *)Handle;
  425.  
  426.         switch (Event->e)
  427.         {
  428.                 case wimp_EREDRAW:
  429.                         Redraw_Window(Window, Event->data.o.w);
  430.                         break;
  431.                 case wimp_EOPEN:
  432.                         Open_Window(Window, &Event->data.o);
  433.                         break;
  434.                 case wimp_ECLOSE:
  435.                         freesession(Window->Session);
  436.                         Window_Close(Window);
  437.                         break;
  438.                 case wimp_EBUT:
  439.                         wc.w      = Window->Window_Handle;
  440.                         wc.i      = -1;
  441.                         wc.height = -1;
  442.                         wc.x      = 0;
  443.                         wc.y      = 0;
  444.                         wc.index  = 0;
  445.                         wimp_set_caret_pos(&wc);                     
  446.                         break;
  447.                 case wimp_EKEY:
  448.                         c = Event->data.key.chcode;
  449.                         if (!keyboard(Window, c))
  450.                                 wimp_processkey(c);
  451.                         break;
  452.                 default:
  453.                         break;
  454.          }
  455. }
  456.  
  457. static int keyboard(struct Window_Struct *Window, int c)
  458. {
  459.         char Key_Buffer[10];
  460.         int  Key_Length;
  461.  
  462.         if (Window->Session->parse == NULLVFP) return(0);
  463.  
  464.         if ((Key_Length = keymap(Window->Session->raw, Window->Session->keypad, Key_Buffer, c)) == 0)
  465.                    return(0);
  466.  
  467.         if (Window->Session->echo)
  468.                   Window_Write(Window, Key_Buffer, Key_Length);      
  469.  
  470.         if (Window->Session->raw)
  471.         {
  472.                   (*Window->Session->parse)(Window->Session, Key_Buffer, Key_Length);
  473.         }
  474.         else
  475.         {
  476.                   switch (c)
  477.                   {
  478.                           case '\b':
  479.                                  if (Window->Session->bufptr > Window->Session->buffer)
  480.                                             Window->Session->bufptr--;
  481.                                  break;
  482.                           case '\r':
  483.                           case '\n':
  484.                                  if (!Window->Session->echo) Window_Write(Window, "\n", 1);
  485.                                  *Window->Session->bufptr++ = '\r';
  486.                                  *Window->Session->bufptr++ = '\n';
  487.                                  (*Window->Session->parse)(Window->Session, Window->Session->buffer, Window->Session->bufptr - Window->Session->buffer);
  488.                                  Window->Session->bufptr = Window->Session->buffer;
  489.                                  break;
  490.                           default:
  491.                                  *Window->Session->bufptr++ = c;
  492.                                  break;
  493.                   }
  494.         }
  495.  
  496.         return(1);
  497. }
  498.  
  499. static void Open_Window(struct Window_Struct *Window, wimp_openstr *o)
  500. {
  501.         o->x = 0;
  502.         o->y = 0;
  503.  
  504.         wimp_open_wind(o);
  505.  
  506.         if (Window->Old_X != (o->box.x1 - o->box.x0) ||
  507.             Window->Old_Y != (o->box.y1 - o->box.y0))
  508.         {
  509.                 Redraw_Window(Window, o->w);
  510.                 Window->Old_X = o->box.x1 - o->box.x0;
  511.                 Window->Old_Y = o->box.y1 - o->box.y0;
  512.         }
  513. }
  514.  
  515. static void Redraw_Window(struct Window_Struct *Window, wimp_w handle)
  516. {
  517.          BOOL more;
  518.          wimp_redrawstr r;
  519.          wimp_winfo     winfo;
  520.  
  521.          winfo.w = handle;
  522.          wimp_get_wind_info(&winfo);
  523.  
  524.          Window->X_Div_Mult = winfo.info.ex.x1 - winfo.info.ex.x0;
  525.          Window->Y_Div_Mult = winfo.info.ex.y1 - winfo.info.ex.y0;
  526.          Window->X_Mag_Mult = winfo.info.box.x1 - winfo.info.box.x0;
  527.          Window->Y_Mag_Mult = winfo.info.box.y1 - winfo.info.box.y0;
  528.  
  529.          r.w = handle;
  530.          wimp_redraw_wind(&r, &more);
  531.  
  532.          if (more) Redo_Window(Window, r, more);
  533. }
  534.                                         
  535. static void Redo_Window(struct Window_Struct *Window, wimp_redrawstr r, BOOL more)
  536. {
  537.          BOOL more_to_do      = more;
  538.          wimp_redrawstr new_r = r;
  539.          sprite_factors  factors;
  540.          sprite_pixtrans pixtrans[256];
  541.  
  542.          wimp_readpixtrans(Window->Sprite.Area, &Window->Sprite.id, &factors, pixtrans);
  543.  
  544.          factors.xdiv *= Window->X_Div_Mult;
  545.          factors.ydiv *= Window->Y_Div_Mult;
  546.          factors.xmag *= Window->X_Mag_Mult;
  547.          factors.ymag *= Window->Y_Mag_Mult;
  548.  
  549.          while (more_to_do)
  550.          {
  551.                   sprite_put_scaled(Window->Sprite.Area, &Window->Sprite.id, 0, r.box.x0, r.box.y0, &factors, pixtrans);
  552.  
  553.                   wimp_get_rectangle(&new_r, &more_to_do);
  554.          }
  555. }
  556.  
  557. void Update_Window(struct Window_Struct *Window, wimp_redrawstr r)
  558. {
  559.          wimp_redrawstr new_r = r;
  560.          BOOL more;
  561.  
  562.          wimp_update_wind(&new_r, &more);
  563.  
  564.          if (more) Redo_Window(Window, new_r, more);
  565. }
  566.