home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0682.ZIP / CCE_0682.PD / DSPSHELL / C_SOURCE / POWRTEXT.C < prev    next >
C/C++ Source or Header  |  1993-09-27  |  9KB  |  335 lines
  1. /****************************************************
  2.  * Textroutinen für PowerGEM                         *
  3.  * Erstellt von Mario Bahr  30.08. 1993                *
  4.  ****************************************************/
  5.  
  6. #include <aes.h>
  7. #include <string.h>
  8. #include <stdio.h>
  9. #include <vdi.h>
  10. #include <stdlib.h>
  11. #include "powergem.h"
  12. #include "powrtext.h"
  13.  
  14. #define  _CRLF 0x0A    /* Wagenrücklauf und Line Feed */
  15. #define _TAB 0x09    /* Tabulatoren   */
  16.  
  17. /*************************************************************
  18.  * Ließt einen ASCII - Text ein und wandelt ihn so um,         *
  19.  * das er mit show_asciitext() dargestellt werden kann.         *
  20.  * Durch seine Flexibilität (jedes Zeichen wird getestet)    *
  21.  * kann er z.B. als Filter für die unterschiedlichen Formate *
  22.  * in der Textverarbeitung erweitert werden(max.256 Spalten).*
  23.  * Wenn der Text wegen mangelnden Speicher nur unvollständig *
  24.  * Eingelesen werden konnte, ist text->end == NULL !         *
  25.  * Ansonsten wird hier KEINE Fehlermeldung ausgegeben         *
  26.  * Input: textname Name der Textdatei                         *
  27.  *              tab Tabulatorweite                             *
  28.  * Output: Zeiger auf TEXT-Struktur oder NULL bei Fehler     *
  29.  *************************************************************/
  30. TEXT *text_read(char *textname,int tab)
  31. {
  32. char buffer[257],tabulator[51]; /* Tabulator auf 50 beschränkt */
  33. struct ZEILE *first=NULL,*z_p=NULL;
  34. TEXT *text;
  35. FILE *t_file;
  36. int cbuf,break_flag=FALSE,i,buf_count=0;
  37.  
  38.  
  39. t_file=fopen(textname,"r");    /* Im Textmodus einlesen */
  40. if(t_file == NULL)
  41.     return NULL;
  42.  
  43. text=calloc(1,sizeof(TEXT));
  44. if(text == NULL)
  45.     return NULL;
  46.     
  47. if(tab >50)
  48.     tab=50;
  49. tabulator[0]=0x0;
  50. for(i=0;i<tab;i++)                /* Tabulator vorbereiten */
  51.     strcat(tabulator," ");    
  52.  
  53. buffer[0]=0x0;
  54. while((cbuf=getc(t_file )) !=  EOF && !break_flag)    
  55.     {
  56.     switch(cbuf)
  57.         {
  58.         case _CRLF:             /* Wagenrücklauf                         */
  59.         buffer[buf_count]=0; /* Nullterminieren                     */ 
  60.         if(first)             /* Speicher für Struktur Zeile         */    
  61.             {
  62.             z_p->next_zeile=(struct ZEILE *)calloc( 1,sizeof(struct ZEILE) );
  63.             z_p->next_zeile->prev_zeile=z_p;
  64.             z_p=z_p->next_zeile;
  65.             }
  66.         else
  67.             {
  68.             first=(struct ZEILE *)calloc(1, sizeof(struct ZEILE) );
  69.             first->prev_zeile = NULL;
  70.             z_p=first;
  71.             }
  72.          if(!z_p)
  73.              {break_flag=TRUE;break;}
  74.         z_p->string=(char *)calloc( 1,strlen(buffer)+1);
  75.         if(!z_p->string)
  76.              {
  77.              break_flag=TRUE;
  78.             break;
  79.             }
  80.         strcpy(z_p->string,buffer);    /* buffer Kopieren          */
  81.         text->max_spalten=max(text->max_spalten,buf_count);
  82.         if(text->zeilen < LAST_ZEILE)
  83.             text->zeilen++;
  84.         else
  85.             text->zeilen= -1;
  86.                     
  87.         buf_count=0;                /* Buffercounter reseten */
  88.         break;
  89.         case _TAB:                    /* Tabulatoren              */
  90.         if(buf_count + strlen(tabulator) < 255)
  91.             {
  92.             buffer[buf_count]=0;
  93.             strcat(buffer,tabulator);
  94.             buf_count+=(int)strlen(tabulator);
  95.             }
  96.         break;
  97.         default:
  98.         if(buf_count < 255)                        
  99.             buffer[buf_count++]=(char)cbuf;
  100.         break;    
  101.         } 
  102.     }
  103. text->max_spalten++;
  104. text->start=first;
  105. if(!break_flag && text->zeilen >0) /* kleiner 0 steht für Wert größer 32767 */
  106.     text->ende=z_p;
  107. else
  108.     text->ende=NULL;
  109. fclose(t_file);
  110. return(text);
  111. }
  112. /*************************************
  113.  * Gibt den Textspeicher wieder frei *
  114.  * Input: Zeiger auf TEXT-Struktur     *
  115.  *************************************/        
  116. void text_free(TEXT *asciitext)
  117. {
  118. struct ZEILE *help;
  119.  
  120. help = asciitext->start; 
  121. if(help==NULL)
  122.     return;
  123. do
  124.     {
  125.     if(help->string != NULL)
  126.         free(help->string);
  127.     if(help->next_zeile)        
  128.         {
  129.         help=help->next_zeile;  /* Nachfolger setzen     */
  130.         free(help->prev_zeile);    /* Vorgänger freigeben   */
  131.         }
  132.     else
  133.         {
  134.         free(help);    /* letzter gibt sich selbst frei */
  135.         break;
  136.         }
  137.     }while(1);
  138. free(asciitext);    
  139. }
  140. /***************************************************************
  141.  * (RE)DRAW eines Textes nach der obigen Struktur in einem       *    
  142.  * Fenster .                                                    *         
  143.  * Input:   text_win   Zeiger auf WINDOW-Struktur des Fensters *
  144.  *             asciitext  Zeiger auf die >TEXT-Struktur           *
  145.  ***************************************************************/
  146. void text_draw(struct WINDOW *text_win,TEXT *asciitext)
  147. {
  148. int x_offset, y_offset,w_z,vdi_handle,gl_wchar,gl_hchar,x,y,pxy[8];
  149. int register i=0,w_s,s_len,buf_xo,gl_hbox;
  150. boolean scroll=FALSE;
  151. char buf;
  152. GRECT workarea;
  153. static int old_xo;
  154. static GRECT old_w;
  155. struct ZEILE *help;
  156. static struct ZEILE *old_z;
  157. MFDB *screen;
  158.  
  159. vdi_handle=get_handle();            /* VDI- Handle     ermitteln */
  160. get_workarea(text_win, &workarea);    /* Fenstergröße ermitteln */
  161. x_offset = get_x_slider(text_win);        
  162. y_offset = get_y_slider(text_win);    /* Slideroffset              */
  163. gl_wchar = get_app_cntrl()->gl_wchar;
  164. gl_hchar = get_app_cntrl()->gl_hchar; /* Buchstabengröße       */
  165. gl_hbox  = get_app_cntrl()->gl_hbox;
  166.  
  167. if(workarea.g_h + workarea.g_y > get_screen()->fd_h)
  168.     workarea.g_h=get_screen()->fd_h - workarea.g_y;
  169. if(workarea.g_w +  workarea.g_x > get_screen()->fd_w )
  170.     workarea.g_w =get_screen()->fd_w-workarea.g_x;
  171.     
  172. x=(workarea.g_x + 7)&0xFFF8;    /* auf Bytegrenze */
  173. y= workarea.g_y;
  174.  
  175. w_s = (workarea.g_w - 1)/gl_wchar;
  176. w_z = workarea.g_h/gl_hbox; /* Anzahl der darstellbaren Zeilen  */
  177.  
  178. help = asciitext->start; 
  179. while(help)                        /* Zeile heraussuchen */
  180.     {
  181.     if(y_offset == i++)
  182.         break;
  183.     help=help->next_zeile;
  184.     }        
  185. if(!help)
  186.     return;     /* Man kann gar nicht so blöd denken (Vorbeugung)... */
  187.  
  188. buf_xo = x_offset;
  189.  
  190. /* Eventuell Scrolling möglich ? */
  191. if(old_w.g_w == workarea.g_w && old_w.g_h == workarea.g_h) 
  192.     {
  193.     char buffer[256];
  194.  
  195.     memset(buffer,0x20,w_s+1);
  196.     buffer[w_s+1]=0;    
  197.     screen=get_screen();
  198.  
  199.     if( old_z == help->next_zeile )
  200.         {
  201.         long str_len;
  202.         
  203.         pxy[0]= workarea.g_x;
  204.         pxy[2]= pxy[0] + workarea.g_w - 1; /* aufwärts Scrollen */
  205.         pxy[4]= pxy[0];    
  206.         pxy[6]= pxy[2];
  207.  
  208.         pxy[1]= workarea.g_y;    
  209.         pxy[3]= pxy[1] + ((w_z-1) * gl_hbox) - 1; 
  210.         pxy[5]= pxy[1] + gl_hbox;
  211.         pxy[7]= pxy[3] + gl_hbox ;
  212.  
  213.         vro_cpyfm(vdi_handle,S_ONLY ,pxy,  screen,screen);
  214.         if((str_len = strlen( help->string ) - (long)x_offset )> 0L)
  215.             memcpy(buffer,help->string + x_offset,str_len);
  216.         v_gtext(vdi_handle, x, y + gl_hchar,buffer); 
  217.         scroll=TRUE;
  218.         }     
  219.     else
  220.         {
  221.         if( old_z == help->prev_zeile  )
  222.             {
  223.             struct ZEILE *buf;
  224.  
  225.             pxy[0]= workarea.g_x;
  226.             pxy[2]= pxy[0] + workarea.g_w - 1;
  227.             pxy[4]= pxy[0];    
  228.             pxy[6]= pxy[2];
  229.  
  230.             pxy[5]= workarea.g_y;
  231.             pxy[7]= pxy[5] + ((w_z-1) * gl_hbox) - 1;
  232.             pxy[1]= pxy[5] + gl_hbox;   /* abwärts Scrollen */
  233.             pxy[3]= pxy[7] + gl_hbox;
  234.             
  235.             vro_cpyfm(vdi_handle,S_ONLY,pxy,  screen,screen);
  236.             i=0;
  237.             buf=help;
  238.             while(buf && i < (w_z-1))
  239.                 {
  240.                 i++;buf=buf->next_zeile;
  241.                 }                                    
  242.             if(buf)
  243.                 {
  244.                 long str_len; 
  245.                 if((str_len = strlen(buf->string)-x_offset )> 0L)
  246.                     memcpy(buffer,buf->string + x_offset,str_len);
  247.                 v_gtext(vdi_handle, x , y + ((w_z-1) * gl_hbox) + gl_hchar,buffer);
  248.                 }
  249.             scroll=TRUE;
  250.             }     
  251.         else
  252.             {
  253.             if(x_offset > old_xo)     /* Text nach links  */
  254.                 {
  255.                 int delta= x_offset - old_xo;
  256.                 pxy[1]= workarea.g_y;
  257.                 pxy[3]= pxy[1]+ workarea.g_h -1;
  258.                 pxy[5]= pxy[1];
  259.                 pxy[7]= pxy[3];
  260.                 
  261.                 pxy[0]= x + (gl_wchar * delta);
  262.                 pxy[2]= workarea.g_w + workarea.g_x - 1;              
  263.                 pxy[4]= x;
  264.                 pxy[6]= pxy[2] - (gl_wchar * delta);
  265.                 
  266.                 vro_cpyfm(vdi_handle,S_ONLY,pxy,  screen,screen);
  267.                 /* Folgende Werte manipulieren: */
  268.                 workarea.g_x+=workarea.g_w - (gl_wchar * delta) ;
  269.                 workarea.g_w= (gl_wchar * delta);
  270.                 x+=((w_s - delta) * (gl_wchar) - (gl_wchar));  
  271.                 x_offset+=(w_s - delta -1);
  272.                 w_s = delta + 2;
  273.                 }
  274.             else
  275.                 {
  276.                 if(x_offset < old_xo)    /* Text nach rechts */
  277.                     {        
  278.                     int delta= old_xo - x_offset;
  279.                     pxy[1]= workarea.g_y;
  280.                     pxy[3]= pxy[1]+ workarea.g_h -1;
  281.                     pxy[5]= pxy[1];
  282.                     pxy[7]= pxy[3];
  283.                 
  284.                     pxy[0]= x;
  285.                     pxy[2]= pxy[0] + workarea.g_w - (gl_wchar * delta) - 1;            
  286.                     pxy[4]= pxy[0] + (gl_wchar * delta);
  287.                     pxy[6]= pxy[0] + workarea.g_w -1 ;
  288.                     vro_cpyfm(vdi_handle,S_ONLY,pxy,  screen,screen);
  289.                     /* Folgende Werte manipulieren: */
  290.                     workarea.g_w = (gl_wchar * delta);
  291.                     w_s = delta; 
  292.                     }
  293.                 }
  294.             }
  295.         }
  296.     }    
  297. get_workarea(text_win, &old_w);        /* Fenstergröße merken      */
  298. if(old_w.g_h + old_w.g_y > get_screen()->fd_h)
  299.     old_w.g_h=get_screen()->fd_h - old_w.g_y;
  300. if(old_w.g_w +  old_w.g_x > get_screen()->fd_w )
  301.     old_w.g_w =get_screen()->fd_w-old_w.g_x;
  302. old_z=help;                                    /* sichern           */    
  303. old_xo= buf_xo;
  304.  
  305. if(scroll== TRUE)    
  306.     return;
  307.  
  308. pxy[0] = workarea.g_x; 
  309. pxy[1] = workarea.g_y;
  310. pxy[2] = workarea.g_w + pxy[0] -1 ;
  311. pxy[3] = workarea.g_h + pxy[1] -1 ;
  312. v_bar(vdi_handle,pxy);
  313. y+=gl_hchar;
  314. for(i = 0;i < w_z && help;i++)
  315.     {
  316.     s_len=(int)strlen(help->string);
  317.     if(s_len > x_offset + w_s) /* auch über rechte Kante hinweg */ 
  318.         {
  319.         buf= help->string[w_s + x_offset];    
  320.         help->string[w_s + x_offset]=0;
  321.         v_gtext(vdi_handle, x,y, help->string + x_offset); 
  322.         help->string[w_s + x_offset]=buf;
  323.         }
  324.     else
  325.         {
  326.         if(s_len > x_offset) /* innerhalb des Fensterbereiches */
  327.             v_gtext(vdi_handle, x,y,help->string + x_offset); 
  328.         }
  329.     y+= gl_hbox;
  330.     help = help->next_zeile;
  331.     }
  332.  
  333. }
  334.  
  335. /* EOF */