procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-19 01:10:08 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

Added parent window API to the GimpProgress interface and to the libgimp

Browse source 
2005-09-09  Michael Natterer  <mitch@gimp.org>

	Added parent window API to the GimpProgress interface and to
	the libgimp progress stuff. Might look strange, but does
	the right thing in almost all cases (image window, file dialog,
	script-fu dialog etc). Fixes bug #62988.

	* app/core/gimpprogress.[ch]: added GimpProgress::get_window()
	which should return a toplevel window ID if the progress is in a
	window that wants to be the transient parent of plug-in dialogs.

	* app/widgets/gimpwidgets-utils.[ch] (gimp_window_get_native): new
	function which returns the window handle of a GtkWindow's GdkWindow.

	* app/widgets/gimpfiledialog.c: implement ::get_window().

	* app/display/gimpdisplay.[ch]: ditto. Removed window handle API.

	* app/gui/gui-vtable.c: changed accordingly.

	* libgimpbase/gimpbaseenums.[ch] (enum GimpProgressCommand):
	added GIMP_PROGRESS_COMMAND_GET_WINDOW.

	* app/plug-in/plug-in-progress.[ch] (plug_in_progress_get_window):
	new function. Also renamed some functions to match the
	GimpProgress interface, and not the legacy PDB procedure names.

	* tools/pdbgen/pdb/progress.pdb
	* app/core/gimppdbprogress.c: implement get_window() on both
	sides of the wire, keeping backward compatibility (hopefully).

	* libgimp/gimpprogress.[ch]: deprecated gimp_progress_install()
	and added gimp_progress_install_vtable() which takes a vtable with
	padding to be extensible. Added get_window() vtable entry and
	dispatch it accordingly. Also added pulse() which was implemented
	in a hackish way before. Everything is of course backward
	compatible.

	* libgimp/gimpprogressbar.c: inmplement the get_window() stuff
	so a plug-in dialog containing a progress can be the transient
	parent of another dialog in another plug-in.

	* libgimp/gimpui.[ch] (gimp_ui_get_progress_window): new function
	which returns a foreign GdkWindow of this plug-ins progress
	window.

	Renamed gimp_window_set_transient_for_default_display() to
	gimp_window_set_transient() and make it use the progress' window
	handle instead of the display's (which is the right thing to do in
	almost all cases).

	* libgimp/gimp.def
	* libgimp/gimpui.def: add the new functions.

	* tools/pdbgen/enums.pl
	* app/pdb/internal_procs.c
	* app/pdb/progress_cmds.c
	* libgimp/gimpprogress_pdb.[ch]: regenerated.

	* libgimp/gimpexport.c
	* plug-ins/*/*.c: follow API change.
This commit is contained in:
Michael Natterer 2005-09-09 18:07:31 +00:00 • committed by Michael Natterer
parent 5a81d39e07
commit b10adabb5e
129 changed files with 1187 additions and 712 deletions
Download patch file Download diff file Expand all files Collapse all files

62
ChangeLog
View file

@ -1,3 +1,65 @@
2005-09-09 Michael Natterer <mitch@gimp.org>
Added parent window API to the GimpProgress interface and to
the libgimp progress stuff. Might look strange, but does
the right thing in almost all cases (image window, file dialog,
script-fu dialog etc). Fixes bug #62988.
* app/core/gimpprogress.[ch]: added GimpProgress::get_window()
which should return a toplevel window ID if the progress is in a
window that wants to be the transient parent of plug-in dialogs.
* app/widgets/gimpwidgets-utils.[ch] (gimp_window_get_native): new
function which returns the window handle of a GtkWindow's GdkWindow.
* app/widgets/gimpfiledialog.c: implement ::get_window().
* app/display/gimpdisplay.[ch]: ditto. Removed window handle API.
* app/gui/gui-vtable.c: changed accordingly.
* libgimpbase/gimpbaseenums.[ch] (enum GimpProgressCommand):
added GIMP_PROGRESS_COMMAND_GET_WINDOW.
* app/plug-in/plug-in-progress.[ch] (plug_in_progress_get_window):
new function. Also renamed some functions to match the
GimpProgress interface, and not the legacy PDB procedure names.
* tools/pdbgen/pdb/progress.pdb
* app/core/gimppdbprogress.c: implement get_window() on both
sides of the wire, keeping backward compatibility (hopefully).
* libgimp/gimpprogress.[ch]: deprecated gimp_progress_install()
and added gimp_progress_install_vtable() which takes a vtable with
padding to be extensible. Added get_window() vtable entry and
dispatch it accordingly. Also added pulse() which was implemented
in a hackish way before. Everything is of course backward
compatible.
* libgimp/gimpprogressbar.c: inmplement the get_window() stuff
so a plug-in dialog containing a progress can be the transient
parent of another dialog in another plug-in.
* libgimp/gimpui.[ch] (gimp_ui_get_progress_window): new function
which returns a foreign GdkWindow of this plug-ins progress
window.
Renamed gimp_window_set_transient_for_default_display() to
gimp_window_set_transient() and make it use the progress' window
handle instead of the display's (which is the right thing to do in
almost all cases).
* libgimp/gimp.def
* libgimp/gimpui.def: add the new functions.
* tools/pdbgen/enums.pl
* app/pdb/internal_procs.c
* app/pdb/progress_cmds.c
* libgimp/gimpprogress_pdb.[ch]: regenerated.
* libgimp/gimpexport.c
* plug-ins/*/*.c: follow API change.
2005-09-09 Tor Lillqvist <tml@novell.com> 2005-09-09 Tor Lillqvist <tml@novell.com>
* gimptool-win32.c.in (get_prefix, maybe_append_exe) * gimptool-win32.c.in (get_prefix, maybe_append_exe)

60
app/core/gimppdbprogress.c
View file

@ -60,18 +60,18 @@ static void gimp_pdb_progress_set_property (GObject *object,
const GValue *value, const GValue *value,
GParamSpec *pspec); GParamSpec *pspec);
static GimpProgress * static GimpProgress * gimp_pdb_progress_progress_start(GimpProgress *progress,
gimp_pdb_progress_progress_start (GimpProgress *progress, const gchar *message,
const gchar *message, gboolean cancelable);
gboolean cancelable); static void gimp_pdb_progress_progress_end (GimpProgress *progress);
static void gimp_pdb_progress_progress_end (GimpProgress *progress); static gboolean gimp_pdb_progress_progress_is_active (GimpProgress *progress);
static gboolean gimp_pdb_progress_progress_is_active (GimpProgress *progress); static void gimp_pdb_progress_progress_set_text (GimpProgress *progress,
static void gimp_pdb_progress_progress_set_text (GimpProgress *progress, const gchar *message);
const gchar *message); static void gimp_pdb_progress_progress_set_value (GimpProgress *progress,
static void gimp_pdb_progress_progress_set_value (GimpProgress *progress, gdouble percentage);
gdouble percentage); static gdouble gimp_pdb_progress_progress_get_value (GimpProgress *progress);
static gdouble gimp_pdb_progress_progress_get_value (GimpProgress *progress); static void gimp_pdb_progress_progress_pulse (GimpProgress *progress);
static void gimp_pdb_progress_progress_pulse (GimpProgress *progress); static guint32 gimp_pdb_progress_progress_get_window (GimpProgress *progress);
static GObjectClass *parent_class = NULL; static GObjectClass *parent_class = NULL;
@ -151,13 +151,14 @@ gimp_pdb_progress_init (GimpPdbProgress *progress,
static void static void
gimp_pdb_progress_progress_iface_init (GimpProgressInterface *progress_iface) gimp_pdb_progress_progress_iface_init (GimpProgressInterface *progress_iface)
{ {
progress_iface->start = gimp_pdb_progress_progress_start; progress_iface->start = gimp_pdb_progress_progress_start;
progress_iface->end = gimp_pdb_progress_progress_end; progress_iface->end = gimp_pdb_progress_progress_end;
progress_iface->is_active = gimp_pdb_progress_progress_is_active; progress_iface->is_active = gimp_pdb_progress_progress_is_active;
progress_iface->set_text = gimp_pdb_progress_progress_set_text; progress_iface->set_text = gimp_pdb_progress_progress_set_text;
progress_iface->set_value = gimp_pdb_progress_progress_set_value; progress_iface->set_value = gimp_pdb_progress_progress_set_value;
progress_iface->get_value = gimp_pdb_progress_progress_get_value; progress_iface->get_value = gimp_pdb_progress_progress_get_value;
progress_iface->pulse = gimp_pdb_progress_progress_pulse; progress_iface->pulse = gimp_pdb_progress_progress_pulse;
progress_iface->get_window = gimp_pdb_progress_progress_get_window;
} }
static GObject * static GObject *
@ -233,12 +234,14 @@ gimp_pdb_progress_set_property (GObject *object,
} }
} }
static void static gdouble
gimp_pdb_progress_run_callback (GimpPdbProgress *progress, gimp_pdb_progress_run_callback (GimpPdbProgress *progress,
GimpProgressCommand command, GimpProgressCommand command,
const gchar *text, const gchar *text,
gdouble value) gdouble value)
{ {
gdouble retval = 0;
if (progress->callback_name && ! progress->callback_busy) if (progress->callback_name && ! progress->callback_busy)
{ {
Argument *return_vals; Argument *return_vals;
@ -262,12 +265,18 @@ gimp_pdb_progress_run_callback (GimpPdbProgress *progress,
"The corresponding plug-in may have crashed."), "The corresponding plug-in may have crashed."),
g_type_name (G_TYPE_FROM_INSTANCE (progress))); g_type_name (G_TYPE_FROM_INSTANCE (progress)));
} }
else if (n_return_vals >= 2 && return_vals[1].arg_type == GIMP_PDB_FLOAT)
{
retval = return_vals[1].value.pdb_float;
}
if (return_vals) if (return_vals)
procedural_db_destroy_args (return_vals, n_return_vals); procedural_db_destroy_args (return_vals, n_return_vals);
progress->callback_busy = FALSE; progress->callback_busy = FALSE;
} }
return retval;
} }
static GimpProgress * static GimpProgress *
@ -363,6 +372,17 @@ gimp_pdb_progress_progress_pulse (GimpProgress *progress)
NULL, 0.0); NULL, 0.0);
} }
static guint32
gimp_pdb_progress_progress_get_window (GimpProgress *progress)
{
GimpPdbProgress *pdb_progress = GIMP_PDB_PROGRESS (progress);
return (guint32)
gimp_pdb_progress_run_callback (pdb_progress,
GIMP_PROGRESS_COMMAND_GET_WINDOW,
NULL, 0.0);
}
GimpPdbProgress * GimpPdbProgress *
gimp_pdb_progress_get_by_callback (GimpPdbProgressClass *klass, gimp_pdb_progress_get_by_callback (GimpPdbProgressClass *klass,
const gchar *callback_name) const gchar *callback_name)

15
app/core/gimpprogress.c
View file

