Example #1
0
static sequence_view_t *new_sequence_view( void *vp, int num )
{
	sequence_view_t *seqv = (sequence_view_t*) vj_calloc(sizeof(sequence_view_t));

	seqv->num = num;
	seqv->backlink = vp;

	seqv->event_box = gtk_event_box_new();
	gtk_event_box_set_visible_window( GTK_EVENT_BOX(seqv->event_box), TRUE );
	GTK_WIDGET_SET_FLAGS( seqv->event_box, GTK_CAN_FOCUS );

	g_signal_connect( G_OBJECT( seqv->event_box ),
				"button_press_event",
				G_CALLBACK( seqv_mouse_press_event ),
				(gpointer*) seqv );
	gtk_widget_show( GTK_WIDGET( seqv->event_box ) );


	gchar *track_title = g_new0( gchar, 20 );
	sprintf(track_title, "Track %d", num );
	seqv->frame = gtk_frame_new( track_title );
	g_free(track_title);
	
	gtk_container_set_border_width( GTK_CONTAINER( seqv->frame) , 1 );
	gtk_widget_show( GTK_WIDGET( seqv->frame ) );
	gtk_container_add( GTK_CONTAINER( seqv->event_box), seqv->frame );

	seqv->main_vbox = gtk_vbox_new(FALSE,0);
	gtk_container_add( GTK_CONTAINER( seqv->frame ), seqv->main_vbox );
	gtk_widget_show( GTK_WIDGET( seqv->main_vbox ) );
	
	seqv->area = gtk_image_new();

	
	gtk_box_pack_start( GTK_BOX(seqv->main_vbox),GTK_WIDGET( seqv->area), FALSE,FALSE,0);
	gtk_widget_set_size_request_( seqv->area, 176,144  ); //FIXME
	seqv->panel = gtk_frame_new(NULL);

	seqv->toggle = gtk_toggle_button_new_with_label( "preview" );
	
	if(num>0) {
		gtk_toggle_button_set_active(
			GTK_TOGGLE_BUTTON(seqv->toggle), FALSE );
		g_signal_connect( G_OBJECT( seqv->toggle ), "toggled", G_CALLBACK(sequence_preview_cb),
			(gpointer)seqv );
		gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );

		gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
	
		gtk_widget_show( seqv->toggle );
	} else {
		gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
		gtk_widget_show( seqv->toggle );
		gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
	}

	GtkWidget *vvbox = gtk_vbox_new(FALSE, 0);
	seqv->button_box = gtk_hbox_new(FALSE,0);
	gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box ,FALSE,FALSE, 0 );	
	add_buttons( seqv,seqv,seqv->button_box );

	gtk_widget_show( seqv->button_box );	
	gtk_container_add( GTK_CONTAINER( seqv->main_vbox ), seqv->panel );

	seqv->button_box2 = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box2, FALSE,FALSE, 0 );
	add_buttons2( seqv,seqv,seqv->button_box2 );
	gtk_widget_show( seqv->button_box2 );
	gtk_container_add( GTK_CONTAINER( seqv->panel ), vvbox );
	gtk_widget_show(vvbox);
	
	GtkWidget *box = gtk_vbox_new(FALSE,0);
	seqv->timeline_ = gtk_hscale_new_with_range( 0.0,1.0,0.1 );
	gtk_scale_set_draw_value( GTK_SCALE(seqv->timeline_), FALSE );
	//gtk_widget_set_size_request_( seqv->panel,180 ,180);
	gtk_adjustment_set_value(
                GTK_ADJUSTMENT(GTK_RANGE(seqv->timeline_)->adjustment), 0.0 );
	gtk_widget_show( seqv->panel );
	gtk_box_pack_start( GTK_BOX( box ), seqv->timeline_, FALSE,FALSE, 0 );
	gtk_box_pack_start( GTK_BOX( vvbox ), box , FALSE,FALSE,0);
	gtk_widget_show(seqv->timeline_);
	g_signal_connect( seqv->timeline_, "value_changed",
       	         (GCallback) sequence_set_current_frame, (gpointer*) seqv );

	GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL);
	gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN );
	gtk_widget_set_size_request_(scroll,30,140);
	gtk_container_set_border_width(GTK_CONTAINER(scroll),0);
	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
	GtkWidget *vvvbox = gtk_hbox_new(FALSE,0);
	seqv->tracks = create_track_view(seqv->num, MAX_TRACKS, (void*) seqv );
	gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( get_track_tree(seqv->tracks)) , FALSE );
	gtk_widget_set_size_request_( get_track_tree(seqv->tracks),20,80 );
	gtk_widget_show(scroll);

	gtk_scrolled_window_add_with_viewport(
		GTK_SCROLLED_WINDOW( scroll ), get_track_tree(seqv->tracks) );
	gtk_widget_show( get_track_tree(seqv->tracks));
	gtk_box_pack_start( GTK_BOX(vvvbox), scroll, TRUE,TRUE, 0);

	GtkWidget *hhbox = gtk_hbox_new(FALSE,0);

	seqv->sliders_[0] = gtk_vscale_new_with_range( -12.0,12.0,1.0 );
	seqv->sliders_[1] = gtk_vscale_new_with_range( 0.0, 1.0, 0.01 );

	gtk_adjustment_set_value(
		GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[0])->adjustment), 1.0 );
	gtk_adjustment_set_value(
                GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[1])->adjustment), 0.0 );
				
	
	gtk_scale_set_digits( GTK_SCALE(seqv->sliders_[1]), 2 );
	g_signal_connect( G_OBJECT( seqv->sliders_[0] ), "value_changed", G_CALLBACK( seq_speed ),
				(gpointer*)seqv );		
	g_signal_connect( G_OBJECT( seqv->sliders_[1] ), "value_changed", G_CALLBACK( seq_opacity ),
				(gpointer*)seqv );		

	gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[0], TRUE, TRUE, 0 );
	gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[1], TRUE, TRUE, 0 );
	gtk_widget_show( seqv->sliders_[0] );
	gtk_widget_show( seqv->sliders_[1] );
	gtk_box_pack_start( GTK_BOX(vvvbox), hhbox, TRUE,TRUE, 0 );
	gtk_widget_show( hhbox ); 
	gtk_container_add( GTK_CONTAINER( box ), vvvbox );
	gtk_widget_show( vvvbox );
	gtk_widget_show( box );	

	
	GtkWidget *hbox = gtk_hbox_new(FALSE,0);
	gtk_box_set_spacing( GTK_BOX(hbox), 10 );
	seqv->labels_[0] = gtk_label_new( "00:00:00:00" );
	seqv->labels_[1] = gtk_label_new( "00:00:00:00" );
	gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[0], FALSE, FALSE, 0 );
	gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[1], FALSE, FALSE, 0 );
	gtk_widget_show( seqv->labels_[0] );
	gtk_widget_show( seqv->labels_[1] );
	gtk_box_pack_start( GTK_BOX(seqv->main_vbox), hbox, FALSE,FALSE, 0 );
	gtk_widget_show( hbox );
	

	gtk_widget_set_sensitive_(GTK_WIDGET(seqv->panel), FALSE );

	gtk_widget_show( GTK_WIDGET( seqv->area ) );

	return seqv;
}
int DoLoadPortalFileDialog( GtkWidget *parent ){
	GtkWidget *dialog, *vbox, *hbox, *button, *entry, *check2d, *check3d;
	GtkWidget *content_area, *ok_button, *cancel_button, *change_button;
	gint response_id;
	int ret;
	GtkSizeGroup *size_group;
	GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;

	dialog = gtk_dialog_new_with_buttons( _( "Load .prt" ), NULL, flags, NULL );
	gtk_window_set_transient_for( GTK_WINDOW( dialog ), GTK_WINDOW( parent ) );

	ok_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "OK" ), GTK_RESPONSE_OK );
	cancel_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "Cancel" ), GTK_RESPONSE_CANCEL );

	content_area = gtk_dialog_get_content_area( GTK_DIALOG( dialog ) );

	vbox = gtk_vbox_new( FALSE, 5 );
	gtk_container_add( GTK_CONTAINER( content_area ), vbox );
	gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
	gtk_widget_show( vbox );

	entry = gtk_entry_new();
	gtk_editable_set_editable( GTK_EDITABLE( entry ), FALSE );
	gtk_box_pack_start( GTK_BOX( vbox ), entry, FALSE, FALSE, 0 );
	gtk_widget_show( entry );

	hbox = gtk_hbox_new( FALSE, 5 );
	gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
	gtk_widget_show( hbox );

	check3d = gtk_check_button_new_with_label( _( "Show 3D" ) );
	gtk_box_pack_start( GTK_BOX( hbox ), check3d, FALSE, FALSE, 0 );
	gtk_widget_show( check3d );

	check2d = gtk_check_button_new_with_label( _( "Show 2D" ) );
	gtk_box_pack_start( GTK_BOX( hbox ), check2d, FALSE, FALSE, 0 );
	gtk_widget_show( check2d );

	change_button = button = gtk_button_new_with_label( _( "Change" ) );
	gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
	g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( change_clicked ), parent );
	gtk_widget_show( button );

	size_group = gtk_size_group_new( GTK_SIZE_GROUP_BOTH );
	gtk_size_group_add_widget( size_group, ok_button );
	gtk_size_group_add_widget( size_group, cancel_button );
	gtk_size_group_add_widget( size_group, change_button );
	g_object_unref( size_group );

	char *fn = g_FuncTable.m_pfnGetMapName();
	strcpy( portals.fn, fn );
	fn = strrchr( portals.fn, '.' );
	if ( fn != NULL ) {
		*fn = '\0';
		strcat( portals.fn, ".prt" );
	}

	gtk_entry_set_text( GTK_ENTRY( entry ), portals.fn );
	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check2d ), portals.show_2d );
	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check3d ), portals.show_3d );


	response_id = gtk_dialog_run( GTK_DIALOG( dialog ) );

	if( response_id == GTK_RESPONSE_OK ) {

		portals.Purge();

		portals.show_3d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check3d ) ) ? true : false;
		portals.show_2d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check2d ) ) ? true : false;

		ret = IDOK;
	} else {
		ret = IDCANCEL;
	}

	gtk_widget_destroy( dialog );

	return ret;
}
Example #3
0
GtkWidget      *sat_pref_debug_create()
{
    GtkWidget      *vbox;       /* vbox containing the list part and the details part */
    GtkWidget      *hbox;
    GtkWidget      *rbut;
    GtkWidget      *label;
    GtkWidget      *butbox;
    gchar          *msg;
    gchar          *confdir;

    vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
    gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), 20);
    gtk_box_set_spacing(GTK_BOX(vbox), 10);

    /* debug level */
    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
    gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);

    label = gtk_label_new(_("Debug level:"));
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

    level = gtk_combo_box_text_new();
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level),
                                   _("Level 0: None"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level),
                                   _("Level 1: Error"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level),
                                   _("Level 2: Warning"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level),
                                   _("Level 3: Info"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level),
                                   _("Level 4: Debug"));
    gtk_combo_box_set_active(GTK_COMBO_BOX(level),
                             sat_cfg_get_int(SAT_CFG_INT_LOG_LEVEL));
    g_signal_connect(G_OBJECT(level), "realize",
                     G_CALLBACK(gpredict_set_combo_tooltips),
                     _("Select the debug level. The higher the level, "
                       "the more messages will be logged."));
    g_signal_connect(G_OBJECT(level), "changed", G_CALLBACK(state_change_cb),
                     NULL);

    gtk_box_pack_start(GTK_BOX(hbox), level, FALSE, FALSE, 10);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

    /* clean frequency */
    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
    gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);

    label = gtk_label_new(_("Delete log files older than:"));
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

    age = gtk_combo_box_text_new();
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age),
                                   _("Always delete"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("1 day"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("1 week"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("1 month"));
    select_age();
    g_signal_connect(G_OBJECT(age), "realize",
                     G_CALLBACK(gpredict_set_combo_tooltips),
                     _("Select how often gpredict should delete "
                       "old log files."));
    g_signal_connect(G_OBJECT(age), "changed", G_CALLBACK(state_change_cb),
                     NULL);
    gtk_box_pack_start(GTK_BOX(hbox), age, FALSE, FALSE, 10);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

    /* separator */
    gtk_box_pack_start(GTK_BOX(vbox),
                       gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
                       FALSE, FALSE, 0);

    /* info label */
    confdir = get_user_conf_dir();
    msg =
        g_strdup_printf(_
                        ("Gpredict stores all run-time messages in the %s%slogs%s\n"
                         "directory. The current log file is called gpredict.log and the file is\n"
                         "always kept until the next execution, so that you can examine it in case\n"
                         "of a failure. If old log files are kept, they are called gpredict-XYZ.log\n"
                         "where XYZ is a unique timestamp."), confdir,
                        G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S);
    label = gtk_label_new(msg);
    gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
    gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
    g_free(msg);

    /* reset button */
    rbut = gtk_button_new_with_label(_("Reset"));
    gtk_widget_set_tooltip_text(rbut,
                                _("Reset settings to the default values."));
    g_signal_connect(G_OBJECT(rbut), "clicked", G_CALLBACK(reset_cb), NULL);
    butbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_button_box_set_layout(GTK_BUTTON_BOX(butbox), GTK_BUTTONBOX_END);
    gtk_box_pack_end(GTK_BOX(butbox), rbut, FALSE, TRUE, 10);

    gtk_box_pack_end(GTK_BOX(vbox), butbox, FALSE, TRUE, 0);

    return vbox;
}
Example #4
0
void
FormDialog::multiple_choice (const std::string name,
			     const std::string description,
			     const std::set<std::string> values,
			     const std::map<std::string, std::string> choices,
			     bool advanced)
{
  GtkWidget *label = NULL;
  GtkWidget *scroll = NULL;
  GtkWidget *tree_view = NULL;
  GtkWidget *frame = NULL;

  GtkListStore *list_store = NULL;
  GtkTreeViewColumn *column = NULL;
  GtkCellRenderer *renderer = NULL;
  GtkTreeIter iter;

  gchar *label_text = NULL;

  MultipleChoiceSubmitter *submitter = NULL;

  grow_fields (advanced);

  /* The label */
  label = gtk_label_new (NULL);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
  gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
  g_free (label_text);

  /* The GtkListStore containing the choices */
  tree_view = gtk_tree_view_new ();
  list_store = gtk_list_store_new (MultipleChoiceSubmitter::COLUMN_NUMBER,
                                   G_TYPE_BOOLEAN, G_TYPE_STRING);
  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
  gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);

  frame = gtk_frame_new (NULL);
  gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125);
  gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  scroll = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
				  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
  gtk_container_add (GTK_CONTAINER (frame), scroll);
  gtk_container_add (GTK_CONTAINER (scroll), tree_view);

  renderer = gtk_cell_renderer_toggle_new ();
  column =
    gtk_tree_view_column_new_with_attributes (NULL, renderer,
                                              "active", MultipleChoiceSubmitter::COLUMN_ACTIVE,
                                              NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
  g_signal_connect (renderer, "toggled",
                    G_CALLBACK (multiple_choice_choice_toggled_cb), list_store);

  renderer = gtk_cell_renderer_text_new ();
  column =
    gtk_tree_view_column_new_with_attributes (NULL, renderer,
                                              "text", MultipleChoiceSubmitter::COLUMN_NAME,
                                              NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);


  for (std::map<std::string, std::string>::const_iterator map_iter
	 = choices.begin ();
       map_iter != choices.end ();
       map_iter++) {

    bool active = (std::find (values.begin (), values.end (), map_iter->first) != values.end ());

    gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
    gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
                        MultipleChoiceSubmitter::COLUMN_ACTIVE, active,
                        MultipleChoiceSubmitter::COLUMN_NAME, map_iter->second.c_str (),
                        -1);
  }

  if (advanced) {

    gtk_table_attach (GTK_TABLE (advanced_fields), label,
		      0, 2, advanced_rows - 1, advanced_rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
    gtk_table_attach (GTK_TABLE (advanced_fields), frame,
		      0, 2, advanced_rows - 1, advanced_rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
  } else {

    gtk_table_attach (GTK_TABLE (fields), label,
		      0, 2, rows - 1, rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
    gtk_table_attach (GTK_TABLE (fields), frame,
		      0, 2, rows - 1, rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
  }

  submitter = new MultipleChoiceSubmitter (name, description,
					   choices, advanced, tree_view);
  submitters.push_back (submitter);
}
Example #5
0
static gboolean
maskcor_dialog(MaskcorArgs *args)
{
    MaskcorControls controls;
    GtkWidget *dialog, *table, *chooser, *spin, *combo, *method;
    GtkObject *adj;
    gint row, response;
    gboolean ok;

    controls.args = args;

    dialog = gtk_dialog_new_with_buttons(_("Mask by Correlation"), NULL, 0,
                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                         GTK_STOCK_OK, GTK_RESPONSE_OK,
                                         NULL);
    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
    gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);

    table = gtk_table_new(5, 4, FALSE);
    gtk_table_set_row_spacings(GTK_TABLE(table), 2);
    gtk_table_set_col_spacings(GTK_TABLE(table), 6);
    gtk_container_set_border_width(GTK_CONTAINER(table), 4);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4);
    row = 0;

    /* Kernel */
    chooser = gwy_data_chooser_new_channels();
    g_object_set_data(G_OBJECT(chooser), "dialog", dialog);
    gwy_data_chooser_set_active(GWY_DATA_CHOOSER(chooser), NULL, -1);
    gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(chooser),
                                maskcor_kernel_filter, &args->data, NULL);
    gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(chooser), &args->kernel);
    gwy_data_chooser_get_active_id(GWY_DATA_CHOOSER(chooser), &args->kernel);
    g_signal_connect(chooser, "changed",
                     G_CALLBACK(maskcor_kernel_changed), &args->kernel);
    gwy_table_attach_hscale(table, row, _("Correlation _kernel:"), NULL,
                            GTK_OBJECT(chooser), GWY_HSCALE_WIDGET);
    row++;

    /* Result */
    combo = gwy_enum_combo_box_newl(G_CALLBACK(maskcor_operation_changed),
                                    &controls, args->result,
                                    _("Objects marked"), GWY_MASKCOR_OBJECTS,
                                    _("Correlation maxima"), GWY_MASKCOR_MAXIMA,
                                    _("Correlation score"), GWY_MASKCOR_SCORE,
                                    NULL);
    gwy_table_attach_row(table, row, _("Output _type:"), NULL, combo);
    row++;

    /* Parameters */
    method = gwy_enum_combo_box_new(gwy_correlation_type_get_enum(), -1,
                                    G_CALLBACK(gwy_enum_combo_box_update_int),
                                    &args->method, args->method, TRUE);
    gwy_table_attach_row(table, row, _("Correlation _method:"), NULL, method);
    row++;

    adj = gtk_adjustment_new(args->threshold, -1.0, 1.0, 0.01, 0.1, 0);
    controls.threshold = adj;
    spin = gwy_table_attach_hscale(table, row, _("T_hreshold:"), NULL, adj, 0);
    gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 3);
    gwy_table_hscale_set_sensitive(adj, args->result != GWY_MASKCOR_SCORE);
    g_signal_connect(adj, "value-changed",
                     G_CALLBACK(maskcor_threshold_changed), &args->threshold);
    row++;

    gtk_widget_show_all(dialog);

    do {
        response = gtk_dialog_run(GTK_DIALOG(dialog));
        switch (response) {
            case GTK_RESPONSE_CANCEL:
            case GTK_RESPONSE_DELETE_EVENT:
            gtk_widget_destroy(dialog);
            case GTK_RESPONSE_NONE:
            return FALSE;
            break;

            case GTK_RESPONSE_OK:
            gtk_widget_destroy(dialog);
            ok = TRUE;
            break;

            default:
            g_assert_not_reached();
            break;
        }
    } while (!ok);

    return ok;
}
Example #6
0
struct master *add_master_dialog (struct master *m) {
	GtkWidget *window;
	GtkWidget *main_vbox;
	GtkWidget *table;
	GtkWidget *option_menu;
	GtkWidget *hbox;
	GtkWidget *label;
	GtkWidget *button;
	GtkWidget *hseparator;
	char *typestr;
	enum master_query_type i;
	struct master *master_to_edit;
	char *windowtitle;

