name change, slrn was taken by some guy from 1994

README.md

-slrn
+slop
 ====
 
-slrn (Select Region) is an application that querys for a selection from the user and prints the region to stdout. It grabs the mouse and turns it into a crosshair, lets the user click and drag to make a selection (or click on a window) while drawing a pretty box around it, then finally prints the selection's dimensions to stdout.
+slop (Select Operation) is an application that querys for a selection from the user and prints the region to stdout. It grabs the mouse and turns it into a crosshair, lets the user click and drag to make a selection (or click on a window) while drawing a pretty box around it, then finally prints the selection's dimensions to stdout.
 
 features
 --------
 * Hovering over a window will cause a selection rectangle to appear over it.
-* Clicking on a window makes slrn return the dimensions of the window.
+* Clicking on a window makes slop return the dimensions of the window.
 * Clicking and dragging causes a selection rectangle to appear, renders pretty well (compared to scrot). And will return the dimensions of that rectangle in absolute screen coords.
 * On startup it turns your cursor into a crosshair, then adjusts the cursor into angles as you drag the selection rectangle.
 * Supports simple arguments:
 
 practical applications
 ----------------------
-slrn can be used to create a video recording script in only two lines of code.
+slop can be used to create a video recording script in only two lines of code.
 ```bash
 #!/bin/bash
-eval `slrn`
+eval `slop`
 ffmpeg -f x11grab -s "$W"x"$H" -i :0.0+$X,$Y -f alsa -i pulse ~/myfile.webm
 ```
-slrn lets you select a region or window and ffmpeg will record it in the format of your choice!
+slop lets you select a region or window and ffmpeg will record it in the format of your choice!
 Combined with keybinds and a server on your filesystem you can make a really neat and unobtrusive screenshooter.
 
 You can also take images using imagemagick like so:
 ```bash
 #!/bin/bash
-eval `slrn`
+eval `slop`
 import -window root -crop "$W"x"$H"+$X+$Y ~/myimage.png
 ```
 
 lets see some action
 --------------------
