← Back to branch summary

~ubuntu-branches/ubuntu/hoary/gimp/hoary

« back to all changes in this revision

Viewing changes to plug-ins/rcm/rcm_callback.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-04-04 14:51:23 UTC
  • Revision ID: james.westby@ubuntu.com-20050404145123-9py049eeelfymur8
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/rcm/rcm_callback.c
 
1
/*
 
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 
3
 *
 
4
 * This is a plug-in for the GIMP.
 
5
 *
 
6
 * Colormap-Rotation plug-in. Exchanges two color ranges.
 
7
 *
 
8
 * Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
 
9
 *                    Based on code from Pavel Grinfeld (pavel@ml.com)
 
10
 *
 
11
 *
 
12
 * This program is free software; you can redistribute it and/or modify
 
13
 * it under the terms of the GNU General Public License as published by
 
14
 * the Free Software Foundation; either version 2 of the License, or
 
15
 * (at your option) any later version.
 
16
 *
 
17
 * This program is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 * GNU General Public License for more details.
 
21
 *
 
22
 * You should have received a copy of the GNU General Public License
 
23
 * along with this program; if not, write to the Free Software
 
24
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
25
 */
 
26
 
 
27
/*---------------------------------------------------------------------------
 
28
 * Change log:
 
29
 *
 
30
 * Version 2.0, 04 April 1999.
 
31
 *  Nearly complete rewrite, made plug-in stable.
 
32
 *  (Works with GIMP 1.1 and GTK+ 1.2)
 
33
 *
 
34
 * Version 1.0, 27 March 1997.
 
35
 *  Initial (unstable) release by Pavel Grinfeld
 
36
 *
 
37
 *---------------------------------------------------------------------------*/
 
38
 
 
39
#include "config.h"
 
40
 
 
41
#include <stdio.h>
 
42
#include <stdlib.h>
 
43
 
 
44
#include <gtk/gtk.h>
 
45
 
 
46
#include "libgimpmath/gimpmath.h"
 
47
#include "libgimpwidgets/gimpwidgets.h"
 
48
#include "libgimp/gimp.h"
 
49
 
 
50
#include "rcm.h"
 
51
#include "rcm_misc.h"
 
52
#include "rcm_gdk.h"
 
53
#include "rcm_dialog.h"
 
54
#include "rcm_callback.h"
 
55
#include "rcm_stock.h"
 
56
 
 
57
#include "images/rcm-stock-pixbufs.h"
 
58
 
 
59
 
 
60
/* Misc functions */
 
61
 
 
62
float
 
63
rcm_units_factor (gint units)
 
64
{
 
65
  switch (units)
 
66
  {
 
67
    case DEGREES:         return 180.0 / G_PI;
 
68
    case RADIANS:         return 1.0;
 
69
    case RADIANS_OVER_PI: return 1.0 / G_PI;
 
70
    default:              return -1;
 
71
  }
 
72
}
 
73
 
 
74
gchar *
 
75
rcm_units_string (gint units)
 
76
{
 
77
  switch (units)
 
78
  {
 
79
    case DEGREES:         return "deg";
 
80
    case RADIANS:         return "rad";
 
81
    case RADIANS_OVER_PI: return "rad/pi";
 
82
    default:              return "(unknown)";
 
83
  }
 
84
}
 
85
 
 
86
 
 
87
/* Circle buttons */
 
88
 
 
89
void
 
90
rcm_360_degrees (GtkWidget *button,
 
91
                 RcmCircle *circle)
 
92
{
 
93
  circle->action_flag = DO_NOTHING;
 
94
  gtk_widget_queue_draw (circle->preview);
 
95
  circle->angle->beta = circle->angle->alpha-circle->angle->cw_ccw * 0.001;
 
96
  rcm_draw_arrows (circle->preview->window, circle->preview->style->black_gc,
 
97
                   circle->angle);
 
98
  circle->action_flag = VIRGIN;
 
99
  rcm_render_preview (Current.Bna->after, CURRENT);
 
100
}
 
101
 
 
102
void
 
103
rcm_cw_ccw (GtkWidget *button,
 
104
            RcmCircle *circle)
 
