-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
+// Copyright (C) 2014-2015 EDF-R&D
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "HYDROGUI_PrsImage.h"
#include "HYDROGUI_Tool.h"
+#include "HYDROGUI_Module.h"
#include <HYDROData_Lambert93.h>
+#include <HYDROData_Image.h>
+#include <LightApp_Application.h>
#include <SUIT_FileDlg.h>
#include <SUIT_ResourceMgr.h>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
#include <SUIT_Session.h>
#include <QtxDoubleSpinBox.h>
#include <QPushButton>
#include <QRadioButton>
#include <QToolButton>
+#include <QCheckBox>
HYDROGUI_ImportImageDlg::HYDROGUI_ImportImageDlg( HYDROGUI_Module* theModule, const QString& theTitle )
: HYDROGUI_InputPanel( theModule, theTitle ),
SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
// Import image from file
- myFileNameGroup = new QGroupBox( tr( "IMPORT_IMAGE_FROM_FILE" ) );
+ myFileNameGroup = new QGroupBox( tr( "IMPORT_IMAGE_FROM_FILE" ), this );
QLabel* aFileNameLabel = new QLabel( tr( "FILE_NAME" ), myFileNameGroup );
myFileName = new QLineEdit( myFileNameGroup );
myFileName->setReadOnly( true );
- QToolButton* aBrowseBtn = new QToolButton( myFileNameGroup );
- aBrowseBtn->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "BROWSE_ICO" ) ) );
+ myBrowseBtn = new QToolButton( myFileNameGroup );
+ myBrowseBtn->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "BROWSE_ICO" ) ) );
QBoxLayout* aFileNameLayout = new QHBoxLayout( myFileNameGroup );
aFileNameLayout->setMargin( 5 );
aFileNameLayout->setSpacing( 5 );
aFileNameLayout->addWidget( aFileNameLabel );
aFileNameLayout->addWidget( myFileName );
- aFileNameLayout->addWidget( aBrowseBtn );
+ aFileNameLayout->addWidget( myBrowseBtn );
// Image name
- myImageNameGroup = new QGroupBox( tr( "IMAGE_NAME" ) );
+ myImageNameGroup = new QGroupBox( tr( "IMAGE_NAME" ), this );
QLabel* anImageNameLabel = new QLabel( tr( "NAME" ), myImageNameGroup );
myImageName = new QLineEdit( myImageNameGroup );
anImageNameLayout->addWidget( myImageName );
// Transform image
- myTransformGroup = new QGroupBox( tr( "TRANSFORM_IMAGE" ) );
+ myTransformGroup = new QGroupBox( tr( "TRANSFORM_IMAGE" ), this );
// Make a pixmap for arrow
QPixmap anArrowPixmap = aResMgr->loadPixmap( "HYDRO", tr( "ARROW_RIGHT_ICO" ) );
aPainter.drawPixmap( 0, 0, anArrowPixmap );
aPainter.end();
- QRadioButton* aManualLambertBtn = new QRadioButton( tr( "MANUALLY_LAMBERT93" ), myTransformGroup );
- QRadioButton* aManualCartesianBtn = new QRadioButton( tr( "MANUALLY_CARTESIAN" ), myTransformGroup );
+ QRadioButton* aManualGeodesicBtn = new QRadioButton( tr( "MANUALLY_GEODESIC" ), myTransformGroup );
+ QRadioButton* aManualCartesianBtn = new QRadioButton( tr( "MANUALLY_LAMBERT93" ), myTransformGroup );
+ QRadioButton* aCartesianFromFileBtn = new QRadioButton( tr( "LAMBERT93_FROM_FILE" ), myTransformGroup );
QRadioButton* aRefImageBtn = new QRadioButton( tr( "BY_REFERENCE_IMAGE" ), myTransformGroup );
myModeGroup = new QButtonGroup( myTransformGroup );
- myModeGroup->addButton( aManualLambertBtn, ManualLambert );
- myModeGroup->addButton( aManualCartesianBtn, ManualCartesian );
- myModeGroup->addButton( aRefImageBtn, RefImage );
+ myModeGroup->addButton( aManualGeodesicBtn, HYDROData_Image::ManualGeodesic );
+ myModeGroup->addButton( aManualCartesianBtn, HYDROData_Image::ManualCartesian );
+ myModeGroup->addButton( aCartesianFromFileBtn, HYDROData_Image::CartesianFromFile );
+ myModeGroup->addButton( aRefImageBtn, HYDROData_Image::ReferenceImage );
myRefImage = new QComboBox( myTransformGroup );
- QGridLayout* aModeLayout = new QGridLayout();
+ QVBoxLayout* aTransformLayout = new QVBoxLayout( myTransformGroup );
+ aTransformLayout->setMargin( 5 );
+ aTransformLayout->setSpacing( 5 );
+
+ QGridLayout* aModeLayout = new QGridLayout( myTransformGroup );
aModeLayout->setMargin( 0 );
aModeLayout->setSpacing( 5 );
- aModeLayout->addWidget( aManualLambertBtn, 0, 0 );
+ aModeLayout->addWidget( aManualGeodesicBtn, 0, 0 );
aModeLayout->addWidget( aManualCartesianBtn, 1, 0 );
- aModeLayout->addWidget( aRefImageBtn, 2, 0 );
- aModeLayout->addWidget( myRefImage, 2, 1 );
+ aModeLayout->addWidget( aCartesianFromFileBtn, 2, 0 );
+ aModeLayout->addWidget( aRefImageBtn, 3, 0 );
+ aModeLayout->addWidget( myRefImage, 3, 1 );
aModeLayout->setColumnStretch( 1, 1 );
- QGridLayout* aTransformLayout = new QGridLayout( myTransformGroup );
- aTransformLayout->setMargin( 5 );
- aTransformLayout->setSpacing( 5 );
- aTransformLayout->addLayout( aModeLayout, 0, 0, 1, 9 );
+ aTransformLayout->addLayout( aModeLayout );
+
+ // Manual input widget
+ QWidget* aManualInputGroup = new QWidget( myTransformGroup );
+ QGridLayout* aManualInputLayout = new QGridLayout( aManualInputGroup );
+ aManualInputLayout->setMargin( 5 );
+ aManualInputLayout->setSpacing( 5 );
+
+ QLabel* aImageCSLabel = new QLabel( tr( "IMAGE_CS" ), aManualInputGroup );
+ QLabel* aGeodesicLabel = new QLabel( tr( "GEODESIC" ), aManualInputGroup );
+ QLabel* aLambertLabel = new QLabel( tr( "LAMBERT93" ), aManualInputGroup );
+ QLabel* aRefImageLabel = new QLabel( tr( "REFERENCE_IMAGE_CS" ), aManualInputGroup );
+
+ aManualInputLayout->addWidget( aImageCSLabel, 0, 1 );
+ aManualInputLayout->addWidget( aGeodesicLabel, 0, 2, 1, 6 );
+ aManualInputLayout->addWidget( aLambertLabel, 0, 2, 1, 6 );
+ aManualInputLayout->addWidget( aRefImageLabel, 0, 2, 1, 6 );
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
QPushButton* aPointBtn = new QPushButton( aPointStr, myTransformGroup );
aPointBtn->setCheckable( true );
- QLabel* aPointXLabel = new QLabel( "X", myTransformGroup );
- QLabel* aPointYLabel = new QLabel( "Y", myTransformGroup );
+ QLabel* aPointXLabel = new QLabel( "X", aManualInputGroup );
+ QLabel* aPointYLabel = new QLabel( "Y", aManualInputGroup );
- QtxIntSpinBox* aPointX = new QtxIntSpinBox( 0, 0, 1, myTransformGroup ); // max is updated later
- QtxIntSpinBox* aPointY = new QtxIntSpinBox( 0, 0, 1, myTransformGroup ); // max is updated later
+ QtxIntSpinBox* aPointX = new QtxIntSpinBox( 0, 0, 1, aManualInputGroup ); // max is updated later
+ QtxIntSpinBox* aPointY = new QtxIntSpinBox( 0, 0, 1, aManualInputGroup ); // max is updated later
- QLabel* aPointArrowLabel = new QLabel( myTransformGroup );
+ QLabel* aPointArrowLabel = new QLabel( aManualInputGroup );
aPointArrowLabel->setPicture( anArrowPicture );
- QLabel* aPointXDegLabel = new QLabel( QChar( 0x00B0 ), myTransformGroup );
- QLabel* aPointYDegLabel = new QLabel( QChar( 0x00B0 ), myTransformGroup );
- QLabel* aPointXMinLabel = new QLabel( "'", myTransformGroup );
- QLabel* aPointYMinLabel = new QLabel( "'", myTransformGroup );
- QLabel* aPointXSecLabel = new QLabel( "\"", myTransformGroup );
- QLabel* aPointYSecLabel = new QLabel( "\"", myTransformGroup );
- myLambertLabels << aPointXDegLabel << aPointYDegLabel
+ QLabel* aPointXDegLabel = new QLabel( QChar( 0x00B0 ), aManualInputGroup );
+ QLabel* aPointYDegLabel = new QLabel( QChar( 0x00B0 ), aManualInputGroup );
+ QLabel* aPointXMinLabel = new QLabel( "'", aManualInputGroup );
+ QLabel* aPointYMinLabel = new QLabel( "'", aManualInputGroup );
+ QLabel* aPointXSecLabel = new QLabel( "\"", aManualInputGroup );
+ QLabel* aPointYSecLabel = new QLabel( "\"", aManualInputGroup );
+ QLabel* aPointLatLabel = new QLabel( tr( "POINT_LATITUDE" ), aManualInputGroup );
+ QLabel* aPointLonLabel = new QLabel( tr( "POINT_LONGITUDE" ), aManualInputGroup );
+ myGeodesicLabels << aPointXDegLabel << aPointYDegLabel
<< aPointXMinLabel << aPointYMinLabel
- << aPointXSecLabel << aPointYSecLabel;
-
- QtxIntSpinBox* aPointXDeg = new QtxIntSpinBox( -180, 180, 1, myTransformGroup );
- QtxIntSpinBox* aPointYDeg = new QtxIntSpinBox( -90, 90, 1, myTransformGroup );
- QtxIntSpinBox* aPointXMin = new QtxIntSpinBox( 0, 59, 1, myTransformGroup );
- QtxIntSpinBox* aPointYMin = new QtxIntSpinBox( 0, 59, 1, myTransformGroup );
- QtxDoubleSpinBox* aPointXSec = new QtxDoubleSpinBox( 0, 59.9999, 1, 4, 4, myTransformGroup );
- QtxDoubleSpinBox* aPointYSec = new QtxDoubleSpinBox( 0, 59.9999, 1, 4, 4, myTransformGroup );
-
- QtxDoubleSpinBox* aCartPointX = new QtxDoubleSpinBox( 0, 1e8, 1, 2, 2, myTransformGroup );
- QtxDoubleSpinBox* aCartPointY = new QtxDoubleSpinBox( 0, 1e8, 1, 2, 2, myTransformGroup );
-
- QtxIntSpinBox* aRefPointX = new QtxIntSpinBox( 0, 0, 1, myTransformGroup ); // max is updated later
- QtxIntSpinBox* aRefPointY = new QtxIntSpinBox( 0, 0, 1, myTransformGroup ); // max is updated later
-
- int aRow = 4 * aPointType + 2;
- aTransformLayout->addWidget( aPointBtn, aRow, 0, 1, 9 );
-
- aTransformLayout->addWidget( aPointXLabel, aRow + 1, 0 );
- aTransformLayout->addWidget( aPointX, aRow + 1, 1 );
- aTransformLayout->addWidget( aPointArrowLabel, aRow + 1, 2, 2, 1 );
- aTransformLayout->addWidget( aPointXDeg, aRow + 1, 3 );
- aTransformLayout->addWidget( aPointXDegLabel, aRow + 1, 4 );
- aTransformLayout->addWidget( aPointXMin, aRow + 1, 5 );
- aTransformLayout->addWidget( aPointXMinLabel, aRow + 1, 6 );
- aTransformLayout->addWidget( aPointXSec, aRow + 1, 7 );
- aTransformLayout->addWidget( aPointXSecLabel, aRow + 1, 8 );
-
- aTransformLayout->addWidget( aCartPointX, aRow + 1, 3, 1, 6 );
- aTransformLayout->addWidget( aRefPointX, aRow + 1, 3, 1, 6 );
-
- aTransformLayout->addWidget( aPointYLabel, aRow + 2, 0 );
- aTransformLayout->addWidget( aPointY, aRow + 2, 1 );
- aTransformLayout->addWidget( aPointYDeg, aRow + 2, 3 );
- aTransformLayout->addWidget( aPointYDegLabel, aRow + 2, 4 );
- aTransformLayout->addWidget( aPointYMin, aRow + 2, 5 );
- aTransformLayout->addWidget( aPointYMinLabel, aRow + 2, 6 );
- aTransformLayout->addWidget( aPointYSec, aRow + 2, 7 );
- aTransformLayout->addWidget( aPointYSecLabel, aRow + 2, 8 );
-
- aTransformLayout->addWidget( aCartPointY, aRow + 2, 3, 1, 6 );
- aTransformLayout->addWidget( aRefPointY, aRow + 2, 3, 1, 6 );
+ << aPointXSecLabel << aPointYSecLabel
+ << aPointLonLabel << aPointLatLabel;
+
+ QtxIntSpinBox* aPointXDeg = new QtxIntSpinBox( -179, 179, 1, aManualInputGroup );
+ QtxIntSpinBox* aPointYDeg = new QtxIntSpinBox( 0, 89, 1, aManualInputGroup );
+ QtxIntSpinBox* aPointXMin = new QtxIntSpinBox( 0, 59, 1, aManualInputGroup );
+ QtxIntSpinBox* aPointYMin = new QtxIntSpinBox( 0, 59, 1, aManualInputGroup );
+ QtxDoubleSpinBox* aPointXSec = new QtxDoubleSpinBox( 0, 59.9999, 1, 4, 4, aManualInputGroup );
+ QtxDoubleSpinBox* aPointYSec = new QtxDoubleSpinBox( 0, 59.9999, 1, 4, 4, aManualInputGroup );
+
+ QtxDoubleSpinBox* aCartPointX = new QtxDoubleSpinBox( 0, 1e8, 1, 2, 2, aManualInputGroup );
+ QtxDoubleSpinBox* aCartPointY = new QtxDoubleSpinBox( 0, 1e8, 1, 2, 2, aManualInputGroup );
+
+ QtxIntSpinBox* aRefPointX = new QtxIntSpinBox( 0, 0, 1, aManualInputGroup ); // max is updated later
+ QtxIntSpinBox* aRefPointY = new QtxIntSpinBox( 0, 0, 1, aManualInputGroup ); // max is updated later
+
+ int aRow = 4 * aPointType;
+ if ( aPointType == HYDROGUI_PrsImage::PointC )
+ {
+ myPointCEnabler = new QCheckBox( aManualInputGroup );
+ aManualInputLayout->addWidget( myPointCEnabler, aRow, 0, 1, 2, Qt::AlignHCenter );
+ aManualInputLayout->addWidget( aPointBtn, aRow, 2, 1, 8 );
+ }
+ else
+ {
+ aManualInputLayout->addWidget( aPointBtn, aRow, 0, 1, 10 );
+ }
+
+ aManualInputLayout->addWidget( aPointXLabel, aRow + 1, 0 );
+ aManualInputLayout->addWidget( aPointX, aRow + 1, 1 );
+ aManualInputLayout->addWidget( aPointArrowLabel, aRow + 1, 2, 2, 1 );
+ aManualInputLayout->addWidget( aPointXDeg, aRow + 1, 3 );
+ aManualInputLayout->addWidget( aPointXDegLabel, aRow + 1, 4 );
+ aManualInputLayout->addWidget( aPointXMin, aRow + 1, 5 );
+ aManualInputLayout->addWidget( aPointXMinLabel, aRow + 1, 6 );
+ aManualInputLayout->addWidget( aPointXSec, aRow + 1, 7 );
+ aManualInputLayout->addWidget( aPointXSecLabel, aRow + 1, 8 );
+ aManualInputLayout->addWidget( aPointLonLabel, aRow + 1, 9 );
+
+ aManualInputLayout->addWidget( aCartPointX, aRow + 1, 3, 1, 6 );
+ aManualInputLayout->addWidget( aRefPointX, aRow + 1, 3, 1, 6 );
+
+ aManualInputLayout->addWidget( aPointYLabel, aRow + 2, 0 );
+ aManualInputLayout->addWidget( aPointY, aRow + 2, 1 );
+ aManualInputLayout->addWidget( aPointYDeg, aRow + 2, 3 );
+ aManualInputLayout->addWidget( aPointYDegLabel, aRow + 2, 4 );
+ aManualInputLayout->addWidget( aPointYMin, aRow + 2, 5 );
+ aManualInputLayout->addWidget( aPointYMinLabel, aRow + 2, 6 );
+ aManualInputLayout->addWidget( aPointYSec, aRow + 2, 7 );
+ aManualInputLayout->addWidget( aPointYSecLabel, aRow + 2, 8 );
+ aManualInputLayout->addWidget( aPointLatLabel, aRow + 2, 9 );
+
+ aManualInputLayout->addWidget( aCartPointY, aRow + 2, 3, 1, 6 );
+ aManualInputLayout->addWidget( aRefPointY, aRow + 2, 3, 1, 6 );
if( aPointType != HYDROGUI_PrsImage::PointC )
{
- QFrame* aLine = new QFrame( myTransformGroup );
+ QFrame* aLine = new QFrame( aManualInputGroup );
aLine->setFrameShape( QFrame::HLine );
aLine->setFrameShadow( QFrame::Sunken );
- aTransformLayout->addWidget( aLine, aRow + 3, 0, 1, 9 );
+ aManualInputLayout->addWidget( aLine, aRow + 3, 0, 1, 10 );
}
myPointBtnMap[ aPointType ] = aPointBtn;
connect( aPointX, SIGNAL( valueChanged( int ) ), this, SLOT( onPointCoordChanged( int ) ) );
connect( aPointY, SIGNAL( valueChanged( int ) ), this, SLOT( onPointCoordChanged( int ) ) );
- connect( aPointXDeg, SIGNAL( valueChanged( int ) ), this, SLOT( onLambertCoordChanged() ) );
- connect( aPointYDeg, SIGNAL( valueChanged( int ) ), this, SLOT( onLambertCoordChanged() ) );
- connect( aPointXMin, SIGNAL( valueChanged( int ) ), this, SLOT( onLambertCoordChanged() ) );
- connect( aPointYMin, SIGNAL( valueChanged( int ) ), this, SLOT( onLambertCoordChanged() ) );
- connect( aPointXSec, SIGNAL( valueChanged( double ) ), this, SLOT( onLambertCoordChanged() ) );
- connect( aPointYSec, SIGNAL( valueChanged( double ) ), this, SLOT( onLambertCoordChanged() ) );
+ connect( aPointXDeg, SIGNAL( valueChanged( int ) ), this, SLOT( onGeodesicCoordChanged() ) );
+ connect( aPointYDeg, SIGNAL( valueChanged( int ) ), this, SLOT( onGeodesicCoordChanged() ) );
+ connect( aPointXMin, SIGNAL( valueChanged( int ) ), this, SLOT( onGeodesicCoordChanged() ) );
+ connect( aPointYMin, SIGNAL( valueChanged( int ) ), this, SLOT( onGeodesicCoordChanged() ) );
+ connect( aPointXSec, SIGNAL( valueChanged( double ) ), this, SLOT( onGeodesicCoordChanged() ) );
+ connect( aPointYSec, SIGNAL( valueChanged( double ) ), this, SLOT( onGeodesicCoordChanged() ) );
connect( aCartPointX, SIGNAL( valueChanged( double ) ), this, SLOT( onCartesianCoordChanged() ) );
connect( aCartPointY, SIGNAL( valueChanged( double ) ), this, SLOT( onCartesianCoordChanged() ) );
connect( aRefPointX, SIGNAL( valueChanged( int ) ), this, SLOT( onPointCoordChanged( int ) ) );
connect( aRefPointY, SIGNAL( valueChanged( int ) ), this, SLOT( onPointCoordChanged( int ) ) );
}
- aTransformLayout->setColumnStretch( 1, 1 ); // double
- aTransformLayout->setColumnStretch( 3, 1 ); // degrees
- aTransformLayout->setColumnStretch( 5, 1 ); // minutes
- aTransformLayout->setColumnStretch( 7, 2 ); // seconds (double with 4 digits)
+
+ // Connect checkbox enabling point C
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointBtnMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointXMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointYMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointXDegMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointYDegMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointXMinMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointYMinMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointXSecMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myPointYSecMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myCartPointXMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myCartPointYMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myRefPointXMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), myRefPointYMap[ HYDROGUI_PrsImage::PointC ], SLOT( setEnabled( bool ) ) );
+
+ connect( myPointCEnabler, SIGNAL( toggled( bool ) ), SLOT( onSetCIsUsed( bool ) ) );
+
+ aManualInputLayout->setColumnStretch( 1, 1 ); // double
+ aManualInputLayout->setColumnStretch( 3, 1 ); // degrees
+ aManualInputLayout->setColumnStretch( 5, 1 ); // minutes
+ aManualInputLayout->setColumnStretch( 7, 2 ); // seconds (double with 4 digits)
+
+ // Image georeferencement file widget
+ QWidget* aFromFileInputGroup = new QWidget( myTransformGroup );
+ QBoxLayout* aFromFileInputLayout = new QHBoxLayout( aFromFileInputGroup );
+ aFromFileInputLayout->setMargin( 5 );
+ aFromFileInputLayout->setSpacing( 5 );
+
+ QLabel* aGeoFileNameLabel = new QLabel( tr( "FILE_NAME" ), aFromFileInputGroup );
+
+ myGeoFileName = new QLineEdit( aFromFileInputGroup );
+ myGeoFileName->setReadOnly( true );
+
+ QToolButton* aGeoBrowseBtn = new QToolButton( aFromFileInputGroup );
+ aGeoBrowseBtn->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "BROWSE_ICO" ) ) );
+
+ aFromFileInputLayout->addWidget( aGeoFileNameLabel );
+ aFromFileInputLayout->addWidget( myGeoFileName );
+ aFromFileInputLayout->addWidget( aGeoBrowseBtn );
+
+ // Widgets connections
+ connect( aManualCartesianBtn, SIGNAL( toggled( bool ) ), aLambertLabel, SLOT( setVisible ( bool ) ) );
+ connect( aManualCartesianBtn, SIGNAL( toggled( bool ) ), aGeodesicLabel, SLOT( setHidden ( bool ) ) );
+ connect( aManualCartesianBtn, SIGNAL( toggled( bool ) ), aRefImageLabel, SLOT( setHidden ( bool ) ) );
+ connect( aManualCartesianBtn, SIGNAL( toggled( bool ) ), aFromFileInputGroup, SLOT( setHidden ( bool ) ) );
+ connect( aManualGeodesicBtn, SIGNAL( toggled( bool ) ), aGeodesicLabel, SLOT( setVisible ( bool ) ) );
+ connect( aManualGeodesicBtn, SIGNAL( toggled( bool ) ), aLambertLabel, SLOT( setHidden ( bool ) ) );
+ connect( aManualGeodesicBtn, SIGNAL( toggled( bool ) ), aRefImageLabel, SLOT( setHidden ( bool ) ) );
+ connect( aManualGeodesicBtn, SIGNAL( toggled( bool ) ), aFromFileInputGroup, SLOT( setHidden ( bool ) ) );
+ connect( aRefImageBtn, SIGNAL( toggled( bool ) ), aRefImageLabel, SLOT( setVisible ( bool ) ) );
+ connect( aRefImageBtn, SIGNAL( toggled( bool ) ), aGeodesicLabel, SLOT( setHidden ( bool ) ) );
+ connect( aRefImageBtn, SIGNAL( toggled( bool ) ), aLambertLabel, SLOT( setHidden ( bool ) ) );
+ connect( aRefImageBtn, SIGNAL( toggled( bool ) ), aFromFileInputGroup, SLOT( setHidden ( bool ) ) );
+ connect( aCartesianFromFileBtn, SIGNAL( toggled( bool ) ), aFromFileInputGroup, SLOT( setVisible ( bool ) ) );
+ connect( aCartesianFromFileBtn, SIGNAL( toggled( bool ) ), aManualInputGroup, SLOT( setHidden ( bool ) ) );
+
+ // Input widgets
+ aTransformLayout->addWidget( aManualInputGroup );
+ aTransformLayout->addWidget( aFromFileInputGroup );
// Common
addWidget( myFileNameGroup );
addWidget( myTransformGroup );
addStretch();
- connect( aBrowseBtn, SIGNAL( clicked() ), this, SLOT( onBrowse() ) );
+ connect( myBrowseBtn, SIGNAL( clicked() ), this, SLOT( onBrowse() ) );
connect( myModeGroup, SIGNAL( buttonClicked( int ) ),
this, SLOT( onModeActivated( int ) ) );
+ connect( aGeoBrowseBtn, SIGNAL( clicked() ), this, SLOT( onGeoBrowse() ) );
+
connect( myRefImage, SIGNAL( activated( const QString& ) ),
this, SLOT( onRefImageActivated( const QString& ) ) );
- setTransformationMode( ManualLambert );
+ //setTransformationMode( HYDROData_Image::ManualCartesian );
setMinimumWidth( 350 );
}
{
}
+void HYDROGUI_ImportImageDlg::onSetCIsUsed( bool theCIsUsed )
+{
+ if ( !theCIsUsed && myPointBtnMap[ HYDROGUI_PrsImage::PointC ]->isChecked() )
+ {
+ // Turn on point A selection if point C selection has been activated and we disable point C.
+ myPointBtnMap[ HYDROGUI_PrsImage::PointA ]->toggle();
+ }
+ emit setCIsUsed( theCIsUsed );
+}
+
void HYDROGUI_ImportImageDlg::setIsEdit( const bool theIsEdit )
{
myFileNameGroup->setVisible( !theIsEdit );
myFileName->clear();
myImageName->clear();
myImageNameGroup->setEnabled( false );
+ myGeoFileName->clear();
+ bool isPBlocked = blockSignalsPoints( true );
+ bool isGBlocked = blockSignalsGeodesic( true );
+ bool isCBlocked = blockSignalsCartesian( true );
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
{
aBtn->setChecked( false );
aBtn->blockSignals( anIsBlocked );
- myPointXMap[ aPointType ]->clear();
- myPointYMap[ aPointType ]->clear();
- myPointXDegMap[ aPointType ]->clear();
- myPointYDegMap[ aPointType ]->clear();
- myPointXMinMap[ aPointType ]->clear();
- myPointYMinMap[ aPointType ]->clear();
- myPointXSecMap[ aPointType ]->clear();
- myPointYSecMap[ aPointType ]->clear();
+ clearSpins( myPointXMap[ aPointType ] );
+ clearSpins( myPointYMap[ aPointType ] );
+ clearSpins( myPointXDegMap[ aPointType ] );
+ clearSpins( myPointYDegMap[ aPointType ] );
+ clearSpins( myPointXMinMap[ aPointType ] );
+ clearSpins( myPointYMinMap[ aPointType ] );
+ clearSpins( myPointXSecMap[ aPointType ] );
+ clearSpins( myPointYSecMap[ aPointType ] );
- myRefPointXMap[ aPointType ]->clear();
- myRefPointYMap[ aPointType ]->clear();
+ clearSpins( myRefPointXMap[ aPointType ] );
+ clearSpins( myRefPointYMap[ aPointType ] );
- myCartPointXMap[ aPointType ]->clear();
- myCartPointYMap[ aPointType ]->clear();
+ clearSpins( myCartPointXMap[ aPointType ] );
+ clearSpins( myCartPointYMap[ aPointType ] );
}
+ blockSignalsPoints( isPBlocked );
+ blockSignalsGeodesic( isGBlocked );
+ blockSignalsCartesian( isCBlocked );
+
+ // Emulate turning off C point usage
+ myPointCEnabler->blockSignals( true );
+
+ myPointCEnabler->setChecked( false );
+ myPointBtnMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointXMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointYMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointXDegMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointYDegMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointXMinMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointYMinMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointXSecMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myPointYSecMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myCartPointXMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myCartPointYMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myRefPointXMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ myRefPointYMap[ HYDROGUI_PrsImage::PointC ]->setEnabled( false );
+ onSetCIsUsed( false );
+
+ myPointCEnabler->blockSignals( false );
+
myTransformGroup->setEnabled( false );
myRefImage->clear();
- setTransformationMode( ManualCartesian );
+ setTransformationMode( HYDROData_Image::ManualCartesian );
myPrsPointDataList.clear();
return myImageName->text();
}
+void HYDROGUI_ImportImageDlg::setRefImageName( const QString& theName )
+{
+ myRefImage->setCurrentIndex( myRefImage->findText( theName ) );
+}
+
+QString HYDROGUI_ImportImageDlg::getRefImageName() const
+{
+ return myRefImage->currentText();
+}
+
QString HYDROGUI_ImportImageDlg::getFileName() const
{
return myFileName->text();
}
+void HYDROGUI_ImportImageDlg::setFileName( const QString& theName )
+{
+ myFileName->setText( theName );
+ myImageNameGroup->setEnabled( true );
+ myTransformGroup->setEnabled( true );
+}
+
+QString HYDROGUI_ImportImageDlg::getGeoreferencementFileName() const
+{
+ return myGeoFileName->text();
+}
+
void HYDROGUI_ImportImageDlg::setImageSize( const QSize& theSize,
const bool theIsRefImage )
{
return myModeGroup->checkedId();
}
+void HYDROGUI_ImportImageDlg::setByTwoPoints( const bool theIsByTwoPoints )
+{
+ myPointCEnabler->setChecked( !theIsByTwoPoints );
+}
+
+bool HYDROGUI_ImportImageDlg::isByTwoPoints() const
+{
+ return !myPointCEnabler->isChecked();
+}
+
void HYDROGUI_ImportImageDlg::setTransformationDataMap( const TransformationDataMap& theMap,
const bool theIsOnlyInput,
const bool theIsRefImage )
{
- blockSignalsLambert( true );
+ blockSignalsGeodesic( true );
blockSignalsCartesian( true );
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
if( !theIsOnlyInput && !theIsRefImage )
{
- QPointF aLPoint = aData.LambertPoint;
+ QPointF aLPoint = aData.GeodesicPoint;
int aXDeg = 0, aYDeg = 0;
int aXMin = 0, aYMin = 0;
double aXSec = 0, aYSec = 0;
- HYDROData_Lambert93::secToDMS( aLPoint.x(), aXDeg, aXMin, aXSec );
- HYDROData_Lambert93::secToDMS( aLPoint.y(), aYDeg, aYMin, aYSec );
+ HYDROData_Lambert93::degToDMS( aLPoint.x(), aXDeg, aXMin, aXSec );
+ HYDROData_Lambert93::degToDMS( aLPoint.y(), aYDeg, aYMin, aYSec );
myPointXDegMap[ aPointType ]->setValue( aXDeg );
myPointYDegMap[ aPointType ]->setValue( aYDeg );
}
}
}
- blockSignalsLambert( false );
+ blockSignalsGeodesic( false );
blockSignalsCartesian( false );
}
return false;
double aX2 = 0, aY2 = 0;
- HYDROData_Lambert93::DMSToSec( aXDeg, aXMin, aXSec, aX2 );
- HYDROData_Lambert93::DMSToSec( aYDeg, aYMin, aYSec, aY2 );
+ HYDROData_Lambert93::DMSToDeg( aXDeg, aXMin, aXSec, aX2 );
+ HYDROData_Lambert93::DMSToDeg( aYDeg, aYMin, aYSec, aY2 );
TransformationData aData( QPoint( aX1, aY1 ), QPointF( aX2, aY2 ), QPointF( aXCart, aYCart ) );
theMap[ aPointType ] = aData;
return true;
}
-QString HYDROGUI_ImportImageDlg::getRefImageName() const
-{
- return myRefImage->currentText();
-}
-
void HYDROGUI_ImportImageDlg::setPrsPointDataList( const PrsPointDataList& theList )
{
myPrsPointDataList = theList;
if( !myPrsPointDataList.isEmpty() )
{
- myModeGroup->button( RefImage )->setEnabled( true );
+ myModeGroup->button( HYDROData_Image::ReferenceImage )->setEnabled( true );
myRefImage->clear();
myRefImage->addItem( "" ); // first empty item
myRefImage->addItem( anIter.next().first );
}
else
- myModeGroup->button( RefImage )->setEnabled( false );
+ myModeGroup->button( HYDROData_Image::ReferenceImage )->setEnabled( false );
}
void HYDROGUI_ImportImageDlg::initializePointSelection()
myPointBtnMap[ HYDROGUI_PrsImage::PointA ]->setChecked( true );
- // ouv: tmp
- /*
- blockSignalsLambert( true );
-
- myPointXDegMap[ HYDROGUI_PrsImage::PointA ]->setValue( 50 );
- myPointXMinMap[ HYDROGUI_PrsImage::PointA ]->setValue( 0 );
- myPointXSecMap[ HYDROGUI_PrsImage::PointA ]->setValue( 0 );
- myPointYDegMap[ HYDROGUI_PrsImage::PointA ]->setValue( 50 );
- myPointYMinMap[ HYDROGUI_PrsImage::PointA ]->setValue( 0 );
- myPointYSecMap[ HYDROGUI_PrsImage::PointA ]->setValue( 0 );
-
- myPointXDegMap[ HYDROGUI_PrsImage::PointB ]->setValue( 50 );
- myPointXMinMap[ HYDROGUI_PrsImage::PointB ]->setValue( 1 );
- myPointXSecMap[ HYDROGUI_PrsImage::PointB ]->setValue( 0 );
- myPointYDegMap[ HYDROGUI_PrsImage::PointB ]->setValue( 50 );
- myPointYMinMap[ HYDROGUI_PrsImage::PointB ]->setValue( 0 );
- myPointYSecMap[ HYDROGUI_PrsImage::PointB ]->setValue( 0 );
-
- myPointXDegMap[ HYDROGUI_PrsImage::PointC ]->setValue( 50 );
- myPointXMinMap[ HYDROGUI_PrsImage::PointC ]->setValue( 0 );
- myPointXSecMap[ HYDROGUI_PrsImage::PointC ]->setValue( 0 );
- myPointYDegMap[ HYDROGUI_PrsImage::PointC ]->setValue( 50 );
- myPointYMinMap[ HYDROGUI_PrsImage::PointC ]->setValue( 1 );
- myPointYSecMap[ HYDROGUI_PrsImage::PointC ]->setValue( 0 );
-
- for( int aPointType = HYDROGUI_PrsImage::PointA;
- aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
- onLambertCoordChanged( aPointType );
-
- blockSignalsLambert( false );
- */
-
- //double aCartX0 = 600000;
- //double aCartY0 = 6800000;
- double aCartX0 = 0;
- double aCartY0 = 0;
+ double aCartX0 = LAMBERT_X0;
+ double aCartY0 = LAMBERT_Y0;
blockSignalsCartesian( true );
myCartPointXMap[ HYDROGUI_PrsImage::PointA ]->setValue( aCartX0 );
- myCartPointYMap[ HYDROGUI_PrsImage::PointA ]->setValue( aCartY0 );
+ myCartPointYMap[ HYDROGUI_PrsImage::PointA ]->setValue( aCartY0 + IMG_DELTA );
- myCartPointXMap[ HYDROGUI_PrsImage::PointB ]->setValue( aCartX0 + 500 );
- myCartPointYMap[ HYDROGUI_PrsImage::PointB ]->setValue( aCartY0 );
+ myCartPointXMap[ HYDROGUI_PrsImage::PointB ]->setValue( aCartX0 + IMG_DELTA );
+ myCartPointYMap[ HYDROGUI_PrsImage::PointB ]->setValue( aCartY0 + IMG_DELTA );
myCartPointXMap[ HYDROGUI_PrsImage::PointC ]->setValue( aCartX0 );
- myCartPointYMap[ HYDROGUI_PrsImage::PointC ]->setValue( aCartY0 + 500 );
+ myCartPointYMap[ HYDROGUI_PrsImage::PointC ]->setValue( aCartY0 );
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
blockSignalsCartesian( false );
}
+HYDROGUI_ImportImageDlg::TransformationData HYDROGUI_ImportImageDlg::ComputeTrsfData(
+ const int theMode,
+ const QPoint& theLocalPoint,
+ const QPointF& theGlobalPoint )
+{
+ TransformationData aResTrsfData;
+ aResTrsfData.ImagePoint = theLocalPoint;
+
+ double arx = theGlobalPoint.x();
+ double ary = theGlobalPoint.y();
+ if ( theMode == HYDROData_Image::ManualGeodesic )
+ {
+ // Geodesic to Cartesian
+ double aXCart = 0, aYCart = 0;
+ // Interpreting arY as attitude and arX as longitude
+ HYDROData_Lambert93::toXY( ary, arx, aXCart, aYCart );
+
+ aResTrsfData.GeodesicPoint = theGlobalPoint;
+ aResTrsfData.CartesianPoint = QPointF( aXCart, aYCart );
+ }
+ else if ( theMode == HYDROData_Image::ManualCartesian )
+ {
+ // Cartesian to Geodesic
+ double aLonDeg = 0, aLatDeg = 0;
+ HYDROData_Lambert93::toGeo( arx, ary, aLatDeg, aLonDeg );
+
+ aResTrsfData.CartesianPoint = theGlobalPoint;
+ aResTrsfData.GeodesicPoint = QPointF( aLonDeg, aLatDeg );
+ }
+
+ return aResTrsfData;
+}
+
void HYDROGUI_ImportImageDlg::onBrowse()
{
QString aFilter( tr( "IMAGE_FILTER" ) );
- QString aFileName = SUIT_FileDlg::getFileName( this, "", aFilter, tr( "IMPORT_IMAGE_FROM_FILE" ), true );
- if( !aFileName.isEmpty() )
+ QStringList aFileNamesList = SUIT_FileDlg::getOpenFileNames( this, "", aFilter, tr( "IMPORT_IMAGE_FROM_FILE" ), true );
+ emit filesSelected( aFileNamesList );
+}
+
+void HYDROGUI_ImportImageDlg::ActivateFile( const QString& theFileName, bool isEnableFilesChoice )
+{
+ myFileName->setEnabled( isEnableFilesChoice );
+ myBrowseBtn->setEnabled( isEnableFilesChoice );
+
+ if( !theFileName.isEmpty() )
{
- QImage anImage( aFileName );
- if( !anImage.isNull() )
+ QImage anImage( theFileName );
+ if( anImage.isNull() )
+ {
+ QString aTitle = QObject::tr( "INPUT_VALID_DATA" );
+ QString aMessage = QObject::tr( "FILE_CAN_NOT_BE_IMPORTED" ).
+ arg( theFileName ).arg( QFileInfo( theFileName ).suffix() );
+ SUIT_MessageBox::warning( module()->getApp()->desktop(), aTitle, aMessage );
+ }
+ else
{
- myFileName->setText( aFileName );
+ setFileName( theFileName );
+ setImageName( "" );
emit createPreview( anImage );
- myImageNameGroup->setEnabled( true );
- myTransformGroup->setEnabled( true );
}
}
}
+void HYDROGUI_ImportImageDlg::onGeoBrowse()
+{
+ QString aFilter( tr( "IMAGE_GEOREFERENCEMENT_FILTER" ) );
+ QString aGeoFileName = SUIT_FileDlg::getFileName( this, "", aFilter, tr( "IMPORT_GEO_DATA_FROM_FILE" ), true );
+ if( !aGeoFileName.isEmpty() ) {
+ myGeoFileName->setText( aGeoFileName );
+ }
+}
+
void HYDROGUI_ImportImageDlg::onModeActivated( int theMode )
{
- bool anIsManualLambert = theMode == ManualLambert;
- bool anIsManualCartesian = theMode == ManualCartesian;
- bool anIsRefImage = theMode == RefImage;
+ bool anIsManualGeodesic = theMode == HYDROData_Image::ManualGeodesic;
+ bool anIsManualCartesian = theMode == HYDROData_Image::ManualCartesian;
+ bool anIsRefImage = theMode == HYDROData_Image::ReferenceImage;
myRefImage->setEnabled( anIsRefImage );
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
{
- myPointXDegMap[ aPointType ]->setVisible( anIsManualLambert );
- myPointYDegMap[ aPointType ]->setVisible( anIsManualLambert );
- myPointXMinMap[ aPointType ]->setVisible( anIsManualLambert );
- myPointYMinMap[ aPointType ]->setVisible( anIsManualLambert );
- myPointXSecMap[ aPointType ]->setVisible( anIsManualLambert );
- myPointYSecMap[ aPointType ]->setVisible( anIsManualLambert );
+ myPointXDegMap[ aPointType ]->setVisible( anIsManualGeodesic );
+ myPointYDegMap[ aPointType ]->setVisible( anIsManualGeodesic );
+ myPointXMinMap[ aPointType ]->setVisible( anIsManualGeodesic );
+ myPointYMinMap[ aPointType ]->setVisible( anIsManualGeodesic );
+ myPointXSecMap[ aPointType ]->setVisible( anIsManualGeodesic );
+ myPointYSecMap[ aPointType ]->setVisible( anIsManualGeodesic );
myCartPointXMap[ aPointType ]->setVisible( anIsManualCartesian );
myCartPointYMap[ aPointType ]->setVisible( anIsManualCartesian );
myRefPointYMap[ aPointType ]->setVisible( anIsRefImage );
}
- QListIterator<QLabel*> anIter( myLambertLabels );
+ QListIterator<QLabel*> anIter( myGeodesicLabels );
while( anIter.hasNext() )
- anIter.next()->setVisible( anIsManualLambert );
+ anIter.next()->setVisible( anIsManualGeodesic );
emit modeActivated( theMode );
}
}
}
-void HYDROGUI_ImportImageDlg::onLambertCoordChanged()
+void HYDROGUI_ImportImageDlg::onGeodesicCoordChanged()
{
QObject* aSender = sender();
if( !aSender )
aSender == myPointXSecMap[ aPointType ] ||
aSender == myPointYSecMap[ aPointType ] )
{
- onLambertCoordChanged( aPointType );
+ onGeodesicCoordChanged( aPointType );
return;
}
}
}
-void HYDROGUI_ImportImageDlg::onLambertCoordChanged( const int thePointType )
+void HYDROGUI_ImportImageDlg::onGeodesicCoordChanged( const int thePointType )
{
bool anIsOk[6];
for( int i = 0; i < 6; i++ )
HYDROData_Lambert93::degToDMS( aLonDeg, aXDeg, aXMin, aXSec );
HYDROData_Lambert93::degToDMS( aLatDeg, aYDeg, aYMin, aYSec );
- blockSignalsLambert( true );
+ blockSignalsGeodesic( true );
myPointXDegMap[ thePointType ]->setValue( aXDeg );
myPointYDegMap[ thePointType ]->setValue( aYDeg );
myPointXSecMap[ thePointType ]->setValue( aXSec );
myPointYSecMap[ thePointType ]->setValue( aYSec );
- blockSignalsLambert( false );
+ blockSignalsGeodesic( false );
+}
+
+void HYDROGUI_ImportImageDlg::clearSpins( QAbstractSpinBox* theSpin )
+{
+ if ( dynamic_cast<QtxIntSpinBox*>( theSpin ) )
+ {
+ QtxIntSpinBox* aSpin = dynamic_cast<QtxIntSpinBox*>( theSpin );
+ aSpin->setValue( aSpin->minimum() );
+ }
+ else if ( dynamic_cast<QtxIntSpinBox*>( theSpin ) )
+ {
+ QtxDoubleSpinBox* aDblSpin = dynamic_cast<QtxDoubleSpinBox*>( theSpin );
+ aDblSpin->setValue( aDblSpin->minimum() );
+ }
+
+ theSpin->clear();
+}
+
+bool HYDROGUI_ImportImageDlg::blockSignalsPoints( const bool theState )
+{
+ bool isBlocked = false;
+ for( int aPointType = HYDROGUI_PrsImage::PointA;
+ aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
+ {
+ isBlocked =
+ myPointXMap[ aPointType ]->blockSignals( theState ) || isBlocked;
+ myPointYMap[ aPointType ]->blockSignals( theState );
+
+ myRefPointXMap[ aPointType ]->blockSignals( theState );
+ myRefPointYMap[ aPointType ]->blockSignals( theState );
+ }
+ return isBlocked;
}
-void HYDROGUI_ImportImageDlg::blockSignalsLambert( const bool theState )
+bool HYDROGUI_ImportImageDlg::blockSignalsGeodesic( const bool theState )
{
+ bool isBlocked = false;
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
{
- myPointXDegMap[ aPointType ]->blockSignals( theState );
+ isBlocked =
+ myPointXDegMap[ aPointType ]->blockSignals( theState ) || isBlocked;
myPointXMinMap[ aPointType ]->blockSignals( theState );
myPointXSecMap[ aPointType ]->blockSignals( theState );
myPointYDegMap[ aPointType ]->blockSignals( theState );
myPointYMinMap[ aPointType ]->blockSignals( theState );
myPointYSecMap[ aPointType ]->blockSignals( theState );
}
+ return isBlocked;
}
-void HYDROGUI_ImportImageDlg::blockSignalsCartesian( const bool theState )
+bool HYDROGUI_ImportImageDlg::blockSignalsCartesian( const bool theState )
{
+ bool isBlocked = false;
for( int aPointType = HYDROGUI_PrsImage::PointA;
aPointType <= HYDROGUI_PrsImage::PointC; aPointType++ )
{
- myCartPointXMap[ aPointType ]->blockSignals( theState );
+ isBlocked =
+ myCartPointXMap[ aPointType ]->blockSignals( theState ) || isBlocked;
myCartPointYMap[ aPointType ]->blockSignals( theState );
}
+ return isBlocked;
}