!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                   Safe>LRepresents a transformation matrix that can be used to transform forms. This is more useful than just using the composing methods in the graphics API, as it can perform skewing and other complex transformation techniques.gConstruct an identity transformation matrix. Anything transformed by this matrix will remain the same.BConstruct a transformation matrix with specific row/column values. matrix a b c d x y/ a b x c d y /=Construct a counter-clockwise rotating transformation matrix.  rotation t(/ cos t -sin t 0 sin t cos t 0 /.Construct a translating transformation matrix. translation (V2 x y)/ 1 0 x 0 1 y /Construction a scaling transformation matrix. To scale in all directions, simply have the x and y values the same. Alternatively, to scale by only one direction, keep the excluded dimenion's vector component as 1. scale (V2 x y)/ x 0 0 0 y 0 //Multiply two transformatio nmatrices together.. Safe0>L Represents a gradient.Helm supports radial and linear gradients. Radial gradients are based on a set of colors transitioned over certain radii in an arc pattern. Linear gradients are a set of colors transitioned in a straight line. A linear gradient. A radial gradient. ]Represents a color. It is represented interally as an RGBA color, but the utility functions , L, etc. can be used to convert from other popular formats to this structure. Create an RGB color.Create an RGBA color.?Blends colors together by averaging out their color components.Adds colors together.Calculate the complementary color for a color provided color. This is useful for outlining a filled shape in a color clearly distinguishable from the fill color.&Create an RGBA color from HSVA values.$Create an RGB color from HSV values.Creates a linear gradient. Takes a starting position, ending position and a list of color stops (which are colors combined with a floating value between 0.0 and 1.0 that describes at what step along the line between the starting position and ending position the paired color should be transitioned to). 1linear (0, 0) (100, 100) [(0, black), (1, white)]4The above example creates a gradient that starts at (0, 0) and ends at  (100, 100). In other words, it's a diagonal gradient, transitioning from the top-left to the bottom-right. The provided color stops result in the gradient transitioning from black to white.Creates a radial gradient. Takes a starting position and radius, ending position and radius and a list of color stops. See the document for % for more information on color stops.         Safe>L _Represents a graphical piece of text, containing a UTF-8 string and any relevant style fields.'Represents the style for a text's font.!(Represents the weight for a text's font.%UCreate the default text. By default it is is black sans-serif with a height of 14pt.&UCreate a text from a string. By default, this text will be 14pt, black and unstyled.'%Create a text from a type instancing .(!Set the weight of a text to bold.)+Set the weight of a piece of text to light.*+Set the slant of a piece of text to italic.+,Set the slant of a piece of text to oblique.,!Set the color of a piece of text.-Set the typeface of the text.. Set the size of a piece of text. !"#$%&'()*+,-. !"#$%&'()*+,-.!"#$ %&')(*+,-.  !"#$%&'()*+,-.Safe>L/7Represents an image asset loaded by an engine instance.This is a type family, where the instance types are the specific internal representations of an image for an engine. Hence the e type variable here should refer to an Engine- instance, but that is not strictly required.Having the image type be a family allows us to separate the internal representation of the image assets for each engine from the core Helm library.////Safe>L>0.Represents the style used for drawing a shape.15Stroke/outline the shape, with a specific line style.2+Fill the shape, with a specific fill style.3Represents a collection of points that when drawn in order will result in a closed polygon. They have no style information - rather, you compose shapes into a form with fill or line style and that affects their appearance.(Note that realistically, a shape could be represented as a path only. However, we add extra variants here as drawing backends usually provide optimized forms of drawing circles (and perhaps rectangles, although that is less likely) hence it's better to fall to those if our shape is circular.7JRepresents a series of 2D points which will be drawn in sequence. Like a 31, a path on its own holds no styling information.9?Represents the style used for drawing lines. It's best to use k. and then only change the fields you need to.A9Represents the shape of the joints between line segments.E+Represents the shape of the ends of a line.I0Represents the style of shape filling available.J,The shape will be filled with a solid color.K7The shape will be filled with a texture (a.k.a. image).LIThe shape will be filled with a gradient (which can be linear or radial).MRepresents something that can be rendered to the screen ( contained under a collage). There are many different types of forms, which can be composed below but are generally represented by the T type.A form might be an image, or a rectangle, or a circle, or even a collection of forms (which in turn can be those same things).O&The rotation of the form (in radians).PThe scale factor of the form.QOThe position of the form. This will be rendered relative to the collage origin.RThe alpha channel of the form.SThe style of form.TnRepresents the styles of forms available. The form style holds data specific to a variation of form, and the MZ is instead a general version of this with positioning information, rotation, scale, etc.UA form composed of a pathVA form composed of a shape.WDA form composed of a piece of text, including string and style info.XA form composed of an imageY;A form composed of a group of forms, with a transformation.ZFA form composed of a collage (which in turn is a collection of forms).[Represents a collection of forms, which in turn are rendereable shapes and lines. In Helm, the collage is the main structure representing 2D graphics and is passed directly to the engine to be rendered by your view function. It's best to think of a collage as a fancy version of a game screen, with the difference being that the collage itself knows nothing about the window state. It only knows what will be rendered to the screen (which in this case, is a series of forms) and the order in which they will be rendered.]IThe optional dimensions of the collage. It will be clipped to these dims.^*The collection of forms under the collage._#The optional center of the collage.`-Create a collage from a list of forms. By default, the collage will not be clipped and will not be centered. The origin point of the contained forms will be the top-left of the collage (which in the case of rendering a collage to the screen, is coincidently the top-left of the game window). See a and b.adCenter a collage around a fixed point. This is useful to implement 2D game cameras - usually, you have the center of the screen at the position of the game camera (which in a 2D platformer, is usually your game character). Note that this will center the forms themselves, i.e. their original point will change from being the top left of the collage tob1Clip a collage by provided dimensions. Note that by default, a collage will not be clipped and anything beyond the window dimensions will still technically be rendered (although obviously it will not appear on the game screen). By composing a collage with this function, when the collage is rendered its contents will be clipped by these dimensions. Not only will this generally speed up performance, it can be used for certain cases where you don't want the forms in the collage to spill over to other collages near it (but that's a very rare use-case).bSomething to note, that this is absolutely not an ensurance that your 2D graphics will be rendered quickly if you're doing a lot of graphics work. The clip merely prevents things being drawn outside the dimensions, which in most cases will indeed speed up the performance, but it is down to the engine implementation for how much this actually helps.In that sense, it's up to the library user to make sure they're not rendering huge amounts of forms that aren't even in the screen's bounds.cCreate a form from a collage. This might seem a little strange (as a collage is generally what you provide to the engine to render the 2D graphics) but by allowing this functionality, you can compose collages from other collages.dDCreate a path from a sequence of points (represented as 2D vectors).eCreate an arbitary-sided polygon from a path. The points provided should refer to each corner of the -gon, however the points do not need to loop around (i.e. the final point will automatically connect to the first point).fgCreate a rectangular shape from a 2D vector, with x and y representing width and height, respectively.g)Create a square shape with a side length.h-Create an oval shape with a width and height.i$Create a circle shape with a radius.j]Create a generic n-sided polygon (e.g. octagon, pentagon, etc) with a side count and radius.ktCreate the default line style. By default, the line is black with a width of 1, flat caps and regular sharp joints._Create a initial form from a specific form style. The form will be at the origin point (0, 0).l'Create a solid line style with a color.m(Create a dashed line style with a color.n(Create a dotted line style with a color.(Fill a shape with a specific fill style.oFill a shape with a color.pRFill a shape with a texture. The texture should be an image loaded by the engine.q%Fill a shape with a gradient (either linear or radial).rFCreate a form from a shape by outlining it with a specific line style.sCCreate a form from a path by tracing it with a specific line style.tJCreate an empty form, useful for having forms rendered only at some state.uwCreate a form from an image. If the image dimensions are not the same as provided, then it will stretch/shrink to fit.v=Create a form from an image with a 2D vector describing its dimensions. If the image dimensions are not the same as given, then it will only use the relevant pixels (i.e. cut out the given dimensions instead of scaling). If the given dimensions are bigger than the actual image, than irrelevant pixels are ignored.wCreate a form from an image by cropping it with a certain position, width, height and image file path. This can be used to divide a single image up into smaller ones ( for example, drawing a single sprite from a sprite sheet).x^Group a list of forms into one. They will be drawn in their sequential order within the list.yMGroup a list of forms into one, while also applying a matrix transformation.zMove a form by a given 2D vector. The movement is relative, i.e. the translation vector provided will be added to the form's current position.{Scale a form by a scalar factor. Scaling by 2 will double the size of the form, and scaling by 0.5 will half the size. Note that like z, the scale function is relative - i.e. if you scaled by 0.5 and then scaled by 0.5 a gain, the final scale would be 0.25 or a quarter of the form's initial scale.|3Rotate a form by a given angle (in radians). Like z and {, the rotation is relative.}Change the alpha value of a form (i.e. its transparency). By default, forms will have an alpha value of 1, in other words, they are fully opaque. Alternatively, a value of 0 will mean the form is completely hidden.~Create a form from a  structure, which in turn contains all of the text values and styling. This allows you to render a the text graphically (and in turn it's a regular old form, so it can be translated, rotated, etc.).Q0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a&The position to center the collage at.The source collage.The centered collage.b(The dimensions to clip the collage with.The source collage.The clipped collage.cdefghijklmnopqrstuvwxyz{|}~Y0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y[\]^_MNOPQRSTUVWXYZIJKLEFGHABCD9:;<=>?@783456012`backlmnopqrsuvwt}~xy|{zdefghij+0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe>LfRepresents any form of structure that produces visual graphics to the screen, e.g. 2D or 3D graphics.'The type variable e should refer to an Engine instance.None>L5Represents a key that can be pressed on the keyboard.n9Represents a mouse button that can be pressed on a mouse.u-Represents the configuration for a Helm game.1The type variable e refers to an instance of the J class, m refers to a game model type and a refers to a game action type.wCalled when the game starts up. The first value in the tuple is the initial game model state and then the second value is an optional command to be run. The command allows you to execute some monads during game startup and build up some game actions before the game begins rendering. A good example would be loading a game configuration file, parsing the file contents and then mapping the parsed contents to relevant game actions./If no initial command is required, simply pass ] for the second tuple value. Alternatively, if there are a number of commands to run, call  to combine them into one.xCalled whenever a game action is mapped from a command or subscription. This is where the actual implementation of a Helm game is done. The function is given a game model and the mapped action type, and should produce the new game model state based off of the action.The first tuple value is the new model state, and then the second is a command that can be run to produce more game actions. By having this command returnable here, you can run additional IO logic based off the game action, and produce more game actions from the result.Be very careful with what commands you run in the game update function - most importantly, don't execute long-winding commands or it will block the rendering process!. Helm will try to intelligently queue recursive commands to prevent blocking rendering. However, having a game action that returns a specific command from the update function, which in turn is executed and returns that same game action (which will then in turn return the same command, and so on) is not recommend. The best way to return commands from the update function is to to hide them behind conditionals based off your game state, so that they're not run every update function.yThe subscriptions for a game. All the input sources required to make the game work should be subscribed to and mapped to the relevant game action type variant.IIf no subscriptions are required (i.e. no user input is required), pass =. Alternatively, if multiple subscriptions are required use  to combine them.zCalled when the engine is ready to render the game. The function is given the current state of the game model and should produce a graphics value to be rendered to the screen.Do not rely on this function being called every game tick - the engine will figure out whether it needs to be called based off window exposure and whether or not the game model has changed since the last render.{Represents an IO-like monad with knowledge about the state of the game engine. Each command contains a collection of game actions that will be applied to your game's update function to update the game state. This is similar to a subscription in a way, with the difference being that a command does not change over time, but rather is a lazy monad and hence contains a value that from the time of the execution. A good example of the usage of a command vs. a subscription is the game window size - a command would allow you to map the current window size into an action, whereas a subscription would let you subscribe to when the window is resized and then map that event into a game action.QJust like a subscription, any function that returns a command in the Helm library will first let you map from the original contained value to a game action. It's important to note that commands are **evaluated on the main-thread** - which means they can block the rendering process. *Don't execute long-running monads under commands!*/Here the type variable e is an instance of the N typeclass and the variable a is the game action data type used by your game.}Represents a subscription to a stream of events captured from a user's interaction with the engine. A subscription is best thought of as a collection of events over time - which is the nature of functional reactive programming (the paradigm that Helm bases it's concepts on). Although Helm uses a departed version of the traditional FRP paradigm, it still follows the concept closely and hence an understanding of FRP will allow you to understnad the library easily.hFunctions throughout the Helm library that return a subscription will first let you map the data related to the event you're subscribing to into another form (specifically, a game action). These game actions are then sent to the update function of your game, i.e. the mapped subscription specifies exactly how game events will interact with your game state./Here the type variable e is an instance of the N typeclass and the variable a is the game action data type used by your game.5Represents a backend engine that can run a Helm game.HHelm separates the logic for running a game from the actual interaction with the user - window management, event management (key presses, mouse presses, etc.) are all handled by a specific instance of the engine typeclass. Meanwhile, the game loop and other core features are handled independently by the Helm library itself.7Renders a graphics element to the engine's game window. Ticks (or steps) the engine forward. Generally, an engine should use this method to gather any new input events from the underlying engine and sink them into the signals it provides below. Depending on the implementation of the engine, it might be necessary to do other things here too.Cleans up all resources loaded by the engine. This will be run when the engine has stopped execution, hence it should do everything required to free any resources allocated by the engine.Get the game window size."Get the current game running time.:The mouse move signal, with events provided by the engine.:The mouse down signal, with events provided by the engine.8The mouse up signal, with events provided by the engine.;The mouse click signal, with events provided by the engine.=The keyboard down signal, with events provided by the engine.;The keyboard up signal, with events provided by the engine.>The keyboard press signal, with events provided by the engine.=The window resize signal, with events provided by the engine.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ {|uvwxyz}~nopqrst      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None>L-Combine a list of commands into a single one.A command that does nothing. When returned in a Helm game's update or initial functions, it will not produce any game actions.]Execute an IO monad and then map its result to a game action. This can be used as a kind of liftIOp, however to keep things consistent with the rest of the library, you must map the monad result a game action. The list of commands to combine.The accumulated command.The IO monad to execute.2The function to map the monad result to an action.The mapped command.{|{| None>L+Represents the SDL engine's internal state.>Represents the configuration to run the SDL engine with. Use  defaultConfig+ and then only change the necessary fields. None>L The Cairo surface for the image.7The image dimensions of the image (when it was loaded).Load an image asset using the SDL engine and do something with it. The image will be cleaned up once the provided monad completes.7Currently, the only supported image file format is PNG.#The expected usage would be to use  for each image you need to load before running the engine, and then use the images with graphics. Once the engine stops running, the image will then be automatically cleaned up.Represents an / for the SDL engine.// None>L!Map an SDL keycode to a Helm key. None>L/Map an SDL mouse button to a Helm mouse button. None>LSubscribe to keyboard press events and map to a game action. A key press event is produced whenever a key is either released or continously held down.;Subscribe to keyboard down events and map to a game action.9Subscribe to keyboard up events and map to a game action.1The function to map the key pressed to an action.The mapped subscription.3The function to map the key held down to an action.The mapped subscription.2The function to map the key released to an action.The mapped subscription.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmNone>L<Subscribe to mouse movement events and map to a game action.Subscribe to mouse click events and map to a game action. This subscription is for all mouse buttons - you'll need to match over a mouse button if you want to capture a specific one.Note that Helm defines a mouse click as a mouse up event which came after a very recent mouse down event in a close radius of the mouse down event.?Subscribe to mouse button down events and map to a game action.=Subscribe to mouse button up events and map to a game action.2The function to map a mouse position to an action.The mapped subscription.=The function to map a mouse button and position to an action.The mapped subscription.=The function to map a mouse button and position to an action.The mapped subscription.=The function to map a mouse button and position to an action.The mapped subscription. nopqrst nopqrstNone>LCombine a list of subscriptions into a single one. This is allows for subscriptions to multiple input events to be combined into one subscription that encompasses all the actions mapped from events.A subscription that does nothing. If user input events aren't required for a game, return this in the subscriptions function of the game.The list of subscriptions.The subscriptions accumulated.}~}~None>L vRepresents an amount of time in an arbitary unit. This type can then be composed with the relevant utility functions.*A time value representing one millisecond.%A time value representing one second.%A time value representing one minute.#A time value representing one hour.=Converts a time value to a fractional value, in milliseconds.8Converts a time value to a fractional value, in seconds.8Converts a time value to a fractional value, in minutes.6Converts a time value to a fractional value, in hours.Map the running time of the engine to a game action. Note that this is not the current clock time but rather the engine time, i.e. when the engine first starts running, the applied value will be zero.4Generic subscription for time interval-based events.oSubscribe to the running time of the engine and map to a game action, producing events at a provided interval.Subscribe to events that emit at a provided frames per second and map to a game action, producing events at a provided interval. The time value applied is the delta between the current and last event emission time. 2The function to map the running time to an action.The mapped command.*The interval of time to produce events at.2The function to map the running time to an action.The mapped subscription.The frames per second.0The function to map the time delta to an action.The mapped subscription.   None>L*Map the game window size to a game action.MSubscribe to the resize events from the game window and map to a game action.1The function to map the window size to an action.The mapped command.9The function to map the changed window size to an action.The mapped subscription.None>L @Render a 2D element to an SDL texture (with a width and height).1Render a collage (a group of forms with context).Map a ! to a Pango font weight.Map a  variant to a Pango font style.WSetup a transformation state, render something with it, and then restore the old state.Set the Cairo line cap from a E.Set the Cairo line join from a A.Set up all the necessary settings with Cairo to render with a line style (and then stroke the line). Assumes that all drawing paths have already been setup before being called.Set up all the necessary settings with Cairo to render with a fill style (and then fill the line). Assumes that all drawing paths have already been setup before being called..Add color stops to a pattern and then fill it.Render a form. &The x and y scale factor of the state.,The theta rotation of the state, in radians.&The x translation value for the state.&The y translation value for the state.6The render monad to run with the transformation state.The final render monad. None>LWThe default configuration for the engine. You should change the values where necessary.[Initialize a new engine with default configuration. The engine can then be run later using run.@Prepare a texture for streamed rendering based of a window size.<Initialize a new engine with some configration, ready to be run.*Renders a 2D element to the engine screen.8Turns a point containing a vector into a regular vector.Sink an SDL event into the Elerea sinks initialized at startup of the SDL engine. These sinks then provide the data for the Elerea signals, which will be in turn will provide the Helm subscriptions with events.  None>LMA data structure describing a game's state (that is running under an engine).0The configuration of the game, passed by a user.The current game model state.@A feedable monad that returns actions from mapped subscriptions.BPrepare the game state from an engine and some game configuration.&Runs a Helm game using an engine and some configuration for a game. An engine should first be initialized separately to Helm, and then passed to this function. Helm is written this way so that library users can choose what backend engine they want to use (and hence Helm is engine-agnostic).The best engine to get started with is the SDL implementation of Helm, which is currently bundled with the engine (although it will eventually be moved to its own package). See L for how to startup the SDL engine, which can then be run by this function.Step the game state forward.8Step the game model forward with a specific game action. /uvwxyz{|}~{|uvwxyz/}~ !"#$$%&'()*+,--./0123456789:;<=>?@ABCDEFGHIJKLMNNOOPQRSTUVWXYZ[\]^_`!aabcdefghijklmnnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                       EV8BUlk6uKZ800Cot9Tap8Helm.Graphics2D.Transform Helm.ColorHelm.Graphics2D.Text Helm.AssetHelm.Graphics2D Helm.Graphics Helm.EngineHelm.CmdHelm.Engine.SDL.EngineHelm.Engine.SDL.AssetHelm.Engine.SDL.KeyboardHelm.Engine.SDL.Mouse Helm.Keyboard Helm.MouseHelm.Sub Helm.Time Helm.WindowHelm.Engine.SDL.Graphics2DHelm.Engine.SDLHelmCmdnonebatchSubstartup Transformidentitymatrixrotation translationscalemultiplyGradientLinearRadialColorrgbrgbablend complementhsvahsvlinearradialText textString textColor textTypeface textHeight textWeight textStyle FontStyle NormalStyle ObliqueStyle ItalicStyle FontWeight LightWeight NormalWeight BoldWeight defaultTexttoTextshowTextboldlightitalicobliquecolortypefaceheightImage ShapeStyle OutlinedShape FilledShapeShape PolygonShapeRectangleShapeArcShapePath LineStyle lineColor lineWidthlineCaplineJoin lineDashinglineDashOffsetLineJoin SmoothJoin SharpJoin ClippedJoinLineCapFlatCapRoundCap PaddedCap FillStyleSolidTextureForm formTheta formScaleformPos formAlpha formStyle FormStylePathForm ShapeFormTextForm ImageForm GroupForm CollageFormCollage collageDims collageForms collageCentercollagecentercliptoFormpathpolygonrectsquareovalcirclengon defaultLinesoliddasheddottedfilledtexturedgradientoutlinedtracedblankimage fittedImage croppedImagegroupgroupTransformmoverotatealphatextGraphics Graphics2DKey ReturnKey EscapeKey BackspaceKeyTabKeySpaceKey ExclaimKey QuoteDblKeyHashKey PercentKey DollarKey AmpersandKeyQuoteKey LeftParenKey RightParenKey AsteriskKeyPlusKeyCommaKeyMinusKey PeriodKeySlashKey Number0Key Number1Key Number2Key Number3Key Number4Key Number5Key Number6Key Number7Key Number8Key Number9KeyColonKey SemicolonKeyLessKey EqualsKey GreaterKey QuestionKeyAtKeyLeftBracketKey BackslashKeyRightBracketKeyCaretKey UnderscoreKey BackquoteKeyAKeyBKeyCKeyDKeyEKeyFKeyGKeyHKeyIKeyJKeyKKeyLKeyMKeyNKeyOKeyPKeyQKeyRKeySKeyTKeyUKeyVKeyWKeyXKeyYKeyZKey CapsLockKeyF1KeyF2KeyF3KeyF4KeyF5KeyF6KeyF7KeyF8KeyF9KeyF10KeyF11KeyF12KeyPrintScreenKey ScrollLockKeyPauseKey InsertKeyHomeKey PageUpKey DeleteKeyEndKey PageDownKeyRightKeyLeftKeyDownKeyUpKeyNumLockClearKeyKeypadDivideKeyKeypadMultiplyKeyKeypadMinusKey KeypadPlusKeyKeypadEnterKeyKeypadNumber1KeyKeypadNumber2KeyKeypadNumber3KeyKeypadNumber4KeyKeypadNumber5KeyKeypadNumber6KeyKeypadNumber7KeyKeypadNumber8KeyKeypadNumber9KeyKeypadNumber0KeyKeypadPeriodKeyApplicationKeyPowerKeyKeypadEqualsKeyF13KeyF14KeyF15KeyF16KeyF17KeyF18KeyF19KeyF20KeyF21KeyF22KeyF23KeyF24Key ExecuteKeyHelpKeyMenuKey SelectKeyStopKeyAgainKeyUndoKeyCutKeyCopyKeyPasteKeyFindKeyMuteKey VolumeUpKey VolumeDownKeyKeypadCommaKeyKeypadEqualsAS400Key AltEraseKey SysReqKey CancelKeyClearKeyPriorKey Return2Key SeparatorKeyOutKeyOperKey ClearAgainKeyCrSelKeyExSelKey Keypad00Key Keypad000KeyThousandsSeparatorKeyDecimalSeparatorKeyCurrencyUnitKeyCurrencySubunitKeyKeypadLeftParenKeyKeypadRightParenKeyKeypadLeftBraceKeyKeypadRightBraceKey KeypadTabKeyKeypadBackspaceKey KeypadAKey KeypadBKey KeypadCKey KeypadDKey KeypadEKey KeypadFKey KeypadXorKeyKeypadPowerKeyKeypadPercentKey KeypadLessKeyKeypadGreaterKeyKeypadAmpersandKeyKeypadDblAmpersandKeyKeypadVerticalBarKeyKeypadDblVerticalBarKeyKeypadColonKey KeypadHashKeyKeypadSpaceKey KeypadAtKeyKeypadExclamKeyKeypadMemStoreKeyKeypadMemRecallKeyKeypadMemClearKeyKeypadMemAddKeyKeypadMemSubtractKeyKeypadMemMultiplyKeyKeypadMemDivideKeyKeypadPlusMinusKeyKeypadClearKeyKeypadClearEntryKeyKeypadBinaryKeyKeypadOctalKeyKeypadDecimalKeyKeypadHexadecimalKey LeftCtrlKey LeftShiftKey LeftAltKey LeftGUIKey RightCtrlKey RightShiftKey RightAltKey RightGUIKeyModeKey AudioNextKey AudioPrevKey AudioStopKey AudioPlayKey AudioMuteKeyMediaSelectKeyWWWKeyMailKey CalculatorKey ComputerKey ACSearchKey ACHomeKey ACBackKey ACForwardKey ACStopKey ACRefreshKeyACBookmarksKeyBrightnessDownKeyBrightnessUpKeyDisplaySwitchKeyKeyboardIllumToggleKeyKeyboardIllumDownKeyKeyboardIllumUpKeyEjectKeySleepKey UnknownKey MouseButton LeftButton MiddleButton RightButtonX1ButtonX2Button UnknownButton GameConfig initialFnupdateFnsubscriptionsFnviewFnEnginerendertickcleanup windowSize runningTimemouseMoveSignalmouseDownSignal mouseUpSignalmouseClickSignalkeyboardDownSignalkeyboardUpSignalkeyboardPressSignalwindowResizeSignalexecute SDLEnginewindowrenderertexture engineConfiglastMousePressmouseMoveEventSignalmouseMoveEventSinkmouseDownEventSignalmouseDownEventSinkmouseUpEventSignalmouseUpEventSinkmouseClickEventSignalmouseClickEventSinkkeyboardDownEventSignalkeyboardDownEventSinkkeyboardUpEventSignalkeyboardUpEventSinkkeyboardPressEventSignalkeyboardPressEventSinkwindowResizeEventSignalwindowResizeEventSinkSDLEngineConfigwindowDimensionswindowIsFullscreenwindowIsResizable windowTitle withImagemapKeymapMouseButtonpressesdownsupsmovesclicksTime millisecondsecondminutehourinMilliseconds inSeconds inMinutesinHoursnoweveryfpssizeresizes defaultConfig startupWithrun$fNumTransformblend'baseGHC.ShowShow defaultFormfill cairoSurface imageDimsTFCo:R:ImageSDLEngineSDLImageevery' renderCollage mapFontWeight mapFontStyle withTransform setLineCap setLineJoin setLineStyle setFillStylesetGradientFill renderForm prepTexturerender2ddepoint sinkEvent$fEngineSDLEngineGame gameConfig gameModel actionSmppreparestep stepModel