first commit

README.md

@@ -0,0 +1,7 @@
+slrn
+----
+
+slrn is an application that literally just allows a user to select a region of his screen. It grabs the cursor, draws a fancy box, and prints the selection's dimensions and position to stdout.
+
+It does a better job than scrot's selection since it doesn't draw directly to the root window, it creates its own to draw the selection rectangle.
+However due to the X11's Shape extension and window resizing not being synchronized it doesn't render a perfect box during movement. I'm hoping to fix this later by never resizing the window.

main.cpp

@@ -0,0 +1,67 @@
+#include <unistd.h>
+#include "x.hpp"
+
+int main( int argc, char** argv ) {
+    int state = 0;
+    bool running = true;
+    is::Rectangle* selection;
+
+    xengine->init( ":0" );
+    xengine->grabCursor( is::Cross );
+    while ( running ) {
+        xengine->tick();
+        switch ( state ) {
+            case 0: {
+                if ( xengine->mouseDown( 1 ) ) {
+                    state++;
+                }
+                break;
+            }
+            case 1: {
+                // Check to make sure we actually have a cursor position before creating the selection rectangle.
+                if ( xengine->m_mousex == -1 ) {
+                    break;
+                }
+                selection = new is::Rectangle( xengine->m_mousex, xengine->m_mousey, 1, 1, 10, 0 );
+                selection->setPos( xengine->m_mousex, xengine->m_mousey );
+                xengine->addRect( selection );
+                state++;
+                break;
+            }
+            case 2: {
+                if ( !xengine->mouseDown( 1 ) ) {
+                    state++;
+                    break;
+                }
+                selection->setDim( xengine->m_mousex - selection->m_x, xengine->m_mousey - selection->m_y );
+                // x and y offsets can indicate if the selection is inside-out, which lets us know which kind of cursor we need.
+                int x = selection->m_xoffset;
+                int y = selection->m_yoffset;
+                if ( x == 0 && y == 0) {
+                    xengine->setCursor( is::LowerRightCorner );
+                } else if ( x && y == 0 ) {
+                    xengine->setCursor( is::LowerLeftCorner );
+                } else if ( x == 0 && y ) {
+                    xengine->setCursor( is::UpperRightCorner );
+                } else {
+                    xengine->setCursor( is::UpperLeftCorner );
+                }
+
+                break;
+            }
+            case 3: {
+                printf( "X: %i\n", selection->m_x+selection->m_xoffset );
+                printf( "Y: %i\n", selection->m_y+selection->m_yoffset );
+                printf( "W: %i\n", selection->m_width + 1 );
+                printf( "H: %i\n", selection->m_height + 1 );
+                xengine->removeRect( selection );
+                running = false;
+                break;
+            }
+        }
+        // No need to max out CPU--
+        usleep( 1000 );
+    }
+    delete xengine;
+    return 0;
+}

makefile

@@ -0,0 +1,14 @@
+CC=g++
+CFLAGS=-O2 -g
+LDFLAGS=-lX11 -lXext
+SOURCES=main.cpp x.cpp
+OBJECTS=$(SOURCES:.cpp=.o)
+EXECUTABLE=slrn
+
+all: $(SOURCES) $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+	$(CC) $(LDFLAGS) $(OBJECTS) -o $@
+
+clean:
+	rm -rf $(OBJECTS) $(EXECUTABLE)

x.cpp

