示例#1
0
文件: gtkmisc.c 项目: ciqdj/PuTTY
void our_dialog_set_action_area(GtkWindow *dlg, GtkWidget *w)
{
#if !GTK_CHECK_VERSION(2,0,0)

    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->action_area),
                       w, TRUE, TRUE, 0);

#elif !GTK_CHECK_VERSION(3,0,0)

    GtkWidget *align;
    align = gtk_alignment_new(0, 0, 1, 1);
    gtk_container_add(GTK_CONTAINER(align), w);
    /*
     * The purpose of this GtkAlignment is to provide padding
     * around the buttons. The padding we use is twice the padding
     * used in our GtkColumns, because we nest two GtkColumns most
     * of the time (one separating the tree view from the main
     * controls, and another for the main controls themselves).
     */
#if GTK_CHECK_VERSION(2,4,0)
    gtk_alignment_set_padding(GTK_ALIGNMENT(align), 8, 8, 8, 8);
#endif
    gtk_widget_show(align);
    gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
                     align, FALSE, TRUE, 0);

    w = gtk_hseparator_new();
    gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
                     w, FALSE, TRUE, 0);
    gtk_widget_show(w);
    gtk_widget_hide(gtk_dialog_get_action_area(GTK_DIALOG(dlg)));
    g_object_set(G_OBJECT(dlg), "has-separator", TRUE, (const char *)NULL);

#else /* GTK 3 */

    /* GtkWindow is a GtkBin, hence contains exactly one child, which
     * here we always expect to be a vbox */
    GtkBox *vbox = GTK_BOX(gtk_bin_get_child(GTK_BIN(dlg)));
    GtkWidget *sep;

    g_object_set(G_OBJECT(w), "margin", 8, (const char *)NULL);
    gtk_box_pack_end(vbox, w, FALSE, TRUE, 0);

    sep = gtk_hseparator_new();
    gtk_box_pack_end(vbox, sep, FALSE, TRUE, 0);
    gtk_widget_show(sep);