	master_name_result = NULL;
	master_addr_result = NULL;
	current_master_query_type = MASTER_NATIVE;

	master_to_edit = NULL;
	master_to_add = NULL;

	for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++)
		master_query_type_radios[i]=NULL;

	master_to_edit = m;

	if (master_to_edit) {
		current_master_query_type = master_to_edit->master_type;
		master_type = master_to_edit->type;
	}
	else {
		// Get last game type added (stored in master_okbutton_callback)
		typestr = config_get_string ("/" CONFIG_FILE "/Add Master/game");
		if (typestr) {
			master_type = id2type (typestr);
			g_free (typestr);
		}
		else {
			master_type = QW_SERVER;
		}
	}

	if (master_to_edit) {
		windowtitle=_("Rename Master");
	}
	else {
		windowtitle=_("Add Master");
	}
	window = dialog_create_modal_transient_window(windowtitle, TRUE, FALSE, NULL);
	main_vbox = gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (window), main_vbox);

	table = gtk_table_new (2, 2, FALSE);
	gtk_table_set_row_spacings (GTK_TABLE (table), 2);
	gtk_table_set_col_spacings (GTK_TABLE (table), 4);
	gtk_container_set_border_width (GTK_CONTAINER (table), 16);
	gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);

	/* Master Name (Description) */

	label = gtk_label_new (_("Master Name"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, 
			GTK_FILL, GTK_FILL, 0, 0);
	gtk_widget_show (label);

	hbox = gtk_hbox_new (FALSE, 4);
	gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 0, 1);

	master_name_combo = gtk_combo_new ();
	gtk_widget_set_usize (master_name_combo, 200, -1);
	gtk_box_pack_start (GTK_BOX (hbox), master_name_combo, TRUE, TRUE, 0);
	gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), 256);
	gtk_combo_set_case_sensitive (GTK_COMBO (master_name_combo), TRUE);
	gtk_combo_set_use_arrows_always (GTK_COMBO (master_name_combo), TRUE);
	gtk_combo_disable_activate (GTK_COMBO (master_name_combo));
	gtk_signal_connect(
			GTK_OBJECT (GTK_COMBO (master_name_combo)->entry), "activate",
			GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window));

	GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_name_combo)->entry, GTK_CAN_FOCUS);
	GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_name_combo)->button, GTK_CAN_FOCUS);
	gtk_widget_grab_focus (GTK_COMBO (master_name_combo)->entry);

	gtk_widget_show (master_name_combo);

	if (master_history_name->items)
		combo_set_vals (master_name_combo, master_history_name->items, "");

	if (master_to_edit) {
		gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), master_to_edit->name);
	}


	/* Master Type Option Menu */

	option_menu = create_server_type_menu (master_type, create_server_type_menu_filter_configured, GTK_SIGNAL_FUNC(select_master_type_callback));

	gtk_box_pack_start (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);

	if (master_to_edit) {
		gtk_widget_set_state (option_menu, GTK_STATE_NORMAL);
		gtk_widget_set_sensitive (GTK_WIDGET(option_menu),FALSE);
	}

	gtk_widget_show (option_menu);

	gtk_widget_show (hbox);

	/* Master Address */

	label = gtk_label_new (_("Master Address"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, 
			GTK_FILL, GTK_FILL, 0, 0);
	gtk_widget_show (label);

	master_addr_combo = gtk_combo_new ();
	gtk_table_attach_defaults (GTK_TABLE (table), master_addr_combo, 1, 2, 1, 2);
	gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), 4096);
	gtk_combo_set_case_sensitive (GTK_COMBO (master_addr_combo), TRUE);
	gtk_combo_set_use_arrows_always (GTK_COMBO (master_addr_combo), TRUE);
	gtk_combo_disable_activate (GTK_COMBO (master_addr_combo));
	gtk_signal_connect (
			GTK_OBJECT (GTK_COMBO (master_addr_combo)->entry), "activate",
			GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window));
	gtk_signal_connect (
			GTK_OBJECT (GTK_COMBO (master_addr_combo)->list),
			"selection-changed",
			GTK_SIGNAL_FUNC
			(master_address_from_history_selected_callback),NULL);

	GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_addr_combo)->entry, GTK_CAN_FOCUS);
	GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_addr_combo)->button, GTK_CAN_FOCUS);
	// gtk_widget_grab_focus (GTK_COMBO (master_addr_combo)->entry);

	gtk_widget_show (master_addr_combo);

	if (master_history_addr->items)
		combo_set_vals (master_addr_combo, master_history_addr->items, "");

	if (master_to_edit) {
		char* url = master_to_url(master_to_edit);
		gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), url);
		gtk_widget_set_state (master_addr_combo, GTK_STATE_NORMAL);
		gtk_widget_set_sensitive (GTK_WIDGET(master_addr_combo),FALSE);
		g_free(url);
	}

	gtk_widget_show (table);

	/* query type */
	hbox = gtk_hbox_new (TRUE, 8);
	for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++) {
		master_query_type_radios[i] =
			gtk_radio_button_new_with_label_from_widget(
					i==MASTER_NATIVE?NULL:GTK_RADIO_BUTTON(master_query_type_radios[MASTER_NATIVE]),
					_(master_designation[i]));
		if (master_to_edit) {
			gtk_widget_set_sensitive (GTK_WIDGET(master_query_type_radios[i]),FALSE);
		}
		gtk_signal_connect(GTK_OBJECT (master_query_type_radios[i]), "toggled",
				GTK_SIGNAL_FUNC (master_type_radio_callback), (gpointer)i);

		gtk_widget_show (master_query_type_radios[i]);
		gtk_box_pack_start (GTK_BOX (hbox),master_query_type_radios[i], FALSE, FALSE, 0);
	}
	if (master_to_edit) {
		master_activate_radio_for_type(current_master_query_type);
	}
	else if (!games[master_type].default_master_port &&
			current_master_query_type == MASTER_NATIVE) {
		gtk_widget_set_state (master_query_type_radios[MASTER_NATIVE], GTK_STATE_NORMAL);
		gtk_widget_set_sensitive
			(GTK_WIDGET(master_query_type_radios[MASTER_NATIVE]),FALSE);
		gtk_toggle_button_set_active
			(GTK_TOGGLE_BUTTON(master_query_type_radios[MASTER_GAMESPY]),TRUE);
	}

	gtk_widget_show (hbox);
	gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);

	/* Separator */

	hseparator = gtk_hseparator_new ();
	gtk_box_pack_start (GTK_BOX (main_vbox), hseparator, FALSE, FALSE, 0);
	gtk_widget_show (hseparator);

	/* Buttons */

	hbox = gtk_hbox_new (FALSE, 8);
	gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
	gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);

	/* Cancel Button */

	button = gtk_button_new_with_label (_("Cancel"));
	gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
	gtk_widget_set_usize (button, 80, -1);
	gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
	GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
	gtk_widget_show (button);

	/* OK Button */

	button = gtk_button_new_with_label ("OK");
	gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
	gtk_widget_set_usize (button, 80, -1);
	gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(master_okbutton_callback), window);
	GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
	gtk_widget_grab_default (button);
	gtk_widget_show (button);

	gtk_widget_show (hbox);

	gtk_widget_show (main_vbox);
	gtk_widget_show (window);

	gtk_main ();

	unregister_window (window);

	return master_to_add;
}
static void
stm_new_transfer_window_ui (StmNewTransferWindow *self)
{
	StmNewTransferWindowPrivate *priv = self->priv;
	
	gtk_window_set_title (GTK_WINDOW (self), _("Add transfer"));

	/* Buttons */
	GtkWidget *close = gtk_dialog_add_button (GTK_DIALOG (self),
	                                          GTK_STOCK_CANCEL,
	                                          GTK_RESPONSE_CANCEL);
	g_signal_connect (G_OBJECT (close), "clicked",
	                  G_CALLBACK (stm_new_transfer_window_close_clicked), self);

	/* Table */
	GtkWidget *table = gtk_table_new (3, 2, FALSE);
	gtk_table_set_row_spacings (GTK_TABLE (table), 6);
	gtk_table_set_col_spacings (GTK_TABLE (table), 6);
	gtk_container_set_border_width (GTK_CONTAINER (table), 12);
	GtkWidget *label;
	
	/* Left column */
	label = gtk_label_new ("");
	gtk_label_set_markup (GTK_LABEL (label), _("<b>URL:</b>"));
	gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
	gtk_table_attach (GTK_TABLE (table), label,
	                  0, 1, 0, 1,
	                  GTK_FILL, GTK_SHRINK, 0, 0);

	label = gtk_label_new ("");
	gtk_label_set_markup (GTK_LABEL (label), _("<b>Save to:</b>"));
	gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
	gtk_table_attach (GTK_TABLE (table), label,
	                  0, 1, 1, 2,
	                  GTK_FILL, GTK_SHRINK, 0, 0);

	/* Right column */
	GtkWidget *entry;
	entry = gtk_entry_new ();
	gtk_table_attach (GTK_TABLE (table), entry,
	                  1, 2, 0, 1,
	                  GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
	priv->source = GTK_ENTRY (entry);
	
	entry = gtk_file_chooser_button_new (_("Select destination"),
	                                     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
	gtk_table_attach (GTK_TABLE (table), entry,
	                  1, 2, 1, 2,
	                  GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
	priv->destination = GTK_FILE_CHOOSER_BUTTON (entry);
	
	entry = gtk_check_button_new_with_label (_("Automatically start transfer"));
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry), TRUE);
	gtk_table_attach (GTK_TABLE (table), entry,
	                  0, 2, 2, 3,
	                  GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
	priv->auto_start = GTK_CHECK_BUTTON (entry);
	
	gtk_widget_show_all (table);
	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), table,
	                    FALSE, FALSE, 0);
	/* Buttons */
	GtkWidget *ok = gtk_dialog_add_button (GTK_DIALOG (self),
	                                       GTK_STOCK_OK,
	                                       GTK_RESPONSE_OK);
	g_signal_connect (G_OBJECT (ok), "clicked",
	                  G_CALLBACK (stm_new_transfer_window_close_clicked), self);
}
Example #8
0
static void configurewin_check_drive(GtkButton *w, gpointer data)
{
	struct driveconfig *drive = data;
	GtkWidget *window, *vbox, *label, *bbox, *closeb;
	char *device, *directory;
	int fd, dae_track = -1;
	GString *str = g_string_new("");
	struct stat stbuf;

	device = gtk_entry_get_text(GTK_ENTRY(drive->device));
	directory = gtk_entry_get_text(GTK_ENTRY(drive->directory));

	if ((fd = open(device, CDOPENFLAGS)) < 0)
		g_string_sprintfa(str, _("Failed to open device %s\n"
					 "Error: %s\n\n"),
				  device, strerror(errno));
	else
	{
		cdda_disc_toc_t toc;
		if (!cdda_get_toc(&toc, device))
			g_string_append(str,
					_("Failed to read \"Table of Contents\""
					  "\nMaybe no disc in the drive?\n\n"));
		else
		{
			int i, data = 0;
			g_string_sprintfa(str, _("Device %s OK.\n"
						 "Disc has %d tracks"), device,
					  toc.last_track - toc.first_track + 1);
			for (i = toc.first_track; i <= toc.last_track; i++)
				if (toc.track[i].flags.data_track)
					data++;
				else if (dae_track < 0)
					dae_track = i;
			if (data > 0)
				g_string_sprintfa(str, _(" (%d data tracks)"),
						  data);
			g_string_sprintfa(str, _("\nTotal length: %d:%.2d\n"),
					  toc.leadout.minute,
					  toc.leadout.second);
#ifdef CDDA_HAS_READAUDIO
			if (dae_track == -1)
				g_string_sprintfa(str,
						  _("Digital audio extraction "
						    "not tested as the disc has "
						    "no audio tracks\n"));
			else
			{
				int start, end, fr;
				char buffer[CD_FRAMESIZE_RAW];
				start = LBA(toc.track[dae_track]);

				if (dae_track == toc.last_track)
					end = LBA(toc.leadout);
				else
					end = LBA(toc.track[dae_track + 1]);
				fr = read_audio_data(fd, start + (end - start) / 2,
						     1, buffer);
				if (fr > 0)
					g_string_sprintfa(str,
						_("Digital audio extraction "
						  "test: OK\n\n"));
				else
					g_string_sprintfa(str,
						_("Digital audio extraction "
						  "test failed: %s\n\n"),
						strerror(-fr));
			}
#else
			g_string_sprintfa(str, "\n");
#endif
		}
		close(fd);
	}

	if (stat(directory, &stbuf) < 0)
	{
		g_string_sprintfa(str, _("Failed to check directory %s\n"
					 "Error: %s"),
				  directory, strerror(errno));
	}
	else
	{
		if (!S_ISDIR(stbuf.st_mode))
			g_string_sprintfa(str,
				_("Error: %s exists, but is not a directory"),
				directory);
		else
		{
			if (!access(directory, R_OK))
				g_string_sprintfa(str, _("Directory %s OK."),
						  directory);
			else
				g_string_sprintfa(str,
						  _("Directory %s exists, but "
						    "you do not have permission "
						    "to access it."),
						  directory);
		}
				
	}
			
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_transient_for(GTK_WINDOW(window),
				     GTK_WINDOW(cdda_configure_win));
	gtk_container_set_border_width(GTK_CONTAINER(window), 10);
	vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	label = gtk_label_new(str->str);
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);

	bbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);

	closeb = gtk_button_new_with_label("Close");
	GTK_WIDGET_SET_FLAGS(closeb, GTK_CAN_DEFAULT);
	gtk_signal_connect_object(GTK_OBJECT(closeb), "clicked",
				  GTK_SIGNAL_FUNC(gtk_widget_destroy),
				  GTK_OBJECT(window));
	gtk_box_pack_start(GTK_BOX(bbox), closeb, TRUE, TRUE, 0);
	gtk_widget_grab_default(closeb);

	g_string_free(str, TRUE);

	gtk_widget_show_all(window);
}
Example #9
0
static GtkWidget* configurewin_add_drive(struct driveinfo *drive, void *nb)
{
	GtkWidget *vbox, *bbox, *dev_frame, *dev_table, *dev_label;
	GtkWidget *dev_dir_label, *check_btn;
	GtkWidget *volume_frame, *volume_box, *volume_none;
	GtkWidget *readmode_frame, *readmode_box, *readmode_analog;
	struct driveconfig *d = g_malloc(sizeof (struct driveconfig));

	vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
	
	dev_frame = gtk_frame_new(_("Device:"));
	gtk_box_pack_start(GTK_BOX(vbox), dev_frame, FALSE, FALSE, 0);
	dev_table = gtk_table_new(2, 2, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(dev_table), 5);
	gtk_container_add(GTK_CONTAINER(dev_frame), dev_table);
	gtk_table_set_row_spacings(GTK_TABLE(dev_table), 5);
	gtk_table_set_col_spacings(GTK_TABLE(dev_table), 5);

	dev_label = gtk_label_new(_("Device:"));
	gtk_misc_set_alignment(GTK_MISC(dev_label), 1.0, 0.5);
	gtk_table_attach(GTK_TABLE(dev_table), dev_label, 0, 1, 0, 1,
			 GTK_FILL, 0, 0, 0);

	d->device = gtk_entry_new();
	gtk_table_attach(GTK_TABLE(dev_table), d->device, 1, 2, 0, 1,
			 GTK_FILL | GTK_EXPAND, 0, 0 , 0);

	dev_dir_label = gtk_label_new(_("Directory:"));
	gtk_misc_set_alignment(GTK_MISC(dev_dir_label), 1.0, 0.5);
	gtk_table_attach(GTK_TABLE(dev_table), dev_dir_label, 0, 1, 1, 2,
			 GTK_FILL, 0, 0, 0);

	d->directory = gtk_entry_new();
	gtk_table_attach(GTK_TABLE(dev_table), d->directory, 1, 2, 1, 2,
			 GTK_FILL | GTK_EXPAND, 0, 0, 0);

	readmode_frame = gtk_frame_new(_("Play mode:"));
	gtk_box_pack_start(GTK_BOX(vbox), readmode_frame, FALSE, FALSE, 0);

	readmode_box = gtk_vbox_new(5, FALSE);
	gtk_container_add(GTK_CONTAINER(readmode_frame), readmode_box);

	readmode_analog = gtk_radio_button_new_with_label(NULL, _("Analog"));
	gtk_box_pack_start(GTK_BOX(readmode_box), readmode_analog, FALSE, FALSE, 0);
	
	d->dae = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(readmode_analog), _("Digital audio extraction"));
	gtk_box_pack_start(GTK_BOX(readmode_box), d->dae, FALSE, FALSE, 0);
