home *** CD-ROM | disk | FTP | other *** search
/ Creative Computers / CreativeComputers.iso / shareware / text / dvi_3.62 / source / dvisrc.lha / dviapoll.c < prev    next >
C/C++ Source or Header  |  1993-10-26  |  8KB  |  283 lines
  1. /*
  2. ** Datei: dviapollo.c
  3. ** Autor: Ingo Eichenseher
  4. */      
  5.  
  6. #include <apollo/base.h>
  7. #include <apollo/gpr.h>
  8. #include <apollo/kbd.h>
  9. #include <apollo/tone.h>  
  10. #include <apollo/error.h>
  11.  
  12. #define SETSIZE (short)256      
  13.  
  14. #include <ctype.h>       
  15. #include <stdio.h>
  16. #include <stdarg.h>
  17. #include "dvi.h"    
  18. #include "dvihdcp.h"
  19. #include "dviframe.h"
  20.  
  21. #define XXSTEP 100
  22. #define YYSTEP 100
  23. #define XSTEP 8
  24. #define YSTEP 8
  25.  
  26.  
  27. static gpr_$bitmap_desc_t       memory_bitmap;
  28. static gpr_$offset_t            memory_size;
  29. static short int            memory_groups;
  30. static gpr_$attribute_desc_t        memory_attrib;
  31. static gpr_$bmf_group_header_array_t    memory_g_headers;
  32. static gpr_$color_vector_t      color_map;
  33. static status_$t            status;
  34.  
  35. void check(char *messagex)
  36. {
  37.     if (status.all)
  38.     {   
  39.     error_$print (status);
  40.     fprintf(stderr,"Error occurred while %s.\n", messagex);
  41.     }    
  42. }
  43.  
  44. static void create_array(void)
  45. {
  46.     gpr_$allocate_attribute_block(&memory_attrib,&status);
  47.     check("Allocating");
  48.     memory_size.x_size = frame_width*8;
  49.     memory_size.y_size = frame_height; 
  50.     memory_groups = 1;
  51.     memory_g_headers[0].pixel_size = 1;
  52.     memory_g_headers[0].n_sects = 1;
  53.     memory_g_headers[0].allocated_size = 0;
  54.     memory_g_headers[0].bytes_per_line = 0;
  55.     memory_g_headers[0].bytes_per_sect = 0;
  56.     memory_g_headers[0].storage_offset = (char *)frame_ptr(0);
  57.  
  58.     gpr_$make_bitmap_from_array(memory_size,memory_attrib,memory_groups,
  59.     memory_g_headers,&memory_bitmap,&status);     
  60.     check("Making bitmap");
  61. }
  62.  
  63. static void display_array(int x, int y)
  64. {
  65.     gpr_$window_t   src_window;
  66.     gpr_$position_t dst_offset;
  67.  
  68.     src_window.window_size.x_size = frame_width*8;
  69.     src_window.window_size.y_size = frame_height;
  70.     src_window.window_base.x_coord = x;
  71.     src_window.window_base.y_coord = y;
  72.     dst_offset.x_coord = 0;
  73.     dst_offset.y_coord = 0;                                  
  74.  
  75.     gpr_$pixel_blt(memory_bitmap,src_window,dst_offset,&status); 
  76.     check("BLTing");
  77. }                                                 
  78.  
  79. static int xoff = 0, yoff = 0, xsize, ysize;
  80.  
  81. static void check_position(void)
  82. {
  83.     gpr_$disp_char_t    display_characteristics;
  84.     long            pad_id = 1;
  85.     static short int    disp_len = sizeof(gpr_$disp_char_t);
  86.     short int       disp_len_returned;
  87.  
  88.     gpr_$inq_display_characteristics(gpr_$pad_id,pad_id,disp_len,
  89.     &display_characteristics,&disp_len_returned,&status); 
  90.     check("Inquiring");
  91.  
  92.     if (ysize-yoff < display_characteristics.y_window_size) 
  93.     yoff = ysize - display_characteristics.y_window_size;
  94.     if (xsize-xoff < display_characteristics.x_window_size) 
  95.     xoff = xsize - display_characteristics.x_window_size;
  96.     if (yoff<0) yoff = 0;
  97.     if (xoff<0) xoff = 0;   
  98. }
  99.  
  100. void refresh(boolean *unobscured, boolean *pos_change)
  101. {
  102.     check_position();
  103.     gpr_$acquire_display(&status);
  104.     display_array(xoff,yoff);
  105.     gpr_$release_display(&status);
  106. }         
  107.  
  108. void refresh_obscured(void)
  109. {         
  110.     static gpr_$window_t vis_list[50];    
  111.     short int slots_total, i;
  112.  
  113.     check_position();
  114.     gpr_$acquire_display(&status);      
  115.     check("Acquiring display");
  116.     gpr_$inq_vis_list(50,&slots_total,vis_list,&status);
  117.     check("Inquiring visible list");
  118.     for (i=0; i<slots_total; i++) 
  119.     {
  120.     gpr_$set_clip_window(vis_list[i],&status);
  121.     display_array(xoff,yoff);
  122.     }
  123.     gpr_$release_display(&status);
  124.     check("Releasing display");
  125. }
  126.  
  127. int screen(void)
  128. {     
  129.     gpr_$pixel_format_t pix_format;
  130.     gpr_$proj_format_t  proj_format;
  131.     gpr_$video_format_t video_format;
  132.     gpr_$bitmap_desc_t  display_bitmap;
  133.     gpr_$offset_t       display_bitmap_size;
  134.  
  135.     gpr_$event_t        my_events[2];
  136.     gpr_$keyset_t       key_set;
  137.  
  138.     gpr_$event_t        event_type;
  139.     unsigned char       event_data;
  140.  
  141.     gpr_$position_t     position;
  142.  
  143.     boolean         stop; 
  144.     boolean         end = false; 
  145.     boolean         quit = false;     
  146.     boolean         unob, pos_ch;
  147.  
  148.  
  149.     xoff = 0; 
  150.     yoff = 0;
  151.  
  152.     xsize = display_bitmap_size.x_size = frame_width*8; 
  153.     ysize = display_bitmap_size.y_size = frame_height;
  154.  
  155.     pix_format.pixel_mode = gpr_$pixel_pseudocolor;
  156.     pix_format.image_depth = 1;
  157.     pix_format.length = 2;
  158.  
  159.     proj_format.proj_mode = gpr_$proj_mode_argb;
  160.     proj_format.proj_buffer = 1;
  161.     proj_format.length = 2;
  162.  
  163.     video_format.length = 1;
  164.     video_format.video_buffer = 1;
  165.  
  166.     gpr_$initialize(gpr_$pad_id, 1, 0,
  167.     &display_bitmap_size,&pix_format,&proj_format,&video_format,
  168.     &display_bitmap, &status);    
  169.     check("Initializing");
  170.  
  171.     create_array(); 
  172.  
  173.     gpr_$set_refresh_entry(refresh,refresh_obscured,&status); 
  174.     check("Setting refresh entries");
  175.     gpr_$set_obscured_opt(gpr_$ok_if_obs,&status); 
  176.     check("Setting obscured options"); 
  177.  
  178.     while(!end)
  179.     {
  180.     refresh(&unob,&pos_ch);
  181.  
  182.     gpr_$set_cursor_active(true,&status);
  183.     my_events[0] = gpr_$locator_stop;
  184.     gpr_$enable_input(my_events[0],key_set,&status);
  185.     lib_$init_set(key_set,SETSIZE);
  186.     lib_$add_to_set(key_set,SETSIZE,'q');
  187.     lib_$add_to_set(key_set,SETSIZE,'n');
  188.     lib_$add_to_set(key_set,SETSIZE,'t');
  189.     lib_$add_to_set(key_set,SETSIZE,KBD_$DOWN_BOX_ARROW2);
  190.     lib_$add_to_set(key_set,SETSIZE,KBD_$R_BOX_ARROW);
  191.     lib_$add_to_set(key_set,SETSIZE,KBD_$L_BOX_ARROW);
  192.     lib_$add_to_set(key_set,SETSIZE,KBD_$UP_BOX_ARROW2);
  193.     lib_$add_to_set(key_set,SETSIZE,KBD_$L8S);
  194.     lib_$add_to_set(key_set,SETSIZE,KBD_$LAS);
  195.     lib_$add_to_set(key_set,SETSIZE,KBD_$LCS);
  196.     lib_$add_to_set(key_set,SETSIZE,KBD_$LES);
  197.     my_events[1] = gpr_$keystroke;
  198.     gpr_$enable_input(my_events[1],key_set,&status);
  199.  
  200.     stop = false;
  201.     while(!stop)
  202.     {
  203.         gpr_$event_wait(&event_type,&event_data,&position,&status);
  204.         switch(event_type)
  205.         {     
  206.         case gpr_$keystroke    : 
  207.             switch(event_data)
  208.             {             
  209.             case 'n' : stop = end = true; break;
  210.             case 'q' : stop = end = quit = true; break;
  211.             case 't' : xoff = yoff = 0; stop = true; break; 
  212.             case KBD_$L_BOX_ARROW : xoff -= XXSTEP; stop = true; break;
  213.             case KBD_$R_BOX_ARROW : xoff += XXSTEP; stop = true; break;
  214.             case KBD_$DOWN_BOX_ARROW2: yoff += YYSTEP; stop=true; break;
  215.             case KBD_$UP_BOX_ARROW2: yoff -= YYSTEP; stop=true; break;
  216.             case KBD_$L8S : yoff -= YSTEP; stop = true; break;
  217.             case KBD_$LES : yoff += YSTEP; stop = true; break;
  218.             case KBD_$LAS : xoff -= XSTEP; stop = true; break;
  219.             case KBD_$LCS : xoff += XSTEP; stop = true; break;
  220.             }
  221.             break;
  222.         default : break;
  223.         }
  224.     }        
  225.     }
  226.     gpr_$deallocate_attribute_block(memory_attrib,&status);    
  227.     check("Deallocating attribute block");
  228.     gpr_$deallocate_bitmap(memory_bitmap,&status);   
  229.     check("Deallocating bitmap");
  230.     gpr_$terminate(false,&status);
  231.     check("Terminating"); 
  232.     return quit;
  233. }
  234.  
  235.  
  236. /***********************************************************************
  237.  Compare strings (ignoring case), and return:
  238.     s1>s2:  >0
  239.     s1==s2:  0
  240.     s1<s2:  <0
  241. ***********************************************************************/
  242.  
  243. /* toupper() is supposed to work for all letters, but PCC-20 does it
  244. incorrectly if the argument is not already lowercase; this definition
  245. fixes that. */
  246.  
  247. #define UC(c) (islower(c) ? toupper(c) : c)
  248.  
  249. int stricmp(char *s1, char *s2)
  250. {
  251.     while ((*s1) && (UC(*s1) == UC(*s2)))
  252.     {
  253.     s1++;
  254.     s2++;
  255.     }
  256.     return((int)(UC(*s1) - UC(*s2)));
  257. }
  258. #undef UC
  259.  
  260. int stop_key(void)
  261. {
  262.     return 0;
  263. }
  264.  
  265. void install(void)
  266. {
  267. }
  268.  
  269. void destall(void)
  270. {
  271. }
  272.  
  273. int getch(void)
  274. {
  275.     fflush(stdout);
  276.     return getchar();
  277. }
  278.  
  279. void prbyte(int c)
  280. {
  281. }
  282.  
  283.