自学教程：C++ GTK_REVEALER函数代码示例

static voidphotos_edit_palette_row_constructed (GObject *object){  PhotosEditPaletteRow *self = PHOTOS_EDIT_PALETTE_ROW (object);  GtkWidget *grid0;  GtkWidget *grid1;  GtkWidget *image;  GtkWidget *label;  GtkWidget *tool_widget;  const gchar *icon_name;  const gchar *name;  gchar *name_markup;  G_OBJECT_CLASS (photos_edit_palette_row_parent_class)->constructed (object);  self->row_revealer = gtk_revealer_new();  gtk_revealer_set_transition_type (GTK_REVEALER (self->row_revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);  gtk_container_add (GTK_CONTAINER (self), self->row_revealer);  grid0 = gtk_grid_new ();  gtk_widget_set_margin_bottom (grid0, 6);  gtk_widget_set_margin_start (grid0, 18);  gtk_widget_set_margin_end (grid0, 18);  gtk_widget_set_margin_top (grid0, 6);  gtk_orientable_set_orientation (GTK_ORIENTABLE (grid0), GTK_ORIENTATION_VERTICAL);  gtk_container_add (GTK_CONTAINER (self->row_revealer), grid0);  grid1 = gtk_grid_new ();  gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_HORIZONTAL);  gtk_grid_set_column_spacing (GTK_GRID (grid1), 12);  gtk_container_add (GTK_CONTAINER (grid0), grid1);  icon_name = photos_tool_get_icon_name (self->tool);  image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_BUTTON);  gtk_container_add (GTK_CONTAINER (grid1), image);  name = photos_tool_get_name (self->tool);  label = gtk_label_new (NULL);  name_markup = g_strdup_printf ("<b>%s</b>", name);  gtk_label_set_markup (GTK_LABEL (label), name_markup);  gtk_container_add (GTK_CONTAINER (grid1), label);  self->details_revealer = gtk_revealer_new ();  gtk_revealer_set_transition_type (GTK_REVEALER (self->details_revealer),                                    GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);  gtk_container_add (GTK_CONTAINER (grid0), self->details_revealer);  tool_widget = photos_tool_get_widget (self->tool);  gtk_widget_set_margin_bottom (tool_widget, 12);  gtk_widget_set_margin_top (tool_widget, 12);  gtk_container_add (GTK_CONTAINER (self->details_revealer), tool_widget);  gtk_size_group_add_widget (self->size_group, tool_widget);  g_signal_connect_swapped (self->tool, "hide-requested", G_CALLBACK (photos_edit_palette_row_hide_details), self);  gtk_widget_show_all (GTK_WIDGET (self));  g_free (name_markup);  g_clear_object (&self->size_group); /* We will not need it any more */}

static voidfsearch_window_apply_config (FsearchApplicationWindow *self){    g_assert (FSEARCH_WINDOW_IS_WINDOW (self));    FsearchApplication *app = FSEARCH_APPLICATION_DEFAULT;    FsearchConfig *config = fsearch_application_get_config (app);    if (config->restore_window_size) {        gtk_window_set_default_size (GTK_WINDOW (self),                                     config->window_width,                                     config->window_height);    }    gtk_widget_set_visible (self->menubar, config->show_menubar);    gtk_widget_set_visible (self->statusbar, config->show_statusbar);    gtk_widget_set_visible (self->filter_combobox, config->show_filter);    gtk_widget_set_visible (self->search_button, config->show_search_button);    gtk_revealer_set_reveal_child (GTK_REVEALER (self->match_case_revealer), config->match_case);    gtk_revealer_set_reveal_child (GTK_REVEALER (self->search_mode_revealer), config->enable_regex);    gtk_revealer_set_reveal_child (GTK_REVEALER (self->search_in_path_revealer), config->search_in_path);    if (!config->locations) {        gtk_widget_show (self->empty_database_overlay);    }}

