home *** CD-ROM | disk | FTP | other *** search
/ ftp.sunet.sepub/pictures / 2014.11.ftp.sunet.se-pictures.tar / ftp.sunet.se / pub / pictures / ACiD-artpacks / programs / unix / editors / gimp-plugins-unstable-0_99_23_tar.gz / gimp-plugins-unstable-0_99_23_tar / gimp-plugins-unstable-0.99.23 / gag / gag-lib.c < prev    next >
C/C++ Source or Header  |  1998-02-19  |  18KB  |  729 lines
  1. #include <strings.h>
  2. #include <stdio.h>
  3.  
  4. #include "gag.h"
  5.  
  6. #define LIB_DATA    "lib_data"
  7.  
  8.  
  9. typedef struct library_entry_struct  LENTRY;
  10. struct library_entry_struct {
  11.   NODE          *expression;
  12.   GtkWidget    *list_item;
  13.   GtkWidget    *label;
  14.  
  15.   char          name [30];
  16.   LENTRY      *Next;
  17. };
  18. static LENTRY    *Library= NULL;
  19. static LENTRY    *CurrentLentry=NULL;
  20.  
  21. static ENTRY_DIALOG SaveWindow= {NULL, NULL, NULL};
  22. static ENTRY_DIALOG RenameWindow= {NULL, NULL, NULL};
  23.  
  24. static int        save_counter=1;
  25.  
  26. static struct {
  27.   GtkWidget    *window;
  28.   GtkWidget    *list;
  29.   GtkWidget    *popup_menu;
  30.   GtkWidget    *preview;
  31.   GtkWidget    *progress;
  32.   INDIVIDUAL    *ind;
  33. } LibraryWin= {NULL, NULL, NULL, NULL, NULL, NULL};
  34.  
  35. void gag_destroy_window(GtkWidget *, gpointer);
  36. void gag_cancel_button(GtkWidget *, gpointer);
  37. void gag_hide_window(GtkWidget *widget, gpointer  data);
  38.  
  39. void gag_add_lentry_2_list( LENTRY *n )
  40. {
  41.   GtkWidget *label;
  42.   GtkWidget *list_item;
  43.  
  44.   if (LibraryWin.window == NULL) return;
  45.  
  46.   label= gtk_label_new(n->name);
  47.   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  48.   list_item= gtk_list_item_new( );
  49.   gtk_container_add(GTK_CONTAINER(list_item),label);
  50.   gtk_container_add(GTK_CONTAINER(LibraryWin.list),
  51.             list_item);
  52.   gtk_object_set_data( GTK_OBJECT(list_item), LIB_DATA, n);
  53.   n->list_item= list_item;
  54.   n->label= label;
  55.   gtk_widget_show(label);
  56.   gtk_widget_show(list_item);
  57. }
  58.  
  59. void SaveWindow_callback(GtkWidget *widget, gpointer data)
  60. {
  61.   LENTRY    **ptr= &Library, *n;
  62.  
  63.   if (SaveWindow.ind->expression == NULL)
  64.     return;
  65.  
  66.   if (GTK_WIDGET_VISIBLE( SaveWindow.dialog ))
  67.     gtk_widget_hide( SaveWindow.dialog);
  68.  
  69.   n= (LENTRY *) malloc(sizeof(LENTRY));
  70.   n-> expression= node_copy( SaveWindow.ind->expression );
  71.   strncpy(n->name,GTK_ENTRY( SaveWindow.entry )->text, 29);
  72.   n-> Next= NULL;
  73.     
  74.   while (*ptr != NULL) ptr= &( (*ptr)->Next );
  75.   *ptr= n;
  76.  
  77.   gag_add_lentry_2_list( n );
  78. }
  79.  
  80. void gag_show_save_dialog(GtkWidget *w, gpointer data)
  81. {
  82.   if (SaveWindow.dialog == NULL)
  83.     gag_create_entry(&SaveWindow, "Enter name of expression",
  84.              GTK_SIGNAL_FUNC(SaveWindow_callback));
  85.  
  86.   if (!(GTK_WIDGET_VISIBLE(SaveWindow.dialog)))
  87.     {
  88.       char buff[20];
  89.       
  90.       sprintf(buff,"Noname%0d",save_counter++);
  91.       gtk_entry_set_text(GTK_ENTRY(SaveWindow.entry),buff);
  92.       SaveWindow.ind= ui.popup_individual;
  93.       gtk_widget_show(SaveWindow.dialog);
  94.     }
  95. }
  96.  
  97. /******************************
  98.  
  99.    Main Library window
  100.  
  101. ******************************/
  102. void gag_lib_Copy( GtkWidget *widget, gpointer data)
  103. {
  104. }
  105.  
  106. void gag_lib_Delete( GtkWidget *widget, gpointer data)
  107. {
  108.   LENTRY **ptr= &Library, *n;
  109.  
  110.   while (*ptr != NULL)
  111.     {
  112.       if (*ptr == CurrentLentry) break;
  113.       ptr= &( (*ptr)->Next ); 
  114.     }
  115.   if (ptr != NULL)
  116.     {
  117.       GList    *tmp;
  118.       n= *ptr;
  119.  
  120.       *ptr= n->Next;
  121.  
  122.       tmp->data= n->list_item;
  123.       tmp->prev= tmp->next= NULL;
  124.       gtk_list_remove_items (GTK_LIST (LibraryWin.list),tmp);
  125.  
  126.       gtk_widget_destroy(n->list_item);
  127.       free( n );
  128.     }
  129. }
  130.  
  131. static void RenameWindow_callback( GtkWidget *widget, gpointer *data)
  132. {
  133.   LENTRY *lptr;
  134.  
  135.   if (GTK_WIDGET_VISIBLE( RenameWindow.dialog ))
  136.     gtk_widget_hide( RenameWindow.dialog);
  137.  
  138.   lptr= (LENTRY *) (RenameWindow.ind);
  139.   strncpy(lptr->name, GTK_ENTRY( RenameWindow.entry )->text, 29);
  140.   gtk_label_set(GTK_LABEL(lptr->label), lptr->name);
  141.   gtk_widget_draw(lptr->label, NULL);
  142. }
  143.  
  144. void gag_lib_Rename( GtkWidget *widget, gpointer data)
  145. {
  146.   if (RenameWindow.dialog == NULL)
  147.     gag_create_entry(&RenameWindow, "Enter name of expression",
  148.              GTK_SIGNAL_FUNC(RenameWindow_callback));
  149.  
  150.   if (!(GTK_WIDGET_VISIBLE(RenameWindow.dialog)))
  151.     {
  152.       gtk_entry_set_text(GTK_ENTRY(RenameWindow.entry),CurrentLentry->name);
  153.       RenameWindow.ind= (INDIVIDUAL *) CurrentLentry;
  154.       gtk_widget_show(RenameWindow.dialog);
  155.     }
  156. }
  157.  
  158. void gag_lib_Evoke( GtkWidget *widget, gpointer data)
  159. {
  160.   destroy_node(LibraryWin.ind->expression);
  161.   LibraryWin.ind->expression= node_copy( CurrentLentry->expression );
  162.   gag_repaint_ind( NULL, LibraryWin.ind, 0);
  163.  
  164.   ui.repaint_preview = TRUE;
  165. }
  166.  
  167. void gag_lib_render_pic( GtkWidget *widget, gpointer data)
  168. {
  169.   INDIVIDUAL tmp, *tmpptr;
  170.  
  171.   tmpptr= &tmp;
  172.   tmp.expression=  CurrentLentry->expression;
  173.   gag_render_picture_ptr(NULL, &tmpptr);
  174. }
  175.  
  176. static void gag_Create_FS(GtkWidget **window, char *label,
  177.               void *ok_cb)
  178. {
  179.   *window = gtk_file_selection_new ("file selection dialog");
  180.   gtk_window_position (GTK_WINDOW (*window), GTK_WIN_POS_MOUSE);
  181.   gtk_signal_connect (GTK_OBJECT (*window), "destroy",
  182.               (GtkSignalFunc)gag_destroy_window,
  183.               window);
  184.  
  185.   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (*window)->ok_button),
  186.               "clicked", (GtkSignalFunc ) ok_cb,
  187.               *window);
  188.  
  189.   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (*window)->ok_button),
  190.               "clicked", (GtkSignalFunc ) gag_hide_window,
  191.               *window);
  192.  
  193.   gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (*window)->cancel_button),
  194.                  "clicked", (GtkSignalFunc) gtk_widget_destroy,
  195.                  GTK_OBJECT (*window));
  196. }
  197.  
  198.  
  199. static void gag_lib_load_cb(GtkWidget *widget, GtkWidget *fs)
  200. {
  201.   DPRINT("Loading Library");
  202.   gag_load_library(
  203.      gtk_file_selection_get_filename(GTK_FILE_SELECTION (fs))
  204.   );
  205. }
  206.  
  207. static void gag_lib_save_cb(GtkWidget *widget, GtkWidget *fs)
  208. {
  209.   gag_save_library(
  210.       gtk_file_selection_get_filename(GTK_FILE_SELECTION (fs))
  211.   );
  212. }
  213.  
  214. static void gag_lib_Load( GtkWidget *widget, gpointer data)
  215. {
  216.   static GtkWidget *LoadWin= NULL;
  217.  
  218.   if (LoadWin==NULL)
  219.     gag_Create_FS(&LoadWin, "Load Library", (void *)gag_lib_load_cb);
  220.  
  221.   if (!(GTK_WIDGET_VISIBLE(LoadWin)))
  222.       gtk_widget_show(LoadWin);
  223. }
  224.  
  225. void gag_lib_Save( GtkWidget *widget, gpointer data)
  226. {
  227.   static GtkWidget *SaveWin= NULL;
  228.  
  229.   if (SaveWin==NULL)
  230.     gag_Create_FS(&SaveWin, "Save Library as", (void *)gag_lib_save_cb);
  231.  
  232.   if (!(GTK_WIDGET_VISIBLE(SaveWin)))
  233.       gtk_widget_show(SaveWin);
  234. }
  235.  
  236.  
  237. int gag_lib_popup (GtkWidget *widget, GdkEventButton *event,
  238.            gpointer        user_data)
  239. {
  240.   GtkWidget *event_widget;        
  241.   GdkEventButton *bevent;
  242.  
  243.   event_widget = gtk_get_event_widget ((GdkEvent*) event);  
  244.  
  245.  
  246.  
  247.   bevent= (GdkEventButton *)event;
  248.  
  249.   switch (event->type)
  250.     {
  251.     case GDK_2BUTTON_PRESS:
  252.       switch (bevent->button)
  253.     {
  254.     case 1:
  255.       {
  256.         INDIVIDUAL     i;
  257.         LENTRY    *lptr;
  258.  
  259.         lptr= gtk_object_get_data( GTK_OBJECT(event_widget),
  260.                        LIB_DATA);
  261.  
  262.         i.preview= LibraryWin.preview;
  263.         i.expression= lptr->expression;
  264.  
  265.         gag_repaint_ind( LibraryWin.progress, &i,1);
  266.         break;
  267.       }
  268.     default:
  269.       break;
  270.     }
  271.       break;
  272.  
  273.     case GDK_BUTTON_PRESS:
  274.       if (bevent->button==3)
  275.     {
  276.       CurrentLentry= 
  277.         gtk_object_get_data( GTK_OBJECT(event_widget),
  278.                  LIB_DATA);
  279.       gtk_menu_popup( GTK_MENU(LibraryWin.popup_menu),NULL, NULL,
  280.               NULL,NULL, 3, bevent->time);
  281.  
  282.     }
  283.       break;
  284.     default:
  285.       break;
  286.     }
  287.   return FALSE;
  288. }
  289.  
  290. void gag_library_show(GtkWidget *widget, gpointer data)
  291. {
  292.   if (LibraryWin.popup_menu == NULL)
  293.     {
  294.       GtkMenu *menu;
  295.       GtkWidget    *menuitem;
  296.  
  297.       menu= GTK_MENU( gtk_menu_new () );
  298.       
  299.       /* for now this seems needless
  300.  
  301.      menuitem= gtk_menu_item_new_with_label("Copy");
  302.      gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  303.      (GtkSignalFunc) gag_lib_Copy, NULL);
  304.      gtk_menu_append(menu, menuitem);
  305.      gtk_widget_show( menuitem );
  306.        */
  307.  
  308.       menuitem= gtk_menu_item_new_with_label("Evoke");      
  309.       gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  310.               (GtkSignalFunc) gag_lib_Evoke, NULL);
  311.       gtk_menu_append(menu, menuitem);
  312.       gtk_widget_show( menuitem );
  313.  
  314.       if (gag_render_picture_ptr != NULL)
  315.     {
  316.       menuitem= gtk_menu_item_new_with_label("Render picture");
  317.       gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  318.                   (GtkSignalFunc) gag_lib_render_pic, 
  319.                   NULL);
  320.       gtk_menu_append(menu, menuitem);
  321.       gtk_widget_show( menuitem );
  322.     }
  323.  
  324.       menuitem= gtk_menu_item_new();
  325.       gtk_menu_append( menu, menuitem);
  326.       gtk_widget_show( menuitem );
  327.  
  328.       menuitem= gtk_menu_item_new_with_label("Rename");      
  329.       gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  330.               (GtkSignalFunc) gag_lib_Rename, NULL);
  331.       gtk_menu_append(menu, menuitem);
  332.       gtk_widget_show( menuitem );
  333.  
  334.       menuitem= gtk_menu_item_new_with_label("Delete");
  335.       gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  336.               (GtkSignalFunc) gag_lib_Delete, NULL);
  337.       gtk_menu_append(menu, menuitem);
  338.       gtk_widget_show( menuitem );
  339.  
  340.       menuitem= gtk_menu_item_new();
  341.       gtk_menu_append( menu, menuitem);
  342.       gtk_widget_show( menuitem );
  343.  
  344.       menuitem= gtk_menu_item_new_with_label("Load from file"); 
  345.       gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  346.               (GtkSignalFunc) gag_lib_Load, NULL);
  347.       gtk_menu_append(menu, menuitem);
  348.       gtk_widget_show( menuitem );
  349.       
  350.       menuitem= gtk_menu_item_new_with_label("Save to file");
  351.       gtk_signal_connect( GTK_OBJECT(menuitem), "activate",
  352.               (GtkSignalFunc) gag_lib_Save, NULL);
  353.       gtk_menu_append(menu, menuitem);
  354.       gtk_widget_show( menuitem );
  355.  
  356.       LibraryWin.popup_menu= GTK_WIDGET(menu);
  357.     }
  358.  
  359.   if (LibraryWin.window == NULL)
  360.     {
  361.       GtkWidget *window;
  362.       GtkWidget    *hbox, *vbox;
  363.       GtkWidget    *list;
  364.       GtkWidget    *preview;
  365.       GtkWidget    *scwin;
  366.       GtkWidget    *frame;
  367.       GtkWidget    *button;
  368.       GtkWidget    *progress;
  369.  
  370.       LENTRY    *lptr;
  371.  
  372.       gtk_widget_push_visual( gtk_preview_get_visual ());
  373.       gtk_widget_push_colormap (gtk_preview_get_cmap());
  374.  
  375.       window= gtk_window_new( GTK_WINDOW_TOPLEVEL );
  376.       gtk_signal_connect( GTK_OBJECT(window), "destroy",
  377.               (GtkSignalFunc) gag_destroy_window,
  378.               &(LibraryWin.window));
  379.       gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE);
  380.       gtk_window_set_title( GTK_WINDOW(window),"GAG Library");
  381.       LibraryWin.window= window;
  382.  
  383.       hbox= gtk_hbox_new(FALSE, 10);
  384.       gtk_container_border_width( GTK_CONTAINER(hbox),10);
  385.       gtk_container_add(GTK_CONTAINER(window), hbox);
  386.  
  387.       scwin= gtk_scrolled_window_new( NULL, NULL );
  388.       gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
  389.                      GTK_POLICY_AUTOMATIC,
  390.                      GTK_POLICY_AUTOMATIC);
  391.  
  392.       gtk_widget_set_usize( scwin, 300, 150);
  393.       gtk_box_pack_start( GTK_BOX(hbox), scwin, TRUE, TRUE, TRUE);
  394.  
  395.       LibraryWin.list= list= gtk_list_new();
  396.       gtk_list_set_selection_mode (GTK_LIST (list),    
  397.                    GTK_SELECTION_BROWSE);
  398.       gtk_container_add( GTK_CONTAINER(scwin), list);
  399.       gtk_signal_connect(GTK_OBJECT( list ), "button_press_event",
  400.              (GtkSignalFunc)gag_lib_popup, NULL);
  401.       gtk_widget_show( list );
  402.       gtk_widget_show(scwin);
  403.  
  404.  
  405.       vbox= gtk_vbox_new(FALSE, 5);
  406.       gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE,0);
  407.  
  408.       frame= gtk_frame_new(NULL);
  409.       gtk_frame_set_shadow_type(GTK_FRAME(frame),
  410.                 GTK_SHADOW_IN);
  411.       gtk_box_pack_start( GTK_BOX(vbox), frame,
  412.               FALSE, FALSE, FALSE);      
  413.  
  414.       LibraryWin.preview= preview= gtk_preview_new( PREVIEW_MODE );
  415.       gtk_preview_size( GTK_PREVIEW(preview), 
  416.             PREVIEW_WIDTH, PREVIEW_HEIGHT);
  417.       gtk_container_add( GTK_CONTAINER(frame), preview );
  418.       gtk_widget_show( preview );
  419.       gtk_widget_show( frame );
  420.  
  421.       button= gtk_button_new_with_label("Close");
  422.       gtk_box_pack_end(GTK_BOX(vbox), button, FALSE, FALSE,  0);
  423.       gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
  424.                 (GtkSignalFunc) gag_cancel_button,(gpointer)window);
  425.       gtk_widget_show(button);
  426.  
  427.       progress= gtk_progress_bar_new();
  428.       gtk_widget_set_usize(progress, 80, 20);
  429.       gtk_box_pack_end(GTK_BOX(vbox), progress, 
  430.                FALSE, FALSE, 0);
  431.       LibraryWin.progress=progress;
  432.       gtk_widget_show( progress );
  433.       
  434.       gtk_widget_show( vbox );
  435.       for (lptr=Library; lptr != NULL; lptr= lptr->Next)
  436.     gag_add_lentry_2_list( lptr );
  437.       
  438.       gtk_widget_show( hbox );
  439.     }
  440.  
  441.   if (!(GTK_WIDGET_VISIBLE(LibraryWin.window)))
  442.     {    
  443.       gtk_widget_show(LibraryWin.window);
  444.     }
  445.   LibraryWin.ind= ui.popup_individual;
  446. }
  447.  
  448. /******************************
  449.  
  450.   GAG LIB LOAD/SAVE functions
  451.  
  452. ******************************/
  453.  
  454. void translate_name2esc(char *s, char *d)
  455. {
  456.   while ( (*d=*s) != '\000')
  457.     {
  458.       if (*d == '\\'){          d++; *d='\\'; }
  459.       if (*d == '"') { *d='\\'; d++; *d='"'; }
  460.       d++;
  461.       s++;
  462.     }
  463. }
  464.  
  465. void gag_save_library(char *file)
  466. {
  467.   FILE         *f;
  468.   LENTRY    *lptr;
  469.   char         buff[100];
  470.  
  471.   lptr= Library;
  472.   
  473.   f= fopen( file, "wt");
  474.  
  475.   fprintf(f,";;; GAG Library file\n\n");
  476.  
  477.   while  (lptr != NULL)
  478.     {
  479.       translate_name2esc(lptr->name, buff);
  480.       fprintf(f, "(insert-to-library \"%s\" \n", buff);
  481.       expr_fprint(f, 2, lptr->expression);
  482.       fprintf(f, ") ;;; end of function\n\n");
  483.       lptr= lptr->Next;
  484.     }
  485.   fclose(f);
  486. }
  487.  
  488. static void string_convert(char *line, char *pline, char *name)
  489. {
  490.   int         state=0;  /* 0 - ok, 1 - inside string */
  491.   guchar    prevchar=0;
  492.  
  493.   while ((*pline= *line) != 0)
  494.     {
  495.       if ((state == 0)&&(*line==';'))
  496.     { *pline = '\000'; return; }
  497.  
  498.       pline++;
  499.  
  500.       if ((state==0)&&(*line=='"'))
  501.     { state=1; line++; continue; }
  502.  
  503.       if ((state==1)&&(prevchar!='\\')&&(*line=='"'))
  504.     { state=0; *name= '\000'; line++; continue; }
  505.  
  506.       if (state==1)
  507.     {
  508.       switch (prevchar)
  509.         {
  510.         case '\\':
  511.           switch (*line)
  512.         {
  513.         case '"': case '\\':
  514.           *(name-1)= *line;
  515.           break;
  516.         default:
  517.           printf("Warning: Unknown prefix");
  518.           break;
  519.         }
  520.           prevchar='\000';
  521.           break;
  522.         default:
  523.           *name= *line; ++name; break;
  524.         }
  525.     }
  526.       prevchar= *line;
  527.       line++;
  528.     }
  529.  
  530.   if (state!=0)
  531.     {
  532.       printf("Error: Unterminated string constant: %s\n",line);
  533.     }
  534. }
  535.  
  536. static void readln(FILE *f, guchar *str, int max)
  537. {
  538.   int z;
  539.  
  540.   do {
  541.     if ((z= fgetc(f))==EOF) break;
  542.  
  543.     if ((z == '\n') || (z=='\r') || (z=='\f') || (z=='\v'))
  544.       break;
  545.     else
  546.       *str= (guchar) z;
  547.     str++;
  548.     max--;
  549.   } while (max);
  550.   *str='\000';
  551. }
  552.  
  553. void gag_load_library(char *file)
  554. {
  555.   FILE        *f;
  556.   char         *buff, *s;
  557.   
  558.   char        line[500];
  559.   char        smbuff[500];
  560.   char        name[30], tmp[100];
  561.   int        state=0;           /* 0 - waiting, 1 - recieving */
  562.   int        ll;
  563.  
  564.   NODE     *n;
  565.   LENTRY *v, **head;
  566.  
  567.   DPRINT("Loading library...");
  568.  
  569.   head= &Library;
  570.   while (*head != NULL) head= &((*head)->Next);
  571.  
  572.   if ((f= fopen(file, "rt"))==NULL) return;
  573.  
  574.   buff= malloc(200*1000);        /* oh - we are lazy programmers !!!) */
  575.   
  576.   while (! (feof(f)))
  577.     {
  578.       readln(f, (guchar *) line, 499);
  579.  
  580.       string_convert(line, smbuff, tmp);
  581.       if (smbuff[0]=='\000') continue;
  582.  
  583.       if (state == 0)
  584.     {
  585.       if (strncmp(smbuff,"(insert-to-library ",18 )==0)
  586.         {
  587.           strncpy(name, tmp, 30);
  588.           state=1;
  589.  
  590.           s= buff;
  591.           memset(buff, ' ', 200*1000);
  592.           
  593.           continue;
  594.         }
  595.       printf("Error: unexpected line %s\n", line);
  596.       continue;
  597.     }
  598.       else
  599.     {
  600.       if (strncmp(line, ") ;;; end of function",20)==0)
  601.           {
  602.         s= buff;
  603.         n= parse_prefix_expression(&s);
  604.         if (n==NULL) goto end_of_loading;
  605.         v= (LENTRY *) malloc(sizeof(LENTRY));
  606.         
  607.         v->expression= n;
  608.         v->Next=NULL;
  609.         v->list_item=NULL;
  610.  
  611.         strncpy(v->name, name, 30);
  612.         gag_add_lentry_2_list( v );
  613.         
  614.         *head= v;
  615.         head= & (v->Next);
  616.         
  617.         state=0;
  618.         continue;
  619.           }
  620.       *(s++)= ' ';
  621.       ll= strlen (smbuff);
  622.       strcpy(s, smbuff);
  623.       s+= ll;
  624.     }
  625.     } /* end of while */
  626.  
  627.   if (state == 1)
  628.     {
  629.       printf("Error: corrupted library\n");
  630.     }
  631.  
  632. end_of_loading:
  633.   if (f!= NULL) fclose( f);
  634.   if (buff != NULL) free (buff);
  635. }
  636.  
  637. /******************************
  638.  
  639.    MISC FUNCTIONS
  640.  
  641. ******************************/
  642.  
  643. void gag_hide_window(GtkWidget *widget, gpointer  data)
  644. {
  645.   GtkWidget    *tmp;
  646.  
  647.   tmp= (GtkWidget *) data;
  648.   if (GTK_WIDGET_VISIBLE(tmp))
  649.     gtk_widget_hide(tmp);
  650. }
  651.  
  652. void gag_destroy_window(GtkWidget *widget, gpointer  data)
  653. {
  654.   GtkWidget    **tmp;
  655.  
  656.   tmp= (GtkWidget **) data;
  657.   *tmp= NULL;
  658. }
  659.  
  660. void gag_cancel_button(GtkWidget *widget, gpointer data)
  661. {
  662.   if (GTK_WIDGET_VISIBLE (GTK_WIDGET(data)))
  663.     gtk_widget_hide (GTK_WIDGET(data));
  664. }
  665.  
  666. void gag_clear_entry(GtkWidget *widget, GtkEntry *entry)
  667. {
  668.   gtk_entry_set_text(entry, "");
  669. }
  670.  
  671. void gag_create_entry( ENTRY_DIALOG *ed, char *title, GtkSignalFunc OkFunc )
  672. {
  673.   GtkWidget     *dialog;
  674.   GtkWidget    *button;
  675.   GtkWidget    *entry;
  676.   GtkWidget    *vb;
  677.  
  678.   dialog= gtk_dialog_new();
  679.   ed->dialog= dialog;
  680.   gtk_signal_connect( GTK_OBJECT(dialog), "destroy",
  681.               (GtkSignalFunc)gag_destroy_window,
  682.               &(ed->dialog));
  683.   gtk_window_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
  684.   gtk_container_border_width (GTK_CONTAINER (dialog), 0);
  685.   gtk_window_set_title(GTK_WINDOW(dialog), title);
  686.  
  687.   vb= gtk_vbox_new(TRUE, 0);
  688.   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vb,
  689.              TRUE, TRUE,0);
  690.   gtk_container_border_width( GTK_CONTAINER(vb), 10);
  691.  
  692.   entry= gtk_entry_new();
  693.   gtk_widget_set_usize( entry, 400, 0);
  694.   gtk_box_pack_start( GTK_BOX(vb), entry, TRUE, TRUE,0);
  695.   ed->entry=entry;
  696.   gtk_widget_show(entry);
  697.  
  698.   gtk_widget_show( vb );
  699.  
  700.   button= gtk_button_new_with_label("OK");
  701.   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  702.   gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dialog)->action_area),
  703.               button, TRUE, TRUE,0);
  704.   gtk_signal_connect( GTK_OBJECT(button), "clicked",
  705.               (GtkSignalFunc) OkFunc,
  706.               NULL);
  707.   gtk_widget_grab_default (button);
  708.   gtk_widget_show(button);
  709.  
  710.   button= gtk_button_new_with_label("Clear");
  711.   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  712.   gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dialog)->action_area),
  713.               button, TRUE, TRUE,0);
  714.   gtk_signal_connect( GTK_OBJECT(button), "clicked",
  715.               (GtkSignalFunc) gag_clear_entry,
  716.               entry);
  717.   gtk_widget_show(button);
  718.  
  719.   button= gtk_button_new_with_label("Cancel");
  720.   GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  721.   gtk_signal_connect( GTK_OBJECT(button), "clicked",
  722.               (GtkSignalFunc) gag_cancel_button,
  723.               GTK_OBJECT(dialog));
  724.   gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dialog)->action_area),
  725.               button, TRUE, TRUE,0);
  726.   gtk_widget_show(button);
  727. }
  728.  
  729.