Building custom applications with C++

One can build custom applications with HippoDraw's C++ class library along with Qt.

Custom application with canvas

To build an application with the CanvasWindow and Inspector, it can be as simple as the one shown below...

#include "QtApp.h"

int main ( int argc, char** argv)
{
  QtApp app ( argc, argv );
  app.setFirstWindow();
  
  return app.exec();
}

Your custom code, say to generate the DataSource data should be inserted before the call to app.exec() as that function starts the Qt event loop and doesn't return until the application is terminated.

If you already have a Qt application, then you can add the HippoDraw CanvasWindow and Inspector to your application by adding code to your main with something like the implementation of QtApp::setFirstWindow does. The result might look like this ...

#include "qt/CanvasWindow.h"
#include "qapplication.h"


int main ( int argc, char** argv)
{
  MyApp app ( argc, argv );
  
  CanvasWindow * window = new CanvasWindow ();
  window->show();

  return app.exec();
}

One doesn't need to create the CanvasWindow before starting the Qt event loop. It can be created at any time.

Custom application with widget in window

This section describes how to put a HippoDraw plot in a single window.

First the QApplication object is created and the NTupleController is used to create an NTuple by reading a file as shown here.

int main ( int argc, char **argv )
{
    QApplication app ( argc, argv );

    const string filename ( "../../../hippodraw/examples/aptuple.tnt" );
    NTupleController * nt_controller = NTupleController::instance ();
    NTuple * nt 
      = nt_controller->createNTuple ( filename  );

In a custom application, you will probably have other ways of creating the NTuple. If you want the NTuple visible to the Inspector, then you must register it with the NTupleController like this ...

    NTuple * nt = // create your NTuple somehow 
    NTupleController * nt_controller = NTupleController::instance ();

    nt_controller->registerNTuple ( nt );

Next a display is created bound to the NTuple and one of its columns.

    const string histo ( "Histogram" );
    vector < string > bindings;
    bindings.push_back ( "Cost" );

    DisplayController * dc_controller = DisplayController::instance ();
    PlotterBase * plotter 
      = dc_controller->createDisplay ( histo, *nt, bindings );

Note that DisplayController creates the appropriate class derived from PlotterBase for the kind of display you requested.

Plotter objects are used both for canvas items and widgets. In this case, a QtViewWidget is created and the plotter is attached to it.

    QtViewWidget * view = new QtViewWidget ( );
    view->setPlotter ( plotter );

Finally, the view it set into the Qt main window, resized, captioned, and the event loop started.

    view->resize ( 200, 200 );
    app.setMainWidget( view );
    view->setCaption ( "Qt HippoDraw - View widget" );
    view->show();

    int result = a.exec();

Note that the above code used methods that QtViewWidget inherits from Qt's QWidget class.

Don't forget to clean up when you are done.

    delete view;
    delete nt;

    return result;
}

The resulting application window looks like this ...

QtViewWidget set as application's main window.

The complete code is shown below ...

#include "qt/QtViewWidget.h"

#include "controllers/DisplayController.h"
#include "datasrcs/NTupleController.h"
#include "datasrcs/NTuple.h"
#include "plotters/PlotterBase.h"

#include <qapplication.h>

#include <string>
#include <vector>

using std::string;
using std::vector;


int main ( int argc, char **argv )
{
    QApplication a( argc, argv );

    const string filename ( "../../../hippodraw/examples/aptuple.tnt" );
    NTupleController * nt_controller = NTupleController::instance ();
    DataSource * nt 
      = nt_controller->createNTuple ( filename  );

    const string histo ( "Histogram" );
    vector < string > bindings;
    bindings.push_back ( "Cost" );

    DisplayController * dc_controller = DisplayController::instance ();
    PlotterBase * plotter 
      = dc_controller->createDisplay ( histo, *nt, bindings );

    QtViewWidget * view = new QtViewWidget ( );
    view->setPlotter ( plotter );

    view->resize ( 200, 200 );
    a.setMainWidget( view );
    view->setCaption ( "Qt HippoDraw - View widget" );
    view->show();

    int result = a.exec();

    delete view;
    delete nt;

    return result;
}

