path: root/client/macrowindow.cc

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/***************************************************************************
 *            macrowindow.cc
 *
 *  Fri Aug 31 12:27:45 CEST 2007
 *  Copyright 2007 Lars Bisballe Jensen and Bent Bisballe Nyeng
 *  elsenator@gmail.com and deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of Pracro.
 *
 *  Pracro 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.
 *
 *  Pracro 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 Pracro; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "macrowindow.h"

#include <QVBoxLayout>
#include <QDomDocument>
#include <QDomElement>
#include <QByteArray>
#include <QApplication>

#include "messagebox.h"
#include "widgets/widget.h"
#include "widgets/window.h"
#include "lua.h"

#include "debug.h"

extern QString cpr;
extern QString user;
extern QString host;
extern quint16 port;

MacroWindow::MacroWindow(NetCom &n, QDomNode &xml_doc, QString templ,
                         bool is_static, bool compact,
                         QScrollArea *scrollarea)
  : Collapser(NULL, compact?NULL:scrollarea), netcom(n)
{
  this->is_static = is_static;

  DEBUG(macrowindow, "Constructor %p\n", this);

  mainwidget = NULL;
  lua = new LUA(&mainwidget);

  waschanged = false;

  this->templ = templ;

  resumewidget = new ResumeWidget(compact);

  //  update(xml_doc);
  updateResume(xml_doc);
  initMacro(xml_doc);

  if(mainwidget) animateToWidget(mainwidget->qwidget(), true);
  else animateToWidget(resumewidget);

  active = true;

  connect(this, SIGNAL(doneAnimating(QWidget*)),
          this, SLOT(animated(QWidget*)));
}

MacroWindow::~MacroWindow()
{
  clear();
  delete resumewidget;
}

void MacroWindow::update(QDomNode &node)
{
  /*
  if(is_static || mainwidget == NULL) {
    clear();
    lua->clear();

    initMacro(node);

    if(mainwidget) setExpandedWidget(mainwidget->qwidget());
    else setExpandedWidget(NULL);
  }
  */
  updateResume(node);
}

void MacroWindow::updateResume(QDomNode &node)
{
  QDomElement elem = node.toElement();

  if(elem.tagName() == "resume") {
    QString resume = elem.text();
    ResumeWidget::state_t state = ResumeWidget::OLD;
    if(elem.hasAttribute("state")) {
      if(elem.attribute("state") == "old") state = ResumeWidget::OLD;
      if(elem.attribute("state") == "new") state = ResumeWidget::NEW;
      if(elem.attribute("state") == "dirty") state = ResumeWidget::DIRTY;
    }
    /*
    if(!mainwidget) { // Only call collapse if the macro is in resume state.
      collapse();
    }
    */
    resumewidget->setText(resume, state);
    updateHeight();

    return;
  }

  QDomNodeList children = node.childNodes();

  for (int i=0; i<children.count();i++) {
    QDomNode child = children.at(i);
    updateResume(child);
  }

}

void MacroWindow::initMacro(QDomNode &node)
{
  QDomElement elem = node.toElement();

  if(elem.tagName() == "macro") {

    // Assign the macro name and version to QStrings for use when comitting
    macro = elem.attribute("name", "");
    version = elem.attribute("version", "");

  } else if(elem.tagName() == "scripts") {
    // Nothing to do here
  } else if(elem.tagName() == "resume") {
    // Handled in updateResume
  } else if(elem.tagName() == "script") {

    lua->runScript(elem.text(), NULL, "preload");
  
  } else if(elem.tagName() == "widgets") {

    if(mainwidget) {
      WARN(macrowindow,
           "WARNING: mainwidget already exists! Calling clear().\n");
      clear();
    }

    DEBUG(mainwindow, "----------------------Before-----------------------\n");

    Window *window = new Window(elem, this);

    DEBUG(mainwindow, "----------------------After------------------------\n");

    connect(window, SIGNAL(wasChanged()), this, SLOT(macroChanged()));
    macrotitle = elem.attribute("caption");

    mainwidget = window;

    // Moved to expandWrapper (validation bugfix)
    //    mainwidget->setValues();
    if(is_static) mainwidget->setValues();

    if(waschanged == true) macroChanged();

    return; // No further recursion here.
  }

  QDomNodeList children = node.childNodes();

  for (int i=0; i<children.count();i++) {
    QDomNode child = children.at(i);
    initMacro(child);
  }
}

