void
moz_drawingarea_set_visibility (MozDrawingarea *drawingarea,
gboolean visibility)
{
if (visibility) {
gdk_window_show_unraised(drawingarea->inner_window);
gdk_window_show_unraised(drawingarea->clip_window);
}
else {
gdk_window_hide(drawingarea->clip_window);
gdk_window_hide(drawingarea->inner_window);
}
}
static void
map (GtkWidget* widget)
{
GTK_WIDGET_CLASS (gtk_mvc_adaptor_parent_class)->map (widget);
gdk_window_show_unraised (PRIV (widget)->event_window);
}
static void deepin_workspace_overview_map (GtkWidget *widget)
{
DeepinWorkspaceOverview *self = DEEPIN_WORKSPACE_OVERVIEW (widget);
DeepinWorkspaceOverviewPrivate *priv = self->priv;
GTK_WIDGET_CLASS (deepin_workspace_overview_parent_class)->map (widget);
if (priv->event_window)
gdk_window_show_unraised(priv->event_window);
}
static void
anjuta_tabber_map (GtkWidget* widget)
{
AnjutaTabber* tabber = ANJUTA_TABBER (widget);
gtk_widget_set_mapped (widget, TRUE);
gdk_window_show_unraised (tabber->priv->event_window);
GTK_WIDGET_CLASS (anjuta_tabber_parent_class)->map (widget);
}
static void
container_map (GtkWidget* widget)
{
GTK_WIDGET_CLASS (progress_simple_container_parent_class)->map (widget);
if (PRIV (widget)->input_window)
{
gdk_window_show_unraised (PRIV (widget)->input_window);
}
}
void
meta_ui_map_frame (MetaUI *ui,
Window xwindow)
{
GdkWindow *window;
window = gdk_xid_table_lookup (xwindow);
if (window)
gdk_window_show_unraised (window);
}
static void
display_entry (MetaTabPopup *popup,
TabEntry *te)
{
if (popup->current_selected_entry)
{
if (popup->outline)
meta_select_image_unselect (META_SELECT_IMAGE (popup->current_selected_entry->widget));
else
meta_select_workspace_unselect (META_SELECT_WORKSPACE (popup->current_selected_entry->widget));
}
gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
if (popup->outline)
meta_select_image_select (META_SELECT_IMAGE (te->widget));
else
meta_select_workspace_select (META_SELECT_WORKSPACE (te->widget));
if (popup->outline)
{
GdkRectangle rect;
GdkWindow *window;
cairo_region_t *region;
window = gtk_widget_get_window (popup->outline_window);
/* Do stuff behind gtk's back */
gdk_window_hide (window);
meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
rect = te->rect;
rect.x = 0;
rect.y = 0;
gtk_window_move (GTK_WINDOW (popup->outline_window), te->rect.x, te->rect.y);
gtk_window_resize (GTK_WINDOW (popup->outline_window), te->rect.width, te->rect.height);
region = cairo_region_create_rectangle (&rect);
cairo_region_subtract_rectangle (region, &te->inner_rect);
gdk_window_shape_combine_region (gtk_widget_get_window (popup->outline_window),
region,
0, 0);
cairo_region_destroy (region);
gdk_window_show_unraised (window);
}
/* Must be before we handle an expose for the outline window */
popup->current_selected_entry = te;
}
void
meta_ui_map_frame (MetaUI *ui,
Window xwindow)
{
GdkWindow *window;
GdkDisplay *display;
display = gdk_x11_lookup_xdisplay (ui->xdisplay);
window = gdk_x11_window_lookup_for_display (display, xwindow);
if (window)
gdk_window_show_unraised (window);
}
static void
clutter_stage_gdk_show (ClutterStageWindow *stage_window,
gboolean do_raise)
{
ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window);
g_return_if_fail (stage_gdk->window != NULL);
clutter_actor_map (CLUTTER_ACTOR (CLUTTER_STAGE_COGL (stage_gdk)->wrapper));
if (do_raise)
gdk_window_show (stage_gdk->window);
else
gdk_window_show_unraised (stage_gdk->window);
}
JNIEXPORT void JNICALL
Java_org_gnome_gdk_GdkWindow_gdk_1window_1show_1unraised
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GdkWindow* self;
// convert parameter self
self = (GdkWindow*) _self;
// call function
gdk_window_show_unraised(self);
// cleanup parameter self
}
gboolean
gd_tagged_entry_insert_tag (GdTaggedEntry *self,
GdTaggedEntryTag *tag,
gint position)
{
if (g_list_find (self->tags, tag) != NULL)
return FALSE;
tag->entry = self;
self->tags = g_list_insert (self->tags, g_object_ref (tag), position);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
gd_tagged_entry_tag_realize (tag, self);
if (gtk_widget_get_mapped (GTK_WIDGET (self)))
gdk_window_show_unraised (tag->window);
gtk_widget_queue_resize (GTK_WIDGET (self));
return TRUE;
}
static VALUE
gdkwin_show_unraised(VALUE self)
{
gdk_window_show_unraised(_SELF(self));
return self;
}
bool MPlayer::init(const char * p_filename, MCStack *p_stack, MCRectangle p_rect )
{
// Are we already running a movie? If we are, then stop.
if ( m_window != DNULL && m_filename != NULL )
quit();
GdkWindow* w ;
if ( p_stack == NULL )
return false ;
// Locate the window for the stack
GdkWindow* stack_window = p_stack->getwindow();
if ( stack_window == DNULL)
return false ;
GdkWindowAttr t_wa;
t_wa.colormap = ((MCScreenDC*)MCscreen)->getcmapnative();
t_wa.x = p_rect.x;
t_wa.y = p_rect.y;
t_wa.width = p_rect.width;
t_wa.height = p_rect.height;
t_wa.event_mask = 0;
t_wa.wclass = GDK_INPUT_OUTPUT;
t_wa.visual = ((MCScreenDC*)MCscreen)->getvisual();
t_wa.window_type = GDK_WINDOW_CHILD;
w = gdk_window_new(stack_window, &t_wa, GDK_WA_X|GDK_WA_Y|GDK_WA_VISUAL);
if ( w == DNULL )
return False;
// Set-up our hints so that we have NO window decorations.
gdk_window_set_decorations(w, GdkWMDecoration(0));
// Ensure the newly created window stays above the stack window & map ( show )
gdk_window_set_transient_for(w, stack_window);
gdk_window_show_unraised(w);
m_window = w ;
MClastvideowindow = w ;
if ( m_filename == NULL )
m_filename = strdup(p_filename) ;
m_player_rect = p_rect ;
m_stack = p_stack ;
if ( !launch_player() )
{
gdk_window_hide(m_window);
gdk_window_destroy(m_window);
m_window = DNULL;
MClastvideowindow = DNULL ;
return false;
}
// We will be playing at start by default, so mark it as such
m_playing = true ;
// Start the media stopped
pause();
return true ;
}
static void
display_entry (MetaTabPopup *popup,
TabEntry *te)
{
GdkRectangle rect;
GdkRegion *region;
GdkRegion *inner_region;
GdkWindow *window;
if (popup->current_selected_entry)
{
if (popup->outline)
unselect_image (popup->current_selected_entry->widget);
else
unselect_workspace (popup->current_selected_entry->widget);
}
gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
if (popup->outline)
select_image (te->widget);
else
select_workspace (te->widget);
if (popup->outline)
{
/* Do stuff behind gtk's back */
gdk_window_hide (gtk_widget_get_window(popup->outline_window));
meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
rect = te->rect;
rect.x = 0;
rect.y = 0;
window = gtk_widget_get_window(GTK_WIDGET(popup->outline_window));
gdk_window_move_resize (window,
te->rect.x, te->rect.y,
te->rect.width, te->rect.height);
#if GTK_CHECK_VERSION(3, 0, 0)
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gdk_window_set_background_rgba (window, &black);
#else
gdk_window_set_background (window,
&popup->outline_window->style->black);
#endif
region = gdk_region_rectangle (&rect);
inner_region = gdk_region_rectangle (&te->inner_rect);
gdk_region_subtract (region, inner_region);
gdk_region_destroy (inner_region);
gdk_window_shape_combine_region (window,
region,
0, 0);
gdk_region_destroy (region);
/* This should piss off gtk a bit, but we don't want to raise
* above the tab popup. So, instead of calling gtk_widget_show,
* we manually set the window as mapped and then manually map it
* with gdk functions.
*/
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_set_mapped (popup->outline_window, TRUE);
#else
GTK_WIDGET_SET_FLAGS (popup->outline_window, GTK_MAPPED);
#endif
gdk_window_show_unraised (window);
}
/* Must be before we handle an expose for the outline window */
popup->current_selected_entry = te;
}
static void
anjuta_tabber_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
g_return_if_fail (ANJUTA_IS_TABBER (widget));
AnjutaTabber* tabber = ANJUTA_TABBER (widget);
GtkStyleContext* context;
GList* child;
gint focus_width;
gint focus_pad;
gint tab_curvature;
gint tab_overlap;
gint n_children = g_list_length (tabber->priv->children);
gint x;
gint focus_space;
gint tab_space;
context = gtk_widget_get_style_context (widget);
gtk_widget_style_get (GTK_WIDGET (tabber),
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"tab-curvature", &tab_curvature,
"tab-overlap", &tab_overlap,
NULL);
focus_space = focus_width + focus_pad;
tab_space = tab_curvature - tab_overlap;
gtk_widget_set_allocation (widget, allocation);
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
x = allocation->x + allocation->width;
break;
case GTK_TEXT_DIR_LTR:
default:
x = allocation->x;
}
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (tabber->priv->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
if (gtk_widget_get_mapped (widget))
gdk_window_show_unraised (tabber->priv->event_window);
}
if (n_children > 0)
{
gint total_space;
gint total_width;
gboolean use_natural = FALSE;
gint child_equal;
gint extra_space = 0;
gint real_width = allocation->width;
/* Calculate the total space that is used for padding/overlap */
total_space = 2 * tab_curvature
+ 2 * tab_space * (n_children - 1)
+ 2 * focus_space * n_children;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkStateFlags state;
GtkBorder tab_padding;
/* Get the padding of the tab */
gtk_style_context_save (context);
anjuta_tabber_setup_style_context (tabber, context, child, &state, NULL);
gtk_style_context_get_padding (context, state, &tab_padding);
gtk_style_context_restore (context);
total_space += tab_padding.left + tab_padding.right;
}
/* Check if we have enough space for all widgets natural size */
child_equal = (real_width - total_space) / n_children;
if (child_equal < 0)
return;
/* Calculate the total width of the tabs */
total_width = total_space;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
gint natural;
gtk_widget_get_preferred_width (child_widget, NULL,
&natural);
total_width += natural;
if (natural < child_equal)
extra_space += child_equal - natural;
}
use_natural = (total_width <= real_width);
child_equal += extra_space / n_children;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
GtkStateFlags state;
GtkBorder tab_padding, active_padding;
GtkAllocation child_alloc;
gint natural;
gint minimal;
gint begin_tab = tab_space;
gint end_tab = tab_space;
/* Get the padding of the tab */
gtk_style_context_save (context);
anjuta_tabber_setup_style_context (tabber, context, child, &state, NULL);
gtk_style_context_get_padding (context, state, &tab_padding);
gtk_style_context_get_padding (context, state | GTK_STATE_ACTIVE, &active_padding);
gtk_style_context_restore (context);
if (child->prev == NULL)
begin_tab = tab_curvature;
if (child->next == NULL)
end_tab = tab_curvature;
gtk_widget_get_preferred_width (child_widget, &minimal,
&natural);
if (use_natural)
{
child_alloc.width = natural;
}
else
{
if (natural < child_equal)
child_alloc.width = natural;
else
child_alloc.width = child_equal;
}
/* The active pad is by definition at least the same height
* as the inactive one. Therefore we always use the padding of the
* active tab to calculate the height and y position of the child.
*/
child_alloc.height = allocation->height - 2 * focus_space
- active_padding.top - active_padding.bottom;
child_alloc.y = allocation->y + focus_space + active_padding.top;
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
child_alloc.x = x - focus_space - tab_padding.right
- begin_tab - child_alloc.width;
x = child_alloc.x - focus_space - tab_padding.left - end_tab;
break;
case GTK_TEXT_DIR_LTR:
default:
child_alloc.x = x + focus_space + tab_padding.left + begin_tab;
x = child_alloc.x + child_alloc.width + focus_space
+ tab_padding.right + end_tab;
}
gtk_widget_size_allocate (child_widget, &child_alloc);
}
}
}
static void
anjuta_tabber_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
g_return_if_fail (ANJUTA_IS_TABBER (widget));
AnjutaTabber* tabber = ANJUTA_TABBER (widget);
GList* child;
gint focus_width;
gint tab_curvature;
gint tab_overlap;
gint n_children = g_list_length (tabber->priv->children);
gint x;
gint padding;
gint tab_space;
gtk_widget_style_get (GTK_WIDGET (tabber),
"focus-line-width", &focus_width,
"tab-curvature", &tab_curvature,
"tab-overlap", &tab_overlap,
NULL);
padding = focus_width + tabber->priv->tab_hborder;
tab_space = tab_curvature - tab_overlap;
gtk_widget_set_allocation (widget, allocation);
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
x = allocation->x + allocation->width;
break;
case GTK_TEXT_DIR_LTR:
default:
x = allocation->x;
}
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (tabber->priv->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
if (gtk_widget_get_mapped (widget))
gdk_window_show_unraised (tabber->priv->event_window);
}
if (n_children > 0)
{
gint total_width = 2 * tab_overlap;
gboolean use_natural = FALSE;
gint child_equal;
gint extra_space = 0;
gint real_width = allocation->width;
/* Check if we have enough space for all widgets natural size */
child_equal = real_width / n_children -
n_children * 2 * (padding + tab_space) - 2 * tab_overlap;
if (child_equal < 0)
return;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
gint natural;
gtk_widget_get_preferred_width (child_widget, NULL,
&natural);
total_width += natural + 2 * (padding + tab_space);
if (natural < child_equal)
extra_space += child_equal - natural;
}
use_natural = (total_width <= real_width);
child_equal += extra_space / n_children;
for (child = tabber->priv->children; child != NULL; child = g_list_next (child))
{
GtkWidget* child_widget = GTK_WIDGET (child->data);
GtkAllocation child_alloc;
gint natural;
gint minimal;
gint begin_tab = tab_space;
gint end_tab = tab_space;
if (child == g_list_first (tabber->priv->children))
begin_tab += tab_overlap;
if (child == g_list_last (tabber->priv->children))
end_tab += tab_overlap;
gtk_widget_get_preferred_width (child_widget, &minimal,
&natural);
if (use_natural)
{
child_alloc.width = natural;
}
else
{
if (natural < child_equal)
child_alloc.width = natural;
else
child_alloc.width = child_equal;
}
child_alloc.height = allocation->height
- 2 * (focus_width + tabber->priv->tab_vborder);
switch (gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_RTL:
child_alloc.x = x - padding - begin_tab - child_alloc.width;
x = child_alloc.x - padding - end_tab;
break;
case GTK_TEXT_DIR_LTR:
default:
child_alloc.x = x + padding + begin_tab;
x = child_alloc.x + child_alloc.width + padding + end_tab;
}
child_alloc.y = allocation->y +
tabber->priv->tab_vborder + focus_width;
gtk_widget_size_allocate (GTK_WIDGET (child->data), &child_alloc);
}
}
}
