示例#1
0
static size_t write_fru(char *eeprom)
{
    gint result;
    const char *serial, *file;
    char *ser_num, *filename;
    time_t frutime;
    FILE *fp = NULL;
    size_t i;
    time_t tmp;
    struct tm *tmp2;
    char buf[256];
    int j, n;
    struct dirent **namelist;
    GtkListStore *store;

    n = scandir(FRU_FILES, &namelist, 0, alphasort);
    /* No fru files, don't bother */
    if (n < 0) {
        printf("didn't find FRU_Files in %s at %s(%s)\n", FRU_FILES, __FILE__, __func__);
        return 0;
    }

    g_object_set(dialogs.serial_num, "secondary_text", eeprom, NULL);

    filename = g_malloc(PATH_MAX);
    ser_num = malloc(128);
    memset(ser_num, 0, 128);

    fp = fopen(".serialnum", "r");
    if (fp) {
        i = fread(ser_num, 1, 128, fp);
        if (!ferror(fp) && (i == 128 || feof(fp)))
            gtk_entry_set_text(GTK_ENTRY(serial_num), (const gchar*)&ser_num[1]);
        fclose(fp);
    }

    store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(fru_file_list)));
    gtk_list_store_clear(store);

    for (j = 0; j < n; j++) {
        if (namelist[j]->d_type == DT_REG && str_endswith(namelist[j]->d_name, ".bin"))
            gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), namelist[j]->d_name);
        free(namelist[j]);
    }
    free(namelist);

    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), "Other...");

    gtk_combo_box_set_active(GTK_COMBO_BOX(fru_file_list), ser_num[0]);
    free(ser_num);

    frutime = mins_since_jan_1_1996();
    tmp = min2date(frutime);
    tmp2 = gmtime(&tmp);

    strftime(buf, sizeof(buf), "%a %b %d %H:%M %Y", tmp2);

    gtk_entry_set_text(GTK_ENTRY(fru_date), buf);

get_serial_and_file:
    result = gtk_dialog_run(GTK_DIALOG(dialogs.serial_num));

    i = 0;
    switch (result) {
    case GTK_RESPONSE_OK:
        serial = gtk_entry_get_text(GTK_ENTRY(serial_num));
        if (strlen(serial) == 0) {
            create_blocking_popup(GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
                                  "", "Serial number required");
            goto get_serial_and_file;
        }

        file = gtk_combo_box_get_active_text(GTK_COMBO_BOX(fru_file_list));

        if (strncmp(file, "Other...", 8) != 0) {
            snprintf(filename, PATH_MAX, FRU_FILES "%s", file);
        } else {
            /* manually choose fru file */
            GtkWidget *dialog;

            dialog = gtk_file_chooser_dialog_new("Select FRU file",
                                                 GTK_WINDOW(dialogs.serial_num),
                                                 GTK_FILE_CHOOSER_ACTION_OPEN,
                                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                                 NULL);

            if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
                filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
            }
            gtk_widget_destroy(dialog);
        }

        if (filename) {
            fflush(NULL);
            sprintf(buf, "fru-dump -i %s -o %s -s %s -d %d 2>&1",
                    filename, eeprom, serial, (unsigned int)frutime);
#if DEBUG
            printf("%s\n", buf);
#else
            fp = popen(buf, "r");
#endif
            if (!fp) {
                printf("can't execute \"%s\"\n", buf);
            } else {
                i = 0;
                while(fgets(buf, sizeof(buf), fp) != NULL) {
                    /* fru-dump not installed */
                    if (strstr(buf, "not found"))
                        printf("no fru-tools installed\n");
                    if (strstr(buf, "wrote") && strstr(buf, "bytes to") && strstr(buf, eeprom))
                        i = 1;
                }
                pclose(fp);
            }
            fp = fopen(".serialnum", "w");
            if (fp) {
                fprintf(fp, "%c%s", gtk_combo_box_get_active(GTK_COMBO_BOX(fru_file_list)), serial);
                fclose(fp);
            }
        }
        break;
    case GTK_RESPONSE_DELETE_EVENT:
        break;
    default:
        printf("unknown response %d in %s\n", result, __func__);
        break;
    }
    gtk_widget_hide(GTK_WIDGET(dialogs.serial_num));

    g_free(filename);
    return i;
}
void ButtonConfigGui::saveSettings()
{
	XOJ_CHECK_TYPE(ButtonConfigGui);

	ButtonConfig* cfg = settings->getButtonConfig(button);
	ToolType action = TOOL_NONE;
	GtkTreeIter iter;

	gtk_combo_box_get_active_iter(GTK_COMBO_BOX(cbTool), &iter);

	GValue value = {0};
	GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(cbTool));

	gtk_tree_model_get_value(model, &iter, 2, &value);
	action = (ToolType) g_value_get_int(&value);

	cfg->action = action;

	int thickness = gtk_combo_box_get_active(GTK_COMBO_BOX(cbThickness));

	if (thickness == 1)
	{
		cfg->size = TOOL_SIZE_FINE;
	}
	else if (thickness == 2)
	{
		cfg->size = TOOL_SIZE_MEDIUM;
	}
	else if (thickness == 3)
	{
		cfg->size = TOOL_SIZE_THICK;
	}
	else
	{
		cfg->size = TOOL_SIZE_NONE;
	}

	GdkColor color = {0, 0, 0, 0};
	gtk_color_button_get_color(GTK_COLOR_BUTTON(colorButton), &color);

	cfg->color = (color.red / 256) << 16 | (color.green / 256) << 8 | (color.blue / 256);

	cfg->drawingType = (DrawingType) gtk_combo_box_get_active(GTK_COMBO_BOX(this->cbDrawingType));

	int eraserMode = gtk_combo_box_get_active(GTK_COMBO_BOX(this->cbEraserType));

	if (eraserMode == 1)
	{
		cfg->eraserMode = ERASER_TYPE_DEFAULT;
	}
	else if (eraserMode == 2)
	{
		cfg->eraserMode = ERASER_TYPE_WHITEOUT;
	}
	else if (eraserMode == 3)
	{
		cfg->eraserMode = ERASER_TYPE_DELETE_STROKE;
	}
	else
	{
		cfg->eraserMode = ERASER_TYPE_NONE;
	}

	if (this->withDevice)
	{
		GList* devices = gdk_devices_list();
		int dev = gtk_combo_box_get_active(GTK_COMBO_BOX(cbDevice));
		GList* selected = g_list_nth(devices, dev - 1);
		if (selected == 0)
		{
			cfg->device = "";
		}
		else
		{
			cfg->device = ((GdkDevice*) selected->data)->name;
		}

		cfg->disableDrawing = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbDisableDrawing));
	}

	settings->customSettingsChanged();
}
示例#3
0
gint ConversionBoxOKEvent(GtkWidget *widget, GdkEvent event, gpointer data)
{
	char templine[256];
	char tempblock[2352];
	const char *filename;
	int compressmethod;
	int multi;
	struct IsoFile *fromfile;
	struct IsoFile *tofile;
	int i;
	off64_t endsector;
	int stop;
	int retval;

	ConversionBoxUnfocus();

	filename = gtk_entry_get_text(GTK_ENTRY(conversionbox.file));
	if (IsIsoFile(filename) < 0)
	{
		filename = NULL;
		MessageBoxShow("Not a valid file", 3);
		return(TRUE);
	} // ENDIF- Not an Iso File? Stop early.

	compressmethod = gtk_combo_box_get_active(GTK_COMBO_BOX(conversionbox.compress));
	if (compressmethod > 0)  compressmethod += 2;
	multi = 0;
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(conversionbox.multi)) == TRUE)
		multi = 1;

	fromfile = NULL;
	fromfile = IsoFileOpenForRead(filename);
	if (fromfile == NULL)
	{
		filename = NULL;
		MessageBoxShow("Cannot opening the source file", 3);
		return(TRUE);
	} // ENDIF- Not an Iso File? Stop early.

	if ((compressmethod == fromfile->compress) &&
	        (multi == fromfile->multi))
	{
		fromfile = IsoFileClose(fromfile);
		filename = NULL;
		MessageBoxShow("Compress/Multifile methods match - no need to convert", 3);
		return(TRUE);
	} // ENDIF- Not an Iso File? Stop early.

	tofile = IsoFileOpenForWrite(filename,
	                             GetImageTypeConvertTo(fromfile->imagetype),
	                             multi,
	                             compressmethod);
	if (tofile == NULL)
	{
		fromfile = IsoFileClose(fromfile);
		filename = NULL;
		MessageBoxShow("Cannot create the new file", 3);
		return(TRUE);
	} // ENDIF- Not an Iso File? Stop early.

	if (fromfile->multi == 1)
	{
		i = 0;
		while ((i < 10) &&
		        (IsoFileSeek(fromfile, fromfile->multisectorend[i] + 1) == 0))  i++;
		endsector = fromfile->multisectorend[fromfile->multiend];
	}
	else
	{
		endsector = fromfile->filesectorsize;
	} // ENDIF- Get ending sector from multifile? (Or single file?)
	IsoFileSeek(fromfile, 0);

	// Open Progress Bar
	sprintf(templine, "%s: %s%s -> %s%s",
	        filename,
	        multinames[fromfile->multi],
	        compressdesc[fromfile->compress],
	        multinames[tofile->multi],
	        compressdesc[tofile->compress]);
	ProgressBoxStart(templine, endsector);

	tofile->cdvdtype = fromfile->cdvdtype;
	for (i = 0; i < 2048; i++)  tofile->toc[i] = fromfile->toc[i];

	stop = 0;
	mainbox.stop = 0;
	progressbox.stop = 0;
	while ((stop == 0) && (tofile->sectorpos < endsector))
	{
		retval = IsoFileRead(fromfile, tempblock);
		if (retval < 0)
		{
			MessageBoxShow("Trouble reading source file", 3);
			stop = 1;
		}
		else
		{
			retval = IsoFileWrite(tofile, tempblock);
			if (retval < 0)
			{
				MessageBoxShow("Trouble writing new file", 3);
				stop = 1;
			} // ENDIF- Trouble writing out the next block?
		} // ENDIF- Trouble reading in the next block?

		ProgressBoxTick(tofile->sectorpos);
		while (gtk_events_pending())  gtk_main_iteration();

		if (mainbox.stop != 0)  stop = 2;
		if (progressbox.stop != 0)  stop = 2;
	} // ENDWHILE- Not stopped for some reason...

	ProgressBoxStop();

	if (stop == 0)
	{
		if (tofile->multi == 1)  tofile->name[tofile->multipos] = '0'; // First file
		strcpy(templine, tofile->name);

		// fromfile = IsoFileCloseAndDelete(fromfile);
		fromfile = IsoFileClose(fromfile);

		IsoSaveTOC(tofile);
		tofile = IsoFileClose(tofile);
		gtk_entry_set_text(GTK_ENTRY(mainbox.file), templine);

	}
	else
	{
		fromfile = IsoFileClose(fromfile);
		tofile = IsoFileCloseAndDelete(tofile);
	} // ENDIF- Did we succeed in the transfer?

	if (stop != 1)  ConversionBoxRefocus();
	if (stop == 0)  ConversionBoxCancelEvent(widget, event, data);
	return(TRUE);
} // END ConversionBoxOKEvent()
示例#4
0
void GTKGeomWindow::combobox( GtkComboBox *combobox )
{
    //std::cout << "Combobox\n";

    int level;
    int levelmax;
    view_e view;
    if( _geom.geom_mode() == MODE_3D )
	view = (view_e)gtk_combo_box_get_active( GTK_COMBO_BOX(_combobox) );
    else {
	if( gtk_combo_box_get_active( GTK_COMBO_BOX(_combobox) ) == 0 )
	    view = VIEW_XY;
	else
	    view = VIEW_YX;
    }

    switch( view ) {
    case VIEW_XY:
	levelmax = _geom.size(2);
	level = levelmax/2;
        break;
    case VIEW_XZ:
	levelmax = _geom.size(1);
	level = levelmax/2;
        break;
    case VIEW_YX:
	levelmax = _geom.size(2);
	level = levelmax/2;
        break;
    case VIEW_YZ:
	levelmax = _geom.size(0);
	level = levelmax/2;
        break;
    case VIEW_ZX:
	levelmax = _geom.size(1);
	level = levelmax/2;
        break;
    case VIEW_ZY:
	levelmax = _geom.size(0);
	level = levelmax/2;
        break;
    default:
	throw( ErrorUnimplemented( ERROR_LOCATION ) );
	break;
    }

    // Set ranges to defaults on view change
    double min = -std::numeric_limits<double>::infinity();
    double max = std::numeric_limits<double>::infinity();
    _frame.set_ranges( PLOT_AXIS_X1, min, max );
    _frame.set_ranges( PLOT_AXIS_Y1, min, max );
    _frame.ruler_autorange_enable( PLOT_AXIS_X1, false, false );
    _frame.ruler_autorange_enable( PLOT_AXIS_Y1, false, false );

    // Update spinbutton
    /*
    g_signal_handlers_block_by_func( G_OBJECT(_spinbutton),
				     (void *)spinbutton_signal,
				     (gpointer)this );
    */
    g_signal_handlers_disconnect_by_func( G_OBJECT(_spinbutton),
					  (void *)spinbutton_signal,
					  (gpointer)this );
    gtk_spin_button_set_range( GTK_SPIN_BUTTON(_spinbutton), 0, levelmax-1 );
    gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), level );
    /*
    g_signal_handlers_unblock_by_func( G_OBJECT(_spinbutton),
				       (void *)spinbutton_signal,
				       (gpointer)this );
    */
    //g_signal_stop_emission_by_name( G_OBJECT(_spinbutton), "value-changed" );
    g_signal_connect( G_OBJECT(_spinbutton), "value-changed",
                      G_CALLBACK(spinbutton_signal),
                      (gpointer)this );


    // Update view
    _geomplot.set_view( view, level );
    update_view();
    draw_and_expose();
}
示例#5
0
void toggle_units_group(GtkToggleButton *togglebutton, gpointer user_data) 
{
    gboolean percent_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio_size_percent));
    gboolean aspect_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio_stretch_aspect));
    
    int combo_manualsize_sel = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_manualsize));
    gboolean both_active = (combo_manualsize_sel == 0);
    gboolean width_active = (combo_manualsize_sel == 1);
    gboolean height_active = (combo_manualsize_sel == 2);
    
    if (percent_active) {
        // store last pixel values
        if (gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_width)) > 0 && gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_height)) > 0) {
            last_pixel_w_value = gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_width));
            last_pixel_h_value = gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_height));
        }
        
        gtk_widget_set_sensitive(GTK_WIDGET(combo_manualsize), FALSE);
        gtk_label_set_text(GTK_LABEL(label_unit), "%");
        
        // set adjustments
        gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_width), GTK_ADJUSTMENT(gtk_adjustment_new (last_percent_w_value, 1, 40960, 0.01, 1, 0)), 0, 2);
        if (aspect_active) {
            gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_height), gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(spin_width)), 0, 2);
        }
        else {
            gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_height), GTK_ADJUSTMENT(gtk_adjustment_new (last_percent_h_value, 1, 40960, 0.01, 1, 0)), 0, 2);
        }
        
        previous_was_percent = TRUE;
    }
    else {
        if (gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_width)) > 0 && gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_height)) > 0) {
            if (previous_was_percent) {
                last_percent_w_value = gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_width));
                last_percent_h_value = gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_height));
            }
            else {
                last_pixel_w_value = gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_width));
                last_pixel_h_value = gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_height));
            }
        }
        
        gtk_widget_set_sensitive(GTK_WIDGET(combo_manualsize), TRUE);
        gtk_label_set_text(GTK_LABEL(label_unit), "px");
        
        gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_width), GTK_ADJUSTMENT(gtk_adjustment_new (last_pixel_w_value, 1, 262144, 1, 10, 0)), 0, 0);
        gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_height), GTK_ADJUSTMENT(gtk_adjustment_new (last_pixel_h_value, 1, 262144, 1, 10, 0)), 0, 0);
        
        previous_was_percent = FALSE;
    }
    
    // adjustments for resolution spinners
    if (aspect_active) {
        gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_resY), gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(spin_resX)), 0, 3);
    }
    else {
        gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_resY), GTK_ADJUSTMENT(gtk_adjustment_new (gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_resY)), 0.005, 65536.000, 1.000, 1, 0)), 0, 3);
    }
    
    gtk_widget_set_sensitive(GTK_WIDGET(spin_width), (percent_active || both_active || width_active));
    gtk_widget_set_sensitive(GTK_WIDGET(spin_height), (percent_active || both_active || height_active));
    gtk_widget_set_sensitive(GTK_WIDGET(chooser_paddingcolor), gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio_stretch_padded)));
}
示例#6
0
文件: main.cpp 项目: Tiger66639/yarp
//*********************************************************************************
static void combo_net_changed (GtkComboBox *box,    gpointer   user_data)
{
    PART = gtk_combo_box_get_active (box);
}
示例#7
0
文件: serial.c 项目: mahiso/JudoShiai
void set_serial_dialog(GtkWidget *w, gpointer data)
{
    gint i;
    GtkWidget *dialog, *used, *device, *baudrate, *table, *devtype;

    dialog = gtk_dialog_new_with_buttons (_("Serial Communication"),
                                          GTK_WINDOW(main_window),
                                          GTK_DIALOG_MODAL,
                                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                          GTK_STOCK_OK, GTK_RESPONSE_OK,
                                          NULL);

#if (GTKVER == 3)
    table = gtk_grid_new();
#else
    table = gtk_table_new(2, 4, FALSE);
#endif
    used = gtk_check_button_new();
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(used), serial_used);

    device = gtk_entry_new();
    gtk_entry_set_max_length(GTK_ENTRY(device), 20);
    gtk_entry_set_text(GTK_ENTRY(device), serial_device[0] ? serial_device : "COM1");