@ -203,6 +203,21 @@ gimp_progress_pulse (GimpProgress *progress)
progress_iface->pulse (progress); progress_iface->pulse (progress);
} }
guint32
gimp_progress_get_window (GimpProgress *progress)
{
GimpProgressInterface *progress_iface;
g_return_val_if_fail (GIMP_IS_PROGRESS (progress), 0);
progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);
if (progress_iface->get_window)
return progress_iface->get_window (progress);
return 0;
}
void void
gimp_progress_message (GimpProgress *progress, gimp_progress_message (GimpProgress *progress,
Gimp *gimp, Gimp *gimp,

36
app/core/gimpprogress.h
View file

@ -36,26 +36,28 @@ struct _GimpProgressInterface
GTypeInterface base_iface; GTypeInterface base_iface;
/* virtual functions */ /* virtual functions */
GimpProgress * (* start) (GimpProgress *progress, GimpProgress * (* start) (GimpProgress *progress,
const gchar *message, const gchar *message,
gboolean cancelable); gboolean cancelable);
void (* end) (GimpProgress *progress); void (* end) (GimpProgress *progress);
gboolean (* is_active) (GimpProgress *progress); gboolean (* is_active) (GimpProgress *progress);
void (* set_text) (GimpProgress *progress, void (* set_text) (GimpProgress *progress,
const gchar *message); const gchar *message);
void (* set_value) (GimpProgress *progress, void (* set_value) (GimpProgress *progress,
gdouble percentage); gdouble percentage);
gdouble (* get_value) (GimpProgress *progress); gdouble (* get_value) (GimpProgress *progress);
void (* pulse) (GimpProgress *progress); void (* pulse) (GimpProgress *progress);
void (* message) (GimpProgress *progress, guint32 (* get_window) (GimpProgress *progress);
Gimp *gimp,
const gchar *domain, void (* message) (GimpProgress *progress,
const gchar *message); Gimp *gimp,
const gchar *domain,
const gchar *message);
/* signals */ /* signals */
void (* cancel) (GimpProgress *progress); void (* cancel) (GimpProgress *progress);
}; };
@ -74,6 +76,8 @@ void gimp_progress_set_value (GimpProgress *progress,
gdouble gimp_progress_get_value (GimpProgress *progress); gdouble gimp_progress_get_value (GimpProgress *progress);
void gimp_progress_pulse (GimpProgress *progress); void gimp_progress_pulse (GimpProgress *progress);
guint32 gimp_progress_get_window (GimpProgress *progress);
void gimp_progress_message (GimpProgress *progress, void gimp_progress_message (GimpProgress *progress,
Gimp *gimp, Gimp *gimp,
const gchar *domain, const gchar *domain,

133
app/display/gimpdisplay.c
View file

@ -20,14 +20,6 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#ifdef GDK_WINDOWING_WIN32
#include <gdk/gdkwin32.h>
#endif
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "display-types.h" #include "display-types.h"
#include "tools/tools-types.h" #include "tools/tools-types.h"
@ -37,6 +29,8 @@
#include "core/gimplist.h" #include "core/gimplist.h"
#include "core/gimpprogress.h" #include "core/gimpprogress.h"
#include "widgets/gimpwidgets-utils.h"
#include "tools/gimptool.h" #include "tools/gimptool.h"
#include "tools/tool_manager.h" #include "tools/tool_manager.h"
@ -64,37 +58,38 @@ static void gimp_display_class_init (GimpDisplayClass *klass);
static void gimp_display_init (GimpDisplay *gdisp); static void gimp_display_init (GimpDisplay *gdisp);
static void gimp_display_progress_iface_init (GimpProgressInterface *progress_iface); static void gimp_display_progress_iface_init (GimpProgressInterface *progress_iface);
static void gimp_display_set_property (GObject *object, static void gimp_display_set_property (GObject *object,
guint property_id, guint property_id,
const GValue *value, const GValue *value,
GParamSpec *pspec); GParamSpec *pspec);
static void gimp_display_get_property (GObject *object, static void gimp_display_get_property (GObject *object,
guint property_id, guint property_id,
GValue *value, GValue *value,
GParamSpec *pspec); GParamSpec *pspec);
static GimpProgress * static GimpProgress *
gimp_display_progress_start (GimpProgress *progress, gimp_display_progress_start (GimpProgress *progress,
const gchar *message, const gchar *message,
gboolean cancelable); gboolean cancelable);
static void gimp_display_progress_end (GimpProgress *progress); static void gimp_display_progress_end (GimpProgress *progress);
static gboolean gimp_display_progress_is_active (GimpProgress *progress); static gboolean gimp_display_progress_is_active (GimpProgress *progress);
static void gimp_display_progress_set_text (GimpProgress *progress, static void gimp_display_progress_set_text (GimpProgress *progress,
const gchar *message); const gchar *message);
static void gimp_display_progress_set_value (GimpProgress *progress, static void gimp_display_progress_set_value (GimpProgress *progress,
gdouble percentage); gdouble percentage);
static gdouble gimp_display_progress_get_value (GimpProgress *progress); static gdouble gimp_display_progress_get_value (GimpProgress *progress);
static void gimp_display_progress_pulse (GimpProgress *progress); static void gimp_display_progress_pulse (GimpProgress *progress);
static void gimp_display_progress_canceled (GimpProgress *progress, static guint32 gimp_display_progress_get_window (GimpProgress *progress);
GimpDisplay *display); static void gimp_display_progress_canceled (GimpProgress *progress,
GimpDisplay *display);
static void gimp_display_flush_whenever (GimpDisplay *gdisp, static void gimp_display_flush_whenever (GimpDisplay *gdisp,
gboolean now); gboolean now);
static void gimp_display_paint_area (GimpDisplay *gdisp, static void gimp_display_paint_area (GimpDisplay *gdisp,
gint x, gint x,
gint y, gint y,
gint w, gint w,
gint h); gint h);
static GimpObjectClass *parent_class = NULL; static GimpObjectClass *parent_class = NULL;
@ -184,13 +179,14 @@ gimp_display_init (GimpDisplay *gdisp)
static void static void
gimp_display_progress_iface_init (GimpProgressInterface *progress_iface) gimp_display_progress_iface_init (GimpProgressInterface *progress_iface)
{ {
progress_iface->start = gimp_display_progress_start; progress_iface->start = gimp_display_progress_start;
progress_iface->end = gimp_display_progress_end; progress_iface->end = gimp_display_progress_end;
progress_iface->is_active = gimp_display_progress_is_active; progress_iface->is_active = gimp_display_progress_is_active;
progress_iface->set_text = gimp_display_progress_set_text; progress_iface->set_text = gimp_display_progress_set_text;
progress_iface->set_value = gimp_display_progress_set_value; progress_iface->set_value = gimp_display_progress_set_value;
progress_iface->get_value = gimp_display_progress_get_value; progress_iface->get_value = gimp_display_progress_get_value;
progress_iface->pulse = gimp_display_progress_pulse; progress_iface->pulse = gimp_display_progress_pulse;
progress_iface->get_window = gimp_display_progress_get_window;
} }
static void static void
@ -344,6 +340,17 @@ gimp_display_progress_pulse (GimpProgress *progress)
gimp_progress_pulse (GIMP_PROGRESS (shell->statusbar)); gimp_progress_pulse (GIMP_PROGRESS (shell->statusbar));
} }
static guint32
gimp_display_progress_get_window (GimpProgress *progress)
{
GimpDisplay *display = GIMP_DISPLAY (progress);
if (! display->shell)
return 0;
return (guint32) gimp_window_get_native (GTK_WINDOW (display->shell));
}
static void static void
gimp_display_progress_canceled (GimpProgress *progress, gimp_display_progress_canceled (GimpProgress *progress,
GimpDisplay *display) GimpDisplay *display)
@ -446,46 +453,6 @@ gimp_display_get_ID (GimpDisplay *gdisp)
return gdisp->ID; return gdisp->ID;
} }
/**
* gimp_display_get_window:
* @display: a #GimpDisplayShell
*
* This function is used to pass a window handle to plug-ins so that
* they can set their dialog windows transient to the image display.
*
* Return value: a native window handle of the display's shell or 0
* if the shell isn't realized yet
*/
GdkNativeWindow
gimp_display_get_window (GimpDisplay *display)
{
GtkWidget *shell;
#ifdef GDK_NATIVE_WINDOW_POINTER
g_return_val_if_fail (GIMP_IS_DISPLAY (display), NULL);
#else
g_return_val_if_fail (GIMP_IS_DISPLAY (display), 0);
#endif
shell = display->shell;
#ifdef GDK_WINDOWING_WIN32
if (shell && GTK_WIDGET_REALIZED (shell))
return GDK_WINDOW_HWND (shell->window);
#endif
#ifdef GDK_WINDOWING_X11
if (shell && GTK_WIDGET_REALIZED (shell))
return GDK_WINDOW_XID (shell->window);
#endif
#ifdef GDK_NATIVE_WINDOW_POINTER
return NULL;
#else
return 0;
#endif
}
GimpDisplay * GimpDisplay *
gimp_display_get_by_ID (Gimp *gimp, gimp_display_get_by_ID (Gimp *gimp,
gint ID) gint ID)

41
app/display/gimpdisplay.h
View file

@ -54,32 +54,31 @@ struct _GimpDisplayClass
}; };
GType gimp_display_get_type (void) G_GNUC_CONST; GType gimp_display_get_type (void) G_GNUC_CONST;
GimpDisplay * gimp_display_new (GimpImage *gimage, GimpDisplay * gimp_display_new (GimpImage *gimage,
GimpUnit unit, GimpUnit unit,
gdouble scale, gdouble scale,
GimpMenuFactory *menu_factory, GimpMenuFactory *menu_factory,
GimpUIManager *popup_manager); GimpUIManager *popup_manager);
void gimp_display_delete (GimpDisplay *gdisp); void gimp_display_delete (GimpDisplay *gdisp);
gint gimp_display_get_ID (GimpDisplay *gdisp); gint gimp_display_get_ID (GimpDisplay *gdisp);
GdkNativeWindow gimp_display_get_window (GimpDisplay *gdisp); GimpDisplay * gimp_display_get_by_ID (Gimp *gimp,
GimpDisplay * gimp_display_get_by_ID (Gimp *gimp, gint ID);
gint ID);
void gimp_display_reconnect (GimpDisplay *gdisp, void gimp_display_reconnect (GimpDisplay *gdisp,
GimpImage *gimage); GimpImage *gimage);
void gimp_display_update_area (GimpDisplay *gdisp, void gimp_display_update_area (GimpDisplay *gdisp,
gboolean now, gboolean now,
gint x, gint x,
gint y, gint y,
gint w, gint w,
gint h); gint h);
void gimp_display_flush (GimpDisplay *gdisp); void gimp_display_flush (GimpDisplay *gdisp);
void gimp_display_flush_now (GimpDisplay *gdisp); void gimp_display_flush_now (GimpDisplay *gdisp);
#endif /* __GIMP_DISPLAY_H__ */ #endif /* __GIMP_DISPLAY_H__ */

13
app/gui/gui-vtable.c
View file

@ -58,6 +58,7 @@
#include "widgets/gimppatternselect.h" #include "widgets/gimppatternselect.h"
#include "widgets/gimpprogressdialog.h" #include "widgets/gimpprogressdialog.h"
#include "widgets/gimpuimanager.h" #include "widgets/gimpuimanager.h"
#include "widgets/gimpwidgets-utils.h"
#include "display/gimpdisplay.h" #include "display/gimpdisplay.h"
#include "display/gimpdisplay-foreach.h" #include "display/gimpdisplay-foreach.h"
@ -333,14 +334,12 @@ gui_display_get_ID (GimpObject *display)
static guint32 static guint32
gui_display_get_window (GimpObject *display) gui_display_get_window (GimpObject *display)
{ {
#ifdef GDK_NATIVE_WINDOW_POINTER GimpDisplay *disp = GIMP_DISPLAY (display);
#ifdef __GNUC__
#warning gui_display_get_window() unimplementable for the target windowing system if (disp->shell)
#endif return (guint32) gimp_window_get_native (GTK_WINDOW (disp->shell));
return 0; return 0;
#else
return (guint32) gimp_display_get_window (GIMP_DISPLAY (display));
#endif
} }
static GimpObject * static GimpObject *

60
app/pdb/internal_procs.c
View file

