dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rewrote a large part of the screenshot plug-in. The plug-in now no longer 

2003-08-28 Henrik Brix Andersen <brix@gimp.org>

* plug-ins/common/screenshot.c: rewrote a large part of the
screenshot plug-in. The plug-in now no longer depends on the xwd
utility, but uses Xlib/GDK functionality to obtain the screen shot.

The window to shoot is now selected prior to the time out. This
fixes bug #103852.

The ability to obtain a screen shot of a window without
decorations has had to go since this can not be done using plain
Xlib/GDK (one would have to depend on libXmu to do this).

The source is prepared for G_OS_WIN32 but the win32 specific code
is yet to be written.

* tools/pdbgen/pdb/plug_in.pdb (gimp_progress_update): improved the
inline documentation

* app/pdb/plug_in_cmds.c
* libgimp/gimpplugin_pdb.c: regenerated
This commit is contained in:
Henrik Brix Andersen 2003-08-28 20:23:09 +00:00 committed by Henrik Brix Andersen
parent edf64d16a2
commit f33c7af756
5 changed files with 313 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
ChangeLog
View File

@ -1,3 +1,25 @@
2003-08-28 Henrik Brix Andersen <brix@gimp.org>
* plug-ins/common/screenshot.c: rewrote a large part of the
screenshot plug-in. The plug-in now no longer depends on the xwd
utility, but uses Xlib/GDK functionality to obtain the screen shot.
The window to shoot is now selected prior to the time out. This
fixes bug #103852.
The ability to obtain a screen shot of a window without
decorations has had to go since this can not be done using plain
Xlib/GDK (one would have to depend on libXmu to do this).
The source is prepared for G_OS_WIN32 but the win32 specific code
is yet to be written.
* tools/pdbgen/pdb/plug_in.pdb (gimp_progress_update): improved the
inline documentation
* app/pdb/plug_in_cmds.c
* libgimp/gimpplugin_pdb.c: regenerated
2003-08-28 Sven Neumann <sven@gimp.org>
* app/core/gimpimage-convert.c (gimp_image_convert): free the

2
app/pdb/plug_in_cmds.c
View File

@ -152,7 +152,7 @@ static ProcArg progress_update_inargs[] =
{
GIMP_PDB_FLOAT,
"percentage",
"Percentage of progress completed"
"Percentage of progress completed which must be between 0.0 and 1.0"
}
};

2
libgimp/gimpplugin_pdb.c
View File

