← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gimp/karmic-security

« back to all changes in this revision

Viewing changes to app/paint/gimppaintoptions.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2008-10-06 13:30:41 UTC
  • mfrom: (1.1.15 upstream)
  • Revision ID: james.westby@ubuntu.com-20081006133041-axco233xt49jobn7
Tags: 2.6.0-1ubuntu1
https://launchpad.net/bugs/276839
* Sync on debian and new version (lp: #276839)
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch:
  - updated some strings for ubuntu
* debian/rules:
  - updated translation templates

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/paint/gimppaintoptions.c
38
38
#define DEFAULT_APPLICATION_MODE      GIMP_PAINT_CONSTANT
39
39
#define DEFAULT_HARD                  FALSE
40
40
 
41
 
#define DEFAULT_PRESSURE_EXPANDED     FALSE
 
41
#define DEFAULT_DYNAMICS_EXPANDED     FALSE
 
42
 
42
43
#define DEFAULT_PRESSURE_OPACITY      TRUE
43
44
#define DEFAULT_PRESSURE_HARDNESS     FALSE
44
45
#define DEFAULT_PRESSURE_RATE         FALSE
45
46
#define DEFAULT_PRESSURE_SIZE         FALSE
46
47
#define DEFAULT_PRESSURE_INVERSE_SIZE FALSE
47
48
#define DEFAULT_PRESSURE_COLOR        FALSE
 
49
#define DEFAULT_PRESSURE_PRESCALE     1.0
 
50
 
 
51
#define DEFAULT_VELOCITY_OPACITY      FALSE
 
52
#define DEFAULT_VELOCITY_HARDNESS     FALSE
 
53
#define DEFAULT_VELOCITY_RATE         FALSE
 
54
#define DEFAULT_VELOCITY_SIZE         FALSE
 
55
#define DEFAULT_VELOCITY_INVERSE_SIZE FALSE
 
56
#define DEFAULT_VELOCITY_COLOR        FALSE
 
57
#define DEFAULT_VELOCITY_PRESCALE     1.0
 
58
 
 
59
#define DEFAULT_RANDOM_OPACITY        FALSE
 
60
#define DEFAULT_RANDOM_HARDNESS       FALSE
 
61
#define DEFAULT_RANDOM_RATE           FALSE
 
62
#define DEFAULT_RANDOM_SIZE           FALSE
 
63
#define DEFAULT_RANDOM_INVERSE_SIZE   FALSE
 
64
#define DEFAULT_RANDOM_COLOR          FALSE
 
65
#define DEFAULT_RANDOM_PRESCALE       1.0
48
66
 
49
67
#define DEFAULT_USE_FADE              FALSE
50
68
#define DEFAULT_FADE_LENGTH           100.0
63
81
enum
64
82
{
65
83
  PROP_0,
 
84
 
66
85
  PROP_PAINT_INFO,
67
86
  PROP_BRUSH_SCALE,
68
87
  PROP_APPLICATION_MODE,
69
88
  PROP_HARD,
70
 
  PROP_PRESSURE_EXPANDED,
 
89
 
 
90
  PROP_DYNAMICS_EXPANDED,
 
91
 
71
92
  PROP_PRESSURE_OPACITY,
72
93
  PROP_PRESSURE_HARDNESS,
73
94
  PROP_PRESSURE_RATE,
74
95
  PROP_PRESSURE_SIZE,
75
96
  PROP_PRESSURE_INVERSE_SIZE,
76
97
  PROP_PRESSURE_COLOR,
 
98
  PROP_PRESSURE_PRESCALE,
 
99
 
 
100
  PROP_VELOCITY_OPACITY,
 
101
  PROP_VELOCITY_HARDNESS,
 
102
  PROP_VELOCITY_RATE,
 
103
  PROP_VELOCITY_SIZE,
 
104
  PROP_VELOCITY_INVERSE_SIZE,
 
105
  PROP_VELOCITY_COLOR,
 
106
  PROP_VELOCITY_PRESCALE,
 
107
 
 
108
  PROP_RANDOM_OPACITY,
 
109
  PROP_RANDOM_HARDNESS,
 
110
  PROP_RANDOM_RATE,
 
111
  PROP_RANDOM_SIZE,
 
112
  PROP_RANDOM_INVERSE_SIZE,
 
113
  PROP_RANDOM_COLOR,
 
114
  PROP_RANDOM_PRESCALE,
 
115
 
77
116
  PROP_USE_FADE,
78
117
  PROP_FADE_LENGTH,
79
118
  PROP_FADE_UNIT,
 
119
 
 
120
  PROP_USE_JITTER,
 
121
  PROP_JITTER_AMOUNT,
 
122
 
80
123
  PROP_USE_GRADIENT,
81
124
  PROP_GRADIENT_REVERSE,
82
125
  PROP_GRADIENT_REPEAT,
83
126
  PROP_GRADIENT_LENGTH,
84
127
  PROP_GRADIENT_UNIT,
85
 
  PROP_USE_JITTER,
86
 
  PROP_JITTER_AMOUNT,
87
128
 
88
129
  PROP_BRUSH_VIEW_TYPE,
89
130
  PROP_BRUSH_VIEW_SIZE,
94
135
};
95
136
 
96
137
 
97
 
static void   gimp_paint_options_finalize     (GObject      *object);
98
 
static void   gimp_paint_options_set_property (GObject      *object,
99
 
                                               guint         property_id,
100
 
                                               const GValue *value,
101
 
                                               GParamSpec   *pspec);
102
 
static void   gimp_paint_options_get_property (GObject      *object,
103
 
                                               guint         property_id,
104
 
                                               GValue       *value,
105
 
                                               GParamSpec   *pspec);
106
 
static void   gimp_paint_options_notify       (GObject      *object,
107
 
                                               GParamSpec   *pspec);
 
138
static void    gimp_paint_options_finalize         (GObject      *object);
 
139
static void    gimp_paint_options_set_property     (GObject      *object,
 
140
                                                    guint         property_id,
 
141
                                                    const GValue *value,
 
142
                                                    GParamSpec   *pspec);
 
143
static void    gimp_paint_options_get_property     (GObject      *object,
 
144
                                                    guint         property_id,
 
145
                                                    GValue       *value,
 
146
                                                    GParamSpec   *pspec);
 
147
static void    gimp_paint_options_notify           (GObject      *object,
 
148
                                                    GParamSpec   *pspec);
 
149
 
 
150
static gdouble gimp_paint_options_get_dynamics_mix (gdouble       mix1,
 
151
                                                    gdouble       mix1_scale,
 
152
                                                    gdouble       mix2,
 
153
                                                    gdouble       mix2_scale,
 
154
                                                    gdouble       mix3,
 
155
                                                    gdouble       mix3_scale);
108
156
 
109
157
 
110
158
G_DEFINE_TYPE (GimpPaintOptions, gimp_paint_options, GIMP_TYPE_TOOL_OPTIONS)
143
191
                                    DEFAULT_HARD,
144
192
                                    GIMP_PARAM_STATIC_STRINGS);
