Esempio n. 1
0
static void clist_selected(GtkWidget *widget, gint row, gint column,
	GdkEventButton *event, gpointer data)
{
    int connect_sensitive = 0;
    int disconnect_sensitive = 0;
    int forget_sensitive = 0;
    int verify_sensitive = 0;
    Fingerprint *f = gtk_clist_get_row_data(GTK_CLIST(ui_layout.keylist),
	    row);
    ConnContext *context_iter;

    if (f) {
	verify_sensitive = 1;
	forget_sensitive = 1;

	if (f->context && f->context->m_context) {
	    for (context_iter = f->context;
		    context_iter && context_iter->m_context ==
		    f->context->m_context;
		    context_iter = context_iter->next) {

		if (context_iter->msgstate == OTRL_MSGSTATE_ENCRYPTED &&
		    context_iter->active_fingerprint == f) {
		    disconnect_sensitive = 1;
		    forget_sensitive = 0;
		}
		else if (context_iter->msgstate == OTRL_MSGSTATE_FINISHED) {
		    disconnect_sensitive = 1;
		    connect_sensitive = 1;
		}
		else if (context_iter->msgstate == OTRL_MSGSTATE_PLAINTEXT) {
		    connect_sensitive = 1;
		}
	    }
	}
    }

    gtk_widget_set_sensitive(ui_layout.connect_button,
	    connect_sensitive);
    gtk_widget_set_sensitive(ui_layout.disconnect_button,
	    disconnect_sensitive);
    gtk_widget_set_sensitive(ui_layout.forget_button, forget_sensitive);
    gtk_widget_set_sensitive(ui_layout.verify_button, verify_sensitive);
    ui_layout.selected_fprint = f;
}
Esempio n. 2
0
static void add_filter_callback_2(GtkWidget *widget, GtkWidget *nothing)
{
int i;
GtkCList *cl;

if(!GLOBALS->filesel_ok) { return; }

if(*GLOBALS->fileselbox_text)
	{
	for(i=0;i<GLOBALS->num_ttrans_filters;i++)
		{
		if(GLOBALS->ttranssel_filter[i])
			{
			if(!strcmp(GLOBALS->ttranssel_filter[i], *GLOBALS->fileselbox_text)) 
				{
				status_text("Filter already imported.\n");
				if(GLOBALS->is_active_ttranslate_c_2) gdk_window_raise(GLOBALS->window_ttranslate_c_5->window);
				return;
				}
			}
		}
	}

GLOBALS->num_ttrans_filters++;
load_ttrans_filter(GLOBALS->num_ttrans_filters, *GLOBALS->fileselbox_text);
if(GLOBALS->ttrans_filter[GLOBALS->num_ttrans_filters])
	{
	if(GLOBALS->ttranssel_filter[GLOBALS->num_ttrans_filters]) free_2(GLOBALS->ttranssel_filter[GLOBALS->num_ttrans_filters]);
	GLOBALS->ttranssel_filter[GLOBALS->num_ttrans_filters] = malloc_2(strlen(*GLOBALS->fileselbox_text) + 1);
	strcpy(GLOBALS->ttranssel_filter[GLOBALS->num_ttrans_filters], *GLOBALS->fileselbox_text);

	cl=GTK_CLIST(GLOBALS->clist_ttranslate_c_2);
	gtk_clist_freeze(cl);
	gtk_clist_append(cl,(gchar **)&(GLOBALS->ttranssel_filter[GLOBALS->num_ttrans_filters]));

	gtk_clist_set_column_width(cl,0,gtk_clist_optimal_column_width(cl,0));
	gtk_clist_thaw(cl);
	}
	else
	{
	GLOBALS->num_ttrans_filters--;
	}

if(GLOBALS->is_active_ttranslate_c_2) gdk_window_raise(GLOBALS->window_ttranslate_c_5->window);
}
void
gradient_select_rename_all (gradient_t *gradient)
{
  GradientSelect *gsp; 
  GSList         *list;
  gint            row;

  for (list = gradient_active_dialogs; list; list = g_slist_next (list))
    {
      gsp = (GradientSelect *) list->data;

      row = gtk_clist_find_row_from_data (GTK_CLIST (gsp->clist), gradient);
		/*
      if (row > -1)
		  gtk_clist_set_text (GTK_CLIST (gsp->clist), row, 1, gradient->name);  
		*/
    }
}
Esempio n. 4
0
static void imp_ldif_modify_pressed( GtkWidget *widget, gpointer data ) {
	GtkCList *clist = GTK_CLIST(impldif_dlg.clist_field);
	Ldif_FieldRec *rec;
	gint row;

	if( impldif_dlg.rowIndSelect < 0 ) return;
	row = impldif_dlg.rowIndSelect;
	rec = gtk_clist_get_row_data( clist, impldif_dlg.rowIndSelect );

	g_free( rec->userName );
	rec->userName = gtk_editable_get_chars( GTK_EDITABLE(impldif_dlg.name_attrib), 0, -1 );
	rec->selected = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( impldif_dlg.check_select) );
	imp_ldif_update_row( clist );
	gtk_clist_select_row( clist, row, 0 );
	gtk_label_set_text( GTK_LABEL(impldif_dlg.name_ldif), "" );
	gtk_entry_set_text( GTK_ENTRY(impldif_dlg.name_attrib), "" );
	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( impldif_dlg.check_select), FALSE );
}
Esempio n. 5
0
GtkWidget *gtk_clist_new(gint columns)
{
  GtkCList *clist;
  int i;

  clist = GTK_CLIST(GtkNewObject(&GtkCListClass));
  clist->cols = columns;
  clist->coldata = g_new0(GtkCListColumn, columns);
  clist->rows = 0;
  clist->rowdata = NULL;
  for (i = 0; i < columns; i++) {
    clist->coldata[i].width = 0;
    clist->coldata[i].visible = TRUE;
    clist->coldata[i].resizeable = TRUE;
  }

  return GTK_WIDGET(clist);
}
Esempio n. 6
0
void
on_rule_new_rule_clicked (GtkButton * button, gpointer UNUSED(user_data))
{
    rule *r;
    int x;
    GtkCList *clist;

    r = (rule *) malloc (sizeof (rule));
    r->regex = g_strdup ("");
    r->mbox = g_strdup ("Inbox");
    r->name = g_strdup ("New rule");
    r->piece = g_strdup ("Header");
    clist = GTK_CLIST (lookup_widget (GTK_WIDGET (button), "clist1"));
    x = clist->rows;
    gtk_clist_insert (clist, x, &(r->name));
    gtk_clist_set_row_data (clist, x, r);
    gtk_clist_select_row (clist, x, 0);
}
Esempio n. 7
0
/**
 * Update the row with the given nodeinfo. If row is -1 the row number
 * is determined by the node_id contained in the gnet_node_info_t.
 */
