Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

An array of buttons

From time to time I wish I had a control array of the sort native to Visual Basic.

A control array of buttons would be a table of buttons in which each button "knows" its location in the table. For example If I click on the button in the second row and third column, it would do something with the respective row and column of some array that holds data.

Ideally Mathematica would have something like a ButtonTable, a 2D version of ButtonBar.


As a work around, I've come up with this:

a = Array[0 &, {8, 4}]
DynamicModule[{pt = {0, 0}}, 
ClickPane[Dynamic[Graphics[{Black, Point[pt]},
GridLinesStyle -> LightGray,
GridLines -> {Range[1, 5], Range[-8, 0]},
PlotRange -> {{1, 5}, {0, -8}},
ImageSize -> 130]], (pt = #; 
a[[Sequence @@ Reverse@Abs[Floor@ pt]]] = Reverse@Abs[Floor@ pt]; 
Print[a]) &]]

It (clumsily) draws a table of 8 rows and 4 columns. This corresponds to an 8 by 4 matrix, a, which initially holds only zeros. When I click on a "cell" it, the ClickPane returns its integer coordinates and also updates the respective element in a with it's value. (Don't worry about the Point. I used it to check positions. Now that I think of it, MousePosition may be useful to capture the coordinates.)

In a real life application, it would do something useful with the value of the respective array element. Also, I would want there to be labels in each cell of the graphical representation. Unfortunately, with the above code I'd have to enter this labels manually. If the control array were a true control array, each button (or toggler) would have its own label. And there would be no need to manually lay out the buttons.

Any help would be appreciated.

share|improve this question

3 Answers 3

up vote 6 down vote accepted

For simplicity, I'm using function downvalues as a backend (and not an array)

(* Define functions *)
bTable[action_, fArray_, dims_]:= Grid@Array[Button[{#1, #2}, action[fArray, #1, #2]]&, dims]
action[fArray_, x_, y_] := (fArray[x, y] = fArray[x, y] + 1) (* or whatever *)

(* Initialize *)
dims = {3, 3};
Array[(f[#1, #2] = 0) &, dims];

(* Run *)
Row[{bTable[action, f, dims], Dynamic@ArrayPlot@Array[f@## &, dims]}]

Mathematica graphics

share|improve this answer
    
You could add another array containing the labels as a parameter for bTable[ ] –  belisarius Dec 2 '13 at 6:35
    
Very elegant! I can see how this could be useful in all kinds of circumstances, with other controls. –  David Carraher Dec 2 '13 at 11:57

SparseArray is another tool for constructing arrays with regular patterns,

SparseArray[{
   {i_, j_} :> Button[
     Row[{"(", i, ",", j, ")"}],
     actfunc[i, j]]
   }, {3, 4}] // Grid

You can define/redefine your button function later,

Clear[actfunc]
actfunc[i_, j_] := arry[[i, j]] = RandomReal[]

Then your data,

arry = ConstantArray[0, {3, 4}];
Dynamic[arry // ArrayPlot]

sample output

share|improve this answer

A similar approach where I simulated a grid of togglers: whichever button is pushed, its position is added to/removed from list. It is general enough to lay out ragged tables.

num = 27; (* number of buttons *)
edge = 6;    (* edge size of grid *)

list = {};
Dynamic@list
Grid[MapIndexed[
  Button[#2, list = If[MemberQ[list, #2], DeleteCases[list, #2], Append[list, #2]], 
    Appearance -> Dynamic@{"Palette", If[MemberQ[list, #2], "Pressed", "Normal"]}] &, 
  Partition[Range@num, edge, edge, {1, 1}, {}], {2}],
 Alignment -> {Center, Center}, Spacings -> {0, 0}]

Mathematica graphics

share|improve this answer
    
Works nicely with one dimensional arrays. –  David Carraher Dec 2 '13 at 12:12

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.