Пример #1
0
static void
game_preferences_callback (GtkWidget *widget, void *data)
{
	GtkWidget *menu, *omenu, *l, *hb, *cb, *f, *fv;
	GtkWidget *button;

	if (pref_dialog)
		return;
	
	pref_dialog = gnome_dialog_new (_("Preferences"),
			GNOME_STOCK_BUTTON_OK, GNOME_STOCK_BUTTON_CANCEL,
			NULL);
	gnome_dialog_set_parent (GNOME_DIALOG (pref_dialog), GTK_WINDOW (app));
	gtk_signal_connect (GTK_OBJECT(pref_dialog), "delete_event",
			    GTK_SIGNAL_FUNC (cancel), NULL);

	omenu = gtk_option_menu_new ();
	menu = gtk_menu_new ();
	fill_menu (menu);
	gtk_widget_show (omenu);
	gtk_option_menu_set_menu (GTK_OPTION_MENU(omenu), menu);

	f = gtk_frame_new (_ ("Scenario"));
	gtk_container_border_width (GTK_CONTAINER (f), 5);

	hb = gtk_hbox_new (FALSE, FALSE);
	gtk_widget_show (hb);
	
	l = gtk_label_new (_("Select scenario:"));
	gtk_widget_show (l);
	    
	gtk_box_pack_start_defaults (GTK_BOX(hb), l);
	gtk_box_pack_start_defaults (GTK_BOX(hb), omenu);

	cb = gtk_check_button_new_with_label ( _("Make it the default scenario") );
	gtk_signal_connect (GTK_OBJECT(cb), "clicked", (GtkSignalFunc)set_selection_def, NULL);
	gtk_widget_show (cb);

	fv = gtk_vbox_new (0, 5);
	gtk_container_border_width (GTK_CONTAINER (fv), 5);
	gtk_widget_show (fv);
	
	gtk_box_pack_start_defaults (GTK_BOX(fv), hb);
	gtk_box_pack_start_defaults (GTK_BOX(fv), cb);
	gtk_box_pack_start_defaults (GTK_BOX(GNOME_DIALOG(pref_dialog)->vbox), f);
	gtk_container_add (GTK_CONTAINER (f), fv);
	
	gtk_widget_show (f);
	
	gnome_dialog_button_connect (GNOME_DIALOG (pref_dialog), 0,
			GTK_SIGNAL_FUNC (load_scenario_callback), NULL);
	gnome_dialog_button_connect (GNOME_DIALOG (pref_dialog), 1,
			GTK_SIGNAL_FUNC (cancel), (gpointer)1);

        gtk_widget_show (pref_dialog);
}
Пример #2
0
int main(int argc, char *argv[])
{
    GtkWidget *button;
    GtkWidget *app;

    //初始化
    gnome_init("Helloworld", "1.0", argc, argv);

    //建立主窗口
    app = gnome_app_new ("hello", "Hello World Gnomified");
    //gtk_widget_realize (app);
    gtk_signal_connect (GTK_OBJECT (app), "delete_event",
                        GTK_SIGNAL_FUNC (quit_cb), NULL);

    //建立GTK按钮组件
    button = gtk_button_new_with_label ("Hello World!");
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (hello_cb), NULL);
    gtk_container_border_width (GTK_CONTAINER (button), 60);

    //加入组件
    gnome_app_set_contents ( GNOME_APP (app), button);

    //显示组件
    gtk_widget_show (button);
    gtk_widget_show (app);

    gtk_main ();
    return 0;
}
Пример #3
0
int main (int argc, char *argv[])
{
  GtkWidget *window;
  GtkWidget *button;

  gtk_init (&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_signal_connect (GTK_OBJECT (window), "destroy",
                      GTK_SIGNAL_FUNC (destroy), NULL);
  gtk_container_border_width (GTK_CONTAINER (window), 10);

  button = gtk_button_new_with_label ("Hello World");

  gtk_signal_connect (GTK_OBJECT (button), "clicked",
                      GTK_SIGNAL_FUNC (hello), NULL);
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
                             GTK_OBJECT (window));
  gtk_container_add (GTK_CONTAINER (window), button);

  gtk_widget_show (button);
  gtk_widget_show (window);

  gtk_main ();
  return 0;
}
Пример #4
0
/* Create actual buttons */
GtkWidget *
create_discard_buttons (void)
{
GtkWidget *table;
GtkWidget *table2;
GtkWidget *frame;
GtkWidget *main_vbox;
GtkWidget *b1;
GtkWidget *b2;
GtkWidget *pixmapwid1, *pixmapwid2;

GtkTooltips *tooltips;

tooltips=gtk_tooltips_new_2();
gtk_tooltips_set_delay_2(tooltips,1500);

pixmapwid1=gtk_pixmap_new(larrow_pixmap, larrow_mask);
gtk_widget_show(pixmapwid1);
pixmapwid2=gtk_pixmap_new(rarrow_pixmap, rarrow_mask);
gtk_widget_show(pixmapwid2);
   
/* Create a table to hold the text widget and scrollbars */
table = gtk_table_new (1, 1, FALSE);

main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_container_add (GTK_CONTAINER (table), main_vbox);

frame = gtk_frame_new ("Disc ");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);

gtk_widget_show (frame);
gtk_widget_show (main_vbox);

table2 = gtk_table_new (2, 1, FALSE);

b1 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b1), pixmapwid1);
gtk_table_attach (GTK_TABLE (table2), b1, 0, 1, 0, 1,
			GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b1), "clicked",
              		GTK_SIGNAL_FUNC(discard_left), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b1, "Increase 'From' Time", NULL);
gtk_widget_show(b1);

b2 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b2), pixmapwid2);
gtk_table_attach (GTK_TABLE (table2), b2, 0, 1, 1, 2,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b2), "clicked",
               		GTK_SIGNAL_FUNC(discard_right), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b2, "Decrease 'To' Time", NULL);
gtk_widget_show(b2);