#if (GTKVER == 3)
    baudrate = gtk_combo_box_text_new();
    for (i = 0; i < NUM_BAUDRATES; i++)
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(baudrate), NULL, serial_baudrates[i].text);
    gtk_combo_box_set_active(GTK_COMBO_BOX(baudrate), serial_baudrate);
#else
    baudrate = gtk_combo_box_new_text();
    for (i = 0; i < NUM_BAUDRATES; i++)
        gtk_combo_box_append_text((GtkComboBox *)baudrate, serial_baudrates[i].text);
    gtk_combo_box_set_active((GtkComboBox *)baudrate, serial_baudrate);
#endif

#if (GTKVER == 3)
    devtype = gtk_combo_box_text_new();
    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "Normal");
    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "Stathmos/Allvåg");
    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "AP-1");
    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "My Weight");
    gtk_combo_box_set_active(GTK_COMBO_BOX(devtype), device_type);
#else
    devtype = gtk_combo_box_new_text();
    gtk_combo_box_append_text((GtkComboBox *)devtype, "Normal");
    gtk_combo_box_append_text((GtkComboBox *)devtype, "Stathmos/Allvåg");
    gtk_combo_box_append_text((GtkComboBox *)devtype, "AP-1");
    gtk_combo_box_append_text((GtkComboBox *)devtype, "My Weight");
    gtk_combo_box_set_active((GtkComboBox *)devtype, device_type);
#endif

#if (GTKVER == 3)
    gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("In Use")), 0, 0, 1, 1);
    gtk_grid_attach(GTK_GRID(table), used, 1, 0, 1, 1);
    gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("Device")), 0, 1, 1, 1);
    gtk_grid_attach(GTK_GRID(table), device, 1, 1, 1, 1);
    gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("Baudrate")), 0, 2, 1, 1);
    gtk_grid_attach(GTK_GRID(table), baudrate, 1, 2, 1, 1);
    gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("Type")), 0, 3, 1, 1);
    gtk_grid_attach(GTK_GRID(table), devtype, 1, 3, 1, 1);

    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), 
                       table, FALSE, FALSE, 0);
#else
    gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("In Use")), 0, 1, 0, 1);
    gtk_table_attach_defaults(GTK_TABLE(table), used, 1, 2, 0, 1);
    gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Device")), 0, 1, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), device, 1, 2, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Baudrate")), 0, 1, 2, 3);
    gtk_table_attach_defaults(GTK_TABLE(table), baudrate, 1, 2, 2, 3);
    gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Type")), 0, 1, 3, 4);
    gtk_table_attach_defaults(GTK_TABLE(table), devtype, 1, 2, 3, 4);

    gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), table);
#endif

    gtk_widget_show_all(dialog);

    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
        strncpy(serial_device, gtk_entry_get_text(GTK_ENTRY(device)), sizeof(serial_device)-1);
        serial_baudrate = gtk_combo_box_get_active(GTK_COMBO_BOX(baudrate));
        device_type = gtk_combo_box_get_active(GTK_COMBO_BOX(devtype));
        g_key_file_set_string(keyfile, "preferences", "serialdevice", serial_device);
        g_key_file_set_integer(keyfile, "preferences", "serialbaudrate", serial_baudrate);
        g_key_file_set_integer(keyfile, "preferences", "serialtype", device_type);
        serial_used = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(used));
        serial_changed = TRUE;
    }

    gtk_widget_destroy(dialog);
}
示例#8
0
/* private functions */