145
193
 
146
 
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PRESSURE_EXPANDED,
147
 
                                    "pressure-expanded", NULL,
148
 
                                    DEFAULT_PRESSURE_EXPANDED,
 
194
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DYNAMICS_EXPANDED,
 
195
                                    "dynamics-expanded", NULL,
 
196
                                    DEFAULT_DYNAMICS_EXPANDED,
149
197
                                    GIMP_PARAM_STATIC_STRINGS);
 
198
 
150
199
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PRESSURE_OPACITY,
151
200
                                    "pressure-opacity", NULL,
152
201
                                    DEFAULT_PRESSURE_OPACITY,
171
220
                                    "pressure-inverse-size", NULL,
172
221
                                    DEFAULT_PRESSURE_INVERSE_SIZE,
173
222
                                    GIMP_PARAM_STATIC_STRINGS);
 
223
  GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_PRESSURE_PRESCALE,
 
224
                                   "pressure-prescale", NULL,
 
225
                                   0.0, 1.0, DEFAULT_PRESSURE_PRESCALE,
 
226
                                   GIMP_PARAM_STATIC_STRINGS);
 
227
 
 
228
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY_OPACITY,
 
229
                                    "velocity-opacity", NULL,
 
230
                                    DEFAULT_VELOCITY_OPACITY,
 
231
                                    GIMP_PARAM_STATIC_STRINGS);
 
232
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY_HARDNESS,
 
233
                                    "velocity-hardness", NULL,
 
234
                                    DEFAULT_VELOCITY_HARDNESS,
 
235
                                    GIMP_PARAM_STATIC_STRINGS);
 
236
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY_RATE,
 
237
                                    "velocity-rate", NULL,
 
238
                                    DEFAULT_VELOCITY_RATE,
 
239
                                    GIMP_PARAM_STATIC_STRINGS);
 
240
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY_SIZE,
 
241
                                    "velocity-size", NULL,
 
242
                                    DEFAULT_VELOCITY_SIZE,
 
243
                                    GIMP_PARAM_STATIC_STRINGS);
 
244
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY_COLOR,
 
245
                                    "velocity-color", NULL,
 
246
                                    DEFAULT_VELOCITY_COLOR,
 
247
                                    GIMP_PARAM_STATIC_STRINGS);
 
248
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY_INVERSE_SIZE,
 
249
                                    "velocity-inverse-size", NULL,
 
250
                                    DEFAULT_VELOCITY_INVERSE_SIZE,
 
251
                                    GIMP_PARAM_STATIC_STRINGS);
 
252
  GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_VELOCITY_PRESCALE,
 
253
                                   "velocity-prescale", NULL,
 
254
                                   0.0, 1.0, DEFAULT_VELOCITY_PRESCALE,
 
255
                                   GIMP_PARAM_STATIC_STRINGS);
 
256
 
 
257
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM_OPACITY,
 
258
                                    "random-opacity", NULL,
 
259
                                    DEFAULT_RANDOM_OPACITY,
 
260
                                    GIMP_PARAM_STATIC_STRINGS);
 
261
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM_HARDNESS,
 
262
                                    "random-hardness", NULL,
 
263
                                    DEFAULT_RANDOM_HARDNESS,
 
264
                                    GIMP_PARAM_STATIC_STRINGS);
 
265
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM_RATE,
 
266
                                    "random-rate", NULL,
 
267
                                    DEFAULT_RANDOM_RATE,
 
268
                                    GIMP_PARAM_STATIC_STRINGS);
 
269
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM_SIZE,
 
270
                                    "random-size", NULL,
 
271
                                    DEFAULT_RANDOM_SIZE,
 
272
                                    GIMP_PARAM_STATIC_STRINGS);
 
273
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM_COLOR,
 
274
                                    "random-color", NULL,
 
275
                                    DEFAULT_RANDOM_COLOR,
 
276
                                    GIMP_PARAM_STATIC_STRINGS);
 
277
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM_INVERSE_SIZE,
 
278
                                    "random-inverse-size", NULL,
 
