GLIMSView Source Code Documentation

maintoolbar.cpp

Go to the documentation of this file.

#include "maintoolbar.h"
#include <qmessagebox.h>
#include <exception>

const char *MainToolbar::VIEW_FILE = "viewfile.vlb";

MainToolbar::MainToolbar( ) {
  this->setCaption( "GLIMSView" );

  //added by EL April 13, 2006
  //to use a custom icon

  QPixmap *pixmap = new QPixmap( "xpms/glimsV2.png", "PNG");

  this->setIcon(*pixmap);

  //end addition by EL

  mInit = true;
  mWorkspace = new QWorkspace( this );

  connect( mWorkspace,
           SIGNAL( windowActivated( QWidget * ) ),
           this,
           SLOT( setFocusWidget( QWidget * ) ) );

  this->setCentralWidget( mWorkspace );

  mHistDlg = new HistogramDlg( mWorkspace );
  mHistDlg->setUser( &View::mGlbHistUser );
  mHistDlg->hide();

  setGeometry( 20, 50, 800, 700 );

  mActGrp      = new QActionGroup( NULL );
  mFileToolbar = new QToolBar( this );
  mNavToolbar  = new QToolBar( this );
  mEditToolbar = new QToolBar( this );
  mToolToolbar = new QToolBar( this );
  mStatBar     = new QStatusBar( this );

  mLblLL = new QLabel( mStatBar );
  mLblXY = new QLabel( mStatBar );
  mLblLL->setMinimumWidth( 225 );
  mLblXY->setMinimumWidth( 150 );
  mLblLL->setMaximumWidth( 225 );
  mLblXY->setMaximumWidth( 150 );
  mStatBar->addWidget( mLblLL );
  mStatBar->addWidget( mLblXY );

  mLblProjFile = new QLabel (mStatBar) ;
  mLblProjFile->setMaximumWidth( 2000 );
  mLblProjFile->setMaximumWidth( 500 );
//  mLblProjFile->setText("No Project Open") ;
  mStatBar->addWidget( mLblProjFile );

  buildMenu();
  buildToolbar();
  buildViews();

  mBandChooser = NULL;
  mProject = NULL;
}

MainToolbar::~MainToolbar( ) {
  toXMLFile( "gvstate.xml", "GVState" );
}

void MainToolbar::buildViews( ) {
  if ( !fromXMLFile( "gvstate.xml", "GVState" ) )
    buildDefaultViews();

  for ( int iview=0; iview < (int)mViewSet.size(); iview++ ) {
    connect( &mViewSet.getView( iview ),
             SIGNAL( mousePosChanged( View::MousePos, View::MousePos ) ),
             this,
             SLOT( setCoordLbls( View::MousePos, View::MousePos ) ) );

    connect( &View::mGlbHistUser,
             SIGNAL( ctableChanged() ),
             &mViewSet.getView( iview ),
             SLOT( ctableChanged() ) );

    mHistDlg->addHDS( &mViewSet.getView( iview ) );
  }

  View::mTool = View::PAN_HAND;
}

void MainToolbar::buildDefaultViews( ) {
  View *v3 = new View( mWorkspace );
  View *v2 = new View( mWorkspace );
  View *v1 = new View( mWorkspace );

  v1->setEditable( false );

  ZoomAttr zattr;
  zattr.factor = 1.0;
  zattr.type = ZoomAttr::SCALE;
  v3->setZoomAttr( zattr );

  zattr.type = ZoomAttr::SCALE;
  zattr.factor = 2.0;
  v2->setZoomAttr( zattr );

  v1->setViewName( "Whole View" );
  v2->setViewName( "Zoom View" );
  v3->setViewName( "Fixed" );

  v1->setGeometry( 401, 0, 300, 300 );
  v2->setGeometry( 401, 301, 300, 300 );
  v3->setGeometry( 0, 0, 400, 600 );
  // v1->parentWidget()->set

  v1->setLinkParent( v3 );
  v3->setLinkChild( v1 );
  v3->setLinkParent( v2 );
  v2->setLinkChild( v3 );

  mViewSet.addView( *v3 );
  mViewSet.addView( *v2 );
  mViewSet.addView( *v1 );

  mViewSet.setRSM( ImageFormat::SCALE_NN );
}