gtk_container_add (GTK_CONTAINER (frame), table2);
gtk_widget_show(table2);
return(table);
}
Пример #5
0
static void
show_tclist_dialog (GbWidgetNewData * data)
{
  GtkWidget *dialog, *vbox, *hbox, *label, *spinbutton;
  GtkObject *adjustment;

  dialog = glade_util_create_dialog (_("New tree columned list"), data->parent,
				     on_tclist_dialog_ok, data, &vbox);
  gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
		      GTK_SIGNAL_FUNC (on_tclist_dialog_destroy), data);

  hbox = gtk_hbox_new (FALSE, 5);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
  gtk_container_border_width (GTK_CONTAINER (hbox), 10);
  gtk_widget_show (hbox);

  label = gtk_label_new (_("Number of columns:"));
  gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 5);
  gtk_widget_show (label);

  adjustment = gtk_adjustment_new (3, 1, 100, 1, 10, 10);
  spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0);
  /* save pointer to spinbutton so we can find it easily in the OK handler */
  gtk_object_set_data (GTK_OBJECT (dialog), "cols", spinbutton);
  gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, TRUE, 5);
  gtk_widget_set_usize (spinbutton, 50, -1);
  gtk_widget_grab_focus (spinbutton);
  gtk_widget_show (spinbutton);

  gtk_widget_show (dialog);
  gtk_grab_add (dialog);
}
Пример #6
0
gint main (gint argc, gchar * argv[])
{
    GtkWidget *window;
    GtkWidget *button;

    //初始化
    gtk_set_locale ();
    gtk_init (&argc, &argv);
    //禁止 Ctrl-C
    (void)signal (SIGINT, SIG_IGN);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                        GTK_SIGNAL_FUNC (delete_event), window);
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
    gtk_container_border_width (GTK_CONTAINER (window), 10);

    button = gtk_button_new_with_label ("从窗口管理器关闭窗口");
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (hello), NULL);

    gtk_container_add (GTK_CONTAINER (window), button);
    gtk_widget_show (button);

    gtk_widget_show (window);
    gtk_main ();
    g_print ("Good Bye!\n");
    return 0;
}
Пример #7
0
/*
 * Función mostrarConsultaWindow()
 *
 * Parámetros de entrada:
 *      char * dir[3]: nombre direccion y telefono a mostrar
 *      
 * Parámetros de salida:
 *      Ninguno
 *
 * Descripción: 
 *      Mostrar en la pantalla una única consulta
 */
void mostrarConsultaWindow(char* dir[3])
{
    GtkWidget *datos;
    GtkWidget *window;
  
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_usize (GTK_WIDGET (window), 300, 300);
    gtk_window_set_policy(GTK_WINDOW (window), TRUE, TRUE, FALSE);      
    gtk_window_set_title (GTK_WINDOW (window), "Libro de direcciones");
    gtk_container_border_width (GTK_CONTAINER (window), 10);    
    gtk_widget_set_uposition( window, 300, 300 );   
  
    datos=gtk_clist_new(3);
    gtk_clist_set_column_title(GTK_CLIST(datos),0,"Nombre");    
    gtk_clist_set_column_title(GTK_CLIST(datos),1,"Direccion");
    gtk_clist_set_column_title(GTK_CLIST(datos),2,"Telefono");
    gtk_clist_column_titles_show(GTK_CLIST(datos));
    gtk_clist_set_column_width(GTK_CLIST(datos),0,100);
    gtk_clist_set_column_width(GTK_CLIST(datos),1,100);
    gtk_clist_set_column_width(GTK_CLIST(datos),2,50);          
    gtk_container_add (GTK_CONTAINER (window), datos); 
    gtk_clist_append(GTK_CLIST(datos),dir);   
    gtk_widget_show(datos);
    gtk_grab_add(window);
    gtk_widget_show(window);
} 
Пример #8
0
/*----------------------------------------------------------------------------------------------------------------------*/
void SaveAsS(GtkWidget *W,gpointer Unused)
{
GtkWidget *Label,*But,*Win;
char Str[MAX_FNAME_LENGTH+20];

if (strlen(FileX->Path)+strlen(FileX->TargetFile)+1>MAX_FNAME_LENGTH) 
   { Attention(0,"ERROR: MAX_FNAME_LENGTH exceeded"); return; }
sprintf(Setup.FName,"%s/%s",FileX->Path,FileX->TargetFile);
strcpy(SetupDir,FileX->Path); SavePrefs();                                                                   //Store path
g_free(FileX);

if (access(Setup.FName,0)==0) 
   {
   Win=gtk_dialog_new(); gtk_grab_add(Win);
   gtk_signal_connect_object(GTK_OBJECT(Win),"destroy",GTK_SIGNAL_FUNC(gtk_widget_destroy),GTK_OBJECT(Win));
   gtk_window_set_title(GTK_WINDOW(Win),"Overwrite?"); gtk_container_border_width(GTK_CONTAINER(Win),5);
   sprintf(Str,"Overwrite %s?",Setup.FName);
   Label=gtk_label_new(Str); gtk_misc_set_padding(GTK_MISC(Label),10,10);
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Win)->vbox),Label,TRUE,TRUE,0);
   But=gtk_button_new_with_label("Yes");
   gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(YesOverwrite),Win);
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Win)->action_area),But,TRUE,TRUE,0);
   But=gtk_button_new_with_label("No");
   gtk_signal_connect_object(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),GTK_OBJECT(Win));
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Win)->action_area),But,TRUE,TRUE,0);
   gtk_widget_show_all(Win);
   }
else Save(0);
}
Пример #9
0
int
main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *vpaned;
    GtkWidget *list;
    GtkWidget *text;

    gtk_init (&argc, &argv);
   
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
    gtk_container_border_width (GTK_CONTAINER (window), 10);
   
    /* vpaned widget을 만들어서 toplevel 윈도에 더한다. */
   
    vpaned = gtk_vpaned_new ();
    gtk_container_add (GTK_CONTAINER(window), vpaned);
    gtk_widget_show (vpaned);
   
    /* 이제 윈도 두 부분의 내용을 만든다. */
   
    list = create_list ();
    gtk_paned_add1 (GTK_PANED(vpaned), list);
    gtk_widget_show (list);
   
    text = create_text ();
    gtk_paned_add2 (GTK_PANED(vpaned), text);
    gtk_widget_show (text);
    gtk_widget_show (window);
    gtk_main ();
    return 0;
}
Пример #10
0
void init_ui(void) {
	int argc;
	char **argv;
	GtkWidget* dlg;
	
	disp = malloc(WWIDTH*WHEIGHT*3);	
	argc = 1;
	argv = g_new (gchar *, 1);
	argv[0] = g_strdup ("myprog");
	gtk_init (&argc, &argv);	
	gdk_rgb_init ();
	gtk_widget_set_default_visual (gdk_rgb_get_visual());
	gtk_widget_set_default_colormap (gdk_rgb_get_cmap());
	dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
	gtk_signal_connect (GTK_OBJECT (dlg), "destroy",	(GtkSignalFunc) gtk_main_quit, NULL);
	gtk_window_set_title (GTK_WINDOW (dlg), "FLYNN");
	eventbox = gtk_event_box_new();
	gtk_container_border_width (GTK_CONTAINER (eventbox), 0);
	gtk_container_add (GTK_CONTAINER (dlg), GTK_WIDGET (eventbox));
	drawing_area = gtk_drawing_area_new ();
	gtk_widget_set_usize (drawing_area, WWIDTH, WHEIGHT);
	gtk_container_add (GTK_CONTAINER (eventbox),
	GTK_WIDGET (drawing_area));	
	gtk_widget_show (drawing_area);
	gtk_widget_show (eventbox);	
	gtk_widget_add_events (dlg,
	GDK_KEY_PRESS_MASK);
	gtk_signal_connect (GTK_OBJECT (dlg), "key_press_event",	(GtkSignalFunc) key_press, NULL);
	gtk_widget_show (dlg);
	/* gdk_key_repeat_disable (); */
	/* gdk_keyboard_grab (eventbox->window, FALSE, time); */
}
Пример #11
0
/* Make the insides of a error, info or question dialog.
 */