@ -75,7 +75,7 @@ void register_undo_procs (Gimp *gimp);
void register_unit_procs (Gimp *gimp); void register_unit_procs (Gimp *gimp);
void register_vectors_procs (Gimp *gimp); void register_vectors_procs (Gimp *gimp);
/* 474 procedures registered total */ /* 475 procedures registered total */
void void
internal_procs_init (Gimp *gimp, internal_procs_init (Gimp *gimp,
@ -102,13 +102,13 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Context"), 0.12); (* status_callback) (NULL, _("Context"), 0.12);
register_context_procs (gimp); register_context_procs (gimp);
(* status_callback) (NULL, _("Convert"), 0.167); (* status_callback) (NULL, _("Convert"), 0.166);
register_convert_procs (gimp); register_convert_procs (gimp);
(* status_callback) (NULL, _("Display procedures"), 0.173); (* status_callback) (NULL, _("Display procedures"), 0.173);
register_display_procs (gimp); register_display_procs (gimp);
(* status_callback) (NULL, _("Drawable procedures"), 0.184); (* status_callback) (NULL, _("Drawable procedures"), 0.183);
register_drawable_procs (gimp); register_drawable_procs (gimp);
(* status_callback) (NULL, _("Transformation procedures"), 0.257); (* status_callback) (NULL, _("Transformation procedures"), 0.257);
@ -117,82 +117,82 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Edit procedures"), 0.291); (* status_callback) (NULL, _("Edit procedures"), 0.291);
register_edit_procs (gimp); register_edit_procs (gimp);
(* status_callback) (NULL, _("File Operations"), 0.327); (* status_callback) (NULL, _("File Operations"), 0.326);
register_fileops_procs (gimp); register_fileops_procs (gimp);
(* status_callback) (NULL, _("Floating selections"), 0.348); (* status_callback) (NULL, _("Floating selections"), 0.347);
register_floating_sel_procs (gimp); register_floating_sel_procs (gimp);
(* status_callback) (NULL, _("Font UI"), 0.361); (* status_callback) (NULL, _("Font UI"), 0.36);
register_font_select_procs (gimp); register_font_select_procs (gimp);
(* status_callback) (NULL, _("Fonts"), 0.367); (* status_callback) (NULL, _("Fonts"), 0.366);
register_fonts_procs (gimp); register_fonts_procs (gimp);
(* status_callback) (NULL, _("Gimprc procedures"), 0.371); (* status_callback) (NULL, _("Gimprc procedures"), 0.371);
register_gimprc_procs (gimp); register_gimprc_procs (gimp);
(* status_callback) (NULL, _("Gradient"), 0.386); (* status_callback) (NULL, _("Gradient"), 0.385);
register_gradient_procs (gimp); register_gradient_procs (gimp);
(* status_callback) (NULL, _("Gradient UI"), 0.449); (* status_callback) (NULL, _("Gradient UI"), 0.448);
register_gradient_select_procs (gimp); register_gradient_select_procs (gimp);
(* status_callback) (NULL, _("Gradients"), 0.456); (* status_callback) (NULL, _("Gradients"), 0.455);
register_gradients_procs (gimp); register_gradients_procs (gimp);
(* status_callback) (NULL, _("Guide procedures"), 0.466); (* status_callback) (NULL, _("Guide procedures"), 0.465);
register_guides_procs (gimp); register_guides_procs (gimp);
(* status_callback) (NULL, _("Help procedures"), 0.479); (* status_callback) (NULL, _("Help procedures"), 0.478);
register_help_procs (gimp); register_help_procs (gimp);
(* status_callback) (NULL, _("Image"), 0.481); (* status_callback) (NULL, _("Image"), 0.48);
register_image_procs (gimp); register_image_procs (gimp);
(* status_callback) (NULL, _("Layer"), 0.614); (* status_callback) (NULL, _("Layer"), 0.613);
register_layer_procs (gimp); register_layer_procs (gimp);
(* status_callback) (NULL, _("Message procedures"), 0.671); (* status_callback) (NULL, _("Message procedures"), 0.669);
register_message_procs (gimp); register_message_procs (gimp);
(* status_callback) (NULL, _("Miscellaneous"), 0.677); (* status_callback) (NULL, _("Miscellaneous"), 0.676);
register_misc_procs (gimp); register_misc_procs (gimp);
(* status_callback) (NULL, _("Paint Tool procedures"), 0.684); (* status_callback) (NULL, _("Paint Tool procedures"), 0.682);
register_paint_tools_procs (gimp); register_paint_tools_procs (gimp);
(* status_callback) (NULL, _("Palette"), 0.715); (* status_callback) (NULL, _("Palette"), 0.714);
register_palette_procs (gimp); register_palette_procs (gimp);
(* status_callback) (NULL, _("Palette UI"), 0.745); (* status_callback) (NULL, _("Palette UI"), 0.743);
register_palette_select_procs (gimp); register_palette_select_procs (gimp);
(* status_callback) (NULL, _("Palettes"), 0.751); (* status_callback) (NULL, _("Palettes"), 0.749);
register_palettes_procs (gimp); register_palettes_procs (gimp);
(* status_callback) (NULL, _("Parasite procedures"), 0.759); (* status_callback) (NULL, _("Parasite procedures"), 0.758);
register_parasite_procs (gimp); register_parasite_procs (gimp);
(* status_callback) (NULL, _("Paths"), 0.785); (* status_callback) (NULL, _("Paths"), 0.783);
register_paths_procs (gimp); register_paths_procs (gimp);
(* status_callback) (NULL, _("Pattern"), 0.819); (* status_callback) (NULL, _("Pattern"), 0.817);
register_pattern_procs (gimp); register_pattern_procs (gimp);
(* status_callback) (NULL, _("Pattern UI"), 0.823); (* status_callback) (NULL, _("Pattern UI"), 0.821);
register_pattern_select_procs (gimp); register_pattern_select_procs (gimp);
(* status_callback) (NULL, _("Patterns"), 0.829); (* status_callback) (NULL, _("Patterns"), 0.827);
register_patterns_procs (gimp); register_patterns_procs (gimp);
(* status_callback) (NULL, _("Plug-in"), 0.838); (* status_callback) (NULL, _("Plug-in"), 0.836);
register_plug_in_procs (gimp); register_plug_in_procs (gimp);
(* status_callback) (NULL, _("Procedural database"), 0.85); (* status_callback) (NULL, _("Procedural database"), 0.848);
register_procedural_db_procs (gimp); register_procedural_db_procs (gimp);
(* status_callback) (NULL, _("Progress"), 0.869); (* status_callback) (NULL, _("Progress"), 0.867);
register_progress_procs (gimp); register_progress_procs (gimp);
(* status_callback) (NULL, _("Image mask"), 0.884); (* status_callback) (NULL, _("Image mask"), 0.884);
@ -201,13 +201,13 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Selection Tool procedures"), 0.92); (* status_callback) (NULL, _("Selection Tool procedures"), 0.92);
register_selection_tools_procs (gimp); register_selection_tools_procs (gimp);
(* status_callback) (NULL, _("Text procedures"), 0.93); (* status_callback) (NULL, _("Text procedures"), 0.931);
register_text_tool_procs (gimp); register_text_tool_procs (gimp);
(* status_callback) (NULL, _("Transform Tool procedures"), 0.939); (* status_callback) (NULL, _("Transform Tool procedures"), 0.939);
register_transform_tools_procs (gimp); register_transform_tools_procs (gimp);
(* status_callback) (NULL, _("Undo"), 0.951); (* status_callback) (NULL, _("Undo"), 0.952);
register_undo_procs (gimp); register_undo_procs (gimp);
(* status_callback) (NULL, _("Units"), 0.966); (* status_callback) (NULL, _("Units"), 0.966);

57
app/pdb/progress_cmds.c
View file

@ -34,6 +34,7 @@ static ProcRecord progress_init_proc;
static ProcRecord progress_update_proc; static ProcRecord progress_update_proc;
static ProcRecord progress_pulse_proc; static ProcRecord progress_pulse_proc;
static ProcRecord progress_set_text_proc; static ProcRecord progress_set_text_proc;
static ProcRecord progress_get_window_handle_proc;
static ProcRecord progress_install_proc; static ProcRecord progress_install_proc;
static ProcRecord progress_uninstall_proc; static ProcRecord progress_uninstall_proc;
static ProcRecord progress_cancel_proc; static ProcRecord progress_cancel_proc;
@ -45,6 +46,7 @@ register_progress_procs (Gimp *gimp)
procedural_db_register (gimp, &progress_update_proc); procedural_db_register (gimp, &progress_update_proc);
procedural_db_register (gimp, &progress_pulse_proc); procedural_db_register (gimp, &progress_pulse_proc);
procedural_db_register (gimp, &progress_set_text_proc); procedural_db_register (gimp, &progress_set_text_proc);
procedural_db_register (gimp, &progress_get_window_handle_proc);
procedural_db_register (gimp, &progress_install_proc); procedural_db_register (gimp, &progress_install_proc);
procedural_db_register (gimp, &progress_uninstall_proc); procedural_db_register (gimp, &progress_uninstall_proc);
procedural_db_register (gimp, &progress_cancel_proc); procedural_db_register (gimp, &progress_cancel_proc);
@ -126,7 +128,7 @@ progress_update_invoker (Gimp *gimp,
if (gimp->current_plug_in && gimp->current_plug_in->open) if (gimp->current_plug_in && gimp->current_plug_in->open)
{ {
if (! gimp->no_interface) if (! gimp->no_interface)
plug_in_progress_update (gimp->current_plug_in, percentage); plug_in_progress_set_value (gimp->current_plug_in, percentage);
} }
else else
success = FALSE; success = FALSE;
@ -250,6 +252,59 @@ static ProcRecord progress_set_text_proc =
{ { progress_set_text_invoker } } { { progress_set_text_invoker } }
}; };
static Argument *
progress_get_window_handle_invoker (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
gint32 window = 0;
if (gimp->current_plug_in && gimp->current_plug_in->open)
{
if (! gimp->no_interface)
window = plug_in_progress_get_window (gimp->current_plug_in);
}
else
success = FALSE;
return_args = procedural_db_return_args (&progress_get_window_handle_proc, success);
if (success)
return_args[1].value.pdb_int = window;
return return_args;
}
static ProcArg progress_get_window_handle_outargs[] =
{
{
GIMP_PDB_INT32,
"window",
"The progress bar's toplevel window"
}
};
static ProcRecord progress_get_window_handle_proc =
{
"gimp-progress-get-window-handle",
"gimp-progress-get-window-handle",
"Returns the native window ID of the toplevel window this plug-in's progress is displayed in.",
"This function returns the native window ID of the toplevel window this plug-in\'s progress is displayed in.",
"Michael Natterer <mitch@gimp.org>",
"Michael Natterer",
"2004",
NULL,
GIMP_INTERNAL,
0,
NULL,
1,
progress_get_window_handle_outargs,
{ { progress_get_window_handle_invoker } }
};
static Argument * static Argument *
progress_install_invoker (Gimp *gimp, progress_install_invoker (Gimp *gimp,
GimpContext *context, GimpContext *context,

87
app/plug-in/gimpplugin-progress.c
View file

@ -91,8 +91,52 @@ plug_in_progress_start (PlugIn *plug_in,
} }
void void
plug_in_progress_update (PlugIn *plug_in, plug_in_progress_end (PlugIn *plug_in)
gdouble percentage) {
PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL);
proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
{
if (proc_frame->progress_cancel_id)
{
g_signal_handler_disconnect (proc_frame->progress,
proc_frame->progress_cancel_id);
proc_frame->progress_cancel_id = 0;
}
if (gimp_progress_is_active (proc_frame->progress))
gimp_progress_end (proc_frame->progress);
if (proc_frame->progress_created)
{
gimp_free_progress (plug_in->gimp, proc_frame->progress);
g_object_unref (proc_frame->progress);
proc_frame->progress = NULL;
}
}
}
void
plug_in_progress_set_text (PlugIn *plug_in,
const gchar *message)
{
PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL);
proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
gimp_progress_set_text (proc_frame->progress, message);
}
void
plug_in_progress_set_value (PlugIn *plug_in,
gdouble percentage)
{ {
PlugInProcFrame *proc_frame; PlugInProcFrame *proc_frame;
@ -131,48 +175,19 @@ plug_in_progress_pulse (PlugIn *plug_in)
gimp_progress_pulse (proc_frame->progress); gimp_progress_pulse (proc_frame->progress);
} }
void guint32
plug_in_progress_set_text (PlugIn *plug_in, plug_in_progress_get_window (PlugIn *plug_in)
const gchar *message)
{ {
PlugInProcFrame *proc_frame; PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL); g_return_val_if_fail (plug_in != NULL, 0);
proc_frame = plug_in_get_proc_frame (plug_in); proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress) if (proc_frame->progress)
gimp_progress_set_text (proc_frame->progress, message); return gimp_progress_get_window (proc_frame->progress);
}
void return 0;
plug_in_progress_end (PlugIn *plug_in)
{
PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL);
proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
{
if (proc_frame->progress_cancel_id)
{
g_signal_handler_disconnect (proc_frame->progress,
proc_frame->progress_cancel_id);
proc_frame->progress_cancel_id = 0;
}
if (gimp_progress_is_active (proc_frame->progress))
gimp_progress_end (proc_frame->progress);
if (proc_frame->progress_created)
{
gimp_free_progress (plug_in->gimp, proc_frame->progress);
g_object_unref (proc_frame->progress);
proc_frame->progress = NULL;
}
}
} }
gboolean gboolean

