path: root/src/Window.hh

// Window.hh for Fluxbox Window Manager
// Copyright (c) 2001 - 2006 Henrik Kinnunen (fluxgen at fluxbox dot org)
//
// Window.hh for Blackbox - an X11 Window manager
// Copyright (c) 1997 - 2000 Brad Hughes (bhughes at tcac.net)
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

#ifndef WINDOW_HH
#define WINDOW_HH

#include "FbWinFrame.hh"
#include "Focusable.hh"
#include "FocusableTheme.hh"
#include "FocusControl.hh"
#include "WinButton.hh"

#include "FbTk/DefaultValue.hh"
#include "FbTk/Timer.hh"
#include "FbTk/FbTime.hh"
#include "FbTk/EventHandler.hh"
#include "FbTk/LayerItem.hh"
#include "FbTk/Signal.hh"

#include <vector>
#include <string>
#include <memory>
#include <map>
#include <inttypes.h>

class WinClient;
class FbWinFrameTheme;
class BScreen;
class FbMenu;

namespace FbTk {
class TextButton;
class MenuTheme;
class ImageControl;
class Layer;
}

/// Creates the window frame and handles any window event for it
class FluxboxWindow: public Focusable,
                     public FbTk::EventHandler,
                     private FbTk::SignalTracker {
public:
    /// Motif wm Hints
    enum {
        MwmHintsFunctions   = (1l << 0), ///< use motif wm functions
        MwmHintsDecorations = (1l << 1) ///< use motif wm decorations
    };

    /// Motif wm functions
    enum MwmFunc{
        MwmFuncAll          = (1l << 0), ///< all motif wm functions
        MwmFuncResize       = (1l << 1), ///< resize
        MwmFuncMove         = (1l << 2), ///< move
        MwmFuncIconify      = (1l << 3), ///< iconify
        MwmFuncMaximize     = (1l << 4), ///< maximize
        MwmFuncClose        = (1l << 5)  ///< close
    };

    /// Motif wm decorations
    enum MwmDecor {
        MwmDecorAll         = (1l << 0), /// all decorations
        MwmDecorBorder      = (1l << 1), /// border
        MwmDecorHandle      = (1l << 2), /// handle
        MwmDecorTitle       = (1l << 3), /// title
        MwmDecorMenu        = (1l << 4), /// menu
        MwmDecorIconify     = (1l << 5), /// iconify
        MwmDecorMaximize    = (1l << 6)  /// maximize
    };

    /// Different resize modes when resizing a window
    enum ResizeModel {
        CENTERRESIZE,                     ///< resizes from center
        TOPLEFTRESIZE,                    ///< resizes top left corner
        TOPRESIZE,                        ///< resizes top edge
        TOPRIGHTRESIZE,                   ///< resizes top right corner
        LEFTRESIZE,                       ///< resizes left edge
        RIGHTRESIZE,                      ///< resizes right edge
        BOTTOMLEFTRESIZE,                 ///< resizes bottom left corner
        BOTTOMRESIZE,                     ///< resizes bottom edge
        BOTTOMRIGHTRESIZE,                ///< resizes bottom right corner
        EDGEORCORNERRESIZE,               ///< resizes nearest edge or corner
        DEFAULTRESIZE = BOTTOMRIGHTRESIZE ///< default resize mode
    };

    /**
     * Reference corner for moves and resizes
     */
     enum ReferenceCorner {
         ERROR        = -1,
         LEFTTOP      = 0,
         TOP          = 1,
         RIGHTTOP     = 2,
         RIGHT        = 3,
         RIGHTBOTTOM  = 4,
         BOTTOM       = 5,
         LEFTBOTTOM   = 6,
         LEFT         = 7,
         CENTER       = 8
    };

    typedef std::list<WinClient *> ClientList;

    /// create a window from a client
    FluxboxWindow(WinClient &client);

    virtual ~FluxboxWindow();

    /// attach client to our client list and remove it from old window
    void attachClient(WinClient &client, int x=-1, int y=-1);
    /// detach client (remove it from list) and create a new window for it
    bool detachClient(WinClient &client);
    /// detach current working client if we have more than one
    void detachCurrentClient();
    /// remove client from client list
    bool removeClient(WinClient &client);
    /// set new current client and raise it
    bool setCurrentClient(WinClient &client, bool setinput = true);
    /**
     * Searches for a client
     * @param win the client X window
     * @return pointer to client matching the window or NULL
     */
    WinClient *findClient(Window win);
    /// select next client
    void nextClient();
    /// select previous client
    void prevClient();
    /// move the current client to the left
    void moveClientLeft();
    /// move the current client to the right
    void moveClientRight();
    /**
     * Move a client to the right of dest.
     * @param win the client to move
     * @param dest the left-of-client
     */
    void moveClientRightOf(WinClient &win, WinClient &dest);
    /**
     * Move a client to the right of dest.
     * @param win the client to move
     * @param dest the left-of-client
     */
    void moveClientLeftOf(WinClient &win, WinClient &dest);
    /**
     * Move client to place specified by pixel position
     * @param win the client to move
     * @param x position
     * @param y position
     */
    void moveClientTo(WinClient &win, int x, int y);
    /**
     * Take focus.
     * @see Focusable
     * @return true if it took focus.
     */
    bool focus();
    bool focusRequestFromClient(WinClient &from);

    /// Raises the window and takes focus (if possible).
    void raiseAndFocus() { raise(); focus(); }
    /// sets the internal focus flag
    void setFocusFlag(bool flag);
    /// make this window visible
    void show();
    /// hide window
    void hide(bool interrupt_moving = true);
    /// iconify window
    void iconify();
    /**
     * Deiconify window
     * @param do_raise raise the window when its been deiconfied
     */
    void deiconify(bool do_raise = true);

    // ------------------
    // Per window transparency addons
    int getFocusedAlpha() const { return frame().getAlpha(true); }
    int getUnfocusedAlpha() const { return frame().getAlpha(false); }
    void setFocusedAlpha(int alpha) { frame().setAlpha(true, alpha); }
    void setUnfocusedAlpha(int alpha) { frame().setAlpha(false, alpha); }
    void updateAlpha(bool focused, int alpha)  { frame().setAlpha(focused, alpha); }

    bool getUseDefaultAlpha() const { return frame().getUseDefaultAlpha(); }
    void setDefaultAlpha() { frame().setDefaultAlpha(); }
    // ------------------

    /// close current client
    void close();
    /// kill current client
    void kill();
    /// set fullscreen
    void setFullscreen(bool flag);
    /// toggle maximize
    void maximize(int type = WindowState::MAX_FULL);
    /// sets the maximized state
    void setMaximizedState(int type);
    /// maximizes the window horizontal
    void maximizeHorizontal();
    /// maximizes the window vertical
    void maximizeVertical();
    /// maximizes the window fully
    void maximizeFull();

    /// disables maximization, without restoring the old size
    void disableMaximization();

    /// toggles shade
    void shade();
    /// shades window
    void shadeOn();
    /// unshades window
    void shadeOff();
    /// sets shaded state
    void setShaded(bool val);
    /// toggles sticky
    void stick();
    /// sets stuck state
    void setStuck(bool val);
    /// toggles iconic
    void toggleIconic();
    /// sets iconic state
    void setIconic(bool val);
    void raise();
    void lower();
    void tempRaise();
    void changeLayer(int diff);
    /// moves the window to a new layer
    void moveToLayer(int layernum, bool force = false);
    int getOnHead() const;
    void setOnHead(int head);
    /// sets the window focus hidden state
    void placeWindow(int head);
    void setFocusHidden(bool value);
    /// sets the window icon hidden state
    void setIconHidden(bool value);
    /// sets whether or not the window normally gets focus when mapped
    void setFocusNew(bool value) { m_focus_new = value; }
    /// sets whether or not the window gets focused with mouse
    void setMouseFocus(bool value) { m_mouse_focus = value; }
    /// sets whether or not the window gets focused with click
    void setClickFocus(bool value) { m_click_focus = value; }
    void reconfigure();


    void installColormap(bool);
    void restore(WinClient *client, bool remap);
    void restore(bool remap);
    /// move frame to x, y
    void move(int x, int y);
    /// resize frame to width, height
    void resize(unsigned int width, unsigned int height);
    /// move and resize frame to pox x,y and size width, height
    void moveResize(int x, int y, unsigned int width, unsigned int height, bool send_event = false);
    /// move to pos x,y and resize client window to size width, height
    void moveResizeForClient(int x, int y, unsigned int width, unsigned int height, int gravity = ForgetGravity, unsigned int client_bw = 0);
    /**
     * Determines maximum size using all clients that this window can have.
     * @param width will be filled in with maximum width
     * @param height will be filled in with maximum height
     */
    void getMaxSize(unsigned int* width, unsigned int* height) const;
    void setWorkspace(int n);
    void updateFunctions();
    /**
     * Show window meny at at given position
     * @param mx position
     * @param my position
     */
    void showMenu(int mx, int my);

    /** popup window menu at specific location
     * @param x 
     * @param y
     */
    void popupMenu(int x, int y);
    // popup menu on last button press position
    void popupMenu();

    /**
       @name event handlers
    */
    //@{
    void handleEvent(XEvent &event);
    void keyPressEvent(XKeyEvent &ke);
    void buttonPressEvent(XButtonEvent &be);
    void buttonReleaseEvent(XButtonEvent &be);
    void motionNotifyEvent(XMotionEvent &me);
    void destroyNotifyEvent(XDestroyWindowEvent &dwe);
    void mapRequestEvent(XMapRequestEvent &mre);
    void mapNotifyEvent(XMapEvent &mapev);
    void unmapNotifyEvent(XUnmapEvent &unmapev);
    void exposeEvent(XExposeEvent &ee);
    void configureRequestEvent(XConfigureRequestEvent &ce);
    void propertyNotifyEvent(WinClient &client, Atom a);
    void enterNotifyEvent(XCrossingEvent &ev);
    void leaveNotifyEvent(XCrossingEvent &ev);
    //@}

    void applyDecorations();
    void toggleDecoration();

    unsigned int decorationMask() const;
    void setDecorationMask(unsigned int mask, bool apply = true);
    /**
     * Start moving process, grabs the pointer and draws move rectangle
     * @param x position of pointer
     * @param y position of pointer
     */
    void startMoving(int x, int y);
    /**
     * Stop moving process
     * @param interrupted whether the move was interrupted by hide or destroy
     */
    void stopMoving(bool interrupted = false);
    /**
     * Starts resizing process
     * @param x start position
     * @param y start position
     * @param dir the resize direction
     */
    void startResizing(int x, int y, ReferenceCorner dir);
    /// determine which edge or corner to resize
    ReferenceCorner getResizeDirection(int x, int y, ResizeModel model, int corner_size_px, int corner_size_pc) const;
    /// stops the resizing
    void stopResizing(bool interrupted = false);
    /// starts tabbing
    void startTabbing(const XButtonEvent &be);

    /// determine the reference corner from a string
    static ReferenceCorner getCorner(std::string str);
    /// convert to coordinates on the root window
    void translateXCoords(int &x, ReferenceCorner dir = LEFTTOP) const;
    void translateYCoords(int &y, ReferenceCorner dir = LEFTTOP) const;
    void translateCoords(int &x, int &y, ReferenceCorner dir = LEFTTOP) const;

    /**
       @name accessors
    */
    //@{

    // whether this window can be tabbed with other windows,
    // and others tabbed with it
    void setTabable(bool tabable) { functions.tabable = tabable; }
    bool isTabable() const { return functions.tabable; }
    void setMovable(bool movable) { functions.move = movable; }
    void setResizable(bool resizable) { functions.resize = resizable; }

    bool isFocusHidden() const { return m_state.focus_hidden; }
    bool isIconHidden() const { return m_state.icon_hidden; }
    bool isManaged() const { return m_initialized; }
    bool isVisible() const;
    bool isIconic() const { return m_state.iconic; }
    bool isShaded() const { return m_state.shaded; }
    bool isFullscreen() const { return m_state.fullscreen; }
    bool isMaximized() const { return m_state.isMaximized(); }
    bool isMaximizedVert() const { return m_state.isMaximizedVert(); }
    bool isMaximizedHorz() const { return m_state.isMaximizedHorz(); }
    int maximizedState() const { return m_state.maximized; }
    bool isIconifiable() const { return functions.iconify; }
    bool isMaximizable() const { return functions.maximize; }
    bool isResizable() const { return functions.resize; }
    bool isClosable() const { return functions.close; }
    bool isMoveable() const { return functions.move; }
    bool isStuck() const { return m_state.stuck; }
    bool isFocusNew() const { return m_focus_new; }
    bool hasTitlebar() const { return decorations.titlebar; }
    bool isMoving() const { return moving; }
    bool isResizing() const { return resizing; }
    bool isGroupable() const;
    int numClients() const { return m_clientlist.size(); }
    bool empty() const { return m_clientlist.empty(); }
    ClientList &clientList() { return m_clientlist; }
    const ClientList &clientList() const { return m_clientlist; }
    WinClient &winClient() { return *m_client; }
    const WinClient &winClient() const { return *m_client; }

    WinClient* winClientOfLabelButtonWindow(Window w);

    bool isTyping() const;

    const FbTk::LayerItem &layerItem() const { return m_frame.layerItem(); }
    FbTk::LayerItem &layerItem() { return m_frame.layerItem(); }

    Window clientWindow() const;

    FbTk::FbWindow &fbWindow();
    const FbTk::FbWindow &fbWindow() const;

    FbMenu &menu();
    const FbMenu &menu() const;

    const FbTk::FbWindow &parent() const { return m_parent; }
    FbTk::FbWindow &parent() { return m_parent; }

    bool acceptsFocus() const;
    bool isModal() const;
    const FbTk::PixmapWithMask &icon() const;
    const FbTk::BiDiString &title() const;
    const FbTk::FbString &getWMClassName() const;
    const FbTk::FbString &getWMClassClass() const;
    std::string getWMRole() const;
    long getCardinalProperty(Atom prop,bool*exists=NULL) const;
    FbTk::FbString getTextProperty(Atom prop,bool*exists=NULL) const;
    void setWindowType(WindowState::WindowType type);
    bool isTransient() const;

    int x() const { return frame().x(); }
    int y() const { return frame().y(); }
    unsigned int width() const { return frame().width(); }
    unsigned int height() const { return frame().height(); }

    int normalX() const { return m_state.x; }
    int normalY() const { return m_state.y; }
    unsigned int normalWidth() const { return m_state.width; }
    unsigned int normalHeight() const { return m_state.height; }

    int xOffset() const { return frame().xOffset(); }
    int yOffset() const { return frame().yOffset(); }
    int widthOffset() const { return frame().widthOffset(); }
    int heightOffset() const { return frame().heightOffset(); }

    unsigned int workspaceNumber() const { return m_workspace_number; }

    int layerNum() const { return m_state.layernum; }
    void setLayerNum(int layernum);

    unsigned int titlebarHeight() const;

    int initialState() const;

    FbWinFrame &frame() { return m_frame; }
    const FbWinFrame &frame() const { return m_frame; }

    /**
       @name signals
       @{
    */
    FbTk::Signal<FluxboxWindow &> &stateSig() { return m_statesig; }
    FbTk::Signal<FluxboxWindow &> &layerSig() { return m_layersig; }
    FbTk::Signal<FluxboxWindow &> &hintSig() { return m_hintsig; }
    FbTk::Signal<FluxboxWindow &> &workspaceSig() { return m_workspacesig; }
    /** @} */ // end group signals

    //@}

    bool oplock; ///< Used to help stop transient loops occurring by locking a window during certain operations

private:
    /// signal callback for title changes by clients
    void setTitle(const std::string &title, Focusable &client);

    void setupWindow();
    void updateButtons();

    void init();
    void updateClientLeftWindow();
    void grabButtons();

    void themeReconfigured();

    /**
     * Calculates insertition position in the list by
     * using pixel position x and y.
     * @param x position
     * @param y position
     * @return iterator position for insertion
     */
    ClientList::iterator getClientInsertPosition(int x, int y);

    /// try to attach current attaching client to a window at pos x, y
    void attachTo(int x, int y, bool interrupted = false);

    bool getState();
    void updateMWMHintsFromClient(WinClient &client);
    void updateSizeHints();
    void associateClientWindow();

    void setState(unsigned long stateval, bool setting_up);
    /// set the layer of a fullscreen window
    void setFullscreenLayer();
    void attachWorkAreaSig();

    // modifies left and top if snap is necessary
    void doSnapping(int &left, int &top, bool resize = false);
    // user_w/h return the values that should be shown to the user
    void fixSize();
    void moveResizeClient(WinClient &client);
    /// sends configurenotify to all clients
    void sendConfigureNotify();

    static void grabPointer(Window grab_window,
                     Bool owner_events,
                     unsigned int event_mask,
                     int pointer_mode, int keyboard_mode,
                     Window confine_to,
                     Cursor cursor,
                     Time time);
    static void ungrabPointer(Time time);

    void associateClient(WinClient &client);
    /// Called when focused changed, and is attached when it is not in fullscreen mode
    void focusedWindowChanged(BScreen &screen, FluxboxWindow *focused_win, WinClient* client);
    /// Called when workspace area on screen changed.
    void workspaceAreaChanged(BScreen &screen);
    void frameExtentChanged();


    // state and hint signals
    FbTk::Signal<FluxboxWindow &> m_workspacesig, m_statesig, m_layersig, m_hintsig;

    uint64_t m_creation_time;
    uint64_t m_last_keypress_time;
    FbTk::Timer m_timer;

    // Window states
    bool moving, resizing, m_initialized;

    WinClient *m_attaching_tab;

    Display *display; /// display connection

    int m_button_grab_x, m_button_grab_y; // handles last button press event for move
    int m_last_resize_x, m_last_resize_y; // handles last button press event for resize
    int m_last_move_x, m_last_move_y; // handles last pos for non opaque moving
    int m_last_resize_h, m_last_resize_w; // handles height/width for resize "window"
    int m_last_pressed_button;

    unsigned int m_workspace_number;
    unsigned long m_current_state; // NormalState | IconicState | Withdrawn

    unsigned int m_old_decoration_mask;

    ClientList m_clientlist;
    WinClient *m_client; ///< current client
    typedef std::map<WinClient *, IconButton *> Client2ButtonMap;
    Client2ButtonMap m_labelbuttons;

    SizeHints m_size_hint;
    struct {
        bool titlebar:1, handle:1, border:1, iconify:1,
            maximize:1, close:1, menu:1, sticky:1, shade:1, tab:1, enabled:1;
    } decorations;

    std::vector<WinButton::Type> m_titlebar_buttons[2];
    bool m_toggled_decos;

    struct {
        bool resize:1, move:1, iconify:1, maximize:1, close:1, tabable:1;
    } functions;

    typedef FbTk::ConstObjectAccessor<bool, FocusControl> BoolAcc;
    /// if the window is normally focused when mapped
    FbTk::DefaultValue<bool, BoolAcc> m_focus_new;
    /// if the window is focused with EnterNotify
    FbTk::DefaultValue<bool, BoolAcc> m_mouse_focus;
    bool m_click_focus;  ///< if the window is focused by clicking
    int m_last_button_x, ///< last known x position of the mouse button
        m_last_button_y; ///< last known y position of the mouse button

    FocusableTheme<WinButtonTheme> m_button_theme;
    FocusableTheme<FbWinFrameTheme> m_theme;

    WindowState m_state;
    FbWinFrame m_frame;  ///< the actual window frame

    bool m_placed; ///< determine whether or not we should place the window

    int m_old_layernum;

    FbTk::FbWindow &m_parent; ///< window on which we draw move/resize rectangle  (the "root window")

    ReferenceCorner m_resize_corner; //< the current corner used while resizing

    static int s_num_grabs; ///< number of XGrabPointer's
};


#endif // WINDOW_HH