update_statusbar (buffer, GTK_STATUSBAR (statusbar));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
G_CALLBACK (on_assistant_prepare), NULL);
}
- if (!GTK_WIDGET_VISIBLE (assistant))
+ if (!gtk_widget_get_visible (assistant))
gtk_widget_show (assistant);
else
{
G_CALLBACK (gtk_widget_destroyed), &window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
TRUE, TRUE, 5);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
gtk_clipboard_set_can_store (clipboard, NULL, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
G_CALLBACK (change_color_callback), NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry2);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_window_set_default_size (GTK_WINDOW (window), 320, 200);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
g_object_unref (buffer);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_entry_completion_set_text_column (completion, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_container_add (GTK_CONTAINER (expander), label);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show_all (sw);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_container_add (GTK_CONTAINER (window), icon_view);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
vbox);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
gtk_widget_show (label);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
G_CALLBACK (window_closed), NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
if (timeout == 0) {
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
GtkAllocation child_area;
double x, y;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
to_child (bin, widget_x, widget_y, &x, &y);
attributes.window_type = GDK_WINDOW_OFFSCREEN;
child_requisition.width = child_requisition.height = 0;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
attributes.width = bin->child->allocation.width;
attributes.height = bin->child->allocation.height;
GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
gboolean was_visible;
- was_visible = GTK_WIDGET_VISIBLE (widget);
+ was_visible = gtk_widget_get_visible (widget);
if (bin->child == widget)
{
bin->child = NULL;
- if (was_visible && GTK_WIDGET_VISIBLE (container))
+ if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
}
child_requisition.width = 0;
child_requisition.height = 0;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
gtk_widget_size_request (bin->child, &child_requisition);
s = sin (bin->angle);
allocation->y + border_width,
w, h);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
GtkAllocation child_allocation;
GtkAllocation child_area;
cairo_t *cr;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
child_area = bin->child->allocation;
gtk_container_add (GTK_CONTAINER (bin), button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
GtkAllocation child_area;
double x, y;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
to_child (bin, widget_x, widget_y, &x, &y);
attributes.window_type = GDK_WINDOW_OFFSCREEN;
child_requisition.width = child_requisition.height = 0;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
attributes.width = bin->child->allocation.width;
attributes.height = bin->child->allocation.height;
GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
gboolean was_visible;
- was_visible = GTK_WIDGET_VISIBLE (widget);
+ was_visible = gtk_widget_get_visible (widget);
if (bin->child == widget)
{
bin->child = NULL;
- if (was_visible && GTK_WIDGET_VISIBLE (container))
+ if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
}
child_requisition.width = 0;
child_requisition.height = 0;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
gtk_widget_size_request (bin->child, &child_requisition);
requisition->width = GTK_CONTAINER (widget)->border_width * 2 + child_requisition.width + 10;
allocation->y + border_width,
w, h);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
GtkAllocation child_allocation;
cairo_matrix_t matrix;
cairo_pattern_t *mask;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
gdk_drawable_get_size (pixmap, &width, &height);
gtk_box_pack_start (GTK_BOX (hbox), applybutton, FALSE, FALSE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_show_all (vbox);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
gtk_table_attach_defaults (GTK_TABLE (table), picker, 1, 2, 3, 4);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
pango_attr_list_unref (attrs);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
gtk_widget_show_all (menu);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
G_CALLBACK (toggle_grouping), size_group);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
on_play_clicked (NULL, NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
create_text_view (hbox, FALSE);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show_all (vpaned);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
gtk_label_new ("Interactive DnD Mode"));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
calendar->font_dialog);
}
window = calendar->font_dialog;
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
requisition->width = GTK_CONTAINER (widget)->border_width * 2;
requisition->height = GTK_CONTAINER (widget)->border_width * 2;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
alignment = GTK_ALIGNMENT (widget);
bin = GTK_BIN (widget);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkExtendedLayout *layout = GTK_EXTENDED_LAYOUT (bin->child);
GtkBin *bin = GTK_BIN (frame);
gdouble ratio;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkAllocation full_allocation;
page_info = (GtkAssistantPage *) page_node->data;
- while (page_node && !GTK_WIDGET_VISIBLE (page_info->page))
+ while (page_node && !gtk_widget_get_visible (page_info->page))
{
page_node = page_node->next;
current_page++;
g_signal_emit (assistant, signals [PREPARE], 0, priv->current_page->page);
- if (GTK_WIDGET_VISIBLE (priv->current_page->page) && GTK_WIDGET_MAPPED (assistant))
+ if (gtk_widget_get_visible (priv->current_page->page) && GTK_WIDGET_MAPPED (assistant))
{
gtk_widget_set_child_visible (priv->current_page->page, TRUE);
gtk_widget_map (priv->current_page->page);
button[5] = assistant->last;
for (i = 0; i < 6; i++)
{
- if (GTK_WIDGET_VISIBLE (button[i]) && gtk_widget_get_sensitive (button[i]))
+ if (gtk_widget_get_visible (button[i]) && gtk_widget_get_sensitive (button[i]))
{
gtk_widget_grab_focus (button[i]);
break;
g_slist_free_1 (page_node);
}
while (page_info->type == GTK_ASSISTANT_PAGE_PROGRESS ||
- !GTK_WIDGET_VISIBLE (page_info->page));
+ !gtk_widget_get_visible (page_info->page));
set_current_page (assistant, page_info);
}
*/
page_node = priv->pages;
- while (page_node && !GTK_WIDGET_VISIBLE (((GtkAssistantPage *) page_node->data)->page))
+ while (page_node && !gtk_widget_get_visible (((GtkAssistantPage *) page_node->data)->page))
page_node = page_node->next;
if (page_node == element)
child_allocation.height = allocation->height - 2 * GTK_CONTAINER (widget)->border_width -
priv->header_image->allocation.height - 2 * header_padding - ACTION_AREA_SPACING - priv->action_area->allocation.height - 2 * content_padding;
- if (GTK_WIDGET_VISIBLE (priv->sidebar_image))
+ if (gtk_widget_get_visible (priv->sidebar_image))
{
if (!rtl)
child_allocation.x += priv->sidebar_image->allocation.width;
gtk_widget_map (priv->header_image);
gtk_widget_map (priv->action_area);
- if (GTK_WIDGET_VISIBLE (priv->sidebar_image) &&
+ if (gtk_widget_get_visible (priv->sidebar_image) &&
!GTK_WIDGET_MAPPED (priv->sidebar_image))
gtk_widget_map (priv->sidebar_image);
{
page_node = priv->pages;
- while (page_node && !GTK_WIDGET_VISIBLE (((GtkAssistantPage *) page_node->data)->page))
+ while (page_node && !gtk_widget_get_visible (((GtkAssistantPage *) page_node->data)->page))
page_node = page_node->next;
if (page_node)
}
if (page &&
- GTK_WIDGET_VISIBLE (page->page) &&
+ gtk_widget_get_visible (page->page) &&
!GTK_WIDGET_MAPPED (page->page))
set_current_page (assistant, page);
content_x = content_padding + border_width;
content_width = widget->allocation.width - 2 * content_padding - 2 * border_width;
- if (GTK_WIDGET_VISIBLE (priv->sidebar_image))
+ if (gtk_widget_get_visible (priv->sidebar_image))
{
if (!rtl)
content_x += priv->sidebar_image->allocation.width;
gtk_widget_child_notify (child, "secondary");
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (GTK_WIDGET (widget))
+ && gtk_widget_get_visible (child))
gtk_widget_queue_resize (child);
}
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
nchildren += 1;
gtk_widget_size_request (child->widget, &child_requisition);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
child_allocation.width = child_width;
child_allocation.height = child_height;
g_return_if_fail (bin->child == child);
- widget_was_visible = GTK_WIDGET_VISIBLE (child);
+ widget_was_visible = gtk_widget_get_visible (child);
gtk_widget_unparent (child);
bin->child = NULL;
- /* queue resize regardless of GTK_WIDGET_VISIBLE (container),
+ /* queue resize regardless of gtk_widget_get_visible (container),
* since that's what is needed by toplevels, which derive from GtkBin.
*/
if (widget_was_visible)
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
GtkRequisition child_minimum_size;
GtkRequisition child_natural_size;
{
child = children->data;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
nvis_children += 1;
if (child->expand)
gint border_width = GTK_CONTAINER (box)->border_width;
GtkTextDirection direction = gtk_widget_get_direction (widget);
GtkAllocation child_allocation;
-
GtkBoxSpreading *spreading = g_newa (GtkBoxSpreading, nvis_children);
GtkBoxDesiredSizes *sizes = g_newa (GtkBoxDesiredSizes, nvis_children);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
if (child->pack == packing)
{
box->children = g_list_insert_before (box->children, new_link, child_info);
gtk_widget_child_notify (child, "position");
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
+ if (gtk_widget_get_visible (child)
+ && gtk_widget_get_visible (GTK_WIDGET (box)))
gtk_widget_queue_resize (child);
}
child_info->pack = GTK_PACK_START;
gtk_widget_child_notify (child, "pack-type");
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
+ if (gtk_widget_get_visible (child)
+ && gtk_widget_get_visible (GTK_WIDGET (box)))
gtk_widget_queue_resize (child);
}
gtk_widget_thaw_child_notify (child);
{
gboolean was_visible;
- was_visible = GTK_WIDGET_VISIBLE (widget);
+ was_visible = gtk_widget_get_visible (widget);
gtk_widget_unparent (widget);
box->children = g_list_remove_link (box->children, children);
g_list_free (children);
g_free (child);
- /* queue resize regardless of GTK_WIDGET_VISIBLE (container),
+ /* queue resize regardless of gtk_widget_get_visible (container),
* since that's what is needed by toplevels.
*/
if (was_visible)
requisition->height += default_border.top + default_border.bottom;
}
- if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
+ if (GTK_BIN (button)->child && gtk_widget_get_visible (GTK_BIN (button)->child))
{
GtkRequisition child_requisition;
widget->allocation.width - border_width * 2,
widget->allocation.height - border_width * 2);
- if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
+ if (GTK_BIN (button)->child && gtk_widget_get_visible (GTK_BIN (button)->child))
{
child_allocation.x = widget->allocation.x + border_width + inner_border.left + xthickness;
child_allocation.y = widget->allocation.y + border_width + inner_border.top + ythickness;
{
GtkWidget *child = GTK_BIN (widget)->child;
- if (interior_focus && child && GTK_WIDGET_VISIBLE (child))
+ if (interior_focus && child && gtk_widget_get_visible (child))
gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
area, widget, "checkbutton",
child->allocation.x - focus_width - focus_pad,
&indicator_size, &indicator_spacing);
child = GTK_BIN (widget)->child;
- if (child && GTK_WIDGET_VISIBLE (child))
+ if (child && gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
allocation->x, allocation->y,
allocation->width, allocation->height);
- if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
+ if (GTK_BIN (button)->child && gtk_widget_get_visible (GTK_BIN (button)->child))
{
GtkRequisition child_requisition;
gint border_width = GTK_CONTAINER (widget)->border_width;
y = widget->allocation.y + (widget->allocation.height - indicator_size) / 2;
child = GTK_BIN (check_button)->child;
- if (!interior_focus || !(child && GTK_WIDGET_VISIBLE (child)))
+ if (!interior_focus || !(child && gtk_widget_get_visible (child)))
x += focus_width + focus_pad;
if (toggle_button->inconsistent)
clist->shadow_type = type;
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)))
gtk_widget_queue_resize (GTK_WIDGET (clist));
}
NULL);
GTK_WIDGET_SET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)))
gtk_widget_queue_draw (clist->column[column].button);
}
NULL);
GTK_WIDGET_UNSET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)))
gtk_widget_queue_draw (clist->column[column].button);
}
/* if this button didn't previously exist, then the
* column button positions have to be re-computed */
- if (GTK_WIDGET_VISIBLE (clist) && new_button)
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)) && new_button)
size_allocate_title_buttons (clist);
}
/* if this button didn't previously exist, then the
* column button positions have to be re-computed */
- if (GTK_WIDGET_VISIBLE (clist) && new_button)
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)) && new_button)
size_allocate_title_buttons (clist);
}
if (resizeable)
clist->column[column].auto_resize = FALSE;
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)))
size_allocate_title_buttons (clist);
}
}
}
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET (clist)))
size_allocate_title_buttons (clist);
}
for (i = 0; i < clist->columns; i++)
{
if (clist->column[i].button &&
- GTK_WIDGET_VISIBLE (clist->column[i].button) &&
+ gtk_widget_get_visible (clist->column[i].button) &&
!GTK_WIDGET_MAPPED (clist->column[i].button))
gtk_widget_map (clist->column[i].button);
}
if (!GTK_WIDGET_REALIZED (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GdkRectangle tmp_rectangle = widget->allocation;
tmp_rectangle.x += scroll_data->dx;
while (!return_val && j >= 0 && j < clist->columns)
{
if (clist->column[j].button &&
- GTK_WIDGET_VISIBLE (clist->column[j].button))
+ gtk_widget_get_visible (clist->column[j].button))
{
if (focus_column (clist, j, dir))
{
while (!return_val && j != i)
{
if (clist->column[j].button &&
- GTK_WIDGET_VISIBLE (clist->column[j].button))
+ gtk_widget_get_visible (clist->column[j].button))
{
if (focus_column (clist, j, dir))
{
gtk_combo_selection_changed (GtkList *list,
GtkCombo *combo)
{
- if (!GTK_WIDGET_VISIBLE (combo->popwin))
+ if (!gtk_widget_get_visible (combo->popwin))
gtk_combo_update_entry (combo);
}
if (active == child)
break;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
gtk_widget_get_child_requisition (child, &requisition);
menu_ypos -= requisition.height;
gtk_combo_box_menu_position_over (menu, x, y, push_in, user_data);
}
- if (!GTK_WIDGET_VISIBLE (GTK_MENU (priv->popup_widget)->toplevel))
+ if (!gtk_widget_get_visible (GTK_MENU (priv->popup_widget)->toplevel))
gtk_window_set_type_hint (GTK_WINDOW (GTK_MENU (priv->popup_widget)->toplevel),
GDK_WINDOW_TYPE_HINT_COMBO);
}
child.width -= child.x;
}
- if (GTK_WIDGET_VISIBLE (priv->popup_widget))
+ if (gtk_widget_get_visible (priv->popup_widget))
{
gint width;
GtkRequisition requisition;
child.height -= delta_y * 2;
}
- if (GTK_WIDGET_VISIBLE (priv->popup_window))
+ if (gtk_widget_get_visible (priv->popup_window))
{
gint x, y, width, height;
gtk_combo_box_list_position (combo_box, &x, &y, &width, &height);
if (resize_container)
{
- if (GTK_WIDGET_VISIBLE (resize_container) &&
+ if (gtk_widget_get_visible (GTK_WIDGET (resize_container)) &&
(gtk_widget_is_toplevel (GTK_WIDGET (resize_container)) || GTK_WIDGET_REALIZED (resize_container)))
{
switch (resize_container->resize_mode)
gtk_container_map_child (GtkWidget *child,
gpointer client_data)
{
- if (GTK_WIDGET_VISIBLE (child) &&
+ if (gtk_widget_get_visible (child) &&
GTK_WIDGET_CHILD_VISIBLE (child) &&
!GTK_WIDGET_MAPPED (child))
gtk_widget_map (child);
if (!was_modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
- if (!GTK_WIDGET_VISIBLE (dialog))
+ if (!gtk_widget_get_visible (GTK_WIDGET (dialog)))
gtk_widget_show (GTK_WIDGET (dialog));
response_handler =
info->cur_x - hot_x,
info->cur_y - hot_y);
- if (GTK_WIDGET_VISIBLE (icon_window))
+ if (gtk_widget_get_visible (icon_window))
gdk_window_raise (icon_window->window);
else
gtk_widget_show (icon_window);
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
g_object_get (completion, "popup-single-match", &popup_single, NULL);
if ((matches > (popup_single ? 0: 1)) || actions > 0)
{
- if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_resize_popup (completion);
else
_gtk_entry_completion_popup (completion);
else
_gtk_entry_completion_popdown (completion);
}
- else if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ else if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_popdown (completion);
return FALSE;
if (completion->priv->minimum_key_length > 0 &&
strcmp ("", gtk_entry_get_text (GTK_ENTRY (entry))) == 0)
{
- if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_popdown (completion);
return;
}
g_object_notify (G_OBJECT (completion), "model");
- if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_resize_popup (completion);
}
gtk_tree_model_filter_refilter (completion->priv->filter_model);
- if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_resize_popup (completion);
}
{
if (GTK_WIDGET_REALIZED (widget))
{
- gboolean visible = GTK_WIDGET_VISIBLE (widget);
+ gboolean visible = gtk_widget_get_visible (widget);
if (visible)
gtk_widget_hide (widget);
gtk_widget_set_has_window (widget, visible_window);
}
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_widget_queue_resize (widget);
g_object_notify (G_OBJECT (event_box), "visible-window");
}
else
{
- gboolean visible = GTK_WIDGET_VISIBLE (widget);
+ gboolean visible = gtk_widget_get_visible (widget);
if (visible)
gtk_widget_hide (widget);
}
}
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_widget_queue_resize (widget);
g_object_notify (G_OBJECT (event_box), "above-child");
requisition->width = GTK_CONTAINER (widget)->border_width * 2;
requisition->height = GTK_CONTAINER (widget)->border_width * 2;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
get_expander_bounds (GTK_EXPANDER (widget), &expander_rect);
- if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
+ if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
{
GtkRequisition label_requisition;
2 * focus_width + 2 * focus_pad;
requisition->height = interior_focus ? (2 * focus_width + 2 * focus_pad) : 0;
- if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
+ if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
{
GtkRequisition label_requisition;
rect->x += widget->allocation.width - 2 * border_width -
expander_spacing - expander_size;
- if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
+ if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
{
GtkAllocation label_allocation;
widget->allocation = *allocation;
- if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
+ if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
{
GtkAllocation label_allocation;
GtkRequisition label_requisition;
area.y = widget->allocation.y + container->border_width;
area.width = widget->allocation.width - (2 * container->border_width);
- if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
+ if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
area.height = priv->label_widget->allocation.height;
else
area.height = 0;
if (priv->label_widget)
{
- if (GTK_WIDGET_VISIBLE (priv->label_widget))
+ if (gtk_widget_get_visible (priv->label_widget))
{
GtkAllocation label_allocation = priv->label_widget->allocation;
GtkWidget *label_widget)
{
GtkExpanderPrivate *priv;
+ GtkWidget *widget;
g_return_if_fail (GTK_IS_EXPANDER (expander));
g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
}
priv->label_widget = label_widget;
+ widget = GTK_WIDGET (expander);
if (label_widget)
{
priv->label_widget = label_widget;
- gtk_widget_set_parent (label_widget, GTK_WIDGET (expander));
+ gtk_widget_set_parent (label_widget, widget);
if (priv->prelight)
gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT);
}
- if (GTK_WIDGET_VISIBLE (expander))
- gtk_widget_queue_resize (GTK_WIDGET (expander));
+ if (gtk_widget_get_visible (widget))
+ gtk_widget_queue_resize (widget);
g_object_freeze_notify (G_OBJECT (expander));
g_object_notify (G_OBJECT (expander), "label-widget");
/* Setup the dialog parent to be chooser button's toplevel, and be modal
as needed. */
- if (!GTK_WIDGET_VISIBLE (priv->dialog))
+ if (!gtk_widget_get_visible (priv->dialog))
{
GtkWidget *toplevel;
if (impl->preview_widget_active &&
impl->preview_widget &&
- GTK_WIDGET_VISIBLE (impl->preview_widget))
+ gtk_widget_get_visible (impl->preview_widget))
{
gtk_widget_size_request (impl->preview_box, &req);
*default_width += PREVIEW_HBOX_SPACING + req.width;
}
if (impl->extra_widget &&
- GTK_WIDGET_VISIBLE (impl->extra_widget))
+ gtk_widget_get_visible (impl->extra_widget))
{
gtk_widget_size_request (impl->extra_align, &req);
*default_height += GTK_BOX (chooser_embed)->spacing + req.height;
gtk_widget_thaw_child_notify (widget);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (fixed))
+ if (gtk_widget_get_visible (widget) &&
+ gtk_widget_get_visible (GTK_WIDGET (fixed)))
gtk_widget_queue_resize (GTK_WIDGET (fixed));
}
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
gtk_widget_size_request (child->widget, &child_requisition);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
gtk_widget_get_child_requisition (child->widget, &child_requisition);
child_allocation.x = child->x + border_width;
{
GtkFixed *fixed;
GtkFixedChild *child;
+ GtkWidget *widget_container;
GList *children;
fixed = GTK_FIXED (container);
+ widget_container = GTK_WIDGET (container);
children = fixed->children;
while (children)
if (child->widget == widget)
{
- gboolean was_visible = GTK_WIDGET_VISIBLE (widget);
+ gboolean was_visible = gtk_widget_get_visible (widget);
gtk_widget_unparent (widget);
g_list_free (children);
g_free (child);
- if (was_visible && GTK_WIDGET_VISIBLE (container))
- gtk_widget_queue_resize (GTK_WIDGET (container));
+ if (was_visible && gtk_widget_get_visible (widget_container))
+ gtk_widget_queue_resize (widget_container);
break;
}
G_CALLBACK (dialog_destroy), font_button);
}
- if (!GTK_WIDGET_VISIBLE (font_button->priv->font_dialog))
+ if (!gtk_widget_get_visible (font_button->priv->font_dialog))
{
font_dialog = GTK_FONT_SELECTION_DIALOG (font_button->priv->font_dialog);
if (frame->label_widget)
{
- need_resize = GTK_WIDGET_VISIBLE (frame->label_widget);
+ need_resize = gtk_widget_get_visible (frame->label_widget);
gtk_widget_unparent (frame->label_widget);
}
{
frame->label_widget = label_widget;
gtk_widget_set_parent (label_widget, GTK_WIDGET (frame));
- need_resize |= GTK_WIDGET_VISIBLE (label_widget);
+ need_resize |= gtk_widget_get_visible (label_widget);
}
- if (GTK_WIDGET_VISIBLE (frame) && need_resize)
+ if (gtk_widget_get_visible (GTK_WIDGET (frame)) && need_resize)
gtk_widget_queue_resize (GTK_WIDGET (frame));
g_object_freeze_notify (G_OBJECT (frame));
GtkBin *bin = GTK_BIN (widget);
GtkRequisition child_requisition;
- if (frame->label_widget && GTK_WIDGET_VISIBLE (frame->label_widget))
+ if (frame->label_widget && gtk_widget_get_visible (frame->label_widget))
{
gtk_widget_size_request (frame->label_widget, &child_requisition);
requisition->height = 0;
}
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
gtk_widget_size_request (bin->child, &child_requisition);
new_allocation.height != frame->child_allocation.height))
gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
gtk_widget_size_allocate (bin->child, &new_allocation);
frame->child_allocation = new_allocation;
- if (frame->label_widget && GTK_WIDGET_VISIBLE (frame->label_widget))
+ if (frame->label_widget && gtk_widget_get_visible (frame->label_widget))
{
GtkRequisition child_requisition;
GtkAllocation child_allocation;
hb = GTK_HANDLE_BOX (widget);
if (bin->child &&
- GTK_WIDGET_VISIBLE (bin->child) &&
+ gtk_widget_get_visible (bin->child) &&
!GTK_WIDGET_MAPPED (bin->child))
gtk_widget_map (bin->child);
widget->allocation.height);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkAllocation child_allocation;
guint border_width;
event ? &event->area : area,
handle_orientation);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
GTK_WIDGET_CLASS (gtk_handle_box_parent_class)->expose_event (widget, event);
}
tmp_list = tmp_list->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
gtk_widget_size_request (child->widget, &child_requisition);
}
}
gint image_width,
gint image_height)
{
- GTK_WIDGET (image)->requisition.width = image_width + GTK_MISC (image)->xpad * 2;
- GTK_WIDGET (image)->requisition.height = image_height + GTK_MISC (image)->ypad * 2;
+ GtkWidget *widget = GTK_WIDGET (image);
+
+ widget->requisition.width = image_width + GTK_MISC (image)->xpad * 2;
+ widget->requisition.height = image_height + GTK_MISC (image)->ypad * 2;
- if (GTK_WIDGET_VISIBLE (image))
- gtk_widget_queue_resize (GTK_WIDGET (image));
+ if (gtk_widget_get_visible (widget))
+ gtk_widget_queue_resize (widget);
}
*requisition = 0;
- if (image_menu_item->image && GTK_WIDGET_VISIBLE (image_menu_item->image))
+ if (image_menu_item->image && gtk_widget_get_visible (image_menu_item->image))
{
GtkRequisition image_requisition;
guint toggle_spacing;
image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
- if (image_menu_item->image && GTK_WIDGET_VISIBLE (image_menu_item->image))
+ if (image_menu_item->image && gtk_widget_get_visible (image_menu_item->image))
{
GtkRequisition child_requisition;
GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation);
- if (image_menu_item->image && GTK_WIDGET_VISIBLE (image_menu_item->image))
+ if (image_menu_item->image && gtk_widget_get_visible (image_menu_item->image))
{
gint x, y, offset;
GtkRequisition child_requisition;
{
gboolean widget_was_visible;
- widget_was_visible = GTK_WIDGET_VISIBLE (child);
+ widget_was_visible = gtk_widget_get_visible (child);
gtk_widget_unparent (child);
image_menu_item->image = NULL;
- if (GTK_WIDGET_VISIBLE (container) && widget_was_visible)
+ if (widget_was_visible &&
+ gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
g_object_notify (G_OBJECT (image_menu_item), "image");
gtk_label_ensure_layout (label);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget) &&
+ if (gtk_widget_get_visible (widget) && GTK_WIDGET_MAPPED (widget) &&
label->text && (*label->text != '\0'))
{
get_layout_location (label, &x, &y);
gtk_widget_thaw_child_notify (widget);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (layout))
- gtk_widget_queue_resize (GTK_WIDGET (widget));
+ if (gtk_widget_get_visible (widget) &&
+ gtk_widget_get_visible (GTK_WIDGET (layout)))
+ gtk_widget_queue_resize (widget);
}
/**
GtkLayoutChild *child = tmp_list->data;
tmp_list = tmp_list->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
if (!GTK_WIDGET_MAPPED (child->widget))
gtk_widget_map (child->widget);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
gtk_widget_get_child_requisition (child, &child_requisition);
}
}
- if (GTK_WIDGET_VISIBLE (list))
+ if (gtk_widget_get_visible (GTK_WIDGET (list)))
gtk_widget_queue_resize (GTK_WIDGET (list));
}
}
}
- if (GTK_WIDGET_VISIBLE (list))
+ if (gtk_widget_get_visible (GTK_WIDGET (list)))
gtk_widget_queue_resize (GTK_WIDGET (list));
}
requisition->height = 2 * (GTK_CONTAINER (widget)->border_width +
focus_width + focus_pad - 1);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
gtk_widget_size_request (bin->child, &child_requisition);
gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, str, -1);
level -= 1;
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
}
#endif
/* We need to show the menu here rather in the init function because
* code expects to be able to tell if the menu is onscreen by
- * looking at the GTK_WIDGET_VISIBLE (menu)
+ * looking at the gtk_widget_get_visible (menu)
*/
gtk_widget_show (GTK_WIDGET (menu));
if (!menu->tearoff_window)
return;
- if (GTK_WIDGET_VISIBLE (menu->tearoff_scrollbar))
+ if (gtk_widget_get_visible (menu->tearoff_scrollbar))
{
gtk_widget_size_request (menu->tearoff_scrollbar, NULL);
width += menu->tearoff_scrollbar->requisition.width;
if (menu->torn_off)
{
- if (GTK_WIDGET_VISIBLE (menu))
+ if (gtk_widget_get_visible (GTK_WIDGET (menu)))
gtk_menu_popdown (menu);
if (!menu->tearoff_window)
child = children->data;
children = children->next;
- if (! GTK_WIDGET_VISIBLE (child))
+ if (! gtk_widget_get_visible (child))
continue;
get_effective_child_attach (child, &l, &r, &t, &b);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
gint i;
gint l, r, t, b;
{
if (allocation->height >= widget->requisition.height)
{
- if (GTK_WIDGET_VISIBLE (menu->tearoff_scrollbar))
+ if (gtk_widget_get_visible (menu->tearoff_scrollbar))
{
gtk_widget_hide (menu->tearoff_scrollbar);
gtk_menu_set_tearoff_hints (menu, allocation->width);
gtk_adjustment_changed (menu->tearoff_adjustment);
- if (!GTK_WIDGET_VISIBLE (menu->tearoff_scrollbar))
+ if (!gtk_widget_get_visible (menu->tearoff_scrollbar))
{
gtk_widget_show (menu->tearoff_scrollbar);
gtk_menu_set_tearoff_hints (menu, allocation->width);
private->initially_pushed_in = FALSE;
/* Set the type hint here to allow custom position functions to set a different hint */
- if (!GTK_WIDGET_VISIBLE (menu->toplevel))
+ if (!gtk_widget_get_visible (menu->toplevel))
gtk_window_set_type_hint (GTK_WINDOW (menu->toplevel), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
if (menu->position_func)
for (children = menu_shell->children; children; children = children->next)
{
- if (GTK_WIDGET_VISIBLE (children->data))
+ if (gtk_widget_get_visible (children->data))
{
GtkRequisition child_requisition;
requisition->width = 0;
requisition->height = 0;
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
menu_bar = GTK_MENU_BAR (widget);
menu_shell = GTK_MENU_SHELL (widget);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
gint toggle_size;
ltr_x = allocation->width -
child_requisition.width - offset;
}
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
if ((direction == GTK_TEXT_DIR_LTR) == (priv->pack_direction == GTK_PACK_DIRECTION_LTR))
child_allocation.x = ltr_x;
ltr_y = allocation->height -
child_requisition.height - offset;
}
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
if ((direction == GTK_TEXT_DIR_LTR) ==
(priv->pack_direction == GTK_PACK_DIRECTION_TTB))
(child_pack_dir == GTK_PACK_DIRECTION_TTB || child_pack_dir == GTK_PACK_DIRECTION_BTT))
requisition->height += 2 * horizontal_padding;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
gtk_menu_set_monitor (menu, monitor_num);
- if (!GTK_WIDGET_VISIBLE (menu->toplevel))
+ if (!gtk_widget_get_visible (menu->toplevel))
{
gtk_window_set_type_hint (GTK_WINDOW (menu->toplevel), menu_item->from_menubar?
GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU : GDK_WINDOW_TYPE_HINT_POPUP_MENU);
guint signal_id)
{
/* Chain to the parent GtkMenu for further checks */
- return (gtk_widget_is_sensitive (widget) && GTK_WIDGET_VISIBLE (widget) &&
+ return (gtk_widget_is_sensitive (widget) && gtk_widget_get_visible (widget) &&
widget->parent && gtk_widget_can_activate_accel (widget->parent, signal_id));
}
G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
!gtk_widget_is_sensitive (menu_item) ||
- !GTK_WIDGET_VISIBLE (menu_item))
+ !gtk_widget_get_visible (menu_item))
return FALSE;
return TRUE;
if (menu_item && _gtk_menu_item_is_selectable (menu_item) &&
GTK_MENU_ITEM (menu_item)->submenu != NULL &&
- !GTK_WIDGET_VISIBLE (GTK_MENU_ITEM (menu_item)->submenu))
+ !gtk_widget_get_visible (GTK_MENU_ITEM (menu_item)->submenu))
{
GtkMenuShellPrivate *priv;
priv = GTK_MENU_SHELL_GET_PRIVATE (menu_item->parent);
priv->activated_submenu = TRUE;
- if (!GTK_WIDGET_VISIBLE (GTK_MENU_ITEM (menu_item)->submenu))
+ if (!gtk_widget_get_visible (GTK_MENU_ITEM (menu_item)->submenu))
{
gboolean touchscreen_mode;
event->mode == GDK_CROSSING_STATE_CHANGED)
return TRUE;
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget);
GtkWidget *event_widget = gtk_get_event_widget ((GdkEvent*) event);
GtkMenuShell *menu_shell = GTK_MENU_SHELL (container);
gint was_visible;
- was_visible = GTK_WIDGET_VISIBLE (widget);
+ was_visible = gtk_widget_get_visible (widget);
menu_shell->children = g_list_remove (menu_shell->children, widget);
if (widget == menu_shell->active_menu_item)
gtk_widget_unparent (widget);
- /* queue resize regardless of GTK_WIDGET_VISIBLE (container),
+ /* queue resize regardless of gtk_widget_get_visible (container),
* since that's what is needed by toplevels.
*/
if (was_visible)
{
GtkWidget *child = tmp_list->data;
- if ((!search_sensitive && GTK_WIDGET_VISIBLE (child)) ||
+ if ((!search_sensitive && gtk_widget_get_visible (child)) ||
_gtk_menu_item_is_selectable (child))
{
to_select = child;
{
GtkWidget *child = tmp_list->data;
- if ((!search_sensitive && GTK_WIDGET_VISIBLE (child)) ||
+ if ((!search_sensitive && gtk_widget_get_visible (child)) ||
_gtk_menu_item_is_selectable (child))
{
to_select = child;
if (touchscreen_mode &&
menu_shell->active_menu_item &&
GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu &&
- GTK_WIDGET_VISIBLE (GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu))
+ gtk_widget_get_visible (GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu))
{
/* if we are on a menu item that has an open submenu but the
* focus is not in that submenu (e.g. because it's empty or
return;
if (gtk_toggle_button_get_active (togglebutton) &&
- !GTK_WIDGET_VISIBLE (priv->menu))
+ !gtk_widget_get_visible (GTK_WIDGET (priv->menu)))
{
/* we get here only when the menu is activated by a key
* press, so that we can select the first menu item */
if (priv->menu != GTK_MENU (menu))
{
- if (priv->menu && GTK_WIDGET_VISIBLE (priv->menu))
+ if (priv->menu && gtk_widget_get_visible (GTK_WIDGET (priv->menu)))
gtk_menu_shell_deactivate (GTK_MENU_SHELL (priv->menu));
if (priv->menu)
for (tmp_list = notebook->children; tmp_list; tmp_list = tmp_list->next)
{
GtkNotebookPage *page = tmp_list->data;
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (gtk_widget_get_visible (page->child))
{
visible_page = page;
break;
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i] &&
- GTK_WIDGET_VISIBLE (priv->action_widget[i]))
+ gtk_widget_get_visible (priv->action_widget[i]))
{
rectangle->width -= priv->action_widget[i]->allocation.width;
if ((!is_rtl && i == ACTION_WIDGET_START) ||
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i] &&
- GTK_WIDGET_VISIBLE (priv->action_widget[i]))
+ gtk_widget_get_visible (priv->action_widget[i]))
{
rectangle->height -= priv->action_widget[i]->allocation.height;
priv = GTK_NOTEBOOK_GET_PRIVATE (notebook);
if (notebook->cur_page &&
- GTK_WIDGET_VISIBLE (notebook->cur_page->child) &&
+ gtk_widget_get_visible (notebook->cur_page->child) &&
!GTK_WIDGET_MAPPED (notebook->cur_page->child))
gtk_widget_map (notebook->cur_page->child);
for (i = 0; i < N_ACTION_WIDGETS; i++)
{
if (priv->action_widget[i] &&
- GTK_WIDGET_VISIBLE (priv->action_widget[i]) &&
+ gtk_widget_get_visible (priv->action_widget[i]) &&
GTK_WIDGET_CHILD_VISIBLE (priv->action_widget[i]) &&
!GTK_WIDGET_MAPPED (priv->action_widget[i]))
gtk_widget_map (priv->action_widget[i]);
children = children->next;
if (page->tab_label &&
- GTK_WIDGET_VISIBLE (page->tab_label) &&
+ gtk_widget_get_visible (page->tab_label) &&
!GTK_WIDGET_MAPPED (page->tab_label))
gtk_widget_map (page->tab_label);
}
{
page = children->data;
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (gtk_widget_get_visible (page->child))
{
vis_pages++;
gtk_widget_size_request (page->child, &child_requisition);
child_requisition.height);
if (notebook->menu && page->menu_label->parent &&
- !GTK_WIDGET_VISIBLE (page->menu_label->parent))
+ !gtk_widget_get_visible (page->menu_label->parent))
gtk_widget_show (page->menu_label->parent);
}
else
if (page == notebook->cur_page)
switch_page = TRUE;
if (notebook->menu && page->menu_label->parent &&
- GTK_WIDGET_VISIBLE (page->menu_label->parent))
+ gtk_widget_get_visible (page->menu_label->parent))
gtk_widget_hide (page->menu_label->parent);
}
}
{
page = children->data;
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (gtk_widget_get_visible (page->child))
{
- if (!GTK_WIDGET_VISIBLE (page->tab_label))
+ if (!gtk_widget_get_visible (page->tab_label))
gtk_widget_show (page->tab_label);
gtk_widget_size_request (page->tab_label,
break;
}
}
- else if (GTK_WIDGET_VISIBLE (page->tab_label))
+ else if (gtk_widget_get_visible (page->tab_label))
gtk_widget_hide (page->tab_label);
}
page = children->data;
children = children->next;
- if (!GTK_WIDGET_VISIBLE (page->child))
+ if (!gtk_widget_get_visible (page->child))
continue;
if (notebook->homogeneous)
page = children->data;
children = children->next;
- if (!GTK_WIDGET_VISIBLE (page->child))
+ if (!gtk_widget_get_visible (page->child))
continue;
page->requisition.width = tab_width;
{
page = children->data;
- if (page->tab_label && GTK_WIDGET_VISIBLE (page->tab_label))
+ if (page->tab_label && gtk_widget_get_visible (page->tab_label))
gtk_widget_hide (page->tab_label);
}
}
children = children->next)
{
page = children->data;
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (gtk_widget_get_visible (page->child))
{
gtk_notebook_switch_page (notebook, page);
break;
}
}
}
- else if (GTK_WIDGET_VISIBLE (widget))
+ else if (gtk_widget_get_visible (widget))
{
widget->requisition.width = GTK_CONTAINER (widget)->border_width * 2;
widget->requisition.height= GTK_CONTAINER (widget)->border_width * 2;
page = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (gtk_widget_get_visible (page->child))
gtk_widget_size_allocate (page->child, &child_allocation);
}
{
page = children->data;
- if (GTK_WIDGET_VISIBLE (page->child) &&
+ if (gtk_widget_get_visible (page->child) &&
page->tab_label && GTK_WIDGET_MAPPED (page->tab_label) &&
(x >= page->allocation.x) &&
(y >= page->allocation.y) &&
page = children->data;
if ((priv->operation != DRAG_OPERATION_REORDER || page != notebook->cur_page) &&
- GTK_WIDGET_VISIBLE (page->child) &&
+ gtk_widget_get_visible (page->child) &&
page->tab_label &&
GTK_WIDGET_MAPPED (page->tab_label) &&
page->pack == pack)
GtkNotebookPrivate *priv = GTK_NOTEBOOK_GET_PRIVATE (notebook);
if (priv->action_widget[action] &&
- GTK_WIDGET_VISIBLE (priv->action_widget[action]))
+ gtk_widget_get_visible (priv->action_widget[action]))
return gtk_widget_child_focus (priv->action_widget[action], direction);
else
return FALSE;
if (notebook->cur_page &&
notebook->cur_page->child == page &&
- !GTK_WIDGET_VISIBLE (page))
+ !gtk_widget_get_visible (page))
{
list = g_list_find (notebook->children, notebook->cur_page);
if (list)
if (tab_label)
{
- if (notebook->show_tabs && GTK_WIDGET_VISIBLE (child))
+ if (notebook->show_tabs && gtk_widget_get_visible (child))
gtk_widget_show (tab_label);
else
gtk_widget_hide (tab_label);
g_signal_handler_disconnect (page->child, page->notify_visible_handler);
- if (GTK_WIDGET_VISIBLE (page->child) && GTK_WIDGET_VISIBLE (notebook))
+ if (gtk_widget_get_visible (page->child) &&
+ gtk_widget_get_visible (GTK_WIDGET (notebook)))
need_resize = TRUE;
gtk_widget_unparent (page->child);
gtk_label_set_text (GTK_LABEL (page->tab_label), string);
}
- if (GTK_WIDGET_VISIBLE (page->child) &&
- !GTK_WIDGET_VISIBLE (page->tab_label))
+ if (gtk_widget_get_visible (page->child) &&
+ !gtk_widget_get_visible (page->tab_label))
gtk_widget_show (page->tab_label);
- else if (!GTK_WIDGET_VISIBLE (page->child) &&
- GTK_WIDGET_VISIBLE (page->tab_label))
+ else if (!gtk_widget_get_visible (page->child) &&
+ gtk_widget_get_visible (page->tab_label))
gtk_widget_hide (page->tab_label);
}
if (notebook->menu && page->default_menu)
page = list->data;
if (page->pack == flag &&
(!find_visible ||
- (GTK_WIDGET_VISIBLE (page->child) &&
+ (gtk_widget_get_visible (page->child) &&
(!page->tab_label || NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)))))
return list;
old_list = list;
page = list->data;
if (page->pack != flag &&
(!find_visible ||
- (GTK_WIDGET_VISIBLE (page->child) &&
+ (gtk_widget_get_visible (page->child) &&
(!page->tab_label || NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)))))
return list;
old_list = list;
tab_pos = get_effective_tab_pos (notebook);
if ((!notebook->show_tabs && !notebook->show_border) ||
- !notebook->cur_page || !GTK_WIDGET_VISIBLE (notebook->cur_page->child))
+ !notebook->cur_page || !gtk_widget_get_visible (notebook->cur_page->child))
return;
x = widget->allocation.x + border_width;
page = children->data;
children = gtk_notebook_search_page (notebook, children,
step, TRUE);
- if (!GTK_WIDGET_VISIBLE (page->child))
+ if (!gtk_widget_get_visible (page->child))
continue;
if (!GTK_WIDGET_MAPPED (page->tab_label))
showarrow = TRUE;
children = children->next;
if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) &&
- GTK_WIDGET_VISIBLE (page->child))
+ gtk_widget_get_visible (page->child))
*tab_space += page->requisition.width;
}
break;
children = children->next;
if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) &&
- GTK_WIDGET_VISIBLE (page->child))
+ gtk_widget_get_visible (page->child))
*tab_space += page->requisition.height;
}
break;
*remaining_space = tab_space;
if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, notebook->cur_page) &&
- GTK_WIDGET_VISIBLE (notebook->cur_page->child))
+ gtk_widget_get_visible (notebook->cur_page->child))
{
gtk_notebook_calc_tabs (notebook,
notebook->focus_tab,
/* Is first_tab really predecessor of focus_tab? */
page = notebook->first_tab->data;
if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) &&
- GTK_WIDGET_VISIBLE (page->child))
+ gtk_widget_get_visible (page->child))
for (children = notebook->focus_tab;
children && children != notebook->first_tab;
children = gtk_notebook_search_page (notebook,
children = children->next;
if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) ||
- !GTK_WIDGET_VISIBLE (page->child))
+ !gtk_widget_get_visible (page->child))
continue;
c++;
{
*children = (*children)->next;
- if (page->pack != GTK_PACK_END || !GTK_WIDGET_VISIBLE (page->child))
+ if (page->pack != GTK_PACK_END || !gtk_widget_get_visible (page->child))
continue;
}
gboolean was_visible = page->tab_allocated_visible;
if (!page->tab_label ||
- !GTK_WIDGET_VISIBLE (page->tab_label) ||
+ !gtk_widget_get_visible (page->tab_label) ||
!gtk_widget_get_child_visible (page->tab_label))
{
page->tab_allocated_visible = FALSE;
{
page = children->data;
if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) &&
- GTK_WIDGET_VISIBLE (page->child))
+ gtk_widget_get_visible (page->child))
{
if (page->pack == pack)
{
{
page = children->data;
if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) &&
- GTK_WIDGET_VISIBLE (page->child))
+ gtk_widget_get_visible (page->child))
{
if (page->pack == pack)
{
{
gboolean child_has_focus;
- if (notebook->cur_page == page || !GTK_WIDGET_VISIBLE (page->child))
+ if (notebook->cur_page == page || !gtk_widget_get_visible (page->child))
return;
/* save the value here, changing visibility changes focus */
gtk_notebook_real_page_position (notebook, list));
g_signal_connect (menu_item, "activate",
G_CALLBACK (gtk_notebook_menu_switch_page), page);
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (gtk_widget_get_visible (page->child))
gtk_widget_show (menu_item);
}
notebook->tab_hborder = border_width;
notebook->tab_vborder = border_width;
- if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
+ if (notebook->show_tabs &&
+ gtk_widget_get_visible (GTK_WIDGET (notebook)))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
g_object_freeze_notify (G_OBJECT (notebook));
notebook->tab_hborder = tab_hborder;
- if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
+ if (notebook->show_tabs &&
+ gtk_widget_get_visible (GTK_WIDGET (notebook)))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
g_object_notify (G_OBJECT (notebook), "tab-hborder");
notebook->tab_vborder = tab_vborder;
- if (GTK_WIDGET_VISIBLE (notebook) && notebook->show_tabs)
+ if (notebook->show_tabs &&
+ gtk_widget_get_visible (GTK_WIDGET (notebook)))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
g_object_notify (G_OBJECT (notebook), "tab-vborder");
{
notebook->show_border = show_border;
- if (GTK_WIDGET_VISIBLE (notebook))
+ if (gtk_widget_get_visible (GTK_WIDGET (notebook)))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
g_object_notify (G_OBJECT (notebook), "show-border");
if (notebook->tab_pos != pos)
{
notebook->tab_pos = pos;
- if (GTK_WIDGET_VISIBLE (notebook))
+ if (gtk_widget_get_visible (GTK_WIDGET (notebook)))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
{
notebook->scrollable = scrollable;
- if (GTK_WIDGET_VISIBLE (notebook))
+ if (gtk_widget_get_visible (GTK_WIDGET (notebook)))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
g_object_notify (G_OBJECT (notebook), "scrollable");
G_CALLBACK (gtk_notebook_mnemonic_activate_switch_page),
notebook);
- if (notebook->show_tabs && GTK_WIDGET_VISIBLE (child))
+ if (notebook->show_tabs && gtk_widget_get_visible (child))
{
gtk_widget_show (page->tab_label);
gtk_widget_queue_resize (GTK_WIDGET (notebook));
requisition->width = border_width * 2;
requisition->height = border_width * 2;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_req;
allocation->width,
allocation->height);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkAllocation child_alloc;
{
GtkWidget *widget = GTK_WIDGET (container);
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_offscreen_window_resize (widget);
}
gtk_option_menu_get_props (option_menu, &props);
- if (GTK_BIN (option_menu)->child && GTK_WIDGET_VISIBLE (GTK_BIN (option_menu)->child))
+ if (GTK_BIN (option_menu)->child && gtk_widget_get_visible (GTK_BIN (option_menu)->child))
{
gtk_widget_size_request (GTK_BIN (option_menu)->child, &child_requisition);
allocation->width - border_width * 2, allocation->height - border_width * 2);
child = GTK_BIN (widget)->child;
- if (child && GTK_WIDGET_VISIBLE (child))
+ if (child && gtk_widget_get_visible (child))
{
gint xthickness = GTK_WIDGET (widget)->style->xthickness;
gint ythickness = GTK_WIDGET (widget)->style->ythickness;
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
GtkWidget *inner = GTK_BIN (child)->child;
if (active == child)
break;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
gtk_widget_get_child_requisition (child, &requisition);
menu_ypos -= requisition.height;
l = g_list_nth (GTK_MENU_SHELL (option_menu->menu)->children, index);
item = GTK_MENU_ITEM (l->data);
- if (GTK_WIDGET_VISIBLE (item) && gtk_widget_is_sensitive (GTK_WIDGET (item)))
+ if (gtk_widget_get_visible (GTK_WIDGET (item)) &&
+ gtk_widget_is_sensitive (GTK_WIDGET (item)))
{
gtk_option_menu_set_history (option_menu, index);
gtk_menu_item_activate (GTK_MENU_ITEM (item));
requisition->width = 0;
requisition->height = 0;
- if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
+ if (paned->child1 && gtk_widget_get_visible (paned->child1))
{
gtk_widget_size_request (paned->child1, &child_requisition);
requisition->width = child_requisition.width;
}
- if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
+ if (paned->child2 && gtk_widget_get_visible (paned->child2))
{
gtk_widget_size_request (paned->child2, &child_requisition);
requisition->width += GTK_CONTAINER (paned)->border_width * 2;
requisition->height += GTK_CONTAINER (paned)->border_width * 2;
- if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
- paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
+ if (paned->child1 && gtk_widget_get_visible (paned->child1) &&
+ paned->child2 && gtk_widget_get_visible (paned->child2))
{
gint handle_size;
widget->allocation = *allocation;
- if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
- paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
+ if (paned->child1 && gtk_widget_get_visible (paned->child1) &&
+ paned->child2 && gtk_widget_get_visible (paned->child2))
{
GtkRequisition child1_requisition;
GtkRequisition child2_requisition;
child_allocation.width = MAX (1, allocation->width - 2 * border_width);
child_allocation.height = MAX (1, allocation->height - 2 * border_width);
- if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
+ if (paned->child1 && gtk_widget_get_visible (paned->child1))
gtk_widget_size_allocate (paned->child1, &child_allocation);
- else if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
+ else if (paned->child2 && gtk_widget_get_visible (paned->child2))
gtk_widget_size_allocate (paned->child2, &child_allocation);
}
}
widget->style = gtk_style_attach (widget->style, widget->window);
- if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
- paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
+ if (paned->child1 && gtk_widget_get_visible (paned->child1) &&
+ paned->child2 && gtk_widget_get_visible (paned->child2))
gdk_window_show (paned->handle);
}
{
GtkPaned *paned = GTK_PANED (widget);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget) &&
- paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
- paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
+ if (gtk_widget_get_visible (widget) && GTK_WIDGET_MAPPED (widget) &&
+ paned->child1 && gtk_widget_get_visible (paned->child1) &&
+ paned->child2 && gtk_widget_get_visible (paned->child2))
{
GtkStateType state;
gboolean was_visible;
paned = GTK_PANED (container);
- was_visible = GTK_WIDGET_VISIBLE (widget);
+ was_visible = gtk_widget_get_visible (widget);
if (paned->child1 == widget)
{
paned->child1 = NULL;
- if (was_visible && GTK_WIDGET_VISIBLE (container))
+ if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize_no_redraw (GTK_WIDGET (container));
}
else if (paned->child2 == widget)
paned->child2 = NULL;
- if (was_visible && GTK_WIDGET_VISIBLE (container))
+ if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize_no_redraw (GTK_WIDGET (container));
}
}
gtk_path_bar_remove_1 (GtkContainer *container,
GtkWidget *widget)
{
- gboolean was_visible = GTK_WIDGET_VISIBLE (widget);
+ gboolean was_visible = gtk_widget_get_visible (widget);
gtk_widget_unparent (widget);
if (was_visible)
gtk_widget_queue_resize (GTK_WIDGET (container));
GTK_WIDGET (pixmap)->requisition.width = 0;
GTK_WIDGET (pixmap)->requisition.height = 0;
}
- if (GTK_WIDGET_VISIBLE (pixmap))
+ if (gtk_widget_get_visible (GTK_WIDGET (pixmap)))
{
if ((GTK_WIDGET (pixmap)->requisition.width != oldwidth) ||
(GTK_WIDGET (pixmap)->requisition.height != oldheight))
pixmap->build_insensitive = build;
- if (GTK_WIDGET_VISIBLE (pixmap))
+ if (gtk_widget_get_visible (GTK_WIDGET (pixmap)))
{
gtk_widget_queue_draw (GTK_WIDGET (pixmap));
}
g_object_ref (plug);
g_object_ref (socket_);
- widget_was_visible = GTK_WIDGET_VISIBLE (plug);
+ widget_was_visible = gtk_widget_get_visible (widget);
gdk_window_hide (widget->window);
GTK_PRIVATE_SET_FLAG (plug, GTK_IN_REPARENT);
g_object_unref (plug);
- if (widget_was_visible && GTK_WIDGET_VISIBLE (socket_))
+ if (widget_was_visible && gtk_widget_get_visible (GTK_WIDGET (socket_)))
gtk_widget_queue_resize (GTK_WIDGET (socket_));
g_object_unref (socket_);
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if (bin->child &&
- GTK_WIDGET_VISIBLE (bin->child) &&
+ gtk_widget_get_visible (bin->child) &&
!GTK_WIDGET_MAPPED (bin->child))
gtk_widget_map (bin->child);
allocation->x, allocation->y,
allocation->width, allocation->height);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkAllocation child_allocation;
y = widget->allocation.y + (widget->allocation.height - indicator_size) / 2;
child = GTK_BIN (check_button)->child;
- if (!interior_focus || !(child && GTK_WIDGET_VISIBLE (child)))
+ if (!interior_focus || !(child && gtk_widget_get_visible (child)))
x += focus_width + focus_pad;
if (toggle_button->inconsistent)
gtk_scale_set_value_pos (GtkScale *scale,
GtkPositionType pos)
{
+ GtkWidget *widget;
+
g_return_if_fail (GTK_IS_SCALE (scale));
if (scale->value_pos != pos)
{
scale->value_pos = pos;
+ widget = GTK_WIDGET (scale);
_gtk_scale_clear_layout (scale);
- if (GTK_WIDGET_VISIBLE (scale) && GTK_WIDGET_MAPPED (scale))
- gtk_widget_queue_resize (GTK_WIDGET (scale));
+ if (gtk_widget_get_visible (widget) && GTK_WIDGET_MAPPED (widget))
+ gtk_widget_queue_resize (widget);
g_object_notify (G_OBJECT (scale), "value-pos");
}
gtk_widget_size_request (scrolled_window->vscrollbar,
&vscrollbar_requisition);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
gtk_extended_layout_get_desired_size (GTK_EXTENDED_LAYOUT (bin->child),
&min_child_requisition,
else if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
scrolled_window->vscrollbar_visible = FALSE;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
gboolean previous_hvis;
gboolean previous_vvis;
gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
&hscrollbar_requisition);
- if (!GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
+ if (!gtk_widget_get_visible (scrolled_window->hscrollbar))
gtk_widget_show (scrolled_window->hscrollbar);
child_allocation.x = relative_allocation.x;
gtk_widget_size_allocate (scrolled_window->hscrollbar, &child_allocation);
}
- else if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
+ else if (gtk_widget_get_visible (scrolled_window->hscrollbar))
gtk_widget_hide (scrolled_window->hscrollbar);
if (scrolled_window->vscrollbar_visible)
{
GtkRequisition vscrollbar_requisition;
- if (!GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
+ if (!gtk_widget_get_visible (scrolled_window->vscrollbar))
gtk_widget_show (scrolled_window->vscrollbar);
gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
gtk_widget_size_allocate (scrolled_window->vscrollbar, &child_allocation);
}
- else if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
+ else if (gtk_widget_get_visible (scrolled_window->vscrollbar))
gtk_widget_hide (scrolled_window->vscrollbar);
}
else
range = GTK_SCROLLED_WINDOW (widget)->hscrollbar;
- if (range && GTK_WIDGET_VISIBLE (range))
+ if (range && gtk_widget_get_visible (range))
{
GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
gdouble delta, new_value;
{
child = l->data;
- if (!GTK_WIDGET_VISIBLE (child->widget))
+ if (!gtk_widget_get_visible (child->widget))
continue;
if (frame->pack == GTK_PACK_START || child->pack == GTK_PACK_END)
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
break;
}
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (table))
+ if (gtk_widget_get_visible (child) &&
+ gtk_widget_get_visible (GTK_WIDGET (table)))
gtk_widget_queue_resize (child);
}
{
table->rows[row].spacing = spacing;
- if (GTK_WIDGET_VISIBLE (table))
+ if (gtk_widget_get_visible (GTK_WIDGET (table)))
gtk_widget_queue_resize (GTK_WIDGET (table));
}
}
{
table->cols[column].spacing = spacing;
- if (GTK_WIDGET_VISIBLE (table))
+ if (gtk_widget_get_visible (GTK_WIDGET (table)))
gtk_widget_queue_resize (GTK_WIDGET (table));
}
}
for (row = 0; row < table->nrows; row++)
table->rows[row].spacing = spacing;
- if (GTK_WIDGET_VISIBLE (table))
+ if (gtk_widget_get_visible (GTK_WIDGET (table)))
gtk_widget_queue_resize (GTK_WIDGET (table));
g_object_notify (G_OBJECT (table), "row-spacing");
for (col = 0; col < table->ncols; col++)
table->cols[col].spacing = spacing;
- if (GTK_WIDGET_VISIBLE (table))
+ if (gtk_widget_get_visible (GTK_WIDGET (table)))
gtk_widget_queue_resize (GTK_WIDGET (table));
g_object_notify (G_OBJECT (table), "column-spacing");
{
table->homogeneous = homogeneous;
- if (GTK_WIDGET_VISIBLE (table))
+ if (gtk_widget_get_visible (GTK_WIDGET (table)))
gtk_widget_queue_resize (GTK_WIDGET (table));
g_object_notify (G_OBJECT (table), "homogeneous");
{
GtkTable *table = GTK_TABLE (container);
GtkTableChild *child;
+ GtkWidget *widget_container = GTK_WIDGET (container);
GList *children;
children = table->children;
if (child->widget == widget)
{
- gboolean was_visible = GTK_WIDGET_VISIBLE (widget);
+ gboolean was_visible = gtk_widget_get_visible (widget);
gtk_widget_unparent (widget);
table->children = g_list_remove (table->children, child);
g_free (child);
- if (was_visible && GTK_WIDGET_VISIBLE (container))
- gtk_widget_queue_resize (GTK_WIDGET (container));
+ if (was_visible && gtk_widget_get_visible (widget_container))
+ gtk_widget_queue_resize (widget_container);
break;
}
}
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
gtk_widget_size_request (child->widget, NULL);
if (child->left_attach == (child->right_attach - 1) && child->xexpand)
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
GtkRequisition child_requisition;
gtk_widget_get_child_requisition (child->widget, &child_requisition);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
/* Child spans multiple columns.
*/
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
if (child->left_attach == (child->right_attach - 1))
{
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
if (child->left_attach != (child->right_attach - 1))
{
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
GtkRequisition child_requisition;
gtk_widget_get_child_requisition (child->widget, &child_requisition);
g_object_notify (G_OBJECT (text_view), "buffer");
- if (GTK_WIDGET_VISIBLE (text_view))
+ if (gtk_widget_get_visible (GTK_WIDGET (text_view)))
gtk_widget_queue_draw (GTK_WIDGET (text_view));
DV(g_print ("Invalidating due to set_buffer\n"));
*/
if (!GTK_WIDGET_REALIZED (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GdkRectangle tmp_rectangle = widget->allocation;
tmp_rectangle.x += scroll_data->dx;
vc->x = xpos;
vc->y = ypos;
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (text_view))
+ if (gtk_widget_get_visible (child) &&
+ gtk_widget_get_visible (GTK_WIDGET (text_view)))
gtk_widget_queue_resize (child);
}
toggle_button->draw_indicator = draw_indicator;
GTK_BUTTON (toggle_button)->depress_on_activate = !draw_indicator;
- if (GTK_WIDGET_VISIBLE (toggle_button))
+ if (gtk_widget_get_visible (GTK_WIDGET (toggle_button)))
gtk_widget_queue_resize (GTK_WIDGET (toggle_button));
g_object_notify (G_OBJECT (toggle_button), "draw-indicator");
{
gtk_widget_hide (GTK_WIDGET (priv->arrow_button));
- if (priv->menu && GTK_WIDGET_VISIBLE (priv->menu))
+ if (priv->menu && gtk_widget_get_visible (GTK_WIDGET (priv->menu)))
gtk_menu_shell_deactivate (GTK_MENU_SHELL (priv->menu));
}
GtkToolbarPrivate *priv = GTK_TOOLBAR_GET_PRIVATE (toolbar);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->arrow_button)) &&
- (!priv->menu || !GTK_WIDGET_VISIBLE (priv->menu)))
+ (!priv->menu || !gtk_widget_get_visible (GTK_WIDGET (priv->menu))))
{
/* We only get here when the button is clicked with the keyboard,
* because mouse button presses result in the menu being shown so
case TOOL_ITEM:
item = content->u.tool_item.item;
- if (!GTK_WIDGET_VISIBLE (item))
+ if (!gtk_widget_get_visible (GTK_WIDGET (item)))
return FALSE;
if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL &&
case COMPATIBILITY:
if (content->u.compatibility.child.type != GTK_TOOLBAR_CHILD_SPACE)
- return GTK_WIDGET_VISIBLE (content->u.compatibility.child.widget);
+ return gtk_widget_get_visible (content->u.compatibility.child.widget);
else
return TRUE;
break;
{
GtkWidget *child = GTK_BIN (widget)->child;
- if (child && GTK_WIDGET_VISIBLE (child))
+ if (child && gtk_widget_get_visible (child))
{
gtk_widget_size_request (child, requisition);
}
widget->allocation.width - border_width * 2,
widget->allocation.height - border_width * 2);
- if (child && GTK_WIDGET_VISIBLE (child))
+ if (child && gtk_widget_get_visible (child))
{
child_allocation.x = allocation->x + border_width;
child_allocation.y = allocation->y + border_width;
return FALSE;
return
- (GTK_WIDGET_VISIBLE (child->item)) &&
+ (gtk_widget_get_visible (GTK_WIDGET (child->item))) &&
(GTK_ORIENTATION_VERTICAL == orientation ?
gtk_tool_item_get_visible_vertical (child->item) :
gtk_tool_item_get_visible_horizontal (child->item));
inquery->height = 0;
/* figure out header widget size */
- if (GTK_WIDGET_VISIBLE (priv->header))
+ if (gtk_widget_get_visible (priv->header))
{
GtkRequisition child_requisition;
child_allocation.y = border_width;
/* place the header widget */
- if (GTK_WIDGET_VISIBLE (priv->header))
+ if (gtk_widget_get_visible (priv->header))
{
gtk_widget_size_request (priv->header, &child_requisition);
gtk_widget_thaw_child_notify (GTK_WIDGET (item));
- if (changed && GTK_WIDGET_VISIBLE (group) && GTK_WIDGET_VISIBLE (item))
+ if (changed
+ && gtk_widget_get_visible (GTK_WIDGET (group))
+ && gtk_widget_get_visible (GTK_WIDGET (item)))
gtk_widget_queue_resize (GTK_WIDGET (group));
}
priv->label_widget = label_widget;
- if (GTK_WIDGET_VISIBLE (group))
+ if (gtk_widget_get_visible (GTK_WIDGET (group)))
gtk_widget_queue_resize (GTK_WIDGET (group));
/* Only show the header widget if the group has children: */
gtk_widget_translate_coordinates (widget, parent, 0, 0, &x, &y);
- if (GTK_WIDGET_VISIBLE (priv->header))
+ if (gtk_widget_get_visible (priv->header))
{
height -= priv->header->allocation.height;
y += priv->header->allocation.height;
priv->children = g_list_insert (priv->children, child, position);
gtk_widget_child_notify (GTK_WIDGET (item), "position");
- if (GTK_WIDGET_VISIBLE (group) && GTK_WIDGET_VISIBLE (item))
+ if (gtk_widget_get_visible (GTK_WIDGET (group)) &&
+ gtk_widget_get_visible (GTK_WIDGET (item)))
gtk_widget_queue_resize (GTK_WIDGET (group));
}
v0 = v1 - 256;
- if (!GTK_WIDGET_VISIBLE (priv->header))
+ if (!gtk_widget_get_visible (priv->header))
v0 = MAX (v0, 0);
else if (GTK_ORIENTATION_VERTICAL == orientation)
v0 = MAX (v0, priv->header->allocation.height);
GObjectClass parent_class;
};
-#define GTK_TOOLTIP_VISIBLE(tooltip) ((tooltip)->current_window && GTK_WIDGET_VISIBLE ((tooltip)->current_window))
+#define GTK_TOOLTIP_VISIBLE(tooltip) ((tooltip)->current_window && gtk_widget_get_visible (GTK_WIDGET((tooltip)->current_window)))
static void gtk_tooltip_class_init (GtkTooltipClass *klass);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child) &&
+ if (gtk_widget_get_visible (child) &&
!GTK_WIDGET_MAPPED (child))
gtk_widget_map (child);
{
child = GTK_WIDGET (GTK_TREE_ITEM (child)->subtree);
- if (GTK_WIDGET_VISIBLE (child) && !GTK_WIDGET_MAPPED (child))
+ if (gtk_widget_get_visible (child) && !GTK_WIDGET_MAPPED (child))
gtk_widget_map (child);
}
}
gtk_tree_select_child (root_tree, widget);
}
- if (GTK_WIDGET_VISIBLE (root_tree))
+ if (gtk_widget_get_visible (GTK_WIDGET (root_tree)))
{
#ifdef TREE_DEBUG
g_message("* query queue resizing for root_tree\n");
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
gtk_widget_get_child_requisition (child, &child_requisition);
child_allocation.y += child_allocation.height;
if((subtree = GTK_TREE_ITEM(child)->subtree))
- if(GTK_WIDGET_VISIBLE (subtree))
+ if(gtk_widget_get_visible (subtree))
{
child_allocation.height = subtree->requisition.height;
gtk_widget_size_allocate (subtree, &child_allocation);
child = children->data;
children = children->next;
- if (GTK_WIDGET_VISIBLE (child))
+ if (gtk_widget_get_visible (child))
{
gtk_widget_size_request (child, &child_requisition);
requisition->height += child_requisition.height;
if((subtree = GTK_TREE_ITEM(child)->subtree) &&
- GTK_WIDGET_VISIBLE (subtree))
+ gtk_widget_get_visible (subtree))
{
gtk_widget_size_request (subtree, &child_requisition);
{
g_return_if_fail (GTK_IS_EVENT_BOX (widget));
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
if (widget->state == GTK_STATE_NORMAL)
widget->style->xthickness) * 2;
requisition->height = GTK_CONTAINER (widget)->border_width * 2;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition pix_requisition;
gtk_tree_item_draw_lines(widget);
if (tree_item->pixmaps_box &&
- GTK_WIDGET_VISIBLE(tree_item->pixmaps_box) &&
+ gtk_widget_get_visible(tree_item->pixmaps_box) &&
gtk_widget_intersect (tree_item->pixmaps_box, area, &child_area))
{
gtk_widget_queue_draw_area (tree_item->pixmaps_box,
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if(item->pixmaps_box &&
- GTK_WIDGET_VISIBLE (item->pixmaps_box) &&
+ gtk_widget_get_visible (item->pixmaps_box) &&
!GTK_WIDGET_MAPPED (item->pixmaps_box))
gtk_widget_map (item->pixmaps_box);
if (bin->child &&
- GTK_WIDGET_VISIBLE (bin->child) &&
+ gtk_widget_get_visible (bin->child) &&
!GTK_WIDGET_MAPPED (bin->child))
gtk_widget_map (bin->child);
gdk_window_hide (widget->window);
if(item->pixmaps_box &&
- GTK_WIDGET_VISIBLE (item->pixmaps_box) &&
+ gtk_widget_get_visible (item->pixmaps_box) &&
GTK_WIDGET_MAPPED (item->pixmaps_box))
gtk_widget_unmap (bin->child);
if (bin->child &&
- GTK_WIDGET_VISIBLE (bin->child) &&
+ gtk_widget_get_visible (bin->child) &&
GTK_WIDGET_MAPPED (bin->child))
gtk_widget_unmap (bin->child);
}
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
- if (GTK_WIDGET_VISIBLE (column->button) &&
+ if (gtk_widget_get_visible (column->button) &&
!GTK_WIDGET_MAPPED (column->button))
gtk_widget_map (column->button);
}
GtkTreeViewChild *child = tmp_list->data;
tmp_list = tmp_list->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
if (!GTK_WIDGET_MAPPED (child->widget))
gtk_widget_map (child->widget);
tmp_list = tmp_list->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
gtk_widget_size_request (child->widget, &child_requisition);
}
}
return FALSE;
if (tree_view->priv->search_window != NULL &&
- GTK_WIDGET_VISIBLE (tree_view->priv->search_window))
+ gtk_widget_get_visible (tree_view->priv->search_window))
return TRUE;
for (list = tree_view->priv->columns; list; list = list->next)
*/
if (!GTK_WIDGET_REALIZED (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GdkRectangle tmp_rectangle = widget->allocation;
tmp_rectangle.x += scroll_data->dx;
* scrolling code, we short-circuit validate_visible_area's immplementation as
* it is much slower than just going to the point.
*/
- if (! GTK_WIDGET_VISIBLE (tree_view) ||
+ if (! gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
! GTK_WIDGET_REALIZED (tree_view) ||
GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
tree_view->priv->typeselect_flush_timeout = 0;
}
- if (GTK_WIDGET_VISIBLE (search_dialog))
+ if (gtk_widget_get_visible (search_dialog))
{
/* send focus-in event */
send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
cur = children;
while (cur)
{
- if (GTK_WIDGET_VISIBLE (cur->data))
+ if (gtk_widget_get_visible (cur->data))
{
if (!GTK_IS_TEAROFF_MENU_ITEM (cur->data) &&
!g_object_get_data (cur->data, "gtk-empty-menu-item"))
break;
}
}
- else if (GTK_WIDGET_VISIBLE (cur->data))
+ else if (gtk_widget_get_visible (cur->data))
{
last = NULL;
if (GTK_IS_TEAROFF_MENU_ITEM (cur->data) || cur->data == filler)
hadjustment->lower = 0;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
vadjustment->lower = 0;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
{
viewport->shadow_type = type;
- if (GTK_WIDGET_VISIBLE (viewport))
+ if (gtk_widget_get_visible (GTK_WIDGET (viewport)))
{
gtk_widget_size_allocate (GTK_WIDGET (viewport), &(GTK_WIDGET (viewport)->allocation));
gtk_widget_queue_draw (GTK_WIDGET (viewport));
requisition->height += 2 * widget->style->ythickness;
}
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
gtk_widget_size_request (bin->child, &child_requisition);
requisition->width += child_requisition.width;
child_allocation.width,
child_allocation.height);
}
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
gtk_widget_size_allocate (bin->child, &child_allocation);
gtk_adjustment_changed (hadjustment);
GtkViewport *viewport = GTK_VIEWPORT (data);
GtkBin *bin = GTK_BIN (data);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child) &&
+ if (bin->child && gtk_widget_get_visible (bin->child) &&
GTK_WIDGET_REALIZED (viewport))
{
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
break;
case PROP_TOOLTIP_TEXT:
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
break;
case PROP_DOUBLE_BUFFERED:
}
break;
case PROP_VISIBLE:
- g_value_set_boolean (value, (GTK_WIDGET_VISIBLE (widget) != FALSE));
+ g_value_set_boolean (value, (gtk_widget_get_visible (widget) != FALSE));
break;
case PROP_SENSITIVE:
g_value_set_boolean (value, (gtk_widget_get_sensitive (widget) != FALSE));
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_visible (widget))
{
g_object_ref (widget);
if (!gtk_widget_is_toplevel (widget))
static void
gtk_widget_real_show (GtkWidget *widget)
{
- if (!GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_visible (widget))
{
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
static void
gtk_widget_real_hide (GtkWidget *widget)
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
gtk_widget_map (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (GTK_WIDGET_VISIBLE (widget));
+ g_return_if_fail (gtk_widget_get_visible (widget));
g_return_if_fail (GTK_WIDGET_CHILD_VISIBLE (widget));
if (!GTK_WIDGET_MAPPED (widget))
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (visible != GTK_WIDGET_VISIBLE (widget))
+ if (visible != gtk_widget_get_visible (widget))
{
if (visible)
gtk_widget_show (widget);
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_VISIBLE) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_VISIBLE) != 0;
}
/**
if (GTK_WIDGET_REALIZED (widget->parent))
gtk_widget_realize (widget);
- if (GTK_WIDGET_VISIBLE (widget->parent) &&
- GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget->parent) &&
+ gtk_widget_get_visible (widget))
{
if (GTK_WIDGET_CHILD_VISIBLE (widget) &&
GTK_WIDGET_MAPPED (widget->parent))
{
if (GTK_WIDGET_MAPPED (widget->parent) &&
GTK_WIDGET_CHILD_VISIBLE (widget) &&
- GTK_WIDGET_VISIBLE (widget))
+ gtk_widget_get_visible (widget))
gtk_widget_map (widget);
else
gtk_widget_unmap (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- if (!GTK_WIDGET_VISIBLE (widget) ||
+ if (!gtk_widget_get_visible (widget) ||
!gtk_widget_is_sensitive (widget))
return FALSE;
if (GTK_IS_WINDOW (widget) && aux_info->x_set && aux_info->y_set)
_gtk_window_reposition (GTK_WINDOW (widget), aux_info->x, aux_info->y);
- if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
+ if (gtk_widget_get_visible (widget) && widget->parent)
gtk_widget_size_allocate (widget, &widget->allocation);
}
changed = TRUE;
}
- if (GTK_WIDGET_VISIBLE (widget) && changed)
+ if (gtk_widget_get_visible (widget) && changed)
gtk_widget_queue_resize (widget);
g_object_thaw_notify (G_OBJECT (widget));
if (widget->parent)
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
- else if (GTK_WIDGET_VISIBLE (widget))
+ else if (gtk_widget_get_visible (widget))
gtk_widget_hide (widget);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
GList *windows = NULL, *list;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- if (!GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_visible (widget))
return NULL;
/* the widget (and parent_window) must be realized to be drawable */
has_tooltip = (custom_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, has_tooltip, FALSE);
- if (has_tooltip && GTK_WIDGET_VISIBLE (widget))
+ if (has_tooltip && gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
}
*/
#define GTK_WIDGET_MAPPED(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_MAPPED) != 0)
+#ifndef GTK_DISABLE_DEPRECATED
/**
* GTK_WIDGET_VISIBLE:
* @wid: a #GtkWidget.
*
* Evaluates to %TRUE if the widget is visible.
+ *
+ * Deprecated: 2.20: Use gtk_widget_get_visible() instead.
*/
#define GTK_WIDGET_VISIBLE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_VISIBLE) != 0)
+#endif
#ifndef GTK_DISABLE_DEPRECATED
/**
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if (bin->child &&
- GTK_WIDGET_VISIBLE (bin->child) &&
+ gtk_widget_get_visible (bin->child) &&
!GTK_WIDGET_MAPPED (bin->child))
gtk_widget_map (bin->child);
allocation->x, allocation->y,
allocation->width, allocation->height);
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkAllocation child_allocation;
gtk_window_set_modal (GtkWindow *window,
gboolean modal)
{
+ GtkWidget *widget;
+
g_return_if_fail (GTK_IS_WINDOW (window));
modal = modal != FALSE;
return;
window->modal = modal;
+ widget = GTK_WIDGET (window);
/* adjust desired modality state */
if (GTK_WIDGET_REALIZED (window))
{
- GtkWidget *widget = GTK_WIDGET (window);
-
if (window->modal)
gdk_window_set_modal_hint (widget->window, TRUE);
else
gdk_window_set_modal_hint (widget->window, FALSE);
}
- if (GTK_WIDGET_VISIBLE (window))
+ if (gtk_widget_get_visible (widget))
{
if (window->modal)
- gtk_grab_add (GTK_WIDGET (window));
+ gtk_grab_add (widget);
else
- gtk_grab_remove (GTK_WIDGET (window));
+ gtk_grab_remove (widget);
}
g_object_notify (G_OBJECT (window), "modal");
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if (window->bin.child &&
- GTK_WIDGET_VISIBLE (window->bin.child) &&
+ gtk_widget_get_visible (window->bin.child) &&
!GTK_WIDGET_MAPPED (window->bin.child))
gtk_widget_map (window->bin.child);
requisition->width = GTK_CONTAINER (window)->border_width * 2;
requisition->height = GTK_CONTAINER (window)->border_width * 2;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
window = GTK_WINDOW (widget);
widget->allocation = *allocation;
- if (window->bin.child && GTK_WIDGET_VISIBLE (window->bin.child))
+ if (window->bin.child && gtk_widget_get_visible (window->bin.child))
{
child_allocation.x = GTK_CONTAINER (window)->border_width;
child_allocation.y = GTK_CONTAINER (window)->border_width;
* the window is visible before actually handling the
* event
*/
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
_gtk_window_set_has_toplevel_focus (window, TRUE);
_gtk_window_set_is_active (window, TRUE);
static void
gtk_window_check_resize (GtkContainer *container)
{
- GtkWindow *window = GTK_WINDOW (container);
-
- if (GTK_WIDGET_VISIBLE (container))
- gtk_window_move_resize (window);
+ if (gtk_widget_get_visible (GTK_WIDGET (container)))
+ gtk_window_move_resize (GTK_WINDOW (container));
}
static gboolean
widget = GTK_WIDGET (window);
- if (GTK_WIDGET_VISIBLE (window))
+ if (gtk_widget_get_visible (widget))
{
g_assert (widget->window != NULL);
GdkWindow *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (GTK_WIDGET_VISIBLE (window));
-
widget = GTK_WIDGET (window);
+ g_return_if_fail (gtk_widget_get_visible (widget));
if (window->frame)
toplevel = window->frame;
GdkWindow *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (GTK_WIDGET_VISIBLE (window));
-
widget = GTK_WIDGET (window);
+ g_return_if_fail (gtk_widget_get_visible (widget));
if (window->frame)
toplevel = window->frame;
/* OPEN implies that the "new folder" button is hidden; otherwise it is shown */
if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
- passed = passed && !GTK_WIDGET_VISIBLE (impl->browse_new_folder_button);
+ passed = passed && !gtk_widget_get_visible (impl->browse_new_folder_button);
else
- passed = passed && GTK_WIDGET_VISIBLE (impl->browse_new_folder_button);
+ passed = passed && gtk_widget_get_visible (impl->browse_new_folder_button);
/* Check that the widgets are present/visible or not */
if (has_action (open_actions, G_N_ELEMENTS (open_actions), impl->action))
*/
return FALSE;
- if (!gtk_widget_is_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
button = GAIL_BUTTON (action);
g_object_ref (gail_button);
if (widget == NULL /* State is defunct */ ||
- !gtk_widget_is_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget))
{
g_object_unref (gail_button);
return FALSE;
*/
return FALSE;
- if (!gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
combo = GAIL_COMBO (action);
gail_combo->action_idle_handler = 0;
widget = GTK_ACCESSIBLE (gail_combo)->widget;
if (widget == NULL /* State is defunct */ ||
- !gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
combo = GTK_COMBO (widget);
*/
return FALSE;
- if (!gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
combo_box = GAIL_COMBO_BOX (action);
gail_combo_box->action_idle_handler = 0;
widget = GTK_ACCESSIBLE (gail_combo_box)->widget;
if (widget == NULL || /* State is defunct */
- !gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
combo_box = GTK_COMBO_BOX (widget);
*/
return FALSE;
- if (!gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
switch (i)
entry->action_idle_handler = 0;
widget = GTK_ACCESSIBLE (entry)->widget;
if (widget == NULL /* State is defunct */ ||
- !gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
gtk_widget_activate (widget);
*/
return FALSE;
- if (!gtk_widget_is_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
expander = GAIL_EXPANDER (action);
widget = GTK_ACCESSIBLE (gail_expander)->widget;
if (widget == NULL /* State is defunct */ ||
- !gtk_widget_is_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
gtk_widget_activate (widget);
*
* The following hack forces the menu items to be created.
*/
- if (!GTK_WIDGET_VISIBLE (submenu))
+ if (!gtk_widget_get_visible (submenu))
{
GTK_WIDGET_SET_FLAGS (submenu, GTK_VISIBLE);
g_signal_emit_by_name (submenu, "show");
/* State is defunct */
return FALSE;
- if (!gtk_widget_get_sensitive (item) || !GTK_WIDGET_VISIBLE (item))
+ if (!gtk_widget_get_sensitive (item) || !gtk_widget_get_visible (item))
return FALSE;
gail_menu_item = GAIL_MENU_ITEM (action);
menu_item->action_idle_handler = 0;
item = GTK_ACCESSIBLE (menu_item)->widget;
if (item == NULL /* State is defunct */ ||
- !gtk_widget_get_sensitive (item) || !GTK_WIDGET_VISIBLE (item))
+ !gtk_widget_get_sensitive (item) || !gtk_widget_get_visible (item))
return FALSE;
item_parent = gtk_widget_get_parent (item);
*/
return FALSE;
- if (!gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
switch (i)
widget = GTK_ACCESSIBLE (gail_button)->widget;
if (widget == NULL /* State is defunct */ ||
- !gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
button = GTK_BUTTON (widget);
* State is defunct
*/
return FALSE;
- if (!gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
if(i==0)
{
range->action_idle_handler = 0;
widget = GTK_ACCESSIBLE (range)->widget;
if (widget == NULL /* State is defunct */ ||
- !gtk_widget_get_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ !gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
gtk_widget_activate (widget);
if (widget == NULL)
return FALSE;
- if (!gtk_widget_is_sensitive (widget) || !GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
switch (i) {
window = GTK_WINDOW (l->data);
widget = GTK_WIDGET (window);
if (!window ||
- !GTK_WIDGET_VISIBLE (widget) ||
+ !gtk_widget_get_visible (widget) ||
is_attached_menu_window (widget) ||
GTK_WIDGET (window)->parent ||
GTK_IS_PLUG (window))
* GailWidget data structure so we can determine whether the value has
* changed.
*/
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
atk_state_set_add_state (state_set, ATK_STATE_VISIBLE);
if (gail_widget_on_screen (widget) && GTK_WIDGET_MAPPED (widget) &&
else if (strcmp (pspec->name, "visible") == 0)
{
state = ATK_STATE_VISIBLE;
- value = GTK_WIDGET_VISIBLE (widget);
+ value = gtk_widget_get_visible (widget);
}
else if (strcmp (pspec->name, "sensitive") == 0)
{
for (iter_parent = gtk_widget_get_parent (widget); iter_parent;
iter_parent = gtk_widget_get_parent (iter_parent))
{
- if (!GTK_WIDGET_VISIBLE (iter_parent))
+ if (!gtk_widget_get_visible (iter_parent))
{
result = FALSE;
break;
{
atk_relation_set_remove (relation_set, relation);
}
- if (GTK_WIDGET_VISIBLE(widget) && gtk_tooltips_get_info_from_tip_window (GTK_WINDOW (widget), NULL, ¤t_widget))
+ if (gtk_widget_get_visible(widget) && gtk_tooltips_get_info_from_tip_window (GTK_WINDOW (widget), NULL, ¤t_widget))
{
array [0] = gtk_widget_get_accessible (current_widget);
gtk_container_add (GTK_CONTAINER (vbox1), GTK_WIDGET (notebook));
gtk_widget_show (GTK_WIDGET (notebook));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
mainWindow = GTK_WIDGET (window);
if (!widget)
g_error ("The profiler emitted the \"create-widget\" signal but the signal handler returned no widget!");
- if (GTK_WIDGET_VISIBLE (widget) || GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_visible (widget) || GTK_WIDGET_MAPPED (widget))
g_error ("The handler for \"create-widget\" must return an unmapped and unshown widget");
return widget;
x = widget_x;
y = widget_y;
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
y -= offscreen_box->child1->allocation.height;
child_area = offscreen_box->child2->allocation;
x += child_area.width / 2;
y += child_area.height / 2;
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
y += offscreen_box->child1->allocation.height;
*x_out = x;
/* First check for child 2 */
if (offscreen_box->child2 &&
- GTK_WIDGET_VISIBLE (offscreen_box->child2))
+ gtk_widget_get_visible (offscreen_box->child2))
{
to_child_2 (offscreen_box,
widget_x, widget_y,
return offscreen_box->offscreen_window2;
}
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
{
x = widget_x;
y = widget_y;
/* Child 1 */
attributes.x = attributes.y = 0;
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
{
attributes.width = offscreen_box->child1->allocation.width;
attributes.height = offscreen_box->child1->allocation.height;
/* Child 2 */
attributes.y = start_y;
child_requisition.width = child_requisition.height = 0;
- if (offscreen_box->child2 && GTK_WIDGET_VISIBLE (offscreen_box->child2))
+ if (offscreen_box->child2 && gtk_widget_get_visible (offscreen_box->child2))
{
attributes.width = offscreen_box->child2->allocation.width;
attributes.height = offscreen_box->child2->allocation.height;
GtkOffscreenBox *offscreen_box = GTK_OFFSCREEN_BOX (container);
gboolean was_visible;
- was_visible = GTK_WIDGET_VISIBLE (widget);
+ was_visible = gtk_widget_get_visible (widget);
if (offscreen_box->child1 == widget)
{
offscreen_box->child1 = NULL;
- if (was_visible && GTK_WIDGET_VISIBLE (container))
+ if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
else if (offscreen_box->child2 == widget)
offscreen_box->child2 = NULL;
- if (was_visible && GTK_WIDGET_VISIBLE (container))
+ if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
}
w = 0;
h = 0;
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
{
GtkRequisition child_requisition;
h += CHILD1_SIZE_SCALE * child_requisition.height;
}
- if (offscreen_box->child2 && GTK_WIDGET_VISIBLE (offscreen_box->child2))
+ if (offscreen_box->child2 && gtk_widget_get_visible (offscreen_box->child2))
{
GtkRequisition child_requisition;
start_y = 0;
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
{
GtkRequisition child_requisition;
GtkAllocation child_allocation;
gtk_widget_size_allocate (offscreen_box->child1, &child_allocation);
}
- if (offscreen_box->child2 && GTK_WIDGET_VISIBLE (offscreen_box->child2))
+ if (offscreen_box->child2 && gtk_widget_get_visible (offscreen_box->child2))
{
GtkRequisition child_requisition;
GtkAllocation child_allocation;
cairo_t *cr;
int start_y = 0;
- if (offscreen_box->child1 && GTK_WIDGET_VISIBLE (offscreen_box->child1))
+ if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
{
pixmap = gdk_offscreen_window_get_pixmap (offscreen_box->offscreen_window1);
child_area = offscreen_box->child1->allocation;
start_y += child_area.height;
}
- if (offscreen_box->child2 && GTK_WIDGET_VISIBLE (offscreen_box->child2))
+ if (offscreen_box->child2 && gtk_widget_get_visible (offscreen_box->child2))
{
gint w, h;
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), page, TRUE);
}
- if (!GTK_WIDGET_VISIBLE (assistant))
+ if (!gtk_widget_get_visible (assistant))
gtk_widget_show (assistant);
else
{
G_CALLBACK (complete_cb), pdata);
}
- if (!GTK_WIDGET_VISIBLE (assistant))
+ if (!gtk_widget_get_visible (assistant))
gtk_widget_show (assistant);
else
{
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), page, TRUE);
}
- if (!GTK_WIDGET_VISIBLE (assistant))
+ if (!gtk_widget_get_visible (assistant))
gtk_widget_show (assistant);
else
{
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), page, TRUE);
}
- if (!GTK_WIDGET_VISIBLE (assistant))
+ if (!gtk_widget_get_visible (assistant))
gtk_widget_show (assistant);
else
{
gtk_assistant_set_page_header_image (GTK_ASSISTANT (assistant), page, pixbuf);
}
- if (!GTK_WIDGET_VISIBLE (assistant))
+ if (!gtk_widget_get_visible (assistant))
gtk_widget_show (assistant);
else
{
NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
G_CALLBACK (window_expose_event), NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_hide (window);
button_window (GtkWidget *widget,
GtkWidget *button)
{
- if (!GTK_WIDGET_VISIBLE (button))
+ if (!gtk_widget_get_visible (button))
gtk_widget_show (button);
else
gtk_widget_hide (button);
gtk_widget_grab_default (button[9]);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
TRUE, TRUE, 5);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_set_size_request (toolbar, 200, -1);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
G_CALLBACK (gtk_widget_destroy),
window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
g_object_new (GTK_TYPE_ARROW, "visible", 1, "parent", hbox, NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_image_new_from_pixmap (pixmap, mask));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_container_add (GTK_CONTAINER (expander), hidden);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
&window2);
}
- if (GTK_WIDGET_VISIBLE (window1) && GTK_WIDGET_VISIBLE (window2))
+ if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
{
gtk_widget_destroy (window1);
gtk_widget_destroy (window2);
}
else
{
- if (!GTK_WIDGET_VISIBLE (window1))
+ if (!gtk_widget_get_visible (window1))
gtk_widget_show_all (window1);
- if (!GTK_WIDGET_VISIBLE (window2))
+ if (!gtk_widget_get_visible (window2))
gtk_widget_show_all (window2);
}
}
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_set_size_request (GTK_WIDGET (export_ctree), 300, 200);
}
- if (!GTK_WIDGET_VISIBLE (export_window))
+ if (!gtk_widget_get_visible (export_window))
gtk_widget_show_all (export_window);
gtk_clist_clear (GTK_CLIST (export_ctree));
rebuild_tree (NULL, ctree);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
picker);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
button, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_container_add (GTK_CONTAINER (frame), table);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_container_add (GTK_CONTAINER (hbox), picker);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (dialog_window))
+ if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (dialog_window))
+ if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_show (ruler);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show_all (vbox);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
&window4);
}
- if (GTK_WIDGET_VISIBLE (window1))
+ if (gtk_widget_get_visible (window1))
gtk_widget_destroy (GTK_WIDGET (window1));
else
gtk_widget_show_all (GTK_WIDGET (window1));
- if (GTK_WIDGET_VISIBLE (window2))
+ if (gtk_widget_get_visible (window2))
gtk_widget_destroy (GTK_WIDGET (window2));
else
gtk_widget_show_all (GTK_WIDGET (window2));
- if (GTK_WIDGET_VISIBLE (window3))
+ if (gtk_widget_get_visible (window3))
gtk_widget_destroy (GTK_WIDGET (window3));
else
gtk_widget_show_all (GTK_WIDGET (window3));
- if (GTK_WIDGET_VISIBLE (window4))
+ if (gtk_widget_get_visible (window4))
gtk_widget_destroy (GTK_WIDGET (window4));
else
gtk_widget_show_all (GTK_WIDGET (window4));
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_show_all (box1);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
* of behavior on first show.
*/
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (pdata->window))
+ if (!gtk_widget_get_visible (pdata->window))
gtk_widget_show_all (pdata->window);
else
gtk_widget_destroy (pdata->window);
data);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
data);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
max, vec);
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else if (count % 4 == 3)
{
drawing_area, &geometry, geometry_mask);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
button, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}