bool MainToolbar::fromXML( QDomElement &elem ) {
  int ivs;

  Rect        mainRect;
  ViewState   viewset;
  View        *view;
  QDomElement e;
  QDomNodeList nodelist;

  nodelist = elem.elementsByTagName( "Rect" );
  for ( unsigned int irect=0; irect < nodelist.count(); irect++ ) {
    e = nodelist.item( irect ).toElement();
    std::string name = "Main";
    if ( !name.compare( (const char*)e.attribute( "id" ) ) ) {
      if ( !mainRect.fromXML( e ) )
        return false;
      break;
    }
  }

  setGeometry( (int)mainRect.x,
               (int)mainRect.y,
               (int)mainRect.w,
               (int)mainRect.h );

  nodelist = elem.elementsByTagName( "ViewState" );
  for ( int iview=0; iview < (int)nodelist.count(); iview++ ) {
    e = nodelist.item( iview ).toElement();
    if ( !viewset.fromXML( e ) )
      continue;

    view = new View( mWorkspace );
    view->getViewState() = viewset;
    mViewSet.addView( *view );
  }

  for ( ivs=0; ivs < (int)mViewSet.size(); ivs++ ) {
    // LINK THE CHILD
    for ( int ipv=0; ipv < (int)mViewSet.size(); ipv++ ) {
      ViewState &ipvs = mViewSet[ipv].getViewState();
      ViewState &ivvs = mViewSet[ivs].getViewState();
      if ( ipvs.mChildName == ivvs.mName ) {
        mViewSet[ivs].setLinkChild( &mViewSet[ipv] );
        break;
      }
    }

    // LINK THE PARENT
    for ( int icv=0; icv < (int)mViewSet.size(); icv++ ) {
      ViewState &icvs = mViewSet[icv].getViewState();
      ViewState &ivvs = mViewSet[ivs].getViewState();
      if ( icvs.mParentName == ivvs.mName ) {
        mViewSet[ivs].setLinkParent( &mViewSet[icv] );
        break;
      }
    }
  }

  for ( ivs=0; ivs < (int)mViewSet.size(); ivs++ ) {
    ViewState &vs = mViewSet[ivs].getViewState();
    mViewSet[ivs].setGeometry( (int)vs.mGeom.x,
                               (int)vs.mGeom.y,
                               (int)vs.mGeom.w,
                               (int)vs.mGeom.h );
    mViewSet[ivs].loadCaption();
  }

  return true;
}

bool MainToolbar::toXML( QDomDocument &doc,
                         QDomElement &elem,
                         std::string id ) {
  QDomElement base;
  base = createBaseTag( doc, elem, id, "GVViewState" );

  QRect r = geometry();
  Rect mainRect;
  int  nViews = (int)mViewSet.size();

  mainRect.x = r.x();
  mainRect.y = r.y();
  mainRect.w = r.width();
  mainRect.h = r.height();
  mainRect.toXML( doc, base, "Main" );

  for ( int iview=0; iview < nViews; iview++ ) {
    QRect pr = mViewSet[iview].parentWidget()->geometry();
    QRect tr = mViewSet[iview].geometry();

    ViewState &vs = mViewSet[iview].getViewState();
    vs.mGeom.x = pr.x();
    vs.mGeom.y = pr.y();
#ifdef WIN32
    vs.mGeom.w = pr.width();
#else
    vs.mGeom.w = tr.width();
#endif
    vs.mGeom.h = tr.height();

    vs.toXML( doc, base );
  }
  return true;
}