35
app/plug-in/gimpplugin-progress.h
View file

@ -22,25 +22,26 @@
#define __PLUG_IN_PROGRESS_H__ #define __PLUG_IN_PROGRESS_H__
void plug_in_progress_start (PlugIn *plug_in, void plug_in_progress_start (PlugIn *plug_in,
const gchar *message, const gchar *message,
gint display_ID); gint display_ID);
void plug_in_progress_update (PlugIn *plug_in, void plug_in_progress_end (PlugIn *plug_in);
gdouble percentage); void plug_in_progress_set_text (PlugIn *plug_in,
void plug_in_progress_pulse (PlugIn *plug_in); const gchar *message);
void plug_in_progress_set_text (PlugIn *plug_in, void plug_in_progress_set_value (PlugIn *plug_in,
const gchar *message); gdouble percentage);
void plug_in_progress_end (PlugIn *plug_in); void plug_in_progress_pulse (PlugIn *plug_in);
guint32 plug_in_progress_get_window (PlugIn *plug_in);
gboolean plug_in_progress_install (PlugIn *plug_in, gboolean plug_in_progress_install (PlugIn *plug_in,
const gchar *progress_callback); const gchar *progress_callback);
gboolean plug_in_progress_uninstall (PlugIn *plug_in, gboolean plug_in_progress_uninstall (PlugIn *plug_in,
const gchar *progress_callback); const gchar *progress_callback);
gboolean plug_in_progress_cancel (PlugIn *plug_in, gboolean plug_in_progress_cancel (PlugIn *plug_in,
const gchar *progress_callback); const gchar *progress_callback);
void plug_in_progress_message (PlugIn *plug_in, void plug_in_progress_message (PlugIn *plug_in,
const gchar *message); const gchar *message);
#endif /* __PLUG_IN_PROGRESS_H__ */ #endif /* __PLUG_IN_PROGRESS_H__ */

87
app/plug-in/plug-in-progress.c
View file

@ -91,8 +91,52 @@ plug_in_progress_start (PlugIn *plug_in,
} }
void void
plug_in_progress_update (PlugIn *plug_in, plug_in_progress_end (PlugIn *plug_in)
gdouble percentage) {
PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL);
proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
{
if (proc_frame->progress_cancel_id)
{
g_signal_handler_disconnect (proc_frame->progress,
proc_frame->progress_cancel_id);
proc_frame->progress_cancel_id = 0;
}
if (gimp_progress_is_active (proc_frame->progress))
gimp_progress_end (proc_frame->progress);
if (proc_frame->progress_created)
{
gimp_free_progress (plug_in->gimp, proc_frame->progress);
g_object_unref (proc_frame->progress);
proc_frame->progress = NULL;
}
}
}
void
plug_in_progress_set_text (PlugIn *plug_in,
const gchar *message)
{
PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL);
proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
gimp_progress_set_text (proc_frame->progress, message);
}
void
plug_in_progress_set_value (PlugIn *plug_in,
gdouble percentage)
{ {
PlugInProcFrame *proc_frame; PlugInProcFrame *proc_frame;
@ -131,48 +175,19 @@ plug_in_progress_pulse (PlugIn *plug_in)
gimp_progress_pulse (proc_frame->progress); gimp_progress_pulse (proc_frame->progress);
} }
void guint32
plug_in_progress_set_text (PlugIn *plug_in, plug_in_progress_get_window (PlugIn *plug_in)
const gchar *message)
{ {
PlugInProcFrame *proc_frame; PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL); g_return_val_if_fail (plug_in != NULL, 0);
proc_frame = plug_in_get_proc_frame (plug_in); proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress) if (proc_frame->progress)
gimp_progress_set_text (proc_frame->progress, message); return gimp_progress_get_window (proc_frame->progress);
}
void return 0;
plug_in_progress_end (PlugIn *plug_in)
{
PlugInProcFrame *proc_frame;
g_return_if_fail (plug_in != NULL);
proc_frame = plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
{
if (proc_frame->progress_cancel_id)
{
g_signal_handler_disconnect (proc_frame->progress,
proc_frame->progress_cancel_id);
proc_frame->progress_cancel_id = 0;
}
if (gimp_progress_is_active (proc_frame->progress))
gimp_progress_end (proc_frame->progress);
if (proc_frame->progress_created)
{
gimp_free_progress (plug_in->gimp, proc_frame->progress);
g_object_unref (proc_frame->progress);
proc_frame->progress = NULL;
}
}
} }
gboolean gboolean

35
app/plug-in/plug-in-progress.h
View file

@ -22,25 +22,26 @@
#define __PLUG_IN_PROGRESS_H__ #define __PLUG_IN_PROGRESS_H__
void plug_in_progress_start (PlugIn *plug_in, void plug_in_progress_start (PlugIn *plug_in,
const gchar *message, const gchar *message,
gint display_ID); gint display_ID);
void plug_in_progress_update (PlugIn *plug_in, void plug_in_progress_end (PlugIn *plug_in);
gdouble percentage); void plug_in_progress_set_text (PlugIn *plug_in,
void plug_in_progress_pulse (PlugIn *plug_in); const gchar *message);
void plug_in_progress_set_text (PlugIn *plug_in, void plug_in_progress_set_value (PlugIn *plug_in,
const gchar *message); gdouble percentage);
void plug_in_progress_end (PlugIn *plug_in); void plug_in_progress_pulse (PlugIn *plug_in);
guint32 plug_in_progress_get_window (PlugIn *plug_in);
gboolean plug_in_progress_install (PlugIn *plug_in, gboolean plug_in_progress_install (PlugIn *plug_in,
const gchar *progress_callback); const gchar *progress_callback);
gboolean plug_in_progress_uninstall (PlugIn *plug_in, gboolean plug_in_progress_uninstall (PlugIn *plug_in,
const gchar *progress_callback); const gchar *progress_callback);
gboolean plug_in_progress_cancel (PlugIn *plug_in, gboolean plug_in_progress_cancel (PlugIn *plug_in,
const gchar *progress_callback); const gchar *progress_callback);
void plug_in_progress_message (PlugIn *plug_in, void plug_in_progress_message (PlugIn *plug_in,
const gchar *message); const gchar *message);
#endif /* __PLUG_IN_PROGRESS_H__ */ #endif /* __PLUG_IN_PROGRESS_H__ */

24
app/widgets/gimpfiledialog.c
View file

@ -75,6 +75,7 @@ static void gimp_file_dialog_progress_set_value (GimpProgress *progress,
gdouble percentage); gdouble percentage);
static gdouble gimp_file_dialog_progress_get_value (GimpProgress *progress); static gdouble gimp_file_dialog_progress_get_value (GimpProgress *progress);
static void gimp_file_dialog_progress_pulse (GimpProgress *progress); static void gimp_file_dialog_progress_pulse (GimpProgress *progress);
static guint32 gimp_file_dialog_progress_get_window(GimpProgress *progress);
static void gimp_file_dialog_add_preview (GimpFileDialog *dialog, static void gimp_file_dialog_add_preview (GimpFileDialog *dialog,
Gimp *gimp); Gimp *gimp);
@ -155,13 +156,14 @@ gimp_file_dialog_class_init (GimpFileDialogClass *klass)
static void static void
gimp_file_dialog_progress_iface_init (GimpProgressInterface *progress_iface) gimp_file_dialog_progress_iface_init (GimpProgressInterface *progress_iface)
{ {
progress_iface->start = gimp_file_dialog_progress_start; progress_iface->start = gimp_file_dialog_progress_start;
progress_iface->end = gimp_file_dialog_progress_end; progress_iface->end = gimp_file_dialog_progress_end;
progress_iface->is_active = gimp_file_dialog_progress_is_active; progress_iface->is_active = gimp_file_dialog_progress_is_active;
progress_iface->set_text = gimp_file_dialog_progress_set_text; progress_iface->set_text = gimp_file_dialog_progress_set_text;
progress_iface->set_value = gimp_file_dialog_progress_set_value; progress_iface->set_value = gimp_file_dialog_progress_set_value;
progress_iface->get_value = gimp_file_dialog_progress_get_value; progress_iface->get_value = gimp_file_dialog_progress_get_value;
progress_iface->pulse = gimp_file_dialog_progress_pulse; progress_iface->pulse = gimp_file_dialog_progress_pulse;
progress_iface->get_window = gimp_file_dialog_progress_get_window;
} }
static gboolean static gboolean
@ -294,6 +296,14 @@ gimp_file_dialog_progress_pulse (GimpProgress *progress)
} }
} }
static guint32
gimp_file_dialog_progress_get_window (GimpProgress *progress)
{
GimpFileDialog *dialog = GIMP_FILE_DIALOG (progress);
return (guint32) gimp_window_get_native (GTK_WINDOW (dialog));
}
/* public functions */ /* public functions */

44
app/widgets/gimpwidgets-utils.c
View file

@ -40,6 +40,14 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#ifdef GDK_WINDOWING_WIN32
#include <gdk/gdkwin32.h>
#endif
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "libgimpbase/gimpbase.h" #include "libgimpbase/gimpbase.h"
#include "libgimpcolor/gimpcolor.h" #include "libgimpcolor/gimpcolor.h"
#include "libgimpwidgets/gimpwidgets.h" #include "libgimpwidgets/gimpwidgets.h"
@ -708,6 +716,40 @@ gimp_window_set_hint (GtkWindow *window,
} }
} }
/**
* gimp_window_get_native:
* @window: a #GtkWindow
*
* This function is used to pass a window handle to plug-ins so that
* they can set their dialog windows transient to the parent window.
*
* Return value: a native window handle of the window's #GdkWindow or 0
* if the window isn't realized yet
*/
GdkNativeWindow
gimp_window_get_native (GtkWindow *window)
{
g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
#ifdef GDK_NATIVE_WINDOW_POINTER
#ifdef __GNUC__
#warning gimp_window_get_native() unimplementable for the target windowing system
#endif
#endif
#ifdef GDK_WINDOWING_WIN32
if (window && GTK_WIDGET_REALIZED (window))
return GDK_WINDOW_HWND (GTK_WIDGET (window)->window);
#endif
#ifdef GDK_WINDOWING_X11
if (window && GTK_WIDGET_REALIZED (window))
return GDK_WINDOW_XID (GTK_WIDGET (window)->window);
#endif
return 0;
}
void void
gimp_dialog_set_sensitive (GtkDialog *dialog, gimp_dialog_set_sensitive (GtkDialog *dialog,
gboolean sensitive) gboolean sensitive)
@ -864,7 +906,7 @@ gimp_toggle_button_set_visible (GtkToggleButton *toggle,
} }
#ifdef __GNUC__ #ifdef __GNUC__
#warning FIXME: remove this function as soon as bug #141750 is fixed. #warning FIXME: remove this function as soon as we depend on GTK >= 2.8
#endif #endif
GClosure * GClosure *
gimp_action_get_accel_closure (GtkAction *action) gimp_action_get_accel_closure (GtkAction *action)

101
app/widgets/gimpwidgets-utils.h
View file

