improved namespace clashing

CMakeLists.txt

                                     src/x.cpp
                                     src/slopstates.cpp
                                     src/framebuffer.cpp
-                                    src/windowhelper.cpp
                                     src/resource.cpp
                                     src/gl_core_3_3.c
                                     src/shader.cpp

src/framebuffer.cpp

 #include "framebuffer.hpp"
 
-Framebuffer::Framebuffer( int w, int h ) {
+slop::Framebuffer::Framebuffer( int w, int h ) {
     std::string vert = "#version 130\nattribute vec2 position;\nattribute vec2 uv;\nvarying vec2 uvCoord;\nvoid main()\n{\nuvCoord = uv;\ngl_Position = vec4(position,0,1);\n}\n";
     std::string frag = "#version 130\nuniform sampler2D texture;\nvarying vec2 uvCoord;\nout vec4 outColor;void main()\n{\noutColor = texture2D( texture, uvCoord );\n}\n";
     shader = new Shader( vert, frag, false );
     vertCount = verts.size();
 }
 
-void Framebuffer::setShader( std::string name ) {
+void slop::Framebuffer::setShader( std::string name ) {
     delete shader;
     shader = new Shader( name + ".vert", name + ".frag" );
 }
 
-Framebuffer::~Framebuffer() {
+slop::Framebuffer::~Framebuffer() {
     glDeleteTextures(1, &image);
     glDeleteFramebuffers(1,&fbuffer);
     glDeleteBuffers(2,buffers);
     delete shader;
 }
 
-void Framebuffer::resize( int w, int h ) {
+void slop::Framebuffer::resize( int w, int h ) {
     // Regenerate the image
     glDeleteTextures(1, &image);
     glBindTexture(GL_TEXTURE_2D, image);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-void Framebuffer::bind() {
+void slop::Framebuffer::bind() {
     glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
 }
 
-void Framebuffer::unbind() {
+void slop::Framebuffer::unbind() {
     glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
-void Framebuffer::draw(){
+void slop::Framebuffer::draw(){
     shader->bind();
     shader->setParameter( "texture", 0 );
     shader->setAttribute( "position", buffers[0], 2 );

src/framebuffer.hpp

 
 #include "shader.hpp"
 
+namespace slop {
+
 class Framebuffer {
 private:
     unsigned int fbuffer;
     void unbind();
 };
 
+}
+
 #endif

src/glrectangle.cpp

 #include "glrectangle.hpp"
 
-GLRectangle::GLRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
+slop::GLRectangle::GLRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
     this->color = color;
     this->border = border;
     this->padding = padding;
     shader = new Shader( vert, frag, false );
 }
 
-void GLRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+void slop::GLRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
     // Find each corner of the rectangle
     ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
     bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
     generateBuffers();
 }
 
-void GLRectangle::generateBuffers() {
+void slop::GLRectangle::generateBuffers() {
     std::vector<glm::vec2> rectangle_verts;
     std::vector<glm::vec2> rectangle_uvs;
     std::vector<glm::vec2> corner_verts;
     center_vertCount = center_verts.size();
 }
 
-GLRectangle::~GLRectangle() {
+slop::GLRectangle::~GLRectangle() {
     delete shader;
     glDeleteBuffers( 6, (GLuint*)&buffer );
 }
 
-void GLRectangle::draw( glm::mat4& matrix ) {
+void slop::GLRectangle::draw( glm::mat4& matrix ) {
     glEnable( GL_BLEND );
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     shader->bind();
     glDisable( GL_BLEND );
 }
 
-glm::vec4 GLRectangle::getRect() {
+glm::vec4 slop::GLRectangle::getRect() {
     return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
 }

src/glrectangle.hpp

 #include "shader.hpp"
 #include "rectangle.hpp"
 
+namespace slop {
+
 struct RectangleBuffer {
     unsigned int corner_verts;
     unsigned int corner_uvs;
     void draw(glm::mat4& matrix);
 };
 
+}
+
 #endif // N_RECTANGLE_H_

src/keyboard.cpp

 #include "keyboard.hpp"
 
-bool Keyboard::getKey( KeySym key ) {
+bool slop::Keyboard::getKey( KeySym key ) {
     KeyCode keycode = XKeysymToKeycode( x11->display, key );
     if ( keycode != 0 ) {
         // Get the whole keyboard state
     }
 }
 
-bool Keyboard::anyKeyDown() {
+bool slop::Keyboard::anyKeyDown() {
     return keyDown;
 }
 
-void Keyboard::update() {
+void slop::Keyboard::update() {
     char keys[32];
     XQueryKeymap( x11->display, keys );
     keyDown = false;
     }
 }
 
-Keyboard::Keyboard( X11* x11 ) {
+slop::Keyboard::Keyboard( X11* x11 ) {
     this->x11 = x11;
     int err = XGrabKeyboard( x11->display, x11->root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
     if ( err != GrabSuccess ) {
     keyDown = false;
 }
 
-Keyboard::~Keyboard() {
+slop::Keyboard::~Keyboard() {
     XUngrabKeyboard( x11->display, CurrentTime );
 }

src/keyboard.hpp

 
 #include "x.hpp"
 
+namespace slop {
+
 class Keyboard {
 private:
     char deltaState[32];
 
 extern Keyboard* keyboard;
 
+}
+
 #endif // N_KEYBOARD_H_

src/main.cpp

 #include "slop.hpp"
 #include "options.hpp"
 
+using namespace slop;
+
 SlopOptions* getOptions( Options& options ) {
     SlopOptions* foo = new SlopOptions();
     options.getFloat("bordersize", 'b', foo->borderSize);

src/mouse.cpp

 #include "mouse.hpp"
 
-void Mouse::setButton( int button, int state ) {
+void slop::Mouse::setButton( int button, int state ) {
     for (unsigned int i=0;i<buttons.size();i++ ) {
         if ( buttons[i].x == button ) {
             buttons[i].y = state;
     buttons.push_back(glm::ivec2(button,state));
 }
 
-int Mouse::getButton( int button ) {
+int slop::Mouse::getButton( int button ) {
     for (unsigned int i=0;i<buttons.size();i++ ) {
         if ( buttons[i].x == button ) {
             return buttons[i].y;
     return 0;
 }
 
-glm::vec2 Mouse::getMousePos() {
+glm::vec2 slop::Mouse::getMousePos() {
     Window root, child;
     int mx, my;
     int wx, wy;
     return glm::vec2( mx, my );
 }
 
-void Mouse::setCursor( int cursor ) {
+void slop::Mouse::setCursor( int cursor ) {
     if ( currentCursor == cursor ) {
         return;
     }
                               xcursor, CurrentTime );
 }
 
-Mouse::Mouse(X11* x11, int nodecorations, Window ignoreWindow ) {
+slop::Mouse::Mouse(X11* x11, int nodecorations, Window ignoreWindow ) {
     this->x11 = x11;
     currentCursor = XC_cross;
     xcursor = XCreateFontCursor( x11->display, XC_cross );
     hoverWindow = findWindow(x11->root);
 }
 
-Mouse::~Mouse() {
+slop::Mouse::~Mouse() {
 	XUngrabPointer( x11->display, CurrentTime );
 }
 
-void Mouse::update() {
+void slop::Mouse::update() {
     XEvent event;
     while ( XCheckTypedEvent( x11->display, ButtonPress, &event ) ) {
 		setButton( event.xbutton.button, 1 );
 	}
 }
 
-Window Mouse::findWindow( Window foo ) {
+Window slop::Mouse::findWindow( Window foo ) {
     glm::vec2 pos = getMousePos();
     Window root, parent;
     Window* children;

src/mouse.hpp

 #include <iostream>
 
 #include "x.hpp"
-#include "windowhelper.hpp"
+
+namespace slop {
 
 class Mouse {
 private:
 
 extern Mouse* mouse;
 
+}
+
 #endif // N_MOUSE_H_

src/rectangle.cpp

 #include "rectangle.hpp"
 
-Rectangle::Rectangle() {
+slop::Rectangle::Rectangle() {
 }
-Rectangle::~Rectangle() {
+slop::Rectangle::~Rectangle() {
 }
-void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+void slop::Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
 }
-void Rectangle::draw(glm::mat4& matrix) {
+void slop::Rectangle::draw(glm::mat4& matrix) {
 }
-glm::vec4 Rectangle::getRect() {
+glm::vec4 slop::Rectangle::getRect() {
     return glm::vec4();
 }

src/rectangle.hpp

 
 #include <glm/glm.hpp>
 
+namespace slop {
+
 class Rectangle {
 public:
     Rectangle();
     virtual void draw(glm::mat4& matrix);
 };
 
+}
+
 #endif // N_RECTANGLE_H_

src/resource.cpp

 
 #include "resource.hpp"
 
-Resource::Resource() {
+slop::Resource::Resource() {
     // Find the configuration directory.
     // usually ~/.config/slop and /usr/share/slop
     char* config = getenv( "XDG_CONFIG_HOME" );
     usrconfig += "/slop/";
 }
 
-std::string Resource::getRealPath( std::string localpath ) {
+std::string slop::Resource::getRealPath( std::string localpath ) {
     if ( validatePath( usrconfig + localpath ) ) {
         return usrconfig + localpath;
     }
     return localpath;
 }
 
-bool Resource::validatePath( std::string path ) {
+bool slop::Resource::validatePath( std::string path ) {
     struct stat st;
     const char* dirname = path.c_str();
     if ( stat( dirname, &st ) != 0 ) {

src/resource.hpp

 #include <sys/stat.h>
 #include <pwd.h>
 
+namespace slop {
+
 class Resource {
 public:
     Resource();
 
 extern Resource* resource;
 
+}
+
 #endif // IS_RESOURCE_H_

src/shader.cpp

 #include "shader.hpp"
 
-Shader::Shader( std::string vert, std::string frag, bool file ) {
+slop::Shader::Shader( std::string vert, std::string frag, bool file ) {
     std::string vert_contents;
     std::string frag_contents;
     if ( file ) {
     glUseProgram( 0 );
 }
 
-Shader::~Shader() {
+slop::Shader::~Shader() {
     glDeleteProgram( program );
 }
 
-unsigned int Shader::getProgram() {
+unsigned int slop::Shader::getProgram() {
     return program;
 }
 
-void Shader::bind() {
+void slop::Shader::bind() {
     glUseProgram( program );
 }
 
-int Shader::compile( unsigned int shader, std::string& error ) {
+int slop::Shader::compile( unsigned int shader, std::string& error ) {
     glCompileShader( shader );
 
     // Compiling the shader is the easy part, all this junk down here is for printing the error it might generate.
     return 0;
 }
 
-int Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) {
+int slop::Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) {
     glAttachShader( program, vertshader );
     glAttachShader( program, fragshader );
     glLinkProgram( program );
     return 0;
 }
 
-unsigned int Shader::getUniformLocation( std::string name ) {
+unsigned int slop::Shader::getUniformLocation( std::string name ) {
     glUseProgram( program );
     return glGetUniformLocation( program, name.c_str() );
 }
 
-void Shader::setParameter( std::string name, int foo ) {
+void slop::Shader::setParameter( std::string name, int foo ) {
     glUniform1i( getUniformLocation( name ), foo );
 }
 
-void Shader::setParameter( std::string name, float foo ) {
+void slop::Shader::setParameter( std::string name, float foo ) {
     glUniform1f( getUniformLocation( name ), foo );
 }
 
-void Shader::setParameter( std::string name, glm::mat4& foo ) {
+void slop::Shader::setParameter( std::string name, glm::mat4& foo ) {
     glUniformMatrix4fv( getUniformLocation( name ), 1, GL_FALSE, glm::value_ptr( foo ) );
 }
 
-void Shader::setParameter( std::string name, glm::vec4 foo ) {
+void slop::Shader::setParameter( std::string name, glm::vec4 foo ) {
     glUniform4f( getUniformLocation( name ), foo.x, foo.y, foo.z, foo.w );
 }
 
-void Shader::setParameter( std::string name, glm::vec2 foo ) {
+void slop::Shader::setParameter( std::string name, glm::vec2 foo ) {
     glUniform2f( getUniformLocation( name ), foo.x, foo.y );
 }
 
-void Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
+void slop::Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
     unsigned int a = glGetAttribLocation( program, name.c_str() );
     glEnableVertexAttribArray( a );
     glBindBuffer( GL_ARRAY_BUFFER, buffer );
     activeAttributes.push_back( a );
 }
 
-void Shader::unbind() {
+void slop::Shader::unbind() {
     for ( unsigned int i=0; i<activeAttributes.size(); i++ ) {
         glDisableVertexAttribArray( activeAttributes[i] );
     }

src/shader.hpp

 
 #include "resource.hpp"
 
+namespace slop {
+
 class Shader {
 public:
     Shader( std::string vert, std::string frag, bool file = true );
     unsigned int                program;
 };
 
+}
+
 #endif // N_SHADER_H_

src/slop.cpp

 #include "xshaperectangle.hpp"
 #include "slop.hpp"
 
+namespace slop {
+
 X11* x11;
 Mouse* mouse;
 Keyboard* keyboard;
 Resource* resource;
 
+SlopSelection GLSlopSelect( slop::SlopOptions* options, bool* cancelled, slop::SlopWindow* window );
+SlopSelection XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled);
+
+}
+
+using namespace slop;
+
 // Defaults!
-SlopOptions::SlopOptions() {
+slop::SlopOptions::SlopOptions() {
     borderSize = 1;
     nokeyboard = false;
     nodecorations = false;
     a = 1;
 }
 
-SlopSelection::SlopSelection( float x, float y, float w, float h, int id ) {
+slop::SlopSelection::SlopSelection( float x, float y, float w, float h, int id ) {
     this->x = x;
     this->y = y;
     this->w = w;
     this->id = id;
 }
 
-SlopSelection GLSlopSelect( SlopOptions* options, bool* cancelled, SlopWindow* window );
-SlopSelection XShapeSlopSelect( SlopOptions* options, bool* cancelled);
-
-SlopSelection SlopSelect( SlopOptions* options, bool* cancelled, bool quiet) {
-    SlopSelection returnval(0,0,0,0,0);
+slop::SlopSelection slop::SlopSelect( slop::SlopOptions* options, bool* cancelled, bool quiet) {
+    slop::SlopSelection returnval(0,0,0,0,0);
     bool deleteOptions = false;
     if ( !options ) {
         deleteOptions = true;
-        options = new SlopOptions();
+        options = new slop::SlopOptions();
     }
     resource = new Resource();
     // Set up x11 temporarily
                 std::cerr << errorstring;
             }
         }
-        returnval = XShapeSlopSelect( options, cancelled );
+        returnval = slop::XShapeSlopSelect( options, cancelled );
     } else {
-        returnval = GLSlopSelect( options, cancelled, window );
+        returnval = slop::GLSlopSelect( options, cancelled, window );
     }
     delete x11;
-    delete resource;
+    delete slop::resource;
     if ( deleteOptions ) {
         delete options;
     }
     return returnval;
 }
 
-SlopSelection XShapeSlopSelect( SlopOptions* options, bool* cancelled ) {
+slop::SlopSelection slop::XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled ) {
     // Init our little state machine, memory is a tad of a misnomer
-    SlopMemory memory( options, new XShapeRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
-    mouse = new Mouse( x11, options->nodecorations, ((XShapeRectangle*)memory.rectangle)->window );
+    slop::SlopMemory memory( options, new XShapeRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
+    slop::mouse = new slop::Mouse( x11, options->nodecorations, ((XShapeRectangle*)memory.rectangle)->window );
 
     // We have no GL context, so the matrix is useless...
     glm::mat4 fake;
     // This is where we'll run through all of our stuffs
     while( memory.running ) {
-        mouse->update();
-        keyboard->update();
+        slop::mouse->update();
+        slop::keyboard->update();
         // We move our statemachine forward.
         memory.update( 1 );
 
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
         // Then we draw the framebuffer to the screen
-        if ( (keyboard->anyKeyDown() && !options->nokeyboard) || mouse->getButton( 3 ) ) {
+        if ( (slop::keyboard->anyKeyDown() && !options->nokeyboard) || slop::mouse->getButton( 3 ) ) {
             memory.running = false;
             if ( cancelled ) {
                 *cancelled = true;
     // Lets now clear both front and back buffers before closing.
     // hopefully it'll be completely transparent while closing!
     // Then we clean up.
-    delete mouse;
+    delete slop::mouse;
     // Finally return the data.
-    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+    return slop::SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
 }
 
-SlopSelection GLSlopSelect( SlopOptions* options, bool* cancelled, SlopWindow* window ) {
-    mouse = new Mouse( x11, options->nodecorations, window->window );
+slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, bool* cancelled, SlopWindow* window ) {
+    slop::mouse = new slop::Mouse( x11, options->nodecorations, window->window );
 
     if ( options->shader != "textured" ) {
         window->framebuffer->setShader( options->shader );
     }
 
     // Init our little state machine, memory is a tad of a misnomer
-    SlopMemory memory( options, new GLRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
+    slop::SlopMemory memory( options, new GLRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
 
     // This is where we'll run through all of our stuffs
     while( memory.running ) {
-        mouse->update();
-        keyboard->update();
+        slop::mouse->update();
+        slop::keyboard->update();
         // We move our statemachine forward.
         memory.update( 1 );
 
         if ( err != GL_NO_ERROR ) {
             throw err;
         }
-        if ( (keyboard->anyKeyDown() && !options->nokeyboard) || mouse->getButton( 3 ) ) {
+        if ( (slop::keyboard->anyKeyDown() && !options->nokeyboard) || slop::mouse->getButton( 3 ) ) {
             memory.running = false;
             if ( cancelled ) {
                 *cancelled = true;
     window->display();
     // Then we clean up.
     delete window;
-    delete mouse;
+    delete slop::mouse;
     // Finally return the data.
-    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+    return slop::SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
 }

src/slop.hpp

 
 #include <string>
 
+namespace slop {
+
 class SlopOptions {
 public:
     SlopOptions();
 
 SlopSelection SlopSelect( SlopOptions* options = NULL, bool* cancelled = NULL, bool quiet = false );
 
+}
+
 #endif // N_SLOP_H_

src/slopstates.cpp

 #include "slopstates.hpp"
 
-SlopMemory::SlopMemory( SlopOptions* options, Rectangle* rect ) {
+using namespace slop;
+
+slop::SlopMemory::SlopMemory( SlopOptions* options, Rectangle* rect ) {
     running = true;
     state = (SlopState*)new SlopStart();
     nextState = NULL;
     state->onEnter( *this );
 }
 
-SlopMemory::~SlopMemory() {
+slop::SlopMemory::~SlopMemory() {
     delete state;
     if ( nextState ) {
         delete nextState;
     delete rectangle;
 }
 
-void SlopMemory::update( double dt ) {
+void slop::SlopMemory::update( double dt ) {
     state->update( *this, dt );
     if ( nextState ) {
         state->onExit( *this );
     }
 }
 
-void SlopMemory::setState( SlopState* state ) {
+void slop::SlopMemory::setState( SlopState* state ) {
     if ( nextState ) {
         delete nextState;
     }
     nextState = state;
 }
 
-void SlopMemory::draw( glm::mat4& matrix ) {
+void slop::SlopMemory::draw( glm::mat4& matrix ) {
     state->draw( *this, matrix );
 }
 
 
-SlopState::~SlopState() {
+slop::SlopState::~SlopState() {
 }
-void SlopState::onEnter( SlopMemory& memory ) {
+void slop::SlopState::onEnter( SlopMemory& memory ) {
 }
-void SlopState::onExit( SlopMemory& memory ) {
+void slop::SlopState::onExit( SlopMemory& memory ) {
 }
-void SlopState::update( SlopMemory& memory, double dt ) {
+void slop::SlopState::update( SlopMemory& memory, double dt ) {
 }
-void SlopState::draw( SlopMemory& memory, glm::mat4 matrix ) {
+void slop::SlopState::draw( SlopMemory& memory, glm::mat4 matrix ) {
 }
 
-void SlopStart::onEnter( SlopMemory& memory ) {
+void slop::SlopStart::onEnter( SlopMemory& memory ) {
     setStartPos = false;
 }
-void SlopStart::update( SlopMemory& memory, double dt ) {
+void slop::SlopStart::update( SlopMemory& memory, double dt ) {
     if ( mouse->getButton( 1 ) && !setStartPos ) {
         startPos = mouse->getMousePos();
         setStartPos = true;
     }
 }
 
-void SlopStart::draw( SlopMemory& memory, glm::mat4 matrix ) {
+void slop::SlopStart::draw( SlopMemory& memory, glm::mat4 matrix ) {
     if ( memory.tolerance > 0 ) {
         memory.rectangle->draw( matrix );
     }
 }
 
-SlopStartDrag::SlopStartDrag( glm::vec2 point ) {
+slop::SlopStartDrag::SlopStartDrag( glm::vec2 point ) {
     startPoint = point;
 }
 
-void SlopStartDrag::onEnter( SlopMemory& memory ) {
+void slop::SlopStartDrag::onEnter( SlopMemory& memory ) {
     memory.rectangle->setPoints(startPoint, startPoint);
 }
 
-void SlopStartDrag::update( SlopMemory& memory, double dt ) {
+void slop::SlopStartDrag::update( SlopMemory& memory, double dt ) {
     char a = startPoint.y > mouse->getMousePos().y;
     char b = startPoint.x > mouse->getMousePos().x;
     char c = (a << 1) | b;
     }
 }
 
-void SlopStartDrag::draw( SlopMemory& memory, glm::mat4 matrix ) {
+void slop::SlopStartDrag::draw( SlopMemory& memory, glm::mat4 matrix ) {
     memory.rectangle->draw( matrix );
 }
 
-void SlopEndDrag::onEnter( SlopMemory& memory ) {
+void slop::SlopEndDrag::onEnter( SlopMemory& memory ) {
     memory.running = false;
 }

src/slopstates.hpp

 #define N_SLOPSTATES_H_
 
 #include "mouse.hpp"
-#include "windowhelper.hpp"
 #include "slop.hpp"
 
-#ifdef SLOP_LEGACY_MODE
-#include "xshaperectangle.hpp"
-#else
 #include "rectangle.hpp"
-#endif
+
+namespace slop {
 
 class SlopMemory;
 class SlopOptions;
     void draw( glm::mat4& matrix );
 };
 
+}
+
 #endif // N_SLOPSTATES_H_

src/window.cpp

 #include "window.hpp"
 
-SlopWindow::SlopWindow() {
+using namespace slop;
+
+slop::SlopWindow::SlopWindow() {
     XVisualInfo visual;
     XMatchVisualInfo(x11->display, DefaultScreen(x11->display), 32, TrueColor, &visual);
 
 
 
     // Create the window
-    window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
+    window = XCreateWindow( slop::x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
                             0, visual.depth, InputOutput,
                             visual.visual, valueMask, &attributes );
 
 	XMapWindow( x11->display, window );
 }
 
-SlopWindow::~SlopWindow() {
+slop::SlopWindow::~SlopWindow() {
     delete framebuffer;
     // Try to erase the window before destroying it.
     glClearColor( 0, 0, 0, 0 );
     XDestroyWindow( x11->display, window );
 }
 
-void SlopWindow::display() {
+void slop::SlopWindow::display() {
     glXSwapBuffers( x11->display, window );
     glXWaitGL();
 }
 
-void SlopWindow::setCurrent() {
+void slop::SlopWindow::setCurrent() {
     glXMakeCurrent( x11->display, window, context ) ;
 }

src/window.hpp

 #include "x.hpp"
 #include "framebuffer.hpp"
 
-// Gotta name it SlopWindow since Window and GLXWindow are taken... :/
+namespace slop {
+
 class SlopWindow {
 public:
     Framebuffer* framebuffer;
     void display();
 };
 
+}
+
 #endif // N_WINDOW_H_

src/windowhelper.cpp

-#include "windowhelper.hpp"
-
-glm::vec4 getWindowGeometry( Window win, bool removeDecoration) {
-    XWindowAttributes attr;         
-    XGetWindowAttributes( x11->display, win, &attr );
-    unsigned int width = attr.width;           
-    unsigned int height = attr.height;         
-    unsigned int border = attr.border_width;   
-    int x, y;
-    Window junk;
-    XTranslateCoordinates( x11->display, win, attr.root, -attr.border_width, -attr.border_width, &x, &y, &junk );
-    if ( !removeDecoration ) {
-        width += border*2;
-        height += border*2;
-        return glm::vec4( x, y, width, height );
-    }
-    // This is required to be defined by the window manager, so we can assume it exists.
-    Atom actual_type;
-    int actual_format;
-    unsigned long nitems, bytes_after;
-    unsigned char *data;
-    int result = XGetWindowProperty(x11->display, win,
-                                    XInternAtom(x11->display, "_NET_FRAME_EXTENTS", true),
-                                    0, 4, False, AnyPropertyType, 
-                                    &actual_type, &actual_format, &nitems, &bytes_after, &data);
-    if ( result == Success ) {
-        // Make sure we got the data we expect...
-        if ((nitems == 4) && (bytes_after == 0)) {
-            x += (int)data[0];
-            width -= (int)data[1];
-            y += (int)data[2];
-            height -= (int)data[3];
-        }
-    }
-    return glm::vec4( x, y, width, height );
-}

src/windowhelper.hpp

-/* windowhelper.hpp: Analyzes input windows to determine decorations and such.
- *
- * 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 N_WINDOWHELPER_H_
-#define N_WINDOWHELPER_H_
-
-#include <glm/glm.hpp>
-#include <X11/Xlib.h>
-
-#include "x.hpp"
-
-glm::vec4 getWindowGeometry( Window win, bool removeDecoration );
-
-#endif

src/x.cpp

 #include "x.hpp"
 
+using namespace slop;
+
+glm::vec4 slop::getWindowGeometry( Window win, bool removeDecoration) {
+    XWindowAttributes attr;         
+    XGetWindowAttributes( x11->display, win, &attr );
+    unsigned int width = attr.width;           
+    unsigned int height = attr.height;         
+    unsigned int border = attr.border_width;   
+    int x, y;
+    Window junk;
+    XTranslateCoordinates( x11->display, win, attr.root, -attr.border_width, -attr.border_width, &x, &y, &junk );
+    if ( !removeDecoration ) {
+        width += border*2;
+        height += border*2;
+        return glm::vec4( x, y, width, height );
+    }
+    // This is required to be defined by the window manager, so we can assume it exists.
+    Atom actual_type;
+    int actual_format;
+    unsigned long nitems, bytes_after;
+    unsigned char *data;
+    int result = XGetWindowProperty(x11->display, win,
+                                    XInternAtom(x11->display, "_NET_FRAME_EXTENTS", true),
+                                    0, 4, False, AnyPropertyType, 
+                                    &actual_type, &actual_format, &nitems, &bytes_after, &data);
+    if ( result == Success ) {
+        // Make sure we got the data we expect...
+        if ((nitems == 4) && (bytes_after == 0)) {
+            x += (int)data[0];
+            width -= (int)data[1];
+            y += (int)data[2];
+            height -= (int)data[3];
+        }
+    }
+    return glm::vec4( x, y, width, height );
+}
+
 bool X11::hasCompositor() {
     std::stringstream prop_name;
     prop_name << "_NET_WM_CM_S" << XScreenNumberOfScreen( screen );

src/x.hpp

 #include <sstream>
 #include <stdexcept>
 #include <X11/Xatom.h>
+#include <glm/glm.hpp>
+
+namespace slop {
+
+glm::vec4 getWindowGeometry( Window win, bool removeDecoration );
 
 class X11 {
 public:
 
 extern X11* x11;
 
+}
+
 #endif

src/xshaperectangle.cpp

 #include "xshaperectangle.hpp"
 
-XShapeRectangle::XShapeRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
+slop::XShapeRectangle::XShapeRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
     this->color = convertColor( color );
     this->border = border;
     this->padding = padding;
     createdWindow = false;
 }
 
-void XShapeRectangle::createWindow() {
+void slop::XShapeRectangle::createWindow() {
     if ( createdWindow ) {
         return;
     }
     createdWindow = true;
 }
 
-void XShapeRectangle::generateHoles() {
+void slop::XShapeRectangle::generateHoles() {
     if ( !highlight ) {
         XRectangle rects[4];
         // Left
     XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
 }
 
-void XShapeRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+void slop::XShapeRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
     // Find each corner of the rectangle
     ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
     bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
     generateHoles();
 }
 
-XShapeRectangle::~XShapeRectangle() {
+slop::XShapeRectangle::~XShapeRectangle() {
 }
 
-void XShapeRectangle::draw( glm::mat4& matrix ) {
+void slop::XShapeRectangle::draw( glm::mat4& matrix ) {
     // We don't want to be visible until we're asked to draw.
     createWindow();
 }
 
-glm::vec4 XShapeRectangle::getRect() {
+glm::vec4 slop::XShapeRectangle::getRect() {
     return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
 }
 
-XColor XShapeRectangle::convertColor( glm::vec4 color ) {
+XColor slop::XShapeRectangle::convertColor( glm::vec4 color ) {
     // Convert float colors to shorts.
     short red   = short( floor( color.r * 65535.f ) );
     short green = short( floor( color.g * 65535.f ) );

src/xshaperectangle.hpp

 #include "x.hpp"
 #include "rectangle.hpp"
 
+namespace slop {
+
 class XShapeRectangle : public Rectangle {
 private:
     glm::vec2 ul, oul;
     void draw(glm::mat4& matrix);
 };
 
+}
+
 #endif // N_XSHAPERECTANGLE_H_