Added basic textured themes.

CMakeLists.txt

      src/cmdline.c
      src/selectrectangle.cpp
      src/glselectrectangle.cpp
+     src/resource.cpp
      src/xselectrectangle.cpp
      src/x.cpp
      src/main.cpp )
 find_package( GLX       REQUIRED )
 find_package( XRender   REQUIRED )
 find_package( XRandr    REQUIRED )
+find_package( DevIL     REQUIRED )
 # This library is needed only for Ubuntu it seems, some platforms don't even
 # ship with it. I couldn't find a way to do a test compile to check if librt
 # was needed, so instead I just didn't mark it as REQUIRED.
                          ${XEXT_INCLUDE_DIR}
                          ${XRANDR_INCLUDE_DIR}
                          ${OPENGL_INCLUDE_DIR}
+                         ${IL_INCLUDE_DIR}
                          ${GLX_INCLUDE_DIR}
                          ${XRENDER_INCLUDE_DIRS}
                          ${RT_INCLUDE_DIR} )
 else()
     include_directories( ${X11_INCLUDE_DIR}
                          ${OPENGL_INCLUDE_DIR}
+                         ${IL_INCLUDE_DIR}
                          ${GLX_INCLUDE_DIR}
                          ${XEXT_INCLUDE_DIR} )
 endif()
     target_link_libraries( "${BIN_TARGET}"
                            ${X11_LIBRARIES}
                            ${OPENGL_LIBRARIES}
+                           ${IL_LIBRARIES}
+                           ${ILUT_LIBRARIES}
                            ${GLX_LIBRARIES}
                            ${XRENDER_LIBRARIES}
                            "${XEXT_LIBRARY}"
 else()
     target_link_libraries( "${BIN_TARGET}"
                            ${OPENGL_LIBRARIES}
+                           ${IL_LIBRARIES}
+                           ${ILUT_LIBRARIES}
                            ${GLX_LIBRARIES}
                            ${X11_LIBRARIES}
                            "${XEXT_LIBRARY}" )
 
 install( TARGETS ${BIN_TARGET}
          DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
+
+add_definitions(-DINSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}")

src/glselectrectangle.cpp

     glDisable(GL_TEXTURE_2D);
 }
 
+void slop::GLSelectRectangle::setTheme( bool on, std::string name ) {
+    if ( !on ) {
+        return;
+    }
+    std::string root = resource->getRealPath( name );
+    std::string tl = root + "/corner_tl.png";
+    std::string bl = root + "/corner_bl.png";
+    std::string tr = root + "/corner_tr.png";
+    std::string br = root + "/corner_br.png";
+    std::string straight = root + "/straight.png";
+    // One of the textures didn't exist, so we cancel the theme.
+    if (!resource->validatePath( tl ) ||
+        !resource->validatePath( bl ) ||
+        !resource->validatePath( tr ) ||
+        !resource->validatePath( br ) ||
+        !resource->validatePath( straight ) ) {
+        fprintf( stderr, "One of the textures was missing in the theme... disabling.\n" );
+        return;
+    }
+    // Otherwise we load each one :)
+    ilInit();
+    ilutInit();
+    ilutRenderer(ILUT_OPENGL);
+    ILuint corner;
+    ilGenImages( 1, &corner );
+    ilBindImage( corner );
+    ilLoadImage( tl.c_str() );
+    m_cornerids[0] = ilutGLBindMipmaps();
+    ilLoadImage( tr.c_str() );
+    m_cornerids[1] = ilutGLBindMipmaps();
+    ilLoadImage( bl.c_str() );
+    m_cornerids[2] = ilutGLBindMipmaps();
+    ilLoadImage( br.c_str() );
+    m_cornerids[3] = ilutGLBindMipmaps();
+    ilLoadImage( straight.c_str() );
+    m_straightwidth = ilGetInteger( IL_IMAGE_WIDTH );
+    m_straightheight = ilGetInteger( IL_IMAGE_HEIGHT );
+    m_straightid = ilutGLBindMipmaps();
+    // And clean up after.
+    ilDeleteImages( 1, &corner );
+    m_themed = on;
+}
+
 slop::GLSelectRectangle::GLSelectRectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a ) {
     m_x = std::min( sx, ex );
     m_y = std::min( sy, ey );
     m_glassSize = 4;
     m_glassBorder = 1;
     m_monitors = xengine->getCRTCS();
+    m_themed = false;
 
     // If we don't have a border, we don't exist, so just die.
     if ( m_border == 0 ) {
     if ( !glXMakeContextCurrent( xengine->m_display, m_glxWindow, m_glxWindow, m_renderContext ) ) {
         fprintf( stderr, "Failed to attach GL context to window!\n" );
     }
+    glEnable( GL_BLEND );
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
     glClearColor( 0, 0, 0, 0 );
     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
     glXSwapBuffers( xengine->m_display, m_glxWindow );
     glMatrixMode( GL_MODELVIEW );
     glLoadIdentity();
 
-    glColor4f( m_r, m_g, m_b, m_a );
-    glRecti( m_x-m_border, m_y, m_x+m_width+m_border, m_y-m_border );
-    glRecti( m_x-m_border, m_y+m_height, m_x+m_width+m_border, m_y+m_height+m_border );
-    glRecti( m_x-m_border, m_y, m_x, m_y+m_height );
-    glRecti( m_x+m_width, m_y, m_x+m_width+m_border, m_y+m_height );
+    if ( !m_themed ) {
+        glColor4f( m_r, m_g, m_b, m_a );
+        glRecti( m_x-m_border, m_y, m_x+m_width+m_border, m_y-m_border );
+        glRecti( m_x-m_border, m_y+m_height, m_x+m_width+m_border, m_y+m_height+m_border );
+        glRecti( m_x-m_border, m_y, m_x, m_y+m_height );
+        glRecti( m_x+m_width, m_y, m_x+m_width+m_border, m_y+m_height );
+    } else {
+        glColor4f( m_r, m_g, m_b, m_a );
+        glEnable( GL_TEXTURE_2D );
+        glBindTexture( GL_TEXTURE_2D, m_straightid );
+        float something = (float)(m_border)/(float)m_straightheight;
+        float txoffset = (((float)m_width+m_border)/(float)m_straightwidth)/something;
+        float tyoffset = (((float)m_height+m_border)/(float)m_straightwidth)/something;
+        //float ratio = ((float)m_straightwidth/(float)m_straightheight);
+        glBegin( GL_QUADS );
+        // straight top
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border/2, m_y-m_border );
+        glTexCoord2f(txoffset, 1.0); glVertex2f( m_x+m_width+m_border/2, m_y-m_border );
+        glTexCoord2f(txoffset, 0.0); glVertex2f( m_x+m_width+m_border/2, m_y );
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border/2, m_y );
+        // straight bot
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border/2, m_y+m_height );
+        glTexCoord2f(txoffset, 1.0); glVertex2f( m_x+m_width+m_border/2, m_y+m_height );
+        glTexCoord2f(txoffset, 0.0); glVertex2f( m_x+m_width+m_border/2, m_y+m_height+m_border );
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border/2, m_y+m_height+m_border );
+        // straight left
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y-m_border/2 );
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x, m_y-m_border/2 );
+        glTexCoord2f(tyoffset, 1.0); glVertex2f( m_x, m_y+m_height+m_border/2 );
+        glTexCoord2f(tyoffset, 0.0); glVertex2f( m_x-m_border, m_y+m_height+m_border/2 );
+        // straight right
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y-m_border/2 );
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y-m_border/2 );
+        glTexCoord2f(tyoffset, 1.0); glVertex2f( m_x+m_width+m_border, m_y+m_height+m_border/2 );
+        glTexCoord2f(tyoffset, 0.0); glVertex2f( m_x+m_width, m_y+m_height+m_border/2 );
+        glEnd();
+        // top left corner
+        glBindTexture( GL_TEXTURE_2D, m_cornerids[0] );
+        glBegin( GL_QUADS );
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border, m_y-m_border );
+        glTexCoord2f(1.0, 1.0); glVertex2f( m_x, m_y-m_border );
+        glTexCoord2f(1.0, 0.0); glVertex2f( m_x, m_y );
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y );
+        glEnd();
+        // top right
+        glBindTexture( GL_TEXTURE_2D, m_cornerids[1] );
+        glBegin( GL_QUADS );
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width, m_y-m_border );
+        glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y-m_border );
+        glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y );
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y );
+        glEnd();
+        // bottom left
+        glBindTexture( GL_TEXTURE_2D, m_cornerids[2] );
+        glBegin( GL_QUADS );
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border, m_y+m_height );
+        glTexCoord2f(1.0, 1.0); glVertex2f( m_x, m_y+m_height );
+        glTexCoord2f(1.0, 0.0); glVertex2f( m_x, m_y+m_height+m_border );
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y+m_height+m_border );
+        glEnd();
+        // bottom right
+        glBindTexture( GL_TEXTURE_2D, m_cornerids[2] );
+        glBegin( GL_QUADS );
+        glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width, m_y+m_height );
+        glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y+m_height );
+        glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y+m_height+m_border );
+        glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y+m_height+m_border );
+        glEnd();
+    }
 
     if ( m_glassEnabled ) {
         generateMagnifyingGlass();

src/glselectrectangle.hpp

 
 #include "x.hpp"
 #include "selectrectangle.hpp"
+#include "resource.hpp"
 
 #include <unistd.h>
 
 #include <GL/gl.h>
 #include <GL/glx.h>
 #include <GL/glxext.h>
+#define ILUT_USE_OPENGL
+#include <IL/il.h>
+#include <IL/ilut.h>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/Xrender.h>
     void                pushOut( int* x, int* y, int w, int h, int rx, int ry, int rw, int rh );
     void                findOptimalGlassPosition();
     void                constrainWithinMonitor( int* x, int* y, int* w, int* h );
+    void                setTheme( bool on, std::string name );
     float               m_r;
     float               m_g;
     float               m_b;
     GLXContext          m_renderContext;
     GLXWindow           m_glxWindow;
     Colormap            m_cmap;
+    bool                m_themed;
     unsigned int        m_texid;
+    unsigned int        m_cornerids[4];
+    unsigned int        m_straightid;
+    unsigned int        m_straightwidth;
+    unsigned int        m_straightheight;
     int                 m_offsetx;
     int                 m_offsety;
     int                 m_offsetw;

src/main.cpp

                                                                      r, g, b, a );
                             // Haha why is this so hard to cast?
                             ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