static void
box_build( iDialog *idlg, 
	GtkWidget *work, char *s, const char *stock_id )
{	
	GtkWidget *icon;
	GtkWidget *hb;
	GtkWidget *lab;

	hb = gtk_hbox_new( FALSE, 12 );
	gtk_container_border_width( GTK_CONTAINER( hb ), 0 );
	gtk_container_add( GTK_CONTAINER( work ), hb );
	gtk_widget_show( hb );

	icon = gtk_image_new_from_stock( stock_id, GTK_ICON_SIZE_DIALOG );
	gtk_misc_set_alignment( GTK_MISC( icon ), 0.0, 0.0 );
        gtk_box_pack_start( GTK_BOX( hb ), icon, FALSE, FALSE, 0 );
	gtk_widget_show( icon );

	lab = gtk_label_new( NULL );
	gtk_label_set_markup( GTK_LABEL( lab ), s );
        gtk_label_set_justify( GTK_LABEL( lab ), GTK_JUSTIFY_LEFT );
        gtk_label_set_selectable( GTK_LABEL( lab ), TRUE );
	gtk_label_set_line_wrap( GTK_LABEL( lab ), TRUE );
        gtk_box_pack_start( GTK_BOX( hb ), lab, FALSE, FALSE, 0 );
	gtk_widget_show( lab );
}
Пример #12
0
/*-----------------------------------------------------------------------------------------------------------------------*/
void StartCallBack(GtkWidget *W,GtkWidget *StartWin)
{
GtkWidget *Win,*But,*Label;
gchar Str[MAX_FNAME_LENGTH+25];

gtk_widget_destroy(GTK_WIDGET(StartWin));

if (!access(RunName,F_OK)) 
   {
   Win=gtk_dialog_new(); gtk_grab_add(Win);
   gtk_signal_connect_object(GTK_OBJECT(Win),"destroy",GTK_SIGNAL_FUNC(gtk_widget_destroy),GTK_OBJECT(Win));
   gtk_window_set_title(GTK_WINDOW(Win),"Overwrite?"); gtk_container_border_width(GTK_CONTAINER(Win),5);
   gtk_widget_set_uposition(GTK_WIDGET(Win),400,400);
   sprintf(Str,"Overwrite %s?",RunName);
   Label=gtk_label_new(Str); gtk_misc_set_padding(GTK_MISC(Label),10,10);
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Win)->vbox),Label,TRUE,TRUE,0);
   But=gtk_button_new_with_label("Yes");
   gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(OverwriteStart),Win);
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Win)->action_area),But,TRUE,TRUE,0);
   But=gtk_button_new_with_label("Cancel");
   gtk_signal_connect_object(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),GTK_OBJECT(Win));
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Win)->action_area),But,TRUE,TRUE,0);
   gtk_widget_show_all(Win);
   return;
   } 
