/*
 * Copyright (C) 2010 Collabora Ltd.
 * Copyright (C) 2010 Igalia, S.L.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301, USA.
 */

#include "GtkVersioning.h"

#include <gtk/gtk.h>

#ifdef GDK_WINDOWING_X11
#include <X11/Xatom.h>
#include <gdk/gdkx.h>
#endif

#if !GTK_CHECK_VERSION(2, 14, 0)
void gtk_adjustment_set_value(GtkAdjustment* adjusment, gdouble value)
{
        m_adjustment->value = m_currentPos;
        gtk_adjustment_value_changed(m_adjustment);
}

void gtk_adjustment_configure(GtkAdjustment* adjustment, gdouble value, gdouble lower, gdouble upper,
                              gdouble stepIncrement, gdouble pageIncrement, gdouble pageSize)
{
    g_object_freeze_notify(G_OBJECT(adjustment));

    g_object_set(adjustment,
                 "lower", lower,
                 "upper", upper,
                 "step-increment", stepIncrement,
                 "page-increment", pageIncrement,
                 "page-size", pageSize,
                 NULL);

    g_object_thaw_notify(G_OBJECT(adjustment));

    gtk_adjustment_changed(adjustment);
    gtk_adjustment_value_changed(adjustment);
}
#endif

GdkDevice *getDefaultGDKPointerDevice(GdkWindow* window)
{
#ifndef GTK_API_VERSION_2
    GdkDeviceManager *manager =  gdk_display_get_device_manager(gdk_window_get_display(window));
    return gdk_device_manager_get_client_pointer(manager);
#else
    return gdk_device_get_core_pointer();
#endif // GTK_API_VERSION_2
}

#if !GTK_CHECK_VERSION(2, 17, 3)
void gdk_window_get_root_coords(GdkWindow* window, gint x, gint y, gint* rootX, gint* rootY)
{
    gdk_window_get_root_origin(window, rootX, rootY);
    *rootX = *rootX + x;
    *rootY = *rootY + y;
}
#endif

GdkCursor * blankCursor()
{
#if GTK_CHECK_VERSION(2, 16, 0)
    return gdk_cursor_new(GDK_BLANK_CURSOR);
#else
    GdkCursor * cursor;
    GdkPixmap * source;
    GdkPixmap * mask;
    GdkColor foreground = { 0, 65535, 0, 0 }; // Red.
    GdkColor background = { 0, 0, 0, 65535 }; // Blue.
    static gchar cursorBits[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};

    source = gdk_bitmap_create_from_data(0, cursorBits, 8, 8);
    mask = gdk_bitmap_create_from_data(0, cursorBits, 8, 8);
    cursor = gdk_cursor_new_from_pixmap(source, mask, &foreground, &background, 8, 8);
    gdk_pixmap_unref(source);
    gdk_pixmap_unref(mask);
    return cursor;
#endif // GTK_CHECK_VERSION(2, 16, 0)
}

#if !GTK_CHECK_VERSION(2, 16, 0)
const gchar* gtk_menu_item_get_label(GtkMenuItem* menuItem)
{
    GtkWidget * label = gtk_bin_get_child(GTK_BIN(menuItem));
    if (GTK_IS_LABEL(label))
        return gtk_label_get_text(GTK_LABEL(label));
    return 0;
}
#endif // GTK_CHECK_VERSION(2, 16, 0)

#ifdef GTK_API_VERSION_2
static cairo_format_t
gdk_cairo_format_for_content(cairo_content_t content)
{
    switch (content) {
    case CAIRO_CONTENT_COLOR:
        return CAIRO_FORMAT_RGB24;
    case CAIRO_CONTENT_ALPHA:
        return CAIRO_FORMAT_A8;
    case CAIRO_CONTENT_COLOR_ALPHA:
    default:
        return CAIRO_FORMAT_ARGB32;
    }
}

static cairo_surface_t*
gdk_cairo_surface_coerce_to_image(cairo_surface_t* surface,
                                  cairo_content_t content,
                                  int width,
                                  int height)
{
    cairo_surface_t * copy;
    cairo_t * cr;

    if (cairo_surface_get_type(surface) == CAIRO_SURFACE_TYPE_IMAGE
        && cairo_surface_get_content(surface) == content
        && cairo_image_surface_get_width(surface) >= width
        && cairo_image_surface_get_height(surface) >= height)
        return cairo_surface_reference(surface);

    copy = cairo_image_surface_create(gdk_cairo_format_for_content(content),
                                      width,
                                      height);

    cr = cairo_create(copy);
    cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
    cairo_set_source_surface(cr, surface, 0, 0);
    cairo_paint(cr);
    cairo_destroy(cr);

    return copy;
}