-Ok. Here's a comparison between 'scrot -s's selection and slrn's:
-![scrot](http://farmpolice.com/content/images/scrot_bad.png)
-![slrn](http://farmpolice.com/content/images/slrn_good.png)
+Ok. Here's a comparison between 'scrot -s's selection and slop's:
+![scrotbad](http://farmpolice.com/content/images/scrot_bad.png)
+![slopgood](http://farmpolice.com/content/images/slrn_good.png)
 
 You can see scrot leaves garbage lines over the things you're trying to screenshot!
-While slrn not only looks nicer, it's impossible for it to end up in screenshots or recordings because it shuts down before ffmpeg or imagemagick can take a picture.
+While slop not only looks nicer, it's impossible for it to end up in screenshots or recordings because it shuts down before ffmpeg or imagemagick can take a picture.

main.cpp

     }
     int state = 0;
     bool running = true;
-    slrn::Rectangle* selection;
-    slrn::Rectangle* windowselection = NULL;
+    slop::Rectangle* selection;
+    slop::Rectangle* windowselection = NULL;
     Window window = None;
     std::string xdisplay = options->m_xdisplay;
     int padding = options->m_padding;
     if ( err ) {
         return err;
     }
-    err = xengine->grabCursor( slrn::Cross );
+    err = xengine->grabCursor( slop::Cross );
     if ( err ) {
         return err;
     }
                     if ( windowselection ) {
                         xengine->removeRect( windowselection ); // removeRect also dealloc's the rectangle for us.
                     }
-                    slrn::WindowRectangle t = xengine->m_hoverWindow;
-                    windowselection = new slrn::Rectangle( t.m_x - t.m_border,
+                    slop::WindowRectangle t = xengine->m_hoverWindow;
+                    windowselection = new slop::Rectangle( t.m_x - t.m_border,
                                                          t.m_y - t.m_border,
                                                          t.m_width + t.m_border,
                                                          t.m_height + t.m_border,
             case 1: {
                 // Simply create a new rectangle at the mouse position and move on
                 // to the next state.
-                selection = new slrn::Rectangle( xengine->m_mousex, xengine->m_mousey, 0, 0, borderSize, padding, r, g, b );
+                selection = new slop::Rectangle( xengine->m_mousex, xengine->m_mousey, 0, 0, borderSize, padding, r, g, b );
                 xengine->addRect( selection );
                 state++;
                 break;
                 bool x = selection->m_flippedx;
                 bool y = selection->m_flippedy;
                 if ( !x && !y ) {
-                    xengine->setCursor( slrn::LowerRightCorner );
+                    xengine->setCursor( slop::LowerRightCorner );
                 } else if ( x && !y ) {
-                    xengine->setCursor( slrn::LowerLeftCorner );
+                    xengine->setCursor( slop::LowerLeftCorner );
                 } else if ( !x && y ) {
-                    xengine->setCursor( slrn::UpperRightCorner );
+                    xengine->setCursor( slop::UpperRightCorner );
                 } else {
-                    xengine->setCursor( slrn::UpperLeftCorner );
+                    xengine->setCursor( slop::UpperLeftCorner );
                 }
 
                 break;
                     break;
                 }
                 // Otherwise lets grab the window's dimensions and use those (with padding).
-                slrn::WindowRectangle t = xengine->m_hoverWindow;
+                slop::WindowRectangle t = xengine->m_hoverWindow;
                 x = t.m_x - padding - t.m_border;
                 y = t.m_y - padding - t.m_border;
                 w = t.m_width + t.m_border + padding*2;

makefile

 LDFLAGS=-lX11 -lXext
 SOURCES=main.cpp x.cpp options.cpp
 OBJECTS=$(SOURCES:.cpp=.o)
-EXECUTABLE=slrn
+EXECUTABLE=slop
 BINDIR="usr/bin"
 
 all: $(SOURCES) $(EXECUTABLE)
 
 install: all
 	mkdir -p $(DESTDIR)/$(BINDIR)
-	cp $(CURDIR)/slrn $(DESTDIR)/$(BINDIR)
+	cp $(CURDIR)/slop $(DESTDIR)/$(BINDIR)

options.cpp

 #include "options.hpp"
 
-slrn::Options* options = new slrn::Options();
+slop::Options* options = new slop::Options();
 
-slrn::Options::Options() {
+slop::Options::Options() {
     m_borderSize = 10;
     m_padding = 0;
     m_xdisplay = ":0";
     m_blue = 0;
 }
 
-void slrn::Options::printHelp() {
-    printf( "Usage: slrn [options]\n" );
+void slop::Options::printHelp() {
+    printf( "Usage: slop [options]\n" );
     printf( "Print user selected region to stdout.\n" );
     printf( "\n" );
     printf( "options\n" );
     printf( "    -h, --help                     show this message.\n" );
     printf( "    -b=INT, --bordersize=INT       set selection rectangle border size.\n" );
     printf( "    -p=INT, --m_padding=INT        set m_padding size for selection.\n" );
-    printf( "    -t=INT, --tolerance=INT        if you have a shaky mouse, increasing this value will make slrn detect single clicks better. Rather than interpreting your shaky clicks as region selections.\n" );
+    printf( "    -t=INT, --tolerance=INT        if you have a shaky mouse, increasing this value will make slop detect single clicks better. Rather than interpreting your shaky clicks as region selections.\n" );
     printf( "    -x=STRING, --xdisplay=STRING   set x display (STRING must be hostname:number.screen_number format)\n" );
     printf( "    -c=COLOR, --color=COLOR        set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT\n" );
     printf( "examples\n" );
-    printf( "    slrn -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5\n" );
+    printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5\n" );
 }
 
-int slrn::Options::parseOptions( int argc, char** argv ) {
+int slop::Options::parseOptions( int argc, char** argv ) {
     // Simple command parsing. Just uses sscanf to read each argument.
     // It looks complicated because you have to have spaces for delimiters for sscanf.
     for ( int i=0; i<argc; i++ ) {
     return 0;
 }
 
-int slrn::Options::parseInt( std::string arg, int* returnInt ) {
+int slop::Options::parseInt( std::string arg, int* returnInt ) {
     std::string copy = arg;
     int find = copy.find( "=" );
     if ( find != copy.npos ) {
     return 0;
 }
 
-bool slrn::Options::matches( std::string arg, std::string shorthand, std::string longhand ) {
+bool slop::Options::matches( std::string arg, std::string shorthand, std::string longhand ) {
     if ( arg.substr( 0, shorthand.size() ) == shorthand ||
          arg.substr( 0, longhand.size() ) == longhand ) {
         return true;
     return false;
 }
 
-int slrn::Options::parseString( std::string arg, std::string* returnString ) {
+int slop::Options::parseString( std::string arg, std::string* returnString ) {
     std::string copy = arg;
     int find = copy.find( "=" );
     if ( find != copy.npos ) {
     return 0;
 }
 
-int slrn::Options::parseColor( std::string arg, float* r, float* g, float* b ) {
+int slop::Options::parseColor( std::string arg, float* r, float* g, float* b ) {
     std::string copy = arg;
     int find = copy.find( "=" );
     while( find != copy.npos ) {

options.hpp

 #include <string>
 #include <cstdio>
 
-namespace slrn {
+namespace slop {
 
 class Options {
 public:
 
 }
 
-extern slrn::Options* options;
+extern slop::Options* options;
 
 #endif // IS_OPTIONS_H_

x.cpp

 #include "x.hpp"
 
-slrn::XEngine* xengine = new slrn::XEngine();
+slop::XEngine* xengine = new slop::XEngine();
 
-slrn::XEngine::XEngine() {
+slop::XEngine::XEngine() {
     m_keypressed = false;
     m_display = NULL;
     m_visual = NULL;
     m_hoverXWindow = None;
 }
 
-slrn::XEngine::~XEngine() {
+slop::XEngine::~XEngine() {
     if ( !m_good ) {
         return;
     }
 }
 
 // We need to keep track of the rectangle windows, so that they don't override our "focus"d windows.
-void slrn::XEngine::addRect( Rectangle* rect ) {
+void slop::XEngine::addRect( Rectangle* rect ) {
     m_rects.push_back( rect );
 }
 
-void slrn::XEngine::removeRect( Rectangle* rect ) {
+void slop::XEngine::removeRect( Rectangle* rect ) {
     for ( unsigned int i=0; i<m_rects.size(); i++ ) {
         if ( m_rects.at( i ) == rect ) {
             m_rects.erase( m_rects.begin() + i );
     }
 }
 
-bool slrn::XEngine::mouseDown( unsigned int button ) {
+bool slop::XEngine::mouseDown( unsigned int button ) {
     if ( button >= m_mouse.size() ) {
         return false;
     }
     return m_mouse.at( button );
 }
 
-int slrn::XEngine::init( std::string display ) {
+int slop::XEngine::init( std::string display ) {
     // Initialize display
     m_display = XOpenDisplay( display.c_str() );
     if ( !m_display ) {
     return 0;
 }
 
-int slrn::XEngine::grabKeyboard() {
+int slop::XEngine::grabKeyboard() {
     if ( !m_good ) {
         return 1;
     }
                              GrabModeAsync, GrabModeAsync, CurrentTime );
     if ( err != GrabSuccess ) {
         fprintf( stderr, "Error: Failed to grab X keyboard.\n" );
-        fprintf( stderr, "This can be caused by launching slrn incorrectly.\n" );
+        fprintf( stderr, "This can be caused by launching slop incorrectly.\n" );
         fprintf( stderr, "gnome-session launches it fine from keyboard binds.\n" );
         return 1;
     }
 }
 
-int slrn::XEngine::releaseKeyboard() {
+int slop::XEngine::releaseKeyboard() {
     if ( !m_good ) {
         return 1;
     }
 }
 
 // Grabs the cursor, be wary that setCursor changes the mouse masks.
-int slrn::XEngine::grabCursor( slrn::CursorType type ) {
+int slop::XEngine::grabCursor( slop::CursorType type ) {
     if ( !m_good ) {
         return 1;
     }
                             GrabModeAsync, GrabModeAsync, m_root, xfontcursor, CurrentTime );
     if ( err != GrabSuccess ) {
         fprintf( stderr, "Error: Failed to grab X cursor.\n" );
-        fprintf( stderr, "This can be caused by launching slrn incorrectly.\n" );
+        fprintf( stderr, "This can be caused by launching slop incorrectly.\n" );
         fprintf( stderr, "gnome-session launches it fine from keyboard binds.\n" );
         return 1;
     }
     return 0;
 }
 
-int slrn::XEngine::releaseCursor() {
+int slop::XEngine::releaseCursor() {
     if ( !m_good ) {
         return 1;
     }
     return 0;
 }
 
-void slrn::XEngine::tick() {
+void slop::XEngine::tick() {
     if ( !m_good ) {
         return;
     }
 }
 
 // This converts an enum into a preallocated cursor, the cursor will automatically deallocate itself on ~XEngine
-Cursor slrn::XEngine::getCursor( slrn::CursorType type ) {
+Cursor slop::XEngine::getCursor( slop::CursorType type ) {
     int xfontcursor;
     switch ( type ) {
         default:
 }
 
 // Swaps out the current cursor, bewary that XChangeActivePointerGrab also resets masks, so if you change the mouse masks on grab you need to change them here too.
-void slrn::XEngine::setCursor( slrn::CursorType type ) {
+void slop::XEngine::setCursor( slop::CursorType type ) {
     if ( !m_good ) {
         return;
     }
                               xfontcursor, CurrentTime );
 }
 
-slrn::Rectangle::~Rectangle() {
+slop::Rectangle::~Rectangle() {
     //XFreeGC( xengine->m_display, m_gc );
     if ( m_window == None ) {
         return;
     XDestroyWindow( xengine->m_display, m_window );
 }
 
-slrn::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b ) {
+slop::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b ) {
     m_xoffset = 0;
     m_yoffset = 0;
     m_x = x;
     XMapWindow( xengine->m_display, m_window );
 }
 
-void slrn::Rectangle::setPos( int x, int y ) {
+void slop::Rectangle::setPos( int x, int y ) {
     if ( m_x == x && m_y == y ) {
         return;
     }
     XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset, m_y+m_yoffset );
 }
 
-void slrn::Rectangle::setDim( int w, int h ) {
+void slop::Rectangle::setDim( int w, int h ) {
     if ( m_width == w && m_height == h ) {
         return;
     }
     XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
 }
 
-void slrn::XEngine::updateHoverWindow() {
+void slop::XEngine::updateHoverWindow() {
     Window root, child;
     int mx, my;
     int wx, wy;
                   &(m_hoverWindow.m_border), &depth );
 }
 
-void slrn::XEngine::updateHoverWindow( Window child ) {
+void slop::XEngine::updateHoverWindow( Window child ) {
     // Same thing as updateHoverWindow but it uses the specified child.
     // It's used when we first grab the cursor so it's slightly more effecient
     // than calling XQueryPointer twice.
 
 // Keeps our rectangle's sizes all positive, so Xlib doesn't throw an exception.
 // It also keeps our values in absolute coordinates which is nice.
-void slrn::Rectangle::constrain( int w, int h ) {
+void slop::Rectangle::constrain( int w, int h ) {
     int pad = m_padding;
     if ( pad < 0 && std::abs( w ) < std::abs( pad )*2 ) {
         pad = 0;
     }
 }
 
-int slrn::Rectangle::convertColor( float r, float g, float b ) {
+int slop::Rectangle::convertColor( float r, float g, float b ) {
     // Convert float colors to shorts.
     short red   = short( floor( r * 65535.f ) );
     short green = short( floor( g * 65535.f ) );

x.hpp

 #include <string>
 #include <vector>
 
-namespace slrn {
+namespace slop {
 
 enum CursorType {
     Left,
                         ~XEngine();
     int                 init( std::string display );
     void                tick();
-    int                 grabCursor( slrn::CursorType type );
+    int                 grabCursor( slop::CursorType type );
     int                 grabKeyboard();
     int                 releaseCursor();
     int                 releaseKeyboard();
-    void                setCursor( slrn::CursorType type );
+    void                setCursor( slop::CursorType type );
     void                drawRect( int x, int y, unsigned int w, unsigned int h );
     void                addRect( Rectangle* rect );
     void                removeRect( Rectangle* rect );
     bool                m_good;
     std::vector<Cursor> m_cursors;
     std::vector<Rectangle*> m_rects;
-    Cursor              getCursor( slrn::CursorType type );
+    Cursor              getCursor( slop::CursorType type );
 };
 
 }
 
-extern slrn::XEngine* xengine;
+extern slop::XEngine* xengine;
 
 #endif // IS_X_H_