g_ui_gtk.c

来自「Non-Networked File System在几个非网络的（或慢网络的）U」· C语言 代码 · 共 1,262 行 · 第 1/3 页

		    pc += sprintf(pc, " type=d") ;
		    break ;
		  case g_Is_A_Link:
		    pc += sprintf(pc, " type=l") ;
		    break ;
		  case g_Is_A_FIFO:
		    pc += sprintf(pc, " type=p") ;
		    break ;
		  case g_Is_A_File:
		    pc += sprintf(pc, " type=f") ;
		    break ;
		  case g_Is_Any:
		    break ;
		  default:
		    abort() ;
		  }
		if ( t[i][7][0] )
		  pc += sprintf(pc, " regex=%s", t[i][7]) ;
		pc += sprintf(pc, "\n") ;
	      }
	    for(j=0;j<8;j++)
	      if ( t[i][j] )
		g_Free(t[i][j]) ;
	  }
      }
      break ;
    }
}

void save_config()
{
  FILE *g ;
  g_Nnfsrc_Var *v ;
  char **cases ;
  int nb_cases ;
  g_Boolean found ;
  GtkWidget **tables ;
  int k ;
  char *tmp ;
  char *new_file_name ;
  char *old_file_name ;

  v = g_Nnfsrc_Var_Table() ;

  G_MALLOC(new_file_name, strlen(gconfig->nnfsrc)+6) ;
  sprintf(new_file_name, "%s.new~", gconfig->nnfsrc) ;
  g = fopen(new_file_name, "w+") ;
  if ( g == NULL )
    {
      g_Printf("Can't write new configuration") ;
      perror(new_file_name) ;
      return ;
    }
  tables = pages[search_page("Setup")].tables ;

  for(k=0;tables[k];k++) /* 10 = More than the number of pages */
    {
      gtk_container_foreach (GTK_CONTAINER (tables[k]),
			     (GtkCallback) retrieve_values, NULL);
    }
  tmp = g_Case_Name(goptions->hostname) ;
  g_Nnfsrc_Action( gconfig->nnfsrc,v,g_True, tmp,&found, &cases,&nb_cases,g,
		   goptions->hostname) ;
  fclose(g) ;

  G_MALLOC(old_file_name, strlen(gconfig->nnfsrc)+6) ;
  sprintf(old_file_name, "%s~", gconfig->nnfsrc) ;
  if ( rename(gconfig->nnfsrc, old_file_name) )
    {
      g_Printf("Error renaming %s to %s\n", gconfig->nnfsrc, old_file_name) ;
      perror(old_file_name) ;
    }

  if ( rename(new_file_name, gconfig->nnfsrc) )
    {
      g_Printf("Error renaming %s to %s\n", new_file_name, gconfig->nnfsrc) ;
      perror(new_file_name) ;
    }

  gtk_main_quit ();
  /*

  set_config_widget(tmp) ;
  g_Free(tmp) ;
  */
}

