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(); }
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()
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(); }
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))); }
//********************************************************************************* static void combo_net_changed (GtkComboBox *box, gpointer user_data) { PART = gtk_combo_box_get_active (box); }
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); }
/* 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]; }
static gint SetGameType (GtkWidget *widget, gpointer *data) { NewGameType = gtk_combo_box_get_active (GTK_COMBO_BOX (widget)); return FALSE; }
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)); }
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; }
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)); }
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))); }
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(); }
static void setOption(GtkWidget *widget, gpointer data) { currentOption = gtk_combo_box_get_active(GTK_COMBO_BOX(optionBox)); }
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); }
/* * 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*/ }
static void pgd_render_rotate_selector_changed (GtkComboBox *combobox, PgdRenderDemo *demo) { demo->rotate = gtk_combo_box_get_active (combobox) * 90; }
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; }
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); }
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; } }
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; } } } }
//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); }
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 */ }
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; }
// // 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 (); }
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); }
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; }
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); }