Function gtk_cell_renderer_toggle_set_active does not work properly - gtk

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

Related

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

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.

How to make placeholder text of a Gtk.SearchEntry visible even if the entry is focused?

The search entry appears when a menu button is clicked. But the problem is that, it gets automatically focused and as a result, the placeholder text is not visible. I want the placeholder text to be always visible, even when the entry is focused.
Feel free to post the solutions using any language you want but vala is preferred.
Thank you
Until you find a better solution, this is what I'll do in this case:
create an entry buffer
set the buffer on that entry
set cursor position at the end of the buffer (optional)
select the whole region text (probably this is what you need)
Now what I did was to connect the button to the "toggled" signal and put all that information in the callback, feel free to adjust it for your needs:
#include <gtk/gtk.h>
static void toggled_clbk ( GtkWidget *button, GtkWidget *search_entry )
{
g_return_if_fail ( GTK_IS_TOGGLE_BUTTON ( button ) );
g_return_if_fail ( GTK_IS_SEARCH_ENTRY ( search_entry ) );
if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( button ) ) )
{
/// ***
GtkEntryBuffer *buffer;
/// ***
buffer = gtk_entry_buffer_new ( "Type here...", -1 );
/// ***
gtk_entry_set_buffer ( GTK_ENTRY ( search_entry ), buffer );
/// ***
///gtk_editable_set_position ( GTK_EDITABLE ( search_entry ), -1 );
gtk_editable_select_region ( GTK_EDITABLE ( search_entry ), 0, -1 );
/// ***
g_object_unref ( buffer );
}
}
int main ( void )
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *search_box;
GtkWidget *search_button;
GtkWidget *search_bar;
GtkWidget *search_entry;
/// ***
gtk_init ( NULL, NULL );
/// ***
window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_size_request ( window, 300, -1 );
/// ***
g_signal_connect ( window, "destroy", gtk_main_quit, NULL );
/// ***
box = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_container_add ( GTK_CONTAINER ( window ), box );
gtk_container_set_border_width ( GTK_CONTAINER ( box ), 0 );
/// ***
search_entry = gtk_search_entry_new ();
/// ***
search_box = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL, 10 );
gtk_box_pack_start ( GTK_BOX ( search_box ), search_entry, FALSE, FALSE, 0 );
/// ***
search_bar = gtk_search_bar_new ();
gtk_search_bar_connect_entry ( GTK_SEARCH_BAR ( search_bar ), GTK_ENTRY ( search_entry ) );
/// ***
gtk_container_add ( GTK_CONTAINER ( search_bar ), search_box );
gtk_box_pack_end ( GTK_BOX ( box ), search_bar, FALSE, FALSE, 0 );
/// ***
search_button = gtk_toggle_button_new_with_label ( "Search" );
g_object_bind_property ( search_button, "active", search_bar, "search-mode-enabled", G_BINDING_BIDIRECTIONAL );
/// ***
gtk_box_pack_start ( GTK_BOX ( box ), search_button, TRUE, TRUE, 0 );
/// ***
g_signal_connect ( search_button, "toggled", G_CALLBACK ( toggled_clbk ), search_entry );
/// ***
gtk_widget_show_all ( window );
/// ***
gtk_main();
}
As a result, once that you click the search button and the search bar gets revealed you will have something like this:
Before you click the button:
After you click the button:

TreeView or ListView without column title bar

Is there a way to show data in TreeView or ListView without column title bar?
When you talk about column title bar without showing any code makes me think that you are asking about Header.
If so, then this is the function you need:
gtk_tree_view_set_headers_visible()
Here is with headers_visible set to TRUE (which is default):
And here is with headers_visible set to FALSE:
And here is an example Code:
#include <gtk/gtk.h>
GtkWidget *create_window ( void );
GtkWidget *create_scrolled_window ( void );
GtkWidget *create_tree_view ( void );
GtkListStore *create_list_store ( void );
int main ( void )
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
/// ***
gtk_init ( NULL, NULL );
/// ***
window = create_window();
/// ***
///scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
scrolled_window = create_scrolled_window ( );
gtk_scrolled_window_set_kinetic_scrolling ( GTK_SCROLLED_WINDOW ( scrolled_window ), TRUE );
gtk_scrolled_window_set_capture_button_press ( GTK_SCROLLED_WINDOW ( scrolled_window ), TRUE );
/// ***
tree_view = create_tree_view ( );
gtk_container_add ( GTK_CONTAINER ( scrolled_window ), tree_view );
gtk_container_add ( GTK_CONTAINER ( window ), scrolled_window );
/// ***
gtk_widget_show_all ( window );
// ***
gtk_widget_show_all ( window );
gtk_main ();
}
GtkWidget *create_window ( void )
{
GtkWidget *window;
/// ***
window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
gtk_window_set_default_size ( GTK_WINDOW ( window ), 150, 150 );
gtk_container_set_border_width ( GTK_CONTAINER ( window ), 5 );
/// ***
g_signal_connect ( window, "delete_event", G_CALLBACK ( gtk_main_quit ), NULL );
/// ***
return window;
}
GtkWidget *create_scrolled_window ( void )
{
GtkWidget *scrolled_window;
/// ***
scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_kinetic_scrolling ( GTK_SCROLLED_WINDOW ( scrolled_window ), TRUE );
gtk_scrolled_window_set_capture_button_press ( GTK_SCROLLED_WINDOW ( scrolled_window ), TRUE );
/// ***
return scrolled_window;
}
GtkListStore *create_list_store ( void )
{
GtkListStore *list_store;
list_store = gtk_list_store_new ( 1, G_TYPE_STRING );
/// ***
for ( gint i = 0; i < 10; i++ )
{
GtkTreeIter iter;
gchar *label = g_strdup_printf ( "Row number %d", i );
/// ***
gtk_list_store_append ( list_store, &iter );
gtk_list_store_set ( list_store, &iter, 0, label, -1 );
/// ***
g_free ( label );
}
return list_store;
}
GtkWidget *create_tree_view ( void )
{
GtkWidget *tree_view;
GtkCellRenderer *renderer;
GtkListStore *store;
/// ***
tree_view = gtk_tree_view_new ();
store = create_list_store();
/// ***
renderer = gtk_cell_renderer_text_new ();
g_object_set ( renderer, "editable", TRUE, NULL );
/// **
gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW ( tree_view ),
0, "This is the Title",
renderer,
"text", 0,
NULL );
/// ***
gtk_tree_view_set_model ( GTK_TREE_VIEW ( tree_view ), GTK_TREE_MODEL ( store ) );
g_object_unref ( store );
/// ***
gtk_tree_view_set_headers_visible ( GTK_TREE_VIEW ( tree_view ), FALSE );
/// ***
return tree_view;
}

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

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.