105
{
 
106
  circle->angle->cw_ccw *= -1;
 
107
 
 
108
  g_object_set (button,
 
109
                "label",
 
110
                (circle->angle->cw_ccw>0) ?
 
111
                STOCK_COLORMAP_SWITCH_CLOCKWISE :
 
112
                STOCK_COLORMAP_SWITCH_COUNTERCLOCKWISE,
 
113
                "use_stock", TRUE,
 
114
                NULL);
 
115
 
 
116
  rcm_a_to_b (button, circle);
 
117
}
 
118
 
 
119
void
 
120
rcm_a_to_b (GtkWidget *button,
 
121
            RcmCircle *circle)
 
122
{
 
123
  circle->action_flag = DO_NOTHING;
 
124
  gtk_widget_queue_draw (circle->preview);
 
125
 
 
126
  SWAP (circle->angle->alpha, circle->angle->beta);
 
127
 
 
128
  rcm_draw_arrows (circle->preview->window, circle->preview->style->black_gc,
 
129
                   circle->angle);
 
130
 
 
131
  circle->action_flag = VIRGIN;
 
132
  rcm_render_preview (Current.Bna->after, CURRENT);
 
133
}
 
134
 
 
135
 
 
136
/* Misc: units buttons */
 
137
 
 
138
static void
 
139
rcm_spinbutton_to_degrees (GtkWidget *button,
 
140
                           float      value,
 
141
                           GtkWidget *label)
 
142
{
 
143
  GtkAdjustment *adj;
 
144
 
 
145
  adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (button));
 
146
  adj->value = value * rcm_units_factor (Current.Units);
 
147
  adj->upper = 360.0;
 
148
  adj->step_increment = 0.01;
 
149
  adj->page_increment = 1.0;
 
150
  gtk_spin_button_set_digits (GTK_SPIN_BUTTON (button), 2);
 
151
 
 
152
  gtk_label_set_text (GTK_LABEL (label), rcm_units_string (Current.Units));
 
153
}
 
154
 
 
155
void
 
156
rcm_switch_to_degrees (GtkWidget *button,
 
157
                       gpointer  *value)
 
158
{
 
159
  if (GTK_TOGGLE_BUTTON (button)->active)
 
160
    {
 
161
      Current.Units = DEGREES;
 
162
 
 
163
      rcm_spinbutton_to_degrees (Current.From->alpha_entry,
 
164
                                 Current.From->angle->alpha,
 
165
                                 Current.From->alpha_units_label);
 
166
 
 
167
      rcm_spinbutton_to_degrees (Current.From->beta_entry,
 
168
                                 Current.From->angle->beta,
 
169
                                 Current.From->beta_units_label);
 
170
 
 
171
      rcm_spinbutton_to_degrees (Current.To->alpha_entry,
 
172
                                 Current.To->angle->alpha,
 
173
                                 Current.To->alpha_units_label);
 
174
 
 
175
      rcm_spinbutton_to_degrees (Current.To->beta_entry,
 
176
                                 Current.To->angle->beta,
 
177
                                 Current.To->beta_units_label);
 
178
 
 
179
      rcm_spinbutton_to_degrees (Current.Gray->hue_entry,
 
180
                                 Current.Gray->hue,
 
181
                                 Current.Gray->hue_units_label);
 
182
 
 
183
      Current.From->action_flag = VIRGIN;
 
184
      Current.To->action_flag   = VIRGIN;
 
185
      Current.Gray->action_flag = VIRGIN;
 
186
    }
 
187
}
 
188
 
 
189
static void
 
190
rcm_spinbutton_to_radians (GtkWidget *button,
 
191
                           float      value,
 
192
                           GtkWidget *label)
 
193
{
 
194
  GtkAdjustment *adj;
 
195
 
 
196
  adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (button));
 
197
  adj->value = value * rcm_units_factor (Current.Units);
 
198
  adj->upper = TP;
 
199
  adj->step_increment = 0.0001;
 
200
  adj->page_increment = 0.001;
 
201
  gtk_spin_button_set_digits (GTK_SPIN_BUTTON (button), 4);
 
202
 
 
203
  gtk_label_set_text (GTK_LABEL (label), rcm_units_string (Current.Units));
 
204
}
 
205
 
 
206
void
 
207
rcm_switch_to_radians (GtkWidget *button,
 
208
                       gpointer  *value)
 