static void
logview_version_selector_changed (GtkComboBox *version_selector, gpointer user_data)
{

}
#if 0
	LogviewWindow *logview = user_data;
	Log *log = logview->curlog;
	int selected;

    g_assert (LOGVIEW_IS_WINDOW (logview));

	selected = gtk_combo_box_get_active (version_selector);

	if (selected == log->current_version)
		return;

	/* select a new version */
	if (selected == 0) {
		logview_select_log (logview, log->parent_log);
	} else {
		Log *new;
		if (log->parent_log) {
			new = log->parent_log->older_logs[selected];
		} else {
			new = log->older_logs[selected];
		}
示例#9
0
文件: setup.c 项目: GNOME/tali
static gint
SetGameType (GtkWidget *widget, gpointer *data)
{
    NewGameType = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
    return FALSE;
}
示例#10
0
static void
change_action_click_cb (GtkComboBox *widget, gpointer user_data)
{
    VNR_PREFS(user_data)->behavior_click = gtk_combo_box_get_active(widget);
    vnr_prefs_save(VNR_PREFS(user_data));
}
示例#11
0
 int DIA_getLameSettings(ADM_audioEncoderDescriptor *descriptor)
  {
  GtkWidget *dialog;
  
  int ret=0;
  char string[400];
  GtkComboBox *combo_box;

  LAME_encoderParam *lameParam;
  ADM_assert(sizeof(LAME_encoderParam)==descriptor->paramSize);
  
  lameParam=(LAME_encoderParam*)descriptor->param;
  
    dialog=create_dialog1();
    gtk_register_dialog(dialog);

        // ******** Set mode****************
        int mindex;
        mindex=1;
        switch(lameParam->mode)
        {
            case ADM_MONO:mindex=0;break;
            default:
            case ADM_STEREO:mindex=1;break;
            case ADM_JSTEREO:mindex=2;break;	
        }
        combo_box=GTK_COMBO_BOX(WID(comboboxMode));
        gtk_combo_box_set_active(combo_box,mindex);
        // *******  set bitrate ************
        combo_box=GTK_COMBO_BOX(WID(comboboxBitrate));
        gtk_combo_box_remove_text(combo_box,0);
        
        for(unsigned int i=0;i<NB_BITRATE;i++)
        {
            sprintf(string,"%d kbits",BTR[i]);
            gtk_combo_box_append_text(combo_box,string);
            if(descriptor->bitrate==BTR[i])
              gtk_combo_box_set_active(combo_box,i);
        }
        // ******** Set preset ********
        combo_box=GTK_COMBO_BOX(WID(comboboxPreset));
        gtk_combo_box_remove_text(combo_box,0);
        for(unsigned int i=0;i<3;i++)
        {
          gtk_combo_box_append_text(combo_box,presetDefinition[i].name);
          if(lameParam->preset==presetDefinition[i].preset)
            gtk_combo_box_set_active(combo_box,i);
        }
        // ********* Quality ******
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(WID(spinbuttonQuality)),(gfloat)lameParam->quality) ;

        if(GTK_RESPONSE_OK==gtk_dialog_run(GTK_DIALOG(dialog)))
        {
          combo_box=GTK_COMBO_BOX(WID(comboboxBitrate));
          descriptor->bitrate=BTR[gtk_combo_box_get_active(combo_box)];
          
          combo_box=GTK_COMBO_BOX(WID(comboboxPreset));
          lameParam->preset=presetDefinition[gtk_combo_box_get_active(combo_box)].preset;
              
          combo_box=GTK_COMBO_BOX(WID(comboboxMode));
          switch(gtk_combo_box_get_active(combo_box))
          {
            case 0: lameParam->mode=ADM_MONO;break;
            case 1: lameParam->mode=ADM_STEREO;break;
            case 2: lameParam->mode=ADM_JSTEREO;break;
            default : ADM_assert(0);
          }
          lameParam->quality=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(WID(spinbuttonQuality))) ;
          
        }
        gtk_unregister_dialog(dialog);
        gtk_widget_destroy(dialog);
        return ret;
  }
示例#12
0
static void
change_zoom_mode_cb (GtkComboBox *widget, gpointer user_data)
{
    VNR_PREFS(user_data)->zoom = gtk_combo_box_get_active(widget);
    vnr_prefs_save(VNR_PREFS(user_data));
}
示例#13
0
void save_appearance_conf()
{
  if (appearance_widget == NULL)
  {
    fprintf(stderr, "save_appearance_conf: appearance_widget is NULL!\n");
    return;
  }

  char fname[128];
  strcpy(fname, gtk_font_button_get_font_name(GTK_FONT_BUTTON(font_sel)));
  int len = strlen(fname)-1;
  

  while (len > 0 && isdigit(fname[len])) {
       len--;
  }
  save_hime_conf_int(HIME_FONT_SIZE, atoi(&(fname[len+1])));

  while (len > 0 && fname[len]==' ') {
       fname[len--]=0;
  }
  save_hime_conf_str(HIME_FONT_NAME, fname);

  int font_size_tsin_presel = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_tsin_presel));
  save_hime_conf_int(HIME_FONT_SIZE_TSIN_PRESEL, font_size_tsin_presel);

  int font_size_symbol = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_symbol));
  save_hime_conf_int(HIME_FONT_SIZE_SYMBOL, font_size_symbol);

  int font_size_tsin_pho_in = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_tsin_pho_in));
  save_hime_conf_int(HIME_FONT_SIZE_TSIN_PHO_IN, font_size_tsin_pho_in);

  int font_size_pho_near = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_pho_near));
  save_hime_conf_int(HIME_FONT_SIZE_PHO_NEAR, font_size_pho_near);

  int font_size_gtab_in = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_gtab_in));
  save_hime_conf_int(HIME_FONT_SIZE_GTAB_IN, font_size_gtab_in);

  int font_size_win_kbm = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_win_kbm));
  save_hime_conf_int(HIME_FONT_SIZE_WIN_KBM, font_size_win_kbm);
  int font_size_win_kbm_en = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_hime_font_size_win_kbm_en));
  save_hime_conf_int(HIME_FONT_SIZE_WIN_KBM_EN, font_size_win_kbm_en);

  int hime_pop_up_win = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_pop_up_win));
  save_hime_conf_int(HIME_POP_UP_WIN, hime_pop_up_win);

  int hime_root_x = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_root_style_x));
  save_hime_conf_int(HIME_ROOT_X, hime_root_x);

  int hime_root_y = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_root_style_y));
  save_hime_conf_int(HIME_ROOT_Y, hime_root_y);

  int style = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_root_style_use)) ?
            InputStyleRoot : InputStyleOverSpot;
  save_hime_conf_int(HIME_INPUT_STYLE, style);

  save_hime_conf_int(HIME_INNER_FRAME, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_inner_frame)));
#if TRAY_ENABLED
  save_hime_conf_int(HIME_STATUS_TRAY, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_status_tray)));
#endif

  save_hime_conf_int(HIME_WIN_COLOR_USE, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_win_color_use)));
  save_hime_conf_str(HIME_WIN_COLOR_FG, hime_win_color_fg);
  save_hime_conf_str(HIME_WIN_COLOR_BG, hime_win_color_bg);
  save_hime_conf_str(HIME_SEL_KEY_COLOR, hime_sel_key_color);
  int idx = gtk_combo_box_get_active(GTK_COMBO_BOX(opt_hime_icon_dir_display));
  save_hime_conf_str(HIME_ICON_DIR, icon_dir_sel[idx].path);
  save_hime_conf_str(TSIN_CURSOR_COLOR, tsin_cursor_color);

  save_hime_conf_int(HIME_ON_THE_SPOT_KEY, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_on_the_spot_key)));
  save_hime_conf_int(KBM_TOGGLE, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_show_win_kbm)));
#if TRAY_ENABLED
  save_hime_conf_int(HIME_TRAY_HF_WIN_KBM, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_tray_hf_win_kbm)));
#endif

  idx = gtk_combo_box_get_active (GTK_COMBO_BOX (opt_hime_edit_display));
  save_hime_conf_int(HIME_EDIT_DISPLAY, edit_disp[idx].keynum);

#if TRAY_ENABLED
  idx = gtk_combo_box_get_active (GTK_COMBO_BOX (opt_hime_tray_display));
  save_hime_conf_int(HIME_TRAY_DISPLAY, tray_disp[idx].keynum);
#endif

#if 0
  save_hime_conf_int(HIME_SETUP_WINDOW_TYPE_UTILITY, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_setup_window_type_utility)));
#endif

  save_omni_config();
  send_hime_message(GDK_DISPLAY(), CHANGE_FONT_SIZE);
#if TRAY_ENABLED
  send_hime_message(GDK_DISPLAY(), UPDATE_TRAY);
#endif
}
static void cal_switch_ports_enable_cb (GtkWidget *widget, gpointer data)
{
	__cal_switch_ports_enable_cb(gtk_combo_box_get_active(GTK_COMBO_BOX(widget)));
}
示例#15
0
static void _lib_lighttable_layout_changed(GtkComboBox *widget, gpointer user_data)
{
  const int i = gtk_combo_box_get_active(widget);
  dt_conf_set_int("plugins/lighttable/layout", i);
  dt_control_queue_redraw_center();
}
示例#16
0
static void setOption(GtkWidget *widget, gpointer  data)
{	
	currentOption = gtk_combo_box_get_active(GTK_COMBO_BOX(optionBox));
}
示例#17
0
void DisplayDialog()
{
    int return_value;

    GtkWidget *dialog;
    GtkWidget *main_frame, *main_box;

    GtkWidget *mixing_frame, *mixing_box;
    GtkWidget *int_label, *int_box;
    GtkWidget *effects_check;
    GtkWidget *dealias_filter;
    GtkWidget *debug_check;
    GtkWidget *debug_button;

    GtkWidget *output_frame, *output_box;
    GtkWidget *mod_label, *mod_box;
    GtkWidget *api_label, *api_box;
#if SDL_MAJOR_VERSION >= 2
    GtkWidget *sdl_api_label, *sdl_api_box;
#endif
    GtkWidget *latency_label, *latency_slide;
    GtkWidget *sync_label, *sync_box;
    GtkWidget *advanced_button;

    /* Create the widgets */
    dialog = gtk_dialog_new_with_buttons (
		"SPU2-X Config",
		NULL, /* parent window*/
		(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
		"OK", GTK_RESPONSE_ACCEPT,
		"Cancel", GTK_RESPONSE_REJECT,
		NULL);

    int_label = gtk_label_new ("Interpolation:");
    int_box = gtk_combo_box_text_new ();
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "0 - Nearest (fastest/bad quality)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "1 - Linear (simple/okay sound)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "2 - Cubic (artificial highs)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "3 - Hermite (better highs)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "4 - Catmull-Rom (PS2-like/slow)");
    gtk_combo_box_set_active(GTK_COMBO_BOX(int_box), Interpolation);

    effects_check = gtk_check_button_new_with_label("Disable Effects Processing");
    dealias_filter = gtk_check_button_new_with_label("Use the de-alias filter (overemphasizes the highs)");

    debug_check = gtk_check_button_new_with_label("Enable Debug Options");
	debug_button = gtk_button_new_with_label("Debug...");

    mod_label = gtk_label_new ("Module:");
    mod_box = gtk_combo_box_text_new ();
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "0 - No Sound (emulate SPU2 only)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "1 - PortAudio (cross-platform)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "2 - SDL Audio (recommended for PulseAudio)");
    //gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "3 - Alsa (probably doesn't work)");
    gtk_combo_box_set_active(GTK_COMBO_BOX(mod_box), OutputModule);

    api_label = gtk_label_new ("PortAudio API:");
    api_box = gtk_combo_box_text_new ();
	// In order to keep it the menu light, I only put linux major api
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "0 - ALSA (recommended)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "1 - OSS (legacy)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "2 - JACK");
    gtk_combo_box_set_active(GTK_COMBO_BOX(api_box), OutputAPI);