279
                                    DEFAULT_RANDOM_INVERSE_SIZE,
 
280
                                    GIMP_PARAM_STATIC_STRINGS);
 
281
  GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RANDOM_PRESCALE,
 
282
                                   "random-prescale", NULL,
 
283
                                   0.0, 1.0, DEFAULT_RANDOM_PRESCALE,
 
284
                                   GIMP_PARAM_STATIC_STRINGS);
174
285
 
175
286
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FADE,
176
287
                                    "use-fade", NULL,
258
369
{
259
370
  options->application_mode_save = DEFAULT_APPLICATION_MODE;
260
371
 
261
 
  options->pressure_options = g_slice_new0 (GimpPressureOptions);
 
372
  options->pressure_options = g_slice_new0 (GimpDynamicOptions);
 
373
  options->velocity_options = g_slice_new0 (GimpDynamicOptions);
 
374
  options->random_options   = g_slice_new0 (GimpDynamicOptions);
262
375
  options->fade_options     = g_slice_new0 (GimpFadeOptions);
 
376
  options->jitter_options   = g_slice_new0 (GimpJitterOptions);
263
377
  options->gradient_options = g_slice_new0 (GimpGradientOptions);
264
 
  options->jitter_options   = g_slice_new0 (GimpJitterOptions);
265
378
}
266
379
 
267
380
static void
272
385
  if (options->paint_info)
273
386
    g_object_unref (options->paint_info);
274
387
 
275
 
  g_slice_free (GimpPressureOptions, options->pressure_options);
 
388
  g_slice_free (GimpDynamicOptions,  options->pressure_options);
 
389
  g_slice_free (GimpDynamicOptions,  options->velocity_options);
 
390
  g_slice_free (GimpDynamicOptions,  options->random_options);
276
391
  g_slice_free (GimpFadeOptions,     options->fade_options);
 
392
  g_slice_free (GimpJitterOptions,   options->jitter_options);
277
393
  g_slice_free (GimpGradientOptions, options->gradient_options);
278
 
  g_slice_free (GimpJitterOptions,   options->jitter_options);
279
394
 
280
395
  G_OBJECT_CLASS (parent_class)->finalize (object);
281
396
}
286
401
                                 const GValue *value,
287
402
                                 GParamSpec   *pspec)
