← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gimp/vivid

« back to all changes in this revision

Viewing changes to libgimpwidgets/gimpscaleentry.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-08 18:50:03 UTC
  • mto: (1.1.26) (0.5.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 71.
  • Revision ID: package-import@ubuntu.com-20120508185003-tltkvbaysf8d2426
Import upstream version 2.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgimpwidgets/gimpscaleentry.c
4
4
 * gimpscaleentry.c
5
5
 * Copyright (C) 2000 Michael Natterer <mitch@gimp.org>
6
6
 *
7
 
 * This library is free software; you can redistribute it and/or
 
7
 * This library is free software: you can redistribute it and/or
8
8
 * modify it under the terms of the GNU Lesser General Public
9
9
 * License as published by the Free Software Foundation; either
10
 
 * version 2 of the License, or (at your option) any later version.
 
10
 * version 3 of the License, or (at your option) any later version.
11
11
 *
12
12
 * This library is distributed in the hope that it will be useful,
13
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
15
 * Library General Public License for more details.
16
16
 *
17
17
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with this library; if not, write to the
19
 
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20
 
 * Boston, MA 02111-1307, USA.
 
18
 * License along with this library.  If not, see
 
19
 * <http://www.gnu.org/licenses/>.
21
20
 */
22
21
 
23
22
#include "config.h"
82
81
  g_signal_handlers_block_by_func (other_adj,
83
82
                                   gimp_scale_entry_exp_adjustment_callback,
84
83
                                   adjustment);
85
 
  if (adjustment->lower <= 0.0)
86
 
    value = log (adjustment->value - adjustment->lower + 0.1);
 
84
 
 
85
  if (gtk_adjustment_get_lower (adjustment) <= 0.0)
 
86
    value = log (gtk_adjustment_get_value (adjustment) -
 
87
                 gtk_adjustment_get_lower (adjustment) + 0.1);
87
88
  else
88
 
    value = log (adjustment->value);
 
89
    value = log (gtk_adjustment_get_value (adjustment));
89
90
 
90
91
  gtk_adjustment_set_value (other_adj, value);
91
92
 
105
106
                                   adjustment);
106
107
 
107
108
  value = exp (gtk_adjustment_get_value (adjustment));
108
 
  if (other_adj->lower <= 0.0)
109
 
    value += other_adj->lower  - 0.1;
 
109
  if (gtk_adjustment_get_lower (other_adj) <= 0.0)
 
110
    value += gtk_adjustment_get_lower (other_adj) - 0.1;
110
111
 
111
112
  gtk_adjustment_set_value (other_adj, value);
112
113
 
136
137
                               const gchar *help_id)
137
138
{
138
139
  GtkWidget *label;
139
 
  GtkWidget *ebox;
140
140
  GtkWidget *scale;
141
141
  GtkWidget *spinbutton;
142
142
  GtkObject *adjustment;
144
144
 
145
145
  label = gtk_label_new_with_mnemonic (text);
146
146
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
147
 
 
148
 
  if (tooltip)
149
 
    {
150
 
      ebox = g_object_new (GTK_TYPE_EVENT_BOX,
151
 
                           "visible-window", FALSE,
152
 
                           NULL);
153
 
      gtk_table_attach (GTK_TABLE (table), ebox,
154
 
                        column, column + 1, row, row + 1,
155
 
                        GTK_FILL, GTK_FILL, 0, 0);
156
 
      gtk_widget_show (ebox);
157
 
 
158
 
      gtk_container_add (GTK_CONTAINER (ebox), label);
159
 
    }
160
 
  else
161
 
    {
162
 
      ebox = NULL;
163
 
      gtk_table_attach (GTK_TABLE (table), label,
164
 
                        column, column + 1, row, row + 1,
165
 
                        GTK_FILL, GTK_FILL, 0, 0);
166
 
    }
167
 
 
 
147
  gtk_table_attach (GTK_TABLE (table), label,
 
148
                    column, column + 1, row, row + 1,
 
149
                    GTK_FILL, GTK_FILL, 0, 0);
168
150
  gtk_widget_show (label);
169
151
 
170
152
  if (! constrain &&
226
208
    }
227
209
  else
228
210
    {
229
 
      scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
 
211
      scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
 
212
                             GTK_ADJUSTMENT (adjustment));
230
213
    }
231
214
 
232
215
  if (scale_width > 0)
240
223
 
241
224
  gtk_table_attach (GTK_TABLE (table), spinbutton,
242
225
                    column + 2, column + 3, row, row + 1,
243
 
                    GTK_SHRINK, GTK_SHRINK, 0, 0);
 
226
                    GTK_FILL | GTK_SHRINK, GTK_SHRINK, 0, 0);
