← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/core/gimpmarshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/core/gimpmarshal.c
571
571
            data2);
572
572
}
573
573
 
574
 
/* VOID:OBJECT,POINTER (./gimpmarshal.list:45) */
 
574
/* VOID:OBJECT,OBJECT (./gimpmarshal.list:45) */
 
575
void
 
576
gimp_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
 
577
                                  GValue       *return_value,
 
578
                                  guint         n_param_values,
 
579
                                  const GValue *param_values,
 
580
                                  gpointer      invocation_hint,
 
581
                                  gpointer      marshal_data)
 
582
{
 
583
  typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
 
584
                                                    gpointer     arg_1,
 
585
                                                    gpointer     arg_2,
 
586
                                                    gpointer     data2);
 
587
  register GMarshalFunc_VOID__OBJECT_OBJECT callback;
 
588
  register GCClosure *cc = (GCClosure*) closure;
 
589
  register gpointer data1, data2;
 
590
 
 
591
  g_return_if_fail (n_param_values == 3);
 
592
 
 
593
  if (G_CCLOSURE_SWAP_DATA (closure))
 
594
    {
 
595
      data1 = closure->data;
 
596
      data2 = g_value_peek_pointer (param_values + 0);
 
597
    }
 
598
  else
 
599
    {
 
600
      data1 = g_value_peek_pointer (param_values + 0);
 
601
      data2 = closure->data;
 
602
    }
 
603
  callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
604
 
 
605
  callback (data1,
 
606
            g_marshal_value_peek_object (param_values + 1),
 
607
            g_marshal_value_peek_object (param_values + 2),
 
608
            data2);
 
609
}
 
610
 
 
611
/* VOID:OBJECT,POINTER (./gimpmarshal.list:46) */
575
612
void
576
613
gimp_marshal_VOID__OBJECT_POINTER (GClosure     *closure,
577
614
                                   GValue       *return_value,
608
645
            data2);
609
646
}
610
647
 
611
 
/* VOID:POINTER (./gimpmarshal.list:46) */
612
 
 
613
 
/* VOID:STRING (./gimpmarshal.list:47) */
614
 
 
615
 
/* VOID:STRING,BOOLEAN,UINT,FLAGS (./gimpmarshal.list:48) */
 
648
/* VOID:POINTER (./gimpmarshal.list:47) */
 
649
 
 
650
/* VOID:POINTER,BOXED (./gimpmarshal.list:48) */
 
651
void
 
652
gimp_marshal_VOID__POINTER_BOXED (GClosure     *closure,
 
653
                                  GValue       *return_value,
 
654
                                  guint         n_param_values,
 
655
                                  const GValue *param_values,
 
656
                                  gpointer      invocation_hint,
 
657
                                  gpointer      marshal_data)
 
658
{
 
659
  typedef void (*GMarshalFunc_VOID__POINTER_BOXED) (gpointer     data1,
 
660
                                                    gpointer     arg_1,
 
661
                                                    gpointer     arg_2,
 
662
                                                    gpointer     data2);
 
663
  register GMarshalFunc_VOID__POINTER_BOXED callback;
 
664
  register GCClosure *cc = (GCClosure*) closure;
 
665
  register gpointer data1, data2;
 
666
 
 
667
  g_return_if_fail (n_param_values == 3);
 
668
 
 
669
  if (G_CCLOSURE_SWAP_DATA (closure))
 
670
    {
 
671
      data1 = closure->data;
 
672
      data2 = g_value_peek_pointer (param_values + 0);
 
673
    }
 
674
  else
 
675
    {
 
676
      data1 = g_value_peek_pointer (param_values + 0);
 
677
      data2 = closure->data;
 
678
    }
 
679
  callback = (GMarshalFunc_VOID__POINTER_BOXED) (marshal_data ? marshal_data : cc->callback);
 
680
 
 
681
  callback (data1,
 
682
            g_marshal_value_peek_pointer (param_values + 1),
 
683
            g_marshal_value_peek_boxed (param_values + 2),
 
684
            data2);
 
685
}
 
686
 
 
687
/* VOID:POINTER,ENUM (./gimpmarshal.list:49) */
 
688
void
 