static voidshow_info_bar(GtWin* self){    GtWinPrivate* priv = gt_win_get_instance_private(self);    QueuedInfoData* data = g_queue_pop_head(priv->info_queue);    if (data)    {        if (data->cb)        {            if (data->cb == G_CALLBACK(show_error_dialogue_cb))            {                gtk_widget_set_visible(priv->info_bar_ok_button, FALSE);                gtk_widget_set_visible(priv->info_bar_yes_button, FALSE);                gtk_widget_set_visible(priv->info_bar_no_button, FALSE);                gtk_widget_set_visible(priv->info_bar_details_button, TRUE);                gtk_widget_set_visible(priv->info_bar_close_button, TRUE);                gtk_label_set_markup(GTK_LABEL(priv->info_label), data->msg);                gtk_info_bar_set_message_type(GTK_INFO_BAR(priv->info_bar), GTK_MESSAGE_ERROR);                g_signal_connect(priv->info_bar, "response", G_CALLBACK(data->cb), data->udata);            }            else            {                g_signal_connect(priv->info_bar, "response", G_CALLBACK(data->cb), data->udata);                gtk_widget_set_visible(priv->info_bar_ok_button, FALSE);                gtk_widget_set_visible(priv->info_bar_yes_button, TRUE);                gtk_widget_set_visible(priv->info_bar_no_button, TRUE);                gtk_widget_set_visible(priv->info_bar_details_button, FALSE);                gtk_widget_set_visible(priv->info_bar_close_button, FALSE);                gtk_label_set_markup(GTK_LABEL(priv->info_label), data->msg);                gtk_info_bar_set_message_type(GTK_INFO_BAR(priv->info_bar), GTK_MESSAGE_QUESTION);            }        }        else        {            gtk_widget_set_visible(priv->info_bar_yes_button, FALSE);            gtk_widget_set_visible(priv->info_bar_no_button, FALSE);            gtk_widget_set_visible(priv->info_bar_ok_button, TRUE);            gtk_widget_set_visible(priv->info_bar_details_button, FALSE);            gtk_widget_set_visible(priv->info_bar_close_button, FALSE);            gtk_label_set_markup(GTK_LABEL(priv->info_label), data->msg);            gtk_info_bar_set_message_type(GTK_INFO_BAR(priv->info_bar), GTK_MESSAGE_INFO);        }        priv->cur_info_data = data;        gtk_revealer_set_reveal_child(GTK_REVEALER(priv->info_revealer), TRUE);    }    else    {        priv->cur_info_data = NULL;        gtk_revealer_set_reveal_child(GTK_REVEALER(priv->info_revealer), FALSE);    }}

intmain(int argc, char **argv){  GtkWidget *window, *revealer, *grid, *widget;  GtkCssProvider *cssprovider;  GError *error = NULL;  guint x, y;  GOptionContext *context = g_option_context_new (NULL);  g_option_context_add_main_entries (context, options, NULL);  frame_stats_add_options (g_option_context_get_main_group (context));  g_option_context_add_group (context,                              gtk_get_option_group (TRUE));  if (!g_option_context_parse (context, &argc, &argv, &error))    {      g_printerr ("Option parsing failed: %s/n", error->message);      return 1;    }  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  frame_stats_ensure (GTK_WINDOW (window));  revealer = gtk_revealer_new ();  gtk_widget_set_valign (revealer, GTK_ALIGN_START);  gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);  gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), reveal_time * 1000);  gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), TRUE);  g_signal_connect_after (revealer, "map", G_CALLBACK (toggle_reveal), NULL);  g_signal_connect_after (revealer, "notify::child-revealed", G_CALLBACK (toggle_reveal), NULL);  gtk_container_add (GTK_CONTAINER (window), revealer);  grid = gtk_grid_new ();  gtk_container_add (GTK_CONTAINER (revealer), grid);  cssprovider = gtk_css_provider_new ();  gtk_css_provider_load_from_data (cssprovider, "* { padding: 2px; text-shadow: 5px 5px 2px grey; }", -1, NULL);  for (x = 0; x < 10; x++)    {      for (y = 0; y < 20; y++)        {          widget = gtk_label_new ("Hello World");          gtk_style_context_add_provider (gtk_widget_get_style_context (widget),                                          GTK_STYLE_PROVIDER (cssprovider),                                          GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);          gtk_grid_attach (GTK_GRID (grid), widget, x, y, 1, 1);        }    }  gtk_widget_show_all (window);  gtk_main ();  return 0;}

