What do you guys use for "printscreen"?

answered 2012-07-04 13:53:54 +0000

Klaas
101 ●1 ●5 ●9

updated 2012-07-04 13:56:13 +0000

I like scrot. It is unmaintained but works (for my applications). It has some options, such as -s to interactively select a window/rectangle, or -d for a delay and more.

answered 2013-07-24 05:21:03 +0000

avk
21 ●1 ●3

updated 2013-07-24 05:25:00 +0000

'import' from ImageMagic works only if you don't have container widnows. So, on plain layout it works well, but in complicated situation it fails and produces blank image.

I prefer that my screenshot utility automatically places resulting image filename into my clipboard buffer. Here is my small script which does all of that (all my utilities link):

#!/usr/bin/env python
# -*- coding: utf-8 -*-

""" Use in i3wm with:
Save as screeshot.py somewhere into your PATH
bindsym --release Print exec --no-startup-id screenshot.py
"""


import os
from subprocess import Popen, PIPE
from tempfile import NamedTemporaryFile

SCREENSHOT_UTILITY = '/usr/bin/scrot -s' # /usr/bin/import

def feed_xclipboard(str):
    pipe = Popen("xclip -sel clip", shell=True, stdin=PIPE).stdin
    pipe.write(str)
    pipe.close()

def import_screenshot():
    filename = NamedTemporaryFile(
        suffix='.png',
        prefix='screenshot_',
        dir = os.path.expanduser('~/tmp'),
        delete=False).name
    p = Popen(SCREENSHOT_UTILITY + " " + filename, shell=True)
    sts = os.waitpid(p.pid, 0)[1]
    return filename


if __name__ == '__main__':
    screenshot = import_screenshot()
    feed_xclipboard(screenshot)

answered 2012-07-27 21:40:31 +0000

BroX
41 ●1 ●1 ●5

scrot, with the following in i3/config:

# scrot & gimp - root
bindsym Print exec scrot -e 'mv $f /tmp/ && gimp /tmp/$f'
# scrot & gimp - select window or rectangle
bindsym Mod1+Print exec scrot -s -e 'mv $f /tmp/ && gimp /tmp/$f'

answered 2015-09-11 12:34:01 +0000

SpicyCat
56 ●2 ●3

ksnapshot

Work out of box and it is the best.

It has a delay feature. It can delay several seconds before taking snapshot. This feature is really useful when you need take screen shot of some menus or tooltip.

I don't see any other tool supporting this feature.

I don't understand why so many people here use script and command line tool to take screenshot. What is the merit? Flexible? Configurable? But what you do by your scripts is the same with what I do by ksnapshot

answered 2012-07-11 09:05:45 +0000

kevin
45 ●3 ●5 ●9

I personally use import from the Image Magick package.

A little while ago I used gnome-screenshot, but it recently stop working on my system, maybe because of a dist update, or an i3 update, I'm not sure.

answered 2012-07-24 19:53:55 +0000

loblik
256 ●1 ●3 ●7

updated 2012-07-24 19:59:51 +0000

I have a script which takes a screenshot using import from imagemagick. It's able to shot whole root window or currently focused window. That depends on the only one argument it takes.

screen.sh root
screen.sh active

At the top of the script there are to variables which control its behaviour. The SCREEN_DIR is a directory where you want to save your screenshots. And the SCREEN_PROMPT defines whether you want to be prompted for name of screenshot by i3-input. If you don't then this variable must not be set at all.

You can export these variables from your startup scripts to have settings separated from script itself.

The screenshot is saved in SCREEN_DIR under name in format NAME-YEAR-MONTH-DAY_HOUR-MIN-SEC.png where NAME is string typed in to the i3-input. If prompt is disabled or empty string is given then WM_CLASS of window is used or just "window" if WM_CLASS is not set. In case of root window screenshot NAME is "root".

And finally symlink named 'last' pointing to last taken screenshot is created for easier lookup.

#!/bin/bash

SCREEN_DIR=~/screenshots/
SCREEN_PROMPT=1

window='root'

case $1 in
  root)
    window='root';;
  active)
    window=`xprop -root | grep "_NET_ACTIVE_WINDOW(WINDOW)" | cut -d' ' -f5`;;
esac

[ ! -z "$SCREEN_PROMPT" ] && \
  name=`i3-input -P 'screen-name: ' | sed -n '/command = /s/command = //p'`

if [ -z "$name" ];then
  if [ $window == "root" ];then
    name='root'
  else
    name=`xprop -id $window | sed -n '/WM_CLASS/s/.* = "\([^\"]*\)".*/\1\n/p'`
    [ -z "$name" ] && name='window'
  fi
fi

filename="$name-`date +%Y-%m-%d_%H-%M-%S`.png"

import -border -window $window "$SCREEN_DIR/$filename"


