{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, ViewPatterns #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE DefaultSignatures #-} ----------------------------------------------------------------------------- -- | -- Module : XMonad.Layout.DecorationEx.Engine -- Description : Type class and its default implementation for window decoration engines. -- Copyright : (c) 2007 Andrea Rossato, 2009 Jan Vornberger, 2023 Ilya Portnov -- License : BSD-style (see xmonad/LICENSE) -- -- Maintainer : portnov84@rambler.ru -- Stability : unstable -- Portability : unportable -- -- This module defines @DecorationEngine@ type class, and default implementation for it. ----------------------------------------------------------------------------- module XMonad.Layout.DecorationEx.Engine ( -- * DecorationEngine class DecorationEngine (..), -- * Auxiliary data types DrawData (..), DecorationLayoutState (..), -- * Re-exports from X.L.Decoration Shrinker (..), shrinkText, -- * Utility functions mkDrawData, paintDecorationSimple ) where import Control.Monad import Data.Kind import Foreign.C.Types (CInt) import XMonad import XMonad.Prelude import qualified XMonad.StackSet as W import XMonad.Layout.Decoration (Shrinker (..), shrinkWhile, shrinkText) import XMonad.Layout.DraggingVisualizer (DraggingVisualizerMsg (..)) import XMonad.Layout.DecorationAddons (handleScreenCrossing) import XMonad.Util.Font import XMonad.Util.NamedWindows (getName) import XMonad.Layout.DecorationEx.Common -- | Auxiliary type for data which are passed from -- decoration layout modifier to decoration engine. data DrawData engine widget = DrawData { ddEngineState :: !(DecorationEngineState engine) -- ^ Decoration engine state , ddStyle :: !(Style (Theme engine widget)) -- ^ Graphics style of the decoration. This defines colors, fonts etc -- which are to be used for this particular window in it's current state. , ddOrigWindow :: !Window -- ^ Original window to be decorated , ddWindowTitle :: !String -- ^ Original window title (not shrinked yet) , ddDecoRect :: !Rectangle -- ^ Decoration rectangle , ddWidgets :: !(WidgetLayout widget) -- ^ Widgets to be placed on decoration , ddWidgetPlaces :: !(WidgetLayout WidgetPlace) -- ^ Places where widgets must be shown } -- | State of decoration engine data DecorationLayoutState engine = DecorationLayoutState { dsStyleState :: !(DecorationEngineState engine) -- ^ Engine-specific state , dsDecorations :: ![WindowDecoration] -- ^ Mapping between decoration windows and original windows } -- | Decoration engines type class. -- Decoration engine is responsible for drawing something inside decoration rectangle. -- It is also responsible for handling X11 events (such as clicks) which happen -- within decoration rectangle. -- Decoration rectangles are defined by DecorationGeometry implementation. class (Read (engine widget a), Show (engine widget a), Eq a, DecorationWidget widget, HasWidgets (Theme engine) widget, ClickHandler (Theme engine) widget, ThemeAttributes (Theme engine widget)) => DecorationEngine engine widget a where -- | Type of themes used by decoration engine. -- This type must be parameterized over a widget type, -- because a theme will contain a list of widgets. type Theme engine :: Type -> Type -- | Type of data used by engine as a context during painting; -- for plain X11-based implementation this is Display, Pixmap -- and GC. type DecorationPaintingContext engine -- | Type of state used by the decoration engine. -- This can contain some resources that should be initialized -- and released at time, such as X11 fonts. type DecorationEngineState engine -- | Give a name to decoration engine. describeEngine :: engine widget a -> String -- | Initialize state of the engine. initializeState :: engine widget a -- ^ Decoration engine instance -> geom a -- ^ Decoration geometry instance -> Theme engine widget -- ^ Theme to be used -> X (DecorationEngineState engine) -- | Release resources held in engine state. releaseStateResources :: engine widget a -- ^ Decoration engine instance -> DecorationEngineState engine -- ^ Engine state -> X () -- | Calculate place which will be occupied by one widget. -- NB: X coordinate of the returned rectangle will be ignored, because -- the rectangle will be moved to the right or to the left for proper alignment -- of widgets. calcWidgetPlace :: engine widget a -- ^ Decoration engine instance -> DrawData engine widget -- ^ Information about window and decoration -> widget -- ^ Widget to be placed -> X WidgetPlace -- | Place widgets along the decoration bar. placeWidgets :: Shrinker shrinker => engine widget a -- ^ Decoration engine instance -> Theme engine widget -- ^ Theme to be used -> shrinker -- ^ Strings shrinker -> DecorationEngineState engine -- ^ Current state of the engine -> Rectangle -- ^ Decoration rectangle -> Window -- ^ Original window to be decorated -> WidgetLayout widget -- ^ Widgets layout -> X (WidgetLayout WidgetPlace) placeWidgets engine theme _ decoStyle decoRect window wlayout = do let leftWidgets = wlLeft wlayout rightWidgets = wlRight wlayout centerWidgets = wlCenter wlayout dd <- mkDrawData engine theme decoStyle window decoRect let paddedDecoRect = pad (widgetsPadding theme) (ddDecoRect dd) paddedDd = dd {ddDecoRect = paddedDecoRect} rightRects <- alignRight engine paddedDd rightWidgets leftRects <- alignLeft engine paddedDd leftWidgets let wantedLeftWidgetsWidth = sum $ map (rect_width . wpRectangle) leftRects wantedRightWidgetsWidth = sum $ map (rect_width . wpRectangle) rightRects hasShrinkableOnLeft = any isShrinkable leftWidgets hasShrinkableOnRight = any isShrinkable rightWidgets decoWidth = rect_width decoRect (leftWidgetsWidth, rightWidgetsWidth) | hasShrinkableOnLeft = (min (decoWidth - wantedRightWidgetsWidth) wantedLeftWidgetsWidth, wantedRightWidgetsWidth) | hasShrinkableOnRight = (wantedLeftWidgetsWidth, min (decoWidth - wantedLeftWidgetsWidth) wantedRightWidgetsWidth) | otherwise = (wantedLeftWidgetsWidth, wantedRightWidgetsWidth) ddForCenter = paddedDd {ddDecoRect = padCenter leftWidgetsWidth rightWidgetsWidth paddedDecoRect} centerRects <- alignCenter engine ddForCenter centerWidgets let shrinkedLeftRects = packLeft (rect_x paddedDecoRect) $ shrinkPlaces leftWidgetsWidth $ zip leftRects (map isShrinkable leftWidgets) shrinkedRightRects = packRight (rect_width paddedDecoRect) $ shrinkPlaces rightWidgetsWidth $ zip rightRects (map isShrinkable rightWidgets) return $ WidgetLayout shrinkedLeftRects centerRects shrinkedRightRects where shrinkPlaces targetWidth ps = let nShrinkable = length (filter snd ps) totalUnshrinkedWidth = sum $ map (rect_width . wpRectangle . fst) $ filter (not . snd) ps shrinkedWidth = (targetWidth - totalUnshrinkedWidth) `div` fi nShrinkable resetX place = place {wpRectangle = (wpRectangle place) {rect_x = 0}} adjust (place, True) = resetX $ place {wpRectangle = (wpRectangle place) {rect_width = shrinkedWidth}} adjust (place, False) = resetX place in map adjust ps pad p (Rectangle _ _ w h) = Rectangle (fi (bxLeft p)) (fi (bxTop p)) (w - bxLeft p - bxRight p) (h - bxTop p - bxBottom p) padCenter left right (Rectangle x y w h) = Rectangle (x + fi left) y (w - left - right) h -- | Shrink window title so that it would fit in decoration. getShrinkedWindowName :: Shrinker shrinker => engine widget a -- ^ Decoration engine instance -> shrinker -- ^ Strings shrinker -> DecorationEngineState engine -- ^ State of decoration engine -> String -- ^ Original window title -> Dimension -- ^ Width of rectangle in which the title should fit -> Dimension -- ^ Height of rectangle in which the title should fit -> X String default getShrinkedWindowName :: (Shrinker shrinker, DecorationEngineState engine ~ XMonadFont) => engine widget a -> shrinker -> DecorationEngineState engine -> String -> Dimension -> Dimension -> X String getShrinkedWindowName _ shrinker font name wh _ = do let s = shrinkIt shrinker dpy <- asks display shrinkWhile s (\n -> do size <- io $ textWidthXMF dpy font n return $ size > fromIntegral wh) name -- | Mask of X11 events on which the decoration engine should do something. -- @exposureMask@ should be included here so that decoration engine could -- repaint decorations when they are shown on screen. -- @buttonPressMask@ should be included so that decoration engine could -- response to mouse clicks. -- Other events can be added to custom implementations of DecorationEngine. decorationXEventMask :: engine widget a -> EventMask decorationXEventMask _ = exposureMask .|. buttonPressMask -- | List of X11 window property atoms of original (client) windows, -- change of which should trigger repainting of decoration. -- For example, if @WM_NAME@ changes it means that we have to redraw -- window title. propsToRepaintDecoration :: engine widget a -> X [Atom] propsToRepaintDecoration _ = mapM getAtom ["WM_NAME", "_NET_WM_NAME", "WM_STATE", "WM_HINTS"] -- | Generic event handler, which recieves X11 events on decoration -- window. -- Default implementation handles mouse clicks and drags. decorationEventHookEx :: Shrinker shrinker => engine widget a -> Theme engine widget -> DecorationLayoutState engine -> shrinker -> Event -> X () decorationEventHookEx = handleMouseFocusDrag -- | Event handler for clicks on decoration window. -- This is called from default implementation of "decorationEventHookEx". -- This should return True, if the click was handled (something happened -- because of that click). If this returns False, the click can be considered -- as a beginning of mouse drag. handleDecorationClick :: engine widget a -- ^ Decoration engine instance -> Theme engine widget -- ^ Decoration theme -> Rectangle -- ^ Decoration rectangle -> [Rectangle] -- ^ Rectangles where widgets are placed -> Window -- ^ Original (client) window -> Int -- ^ Mouse click X coordinate -> Int -- ^ Mouse click Y coordinate -> Int -- ^ Mouse button number -> X Bool handleDecorationClick = decorationHandler -- | Event handler which is called during mouse dragging. -- This is called from default implementation of "decorationEventHookEx". decorationWhileDraggingHook :: engine widget a -- ^ Decoration engine instance -> CInt -- ^ Event X coordinate -> CInt -- ^ Event Y coordinate -> (Window, Rectangle) -- ^ Original window and it's rectangle -> Position -- ^ X coordinate of new pointer position during dragging -> Position -- ^ Y coordinate of new pointer position during dragging -> X () decorationWhileDraggingHook _ = handleDraggingInProgress -- | This hoook is called after a window has been dragged using the decoration. -- This is called from default implementation of "decorationEventHookEx". decorationAfterDraggingHook :: engine widget a -- ^ Decoration engine instance -> (Window, Rectangle) -- ^ Original window and its rectangle -> Window -- ^ Decoration window -> X () decorationAfterDraggingHook _ds (w, _r) decoWin = do focus w hasCrossed <- handleScreenCrossing w decoWin unless hasCrossed $ do sendMessage DraggingStopped performWindowSwitching w -- | Draw everything required on the decoration window. -- This method should draw background (flat or gradient or whatever), -- borders, and call @paintWidget@ method to draw window widgets -- (buttons and title). paintDecoration :: Shrinker shrinker => engine widget a -- ^ Decoration engine instance -> a -- ^ Decoration window -> Dimension -- ^ Decoration window width -> Dimension -- ^ Decoration window height -> shrinker -- ^ Strings shrinker instance -> DrawData engine widget -- ^ Details about what to draw -> Bool -- ^ True when this method is called during Expose event -> X () -- | Paint one widget on the decoration window. paintWidget :: Shrinker shrinker => engine widget a -- ^ Decoration engine instance -> DecorationPaintingContext engine -- ^ Decoration painting context -> WidgetPlace -- ^ Place (rectangle) where the widget should be drawn -> shrinker -- ^ Strings shrinker instance -> DrawData engine widget -- ^ Details about window decoration -> widget -- ^ Widget to be drawn -> Bool -- ^ True when this method is called during Expose event -> X () handleDraggingInProgress :: CInt -> CInt -> (Window, Rectangle) -> Position -> Position -> X () handleDraggingInProgress ex ey (mainw, r) x y = do let rect = Rectangle (x - (fi ex - rect_x r)) (y - (fi ey - rect_y r)) (rect_width r) (rect_height r) sendMessage $ DraggingWindow mainw rect performWindowSwitching :: Window -> X () performWindowSwitching win = withDisplay $ \d -> do root <- asks theRoot (_, _, selWin, _, _, _, _, _) <- io $ queryPointer d root ws <- gets windowset let allWindows = W.index ws -- do a little double check to be sure when ((win `elem` allWindows) && (selWin `elem` allWindows)) $ do let allWindowsSwitched = map (switchEntries win selWin) allWindows let (ls, notEmpty -> t :| rs) = break (win ==) allWindowsSwitched let newStack = W.Stack t (reverse ls) rs windows $ W.modify' $ const newStack where switchEntries a b x | x == a = b | x == b = a | otherwise = x ignoreX :: WidgetPlace -> WidgetPlace ignoreX place = place {wpRectangle = (wpRectangle place) {rect_x = 0}} alignLeft :: forall engine widget a. DecorationEngine engine widget a => engine widget a -> DrawData engine widget -> [widget] -> X [WidgetPlace] alignLeft engine dd widgets = do places <- mapM (calcWidgetPlace engine dd) widgets return $ packLeft (rect_x $ ddDecoRect dd) $ map ignoreX places packLeft :: Position -> [WidgetPlace] -> [WidgetPlace] packLeft _ [] = [] packLeft x0 (place : places) = let rect = wpRectangle place x' = x0 + rect_x rect rect' = rect {rect_x = x'} place' = place {wpRectangle = rect'} in place' : packLeft (x' + fi (rect_width rect)) places alignRight :: forall engine widget a. DecorationEngine engine widget a => engine widget a -> DrawData engine widget -> [widget] -> X [WidgetPlace] alignRight engine dd widgets = do places <- mapM (calcWidgetPlace engine dd) widgets return $ packRight (rect_width $ ddDecoRect dd) $ map ignoreX places packRight :: Dimension -> [WidgetPlace] -> [WidgetPlace] packRight x0 places = reverse $ go x0 places where go _ [] = [] go x (place : rest) = let rect = wpRectangle place x' = x - rect_width rect rect' = rect {rect_x = fi x'} place' = place {wpRectangle = rect'} in place' : go x' rest alignCenter :: forall engine widget a. DecorationEngine engine widget a => engine widget a -> DrawData engine widget -> [widget] -> X [WidgetPlace] alignCenter engine dd widgets = do places <- alignLeft engine dd widgets let totalWidth = sum $ map (rect_width . wpRectangle) places availableWidth = fi (rect_width (ddDecoRect dd)) :: Position x0 = max 0 $ (availableWidth - fi totalWidth) `div` 2 places' = map (shift x0) places return $ pack (fi availableWidth) places' where shift x0 place = let rect = wpRectangle place rect' = rect {rect_x = rect_x rect + fi x0} in place {wpRectangle = rect'} pack _ [] = [] pack available (place : places) = let rect = wpRectangle place placeWidth = rect_width rect widthToUse = min available placeWidth remaining = available - widthToUse rect' = rect {rect_width = widthToUse} place' = place {wpRectangle = rect'} in place' : pack remaining places -- | Build an instance of 'DrawData' type. mkDrawData :: (DecorationEngine engine widget a, ThemeAttributes (Theme engine widget), HasWidgets (Theme engine) widget) => engine widget a -> Theme engine widget -- ^ Decoration theme -> DecorationEngineState engine -- ^ State of decoration engine -> Window -- ^ Original window (to be decorated) -> Rectangle -- ^ Decoration rectangle -> X (DrawData engine widget) mkDrawData _ theme decoState origWindow decoRect = do -- xmonad-contrib #809 -- qutebrowser will happily shovel a 389K multiline string into @_NET_WM_NAME@ -- and the 'defaultShrinker' (a) doesn't handle multiline strings well (b) is -- quadratic due to using 'init' name <- fmap (take 2048 . takeWhile (/= '\n') . show) (getName origWindow) style <- selectWindowStyle theme origWindow return $ DrawData { ddEngineState = decoState, ddStyle = style, ddOrigWindow = origWindow, ddWindowTitle = name, ddDecoRect = decoRect, ddWidgets = themeWidgets theme, ddWidgetPlaces = WidgetLayout [] [] [] } -- | Mouse focus and mouse drag are handled by the same function, this -- way we can start dragging unfocused windows too. handleMouseFocusDrag :: (DecorationEngine engine widget a, Shrinker shrinker) => engine widget a -> Theme engine widget -> DecorationLayoutState engine -> shrinker -> Event -> X () handleMouseFocusDrag ds theme (DecorationLayoutState {dsDecorations}) _ (ButtonEvent {ev_window, ev_x_root, ev_y_root, ev_event_type, ev_button}) | ev_event_type == buttonPress , Just (WindowDecoration {..}) <- findDecoDataByDecoWindow ev_window dsDecorations = do let decoRect@(Rectangle dx dy _ _) = fromJust wdDecoRect x = fi $ ev_x_root - fi dx y = fi $ ev_y_root - fi dy button = fi ev_button dealtWith <- handleDecorationClick ds theme decoRect (map wpRectangle wdWidgets) wdOrigWindow x y button unless dealtWith $ when (isDraggingEnabled theme button) $ mouseDrag (\dragX dragY -> focus wdOrigWindow >> decorationWhileDraggingHook ds ev_x_root ev_y_root (wdOrigWindow, wdOrigWinRect) dragX dragY) (decorationAfterDraggingHook ds (wdOrigWindow, wdOrigWinRect) ev_window) handleMouseFocusDrag _ _ _ _ _ = return () -- | Given a window and the state, if a matching decoration is in the -- state return it with its ('Maybe') 'Rectangle'. findDecoDataByDecoWindow :: Window -> [WindowDecoration] -> Maybe WindowDecoration findDecoDataByDecoWindow decoWin = find (\dd -> wdDecoWindow dd == Just decoWin) decorationHandler :: forall engine widget a. (DecorationEngine engine widget a, ClickHandler (Theme engine) widget) => engine widget a -> Theme engine widget -> Rectangle -> [Rectangle] -> Window -> Int -> Int -> Int -> X Bool decorationHandler _ theme _ widgetPlaces window x y button = do widgetDone <- go $ zip (widgetLayout $ themeWidgets theme) widgetPlaces if widgetDone then return True else case onDecorationClick theme button of Just cmd -> do executeWindowCommand cmd window Nothing -> return False where go :: [(widget, Rectangle)] -> X Bool go [] = return False go ((w, rect) : rest) = do if pointWithin (fi x) (fi y) rect then do executeWindowCommand (widgetCommand w button) window else go rest -- | Simple implementation of @paintDecoration@ method. -- This is used by @TextEngine@ and can be re-used by other decoration -- engines. paintDecorationSimple :: forall engine shrinker widget. (DecorationEngine engine widget Window, DecorationPaintingContext engine ~ XPaintingContext, Shrinker shrinker, Style (Theme engine widget) ~ SimpleStyle) => engine widget Window -> Window -> Dimension -> Dimension -> shrinker -> DrawData engine widget -> Bool -> X () paintDecorationSimple deco win windowWidth windowHeight shrinker dd isExpose = do dpy <- asks display let widgets = widgetLayout $ ddWidgets dd style = ddStyle dd pixmap <- io $ createPixmap dpy win windowWidth windowHeight (defaultDepthOfScreen $ defaultScreenOfDisplay dpy) gc <- io $ createGC dpy pixmap -- draw io $ setGraphicsExposures dpy gc False bgColor <- stringToPixel dpy (sBgColor style) -- we start with the border let borderWidth = sDecoBorderWidth style borderColors = sDecorationBorders style when (borderWidth > 0) $ do drawLineWith dpy pixmap gc 0 0 windowWidth borderWidth (bxTop borderColors) drawLineWith dpy pixmap gc 0 0 borderWidth windowHeight (bxLeft borderColors) drawLineWith dpy pixmap gc 0 (fi (windowHeight - borderWidth)) windowWidth borderWidth (bxBottom borderColors) drawLineWith dpy pixmap gc (fi (windowWidth - borderWidth)) 0 borderWidth windowHeight (bxRight borderColors) -- and now again io $ setForeground dpy gc bgColor io $ fillRectangle dpy pixmap gc (fi borderWidth) (fi borderWidth) (windowWidth - (borderWidth * 2)) (windowHeight - (borderWidth * 2)) -- paint strings forM_ (zip widgets $ widgetLayout $ ddWidgetPlaces dd) $ \(widget, place) -> paintWidget deco (dpy, pixmap, gc) place shrinker dd widget isExpose -- debug -- black <- stringToPixel dpy "black" -- io $ setForeground dpy gc black -- forM_ (ddWidgetPlaces dd) $ \(WidgetPlace {wpRectangle = Rectangle x y w h}) -> -- io $ drawRectangle dpy pixmap gc x y w h -- copy the pixmap over the window io $ copyArea dpy pixmap win gc 0 0 windowWidth windowHeight 0 0 -- free the pixmap and GC io $ freePixmap dpy pixmap io $ freeGC dpy gc where drawLineWith dpy pixmap gc x y w h colorName = do color <- stringToPixel dpy colorName io $ setForeground dpy gc color io $ fillRectangle dpy pixmap gc x y w h