fixed a few bugs and added window selections

README.md

 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.
+features
+--------
+* Clicking on a window makes slrn 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.
+* Hovering over a window will cause a selection rectangle to appear over it.
+* On startup it turns your cursor into a crosshair, then adjusts the cursor into angles as you drag the selection rectangle.

main.cpp

     int state = 0;
     bool running = true;
     is::Rectangle* selection;
+    is::Rectangle* windowselection = NULL;
+    Window window = None;
 
     xengine->init( ":0" );
     xengine->grabCursor( is::Cross );
     while ( running ) {
         xengine->tick();
+        if ( xengine->mouseDown( 3 ) ) {
+            printf( "X: 0\n" );
+            printf( "Y: 0\n" );
+            printf( "W: 0\n" );
+            printf( "H: 0\n" );
+            printf( "User right-clicked. Canceled selection.\n" );
+            state = -1;
+            running = false;
+        }
         switch ( state ) {
+            default: {
+                break;
+            }
             case 0: {
+                if ( window != xengine->m_hoverXWindow ) {
+                    if ( windowselection ) {
+                        xengine->removeRect( windowselection );
+                    }
+                    is::WindowRectangle t = xengine->m_hoverWindow;
+                    windowselection = new is::Rectangle( t.m_x,
+                                                         t.m_y,
+                                                         t.m_width,
+                                                         t.m_height,
+                                                         10, 0 );
+                    xengine->addRect( windowselection );
+                    window = xengine->m_hoverXWindow;
+                }
                 if ( xengine->mouseDown( 1 ) ) {
+                    if ( windowselection ) {
+                        xengine->removeRect( windowselection );
+                    }
                     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 = new is::Rectangle( xengine->m_mousex, xengine->m_mousey, 0, 0, 10, 0 );
                 selection->setPos( xengine->m_mousex, xengine->m_mousey );
                 xengine->addRect( selection );
                 state++;
                 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 );
+                int x = selection->m_x+selection->m_xoffset;
+                int y = selection->m_y+selection->m_yoffset;
+                int w = selection->m_width;
+                int h = selection->m_height;
                 xengine->removeRect( selection );
                 running = false;
+                if ( w || h || xengine->m_hoverXWindow == None ) {
+                    printf( "X: %i\n", x );
+                    printf( "Y: %i\n", y );
+                    printf( "W: %i\n", w + 1 );
+                    printf( "H: %i\n", h + 1 );
+                    break;
+                }
+                is::WindowRectangle t = xengine->m_hoverWindow;
+                x = t.m_x;
+                y = t.m_y;
+                w = t.m_width + t.m_border;
+                h = t.m_height + t.m_border;
+                printf( "X: %i\n", x );
+                printf( "Y: %i\n", y );
+                printf( "W: %i\n", w );
+                printf( "H: %i\n", h );
                 break;
             }
         }

x.cpp

     m_good = false;
     m_mousex = -1;
     m_mousey = -1;
+    m_hoverXWindow = None;
 }
 
 is::XEngine::~XEngine() {
         printf( "Failed to grab X cursor\n" );
         return 1;
     }
+
+    // Quickly set the mouse position so we don't have to worry about x11 generating an event.
+    Window root, child;
+    int mx, my;
+    int wx, wy;
+    unsigned int mask;
+    XQueryPointer( m_display, m_root, &root, &child, &mx, &my, &wx, &wy, &mask );
+    m_mousex = mx;
+    m_mousex = my;
+    updateHoverWindow( child );
     return 0;
 }
 
     if ( !m_good ) {
         return;
     }
-    XFlush( m_display );
+    XSync( m_display, false );
     XEvent event;
     while ( XPending( m_display ) ) {
         XNextEvent( m_display, &event );
                 }
                 break;
             }
+            default: break;
         }
     }
+
+    // Since I couldn't get Xlib to send a EnterNotify or LeaveNotify events, we need to query the underlying window every frame.
+    updateHoverWindow();
 }
 
 Cursor is::XEngine::getCursor( is::CursorType type ) {
     }
     Cursor xfontcursor = getCursor( type );
     XChangeActivePointerGrab( m_display,
-                              ButtonMotionMask | ButtonPressMask | ButtonReleaseMask,
+                              PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
                               xfontcursor, CurrentTime );
 }
 
         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 );
                               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,
+    m_window = XCreateWindow( xengine->m_display, xengine->m_root, m_x-m_border+m_xoffset, m_y-m_border+m_yoffset, m_width+m_border*2, m_height+m_border*2,
                               0, CopyFromParent, InputOutput,
                               CopyFromParent, valueMask, &attributes );
     XRectangle rect;
         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.
 
 void is::Rectangle::draw() {
 }
+
+void is::XEngine::updateHoverWindow() {
+    Window root, child;
+    int mx, my;
+    int wx, wy;
+    unsigned int mask;
+    XQueryPointer( m_display, m_root, &root, &child, &mx, &my, &wx, &wy, &mask );
+    if ( m_hoverXWindow == child ) {
+        return;
+    }
+    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
+        if ( m_rects.at( i )->m_window == child ) {
+            return;
+        }
+    }
+    m_hoverXWindow = child;
+    if ( child == None ) {
+        return;
+    }
+    unsigned int depth;
+    XGetGeometry( m_display, child, &root,
+                  &(m_hoverWindow.m_x), &(m_hoverWindow.m_y),
+                  &(m_hoverWindow.m_width), &(m_hoverWindow.m_height),
+                  &(m_hoverWindow.m_border), &depth );
+}
+
+void is::XEngine::updateHoverWindow( Window child ) {
+    if ( m_hoverXWindow == child ) {
+        return;
+    }
+    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
+        if ( m_rects.at( i )->m_window == child ) {
+            return;
+        }
+    }
+    m_hoverXWindow = child;
+    if ( child == None ) {
+        return;
+    }
+    unsigned int depth;
+    Window root;
+    XGetGeometry( m_display, child, &root,
+                  &(m_hoverWindow.m_x), &(m_hoverWindow.m_y),
+                  &(m_hoverWindow.m_width), &(m_hoverWindow.m_height),
+                  &(m_hoverWindow.m_border), &depth );
+}

x.hpp

     LowerLeftCorner
 };
 
+class WindowRectangle {
+public:
+    int m_x;
+    int m_y;
+    unsigned int m_width;
+    unsigned int m_height;
+    unsigned int m_border;
+};
+
 class Rectangle {
 public:
             Rectangle( int x, int y, int width, int height, int border, int padding );
     int                 m_mousey;
     std::vector<bool>   m_mouse;
     bool                mouseDown( unsigned int button );
+    WindowRectangle     m_hoverWindow;
+    Window              m_hoverXWindow;
 private:
+    void                updateHoverWindow();
+    void                updateHoverWindow( Window child );
     bool                m_good;
     std::vector<Cursor> m_cursors;
     std::vector<Rectangle*> m_rects;