288
403
{
289
 
  GimpPaintOptions    *options = GIMP_PAINT_OPTIONS (object);
290
 
  GimpPressureOptions *pressure_options;
291
 
  GimpFadeOptions     *fade_options;
292
 
  GimpGradientOptions *gradient_options;
293
 
  GimpJitterOptions   *jitter_options;
294
 
 
295
 
  pressure_options = options->pressure_options;
296
 
  fade_options     = options->fade_options;
297
 
  gradient_options = options->gradient_options;
298
 
  jitter_options   = options->jitter_options;
 
404
  GimpPaintOptions    *options          = GIMP_PAINT_OPTIONS (object);
 
405
  GimpDynamicOptions  *pressure_options = options->pressure_options;
 
406
  GimpDynamicOptions  *velocity_options = options->velocity_options;
 
407
  GimpDynamicOptions  *random_options   = options->random_options;
 
408
  GimpFadeOptions     *fade_options     = options->fade_options;
 
409
  GimpJitterOptions   *jitter_options   = options->jitter_options;
 
410
  GimpGradientOptions *gradient_options = options->gradient_options;
299
411
 
300
412
  switch (property_id)
301
413
    {
302
414
    case PROP_PAINT_INFO:
303
 
      options->paint_info = (GimpPaintInfo *) g_value_dup_object (value);
 
415
      options->paint_info = g_value_dup_object (value);
304
416
      break;
305
417
 
306
418
    case PROP_BRUSH_SCALE:
307
419
      options->brush_scale = g_value_get_double (value);
308
420
      break;
 
421
 
309
422
    case PROP_APPLICATION_MODE:
310
423
      options->application_mode = g_value_get_enum (value);
311
424
      break;
 
425
 
312
426
    case PROP_HARD:
313
427
      options->hard = g_value_get_boolean (value);
314
428
      break;
315
429
 
316
 
    case PROP_PRESSURE_EXPANDED:
317
 
      pressure_options->expanded = g_value_get_boolean (value);
 
430
    case PROP_DYNAMICS_EXPANDED:
 
431
      options->dynamics_expanded = g_value_get_boolean (value);
318
432
      break;
 
433
 
319
434
    case PROP_PRESSURE_OPACITY:
320
435
      pressure_options->opacity = g_value_get_boolean (value);
321
436
      break;
 
437
 
322
438
    case PROP_PRESSURE_HARDNESS:
323
439
      pressure_options->hardness = g_value_get_boolean (value);
324
440
      break;
 
441
 
325
442
    case PROP_PRESSURE_RATE:
326
443
      pressure_options->rate = g_value_get_boolean (value);
327
444
      break;
 
445
 
328
446
    case PROP_PRESSURE_SIZE:
329
447
      pressure_options->size = g_value_get_boolean (value);
330
448
      break;
 
449
 
331
450
    case PROP_PRESSURE_INVERSE_SIZE:
332
451
      pressure_options->inverse_size = g_value_get_boolean (value);
333
452
      break;
 
453
 
334
454
    case PROP_PRESSURE_COLOR:
335
455
      pressure_options->color = g_value_get_boolean (value);
336
456
      break;
337
457
 
 
458
    case PROP_PRESSURE_PRESCALE:
 
459
      pressure_options->prescale = g_value_get_double (value);
 
460
      break;
 
461
 
 
462
    case PROP_VELOCITY_OPACITY:
 
463
      velocity_options->opacity = g_value_get_boolean (value);
 
464
      break;
 
465
 
 
466
    case PROP_VELOCITY_HARDNESS:
 
467
      velocity_options->hardness = g_value_get_boolean (value);
 
468
      break;
 
469
 
 
470
    case PROP_VELOCITY_RATE:
 
471
      velocity_options->rate = g_value_get_boolean (value);
 
472
      break;
 
473
 
 
474
    case PROP_VELOCITY_SIZE:
 
475
      velocity_options->size = g_value_get_boolean (value);
 
476
      break;
 
477
 
 
478
    case PROP_VELOCITY_INVERSE_SIZE:
 
479
      velocity_options->inverse_size = g_value_get_boolean (value);
 
480
      break;
 
481
 
 
482
    case PROP_VELOCITY_COLOR:
 
483
      velocity_options->color = g_value_get_boolean (value);
 
484
      break;
 
485
 
 
486
    case PROP_VELOCITY_PRESCALE:
 
487
      velocity_options->prescale = g_value_get_double (value);
 
488
      break;
 
489
 
 
490
    case PROP_RANDOM_OPACITY:
 
491
      random_options->opacity = g_value_get_boolean (value);
 
492
      break;
 
493
 
 
494
    case PROP_RANDOM_HARDNESS:
 
495
      random_options->hardness = g_value_get_boolean (value);
 
496
      break;
 
497
 
 
498
    case PROP_RANDOM_RATE:
 
499
      random_options->rate = g_value_get_boolean (value);
 
500
      break;
 
501
 
 
502
    case PROP_RANDOM_SIZE:
 
503
      random_options->size = g_value_get_boolean (value);
 
504
      break;
 
505
 
 
506
    case PROP_RANDOM_INVERSE_SIZE:
 
507
      random_options->inverse_size = g_value_get_boolean (value);
 
508
      break;
 
509
 
 
510
    case PROP_RANDOM_COLOR:
 
511
      random_options->color = g_value_get_boolean (value);
 
512
      break;
 
513
 
 
514
    case PROP_RANDOM_PRESCALE:
 
515
      random_options->prescale = g_value_get_double (value);
 
516
      break;
 
517
 
338
518
    case PROP_USE_FADE:
339
519
      fade_options->use_fade = g_value_get_boolean (value);
340
520
      break;
 
521
 
341
522
    case PROP_FADE_LENGTH:
342
523
      fade_options->fade_length = g_value_get_double (value);
343
524
      break;
 
525
 
344
526
    case PROP_FADE_UNIT:
345
527
      fade_options->fade_unit = g_value_get_int (value);
346
528
      break;
348
530
    case PROP_USE_JITTER:
349
531
      jitter_options->use_jitter = g_value_get_boolean (value);
350
532
      break;
 
533
 
351
534
    case PROP_JITTER_AMOUNT:
352
535
      jitter_options->jitter_amount = g_value_get_double (value);
353
536
      break;
355
538
    case PROP_USE_GRADIENT:
356
539
      gradient_options->use_gradient = g_value_get_boolean (value);
357
540
      break;
 
541
 
358
542
    case PROP_GRADIENT_REVERSE:
359
543
      gradient_options->gradient_reverse = g_value_get_boolean (value);
360
544
      break;
 
545
 
361
546
    case PROP_GRADIENT_REPEAT:
362
547
      gradient_options->gradient_repeat = g_value_get_enum (value);
363
548
      break;
 
549
 
364
550
    case PROP_GRADIENT_LENGTH:
365
551
      gradient_options->gradient_length = g_value_get_double (value);
366
552
      break;
 
553
 
367
554
    case PROP_GRADIENT_UNIT:
368
555
      gradient_options->gradient_unit = g_value_get_int (value);
369
556
      break;
371
558
    case PROP_BRUSH_VIEW_TYPE:
372
559
      options->brush_view_type = g_value_get_enum (value);
373
560
      break;
 
561
 
374
562
    case PROP_BRUSH_VIEW_SIZE:
375
563
      options->brush_view_size = g_value_get_int (value);
376
564
      break;
378
566
    case PROP_PATTERN_VIEW_TYPE:
379
567
      options->pattern_view_type = g_value_get_enum (value);
380
568
      break;
 
569
 
381
570
    case PROP_PATTERN_VIEW_SIZE:
382
571
      options->pattern_view_size = g_value_get_int (value);
383
572
      break;
385
574
    case PROP_GRADIENT_VIEW_TYPE:
386
575
      options->gradient_view_type = g_value_get_enum (value);
387
576
      break;
 
577
 
388
578
    case PROP_GRADIENT_VIEW_SIZE:
389
579
      options->gradient_view_size = g_value_get_int (value);
390
580
      break;
401
591
                                 GValue     *value,
402
592
                                 GParamSpec *pspec)
403
593
{
404
 
  GimpPaintOptions    *options = GIMP_PAINT_OPTIONS (object);
405
 
  GimpPressureOptions *pressure_options;
406
 
  GimpFadeOptions     *fade_options;
407
 
  GimpGradientOptions *gradient_options;
408
 
  GimpJitterOptions   *jitter_options;
409
 
 
410
 
  pressure_options = options->pressure_options;
411
 
  fade_options     = options->fade_options;
412
 
  gradient_options = options->gradient_options;
413
 
  jitter_options   = options->jitter_options;
 
594
  GimpPaintOptions    *options          = GIMP_PAINT_OPTIONS (object);
 
595
  GimpDynamicOptions  *pressure_options = options->pressure_options;
 
596
  GimpDynamicOptions  *velocity_options = options->velocity_options;
 
597
  GimpDynamicOptions  *random_options   = options->random_options;
 
598
  GimpFadeOptions     *fade_options     = options->fade_options;
 
599
  GimpJitterOptions   *jitter_options   = options->jitter_options;
 
600
  GimpGradientOptions *gradient_options = options->gradient_options;
414
601
 
415
602
  switch (property_id)
416
603
    {
421
608
    case PROP_BRUSH_SCALE:
422
609
      g_value_set_double (value, options->brush_scale);
423
610
      break;
 
611
 
424
612
    case PROP_APPLICATION_MODE:
425
613
      g_value_set_enum (value, options->application_mode);
426
614
      break;
 
615
 
427
616
    case PROP_HARD:
428
617
      g_value_set_boolean (value, options->hard);
429
618
      break;
430
619
 
431
 
    case PROP_PRESSURE_EXPANDED:
432
 
      g_value_set_boolean (value, pressure_options->expanded);
 
620
    case PROP_DYNAMICS_EXPANDED:
 
621
      g_value_set_boolean (value, options->dynamics_expanded);
433
622
      break;
 
623
 
434
624
    case PROP_PRESSURE_OPACITY:
435
625
      g_value_set_boolean (value, pressure_options->opacity);
436
626
      break;
 
627
 
437
628
    case PROP_PRESSURE_HARDNESS:
438
629
      g_value_set_boolean (value, pressure_options->hardness);
439
630
      break;
 
631
 
440
632
    case PROP_PRESSURE_RATE:
441
633
      g_value_set_boolean (value, pressure_options->rate);
442
634
      break;
 
635
 
443
636
    case PROP_PRESSURE_SIZE:
444
637
      g_value_set_boolean (value, pressure_options->size);
445
638
      break;
 
639
 
446
640
    case PROP_PRESSURE_INVERSE_SIZE:
447
641
      g_value_set_boolean (value, pressure_options->inverse_size);
448
642
      break;
 
643
 
449
644
    case PROP_PRESSURE_COLOR:
450
645
      g_value_set_boolean (value, pressure_options->color);
451
646
      break;
452
647
 
 
648
    case PROP_PRESSURE_PRESCALE:
 
649
      g_value_set_double (value, pressure_options->prescale);
 
650
      break;
 
651
 
 
652
    case PROP_VELOCITY_OPACITY:
 
653
      g_value_set_boolean (value, velocity_options->opacity);
 
654
      break;
 
655
 
 
656
    case PROP_VELOCITY_HARDNESS:
 
657
      g_value_set_boolean (value, velocity_options->hardness);
 
658
      break;
 
659
 
 
660
    case PROP_VELOCITY_RATE:
 
661
      g_value_set_boolean (value, velocity_options->rate);
 
662
      break;
 
663
 
 
664
    case PROP_VELOCITY_SIZE:
 
665
      g_value_set_boolean (value, velocity_options->size);
 
666
      break;
 
667
 
 
668
    case PROP_VELOCITY_INVERSE_SIZE:
 
669
      g_value_set_boolean (value, velocity_options->inverse_size);
 
670
      break;
 
671
 
 
672
    case PROP_VELOCITY_COLOR:
 
673
      g_value_set_boolean (value, velocity_options->color);
 
674
      break;
 
675
 
 
676
    case PROP_VELOCITY_PRESCALE:
 
677
      g_value_set_double (value, velocity_options->prescale);
 
678
      break;
 
679
 
 
680
    case PROP_RANDOM_OPACITY:
 
681
      g_value_set_boolean (value, random_options->opacity);
 
682
      break;
 
683
 
 
684
    case PROP_RANDOM_HARDNESS:
 
685
      g_value_set_boolean (value, random_options->hardness);
 
686
      break;
 
687
 
 
688
    case PROP_RANDOM_RATE:
 
689
      g_value_set_boolean (value, random_options->rate);
 
690
      break;
 
691
 
 
692
    case PROP_RANDOM_SIZE:
 
693
      g_value_set_boolean (value, random_options->size);
 
694
      break;
 
695
 
 
696
    case PROP_RANDOM_INVERSE_SIZE:
 
697
      g_value_set_boolean (value, random_options->inverse_size);
 
698
      break;
 
699
 
 
700
    case PROP_RANDOM_COLOR:
 
701
      g_value_set_boolean (value, random_options->color);
 
702
      break;
 
703
 
 
704
    case PROP_RANDOM_PRESCALE:
 
705
      g_value_set_double (value, random_options->prescale);
 
706
      break;
 
707
 
453
708
    case PROP_USE_FADE:
454
709
      g_value_set_boolean (value, fade_options->use_fade);
455
710
      break;
 
711
 
456
712
    case PROP_FADE_LENGTH:
457
713
      g_value_set_double (value, fade_options->fade_length);
458
714
      break;
 
715
 
459
716
    case PROP_FADE_UNIT:
460
717
      g_value_set_int (value, fade_options->fade_unit);
461
718
      break;
463
720
    case PROP_USE_JITTER:
464
721
      g_value_set_boolean (value, jitter_options->use_jitter);
465
722
      break;
 
723
 
466
724
    case PROP_JITTER_AMOUNT:
467
725
      g_value_set_double (value, jitter_options->jitter_amount);
468
726
      break;
470
728
    case PROP_USE_GRADIENT:
471
729
      g_value_set_boolean (value, gradient_options->use_gradient);
472
730
      break;
 
731
 
473
732
    case PROP_GRADIENT_REVERSE:
474
733
      g_value_set_boolean (value, gradient_options->gradient_reverse);
475
734
      break;
 
735
 
476
736
    case PROP_GRADIENT_REPEAT:
477
737
      g_value_set_enum (value, gradient_options->gradient_repeat);
478
738
      break;
 
739
 
479
740
    case PROP_GRADIENT_LENGTH:
480
741
      g_value_set_double (value, gradient_options->gradient_length);
481
742
      break;
 
743
 
482
744
    case PROP_GRADIENT_UNIT:
483
745
      g_value_set_int (value, gradient_options->gradient_unit);
484
746
      break;
486
748
    case PROP_BRUSH_VIEW_TYPE:
487
749
      g_value_set_enum (value, options->brush_view_type);
488
750
      break;
 
751
 
489
752
    case PROP_BRUSH_VIEW_SIZE:
490
753
      g_value_set_int (value, options->brush_view_size);
491
754
      break;
493
756
    case PROP_PATTERN_VIEW_TYPE:
494
757
      g_value_set_enum (value, options->pattern_view_type);
495
758
      break;
 
759
 
496
760
    case PROP_PATTERN_VIEW_SIZE:
497
761
      g_value_set_int (value, options->pattern_view_size);
498
762
      break;
500
764
    case PROP_GRADIENT_VIEW_TYPE:
501
765
      g_value_set_enum (value, options->gradient_view_type);
502
766
      break;
 
767
 
503
768
    case PROP_GRADIENT_VIEW_SIZE:
504
769
      g_value_set_int (value, options->gradient_view_size);
505
770
      break;
575
840
          fade_out = fade_options->fade_length;
576
841
          break;
577
842
        case GIMP_UNIT_PERCENT:
578
 
          fade_out = (MAX (image->width, image->height) *
 
843
          fade_out = (MAX (gimp_image_get_width  (image),
 
844
                           gimp_image_get_height (image)) *
579
845
                      fade_options->fade_length / 100);
580
846
          break;
581
847
        default:
582
 
          unit_factor = gimp_unit_get_factor (fade_options->fade_unit);
583
 
          fade_out    = (fade_options->fade_length *
584
 
                         MAX (image->xresolution,
585
 
                              image->yresolution) / unit_factor);
 
848
          {
 
849
            gdouble xres;
 
850
            gdouble yres;
 
851
 
 
852
            gimp_image_get_resolution (image, &xres, &yres);
 
853
 
 
854
            unit_factor = gimp_unit_get_factor (fade_options->fade_unit);
 
855
            fade_out    = (fade_options->fade_length *
 
856
                           MAX (xres, yres) / unit_factor);
 
857
          }
586
858
          break;
587
859
        }
588
860
 
609
881
{
610
882
  GimpJitterOptions *jitter_options;
611
883
 
 
884
  g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), 0.0);
 
885
 
612
886
  jitter_options = paint_options->jitter_options;
613
887
 
614
888
  if (jitter_options->use_jitter)
620
894
gboolean
621
895
gimp_paint_options_get_gradient_color (GimpPaintOptions *paint_options,
622
896
                                       GimpImage        *image,
623
 
                                       gdouble           pressure,
 
897
                                       gdouble           grad_point,
624
898
                                       gdouble           pixel_dist,
625
899
                                       GimpRGB          *color)
626
900
{
627
 
  GimpPressureOptions *pressure_options;
628
901
  GimpGradientOptions *gradient_options;
629
902
  GimpGradient        *gradient;
630
903
 
632
905
  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
633
906
  g_return_val_if_fail (color != NULL, FALSE);
634
907
 
635
 
  pressure_options = paint_options->pressure_options;
636
908
  gradient_options = paint_options->gradient_options;
637
909
 
638
910
  gradient = gimp_context_get_gradient (GIMP_CONTEXT (paint_options));
639
911
 
640
 
  if (pressure_options->color)
 
912
  if (paint_options->pressure_options->color ||
 
913
      paint_options->velocity_options->color ||
 
914
      paint_options->random_options->color)
641
915
    {
642
916
      gimp_gradient_get_color_at (gradient, GIMP_CONTEXT (paint_options),
643
 
                                  NULL, pressure,
 
917
                                  NULL, grad_point,
644
918
                                  gradient_options->gradient_reverse,
645
919
                                  color);
646
920
 
658
932
          gradient_length = gradient_options->gradient_length;
659
933
          break;
660
934
        case GIMP_UNIT_PERCENT:
661
 
          gradient_length = (MAX (image->width, image->height) *
 
935
          gradient_length = (MAX (gimp_image_get_width  (image),
 
936
                                  gimp_image_get_height (image)) *
662
937
                             gradient_options->gradient_length / 100);
663
938
          break;
664
939
        default:
665
 
          unit_factor = gimp_unit_get_factor (gradient_options->gradient_unit);
666
 
          gradient_length = (gradient_options->gradient_length *
667
 
                             MAX (image->xresolution,
668
 
                                  image->yresolution) / unit_factor);
 
940
          {
 
941
            gdouble xres;
 
942
            gdouble yres;
 
943
 
 
944
            gimp_image_get_resolution (image, &xres, &yres);
 
945
 
 
946
            unit_factor = gimp_unit_get_factor (gradient_options->gradient_unit);
 
947
            gradient_length = (gradient_options->gradient_length *
 
948
                               MAX (xres, yres) / unit_factor);
 
949
          }
669
950
          break;
670
951
        }
671
952
 
703
984
  if (paint_options->hard)
704
985
    return GIMP_BRUSH_HARD;
705
986
 
706
 
  if (paint_options->pressure_options->hardness)
 
987
  if (paint_options->pressure_options->hardness ||
 
988
      paint_options->velocity_options->hardness ||
 
989
      paint_options->random_options->hardness)
707
990
    return GIMP_BRUSH_PRESSURE;
708
991
 
709
992
  return GIMP_BRUSH_SOFT;
710
993
}
 
994
 
 
995
 
 
996
/* Calculates dynamics mix to be used for same parameter
 
997
 * (velocity/pressure/random) mix Needed in may places and tools.
 
998
 */
 
999
static gdouble
 
1000
gimp_paint_options_get_dynamics_mix (gdouble mix1,
 
1001
                                     gdouble mix1_scale,
 
1002
                                     gdouble mix2,
 
1003
                                     gdouble mix2_scale,
 
1004
                                     gdouble mix3,
 
1005
                                     gdouble mix3_scale)
 
1006
{
 
1007
  gdouble scale_sum = 0.0;
 
1008
  gdouble result    = 1.0;
 
1009
 
 
1010
  if (mix1 >= 0.0)
 
1011
    {
 
1012
      scale_sum += fabs (mix1_scale);
 
1013
    }
 
1014
  else mix1 = 0.0;
 
1015
 
 
1016
  if (mix2 >= 0.0)
 
1017
    {
 
1018
      scale_sum += fabs (mix2_scale);
 
1019
    }
 
1020
  else mix2 = 0.0;
 
1021
 
 
1022
  if (mix3 >= 0.0)
 
1023
    {
 
1024
      scale_sum += fabs (mix3_scale);
 
1025
    }
 
1026
  else mix3 = 0.0;
 
1027
 
 
1028
  if (scale_sum > 0.0)
 
1029
    {
 
1030
      result = (mix1 * mix1_scale) / scale_sum +
 
1031
               (mix2 * mix2_scale) / scale_sum +
 
1032
               (mix3 * mix3_scale) / scale_sum;
 
1033
    }
 
1034
 
 
1035
  if (result < 0.0)
 
1036
    result = 1.0 + result;
 
1037
 
 
1038
  return MAX (0.0, result);
 
1039
}
 
1040
 
 
1041
gdouble
 
1042
gimp_paint_options_get_dynamic_opacity (GimpPaintOptions *paint_options,
 
1043
                                        const GimpCoords *coords)
 
1044
{
 
1045
  gdouble opacity = 1.0;
 
1046
 
 
1047
  g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), 1.0);
 
1048
  g_return_val_if_fail (coords != NULL, 1.0);
 
1049
 
 
1050
  if (paint_options->pressure_options->opacity ||
 
1051
      paint_options->velocity_options->opacity ||
 
1052
      paint_options->random_options->opacity)
 
1053
    {
 
1054
      gdouble pressure = -1.0;
 
1055
      gdouble velocity = -1.0;
 
1056
      gdouble random   = -1.0;
 
1057
 
 
1058
      if (paint_options->pressure_options->opacity)
 
1059
        pressure = GIMP_PAINT_PRESSURE_SCALE * coords->pressure;
 
1060
 
 
1061
      if (paint_options->velocity_options->opacity)
 
1062
        velocity = GIMP_PAINT_VELOCITY_SCALE * (1 - coords->velocity);
 
1063
 
 
1064
      if (paint_options->random_options->opacity)
 
1065
        random = g_random_double_range (0.0, 1.0);
 
1066
 
 
1067
      opacity = gimp_paint_options_get_dynamics_mix (pressure,
 
1068
                                                     paint_options->pressure_options->prescale,
 
1069
                                                     velocity,
 
1070
                                                     paint_options->velocity_options->prescale,
 
1071
                                                     random,
 
1072
                                                     paint_options->random_options->prescale);
 
1073
    }
 
1074
 
 
1075
  return opacity;
 
1076
}
 
1077
 
 
1078
gdouble
 
1079
gimp_paint_options_get_dynamic_size (GimpPaintOptions *paint_options,
 
1080
                                     const GimpCoords *coords,
 
1081
                                     gboolean          use_dynamics)
 
1082
{
 
1083
  gdouble scale = 1.0;
 
1084
 
 
1085
  if (use_dynamics)
 
1086
    {
 
1087
      gdouble pressure = -1.0;
 
1088
      gdouble velocity = -1.0;
 
1089
      gdouble random   = -1.0;
 
1090
 
 
1091
      if (paint_options->pressure_options->size)
 
1092
        {
 
1093
          pressure = coords->pressure;
 
1094
        }
 
1095
      else if (paint_options->pressure_options->inverse_size)
 
1096
        {
 
1097
          pressure = 1.0 - 0.9 * coords->pressure;
 
1098
        }
 
1099
 
 
1100
      if (paint_options->velocity_options->size)
 
1101
        {
 
1102
          velocity = 1.0 - sqrt (coords->velocity);
 
1103
        }
 
1104
      else if (paint_options->velocity_options->inverse_size)
 
1105
        {
 
1106
          velocity = sqrt (coords->velocity);
 
1107
        }
 
1108
 
 
1109
      if (paint_options->random_options->size)
 
1110
        {
 
1111
          random = 1.0 - g_random_double_range (0.0, 1.0);
 
1112
        }
 
1113
      else if (paint_options->random_options->inverse_size)
 
1114
        {
 
1115
          random = g_random_double_range (0.0, 1.0);
 
1116
        }
 
1117
 
 
1118
      scale = gimp_paint_options_get_dynamics_mix (pressure,
 
1119
                                                   paint_options->pressure_options->prescale,
 
1120
                                                   velocity,
 
1121
                                                   paint_options->velocity_options->prescale,
 
1122
                                                   random,
 
1123
                                                   paint_options->random_options->prescale);
 
1124
 
 
1125
      if (scale < 1 / 64.0)
 
1126
        scale = 1 / 8.0;
 
1127
      else
 
1128
        scale = sqrt (scale);
 
1129
    }
 
1130
 
 
1131
  scale *= paint_options->brush_scale;
 
1132
 
 
1133
  return scale;
 
1134
}
 
1135
 
 
1136
 
 
1137
gdouble
 
1138
gimp_paint_options_get_dynamic_rate (GimpPaintOptions *paint_options,
 
1139
                                     const GimpCoords *coords)
 
1140
{
 
1141
  gdouble rate = 1.0;
 
1142
 
 
1143
  g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), 1.0);
 