void MainToolbar::buildMenu( ) {
  QAction *action = NULL ;
  QMenuBar *mb = this->menuBar();

  QPopupMenu *projectMenu = new QPopupMenu( mb );
  mb->insertItem( tr("&Project"), projectMenu );

  QPopupMenu *imageMenu = new QPopupMenu( mb );
  mb->insertItem( tr("&Image"), imageMenu );

  QPopupMenu *toolsMenu = new QPopupMenu( mb );
  mb->insertItem( tr("&Tools"), toolsMenu );

  QPopupMenu *windowMenu = new QPopupMenu( mb );
  mb->insertItem( tr("&Window"), windowMenu );

  QPopupMenu *helpMenu = new QPopupMenu( mb );
  mb->insertItem( tr("&Help"), helpMenu );

  // ADD FILE MENU ITEMS
  action = new QAction( tr("Create New Project"), tr("Create &New Project"), 0, this );
  action->addTo( projectMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( newProject() ) );

  action = new QAction( tr("Open Project"), tr("&Open Project"), 0, this );
  action->addTo( projectMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openProject() ) );

  action = new QAction( tr("Save Project"), tr("&Save Project"), 0, this );
  action->addTo( projectMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( saveProject() ) );

  action = new QAction( tr("Save As"), tr("&Save As"), 0, this );
  action->addTo( projectMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( saveProjectAs() ) );

  projectMenu->insertSeparator( 5 );

  QPopupMenu *importExportMenu = new QPopupMenu( projectMenu );
  projectMenu->insertItem( tr("Import/Export" ), importExportMenu );

  action = new QAction( tr("Export GLIMS Shapefile"), tr("&Export GLIMS Shapefile"), 0, this );
  action->addTo( importExportMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( exportGLIMSIngest() ) );

  action = new QAction( tr("Import GLIMS Ingest"), tr("&Import GLIMS Shapefile"), 0, this );
  action->addTo( importExportMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( importGLIMSIngest() ) );


  QPopupMenu *importShapefileMenu = new QPopupMenu( importExportMenu );
  importExportMenu->insertItem( tr("Import Generic Shapefile" ), importShapefileMenu );

  action = new QAction( tr("Import Glacier IDs"), tr("&Import Glacier IDs"), 0, this );
  action->addTo( importShapefileMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( importGIDsFromShapefile() ) );

  action = new QAction( tr("Import Segments"), tr("&Import Segments"), 0, this );
  action->addTo( importShapefileMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( importSegmentsFromShapefile() ) );

  projectMenu->insertSeparator( 8 );

  action = new QAction( tr("Exit"), tr("&Exit"), 0, this );
  action->addTo( projectMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( closeApp( ) ) );


  action = new QAction( tr("Open Config"), tr("&Open Config"), 0, this );
  action->addTo( toolsMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openConfigDlg() ) );

  //Added by EL March 28, 2006
  //to add the menu option for the output of selected
  //shapes to a textfile.

  action = new QAction( tr("Output to Spreadsheet"), tr("Output to &Spreadsheet"), 0, this );
  action->addTo( toolsMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openGtoSDlg() ) );

  action = new QAction( tr("Image Polygon Calculator"), tr("&Image Polygon Calculator"), 0, this );
  action->addTo( toolsMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openImgCalcDlg() ) );

  //End Added by EL

  QPopupMenu *pluginMenu = new QPopupMenu( toolsMenu );
  toolsMenu->insertItem( tr("&Additional Tools"), pluginMenu );

  mPlugSet = new PluginSet( mWorkspace, pluginMenu );
  mPlugSet->hide();

  // ADD IMAGE MENU ITEMS
  action = new QAction( tr("Histogram"), tr("&Histogram"), 0, this );
  action->addTo( imageMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openHistDlg() ) );

  action = new QAction( tr("Band Selector"), tr("&Band Selector"), 0, this );
  action->addTo( imageMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openBandSel() ) );

  mMemBufAction = new QAction( tr("Memory Buffer"), tr("&Memory Buffer"),
                               0, this, NULL, true );
  mMemBufAction->addTo( imageMenu );
  connect( mMemBufAction, SIGNAL( activated() ), this, SLOT( setMemBuf() ) );

  // RESAMPLE MENU
  QPopupMenu *resampleMenu = new QPopupMenu( imageMenu );
  imageMenu->insertItem( tr("Resample" ), resampleMenu );

  QActionGroup *rsg = new QActionGroup( NULL );

  action = new QAction( tr("Nearest Neighbor"), tr("&Nearest Neighbor"), 0, this, NULL, true );
  action->addTo( resampleMenu );
  action->setOn( true );
  connect( action, SIGNAL( activated() ), this, SLOT( setNN() ) );
  rsg->insert( action );

  action = new QAction( tr("Bilinear"), tr("&Bilinear"), 0, this, NULL, true );
  action->addTo( resampleMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( setBI() ) );
  rsg->insert( action );

  /*
  action = new QAction( tr("Bicubic"), tr("&Bicubic"), 0, this, NULL, true );
action->addTo( resampleMenu );
connect( action, SIGNAL( activated() ), this, SLOT( setBC() ) );
  rsg->add( action );
  */

  // ADD WINDOW MENU ITEMS
  action = new QAction( tr("Tile"), tr("&Tile"), 0, this );
  action->addTo( windowMenu );
  connect( action, SIGNAL( activated() ), mWorkspace, SLOT( tile() ) );

  action = new QAction( tr("Cascade"), tr("&Cascade"), 0, this );
  action->addTo( windowMenu );
  connect( action, SIGNAL( activated() ), mWorkspace, SLOT( cascade() ) );

  windowMenu->insertSeparator();

  mViewActGroup = new QActionGroup( windowMenu, "Views", true );
  mViewSet.setActGrp( mViewActGroup );
  mViewSet.setMenuParent( windowMenu );


  // ADD HELP MENU ITEMS
  action = new QAction( tr("About"), tr("&About"), 0, this );
  action->addTo( helpMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openAbout() ) );

  action = new QAction( tr("Users Guide"), tr("&Users Guide"), 0, this );
  action->addTo( helpMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( openManual() ) );
}

