ID:264845
 
This is a grid, obviously.
Code:
for(var/A in src.verbs)
Verbz++
winset(src,"Blah","current-cell=1x[Verbz]")
src << output(A,"Blah")


Problem description:

Instead of listing the verbs, I rather them be applicable like in a 'statpanel'. Clicking them, to execute the verb(command).
Create objects to display in that grid and have their Click() procs execute verbs.
In response to Warlord Fred
I rather not use an inefficient method that uses repetition. Statpanels manage to do so, and I've been able to manipulate everything that they do so far, so I deem it is possible.
Any other ideas other than creating separate objects?
What Warlord presented to you is just about the only other option. Your talk of repetition is stupid since you'd be doing the same kind of repetition changing all those verbs into objs and just putting the verbs' code under their corresponding obj's Click() proc.
//from...
/mob/admin/verb/whatever()

//to...
/obj/admin/whatever/Click()
Verbs VS Objects

Verb:
mob/player/verb/whoami()
src << "im a verb"

mob/proc/add()
verbs+= /mob/player/verb/whoami

for(var/x in src.verbs)
src << ouput(x)


Objects:
var/list/obj_verbs = new() // 1 line diffrent
obj/player/click()
src << "im a verb"

mob/proc/add()
obj_verbs += new /mob/player/whoami // 2 line diffrent

for(var/x in src.obj_verbs) //3 line diffrent
src << ouput(x)


Not really too much to complain about for a desired effect.
There are only 2 ways to have a grid cell react to clicking AFAIK:
1) Display an atom object in it and override Click()/MouseDown() to do the reaction.
2) Display a hyperlink in it and override Topic() to do the reaction.

Of course, if you use method #1, it doesn't mean you necessarily have to do any code repetition whatsoever or even define multiple object types. Among other things, you can change objects' vars at runtime...
In response to Kaioken
An example to support this course of action:
obj/verbEncapsulation
var/owner
var/verbName

New(owner, verbName)
src.owner = owner
src.verbName = verbName

Click()
call(owner, verbName)

You could even have it accept a reference to a verb itself rather than a verb name, and you could then parse the verb's name out of the verb reference in that New().

One drawback here though: it does not support the functionality that verbs have of prompting a client for input for the arguments.

Also, this would require an object per client per verb. You could get around that by not having an owner variable and instead doing 'call(usr, verbName)' or 'call(src, verbName)'

So there are some limitations, but I think this would work great in most situations. Especially if you don't rely on verbs to give input prompts for their arguments - it looks nicer anyway if you use input() inside the verb rather than letting it prompt for the args, as you have more control over the look of the input prompt, so I don't think the first drawback I mentioned is very relevant.