JError
JDirInfo::GoTo
(
const JCharacter* origDirName
)
{
JString dirName;
if (JStringEmpty(origDirName) ||
!JConvertToAbsolutePath(origDirName, NULL, &dirName))
{
return JBadPath(origDirName);
}
if (JSameDirEntry(dirName, *itsCWD))
{
Update();
return JNoError();
}
JAppendDirSeparator(&dirName);
const JString origCWD = *itsCWD;
*itsCWD = dirName;
const JError err = BuildInfo();
if (err.OK())
{
Broadcast(PathChanged());
}
else
{
*itsCWD = origCWD;
}
return err;
}
JColorIndex
JXPathInput::GetTextColor
(
const JCharacter* path,
const JCharacter* base,
const JBoolean requireWrite,
const JColormap* colormap
)
{
if (JStringEmpty(path))
{
return colormap->GetBlackColor();
}
JString fullPath;
if ((JIsAbsolutePath(path) || !JStringEmpty(base)) &&
JConvertToAbsolutePath(path, base, &fullPath) &&
JDirectoryReadable(fullPath) &&
JCanEnterDirectory(fullPath) &&
(!requireWrite || JDirectoryWritable(fullPath)))
{
return colormap->GetBlackColor();
}
else
{
return colormap->GetRedColor();
}
}
void
SVNListBase::GetSelectedFiles
(
JPtrArray<JString>* fullNameList,
const JBoolean includeDeleted
)
{
fullNameList->CleanOut();
fullNameList->SetCleanUpAction(JPtrArrayT::kDeleteAll);
JTableSelection& s = GetTableSelection();
JTableSelectionIterator iter(&s);
JString name, fullName;
JPoint cell;
const JString& basePath = GetPath();
while (iter.Next(&cell))
{
const JString* line = itsLineList->NthElement(cell.y);
name = ExtractRelativePath(*line);
const JBoolean exists = JConvertToAbsolutePath(name, basePath, &fullName);
if (exists || includeDeleted)
{
fullNameList->Append(fullName);
}
}
}
JColorIndex
JXFileInput::GetTextColor
(
const JCharacter* fileName,
const JCharacter* basePath,
const JBoolean requireRead,
const JBoolean requireWrite,
const JBoolean requireExec,
const JColormap* colormap
)
{
if (JStringEmpty(fileName))
{
return colormap->GetBlackColor();
}
JString fullName;
if ((!JIsRelativePath(fileName) || !JStringEmpty(basePath)) &&
JConvertToAbsolutePath(fileName, basePath, &fullName) &&
(!requireRead || JFileReadable(fullName)) &&
(!requireWrite || JFileWritable(fullName)) &&
(!requireExec || JFileExecutable(fullName)))
{
return colormap->GetBlackColor();
}
else
{
return colormap->GetRedColor();
}
}
void
JDirInfo::AllocateCWD
(
const JCharacter* dirName
)
{
itsCWD = new JString;
assert( itsCWD != NULL );
const JBoolean ok = JConvertToAbsolutePath(dirName, NULL, itsCWD);
assert( ok );
JAppendDirSeparator(itsCWD);
}
JBoolean
JXFileInput::InputValid()
{
if (itsAllowInvalidFileFlag)
{
return kJTrue;
}
else if (!JXInputField::InputValid())
{
return kJFalse;
}
const JString& text = GetText();
if (text.IsEmpty())
{
return JNegate(IsRequired());
}
JString fullName;
const JCharacter* errID = NULL;
if (JIsRelativePath(text) && !HasBasePath())
{
errID = kNoRelPathID;
RecalcAll(kJTrue);
}
else if (!JConvertToAbsolutePath(text, itsBasePath, &fullName) ||
!JFileExists(fullName))
{
errID = kDoesNotExistID;
}
else if (itsRequireReadFlag && !JFileReadable(fullName))
{
errID = kUnreadableID;
}
else if (itsRequireWriteFlag && !JFileWritable(fullName))
{
errID = kUnwritableID;
}
else if (itsRequireExecFlag && !JFileExecutable(fullName))
{
errID = kCannotExecID;
}
if (JStringEmpty(errID))
{
return kJTrue;
}
else
{
(JGetUserNotification())->ReportError(JGetString(errID));
return kJFalse;
}
}
void
JXPathHistoryMenu::RemoveInvalidPaths()
{
JString fullName;
const JSize count = GetItemCount();
const JIndex firstIndex = GetFirstIndex();
for (JIndex i=count; i>=firstIndex; i--)
{
const JString& dirName = JXTextMenu::GetItemText(i);
if (!JConvertToAbsolutePath(dirName, itsBasePath, &fullName))
{
RemoveItem(i);
}
}
}
JBoolean
JXPathInput::GetPath
(
JString* path
)
const
{
const JString& text = GetText();
return JI2B(!text.IsEmpty() &&
(JIsAbsolutePath(text) || HasBasePath()) &&
JConvertToAbsolutePath(text, itsBasePath, path) &&
JDirectoryExists(*path) &&
JDirectoryReadable(*path) &&
JCanEnterDirectory(*path) &&
(!itsRequireWriteFlag || JDirectoryWritable(*path)));
}
JBoolean
JXFileInput::GetFile
(
JString* fullName
)
const
{
const JString& text = GetText();
return JI2B(!text.IsEmpty() &&
(!JIsRelativePath(text) || HasBasePath()) &&
JConvertToAbsolutePath(text, itsBasePath, fullName) &&
JFileExists(*fullName) &&
(!itsRequireReadFlag || JFileReadable(*fullName)) &&
(!itsRequireWriteFlag || JFileWritable(*fullName)) &&
(!itsRequireExecFlag || JFileExecutable(*fullName)));
}
JString
JGetUniqueDirEntryName
(
const JCharacter* path,
const JCharacter* namePrefix,
const JCharacter* nameSuffix,
const JIndex startIndex
)
{
assert( !JStringEmpty(namePrefix) );
JString fullPath;
if (JStringEmpty(path))
{
if (!JGetTempDirectory(&fullPath))
{
fullPath = JGetCurrentDirectory();
}
}
else
{
const JBoolean ok = JConvertToAbsolutePath(path, NULL, &fullPath);
assert( ok );
}
assert( JDirectoryExists(fullPath) );
const JString prefix = JCombinePathAndName(fullPath, namePrefix);
JString name;
for (JIndex i=startIndex; i<=kJIndexMax; i++)
{
name = prefix;
if (i > 1)
{
name += JString(i, JString::kBase10);
}
if (!JStringEmpty(nameSuffix))
{
name += nameSuffix;
}
if (!JNameUsed(name))
{
break;
}
}
return name;
}
void
GFGLink::ParseClass
(
GFGClass* list,
const JCharacter* filename,
const JCharacter* classname
)
{
JBoolean ok = kJTrue;
if (itsCTagsProcess == NULL)
{
ok = StartCTags();
}
if (ok)
{
itsClassList = list;
itsCurrentClass = classname;
itsCurrentFile = filename;
JConvertToAbsolutePath(filename, "", &itsCurrentFile);
itsCurrentFile.Print(*itsOutputLink);
*itsOutputLink << std::endl;
itsOutputLink->flush();
JBoolean found = kJFalse;
JString result = JReadUntil(itsInputFD, kDelimiter, &found);
if (found)
{
JIndex findex;
while ( result.LocateSubstring("\n", &findex) &&
findex > 1)
{
JString line = result.GetSubstring(1, findex - 1);
result.RemoveSubstring(1, findex);
ParseLine(line);
}
Broadcast(FileParsed());
}
}
}
void
XDLink::SetProgram
(
const JCharacter* fileName
)
{
Send("detach");
// StopDebugger(); // avoid broadcasting DebuggerRestarted
// StartDebugger();
itsProgramConfigFileName.Clear();
itsSourcePathList->DeleteAll();
JString fullName;
if (!JConvertToAbsolutePath(fileName, NULL, &fullName) ||
!JFileReadable(fullName))
{
const JString error = JGetString("ConfigFileUnreadable::XDLink");
Broadcast(UserOutput(error, kJTrue));
return;
}
else if (CMMDIServer::IsBinary(fullName))
{
const JString error = JGetString("ConfigFileIsBinary::XDLink");
Broadcast(UserOutput(error, kJTrue));
return;
}
JString line;
if (!CMMDIServer::GetLanguage(fullName, &line) ||
JStringCompare(line, "php", kJFalse) != 0)
{
const JString error = JGetString("ConfigFileWrongLanguage::XDLink");
Broadcast(UserOutput(error, kJTrue));
return;
}
JString path, name, suffix;
JSplitPathAndName(fullName, &path, &name);
JSplitRootAndSuffix(name, &itsProgramName, &suffix);
itsProgramConfigFileName = fullName;
ifstream input(fullName);
while (1)
{
line = JReadLine(input);
line.TrimWhitespace();
if (line.BeginsWith("source-path:"))
{
line.RemoveSubstring(1, 12);
line.TrimWhitespace();
name = JCombinePathAndName(path, line);
itsSourcePathList->Append(name);
}
else if (!line.IsEmpty() && !line.BeginsWith("code-medic:"))
{
line.Prepend("Unknown option: ");
line.AppendCharacter('\n');
Broadcast(UserOutput(line, kJTrue));
}
if (!input.good())
{
break;
}
}
XDSetProgramTask* task = new XDSetProgramTask();
assert( task != NULL );
task->Go();
}
JBoolean
SyGApplication::OpenDirectory
(
const JString& pathName,
SyGTreeDir** dir,
JIndex* row,
const JBoolean deiconify,
const JBoolean reportError,
const JBoolean forceNew,
const JBoolean clearSelection
)
{
if (dir != NULL)
{
*dir = NULL;
}
if (row != NULL)
{
*row = 0;
}
JString fixedName, trueName;
if (!JExpandHomeDirShortcut(pathName, &fixedName) ||
!JConvertToAbsolutePath(fixedName, NULL, &trueName))
{
if (reportError)
{
JString msg = "\"";
msg += pathName;
msg += "\" does not exist.";
(JGetUserNotification())->ReportError(msg);
}
return kJFalse;
}
// if file, select it after opening the window
JString selectName;
if (JFileExists(trueName) ||
!JDirectoryExists(trueName)) // broken link
{
JStripTrailingDirSeparator(&trueName);
JString path;
JSplitPathAndName(trueName, &path, &selectName);
trueName = path;
}
// can't check this until after making sure that trueName is directory
if (!JFSFileTreeNode::CanHaveChildren(trueName))
{
if (reportError)
{
JString msg = "Unable to read contents of \"";
msg += pathName;
msg += "\"";
(JGetUserNotification())->ReportError(msg);
}
return kJFalse;
}
// resolve all .. in path
JIndex i;
JString p, p1;
while (trueName.LocateSubstring("..", &i))
{
p = trueName.GetSubstring(1, i+1);
if (!JGetTrueName(p, &p1))
{
if (reportError)
{
JString msg = "\"";
msg += p;
msg += "\" does not exist.";
(JGetUserNotification())->ReportError(msg);
}
return kJFalse;
}
trueName.ReplaceSubstring(1, i+1, p1);
}
// check if window is already open
JString ancestor = trueName, n;
JPtrArray<JString> pathList(JPtrArrayT::kDeleteAll);
while (!JIsRootDirectory(ancestor))
{
const JIndex count = itsWindowList->GetElementCount();
for (JIndex i=1; i<=count; i++)
{
const JString name = (itsWindowList->NthElement(i))->GetDirectory();
if (JSameDirEntry(name, ancestor))
{
SyGTreeDir* childDir = itsWindowList->NthElement(i);
childDir->Activate();
if (dir != NULL)
{
*dir = childDir;
}
JPoint cell;
(childDir->GetTable())->SelectName(pathList, selectName, &cell, clearSelection);
if (row != NULL)
{
*row = cell.y;
}
return kJTrue;
}
}
if (forceNew)
{
break;
}
JStripTrailingDirSeparator(&ancestor);
JSplitPathAndName(ancestor, &p, &n);
ancestor = p;
pathList.Prepend(n);
}
// create new window
fixedName = trueName;
JGetTrueName(fixedName, &trueName);
SyGTreeDir* childDir = new SyGTreeDir(trueName);
assert( childDir != NULL );
childDir->Activate();
JPoint cell;
(childDir->GetTable())->SelectName(selectName, NULL, &cell);
if (row != NULL)
{
*row = cell.y;
}
if (deiconify)
{
childDir->GetWindow()->Deiconify();
}
itsWindowList->Append(childDir);
if (dir != NULL)
{
*dir = childDir;
}
return kJTrue;
}
void
JXPathInput::AdjustStylesBeforeRecalc
(
const JString& buffer,
JRunArray<Font>* styles,
JIndexRange* recalcRange,
JIndexRange* redrawRange,
const JBoolean deletion
)
{
const JColormap* colormap = GetColormap();
const JSize totalLength = buffer.GetLength();
JString fullPath = buffer;
if ((JIsRelativePath(buffer) && !HasBasePath()) ||
!JExpandHomeDirShortcut(buffer, &fullPath))
{
fullPath.Clear();
}
// Last clause because if JConvertToAbsolutePath() succeeds, we don't
// want to further modify fullName.
else if (JIsRelativePath(buffer) &&
!JConvertToAbsolutePath(buffer, itsBasePath, &fullPath))
{
if (HasBasePath())
{
fullPath = JCombinePathAndName(itsBasePath, buffer);
}
else
{
fullPath.Clear();
}
}
JSize errLength;
if (fullPath.IsEmpty())
{
errLength = totalLength;
}
else
{
const JString closestDir = JGetClosestDirectory(fullPath, itsRequireWriteFlag);
if (fullPath.BeginsWith(closestDir))
{
errLength = fullPath.GetLength() - closestDir.GetLength();
}
else
{
errLength = totalLength;
}
}
if (errLength > 0 && buffer.EndsWith(kThisDirSuffix))
{
errLength++; // trailing . is trimmed
}
Font f = styles->GetFirstElement();
styles->RemoveAll();
if (errLength >= totalLength)
{
f.style.color = colormap->GetRedColor();
styles->AppendElements(f, totalLength);
}
else
{
f.style.color = colormap->GetBlackColor();
styles->AppendElements(f, totalLength - errLength);
if (errLength > 0)
{
f.style.color = colormap->GetRedColor();
styles->AppendElements(f, errLength);
}
}
*redrawRange += JIndexRange(1, totalLength);
}
JBoolean
JXPathInput::InputValid()
{
if (itsAllowInvalidPathFlag)
{
return kJTrue;
}
else if (!JXInputField::InputValid())
{
return kJFalse;
}
const JString& text = GetText();
if (text.IsEmpty()) // paranoia -- JXInputField should have reported
{
return !IsRequired();
}
JString path;
if (JIsRelativePath(text) && !HasBasePath())
{
(JGetUserNotification())->ReportError(JGetString(kNoRelPathID));
RecalcAll(kJTrue);
return kJFalse;
}
if (!JConvertToAbsolutePath(text, itsBasePath, &path))
{
(JGetUserNotification())->ReportError(JGetString(kInvalidPathID));
RecalcAll(kJTrue);
return kJFalse;
}
const JString currDir = JGetCurrentDirectory();
const JError err = JChangeDirectory(path);
JChangeDirectory(currDir);
if (err.OK())
{
if (!JDirectoryReadable(path))
{
(JGetUserNotification())->ReportError(JGetString(kUnreadableID));
RecalcAll(kJTrue);
return kJFalse;
}
else if (itsRequireWriteFlag && !JDirectoryWritable(path))
{
(JGetUserNotification())->ReportError(JGetString(kUnwritableID));
RecalcAll(kJTrue);
return kJFalse;
}
else
{
return kJTrue;
}
}
const JCharacter* errID;
if (err == kJAccessDenied)
{
errID = kAccessDeniedID;
}
else if (err == kJBadPath)
{
errID = kBadPathID;
}
else if (err == kJComponentNotDirectory)
{
errID = kCompNotDirID;
}
else
{
errID = kInvalidDirID;
}
(JGetUserNotification())->ReportError(JGetString(errID));
RecalcAll(kJTrue);
return kJFalse;
}