void set_config_widget(char *named)
{
  char **cases ;
  int nb_cases ;
  int k, m, i ;
  GtkWidget **tables, *name, *entry, *menu, *item ;
  g_Nnfsrc_Var *v ;
  g_Boolean found ;

  v = g_Nnfsrc_Var_Table() ;
  g_Nnfsrc_Action( gconfig->nnfsrc,v,g_True, named,&found, &cases, &nb_cases, NULL,
		   goptions->hostname) ;

  tables = pages[search_page("Setup")].tables ;

  for(k=0;tables[k];k++) /* 10 = More than the number of pages */
    {
      gtk_widget_hide(tables[k]) ;

      gtk_container_foreach (GTK_CONTAINER (tables[k]),
			     (GtkCallback) gtk_widget_destroy, NULL);

      for(m=0; v[m].name ; m++)
	{
	  if ( v[m].page != k )
	    continue ;

	  if ( v[m].type != g_Var_Filter )
	    {
	      name = gtk_label_new( v[m].name ) ;
	      gtk_widget_show(name) ;
	      gtk_table_attach( GTK_TABLE(tables[k]), name,
				0,1, m,m+1, VO,VO,0,0) ; 
	    }

	  switch( v[m].type )
	    {
	    case g_Var_Big_String:
	      entry = gtk_text_new(NULL,NULL) ;
	      gtk_signal_connect (GTK_OBJECT (entry), "realize",
				  GTK_SIGNAL_FUNC (realize_text),
				  v[m].content);
	      gtk_text_set_editable(GTK_TEXT(entry), TRUE) ;
	      break ;
	    case g_Var_Filter:
	      entry = output_filter(v[m].content) ;
	      break ;
	    case g_Var_Choice:
	    case g_Var_Boolean:
	      entry = gtk_option_menu_new() ;
	      v[m].menu = create_texts(v[m].choices) ;

	      gtk_option_menu_set_menu(GTK_OPTION_MENU(entry), v[m].menu);


	      for(i=0;v[m].choices[i][0][0];i++)
		if ( strcmp(v[m].choices[i][0], v[m].content) == 0 )
		  break ;
	      if ( v[m].choices[i][0][0]=='\0' ) i = 0 ;
	      gtk_option_menu_set_history(GTK_OPTION_MENU(entry), i) ;
	      break ;
	    default:
	      entry = gtk_entry_new() ;
	      if ( v[m].widget_name )
		gtk_widget_set_name(entry, v[m].widget_name) ;
	      gtk_entry_set_text (GTK_ENTRY (entry), v[m].content) ;
	      break ;
	    }

	  gtk_widget_show(entry) ;

	  gtk_tooltips_set_tip(tips, entry, v[m].tip, NULL) ;

	  gtk_object_set_data(GTK_OBJECT(entry), "nnfs2", (gpointer)(m+1)) ;
	  gtk_table_attach( GTK_TABLE(tables[k]), entry, 1,2, m,m+1,
			    (GtkAttachOptions)(GTK_FILL|GTK_EXPAND),VO,0,0) ; 
	}

      gtk_widget_show(tables[k]) ;
    }

  if ( pages[search_page("Setup")].menu )
    gtk_widget_destroy( pages[search_page("Setup")].menu ) ;

  menu = gtk_menu_new();
  pages[search_page("Setup")].menu = menu ;
  for(k=0;k<nb_cases;k++)
    {
      item = gtk_menu_item_new_with_label(cases[k]);
      gtk_menu_append(GTK_MENU (menu), item);
      gtk_signal_connect_object(GTK_OBJECT(item), "activate",
				GTK_SIGNAL_FUNC(load_config),
				(gpointer) cases[k]);
      gtk_widget_show(item);
    }

  if ( pages[search_page("Setup")].signal )
    {
      gtk_signal_disconnect(GTK_OBJECT(pages[search_page("Setup")].button),
			    pages[search_page("Setup")].signal
			    ) ;
    }

  pages[search_page("Setup")].signal =
    gtk_signal_connect_object(GTK_OBJECT(pages[search_page("Setup")].button),
			      "event",
			      GTK_SIGNAL_FUNC (button_press),
			      GTK_OBJECT(menu));

}


/*
 *
 */
GtkWidget *setup_page(int i)
{
  GtkWidget *vbox, *noteb, *frame ;
  GtkWidget *hbox, *b2, *eb ;
  int k ;
  static char *t[][2] =
  {
    {"Medium Access","How to read/write/eject the medium (host dependent)"},
    {"Basic options", "Simple options (host independent)"},
    {"Advanced options", "Advanced options (host independent)"},
    {"Output Filter", "The output filter allow to choose files no to be wrote on medium (host independent)"}
  } ;
  

  vbox = gtk_vbox_new(0,0) ;

  pages[i].label = gtk_label_new("NNFS2 Configuration pages") ;
  gtk_widget_show(pages[i].label) ;
  gtk_box_pack_start(GTK_BOX(vbox), pages[i].label, 0,0,0) ;

  noteb = gtk_notebook_new() ;
  gtk_container_border_width (GTK_CONTAINER (noteb), 5);
  gtk_box_pack_start(GTK_BOX(vbox), noteb, 0,0,0) ;

  for(k=0;k<sizeof(t)/sizeof(t[0]);k++)
    {
      pages[i].tables[k] = gtk_table_new(2, 20, 0) ;

      frame = gtk_frame_new (t[k][1]);
      gtk_container_border_width (GTK_CONTAINER (frame), 5);
      gtk_container_add (GTK_CONTAINER (frame), pages[i].tables[k]);
      gtk_widget_show(frame) ;

      eb = notebook_label(t[k][0], k, t[k][1]) ;

      gtk_notebook_append_page (GTK_NOTEBOOK (noteb), frame, eb);
    }
  gtk_widget_show(noteb) ;


  hbox = gtk_hbox_new(0,0) ;

  pages[i].button = gtk_button_new_with_label("Read a configuration");
  gtk_tooltips_set_tip(tips, pages[i].button,
		       "Use this button to load an example of configuration for various systems. The configuration is used only once the configuration saved.", NULL) ;
  gtk_widget_show(pages[i].button) ;
  gtk_box_pack_start(GTK_BOX(hbox), pages[i].button, TRUE,0,0) ;

  b2 = gtk_button_new_with_label ("Save this configuration and exit");
  gtk_signal_connect (GTK_OBJECT (b2), "clicked",
		      GTK_SIGNAL_FUNC (save_config), NULL);
  gtk_tooltips_set_tip(tips, b2,
		       "Use this button to save the configuration for this host, this will not affect the others. The edited configuration is used only once saved.", NULL) ;
  gtk_widget_show(b2) ;
  gtk_box_pack_start(GTK_BOX(hbox), b2, TRUE,0,0) ;

  gtk_widget_show(hbox) ;
  gtk_box_pack_start(GTK_BOX(vbox), hbox, 0,0,0) ;

  set_config_widget(gconfig->switchcase) ;

  return(vbox) ;
}