AcqOn=TRUE; StopSignal=FALSE;
pthread_create(&Acq,NULL,AcquireData,NULL);
}
Пример #13
0
void StartProgress(char *message, int canstop)
{
GtkWidget *label;
GtkWidget *table;
GtkWidget *window;
GtkAdjustment *adj;
GtkWidget *sbut;
GtkWidget *hseparator2;

pdata= g_malloc (sizeof (typProgressData));
pdata->nLastPct= -1;
pdata->bProgressUp=TRUE;

window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
pdata->window=window;

gtk_signal_connect(GTK_OBJECT (window), "delete_event",
              GTK_SIGNAL_FUNC ((gint)CanWindowClose), pdata);
gtk_container_border_width(GTK_CONTAINER (window),10);

table=gtk_table_new(4,2,TRUE);
gtk_container_add(GTK_CONTAINER(window),table);

label=gtk_label_new(message);
gtk_table_attach_defaults (GTK_TABLE(table),label,0,2,0,1);
gtk_widget_show(label);

adj= (GtkAdjustment *) gtk_adjustment_new (0,0,400,0,0,0);
pdata->progressbar= gtk_progress_bar_new_with_adjustment(adj);
gtk_table_attach_defaults(GTK_TABLE(table),pdata->progressbar,0,2,1,2);
gtk_widget_show(pdata->progressbar);

 if(canstop==TRUE) { 
   hseparator2 = gtk_hseparator_new ();
   gtk_widget_ref (hseparator2);
   gtk_object_set_data_full (GTK_OBJECT (window), "hseparator2", hseparator2,
			     (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (hseparator2);
   gtk_table_attach (GTK_TABLE (table), hseparator2, 0, 2, 2, 3,
		     (GtkAttachOptions) (GTK_FILL),
		     (GtkAttachOptions) (GTK_FILL), 0, 0);
   
   sbut = gtk_button_new_with_label (("stop me...!"));
   gtk_widget_ref (sbut);
   gtk_object_set_data_full (GTK_OBJECT (window), "sbut", sbut,
			     (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (sbut);
   gtk_table_attach (GTK_TABLE (table), sbut, 0, 2, 3, 4,
		     (GtkAttachOptions) (GTK_FILL),
		     (GtkAttachOptions) (GTK_FILL), 0, 0);
   gtk_signal_connect (GTK_OBJECT (sbut), "clicked",GTK_SIGNAL_FUNC (stop_process),NULL);
 }

gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_widget_show(table);
 gtk_grab_add (window);
gtk_widget_show(window);

}
// Create new game dialog
void new_game_dialog_init(void)
{
        GtkWidget *vbox, *hbox, *w;

        vbox = gtk_vbox_new(FALSE, 4);

        /* Stock games */
        ngd_combo = gtk_combo_box_new_text();
        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Tic Tac Toe");
        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Go Moku");
        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Connect 6");
        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Custom");
        gtk_combo_box_set_active(GTK_COMBO_BOX(ngd_combo), 2);
        gtk_box_pack_start(GTK_BOX(vbox), ngd_combo, FALSE, FALSE, 0);
        g_signal_connect(ngd_combo, "changed", G_CALLBACK(new_game_set_combo),
                         NULL);

        // Parameters
        hbox = labeled_spin_new("Board size:", 2., MAX_BOARD_SIZE, 19.,
                                &ngd_board_size, new_game_set_custom);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
        hbox = labeled_spin_new("Connect to win:", 2., MAX_CONNECT_K, 6.,
                                &ngd_connect_k, new_game_set_custom);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
        hbox = labeled_spin_new("Moves per turn:", 1., MAX_PLACE_P, 2.,
                                &ngd_place_p, new_game_set_custom);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
        hbox = labeled_spin_new("Starting moves:", 1., MAX_START_Q, 1.,
                                &ngd_start_q, new_game_set_custom);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Separator */
        w = gtk_vbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), w, FALSE, FALSE, 4);

        /* Cancel/Ok buttons */
        hbox = gtk_hbox_new(TRUE, 4);
        w = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
        g_signal_connect(G_OBJECT(w), "clicked",
                         G_CALLBACK(new_game_dialog_cancel), NULL);
        gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);
        w = gtk_button_new_from_stock(GTK_STOCK_OK);
        g_signal_connect(G_OBJECT(w), "clicked",
                         G_CALLBACK(new_game_dialog_ok), NULL);
        gtk_box_pack_end(GTK_BOX(hbox), w, TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        // Create dialog window
        new_game_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        g_signal_connect(G_OBJECT(new_game_dialog), "delete-event",
                         G_CALLBACK(gtk_widget_hide_on_delete), NULL);
        gtk_window_set_title(GTK_WINDOW(new_game_dialog), "New game...");
        gtk_window_set_transient_for(GTK_WINDOW(new_game_dialog),
                                     GTK_WINDOW(window));
        gtk_window_set_modal(GTK_WINDOW(new_game_dialog), TRUE);
        gtk_window_set_resizable(GTK_WINDOW(new_game_dialog), FALSE);
        gtk_container_add(GTK_CONTAINER(new_game_dialog), vbox);
        gtk_container_border_width(GTK_CONTAINER(new_game_dialog), 12);
}
Пример #15
0
void *thread_fn(void *_arg)
{
	GtkWidget *window;
	GtkWidget *table;
	GtkWidget *labl1, *labl2, *labl3;

	gtk_init(NULL, NULL);

	/* Create the main window */
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_signal_connect(GTK_OBJECT(window), "delete_event",
			GTK_SIGNAL_FUNC(destroy), NULL);
	gtk_container_border_width(GTK_CONTAINER(window), 10);
	gtk_window_set_title(GTK_WINDOW(window), "Status");
	gtk_window_set_resizable(GTK_WINDOW(window), FALSE);

	/* Create a packing box */
	table = gtk_table_new(3, 2, FALSE);
	gtk_table_set_row_spacings(GTK_TABLE(table), 5);
	gtk_table_set_col_spacings(GTK_TABLE(table), 5);
	gtk_container_add(GTK_CONTAINER(window), table);
	gtk_widget_show(table);

	/* Create the progress bars */
	labl1 = gtk_label_new("Connection queue:");
	pbar1 = gtk_progress_bar_new();
	labl2 = gtk_label_new("Verification queue:");
	pbar2 = gtk_progress_bar_new();
	labl3 = gtk_label_new("Whitelist queue:");
	pbar3 = gtk_progress_bar_new();

	/* Attach the widgets */
	gtk_misc_set_alignment(GTK_MISC(labl1), 1.0, 0.5);
	gtk_misc_set_alignment(GTK_MISC(labl2), 1.0, 0.5);
	gtk_misc_set_alignment(GTK_MISC(labl3), 1.0, 0.5);

	gtk_table_attach(GTK_TABLE(table), labl1, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), labl2, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), labl3, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach_defaults(GTK_TABLE(table), pbar1, 1, 2, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), pbar2, 1, 2, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), pbar3, 1, 2, 2, 3);

	gtk_widget_show(pbar1);
	gtk_widget_show(pbar2);
	gtk_widget_show(pbar3);
	gtk_widget_show(labl1);
	gtk_widget_show(labl2);
	gtk_widget_show(labl3);

	gtk_widget_show(window);

	/* Set an update timer */
	g_timeout_add(100, update_fn, NULL);
	gtk_main();

	return NULL;
}
Пример #16
0
GtkWidget * create_jpeg_gui()
{

	printf("creating jpeg gui\n");

	GtkWidget *label;
	GtkWidget *tab_box;
	GtkWidget *jpeg_compress_check_button;
	GtkWidget *jpeg_compress_hscale;
	GtkObject *jpeg_compress_value;
	GtkWidget *jpeg_threshold_hscale;
	GtkObject *jpeg_threshold_value;

	label = gtk_label_new ("Jpeg");

	//so this is the page
	tab_box = gtk_vbox_new (FALSE, 6);

	gtk_container_border_width (GTK_CONTAINER (tab_box), 10);
	gtk_widget_set_size_request (tab_box, 200, 150);
	gtk_widget_show (tab_box);
	//this is the button i want to add to the page
	jpeg_compress_check_button = gtk_check_button_new_with_label ( "Find Jpeg Age");
	gtk_widget_set_size_request (jpeg_compress_check_button, 200, 50);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(jpeg_compress_check_button), FALSE);
	gtk_widget_show (jpeg_compress_check_button);
	//i add the button to the page
	gtk_container_add (GTK_CONTAINER (tab_box), jpeg_compress_check_button);
	//then add the page to the notbook


	jpeg_compress_value = gtk_adjustment_new (jpeg_compress, 0, 1.0, .01, .01, .01);
	jpeg_compress_hscale = gtk_hscale_new (GTK_ADJUSTMENT (jpeg_compress_value));
	gtk_scale_set_digits( GTK_SCALE(jpeg_compress_hscale), 3);
	//  gtk_range_set_update_policy      (GtkRange      *range,   GtkUpdateType  policy);
	gtk_widget_set_size_request (jpeg_compress_hscale, 100, 50);
	gtk_widget_show (jpeg_compress_hscale);

	gtk_container_add (GTK_CONTAINER (tab_box), jpeg_compress_hscale);


	jpeg_threshold_value = gtk_adjustment_new (jpeg_threshold, 0, 255, 1, 1, 1);
	jpeg_threshold_hscale = gtk_hscale_new (GTK_ADJUSTMENT (jpeg_threshold_value));
	gtk_scale_set_digits( GTK_SCALE(jpeg_threshold_hscale), 0);
	//  gtk_range_set_update_policy      (GtkRange      *range,   GtkUpdateType  policy);
	gtk_widget_set_size_request (jpeg_threshold_hscale, 100, 50);
	gtk_widget_show (jpeg_threshold_hscale);

	gtk_container_add (GTK_CONTAINER (tab_box), jpeg_threshold_hscale);

	g_signal_connect (jpeg_compress_check_button, "clicked", G_CALLBACK (cb_jpeg_compress_check_button), &jpeg_plugin.checked);
	g_signal_connect (GTK_OBJECT (jpeg_compress_value), "value_changed", G_CALLBACK (gimp_float_adjustment_update), &jpeg_compress);
	g_signal_connect (GTK_OBJECT (jpeg_threshold_value), "value_changed", G_CALLBACK (gimp_int_adjustment_update), &jpeg_threshold);

	printf("jpeg compress gui created\n");

	return tab_box;
}
Пример #17
0
/* main ルーチン
 */
