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;
}
