/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* ***** BEGIN LICENSE BLOCK *****

 * Version: MPL 1.1/GPL 2.0/LGPL 2.1

 *

 * The contents of this file are subject to the Mozilla Public License Version

 * 1.1 (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

 * for the specific language governing rights and limitations under the

 * License.

 *

 * The Original Code is mozilla.org code.

 *

 * The Initial Developer of the Original Code is

 * Netscape Communications Corporation.

 * Portions created by the Initial Developer are Copyright (C) 2002

 * the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *  Brian Ryner <bryner@brianryner.com>  (Original Author)

 *  Pierre Chanial <p_ch@verizon.net>

 *  Michael Ventnor <m.ventnor@gmail.com>

 *  Alp Toker <alp@nuanti.com>

 *

 * Alternatively, the contents of this file may be used under the terms of

 * either the GNU General Public License Version 2 or later (the "GPL"), or

 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

 * in which case the provisions of the GPL or the LGPL are applicable instead

 * of those above. If you wish to allow use of your version of this file only

 * under the terms of either the GPL or the LGPL, and not to allow others to

 * use your version of this file under the terms of the MPL, indicate your

 * decision by deleting the provisions above and replace them with the notice

 * and other provisions required by the GPL or the LGPL. If you do not delete

 * the provisions above, a recipient may use your version of this file under

 * the terms of any one of the MPL, the GPL or the LGPL.

 *

 * ***** END LICENSE BLOCK ***** */

/*

 * This file contains painting functions for each of the gtk2 widgets.

 * Adapted from the gtkdrawing.c, and gtk+2.0 source.

 */

#include <gdk/gdkprivate.h>

#include "gtkdrawing.h"

#include "Assertions.h"

#include "GtkVersioning.h"

#include <math.h>

#include <string.h>

#define XTHICKNESS(style) (style->xthickness)

#define YTHICKNESS(style) (style->ythickness)

#define WINDOW_IS_MAPPED(window) ((window) && GDK_IS_WINDOW(window) && gdk_window_is_visible(window))

static GtkThemeParts *gParts = NULL;

static style_prop_t style_prop_func;

static gboolean have_arrow_scaling;

static gboolean is_initialized;

void

moz_gtk_use_theme_parts(GtkThemeParts* parts)

{

    gParts = parts;

}

/* Because we have such an unconventional way of drawing widgets, signal to the GTK theme engine

   that they are drawing for Mozilla instead of a conventional GTK app so they can do any specific

   things they may want to do. */

static void

moz_gtk_set_widget_name(GtkWidget* widget)

{

    gtk_widget_set_name(widget, "MozillaGtkWidget");

}

gint

moz_gtk_enable_style_props(style_prop_t styleGetProp)

{

    style_prop_func = styleGetProp;

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_window_widget()

{

    if (!gParts->protoWindow) {

        gParts->protoWindow = gtk_window_new(GTK_WINDOW_POPUP);

        if (gParts->colormap)

            gtk_widget_set_colormap(gParts->protoWindow, gParts->colormap);

        gtk_widget_realize(gParts->protoWindow);

        moz_gtk_set_widget_name(gParts->protoWindow);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

setup_widget_prototype(GtkWidget* widget)

{

    ensure_window_widget();

    if (!gParts->protoLayout) {

        gParts->protoLayout = gtk_fixed_new();

        gtk_container_add(GTK_CONTAINER(gParts->protoWindow), gParts->protoLayout);

    }

    gtk_container_add(GTK_CONTAINER(gParts->protoLayout), widget);

    gtk_widget_realize(widget);

    g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_button_widget()

{

    if (!gParts->buttonWidget) {

        gParts->buttonWidget = gtk_button_new_with_label("M");

        setup_widget_prototype(gParts->buttonWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_hpaned_widget()

{

    if (!gParts->hpanedWidget) {

        gParts->hpanedWidget = gtk_hpaned_new();

        setup_widget_prototype(gParts->hpanedWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_vpaned_widget()

{

    if (!gParts->vpanedWidget) {

        gParts->vpanedWidget = gtk_vpaned_new();

        setup_widget_prototype(gParts->vpanedWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_toggle_button_widget()

{

    if (!gParts->toggleButtonWidget) {

        gParts->toggleButtonWidget = gtk_toggle_button_new();

        setup_widget_prototype(gParts->toggleButtonWidget);

        /* toggle button must be set active to get the right style on hover. */

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gParts->toggleButtonWidget), TRUE);

  }

  return MOZ_GTK_SUCCESS;

}

static gint

ensure_button_arrow_widget()

{

    if (!gParts->buttonArrowWidget) {

        ensure_toggle_button_widget();

        gParts->buttonArrowWidget = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);

        gtk_container_add(GTK_CONTAINER(gParts->toggleButtonWidget), gParts->buttonArrowWidget);

        gtk_widget_realize(gParts->buttonArrowWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_checkbox_widget()

{

    if (!gParts->checkboxWidget) {

        gParts->checkboxWidget = gtk_check_button_new_with_label("M");

        setup_widget_prototype(gParts->checkboxWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_radiobutton_widget()

{

    if (!gParts->radiobuttonWidget) {

        gParts->radiobuttonWidget = gtk_radio_button_new_with_label(NULL, "M");

        setup_widget_prototype(gParts->radiobuttonWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_scrollbar_widget()

{

    if (!gParts->vertScrollbarWidget) {

        gParts->vertScrollbarWidget = gtk_vscrollbar_new(NULL);

        setup_widget_prototype(gParts->vertScrollbarWidget);

    }

    if (!gParts->horizScrollbarWidget) {

        gParts->horizScrollbarWidget = gtk_hscrollbar_new(NULL);

        setup_widget_prototype(gParts->horizScrollbarWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_spin_widget()

{

  if (!gParts->spinWidget) {

    gParts->spinWidget = gtk_spin_button_new(NULL, 1, 0);

    setup_widget_prototype(gParts->spinWidget);

  }

  return MOZ_GTK_SUCCESS;

}

static gint

ensure_scale_widget()

{

  if (!gParts->hScaleWidget) {

    gParts->hScaleWidget = gtk_hscale_new(NULL);

    setup_widget_prototype(gParts->hScaleWidget);

  }

  if (!gParts->vScaleWidget) {

    gParts->vScaleWidget = gtk_vscale_new(NULL);

    setup_widget_prototype(gParts->vScaleWidget);

  }

  return MOZ_GTK_SUCCESS;

}

static gint

ensure_entry_widget()

{

    if (!gParts->entryWidget) {

        gParts->entryWidget = gtk_entry_new();

        setup_widget_prototype(gParts->entryWidget);

    }

    return MOZ_GTK_SUCCESS;

}

/* We need to have pointers to the inner widgets (button, separator, arrow)

 * of the ComboBox to get the correct rendering from theme engines which

 * special cases their look. Since the inner layout can change, we ask GTK

 * to NULL our pointers when they are about to become invalid because the

 * corresponding widgets don't exist anymore. It's the role of

 * g_object_add_weak_pointer().

 * Note that if we don't find the inner widgets (which shouldn't happen), we

 * fallback to use generic "non-inner" widgets, and they don't need that kind

 * of weak pointer since they are explicit children of gParts->protoWindow and as

 * such GTK holds a strong reference to them. */

static void

moz_gtk_get_combo_box_inner_button(GtkWidget *widget, gpointer client_data)

{

    if (GTK_IS_TOGGLE_BUTTON(widget)) {

        gParts->comboBoxButtonWidget = widget;

        g_object_add_weak_pointer(G_OBJECT(widget),

                                  (gpointer) &gParts->comboBoxButtonWidget);

        gtk_widget_realize(widget);

        g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));

    }

}

static void

moz_gtk_get_combo_box_button_inner_widgets(GtkWidget *widget,

                                           gpointer client_data)

{

    if (GTK_IS_SEPARATOR(widget)) {

        gParts->comboBoxSeparatorWidget = widget;

        g_object_add_weak_pointer(G_OBJECT(widget),

                                  (gpointer) &gParts->comboBoxSeparatorWidget);

    } else if (GTK_IS_ARROW(widget)) {

        gParts->comboBoxArrowWidget = widget;

        g_object_add_weak_pointer(G_OBJECT(widget),

                                  (gpointer) &gParts->comboBoxArrowWidget);

    } else

        return;

    gtk_widget_realize(widget);

    g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));

}

static gint

ensure_combo_box_widgets()

{

    GtkWidget* buttonChild;

    if (gParts->comboBoxButtonWidget && gParts->comboBoxArrowWidget)

        return MOZ_GTK_SUCCESS;

    /* Create a ComboBox if needed */

    if (!gParts->comboBoxWidget) {

        gParts->comboBoxWidget = gtk_combo_box_new();

        setup_widget_prototype(gParts->comboBoxWidget);

    }

    /* Get its inner Button */

    gtk_container_forall(GTK_CONTAINER(gParts->comboBoxWidget),

                         moz_gtk_get_combo_box_inner_button,

                         NULL);

    if (gParts->comboBoxButtonWidget) {

        /* Get the widgets inside the Button */

        buttonChild = gtk_bin_get_child(GTK_BIN(gParts->comboBoxButtonWidget));

        if (GTK_IS_HBOX(buttonChild)) {

            /* appears-as-list = FALSE, cell-view = TRUE; the button

             * contains an hbox. This hbox is there because the ComboBox

             * needs to place a cell renderer, a separator, and an arrow in

             * the button when appears-as-list is FALSE. */

            gtk_container_forall(GTK_CONTAINER(buttonChild),

                                 moz_gtk_get_combo_box_button_inner_widgets,

                                 NULL);

        } else if(GTK_IS_ARROW(buttonChild)) {

            /* appears-as-list = TRUE, or cell-view = FALSE;

             * the button only contains an arrow */

            gParts->comboBoxArrowWidget = buttonChild;

            g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer)

                                      &gParts->comboBoxArrowWidget);

            gtk_widget_realize(gParts->comboBoxArrowWidget);

            g_object_set_data(G_OBJECT(gParts->comboBoxArrowWidget),

                              "transparent-bg-hint", GINT_TO_POINTER(TRUE));

        }

    } else {

        /* Shouldn't be reached with current internal gtk implementation; we

         * use a generic toggle button as last resort fallback to avoid

         * crashing. */

        ensure_toggle_button_widget();

        gParts->comboBoxButtonWidget = gParts->toggleButtonWidget;

    }

    if (!gParts->comboBoxArrowWidget) {

        /* Shouldn't be reached with current internal gtk implementation;

         * we gParts->buttonArrowWidget as last resort fallback to avoid

         * crashing. */

        ensure_button_arrow_widget();

        gParts->comboBoxArrowWidget = gParts->buttonArrowWidget;

    }

    /* We don't test the validity of gParts->comboBoxSeparatorWidget since there

     * is none when "appears-as-list" = TRUE or "cell-view" = FALSE; if it

     * is invalid we just won't paint it. */

    return MOZ_GTK_SUCCESS;

}

/* We need to have pointers to the inner widgets (entry, button, arrow) of

 * the ComboBoxEntry to get the correct rendering from theme engines which

 * special cases their look. Since the inner layout can change, we ask GTK

 * to NULL our pointers when they are about to become invalid because the

 * corresponding widgets don't exist anymore. It's the role of

 * g_object_add_weak_pointer().

 * Note that if we don't find the inner widgets (which shouldn't happen), we

 * fallback to use generic "non-inner" widgets, and they don't need that kind

 * of weak pointer since they are explicit children of gParts->protoWindow and as

 * such GTK holds a strong reference to them. */

static void

moz_gtk_get_combo_box_entry_inner_widgets(GtkWidget *widget,

                                          gpointer client_data)

{

    if (GTK_IS_TOGGLE_BUTTON(widget)) {

        gParts->comboBoxEntryButtonWidget = widget;

        g_object_add_weak_pointer(G_OBJECT(widget),

                                  (gpointer) &gParts->comboBoxEntryButtonWidget);

    } else if (GTK_IS_ENTRY(widget)) {

        gParts->comboBoxEntryTextareaWidget = widget;

        g_object_add_weak_pointer(G_OBJECT(widget),

                                  (gpointer) &gParts->comboBoxEntryTextareaWidget);

    } else

        return;

    gtk_widget_realize(widget);

    g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));

}

static void

moz_gtk_get_combo_box_entry_arrow(GtkWidget *widget, gpointer client_data)

{

    if (GTK_IS_ARROW(widget)) {

        gParts->comboBoxEntryArrowWidget = widget;

        g_object_add_weak_pointer(G_OBJECT(widget),

                                  (gpointer) &gParts->comboBoxEntryArrowWidget);

        gtk_widget_realize(widget);

        g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));

    }

}

static gint

ensure_combo_box_entry_widgets()

{

    GtkWidget* buttonChild;

    if (gParts->comboBoxEntryTextareaWidget &&

            gParts->comboBoxEntryButtonWidget &&

            gParts->comboBoxEntryArrowWidget)

        return MOZ_GTK_SUCCESS;

    /* Create a ComboBoxEntry if needed */

    if (!gParts->comboBoxEntryWidget) {

        gParts->comboBoxEntryWidget = gtk_combo_box_entry_new();

        setup_widget_prototype(gParts->comboBoxEntryWidget);

    }

    /* Get its inner Entry and Button */

    gtk_container_forall(GTK_CONTAINER(gParts->comboBoxEntryWidget),

                         moz_gtk_get_combo_box_entry_inner_widgets,

                         NULL);

    if (!gParts->comboBoxEntryTextareaWidget) {

        ensure_entry_widget();

        gParts->comboBoxEntryTextareaWidget = gParts->entryWidget;

    }

    if (gParts->comboBoxEntryButtonWidget) {

        /* Get the Arrow inside the Button */

        buttonChild = gtk_bin_get_child(GTK_BIN(gParts->comboBoxEntryButtonWidget));

        if (GTK_IS_HBOX(buttonChild)) {

            /* appears-as-list = FALSE, cell-view = TRUE; the button

             * contains an hbox. This hbox is there because ComboBoxEntry

             * inherits from ComboBox which needs to place a cell renderer,

             * a separator, and an arrow in the button when appears-as-list

             * is FALSE. Here the hbox should only contain an arrow, since

             * a ComboBoxEntry doesn't need all those widgets in the

             * button. */

            gtk_container_forall(GTK_CONTAINER(buttonChild),

                                 moz_gtk_get_combo_box_entry_arrow,

                                 NULL);

        } else if(GTK_IS_ARROW(buttonChild)) {

            /* appears-as-list = TRUE, or cell-view = FALSE;

             * the button only contains an arrow */

            gParts->comboBoxEntryArrowWidget = buttonChild;

            g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer)

                                      &gParts->comboBoxEntryArrowWidget);

            gtk_widget_realize(gParts->comboBoxEntryArrowWidget);

            g_object_set_data(G_OBJECT(gParts->comboBoxEntryArrowWidget),

                              "transparent-bg-hint", GINT_TO_POINTER(TRUE));

        }

    } else {

        /* Shouldn't be reached with current internal gtk implementation;

         * we use a generic toggle button as last resort fallback to avoid

         * crashing. */

        ensure_toggle_button_widget();

        gParts->comboBoxEntryButtonWidget = gParts->toggleButtonWidget;

    }

    if (!gParts->comboBoxEntryArrowWidget) {

        /* Shouldn't be reached with current internal gtk implementation;

         * we gParts->buttonArrowWidget as last resort fallback to avoid

         * crashing. */

        ensure_button_arrow_widget();

        gParts->comboBoxEntryArrowWidget = gParts->buttonArrowWidget;

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_handlebox_widget()

{

    if (!gParts->handleBoxWidget) {

        gParts->handleBoxWidget = gtk_handle_box_new();

        setup_widget_prototype(gParts->handleBoxWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_toolbar_widget()

{

    if (!gParts->toolbarWidget) {

        ensure_handlebox_widget();

        gParts->toolbarWidget = gtk_toolbar_new();

        gtk_container_add(GTK_CONTAINER(gParts->handleBoxWidget), gParts->toolbarWidget);

        gtk_widget_realize(gParts->toolbarWidget);

        g_object_set_data(G_OBJECT(gParts->toolbarWidget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_toolbar_separator_widget()

{

    if (!gParts->toolbarSeparatorWidget) {

        ensure_toolbar_widget();

        gParts->toolbarSeparatorWidget = GTK_WIDGET(gtk_separator_tool_item_new());

        setup_widget_prototype(gParts->toolbarSeparatorWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_tooltip_widget()

{

    if (!gParts->tooltipWidget) {

        gParts->tooltipWidget = gtk_window_new(GTK_WINDOW_POPUP);

        gtk_widget_realize(gParts->tooltipWidget);

        moz_gtk_set_widget_name(gParts->tooltipWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_tab_widget()

{

    if (!gParts->tabWidget) {

        gParts->tabWidget = gtk_notebook_new();

        setup_widget_prototype(gParts->tabWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_progress_widget()

{

    if (!gParts->progresWidget) {

        gParts->progresWidget = gtk_progress_bar_new();

        setup_widget_prototype(gParts->progresWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint

ensure_statusbar_widget()

{

    if (!gParts->statusbarWidget) {

      gParts->statusbarWidget = gtk_statusbar_new();

      setup_widget_prototype(gParts->statusbarWidget);

    }

    return MOZ_GTK_SUCCESS;

}

static gint