int main( int argc, char *argv[] ) {
    GtkWidget *window, *table, *area, *hrule, *vrule;

    /* gtk を初期化、メインウィンドウを作成する */
    gtk_init( &argc, &argv );

    window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
            GTK_SIGNAL_FUNC( close_application ), NULL);
    gtk_container_border_width (GTK_CONTAINER (window), 10);

    /* ルーラとドローイングエリアを配置するテーブルを作成 */
    table = gtk_table_new( 3, 2, FALSE );
    gtk_container_add( GTK_CONTAINER(window), table );

    area = gtk_drawing_area_new();
    gtk_drawing_area_size( (GtkDrawingArea *)area, XSIZE, YSIZE );
    gtk_table_attach( GTK_TABLE(table), area, 1, 2, 1, 2,
                      GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0 );
    gtk_widget_set_events( area, GDK_POINTER_MOTION_MASK |
                                  GDK_POINTER_MOTION_HINT_MASK );

    /* 水平ルーラは上に置かれる。マウスがドローイングエリアを横切って
     * 移動すると、motion_notify_event がこのルーラの対応するイベント
     * ハンドラに渡される。*/
    hrule = gtk_hruler_new();
    gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
    gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
    gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
                               (GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
                               GTK_OBJECT(hrule) );
    /*  GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
    gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
                      GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
    
    /* 垂直ルーラは左に置かれる。マウスがドローイングエリアを横切って
     * 移動すると、motion_notify_event がこのルーラの対応するイベント
     * ハンドラに渡される。*/
    vrule = gtk_vruler_new();
    gtk_ruler_set_metric( GTK_RULER(vrule), GTK_PIXELS );
    gtk_ruler_set_range( GTK_RULER(vrule), 0, YSIZE, 10, YSIZE );
    gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
                               (GtkSignalFunc)
                                  GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)->motion_notify_event,
                               GTK_OBJECT(vrule) );
    gtk_table_attach( GTK_TABLE(table), vrule, 0, 1, 1, 2,
                      GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0 );

    /* では全てを表示しよう */
    gtk_widget_show( area );
    gtk_widget_show( hrule );
    gtk_widget_show( vrule );
    gtk_widget_show( table );
    gtk_widget_show( window );
    gtk_main();

    return 0;
}
Пример #18
0
/* Create shift buttons */
GtkWidget *
create_edge_buttons (void)
{
GtkWidget *table;
GtkWidget *table2;
GtkWidget *frame;
GtkWidget *main_vbox;
GtkWidget *b1;
GtkWidget *b2;
GtkWidget *pixmapwid1, *pixmapwid2;

GtkTooltips *tooltips;

tooltips=gtk_tooltips_new_2();
gtk_tooltips_set_delay_2(tooltips,1500);

pixmapwid1=gtk_pixmap_new(GLOBALS->larrow_pixmap, GLOBALS->larrow_mask);
gtk_widget_show(pixmapwid1);
pixmapwid2=gtk_pixmap_new(GLOBALS->rarrow_pixmap, GLOBALS->rarrow_mask);
gtk_widget_show(pixmapwid2);

/* Create a table to hold the text widget and scrollbars */
table = gtk_table_new (1, 1, FALSE);

main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_container_add (GTK_CONTAINER (table), main_vbox);

frame = gtk_frame_new ("Edge ");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);

gtk_widget_show (frame);
gtk_widget_show (main_vbox);

table2 = gtk_table_new (2, 1, FALSE);

b1 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b1), pixmapwid1);
gtk_table_attach (GTK_TABLE (table2), b1, 0, 1, 0, 1,
			GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b1), "clicked", GTK_SIGNAL_FUNC(service_left_edge), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b1, "Find next transition of highlighted trace scanning left", NULL);
gtk_widget_show(b1);

b2 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b2), pixmapwid2);
gtk_table_attach (GTK_TABLE (table2), b2, 0, 1, 1, 2,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b2), "clicked", GTK_SIGNAL_FUNC(service_right_edge), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b2, "Find next transition of highlighted trace scanning right", NULL);
gtk_widget_show(b2);

gtk_container_add (GTK_CONTAINER (frame), table2);
gtk_widget_show(table2);
return(table);
}
Пример #19
0
int main (int argc, char *argv[])
{
    GtkWidget *ventana;
    GtkWidget *boton;
    GtkWidget *table;

    gtk_init (&argc, &argv);

    ventana = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    gtk_window_set_title (GTK_WINDOW (ventana), "Table");

    gtk_signal_connect (GTK_OBJECT (ventana), "delete_event",
                        GTK_SIGNAL_FUNC (delete_event), NULL);

    gtk_container_border_width (GTK_CONTAINER (ventana), 20);

    table = gtk_table_new (2, 2, TRUE);

    gtk_container_add (GTK_CONTAINER (ventana), table);

    boton = gtk_button_new_with_label ("reproduir ");

    gtk_signal_connect (GTK_OBJECT (boton), "clicked",
              GTK_SIGNAL_FUNC (rep),NULL); 

    gtk_table_attach_defaults (GTK_TABLE(table), boton, 0, 1, 0, 1);

    gtk_widget_show (boton);

    boton = gtk_button_new_with_label ("veure llista");

    gtk_signal_connect (GTK_OBJECT (boton), "clicked",
              GTK_SIGNAL_FUNC (vllista),NULL);
			  
    gtk_table_attach_defaults (GTK_TABLE(table), boton, 1, 2, 0, 1);

    gtk_widget_show (boton);

    boton = gtk_button_new_with_label ("Surt");

    gtk_signal_connect (GTK_OBJECT (boton), "clicked",
                        GTK_SIGNAL_FUNC (delete_event), NULL);
	
    gtk_table_attach_defaults (GTK_TABLE(table), boton, 0, 2, 1, 2);

    gtk_widget_show (boton);

    gtk_widget_show (table);
    gtk_widget_show (ventana);

    gtk_main ();

    return 0;
}
Пример #20
0
/*
 * CreateNotebook
 *
 * Create a new notebook and add pages to it.
 *
 * window - window to create the notebook in.
 */