@ -23,66 +23,67 @@
#define __GIMP_WIDGETS_UTILS_H__ #define __GIMP_WIDGETS_UTILS_H__
void gimp_menu_position (GtkMenu *menu, void gimp_menu_position (GtkMenu *menu,
gint *x, gint *x,
gint *y); gint *y);
void gimp_button_menu_position (GtkWidget *button, void gimp_button_menu_position (GtkWidget *button,
GtkMenu *menu, GtkMenu *menu,
GtkPositionType position, GtkPositionType position,
gint *x, gint *x,
gint *y); gint *y);
void gimp_table_attach_stock (GtkTable *table, void gimp_table_attach_stock (GtkTable *table,
gint row, gint row,
const gchar *stock_id, const gchar *stock_id,
GtkWidget *widget, GtkWidget *widget,
gint colspan, gint colspan,
gboolean left_align); gboolean left_align);
void gimp_enum_radio_frame_add (GtkFrame *frame, void gimp_enum_radio_frame_add (GtkFrame *frame,
GtkWidget *widget, GtkWidget *widget,
gint enum_value); gint enum_value);
GtkIconSize gimp_get_icon_size (GtkWidget *widget, GtkIconSize gimp_get_icon_size (GtkWidget *widget,
const gchar *stock_id, const gchar *stock_id,
GtkIconSize max_size, GtkIconSize max_size,
gint width, gint width,
gint height); gint height);
const gchar * gimp_get_mod_name_shift (void); const gchar * gimp_get_mod_name_shift (void);
const gchar * gimp_get_mod_name_control (void); const gchar * gimp_get_mod_name_control (void);
const gchar * gimp_get_mod_name_alt (void); const gchar * gimp_get_mod_name_alt (void);
const gchar * gimp_get_mod_separator (void); const gchar * gimp_get_mod_separator (void);
const gchar * gimp_get_mod_string (GdkModifierType modifiers); const gchar * gimp_get_mod_string (GdkModifierType modifiers);
gchar * gimp_get_accel_string (guint key, gchar * gimp_get_accel_string (guint key,
GdkModifierType modifiers); GdkModifierType modifiers);
void gimp_get_screen_resolution (GdkScreen *screen, void gimp_get_screen_resolution (GdkScreen *screen,
gdouble *xres, gdouble *xres,
gdouble *yres); gdouble *yres);
void gimp_rgb_get_gdk_color (const GimpRGB *rgb, void gimp_rgb_get_gdk_color (const GimpRGB *rgb,
GdkColor *gdk_color); GdkColor *gdk_color);
void gimp_rgb_set_gdk_color (GimpRGB *rgb, void gimp_rgb_set_gdk_color (GimpRGB *rgb,
const GdkColor *gdk_color); const GdkColor *gdk_color);
void gimp_window_set_hint (GtkWindow *window, void gimp_window_set_hint (GtkWindow *window,
GimpWindowHint hint); GimpWindowHint hint);
GdkNativeWindow gimp_window_get_native (GtkWindow *window);
void gimp_dialog_set_sensitive (GtkDialog *dialog, void gimp_dialog_set_sensitive (GtkDialog *dialog,
gboolean sensitive); gboolean sensitive);
gboolean gimp_text_buffer_load (GtkTextBuffer *buffer, gboolean gimp_text_buffer_load (GtkTextBuffer *buffer,
const gchar *filename, const gchar *filename,
GError **error); GError **error);
gboolean gimp_text_buffer_save (GtkTextBuffer *buffer, gboolean gimp_text_buffer_save (GtkTextBuffer *buffer,
const gchar *filename, const gchar *filename,
gboolean selection_only, gboolean selection_only,
GError **error); GError **error);
void gimp_toggle_button_set_visible (GtkToggleButton *toggle, void gimp_toggle_button_set_visible (GtkToggleButton *toggle,
GtkWidget *widget); GtkWidget *widget);
GClosure * gimp_action_get_accel_closure (GtkAction *action); GClosure * gimp_action_get_accel_closure (GtkAction *action);
#endif /* __GIMP_WIDGETS_UTILS_H__ */ #endif /* __GIMP_WIDGETS_UTILS_H__ */

2
libgimp/gimp.def
View file

@ -500,8 +500,10 @@ EXPORTS
gimp_progress_cancel gimp_progress_cancel
gimp_progress_init gimp_progress_init
gimp_progress_install gimp_progress_install
gimp_progress_install_vtable
gimp_progress_pulse gimp_progress_pulse
gimp_progress_set_text gimp_progress_set_text
gimp_progress_get_window_handle
gimp_progress_uninstall gimp_progress_uninstall
gimp_progress_update gimp_progress_update
gimp_quit gimp_quit

4
libgimp/gimpexport.c
View file

@ -393,6 +393,9 @@ confirm_save_dialog (const gchar *message,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gimp_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_hbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
@ -473,6 +476,7 @@ export_dialog (GSList *actions,
-1); -1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gimp_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_hbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);

135
libgimp/gimpprogress.c
View file

