libdocument/ev-transition-effect.c

   1 /* ev-transition-effect.c
   2  *  this file is part of evince, a gnome document viewer
   3  *
   4  * Copyright (C) 2007 Carlos Garnacho <carlos@imendio.com>
   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., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "ev-transition-effect.h"
  22
  23 #define EV_TRANSITION_EFFECT_GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EV_TYPE_TRANSITION_EFFECT, EvTransitionEffectPrivate))
  24
  25 typedef struct EvTransitionEffectPrivate EvTransitionEffectPrivate;
  26
  27 struct EvTransitionEffectPrivate {
  28         EvTransitionEffectType type;
  29         EvTransitionEffectAlignment alignment;
  30         EvTransitionEffectDirection direction;
  31
  32         gint duration;
  33         gint angle;
  34         gdouble scale;
  35
  36         guint rectangular : 1;
  37 };
  38
  39 enum {
  40         PROP_0,
  41         PROP_TYPE,
  42         PROP_ALIGNMENT,
  43         PROP_DIRECTION,
  44         PROP_DURATION,
  45         PROP_ANGLE,
  46         PROP_SCALE,
  47         PROP_RECTANGULAR
  48 };
  49
  50 G_DEFINE_TYPE (EvTransitionEffect, ev_transition_effect, G_TYPE_OBJECT)
  51
  52
  53 GType
  54 ev_transition_effect_type_get_type (void)
  55 {
  56         static GType type = 0;
  57
  58         if (G_UNLIKELY (type == 0)) {
  59                 static const GEnumValue values[] = {
  60                         { EV_TRANSITION_EFFECT_REPLACE, "EV_TRANSITION_EFFECT_REPLACE", "replace" },
  61                         { EV_TRANSITION_EFFECT_SPLIT, "EV_TRANSITION_EFFECT_SPLIT", "split" },
  62                         { EV_TRANSITION_EFFECT_BLINDS, "EV_TRANSITION_EFFECT_BLINDS", "blinds" },
  63                         { EV_TRANSITION_EFFECT_BOX, "EV_TRANSITION_EFFECT_BOX", "box" },
  64                         { EV_TRANSITION_EFFECT_WIPE, "EV_TRANSITION_EFFECT_WIPE", "wipe" },
  65                         { EV_TRANSITION_EFFECT_DISSOLVE, "EV_TRANSITION_EFFECT_DISSOLVE", "dissolve" },
  66                         { EV_TRANSITION_EFFECT_GLITTER, "EV_TRANSITION_EFFECT_GLITTER", "glitter" },
  67                         { EV_TRANSITION_EFFECT_FLY, "EV_TRANSITION_EFFECT_FLY", "fly" },
  68                         { EV_TRANSITION_EFFECT_PUSH, "EV_TRANSITION_EFFECT_PUSH", "push" },
  69                         { EV_TRANSITION_EFFECT_COVER, "EV_TRANSITION_EFFECT_COVER", "cover" },
  70                         { EV_TRANSITION_EFFECT_UNCOVER, "EV_TRANSITION_EFFECT_UNCOVER", "uncover" },
  71                         { EV_TRANSITION_EFFECT_FADE, "EV_TRANSITION_EFFECT_FADE", "fade" },
  72                         { 0, NULL, NULL }
  73                 };
  74
  75                 type = g_enum_register_static ("EvTransitionEffectType", values);
  76         }
  77
  78         return type;
  79 }
  80
  81 GType
  82 ev_transition_effect_alignment_get_type (void)
  83 {
  84         static GType type = 0;
  85
  86         if (G_UNLIKELY (type == 0)) {
  87                 static const GEnumValue values[] = {
  88                         { EV_TRANSITION_ALIGNMENT_HORIZONTAL, "EV_TRANSITION_ALIGNMENT_HORIZONTAL", "horizontal" },
  89                         { EV_TRANSITION_ALIGNMENT_VERTICAL, "EV_TRANSITION_ALIGNMENT_VERTICAL", "vertical" },
  90                         { 0, NULL, NULL }
  91                 };
  92
  93                 type = g_enum_register_static ("EvTransitionEffectAlignment", values);
  94         }
  95
  96         return type;
  97 }
  98
  99 GType
 100 ev_transition_effect_direction_get_type (void)
 101 {
 102         static GType type = 0;
 103
 104         if (G_UNLIKELY (type == 0)) {
 105                 static const GEnumValue values[] = {
 106                         { EV_TRANSITION_DIRECTION_INWARD, "EV_TRANSITION_DIRECTION_INWARD", "inward" },
 107                         { EV_TRANSITION_DIRECTION_OUTWARD, "EV_TRANSITION_DIRECTION_OUTWARD", "outward" },
 108                         { 0, NULL, NULL }
 109                 };
 110
 111                 type = g_enum_register_static ("EvTransitionEffectDirection", values);
 112         }
 113
 114         return type;
 115 }
 116
 117 static void
 118 ev_transition_effect_set_property (GObject      *object,
 119                                    guint         prop_id,
 120                                    const GValue *value,
 121                                    GParamSpec   *pspec)
 122 {
 123         EvTransitionEffectPrivate *priv;
 124
 125         priv = EV_TRANSITION_EFFECT_GET_PRIV (object);
 126
 127         switch (prop_id) {
 128         case PROP_TYPE:
 129                 priv->type = g_value_get_enum (value);
 130                 break;
 131         case PROP_ALIGNMENT:
 132                 priv->alignment = g_value_get_enum (value);
 133                 break;
 134         case PROP_DIRECTION:
 135                 priv->direction = g_value_get_enum (value);
 136                 break;
 137         case PROP_DURATION:
 138                 priv->duration = g_value_get_int (value);
 139                 break;
 140         case PROP_ANGLE:
 141                 priv->angle = g_value_get_int (value);
 142                 break;
 143         case PROP_SCALE:
 144                 priv->scale = g_value_get_double (value);
 145                 break;
 146         case PROP_RECTANGULAR:
 147                 priv->rectangular = g_value_get_boolean (value);
 148                 break;
 149         default:
 150                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 151                 break;
 152         }
 153 }
 154
 155 static void
 156 ev_transition_effect_get_property (GObject    *object,
 157                                    guint       prop_id,
 158                                    GValue     *value,
 159                                    GParamSpec *pspec)
 160 {
 161         EvTransitionEffectPrivate *priv;
 162
 163         priv = EV_TRANSITION_EFFECT_GET_PRIV (object);
 164
 165         switch (prop_id) {
 166         case PROP_TYPE:
 167                 g_value_set_enum (value, priv->type);
 168                 break;
 169         case PROP_ALIGNMENT:
 170                 g_value_set_enum (value, priv->alignment);
 171                 break;
 172         case PROP_DIRECTION:
 173                 g_value_set_enum (value, priv->direction);
 174                 break;
 175         case PROP_DURATION:
 176                 g_value_set_int (value, priv->duration);
 177                 break;
 178         case PROP_ANGLE:
 179                 g_value_set_int (value, priv->angle);
 180                 break;
 181         case PROP_SCALE:
 182                 g_value_set_double (value, priv->scale);
 183                 break;
 184         case PROP_RECTANGULAR:
 185                 g_value_set_enum (value, priv->rectangular);
 186                 break;
 187         default:
 188                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 189                 break;
 190         }
 191 }
 192
 193 static void
 194 ev_transition_effect_init (EvTransitionEffect *effect)
 195 {
 196         EvTransitionEffectPrivate *priv;
 197
 198         priv = EV_TRANSITION_EFFECT_GET_PRIV (effect);
 199
 200         priv->scale = 1.;
 201 }
 202
 203 static void
 204 ev_transition_effect_class_init (EvTransitionEffectClass *klass)
 205 {
 206         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 207
 208         object_class->set_property = ev_transition_effect_set_property;
 209         object_class->get_property = ev_transition_effect_get_property;
 210
 211         g_object_class_install_property (object_class,
 212                                          PROP_TYPE,
 213                                          g_param_spec_enum ("type",
 214                                                             "Effect type",
 215                                                             "Page transition effect type",
 216                                                             EV_TYPE_TRANSITION_EFFECT_TYPE,
 217                                                             EV_TRANSITION_EFFECT_REPLACE,
 218                                                             G_PARAM_READWRITE));
 219         g_object_class_install_property (object_class,
 220                                          PROP_ALIGNMENT,
 221                                          g_param_spec_enum ("alignment",
 222                                                             "Effect alignment",
 223                                                             "Alignment for the effect",
 224                                                             EV_TYPE_TRANSITION_EFFECT_ALIGNMENT,
 225                                                             EV_TRANSITION_ALIGNMENT_HORIZONTAL,
 226                                                             G_PARAM_READWRITE));
 227         g_object_class_install_property (object_class,
 228                                          PROP_DIRECTION,
 229                                          g_param_spec_enum ("direction",
 230                                                             "Effect direction",
 231                                                             "Direction for the effect",
 232                                                             EV_TYPE_TRANSITION_EFFECT_DIRECTION,
 233                                                             EV_TRANSITION_DIRECTION_INWARD,
 234                                                             G_PARAM_READWRITE));
 235         g_object_class_install_property (object_class,
 236                                          PROP_DURATION,
 237                                          g_param_spec_int ("duration",
 238                                                            "Effect duration",
 239                                                            "Effect duration in seconds",
 240                                                            0, G_MAXINT, 0,
 241                                                            G_PARAM_READWRITE));
 242         g_object_class_install_property (object_class,
 243                                          PROP_ANGLE,
 244                                          g_param_spec_int ("angle",
 245                                                            "Effect angle",
 246                                                            "Effect angle in degrees, counted "
 247                                                            "counterclockwise from left to right",
 248                                                            0, 360, 0,
 249                                                            G_PARAM_READWRITE));
 250         g_object_class_install_property (object_class,
 251                                          PROP_SCALE,
 252                                          g_param_spec_double ("scale",
 253                                                               "Effect scale",
 254                                                               "Scale at which the effect is applied",
 255                                                               0., 1., 1.,
 256                                                               G_PARAM_READWRITE));
 257         g_object_class_install_property (object_class,
 258                                          PROP_RECTANGULAR,
 259                                          g_param_spec_boolean ("rectangular",
 260                                                                "Rectangular area",
 261                                                                "Whether the covered area is rectangular",
 262                                                                FALSE,
 263                                                                G_PARAM_READWRITE));
 264
 265         g_type_class_add_private (klass, sizeof (EvTransitionEffectPrivate));
 266 }
 267
 268 EvTransitionEffect *
 269 ev_transition_effect_new (EvTransitionEffectType  type,
 270                           const gchar            *first_property_name,
 271                           ...)
 272 {
 273         GObject *object;
 274         va_list  args;
 275
 276         object = g_object_new (EV_TYPE_TRANSITION_EFFECT,
 277                                "type", type,
 278                                NULL);
 279
 280         va_start (args, first_property_name);
 281         g_object_set_valist (object, first_property_name, args);
 282         va_end (args);
 283
 284         return EV_TRANSITION_EFFECT (object);
 285 }