static voidupdate_operations (NautilusToolbar *self){        GList *progress_infos;        GList *l;        GtkWidget *progress;        gboolean should_show_progress_button = FALSE;        gtk_container_foreach (GTK_CONTAINER (self->priv->operations_container),                               (GtkCallback) gtk_widget_destroy,                               NULL);        disconnect_progress_infos (self);        progress_infos = get_filtered_progress_infos (self);        for (l = progress_infos; l != NULL; l = l->next) {                should_show_progress_button = should_show_progress_button ||                                              should_show_progress_info (l->data);                g_signal_connect_swapped (l->data, "finished",		                          G_CALLBACK (on_progress_info_finished), self);                g_signal_connect_swapped (l->data, "cancelled",		                          G_CALLBACK (on_progress_info_cancelled), self);                g_signal_connect_swapped (l->data, "progress-changed",		                          G_CALLBACK (on_progress_info_progress_changed), self);                progress = nautilus_progress_info_widget_new (l->data);                gtk_box_pack_start (GTK_BOX (self->priv->operations_container),                                    progress,                                    FALSE, FALSE, 0);        }        g_list_free (progress_infos);        /* Either we are already showing the button, so keep showing it until the user         * toggle it to hide the operations popover, or, if we want now to show it,         * we have to have at least one operation that its total stimated time         * is longer than OPERATION_MINIMUM_TIME seconds, or if we failed to get         * a correct stimated time and it's around OPERATION_MINIMUM_TIME,         * showing the button for just for a moment because now we realized the         * estimated time is longer than a OPERATION_MINIMUM_TIME is odd, so show         * it only if the remaining time is bigger than again OPERATION_MINIMUM_TIME.         */        if (should_show_progress_button &&            !gtk_revealer_get_reveal_child (GTK_REVEALER (self->priv->operations_revealer))) {                add_operations_button_attention_style (self);                gtk_revealer_set_reveal_child (GTK_REVEALER (self->priv->operations_revealer),                                               TRUE);                gtk_widget_queue_draw (self->priv->operations_icon);        }}

static voidtoggle_all (GtkButton  *button,            PnlDockBin *dock){  GtkRevealer *edge;  edge = GTK_REVEALER (pnl_dock_bin_get_left_edge (dock));  gtk_revealer_set_reveal_child (edge, !gtk_revealer_get_reveal_child (edge));  edge = GTK_REVEALER (pnl_dock_bin_get_right_edge (dock));  gtk_revealer_set_reveal_child (edge, !gtk_revealer_get_reveal_child (edge));  edge = GTK_REVEALER (pnl_dock_bin_get_bottom_edge (dock));  gtk_revealer_set_reveal_child (edge, !gtk_revealer_get_reveal_child (edge));}

static voidtoggle_overlay (GtkWidget *checkbutton,		GtkWidget *revealer){  gtk_revealer_set_reveal_child (GTK_REVEALER (revealer),				 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));}

static voidstop_search_cb (GtkWidget    *entry,                GtkSearchBar *bar){  GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);  gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), FALSE);}

