Changed build system to cmake, made error handling more verbose, fixed many warnings, and added exception handling.

CMakeLists.txt

+cmake_minimum_required( VERSION 2.8 )
+
+set( PROJECT_NAME   "slop" )
+set( BIN_TARGET     "${PROJECT_NAME}" )
+set( CMAKE_INSTALL_PREFIX "/usr/bin" )
+
+project( ${PROJECT_NAME} )
+
+# Linux compiler initialization.
+if ( CMAKE_COMPILER_IS_GNUCXX )
+    set( CMAKE_CXX_FLAGS
+         "${CMAKE_CXX_FLAGS} -Wall -Wextra -Werror -pedantic-errors -Wno-unused-parameter" )
+         # -Wall:   Enable all warnings.
+         # -Wextra: Enable some more warnings.
+         # -Werror: Have errors on warnings.
+         # -Wno-unused-parameter: Prevent unused variable warning. (Several functions are required to have unecessary variables because X11.)
+    add_definitions( -D_CMAKE_LINUX_ )
+else()
+    message( FATAL_ERROR "Your operating system isn't supported yet! CMake will now exit." )
+endif()
+
+# Add a check target for our makefile.
+find_program( CPPCHECK_EXECUTABLE cppcheck
+              DOC "A tool for static C/C++ code analysis." )
+if (CPPCHECK_EXECUTABLE)
+    add_custom_target( "check"
+                       COMMAND "${CPPCHECK_EXECUTABLE}" "--enable=all" "*"
+                       WORKING_DIRECTORY src VERBATIM )
+endif()
+
+# Sources
+set( source
+     src/cmdline.c
+     src/rectangle.cpp
+     src/x.cpp
+     src/main.cpp )
+
+# Obtain library paths and make sure they exist.
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmakemodules" )
+find_package( X11       REQUIRED )
+find_package( XExt      REQUIRED )
+
+set( CMAKE_CXX_FLAGS
+     "${CMAKE_CXX_FLAGS} ${CMAKE_IMLIB2_CXX_FLAGS}" )
+
+# Includes
+include_directories( ${X11_INCLUDE_DIR}
+                     ${XEXT_INCLUDE_DIR} )
+
+# Executable
+add_executable( ${BIN_TARGET} ${source} )
+
+# Libraries
+target_link_libraries( ${BIN_TARGET}
+                       ${X11_LIBRARIES}
+                       ${XEXT_LIBRARY} )
+
+install( TARGETS ${BIN_TARGET}
+         DESTINATION  ${CMAKE_INSTALL_PREFIX} )

README.md

 
 ## how to install
 
