sd_Alert
  var/response = 0

  New()
    var/response = 0
    player << browse() // create popup
    while(!response)
      sleep(2)
    player << browse(null) // delete popup
    del(src)

fo_Alert // your alert datum
    var
        result // to hold the result

    New(mob/M, message, title, option1, option2, option3)
        ..()
        // build your alert interface here...

    Del()
        // destroy your alert interface here...
        ..()

    proc
        GetResult(t as text) // your button uses this as the default command
            set hidden = 1   // followed by the value of the button
            result = t       // ie: default command: GetResult "OK"

proc
    fo_alert(mob/M = usr, message, title, option1 = "OK", option2, option3)
        if(!M || !M.client) return
        var/fo_Alert/A = new(M, message, title, option1, option2, option3)
        M.verbs += /fo_Alert/proc/GetResult
        while(!A.result) sleep(-1)
        . = A.result
        M.verbs -= /fo_Alert/proc/GetResult
        del(A)
        return . // this line may not be neccessary

mob
    verb
        test()
            fo_alert(,"This is a test of the fo_Alert system.", "Testing")

/***********************************************************
Interface Alerts - iAlert!

Example:
    var/iAlert/i = new(usr, "window")
    var/result = i.Response(arg1, arg2)
    
NOTE: You need to set the id of your "Okay" button to 
"confirm" if you want to get a return value from GetReturn().
If you want a "cancel" button, you need to set its id
to "cancel" or it won't respond.

iAlerts use two-steps to get the results from the alert:

The first step is used to create the alert datum, tell it
which interface window to use and assign it to a player.

The second step is used to get the player's response to
the provided window. Any arguments provided for the Response
proc will be passed on to the Display() and GetReturn() procs.

The Display() proc is used to setup the window, assigning
new values to interface elements and so forth. Arguments used
for the Response() proc can be used here to determine how
the interface elements should be set up.

The GetReturn() proc lets you decide how you want the
alert to understand the values intered in the alert window
to be returned. The value returned by the Response() proc
is the same as the value returned by this proc.
***********************************************************/

iAlert
    var
        target
        window
        response
        confirmed
        
    New(mob/target=usr, window)
        // Make sure that the target is an acceptable player
        // with a client before allowing the window to be created.
        if(!ismob(target))
            del(src)
        if(!target.client || !window)
            del(src)
            
        src.target = target
        src.window = window
        return
        
    Del()
        winshow(src.target, src.window, 0)
        sleep(100)
        ..()
    
    Topic(href, params[])
        if(params["confirm"])
            src.confirmed = 1
        src.response = 1
        spawn(2)
            del(src)
    
    // This function is called after the iAlert is created
    // in order to retreive a player's response from the window.
    proc/Response()
        src.Display(args)
        winset(src.target, "[src.window].cancel", "command='byond://?src=\ref[src]'")
        winset(src.target, "[src.window].confirm", "command='byond://?src=\ref[src];confirm=true'")
        winshow(src.target, src.window, 1)
        while(src.target && !src.response)
            sleep(2)
        if(src.confirmed)
            return src.GetReturn(args)
        return null

    // Use this to setup the window before it is displayed, 
    // such as filling in inputs or adjusting labels.
    proc/Display(arguments)
        return
        
    // This is how you tell the alert what kind of value you want it
    // to return. The value returned by the Response() is the same
    // as the value returned by this proc.
    proc/GetReturn(arguments)
        return