static voidgtk_revealer_real_get_preferred_width_for_height (GtkWidget *widget,                                                  gint       height,                                                  gint      *minimum_width_out,                                                  gint      *natural_width_out){  GtkRevealer *revealer = GTK_REVEALER (widget);  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);  gint minimum_width;  gint natural_width;  GtkRevealerTransitionType transition;  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_width_for_height (widget, height, &minimum_width, &natural_width);  transition = effective_transition (revealer);  if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT ||      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT)    natural_width = round (natural_width * priv->current_pos);  minimum_width = MIN (minimum_width, natural_width);  if (minimum_width_out)    *minimum_width_out = minimum_width;  if (natural_width_out)    *natural_width_out = natural_width;}

static voidgtk_revealer_get_property (GObject    *object,                           guint       property_id,                           GValue     *value,                           GParamSpec *pspec){  GtkRevealer *revealer = GTK_REVEALER (object);  switch (property_id)   {    case PROP_TRANSITION_TYPE:      g_value_set_enum (value, gtk_revealer_get_transition_type (revealer));      break;    case PROP_TRANSITION_DURATION:      g_value_set_uint (value, gtk_revealer_get_transition_duration (revealer));      break;    case PROP_REVEAL_CHILD:      g_value_set_boolean (value, gtk_revealer_get_reveal_child (revealer));      break;    case PROP_CHILD_REVEALED:      g_value_set_boolean (value, gtk_revealer_get_child_revealed (revealer));      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);      break;    }}

static voidgtk_revealer_real_get_preferred_height_for_width (GtkWidget *widget,                                                  gint       width,                                                  gint      *minimum_height_out,                                                  gint      *natural_height_out){  GtkRevealer *revealer = GTK_REVEALER (widget);  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);  gint minimum_height;  gint natural_height;  GtkRevealerTransitionType transition;  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_height_for_width (widget, width, &minimum_height, &natural_height);  transition = effective_transition (revealer);  if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP ||      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN)    natural_height = round (natural_height * priv->current_pos);  minimum_height = MIN (minimum_height, natural_height);  if (minimum_height_out)    *minimum_height_out = minimum_height;  if (natural_height_out)    *natural_height_out = natural_height;}

static voidgtk_revealer_real_realize (GtkWidget *widget){  GtkRevealer *revealer = GTK_REVEALER (widget);  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);  GtkAllocation allocation;  GdkWindowAttr attributes = { 0 };  GdkWindowAttributesType attributes_mask;  GtkAllocation child_allocation;  GtkWidget *child;  GtkStyleContext *context;  GtkRevealerTransitionType transition;  gtk_widget_set_realized (widget, TRUE);  gtk_widget_get_allocation (widget, &allocation);  attributes.x = allocation.x;  attributes.y = allocation.y;  attributes.width = allocation.width;  attributes.height = allocation.height;  attributes.window_type = GDK_WINDOW_CHILD;  attributes.wclass = GDK_INPUT_OUTPUT;  attributes.visual = gtk_widget_get_visual (widget);  attributes.event_mask =    gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;  attributes_mask = (GDK_WA_X | GDK_WA_Y) | GDK_WA_VISUAL;  priv->view_window =    gdk_window_new (gtk_widget_get_parent_window ((GtkWidget*) revealer),                    &attributes, attributes_mask);  gtk_widget_set_window (widget, priv->view_window);  gtk_widget_register_window (widget, priv->view_window);  gtk_revealer_get_child_allocation (revealer, &allocation, &child_allocation);  attributes.x = 0;  attributes.y = 0;  attributes.width = child_allocation.width;  attributes.height = child_allocation.height;  transition = effective_transition (revealer);  if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN)    attributes.y = allocation.height - child_allocation.height;  else if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT)    attributes.x = allocation.width - child_allocation.width;  priv->bin_window =    gdk_window_new (priv->view_window, &attributes, attributes_mask);  gtk_widget_register_window (widget, priv->bin_window);  child = gtk_bin_get_child (GTK_BIN (revealer));  if (child != NULL)    gtk_widget_set_parent_window (child, priv->bin_window);  context = gtk_widget_get_style_context (widget);  gtk_style_context_set_background (context, priv->view_window);  gtk_style_context_set_background (context, priv->bin_window);  gdk_window_show (priv->bin_window);}