-### Install using your Package Manager (preferred)
+### Install using your Package Manager (Preferred)
 
 * [Arch Linux AUR (slop-git)](https://aur.archlinux.org/packages/slop-git/)
 * Please make a package for slop on your favorite system, and make a pull request to add it to this list.
 
 
-### Install using Make
+### Install using CMake (Requires CMake)
 
-Note: Dependencies should be installed first: libXext, and glibc.
+Note: Dependencies should be installed first: libXext.
 
 ```bash
 git clone https://github.com/naelstrof/slop.git
 cd slop
+cmake ./
 make && sudo make install
 ```
 
 help
 ----
 ```text
-slop v3.1.7
+slop v3.1.8
 
 Copyright (C) 2014 Dalton Nell, Slop Contributors
 (https://github.com/naelstrof/slop/graphs/contributors)

cmakemodules/FindXExt.cmake

+# - Find XExt
+# Find the XExtension libraries (WARNING: It's geared and tested specifically for the XShape extension though)
+#
+#  This module defines the following variables:
+#     XEXT_FOUND        - 1 if XEXT_INCLUDE_DIR & XEXT_LIBRARY are found, 0 otherwise
+#     XEXT_INCLUDE_DIR  - where to find Xlib.h, etc.
+#     XEXT_LIBRARY      - the X11 library
+#
+
+find_path( XEXT_INCLUDE_DIR
+           NAMES X11/extensions/shape.h
+           PATH_SUFFIXES X11/extensions
+           DOC "The XExtension include directory" )
+
+find_library( XEXT_LIBRARY
+              NAMES Xext
+              PATHS /usr/lib /lib
+              DOC "The XExtension library" )
+
+if( XEXT_INCLUDE_DIR AND XEXT_LIBRARY )
+    set( XEXT_FOUND 1 )
+else()
+    set( XEXT_FOUND 0 )
+endif()
+
+mark_as_advanced( XEXT_INCLUDE_DIR XEXT_LIBRARY )

gengetopt.sh

 #!/bin/bash
 # This is used because a bug in gengetopt keeps you from putting \n in default string options. All it does is replace REPLACEME with the correct code to make the application work properly.
+cd "$(dirname $0)/src"
 gengetopt < options.ggo
 sed -i '0,/REPLACEME/{s/REPLACEME/X=%x\\\\nY=%y\\\\nW=%w\\\\nH=%h\\\\nG=%g\\\\nID=%i\\\\nCancel=%c\\\\n/}' cmdline.c
 sed -i 's/REPLACEME/X=%x\\nY=%y\\nW=%w\\nH=%h\\nG=%g\\nID=%i\\nCancel=%c\\n/' cmdline.c

makefile

-CXX ?= g++
-CXXFLAGS ?= -O2 -g
-LDFLAGS += -lX11 -lXext -lrt
-SOURCES = main.cpp x.cpp cmdline.c rectangle.cpp
-OBJECTS = main.o x.o cmdline.o rectangle.o
-EXECUTABLE = slop
-BINDIR = "/usr/bin"
-
-all: $(EXECUTABLE)
-
-$(EXECUTABLE): $(OBJECTS)
-	$(CXX) $(OBJECTS) -o $@ $(LDFLAGS)
-
-clean:
-	$(RM) $(OBJECTS)
-
-dist-clean: clean
-	$(RM) $(EXECUTABLE)
-
-install: all
-	mkdir -p $(DESTDIR)$(BINDIR)
-	cp $(CURDIR)/$(EXECUTABLE) $(DESTDIR)$(BINDIR)
-

cmdline.h → src/cmdline.h

 
 #ifndef CMDLINE_PARSER_VERSION
 /** @brief the program version */
-#define CMDLINE_PARSER_VERSION "v3.1.7"
+#define CMDLINE_PARSER_VERSION "v3.1.8"
 #endif
 
 /** @brief Where the command line options are stored */

main.cpp → src/main.cpp

     size_t pos = 0;
     while ( ( pos = format.find( "%", pos ) ) != std::string::npos ) {
         if ( pos + 1 > format.size() ) {
-            fprintf( stderr, "Format error: %% found at the end of format string.\n", format[ pos + 1 ] );
-            return 1;
+            fprintf( stderr, "Format error: %% found at the end of format string.\n" );
+            return EXIT_FAILURE;
         }
         std::stringstream foo;
         switch( format[ pos + 1 ] ) {
             default:
                 fprintf( stderr, "Format error: %%%c is an unknown replacement identifier.\n", format[ pos + 1 ] );
                 fprintf( stderr, "Valid replacements: %%x, %%y, %%w, %%h, %%i, %%c, %%.\n" );
-                return 1;
+                return EXIT_FAILURE;
                 break;
         }
     }
         pos = pos + 1;
     }
     printf( "%s", format.c_str() );
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 int parseColor( std::string arg, float* r, float* g, float* b, float* a ) {
     std::string copy = arg;
     int find = copy.find( "," );
-    while( find != copy.npos ) {
+    while( find != (int)copy.npos ) {
         copy.at( find ) = ' ';
         find = copy.find( "," );
     }
     int num = sscanf( copy.c_str(), "%f %f %f %f", r, g, b, a );
     if ( num != 3 && num != 4 ) {
         fprintf( stderr, "Error parsing color %s\n", arg.c_str() );
-        return 1;
+        return EXIT_FAILURE;
     }
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 void constrain( int sx, int sy, int ex, int ey, int padding, int minimumsize, int maximumsize, int* rsx, int* rsy, int* rex, int* rey ) {
     *rey = y + h;
 }
 
-int main( int argc, char** argv ) {
+int app( int argc, char** argv ) {
     gengetopt_args_info options;
     int err = cmdline_parser( argc, argv, &options );
-    if ( err ) {
-        return err;
+    if ( err != EXIT_SUCCESS ) {
+        return EXIT_FAILURE;
     }
     int state = 0;
     bool running = true;
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
     err = xengine->init( xdisplay.c_str() );
-    if ( err ) {
+    if ( err != EXIT_SUCCESS ) {
         printSelection( format, true, 0, 0, 0, 0, None );
-        return err;
+        return EXIT_FAILURE;
     }
     err = xengine->grabCursor( slop::Cross );
-    if ( err ) {
+    if ( err != EXIT_SUCCESS ) {
         printSelection( format, true, 0, 0, 0, 0, None );
-        return err;
+        return EXIT_FAILURE;
     }
     if ( keyboard ) {
         err = xengine->grabKeyboard();
                 // We also detect which way the user is pulling and set the mouse icon accordingly.
                 bool x = cx > xengine->m_mousex;
                 bool y = cy > xengine->m_mousey;
-                if ( selection->m_width <= 1 && selection->m_height <= 1 || ( minimumsize == maximumsize && minimumsize != 0 && maximumsize != 0 ) ) {
+                if ( ( selection->m_width <= 1 && selection->m_height <= 1 ) || ( minimumsize == maximumsize && minimumsize != 0 && maximumsize != 0 ) ) {
                     xengine->setCursor( slop::Cross );
                 } else if ( !x && !y ) {
                     xengine->setCursor( slop::LowerRightCorner );
     usleep( 50000 );
     // If we canceled the selection, return error.
     if ( state == -1 ) {
-        return 1;
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+int main( int argc, char** argv ) {
+    int exitvalue = EXIT_SUCCESS;
+    try {
+        exitvalue = app( argc, argv );
+    } catch( std::exception* exception ) {
+        fprintf( stderr, "Unhandled Exception Thrown: %s\n", exception->what() );
+        exit( EXIT_FAILURE );
     }
-    return 0;
+    return exitvalue;
 }

options.ggo → src/options.ggo

 package "slop"
-version "v3.1.7"
+version "v3.1.8"
 usage "slop [options]"
 description "slop (Select Operation) is an application that queries for a selection from the user and prints the region to stdout."
 versiontext "Copyright (C) 2014 Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors)"

rectangle.cpp → src/rectangle.cpp

     unsigned long valueMask = CWBackPixel | CWOverrideRedirect | CWEventMask;
 
     // Create the window
-    m_window = XCreateWindow( xengine->m_display, xengine->m_root, 0, 0, WidthOfScreen( xengine->m_screen ), HeightOfScreen( xengine->m_screen ),
+    m_window = XCreateWindow( xengine->m_display, xengine->m_root, 0, 0, xengine->getWidth(), xengine->getHeight(),
                               0, CopyFromParent, InputOutput,
                               CopyFromParent, valueMask, &attributes );
 

x.cpp → src/x.cpp

     // 31 = XGrabKeyboard's request code
     if ( event->request_code == 31 && event->error_code == BadAccess ) {
         fprintf( stderr, "_X Error \"BadAccess\" for XGrabKeyboard ignored...\n" );
-        return 0;
+        return EXIT_SUCCESS;
     }
     // Everything else should be fatal as I don't like undefined behavior.
     char buffer[1024];
     exit(1);
 }
 
-int slop::XEngine::getWidth() {
+unsigned int slop::XEngine::getWidth() {
     if ( !m_good ) {
         return -1;
     }
-    return (int)WidthOfScreen( m_screen );
+    return WidthOfScreen( m_screen );
 }
 
-int slop::XEngine::getHeight() {
+unsigned int slop::XEngine::getHeight() {
     if ( !m_good ) {
         return -1;
     }
-    return (int)HeightOfScreen( m_screen );
+    return HeightOfScreen( m_screen );
 }
 
 slop::XEngine::XEngine() {
+    m_keypressed = false;
     m_display = NULL;
     m_visual = NULL;
     m_screen = NULL;
     m_display = XOpenDisplay( display.c_str() );
     if ( !m_display ) {
         fprintf( stderr, "Error: Failed to open X display %s\n", display.c_str() );
-        return 1;
+        return EXIT_FAILURE;
     }
     m_screen    = ScreenOfDisplay( m_display, DefaultScreen( m_display ) );
     m_visual    = DefaultVisual  ( m_display, XScreenNumberOfScreen( m_screen ) );
     m_good = true;
     XSetErrorHandler( slop::XEngineErrorHandler );
     selectAllInputs( m_root, EnterWindowMask );
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 bool slop::XEngine::anyKeyPressed() {
 
 int slop::XEngine::grabKeyboard() {
     if ( !m_good ) {
-        return 1;
+        return EXIT_FAILURE;
     }
     int err = XGrabKeyboard( m_display, m_root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
     if ( err != GrabSuccess ) {
         fprintf( stderr, "Warning: Failed to grab X keyboard.\n" );
         fprintf( stderr, "         This happens when something has already grabbed your keybaord.\n" );
         fprintf( stderr, "         slop should still run properly though.\n" );
-        return 1;
+        return EXIT_FAILURE;
     }
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 int slop::XEngine::releaseKeyboard() {
     if ( !m_good ) {
-        return 1;
+        return EXIT_FAILURE;
     }
     XUngrabKeyboard( m_display, CurrentTime );
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 void slop::XEngine::selectAllInputs( Window win, long event_mask) {
 // Grabs the cursor, be wary that setCursor changes the mouse masks.
 int slop::XEngine::grabCursor( slop::CursorType type ) {
     if ( !m_good ) {
-        return 1;
+        return EXIT_FAILURE;
     }
     int xfontcursor = getCursor( type );
     int err = XGrabPointer( m_display, m_root, True,
     if ( err != GrabSuccess ) {
         fprintf( stderr, "Error: Failed to grab X cursor.\n" );
         fprintf( stderr, "       This can be caused by launching slop weirdly.\n" );
-        return 1;
+        return EXIT_FAILURE;
     }
     // Quickly set the mouse position so we don't have to worry about x11 generating an event.
     Window root, child;
         XQueryPointer( m_display, child, &root, &test, &mx, &my, &wx, &wy, &mask );
     }
     m_hoverWindow = child;
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 int slop::XEngine::releaseCursor() {
     if ( !m_good ) {
-        return 1;
+        return EXIT_FAILURE;
     }
     XUngrabPointer( m_display, CurrentTime );
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 void slop::XEngine::tick() {
         case Box:                   xfontcursor = 40; break;
     }
     Cursor newcursor = 0;
-    if ( m_cursors.size() > xfontcursor ) {
+    if ( m_cursors.size() > (unsigned int)xfontcursor ) {
         newcursor = m_cursors.at( xfontcursor );
     }
     if ( !newcursor ) {
 }
 
 void slop::WindowRectangle::applyPadding( int padding ) {
-    if ( m_width + padding*2 >= 0 ) {
+    if ( (int)m_width + padding*2 >= 0 ) {
         m_x -= padding;
         m_width += padding*2;
     }
-    if ( m_height + padding*2 >= 0 ) {
+    if ( (int)m_height + padding*2 >= 0 ) {
         m_y -= padding;
         m_height += padding*2;
     }
     return m_window;
 }
 
-void slop::WindowRectangle::applyMinMaxSize( int minimumsize, int maximumsize ) {
+void slop::WindowRectangle::applyMinMaxSize( unsigned int minimumsize, unsigned int maximumsize ) {
     if ( minimumsize > maximumsize && maximumsize > 0 ) {
         fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
         exit( 1 );
         Window root, parent, test, junk;
         Window* childlist;
         unsigned int ujunk;
-        unsigned int depth;
         // Try to find the actual decorations.
         test = win;
         int status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);

x.hpp → src/x.hpp

     Window       getWindow();
     void         setGeometry( Window win, bool decorations );
     void         applyPadding( int padding );
-    void         applyMinMaxSize( int minimumsize, int maximumsize );
+    void         applyMinMaxSize( unsigned int minimumsize, unsigned int maximumsize );
 };
 
 class XEngine {
     int                 releaseKeyboard();
     void                setCursor( slop::CursorType type );
     void                drawRect( int x, int y, unsigned int w, unsigned int h );
-    int                 getWidth();
-    int                 getHeight();
+    unsigned int        getWidth();
+    unsigned int        getHeight();
     int                 m_mousex;
     int                 m_mousey;
     Display*            m_display;