Custom application with custom widget in Qt Designer

One can use HippoDraw's QtViewWidget as a custom widget within Qt Designer. When doing so, your main program may look like this

#include <qapplication.h>
#include "QtViewWidgetWindow.h"

int main( int argc, char ** argv )
{
    QApplication app ( argc, argv );
    QtViewWidgetWindow w;
    w.show();
    app.connect( &a, SIGNAL( lastWindowClosed() ), &a, SLOT( quit() ) );

    return app.exec();
}

In this example, the class QtViewWidgetWindow was built with Qt Designer. It was created by asking for a new main window. QtViewWidget was inserted in Qt Designer as a custom widget. The results look like this ...

QtViewWidget as custom widget

In this example, the fileOpen() slot as implemented like the implementation in the Custom application with canvas example. But in addition, the implementation creates an Inspector and signals it to update itself with the created plotter. The code look like this ...

  m_inspector = new Inspector ();
  m_inspector->show();
  QCustomEvent * event = new QCustomEvent ( QEvent::User, plotter );
  QApplication::postEvent ( m_inspector, event );

One might have expected a direct call to Inspector::update following the Observer pattern instead of this implementation. However, it was found that under the Windows operating system, such a direct call caused problems with the OS's threading model. So the QCustomEvent is used to avoid the problem.

Some part of the application may cause a change to the plotter. When that happens, one needs to update the Inspector. Following the Observer pattern, when something in the plotter changes, it sends an update message to its observer which is the QtViewWidget. It in turn, needs to send a message to its parent which is the QtViewWidgetWindow object. It uses a QCustomEvent to do this, so the implementation of the QtViewWidgetWindow must implement it something like this ...

void QtViewWidgetWindow::customEvent ( QCustomEvent * event )
{
  void * data = event->data();
  QCustomEvent * e = new QCustomEvent ( QEvent::User, data );

  QApplication::postEvent ( m_inspector, e );
}

After opening the file, the window looks like this ...

QtViewWidgetWindow after opening file

The complete source code is show below ...

/* -*- mode: c++ -*- */
/****************************************************************************
** ui.h extension file, included from the uic-generated form implementation.
**
** If you wish to add, delete or rename functions or slots use
** Qt Designer which will update this file, preserving your code. Create an
** init() function in place of a constructor, and a destroy() function in
** place of a destructor.
*****************************************************************************/

using std::string;
using std::vector;

void QtViewWidgetWindow::init()
{

}

void QtViewWidgetWindow::fileOpen()
{
   QString file_name 
    = QFileDialog::getOpenFileName ( QString::null, // starting directory
                                     "ntuple (*.*)", // filter
                                     this, // parent
                                     "open ntuple file", // internal name
                                     "Open ntuple" ); // actual window caption
  if ( file_name.isEmpty () ) return;

#if QT_VERSION < 0x030100 // 3.1.0
  const string filename ( file_name );  
#else
  const string filename( file_name.latin1() );
#endif
 NTupleController * nt_controller = NTupleController::instance ();
 DataSource * nt 
    = nt_controller->createNTuple ( filename  );

  const string histo ( "Histogram" );
  vector < string > bindings;
  bindings.push_back ( "Cost" );

  DisplayController * dc_controller = DisplayController::instance ();
  PlotterBase * plotter 
      = dc_controller->createDisplay ( histo, *nt, bindings );

  m_view->setPlotter ( plotter );

  m_inspector = new Inspector ();
  m_view -> setInspector ( m_inspector );

  m_inspector->show();
  m_view->update ( plotter );
  PlotterEvent * event = new PlotterEvent ( plotter );
  QApplication::postEvent ( m_inspector, event );
}

void QtViewWidgetWindow::filePrint()
{

}

void QtViewWidgetWindow::fileExit()
{
qApp->quit();
}

void QtViewWidgetWindow::helpAbout()
{

}

---