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.

  • $\begingroup$ For a clickable, interactive ArrayPlot, see this. $\endgroup$ Commented Jun 1, 2016 at 14:11

3 Answers 3


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

  • $\begingroup$ You could add another array containing the labels as a parameter for bTable[ ] $\endgroup$ Commented Dec 2, 2013 at 6:35
  • $\begingroup$ Very elegant! I can see how this could be useful in all kinds of circumstances, with other controls. $\endgroup$
    – DavidC
    Commented Dec 2, 2013 at 11:57

SparseArray is another tool for constructing arrays with regular patterns,

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

You can define/redefine your button function later,

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

Then your data,

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

sample output


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 = {};
  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

  • $\begingroup$ Works nicely with one dimensional arrays. $\endgroup$
    – DavidC
    Commented Dec 2, 2013 at 12:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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