Lobby Protos Gtk := Object clone
Lobby appendProto(Lobby Protos Gtk)

Lobby Protos Gtk gtk := DynLib clone open("libgtk-x11-2.0.so.0") do(
  if (isOpen == Nil, Exception raise("gtk", "cannot load gtk") )

  WINDOW_TOPLEVEL := 0
  WINDOW_POPUP := 1
  GTK_ICON_SIZE_MENU := 1
  GTK_TYPE_STRING := 64
  GTK_SORT_ASCENDING := 0

  signal_connect := method(object,name,func,func_data, 
    signal_connect_full(object, name, getSlot("func"), 0, func_data, 0, 0, 0)
  )

  signal_connect_object := method(object,name,func,slot_object,
    signal_connect_full(object, name, getSlot("func"), 0, slot_object, 0, 1, 0)
  )

  main_quit := method(call("gtk_main_quit"))

  forward := method( 
    m := thisMessage clone
    if (m name beginsWithSeq("gtk_"),
      m setArguments(m arguments prepend(("\"" .. m name .. "\"") asMessage))
    ,
      m setArguments(m arguments prepend(("\"gtk_" .. m name .. "\"") asMessage))
    )
    m setName("call")
    self doMessage(m, sender)
  )
)

Lobby Protos Gtk do(

gtk_runner := Object clone do(

  idle_handler := block(yield ; 1)

  startup := method(
	pNum := list(Lobby args size)
	pArgs := list(Lobby args clone prepend("gtk.io"))
	gtk gtk_init(pNum, pArgs)
	Lobby args = pArgs at(0)
    Lobby args removeAt(0)
	Lobby args remove("")

    gtk idle_add(self getSlot("idle_handler"), 0)

    @@run
  )

  run := method(
    gtk main
  )
)

gtk_runner startup

Object callback := method(x, y,
  rc := Object clone 
  rc target := x 
  rc handler := y
  rc
)

Widget := Object clone do(
  type := "Widget"

  init := method(
    if (?gobject,
      gtk signal_connect(gobject, "delete_event", callback(self, "delete_event"), 0)
    )
  )

  show := method(
    gtk widget_show(gobject)
    self
  )
)

Container := Widget clone do(
  type := "Container"
  
  setBorderWidth := method(x,
    gtk container_set_border_width(gobject, x)
    self
  )

  add := method(x,
    gtk container_add(gobject, x gobject)
    self
  )
)

TextBuffer := Object clone do(
  type := "TextBuffer"
  
  getText := method(
    gtk text_buffer_get_start_iter(gobject, pstart)
    gtk text_buffer_get_end_iter(gobject, pend)
    gtk returnsString(gtk text_buffer_get_text(gobject, pstart, pend, 0))
  )

  setText := method(s,
    gtk text_buffer_set_text(gobject, if(s, s, ""), -1)
    self
  )

  pstart := Buffer clone preallocateToSize(100)
  pend := Buffer clone preallocateToSize(100)

  setBackground := method(begin, end, color,
    tag := gtk text_tag_table_lookup(gtk text_buffer_get_tag_table(gobject), "background")
    if (tag != 0,
      gtk text_tag_table_remove(gtk text_buffer_get_tag_table(gobject), tag)
    )
    gtk text_buffer_create_tag(gobject, "background", "background", color, 0)
    gtk text_buffer_get_iter_at_offset(gobject, pstart, begin)
    gtk text_buffer_get_iter_at_offset(gobject, pend, end)
    gtk text_buffer_apply_tag_by_name(gobject, "background", pstart, pend)
    self
  )

  insertPixBuf := method(offset, pixbuf,
    writeln("insertPixBuf offset: ", offset)
    gtk text_buffer_get_iter_at_offset(gobject, pstart, offset)
    gtk text_buffer_insert_pixbuf(gobject, pstart, pixbuf)
    self
  )
)

TextView := Container clone do(
  type := "TextView"

  init := method(
    self gobject := gtk text_view_new
    self buffer := TextBuffer clone
    buffer gobject := gtk text_view_get_buffer(gobject)
  )

  setEditable := method(e,
    gtk text_view_set_editable(gobject, if (e, e, 0))
    self
  )

  getText := method(buffer getText)

  setText := method(s,
    buffer setText(s)
    self
  )

  setBackground := method(begin, end, color,
    buffer setBackground(begin, end, color)
    self
  )

  insertPixBuf := method(offset, pixbuf, 
    buffer insertPixBuf(offset, pixbuf)
    self
  )
)

Box := Container clone do(
  type := "Box"

  packStart := method(child, expand, fill, padding,
    gtk box_pack_start(gobject, child gobject, if(expand, expand, 0), if(fill, fill, 0), padding)
    self
  )

  packEnd := method(child, expand, fill, padding,
    gtk box_pack_end(gobject, child gobject, if(expand, expand, 0), if(fill, fill, 0), padding)
    self
  )
)

VBox := Box clone do(
  type := "VBox"

  init := method(
    self gobject := gtk vbox_new(0, 10)
  )
)

HBox := Box clone do(
  type := "HBox"

  init := method(
    self gobject := gtk hbox_new(0, 10)
  )
)

Bin := Container clone do(
  type := "Bin"
)

Window := Bin clone do(
  type := "Window"

  destroy := block(gtk main_quit)

  init := method(
    self gobject := gtk window_new(gtk WINDOW_TOPLEVEL)
    resend
  )

  setTitle := method(t,
    gtk window_set_title(gobject, t)
    self
  )

  quitOnDestroy := method(
    gtk signal_connect(gobject, "destroy", callback(self, "destroy"), 0)
    self
  )
)

PopupWindow := Window clone do(
  type := "PopupWindow"

  init := method(
    self gobject := gtk window_new(gtk WINDOW_POPUP)
  )
)

ScrolledWindow := Bin clone do(
  type := "ScrolledWindow"

  init := method(
    self gobject := gtk scrolled_window_new(0, 0)
  )
)

Button := Bin clone do(
  type := "Button"

  init := method(
    self gobject := gtk button_new
    gtk signal_connect(gobject, "clicked", callback(self, "clicked"), 0)
  )

  setLabel := method(name, gtk button_set_label(gobject, name) ; self)
)

TreeView := Container clone do(
  type := "TreeView"

  init := method(
    self model := gtk tree_store_new(1, gtk GTK_TYPE_STRING)
    self gobject := gtk tree_view_new_with_model(model)
    renderer := gtk cell_renderer_text_new
    column := gtk tree_view_column_new_with_attributes("Column1", renderer, "text", 0, 0)
    gtk tree_view_append_column(gobject, column)
    gtk tree_view_set_headers_visible(gobject, 0)
  )

  add := method(str, parent,
    iter := Buffer clone preallocateToSize(100)
    iter setSize(100)
    for (i,0,99, iter atPut(i, 0))
    gtk tree_store_append(model, iter, if(parent, parent, 0))
    gtk tree_store_set(model, iter, 0, str, -1)
    iter
  )
)

BrowserView := TreeView clone do(
  type := "BrowserView"

  init := method(
    self model := gtk tree_store_new(3, gtk GTK_TYPE_STRING, gtk GTK_TYPE_STRING, gtk GTK_TYPE_STRING)
    self gobject := gtk tree_view_new_with_model(model)
    renderer := gtk cell_renderer_text_new
    column := gtk tree_view_column_new_with_attributes("Slot", renderer, "text", 0, 0)
    gtk tree_view_append_column(gobject, column)
    renderer := gtk cell_renderer_text_new
    column := gtk tree_view_column_new_with_attributes("Type", renderer, "text", 1, 0)
    gtk tree_view_append_column(gobject, column)
    renderer := gtk cell_renderer_text_new
    column := gtk tree_view_column_new_with_attributes("Value", renderer, "text", 2, 0)
    gtk tree_view_append_column(gobject, column)
    gtk tree_sortable_set_sort_column_id(model, 0, gtk GTK_SORT_ASCENDING)

    self iters := Map clone
    self objs := Map clone
  )

  fill := method(o, parent,
    if (iters hasKey(o uniqueId asString) == Nil,
      iters atPut(o uniqueId asString, parent)
      objs atPut(o uniqueId asString, o)

      o slotNames foreach(i, v,
        iter := self add(v, parent)
        if (v != "Nop" and o getSlot(v) != Nil,
          setType(iter, if (o getSlot(v) ?isSymbol, "Symbol", o getSlot(v) type))
          if (o getSlot(v) type != "Block" and o getSlot(v) type != "CFunction",
            setValue(iter, toString(o getSlot(v)))
            fill(o getSlot(v), iter)
          )
        )
      )
    )
    self
  )

  setType := method(iter, str,
    gtk tree_store_set(model, iter, 1, str, -1)
    self
  )

  toString := method(o,
    str := ""
    if (o type == "Sequence", str = "\"" .. o .. "\"")
    if (o type == "Number", str = o asString)
    if (o type == "List", 
      str = "list("
      o foreach(i, v,
        str = str .. toString(v)
        if (i != o size - 1, str = str .. ", ")
      )
      str = str .. ")"
    )
    str
  )

  setValue := method(iter, str,
    if (str == Nil, str = "Nil")
    gtk tree_store_set(model, iter, 2, str, -1)
    self
  )
) 

BrowseWindow := Window clone do(
  type := "BrowseWindow"

  init := method(
    self bview := BrowserView clone show
    self add(ScrolledWindow clone add(bview) show)
    resize
    gtk signal_connect(bview gobject, "row-activated", callback(self, "rowActivated"), 0)
  )

  fill := method(o, bview fill(o) ; resize ; self)

  resize := method(
    requisition := list(0, 0)
    gtk widget_size_request(bview gobject, requisition)
    gtk window_resize(gobject, requisition at(0) + 50, requisition at(1) * 2)
  )

  rowActivated := method(treeview, arg1, arg2, user_data,
    writeln("rowActivated")
    iter := Buffer clone preallocateToSize(100)
    iter setSize(100)
    for (i,0,99, iter atPut(i, 0))
    gtk tree_model_get_iter(bview model, iter, arg1)

    return
    bview iters foreach(k, v,
      if (v == Nil, continue)
      match := 1
      for (i,0,99, if (iter at(i) != v at(i), match = Nil ; break))
      if (match and bview objs at(k) != Lobby,
        BrowseWindow clone 
        //fill(bview objs at(k)) show
      )
    )
  )
)

) // end Gtk