void
WellBoreAttributes::SetWellLineWidth(int wellLineWidth_)
{
wellLineWidth = wellLineWidth_;
Select(ID_wellLineWidth, (void *)&wellLineWidth);
}
void
HistogramAttributes::SetDomain(int domain_)
{
domain = domain_;
Select(ID_domain, (void *)&domain);
}
void
HistogramAttributes::SetUseBinWidths(bool useBinWidths_)
{
useBinWidths = useBinWidths_;
Select(ID_useBinWidths, (void *)&useBinWidths);
}
/* initialize()
* ====================================================================
*/
int
initialize( void )
{
int berror;
int flag;
flag = TRUE;
/* Get the Boot Drive and Muck the paths */
Drive = GetBaseDrive();
OnPath[0] = OffPath[0] = Drive;
NPOnPath[0] = NPOffPath[0] = Drive;
olddma = Fgetdta();
Fsetdta( &newdma ); /* Point to OUR buffer */
berror = Fsfirst( OnPath, 0 );
if( berror == E_OK ) /* Found it! */
{
/* MINT IS ON! with Memory Protection */
Select( SETON );
Deselect( SETOFF );
Select( NPON );
Deselect( NPOFF );
bstate = TRUE;
cstate = TRUE;
}
else
{
/* Check for No Memory Protection */
berror = Fsfirst( NPOnPath, 0 );
if( berror == E_OK )
{
/* Found it! It is ON with No Memory Protection */
Select( NPOFF );
Deselect( NPON );
Select( SETON );
Deselect( SETOFF );
bstate = TRUE;
cstate = FALSE;
}
else
{
/* Check for Off items */
/* Mint is OFF, with memory protection */
berror = Fsfirst( OffPath, 0 );
if( berror == E_OK ) /* Found it! */
{
/* MInT.PRX is found! */
Select( SETOFF );
Deselect( SETON );
Select( NPON );
Deselect( NPOFF );
bstate = FALSE;
cstate = TRUE;
}
else
{
/* Mint is off with no memory protection */
berror = Fsfirst( NPOffPath, 0 );
if( berror == E_OK )
{
/* MintNP.prx is found */
Select( SETOFF );
Deselect( SETON );
Select( NPOFF );
Deselect( NPON );
bstate = FALSE;
cstate = FALSE;
}
else
{
/* Mint is not on the hard disk...*/
form_alert( 1, nomint );
flag = FALSE;
}
}
}
}
Fsetdta( olddma ); /* Point to OLD buffer */
return( flag );
}
void
HistogramAttributes::SetMax(double max_)
{
max = max_;
Select(ID_max, (void *)&max);
}
void
TensorAttributes::SelectTensorColor()
{
Select(ID_tensorColor, (void *)&tensorColor);
}
void wxVListBox::DoHandleItemClick(int item, int flags)
{
// has anything worth telling the client code about happened?
bool notify = false;
if ( HasMultipleSelection() )
{
// select the iteem clicked?
bool select = true;
// NB: the keyboard interface we implement here corresponds to
// wxLB_EXTENDED rather than wxLB_MULTIPLE but this one makes more
// sense IMHO
if ( flags & ItemClick_Shift )
{
if ( m_current != wxNOT_FOUND )
{
if ( m_anchor == wxNOT_FOUND )
m_anchor = m_current;
select = false;
// only the range from the selection anchor to new m_current
// must be selected
if ( DeselectAll() )
notify = true;
if ( SelectRange(m_anchor, item) )
notify = true;
}
//else: treat it as ordinary click/keypress
}
else // Shift not pressed
{
m_anchor = item;
if ( flags & ItemClick_Ctrl )
{
select = false;
if ( !(flags & ItemClick_Kbd) )
{
Toggle(item);
// the status of the item has definitely changed
notify = true;
}
//else: Ctrl-arrow pressed, don't change selection
}
//else: behave as in single selection case
}
if ( select )
{
// make the clicked item the only selection
if ( DeselectAll() )
notify = true;
if ( Select(item) )
notify = true;
}
}
// in any case the item should become the current one
if ( DoSetCurrent(item) )
{
if ( !HasMultipleSelection() )
{
// this has also changed the selection for single selection case
notify = true;
}
}
if ( notify )
{
// notify the user about the selection change
SendSelectedEvent();
}
//else: nothing changed at all
}
void
TensorAttributes::SetUseStride(bool useStride_)
{
useStride = useStride_;
Select(ID_useStride, (void *)&useStride);
}
void
TensorAttributes::SetStride(int stride_)
{
stride = stride_;
Select(ID_stride, (void *)&stride);
}
void
WellBoreAttributes::SetWellNameScale(float wellNameScale_)
{
wellNameScale = wellNameScale_;
Select(ID_wellNameScale, (void *)&wellNameScale);
}
void
TensorAttributes::SelectAll()
{
Select(ID_useStride, (void *)&useStride);
Select(ID_stride, (void *)&stride);
Select(ID_nTensors, (void *)&nTensors);
Select(ID_scale, (void *)&scale);
Select(ID_scaleByMagnitude, (void *)&scaleByMagnitude);
Select(ID_autoScale, (void *)&autoScale);
Select(ID_colorByEigenvalues, (void *)&colorByEigenvalues);
Select(ID_useLegend, (void *)&useLegend);
Select(ID_tensorColor, (void *)&tensorColor);
Select(ID_colorTableName, (void *)&colorTableName);
Select(ID_invertColorTable, (void *)&invertColorTable);
}
void
WellBoreAttributes::SetWellStemHeight(float wellStemHeight_)
{
wellStemHeight = wellStemHeight_;
Select(ID_wellStemHeight, (void *)&wellStemHeight);
}
void
WellBoreAttributes::SetWellAnnotation(WellBoreAttributes::WellAnnotation wellAnnotation_)
{
wellAnnotation = wellAnnotation_;
Select(ID_wellAnnotation, (void *)&wellAnnotation);
}
void
WellBoreAttributes::SetWellLineStyle(int wellLineStyle_)
{
wellLineStyle = wellLineStyle_;
Select(ID_wellLineStyle, (void *)&wellLineStyle);
}
void
TensorAttributes::SetColorTableName(const std::string &colorTableName_)
{
colorTableName = colorTableName_;
Select(ID_colorTableName, (void *)&colorTableName);
}
void
TensorAttributes::SetNTensors(int nTensors_)
{
nTensors = nTensors_;
Select(ID_nTensors, (void *)&nTensors);
}
void
TensorAttributes::SetInvertColorTable(bool invertColorTable_)
{
invertColorTable = invertColorTable_;
Select(ID_invertColorTable, (void *)&invertColorTable);
}
void
TensorAttributes::SetScale(double scale_)
{
scale = scale_;
Select(ID_scale, (void *)&scale);
}
void
TensorAttributes::SelectColorTableName()
{
Select(ID_colorTableName, (void *)&colorTableName);
}
void
TensorAttributes::SetScaleByMagnitude(bool scaleByMagnitude_)
{
scaleByMagnitude = scaleByMagnitude_;
Select(ID_scaleByMagnitude, (void *)&scaleByMagnitude);
}
void CPlayer::Update(float dt)
{
CCommander::Update(dt);
Select(dt);
Move(dt);
}
void
TensorAttributes::SetAutoScale(bool autoScale_)
{
autoScale = autoScale_;
Select(ID_autoScale, (void *)&autoScale);
}
void
HistogramAttributes::SetMin(double min_)
{
min = min_;
Select(ID_min, (void *)&min);
}
void
TensorAttributes::SetColorByEigenvalues(bool colorByEigenvalues_)
{
colorByEigenvalues = colorByEigenvalues_;
Select(ID_colorByEigenvalues, (void *)&colorByEigenvalues);
}
void
HistogramAttributes::SetNumBins(int numBins_)
{
numBins = numBins_;
Select(ID_numBins, (void *)&numBins);
}
void
TensorAttributes::SetUseLegend(bool useLegend_)
{
useLegend = useLegend_;
Select(ID_useLegend, (void *)&useLegend);
}
void
HistogramAttributes::SetZone(int zone_)
{
zone = zone_;
Select(ID_zone, (void *)&zone);
}
void
TensorAttributes::SetTensorColor(const ColorAttribute &tensorColor_)
{
tensorColor = tensorColor_;
Select(ID_tensorColor, (void *)&tensorColor);
}
void
HistogramAttributes::SetOutputType(HistogramAttributes::OutputType outputType_)
{
outputType = outputType_;
Select(ID_outputType, (void *)&outputType);
}
void
WellBoreAttributes::SetWellRadius(float wellRadius_)
{
wellRadius = wellRadius_;
Select(ID_wellRadius, (void *)&wellRadius);
}
