gib_hash_node *gib_hash_node_new(char *key, void *data)
{
gib_hash_node *node = gib_emalloc(sizeof(gib_hash_node));
node->key = gib_estrdup(key);
GIB_LIST(node)->data = data;
GIB_LIST(node)->next = NULL;
GIB_LIST(node)->prev = NULL;
return node;
}
/*
* XXX gib_imlib_save_image_with_error_return breaks with *.END and
* similar because it tries to set the image format, which only works
* with .end .
* So we leave that part out.
*/
void ungib_imlib_save_image_with_error_return(Imlib_Image im, char *file,
Imlib_Load_Error * error_return)
{
char *tmp;
imlib_context_set_image(im);
tmp = strrchr(file, '.');
if (tmp) {
char *p, *pp;
p = gib_estrdup(tmp + 1);
pp = p;
while(*pp) {
*pp = tolower(*pp);
pp++;
}
imlib_image_set_format(p);
gib_efree(p);
}
imlib_save_image_with_error_return(file, error_return);
}
void
gib_imlib_save_image(Imlib_Image im, char *file)
{
char *tmp;
imlib_context_set_image(im);
tmp = strrchr(file, '.');
if (tmp)
{
char *p, *pp;
p = gib_estrdup(tmp + 1);
pp = p;
while(*pp) {
*pp = tolower(*pp);
pp++;
}
imlib_image_set_format(p);
gib_efree(p);
}
imlib_save_image(file);
}
Imlib_Image
scrot_grab_shot_multi(void)
{
int screens;
int i;
char *dispstr, *subdisp;
char newdisp[255];
gib_list *images = NULL;
Imlib_Image ret = NULL;
screens = ScreenCount(disp);
if (screens < 2)
return scrot_grab_shot();
dispstr = DisplayString(disp);
subdisp = gib_estrdup(DisplayString(disp));
for (i = 0; i < screens; i++) {
dispstr = strchr(subdisp, ':');
if (dispstr) {
dispstr = strchr(dispstr, '.');
if (NULL != dispstr)
*dispstr = '\0';
}
snprintf(newdisp, sizeof(newdisp), "%s.%d", subdisp, i);
init_x_and_imlib(newdisp, i);
ret =
gib_imlib_create_image_from_drawable(root, 0, 0, 0, scr->width,
scr->height, 1);
images = gib_list_add_end(images, ret);
}
free(subdisp);
ret = stalk_image_concat(images);
return ret;
}
char *
im_printf(char *str, struct tm *tm,
char *filename_im,
char *filename_thumb,
Imlib_Image im)
{
char *c;
char buf[20];
char ret[4096];
char strf[4096];
char *tmp;
struct stat st;
ret[0] = '\0';
strftime(strf, 4095, str, tm);
for (c = strf; *c != '\0'; c++) {
if (*c == '$') {
c++;
switch (*c) {
case 'f':
if (filename_im)
strcat(ret, filename_im);
break;
case 'm': /* t was allready taken, so m as in mini */
if (filename_thumb)
strcat(ret, filename_thumb);
break;
case 'n':
if (filename_im) {
tmp = strrchr(filename_im, '/');
if (tmp)
strcat(ret, tmp + 1);
else
strcat(ret, filename_im);
}
break;
case 'w':
snprintf(buf, sizeof(buf), "%d", gib_imlib_image_get_width(im));
strcat(ret, buf);
break;
case 'h':
snprintf(buf, sizeof(buf), "%d", gib_imlib_image_get_height(im));
strcat(ret, buf);
break;
case 's':
if (filename_im) {
if (!stat(filename_im, &st)) {
int size;
size = st.st_size;
snprintf(buf, sizeof(buf), "%d", size);
strcat(ret, buf);
} else
strcat(ret, "[err]");
}
break;
case 'p':
snprintf(buf, sizeof(buf), "%d",
gib_imlib_image_get_width(im) *
gib_imlib_image_get_height(im));
strcat(ret, buf);
break;
case 't':
strcat(ret, gib_imlib_image_format(im));
break;
case '$':
strcat(ret, "$");
break;
default:
strncat(ret, c, 1);
break;
}
} else if (*c == '\\') {
c++;
switch (*c) {
case 'n':
if (filename_im)
strcat(ret, "\n");
break;
default:
strncat(ret, c, 1);
break;
}
} else
strncat(ret, c, 1);
}
return gib_estrdup(ret);
}
int
main(int argc,
char **argv)
{
Imlib_Image image;
Imlib_Image thumbnail;
Imlib_Load_Error err;
char *filename_im = NULL, *filename_thumb = NULL;
time_t t;
struct tm *tm;
init_parse_options(argc, argv);
init_x_and_imlib(NULL, 0);
if (!opt.output_file) {
opt.output_file = gib_estrdup("%Y-%m-%d-%H%M%S_$wx$h_scrot.png");
opt.thumb_file = gib_estrdup("%Y-%m-%d-%H%M%S_$wx$h_scrot-thumb.png");
}
if (opt.focused)
image = scrot_grab_focused();
else if (opt.window)
image = scrot_grab_window();
else if (opt.select)
image = scrot_sel_and_grab_image();
else {
scrot_do_delay();
if (opt.multidisp) {
image = scrot_grab_shot_multi();
} else {
image = scrot_grab_shot();
}
}
if (!image)
gib_eprintf("no image grabbed");
time(&t); /* Get the time directly after the screenshot */
tm = localtime(&t);
imlib_context_set_image(image);
imlib_image_attach_data_value("quality", NULL, opt.quality, NULL);
filename_im = im_printf(opt.output_file, tm, NULL, NULL, image);
gib_imlib_save_image_with_error_return(image, filename_im, &err);
if (err)
gib_eprintf("Saving to file %s failed\n", filename_im);
if (opt.thumb)
{
int cwidth, cheight;
int twidth, theight;
cwidth = gib_imlib_image_get_width(image);
cheight = gib_imlib_image_get_height(image);
/* Geometry based thumb size */
if (opt.thumb_width || opt.thumb_height)
{
if (!opt.thumb_width)
{
twidth = cwidth * opt.thumb_height / cheight;
theight = opt.thumb_height;
}
else if (!opt.thumb_height)
{
twidth = opt.thumb_width;
theight = cheight * opt.thumb_width / cwidth;
}
else
{
twidth = opt.thumb_width;
theight = opt.thumb_height;
}
}
else
{
twidth = cwidth * opt.thumb / 100;
theight = cheight * opt.thumb / 100;
}
thumbnail =
gib_imlib_create_cropped_scaled_image(image, 0, 0, cwidth, cheight,
twidth, theight, 1);
if (thumbnail == NULL)
gib_eprintf("Unable to create scaled Image\n");
else
{
filename_thumb = im_printf(opt.thumb_file, tm, NULL, NULL, thumbnail);
gib_imlib_save_image_with_error_return(thumbnail, filename_thumb, &err);
if (err)
gib_eprintf("Saving thumbnail %s failed\n", filename_thumb);
}
}
if (opt.exec)
scrot_exec_app(image, tm, filename_im, filename_thumb);
gib_imlib_free_image_and_decache(image);
return 0;
}
static void
scrot_parse_option_array(int argc, char **argv)
{
static char stropts[] = "bcd:e:hmq:st:v+:";
static struct option lopts[] = {
/* actions */
{"help", 0, 0, 'h'}, /* okay */
{"version", 0, 0, 'v'}, /* okay */
{"count", 0, 0, 'c'},
{"select", 0, 0, 's'},
{"border", 0, 0, 'b'},
{"multidisp", 0, 0, 'm'},
/* toggles */
{"thumb", 1, 0, 't'},
{"quality", 1, 0, 'q'},
{"exec", 1, 0, 'e'},
{"debug-level", 1, 0, '+'},
{0, 0, 0, 0}
};
int optch = 0, cmdx = 0;
/* Now to pass some optionarinos */
while ((optch = getopt_long(argc, argv, stropts, lopts, &cmdx)) !=
EOF)
{
switch (optch)
{
case 0:
break;
case 'h':
show_usage();
break;
case 'v':
show_version();
break;
case 'b':
opt.border = 1;
break;
case 'e':
opt.exec = gib_estrdup(optarg);
break;
case 'm':
opt.multidisp = 1;
break;
case 'q':
opt.quality = atoi(optarg);
break;
case 's':
opt.select = 1;
break;
case '+':
opt.debug_level = atoi(optarg);
break;
case 'c':
opt.countdown = 1;
break;
case 't':
options_parse_thumbnail(optarg);
break;
default:
break;
}
}
/* Now the leftovers, which must be files */
if (optind < argc)
{
while (optind < argc)
{
/* If recursive is NOT set, but the only argument is a directory
name, we grab all the files in there, but not subdirs */
if (!opt.output_file)
{
opt.output_file = argv[optind++];
if (opt.thumb)
opt.thumb_file = name_thumbnail(opt.output_file);
}
else
gib_weprintf("unrecognised option %s\n", argv[optind++]);
}
}
/* So that we can safely be called again */
optind = 1;
}