voidgt_games_view_child_hide_overlay(GtGamesViewChild* self){    GtGamesViewChildPrivate* priv = gt_games_view_child_get_instance_private(self);    gtk_revealer_set_reveal_child(GTK_REVEALER(priv->middle_revealer), FALSE);}

/** * gtk_search_bar_handle_event: * @bar: a #GtkSearchBar * @event: a #GdkEvent containing key press events * * This function should be called when the top-level * window which contains the search bar received a key event. * * If the key event is handled by the search bar, the bar will * be shown, the entry populated with the entered text and %GDK_EVENT_STOP * will be returned. The caller should ensure that events are * not propagated further. * * If no entry has been connected to the search bar, using * gtk_search_bar_connect_entry(), this function will return * immediately with a warning. * * ## Showing the search bar on key presses * * |[<!-- language="C" --> * static gboolean * on_key_press_event (GtkWidget *widget, *                     GdkEvent  *event, *                     gpointer   user_data) * { *   GtkSearchBar *bar = GTK_SEARCH_BAR (user_data); *   return gtk_search_bar_handle_event (bar, event); * } * * g_signal_connect (window, *                  "key-press-event", *                   G_CALLBACK (on_key_press_event), *                   search_bar); * ]| * * Returns: %GDK_EVENT_STOP if the key press event resulted *     in text being entered in the search entry (and revealing *     the search bar if necessary), %GDK_EVENT_PROPAGATE otherwise. * * Since: 3.10 */gbooleangtk_search_bar_handle_event (GtkSearchBar *bar,                             GdkEvent     *event){  GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);  gboolean handled;  if (priv->reveal_child)    return GDK_EVENT_PROPAGATE;  if (priv->entry == NULL)    {      g_warning ("The search bar does not have an entry connected to it. Call gtk_search_bar_connect_entry() to connect one.");      return GDK_EVENT_PROPAGATE;    }  if (GTK_IS_SEARCH_ENTRY (priv->entry))    handled = gtk_search_entry_handle_event (GTK_SEARCH_ENTRY (priv->entry), event);  else    handled = gtk_search_bar_handle_event_for_entry (bar, event);  if (handled == GDK_EVENT_STOP)    gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), TRUE);  return handled;}

static voidphotos_zoom_controls_update_buttons (PhotosZoomControls *self){  GtkWidget *image;  gboolean zoom_best_fit_enabled;  gboolean zoom_out_enabled;  const gchar *icon_name;  zoom_best_fit_enabled = g_action_get_enabled (self->zoom_best_fit_action);  zoom_out_enabled = g_action_get_enabled (self->zoom_out_action);  g_return_if_fail (zoom_best_fit_enabled == zoom_out_enabled);  gtk_revealer_set_reveal_child (GTK_REVEALER (self->revealer), zoom_out_enabled);  gtk_actionable_set_action_name (GTK_ACTIONABLE (self->zoom_toggle_button), NULL);  gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->zoom_toggle_button), NULL);  if (zoom_out_enabled)    {      gtk_actionable_set_action_name (GTK_ACTIONABLE (self->zoom_toggle_button), "app.zoom-best-fit");    }  else    {      GVariant *target_value = NULL;      target_value = photos_utils_create_zoom_target_value (1.0, PHOTOS_ZOOM_EVENT_MOUSE_CLICK);      gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->zoom_toggle_button), target_value);      gtk_actionable_set_action_name (GTK_ACTIONABLE (self->zoom_toggle_button), "app.zoom-in");    }  icon_name = zoom_out_enabled ? "zoom-fit-best-symbolic" : "zoom-in-symbolic";  image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_INVALID);  gtk_image_set_pixel_size (GTK_IMAGE (image), 16);  gtk_button_set_image (GTK_BUTTON (self->zoom_toggle_button), image);}

