diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/UI/NCurses.chs b/UI/NCurses.chs new file mode 100644 --- /dev/null +++ b/UI/NCurses.chs @@ -0,0 +1,1062 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +----------------------------------------------------------------------------- +-- Copyright (C) 2010 John Millikin +-- +-- This program is free software: you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation, either version 3 of the License, or +-- any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program. If not, see . +----------------------------------------------------------------------------- +-- | +-- Module: UI.NCurses +-- Copyright: 2010 John Millikin +-- License: GPL-3 +-- +-- Maintainer: jmillikin@gmail.com +-- Portability: portable (requires FFI) +-- +----------------------------------------------------------------------------- +module UI.NCurses + ( + -- * Primary types + Curses + , Update + , Window + + -- * Initialization + , runCurses + , defaultWindow + + -- * Window management + , newWindow + , closeWindow + , cloneWindow + + -- * Drawing to the screen + , updateWindow + , render + , moveCursor + , setColor + , drawText + , drawBorder + , drawBox + , drawLineH + , drawLineV + , setBackground + + -- * Attributes + , Attribute (..) + , setAttribute + , setAttributes + + -- * Colors + , Color (..) + , ColorID + , supportsColor + , canDefineColor + , defineColor + , queryColor + , defaultColorID + , newColorID + , setColorID + , maxColorID + + -- * Glyphs + , Glyph (..) + + -- ** VT100 drawing glyphs + , glyphCornerUL + , glyphCornerLL + , glyphCornerUR + , glyphCornerLR + , glyphTeeL + , glyphTeeR + , glyphTeeB + , glyphTeeT + , glyphLineH + , glyphLineV + , glyphPlus + , glyphScan1 + , glyphScan9 + , glyphDiamond + , glyphStipple + , glyphDegree + , glyphPlusMinus + , glyphBullet + + -- ** Teletype 5410v1 symbols + , glyphArrowL + , glyphArrowR + , glyphArrowD + , glyphArrowU + , glyphBoard + , glyphLantern + , glyphBlock + + -- ** Other glyphs + , glyphS3 + , glyphS7 + , glyphNE + , glyphLTE + , glyphGTE + , glyphPi + , glyphSterling + + -- * Event handling + , Event (..) + , getEvent + + -- ** Keyboard events + , Key (..) + + -- ** Mouse events + , ButtonState (..) + , MouseState (..) + + -- * misc + , setRaw + , setCBreak + , setEcho + , baudrate + , beep + , flash + , hasMouse + , enclosed + , screenSize + , setTouched + , setRowsTouched + , setKeypad + , getCursor + ) where +-- Imports {{{ +import Control.Exception (bracket_) +import Control.Monad (when, unless) +import qualified Control.Monad.Trans.Reader as R +import Data.Char (chr, ord) +import Data.List (foldl') +import Data.Maybe (catMaybes) +import qualified Data.Map as M +import qualified Data.Text as T +import UI.NCurses.Types +import qualified UI.NCurses.Enums as E +-- }}} + +-- c2hs setup {{{ +#define NCURSES_ENABLE_STDBOOL_H 0 +#define _XOPEN_SOURCE_EXTENDED +#define NCURSES_NOMACROS +#include +#include + +import Foreign hiding (shift) +import Foreign.C + +{# pointer *WINDOW as Window nocode #} +{# pointer *cchar_t as CCharT newtype #} +{# pointer *wchar_t as CWString nocode #} + +type AttrT = {# type attr_t #} +type MMaskT = {# type mmask_t #} +-- }}} + +-- Initialization {{{ + +-- | Put the terminal in graphical mode, including enabling special keys, +-- colors, and mouse events (if supported). +-- +-- After the 'Curses' block has finished running, the terminal is reset +-- to text mode. +runCurses :: Curses a -> IO a +runCurses = bracket_ initCurses {# call endwin #} . unCurses where + allEvents = fromInteger (E.fromEnum E.ALL_MOUSE_EVENTS) + initCurses = do + {# call initscr #} + {# call mousemask #} allEvents nullPtr + hasColor <- {# call has_colors #} + when (hasColor == 1) $ do + {# call start_color #} + {# call use_default_colors #} + return () + stdscr <- peek c_stdscr + {# call keypad #} (Window stdscr) 1 + {# call meta #} (Window stdscr) 1 + +-- | The default window created when @ncurses@ is initialized, also known +-- as @stdscr@. +defaultWindow :: Curses Window +defaultWindow = Curses (Window `fmap` peek c_stdscr) + +foreign import ccall "static &stdscr" + c_stdscr :: Ptr (Ptr Window) + +-- }}} + +-- Window management {{{ + +-- | Create a new 'Window', with the given dimensions. To create a +-- fullscreen window, use @'newWindow' 0 0 0 0@. +-- +-- When the window is no longer needed, call 'closeWindow'. Windows are not +-- garbage–collected, because there’s no way to know if +-- they’re still in use (as a background, or event source, etc). +newWindow :: Integer -- ^ Rows + -> Integer -- ^ Columns + -> Integer -- ^ Begin Y + -> Integer -- ^ Begin X + -> Curses Window +newWindow rows cols x y = Curses $ do + win <- {# call newwin #} + (fromInteger rows) + (fromInteger cols) + (fromInteger x) + (fromInteger y) + if windowPtr win == nullPtr + then error "newWindow: newwin() returned NULL" + else do + {# call keypad #} win 1 + {# call meta #} win 1 + return win + +-- | Close a window, and free all resources associated with it. Once a +-- window has been closed, it is no longer safe to use. +-- +-- Note: this computation will not automatically clear the window from the +-- screen. +closeWindow :: Window -> Curses () +closeWindow win = Curses ({# call delwin #} win >>= checkRC "closeWindow") + +-- | Create a separate window, initialised with the state of an existing +-- window. +cloneWindow :: Window -> Curses Window +cloneWindow old = Curses $ do + win <- {# call dupwin #} old + if windowPtr win == nullPtr + then error "cloneWindow: dupwin() returned NULL" + else return win + +-- }}} + +-- Drawing to the screen {{{ + +-- | Apply a window update to the window. After all of an +-- application’s windows have been updated, call 'render' to update +-- the terminal’s contents. +updateWindow :: Window -> Update a -> Curses a +updateWindow win (Update reader) = do + a <- R.runReaderT reader win + Curses ({# call wnoutrefresh #} win >>= checkRC "updateWindow") + return a + +-- | Re–draw any portions of the screen which have changed since the +-- last render. +render :: Curses () +render = Curses ({# call doupdate #} >>= checkRC "render") + +-- | Set the current foreground and background colors. See 'newColorID' +-- for how to create color IDs. +setColor :: ColorID -> Update () +setColor (ColorID pair) = withWindow_ "setColor" $ \win -> + {# call wcolor_set #} win pair nullPtr + +-- | Move the window’s cursor position to the given row and column. +moveCursor :: Integer -- ^ Row + -> Integer -- ^ Column + -> Update () +moveCursor y x = withWindow_ "moveCursor" $ \win -> + {# call wmove #} win (fromInteger y) (fromInteger x) + +-- | Add some text to the window, at the current cursor position. +drawText :: T.Text -> Update () +drawText txt = withWindow_ "drawText" $ \win -> + withCWString (T.unpack txt) ({# call waddwstr #} win) + +-- | Draw a border around the edge of the window. For any edge, passing +-- 'Nothing' means to use the default glyph. +drawBorder :: Maybe Glyph -- ^ Left edge + -> Maybe Glyph -- ^ Right edge + -> Maybe Glyph -- ^ Top edge + -> Maybe Glyph -- ^ Bottom edge + -> Maybe Glyph -- ^ Top left corner + -> Maybe Glyph -- ^ Top right corner + -> Maybe Glyph -- ^ Bottom left corner + -> Maybe Glyph -- ^ Bottom right corner + -> Update () +drawBorder le re te be tl tr bl br = + withWindow_ "drawBorder" $ \win -> + withGlyph le $ \pLE -> + withGlyph re $ \pRE -> + withGlyph te $ \pTE -> + withGlyph be $ \pBE -> + withGlyph tl $ \pTL -> + withGlyph tr $ \pTR -> + withGlyph bl $ \pBL -> + withGlyph br $ \pBR -> + {# call wborder_set #} win pLE pRE pTE pBE pTL pTR pBL pBR + +-- | @drawBox v h = drawBorder v v h h Nothing Nothing Nothing Nothing@ +drawBox :: Maybe Glyph -> Maybe Glyph -> Update () +drawBox v h = drawBorder v v h h Nothing Nothing Nothing Nothing + +-- | Draw a horizontal line from left to right, using the given glyph and +-- maximum character count. The cursor position is not changed. +drawLineH :: Maybe Glyph -> Integer -> Update () +drawLineH g n = withWindow_ "drawLineH" $ \win -> + withGlyph g $ \pChar -> + {# call whline_set #} win pChar (fromInteger n) + +-- | Draw a vertical line from top to bottom, using the given glyph and +-- maximum character count. The cursor position is not changed. +drawLineV :: Maybe Glyph -> Integer -> Update () +drawLineV g n = withWindow_ "drawLineV" $ \win -> + withGlyph g $ \pChar -> + {# call wvline_set #} win pChar (fromInteger n) + +-- | Set the window’s background glyph. The glyph will be drawn in +-- place of any blank characters, and the glyph’s attributes will be +-- combined with those of every character. +setBackground :: Glyph -> Update () +setBackground g = withWindow_ "setBackground" $ \win -> + withGlyph (Just g) $ \pChar -> + {# call wbkgrndset #} win pChar >> return 0 + +-- }}} + +-- Attributes {{{ + +data Attribute + = AttributeStandout + | AttributeUnderline + | AttributeReverse + | AttributeBlink + | AttributeDim + | AttributeBold + | AttributeAltCharset + | AttributeInvisible + | AttributeProtect + deriving (Show, Eq) + +attrEnum :: E.Attribute -> AttrT +attrEnum = fromInteger . E.fromEnum + +attrToInt :: Attribute -> AttrT +attrToInt x = case x of + AttributeStandout -> attrEnum E.WA_STANDOUT + AttributeUnderline -> attrEnum E.WA_UNDERLINE + AttributeReverse -> attrEnum E.WA_REVERSE + AttributeBlink -> attrEnum E.WA_BLINK + AttributeDim -> attrEnum E.WA_DIM + AttributeBold -> attrEnum E.WA_BOLD + AttributeAltCharset -> attrEnum E.WA_ALTCHARSET + AttributeInvisible -> attrEnum E.WA_INVIS + AttributeProtect -> attrEnum E.WA_PROTECT + +-- | Set a single 'Attribute' on the current window. No other attributes +-- are modified. +setAttribute :: Attribute -> Bool -> Update () +setAttribute attr on = withWindow_ "setAttribute" $ \win -> + let c = if on then {# call wattr_on #} else {# call wattr_off #} in + c win (attrToInt attr) nullPtr + +-- | Set all 'Attribute's at once on the current window. Any attributes not +-- included in the list will be unset. +setAttributes :: [Attribute] -> Update () +setAttributes attrs = withWindow_ "setAttributes" $ \win -> + let cint = foldl' (\acc a -> acc .|. attrToInt a) 0 attrs in + alloca $ \pPair -> do + {# call wattr_get #} win nullPtr pPair nullPtr >>= checkRC "setAttributes" + colorPair <- peek pPair + {# call wattr_set #} win cint colorPair nullPtr + +-- }}} + +-- Colors {{{ + +data Color + = ColorBlack + | ColorRed + | ColorGreen + | ColorYellow + | ColorBlue + | ColorMagenta + | ColorCyan + | ColorWhite + deriving (Show, Eq) + +-- | A wrapper around 'Integer' to ensure clients don’t use an +-- uninitialized color in an attribute. +newtype ColorID = ColorID CShort + deriving (Show, Eq) + +colorEnum :: E.Color -> CShort +colorEnum = fromInteger . E.fromEnum + +colorToShort :: Color -> CShort +colorToShort x = case x of + ColorBlack -> colorEnum E.COLOR_BLACK + ColorRed -> colorEnum E.COLOR_RED + ColorGreen -> colorEnum E.COLOR_GREEN + ColorYellow -> colorEnum E.COLOR_YELLOW + ColorBlue -> colorEnum E.COLOR_BLUE + ColorMagenta -> colorEnum E.COLOR_MAGENTA + ColorCyan -> colorEnum E.COLOR_CYAN + ColorWhite -> colorEnum E.COLOR_WHITE + +-- | Check if the terminal supports color. If it doesn’t, +-- alternative indicators (such as underlines or bold) should be used. +supportsColor :: Curses Bool +supportsColor = Curses (fmap cToBool {# call has_colors #}) + +-- | Check if the terminal supports changing color defintiions. +canDefineColor :: Curses Bool +canDefineColor = Curses (fmap cToBool {# call can_change_color #}) + +-- | Change the definition of an existing color. Use 'canDefineColor' to +-- determine whether changing color values is possible. +defineColor :: Color + -> Integer -- ^ Red (0 – 1000) + -> Integer -- ^ Green (0 – 1000) + -> Integer -- ^ Blue (0 – 1000) + -> Curses () +defineColor c r g b = Curses $ do + rc <- {# call init_color #} + (colorToShort c) + (fromInteger r) + (fromInteger g) + (fromInteger b) + checkRC "defineColor" rc + +-- | Query the current definition of the given color (see 'defineColor'). +-- The returned tuple is (red, green, blue), with values 0 – 1000. +queryColor :: Color -> Curses (Integer, Integer, Integer) +queryColor c = Curses $ + alloca $ \pRed -> + alloca $ \pGreen -> + alloca $ \pBlue -> do + rc <- {# call color_content #} (colorToShort c) pRed pGreen pBlue + checkRC "queryColor" rc + red <- fmap toInteger (peek pRed) + green <- fmap toInteger (peek pGreen) + blue <- fmap toInteger (peek pBlue) + return (red, green, blue) + +-- | The default color ID +defaultColorID :: ColorID +defaultColorID = ColorID 0 + +-- | Assign a new 'ColorID' to some (foreground, background) color pair. +-- The user may pick which color ID is assigned, but it must be valid. Use +-- 'maxColorID' to determine how many colors the current terminal supports. +newColorID :: Color -- ^ Foreground + -> Color -- ^ Background + -> Integer -- ^ A value /n/, such that + -- (0 < /n/ ≤ 'maxColorID') + -> Curses ColorID +newColorID fg bg n = Curses $ do + unless (n > 0) $ error "newColorID: n must be > 0" + maxColor <- unCurses maxColorID + unless (n <= maxColor) $ error "newColorID: n must be <= maxColorID" + checkRC "newColorID" =<< {# call init_pair #} + (fromInteger n) + (colorToShort fg) + (colorToShort bg) + return (ColorID (fromInteger n)) + +-- Change the definition of an existing 'ColorID' +setColorID :: Color -- ^ Foreground + -> Color -- ^ Background + -> ColorID -- ^ The 'ColorID' to change + -> Curses () +setColorID fg bg (ColorID n) = Curses $ + checkRC "setColorID" =<< {# call init_pair #} n + (colorToShort fg) + (colorToShort bg) + +-- | Get the maximum color ID supported by the current terminal +maxColorID :: Curses Integer +maxColorID = Curses $ do + pairs <- toInteger `fmap` peek c_COLOR_PAIRS + return (pairs - 1) + +foreign import ccall "static &COLOR_PAIRS" + c_COLOR_PAIRS :: Ptr CInt + +-- }}} + +-- Glyphs {{{ + +-- | A glyph is a character, typically spacing, combined with a set of +-- attributes. +data Glyph = Glyph + { glyphCharacter :: Char + , glyphAttributes :: [Attribute] + } + deriving (Show, Eq) + +withGlyph :: Maybe Glyph -> (CCharT -> IO a) -> IO a +withGlyph Nothing io = io (CCharT nullPtr) +withGlyph (Just (Glyph char attrs)) io = + let cAttrs = foldl' (\acc a -> acc .|. attrToInt a) 0 attrs in + + allocaBytes {# sizeof cchar_t #} $ \pBuf -> do + {# call memset #} (castPtr pBuf) 0 {# sizeof cchar_t #} + {# set cchar_t->attr #} pBuf cAttrs + {# set cchar_t->chars #} pBuf (wordPtrToPtr (fromIntegral (ord char))) + io (CCharT pBuf) + +-- VT100 drawing glyphs {{{ + +-- | Upper left corner +glyphCornerUL :: Glyph +glyphCornerUL = Glyph '\x250C' [] + +-- | Lower left corner +glyphCornerLL :: Glyph +glyphCornerLL = Glyph '\x2514' [] + +-- | Upper right corner +glyphCornerUR :: Glyph +glyphCornerUR = Glyph '\x2510' [] + +-- | Lower right corner +glyphCornerLR :: Glyph +glyphCornerLR = Glyph '\x2518' [] + +-- | Tee pointing right +glyphTeeL :: Glyph +glyphTeeL = Glyph '\x251C' [] + +-- | Tee pointing left +glyphTeeR :: Glyph +glyphTeeR = Glyph '\x2524' [] + +-- | Tee pointing up +glyphTeeB :: Glyph +glyphTeeB = Glyph '\x2534' [] + +-- | Tee pointing down +glyphTeeT :: Glyph +glyphTeeT = Glyph '\x252C' [] + +-- | Horizontal line +glyphLineH :: Glyph +glyphLineH = Glyph '\x2500' [] + +-- | Vertical line +glyphLineV :: Glyph +glyphLineV = Glyph '\x2502' [] + +-- | Large plus or crossover +glyphPlus :: Glyph +glyphPlus = Glyph '\x253C' [] + +-- | Scan line 1 +glyphScan1 :: Glyph +glyphScan1 = Glyph '\x23BA' [] + +-- | Scan line 9 +glyphScan9 :: Glyph +glyphScan9 = Glyph '\x23BD' [] + +-- | Diamond +glyphDiamond :: Glyph +glyphDiamond = Glyph '\x25C6' [] + +-- | Stipple, or checker board +glyphStipple :: Glyph +glyphStipple = Glyph '\x2592' [] + +-- | Degree symbol +glyphDegree :: Glyph +glyphDegree = Glyph '\xb0' [] + +-- | Plus/minus +glyphPlusMinus :: Glyph +glyphPlusMinus = Glyph '\xb1' [] + +-- | Bullet +glyphBullet :: Glyph +glyphBullet = Glyph '\xb7' [] + +-- }}} + +-- Teletype 5410v1 symbols {{{ + +-- | Arrow pointing left +glyphArrowL :: Glyph +glyphArrowL = Glyph '\x2190' [] + +-- | Arrow pointing right +glyphArrowR :: Glyph +glyphArrowR = Glyph '\x2192' [] + +-- | Arrow pointing down +glyphArrowD :: Glyph +glyphArrowD = Glyph '\x2193' [] + +-- | Arrow pointing up +glyphArrowU :: Glyph +glyphArrowU = Glyph '\x2191' [] + +-- | Board of squares +glyphBoard :: Glyph +glyphBoard = Glyph '\x2592' [] + +-- | Lantern symbol +glyphLantern :: Glyph +glyphLantern = Glyph '\x2603' [] + +-- | Solid square block +glyphBlock :: Glyph +glyphBlock = Glyph '\x25AE' [] + +-- }}} + +-- Other glyphs {{{ + +-- | Scan line 3 +glyphS3 :: Glyph +glyphS3 = Glyph '\x23BB' [] + +-- | Scan line 7 +glyphS7 :: Glyph +glyphS7 = Glyph '\x23BC' [] + +-- | Not equal +glyphNE :: Glyph +glyphNE = Glyph '\x2260' [] + +-- | Less than or equal +glyphLTE :: Glyph +glyphLTE = Glyph '\x2264' [] + +-- | Greater than or equal +glyphGTE :: Glyph +glyphGTE = Glyph '\x2265' [] + +-- | Pi +glyphPi :: Glyph +glyphPi = Glyph '\x3c0' [] + +-- | UK pounds sterling symbol +glyphSterling :: Glyph +glyphSterling = Glyph '\xa3' [] + +-- }}} + +-- }}} + +-- Event handling {{{ + +data Event + = EventCharacter Char + | EventSpecialKey Key + | EventMouse Integer MouseState + | EventResized + | EventUnknown Integer + deriving (Show, Eq) + +-- | Get the next 'Event' from a given window. This blocks until an event +-- is received. +getEvent :: Window -> Curses Event +getEvent win = Curses io where + io = alloca $ \ptr -> do + rc <- {# call wget_wch #} win ptr + checkRC "getEvent" rc + code <- toInteger `fmap` peek ptr + if rc == 0 + then return (charEvent code) + else if code == E.fromEnum E.KEY_MOUSE + then mouseEvent + else if code == E.fromEnum E.KEY_RESIZE + then return EventResized + else keyEvent code + + charEvent = EventCharacter . chr . fromInteger + + mouseEvent = allocaBytes {# sizeof MEVENT #} $ \pEv -> do + {# call getmouse #} pEv >>= checkRC "getEvent" + evID <- fmap toInteger ({# get MEVENT->id #} pEv) + x <- fmap toInteger ({# get MEVENT->x #} pEv) + y <- fmap toInteger ({# get MEVENT->y #} pEv) + z <- fmap toInteger ({# get MEVENT->z #} pEv) + + mask <- {# get MEVENT->bstate #} pEv + let state = parseMouseState mask + + return (EventMouse evID (state { mouseCoordinates = (x, y, z) })) + + codeF0 = E.fromEnum E.KEY_F0 + codeF64 = codeF0 + 64 + keyEvent code = return $ if code >= codeF0 && code <= codeF64 + then EventSpecialKey (KeyFunction (code - codeF0)) + else case M.lookup code keyMap of + Just key -> EventSpecialKey key + Nothing -> EventUnknown code + +-- Keyboard events {{{ + +data Key + = KeyUpArrow + | KeyDownArrow + | KeyLeftArrow + | KeyRightArrow + | KeyHome + | KeyBackspace + | KeyFunction Integer -- ^ Function keys, F0 – F64 + | KeyDeleteLine + | KeyInsertLine + | KeyDeleteCharacter + | KeyInsertCharacter + | KeyEIC -- ^ Sent by rmir or smir in insert mode + | KeyClear -- ^ Clear screen + | KeyEOS -- ^ Clear to end of screen + | KeyEOL -- ^ Clear to end of line + | KeyScrollForward + | KeyScrollBackward + | KeyNextPage + | KeyPreviousPage + | KeySetTab + | KeyClearTab + | KeyClearAllTabs + | KeyEnter + | KeyPrint + | KeyHomeDown + | KeyA1 -- ^ Upper left of keypad + | KeyA3 -- ^ Upper right of keypad + | KeyB2 -- ^ Center of keypad + | KeyC1 -- ^ Lower left of keypad + | KeyC3 -- ^ Lower right of keypad + | KeyBackTab + | KeyBegin + | KeyCancel + | KeyClose + | KeyCommand + | KeyCopy + | KeyCreate + | KeyEnd + | KeyExit + | KeyFind + | KeyHelp + | KeyMark + | KeyMessage + | KeyMove + | KeyNext + | KeyOpen + | KeyOptions + | KeyPrevious + | KeyRedo + | KeyReference + | KeyRefresh + | KeyReplace + | KeyRestart + | KeyResume + | KeySave + | KeyShiftedBegin + | KeyShiftedCancel + | KeyShiftedCommand + | KeyShiftedCopy + | KeyShiftedCreate + | KeyShiftedDeleteCharacter + | KeyShiftedDeleteLine + | KeySelect + | KeyShiftedEnd + | KeyShiftedEOL + | KeyShiftedExit + | KeyShiftedFind + | KeyShiftedHelp + | KeyShiftedHome + | KeyShiftedInsertCharacter + | KeyShiftedLeftArrow + | KeyShiftedMessage + | KeyShiftedMove + | KeyShiftedNext + | KeyShiftedOptions + | KeyShiftedPrevious + | KeyShiftedPrint + | KeyShiftedRedo + | KeyShiftedReplace + | KeyShiftedRightArrow + | KeyShiftedResume + | KeyShiftedSave + | KeyShiftedSuspend + | KeyShiftedUndo + | KeySuspend + | KeyUndo + deriving (Show, Eq) + +keyMap :: M.Map Integer Key +keyMap = M.fromList $ map (\(enum, key) -> (E.fromEnum enum, key)) + [ (E.KEY_DOWN, KeyDownArrow) + , (E.KEY_UP, KeyUpArrow) + , (E.KEY_LEFT, KeyLeftArrow) + , (E.KEY_RIGHT, KeyRightArrow) + , (E.KEY_HOME, KeyHome) + , (E.KEY_BACKSPACE, KeyBackspace) + , (E.KEY_DL, KeyDeleteLine) + , (E.KEY_IL, KeyInsertLine) + , (E.KEY_DC, KeyDeleteCharacter) + , (E.KEY_IC, KeyInsertCharacter) + , (E.KEY_EIC, KeyEIC) + , (E.KEY_CLEAR, KeyClear) + , (E.KEY_EOS, KeyEOS) + , (E.KEY_EOL, KeyEOL) + , (E.KEY_SF, KeyScrollForward) + , (E.KEY_SR, KeyScrollBackward) + , (E.KEY_NPAGE, KeyNextPage) + , (E.KEY_PPAGE, KeyPreviousPage) + , (E.KEY_STAB, KeySetTab) + , (E.KEY_CTAB, KeyClearTab) + , (E.KEY_CATAB, KeyClearAllTabs) + , (E.KEY_ENTER, KeyEnter) + , (E.KEY_PRINT, KeyPrint) + , (E.KEY_LL, KeyHomeDown) + , (E.KEY_A1, KeyA1) + , (E.KEY_A3, KeyA3) + , (E.KEY_B2, KeyB2) + , (E.KEY_C1, KeyC1) + , (E.KEY_C3, KeyC3) + , (E.KEY_BTAB, KeyBackTab) + , (E.KEY_BEG, KeyBegin) + , (E.KEY_CANCEL, KeyCancel) + , (E.KEY_CLOSE, KeyClose) + , (E.KEY_COMMAND, KeyCommand) + , (E.KEY_COPY, KeyCopy) + , (E.KEY_CREATE, KeyCreate) + , (E.KEY_END, KeyEnd) + , (E.KEY_EXIT, KeyExit) + , (E.KEY_FIND, KeyFind) + , (E.KEY_HELP, KeyHelp) + , (E.KEY_MARK, KeyMark) + , (E.KEY_MESSAGE, KeyMessage) + , (E.KEY_MOVE, KeyMove) + , (E.KEY_NEXT, KeyNext) + , (E.KEY_OPEN, KeyOpen) + , (E.KEY_OPTIONS, KeyOptions) + , (E.KEY_PREVIOUS, KeyPrevious) + , (E.KEY_REDO, KeyRedo) + , (E.KEY_REFERENCE, KeyReference) + , (E.KEY_REFRESH, KeyRefresh) + , (E.KEY_REPLACE, KeyReplace) + , (E.KEY_RESTART, KeyRestart) + , (E.KEY_RESUME, KeyResume) + , (E.KEY_SAVE, KeySave) + , (E.KEY_SBEG, KeyShiftedBegin) + , (E.KEY_SCANCEL, KeyShiftedCancel) + , (E.KEY_SCOMMAND, KeyShiftedCommand) + , (E.KEY_SCOPY, KeyShiftedCopy) + , (E.KEY_SCREATE, KeyShiftedCreate) + , (E.KEY_SDC, KeyShiftedDeleteCharacter) + , (E.KEY_SDL, KeyShiftedDeleteLine) + , (E.KEY_SELECT, KeySelect) + , (E.KEY_SEND, KeyShiftedEnd) + , (E.KEY_SEOL, KeyShiftedEOL) + , (E.KEY_SEXIT, KeyShiftedExit) + , (E.KEY_SFIND, KeyShiftedFind) + , (E.KEY_SHELP, KeyShiftedHelp) + , (E.KEY_SHOME, KeyShiftedHome) + , (E.KEY_SIC, KeyShiftedInsertCharacter) + , (E.KEY_SLEFT, KeyShiftedLeftArrow) + , (E.KEY_SMESSAGE, KeyShiftedMessage) + , (E.KEY_SMOVE, KeyShiftedMove) + , (E.KEY_SNEXT, KeyShiftedNext) + , (E.KEY_SOPTIONS, KeyShiftedOptions) + , (E.KEY_SPREVIOUS, KeyShiftedPrevious) + , (E.KEY_SPRINT, KeyShiftedPrint) + , (E.KEY_SREDO, KeyShiftedRedo) + , (E.KEY_SREPLACE, KeyShiftedReplace) + , (E.KEY_SRIGHT, KeyShiftedRightArrow) + , (E.KEY_SRSUME, KeyShiftedResume) + , (E.KEY_SSAVE, KeyShiftedSave) + , (E.KEY_SSUSPEND, KeyShiftedSuspend) + , (E.KEY_SUNDO, KeyShiftedUndo) + , (E.KEY_SUSPEND, KeySuspend) + , (E.KEY_UNDO, KeyUndo) + ] + +-- }}} + +-- Mouse events {{{ + +data ButtonState + = ButtonPressed + | ButtonReleased + | ButtonClicked + | ButtonDoubleClicked + | ButtonTripleClicked + deriving (Show, Eq) + +data MouseState = MouseState + { mouseCoordinates :: (Integer, Integer, Integer) -- ^ (X, Y, Z) + + -- | If the mouse event was caused by a change in button state, + -- the buttons and their new state will be listed here. + , mouseButtons :: [(Integer, ButtonState)] + + , mouseAlt :: Bool + , mouseShift :: Bool + , mouseControl :: Bool + } + deriving (Show, Eq) + +parseMouseState :: MMaskT -> MouseState +parseMouseState mask = MouseState (0, 0, 0) buttons alt shift ctrl where + maskI = toInteger mask + test e = (maskI .&. (E.fromEnum e)) > 0 + + alt = test E.BUTTON_ALT + shift = test E.BUTTON_SHIFT + ctrl = test E.BUTTON_CTRL + + buttons = catMaybes [button1, button2, button3, button4, button5] + + testButton idx r p c dc tc + | test r = Just (idx, ButtonReleased) + | test p = Just (idx, ButtonPressed) + | test c = Just (idx, ButtonClicked) + | test dc = Just (idx, ButtonDoubleClicked) + | test tc = Just (idx, ButtonTripleClicked) + | otherwise = Nothing + + button1 = testButton 1 + E.BUTTON1_RELEASED + E.BUTTON1_PRESSED + E.BUTTON1_CLICKED + E.BUTTON1_DOUBLE_CLICKED + E.BUTTON1_TRIPLE_CLICKED + button2 = testButton 2 + E.BUTTON2_RELEASED + E.BUTTON2_PRESSED + E.BUTTON2_CLICKED + E.BUTTON2_DOUBLE_CLICKED + E.BUTTON2_TRIPLE_CLICKED + button3 = testButton 3 + E.BUTTON3_RELEASED + E.BUTTON3_PRESSED + E.BUTTON3_CLICKED + E.BUTTON3_DOUBLE_CLICKED + E.BUTTON3_TRIPLE_CLICKED + button4 = testButton 4 + E.BUTTON4_RELEASED + E.BUTTON4_PRESSED + E.BUTTON4_CLICKED + E.BUTTON4_DOUBLE_CLICKED + E.BUTTON4_TRIPLE_CLICKED +#ifdef BUTTON5_RELEASED + button5 = testButton 5 + E.BUTTON5_RELEASED + E.BUTTON5_PRESSED + E.BUTTON5_CLICKED + E.BUTTON5_DOUBLE_CLICKED + E.BUTTON5_TRIPLE_CLICKED +#else + button5 = Nothing +#endif + +-- }}} + +-- }}} + +-- misc {{{ + +-- | Runs @raw()@ or @noraw()@ +setRaw :: Bool -> Curses () +setRaw set = Curses (io >>= checkRC "setRaw") where + io = if set then {# call raw #} else {# call noraw #} + +-- | Runs @cbreak()@ or @nocbreak()@ +setCBreak :: Bool -> Curses () +setCBreak set = Curses (io >>= checkRC "setCBreak") where + io = if set then {# call cbreak #} else {# call nocbreak #} + +-- | Runs @echo()@ or @noecho()@ +setEcho :: Bool -> Curses () +setEcho set = Curses (io >>= checkRC "setEcho") where + io = if set then {# call echo #} else {# call noecho #} + +-- | Get the output speed of the current terminal, in bits per second. +baudrate :: Curses Integer +baudrate = Curses $ do + rc <- {# call baudrate as c_baudrate #} + checkRC "baudrate" rc + return (toInteger rc) + +beep :: Curses () +beep = Curses ({# call beep as c_beep #} >>= checkRC "beep") + +flash :: Curses () +flash = Curses ({# call flash as c_flash #} >>= checkRC "flash") + +-- | Check if the terminal has a mouse +hasMouse :: Curses Bool +hasMouse = Curses (fmap cToBool {# call has_mouse #}) + +-- | Check if some position is contained within the given 'Window'. +enclosed :: Window + -> Integer -- ^ Row + -> Integer -- ^ Column + -> Curses Bool +enclosed win y x = Curses . fmap cToBool $ + {# call wenclose #} win (fromInteger y) (fromInteger x) + +-- | Return (rows, columns) of current screen +screenSize :: Curses (Integer, Integer) +screenSize = Curses $ do + rows <- peek c_LINES + cols <- peek c_COLS + return (toInteger rows, toInteger cols) + +foreign import ccall "static &LINES" + c_LINES :: Ptr CInt + +foreign import ccall "static &COLS" + c_COLS :: Ptr CInt + +-- | Set whether the entire window has been “touched”; +-- touched characters are redrawn on the next refresh. +setTouched :: Bool -> Update () +setTouched touched = withWindow_ "setTouched" $ if touched + then {# call touchwin #} + else {# call untouchwin #} + +-- | Set whether particular rows in the window have been +-- “touched”. +setRowsTouched :: Bool + -> Integer -- ^ Start + -> Integer -- ^ Count + -> Update () +setRowsTouched touched start count = withWindow_ "setRowsTouched" $ \win -> + {# call wtouchln #} win + (fromInteger start) + (fromInteger count) + (cFromBool touched) + +-- | Enable/disable support for special keys. +setKeypad :: Window -> Bool -> Curses () +setKeypad win set = Curses (io >>= checkRC "setKeypad") where + io = {# call keypad #} win (cFromBool set) + +getCursor :: Window -> Curses (Integer, Integer) +getCursor win = Curses $ do + row <- {# call getcury #} win + col <- {# call getcurx #} win + return (toInteger row, toInteger col) + +-- }}} + +-- Utility {{{ + +withWindow :: (Window -> IO a) -> Update a +withWindow io = Update (R.ReaderT (\win -> Curses (io win))) + +withWindow_ :: String -> (Window -> IO CInt) -> Update () +withWindow_ name io = withWindow $ \win -> io win >>= checkRC name + +-- }}} diff --git a/UI/NCurses/Enums.chs b/UI/NCurses/Enums.chs new file mode 100644 --- /dev/null +++ b/UI/NCurses/Enums.chs @@ -0,0 +1,215 @@ +----------------------------------------------------------------------------- +-- Copyright (C) 2010 John Millikin +-- +-- This program is free software: you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation, either version 3 of the License, or +-- any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program. If not, see . +----------------------------------------------------------------------------- +module UI.NCurses.Enums where + +-- this module is a hack to work around c2hs's lack of #define hooks. +-- the idea is to create a new class 'Enum' which uses 'Integer' instead +-- of 'Int', so integral defines of any size can be retrieved. +import Prelude (Integer, error, show, (++)) + +#define NCURSES_ENABLE_STDBOOL_H 0 +#define _XOPEN_SOURCE_EXTENDED +#define NCURSES_NOMACROS +#include + +class Enum a where + toEnum :: Integer -> a + fromEnum :: a -> Integer + +-- misc enums +#c +enum hsncurses_EnumWrapper +{ hsncurses_ALL_MOUSE_EVENTS = ALL_MOUSE_EVENTS +, hsncurses_ERR = ERR +}; +#endc + +{# enum hsncurses_EnumWrapper as EnumWrapper {} with prefix = "hsncurses_" #} + +-- attributes +#c +enum hsncurses_Attribute +{ hsncurses_WA_STANDOUT = WA_STANDOUT +, hsncurses_WA_UNDERLINE = WA_UNDERLINE +, hsncurses_WA_REVERSE = WA_REVERSE +, hsncurses_WA_BLINK = WA_BLINK +, hsncurses_WA_DIM = WA_DIM +, hsncurses_WA_BOLD = WA_BOLD +, hsncurses_WA_ALTCHARSET = WA_ALTCHARSET +, hsncurses_WA_INVIS = WA_INVIS +, hsncurses_WA_PROTECT = WA_PROTECT +}; +#endc + +{# enum hsncurses_Attribute as Attribute {} with prefix = "hsncurses_" #} + +-- colors +#c +enum hsncurses_Color +{ hsncurses_COLOR_BLACK = COLOR_BLACK +, hsncurses_COLOR_RED = COLOR_RED +, hsncurses_COLOR_GREEN = COLOR_GREEN +, hsncurses_COLOR_YELLOW = COLOR_YELLOW +, hsncurses_COLOR_BLUE = COLOR_BLUE +, hsncurses_COLOR_MAGENTA = COLOR_MAGENTA +, hsncurses_COLOR_CYAN = COLOR_CYAN +, hsncurses_COLOR_WHITE = COLOR_WHITE +}; +#endc + +{# enum hsncurses_Color as Color {} with prefix = "hsncurses_" #} + +-- keys +#c +enum hsncurses_Key +{ hsncurses_KEY_CODE_YES = KEY_CODE_YES +, hsncurses_KEY_DOWN = KEY_DOWN +, hsncurses_KEY_UP = KEY_UP +, hsncurses_KEY_LEFT = KEY_LEFT +, hsncurses_KEY_RIGHT = KEY_RIGHT +, hsncurses_KEY_HOME = KEY_HOME +, hsncurses_KEY_BACKSPACE = KEY_BACKSPACE +, hsncurses_KEY_F0 = KEY_F0 +, hsncurses_KEY_DL = KEY_DL +, hsncurses_KEY_IL = KEY_IL +, hsncurses_KEY_DC = KEY_DC +, hsncurses_KEY_IC = KEY_IC +, hsncurses_KEY_EIC = KEY_EIC +, hsncurses_KEY_CLEAR = KEY_CLEAR +, hsncurses_KEY_EOS = KEY_EOS +, hsncurses_KEY_EOL = KEY_EOL +, hsncurses_KEY_SF = KEY_SF +, hsncurses_KEY_SR = KEY_SR +, hsncurses_KEY_NPAGE = KEY_NPAGE +, hsncurses_KEY_PPAGE = KEY_PPAGE +, hsncurses_KEY_STAB = KEY_STAB +, hsncurses_KEY_CTAB = KEY_CTAB +, hsncurses_KEY_CATAB = KEY_CATAB +, hsncurses_KEY_ENTER = KEY_ENTER +, hsncurses_KEY_PRINT = KEY_PRINT +, hsncurses_KEY_LL = KEY_LL +, hsncurses_KEY_A1 = KEY_A1 +, hsncurses_KEY_A3 = KEY_A3 +, hsncurses_KEY_B2 = KEY_B2 +, hsncurses_KEY_C1 = KEY_C1 +, hsncurses_KEY_C3 = KEY_C3 +, hsncurses_KEY_BTAB = KEY_BTAB +, hsncurses_KEY_BEG = KEY_BEG +, hsncurses_KEY_CANCEL = KEY_CANCEL +, hsncurses_KEY_CLOSE = KEY_CLOSE +, hsncurses_KEY_COMMAND = KEY_COMMAND +, hsncurses_KEY_COPY = KEY_COPY +, hsncurses_KEY_CREATE = KEY_CREATE +, hsncurses_KEY_END = KEY_END +, hsncurses_KEY_EXIT = KEY_EXIT +, hsncurses_KEY_FIND = KEY_FIND +, hsncurses_KEY_HELP = KEY_HELP +, hsncurses_KEY_MARK = KEY_MARK +, hsncurses_KEY_MESSAGE = KEY_MESSAGE +, hsncurses_KEY_MOVE = KEY_MOVE +, hsncurses_KEY_NEXT = KEY_NEXT +, hsncurses_KEY_OPEN = KEY_OPEN +, hsncurses_KEY_OPTIONS = KEY_OPTIONS +, hsncurses_KEY_PREVIOUS = KEY_PREVIOUS +, hsncurses_KEY_REDO = KEY_REDO +, hsncurses_KEY_REFERENCE = KEY_REFERENCE +, hsncurses_KEY_REFRESH = KEY_REFRESH +, hsncurses_KEY_REPLACE = KEY_REPLACE +, hsncurses_KEY_RESTART = KEY_RESTART +, hsncurses_KEY_RESUME = KEY_RESUME +, hsncurses_KEY_SAVE = KEY_SAVE +, hsncurses_KEY_SBEG = KEY_SBEG +, hsncurses_KEY_SCANCEL = KEY_SCANCEL +, hsncurses_KEY_SCOMMAND = KEY_SCOMMAND +, hsncurses_KEY_SCOPY = KEY_SCOPY +, hsncurses_KEY_SCREATE = KEY_SCREATE +, hsncurses_KEY_SDC = KEY_SDC +, hsncurses_KEY_SDL = KEY_SDL +, hsncurses_KEY_SELECT = KEY_SELECT +, hsncurses_KEY_SEND = KEY_SEND +, hsncurses_KEY_SEOL = KEY_SEOL +, hsncurses_KEY_SEXIT = KEY_SEXIT +, hsncurses_KEY_SFIND = KEY_SFIND +, hsncurses_KEY_SHELP = KEY_SHELP +, hsncurses_KEY_SHOME = KEY_SHOME +, hsncurses_KEY_SIC = KEY_SIC +, hsncurses_KEY_SLEFT = KEY_SLEFT +, hsncurses_KEY_SMESSAGE = KEY_SMESSAGE +, hsncurses_KEY_SMOVE = KEY_SMOVE +, hsncurses_KEY_SNEXT = KEY_SNEXT +, hsncurses_KEY_SOPTIONS = KEY_SOPTIONS +, hsncurses_KEY_SPREVIOUS = KEY_SPREVIOUS +, hsncurses_KEY_SPRINT = KEY_SPRINT +, hsncurses_KEY_SREDO = KEY_SREDO +, hsncurses_KEY_SREPLACE = KEY_SREPLACE +, hsncurses_KEY_SRIGHT = KEY_SRIGHT +, hsncurses_KEY_SRSUME = KEY_SRSUME +, hsncurses_KEY_SSAVE = KEY_SSAVE +, hsncurses_KEY_SSUSPEND = KEY_SSUSPEND +, hsncurses_KEY_SUNDO = KEY_SUNDO +, hsncurses_KEY_SUSPEND = KEY_SUSPEND +, hsncurses_KEY_UNDO = KEY_UNDO +, hsncurses_KEY_MOUSE = KEY_MOUSE +, hsncurses_KEY_RESIZE = KEY_RESIZE +, hsncurses_KEY_EVENT = KEY_EVENT +}; +#endc + +{# enum hsncurses_Key as Key {} with prefix = "hsncurses_" #} + +-- mouse buttons +#c +enum hsncurses_Button +{ hsncurses_BUTTON_CTRL = BUTTON_CTRL +, hsncurses_BUTTON_SHIFT = BUTTON_SHIFT +, hsncurses_BUTTON_ALT = BUTTON_ALT + +, hsncurses_BUTTON1_RELEASED = BUTTON1_RELEASED +, hsncurses_BUTTON1_PRESSED = BUTTON1_PRESSED +, hsncurses_BUTTON1_CLICKED = BUTTON1_CLICKED +, hsncurses_BUTTON1_DOUBLE_CLICKED = BUTTON1_DOUBLE_CLICKED +, hsncurses_BUTTON1_TRIPLE_CLICKED = BUTTON1_TRIPLE_CLICKED + +, hsncurses_BUTTON2_RELEASED = BUTTON2_RELEASED +, hsncurses_BUTTON2_PRESSED = BUTTON2_PRESSED +, hsncurses_BUTTON2_CLICKED = BUTTON2_CLICKED +, hsncurses_BUTTON2_DOUBLE_CLICKED = BUTTON2_DOUBLE_CLICKED +, hsncurses_BUTTON2_TRIPLE_CLICKED = BUTTON2_TRIPLE_CLICKED + +, hsncurses_BUTTON3_RELEASED = BUTTON3_RELEASED +, hsncurses_BUTTON3_PRESSED = BUTTON3_PRESSED +, hsncurses_BUTTON3_CLICKED = BUTTON3_CLICKED +, hsncurses_BUTTON3_DOUBLE_CLICKED = BUTTON3_DOUBLE_CLICKED +, hsncurses_BUTTON3_TRIPLE_CLICKED = BUTTON3_TRIPLE_CLICKED + +, hsncurses_BUTTON4_RELEASED = BUTTON4_RELEASED +, hsncurses_BUTTON4_PRESSED = BUTTON4_PRESSED +, hsncurses_BUTTON4_CLICKED = BUTTON4_CLICKED +, hsncurses_BUTTON4_DOUBLE_CLICKED = BUTTON4_DOUBLE_CLICKED +, hsncurses_BUTTON4_TRIPLE_CLICKED = BUTTON4_TRIPLE_CLICKED + +#ifdef BUTTON5_RELEASED +, hsncurses_BUTTON5_RELEASED = BUTTON5_RELEASED +, hsncurses_BUTTON5_PRESSED = BUTTON5_PRESSED +, hsncurses_BUTTON5_CLICKED = BUTTON5_CLICKED +, hsncurses_BUTTON5_DOUBLE_CLICKED = BUTTON5_DOUBLE_CLICKED +, hsncurses_BUTTON5_TRIPLE_CLICKED = BUTTON5_TRIPLE_CLICKED +#endif +}; +#endc + +{# enum hsncurses_Button as Button {} with prefix = "hsncurses_" #} diff --git a/UI/NCurses/Panel.chs b/UI/NCurses/Panel.chs new file mode 100644 --- /dev/null +++ b/UI/NCurses/Panel.chs @@ -0,0 +1,146 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +----------------------------------------------------------------------------- +-- Copyright (C) 2010 John Millikin +-- +-- This program is free software: you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation, either version 3 of the License, or +-- any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program. If not, see . +----------------------------------------------------------------------------- +-- | +-- Module: UI.NCurses.Panel +-- Copyright: 2010 John Millikin +-- License: GPL-3 +-- +-- Maintainer: jmillikin@gmail.com +-- Portability: portable (requires FFI) +-- +----------------------------------------------------------------------------- +module UI.NCurses.Panel + ( Panel + , newPanel + , deletePanel + , refreshPanels + , panelAbove + , panelBelow + , panelTop + , panelBottom + , showPanel + , hidePanel + , panelHidden + , movePanel + , raisePanel + , lowerPanel + , getPanelWindow + , replacePanelWindow + ) where +import Foreign +import Foreign.C +import UI.NCurses.Types + +-- for haddock +import UI.NCurses (render) + +#include + +{# pointer *PANEL as Panel nocode #} +{# pointer *WINDOW as Window nocode #} +newtype Panel = Panel { panelPtr :: Ptr Panel } + +-- | Creates a new 'Panel', on top of the panel stack. +newPanel :: Window -> Curses Panel +newPanel win = Curses $ do + p <- {# call new_panel #} win + if panelPtr p == nullPtr + then error "newPanel: new_panel() returned NULL" + else return p + +-- | Permanently removes the given panel from the panel stack. +deletePanel :: Panel -> Curses () +deletePanel p = Curses ({# call del_panel #} p >>= checkRC "deletePanel") + +-- | Updates windows to account for the current panel stack order. The user +-- must call 'render' before changes are drawn to the screen. +refreshPanels :: Curses () +refreshPanels = Curses {#call update_panels #} + +-- | @panelAbove p@ retrieve the panel above /p/. +panelAbove :: Panel -> Curses (Maybe Panel) +panelAbove p = Curses $ do + ptr <- {# call panel_above #} p + return $ if panelPtr ptr == nullPtr + then Nothing + else Just ptr + +-- | @panelAbove p@ retrieve the panel below /p/. +panelBelow :: Panel -> Curses (Maybe Panel) +panelBelow p = Curses $ do + ptr <- {# call panel_below #} p + return $ if panelPtr ptr == nullPtr + then Nothing + else Just ptr + +-- | Retrieve the top–most panel in the stack. +panelTop :: Curses (Maybe Panel) +panelTop = Curses $ do + ptr <- {# call panel_below #} (Panel nullPtr) + return $ if panelPtr ptr == nullPtr + then Nothing + else Just ptr + +-- | Retrieve the bottom–most panel in the stack. +panelBottom :: Curses (Maybe Panel) +panelBottom = Curses $ do + ptr <- {# call panel_above #} (Panel nullPtr) + return $ if panelPtr ptr == nullPtr + then Nothing + else Just ptr + +-- | Makes a hidden panel visible, and places it on the top of the stack. +showPanel :: Panel -> Curses () +showPanel p = Curses ({# call show_panel #} p >>= checkRC "showPanel") + +-- | Temporarily removes the given panel from the panel stack. Use +-- 'showPanel' to restore it. +hidePanel :: Panel -> Curses () +hidePanel p = Curses ({# call hide_panel #} p >>= checkRC "hidePanel") + +-- | Checks if the given panel is currently visible. +panelHidden :: Panel -> Curses Bool +panelHidden p = Curses (cToBool `fmap` {# call panel_hidden #} p) + +-- | Move the panel so its upper–left corner is at the new +-- coordinates. +movePanel :: Panel + -> Integer -- ^ New upper–left row + -> Integer -- ^ New upper–left column + -> Curses () +movePanel p row col = Curses $ + checkRC "movePanel" =<< {# call move_panel #} p + (fromInteger row) + (fromInteger col) + +-- | Raise a bottom to the top of the stack. +raisePanel :: Panel -> Curses () +raisePanel p = Curses ({# call top_panel #} p >>= checkRC "raisePanel") + +-- | Lower a panel to the bottom of the stack. +lowerPanel :: Panel -> Curses () +lowerPanel p = Curses ({# call bottom_panel #} p >>= checkRC "lowerPanel") + +-- | Retrieves which window a panel is drawn to. +getPanelWindow :: Panel -> Curses Window +getPanelWindow p = Curses ({# call panel_window #} p) + +-- | Replaces which window a panel is drawn to. +replacePanelWindow :: Panel -> Window -> Curses () +replacePanelWindow p win = Curses $ + {# call replace_panel #} p win >>= checkRC "replacePanelWindow" diff --git a/UI/NCurses/Types.hs b/UI/NCurses/Types.hs new file mode 100644 --- /dev/null +++ b/UI/NCurses/Types.hs @@ -0,0 +1,85 @@ +----------------------------------------------------------------------------- +-- Copyright (C) 2010 John Millikin +-- +-- This program is free software: you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation, either version 3 of the License, or +-- any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program. If not, see . +----------------------------------------------------------------------------- +module UI.NCurses.Types where +import qualified Control.Applicative as A +import Control.Monad (liftM, ap) +import Control.Monad.Fix (MonadFix, mfix) +import Control.Monad.IO.Class (MonadIO, liftIO) +import Control.Monad.Trans.Reader (ReaderT) +import qualified Foreign as F +import qualified Foreign.C as F +import qualified UI.NCurses.Enums as E + +-- newtype Curses {{{ + +-- | A small wrapper around 'IO', to ensure the @ncurses@ library is +-- initialized while running. +newtype Curses a = Curses { unCurses :: IO a } + +instance Monad Curses where + return = Curses . return + m >>= f = Curses (unCurses m >>= unCurses . f) + +instance MonadFix Curses where + mfix f = Curses (mfix (unCurses . f)) + +instance MonadIO Curses where + liftIO = Curses + +instance Functor Curses where + fmap = liftM + +instance A.Applicative Curses where + pure = return + (<*>) = ap + +-- }}} + +-- newtype Update {{{ + +newtype Update a = Update { unUpdate :: ReaderT Window Curses a } + +instance Monad Update where + return = Update . return + m >>= f = Update (unUpdate m >>= unUpdate . f) + +instance MonadFix Update where + mfix f = Update (mfix (unUpdate . f)) + +instance Functor Update where + fmap = liftM + +instance A.Applicative Update where + pure = return + (<*>) = ap + +-- }}} + +newtype Window = Window { windowPtr :: F.Ptr Window } + +checkRC :: String -> F.CInt -> IO () +checkRC name rc = if toInteger rc == E.fromEnum E.ERR + then error $ name ++ ": rc == ERR" + else return () + +cToBool :: Integral a => a -> Bool +cToBool 0 = False +cToBool _ = True + +cFromBool :: Integral a => Bool -> a +cFromBool False = 0 +cFromBool True = 1 diff --git a/license.txt b/license.txt new file mode 100644 --- /dev/null +++ b/license.txt @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/ncurses.cabal b/ncurses.cabal new file mode 100644 --- /dev/null +++ b/ncurses.cabal @@ -0,0 +1,41 @@ +name: ncurses +version: 0.1 +synopsis: Modernised bindings to GNU ncurses +license: GPL-3 +license-file: license.txt +author: John Millikin +maintainer: jmillikin@gmail.com +copyright: Copyright (c) John Millikin 2010 +build-type: Simple +cabal-version: >=1.6 +category: User Interfaces, Foreign +stability: experimental +bug-reports: mailto:jmillikin@gmail.com +homepage: http://ianen.org/haskell/bindings/ncurses/ +tested-with: GHC==6.12.1 + +source-repository head + type: darcs + location: http://ianen.org/haskell/bindings/ncurses/ + +library + ghc-options: -Wall -fno-warn-unused-do-bind + + build-depends: + base >= 4 && < 5 + , containers >= 0.2 && < 0.4 + , text >= 0.7 && < 0.9 + , transformers >= 0.2 && < 0.3 + + build-tools: + c2hs >= 0.15 + + extra-libraries: panel ncursesw + + exposed-modules: + UI.NCurses + UI.NCurses.Panel + + other-modules: + UI.NCurses.Enums + UI.NCurses.Types