209
{
 
210
  if (GTK_TOGGLE_BUTTON (button)->active)
 
211
    {
 
212
      Current.Units = RADIANS;
 
213
 
 
214
      rcm_spinbutton_to_radians (Current.From->alpha_entry,
 
215
                                 Current.From->angle->alpha,
 
216
                                 Current.From->alpha_units_label);
 
217
 
 
218
      rcm_spinbutton_to_radians (Current.From->beta_entry,
 
219
                                 Current.From->angle->beta,
 
220
                                 Current.From->beta_units_label);
 
221
 
 
222
      rcm_spinbutton_to_radians (Current.To->alpha_entry,
 
223
                                 Current.To->angle->alpha,
 
224
                                 Current.To->alpha_units_label);
 
225
 
 
226
      rcm_spinbutton_to_radians (Current.To->beta_entry,
 
227
                                 Current.To->angle->beta,
 
228
                                 Current.To->beta_units_label);
 
229
 
 
230
      rcm_spinbutton_to_radians (Current.Gray->hue_entry,
 
231
                                 Current.Gray->hue,
 
232
                                 Current.Gray->hue_units_label);
 
233
 
 
234
      Current.From->action_flag = VIRGIN;
 
235
      Current.To->action_flag   = VIRGIN;
 
236
      Current.Gray->action_flag = VIRGIN;
 
237
    }
 
238
}
 
239
 
 
240
static void
 
241
rcm_spinbutton_to_radians_over_PI (GtkWidget *button,
 
242
                                   float      value,
 
243
                                   GtkWidget *label)
 
244
{
 
245
  GtkAdjustment *adj;
 
246
 
 
247
  adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (button));
 
248
  adj->value = value * rcm_units_factor (Current.Units);
 
249
  adj->upper = 2.0;
 
250
  adj->step_increment = 0.0001;
 
251
  adj->page_increment = 0.001;
 
252
  gtk_spin_button_set_digits (GTK_SPIN_BUTTON (button), 4);
 
253
 
 
254
  gtk_label_set_text (GTK_LABEL (label), rcm_units_string (Current.Units));
 
255
}
 
256
 
 
257
void
 
258
rcm_switch_to_radians_over_PI (GtkWidget *button,
 
259
                               gpointer  *value)
 
260
{
 
261
  if (GTK_TOGGLE_BUTTON (button)->active)
 
262
    {
 
263
      Current.Units = RADIANS_OVER_PI;
 
264
 
 
265
      rcm_spinbutton_to_radians_over_PI (Current.From->alpha_entry,
 
266
                                         Current.From->angle->alpha,
 
267
                                         Current.From->alpha_units_label);
 
268
 
 
269
      rcm_spinbutton_to_radians_over_PI (Current.From->beta_entry,
 
270
                                         Current.From->angle->beta,
 
271
                                         Current.From->beta_units_label);
 
272
 
 
273
      rcm_spinbutton_to_radians_over_PI (Current.To->alpha_entry,
 
274
                                         Current.To->angle->alpha,
 
275
                                         Current.To->alpha_units_label);
 
276
 
 
277
      rcm_spinbutton_to_radians_over_PI (Current.To->beta_entry,
 
278
                                         Current.To->angle->beta,
 
279
                                         Current.To->beta_units_label);
 
280
 
 
281
      rcm_spinbutton_to_radians_over_PI (Current.Gray->hue_entry,
 
282
                                         Current.Gray->hue,
 
283
                                         Current.Gray->hue_units_label);
 
284
 
 
285
      Current.From->action_flag = VIRGIN;
 
286
      Current.To->action_flag   = VIRGIN;
 
287
      Current.Gray->action_flag = VIRGIN;
 
288
    }
 
289
}
 
290
 
 
291
 
 
292
/* Misc: Gray: mode buttons */
 
293
 
 
294
void
 
295
rcm_switch_to_gray_to (GtkWidget *button,
 
296
                       gpointer  *value)
 
297
{
 
298
  if (! GTK_TOGGLE_BUTTON (button)->active)
 
299
    return;
 
300
 
 
301
  Current.Gray_to_from = GRAY_TO;
 
302
  rcm_render_preview (Current.Bna->after, CURRENT);
 
303
}
 
304
 
 
305
void
 
306
rcm_switch_to_gray_from (GtkWidget *button,
 
307
                         gpointer  *value)
 
308
{
 
309
  if (! GTK_TOGGLE_BUTTON (button)->active)
 
310
    return;
 
311
 
 
312
  Current.Gray_to_from = GRAY_FROM;
 
313
  rcm_render_preview (Current.Bna->after, CURRENT);
 
314
}
 
