123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284
  1. #include <chrono>
  2. #include <thread>
  3. #include <stdlib.h>
  4. #include "slopstates.hpp"
  5. #include "mouse.hpp"
  6. #include "resource.hpp"
  7. #include "keyboard.hpp"
  8. #include "window.hpp"
  9. #include "shader.hpp"
  10. #include "framebuffer.hpp"
  11. #include "glrectangle.hpp"
  12. #include "xshaperectangle.hpp"
  13. #include "slop.hpp"
  14. namespace slop {
  15. X11* x11;
  16. Mouse* mouse;
  17. Keyboard* keyboard;
  18. Resource* resource;
  19. SlopSelection GLSlopSelect( slop::SlopOptions* options, bool* cancelled, slop::SlopWindow* window );
  20. SlopSelection XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled);
  21. static int TmpXError(Display * d, XErrorEvent * ev) {
  22. return 0;
  23. }
  24. }
  25. using namespace slop;
  26. // Defaults!
  27. slop::SlopOptions::SlopOptions() {
  28. borderSize = 1;
  29. nokeyboard = false;
  30. noopengl = false;
  31. nodecorations = false;
  32. tolerance = 2;
  33. padding = 0;
  34. shaders.push_back("textured");
  35. highlight = false;
  36. r = 0.5;
  37. g = 0.5;
  38. b = 0.5;
  39. a = 1;
  40. char * envdisplay = getenv("DISPLAY");
  41. if (envdisplay == NULL)
  42. xdisplay = ":0";
  43. else
  44. xdisplay = envdisplay;
  45. }
  46. slop::SlopSelection::SlopSelection( float x, float y, float w, float h, int id ) {
  47. this->x = x;
  48. this->y = y;
  49. this->w = w;
  50. this->h = h;
  51. this->id = id;
  52. }
  53. slop::SlopSelection slop::SlopSelect( slop::SlopOptions* options, bool* cancelled, bool quiet) {
  54. slop::SlopSelection returnval(0,0,0,0,0);
  55. bool deleteOptions = false;
  56. if ( !options ) {
  57. deleteOptions = true;
  58. options = new slop::SlopOptions();
  59. }
  60. resource = new Resource();
  61. // Set up x11 temporarily
  62. x11 = new X11(options->xdisplay);
  63. if ( !options->nokeyboard ) {
  64. XErrorHandler ph = XSetErrorHandler(slop::TmpXError);
  65. keyboard = new Keyboard( x11 );
  66. XSetErrorHandler(ph);
  67. }
  68. bool success = false;
  69. std::string errorstring = "";
  70. SlopWindow* window;
  71. // First we check if we have a compositor available
  72. if ( x11->hasCompositor() && !options->noopengl ) {
  73. // If we have a compositor, we try using OpenGL
  74. try {
  75. window = new SlopWindow();
  76. success = true;
  77. } catch( std::exception* e ) {
  78. errorstring += std::string(e->what()) + "\n";
  79. success = false;
  80. } catch (...) {
  81. success = false;
  82. }
  83. } else {
  84. errorstring += "Failed to detect a compositor, OpenGL hardware-accelleration disabled...\n";
  85. }
  86. if ( !success ) {
  87. // If we fail, we launch the XShape version of slop.
  88. if ( !quiet && !options->noopengl ) {
  89. if ( errorstring.length() <= 0 ) {
  90. errorstring += "Failed to launch OpenGL context, --shader parameter will be ignored.\n";
  91. std::cerr << errorstring;
  92. } else {
  93. std::cerr << errorstring;
  94. }
  95. }
  96. returnval = slop::XShapeSlopSelect( options, cancelled );
  97. } else {
  98. returnval = slop::GLSlopSelect( options, cancelled, window );
  99. }
  100. delete x11;
  101. delete slop::resource;
  102. if ( deleteOptions ) {
  103. delete options;
  104. }
  105. return returnval;
  106. }
  107. slop::SlopSelection slop::XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled ) {
  108. // Init our little state machine, memory is a tad of a misnomer
  109. 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) );
  110. slop::mouse = new slop::Mouse( x11, options->nodecorations, ((XShapeRectangle*)memory.rectangle)->window );
  111. // We have no GL context, so the matrix is useless...
  112. glm::mat4 fake;
  113. // This is where we'll run through all of our stuffs
  114. while( memory.running ) {
  115. slop::mouse->update();
  116. if ( !options->nokeyboard ) {
  117. slop::keyboard->update();
  118. }
  119. // We move our statemachine forward.
  120. memory.update( 1 );
  121. // We don't actually draw anything, but the state machine uses
  122. // this to know when to spawn the window.
  123. memory.draw( fake );
  124. // X11 explodes if we update as fast as possible, here's a tiny sleep.
  125. XFlush(x11->display);
  126. std::this_thread::sleep_for(std::chrono::milliseconds(10));
  127. // Then we draw the framebuffer to the screen
  128. if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) {
  129. memory.running = false;
  130. if ( cancelled ) {
  131. *cancelled = true;
  132. }
  133. } else {
  134. *cancelled = false;
  135. }
  136. }
  137. // Now we should have a selection! We parse everything we know about it here.
  138. glm::vec4 output = memory.rectangle->getRect();
  139. // Lets now clear both front and back buffers before closing.
  140. // hopefully it'll be completely transparent while closing!
  141. // Then we clean up.
  142. delete slop::mouse;
  143. // Finally return the data.
  144. return slop::SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
  145. }
  146. slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, bool* cancelled, SlopWindow* window ) {
  147. slop::mouse = new slop::Mouse( x11, options->nodecorations, window->window );
  148. 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";
  149. std::string frag = "#version 130\n uniform sampler2D texture;\n varying vec2 uvCoord;\n out vec4 outColor;\n void main()\n {\n outColor = texture2D( texture, uvCoord );\n }\n";
  150. slop::Shader* textured = new slop::Shader( vert, frag, false );
  151. std::vector<slop::Shader*> shaders;
  152. for( int i=0;i<options->shaders.size();i++ ) {
  153. std::string sn = options->shaders[i];
  154. if ( sn != "textured" ) {
  155. shaders.push_back( new slop::Shader( sn + ".vert", sn + ".frag" ) );
  156. } else {
  157. shaders.push_back( textured );
  158. }
  159. }
  160. // Init our little state machine, memory is a tad of a misnomer
  161. 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) );
  162. slop::Framebuffer* pingpong;
  163. if ( shaders.size() > 1 ) {
  164. pingpong = new slop::Framebuffer(WidthOfScreen(x11->screen), HeightOfScreen(x11->screen));
  165. }
  166. // This is where we'll run through all of our stuffs
  167. auto start = std::chrono::high_resolution_clock::now();
  168. while( memory.running ) {
  169. slop::mouse->update();
  170. if ( !options->nokeyboard ) {
  171. slop::keyboard->update();
  172. }
  173. // We move our statemachine forward.
  174. memory.update( 1 );
  175. // Then we draw our junk to a framebuffer.
  176. window->framebuffer->setShader( textured );
  177. window->framebuffer->bind();
  178. glClearColor (0.0, 0.0, 0.0, 0.0);
  179. glClear (GL_COLOR_BUFFER_BIT);
  180. memory.draw( window->camera );
  181. window->framebuffer->unbind();
  182. auto end = std::chrono::high_resolution_clock::now();
  183. std::chrono::duration<double, std::milli> elapsed = end-start;
  184. if ( shaders.size() > 1 ) {
  185. int i;
  186. // We have our clean buffer, now to slather it with some juicy shader chains.
  187. for (i=0;i<=(int)shaders.size()-2;i+=2) {
  188. pingpong->bind();
  189. glClearColor (0.0, 0.0, 0.0, 0.0);
  190. glClear (GL_COLOR_BUFFER_BIT);
  191. window->framebuffer->setShader( shaders[i] );
  192. window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
  193. pingpong->unbind();
  194. window->framebuffer->bind();
  195. glClearColor (0.0, 0.0, 0.0, 0.0);
  196. glClear (GL_COLOR_BUFFER_BIT);
  197. pingpong->setShader( shaders[i+1] );
  198. pingpong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
  199. window->framebuffer->unbind();
  200. }
  201. for (;i<shaders.size();i++) {
  202. pingpong->bind();
  203. glClearColor (0.0, 0.0, 0.0, 0.0);
  204. glClear (GL_COLOR_BUFFER_BIT);
  205. window->framebuffer->setShader( shaders[i] );
  206. window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
  207. pingpong->unbind();
  208. }
  209. if ( i%2 != 0 ) {
  210. window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
  211. } else {
  212. pingpong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
  213. }
  214. } else {
  215. window->framebuffer->setShader( shaders[0] );
  216. window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
  217. }
  218. window->display();
  219. GLenum err = glGetError();
  220. if ( err != GL_NO_ERROR ) {
  221. std::string error;
  222. switch(err) {
  223. case GL_INVALID_OPERATION: error="INVALID_OPERATION"; break;
  224. case GL_INVALID_ENUM: error="INVALID_ENUM"; break;
  225. case GL_INVALID_VALUE: error="INVALID_VALUE"; break;
  226. case GL_OUT_OF_MEMORY: error="OUT_OF_MEMORY"; break;
  227. case GL_INVALID_FRAMEBUFFER_OPERATION: error="INVALID_FRAMEBUFFER_OPERATION"; break;
  228. }
  229. throw new std::runtime_error( "OpenGL threw an error: " + error );
  230. }
  231. if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) {
  232. memory.running = false;
  233. if ( cancelled ) {
  234. *cancelled = true;
  235. }
  236. } else {
  237. *cancelled = false;
  238. }
  239. }
  240. // Now we should have a selection! We parse everything we know about it here.
  241. glm::vec4 output = memory.rectangle->getRect();
  242. // Lets now clear both front and back buffers before closing.
  243. // hopefully it'll be completely transparent while closing!
  244. glClearColor (0.0, 0.0, 0.0, 0.0);
  245. glClear (GL_COLOR_BUFFER_BIT);
  246. window->display();
  247. glClear (GL_COLOR_BUFFER_BIT);
  248. window->display();
  249. // Then we clean up.
  250. delete window;
  251. delete slop::mouse;
  252. // Finally return the data.
  253. return slop::SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
  254. }