@ -59,7 +59,7 @@ gimp_progress_init (const gchar *message)
/**
* gimp_progress_update:
* @percentage: Percentage of progress completed.
* @percentage: Percentage of progress completed which must be between 0.0 and 1.0.
*
* Updates the progress bar for the current plug-in.
*

478
plug-ins/common/screenshot.c
View File

@ -1,13 +1,10 @@
/*
/*
* ScreenShot plug-in
* Copyright 1998-2000 Sven Neumann <sven@gimp.org>
* Copyright 2003 Henrik Brix Andersen <brix@gimp.org>
*
* Any suggestions, bug-reports or patches are very welcome.
*
* This plug-in uses the X-utility xwd to grab an image from the screen
* and the xwd-plug-in created by Peter Kirchgessner (pkirchg@aol.com)
* to load this image into the gimp.
* Hence its nothing but a simple frontend to those utilities.
*
*/
/* The GIMP -- an image manipulation program
@ -30,56 +27,61 @@
#include "config.h"
#include <stdio.h>
#include <errno.h>
#include <sys/wait.h>
#include <unistd.h>
#ifdef __EMX__
#include <process.h>
#endif
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#ifdef G_OS_WIN32
#include <windows.h>
#else /* ! G_OS_WIN32 */
#include <X11/Xlib.h>
#include <X11/cursorfont.h>
#include <gdk/gdkx.h>
#endif /* ! G_OS_WIN32 */
#include "libgimp/stdplugins-intl.h"
/* Defines */
#define PLUG_IN_NAME "plug_in_screenshot"
#ifndef XWD
#define XWD "xwd"
#ifdef __GNUC__
#ifdef GDK_NATIVE_WINDOW_POINTER
#if GLIB_SIZEOF_VOID_P != sizeof (guint32)
#warning window_id does not fit in PDB_INT32
#endif
#endif
#endif
typedef struct
{
gboolean root;
gchar *window_id;
guint delay;
gboolean decor;
gboolean root;
guint window_id;
guint delay;
} ScreenShotValues;
static ScreenShotValues shootvals =
{
static ScreenShotValues shootvals =
{
FALSE, /* root window */
NULL, /* window ID */
0, /* delay */
TRUE, /* decorations */
0, /* window ID */
0, /* delay */
};
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static GdkNativeWindow select_window (const GdkScreen *screen);
static gint32 create_image (const GdkPixbuf *pixbuf);
static void shoot (void);
static gboolean shoot_dialog (void);
static void shoot_ok_callback (GtkWidget *widget,
static void shoot_ok_callback (GtkWidget *widget,
gpointer data);
static void shoot_delay (gint32 delay);
static gboolean shoot_delay_callback (gpointer data);
@ -95,10 +97,15 @@ GimpPlugInInfo PLUG_IN_INFO =
};
/* the image that will be returned */
gint32 image_ID = -1;
gint32 image_ID = -1;
gboolean run_flag = FALSE;
gboolean run_flag = FALSE;
/* the screen on which we are running */
GdkScreen *cur_screen = NULL;
/* the window the user selected */
GdkNativeWindow selected_native;
/* Functions */
@ -109,9 +116,9 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_INT32, "root", "Root window { TRUE, FALSE }" },
{ GIMP_PDB_STRING, "window_id", "Window id" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_INT32, "root", "Root window { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "window_id", "Window id" }
};
static GimpParamDef return_vals[] =
@ -121,17 +128,14 @@ query (void)
gimp_install_procedure (PLUG_IN_NAME,
"Creates a screenshot of a single window or the whole screen",
"This extension serves as a simple frontend to the "
"X-window utility xwd and the xwd-file-plug-in. "
"After specifying some options, xwd is called, the "
"user selects a window, and the resulting image is "
"loaded into the gimp. Alternatively the whole "
"screen can be grabbed. When called non-interactively "
"it may grab the root window or use the window-id "
"passed as a parameter.",
"Sven Neumann <sven@gimp.org>",
"1998 - 2000",
"v0.9.5 (2000/10/29)",
"After specifying some options the user selects a window and "
"a time out is started. At the end of the time out the window "
"is grabbed and the image is loaded into The GIMP. Alternatively "
"the whole screen can be grabbed. When called non-interactively "
"it may grab the root window or use the window-id passed as a parameter.",
"Sven Neumann <sven@gimp.org>, Henrik Brix Andersen <brix@gimp.org>",
"1998 - 2003",
"v0.9.6 (2003/08/28)",
N_("<Toolbox>/File/Acquire/_Screen Shot..."),
NULL,
GIMP_PLUGIN,
@ -140,7 +144,7 @@ query (void)
args, return_vals);
}
static void
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
@ -148,17 +152,17 @@ run (const gchar *name,
GimpParam **return_vals)
{
/* Get the runmode from the in-parameters */
GimpRunMode run_mode = param[0].data.d_int32;
GimpRunMode run_mode = param[0].data.d_int32;
/* status variable, use it to check for errors in invocation usualy only
/* status variable, use it to check for errors in invocation usually only
* during non-interactive calling
*/
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
/* always return at least the status to the caller. */
static GimpParam values[2];
/* initialize the return of the status */
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
@ -172,7 +176,7 @@ run (const gchar *name,
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_NAME, &shootvals);
shootvals.window_id = NULL;
shootvals.window_id = 0;
/* Get information from the dialog */
if (!shoot_dialog ())
@ -180,15 +184,17 @@ run (const gchar *name,
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams == 3)
if (nparams == 3)
{
shootvals.root = param[1].data.d_int32;
shootvals.window_id = (gchar*) param[2].data.d_string;
shootvals.window_id = param[2].data.d_int32;
shootvals.delay = 0;
shootvals.decor = FALSE;
}
else
status = GIMP_PDB_CALLING_ERROR;
if (!gdk_init_check (0, NULL))
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
@ -225,139 +231,255 @@ run (const gchar *name,
values[1].data.d_image = image_ID;
}
values[0].data.d_status = status;
values[0].data.d_status = status;
}
/* Allow the user to select a window with the mouse */
/* The main ScreenShot function */
static void
shoot (void)
static GdkNativeWindow
select_window (const GdkScreen *screen)
{
GimpParam *params;
gint retvals;
gchar *tmpname;
gchar *xwdargv[7]; /* need a maximum of 7 arguments to xwd */
gdouble xres, yres;
gint pid;
gint wpid;
gint status;
gint i = 0;
#ifdef G_OS_WIN32
/* MS Windows specific code goes here (yet to be written) */
/* get a temp name with the right extension */
tmpname = gimp_temp_name ("xwd");
/* basically the code should grab the pointer using a crosshair
cursor, allow the user to click on a window and return the
obtained HWND (as a GdkNativeWindow) - for more details consult
the X11 specific code below */
/* construct the xwd arguments */
xwdargv[i++] = XWD;
xwdargv[i++] = "-out";
xwdargv[i++] = tmpname;
if ( shootvals.root == TRUE )
xwdargv[i++] = "-root";
else
{
if (shootvals.decor == TRUE )
xwdargv[i++] = "-frame";
if (shootvals.window_id != NULL)
{
xwdargv[i++] = "-id";
xwdargv[i++] = shootvals.window_id;
}
}
xwdargv[i] = NULL;
#ifndef __EMX__
/* fork off a xwd process */
if ((pid = fork ()) < 0)
{
g_message ("fork() failed: %s", g_strerror (errno));
return;
}
else if (pid == 0)
{
execvp (XWD, xwdargv);
/* What are we doing here? exec must have failed */
g_message ("exec failed: xwd: %s", g_strerror (errno));
return;
}
else
#else /* __EMX__ */
pid = spawnvp (P_NOWAIT, XWD, xwdargv);
if (pid == -1)
{
g_message ("spawn failed: %s", g_strerror (errno));
return;
}
#endif
{
status = -1;
wpid = waitpid (pid, &status, 0);
/* note to self: take a look at the winsnap plug-in for example
code */
if ((wpid < 0) || !WIFEXITED (status))
{
/* the tmpfile may have been created even if xwd failed */
unlink (tmpname);
g_free (tmpname);
g_message ("xwd didn't work");
return;
}
#else /* ! G_OS_WIN32 */
/* X11 specific code */
Display *x_dpy;
Cursor x_cursor;
XEvent x_event;
Window x_win;
Window x_root;
gint x_scr;
gint status;
gint buttons;
x_dpy = GDK_SCREEN_XDISPLAY (GDK_SCREEN (screen));
x_scr = GDK_SCREEN_XNUMBER (GDK_SCREEN (screen));
x_win = None;
x_root = RootWindow (x_dpy, x_scr);
x_cursor = XCreateFontCursor (x_dpy, XC_crosshair);
buttons = 0;
status = XGrabPointer (x_dpy, x_root, False,
ButtonPressMask|ButtonReleaseMask,
GrabModeSync, GrabModeAsync,
x_root, x_cursor, CurrentTime);
if (status != GrabSuccess)
{
g_message (_("Screen Shot: Error grabbing the pointer"));
return 0;
}
/* now load the tmpfile using the xwd-plug-in */
params = gimp_run_procedure ("file_xwd_load",
&retvals,
GIMP_PDB_INT32, 1,
GIMP_PDB_STRING, tmpname,
GIMP_PDB_STRING, tmpname,
GIMP_PDB_END);
if (params[0].data.d_status == GIMP_PDB_SUCCESS)
while ((x_win == None) || (buttons != 0))
{
image_ID = params[1].data.d_image;
}
gimp_destroy_params (params, retvals);
XAllowEvents (x_dpy, SyncPointer, CurrentTime);
XWindowEvent (x_dpy, x_root, ButtonPressMask|ButtonReleaseMask, &x_event);
/* get rid of the tmpfile */
unlink (tmpname);
g_free (tmpname);
if (image_ID != -1)
{
GimpParasite *parasite;
gchar *comment;
/* figure out the monitor resolution and set the image to it */
gimp_get_monitor_resolution (&xres, &yres);
gimp_image_set_resolution (image_ID, xres, yres);
/* unset the image filename */
gimp_image_set_filename (image_ID, "");
/* Set the default comment parasite */
comment = gimp_get_default_comment ();
if (comment != NULL)
switch (x_event.type)
{
parasite = gimp_parasite_new ("gimp-comment",
GIMP_PARASITE_PERSISTENT,
g_utf8_strlen (comment, -1) + 1,
comment);
case ButtonPress:
if (x_win == None)
{
x_win = x_event.xbutton.subwindow;
if (x_win == None)
x_win = x_root;
}
buttons++;
break;
gimp_image_parasite_attach (image_ID, parasite);
gimp_parasite_free(parasite);
case ButtonRelease:
if (buttons > 0)
buttons--;
break;
default:
g_assert_not_reached ();
}
}
return;
XUngrabPointer (x_dpy, CurrentTime);
return x_win;
#endif /* ! G_OS_WIN32 */
}
/* Create a GimpImage from a GdkPixbuf */
static gint32
create_image (const GdkPixbuf *pixbuf)
{
GimpPixelRgn pr;
GimpDrawable *drawable;
GimpParasite *parasite;
gint32 image;
gint32 layer;
gdouble xres, yres;
gchar *comment;
gint width, height;
gint rowstride;
gboolean status;
gchar *buf;
gint i;
width = gdk_pixbuf_get_width (GDK_PIXBUF (pixbuf));
height = gdk_pixbuf_get_height (GDK_PIXBUF (pixbuf));
image = gimp_image_new (width, height, GIMP_RGB);
layer = gimp_layer_new (image, _("Background"),
width, height,
GIMP_RGB_IMAGE, 100, GIMP_NORMAL_MODE);
gimp_image_add_layer (image, layer, 0);
drawable = gimp_drawable_get (layer);
gimp_pixel_rgn_init (&pr, drawable,
0, 0, width, height,
TRUE, FALSE);
/* copy the contents of the GdkPixbuf to the GimpDrawable */
rowstride = gdk_pixbuf_get_rowstride (GDK_PIXBUF (pixbuf));
buf = gdk_pixbuf_get_pixels (GDK_PIXBUF (pixbuf));
status = gimp_progress_init (_("Loading Screen Shot..."));
for (i = 0; i < height; i++)
{
gimp_pixel_rgn_set_row (&pr, buf, 0, i, width);
buf += rowstride;
/* update progress every 10 percent */
if (status && ((i + 1) * 100 / height) % 10 == 0)
status = gimp_progress_update ((i + 1.0) / height);
}
gimp_progress_update (1.0);
/* figure out the monitor resolution and set the image to it */
gimp_get_monitor_resolution (&xres, &yres);
gimp_image_set_resolution (image, xres, yres);
/* Set the default comment parasite */
comment = gimp_get_default_comment ();
if (comment)
{
parasite = gimp_parasite_new ("gimp-comment",
GIMP_PARASITE_PERSISTENT,
g_utf8_strlen (comment, -1) + 1,
comment);
gimp_image_parasite_attach (image_ID, parasite);
gimp_parasite_free (parasite);
g_free (comment);
}
return image;
}
/* The main ScreenShot function */
static void
shoot (void)
{
GdkWindow *window;
GdkPixbuf *screenshot;
GdkRectangle clip;
GdkPoint origin;
gint screen_w, screen_h;
/* use default screen if we are running non-interactively */
if (cur_screen == NULL)
cur_screen = gdk_screen_get_default ();
screen_w = gdk_screen_get_width (GDK_SCREEN (cur_screen));
screen_h = gdk_screen_get_height (GDK_SCREEN (cur_screen));
clip.x = 0;
clip.y = 0;
if (shootvals.root)
{
/* entire screen */
window = gdk_screen_get_root_window (GDK_SCREEN (cur_screen));
}
else
{
/* single window */
if (shootvals.window_id)
{
window = gdk_window_foreign_new (shootvals.window_id);
}
else
{
window = gdk_window_foreign_new (selected_native);
}
}
if (!window)
{
g_message (_("Screen Shot: Specified window not found"));
return;
}
gdk_drawable_get_size (GDK_WINDOW (window), &clip.width, &clip.height);
gdk_window_get_origin (GDK_WINDOW (window), &origin.x, &origin.y);
/* do clipping */
if (origin.x < 0)
{
clip.x = -origin.x;
clip.width += origin.x;
}
if (origin.y < 0)
{
clip.y = -origin.y;
clip.height += origin.y;
}
if (origin.x + clip.width > screen_w)
clip.width -= origin.x + clip.width - screen_w;
if (origin.y + clip.height > screen_h)
clip.height -= origin.y + clip.height - screen_h;
screenshot = gdk_pixbuf_get_from_drawable (NULL, GDK_WINDOW (window),
NULL, clip.x, clip.y, 0, 0,
clip.width, clip.height);
gdk_display_beep (gdk_screen_get_display (GDK_SCREEN (cur_screen)));
gdk_flush ();
if (!screenshot)
{
g_message (_("Screen Shot: Error obtaining screenshot"));
return;
}
image_ID = create_image (GDK_PIXBUF (screenshot));
}
/* ScreenShot dialog */
static void
shoot_ok_callback (GtkWidget *widget,
shoot_ok_callback (GtkWidget *widget,
gpointer data)
{
run_flag = TRUE;
/* get the screen on which we are running */
cur_screen = gtk_widget_get_screen (GTK_WIDGET (widget));
gtk_widget_destroy (GTK_WIDGET (data));
if (!shootvals.root && !shootvals.window_id)
selected_native = select_window (GDK_SCREEN (cur_screen));
}
static gboolean
@ -370,9 +492,7 @@ shoot_dialog (void)
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *decor_button;
GtkWidget *spinner;
GtkWidget *sep;
GSList *radio_group = NULL;
GtkObject *adj;
@ -411,9 +531,9 @@ shoot_dialog (void)
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
button = gtk_radio_button_new_with_mnemonic (radio_group,
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("_Single Window"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), ! shootvals.root);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -425,32 +545,10 @@ shoot_dialog (void)
G_CALLBACK (gimp_radio_button_update),
&shootvals.root);
/* with decorations */
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
decor_button =
gtk_check_button_new_with_mnemonic (_("With _Decorations"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (decor_button),
shootvals.decor);
gtk_box_pack_end (GTK_BOX (hbox), decor_button, FALSE, FALSE, 0);
gtk_widget_show (decor_button);
g_object_set_data (G_OBJECT (button), "set_sensitive", decor_button);
g_signal_connect (decor_button, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&shootvals.decor);
gtk_widget_show (hbox);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
/* root window */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("_Whole Screen"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.root);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
@ -471,14 +569,14 @@ shoot_dialog (void)
label = gtk_label_new_with_mnemonic (_("_after"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj = gtk_adjustment_new (shootvals.delay, 0.0, 100.0, 1.0, 5.0, 0.0);
spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
gtk_widget_show (spinner);
g_signal_connect (adj, "value_changed",
G_CALLBACK (gimp_int_adjustment_update),
G_CALLBACK (gimp_int_adjustment_update),
&shootvals.delay);
label = gtk_label_new (_("Seconds Delay"));
@ -509,7 +607,7 @@ shoot_delay_callback (gpointer data)
(*seconds_left)--;
if (!*seconds_left)
if (!*seconds_left)
gtk_main_quit();
return *seconds_left;

2
tools/pdbgen/pdb/plug_in.pdb
View File

@ -80,7 +80,7 @@ HELP
@inargs = (
{ name => 'percentage', type => 'float',
desc => 'Percentage of progress completed' }
desc => 'Percentage of progress completed which must be between 0.0 and 1.0' }
);
%invoke = (