GTK Tree View # How to remove or hide the toggle button in column - gtk

There is defined a GTK tree view and one of the column is rendered the toggle button. Now every row is showing the toggle button, is there a way to remove or hide the toggle button from some row completely. For example I have following example
#include <gtk/gtk.h>
enum {
COL_NUM_LIST = 0,
COL_TOGGLE,
COL_STRING,
NUM_COLS
};
static GtkTreeModel*
create_and_fill_model(void) {
GtkTreeStore *treestore;
GtkTreeIter toplevel, child;
treestore = gtk_tree_store_new(NUM_COLS,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_STRING);
/* Append a top level row and leave it empty */
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
COL_NUM_LIST, "1",
COL_TOGGLE, TRUE,
COL_STRING, "Foo Bar",
-1);
/* Append a second top level row, and fill it with some data */
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
COL_NUM_LIST, "2",
COL_TOGGLE, TRUE,
COL_STRING, "", // empty
-1);
/* Append a child to the second top level row, and fill in some data */
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set(treestore, &child,
COL_NUM_LIST, "3",
COL_TOGGLE, FALSE,
COL_STRING, "Not needed toggle button here",
-1);
return GTK_TREE_MODEL(treestore);
}
void string_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data) {
char *string;
gtk_tree_model_get(model, iter, COL_STRING, &string, -1);
g_object_set(renderer, "text", string, NULL);
}
void toggle_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data) {
int bol;
gtk_tree_model_get(model, iter, COL_TOGGLE, &bol, -1);
if (bol == 0)
g_object_set(renderer, "active", NULL, NULL); // Can we somehow null or remove toggle button
else
g_object_set(renderer, "active", TRUE, NULL);
}
static GtkWidget*
create_view_and_model(void) {
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
GtkTreeModel *model;
view = gtk_tree_view_new();
// --- Column #1 ---
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "#");
/* pack tree view column into tree view */
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
// toggle renderer
renderer = gtk_cell_renderer_text_new();
/* pack cell renderer into tree view column */
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_NUM_LIST);
// --- Column #2 ---
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "Toggle");
/* pack tree view column into tree view */
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
// toggle renderer
renderer = gtk_cell_renderer_toggle_new();
/* pack cell renderer into tree view column */
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(col, renderer,
toggle_cell_data_func, NULL, NULL);
// --- Column #3 ---
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "String");
/* pack tree view column into tree view */
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
// text renderer
renderer = gtk_cell_renderer_text_new();
/* pack cell renderer into tree view column */
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(col, renderer,
string_cell_data_func, NULL, NULL);
model = create_and_fill_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model); /* destroy model automatically with view */
gtk_tree_selection_set_mode(
gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
GTK_SELECTION_NONE);
return view;
}
int main(int argc, char **argv) {
GtkWidget *window;
GtkWidget *view;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "delete_event", gtk_main_quit, NULL); /* dirty */
view = create_view_and_model();
gtk_container_add(GTK_CONTAINER(window), view);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
Compiled and run with GTK 3 , it creates following windows
So, I don't need toggle button at #3 leave of tree. How can I hide it.
P.S : I know that using GTK, I can set the state of button to disable or inconsistent, but can I completely hide it?

You could probably revise the properties you are setting via the "g_object_set" function as in the following code snippet.
void toggle_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
{
int bol;
gtk_tree_model_get(model, iter, COL_TOGGLE, &bol, -1);
if (bol == 0)
g_object_set(renderer, "visible", NULL, NULL); // Can we somehow null or remove toggle button
else
{
g_object_set(renderer, "visible", TRUE, "active", TRUE, NULL);
}
}
For the toggle button that should not appear, I utilized the "visible" property in lieu of the "active" property. That yielded the following sample image.
See if that helps.
Regards.

Related

GTK Main blocking Others threads.How to solve

