Model::CanHandleResult
Model::CanHandleDrops() const
{
if (IsDirectory())
// directories take anything
// resolve permissions here
return kCanHandle;
if (IsSymLink()) {
// descend into symlink and try again on it's target
BEntry entry(&fEntryRef, true);
if (entry.InitCheck() != B_OK)
return kCannotHandle;
if (entry == BEntry(EntryRef()))
// self-referencing link, avoid infinite recursion
return kCannotHandle;
Model model(&entry);
if (model.InitCheck() != B_OK)
return kCannotHandle;
return model.CanHandleDrops();
}
if (IsExecutable())
return kNeedToCheckType;
return kCannotHandle;
}
bool
Model::IsSuperHandler() const
{
ASSERT(CanHandleDrops() == kNeedToCheckType);
BFile file(EntryRef(), O_RDONLY);
BAppFileInfo handlerInfo(&file);
BMessage message;
if (handlerInfo.GetSupportedTypes(&message) != B_OK)
return false;
for (int32 index = 0; ; index++) {
const char *mimeSignature;
int32 bufferLength;
if (message.FindData("types", 'CSTR', index, (const void **)&mimeSignature,
&bufferLength))
return false;
if (IsSuperHandlerSignature(mimeSignature))
return true;
}
return false;
}
void CDoc::Save()
{
try
{
if (!fDocIO)
THROW(("No file available"));
// Only save directly if the file is writable and if we already
// have a place (entry) for the file
if (!fReadOnly && (!fDocIO->IsLocal() || EntryRef()))
{
if (IsDirty())
{
StopWatchingFile();
if (fDocIO->WriteDoc())
SetDirty(false);
StartWatchingFile();
}
}
else
{
// Ask user where to save to
SaveAs();
}
}
catch (HErr& err)
{
err.DoError();
}
}
int32
Model::SupportsMimeType(const char *type, const BObjectList<BString> *list,
bool exactReason) const
{
ASSERT((type == 0) != (list == 0));
// pass in one or the other
int32 result = kDoesNotSupportType;
BFile file(EntryRef(), O_RDONLY);
BAppFileInfo handlerInfo(&file);
BMessage message;
if (handlerInfo.GetSupportedTypes(&message) != B_OK)
return kDoesNotSupportType;
for (int32 index = 0; ; index++) {
// check if this model lists the type of dropped document as supported
const char *mimeSignature;
int32 bufferLength;
if (message.FindData("types", 'CSTR', index, (const void **)&mimeSignature,
&bufferLength))
return result;
if (IsSuperHandlerSignature(mimeSignature)) {
if (!exactReason)
return kSuperhandlerModel;
if (result == kDoesNotSupportType)
result = kSuperhandlerModel;
}
int32 match;
if (type) {
BString typeString(type);
match = MatchMimeTypeString(&typeString, mimeSignature);
} else
match = WhileEachListItem(const_cast<BObjectList<BString> *>(list),
MatchMimeTypeString, mimeSignature);
// const_cast shouldnt be here, have to have it until MW cleans up
if (match == kMatch)
// supports the actual type, it can't get any better
return kModelSupportsType;
else if (match == kMatchSupertype) {
if (!exactReason)
return kModelSupportsSupertype;
// we already know this model supports the file as a supertype,
// now find out if it matches the type
result = kModelSupportsSupertype;
}
}
return result;
}
void PProjectWindow::AddFiles()
{
if (fPanel)
fPanel->Show();
else
{
entry_ref ref;
if (EntryRef())
{
BEntry e, p;
FailOSErr(e.SetTo(EntryRef()));
FailOSErr(e.GetParent(&p));
FailOSErr(p.GetRef(&ref));
}
fPanel = new BFilePanel(B_OPEN_PANEL, new BMessenger(this), &ref);
fPanel->SetButtonLabel(B_DEFAULT_BUTTON, "Add");
fPanel->Show();
}
} /* PProjectWindow::AddFiles */
void CDoc::SetReadOnly(bool readOnly)
{
if ((readOnly && fDirty) || !EntryRef())
{
MWarningAlert a("You have to save the file first before marking it read-only");
a.Go();
}
else
{
try
{
BEntry e;
FailOSErr(e.SetTo(EntryRef(), true));
BPath p;
FailOSErr(e.GetPath(&p));
struct stat st;
FailOSErr(stat(p.Path(), &st));
if (readOnly)
st.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
else
{
// is this the right way, or is it a hack???
mode_t t = umask(0); // get the umask
umask(t); // and reset it.
st.st_mode |= (S_IWUSR | S_IWGRP | S_IWOTH) & ~t;
}
FailOSErr(chmod(p.Path(), st.st_mode));
fReadOnly = readOnly;
}
catch (HErr& e)
{
e.DoError();
}
}
}
void CDoc::SaveAs()
{
if (!fSavePanel)
CreateFilePanel();
BWindow *w = fSavePanel->Window();
FailNil(w);
w->Lock();
char s[256];
sprintf(s, "Save %s as:", Name());
w->SetTitle(s);
fSavePanel->SetSaveText(Name());
if (EntryRef())
{
BEntry e(EntryRef()), p;
e.GetParent(&p);
fSavePanel->SetPanelDirectory(&p);
}
else
fSavePanel->SetPanelDirectory(&gCWD);
fSavePanel->SetMessage(new BMessage(B_SAVE_REQUESTED));
if (fDocIO)
fSavePanel->SetTarget(fDocIO->Target());
else
fSavePanel->SetTarget(dynamic_cast<BLooper*>(this));
w->Unlock();
if (!fSavePanel->IsShowing())
fSavePanel->Show();
else
fSavePanel->Window()->Activate();
}
status_t
Model::GetLongVersionString(BString &result, version_kind kind)
{
BFile file(EntryRef(), O_RDONLY);
status_t error = file.InitCheck();
if (error != B_OK)
return error;
BAppFileInfo info(&file);
error = info.InitCheck();
if (error != B_OK)
return error;
version_info version;
error = info.GetVersionInfo(&version, kind);
if (error != B_OK)
return error;
result = version.long_info;
return B_OK;
}
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 */
void PProjectWindow::MessageReceived(BMessage *msg)
{
if (msg->WasDropped() && msg->HasRef("refs"))
AddRefs(msg);
else
switch (msg->what)
{
case msg_PProjectItemInvoked:
OpenItem();
break;
case msg_PProjectItemSelected:
SelectionChanged();
break;
case msg_PAdd:
AddFiles();
SetDirty(true);
break;
case msg_PRemove:
RemoveSelected();
break;
case B_REFS_RECEIVED:
AddRefs(msg);
break;
case msg_EditAsText:
if (IsDirty())
Save();
gApp->NewWindow(EntryRef());
Close();
break;
default:
inherited::MessageReceived(msg);
break;
}
} /* PProjectWindow::MessageReceived */
status_t
Model::GetVersionString(BString &result, version_kind kind)
{
BFile file(EntryRef(), O_RDONLY);
status_t error = file.InitCheck();
if (error != B_OK)
return error;
BAppFileInfo info(&file);
error = info.InitCheck();
if (error != B_OK)
return error;
version_info version;
error = info.GetVersionInfo(&version, kind);
if (error != B_OK)
return error;
char vstr[32];
sprintf(vstr, "%ld.%ld.%ld", version.major, version.middle, version.minor);
result = vstr;
return B_OK;
}
status_t
Model::GetVersionString(BString &result, version_kind kind)
{
BFile file(EntryRef(), O_RDONLY);
status_t error = file.InitCheck();
if (error != B_OK)
return error;
BAppFileInfo info(&file);
error = info.InitCheck();
if (error != B_OK)
return error;
version_info version;
error = info.GetVersionInfo(&version, kind);
if (error != B_OK)
return error;
result.SetToFormat("%" B_PRId32 ".%" B_PRId32 ".%" B_PRId32, version.major,
version.middle, version.minor);
return B_OK;
}
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);
}
void
Model::GetPath(BPath *path) const
{
BEntry entry(EntryRef());
entry.GetPath(path);
}
void
Model::GetEntry(BEntry *entry) const
{
entry->SetTo(EntryRef());
}