689
gimp_marshal_VOID__POINTER_ENUM (GClosure     *closure,
 
690
                                 GValue       *return_value,
 
691
                                 guint         n_param_values,
 
692
                                 const GValue *param_values,
 
693
                                 gpointer      invocation_hint,
 
694
                                 gpointer      marshal_data)
 
695
{
 
696
  typedef void (*GMarshalFunc_VOID__POINTER_ENUM) (gpointer     data1,
 
697
                                                   gpointer     arg_1,
 
698
                                                   gint         arg_2,
 
699
                                                   gpointer     data2);
 
700
  register GMarshalFunc_VOID__POINTER_ENUM callback;
 
701
  register GCClosure *cc = (GCClosure*) closure;
 
702
  register gpointer data1, data2;
 
703
 
 
704
  g_return_if_fail (n_param_values == 3);
 
705
 
 
706
  if (G_CCLOSURE_SWAP_DATA (closure))
 
707
    {
 
708
      data1 = closure->data;
 
709
      data2 = g_value_peek_pointer (param_values + 0);
 
710
    }
 
711
  else
 
712
    {
 
713
      data1 = g_value_peek_pointer (param_values + 0);
 
714
      data2 = closure->data;
 
715
    }
 
716
  callback = (GMarshalFunc_VOID__POINTER_ENUM) (marshal_data ? marshal_data : cc->callback);
 
717
 
 
718
  callback (data1,
 
719
            g_marshal_value_peek_pointer (param_values + 1),
 
720
            g_marshal_value_peek_enum (param_values + 2),
 
721
            data2);
 
722
}
 
723
 
 
724
/* VOID:STRING (./gimpmarshal.list:50) */
 
725
 
 
726
/* VOID:STRING,BOOLEAN,UINT,FLAGS (./gimpmarshal.list:51) */
616
727
void
617
728
gimp_marshal_VOID__STRING_BOOLEAN_UINT_FLAGS (GClosure     *closure,
618
729
                                              GValue       *return_value,
653
764
            data2);
654
765
}
655
766
 
656
 
/* VOID:STRING,FLAGS (./gimpmarshal.list:49) */
 
767
/* VOID:STRING,FLAGS (./gimpmarshal.list:52) */
657
768
void
658
769
gimp_marshal_VOID__STRING_FLAGS (GClosure     *closure,
659
770
                                 GValue       *return_value,
690
801
            data2);
691
802
}
692
803
 
693
 
/* VOID:VOID (./gimpmarshal.list:50) */
 
804
/* VOID:STRING,STRING,STRING (./gimpmarshal.list:53) */
 
805
void
 
806
gimp_marshal_VOID__STRING_STRING_STRING (GClosure     *closure,
 
807
                                         GValue       *return_value,
 
808
                                         guint         n_param_values,
 
809
                                         const GValue *param_values,
 
810
                                         gpointer      invocation_hint,
 
811
                                         gpointer      marshal_data)
 
812
{
 
813
  typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer     data1,
 
814
                                                           gpointer     arg_1,
 
815
                                                           gpointer     arg_2,
 
816
                                                           gpointer     arg_3,
 
817
                                                           gpointer     data2);
 
818
  register GMarshalFunc_VOID__STRING_STRING_STRING callback;
 
819
  register GCClosure *cc = (GCClosure*) closure;
 
820
  register gpointer data1, data2;
 
821
 
 
822
  g_return_if_fail (n_param_values == 4);
 
823
 
 
824
  if (G_CCLOSURE_SWAP_DATA (closure))
 
825
    {
 
826
      data1 = closure->data;
 
827
      data2 = g_value_peek_pointer (param_values + 0);
 
828
    }
 
829
  else
 
830
    {
 
831
      data1 = g_value_peek_pointer (param_values + 0);
 
832
      data2 = closure->data;
 
833
    }
 
834
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
835
 
 
836
  callback (data1,
 
837
            g_marshal_value_peek_string (param_values + 1),
 
838
            g_marshal_value_peek_string (param_values + 2),
 
839
            g_marshal_value_peek_string (param_values + 3),
 
840
            data2);
 
841
}
 
842
 
 
843
/* VOID:VOID (./gimpmarshal.list:54) */
694
844