1144
  g_return_val_if_fail (coords != NULL, 1.0);
 
1145
 
 
1146
  if (paint_options->pressure_options->rate ||
 
1147
      paint_options->velocity_options->rate ||
 
1148
      paint_options->random_options->rate)
 
1149
    {
 
1150
      gdouble pressure = -1.0;
 
1151
      gdouble velocity = -1.0;
 
1152
      gdouble random   = -1.0;
 
1153
 
 
1154
      if (paint_options->pressure_options->rate)
 
1155
        pressure = GIMP_PAINT_PRESSURE_SCALE * coords->pressure;
 
1156
 
 
1157
      if (paint_options->velocity_options->rate)
 
1158
        velocity = GIMP_PAINT_VELOCITY_SCALE * (1 - coords->velocity);
 
1159
 
 
1160
      if (paint_options->random_options->rate)
 
1161
        random = g_random_double_range (0.0, 1.0);
 
1162
 
 
1163
      rate = gimp_paint_options_get_dynamics_mix (pressure,
 
1164
                                                  paint_options->pressure_options->prescale,
 
1165
                                                  velocity,
 
1166
                                                  paint_options->velocity_options->prescale,
 
1167
                                                  random,
 
1168
                                                  paint_options->random_options->prescale);
 
1169
    }
 