#if SDL_MAJOR_VERSION >= 2
    sdl_api_label = gtk_label_new ("SDL API:");
    sdl_api_box = gtk_combo_box_text_new ();
    // YES It sucks ...
    for (int i = 0; i < SDL_GetNumAudioDrivers(); ++i) {
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sdl_api_box), SDL_GetAudioDriver(i));
    }
    gtk_combo_box_set_active(GTK_COMBO_BOX(sdl_api_box), SdlOutputAPI);
#endif

    latency_label = gtk_label_new ("Latency:");
#if GTK_MAJOR_VERSION < 3
    latency_slide = gtk_hscale_new_with_range(LATENCY_MIN, LATENCY_MAX, 5);
#else
    latency_slide = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, LATENCY_MIN, LATENCY_MAX, 5);
#endif
    gtk_range_set_value(GTK_RANGE(latency_slide), SndOutLatencyMS);

    sync_label = gtk_label_new ("Synchronization Mode:");
    sync_box = gtk_combo_box_text_new ();
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "TimeStretch (Recommended)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "Async Mix (Breaks some games!)");
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "None (Audio can skip.)");
    gtk_combo_box_set_active(GTK_COMBO_BOX(sync_box), SynchMode);

	advanced_button = gtk_button_new_with_label("Advanced...");

    main_box = gtk_hbox_new(false, 5);
    main_frame = gtk_frame_new ("SPU2-X Config");
    gtk_container_add (GTK_CONTAINER(main_frame), main_box);

    mixing_box = gtk_vbox_new(false, 5);
    mixing_frame = gtk_frame_new ("Mixing Settings:");
    gtk_container_add (GTK_CONTAINER(mixing_frame), mixing_box);

    output_box = gtk_vbox_new(false, 5);
    output_frame = gtk_frame_new ("Output Settings:");
    gtk_container_add (GTK_CONTAINER(output_frame), output_box);

	gtk_container_add(GTK_CONTAINER(mixing_box), int_label);
	gtk_container_add(GTK_CONTAINER(mixing_box), int_box);
	gtk_container_add(GTK_CONTAINER(mixing_box), effects_check);
	gtk_container_add(GTK_CONTAINER(mixing_box), dealias_filter);
	gtk_container_add(GTK_CONTAINER(mixing_box), debug_check);
	gtk_container_add(GTK_CONTAINER(mixing_box), debug_button);

	gtk_container_add(GTK_CONTAINER(output_box), mod_label);
	gtk_container_add(GTK_CONTAINER(output_box), mod_box);
	gtk_container_add(GTK_CONTAINER(output_box), api_label);
	gtk_container_add(GTK_CONTAINER(output_box), api_box);
#if SDL_MAJOR_VERSION >= 2
	gtk_container_add(GTK_CONTAINER(output_box), sdl_api_label);
	gtk_container_add(GTK_CONTAINER(output_box), sdl_api_box);
#endif
	gtk_container_add(GTK_CONTAINER(output_box), sync_label);
	gtk_container_add(GTK_CONTAINER(output_box), sync_box);
	gtk_container_add(GTK_CONTAINER(output_box), latency_label);
	gtk_container_add(GTK_CONTAINER(output_box), latency_slide);
	gtk_container_add(GTK_CONTAINER(output_box), advanced_button);

	gtk_container_add(GTK_CONTAINER(main_box), mixing_frame);
	gtk_container_add(GTK_CONTAINER(main_box), output_frame);

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(effects_check), EffectsDisabled);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dealias_filter), postprocess_filter_dealias);
	//FinalVolume;
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(debug_check), DebugEnabled);

    gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_frame);
    gtk_widget_show_all (dialog);

    g_signal_connect_swapped(advanced_button, "clicked", G_CALLBACK(advanced_dialog), advanced_button);
    g_signal_connect_swapped(debug_button, "clicked", G_CALLBACK(debug_dialog), debug_button);

    return_value = gtk_dialog_run (GTK_DIALOG (dialog));

    if (return_value == GTK_RESPONSE_ACCEPT)
    {
		DebugEnabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(debug_check));
		postprocess_filter_dealias = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dealias_filter));
    	if (gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)) != -1)
    		Interpolation = gtk_combo_box_get_active(GTK_COMBO_BOX(int_box));

    	EffectsDisabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(effects_check));
		//FinalVolume;

    	if (gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box)) != -1)
			OutputModule = gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box));

    	if (gtk_combo_box_get_active(GTK_COMBO_BOX(api_box)) != -1) {
			OutputAPI = gtk_combo_box_get_active(GTK_COMBO_BOX(api_box));
			switch(OutputAPI) {
				case 0: PortaudioOut->SetApiSettings(L"ALSA"); break;
				case 1: PortaudioOut->SetApiSettings(L"OSS"); break;
				case 2: PortaudioOut->SetApiSettings(L"JACK"); break;
				default: PortaudioOut->SetApiSettings(L"Unknown");
			}
		}

#if SDL_MAJOR_VERSION >= 2
		if (gtk_combo_box_get_active(GTK_COMBO_BOX(sdl_api_box)) != -1) {
			SdlOutputAPI = gtk_combo_box_get_active(GTK_COMBO_BOX(sdl_api_box));
			// YES It sucks ...
			SDLOut->SetApiSettings(wxString(SDL_GetAudioDriver(SdlOutputAPI), wxConvUTF8));
		}
#endif

    	SndOutLatencyMS = gtk_range_get_value(GTK_RANGE(latency_slide));
    	
    	if (gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box)) != -1)
			SynchMode = gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box));
    }

    gtk_widget_destroy (dialog);
}
示例#18
0
/*
 * GUI warning/error dialog
 * args:
 *   title - dialog title string
 *   message - error message string
 *   fatal - flag a fatal error (display device list combo box)
 *
 * asserts:
 *   none
 *
 * returns: none
 */
void gui_error_gtk3(
	const char *title,
	const char *message,
	int fatal)
{
	if(!gtk_init_called)
	{
		if(!gtk_init_check(NULL, NULL))
		{
			fprintf(stderr, "GUVCVIEW: (GUI) Gtk3 can't open display\n");
			fprintf(stderr, "%s: %s \n", title, message);
			return;
		}

		gtk_init_called = 1;
	}
	/*simple warning message - not fatal and no device selection*/
	if(!fatal)
	{
		GtkWidget *warndialog;
		warndialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
		    GTK_DIALOG_DESTROY_WITH_PARENT,
		    GTK_MESSAGE_WARNING,
		    GTK_BUTTONS_CLOSE,
		    "%s",gettext(title));

		gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(warndialog),
		    "%s",gettext(message));

		gtk_widget_show(warndialog);
		gtk_dialog_run (GTK_DIALOG (warndialog));
		gtk_widget_destroy (warndialog);
		return;
	}

	/*fatal error message*/

	/*add device list (more than one device)*/
	int show_dev_list = (v4l2core_get_num_devices() >= 1) ? 1: 0;

	GtkWidget *errdialog = NULL;
	if(show_dev_list)
		errdialog = gtk_dialog_new_with_buttons (_("Error"),
			GTK_WINDOW(main_window),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			_("_Ok"), GTK_RESPONSE_ACCEPT,
			_("_Cancel"), GTK_RESPONSE_REJECT,
			NULL);
	else
		errdialog = gtk_dialog_new_with_buttons (_("Error"),
			GTK_WINDOW(main_window),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			_("_Ok"), GTK_RESPONSE_ACCEPT,
			NULL);

	GtkWidget *table = gtk_grid_new();

	GtkWidget *title_lbl = gtk_label_new (gettext(title));
	