/*
 *
 */

GtkWidget *byebye_page(int i)
{
  GtkWidget *label ;

  label = gtk_label_new ("Program is running or asking you a question") ;
  return(label) ;
}

/*
 *
 */

void continue_update()
{
  char c ;

  c = G_CONTINUE ;
  write(ganswer,&c,1) ;
  unsensitivize_all() ;
  if ( can_not_write )
    {
      gtk_object_destroy(GTK_OBJECT(can_not_write)) ;
      can_not_write = NULL ;
    }
}

GtkWidget *question_page(int i)
{
  GtkWidget *hbox, *frame, *scrolled_window ;

  hbox = gtk_hbox_new(TRUE,5) ;
  gtk_container_border_width( GTK_CONTAINER(hbox), 5) ;

  pages[i].lrw = gtk_list_new() ;
  /*  gtk_widget_set_sensitive(pages[i].lrw, FALSE) ; */
  gtk_widget_show(pages[i].lrw) ;
  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),pages[i].lrw) ;
  gtk_widget_show(scrolled_window) ;
  frame = gtk_frame_new("Read/Write/Xchange") ;
  gtk_container_add(GTK_CONTAINER(frame), scrolled_window) ;
  gtk_widget_show(frame) ;
  gtk_box_pack_start( GTK_BOX(hbox), frame,TRUE,TRUE,0) ;

  pages[i].ldc = gtk_list_new() ;
  /*  gtk_widget_set_sensitive(pages[i].ldc, FALSE) ; */
  gtk_widget_show(pages[i].ldc) ;
  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),pages[i].ldc) ;
  gtk_widget_show(scrolled_window) ;
  frame = gtk_frame_new("Delete/Conflict") ;
  gtk_container_add(GTK_CONTAINER(frame),scrolled_window) ;
  gtk_widget_show(frame) ;
  gtk_box_pack_end( GTK_BOX(hbox), frame,TRUE,TRUE,0) ;



  return(hbox) ;
}

/*
 *
 */

void delete_medium_page()
{
  gtk_widget_set_sensitive(skip_reading, FALSE) ;
  gtk_widget_set_sensitive(ok_medium, FALSE) ;
}

void answer_function1()
{
  char c ;
  c = G_CONTINUE ;
  write(ganswer, &c, 1) ;
  delete_medium_page() ;
}
void answer_function0()
{
  char c ;
  c = G_ABORT_READING ;
  write(ganswer, &c, 1) ;
  delete_medium_page() ;
}


void medium_function(gpointer data, gint source, GdkInputCondition condition)
{
  char buf[G_LINE_CHUNK] ;
  char tmp[G_LINE_CHUNK] ;
  int nb ;
  static char last_name[G_LINE_CHUNK] = "" ;
  GList *gl ;

  nb = read(source,buf,G_LINE_CHUNK) ;

  if ( nb<=0 )
    {
      remove_end(&id_medium) ;
      return ;
    }
  if ( nb!=4 )
    {
      fprintf(stderr, "Impossible case : nb=%d\n", nb) ;
      exit(46) ;
    }
  buf[4] = '\0' ;
  if ( strcmp(last_name, ((char*)buf)+1) )
    {
      sprintf(tmp, "Medium %s is ready for %s",
	      buf+1, buf[0]=='R' ? "reading" : "writing") ;
    }
  else
    {
      if ( buf[0]=='R' )
	{
	  sprintf(tmp,
		  "ERROR! Reinsert medium %s",
		  buf+1) ;
	}
      else
	{
	  sprintf(tmp,
		  "ERROR! Reinsert medium %s",
		  buf+1) ;
	}
    }
  gl = gtk_container_children(GTK_CONTAINER(ok_medium)) ;
  gtk_label_set(GTK_LABEL((GtkWidget*)gl->data), tmp) ;
  g_list_free(gl) ;

  gtk_widget_set_sensitive(ok_medium, TRUE) ;

  if ( buf[0] == 'R' )
    gtk_widget_set_sensitive(skip_reading, TRUE) ;

  strcpy(last_name, ((char*)buf)+1) ;
}




/*
 ******************************************************************************
 */


struct pages pages[] =
{
  { "