#ifndef CDDA_HAS_READAUDIO
	gtk_widget_set_sensitive(readmode_frame, FALSE);
#endif	

	/*
	 * Volume config
	 */

	volume_frame = gtk_frame_new(_("Volume control:"));
	gtk_box_pack_start(GTK_BOX(vbox), volume_frame, FALSE, FALSE, 0);

	volume_box = gtk_vbox_new(5, FALSE);
	gtk_container_add(GTK_CONTAINER(volume_frame), volume_box);

	volume_none = gtk_radio_button_new_with_label(NULL, _("No mixer"));
	gtk_box_pack_start(GTK_BOX(volume_box), volume_none, FALSE, FALSE, 0);

	d->mixer_drive = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(volume_none), _("CD-ROM drive"));
	gtk_box_pack_start(GTK_BOX(volume_box), d->mixer_drive, FALSE, FALSE, 0);

	d->mixer_oss = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(volume_none), _("OSS mixer"));
	gtk_box_pack_start(GTK_BOX(volume_box), d->mixer_oss, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(readmode_analog), "toggled",
			   toggle_set_sensitive_cb, volume_frame);
#ifndef HAVE_OSS
	gtk_widget_set_sensitive(d->mixer_oss, FALSE);
#endif
	if (drive)
	{
		gtk_entry_set_text(GTK_ENTRY(d->device), drive->device);
		gtk_entry_set_text(GTK_ENTRY(d->directory), drive->directory);
		if (drive->mixer == CDDA_MIXER_DRIVE)
			SET_TB(d->mixer_drive);
		else if (drive->mixer == CDDA_MIXER_OSS)
			SET_TB(d->mixer_oss);
		if (drive->dae == CDDA_READ_DAE)
			SET_TB(d->dae);
	}

	bbox = gtk_hbutton_box_new();
	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD);

	check_btn = gtk_button_new_with_label(_("Check drive..."));
	GTK_WIDGET_SET_FLAGS(check_btn, GTK_CAN_DEFAULT);
	gtk_box_pack_start_defaults(GTK_BOX(bbox), check_btn);
	gtk_signal_connect(GTK_OBJECT(check_btn), "clicked",
			   GTK_SIGNAL_FUNC(configurewin_check_drive), d);

	d->remove_button = gtk_button_new_with_label(_("Remove drive"));
	GTK_WIDGET_SET_FLAGS(d->remove_button, GTK_CAN_DEFAULT);
	gtk_box_pack_start_defaults(GTK_BOX(bbox), d->remove_button);
	gtk_signal_connect(GTK_OBJECT(d->remove_button), "clicked",
			   GTK_SIGNAL_FUNC(configurewin_remove_page), nb);


	if (drives == NULL)
		gtk_widget_set_sensitive(d->remove_button, FALSE);
	else
	{
		struct driveconfig *tmp = drives->data;
		gtk_widget_set_sensitive(tmp->remove_button, TRUE);
	}

	drives = g_list_append(drives, d);

	return vbox;
}
Example #10
0
GtkWidget *
mate_volume_applet_dock_new (GtkOrientation orientation,
			      MateVolumeApplet *parent)
{
  /* FIXME: Remove the orientation argument, or fix it for vertical
     boxes (a "horizontal" orientation - the meaning is reversed for
     historical reasons. */

  GtkWidget *button, *scale, *mute, *more, *label;
  GtkWidget *container, *outerline, *innerline, *frame;
  MateVolumeAppletDock *dock;
  gint i;
  static struct {
    GtkWidget * (* sfunc) (GtkAdjustment *adj);
    GtkWidget * (* container) (gboolean, gint);
    GtkWidget * (* subcontainer) (gboolean, gint);
    gint sw, sh;
    gboolean inverted;
  } magic[2] = {
    { gtk_vscale_new, gtk_hbox_new, gtk_vbox_new, -1, 200, TRUE},
    { gtk_hscale_new, gtk_vbox_new, gtk_hbox_new, 200, -1, FALSE}
  };

  dock = g_object_new (MATE_VOLUME_APPLET_TYPE_DOCK,
		       NULL);
  gtk_window_set_screen (GTK_WINDOW (dock),
                         gtk_widget_get_screen(GTK_WIDGET (parent)));
  dock->orientation = orientation;
  dock->model = parent;
  g_signal_connect (dock, "key_press_event", G_CALLBACK (cb_key_press),
		    NULL);

  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
  gtk_container_add (GTK_CONTAINER (dock), frame);

  container = magic[orientation].container (FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (container), 6);
  gtk_container_add (GTK_CONTAINER (frame), container);
  outerline = magic[orientation].subcontainer (FALSE, 0);
  innerline = magic[orientation].subcontainer (FALSE, 0);
  gtk_box_pack_start (GTK_BOX (container), outerline, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (container), innerline, FALSE, FALSE, 0);

  dock->minus = GTK_BUTTON (gtk_button_new ());
  gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->minus),
		      FALSE, FALSE, 0);
  gtk_container_add (GTK_CONTAINER (dock->minus),
		     gtk_image_new_from_stock (GTK_STOCK_REMOVE,
					       GTK_ICON_SIZE_BUTTON));
  dock->plus = GTK_BUTTON (gtk_button_new ());
  gtk_box_pack_end (GTK_BOX (outerline), GTK_WIDGET (dock->plus),
		    FALSE, FALSE, 0);
  gtk_container_add (GTK_CONTAINER (dock->plus),
		     gtk_image_new_from_stock (GTK_STOCK_ADD,
					       GTK_ICON_SIZE_BUTTON));

  button = GTK_WIDGET (dock->plus);
  for (i = 0; i<2; i++) { /* For button in (dock->plus, dock->minus): */
    gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
    g_signal_connect (button, "button-press-event",
		      G_CALLBACK (cb_button_press), dock);
    g_signal_connect (button, "button-release-event",
		      G_CALLBACK (cb_button_release), dock);
    button = GTK_WIDGET (dock->minus);
  }

  scale = magic[orientation].sfunc (NULL);
  g_signal_connect (scale, "key-press-event", G_CALLBACK (proxy_key_event),
		    parent);
  g_signal_connect (scale, "scroll-event", G_CALLBACK (proxy_scroll_event),
		    parent);
  dock->scale = GTK_RANGE (scale);
  gtk_widget_set_size_request (scale,
			       magic[orientation].sw,
			       magic[orientation].sh);
  gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
  gtk_range_set_inverted (dock->scale, magic[orientation].inverted);
  gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->scale),
		      TRUE, TRUE, 0);

  dock->mute = gtk_check_button_new_with_label (_("Mute"));
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->mute),
				mixer_is_muted (dock->model));
  g_signal_connect (dock->mute, "toggled", G_CALLBACK (mute_cb), dock);
  gtk_box_pack_start (GTK_BOX (innerline), dock->mute, TRUE, TRUE, 0);

  more = gtk_button_new_with_label (_("Volume Control..."));
  g_signal_connect (more, "clicked", G_CALLBACK (launch_mixer_cb), dock);
  gtk_box_pack_end (GTK_BOX (innerline), more, TRUE, TRUE, 0);

  gtk_container_add (GTK_CONTAINER (dock), frame);

  return GTK_WIDGET (dock);
}
Example #11
0
int main (int argc, char *argv[])
{
   GtkWidget *load_button;
   GtkWidget *table;
   GtkWidget *pixmapwid;
   GtkStyle *style;
   GdkPixmap *pixmap;
   GdkBitmap *mask;
   GtkWidget *label_core;
   
   GList *glist_gfx = NULL;
   GtkWidget *label_gfx;
   GtkWidget *config_gfx_button;
   GtkWidget *test_gfx_button;
   GtkWidget *about_gfx_button;
   
   GList *glist_audio = NULL;
   GtkWidget *label_audio;
   GtkWidget *config_audio_button;
   GtkWidget *test_audio_button;
   GtkWidget *about_audio_button;
   
   GList *glist_input = NULL;
   GtkWidget *label_input;
   GtkWidget *config_input_button;
   GtkWidget *test_input_button;
   GtkWidget *about_input_button;
   
   GList *glist_RSP = NULL;
   GtkWidget *label_RSP;
   GtkWidget *config_RSP_button;
   GtkWidget *test_RSP_button;
   GtkWidget *about_RSP_button;
   
#ifdef DBG
   if (!g_thread_supported())
     g_thread_init(NULL);
   else
     {
	fprintf(stderr, "mupen64 will certainly have problems with GTK threads.\n");
	fprintf(stderr, "Check your GLIB/GDK/GTK installation for thread support.\n");
     }
#endif
   
   gtk_init(&argc, &argv);
   
   if (argv[0][0] != '/')
     {
	getcwd(cwd, 1024);
	strcat(cwd, "/");
	strcat(cwd, argv[0]);
     }
   else
     strcpy(cwd, argv[0]);
   while(cwd[strlen(cwd)-1] != '/') cwd[strlen(cwd)-1] = '\0';
   
   // création de la fenêtre
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_container_set_border_width(GTK_CONTAINER(window), 10);
   gtk_widget_show(window);
   
   // création du bouton Load rom
   load_button = gtk_button_new_with_label("Load rom...");   
   gtk_widget_show(load_button);
   
   // création du logo
   style = gtk_widget_get_style(window);
   pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask,
					 &style->bg[GTK_STATE_NORMAL],
					 (gchar **)logo_xpm);
   pixmapwid = gtk_pixmap_new(pixmap, mask);
   gtk_widget_show(pixmapwid);
   
   // création de la selection du mode d'émulation
   label_core = gtk_frame_new("cpu core : ");
   gtk_widget_show(label_core);
   interp = gtk_radio_button_new_with_label(NULL, "interpreter");
   gtk_widget_show(interp);
   dynam = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)),
					   "dynamic compiler");
   gtk_widget_show(dynam);
   pure_interp = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)), 
						 "pure interpreter");
   gtk_widget_show(pure_interp);
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dynam), TRUE);
   
   // création de l'option 'debugger'
#ifdef DBG
   button_debug = gtk_check_button_new_with_label("debugger mode");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_debug), FALSE);
   gtk_widget_show(button_debug);