void MainToolbar::buildToolbar( ) {
  char *xpmFNameSet[] =
  {
    "xpms/hand.xpm",
    "xpms/zoomin.xpm",
    "xpms/zoomout.xpm",
    "xpms/configtool.png",
    "xpms/linetool.xpm",
    "xpms/gid.png",
    "xpms/seltool.xpm",
    "xpms/joinline.png",
    "xpms/splitline.png",
    "xpms/contline.xpm",
    "xpms/fileopen.xpm",
    "xpms/filesave.xpm",
    "xpms/validate.png"
  };

  QPixmap xpmset[13];
  for ( int i=0; i <= 12; i++ ) {
    QImage img( xpmFNameSet[i] );
    xpmset[i].convertFromImage( img.smoothScale( 22, 22 ) );
  }

  setToolBarsMovable (true) ;
  QToolBar *tb_file = mFileToolbar;
  QToolBar *tb_nav  = mNavToolbar;
  QToolBar *tb_edit = mEditToolbar;
  QToolBar *tb_tool = mToolToolbar;
  QAction *action;

  // *********************************
  // FILE TOOLBAR
  // open project
  action = new QAction( "", QIconSet( xpmset[10] ), "", 0, this, 0, false );
  action->addTo( tb_file );
  connect( action, SIGNAL( activated() ), this, SLOT( openProject() ) );
  action->setToolTip( "Open Project" );

  // save project
  action = new QAction( "", QIconSet( xpmset[11] ), "", 0, this, 0, false );
  action->addTo( tb_file );
  connect( action, SIGNAL( activated() ), this, SLOT( saveProject() ) );
  action->setToolTip( "Save Project" );

  // *********************************
  // NAVIGATION TOOLBAR
  // pan
  action = new QAction( "", QIconSet( xpmset[0] ), "", 0, this, 0, true );
  action->addTo( tb_nav );
  mActGrp->insert( action );
  connect( action, SIGNAL( activated() ), this, SLOT( setPanHand() ) );
  action->setToolTip( "Pan Tool" );

  // zoom in
  action = new QAction( "", QIconSet( xpmset[1] ), "", 0, this, 0, true );
  action->addTo( tb_nav );
  mActGrp->insert( action );
  connect( action, SIGNAL( activated() ), this, SLOT( setZoomInInc() ) );
  action->setToolTip( "Zoom In" );

  // zoom out
  action = new QAction( "", QIconSet( xpmset[2] ), "", 0, this, 0, true );
  action->addTo( tb_nav );
  mActGrp->insert( action );
  connect( action, SIGNAL( activated() ), this, SLOT( setZoomOutInc() ) );
  action->setToolTip( "Zoom Out" );


  // ****************
  // TOOL TOOLBAR 
  // Selection tool
  action = new QAction( "", QIconSet( xpmset[6] ), "", 0, this, 0, true );
  action->addTo( tb_tool );
  connect( action, SIGNAL( activated() ), this, SLOT( setSelTool() ) );
  mActGrp->insert( action );
  action->setToolTip( "Selection Tool" );

  // GLIMS configuration tool
  mOpenConfigAction = new QAction( "", QIconSet( xpmset[3] ), "", 0, this, 0, false );
  mOpenConfigAction->addTo( tb_tool );
  mOpenConfigAction->setToolTip( "GLIMS Config Tool" );

  // Vector layer tool
  /*
  mOpenVectorLayerAction = new QAction( "", QIconSet( xpmset[3] ), "", 0, this, 0, false );
  mOpenVectorLayerAction->addTo( tb_tool );
  mOpenVectorLayerAction->setToolTip( "Vector Layers" );
  */

  // Glacier ID tool
  action = new QAction( "", QIconSet( xpmset[5] ), "", 0, this, 0, true );
  action->addTo( tb_tool );
  connect( action, SIGNAL( activated() ), this, SLOT( setGIDTool() ) );
  mActGrp->insert( action );
  action->setToolTip( "Glacer ID Tool" );

  // Validate project
  mValidateProject = new QAction( "", QIconSet( xpmset[12] ), "", 0, this, 0, false );
  mValidateProject->addTo( tb_tool );
  mValidateProject->setToolTip( "Check Project Validation" );


  // *******************************
  // LINE EDITOR TOOLBAR
  // line tool
  action = new QAction( "", QIconSet( xpmset[4] ), "", 0, this, 0, true );
  action->addTo( tb_edit );
  connect( action, SIGNAL( activated() ), this, SLOT( setLineTool() ) );
  mActGrp->insert( action );
  action->setToolTip( "Line Tool" );

  // split line
  mBreakAction = new QAction( "", QIconSet( xpmset[8] ), "", 0, this, 0, false );
  mBreakAction->addTo( tb_edit );
  mBreakAction->setToolTip( "Split Line" );

  // join line
  mJoinAction = new QAction( "", QIconSet( xpmset[7] ), "", 0, this, 0, false );
  mJoinAction->addTo( tb_edit );
  mJoinAction->setToolTip( "Join Line" );

  /*
mContAction = new QAction( "", QIconSet( xpmset[9] ), "", 0, this, 0, false );
  mContAction->addTo( tb );
  */

}