1170
 
 
1171
  return rate;
 
1172
}
 
1173
 
 
1174
 
 
1175
gdouble
 
1176
gimp_paint_options_get_dynamic_color (GimpPaintOptions *paint_options,
 
1177
                                      const GimpCoords *coords)
 
1178
{
 
1179
  gdouble color = 1.0;
 
1180
 
 
1181
  g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), 1.0);
 
1182
  g_return_val_if_fail (coords != NULL, 1.0);
 
1183
 
 
1184
  if (paint_options->pressure_options->color ||
 
1185
      paint_options->velocity_options->color ||
 
1186
      paint_options->random_options->color)
 
1187
    {
 
1188
      gdouble pressure = -1.0;
 
1189
      gdouble velocity = -1.0;
 
1190
      gdouble random   = -1.0;
 
1191
 
 
1192
      if (paint_options->pressure_options->color)
 
1193
        pressure = GIMP_PAINT_PRESSURE_SCALE * coords->pressure;
 
1194
 
 
1195
      if (paint_options->velocity_options->color)
 
1196
        velocity = GIMP_PAINT_VELOCITY_SCALE * coords->velocity;
 
1197
 
 
1198
      if (paint_options->random_options->color)
 
1199
        random = g_random_double_range (0.0, 1.0);
 
1200
 
 
1201
      color = gimp_paint_options_get_dynamics_mix (pressure,
 
1202
                                                   paint_options->pressure_options->prescale,
 
1203
                                                   velocity,
 
1204
                                                   paint_options->velocity_options->prescale,
 
1205
                                                   random,
 
1206
                                                   paint_options->random_options->prescale);
 
1207
    }
 
