QtApp.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "QtApp.h"

#include "CanvasWindow.h"
#if QT_VERSION < 0x040000
#include "FileOpenEvent.h"
#else
#include <QtGui/QFileOpenEvent>
#endif
#include "QtFileDialog.h"
#include "WindowController.h"

#include "qdir.h"

#include <cstdlib>
#include <cassert>

using std::string;

using namespace hippodraw;

QtApp * QtApp::s_instance = 0;

QtApp::QtApp ( int & argc, char** argv)
  : QApplication ( argc, argv )
{
  init ();
}

QtApp::QtApp ( int & argc, char** argv, bool gui )
  : QApplication ( argc, argv, gui )
{
  init ();

}

void
QtApp::
init ()
{

  /* Create temp directory. Now it is used for only PNG files generated
     from LaTex equation. It will be deleted when the application exit. 
  */
  QDir current_dir = QDir();
  char * tmp_dir(std::getenv("TMP"));
  if (tmp_dir) {
     m_tmpDirName = tmp_dir + std::string("/temp_latex");
  } else {
     m_tmpDirName = "temp_latex";
  }
  current_dir.mkdir(m_tmpDirName.c_str());

  CanvasWindow::resetFontSize ();

#if QT_VERSION < 0x040000
#else
  // Needed in order to use std::string as argument in signal/slot connection.
  qRegisterMetaType < std::string > ( "std::string" );
#endif

  // The Apple event handling implementaton for Qt 3  taken from 
  // http://doc.trolltech.com/qq/qq12-mac-events.html

#ifdef Q_OS_MACX
#if QT_VERSION < 0x040000
  AEInstallEventHandler ( kCoreEventClass,
                          kAEOpenDocuments,
                          appleEventHandler, 0, false );
#else
#endif
#endif

  s_instance = this;
}

QtApp::~QtApp ()
{
  /* It's not session safe here. Consider two copy of hippo are running. */
  QDir current_dir = QDir();
  std::string command("rm -f " + m_tmpDirName + "/*.*");
  system(command.c_str()); 
  current_dir.rmdir(m_tmpDirName.c_str());


  WindowController * controller = WindowController::instance ();
  controller -> closeAllWindows ( true );
  delete controller;

#ifdef Q_OS_MACX
#if QT_VERSION < 0x040000
  AERemoveEventHandler ( kCoreEventClass,
                         kAEOpenDocuments,
                         appleEventHandler, false );
#else
#endif
#endif

  s_instance = 0;
}

QtApp * QtApp::instance ()
{
  return s_instance;
}

#ifdef Q_OS_MAC

void
QtApp::
customEvent ( QCustomEvent * event )
{
//   int type = event -> type ();
#if QT_VERSION < 0x040000
//   if ( type == OpenEventType ) {
  FileOpenEvent * oe = dynamic_cast < FileOpenEvent * > ( event );
#else
  QFileOpenEvent * oe = dynamic_cast < QFileOpenEvent * > ( event );
#endif
//     assert ( oe != 0 );
  if ( oe != 0 ) {
    QString fn = oe -> file ();
    const string filename = fn.latin1();
    tryOpenFile ( filename );
  }
}

#if QT_VERSION < 0x040000
OSErr
QtApp::
appleEventHandler ( const AppleEvent * event,
                    AppleEvent *,
                    long )
{
  AEDescList docs;
  if ( AEGetParamDesc ( event,
                        keyDirectObject,
                        typeAEList, & docs) == noErr) {
    long cnt = 0;
    AECountItems ( &docs, &cnt );
    UInt8 strBuffer[256];
    for ( int i = 0; i < cnt; i++ ) {
      FSRef ref;
      if ( AEGetNthPtr( & docs, i+1,
                        typeFSRef, 0, 0,
                        & ref, sizeof(ref), 0 ) != noErr ) continue;
      if ( FSRefMakePath ( &ref, strBuffer, 256) == noErr ) {
       QString fn ( QString::fromUtf8 ( reinterpret_cast<char * >
                                        ( strBuffer ) ) );
       FileOpenEvent event ( fn );
       // bool yes = 
       QApplication::sendEvent ( s_instance, & event );
      }
    }
  }
  return noErr;
}
#endif
#endif

void QtApp::setFirstWindow ()
{
  bool hasWindow = false;
  
  WindowController * wc = WindowController::instance ();
#if QT_VERSION < 0x040000
  int count = argc ();
  char ** args = argv ();
#else
  QStringList args = QCoreApplication::arguments();
   int count = args.count();
#endif
  // No argument.
  if ( count == 1 ) {
    wc -> setFirstWindow();
    return;
  }

  wc -> createInspector();

  QString qarg;
  string arg;
  // Process each argument
  for ( int i = 1; i < count; i++ ) {
//     const string arg ( args[i] );
    qarg =  args[i];

    hasWindow |= tryOpenFile ( qarg.latin1() );
  }
  // No window created ( no .hpo argument ), create the first window.
  if ( !hasWindow ) wc->setFirstWindow();
}

bool
QtApp::
tryOpenFile ( const std::string & arg )
{
  string::size_type pos = arg.find_last_of ( '.' );
  if ( pos == string::npos ) return false;

  string suffix = arg.substr ( pos );

  if ( QtFileDialog::isDocSuffix ( suffix ) ) {
    CanvasWindow * window = new CanvasWindow ();
    try {
      window -> initFromFile ( arg );
    }
    catch ( ... ) {
    }
    return true;
  }

  if ( QtFileDialog::isTextSuffix ( suffix ) ) {
    QtFileDialog::openTextTuple ( arg );
    return false;
  }

  // Use a QtFileDialog object to call non-static methods.
  QtFileDialog * qd = new QtFileDialog ();

  if ( QtFileDialog::isFitsSuffix ( suffix ) ) {
    qd->openFitsTuple ( arg, 0 );
    delete qd;
    return false;
  }

  if ( QtFileDialog::isRootSuffix ( suffix ) ) {
    qd->openRootTuple ( arg, 0 );
    delete qd;
    return false;
  }

  delete qd;
  return false;
}

CanvasWindow *
QtApp::
currentCanvas ()
{
  return WindowController::instance() -> currentCanvas();
}