void MainToolbar::newProject( ) {
  GLIMSProject *proj = new GLIMSProject( mWorkspace, &mViewSet );
  proj->create();
  if ( proj->isOpen() ) {
    setupProj( proj );
    setProjectFileName ("New Project") ;
  }
  else {
    delete proj;
  }
}

void MainToolbar::openProject( ) {
  GLIMSProject *proj = new GLIMSProject( mWorkspace, &mViewSet );
  if ( !(proj->open()) ) {
    // FOR SOME REASON I AM NOT ABLE TO DELETE THIS IN WINDOWS??? (Dan)
    // glimsview crashes when the following line is uncommented and 
    // a Open Project file chooser window is cancelled (deborah)
    // delete proj;
    return;
  }

  setupProj( proj );
  setProjectFileName ((proj->getFileName()).c_str()) ;
}

void MainToolbar::setupProj( GLIMSProject *proj ) {
  int i;
  if ( !proj ) return;

  mViewSet.initViews();

  if ( mProject ) delete mProject;

  if ( mBandChooser ) delete mBandChooser;

  Image * theImage = proj->getImage() ;

  mBandChooser = new BandChooserDlg( mWorkspace, theImage );

  mBandChooser->show();

  ImageState theState = proj->getImage()->getImageState() ;

  for ( i=0; i < (int)mViewSet.size(); i++ ) {
    Image *img = proj->getImage();
    View &v = mViewSet.getView( i );
    v.setImage( img );
    mViewSet.getView( i ).setVectorLayerSet( proj->getVectorLayerSet() );
  }

  connect( mBandChooser,
           SIGNAL( selBandsChanged() ),
           proj->getVectorLayerSet(),
           SLOT( transformDatasets() ) );

  connect( mBandChooser,
           SIGNAL( selBandsChanged() ),
           &mViewSet,
           SLOT( resetViews() ) );

  for ( i=0; i < (int)mViewSet.size(); i++ ) {
    proj->getVectorEditor()->addView( &mViewSet.getView(i) );
  }

  connect( mBreakAction,
           SIGNAL( activated() ),
           proj->getVectorEditor(),
           SLOT( breakLine() ) );

  connect( mJoinAction,
           SIGNAL( activated() ),
           proj->getVectorEditor(),
           SLOT( joinLine() ) );

  connect( mOpenConfigAction,
           SIGNAL( activated() ),
           proj,
           SLOT( openConfigDlg() ) );

  connect( mValidateProject,
           SIGNAL( activated() ),
           proj,
           SLOT( validate() ) );

  /*
  connect( mOpenVectorLayerAction,
           SIGNAL( activated() ),
           proj,
           SLOT( openVectorLayerDlg() ) );
  */

  mProject = proj;

  // set the current software version date so it can be written
  // to the project file when saved.
  mProject->setCurrentVersion(AboutDlg::GV_DATE) ;

  mMemBufAction->setOn( false );

  mPlugSet->setProj( mProject );
}