#endif
   
   // recherche des plugins
   plugin_scan_directory(cwd);
   while(plugin_type() != -1)
     switch (plugin_type())
       {
	case PLUGIN_TYPE_GFX:
	  glist_gfx = g_list_append(glist_gfx, plugin_next());
	  break;
	case PLUGIN_TYPE_AUDIO:
	  glist_audio = g_list_append(glist_audio, plugin_next());
	  break;
	case PLUGIN_TYPE_CONTROLLER:
	  glist_input = g_list_append(glist_input, plugin_next());
	  break;
	case PLUGIN_TYPE_RSP:
	  glist_RSP = g_list_append(glist_RSP, plugin_next());
	  break;
       }
   
   label_gfx = gtk_frame_new("gfx plugin : ");
   gtk_widget_show(label_gfx);
   combo_gfx = gtk_combo_new();
   gtk_combo_set_popdown_strings(GTK_COMBO(combo_gfx), glist_gfx);
   gtk_combo_set_value_in_list(GTK_COMBO(combo_gfx), TRUE, FALSE);
   gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_gfx)->entry), FALSE);
   gtk_widget_show(combo_gfx);
   config_gfx_button = gtk_button_new_with_label("Config");
   gtk_widget_show(config_gfx_button);
   test_gfx_button = gtk_button_new_with_label("Test");
   gtk_widget_show(test_gfx_button);
   about_gfx_button = gtk_button_new_with_label("About");
   gtk_widget_show(about_gfx_button);
   
   label_audio = gtk_frame_new("audio plugin : ");
   gtk_widget_show(label_audio);
   combo_audio = gtk_combo_new();
   gtk_combo_set_popdown_strings(GTK_COMBO(combo_audio), glist_audio);
   gtk_combo_set_value_in_list(GTK_COMBO(combo_audio), TRUE, FALSE);
   gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_audio)->entry), FALSE);
   gtk_widget_show(combo_audio);
   config_audio_button = gtk_button_new_with_label("Config");
   gtk_widget_show(config_audio_button);
   test_audio_button = gtk_button_new_with_label("Test");
   gtk_widget_show(test_audio_button);
   about_audio_button = gtk_button_new_with_label("About");
   gtk_widget_show(about_audio_button);
   
   label_input = gtk_frame_new("input plugin : ");
   gtk_widget_show(label_input);
   combo_input = gtk_combo_new();
   gtk_combo_set_popdown_strings(GTK_COMBO(combo_input), glist_input);
   gtk_combo_set_value_in_list(GTK_COMBO(combo_input), TRUE, FALSE);
   gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_input)->entry), FALSE);
   gtk_widget_show(combo_input);
   config_input_button = gtk_button_new_with_label("Config");
   gtk_widget_show(config_input_button);
   test_input_button = gtk_button_new_with_label("Test");
   gtk_widget_show(test_input_button);
   about_input_button = gtk_button_new_with_label("About");
   gtk_widget_show(about_input_button);
   
   label_RSP = gtk_frame_new("RSP plugin : ");
   gtk_widget_show(label_RSP);
   combo_RSP = gtk_combo_new();
   gtk_combo_set_popdown_strings(GTK_COMBO(combo_RSP), glist_RSP);
   gtk_combo_set_value_in_list(GTK_COMBO(combo_RSP), TRUE, FALSE);
   gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_RSP)->entry), FALSE);
   gtk_widget_show(combo_RSP);
   config_RSP_button = gtk_button_new_with_label("Config");
   gtk_widget_show(config_RSP_button);
   test_RSP_button = gtk_button_new_with_label("Test");
   gtk_widget_show(test_RSP_button);
   about_RSP_button = gtk_button_new_with_label("About");
   gtk_widget_show(about_RSP_button);
   
   // mise en place des évenements
   gtk_signal_connect(GTK_OBJECT(window), "delete_event",
		      GTK_SIGNAL_FUNC(delete_event), NULL);
   gtk_signal_connect(GTK_OBJECT(window), "destroy",
		      GTK_SIGNAL_FUNC(destroy), NULL);
   gtk_signal_connect(GTK_OBJECT(load_button), "clicked",
		      GTK_SIGNAL_FUNC(load), NULL);
   gtk_signal_connect(GTK_OBJECT(config_gfx_button), "clicked",
		      GTK_SIGNAL_FUNC(config_gfx), NULL);
   gtk_signal_connect(GTK_OBJECT(test_gfx_button), "clicked",
		      GTK_SIGNAL_FUNC(test_gfx), NULL);
   gtk_signal_connect(GTK_OBJECT(about_gfx_button), "clicked",
		      GTK_SIGNAL_FUNC(about_gfx), NULL);
   gtk_signal_connect(GTK_OBJECT(config_audio_button), "clicked",
		      GTK_SIGNAL_FUNC(config_audio), NULL);
   gtk_signal_connect(GTK_OBJECT(test_audio_button), "clicked",
		      GTK_SIGNAL_FUNC(test_audio), NULL);
   gtk_signal_connect(GTK_OBJECT(about_audio_button), "clicked",
		      GTK_SIGNAL_FUNC(about_audio), NULL);
   gtk_signal_connect(GTK_OBJECT(config_input_button), "clicked",
		      GTK_SIGNAL_FUNC(config_input), NULL);
   gtk_signal_connect(GTK_OBJECT(test_input_button), "clicked",
		      GTK_SIGNAL_FUNC(test_input), NULL);
   gtk_signal_connect(GTK_OBJECT(about_input_button), "clicked",
		      GTK_SIGNAL_FUNC(about_input), NULL);
   gtk_signal_connect(GTK_OBJECT(config_RSP_button), "clicked",
		      GTK_SIGNAL_FUNC(config_RSP), NULL);
   gtk_signal_connect(GTK_OBJECT(test_RSP_button), "clicked",
		      GTK_SIGNAL_FUNC(test_RSP), NULL);
   gtk_signal_connect(GTK_OBJECT(about_RSP_button), "clicked",
		      GTK_SIGNAL_FUNC(about_RSP), NULL);
   
   // mise en page
   table = gtk_table_new(55, 30, TRUE);
   gtk_widget_show(table);
   
   gtk_container_add(GTK_CONTAINER(window), table);
   gtk_table_attach_defaults(GTK_TABLE(table), load_button, 0, 10, 0, 3);
   gtk_table_attach_defaults(GTK_TABLE(table), label_core, 0, 10, 5, 15);
   gtk_table_attach_defaults(GTK_TABLE(table), pixmapwid, 10, 30, 0, 10);
   gtk_table_attach_defaults(GTK_TABLE(table), interp, 1, 10, 6, 9);
   gtk_table_attach_defaults(GTK_TABLE(table), dynam, 1, 10, 9, 12);
   gtk_table_attach_defaults(GTK_TABLE(table), pure_interp, 1, 10, 12, 15);
   
#ifdef DBG
   gtk_table_attach_defaults(GTK_TABLE(table), button_debug, 15, 25, 12, 15);
#endif
   
   gtk_table_attach_defaults(GTK_TABLE(table), label_gfx, 0, 30, 15, 25);
   gtk_table_attach_defaults(GTK_TABLE(table), combo_gfx, 1, 29, 17, 22);
   gtk_table_attach_defaults(GTK_TABLE(table), config_gfx_button, 1, 10, 22, 24);
   gtk_table_attach_defaults(GTK_TABLE(table), test_gfx_button, 10, 20, 22, 24);
   gtk_table_attach_defaults(GTK_TABLE(table), about_gfx_button, 20, 29, 22, 24);
   
   gtk_table_attach_defaults(GTK_TABLE(table), label_audio, 0, 30, 25, 35);
   gtk_table_attach_defaults(GTK_TABLE(table), combo_audio, 1, 29, 27, 32);
   gtk_table_attach_defaults(GTK_TABLE(table), config_audio_button, 1, 10, 32, 34);
   gtk_table_attach_defaults(GTK_TABLE(table), test_audio_button, 10, 20, 32, 34);
   gtk_table_attach_defaults(GTK_TABLE(table), about_audio_button, 20, 29, 32, 34);
   
   gtk_table_attach_defaults(GTK_TABLE(table), label_input, 0, 30, 35, 45);
   gtk_table_attach_defaults(GTK_TABLE(table), combo_input, 1, 29, 37, 42);
   gtk_table_attach_defaults(GTK_TABLE(table), config_input_button, 1, 10, 42, 44);
   gtk_table_attach_defaults(GTK_TABLE(table), test_input_button, 10, 20, 42, 44);
   gtk_table_attach_defaults(GTK_TABLE(table), about_input_button, 20, 29, 42, 44);
   
   gtk_table_attach_defaults(GTK_TABLE(table), label_RSP, 0, 30, 45, 55);
   gtk_table_attach_defaults(GTK_TABLE(table), combo_RSP, 1, 29, 47, 52);
   gtk_table_attach_defaults(GTK_TABLE(table), config_RSP_button, 1, 10, 52, 54);
   gtk_table_attach_defaults(GTK_TABLE(table), test_RSP_button, 10, 20, 52, 54);
   gtk_table_attach_defaults(GTK_TABLE(table), about_RSP_button, 20, 29, 52, 54);
   
   gtk_main();
   
   return 0;
}
Example #12
0
File: menu.c Project: g7/fbpanel
/* Creates menu item. Text and image are read from xconf. Action
 * depends on @menu. If @menu is NULL, action is to execute external
 * command. Otherwise it is to pop up @menu menu */
static GtkWidget *
menu_create_item(xconf *xc, GtkWidget *menu, menu_priv *m)
{
    gchar *name, *fname, *iname, *action, *cmd;
    GtkWidget *mi;
    
    cmd = name = fname = action = iname = NULL;
    XCG(xc, "name", &name, str);
    mi = gtk_image_menu_item_new_with_label(name ? name : "");
    gtk_container_set_border_width(GTK_CONTAINER(mi), 0);
    XCG(xc, "image", &fname, str);
    fname = expand_tilda(fname);
    XCG(xc, "icon", &iname, str);
    if (fname || iname)
    {
        GdkPixbuf *pb;
        
        if ((pb = fb_pixbuf_new(iname, fname, m->icon_size, m->icon_size,
                    FALSE)))
        {
            gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi),
                    gtk_image_new_from_pixbuf(pb));
            g_object_unref(G_OBJECT(pb));
        }
    }
    g_free(fname);

    if (menu)
    {
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), menu);
        goto done;
    }
    XCG(xc, "action", &action, str);
    if (action)
    {
        action = expand_tilda(action);

        g_signal_connect_swapped(G_OBJECT(mi), "activate",
                (GCallback)run_app, action);
        g_object_set_data_full(G_OBJECT(mi), "activate",
            action, g_free);
        goto done;
    }
    XCG(xc, "command", &cmd, str);
    if (cmd)
    {
        /* XXX: implement command API */
#if 0
        command *tmp;
        
        for (tmp = commands; tmp->name; tmp++)
            if (!g_ascii_strcasecmp(cmd, tmp->name))
            {
                g_signal_connect(G_OBJECT(mi), "activate",
                        (GCallback)run_command, tmp->cmd);
                goto done;
            }
#endif        
    }
   
done:
    return mi;
}
Example #13
0
int l_uosindm(int innom,GtkWidget *wpredok)
{
l_uosindm_data data;
char bros[512];
SQL_str row;
class SQLCURSOR cur;
data.innom=innom;

sprintf(bros,"select naim from Uosin where innom=%d",innom);
if(iceb_sql_readkey(bros,&row,&cur,wpredok) == 1)
 data.naim_in.new_plus(row[0]);


data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);



sprintf(bros,"%s %s",name_system,gettext("Список драгоценных металлов"));

gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);

gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);


if(wpredok != NULL)
 {
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
  //Удерживать окно над породившем его окном всегда
  gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
  //Закрыть окно если окно предок удалено
  gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
 }

gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosindm_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);

GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);

GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);

gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);

data.label_kolstr=gtk_label_new (gettext("Список драгоценных металлов"));
//gdk_color_parse("green",&color);
//gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color);


gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);

gtk_widget_show(vbox1);
gtk_widget_show(vbox2);


data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);

gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);

//Кнопки
GtkTooltips *tooltips[KOL_F_KL];

sprintf(bros,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);

sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);


sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);


sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);

sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);


gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));

gtk_widget_grab_focus(data.knopka[FK10]);

l_uosindm_create_list(&data);

gtk_widget_show(data.window);
gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));


gtk_main();


if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

return(data.metka_voz);

}
Example #14
0
static void create_adapter(adapter_data *adapter)
{
	GHashTable *hash = NULL;
	GValue *value;
	DBusGProxy *default_proxy;
	const gchar *name;
	gboolean powered, discoverable;
	guint timeout;

	GtkWidget *mainbox;
	GtkWidget *vbox;
	GtkWidget *alignment;
	GtkWidget *table;
	GtkWidget *label;
	GtkWidget *image;
	GtkWidget *button;
	GtkWidget *entry;
	GtkWidget *buttonbox;
	int page_num;

	dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID,
				dbus_g_type_get_map("GHashTable",
						G_TYPE_STRING, G_TYPE_VALUE),
				&hash, G_TYPE_INVALID);

	if (hash != NULL) {
		value = g_hash_table_lookup(hash, "Name");
		name = value ? g_value_get_string(value) : NULL;

		value = g_hash_table_lookup(hash, "Powered");
		powered = value ? g_value_get_boolean(value) : FALSE;

		value = g_hash_table_lookup(hash, "Discoverable");
		discoverable = value ? g_value_get_boolean(value) : FALSE;

		value = g_hash_table_lookup(hash, "DiscoverableTimeout");
		timeout = value ? g_value_get_uint(value) : 0;
	} else {
		name = NULL;
		powered = FALSE;
		discoverable = FALSE;
		timeout = 0;
	}

	adapter->powered = powered;
	adapter->discoverable = discoverable;
	adapter->timeout_value = timeout;

	default_proxy = bluetooth_client_get_default_adapter (client);
	if (default_proxy != NULL) {
		adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy),
						   dbus_g_proxy_get_path (adapter->proxy));
		g_object_unref (default_proxy);
	}

	mainbox = gtk_vbox_new(FALSE, 6);
	gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12);

	page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook),
							mainbox, NULL);

	adapter->child = mainbox;

	vbox = gtk_vbox_new(FALSE, 6);
	gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0);

	/* The discoverable checkbox */
	button = gtk_check_button_new_with_mnemonic (_("Make computer _visible"));
	if (powered == FALSE)
		discoverable = FALSE;
	if (discoverable != FALSE && timeout == 0)
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
	else if (discoverable == FALSE)
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
	else {
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
		gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
	}
	gtk_widget_set_sensitive (button, adapter->powered);

	adapter->button_discoverable = button;
	adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled",
							G_CALLBACK(discoverable_changed_cb), adapter);

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

	/* The friendly name */
	vbox = gtk_vbox_new(FALSE, 6);
	gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0);

	label = create_label(_("Friendly name"));
	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);

	entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(entry), 248);
	gtk_widget_set_size_request(entry, 240, -1);
	gtk_container_add (GTK_CONTAINER (alignment), entry);

	if (name != NULL)
		gtk_entry_set_text(GTK_ENTRY(entry), name);

	adapter->entry = entry;
	adapter->name_vbox = vbox;

	g_signal_connect(G_OBJECT(entry), "changed",
					G_CALLBACK(name_callback), adapter);
	g_signal_connect(G_OBJECT(entry), "focus-out-event",
					G_CALLBACK(focus_callback), adapter);

	gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered);

	/* The known devices */
	table = gtk_table_new(2, 2, FALSE);
	gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0);

	label = create_label(_("Devices"));
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1,
			 GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6);

	/* Note that this will only ever show the devices on the default
	 * adapter, this is on purpose */
	adapter->chooser = bluetooth_chooser_new (NULL);
	g_object_set (adapter->chooser,
		      "show-searching", FALSE,
		      "show-device-type", FALSE,
		      "show-device-category", FALSE,
		      "show-pairing", TRUE,
		      "show-connected", TRUE,
		      "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED,
		      NULL);

	g_signal_connect (adapter->chooser, "notify::device-selected",
			  G_CALLBACK(device_selected_cb), adapter);

	gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2,
			 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

	adapter->devices_table = table;

	buttonbox = gtk_vbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox),
						GTK_BUTTONBOX_START);
	gtk_box_set_spacing(GTK_BOX(buttonbox), 6);
	gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE);
	gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2,
			 GTK_FILL, GTK_FILL, 6, 6);

	button = gtk_button_new_with_mnemonic(_("Set up _new device..."));
	image = gtk_image_new_from_stock(GTK_STOCK_ADD,
						GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image(GTK_BUTTON(button), image);
	gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);

	g_signal_connect(G_OBJECT(button), "clicked",
				G_CALLBACK(wizard_callback), adapter);

	button = gtk_button_new_with_label(_("Disconnect"));
	image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT,
						GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image(GTK_BUTTON(button), image);
	gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
	gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox),
								button, TRUE);
	gtk_widget_set_sensitive(button, FALSE);

	g_signal_connect(G_OBJECT(button), "clicked",
				G_CALLBACK(disconnect_callback), adapter);

	adapter->button_disconnect = button;

	button = gtk_button_new_with_mnemonic(_("_Remove"));
	image = gtk_image_new_from_stock(GTK_STOCK_REMOVE,
						GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image(GTK_BUTTON(button), image);
	gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
	gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox),
								button, TRUE);
	gtk_widget_set_sensitive(button, FALSE);

	g_signal_connect(G_OBJECT(button), "clicked",
				G_CALLBACK(remove_callback), adapter);

	adapter->button_delete = button;

	gtk_widget_set_sensitive (adapter->devices_table, adapter->powered);

	g_object_set_data(G_OBJECT(mainbox), "adapter", adapter);

	gtk_widget_show_all(mainbox);

	if (adapter->is_default != FALSE)
		gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num);
}
/**
 * create_directory_config_window(): Create the Directory Configuration Window.
 * @return Directory Configuration Window.
 */