@ -21,6 +21,12 @@
#include "config.h" #include "config.h"
#include <glib-object.h>
#undef GIMP_DISABLE_DEPRECATED
#include "gimpprogress.h"
#define GIMP_DISABLE_DEPRECATED
#include "gimp.h" #include "gimp.h"
@ -28,25 +34,19 @@ typedef struct _GimpProgressData GimpProgressData;
struct _GimpProgressData struct _GimpProgressData
{ {
gchar *progress_callback; gchar *progress_callback;
GimpProgressStartCallback start_callback; GimpProgressVtable vtable;
GimpProgressEndCallback end_callback; gpointer data;
GimpProgressTextCallback text_callback;
GimpProgressValueCallback value_callback;
gpointer data;
}; };
/* local function prototypes */ /* local function prototypes */
static void gimp_temp_progress_run (const gchar *name, static void gimp_temp_progress_run (const gchar *name,
gint nparams, gint nparams,
const GimpParam *param, const GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GimpParam **return_vals); GimpParam **return_vals);
#if 0
static gboolean gimp_temp_progress_run_idle (GimpProgressData *progress_data);
#endif
/* private variables */ /* private variables */
@ -79,6 +79,34 @@ gimp_progress_install (GimpProgressStartCallback start_callback,
GimpProgressTextCallback text_callback, GimpProgressTextCallback text_callback,
GimpProgressValueCallback value_callback, GimpProgressValueCallback value_callback,
gpointer user_data) gpointer user_data)
{
GimpProgressVtable vtable = { 0, };
g_return_val_if_fail (start_callback != NULL, NULL);
g_return_val_if_fail (end_callback != NULL, NULL);
g_return_val_if_fail (text_callback != NULL, NULL);
g_return_val_if_fail (value_callback != NULL, NULL);
vtable.start = start_callback;
vtable.end = end_callback;
vtable.set_text = text_callback;
vtable.set_value = value_callback;
return gimp_progress_install_vtable (&vtable, user_data);
}
/**
* gimp_progress_install_vtable:
* @vtable: a pointer to a @GimpProgressVtable.
* @user_data: a pointer that is passed as user_data to all vtable functions.
*
* Return value: the name of the temporary procedure that's been installed
*
* Since: GIMP 2.4
**/
const gchar *
gimp_progress_install_vtable (const GimpProgressVtable *vtable,
gpointer user_data)
{ {
static const GimpParamDef args[] = static const GimpParamDef args[] =
{ {
@ -87,12 +115,18 @@ gimp_progress_install (GimpProgressStartCallback start_callback,
{ GIMP_PDB_FLOAT, "value", "" } { GIMP_PDB_FLOAT, "value", "" }
}; };
static const GimpParamDef values[] =
{
{ GIMP_PDB_FLOAT, "value", "" }
};
gchar *progress_callback; gchar *progress_callback;
g_return_val_if_fail (start_callback != NULL, NULL); g_return_val_if_fail (vtable != NULL, NULL);
g_return_val_if_fail (end_callback != NULL, NULL); g_return_val_if_fail (vtable->start != NULL, NULL);
g_return_val_if_fail (text_callback != NULL, NULL); g_return_val_if_fail (vtable->end != NULL, NULL);
g_return_val_if_fail (value_callback != NULL, NULL); g_return_val_if_fail (vtable->set_text != NULL, NULL);
g_return_val_if_fail (vtable->set_value != NULL, NULL);
progress_callback = gimp_procedural_db_temp_name (); progress_callback = gimp_procedural_db_temp_name ();
@ -105,8 +139,8 @@ gimp_progress_install (GimpProgressStartCallback start_callback,
NULL, NULL,
"RGB*, GRAY*, INDEXED*", "RGB*, GRAY*, INDEXED*",
GIMP_TEMPORARY, GIMP_TEMPORARY,
G_N_ELEMENTS (args), 0, G_N_ELEMENTS (args), G_N_ELEMENTS (values),
args, NULL, args, values,
gimp_temp_progress_run); gimp_temp_progress_run);
if (_gimp_progress_install (progress_callback)) if (_gimp_progress_install (progress_callback))
@ -123,10 +157,12 @@ gimp_progress_install (GimpProgressStartCallback start_callback,
progress_data = g_new0 (GimpProgressData, 1); progress_data = g_new0 (GimpProgressData, 1);
progress_data->progress_callback = progress_callback; progress_data->progress_callback = progress_callback;
progress_data->start_callback = start_callback; progress_data->vtable.start = vtable->start;
progress_data->end_callback = end_callback; progress_data->vtable.end = vtable->end;
progress_data->text_callback = text_callback; progress_data->vtable.set_text = vtable->set_text;
progress_data->value_callback = value_callback; progress_data->vtable.set_value = vtable->set_value;
progress_data->vtable.pulse = vtable->pulse;
progress_data->vtable.get_window = vtable->get_window;
progress_data->data = user_data; progress_data->data = user_data;
g_hash_table_insert (gimp_progress_ht, progress_callback, progress_data); g_hash_table_insert (gimp_progress_ht, progress_callback, progress_data);
@ -224,14 +260,22 @@ gimp_temp_progress_run (const gchar *name,
gint *nreturn_vals, gint *nreturn_vals,
GimpParam **return_vals) GimpParam **return_vals)
{ {
static GimpParam values[1]; static GimpParam values[2];
GimpProgressData *progress_data; GimpProgressData *progress_data;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_SUCCESS;
progress_data = g_hash_table_lookup (gimp_progress_ht, name); progress_data = g_hash_table_lookup (gimp_progress_ht, name);
if (! progress_data) if (! progress_data)
{ {
g_warning ("Can't find internal progress data"); g_warning ("Can't find internal progress data");
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
} }
else else
{ {
@ -240,39 +284,46 @@ gimp_temp_progress_run (const gchar *name,
switch (command) switch (command)
{ {
case GIMP_PROGRESS_COMMAND_START: case GIMP_PROGRESS_COMMAND_START:
progress_data->start_callback (param[1].data.d_string, progress_data->vtable.start (param[1].data.d_string,
param[2].data.d_float != 0.0, param[2].data.d_float != 0.0,
progress_data->data); progress_data->data);
break; break;
case GIMP_PROGRESS_COMMAND_END: case GIMP_PROGRESS_COMMAND_END:
progress_data->end_callback (progress_data->data); progress_data->vtable.end (progress_data->data);
break; break;
case GIMP_PROGRESS_COMMAND_SET_TEXT: case GIMP_PROGRESS_COMMAND_SET_TEXT:
progress_data->text_callback (param[1].data.d_string, progress_data->vtable.set_text (param[1].data.d_string,
progress_data->data); progress_data->data);
break; break;
case GIMP_PROGRESS_COMMAND_SET_VALUE: case GIMP_PROGRESS_COMMAND_SET_VALUE:
progress_data->value_callback (param[2].data.d_float, progress_data->vtable.set_value (param[2].data.d_float,
progress_data->data); progress_data->data);
break; break;
case GIMP_PROGRESS_COMMAND_PULSE: case GIMP_PROGRESS_COMMAND_PULSE:
progress_data->value_callback (-1.0, if (progress_data->vtable.pulse)
progress_data->data); progress_data->vtable.pulse (progress_data->data);
else
progress_data->vtable.set_value (-1, progress_data->data);
break;
case GIMP_PROGRESS_COMMAND_GET_WINDOW:
*nreturn_vals = 2;
values[1].type = GIMP_PDB_FLOAT;
if (progress_data->vtable.get_window)
values[1].data.d_float =
(gdouble) progress_data->vtable.get_window (progress_data->data);
else
values[1].data.d_float = 0;
break; break;
default: default:
g_warning ("Unknown command passed to progress callback"); values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
} }
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_SUCCESS;
} }

48
libgimp/gimpprogress.h
View file

@ -25,6 +25,34 @@
G_BEGIN_DECLS G_BEGIN_DECLS
typedef struct _GimpProgressVtable GimpProgressVtable;
struct _GimpProgressVtable
{
void (* start) (const gchar *message,
gboolean cancelable,
gpointer user_data);
void (* end) (gpointer user_data);
void (* set_text) (const gchar *message,
gpointer user_data);
void (* set_value) (gdouble percentage,
gpointer user_data);
void (* pulse) (gpointer user_data);
guint32 (* get_window) (gpointer user_data);
/* Padding for future expansion. Must be initialized with NULL! */
void (* _gimp_reserved1) (void);
void (* _gimp_reserved2) (void);
void (* _gimp_reserved3) (void);
void (* _gimp_reserved4) (void);
void (* _gimp_reserved5) (void);
void (* _gimp_reserved6) (void);
void (* _gimp_reserved7) (void);
void (* _gimp_reserved8) (void);
};
#ifndef GIMP_DISABLE_DEPRECATED
typedef void (* GimpProgressStartCallback) (const gchar *message, typedef void (* GimpProgressStartCallback) (const gchar *message,
gboolean cancelable, gboolean cancelable,
gpointer user_data); gpointer user_data);
@ -35,15 +63,19 @@ typedef void (* GimpProgressValueCallback) (gdouble percentage,
gpointer user_data); gpointer user_data);
const gchar * gimp_progress_install (GimpProgressStartCallback start_callback, const gchar * gimp_progress_install (GimpProgressStartCallback start_callback,
GimpProgressEndCallback end_callback, GimpProgressEndCallback end_callback,
GimpProgressTextCallback text_callback, GimpProgressTextCallback text_callback,
GimpProgressValueCallback value_callback, GimpProgressValueCallback value_callback,
gpointer user_data); gpointer user_data);
gpointer gimp_progress_uninstall (const gchar *progress_callback); #endif /* GIMP_DISABLE_DEPRECATED */
gboolean gimp_progress_set_text (const gchar *format, const gchar * gimp_progress_install_vtable (const GimpProgressVtable *funcs,
...) G_GNUC_PRINTF (1, 2); gpointer user_data);
gpointer gimp_progress_uninstall (const gchar *progress_callback);
gboolean gimp_progress_set_text (const gchar *format,
...) G_GNUC_PRINTF (1, 2);
G_END_DECLS G_END_DECLS

32
libgimp/gimpprogress_pdb.c
View file

@ -153,6 +153,38 @@ _gimp_progress_set_text (const gchar *message)
return success; return success;
} }
/**
* gimp_progress_get_window_handle:
*
* Returns the native window ID of the toplevel window this plug-in's
* progress is displayed in.
*
* This function returns the native window ID of the toplevel window
* this plug-in\'s progress is displayed in.
*
* Returns: The progress bar's toplevel window.
*
* Since: GIMP 2.2
*/
gint
gimp_progress_get_window_handle (void)
{
GimpParam *return_vals;
gint nreturn_vals;
gint window = 0;
return_vals = gimp_run_procedure ("gimp-progress-get-window-handle",
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
window = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
return window;
}
/** /**
* _gimp_progress_install: * _gimp_progress_install:
* @progress_callback: The callback PDB proc to call. * @progress_callback: The callback PDB proc to call.

15
libgimp/gimpprogress_pdb.h
View file

@ -29,13 +29,14 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */ /* For information look into the C source or the html documentation */
gboolean gimp_progress_init (const gchar *message); gboolean gimp_progress_init (const gchar *message);
gboolean gimp_progress_update (gdouble percentage); gboolean gimp_progress_update (gdouble percentage);
gboolean gimp_progress_pulse (void); gboolean gimp_progress_pulse (void);
gboolean _gimp_progress_set_text (const gchar *message); gboolean _gimp_progress_set_text (const gchar *message);
gboolean _gimp_progress_install (const gchar *progress_callback); gint gimp_progress_get_window_handle (void);
gboolean _gimp_progress_uninstall (const gchar *progress_callback); gboolean _gimp_progress_install (const gchar *progress_callback);
gboolean gimp_progress_cancel (const gchar *progress_callback); gboolean _gimp_progress_uninstall (const gchar *progress_callback);
gboolean gimp_progress_cancel (const gchar *progress_callback);
G_END_DECLS G_END_DECLS

97
libgimp/gimpprogressbar.c
View file

@ -24,6 +24,14 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#ifdef GDK_WINDOWING_WIN32
#include <gdk/gdkwin32.h>
#endif
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "gimpuitypes.h" #include "gimpuitypes.h"
#include "gimp.h" #include "gimp.h"
@ -31,19 +39,21 @@
#include "gimpprogressbar.h" #include "gimpprogressbar.h"
static void gimp_progress_bar_class_init (GimpProgressBarClass *klass); static void gimp_progress_bar_class_init (GimpProgressBarClass *klass);
static void gimp_progress_bar_init (GimpProgressBar *bar); static void gimp_progress_bar_init (GimpProgressBar *bar);
static void gimp_progress_bar_destroy (GtkObject *object); static void gimp_progress_bar_destroy (GtkObject *object);
static void gimp_progress_bar_start (const gchar *message, static void gimp_progress_bar_start (const gchar *message,
gboolean cancelable, gboolean cancelable,
gpointer user_data); gpointer user_data);
static void gimp_progress_bar_end (gpointer user_data); static void gimp_progress_bar_end (gpointer user_data);
static void gimp_progress_bar_set_text (const gchar *message, static void gimp_progress_bar_set_text (const gchar *message,
gpointer user_data); gpointer user_data);
static void gimp_progress_bar_set_value (gdouble percentage, static void gimp_progress_bar_set_value (gdouble percentage,
gpointer user_data); gpointer user_data);
static void gimp_progress_bar_pulse (gpointer user_data);
static guint32 gimp_progress_bar_get_window (gpointer user_data);
static GtkProgressBarClass *parent_class = NULL; static GtkProgressBarClass *parent_class = NULL;
@ -90,13 +100,18 @@ gimp_progress_bar_class_init (GimpProgressBarClass *klass)
static void static void
gimp_progress_bar_init (GimpProgressBar *bar) gimp_progress_bar_init (GimpProgressBar *bar)
{ {
GimpProgressVtable vtable = { 0, };
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (bar), " "); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (bar), " ");
bar->progress_callback = gimp_progress_install (gimp_progress_bar_start, vtable.start = gimp_progress_bar_start;
gimp_progress_bar_end, vtable.end = gimp_progress_bar_end;
gimp_progress_bar_set_text, vtable.set_text = gimp_progress_bar_set_text;
gimp_progress_bar_set_value, vtable.set_value = gimp_progress_bar_set_value;
bar); vtable.pulse = gimp_progress_bar_pulse;
vtable.get_window = gimp_progress_bar_get_window;
bar->progress_callback = gimp_progress_install_vtable (&vtable, bar);
} }
static void static void
@ -170,6 +185,56 @@ gimp_progress_bar_set_value (gdouble percentage,
g_main_context_iteration (NULL, TRUE); g_main_context_iteration (NULL, TRUE);
} }
static void
gimp_progress_bar_pulse (gpointer user_data)
{
GimpProgressBar *bar = GIMP_PROGRESS_BAR (user_data);
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (bar));
if (GTK_WIDGET_DRAWABLE (bar))
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, TRUE);
}
static GdkNativeWindow
gimp_window_get_native (GtkWindow *window)
{
g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
#ifdef GDK_NATIVE_WINDOW_POINTER
#ifdef __GNUC__
#warning gimp_window_get_native() unimplementable for the target windowing system
#endif
#endif
#ifdef GDK_WINDOWING_WIN32
if (window && GTK_WIDGET_REALIZED (window))
return GDK_WINDOW_HWND (GTK_WIDGET (window)->window);
#endif
#ifdef GDK_WINDOWING_X11
if (window && GTK_WIDGET_REALIZED (window))
return GDK_WINDOW_XID (GTK_WIDGET (window)->window);
#endif
return 0;
}
static guint32
gimp_progress_bar_get_window (gpointer user_data)
{
GimpProgressBar *bar = GIMP_PROGRESS_BAR (user_data);
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (bar));
if (GTK_IS_WINDOW (toplevel))
return (guint32) gimp_window_get_native (GTK_WINDOW (toplevel));
return 0;
}
/** /**
* gimp_progress_bar_new: * gimp_progress_bar_new:
* *

92
libgimp/gimpui.c
View file

@ -39,6 +39,8 @@ static void gimp_ui_help_func (const gchar *help_id,
static void gimp_ensure_modules (void); static void gimp_ensure_modules (void);
static void gimp_window_transient_realized (GtkWidget *window, static void gimp_window_transient_realized (GtkWidget *window,
GdkWindow *parent); GdkWindow *parent);
static void gimp_window_set_transient_for (GtkWindow *window,
GdkWindow *parent);
static gboolean gimp_ui_initialized = FALSE; static gboolean gimp_ui_initialized = FALSE;
@ -141,11 +143,11 @@ gimp_ui_init (const gchar *prog_name,
GdkWindow * GdkWindow *
gimp_ui_get_display_window (guint32 gdisp_ID) gimp_ui_get_display_window (guint32 gdisp_ID)
{ {
#ifndef GDK_NATIVE_WINDOW_POINTER
GdkNativeWindow window; GdkNativeWindow window;
g_return_val_if_fail (gimp_ui_initialized, NULL); g_return_val_if_fail (gimp_ui_initialized, NULL);
#ifndef GDK_NATIVE_WINDOW_POINTER
window = gimp_display_get_window_handle (gdisp_ID); window = gimp_display_get_window_handle (gdisp_ID);
if (window) if (window)
return gdk_window_foreign_new_for_display (gdk_display_get_default (), return gdk_window_foreign_new_for_display (gdk_display_get_default (),
@ -155,6 +157,39 @@ gimp_ui_get_display_window (guint32 gdisp_ID)
return NULL; return NULL;
} }
/**
* gimp_ui_get_progress_window:
*
* Returns the #GdkWindow of the window this plug-in's progress bar is
* shown in. Use it to make plug-in dialogs transient to this window
* as explained with gdk_window_set_transient_for().
*
* You shouldn't have to call this function directly. Use
* gimp_window_set_transient() instead.
*
* Return value: A reference to a #GdkWindow or %NULL. You should
* unref the window using g_object_unref() as soon as
* you don't need it any longer.
*
* Since: GIMP 2.4
*/
GdkWindow *
gimp_ui_get_progress_window (void)
{
#ifndef GDK_NATIVE_WINDOW_POINTER
GdkNativeWindow window;
g_return_val_if_fail (gimp_ui_initialized, NULL);
window = gimp_progress_get_window_handle ();
if (window)
return gdk_window_foreign_new_for_display (gdk_display_get_default (),
window);
#endif
return NULL;
}
/** /**
* gimp_window_set_transient_for_display: * gimp_window_set_transient_for_display:
* @window: the #GtkWindow that should become transient * @window: the #GtkWindow that should become transient
@ -165,7 +200,7 @@ gimp_ui_get_display_window (guint32 gdisp_ID)
* display ID. See gdk_window_set_transient_for () for more information. * display ID. See gdk_window_set_transient_for () for more information.
* *
* Most of the time you will want to use the convenience function * Most of the time you will want to use the convenience function
* gimp_window_set_transient_for_default_display(). * gimp_window_set_transient().
* *
* Since: GIMP 2.4 * Since: GIMP 2.4
*/ */
@ -173,48 +208,30 @@ void
gimp_window_set_transient_for_display (GtkWindow *window, gimp_window_set_transient_for_display (GtkWindow *window,
guint32 gdisp_ID) guint32 gdisp_ID)
{ {
GdkWindow *display;
g_return_if_fail (gimp_ui_initialized); g_return_if_fail (gimp_ui_initialized);
g_return_if_fail (GTK_IS_WINDOW (window)); g_return_if_fail (GTK_IS_WINDOW (window));
gtk_window_set_transient_for (window, NULL); gimp_window_set_transient_for (window,
gimp_ui_get_display_window (gdisp_ID));
g_signal_handlers_disconnect_matched (window, G_SIGNAL_MATCH_FUNC,
0, 0, NULL,
gimp_window_transient_realized,
NULL);
display = gimp_ui_get_display_window (gdisp_ID);
if (! display)
return;
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_transient_for (GTK_WIDGET (window)->window, display);
g_signal_connect_object (window, "realize",
G_CALLBACK (gimp_window_transient_realized),
display, 0);
g_object_unref (display);
} }
/** /**
* gimp_window_set_transient_for_default_display: * gimp_window_set_transient:
* @window: the #GtkWindow that should become transient * @window: the #GtkWindow that should become transient
* *
* Indicates to the window manager that @window is a transient dialog * Indicates to the window manager that @window is a transient dialog
* associated with the GIMP image window that the plug-in has been * associated with the GIMP window that the plug-in has been
* started from. See also gimp_window_set_transient_for_display(). * started from. See also gimp_window_set_transient_for_display().
* *
* Since: GIMP 2.4 * Since: GIMP 2.4
*/ */
void void
gimp_window_set_transient_for_default_display (GtkWindow *window) gimp_window_set_transient (GtkWindow *window)
{ {
g_return_if_fail (gimp_ui_initialized); g_return_if_fail (gimp_ui_initialized);
g_return_if_fail (GTK_IS_WINDOW (window)); g_return_if_fail (GTK_IS_WINDOW (window));
gimp_window_set_transient_for_display (window, gimp_default_display ()); gimp_window_set_transient_for (window, gimp_ui_get_progress_window ());
} }
@ -254,3 +271,26 @@ gimp_window_transient_realized (GtkWidget *window,
if (GTK_WIDGET_REALIZED (window)) if (GTK_WIDGET_REALIZED (window))
gdk_window_set_transient_for (window->window, parent); gdk_window_set_transient_for (window->window, parent);
} }
static void
gimp_window_set_transient_for (GtkWindow *window,
GdkWindow *parent)
{
gtk_window_set_transient_for (window, NULL);
g_signal_handlers_disconnect_matched (window, G_SIGNAL_MATCH_FUNC,
0, 0, NULL,
gimp_window_transient_realized,
NULL);
if (! parent)
return;
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_transient_for (GTK_WIDGET (window)->window, parent);
g_signal_connect_object (window, "realize",
G_CALLBACK (gimp_window_transient_realized),
parent, 0);
g_object_unref (parent);
}

