#include "tab.h"
#include <unistd.h>
#include <qapplication.h>
#include <stdio.h>
#include <qstring.h>
#include <qregexp.h>
#include <unistd.h>
#include <qtimer.h>
#include <qsizepolicy.h>
#include <qdialog.h>
#include <qtabbar.h>
#include <qpainter.h>
#include <qstyle.h>
#include <qlayout.h>
#include <assert.h>

enum {GRAPH, SETTINGS, DEVICE, COMMAND};

void Tab::checkSplit(SplitNo splitNo) {
  assert(widgetno == splitNo);
  widgetno++;
}

//Tab::Tab(const char* instr, QWidget *parent, long range, const char *warning)
//    : QDialog(parent, "tab", false, Qt::WType_TopLevel | Qt::WStyle_Minimize)
Tab::Tab(const char* instr, QWidget *parent, long range, const char *warning)
    : QMainWindow(parent, "tab", Qt::WType_TopLevel | Qt::WStyle_Minimize)
{
  //QBoxLayout *vbox;
  QApplication::style().polish(this);
  
  actFocus = -1;
  
  //vbox = new QVBoxLayout(this, 0, 0, "vbx");
  split = new QSplitter(Qt::Horizontal, this);
  setCentralWidget(split);
  //vbox->addWidget(split);
  
  widgetno = 0;
  leftWidgetNo = graph_split;
  rightWidgetNo = right_split;
  
  graph = new Graph(instr, split, range);
  if (graph->set == NULL) {
    graph = NULL;
    return;
  }
  checkSplit(graph_split);
  
  graph->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, 1, 1));
  connect(graph, SIGNAL(gotoSettings()), this, SLOT(gotoSettings()));
  settings = new Settings(split);
  settings->set = graph->set;
  connect(settings, SIGNAL(leaveSettings()),
          this, SLOT(leaveSettings()));
  settings->hide();
  checkSplit(settings_split);
  
  rightSplit = new QSplitter(Qt::Vertical, split, "rightSplit");
  rightSplit->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, 1, 1));
  checkSplit(right_split);

  if (warning[0]) {
    foreignwarn = new QVBox(rightSplit);
    warnlabel = new QLabel(warning, foreignwarn);
    showparbutton = new QPushButton("show parameters", foreignwarn);
    QSize siz = foreignwarn->minimumSizeHint();
    foreignwarn->setFixedHeight(siz.height());
    warnlabel->setEraseColor(QColor(255,127,0));
  }
  
  device = new Device(rightSplit);
  if (warning[0]) {
    device->hide();
    connect(showparbutton, SIGNAL(clicked()), this, SLOT(showPars()));
  }
  
  command = new Command(rightSplit, "Command", graph->set->uc);
  connect(command->cmd, SIGNAL(returnPressed()), device, SLOT(update()));
  connect(command, SIGNAL(activate()), device, SLOT(activate()));
  device->init(command, graph->set);
  
  QTimer *timer = new QTimer(this, "repeat");
  connect(timer, SIGNAL(timeout()), this, SLOT(handler()));
  timer->start(100);
  setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
  
  exportXY = new Export(graph->set, split, instr);
  exportXY->hide();
  exportXY->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, 1, 1));
  connect(exportXY, SIGNAL(finish()), this, SLOT(finishExport()));
  connect(graph, SIGNAL(openExport()), this, SLOT(openExport()));
  connect(graph->set, SIGNAL(updateCurveList()), exportXY, SLOT(updateCurveList()));
  checkSplit(export_split);
  
  report = new Report(split, graph->set->ec);
  report->hide();
  checkSplit(report_split);
  connect(report, SIGNAL(leave()), this, SLOT(leaveReport()));
  connect(report, SIGNAL(openMe()), this, SLOT(openReport()));
  
  message = new QLabel(split);
  message->hide();
  
  for (int i = 0; i < 2 * 3; i++) {
    oldSizes[i] = 0;
  }
}

bool Tab::shown(QWidget *w) {
  return w->isShown() && w->width() > 3 && w->height() > 3;
}