GtkWidget* create_directory_config_window(void)
{
	GdkPixbuf *directory_config_window_icon_pixbuf;
	GtkWidget *vbox_dc;
	GtkWidget *frame_direntry = NULL, *label_frame_direntry = NULL, *table_frame_direntry = NULL;
	GtkWidget *label_direntry = NULL, *entry_direntry = NULL, *button_direntry = NULL;
	GtkWidget *hbutton_box_dc_buttonRow;
	GtkWidget *button_dc_Cancel, *button_dc_Apply, *button_dc_Save;
	
	char tmp[64];
	int dir = 0;
	
	if (directory_config_window)
	{
		// Directory Configuration window is already created. Set focus.
		gtk_widget_grab_focus(directory_config_window);
		return NULL;
	}
	
	accel_group = gtk_accel_group_new();
	
	// Create the Directory Configuration window.
	CREATE_GTK_WINDOW(directory_config_window,
			  "directory_config_window",
			  "Configure Directories",
			  directory_config_window_icon_pixbuf, "Gens2.ico");
	
	// Callbacks for if the window is closed.
	g_signal_connect((gpointer)directory_config_window, "delete_event",
			 G_CALLBACK(on_directory_config_window_close), NULL);
	g_signal_connect((gpointer)directory_config_window, "destroy_event",
			 G_CALLBACK(on_directory_config_window_close), NULL);
	
	// Create the main VBox.
	vbox_dc = gtk_vbox_new(FALSE, 10);
	gtk_widget_set_name(vbox_dc, "vbox_dc");
	gtk_widget_show(vbox_dc);
	gtk_container_add(GTK_CONTAINER(directory_config_window), vbox_dc);
	GLADE_HOOKUP_OBJECT(directory_config_window, vbox_dc, "vbox_dc");
	
	// Create the directory entry frame.
	frame_direntry = gtk_frame_new(NULL);
	gtk_widget_set_name(frame_direntry, "frame_direntry");
	gtk_container_set_border_width(GTK_CONTAINER(frame_direntry), 4);
	gtk_frame_set_shadow_type(GTK_FRAME(frame_direntry), GTK_SHADOW_ETCHED_IN);
	gtk_widget_show(frame_direntry);
	gtk_box_pack_start(GTK_BOX(vbox_dc), frame_direntry, TRUE, TRUE, 0);
	GLADE_HOOKUP_OBJECT(directory_config_window, frame_direntry, "frame_direntry");
	
	// Add the frame label.
	label_frame_direntry = gtk_label_new("<b><i>Configure Directories</i></b>");
	gtk_widget_set_name(label_frame_direntry, "label_frame_direntry");
	gtk_label_set_use_markup(GTK_LABEL(label_frame_direntry), TRUE);
	gtk_widget_show(label_frame_direntry);
	gtk_frame_set_label_widget(GTK_FRAME(frame_direntry), label_frame_direntry);
	GLADE_HOOKUP_OBJECT(directory_config_window, label_frame_direntry, "label_frame_direntry");
	
	// Add the frame table.
	table_frame_direntry = gtk_table_new(1, 3, FALSE);
	gtk_widget_set_name(table_frame_direntry, "table_frame_direntry");
	gtk_container_set_border_width(GTK_CONTAINER(table_frame_direntry), 8);
	gtk_table_set_row_spacings(GTK_TABLE(table_frame_direntry), 4);
	gtk_table_set_col_spacings(GTK_TABLE(table_frame_direntry), 4);
	gtk_widget_show(table_frame_direntry);
	gtk_container_add(GTK_CONTAINER(frame_direntry), table_frame_direntry);
	GLADE_HOOKUP_OBJECT(directory_config_window, table_frame_direntry, "table_frame_direntry");
	
	// Create all directory entries.
	while (DirEntries[dir].title)
	{
		// Check if the table needs to be resized.
		if (dir > 0)
			gtk_table_resize(GTK_TABLE(table_frame_direntry), dir + 1, 3);
		
		// Create the label for this file.
		sprintf(tmp, "label_%s", DirEntries[dir].tag);
		label_direntry = gtk_label_new(DirEntries[dir].title);
		gtk_widget_set_name(label_direntry, tmp);
		gtk_widget_set_size_request(label_direntry, 100, -1);
		gtk_misc_set_alignment(GTK_MISC(label_direntry), 0, 0.5);
		gtk_widget_show(label_direntry);
		gtk_table_attach(GTK_TABLE(table_frame_direntry), label_direntry,
					0, 1, dir, dir + 1,
					(GtkAttachOptions)(GTK_FILL),
					(GtkAttachOptions)(0), 0, 0);
		GLADE_HOOKUP_OBJECT(directory_config_window, label_direntry, tmp);
		
		// Create the entry for this file.
		sprintf(tmp, "entry_%s", DirEntries[dir].tag);
		entry_direntry = gtk_entry_new();
		gtk_widget_set_name(entry_direntry, tmp);
		gtk_entry_set_max_length(GTK_ENTRY(entry_direntry), GENS_PATH_MAX - 1);
		gtk_entry_set_text(GTK_ENTRY(entry_direntry), DirEntries[dir].entry);
		gtk_widget_set_size_request(entry_direntry, 250, -1);
		gtk_widget_show(entry_direntry);
		gtk_table_attach(GTK_TABLE(table_frame_direntry), entry_direntry,
					1, 2, dir, dir + 1,
					(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
					(GtkAttachOptions)(0), 0, 0);
		GLADE_HOOKUP_OBJECT(directory_config_window, entry_direntry, tmp);
		
		// Create the button for this file.
		// TODO: Use an icon?
		sprintf(tmp, "button_%s", DirEntries[dir].tag);
		button_direntry = gtk_button_new_with_label("Change...");
		gtk_widget_set_name(button_direntry, tmp);
		gtk_widget_show(button_direntry);
		gtk_table_attach(GTK_TABLE(table_frame_direntry), button_direntry,
				 2, 3, dir, dir + 1,
				 (GtkAttachOptions)(GTK_FILL),
				 (GtkAttachOptions)(0), 0, 0);
		g_signal_connect((gpointer)button_direntry, "clicked",
				 G_CALLBACK(on_button_dc_Change_clicked),
				 GINT_TO_POINTER(dir));
		GLADE_HOOKUP_OBJECT(directory_config_window, button_direntry, tmp);
		
		dir++;
	}
	
	// HButton Box for the row of buttons on the bottom of the window
	hbutton_box_dc_buttonRow = gtk_hbutton_box_new();
	gtk_widget_set_name(hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow");
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbutton_box_dc_buttonRow), GTK_BUTTONBOX_END);
	gtk_widget_show(hbutton_box_dc_buttonRow);
	gtk_box_pack_start(GTK_BOX(vbox_dc), hbutton_box_dc_buttonRow, FALSE, FALSE, 0);
	GLADE_HOOKUP_OBJECT(directory_config_window, hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow");
	
	// Cancel
	button_dc_Cancel = gtk_button_new_from_stock("gtk-cancel");
	gtk_widget_set_name(button_dc_Cancel, "button_dc_cancel");
	gtk_widget_show(button_dc_Cancel);
	gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Cancel, FALSE, FALSE, 0);
	gtk_widget_add_accelerator(button_dc_Cancel, "activate", accel_group,
				   GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0));
	AddButtonCallback_Clicked(button_dc_Cancel, on_button_dc_Cancel_clicked);
	GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Cancel, "button_dc_Cancel");
	
	// Apply
	button_dc_Apply = gtk_button_new_from_stock("gtk-apply");
	gtk_widget_set_name(button_dc_Apply, "button_dc_Apply");
	gtk_widget_show(button_dc_Apply);
	gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Apply, FALSE, FALSE, 0);
	gtk_widget_add_accelerator(button_dc_Apply, "activate", accel_group,
				   GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0));
	AddButtonCallback_Clicked(button_dc_Apply, on_button_dc_Apply_clicked);
	GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Apply, "button_dc_Apply");
	
	// Save
	button_dc_Save = gtk_button_new_from_stock("gtk-save");
	gtk_widget_set_name(button_dc_Save, "button_dc_Save");
	gtk_widget_show(button_dc_Save);
	gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Save, FALSE, FALSE, 0);
	gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group,
				   GDK_Return, (GdkModifierType)(0), (GtkAccelFlags)(0));
	gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group,
				   GDK_KP_Enter, (GdkModifierType)(0), (GtkAccelFlags)(0));
	AddButtonCallback_Clicked(button_dc_Save, on_button_dc_Save_clicked);
	GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Save, "button_dc_Save");
	
	// Add the accel group.
	gtk_window_add_accel_group(GTK_WINDOW(directory_config_window), accel_group);
	
	return directory_config_window;
}
Example #16
0
void cdda_configure(void)
{
	GtkWidget *vbox, *notebook;
	GtkWidget *dev_vbox, *dev_notebook, *add_drive, *add_bbox;
	GtkWidget *cdi_vbox;
	GtkWidget *cdi_cddb_frame, *cdi_cddb_vbox, *cdi_cddb_hbox;
	GtkWidget *cdi_cddb_server_hbox, *cdi_cddb_server_label;
	GtkWidget *cdi_cddb_server_list, *cdi_cddb_debug_win;
#if 0
	GtkWidget *cdi_cdin_frame, *cdi_cdin_vbox;
	GtkWidget *cdi_cdin_server_hbox, *cdi_cdin_server_label;
#endif
	GtkWidget *cdi_name_frame, *cdi_name_vbox, *cdi_name_hbox;
	GtkWidget *cdi_name_label, *cdi_desc;
	GtkWidget *cdi_name_enable_vbox;
	GtkWidget *bbox, *ok, *cancel;

	GList *node;
	int i = 1;

	if (cdda_configure_win)
		return;
	
	cdda_configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_signal_connect(GTK_OBJECT(cdda_configure_win), "destroy",
			   GTK_SIGNAL_FUNC(gtk_widget_destroyed),
			   &cdda_configure_win);
	gtk_window_set_title(GTK_WINDOW(cdda_configure_win),
			     _("CD Audio Player Configuration"));
	gtk_window_set_policy(GTK_WINDOW(cdda_configure_win), FALSE, FALSE, FALSE);
	gtk_window_set_position(GTK_WINDOW(cdda_configure_win), GTK_WIN_POS_MOUSE);
	gtk_container_border_width(GTK_CONTAINER(cdda_configure_win), 10);

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

	notebook = gtk_notebook_new();
	gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);

	/*
	 * Device config
	 */
	dev_vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5);

	dev_notebook = gtk_notebook_new();
	gtk_notebook_set_scrollable(GTK_NOTEBOOK(dev_notebook), TRUE);
	gtk_box_pack_start(GTK_BOX(dev_vbox), dev_notebook, FALSE, FALSE, 0);

	for (node = cdda_cfg.drives; node; node = node->next)
	{
		struct driveinfo *drive = node->data;
		char *label = g_strdup_printf(_("Drive %d"), i++);
		GtkWidget *w;

		w = configurewin_add_drive(drive, dev_notebook);
		gtk_notebook_append_page(GTK_NOTEBOOK(dev_notebook), w,
					 gtk_label_new(label));
		g_free(label);

	}

	add_bbox = gtk_hbutton_box_new();
	gtk_box_pack_start(GTK_BOX(dev_vbox), add_bbox, FALSE, FALSE, 0);
	add_drive = gtk_button_new_with_label(_("Add drive"));
	gtk_signal_connect(GTK_OBJECT(add_drive), "clicked",
			   GTK_SIGNAL_FUNC(configurewin_add_page), dev_notebook);
	GTK_WIDGET_SET_FLAGS(add_drive, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(add_bbox), add_drive, FALSE, FALSE, 0);

	
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dev_vbox,
				 gtk_label_new(_("Device")));

	/*
	 * CD Info config
	 */
	cdi_vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_set_border_width(GTK_CONTAINER(cdi_vbox), 5);


	/* CDDB */
	cdi_cddb_frame = gtk_frame_new(_("CDDB:"));
	gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cddb_frame, FALSE, FALSE, 0);

	cdi_cddb_vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_border_width(GTK_CONTAINER(cdi_cddb_vbox), 5);
	gtk_container_add(GTK_CONTAINER(cdi_cddb_frame), cdi_cddb_vbox);

	cdi_cddb_hbox = gtk_hbox_new(FALSE, 10);
	gtk_container_border_width(GTK_CONTAINER(cdi_cddb_hbox), 0);
	gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox),
			   cdi_cddb_hbox, FALSE, FALSE, 0);
	cdi_use_cddb = gtk_check_button_new_with_label(_("Use CDDB"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cddb),
				     cdda_cfg.use_cddb);
	gtk_box_pack_start(GTK_BOX(cdi_cddb_hbox), cdi_use_cddb, FALSE, FALSE, 0);
	cdi_cddb_server_list = gtk_button_new_with_label(_("Get server list"));
	gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox), cdi_cddb_server_list, FALSE, FALSE, 0);
	cdi_cddb_debug_win = gtk_button_new_with_label(_("Show network window"));
	gtk_signal_connect(GTK_OBJECT(cdi_cddb_debug_win), "clicked",
			   GTK_SIGNAL_FUNC(cdda_cddb_show_network_window), NULL);
	gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox),
			 cdi_cddb_debug_win, FALSE, FALSE, 0);

	cdi_cddb_server_hbox = gtk_hbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox),
			   cdi_cddb_server_hbox, FALSE, FALSE, 0);

	cdi_cddb_server_label = gtk_label_new(_("CDDB server:"));
	gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox),
			   cdi_cddb_server_label, FALSE, FALSE, 0);

	cdi_cddb_server = gtk_entry_new();
	gtk_entry_set_text(GTK_ENTRY(cdi_cddb_server), cdda_cfg.cddb_server);
	gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox), cdi_cddb_server, TRUE, TRUE, 0);
	gtk_signal_connect(GTK_OBJECT(cdi_cddb_server_list), "clicked",
			   GTK_SIGNAL_FUNC(cdda_cddb_show_server_dialog),
			   cdi_cddb_server);

#if 0
	/*
	 * CDindex
	 */
	cdi_cdin_frame = gtk_frame_new(_("CD Index:"));
	gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cdin_frame, FALSE, FALSE, 0);

	cdi_cdin_vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_border_width(GTK_CONTAINER(cdi_cdin_vbox), 5);
	gtk_container_add(GTK_CONTAINER(cdi_cdin_frame), cdi_cdin_vbox);

	cdi_use_cdin = gtk_check_button_new_with_label(_("Use CD Index"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cdin), cdda_cfg.use_cdin);
	gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_use_cdin, FALSE, FALSE, 0);

	cdi_cdin_server_hbox = gtk_hbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_cdin_server_hbox, FALSE, FALSE, 0);

	cdi_cdin_server_label = gtk_label_new(_("CD Index server:"));
	gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server_label,
			   FALSE, FALSE, 0);

	cdi_cdin_server = gtk_entry_new();
	gtk_entry_set_text(GTK_ENTRY(cdi_cdin_server), cdda_cfg.cdin_server);
	gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server, TRUE, TRUE, 0);