3
libgimp/gimpui.def
View file

@ -45,5 +45,6 @@ EXPORTS
gimp_progress_bar_new gimp_progress_bar_new
gimp_ui_init gimp_ui_init
gimp_ui_get_display_window gimp_ui_get_display_window
gimp_ui_get_progress_window
gimp_window_set_transient
gimp_window_set_transient_for_display gimp_window_set_transient_for_display
gimp_window_set_transient_for_default_display

14
libgimp/gimpui.h
View file

@ -49,15 +49,15 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */ /* For information look into the C source or the html documentation */
void gimp_ui_init (const gchar *prog_name, void gimp_ui_init (const gchar *prog_name,
gboolean preview); gboolean preview);
GdkWindow * gimp_ui_get_display_window (guint32 gdisp_ID); GdkWindow * gimp_ui_get_display_window (guint32 gdisp_ID);
GdkWindow * gimp_ui_get_progress_window (void);
void gimp_window_set_transient_for_display (GtkWindow *window,
guint32 gdisp_ID);
void gimp_window_set_transient_for_default_display (GtkWindow *window);
void gimp_window_set_transient_for_display (GtkWindow *window,
guint32 gdisp_ID);
void gimp_window_set_transient (GtkWindow *window);
G_END_DECLS G_END_DECLS

2
libgimpbase/gimpbaseenums.c
View file

@ -901,6 +901,7 @@ gimp_progress_command_get_type (void)
{ GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", "set-text" }, { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", "set-text" },
{ GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", "set-value" }, { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", "set-value" },
{ GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", "pulse" }, { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", "pulse" },
{ GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", "get-window" },
{ 0, NULL, NULL } { 0, NULL, NULL }
}; };
@ -911,6 +912,7 @@ gimp_progress_command_get_type (void)
{ GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", NULL }, { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", NULL },
{ GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", NULL }, { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", NULL },
{ GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", NULL }, { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", NULL },
{ GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", NULL },
{ 0, NULL, NULL } { 0, NULL, NULL }
}; };

3
libgimpbase/gimpbaseenums.h
View file

@ -402,7 +402,8 @@ typedef enum
GIMP_PROGRESS_COMMAND_END, GIMP_PROGRESS_COMMAND_END,
GIMP_PROGRESS_COMMAND_SET_TEXT, GIMP_PROGRESS_COMMAND_SET_TEXT,
GIMP_PROGRESS_COMMAND_SET_VALUE, GIMP_PROGRESS_COMMAND_SET_VALUE,
GIMP_PROGRESS_COMMAND_PULSE GIMP_PROGRESS_COMMAND_PULSE,
GIMP_PROGRESS_COMMAND_GET_WINDOW
} GimpProgressCommand; } GimpProgressCommand;

2
plug-ins/FractalExplorer/Dialogs.c
View file

@ -556,7 +556,7 @@ explorer_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
g_signal_connect (dialog, "response", g_signal_connect (dialog, "response",
G_CALLBACK (dialog_response), G_CALLBACK (dialog_response),

2
plug-ins/Lighting/lighting_ui.c
View file

@ -981,7 +981,7 @@ main_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (appwin)); gimp_window_set_transient (GTK_WINDOW (appwin));
main_hbox = gtk_hbox_new (FALSE, 12); main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);

2
plug-ins/MapObject/mapobject_ui.c
View file

@ -1381,7 +1381,7 @@ main_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (appwin)); gimp_window_set_transient (GTK_WINDOW (appwin));
main_hbox = gtk_hbox_new (FALSE, 12); main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);

2
plug-ins/common/AlienMap2.c
View file

@ -406,7 +406,7 @@ alienmap2_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

74
plug-ins/common/CML_explorer.c
View file

@ -1170,7 +1170,7 @@ logistic_function (CML_PARAM *param,
static gint static gint
CML_explorer_dialog (void) CML_explorer_dialog (void)
{ {
GtkWidget *dlg; GtkWidget *dialog;
GtkWidget *hbox; GtkWidget *hbox;
GtkWidget *vbox; GtkWidget *vbox;
GtkWidget *frame; GtkWidget *frame;
@ -1181,27 +1181,28 @@ CML_explorer_dialog (void)
gimp_ui_init (PLUG_IN_BINARY, TRUE); gimp_ui_init (PLUG_IN_BINARY, TRUE);
dlg = gimp_dialog_new (_("Coupled-Map-Lattice Explorer"), PLUG_IN_BINARY, dialog = gimp_dialog_new (_("Coupled-Map-Lattice Explorer"), PLUG_IN_BINARY,
NULL, 0, NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC, gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL); NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK, GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dialog));
CML_preview_defer = TRUE; CML_preview_defer = TRUE;
hbox = gtk_hbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
FALSE, FALSE, 0);
gtk_widget_show (hbox); gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 12); vbox = gtk_vbox_new (FALSE, 12);
@ -1520,14 +1521,14 @@ CML_explorer_dialog (void)
/* Displaying preview might takes a long time. Thus, first, dialog itself /* Displaying preview might takes a long time. Thus, first, dialog itself
* should be shown before making preview in it. * should be shown before making preview in it.
*/ */
gtk_widget_show (dlg); gtk_widget_show (dialog);
CML_preview_defer = FALSE; CML_preview_defer = FALSE;
preview_update (); preview_update ();
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg); gtk_widget_destroy (dialog);
return run; return run;
} }
@ -1817,22 +1818,23 @@ static void
function_graph_new (GtkWidget *widget, function_graph_new (GtkWidget *widget,
gpointer *data) gpointer *data)
{ {
GtkWidget *dlg; GtkWidget *dialog;
GtkWidget *frame; GtkWidget *frame;
GtkWidget *preview; GtkWidget *preview;
dlg = gimp_dialog_new (_("Graph of the Current Settings"), "cml_explorer", dialog = gimp_dialog_new (_("Graph of the Current Settings"), "cml_explorer",
gtk_widget_get_toplevel (widget), 0, gtk_widget_get_toplevel (widget), 0,
gimp_standard_help_func, PLUG_IN_PROC, gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL); NULL);
frame = gtk_frame_new (NULL); frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 12); gtk_container_set_border_width (GTK_CONTAINER (frame), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame,
FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
preview = gtk_drawing_area_new (); preview = gtk_drawing_area_new ();
@ -1842,11 +1844,11 @@ function_graph_new (GtkWidget *widget,
g_signal_connect (preview, "expose-event", g_signal_connect (preview, "expose-event",
G_CALLBACK (function_graph_expose), data); G_CALLBACK (function_graph_expose), data);
gtk_widget_show (dlg); gtk_widget_show (dialog);
gimp_dialog_run (GIMP_DIALOG (dlg)); gimp_dialog_run (GIMP_DIALOG (dialog));
gtk_widget_destroy (dlg); gtk_widget_destroy (dialog);
} }
static void static void
@ -2078,23 +2080,23 @@ static gboolean
force_overwrite (const gchar *filename, force_overwrite (const gchar *filename,
GtkWidget *parent) GtkWidget *parent)
{ {
GtkWidget *dlg; GtkWidget *dialog;
GtkWidget *label; GtkWidget *label;
GtkWidget *hbox; GtkWidget *hbox;
gchar *buffer; gchar *buffer;
gboolean overwrite; gboolean overwrite;
dlg = gimp_dialog_new (_("CML Explorer: Overwrite File?"), "cml_explorer", dialog = gimp_dialog_new (_("CML Explorer: Overwrite File?"), "cml_explorer",
parent, GTK_DIALOG_MODAL, parent, GTK_DIALOG_MODAL,
gimp_standard_help_func, PLUG_IN_PROC, gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL); NULL);
hbox = gtk_hbox_new (FALSE, 0); hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
hbox, FALSE, FALSE, 12); hbox, FALSE, FALSE, 12);
gtk_widget_show (hbox); gtk_widget_show (hbox);
@ -2107,11 +2109,11 @@ force_overwrite (const gchar *filename,
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 12);
gtk_widget_show (label); gtk_widget_show (label);
gtk_widget_show (dlg); gtk_widget_show (dialog);
overwrite = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); overwrite = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg); gtk_widget_destroy (dialog);
return overwrite; return overwrite;
} }
@ -2165,8 +2167,8 @@ CML_load_from_file_callback (GtkWidget *widget,
static void static void
CML_load_from_file_response (GtkWidget *dialog, CML_load_from_file_response (GtkWidget *dialog,
gint response_id, gint response_id,
gpointer data) gpointer data)
{ {
if (response_id == GTK_RESPONSE_OK) if (response_id == GTK_RESPONSE_OK)
{ {

29
plug-ins/common/align_layers.c
View file

@ -74,7 +74,8 @@ static void align_layers_get_align_offsets (gint32 drawable_id,
gint *x, gint *x,
gint *y); gint *y);
static gint align_layers_dialog (void); static gint align_layers_dialog (void);
GimpPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
@ -384,7 +385,7 @@ align_layers_get_align_offsets (gint32 drawable_id,
static int static int
align_layers_dialog (void) align_layers_dialog (void)
{ {
GtkWidget *dlg; GtkWidget *dialog;
GtkWidget *table; GtkWidget *table;
GtkWidget *combo; GtkWidget *combo;
GtkWidget *toggle; GtkWidget *toggle;
@ -393,27 +394,27 @@ align_layers_dialog (void)
gimp_ui_init (PLUG_IN_BINARY, FALSE); gimp_ui_init (PLUG_IN_BINARY, FALSE);
dlg = gimp_dialog_new (_("Align Visible Layers"), PLUG_IN_BINARY, dialog = gimp_dialog_new (_("Align Visible Layers"), PLUG_IN_BINARY,
NULL, 0, NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC, gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL); NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK, GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dialog));
table = gtk_table_new (7, 3, FALSE); table = gtk_table_new (7, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), table,
FALSE, FALSE, 0); FALSE, FALSE, 0);
gtk_widget_show (table); gtk_widget_show (table);
@ -508,11 +509,11 @@ align_layers_dialog (void)
G_CALLBACK (gimp_toggle_button_update), G_CALLBACK (gimp_toggle_button_update),
&VALS.base_is_bottom_layer); &VALS.base_is_bottom_layer);
gtk_widget_show (dlg); gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg); gtk_widget_destroy (dialog);
return run; return run;
} }