#if GTK_VER_AT_LEAST(3,16)
	/* Style provider for this label. */
	GtkCssProvider *providerTitle = gtk_css_provider_new();

	gtk_style_context_add_provider(gtk_widget_get_style_context(title_lbl),
	        GTK_STYLE_PROVIDER(providerTitle),
	        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
	gtk_css_provider_load_from_data(providerTitle,
	                                "GtkLabel { font: \"Sans bold 10\"; }",
	                                -1, NULL);
	g_object_unref(providerTitle);
#else
	gtk_widget_override_font(title_lbl, pango_font_description_from_string ("Sans bold 10"));
	gtk_misc_set_alignment (GTK_MISC (title_lbl), 0, 0);
#endif
	gtk_grid_attach (GTK_GRID (table), title_lbl, 0, 0, 2, 1);
	gtk_widget_show (title_lbl);

	GtkWidget *text = gtk_label_new (gettext(message));

#if GTK_VER_AT_LEAST(3,16)
	/* Style provider for this label. */
	GtkCssProvider *providerText = gtk_css_provider_new();

	gtk_style_context_add_provider(gtk_widget_get_style_context(text),
	        GTK_STYLE_PROVIDER(providerText),
	        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
	gtk_css_provider_load_from_data(providerText,
	                                "GtkLabel { font: \"Sans italic 8\"; }",
	                                -1, NULL);
	g_object_unref(providerText);
#else
	gtk_widget_override_font(text, pango_font_description_from_string ("Sans italic 8"));
	gtk_misc_set_alignment (GTK_MISC (text), 0, 0);
#endif
	
	gtk_grid_attach (GTK_GRID (table), text, 0, 1, 2, 1);
	gtk_widget_show (text);

	GtkWidget *wgtDevices = NULL;

	if(show_dev_list)
	{
		GtkWidget *text2 = gtk_label_new (_("\nYou seem to have video devices installed.\n"
							                "Do you want to try one ?\n"));

#if GTK_VER_AT_LEAST(3,16)
	/* Style provider for this label. */
	GtkCssProvider *providerText2 = gtk_css_provider_new();

	gtk_style_context_add_provider(gtk_widget_get_style_context(text2),
	        GTK_STYLE_PROVIDER(providerText2),
	        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
	gtk_css_provider_load_from_data(providerText2,
	                                "GtkLabel { font: \"Sans 10\"; }",
	                                -1, NULL);
	g_object_unref(providerText2);
#else
		gtk_widget_override_font(text2, pango_font_description_from_string ("Sans 10"));
		gtk_misc_set_alignment (GTK_MISC (text2), 0, 0);
#endif
		gtk_grid_attach (GTK_GRID (table), text2, 0, 2, 2, 1);
		gtk_widget_show (text2);

		GtkWidget *dev_lbl = gtk_label_new(_("Device:"));

#if GTK_VER_AT_LEAST(3,15)
		gtk_label_set_xalign(GTK_LABEL(dev_lbl), 0.5);
		gtk_label_set_yalign(GTK_LABEL(dev_lbl), 0.5);
#else
		gtk_misc_set_alignment (GTK_MISC (dev_lbl), 0.5, 0.5);
#endif
		gtk_grid_attach (GTK_GRID(table), dev_lbl, 0, 3, 1, 1);
		gtk_widget_show (dev_lbl);

		wgtDevices = gtk_combo_box_text_new ();
		gtk_widget_set_halign (wgtDevices, GTK_ALIGN_FILL);
		gtk_widget_set_hexpand (wgtDevices, TRUE);

		int i = 0;
		for(i = 0; i < v4l2core_get_num_devices(); i++)
		{
			gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(wgtDevices),
				v4l2core_get_device_sys_data(i)->name);
		}
		/*select the last listed device by default*/
		gtk_combo_box_set_active(GTK_COMBO_BOX(wgtDevices), v4l2core_get_num_devices() - 1);

		gtk_grid_attach(GTK_GRID(table), wgtDevices, 1, 3, 1, 1);
		gtk_widget_show (wgtDevices);
	}

	GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (errdialog));
	gtk_container_add (GTK_CONTAINER (content_area), table);
	gtk_widget_show (table);

	int result = gtk_dialog_run (GTK_DIALOG (errdialog));

	if(show_dev_list)
	{
		switch (result)
		{
			case GTK_RESPONSE_ACCEPT:
			{
				/*launch another guvcview instance for the selected device*/
				int index = gtk_combo_box_get_active(GTK_COMBO_BOX(wgtDevices));

				char videodevice[30];
				strncpy(videodevice, v4l2core_get_device_sys_data(index)->device, 29);

				gchar *command = g_strjoin("",
					g_get_prgname(),
					" --device=",
					videodevice,
					NULL);

				/*spawn new process*/
				GError *error = NULL;
				if(!(g_spawn_command_line_async(command, &error)))
				{
					fprintf(stderr, "GUVCVIEW: spawn failed: %s\n", error->message);
					g_error_free( error );
				}
				g_free(command);
			}
			break;

			default:
				/* do nothing since dialog was cancelled or closed */
				break;

		}
	}

	gtk_widget_destroy (errdialog);

	quit_callback(NULL); /*terminate the program*/
}
示例#19
0
文件: render.c 项目: CrashFil/poppler
static void
pgd_render_rotate_selector_changed (GtkComboBox   *combobox,
				    PgdRenderDemo *demo)
{
	demo->rotate = gtk_combo_box_get_active (combobox) * 90;
}
示例#20
0
gpointer
engine_session_open (GtkWidget *logon_widget, gchar *buffer)
{
	GSQL_TRACE_FUNC;

	GtkWidget *widget;
		
	const gchar *username,
				*password,
				*database;
	gchar info[32];
	
	GSQLSession  *session;
	GSQLSession  *current;
	GSQLEngine   *engine;
	GSQLCursor   *cursor;
	GSQLCursorState c_state;
	GSQLWorkspace *workspace;
	GSQLNavigation *navigation;
	GSQLEOracleSession *spec;
	GList   *lst;
	gchar *sql = "select version from product_component_version "
	 			 "where instr(lower(product),'oracle') >0  "
				 "and rownum <2 ";
	GSQLVariable *variable;
	ub4 mode;

	
	gint connect_as = 0;
	widget = g_object_get_data (G_OBJECT (logon_widget), "username");
	username = gtk_entry_get_text (GTK_ENTRY (widget));
	widget = g_object_get_data (G_OBJECT (logon_widget), "password");
	password = gtk_entry_get_text (GTK_ENTRY (widget));
	widget = g_object_get_data (G_OBJECT (logon_widget), "database");
	database = gtk_combo_box_get_active_text (GTK_COMBO_BOX (widget));
	widget = g_object_get_data (G_OBJECT (logon_widget), "mode");
	
	switch (gtk_combo_box_get_active (GTK_COMBO_BOX (widget)))
	{
		case 2:
			GSQL_DEBUG ("Session mode: OCI_SYSOPER");
			mode = OCI_SYSOPER;
			break;
		case 1:
			GSQL_DEBUG ("Session mode: OCI_SYSDBA");
			mode = OCI_SYSDBA;
			break;
			
		case 0:
		default:
			GSQL_DEBUG ("Session mode: OCI_DEFAULT");
			mode = OCI_DEFAULT;
	}
	
	
	
	spec = g_malloc0 (sizeof (GSQLEOracleSession));
	
	
	spec->mode = mode;
	
	if (!oracle_session_open (spec, username, password, database, buffer)) {
		
		g_free (spec);
		
		return NULL;
	}
	
	session = gsql_session_new_with_attrs ("session-username", 
										   g_strdup(username),
										   "session-password",
										   g_strdup (password),
										   "session-database",
										   g_strdup (database),
										   NULL);
	session->spec = spec;
	
	GSQL_FIXME;
	/* <workaround> */
	engine = g_object_get_data (G_OBJECT (logon_widget), "engine");
	session->engine = engine;
	/* </workaround> */
	
	cursor = gsql_cursor_new (session, sql);
	c_state = gsql_cursor_open (cursor, FALSE); 
	
	memset ((void *) info, 0, 32);
	
	if ((c_state == GSQL_CURSOR_STATE_OPEN) && (gsql_cursor_fetch (cursor, 1)))
	{
		lst = g_list_first (cursor->var_list);
		variable = GSQL_VARIABLE (lst->data);
		g_snprintf (info, 32, "%s", (gchar *) variable->value);
		
	} else {
		g_snprintf (info, 32, "%s", "0.0.0.0");
	}
	
	gsql_cursor_close (cursor);
	
	gsql_session_set_attrs (session, "session-info",
							info,
							NULL);	 
	
	workspace = gsql_workspace_new (session);
	navigation = gsql_workspace_get_navigation (workspace);
	
	nav_tree_set_root (navigation, (gchar *) username);
	
	
	
	g_signal_connect (G_OBJECT (session), "close",
					  G_CALLBACK (on_session_close), session);
	g_signal_connect (G_OBJECT (session), "reopen",
					  G_CALLBACK (on_session_reopen), session);
	g_signal_connect (G_OBJECT (session), "duplicate",
					  G_CALLBACK (on_session_duplicate), session);
	g_signal_connect (G_OBJECT (session), "commit",
					  G_CALLBACK (on_session_commit), session);
	g_signal_connect (G_OBJECT (session), "rollback",
					  G_CALLBACK (on_session_rollback), session);
	g_signal_connect (G_OBJECT (session), "switch",
					  G_CALLBACK (on_session_switch), session);
	
	g_snprintf(buffer, 256,
			   _("Connect to the Oracle database \"<b>%s</b>\" succesfully\n"
				 "<small>(%s)</small>"), 
			   g_utf8_strup (database, g_utf8_strlen (database, 128)),
			   spec->server_version);
	
	gsql_message_add (workspace, GSQL_MESSAGE_NORMAL, buffer);
	
	GSQL_DEBUG ("New session created with name [%s]", gsql_session_get_name (session));
	
	return session;
}
示例#21
0
文件: live_view.c 项目: bgK/darktable
void
gui_post_expose(dt_lib_module_t *self, cairo_t *cr, int32_t width, int32_t height, int32_t pointerx, int32_t pointery)
{
  dt_camera_t *cam = (dt_camera_t*)darktable.camctl->active_camera;
  dt_lib_live_view_t *lib = self->data;

  if(cam->is_live_viewing == FALSE || cam->live_view_zoom == TRUE)
    return;

  dt_pthread_mutex_lock(&cam->live_view_pixbuf_mutex);
  if(GDK_IS_PIXBUF(cam->live_view_pixbuf))
  {
    gint pw = gdk_pixbuf_get_width(cam->live_view_pixbuf);
    gint ph = gdk_pixbuf_get_height(cam->live_view_pixbuf);
    float w = width-(MARGIN*2.0f);
    float h = height-(MARGIN*2.0f);
    float scale = 1.0;
//     if(cam->live_view_zoom == FALSE)
//     {
      if(pw > w) scale = w/pw;
      if(ph > h) scale = MIN(scale, h/ph);
//     }
    float sw = scale*pw;
    float sh = scale*ph;

    // draw guides
    float left = (width - scale*pw)*0.5;
    float right = left + scale*pw;
    float top = (height - scale*ph)*0.5;
    float bottom = top + scale*ph;

    double dashes = 5.0;

    cairo_save(cr);
    cairo_set_dash(cr, &dashes, 1, 0);

    int which = gtk_combo_box_get_active(GTK_COMBO_BOX(lib->guide_selector));
    switch(which)
    {
      case GUIDE_GRID:
        dt_guides_draw_simple_grid(cr, left, top, right, bottom, 1.0);
        break;

      case GUIDE_DIAGONAL:
        dt_guides_draw_diagonal_method(cr, left, top, sw, sh);
        cairo_stroke (cr);
        cairo_set_dash (cr, &dashes, 0, 0);
        cairo_set_source_rgba(cr, .3, .3, .3, .8);
        dt_guides_draw_diagonal_method(cr, left, top, sw, sh);
        cairo_stroke (cr);
        break;
      case GUIDE_THIRD:
        dt_guides_draw_rules_of_thirds(cr, left, top,  right, bottom, sw/3.0, sh/3.0);
        cairo_stroke (cr);
        cairo_set_dash (cr, &dashes, 0, 0);
        cairo_set_source_rgba(cr, .3, .3, .3, .8);
        dt_guides_draw_rules_of_thirds(cr, left, top,  right, bottom, sw/3.0, sh/3.0);
        cairo_stroke (cr);
        break;
      case GUIDE_TRIANGL:
      {
        int dst = (int)((sh*cos(atan(sw/sh)) / (cos(atan(sh/sw)))));
        // Move coordinates to local center selection.
        cairo_translate(cr, ((right - left)/2+left), ((bottom - top)/2+top));

        // Flip horizontal.
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->flipHorGoldenGuide)))
          cairo_scale(cr, -1, 1);
        // Flip vertical.
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->flipVerGoldenGuide)))
          cairo_scale(cr, 1, -1);

        dt_guides_draw_harmonious_triangles(cr, left, top,  right, bottom, dst);
        cairo_stroke (cr);
        //p.setPen(QPen(d->guideColor, d->guideSize, Qt::DotLine));
        cairo_set_dash (cr, &dashes, 0, 0);
        cairo_set_source_rgba(cr, .3, .3, .3, .8);
        dt_guides_draw_harmonious_triangles(cr, left, top,  right, bottom, dst);
        cairo_stroke (cr);
      }
      break;
      case GUIDE_GOLDEN:
      {
        // Move coordinates to local center selection.
        cairo_translate(cr, ((right - left)/2+left), ((bottom - top)/2+top));

        // Flip horizontal.
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->flipHorGoldenGuide)))
          cairo_scale(cr, -1, 1);
        // Flip vertical.
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->flipVerGoldenGuide)))
          cairo_scale(cr, 1, -1);

        float w = sw;
        float h = sh;

        // lengths for the golden mean and half the sizes of the region:
        float w_g = w*INVPHI;
        float h_g = h*INVPHI;
        float w_2 = w/2;
        float h_2 = h/2;

        dt_QRect_t R1, R2, R3, R4, R5, R6, R7;
        dt_guides_q_rect (&R1, -w_2, -h_2, w_g, h);

        // w - 2*w_2 corrects for one-pixel difference
        // so that R2.right() is really at the right end of the region
        dt_guides_q_rect (&R2, w_g-w_2, h_2-h_g, w-w_g+1-(w - 2*w_2), h_g);
        dt_guides_q_rect (&R3, w_2 - R2.width*INVPHI, -h_2, R2.width*INVPHI, h - R2.height);
        dt_guides_q_rect (&R4, R2.left, R1.top, R3.left - R2.left, R3.height*INVPHI);
        dt_guides_q_rect (&R5, R4.left, R4.bottom, R4.width*INVPHI, R3.height - R4.height);
        dt_guides_q_rect (&R6, R5.left + R5.width, R5.bottom - R5.height*INVPHI, R3.left - R5.right, R5.height*INVPHI);
        dt_guides_q_rect (&R7, R6.right - R6.width*INVPHI, R4.bottom, R6.width*INVPHI, R5.height - R6.height);

        dt_guides_draw_golden_mean(cr, &R1, &R2, &R3, &R4, &R5, &R6, &R7,
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenSectionBox)),
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenTriangleBox)),
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenSpiralSectionBox)),
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenSpiralBox))
                                  );
        cairo_stroke (cr);

        cairo_set_dash (cr, &dashes, 0, 0);
        cairo_set_source_rgba(cr, .3, .3, .3, .8);
        dt_guides_draw_golden_mean(cr, &R1, &R2, &R3, &R4, &R5, &R6, &R7,
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenSectionBox)),
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenTriangleBox)),
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenSpiralSectionBox)),
                                   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->goldenSpiralBox))
                                   );
        cairo_stroke (cr);
      }
      break;
    }
    cairo_restore(cr);
  }
  dt_pthread_mutex_unlock(&cam->live_view_pixbuf_mutex);
}
示例#22
0
static void
export_dialog_response_cb (GtkDialog *dialog,
			   int        response_id,
			   gpointer   user_data)
{
	DialogData *data = user_data;

	switch (response_id) {
	case GTK_RESPONSE_DELETE_EVENT:
	case GTK_RESPONSE_CANCEL:
		gth_file_list_cancel (GTH_FILE_LIST (data->list_view), (DataFunc) destroy_dialog, data);
		break;

	case GTK_RESPONSE_OK:
		{
			GtkTreeModel *tree_model;
			GtkTreeIter   iter;
			GList        *file_list;
			int           max_width;
			int           max_height;

			if (! gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (GET_WIDGET ("albums_treeview"))), &tree_model, &iter)) {
				gtk_dialog_set_response_sensitive (GTK_DIALOG (data->dialog),
								   GTK_RESPONSE_OK,
								   FALSE);
				return;
			}

			_g_clear_object (&data->album);
			gtk_tree_model_get (tree_model, &iter,
					    ALBUM_DATA_COLUMN, &data->album,
					    -1);

			gtk_widget_hide (data->dialog);
			gth_task_dialog (GTH_TASK (data->service), FALSE, NULL);

			file_list = gth_file_data_list_to_file_list (data->file_list);

			max_width = -1;
			max_height = -1;
			if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("resize_checkbutton")))) {
				int idx = gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("resize_combobox")));
				max_width = ImageSizeValues[idx].width;
				max_height = ImageSizeValues[idx].height;
			}
			g_settings_set_int (data->settings, PREF_PICASAWEB_RESIZE_WIDTH, max_width);
			g_settings_set_int (data->settings, PREF_PICASAWEB_RESIZE_HEIGHT, max_height);

			picasa_web_service_post_photos (data->service,
							data->album,
							file_list,
							max_width,
							max_height,
							data->cancellable,
							post_photos_ready_cb,
							data);

			_g_object_list_unref (file_list);
		}
		break;

	default:
		break;
	}
}
示例#23
0
void Dialog::UpdateData( bool retrieve ){
	DLG_DATA *data;
	GSList *lst;
	char buf[32];

	if ( retrieve ) {
		for ( lst = m_pDataList; lst != NULL; lst = g_slist_next( lst ) )
		{
			data = (DLG_DATA*)lst->data;

			switch ( data->type )
			{
			case DLG_CHECK_BOOL:
				*(bool*)data->buffer = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->object ) );
				break;
			case DLG_RADIO_INT:
			{
				GSList *radio = gtk_radio_button_group( GTK_RADIO_BUTTON( data->object ) );
				*(int*)data->buffer = g_slist_length( radio ) - 1;
				for (; radio; radio = g_slist_next( radio ) )
					if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( radio->data ) ) ) {
						break;
					}
					else{
						( *(int*)data->buffer )--;
					}
			} break;
			case DLG_ENTRY_TEXT:
			{
				const char *txt;
				Str* str;
				str = (Str*)data->buffer;
				txt = gtk_entry_get_text( GTK_ENTRY( data->object ) );
				*str = txt;
			} break;
			case DLG_ENTRY_FLOAT:
				*(float*)data->buffer = atof( gtk_entry_get_text( GTK_ENTRY( data->object ) ) );
				break;
			case DLG_ENTRY_INT:
				*(int*)data->buffer = atoi( gtk_entry_get_text( GTK_ENTRY( data->object ) ) );
				break;
			case DLG_SPIN_FLOAT:
				*(float*)data->buffer = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( data->object ) );
				break;
			case DLG_SPIN_INT:
				*(int*)data->buffer = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( data->object ) );
				break;
			case DLG_ADJ_INT:
				*(int*)data->buffer = (int) GTK_ADJUSTMENT( data->object )->value;
				break;
			case DLG_COMBO_INT:
			{
				GList *lst = GTK_LIST( GTK_COMBO( data->object )->list )->children;
				char *label;
				const char *entry;
				int i;

				*(int*)data->buffer = -1;
				entry = gtk_entry_get_text( GTK_ENTRY( GTK_COMBO( data->object )->entry ) );

				for ( i = 0; lst != NULL; lst = g_list_next( lst ) )
				{
					gtk_label_get( GTK_LABEL( GTK_BIN( lst->data )->child ), &label );

					if ( strcmp( label, entry ) == 0 ) {
						*(int*)data->buffer = i;
						break;
					}
					i++;
				}
			}
			break;
			case DLG_COMBO_BOX_INT: {
				*(int*)data->buffer = gtk_combo_box_get_active( GTK_COMBO_BOX( data->object ) );
			}
			break;

			}
		}
	}
	else
	{
		for ( lst = m_pDataList; lst != NULL; lst = g_slist_next( lst ) )
		{
			data = (DLG_DATA*)lst->data;

			switch ( data->type )
			{
			case DLG_CHECK_BOOL:
				gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( data->object ), *(bool*)data->buffer );
				break;
			case DLG_RADIO_INT:
			{
				GSList *radio = gtk_radio_button_group( GTK_RADIO_BUTTON( data->object ) );
				gpointer btn =  g_slist_nth_data( radio, g_slist_length( radio ) - ( *(int*)data->buffer ) - 1 );
				gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( btn ), TRUE );
			} break;
			case DLG_ENTRY_TEXT:
			{
				Str* str;
				str = (Str*)data->buffer;
				const char *txt = str->GetBuffer();
				gtk_entry_set_text( GTK_ENTRY( data->object ), txt );
			} break;
			case DLG_ENTRY_FLOAT:
				sprintf( buf, "%g", ( *(float*)data->buffer ) );
				gtk_entry_set_text( GTK_ENTRY( data->object ), buf );
				break;
			case DLG_ENTRY_INT:
				sprintf( buf, "%d", ( *(int*)data->buffer ) );
				gtk_entry_set_text( GTK_ENTRY( data->object ), buf );
				break;
			case DLG_SPIN_FLOAT:
				gtk_spin_button_set_value( GTK_SPIN_BUTTON( data->object ), ( *(float*)data->buffer ) );
				break;
			case DLG_SPIN_INT:
				gtk_spin_button_set_value( GTK_SPIN_BUTTON( data->object ), ( *(int*)data->buffer ) );
				break;
			case DLG_ADJ_INT:
				gtk_adjustment_set_value( GTK_ADJUSTMENT( data->object ), ( *(int*)data->buffer ) );
				break;
			case DLG_COMBO_INT: {
				GList *lst = GTK_LIST( GTK_COMBO( data->object )->list )->children;
				char *entry = NULL;

				if ( *(int*)data->buffer != -1 ) {
					lst = g_list_nth( lst, *(int*)data->buffer );
					if ( lst != NULL ) {
						gtk_label_get( GTK_LABEL( GTK_BIN( lst->data )->child ), &entry );
					}
				}
				if ( entry ) {
					gtk_entry_set_text( GTK_ENTRY( GTK_COMBO( data->object )->entry ), entry );
				}
				else{
					gtk_entry_set_text( GTK_ENTRY( GTK_COMBO( data->object )->entry ), "" );
				}
			}
			break;
			case DLG_COMBO_BOX_INT: {
				gtk_combo_box_set_active( GTK_COMBO_BOX( data->object ), *(int*)data->buffer );
			}
			break;
			}
		}
	}
}
示例#24
0
//callback that handles changing an enumerated control
void change_combo_box(GtkWidget *combo_box, Element *elem){
	int state = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_box));
	elem->set((int)state);
}
示例#25
0
文件: vikgoto.c 项目: idaohang/viking
static gchar *a_prompt_for_goto_string(VikWindow *vw)
{
  GtkWidget *dialog = NULL;

  dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
  gtk_window_set_title(GTK_WINDOW(dialog), _("goto"));

  GtkWidget *tool_label = gtk_label_new(_("goto provider:"));
  GtkWidget *tool_list = vik_combo_box_text_new ();
  GList *current = g_list_first (goto_tools_list);
  while (current != NULL)
  {
    char *label = NULL;
    VikGotoTool *tool = current->data;
    label = vik_goto_tool_get_label (tool);
    vik_combo_box_text_append ( tool_list, label );
    current = g_list_next (current);
  }

  get_provider ();
  gtk_combo_box_set_active ( GTK_COMBO_BOX( tool_list ), last_goto_tool );

  GtkWidget *goto_label = gtk_label_new(_("Enter address or place name:"));
  GtkWidget *goto_entry = gtk_entry_new();
  if (last_goto_str)
    gtk_entry_set_text(GTK_ENTRY(goto_entry), last_goto_str);

  // 'ok' when press return in the entry
  g_signal_connect_swapped (goto_entry, "activate", G_CALLBACK(a_dialog_response_accept), dialog);

  gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tool_label, FALSE, FALSE, 5 );
  gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tool_list, FALSE, FALSE, 5 );
  gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), goto_label, FALSE, FALSE, 5 );
  gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), goto_entry, FALSE, FALSE, 5 );
  gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
  gtk_widget_show_all(dialog);

  // Ensure the text field has focus so we can start typing straight away
  gtk_widget_grab_focus ( goto_entry );

  if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
    gtk_widget_destroy(dialog);
    return NULL;
  }
  
  // TODO check if list is empty
  last_goto_tool = gtk_combo_box_get_active ( GTK_COMBO_BOX(tool_list) );
  gchar *provider = vik_goto_tool_get_label ( g_list_nth_data (goto_tools_list, last_goto_tool) );
  a_settings_set_string ( VIK_SETTINGS_GOTO_PROVIDER, provider );

  gchar *goto_str = g_strdup ( gtk_entry_get_text ( GTK_ENTRY(goto_entry) ) );

  gtk_widget_destroy(dialog);

  if (goto_str[0] != '\0') {
    if (last_goto_str)
      g_free(last_goto_str);
    last_goto_str = g_strdup(goto_str);
  }

  return(goto_str);   /* goto_str needs to be freed by caller */
}
示例#26
0
static gboolean cb_ok( GtkWidget *widget,
                                   GdkEvent  *event,
                                   gpointer   data )
{
  int idx = gtk_combo_box_get_active (GTK_COMBO_BOX (opt_kbm_opts));

  int idx_selkeys = gtk_combo_box_get_active (GTK_COMBO_BOX (opt_selkeys));

  pho_candicate_col_N = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_pho_candicate_col_N));

  if (pho_candicate_col_N > strlen(selkeys[idx_selkeys].kstr))
    pho_candicate_col_N = strlen(selkeys[idx_selkeys].kstr);

  dbg("pho_candicate_col_N %d\n", pho_candicate_col_N);

  char tt[128];
  sprintf(tt, "%s %s %d %d", kbm_sel[idx].kbm, selkeys[idx_selkeys].kstr, pho_candicate_col_N, selkeys[idx_selkeys].RL);

  char phokbm_name[128];
  get_hime_conf_fstr(PHONETIC_KEYBOARD, phokbm_name, "");

  if (strcmp(phokbm_name, tt)) {
    save_hime_conf_str(PHONETIC_KEYBOARD_BAK, phokbm_name);
  }
  save_hime_conf_str(PHONETIC_KEYBOARD, tt);

  save_tsin_eng_pho_key();

  save_hime_conf_int(TSIN_SPACE_OPT,
                     tsin_space_options[new_select_idx_tsin_space_opt].key);

  save_hime_conf_int(TSIN_PHRASE_PRE_SELECT,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select)));

  save_hime_conf_int(PHONETIC_CHAR_DYNAMIC_SEQUENCE,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence)));
  save_hime_conf_int(PHO_HIDE_ROW2,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_pho_hide_row2)));

  save_hime_conf_int(PHO_IN_ROW1,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_pho_in_row1)));

  save_hime_conf_int(PHONETIC_HUGE_TAB,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab)));

  save_hime_conf_int(TSIN_TONE_CHAR_INPUT,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input)));

  save_hime_conf_int(TSIN_USE_PHO_NEAR,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near)));


  save_hime_conf_int(TSIN_TAB_PHRASE_END,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end)));


  save_hime_conf_int(TSIN_TAIL_SELECT_KEY,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key)));

  save_hime_conf_int(TSIN_BUFFER_EDITING_MODE,
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode)));

  tsin_buffer_size = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_tsin_buffer_size));
  save_hime_conf_int(TSIN_BUFFER_SIZE, tsin_buffer_size);

  gchar *cstr;
