File: gimp-utils.h

package info (click to toggle)
gimp 3.0.4-3
  • links: PTS, VCS
  • area: main
  • in suites: sid, trixie
  • size: 210,076 kB
  • sloc: ansic: 842,287; lisp: 10,761; python: 10,318; cpp: 7,238; perl: 4,355; sh: 1,043; xml: 963; yacc: 609; lex: 348; javascript: 150; makefile: 43
file content (141 lines) | stat: -rw-r--r-- 7,303 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* GIMP - The GNU Image Manipulation Program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef __APP_GIMP_UTILS_H__
#define __APP_GIMP_UTILS_H__


#ifdef GIMP_RELEASE
#define GIMP_TIMER_START()
#define GIMP_TIMER_END(message)
#else
#define GIMP_TIMER_START() \
  { GTimer *_timer = g_timer_new ();

#define GIMP_TIMER_END(message) \
  g_printerr ("%s: %s took %0.4f seconds\n", \
              G_STRFUNC, message, g_timer_elapsed (_timer, NULL)); \
  g_timer_destroy (_timer); }
#endif


#define MIN4(a,b,c,d) MIN (MIN ((a), (b)), MIN ((c), (d)))
#define MAX4(a,b,c,d) MAX (MAX ((a), (b)), MAX ((c), (d)))


gint         gimp_get_pid                          (void);
guint64      gimp_get_physical_memory_size         (void);
gchar      * gimp_get_default_language             (const gchar     *category);
GimpUnit   * gimp_get_default_unit                 (void);

gchar     ** gimp_properties_append                (GType            object_type,
                                                    gint            *n_properties,
                                                    gchar          **names,
                                                    GValue         **values,
                                                    ...) G_GNUC_NULL_TERMINATED;
gchar     ** gimp_properties_append_valist         (GType            object_type,
                                                    gint            *n_properties,
                                                    gchar          **names,
                                                    GValue         **values,
                                                    va_list          args);
void         gimp_properties_free                  (gint             n_properties,
                                                    gchar          **names,
                                                    GValue          *values);

gchar      * gimp_markup_extract_text              (const gchar     *markup);

const gchar* gimp_enum_get_value_name              (GType            enum_type,
                                                    gint             value);

gboolean     gimp_get_fill_params                  (GimpContext      *context,
                                                    GimpFillType      fill_type,
                                                    GeglColor       **color,
                                                    GimpPattern     **pattern,
                                                    GError          **error);

/* Common values for the n_snap_lines parameter of
 * gimp_constrain_line.
 */
#define GIMP_CONSTRAIN_LINE_90_DEGREES 2
#define GIMP_CONSTRAIN_LINE_45_DEGREES 4
#define GIMP_CONSTRAIN_LINE_15_DEGREES 12

void         gimp_constrain_line                   (gdouble            start_x,
                                                    gdouble            start_y,
                                                    gdouble           *end_x,
                                                    gdouble           *end_y,
                                                    gint               n_snap_lines,
                                                    gdouble            offset_angle,
                                                    gdouble            xres,
                                                    gdouble            yres);

gint         gimp_file_compare                     (GFile             *file1,
                                                    GFile             *file2);
gboolean     gimp_file_is_executable               (GFile             *file);
gchar      * gimp_file_get_extension               (GFile             *file);
GFile      * gimp_file_with_new_extension          (GFile             *file,
                                                    GFile             *ext_file);
gboolean     gimp_file_delete_recursive            (GFile             *file,
                                                    GError           **error);

gchar      * gimp_data_input_stream_read_line_always
                                                   (GDataInputStream  *stream,
                                                    gsize             *length,
                                                    GCancellable      *cancellable,
                                                    GError           **error);

gboolean     gimp_ascii_strtoi                     (const gchar       *nptr,
                                                    gchar            **endptr,
                                                    gint               base,
                                                    gint              *result);
gboolean     gimp_ascii_strtod                     (const gchar       *nptr,
                                                    gchar            **endptr,
                                                    gdouble           *result);

gchar     *  gimp_appstream_to_pango_markup        (const gchar       *as_text);
void         gimp_appstream_to_pango_markups       (const gchar       *as_text,
                                                    gchar            **introduction,
                                                    GList            **release_items);

gint         gimp_g_list_compare                   (GList             *list1,
                                                    GList             *list2);

GimpTRCType  gimp_suggest_trc_for_component_type   (GimpComponentType  component_type,
                                                    GimpTRCType        old_trc);

GimpAsync  * gimp_idle_run_async                   (GimpRunAsyncFunc func,
                                                    gpointer         user_data);
GimpAsync  * gimp_idle_run_async_full              (gint             priority,
                                                    GimpRunAsyncFunc func,
                                                    gpointer         user_data,
                                                    GDestroyNotify   user_data_destroy_func);

GimpImage  * gimp_create_image_from_buffer         (Gimp              *gimp,
                                                    GeglBuffer        *buffer,
                                                    const gchar       *image_name);

gint         gimp_view_size_get_larger             (gint view_size);
gint         gimp_view_size_get_smaller            (gint view_size);

#ifdef G_OS_WIN32

gboolean     gimp_win32_have_wintab                (void);
gboolean     gimp_win32_have_windows_ink           (void);

#endif

#endif /* __APP_GIMP_UTILS_H__ */