x.cpp 13KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393
  1. /* x.cpp: Handles starting and managing X.
  2. *
  3. * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  4. *
  5. * This file is part of Slop.
  6. *
  7. * Slop is free software: you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation, either version 3 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * Slop is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with Slop. If not, see <http://www.gnu.org/licenses/>.
  19. */
  20. #include "x.hpp"
  21. slop::XEngine* xengine = new slop::XEngine();
  22. int slop::XEngineErrorHandler( Display* dpy, XErrorEvent* event ) {
  23. // Ignore XGrabKeyboard BadAccess errors, we can work without it.
  24. // 31 = XGrabKeyboard's request code
  25. if ( event->request_code == 31 && event->error_code == BadAccess ) {
  26. fprintf( stderr, "_X Error \"BadAccess\" for XGrabKeyboard ignored...\n" );
  27. return EXIT_SUCCESS;
  28. }
  29. // Ignore XQueryKeymap BadValue errors, we can work without it.
  30. // 128 = XShape request code, not sure why XQueryKeymap generates this?
  31. if ( event->request_code == 128 && event->error_code == BadValue ) {
  32. fprintf( stderr, "_X Error \"BadValue\" for XQueryKeymap ignored...\n" );
  33. return EXIT_SUCCESS;
  34. }
  35. // Everything else should be fatal as I don't like undefined behavior.
  36. char buffer[1024];
  37. XGetErrorText( dpy, event->error_code, buffer, 1024 );
  38. fprintf( stderr,
  39. "_X Error of failed request: %s\n_ Error code of failed request: %3d\n_ Major opcode of failed request: %3d\n_ Minor opcode of failed request: %3d\n_ Serial number of failed request: %5li\n_ Current serial number in output stream:?????\n",
  40. buffer,
  41. event->error_code,
  42. event->request_code,
  43. event->minor_code,
  44. event->serial );
  45. exit(1);
  46. }
  47. unsigned int slop::XEngine::getWidth() {
  48. if ( !m_good ) {
  49. return -1;
  50. }
  51. return WidthOfScreen( m_screen );
  52. }
  53. unsigned int slop::XEngine::getHeight() {
  54. if ( !m_good ) {
  55. return -1;
  56. }
  57. return HeightOfScreen( m_screen );
  58. }
  59. slop::XEngine::XEngine() {
  60. m_keypressed = false;
  61. m_display = NULL;
  62. m_visual = NULL;
  63. m_screen = NULL;
  64. m_good = false;
  65. m_mousex = -1;
  66. m_mousey = -1;
  67. m_hoverWindow = None;
  68. }
  69. slop::XEngine::~XEngine() {
  70. if ( !m_good ) {
  71. return;
  72. }
  73. for ( unsigned int i=0; i<m_cursors.size(); i++ ) {
  74. if ( m_cursors.at( i ) ) {
  75. XFreeCursor( m_display, m_cursors[i] );
  76. }
  77. }
  78. XCloseDisplay( m_display );
  79. }
  80. bool slop::XEngine::mouseDown( unsigned int button ) {
  81. if ( button >= m_mouse.size() ) {
  82. return false;
  83. }
  84. return m_mouse.at( button );
  85. }
  86. int slop::XEngine::init( std::string display ) {
  87. // Initialize display
  88. m_display = XOpenDisplay( display.c_str() );
  89. if ( !m_display ) {
  90. fprintf( stderr, "Error: Failed to open X display %s\n", display.c_str() );
  91. return EXIT_FAILURE;
  92. }
  93. m_screen = ScreenOfDisplay( m_display, DefaultScreen( m_display ) );
  94. m_visual = DefaultVisual ( m_display, XScreenNumberOfScreen( m_screen ) );
  95. m_colormap = DefaultColormap( m_display, XScreenNumberOfScreen( m_screen ) );
  96. //m_root = RootWindow ( m_display, XScreenNumberOfScreen( m_screen ) );
  97. m_root = DefaultRootWindow( m_display );
  98. m_good = true;
  99. XSetErrorHandler( slop::XEngineErrorHandler );
  100. selectAllInputs( m_root, EnterWindowMask );
  101. return EXIT_SUCCESS;
  102. }
  103. bool slop::XEngine::keyPressed( KeySym key ) {
  104. KeyCode keycode = XKeysymToKeycode( m_display, key );
  105. if ( keycode != 0 ) {
  106. // Get the whole keyboard state
  107. char keys[32];
  108. XQueryKeymap( m_display, keys );
  109. // Check our keycode
  110. return ( keys[ keycode / 8 ] & ( 1 << ( keycode % 8 ) ) ) != 0;
  111. } else {
  112. return false;
  113. }
  114. }
  115. bool slop::XEngine::anyKeyPressed() {
  116. if ( !m_good ) {
  117. return false;
  118. }
  119. // Thanks to SFML for some reliable key state grabbing.
  120. // Get the whole keyboard state
  121. char keys[ 32 ];
  122. XQueryKeymap( m_display, keys );
  123. // Each bit indicates a different key, 1 for pressed, 0 otherwise.
  124. // Every bit should be 0 if nothing is pressed.
  125. for ( unsigned int i = 0; i < 32; i++ ) {
  126. if ( keys[ i ] != 0 ) {
  127. return true;
  128. }
  129. }
  130. return false;
  131. }
  132. int slop::XEngine::grabKeyboard() {
  133. if ( !m_good ) {
  134. return EXIT_FAILURE;
  135. }
  136. int err = XGrabKeyboard( m_display, m_root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
  137. if ( err != GrabSuccess ) {
  138. fprintf( stderr, "Warning: Failed to grab X keyboard.\n" );
  139. fprintf( stderr, " This happens when something has already grabbed your keybaord.\n" );
  140. fprintf( stderr, " slop should still run properly though.\n" );
  141. return EXIT_FAILURE;
  142. }
  143. return EXIT_SUCCESS;
  144. }
  145. int slop::XEngine::releaseKeyboard() {
  146. if ( !m_good ) {
  147. return EXIT_FAILURE;
  148. }
  149. XUngrabKeyboard( m_display, CurrentTime );
  150. return EXIT_SUCCESS;
  151. }
  152. void slop::XEngine::selectAllInputs( Window win, long event_mask) {
  153. Window root, parent;
  154. Window* children;
  155. unsigned int nchildren;
  156. XQueryTree( m_display, win, &root, &parent, &children, &nchildren );
  157. for ( unsigned int i=0;i<nchildren;i++ ) {
  158. XSelectInput( m_display, children[ i ], event_mask );
  159. selectAllInputs( children[ i ], event_mask );
  160. }
  161. free( children );
  162. }
  163. // Grabs the cursor, be wary that setCursor changes the mouse masks.
  164. int slop::XEngine::grabCursor( slop::CursorType type ) {
  165. if ( !m_good ) {
  166. return EXIT_FAILURE;
  167. }
  168. int xfontcursor = getCursor( type );
  169. int err = XGrabPointer( m_display, m_root, True,
  170. PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
  171. GrabModeAsync, GrabModeAsync, None, xfontcursor, CurrentTime );
  172. if ( err != GrabSuccess ) {
  173. fprintf( stderr, "Error: Failed to grab X cursor.\n" );
  174. fprintf( stderr, " This can be caused by launching slop weirdly.\n" );
  175. return EXIT_FAILURE;
  176. }
  177. // Quickly set the mouse position so we don't have to worry about x11 generating an event.
  178. Window root, child;
  179. int mx, my;
  180. int wx, wy;
  181. unsigned int mask;
  182. XQueryPointer( m_display, m_root, &root, &child, &mx, &my, &wx, &wy, &mask );
  183. m_mousex = mx;
  184. m_mousey = my;
  185. // Get the deepest available window.
  186. Window test = child;
  187. while( test ) {
  188. child = test;
  189. XQueryPointer( m_display, child, &root, &test, &mx, &my, &wx, &wy, &mask );
  190. }
  191. m_hoverWindow = child;
  192. return EXIT_SUCCESS;
  193. }
  194. int slop::XEngine::releaseCursor() {
  195. if ( !m_good ) {
  196. return EXIT_FAILURE;
  197. }
  198. XUngrabPointer( m_display, CurrentTime );
  199. return EXIT_SUCCESS;
  200. }
  201. void slop::XEngine::tick() {
  202. if ( !m_good ) {
  203. return;
  204. }
  205. XEvent event;
  206. while ( XPending( m_display ) ) {
  207. XNextEvent( m_display, &event );
  208. switch ( event.type ) {
  209. case MotionNotify: {
  210. m_mousex = event.xmotion.x;
  211. m_mousey = event.xmotion.y;
  212. break;
  213. }
  214. case ButtonPress: {
  215. // Our pitiful mouse manager--
  216. if ( m_mouse.size() > event.xbutton.button ) {
  217. m_mouse.at( event.xbutton.button ) = true;
  218. } else {
  219. m_mouse.resize( event.xbutton.button+2, false );
  220. m_mouse.at( event.xbutton.button ) = true;
  221. }
  222. break;
  223. }
  224. case EnterNotify: {
  225. if ( event.xcrossing.subwindow != None ) {
  226. m_hoverWindow = event.xcrossing.subwindow;
  227. } else {
  228. m_hoverWindow = event.xcrossing.window;
  229. }
  230. break;
  231. }
  232. case ButtonRelease: {
  233. if ( m_mouse.size() > event.xbutton.button ) {
  234. m_mouse.at( event.xbutton.button ) = false;
  235. } else {
  236. m_mouse.resize( event.xbutton.button+2, false );
  237. m_mouse.at( event.xbutton.button ) = false;
  238. }
  239. break;
  240. }
  241. default: break;
  242. }
  243. }
  244. }
  245. // This converts an enum into a preallocated cursor, the cursor will automatically deallocate itself on ~XEngine
  246. Cursor slop::XEngine::getCursor( slop::CursorType type ) {
  247. int xfontcursor;
  248. switch ( type ) {
  249. default:
  250. case Left: xfontcursor = XC_left_ptr; break;
  251. case Crosshair: xfontcursor = XC_crosshair; break;
  252. case Cross: xfontcursor = XC_cross; break;
  253. case UpperLeftCorner: xfontcursor = XC_ul_angle; break;
  254. case UpperRightCorner: xfontcursor = XC_ur_angle; break;
  255. case LowerLeftCorner: xfontcursor = XC_ll_angle; break;
  256. case LowerRightCorner: xfontcursor = XC_lr_angle; break;
  257. case Dot: xfontcursor = XC_dot; break;
  258. case Box: xfontcursor = 40; break;
  259. }
  260. Cursor newcursor = 0;
  261. if ( m_cursors.size() > (unsigned int)xfontcursor ) {
  262. newcursor = m_cursors.at( xfontcursor );
  263. }
  264. if ( !newcursor ) {
  265. newcursor = XCreateFontCursor( m_display, xfontcursor );
  266. m_cursors.resize( xfontcursor+2, 0 );
  267. m_cursors.at( xfontcursor ) = newcursor;
  268. }
  269. return newcursor;
  270. }
  271. // Swaps out the current cursor, bewary that XChangeActivePointerGrab also resets masks, so if you change the mouse masks on grab you need to change them here too.
  272. void slop::XEngine::setCursor( slop::CursorType type ) {
  273. if ( !m_good ) {
  274. return;
  275. }
  276. Cursor xfontcursor = getCursor( type );
  277. XChangeActivePointerGrab( m_display,
  278. PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
  279. xfontcursor, CurrentTime );
  280. }
  281. void slop::WindowRectangle::applyPadding( int padding ) {
  282. if ( (int)m_width + padding*2 >= 0 ) {
  283. m_x -= padding;
  284. m_width += padding*2;
  285. }
  286. if ( (int)m_height + padding*2 >= 0 ) {
  287. m_y -= padding;
  288. m_height += padding*2;
  289. }
  290. }
  291. Window slop::WindowRectangle::getWindow() {
  292. return m_window;
  293. }
  294. void slop::WindowRectangle::applyMinMaxSize( unsigned int minimumsize, unsigned int maximumsize ) {
  295. if ( minimumsize > maximumsize && maximumsize > 0 ) {
  296. fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
  297. exit( 1 );
  298. }
  299. if ( m_width < minimumsize ) {
  300. int diff = minimumsize - m_width;
  301. m_width = minimumsize;
  302. m_x -= diff/2;
  303. }
  304. if ( m_height < minimumsize ) {
  305. int diff = minimumsize - m_height;
  306. m_height = minimumsize;
  307. m_y -= diff/2;
  308. }
  309. if ( maximumsize > 0 ) {
  310. if ( m_width > maximumsize ) {
  311. int diff = m_width;
  312. m_width = maximumsize;
  313. // Center in the center of the window
  314. m_x += diff/2 - maximumsize/2;
  315. }
  316. if ( m_height > maximumsize ) {
  317. int diff = m_height;
  318. m_height = maximumsize;
  319. // Center in the center of the window
  320. m_y += diff/2 - maximumsize/2;
  321. }
  322. }
  323. }
  324. void slop::WindowRectangle::setGeometry( Window win, bool decorations ) {
  325. if ( decorations ) {
  326. Window root, parent, test, junk;
  327. Window* childlist;
  328. unsigned int ujunk;
  329. // Try to find the actual decorations.
  330. test = win;
  331. int status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);
  332. free( childlist );
  333. while( parent != root ) {
  334. if ( !parent || !status ) {
  335. break;
  336. }
  337. test = parent;
  338. status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);
  339. free( childlist );
  340. }
  341. // test contains the window we're screenshotting.
  342. m_window = test;
  343. // Once found, proceed normally.
  344. if ( test && parent == root && status ) {
  345. XWindowAttributes attr;
  346. XGetWindowAttributes( xengine->m_display, test, &attr );
  347. m_width = attr.width;
  348. m_height = attr.height;
  349. m_border = attr.border_width;
  350. XTranslateCoordinates( xengine->m_display, test, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
  351. // We make sure we include borders, since we want decorations.
  352. m_width += m_border * 2;
  353. m_height += m_border * 2;
  354. }
  355. return;
  356. }
  357. Window junk;
  358. // Now here we should be able to just use whatever we get.
  359. XWindowAttributes attr;
  360. // We use XGetWindowAttributes to know our root window.
  361. XGetWindowAttributes( xengine->m_display, win, &attr );
  362. //m_x = attr.x;
  363. //m_y = attr.y;
  364. m_width = attr.width;
  365. m_height = attr.height;
  366. m_border = attr.border_width;
  367. XTranslateCoordinates( xengine->m_display, win, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
  368. m_window = win;
  369. }