+                            ((slop::GLSelectRectangle*)(selection))->setTheme( true, "gothic" );
                         } else {
                             selection = new slop::XSelectRectangle( t.m_x, t.m_y,
                                                                     t.m_x + t.m_width,
                                                                  r, g, b, a );
                         // Haha why is this so hard to cast?
                         ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
+                        ((slop::GLSelectRectangle*)(selection))->setTheme( true, "gothic" );
                     } else {
                         selection = new slop::XSelectRectangle( sx, sy,
                                                                 ex, ey,

src/resource.cpp

+/* resource.cpp: Handles getting resources like textures and stuff.
+ *
+ * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
+ *
+ * This file is part of Slop.
+ *
+ * Slop is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Slop is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resource.hpp"
+
+slop::Resource* resource = new slop::Resource();
+
+slop::Resource::Resource() {
+    // Find the configuration directory.
+    // usually ~/.config/slop and /usr/share/slop
+    char* config = getenv( "XDG_CONFIG_HOME" );
+    if ( config == NULL ) {
+        char* home = getpwuid(getuid())->pw_dir;
+        m_usrconfig += home;
+        m_usrconfig += "/.config/slop/";
+        return;
+    }
+    m_usrconfig += config;
+    m_usrconfig += "/slop/";
+    m_sysconfig = INSTALL_PREFIX;
+    m_sysconfig += "/share/slop";
+}
+
+std::string slop::Resource::getRealPath( std::string localpath ) {
+    if ( !validatePath( m_usrconfig + localpath ) ) {
+        if ( !validatePath( m_sysconfig + localpath ) ) {
+            fprintf( stderr, "Failed to find directory %s in %s or %s...\n", localpath.c_str(), m_usrconfig.c_str(), m_sysconfig.c_str() );
+        }
+        return m_sysconfig + localpath;
+    }
+    return m_usrconfig + localpath;
+}
+
+bool slop::Resource::validatePath( std::string path ) {
+
+    struct stat st;
+
+    const char* dirname = path.c_str();
+    if ( stat( dirname, &st ) != 0 ) {
+        return false;
+    }
+    // No read permissions.
+    //if ( !(st.st_mode & S_IROTH) &&
+         //(st.st_uid != getuid() || !(st.st_mode & S_IRUSR)) &&
+         //(st.st_gid != getgid() || !(st.st_mode & S_IRGRP)) ) {
+        //return false;
+    //}
+    // Lookin' good!
+    return true;
+}
+

src/resource.hpp

+/* resource.hpp: Handles getting resources like textures and stuff.
+ *
+ * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
+ *
+ * This file is part of Slop.
+ *
+ * Slop is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Slop is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef IS_RESOURCE_H_
+#define IS_RESOURCE_H_
+
+#include <stdlib.h>
+#include <cstdio>
+#include <string>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pwd.h>
+
+namespace slop {
+
+class Resource {
+public:
+
+                    Resource();
+                    ~Resource();
+    std::string     getRealPath( std::string localpath );
+    bool            validatePath( std::string path );
+private:
+    std::string     m_usrconfig;
+    std::string     m_sysconfig;
+};
+
+}
+
+extern slop::Resource* resource;
+
+#endif // IS_RESOURCE_H_