!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCD E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%& ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d"e"f"g"h"i"j"k"l"m"n"o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~############$$$$$$%%%%%%%%%%%%%'Safe The class of types that can be pretty-printed. (Unfortunately this is not very useful, because and Expr can be pretty Haskell or pretty Python or pretty Scheme, leading to overlapping instance declarations.))pretty x is a pretty String representation of x. prettyList prefix infix postfix xs is a pretty String representation of the list xs, with prefix, infix, and postfix specifying the punctuation. For example, if (pretty x) => "x", then prettyList "[" ", " "]" [x, x, x] => "[x, x, x]"./Minimal complete implementation: define pretty.Indent a single line n spaces.GsepLines is like unlines, but omits the n at the end of the last line.hsepLines2 is like sepLines, but adds an extra n between each pair of lines so they are "double spaced."1Separate strings by commas and nothing else (","),Separate strings by commas and spaces (", ")%Separate strings by just spaces (" ")           &Safe  None8Set the X Window cursor for a window to a specified typeNone   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   $~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:987631524('&%  !#" )+0,.-/*Safe _Enclose in parentheses, like a Lisp function call. Example: par "foo" ["x", "y"] = "(foo x y)" *Write a list of words, separated by spaces!.Write a list of words, not separated by spaces%:Signal an error using a list of strings to be concatenated&ZSignal an error using a list of strings to be concatenated with spaces between (unwords).''Generalization of map to lists of lists((Generalization of mapM to lists of lists)]Insert an item into a list of lists of items, making it the last element in the last sublist*=Insert an item in a list of items, making it the last element+RUpdate a value at a given key by applying a function. Similar to Data.Map.adjust.,&Monadic generalization of adjustAList  !"#$%&'()*+, !"#$%&'()*+, !"#$%&'(+,)* !"#$%&'()*+,Nonetext for the expander button)use the root to add rpanel to a containerids of widgets added, in rowsframe, same as rootexpandervbox to contain the rows!next element goes here if it fitsfree width in current rowmaximum row widthhorizontal padding2YGiven a list of (name, widget) pairs, add each of the widgets and its name to the rpanel3'Add a single named widget to the RPanel4#Force the RPanel to begin a new row5Given a list of lists, each sublist representing a row of widgets, add the widgets to the RPanel, preserving the row structure as much as possible. (Row structure will be broken if any intended row is too wide.)Add a row of widgets to an RPanel. This does not start a new row before the first widget, but after the last, so at the end, the current row will be empty.-./012345 -./012345 -1./03245 - ./012345None9Show a message and a set of choices; run the action corresponding to the selected choice. The last argument is an action corresponding to the Cancel option (a Cancel button is automatically inserted) and is also used for strange actions like closing the dialog window. A good value for this might be return ().:Where to put a dialog window. Possible values are WinPosNone WinPosCenter WinPosMouse WinPosCenterAlways WinPosCenterOnParent;+Customizable framework for running a dialogC%Add a labeled text entry to the vbox.6789:;<=>?@ABC6789:;<=>?@ABC89:<;=>?@67ABC6789:;<=>?@ABC NoneDGA Translate is a thing that can be repositioned by delta x and delta yGhMake an object have at least a specified minimum width; does nothing if it's already at least that wideH4BBox x y width height; (x, y) is the top left corner[BBox accessors and utilities\BBox accessors and utilities]BBox accessors and utilities^BBox accessors and utilitiesk)Form a new BBox which encloses two bboxes0DEdelta Xdelta Ything in old positionthing in new positionFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm*DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm*RSTUVWXYNOPQZJKLMHI[\]b^_`ijacdefghklmFGDE$DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm Safe nUA Number represents a real number, which can be exact (Integer) or inexact (Double).qTell whether a Number is exactrATake a number, which may be exact or inexact, and produce the inexact number which equals it. Note that there is no inverse function toExact, because some inexact numbers like 3.5 are not equal to any exact number. The class RealFrac provides methods round, ceiling, floor, truncate for converting to exact numbers.Unary operations fall into two groups: exactOp1 works only for an exact operand; it is an error if the operand is inexact. The result is always exact. (Unused) inexactOp1 works directly for an inexact operand; otherwise by conversion of its exact operand to inexact; the result is always inexact. eitherOp1 works for either exact or inexact operand, and the result is exact if and only if the operand is exact.[Binary operations fall in 3 groups: exactOp2 is implemented only for exact, exact operands; if there's any inexact operand, it's an error. Integer division operations (quot, rem, div, mod) are like this. The result is always exact. eitherOp2 is implemented directly for exact, exact operands and inexact, inexact operands; if one operand is exact and the other inexact, the exact operand is converted to inexact. Most arithmetic operations (+, -, *) are like this. The result may be exact or inexact. inexactop2 is directly implemented for inexact, inexact operands, but handles exact operands by converting them to inexact (even if both are exact). Math functions such as exp, log, sqrt, and sin are like this. The result is always inexact.Numbers are Floating, i.e., support exponential, log, and trig functions. This works directly for inexact Numbers, and otherwise by conversion from Exact to Inexact.Numbers are Fractional, i.e., support division and conversion from Rational. This works directly for inexact Numbers, and otherwise by conversion from Exact to Inexact.pNumbers are Integral, i.e., can do integer division and convert to Integer. However, there is a restriction: this only works for Exact numbers; for Inexact, there will be an error. Some may see this as regrettable, but how is it different in principle from division, which doesn't work for zero divisors, and square root, which doesn't work for negative numbers?In Haskell both Intgeger and Double are instances of Enum, so Number should be an instance too. Also, this is a prerequisite of being an instance of Integral.4Numbers are Real, i.e., can be converted to RationalNumber as an instance of NumNumber as an ordered typeThis Show instance will not be compatible with the derived Read instance above -- so fix it. (And yet, mysteriously, ghci accepts 1 and 1.0 as Number literals.)nopqrstuvw nopqrstuvw nopqrstuvwnopqrstuvw Safez:class Repr: representable by a String or a list of Strings^repr x is a String representation of x. reprl x is a [String] representation of x, where the first element should be the same as repr x, and the rest provide auxiliary information that you want to be shown with x. reprs x is a reduction of reprl x to a single String. reprList prefix infix postfix xs is the representation of a list of xsMinimal complete implementation: define repr, or define reprl. The normal way is to define repr. Define reprl instead, if for some reason you want to include additional information such as the value of an expression in an expression node.Examples: - (3 :: Int) has repr => "3", reprl => ["3"], reprs => "3" - In Language.Sifflet.Expr, (ENode (NSymbol "x") (EvalOk (3 :: Int) has reprl => ["x", "3"], reprs => "x 3", and repr => "x". - reprList "(" " " ")" [3 :: Int, 4, 5] => "(3 4 5)"xyz{|}~xyz{|}~z{|}~xy xyz{|}~Safe xyz{|}~z{|}~xy  None:An Iolet is a circular port. Other shapes could be added.ftExtents: used for what?$Center a GNode in a rectangular area tree styletop left after paddingkthe tree being laid out (actually we don't need the tree as an argument; it's implied by the GNode tree) "node sizes" tree SizesyyO  Safe/SAn Environment contains variable bindings and may be linked to a next environmentIPerhaps it may also be used to generate Vp type variables (with int id's) ;A function may have a name and always has an implementationQA collection of functions, typically to be saved or exported or read from a filehA Type is either a type variable or a constructed type with a constructor and a list of type parametersType constructor name)Type variable name !IOperator grouping: left to right or right to left, or perhaps not at all%XOperator priority, normally is > 0 or >= 0, but does that really matter? I think not.&An operator, such as * or + An operator is associative, like +, if (a + b) + c == a + (b + c). Its grouping is left to right if (a op b op c) means (a op b) op c; right to left if (a op b op c) means a op (b op c). Most operators group left to right.* associative?,)A more highly "parsed" type of expressionFunction calls have two kinds: 1. ECall: restricted to the case where the function expression is just a symbol, since otherwise it will be hard to visualize. 2. EApp: allows any expression to be the function, but is applied to only one argument. For now, the type checker will convert ECall expressions to EApp expressions. Ultimately, the two variants ought to be unified.The constructors EOp and EGroup are not used in Sifflet itself, but they are needed for export to Python, Haskell, and similar languages; they allow a distinction between operators and functions, and wrapping expressions in parentheses. EGroup e represents parentheses used for grouping: (e); it is not used for other cases of parentheses, e.g., around the argument list in a function call.] 3if test branch1 branch26apply function to argument7function name, arglist8binary operator application9grouping parenthesesrTransform a numerical expression into its negation, e.g., 5 --> (-5). Fails if the expression is not an ENumber.?Try to convert the arguments and body of a function to a lambda expression. Fails if there are no arguments, since a lambda expression requires one. If there are multiple arguments, then we get a nested lambda expression.@1Convert an ECall expression to an EApp expressionAHelper for callToApp, but may have other uses. Creates an EApp expression representing a function call with possibly many arguments.B1Convert an EApp expression to an ECall expressionCLHelper for appToCall, but may have other uses. Creates an ECall expression.xAn Expr is "extended" if it uses the extended constructors EOp or EGroup. In pure Sifflet, no extended Exprs are used.DIs an Expr a literal? A literal is a boolean, character, number, string, or list of literals. We (should) only allow user input expressions to be literal expressions.EIs an expression atomic? Atomic expressions do not need parentheses in any reasonable language, because there is nothing to be grouped (symbols, literals) or in the case of lists, they already have brackets which separate them from their neighbors.xAll lists are atomic, even if they are not literals, because (for example) we can remove parentheses from ([a + b, 7])FCompound = non-atomicR0Example: ePlus_2_3 = eCall "+" [eInt 2, eInt 3]T3The value of an expression in the base environment.Convert a literal expression to the value it represents. It is an error if the expression is non-literal. See exprIsLiteral. \lThe type of a function, from its argument types and result type, where (a -> b) is represented as TypeCons Functionz [a, b]. Note that for n-ary functions, n > 2 implies nested function types: (a -> b -> c) is represented as TypeCons Function [a, TypeCons Function [b, c]], etc.]HTry to find the number of inlets for an argument from a list of ArgSpecd<Type type of a function, a tuple of (arg types, result type)eDThe type of a function, where (a -> b) is represented as TypeCons Function [a, b]n6Insert names and values from lists into an environmentq/Get the value of a variable from an environmentu,List of all symbols bound in the environmentv9List of all symbols bound to functions in the environmentw$All the functions in the environmentx/Return to the environment prior to an extendEnv|yApply a function fvalue to a list of actual arguments args in an environment env and with a limited stack size stacksizeInteger div and mod operations, for exact integers only. Using an inexact (floating point) argument is an error, even if the argument is "equal" to an integer (e.g., 5.0). Division (div or mod) by zero is an error.Floating point division. Integer arguments are coerced to floating point, and the result is always floating point. operands are ints. x / 0 is NaN if x == 0, Infinity if x > 0, -Infinity if x < 0.xPrimitive function with 2 number arguments yield an number value fn = Number function to implement for Number operands.*Primitive unary functions number to numberWGiven an expression, return the list of names of variables occurring in the expressionexprVarNames expr returns the names of variables in expr that are UNBOUND in the base environment. This may not be ideal, but it's a start.{We need to be able to say functions are equal (or not) in order to tell if environments are equal or not, in order to know whether there are unsaved changes. This is tricky since the primitive function implementations do not instantiate Eq, so if it's primitive == primitive? we go by the names alone (there's nothing else to go by). Otherwise all the parts must be equal.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   ]TUV=><;:,-./0123456789GHIJKL?@ABCEFMNOPQRD&'()*+%!"#$ S  `a^bcdegjfhiWXYZ[\klmnxopqrstuvwz{y|_}~      !"#$%&'()*+, -./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     Safe <The type of a function to export (user) functions to a file.Simplify an expression by applying rules top-down throughout the expression tree and repeatedly until there is no change. This is intended for removing extra parentheses, but could be used for other forms of simplification.Should each rule also know the level in the original expr tree, with 0 = top level (root)? That would require additional arguments.Repeatedly apply a function to an object until there is no change, that is, until reaching a fixed point of the function, a point where f x == x.)Common rules for simplifying parentheses.mRemove ()'s around a higher precedence operator: e.g., (a * b) + c ==> a * b + c a + (b * c) ==> a + b * cHRemove ()'s around an atomic expression -- a variable, literal, or listRemove ()'s in the case of (a op1 b) op2 c, if op1 and op2 have the same precedence, and both group left to right, since left to right evaluation makes them unnecessary.Remove ()'s in the case of a op (b op c) if op groups right to left, and note that it is the same operator op in both places (though I don't know if that restriction is necessary). This applies to (:) in Haskell, for example: x : y : zs == x : (y : zs)A list of common rules for simplifying expressions. Does *not* include ruleIfRight, since that works for Haskell but not Python. Try the first rule in a list to see if it changes an expression, returning the new expression if it does; otherwise, try the next rule, and so on; if no rule changes the expression, then return the expression. (Note that (applyFirstMatch rules) is itself a rule.)xApply a rule top-down to all levels of an expression. Normally, the "rule" would be a value of (applyFirstMatch rules).    Safe5grossProfit salesA salesB = 0.12 salesA + 0.25 salesBlbonus1 profit = if profit > 100000 then 1000 + 0.0012 * profit else 09bonus2 salesA salesB = bonus1 (grossProfit salesA salesB)foo a b = 2 * a + b(An expression representing a call to foo max x y = if x > y then x else y(An expression representing a call to max1fact n = if n == 0 then 1 else n * (fact (n - 1)))An expression representing a call to factbsum of the integers 0..n Lewis and Loftus, Jave Software Solutions, 6th. ed. (they call it "sum")rmul: multiplication by repeated addition. The "multiply" function in Hanly and Koffman, "Problem Solving and Program Design in C", 5th ed.)An expression representing a call to rmul,Even and odd, the slow way. Springer and Friedman, Scheme and the Art of Programming (??). Rubio-Sanchez, Urquiza-Fuentes, and Pareja-Flores, "A Gentle Introduction to Mutual Recursion", in ITiCSE 2008: The 13th SIGCSE Conference on Innovation and Technology in Computer Science Education, 2008.,Even and odd, the slow way. Springer and Friedman, Scheme and the Art of Programming (??). Rubio-Sanchez, Urquiza-Fuentes, and Pareja-Flores, "A Gentle Introduction to Mutual Recursion", in ITiCSE 2008: The 13th SIGCSE Conference on Innovation and Technology in Computer Science Education, 2008. tFibonacci series through mutual recursion. Rubio-Sanchez, Urquiza-Fuentes, and Pareja-Flores, "Gentle Introduction"!tFibonacci series through mutual recursion. Rubio-Sanchez, Urquiza-Fuentes, and Pareja-Flores, "Gentle Introduction"PThis function will be in error if the function name is not found in exampleEnv.$"#$%&'() !*+,-./01$"#$%&'() !*+,-./01SafeA Haskell function or variable declaration. An explicit type declaration is optional. Thus we have just enough for name :: type name [args] = expr. Of course [args] would be empty if it's just a variable.A Haskell modules import decls: a list of module identifiers. No support for "qualified" or "as" or for selecting only some identifiers from the imported modules.MA Haskell module's export spec: a list of function and variable identifiers:A Haskell module; moduleDecls are functions and variables.2Wrap a string in parentheses2The Haskell operators. Now what about the associativity of (:)? It really doesn't even make sense to ask if (:) is associative in the usual sense, since (x1 : x2) : xs == x1 : (x2 : xs) is not only untrue, but the left-hand side is a type error, except maybe in some very special cases (and then the right-hand side would probably be a type error). Is (:) what is called a "right-associative" operator? And do I need to expand my Operator type to include this? And then what about (-) and (/)??? Does this affect their relationship with (+) and (-)?3=HsPretty expressions. This is going to be like in Python.hs.2345678923456789SafeUser configurable options for export to Haskell. Currently these options are unused. The line width options should probably go somewhere else, maybe as PrettyOptions.*The default options for export to Haskell.1Export functions with specified options to a file)Converting Sifflet to Haskell syntax tree1Create a module from a module name and Functions.xCreate a declaration from a Function. Needs work: infer and declare the type of the function. Minimally parenthesized.=Converts a Sifflet Expr to a fully parenthesized Haskell Expr:Map Sifflet names to Haskell names. Returns a Left Operator for Haskell operators, which always have the same name as their corresponding Sifflet functions, or a Right String for Haskell function and variable names. ;<:   ;<:SafePython statementimport statementif condition action alt-action&function name, formal parameters, bodyOPython module -- essentially a list of statements; should it also have a name?Python return statementPython if STATEMENTPython variablePython identifierBPython character expression = string expression with one character= Python function formal parameterDefines function definitionjBinary operators Precedence levels are rather *informally* described in The Python Language Reference,  !http://docs.python.org/reference/. I am adopting the infixr levels from Haskell, which seem to be consistent with Python, at least for the operators that Sifflet uses.V| Operator information Arithmetic operators: + and - have lower precedence than *, ,  /, % | Comparison operators have precedence lower than any arithmetic operator. Here, I've specified associative = False, because association doesn't even make sense (well, it does in Python but not in other languages); (a == b) == c is in general not well typed.>Expr as an instance of PyPretty. This instance is only for Exprs as Python exprs, for export to Python! It will conflict with the one in ToHaskell.hs (or Haskell.hs).The EOp case needs work to deal with precedences and avoid unnecessary parens. Note that this instance declaration is for *Python* Exprs. Haskell Exprs of course should not be pretty-printed the same way!?=>@ABC?=>@ABCNoneLEXPRESSION TREES For pure Sifflet, so not defined for extended expressions.7Counts the number of inlets and outlets for an ExprNodexConvert an expression tree (back) to an expression It will not give back the *same* expression in the case of an EList.DE DENone/What is a FunctoidLayout? You can think of it as a tree layout for a Frame, or for a Functoid, or as a Forest of Tree Layouts! For an Edit frame, it must be a forest, since the nodes are not yet necessarily connected into a tree. For a call frame, it will be a single TreeLayout (singleton list).sA Functoid is either a FunctoidParts, representing a partially defined function, or a (completely defined) Function. A FunctoidParts represents an incompletely defined function, which has a function name, argument names, and a list of graph nodes representing the function body which might not yet form a complete expression tree, e.g., nodes might be unconnected.Graphically lay out the Functoid. mvalues: Nothing implies an uncalled frame, Just values implies a called frame, even with 0 arguments.F FNoneGHIJKLMNOPQRSTUGHIJKLMNOPQRSTUNoneTwo kinds of WNodes: A WSimple node represents a node in an expression tree, e.g., "if", "+" A WFrame node represents a panel or frame that displays an expression tree, function call, or something similar. tA WGraph consists of WNodes with (sort of) Int-labled edges; the edge labels serve to order the children of a node.!Print a description of the WGraphNext node number which may be used in a graph. For an empty graph, this is 0. Otherwise it is 1 + the maximum node in the graph.tInsert new node with given label into graph, without any new edges; return the new graph and the new node (number)7Remove a node from the graph; return the updated graph.Connect parent to child, using inlet as the order of the child (0, 1, ...). outlet is ignored, since there is only outlet 0. As rendered, the parent's inlet-th inlet will have a line to the child's outlet-th outlet. This is achieved by inserting a labeled edge (parent, child, inlet) and clearing any incompatible edge. The incompatibles are: a. from same parent on same inlet to a different child. b. from the same parent on a different inlet to the same child. c. from same child (on same outlet) to a different parent.NOTE: This is confusing, because, from the data flow perspective, data flows OUT of the child INTO the parent, but from the "tree in graph" perspective, links are directed OUT of the parent INTO the child. So beware!MTell whether a parent node already has a child connected on the given inlet.8Removes a link between parent and child where the edge was labeled inlet (order of child). Ignores outlet, which should always be 0. If child is not the inlet-th child of parent, well, this is an error, but grDisconnect ignores it. If toFrameP is true, the child node is reconnected as a child to its frameExtract from a graph the expression with root node n, returning a Tree of ExprNode. Use only the WSimple nodes of the graph (and n had better be one).kFinding characteristics of the WNodes in a graph It is an implicit error if there is no label for the node<wlab is like lab with no Maybe: the node *must* have a label.llab is the tree layout node of a WSimple node*The ExprNode represented by the graph nodeThe repr of the node's value5The result of an evaluated node in an expression treeThe node's BBox!$Find all parentless nodes in a graph"*Connect the given children to a new parent#Finding the children (nodes, numbers) of a node in a graph : all children, only WSimple-labeled children, only WFrame-labeled children When constructing the graph, ordered children of a tree node get graph node numbers in ascending order; therefore, sorting the graph nodes gives back the original order of children in the tree (plus WFrames that are added later, and those should always be after the simple children)%:All (proper and improper) descendants of a node in a graph*'An open node has a WFrame-labeled child+8The graph node of the frame that contains the given node,The parent (if any) of a node.BReplace the tree embedded in graph g with root n, with a new tree./@Extract just the single tree layout node of the given graph node0AExtract the tree layout (tree) descended from the given root node16Translate the nodes forming a tree with the given root4&Replace the label of a node in a graph5_Get the parts of a Functoid. See note on functionToParts (just below). Seems to be unused ***6Convert a function to its parts. COULDN'T THIS BE DONE USING the function's implementation, and not need to use the graph? Then this could go in Functoid.hs without circular import between it and WGraph7Filter the nodes of a graph9     VWX !"#$%&'()*+,-./01234567YZ[3      !"#$%&'()*+,-./012345673     /0 !"#$%(&')*+,-.23415676     VWX !"#$%&'()*+,-./01234567YZ[None;A CanvFrame represents (indirectly, through cfRoot, and we access to the graph which is provided by the VCanvas) a "subgraph" such as the expression tree of a function which is being edited or called.=top area of the frame> bottom area?variable (parameter) names@"the node opened to make this frameAIthis frame as a node in the graph; also serves as the ID of the frame.Benvironment for evaluationC1box of the whole frame (header, tree, and footer)D'0 = bottom level, 1 = next higher, etc.Eincludes tlo for an edit frameFedit or call frameG5Use levelOrder for sorting frames before drawing themH+The root of the tree displayed in the frameInA frame is "eval ready" -- that is, okay to run the Eval Frame dialog -- if it is a call frame with no parentQkWhere to position a new frame that is grown out of an old frame? This is a very rough draft of frameOffsetUyargIoletCounter returns (no. of inlets, no. of outlets) derived from the argument list of a function still being defined\Aligning a CanvFrame's header and footer with the body of the frame. Aligns the header above, and the footer below, the body of the frame, also matching the width if the body widenedVFigure out the frame layout for a function. Returns the layout and frame. Currently, the frame is marked as a "call frame"; if you want to edit it, call (editFrame? editFunction?)]vCanvFrame needs to be Eq in order to be Ord, but maybe the Eq and Ord definitions should be more in the same spirit?&89:;<=>?@ABCDEFGHIJKL^M_`NOPQRSTU\aVb]89:;<=>?@ABCDEFGHIJKLMNOPQRSTUV;<=>?@ABCDEF89:UNIJKHVLMQGRTOPS89:; <=>?@ABCDEFGHIJKL^M_`NOPQRSTU\aVb]None WZA Dragging keeps track of the object (node) being dragged and the current mouse position.bdA canvas that can display multiple boxes representing expressions or function definitions or callsnRToolContext: The way a tool should be applied depends on where it is being used yToolOp a is intended for a = VPUIWindow or VCanvas type ToolOp a = VPUI -> a -> ToolContext -> [Modifier] -> Double -> Double -> IO az:A Toolbox is a framed VBox with a set of Toolbars attached~OToolkit functions are organized in groups (rows) for presentation in a toolboxcontainer of the rest the canvasnone if not editingVPUI: Sifflet (formerly VisiProg) User Interface The initialEnv is apt to contain "builtin" functions; it's preserved here so that when writing to a file, we can skip the functions that were in the initial env.all the windows of the program/ordered association list, collections of toolsthe file opened or to savefor windows, canvases, editors#initial value of global environmentthe global environmentHglobal env as of last file open or save, used to detect unsaved changes'include debug commands in context menu?RTell whether the global environmkent has changed since the last file open or saveExtract from the environment the part defined by the user But you probably want to use Graphics.UI.Sifflet.Window.UserFunctions instead of this.!Insert a window in the window mapRTry to get the VPUIWindow with the given window ID, return Just result or NothingKGet the VPUIWindow with the given window ID; it is an error if this fails.IReplace a VPUIWindow with given window ID; it is an error if this fails.]Apply an update function to a VPUIWindow with given window ID; it is an error if this fails.^Apply an update IO action to a VPUIWindow with given window ID; it is an error if this fails.ORemove a window from the windows map; it has already been destroyed in the GUI#Try to find canvas; fail gracefully Find canvas or fail dramatically5Update the canvas of the specified window, without IO2Update the canvas of the specified window, with IO3A helper for making toolOps from actions on VCanvasUWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~UWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~W~z{|}stuvwnopqrxybcdefghijklm[\^`]]_]aWXYZWXYZ[\^`]]_]ab cdefghijklmnopqrstuvwxyz{|}~ NoneCommands for the CBMgrHThe CBMgr (Callback manager) encapsulates (in an enclosure, no less!) an IORef VPUI. It is used *solely* to set up callbacks and similar stuff in Gtk, where the callback needs access to the IORef. By passing a CBMgr to a function, we can avoid passing the IORef directly, and all the harm and confusion that could result.We only need *one* CBMgr for the application; however, two CBMgrs with the same IORef are logically equivalent, so there would be no harm in having two as long as they share one IORef.Create the CBMgrRead an IORef, update with IO, and write the updated value. This is like (flip modifyIORef), but the type of the first argument is (a -> IO a) instead of (a -> a). Note that if a = VPUI, then updateIO :: VPUI -> IO VPUI and consequently modifyIORefIO updateIO :: CBMgrAction.  None Create an EditArgsPanel It currently returns a EditArgsPanel object, and you can put the root of it into a container, e.g., set window [containerChild := editArgsPanelRoot panel]@Frame | | +------------------------------+ | | | VBox | | | | +--------------------------+ | | | | | Table (n+2 rows)x(3 cols)| | | | | | +----------------------+ | | | | | | | | | | | | | | | (arguments) | | | | | | | +----------------------+ | | | | | | | | | | | | HButtonBox | | | | | | +----------------------+ | | | | | | | (buttons) | | | | | | | +----------------------+ | | | | | | | | | | | | Label | | | | | | +----------------------+ | | | | | | | (status messages) | | | | | | | +----------------------+ | | | | | +--------------------------+ | | | +------------------------------+ | +----------------------------------+c@Fill the table with rows for each argument in the model and more}Resize a widget to be at least as big as a(nother) widget. Normally the widget being resized is one that contains the other.dBRemove from table and destroy all arg rows (does not alter model)eeAttach a widget to a table in a single cell, specified by its row column (top lef = 0 0) coordinatesfHClose (destroy) the panel. I hope this also removes it from its parent.gCreate a new ArgRowhGAdd a new argument, nth in the model, from the (n+1)th row in the tablei>Remove an argument, nth in the model, (n+1)th row in the tablej0Remove the nth element of a list (0 is the head)!klmnopqrstuvcdwexfghyijz{|}~klmnopqrstuvcdwexfghyijz{|}~NoneTry to find the original of a datafile that is part of the sifflet library. These are usually files like sifflet.scm or sifflet.py that provide Sifflet support for the target language when exporting. First try the directory where Cabal would have installed data files. This may fail if Sifflet has been installed (or portably installed) on Windows into a non-standard location; in that case, also try the directory from which sifflet.exe was launched.Try to copy a library file (such as sifflet.py or Sifflet.java) to the same directory where an export file is being written, if it doesn't already exist there. Show a warning message if the library file cannot be found.Get the contents of a library file (such as sifflet.scm) so you can insert it into the file being exported. If the file cannot be found, display an error message and return the empty string.NoneOptions for Python export. Should probably include choices like Python2 or Python3; if statement or if expression. Right now, just a placeholder.XConvert Sifflet name (of a function) to Python operator (Left) or function name (Right)Remove characters that are not valid in a Python identifier, and in some cases, insert other characters to show what's missingPCreate a Python def statement from a Sifflet function. Minimally parenthesized.    NoneA source of variable namesA type environment maps type variable names to type schemes. Oh, is it really type variable names, or just names? It seems to me that in envToTypeEnv, it's function names, instead of type variable names.A TypeScheme (TypeScheme schematicVariables typeExpression) is a sort of type template, in which schematic variables (i.e., type parameters or "generics") are made explicit; any other type variables in the type expression are unknownsGThe type of a substitution function, which maps type variables to types>Determine the type of a value. May result in a type variable.ECheck whether the values agree with the types (which may be abstract)]This is *probably* too lenient in the case of type variables: it can pass a mixed-type list.Try to match a single type and value, may result in binding a type variable in a new environment or just the old environment (Note that this tries to produce a map of type variable names to Types, instead of TypeSchemes as with TypeEnv below)HApply a substitution function to a type (possibly a type with variables)Composing two substitutionsIdentity substitution@A delta substitution is one that affects just a single variable.CTry to extend a substitution by adding a single variable-value pairlApply a substitution to a type scheme, taking care to affect only the unknowns, not the schematic variablesThe range of a type environment4Insert a new type variable and its type scheme value"The unknowns of a type environmentCreates a name supply)Produces next variable from a name supply2Produces next several variables from a name supplyType check an expressionType check a variable (actually the variable name). Find the type scheme associated with the variable in the type environment. Return a "new instance" of the type scheme, in which its schematic variables are replaced by new variables, and the unknowns are left as they are.FConvert an association list of type variable names into a substitutionDecide the type of a function -- called by the function editor when the Apply button is clicked. decideTypes tries to find the argument types and return type of an expression considered as the body of a function, at the same time checking for consistency of inputs and outputs between the parts of the expression. It returns Succ (argtypes, returntype) if successful; Fail errormessage otherwise.Convert a function type, such as a -> (b -> c), to a pair consisting of the list of argument types and the result type, such as ([a, b], c).FType check an IF expression *** Failure messages need improvement ***Type check a list expression. NOTE: This is to check a single Expr with the EList type, in which all elements must be of the same type, not a general list of Exprs of possibly mixed type. See tcExprs.(** Failure messages need improvement ***7IDEA: can this be reduced to [] and application of (:)?kCreate a TypeEnv from an Env Bindings on the left replace bindings of the same name on the right, if any.jThe base type environment, derived from the base environment of the Sifflet language (built-in functions)/""-None2List of the nodes children, ordered by edge number                    NoneSafe VParse a Sifflet data literal (number, string, char, bool, or list), returning an Expr7Parse a Sifflet literal expression and return its Value.Try to parse an input value of a specific type+Try to parse input values of specific typesCTry to parse an input value for a named variable of a specific type?Try to parse input values for named variables of specific typesiLike expr, but consumes the entire input, so there must not be any extraneous characters after the Expr.'nothingBut p is like pk, but consumes the entire input, so there must be no extraneous characters (except space) after whatever p parses.RParse a Sifflet data expression -- actually only a literal or a list of literals.;Parser for a Value of any primitive or (concrete) list typeNParser for a value with a specific primitive or concrete list type expected.6A name for the type, for use in parser error reporting input stringsexpected typesinputsvariable namesvariable types !"#$%  !"#$%  !"#$% !"#$% None)Ask the vcanvas to update the frame and install a new graph. Frames are identified by their frame nodes, so the new frame must have the same frame node as the old. It is an unreported error if there is not exactly one match.<Like vcUpdateFrameAndGraph, but keep the canvas's old graph.Render a node. Returns a list of inlets and a list of "outs": a list of (child, edge) pairs (adjs) going to *simple* children only (not to frames formed by expanding a node). This can then be used if we wish to render the children of the node, as when rendering a tree.*Make nothing be selectedThe Graph Node of a Selection+)What is selected (if anything) at a point,Connect nodes. If parent and child are different, connect the i-th inlet of node parent to the o-th outlet of node child UNLESS doing so would create a cycle parent -> child -> ... -> parent AND UNLESS something is already connected to the ith inlet of the parent node.-|Disconnect nodes. Disconnect wouldn't need to be in the IO monad, except that it needs the same type signature as connect.1Remove the (sub)tree rooted at the given node. Removes it from the graph of the canvas and from the FunctoidParts of the frame.22Add a frame representing a functoid to the canvas.xUse mvalues = Nothing if you do not want the frame to be evaluated as a function call, otherwise mvalues = Just values.XprevEnv is *supposed* to be the previous environment, i.e., that of the "parent" frame or the canvas, not of the new frame, because vcAddFrame itself will extend the environment with the new (vars, values). But this is odd, because openNode calls vcAddFrame apparently with the *new* environment as prevEnv, and yet it works correctly.dCaution: I think it is necessary for the canvas to have been realized before calling this function!3TReturn a canvas of at least the specified size and otherwise like the given canvas.7(Draw the canvas in its window, on screen8iRender the canvas in Cairo (use with renderWith to provide an alternate surface, such as an SVG file).:9Find the node, if any, at a given position on the canvas.=editFunction: reverse of defineFunction: replace the call frame by an edit frame; does not change the VPUI (global env.), just the canvas..>Find a frame's subframes, i.e., those that were expanded to trace the execution of a function call. Cannot be in an edit frame.sGiven a graph with a rooted tree, collect list of "subframes," i.e., frames that are children of nodes in the treeBEvaluate the frame, having gotten a list of values from the dialog@SvcClearFrame - clear a frame in a canvas; not yet implemented What does this mean?A%Close a frame and any subframes of it:Close any subframes of the frame, but not the frame itself!Is our canvas editing a function?C3Find the frames that are calling the named function,&'()*+,-./0123456789:;<=>?@ABC&'()*+,-./0123456789:;<=>?@ABC3B,9-7=6'+82*@A?./01>(45)&:;<C,&'()*+,-./0123456789:;<=>?@ABC!NoneJ function nameLargument name, no. of inputsT.Check that all required modifiers are in foundZoAdd a frame representing a functoid to the canvas of a particular window, specified by its window id (title).[Add a frame representing a functoid to the canvas of a VPUIWindow (which ought to have a canvas, of course). Otherwise like vcAddFrame.]Open an entry for user input of function name to select a function tool. Returns unaltered VPUI, for convenience in menus and key callbacks.^pShow an entry for input of a literal value. Returns unaltered VPUI, for convenience in menus and key callbacks.7When activated, send a message to set the current tool Set actions for Tab and Escape_*For debugging (frame context menu command)`*For debugging (frame context menu command)a*For debugging the window's widget childrenb'Clear frame indicated by mouse locationc"Close frame (context menu command),DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc DEFGHIJKLTMY\UXSVWR]^NO[ZQP_`abc$DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc"NonedCreate a new VPUI. This used to set up the basic "q to quit" and "on exposed" callbacks, but now does not even do that. The Y function argument may perform additional initialization; if there is none, simply use .eCreate a new "main" workspace window, with a given style. The second argument should set up a menu bar and place it on the vbox, or do nothing if no menu is wanted.)Update an Edit Function window after the Inputs dialog, which might have given it some new ArgSpec's. In the resulting VPUIWindow, no node inlets or inputs than its new arity.{Given a WGraph and a list of valid symbols, a node is valid if it is an ExprNode ... labeled with one of the valid symbols?(This function is only used above, in updateEditWindowArgSpecs)|Require a node to have <= n inlets in the node and <= n successors in the graph, where n is specified in a list of ArgSpec,Like wLimitOut, but applies to a whole graph*Redraw the entire canvas of a given window|fedFuncFrame generates a throw-away frame for the sole purplse of obtaining its measurements before initializing the canvas]If mViewSize is Nothing, no scrollbars are put on the canvas, and its display size request is its natural size. If mViewSize = Just viewSize, then scrollbars are wrapped around the canvas, and its displayed size request is viewSize. addMenuBar is an action which, if desired, adds a menu bar; if you don't want one, just pass ( _ -> return ()).$List of all window ids of the vpui, i|Perform action on all windows (actually (WinId, VPUIWindow) pairs. Returns updated VPUI (in case any windows are changed).jThis function is called either when a window *has been* destroyed, with destroy = False, or when you *want to* destroy a window, with destroy = True.qremoveWindow actually *closes* the window if destroy = True, as well as removing it from the vpui's windows map.kGContext menu command to apply the function definition of an EditFrame.Execute the definition currently represented in the frame, i.e., bind the function name in the global environment to the function definition found in the frame.rIn the workspace window, update each frame calling the named function to reflect the current function definition In the canvas, update a call frame with the current function definition from the environment, returning a new canvas. Root call frames are torn down and rebuilt with the new function definition. Call frames that are called by other call frames are simply torn down.defghijklmn defghijklmn defgklmjhindefghijklmn#NoneqJuse explicit lambda in function definitions, (define f (lambda (a b) ...)rAn SExpr is "flattish" if it is an atom or is a list containing only atoms, where the empty list () is an atom.Newline and indent*Convert Sifflet Functions to Scheme SExprs*Convert Sifflet Functions to pretty SchemeConvert a FunctionDefTuple to a Scheme SExpr. Use the form (define (name . args) body) except when there are zero arguments, which becomes a Scheme constant rather than a function, use (define name expr)."Export functions to a Scheme file.#opqrstuvwxyz{|}~opqrstuvwxyz{|}~{|}stuvwxyzropq~opqrstuvwxyz{|}~$None An XMLConsumer consumes XMLAn XMLProducer produces XMLvConvert a literal expression to a value. It is an error if the expr is not a literal. Compare exprToValue in Expr.hstestFromXml :: (ToXml a, Show a) => a -> XMLConsumer XmlTree a -> IO () VVV This type generalization (a, a to a, b) is for debugging, undo it later: FunctionsTypes5Values Still used in exprToXml in the EList case :-(ExprSymbols%None5 set a toolstart a dialogmodify VPUI with IO help or quit8Finding, creating, and initializing windows (VPUIWindow)0Find and show a window, if it exists. If not, create the window, put it in the vpui's window map, and initialize it and any auxiliary objects using the initWin function. The 3rd argument of initWin will be the window's title. Always presents the window (shows and raises). Returns a 3-tuple: the VPUIWindow contains the Window, and the Bool value is True if the Window is new (and therefore might need some further initialization). The third tuple element is an IORef to the VPUIWindow; it may be useful for setting up signal and event handling.BLike showWindow, except that making the window visible is optional+Default "do-nothing" add-callbacks functionEShow a workspace window, with a given title, _not_ editing a functionEShow a workspace window with a given title and maybe function to editjInitialize a Workspace window. Called in sifflet.hs:Main from showWindow called from showWorkspaceWindow.Show a function editor window = a workspace window editing a given function. Use argNames for a new function; ignore them if funcName is bound.1Show the function pad window; create it if needed2Create the function pad window if it doesn't existAAdd a tool button to the function pad window in a specified panelOAsk user for new function name and arguments, then begin editing the function.Quit from Sifflet+Open a file (load its function definitions)Offer to save changes, if any, and continue with the continuation. The continuation gets the current vpui if there are no changes or if the offer to save is rejected; otherwise, it gets a vpui which knows it has saved its last changes. If offerCancel is true, there is an option to cancel the operation; this won't work if the user is closing the main (workspace) window. The message, if any, is a confirmation that the file was saved and that we are going on to the next operation -- useful for open file, but not for quit.CContinue with opening the file, after having possibly saved changesNow that we have a file path, go ahead and open it, loading the function definitions into Sifflet and adding buttons to the function pad "My Functions" area.Implements File menu Save command.'Implements File menu "Save as" command.Unconditionally save user functions in SiffML file. Called from menuFileSave and menuFileSaveAs. Updates vpuiCurrentFile and vpuiFileEnv.-The user-defined functions of the environment^Export user functions to a file, given an exporter and a path, returning the vpui unchanged.%Export user functions to Haskell file$Export user functions to Python file$Export user functions to Scheme fileBChoose an output file, for file save, save as, and export commands#Save an image of a window in a filevReturns (WinId, fileExtension), e.g., ("Sifflet Workspace", ".svg"), where fileExtension is ".svg", ".ps", or ".pdf"Save the window image in the file format specified, adding the right file extension to the file path if it is not already present.Text shown by the help dialogShow the help dialogHow to report bugsText for the About dialogDContext menu command to edit the function displayed in a CallFrameCreate a new function, add it to the global environment with body undefined, and start editing it in a new window. Also update and show "My Functions" toolbox and update its toolkit.Handle the Configured event.KHandle the Exposed event, should be called only for a window with a canvas8Key bindings map. This is derived from keyBindingsList.:KeyBinding list for workspace and function editor windows.'Unused argument needed for key bindings!Help text built from key bindings What to do when a key is pressedQHandle the ButtonPress event. Should be called only for a window with a canvas.!Handles button pressed in a frameHandles button pressed in the body of a frame frameBodyButtonPressed needs VPUIWindow because it calls a toolOp. mb (mouse button) is unused, but might be used later.4Handles left button pressed in the footer of a frameHandles beginning of mouse-dragHandle mouse move event/Show a context menu for mouse click in a frame. 7Options for context menu that depend on the frame type.[    initialize Gtk Windowinitialize callbacksmake window visible !"#$%&'()*+,  Q     !"#$%&'()*+, 'None  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  -./0123456789:;<=>?@ABC89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn-()*()+(),()-./0.12.13.14.15.16.17.18.19.1:;<=;<>;<?;<@;<A;BC;BD;BE;BF;BG;BH;BI;BJ;BK;BL;BM;BN;BO;BP;BQ;BR;BS;TU;VW;XY;XZ;[\;]^;]_;]`;]a;]b;]c;]d;]e;fg;fh;fi;fj;fk;lm;no;np;nq;nr;ns;nt;nu;nv;nw;nx;ny;nz;n{;n|;n};n~;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ;  ;  ; ; ;;;;;;;;;;;;;;;;; ;!";!#;!$;!%;!&;!';!(;!);!*;!+;!,;!-;!.;!/;!0;!1;!2;34;35;36;37;38;39;3:;3;;3<;3=;3>;3?;@A;@B;@C;@D;@E;@F;@G;@H;@I;@J;@K;@L;@M;@N;@O;@P;@Q;@R;@S;@T;@U;@V;@WXYZXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M M N O P P Q Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h h i j k l m n o p q r s t u v w x y z { | } ~ ~                                                                                       !"#$%&'()*+,-./0123456789:;<=>?@AABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!"""""""""""###########################$$$$$$%%%%%%%%%%%%%&&&&&&&&&&&&&                                                         ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYqZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~              !!!!!!!!!!!!""""""""""""########$$$$$$$$$$$$$$$$$$$$%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%NOsiffl_ANLRbF0020UC8XSROsOK9hData.Sifflet.TreeGraphics.UI.Sifflet.LittleGtkLanguage.Sifflet.ParserText.Sifflet.PrettyGraphics.UI.Sifflet.GtkForeignLanguage.Sifflet.UtilGraphics.UI.Sifflet.RPanelGraphics.UI.Sifflet.GtkUtilData.Sifflet.GeometryData.Number.SiffletText.Sifflet.ReprData.Sifflet.TreeLayoutLanguage.Sifflet.Expr Language.Sifflet.Export.ExporterLanguage.Sifflet.ExamplesLanguage.Sifflet.Export.Haskell!Language.Sifflet.Export.ToHaskellLanguage.Sifflet.Export.PythonLanguage.Sifflet.ExprTreeData.Sifflet.FunctoidGraphics.Rendering.Sifflet.DrawData.Sifflet.WGraphGraphics.UI.Sifflet.FrameGraphics.UI.Sifflet.TypesGraphics.UI.Sifflet.Callback!Graphics.UI.Sifflet.EditArgsPanelSystem.Sifflet.Paths Language.Sifflet.Export.ToPythonLanguage.Sifflet.TypeCheckData.Sifflet.TreeGraph(Graphics.Rendering.Sifflet.DrawTreeGraphGraphics.UI.Sifflet.CanvasGraphics.UI.Sifflet.ToolGraphics.UI.Sifflet.Workspace Language.Sifflet.Export.ToSchemeLanguage.Sifflet.SiffMLGraphics.UI.Sifflet.Window Paths_siffletGraphics.UI.Siffletconta_2C3ZI8RgPO2LBMidXKTvIU Data.Tree subForest rootLabelNodeTreeglib_1k0TiRm3S3u0RjZ08MH1odSystem.Glib.SignalsonSystem.Glib.Attributesgetset::~::=:~>:=>:~:=AttrOpgtk_IthCkrmZyC49kGQu4HvvO2Graphics.UI.Gtk.General.General grabRemovegrabAddmainQuitmainGUIinitGUIGraphics.UI.Gtk.Abstract.Widget onSizeRequest onDestroy keyPressEvent exposeEventbuttonPressEvent widgetVisiblewidgetSetCanFocuswidgetSetSizeRequestwidgetSetDoubleBufferedwidgetClassPathwidgetAddEvents widgetSetNamewidgetGrabFocuswidgetSizeRequest widgetDestroy widgetShowAll widgetShowGraphics.UI.Gtk.Buttons.ButtonbuttonNewWithLabel%Graphics.UI.Gtk.MenuComboToolbar.Menu menuPopupGraphics.UI.Gtk.Display.Label labelSetTextlabelNew+Graphics.UI.Gtk.Selectors.FileChooserDialogfileChooserDialogNewGraphics.UI.Gtk.Windows.WindowwindowDeletable windowTitle windowMove windowPresentwindowSetPositionwindowSetDefaultSizewindowSetTitle windowNewGraphics.UI.Gtk.Entry.EntryentryGetCompletionentrySetCompletion entryGetText entrySetTextentryNewGraphics.UI.Gtk.Gdk.DrawWindowdrawWindowInvalidateRectGraphics.UI.Gtk.Gdk.CursorCursorIsPixmap BlankCursor LastCursorXtermWatchUrAngleUmbrellaUlAngleTrekTopTeeTopSideTopRightCorner TopLeftCorner TopLeftArrowTcrossTargetStarSpraycanSpiderSizingShuttleSbVDoubleArrow SbUpArrow SbRightArrow SbLeftArrowSbHDoubleArrow SbDownArrowSailboatRtlLogo RightbuttonRightTee RightSideRightPtr QuestionArrowPlusPiratePencilMouse MiddlebuttonManLrAngleLlAngle LeftbuttonLeftTeeLeftSideLeftPtr IronCrossIconHeartHand2Hand1GumbyGobblerFleurExchange DrapedBox DraftSmall DraftLarge DoubleArrowDotboxDot DiamondCross Crosshair CrossReverseCross CoffeeMugClockCircle CenterPtr BoxSpiral BottomTee BottomSideBottomRightCornerBottomLeftCornerBogosityBoat BasedArrowUpBasedArrowDownArrowXCursor CursorTypeGraphics.UI.Gtk.CairorenderWithDrawableGraphics.UI.Gtk.Windows.DialogdialogSetDefaultResponsedialogAddButton dialogRun dialogNew%Graphics.UI.Gtk.Windows.MessageDialogmessageDialogNew MessageOther MessageErrorMessageQuestionMessageWarning MessageInfo MessageTypeButtonsOkCancel ButtonsYesNo ButtonsCancel ButtonsClose ButtonsOk ButtonsNone ButtonsType!Graphics.UI.Gtk.Display.Statusbar statusbarPop statusbarPushstatusbarGetContextId statusbarNew%Graphics.UI.Gtk.Entry.EntryCompletionentryCompletionModelentryCompletionInsertPrefixentryCompletionSetTextColumnentryCompletionNew#Graphics.UI.Gtk.ModelView.ListStore listStoreNew#Graphics.UI.Gtk.ModelView.TreeModelmakeColumnIdString%Graphics.UI.Gtk.ModelView.CustomStorecustomStoreSetColumn%Graphics.UI.Gtk.Selectors.FileChooserfileChooserSetCurrentFolderfileChooserGetFilenameFileChooserActionCreateFolderFileChooserActionSelectFolderFileChooserActionSaveFileChooserActionOpenFileChooserActionGraphics.UI.Gtk.Layout.HBoxhBoxNewGraphics.UI.Gtk.Layout.LayoutlayoutGetDrawWindow layoutSetSize layoutPut layoutNewGraphics.UI.Gtk.Layout.ExpanderexpanderSetExpanded expanderNewGraphics.UI.Gtk.Layout.TabletableAttachDefaultstableNewGraphics.UI.Gtk.Layout.VBoxvBoxNewGraphics.UI.Gtk.Ornaments.Frame frameSetLabelframeNew(Graphics.UI.Gtk.Scrolling.ScrolledWindowscrolledWindowSetPolicyscrolledWindowNewGraphics.UI.Gtk.Misc.Adjustment adjustmentNewGraphics.UI.Gtk.Misc.EventBox eventBoxNewGraphics.UI.Gtk.Abstract.BoxboxPackStartDefaults boxPackEnd boxPackStart"Graphics.UI.Gtk.Abstract.ContainercontainerChildcontainerGetChildrencontainerForeach containerAddGraphics.UI.Gtk.General.StructsdialogGetActionAreadialogGetUpper Requisition ResponseUser ResponseHelp ResponseApply ResponseNo ResponseYes ResponseCloseResponseCancel ResponseOkResponseDeleteEventResponseAcceptResponseReject ResponseNone ResponseIdGraphics.UI.Gtk.TypestoDialogcastToContainer DrawWindow WidgetClassLabelContainerClassButtonWindowDialogScrolledWindowExpanderVBoxHBox StatusbarLayoutTableEntryGraphics.UI.Gtk.General.Enums PackNaturalPackGrow PackRepelPackingPolicyAutomatic PolicyTypeWinPosCenterOnParentWinPosCenterAlways WinPosMouse WinPosCenter WinPosNoneWindowPositionGraphics.UI.Gtk.Gdk.Enums AllEventsMask ScrollMaskSubstructureMaskProximityOutMaskProximityInMaskVisibilityNotifyMaskPropertyChangeMask StructureMaskFocusChangeMaskLeaveNotifyMaskEnterNotifyMaskKeyReleaseMask KeyPressMaskButtonReleaseMaskButtonPressMaskButton3MotionMaskButton2MotionMaskButton1MotionMaskButtonMotionMaskPointerMotionHintMaskPointerMotionMask ExposureMask EventMaskpango_KgG1Z92ZTgJEQtWynhlo9f Graphics.Rendering.Pango.Structs Rectangleparse_AtBt9uDOS2NCyWnucTHV3yText.Parsec.Prim parseTestPrettypretty prettyList indentLinesepLines sepLines2sepComma sepCommaSpsepSpace setCursor GtkLayoutGtkFrameSuccFailSuccFailparsefparseInt parseDouble parseVerbatimpar putCatsLnputCatLninfofakestuberrcaterrcatsmap2mapM2insertLastLast insertLast adjustAList adjustAListMRPanelrpanelId rpanelRoot rpanelContent newRPanelrpanelAddWidgetsrpanelAddWidget rpanelNewRow rpanelAddRows EntryDialogReadersuppressScimBridgeshowChoicesDialogdefaultDialogPosition runDialogS runDialogMshowInputErrorMessageshowErrorMessageshowInfoMessage showMessagecreateEntryDialogrunEntryDialogaddEntryWithLabel Translate translateWidenwidenBBoxSizesizeWsizeH circleCenter circleRadiusPositionposXposY positionDeltapositionDistancepositionDistanceSquaredpositionCloseEnough pointInCirclebbXbbYbbWidthbbHeight bbPositionbbSizebbCenter bbSetWidthbbLeft bbXCenterbbRightbbTop bbYCenterbbBottombbToRect bbFromRectbbMerge bbMergeList pointInBBNumberExactInexactisExact toInexactadd1sub1eqZerogtZeroltZeroNameReprreprreprlreprsreprListtreeleafisLeaftreeSize treeDepthnameTreeputTreeputTreeR putTreeRsputTreeS drawTreeShow LayoutNode nodeGNode nodeTreeBB TreeLayoutIolet IoletCounterGNode gnodeValuegnodeTextBoxes gnodeNodeBB gnodeInlets gnodeOutletsTextBoxtbTexttbTextBBtbBoxBBFontTextExtents fontAscent fontDescent fontHeightfontMaxXadvancefontMaxYadvance textXbearing textYbearing extTextWidth extTextHeight textXadvance textYadvanceStyle styleFont lineWidth textMarginhpadvpad exomarginvtinypad styleFramePadstyleNormalTextColorstyleNormalFillColorstyleNormalEdgeColorstyleActiveTextColorstyleActiveFillColorstyleActiveEdgeColorstyleSelectedTextColorstyleSelectedFillColorstyleSelectedEdgeColorstyleTetherColorstyleAuxOffset styleAuxColor styleAuxFontstyleIoletRadiusstyleShowNodeBoxesstyleShowNodePortsVFont vfontFace vfontSlant vfontWeight vfontSizeVColorColorRGB ColorRGBAblackwhitecream lightBluelightBlueGreen lightGray mediumGraydarkGrayyellow darkBlueGreen blueGreenstyleIncreasePaddingstyle0style1style2style3 defaultStylewstylepointInLayoutNode pointInGNodefindRectsetFont measureTextstyleTextExtents ftExtents makeTextBoxtbWidth tbSetWidthtbHeighttbBottomtbCenter tbBoxCenter tbTextCenteroffsetTextBoxCenters gnodeText gnodeTextBBzeroIoletCounter makeGNode makeIolets makeIoletsRow ioletCenter pointInIolet treeSizeslayoutNodeSource layoutRootBB layoutTreeBB treeLayout treeGNodestreeLayoutPaddedSizetreeLayoutSizelayoutTreeMoveCenterTotreeLayoutWidthtreeLayoutWidenEnvFunctionDefTuple FunctionImpl PrimitiveCompoundArgSpecargName argInletsFunction FunctionsTypeTypeVarTypeCons TypeConsName TypeVarNameEvalResEvalOk EvalError EvalUntried EvalResultValueVBoolVCharVNumberVStringVFunVListOperatorGrouping GroupLtoR GroupRtoL GroupNone PrecedenceOperatoropNameopPrecopAssoc opGroupingExpr EUndefinedESymbolEBoolECharENumberEStringEIfEListELambdaEAppECallEOpEGroupOCharOBoolOStrSymbol toLambdaExpr callToAppmapply appToCallmcall exprIsLiteral exprIsAtomicexprIsCompoundeSymboleSymeInteStringeChareFloateBooleFalseeTrueeIfeListeCall valueFunction exprToValuevalueToLiteralvalueToLiteral'typeBooltypeChartypeNum typeStringtypeList typeFunction aspecsLookupfunctionArgSpecsnewUndefinedFunction functionName functionNArgsfunctionArgTypesfunctionResultTypefunctionArgResultTypes functionTypefunctionImplementationfunctionArgNames functionToDeffunctionFromDef functionBodyemptyEnvmakeEnv extendEnv envInsertLenvInsenvSetenvGetenvGetFunction envLookupenvLookupFunction envSymbolsenvFunctionSymbols envFunctionsenvPop stackSizeeval evalWithLimitapplyePluseTimeseMinuseDiveModeAdd1eSub1eEqeNeeGteGeeLteLeeZerop ePositivep eNegativepbaseEnv exprSymbols exprVarNamesExporter simplifyExpr findFixedcommonRuleHigherPreccommonRuleAtomiccommonRuleLeftToRightruleRightToLeftcommonRuleAssocRight ruleIfRightcommonRuleFuncOpcommonRulesForSimplifyingExprsapplyFirstMatchfooeFooeMaxeFactexampleFunctionsexampleFunctionNames exampleEnvgetExampleFunctionDecl declIdentdeclType declParamsdeclExpr ImportDecl ExportSpecModule moduleName moduleExports moduleImports moduleDeclsHsPrettyhsPretty hsPrettyList operatorTableHaskellOptionsoptionsSoftMaxLineWidthoptionsHardMaxLineWidthdefaultHaskellOptions exportHaskellfunctionsToHsModulefunctionToHsDecl exprToHsExpr PStatementPReturnPImportPCondSPFunPModulePyPrettypyPretty pyPrettyList alterParensretcondSvaridentcharfun ExprNodeLabel NUndefinedNSymbolNBoolNCharNNumberNStringNListExprNodeENodeExprTreeexprNodeIoletCounter exprToTree treeToExprexprToReprTreeevalTree unevalTreeFunctoidLayout FLayoutTree FLayoutForestFunctoid FunctoidPartsfpNamefpArgsfpNodes FunctoidFuncfpFunc functoidNamefunctoidArgNamesfunctoidHeaderflayout flayoutBBox flayoutSize flayoutWidth flayoutBottom flayoutWidenDrawMode DrawNormal DrawActiveDrawSelectedNodeDrawSelectedInletDrawSelectedOutletDrawdrawsetColor drawTextBoxdrawBox modeFillCol modeTextCol modeEdgeColWNodeWSimpleWFrameWEdgeWContextWGraph wgraphNew isWSimpleisWFrame printWGraphnextNode grInsertNode grRemoveNode grConnectgrInletIsConnected grDisconnectconnectToFrame grAddGraphgrExtractExprTreewlabllab nodeExprNodenodeText nodeValuenodeBBox nodePositionnodeInputValues graphOrphans adoptChildrennodeAllChildrennodeSimpleChildrenallDescendantsnodeAllSimpleDescendantsnodeProperSimpleDescendantsnodeFrameChildren nodeIsSimple nodeIsOpennodeContainerFrameNode nodeParentgrUpdateFLayoutgrUpdateTreeLayoutgrExtractLayoutNodegrExtractLayoutTree translateTreetranslateNodes translateNode grRelabelNode functoidPartsfunctionToPartsnfilter FrameType EditFrame CallFrame CanvFramecfHeadercfFooter cfVarNamescfParent cfFrameNodecfEnvcfBoxcfLevel cfFunctoid frameType levelOrdercfRoot cfEvalReadycfPointInHeadercfPointInFooter frameBodyBox frameNodeAtatLeastSizeFrame resizeFrametranslateFrame frameOffsetnodeCompoundFunctiongrTranslateFrameNodes pointIoletargIoletCounterframeNewWithLayoutDragging draggingNodedraggingPosition Selection SelectionNodeselNodeSelectionInlet selInEdgeSelectionOutlet selOutEdgeVCanvasvcLayoutvcStylevcGraphvcFramesvcSize vcMousePosvcToolvcActive vcSelected vcDragging ToolContext TCWorkspace TCCallFrame TCEditFrame TCExprNodeTooltoolName toolActivatedtoolOp CanvasToolOpToolOpToolbox toolboxFrame toolboxVBox VPToolkit toolkitName toolkitWidth toolkitRows Workspace wsRootWidgetwsCanvas wsButtonBar wsStatusbarwsArgToolSpecsWinId VPUIWindow VPUIWorkWinFunctionPadWindowVPUI vpuiWindows vpuiToolkitsvpuiInitialDirvpuiCurrentDirvpuiCurrentFile vpuiStylevpuiInitialEnv vpuiGlobalEnv vpuiFileEnv vpuiDebuggingvpuiFileChangedvpuiUserEnvAListvpuiInsertWindowvpuiTryGetWindow vpuiGetWindowvpuiReplaceWindowvpuiUpdateWindowvpuiUpdateWindowIOvpuiRemoveVPUIWindowvpuiWindowWindowvpuiWindowLookupCanvasvpuiWindowGetCanvasvpuiWindowSetCanvasvpuiWindowModCanvasvpuiWindowModCanvasIO vpuiModCanvasvpuiModCanvasIO toToolOpVWMenuItemAction MenuItemSpecMenuItemSubMenuMenuSpecCBMgrCmdOnWindowConfigureOnWindowDestroyAfterWindowKeyPressOnLayoutExposeOnLayoutMouseMoveOnLayoutButtonPressOnLayoutButtonReleaseOnMenuItemActivateLeafOnEntryActivateAfterButtonClicked WithUIRefUMTest CBMgrActionCBMgrmkCBMgr createMenuBaraddMenu createMenucreateMenuItem modifyIORefIO EditArgsPaneleditArgsPanelRoot ArgSpecActionmakeEditArgsPanel expandToFit findDataFile copyLibFile readLibFile PythonOptionsdefaultPythonOptions exprToPExpr nameToPythonfixIdentifierCharsfunctionToPyDefdefToPyfunctionsToPyModulefunctionsToPrettyPy exportPython NameSupplyTypeEnv TypeSchemeSubst valueTypetypeCheckValues typeVarsInsubst substCompidSubst deltaSubstextendunify schematicsTS unknownsTSsubstTS emptyTypeEnvinstall unknownsTEsubstTE newNameSupplynameSupplyNextnameSupplyTaketcExprtcExprstcVar newInstancearrow decideTypesfromLambdaType envToTypeEnv baseTypeEnv LayoutGraphflayoutToGraphtreeLayoutToGraphflayoutToGraphRootsorderedTreeToGraphtreeGraphNodesTree nextNodesgraphToOrderedTreegraphToOrderedTreeFromorderedChildrenadjCompareEdgegraphToTreeOriginalgraphToTreeStructuregrTranslateNodegrTranslateSubtreegrTranslateGraphfunctoidToFunctiongraphToExprTreegraphWriteImageFile graphRender treeRendertreeWriteImageFile gtkShowTree parseExpr parseValue parseLiteral parseSuccFailparseTypedInput2parseTypedInputs2parseTypedInput3parseTypedInputs3 nothingButexprlistvalue typedValueboolqcharqstringintegerdoublenumber vcanvasNewnodeContainerFrame vcGetFramevcUpdateFrameAndGraphvcClearSelectionpointSelectionconnect disconnectvcFrameAddFunctoidNodevcFrameAddNodevcFrameDeleteNodevcFrameDeleteTree vcAddFrame atLeastSizevcInvalidateFrameWithParentvcInvalidateBox frameChanged drawCanvas renderCanvasdefaultFileSaveClipBox vcanvasNodeAtvcanvasNodeRect whichFrame editFunctionvcFrameSubframes vcEvalDialog vcClearFrame vcCloseFrame cfContext callFramesToolId ToolConnectToolDisconnectToolIfToolMove ToolDelete ToolFunction ToolLiteralToolArgfunctionArgToolSpecs vpuiSetToolvpuiWindowSetToolwsPushStatusbarwsPopStatusbar makeMoveToolmakeDeleteTool checkModsmakeConnectToolmakeDisconnectTool makeIfTool makeCopyTool functionTool vpuiAddFrame vwAddFramefunctionToolsFromListsshowFunctionEntryshowLiteralEntry dumpFrame dumpGraph dumpWorkWin clearFrame closeFramevpuiNewworkspaceNewDefaultworkspaceNewEditingaddFedWinButtonsvpuiQuitforallWindowsIO removeWindowdefineFunction workspaceIdopenNodebaseFunctionsRows SchemeOptionsdefineWithLambdaIndentAtomSFloatSIntSSymbolSStringSCharSBool SFunctionSExprSAtomSListdefaultSchemeOptions exprToSExprfunctionNameToSchemeName valueToSExprexprToSchemeReprexprToSchemePretty exprToSchemeinlfunctionsToSExprsfunctionsToPrettyScheme defToSExpr exportSchemeToXmltoXmlproduceSiffMLFileconsumeSiffMLFilexmlToFunctions testFromXml showWindowgetOrCreateWindownewWindowTitled showWorkWinshowWorkspaceWindow showFedWinfedWindowTitleshowFunctionPadWindowgetOrCreateFunctionPadWindownewFunctionDialog openFilePathsetWSCanvasCallbackskeyBindingsHelpTextcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName gdkCursorNewgdkWindowSetCursorcursorTypeNumber$fMonadSuccFail$fApplicativeSuccFail$fFunctorSuccFailrpIdrpRoot rpContentrpFrame rpExpanderrpVBox rpCurrentRowrpCurrentRowFreeWidth rpMaxWidthrpHPad rpanelAddRow debugTracing createDialogrunDialogHelper addEntries$fTranslateCircle$fTranslatePosition$fTranslateBBox$fTranslateTree $fTranslate[] $fWidenBBoxexactOp1exactOp2$fFloatingNumber$fFractionalNumber$fIntegralNumber $fEnumNumber $fRealNumber $fNumNumber $fOrdNumber $fShowNumbertoDouble inexactOp1 eitherOp1 inexactOp2 eitherOp2$fRealFracNumber $fReprName $fReprDouble $fReprFloat $fReprNumber $fReprInteger $fReprInt $fReprChar $fReprBool centerGNodefindNode paddedWidth paddedHeight treeLayout2treeLayoutAddMargin$fWidenLayoutNode$fTranslateLayoutNode$fReprLayoutNode$fShowLayoutNode$fTranslateIolet$fTranslateGNode $fReprGNode $fShowGNode$fTranslateTextBox$fWidenTextBoxEnvFrameeNegateexprIsExtendedliteralToValue primIntDivMod primFloatDivprimN2NprimN1N $fEqFunctionBinding typeToArityprimTypeundefinedTypesunboundprimitiveFunctionsprim primIntDiv primIntModprimArgCountErrorprimNullprimHeadprimTailprimConsprimN2BprimN1B$fReprFunction$fReadFunctionImpl$fShowFunctionImpl $fShowType$fMonadEvalRes$fApplicativeEvalRes$fFunctorEvalRes $fReprValue$fPrettyOperator $fReprExpr $fReprSymbol$fPrettySymboltopDown grossProfitbonus1bonus2maxfact sumFromZerormuleRmuleEvenpeOddp eRabbitBabies eRabbitAdultsbuggySumFromZeroeFib1fib1 eSumFromZeroeGcdgcdevenpoddp rabbitTotal rabbitAdults rabbitBabies buggyLength listLengthlistSumsumbodybuggySum$fHsPrettyExpr$fHsPrettyDecl$fHsPrettyImportDecl$fHsPrettyExportSpec$fHsPrettyModule$fHsPrettyOperator$fHsPrettySymbol nameToHaskellpathToModuleName haskellRulesparam$fPyPrettyExprpyPrettyParens$fPyPrettyPStatement$fPyPrettyPModule$fPyPrettyOperator$fPyPrettySymbolevalTreeWithLimit$fReprExprNode$fTranslateFunctoidLayout drawIolet drawInlets drawOutlets drawIolets drawCircle $fDrawCircle $fDrawIolet$fDrawPosition $fDrawBBox $fDrawTextBox $fDrawGNode$fDrawLayoutNode $fDrawTree$fDraw[]$fDrawFunctoidLayout edgeEqual edgeNotEqual edgeNotTonfilter' $fReprWNode $fOrdWEdge alignHeader $fEqCanvFrameeditFrameNodeseditFrameNodeAtcallFrameNodeAt alignFooterbuildFooterText dressTable stripTabletableAttachCell closePanel argRowNewaddArg removeArg listRemoveArgRowUIModelStateStateRefeditArgsPanelAction PanelRoot attachRow fillButtonBox readArgRow makeEntry applyArgRows readArgRows setStatusOK setStatuspyRules typeMatchrng alistToSubsttcIftcList unifyListtcExprs1tcExprs2tcApptcLambda traceValuevftypeftypesproutgrUpdateNodeLabel updateCanvaskeyPressinputtypeNameSignMinusprog1 escapedCharunsignedIntegeroptSign applySign vcUpdateFramegraphRenderNode selectionNodegrTreeSubframeNodes evalFramevcCloseSubframes canvasEditingenableDoubleBuffering vcDeleteFramegraphRenderFunctoidPartsgraphRenderForestgraphRenderTreegraphStartRendervcInvalidateSimpleNodeentryActivated entryKeyPress toolIdToTooldefaultContextDescriptionconnmakeBoundLiteralToolmakeBoundArgTool dummyTool showToolEntryaddEntryCompletions dumpWidgetwidgetClassNamebaseGHC.ListinitGHC.BasereturnupdateEditWindowArgSpecs validNode wLimitOut wLimitOuts redrawCanvas fedFuncFrame workspaceNewvpuiAllWindowKeysvpuiUpdateCallFramescanvasUpdateCallFramevpuiWindowArgSpecsaddArgToolButtonflattishatom prettyLoop displayList1 displayList2 displayTail $fPrettySExpr $fReprSExpr XMLConsumer XMLProducer$fToXmlFunction $fToXmlType $fToXmlValue $fToXmlExpr $fToXmlSymboldefaultOptions symbolToXml exprToXml xmlToExpr valueToXml xmlToValue typeToXml xmlToType functionToXml xmlToFunctionfunctionsToXml$fToXmlFunctions KeyActionST KeyActionDGKeyActionModIO KeyActionHQ initCBDefaultworkspaceWindowInitaddFunctionPadToolButton menuFileQuit menuFileOpencheckForChangescontinueFileOpen menuFileSavemenuFileSaveAssaveFile userFunctionsmaybeExportUserFunctionsmenuFileExportHaskellmenuFileExportPythonmenuFileExportSchemechooseOutputFilemenuFileSaveImagechooseImageOptions saveImageFilehelpTextshowHelpDialogbugsText aboutTexteditFrameFunctioneditNewFunctionhandleConfigured handleExposedkeyBindingsMapkeyBindingsList vpuiKeyHelpkeyPressCallbackhandleButtonPressframeButtonPressedframeBodyButtonPressedleftButtonPressedInFrameFooterbeginFrameDraghandleMouseMoveofferContextMenucontextMenuOptions KeyAction KeyBinding kbGtkKeyName kbAltKeyNamekbRequiredModifiers kbDescriptionkbActiononWindowDestroy buildMainMenuupdateFunctionPadIOfunctionPadWinIdaddUserFunctionsmakeFunctionPadPanelmakeToolButtonRowsmakeNamedToolButtonmakeToolButtonsetWorkspaceTitleForFileshowDialogFileOpenloadFile bindFunctionmaybeDefaultOptionsmaybeRunSchemeOptionsDialogbugReportAddressshowBugsshowAboutDialogconfiguredCallbackexposedCallbackbuttonPressCallbackmouseMoveCallbackbuttonReleaseCallback continueDragcontinueDragSimplecontinueDragFramehandleButtonRelease