Well, it's a start at least. A few things you should know for now:
- This is a very rough implementation, and nowhere near complete
- There is absolutely no commenting in the code, this was written in ~1/2 an hour, so give me a break
- This is being released with the expectation that if this is being used, credit will be given to the original author
- That being said, modify away! Just remember the credit
- I'm planning on reworking this, for now, just deal with it if you want to use it.
With that, I'd like to document this for now. To start with, you can still use this the exact same way you could've before I added the action procedure code. However, if you want to experiment, I'll give some documentation on how to do so.
First, the old documentation on all of the old methods for creating the buttons:
| Turing: |
Buttons.Create (x, y : int, text : string) : int |
Give Create an (x, y) orderec pair, along with the text you want on it, it'll do the rest.
| Turing: |
Buttons.CreateFull (x, y, width, height : int, text : string) : int |
Allows you to customize your button's width and height, otherwise, everything else is the same.
| Turing: |
Buttons.Refresh (button_id : int) |
Redraws the button that you pass it.
| Turing: |
Buttons.EnableRollover (button_id : int, choice : boolean, clr : int) |
Enables/disables the rollover effect of your button based on whether choice is true or false. true sets rollover to on, false, off.
| Turing: |
Buttons.Pressed (button_id : int) : boolean |
Returns true if the button passed to Pressed has been pressed down on.
Now, you need to realize that in order to do this, I really had to redo the way you handle basic data types. Each of the four has it's own class, all of which subclass from Object. So, instead of having reals, strings, ints, and booleans, you now have a class representing each, Float, String, Integer, and Boolean respectively. Each class has it's own setter and getter methods (the setter a procedure, the getter a function), as well as a to_s function and a is_a function. The to_s function represents your data as a string (Ruby users will recognize that), and the is_a function, taking a string as an argument, will return a boolean if the object_type of your data is the same as the argument you pass to it.
As a side note, the getters and setters for each data type is in the form of get/set_<datatype>_value. Unfortunately, right now, you can't create your own objects to use for parameters because I had to handle things a really clunky way. I am working on a way to handle any and all types that are Objects.
With that, to create your button that points to an action procedure, you need to take advantage of Buttons.CreateFullAction() function. It looks like this:
| Turing: |
Buttons.CreateFullAction (x, y, width, height : int, text : string, action_proc : procedure action (args : array 1 .. * of ^Object)) : int |
So, your action procedure must take all of it's arguments as a single array of Objects, with which you can do what you wish. Now, to detect when the button has been pressed, and call your action procedure, you need to use the Buttons.ProcessForAction() procedure, where you pass the button's ID, as well as the array of arguments you wish to pass to it.
| Turing: |
Buttons.ProcessForAction (button_id : int, arguments : array 1 .. * of ^Object) |
Well, it's kind of hard to explain this all in type, so I've included an example program in the attached folder called Test.t. Check it out for more information on how it works. Updates to come.
. Anyway, this is pretty complicated, with all the pointer passing. My problem is how does turing know which set_variable_value it's dealing with, as it's declared in both object and variable type.
