libview/ev-loading-window.c

   1 /* ev-loading-window.c
   2  *  this file is part of evince, a gnome document viewer
   3  *
   4  * Copyright (C) 2010 Carlos Garcia Campos <carlosgc@gnome.org>
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24 #include <glib/gi18n.h>
  25 #include "ev-loading-window.h"
  26
  27 enum {
  28         PROP_0,
  29         PROP_PARENT
  30 };
  31
  32 struct _EvLoadingWindow {
  33         GtkWindow  base_instance;
  34
  35         GtkWindow *parent;
  36
  37         gint       x;
  38         gint       y;
  39         gint       width;
  40         gint       height;
  41 };
  42
  43 struct _EvLoadingWindowClass {
  44         GtkWindowClass base_class;
  45 };
  46
  47 G_DEFINE_TYPE (EvLoadingWindow, ev_loading_window, GTK_TYPE_WINDOW)
  48
  49 static void
  50 ev_loading_window_set_property (GObject      *object,
  51                                 guint         prop_id,
  52                                 const GValue *value,
  53                                 GParamSpec   *pspec)
  54 {
  55         EvLoadingWindow *window = EV_LOADING_WINDOW (object);
  56
  57         switch (prop_id) {
  58         case PROP_PARENT:
  59                 window->parent = g_value_get_object (value);
  60                 break;
  61         default:
  62                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  63         }
  64 }
  65
  66 static void
  67 ev_loading_window_init (EvLoadingWindow *window)
  68 {
  69         GtkWindow   *gtk_window = GTK_WINDOW (window);
  70         GtkWidget   *widget = GTK_WIDGET (window);
  71         GtkWidget   *hbox;
  72         GtkWidget   *spinner;
  73         GtkWidget   *label;
  74         GtkStyle    *style;
  75         GdkColor    fg, bg;
  76         const gchar *loading_text = _("Loading…");
  77         const gchar *fg_color_name = "info_fg_color";
  78         const gchar *bg_color_name = "info_bg_color";
  79
  80         hbox = gtk_hbox_new (FALSE, 12);
  81
  82         spinner = gtk_spinner_new ();
  83         gtk_spinner_start (GTK_SPINNER (spinner));
  84         gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
  85         gtk_widget_show (spinner);
  86
  87         label = gtk_label_new (loading_text);
  88         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  89         gtk_widget_show (label);
  90
  91         gtk_container_add (GTK_CONTAINER (window), hbox);
  92         gtk_widget_show (hbox);
  93
  94         gtk_widget_set_app_paintable (widget, TRUE);
  95
  96         gtk_container_set_border_width (GTK_CONTAINER (window), 10);
  97
  98         gtk_window_set_type_hint (gtk_window, GDK_WINDOW_TYPE_HINT_NOTIFICATION);
  99         gtk_window_set_accept_focus (gtk_window, FALSE);
 100         gtk_window_set_decorated (gtk_window, FALSE);
 101         gtk_window_set_resizable (gtk_window, FALSE);
 102
 103         style = gtk_widget_get_style (widget);
 104         if (!gtk_style_lookup_color (style, fg_color_name, &fg) ||
 105             !gtk_style_lookup_color (style, bg_color_name, &bg)) {
 106                 fg.pixel = 0;
 107                 fg.red = 0xb800;
 108                 fg.green = 0xad00;
 109                 fg.blue = 0x9d00;
 110
 111                 bg.pixel = 0;
 112                 bg.red = 0xff00;
 113                 bg.green = 0xff00;
 114                 bg.blue = 0xbf00;
 115         }
 116
 117         if (!gdk_color_equal (&bg, &style->bg[GTK_STATE_NORMAL]))
 118                 gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &bg);
 119         if (!gdk_color_equal (&fg, &style->fg[GTK_STATE_NORMAL]))
 120                 gtk_widget_modify_fg (widget, GTK_STATE_NORMAL, &fg);
 121 }
 122
 123 static GObject *
 124 ev_loading_window_constructor (GType                  type,
 125                                guint                  n_construct_properties,
 126                                GObjectConstructParam *construct_params)
 127 {
 128         GObject         *object;
 129         EvLoadingWindow *window;
 130         GtkWindow       *gtk_window;
 131
 132         object = G_OBJECT_CLASS (ev_loading_window_parent_class)->constructor (type,
 133                                                                                n_construct_properties,
 134                                                                                construct_params);
 135         window = EV_LOADING_WINDOW (object);
 136         gtk_window = GTK_WINDOW (window);
 137
 138         gtk_window_set_transient_for (gtk_window, window->parent);
 139         gtk_window_set_destroy_with_parent (gtk_window, TRUE);
 140
 141         return object;
 142 }
 143
 144 static void
 145 _cairo_rounded_rectangle (cairo_t *cr,
 146                           gint     width,
 147                           gint     height,
 148                           gdouble  radius)
 149 {
 150         cairo_move_to (cr, radius, 0);
 151         cairo_line_to (cr, width - radius, 0);
 152         cairo_curve_to (cr,
 153                         width, 0,
 154                         width, 0,
 155                         width,
 156                         radius);
 157         cairo_line_to (cr, width, height - radius);
 158         cairo_curve_to (cr,
 159                         width,height,
 160                         width, height,
 161                         width - radius,
 162                         height);
 163         cairo_line_to (cr, radius, height);
 164         cairo_curve_to (cr,
 165                         0, height,
 166                         0, height,
 167                         0, height - radius);
 168         cairo_line_to (cr, 0, radius);
 169         cairo_curve_to (cr,
 170                         0, 0,
 171                         0, 0,
 172                         radius, 0);
 173 }
 174
 175 static void
 176 ev_loading_window_size_allocate (GtkWidget      *widget,
 177                                  GtkAllocation  *allocation)
 178 {
 179         EvLoadingWindow *window = EV_LOADING_WINDOW (widget);
 180 #if GTK_CHECK_VERSION (2, 90, 8)
 181         cairo_surface_t *surface;
 182         cairo_region_t *shape;
 183 #endif
 184         cairo_t         *cr;
 185         double           r;
 186
 187         GTK_WIDGET_CLASS (ev_loading_window_parent_class)->size_allocate (widget, allocation);
 188
 189         if (allocation->width == window->width && allocation->height == window->height)
 190                 return;
 191
 192         window->width = allocation->width;
 193         window->height = allocation->height;
 194
 195 #if GTK_CHECK_VERSION (2, 90, 8)
 196         surface = cairo_image_surface_create (CAIRO_FORMAT_A8,
 197                                               window->width,
 198                                               window->height);
 199         cr = cairo_create (surface);
 200 #else
 201         mask = gdk_pixmap_new (NULL, window->width, window->height, 1);
 202         cr = gdk_cairo_create (GDK_DRAWABLE (mask));
 203 #endif
 204
 205         cairo_save (cr);
 206         cairo_rectangle (cr, 0, 0, window->width, window->height);
 207         cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
 208         cairo_fill (cr);
 209         cairo_restore (cr);
 210
 211         cairo_set_source_rgb (cr, 1., 1., 1.);
 212         r = MIN (window->width, window->height) / 2.;
 213         _cairo_rounded_rectangle (cr, window->width, window->height, r);
 214         cairo_fill (cr);
 215
 216         cairo_destroy (cr);
 217
 218 #if GTK_CHECK_VERSION (2, 90, 8)
 219         shape = gdk_cairo_region_create_from_surface (surface);
 220         cairo_surface_destroy (surface);
 221
 222         gtk_widget_shape_combine_region (widget, shape);
 223         cairo_region_destroy (shape);
 224 #else
 225         gtk_widget_shape_combine_mask (widget, mask, 0, 0);
 226         g_object_unref (mask);
 227 #endif
 228 }
 229
 230 static void
 231 ev_loading_window_hide (GtkWidget *widget)
 232 {
 233         EvLoadingWindow *window = EV_LOADING_WINDOW (widget);
 234
 235         window->x = window->y = 0;
 236
 237         GTK_WIDGET_CLASS (ev_loading_window_parent_class)->hide (widget);
 238 }
 239
 240 static void
 241 ev_loading_window_class_init (EvLoadingWindowClass *klass)
 242 {
 243         GObjectClass   *g_object_class = G_OBJECT_CLASS (klass);
 244         GtkWidgetClass *gtk_widget_class = GTK_WIDGET_CLASS (klass);
 245
 246         g_object_class->constructor = ev_loading_window_constructor;
 247         g_object_class->set_property = ev_loading_window_set_property;
 248
 249         gtk_widget_class->size_allocate = ev_loading_window_size_allocate;
 250         gtk_widget_class->hide = ev_loading_window_hide;
 251
 252         g_object_class_install_property (g_object_class,
 253                                          PROP_PARENT,
 254                                          g_param_spec_object ("parent",
 255                                                               "Parent",
 256                                                               "The parent window",
 257                                                               GTK_TYPE_WINDOW,
 258                                                               G_PARAM_WRITABLE |
 259                                                               G_PARAM_CONSTRUCT_ONLY));
 260 }
 261
 262 /* Public methods */
 263 GtkWidget *
 264 ev_loading_window_new (GtkWindow *parent)
 265 {
 266         GtkWidget *window;
 267
 268         g_return_val_if_fail (GTK_IS_WINDOW (parent), NULL);
 269
 270         window = g_object_new (EV_TYPE_LOADING_WINDOW,
 271                                "parent", parent,
 272                                NULL);
 273         return window;
 274 }
 275
 276 void
 277 ev_loading_window_get_size (EvLoadingWindow *window,
 278                             gint            *width,
 279                             gint            *height)
 280 {
 281         if (width) *width = window->width;
 282         if (height) *height = window->height;
 283 }
 284
 285 void
 286 ev_loading_window_move (EvLoadingWindow *window,
 287                         gint             x,
 288                         gint             y)
 289 {
 290         if (x == window->x && y == window->y)
 291                 return;
 292
 293         window->x = x;
 294         window->y = y;
 295         gtk_window_move (GTK_WINDOW (window), x, y);
 296 }