func misc(mType string, id int, o *overlay.Overlay, deleteFunc func(int) error) func(dom.Element) {
return func(c dom.Element) {
download := xdom.A()
download.Href = "http://" + js.Global.Get("location").Get("host").String() + "/download/" + mType + "/" + strconv.Itoa(id) + ".zip"
download.Target = "_blank"
del := xdom.Button()
del.AddEventListener("click", false, func(dom.Event) {
del.Disabled = true
if dom.GetWindow().Confirm("Are you sure?") {
go func() {
err := deleteFunc(id)
if err != nil {
del.Disabled = false
xjs.Alert("Error while deleting %s: %s", mType, err)
} else {
o.Close()
}
}()
}
})
xjs.AppendChildren(c,
xjs.AppendChildren(xdom.Fieldset(),
xjs.SetInnerText(xdom.Legend(), "Download"),
xjs.SetInnerText(xdom.Div(), "Click the following link to download the "+mType+" as a zip file."),
xjs.SetInnerText(download, download.Href),
),
xjs.AppendChildren(xdom.Fieldset(),
xjs.SetInnerText(xdom.Legend(), "Delete"),
xjs.SetInnerText(xdom.Div(), "The following button will permanently delete the "+mType+" (this cannot be undone)."),
xjs.SetInnerText(del, "Delete "+mType),
),
)
}
}
func GeneratorsTab(c dom.Element) {
go func() {
xjs.RemoveChildren(c)
gs, err := RPC.Generators()
if err != nil {
xjs.Alert("Error getting generator list: %s", err)
return
}
ng := xdom.Button()
xjs.SetInnerText(ng, "New Generator")
ng.AddEventListener("click", false, func(dom.Event) {
d := xdom.Div()
o := overlay.New(d)
o.OnClose(func() {
GeneratorsTab(c)
})
d.AppendChild(transferFile("Map", "Upload/Download", 3, o))
xjs.Body().AppendChild(o)
})
table := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Generator")))
if len(gs) == 0 {
table.AppendChild(xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Td(), "No Generators")))
} else {
for _, g := range gs {
td := xdom.Td()
td.AddEventListener("click", false, func(g data.Generator) func(dom.Event) {
return func(dom.Event) {
d := xdom.Div()
o := overlay.New(d)
o.OnClose(func() {
GeneratorsTab(c)
})
d.AppendChild(tabs.New([]tabs.Tab{
{"Profile", generatorProfile(g.ID)},
{"Misc", misc("generator", g.ID, o, RPC.RemoveGenerator)},
}))
xjs.Body().AppendChild(o)
}
}(g))
table.AppendChild(xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(td, g.Name)))
}
}
xjs.AppendChildren(c,
xjs.SetInnerText(xdom.H2(), "Generators"),
ng,
table,
)
}()
}
func ServersTab() func(dom.Element) {
forceUpdate := make(chan struct{})
ns := xdom.Button()
ns.AddEventListener("click", false, func(dom.Event) {
d := xdom.Div()
o := overlay.New(d)
d.AppendChild(transferFile("Server", "Upload/Download", 0, o))
o.OnClose(func() {
go func() {
forceUpdate <- struct{}{}
}()
})
xjs.Body().AppendChild(o)
})
noneTd := xdom.Td()
noneTd.ColSpan = 3
none := xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(noneTd, "No Servers Found"))
serverList := xjs.AppendChildren(xdom.Table(),
xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(),
xjs.SetInnerText(xdom.Th(), "Server Name"),
xjs.SetInnerText(xdom.Th(), "Status"),
xjs.SetInnerText(xdom.Th(), "Controls"),
)),
none,
)
nodes := xjs.AppendChildren(xdom.Div(),
xjs.SetInnerText(xdom.H2(), "Servers"),
xjs.SetInnerText(ns, "New Server"),
serverList,
)
servers := make(map[int]*Server)
return func(c dom.Element) {
c.AppendChild(nodes)
updateStop := make(chan struct{})
registerUpdateStopper(c, updateStop)
for {
servs, err := RPC.ServerList()
if err != nil {
xjs.Alert("Error getting server list: %s", err)
return
}
if none.ParentNode() != nil {
serverList.RemoveChild(none)
}
for _, s := range servers {
s.ID = -1
}
for _, s := range servs {
os, ok := servers[s.ID]
if ok {
os.Server = s
} else {
name := xdom.Td()
status := xdom.Td()
startStop := xdom.Button()
os = &Server{
Server: s,
row: xjs.AppendChildren(xdom.Tr(),
name,
status,
xjs.AppendChildren(xdom.Td(), startStop),
),
name: name,
status: status,
button: startStop,
}
servers[s.ID] = os
serverList.AppendChild(os.row)
name.Class().SetString("serverName")
name.AddEventListener("click", false, func() func(dom.Event) {
s := os
return func(dom.Event) {
go func() {
d, err := RPC.ServerEULA(s.ID)
if err != nil {
d = ""
}
t := []tabs.Tab{
{"General", serverGeneral(s.Server)},
{"Properties", serverProperties(s.Server)},
{"Console", serverConsole(s.Server)},
}
if d != "" {
t = append(t, tabs.Tab{"EULA", serverEULA(s.Server, d)})
}
div := xdom.Div()
o := overlay.New(div)
t = append(t, tabs.Tab{"Misc.", misc("server", s.Server.ID, o, RPC.RemoveServer)})
div.AppendChild(tabs.New(t))
o.OnClose(func() {
go func() {
forceUpdate <- struct{}{}
}()
})
xjs.Body().AppendChild(o)
}()
}
}())
startStop.AddEventListener("click", false, func() func(dom.Event) {
b := startStop
s := os
return func(dom.Event) {
go func() {
b.Disabled = true
switch s.State {
case data.StateStopped:
err := RPC.StartServer(s.ID)
if err != nil {
xjs.Alert("Error starting server: %s", err)
return
}
case data.StateRunning:
err := RPC.StopServer(s.ID)
if err != nil {
xjs.Alert("Error stopping server: %s", err)
return
}
default:
return
}
go func() {
forceUpdate <- struct{}{}
}()
}()
}
}())
}
if os.Map >= 0 {
xjs.SetInnerText(os.status, os.State.String())
switch os.State {
case data.StateStopped:
xjs.SetInnerText(os.button, "Start")
os.button.Disabled = false
case data.StateRunning:
xjs.SetInnerText(os.button, "Stop")
os.button.Disabled = false
default:
xjs.SetInnerText(os.button, "N/A")
os.button.Disabled = true
}
} else {
xjs.SetInnerText(os.status, "No Map")
os.button.Disabled = true
xjs.SetInnerText(os.button, "N/A")
}
xjs.SetInnerText(os.name, os.Name)
}
for id, s := range servers {
if s.ID == -1 {
delete(servers, id)
serverList.RemoveChild(s.row)
}
}
if len(servers) == 0 {
serverList.AppendChild(none)
}
// Sleep until update
if !updateSleep(forceUpdate, updateStop) {
return
}
}
}
}
func transferFile(typeName, method string, typeID uint8, o *overlay.Overlay) dom.Node {
name := xform.InputText("name", "")
url := xform.InputRadio("url", "switch", true)
upload := xform.InputRadio("upload", "switch", false)
fileI := xform.InputUpload("")
urlI := xform.InputURL("", "")
s := xform.InputSubmit(method)
name.Required = true
typeFunc := func(dom.Event) {
if url.Checked {
urlI.Style().RemoveProperty("display")
fileI.Style().SetProperty("display", "none", "")
urlI.Required = true
fileI.Required = false
fileI.SetID("")
urlI.SetID("file")
} else {
fileI.Style().RemoveProperty("display")
urlI.Style().SetProperty("display", "none", "")
fileI.Required = true
urlI.Required = false
urlI.SetID("")
fileI.SetID("file")
}
}
typeFunc(nil)
url.AddEventListener("change", false, typeFunc)
upload.AddEventListener("change", false, typeFunc)
f := xjs.AppendChildren(xdom.Form(), xjs.AppendChildren(xdom.Fieldset(),
xjs.SetInnerText(xdom.Legend(), method+" "+typeName),
xform.Label(typeName+" Name", "name"),
name,
xdom.Br(),
xform.Label("URL", "url"),
url,
xdom.Br(),
xform.Label("Upload", "upload"),
upload,
xdom.Br(),
xform.Label("File", "file"),
fileI,
urlI,
xdom.Br(),
s,
))
s.AddEventListener("click", false, func(e dom.Event) {
if name.Value == "" {
return
}
if url.Checked {
if urlI.Value == "" {
return
}
} else if len(fileI.Files()) != 1 {
return
}
s.Disabled = true
name.Disabled = true
url.Disabled = true
upload.Disabled = true
fileI.Disabled = true
urlI.Disabled = true
e.PreventDefault()
go func() {
d := xdom.Div()
uo := overlay.New(d)
uo.OnClose(func() {
o.Close()
})
xjs.Body().AppendChild(uo)
status := xdom.Div()
d.AppendChild(xjs.SetInnerText(status, "Transferring..."))
conn, err := websocket.Dial("ws://" + js.Global.Get("location").Get("host").String() + "/transfer")
if err != nil {
xjs.SetInnerText(status, err.Error())
return
}
defer conn.Close()
w := byteio.StickyWriter{Writer: byteio.LittleEndianWriter{Writer: conn}}
r := byteio.StickyReader{Reader: byteio.LittleEndianReader{Reader: conn}}
pb := progress.New(color.RGBA{255, 0, 0, 0}, color.RGBA{0, 0, 255, 0}, 400, 50)
d.AppendChild(pb)
if url.Checked {
w.WriteUint8(typeID << 1)
data.WriteString(&w, urlI.Value)
length := int(r.ReadInt32())
total := 0
for total < length {
switch v := r.ReadUint8(); v {
case 1:
i := int(r.ReadInt32())
total += i
pb.Percent(100 * total / length)
default:
xjs.SetInnerText(status, ReadError(&r).Error())
return
}
}
} else {
f := files.NewFileReader(files.NewFile(fileI.Files()[0]))
l := f.Len()
if l == 0 {
xjs.SetInnerText(status, "Zero-length file")
return
}
w.WriteUint8(typeID<<1 | 1)
w.WriteInt32(int32(l))
io.Copy(&w, pb.Reader(f, l))
}
d.RemoveChild(pb)
xjs.SetInnerText(status, "Checking File")
data.WriteString(&w, name.Value)
var ctx *dom.CanvasRenderingContext2D
for {
switch v := r.ReadUint8(); v {
case 0:
if r.Err != nil {
xjs.SetInnerText(status, r.Err.Error())
} else {
xjs.SetInnerText(status, ReadError(&r).Error())
}
return
case 1:
files := make([]xform.Option, r.ReadInt16())
for i := range files {
files[i] = xform.Option{
Value: strconv.Itoa(i),
Label: data.ReadString(&r),
}
}
j := xform.SelectBox("files", files...)
sel := xjs.SetInnerText(xdom.Button(), "Select")
fo := overlay.New(xjs.AppendChildren(xdom.Div(), xjs.AppendChildren(xdom.Fieldset(),
xjs.SetInnerText(xdom.Legend(), "Please select the "+typeName+" file"),
xform.Label("File", "files"),
j,
xdom.Br(),
sel,
)))
c := make(chan int16, 0)
done := false
fo.OnClose(func() {
if !done {
done = true
c <- -1
}
})
sel.AddEventListener("click", false, func(dom.Event) {
if !done {
done = true
v, err := strconv.Atoi(j.Value)
if err != nil {
v = -1
}
c <- int16(v)
fo.Close()
}
})
xjs.Body().AppendChild(fo)
w.WriteInt16(<-c)
close(c)
case 2:
w := r.ReadInt32()
h := r.ReadInt32()
canvas := xdom.Canvas()
canvas.Width = int(w) * 8
canvas.Height = int(h) * 8
d.AppendChild(canvas)
ctx = canvas.GetContext2d()
ctx.Scale(8, 8)
case 3:
xjs.SetInnerText(status, data.ReadString(&r))
case 4:
x := r.ReadInt32()
y := r.ReadInt32()
red := r.ReadUint8()
green := r.ReadUint8()
blue := r.ReadUint8()
alpha := r.ReadUint8()
ctx.FillStyle = "rgba(" + strconv.Itoa(int(red)) + ", " + strconv.Itoa(int(green)) + ", " + strconv.Itoa(int(blue)) + ", " + strconv.FormatFloat(float64(alpha)/255, 'f', -1, 32) + ")"
ctx.FillRect(int(x), int(y), 1, 1)
case 255:
uo.Close()
return
}
}
}()
})
return f
}
func MapsTab() func(dom.Element) {
forceUpdate := make(chan struct{})
nm := xdom.Button()
nm.AddEventListener("click", false, func(dom.Event) {
d := xdom.Div()
o := overlay.New(d)
o.OnClose(func() {
go func() {
forceUpdate <- struct{}{}
}()
})
xjs.AppendChildren(d,
xjs.SetInnerText(xdom.H1(), "New Map"),
tabs.New([]tabs.Tab{
{"Create", createMap(o)},
{"Upload/Download", func(c dom.Element) {
c.AppendChild(transferFile("Map", "Upload/Download", 1, o))
}},
{"Generate", func(c dom.Element) {
c.AppendChild(transferFile("Map", "Generate", 2, o))
}},
}),
)
xjs.Body().AppendChild(o)
})
noneTd := xdom.Td()
noneTd.ColSpan = 2
none := xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(noneTd, "No Maps Found"))
mapList := xjs.AppendChildren(xdom.Table(),
xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(),
xjs.SetInnerText(xdom.Th(), "Map Name"),
xjs.SetInnerText(xdom.Th(), "Status"),
)),
none,
)
nodes := xjs.AppendChildren(xdom.Div(),
xjs.SetInnerText(xdom.H2(), "Maps"),
xjs.SetInnerText(nm, "New Map"),
mapList,
)
maps := make(map[int]*Map)
return func(c dom.Element) {
c.AppendChild(nodes)
updateStop := make(chan struct{})
registerUpdateStopper(c, updateStop)
for {
mps, err := RPC.MapList()
if err != nil {
xjs.Alert("Error getting map list: %s", err)
return
}
if none.ParentNode() != nil {
mapList.RemoveChild(none)
}
for _, m := range maps {
m.ID = -1
}
for _, m := range mps {
om, ok := maps[m.ID]
if ok {
om.Map = m
} else {
name := xdom.Td()
status := xdom.Td()
om = &Map{
Map: m,
row: xjs.AppendChildren(xdom.Tr(),
name,
status,
),
name: name,
status: status,
}
maps[m.ID] = om
mapList.AppendChild(om.row)
name.Class().SetString("mapName")
name.AddEventListener("click", false, func() func(dom.Event) {
m := om
return func(dom.Event) {
div := xdom.Div()
o := overlay.New(div)
div.AppendChild(tabs.New([]tabs.Tab{
{"General", mapGeneral(m.Map)},
{"Properties", mapProperties(m.Map)},
{"Misc.", misc("map", m.Map.ID, o, RPC.RemoveMap)},
}))
o.OnClose(func() {
go func() {
forceUpdate <- struct{}{}
}()
})
xjs.Body().AppendChild(o)
}
}())
}
switch om.Server {
case -2:
xjs.SetInnerText(om.status, "Busy")
om.status.Style().SetProperty("color", "#f00", "")
case -1:
xjs.SetInnerText(om.status, "Unassigned")
om.status.Style().SetProperty("color", "#00f", "")
default:
serv, err := RPC.Server(om.Server)
if err == nil {
xjs.SetInnerText(om.status, "Assigned")
} else {
xjs.SetInnerText(om.status, "Assigned - "+serv.Name)
}
om.status.Style().SetProperty("color", "#000", "")
}
xjs.SetInnerText(om.name, om.Name)
}
for id, m := range maps {
if m.ID == -1 {
delete(maps, id)
mapList.RemoveChild(m.row)
}
}
if len(maps) == 0 {
mapList.AppendChild(none)
}
// Sleep until update
if !updateSleep(forceUpdate, updateStop) {
return
}
}
}
}