2
plug-ins/common/animationplay.c
View file

@ -417,7 +417,7 @@ build_dialog (GimpImageBaseType basetype,
g_free (windowname); g_free (windowname);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
g_signal_connect (dlg, "response", g_signal_connect (dlg, "response",
G_CALLBACK (window_response), G_CALLBACK (window_response),

2
plug-ins/common/apply_lens.c
View file

@ -405,7 +405,7 @@ lens_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/blinds.c
View file

@ -241,7 +241,7 @@ blinds_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/borderaverage.c
View file

@ -362,7 +362,7 @@ borderaverage_dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/bumpmap.c
View file

@ -845,7 +845,7 @@ bumpmap_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
paned = gtk_hpaned_new (); paned = gtk_hpaned_new ();
gtk_container_set_border_width (GTK_CONTAINER (paned), 12); gtk_container_set_border_width (GTK_CONTAINER (paned), 12);

2
plug-ins/common/cartoon.c
View file

@ -822,7 +822,7 @@ cartoon_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/ccanalyze.c
View file

@ -365,7 +365,7 @@ doDialog (void)
NULL); NULL);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_vbox_new (FALSE, 6); vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);

2
plug-ins/common/channel_mixer.c
View file

@ -503,7 +503,7 @@ cm_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/checkerboard.c
View file

@ -356,7 +356,7 @@ checkerboard_dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_vbox_new (FALSE, 12); vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);

2
plug-ins/common/colorify.c
View file

@ -269,7 +269,7 @@ colorify_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/colortoalpha.c
View file

@ -390,7 +390,7 @@ color_to_alpha_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/compose.c
View file

@ -1288,7 +1288,7 @@ compose_dialog (const gchar *compose_type,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
/* parameter settings */ /* parameter settings */
hbox = gtk_hbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 12);

2
plug-ins/common/convmatrix.c
View file

@ -885,7 +885,7 @@ convmatrix_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/cubism.c
View file

@ -280,7 +280,7 @@ cubism_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/curve_bend.c
View file

@ -1249,7 +1249,7 @@ bender_new_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (cd->shell)); gimp_window_set_transient (GTK_WINDOW (cd->shell));
g_signal_connect (cd->shell, "response", g_signal_connect (cd->shell, "response",
G_CALLBACK (bender_response), G_CALLBACK (bender_response),

2
plug-ins/common/decompose.c
View file

@ -1238,7 +1238,7 @@ decompose_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/deinterlace.c
View file

@ -338,7 +338,7 @@ deinterlace_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/depthmerge.c
View file

@ -638,7 +638,7 @@ DepthMerge_dialog (DepthMerge *dm)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_vbox_new (FALSE, 12); vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);

2
plug-ins/common/despeckle.c
View file

@ -404,7 +404,7 @@ despeckle_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/destripe.c
View file

@ -449,7 +449,7 @@ destripe_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/diffraction.c
View file

@ -445,7 +445,7 @@ diffraction_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_hbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);

2
plug-ins/common/displace.c
View file

@ -324,7 +324,7 @@ displace_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/dog.c
View file

@ -287,7 +287,7 @@ dog_dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/edge.c
View file

@ -655,7 +655,7 @@ edge_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/emboss.c
View file

@ -462,7 +462,7 @@ emboss_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/engrave.c
View file

@ -222,7 +222,7 @@ engrave_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/exchange.c
View file

@ -299,7 +299,7 @@ exchange_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
/* do some boxes here */ /* do some boxes here */
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);

2
plug-ins/common/film.c
View file

@ -1457,7 +1457,7 @@ film_dialog (gint32 image_ID)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/flarefx.c
View file

@ -320,7 +320,7 @@ flare_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/fp.c
View file

@ -1193,7 +1193,7 @@ fp_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
g_signal_connect (dlg, "response", g_signal_connect (dlg, "response",
G_CALLBACK (fp_response), G_CALLBACK (fp_response),

2
plug-ins/common/fractaltrace.c
View file

@ -698,7 +698,7 @@ dialog_show (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
mainbox = gtk_vbox_new (FALSE, 12); mainbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (mainbox), 12); gtk_container_set_border_width (GTK_CONTAINER (mainbox), 12);

2
plug-ins/common/gauss.c
View file

@ -477,7 +477,7 @@ gauss_dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

53
plug-ins/common/gif.c
View file

@ -1193,30 +1193,33 @@ save_image (const gchar *filename,
static gboolean static gboolean
badbounds_dialog (void) badbounds_dialog (void)
{ {
GtkWidget *dlg; GtkWidget *dialog;
GtkWidget *label; GtkWidget *label;
GtkWidget *vbox; GtkWidget *vbox;
gboolean crop; gboolean crop;
dlg = gimp_dialog_new (_("GIF Warning"), "gif_warning", dialog = gimp_dialog_new (_("GIF Warning"), "gif_warning",
NULL, 0, NULL, 0,
gimp_standard_help_func, "file-gif-save", gimp_standard_help_func, "file-gif-save",
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL); NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK, GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gimp_window_set_transient (GTK_WINDOW (dialog));
/* the warning message */ /* the warning message */
vbox = gtk_vbox_new (FALSE, 12); vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox); gtk_widget_show (vbox);
label= gtk_label_new (_("The image which you are trying to save as a GIF\n" label= gtk_label_new (_("The image which you are trying to save as a GIF\n"
@ -1228,11 +1231,11 @@ badbounds_dialog (void)
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
gtk_widget_show (label); gtk_widget_show (label);
gtk_widget_show (dlg); gtk_widget_show (dialog);
crop = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); crop = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg); gtk_widget_destroy (dialog);
return crop; return crop;
} }
@ -1241,7 +1244,7 @@ badbounds_dialog (void)
static gint static gint
save_dialog (gint32 image_ID) save_dialog (gint32 image_ID)
{ {
GtkWidget *dlg; GtkWidget *dialog;
GtkWidget *main_vbox; GtkWidget *main_vbox;
GtkWidget *toggle; GtkWidget *toggle;
GtkWidget *label; GtkWidget *label;
@ -1263,23 +1266,25 @@ save_dialog (gint32 image_ID)
gimp_image_get_layers (image_ID, &nlayers); gimp_image_get_layers (image_ID, &nlayers);
dlg = gimp_dialog_new (_("Save as GIF"), PLUG_IN_BINARY, dialog = gimp_dialog_new (_("Save as GIF"), PLUG_IN_BINARY,
NULL, 0, NULL, 0,
gimp_standard_help_func, SAVE_PROC, gimp_standard_help_func, SAVE_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK, GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL); NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK, GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dlg)->vbox), main_vbox); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
gtk_widget_show (main_vbox); gtk_widget_show (main_vbox);
/* regular gif parameter settings */ /* regular gif parameter settings */
@ -1460,11 +1465,11 @@ save_dialog (gint32 image_ID)
gtk_widget_set_sensitive (frame, FALSE); gtk_widget_set_sensitive (frame, FALSE);
gtk_widget_show (frame); gtk_widget_show (frame);
gtk_widget_show (dlg); gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg); gtk_widget_destroy (dialog);
return run; return run;
} }

2
plug-ins/common/glasstile.c
View file

@ -263,7 +263,7 @@ glasstile_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/gqbist.c
View file

@ -800,7 +800,7 @@ dialog_run (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_vbox_new (FALSE, 12); vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);

2
plug-ins/common/grid.c
View file

@ -646,7 +646,7 @@ dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
/* Get the image resolution and unit */ /* Get the image resolution and unit */
gimp_image_get_resolution (image_ID, &xres, &yres); gimp_image_get_resolution (image_ID, &xres, &yres);

2
plug-ins/common/hot.c
View file

@ -581,7 +581,7 @@ pluginCoreIA (piArgs *argp)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
hbox = gtk_hbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);

2
plug-ins/common/illusion.c
View file

@ -402,7 +402,7 @@ illusion_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/iwarp.c
View file

@ -1164,7 +1164,7 @@ iwarp_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
g_signal_connect (dlg, "response", g_signal_connect (dlg, "response",
G_CALLBACK (iwarp_response), G_CALLBACK (iwarp_response),

2
plug-ins/common/jigsaw.c
View file

@ -2432,7 +2432,7 @@ jigsaw_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/lic.c
View file

@ -653,7 +653,7 @@ create_main_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_vbox_new (FALSE, 12); vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);

2
plug-ins/common/mail.c
View file

@ -519,7 +519,7 @@ save_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/mapcolor.c
View file

@ -366,7 +366,7 @@ mapcolor_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/max_rgb.c
View file

@ -276,7 +276,7 @@ max_rgb_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/mblur.c
View file

@ -921,7 +921,7 @@ mblur_dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/mosaic.c
View file

@ -595,7 +595,7 @@ mosaic_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/neon.c
View file

@ -713,7 +713,7 @@ neon_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/newsprint.c
View file

@ -1201,7 +1201,7 @@ newsprint_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
paned = gtk_hpaned_new (); paned = gtk_hpaned_new ();
gtk_container_set_border_width (GTK_CONTAINER (paned), 12); gtk_container_set_border_width (GTK_CONTAINER (paned), 12);

2
plug-ins/common/nlfilt.c
View file

@ -1029,7 +1029,7 @@ nlfilter_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/noisify.c
View file

@ -459,7 +459,7 @@ noisify_dialog (GimpDrawable *drawable,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/nova.c
View file

@ -316,7 +316,7 @@ nova_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/oilify.c
View file

@ -486,7 +486,7 @@ oilify_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/papertile.c
View file

@ -245,7 +245,7 @@ open_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_hbox = gtk_hbox_new (FALSE, 12); main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);

2
plug-ins/common/photocopy.c
View file

@ -851,7 +851,7 @@ photocopy_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/pixelize.c
View file

@ -325,7 +325,7 @@ pixelize_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/plasma.c
View file

@ -314,7 +314,7 @@ plasma_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/polar.c
View file

@ -594,7 +594,7 @@ polarize_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/randomize.c
View file

@ -735,7 +735,7 @@ randomize_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
table = gtk_table_new (3, 3, FALSE); table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6);

2
plug-ins/common/retinex.c
View file

@ -302,7 +302,7 @@ retinex_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/ripple.c
View file

@ -484,7 +484,7 @@ ripple_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
/* The main vbox */ /* The main vbox */
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);

2
plug-ins/common/sample_colorize.c
View file

@ -1330,7 +1330,7 @@ smp_dialog (void)
GTK_RESPONSE_CLOSE, GTK_RESPONSE_CLOSE,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
g_signal_connect (dialog, "response", g_signal_connect (dialog, "response",
G_CALLBACK (smp_response_callback), G_CALLBACK (smp_response_callback),

2
plug-ins/common/scatter_hsv.c
View file

@ -365,7 +365,7 @@ scatter_hsv_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/sel_gauss.c
View file

@ -237,7 +237,7 @@ sel_gauss_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/sharpen.c
View file

@ -489,7 +489,7 @@ sharpen_dialog (GimpDrawable *drawable)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/shift.c
View file

@ -368,7 +368,7 @@ shift_dialog (gint32 image_ID,
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dialog)); gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12); main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);

2
plug-ins/common/sinus.c
View file

@ -659,7 +659,7 @@ sinus_dialog (void)
GTK_RESPONSE_CANCEL, GTK_RESPONSE_CANCEL,
-1); -1);
gimp_window_set_transient_for_default_display (GTK_WINDOW (dlg)); gimp_window_set_transient (GTK_WINDOW (dlg));
main_hbox = gtk_hbox_new (FALSE, 12); main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);

Some files were not shown because too many files have changed in this diff Show more