static void
nodes_gui_update_node_info(gnet_node_info_t *n, gint row)
{
    GtkCList *clist = GTK_CLIST(gui_main_window_lookup("clist_nodes"));

    g_assert(n != NULL);

    if (row == -1) {
        row = gtk_clist_find_row_from_data(clist,
					deconstify_gpointer(n->node_id));
    }

    if (row != -1) {
		gchar ver_buf[64];
        gnet_node_status_t status;
        time_t now = tm_time();

        if (guc_node_get_status(n->node_id, &status)) {
			gtk_clist_set_text(clist, row, c_gnet_user_agent,
					n->vendor ? lazy_utf8_to_locale(n->vendor) : "...");

			gtk_clist_set_text(clist, row, c_gnet_loc,
					deconstify_gchar(iso3166_country_cc(n->country)));

			str_bprintf(ver_buf, sizeof ver_buf, "%d.%d",
					n->proto_major, n->proto_minor);
			gtk_clist_set_text(clist, row, c_gnet_version, ver_buf);

			if (status.status == GTA_NODE_CONNECTED)
				gtk_clist_set_text(clist, row, c_gnet_connected,
						short_uptime(delta_time(now, status.connect_date)));

			if (status.up_date)
				gtk_clist_set_text(clist, row, c_gnet_uptime,
						status.up_date
						? short_uptime(delta_time(now, status.up_date)) : "...");

			gtk_clist_set_text(clist, row, c_gnet_info,
					nodes_gui_common_status_str(&status));
		}
    } else {
        g_warning("%s(): no matching row found", G_STRFUNC);
    }
}
Esempio n. 8
0
static void widget_table_input_by_command(variable *var, char *filename,
	gint command_or_file)
{
	FILE             *infile;
	gchar             line[512];
	gint              count;
	list_t           *sliced;

#ifdef DEBUG_TRANSITS
	fprintf(stderr, "%s(): Entering.\n", __func__);
#endif

#if !GTK_CHECK_VERSION(3,0,0)	/* gtk3: Deprecated in gtk2 and now gone */
	if (command_or_file) {
		infile = widget_opencommand(filename);
	} else {
		infile = fopen(filename, "r");
	}

	/* Opening pipe for reading... */
	if (infile) {
		/* Read the file one line at a time (trailing [CR]LFs are read too) */
		while (fgets(line, 512, infile) != NULL) {
			/* Enforce end of string in case of max chars read */
			line[512 - 1] = 0;
			/* Remove the trailing [CR]LFs */
			for (count = strlen(line) - 1; count >= 0; count--)
				if (line[count] == 13 || line[count] == 10) line[count] = 0;
			sliced = linecutter(g_strdup(line), '|');
			gtk_clist_append(GTK_CLIST(var->Widget), sliced->line);
			if (sliced) list_t_free(sliced);	/* Free linecutter memory */
		}
		/* Close the file */
		pclose(infile);
	} else {
		fprintf(stderr, "%s(): Couldn't open '%s' for reading.\n", __func__,
			filename);
	}
#endif

#ifdef DEBUG_TRANSITS
	fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
static void
update_row (int               row,
	    XSettingsSetting *setting)
{
  char buffer[256];
  GtkStyle *style;
  const char *type;
  
  if (setting->type != XSETTINGS_TYPE_COLOR)
    gtk_clist_set_cell_style (GTK_CLIST (settings_clist),
			      row, VALUE, NULL);

  switch (setting->type)
    {
    case XSETTINGS_TYPE_INT:
      type = "INT";
      sprintf (buffer, "%d", setting->data.v_int);
      gtk_clist_set_text (GTK_CLIST (settings_clist), row, VALUE, buffer);      
      break;
    case XSETTINGS_TYPE_STRING:
      type = "STRING";
      gtk_clist_set_text (GTK_CLIST (settings_clist), row, VALUE, setting->data.v_string);
      break;
    case XSETTINGS_TYPE_COLOR:
      type = "COLOR";
      gtk_clist_set_text (GTK_CLIST (settings_clist), row, VALUE, "");
      style = gtk_style_copy (settings_clist->style);
      style->base[GTK_STATE_NORMAL].red = setting->data.v_color.red;
      style->base[GTK_STATE_NORMAL].green = setting->data.v_color.green;
      style->base[GTK_STATE_NORMAL].blue = setting->data.v_color.blue;
      style->bg[GTK_STATE_SELECTED].red = setting->data.v_color.red;
      style->bg[GTK_STATE_SELECTED].green = setting->data.v_color.green;
      style->bg[GTK_STATE_SELECTED].blue = setting->data.v_color.blue;
      gtk_clist_set_cell_style (GTK_CLIST (settings_clist),
				row, VALUE, style);
      gtk_style_unref (style);
      break;
    default:
      g_assert_not_reached ();
    }

  gtk_clist_set_text (GTK_CLIST (settings_clist), row, TYPE, type);

  sprintf (buffer, "%ld", setting->last_change_serial);
  gtk_clist_set_text (GTK_CLIST (settings_clist), row, SERIAL, buffer);
}
Esempio n. 10
0
static void eqSetChannelNames( void )
{
 gchar * str[2];
 gtk_clist_clear( GTK_CLIST( ChannelsList ) );
 str[1]="";
 str[0]=MSGTR_EQU_All;
 gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
 if ( guiIntfStruct.AudioType > 1 )
  {
   str[0]=gtkEquChannel1; gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
   str[0]=gtkEquChannel2; gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
  }
 if ( guiIntfStruct.AudioType > 2 )
  {
   str[0]=gtkEquChannel3; gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
   str[0]=gtkEquChannel4; gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
  }
 if ( guiIntfStruct.AudioType > 4 )
  {
   str[0]=gtkEquChannel5; gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
   str[0]=gtkEquChannel6; gtk_clist_append( GTK_CLIST( ChannelsList ) ,str);
  }
 gtk_clist_select_row( GTK_CLIST( ChannelsList ),0,0 );
}
Esempio n. 11
0
static void
gnc_query_list_toggle (GNCQueryList *list)
{
    gpointer entry;
    gint row;

    g_return_if_fail (IS_GNC_QUERY_LIST(list));

    if (list->no_toggle)
        return;

    row = list->current_row;
    entry = gtk_clist_get_row_data (GTK_CLIST(list), row);
    list->current_entry = entry;

    g_signal_emit (list, query_list_signals[LINE_TOGGLED], 0, entry);

    update_booleans (list, row);
}
Esempio n. 12
0
static void
gnc_query_list_column_title (GNCQueryList *list, gint column, const gchar *title)
{
    GtkWidget *hbox, *label, *arrow;

    hbox = gtk_hbox_new(FALSE, 2);
    gtk_widget_show(hbox);
    gtk_clist_set_column_widget(GTK_CLIST(list), column, hbox);

    label = gtk_label_new(title);
    gtk_widget_show(label);
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

    arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_ETCHED_IN);
    list->title_arrows[column] = arrow;
    if (column == 0)
        gtk_widget_show(arrow);
    gtk_box_pack_end(GTK_BOX(hbox), arrow, FALSE, FALSE, 0);
}
Esempio n. 13
0
void
on_button_uploads_kill_clicked(GtkButton *unused_button, gpointer unused_udata)
{
    GSList *sl = NULL;
    GtkCList *clist;

	(void) unused_button;
	(void) unused_udata;

    clist = GTK_CLIST(gui_main_window_lookup("clist_uploads"));

    gtk_clist_freeze(clist);

    sl = clist_collect_data(clist, FALSE, NULL);
    g_slist_foreach(sl, kill_upload, NULL);
    g_slist_free(sl);

    gtk_clist_thaw(clist);
}
Esempio n. 14
0
File: xqf-ui.c Progetto: IR4T4/xqf
GtkWidget *create_source_ctree (GtkWidget *scrollwin) {
	char *titles[1] = { _("Source") };
	GtkWidget *ctree;

/*	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
*/
	ctree = gtk_ctree_new_with_titles (1, 0, titles);
	gtk_container_add (GTK_CONTAINER (scrollwin), ctree);

	gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);

	gtk_ctree_set_line_style (GTK_CTREE (ctree), GTK_CTREE_LINES_NONE);
	gtk_ctree_set_expander_style (GTK_CTREE (ctree), GTK_CTREE_EXPANDER_TRIANGLE);
	gtk_ctree_set_indent (GTK_CTREE (ctree), 10);

	fill_source_ctree (ctree);

	return ctree;
}
static int
find_row (const char *name)
{
  GList *tmp_list = GTK_CLIST (settings_clist)->row_list;
  int index = 0;
  
  while (tmp_list)
    {
      GtkCListRow *row = GTK_CLIST_ROW (tmp_list);

      if (strcmp (row->data, name) == 0)
	return index;
	
      tmp_list = tmp_list->next;
      index++;
    }

  return -1;
}
Esempio n. 16
0
void on_main_popup_delete_activate(GtkMenuItem * menuitem, gpointer user_data)
{
    gint row, col;
    popup_info_t *info;

    fprintf( stderr, "on_main_popup_delete_activate\n" );

    if (info = (popup_info_t *) user_data)
    {
        gtk_clist_get_selection_info(GTK_CLIST(main_clist),
                                     info->x, info->y, &row, &col);

        //printf("bloa! (x %d y %d is row %d col %d)\n");
    }
    else
        printf("%s",
               _("Oops.  NULL info in on_main_popup_delete_activate\n"));

}
void add_selected_to_playlist_and_play(void) {
  int i;
  int playnow = 1;
  
  

  for(i=0; i<row_count; i++) {
    struct entry *d = 
      (struct entry*)gtk_clist_get_row_data(GTK_CLIST(file_list), i);

    if( d->selected ) {
      	if (!playnow) 	add_to_playlist(i);
	else {
		playnow = 0;
		add_to_playlist_and_play(i);
	}
      }
  }
}
void add_to_playlist(gint row)
{
  DEBUG_MSG("add_to_playlist");
  gchar *text;
  GList *list = NULL;
  struct entry *d = ((struct entry*) gtk_clist_get_row_data(GTK_CLIST(file_list),row));

  if( d == NULL ) {
    DEBUG_MSG("WRONG\n");
    return;
  }

  text = d->filename;

  list = g_list_append(list, text);
  
  xmms_remote_playlist_add(cue_gp.xmms_session, list);
  DEBUG_MSG("add_to_playlist finished");
}
Esempio n. 19
0
File: fkeys.c Progetto: n2i/xvnkb
static void
key_dialog_sel_row (GtkWidget * clist, gint row, gint column,
						  GdkEventButton * evt, gpointer data)
{
	struct key_binding *kb = gtk_clist_get_row_data (GTK_CLIST (clist), row);

	if (kb == NULL)
	{
		printf ("*** key_dialog_sel_row: kb == NULL\n");
		abort ();
	}
	if (kb->action > -1 && kb->action <= KEY_MAX_ACTIONS)
	{
		gtk_option_menu_set_history (GTK_OPTION_MENU (key_dialog_act_menu),
											  kb->action);
		if (key_actions[kb->action].help)
		{
			key_print_text (GTK_XTEXT (key_dialog_text), _(key_actions[kb->action].help));
		}
	}
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (key_dialog_tog_c),
										  (kb->mod & STATE_CTRL) == STATE_CTRL);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (key_dialog_tog_s),
										  (kb->mod & STATE_SHIFT) == STATE_SHIFT);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (key_dialog_tog_a),
										  (kb->mod & STATE_ALT) == STATE_ALT);

	if (kb->data1)
		gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d1), kb->data1);
	else
		gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d1), "");

	if (kb->data2)
		gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d2), kb->data2);
	else
		gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d2), "");

	if (kb->keyname)
		gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_key), kb->keyname);
	else
		gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_key), "");
}
Esempio n. 20
0
void
url_opengui ()
{
	GtkWidget *vbox, *hbox;
	GSList *list;

	if (urlgrabberwindow)
	{
		wins_bring_tofront (urlgrabberwindow);
		return;
	}

	urlgrabberwindow =
		maingui_window ("urlgrabber", _("X-Chat: URL Grabber"), FALSE, TRUE,
							 url_closegui, NULL, 350, 100, &urlgrabberwindow);
	vbox = wins_get_vbox (urlgrabberwindow);

	urlgrabberlist = gtkutil_clist_new (1, 0, vbox, GTK_POLICY_AUTOMATIC,
													0, 0, 0, 0, GTK_SELECTION_BROWSE);
	gtk_signal_connect (GTK_OBJECT (urlgrabberlist), "button_press_event",
							  GTK_SIGNAL_FUNC (url_clicklist), 0);
	gtk_widget_set_usize (urlgrabberlist, 350, 0);
	gtk_clist_set_column_width (GTK_CLIST (urlgrabberlist), 0, 100);

	hbox = gtk_hbox_new (FALSE, 1);
	gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
	gtk_widget_show (hbox);

	gtkutil_button (urlgrabberwindow, GNOME_STOCK_PIXMAP_CLEAR,
						 _("Clear"), url_button_clear, 0, hbox);
	gtkutil_button (urlgrabberwindow, GNOME_STOCK_PIXMAP_SAVE,
						 _("Save"), url_button_save, 0, hbox);

	gtk_widget_show (urlgrabberwindow);

	list = url_list;
	while (list)
	{
		url_addurlgui ((char *) list->data);
		list = list->next;
	}
}
Esempio n. 21
0
void add_ipvs_server(advertised_service *a, char *addr){
   back_end_server *last_be=NULL;
   ipvs_server *last_ipvs=NULL;
   ipvs_server *ipvs;
   gchar *s_text[1];
   GList *list_last;

   extern GtkWidget *ipvs_server_clist;

   ipvs = g_malloc(sizeof(ipvs_server));

   if((list_last=g_list_last(a->ipvs_servers))==NULL){
      if((list_last=g_list_last(a->back_end_servers))!=NULL){
         last_be=(back_end_server *)list_last->data;
      }
   }
   else{
      last_ipvs=(ipvs_server *)list_last->data;
   }

   if(strcmp(addr, IP_ADDR_NEXT)){
      ipvs->address=g_strdup(addr);
   }
   else{
      if(last_ipvs==NULL){
         if(last_be==NULL){
            ipvs->address=ip_addr_next(a->address);
         }
         else{
            ipvs->address=ip_addr_next(last_be->address);
         }
      }
      else{
         ipvs->address=ip_addr_next(last_ipvs->address);
      }
   }

   a->ipvs_servers = g_list_append(a->ipvs_servers, ipvs);

   s_text[0] = ipvs->address;
   gtk_clist_append(GTK_CLIST(ipvs_server_clist), s_text);
}
Esempio n. 22
0
void
on_rule_apply_clicked (GtkButton * button, gpointer UNUSED(user_data))
{
    rule **rulelist;
    GtkCList *clist;
    int length, x;

    clist = GTK_CLIST (lookup_widget (GTK_WIDGET (button), "clist1"));
    length = clist->rows + 1;
    rulelist = (void *)malloc (sizeof (void *) * length);

    for (x = 0; x < length; x++)
	rulelist[x] = gtk_clist_get_row_data (clist, x);

    db_set_rules (rulelist);
    free (rulelist);

    gnome_o_put_the_damn_rules_in_the_box (GTK_WIDGET (button));
    return;
}
Esempio n. 23
0
static void pattern_clist_row_move_callback (GtkWidget *widget, 
                                                       int source, int dest, gpointer data) {
  GtkCList *clist = GTK_CLIST (widget);
  GSList *link;
  struct player_pattern *pp;

  debug(5,"pattern_clist_row_move_callback(widget=%d,source=%d,dest=%d)",widget,source,dest);

  if (source < 0 || dest < 0 || source == dest || 
                                 source > clist->rows || dest > clist->rows) {
    return;
  }

  link = g_slist_nth (curplrs, source);
  pp = (struct player_pattern *) link->data;
  curplrs = g_slist_remove_link (curplrs, link);
  curplrs = g_slist_insert (curplrs, pp, dest);

  current_row = dest;
}
static void
file_selection_dir_button (GtkWidget *widget,
			   gint row, 
			   gint column, 
			   GdkEventButton *bevent,
			   gpointer user_data)
{
    gchar *k = NULL;
    static gchar t[256];

    gtk_clist_get_text (GTK_CLIST (widget), row, 0, &k);

    if(k != NULL) {
	strncpy(t, k, 255);
	t[255] = 0;

	gtk_file_selection_set_filename (GTK_FILE_SELECTION(user_data),
					 t);
    }
}
Esempio n. 25
0
static gint mimeview_button_pressed(GtkWidget *widget, GdkEventButton *event,
				    MimeView *mimeview)
{
	GtkCList *clist = GTK_CLIST(widget);
	gint row, column;

	if (!event) return FALSE;

	if (event->button == 2 || event->button == 3) {
		if (!gtk_clist_get_selection_info(clist, event->x, event->y,
						  &row, &column))
			return FALSE;
		gtk_clist_unselect_all(clist);
		gtk_clist_select_row(clist, row, column);
		gtkut_clist_set_focus_row(clist, row);
	}
	part_button_pressed(mimeview, event, mimeview_get_selected_part(mimeview));

	return TRUE;
}
void
x_listbox_select_nth (WListbox *l, int nth)
{
	static int inside;
	GtkCList *clist;
	
	if (inside)
		return;

	if (!l->widget.wdata)
		return;
	
	inside = 1;
	clist = GTK_CLIST (listbox_pull (l->widget.wdata));
	
	gtk_clist_select_row (clist, nth, 0);
	if (gtk_clist_row_is_visible (clist, nth) != GTK_VISIBILITY_FULL)
		gtk_clist_moveto (clist, nth, 0, 0.5, 0.0);
	
	inside = 0;
}
Esempio n. 27
0
static void
send_row_selected (GtkWidget * clist, gint row, gint column,
						 GdkEventButton * even)
{
	struct DCC *dcc;

	if (even && even->type == GDK_2BUTTON_PRESS)
	{
		dcc = gtk_clist_get_row_data (GTK_CLIST (clist), row);
		if (dcc)
		{
			switch (dcc->dccstat)
			{
			case STAT_FAILED:
			case STAT_ABORTED:
			case STAT_DONE:
				dcc_abort (dcc);
			}
		}
	}
}
Esempio n. 28
0
/* If we come here, then the user has selected a row in the list. */
void selection_made( GtkWidget      *clist,
                     gint            row,
                     gint            column,
                     GdkEventButton *event,
                     gpointer        data )
{
    gchar *text;

    /* Get the text that is stored in the selected row and column
     * which was clicked in. We will receive it as a pointer in the
     * argument text.
     */
    gtk_clist_get_text(GTK_CLIST(clist), row, column, &text);

    /* Just prints some information about the selected row */
    g_print("You selected row %d. More specifically you clicked in "
            "column %d, and the text in this cell is %s\n\n",
            row, column, text);

    return;
}
Esempio n. 29
0
static void ssl_manager_view_cb(GtkWidget *widget, 
			      gpointer data) 
{
	SSLCertificate *cert;
	GList *rowlist;
	
	rowlist = GTK_CLIST(manager.certlist)->selection;
	if (!rowlist) 
		return;
	
	cert = gtk_ctree_node_get_row_data
			(GTK_CTREE(manager.certlist),
			 GTK_CTREE_NODE(rowlist->data));
	
	if (!cert)
		return;

	sslcertwindow_show_cert(cert);
	
	
}
Esempio n. 30
0
/*
 * Función notasWidget()
 */
GtkWidget *notasWidget(void) 
{
    GtkWidget *scroll;
    GtkWidget *notas;
    gchar     *notas_titulo[2] = {"índice", "contenido"};

    /* 
     * Se crea los componentes asociados a notas:
     * una ventana con barra de desplazamiento y una lista 
     */
    scroll = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
    gtk_widget_set_usize(scroll,150,200);
    
    notas=gtk_clist_new_with_titles (2,notas_titulo);
    datosAgenda.gtk_notas=notas;
    gtk_clist_set_shadow_type (GTK_CLIST(notas), GTK_SHADOW_OUT);
    gtk_container_add(GTK_CONTAINER(scroll), notas);

    return (scroll);
}