#ifndef WITH_CDINDEX
	gtk_widget_set_sensitive(cdi_cdin_frame, FALSE);
#endif
#endif

	/*
	 * Track names
	 */
	cdi_name_frame = gtk_frame_new(_("Track names:"));
	gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_name_frame, FALSE, FALSE, 0);

	cdi_name_vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_add(GTK_CONTAINER(cdi_name_frame), cdi_name_vbox);
	gtk_container_border_width(GTK_CONTAINER(cdi_name_vbox), 5);
	cdi_name_override = gtk_check_button_new_with_label(_("Override generic titles"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_name_override),
				     cdda_cfg.title_override);
	gtk_box_pack_start(GTK_BOX(cdi_name_vbox), cdi_name_override, FALSE, FALSE, 0);

	cdi_name_enable_vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_add(GTK_CONTAINER(cdi_name_vbox), cdi_name_enable_vbox);
	gtk_widget_set_sensitive(cdi_name_enable_vbox, cdda_cfg.title_override);
	gtk_signal_connect(GTK_OBJECT(cdi_name_override), "toggled",
			   toggle_set_sensitive_cb, cdi_name_enable_vbox);

	cdi_name_hbox = gtk_hbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_name_hbox, FALSE, FALSE, 0);
	cdi_name_label = gtk_label_new(_("Name format:"));
	gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name_label, FALSE, FALSE, 0);
	cdi_name = gtk_entry_new();
	gtk_entry_set_text(GTK_ENTRY(cdi_name), cdda_cfg.name_format);
	gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name, TRUE, TRUE, 0);

	cdi_desc = xmms_titlestring_descriptions("patn", 2);
	gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_desc, FALSE, FALSE, 0);

	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), cdi_vbox,
				 gtk_label_new(_("CD Info")));

	bbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);

	ok = gtk_button_new_with_label(_("OK"));
	gtk_signal_connect(GTK_OBJECT(ok), "clicked",
			   GTK_SIGNAL_FUNC(cdda_configurewin_ok_cb), NULL);
	gtk_signal_connect(GTK_OBJECT(ok), "clicked",
			   GTK_SIGNAL_FUNC(configurewin_close), NULL);
	GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
	gtk_widget_grab_default(ok);

	cancel = gtk_button_new_with_label(_("Cancel"));
	gtk_signal_connect(GTK_OBJECT(cancel), "clicked",
			   GTK_SIGNAL_FUNC(configurewin_close), NULL);
	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);

	gtk_widget_show_all(cdda_configure_win);
}
Example #17
0
int main( int   argc,
          char *argv[] )
{
    /* GtkWidget is the storage type for widgets */
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *box1;

    /* This is called in all GTK applications. Arguments are parsed
     * from the command line and are returned to the application. */
    gtk_init (&argc, &argv);

    /* Create a new window */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    /* This is a new call, which just sets the title of our
     * new window to "Hello Buttons!" */
    gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");

    /* Here we just set a handler for delete_event that immediately
     * exits GTK. */
    g_signal_connect (window, "delete-event",
		      G_CALLBACK (delete_event), NULL);

    /* Sets the border width of the window. */
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);

    /* We create a box to pack widgets into.  This is described in detail
     * in the "packing" section. The box is not really visible, it
     * is just used as a tool to arrange widgets. */
    box1 = gtk_hbox_new (FALSE, 0);

    /* Put the box into the main window. */
    gtk_container_add (GTK_CONTAINER (window), box1);

    /* Creates a new button with the label "Button 1". */
    button = gtk_button_new_with_label ("Button 1");
    
    /* Now when the button is clicked, we call the "callback" function
     * with a pointer to "button 1" as its argument */
    g_signal_connect (button, "clicked",
		      G_CALLBACK (callback), (gpointer) "button 1");

    /* Instead of gtk_container_add, we pack this button into the invisible
     * box, which has been packed into the window. */
    gtk_box_pack_start (GTK_BOX(box1), button, TRUE, TRUE, 0);

    /* Always remember this step, this tells GTK that our preparation for
     * this button is complete, and it can now be displayed. */
    gtk_widget_show (button);

    /* Do these same steps again to create a second button */
    button = gtk_button_new_with_label ("Button 2");

    /* Call the same callback function with a different argument,
     * passing a pointer to "button 2" instead. */
    g_signal_connect (button, "clicked",
		      G_CALLBACK (callback), (gpointer) "button 2");

    gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0);

    /* The order in which we show the buttons is not really important, but I
     * recommend showing the window last, so it all pops up at once. */
    gtk_widget_show (button);

    gtk_widget_show (box1);

    gtk_widget_show (window);
    
    /* Rest in gtk_main and wait for the fun to begin! */
    gtk_main ();

    return 0;
}
Example #18
0
bool gtkgui_init(int argc, char *argv[], Stream_mixer *mix)
{

	GtkWidget *bbox = NULL;
	bool isx = false;
	/* FIXME: bisogan mettere l'enable_nls*/
	/* i18n */
	setlocale(LC_ALL, "");
	bindtextdomain("muse", LOCALEDIR);
	bind_textdomain_codeset("muse", "UTF-8");
	textdomain("muse");
	
	/* initialization */
	state = true;
	mixer = mix;
	
	list_init(&listachan);
	list_init(&lamelist);
	list_init(&ogglist);
	iceprof = lameprof = vorbisprof = NULL;
	
	if(!profile_init())
		error(_("profile initialization error"));
	profile_ice_load();
	/* profile_lame_load and profile_vorbis_load are into encoder.cpp */

	pathfile = NULL;
	
	/* signal to glib we're going to use threads */
	g_thread_init(NULL);

	isx = gtk_init_check(&argc,&argv);
	if(!isx) 
		return false;	

	isx = mixer->set_lineout(true);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), _("MuSE-cvs Gtk+2"));
	gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(window), 12);
	g_signal_connect(G_OBJECT(window), "delete_event",
					G_CALLBACK(gcb_exit), NULL);

	/* FIXME: gtk2 remove ? */
	gtk_widget_realize(window);
	
	vbox=gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	

	fix = gtk_fixed_new();
	gtk_box_pack_start(GTK_BOX(vbox), fix, FALSE, FALSE, 0);
	
	bbox = createbbox(bbox);
	gtk_fixed_put(GTK_FIXED(fix), bbox, 0, 0);
	if(isx)
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speakout), TRUE);
	
	
	pack_new();		
	
	createch();
	putstatusbar();
	
	/*let's show window */
	gtk_widget_show_all(window);
	gtk_widget_hide(pack1.hscale);
	gtk_widget_hide(pack2.hscale);
	gtk_widget_hide(pack3.hscale);

	return true;	
}
Example #19
0
GtkWidget *
do_list_store (GtkWidget *do_widget)
{
  if (!window)
    {
      GtkWidget *vbox;
      GtkWidget *label;
      GtkWidget *sw;
      GtkWidget *treeview;

      /* create window, etc */
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_screen (GTK_WINDOW (window),
                             gtk_widget_get_screen (do_widget));
      gtk_window_set_title (GTK_WINDOW (window), "List Store");

      g_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);
      gtk_container_set_border_width (GTK_CONTAINER (window), 8);

      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
      gtk_container_add (GTK_CONTAINER (window), vbox);

      label = gtk_label_new ("This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).");
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

      sw = gtk_scrolled_window_new (NULL, NULL);
      gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
                                           GTK_SHADOW_ETCHED_IN);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                      GTK_POLICY_NEVER,
                                      GTK_POLICY_AUTOMATIC);
      gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);

      /* create tree model */
      model = create_model ();

      /* create tree view */
      treeview = gtk_tree_view_new_with_model (model);
      gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
                                       COLUMN_DESCRIPTION);

      g_object_unref (model);

      gtk_container_add (GTK_CONTAINER (sw), treeview);

      /* add columns to the tree view */
      add_columns (GTK_TREE_VIEW (treeview));

      /* finish & show */
      gtk_window_set_default_size (GTK_WINDOW (window), 280, 250);
      g_signal_connect (window, "delete-event",
                        G_CALLBACK (window_closed), NULL);
    }

  if (!gtk_widget_get_visible (window))
    {
      gtk_widget_show_all (window);
      if (timeout == 0) {
        /* FIXME this should use the animation-duration instead */
        timeout = g_timeout_add (80, spinner_timeout, NULL);
      }
    }
  else
    {
      gtk_widget_destroy (window);
      window = NULL;
      if (timeout != 0)
        {
          g_source_remove (timeout);
          timeout = 0;
        }
    }

  return window;
}
Example #20
0
static void
gdict_applet_build_window (GdictApplet *applet)
{
  GdictAppletPrivate *priv = applet->priv;
  GtkWidget *window;
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *bbox;
  GtkWidget *button;

  if (!priv->entry)
    {
      g_warning ("No entry widget defined");

      return;
    }
  
  window = gdict_aligned_window_new (priv->toggle);
  g_signal_connect (window, "key-press-event",
		    G_CALLBACK (window_key_press_event_cb),
		    applet);
  g_signal_connect (window, "show",
  		    G_CALLBACK (window_show_cb),
		    applet);

  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  gtk_container_add (GTK_CONTAINER (window), frame);
  gtk_widget_show (frame);
  priv->frame = frame;
  
  vbox = gtk_vbox_new (FALSE, 12);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
  gtk_container_add (GTK_CONTAINER (frame), vbox);
  gtk_widget_show (vbox);
  
  priv->defbox = gdict_defbox_new ();
  if (priv->context)
    gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), priv->context);
  
  gtk_box_pack_start (GTK_BOX (vbox), priv->defbox, TRUE, TRUE, 0);
  gtk_widget_show (priv->defbox);
  gtk_widget_set_can_focus (priv->defbox, TRUE);
  gtk_widget_set_can_default (priv->defbox, TRUE);
  
  bbox = gtk_hbutton_box_new ();
  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
  gtk_box_set_spacing (GTK_BOX (bbox), 6);
  gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
  gtk_widget_show (bbox);
  
  button = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
  gtk_widget_set_tooltip_text (button, _("Clear the definitions found"));
  set_atk_name_description (button,
		  	    _("Clear definition"),
			    _("Clear the text of the definition"));
  
  g_signal_connect (button, "clicked", G_CALLBACK (clear_cb), applet);
  gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_button_new_from_stock (GTK_STOCK_PRINT);
  gtk_widget_set_tooltip_text (button, _("Print the definitions found"));
  set_atk_name_description (button,
		  	    _("Print definition"),
			    _("Print the text of the definition"));
  
  g_signal_connect (button, "clicked", G_CALLBACK (print_cb), applet);
  gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
  gtk_widget_set_tooltip_text (button, _("Save the definitions found"));
  set_atk_name_description (button,
		  	    _("Save definition"),
			    _("Save the text of the definition to a file"));
  
  g_signal_connect (button, "clicked", G_CALLBACK (save_cb), applet);
  gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);
  
  gtk_window_set_default (GTK_WINDOW (window), priv->defbox);
  
  priv->window = window;
  priv->is_window_showing = FALSE;
}
static void prefs_summary_column_create(void)
{
	GtkWidget *window;
	GtkWidget *vbox;

	GtkWidget *label_hbox;
	GtkWidget *label;

	GtkWidget *vbox1;

	GtkWidget *hbox1;
	GtkWidget *clist_hbox;
	GtkWidget *scrolledwin;
	GtkWidget *stock_clist;
	GtkWidget *shown_clist;

	GtkWidget *btn_vbox;
	GtkWidget *btn_vbox1;
	GtkWidget *add_btn;
	GtkWidget *remove_btn;
	GtkWidget *up_btn;
	GtkWidget *down_btn;

	GtkWidget *btn_hbox;
	GtkWidget *default_btn;
	GtkWidget *confirm_area;
	GtkWidget *ok_btn;
	GtkWidget *cancel_btn;

	gchar *title[1];

	debug_print("Creating summary column setting window...\n");

	window = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_container_set_border_width(GTK_CONTAINER(window), 8);
	gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_modal(GTK_WINDOW(window), TRUE);
	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
	gtk_window_set_title(GTK_WINDOW(window),
			     _("Displayed items configuration"));
	gtk_signal_connect(GTK_OBJECT(window), "delete_event",
			   GTK_SIGNAL_FUNC(prefs_summary_column_delete_event),
			   NULL);
	gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
			   GTK_SIGNAL_FUNC(prefs_summary_column_key_pressed),
			   NULL);

	vbox = gtk_vbox_new(FALSE, 6);
	gtk_widget_show(vbox);
	gtk_container_add(GTK_CONTAINER(window), vbox);

	label_hbox = gtk_hbox_new(FALSE, 0);
	gtk_widget_show(label_hbox);
	gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4);

	label = gtk_label_new
		(_("Select items to be displayed in the summary view. You can modify\n"
		   "the order by using the Up / Down buttons or by dragging the items."));
	gtk_widget_show(label);
	gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4);
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);

	vbox1 = gtk_vbox_new(FALSE, VSPACING);
	gtk_widget_show(vbox1);
	gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2);

	hbox1 = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(hbox1);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);

	clist_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(clist_hbox);
	gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_usize(scrolledwin, 180, 210);
	gtk_widget_show(scrolledwin);
	gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	title[0] = _("Available items");
	stock_clist = gtk_clist_new_with_titles(1, title);
	gtk_widget_show(stock_clist);
	gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist);
	gtk_clist_set_selection_mode(GTK_CLIST(stock_clist),
				     GTK_SELECTION_BROWSE);
	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button,
			       GTK_CAN_FOCUS);

	/* add/remove button */
	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);

	btn_vbox1 = gtk_vbox_new(FALSE, 8);
	gtk_widget_show(btn_vbox1);
	gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);

	add_btn = gtk_button_new_with_label(_("  ->  "));
	gtk_widget_show(add_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0);

	remove_btn = gtk_button_new_with_label(_("  <-  "));
	gtk_widget_show(remove_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(add_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_add), NULL);
	gtk_signal_connect(GTK_OBJECT(remove_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_remove), NULL);

	clist_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(clist_hbox);
	gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_usize(scrolledwin, 180, 210);
	gtk_widget_show(scrolledwin);
	gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	title[0] = _("Displayed items");
	shown_clist = gtk_clist_new_with_titles(1, title);
	gtk_widget_show(shown_clist);
	gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist);
	gtk_clist_set_selection_mode(GTK_CLIST(shown_clist),
				     GTK_SELECTION_BROWSE);
	gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE);
	gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE);
	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button,
			       GTK_CAN_FOCUS);

	/* up/down button */
	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);

	btn_vbox1 = gtk_vbox_new(FALSE, 8);
	gtk_widget_show(btn_vbox1);
	gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);

	up_btn = gtk_button_new_with_label(_("Up"));
	gtk_widget_show(up_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0);

	down_btn = gtk_button_new_with_label(_("Down"));
	gtk_widget_show(down_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(up_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_up), NULL);
	gtk_signal_connect(GTK_OBJECT(down_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_down), NULL);

	btn_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(btn_hbox);
	gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0);

	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0);

	default_btn = gtk_button_new_with_label(_(" Use default "));
	gtk_widget_show(default_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0);
	gtk_signal_connect(GTK_OBJECT(default_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_set_to_default),
			   NULL);

	gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
				&cancel_btn, _("Cancel"), NULL, NULL);
	gtk_widget_show(confirm_area);
	gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
	gtk_widget_grab_default(ok_btn);

	gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_ok), NULL);
	gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_cancel), NULL);

	summary_col.window      = window;
	summary_col.stock_clist = stock_clist;
	summary_col.shown_clist = shown_clist;
	summary_col.add_btn     = add_btn;
	summary_col.remove_btn  = remove_btn;
	summary_col.up_btn      = up_btn;
	summary_col.down_btn    = down_btn;
	summary_col.ok_btn      = ok_btn;
	summary_col.cancel_btn  = cancel_btn;
}
Example #22
0
static gboolean
gdict_applet_draw (GdictApplet *applet)
{
  GdictAppletPrivate *priv = applet->priv;
  GtkWidget *box;
  GtkWidget *hbox;
  gchar *text = NULL;

  if (priv->entry)
    text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1);
  
  if (priv->box)
    gtk_widget_destroy (priv->box);

  switch (priv->orient)
    {
    case GTK_ORIENTATION_VERTICAL:
      box = gtk_vbox_new (FALSE, 0);
      break;
    case GTK_ORIENTATION_HORIZONTAL:
      box = gtk_hbox_new (FALSE, 0);
      break;
    default:
      g_assert_not_reached ();
      break;
    }
  
  gtk_container_add (GTK_CONTAINER (applet), box);
  gtk_widget_show (box);

  /* toggle button */
  priv->toggle = gtk_toggle_button_new ();
  gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window"));
  set_atk_name_description (priv->toggle,
			    _("Toggle dictionary window"),
		  	    _("Show or hide the definition window"));
  
  gtk_button_set_relief (GTK_BUTTON (priv->toggle),
		  	 GTK_RELIEF_NONE);
  g_signal_connect (priv->toggle, "toggled",
		    G_CALLBACK (gdict_applet_icon_toggled_cb),
		    applet);
  g_signal_connect (priv->toggle, "button-press-event",
		    G_CALLBACK (gdict_applet_icon_button_press_event_cb),
		    applet);
  gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0);
  gtk_widget_show (priv->toggle);

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
  gtk_container_add (GTK_CONTAINER (priv->toggle), hbox);
  gtk_widget_show (hbox);

  if (priv->icon)
    {
      GdkPixbuf *scaled;
      
      priv->image = gtk_image_new ();
      gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);

      scaled = gdk_pixbuf_scale_simple (priv->icon,
		      			priv->size - 5,
					priv->size - 5,
					GDK_INTERP_BILINEAR);
      
      gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled);
      g_object_unref (scaled);
      
      gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
      
      gtk_widget_show (priv->image);
    }
  else
    {
      priv->image = gtk_image_new ();

      gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
      gtk_image_set_from_stock (GTK_IMAGE (priv->image),
				GTK_STOCK_MISSING_IMAGE,
				-1);
      
      gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
      gtk_widget_show (priv->image);
    }

  /* entry */
  priv->entry = gtk_entry_new ();
  gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up"));
  set_atk_name_description (priv->entry,
		  	    _("Dictionary entry"),
			    _("Look up words in dictionaries"));
  
  gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE);
  gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12);
  g_signal_connect (priv->entry, "activate",
  		    G_CALLBACK (gdict_applet_entry_activate_cb),
  		    applet);
  g_signal_connect (priv->entry, "button-press-event",
		    G_CALLBACK (gdict_applet_entry_button_press_event_cb),
		    applet);
  g_signal_connect (priv->entry, "key-press-event",
		    G_CALLBACK (gdict_applet_entry_key_press_cb),
		    applet);
  gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0);
  gtk_widget_show (priv->entry);

  if (text)
    {
      gtk_entry_set_text (GTK_ENTRY (priv->entry), text);

      g_free (text);
    }
  
  priv->box = box;

