MimeType MimeTypeForData(const QByteArray &data) {
if (data.size() >= 12) {
if (!memcmp(data.constData(), "RIFF", 4) && !memcmp(data.constData() + 8, "WEBP", 4)) {
return MimeType(MimeType::Known::WebP);
}
}
return MimeType(QMimeDatabase().mimeTypeForData(data));
}
MimeType MimeTypeForName(const QString &mime) {
if (mime == qsl("image/webp")) {
return MimeType(MimeType::Known::WebP);
} else if (mime == qsl("application/x-tdesktop-theme")) {
return MimeType(MimeType::Known::TDesktopTheme);
} else if (mime == qsl("application/x-tdesktop-palette")) {
return MimeType(MimeType::Known::TDesktopPalette);
}
return MimeType(QMimeDatabase().mimeTypeForName(mime));
}
bool
Model::Mimeset(bool force)
{
BString oldType = MimeType();
BPath path;
GetPath(&path);
update_mime_info(path.Path(), 0, 1, force ? 2 : 0);
ModelNodeLazyOpener opener(this);
opener.OpenNode();
AttrChanged(NULL);
return !oldType.ICompare(MimeType());
}
// return ETrue if the attachment passed in is the same
TBool CAgnAttachment::CompareL(const CAgnAttachment& aSource) const
{
if (Type() != aSource.Type())
{
return EFalse;
}
if (MimeType() != aSource.MimeType())
{
return EFalse;
}
if (Content() != aSource.Content())
{
return EFalse;
}
if (iAttributes != aSource.iAttributes)
{
return EFalse;
}
if (Label() != aSource.Label())
{
return EFalse;
}
if (Size() != aSource.Size())
{
return EFalse;
}
// Only properties exposed to clients are compared, i.e. not UIDs.
return ETrue;
}
status_t ArpConfigureFile::WriteSettings(const BMessage* from) const
{
if( from == 0 ) return B_BAD_VALUE;
ArpD(cdb << ADH << "ArpConfigureFile: Writing settings with BMessage: "
<< *from << endl);
if( mFile == entry_ref() ) return B_NO_INIT;
status_t err;
// We seem to need to force any symbolic link to be resolved --
// otherwise, the BFile.Flatten() fails.
BEntry entry(&mFile, true);
BFile file(&entry, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
err = file.InitCheck();
ArpD(cdb << ADH << "Result from creating file: " << err << endl);
if( err ) return err;
if( (err=from->Flatten(&file)) ) return err;
ArpD(cdb << ADH << "Result from writing settings: " << err << endl);
if( mMimeType != "" ) {
ArpD(cdb << ADH << "Writing MIME type: " << MimeType() << endl);
BNodeInfo info(&file);
if( (err=info.InitCheck()) ) return err;
err = info.SetType(mMimeType.String());
ArpD(cdb << ADH << "Result from writing mime type: " << err << endl);
if( err ) return err;
}
return err;
}
MimeType FileReaderWriterBase::GetRegisteredMimeType() const
{
MimeType result;
if (!m_MimeTypeReg)
{
if (!m_CustomMimeType->GetName().empty())
{
CoreServicePointer<IMimeTypeProvider> mimeTypeProvider(
CoreServices::GetMimeTypeProvider(us::GetModuleContext()));
return mimeTypeProvider->GetMimeTypeForName(m_CustomMimeType->GetName());
}
return result;
}
us::ServiceReferenceU reference = m_MimeTypeReg.GetReference();
try
{
int rank = 0;
us::Any rankProp = reference.GetProperty(us::ServiceConstants::SERVICE_RANKING());
if (!rankProp.Empty())
{
rank = us::any_cast<int>(rankProp);
}
long id = us::any_cast<long>(reference.GetProperty(us::ServiceConstants::SERVICE_ID()));
result = MimeType(*m_CustomMimeType, rank, id);
}
catch (const us::BadAnyCastException& e)
{
MITK_WARN << "Unexpected exception: " << e.what();
}
return result;
}
MimeType MimeTypeProvider::GetMimeType(const ServiceReferenceType &reference) const
{
MimeType result;
if (!reference)
return result;
CustomMimeType *mimeType = us::GetModuleContext()->GetService(reference);
if (mimeType != nullptr)
{
try
{
int rank = 0;
us::Any rankProp = reference.GetProperty(us::ServiceConstants::SERVICE_RANKING());
if (!rankProp.Empty())
{
rank = us::any_cast<int>(rankProp);
}
auto id = us::any_cast<long>(reference.GetProperty(us::ServiceConstants::SERVICE_ID()));
result = MimeType(*mimeType, rank, id);
}
catch (const us::BadAnyCastException &e)
{
MITK_WARN << "Unexpected exception: " << e.what();
}
us::GetModuleContext()->UngetService(reference);
}
return result;
}
MimeType MimeTypeProvider::GetMimeTypeForName(const std::string &name) const
{
auto iter = m_NameToMimeType.find(name);
if (iter != m_NameToMimeType.end())
return iter->second;
return MimeType();
}
void CAgnAttachment::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteUint8L(Type());
aStream << MimeType();
aStream.WriteUint32L(iUid);
aStream.WriteUint16L(iAttributes);
aStream.WriteUint16L(iFlags);
aStream.WriteInt32L(iSize);
aStream << Label();
}
bool
Model::Mimeset(bool force)
{
BString oldType = MimeType();
ModelNodeLazyOpener opener(this);
BPath path;
GetPath(&path);
if (force) {
if (opener.OpenNode(true) != B_OK)
return false;
Node()->RemoveAttr(kAttrMIMEType);
update_mime_info(path.Path(), 0, 1, 1);
} else
update_mime_info(path.Path(), 0, 1, 0);
AttrChanged(0);
return !oldType.ICompare(MimeType());
}
MimeType MimeTypeForFile(const QFileInfo &file) {
QString path = file.absoluteFilePath();
if (path.endsWith(qstr(".webp"), Qt::CaseInsensitive)) {
return MimeType(MimeType::Known::WebP);
} else if (path.endsWith(qstr(".tdesktop-theme"), Qt::CaseInsensitive)) {
return MimeType(MimeType::Known::TDesktopTheme);
} else if (path.endsWith(qstr(".tdesktop-palette"), Qt::CaseInsensitive)) {
return MimeType(MimeType::Known::TDesktopPalette);
}
{
QFile f(path);
if (f.open(QIODevice::ReadOnly)) {
QByteArray magic = f.read(12);
if (magic.size() >= 12) {
if (!memcmp(magic.constData(), "RIFF", 4) && !memcmp(magic.constData() + 8, "WEBP", 4)) {
return MimeType(MimeType::Known::WebP);
}
}
f.close();
}
}
return MimeType(QMimeDatabase().mimeTypeForFile(file));
}
QStringList opie_imageExtensions() {
/*
* File extensions (e.g jpeg JPG jpg) are not
* parsed yet
*/
if ( !opie_image_extension_List ) {
opie_image_extension_List = new QStringList();
qAddPostRoutine( clean_opie_image_extension_List );
QStrList fileFormats = QImageIO::inputFormats();
QString ff = fileFormats.first();
while ( fileFormats.current() ) {
*opie_image_extension_List += MimeType("image/"+ff.lower()).extensions();
ff = fileFormats.next();
}
}
return *opie_image_extension_List; // QShared so it should be efficient
}
void PProjectWindow::SetText(const BString& docText)
{
fPrjFile = ProjectRoster->ParseProjectFile(EntryRef(), MimeType(), docText);
if (!fPrjFile || !fPrjFile->HaveProjectInfo())
return;
try
{
fList->MakeEmpty();
if (fPrjFile) {
list<CProjectItem*>::const_iterator iter;
for( iter = fPrjFile->begin(); iter != fPrjFile->end(); ++iter)
AddItemsToList( *iter, NULL);
}
fButtonBar->SetEnabled(msg_Save, false);
}
catch (HErr& e)
{
e.DoError();
}
} /* PProjectWindow::ReadData */
/*!
Returns the file associated with the AppLnk.
\sa exec() name()
*/
QString AppLnk::file() const
{
if ( mExec.isEmpty ( ) && mFile.isNull() ) {
AppLnk* that = (AppLnk*)this;
QString ext = MimeType(mType).extension();
if ( !ext.isEmpty() )
ext = "." + ext;
if ( !mLinkFile.isEmpty() ) {
that->mFile =
mLinkFile.right(8)==".desktop" // 8 = strlen(".desktop")
? mLinkFile.left(mLinkFile.length()-8) : mLinkFile;
qDebug("mFile now == %s", mFile.latin1());
} else if ( mType.contains('/') ) {
that->mFile =
QString(getenv("HOME"))+"/Documents/"+mType+"/"+safeFileName(that->mName);
/*
* A file with the same name or a .desktop file already exists
*/
if ( QFile::exists(that->mFile+ext) || QFile::exists(that->mFile+".desktop") ) {
int n=1;
QString nn;
while (QFile::exists((nn=(that->mFile+"_"+QString::number(n)))+ext)
|| QFile::exists(nn+".desktop"))
n++;
that->mFile = nn;
}
that->mLinkFile = that->mFile+".desktop";
that->mFile += ext;
}
prepareDirectories(that->mFile);
if ( !that->mFile.isEmpty() ) {
QFile f(that->mFile);
if ( !f.open(IO_WriteOnly) )
that->mFile = QString::null;
return that->mFile;
}
}
return mFile;
}
// -----------------------------------------------------------------------------
// CPhoneRingingTone::IsFileDrmProtected
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPhoneRingingTone::IsFileDrmProtected() const
{
const TDesC& type = MimeType();
if ( type == KAac || type == KMp3 || type == KMpeg ||
type == K3gpp || type == KMp4 || type == KAmrWb ||
type == KWavX || type == KWav || type == KV3gpp ||
type == KVMp4 || type == KV3gpp2 )
{
ContentAccess::CContent* content = NULL;
TRAPD( err, content = ContentAccess::CContent::NewL( *iFileName ) );
if ( err == KErrNone && content )
{
TInt drmProtected( 0 );
content->GetAttribute( ContentAccess::EIsProtected, drmProtected );
delete content;
return drmProtected;
}
}
return ETrue; // Other MIMEs can be played without DRM check.
}
void
Model::TrackIconSource(icon_size size)
{
PRINT(("tracking %s icon\n", size == B_LARGE_ICON ? "large" : "small"));
BRect rect;
if (size == B_MINI_ICON)
rect.Set(0, 0, B_MINI_ICON - 1, B_MINI_ICON - 1);
else
rect.Set(0, 0, B_LARGE_ICON - 1, B_LARGE_ICON - 1);
BBitmap bitmap(rect, B_CMAP8);
BModelOpener opener(this);
if (Node() == NULL) {
PRINT(("track icon error - no node\n"));
return;
}
if (IsSymLink()) {
PRINT(("tracking symlink icon\n"));
if (fLinkTo) {
fLinkTo->TrackIconSource(size);
return;
}
}
if (fBaseType == kVolumeNode) {
BVolume volume(NodeRef()->device);
status_t result = volume.GetIcon(&bitmap, size);
PRINT(("getting icon from volume %s\n", strerror(result)));
} else {
BNodeInfo nodeInfo(Node());
status_t err = nodeInfo.GetIcon(&bitmap, size);
if (err == B_OK) {
// file knew which icon to use, we are done
PRINT(("track icon - got icon from file\n"));
return;
}
char preferredApp[B_MIME_TYPE_LENGTH];
err = nodeInfo.GetPreferredApp(preferredApp);
if (err == B_OK && preferredApp[0]) {
BMimeType preferredAppType(preferredApp);
err = preferredAppType.GetIconForType(MimeType(), &bitmap, size);
if (err == B_OK) {
PRINT(("track icon - got icon for type %s from preferred app %s for file\n",
MimeType(), preferredApp));
return;
}
}
BMimeType mimeType(MimeType());
err = mimeType.GetIcon(&bitmap, size);
if (err == B_OK) {
// the system knew what icon to use for the type, we are done
PRINT(("track icon - signature %s, got icon from system\n",
MimeType()));
return;
}
err = mimeType.GetPreferredApp(preferredApp);
if (err != B_OK) {
// no preferred App for document, give up
PRINT(("track icon - signature %s, no prefered app, error %s\n",
MimeType(), strerror(err)));
return;
}
BMimeType preferredAppType(preferredApp);
err = preferredAppType.GetIconForType(MimeType(), &bitmap, size);
if (err == B_OK) {
// the preferred app knew icon to use for the type, we are done
PRINT(("track icon - signature %s, got icon from preferred app %s\n",
MimeType(), preferredApp));
return;
}
PRINT(("track icon - signature %s, preferred app %s, no icon, error %s\n",
MimeType(), preferredApp, strerror(err)));
}
}
void
Model::PrintToStream(int32 level, bool deep)
{
PRINT(("model name %s, entry name %s, inode %Lx, dev %x, directory inode %Lx\n",
Name() ? Name() : "**empty name**",
EntryRef()->name ? EntryRef()->name : "**empty ref name**",
NodeRef()->node,
NodeRef()->device,
EntryRef()->directory));
PRINT(("type %s \n", MimeType()));
PRINT(("model type: "));
switch (fBaseType) {
case kPlainNode:
PRINT(("plain\n"));
break;
case kQueryNode:
PRINT(("query\n"));
break;
case kQueryTemplateNode:
PRINT(("query template\n"));
break;
case kExecutableNode:
PRINT(("exe\n"));
break;
case kDirectoryNode:
PRINT(("dir\n"));
break;
case kLinkNode:
PRINT(("link\n"));
break;
case kRootNode:
PRINT(("root\n"));
break;
case kVolumeNode:
PRINT(("volume, name %s\n", fVolumeName ? fVolumeName : ""));
break;
default:
PRINT(("unknown\n"));
break;
}
if (level < 1)
return;
if (!IsVolume())
PRINT(("preferred app %s\n", fPreferredAppName ? fPreferredAppName : ""));
PRINT(("icon from: "));
switch (IconFrom()) {
case kUnknownSource:
PRINT(("unknown\n"));
break;
case kUnknownNotFromNode:
PRINT(("unknown but not from a node\n"));
break;
case kTrackerDefault:
PRINT(("tracker default\n"));
break;
case kTrackerSupplied:
PRINT(("tracker supplied\n"));
break;
case kMetaMime:
PRINT(("metamime\n"));
break;
case kPreferredAppForType:
PRINT(("preferred app for type\n"));
break;
case kPreferredAppForNode:
PRINT(("preferred app for node\n"));
break;
case kNode:
PRINT(("node\n"));
break;
case kVolume:
PRINT(("volume\n"));
break;
}
PRINT(("model %s opened %s \n", !IsNodeOpen() ? "not " : "",
IsNodeOpenForWriting() ? "for writing" : ""));
if (IsNodeOpen()) {
node_ref nodeRef;
fNode->GetNodeRef(&nodeRef);
PRINT(("node ref of open Node %Lx %x\n", nodeRef.node, nodeRef.device));
}
if (deep && IsSymLink()) {
BEntry tmpEntry(EntryRef(), true);
Model tmp(&tmpEntry);
PRINT(("symlink to:\n"));
tmp.PrintToStream();
}
TrackIconSource(B_MINI_ICON);
TrackIconSource(B_LARGE_ICON);
}
MimeType MimeTypeProvider::GetMimeTypeForName(const std::string& name) const
{
std::map<std::string, MimeType>::const_iterator iter = m_NameToMimeType.find(name);
if (iter != m_NameToMimeType.end()) return iter->second;
return MimeType();
}
MimeType MimeTypeRegistry::mimeType (const QFile & file) const
{
Q_UNUSED(file);
return MimeType (QString ("application/octet-stream"));
}