I have 2 threads
1)Holds the GTK main and gtk screen display codes (code is explained below) 2)generates key events according to user rquirement
if() block i ported into my code. but result is same. Once the signal is generated .after that its not coming to 2nd thread(signal generation thread). Have put debug prints ,but its not happening Seems its waiting on gtk_main on first thread.
What my code is :
void S1(void)
{
GtkWidget *Win_1;
GtkBuilder *builder;
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, "/home/glade/glade1.glade", NULL);
window = GTK_WIDGET (gtk_builder_get_object (builder, "Win_1"));
g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), G_OBJECT(window));
g_signal_connect (G_OBJECT (window), "key_press_event", G_CALLBACK(kp_event), NULL);
gtk_widget_show_all(window);
gtk_main();
}
kp_event()
{
gtk_widget_destroy (window);
S2();
}
S2 is same as S1,only screen item difference.Am calling S2() from keypress handler of S1 & vice versa. Since i have no keyboards attached,need to change two screens base on some user input via sockets or something.
You may need to call gtk_main() just one time, and use gtk_widget_hide() and gtk_window_present(), instead of gtk_widget_destroy(), declaring window1 and window2 as global variables, and creating the two windows at startup. A sample code:
GtkWidget * window1;
GtkWidget * window2;
void S1() {
// create the window
window1 = GTK_WIDGET (gtk_builder_get_object (builder, "Win_1"));
// do not call gtk_main()
}
void S2() {
// create the window
window2 = GTK_WIDGET (gtk_builder_get_object (builder, "Win_2"));
// do not call gtk_main()
}
kp_event_S1() {
gtk_widget_hide(window1);
gtk_window_present(GTK_WINDOW(window2));
}
kp_event_S2() {
gtk_widget_hide(window2);
gtk_window_present(GTK_WINDOW(window1));
}
int main() {
gtk_init();
S1();
S2();
gtk_widget_hide(window2);
gtk_main();
}
If you don't want to use global variables, you can do:
GtkWidget * S1() {
// create the window
GtkWidget * window1 = GTK_WIDGET (gtk_builder_get_object (builder, "Win_1"));
return window1;
}
GtkWidget * S2() {
// create the window
GtkWidget * window2 = GTK_WIDGET (gtk_builder_get_object (builder, "Win_2"));
return window2;
}
gboolean kp_event_S1(GtkWidget * window, GdkEvent e, gpointer user_data) {
gtk_widget_hide(window);
gtk_window_present(GTK_WINDOW(user_data));
}
gboolean kp_event_S2(GtkWidget * window, GdkEvent e, gpointer user_data) {
gtk_widget_hide(window);
gtk_window_present(GTK_WINDOW(user_data));
}
int main() {
gtk_init();
GtkWidget * w1 = S1();
GtkWidget * w2 = S2();
gtk_widget_hide(w2);
g_signal_connect (G_OBJECT (w1), "key-press-event", G_CALLBACK(kp_event_S1), (gpointer)w2);
g_signal_connect (G_OBJECT (w2), "key-press-event", G_CALLBACK(kp_event_S2), (gpointer)w1);
gtk_main();
}

Function gtk_cell_renderer_toggle_set_active does not work properly