#if 0
  gtk_widget_grab_focus (priv->entry);
#endif
  
  gtk_widget_show_all (GTK_WIDGET (applet));

  return FALSE;
}
Example #23
0
void
FormDialog::editable_set (const std::string name,
			  const std::string description,
			  const std::set<std::string> values,
			  const std::set<std::string> proposed_values,
			  bool advanced)
{
  GtkWidget *label = NULL;
  GtkWidget *scroll = NULL;
  GtkWidget *button = NULL;
  GtkWidget *tree_view = NULL;
  GtkWidget *frame = NULL;
  GtkWidget *hbox = NULL;
  GtkWidget *entry = NULL;

  GtkListStore *list_store = NULL;
  GtkTreeViewColumn *column = NULL;
  GtkCellRenderer *renderer = NULL;
  GtkTreeIter iter;

  gchar *label_text = NULL;

  EditableSetSubmitter *submitter = NULL;

  /* The label */
  label = gtk_label_new (NULL);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
  gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
  g_free (label_text);

  /* The GtkListStore containing the values */
  list_store = gtk_list_store_new (EditableSetSubmitter::COLUMN_NUMBER,
				   G_TYPE_BOOLEAN, G_TYPE_STRING);
  tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);

  frame = gtk_frame_new (NULL);
  gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125);
  gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  scroll = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
				  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
  gtk_container_add (GTK_CONTAINER (frame), scroll);
  gtk_container_add (GTK_CONTAINER (scroll), tree_view);

  renderer = gtk_cell_renderer_toggle_new ();
  column =
    gtk_tree_view_column_new_with_attributes (NULL, renderer,
                                              "active", EditableSetSubmitter::COLUMN_ACTIVE,
                                              NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
  g_signal_connect (renderer, "toggled",
                    G_CALLBACK (editable_set_choice_toggled_cb), list_store);

  renderer = gtk_cell_renderer_text_new ();
  column =
    gtk_tree_view_column_new_with_attributes (NULL, renderer,
                                              "text", EditableSetSubmitter::COLUMN_VALUE,
                                              NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);

  for (std::set<std::string>::const_iterator set_iter = values.begin ();
       set_iter != values.end ();
       set_iter++) {

    gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
    gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
			EditableSetSubmitter::COLUMN_ACTIVE, TRUE,
                        EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (),
                        -1);
  }
  for (std::set<std::string>::const_iterator set_iter
	 = proposed_values.begin ();
       set_iter != proposed_values.end ();
       set_iter++) {

    if (values.find (*set_iter) == values.end ()) {

      gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
      gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
			  EditableSetSubmitter::COLUMN_ACTIVE, FALSE,
			  EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (),
			  -1);
    }
  }

  if (advanced) {

    grow_fields (advanced);
    gtk_table_attach (GTK_TABLE (advanced_fields), label,
		      0, 2, advanced_rows - 1, advanced_rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
    grow_fields (advanced);
    gtk_table_attach (GTK_TABLE (advanced_fields), frame,
		      0, 2, advanced_rows - 1, advanced_rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
  } else {

    grow_fields (advanced);
    gtk_table_attach (GTK_TABLE (fields), label,
		      0, 2, rows - 1, rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
    grow_fields (advanced);
    gtk_table_attach (GTK_TABLE (fields), frame,
		      0, 2, rows - 1, rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
  }

  hbox = gtk_hbox_new (FALSE, 2);
  entry = gtk_entry_new ();
  button = gtk_button_new_from_stock (GTK_STOCK_ADD);
  gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 2);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);

  g_signal_connect (entry, "activate",
		    (GCallback) editable_set_add_value_activated_cb,
		    (gpointer) tree_view);

  g_signal_connect (button, "clicked",
		    (GCallback) editable_set_add_value_clicked_cb,
		    (gpointer) entry);

  grow_fields (advanced);
  if (advanced) {

    gtk_table_attach (GTK_TABLE (advanced_fields), hbox,
		      0, 2, advanced_rows - 1, advanced_rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
  } else {

    gtk_table_attach (GTK_TABLE (fields), hbox,
		      0, 2, rows - 1, rows,
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
		      0, 0);
  }

  submitter = new EditableSetSubmitter (name, description, advanced, tree_view);
  submitters.push_back (submitter);
}
Example #24
0
static void
gimp_color_dialog_init (GimpColorDialog *dialog)
{
  GtkWidget *table;
  GtkWidget *button;
  GtkWidget *arrow;
  gint       i;

  color_dialogs = g_list_prepend (color_dialogs, dialog);

  gtk_dialog_add_buttons (GTK_DIALOG (dialog),
                          GIMP_STOCK_RESET, RESPONSE_RESET,
                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                          GTK_STOCK_OK,     GTK_RESPONSE_OK,
                          NULL);
  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
                                           RESPONSE_RESET,
                                           GTK_RESPONSE_OK,
                                           GTK_RESPONSE_CANCEL,
                                           -1);

  dialog->selection = gimp_color_selection_new ();
  gtk_container_set_border_width (GTK_CONTAINER (dialog->selection), 12);
  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
                      dialog->selection, TRUE, TRUE, 0);
  gtk_widget_show (dialog->selection);

  g_signal_connect (dialog->selection, "color-changed",
                    G_CALLBACK (gimp_color_dialog_color_changed),
                    dialog);

  /* The color history */
  table = gtk_table_new (2, 1 + COLOR_HISTORY_SIZE / 2, TRUE);
  gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
  gtk_box_pack_end (GTK_BOX (GIMP_COLOR_SELECTION (dialog->selection)->right_vbox),
                    table, FALSE, FALSE, 0);
  gtk_widget_show (table);

  button = gtk_button_new ();
  gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 0, 1);
  gimp_help_set_help_data (button,
                           _("Add the current color to the color history"),
                           NULL);
  gtk_widget_show (button);

  g_signal_connect (button, "clicked",
                    G_CALLBACK (gimp_color_history_add_clicked),
                    dialog);

  arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
  gtk_container_add (GTK_CONTAINER (button), arrow);
  gtk_widget_show (arrow);

  for (i = 0; i < COLOR_HISTORY_SIZE; i++)
    {
      GimpRGB history_color;
      gint    row, column;

      column = i % (COLOR_HISTORY_SIZE / 2);
      row    = i / (COLOR_HISTORY_SIZE / 2);

      button = gtk_button_new ();
      gtk_widget_set_size_request (button, COLOR_AREA_SIZE, COLOR_AREA_SIZE);
      gtk_table_attach_defaults (GTK_TABLE (table), button,
                                 column + 1, column + 2, row, row + 1);
      gtk_widget_show (button);

      color_history_get (i, &history_color);

      dialog->history[i] = gimp_color_area_new (&history_color,
                                                GIMP_COLOR_AREA_SMALL_CHECKS,
                                                GDK_BUTTON2_MASK);
      gtk_container_add (GTK_CONTAINER (button), dialog->history[i]);
      gtk_widget_show (dialog->history[i]);

      g_signal_connect (button, "clicked",
                        G_CALLBACK (gimp_color_history_color_clicked),
                        dialog);

      g_signal_connect (dialog->history[i], "color-changed",
                        G_CALLBACK (gimp_color_history_color_changed),
                        GINT_TO_POINTER (i));
    }
}
Example #25
0
GtkDialog*
seahorse_passphrase_prompt_show (const gchar *title, const gchar *description, 
                                 const gchar *prompt, const gchar *check,
                                 gboolean confirm)
{
    GtkEntryBuffer *buffer;
    GtkEntry *entry;
    GtkDialog *dialog;
    GtkWidget *w;
    GtkWidget *box;
    GtkTable *table;
    GtkWidget *wvbox;
    GtkWidget *chbox;
    gchar *msg;
    
    if (!title)
        title = _("Passphrase");

    if (!prompt)
        prompt = _("Password:"******"size-request", G_CALLBACK (constrain_size), NULL);
    g_signal_connect (G_OBJECT (dialog), "map-event", G_CALLBACK (grab_keyboard), NULL);
    g_signal_connect (G_OBJECT (dialog), "unmap-event", G_CALLBACK (ungrab_keyboard), NULL);
    g_signal_connect (G_OBJECT (dialog), "window-state-event", G_CALLBACK (window_state_changed), NULL); 

    wvbox = gtk_vbox_new (FALSE, HIG_LARGE * 2);
    gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (dialog)), wvbox);
    gtk_container_set_border_width (GTK_CONTAINER (wvbox), HIG_LARGE);

    chbox = gtk_hbox_new (FALSE, HIG_LARGE);
    gtk_box_pack_start (GTK_BOX (wvbox), chbox, FALSE, FALSE, 0);

    /* The image */
    w = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
    gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.0);
    gtk_box_pack_start (GTK_BOX (chbox), w, FALSE, FALSE, 0);

    box = gtk_vbox_new (FALSE, HIG_SMALL);
    gtk_box_pack_start (GTK_BOX (chbox), box, TRUE, TRUE, 0);

    /* The description text */
    if (description) {
        msg = utf8_validate (description);
        w = gtk_label_new (msg);
        g_free (msg);

        gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
        gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
        gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0);
    }

    /* Two entries (usually on is hidden)  in a vbox */
    table = GTK_TABLE (gtk_table_new (3, 2, FALSE));
    gtk_table_set_row_spacings (table, HIG_SMALL);
    gtk_table_set_col_spacings (table, HIG_LARGE);
    gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (table), FALSE, FALSE, 0);

    /* The first entry if we have one */
    if (confirm) {
        msg = utf8_validate (prompt);
        w = gtk_label_new (msg);
        g_free (msg);
        gtk_table_attach (table, w, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);

        buffer = seahorse_secure_buffer_new ();
        entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer));
        g_object_unref (buffer);
        gtk_entry_set_visibility (entry, FALSE);
        gtk_widget_set_size_request (GTK_WIDGET (entry), 200, -1);
        g_object_set_data (G_OBJECT (dialog), "confirm-entry", entry);
        g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (confirm_callback), dialog);
        g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog);
        gtk_table_attach_defaults (table, GTK_WIDGET (entry), 1, 2, 0, 1);
        gtk_widget_grab_focus (GTK_WIDGET (entry));
    }

    /* The second and main entry */
    msg = utf8_validate (confirm ? _("Confirm:") : prompt);
    w = gtk_label_new (msg);
    g_free (msg);
    gtk_table_attach (table, w, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);

    buffer = seahorse_secure_buffer_new ();
    entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer));
    g_object_unref (buffer);
    gtk_widget_set_size_request (GTK_WIDGET (entry), 200, -1);
    gtk_entry_set_visibility (entry, FALSE);
    g_object_set_data (G_OBJECT (dialog), "secure-entry", entry);
    g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (enter_callback), dialog);
    gtk_table_attach_defaults (table, GTK_WIDGET (entry), 1, 2, 1, 2);
    if (!confirm)
        gtk_widget_grab_focus (GTK_WIDGET (entry));
    else
        g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog);

    /* The checkbox */
    if (check) {
        w = gtk_check_button_new_with_mnemonic (check);
        gtk_table_attach_defaults (table, w, 1, 2, 2, 3);
        g_object_set_data (G_OBJECT (dialog), "check-option", w);
    }

    gtk_widget_show_all (GTK_WIDGET (table));
    
    w = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
    gtk_dialog_add_action_widget (dialog, w, GTK_RESPONSE_REJECT);
    gtk_widget_set_can_default (w, TRUE);

    w = gtk_button_new_from_stock (GTK_STOCK_OK);
    gtk_dialog_add_action_widget (dialog, w, GTK_RESPONSE_ACCEPT);
    gtk_widget_set_can_default (w, TRUE);
    g_signal_connect_object (G_OBJECT (entry), "focus_in_event",
                             G_CALLBACK (gtk_widget_grab_default), G_OBJECT (w), 0);
    gtk_widget_grab_default (w);
    
    g_signal_connect (dialog, "key_press_event", G_CALLBACK (key_press), NULL);

    gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
    gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);    
    gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NORMAL);
    gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
    gtk_widget_show_all (GTK_WIDGET (dialog));
    gdk_window_focus (gtk_widget_get_window (GTK_WIDGET (dialog)), GDK_CURRENT_TIME);

    if (confirm)
        entry_changed (NULL, dialog);
    
    return dialog;
}
Example #26
0
GtkWidget *
module_dialog_new (Gimp *gimp)
{
  GtkWidget         *shell;
  GtkWidget         *vbox;
  GtkWidget         *sw;
  GtkWidget         *view;
  GtkWidget         *image;
  ModuleDialog      *dialog;
  GtkTreeSelection  *sel;
  GtkTreeIter        iter;
  GtkTreeViewColumn *col;
  GtkCellRenderer   *rend;

  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);

  dialog = g_slice_new0 (ModuleDialog);

  dialog->gimp = gimp;

  shell = gimp_dialog_new (_("Module Manager"),
                           "gimp-modules", NULL, 0,
                           gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG,

                           GTK_STOCK_REFRESH, RESPONSE_REFRESH,
                           GTK_STOCK_CLOSE,   GTK_STOCK_CLOSE,

                           NULL);

  gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell),
                                           GTK_RESPONSE_CLOSE,
                                           RESPONSE_REFRESH,
                                           -1);

  g_signal_connect (shell, "response",
                    G_CALLBACK (dialog_response),
                    dialog);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell))),
                      vbox, TRUE, TRUE, 0);
  gtk_widget_show (vbox);

  dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP "
                                      "for the changes to take effect."));
  gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0);

  if (gimp->write_modulerc)
    gtk_widget_show (dialog->hint);

  sw = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
                                       GTK_SHADOW_IN);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                  GTK_POLICY_AUTOMATIC,
                                  GTK_POLICY_AUTOMATIC);
  gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
  gtk_widget_set_size_request (sw, 124, 100);
  gtk_widget_show (sw);

  dialog->list = gtk_list_store_new (N_COLUMNS,
                                     G_TYPE_STRING,
                                     G_TYPE_BOOLEAN,
                                     GIMP_TYPE_MODULE);
  view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list));
  g_object_unref (dialog->list);

  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);

  g_list_foreach (gimp->module_db->modules, make_list_item, dialog);

  rend = gtk_cell_renderer_toggle_new ();

  g_signal_connect (rend, "toggled",
                    G_CALLBACK (dialog_enabled_toggled),
                    dialog);

  col = gtk_tree_view_column_new ();
  gtk_tree_view_column_pack_start (col, rend, FALSE);
  gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED);

  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);

  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
                                               _("Module"),
                                               gtk_cell_renderer_text_new (),
                                               "text", COLUMN_NAME,
                                               NULL);

  gtk_container_add (GTK_CONTAINER (sw), view);
  gtk_widget_show (view);

  dialog->table = gtk_table_new (2, N_INFOS, FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6);
  gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0);
  gtk_widget_show (dialog->table);

  dialog->error_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
  gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0);

  image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON);
  gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0);
  gtk_widget_show (image);

  dialog->error_label = gtk_label_new (NULL);
  gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5);
  gtk_box_pack_start (GTK_BOX (dialog->error_box),
                      dialog->error_label, TRUE, TRUE, 0);
  gtk_widget_show (dialog->error_label);

  dialog_info_init (dialog, dialog->table);

  dialog_info_update (gimp->module_db, dialog->selected, dialog);

  sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));

  g_signal_connect (sel, "changed",
                    G_CALLBACK (dialog_select_callback),
                    dialog);

  if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter))
    gtk_tree_selection_select_iter (sel, &iter);

  /* hook the GimpModuleDB signals so we can refresh the display
   * appropriately.
   */
  g_signal_connect (gimp->module_db, "add",
                    G_CALLBACK (dialog_info_add),
                    dialog);
  g_signal_connect (gimp->module_db, "remove",
                    G_CALLBACK (dialog_info_remove),
                    dialog);
  g_signal_connect (gimp->module_db, "module-modified",
                    G_CALLBACK (dialog_info_update),
                    dialog);

  g_signal_connect (shell, "destroy",
                    G_CALLBACK (dialog_destroy_callback),
                    dialog);

  return shell;
}
Example #27
0
static gboolean
level_grains_dialog(LevelGrainsArgs *args)
{
    GtkWidget *dialog, *table, *label;
    LevelGrainsControls controls;
    gint response, row;

    controls.args = args;

    dialog = gtk_dialog_new_with_buttons(_("Level Grains"),
                                         NULL, 0,
                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                         GTK_STOCK_OK, GTK_RESPONSE_OK,
                                         NULL);
    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
    gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);

    table = gtk_table_new(2 + G_N_ELEMENTS(level_grains_bases), 1, FALSE);
    gtk_table_set_row_spacings(GTK_TABLE(table), 2);
    gtk_table_set_col_spacings(GTK_TABLE(table), 6);
    gtk_container_set_border_width(GTK_CONTAINER(table), 4);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4);
    row = 0;

    label = gtk_label_new(_("Quantity to level:"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_table_attach(GTK_TABLE(table), label,
                     0, 1, row, row+1, GTK_FILL, 0, 0, 0);
    row++;

    controls.base = construct_bases_radio(args->base,
                                          G_CALLBACK(base_changed), &controls);
    row = gwy_radio_buttons_attach_to_table(controls.base, GTK_TABLE(table),
                                            1, row);

    gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
    controls.do_extract
        = gtk_check_button_new_with_mnemonic(_("E_xtract background"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract),
                                 args->do_extract);
    gtk_table_attach(GTK_TABLE(table), controls.do_extract,
                     0, 1, row, row+1, GTK_FILL, 0, 0, 0);
    g_signal_connect_swapped(controls.do_extract, "toggled",
                             G_CALLBACK(do_extract_changed), &controls);
    row++;

    gtk_widget_show_all(dialog);
    do {
        response = gtk_dialog_run(GTK_DIALOG(dialog));
        switch (response) {
            case GTK_RESPONSE_CANCEL:
            case GTK_RESPONSE_DELETE_EVENT:
            gtk_widget_destroy(dialog);
            case GTK_RESPONSE_NONE:
            return FALSE;
            break;

            case GTK_RESPONSE_OK:
            break;

            default:
            g_assert_not_reached();
            break;
        }
    } while (response != GTK_RESPONSE_OK);

    gtk_widget_destroy(dialog);
    return TRUE;
}
Example #28
0
GtkWidget*
gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor)
{
  const char *     str;
  GtkWidget *      w;
  GtkWidget *      d;
  GtkGrid        * grid;
  int              row;
  GtkWidget *      l;
  GtkWidget *      source_chooser;
  struct OpenData * data;
  bool             flag;
  GSList *         list;
  GSList *         walk;

  /* make the dialog */
  d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent,
                                   GTK_DIALOG_DESTROY_WITH_PARENT,
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                   GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                   NULL);
  gtk_dialog_set_default_response (GTK_DIALOG (d),
                                   GTK_RESPONSE_ACCEPT);
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
                                           GTK_RESPONSE_ACCEPT,
                                           GTK_RESPONSE_CANCEL,
                                           -1);
  gtk_window_set_default_size(GTK_WINDOW(d),
                              gtr_pref_int_get (TR_KEY_details_window_width),
                              gtr_pref_int_get (TR_KEY_details_window_height));

  if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &str))
    g_assert_not_reached ();
  g_assert (str);

  data = g_new0 (struct OpenData, 1);
  data->core = core;
  data->ctor = ctor;
  data->filename = g_strdup (tr_ctorGetSourceFile (ctor));
  data->downloadDir = g_strdup (str);
  data->file_list = gtr_file_list_new (core, 0);
  str = _("Mo_ve .torrent file to the trash");
  data->trash_check = gtk_check_button_new_with_mnemonic (str);
  str = _("_Start when added");
  data->run_check = gtk_check_button_new_with_mnemonic (str);

  w = data->priority_combo = gtr_priority_combo_new ();
  gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL);

  g_signal_connect (G_OBJECT (d), "response",
                    G_CALLBACK (addResponseCB), data);

  row = 0;
  grid = GTK_GRID (gtk_grid_new ());
  gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
  gtk_grid_set_row_spacing (grid, GUI_PAD);
  gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);

  /* "torrent file" row */
  l = gtk_label_new_with_mnemonic (_("_Torrent file:"));
  gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
  gtk_grid_attach (grid, l, 0, row, 1, 1);
  w = gtk_file_chooser_button_new (_("Select Source File"),
                                   GTK_FILE_CHOOSER_ACTION_OPEN);
  source_chooser = w;
  gtk_widget_set_hexpand (w, TRUE);
  gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
  gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
  addTorrentFilters (GTK_FILE_CHOOSER (w));
  g_signal_connect (w, "selection-changed",
                    G_CALLBACK (sourceChanged), data);

  /* "destination folder" row */
  row++;
  l = gtk_label_new_with_mnemonic (_("_Destination folder:"));
  gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
  gtk_grid_attach (grid, l, 0, row, 1, 1);
  w = gtk_file_chooser_button_new (_("Select Destination Folder"),
                                   GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
  if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w),
                                            data->downloadDir))
    g_warning ("couldn't select '%s'", data->downloadDir);
  list = get_recent_destinations ();
  for (walk = list; walk; walk = walk->next)
    gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL);
  g_slist_free (list);
  gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
  gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
  g_signal_connect (w, "selection-changed",
                    G_CALLBACK (downloadDirChanged), data);

  row++;
  l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir);
  gtk_widget_set_margin_bottom (l, GUI_PAD_BIG);
  gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f);
  gtk_grid_attach (grid, l, 0, row, 2, 1);


  /* file list row */
  row++;
  w = data->file_list;
  gtk_widget_set_vexpand (w, TRUE);
  gtk_widget_set_size_request (w, 466u, 300u);
  gtk_grid_attach (grid, w, 0, row, 2, 1);

  /* torrent priority row */
  row++;
  l = gtk_label_new_with_mnemonic (_("Torrent _priority:"));
  gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
  gtk_grid_attach (grid, l, 0, row, 1, 1);
  w = data->priority_combo;
  gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
  gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);

  /* torrent priority row */
  row++;
  w = data->run_check;
  if (!tr_ctorGetPaused (ctor, TR_FORCE, &flag))
    g_assert_not_reached ();
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag);
  gtk_grid_attach (grid, w, 0, row, 2, 1);

  /* "trash .torrent file" row */
  row++;
  w = data->trash_check;
  if (!tr_ctorGetDeleteSource (ctor, &flag))
    g_assert_not_reached ();
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag);
  gtk_grid_attach (grid, w, 0, row, 2, 1);

  /* trigger sourceChanged, either directly or indirectly,
   * so that it creates the tor/gtor objects */
  w = source_chooser;
  if (data->filename)
    gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename);
  else
    sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data);

  gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid));
  w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT);
  gtk_widget_grab_focus (w);
  return d;
}
Example #29
0
/**
 * Constructor
 */
