home *** CD-ROM | disk | FTP | other *** search
/ Dream 55 / Amiga_Dream_55.iso / RISCOS / APPS / SCI / ELECTRON / AUTOPC.ZIP / !AutoPCB / Source / c / Draw < prev    next >
Text File  |  1991-04-05  |  5KB  |  290 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #include "win.h"
  6. #include "wimp.h"
  7. #include "wimpt.h"
  8. #include "res.h"
  9. #include "resspr.h"
  10. #include "template.h"
  11. #include "event.h"
  12. #include "menu.h"
  13. #include "baricon.h"
  14. #include "flex.h"
  15. #include "heap.h"
  16. #include "werr.h"
  17.  
  18. #include "drawfdiag.h"
  19. #include "drawftypes.h"
  20.  
  21. #include "draw.h"
  22.  
  23. #define MAIN_WINDOW     0
  24.  
  25. #define ICON_MENU       0
  26.  
  27. #define MIL            (180*256/1000)
  28.  
  29. #define TRANSPARENT     0xffffffff
  30. #define BLUE            0xff000000
  31. #define GREEN           0x00ff0000
  32. #define RED             0x0000ff00
  33.  
  34. int *diag, diagp;
  35. static wimp_w main_window;
  36. static int diagm;
  37. static double scale;
  38. static draw_diag diagram;
  39.  
  40. static void draw_report_error(draw_error *error);
  41.  
  42. static wimp_w create_window(char *name)
  43. {
  44.   wimp_wind *window;
  45.   wimp_w handle;
  46.  
  47.   handle = 0;
  48.  
  49.   window = template_syshandle(name);
  50.   if (window)
  51.     wimpt_complain(wimp_create_wind(window, &handle));
  52.   return handle;
  53. }
  54.  
  55. static void open_window(wimp_w handle)
  56. {
  57.   wimp_wstate state;
  58.  
  59.   if (wimpt_complain(wimp_get_wind_state(handle, &state)) == 0)
  60.   {
  61.     state.o.behind = -1;
  62.     wimpt_noerr(wimp_open_wind(&state.o));
  63.   }
  64. }
  65.  
  66. static void redraw_window(wimp_w handle)
  67. {
  68.   BOOL flag;
  69.   wimp_redrawstr r;
  70.   draw_error error;
  71.  
  72.   r.w = handle;
  73.   wimpt_noerr(wimp_redraw_wind(&r, &flag));
  74.   while(flag)
  75.   {
  76.     if (!draw_render_diag(&diagram,
  77.                      (draw_redrawstr *)&r,
  78.                       scale,
  79.                      &error))
  80.       draw_report_error(&error);
  81.     wimpt_noerr(wimp_get_rectangle(&r, &flag));
  82.   }
  83. }
  84.  
  85. static void window_event(wimp_eventstr *e, void *handle)
  86. {
  87.   int id;
  88.  
  89.   id = (int)handle;
  90.   switch(e->e)
  91.   {
  92.     case wimp_EREDRAW:
  93.       redraw_window(e->data.o.w);
  94.       break;
  95.  
  96.     case wimp_EOPEN:
  97.       wimpt_noerr(wimp_open_wind(&e->data.o));
  98.       break;
  99.  
  100.     case wimp_ECLOSE:
  101.       wimpt_noerr(wimp_close_wind(e->data.o.w));
  102.       break;
  103.  
  104.     default:
  105.       break;
  106.   }
  107. }
  108.  
  109. static void draw_report_error(draw_error *error)
  110. {
  111.   switch(error->type)
  112.   {
  113.     case DrawOSError:
  114.       werr(0, "OS error: %s (%d)", error->err.os.errmess, error->err.os.errnum);
  115.       break;
  116.  
  117.     case DrawOwnError:
  118.       werr(0, "Draw error: %ld at location %lx",
  119.                error->err.draw.code,
  120.                error->err.draw.location);
  121.       break;
  122.  
  123.     case None:
  124.       werr(0, "Unknown error");
  125.       break;
  126.   }
  127. }
  128.  
  129. void draw_file_header(char *app)
  130. {
  131.   struct
  132.   {
  133.     char name[4];
  134.     int major, minor;
  135.     char title[12];
  136.     int x0, y0, x1, y1;
  137.   } header;
  138.  
  139.   diagp = 0;
  140.  
  141.   memcpy(header.name, "Draw", 4);
  142.   header.major = 201;
  143.   header.minor = 0;
  144.   memcpy(header.title, app, 12);
  145.   header.x0 = 0;
  146.   header.y0 = 0;
  147.   header.x1 = 8000 * MIL;
  148.   header.y1 = 11000 * MIL;
  149.  
  150.   memcpy(&diag[diagp], &header, sizeof(header));
  151.   diagp += (sizeof(header) / sizeof(int));
  152. }
  153.  
  154. void draw_object_header(int type, int x1, int y1)
  155. {
  156.   struct
  157.   {
  158.     int type;
  159.     int size;
  160.     int x0, y0, x1, y1;
  161.   } header;
  162.  
  163.   header.type = type;
  164.   header.size = 0;
  165.   header.x0 = 0;
  166.   header.y0 = 0;
  167.   header.x1 = x1 * MIL;
  168.   header.y1 = y1 * MIL;
  169.  
  170.   diagm = diagp;
  171.   memcpy(&diag[diagp], &header, sizeof(header));
  172.   diagp += (sizeof(header) / sizeof(int));
  173. }
  174.  
  175. void draw_path_header(int fill, int colour)
  176. {
  177.   struct
  178.   {
  179.     int fill, outline, width, style;
  180.   } header;
  181.  
  182.   header.fill = fill;
  183.   header.outline = colour;
  184.   header.width = 15 * MIL;
  185.   header.style = 1 << packshft_join |
  186.                  1 << packshft_endcap |
  187.                  1 << packshft_startcap;
  188.  
  189.   memcpy(&diag[diagp], &header, sizeof(header));
  190.   diagp += (sizeof(header) / sizeof(int));
  191. }
  192.  
  193. void draw_path_move(int x, int y)
  194. {
  195.   struct
  196.   {
  197.     int tag;
  198.     int x, y;
  199.   } header;
  200.  
  201.   header.tag = 2;
  202.   header.x = x;
  203.   header.y = y;
  204.  
  205.   memcpy(&diag[diagp], &header, sizeof(header));
  206.   diagp += (sizeof(header) / sizeof(int));
  207. }
  208.  
  209. void draw_path_line(int x, int y)
  210. {
  211.   struct
  212.   {
  213.     int tag;
  214.     int x, y;
  215.   } header;
  216.  
  217.   header.tag = 8;
  218.   header.x = x;
  219.   header.y = y;
  220.  
  221.   memcpy(&diag[diagp], &header, sizeof(header));
  222.   diagp += (sizeof(header) / sizeof(int));
  223. }
  224.  
  225. void draw_path_circle(int x, int y, int r)
  226. {
  227.   int c;
  228.   struct
  229.   {
  230.     int tag;
  231.     int x0, y0;
  232.     int x1, y1;
  233.     int i, j;
  234.   } path1, path2;
  235.  
  236.   c = r * 14 / 10;
  237.   draw_path_move(x, y - r);
  238.  
  239.   path1.tag = 6;
  240.   path1.x0 = x - c;
  241.   path1.y0 =        y - r;
  242.   path1.x1 = x - c;
  243.   path1.y1 =        y + r;
  244.   path1.i =  x;
  245.   path1.j =         y + r;
  246.  
  247.   path2.tag = 6;
  248.   path2.x0 = x + c;
  249.   path2.y0 =        y + r;
  250.   path2.x1 = x + c;
  251.   path2.y1 =        y - r;
  252.   path2.i =  x;
  253.   path2.j =         y - r;
  254.  
  255.   memcpy(&diag[diagp], &path1, sizeof(path1));
  256.   diagp += (sizeof(path1) / sizeof(int));
  257.  
  258.   memcpy(&diag[diagp], &path2, sizeof(path2));
  259.   diagp += (sizeof(path2) / sizeof(int));
  260. }
  261.  
  262. void draw_path_end(void)
  263. {
  264.   diag[diagp++] = 0;
  265.   diag[diagm + 1] = (diagp - diagm) * 4;
  266. }
  267.  
  268. void draw_init(void)
  269. {
  270.   main_window = create_window("main");
  271.   win_register_event_handler(main_window, window_event, MAIN_WINDOW);
  272.  
  273.   diag = (int *)heap_alloc(50000);
  274. }
  275.  
  276. void draw_display(double setscale)
  277. {
  278.   draw_error error;
  279.  
  280.   scale = setscale;
  281.  
  282.   diagram.data = (char *)&diag[0];
  283.   diagram.length = (diagp) * 4;
  284.  
  285.   if (draw_verify_diag(&diagram, &error))
  286.     open_window(main_window);
  287.   else
  288.     draw_report_error(&error);
  289. }
  290.