void MainToolbar::closeApp( ) {
  closeEvent( NULL );
}

void MainToolbar::closeProject( ) {
  setProjectFileName ("Project closed") ;
}

void MainToolbar::print( ) {}

void MainToolbar::openBandSel( ) {
  if ( mBandChooser ) {
    mBandChooser->show();
    mBandChooser->setFocus();
  }
}

void MainToolbar::openHistDlg( ) {
  mHistDlg->hide();
  mHistDlg->show();
  mHistDlg->setFocus();
}

void MainToolbar::repaintViews( bool ) {
  mViewSet.repaintViews();
}

void MainToolbar::setPanHand( ) {
  View::mTool = View::PAN_HAND;
}

void MainToolbar::setZoomInInc( ) {
  View::mTool = View::ZOOMIN_INC;
}

void MainToolbar::setZoomOutInc( ) {
  View::mTool = View::ZOOMOUT_INC;
}

void MainToolbar::setLineTool( ) {
  View::mTool = View::LINE;
  if ( mProject )
    mProject->getVectorLayerSet()->setActiveLayer( 0 );
}

void MainToolbar::setSelTool( ) {
  View::mTool = View::SELECTION;
}

void MainToolbar::setGIDTool( ) {
  View::mTool = View::GLACIER_ID;
  if ( mProject )
    mProject->getVectorLayerSet()->setActiveLayer( 1 );
}

void MainToolbar::setProjectFileName (QString fn) {
  mLblProjFile->setText(fn) ;
}

void MainToolbar::setCoordLbls( View::MousePos ll, View::MousePos xy ) {
  char buf[100];

  if ( fabs( ll.x ) < 0.000001 || fabs( ll.x ) > 999.0 ) {
    if (ll.x < 0) {
      ll.x += 360.0 ;
    }
    ll.x = 0.0;
  }
  if ( fabs( ll.y ) < 0.000001 || fabs( ll.y ) > 999.0 ) {
    ll.y = 0.0;
  }

  sprintf( buf, "%8.5f Lon X %7.5f Lat", ll.x, ll.y );
  mLblLL->setText( buf );

  sprintf( buf, "%d X %d", (int)xy.x, (int)xy.y );
  mLblXY->setText( buf );
}

void MainToolbar::setFocusWidget( QWidget *w ) {
  w->setFocus();
}

void MainToolbar::saveProject( ) {
  if ( mProject )
    mProject->save();
}

void MainToolbar::saveProjectAs( ) {
  if ( mProject )
    mProject->saveAs();
}

void MainToolbar::openConfigDlg( ) {
  if ( mProject )
    mProject->openConfigDlg();
}

/* void openGtoSDlg()
 * added by EL
 */
