1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- 2 3 client.h for the Openbox window manager 4 Copyright (c) 2006 Mikael Magnusson 5 Copyright (c) 2003-2007 Dana Jansens 6 7 This program 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 2 of the License, or 10 (at your option) any later version. 11 12 This program 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 See the COPYING file for a copy of the GNU General Public License. 18 */ 19 20 #ifndef __client_h 21 #define __client_h 22 23 #include "misc.h" 24 #include "mwm.h" 25 #include "geom.h" 26 #include "stacking.h" 27 #include "window.h" 28 #include "obrender/color.h" 29 30 #include <glib.h> 31 #include <X11/Xlib.h> 32 33 #ifdef HAVE_SYS_TYPES_H 34 # include <sys/types.h> /* for pid_t */ 35 #endif 36 37 struct _ObFrame; 38 struct _ObGroup; 39 struct _ObSessionState; 40 struct _ObPrompt; 41 42 typedef struct _ObClient ObClient; 43 44 /*! Possible window types */ 45 typedef enum 46 { 47 OB_CLIENT_TYPE_DESKTOP, /*!< A desktop (bottom-most window) */ 48 OB_CLIENT_TYPE_DOCK, /*!< A dock bar/panel window */ 49 OB_CLIENT_TYPE_TOOLBAR, /*!< A toolbar window, pulled off an app */ 50 OB_CLIENT_TYPE_MENU, /*!< An unpinned menu from an app */ 51 OB_CLIENT_TYPE_UTILITY, /*!< A small utility window such as a palette */ 52 OB_CLIENT_TYPE_SPLASH, /*!< A splash screen window */ 53 OB_CLIENT_TYPE_DIALOG, /*!< A dialog window */ 54 OB_CLIENT_TYPE_NORMAL /*!< A normal application window */ 55 } ObClientType; 56 57 /*! The things the user can do to the client window */ 58 typedef enum 59 { 60 OB_CLIENT_FUNC_RESIZE = 1 << 0, /*!< Allow user resizing */ 61 OB_CLIENT_FUNC_MOVE = 1 << 1, /*!< Allow user moving */ 62 OB_CLIENT_FUNC_ICONIFY = 1 << 2, /*!< Allow to be iconified */ 63 OB_CLIENT_FUNC_MAXIMIZE = 1 << 3, /*!< Allow to be maximized */ 64 OB_CLIENT_FUNC_SHADE = 1 << 4, /*!< Allow to be shaded */ 65 OB_CLIENT_FUNC_FULLSCREEN = 1 << 5, /*!< Allow to be made fullscreen */ 66 OB_CLIENT_FUNC_CLOSE = 1 << 6, /*!< Allow to be closed */ 67 OB_CLIENT_FUNC_ABOVE = 1 << 7, /*!< Allow to be put in lower layer */ 68 OB_CLIENT_FUNC_BELOW = 1 << 8, /*!< Allow to be put in higher layer */ 69 OB_CLIENT_FUNC_UNDECORATE = 1 << 9 /*!< Allow to be undecorated */ 70 } ObFunctions; 71 72 struct _ObClient 73 { 74 ObWindow obwin; 75 Window window; 76 gboolean managed; 77 78 /*! If this client is managing an ObPrompt window, then this is set to the 79 prompt */ 80 struct _ObPrompt *prompt; 81 82 /*! The window's decorations. NULL while the window is being managed! */ 83 struct _ObFrame *frame; 84 85 /*! The number of unmap events to ignore on the window */ 86 gint ignore_unmaps; 87 88 /*! The id of the group the window belongs to */ 89 struct _ObGroup *group; 90 91 /*! Saved session data to apply to this client */ 92 struct _ObSessionState *session; 93 94 /*! Whether or not the client is a transient window. It may or may not 95 have parents when this is true. */ 96 gboolean transient; 97 /*! Whether or not the client is transient for its group */ 98 gboolean transient_for_group; 99 /*! The client which are parents of this client */ 100 GSList *parents; 101 /*! The clients which are transients (children) of this client */ 102 GSList *transients; 103 /*! The desktop on which the window resides (0xffffffff for all 104 desktops) */ 105 guint desktop; 106 107 /*! The startup id for the startup-notification protocol. This will be 108 NULL if a startup id is not set. */ 109 gchar *startup_id; 110 111 /*! Normal window title */ 112 gchar *title; 113 /*! Window title when iconified */ 114 gchar *icon_title; 115 /*! The title as requested by the client, without any of our own changes */ 116 gchar *original_title; 117 /*! Hostname of machine running the client */ 118 gchar *client_machine; 119 /*! The command used to run the program. Pre-XSMP window identification. */ 120 gchar *wm_command; 121 /*! The PID of the process which owns the window */ 122 pid_t pid; 123 124 /*! The application that created the window */ 125 gchar *name; 126 /*! The class of the window, can used for grouping */ 127 gchar *class; 128 /*! The specified role of the window, used for identification */ 129 gchar *role; 130 /*! The application that created the window's group. */ 131 gchar *group_name; 132 /*! The class of the window's group, can used for grouping */ 133 gchar *group_class; 134 /*! The session client id for the window. *This can be NULL!* */ 135 gchar *sm_client_id; 136 137 /*! The type of window (what its function is) */ 138 ObClientType type; 139 140 /*! Position and size of the window 141 This will not always be the actual position of the window on screen, it 142 is, rather, the position requested by the client, to which the window's 143 gravity is applied. 144 */ 145 Rect area; 146 147 /*! Position of the client window relative to the root window */ 148 Point root_pos; 149 150 /*! Position and size of the window prior to being maximized */ 151 Rect pre_max_area; 152 /*! Position and size of the window prior to being fullscreened */ 153 Rect pre_fullscreen_area; 154 /*! Remember if the window was maximized before going fullscreen */ 155 gboolean pre_fullscreen_max_horz, 156 pre_fullscreen_max_vert; 157 158 /*! The window's strut 159 The strut defines areas of the screen that are marked off-bounds for 160 window placement. In theory, where this window exists. 161 */ 162 StrutPartial strut; 163 164 /*! The logical size of the window 165 The "logical" size of the window is refers to the user's perception of 166 the size of the window, and is the value that should be displayed to the 167 user. For example, with xterms, this value it the number of characters 168 being displayed in the terminal, instead of the number of pixels. 169 */ 170 Size logical_size; 171 172 /*! Width of the border on the window. 173 The window manager will set this to 0 while the window is being managed, 174 but needs to restore it afterwards, so it is saved here. 175 */ 176 gint border_width; 177 178 /*! The minimum aspect ratio the client window can be sized to. 179 A value of 0 means this is ignored. 180 */ 181 gfloat min_ratio; 182 /*! The maximum aspect ratio the client window can be sized to. 183 A value of 0 means this is ignored. 184 */ 185 gfloat max_ratio; 186 187 /*! The minimum size of the client window 188 If the min is > the max, then the window is not resizable 189 */ 190 Size min_size; 191 /*! The maximum size of the client window 192 If the min is > the max, then the window is not resizable 193 */ 194 Size max_size; 195 /*! The size of increments to resize the client window by */ 196 Size size_inc; 197 /*! The base size of the client window 198 This value should be subtracted from the window's actual size when 199 displaying its size to the user, or working with its min/max size 200 */ 201 Size base_size; 202 203 /*! Window decoration and functionality hints */ 204 ObMwmHints mwmhints; 205 206 /*! The client's specified colormap */ 207 Colormap colormap; 208 209 /*! Where to place the decorated window in relation to the undecorated 210 window */ 211 gint gravity; 212 213 /*! The state of the window, one of WithdrawnState, IconicState, or 214 NormalState */ 215 glong wmstate; 216 217 /*! True if the client supports the delete_window protocol */ 218 gboolean delete_window; 219 220 /*! Was the window's position requested by the application or the user? 221 if by the application, we force it completely onscreen, if by the user 222 we only force it if it tries to go completely offscreen, if neither, we 223 should place the window ourselves when it first appears */ 224 guint positioned; 225 226 /*! Was the window's size requested by the application or the user? 227 If by the application we don't let it go outside the available area */ 228 guint sized; 229 230 /*! Can the window receive input focus? */ 231 gboolean can_focus; 232 /*! Notify the window when it receives focus? */ 233 gboolean focus_notify; 234 235 /*! Will the client respond to pings? */ 236 gboolean ping; 237 /*! Indicates if the client is trying to close but has stopped responding 238 to pings */ 239 gboolean not_responding; 240 /*! A prompt shown when you are trying to close a client that is not 241 responding. It asks if you want to kill the client */ 242 struct _ObPrompt *kill_prompt; 243 /*! We tried to close the window with a SIGTERM */ 244 gint kill_level; 245 246 #ifdef SYNC 247 /*! The client wants to sync during resizes */ 248 gboolean sync_request; 249 /*! The XSync counter used for synchronizing during resizes */ 250 guint32 sync_counter; 251 /*! The value we're waiting for the counter to reach */ 252 gulong sync_counter_value; 253 #endif 254 255 /*! The window uses shape extension to be non-rectangular? */ 256 gboolean shaped; 257 /*! The window uses shape extension to have non-rectangular input? */ 258 gboolean shaped_input; 259 260 /*! The window is modal, so it must be processed before any windows it is 261 related to can be focused */ 262 gboolean modal; 263 /*! Only the window's titlebar is displayed */ 264 gboolean shaded; 265 /*! The window is iconified */ 266 gboolean iconic; 267 /*! The window is maximized to fill the screen vertically */ 268 gboolean max_vert; 269 /*! The window is maximized to fill the screen horizontally */ 270 gboolean max_horz; 271 /*! The window should not be displayed by pagers */ 272 gboolean skip_pager; 273 /*! The window should not be displayed by taskbars */ 274 gboolean skip_taskbar; 275 /*! The window is a 'fullscreen' window, and should be on top of all 276 others */ 277 gboolean fullscreen; 278 /*! The window should be on top of other windows of the same type. 279 above takes priority over below. */ 280 gboolean above; 281 /*! The window should be underneath other windows of the same type. 282 above takes priority over below. */ 283 gboolean below; 284 /*! Demands attention flag */ 285 gboolean demands_attention; 286 287 /*! The urgent flag */ 288 gboolean urgent; 289 290 /*! The layer in which the window will be stacked, windows in lower layers 291 are always below windows in higher layers. */ 292 ObStackingLayer layer; 293 294 /*! A bitmask of values in the ObFrameDecorations enum 295 The values in the variable are the decorations that the client wants to 296 be displayed around it. 297 */ 298 guint decorations; 299 300 /*! A user option. When this is set to TRUE the client will not ever 301 be decorated. 302 */ 303 gboolean undecorated; 304 305 /*! A bitmask of values in the ObFunctions enum 306 The values in the variable specify the ways in which the user is allowed 307 to modify this window. 308 */ 309 guint functions; 310 311 /* The window's icon, in a variety of shapes and sizes */ 312 RrImage *icon_set; 313 314 /*! Where the window should iconify to/from */ 315 Rect icon_geometry; 316 317 /*! A boolean used for algorithms which need to mark clients as visited */ 318 gboolean visited; 319 }; 320 321 extern GList *client_list; 322 323 void client_startup(gboolean reconfig); 324 void client_shutdown(gboolean reconfig); 325 326 typedef void (*ObClientCallback)(ObClient *client, gpointer data); 327 328 /* Callback functions */ 329 330 /*! Get notified when the client is unmanaged */ 331 void client_add_destroy_notify(ObClientCallback func, gpointer data); 332 void client_remove_destroy_notify(ObClientCallback func); 333 void client_remove_destroy_notify_data(ObClientCallback func, gpointer data); 334 335 /*! Manages a given window 336 @param prompt This specifies an ObPrompt which is being managed. It is 337 possible to manage Openbox-owned windows through this. 338 */ 339 void client_manage(Window win, struct _ObPrompt *prompt); 340 /*! Unmanages all managed windows */ 341 void client_unmanage_all(void); 342 /*! Unmanages a given client */ 343 void client_unmanage(ObClient *client); 344 345 /*! This manages a window only so far as is needed to get it's decorations. 346 This is used when you want to determine a window's decorations before it 347 is mapped. Call client_fake_unmanage() with the returned client when you 348 are done with it. */ 349 ObClient *client_fake_manage(Window win); 350 /*! Free the stuff created by client_fake_manage() */ 351 void client_fake_unmanage(ObClient *self); 352 353 /*! Sets the client list on the root window from the client_list */ 354 void client_set_list(void); 355 356 /*! Determines if the client should be shown or hidden currently. 357 @return TRUE if it should be visible; otherwise, FALSE. 358 */ 359 gboolean client_should_show(ObClient *self); 360 361 /*! Returns if the window should be treated as a normal window. 362 Some windows (desktops, docks, splash screens) have special rules applied 363 to them in a number of places regarding focus or user interaction. */ 364 gboolean client_normal(ObClient *self); 365 366 /*! Returns if the window is one of an application's helper windows 367 (utilty, menu, etc) */ 368 gboolean client_helper(ObClient *self); 369 370 /*! Returns true if the window occupies space in the monitor conceptually, or 371 false if it does not and its presence should be ignored when possible. */ 372 gboolean client_occupies_space(ObClient *self); 373 374 /*! Return if the client is a type which should be given focus from mouse 375 presses on the *client* window. This doesn't affect clicking on the 376 decorations. This doesn't count for focus cycling, different rules apply to 377 that. */ 378 gboolean client_mouse_focusable(ObClient *self); 379 380 /*! Return if the client is a type which should be given focus from the 381 mouse entering the window. This doesn't count for focus cycling, different 382 rules apply to that. */ 383 gboolean client_enter_focusable(ObClient *self); 384 385 /* Returns if the window is focused */ 386 gboolean client_focused(ObClient *self); 387 388 /*! When the client is resized but not moved, figure out the new position 389 for it based on its gravity: 390 http://standards.freedesktop.org/wm-spec/wm-spec-1.4.html#id2512541 391 */ 392 void client_gravity_resize_w(ObClient *self, gint *x, gint oldw, gint neww); 393 394 /*! When the client is resized but not moved, figure out the new position 395 for it based on its gravity: 396 http://standards.freedesktop.org/wm-spec/wm-spec-1.4.html#id2512541 397 */ 398 void client_gravity_resize_h(ObClient *self, gint *y, gint oldh, gint newh); 399 400 /*! Convert a position/size from a given gravity to the client's true gravity, 401 when the client is only resizing (the reference point doesn't move) 402 */ 403 void client_convert_gravity_resize(ObClient *self, gint gravity, 404 gint *x, gint *y, 405 gint w, gint h); 406 407 #define client_move(self, x, y) \ 408 client_configure(self, x, y, self->area.width, self->area.height, TRUE, TRUE,\ 409 FALSE) 410 #define client_resize(self, w, h) \ 411 client_configure(self, self->area.x, self->area.y, w, h, TRUE, TRUE, FALSE) 412 #define client_move_resize(self, x, y, w, h) \ 413 client_configure(self, x, y, w, h, TRUE, TRUE, FALSE) 414 #define client_reconfigure(self, force) \ 415 client_configure(self, ((ObClient*)self)->area.x, ((ObClient*)self)->area.y, \ 416 ((ObClient*)self)->area.width, \ 417 ((ObClient*)self)->area.height, FALSE, TRUE, force) 418 419 /*! Figure out where a window will end up and what size it will be if you 420 told it to move/resize to these coordinates. 421 422 These values are what client_configure will give the window. 423 424 @param x The x coordiante of the new position for the client. 425 @param y The y coordiante of the new position for the client. 426 @param w The width component of the new size for the client. 427 @param h The height component of the new size for the client. 428 @param logicalw Returns the width component of the new logical width. 429 This value is only returned when the new w or h calculated 430 differ from the ones passed in. 431 @param logicalh Returns the height component of the new logical height. 432 This value is only returned when the new w or h calculated 433 differ from the ones passed in. 434 @param user Specifies whether this is a user-requested change or a 435 program requested change. For program requested changes, the 436 constraints are not checked. 437 */ 438 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h, 439 gint *logicalw, gint *logicalh, 440 gboolean user); 441 442 /*! Move and/or resize the window. 443 This also maintains things like the client's minsize, and size increments. 444 @param x The x coordiante of the new position for the client. 445 @param y The y coordiante of the new position for the client. 446 @param w The width component of the new size for the client. 447 @param h The height component of the new size for the client. 448 @param user Specifies whether this is a user-requested change or a 449 program requested change. For program requested changes, the 450 constraints are not checked. 451 @param final If user is true, then this should specify if this is a final 452 configuration. e.g. Final should be FALSE if doing an 453 interactive move/resize, and then be TRUE for the last call 454 only. 455 @param force_reply Send a ConfigureNotify to the client regardless of if 456 the position/size changed. 457 */ 458 void client_configure(ObClient *self, gint x, gint y, gint w, gint h, 459 gboolean user, gboolean final, gboolean force_reply); 460 461 /*! Finds coordinates to keep a client on the screen. 462 @param self The client 463 @param x The x coord of the client, may be changed. 464 @param y The y coord of the client, may be changed. 465 @param w The width of the client. 466 @param w The height of the client. 467 @param rude Be rude about it. If false, it is only moved if it is entirely 468 not visible. If true, then make sure the window is inside the 469 struts if possible. 470 @return true if the client was moved to be on-screen; false if not. 471 */ 472 gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h, 473 gboolean rude); 474 475 /*! Moves a client so that it is on screen if it is entirely out of the 476 viewable screen. 477 @param self The client to move 478 @param rude Be rude about it. If false, it is only moved if it is entirely 479 not visible. If true, then make sure the window is inside the 480 struts if possible. 481 */ 482 void client_move_onscreen(ObClient *self, gboolean rude); 483 484 /*! dir is either North, South, East or West. It can't be, for example, 485 Northwest */ 486 void client_find_edge_directional(ObClient *self, ObDirection dir, 487 gint my_head, gint my_tail, 488 gint my_edge_start, gint my_edge_size, 489 gint *dest, gboolean *near_edge); 490 void client_find_move_directional(ObClient *self, ObDirection dir, 491 gint *x, gint *y); 492 493 typedef enum { 494 CLIENT_RESIZE_GROW, 495 CLIENT_RESIZE_GROW_IF_NOT_ON_EDGE, 496 CLIENT_RESIZE_SHRINK, 497 } ObClientDirectionalResizeType; 498 499 /*! Moves the client area passed in to grow/shrink the given edge. */ 500 void client_find_resize_directional(ObClient *self, 501 ObDirection side, 502 ObClientDirectionalResizeType resize_type, 503 gint *x, gint *y, gint *w, gint *h); 504 505 /*! Fullscreen's or unfullscreen's the client window 506 @param fs true if the window should be made fullscreen; false if it should 507 be returned to normal state. 508 */ 509 void client_fullscreen(ObClient *self, gboolean fs); 510 511 /*! Determine if the window, using the given client-area, would be considered 512 as an "oldschool fullscreen" window, that is, if it is filling a whole 513 monitor. */ 514 gboolean client_is_oldfullscreen(const ObClient *self, const Rect *area); 515 516 /*! Iconifies or uniconifies the client window 517 @param iconic true if the window should be iconified; false if it should be 518 restored. 519 @param curdesk If iconic is FALSE, then this determines if the window will 520 be uniconified to the current viewable desktop (true) or to 521 its previous desktop (false) 522 */ 523 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk, 524 gboolean hide_animation); 525 526 /*! Maximize or unmaximize the client window 527 @param max true if the window should be maximized; false if it should be 528 returned to normal size. 529 @param dir 0 to set both horz and vert, 1 to set horz, 2 to set vert. 530 */ 531 void client_maximize(ObClient *self, gboolean max, gint dir); 532 533 /*! Shades or unshades the client window 534 @param shade true if the window should be shaded; false if it should be 535 unshaded. 536 */ 537 void client_shade(ObClient *self, gboolean shade); 538 539 /*! Set a client window to have decorations or not */ 540 void client_set_undecorated(ObClient *self, gboolean undecorated); 541 542 /*! Hilite the window to make the user notice it */ 543 void client_hilite(ObClient *self, gboolean hilite); 544 545 /*! Request the client to close its window */ 546 void client_close(ObClient *self); 547 548 /*! Kill the client off violently */ 549 void client_kill(ObClient *self); 550 551 /*! Sends the window to the specified desktop 552 @param donthide If TRUE, the window will not be shown/hidden after its 553 desktop has been changed. Generally this should be FALSE. 554 @param dontraise If TRUE, the window will not be raised. Generally this should 555 be FALSE. 556 */ 557 void client_set_desktop(ObClient *self, guint target, gboolean donthide, 558 gboolean dontraise); 559 560 /*! Show the client if it should be shown. Returns if the window is shown. */ 561 gboolean client_show(ObClient *self); 562 563 /*! Show the client if it should be shown. Returns if the window is hidden. */ 564 gboolean client_hide(ObClient *self); 565 566 /*! Show the client if it should be shown, and hide it if it should be 567 hidden. This is for example, when switching desktops. 568 */ 569 void client_showhide(ObClient *self); 570 571 /*! Validate client, by making sure no Destroy or Unmap events exist in 572 the event queue for the window. 573 @return true if the client is valid; false if the client has already 574 been unmapped/destroyed, and so is invalid. 575 */ 576 gboolean client_validate(ObClient *self); 577 578 /*! Sets the wm_state to the specified value */ 579 void client_set_wm_state(ObClient *self, glong state); 580 581 /*! Adjusts the window's net_state 582 This should not be called as part of the window mapping process! It is for 583 use when updating the state post-mapping.<br> 584 client_apply_startup_state is used to do the same things during the mapping 585 process. 586 */ 587 void client_set_state(ObClient *self, Atom action, glong data1, glong data2); 588 589 /* Given a ObClient, find the client that focus would actually be sent to if 590 you wanted to give focus to the specified ObClient. Will return the same 591 ObClient passed to it or another ObClient if appropriate. */ 592 ObClient *client_focus_target(ObClient *self); 593 594 /*! Returns what client_focus would return if passed the same client, but 595 without focusing it or modifying the focus order lists. */ 596 gboolean client_can_focus(ObClient *self); 597 598 /*! Attempt to focus the client window */ 599 gboolean client_focus(ObClient *self); 600 601 /*! Activates the client for use, focusing, uniconifying it, etc. To be used 602 when the user deliberately selects a window for use. 603 @param desktop If true, and the window is on another desktop, it will still 604 be activated. 605 @param here If true, and the window is on another desktop, it will be moved 606 to the current desktop, otherwise the desktop will switch to 607 where the window is. 608 @param raise If true, the client is brought to the front. 609 @param unshade If true, the client is unshaded (if it is shaded) 610 @param user If true, then a user action is what requested the activation; 611 otherwise, it means an application requested it on its own 612 */ 613 void client_activate(ObClient *self, gboolean desktop, gboolean here, 614 gboolean raise, gboolean unshade, gboolean user); 615 616 /*! Bring all of its helper windows to its desktop. These are the utility and 617 stuff windows. */ 618 void client_bring_helper_windows(ObClient *self); 619 620 /*! Bring all of its modal windows to its desktop. */ 621 void client_bring_modal_windows(ObClient *self); 622 623 /*! Calculates the stacking layer for the client window */ 624 void client_calc_layer(ObClient *self); 625 626 /*! Updates the window's transient status, and any parents of it */ 627 void client_update_transient_for(ObClient *self); 628 /*! Update the protocols that the window supports and adjusts things if they 629 change */ 630 void client_update_protocols(ObClient *self); 631 #ifdef SYNC 632 /*! Updates the window's sync request counter for resizes */ 633 void client_update_sync_request_counter(ObClient *self); 634 #endif 635 /*! Updates the window's colormap */ 636 void client_update_colormap(ObClient *self, Colormap colormap); 637 /*! Updates the requested opacity for the window from the client. */ 638 void client_update_opacity(ObClient *self); 639 /*! Updates the WMNormalHints and adjusts things if they change */ 640 void client_update_normal_hints(ObClient *self); 641 642 /*! Updates the WMHints and adjusts things if they change 643 @param initstate Whether to read the initial_state property from the 644 WMHints. This should only be used during the mapping 645 process. 646 */ 647 void client_update_wmhints(ObClient *self); 648 /*! Updates the window's title and icon title */ 649 void client_update_title(ObClient *self); 650 /*! Updates the strut for the client */ 651 void client_update_strut(ObClient *self); 652 /*! Updates the window's icons */ 653 void client_update_icons(ObClient *self); 654 /*! Updates the window's icon geometry (where to iconify to/from) */ 655 void client_update_icon_geometry(ObClient *self); 656 657 /*! Helper function to convert the ->type member to string representation */ 658 const gchar *client_type_to_string(ObClient *self); 659 660 /*! Set up what decor should be shown on the window and what functions should 661 be allowed (ObClient::decorations and ObClient::functions). 662 This also updates the NET_WM_ALLOWED_ACTIONS hint. 663 @param reconfig When TRUE, the window will be reconfigured to show the 664 changes 665 */ 666 void client_setup_decor_and_functions(ObClient *self, gboolean reconfig); 667 668 /*! Sets the window's type and transient flag */ 669 void client_get_type_and_transientness(ObClient *self); 670 /*! Gets the motif wm hints */ 671 void client_get_mwm_hints(ObClient *self); 672 673 /*! Returns a client's icon set, or its parents (recursively) if it doesn't 674 have one 675 */ 676 RrImage* client_icon(ObClient *self); 677 678 /*! Return TRUE if the client is transient for some other window. Return 679 FALSE if it's not transient or there is no window for it to be 680 transient for */ 681 gboolean client_has_parent(ObClient *self); 682 683 /*! Return TRUE if the client has some transient children, and FALSE otherwise. 684 */ 685 gboolean client_has_children(ObClient *self); 686 687 /*! Searches a client's immediate parents for a focused window. The function 688 does not check for the passed client, only for *ONE LEVEL* of its parents. 689 If no focused parent is found, NULL is returned. 690 */ 691 ObClient *client_search_focus_parent(ObClient *self); 692 693 /*! Searches a client's parents for a focused window. The function 694 does not check for the passed client, but searches through all of its 695 parents. If no focused parent is found, NULL is returned. 696 */ 697 ObClient *client_search_focus_parent_full(ObClient *self); 698 699 /*! Searches a client's transients for a focused window. The function does not 700 check for the passed client, only for its transients. 701 If no focused transient is found, NULL is returned. 702 */ 703 ObClient *client_search_focus_tree(ObClient *self); 704 705 /*! Searches a client's transient tree for a focused window. The function 706 searches up the tree and down other branches as well as the passed client's. 707 If no focused client is found, NULL is returned. 708 */ 709 ObClient *client_search_focus_tree_full(ObClient *self); 710 711 /*! Searches a client's group and each member's transients for a focused 712 window. This doesn't go up the window's transient tree at all. If no 713 focused client is found, NULL is returned. */ 714 ObClient *client_search_focus_group_full(ObClient *self); 715 716 /*! Return a modal child of the client window that can be focused. 717 @return A modal child of the client window that can be focused, or 0 if 718 none was found. 719 */ 720 ObClient *client_search_modal_child(ObClient *self); 721 722 /*! Returns a list of top-level windows which this is a transient for. 723 It will only contain more than 1 element if the client is transient for its 724 group. 725 */ 726 GSList *client_search_all_top_parents(ObClient *self); 727 728 /*! Returns a list of top-level windows which this is a transient for, and 729 which are in the same layer as this client. 730 It will only contain more than 1 element if the client is transient for its 731 group. 732 */ 733 GSList *client_search_all_top_parents_layer(ObClient *self); 734 735 /*! Returns the client's parent when it is transient for a direct window 736 rather than a group. If it has no parents, or is transient for the 737 group, this returns null */ 738 ObClient *client_direct_parent(ObClient *self); 739 740 /*! Returns a window's top level parent. This only counts direct parents, 741 not groups if it is transient for its group. 742 */ 743 ObClient *client_search_top_direct_parent(ObClient *self); 744 745 /*! Is one client a direct child of another (i.e. not through the group.) 746 This checks more than one level, so there may be another direct child in 747 between */ 748 gboolean client_is_direct_child(ObClient *parent, ObClient *child); 749 750 /*! Search for a parent of a client. This only searches up *ONE LEVEL*, and 751 returns the searched for parent if it is a parent, or NULL if not. */ 752 ObClient *client_search_parent(ObClient *self, ObClient *search); 753 754 /*! Search for a transient of a client. The transient is returned if it is one, 755 NULL is returned if the given search is not a transient of the client. */ 756 ObClient *client_search_transient(ObClient *self, ObClient *search); 757 758 /*! Set a client window to be above/below other clients. 759 @layer < 0 indicates the client should be placed below other clients.<br /> 760 = 0 indicates the client should be placed with other clients.<br /> 761 > 0 indicates the client should be placed above other clients. 762 */ 763 void client_set_layer(ObClient *self, gint layer); 764 765 guint client_monitor(ObClient *self); 766 767 ObClient* client_under_pointer(void); 768 769 gboolean client_has_group_siblings(ObClient *self); 770 771 /*! Returns TRUE if the client has a transient child, a parent, or a 772 group member. Returns FALSE otherwise. 773 */ 774 gboolean client_has_relative(ObClient *self); 775 776 /*! Returns TRUE if the client is running on the same machine as Openbox */ 777 gboolean client_on_localhost(ObClient *self); 778 779 #endif 780