@@ -0,0 +1,266 @@
+#include "x.hpp"
+
+is::XEngine* xengine = new is::XEngine();
+
+is::XEngine::XEngine() {
+    m_display = NULL;
+    m_visual = NULL;
+    m_screen = NULL;
+    m_good = false;
+    m_mousex = -1;
+    m_mousey = -1;
+}
+
+is::XEngine::~XEngine() {
+    if ( !m_good ) {
+        return;
+    }
+    for ( unsigned int i=0; i<m_cursors.size(); i++ ) {
+        if ( m_cursors.at( i ) ) {
+            XFreeCursor( m_display, m_cursors[i] );
+        }
+    }
+    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
+        delete m_rects.at( i );
+    }
+    XCloseDisplay( m_display );
+}
+
+void is::XEngine::addRect( Rectangle* rect ) {
+    m_rects.push_back( rect );
+}
+
+void is::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 );
+            i--;
+            delete rect;
+            return;
+        }
+    }
+}
+
+bool is::XEngine::mouseDown( unsigned int button ) {
+    if ( button >= m_mouse.size() ) {
+        return false;
+    }
+    return m_mouse.at( button );
+}
+
+int is::XEngine::init( std::string display ) {
+    // Initialize display
+    m_display = XOpenDisplay( display.c_str() );
+    if ( !m_display ) {
+        printf( "Failed to open X display %s\n", display.c_str() );
+        return 1;
+    }
+    m_screen    = ScreenOfDisplay( m_display, DefaultScreen( m_display ) );
+    m_visual    = DefaultVisual  ( m_display, XScreenNumberOfScreen( m_screen ) );
+    m_colormap  = DefaultColormap( m_display, XScreenNumberOfScreen( m_screen ) );
+    m_root      = RootWindow     ( m_display, XScreenNumberOfScreen( m_screen ) );
+
+    m_good = true;
+    return 0;
+}
+
+int is::XEngine::grabCursor( is::CursorType type ) {
+    if ( !m_good ) {
+        return 1;
+    }
+    int xfontcursor = getCursor( type );
+    int err = XGrabPointer( m_display, m_root, False,
+                            PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
+                            GrabModeAsync, GrabModeAsync, m_root, xfontcursor, CurrentTime );
+    if ( err != GrabSuccess ) {
+        printf( "Failed to grab X cursor\n" );
+        return 1;
+    }
+    return 0;
+}
+
+int is::XEngine::releaseCursor() {
+    if ( !m_good ) {
+        return 1;
+    }
+    XUngrabPointer( m_display, CurrentTime );
+    return 0;
+}
+
+void is::XEngine::tick() {
+    if ( !m_good ) {
+        return;
+    }
+    XFlush( m_display );
+    XEvent event;
+    while ( XPending( m_display ) ) {
+        XNextEvent( m_display, &event );
+        switch ( event.type ) {
+            case MotionNotify: {
+                m_mousex = event.xmotion.x;
+                m_mousey = event.xmotion.y;
+                break;
+            }
+            case ButtonPress: {
+                if ( m_mouse.size() > event.xbutton.button ) {
+                    m_mouse.at( event.xbutton.button ) = true;
+                } else {
+                    m_mouse.resize( event.xbutton.button+2, false );
+                    m_mouse.at( event.xbutton.button ) = true;
+                }
+                break;
+            }
+            case ButtonRelease: {
+                if ( m_mouse.size() > event.xbutton.button ) {
+                    m_mouse.at( event.xbutton.button ) = false;
+                } else {
+                    m_mouse.resize( event.xbutton.button+2, false );
+                    m_mouse.at( event.xbutton.button ) = false;
+                }
+                break;
+            }
+        }
+    }
+}
+
+Cursor is::XEngine::getCursor( is::CursorType type ) {
+    int xfontcursor;
+    switch ( type ) {
+        default:
+        case Left:                  xfontcursor = XC_left_ptr; break;
+        case Crosshair:             xfontcursor = XC_crosshair; break;
+        case Cross:                 xfontcursor = XC_cross; break;
+        case UpperLeftCorner:       xfontcursor = XC_ul_angle; break;
+        case UpperRightCorner:      xfontcursor = XC_ur_angle; break;
+        case LowerLeftCorner:       xfontcursor = XC_ll_angle; break;
+        case LowerRightCorner:      xfontcursor = XC_lr_angle; break;
+    }
+    Cursor newcursor = 0;
+    if ( m_cursors.size() > xfontcursor ) {
+        newcursor = m_cursors.at( xfontcursor );
+    }
+    if ( !newcursor ) {
+        newcursor = XCreateFontCursor( m_display, xfontcursor );
+        m_cursors.resize( xfontcursor+2, 0 );
+        m_cursors.at( xfontcursor ) = newcursor;
+    }
+    return newcursor;
+}
+
+void is::XEngine::setCursor( is::CursorType type ) {
+    if ( !m_good ) {
+        return;
+    }
+    Cursor xfontcursor = getCursor( type );
+    XChangeActivePointerGrab( m_display,
+                              ButtonMotionMask | ButtonPressMask | ButtonReleaseMask,
+                              xfontcursor, CurrentTime );
+}
+
+is::Rectangle::~Rectangle() {
+    //XFreeGC( xengine->m_display, m_gc );
+    XUnmapWindow( xengine->m_display, m_window );
+    XDestroyWindow( xengine->m_display, m_window );
+}
+
+is::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding ) {
+    m_xoffset = 0;
+    m_yoffset = 0;
+    m_x = x;
+    m_y = y;
+    m_width = width;
+    m_height = height;
+    m_border = border;
+    m_padding = padding;
+
+    if ( m_width < 0 ) {
+        m_xoffset += m_width;
+        m_width = -m_width;
+    }
+    if ( m_height < 0 ) {
+        m_yoffset += m_height;
+        m_height = -m_height;
+    }
+    if ( m_width == 0 ) {
+        m_width = 1;
+    }
+    if ( m_height == 0 ) {
+        m_height = 1;
+    }
+
+    XAllocNamedColor( xengine->m_display, xengine->m_colormap, "black", &m_forground, &m_forgroundExact );
+    XAllocNamedColor( xengine->m_display, xengine->m_colormap, "white", &m_background, &m_backgroundExact );
+    XSetWindowAttributes attributes;
+    attributes.background_pixmap = None;
+    attributes.background_pixel = m_forground.pixel;
+    attributes.save_under = True;
+    attributes.override_redirect = True;
+    attributes.colormap = xengine->m_colormap;
+    unsigned long valueMask = CWBackPixmap | CWBackPixel |
+                              CWSaveUnder | CWOverrideRedirect |
+                              CWColormap;
+
+    m_window = XCreateWindow( xengine->m_display, xengine->m_root, m_x+m_xoffset, m_y+m_yoffset, m_width+m_border*2, m_height+m_border*2,
+                              0, CopyFromParent, InputOutput,
+                              CopyFromParent, valueMask, &attributes );
+    XRectangle rect;
+    rect.x = rect.y = m_border;
+    rect.width = m_width;
+    rect.height = m_height;
+
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
+    XMapWindow( xengine->m_display, m_window );
+
+    draw();
+}
+
+void is::Rectangle::setPos( int x, int y ) {
+    if ( m_x == x && m_y == y ) {
+        return;
+    }
+    m_x = x;
+    m_y = y;
+    XMoveWindow( xengine->m_display, m_window, m_x-m_border+m_xoffset, m_y-m_border+m_yoffset );
+}
+
+void is::Rectangle::setDim( int w, int h ) {
+    if ( m_width == w && m_height == h ) {
+        return;
+    }
+
+    m_xoffset = 0;
+    m_yoffset = 0;
+    m_width = w;
+    m_height = h;
+    if ( w < 0 ) {
+        m_xoffset += w;
+        m_width = -w;
+    }
+    if ( h < 0 ) {
+        m_yoffset += h;
+        m_height = -h;
+    }
+    if ( m_width == 0 ) {
+        m_width = 1;
+    }
+    if ( m_height == 0 ) {
+        m_height = 1;
+    }
+    XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
+    XMoveWindow( xengine->m_display, m_window, m_x-m_border+m_xoffset, m_y-m_border+m_yoffset );
+    // Now punch another hole in it.
+    XRectangle rect;
+    rect.x = rect.y = 0;
+    rect.width = m_width+m_border*2;
+    rect.height = m_height+m_border*2;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
+    rect;
+    rect.x = rect.y = m_border;
+    rect.width = m_width;
+    rect.height = m_height;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
+    draw();
+}
+
+void is::Rectangle::draw() {
+}