244
227
  gtk_widget_show (spinbutton);
245
228
 
246
229
  if (tooltip || help_id)
247
230
    {
248
 
      if (ebox)
249
 
        gimp_help_set_help_data (ebox, tooltip, help_id);
250
 
 
 
231
      gimp_help_set_help_data (label, tooltip, help_id);
251
232
      gimp_help_set_help_data (scale, tooltip, help_id);
252
233
      gimp_help_set_help_data (spinbutton, tooltip, help_id);
253
234
    }
389
370
{
390
371
  GtkAdjustment *adj;
391
372
  GtkAdjustment *scale_adj;
392
 
  gdouble        correction;
393
 
  gdouble        log_value, log_lower, log_upper;
394
 
  gdouble        log_step_increment, log_page_increment;
395
373
 
396
374
  g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
397
375
 
398
376
  adj       = GTK_ADJUSTMENT (adjustment);
399
377
  scale_adj = GIMP_SCALE_ENTRY_SCALE_ADJ (adjustment);
400
378
 
 
379
  if (logarithmic == gimp_scale_entry_get_logarithmic (adjustment))
 
380
    return;
 
381
 
401
382
  if (logarithmic)
402
383
    {
403
 
      if (gimp_scale_entry_get_logarithmic (adjustment))
404
 
        return;
405
 
 
406
 
      correction = scale_adj->lower > 0 ? 0 : 0.1 + - scale_adj->lower;
407
 
 
408
 
      log_value = log (scale_adj->value + correction);
409
 
      log_lower = log (scale_adj->lower + correction);
410
 
      log_upper = log (scale_adj->upper + correction);
411
 
      log_step_increment = (log_upper - log_lower) / ((scale_adj->upper -
412
 
                                                       scale_adj->lower) /
413
 
                                                      scale_adj->step_increment);
414
 
      log_page_increment = (log_upper - log_lower) / ((scale_adj->upper -
415
 
                                                       scale_adj->lower) /
416
 
                                                      scale_adj->page_increment);
 
384
      gdouble correction;
 
385
      gdouble log_value, log_lower, log_upper;
 
386
      gdouble log_step_increment, log_page_increment;
 
387
 
 
388
      correction = (gtk_adjustment_get_lower (scale_adj) > 0 ?
 
389
                    0 : 0.1 + - gtk_adjustment_get_lower (scale_adj));
 
390
 
 
391
      log_value = log (gtk_adjustment_get_value (scale_adj) + correction);
 
392
      log_lower = log (gtk_adjustment_get_lower (scale_adj) + correction);
 
393
      log_upper = log (gtk_adjustment_get_upper (scale_adj) + correction);
 
394
      log_step_increment =
 
395
        (log_upper - log_lower) / ((gtk_adjustment_get_upper (scale_adj) -
 
396
                                    gtk_adjustment_get_lower (scale_adj)) /
 
397
                                   gtk_adjustment_get_step_increment (scale_adj));
 
398
      log_page_increment =
 
399
        (log_upper - log_lower) / ((gtk_adjustment_get_upper (scale_adj) -
 
400
                                    gtk_adjustment_get_lower (scale_adj)) /
 
401
                                   gtk_adjustment_get_page_increment (scale_adj));
417
402
 
418
403
      if (scale_adj == adj)
419
404
        {
420
405
          GtkObject *new_adj;
421
 
          gdouble    lower;
422
 
          gdouble    upper;
423
406
 
424
 
          lower = scale_adj->lower;
425
 
          upper = scale_adj->upper;
426
 
          new_adj = gtk_adjustment_new (scale_adj->value,
427
 
                                        scale_adj->lower,
428
 
                                        scale_adj->upper,
429
 
                                        scale_adj->step_increment,
430
 
                                        scale_adj->page_increment,
 
407
          new_adj = gtk_adjustment_new (gtk_adjustment_get_value (scale_adj),
 
408
                                        gtk_adjustment_get_lower (scale_adj),
 
409
                                        gtk_adjustment_get_upper (scale_adj),
 
410
                                        gtk_adjustment_get_step_increment (scale_adj),
 
411
                                        gtk_adjustment_get_page_increment (scale_adj),
431
412
                                        0.0);
432
413
          gtk_range_set_adjustment (GTK_RANGE (GIMP_SCALE_ENTRY_SCALE (adj)),
433
414
                                    GTK_ADJUSTMENT (new_adj));
434
415
 
435
416
          scale_adj = (GtkAdjustment *) new_adj;
436
 
         }
437
 
       else
438
 
         {
439
 
           g_signal_handlers_disconnect_by_func (adj,
440
 
                                                 G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
441
 
                                                 scale_adj);
442
 
           g_signal_handlers_disconnect_by_func (scale_adj,
443
 
                                                 G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
444
 
                                                 adj);
445
 
         }
446
 
 
447
 
       scale_adj->value          = log_value;
448
 
       scale_adj->lower          = log_lower;
449
 
       scale_adj->upper          = log_upper;
450
 
       scale_adj->step_increment = log_step_increment;
451
 
       scale_adj->page_increment = log_page_increment;
452
 
 
453
 
       g_signal_connect (scale_adj, "value-changed",
454
 
                         G_CALLBACK (gimp_scale_entry_exp_adjustment_callback),
455
 
                         adj);
456
 
 
457
 
       g_signal_connect (adj, "value-changed",
458
 
                         G_CALLBACK (gimp_scale_entry_log_adjustment_callback),
459
 
                         scale_adj);
460
 
 
461
 
       g_object_set_data (G_OBJECT (adjustment),
462
 
                          "logarithmic", GINT_TO_POINTER (TRUE));
 
417
        }
 
418
      else
 
419
        {
 
420
          g_signal_handlers_disconnect_by_func (adj,
 
421
                                                gimp_scale_entry_unconstrained_adjustment_callback,
 
422
                                                scale_adj);
 
423
 
 
424
          g_signal_handlers_disconnect_by_func (scale_adj,
 
425
                                                gimp_scale_entry_unconstrained_adjustment_callback,
 
426
                                                adj);
 
427
        }
 
428
 
 
429
      gtk_adjustment_configure (scale_adj,
 
430
                                log_value, log_lower, log_upper,
 
431
                                log_step_increment, log_page_increment, 0.0);
 
432
 
 
433
      g_signal_connect (scale_adj, "value-changed",
 
434
                        G_CALLBACK (gimp_scale_entry_exp_adjustment_callback),
 
435
                        adj);
 
436
 
 
437
      g_signal_connect (adj, "value-changed",
 
438
                        G_CALLBACK (gimp_scale_entry_log_adjustment_callback),
 
439
                        scale_adj);
 
440
 
 
441
      g_object_set_data (G_OBJECT (adjustment),
 
442
                         "logarithmic", GINT_TO_POINTER (TRUE));
463
443
    }
464
444
  else
465
445
    {
466
446
      gdouble lower, upper;
467
447
 
468
 
      if (! gimp_scale_entry_get_logarithmic (adjustment))
469
 
        return;
470
 
 
471
448
      g_signal_handlers_disconnect_by_func (adj,
472
 
                                            G_CALLBACK (gimp_scale_entry_log_adjustment_callback),
 
449
                                            gimp_scale_entry_log_adjustment_callback,
473
450
                                            scale_adj);
 
451
 
474
452
      g_signal_handlers_disconnect_by_func (scale_adj,
475
 
                                            G_CALLBACK (gimp_scale_entry_exp_adjustment_callback),
 
453
                                            gimp_scale_entry_exp_adjustment_callback,
476
454
                                            adj);
477
455
 
478
 
      lower = exp (scale_adj->lower);
479
 
      upper = exp (scale_adj->upper);
 
456
      lower = exp (gtk_adjustment_get_lower (scale_adj));
 
457
      upper = exp (gtk_adjustment_get_upper (scale_adj));
480
458
 
481
 
      if (adj->lower <= 0.0)
 
459
      if (gtk_adjustment_get_lower (adj) <= 0.0)
482
460
        {
483
 
          lower += - 0.1  + adj->lower;
484
 
          upper += - 0.1  + adj->lower;
 
461
          lower += - 0.1 + gtk_adjustment_get_lower (adj);
 
462
          upper += - 0.1 + gtk_adjustment_get_lower (adj);
485
463
        }
486
464
 
487
 
      scale_adj->value          = adj->value;
488
 
      scale_adj->lower          = lower;
489
 
      scale_adj->upper          = upper;
490
 
      scale_adj->step_increment = adj->step_increment;
491
 
      scale_adj->page_increment = adj->page_increment;
 
465
      gtk_adjustment_configure (scale_adj,
 
466
                                gtk_adjustment_get_value (adj),
 
467
                                lower, upper,
 
468
                                gtk_adjustment_get_step_increment (adj),
 
469
                                gtk_adjustment_get_page_increment (adj),
 
470
                                0.0);
492
471
 
493
472
      g_signal_connect (scale_adj, "value-changed",
494
473
                        G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
526
505
 *              parameter of gtk_widget_set_sensitive()
527
506
 *
528
507
 * Sets the sensitivity of the scale_entry's #GtkLabel, #GtkHScale and
529
 
 * #GtkSpinbutton.
 
508
 * #GtkSpinButton.
530
509
 **/
531
510
void
532
511
gimp_scale_entry_set_sensitive (GtkObject *adjustment,