static void
convert_alpha(guchar * destData, int destStride,
              guchar * srcData, int srcStride,
              int srcX, int srcY, int width, int height)
{
    int x, y;

    srcData += srcStride * srcY + srcY * 4;

    for (y = 0; y < height; y++) {
        guint32 * src = (guint32 *) srcData;

        for (x = 0; x < width; x++) {
            guint alpha = src[x] >> 24;

            if (!alpha) {
                destData[x * 4 + 0] = 0;
                destData[x * 4 + 1] = 0;
                destData[x * 4 + 2] = 0;
            } else {
                destData[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
                destData[x * 4 + 1] = (((src[x] & 0x00ff00) >>  8) * 255 + alpha / 2) / alpha;
                destData[x * 4 + 2] = (((src[x] & 0x0000ff) >>  0) * 255 + alpha / 2) / alpha;
            }
            destData[x * 4 + 3] = alpha;
        }

        srcData += srcStride;
        destData += destStride;
    }
}

static void
convert_no_alpha(guchar * destData, int destStride, guchar * srcData,
                 int srcStride, int srcX, int srcY,
                 int width, int height)
{
    int x, y;

    srcData += srcStride * srcY + srcX * 4;

    for (y = 0; y < height; y++) {
        guint32 * src = (guint32 *) srcData;

        for (x = 0; x < width; x++) {
            destData[x * 3 + 0] = src[x] >> 16;
            destData[x * 3 + 1] = src[x] >>  8;
            destData[x * 3 + 2] = src[x];
        }

        srcData += srcStride;
        destData += destStride;
    }
}

/**
 * gdk_pixbuf_get_from_surface:
 * @surface: surface to copy from
 * @src_x: Source X coordinate within @surface
 * @src_y: Source Y coordinate within @surface
 * @width: Width in pixels of region to get
 * @height: Height in pixels of region to get
 *
 * Transfers image data from a #cairo_surface_t and converts it to an RGB(A)
 * representation inside a #GdkPixbuf. This allows you to efficiently read
 * individual pixels from cairo surfaces. For #GdkWindows, use
 * gdk_pixbuf_get_from_window() instead.
 *
 * This function will create an RGB pixbuf with 8 bits per channel. The pixbuf
 * will contain an alpha channel if the @surface contains one.
 *
 * Return value: (transfer full): A newly-created pixbuf with a reference count
 * of 1, or %NULL on error
 **/
GdkPixbuf*
gdk_pixbuf_get_from_surface(cairo_surface_t * surface,
                            int srcX, int srcY,
                            int width, int height)
{
    cairo_content_t content;
    GdkPixbuf * dest;

    /* General sanity checks */
    g_return_val_if_fail(surface, NULL);
    g_return_val_if_fail(srcX >= 0 && srcY >= 0, NULL);
    g_return_val_if_fail(width > 0 && height > 0, NULL);

    content = cairo_surface_get_content(surface) | CAIRO_CONTENT_COLOR;
    dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
                          !!(content & CAIRO_CONTENT_ALPHA),
                          8,
                          width, height);

    surface = gdk_cairo_surface_coerce_to_image(surface, content, srcX + width, srcY + height);
    cairo_surface_flush(surface);
    if (cairo_surface_status(surface) || !dest) {
        cairo_surface_destroy(surface);
        return NULL;
    }

    if (gdk_pixbuf_get_has_alpha(dest))
        convert_alpha(gdk_pixbuf_get_pixels(dest),
                       gdk_pixbuf_get_rowstride(dest),
                       cairo_image_surface_get_data(surface),
                       cairo_image_surface_get_stride(surface),
                       srcX, srcY,
                       width, height);
    else
        convert_no_alpha(gdk_pixbuf_get_pixels(dest),
                          gdk_pixbuf_get_rowstride(dest),
                          cairo_image_surface_get_data(surface),
                          cairo_image_surface_get_stride(surface),
                          srcX, srcY,
                          width, height);

    cairo_surface_destroy(surface);
    return dest;
}

