C++ Modified函数代码示例

void rtEPDataObject::maxSliceChanged(int val) {

  if (val == m_optionsWidget.maxSliceSlider->minimum()) {
    m_optionsWidget.maxSliceSlider->setValue(val+1);
    return;
  }

  m_optionsWidget.maxSliceLabel->setText(QString::number(val));
  if (m_optionsWidget.minSliceSlider->value() >= val)
    m_optionsWidget.minSliceSlider->setValue(val-1);

  setModifyFlagForAll();
  Modified();
}

void mitk::VtkPropRenderer::InitSize(int w, int h)
{
  m_RenderWindow->SetSize(w,h);
  Superclass::InitSize(w, h);
  Modified();
  Update();
  if(m_VtkRenderer!=NULL)
  {
    int w=vtkObject::GetGlobalWarningDisplay();
    vtkObject::GlobalWarningDisplayOff();
    m_VtkRenderer->ResetCamera();
    vtkObject::SetGlobalWarningDisplay(w);
  }
}

bool LayerSurface::LoadVectorFromFile( )
{
  if ( m_sVectorFilename.size() == 0 || !m_surfaceSource->MRISReadVectors( m_sVectorFilename ) )
  {
    return false;
  }

  UpdateVectorActor2D();
  emit Modified();
  emit SurfaceVectorLoaded();
  emit ActorUpdated();

  return true;
}

bool rtEPDataObject::setTransform(vtkTransform* t) {
  if (!t) {
    rtApplication::instance().getMessageHandle()->error(__LINE__, __FILE__, QString("The new transform t is NULL."));
    return false;
  }
  if (!m_objTransform) {
    rtApplication::instance().getMessageHandle()->error(__LINE__, __FILE__, QString("The object transform m_objTransform is NULL."));
    return false;
  }

  m_objTransform->DeepCopy(t);
  Modified();
  return true;
}

void mitk::PlanesPerpendicularToLinesFilter::SetPlane(const mitk::PlaneGeometry* aPlane)
{
  if(aPlane!=NULL)
  {
    m_Plane = static_cast<mitk::PlaneGeometry*>(aPlane->Clone().GetPointer());
  }
  else
  {
    if(m_Plane.IsNull())
      return;
    m_Plane=NULL;
  }
  Modified();
}

void cStructLoader::DelItem(cStructItem *d, bool keep)
{
  if(d) {
    d->Delete();
    if(keep) {
      cStructItem *n=new cCommentItem;
      n->SetComment(cString::sprintf(";%s%s",*d->ToString(false),d->Comment()?d->Comment():""));
      ListLock(true);
      Add(n,d);
      ListUnlock();
      }
    Modified();
    }
}

void mitk::BaseData::ConnectSource(itk::ProcessObject *arg, unsigned int idx) const
{
#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
  itkDebugMacro( "connecting source  " << arg
    << ", source output index " << idx);

  if ( GetSource().GetPointer() != arg || m_SourceOutputIndexDuplicate != idx)
  {
    m_SmartSourcePointer = dynamic_cast<mitk::BaseProcess*>(arg);
    m_SourceOutputIndexDuplicate = idx;
    Modified();
  }
#endif
}

//________________________________________________________________
void KVCanvas::DynamicZoom(Int_t Sign, Int_t px, Int_t py)
{
   // Zoom in or out of histogram with mouse wheel

   //    Info("DynamicZoom","px=%d py=%d",px,py);

   if (!fSelected) return;
   TH2* TheHisto = (TH2*) FindHisto();//fSelected;

   Double_t percent = 0.15 - Sign * 0.05;

   Int_t dX = 0;
   Int_t dY = 0;

   Double_t ppx = AbsPixeltoX(px);
   Double_t ppy = AbsPixeltoY(py);

   TAxis* ax = TheHisto->GetXaxis();
   Int_t NbinsXtmp = ax->GetNbins();
   Int_t X0tmp = ax->GetFirst();
   Int_t X1tmp = ax->GetLast();
   Int_t step = TMath::Min(TMath::Max(1, (Int_t)(percent * (X1tmp - X0tmp))), NbinsXtmp / 2);
   step *= Sign;
   X0tmp = TMath::Min(TMath::Max(X0tmp + step, 1), X1tmp - step);
   X1tmp = TMath::Max(TMath::Min(X1tmp - step, NbinsXtmp), X0tmp);
   if (X0tmp >= X1tmp) X0tmp = X1tmp - 1;
   if (Sign > 0) dX = (Int_t)(X0tmp + (X1tmp - X0tmp) * 0.5 - ax->FindBin(ppx));
   if ((X0tmp - dX) < 0) ax->SetRange(0, X1tmp - X0tmp);
   else if ((X1tmp - dX) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (X1tmp - X0tmp), ax->GetNbins());
   else ax->SetRange(X0tmp - dX, X1tmp - dX);

   ax = TheHisto->GetYaxis();
   Int_t NbinsYtmp = ax->GetNbins();
   Int_t Y0tmp = ax->GetFirst();
   Int_t Y1tmp = ax->GetLast();
   step = TMath::Min(TMath::Max(1, (Int_t)(percent * (Y1tmp - Y0tmp))), NbinsYtmp / 2);
   step *= Sign;
   Y0tmp = TMath::Min(TMath::Max(Y0tmp + step, 1), Y1tmp - step);
   Y1tmp = TMath::Max(TMath::Min(Y1tmp - step, NbinsYtmp), Y0tmp);
   if (Y0tmp >= Y1tmp) Y0tmp = Y1tmp - 1;
   if (Sign > 0) dY = (Int_t)(Y0tmp + (Y1tmp - Y0tmp) * 0.5 - ax->FindBin(ppy));
   if ((Y0tmp - dY) < 0) ax->SetRange(0, Y1tmp - Y0tmp);
   else if ((Y1tmp - dY) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (Y1tmp - Y0tmp), ax->GetNbins());
   else ax->SetRange(Y0tmp - dY, Y1tmp - dY);

   Modified();
   Update();
   return;
}

