void lamixer_mixer_elemets()
{
gint cnt = 0, i;
struct pollfd *fds;
g_list_foreach (VolumeBoxes, (GFunc)lamixer_mixerelem_show, NULL);
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++pCols);
gtk_table_attach(GTK_TABLE(mixerbox), switchvbox, pCols-1, pCols, 0, 5, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
gtk_table_resize(GTK_TABLE(capturebox), mRows, ++cCols);
gtk_table_attach(GTK_TABLE(capturebox), switchcapturevbox, cCols-1, cCols, 0, 5, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
cnt = snd_mixer_poll_descriptors_count(mixer_handle);
fds = g_new0(struct pollfd, cnt);
snd_mixer_poll_descriptors(mixer_handle, fds, cnt);
alsa_chans = g_new0(GIOChannel*, cnt);
for (i=0; i<cnt; i++) {
alsa_chans[i] = g_io_channel_unix_new(fds[i].fd);
g_io_add_watch(alsa_chans[i], G_IO_IN | G_IO_OUT | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, lamixer_volbox_alsa_io, NULL);
}
g_free(fds);
n_alsa_chans = cnt;
}
void lamixer_volbox_show(VolBox *volumebox, snd_mixer_elem_t *elem, GtkWidget *mixerbox)
{
long rangevalue_left,rangevalue_right;
int mute, *bCols;
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
bCols = &pCols;
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
bCols = &cCols;
}
volumebox->curval = rangevalue_left;
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->vollabel, *bCols-1, *bCols, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_range_set_value(GTK_RANGE(volumebox->volbar), rangevalue_left);
gtk_box_pack_start(GTK_BOX(volumebox->volbarbox), volumebox->volbar, TRUE, TRUE, 0);
volumebox->hsignalid = g_signal_connect(G_OBJECT(volumebox->volbar), "value-changed", G_CALLBACK(lamixer_volbox_changed), volumebox);
if (volumebox->rvolbar != NULL) {
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
volumebox->rcurval = rangevalue_right;
gtk_box_pack_start(GTK_BOX(volumebox->volbarbox), volumebox->rvolbar, TRUE, TRUE, 0);
gtk_range_set_value(GTK_RANGE(volumebox->rvolbar), rangevalue_right);
volumebox->hsignalidr = g_signal_connect(G_OBJECT(volumebox->rvolbar), "value-changed", G_CALLBACK(lamixer_volboxr_changed), volumebox);
}
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->volbarbox, *bCols-1, *bCols, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
if (volumebox->lockswitch != NULL) {
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->lockswitch, *bCols-1, *bCols, 2, 3, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(volumebox->lockswitch), TRUE);
}
if (volumebox->muteswitch != NULL) {
snd_mixer_selem_get_playback_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mute);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(volumebox->muteswitch), !mute);
volumebox->hmutesignalid = g_signal_connect(G_OBJECT(volumebox->muteswitch), "toggled", G_CALLBACK(lamixer_muteswitch_changed), elem);
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->muteswitch, *bCols-1, *bCols, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
}
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++(*bCols));
gtk_table_attach(GTK_TABLE(mixerbox), gtk_vseparator_new (), *bCols-1, *bCols, 0, 5, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 4, 0);
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++(*bCols));
}
void
eom_detail_window_load(EomDetailWindow *self)
{
gint i, j = 0, row = 0, col = 0;
int total_qty = self->manga->total_qty;
int rows;
if (!total_qty)
total_qty = self->manga->current_qty + 1;
rows = (int)ceil(total_qty / COLUMNS);
gtk_window_set_title(GTK_WINDOW(self), self->manga->name);
gtk_container_foreach(GTK_CONTAINER(self->ctable), cb_destroy, NULL);
gtk_table_resize(GTK_TABLE(self->ctable), rows, COLUMNS);
gtk_container_foreach(GTK_CONTAINER(self->rtable), cb_destroy, NULL);
gtk_table_resize(GTK_TABLE(self->rtable), rows, COLUMNS);
for (i = 0; i < total_qty; i++) {
GtkWidget *cbtn, *rbtn;
gchar *txt;
if (i > 0 && i % COLUMNS == 0) {
row++;
col = 0;
}
txt = g_strdup_printf("%d", i + 1);
cbtn = create_volume_button(txt, GTK_TABLE(self->ctable), col,
row);
rbtn = create_volume_button(txt, GTK_TABLE(self->rtable), col,
row);
if (j < self->manga->vol_count
&& self->manga->volumes[j].number == i + 1) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbtn), TRUE);
if (self->manga->volumes[j].read)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rbtn),
TRUE);
j++;
}
g_signal_connect(cbtn, "toggled", G_CALLBACK(on_volume_toggled),
(gpointer)self);
g_signal_connect(rbtn, "toggled",
G_CALLBACK(on_volume_read_toggled),
(gpointer)self);
g_free(txt);
col++;
}
gtk_widget_show_all(self->volsbox);
}
void
FormDialog::grow_fields (bool advanced)
{
if (advanced) {
advanced_rows++;
gtk_table_resize (GTK_TABLE (advanced_fields), advanced_rows, 2);
} else {
rows++;
gtk_table_resize (GTK_TABLE (fields), rows, 2);
}
}
static GtkWidget *add_table_int_row(CtkConfig *ctk_config, GtkWidget *table,
const gchar *help, gchar *label1,
uint64_t val, gint row,
gboolean ecc_enabled)
{
GtkWidget *hbox2, *label, *eventbox;
gtk_table_resize(GTK_TABLE(table), row+1, 2);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, row, row+1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(label1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
gtk_widget_set_sensitive(label, ecc_enabled);
eventbox = gtk_event_box_new();
gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, row, row+1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
set_label_value(label, val);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_container_add(GTK_CONTAINER(eventbox), label);
ctk_config_set_tooltip(ctk_config, eventbox, help);
gtk_widget_set_sensitive(label, ecc_enabled);
return label;
} /* add_table_int_row() */
GtkWidget *
get_table (MuMsg *msg)
{
GtkWidget *table;
int row;
row = 0;
table = gtk_table_new (5, 2, FALSE);
if (add_row (table, row, "From", mu_msg_get_from (msg), TRUE))
++row;
if (add_row (table, row, "To", mu_msg_get_to (msg), FALSE))
++row;
if (add_row (table, row, "Cc", mu_msg_get_cc (msg), FALSE))
++row;
if (add_row (table, row, "Subject", mu_msg_get_subject (msg), TRUE))
++row;
if (add_row (table, row, "Date", mu_date_str_s
("%c", mu_msg_get_date (msg)),TRUE))
++row;
gtk_table_resize (GTK_TABLE(table), row, 2);
return table;
}
// Create a new item in the table
rtk_tableitem_t *rtk_tableitem_create_int(rtk_table_t *table,
const char *label, int low, int high)
{
rtk_tableitem_t *item;
item = malloc(sizeof(rtk_tableitem_t));
item->table = table;
RTK_LIST_APPEND(table->item, item);
// Create the gtk objects
item->label = gtk_label_new(label);
item->adj = gtk_adjustment_new(0, low, high, 1, 10, 10);
item->spin = gtk_spin_button_new(GTK_ADJUSTMENT(item->adj), 1, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(item->spin), TRUE);
// Resize the table to make it big enough
if (table->item_count >= table->row_count)
gtk_table_resize(GTK_TABLE(table->table), ++table->row_count, 2);
// Now stick the item in the table
gtk_table_attach(GTK_TABLE(table->table), item->label,
0, 1, table->item_count, table->item_count + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table->table), item->spin,
1, 2, table->item_count, table->item_count + 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
table->item_count++;
return item;
}
void
scope_group_set_num_channels (ScopeGroup *s,
int num_channels)
{
int i;
// Remove superfluous scopes from table
for(i = num_channels; i < s->numchan; i++) {
gtk_container_remove(GTK_CONTAINER(s->table), s->scopebuttons[i]);
}
// Resize table
gtk_table_resize(GTK_TABLE(s->table), 2, num_channels / 2);
// Add new scopes to table
for(i = s->numchan; i < num_channels; i++) {
gtk_object_ref(GTK_OBJECT(s->scopebuttons[i]));
gtk_table_attach_defaults(GTK_TABLE(s->table), s->scopebuttons[i], i / 2, i / 2 + 1, i % 2, i % 2 + 1);
}
// Reset all buttons (enable all channels)
for(i = 0; i < 32; i++) {
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(s->scopebuttons[i]), 1);
#ifndef NO_GDK_PIXBUF
gtk_widget_hide (s->mutedpic[i]);
if (s->scopes_on) gtk_widget_show (GTK_WIDGET(s->scopes[i]));
#endif
}
s->numchan = num_channels;
s->on_mask = 0xFFFFFFFF; /* all channels are on */
}
/* Build the composite widget */
static void avahibrowser_init(AvahiBrowser * ab)
{
GtkCellRenderer *cell;
/* Create model */
ab->data =
gtk_list_store_new(7, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
ab->combo_box =
gtk_combo_box_new_with_model(GTK_TREE_MODEL(ab->data));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ab->combo_box), cell,
TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ab->combo_box),
cell, "text", 6, NULL);
gtk_widget_show(ab->combo_box);
gtk_widget_set_tooltip_text(ab->combo_box,
_
("Select an automatically discovered game"));
gtk_table_resize(GTK_TABLE(ab), 1, 1);
gtk_table_attach_defaults(GTK_TABLE(ab), ab->combo_box, 0, 1, 0,
1);
}
static void execute_widget_init(ExecuteWidget *ew)
{
ew->nes = NULL;
ew->execute_callback = NULL;
ew->step_callback = NULL;
ew->debug_disable_callback = NULL;
ew->running = FALSE;
ew->thread = NULL;
gtk_table_resize(GTK_TABLE(ew), EXECUTE_WIDGET_ROWS, EXECUTE_WIDGET_COLS);
gtk_table_set_homogeneous(GTK_TABLE(ew), TRUE);
ew->step_button = gtk_button_new_with_label("Step");
g_signal_connect(ew->step_button, "clicked", G_CALLBACK(on_step_button_clicked), ew);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->step_button, 0, 1, 0, 1);
ew->execute_button = gtk_button_new_with_label("Execute");
g_signal_connect(ew->execute_button, "clicked", G_CALLBACK(on_execute_button_clicked), ew);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->execute_button, 1, 2, 0, 1);
ew->start_button = gtk_button_new_with_label("Start");
g_signal_connect(ew->start_button, "clicked", G_CALLBACK(on_start_button_clicked), ew);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->start_button, 2, 3, 0, 1);
ew->stop_button = gtk_button_new_with_label("Stop");
g_signal_connect(ew->stop_button, "clicked", G_CALLBACK(on_stop_button_clicked), ew);
gtk_widget_set_sensitive(GTK_WIDGET(ew->stop_button), FALSE);
gtk_table_attach_defaults(GTK_TABLE(ew), ew->stop_button, 3, 4, 0, 1);
}
int ZLGtkDialogContent::addRow() {
int row = myRowCounter++;
gtk_table_resize(myTable, myRowCounter, 2);
return row;
}
extern int setup_grid_table(GtkTable *table, List button_list, List node_list)
{
int rc = SLURM_SUCCESS;
button_processor_t button_processor;
int coord_x=0, coord_y=0;
if (!node_list) {
g_print("setup_grid_table: no node_list given\n");
return SLURM_ERROR;
}
if (_init_button_processor(&button_processor, list_count(node_list))
!= SLURM_SUCCESS)
return SLURM_ERROR;
button_processor.table = table;
button_processor.button_list = button_list;
button_processor.coord_x = &coord_x;
button_processor.coord_y = &coord_y;
gtk_table_resize(table, button_processor.table_y,
working_sview_config.grid_x_width);
if (default_sview_config.grid_topological && g_topo_info_msg_ptr)
rc = _grid_table_by_switch(&button_processor, node_list);
else
rc = _grid_table_by_list(&button_processor, node_list);
list_sort(button_list, (ListCmpF) _sort_button_inx);
return rc;
}
static void
panel_properties_dialog_remove_orientation_combo (PanelPropertiesDialog *dialog)
{
GtkContainer *container = GTK_CONTAINER (dialog->general_table);
GtkTable *table = GTK_TABLE (dialog->general_table);
g_object_ref (dialog->size_label);
g_object_ref (dialog->size_widgets);
g_object_ref (dialog->icon_label);
g_object_ref (dialog->icon_align);
gtk_container_remove (container, dialog->orientation_label);
gtk_container_remove (container, dialog->orientation_combo);
gtk_container_remove (container, dialog->size_label);
gtk_container_remove (container, dialog->size_widgets);
gtk_container_remove (container, dialog->icon_label);
gtk_container_remove (container, dialog->icon_align);
gtk_table_attach_defaults (table, dialog->size_label, 0, 1, 1, 2);
gtk_table_attach_defaults (table, dialog->size_widgets, 1, 2, 1, 2);
gtk_table_attach_defaults (table, dialog->icon_label, 0, 1, 2, 3);
gtk_table_attach_defaults (table, dialog->icon_align, 1, 2, 2, 3);
dialog->orientation_label = NULL;
dialog->orientation_combo = NULL;
g_object_unref (dialog->size_label);
g_object_unref (dialog->size_widgets);
g_object_unref (dialog->icon_label);
g_object_unref (dialog->icon_align);
gtk_table_resize (table, 3, 2);
}
int GtkOptionsDialogTab::addRow(void) {
int row = myRowCounter++;
gtk_table_resize(myTable, myRowCounter, 2);
return row;
}
static void
remmina_chain_button_init (RemminaChainButton *cb)
{
GtkWidget *widget;
GtkWidget *image;
GdkPixbuf *pixbuf;
gtk_table_resize (GTK_TABLE (cb), 3, 1);
pixbuf = gdk_pixbuf_new_from_xpm_data (line_up_xpm);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
gtk_table_attach_defaults (GTK_TABLE (cb), image, 0, 1, 0, 1);
widget = gtk_button_new ();
gtk_widget_show (widget);
gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
gtk_table_attach_defaults (GTK_TABLE (cb), widget, 0, 1, 1, 2);
g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (remmina_chain_button_on_clicked), cb);
image = gtk_image_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (widget), image);
cb->chain_image = image;
pixbuf = gdk_pixbuf_new_from_xpm_data (line_down_xpm);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
gtk_table_attach_defaults (GTK_TABLE (cb), image, 0, 1, 2, 3);
cb->chained = FALSE;
}
static void create_toggle(const char* label, int *on, void *_data)
{
GtkWidget *button, *table = _data;
int rows, cols, x, y;
static int count;
if (table == NULL) {
/* magic way to reset the number of toggle buttons
* that we have already added - call this before you
* create the dialog */
count = 0;
return;
}
g_object_get(G_OBJECT(table), "n-columns", &cols, "n-rows", &rows, NULL);
if (count > rows * cols) {
gtk_table_resize(GTK_TABLE(table),rows+1,cols);
rows++;
}
x = count % cols;
y = count / cols;
button = gtk_check_button_new_with_label(label);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), *on);
gtk_table_attach_defaults(GTK_TABLE(table), button, x, x+1, y, y+1);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(event_toggle), on);
count++;
}
/* Build the composite widget */
static void game_buildings_init(GameBuildings * gb)
{
GtkWidget *label;
GtkWidget *spin;
GtkObject *adjustment;
gint row;
gtk_table_resize(GTK_TABLE(gb), NUM_BUILD_TYPES - 1, 2);
gtk_table_set_row_spacings(GTK_TABLE(gb), 3);
gtk_table_set_col_spacings(GTK_TABLE(gb), 5);
gtk_table_set_homogeneous(GTK_TABLE(gb), TRUE);
for (row = 1; row < NUM_BUILD_TYPES; row++) {
label = gtk_label_new(gettext(building_names[row]));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(gb), label,
0, 1, row - 1, row);
adjustment = gtk_adjustment_new(0, 0, 100, 1, 5, 0);
spin =
gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
gtk_entry_set_alignment(GTK_ENTRY(spin), 1.0);
gtk_table_attach_defaults(GTK_TABLE(gb), spin,
1, 2, row - 1, row);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gb->num_buildings[row] = GTK_SPIN_BUTTON(spin);
}
}
static void create_entry(PROC_T *p){
p->hbox=gtk_hbox_new(FALSE,0);
char lb[12];
char stime[80];
snprintf(lb,12," %5d",p->pid);
struct tm *tim=localtime(&(p->status.timstart));
strftime(stime,80,"[%F %k:%M:%S]",tim);
strcat(stime,lb);
p->entry_pid=new_label(stime,WIDTH_PID,0);
p->entry_path=new_label(p->path,WIDTH_PATH,1);
gtk_label_set_selectable(GTK_LABEL(p->entry_path), TRUE);
gtk_label_set_ellipsize(GTK_LABEL(p->entry_path),PANGO_ELLIPSIZE_START);
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 12
gtk_widget_set_tooltip_text(p->entry_path, p->path);
#endif
p->entry_errlo=new_label("Lo (nm)",WIDTH_ERRLO,1);
p->entry_errhi=new_label("Hi (nm)",WIDTH_ERRHI,1);
p->entry_iseed=new_entry("iSEED",WIDTH_ISEED,0.5);
p->entry_timing=new_entry("Timing",WIDTH_TIMING,1);
/*kill_button_new(p); */
change_button(p, GTK_STOCK_STOP, (GCallback)kill_job_event);
int irow=nrows[p->hid];
nrows[p->hid]++;
gtk_table_resize(GTK_TABLE(tables[p->hid]), nrows[p->hid],ncol);
grid_attach(tables[p->hid], p->entry_pid, 0,1,irow,irow+1,0);
grid_attach(tables[p->hid], p->entry_path, 1,2,irow,irow+1,7);
grid_attach(tables[p->hid], p->entry_errlo, 2,3,irow,irow+1,0);
grid_attach(tables[p->hid], p->entry_errhi, 3,4,irow,irow+1,0);
grid_attach(tables[p->hid], p->entry_iseed, 4,5,irow,irow+1,0);
grid_attach(tables[p->hid], p->entry_timing, 5,6,irow,irow+1,0);
grid_attach(tables[p->hid], p->btn, 6,7,irow,irow+1,0);
gtk_widget_show_all(tables[p->hid]);
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),p->hid);
}
/*
* When items displayed in the menu change (e.g, a new item is added,
* an item is hidden or the list is reordered), the layout must be
* updated. To do this we repack all items starting from a given one.
*/
static void
hildon_app_menu_repack_items (HildonAppMenu *menu,
gint start_from)
{
HildonAppMenuPrivate *priv;
gint row, col, nvisible, i;
GList *iter;
priv = HILDON_APP_MENU_GET_PRIVATE(menu);
i = nvisible = 0;
for (iter = priv->buttons; iter != NULL; iter = iter->next) {
/* Count number of visible items */
if (GTK_WIDGET_VISIBLE (iter->data))
nvisible++;
/* Remove buttons from their parent */
if (start_from != -1 && i >= start_from) {
GtkWidget *item = GTK_WIDGET (iter->data);
GtkWidget *parent = gtk_widget_get_parent (item);
if (parent) {
g_object_ref (item);
gtk_container_remove (GTK_CONTAINER (parent), item);
}
}
i++;
}
/* If items have been removed, recalculate the size of the menu */
if (start_from != -1)
gtk_window_resize (GTK_WINDOW (menu), 1, 1);
/* Set the final size now to avoid unnecessary resizes later */
if (nvisible > 0)
gtk_table_resize (priv->table, ((nvisible - 1) / priv->columns) + 1, priv->columns);
/* Add buttons */
row = col = 0;
for (iter = priv->buttons; iter != NULL; iter = iter->next) {
GtkWidget *item = GTK_WIDGET (iter->data);
if (GTK_WIDGET_VISIBLE (item)) {
/* Don't add an item to the table if it's already there */
if (gtk_widget_get_parent (item) == NULL) {
gtk_table_attach_defaults (priv->table, item, col, col + 1, row, row + 1);
g_object_unref (item);
/* GtkButton must be realized for accelerators to work */
gtk_widget_realize (item);
}
if (++col == priv->columns) {
col = 0;
row++;
}
}
}
gtk_widget_queue_draw (GTK_WIDGET (menu));
}
extern GtkWidget *create_resv_entry(resv_desc_msg_t *resv_msg,
GtkTreeModel *model, GtkTreeIter *iter)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
int i = 0, row = 0;
display_data_t *display_data = create_data_resv;
gtk_scrolled_window_set_policy(window,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_table_resize(table, SORTID_CNT, 2);
gtk_table_set_homogeneous(table, FALSE);
for (i = 0; i < SORTID_CNT; i++) {
while (display_data++) {
if (display_data->id == -1)
break;
if (!display_data->name)
continue;
if (display_data->id != i)
continue;
display_admin_edit(
table, resv_msg, &row, model, iter,
display_data,
G_CALLBACK(_admin_edit_combo_box_resv),
G_CALLBACK(_admin_focus_out_resv),
_set_active_combo_resv);
break;
}
display_data = create_data_resv;
}
gtk_table_resize(table, row, 2);
return GTK_WIDGET(window);
}
void
add_table_entry(gtk_table *tab, const char *str, int x, int y)
{
GtkWidget *tmp;
if(y>=tab->height) {
tab->height=y+1;
gtk_table_resize(GTK_TABLE(tab->widget), tab->height, tab->width);
}
if(x>=tab->width) {
tab->width=x+1;
gtk_table_resize(GTK_TABLE(tab->widget), tab->height, tab->width);
}
tmp=gtk_label_new(str);
gtk_table_attach_defaults(GTK_TABLE(tab->widget), tmp, x, x+1, y, y+1);
gtk_label_set_justify(GTK_LABEL(tmp), GTK_JUSTIFY_LEFT);
gtk_widget_show(tmp);
}
void InitMixer(char card[64])
{
switchvbox = gtk_vbox_new(FALSE,0);
switchcapturevbox = gtk_vbox_new(FALSE,0);
enumvbox = gtk_vbox_new(FALSE,0);
enumcapturevbox = gtk_vbox_new(FALSE,0);
gtk_box_pack_end(GTK_BOX(switchvbox), enumvbox, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(switchcapturevbox), enumcapturevbox, TRUE, TRUE, 0);
pCols = cCols = 1;
gtk_table_resize(GTK_TABLE(mixerbox), mRows, pCols);
gtk_table_resize(GTK_TABLE(capturebox), mRows, cCols);
lamixer_mixer_elemets();
gtk_widget_show_all (mixerbox);
gtk_widget_show_all (capturebox);
}
/* keyboard_layout_add */
KeyboardKey * keyboard_layout_add(KeyboardLayout * layout, unsigned int row,
unsigned int width, unsigned int keysym, char const * label)
{
KeyboardKey * ret = NULL;
KeyboardKeyRow * p = &layout->rows[row];
KeyboardKey ** q;
GtkAttachOptions options = GTK_EXPAND | GTK_SHRINK | GTK_FILL;
GtkWidget * widget;
if(row >= layout->rows_cnt)
{
if((p = realloc(layout->rows, sizeof(*p) * (row + 1))) == NULL)
return NULL;
layout->rows = p;
for(; layout->rows_cnt <= row; layout->rows_cnt++)
{
layout->rows[layout->rows_cnt].keys = NULL;
layout->rows[layout->rows_cnt].keys_cnt = 0;
layout->rows[layout->rows_cnt].width = 0;
}
p = &layout->rows[row];
}
if((q = realloc(p->keys, sizeof(*q) * (p->keys_cnt + 1))) == NULL)
return NULL;
p->keys = q;
q = &p->keys[p->keys_cnt];
if(keysym != 0 && label != NULL)
{
if((ret = keyboard_key_new(keysym, label)) == NULL)
return NULL;
widget = keyboard_key_get_widget(ret);
g_object_set_data(G_OBJECT(widget), "key", ret);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(
_on_key_clicked), layout);
if(width == 0)
width = 1;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() gtk_table_resize(%u, %u)\n",
__func__, (unsigned)layout->rows_cnt,
(unsigned)p->width + width);
fprintf(stderr, "DEBUG: %s() %s(%u, %u, %u, %u)\n", __func__,
"gtk_table_attach", p->width, p->width + width,
row, row + 1);
#endif
gtk_table_resize(GTK_TABLE(layout->widget),
layout->rows_cnt, p->width + width);
gtk_table_attach(GTK_TABLE(layout->widget), widget, p->width,
p->width + width, row, row + 1, options,
options, 2, 2);
p->keys[p->keys_cnt++] = ret;
}
p->width+=width;
return ret;
}
void ConfigDialog::setupRendererParams ()
{
// Remove all existing child widgets
gtk_container_forall (GTK_CONTAINER (mParamTable),
remove_all_callback, mParamTable);
ConfigOptionMap options = mSelectedRenderSystem->getConfigOptions ();
// Resize the table to hold as many options as we have
gtk_table_resize (GTK_TABLE (mParamTable), options.size (), 2);
uint row = 0;
for (ConfigOptionMap::iterator i = options.begin (); i != options.end (); i++, row++)
{
if (i->second.possibleValues.empty())
{
continue;
}
GtkWidget *ro_label = gtk_label_new (i->second.name.c_str ());
gtk_widget_show (ro_label);
gtk_table_attach (GTK_TABLE (mParamTable), ro_label, 0, 1, row, row + 1,
GtkAttachOptions (GTK_EXPAND | GTK_FILL),
GtkAttachOptions (0), 5, 0);
gtk_label_set_justify (GTK_LABEL (ro_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (ro_label), 1, 0.5);
GtkWidget *ro_cb = gtk_combo_box_new_text ();
gtk_widget_show (ro_cb);
gtk_table_attach (GTK_TABLE (mParamTable), ro_cb, 1, 2, row, row + 1,
GtkAttachOptions (GTK_EXPAND | GTK_FILL),
GtkAttachOptions (0), 5, 0);
// Set up a link from the combobox to the label
g_object_set_data (G_OBJECT (ro_cb), "renderer-option", ro_label);
StringVector::iterator opt_it;
uint idx = 0;
for (opt_it = i->second.possibleValues.begin ();
opt_it != i->second.possibleValues.end (); opt_it++, idx++)
{
gtk_combo_box_append_text (GTK_COMBO_BOX (ro_cb),
(*opt_it).c_str ());
if (strcmp (i->second.currentValue.c_str (), (*opt_it).c_str ()) == 0)
gtk_combo_box_set_active (GTK_COMBO_BOX (ro_cb), idx);
}
g_signal_connect (G_OBJECT (ro_cb), "changed",
G_CALLBACK (optionChanged), this);
}
gtk_widget_grab_focus (GTK_WIDGET (mOKButton));
}
/* If you need to change a table's size after it has been created,
* this function allows you to do so. */
int
clip_GTK_TABLERESIZE(ClipMachine *cm)
{
C_widget *ctbl = _fetch_cw_arg(cm);
guint rows = _clip_parni(cm,2);
guint cols = _clip_parni(cm,3);
CHECKCWID(ctbl,GTK_IS_TABLE);
CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
gtk_table_resize (GTK_TABLE(ctbl->widget), rows, cols);
return 0;
err:
return 1;
}
static void
resize_table (GtkTable * table, gint columns, GList * launcher_list)
{
float rows, remainder;
remove_container_entries (GTK_CONTAINER (table));
rows = ((float) g_list_length (launcher_list)) / (float) columns;
remainder = rows - ((int) rows);
if (remainder != 0.0)
rows += 1;
gtk_table_resize (table, (int) rows, columns);
}
static void
panel_properties_dialog_remove_icon_entry (PanelPropertiesDialog *dialog)
{
GtkContainer *container = GTK_CONTAINER (dialog->general_table);
gtk_container_remove (container, dialog->icon_label);
gtk_container_remove (container, dialog->icon_align);
dialog->icon_label = NULL;
dialog->icon_align = NULL;
dialog->icon_entry = NULL;
gtk_table_resize (GTK_TABLE (dialog->general_table), 3, 2);
}
static void
reset_dialog(GncGWENGui *gui)
{
gboolean cache_passwords;
g_return_if_fail(gui);
ENTER("gui=%p", gui);
gtk_entry_set_text(GTK_ENTRY(gui->top_entry), "");
gtk_entry_set_text(GTK_ENTRY(gui->second_entry), "");
g_list_foreach(gui->progresses, (GFunc) free_progress, NULL);
g_list_free(gui->progresses);
gui->progresses = NULL;
if (gui->other_entries_box)
{
gtk_table_resize(GTK_TABLE(gui->entries_table),
OTHER_ENTRIES_ROW_OFFSET, 2);
gtk_widget_destroy(gui->other_entries_box);
gui->other_entries_box = NULL;
}
if (gui->showbox_hash)
g_hash_table_destroy(gui->showbox_hash);
gui->showbox_last = NULL;
gui->showbox_hash = g_hash_table_new_full(
NULL, NULL, NULL, (GDestroyNotify) gtk_widget_destroy);
if (gui->parent)
gtk_window_set_transient_for(GTK_WINDOW(gui->dialog),
GTK_WINDOW(gui->parent));
gnc_restore_window_size(GCONF_SECTION_CONNECTION, GTK_WINDOW(gui->dialog));
gui->keep_alive = TRUE;
gui->state = INIT;
gui->min_loglevel = GWEN_LoggerLevel_Verbous;
cache_passwords = gnc_gconf_get_bool(GCONF_SECTION_AQBANKING,
KEY_REMEMBER_PIN, NULL);
enable_password_cache(gui, cache_passwords);
if (!gui->accepted_certs)
gui->accepted_certs = g_hash_table_new_full(
g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL);
if (!gui->permanently_accepted_certs)
gui->permanently_accepted_certs = gnc_ab_get_permanent_certs();
LEAVE(" ");
}
static void attach(void * priv, GtkWidget * table,
int * row,
int * num_columns)
{
checkbutton_t * b = (checkbutton_t*)priv;
if(*num_columns < 2)
*num_columns = 2;
gtk_table_resize(GTK_TABLE(table), *row+1, *num_columns);
gtk_table_attach(GTK_TABLE(table), b->button,
0, 2, *row, *row+1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
(*row)++;
}
static void remmina_scaler_init(RemminaScaler *scaler)
{
RemminaScalerPriv *priv;
GtkWidget *widget = NULL;
priv = g_new(RemminaScalerPriv, 1);
scaler->priv = priv;
scaler->hscale = 0;
scaler->vscale = 0;
scaler->aspectscale = FALSE;
gtk_table_resize(GTK_TABLE(scaler), 2, 2);
#if GTK_VERSION == 3
widget = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, MIN_SCALE_VALUE, 1.0, 0.01);
#elif GTK_VERSION == 2
widget = gtk_hscale_new_with_range(MIN_SCALE_VALUE, 1.0, 0.01);
#endif
gtk_widget_show(widget);
gtk_widget_set_tooltip_text(widget, _("Horizontal scale"));
gtk_table_attach_defaults(GTK_TABLE(scaler), widget, 1, 2, 0, 1);
g_signal_connect(G_OBJECT(widget), "format-value", G_CALLBACK(remmina_scaler_format_scale_value), NULL);
priv->hscale_widget = widget;
#if GTK_VERSION == 3
widget = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, MIN_SCALE_VALUE, 1.0, 0.01);
#elif GTK_VERSION == 2
widget = gtk_hscale_new_with_range(MIN_SCALE_VALUE, 1.0, 0.01);
#endif
gtk_widget_show(widget);
gtk_widget_set_tooltip_text(widget, _("Vertical scale"));
gtk_table_attach_defaults(GTK_TABLE(scaler), widget, 1, 2, 1, 2);
g_signal_connect(G_OBJECT(widget), "format-value", G_CALLBACK(remmina_scaler_format_scale_value), NULL);
priv->vscale_widget = widget;
g_signal_connect(G_OBJECT(priv->hscale_widget), "value-changed", G_CALLBACK(remmina_scaler_on_hscale_value_changed),
scaler);
g_signal_connect(G_OBJECT(priv->vscale_widget), "value-changed", G_CALLBACK(remmina_scaler_on_vscale_value_changed),
scaler);
widget = remmina_chain_button_new();
gtk_widget_show(widget);
gtk_table_attach(GTK_TABLE(scaler), widget, 2, 3, 0, 2, 0, 0, 0, 0);
g_signal_connect(G_OBJECT(widget), "chain-toggled", G_CALLBACK(remmina_scaler_on_chain_changed), scaler);
priv->aspectscale_button = widget;
g_signal_connect(G_OBJECT(scaler), "destroy", G_CALLBACK(remmina_scaler_destroy), NULL);
}