voidgt_channels_container_child_hide_overlay(GtChannelsContainerChild* self){    GtChannelsContainerChildPrivate* priv = gt_channels_container_child_get_instance_private(self);    gtk_revealer_set_reveal_child(GTK_REVEALER(priv->middle_revealer), FALSE);}

/* public functions */void spd_init(GtkBuilder *builder){	/* widgets and icons */	revealer_scan_progress = GTK_REVEALER(gtk_builder_get_object(builder, "revealer_scan_progress"));	lab_scan_progress = GTK_LABEL(gtk_builder_get_object(builder, "lab_scan_progress"));	scanningSpinner = GTK_SPINNER(gtk_builder_get_object(builder, "scanningSpinner"));  	p_innerPaned = GTK_PANED(gtk_builder_get_object(builder, "p_innerPaned")) ;}

static voidclose_button_clicked_cb (GtkWidget    *button,                         GtkSearchBar *bar){  GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);  gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), FALSE);}

static voiddismiss (GtkWidget *button){  GtkWidget *w;  w = gtk_widget_get_ancestor (button, GTK_TYPE_REVEALER);  gtk_revealer_set_reveal_child (GTK_REVEALER (w), FALSE);}

static voidphotos_preview_nav_buttons_fade_in_button (PhotosPreviewNavButtons *self, GtkWidget *widget){  if (self->model == NULL || !gtk_tree_row_reference_valid (self->current_row))    return;  gtk_widget_show_all (widget);  gtk_revealer_set_reveal_child (GTK_REVEALER (widget), TRUE);}

static voidgtk_revealer_real_unmap (GtkWidget *widget){  GtkRevealer *revealer = GTK_REVEALER (widget);  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->unmap (widget);  gtk_revealer_stop_animation (revealer);}

voidlaps_row_slide_in (LapsRow *row){	LapsRowPrivate *priv;	priv = laps_row_get_instance_private (row);	gtk_revealer_set_reveal_child (GTK_REVEALER (priv->slider), TRUE);}

static voidphotos_preview_nav_buttons_fade_out_button (PhotosPreviewNavButtons *self, GtkWidget *widget){  gtk_revealer_set_reveal_child (GTK_REVEALER (widget), FALSE);  g_signal_connect_swapped (widget,                            "notify::child-revealed",                            G_CALLBACK (photos_preview_nav_buttons_notify_child_revealed),                            self);}

/** * gtk_search_bar_set_search_mode: * @bar: a #GtkSearchBar * @search_mode: the new state of the search mode * * Switches the search mode on or off. * * Since: 3.10 */voidgtk_search_bar_set_search_mode (GtkSearchBar *bar,                                gboolean      search_mode){  GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);  g_return_if_fail (GTK_IS_SEARCH_BAR (bar));  gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), search_mode);}

static voidmotion_leave_cb(GtkWidget* widget,                GdkEvent* evt,                gpointer udata){    GtGamesViewChild* self = GT_GAMES_VIEW_CHILD(udata);    GtGamesViewChildPrivate* priv = gt_games_view_child_get_instance_private(self);    gtk_revealer_set_reveal_child(GTK_REVEALER(priv->middle_revealer), FALSE);}

static voidmotion_leave_cb(GtkWidget* widget,                GdkEvent* evt,                gpointer udata){    GtChannelsContainerChild* self = GT_CHANNELS_CONTAINER_CHILD(udata);    GtChannelsContainerChildPrivate* priv = gt_channels_container_child_get_instance_private(self);    gtk_revealer_set_reveal_child(GTK_REVEALER(priv->middle_revealer), FALSE);}

static voidmotion_enter_cb(GtkWidget* widget,                GdkEvent* evt,                gpointer udata){    GtChannelsViewChild* self = GT_CHANNELS_VIEW_CHILD(udata);    GtChannelsViewChildPrivate* priv = gt_channels_view_child_get_instance_private(self);    gtk_revealer_set_reveal_child(GTK_REVEALER(priv->middle_revealer), TRUE);}