void rtEPDataObject::triggerChanged(int trig) {
  QList<int> k = m_phaseDataList.keys();
  QList<PhaseData> v = m_phaseDataList.values();

  int dist = abs(trig-v[0].triggerDelay);
  int phase = k[0];
  for (int ix1=1; ix1<v.size(); ix1++) {
    if (abs(trig-v[ix1].triggerDelay) < dist) {
      dist = abs(trig-v[ix1].triggerDelay);
      phase = k[ix1];
    }
  }
  setCurrPhase(phase);
  Modified();
}

void
DataFieldEnum::Dec()
{
    if (entries.empty()) {
        assert(value == 0);
        return;
    }

    assert(value < entries.size());

    if (value > 0) {
        value--;
        Modified();
    }
}

/**
 * Consider the list as changed when any of the properties has changed recently.
 */
unsigned long mitk::PropertyList::GetMTime() const
{
  for (auto it = m_Properties.cbegin(); it != m_Properties.cend(); ++it)
  {
    if (it->second.IsNull())
    {
      itkWarningMacro(<< "Property '" << it->first << "' contains nothing (nullptr).");
      continue;
    }
    if (Superclass::GetMTime() < it->second->GetMTime())
    {
      Modified();
      break;
    }
  }

void rtCathDataObject::colorChanged(int index)
{
    if (m_cathGuiSetup.colorBox->currentText() == "None")
        m_currColor = NULL;
    else
    {
        int id = m_colorIDs.value(index);
        rtRenderObject *rObj = rtApplication::instance().getObjectManager()->getObjectWithID(id);
        if (!rObj) return;
        m_currColor = static_cast<rtColorFuncDataObject*>(rObj->getDataObject());
        connect(m_currColor, SIGNAL(objectChanged(int)), this, SLOT(Modified()));
    }
    Modified();

}

void mitk::BaseGeometry::SetIndexToWorldTransform(mitk::AffineTransform3D* transform)
{
  mitk::ModifiedLock lock(this);

  PreSetIndexToWorldTransform(transform);

  m_IndexToWorldTransform = transform;
  CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing);
  vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
  TransferItkToVtkTransform();
  Modified();

  PostSetIndexToWorldTransform(transform);

}

void KVCanvas::ProfileY(TH2* hh)
{
   TObject* obj = 0;
   if ((obj = gROOT->FindObject(Form("%s_pfy", hh->GetName())))) obj->Delete();
   TProfile* pfy = hh->ProfileY("_pfy", 1, -1, "i");
   TGraphErrors* gr = gHistoManipulator->MakeGraphFrom(pfy);
   pfy->Delete();
   TGraph* gg = gHistoManipulator->PermuteAxis(gr);
   gr->Delete();
   gg->SetName(Form("%s_pfy", hh->GetName()));
   gg->SetLineColor(kBlack);
   gg->Draw("PEZ");
   Modified();
   Update();
}

void cStructLoader::Save(void)
{
  if(CheckDoSave()) {
    cSafeFile f(path);
    if(f.Open()) {
      ListLock(false);
      for(cStructItem *it=First(); it; it=Next(it))
        if(!it->Deleted() && !it->Save(f)) break;
      f.Close();
      mtime=MTime(true);
      Modified(false);
      ListUnlock();
      PRINTF(L_CORE_LOAD,"saved %s to %s",type,path);
      }
    }
}