#if GTK_CHECK_VERSION(2, 24, 0)
void getGdkDrawableSize(GdkDrawable *drawable, int *width, int *height)
{
    g_return_if_fail(GDK_IS_PIXMAP(drawable) || GDK_IS_WINDOW(drawable));

    if (GDK_IS_PIXMAP(drawable)) {
        gdk_pixmap_get_size(GDK_PIXMAP(drawable), width, height);
        return;
    }

    GdkWindow *window = GDK_WINDOW(drawable);
    *width = gdk_window_get_width(window);
    *height = gdk_window_get_height(window);
}
#else
void getGdkDrawableSize(GdkDrawable *drawable, int *width, int *height)
{
    gdk_drawable_get_size(drawable, width, height);
}
#endif // GTK_CHECK_VERSION(2, 24, 0)

#endif // GTK_API_VERSION_2

#if !GLIB_CHECK_VERSION(2, 27, 1)
gboolean g_signal_accumulator_first_wins(GSignalInvocationHint *invocationHint, GValue *returnAccumulator, const GValue *handlerReturn, gpointer data)
{
    g_value_copy(handlerReturn, returnAccumulator);
    return FALSE;
}
#endif

#if !GTK_CHECK_VERSION(2, 22, 0)
cairo_surface_t *gdk_window_create_similar_surface(GdkWindow *window, cairo_content_t content, int width, int height)
{
    cairo_t *cairoContext = gdk_cairo_create(window);
    cairo_surface_t *cairoSurface = cairo_get_target(cairoContext);
    cairo_surface_t *newSurface = cairo_surface_create_similar(cairoSurface, content, width, height);
    cairo_destroy(cairoContext);
    return newSurface;
}
#endif // GTK_CHECK_VERSION(2, 22, 0)

#if !GTK_CHECK_VERSION(3, 3, 6)
#ifdef GDK_WINDOWING_X11
static int getScreenCurrentDesktop(GdkScreen *screen)
{
    Display *display = GDK_DISPLAY_XDISPLAY(gdk_screen_get_display(screen));
    Window rootWindow = XRootWindow(display, GDK_SCREEN_XNUMBER(screen));
    Atom currentDesktop = XInternAtom(display, "_NET_CURRENT_DESKTOP", True);

    Atom type;
    int format;
    unsigned long itemsCount, bytesAfter;
    unsigned char *returnedData = NULL;
    XGetWindowProperty(display, rootWindow, currentDesktop, 0, G_MAXLONG, False, XA_CARDINAL,
                       &type, &format, &itemsCount, &bytesAfter, &returnedData);

    int workspace = 0;
    if (type == XA_CARDINAL && format == 32 && itemsCount > 0)
        workspace = (int)returnedData[0];

    if (returnedData)
        XFree(returnedData);

    return workspace;
}

static void getScreenWorkArea(GdkScreen *screen, GdkRectangle *area)
{
    Display *display = GDK_DISPLAY_XDISPLAY(gdk_screen_get_display(screen));
    Atom workArea = XInternAtom(display, "_NET_WORKAREA", True);

    /* Defaults in case of error. */
    area->x = 0;
    area->y = 0;
    area->width = gdk_screen_get_width(screen);
    area->height = gdk_screen_get_height(screen);

    if (workArea == None)
        return;

    Window rootWindow = XRootWindow(display, GDK_SCREEN_XNUMBER(screen));
    Atom type;
    int format;
    unsigned long itemsCount, bytesAfter;
    unsigned char *returnedData = 0;
    int result = XGetWindowProperty(display, rootWindow, workArea, 0, 4 * 32 /* Max length */, False, AnyPropertyType,
                                    &type, &format, &itemsCount, &bytesAfter, &returnedData);
    if (result != Success || type == None || !format || bytesAfter || itemsCount % 4)
        return;

    int desktop = getScreenCurrentDesktop(screen);
    long *workAreas = (long *)returnedData;
    area->x = workAreas[desktop * 4];
    area->y = workAreas[desktop * 4 + 1];
    area->width = workAreas[desktop * 4 + 2];
    area->height = workAreas[desktop * 4 + 3];

    XFree(returnedData);
}
#endif // GDK_WINDOWING_X11

void gdk_screen_get_monitor_workarea(GdkScreen *screen, int monitor, GdkRectangle *area)
{
    gdk_screen_get_monitor_geometry(screen, monitor, area);

#ifdef GDK_WINDOWING_X11
    GdkRectangle workArea;
    getScreenWorkArea(screen, &workArea);
    gdk_rectangle_intersect(&workArea, area, area);
#endif
}
#endif // GTK_CHECK_VERSION(3, 3, 6)