I would like to put a Checkbox in treeview.
When I clicked the Checkbox, it should ckeck. But Checkbox keeps being not checked.
I have written a sample code in C and GTK3:
#include <gtk/gtk.h>
GtkTreeModel* create_model ()
{
GtkTreeIter gti;
GtkListStore *gls = gtk_list_store_new ( 1, G_TYPE_BOOLEAN );
gtk_list_store_append ( gls, &gti );
gtk_list_store_set ( gls, &gti, 0, FALSE, -1 );
return GTK_TREE_MODEL ( gls );
}
void check ( GtkCellRendererToggle *cell )
{
int active = gtk_cell_renderer_toggle_get_active ( cell );
g_print ( "%d\n", active );
if ( active )
{
//fail
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE ( cell ), FALSE );
}
else
{
//fail
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE ( cell ), TRUE) ;
}
return;
}
int main ( int argc, char *argv[] )
{
gtk_init ( &argc, &argv );
//window
GtkWidget *window_main = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
//tree view
GtkWidget *treeview = gtk_tree_view_new_with_model ( create_model () );
//cell_renderer_toggle
GtkCellRenderer *cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_append_column ( GTK_TREE_VIEW ( treeview ), gtk_tree_view_column_new_with_attributes ( "test", cell, "active", 0, NULL ) );
g_signal_connect ( cell, "toggled", G_CALLBACK ( check ), NULL );
gtk_container_add ( GTK_CONTAINER ( window_main ), treeview );
gtk_widget_show_all ( window_main );
gtk_main();
return 0;
}
Function gtk_cell_renderer_toggle_set_active call fails and does not set the cell active.
Please help me fix my code.
With the call of
gtk_tree_view_column_new_with_attributes ("test", cell, "active", 0, NULL);
you bind the "active" property of each cell renderer in any row of the column to the value in the first column of the related data model. Although the state of any GtkCellRendererToggle instance is represented by its own properties its "active" property reflects the corresponding value in the data model at the same time.
If you activate a single cell renderer by means of gtk_cell_renderer_toggle_set_active you just set the "active" property of the specific GtkCellRendererToggle instance. Unfortunately the instance has no knowledge about the data model from which it represent a value and therefore has no access to it. That means that on the next draw of the treeview the "active" property corresponds with the related value from the data model again. Your change is simply overwritten.
Nevertheless you can still safely set all other properties of a cell renderer that are not connected to the data model. I included an example for that in my example.
That means that your callback have to change the value in the data model instead of changing the property of the cell renderer.
The appended modification of your example code illustrates what i've described
#include <gtk/gtk.h>
GtkListStore *
create_model ()
{
GtkTreeIter gti;
GtkListStore *gls;
gls = gtk_list_store_new (1, G_TYPE_BOOLEAN);
gtk_list_store_append (gls, &gti);
gtk_list_store_set (gls, &gti, 0, TRUE, -1);
return gls;
}
void
check (GtkCellRendererToggle * cell, gchar * path, GtkListStore * model)
{
GtkTreeIter iter;
gboolean active;
active = gtk_cell_renderer_toggle_get_active (cell);
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (model), &iter, path);
if (active) {
gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(cell), 0, 0);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, FALSE, -1);
}
else {
gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(cell), 0.5, 0.5);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, TRUE, -1);
}
}
int
main (int argc, char *argv[])
{
GtkTreeViewColumn *column;
GtkWidget *window_main;
GtkWidget *treeview;
GtkCellRenderer *cell;
GtkListStore *store;
gtk_init (&argc, &argv);
store = create_model ();
//window
window_main = gtk_window_new (GTK_WINDOW_TOPLEVEL);
//tree view
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
//cell_renderer_toggle
cell = gtk_cell_renderer_toggle_new ();
column =
gtk_tree_view_column_new_with_attributes ("test",
cell, "active", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_signal_connect (cell, "toggled", G_CALLBACK (check), store);
g_signal_connect (window_main, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_container_add (GTK_CONTAINER (window_main), treeview);
gtk_widget_show_all (window_main);
gtk_main ();
return 0;
}

making a vending machine out of GTK

#include "UI.h"
GtkWidget* create_main_frame(gint wid, gint hgt)
{
GtkWidget* main_frame = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* window attributes */
gtk_window_set_title( GTK_WINDOW(main_frame), "Welcome!!" );
gtk_window_set_default_size( GTK_WINDOW(main_frame), wid, hgt );
/* signals */
g_signal_connect(main_frame, "destroy", G_CALLBACK(gtk_main_quit), NULL);
return main_frame;
}
GtkWidget* create_scrolled_window(void)
{
GtkWidget* scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
gtk_container_set_border_width( GTK_CONTAINER(scrolled_window), 10 );
return scrolled_window;
}
GtkWidget* create_box(GtkOrientation orn, gint spc)
{
GtkWidget* box = gtk_box_new(orn, spc);
//gtk_container_set_border_width( GTK_CONTAINER(box), 5 );
return box;
}
GtkWidget* create_layout(guint wid, guint hgt)
{
GtkWidget* layout = gtk_layout_new(NULL, NULL);
gtk_layout_set_size( GTK_LAYOUT(layout), wid, hgt );
return layout;
}
GtkWidget* create_grid(guint rsp, guint csp)
{
GtkWidget* grid = gtk_grid_new();
gtk_grid_set_row_spacing( GTK_GRID(grid), rsp );
gtk_grid_set_column_spacing( GTK_GRID(grid), csp );
return grid;
}
/*
GtkWidget* create_token_button(Token* tkn)
{
char parsed_value[11];
char* string = parse_to_string(tkn -> value, parsed_value);
GtkWidget* button = gtk_button_new_with_label(value);
//gtk_signal_connect(button, "clicked", G_CALLBACK, );
return button;
}
*/
GtkWidget* create_commodity_button(Commodity* com)
{
GtkWidget* button = gtk_button_new_with_label(com -> name);
//gtk_signal_connect(button, "clicked", G_CALLBACK, );
return button;
}
#include "UI.h"
int main(int argc, char* argv[])
{
int i, j;
/* vending machine */
VendingMachine* vending_machine;
/* frames */
GtkWidget* main_frame;
GtkWidget* scrolled_window;
GtkWidget* commodity_box, * commodity_layout, * commodity_grid, * commodity_button;
/* initialize */
gtk_init(&argc, &argv);
make_new_vending_machine_memory(&vending_machine, sizeof(VendingMachine) );
boot_vending_machine(vending_machine, 13, 13);
/* setting main frame */
main_frame = create_main_frame(1000, 750);
/* setting commodty frames and button table */
commodity_box = create_box(GTK_ORIENTATION_HORIZONTAL, 10);
scrolled_window = create_scrolled_window();
commodity_layout = create_layout(500, 700);
commodity_grid = create_grid(10, 10);
for (i = 0; i < 13; i++)
for (j = 0; j < 13; j++) {
commodity_button = create_commodity_button(&vending_machine -> commodity[i][j]);
gtk_grid_attach( GTK_GRID(commodity_grid), commodity_button, i * 300, j * 300, 5, 7 );
}
/* start adding and packing */
gtk_layout_put( GTK_LAYOUT(commodity_layout), commodity_grid, 10, 10 );
gtk_container_add( GTK_CONTAINER(scrolled_window), commodity_layout );
gtk_box_pack_start( GTK_BOX(commodity_box), scrolled_window, TRUE, TRUE, 10 );
gtk_container_add( GTK_CONTAINER(main_frame), commodity_box );
/* show all */
gtk_widget_show_all(main_frame);
gtk_main();
return 0;
}
I'm done writing the basic functions that are needed in my small vending machine project.
Now, I'm trying to make an UI out of the functions with GTK+. And I'm very confused since
this is the first time I'm actually using GTK.
I want a grid of commodity buttons that should be displayed on the left side, but I got
pretty much stuck on this part. What I'm trying to do is, since I "malloc"ed the commodities
for the purpose of adding and remove comms, I want a scroll bar attached to the comm window.
what I did as you can see in the source code
I made a grid of comm buttons and added on a layout widget.
I added the layout on a scrollbar widget
I added that scrollbar on a box and packed it.
I added that box to the main window.
the result is well "not satisfing"
I'm struggling through the GNOME official APIs
can somebody help me with this??
If you don't see how to create your user interface, give Glade a try. You'll be able to quickly try and see how the widgets fit together.

gtkbin seems to not get event from my gtkwindow toplevel widget

I have some questions, in this moment I try to make a custom widget in gtk with gtkbin so I want to know if it is possible to subclass gtkbin and how to do that...
Thanks for your help.
I have finally managed to implement this myself. Here's how for people who want to derive gtkbin widget.
1) It is important to understand the hierarchy of widgets.
>Hierarchy of widgets:
GtkWidget <- GtkContainer <- GtkBin
If Gtkcontainer and GtkBin don't rewrite a contumize function for GtkWidgetClass->draw, for example, the custom widget class which derives directly from GtkBin will use the default draw function of the GtkWidgetClass.
2) Info about gtkbin:
Download the source code of gtk and open gtkwidget.c, gtkcontainer.c, gtkwindow.c and look at the class_init function in all this files.
In the GtkWidgetClass:
1) We have to see that, widget class doesn't implement the "draw" function:
GtkWidgetClass->draw
2) We have to see that, the implementation of GtkWidgetClass->get_preferred_width and GtkWidgetClass_preferred_width_height always returns "0" which is not correct.
We also see that GtkWidgetClass->size_allocate only allocates size for the widget you want to derive, it doesn't take in count the children of the customize widget.
You have to rewrite these four functions to everything to work properly.
Since GtkWindow is a widget which derives directly from GtkBin, we can implement our functions by viewing the corresponding implementation in GtkWindow.c file and make some changes.
Here is my implementation:
widget_class->get_preferred_width = item_list_get_preferred_width;
widget_class->get_preferred_height = item_list_get_preferred_height;
widget_class->draw = dsn_itemlist_draw;
widget_class->size_allocate = item_list_size_allocate;
void item_list_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkAllocation child_allocation;
GtkWidget *child;
guint border_width;
gtk_widget_set_allocation (widget, allocation);
child = gtk_bin_get_child (GTK_BIN(widget));
if (child && gtk_widget_get_visible (child))
{
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
child_allocation.x = border_width;
child_allocation.y = border_width;
child_allocation.width = MAX (1, allocation->width - border_width * 2);
child_allocation.height = MAX (1, allocation->height - border_width * 2);
gtk_widget_size_allocate (child, &child_allocation);
}
}
gboolean dsn_itemlist_draw( GtkWidget *widget, cairo_t *cr)
{
GtkWidget *child;
GtkBin *bin = GTK_BIN(widget);
GtkContainer *container = GTK_CONTAINER(widget);
child = gtk_bin_get_child(bin);
gtk_container_propagate_draw(container, child, cr);
printf("bonnnnnnn\n");
return TRUE;
}
void item_list_get_preferred_width(GtkWidget *widget,
gint *minimum_size,
gint *natural_size)
{
//GtkWindow *window;
GtkWidget *child;
guint border_width;
//window = GTK_WINDOW (widget);
child = gtk_bin_get_child (GTK_BIN (widget)/*(window)*/);
border_width = 0;//gtk_container_get_border_width (GTK_CONTAINER (window));
*minimum_size = border_width * 2;
*natural_size = border_width * 2;
if (child && gtk_widget_get_visible (child))
{
gint child_min, child_nat;
gtk_widget_get_preferred_width (child, &child_min, &child_nat);
*minimum_size += child_min;
*natural_size += child_nat;
}
}
void item_list_get_preferred_height(GtkWidget *widget,
gint *minimum_size,
gint *natural_size)
{
//GtkWindow *window;
GtkWidget *child;
guint border_width;
//window = GTK_WINDOW (widget);
child = gtk_bin_get_child (GTK_BIN (widget)/*(window)*/);
border_width = 0;//gtk_container_get_border_width (GTK_CONTAINER (window));
*minimum_size = border_width * 2;
*natural_size = border_width * 2;
if (child && gtk_widget_get_visible (child))
{
gint child_min, child_nat;
gtk_widget_get_preferred_height (child, &child_min, &child_nat);
*minimum_size += child_min;
*natural_size += child_nat;
}
}
Note: In the init function, we have to tell gtk that our widget doesn't own a window (gdkwindow) but that it inherits one from its parent widget by calling
gtk_widget_set_has_window (GTK_WIDGET (this_instance), FALSE);
That concludes...