ln -sf "$filename" $SCREEN_DIR/last

exit

In i3 config just create simple binding.

bindsym Print exec screen.sh root
bindsym Mod1+Print exec screen.sh active

Note that if you take second screenshot during single second the previous one taken in that same second gets overwritten since there is no check for this case. So if you like to use printscreen to make movies you should check for this.

answered 2015-09-03 14:47:53 +0000

Miro
11 ●1 ●2

I like scrot, because it's simple, and it can do everything I need (bindings of my configuration):

• fullscreen screenshoot (PrnScr)
• window screenshoot(Alt + PrnScr)
• select windows screenshoot(Alt + Shift + PrnScr)

Combined with date command it can create screens with timestamp in filename, which can be edited later.

Here is the config:

bindsym Print exec scrot $HOME/Pictures/ScreenShoots/`date +%Y-%m-%d_%H:%M:%S`.png
bindsym Mod1+Print exec scrot -u $HOME/Pictures/ScreenShoots/`date +%Y-%m-%d_%H:%M:%S`.png
bindsym Mod1+Shift+Print exec scrot -s $HOME/Pictures/ScreenShoots/`date +%Y-%m-%d_%H:%M:%S`.png

answered 2012-07-30 16:02:09 +0000

jonyamo
31 ●1 ●3

I am using i3 on CrunchBang which was already set up to use xfce4-screenshooter, so I just stuck with it and it has been working perfectly for my needs.

I set up a keybind to call it with Mod4+s :

bindsym Mod4+s exec xfce4-screenshooter

answered 2014-09-29 13:58:34 +0000

Sam73
61 ●2 ●3 ●9

updated 2015-09-10 13:59:39 +0000

I use a mix of scrot and python to load directly the screen capture into clipboard.

In my config I got

bindsym Print exec scrot -e 'pyclip $f'
bindsym Mod1+Print exec scrot -s -e 'pyclip $f'

and got this small python script to load it into clipboard that I took from superuser The trick is that your program need to stay active as long as the clipboard contains the image.

#!/usr/bin/env python
import gtk 
import sys

count = 0
def handle_owner_change(clipboard, event):
    global count
    print 'clipboard.owner-change(%r, %r)' % (clipboard, event)
    count += 1
    # On my new computer, I had to push counter to 2 because the event is triggered immediatly and script goes out with the buffer. This version keeps the buffer until next screenshot.
    if count > 2:
       sys.exit(0)

image = gtk.gdk.pixbuf_new_from_file(sys.argv[1])
clipboard = gtk.clipboard_get()
clipboard.connect('owner-change', handle_owner_change)
clipboard.set_image(image)
clipboard.store()
gtk.main()

answered 2015-04-07 16:26:21 +0000

mimosinnet
1

Similar solution than lobik using perl with 4 options:

bindsym $mod+Print exec Print_Screen root 
bindsym --release $mod+Shift+Print exec Print_Screen area
bindsym $mod+Mod1+Print exec Print_Screen delay
bindsym $mod+Control+Print exec Print_Screen window

This is the script, sending a message when the screenshot is taken.

#!/usr/bin/env perl 
# Info {{{
#  DESCRIPTION: Print Screen
# }}}

# use {{{
use strict;
use warnings;
use experimental 'smartmatch';
use v5.20;
# }}}

# Variables {{{
my @print_option = qw/root area window delay sequence/;
my $timestamp = `date +%Y_%m-%d_%H-%M`; 
chomp $timestamp;
my $target = "/home/mimosinnet/Dades/Imatges/ScreenShots/$timestamp.png";
my (@args, $window);

die "Usage: \n Print_Screen root|area|window|delay \n" unless 
    (scalar @ARGV == 1) and ($ARGV[0] ~~ @print_option);

# }}}

# Select options {{{
for ( $ARGV[0] ) {
    if ( /root/   ) 
        {   @args = ("import", "-window", "root", $target) }
    if ( /area/   ) 
        {   @args = ("import", $target) }
    if ( /window/ )
        {   $window = `xprop -root | grep "_NET_ACTIVE_WINDOW(WINDOW)"`;
            ($window) = $window =~ /(0.*$)/ ;
            @args = ("import", "-window", $window, $target) } 
    if ( /delay/  )
        {   sleep 5;
            $window = `xprop -root | grep "_NET_ACTIVE_WINDOW(WINDOW)"`;
            ($window) = $window =~ /(0.*$)/ ;
            @args = ("import", "-window", $window, $target) } 
};
# }}}

# Debugging
# foreach (@args) { print "$_ "; } exit;

system(@args) == 0 or die "unable to do the screenshot because of: $?";

@args = ("xmessage", "-nearmouse", "Captura de Pantalla Feta");
system(@args) == 0 or die "unable to show message because of: $?";