1208
 
 
1209
  return color;
 
1210
}
 
1211
 
 
1212
gdouble
 
1213
gimp_paint_options_get_dynamic_hardness (GimpPaintOptions *paint_options,
 
1214
                                         const GimpCoords *coords)
 
1215
{
 
1216
  gdouble hardness = 1.0;
 
1217
 
 
1218
  g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), 1.0);
 
1219
  g_return_val_if_fail (coords != NULL, 1.0);
 
1220
 
 
1221
  if (paint_options->pressure_options->hardness ||
 
1222
      paint_options->velocity_options->hardness ||
 
1223
      paint_options->random_options->hardness)
 
1224
    {
 
1225
      gdouble pressure = -1.0;
 
1226
      gdouble velocity = -1.0;
 
1227
      gdouble random   = -1.0;
 
1228
 
 
1229
      if (paint_options->pressure_options->hardness)
 
1230
        pressure = GIMP_PAINT_PRESSURE_SCALE * coords->pressure;
 
1231
 
 
1232
      if (paint_options->velocity_options->hardness)
 
1233
        velocity = GIMP_PAINT_VELOCITY_SCALE * (1 - coords->velocity);
 
1234
 
 
1235
      if (paint_options->random_options->hardness)
 
1236
        random = g_random_double_range (0.0, 1.0);
 
1237
 
 
1238
      hardness = gimp_paint_options_get_dynamics_mix (pressure,
 
1239
                                                      paint_options->pressure_options->prescale,
 
1240
                                                      velocity,
 
1241
                                                      paint_options->velocity_options->prescale,
 
1242
                                                      random,
 
1243
                                                      paint_options->random_options->prescale);
 
1244
    }
 
1245
 
 
1246
  return hardness;
 
1247
}