Gtk, runtime menu

I have runtime-created menu based on words in selected gtkTreeView row.
gboolean
menu_RELEASE(GtkObject *object, GdkEvent *event, gpointer user_data)
{
if (strlen(user_data) > 0)
{
gtk_entry_set_text(GTK_ENTRY(entry1), user_data);
gtk_widget_grab_focus(entry1);
}
else
main_art(get_sifra());
return TRUE;
}
gboolean
treeview1_BUTTONRELEASE(GtkWidget *widget, GdkEventButton *event, gpointer *user_data)
{
if (event->type == GDK_BUTTON_RELEASE && event->button == 3)
{
char *ntext;
treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if (gtk_tree_selection_get_selected(treesel, &model ,&iter))
{
gtk_tree_model_get(model, &iter, cNaziv, &ntext, -1);
GtkWidget *menu, *menu_item;
menu = gtk_menu_new();
char *sresult = NULL;
sresult = strtok(ntext, " ");
while(sresult != NULL)
{
if (strlen(sresult)>1)
{
menu_item = gtk_menu_item_new_with_label(sresult);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
g_signal_connect(G_OBJECT(menu_item), "button-release-event", G_CALLBACK(menu_RELEASE), (gpointer)sresult);
}
sresult = strtok(NULL, " ");
}
menu_item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
//
menu_item = gtk_image_menu_item_new_with_label("Uredi...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), GTK_WIDGET(gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU)));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
g_signal_connect(G_OBJECT(menu_item), "button-release-event", G_CALLBACK(menu_RELEASE), (gpointer)"");
//
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
return TRUE;
}
}
return FALSE;
}
When menu item was released action from "menu_RELEASE" should appear.
But what happened?
Menu don't dissappear, stay's visible and active.
What is wrong with my code?
You're not supposed to connect to mouse-button signals of the items, that's being too low-level. Your handler is "swallowing" the mouse button signal, preventing GTK+ from handling it.
Use the activate signal.