#if 0
  cstr = gtk_color_selection_palette_to_string(&tsin_phrase_line_gcolor, 1);
  dbg("color %s\n", cstr);
  save_hime_conf_str(TSIN_PHRASE_LINE_COLOR, cstr);
  g_free(cstr);
#endif


  cstr = gtk_color_selection_palette_to_string(&tsin_cursor_gcolor, 1);
  dbg("color %s\n", cstr);
  save_hime_conf_str(TSIN_CURSOR_COLOR, cstr);
  g_free(cstr);

  /* caleb- does found where "reload kbm" is used.
   * caleb- think the send_hime_message() here does nothing.
   */
  send_hime_message(GDK_DISPLAY(), "reload kbm");

  gtk_widget_destroy(hime_kbm_window); hime_kbm_window = NULL;

  return TRUE;
}
示例#27
0
//
// Do all pre copy checks and start the copy thread
//
bool handle_copy (void)
{
GError		*error = NULL;
std::string	InputPathLabelString,
		OutputPathLabelString;

	CopyThreadAbort = false;

	gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pbar), 0);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(InputFileRadioButton))){
		data.SourceMediaType	= isFile;
		data.SourceDir		= gtk_entry_get_text (GTK_ENTRY (InputFileEntry));

		if (data.SourceDir.size() == 0){
			alert ("Error: incorrect input filename");
			return FALSE;
		}

	}else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(InputDriveRadioButton))){
		data.SourceMediaType	= isDrive;
        data.SourceDir		      = DriveList->GetDrivePath (gtk_combo_box_get_active (GTK_COMBO_BOX(InputCobobox)));
	}else{
		alert ("Error: unknown media type");
		return FALSE;
	}


	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(OutputFileRadioButton))){
		data.DestinationMediaType	= isFile;
		data.Destination		= gtk_entry_get_text (GTK_ENTRY (OutputFileEntry));

		if (data.Destination.size() == 0){
			alert ("Error: incorrect output filename");
			return FALSE;
		}

		// Check if a file is overwritten and ask if this is allowed if needed :)
		if( g_file_test(data.Destination.c_str(), G_FILE_TEST_EXISTS) ){
			GtkWidget *msgdlg	= NULL;
			msgdlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_YES_NO, "File already exists, do you want to overwrite?");
			if (gtk_dialog_run(GTK_DIALOG(msgdlg)) == GTK_RESPONSE_NO){
				gtk_widget_destroy(msgdlg);
				return FALSE;
			}
			gtk_widget_destroy(msgdlg);
		}

		// Check if the output file is not a directory
		if (g_file_test(data.Destination.c_str(), G_FILE_TEST_IS_DIR) ){
			alert ("Error: output file is a directory");
			return FALSE;
		}

	}else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(OutputDriveRadioButton))){
		data.DestinationMediaType	= isDrive;
		data.Destination	         = DriveList->GetDrivePath (gtk_combo_box_get_active (GTK_COMBO_BOX(OutputCobobox)));

        // Ask if the data on this drive may be overwritten
        GtkWidget *msgdlg	= NULL;
		msgdlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_YES_NO, "All data on the destination drive will be lost, do you want to continue?");
		if (gtk_dialog_run(GTK_DIALOG(msgdlg)) == GTK_RESPONSE_NO){
			gtk_widget_destroy(msgdlg);
			return FALSE;
		}
		gtk_widget_destroy(msgdlg);
	}else{
		alert ("Error: unknown media type");
		return FALSE;
	}

	// Setup the input and output path labels
	InputPathLabelString	= "Input:\t\t\t";
	InputPathLabelString	+= data.SourceDir;
	OutputPathLabelString	= "Output:\t\t\t";
	OutputPathLabelString	+= data.Destination;
	gtk_label_set_label((GtkLabel *)StatusInputPathLabel, InputPathLabelString.c_str());
	gtk_label_set_label((GtkLabel *)StatusOutputPathLabel, OutputPathLabelString.c_str());

	// Show the Status frame
	gtk_widget_show (StatusFrame);
	gtk_widget_hide (InputFrame);
	gtk_widget_hide (ProcessingFrame);
	gtk_widget_hide (OutputFrame);
	gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pbar), 0);


	// Setup the args for the copy thread
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(DeCompressSourceRadioButton)))
		data.InflateSource	= true;
	else
		data.InflateSource	= false;

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(CompressImageRadioButton))){
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(GzipFastRadioButton)))
			data.CompressionMethod	= Z_BEST_SPEED;
		else
			data.CompressionMethod	= Z_BEST_COMPRESSION;
	}else{
		data.CompressionMethod		= 0;
	}

	// Setup the args for the progress status display
	CopyThreadDone         = false;
	Info.BytesRead         = 0;
	Info.BytesWritten      = 0;
	Info.WriteThreadError  = ERROR_WRITETHREAD_NONE;
	Info.ReadThreadError   = ERROR_READTHREAD_NONE;

	gtk_widget_set_sensitive (OkeButton, false);

	// Start the copy thread
	if( (CopyThread = g_thread_create((GThreadFunc)CopyData, (void *)&data, TRUE, &error)) == NULL)
	{
		printf("Thread create failed: %s!!\n", error->message );
		g_error_free ( error ) ;
	}

    return handle_update_progress ();
}
示例#28
0
G_MODULE_EXPORT void on_new_req_commit_clicked (GtkButton *widg,
			       gpointer user_data) 
{
	TlsCreationData *csr_creation_data = NULL;

	GtkWidget *widget = NULL;
	GtkWindow *window = NULL;
	gint active = -1;
	gchar *text = NULL;
	GtkTreeModel *tree_model = NULL;
	GtkTreeIter tree_iter;
	
	csr_creation_data = g_new0 (TlsCreationData, 1);

        if (new_req_ca_id_valid)
                csr_creation_data->parent_ca_id_str = g_strdup_printf ("'%"G_GUINT64_FORMAT"'", new_req_ca_id);

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "country_combobox1"));
	active = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));

	if (active < 0) {
			csr_creation_data->country = NULL;
	} else {
		tree_model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
		gtk_combo_box_get_active_iter (GTK_COMBO_BOX(widget), &tree_iter);
		gtk_tree_model_get (tree_model, &tree_iter, 1, &text, -1);

		csr_creation_data->country = g_strdup (text);
		
	}
		
	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "st_entry1"));
	text = (gchar *) gtk_entry_get_text (GTK_ENTRY(widget));
	if (strlen (text))
		csr_creation_data->state = g_strdup (text);
	else
		csr_creation_data->state = NULL;

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "city_entry1"));
	text = (gchar *) gtk_entry_get_text (GTK_ENTRY(widget));
	if (strlen (text))
		csr_creation_data->city = g_strdup (text);
	else
		csr_creation_data->city = NULL;

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "o_entry1"));
	text = (gchar *) gtk_entry_get_text (GTK_ENTRY(widget));
	if (strlen (text))
		csr_creation_data->org = g_strdup (text);
	else
		csr_creation_data->org = NULL;

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "ou_entry1"));
	text = (gchar *) gtk_entry_get_text (GTK_ENTRY(widget));
	if (strlen (text))
		csr_creation_data->ou = g_strdup (text);
	else
		csr_creation_data->ou = NULL;

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "cn_entry1"));
	text = (gchar *) gtk_entry_get_text (GTK_ENTRY(widget));
	if (strlen (text))
		csr_creation_data->cn = g_strdup (text);
	else
		csr_creation_data->cn = NULL;

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "dsa_radiobutton1"));
	active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget));
	csr_creation_data->key_type = active;

	widget = GTK_WIDGET(gtk_builder_get_object (new_req_window_gtkb, "keylength_spinbutton1"));
	active = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(widget));
	csr_creation_data->key_bitlength = active;

	if (ca_file_is_password_protected()) {
		csr_creation_data->password = pkey_manage_ask_password();

                if (! csr_creation_data->password) {
                        /* The user hasn't provided a valid password */
                        return;
                }
        }

	window = GTK_WINDOW(gtk_builder_get_object (new_req_window_gtkb, "new_req_window"));
	gtk_object_destroy(GTK_OBJECT(window));

	creation_process_window_csr_display (csr_creation_data);	

}
示例#29
0
char *
gui_get_image_save_info (GtkWindow *toplevel, GSList *supported_formats,
			 GOImageFormat *ret_format, double *resolution)
{
	GOImageFormat format;
	GOImageFormatInfo const *format_info;
	GtkComboBox *format_combo = NULL;
	GtkFileChooser *fsel = gui_image_chooser_new (TRUE);
	GtkWidget *expander = NULL;
	GtkWidget *resolution_spin = NULL;
	GtkWidget *resolution_table;
	GladeXML *gui;
	SaveInfoState *state;
	const char *key = "gui_get_image_save_info";
	char *uri = NULL;

	state = g_object_get_data (G_OBJECT (toplevel), key);
	if (state == NULL) {
		state = g_new (SaveInfoState, 1);
		g_return_val_if_fail (state != NULL, NULL);
		state->uri = NULL;
		state->resolution = 150.0;
		state->is_expanded = FALSE;
		state->format = GO_IMAGE_FORMAT_SVG;
		g_object_set_data_full (G_OBJECT (toplevel), key,
					state, (GDestroyNotify) save_info_state_free);
	}

	g_object_set (G_OBJECT (fsel), "title", _("Save as"), NULL);

	gui = go_libglade_new ("go-image-save-dialog-extra.glade", 
			       "image_save_dialog_extra", 
			       GETTEXT_PACKAGE, NULL);
	if (gui != NULL) {
		GtkWidget *widget;

		/* Format selection UI */
		if (supported_formats != NULL && ret_format != NULL) {
			int i;
			GSList *l;
			format_combo = GTK_COMBO_BOX (glade_xml_get_widget (gui, "format_combo"));
			for (l = supported_formats, i = 0; l != NULL; l = l->next, i++) {
				format = GPOINTER_TO_UINT (l->data);
				format_info = go_image_get_format_info (format);
				gtk_combo_box_append_text (format_combo, _(format_info->desc)); 
				if (format == state->format) 
					gtk_combo_box_set_active (format_combo, i);
			}
			if (gtk_combo_box_get_active (format_combo) < 0)
				gtk_combo_box_set_active (format_combo, 0);
		} else {
			widget = glade_xml_get_widget (gui, "file_type_box");
			gtk_widget_hide (widget);
		}

		/* Export setting expander */
		expander = glade_xml_get_widget (gui, "export_expander");
		if (resolution != NULL) {
			gtk_expander_set_expanded (GTK_EXPANDER (expander), state->is_expanded);
			resolution_spin = glade_xml_get_widget (gui, "resolution_spin");
			gtk_spin_button_set_value (GTK_SPIN_BUTTON (resolution_spin), state->resolution);
		} else 
			gtk_widget_hide (expander);

		if (resolution != NULL && supported_formats != NULL && ret_format != NULL) {
			widget = glade_xml_get_widget (gui, "image_save_dialog_extra");
			gtk_file_chooser_set_extra_widget (fsel, widget);

			resolution_table = glade_xml_get_widget (gui, "resolution_table");
		
			cb_format_combo_changed (format_combo, resolution_table);	
			g_signal_connect (GTK_WIDGET (format_combo), "changed", 
					  G_CALLBACK (cb_format_combo_changed), resolution_table);
		}

		g_object_unref (G_OBJECT (gui));
	}

	if (state->uri != NULL) {
		gtk_file_chooser_set_uri (fsel, state->uri);
		gtk_file_chooser_unselect_all (fsel);
	}
	
	/* Show file selector */
 loop:
	if (!go_gtk_file_sel_dialog (toplevel, GTK_WIDGET (fsel)))
		goto out;
	uri = gtk_file_chooser_get_uri (fsel);
	if (format_combo) {
		char *new_uri = NULL;

		format = GPOINTER_TO_UINT (g_slist_nth_data 
			(supported_formats, 
			 gtk_combo_box_get_active (format_combo)));
		format_info = go_image_get_format_info (format);
		if (!go_url_check_extension (uri, format_info->ext, &new_uri) &&
		    !go_gtk_query_yes_no (GTK_WINDOW (fsel), TRUE,
		     _("The given file extension does not match the"
		       " chosen file type. Do you want to use this name"
		       " anyway?"))) {
			g_free (new_uri);
			g_free (uri);
			uri = NULL;
			goto out;
		} else {
			g_free (uri);
			uri = new_uri;
		}
		*ret_format = format;
	}
	if (!go_gtk_url_is_writeable (GTK_WINDOW (fsel), uri, TRUE)) {
		g_free (uri);
		uri = NULL;
		goto loop;
	}
 out:
	if (uri != NULL) {
		g_free (state->uri);
		state->uri = g_strdup (uri);
		state->format = *ret_format;
		if (resolution != NULL) {
			state->is_expanded = gtk_expander_get_expanded (GTK_EXPANDER (expander));
			*resolution =  gtk_spin_button_get_value (GTK_SPIN_BUTTON (resolution_spin));
			state->resolution = *resolution;
		}
	}

	gtk_widget_destroy (GTK_WIDGET (fsel));

	return uri;
}
示例#30
0
void gui_dialog_response(GtkDialog * dialog_widget, int resid, gpointer user_data)
{
    GGaduSignal *signal = (GGaduSignal *) user_data;
    GGaduDialog *dialog = signal ? signal->data : NULL;

    if (dialog)
    {
        GSList *kvlist = ggadu_dialog_get_entries(dialog);

        while (kvlist)
        {
            GGaduKeyValue *kv = (GGaduKeyValue *) kvlist->data;

            switch (kv->type)
            {
            case VAR_STR:
            {
                gchar *tmp = (gchar *) g_strdup(gtk_entry_get_text(GTK_ENTRY(kv->user_data)));

                if (strlen(tmp) > 0)
                {
                    g_free(kv->value);
                    kv->value = (gpointer) tmp;
                }
                else
                {
                    kv->value = NULL;
                    g_free(tmp);
                }
            }
            break;
            case VAR_INT:
            case VAR_INT_WITH_NEGATIVE:
                kv->value = (gpointer) gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(kv->user_data));
                break;
            case VAR_BOOL:
                kv->value = (gpointer) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(kv->user_data));
                break;
            case VAR_FILE_CHOOSER:
            case VAR_FONT_CHOOSER:
            case VAR_COLOUR_CHOOSER:
            {
                gchar *tmp = NULL;
                GtkWidget *hbox = (GtkWidget *) kv->user_data;
                GtkWidget *entry = (GtkWidget *) g_object_get_data(G_OBJECT(hbox), "txt_entry");

                tmp = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
                if (strlen(tmp) > 0)
                {
                    kv->value = (gpointer) tmp;
                }
                else
                {
                    kv->value = NULL;
                    g_free(tmp);
                }
            }
            break;
            case VAR_IMG:
                kv->value = NULL;
                break;
            case VAR_LIST:
            {
                GSList *ltmp = NULL;
                gchar *val = NULL;
                GSList *old_val = kv->value;
                /* KURWA co z tym zwalnianiem, bo do chuja nie wiem czy to zwolnione czy
                   nie zwolnione ma byc do chuja NOOOOOOOOOOOO
                   i czemu KURWA XOSD SIE WYPIERDALA
                   dobra, dziala, ale tu JEST SIECZKA JAKAS */

                // Nie wiem o co biega ale zwolnienie kv->value powoduje ze val = NULL
                // ale jaki to ma związek jedno do drugiego to sam Bóg raczy wiedzieć.
                //g_slist_free(kv->value);
                //kv->value = NULL;

                ltmp = g_object_get_data(G_OBJECT(kv->user_data), "options-list");
                val = g_slist_nth_data(ltmp, gtk_combo_box_get_active(GTK_COMBO_BOX(kv->user_data)));
                kv->value = g_slist_append(NULL, g_strdup(val));

                g_slist_free(old_val);

            }
            break;
            default:
                break;
            }
            kvlist = kvlist->next;
        }

        switch (resid)
        {
        case GTK_RESPONSE_OK:
            dialog->response = GGADU_OK;
            break;
        case GTK_RESPONSE_CANCEL:
            dialog->response = GGADU_CANCEL;
            break;
        case GTK_RESPONSE_YES:
            dialog->response = GGADU_YES;
            break;
        case GTK_RESPONSE_NO:
            dialog->response = GGADU_NO;
            break;
        default:
            dialog->response = GGADU_NONE;
            break;
        }

        signal_emit("main-gui", dialog->callback_signal, dialog, signal->source_plugin_name);
    }

    gtk_widget_destroy(GTK_WIDGET(dialog_widget));

    GGaduSignal_free(signal);

}