How to make a control array of buttons or togglers?

Question

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.

Answer 1

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]}]

Answer 2

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]

Answer 3

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}]