static void rebuildLists()
{
short i, c;
gchar* txt[2];
gUpdateFlag=TRUE;
gtk_clist_freeze(GTK_CLIST(gSrcList));
gtk_clist_freeze(GTK_CLIST(gAppList));
gtk_clist_freeze(GTK_CLIST(gDstList));
gtk_clist_clear(GTK_CLIST(gSrcList));
gtk_clist_clear(GTK_CLIST(gAppList));
gtk_clist_clear(GTK_CLIST(gDstList));
c = MidiCountAppls();
for (i=1; i <= c; i++) {
txt[0] = g_strdup_printf("%d", MidiGetIndAppl(i));
txt[1] = MidiGetName(MidiGetIndAppl(i));
gtk_clist_append(GTK_CLIST(gSrcList), txt);
gtk_clist_append(GTK_CLIST(gAppList), txt);
gtk_clist_append(GTK_CLIST(gDstList), txt);
}
gtk_clist_thaw(GTK_CLIST(gSrcList));
gtk_clist_thaw(GTK_CLIST(gAppList));
gtk_clist_thaw(GTK_CLIST(gDstList));
gUpdateFlag=FALSE;
}
static void prefs_summary_column_set_dialog(SummaryColumnState *state)
{
GtkCList *stock_clist = GTK_CLIST(summary_col.stock_clist);
GtkCList *shown_clist = GTK_CLIST(summary_col.shown_clist);
gint pos;
SummaryColumnType type;
gchar *name;
gtk_clist_clear(stock_clist);
gtk_clist_clear(shown_clist);
if (!state)
state = prefs_summary_column_get_config();
for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
gint row;
type = state[pos].type;
name = gettext(col_name[type]);
if (state[pos].visible) {
row = gtk_clist_append(shown_clist, (gchar **)&name);
gtk_clist_set_row_data(shown_clist, row,
GINT_TO_POINTER(type));
} else {
row = gtk_clist_append(stock_clist, (gchar **)&name);
gtk_clist_set_row_data(stock_clist, row,
GINT_TO_POINTER(type));
}
}
}
/*
* Función listarNotasWidget()
*/
void listarNotasWidget (void)
{
int i, num;
gchar *linea[2];
char posicion[32];
/*
* Lista vacía
*/
num=numeroNotas(&(datosAgenda.notas));
if (0 == num) {
gtk_clist_clear( (GtkCList *) datosAgenda.gtk_notas);
return;
}
/*
* Imprimir lista
*/
gtk_clist_clear( (GtkCList *) datosAgenda.gtk_notas);
for (i=1; i<=num; i++) {
sprintf(posicion,"%d",i);
linea[0]=posicion;
linea[1]=consultarNotas(&(datosAgenda.notas),i);
gtk_clist_append( (GtkCList *) datosAgenda.gtk_notas,
linea);
}
}
/**
* Display the data gathered during the last time period.
* Perhaps it would be better to have this done on a button click(?)
*/
static void
search_stats_gui_update_display(void)
{
GtkWidget *clist_search_stats;
GtkWidget *label_search_stats_count;
clist_search_stats = gui_main_window_lookup("clist_search_stats");
label_search_stats_count =
gui_main_window_lookup("label_search_stats_count");
stat_count = 0;
gtk_clist_freeze(GTK_CLIST(clist_search_stats));
gtk_clist_clear(GTK_CLIST(clist_search_stats));
/* insert the hash table contents into the sorted clist */
g_hash_table_foreach_remove(stat_hash, stats_hash_to_clist, NULL);
gtk_clist_sort(GTK_CLIST(clist_search_stats));
gtk_clist_thaw(GTK_CLIST(clist_search_stats));
/* update the counter */
gtk_label_printf(GTK_LABEL(label_search_stats_count),
NG_("%u term counted", "%u terms counted", stat_count),
stat_count);
}
void ShowPlayList( void )
{
if ( PlayList ) gtkActive( PlayList );
else PlayList=create_PlayList();
if ( old_path && *old_path )
{
char * currentdir = strdup( old_path );
char * tpath,* pos;
GtkCTreeNode * node,* nextnode;
gboolean leaf;
tpath=strdup( "/" );
pos=strtok( currentdir,"/" );
node=gtk_ctree_find_by_row_data_custom( GTK_CTREE( CTDirTree ),NULL,"/",compare_func );
do
{
char * tpathnew = g_strconcat( tpath,pos,"/",NULL );
free( tpath ); tpath=tpathnew;
nextnode=gtk_ctree_find_by_row_data_custom( GTK_CTREE( CTDirTree ),node,tpath,compare_func );
if ( !nextnode ) break;
node=nextnode;
pos=strtok( NULL,"/" );
gtk_ctree_get_node_info( GTK_CTREE( CTDirTree ),node,NULL,NULL,NULL,NULL,NULL,NULL,&leaf,NULL );
if ( !leaf && pos ) gtk_ctree_expand( GTK_CTREE( CTDirTree ),node );
else
{
DirNodeType * DirNode;
gtk_ctree_select( GTK_CTREE( CTDirTree ),node );
DirNode=gtk_ctree_node_get_row_data( GTK_CTREE( CTDirTree ),node );
current_path=DirNode->path;
scan_dir( DirNode->path );
if ( CLFileSelected ) free( CLFileSelected ); CLFileSelected=calloc( 1,NrOfEntrys * sizeof( int ) );
break;
}
} while( pos );
free( tpath );
free( currentdir );
}
else gtk_ctree_select( GTK_CTREE( CTDirTree ),parent );
gtk_clist_freeze( GTK_CLIST( CLSelected ) );
gtk_clist_clear( GTK_CLIST( CLSelected ) );
if ( plList )
{
plItem * next = plList;
while ( next || next->next )
{
char * text[1][3]; text[0][2]="";
text[0][0]=next->name;
text[0][1]=next->path;
gtk_clist_append( GTK_CLIST( CLSelected ),text[0] );
NrOfSelected++;
if ( next->next ) next=next->next; else break;
}
CLListSelected=calloc( 1,NrOfSelected * sizeof( int ) );
}
gtk_clist_thaw( GTK_CLIST( CLSelected ) );
gtk_widget_show( PlayList );
}
static void
update_display( GtkCList *clist, libspectrum_word base )
{
size_t i, j;
gchar buffer[ 8 + 64 + 20 ];
gchar *text[] = { &buffer[0], &buffer[ 8 ], &buffer[ 8 + 64 ] };
char buffer2[ 8 ];
gtk_clist_freeze( clist );
gtk_clist_clear( clist );
for( i = 0; i < 20; i++ ) {
snprintf( text[0], 8, "%04X", base );
text[1][0] = '\0';
for( j = 0; j < 0x10; j++, base++ ) {
libspectrum_byte b = readbyte_internal( base );
snprintf( buffer2, 4, "%02X ", b );
strncat( text[1], buffer2, 4 );
text[2][j] = ( b >= 32 && b < 127 ) ? b : '.';
}
text[2][ 0x10 ] = '\0';
gtk_clist_append( clist, text );
}
gtk_clist_thaw( clist );
}
/**
* TBD
*/
void clear_hist_list( void ) {
/*
* Clear the list using gtk_clist_clear. This is much faster than *
* calling gtk_clist_remove once for each row.
*/
gtk_clist_clear( GTK_CLIST( hist_list ) );
} // clear_hist_list
static void
addkeywords_to_list(GtkWidget* widget, LPCSTR attrs, TGENSETUP *gensetup_t)
{
char *curr, *cour;
char *data[2];
if (!GTK_IS_CLIST (widget))
return;
gtk_clist_clear (GTK_CLIST (widget));
for (curr = (LPSTR) attrs; *curr; curr += (STRLEN (curr) + 1))
{
if (!strncasecmp (curr, "DSN=", STRLEN ("DSN=")) ||
!strncasecmp (curr, "Driver=", STRLEN ("Driver=")) ||
!strncasecmp (curr, "Description=", STRLEN ("Description=")))
continue;
if ((cour = strchr (curr, '=')))
{
*cour = '\0';
data[0] = curr;
data[1] = cour + 1;
gtk_clist_append (GTK_CLIST (widget), data);
*cour = '=';
}
else
{
data[0] = "";
gtk_clist_append (GTK_CLIST (widget), data);
}
}
if (GTK_CLIST (widget)->rows > 0)
gtk_clist_sort (GTK_CLIST (widget));
}
/**
* Clear the list, empty the hash table.
*/
void
search_stats_gui_reset(void)
{
empty_hash_table();
gtk_clist_clear(GTK_CLIST(
gui_main_window_lookup("clist_search_stats")));
}
static void
update_window_listbox (gftp_window_data * wdata)
{
GList * templist, * filelist;
gftp_file * tempfle;
int num;
filelist = wdata->files;
templist = gftp_gtk_get_list_selection (wdata);
num = 0;
while (templist != NULL)
{
templist = get_next_selection (templist, &filelist, &num);
tempfle = filelist->data;
tempfle->was_sel = 1;
}
gtk_clist_freeze (GTK_CLIST (wdata->listbox));
gtk_clist_clear (GTK_CLIST (wdata->listbox));
templist = wdata->files;
while (templist != NULL)
{
tempfle = templist->data;
add_file_listbox (wdata, tempfle);
templist = templist->next;
}
gtk_clist_thaw (GTK_CLIST (wdata->listbox));
update_window (wdata);
}
void
search_gui_clear_details(void)
{
if (clist_search_details) {
gtk_clist_clear(clist_search_details);
}
}
static void RefreshEventList( void )
{
int i;
char buf[128];
// Clear events list
gtk_clist_freeze( GTK_CLIST(g_pEventsList) );
gtk_clist_clear( GTK_CLIST(g_pEventsList) );
if( GetCurrentCam() ) {
// Fill events list
for( i = 0; i < GetCurrentCam()->GetCam()->numEvents(); i++ ) {
char rowbuf[3][128], *row[3];
// FIXME: sort by time?
sprintf( rowbuf[0], "%li", GetCurrentCam()->GetCam()->getEvent(i)->getTime() ); row[0] = rowbuf[0];
strncpy( rowbuf[1], GetCurrentCam()->GetCam()->getEvent(i)->typeStr(), sizeof(rowbuf[0]) ); row[1] = rowbuf[1];
strncpy( rowbuf[2], GetCurrentCam()->GetCam()->getEvent(i)->getParam(), sizeof(rowbuf[1]) ); row[2] = rowbuf[2];
gtk_clist_append( GTK_CLIST(g_pEventsList), row );
}
// Total duration might have changed
sprintf( buf, "%.2f", GetCurrentCam()->GetCam()->getTotalTime() );
gtk_label_set_text( g_pCurrentTime, "0.00" );
gtk_label_set_text( g_pTotalTime, buf );
gtk_adjustment_set_value( g_pTimeLine, 0.f );
g_pTimeLine->upper = ( GetCurrentCam()->GetCam()->getTotalTime() * 1000 );
}
gtk_clist_thaw( GTK_CLIST(g_pEventsList) );
}
static void scan_dir( char * path )
{
DIR * dir = NULL;
char * curr;
struct dirent * dirent;
struct stat statbuf;
gchar * name;
char * text[1][2]; text[0][1]="";
gtk_clist_clear( GTK_CLIST( CLFiles ) );
if ( (dir=opendir( path )) )
{
NrOfEntrys=0;
while( (dirent=readdir( dir )) )
{
curr=calloc( 1,strlen( path ) + strlen( dirent->d_name ) + 3 ); sprintf( curr,"%s/%s",path,dirent->d_name );
if ( stat( curr,&statbuf ) != -1 && ( S_ISREG( statbuf.st_mode ) || S_ISLNK( statbuf.st_mode ) ) )
{
name=g_filename_to_utf8( dirent->d_name, -1, NULL, NULL, NULL );
text[0][0]=name ? name : dirent->d_name;
gtk_clist_append( GTK_CLIST( CLFiles ), text[0] );
g_free( name );
NrOfEntrys++;
}
free( curr );
}
closedir( dir );
gtk_clist_sort( GTK_CLIST( CLFiles ) );
}
}
void DownloadUI::UpdateDownloadList(void)
{
if (!m_List || !isVisible)
return;
gtk_clist_freeze(GTK_CLIST(m_List));
gtk_clist_clear(GTK_CLIST(m_List));
uint32 iLoop = downloadList.size();
if (iLoop == 0) {
gtk_clist_thaw(GTK_CLIST(m_List));
return;
}
for (uint32 i = 0; i < iLoop; i++) {
DownloadItem *dli = downloadList[i];
char *iText[2];
string displayString = dli->GetMetaData().Title();
iText[0] = (char *)displayString.c_str();
iText[1] = (char *)StatusString(dli).c_str();
int row = gtk_clist_append(GTK_CLIST(m_List), iText);
gtk_clist_set_row_data(GTK_CLIST(m_List), row, (gpointer)dli);
}
gtk_clist_select_row(GTK_CLIST(m_List), m_currentindex, 0);
SelChangeEvent(m_currentindex);
gtk_clist_thaw(GTK_CLIST(m_List));
}
static void imp_ldif_load_fields( LdifFile *ldf ) {
GtkCList *clist = GTK_CLIST(impldif_dlg.clist_field);
GList *node, *list;
gchar *text[ FIELDS_N_COLS ];
impldif_dlg.rowIndSelect = -1;
impldif_dlg.rowCount = 0;
if( ! ldf->accessFlag ) return;
gtk_clist_clear( clist );
list = ldif_get_fieldlist( ldf );
node = list;
while( node ) {
Ldif_FieldRec *rec = node->data;
gint row;
if( ! rec->reserved ) {
text[ FIELD_COL_SELECT ] = "";
text[ FIELD_COL_FIELD ] = rec->tagName;
text[ FIELD_COL_ATTRIB ] = rec->userName;
row = gtk_clist_append( clist, text );
gtk_clist_set_row_data( clist, row, rec );
if( rec->selected )
gtk_clist_set_pixmap( clist, row, FIELD_COL_SELECT, markxpm, markxpmmask );
impldif_dlg.rowCount++;
}
node = g_list_next( node );
}
g_list_free( list );
list = NULL;
ldif_set_accessed( ldf, FALSE );
}
static void
megacostat_draw(void *pms)
{
megacostat_t *ms=(megacostat_t *)pms;
int i;
char *str[7];
for(i=0; i<7; i++) {
str[i]=g_malloc(sizeof(char[256]));
}
/* clear list before printing */
gtk_clist_clear(ms->table);
for(i=0; i<NUM_TIMESTATS; i++) {
/* nothing seen, nothing to do */
if(ms->rtd[i].num==0) {
continue;
}
g_snprintf(str[0], sizeof(char[256]), "%s", val_to_str(i,megaco_message_type,"Other"));
g_snprintf(str[1], sizeof(char[256]), "%d", ms->rtd[i].num);
g_snprintf(str[2], sizeof(char[256]), "%8.2f msec", nstime_to_msec(&(ms->rtd[i].min)));
g_snprintf(str[3], sizeof(char[256]), "%8.2f msec", nstime_to_msec(&(ms->rtd[i].max)));
g_snprintf(str[4], sizeof(char[256]), "%8.2f msec", get_average(&(ms->rtd[i].tot), ms->rtd[i].num));
g_snprintf(str[5], sizeof(char[256]), "%6u", ms->rtd[i].min_num);
g_snprintf(str[6], sizeof(char[256]), "%6u", ms->rtd[i].max_num);
gtk_clist_append(ms->table, str);
}
gtk_widget_show(GTK_WIDGET(ms->table));
for(i=0; i<7; i++) {
g_free(str[i]);
}
}
/* Displays contents of a directory in the file list */
void
filelist_populate( GNode *dnode )
{
GNode *node;
GList *node_list = NULL, *node_llink;
Icon *icon;
int row, count = 0;
char *empty_row[] = { NULL };
char strbuf[64];
g_assert( NODE_IS_DIR(dnode) );
/* Get an alphabetized list of directory's immediate children */
node = dnode->children;
while (node != NULL) {
G_LIST_PREPEND(node_list, node);
node = node->next;
}
G_LIST_SORT(node_list, compare_node);
/* Update file clist */
gtk_clist_freeze( GTK_CLIST(file_clist_w) );
gtk_clist_clear( GTK_CLIST(file_clist_w) );
node_llink = node_list;
while (node_llink != NULL) {
node = (GNode *)node_llink->data;
row = gtk_clist_append( GTK_CLIST(file_clist_w), empty_row );
icon = &node_type_mini_icons[NODE_DESC(node)->type];
gtk_clist_set_pixtext( GTK_CLIST(file_clist_w), row, 0, NODE_DESC(node)->name, 2, icon->pixmap, icon->mask );
gtk_clist_set_row_data( GTK_CLIST(file_clist_w), row, node );
++count;
node_llink = node_llink->next;
}
gtk_clist_thaw( GTK_CLIST(file_clist_w) );
g_list_free( node_list );
/* Set node count message in the left statusbar */
switch (count) {
case 0:
strcpy( strbuf, "" );
break;
case 1:
strcpy( strbuf, _("1 node") );
break;
default:
sprintf( strbuf, _("%d nodes"), count );
break;
}
window_statusbar( SB_LEFT, strbuf );
filelist_current_dnode = dnode;
filelist_reset_access( );
}
/* User clicked the "Clear List" button. */
void button_clear_clicked( gpointer data )
{
/* Clear the list using gtk_clist_clear. This is much faster than
* calling gtk_clist_remove once for each row.
*/
gtk_clist_clear ((GtkCList *)data);
return;
}
static void
url_button_clear (void)
{
while (url_list)
{
free (url_list->data);
url_list = g_slist_remove (url_list, url_list->data);
}
gtk_clist_clear (GTK_CLIST (urlgrabberlist));
}
void
remove_files_window (gftp_window_data * wdata)
{
wdata->show_selected = 0;
gtk_clist_freeze (GTK_CLIST (wdata->listbox));
gtk_clist_clear (GTK_CLIST (wdata->listbox));
free_file_list (wdata->files);
wdata->files = NULL;
gtk_clist_thaw (GTK_CLIST (wdata->listbox));
}
void MedSLTDocWindow::ResetTextList()
{
ACE_TRACE("[MedSLTDocWindow::ResetTextList()]");
gtk_clist_clear((GtkCList*)m_list);
m_list_items = 0;
m_back_translation = "";
return;
}
void prefs_display_items_dialog_set_visible(PrefsDisplayItemsDialog *dialog,
const gint *ids)
{
GtkCList *shown_clist = GTK_CLIST(dialog->shown_clist);
GList *cur;
PrefsDisplayItem *item;
gint i;
gint row;
gchar *name;
g_return_if_fail(dialog->available_items != NULL);
if (!ids)
ids = dialog->default_visible_ids;
g_return_if_fail(ids != NULL);
gtk_clist_clear(shown_clist);
if (dialog->visible_items) {
g_list_free(dialog->visible_items);
dialog->visible_items = NULL;
}
for (cur = dialog->available_items; cur != NULL; cur = cur->next) {
item = cur->data;
item->in_use = FALSE;
}
for (i = 0; ids[i] != -1; i++) {
gint id = ids[i];
item = prefs_display_items_get_item_from_id(dialog, id);
g_return_if_fail(item != NULL);
g_return_if_fail(item->allow_multiple || item->in_use == FALSE);
item->in_use = TRUE;
name = gettext(item->label);
row = gtk_clist_append(shown_clist, (gchar **)&name);
gtk_clist_set_row_data(shown_clist, row, item);
}
name = "--------";
row = gtk_clist_append(shown_clist, (gchar **)&name);
gtk_widget_ensure_style(GTK_WIDGET(shown_clist));
gtk_clist_set_foreground
(shown_clist, row,
>K_WIDGET(shown_clist)->style->text[GTK_STATE_INSENSITIVE]);
prefs_display_items_update_available(dialog);
prefs_display_items_set_sensitive(dialog);
gtk_clist_moveto(shown_clist, 0, 0, 0, 0);
}
void
gradient_select_free_all (void)
{
GradientSelect *gsp;
GSList *list;
for (list = gradient_active_dialogs; list; list = g_slist_next (list))
{
gsp = (GradientSelect *) list->data;
gtk_clist_clear (GTK_CLIST (gsp->clist));
}
}
void
update_list(void)
{
GList *pt;
struct logentry *le;
char tmp[8][128];
gchar *pp[8];
int ontime,h,m,s,i;
int lc;
gtk_clist_freeze(GTK_CLIST(loglist));
gtk_clist_clear(GTK_CLIST(loglist));
for(i=0;i<8;i++)
pp[i]=tmp[i];
for(lc=0,pt=log;pt!=NULL;pt=g_list_next(pt),lc++) {
le=(struct logentry *)(pt->data);
strcpy(tmp[0],ctime(&(le->start)));
strcpy(tmp[1],ctime(&(le->end)));
ontime=(int)(le->end - le->start);
h=ontime/3600;
ontime-=3600*h;
m=ontime/60;
ontime-=60*m;
s=ontime;
sprintf(tmp[2],"%.4d:%.2d:%.2d",h,m,s);
switch(le->status) {
case 0:
strcpy(tmp[3],"OK");
break;
case 1:
strcpy(tmp[3],"Error");
break;
default:
strcpy(tmp[3],"Crash");
}
strcpy(tmp[4],le->shortname);
strcpy(tmp[5],le->longname);
strcpy(tmp[6],le->phone);
strcpy(tmp[7],le->user);
gtk_clist_append(GTK_CLIST(loglist),pp);
gtk_clist_set_pixtext(GTK_CLIST(loglist),lc,3,
tmp[3],6,
iconmap[le->status%3],
maskmap[le->status%3]);
}
gtk_clist_thaw(GTK_CLIST(loglist));
}
void CheckDir( GtkWidget * list,char * directory )
{
struct stat fs;
int i;
glob_t gg;
if ( !fsFilter[0] ) return;
gtk_widget_hide( list );
gtk_clist_clear( GTK_CLIST( list ) );
clist_append_fname(list, ".", dpixmap, dmask);
clist_append_fname(list, "..", dpixmap, dmask);
glob( "*",0,NULL,&gg );
for( i=0;(unsigned)i<gg.gl_pathc;i++ )
{
stat( gg.gl_pathv[i],&fs );
if( !S_ISDIR( fs.st_mode ) ) continue;
clist_append_fname(list, gg.gl_pathv[i], dpixmap, dmask);
}
globfree( &gg );
if ( strchr( fsFilter,',' ) )
{
char tmp[8];
int i,c,glob_param = 0;
for ( i=0,c=0;i<(int)strlen( fsFilter ) + 1;i++,c++ )
{
tmp[c]=fsFilter[i];
if ( ( tmp[c] == ',' )||( tmp[c] == '\0' ) )
{
tmp[c]=0; c=-1;
glob( Filter( tmp ),glob_param,NULL,&gg );
glob_param=GLOB_APPEND;
}
}
} else glob( Filter( fsFilter ),0,NULL,&gg );
for( i=0;(unsigned)i<gg.gl_pathc;i++ )
{
stat( gg.gl_pathv[i],&fs );
if( S_ISDIR( fs.st_mode ) ) continue;
clist_append_fname(list, gg.gl_pathv[i], fpixmap, fmask);
}
globfree( &gg );
gtk_clist_set_column_width( GTK_CLIST( list ),0,17 );
gtk_clist_select_row( GTK_CLIST( list ),0,1 );
gtk_widget_show( list );
}
void widget_table_clear(variable *var)
{
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
#if !GTK_CHECK_VERSION(3,0,0) /* gtk3: Deprecated in gtk2 and now gone */
gtk_clist_clear(GTK_CLIST(var->Widget));
#endif
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
void capture_start(GtkWidget *widget,gpointer data)
{
GtkWidget *isenable;
uint8_t i = 0;
guint text_len = 0;
pthread_mutex_lock(&capture_state_mtx);
if (capture_state == 0)
capture_state = 1;
pthread_mutex_unlock(&capture_state_mtx);
init_file();
capture_packet();
pthread_mutex_lock(&packet_stat_mtx);
tot_packet = 0;
ip_packet = 0;
tcp_packet = 0;
udp_packet = 0;
arp_packet = 0;
icmp_packet = 0;
igmp_packet = 0;
capture_pre_packet = 0;
pthread_mutex_unlock(&packet_stat_mtx);
isenable = capture_menu[0].widget;
gtk_widget_set_sensitive(isenable,FALSE);
isenable = capture_menu[1].widget;
gtk_widget_set_sensitive(isenable,TRUE);
gtk_clist_clear((GtkCList *)clist);
for (i = 0;i < 5;i++)
{
if (item[i]) {
gtk_tree_item_remove_subtree((GtkTreeItem *)item[i]);
gtk_container_remove (GTK_CONTAINER(tree), item[i]);
item[i] = NULL;
}
}
gtk_text_freeze(GTK_TEXT(hex_text));
text_len = gtk_text_get_length(GTK_TEXT(hex_text));
gtk_text_backward_delete(GTK_TEXT(hex_text),text_len);
gtk_text_thaw(GTK_TEXT(hex_text));
gtk_text_freeze(GTK_TEXT(hex_text));
text_len = gtk_text_get_length(GTK_TEXT(hex_text));
gtk_text_backward_delete(GTK_TEXT(hex_text),text_len);
gtk_text_thaw(GTK_TEXT(hex_text));
}
AddressBookFile *addressbook_imp_ldif( AddressIndex *addrIndex ) {
_importedBook_ = NULL;
_imp_addressIndex_ = addrIndex;
if( ! impldif_dlg.window )
imp_ldif_create();
impldif_dlg.cancelled = FALSE;
manage_window_set_transient(GTK_WINDOW(impldif_dlg.window));
gtk_widget_grab_default(impldif_dlg.btnNext);
gtk_entry_set_text( GTK_ENTRY(impldif_dlg.name_entry), IMPORTLDIF_GUESS_NAME );
gtk_entry_set_text( GTK_ENTRY(impldif_dlg.file_entry), "" );
gtk_label_set_text( GTK_LABEL(impldif_dlg.name_ldif), "" );
gtk_entry_set_text( GTK_ENTRY(impldif_dlg.name_attrib), "" );
gtk_clist_clear( GTK_CLIST(impldif_dlg.clist_field) );
gtk_notebook_set_current_page( GTK_NOTEBOOK(impldif_dlg.notebook), PAGE_FILE_INFO );
gtk_widget_set_sensitive( impldif_dlg.btnPrev, FALSE );
gtk_widget_set_sensitive( impldif_dlg.btnNext, TRUE );
gtk_button_set_label( GTK_BUTTON(impldif_dlg.btnCancel), GTK_STOCK_CANCEL );
stock_pixmap_gdk( impldif_dlg.window, STOCK_PIXMAP_MARK,
&markxpm, &markxpmmask );
imp_ldif_message();
gtk_widget_grab_focus(impldif_dlg.file_entry);
impldif_dlg.rowIndSelect = -1;
impldif_dlg.rowCount = 0;
g_free( impldif_dlg.nameBook );
g_free( impldif_dlg.fileName );
impldif_dlg.nameBook = NULL;
impldif_dlg.fileName = NULL;
_ldifFile_ = ldif_create();
gtk_widget_show(impldif_dlg.window);
gtk_main();
gtk_widget_hide(impldif_dlg.window);
ldif_free( _ldifFile_ );
_ldifFile_ = NULL;
_imp_addressIndex_ = NULL;
g_free( impldif_dlg.nameBook );
g_free( impldif_dlg.fileName );
impldif_dlg.nameBook = NULL;
impldif_dlg.fileName = NULL;
if( impldif_dlg.cancelled == TRUE ) return NULL;
return _importedBook_;
}
static int mod_update(void)
{
char *module= NULL;
/* Update the mod stuff */
if (GTK_CLIST(modules)->selection) {
module= (char *)gtk_clist_get_row_data(GTK_CLIST(modules), (int) GTK_CLIST(modules)->selection->data);
}
gtk_clist_freeze(GTK_CLIST(modules));
gtk_clist_clear(GTK_CLIST(modules));
ast_update_module_list(add_mod, NULL);
if (module)
gtk_clist_select_row(GTK_CLIST(modules), gtk_clist_find_row_from_data(GTK_CLIST(modules), module), -1);
gtk_clist_thaw(GTK_CLIST(modules));
return 1;
}
static void prefs_display_header_set_dialog(void)
{
GtkCList *clist = GTK_CLIST(dispheader.headers_clist);
GtkCList *hidden_clist = GTK_CLIST(dispheader.hidden_headers_clist);
GSList *cur;
gchar *dp_str[1];
gint row;
gtk_clist_freeze(clist);
gtk_clist_freeze(hidden_clist);
gtk_clist_clear(clist);
gtk_clist_clear(hidden_clist);
for (cur = prefs_common.disphdr_list; cur != NULL;
cur = cur->next) {
DisplayHeaderProp *dp = (DisplayHeaderProp *)cur->data;
dp_str[0] = dp->name;
if (dp->hidden) {
row = gtk_clist_append(hidden_clist, dp_str);
gtk_clist_set_row_data(hidden_clist, row, dp);
} else {
row = gtk_clist_append(clist, dp_str);
gtk_clist_set_row_data(clist, row, dp);
}
}
gtk_clist_thaw(hidden_clist);
gtk_clist_thaw(clist);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(dispheader.other_headers),
prefs_common.show_other_header);
}