bool MacroWindow::doCommit()
{
  if(mainwidget->valid()) {
    QVector< Widget* > wlist;
    if(mainwidget) wlist = mainwidget->widgetList();
    QDomDocument doc = netcom.send(wlist, templ, macro, version);

    QDomNodeList nl = doc.documentElement().childNodes();
    QDomNode n = nl.at(0); // There can be only one! (Swush, flomp)
  
    if(n.toElement().tagName() == "error") {
      QMessageBox::critical(this, "Server Error", "Server Error: " +
                            n.toElement().text());
      return false;
    }

    qApp->processEvents();

    animateToWidget(resumewidget);
    emit updateOnCommit();

    return true;
  } else {
    MessageBox::critical(NULL, "Fejl",
                         "Makroen " + macrotitle +
                         " er ikke udfyldt korrekt, prøv igen.\n",
                         MessageBox::Ok);

    return false;
  }
}

void MacroWindow::commit()
{
  doCommit();
}

void MacroWindow::cancel()
{
  collapseWrapper();
}

void MacroWindow::expandWrapper()
{
  if(currentWidget() != resumewidget) return;

  waschanged = false;
  
  QDomDocument xml_doc = netcom.send(templ, macro);
  
  // Initiate the new macro window with the xml document and push
  //  it to the window list
  QDomNodeList templates = xml_doc.documentElement().childNodes();

  // There can be only one! (Swush, flomp)
  QDomNode templatenode = templates.at(0);
  QDomNodeList macronodes = templatenode.childNodes();
  for(int j = 0; j < macronodes.count(); j++) {
    QDomNode macronode = macronodes.at(j);
    
    if(true || macronode.childNodes().count()) {
      // macrowindows.push_back( new MacroWindow( netcom, macronode ) );
      QDomElement elem = macronode.toElement();
      
      if(elem.tagName() == "macro") {
        
        // Assign the macro name and version to QStrings for use when comitting
        QString macroname;
        if(elem.hasAttribute("name")) {
          if(elem.attribute("name") == macro) {
            // update me!
            initMacro(macronode);
          }
        }
      }
    }
  }

  // Set values here, to be sure that the widgets are visible to the value
  // system and thereby validate correctly.
  if(mainwidget) mainwidget->setValues();

  if(mainwidget) animateToWidget(mainwidget->qwidget(), true);

  // Set keyboard focus on the first focusable widget in the macro.
  QVector< Widget* > widgets;
  if(mainwidget) widgets = mainwidget->widgetList(true);
  QVector< Widget* >::iterator i = widgets.begin();
  while (i != widgets.end()) {
    if(*i) {
      Widget* w = *i;
      if(w->setKeyboardFocus()) break;
    }
    i++;
  }

}

void MacroWindow::collapseWrapper()
{
  if(currentWidget() == resumewidget) return;

  if(waschanged) {
    switch(MessageBox::warning(NULL,
                               "Gem ændringerne i makroen?",
                               "Du har valgt at lukke makroen " +
                               macrotitle + ".\n"
                               "Ønsker du at gemme inden du lukker?",
                               MessageBox::Save | MessageBox::Close |
                               MessageBox::Cancel)) {
    case MessageBox::Save:
      doCommit();
      break;
    case MessageBox::Close:
      animateToWidget(resumewidget);
      break;
    case MessageBox::Cancel:
    default:
      break;
    }
  } else {
    animateToWidget(resumewidget);
  }
}

void MacroWindow::toggleMacro()
{
  if(!active) return;
  if(currentWidget() == resumewidget) {
    expandWrapper();
  } else {
    collapseWrapper();
  }
}

void MacroWindow::macroChanged()
{
  DEBUG(macrowindow, "This macro was changed!\n");
  emit macroHasChanged();
  waschanged = true;
}

void MacroWindow::setActive(bool active)
{
  if(this->active == active) return;

  this->active = active;
  setEnabled(active);

  emit activationChanged(active);
}

void MacroWindow::clear()
{
  //  DEBUG(macrowindow, "clear %p\n", this);
  //setExpandedWidget(NULL);

  if(mainwidget) delete mainwidget;
  mainwidget = NULL;

  //  lua->clear();
}

void MacroWindow::animated(QWidget *w)
{
  if(w == resumewidget) {
    DEBUG(macrowindow, "collapsed %p\n", this);
    clear();
  }
}