x.hpp

@@ -0,0 +1,80 @@
+// x.hpp: handles starting and managing X
+
+#ifndef IS_X_H_
+#define IS_X_H_
+
+#include <unistd.h>
+
+#include <X11/Xlib.h>
+#include <X11/cursorfont.h>
+#include <X11/extensions/shape.h>
+
+#include <cstdio>
+#include <string>
+#include <vector>
+
+namespace is {
+
+enum CursorType {
+    Left,
+    Crosshair,
+    Cross,
+    UpperLeftCorner,
+    UpperRightCorner,
+    LowerRightCorner,
+    LowerLeftCorner
+};
+
+class Rectangle {
+public:
+            Rectangle( int x, int y, int width, int height, int border, int padding );
+            ~Rectangle();
+    void    setPos( int x, int y );
+    void    setDim( int w, int h );
+    void    draw();
+    Window  m_window;
+    int     m_x;
+    int     m_y;
+    int     m_xoffset;
+    int     m_yoffset;
+    int     m_width;
+    int     m_height;
+    int     m_border;
+    int     m_padding;
+    XColor  m_forground, m_forgroundExact;
+    XColor  m_background, m_backgroundExact;
+};
+
+class XEngine {
+public:
+                        XEngine();
+                        ~XEngine();
+    int                 init( std::string display );
+    void                tick();
+    int                 grabCursor( is::CursorType type );
+    int                 releaseCursor();
+    void                setCursor( is::CursorType type );
+    void                drawRect( int x, int y, unsigned int w, unsigned int h );
+    void                addRect( Rectangle* rect );
+    void                removeRect( Rectangle* rect );
+    Display*            m_display;
+    Visual*             m_visual;
+    Screen*             m_screen;
+    Colormap            m_colormap;
+    Window              m_root;
+    int                 m_mousex;
+    int                 m_mousey;
+    std::vector<bool>   m_mouse;
+    bool                mouseDown( unsigned int button );
+private:
+    bool                m_good;
+    std::vector<Cursor> m_cursors;
+    std::vector<Rectangle*> m_rects;
+    Cursor              getCursor( is::CursorType type );
+};
+
+}
+
+extern is::XEngine* xengine;
+
+#endif // IS_X_H_