GtkWidget* gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor ) { guint row; guint col; const char * str; GtkWidget * w; GtkWidget * d; GtkWidget * t; GtkWidget * l; GtkWidget * grab; GtkWidget * source_chooser; struct OpenData * data; bool flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent, GTK_DIALOG_DESTROY_WITH_PARENT, NULL ); gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL ); grab = gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT ); gtk_dialog_set_default_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT ); gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1 ); if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) ) g_assert_not_reached( ); g_assert( str ); data = g_new0( struct OpenData, 1 ); data->core = core; data->ctor = ctor; data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) ); data->downloadDir = g_strdup( str ); data->file_list = gtr_file_list_new( core, 0 ); str = _( "Mo_ve .torrent file to the trash" ); data->trash_check = gtk_check_button_new_with_mnemonic( str ); str = _( "_Start when added" ); data->run_check = gtk_check_button_new_with_mnemonic( str ); w = data->priority_combo = gtr_priority_combo_new( ); gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL ); g_signal_connect( G_OBJECT( d ), "response", G_CALLBACK( addResponseCB ), data ); t = gtk_table_new( 6, 2, FALSE ); gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG ); gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD ); gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG ); row = col = 0; l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Source File" ), GTK_FILE_CHOOSER_ACTION_OPEN ); source_chooser = w; gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); addTorrentFilters( GTK_FILE_CHOOSER( w ) ); g_signal_connect( w, "selection-changed", G_CALLBACK( sourceChanged ), data ); ++row; col = 0; l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Destination Folder" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ); if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), data->downloadDir ) ) g_warning( "couldn't select '%s'", data->downloadDir ); list = get_recent_destinations( ); for( walk = list; walk; walk = walk->next ) gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL ); g_slist_free( list ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); g_signal_connect( w, "selection-changed", G_CALLBACK( downloadDirChanged ), data ); ++row; col = 0; w = data->file_list; gtk_widget_set_size_request ( w, 466u, 300u ); gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 ); ++row; col = 0; w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) ); gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); ++col; gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo ); ++row; col = 0; w = data->run_check; if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); ++row; col = 0; w = data->trash_check; if( tr_ctorGetDeleteSource( ctor, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); /* trigger sourceChanged, either directly or indirectly, * so that it creates the tor/gtor objects */ w = source_chooser; if( data->filename ) gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename ); else sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data ); gtr_dialog_set_content( GTK_DIALOG( d ), t ); gtk_widget_grab_focus( grab ); return d; }
void CExpressDlg::Execute() { int res, id; char msg[256], buf[256]; GtkTreeModel *pList = g_Project->FileList(); GtkTreeIter iter, iter2; m_Updating = true; // Default state GtkTreeSelection *pSel = g_MainWnd->GetSelection(); gtk_widget_set_sensitive(m_SelBtn, gtk_tree_selection_count_selected_rows(pSel)>0); m_Selected = gtk_tree_selection_count_selected_rows(pSel)>1; if (m_Selected) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_SelBtn), true); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_AllBtn), true); // Restore last settings if (m_ConvertBtn) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_ConvertBtn), g_Project->GetBool("ExpressReduction", "Convert", true)); CmpackChannel channel = (CmpackChannel)g_Project->GetInt("Convert", "ColorChannel", CMPACK_CHANNEL_DEFAULT); SelectChannel(channel); } if (m_TimeCorrBtn) { m_TimeCorr = g_Project->GetDbl("TimeCorr", "Seconds", 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_TimeCorrBtn), g_Project->GetBool("ExpressReduction", "TimeCorr", false)); UpdateTimeCorrection(); } if (m_BiasCorrBtn && m_BiasFrameEdit) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_BiasCorrBtn), g_Project->GetBool("ExpressReduction", "BiasCorr", false)); char *bias = g_Project->GetStr("BiasCorr", "File", NULL); if (bias) gtk_entry_set_text(GTK_ENTRY(m_BiasFrameEdit), bias); else gtk_entry_set_text(GTK_ENTRY(m_BiasFrameEdit), ""); g_free(bias); } if (m_DarkCorrBtn && m_DarkFrameEdit) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_DarkCorrBtn), g_Project->GetBool("ExpressReduction", "DarkCorr", false)); char *dark = g_Project->GetStr("DarkCorr", "File", NULL); if (dark) gtk_entry_set_text(GTK_ENTRY(m_DarkFrameEdit), dark); else gtk_entry_set_text(GTK_ENTRY(m_DarkFrameEdit), ""); g_free(dark); } if (m_FlatCorrBtn && m_FlatFrameEdit) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_FlatCorrBtn), g_Project->GetBool("ExpressReduction", "FlatCorr", false)); char *flat = g_Project->GetStr("FlatCorr", "File", NULL); if (flat) gtk_entry_set_text(GTK_ENTRY(m_FlatFrameEdit), flat); else gtk_entry_set_text(GTK_ENTRY(m_FlatFrameEdit), ""); g_free(flat); } if (m_PhotometryBtn) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_PhotometryBtn), g_Project->GetBool("ExpressReduction", "Photometry", false)); } if (m_MatchingBtn && m_RefBtn && m_CatBtn) { m_Matching = g_Project->GetBool("ExpressReduction", "Matching", false); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_MatchingBtn), m_Matching && !m_Selected); if (g_Project->GetInt("MatchingDlg", "Select", 0)==0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_RefBtn), true); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_CatBtn), true); } if (m_RefFrameCombo) { gtk_combo_box_set_model(GTK_COMBO_BOX(m_RefFrameCombo), NULL); gtk_list_store_clear(m_Frames); gboolean ok = gtk_tree_model_get_iter_first(pList, &iter); while (ok) { gtk_tree_model_get(GTK_TREE_MODEL(pList), &iter, FRAME_ID, &id, -1); gtk_list_store_append(m_Frames, &iter2); sprintf(buf, "Frame #%d", id); gtk_list_store_set(m_Frames, &iter2, 0, id, 1, buf, -1); ok = gtk_tree_model_iter_next(pList, &iter); } gtk_combo_box_set_model(GTK_COMBO_BOX(m_RefFrameCombo), GTK_TREE_MODEL(m_Frames)); SelectRefFrame(g_Project->GetInt("MatchingDlg", "Frame", 0)); if (gtk_combo_box_get_active(GTK_COMBO_BOX(m_RefFrameCombo))<0) { GtkTreeIter iter3; if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(m_Frames), &iter3)) gtk_combo_box_set_active_iter(GTK_COMBO_BOX(m_RefFrameCombo), &iter3); } } if (m_CatFrameEdit) { char *path = g_Project->GetStr("MatchingDlg", "File", NULL); if (path) gtk_entry_set_text(GTK_ENTRY(m_CatFrameEdit), path); else gtk_entry_set_text(GTK_ENTRY(m_CatFrameEdit), ""); g_free(path); } m_Updating = false; UpdateControls(); if (gtk_dialog_run(GTK_DIALOG(m_pDlg))!=GTK_RESPONSE_ACCEPT) return; gtk_widget_hide(m_pDlg); // Save parameters memset(&m_Params, 0, sizeof(tProcParams)); if (m_ConvertBtn) { m_Params.Convert = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_ConvertBtn))!=0; g_Project->SetBool("ExpressReduction", "Convert", m_Params.Convert); g_Project->SetInt("Convert", "ColorChannel", SelectedChannel()); } if (m_TimeCorrBtn) { m_Params.TimeCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_TimeCorrBtn))!=0; g_Project->SetBool("ExpressReduction", "TimeCorr", m_Params.TimeCorr); m_Params.Seconds = m_TimeCorr; g_Project->SetDbl("TimeCorr", "Seconds", m_Params.Seconds); } if (m_BiasCorrBtn && m_BiasFrameEdit) { m_Params.BiasCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_BiasCorrBtn))!=0; g_Project->SetBool("ExpressReduction", "BiasCorr", m_Params.BiasCorr); m_Params.BiasFrame = gtk_entry_get_text(GTK_ENTRY(m_BiasFrameEdit)); g_Project->SetStr("BiasCorr", "File", m_Params.BiasFrame); CConfig::SetStr("BiasCorr", "File", m_Params.BiasFrame); } if (m_DarkCorrBtn && m_DarkFrameEdit) { m_Params.DarkCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_DarkCorrBtn))!=0; g_Project->SetBool("ExpressReduction", "DarkCorr", m_Params.DarkCorr); m_Params.DarkFrame = gtk_entry_get_text(GTK_ENTRY(m_DarkFrameEdit)); g_Project->SetStr("DarkCorr", "File", m_Params.DarkFrame); CConfig::SetStr("DarkCorr", "File", m_Params.DarkFrame); } if (m_FlatCorrBtn && m_FlatFrameEdit) { m_Params.FlatCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_FlatCorrBtn))!=0; g_Project->SetBool("ExpressReduction", "FlatCorr", m_Params.FlatCorr); m_Params.FlatFrame = gtk_entry_get_text(GTK_ENTRY(m_FlatFrameEdit)); g_Project->SetStr("FlatCorr", "File", m_Params.FlatFrame); CConfig::SetStr("FlatCorr", "File", m_Params.FlatFrame); } if (m_PhotometryBtn) { m_Params.Photometry = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_PhotometryBtn))!=0; g_Project->SetBool("ExpressReduction", "Photometry", m_Params.Photometry); } if (m_MatchingBtn && m_RefBtn) { m_Params.Matching = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_MatchingBtn))!=0; g_Project->SetBool("ExpressReduction", "Matching", m_Matching); m_Params.UseRef = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_RefBtn))!=0; g_Project->SetInt("MatchingDlg", "Select", (m_Params.UseRef ? 0 : 1)); } if (m_RefFrameCombo) { m_Params.RefFrame = SelectedRefFrame(); g_Project->SetInt("MatchingDlg", "Frame", m_Params.RefFrame); } if (m_CatFrameEdit) { m_Params.CatFile = gtk_entry_get_text(GTK_ENTRY(m_CatFrameEdit)); g_Project->SetStr("MatchingDlg", "File", m_Params.CatFile); CConfig::SetStr("MatchingDlg", "File", m_Params.CatFile); } // Make list of unprocessed frames if (!m_Selected) { // All files GtkTreeModel *pList = g_Project->FileList(); if (gtk_tree_model_iter_n_children(pList, NULL)>0) gtk_tree_model_foreach(pList, foreach_all_files, &m_Params.FileList); else ShowError(m_pParent, "There are no files in the project."); } else { // Selected files GtkTreeSelection *pSel = g_MainWnd->GetSelection(); if (gtk_tree_selection_count_selected_rows(pSel)>0) gtk_tree_selection_selected_foreach(pSel, foreach_sel_files, &m_Params.FileList); else ShowError(m_pParent, "There are no selected files."); } if (m_Params.FileList) { if (m_Params.Convert && !m_Selected) { g_Project->ClearThumbnails(); g_Project->ClearTempFiles(); g_Project->ClearCorrections(); g_Project->ClearReference(); g_Project->ClearObject(); } if (m_Params.Matching) g_Project->ClearReference(); CProgressDlg pDlg(m_pParent, "Processing files"); pDlg.SetMinMax(0, g_list_length(m_Params.FileList)); res = pDlg.Execute(ExecuteProc, this); if (res!=0) { char *msg = cmpack_formaterror(res); ShowError(m_pParent, msg, true); cmpack_free(msg); } else if (m_Params.OutFiles==0) { ShowError(m_pParent, "No file was successfully processed.", true); } else if (m_Params.OutFiles!=m_Params.InFiles) { sprintf(msg, "%d file(s) were successfully processed, %d file(s) failed.", m_Params.OutFiles, m_Params.InFiles-m_Params.OutFiles); ShowWarning(m_pParent, msg, true); } else { sprintf(msg, "All %d file(s) were successfully processed.", m_Params.OutFiles); ShowInformation(m_pParent, msg, true); } g_list_foreach(m_Params.FileList, (GFunc)gtk_tree_row_reference_free, NULL); g_list_free(m_Params.FileList); } g_Project->Save(); }
CmpackChannel CExpressDlg::SelectedChannel(void) { if (m_ChannelCombo) return (CmpackChannel)SelectedItem(GTK_COMBO_BOX(m_ChannelCombo), CMPACK_CHANNEL_DEFAULT); return CMPACK_CHANNEL_DEFAULT; }
void on_dlg_response ( GtkDialog *dialog, gint response_id, gpointer user_data ) { FilePropertiesDialogData * data; PtkFileTask* task; gboolean mod_change; uid_t uid = -1; gid_t gid = -1; const char* owner_name; const char* group_name; int i; GList* l; GList* file_list; char* file_path; GtkWidget* ask_recursive; VFSFileInfo* file; GtkAllocation allocation; gtk_widget_get_allocation ( GTK_WIDGET( dialog ), &allocation ); int width = allocation.width; int height = allocation.height; if ( width && height ) { char* str = g_strdup_printf( "%d", width ); xset_set( "app_dlg", "s", str ); g_free( str ); str = g_strdup_printf( "%d", height ); xset_set( "app_dlg", "z", str ); g_free( str ); } data = ( FilePropertiesDialogData* ) g_object_get_data( G_OBJECT( dialog ), "DialogData" ); if ( data ) { if ( data->update_label_timer ) g_source_remove( data->update_label_timer ); data->cancel = TRUE; if ( data->calc_size_thread ) g_thread_join( data->calc_size_thread ); if ( response_id == GTK_RESPONSE_OK ) { // change file dates char* cmd = NULL; char* quoted_time; char* quoted_path; const char* new_mtime = gtk_entry_get_text( data->mtime ); if ( !( new_mtime && new_mtime[0] ) || !g_strcmp0( data->orig_mtime, new_mtime ) ) new_mtime = NULL; const char* new_atime = gtk_entry_get_text( data->atime ); if ( !( new_atime && new_atime[0] ) || !g_strcmp0( data->orig_atime, new_atime ) ) new_atime = NULL; if ( ( new_mtime || new_atime ) && data->file_list ) { GString* gstr = g_string_new( NULL ); for ( l = data->file_list; l; l = l->next ) { file_path = g_build_filename( data->dir_path, ((VFSFileInfo*)l->data)->name, NULL ); quoted_path = bash_quote( file_path ); g_string_append_printf( gstr, " %s", quoted_path ); g_free( file_path ); g_free( quoted_path ); } if ( new_mtime ) { quoted_time = bash_quote( new_mtime ); cmd = g_strdup_printf( "touch --no-dereference --no-create -m -d %s%s", quoted_time, gstr->str ); } if ( new_atime ) { quoted_time = bash_quote( new_atime ); quoted_path = cmd; // temp str cmd = g_strdup_printf( "%s%stouch --no-dereference --no-create -a -d %s%s", cmd ? cmd : "", cmd ? "\n" : "", quoted_time, gstr->str ); g_free( quoted_path ); } g_free( quoted_time ); g_string_free( gstr, TRUE ); if ( cmd ) { task = ptk_file_exec_new( _("Change File Date"), "/", GTK_WIDGET( dialog ), NULL ); task->task->exec_command = cmd; task->task->exec_sync = TRUE; task->task->exec_export = FALSE; task->task->exec_show_output = TRUE; task->task->exec_show_error = TRUE; ptk_file_task_run( task ); } } /* Set default action for mimetype */ GtkWidget* open_with; if( ( open_with = (GtkWidget*)g_object_get_data( G_OBJECT(dialog), "open_with" ) ) ) { GtkTreeModel* model = gtk_combo_box_get_model( GTK_COMBO_BOX(open_with) ); GtkTreeIter it; if( model && gtk_combo_box_get_active_iter( GTK_COMBO_BOX(open_with), &it ) ) { char* action; gtk_tree_model_get( model, &it, 2, &action, -1 ); if( action ) { file = ( VFSFileInfo* ) data->file_list->data; VFSMimeType* mime = vfs_file_info_get_mime_type( file ); vfs_mime_type_set_default_action( mime, action ); vfs_mime_type_unref( mime ); g_free( action ); } } } /* Check if we need chown */ owner_name = gtk_entry_get_text( data->owner ); if ( owner_name && *owner_name && (!data->owner_name || strcmp( owner_name, data->owner_name ) ) ) { uid = uid_from_name( owner_name ); if ( uid == -1 ) { ptk_show_error( GTK_WINDOW( dialog ), _("Error"), _( "Invalid User" ) ); return ; } } group_name = gtk_entry_get_text( data->group ); if ( group_name && *group_name && (!data->group_name || strcmp( group_name, data->group_name ) ) ) { gid = gid_from_name( group_name ); if ( gid == -1 ) { ptk_show_error( GTK_WINDOW( dialog ), _("Error"), _( "Invalid Group" ) ); return ; } } for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( gtk_toggle_button_get_inconsistent( data->chmod_btns[ i ] ) ) { data->chmod_states[ i ] = 2; /* Don't touch this bit */ } else if ( data->chmod_states[ i ] != gtk_toggle_button_get_active( data->chmod_btns[ i ] ) ) { mod_change = TRUE; data->chmod_states[ i ] = gtk_toggle_button_get_active( data->chmod_btns[ i ] ); } else /* Don't change this bit */ { data->chmod_states[ i ] = 2; } } if ( uid != -1 || gid != -1 || mod_change ) { file_list = NULL; for ( l = data->file_list; l; l = l->next ) { file = ( VFSFileInfo* ) l->data; file_path = g_build_filename( data->dir_path, vfs_file_info_get_name( file ), NULL ); file_list = g_list_prepend( file_list, file_path ); } task = ptk_file_task_new( VFS_FILE_TASK_CHMOD_CHOWN, file_list, NULL, GTK_WINDOW(gtk_widget_get_parent( GTK_WIDGET( dialog ) )), NULL ); //MOD ptk_file_task_set_recursive( task, gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->recurse ) ) ); /* for ( l = data->file_list; l; l = l->next ) { file = ( VFSFileInfo* ) l->data; if ( vfs_file_info_is_dir( file ) ) { ask_recursive = gtk_message_dialog_new( GTK_WINDOW( data->dlg ), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _( "Do you want to recursively apply these changes to all files and sub-folders?" ) ); ptk_file_task_set_recursive( task, ( GTK_RESPONSE_YES == gtk_dialog_run( GTK_DIALOG( ask_recursive ) ) ) ); gtk_widget_destroy( ask_recursive ); break; } } */ if ( mod_change ) { /* If the permissions of file has been changed by the user */ ptk_file_task_set_chmod( task, data->chmod_states ); } /* For chown */ ptk_file_task_set_chown( task, uid, gid ); ptk_file_task_run( task ); /* * This file list will be freed by file operation, so we don't * need to do this. Just set the pointer to NULL. */ data->file_list = NULL; } } g_free( data->owner_name ); g_free( data->group_name ); g_free( data->orig_mtime ); g_free( data->orig_atime ); /* *NOTE: File operation chmod/chown will free the list when it's done, *and we only need to free it when there is no file operation applyed. */ g_slice_free( FilePropertiesDialogData, data ); } gtk_widget_destroy( GTK_WIDGET( dialog ) ); }
/* * Update the channel offset of the given combobox according to the given frequency. */ void airpcap_update_channel_offset_combo(airpcap_if_info_t* if_info, guint chan_freq, GtkWidget *channel_offset_cb, gboolean set) { gint current_offset; gint new_offset; guint i; gint active_idx = 0; gint idx_count = -1; if (!if_info || airpcap_if_is_any(if_info) || if_info->pSupportedChannels == NULL || if_info->numSupportedChannels < 1) { gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb),FALSE); gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), -1); return; } new_offset = current_offset = if_info->channelInfo.ExtChannel; /* Clear out the list */ while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(channel_offset_cb)), NULL) > 0) { gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(channel_offset_cb), 0); } gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb), TRUE); for (i = 0; i < if_info->numSupportedChannels; i++) { if (if_info->pSupportedChannels[i].Frequency == chan_freq) { /* If we can't be low or high, nudge the offset to 0 */ if (current_offset == -1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) { new_offset = 0; } else if (current_offset == 1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)) { new_offset = 0; } if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(channel_offset_cb), "-1"); idx_count++; if (new_offset == -1) { active_idx = idx_count; } } gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(channel_offset_cb), "0"); idx_count++; if (new_offset == 0) { active_idx = idx_count; } if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)){ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(channel_offset_cb), "+1"); idx_count++; if (new_offset == 1) { active_idx = idx_count; } } break; } } gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), active_idx); if (set) { change_airpcap_settings = TRUE; if_info->channelInfo.ExtChannel = new_offset; if (!airpcap_update_frequency_and_offset(if_info)){ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Adapter failed to be set with the following settings: Frequency - %d Extension Channel - %d", if_info->channelInfo.Frequency, if_info->channelInfo.ExtChannel); } } if (idx_count < 1) { gtk_widget_set_sensitive(channel_offset_cb, FALSE); } }
bool XAP_UnixDialog_FileOpenSaveAs::_run_gtk_main(XAP_Frame * pFrame, GtkWidget * filetypes_pulldown) { /* Run the dialog in a loop to catch bad filenames. The location of this check being in this dialog loop could be considered temporary. Doing this matches the Windows common control behavior (where the dialog checks everything for the programmer), but lacks flexibility for different uses of this dialog (file export, print export, directory (not file) selection). This check might need to be moved into the ap code which calls this dialog, and certain interfaces exposed so that the dialog is displayed throughout the verification. For right now you can signal this check on and off with bCheckWritePermission. */ char * szDialogFilename = NULL; // this is the file name returned from the dialog char * szFinalPathname = NULL; // this is the file name after suffix addition, if any char * szFinalPathnameCopy = NULL; // one to mangle when looking for dirs, etc. char * pLastSlash; // if m_bSave is not set, we're looking to OPEN a file. // otherwise we are looking to SAVE a file. if (!m_bSave) { while (1) { gtk_main(); if (m_answer == a_CANCEL) // The easy way out return false; m_szFinalPathnameCandidate = gtk_file_chooser_get_uri(m_FC); UT_ASSERT(m_szFinalPathnameCandidate); return (m_answer == a_OK); } } else { while(1) { gtk_main(); if (m_answer == a_CANCEL) // The easy way out return false; // Give us a filename we can mangle szDialogFilename = gtk_file_chooser_get_uri(m_FC); if (!szDialogFilename) continue; // We append the suffix of the default type, so the user doesn't // have to. This is adapted from the Windows front-end code // (xap_Win32Dlg_FileOpenSaveAs.cpp), since it should act the same. // If, however, the user doesn't want suffixes, they don't have to have them. { //UT_uint32 end = g_strv_length(m_szSuffixes); UT_sint32 nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(filetypes_pulldown)); // set to first item, which should probably be auto detect // TODO : "probably" isn't very good. UT_uint32 nIndex = 0; // the index in the types table will match the index in the suffix // table. nFileType is the data we are searching for. if(m_nTypeList != NULL) { for (UT_uint32 i = 0; m_nTypeList[i]; i++) { if (m_nTypeList[i] == nFileType) { nIndex = i; break; } } } bool wantSuffix = true; XAP_Prefs *pPrefs= XAP_App::getApp()->getPrefs(); pPrefs->getPrefsValueBool(static_cast<const gchar *>(XAP_PREF_KEY_UseSuffix), &wantSuffix); UT_DEBUGMSG(("UseSuffix: %d\n", wantSuffix)); if (nFileType > 0 && getDialogId() != XAP_DIALOG_ID_FILE_SAVE_IMAGE) // 0 means autodetect { if (!UT_pathSuffix(szDialogFilename).empty()) { // warn if we have a suffix that doesn't match the selected file type IE_ExpSniffer* pSniffer = IE_Exp::snifferForFileType(m_nTypeList[nIndex]); if (pSniffer && !pSniffer->recognizeSuffix(UT_pathSuffix(szDialogFilename).c_str())) { UT_UTF8String msg; const XAP_StringSet * pSS = m_pApp->getStringSet(); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ExtensionDoesNotMatch, msg); if (pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_YN, XAP_Dialog_MessageBox::a_NO) != XAP_Dialog_MessageBox::a_YES) goto ContinueLoop; } szFinalPathname = g_strdup(szDialogFilename); } else if (wantSuffix) { // if the file doesn't have a suffix already, and the file type // is normal (special types are negative, like auto detect), // and the user wants extensions, slap a suffix on it. // add suffix based on selected file type UT_UTF8String suffix (IE_Exp::preferredSuffixForFileType(m_nTypeList[nIndex])); UT_uint32 length = strlen(szDialogFilename) + suffix.size() + 1; szFinalPathname = static_cast<char *>(UT_calloc(length,sizeof(char))); if (szFinalPathname) { char * p = szFinalPathname; strcpy(p,szDialogFilename); strcat(p,suffix.utf8_str()); } } else szFinalPathname = g_strdup(szDialogFilename); } else { // the file type is special (auto detect) // set to plain name, and let the auto detector in the // exporter figure it out szFinalPathname = g_strdup(szDialogFilename); } // g_free szDialogFilename since it's been put into szFinalPathname (with // or without changes) and it's invalid (missing an extension which // might have been appended) FREEP(szDialogFilename); } szFinalPathnameCopy = g_strdup(szFinalPathname); if (UT_go_file_exists(szFinalPathnameCopy)) { // we have an existing file, ask to overwrite if (_askOverwrite_YesNo(pFrame, szFinalPathname)) { m_szFinalPathnameCandidate = g_strdup(szFinalPathname); goto ReturnTrue; } goto ContinueLoop; } // We have a string that may contain a path, and may have a file // at the end. First, strip off a file (if it exists), and test // for a matching directory. We can then proceed with the file // if another stat of that dir passes. if (szFinalPathnameCopy && strlen(szFinalPathnameCopy)) pLastSlash = strrchr(szFinalPathnameCopy,'/'); else pLastSlash = NULL; if (!pLastSlash) { _notifyError_OKOnly(pFrame,XAP_STRING_ID_DLG_InvalidPathname); goto ContinueLoop; } m_szFinalPathnameCandidate = g_strdup(szFinalPathname); goto ReturnTrue; // complain about write permission on the directory. // lop off ugly trailing slash only if we don't have // the root dir ('/') for a path if (pLastSlash > szFinalPathnameCopy) *pLastSlash = 0; _notifyError_OKOnly(pFrame,XAP_STRING_ID_DLG_NoSaveFile_DirNotWriteable, szFinalPathname); ContinueLoop: FREEP(szFinalPathnameCopy); } } /* if m_bSave */ /*NOTREACHED*/ ReturnTrue: FREEP(szFinalPathnameCopy); FREEP(szFinalPathname); return true; }
static TrayData * create_tray_on_screen (GdkScreen *screen, gboolean force) { GtkWidget *window, *hbox, *vbox, *button, *combo, *label; TrayData *data; n_windows++; if (!force && na_tray_manager_check_running (screen)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Override tray manager?"); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "There is already a tray manager running on screen %d.", gdk_screen_get_number (screen)); gtk_window_set_screen (GTK_WINDOW (dialog), screen); g_signal_connect (dialog, "response", G_CALLBACK (warning_dialog_response_cb), screen); gtk_window_present (GTK_WINDOW (dialog)); g_object_weak_ref (G_OBJECT (dialog), (GWeakNotify) maybe_quit, NULL); return NULL; } data = g_new0 (TrayData, 1); data->screen = screen; data->screen_num = gdk_screen_get_number (screen); data->window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_weak_ref (G_OBJECT (window), (GWeakNotify) maybe_quit, NULL); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (window), vbox); button = gtk_button_new_with_mnemonic ("_Add another tray"); g_signal_connect (button, "clicked", G_CALLBACK (add_tray_cb), data); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("_Orientation:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Vertical"); g_signal_connect (combo, "changed", G_CALLBACK (orientation_changed_cb), data); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); label = gtk_label_new (NULL); data->count_label = GTK_LABEL (label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); data->tray = na_tray_new_for_screen (screen, GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (data->tray), TRUE, TRUE, 0); data->box = gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN (data->tray)))); g_signal_connect_after (data->box, "add", G_CALLBACK (tray_added_cb), data); g_signal_connect_after (data->box, "remove", G_CALLBACK (tray_removed_cb), data); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); gtk_window_set_screen (GTK_WINDOW (window), screen); gtk_window_set_default_size (GTK_WINDOW (window), -1, 200); /* gtk_window_set_resizable (GTK_WINDOW (window), FALSE); */ gtk_widget_show_all (window); update_child_count (data); return data; }
/** * Clicked on Preferences in the UI */ void show_preferences_dialog (void) { static GtkWidget *prefs_dialog = NULL; if (prefs_dialog) { gtk_window_present (GTK_WINDOW (prefs_dialog)); } else { static const gchar *path_key = SJ_SETTINGS_PATH_PATTERN; static const gchar *file_key = SJ_SETTINGS_FILE_PATTERN; prefs_dialog = GET_WIDGET ("prefs_dialog"); g_assert (prefs_dialog != NULL); g_object_add_weak_pointer (G_OBJECT (prefs_dialog), (gpointer)&prefs_dialog); gtk_window_set_transient_for (GTK_WINDOW (prefs_dialog), GTK_WINDOW (main_window)); cd_option = GET_WIDGET ("cd_option"); basepath_fcb = GET_WIDGET ("path_chooser"); path_option = GET_WIDGET ("path_option"); file_option = GET_WIDGET ("file_option"); profile_option = GET_WIDGET ("profile_option"); check_strip = GET_WIDGET ("check_strip"); check_eject = GET_WIDGET ("check_eject"); check_open = GET_WIDGET ("check_open"); path_example_label = GET_WIDGET ("path_example_label"); sj_add_default_dirs (GTK_FILE_CHOOSER (basepath_fcb)); populate_pattern_combo (GTK_COMBO_BOX (path_option), path_patterns); /* The gpointer cast is to prevent -Wdiscarded-quantifiers from producing a warning. This is safe as the string is treated as const gchar* in the callback. */ g_signal_connect (path_option, "changed", G_CALLBACK (prefs_pattern_option_changed), (gpointer) path_key); populate_pattern_combo (GTK_COMBO_BOX (file_option), (gpointer) file_patterns); /* The gpointer cast is to prevent -Wdiscarded-quantifiers from producing a warning. This is safe as the string is treated as const gchar* in the callback. */ g_signal_connect (file_option, "changed", G_CALLBACK (prefs_pattern_option_changed), (gpointer) file_key); populate_profile_combo (GTK_COMBO_BOX (profile_option)); g_signal_connect (profile_option, "changed", G_CALLBACK (prefs_profile_changed), NULL); g_signal_connect (cd_option, "drive-changed", G_CALLBACK (prefs_drive_changed), NULL); /* Connect to GSettings to update the UI */ g_settings_bind (sj_settings, SJ_SETTINGS_EJECT, G_OBJECT (check_eject), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (sj_settings, SJ_SETTINGS_OPEN, G_OBJECT (check_open), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (sj_settings, SJ_SETTINGS_STRIP, G_OBJECT (check_strip), "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (G_OBJECT (sj_settings), "changed::"SJ_SETTINGS_DEVICE, (GCallback)device_changed_cb, NULL); g_signal_connect (G_OBJECT (sj_settings), "changed::"SJ_SETTINGS_BASEURI, (GCallback)baseuri_changed_cb, NULL); g_signal_connect (G_OBJECT (sj_settings), "changed::"SJ_SETTINGS_AUDIO_PROFILE, (GCallback)settings_changed_cb, profile_option); g_signal_connect (G_OBJECT (sj_settings), "changed::"SJ_SETTINGS_PATH_PATTERN, (GCallback)settings_changed_cb, path_option); g_signal_connect (G_OBJECT (sj_settings), "changed::"SJ_SETTINGS_FILE_PATTERN, (GCallback)settings_changed_cb, file_option); g_signal_connect (G_OBJECT (sj_settings), "changed::"SJ_SETTINGS_STRIP, (GCallback)strip_changed_cb, NULL); g_signal_connect (sj_extractor, "notify::profile", pattern_label_update, NULL); baseuri_changed_cb (sj_settings, SJ_SETTINGS_BASEURI, NULL); settings_changed_cb (sj_settings, SJ_SETTINGS_AUDIO_PROFILE, profile_option); settings_changed_cb (sj_settings, SJ_SETTINGS_FILE_PATTERN, file_option); settings_changed_cb (sj_settings, SJ_SETTINGS_PATH_PATTERN, path_option); device_changed_cb (sj_settings, SJ_SETTINGS_DEVICE, NULL); gtk_widget_show_all (prefs_dialog); } }
static gboolean mud_connections_property_save(MudConnections *conn) { GConfClient *client; const gchar *name = gtk_entry_get_text(GTK_ENTRY(conn->priv->name_entry)); const gchar *host = gtk_entry_get_text(GTK_ENTRY(conn->priv->host_entry)); const gchar *character_name = gtk_entry_get_text(GTK_ENTRY(conn->priv->character_name_entry)); gchar *logon, *profile, *key, *buf, *char_name, *stripped_name, *strip_name_new; GtkTextIter start, end; GtkTextBuffer *buffer; GtkTreeIter iter; GSList *chars, *entry; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(conn->priv->logon_textview)); gtk_text_buffer_get_bounds(buffer, &start, &end); logon = gtk_text_iter_get_text(&start, &end); if(gtk_combo_box_get_active_iter( GTK_COMBO_BOX(conn->priv->profile_combo), &iter)) gtk_tree_model_get( GTK_TREE_MODEL(conn->priv->profile_model), &iter, 0, &profile, -1); else profile = g_strdup("Default"); if(strlen(name) == 0) { utils_error_message(conn->priv->properties_window, _("Error"), "%s", _("No mud name specified.")); if(logon) g_free(logon); if(profile) g_free(profile); return FALSE; } client = gconf_client_get_default(); /* If the user renames the mud we need to * transfer over the old character information * and do some cleanup */ if(conn->priv->original_name && strcmp(conn->priv->original_name, name) != 0) { stripped_name = gconf_escape_key(conn->priv->original_name, -1); strip_name_new = gconf_escape_key(name, -1); key = g_strdup_printf("/apps/gnome-mud/muds/%s/characters", stripped_name); chars = gconf_client_all_dirs(client, key, NULL); g_free(key); for(entry = chars; entry != NULL; entry = g_slist_next(entry)) { char_name = g_path_get_basename((gchar *)entry->data); key = g_strdup_printf( "/apps/gnome-mud/muds/%s/characters/%s/logon", stripped_name, char_name); buf = gconf_client_get_string(client, key, NULL); g_free(key); key = g_strdup_printf( "/apps/gnome-mud/muds/%s/characters/%s/logon", strip_name_new, char_name); gconf_client_set_string(client, key, buf, NULL); g_free(key); g_free(char_name); g_free(buf); } for(entry = chars; entry != NULL; entry = g_slist_next(entry)) if(entry->data) g_free(entry->data); g_slist_free(chars); key = g_strdup_printf( "/apps/gnome-mud/muds/%s", stripped_name); gconf_client_recursive_unset(client, key, 0, NULL); g_free(key); g_free(stripped_name); g_free(strip_name_new); } stripped_name = gconf_escape_key(name, -1); key = g_strdup_printf("/apps/gnome-mud/muds/%s/name", stripped_name); gconf_client_set_string(client, key, name, NULL); g_free(key); key = g_strdup_printf("/apps/gnome-mud/muds/%s/host", stripped_name); gconf_client_set_string(client, key, host, NULL); g_free(key); key = g_strdup_printf("/apps/gnome-mud/muds/%s/port", stripped_name); gconf_client_set_int(client, key, gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(conn->priv->port_entry)), NULL); g_free(key); key = g_strdup_printf("/apps/gnome-mud/muds/%s/icon", stripped_name); if(conn->priv->icon_current && strcmp(conn->priv->icon_current, "gnome-mud") != 0) gconf_client_set_string( client, key, conn->priv->icon_current, NULL); else gconf_client_set_string(client, key, "gnome-mud", NULL); g_free(key); key = g_strdup_printf("/apps/gnome-mud/muds/%s/profile", stripped_name); gconf_client_set_string(client, key, profile, NULL); g_free(key); if(conn->priv->original_char_name && strcmp(conn->priv->original_char_name, character_name) != 0) { strip_name_new = gconf_escape_key(conn->priv->original_char_name, -1); key = g_strdup_printf("/apps/gnome-mud/muds/%s/characters/%s", stripped_name, strip_name_new); gconf_client_recursive_unset(client, key, 0, NULL); g_free(key); g_free(strip_name_new); } strip_name_new = gconf_escape_key(character_name, -1); if(strlen(strip_name_new) > 0) { key = g_strdup_printf("/apps/gnome-mud/muds/%s/characters/%s/logon", stripped_name, strip_name_new); gconf_client_set_string(client, key, logon, NULL); g_free(key); key = g_strdup_printf("/apps/gnome-mud/muds/%s/characters/%s/name", stripped_name, strip_name_new); gconf_client_set_string(client, key, character_name, NULL); g_free(key); } g_object_unref(client); if(logon) g_free(logon); if(profile) g_free(profile); return TRUE; }
int main(int argc,char **argv) { GtkWidget *win; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *notebook; GtkWidget *page; GtkWidget *button; GtkWidget *api[4]; GtkWidget *box; GtkWidget *label; PREData data; char *name[]={"百度词典:","必应词典:","金山词霸:","有道词典:"}; char *dic[]={"百度词典","必应词典","金山词霸","有道词典"}; int i; /*设置默认UTF-8编码*/ setlocale(LC_ALL,""); #ifdef _WIN32 putenv("LANG=zh_CN.UTF-8"); #else setenv("LANG","zh_CN.UTF-8"); #endif /*先读取出配置*/ duoyi_read_config(&data.data); /*默认状态为未更改*/ data.changed=FALSE; gtk_init(&argc,&argv); win=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win),"配置"); gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER); gtk_window_set_icon_from_file(GTK_WINDOW(win), "img/64x64/preferences.png",NULL); gtk_window_set_resizable(GTK_WINDOW(win),FALSE); g_signal_connect(G_OBJECT(win),"delete-event", G_CALLBACK(pre_quit),&data); vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0); notebook=gtk_notebook_new(); gtk_container_add(GTK_CONTAINER(win),vbox); gtk_box_pack_start(GTK_BOX(vbox),notebook,FALSE,FALSE,5); /*添加常规页*/ page=gtk_box_new(GTK_ORIENTATION_VERTICAL,0); label=gtk_label_new("常规"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook),page,label); /*添加选择字体按钮*/ label=gtk_label_new("选择字体:"); hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_start(GTK_BOX(page),hbox,FALSE,FALSE,20); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,20); if(data.data.font) button=gtk_font_button_new_with_font(data.data.font); else button=gtk_font_button_new(); /*按钮使用字体显示文字*/ gtk_font_button_set_use_font(GTK_FONT_BUTTON(button),TRUE); gtk_font_button_set_title(GTK_FONT_BUTTON(button),"字体选择"); gtk_box_pack_start(GTK_BOX(hbox),button,TRUE,TRUE,100); g_signal_connect(G_OBJECT(button),"font-set", G_CALLBACK(pre_set_font),&data); /*添加默认词典选择*/ hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_start(GTK_BOX(page),hbox,FALSE,FALSE,20); label=gtk_label_new("默认词典:"); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,20); box=gtk_combo_box_text_new(); for(i=0;i != 4;++i) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(box),dic[i]); gtk_combo_box_set_active(GTK_COMBO_BOX(box),data.data.dic); g_signal_connect(G_OBJECT(box),"changed", G_CALLBACK(pre_set_default_dic),&data); //gtk_combo_box_set_active(GTK_COMBO_BOX(box),data.data.dic); gtk_box_pack_start(GTK_BOX(hbox),box,TRUE,TRUE,100); /*添加API页*/ page=gtk_box_new(GTK_ORIENTATION_VERTICAL,0); label=gtk_label_new("API"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook),page,label); for(i=0;i != 4;++i) { /*名称*/ label=gtk_label_new(name[i]); /*api输入框*/ api[i]=gtk_entry_new(); /*api*/ data.api[i]=api[i]; /*如果当前API已设置,则显示出来*/ if(data.data.api[i]) gtk_entry_set_text(GTK_ENTRY(api[i]),data.data.api[i]); hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_start(GTK_BOX(page),hbox,TRUE,TRUE,10); gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,10); gtk_box_pack_start(GTK_BOX(hbox),api[i],TRUE,TRUE,10); /*如有改动更改操作状态*/ g_signal_connect(G_OBJECT(api[i]),"changed", G_CALLBACK(pre_save_flag),&data); } hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_end(GTK_BOX(vbox),hbox,FALSE,FALSE,5); gtk_box_pack_end(GTK_BOX(vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE,FALSE,5); label=gtk_label_new("所有更改均在重启后生效!"); gtk_box_pack_end(GTK_BOX(vbox),label,FALSE,FALSE,5); /*取消按钮*/ button=gtk_button_new_with_label("取消"); gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,FALSE,20); g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(pre_quit),&data); /*保存按钮*/ button=gtk_button_new_with_label("保存"); gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,20); g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(pre_quit_with_save),&data); gtk_widget_show_all(win); gtk_main(); return 0; }
void gui_init(dt_lib_module_t *self) { GtkBox *hbox; GtkWidget *button; GtkWidget *label; GtkEntryCompletion *completion; dt_lib_metadata_t *d = (dt_lib_metadata_t *)calloc(1, sizeof(dt_lib_metadata_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_table_new(6, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(self->widget), 5); g_signal_connect(self->widget, "expose-event", G_CALLBACK(expose), self); label = gtk_label_new(_("title")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->title = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->title)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->title))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->title))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->title))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->title), 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("description")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->description = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->description)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->description))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->description))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->description))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->description), 1, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("creator")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->creator = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->creator)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->creator))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->creator))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->creator))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->creator), 1, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("publisher")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->publisher = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->publisher)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->publisher))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->publisher))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->publisher))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->publisher), 1, 2, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("rights")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->rights = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->rights)))); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->rights))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->rights))), completion); g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->rights))), "key-press-event", G_CALLBACK (key_pressed), self); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->rights), 1, 2, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0); g_object_unref(completion); // reset/apply buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("clear")); d->clear_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("remove metadata from selected images"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (clear_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("apply")); d->apply_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("write metadata for selected images"), (char *)NULL); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (apply_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(hbox), 0, 2, 5, 6, GTK_EXPAND|GTK_FILL, 0, 0, 0); /* lets signup for mouse over image change signals */ dt_control_signal_connect(darktable.signals,DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_mouse_over_image_callback), self); }
static void sample_config_update(SooshiState *state, SooshiNode *node, gpointer user_data) { gtk_combo_box_set_active(GTK_COMBO_BOX(user_data), g_variant_get_byte(node->value)); }
int main(int argc, char *argv[]) { GtkBuilder *builder; gtk_init(&argc, &argv); builder = gtk_builder_new(); GError *error = NULL; gtk_builder_add_from_file(builder, "src/ui/mainwindow.glade", &error); if (error != NULL) { printf("Error loading user interface: %s", error->message); g_error_free(error); return 0; } sooshi_error_t sooshi_error = 0; SooshiState *state = sooshi_state_new(&sooshi_error); if (sooshi_error) return -1; AppState *s = g_new0(AppState, 1); s->channel1_top = gtk_builder_get_object(builder, "channel1_top"); s->channel1 = gtk_builder_get_object(builder, "channel1"); s->channel1_bottom = gtk_builder_get_object(builder, "channel1_bottom"); s->channel2_top = gtk_builder_get_object(builder, "channel2_top"); s->channel2 = gtk_builder_get_object(builder, "channel2"); s->channel2_bottom = gtk_builder_get_object(builder, "channel2_bottom"); s->battery_level = gtk_builder_get_object(builder, "battery_level"); s->battery_level_str = gtk_builder_get_object(builder, "battery_level_str"); s->trigger = GTK_COMBO_BOX(gtk_builder_get_object(builder, "Trigger")); s->sample_rate = GTK_COMBO_BOX(gtk_builder_get_object(builder, "Sample Rate")); s->sample_depth = GTK_COMBO_BOX(gtk_builder_get_object(builder, "Sample Depth")); s->sooshi = state; GObject *window = gtk_builder_get_object(builder, "MainWindow"); g_signal_connect(window, "destroy", G_CALLBACK(app_shutdown), s); /* Set up CSS style provider */ GtkCssProvider *provider = gtk_css_provider_new(); GdkDisplay *display = gdk_display_get_default(); GdkScreen *screen = gdk_display_get_default_screen(display); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(provider), "src/ui/style.css", &error); if (error != NULL) { printf("Error loading user interface style: %s", error->message); g_error_free(error); return 0; } g_object_unref(provider); sooshi_setup(state, mooshi_initialized, s, mooshi_scan_timed_out, s ); gtk_widget_show_all(GTK_WIDGET(window)); gtk_main(); sooshi_state_delete(state); return 0; }
static void create_proc_tab(GtkWidget *tab_vbox) { GtkWidget *tabs, *table, *vbox, *vbox1, *hbox, *text, *label; gint i; tabs = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs), GTK_POS_TOP); gtk_box_pack_start(GTK_BOX(tab_vbox), tabs, TRUE, TRUE, 0); /* ---Options tab */ vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Options")); gkrellm_gtk_check_button_connected(vbox, NULL, proc.enabled, FALSE, FALSE, 4, cb_enable, NULL, _("Enable Proc chart")); if (gkrellm_sensors_available()) gkrellm_gtk_check_button_connected(vbox, NULL, sensor_separate_mode, FALSE, FALSE, 0, cb_sensor_separate, NULL, _("Draw fan and temperature values separately (not alternating).")); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); gkrellm_gtk_alert_button(hbox, &processes_alert_button, FALSE, FALSE, 4, TRUE, cb_processes_alert, NULL); label = gtk_label_new(_("Processes")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 4); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); gkrellm_gtk_alert_button(hbox, &users_alert_button, FALSE, FALSE, 4, TRUE, cb_users_alert, NULL); label = gtk_label_new(_("Users")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 4); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); gkrellm_gtk_alert_button(hbox, &load_alert_button, FALSE, FALSE, 4, TRUE, cb_load_alert, NULL); label = gtk_label_new(_("Load")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 4); if (!proc.enabled) { gtk_widget_set_sensitive(load_alert_button, FALSE); gtk_widget_set_sensitive(users_alert_button, FALSE); gtk_widget_set_sensitive(processes_alert_button, FALSE); } vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Setup")); vbox1 = gkrellm_gtk_category_vbox(vbox, _("Format String for Chart Labels"), 4, 0, TRUE); text_format_combo_box = gtk_combo_box_entry_new_text(); gtk_widget_set_size_request (GTK_WIDGET(text_format_combo_box), 350, -1); gtk_box_pack_start(GTK_BOX(vbox1), text_format_combo_box, FALSE, FALSE, 2); gtk_combo_box_append_text(GTK_COMBO_BOX(text_format_combo_box), text_format); gtk_combo_box_append_text(GTK_COMBO_BOX(text_format_combo_box), _(DEFAULT_TEXT_FORMAT)); gtk_combo_box_append_text(GTK_COMBO_BOX(text_format_combo_box), _("\\f$L\\r\\f$F \\w88\\b\\p\\a$p\\f procs\\n\\e$u\\f users")); gtk_combo_box_set_active(GTK_COMBO_BOX(text_format_combo_box), 0); g_signal_connect(G_OBJECT(GTK_COMBO_BOX(text_format_combo_box)), "changed", G_CALLBACK(cb_text_format), NULL); vbox1 = gkrellm_gtk_category_vbox(vbox, _("Launch Commands"), 4, 0, TRUE); table = gkrellm_gtk_launcher_table_new(vbox1, 1); gkrellm_gtk_config_launcher(table, 0, &proc_launch_entry, &proc_tooltip_entry, _("Proc"), &proc_launch); g_signal_connect(G_OBJECT(proc_launch_entry), "changed", G_CALLBACK(cb_launch_entry), NULL); g_signal_connect(G_OBJECT(proc_tooltip_entry), "changed", G_CALLBACK(cb_launch_entry), NULL); /* --Info tab */ vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Info")); text = gkrellm_gtk_scrolled_text_view(vbox, NULL, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); for (i = 0; i < sizeof(proc_info_text)/sizeof(gchar *); ++i) gkrellm_gtk_text_view_append(text, _(proc_info_text[i])); }
static void on_gesture_end(ClutterGestureAction *action, ClutterActor *stage, gpointer data) { ClutterActor *new_actor, *texture, *actor; gfloat x, y, w, h; GError *error = NULL; GdkColor color; guint16 alpha; gint iw = 125; gint ih = 126; gboolean repeat_x = FALSE; gboolean repeat_y = TRUE; guint bgr; new_actor = tmpRect; gtk_color_button_get_color(GTK_COLOR_BUTTON(app.colorpicker), &color); alpha = gtk_color_button_get_alpha(GTK_COLOR_BUTTON(app.colorpicker)); ClutterColor col = { CLAMP(((color.red / 65535.0) * 255), 0, 255), CLAMP(((color.green / 65535.0) * 255), 0, 255), CLAMP(((color.blue / 65535.0) * 255), 0, 255), CLAMP(((alpha / 65535.0) * 255), 0, 255), }; clutter_rectangle_set_color(CLUTTER_RECTANGLE(new_actor), &col); clutter_rectangle_set_border_width(CLUTTER_RECTANGLE(new_actor), 0); tmpRect = NULL; clutter_actor_get_position(new_actor, &x, &y); clutter_actor_get_size(new_actor, &w, &h); if (background_image_file != NULL){ texture = clutter_texture_new_from_file(background_image_file, &error); if (error != NULL){ g_print("Loading image failed\n"); g_error_free(error); } clutter_actor_set_position(texture, x, y); clutter_actor_set_size(texture, w, h); clutter_actor_add_child(stage, texture); clutter_actor_show(texture); bgr = gtk_combo_box_get_active(GTK_COMBO_BOX(app.background_repeat_select)); switch (bgr){ case 0: repeat_x = repeat_y = FALSE; break; case 1: repeat_x = TRUE; repeat_y = FALSE; break; case 2: repeat_x = FALSE; repeat_y = TRUE; break; case 3: repeat_x = repeat_y = TRUE; break; } clutter_texture_get_base_size(CLUTTER_TEXTURE(texture), &iw, &ih); clutter_actor_set_clip(texture, 0, 0, repeat_x ? w : iw, repeat_y ? h : ih); clutter_texture_set_sync_size(CLUTTER_TEXTURE(texture), TRUE); clutter_texture_set_repeat(CLUTTER_TEXTURE(texture), TRUE, TRUE); clutter_texture_set_keep_aspect_ratio(CLUTTER_TEXTURE(texture), TRUE); actor = texture; clutter_actor_destroy(new_actor); } else { actor = new_actor; } tool = TOOL_SELECT; clutter_actor_add_action(actor, clutter_drag_action_new()); clutter_actor_set_reactive(actor, TRUE); actors = g_list_append(actors, actor); GdkWindow *gdk_window; gdk_window = gtk_widget_get_window(app.stage); gdk_window_set_cursor(gdk_window, NULL); }
static void mud_connections_show_properties(MudConnections *conn, gchar *mud) { GladeXML *glade; GConfClient *client; GtkTextBuffer *buffer; gchar *key, *buf, *name_strip, *char_strip; gint port; gchar **mud_tuple; glade = glade_xml_new(GLADEDIR "/muds.glade", "mudviewproperties", NULL); conn->priv->properties_window = glade_xml_get_widget(glade, "mudviewproperties"); conn->priv->name_entry = glade_xml_get_widget(glade, "name_entry"); conn->priv->host_entry = glade_xml_get_widget(glade, "host_entry"); conn->priv->port_entry = glade_xml_get_widget(glade, "port_entry"); conn->priv->icon_button = glade_xml_get_widget(glade, "icon_button"); conn->priv->icon_image = glade_xml_get_widget(glade, "icon_image"); conn->priv->profile_combo = glade_xml_get_widget(glade, "profile_combo"); conn->priv->character_name_entry = glade_xml_get_widget(glade, "character_name_entry"); conn->priv->logon_textview = glade_xml_get_widget(glade, "character_logon_textview"); if(conn->priv->icon_current) g_free(conn->priv->icon_current); conn->priv->icon_current = NULL; mud_connections_property_populate_profiles(conn); gtk_combo_box_set_model( GTK_COMBO_BOX(conn->priv->profile_combo), conn->priv->profile_model); g_object_unref(conn->priv->profile_model); conn->priv->profile_combo_renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(conn->priv->profile_combo), conn->priv->profile_combo_renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(conn->priv->profile_combo), conn->priv->profile_combo_renderer, "text", 0, NULL); g_signal_connect(conn->priv->properties_window, "delete-event", G_CALLBACK(mud_connections_property_delete_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "cancel_button"), "clicked", G_CALLBACK(mud_connections_property_cancel_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "save_button"), "clicked", G_CALLBACK(mud_connections_property_save_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "icon_button"), "clicked", G_CALLBACK(mud_connections_property_icon_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "name_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "host_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "port_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "character_name_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect( glade_xml_get_widget(glade, "character_logon_textview"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "profile_combo"), "changed", G_CALLBACK(mud_connections_property_combo_changed_cb), conn); g_object_unref(glade); if(conn->priv->original_name != NULL) g_free(conn->priv->original_name); conn->priv->original_name = NULL; if(conn->priv->original_char_name != NULL) g_free(conn->priv->original_char_name); conn->priv->original_char_name = NULL; if(mud != NULL) { gint len; mud_tuple = g_strsplit(mud, "\n", -1); g_free(mud); len = g_strv_length(mud_tuple); switch(len) { case 1: conn->priv->original_name = g_strdup(mud_tuple[0]); break; case 2: conn->priv->original_char_name = g_strdup(mud_tuple[0]); conn->priv->original_name = g_strdup(mud_tuple[1]); break; } g_strfreev(mud_tuple); } else return; name_strip = gconf_escape_key(conn->priv->original_name, -1); gtk_entry_set_text( GTK_ENTRY(conn->priv->name_entry), conn->priv->original_name); if(conn->priv->original_char_name) gtk_entry_set_text(GTK_ENTRY(conn->priv->character_name_entry), conn->priv->original_char_name); client = gconf_client_get_default(); key = g_strdup_printf("/apps/gnome-mud/muds/%s/host", name_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf) { gtk_entry_set_text(GTK_ENTRY(conn->priv->host_entry), buf); g_free(buf); } key = g_strdup_printf("/apps/gnome-mud/muds/%s/port", name_strip); port = gconf_client_get_int(client, key, NULL); g_free(key); if(port != 0) gtk_spin_button_set_value( GTK_SPIN_BUTTON(conn->priv->port_entry), port); key = g_strdup_printf("/apps/gnome-mud/muds/%s/profile", name_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf) { mud_connections_property_combo_get_index(conn, buf); g_free(buf); } key = g_strdup_printf("/apps/gnome-mud/muds/%s/icon", name_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf && strcmp(buf, "gnome-mud") != 0) { GdkPixbuf *icon; conn->priv->icon_current = g_strdup(buf); g_free(buf); icon = gdk_pixbuf_new_from_file_at_size( conn->priv->icon_current, 48, 48, NULL); gtk_image_set_from_pixbuf(GTK_IMAGE(conn->priv->icon_image), icon); g_object_unref(icon); } else conn->priv->icon_current = g_strdup("gnome-mud"); if(conn->priv->original_char_name != NULL) { char_strip = gconf_escape_key(conn->priv->original_char_name, -1); key = g_strdup_printf("/apps/gnome-mud/muds/%s/characters/%s/logon", name_strip, char_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf) { buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(conn->priv->logon_textview)); gtk_text_buffer_set_text(buffer, buf, strlen(buf)); g_free(buf); } g_free(char_strip); } g_free(name_strip); g_object_unref(client); conn->priv->changed = FALSE; }
GtkWidget *main_window(){ GtkWidget *vbox, *hpane, *vpane, *swin, *vbox2, *stage_width_entry, *stage_height_entry, *rectangle_button; WebKitWebView *web_view; ClutterActor *stage; ClutterColor stage_bg_color = { 128, 128, 128, 255 }, white = { 255, 255, 255, 255 } ; // Create widgets app.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); app.menubar = gtk_menu_bar_new(); app.toolbar = gtk_toolbar_new(); hpane = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); vpane = gtk_paned_new(GTK_ORIENTATION_VERTICAL); app.statusbar = gtk_statusbar_new(); app.stage = gtk_clutter_embed_new(); app.notebook = gtk_notebook_new(); web_view= WEBKIT_WEB_VIEW(webkit_web_view_new()); swin = gtk_scrolled_window_new(NULL, NULL); vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); stage_width_entry = gtk_spin_button_new_with_range(0, 9999, 1); stage_height_entry = gtk_spin_button_new_with_range(0, 9999, 1); app.colorpicker = gtk_color_button_new(); app.fileselector = gtk_file_chooser_button_new("Background image", GTK_FILE_CHOOSER_ACTION_OPEN); app.background_repeat_select = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "no-repeat"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-x"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-y"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-xy"); stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(app.stage)); rectangle_button = gtk_button_new_from_stock(GTK_STOCK_NEW); app.mainstage = clutter_rectangle_new_with_color(&white); // Pack widgets gtk_container_add(GTK_CONTAINER(app.window), vbox); gtk_box_pack_start(GTK_BOX(vbox), app.menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), app.toolbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), app.notebook, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), app.statusbar, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), vpane, gtk_label_new("Animator")); gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), swin, gtk_label_new("Browser")); gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), gtk_label_new("tbc"), gtk_label_new("Source")); gtk_container_add(GTK_CONTAINER(swin), GTK_WIDGET(web_view)); gtk_paned_pack1(GTK_PANED(vpane), hpane, TRUE, TRUE); gtk_paned_pack2(GTK_PANED(vpane), gtk_label_new("Timeline"), FALSE, TRUE); gtk_paned_pack1(GTK_PANED(hpane), app.stage,TRUE, TRUE); gtk_paned_pack2(GTK_PANED(hpane), vbox2, FALSE, TRUE); gtk_box_pack_start(GTK_BOX(vbox2), stage_width_entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), stage_height_entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), app.colorpicker, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), app.fileselector, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), app.background_repeat_select, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), rectangle_button, FALSE, FALSE, 0); //Setup widgets gtk_paned_set_position(GTK_PANED(hpane), 600); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); webkit_web_view_load_uri(web_view, "http://www.webkitgtk.org/"); gtk_widget_set_size_request(app.stage, 800, 600); gtk_paned_set_position(GTK_PANED(hpane), 600); gtk_spin_button_set_value(GTK_SPIN_BUTTON(stage_width_entry), 300); gtk_spin_button_set_value(GTK_SPIN_BUTTON(stage_height_entry), 200); g_object_set_data(G_OBJECT(stage_width_entry), "type", "width"); g_object_set_data(G_OBJECT(stage_height_entry), "type", "height"); clutter_stage_set_user_resizable(CLUTTER_STAGE(stage), FALSE); gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(app.colorpicker), TRUE); gtk_combo_box_set_active(GTK_COMBO_BOX(app.background_repeat_select), 0); clutter_actor_set_background_color(stage, &stage_bg_color); clutter_actor_set_size(app.mainstage, 400, 300); clutter_actor_set_position(app.mainstage, 100, 100); clutter_actor_add_child(stage, app.mainstage); clutter_actor_show(app.mainstage); clutter_actor_show(stage); // Connect signals g_signal_connect(app.fileselector, "file-set", G_CALLBACK(on_file_set), NULL); g_signal_connect(app.window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(stage_width_entry, "value-changed", G_CALLBACK(on_stage_dim_changed), stage); g_signal_connect(stage_height_entry, "value-changed", G_CALLBACK(on_stage_dim_changed), stage); g_signal_connect(rectangle_button, "clicked", G_CALLBACK(on_new_button_clicked), NULL); return (app.window); }
static gint SetGameType (GtkWidget *widget, gpointer *data) { NewGameType = gtk_combo_box_get_active(GTK_COMBO_BOX(widget)); return FALSE; }
void XAP_UnixDialog_FileOpenSaveAs::runModal(XAP_Frame * pFrame) { const XAP_StringSet * pSS = m_pApp->getStringSet(); std::string szTitle; std::string szFileTypeLabel; switch (m_id) { case XAP_DIALOG_ID_INSERT_PICTURE: { pSS->getValueUTF8(XAP_STRING_ID_DLG_IP_Title, szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel, szFileTypeLabel); m_bSave = false; break; } case XAP_DIALOG_ID_FILE_OPEN: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_OpenTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel); m_bSave = false; break; } case XAP_DIALOG_ID_FILE_IMPORT: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ImportTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel); m_bSave = false; break; } case XAP_DIALOG_ID_INSERTMATHML: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertMath,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertMath,szFileTypeLabel); m_bSave = false; break; } case XAP_DIALOG_ID_INSERTOBJECT: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertObject,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertObject,szFileTypeLabel); m_bSave = false; break; } case XAP_DIALOG_ID_INSERT_FILE: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel); m_bSave = false; break; } case XAP_DIALOG_ID_FILE_SAVEAS: case XAP_DIALOG_ID_FILE_SAVE_IMAGE: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_SaveAsTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel); m_bSave = true; break; } case XAP_DIALOG_ID_FILE_EXPORT: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ExportTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel); m_bSave = true; break; } case XAP_DIALOG_ID_PRINTTOFILE: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_PrintToFileTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FilePrintTypeLabel,szFileTypeLabel); m_bSave = true; break; } case XAP_DIALOG_ID_RECORDTOFILE: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileLabel,szFileTypeLabel); m_bSave = true; break; } case XAP_DIALOG_ID_REPLAYFROMFILE: { pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileTitle,szTitle); pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileLabel,szFileTypeLabel); m_bSave = false; break; } default: UT_ASSERT(UT_SHOULD_NOT_HAPPEN); m_bSave = false; break; } // NOTE: we use our string mechanism to localize the dialog's // NOTE: title and the error/confirmation message boxes. we // NOTE: let GTK take care of the localization of the actual // NOTE: buttons and labels on the FileSelection dialog. // Get the GtkWindow of the parent frame XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(pFrame->getFrameImpl()); GtkWidget * parent = pUnixFrameImpl->getTopLevelWindow(); if(parent && (GTK_WIDGET_TOPLEVEL(parent) != TRUE)) { parent = gtk_widget_get_toplevel (parent); } #if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON m_FC = GTK_FILE_CHOOSER( hildon_file_chooser_dialog_new(GTK_WINDOW(parent), (!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE)) ); #else m_FC = GTK_FILE_CHOOSER( gtk_file_chooser_dialog_new (szTitle.c_str(), GTK_WINDOW(parent), (!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, (m_bSave ? GTK_STOCK_SAVE : GTK_STOCK_OPEN), GTK_RESPONSE_ACCEPT, (gchar*)NULL) ); #endif gtk_file_chooser_set_local_only(m_FC, FALSE); abiSetupModalDialog(GTK_DIALOG(m_FC), pFrame, this, GTK_RESPONSE_ACCEPT); GtkWidget * filetypes_pulldown = NULL; std::string s; /* Add a drop-down list of known types to facilitate a file-types selection. We store an indexer in the user data for each menu item in the popup, so we can read the type we need to return. */ if (m_id == XAP_DIALOG_ID_INSERT_PICTURE) { GtkWidget * preview = createDrawingArea (); gtk_widget_show (preview); m_preview = preview; gtk_widget_set_size_request (preview, PREVIEW_WIDTH, PREVIEW_HEIGHT); // place the preview area inside a container to get a nice border GtkWidget * preview_hbox = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER(preview_hbox), 4); gtk_box_pack_start(GTK_BOX(preview_hbox), preview, TRUE, TRUE, 0); // attach the preview area to the dialog gtk_file_chooser_set_preview_widget (m_FC, preview_hbox); gtk_file_chooser_set_preview_widget_active (m_FC, true); // connect some signals g_signal_connect (m_FC, "update_preview", G_CALLBACK (file_selection_changed), static_cast<gpointer>(this)); g_signal_connect (preview, "expose_event", G_CALLBACK (s_preview_exposed), static_cast<gpointer>(this)); } #if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON filetypes_pulldown = gtk_combo_box_new(); gtk_widget_show(filetypes_pulldown); GtkWidget * pulldown_hbox = filetypes_pulldown; #else // hbox for our pulldown menu (GTK does its pulldown this way */ GtkWidget * pulldown_hbox = gtk_hbox_new(FALSE, 15); gtk_widget_show(pulldown_hbox); // pulldown label GtkWidget * filetypes_label = gtk_label_new_with_mnemonic(convertMnemonics(szFileTypeLabel).c_str()); gtk_label_set_justify(GTK_LABEL(filetypes_label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(filetypes_label), 1.0, 0.5); gtk_widget_show(filetypes_label); gtk_box_pack_start(GTK_BOX(pulldown_hbox), filetypes_label, TRUE, TRUE, 0); // pulldown menu filetypes_pulldown = gtk_combo_box_new(); gtk_widget_show(filetypes_pulldown); gtk_box_pack_end(GTK_BOX(pulldown_hbox), filetypes_pulldown, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(filetypes_label), filetypes_pulldown); #endif // // add the filters to the dropdown list // GtkComboBox* combo = GTK_COMBO_BOX(filetypes_pulldown); XAP_makeGtkComboBoxText(combo, G_TYPE_INT); // Auto-detect is always an option, but a special one, so we use // a pre-defined constant for the type, and don't use the user-supplied // types yet. pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileTypeAutoDetect,s); XAP_appendComboBoxTextAndInt(combo, s.c_str(), XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO); UT_sint32 activeItemIndex = -1; // add list items { UT_ASSERT(g_strv_length((gchar **) m_szSuffixes) == g_strv_length((gchar **) m_szDescriptions)); // measure one list, they should all be the same length UT_uint32 end = g_strv_length((gchar **) m_szDescriptions); for (UT_uint32 i = 0; i < end; i++) { // If this type is default, save its index (i) for later use if (m_nTypeList[i] == m_nDefaultFileType) activeItemIndex = i; XAP_appendComboBoxTextAndInt(combo, m_szDescriptions[i], m_nTypeList[i]); // // Attach a callback when it is activated to change the file suffix // // g_signal_connect(G_OBJECT(thismenuitem), "activate", // G_CALLBACK(s_filetypechanged), // reinterpret_cast<gpointer>(this)); } } m_wFileTypes_PullDown = filetypes_pulldown; // dialog; open dialog always does auto-detect // TODO: should this also apply to the open dialog? if (m_id == XAP_DIALOG_ID_FILE_SAVEAS || m_id == XAP_DIALOG_ID_FILE_SAVE_IMAGE) { gtk_combo_box_set_active(combo, activeItemIndex + 1); } else { gtk_combo_box_set_active(combo, 0); } #if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON hildon_file_chooser_dialog_add_extra ((HildonFileChooserDialog*)m_FC, pulldown_hbox); #else gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(m_FC), pulldown_hbox); #endif // connect the signals for OK and CANCEL and the requisite clean-close signals g_signal_connect(G_OBJECT(m_FC), "delete-event", G_CALLBACK(s_delete_clicked), this); g_signal_connect(G_OBJECT(m_FC), "key_press_event", G_CALLBACK(fsel_key_event), &m_answer); g_signal_connect (G_OBJECT (m_FC), "response", G_CALLBACK(dialog_response), &m_answer); g_signal_connect (G_OBJECT (m_FC), "file-activated", G_CALLBACK(s_file_activated), &m_answer); g_signal_connect(G_OBJECT(filetypes_pulldown), "changed", G_CALLBACK(s_filetypechanged), reinterpret_cast<gpointer>(this)); // use the persistence info and/or the suggested filename // to properly seed the dialog. gchar * szPersistDirectory = NULL; // we must g_free this if (!m_szInitialPathname || !*m_szInitialPathname) { // the caller did not supply initial pathname // (or supplied an empty one). see if we have // some persistent info. UT_ASSERT(!m_bSuggestName); if (m_szPersistPathname) { // we have a pathname from a previous use, // extract the directory portion and start // the dialog there (but without a filename). szPersistDirectory = UT_go_dirname_from_uri(m_szPersistPathname, FALSE); gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory); } else { // no initial pathname given and we don't have // a pathname from a previous use, so just let // it come up in the current working directory. } } else { // we have an initial pathname (the name of the document // in the frame that we were invoked on). if the caller // wanted us to suggest a filename, use the initial // pathname as is. if not, use the directory portion of // it. if (m_bSuggestName) { xxx_UT_DEBUGMSG(("Iniitial filename is %s \n",m_szInitialPathname)); #if 0 if (!g_path_is_absolute (m_szInitialPathname)) { // DAL: todo: is this correct? gchar *dir = g_get_current_dir (); gchar *file = m_szInitialPathname; gchar *filename = g_build_filename (dir, file, (gchar *)NULL); m_szInitialPathname = UT_go_filename_to_uri(filename); g_free(filename); g_free (dir); g_free (file); } #endif if(m_id == XAP_DIALOG_ID_FILE_SAVEAS) { std::string szInitialSuffix = UT_pathSuffix(m_szInitialPathname); std::string szSaveTypeSuffix = IE_Exp::preferredSuffixForFileType(m_nDefaultFileType).utf8_str(); if(!szInitialSuffix.empty() && !szSaveTypeSuffix.empty() && (szSaveTypeSuffix != szInitialSuffix)) { std::string sFileName = m_szInitialPathname; std::string::size_type i = sFileName.find_last_of('.'); if(i != std::string::npos) { // erase to the end() sFileName.erase(i); sFileName += szSaveTypeSuffix; FREEP(m_szInitialPathname); m_szInitialPathname = g_strdup(sFileName.c_str()); } } } if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname)) { gtk_file_chooser_set_uri(m_FC, m_szInitialPathname); } } else { if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname)) { szPersistDirectory = UT_go_dirname_from_uri(m_szInitialPathname, FALSE); gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory); } else { // we are dealing with a plain filename, not an URI or path, so // just let it come up in the current working directory. } } } // center the dialog xxx_UT_DEBUGMSG(("before center IS WIDGET_TOP_LEVL %d \n",(GTK_WIDGET_TOPLEVEL(parent)))); xxx_UT_DEBUGMSG(("before center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent)))); centerDialog(parent, GTK_WIDGET(m_FC)); xxx_UT_DEBUGMSG(("After center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent)))); gtk_widget_show(GTK_WIDGET(m_FC)); gtk_grab_add(GTK_WIDGET(m_FC)); bool bResult = _run_gtk_main(pFrame,filetypes_pulldown); if (bResult) { UT_ASSERT(m_szFinalPathnameCandidate); // store final path name and file type m_szFinalPathname = g_strdup(m_szFinalPathnameCandidate); FREEP(m_szFinalPathnameCandidate); // what a long ugly line of code m_nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(filetypes_pulldown)); } if (m_FC != NULL) { gtk_grab_remove (GTK_WIDGET(m_FC)); gtk_widget_destroy (GTK_WIDGET(m_FC)); m_FC = NULL; FREEP(szPersistDirectory); } return; }
gint setup_game (GtkAction * action, gpointer data) { GtkWidget *box, *box2, *label, *button, *frame; GtkWidget *grid; GtkWidget *combo; gchar *ts; int i; if (setupdialog) { gtk_window_present (GTK_WINDOW (setupdialog)); return FALSE; } setupdialog = gtk_dialog_new_with_buttons (_("Tali Preferences"), GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), 2); gtk_window_set_resizable (GTK_WINDOW (setupdialog), FALSE); g_signal_connect (G_OBJECT (setupdialog), "delete_event", G_CALLBACK (setupdialog_destroy), NULL); button = gtk_button_new_from_stock (GTK_STOCK_OK); g_signal_connect (G_OBJECT (setupdialog), "response", G_CALLBACK (do_setup), NULL); grid = gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (grid), 5); gtk_grid_set_row_spacing (GTK_GRID (grid), 18); gtk_grid_set_column_spacing (GTK_GRID (grid), 18); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), grid, FALSE, FALSE, 0); frame = games_frame_new (_("Human Players")); gtk_grid_attach (GTK_GRID (grid), frame, 0, 0, 1, 1); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), box); /*--- Spinner (number of humans) ---*/ OriginalNumberOfHumans = NumberOfHumans; box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Number of players:")); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); HumanAdj = gtk_adjustment_new ((gfloat) NumberOfHumans, 1.0, 6.0, 1.0, 6.0, 0.0); HumanSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (HumanAdj), 10, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), HumanSpinner); g_signal_connect (G_OBJECT (HumanAdj), "value_changed", G_CALLBACK (MaxPlayersCheck), HumanAdj); gtk_box_pack_start (GTK_BOX (box2), HumanSpinner, TRUE, TRUE, 0); frame = games_frame_new (_("Computer Opponents")); gtk_grid_attach (GTK_GRID (grid), frame, 0, 1, 1, 1); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), box); /*--- Button ---*/ button = gtk_check_button_new_with_mnemonic (_("_Delay between rolls")); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), DoDelay); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (set_as_int), &tmpDoDelay); /*--- Spinner (number of computers) ---*/ OriginalNumberOfComputers = NumberOfComputers; box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("N_umber of opponents:")); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); ComputerAdj = gtk_adjustment_new ((gfloat) NumberOfComputers, 0.0, 5.0, 1.0, 5.0, 0.0); ComputerSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (ComputerAdj), 10, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), ComputerSpinner); g_signal_connect (G_OBJECT (ComputerAdj), "value_changed", G_CALLBACK (MaxPlayersCheck), ComputerAdj); gtk_box_pack_start (GTK_BOX (box2), ComputerSpinner, TRUE, TRUE, 0); box2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start(GTK_BOX(box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Difficulty:")); gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0); combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Easy")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Medium")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Hard")); skill_level = 0; while (NUM_TRIALS > skill_level_table[skill_level].trials && skill_level < (SKILL_LEVEL_TABLE_SIZE - 1)) skill_level++; gtk_combo_box_set_active(GTK_COMBO_BOX(combo), skill_level); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetSkillLevel), combo); gtk_box_pack_start(GTK_BOX(box2), combo, FALSE, FALSE, 0); /*--- Combo (yahtzee or kismet style ----*/ frame = games_frame_new (_("Game Type")); gtk_grid_attach (GTK_GRID (grid), frame, 0, 2, 1, 1); combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("game type", "Regular")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("game type", "Colors")); gtk_combo_box_set_active(GTK_COMBO_BOX(combo), game_type); NewGameType = game_type; g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetGameType), combo); gtk_container_add (GTK_CONTAINER (frame), combo); /*--- PLAYER NAMES FRAME ----*/ frame = games_frame_new (_("Player Names")); gtk_grid_attach (GTK_GRID (grid), frame, 1, 0, 1, 3); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), box); for (i = 0; i < MAX_NUMBER_OF_PLAYERS; i++) { box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); ts = g_strdup_printf ("_%1d:", i + 1); label = gtk_label_new_with_mnemonic (ts); g_free (ts); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); PlayerNames[i] = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), PlayerNames[i]); ts = g_strdup_printf ("PlayerName%1d", i + 1); gtk_widget_set_name (PlayerNames[i], ts); g_free (ts); gtk_entry_set_text (GTK_ENTRY (PlayerNames[i]), players[i].name); gtk_box_pack_start (GTK_BOX (box2), PlayerNames[i], FALSE, FALSE, 0); } gtk_widget_show_all (setupdialog); return FALSE; }
GtkWidget* file_properties_dlg_new( GtkWindow* parent, const char* dir_path, GList* sel_files, int page ) { GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL ); GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" ); GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" ); xset_set_window_icon( GTK_WINDOW( dlg ) ); FilePropertiesDialogData* data; gboolean need_calc_size = TRUE; VFSFileInfo *file, *file2; VFSMimeType* mime; const char* multiple_files = _( "( multiple files )" ); const char* calculating; GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" ); GtkWidget* label_name = (GtkWidget*)gtk_builder_get_object( builder, "label_filename" ); GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" ); gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE ); GtkWidget* target = (GtkWidget*)gtk_builder_get_object( builder, "target" ); GtkWidget* label_target = (GtkWidget*)gtk_builder_get_object( builder, "label_target" ); gtk_editable_set_editable ( GTK_EDITABLE( target ), FALSE ); GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" ); GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" ); char buf[ 64 ]; char buf2[ 32 ]; const char* time_format = "%Y-%m-%d %H:%M:%S"; gchar* disp_path; gchar* file_type; int i; GList* l; gboolean same_type = TRUE; gboolean is_dirs = FALSE; char *owner_group, *tmp; gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) ); int width = xset_get_int( "app_dlg", "s" ); int height = xset_get_int( "app_dlg", "z" ); if ( width && height ) gtk_window_set_default_size( GTK_WINDOW( dlg ), width, -1 ); data = g_slice_new0( FilePropertiesDialogData ); /* FIXME: When will the data be freed??? */ g_object_set_data( G_OBJECT( dlg ), "DialogData", data ); data->file_list = sel_files; data->dlg = dlg; data->dir_path = g_strdup( dir_path ); disp_path = g_filename_display_name( dir_path ); //gtk_label_set_text( GTK_LABEL( location ), disp_path ); gtk_entry_set_text( GTK_ENTRY( location ), disp_path ); g_free( disp_path ); data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) ); data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) ); data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) ); data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) ); data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) ); data->mtime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "mtime" ) ); data->atime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "atime" ) ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) ); } //MOD VFSMimeType* type; VFSMimeType* type2 = NULL; for ( l = sel_files; l ; l = l->next ) { file = ( VFSFileInfo* ) l->data; type = vfs_file_info_get_mime_type( file ); if ( !type2 ) type2 = vfs_file_info_get_mime_type( file ); if ( vfs_file_info_is_dir( file ) ) is_dirs = TRUE; if ( type != type2 ) same_type = FALSE; vfs_mime_type_unref( type ); if ( is_dirs && !same_type ) break; } if ( type2 ) vfs_mime_type_unref( type2 ); data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" ); gtk_widget_set_sensitive( data->recurse, is_dirs ); /* //MOD for ( l = sel_files; l && l->next; l = l->next ) { VFSMimeType *type, *type2; file = ( VFSFileInfo* ) l->data; file2 = ( VFSFileInfo* ) l->next->data; type = vfs_file_info_get_mime_type( file ); type2 = vfs_file_info_get_mime_type( file2 ); if ( type != type2 ) { vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); same_type = FALSE; break; } vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); } */ file = ( VFSFileInfo* ) sel_files->data; if ( same_type ) { mime = vfs_file_info_get_mime_type( file ); file_type = g_strdup_printf( "%s\n%s", vfs_mime_type_get_description( mime ), vfs_mime_type_get_type( mime ) ); gtk_label_set_text( GTK_LABEL( mime_type ), file_type ); g_free( file_type ); vfs_mime_type_unref( mime ); } else { gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) ); } /* Open with... * Don't show this option menu if files of different types are selected, * ,the selected file is a folder, or its type is unknown. */ if( ! same_type || vfs_file_info_is_desktop_entry( file ) || /* vfs_file_info_is_unknown_type( file ) || */ vfs_file_info_is_executable( file, NULL ) ) { /* if open with shouldn't show, destroy it. */ gtk_widget_destroy( open_with ); open_with = NULL; gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) ); } else /* Add available actions to the option menu */ { GtkTreeIter it; char **action, **actions; mime = vfs_file_info_get_mime_type( file ); actions = vfs_mime_type_get_actions( mime ); GtkCellRenderer* renderer; GtkListStore* model; gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) ); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer, "pixbuf", 0, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer, "text", 1, NULL ); model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); if( actions ) { for( action = actions; *action; ++action ) { VFSAppDesktop* desktop; GdkPixbuf* icon; desktop = vfs_app_desktop_new( *action ); gtk_list_store_append( model, &it ); icon = vfs_app_desktop_get_icon(desktop, 20, TRUE); gtk_list_store_set( model, &it, 0, icon, 1, vfs_app_desktop_get_disp_name(desktop), 2, *action, -1 ); if( icon ) g_object_unref( icon ); vfs_app_desktop_unref( desktop ); } } else { g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) ); } /* separator */ gtk_list_store_append( model, &it ); gtk_list_store_append( model, &it ); gtk_list_store_set( model, &it, 0, NULL, 1, _("Choose..."), -1 ); gtk_combo_box_set_model( GTK_COMBO_BOX(open_with), GTK_TREE_MODEL(model) ); gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX(open_with), combo_sep, NULL, NULL ); gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0); g_signal_connect( open_with, "changed", G_CALLBACK(on_combo_change), mime ); /* vfs_mime_type_unref( mime ); */ /* We can unref mime when combo box gets destroyed */ g_object_weak_ref( G_OBJECT(open_with), (GWeakNotify)vfs_mime_type_unref, mime ); } g_object_set_data( G_OBJECT(dlg), "open_with", open_with ); /* Multiple files are selected */ if ( sel_files && sel_files->next ) { gtk_widget_set_sensitive( name, FALSE ); gtk_entry_set_text( GTK_ENTRY( name ), multiple_files ); data->orig_mtime = NULL; data->orig_atime = NULL; for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE ); data->chmod_states[ i ] = 2; /* Don't touch this bit */ g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled", G_CALLBACK( on_chmod_btn_toggled ), data ); } } else { /* special processing for files with special display names */ if( vfs_file_info_is_desktop_entry( file ) ) { char* disp_name = g_filename_display_name( file->name ); gtk_entry_set_text( GTK_ENTRY( name ), disp_name ); g_free( disp_name ); } else { if ( vfs_file_info_is_dir( file ) && !vfs_file_info_is_symlink( file ) ) gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ), _("<b>Folder _Name:</b>") ); gtk_entry_set_text( GTK_ENTRY( name ), vfs_file_info_get_disp_name( file ) ); } gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE ); if ( ! vfs_file_info_is_dir( file ) ) { /* Only single "file" is selected, so we don't need to caculate total file size */ need_calc_size = FALSE; sprintf( buf, _("%s ( %lu bytes )"), vfs_file_info_get_disp_size( file ), ( guint64 ) vfs_file_info_get_size( file ) ); gtk_label_set_text( data->total_size_label, buf ); vfs_file_size_to_string( buf2, vfs_file_info_get_blocks( file ) * 512 ); sprintf( buf, _("%s ( %lu bytes )"), buf2, ( guint64 ) vfs_file_info_get_blocks( file ) * 512 ); gtk_label_set_text( data->size_on_disk_label, buf ); gtk_label_set_text( data->count_label, _("1 file") ); } // Modified / Accessed //gtk_entry_set_text( GTK_ENTRY( mtime ), // vfs_file_info_get_disp_mtime( file ) ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_mtime( file ) ) ); gtk_entry_set_text( GTK_ENTRY( data->mtime ), buf ); data->orig_mtime = g_strdup( buf ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_atime( file ) ) ); gtk_entry_set_text( GTK_ENTRY( data->atime ), buf ); data->orig_atime = g_strdup( buf ); // Permissions owner_group = (char *) vfs_file_info_get_disp_owner( file ); tmp = strchr( owner_group, ':' ); data->owner_name = g_strndup( owner_group, tmp - owner_group ); gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name ); data->group_name = g_strdup( tmp + 1 ); gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */ { data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 ); gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] ); } } // target if ( vfs_file_info_is_symlink( file ) ) { gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ), _("<b>Link _Name:</b>") ); disp_path = g_build_filename( dir_path, file->name, NULL ); char* target_path = g_file_read_link( disp_path, NULL ); if ( target_path ) { gtk_entry_set_text( GTK_ENTRY( target ), target_path ); if ( target_path[0] && target_path[0] != '/' ) { // relative link to absolute char* str = target_path; target_path = g_build_filename( dir_path, str, NULL ); g_free( str ); } if ( !g_file_test( target_path, G_FILE_TEST_EXISTS ) ) gtk_label_set_text( GTK_LABEL( mime_type ), _("( broken link )") ); g_free( target_path ); } else gtk_entry_set_text( GTK_ENTRY( target ), _("( read link error )") ); g_free( disp_path ); gtk_widget_show( target ); gtk_widget_show( label_target ); } } if ( need_calc_size ) { /* The total file size displayed in "File Properties" is not completely calculated yet. So "Calculating..." is displayed. */ calculating = _( "Calculating..." ); gtk_label_set_text( data->total_size_label, calculating ); gtk_label_set_text( data->size_on_disk_label, calculating ); g_object_set_data( G_OBJECT( dlg ), "calc_size", data ); data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size, data, TRUE, NULL ); data->update_label_timer = g_timeout_add( 250, ( GSourceFunc ) on_update_labels, data ); } g_signal_connect( dlg, "response", G_CALLBACK(on_dlg_response), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_object_unref( builder ); gtk_notebook_set_current_page( notebook, page ); gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent ); return dlg; }
int geanypg_encrypt_selection_dialog(encrypt_data * ed, gpgme_key_t ** selected, int * sign) { GtkWidget * dialog = gtk_dialog_new(); unsigned long idx, sidx, capacity; int response; GtkWidget * contentarea, * listview, * scrollwin, * combobox; GtkTreeIter iter; listdata data; gboolean active; GtkListStore * list; *sign = 0; list = geanypg_makelist(ed->key_array, ed->nkeys, 0); listview = geanypg_listview(list, &data); scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwin), listview); gtk_widget_set_size_request(scrollwin, 500, 160); combobox = geanypg_combobox(geanypg_makelist(ed->skey_array, ed->nskeys, 1)); contentarea = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start(GTK_BOX(contentarea), gtk_label_new(_("Please select any recipients")), FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(contentarea), scrollwin, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(contentarea), gtk_label_new(_("Sign the message as:")), FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(contentarea), combobox, FALSE, FALSE, 0); /* add ok and cancel buttons */ gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_window_set_title(GTK_WINDOW(dialog), _("Select recipients")); gtk_widget_show_all(dialog); /* make sure dialog is destroyed when user responds */ response = gtk_dialog_run(GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_CANCEL) { gtk_widget_destroy(dialog); return 0; } idx = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox)); if (idx && idx <= ed->nskeys) { *sign = 1; gpgme_signers_add(ed->ctx, ed->skey_array[idx - 1]); /* -1 because the first option is `None' */ } /* try to loop all the keys in the list * if they are active (the user checked the checkbox in front of the key) * add it to the selected array, finaly make sure that the array * is NULL terminated */ if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list), &iter)) { capacity = SIZE; *selected = (gpgme_key_t*) malloc(SIZE * sizeof(gpgme_key_t)); idx = 0; sidx = 0; gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, TOGGLE_COLUMN, &active, -1); if (active) (*selected)[sidx++] = ed->key_array[idx]; while (gtk_tree_model_iter_next(GTK_TREE_MODEL(list), &iter)) { ++idx; gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, TOGGLE_COLUMN, &active, -1); if (active) (*selected)[sidx++] = ed->key_array[idx]; if (sidx >= capacity - 1) { capacity += SIZE; *selected = (gpgme_key_t*) realloc(*selected, capacity * sizeof(gpgme_key_t)); } } (*selected)[sidx] = NULL; } else { gtk_widget_destroy(dialog); return 0; } gtk_widget_destroy(dialog); return 1; }
/* * Sets the entry of the validation combo using the AirpcapValidationType. */ void airpcap_validation_type_combo_set_by_type(GtkWidget* c, AirpcapValidationType type) { gtk_combo_box_set_active(GTK_COMBO_BOX(c), airpcap_get_validation_combo_entry(type)); }
void UpdateWidgets(GtkWidget* window, gchar* except_name) { char *current_comb_supply = NULL; char *current_comb_supply_local = NULL; short len = 0; short current_comb_supply_id = 0; #ifdef _PRINTUI_DEBUG_ fprintf(stderr,"\n### UpdateWidgets :except_name = %s ###\n",except_name); #endif /* Ver.2.70: for "Front for Plain" */ if( except_name!=NULL ){ /* Store "media_supply_entry" setting(UI strings) */ /* Ver.2.80 */ GtkWidget* combo = LookupWidget(window, "media_supply_combo"); current_comb_supply = (char*)gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo)); len = strlen(current_comb_supply) + 1; current_comb_supply_local = malloc( len ); memset(current_comb_supply_local,0x00, len ); strncpy( current_comb_supply_local , current_comb_supply , len ); current_comb_supply_local[len-1] = '\0'; #ifdef _PRINTUI_DEBUG_ fprintf(stderr,"current_comb_supply_local = %s\n",current_comb_supply_local); #endif } // Print bw button if( !SameName(except_name, "print_bw_button") ) { gboolean sensitive = TRUE; switch( GetCurrentnValue(CNCL_GRAYSCALE) ) { case CND_BJGRAYSCALE_OFF: break; case CND_BJGRAYSCALE_ON: break; case CND_BJGRAYSCALE_GRAY: sensitive = FALSE; break; default: break; } gtk_widget_set_sensitive( LookupWidget(window, "print_bw_button1"), sensitive); gtk_widget_set_sensitive( LookupWidget(window, "print_bw_button2"), sensitive); } // Media type combo if( !SameName(except_name, "media_type_combo") ) { #ifdef _PRINTUI_DEBUG_ fprintf(stderr,"UpdateWidgets:media_type_combo\n"); #endif SetItemsToComboBox(window, "media_type_combo", CNCL_MEDIATYPE, GetCurrentnValue(CNCL_MEDIATYPE));/* Ver.2.80 */ } // Media supply combo if( !SameName(except_name, "media_supply_combo") ) { GList* glist = GetComboList(CNCL_MEDIASUPPLY); /* iP3300,MP510:Add "Front for Plain" (This value is always available) */ { char *str; //GetAllFlags:If CND_SUPPLY_CASSETTE_04 exist --> str > 0 if( GetAllFlags( CNCL_MEDIASUPPLY , CND_SUPPLY_CASSETTE_04 ) >= 0 ){ str = ValueToName( CNCL_MEDIASUPPLY , CND_SUPPLY_FRONT_FOR_PLAIN ); glist = g_list_append(glist, str); } } /* Ver.2.70: for "Front for Plain" */ if( except_name!=NULL ){ /* UI setting at the top of this function is not disable on CNCLDB --> use it (to UI) */ /* UI setting at the top of this function is disable on CNCLDB --> use current value of CNCLDB (to UI) */ current_comb_supply_id = NameToValue( CNCL_MEDIASUPPLY , current_comb_supply_local ); /* Replace "CND_SUPPLY_FRONT_FOR_PLAIN" with "CND_SUPPLY_ASF" before check */ if( current_comb_supply_id == CND_SUPPLY_FRONT_FOR_PLAIN ) current_comb_supply_id = CND_SUPPLY_ASF; if( IsAvailableValue( CNCL_MEDIASUPPLY , current_comb_supply_id ) ){ /* UI setting is not disable on CNCLDB */ SetGListToComboBox(window, "media_supply_combo",glist, current_comb_supply_local , CNCL_MEDIASUPPLY );/* Ver.2.80 */ }else{ /* UI setting is disable on CNCLDB */ #ifdef _PRINTUI_DEBUG_ fprintf(stderr," IsAvailableValue(%s,ID=%d): not Available!!\n",current_comb_supply_local,current_comb_supply_id); #endif SetGListToComboBox(window, "media_supply_combo",glist, GetCurrentString(CNCL_MEDIASUPPLY) , CNCL_MEDIASUPPLY );/* Ver.2.80 */ } } else{ //NULL --> Select "CNCLDB current value" on UI SetGListToComboBox(window, "media_supply_combo",glist, GetCurrentString(CNCL_MEDIASUPPLY) , CNCL_MEDIASUPPLY);/* Ver.2.80 */ } } // Cartridge type combo if( !SameName(except_name, "cartridge_type_combo") ) { #ifdef _PRINTUI_DEBUG_ fprintf(stderr,"UpdateWidgets:cartridge_type_combo\n"); #endif SetItemsToComboBox(window, "cartridge_type_combo", CNCL_CARTRIDGE, GetCurrentnValue(CNCL_CARTRIDGE));/* Ver.2.80 */ } // Quality radio button { gboolean custom_active = GTK_TOGGLE_BUTTON( LookupWidget(window, "quality_custom_button"))->active; GtkWidget* custom_button = LookupWidget(window, "quality_dialog_button"); short quality = GetCurrentnValue(CNCL_PRINTQUALITY); GtkWidget* button; short value[3]; int i; for( i = 0 ; i < 3 ; i++ ) { button = LookupWidget(window, g_quality_button_name[i]); value[i] = GetCurrentnValue(g_mess_map[i]); if( !custom_active && value[i] == quality ) { // activate button gtk_widget_set_sensitive(custom_button, FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); } if( value[i] != CND_QUALITY_ABSOLUTE_NA ) gtk_widget_set_sensitive(button, TRUE); else gtk_widget_set_sensitive(button, FALSE); } if( custom_active ){ // activate custom button gtk_widget_set_sensitive(custom_button, TRUE); } } // Color auto radio button { GtkWidget* button = LookupWidget(window, "color_auto_button"); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(button), g_main_window->color_auto ); } // Color adjust radio button { GtkWidget* button = LookupWidget(window, "color_dialog_button"); if( GTK_TOGGLE_BUTTON( LookupWidget(window, "color_manual_button"))->active ) gtk_widget_set_sensitive(button, TRUE); else gtk_widget_set_sensitive(button, FALSE); } // Guide(Thickness etc...) { GtkWidget* label = LookupWidget(window, "thick_msg_label"); char* position_msg = GetCurrentString(CNCL_MESS_THICK); gtk_label_set_text(GTK_LABEL(label), (gchar*)position_msg); } #ifdef _PRINTUI_DEBUG_ fprintf(stderr,"UpdateWidgets:8\n"); #endif // Paper gap combo if( !SameName(except_name, "paper_gap_combo") ) { #ifdef _PRINTUI_DEBUG_ fprintf(stderr,"UpdateWidgets:paper_gap_combo\n"); #endif SetItemsToComboBox(window, "paper_gap_combo", CNCL_PAPERGAP_COMMAND, GetCurrentnValue(CNCL_PAPERGAP_COMMAND));/* Ver.2.80 */ } ///////////////////////////////////////////////////////////////// // Media size combo if( !SameName(except_name, "media_size_combo") ) { /* for V320_a010 : To not resize the window. */ if( !( (SameName(except_name, "print_bw_button")) || (SameName(except_name, "quality_buttons")) || (SameName(except_name, "color_buttons")) || (SameName(except_name, "printing_type_combo"))) ) //Ver.3.00 SetItemsToComboBox(window, "media_size_combo", CNCL_PAPERSIZE, GetCurrentnValue(CNCL_PAPERSIZE)); } // Printing type combo if( !SameName(except_name, "printing_type_combo") ) { SetTextArrayToComboBox(window, "printing_type_combo", (const gchar**)g_printing_type_name, (const short*)g_printing_type_value, g_main_window->printing_type); } // Printing scaling hbox. { GtkWidget* hbox = LookupWidget(window, "scaling_hbox"); if( g_main_window->printing_type == PRINTING_TYPE_SCALE ) gtk_widget_show(hbox); else gtk_widget_hide(hbox); } // Printing scaling spin. if( !SameName(except_name, "printing_scaling_button") ) { GtkSpinButton* scaling_spin = (GtkSpinButton*)LookupWidget(window, "printing_scaling_spin"); gtk_adjustment_set_value(scaling_spin->adjustment, (gfloat)g_main_window->scaling); } // Centering button. if( !SameName(except_name, "centering_button") ) { gboolean active = (g_main_window->centering == LOCATION_CENTER)? TRUE : FALSE; gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(LookupWidget(UI_DIALOG(g_main_window)->window, "centering_button")), active); } if( IsAvailableBorderless() ) { short margin_type = GetCurrentnValue(CNCL_MARGINTYPE); gboolean active = (margin_type == CND_MARGIN_MINUS)? TRUE : FALSE; // Borderless hbox. GtkWidget* hbox = LookupWidget(window, "borderless_hbox"); // gtk_widget_set_sensitive(hbox, active); if( active == TRUE ) gtk_widget_show(hbox); else gtk_widget_hide(hbox); // Borderless button. if( !SameName(except_name, "borderless_button") ) { GtkWidget* button = LookupWidget(window, "borderless_button"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active); } // Border ext button. if( !SameName(except_name, "border_ext_button") ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(LookupWidget(UI_DIALOG(g_main_window)->window, g_border_ext_button_name[g_main_window->ext_border])), TRUE); } } if( IsAvailableDuplex() ) { GtkWidget* duplex_vbox; GtkWidget* duplex_hbox; gboolean active; // Duplex vbox. duplex_vbox = LookupWidget(window, "duplex_vbox"); gtk_widget_set_sensitive(duplex_vbox, IsAvailableValue(CNCL_DUPLEX_PRINTING, CND_DUPLEX_AUTO)); // Duplex hbox. active = (CND_DUPLEX_AUTO == GetCurrentnValue(CNCL_DUPLEX_PRINTING))? TRUE : FALSE; /* Ver.2.70 */ duplex_hbox = LookupWidget(window, "duplex_hbox"); gtk_widget_set_sensitive(duplex_hbox, active); // Auto Duplex button. if( !SameName(except_name, "auto_duplex_button") ) { // GtkWidget* button = LookupWidget(window, "auto_duplex_button"); // not in use... } // Stapleside if( !SameName(except_name, "stapleside_button") ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(LookupWidget(UI_DIALOG(g_main_window)->window, g_staple_button_name[g_main_window->stapleside])), TRUE); } } // Copies spin. if( !SameName(except_name, "copies_spin") ) { GtkSpinButton* copies_spin = (GtkSpinButton*)LookupWidget(window, "copies_spin"); gtk_adjustment_set_value(copies_spin->adjustment, (gfloat)g_main_window->copies); } if(current_comb_supply_local){ free(current_comb_supply_local); current_comb_supply_local = NULL; } // Ver.2.90:Custom Paper Size dialog button { GtkWidget* hbox_user = LookupWidget(window, "hbox_user"); // GtkWidget* space_user = LookupWidget(window, "usersize_space_label"); if( CND_SIZE_USER == GetCurrentnValue(CNCL_PAPERSIZE) ) { gtk_widget_show(hbox_user); // gtk_widget_show(space_user); }else { gtk_widget_hide(hbox_user); // gtk_widget_hide(space_user); } } /* Ver.3.00: Show supply position */ { GtkWidget* supply_mes_label2 = LookupWidget(window, "supply_label2"); short media,size; media = GetCurrentnValue(CNCL_MEDIATYPE); size = GetCurrentnValue(CNCL_PAPERSIZE); if( GetCurrentnValue(CNCL_MEDIASUPPLY) == CND_SUPPLY_AUTO_SELECT ) { if( ( media==CND_MEDIA_PLAIN ) && ( size==CND_SIZE_A4 || size==CND_SIZE_A5 || size==CND_SIZE_B5 || size==CND_SIZE_LETTER ) ){ gtk_widget_hide(supply_mes_label2); } else{ gtk_label_set_text(GTK_LABEL(supply_mes_label2), (gchar*)ValueToName( CNCL_MEDIASUPPLY , CND_SUPPLY_ASF )); gtk_widget_show(supply_mes_label2); } } else{ gtk_widget_hide(supply_mes_label2); } } }
GtkWidget* ShortcutsListDlg::create_dialog (GtkWidget* parent) { GtkWidget *shortcuts_dialog; GtkWidget *dialog_vbox8; GtkWidget *hbox3; GtkWidget *label33; GtkWidget *label34; GtkWidget *combobox4; GtkWidget *scrolledwindow5; GtkWidget *treeview3; GtkWidget *label35; GtkWidget *dialog_action_area8; GtkWidget *cancelbutton8; GtkWidget *okbutton8; GtkWidget *clearall_btn; GtkWidget *resetall_btn; shortcuts_dialog = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (shortcuts_dialog), _("Shortcut editor")); gtk_window_set_type_hint (GTK_WINDOW (shortcuts_dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_default_size(GTK_WINDOW(shortcuts_dialog), 420, 450); gtk_window_set_modal (GTK_WINDOW (shortcuts_dialog), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (shortcuts_dialog), TRUE); #ifndef _WIN32 //TOFIX API is buggy on Win32 (kills modal dialog state) gtk_window_set_skip_taskbar_hint (GTK_WINDOW (shortcuts_dialog), TRUE); #endif gtk_window_set_skip_pager_hint (GTK_WINDOW (shortcuts_dialog), TRUE); gtk_window_set_transient_for(GTK_WINDOW (shortcuts_dialog), GTK_WINDOW(window1)); //set parent dialog_vbox8 = GTK_DIALOG (shortcuts_dialog)->vbox; gtk_widget_show (dialog_vbox8); hbox3 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox3); gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox3, FALSE, TRUE, 0); label33 = gtk_label_new (_("Context:")); gtk_widget_show (label33); gtk_box_pack_start (GTK_BOX (hbox3), label33, FALSE, TRUE, 2); gtk_misc_set_alignment (GTK_MISC (label33), 0, 0.5); combobox4 = gtk_combo_box_new_text (); gtk_widget_show (combobox4); gtk_box_pack_start (GTK_BOX (hbox3), combobox4, TRUE, TRUE, 2); gtk_combo_box_append_text(GTK_COMBO_BOX(combobox4), _("Global")); gtk_combo_box_append_text(GTK_COMBO_BOX(combobox4), _("Tree widget")); gtk_combo_box_set_active (GTK_COMBO_BOX(combobox4), 0); g_signal_connect(combobox4, "changed", G_CALLBACK (on_context_combo_selected), this); label34 = gtk_label_new (""); gtk_widget_show (label34); gtk_box_pack_start (GTK_BOX (hbox3), label34, FALSE, TRUE, 2); gtk_misc_set_alignment (GTK_MISC (label34), 1.0, 0.5); scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow5); gtk_box_pack_start (GTK_BOX (dialog_vbox8), scrolledwindow5, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_SHADOW_IN); // create shortcuts list GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); treeview3 = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref (G_OBJECT (store)); //tree now holds reference gtk_widget_show (treeview3); gtk_container_add (GTK_CONTAINER (scrolledwindow5), treeview3); g_signal_connect (treeview3, "key_press_event", G_CALLBACK (treeview_keyboard_handler), this); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, _("Action")); gtk_tree_view_column_set_clickable(col, TRUE); //allow column header clicks gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_fixed_width(col, 300); // g_signal_connect (col, "clicked", G_CALLBACK (on_header_clicked), this); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", 0); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview3), col); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, _("Shortcut")); gtk_tree_view_column_set_clickable(col, TRUE); //allow column header clicks gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_fixed_width(col, 50); // g_signal_connect (col, "clicked", G_CALLBACK (on_header_clicked), this); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", 1); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview3), col); GtkWidget *hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox1, FALSE, TRUE, 5); GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)&bulb); GtkWidget *icon = gtk_image_new_from_pixbuf (pixbuf); gtk_widget_show (icon); gtk_box_pack_start (GTK_BOX (hbox1), icon, FALSE, TRUE, 2); label35 = gtk_label_new (_("Use mouse click to select an action, and then press key combination to assign the shortcut to it. Some actions are listed in more than one context so they can have more than one shortcut attached.")); gtk_widget_show (label35); gtk_box_pack_start (GTK_BOX (hbox1), label35, TRUE, TRUE, 2); gtk_misc_set_alignment (GTK_MISC (label35), 0.5, 0.5); gtk_label_set_line_wrap(GTK_LABEL(label35), true); #if GTK_CHECK_VERSION(2,10,0) //minimal version for this api gtk_label_set_line_wrap_mode(GTK_LABEL(label35), PANGO_WRAP_WORD_CHAR); #endif //action area dialog_action_area8 = GTK_DIALOG (shortcuts_dialog)->action_area; gtk_widget_show (dialog_action_area8); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END); clearall_btn = gtk_button_new_with_mnemonic(_("Clear All")); gtk_widget_show (clearall_btn); gtk_container_add (GTK_CONTAINER(dialog_action_area8), clearall_btn); GTK_WIDGET_SET_FLAGS (clearall_btn, GTK_CAN_DEFAULT); g_signal_connect(clearall_btn, "clicked", G_CALLBACK (on_clear_all_clicked), this); resetall_btn = gtk_button_new_with_mnemonic(_("Reset All")); gtk_widget_show (resetall_btn); gtk_container_add (GTK_CONTAINER(dialog_action_area8), resetall_btn); GTK_WIDGET_SET_FLAGS (resetall_btn, GTK_CAN_DEFAULT); g_signal_connect(resetall_btn, "clicked", G_CALLBACK (on_reset_all_clicked), this); cancelbutton8 = gtk_button_new_with_mnemonic (_("Cancel")); gtk_widget_show (cancelbutton8); gtk_dialog_add_action_widget (GTK_DIALOG (shortcuts_dialog), cancelbutton8, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton8, GTK_CAN_DEFAULT); g_signal_connect(cancelbutton8, "clicked", G_CALLBACK (on_cancel_clicked), this); okbutton8 = gtk_button_new_with_mnemonic (_("OK")); gtk_widget_show (okbutton8); gtk_container_add (GTK_CONTAINER(dialog_action_area8), okbutton8); GTK_WIDGET_SET_FLAGS (okbutton8, GTK_CAN_DEFAULT); g_signal_connect(okbutton8, "clicked", G_CALLBACK (on_ok_clicked), this); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, shortcuts_dialog, "shortcuts_dialog"); GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, dialog_vbox8, "dialog_vbox8"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, label33, "label33"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, label34, "label34"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, combobox4, "combobox4"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, scrolledwindow5, "scrolledwindow5"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, treeview3, "treeview3"); GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, dialog_action_area8, "dialog_action_area8"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, cancelbutton8, "cancelbutton8"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, okbutton8, "okbutton8"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, resetall_btn, "resetall_btn"); GLADE_HOOKUP_OBJECT (shortcuts_dialog, clearall_btn, "clearall_btn"); return shortcuts_dialog; }
static void _preferences_on_ok(gpointer data) { Panel * panel = data; gint i; gint cnt = sizeof(_panel_sizes) / sizeof(*_panel_sizes); GtkTreeModel * model; GtkTreeIter iter; gboolean valid; gchar * p; String * value; String * sep; char * filename; GtkWidget * widget; PanelAppletDefinition * pad; PanelApplet * pa; gtk_widget_hide(panel->pr_window); /* general */ config_set(panel->config, NULL, "accept_focus", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( panel->pr_accept_focus)) ? "1" : "0"); config_set(panel->config, NULL, "keep_above", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( panel->pr_keep_above)) ? "1" : "0"); /* top panel */ if((i = gtk_combo_box_get_active(GTK_COMBO_BOX(panel->pr_top_size))) >= 0 && i <= cnt) config_set(panel->config, NULL, "top_size", (i > 0) ? _panel_sizes[i - 1].name : NULL); model = GTK_TREE_MODEL(panel->pr_top_store); value = NULL; sep = ""; for(valid = gtk_tree_model_get_iter_first(model, &iter); valid == TRUE; valid = gtk_tree_model_iter_next(model, &iter)) { gtk_tree_model_get(model, &iter, 0, &p, -1); string_append(&value, sep); string_append(&value, p); sep = ","; g_free(p); } config_set(panel->config, NULL, "top", value); string_delete(value); /* bottom panel */ if((i = gtk_combo_box_get_active(GTK_COMBO_BOX(panel->pr_bottom_size))) >= 0 && i <= cnt) config_set(panel->config, NULL, "bottom_size", (i > 0) ? _panel_sizes[i - 1].name : NULL); model = GTK_TREE_MODEL(panel->pr_bottom_store); value = NULL; sep = ""; for(valid = gtk_tree_model_get_iter_first(model, &iter); valid == TRUE; valid = gtk_tree_model_iter_next(model, &iter)) { gtk_tree_model_get(model, &iter, 0, &p, -1); string_append(&value, sep); string_append(&value, p); sep = ","; g_free(p); } config_set(panel->config, NULL, "bottom", value); string_delete(value); /* XXX applets should be known from Panel already */ cnt = gtk_notebook_get_n_pages(GTK_NOTEBOOK(panel->pr_notebook)); for(i = 1; i < cnt; i++) { widget = gtk_notebook_get_nth_page(GTK_NOTEBOOK( panel->pr_notebook), i); if(widget == NULL || (pad = g_object_get_data(G_OBJECT(widget), "definition")) == NULL || (pa = g_object_get_data(G_OBJECT(widget), "applet")) == NULL) continue; pad->settings(pa, TRUE, FALSE); } if((filename = _config_get_filename()) != NULL) config_save(panel->config, filename); free(filename); }
int CExpressDlg::SelectedRefFrame(void) { if (m_RefFrameCombo) return SelectedItem(GTK_COMBO_BOX(m_RefFrameCombo), -1); return -1; }
static GtkWidget * _preferences_window_applets(Panel * panel) { GtkSizeGroup * group; GtkWidget * vbox; GtkWidget * vbox2; GtkWidget * vbox3; GtkWidget * hbox; GtkWidget * frame; GtkWidget * widget; size_t i; /* FIXME this needs a restart to apply */ group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); vbox = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); hbox = gtk_hbox_new(FALSE, 4); /* plug-ins */ frame = gtk_frame_new(_("Applets:")); widget = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(widget), 4); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN); panel->pr_store = _preferences_window_applets_model(); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(panel->pr_store), 2, GTK_SORT_ASCENDING); panel->pr_view = _preferences_window_applets_view(panel->pr_store, FALSE); gtk_container_add(GTK_CONTAINER(widget), panel->pr_view); gtk_container_add(GTK_CONTAINER(frame), widget); gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 0); /* controls */ vbox2 = gtk_vbox_new(FALSE, 4); widget = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_add), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #ifndef EMBEDDED widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_up), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_down), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #endif widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_remove), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); widget = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_label_new(NULL); gtk_box_pack_end(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_remove), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #ifndef EMBEDDED widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_down), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_up), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #endif widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_add), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 4); /* top plug-ins */ frame = gtk_frame_new(_("Top panel:")); vbox3 = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4); #if GTK_CHECK_VERSION(3, 0, 0) panel->pr_top_size = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(panel->pr_top_size), NULL, _("Default")); #else panel->pr_top_size = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_top_size), _("Default")); #endif for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++) #if GTK_CHECK_VERSION(3, 0, 0) gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT( panel->pr_top_size), NULL, _(_panel_sizes[i].alias)); #else gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_top_size), _(_panel_sizes[i].alias)); #endif gtk_box_pack_start(GTK_BOX(vbox3), panel->pr_top_size, FALSE, TRUE, 0); widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN); panel->pr_top_store = _preferences_window_applets_model(); panel->pr_top_view = _preferences_window_applets_view( panel->pr_top_store, TRUE); gtk_container_add(GTK_CONTAINER(widget), panel->pr_top_view); gtk_box_pack_start(GTK_BOX(vbox3), widget, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox3); gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0); /* bottom plug-ins */ frame = gtk_frame_new(_("Bottom panel:")); vbox3 = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4); #if GTK_CHECK_VERSION(3, 0, 0) panel->pr_bottom_size = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(panel->pr_bottom_size), NULL, _("Default")); #else panel->pr_bottom_size = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_bottom_size), _("Default")); #endif for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++) #if GTK_CHECK_VERSION(3, 0, 0) gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT( panel->pr_bottom_size), NULL, _(_panel_sizes[i].alias)); #else gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_bottom_size), _(_panel_sizes[i].alias)); #endif gtk_box_pack_start(GTK_BOX(vbox3), panel->pr_bottom_size, FALSE, TRUE, 0); widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN); panel->pr_bottom_store = _preferences_window_applets_model(); panel->pr_bottom_view = _preferences_window_applets_view( panel->pr_bottom_store, TRUE); gtk_container_add(GTK_CONTAINER(widget), panel->pr_bottom_view); gtk_box_pack_start(GTK_BOX(vbox3), widget, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox3); gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); return vbox; }
/** * empathy_irc_network_dialog_show: * @network: the #EmpathyIrcNetwork to configure * @parent: the parent of this dialog * * Display a dialog to configure a given #EmpathyIrcNetwork. * This function is a singleton so if a configuration dialog already * exists we use this one to edit the network. * * Returns: The displayed #GtkDialog */ GtkWidget * empathy_irc_network_dialog_show (EmpathyIrcNetwork *network, GtkWidget *parent) { static EmpathyIrcNetworkDialog *dialog = NULL; GladeXML *glade; GtkListStore *store; GtkCellRenderer *renderer; GtkAdjustment *adjustment; GtkTreeSelection *selection; GtkTreeViewColumn *column; gchar *filename; g_return_val_if_fail (network != NULL, NULL); if (dialog != NULL) { change_network (dialog, network); gtk_window_present (GTK_WINDOW (dialog->dialog)); return dialog->dialog; } dialog = g_slice_new0 (EmpathyIrcNetworkDialog); dialog->network = network; g_object_ref (dialog->network); filename = empathy_file_lookup ("empathy-account-widget-irc.glade", "libempathy-gtk"); glade = empathy_glade_get_file (filename, "irc_network_dialog", NULL, "irc_network_dialog", &dialog->dialog, "button_close", &dialog->button_close, "entry_network", &dialog->entry_network, "combobox_charset", &dialog->combobox_charset, "treeview_servers", &dialog->treeview_servers, "button_add", &dialog->button_add, "button_remove", &dialog->button_remove, "button_up", &dialog->button_up, "button_down", &dialog->button_down, NULL); g_free (filename); store = gtk_list_store_new (4, G_TYPE_OBJECT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview_servers), GTK_TREE_MODEL (store)); g_object_unref (store); /* address */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (irc_network_dialog_address_edited_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("Server"), renderer, "text", COL_ADR, NULL); /* port */ adjustment = (GtkAdjustment *) gtk_adjustment_new (6667, 1, G_MAXUINT16, 1, 10, 0); renderer = gtk_cell_renderer_spin_new (); g_object_set (renderer, "editable", TRUE, "adjustment", adjustment, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (irc_network_dialog_port_edited_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("Port"), renderer, "text", COL_PORT, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_servers), 1); gtk_tree_view_column_set_expand (column, TRUE); /* SSL */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "activatable", TRUE, NULL); g_signal_connect (renderer, "toggled", G_CALLBACK (irc_network_dialog_ssl_toggled_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("SSL"), renderer, "active", COL_SSL, NULL); selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (dialog->treeview_servers)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* charset */ totem_subtitle_encoding_init (GTK_COMBO_BOX (dialog->combobox_charset)); irc_network_dialog_setup (dialog); empathy_glade_connect (glade, dialog, "irc_network_dialog", "destroy", irc_network_dialog_destroy_cb, "button_close", "clicked", irc_network_dialog_close_clicked_cb, "entry_network", "focus-out-event", irc_network_dialog_network_focus_cb, "button_add", "clicked", irc_network_dialog_button_add_clicked_cb, "button_remove", "clicked", irc_network_dialog_button_remove_clicked_cb, "button_up", "clicked", irc_network_dialog_button_up_clicked_cb, "button_down", "clicked", irc_network_dialog_button_down_clicked_cb, "combobox_charset", "changed", irc_network_dialog_combobox_charset_changed_cb, NULL); g_object_unref (glade); g_object_add_weak_pointer (G_OBJECT (dialog->dialog), (gpointer) &dialog); g_signal_connect (selection, "changed", G_CALLBACK (irc_network_dialog_selection_changed_cb), dialog); gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent)); gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE); irc_network_dialog_network_update_buttons (dialog); return dialog->dialog; }
GtkWidget *create_notebook_page_dialog(int page, dialog_buttons btn[MAX_KEYS], dialog_checkbox checkbox[CHECK_NBR]) { GtkWidget *main_box; GtkWidget *joy_choose_frame, *joy_choose_box; GtkWidget *keys_frame, *keys_box; GtkWidget *keys_tree_box, *keys_tree_scroll; GtkWidget *keys_tree_clear_btn, *keys_tree_remove_btn, *keys_tree_modify_btn, *keys_tree_show_key_btn, *keys_tree_show_joy_btn; GtkWidget *keys_btn_box, *keys_filter_box; GtkWidget *keys_static_frame, *keys_static_box; GtkWidget *keys_static_area; joy_choose_cbox = GTK_COMBO_BOX(gtk_combo_box_new_text()); populate_new_joysticks(joy_choose_cbox); set_current_joy(); g_signal_connect(GTK_OBJECT (joy_choose_cbox), "changed", G_CALLBACK(joy_changed), NULL); keys_tree_scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(keys_tree_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER(keys_tree_scroll), key_tree_manager->view_widget(page)); gtk_widget_set_size_request(keys_tree_scroll, 300, 500); keys_tree_clear_btn = gtk_button_new_with_label("Clear All"); g_signal_connect(GTK_OBJECT (keys_tree_clear_btn), "clicked", G_CALLBACK(on_clear_clicked), NULL); gtk_widget_set_size_request(keys_tree_clear_btn, 70, 24); keys_tree_remove_btn = gtk_button_new_with_label("Remove"); g_signal_connect(GTK_OBJECT (keys_tree_remove_btn), "clicked", G_CALLBACK(on_remove_clicked), NULL); gtk_widget_set_size_request(keys_tree_remove_btn, 70, 24); keys_tree_modify_btn = gtk_button_new_with_label("Modify"); g_signal_connect(GTK_OBJECT (keys_tree_modify_btn), "clicked", G_CALLBACK(on_modify_clicked), NULL); gtk_widget_set_size_request(keys_tree_modify_btn, 70, 24); keys_tree_show_joy_btn = gtk_check_button_new_with_label("Show joy"); g_signal_connect(GTK_OBJECT (keys_tree_show_joy_btn), "toggled", G_CALLBACK(on_view_joy_clicked), NULL); gtk_widget_set_size_request(keys_tree_show_joy_btn, 100, 24); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_tree_show_joy_btn), true); keys_tree_show_key_btn = gtk_check_button_new_with_label("Show key"); g_signal_connect(GTK_OBJECT (keys_tree_show_key_btn), "toggled", G_CALLBACK(on_view_key_clicked), NULL); gtk_widget_set_size_request(keys_tree_show_key_btn, 100, 24); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_tree_show_key_btn), true); joy_choose_box = gtk_hbox_new(false, 5); joy_choose_frame = gtk_frame_new ("Joystick to use for this pad"); gtk_container_add (GTK_CONTAINER(joy_choose_frame), joy_choose_box); keys_btn_box = gtk_hbox_new(false, 5); keys_filter_box = gtk_hbox_new(false, 5); keys_tree_box = gtk_vbox_new(false, 5); keys_static_box = gtk_hbox_new(false, 5); keys_static_frame = gtk_frame_new (""); gtk_container_add (GTK_CONTAINER(keys_static_frame), keys_static_box); keys_static_area = gtk_fixed_new(); for(int i = 0; i < MAX_KEYS; i++) { btn[i].put(b_pos[i].label, i, GTK_FIXED(keys_static_area), b_pos[i].x, b_pos[i].y); } u32 mask = 1 << (16*page); for(int i = 0; i < CHECK_NBR; i++) { checkbox[i].create(keys_static_area, check_pos[i].label, check_pos[i].x, check_pos[i].y, mask); mask = mask << 1; } keys_box = gtk_hbox_new(false, 5); keys_frame = gtk_frame_new ("Key Settings"); gtk_container_add (GTK_CONTAINER(keys_frame), keys_box); gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_tree_scroll, true, true, 0); gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_btn_box, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_filter_box, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_filter_box), keys_tree_show_joy_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_filter_box), keys_tree_show_key_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_clear_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_remove_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_modify_btn, false, false, 0); gtk_container_add(GTK_CONTAINER(joy_choose_box), GTK_WIDGET(joy_choose_cbox)); gtk_box_pack_start(GTK_BOX (keys_box), keys_tree_box, false, false, 0); gtk_container_add(GTK_CONTAINER(keys_box), keys_static_area); main_box = gtk_vbox_new(false, 5); gtk_container_add(GTK_CONTAINER(main_box), joy_choose_frame); gtk_container_add(GTK_CONTAINER(main_box), keys_frame); return main_box; }