468
514
g_object_class_install_property (object_class, PROP_GIMP,
469
515
g_param_spec_object ("gimp", NULL, NULL,
517
GIMP_PARAM_READWRITE |
472
518
G_PARAM_CONSTRUCT_ONLY));
474
520
g_object_class_install_property (object_class, PROP_ID,
475
521
g_param_spec_int ("id", NULL, NULL,
523
GIMP_PARAM_READABLE));
479
525
g_object_class_install_property (object_class, PROP_WIDTH,
480
526
g_param_spec_int ("width", NULL, NULL,
481
527
1, GIMP_MAX_IMAGE_SIZE, 1,
528
GIMP_PARAM_READWRITE |
483
529
G_PARAM_CONSTRUCT));
485
531
g_object_class_install_property (object_class, PROP_HEIGHT,
486
532
g_param_spec_int ("height", NULL, NULL,
487
533
1, GIMP_MAX_IMAGE_SIZE, 1,
534
GIMP_PARAM_READWRITE |
489
535
G_PARAM_CONSTRUCT));
491
537
g_object_class_install_property (object_class, PROP_BASE_TYPE,
492
538
g_param_spec_enum ("base-type", NULL, NULL,
493
539
GIMP_TYPE_IMAGE_BASE_TYPE,
541
GIMP_PARAM_READWRITE |
496
542
G_PARAM_CONSTRUCT));
498
544
gimp_image_color_hash_init ();
502
gimp_image_init (GimpImage *gimage)
548
gimp_image_init (GimpImage *image)
508
gimage->save_proc = NULL;
512
gimage->xresolution = 1.0;
513
gimage->yresolution = 1.0;
514
gimage->resolution_unit = GIMP_UNIT_INCH;
515
gimage->base_type = GIMP_RGB;
518
gimage->num_cols = 0;
521
gimage->dirty_time = 0;
522
gimage->undo_freeze_count = 0;
524
gimage->instance_count = 0;
525
gimage->disp_count = 0;
527
gimage->tattoo_state = 0;
529
gimage->shadow = NULL;
531
gimage->projection = gimp_projection_new (gimage);
533
gimage->guides = NULL;
537
gimage->layers = gimp_list_new (GIMP_TYPE_LAYER, TRUE);
538
gimage->channels = gimp_list_new (GIMP_TYPE_CHANNEL, TRUE);
539
gimage->vectors = gimp_list_new (GIMP_TYPE_VECTORS, TRUE);
540
gimage->layer_stack = NULL;
542
gimage->layer_update_handler =
543
gimp_container_add_handler (gimage->layers, "update",
554
image->save_proc = NULL;
558
image->xresolution = 1.0;
559
image->yresolution = 1.0;
560
image->resolution_unit = GIMP_UNIT_INCH;
561
image->base_type = GIMP_RGB;
567
image->dirty_time = 0;
568
image->undo_freeze_count = 0;
570
image->instance_count = 0;
571
image->disp_count = 0;
573
image->tattoo_state = 0;
575
image->shadow = NULL;
577
image->projection = gimp_projection_new (image);
579
image->guides = NULL;
581
image->sample_points = NULL;
583
image->layers = gimp_list_new (GIMP_TYPE_LAYER, TRUE);
584
image->channels = gimp_list_new (GIMP_TYPE_CHANNEL, TRUE);
585
image->vectors = gimp_list_new (GIMP_TYPE_VECTORS, TRUE);
586
image->layer_stack = NULL;
588
image->layer_update_handler =
589
gimp_container_add_handler (image->layers, "update",
544
590
G_CALLBACK (gimp_image_drawable_update),
546
gimage->layer_visible_handler =
547
gimp_container_add_handler (gimage->layers, "visibility_changed",
592
image->layer_visible_handler =
593
gimp_container_add_handler (image->layers, "visibility-changed",
548
594
G_CALLBACK (gimp_image_drawable_visibility),
550
gimage->layer_alpha_handler =
551
gimp_container_add_handler (gimage->layers, "alpha_changed",
596
image->layer_alpha_handler =
597
gimp_container_add_handler (image->layers, "alpha-changed",
552
598
G_CALLBACK (gimp_image_layer_alpha_changed),
555
gimage->channel_update_handler =
556
gimp_container_add_handler (gimage->channels, "update",
601
image->channel_update_handler =
602
gimp_container_add_handler (image->channels, "update",
557
603
G_CALLBACK (gimp_image_drawable_update),
559
gimage->channel_visible_handler =
560
gimp_container_add_handler (gimage->channels, "visibility_changed",
605
image->channel_visible_handler =
606
gimp_container_add_handler (image->channels, "visibility-changed",
561
607
G_CALLBACK (gimp_image_drawable_visibility),
563
gimage->channel_name_changed_handler =
564
gimp_container_add_handler (gimage->channels, "name_changed",
609
image->channel_name_changed_handler =
610
gimp_container_add_handler (image->channels, "name-changed",
565
611
G_CALLBACK (gimp_image_channel_name_changed),
567
gimage->channel_color_changed_handler =
568
gimp_container_add_handler (gimage->channels, "color_changed",
613
image->channel_color_changed_handler =
614
gimp_container_add_handler (image->channels, "color-changed",
569
615
G_CALLBACK (gimp_image_channel_color_changed),
572
g_signal_connect (gimage->layers, "add",
618
g_signal_connect (image->layers, "add",
573
619
G_CALLBACK (gimp_image_layer_add),
575
g_signal_connect (gimage->layers, "remove",
621
g_signal_connect (image->layers, "remove",
576
622
G_CALLBACK (gimp_image_layer_remove),
579
g_signal_connect (gimage->channels, "add",
625
g_signal_connect (image->channels, "add",
580
626
G_CALLBACK (gimp_image_channel_add),
582
g_signal_connect (gimage->channels, "remove",
628
g_signal_connect (image->channels, "remove",
583
629
G_CALLBACK (gimp_image_channel_remove),
586
gimage->active_layer = NULL;
587
gimage->active_channel = NULL;
588
gimage->active_vectors = NULL;
590
gimage->floating_sel = NULL;
591
gimage->selection_mask = NULL;
593
gimage->parasites = gimp_parasite_list_new ();
632
image->active_layer = NULL;
633
image->active_channel = NULL;
634
image->active_vectors = NULL;
636
image->floating_sel = NULL;
637
image->selection_mask = NULL;
639
image->parasites = gimp_parasite_list_new ();
595
641
for (i = 0; i < MAX_CHANNELS; i++)
597
gimage->visible[i] = TRUE;
598
gimage->active[i] = TRUE;
643
image->visible[i] = TRUE;
644
image->active[i] = TRUE;
601
gimage->qmask_state = FALSE;
602
gimage->qmask_inverted = FALSE;
603
gimp_rgba_set (&gimage->qmask_color, 1.0, 0.0, 0.0, 0.5);
605
gimage->undo_stack = gimp_undo_stack_new (gimage);
606
gimage->redo_stack = gimp_undo_stack_new (gimage);
607
gimage->group_count = 0;
608
gimage->pushing_undo_group = GIMP_UNDO_GROUP_NONE;
610
gimage->comp_preview = NULL;
611
gimage->comp_preview_valid = FALSE;
613
gimage->flush_accum.alpha_changed = FALSE;
614
gimage->flush_accum.mask_changed = FALSE;
647
image->quick_mask_state = FALSE;
648
image->quick_mask_inverted = FALSE;
649
gimp_rgba_set (&image->quick_mask_color, 1.0, 0.0, 0.0, 0.5);
651
image->undo_stack = gimp_undo_stack_new (image);
652
image->redo_stack = gimp_undo_stack_new (image);
653
image->group_count = 0;
654
image->pushing_undo_group = GIMP_UNDO_GROUP_NONE;
656
image->comp_preview = NULL;
657
image->comp_preview_valid = FALSE;
659
image->flush_accum.alpha_changed = FALSE;
660
image->flush_accum.mask_changed = FALSE;
620
666
GObjectConstructParam *params)
624
670
GimpCoreConfig *config;
626
672
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
628
gimage = GIMP_IMAGE (object);
630
g_assert (GIMP_IS_GIMP (gimage->gimp));
632
config = gimage->gimp->config;
634
gimage->ID = gimage->gimp->next_image_ID++;
636
g_hash_table_insert (gimage->gimp->image_table,
637
GINT_TO_POINTER (gimage->ID),
640
gimage->xresolution = config->default_image->xresolution;
641
gimage->yresolution = config->default_image->yresolution;
642
gimage->resolution_unit = config->default_image->resolution_unit;
644
gimage->grid = gimp_config_duplicate (GIMP_CONFIG (config->default_grid));
646
switch (gimage->base_type)
674
image = GIMP_IMAGE (object);
676
g_assert (GIMP_IS_GIMP (image->gimp));
678
config = image->gimp->config;
682
image->ID = image->gimp->next_image_ID++;
684
if (image->gimp->next_image_ID == G_MAXINT)
685
image->gimp->next_image_ID = 1;
687
while (g_hash_table_lookup (image->gimp->image_table,
688
GINT_TO_POINTER (image->ID)));
690
g_hash_table_insert (image->gimp->image_table,
691
GINT_TO_POINTER (image->ID),
694
image->xresolution = config->default_image->xresolution;
695
image->yresolution = config->default_image->yresolution;
696
image->resolution_unit = config->default_image->resolution_unit;
698
image->grid = gimp_config_duplicate (GIMP_CONFIG (config->default_grid));
700
switch (image->base_type)
651
705
case GIMP_INDEXED:
652
706
/* always allocate 256 colors for the colormap */
653
gimage->num_cols = 0;
654
gimage->cmap = g_new0 (guchar, GIMP_IMAGE_COLORMAP_SIZE);
708
image->cmap = g_new0 (guchar, GIMP_IMAGE_COLORMAP_SIZE);
660
714
/* create the selection mask */
661
gimage->selection_mask = gimp_selection_new (gimage,
664
g_object_ref (gimage->selection_mask);
665
gimp_item_sink (GIMP_ITEM (gimage->selection_mask));
715
image->selection_mask = gimp_selection_new (image,
718
g_object_ref_sink (image->selection_mask);
667
g_signal_connect (gimage->selection_mask, "update",
720
g_signal_connect (image->selection_mask, "update",
668
721
G_CALLBACK (gimp_image_mask_update),
671
724
g_signal_connect_object (config, "notify::transparency-type",
672
725
G_CALLBACK (gimp_image_invalidate_layer_previews),
673
gimage, G_CONNECT_SWAPPED);
726
image, G_CONNECT_SWAPPED);
674
727
g_signal_connect_object (config, "notify::transparency-size",
675
728
G_CALLBACK (gimp_image_invalidate_layer_previews),
676
gimage, G_CONNECT_SWAPPED);
729
image, G_CONNECT_SWAPPED);
677
730
g_signal_connect_object (config, "notify::layer-previews",
678
731
G_CALLBACK (gimp_viewable_size_changed),
679
gimage, G_CONNECT_SWAPPED);
732
image, G_CONNECT_SWAPPED);
734
gimp_container_add (image->gimp->images, GIMP_OBJECT (image));
747
802
gimp_image_dispose (GObject *object)
749
GimpImage *gimage = GIMP_IMAGE (object);
751
gimp_image_undo_free (gimage);
753
gimp_container_remove_handler (gimage->layers,
754
gimage->layer_update_handler);
755
gimp_container_remove_handler (gimage->layers,
756
gimage->layer_visible_handler);
757
gimp_container_remove_handler (gimage->layers,
758
gimage->layer_alpha_handler);
760
gimp_container_remove_handler (gimage->channels,
761
gimage->channel_update_handler);
762
gimp_container_remove_handler (gimage->channels,
763
gimage->channel_visible_handler);
764
gimp_container_remove_handler (gimage->channels,
765
gimage->channel_name_changed_handler);
766
gimp_container_remove_handler (gimage->channels,
767
gimage->channel_color_changed_handler);
769
g_signal_handlers_disconnect_by_func (gimage->layers,
804
GimpImage *image = GIMP_IMAGE (object);
806
gimp_image_undo_free (image);
808
gimp_container_remove_handler (image->layers,
809
image->layer_update_handler);
810
gimp_container_remove_handler (image->layers,
811
image->layer_visible_handler);
812
gimp_container_remove_handler (image->layers,
813
image->layer_alpha_handler);
815
gimp_container_remove_handler (image->channels,
816
image->channel_update_handler);
817
gimp_container_remove_handler (image->channels,
818
image->channel_visible_handler);
819
gimp_container_remove_handler (image->channels,
820
image->channel_name_changed_handler);
821
gimp_container_remove_handler (image->channels,
822
image->channel_color_changed_handler);
824
g_signal_handlers_disconnect_by_func (image->layers,
770
825
gimp_image_layer_add,
772
g_signal_handlers_disconnect_by_func (gimage->layers,
827
g_signal_handlers_disconnect_by_func (image->layers,
773
828
gimp_image_layer_remove,
776
g_signal_handlers_disconnect_by_func (gimage->channels,
831
g_signal_handlers_disconnect_by_func (image->channels,
777
832
gimp_image_channel_add,
779
g_signal_handlers_disconnect_by_func (gimage->channels,
834
g_signal_handlers_disconnect_by_func (image->channels,
780
835
gimp_image_channel_remove,
783
gimp_container_foreach (gimage->layers, (GFunc) gimp_item_removed, NULL);
784
gimp_container_foreach (gimage->channels, (GFunc) gimp_item_removed, NULL);
785
gimp_container_foreach (gimage->vectors, (GFunc) gimp_item_removed, NULL);
838
gimp_container_foreach (image->layers, (GFunc) gimp_item_removed, NULL);
839
gimp_container_foreach (image->channels, (GFunc) gimp_item_removed, NULL);
840
gimp_container_foreach (image->vectors, (GFunc) gimp_item_removed, NULL);
787
842
G_OBJECT_CLASS (parent_class)->dispose (object);
791
846
gimp_image_finalize (GObject *object)
793
GimpImage *gimage = GIMP_IMAGE (object);
795
if (gimage->projection)
797
g_object_unref (gimage->projection);
798
gimage->projection = NULL;
802
gimp_image_free_shadow (gimage);
806
g_free (gimage->cmap);
812
g_object_unref (gimage->layers);
813
gimage->layers = NULL;
815
if (gimage->channels)
817
g_object_unref (gimage->channels);
818
gimage->channels = NULL;
822
g_object_unref (gimage->vectors);
823
gimage->vectors = NULL;
825
if (gimage->layer_stack)
827
g_slist_free (gimage->layer_stack);
828
gimage->layer_stack = NULL;
831
if (gimage->selection_mask)
833
g_object_unref (gimage->selection_mask);
834
gimage->selection_mask = NULL;
837
if (gimage->comp_preview)
839
temp_buf_free (gimage->comp_preview);
840
gimage->comp_preview = NULL;
843
if (gimage->parasites)
845
g_object_unref (gimage->parasites);
846
gimage->parasites = NULL;
851
g_list_foreach (gimage->guides, (GFunc) gimp_image_guide_unref, NULL);
852
g_list_free (gimage->guides);
853
gimage->guides = NULL;
858
g_object_unref (gimage->grid);
862
if (gimage->undo_stack)
864
g_object_unref (gimage->undo_stack);
865
gimage->undo_stack = NULL;
867
if (gimage->redo_stack)
869
g_object_unref (gimage->redo_stack);
870
gimage->redo_stack = NULL;
873
if (gimage->gimp && gimage->gimp->image_table)
875
g_hash_table_remove (gimage->gimp->image_table,
876
GINT_TO_POINTER (gimage->ID));
848
GimpImage *image = GIMP_IMAGE (object);
850
if (image->projection)
852
g_object_unref (image->projection);
853
image->projection = NULL;
857
gimp_image_free_shadow_tiles (image);
861
g_free (image->cmap);
867
g_object_unref (image->layers);
868
image->layers = NULL;
872
g_object_unref (image->channels);
873
image->channels = NULL;
877
g_object_unref (image->vectors);
878
image->vectors = NULL;
880
if (image->layer_stack)
882
g_slist_free (image->layer_stack);
883
image->layer_stack = NULL;
886
if (image->selection_mask)
888
g_object_unref (image->selection_mask);
889
image->selection_mask = NULL;
892
if (image->comp_preview)
894
temp_buf_free (image->comp_preview);
895
image->comp_preview = NULL;
898
if (image->parasites)
900
g_object_unref (image->parasites);
901
image->parasites = NULL;
906
g_list_foreach (image->guides, (GFunc) g_object_unref, NULL);
907
g_list_free (image->guides);
908
image->guides = NULL;
913
g_object_unref (image->grid);
917
if (image->sample_points)
919
g_list_foreach (image->sample_points,
920
(GFunc) gimp_sample_point_unref, NULL);
921
g_list_free (image->sample_points);
922
image->sample_points = NULL;
925
if (image->undo_stack)
927
g_object_unref (image->undo_stack);
928
image->undo_stack = NULL;
930
if (image->redo_stack)
932
g_object_unref (image->redo_stack);
933
image->redo_stack = NULL;
936
if (image->gimp && image->gimp->image_table)
938
g_hash_table_remove (image->gimp->image_table,
939
GINT_TO_POINTER (image->ID));
880
943
G_OBJECT_CLASS (parent_class)->finalize (object);
901
964
gimp_image_get_memsize (GimpObject *object,
902
965
gint64 *gui_size)
904
GimpImage *gimage = GIMP_IMAGE (object);
967
GimpImage *image = GIMP_IMAGE (object);
905
968
gint64 memsize = 0;
908
971
memsize += GIMP_IMAGE_COLORMAP_SIZE;
911
memsize += tile_manager_get_memsize (gimage->shadow, FALSE);
913
if (gimage->projection)
914
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->projection),
917
memsize += gimp_g_list_get_memsize (gimage->guides, sizeof (GimpGuide));
920
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->grid), gui_size);
922
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->layers),
924
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->channels),
926
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->vectors),
929
memsize += gimp_g_slist_get_memsize (gimage->layer_stack, 0);
931
if (gimage->selection_mask)
932
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->selection_mask),
935
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->parasites),
938
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->undo_stack),
940
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimage->redo_stack),
943
if (gimage->comp_preview)
944
*gui_size += temp_buf_get_memsize (gimage->comp_preview);
974
memsize += tile_manager_get_memsize (image->shadow, FALSE);
976
if (image->projection)
977
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->projection),
980
memsize += gimp_g_list_get_memsize (image->guides, sizeof (GimpGuide));
983
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->grid), gui_size);
985
memsize += gimp_g_list_get_memsize (image->sample_points,
986
sizeof (GimpSamplePoint));
988
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->layers),
990
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->channels),
992
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->vectors),
995
memsize += gimp_g_slist_get_memsize (image->layer_stack, 0);
997
if (image->selection_mask)
998
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->selection_mask),
1001
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->parasites),
1004
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->undo_stack),
1006
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->redo_stack),
1009
if (image->comp_preview)
1010
*gui_size += temp_buf_get_memsize (image->comp_preview);
946
1012
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
1017
gimp_image_get_size (GimpViewable *viewable,
1021
GimpImage *image = GIMP_IMAGE (viewable);
1023
*width = image->width;
1024
*height = image->height;
951
1030
gimp_image_invalidate_preview (GimpViewable *viewable)
953
GimpImage *gimage = GIMP_IMAGE (viewable);
1032
GimpImage *image = GIMP_IMAGE (viewable);
955
1034
if (GIMP_VIEWABLE_CLASS (parent_class)->invalidate_preview)
956
1035
GIMP_VIEWABLE_CLASS (parent_class)->invalidate_preview (viewable);
958
gimage->comp_preview_valid = FALSE;
1037
image->comp_preview_valid = FALSE;
960
if (gimage->comp_preview)
1039
if (image->comp_preview)
962
temp_buf_free (gimage->comp_preview);
963
gimage->comp_preview = NULL;
1041
temp_buf_free (image->comp_preview);
1042
image->comp_preview = NULL;
968
1047
gimp_image_size_changed (GimpViewable *viewable)
970
GimpImage *gimage = GIMP_IMAGE (viewable);
1049
GimpImage *image = GIMP_IMAGE (viewable);
973
1052
if (GIMP_VIEWABLE_CLASS (parent_class)->size_changed)
974
1053
GIMP_VIEWABLE_CLASS (parent_class)->size_changed (viewable);
976
gimp_container_foreach (gimage->layers,
977
(GFunc) gimp_viewable_size_changed,
979
gimp_container_foreach (gimage->channels,
980
(GFunc) gimp_viewable_size_changed,
982
gimp_container_foreach (gimage->vectors,
1055
gimp_container_foreach (image->layers,
1056
(GFunc) gimp_viewable_size_changed,
1058
gimp_container_foreach (image->channels,
1059
(GFunc) gimp_viewable_size_changed,
1061
gimp_container_foreach (image->vectors,
983
1062
(GFunc) gimp_viewable_size_changed,
986
for (list = GIMP_LIST (gimage->layers)->list; list; list = g_list_next (list))
1065
for (list = GIMP_LIST (image->layers)->list; list; list = g_list_next (list))
988
1067
GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (list->data));
1082
gimp_image_update (gimage, x, y, width, height);
1083
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
1161
gimp_image_update (image, x, y, width, height);
1162
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image));
1088
1167
gimp_image_drawable_visibility (GimpItem *item,
1094
1173
gimp_item_offsets (item, &offset_x, &offset_y);
1096
gimp_image_update (gimage,
1175
gimp_image_update (image,
1097
1176
offset_x, offset_y,
1098
1177
gimp_item_width (item),
1099
1178
gimp_item_height (item));
1100
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
1179
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image));
1104
1183
gimp_image_layer_alpha_changed (GimpDrawable *drawable,
1107
if (gimp_container_num_children (gimage->layers) == 1)
1108
gimage->flush_accum.alpha_changed = TRUE;
1186
if (gimp_container_num_children (image->layers) == 1)
1187
image->flush_accum.alpha_changed = TRUE;
1112
1191
gimp_image_layer_add (GimpContainer *container,
1113
1192
GimpLayer *layer,
1116
1195
GimpItem *item = GIMP_ITEM (layer);
1118
1197
if (gimp_item_get_visible (item))
1119
gimp_image_drawable_visibility (item, gimage);
1198
gimp_image_drawable_visibility (item, image);
1123
1202
gimp_image_layer_remove (GimpContainer *container,
1124
1203
GimpLayer *layer,
1127
1206
GimpItem *item = GIMP_ITEM (layer);
1129
1208
if (gimp_item_get_visible (item))
1130
gimp_image_drawable_visibility (item, gimage);
1209
gimp_image_drawable_visibility (item, image);
1134
1213
gimp_image_channel_add (GimpContainer *container,
1135
1214
GimpChannel *channel,
1138
1217
GimpItem *item = GIMP_ITEM (channel);
1140
1219
if (gimp_item_get_visible (item))
1141
gimp_image_drawable_visibility (item, gimage);
1220
gimp_image_drawable_visibility (item, image);
1143
if (! strcmp (GIMP_IMAGE_QMASK_NAME,
1222
if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1144
1223
gimp_object_get_name (GIMP_OBJECT (channel))))
1146
gimp_image_set_qmask_state (gimage, TRUE);
1225
gimp_image_set_quick_mask_state (image, TRUE);
1151
1230
gimp_image_channel_remove (GimpContainer *container,
1152
1231
GimpChannel *channel,
1155
1234
GimpItem *item = GIMP_ITEM (channel);
1157
1236
if (gimp_item_get_visible (item))
1158
gimp_image_drawable_visibility (item, gimage);
1237
gimp_image_drawable_visibility (item, image);
1160
if (! strcmp (GIMP_IMAGE_QMASK_NAME,
1239
if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1161
1240
gimp_object_get_name (GIMP_OBJECT (channel))))
1163
gimp_image_set_qmask_state (gimage, FALSE);
1242
gimp_image_set_quick_mask_state (image, FALSE);
1168
1247
gimp_image_channel_name_changed (GimpChannel *channel,
1171
if (! strcmp (GIMP_IMAGE_QMASK_NAME,
1250
if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1172
1251
gimp_object_get_name (GIMP_OBJECT (channel))))
1174
gimp_image_set_qmask_state (gimage, TRUE);
1253
gimp_image_set_quick_mask_state (image, TRUE);
1176
else if (gimp_image_get_qmask_state (gimage) &&
1177
! gimp_image_get_qmask (gimage))
1255
else if (gimp_image_get_quick_mask_state (image) &&
1256
! gimp_image_get_quick_mask (image))
1179
gimp_image_set_qmask_state (gimage, FALSE);
1258
gimp_image_set_quick_mask_state (image, FALSE);
1184
1263
gimp_image_channel_color_changed (GimpChannel *channel,
1187
if (! strcmp (GIMP_IMAGE_QMASK_NAME,
1266
if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1188
1267
gimp_object_get_name (GIMP_OBJECT (channel))))
1190
gimage->qmask_color = channel->color;
1269
image->quick_mask_color = channel->color;
1327
gimp_image_set_save_proc (GimpImage *gimage,
1328
PlugInProcDef *proc)
1409
gimp_image_set_save_proc (GimpImage *image,
1410
GimpPlugInProcedure *proc)
1330
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1412
g_return_if_fail (GIMP_IS_IMAGE (image));
1332
gimage->save_proc = proc;
1414
image->save_proc = proc;
1336
gimp_image_get_save_proc (const GimpImage *gimage)
1417
GimpPlugInProcedure *
1418
gimp_image_get_save_proc (const GimpImage *image)
1338
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
1420
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
1340
return gimage->save_proc;
1422
return image->save_proc;
1344
gimp_image_set_resolution (GimpImage *gimage,
1426
gimp_image_set_resolution (GimpImage *image,
1345
1427
gdouble xresolution,
1346
1428
gdouble yresolution)
1348
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1430
g_return_if_fail (GIMP_IS_IMAGE (image));
1350
1432
/* don't allow to set the resolution out of bounds */
1351
1433
if (xresolution < GIMP_MIN_RESOLUTION || xresolution > GIMP_MAX_RESOLUTION ||
1352
1434
yresolution < GIMP_MIN_RESOLUTION || yresolution > GIMP_MAX_RESOLUTION)
1355
if ((ABS (gimage->xresolution - xresolution) >= 1e-5) ||
1356
(ABS (gimage->yresolution - yresolution) >= 1e-5))
1437
if ((ABS (image->xresolution - xresolution) >= 1e-5) ||
1438
(ABS (image->yresolution - yresolution) >= 1e-5))
1358
gimp_image_undo_push_image_resolution (gimage,
1440
gimp_image_undo_push_image_resolution (image,
1359
1441
_("Change Image Resolution"));
1361
gimage->xresolution = xresolution;
1362
gimage->yresolution = yresolution;
1443
image->xresolution = xresolution;
1444
image->yresolution = yresolution;
1364
gimp_image_resolution_changed (gimage);
1365
gimp_viewable_size_changed (GIMP_VIEWABLE (gimage));
1446
gimp_image_resolution_changed (image);
1447
gimp_viewable_size_changed (GIMP_VIEWABLE (image));
1370
gimp_image_get_resolution (const GimpImage *gimage,
1452
gimp_image_get_resolution (const GimpImage *image,
1371
1453
gdouble *xresolution,
1372
1454
gdouble *yresolution)
1374
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1456
g_return_if_fail (GIMP_IS_IMAGE (image));
1375
1457
g_return_if_fail (xresolution && yresolution);
1377
*xresolution = gimage->xresolution;
1378
*yresolution = gimage->yresolution;
1459
*xresolution = image->xresolution;
1460
*yresolution = image->yresolution;
1382
gimp_image_resolution_changed (GimpImage *gimage)
1464
gimp_image_resolution_changed (GimpImage *image)
1384
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1466
g_return_if_fail (GIMP_IS_IMAGE (image));
1386
g_signal_emit (gimage, gimp_image_signals[RESOLUTION_CHANGED], 0);
1468
g_signal_emit (image, gimp_image_signals[RESOLUTION_CHANGED], 0);
1390
gimp_image_set_unit (GimpImage *gimage,
1472
gimp_image_set_unit (GimpImage *image,
1393
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1475
g_return_if_fail (GIMP_IS_IMAGE (image));
1394
1476
g_return_if_fail (unit > GIMP_UNIT_PIXEL);
1396
if (gimage->resolution_unit != unit)
1478
if (image->resolution_unit != unit)
1398
gimp_image_undo_push_image_resolution (gimage,
1480
gimp_image_undo_push_image_resolution (image,
1399
1481
_("Change Image Unit"));
1401
gimage->resolution_unit = unit;
1402
gimp_image_unit_changed (gimage);
1483
image->resolution_unit = unit;
1484
gimp_image_unit_changed (image);
1407
gimp_image_get_unit (const GimpImage *gimage)
1489
gimp_image_get_unit (const GimpImage *image)
1409
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), GIMP_UNIT_INCH);
1491
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_UNIT_INCH);
1411
return gimage->resolution_unit;
1493
return image->resolution_unit;
1415
gimp_image_unit_changed (GimpImage *gimage)
1417
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1419
g_signal_emit (gimage, gimp_image_signals[UNIT_CHANGED], 0);
1423
gimp_image_get_width (const GimpImage *gimage)
1425
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 0);
1427
return gimage->width;
1431
gimp_image_get_height (const GimpImage *gimage)
1433
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 0);
1435
return gimage->height;
1497
gimp_image_unit_changed (GimpImage *image)
1499
g_return_if_fail (GIMP_IS_IMAGE (image));
1501
g_signal_emit (image, gimp_image_signals[UNIT_CHANGED], 0);
1505
gimp_image_get_width (const GimpImage *image)
1507
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
1509
return image->width;
1513
gimp_image_get_height (const GimpImage *image)
1515
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
1517
return image->height;
1439
gimp_image_has_alpha (const GimpImage *gimage)
1521
gimp_image_has_alpha (const GimpImage *image)
1441
1523
GimpLayer *layer;
1443
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), TRUE);
1445
layer = (GimpLayer *) gimp_container_get_child_by_index (gimage->layers, 0);
1447
return ((gimp_container_num_children (gimage->layers) > 1) ||
1525
g_return_val_if_fail (GIMP_IS_IMAGE (image), TRUE);
1527
layer = (GimpLayer *) gimp_container_get_child_by_index (image->layers, 0);
1529
return ((gimp_container_num_children (image->layers) > 1) ||
1448
1530
(layer && gimp_drawable_has_alpha (GIMP_DRAWABLE (layer))));
1452
gimp_image_is_empty (const GimpImage *gimage)
1534
gimp_image_is_empty (const GimpImage *image)
1454
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), TRUE);
1536
g_return_val_if_fail (GIMP_IS_IMAGE (image), TRUE);
1456
return (gimp_container_num_children (gimage->layers) == 0);
1538
return gimp_container_is_empty (image->layers);
1460
gimp_image_floating_sel (const GimpImage *gimage)
1542
gimp_image_floating_sel (const GimpImage *image)
1462
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
1544
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
1464
return gimage->floating_sel;
1546
return image->floating_sel;
1468
gimp_image_floating_selection_changed (GimpImage *gimage)
1550
gimp_image_floating_selection_changed (GimpImage *image)
1470
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1552
g_return_if_fail (GIMP_IS_IMAGE (image));
1472
g_signal_emit (gimage, gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
1554
g_signal_emit (image, gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
1476
gimp_image_get_mask (const GimpImage *gimage)
1558
gimp_image_get_mask (const GimpImage *image)
1478
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
1560
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
1480
return gimage->selection_mask;
1562
return image->selection_mask;
1484
gimp_image_mask_changed (GimpImage *gimage)
1566
gimp_image_mask_changed (GimpImage *image)
1486
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1568
g_return_if_fail (GIMP_IS_IMAGE (image));
1488
g_signal_emit (gimage, gimp_image_signals[MASK_CHANGED], 0);
1570
g_signal_emit (image, gimp_image_signals[MASK_CHANGED], 0);
1492
gimp_image_get_component_index (const GimpImage *gimage,
1574
gimp_image_get_component_index (const GimpImage *image,
1493
1575
GimpChannelType channel)
1495
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), -1);
1577
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
1497
1579
switch (channel)
1517
gimp_image_set_component_active (GimpImage *gimage,
1599
gimp_image_set_component_active (GimpImage *image,
1518
1600
GimpChannelType channel,
1519
1601
gboolean active)
1521
1603
gint index = -1;
1523
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1525
index = gimp_image_get_component_index (gimage, channel);
1527
if (index != -1 && active != gimage->active[index])
1605
g_return_if_fail (GIMP_IS_IMAGE (image));
1607
index = gimp_image_get_component_index (image, channel);
1609
if (index != -1 && active != image->active[index])
1529
gimage->active[index] = active ? TRUE : FALSE;
1611
GimpLayer *floating_sel = gimp_image_floating_sel (image);
1614
floating_sel_relax (floating_sel, FALSE);
1616
image->active[index] = active ? TRUE : FALSE;
1620
floating_sel_rigor (floating_sel, FALSE);
1621
gimp_drawable_update (GIMP_DRAWABLE (floating_sel),
1623
GIMP_ITEM (floating_sel)->width,
1624
GIMP_ITEM (floating_sel)->height);
1531
1627
/* If there is an active channel and we mess with the components,
1532
1628
* the active channel gets unset...
1534
gimp_image_unset_active_channel (gimage);
1630
gimp_image_unset_active_channel (image);
1536
g_signal_emit (gimage,
1632
g_signal_emit (image,
1537
1633
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
1543
gimp_image_get_component_active (const GimpImage *gimage,
1639
gimp_image_get_component_active (const GimpImage *image,
1544
1640
GimpChannelType channel)
1546
1642
gint index = -1;
1548
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1644
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1550
index = gimp_image_get_component_index (gimage, channel);
1646
index = gimp_image_get_component_index (image, channel);
1552
1648
if (index != -1)
1553
return gimage->active[index];
1649
return image->active[index];
1559
gimp_image_set_component_visible (GimpImage *gimage,
1655
gimp_image_set_component_visible (GimpImage *image,
1560
1656
GimpChannelType channel,
1561
1657
gboolean visible)
1563
1659
gint index = -1;
1565
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1567
index = gimp_image_get_component_index (gimage, channel);
1569
if (index != -1 && visible != gimage->visible[index])
1661
g_return_if_fail (GIMP_IS_IMAGE (image));
1663
index = gimp_image_get_component_index (image, channel);
1665
if (index != -1 && visible != image->visible[index])
1571
gimage->visible[index] = visible ? TRUE : FALSE;
1667
image->visible[index] = visible ? TRUE : FALSE;
1573
g_signal_emit (gimage,
1669
g_signal_emit (image,
1574
1670
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
1577
gimp_image_update (gimage, 0, 0, gimage->width, gimage->height);
1578
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
1673
gimp_image_update (image, 0, 0, image->width, image->height);
1674
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image));
1583
gimp_image_get_component_visible (const GimpImage *gimage,
1679
gimp_image_get_component_visible (const GimpImage *image,
1584
1680
GimpChannelType channel)
1586
1682
gint index = -1;
1588
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1684
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1590
index = gimp_image_get_component_index (gimage, channel);
1686
index = gimp_image_get_component_index (image, channel);
1592
1688
if (index != -1)
1593
return gimage->visible[index];
1689
return image->visible[index];
1599
gimp_image_mode_changed (GimpImage *gimage)
1601
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1603
g_signal_emit (gimage, gimp_image_signals[MODE_CHANGED], 0);
1607
gimp_image_alpha_changed (GimpImage *gimage)
1609
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1611
g_signal_emit (gimage, gimp_image_signals[ALPHA_CHANGED], 0);
1615
gimp_image_update (GimpImage *gimage,
1695
gimp_image_mode_changed (GimpImage *image)
1697
g_return_if_fail (GIMP_IS_IMAGE (image));
1699
g_signal_emit (image, gimp_image_signals[MODE_CHANGED], 0);
1703
gimp_image_alpha_changed (GimpImage *image)
1705
g_return_if_fail (GIMP_IS_IMAGE (image));
1707
g_signal_emit (image, gimp_image_signals[ALPHA_CHANGED], 0);
1711
gimp_image_update (GimpImage *image,
1621
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1717
g_return_if_fail (GIMP_IS_IMAGE (image));
1623
g_signal_emit (gimage, gimp_image_signals[UPDATE], 0,
1719
g_signal_emit (image, gimp_image_signals[UPDATE], 0,
1624
1720
x, y, width, height);
1628
gimp_image_update_guide (GimpImage *gimage,
1724
gimp_image_update_guide (GimpImage *image,
1629
1725
GimpGuide *guide)
1631
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1727
g_return_if_fail (GIMP_IS_IMAGE (image));
1632
1728
g_return_if_fail (guide != NULL);
1634
g_signal_emit (gimage, gimp_image_signals[UPDATE_GUIDE], 0, guide);
1638
gimp_image_colormap_changed (GimpImage *gimage,
1730
g_signal_emit (image, gimp_image_signals[UPDATE_GUIDE], 0, guide);
1734
gimp_image_update_sample_point (GimpImage *image,
1735
GimpSamplePoint *sample_point)
1737
g_return_if_fail (GIMP_IS_IMAGE (image));
1738
g_return_if_fail (sample_point != NULL);
1740
g_signal_emit (image, gimp_image_signals[UPDATE_SAMPLE_POINT], 0,
1745
gimp_image_sample_point_added (GimpImage *image,
1746
GimpSamplePoint *sample_point)
1748
g_return_if_fail (GIMP_IS_IMAGE (image));
1749
g_return_if_fail (sample_point != NULL);
1751
g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_ADDED], 0,
1756
gimp_image_sample_point_removed (GimpImage *image,
1757
GimpSamplePoint *sample_point)
1759
g_return_if_fail (GIMP_IS_IMAGE (image));
1760
g_return_if_fail (sample_point != NULL);
1762
g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_REMOVED], 0,
1767
gimp_image_colormap_changed (GimpImage *image,
1639
1768
gint color_index)
1641
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1642
g_return_if_fail (color_index >= -1 && color_index < gimage->num_cols);
1770
g_return_if_fail (GIMP_IS_IMAGE (image));
1771
g_return_if_fail (color_index >= -1 && color_index < image->num_cols);
1644
g_signal_emit (gimage, gimp_image_signals[COLORMAP_CHANGED], 0,
1773
g_signal_emit (image, gimp_image_signals[COLORMAP_CHANGED], 0,
1649
gimp_image_selection_control (GimpImage *gimage,
1778
gimp_image_selection_control (GimpImage *image,
1650
1779
GimpSelectionControl control)
1652
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1781
g_return_if_fail (GIMP_IS_IMAGE (image));
1654
g_signal_emit (gimage, gimp_image_signals[SELECTION_CONTROL], 0, control);
1783
g_signal_emit (image, gimp_image_signals[SELECTION_CONTROL], 0, control);
1658
gimp_image_qmask_changed (GimpImage *gimage)
1787
gimp_image_quick_mask_changed (GimpImage *image)
1660
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1789
g_return_if_fail (GIMP_IS_IMAGE (image));
1662
g_signal_emit (gimage, gimp_image_signals[QMASK_CHANGED], 0);
1791
g_signal_emit (image, gimp_image_signals[QUICK_MASK_CHANGED], 0);
1669
gimp_image_undo_is_enabled (const GimpImage *gimage)
1798
gimp_image_undo_is_enabled (const GimpImage *image)
1671
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1800
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1673
return (gimage->undo_freeze_count == 0);
1802
return (image->undo_freeze_count == 0);
1677
gimp_image_undo_enable (GimpImage *gimage)
1806
gimp_image_undo_enable (GimpImage *image)
1679
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1808
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1681
1810
/* Free all undo steps as they are now invalidated */
1682
gimp_image_undo_free (gimage);
1684
return gimp_image_undo_thaw (gimage);
1688
gimp_image_undo_disable (GimpImage *gimage)
1690
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1692
return gimp_image_undo_freeze (gimage);
1696
gimp_image_undo_freeze (GimpImage *gimage)
1698
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1700
gimage->undo_freeze_count++;
1702
if (gimage->undo_freeze_count == 1)
1703
gimp_image_undo_event (gimage, GIMP_UNDO_EVENT_UNDO_FREEZE, NULL);
1811
gimp_image_undo_free (image);
1813
return gimp_image_undo_thaw (image);
1817
gimp_image_undo_disable (GimpImage *image)
1819
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1821
return gimp_image_undo_freeze (image);
1825
gimp_image_undo_freeze (GimpImage *image)
1827
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1829
image->undo_freeze_count++;
1831
if (image->undo_freeze_count == 1)
1832
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_FREEZE, NULL);
1709
gimp_image_undo_thaw (GimpImage *gimage)
1838
gimp_image_undo_thaw (GimpImage *image)
1711
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1712
g_return_val_if_fail (gimage->undo_freeze_count > 0, FALSE);
1714
gimage->undo_freeze_count--;
1716
if (gimage->undo_freeze_count == 0)
1717
gimp_image_undo_event (gimage, GIMP_UNDO_EVENT_UNDO_THAW, NULL);
1840
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1841
g_return_val_if_fail (image->undo_freeze_count > 0, FALSE);
1843
image->undo_freeze_count--;
1845
if (image->undo_freeze_count == 0)
1846
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_THAW, NULL);
1723
gimp_image_undo_event (GimpImage *gimage,
1852
gimp_image_undo_event (GimpImage *image,
1724
1853
GimpUndoEvent event,
1725
1854
GimpUndo *undo)
1727
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1856
g_return_if_fail (GIMP_IS_IMAGE (image));
1728
1857
g_return_if_fail (((event == GIMP_UNDO_EVENT_UNDO_FREE ||
1729
1858
event == GIMP_UNDO_EVENT_UNDO_FREEZE ||
1730
1859
event == GIMP_UNDO_EVENT_UNDO_THAW) && undo == NULL) ||
1731
1860
GIMP_IS_UNDO (undo));
1733
g_signal_emit (gimage, gimp_image_signals[UNDO_EVENT], 0, event, undo);
1862
g_signal_emit (image, gimp_image_signals[UNDO_EVENT], 0, event, undo);
1737
/* NOTE about the gimage->dirty counter:
1866
/* NOTE about the image->dirty counter:
1738
1867
* If 0, then the image is clean (ie, copy on disk is the same as the one
1740
1869
* If positive, then that's the number of dirtying operations done
1768
gimp_image_dirty (GimpImage *gimage,
1897
gimp_image_dirty (GimpImage *image,
1769
1898
GimpDirtyMask dirty_mask)
1771
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1775
if (! gimage->dirty_time)
1776
gimage->dirty_time = time (NULL);
1778
g_signal_emit (gimage, gimp_image_signals[DIRTY], 0, dirty_mask);
1780
TRC (("dirty %d -> %d\n", gimage->dirty - 1, gimage->dirty));
1782
return gimage->dirty;
1900
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1904
if (! image->dirty_time)
1905
image->dirty_time = time (NULL);
1907
g_signal_emit (image, gimp_image_signals[DIRTY], 0, dirty_mask);
1909
TRC (("dirty %d -> %d\n", image->dirty - 1, image->dirty));
1911
return image->dirty;
1786
gimp_image_clean (GimpImage *gimage,
1915
gimp_image_clean (GimpImage *image,
1787
1916
GimpDirtyMask dirty_mask)
1789
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
1793
g_signal_emit (gimage, gimp_image_signals[CLEAN], 0, dirty_mask);
1795
TRC (("clean %d -> %d\n", gimage->dirty + 1, gimage->dirty));
1797
return gimage->dirty;
1801
gimp_image_clean_all (GimpImage *gimage)
1803
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1806
gimage->dirty_time = 0;
1808
g_signal_emit (gimage, gimp_image_signals[CLEAN], 0);
1918
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
1922
g_signal_emit (image, gimp_image_signals[CLEAN], 0, dirty_mask);
1924
TRC (("clean %d -> %d\n", image->dirty + 1, image->dirty));
1926
return image->dirty;
1930
gimp_image_clean_all (GimpImage *image)
1932
g_return_if_fail (GIMP_IS_IMAGE (image));
1935
image->dirty_time = 0;
1937
g_signal_emit (image, gimp_image_signals[CLEAN], 0);
1945
* Emits the "saved" signal, indicating that @image was saved to the
1946
* location specified by @uri.
1949
gimp_image_saved (GimpImage *image,
1952
g_return_if_fail (GIMP_IS_IMAGE (image));
1953
g_return_if_fail (uri != NULL);
1955
g_signal_emit (image, gimp_image_signals[SAVED], 0, uri);
1812
1958
/* flush this image's displays */
1815
gimp_image_flush (GimpImage *gimage)
1961
gimp_image_flush (GimpImage *image)
1817
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1963
g_return_if_fail (GIMP_IS_IMAGE (image));
1819
g_signal_emit (gimage, gimp_image_signals[FLUSH], 0);
1965
g_signal_emit (image, gimp_image_signals[FLUSH], 0);
1823
1969
/* color transforms / utilities */
1826
gimp_image_get_foreground (const GimpImage *gimage,
1827
const GimpDrawable *drawable,
1828
GimpContext *context,
1972
gimp_image_get_foreground (const GimpImage *image,
1973
GimpContext *context,
1974
GimpImageType dest_type,
1834
g_return_if_fail (GIMP_IS_IMAGE (gimage));
1835
g_return_if_fail (! drawable || GIMP_IS_DRAWABLE (drawable));
1980
g_return_if_fail (GIMP_IS_IMAGE (image));
1836
1981
g_return_if_fail (GIMP_IS_CONTEXT (context));
1837
1982
g_return_if_fail (fg != NULL);
2186
2330
undoable but does not block the undo system. --Sven
2189
gimp_parasite_list_add (gimage->parasites, parasite);
2333
gimp_parasite_list_add (image->parasites, copy);
2191
if (gimp_parasite_has_flag (parasite, GIMP_PARASITE_ATTACH_PARENT))
2335
if (gimp_parasite_has_flag (copy, GIMP_PARASITE_ATTACH_PARENT))
2193
gimp_parasite_shift_parent (parasite);
2194
gimp_parasite_attach (gimage->gimp, parasite);
2337
gimp_parasite_shift_parent (copy);
2338
gimp_parasite_attach (image->gimp, copy);
2343
g_signal_emit (image, gimp_image_signals[PARASITE_ATTACHED], 0,
2199
gimp_image_parasite_detach (GimpImage *gimage,
2200
const gchar *parasite)
2348
gimp_image_parasite_detach (GimpImage *image,
2204
g_return_if_fail (GIMP_IS_IMAGE (gimage));
2205
g_return_if_fail (parasite != NULL);
2207
if (!(p = gimp_parasite_list_find (gimage->parasites, parasite)))
2351
const GimpParasite *parasite;
2353
g_return_if_fail (GIMP_IS_IMAGE (image));
2354
g_return_if_fail (name != NULL);
2356
if (! (parasite = gimp_parasite_list_find (image->parasites, name)))
2210
if (gimp_parasite_is_undoable (p))
2211
gimp_image_undo_push_image_parasite_remove (gimage,
2359
if (gimp_parasite_is_undoable (parasite))
2360
gimp_image_undo_push_image_parasite_remove (image,
2212
2361
_("Remove Parasite from Image"),
2213
gimp_parasite_name (p));
2215
gimp_parasite_list_remove (gimage->parasites, parasite);
2364
gimp_parasite_list_remove (image->parasites, name);
2366
g_signal_emit (image, gimp_image_signals[PARASITE_DETACHED], 0,
2222
gimp_image_get_new_tattoo (GimpImage *gimage)
2374
gimp_image_get_new_tattoo (GimpImage *image)
2224
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 0);
2226
gimage->tattoo_state++;
2228
if (gimage->tattoo_state <= 0)
2376
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
2378
image->tattoo_state++;
2380
if (G_UNLIKELY (image->tattoo_state == 0))
2229
2381
g_warning ("%s: Tattoo state corrupted (integer overflow).", G_STRFUNC);
2231
return gimage->tattoo_state;
2383
return image->tattoo_state;
2235
gimp_image_get_tattoo_state (GimpImage *gimage)
2387
gimp_image_get_tattoo_state (GimpImage *image)
2237
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 0);
2389
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
2239
return gimage->tattoo_state;
2391
return image->tattoo_state;
2243
gimp_image_set_tattoo_state (GimpImage *gimage,
2395
gimp_image_set_tattoo_state (GimpImage *image,
2244
2396
GimpTattoo val)
2247
2399
gboolean retval = TRUE;
2248
2400
GimpTattoo maxval = 0;
2250
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
2402
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2252
/* Check that the layer tatoos don't overlap with channel or vector ones */
2253
for (list = GIMP_LIST (gimage->layers)->list;
2404
/* Check that the layer tattoos don't overlap with channel or vector ones */
2405
for (list = GIMP_LIST (image->layers)->list;
2255
2407
list = g_list_next (list))
2360
gimp_image_get_active_layer (const GimpImage *gimage)
2512
gimp_image_get_active_layer (const GimpImage *image)
2362
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2514
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2364
return gimage->active_layer;
2516
return image->active_layer;
2368
gimp_image_get_active_channel (const GimpImage *gimage)
2520
gimp_image_get_active_channel (const GimpImage *image)
2370
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2522
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2372
return gimage->active_channel;
2524
return image->active_channel;
2376
gimp_image_get_active_vectors (const GimpImage *gimage)
2528
gimp_image_get_active_vectors (const GimpImage *image)
2378
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2530
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2380
return gimage->active_vectors;
2532
return image->active_vectors;
2384
gimp_image_set_active_layer (GimpImage *gimage,
2536
gimp_image_set_active_layer (GimpImage *image,
2385
2537
GimpLayer *layer)
2387
2539
GimpLayer *floating_sel;
2389
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2541
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2390
2542
g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL);
2391
2543
g_return_val_if_fail (layer == NULL ||
2392
gimp_container_have (gimage->layers,
2544
gimp_container_have (image->layers,
2393
2545
GIMP_OBJECT (layer)), NULL);
2395
floating_sel = gimp_image_floating_sel (gimage);
2547
floating_sel = gimp_image_floating_sel (image);
2397
2549
/* Make sure the floating_sel always is the active layer */
2398
2550
if (floating_sel && layer != floating_sel)
2399
2551
return floating_sel;
2401
if (layer != gimage->active_layer)
2553
if (layer != image->active_layer)
2405
2557
/* Configure the layer stack to reflect this change */
2406
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
2407
gimage->layer_stack = g_slist_prepend (gimage->layer_stack, layer);
2558
image->layer_stack = g_slist_remove (image->layer_stack, layer);
2559
image->layer_stack = g_slist_prepend (image->layer_stack, layer);
2410
2562
/* Don't cache selection info for the previous active layer */
2411
if (gimage->active_layer)
2412
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimage->active_layer));
2414
gimage->active_layer = layer;
2416
g_signal_emit (gimage, gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
2418
if (layer && gimage->active_channel)
2419
gimp_image_set_active_channel (gimage, NULL);
2563
if (image->active_layer)
2564
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (image->active_layer));
2566
image->active_layer = layer;
2568
g_signal_emit (image, gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
2570
if (layer && image->active_channel)
2571
gimp_image_set_active_channel (image, NULL);
2422
return gimage->active_layer;
2574
return image->active_layer;
2426
gimp_image_set_active_channel (GimpImage *gimage,
2578
gimp_image_set_active_channel (GimpImage *image,
2427
2579
GimpChannel *channel)
2429
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2581
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2430
2582
g_return_val_if_fail (channel == NULL || GIMP_IS_CHANNEL (channel), NULL);
2431
2583
g_return_val_if_fail (channel == NULL ||
2432
gimp_container_have (gimage->channels,
2584
gimp_container_have (image->channels,
2433
2585
GIMP_OBJECT (channel)), NULL);
2435
2587
/* Not if there is a floating selection */
2436
if (channel && gimp_image_floating_sel (gimage))
2588
if (channel && gimp_image_floating_sel (image))
2439
if (channel != gimage->active_channel)
2591
if (channel != image->active_channel)
2441
gimage->active_channel = channel;
2443
g_signal_emit (gimage, gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
2445
if (channel && gimage->active_layer)
2446
gimp_image_set_active_layer (gimage, NULL);
2593
image->active_channel = channel;
2595
g_signal_emit (image, gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
2597
if (channel && image->active_layer)
2598
gimp_image_set_active_layer (image, NULL);
2449
return gimage->active_channel;
2601
return image->active_channel;
2453
gimp_image_unset_active_channel (GimpImage *gimage)
2605
gimp_image_unset_active_channel (GimpImage *image)
2455
2607
GimpChannel *channel;
2457
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2609
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2459
channel = gimp_image_get_active_channel (gimage);
2611
channel = gimp_image_get_active_channel (image);
2463
gimp_image_set_active_channel (gimage, NULL);
2615
gimp_image_set_active_channel (image, NULL);
2465
if (gimage->layer_stack)
2466
gimp_image_set_active_layer (gimage, gimage->layer_stack->data);
2617
if (image->layer_stack)
2618
gimp_image_set_active_layer (image, image->layer_stack->data);
2469
2621
return channel;
2473
gimp_image_set_active_vectors (GimpImage *gimage,
2625
gimp_image_set_active_vectors (GimpImage *image,
2474
2626
GimpVectors *vectors)
2476
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2628
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2477
2629
g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), NULL);
2478
2630
g_return_val_if_fail (vectors == NULL ||
2479
gimp_container_have (gimage->vectors,
2631
gimp_container_have (image->vectors,
2480
2632
GIMP_OBJECT (vectors)), NULL);
2482
if (vectors != gimage->active_vectors)
2634
if (vectors != image->active_vectors)
2484
gimage->active_vectors = vectors;
2636
image->active_vectors = vectors;
2486
g_signal_emit (gimage, gimp_image_signals[ACTIVE_VECTORS_CHANGED], 0);
2638
g_signal_emit (image, gimp_image_signals[ACTIVE_VECTORS_CHANGED], 0);
2489
return gimage->active_vectors;
2493
gimp_image_active_layer_changed (GimpImage *gimage)
2495
g_return_if_fail (GIMP_IS_IMAGE (gimage));
2497
g_signal_emit (gimage, gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
2501
gimp_image_active_channel_changed (GimpImage *gimage)
2503
g_return_if_fail (GIMP_IS_IMAGE (gimage));
2505
g_signal_emit (gimage, gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
2509
gimp_image_active_vectors_changed (GimpImage *gimage)
2511
g_return_if_fail (GIMP_IS_IMAGE (gimage));
2513
g_signal_emit (gimage, gimp_image_signals[ACTIVE_VECTORS_CHANGED], 0);
2641
return image->active_vectors;
2645
gimp_image_active_layer_changed (GimpImage *image)
2647
g_return_if_fail (GIMP_IS_IMAGE (image));
2649
g_signal_emit (image, gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
2653
gimp_image_active_channel_changed (GimpImage *image)
2655
g_return_if_fail (GIMP_IS_IMAGE (image));
2657
g_signal_emit (image, gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
2661
gimp_image_active_vectors_changed (GimpImage *image)
2663
g_return_if_fail (GIMP_IS_IMAGE (image));
2665
g_signal_emit (image, gimp_image_signals[ACTIVE_VECTORS_CHANGED], 0);
2517
gimp_image_get_layer_index (const GimpImage *gimage,
2669
gimp_image_get_layer_index (const GimpImage *image,
2518
2670
const GimpLayer *layer)
2520
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), -1);
2672
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
2521
2673
g_return_val_if_fail (GIMP_IS_LAYER (layer), -1);
2523
return gimp_container_get_child_index (gimage->layers,
2675
return gimp_container_get_child_index (image->layers,
2524
2676
GIMP_OBJECT (layer));
2528
gimp_image_get_channel_index (const GimpImage *gimage,
2680
gimp_image_get_channel_index (const GimpImage *image,
2529
2681
const GimpChannel *channel)
2531
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), -1);
2683
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
2532
2684
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), -1);
2534
return gimp_container_get_child_index (gimage->channels,
2686
return gimp_container_get_child_index (image->channels,
2535
2687
GIMP_OBJECT (channel));
2539
gimp_image_get_vectors_index (const GimpImage *gimage,
2691
gimp_image_get_vectors_index (const GimpImage *image,
2540
2692
const GimpVectors *vectors)
2542
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), -1);
2694
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
2543
2695
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), -1);
2545
return gimp_container_get_child_index (gimage->vectors,
2697
return gimp_container_get_child_index (image->vectors,
2546
2698
GIMP_OBJECT (vectors));
2702
gimp_image_get_item_by_tattoo (GimpContainer *items,
2707
for (list = GIMP_LIST (items)->list; list; list = g_list_next (list))
2709
GimpItem *item = list->data;
2711
if (gimp_item_get_tattoo (item) == tattoo)
2550
gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
2719
gimp_image_get_layer_by_tattoo (const GimpImage *image,
2551
2720
GimpTattoo tattoo)
2555
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2557
for (list = GIMP_LIST (gimage->layers)->list;
2559
list = g_list_next (list))
2561
GimpLayer *layer = list->data;
2563
if (gimp_item_get_tattoo (GIMP_ITEM (layer)) == tattoo)
2722
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2724
return GIMP_LAYER (gimp_image_get_item_by_tattoo (image->layers,
2571
gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
2729
gimp_image_get_channel_by_tattoo (const GimpImage *image,
2572
2730
GimpTattoo tattoo)
2576
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2578
for (list = GIMP_LIST (gimage->channels)->list;
2580
list = g_list_next (list))
2582
GimpChannel *channel = list->data;
2584
if (gimp_item_get_tattoo (GIMP_ITEM (channel)) == tattoo)
2732
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2734
return GIMP_CHANNEL (gimp_image_get_item_by_tattoo (image->channels,
2592
gimp_image_get_vectors_by_tattoo (const GimpImage *gimage,
2739
gimp_image_get_vectors_by_tattoo (const GimpImage *image,
2593
2740
GimpTattoo tattoo)
2597
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2599
for (list = GIMP_LIST (gimage->vectors)->list;
2601
list = g_list_next (list))
2603
GimpVectors *vectors = list->data;
2605
if (gimp_item_get_tattoo (GIMP_ITEM (vectors)) == tattoo)
2742
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2744
return GIMP_VECTORS (gimp_image_get_item_by_tattoo (image->vectors,
2613
gimp_image_get_layer_by_name (const GimpImage *gimage,
2749
gimp_image_get_layer_by_name (const GimpImage *image,
2614
2750
const gchar *name)
2616
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2752
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2618
return (GimpLayer *) gimp_container_get_child_by_name (gimage->layers,
2754
return GIMP_LAYER (gimp_container_get_child_by_name (image->layers,
2623
gimp_image_get_channel_by_name (const GimpImage *gimage,
2759
gimp_image_get_channel_by_name (const GimpImage *image,
2624
2760
const gchar *name)
2626
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2762
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2628
return (GimpChannel *) gimp_container_get_child_by_name (gimage->channels,
2764
return GIMP_CHANNEL (gimp_container_get_child_by_name (image->channels,
2633
gimp_image_get_vectors_by_name (const GimpImage *gimage,
2769
gimp_image_get_vectors_by_name (const GimpImage *image,
2634
2770
const gchar *name)
2636
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
2772
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2638
return (GimpVectors *) gimp_container_get_child_by_name (gimage->vectors,
2774
return GIMP_VECTORS (gimp_container_get_child_by_name (image->vectors,
2643
gimp_image_add_layer (GimpImage *gimage,
2779
gimp_image_add_layer (GimpImage *image,
2644
2780
GimpLayer *layer,
2803
gimp_image_set_active_layer (gimage, active_layer);
2940
gimp_image_set_active_layer (image, active_layer);
2806
2943
gimp_item_removed (GIMP_ITEM (layer));
2808
2945
g_object_unref (layer);
2810
if (old_has_alpha != gimp_image_has_alpha (gimage))
2811
gimp_image_alpha_changed (gimage);
2947
if (old_has_alpha != gimp_image_has_alpha (image))
2948
gimp_image_alpha_changed (image);
2813
2950
if (undo_group)
2814
gimp_image_undo_group_end (gimage);
2951
gimp_image_undo_group_end (image);
2955
gimp_image_add_layers (GimpImage *image,
2962
const gchar *undo_desc)
2965
gint layers_x = G_MAXINT;
2966
gint layers_y = G_MAXINT;
2967
gint layers_width = 0;
2968
gint layers_height = 0;
2972
g_return_if_fail (GIMP_IS_IMAGE (image));
2973
g_return_if_fail (layers != NULL);
2977
GimpLayer *active_layer = gimp_image_get_active_layer (image);
2980
position = gimp_image_get_layer_index (image, active_layer);
2985
for (list = layers; list; list = g_list_next (list))
2987
GimpItem *item = GIMP_ITEM (list->data);
2990
gimp_item_offsets (item, &off_x, &off_y);
2992
layers_x = MIN (layers_x, off_x);
2993
layers_y = MIN (layers_y, off_y);
2995
layers_width = MAX (layers_width,
2996
off_x + gimp_item_width (item) - layers_x);
2997
layers_height = MAX (layers_height,
2998
off_y + gimp_item_height (item) - layers_y);
3001
offset_x = x + (width - layers_width) / 2 - layers_x;
3002
offset_y = y + (height - layers_height) / 2 - layers_y;
3004
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_LAYER_ADD, undo_desc);
3006
for (list = layers; list; list = g_list_next (list))
3008
GimpItem *new_item = GIMP_ITEM (list->data);
3010
gimp_item_translate (new_item, offset_x, offset_y, FALSE);
3012
gimp_image_add_layer (image, GIMP_LAYER (new_item), position);
3016
gimp_image_undo_group_end (image);
2818
gimp_image_raise_layer (GimpImage *gimage,
3020
gimp_image_raise_layer (GimpImage *image,
2819
3021
GimpLayer *layer)
2823
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3025
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2824
3026
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
2826
index = gimp_container_get_child_index (gimage->layers,
3028
index = gimp_container_get_child_index (image->layers,
2827
3029
GIMP_OBJECT (layer));
2829
3031
if (index == 0)
2835
if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
2837
g_message (_("Cannot raise a layer without alpha."));
2841
return gimp_image_position_layer (gimage, layer, index - 1,
3037
return gimp_image_position_layer (image, layer, index - 1,
2842
3038
TRUE, _("Raise Layer"));
2846
gimp_image_lower_layer (GimpImage *gimage,
3042
gimp_image_lower_layer (GimpImage *image,
2847
3043
GimpLayer *layer)
2851
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3047
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2852
3048
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
2854
index = gimp_container_get_child_index (gimage->layers,
3050
index = gimp_container_get_child_index (image->layers,
2855
3051
GIMP_OBJECT (layer));
2857
if (index == gimp_container_num_children (gimage->layers) - 1)
3053
if (index == gimp_container_num_children (image->layers) - 1)
2859
3055
g_message (_("Layer cannot be lowered more."));
2863
return gimp_image_position_layer (gimage, layer, index + 1,
3059
return gimp_image_position_layer (image, layer, index + 1,
2864
3060
TRUE, _("Lower Layer"));
2868
gimp_image_raise_layer_to_top (GimpImage *gimage,
3064
gimp_image_raise_layer_to_top (GimpImage *image,
2869
3065
GimpLayer *layer)
2873
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3067
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2874
3068
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
2876
index = gimp_container_get_child_index (gimage->layers,
2877
GIMP_OBJECT (layer));
2881
g_message (_("Layer is already on top."));
2885
if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
2887
g_message (_("Cannot raise a layer without alpha."));
2891
return gimp_image_position_layer (gimage, layer, 0,
3070
return gimp_image_position_layer (image, layer, 0,
2892
3071
TRUE, _("Raise Layer to Top"));
2896
gimp_image_lower_layer_to_bottom (GimpImage *gimage,
3075
gimp_image_lower_layer_to_bottom (GimpImage *image,
2897
3076
GimpLayer *layer)
2902
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3080
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2903
3081
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
2905
index = gimp_container_get_child_index (gimage->layers,
2906
GIMP_OBJECT (layer));
2908
length = gimp_container_num_children (gimage->layers);
2910
if (index == length - 1)
2912
g_message (_("Layer is already on the bottom."));
2916
return gimp_image_position_layer (gimage, layer, length - 1,
3083
length = gimp_container_num_children (image->layers);
3085
return gimp_image_position_layer (image, layer, length - 1,
2917
3086
TRUE, _("Lower Layer to Bottom"));
2921
gimp_image_position_layer (GimpImage *gimage,
3090
gimp_image_position_layer (GimpImage *image,
2922
3091
GimpLayer *layer,
2923
3092
gint new_index,
2924
3093
gboolean push_undo,
2925
3094
const gchar *undo_desc)
2930
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3099
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2931
3100
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
2933
index = gimp_container_get_child_index (gimage->layers,
2934
GIMP_OBJECT (layer));
3102
index = gimp_container_get_child_index (image->layers, GIMP_OBJECT (layer));
2938
num_layers = gimp_container_num_children (gimage->layers);
3106
num_layers = gimp_container_num_children (image->layers);
2940
3108
new_index = CLAMP (new_index, 0, num_layers - 1);
2942
3110
if (new_index == index)
2945
/* check if we want to move it below a bottom layer without alpha */
2946
if (new_index == num_layers - 1)
2950
tmp = (GimpLayer *) gimp_container_get_child_by_index (gimage->layers,
2953
if (new_index == num_layers - 1 &&
2954
! gimp_drawable_has_alpha (GIMP_DRAWABLE (tmp)))
2956
g_message (_("Layer '%s' has no alpha. Layer was placed above it."),
2957
GIMP_OBJECT (tmp)->name);
2963
gimp_image_undo_push_layer_reposition (gimage, undo_desc, layer);
3114
gimp_image_undo_push_layer_reposition (image, undo_desc, layer);
2965
gimp_container_reorder (gimage->layers, GIMP_OBJECT (layer), new_index);
3116
gimp_container_reorder (image->layers, GIMP_OBJECT (layer), new_index);
2967
3118
if (gimp_item_get_visible (GIMP_ITEM (layer)))
2971
3122
gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
2973
gimp_image_update (gimage,
3124
gimp_image_update (image,
2975
3126
gimp_item_width (GIMP_ITEM (layer)),
2976
3127
gimp_item_height (GIMP_ITEM (layer)));
2977
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
3128
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image));
2984
gimp_image_add_channel (GimpImage *gimage,
3135
gimp_image_add_channel (GimpImage *image,
2985
3136
GimpChannel *channel,
2988
3139
GimpChannel *active_channel;
2990
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3141
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2991
3142
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE);
2993
if (GIMP_ITEM (channel)->gimage != NULL &&
2994
GIMP_ITEM (channel)->gimage != gimage)
3144
if (GIMP_ITEM (channel)->image != NULL &&
3145
GIMP_ITEM (channel)->image != image)
2996
3147
g_warning ("%s: attempting to add channel to wrong image.", G_STRFUNC);
3000
if (gimp_container_have (gimage->channels, GIMP_OBJECT (channel)))
3151
if (gimp_container_have (image->channels, GIMP_OBJECT (channel)))
3002
3153
g_warning ("%s: trying to add channel to image twice.", G_STRFUNC);
3006
active_channel = gimp_image_get_active_channel (gimage);
3008
gimp_image_undo_push_channel_add (gimage, _("Add Channel"),
3009
channel, 0, active_channel);
3011
gimp_item_set_image (GIMP_ITEM (channel), gimage);
3157
active_channel = gimp_image_get_active_channel (image);
3159
gimp_image_undo_push_channel_add (image, _("Add Channel"),
3160
channel, active_channel);
3162
gimp_item_set_image (GIMP_ITEM (channel), image);
3013
3164
/* add the layer to the list at the specified position */
3014
3165
if (position == -1)
3016
3167
if (active_channel)
3017
position = gimp_container_get_child_index (gimage->channels,
3168
position = gimp_container_get_child_index (image->channels,
3018
3169
GIMP_OBJECT (active_channel));
3023
3174
/* Don't add at a non-existing index */
3024
if (position > gimp_container_num_children (gimage->channels))
3025
position = gimp_container_num_children (gimage->channels);
3027
gimp_container_insert (gimage->channels, GIMP_OBJECT (channel), position);
3028
gimp_item_sink (GIMP_ITEM (channel));
3030
/* notify this gimage of the currently active channel */
3031
gimp_image_set_active_channel (gimage, channel);
3175
if (position > gimp_container_num_children (image->channels))
3176
position = gimp_container_num_children (image->channels);
3178
g_object_ref_sink (channel);
3179
gimp_container_insert (image->channels, GIMP_OBJECT (channel), position);
3180
g_object_unref (channel);
3182
/* notify this image of the currently active channel */
3183
gimp_image_set_active_channel (image, channel);
3037
gimp_image_remove_channel (GimpImage *gimage,
3189
gimp_image_remove_channel (GimpImage *image,
3038
3190
GimpChannel *channel)
3040
3192
GimpChannel *active_channel;
3042
3194
gboolean undo_group = FALSE;
3044
g_return_if_fail (GIMP_IS_IMAGE (gimage));
3196
g_return_if_fail (GIMP_IS_IMAGE (image));
3045
3197
g_return_if_fail (GIMP_IS_CHANNEL (channel));
3046
g_return_if_fail (gimp_container_have (gimage->channels,
3198
g_return_if_fail (gimp_container_have (image->channels,
3047
3199
GIMP_OBJECT (channel)));
3049
3201
if (gimp_drawable_has_floating_sel (GIMP_DRAWABLE (channel)))
3051
gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE,
3203
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE,
3052
3204
_("Remove Channel"));
3053
3205
undo_group = TRUE;
3055
floating_sel_remove (gimp_image_floating_sel (gimage));
3207
floating_sel_remove (gimp_image_floating_sel (image));
3058
active_channel = gimp_image_get_active_channel (gimage);
3210
active_channel = gimp_image_get_active_channel (image);
3060
index = gimp_container_get_child_index (gimage->channels,
3212
index = gimp_container_get_child_index (image->channels,
3061
3213
GIMP_OBJECT (channel));
3063
gimp_image_undo_push_channel_remove (gimage, _("Remove Channel"),
3215
gimp_image_undo_push_channel_remove (image, _("Remove Channel"),
3064
3216
channel, index, active_channel);
3066
3218
g_object_ref (channel);
3068
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
3220
gimp_container_remove (image->channels, GIMP_OBJECT (channel));
3069
3221
gimp_item_removed (GIMP_ITEM (channel));
3071
3223
if (channel == active_channel)
3073
gint n_children = gimp_container_num_children (gimage->channels);
3225
gint n_children = gimp_container_num_children (image->channels);
3075
3227
if (n_children > 0)
3077
3229
index = CLAMP (index, 0, n_children - 1);
3079
3231
active_channel = (GimpChannel *)
3080
gimp_container_get_child_by_index (gimage->channels, index);
3232
gimp_container_get_child_by_index (image->channels, index);
3082
gimp_image_set_active_channel (gimage, active_channel);
3234
gimp_image_set_active_channel (image, active_channel);
3086
gimp_image_unset_active_channel (gimage);
3238
gimp_image_unset_active_channel (image);
3090
3242
g_object_unref (channel);
3092
3244
if (undo_group)
3093
gimp_image_undo_group_end (gimage);
3245
gimp_image_undo_group_end (image);
3097
gimp_image_raise_channel (GimpImage *gimage,
3249
gimp_image_raise_channel (GimpImage *image,
3098
3250
GimpChannel *channel)
3102
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3254
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3103
3255
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE);
3105
index = gimp_container_get_child_index (gimage->channels,
3257
index = gimp_container_get_child_index (image->channels,
3106
3258
GIMP_OBJECT (channel));
3108
3260
if (index == 0)
3222
3374
gimp_item_offsets (GIMP_ITEM (channel), &off_x, &off_y);
3224
gimp_image_update (gimage,
3376
gimp_image_update (image,
3226
3378
gimp_item_width (GIMP_ITEM (channel)),
3227
3379
gimp_item_height (GIMP_ITEM (channel)));
3228
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
3380
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image));
3235
gimp_image_add_vectors (GimpImage *gimage,
3387
gimp_image_add_vectors (GimpImage *image,
3236
3388
GimpVectors *vectors,
3239
3391
GimpVectors *active_vectors;
3241
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3393
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3242
3394
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE);
3244
if (GIMP_ITEM (vectors)->gimage != NULL &&
3245
GIMP_ITEM (vectors)->gimage != gimage)
3396
if (GIMP_ITEM (vectors)->image != NULL &&
3397
GIMP_ITEM (vectors)->image != image)
3247
3399
g_warning ("%s: attempting to add vectors to wrong image.", G_STRFUNC);
3251
if (gimp_container_have (gimage->vectors, GIMP_OBJECT (vectors)))
3403
if (gimp_container_have (image->vectors, GIMP_OBJECT (vectors)))
3253
3405
g_warning ("%s: trying to add vectors to image twice.", G_STRFUNC);
3257
active_vectors = gimp_image_get_active_vectors (gimage);
3259
gimp_image_undo_push_vectors_add (gimage, _("Add Path"),
3260
vectors, 0, active_vectors);
3262
gimp_item_set_image (GIMP_ITEM (vectors), gimage);
3409
active_vectors = gimp_image_get_active_vectors (image);
3411
gimp_image_undo_push_vectors_add (image, _("Add Path"),
3412
vectors, active_vectors);
3414
gimp_item_set_image (GIMP_ITEM (vectors), image);
3264
3416
/* add the layer to the list at the specified position */
3265
3417
if (position == -1)
3267
3419
if (active_vectors)
3268
position = gimp_container_get_child_index (gimage->vectors,
3420
position = gimp_container_get_child_index (image->vectors,
3269
3421
GIMP_OBJECT (active_vectors));
3274
3426
/* Don't add at a non-existing index */
3275
if (position > gimp_container_num_children (gimage->vectors))
3276
position = gimp_container_num_children (gimage->vectors);
3278
gimp_container_insert (gimage->vectors, GIMP_OBJECT (vectors), position);
3279
gimp_item_sink (GIMP_ITEM (vectors));
3281
/* notify this gimage of the currently active vectors */
3282
gimp_image_set_active_vectors (gimage, vectors);
3427
if (position > gimp_container_num_children (image->vectors))
3428
position = gimp_container_num_children (image->vectors);
3430
g_object_ref_sink (vectors);
3431
gimp_container_insert (image->vectors, GIMP_OBJECT (vectors), position);
3432
g_object_unref (vectors);
3434
/* notify this image of the currently active vectors */
3435
gimp_image_set_active_vectors (image, vectors);
3288
gimp_image_remove_vectors (GimpImage *gimage,
3441
gimp_image_remove_vectors (GimpImage *image,
3289
3442
GimpVectors *vectors)
3291
3444
GimpVectors *active_vectors;
3294
g_return_if_fail (GIMP_IS_IMAGE (gimage));
3447
g_return_if_fail (GIMP_IS_IMAGE (image));
3295
3448
g_return_if_fail (GIMP_IS_VECTORS (vectors));
3296
g_return_if_fail (gimp_container_have (gimage->vectors,
3449
g_return_if_fail (gimp_container_have (image->vectors,
3297
3450
GIMP_OBJECT (vectors)));
3299
active_vectors = gimp_image_get_active_vectors (gimage);
3452
active_vectors = gimp_image_get_active_vectors (image);
3301
index = gimp_container_get_child_index (gimage->vectors,
3454
index = gimp_container_get_child_index (image->vectors,
3302
3455
GIMP_OBJECT (vectors));
3304
gimp_image_undo_push_vectors_remove (gimage, _("Remove Path"),
3457
gimp_image_undo_push_vectors_remove (image, _("Remove Path"),
3305
3458
vectors, index, active_vectors);
3307
3460
g_object_ref (vectors);
3309
gimp_container_remove (gimage->vectors, GIMP_OBJECT (vectors));
3462
gimp_container_remove (image->vectors, GIMP_OBJECT (vectors));
3310
3463
gimp_item_removed (GIMP_ITEM (vectors));
3312
3465
if (vectors == active_vectors)
3314
gint n_children = gimp_container_num_children (gimage->vectors);
3467
gint n_children = gimp_container_num_children (image->vectors);
3316
3469
if (n_children > 0)
3318
3471
index = CLAMP (index, 0, n_children - 1);
3320
3473
active_vectors = (GimpVectors *)
3321
gimp_container_get_child_by_index (gimage->vectors, index);
3474
gimp_container_get_child_by_index (image->vectors, index);
3325
3478
active_vectors = NULL;
3328
gimp_image_set_active_vectors (gimage, active_vectors);
3481
gimp_image_set_active_vectors (image, active_vectors);
3331
3484
g_object_unref (vectors);
3335
gimp_image_raise_vectors (GimpImage *gimage,
3488
gimp_image_raise_vectors (GimpImage *image,
3336
3489
GimpVectors *vectors)
3340
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3493
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3341
3494
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE);
3343
index = gimp_container_get_child_index (gimage->vectors,
3496
index = gimp_container_get_child_index (image->vectors,
3344
3497
GIMP_OBJECT (vectors));
3346
3499
if (index == 0)
3489
gimp_image_pick_correlate_layer (const GimpImage *gimage,
3642
gimp_image_pick_correlate_layer (const GimpImage *image,
3495
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
3648
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
3497
for (list = GIMP_LIST (gimage->layers)->list;
3650
for (list = GIMP_LIST (image->layers)->list;
3499
3652
list = g_list_next (list))
3501
3654
GimpLayer *layer = list->data;
3503
if (gimp_layer_pick_correlate (layer, x, y))
3657
gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
3659
if (gimp_pickable_get_opacity_at (GIMP_PICKABLE (layer),
3660
x - off_x, y - off_y) > 63)
3511
gimp_image_coords_in_active_drawable (GimpImage *gimage,
3512
const GimpCoords *coords)
3670
gimp_image_coords_in_active_pickable (GimpImage *image,
3671
const GimpCoords *coords,
3672
gboolean sample_merged,
3673
gboolean selected_only)
3514
GimpDrawable *drawable;
3516
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
3518
drawable = gimp_image_active_drawable (gimage);
3522
GimpItem *item = GIMP_ITEM (drawable);
3525
gimp_item_offsets (item, &x, &y);
3527
x = ROUND (coords->x) - x;
3528
y = ROUND (coords->y) - y;
3530
if (x < 0 || x > gimp_item_width (item))
3533
if (y < 0 || y > gimp_item_height (item))
3676
gboolean in_pickable = FALSE;
3678
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3680
x = floor (coords->x);
3681
y = floor (coords->y);
3685
if (x >= 0 && x < image->width &&
3686
y >= 0 && y < image->height)
3691
GimpDrawable *drawable = gimp_image_active_drawable (image);
3695
GimpItem *item = GIMP_ITEM (drawable);
3699
gimp_item_offsets (item, &off_x, &off_y);
3704
if (d_x >= 0 && d_x < gimp_item_width (item) &&
3705
d_y >= 0 && d_y < gimp_item_height (item))
3710
if (in_pickable && selected_only)
3712
GimpChannel *selection = gimp_image_get_mask (image);
3714
if (! gimp_channel_is_empty (selection) &&
3715
! gimp_pickable_get_opacity_at (GIMP_PICKABLE (selection),
3718
in_pickable = FALSE;
3543
gimp_image_invalidate_layer_previews (GimpImage *gimage)
3726
gimp_image_invalidate_layer_previews (GimpImage *image)
3545
g_return_if_fail (GIMP_IS_IMAGE (gimage));
3728
g_return_if_fail (GIMP_IS_IMAGE (image));
3547
gimp_container_foreach (gimage->layers,
3730
gimp_container_foreach (image->layers,
3548
3731
(GFunc) gimp_viewable_invalidate_preview,
3553
gimp_image_invalidate_channel_previews (GimpImage *gimage)
3736
gimp_image_invalidate_channel_previews (GimpImage *image)
3555
g_return_if_fail (GIMP_IS_IMAGE (gimage));
3738
g_return_if_fail (GIMP_IS_IMAGE (image));
3557
gimp_container_foreach (gimage->channels,
3740
gimp_container_foreach (image->channels,
3558
3741
(GFunc) gimp_viewable_invalidate_preview,
added
removed
app/core/gimpimage.c
