path: root/lib/widgets/gedit-overlay-child.c

/*
 * gedit-overlay-child.c
 * This file is part of gedit
 *
 * Copyright (C) 2011 - Ignacio Casal Quinteiro
 *
 * gedit is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * gedit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "gedit-overlay-child.h"

struct _GeditOverlayChildPrivate
{
    GBinding                 *binding;
    GeditOverlayChildPosition position;
    guint                     offset;
};

enum
{
    PROP_0,
    PROP_WIDGET,
    PROP_POSITION,
    PROP_OFFSET
};

G_DEFINE_TYPE (GeditOverlayChild, gedit_overlay_child, GTK_TYPE_BIN)

static void
gedit_overlay_child_get_property (GObject    *object,
                                  guint       prop_id,
                                  GValue     *value,
                                  GParamSpec *pspec)
{
    GeditOverlayChild *child = GEDIT_OVERLAY_CHILD (object);

    switch (prop_id)
    {
        case PROP_WIDGET:
            g_value_set_object (value, gtk_bin_get_child (GTK_BIN (child)));
            break;
        case PROP_POSITION:
            g_value_set_uint (value, child->priv->position);
            break;
        case PROP_OFFSET:
            g_value_set_uint (value, child->priv->offset);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
            break;
    }
}

static void
gedit_overlay_child_set_property (GObject      *object,
                                  guint         prop_id,
                                  const GValue *value,
                                  GParamSpec   *pspec)
{
    GeditOverlayChild *child = GEDIT_OVERLAY_CHILD (object);

    switch (prop_id)
    {
        case PROP_WIDGET:
            gtk_container_add (GTK_CONTAINER (child),
                               g_value_get_object (value));
            break;
        case PROP_POSITION:
            child->priv->position = g_value_get_uint (value);
            break;
        case PROP_OFFSET:
            child->priv->offset = g_value_get_uint (value);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
            break;
    }
}

static void
gedit_overlay_child_realize (GtkWidget *widget)
{
    GdkWindowAttr attributes;
    GdkWindow *parent_window;
    GdkWindow *window;
    GtkStyleContext *context;

    gtk_widget_set_realized (widget, TRUE);

    parent_window = gtk_widget_get_parent_window (widget);
    context = gtk_widget_get_style_context (widget);

    attributes.window_type = GDK_WINDOW_CHILD;
    attributes.wclass = GDK_INPUT_OUTPUT;
    attributes.event_mask = GDK_EXPOSURE_MASK;
    attributes.width = 0;
    attributes.height = 0;

    window = gdk_window_new (parent_window, &attributes, 0);
    gdk_window_set_user_data (window, widget);
    gtk_widget_set_window (widget, window);
    gtk_style_context_set_state (context, GTK_STATE_FLAG_NORMAL);
    gtk_style_context_set_background (context, window);
}

static void
gedit_overlay_child_get_size (GtkWidget     *widget,
                              GtkOrientation orientation,
                              gint          *minimum,
                              gint          *natural)
{
    GeditOverlayChild *overlay_child = GEDIT_OVERLAY_CHILD (widget);
    GtkWidget *child;
    gint child_min = 0, child_nat = 0;

    child = gtk_bin_get_child (GTK_BIN (overlay_child));

    if (child != NULL)
    {
        if (orientation == GTK_ORIENTATION_HORIZONTAL)
        {
            gtk_widget_get_preferred_width (child,
                                            &child_min, &child_nat);
        }
        else
        {
            gtk_widget_get_preferred_height (child,
                                             &child_min, &child_nat);
        }
    }

    *minimum = child_min;
    *natural = child_nat;
}

static void
gedit_overlay_child_get_preferred_width (GtkWidget *widget,
                                         gint      *minimum,
                                         gint      *natural)
{
    gedit_overlay_child_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum, natural);
}

static void
gedit_overlay_child_get_preferred_height (GtkWidget *widget,
                                          gint      *minimum,
                                          gint      *natural)
{
    gedit_overlay_child_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum, natural);
}

static void
gedit_overlay_child_size_allocate (GtkWidget     *widget,
                                   GtkAllocation *allocation)
{
    GeditOverlayChild *overlay_child = GEDIT_OVERLAY_CHILD (widget);
    GtkWidget *child;
    GtkAllocation tmp;

    tmp.width = allocation->width;
    tmp.height = allocation->height;
    tmp.x = tmp.y = 0;

    GTK_WIDGET_CLASS (gedit_overlay_child_parent_class)->size_allocate (widget, allocation);

    child = gtk_bin_get_child (GTK_BIN (overlay_child));

    if (child != NULL)
    {
        gtk_widget_size_allocate (child, &tmp);
    }
}

static void
gedit_overlay_child_add (GtkContainer *container,
                         GtkWidget    *widget)
{
    GeditOverlayChild *overlay_child = GEDIT_OVERLAY_CHILD (container);

    overlay_child->priv->binding = g_object_bind_property (G_OBJECT (widget), "visible",
                                   G_OBJECT (container), "visible",
                                   G_BINDING_BIDIRECTIONAL);

    GTK_CONTAINER_CLASS (gedit_overlay_child_parent_class)->add (container, widget);
}

static void
gedit_overlay_child_remove (GtkContainer *container,
                            GtkWidget    *widget)
{
    GeditOverlayChild *child = GEDIT_OVERLAY_CHILD (container);

    g_object_unref (child->priv->binding);

    GTK_CONTAINER_CLASS (gedit_overlay_child_parent_class)->remove (container, widget);
}

static void
gedit_overlay_child_class_init (GeditOverlayChildClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
    GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
    GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
    
    object_class->get_property = gedit_overlay_child_get_property;
    object_class->set_property = gedit_overlay_child_set_property;

    widget_class->realize = gedit_overlay_child_realize;
    widget_class->get_preferred_width = gedit_overlay_child_get_preferred_width;
    widget_class->get_preferred_height = gedit_overlay_child_get_preferred_height;
    widget_class->size_allocate = gedit_overlay_child_size_allocate;

    container_class->add = gedit_overlay_child_add;
    container_class->remove = gedit_overlay_child_remove;

    g_object_class_install_property (object_class, PROP_WIDGET,
                                     g_param_spec_object ("widget",
                                                          "Widget",
                                                          "The Widget",
                                                          GTK_TYPE_WIDGET,
                                                          G_PARAM_READWRITE |
                                                          G_PARAM_CONSTRUCT_ONLY |
                                                          G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (object_class, PROP_POSITION,
                                     g_param_spec_uint ("position",
                                                        "Position",
                                                        "The Widget Position",
                                                        1, GEDIT_OVERLAY_CHILD_POSITION_STATIC,
                                                        GEDIT_OVERLAY_CHILD_POSITION_STATIC,
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT |
                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (object_class, PROP_OFFSET,
                                     g_param_spec_uint ("offset",
                                                        "Offset",
                                                        "The Widget Offset",
                                                        0,
                                                        G_MAXUINT,
                                                        0,
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT |
                                                        G_PARAM_STATIC_STRINGS));

    g_type_class_add_private (object_class, sizeof (GeditOverlayChildPrivate));
}

static void
gedit_overlay_child_init (GeditOverlayChild *child)
{
    child->priv = G_TYPE_INSTANCE_GET_PRIVATE (child,
                                               GEDIT_TYPE_OVERLAY_CHILD,
                                               GeditOverlayChildPrivate);

    gtk_widget_set_has_window (GTK_WIDGET (child), TRUE);
}

/**
 * gedit_overlay_child_new:
 * @widget: a #GtkWidget
 *
 * Creates a new #GeditOverlayChild object
 *
 * Returns: a new #GeditOverlayChild object
 */