315
 
 
316
 
 
317
/* Misc: Preview buttons */
 
318
 
 
319
void
 
320
rcm_preview_as_you_drag (GtkWidget *button,
 
321
                         gpointer  *value)
 
322
{
 
323
  Current.RealTime = GTK_TOGGLE_BUTTON (button)->active;
 
324
}
 
325
 
 
326
static void
 
327
rcm_change_preview (void)
 
328
{
 
329
  /* must hide and show or resize would not work ... */
 
330
 
 
331
  gtk_widget_hide (Current.Bna->before);
 
332
  gtk_widget_hide (Current.Bna->after);
 
333
 
 
334
  gtk_widget_set_size_request (Current.Bna->before,
 
335
                               Current.reduced->width,
 
336
                               Current.reduced->height);
 
337
 
 
338
  gtk_widget_set_size_request (Current.Bna->after,
 
339
                               Current.reduced->width,
 
340
                               Current.reduced->height);
 
341
 
 
342
  rcm_render_preview (Current.Bna->before, ORIGINAL);
 
343
  rcm_render_preview (Current.Bna->after, CURRENT);
 
344
 
 
345
  gtk_widget_queue_draw (Current.Bna->before);
 
346
  gtk_widget_queue_draw (Current.Bna->after);
 
347
 
 
348
  gtk_widget_show (Current.Bna->before);
 
349
  gtk_widget_show (Current.Bna->after);
 
350
}
 
351
 
 
352
void
 
353
rcm_combo_callback (GtkWidget *widget,
 
354
                    gpointer   data)
 
355
{
 
356
  gint value;
 
357
 
 
358
  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value);
 
359
 
 
360
  Current.reduced = rcm_reduce_image (Current.drawable, Current.mask,
 
361
                                      MAX_PREVIEW_SIZE, value);
 
362
  rcm_change_preview ();
 
363
}
 
364
 
 
365
 
 
366
/* Circle events */
 
367
 
 
368
gboolean
 
369
rcm_expose_event (GtkWidget *widget,
 
370
                  GdkEvent  *event,
 
371
                  RcmCircle *circle)
 
372
{
 
373
  switch (circle->action_flag)
 
374
    {
 
375
    case DO_NOTHING: return FALSE; break;
 
376
 
 
377
    case VIRGIN:     rcm_draw_arrows(widget->window, widget->style->black_gc,
 
378
                                     circle->angle);
 
379
                     break;
 
380
 
 
381
    default:         if (Current.RealTime)
 
382
                       rcm_render_preview(Current.Bna->after,CURRENT);
 
383
                     break;
 
384
  }
 
385
  return TRUE;
 
386
}
 
387
 
 
388
gboolean
 
389
rcm_button_press_event (GtkWidget *widget,
 
390
                        GdkEvent  *event,
 
391
                        RcmCircle *circle)
 
392
{
 
393
  float           clicked_angle;
 
394
  float          *alpha;
 
395
  float          *beta;
 
396
  GdkEventButton *bevent;
 
397
 
 
398
  alpha  = &circle->angle->alpha;
 
399
  beta   = &circle->angle->beta;
 
400
  bevent = (GdkEventButton *) event;
 
401
 
 
402
  circle->action_flag = DRAG_START;
 
403
  clicked_angle = angle_mod_2PI (arctg (CENTER-bevent->y, bevent->x-CENTER));
 
404
  circle->prev_clicked = clicked_angle;
 
405
 
 
406
  if ((sqrt (SQR (bevent->y-CENTER) +
 
407
             SQR (bevent->x-CENTER)) > RADIUS * EACH_OR_BOTH) &&
 
408
      (min_prox (*alpha, *beta, clicked_angle) < G_PI / 12))
 
409
    {
 
410
      circle->mode = EACH;
 
411
      circle->target = closest (alpha, beta, clicked_angle);
 
412
 
 
413
      if (*(circle->target) != clicked_angle)
 
414
        {
 
415
          *(circle->target) = clicked_angle;
 
416
          gtk_widget_queue_draw (circle->preview);
 
417
          rcm_draw_arrows (widget->window,
 
418
                           widget->style->black_gc, circle->angle);
 
419
 
 
420
          gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->alpha_entry),
 
421
                                     circle->angle->alpha *
 
422
                                     rcm_units_factor(Current.Units));
 
423
 
 
424
          gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->beta_entry),
 
425
                                     circle->angle->beta *
 
