added color options

main.cpp

     int padding = options->m_padding;
     int borderSize = options->m_borderSize;
     int tolerance = options->m_tolerance;
+    float r = options->m_red;
+    float g = options->m_green;
+    float b = options->m_blue;
 
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
                                                          t.m_y - t.m_border,
                                                          t.m_width + t.m_border,
                                                          t.m_height + t.m_border,
-                                                         borderSize, padding );
+                                                         borderSize, padding,
+                                                         r, g, b );
                     xengine->addRect( windowselection );
                     window = xengine->m_hoverXWindow;
                 }
             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 );
+                selection = new slrn::Rectangle( xengine->m_mousex, xengine->m_mousey, 0, 0, borderSize, padding, r, g, b );
                 xengine->addRect( selection );
                 state++;
                 break;

options.cpp

     m_padding = 0;
     m_xdisplay = ":0";
     m_tolerance = 4;
+    m_red = 0;
+    m_green = 0;
+    m_blue = 0;
 }
 
 void slrn::Options::printHelp() {
     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( "    -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\n" );
+    printf( "    slrn -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5\n" );
 }
 
 int slrn::Options::parseOptions( int argc, char** argv ) {
             if ( err ) {
                 return 1;
             }
+        } else if ( matches( arg, "-c=", "--color=" ) ) {
+            int err = parseColor( arg, &m_red, &m_green, &m_blue );
+            if ( err ) {
+                return 1;
+            }
         } else if ( matches( arg, "-t=", "--tolerance=" ) ) {
             int err = parseInt( arg, &m_tolerance );
             if ( err ) {
     delete[] y;
     return 0;
 }
+
+int slrn::Options::parseColor( std::string arg, float* r, float* g, float* b ) {
+    std::string copy = arg;
+    int find = copy.find( "=" );
+    while( find != copy.npos ) {
+        copy.at( find ) = ' ';
+        find = copy.find( "," );
+    }
+
+    // Just in case we error out, grab the actual argument name into x.
+    char* x = new char[ arg.size() ];
+    int num = sscanf( copy.c_str(), "%s %f %f %f", x, r, g, b );
+    if ( num != 4 ) {
+        fprintf( stderr, "Error parsing command arguments near %s\n", arg.c_str() );
+        fprintf( stderr, "Usage: %s=COLOR\n", x );
+        fprintf( stderr, "Example: %s=0,0,0 or %s=0.7,0.2,1\n", x, x );
+        fprintf( stderr, "Try -h or --help for help.\n" );
+        delete[] x;
+        return 1;
+    }
+    delete[] x;
+    return 0;
+}

options.hpp

     int         m_borderSize;
     int         m_padding;
     int         m_tolerance;
+    float       m_red;
+    float       m_green;
+    float       m_blue;
     std::string m_xdisplay;
 private:
     int         parseInt( std::string arg, int* returnInt );
     int         parseString( std::string arg, std::string* returnString );
+    int         parseColor( std::string arg, float* r, float* g, float* b );
     bool        matches( std::string arg, std::string shorthand, std::string longhand );
 };
 

x.cpp

     if ( m_window == None ) {
         return;
     }
+    //XFreeColors( xengine->m_display, xengine->m_colormap, m_color.pixel, 1,
     XUnmapWindow( xengine->m_display, m_window );
     XDestroyWindow( xengine->m_display, m_window );
 }
 
-slrn::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding ) {
+slrn::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;
         return;
     }
 
-    XAllocNamedColor( xengine->m_display, xengine->m_colormap, "black", &m_forground, &m_forgroundExact );
-    XAllocNamedColor( xengine->m_display, xengine->m_colormap, "white", &m_background, &m_backgroundExact );
+    // This sets up m_color
+    int err = convertColor( r, g, b );
+    if ( err ) {
+        fprintf( stderr, "Couldn't allocate color of value %f,%f,%f!\n", r, g, b );
+    }
     XSetWindowAttributes attributes;
     attributes.background_pixmap = None;
-    attributes.background_pixel = m_forground.pixel;
+    attributes.background_pixel = m_color.pixel;
     attributes.save_under = True;
     attributes.override_redirect = True;
     attributes.colormap = xengine->m_colormap;
         m_height = h + pad*2;
     }
 }
+
+int slrn::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 ) );
+    short blue  = short( floor( b * 65535.f ) );
+    XColor color;
+    color.red = red;
+    color.green = green;
+    color.blue = blue;
+    int err = XAllocColor( xengine->m_display, xengine->m_colormap, &color );
+    if ( err == BadColor ) {
+        return err;
+    }
+    m_color = color;
+    return 0;
+}

x.hpp

 
 class Rectangle {
 public:
-            Rectangle( int x, int y, int width, int height, int border, int padding );
+            Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b );
             ~Rectangle();
     void    setPos( int x, int y );
     void    setDim( int w, int h );
     int     m_height;
     int     m_border;
     int     m_padding;
-    XColor  m_forground, m_forgroundExact;
-    XColor  m_background, m_backgroundExact;
+    XColor  m_color;
     bool    m_flippedx;
     bool    m_flippedy;
 private:
+    int     convertColor( float r, float g, float b );
     void    constrain( int w, int h );
 };