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);
      }
    }
}

// TODO Parameter as Smartpointer
void mitk::LabelSet::AddLabel(mitk::Label *label)
{
  unsigned int max_size = mitk::Label::MAX_LABEL_VALUE + 1;
  if (m_LabelContainer.size() >= max_size)
    return;

  mitk::Label::Pointer newLabel(label->Clone());

  // TODO use layer of label parameter
  newLabel->SetLayer(m_Layer);

  PixelType pixelValue;
  if (m_LabelContainer.empty())
  {
    pixelValue = newLabel->GetValue();
  }
  else
  {
    pixelValue = m_LabelContainer.rbegin()->first;

    if (pixelValue >= newLabel->GetValue() && m_LabelContainer.find(newLabel->GetValue()) != m_LabelContainer.end())
    {
      ++pixelValue;
      newLabel->SetValue(pixelValue);
    }
    else
    {
      pixelValue = newLabel->GetValue();
    }
  }

  // new map entry
  m_LabelContainer[pixelValue] = newLabel;
  UpdateLookupTable(pixelValue);

  // add DICOM information of the label
  DICOMSegmentationPropertyHandler::SetDICOMSegmentProperties(newLabel);

  itk::SimpleMemberCommand<LabelSet>::Pointer command = itk::SimpleMemberCommand<LabelSet>::New();
  command->SetCallbackFunction(this, &LabelSet::OnLabelModified);
  newLabel->AddObserver(itk::ModifiedEvent(), command);
  // newLabel->AddObserver(itk::ModifiedEvent(),command);

  SetActiveLabel(newLabel->GetValue());
  AddLabelEvent.Send();
  Modified();
}

LPCSTR CSHGameMtlTools::AppendItem(LPCSTR folder_name, LPCSTR parent_name)
{
    LPCSTR M=0;
	SGameMtl* parent 	= FindItem(parent_name);
    if (!parent){
	    if (!TfrmChoseItem::SelectItem(smCustom,M,1,0,fastdelegate::bind<TOnChooseFillItems>(this,&CSHGameMtlTools::FillChooseMtlType))||!M) return 0;
    }
    AnsiString pref		= parent_name?AnsiString(parent_name):AnsiString(folder_name)+M;
    m_LastSelection		= FHelper.GenerateName(pref.c_str(),2,fastdelegate::bind<TFindObjectByName>(this,&CSHGameMtlTools::ItemExist),false,true);
    SGameMtl* S 		= GMLib.AppendMaterial(parent);
    S->m_Name			= m_LastSelection.c_str();
    if (!parent)		S->Flags.set (SGameMtl::flDynamic,0==strcmp(M,"Dynamic"));
    ExecCommand			(COMMAND_UPDATE_LIST);
    ExecCommand			(COMMAND_UPDATE_PROPERTIES);
	Modified			();
    return *S->m_Name;
}

bool CodeEditor::SaveFile()
{
	// Return if no change
	if (!Modified()) return true;

	// Get file name
	if (!mFileName)
	{
		wxFileDialog dlg (this, _T("Save file"), _T(""), _T(""), _T("Any file (*)|*"),
			wxSAVE | wxOVERWRITE_PROMPT);
		if (dlg.ShowModal() != wxID_OK) return false;
		mFileName = dlg.GetPath();
	}

	// Save file
	return SaveFile(mFileName);
}

void WrappingTextView::RedoChange() {
	if (m_curr_undo_index >= m_max_undo_index)
		return;
	UndoInfo info = m_undo_vect[m_curr_undo_index++];
	m_in_undo_redo = true;
	if (info.isInsertion) {
		BTextView::Insert( info.offset, info.text.String(), info.text.Length(), info.text_runs);
		Select( info.offset+info.text.Length(), info.offset+info.text.Length());
	} else {
		BTextView::Delete( info.offset, info.offset+info.text.Length());
		Select( info.offset, info.offset);
	}
	ScrollToSelection();
	m_in_undo_redo = false;
	if(!m_modified_disabled)
		Modified();
}

void mitk::PropertyList::ReplaceProperty(const std::string& propertyKey, BaseProperty* property)
{
  if (!property) return;

  PropertyMap::iterator it( m_Properties.find( propertyKey ) );

  // Is a property with key @a propertyKey contained in the list?
  if( it != m_Properties.end() )
  {
    it->second=NULL;
    m_Properties.erase(it);
  }

  //no? add/replace it.
  m_Properties.insert( PropertyMap::value_type(propertyKey, property) );
  Modified();
}