426
                                     rcm_units_factor(Current.Units));
 
427
 
 
428
          if (Current.RealTime)
 
429
            rcm_render_preview (Current.Bna->after, CURRENT);
 
430
        }
 
431
    }
 
432
  else
 
433
    circle->mode = BOTH;
 
434
 
 
435
  return TRUE;
 
436
}
 
437
 
 
438
gboolean
 
439
rcm_release_event (GtkWidget *widget,
 
440
                   GdkEvent  *event,
 
441
                   RcmCircle *circle)
 
442
{
 
443
  if (circle->action_flag == DRAGING)
 
444
    {
 
445
      gtk_widget_queue_draw (circle->preview);
 
446
      rcm_draw_arrows (widget->window, widget->style->black_gc, circle->angle);
 
447
    }
 
448
 
 
449
  circle->action_flag = VIRGIN;
 
450
 
 
451
  if (! Current.RealTime)
 
452
    rcm_render_preview (Current.Bna->after, CURRENT);
 
453
 
 
454
  return TRUE;
 
455
}
 
456
 
 
457
gboolean
 
458
rcm_motion_notify_event (GtkWidget *widget,
 
459
                         GdkEvent  *event,
 
460
                         RcmCircle *circle)
 
461
{
 
462
  gint         x, y;
 
463
  gfloat       clicked_angle, delta;
 
464
  gfloat      *alpha, *beta;
 
465
  gint         cw_ccw;
 
466
  GdkGCValues  values;
 
467
 
 
468
  alpha  = &(circle->angle->alpha);
 
469
  beta   = &(circle->angle->beta);
 
470
  cw_ccw = circle->angle->cw_ccw;
 
471
  delta  = angle_mod_2PI (cw_ccw * (*beta - *alpha));
 
472
 
 
473
  values.foreground = Current.From->preview->style->white;
 
474
  values.function = GDK_XOR;
 
475
  xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
 
476
                                   &values,
 
477
                                   GDK_GC_FOREGROUND | GDK_GC_FUNCTION);
 
478
 
 
479
  gdk_window_get_pointer (widget->window, &x, &y, NULL);
 
480
  clicked_angle = angle_mod_2PI (arctg (CENTER-y, x-CENTER));
 
481
 
 
482
  delta = clicked_angle - circle->prev_clicked;
 
483
  circle->prev_clicked = clicked_angle;
 
484
 
 
485
  if (delta)
 
486
    {
 
487
      if (circle->action_flag == DRAG_START)
 
488
        {
 
489
          gtk_widget_queue_draw (circle->preview);
 
490
          circle->action_flag = DRAGING;
 
491
        }
 
492
      else
 
493
        {
 
494
          /* this should be erasing entire angle */
 
495
          rcm_draw_arrows (widget->window, xor_gc, circle->angle);
 
496
        }
 
497
 
 
498
      if (circle->mode == EACH)
 
499
        {
 
500
          *(circle->target)=clicked_angle;
 
501
        }
 
502
      else
 
503
        {
 
504
          circle->angle->alpha=angle_mod_2PI(circle->angle->alpha + delta);
 
505
          circle->angle->beta =angle_mod_2PI(circle->angle->beta  + delta);
 
506
        }
 
507
 
 
508
      gdk_window_process_updates (widget->window, FALSE);
 
509
      rcm_draw_arrows (widget->window, xor_gc, circle->angle);
 
510
 
 
511
      gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->alpha_entry),
 
512
                                 circle->angle->alpha *
 
513
                                 rcm_units_factor(Current.Units));
 
514
 
 
515
      gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->beta_entry),
 
516
                                 circle->angle->beta *
 
517
                                 rcm_units_factor(Current.Units));
 
518
 
 
519
      if (Current.RealTime)
 
520
        rcm_render_preview (Current.Bna->after, CURRENT);
 
521
  }
 
522
 
 
523
  return TRUE;
 
524
}
 
525
 
 
526
 
 
527
/* Gray circle events */
 
528
 
 
529
gboolean
 
530
rcm_gray_expose_event (GtkWidget *widget,
 
531
                       GdkEvent  *event,
 
532
                       RcmGray   *circle)
 
