# 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.

• For a clickable, interactive ArrayPlot, see this. – István Zachar Jun 1 '16 at 14:11

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]}] • You could add another array containing the labels as a parameter for bTable[ ] – Dr. 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. – DavidC 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[]


arry = ConstantArray[0, {3, 4}];
Dynamic[arry // ArrayPlot] 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}] • Works nicely with one dimensional arrays. – DavidC Dec 2 '13 at 12:12