/*
    TUIpeer works in conjunction with an implementation of java.awt.Toolkit
    to provide a Text User Interface for programs using the Java AWT.

    Copyright (C) 1997-2000  Stuart D. Gathman <stuart@bmsi.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#pragma implementation
#include <stdio.h>
#include <keyboard.h>
#include "menucomp.h"
#include "wincomp.h"

CheckedMenuItem::CheckedMenuItem(const char *s) {
  checked = false;
  setLabel(s);
}

CheckedMenuItem::~CheckedMenuItem() { }

MenuItemComponent::MenuItemComponent() {
  parent = 0;
  enable();
}

MenuItemComponent::~MenuItemComponent() {
  if (parent)
    parent->delItem(this);
}

void MenuBarComponent::show(bool vis) {
  if (vis) {
    toolkit->setfocus(this);
    //menu->top();
    menu->popupAt(Point(0,0),this);
  }
  else {
    menu->setfocus(0);
    menu->hide();
  }
}

void MenuBarComponent::key(int k) {
  if (k == KEY_OPTIONS) {
    setfocus(0);
    return;
  }
  Component::key(k);
}

void MenuComponent::show(bool vis) {
  if (vis)
    menu->popupAt(origin,this);
  else {
    menu->setfocus(0);
    menu->hide();
    if (parent)
      parent->show(vis);
  }
}

void MenuComponent::doit(Karet *app) {
  menu->popupAt(origin,app);
}

void CheckedMenuItem::setLabel(const char *s) {
  label = ' ';
  if (s)
    label += s;
  if (isSep())
    disable();
  setChecked(checked);
}

bool CheckedMenuItem::isSep() const {
  return label.length() == 2 && label.c_str()[1] == '-';
}

void CheckedMenuItem::setChecked(bool b) {
  checked = b;
  label[0] = b ? 0xFB : ' ';
  MenuItem::operator=(label.c_str());
}

void CheckedMenuItem::draw(Window *w,const Rect &r) {
  if (isSep()) {
    w->fill(r,A_NORMAL + ACS_HLINE);
    return;
  }
  MenuItem::draw(w,r);
}

void MenuItemComponent::remoteMethod(int cmd) {
  switch (cmd) {
  case SETSTATE:
    setChecked(readShort() != 0);
    return;
  case Component::DISABLE:
    state(MenuItem::GRAY);
    return;
  case Component::ENABLE:
    enable();
    return;
  case SETLABEL:
    setLabel(readUTF().c_str());
    return;
  }
  Component::remoteMethod(cmd);
}

static CheckedMenuItem sepItem("-");

void MenuComponent::remoteMethod(int cmd) {
  Component *obj;
  switch (cmd) {
  case SHOWPOPUP: {
    obj = toolkit->componentAt(readShort());
    int x = descale(readShort(),toolkit->scalex);
    int y = descale(readShort(),toolkit->scaley);
    origin = obj->absLocation() + Point(y,x);
    show(true);
    return;
  }
  case ADDITEM: {
    obj = toolkit->componentAt(readShort());
    addItem(obj->asMenuItem());
    return;
  }
  case DELITEM:
    delItem(readShort());
    return;
  case ADDSEP:
    addItem(&sepItem);
    return;
  case NEWMENU:
    obj = new MenuComponent;
    toolkit->addComponent(obj,readShort());
    addItem(obj->asMenuItem());
    return;
  case NEWMENUITEM:
  case NEWCHECKMENUITEM:
    obj = new MenuItemComponent;
    toolkit->addComponent(obj,readShort());
    addItem(obj->asMenuItem());
    return;
  }
  MenuItemComponent::remoteMethod(cmd);
}

MenuComponent::MenuComponent(): MenuContainer(new PopupMenu), origin(9,9) { }

MenuComponent::~MenuComponent() {
}

MenuBarComponent::MenuBarComponent(): MenuContainer(new BarMenu) {
}

MenuBarComponent::~MenuBarComponent() { }

void MenuContainer::display() {
  if (menu->ishidden())
    menu->setphys(menu->dim());
  else
    menu->top();
}

void MenuContainer::setFrame(FrameComponent *f) {
  if (frame) {
    FrameComponent *oldf = frame;
    frame = 0;
    oldf->setMenu(0);
  }
  frame = f;
}

MenuContainer::MenuContainer(Menu *m) {
  menu = m;
  frame = 0;
}

MenuContainer::~MenuContainer() {
  setFrame(0);
  for (int i = menu->count(); i > 0;)
    delItem(--i);
  delete menu;
}

void MenuContainer::addItem(MenuItem *m) {
  if (m)
    (*menu) + m;
}

void MenuContainer::addItem(MenuItemComponent *m) {
  if (m) {
    MenuContainer *p = m->parent;
    if (p)
      p->delItem(m);
    (*menu) + m;
    m->parent = this;
  }
}

void MenuContainer::delItem(MenuItemComponent *m) {
  int i = indexOf(m);
  if (i >= 0)
    delItem(i);
}

int MenuContainer::indexOf(Component *c) {
  if (!c) return -1;
  int n = menu->count();
  MenuItem *m = c->asMenuItem();
  if (!m) return -1;
  for (int i = 0; i < n; ++i) {
    if ((*menu)[i] == m)
      return i;		// item already in menu
  }
  return -1;
}

void MenuContainer::delItem(int i) {
  MenuItem *m = menu->remove(i);
  int n = item.size();
  if (n > 0) {
    Component **c = &item[0];
    for (int i = 0; i < n; ++i) {
      MenuItemComponent *mc = c[i]->asMenuItem();
      if (m == mc) {
	mc->parent = 0;
	item.del(i);
	break;
      }
    }
  }
}

void MenuBarComponent::remoteMethod(int cmd) {
  switch (cmd) {
  case NEWMENU: {
    Component *obj = new MenuComponent;
    toolkit->addComponent(obj,readShort());
    addItem(obj->asMenuItem());
    return;
  }
  case ADDHELPMENU:
  case ADDMENU:
    addItem(toolkit->componentAt(readShort())->asMenuItem());
    return;
  case DELMENU:
    delItem(readShort());
    return;
  }
  Component::remoteMethod(cmd);
}

void MenuItemComponent::doit(Karet *) {
  if (state() == MenuItem::ENABLE) {
    if (parent)
      parent->show(false);
    toolkit->callMethod(compID,MENUPICK);
  }
}

void MenuComponent::draw(Window *w,const Rect &r) {
  origin = w->loc.origin() + r.origin() + Point(1,0);
  MenuItem::draw(w,r);
}