533
{
 
534
  if (circle->action_flag == VIRGIN)
 
535
    {
 
536
      rcm_draw_little_circle (widget->window, widget->style->black_gc,
 
537
                              circle->hue, circle->satur);
 
538
 
 
539
      rcm_draw_large_circle (widget->window,
 
540
                             widget->style->black_gc, circle->gray_sat);
 
541
    }
 
542
  else if (Current.RealTime)
 
543
    rcm_render_preview (Current.Bna->after, CURRENT);
 
544
 
 
545
  return TRUE;
 
546
}
 
547
 
 
548
gboolean
 
549
rcm_gray_button_press_event (GtkWidget *widget,
 
550
                             GdkEvent  *event,
 
551
                             RcmGray   *circle)
 
552
{
 
553
  GdkEventButton *bevent;
 
554
  int             x, y;
 
555
 
 
556
  bevent = (GdkEventButton *) event;
 
557
  x      = bevent->x - GRAY_CENTER - LITTLE_RADIUS;
 
558
  y      = GRAY_CENTER - bevent->y + LITTLE_RADIUS;
 
559
 
 
560
  circle->action_flag = DRAG_START;
 
561
  circle->hue         = angle_mod_2PI(arctg(y, x));
 
562
  circle->satur       = sqrt (SQR (x) + SQR (y)) / GRAY_RADIUS;
 
563
 
 
564
  if (circle->satur > 1.0)
 
565
    circle->satur = 1;
 
566
 
 
567
  gtk_widget_queue_draw (circle->preview);
 
568
  rcm_draw_little_circle (widget->window, widget->style->black_gc,
 
569
                          circle->hue, circle->satur);
 
570
 
 
571
  rcm_draw_large_circle (circle->preview->window,
 
572
                         circle->preview->style->black_gc,
 
573
                        circle->gray_sat);
 
574
 
 
575
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->hue_entry),
 
576
                             circle->hue * rcm_units_factor (Current.Units));
 
577
 
 
578
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
 
579
                             circle->satur);
 
580
 
 
581
  if (Current.RealTime)
 
582
    rcm_render_preview (Current.Bna->after,CURRENT);
 
583
 
 
584
  return TRUE;
 
585
}
 
586
 
 
587
gboolean
 
588
rcm_gray_release_event (GtkWidget *widget,
 
589
                        GdkEvent  *event,
 
590
                        RcmGray   *circle)
 
591
{
 
592
  if (circle->action_flag == DRAGING)
 
593
    rcm_draw_little_circle (widget->window,
 
594
                            widget->style->black_gc,
 
595
                            circle->hue,
 
596
                            circle->satur);
 
597
 
 
598
  circle->action_flag = VIRGIN;
 
599
 
 
600
  if (!Current.RealTime)
 
601
    rcm_render_preview (Current.Bna->after, CURRENT);
 
602
 
 
603
  return TRUE;
 
604
}
 
605
 
 
606
gboolean
 
607
rcm_gray_motion_notify_event (GtkWidget *widget,
 
608
                              GdkEvent  *event,
 
609
                              RcmGray   *circle)
 
610
{
 
611
  gint        x, y;
 
612
  GdkGCValues values;
 
613
 
 
614
  values.foreground = Current.From->preview->style->white;
 
615
  values.function = GDK_XOR;
 
616
  xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
 
617
                                   &values,
 
618
                                   GDK_GC_FOREGROUND | GDK_GC_FUNCTION);
 
619
 
 
620
  if (circle->action_flag == DRAG_START)
 
621
    {
 
622
      gtk_widget_queue_draw (circle->preview);
 
623
      rcm_draw_large_circle (circle->preview->window,
 
624
                             circle->preview->style->black_gc,
 
625
                             circle->gray_sat);
 
626
 
 
627
      circle->action_flag = DRAGING;
 
628
    }
 
629
  else
 
630
    {
 
631
      rcm_draw_little_circle (widget->window, xor_gc,
 
632
                              circle->hue, circle->satur); /* erase */
 
633
    }
 
634
 
 
635
  gdk_window_get_pointer (widget->window, &x, &y, NULL);
 
636
 
 
637
  x = x - GRAY_CENTER - LITTLE_RADIUS;
 
638
  y = GRAY_CENTER - y + LITTLE_RADIUS;
 
639
 
 
640
  circle->hue   = angle_mod_2PI (arctg (y, x));
 
641
  circle->satur = sqrt (SQR (x) + SQR (y)) / GRAY_RADIUS;
 
642
 
 
643
  if (circle->satur > 1.0)
 
644
    circle->satur = 1;
 