void Tab::showPars() {
  QValueList<int> splitsizes;
  int h;
  
  showparbutton->hide();
  QSize siz = warnlabel->minimumSizeHint();
  foreignwarn->setFixedHeight(siz.height());
  device->show();
  splitsizes = rightSplit->sizes();
  h = (splitsizes[1] + splitsizes[2]) / 2;
  splitsizes[1] = h;
  splitsizes[2] = h;
  rightSplit->setSizes(splitsizes);
  device->update();
}

bool Tab::splitChange(SplitNo splitNo) {
  int lw = 0, rw = 0;
  int i;
  int tot;
  float s;
  
  sizes = split->sizes();
  lw = sizes[leftWidgetNo];
  rw = sizes[rightWidgetNo];
  i = leftWidgetNo + 2 * (rightWidgetNo - right_split);
  if (splitNo < right_split) {
    if (splitNo == leftWidgetNo) return FALSE;
    leftWidgetNo = splitNo;
  } else {
    if (splitNo == rightWidgetNo) return FALSE;
    rightWidgetNo = splitNo;
  }
  tot = lw + rw;
  if (rw > 1 && lw > 1) {
    oldSizes[i] = lw / float(tot);
  }
  s = oldSizes[leftWidgetNo + 2 * (rightWidgetNo - right_split)];
  if (s != 0) {
    lw = s * tot + 0.5;
    rw = tot - lw;
  }
  for (i = 0; i < n_split; i++) {
    sizes[i] = 0;
  }
  sizes[leftWidgetNo] = lw;
  sizes[rightWidgetNo] = rw;
  return TRUE;
}

void Tab::gotoSettings() {
  if (splitChange(settings_split)) {
    graph->showIt(false);
    settings->showIt(true);
    split->setSizes(sizes);
  }
}

void Tab::leaveSettings() {
  if (splitChange(graph_split)) {
    settings->showIt(false);
    graph->showIt(true);
  }
  split->setSizes(sizes);
}

void Tab::openExport() {
  if (splitChange(export_split)) {
    rightSplit->hide();
    exportXY->showMe();
    split->setSizes(sizes);
  }
}

void Tab::finishExport() {
  if (splitChange(right_split)) {
    exportXY->hide();
    rightSplit->show();
    split->setSizes(sizes);
  }
}

void Tab::openReport() {
  if (splitChange(report_split)) {
    rightSplit->hide();
    report->show();
    split->setSizes(sizes);
  }
}

void Tab::leaveReport() {
 if (splitChange(right_split)) {
    report->hide();
    rightSplit->show();
    split->setSizes(sizes);
  }
}

void Tab::sleep(const char *text) {
  graph->hide();
  rightSplit->hide();
  message->setText(text);
  message->show();
}

void Tab::wake() {
  graph->show();
  rightSplit->show();
  exportXY->hide();
  report->hide();
  message->hide();
  graph->set->sc->disconnect();
  graph->set->uc->disconnect();
  graph->set->gc->disconnect();
  graph->set->ec->disconnect();
  graph->set->sc->reconnect();
  /* uc is connected automatically with sc */
  graph->set->gc->reconnect();
  graph->set->ec->reconnect();
}

void Tab::initSize(int w, int h) {
  QSize qs = QSize(w, h).expandedTo(split->minimumSizeHint());
  resize(qs);
  sizes = split->sizes();
  sizes[0] = w/2;
  sizes[2] = w/2;
  split->setSizes(sizes);
}

void Tab::handler() {
  command->handler();
  if (shown(command) && command->cmd->hasFocus()) {
    actFocus = COMMAND;
  }
  if (shown(graph) && graph->lineEditRange->hasFocus()) {
    actFocus = GRAPH;
  }
  if (!shown(settings) && !shown(device)) {
    if (actFocus == COMMAND) {
      command->cmd->setFocus();
    } else {
      if (!graph->lineEditRange->hasFocus()) {
        graph->lineEditRange->setFocus();
        graph->lineEditRange->lineEdit()->selectAll();
      }
    }
  }
}

void Tab::resizeEvent(QResizeEvent *e) {
  //QDialog::resizeEvent(e);
  QMainWindow::resizeEvent(e);
}