void MainToolbar::openGtoSDlg(){
  if( mProject ) {
    SpreadsheetDialog *ssDlg = new SpreadsheetDialog ( mProject );
    ssDlg->show();
    ssDlg->setFocus();

  }

}

/* void openImgCalcDlg()
 * added by EL
 */
void MainToolbar::openImgCalcDlg(){
  if( mProject ) {
    imgCalcDlg = new ImageCalculatorDialog ( mProject );
    imgCalcDlg->show();
    imgCalcDlg->setFocus();
    connect( imgCalcDlg, SIGNAL( imgCalcComplete() ), imgCalcDlg, SLOT(close() ) ) ;
    connect( imgCalcDlg, SIGNAL( imgCalcComplete() ), this, SLOT(imgCalcEnd()) ) ;
  }
}

void MainToolbar::imgCalcEnd() {
}

void MainToolbar::importGLIMSIngest( ) {
  GLIMSProject *proj = new GLIMSProject( mWorkspace, &mViewSet );

  // start ingest by getting the base image info from the exported shapefile
  QString loc = proj->importGLIMSIngestImageInfo () ;

//  if ( proj->isOpen() ) {
    setupProj( proj );
//  }

  if (loc != "") { 
    // set up project to finish importing GLIMS shapefiles when the band chooser has 
    // loaded the image data
    connect (mBandChooser, SIGNAL(selBandsChanged()), mProject, SLOT(importGLIMSIngestData())) ;
    // setup toolbar to disconnect previous signal-slot when the project is done ingesting data
    connect (mProject, SIGNAL(finishedIngestion()), this, SLOT(ingestEnd())) ;
  }
}

void MainToolbar::exportGLIMSIngest( ) {
  if ( mProject )
    mProject->exportGLIMSIngest();
}

void MainToolbar::importSegmentsFromShapefile( ) {
  if ( mProject )
    mProject->importSegmentsFromShapefile();
  else
    QMessageBox::information( NULL,
                              "Image Not Open",
                              "You must have an image open in order to import shapefiles" );
}

void MainToolbar::importGIDsFromShapefile( ) {
  if ( mProject )
    mProject->importGIDsFromShapefile();
  else
    QMessageBox::information( NULL,
                              "Image Not Open",
                              "You must have an image open in order to import shapefiles" );
}

void MainToolbar::setMemBuf( ) {
  if ( mMemBufAction->isOn() ) {
    if ( !mProject ) {
      mMemBufAction->setOn( false );
      return;
    }

    mProject->getImage()->setMemBuf( true );
  } else {
    if ( !mProject )
      return;
    mProject->getImage()->setMemBuf( false );
  }
}

void MainToolbar::setNN( ) {
  mViewSet.setRSM( ImageFormat::SCALE_NN );
}

void MainToolbar::setBI( ) {
  mViewSet.setRSM( ImageFormat::SCALE_BI );
}

void MainToolbar::setBC( ) {
  mViewSet.setRSM( ImageFormat::SCALE_BC );
}

void MainToolbar::openAbout( ) {
  AboutDlg *abdlg = new AboutDlg;
  abdlg->exec();
}

void MainToolbar::openManual( ) {
  QMimeSourceFactory::defaultFactory()->addFilePath(".");
  QTextBrowser *tb = new QTextBrowser();
  tb->setVScrollBarMode(QScrollView::Auto) ;
  tb->setCaption( "GLIMSView User's Guide" );
  tb->setSource( "doc/GLIMSView_UsersGuide.html" );
  tb->show();
  tb->resize( 850, 600 );
}


void MainToolbar::ingestEnd () {
  disconnect (mBandChooser, SIGNAL(selBandsChanged()), mProject, SLOT(importGLIMSIngestData())) ;
}


TraceLog glimslog ;

int main( int argc, char **argv ) {
  try {
    QApplication app( argc, argv );
    MainToolbar mt ;
    app.setMainWidget( &mt );
    mt.show();
    return app.exec();
  }
  catch (std::exception const &se) {
    QMessageBox::information( 0, "Bomb", "suck air" );
  }


}

---

Home | Search | Disclaimers & Privacy | Contact Us GLIMSView Maintainer: dsoltesz@usgs.gov