645
 
 
646
  rcm_draw_little_circle (widget->window, xor_gc, circle->hue, circle->satur);
 
647
 
 
648
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->hue_entry),
 
649
                             circle->hue * rcm_units_factor(Current.Units));
 
650
 
 
651
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
 
652
                             circle->satur);
 
653
 
 
654
  if (Current.RealTime)
 
655
    rcm_render_preview (Current.Bna->after, CURRENT);
 
656
 
 
657
  return TRUE;
 
658
}
 
659
 
 
660
 
 
661
/* Spinbuttons */
 
662
 
 
663
void
 
664
rcm_set_alpha (GtkWidget *entry,
 
665
               gpointer   data)
 
666
{
 
667
  RcmCircle *circle = data;
 
668
 
 
669
  if (circle->action_flag != VIRGIN)
 
670
    return;
 
671
 
 
672
  circle->angle->alpha = (gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)) /
 
673
                          rcm_units_factor (Current.Units));
 
674
 
 
675
  gtk_widget_queue_draw (circle->preview);
 
676
 
 
677
  rcm_draw_arrows (circle->preview->window, circle->preview->style->black_gc,
 
678
                   circle->angle);
 
679
 
 
680
  rcm_render_preview (Current.Bna->after, CURRENT);
 
681
}
 
682
 
 
683
void
 
684
rcm_set_beta (GtkWidget *entry,
 
685
              gpointer   data)
 
686
{
 
687
  RcmCircle *circle = data;
 
688
 
 
689
  if (circle->action_flag != VIRGIN)
 
690
    return;
 
691
 
 
692
  circle->angle->beta = (gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)) /
 
693
                         rcm_units_factor(Current.Units));
 
694
 
 
695
  gtk_widget_queue_draw (circle->preview);
 
696
 
 
697
  rcm_draw_arrows (circle->preview->window, circle->preview->style->black_gc,
 
698
                   circle->angle);
 
699
 
 
700
  rcm_render_preview (Current.Bna->after, CURRENT);
 
701
}
 
702
 
 
703
void
 
704
rcm_set_hue (GtkWidget *entry,
 
705
             gpointer   data)
 
706
{
 
707
  RcmGray *circle = data;
 
708
 
 
709
  if (circle->action_flag != VIRGIN
 
710
      ) return;
 
711
 
 
712
  circle->hue = (gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)) /
 
713
                 rcm_units_factor(Current.Units));
 
714
 
 
715
  gtk_widget_queue_draw (circle->preview);
 
716
 
 
717
  rcm_draw_little_circle (circle->preview->window,
 
718
                          circle->preview->style->black_gc,
 
719
                          circle->hue, circle->satur);
 
720
 
 
721
  rcm_draw_large_circle (circle->preview->window,
 
722
                         circle->preview->style->black_gc,
 
723
                         circle->gray_sat);
 
724
 
 
725
  rcm_render_preview (Current.Bna->after, CURRENT);
 
726
}
 
727
 
 
728
void
 
729
rcm_set_satur (GtkWidget *entry,
 
730
               gpointer   data)
 
731
{
 
732
  RcmGray *circle = data;
 
733
 
 
734
  if (circle->action_flag != VIRGIN)
 
735
    return;
 
736
 
 
737
  circle->satur = gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry));
 
738
 
 
739
  gtk_widget_queue_draw (circle->preview);
 
740
 
 
741
  rcm_draw_little_circle (circle->preview->window,
 
742
                          circle->preview->style->black_gc,
 
743
                          circle->hue, circle->satur);
 
744
 
 
745
  rcm_draw_large_circle (circle->preview->window,
 
746
                         circle->preview->style->black_gc,
 
747
                         circle->gray_sat);
 
748
 
 
749
  rcm_render_preview (Current.Bna->after, CURRENT);
 
750
}
 
751
 
 
752
void
 
753
rcm_set_gray_sat (GtkWidget *entry,
 
754
                  gpointer   data)
 
755
{
 
756
  RcmGray *circle = data;
 
757
 
 
758
  circle->gray_sat = gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry));
 
759
 
 
760
  gtk_widget_queue_draw (circle->preview);
 
761
 
 
762
  rcm_draw_large_circle (circle->preview->window,
 
763
                         circle->preview->style->black_gc,
 
764
                         circle->gray_sat);
 
765
 
 
766
  rcm_render_preview (Current.Bna->after, CURRENT);
 
767
}