#endif
}
void ResourceConverterDialog::build_entry(GtkWidget * &image_ok, GtkWidget * &label_ok, GtkWidget * &label, const gchar * label_text, GtkWidget * &entry, const ustring & entry_text, GCallback handler)
{
    GtkWidget *hseparator;
    hseparator = gtk_hseparator_new();
    gtk_widget_show(hseparator);
    gtk_table_attach(GTK_TABLE(table1), hseparator, 0, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
    table_attachment_offset++;

    image_ok = gtk_image_new_from_icon_name("gtk-apply", GTK_ICON_SIZE_BUTTON);
    gtk_widget_show(image_ok);
    gtk_table_attach(GTK_TABLE(table1), image_ok, 0, 1, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);

    label_ok = gtk_label_new("");
    gtk_widget_show(label_ok);
    gtk_table_attach(GTK_TABLE(table1), label_ok, 1, 2, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment(GTK_MISC(label_ok), 0, 0.5);

    label = gtk_label_new(label_text);
    gtk_widget_show(label);
    gtk_table_attach(GTK_TABLE(table1), label, 2, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
    table_attachment_offset++;

    entry = gtk_entry_new();
    gtk_widget_show(entry);
    gtk_table_attach(GTK_TABLE(table1), entry, 0, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    table_attachment_offset++;

    gtk_entry_set_text(GTK_ENTRY(entry), entry_text.c_str());

    g_signal_connect((gpointer) entry, "changed", handler, gpointer(this));
}
示例#3
0
void vbox_add_hsep (GtkWidget *vbox)
{
    GtkWidget *h = gtk_hseparator_new();
    
    gtk_box_pack_start(GTK_BOX(vbox), h, FALSE, FALSE, 0);
    gtk_widget_show(h);
}
static gboolean main_win_draw_face(struct wcam_win *c)
{
    GtkWidget *box;
    GtkWidget *hbox;	
    GtkWidget *hseparator;	

    box = gtk_vbox_new(FALSE, 5);
    gtk_container_add(GTK_CONTAINER(c->win), box);          

 	/* draw_area & info_area */
    hbox = gtk_hbox_new(FALSE, 5);
    gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, TRUE, 0);
	draw_area_draw(c, hbox);
    info_area_draw(c, hbox);	

 	/* hseparator */
	hseparator=gtk_hseparator_new(); 
    gtk_box_pack_start(GTK_BOX(box), hseparator, FALSE, TRUE, 0);
    
 	/* button_area */
    main_button_area_draw(c, box);

 	/* control_area */
   // control_area_draw(c, box);

    return TRUE;
}
示例#5
0
文件: line.c 项目: rbuj/emerald
void my_engine_settings(GtkWidget * hbox, gboolean active)
{
    GtkWidget * vbox;
    GtkWidget * scroller;
#if GTK_CHECK_VERSION(3, 0, 0)
    vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL,2);
#else
    vbox = gtk_vbox_new(FALSE,2);
#endif
    gtk_box_pack_startC(hbox, vbox, TRUE, TRUE, 0);
    gtk_box_pack_startC(vbox, gtk_label_new(active?"Active Window":"Inactive Window"), FALSE, FALSE, 0);
#if GTK_CHECK_VERSION(3, 2, 0)
    gtk_box_pack_startC(vbox, gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
#else
    gtk_box_pack_startC(vbox, gtk_hseparator_new(), FALSE, FALSE, 0);
#endif
    scroller = gtk_scrolled_window_new(NULL,NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroller), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_startC(vbox, scroller, TRUE, TRUE, 0);

    table_new(3, FALSE, FALSE);

#if GTK_CHECK_VERSION(3, 8, 0)
    gtk_container_add(GTK_CONTAINER(scroller), GTK_WIDGET(get_current_table()));
#else
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroller), GTK_WIDGET(get_current_table()));
#endif

    make_labels(_("Colors"));
    table_append_separator();
    ACAV(_("Outer Frame Blend"), "border", SECT);
	ACAV(_("Title Bar"), "title_bar", SECT);
}
示例#6
0
GtkWidget *
gtk_separator_new( GtkOrientation orientation )
{
  return ( orientation == GTK_ORIENTATION_HORIZONTAL )?
          gtk_hseparator_new() :
          gtk_vseparator_new();
}
示例#7
0
文件: interface.c 项目: snyh/toy
GtkWidget *simulate_window_create ()
{
  GtkWidget *vbox;
  GtkWidget *button;
  GtkWidget *sep;
  GtkWidget *expander;
  GtkWidget *file_chooser;
  GtkWidget *hbox, *entry_run, *label;


  vbox = gtk_vbox_new (FALSE, 0);

  hbox = gtk_hbox_new (TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
  led1 = gtk_matrix_led_new (16, 16, 0);
  gtk_box_pack_start (GTK_BOX (hbox), led1, TRUE, TRUE, 5);
  led2 = gtk_matrix_led_new (16, 16, 1);
  gtk_box_pack_start (GTK_BOX (hbox), led2, TRUE, TRUE, 5);


  sep = gtk_hseparator_new ();
  gtk_box_pack_start (GTK_BOX (vbox), sep, TRUE, TRUE, 5);
  expander = gtk_expander_new_with_mnemonic ("(_Display)显示点阵数据");
  GtkWidget *tree = create_list ();
  gtk_container_add (GTK_CONTAINER (expander), tree);
  gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 5);


  hbox = gtk_hbox_new (TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
  label = gtk_label_new ("数据文件:");
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
  file_chooser = gtk_file_chooser_button_new ("选择点阵数据文件", 
                                        GTK_FILE_CHOOSER_ACTION_OPEN);
  g_signal_connect (G_OBJECT (file_chooser), "file-set",
                    G_CALLBACK (load_file), NULL);
  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_chooser), "./");
  gtk_box_pack_start (GTK_BOX (hbox), file_chooser, FALSE, TRUE, 5);



  hbox = gtk_hbox_new (TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
  button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (matrix_play), file_chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
  button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (matrix_pause), file_chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
  button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (matrix_stop), NULL);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);



  return vbox;
}
示例#8
0
文件: progress.c 项目: bion/ats
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);

}
示例#9
0
GtkWidget *
gtk_separator_new (GtkOrientation  orientation)
{
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    return gtk_hseparator_new ();
  else
    return gtk_vseparator_new ();
}
示例#10
0
void WdaGtk::create_class_dialog()
{
  if ( wdaclass_dia) {
    return;
  }

  // Create an input dialog
  wdaclass_dia = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
			   "default-height", 150,
			   "default-width", 550,
			   "title", "Select Class",
			   NULL);
  g_signal_connect( wdaclass_dia, "delete_event", G_CALLBACK(india_delete_event), this);

  wdaclass_classvalue = gtk_entry_new();
  GtkWidget *class_label = gtk_label_new("Class");
  gtk_widget_set_size_request( class_label, 95, -1);
  gtk_misc_set_alignment( GTK_MISC(class_label), 0, 0.5);
  wdaclass_hiervalue = gtk_entry_new();
  GtkWidget *hier_label = gtk_label_new("Hierarchy");
  gtk_widget_set_size_request( hier_label, 95, -1);
  gtk_misc_set_alignment( GTK_MISC(hier_label), 0, 0.5);
  wdaclass_attrobjects = gtk_check_button_new_with_label( "Attribute Objects");
 
  GtkWidget *india_hboxclass = gtk_hbox_new( FALSE, 0);
  gtk_box_pack_start( GTK_BOX(india_hboxclass), class_label, FALSE, FALSE, 15);
  gtk_box_pack_end( GTK_BOX(india_hboxclass), wdaclass_classvalue, TRUE, TRUE, 30);

  GtkWidget *india_hboxhier = gtk_hbox_new( FALSE, 0);
  gtk_box_pack_start( GTK_BOX(india_hboxhier), hier_label, FALSE, FALSE, 15);
  gtk_box_pack_end( GTK_BOX(india_hboxhier), wdaclass_hiervalue, TRUE, TRUE, 30);

  GtkWidget *india_hboxattrobj = gtk_hbox_new( FALSE, 0);
  gtk_box_pack_start( GTK_BOX(india_hboxattrobj), wdaclass_attrobjects, FALSE, FALSE, 150);

  GtkWidget *india_ok = gtk_button_new_with_label( "Ok");
  gtk_widget_set_size_request( india_ok, 70, 25);
  g_signal_connect( india_ok, "clicked", 
  		    G_CALLBACK(WdaGtk::class_activate_ok), this);
  GtkWidget *india_cancel = gtk_button_new_with_label( "Cancel");
  gtk_widget_set_size_request( india_cancel, 70, 25);
  g_signal_connect( india_cancel, "clicked", 
  		    G_CALLBACK(WdaGtk::class_activate_cancel), this);

  GtkWidget *india_hboxbuttons = gtk_hbox_new( TRUE, 40);
  gtk_box_pack_start( GTK_BOX(india_hboxbuttons), india_ok, FALSE, FALSE, 0);
  gtk_box_pack_end( GTK_BOX(india_hboxbuttons), india_cancel, FALSE, FALSE, 0);

  GtkWidget *india_vbox = gtk_vbox_new( FALSE, 0);
  gtk_box_pack_start( GTK_BOX(india_vbox), india_hboxclass, FALSE, FALSE, 15);
  gtk_box_pack_start( GTK_BOX(india_vbox), india_hboxhier, FALSE, FALSE, 15);
  gtk_box_pack_start( GTK_BOX(india_vbox), india_hboxattrobj, TRUE, TRUE, 15);
  gtk_box_pack_start( GTK_BOX(india_vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
  gtk_box_pack_end( GTK_BOX(india_vbox), india_hboxbuttons, FALSE, FALSE, 15);
  gtk_container_add( GTK_CONTAINER(wdaclass_dia), india_vbox);
  gtk_widget_show_all( wdaclass_dia);
  g_object_set( wdaclass_dia, "visible", FALSE, NULL);
}
示例#11
0
文件: base_ihm.c 项目: naparuba/vspf
void recreate_front_page(){
  GtkWidget * pNotebook = dw->pNotebook;
  GtkWidget *pVBoxCentral;
  GtkWidget *pVBox1;
  GtkWidget *pVBox2;
  GtkWidget *pSeparatorH;
  GtkWidget *pButtonAddRule;
  
  //debug
  gint i = 0;
  
  
  GtkWidget *pLabel2;
  GtkWidget *pTabLabel;
  
  pSeparatorH = gtk_hseparator_new();
  pButtonAddRule = gtk_button_new_with_label("AddRule");
  g_signal_connect(G_OBJECT(pButtonAddRule),"clicked",G_CALLBACK(OnButtonAddRule),pNotebook);   
  
  pVBoxCentral = gtk_vbox_new(FALSE, 0);
  pVBox1 = gtk_vbox_new(FALSE, 0);
  pVBox2 = gtk_vbox_new(FALSE, 0);
  
  //on ajoute tout cela dans dfp
  dfp->pVBoxCentral = pVBoxCentral;
  dfp->pVBox1 = pVBox1;
  dfp->pVBox2 = pVBox2;
  
  /* Creation des differents GtkLabel */
  pTabLabel = gtk_label_new(g_strdup_printf("Nouvelle page %d", i));
  
  pLabel2 = gtk_label_new(g_strdup_printf("Nouvo label Box 2:%d", i));
  
  create_vbox_from_caract_list(GTK_BOX(pVBox1));
  
  gtk_box_pack_start(GTK_BOX(pVBox2), pSeparatorH, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(pVBox2), pLabel2, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(pVBox2), pButtonAddRule, FALSE, FALSE, 0);
  
  gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBox1, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(pVBoxCentral), pVBox2, FALSE, FALSE, 0);



  gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK(pNotebook));
  printf("Current page = %d\n", current_page);
  // Insertion de la page avec le widget pLabel
  gtk_notebook_remove_page(GTK_NOTEBOOK(pNotebook),0);
  printf("On enleve une page\n");
  gtk_notebook_insert_page(GTK_NOTEBOOK(pNotebook), pVBoxCentral, pTabLabel,0);
  printf("On rajoute une page\n");
  
  printf("On va sur la page %d\n",current_page);


  gtk_widget_show_all(dw->pWindow);
  gtk_notebook_set_current_page (GTK_NOTEBOOK(pNotebook),current_page);
}
void ResourceConverterDialog::build_button(GtkWidget * &image_ok, GtkWidget * &label_ok, GtkWidget * &label_short, GtkWidget * &button, const gchar * button_text, Shortcuts & shortcuts, GCallback handler, GtkWidget * &label_long)
{
    GtkWidget *hseparator;
    hseparator = gtk_hseparator_new();
    gtk_widget_show(hseparator);
    gtk_table_attach(GTK_TABLE(table1), hseparator, 0, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
    table_attachment_offset++;

    image_ok = gtk_image_new_from_icon_name("gtk-apply", GTK_ICON_SIZE_BUTTON);
    gtk_widget_show(image_ok);
    gtk_table_attach(GTK_TABLE(table1), image_ok, 0, 1, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);

    label_ok = gtk_label_new("");
    gtk_widget_show(label_ok);
    gtk_table_attach(GTK_TABLE(table1), label_ok, 1, 2, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment(GTK_MISC(label_ok), 0, 0.5);

    label_short = gtk_label_new("");
    gtk_widget_show(label_short);
    gtk_table_attach(GTK_TABLE(table1), label_short, 2, 3, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment(GTK_MISC(label_short), 0, 0.5);

    button = gtk_button_new();
    gtk_widget_show(button);
    gtk_table_attach(GTK_TABLE(table1), button, 3, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    table_attachment_offset++;

    GtkWidget *alignment;
    alignment = gtk_alignment_new(0.5, 0.5, 0, 0);
    gtk_widget_show(alignment);
    gtk_container_add(GTK_CONTAINER(button), alignment);

    GtkWidget *hbox;
    hbox = gtk_hbox_new(FALSE, 2);
    gtk_widget_show(hbox);
    gtk_container_add(GTK_CONTAINER(alignment), hbox);

    GtkWidget *image_button_surface;
    image_button_surface = gtk_image_new_from_stock("gtk-index", GTK_ICON_SIZE_BUTTON);
    gtk_widget_show(image_button_surface);
    gtk_box_pack_start(GTK_BOX(hbox), image_button_surface, FALSE, FALSE, 0);

    GtkWidget *label_button_surface;
    label_button_surface = gtk_label_new_with_mnemonic(button_text);
    gtk_widget_show(label_button_surface);
    gtk_box_pack_start(GTK_BOX(hbox), label_button_surface, FALSE, FALSE, 0);

    shortcuts.label(label_button_surface);

    label_long = gtk_label_new("");
    gtk_widget_show(label_long);
    gtk_table_attach(GTK_TABLE(table1), label_long, 0, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment(GTK_MISC(label_long), 0, 0.5);
    table_attachment_offset++;

    g_signal_connect((gpointer) button, "clicked", handler, gpointer(this));
}
示例#13
0
static void nyth_light_effects_frame_init(NythLightEffectsFrame *frame) {
	NythLightEffectsFramePrivate *priv = NYTH_LIGHT_EFFECTS_FRAME_GET_PRIVATE(frame);
	GtkBox *box;

	frame->priv = priv;

	box = GTK_BOX(gtk_vbox_new(FALSE, 0));

	add_radios_color_effect(box, frame);
	gtk_box_pack_start(box, gtk_hseparator_new(), TRUE, TRUE, 0);
	add_radios_light_effect(box, frame);
	gtk_box_pack_start(box, gtk_hseparator_new(), TRUE, TRUE, 0);
	add_speed(box, frame);

	gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));

	gtk_frame_set_label(GTK_FRAME(frame), _("Light effects"));
}
示例#14
0
GtkWidget * AddHSeparator( GtkWidget * parent )
{
 GtkWidget * hseparator;
 hseparator=gtk_hseparator_new();
 gtk_widget_set_name( hseparator,"hseparator1" );
 gtk_widget_show( hseparator );
 gtk_box_pack_start( GTK_BOX( parent ),hseparator,FALSE,FALSE,0 );
 gtk_widget_set_usize( hseparator,-2,6 );
 return hseparator;
}
示例#15
0
文件: buttons.c 项目: vyshak/9c2012os
gint main (gint argc, gchar *argv[])
{
  GtkWidget *window;
  GtkWidget *button;       
  GtkWidget *vbox;

  gtk_init (&argc, &argv);
  //window = gtk_window_new(GTK_WINDOW_POPUP);
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size(GTK_WINDOW(window),200,200);
 gtk_window_set_resizable(GTK_WINDOW(window), FALSE);  
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
gtk_window_set_title(GTK_WINDOW(window),"GPU FS");  
  g_signal_connect ( G_OBJECT (window), "destroy",
                       G_CALLBACK (closeApp), NULL);


  radiobutton1 = gtk_radio_button_new(NULL);
  radiobutton2 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
  radiobutton3 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
  radiobutton4 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
  radiobutton5 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
  radiobutton6 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
 hseparator=gtk_hseparator_new ();

  vbox = gtk_vbox_new (TRUE, 4); 
 
  add_widget_with_label (GTK_CONTAINER(vbox), "100%:",radiobutton1);
  add_widget_with_label (GTK_CONTAINER(vbox), "75%:", radiobutton2);
  add_widget_with_label (GTK_CONTAINER(vbox), "50%:", radiobutton3);
  add_widget_with_label (GTK_CONTAINER(vbox), "33%:", radiobutton4);
  add_widget_with_label (GTK_CONTAINER(vbox), NULL, hseparator);
  add_widget_with_label (GTK_CONTAINER(vbox), "Auto:", radiobutton5);
  add_widget_with_label (GTK_CONTAINER(vbox), "PowerSaver:", radiobutton6);
 
  g_signal_connect(G_OBJECT(radiobutton1), "toggled", 
                     G_CALLBACK(radio_button_clicked1), NULL);
  g_signal_connect(G_OBJECT(radiobutton2), "toggled", 
                     G_CALLBACK(radio_button_clicked2), NULL);
  g_signal_connect(G_OBJECT(radiobutton3), "toggled", 
                     G_CALLBACK(radio_button_clicked3), NULL);
  g_signal_connect(G_OBJECT(radiobutton4), "toggled", 
                     G_CALLBACK(radio_button_clicked4), NULL);
  g_signal_connect(G_OBJECT(radiobutton5), "toggled", 
                     G_CALLBACK(radio_button_clicked5), NULL);
  g_signal_connect(G_OBJECT(radiobutton6), "toggled", 
                     G_CALLBACK(radio_button_clicked6), NULL);

	
  gtk_container_add(GTK_CONTAINER(window), vbox);		
  gtk_widget_show_all(window);
  gtk_main ();
	
  return 0;
}
示例#16
0
static void oss_preferences(void)
{
     GtkWidget *a,*b,*c,*d;
     struct oss_prefdlg *pd;
     gchar *q;
     pd = g_malloc(sizeof(struct oss_prefdlg));
     a = gtk_window_new(GTK_WINDOW_DIALOG);     
     gtk_window_set_modal(GTK_WINDOW(a),TRUE);
     gtk_window_set_title(GTK_WINDOW(a),_("OSS preferences"));
     gtk_window_set_position(GTK_WINDOW(a),GTK_WIN_POS_CENTER);
     gtk_container_set_border_width(GTK_CONTAINER(a),5);
     gtk_signal_connect_object(GTK_OBJECT(a),"destroy",GTK_SIGNAL_FUNC(g_free),
			       (GtkObject *)pd);
     pd->wnd = GTK_WINDOW(a);
     b = gtk_vbox_new(FALSE,5);
     gtk_container_add(GTK_CONTAINER(a),b);
     c = gtk_hbox_new(FALSE,3);
     gtk_container_add(GTK_CONTAINER(b),c);
     d = gtk_label_new(_("Playback device file:"));
     gtk_container_add(GTK_CONTAINER(c),d);
     d = gtk_entry_new();
     q = inifile_get(OSS_PCMFILE_PLAYBACK,OSS_PCMFILE_DEFAULT);
     gtk_entry_set_text(GTK_ENTRY(d),q);
     gtk_container_add(GTK_CONTAINER(c),d);
     pd->pcmdev_playback = GTK_ENTRY(d);
     c = gtk_hbox_new(FALSE,3);
     gtk_container_add(GTK_CONTAINER(b),c);
     d = gtk_label_new(_("Recording device file:"));
     gtk_container_add(GTK_CONTAINER(c),d);
     d = gtk_entry_new();
     gtk_entry_set_text(GTK_ENTRY(d),inifile_get(OSS_PCMFILE_RECORD,q));
     gtk_container_add(GTK_CONTAINER(c),d);
     pd->pcmdev_record = GTK_ENTRY(d);
     c = gtk_check_button_new_with_label(_("Avoid select calls (try this if "
					 "recording locks up)"));
     gtk_container_add(GTK_CONTAINER(b),c);
     oss_noselect = inifile_get_gboolean(OSS_NOSELECT,OSS_NOSELECT_DEFAULT);
     pd->noselect = GTK_TOGGLE_BUTTON(c);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c),oss_noselect);
     c = gtk_hseparator_new();
     gtk_container_add(GTK_CONTAINER(b),c);
     c = gtk_hbutton_box_new();
     gtk_container_add(GTK_CONTAINER(b),c);
     d = gtk_button_new_with_label(_("OK"));
     gtk_signal_connect(GTK_OBJECT(d),"clicked",
			GTK_SIGNAL_FUNC(oss_preferences_ok),pd);
     gtk_container_add(GTK_CONTAINER(c),d);
     d = gtk_button_new_with_label(_("Close"));
     gtk_signal_connect_object(GTK_OBJECT(d),"clicked",
			       GTK_SIGNAL_FUNC(gtk_widget_destroy),
			       GTK_OBJECT(a));
     gtk_container_add(GTK_CONTAINER(c),d);     
     gtk_widget_show_all(a);
}
示例#17
0
GtkWidget *
gtk_utils_create_titled_page (GtkWidget *contents,
			      const gchar *icon_stock_id, const gchar *title)
{
  GtkWidget *image = NULL;
  GtkWidget *label = NULL;
  GtkWidget *title_widget;
  GtkWidget *hseparator;

  g_return_val_if_fail (GTK_IS_WIDGET (contents), NULL);
  g_return_val_if_fail (icon_stock_id || title, NULL);

  if (icon_stock_id) {
    image = gtk_image_new_from_stock (icon_stock_id,
				      GTK_ICON_SIZE_LARGE_TOOLBAR);
  }

  if (title) {
    gchar *title_escaped = g_markup_escape_text (title, -1);
    char *marked_up_title
      = utils_cat_strings (NULL,
			   "<span weight=\"bold\" size=\"x-large\">",
			   title_escaped, "</span>", NULL);

    g_free (title_escaped);

    label = gtk_label_new (NULL);
    gtk_label_set_markup (GTK_LABEL (label), marked_up_title);

    utils_free (marked_up_title);
  }

  if (image && label) {
    title_widget = gtk_utils_pack_in_box (GTK_TYPE_HBOX, QUARRY_SPACING_SMALL,
					  image, GTK_UTILS_FILL, label, 0,
					  NULL);
  }
  else if (label) {
    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
    title_widget = label;
  }
  else
    title_widget = image;

  gtk_widget_show_all (title_widget);

  hseparator = gtk_hseparator_new ();
  gtk_widget_show (hseparator);

  return gtk_utils_pack_in_box (GTK_TYPE_VBOX, QUARRY_SPACING_SMALL,
				title_widget, GTK_UTILS_FILL,
				hseparator, GTK_UTILS_FILL,
				contents, GTK_UTILS_PACK_DEFAULT, NULL);
}
示例#18
0
static GtkWidget *graph_range_new(graph_priv_t *priv) {
  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);

  gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);

  priv->vmax_w = gtk_label_new("---");
  gtk_box_pack_start(GTK_BOX(vbox), priv->vmax_w, FALSE, FALSE, 0);

  GtkWidget *ivbox = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start_defaults(GTK_BOX(ivbox), gtk_label_new("Altitude"));
  gtk_box_pack_start_defaults(GTK_BOX(ivbox), gtk_label_new("(m)"));

  gtk_box_pack_start(GTK_BOX(vbox), ivbox, TRUE, FALSE, 0);

  priv->vmin_w = gtk_label_new("---");
  gtk_box_pack_start(GTK_BOX(vbox), priv->vmin_w, FALSE, FALSE, 0);

  gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);

  return vbox;
}
示例#19
0
文件: tasks.c 项目: rosedu/osmo
void
tasks_item_selected (GtkTreeSelection *selection, gpointer data) {

GtkTreeIter iter;
GtkTreeModel *model;
gchar *text;
GtkTextIter titer;
GtkTextBuffer *text_buffer;
GtkTextChildAnchor *anchor;
GtkWidget *hseparator;
guint32 start_date_julian;
gchar tmpbuf[BUFFER_SIZE];

    GUI *appGUI = (GUI *)data;

    text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
    gui_clear_text_buffer (text_buffer, &titer);

    if (gtk_tree_selection_get_selected (selection, &model, &iter)) {

        gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), TRUE);
        gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), TRUE);

        gtk_tree_model_get (model, &iter, COLUMN_DESCRIPTION, &text,
                            COLUMN_START_DATE_JULIAN, &start_date_julian, -1);  

        sprintf(tmpbuf, "\n%s: %s\n", _("Started"), julian_to_str(start_date_julian, DATE_FULL));

        if (text != NULL) {
            gtk_text_buffer_insert_with_tags_by_name (text_buffer, &titer, text, -1, 
                                                      "info_font", NULL);
            gtk_text_buffer_insert(text_buffer, &titer, "\n", -1);
        }

        if (start_date_julian) {
            gtk_text_buffer_insert(text_buffer, &titer, "\n", -1);
            anchor = gtk_text_buffer_create_child_anchor (text_buffer, &titer);
            gtk_text_buffer_insert_with_tags_by_name (text_buffer, &titer, tmpbuf, -1, 
                                                      "italic", NULL);
            gtk_text_view_set_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), text_buffer);

            hseparator = gtk_hseparator_new ();
            gtk_widget_show (hseparator);
            gtk_widget_set_size_request (hseparator, 240, -1);
            gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), hseparator, anchor);
        }

        g_free(text);
    } else {
        gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
        gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
    }
}
示例#20
0
void layout_engine_list(GtkWidget * vbox)
{
    GtkWidget * hbox;
    EngineCombo = gtk_combo_box_new();
    hbox = gtk_hbox_new(FALSE,2);
    gtk_box_pack_startC(vbox,hbox,FALSE,FALSE,0);
    gtk_box_pack_startC(hbox,gtk_label_new(_("Select\nEngine")),FALSE,FALSE,0);
    gtk_box_pack_startC(hbox,EngineCombo,FALSE,FALSE,0);
    gtk_box_pack_startC(vbox,gtk_hseparator_new(),FALSE,FALSE,0);
    EngineContainer = gtk_alignment_new(0,0,1,1); // really only needed for the bin-ness
    gtk_box_pack_startC(vbox,EngineContainer,TRUE,TRUE,0);
}
示例#21
0
int main (int argc, char **argv) {
  
  GtkWidget *window;
  GtkWidget *label1;
  GtkWidget *label2;
  GtkWidget *hseparator;
  GtkWidget *vbox;


  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "GtkHSeparator");
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  //  gtk_window_set_default_size(GTK_WINDOW(window), 230, 150);
  gtk_window_set_resizable(GTK_WINDOW(window), FALSE);

  gtk_container_set_border_width(GTK_CONTAINER(window), 20);

  label1 = gtk_label_new("Zinc is a moderately reactive, blue gray metal \
that tarnishes in moist air and burns in air with a bright blueish-green flame,\
giving off fumes of zinc oxide. It reacts with acids, alkalis and other non-metals.\
If not completely pure, zinc reacts with dilute acids to release hydrogen.");

  gtk_label_set_line_wrap(GTK_LABEL(label1), TRUE);

  label2 = gtk_label_new("Copper is an essential trace nutrient to all high \
plants and animals. In animals, including humans, it is found primarily in \
the bloodstream, as a co-factor in various enzymes, and in copper-based pigments. \
However, in sufficient amounts, copper can be poisonous and even fatal to organisms.");

  gtk_label_set_line_wrap(GTK_LABEL(label2), TRUE);

  vbox = gtk_vbox_new(FALSE, 10);
  gtk_container_add(GTK_CONTAINER(window), vbox);

  hseparator = gtk_hseparator_new();

  gtk_box_pack_start(GTK_BOX(vbox), label1, FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, TRUE, 10);
  gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, TRUE, 0);


  g_signal_connect_swapped (window, "destroy", 
			    G_CALLBACK(gtk_main_quit), G_OBJECT(window));

  gtk_widget_show_all(window);

  gtk_main();

  return 0;
}
示例#22
0
GtkWidget*  gwrgtk_hseparator_new()
{
    //  GTK >= 3.0
    #if GWR_GTK_VERSION_GE(3,0)
    {
        return  gtk_separator_new( GTK_ORIENTATION_HORIZONTAL );
    }
    #else
    {
        return  gtk_hseparator_new();
    }
    #endif
}
示例#23
0
void philips_cfg_separator ( GtkWidget *table, int horv, gint left, gint right, gint top, gint bottom )
{

    GtkWidget	*separator;

    if ( horv == 0 ) 		/* horizontal */
        separator = gtk_hseparator_new();
    else
        separator = gtk_vseparator_new();

    gtk_widget_show ( separator );
    gtk_table_attach_defaults ( GTK_TABLE(table), separator, left, right, top, bottom );
}
示例#24
0
void table_append_separator()
{
    current_table_col=0;
    current_table_row++;
//    gtk_table_resize(current_table,current_table_width,current_table_row+1);
    gtk_table_attach_defaults(current_table,
            gtk_hseparator_new(),
            0,current_table_width,
            current_table_row,
            current_table_row+1);
    current_table_row++;
//    gtk_table_resize(current_table,current_table_width,current_table_row+1);
}
示例#25
0
文件: ats-header.c 项目: rbrown49/ats
void create_hsep(GtkWidget *vbox)
{
  GtkWidget *hsep1;

  hsep1=gtk_hseparator_new();
  gtk_widget_ref (hsep1);
  gtk_object_set_data_full (GTK_OBJECT (window1), "hsep1", hsep1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_box_pack_start (GTK_BOX (vbox), hsep1, TRUE, TRUE,0);
  gtk_widget_show (hsep1);  

return;
}
示例#26
0
文件: widgets.c 项目: pingax/pragha
gpointer sokoke_xfce_header_new(const gchar* header, const gchar *icon)
{
	GtkWidget* entry;
	GtkWidget* xfce_heading;
	GtkWidget* hbox;
	GtkWidget* vbox;
	GtkWidget* image;
	GtkWidget* label;
	GtkWidget* separator;
	gchar* markup;

	entry = gtk_entry_new();
	xfce_heading = gtk_event_box_new();

	gtk_widget_modify_bg(xfce_heading,
				GTK_STATE_NORMAL,
				&gtk_widget_get_style(entry)->base[GTK_STATE_NORMAL]);

	hbox = gtk_hbox_new(FALSE, 12);
	gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);

        if (icon)
            image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_DIALOG);
        else
            image = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_DIALOG);

	label = gtk_label_new(NULL);
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	gtk_widget_modify_fg(label,
				GTK_STATE_NORMAL,
				&gtk_widget_get_style(entry)->text[GTK_STATE_NORMAL]);
        markup = g_strdup_printf("<span size='large' weight='bold'>%s</span>", header);
	gtk_label_set_markup(GTK_LABEL(label), markup);
	gtk_misc_set_alignment (GTK_MISC(label), 0, 0.5);
	g_free(markup);

	gtk_widget_destroy (entry);

	gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);

	gtk_container_add(GTK_CONTAINER(xfce_heading), hbox);

	vbox = gtk_vbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox), xfce_heading, FALSE, FALSE, 0);

	separator = gtk_hseparator_new ();
	gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);

	return vbox;
}
示例#27
0
文件: login.c 项目: younghedong/chat
GtkWidget *login()
{
	GtkWidget* window;
	GtkWidget* box;
	GtkWidget* box1;
	GtkWidget* box2;
	GtkWidget* box3;
	GtkWidget* label1;
	GtkWidget* label2;
	GtkWidget* buttonok;
	GtkWidget* buttonsignup;
	GtkWidget* sep;
	
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(G_OBJECT(window),"destroy",
	G_CALLBACK(gtk_main_quit),NULL);
	gtk_window_set_title(GTK_WINDOW(window),"登录窗口");
	gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
	gtk_container_set_border_width(GTK_CONTAINER(window),20);
	
	box = gtk_vbox_new(FALSE,0);
	gtk_container_add(GTK_CONTAINER(window),box);
	box1 = gtk_hbox_new(FALSE,0);
	gtk_box_pack_start(GTK_BOX(box),box1,FALSE,FALSE,5);
	box2 = gtk_hbox_new(FALSE,0);
	gtk_box_pack_start(GTK_BOX(box),box2,FALSE,FALSE,5);
	sep = gtk_hseparator_new();
	gtk_box_pack_start(GTK_BOX(box),sep,FALSE,FALSE,5);
	label1 = gtk_label_new("用户名:");
	entry1 = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(box1),label1,FALSE,FALSE,5);
	gtk_box_pack_start(GTK_BOX(box1),entry1,FALSE,FALSE,5);
	label2 = gtk_label_new("  密   码:");
	entry2 = gtk_entry_new();
	gtk_entry_set_visibility(GTK_ENTRY(entry2),FALSE);
	gtk_box_pack_start(GTK_BOX(box2),label2,FALSE,FALSE,5);
	gtk_box_pack_start(GTK_BOX(box2),entry2,FALSE,FALSE,5);
	buttonok = gtk_button_new_with_label("确 认");
	buttonsignup = gtk_button_new_with_label("注 册");
	box3 = gtk_hbox_new(FALSE, 0);
	gtk_widget_set_size_request(buttonok, 65, 35);
	gtk_widget_set_size_request(buttonsignup, 65, 35);
	gtk_box_pack_start(GTK_BOX(box),box3,FALSE,FALSE,5);
	gtk_box_pack_start(GTK_BOX(box3),buttonsignup,FALSE,FALSE,50);
	gtk_box_pack_start(GTK_BOX(box3),buttonok,FALSE,FALSE,2);
	g_signal_connect(G_OBJECT(buttonok),"clicked",
	G_CALLBACK(on_button_ok_clicked),window);
	g_signal_connect(G_OBJECT(buttonsignup),"clicked",
	G_CALLBACK(on_button_signup_clicked),window);
	return window;
}
示例#28
0
文件: interface.c 项目: dimkr/beaver
void about (void)
{
  GtkWidget *AboutWindow;
  GtkWidget *PixmapWidget;
  GtkWidget *HSeparator;
  GdkPixmap *Pixmap;
  GdkBitmap *Mask;
  GtkStyle  *Style;
  GtkWidget *Button;
  GtkWidget *AboutLabel;  
  
  AboutWindow = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW(AboutWindow), "About " APP_NAME); 
  gtk_window_set_policy (GTK_WINDOW(AboutWindow), FALSE, FALSE, FALSE);
  gtk_window_set_position (GTK_WINDOW(AboutWindow), GTK_WIN_POS_CENTER);
  gtk_window_set_modal (GTK_WINDOW(AboutWindow), TRUE);
  gtk_window_set_transient_for (GTK_WINDOW(AboutWindow),
				GTK_WINDOW(MainWindow));
  gtk_signal_connect_object (GTK_OBJECT(AboutWindow), "delete_event",
			     (GtkSignalFunc) gtk_widget_destroy,
			     GTK_OBJECT(AboutWindow));
  gtk_signal_connect_object (GTK_OBJECT (AboutWindow), "destroy",
			     (GtkSignalFunc) gtk_widget_destroy,
			     GTK_OBJECT(AboutWindow));
  gtk_widget_realize (AboutWindow);
  Style = gtk_widget_get_style (AboutWindow);
  Pixmap = gdk_pixmap_create_from_xpm_d (AboutWindow->window, &Mask,
					 &Style->bg[GTK_STATE_NORMAL],
					 about_xpm);
  PixmapWidget = gtk_pixmap_new (Pixmap, Mask);
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
		      PixmapWidget, FALSE, FALSE, 0);
  HSeparator = gtk_hseparator_new ();
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
		      HSeparator, FALSE, FALSE, 0);
  AboutLabel = gtk_label_new (APP_NAME " " VERSION_NUMBER "\n"
			      APP_MOTTO "\n\n" APP_URL);
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
		      AboutLabel, FALSE, FALSE, 10);
  Button = gtk_button_new_with_label (" Resume ");
  gtk_signal_connect_object (GTK_OBJECT(Button), "clicked",
			     (GtkSignalFunc) gtk_widget_destroy,
			     GTK_OBJECT(AboutWindow));
  GTK_WIDGET_SET_FLAGS (Button, GTK_CAN_DEFAULT);
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> action_area),
		      Button, TRUE, TRUE, 0);
  gtk_widget_grab_default (Button);
  gtk_widget_show_all (AboutWindow);
  print_msg ("Display About window...");
}
示例#29
0
static void
create_sheets(GtkWidget *parent)
{
  GtkWidget *notebook;
  GtkWidget *separator;
  GSList *list;
  Sheet *sheet;
  GtkWidget *child;
  GtkWidget *label;
  GtkWidget *menu_label;

  
  separator = gtk_hseparator_new ();
  gtk_box_pack_start (GTK_BOX (parent), separator, FALSE, TRUE, 3);
  gtk_widget_show(separator);

  notebook = gtk_notebook_new ();
  /*
  gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
		      GTK_SIGNAL_FUNC (page_switch), NULL);
  */
  gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE);
  gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
  gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook));
  gtk_container_set_border_width (GTK_CONTAINER (notebook), 1);
  gtk_box_pack_start (GTK_BOX (parent), notebook, TRUE, TRUE, 0);
  
  list = get_sheets_list();
  while (list != NULL) {
    sheet = (Sheet *) list->data;

    label = gtk_label_new(gettext(sheet->name));
    menu_label = gtk_label_new(gettext(sheet->name));
    gtk_misc_set_alignment(GTK_MISC(menu_label), 0.0, 0.5);
    
    child = create_sheet_page(notebook, sheet);
    
    gtk_widget_show(label);
    gtk_widget_show(menu_label);
    gtk_widget_show_all(child);

    gtk_notebook_append_page_menu (GTK_NOTEBOOK (notebook),
				   child, label, menu_label);
    
    list = g_slist_next(list);
  }
  
  gtk_widget_show(notebook);
}
void initClientLayout(GtkWidget *window) {
	GtkWidget	*menubar;
	GtkWidget	*main_vbox;		//main vertical box widget	
	GtkWidget	*button_hbox;		//buttons horizon box widget
	GtkWidget	*separator;		//separator widget

	//Create a vbox to put menubar, image, and 3 buttons
	main_vbox = gtk_vbox_new(FALSE, BOX_SPACING_SIZE);
	//Set the border width of man_vbox
	gtk_container_set_border_width(GTK_CONTAINER(main_vbox), BORDER_WIDTH_SIZE);
	//Add the main_vbox into the window
	gtk_container_add(GTK_CONTAINER(window), main_vbox);

	//Create the menubar from itemfactoryentry
	menubar = getMenubarMenu(window);
	//Pack the menubar into the main_vbox
	gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);

	//Create the toolbar
	toolbar = getToolbar();
	//Pack the toolbar into the main_vbox
	gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, TRUE, 0);

	//Create a image to play the video
	image = gtk_image_new_from_file(VIDEO_ICON);
	//Pack the image into the main_vbox
	gtk_box_pack_start(GTK_BOX(main_vbox), image, TRUE, TRUE, 0);

	//Create a separator
	separator = gtk_hseparator_new();
	//Pack the separator into the main_vbox
	gtk_box_pack_start(GTK_BOX(main_vbox), separator, FALSE, TRUE, 0);

	//Create a hbox to put 3 buttons
	button_hbox = gtk_hbox_new(TRUE, BOX_SPACING_SIZE);
	//Pack the button_hbox into the main_vbox
	gtk_box_pack_start(GTK_BOX(main_vbox), button_hbox, FALSE, TRUE, 0);

	//Create the setup button
	setupButton = getButton(button_hbox, GTK_STOCK_NETWORK, "Setup", "Setup RTSP Connection");
	//Create the play button
	playButton = getButton(button_hbox, GTK_STOCK_MEDIA_PLAY, "Play", "Play Streaming Video");
	//Create the teardown button
	teardownButton = getButton(button_hbox, GTK_STOCK_MEDIA_STOP, "Teardown", "Teardown RTSP Connection");

	//Set the sensitive property of buttons
	setSensitive(TRUE, FALSE, FALSE);

	return;
}