C++ (Cpp) CustomMimeType Examples

Example #1

File: mitkLegacyFileWriterService.cpp Project: Cdebus/MITK

mitk::LegacyFileWriterService::LegacyFileWriterService(mitk::FileWriter::Pointer legacyWriter,
                                                       const std::string &description)
  : AbstractFileWriter(legacyWriter->GetSupportedBaseData()), m_LegacyWriter(legacyWriter)
{
  this->SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".legacy.");
  this->SetDescription(description);

  CustomMimeType customMimeType;
  std::vector<std::string> extensions = legacyWriter->GetPossibleFileExtensions();
  for (auto ext = extensions.begin(); ext != extensions.end(); ++ext)
  {
    if (ext->empty())
      continue;

    std::string extension = *ext;
    if (extension.size() > 1 && extension[0] == '*')
    {
      // remove "*"
      extension = extension.substr(1);
    }
    if (extension.size() > 1 && extension[0] == '.')
    {
      // remove "."
      extension = extension.substr(1);
    }
    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
    customMimeType.AddExtension(extension);
  }
  this->SetMimeType(customMimeType);

  m_ServiceRegistration = RegisterService();
}

Example #2

File: mitkAbstractFileReader.cpp Project: riecker/MITK

AbstractFileReader::AbstractFileReader(const std::string& extension, const std::string& description)
  : d(new Impl)
{
  CustomMimeType customMimeType;
  customMimeType.AddExtension(extension);
  d->SetMimeType(customMimeType);
  d->SetDescription(description);
}

Example #3

File: mitkAbstractFileIO.cpp Project: Cdebus/MITK

 AbstractFileIO::AbstractFileIO(const std::string &baseDataType,
                                const CustomMimeType &mimeType,
                                const std::string &description)
   : AbstractFileIOReader(mimeType, description),
     AbstractFileIOWriter(baseDataType, CustomMimeType(mimeType.GetName()), description)
 {
 }

Example #4

File: mitkLegacyFileReaderService.cpp Project: 0r/MITK

mitk::LegacyFileReaderService::LegacyFileReaderService(const std::vector<std::string>& extensions,
                                                       const std::string& category)
  : AbstractFileReader()
{
  this->SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".legacy.");

  CustomMimeType customMimeType;
  customMimeType.SetCategory(category);

  for(auto extension : extensions)
  {

    if (!extension.empty() && extension[0] == '.')
    {
      extension.assign(extension.begin()+1, extension.end());
    }
    customMimeType.AddExtension(extension);
  }
  this->SetDescription(category);
  this->SetMimeType(customMimeType);

  m_ServiceReg = this->RegisterService();
}

Example #5

File: mitkAbstractFileIO.cpp Project: Cdebus/MITK

 void AbstractFileIO::SetMimeType(const CustomMimeType &mimeType)
 {
   this->AbstractFileReader::SetMimeType(mimeType);
   this->AbstractFileWriter::SetMimeType(CustomMimeType(mimeType.GetName()));
 }

Example #6

File: mitkItkImageIO.cpp Project: pollen-metrology/MITK

  ItkImageIO::ItkImageIO(itk::ImageIOBase::Pointer imageIO)
    : AbstractFileIO(Image::GetStaticNameOfClass()), m_ImageIO(imageIO)
  {
    if (m_ImageIO.IsNull())
    {
      mitkThrow() << "ITK ImageIOBase argument must not be NULL";
    }

    this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
    this->InitializeDefaultMetaDataKeys();

    std::vector<std::string> readExtensions = m_ImageIO->GetSupportedReadExtensions();

    if (readExtensions.empty())
    {
      std::string imageIOName = m_ImageIO->GetNameOfClass();
      MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide read extensions";
      readExtensions = FixUpImageIOExtensions(imageIOName);
    }

    CustomMimeType customReaderMimeType;
    customReaderMimeType.SetCategory("Images");
    for (std::vector<std::string>::const_iterator iter = readExtensions.begin(), endIter = readExtensions.end();
         iter != endIter;
         ++iter)
    {
      std::string extension = *iter;
      if (!extension.empty() && extension[0] == '.')
      {
        extension.assign(iter->begin() + 1, iter->end());
      }
      customReaderMimeType.AddExtension(extension);
    }
    this->AbstractFileReader::SetMimeType(customReaderMimeType);

    std::vector<std::string> writeExtensions = imageIO->GetSupportedWriteExtensions();
    if (writeExtensions.empty())
    {
      std::string imageIOName = imageIO->GetNameOfClass();
      MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide write extensions";
      writeExtensions = FixUpImageIOExtensions(imageIOName);
    }

    if (writeExtensions != readExtensions)
    {
      CustomMimeType customWriterMimeType;
      customWriterMimeType.SetCategory("Images");
      for (std::vector<std::string>::const_iterator iter = writeExtensions.begin(), endIter = writeExtensions.end();
           iter != endIter;
           ++iter)
      {
        std::string extension = *iter;
        if (!extension.empty() && extension[0] == '.')
        {
          extension.assign(iter->begin() + 1, iter->end());
        }
        customWriterMimeType.AddExtension(extension);
      }
      this->AbstractFileWriter::SetMimeType(customWriterMimeType);
    }

    std::string description = std::string("ITK ") + imageIO->GetNameOfClass();
    this->SetReaderDescription(description);
    this->SetWriterDescription(description);

    this->RegisterService();
  }

Example #7

File: mitkMimeType.cpp Project: danielknorr/MITK

 Impl(const CustomMimeType& x, int rank, long id)
   : m_CustomMimeType(x.Clone())
   , m_Rank(rank)
   , m_Id(id)
 {}

Example #8

File: mitkFileReaderWriterBase.cpp Project: danielknorr/MITK

void FileReaderWriterBase::SetMimeType(const CustomMimeType& mimeType)
{
  m_CustomMimeType.reset(mimeType.Clone());
}