src/client.hh (raw)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 |
// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*- #ifndef __client_hh #define __client_hh /*! @file client.hh @brief The Client class maintains the state of a client window by handling property changes on the window and some client messages */ #include "screen.hh" #include "otk/strut.hh" #include "otk/rect.hh" #include "otk/eventhandler.hh" #include "otk/ustring.hh" extern "C" { #include <X11/Xlib.h> #ifdef SHAPE #include <X11/extensions/shape.h> #endif // SHAPE } #include <string> #include <list> namespace ob { class Frame; class Screen; struct Icon { unsigned long w, h; unsigned long *data; }; //! The MWM Hints as retrieved from the window property /*! This structure only contains 3 elements, even though the Motif 2.0 structure contains 5. We only use the first 3, so that is all gets defined. */ struct MwmHints { unsigned long flags; //!< A bitmask of Client::MwmFlags values unsigned long functions; //!< A bitmask of Client::MwmFunctions values unsigned long decorations;//!< A bitmask of Client::MwmDecorations values //! The number of elements in the Client::MwmHints struct static const unsigned int elements = 3; }; //! Maintains the state of a client window. /*! Client maintains the state of a client window. The state consists of the hints that the application sets on the window, such as the title, or window gravity. <p> Client also manages client messages for the client window. When the application (or any application) requests something to be changed for the client, it will call the ActionHandler (for client messages) or update the class' member variables and call whatever is nessary to complete the change (such as causing a redraw of the titlebar after the title is changed). */ class Client : public otk::EventHandler { public: //! The frame window which decorates around the client window /*! NOTE: This should NEVER be used inside the client class's constructor! */ Frame *frame; //! Holds a list of Clients typedef std::list<Client*> List; //! The possible stacking layers a client window can be a part of enum StackLayer { Layer_Icon, //!< 0 - iconified windows, in any order at all Layer_Desktop, //!< 1 - desktop windows Layer_Below, //!< 2 - normal windows w/ below Layer_Normal, //!< 3 - normal windows Layer_Above, //!< 4 - normal windows w/ above Layer_Top, //!< 5 - always-on-top-windows (docks?) Layer_Fullscreen, //!< 6 - fullscreeen windows Layer_Internal, //!< 7 - openbox windows/menus NUM_LAYERS }; //! Corners of the client window, used for anchor positions enum Corner { TopLeft, TopRight, BottomLeft, BottomRight }; //! Possible window types enum WindowType { Type_Desktop, //!< A desktop (bottom-most window) Type_Dock, //!< A dock bar/panel window Type_Toolbar, //!< A toolbar window, pulled off an app Type_Menu, //!< An unpinned menu from an app Type_Utility, //!< A small utility window such as a palette Type_Splash, //!< A splash screen window Type_Dialog, //!< A dialog window Type_Normal //!< A normal application window }; //! Possible flags for MWM Hints (defined by Motif 2.0) enum MwmFlags { MwmFlag_Functions = 1 << 0, //!< The MMW Hints define funcs MwmFlag_Decorations = 1 << 1 //!< The MWM Hints define decor }; //! Possible functions for MWM Hints (defined by Motif 2.0) enum MwmFunctions { MwmFunc_All = 1 << 0, //!< All functions MwmFunc_Resize = 1 << 1, //!< Allow resizing MwmFunc_Move = 1 << 2, //!< Allow moving MwmFunc_Iconify = 1 << 3, //!< Allow to be iconfied MwmFunc_Maximize = 1 << 4 //!< Allow to be maximized //MwmFunc_Close = 1 << 5 //!< Allow to be closed }; //! Possible decorations for MWM Hints (defined by Motif 2.0) enum MemDecorations { MwmDecor_All = 1 << 0, //!< All decorations MwmDecor_Border = 1 << 1, //!< Show a border MwmDecor_Handle = 1 << 2, //!< Show a handle (bottom) MwmDecor_Title = 1 << 3, //!< Show a titlebar //MwmDecor_Menu = 1 << 4, //!< Show a menu MwmDecor_Iconify = 1 << 5, //!< Show an iconify button MwmDecor_Maximize = 1 << 6 //!< Show a maximize button }; //! The things the user can do to the client window enum Function { Func_Resize = 1 << 0, //!< Allow resizing Func_Move = 1 << 1, //!< Allow moving Func_Iconify = 1 << 2, //!< Allow to be iconified Func_Maximize = 1 << 3, //!< Allow to be maximized Func_Shade = 1 << 4, //!< Allow to be shaded Func_Fullscreen = 1 << 5, //!< Allow to be made fullscreen Func_Close = 1 << 6 //!< Allow to be closed }; //! Holds a bitmask of Client::Function values typedef unsigned char FunctionFlags; //! The decorations the client window wants to be displayed on it enum Decoration { Decor_Titlebar = 1 << 0, //!< Display a titlebar Decor_Handle = 1 << 1, //!< Display a handle (bottom) Decor_Border = 1 << 2, //!< Display a border Decor_Icon = 1 << 3, //!< Display the window's icon Decor_Iconify = 1 << 4, //!< Display an iconify button Decor_Maximize = 1 << 5, //!< Display a maximize button //! Display a button to toggle the window's placement on //! all desktops Decor_AllDesktops = 1 << 6, Decor_Close = 1 << 7 //!< Display a close button }; //! Holds a bitmask of Client::Decoration values typedef unsigned char DecorationFlags; //! The event mask to grab on client windows static const long event_mask = PropertyChangeMask | FocusChangeMask | StructureNotifyMask; //! The mask of events to not let propogate past the client /*! This makes things like xprop work on the client window, but means we have to explicitly grab clicks that we want. */ static const long no_propagate_mask = ButtonPressMask | ButtonReleaseMask | ButtonMotionMask; //! The number of unmap events to ignore on the window int ignore_unmaps; private: //! The screen number on which the client resides int _screen; //! The actual window that this class is wrapping up Window _window; //! The id of the group the window belongs to Window _group; //! The client which this client is a transient (child) for Client *_transient_for; //! The clients which are transients (children) of this client Client::List _transients; //! The desktop on which the window resides (0xffffffff for all desktops) unsigned int _desktop; //! Normal window title otk::ustring _title; //! Window title when iconifiged otk::ustring _icon_title; //! The application that created the window std::string _app_name; //! The class of the window, can used for grouping std::string _app_class; //! The specified role of the window, used for identification std::string _role; //! The type of window (what its function is) WindowType _type; //! Position and size of the window /*! This will not always be the actual position of the window on screen, it is rather, the position requested by the client, to which the window's gravity is applied. */ otk::Rect _area; //! The window's strut /*! The strut defines areas of the screen that are marked off-bounds for window placement. In theory, where this window exists. */ otk::Strut _strut; //! The logical size of the window /*! The "logical" size of the window is refers to the user's perception of the size of the window, and is the value that should be displayed to the user. For example, with xterms, this value it the number of characters being displayed in the terminal, instead of the number of pixels. */ otk::Size _logical_size; //! Width of the border on the window. /*! The window manager will set this to 0 while the window is being managed, but needs to restore it afterwards, so it is saved here. */ int _border_width; //! The minimum aspect ratio the client window can be sized to. /*! A value of 0 means this is ignored. */ float _min_ratio; //! The maximum aspect ratio the client window can be sized to. /*! A value of 0 means this is ignored. */ float _max_ratio; //! The minimum size of the client window /*! If the min is > the max, then the window is not resizable */ otk::Size _min_size; //! The maximum size of the client window /*! If the min is > the max, then the window is not resizable */ otk::Size _max_size; //! The size of increments to resize the client window by otk::Size _size_inc; //! The base size of the client window /*! This value should be subtracted from the window's actual size when displaying its size to the user, or working with its min/max size */ otk::Size _base_size; //! Window decoration and functionality hints MwmHints _mwmhints; //! Where to place the decorated window in relation to the undecorated window int _gravity; //! The state of the window, one of WithdrawnState, IconicState, or //! NormalState long _wmstate; //! True if the client supports the delete_window protocol bool _delete_window; //! Was the window's position requested by the application? if not, we should //! place the window ourselves when it first appears bool _positioned; //! Can the window receive input focus? bool _can_focus; //! Urgency flag bool _urgent; //! Notify the window when it receives focus? bool _focus_notify; //! Does the client window have the input focus? bool _focused; //! The window uses shape extension to be non-rectangular? bool _shaped; //! The window is modal, so it must be processed before any windows it is //! related to can be focused bool _modal; //! Only the window's titlebar is displayed bool _shaded; //! The window is iconified bool _iconic; //! The window is maximized to fill the screen vertically bool _max_vert; //! The window is maximized to fill the screen horizontally bool _max_horz; //! The window should not be displayed by pagers bool _skip_pager; //! The window should not be displayed by taskbars bool _skip_taskbar; //! The window is a 'fullscreen' window, and should be on top of all others bool _fullscreen; //! The window should be on top of other windows of the same type bool _above; //! The window should be underneath other windows of the same type bool _below; //! The layer in which the window will be stacked, windows in lower layers //! are always below windows in higher layers. StackLayer _layer; //! A bitmask of values in the Client::Decoration enum /*! The values in the variable are the decorations that the client wants to be displayed around it. */ DecorationFlags _decorations; //! A bitmask of values in the Client::Decoration enum. /*! Specifies the decorations that should NOT be displayed on the client. */ DecorationFlags _disabled_decorations; //! A bitmask of values in the Client::Function enum /*! The values in the variable specify the ways in which the user is allowed to modify this window. */ FunctionFlags _functions; //! Icons for the client as specified on the client window Icon *_icons; //! The number of icons in _icons int _nicons; Pixmap _pixmap_icon; Pixmap _pixmap_icon_mask; //! Retrieves the window's initial gravity void getGravity(); //! Retrieves the desktop hint's value and sets Client::_desktop void getDesktop(); //! Retrieves the window's type and sets Client::_type void getType(); //! Gets the MWM Hints and adjusts Client::_functions and //! Client::_decorations void getMwmHints(); //! Gets the position and size of the window and sets Client::_area void getArea(); //! Gets the net_state hint and sets the boolean flags for any states set in //! the hint void getState(); //! Determines if the window uses the Shape extension and sets //! Client::_shaped void getShaped(); //! Set up what decor should be shown on the window and what functions should //! be allowed (Client::_decorations and Client::_functions). /*! This also updates the NET_WM_ALLOWED_ACTIONS hint. */ void setupDecorAndFunctions(); //! Sets the wm_state to the specified value void setWMState(long state); //! Adjusts the window's net_state /*! This should not be called as part of the window mapping process! It is for use when updating the state post-mapping.<br> Client::applyStartupState is used to do the same things during the mapping process. */ void setState(Atom action, long data1, long data2); //! Sends the window to the specified desktop void setDesktop(unsigned int desktop); //! Calculates the stacking layer for the client window void calcLayer(); //! Update the protocols that the window supports and adjusts things if they //! change void updateProtocols(); //! Updates the WMNormalHints and adjusts things if they change void updateNormalHints(); //! Updates the WMHints and adjusts things if they change /*! @param initstate Whether to read the initial_state property from the WMHints. This should only be used during the mapping process. */ void updateWMHints(bool initstate = false); //! Updates the window's title void updateTitle(); //! Updates the window's icon title void updateIconTitle(); //! Updates the window's application name and class void updateClass(); //! Updates the strut for the client void updateStrut(); //! Updates the window's transient status, and any parents of it void updateTransientFor(); //! Updates the window's icons void updateIcons(); //! Updates the window's kwm icon void updateKwmIcon(); //! Change the client's state hints to match the class' data void changeState(); //! Change the allowed actions set on the client void changeAllowedActions(); //! Request the client to close its window. void close(); //! Shades or unshades the client window /*! @param shade true if the window should be shaded; false if it should be unshaded. */ void shade(bool shade); //! Recursively searches the client 'tree' for a modal client, always skips //! the topmost node (the window you're starting with). Client *Client::searchModalTree(Client *node, Client *skip); //! Recursively searches the client 'tree' for a focused client, always skips //! the topmost node (the window you're starting with). Client *Client::searchFocusTree(Client *node, Client *skip); //! Fires the urgent callbacks which lets the user do what they want with //! urgent windows void fireUrgent(); //! Fullscreen's or unfullscreen's the client window /*! @param fs true if the window should be made fullscreen; false if it should be returned to normal state. @param savearea true to have the client's current size and position saved; otherwise, they are not. You should not save when mapping a new window that is set to fullscreen. This has no effect when restoring a window from fullscreen. */ void fullscreen(bool fs, bool savearea = true); //! Iconifies or uniconifies the client window /*! @param iconic true if the window should be iconified; false if it should be restored. @param curdesk If iconic is false, then this determines if the window will be uniconified to the current viewable desktop (true) or to its previous desktop (false) */ void iconify(bool iconic, bool curdesk = true); //! Maximize or unmaximize the client window /*! @param max true if the window should be maximized; false if it should be returned to normal size. @param dir 0 to set both horz and vert, 1 to set horz, 2 to set vert. @param savearea true to have the client's current size and position saved; otherwise, they are not. You should not save when mapping a new window that is set to fullscreen. This has no effect when unmaximizing a window. */ void maximize(bool max, int dir, bool savearea = true); //! Internal version of the Client::move function /*! @param x The X coordinate to move to. @param y The Y coordinate to move to. @param final true if this is the final move, false if there are more move events coming. The client is not notified of the move when final is false. */ void internal_move(int x, int y, bool final = true); //! Internal version of the Client::resize function /*! This also maintains things like the client's minsize, and size increments. @param anchor The corner to keep in the same position when resizing. @param w The width component of the new size for the client. @param h The height component of the new size for the client. @param user Specifies whether this is a user-requested change or a program requested change. @param x An optional X coordinate to which the window will be moved after resizing. @param y An optional Y coordinate to which the window will be moved after resizing. The x and y coordinates must both be sepcified together, or they will have no effect. When they are specified, the anchor is ignored. */ void internal_resize(Corner anchor, int w, int h, bool user = true, int x = INT_MIN, int y = INT_MIN); //! Removes or reapplies the client's border to its window /*! Used when managing and unmanaging a window. @param addborder true if adding the border to the client; false if removing from the client */ void toggleClientBorder(bool addborder); //! Applies the states requested when the window mapped /*! This should be called only once, during the window mapping process. It applies things like maximized, and fullscreen. */ void applyStartupState(); public: //! Constructs a new Client object around a specified window id /*! @param window The window id that the Client class should handle @param screen The screen on which the window resides */ Client(int screen, Window window); //! Destroys the Client object virtual ~Client(); //! Returns the screen on which the clien resides inline int screen() const { return _screen; } //! Returns the window id that the Client object is handling inline Window window() const { return _window; } //! Returns the type of the window, one of the Client::WindowType values inline WindowType type() const { return _type; } //! Returns if the window should be treated as a normal window. /*! Some windows (desktops, docks, splash screens) have special rules applied to them in a number of places regarding focus or user interaction. */ inline bool normal() const { return ! (_type == Type_Desktop || _type == Type_Dock || _type == Type_Splash); } //! Returns the desktop on which the window resides /*! This value is a 0-based index.<br> A value of 0xffffffff indicates that the window exists on all desktops. */ inline unsigned int desktop() const { return _desktop; } //! Returns the window's title inline const otk::ustring &title() const { return _title; } //! Returns the window's title when it is iconified inline const otk::ustring &iconTitle() const { return _title; } //! Returns the application's name to whom the window belongs inline const std::string &appName() const { return _app_name; } //! Returns the class of the window inline const std::string &appClass() const { return _app_class; } //! Returns the program-specified role of the window inline const std::string &role() const { return _role; } //! Returns if the window can be focused /*! @return true if the window can receive focus; otherwise, false */ inline bool canFocus() const { return _can_focus; } //! Returns if the window has indicated that it needs urgent attention inline bool urgent() const { return _urgent; } //! Returns if the window wants to be notified when it receives focus inline bool focusNotify() const { return _focus_notify; } //! Returns if the window is the focused window inline bool focused() const { return _focused; } //! Returns if the window uses the Shape extension inline bool shaped() const { return _shaped; } //! Returns the window's gravity /*! This value determines where to place the decorated window in relation to its position without decorations.<br> One of: NorthWestGravity, SouthWestGravity, EastGravity, ..., SouthGravity, StaticGravity, ForgetGravity */ inline int gravity() const { return _gravity; } //! Returns if the application requested the initial position for the window /*! If the application did not request a position (this function returns false) then the window should be placed intelligently by the window manager initially */ inline bool positionRequested() const { return _positioned; } //! Returns the decorations that the client window wishes to be displayed on //! it inline DecorationFlags decorations() const { return _decorations; } //! Returns the decorations that the user has requested to be disabled on the //! client inline DecorationFlags disabledDecorations() const { return _disabled_decorations; } //! Returns the functions that the user can perform on the window inline FunctionFlags functions() const { return _functions; } //! Return the client this window is transient for inline Client *transientFor() const { return _transient_for; } //! Returns if the window is modal /*! If the window is modal, then no other windows that it is related to can get focus while it exists/remains modal. */ inline bool modal() const { return _modal; } //! The window should not be displayed by pagers inline bool skipPager() const { return _skip_pager; } //! The window should not be displayed by taskbars inline bool skipTaskbar() const { return _skip_taskbar; } //! Returns if the window is shaded /*! When the window is shaded, only its titlebar is visible. */ inline bool shaded() const { return _shaded; } //! Returns if the window is in fullscreen mode inline bool fullscreen() const { return _fullscreen; } //! Returns if the window is iconified /*! When the window is iconified, it is not visible at all (except in iconbars/ panels/etc that want to show lists of iconified windows */ inline bool iconic() const { return _iconic; } //! Returns if the window is maximized vertically inline bool maxVert() const { return _max_vert; } //! Returns if the window is maximized horizontally inline bool maxHorz() const { return _max_horz; } //! Returns the window's stacking layer inline StackLayer layer() const { return _layer; } //! Returns the logical size of the window /*! The "logical" size of the window is refers to the user's perception of the size of the window, and is the value that should be displayed to the user. For example, with xterms, this value it the number of characters being displayed in the terminal, instead of the number of pixels. */ const otk::Size &logicalSize() const { return _logical_size; } //! Returns the position and size of the client relative to the root window /*! Note that this value is *not* the size and position of the window's frame, though the position will often line up.<br> If you want the frame's area, use Frame::area() instead. */ inline const otk::Rect &area() const { return _area; } //! Returns the client's strut definition inline const otk::Strut &strut() const { return _strut; } //! Returns an icon for the window /*! The icon chosen will be the smallest icon available that is still bigger or equal to the specified Size.<br> If none that meet the requirements is found, the largest icon that is smaller than the specified size will be returned. */ const Icon *icon(const otk::Size &s) const; //! Returns the pixmap for the pixmap icon specified on the window (or None) /*! The icon given by Client::icon should take precedence over this icon/mask. */ Pixmap pixmapIcon() const { return _pixmap_icon; } //! Returns the mask for the pixmap icon specified on the window (or None) /*! The icon given by Client::icon should take precedence over this icon/mask. */ Pixmap pixmapIconMask() const { return _pixmap_icon_mask; } //! Move the window (actually, its frame) to a position. /*! This moves the window so that the top-left corner of its frame will be at the position specified. @param x The X coordinate to move to. @param y The Y coordinate to move to. @param final true if this is the final move, false if there are more move events coming. The client is not notified of the move when final is false. */ void move(int x, int y, bool final = true); //! Resizes the client window, anchoring it in a given corner /*! This also maintains things like the client's minsize, and size increments. @param anchor The corner to keep in the same position when resizing. @param w The width component of the new size for the client. @param h The height component of the new size for the client. */ void resize(Corner anchor, int w, int h); //! Reapplies the maximized state to the window /*! Use this to make the window readjust its maximized size to new surroundings (struts, etc). */ void remaximize(); //! Shows the window if it should be shown, or hides it /*! Used when changing desktops, the window's state, etc. */ void showhide(); //! Choose a mask of decorations to not display on the client /*! Pass a value of 0 to the function to turn all decorations back on. Note that you cannot add decorations to a window with this, you can only remove decorations that would otherwise have been displayed. @param flags The mask of values from Client::Decoration to specify which decorations should not be displayed. */ void disableDecorations(DecorationFlags flags); //! Return a modal child of the client window /*! @return A modal child of the client window, or 0 if none was found. */ Client *findModalChild(); //! Attempt to focus the client window bool focus(); //! Remove focus from the client window void unfocus() const; //! Validate client, by making sure no Destroy or Unmap events exist in //! the event queue for the window. /*! @return true if the client is valid; false if the client has already been unmapped/destroyed, and so is invalid. */ bool validate() const; void installColormap(bool install) const; virtual void focusHandler(const XFocusChangeEvent &e); virtual void unfocusHandler(const XFocusChangeEvent &e); virtual void propertyHandler(const XPropertyEvent &e); virtual void clientMessageHandler(const XClientMessageEvent &e); virtual void configureRequestHandler(const XConfigureRequestEvent &e); virtual void unmapHandler(const XUnmapEvent &e); virtual void destroyHandler(const XDestroyWindowEvent &e); virtual void reparentHandler(const XReparentEvent &e); virtual void mapRequestHandler(const XMapRequestEvent &e); #if defined(SHAPE) virtual void shapeHandler(const XShapeEvent &e); #endif // SHAPE friend void Screen::manageWindow(Window); friend void Screen::unmanageWindow(Client *); }; } #endif // __client_hh |