GeditOverlayChild *
gedit_overlay_child_new (GtkWidget *widget)
{
    return g_object_new (GEDIT_TYPE_OVERLAY_CHILD,
                         "widget", widget,
                         NULL);
}

/**
 * gedit_overlay_child_get_position:
 * @child: a #GeditOverlayChild
 *
 * Gets the position of the widget
 *
 * Returns: wether the child should be placed in a #GeditOverlay
 */
GeditOverlayChildPosition
gedit_overlay_child_get_position (GeditOverlayChild *child)
{
    g_return_val_if_fail (GEDIT_IS_OVERLAY_CHILD (child), GEDIT_OVERLAY_CHILD_POSITION_STATIC);

    return child->priv->position;
}

/**
 * gedit_overlay_child_set_position:
 * @child: a #GeditOverlayChild
 * @position: a #GeditOverlayChildPosition
 *
 * Sets the new position for @child
 */
void
gedit_overlay_child_set_position (GeditOverlayChild        *child,
                                  GeditOverlayChildPosition position)
{
    g_return_if_fail (GEDIT_IS_OVERLAY_CHILD (child));

    if (child->priv->position != position)
    {
        child->priv->position = position;

        g_object_notify (G_OBJECT (child), "position");
    }
}

/**
 * gedit_overlay_child_get_offset:
 * @child: a #GeditOverlayChild
 *
 * Gets the offset for @child. The offset is usually used by #GeditOverlay
 * to not place the widget directly in the border of the container
 *
 * Returns: the offset for @child
 */
guint
gedit_overlay_child_get_offset (GeditOverlayChild *child)
{
    g_return_val_if_fail (GEDIT_IS_OVERLAY_CHILD (child), 0);

    return child->priv->offset;
}

/**
 * gedit_overlay_child_set_offset:
 * @child: a #GeditOverlayChild
 * @offset: the offset for @child
 *
 * Sets the new offset for @child
 */
void
gedit_overlay_child_set_offset (GeditOverlayChild *child,
                                guint              offset)
{
    g_return_if_fail (GEDIT_IS_OVERLAY_CHILD (child));

    if (child->priv->offset != offset)
    {
        child->priv->offset = offset;

        g_object_notify (G_OBJECT (child), "offset");
    }
}

/* ex:set ts=8 noet: */