GtkWidget *create_control_window(GtkWidget *parent)
{
    GtkWidget *pp_button, *next_button, *prev_button, *ff_button;
    GtkWidget *vol, *progress, *hbox, *play_image;
    int new_volume;
    /* Create window */
    GtkWidget *base = gtk_event_box_new();
    GtkWidget *ali = gtk_alignment_new(0.5,0,0.6,1);
    g_signal_connect(G_OBJECT(base), "enter-notify-event" ,
            G_CALLBACK(control_window_enter_notify_event), NULL);
    g_signal_connect(G_OBJECT(base), "leave-notify-event" ,
            G_CALLBACK(control_window_leave_notify_event), NULL);
    /* Overwrite background drawing */
    gtk_widget_set_app_paintable(base, TRUE);
    g_signal_connect(G_OBJECT(base), "draw",
        G_CALLBACK(expose_window), NULL);

    hbox = gtk_hbox_new(FALSE, 6);
    g_object_set_data(G_OBJECT(base), "hbox" , hbox);
    gtk_container_add(GTK_CONTAINER(base), ali);
    gtk_container_add(GTK_CONTAINER(ali), hbox);
    gtk_container_set_border_width(GTK_CONTAINER(ali), 1);

    /* Previous button */
    ff_button = gtk_button_new();
    gtk_container_add(GTK_CONTAINER(ff_button),
        gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN,
        GTK_ICON_SIZE_BUTTON));
    gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE);
    gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0);
    g_signal_connect(G_OBJECT(ff_button), "clicked",
        G_CALLBACK(control_window_leave_fullscreen), parent);
    /* Volume button */
    vol = (GtkWidget *)gtk_volume_button_new();
    gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0);
    new_volume = mpd_status_get_volume(connection);
    gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol), new_volume/100.0);
    g_object_set_data(G_OBJECT(base), "vol", vol);
    g_signal_connect(G_OBJECT(vol), "value_changed",
        G_CALLBACK(playlist_player_volume_changed), NULL);
    /* Progress */
    progress = (GtkWidget *)gmpc_progress_new();
    gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE);
    gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0);
    g_object_set_data(G_OBJECT(base), "progress", progress);
    g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event),
            NULL);

    /* Previous button */
    prev_button = gtk_button_new();
    gtk_container_add(GTK_CONTAINER(prev_button),
        gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON));
    gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button),
        GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious")));
    gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE);
    gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0);

    /* Play button */
    pp_button = gtk_button_new();
    if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY)
    {
        play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON);
    }
    else
    {
        play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON);
    }
    gtk_container_add(GTK_CONTAINER(pp_button), play_image);
    g_object_set_data(G_OBJECT(base), "play_image", play_image);

    gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button),
        GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")));
    gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE);
    gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0);

    /* Next */
    next_button = gtk_button_new();
    gtk_container_add(GTK_CONTAINER(next_button),
        gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON));
    gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button),
        GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext")));
    gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE);
    gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0);

    /* Change colors */
    control_window_modify_colors(base);
    gtk_widget_show_all(base);

    timeout = g_timeout_add_seconds(5, (GSourceFunc) gtk_widget_hide, hbox);
    return base;
}
Example #30
0
GtkWidget *
do_data_model_dir (GtkWidget *do_widget)
{
    if (!window) {
        GtkWidget *vbox;
        GtkWidget *label;
        GdaDataModel *model;
        GtkWidget *form, *grid, *nb;
        GdaSet *data_set;
        GdaHolder *param;
        gchar *path;
        GValue *value;

        window = gtk_dialog_new_with_buttons ("GdaDataModelDir data model",
                                              GTK_WINDOW (do_widget),
                                              0,
                                              GTK_STOCK_CLOSE,
                                              GTK_RESPONSE_NONE,
                                              NULL);

        g_signal_connect (window, "response",
                          G_CALLBACK (gtk_widget_destroy), NULL);
        g_signal_connect (window, "destroy",
                          G_CALLBACK (gtk_widget_destroyed), &window);

        vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
        gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
                            vbox, TRUE, TRUE, 0);
        gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);

        label = gtk_label_new ("The following GdauiForm widget displays data from a GdaDataModelDir "
                               "data model which lists the files contained in the selected directory.\n\n"
                               "Each file contents is then displayed using the 'picture' plugin \n"
                               "(right click to open a menu, or double click to load an image).");
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

        /* GdaDataModelDir object */
        path = get_data_path ();
        model = gda_data_model_dir_new (path);
        g_free (path);

        /* Create the demo widget */
        nb = gtk_notebook_new ();
        gtk_box_pack_start (GTK_BOX (vbox), nb, TRUE, TRUE, 0);

        form = gdaui_form_new (model);
        gtk_notebook_append_page (GTK_NOTEBOOK (nb), form, gtk_label_new ("Form"));

        grid = gdaui_grid_new (model);
        gtk_notebook_append_page (GTK_NOTEBOOK (nb), grid, gtk_label_new ("Grid"));
        g_object_unref (model);

        /* specify that we want to use the 'picture' plugin */
        data_set = GDA_SET (gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (grid)));
        param = gda_set_get_holder (data_set, "data");

        value = gda_value_new_from_string ("picture", G_TYPE_STRING);
        gda_holder_set_attribute_static (param, GDAUI_ATTRIBUTE_PLUGIN, value);
        gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (grid), -1, TRUE);
        gda_value_free (value);
    }

    gboolean visible;
    g_object_get (G_OBJECT (window), "visible", &visible, NULL);
    if (!visible)
        gtk_widget_show_all (window);
    else {
        gtk_widget_destroy (window);
        window = NULL;
    }

    return window;
}