sushivision/slice.c

   1 /*
   2  *
   3  *     sushivision copyright (C) 2006-2007 Monty <monty@xiph.org>
   4  *
   5  *  sushivision is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  sushivision is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with sushivision; see the file COPYING.  If not, write to the
  17  *  Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *
  20  */
  21
  22 #include <stdlib.h>
  23 #include <math.h>
  24 #include <string.h>
  25 #include <gdk/gdkkeysyms.h>
  26 #include "internal.h"
  27
  28 static void _sv_slice_draw_and_expose(GtkWidget *widget){
  29   _sv_slice_t *s=SLICE(widget);
  30
  31   _sv_slider_draw(s->slider);
  32   _sv_slider_expose(s->slider);
  33 }
  34
  35 static gboolean _sv_slice_expose(GtkWidget *widget, GdkEventExpose *event ){
  36   _sv_slice_t *s=SLICE(widget);
  37   _sv_slider_expose_slice(s->slider,s->slicenum);
  38   return FALSE;
  39 }
  40
  41 static void _sv_slice_size_request (GtkWidget *widget,GtkRequisition *requisition){
  42   _sv_slice_t *s=SLICE(widget);
  43
  44   _sv_slider_size_request_slice(s->slider,requisition);
  45 }
  46
  47 static gint _sv_slice_motion(GtkWidget        *widget,
  48                          GdkEventMotion   *event){
  49   _sv_slice_t *s=SLICE(widget);
  50   _sv_slider_motion(s->slider,s->slicenum,event->x,event->y);
  51
  52   return TRUE;
  53 }
  54
  55 static gint _sv_slice_enter(GtkWidget        *widget,
  56                         GdkEventCrossing *event){
  57   _sv_slice_t *s=SLICE(widget);
  58   _sv_slider_lightme(s->slider,s->slicenum,event->x,event->y);
  59   _sv_slice_draw_and_expose(widget);
  60   return TRUE;
  61 }
  62
  63 static gint _sv_slice_leave(GtkWidget        *widget,
  64                         GdkEventCrossing *event){
  65   _sv_slice_t *s=SLICE(widget);
  66
  67   _sv_slider_unlight(s->slider);
  68   _sv_slider_draw(s->slider);
  69   _sv_slider_expose(s->slider);
  70
  71   return TRUE;
  72 }
  73
  74 static gboolean _sv_slice_button_press(GtkWidget        *widget,
  75                                    GdkEventButton   *event){
  76   _sv_slice_t *s=SLICE(widget);
  77   if(event->button == 3)return FALSE;
  78
  79   if(event->button == 1)
  80     _sv_slider_button_press(s->slider,s->slicenum,event->x,event->y);
  81
  82   return TRUE;
  83 }
  84
  85 static gboolean _sv_slice_button_release(GtkWidget        *widget,
  86                                      GdkEventButton   *event){
  87   _sv_slice_t *s=SLICE(widget);
  88   if(event->button == 3)return FALSE;
  89
  90   if(event->button == 1)
  91     _sv_slider_button_release(s->slider,s->slicenum,event->x,event->y);
  92
  93   return TRUE;
  94 }
  95
  96 static gboolean _sv_slice_unfocus(GtkWidget        *widget,
  97                               GdkEventFocus       *event){
  98   _sv_slice_t *s=SLICE(widget);
  99   if(s->thumb_focus){
 100     s->thumb_focus=0;
 101     _sv_slice_draw_and_expose(widget);
 102   }
 103   return TRUE;
 104 }
 105
 106 static gboolean _sv_slice_refocus(GtkWidget        *widget,
 107                               GdkEventFocus       *event){
 108   _sv_slice_t *s=SLICE(widget);
 109   if(!s->thumb_focus){
 110     s->thumb_focus=1;
 111     _sv_slice_draw_and_expose(widget);
 112   }
 113   return TRUE;
 114 }
 115
 116 static gboolean _sv_slice_key_press(GtkWidget *widget,GdkEventKey *event){
 117   _sv_slice_t *s=SLICE(widget);
 118
 119   return _sv_slider_key_press(s->slider,event,s->slicenum);
 120 }
 121
 122 static void _sv_slice_state_changed(GtkWidget *w,GtkStateType ps){
 123   _sv_slice_draw_and_expose(w);
 124 }
 125
 126 static void _sv_slice_realize (GtkWidget *widget){
 127   GdkWindowAttr attributes;
 128   gint      attributes_mask;
 129
 130   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 131   GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
 132
 133   attributes.x = widget->allocation.x;
 134   attributes.y = widget->allocation.y;
 135   attributes.width = widget->allocation.width;
 136   attributes.height = widget->allocation.height;
 137   attributes.wclass = GDK_INPUT_OUTPUT;
 138   attributes.window_type = GDK_WINDOW_CHILD;
 139   attributes.event_mask =
 140     gtk_widget_get_events (widget) |
 141     GDK_EXPOSURE_MASK|
 142     GDK_POINTER_MOTION_MASK|
 143     GDK_BUTTON_PRESS_MASK  |
 144     GDK_BUTTON_RELEASE_MASK|
 145     GDK_KEY_PRESS_MASK |
 146     GDK_KEY_RELEASE_MASK |
 147     GDK_STRUCTURE_MASK |
 148     GDK_ENTER_NOTIFY_MASK |
 149     GDK_FOCUS_CHANGE_MASK |
 150     GDK_LEAVE_NOTIFY_MASK;
 151
 152   attributes.visual = gtk_widget_get_visual (widget);
 153   attributes.colormap = gtk_widget_get_colormap (widget);
 154   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 155   widget->window = gdk_window_new (widget->parent->window,
 156                                    &attributes, attributes_mask);
 157   gtk_style_attach (widget->style, widget->window);
 158   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 159   gdk_window_set_user_data (widget->window, widget);
 160   gtk_widget_set_double_buffered (widget, FALSE);
 161 }
 162
 163 static void _sv_slice_size_allocate (GtkWidget     *widget,
 164                                  GtkAllocation *allocation){
 165   //_sv_slice_t *s = SLICE (widget);
 166   if (GTK_WIDGET_REALIZED (widget)){
 167
 168     gdk_window_move_resize (widget->window, allocation->x, allocation->y,
 169                             allocation->width, allocation->height);
 170
 171   }
 172
 173   widget->allocation = *allocation;
 174
 175 }
 176
 177 static GtkWidgetClass *parent_class = NULL;
 178
 179 static void _sv_slice_class_init (_sv_slice_class_t *class){
 180   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 181   //GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
 182
 183   parent_class = g_type_class_peek_parent (class);
 184
 185   //object_class->destroy = slice_destroy;
 186   widget_class->realize = _sv_slice_realize;
 187   widget_class->expose_event = _sv_slice_expose;
 188   widget_class->size_request = _sv_slice_size_request;
 189   widget_class->size_allocate = _sv_slice_size_allocate;
 190   widget_class->key_press_event = _sv_slice_key_press;
 191   widget_class->button_press_event = _sv_slice_button_press;
 192   widget_class->button_release_event = _sv_slice_button_release;
 193   widget_class->enter_notify_event = _sv_slice_enter;
 194   widget_class->leave_notify_event = _sv_slice_leave;
 195   widget_class->motion_notify_event = _sv_slice_motion;
 196   widget_class->focus_out_event = _sv_slice_unfocus;
 197   widget_class->focus_in_event = _sv_slice_refocus;
 198   widget_class->state_changed = _sv_slice_state_changed;
 199 }
 200
 201 static void _sv_slice_init (_sv_slice_t *s){
 202 }
 203
 204 GType _sv_slice_get_type (void){
 205   static GType m_type = 0;
 206   if (!m_type){
 207     static const GTypeInfo m_info={
 208       sizeof (_sv_slice_class_t),
 209       NULL, /* base_init */
 210       NULL, /* base_finalize */
 211       (GClassInitFunc) _sv_slice_class_init,
 212       NULL, /* class_finalize */
 213       NULL, /* class_data */
 214       sizeof (_sv_slice_t),
 215       0,
 216       (GInstanceInitFunc) _sv_slice_init,
 217       0
 218     };
 219
 220     m_type = g_type_register_static (GTK_TYPE_WIDGET, "Slider", &m_info, 0);
 221   }
 222
 223   return m_type;
 224 }
 225
 226 GtkWidget* _sv_slice_new (void (*callback)(void *,int), void *data){
 227   GtkWidget *ret= GTK_WIDGET (g_object_new (_sv_slice_get_type (), NULL));
 228   _sv_slice_t *s=SLICE(ret);
 229   s->callback = callback;
 230   s->callback_data = data;
 231   s->thumb_active = 1;
 232   return ret;
 233 }
 234
 235 void _sv_slice_set_active(_sv_slice_t *s, int activep){
 236   s->thumb_active = activep;
 237   if(s->active_callback)
 238     s->active_callback(s->active_callback_data, activep);
 239   _sv_slice_draw_and_expose(GTK_WIDGET(s));
 240 }
 241
 242 void _sv_slice_thumb_set(_sv_slice_t *s,double v){
 243   GtkWidget *w=GTK_WIDGET(s);
 244
 245   if(s->thumb_val != v){
 246     s->thumb_val=v;
 247     _sv_slider_vals_bound(s->slider,s->slicenum);
 248
 249     if(s->callback)s->callback(s->callback_data,1);
 250     _sv_slice_draw_and_expose(w);
 251   }
 252 }
 253
 254 void _sv_slice_set_active_callback(_sv_slice_t *s, void (*callback)(void *,int), void *data){
 255   s->active_callback = callback;
 256   s->active_callback_data = data;
 257 }