static void CreateNotebook (GtkWidget *window, 
                            GtkPositionType pos)
{
    GtkWidget *widget;
    GtkWidget *box1;
    GtkWidget *notebook;

    /* --- Let us know when getting destroyed. --- */
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
			  &window);

    /* --- Set border width --- */
    gtk_container_border_width (GTK_CONTAINER (window), 0);

    box1 = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (window), box1);

    /* --- Create the notebook --- */
    notebook = gtk_notebook_new ();

    /* --- Listen for the switch page event --- */
    gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
			  GTK_SIGNAL_FUNC (PageSwitch), NULL);

    /* --- Make sure tabs are set on correct side --- */
    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos);

    /* --- Add notebook to vbox --- */
    gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);

    /* --- Give notebook a border --- */
    gtk_container_border_width (GTK_CONTAINER (notebook), 10);
   
    /* --- Add pages to the notebook --- */
    widget = AddPage (notebook, "Groups");
    widget = AddPage (notebook, "Users");
    widget = AddPage (notebook, "Todo");
      
    /* --- Show everything. --- */
    gtk_widget_show_all (window);
}
Пример #21
0
int main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *label;
    GtkWidget *table;
    GtkWidget *pbar;
    
    gtk_init (&argc, &argv);
    
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                        GTK_SIGNAL_FUNC (destroy), NULL);
    
    gtk_container_border_width (GTK_CONTAINER (window), 10);
    
    table = gtk_table_new(3,2,TRUE);
    gtk_container_add (GTK_CONTAINER (window), table);
    
    label = gtk_label_new ("Progress Bar Example");
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
    gtk_widget_show(label);
    
    /* 新しいプログレスバーを作成し、テーブルの中にパックし、表示する */
    pbar = gtk_progress_bar_new ();
    gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
    gtk_widget_show (pbar);
    
    /* プログレスバーの自動更新をを扱うためにタイムアウトを設定する */
    ptimer = gtk_timeout_add (100, progress, pbar);
    
    /* このボタンはプログレスバーをリセットするシグナルを発行する */
    button = gtk_button_new_with_label ("Reset");
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (progress_r), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label ("Cancel");
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (destroy), NULL);
    
    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
    gtk_widget_show (button);
    
    gtk_widget_show(table);
    gtk_widget_show(window);
    
    gtk_main ();
    
    return 0;
}
Пример #22
0
GtkWidget *
create_signalwindow(void)
{
GtkWidget *table;
GtkWidget *frame;

table = gtk_table_new(10, 10, FALSE);

signalarea=gtk_drawing_area_new();

gtk_widget_show(signalarea);
MaxSignalLength();

gtk_widget_set_events(signalarea, 
		GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | 
		GDK_BUTTON_RELEASE_MASK | 
		GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
		);

gtk_signal_connect(GTK_OBJECT(signalarea), "configure_event",
                        GTK_SIGNAL_FUNC(signalarea_configure_event), NULL);
gtk_signal_connect(GTK_OBJECT(signalarea), "expose_event",
                        GTK_SIGNAL_FUNC(expose_event), NULL);
gtk_signal_connect(GTK_OBJECT(signalarea), "button_press_event",
                        GTK_SIGNAL_FUNC(button_press_event), NULL);
gtk_signal_connect(GTK_OBJECT(signalarea), "button_release_event",
                        GTK_SIGNAL_FUNC(button_release_event), NULL);
gtk_signal_connect(GTK_OBJECT(signalarea), "motion_notify_event",
                        GTK_SIGNAL_FUNC(motion_notify_event), NULL);

gtk_table_attach (GTK_TABLE (table), signalarea, 0, 10, 0, 9,
                        GTK_FILL | GTK_EXPAND,
                        GTK_FILL | GTK_EXPAND | GTK_SHRINK, 3, 3);

signal_hslider=gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
gtk_signal_connect(GTK_OBJECT(signal_hslider), "value_changed",
                        GTK_SIGNAL_FUNC(service_hslider), NULL);
hscroll=gtk_hscrollbar_new(GTK_ADJUSTMENT(signal_hslider));
gtk_widget_show(hscroll);
gtk_table_attach (GTK_TABLE (table), hscroll, 0, 10, 9, 10,
                        GTK_FILL,
                        GTK_FILL | GTK_SHRINK, 3, 3);
gtk_widget_show(table);

frame=gtk_frame_new("Signals");
gtk_container_border_width(GTK_CONTAINER(frame),2);

gtk_container_add(GTK_CONTAINER(frame),table);

return(frame);
}
Пример #23
0
GtkWidget *slider_int_new(char *label_str, int *data, int lower, int upper,
			  int vert)
{
	Slider *slider;
	GtkWidget *label;

	slider = gtk_type_new(slider_get_type());

	gtk_container_border_width(GTK_CONTAINER(slider), 1);

	slider->type = SLIDER_TYPE_INT;
	slider->data.iptr = data;

	snprintf(slider->value_str, sizeof(slider->value_str), "%d",
		 *data);
	slider->value_label = gtk_label_new(slider->value_str);
	gtk_box_pack_start(GTK_BOX(slider), slider->value_label, FALSE,
			   TRUE, 0);
	gtk_widget_show(slider->value_label);

	slider->adj = gtk_adjustment_new((gfloat) (lower + upper - *data),
					 (gfloat) lower, (gfloat) upper,
					 1.0, 1.0, 0.0);

	if (vert) {
		slider->scale =
		    GTK_SCALE(gtk_vscale_new(GTK_ADJUSTMENT(slider->adj)));
		/* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 16, 120); */
	} else {
		slider->scale =
		    GTK_SCALE(gtk_hscale_new(GTK_ADJUSTMENT(slider->adj)));
		/* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 120, 16); */
	}
	gtk_box_pack_start(GTK_BOX(slider), GTK_WIDGET(slider->scale),
			   TRUE, TRUE, 0);
	gtk_range_set_update_policy(GTK_RANGE(slider->scale),
				    GTK_UPDATE_CONTINUOUS);

	/* draw number above scale */
	gtk_scale_set_draw_value(GTK_SCALE(slider->scale), FALSE);

	g_signal_connect(G_OBJECT(slider->adj), "value_changed",
			 G_CALLBACK(slider_cb), slider);
	gtk_widget_show(GTK_WIDGET(slider->scale));

	label = gtk_label_new(label_str);
	gtk_box_pack_start(GTK_BOX(slider), label, FALSE, FALSE, 0);
	gtk_widget_show(label);

	return GTK_WIDGET(slider);
}
Пример #24
0
void InputDialog(char *prompt,char *default_str,int len,char *doit,
		 GtkSignalFunc doitfunc,
		 char *cancel,GtkSignalFunc cancelfunc)
{
  GtkWidget *dialog;
  GtkWidget *label;
  GtkWidget *doitbutton;
  GtkWidget *cancelbutton;
  GtkWidget *entry;

  dialog=gtk_dialog_new();

  gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),5);

  label=gtk_label_new(prompt);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),label,TRUE,TRUE,0);
  gtk_widget_show(label);

  entry=gtk_entry_new_with_max_length(len);
  if(default_str) gtk_entry_set_text(GTK_ENTRY(entry),default_str);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),entry,TRUE,TRUE,0);
  gtk_widget_show(entry);

  doitbutton=gtk_button_new_with_label(doit);
  if(doitfunc)
    gtk_signal_connect(GTK_OBJECT(doitbutton),"clicked",
		       doitfunc,(gpointer)entry);
  gtk_signal_connect_object(GTK_OBJECT(doitbutton),"clicked",
			    GTK_SIGNAL_FUNC(gtk_widget_destroy),
			    GTK_OBJECT(dialog));
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),doitbutton,
		     TRUE,TRUE,0);
  gtk_widget_show(doitbutton);

  if(cancel) {
    cancelbutton=gtk_button_new_with_label(cancel);
    if(cancelfunc)
      gtk_signal_connect(GTK_OBJECT(cancelbutton),"clicked",
			 cancelfunc,NULL);
    gtk_signal_connect_object(GTK_OBJECT(cancelbutton),"clicked",
			      GTK_SIGNAL_FUNC(gtk_widget_destroy),
			      GTK_OBJECT(dialog));
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),cancelbutton,
		       TRUE,TRUE,0);
    gtk_widget_show(cancelbutton);
  }

  gtk_widget_show(dialog);

  gtk_grab_add(dialog);
}
Пример #25
0
void rep(GtkWidget *widget, GdkEvent *event, gpointer data)
{
	
	
	GtkWidget *ventana;
    GtkWidget *boton;
    GtkWidget *table;
	
	//g_print("Has clicat el boto de reproduir\n"); 
	ventana= gtk_window_new (GTK_WINDOW_POPUP);

    gtk_window_set_title (GTK_WINDOW (ventana), "Reproduccio");

    gtk_signal_connect (GTK_OBJECT (ventana), "clicked",
                        GTK_SIGNAL_FUNC (tanca_finestra), NULL);

    gtk_container_border_width (GTK_CONTAINER (ventana), 20);

    table = gtk_table_new (2, 2, TRUE);

    gtk_container_add (GTK_CONTAINER (ventana), table);

    boton = gtk_button_new_with_label ("reprodueix la canco actual ");

    gtk_signal_connect (GTK_OBJECT (boton), "clicked",
              GTK_SIGNAL_FUNC (rep),NULL); 

    gtk_table_attach_defaults (GTK_TABLE(table), boton, 0, 1, 0, 1);
	gtk_table_attach_defaults (GTK_TABLE(table), boton, 1, 2, 0, 1);

    gtk_widget_show (boton);

	boton = gtk_button_new_with_label ("Surt");

	gtk_signal_connect_object (GTK_OBJECT (boton), "clicked",   GTK_SIGNAL_FUNC (gtk_widget_destroy),
			     GTK_OBJECT (ventana));
 
						
    gtk_table_attach_defaults (GTK_TABLE(table), boton, 0, 2, 1, 2);

    gtk_widget_show (boton);

    gtk_widget_show (table);
    gtk_widget_show (ventana);

    gtk_main ();

	
	
}
Пример #26
0
static GtkWindow *create_window()
{
    GtkWindow *window;
    GtkBox *vbox;
    GtkButton *btn_abort;
    GtkAlignment *align;
    char buf[256];

    window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
    gtk_window_set_title(window, "File Sender");

    /* padding */
    gtk_container_border_width(GTK_CONTAINER(window), 10);

    /* hide max/min button */
    gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DIALOG);

    /* disable close button */
    gtk_window_set_deletable(window, FALSE);

    /* modal */
    gtk_window_set_modal(window, TRUE);

    vbox = GTK_BOX(gtk_vbox_new(FALSE, 10));

    sprintf(buf, "Sending file %s...", filename);
    lb_message = GTK_LABEL(gtk_label_new(buf));
    gtk_box_pack_start(vbox, GTK_WIDGET(lb_message), FALSE, FALSE, 0);

    lb_progress = GTK_LABEL(gtk_label_new("0 / 0"));
    gtk_box_pack_start(vbox, GTK_WIDGET(lb_progress), FALSE, FALSE, 0);

    lb_status = GTK_LABEL(gtk_label_new("INIT"));
    gtk_box_pack_start(vbox, GTK_WIDGET(lb_status), FALSE, FALSE, 0);

    btn_abort = GTK_BUTTON(gtk_button_new_with_label("Abort!"));
    gtk_widget_set_size_request(GTK_WIDGET(btn_abort), 100, 40);
    g_signal_connect(
        GTK_OBJECT(btn_abort), "clicked",
	GTK_SIGNAL_FUNC(cb_abort), NULL);

    align = GTK_ALIGNMENT(gtk_alignment_new(0.5, 0.5, 0, 0));
    gtk_container_add(GTK_CONTAINER(align), GTK_WIDGET(btn_abort));
    gtk_box_pack_start(vbox, GTK_WIDGET(align), FALSE, FALSE, 0);

    gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(vbox));
    gtk_widget_show_all(GTK_WIDGET(window));

    return window;
}
Пример #27
0
void _start(void){
GtkWidget *window, *box, *button;

	/* Preload the GUI */
	gtk_init(0, 0);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), "Jump2Pattern test");
	gtk_container_border_width(GTK_CONTAINER(window), 10);
	box = gtk_hbox_new(0, 5);
	gtk_container_add(GTK_CONTAINER(window), box);
	button = gtk_button_new_with_label("1");
	gtk_widget_set_usize(button, 30, 30);
	gtk_signal_connect(GTK_OBJECT(button), "clicked",
	   GTK_SIGNAL_FUNC(play_pattern), track);     /* Play Track #1 */
	gtk_box_pack_start(GTK_BOX(box), button, 0, 0, 0);
	gtk_widget_show(button);
	button = gtk_button_new_with_label("2");
	gtk_widget_set_usize(button, 30, 30);
	gtk_signal_connect(GTK_OBJECT(button), "clicked",
	   GTK_SIGNAL_FUNC(play_pattern), track + 1); /* Play Track #2 */
	gtk_box_pack_start(GTK_BOX(box), button, 0, 0, 0);
	gtk_widget_show(button);
	button = gtk_button_new_with_label("3");
	gtk_widget_set_usize(button, 30, 30);
	gtk_signal_connect(GTK_OBJECT(button), "clicked",
	   GTK_SIGNAL_FUNC(play_pattern), track + 2); /* Play Track #3 */
	gtk_box_pack_start(GTK_BOX(box), button, 0, 0, 0);
	gtk_widget_show(button);
	button = gtk_button_new_with_label("Pause");
	gtk_widget_set_usize(button, 72, 30);
	gtk_signal_connect(GTK_OBJECT(button), "clicked",
	   GTK_SIGNAL_FUNC(pause_resume), 0);         /* Pause/Resume */
	gtk_box_pack_start(GTK_BOX(box), button, 0, 0, 0);
	gtk_widget_show(button);
	gtk_signal_connect(GTK_OBJECT(window), "destroy",
	   GTK_SIGNAL_FUNC(quit), 0);                 /* Exit on close */
	gtk_widget_show(box);
	window_prevent_resize(window);

	/* Start playback */
	if(uFMOD_PlaySong(xm, sizeof(xm), XM_MEMORY)){

		/* Show the GUI and start processing events. */
		gtk_widget_show(window);
		gtk_main();
	}else
		write(1, error, sizeof(error) - 1);
	_exit(0);
}
Пример #28
0
int make_list_window(){

    GtkWidget *list_window;
    GtkWidget *button;
    GtkWidget *table;
    int i;

    list_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (list_window), "Card List");

    gtk_container_border_width (GTK_CONTAINER (list_window), 10);

    table = gtk_table_new (5, 5, TRUE);
    gtk_container_add (GTK_CONTAINER (list_window), table);

    //ボタン作成
    for(i=0;card_list[i].num<999;i++){
        button = gtk_button_new_with_label (card_list[i].name);
        gtk_signal_connect (GTK_OBJECT (button), "clicked",
                GTK_SIGNAL_FUNC (card_clicked), (gpointer)card_list[i].name);  
        
        gtk_table_attach_defaults (GTK_TABLE(table), button, i/5, (i/5)+1, i%5, (i%5)+1);
    switch(card_list[i].type){
        case GRAY:
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &gray);
break;
        case BLUE:
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &blue);
break;
        case GREEN:
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &green);
break;
        case YELLOW:
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &yellow);
break;
        case RED:

gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &red);
break;
    }        
        gtk_widget_show(button);
    }
    gtk_widget_show (table);

    gtk_widget_show (list_window);

    return;
}
Пример #29
0
//
// Program starts here
//
int main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *combo;
    GtkWidget *box;
    GtkWidget *vbox;
    GtkWidget *widget;
    
    // --- GTK initialization
    gtk_init (&argc, &argv);
    
    // --- Create the top level window
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    // --- You should always remember to connect the destroy event
    //     to the main window.
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
			GTK_SIGNAL_FUNC (delete_event), NULL);

    // --- Give the window a border
    gtk_container_border_width (GTK_CONTAINER (window), 10);

    // --- Create a new vbox - 
    vbox = gtk_vbox_new (FALSE, 3);

    // --- Create an edit field
    widget = CreateEditField ();
    gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 10);
    
    // --- Create a combo box.
    combo = CreateCombobox ();
    gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 10);

    // --- Create a drop down list.
    box = CreateMenuCombobox ();
    gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 10);

    // --- Add the box and make it visible
    gtk_widget_show (vbox);

    // --- Make the main window visible
    gtk_container_add (GTK_CONTAINER (window), vbox);
    gtk_widget_show (window);

    gtk_main ();
    exit (0);
}
Пример #30
0
/*----------------------------------------------------------------------*/
int
static qm_configure(void)
{
    GtkWidget *dialog;
    GtkWidget *button;
    GtkWidget *buttonbox;

    DB(_("qm_configure\n"));

    /* Set the Window Dialog up */
    dialog = gtk_window_new(GTK_WINDOW_DIALOG);
    gtk_window_set_title(GTK_WINDOW(dialog), "Camera Configuration");
    gtk_window_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);

    /* Set the buttonbox up */
    buttonbox = gtk_hbutton_box_new();
    gtk_container_border_width(GTK_CONTAINER(buttonbox), 10);

    /* One nice button which calls formatCf please... */
    button = gtk_button_new_with_label ( "Format CF Card" );
    gtk_signal_connect ( GTK_OBJECT(button), "clicked",
                         GTK_SIGNAL_FUNC(qm_formatCF),
                         NULL);

    gtk_signal_connect_object ( GTK_OBJECT(button), "clicked",
                                GTK_SIGNAL_FUNC(gtk_widget_destroy),
                                GTK_OBJECT(dialog) );

    gtk_container_add ( GTK_CONTAINER(buttonbox), GTK_WIDGET(button));
    gtk_widget_show ( button );

    /* Another to kill this whole window if you will Sir */
    button = gtk_button_new_with_label ( " Cancel " );
    gtk_signal_connect_object ( GTK_OBJECT(button), "clicked",
                                GTK_SIGNAL_FUNC(gtk_widget_destroy),
                                GTK_OBJECT(dialog) );
    gtk_container_add ( GTK_CONTAINER(buttonbox), GTK_WIDGET(button));
    gtk_widget_show ( button );

    /* Stick the buttonbox to the window and show it all */
    gtk_container_add ( GTK_CONTAINER(dialog), GTK_WIDGET(buttonbox));
    gtk_widget_show( buttonbox );
    gtk_widget_show ( dialog );

    return ANS_OK;
}