static void col_cb(ListStructure *sel, int n, int *values, void *data)
{
SSDataUI *ui = (SSDataUI *) data;
Quark *ssd = (Quark *) sel->anydata;
if (ssd && n == 1) {
int col = values[0];
SetSensitive(ui->col_label->text, TRUE);
SetTextString(ui->col_label, ssd_get_col_label(ssd, col));
} else {
SetSensitive(ui->col_label->text, FALSE);
}
}
void ExtendedProfileDataUIC::Set3DExtendedProfileData(const PSC_3DExtendedProfileData& inData)
{
zvalueSourceUI.SetChoice(int(inData.zvalueSource));
fixedZValueMSUI.SetValue(inData.fixedZValueMS);
SetSensitive();
}
/*
** Clean up after the execution of a shell command sub-process and present
** the output/errors to the user as requested in the initial issueCommand
** call. If "terminatedOnError" is true, don't bother trying to read the
** output, just close the i/o descriptors, free the memory, and restore the
** user interface state.
*/
static void finishCmdExecution(WindowInfo *window, int terminatedOnError)
{
shellCmdInfo *cmdData = window->shellCmdData;
textBuffer *buf;
int status, failure, errorReport, reselectStart, outTextLen, errTextLen;
int resp, cancel = False, fromMacro = cmdData->fromMacro;
char *outText, *errText = NULL;
/* Cancel any pending i/o on the file descriptors */
if (cmdData->stdoutInputID != 0)
XtRemoveInput(cmdData->stdoutInputID);
if (cmdData->stdinInputID != 0)
XtRemoveInput(cmdData->stdinInputID);
if (cmdData->stderrInputID != 0)
XtRemoveInput(cmdData->stderrInputID);
/* Close any file descriptors remaining open */
close(cmdData->stdoutFD);
if (cmdData->flags & ERROR_DIALOGS)
close(cmdData->stderrFD);
if (cmdData->inPtr != NULL)
close(cmdData->stdinFD);
/* Free the provided input text */
if (cmdData->input != NULL)
XtFree(cmdData->input);
/* Cancel pending timeouts */
if (cmdData->flushTimeoutID != 0)
XtRemoveTimeOut(cmdData->flushTimeoutID);
if (cmdData->bannerTimeoutID != 0)
XtRemoveTimeOut(cmdData->bannerTimeoutID);
/* Clean up waiting-for-shell-command-to-complete mode */
if (!cmdData->fromMacro) {
EndWait(window->shell);
SetSensitive(window, window->cancelShellItem, False);
if (cmdData->bannerIsUp)
ClearModeMessage(window);
}
/* If the process was killed or became inaccessable, give up */
if (terminatedOnError) {
freeBufList(&cmdData->outBufs);
freeBufList(&cmdData->errBufs);
waitpid(cmdData->childPid, &status, 0);
goto cmdDone;
}
/* Assemble the output from the process' stderr and stdout streams into
null terminated strings, and free the buffer lists used to collect it */
outText = coalesceOutput(&cmdData->outBufs, &outTextLen);
if (cmdData->flags & ERROR_DIALOGS)
errText = coalesceOutput(&cmdData->errBufs, &errTextLen);
/* Wait for the child process to complete and get its return status */
waitpid(cmdData->childPid, &status, 0);
/* Present error and stderr-information dialogs. If a command returned
error output, or if the process' exit status indicated failure,
present the information to the user. */
if (cmdData->flags & ERROR_DIALOGS)
{
failure = WIFEXITED(status) && WEXITSTATUS(status) != 0;
errorReport = *errText != '\0';
if (failure && errorReport)
{
removeTrailingNewlines(errText);
truncateString(errText, DF_MAX_MSG_LENGTH);
resp = DialogF(DF_WARN, window->shell, 2, "Warning", "%s", "Cancel",
"Proceed", errText);
cancel = resp == 1;
} else if (failure)
{
truncateString(outText, DF_MAX_MSG_LENGTH-70);
resp = DialogF(DF_WARN, window->shell, 2, "Command Failure",
"Command reported failed exit status.\n"
"Output from command:\n%s", "Cancel", "Proceed", outText);
cancel = resp == 1;
} else if (errorReport)
{
removeTrailingNewlines(errText);
truncateString(errText, DF_MAX_MSG_LENGTH);
resp = DialogF(DF_INF, window->shell, 2, "Information", "%s",
"Proceed", "Cancel", errText);
cancel = resp == 2;
}
XtFree(errText);
if (cancel)
{
XtFree(outText);
goto cmdDone;
}
}
/* If output is to a dialog, present the dialog. Otherwise insert the
(remaining) output in the text widget as requested, and move the
insert point to the end */
if (cmdData->flags & OUTPUT_TO_DIALOG) {
removeTrailingNewlines(outText);
if (*outText != '\0')
createOutputDialog(window->shell, outText);
} else if (cmdData->flags & OUTPUT_TO_STRING) {
ReturnShellCommandOutput(window,outText, WEXITSTATUS(status));
} else {
buf = TextGetBuffer(cmdData->textW);
if (!BufSubstituteNullChars(outText, outTextLen, buf)) {
fprintf(stderr,"NEdit: Too much binary data in shell cmd output\n");
outText[0] = '\0';
}
if (cmdData->flags & REPLACE_SELECTION) {
reselectStart = buf->primary.rectangular ? -1 : buf->primary.start;
BufReplaceSelected(buf, outText);
TextSetCursorPos(cmdData->textW, buf->cursorPosHint);
if (reselectStart != -1)
BufSelect(buf, reselectStart, reselectStart + strlen(outText));
} else {
safeBufReplace(buf, &cmdData->leftPos, &cmdData->rightPos, outText);
TextSetCursorPos(cmdData->textW, cmdData->leftPos+strlen(outText));
}
}
/* If the command requires the file to be reloaded afterward, reload it */
if (cmdData->flags & RELOAD_FILE_AFTER)
RevertToSaved(window);
/* Command is complete, free data structure and continue macro execution */
XtFree(outText);
cmdDone:
XtFree((char *)cmdData);
window->shellCmdData = NULL;
if (fromMacro)
ResumeMacroExecution(window);
}
/*
** Issue a shell command and feed it the string "input". Output can be
** directed either to text widget "textW" where it replaces the text between
** the positions "replaceLeft" and "replaceRight", to a separate pop-up dialog
** (OUTPUT_TO_DIALOG), or to a macro-language string (OUTPUT_TO_STRING). If
** "input" is NULL, no input is fed to the process. If an input string is
** provided, it is freed when the command completes. Flags:
**
** ACCUMULATE Causes output from the command to be saved up until
** the command completes.
** ERROR_DIALOGS Presents stderr output separately in popup a dialog,
** and also reports failed exit status as a popup dialog
** including the command output.
** REPLACE_SELECTION Causes output to replace the selection in textW.
** RELOAD_FILE_AFTER Causes the file to be completely reloaded after the
** command completes.
** OUTPUT_TO_DIALOG Send output to a pop-up dialog instead of textW
** OUTPUT_TO_STRING Output to a macro-language string instead of a text
** widget or dialog.
**
** REPLACE_SELECTION, ERROR_DIALOGS, and OUTPUT_TO_STRING can only be used
** along with ACCUMULATE (these operations can't be done incrementally).
*/
static void issueCommand(WindowInfo *window, const char *command, char *input,
int inputLen, int flags, Widget textW, int replaceLeft,
int replaceRight, int fromMacro)
{
int stdinFD, stdoutFD, stderrFD;
XtAppContext context = XtWidgetToApplicationContext(window->shell);
shellCmdInfo *cmdData;
pid_t childPid;
/* verify consistency of input parameters */
if ((flags & ERROR_DIALOGS || flags & REPLACE_SELECTION ||
flags & OUTPUT_TO_STRING) && !(flags & ACCUMULATE))
return;
/* a shell command called from a macro must be executed in the same
window as the macro, regardless of where the output is directed,
so the user can cancel them as a unit */
if (fromMacro)
window = MacroRunWindow();
/* put up a watch cursor over the waiting window */
if (!fromMacro)
BeginWait(window->shell);
/* enable the cancel menu item */
if (!fromMacro)
SetSensitive(window, window->cancelShellItem, True);
/* fork the subprocess and issue the command */
childPid = forkCommand(window->shell, command, window->path, &stdinFD,
&stdoutFD, (flags & ERROR_DIALOGS) ? &stderrFD : NULL);
/* set the pipes connected to the process for non-blocking i/o */
if (fcntl(stdinFD, F_SETFL, O_NONBLOCK) < 0)
perror("NEdit: Internal error (fcntl)");
if (fcntl(stdoutFD, F_SETFL, O_NONBLOCK) < 0)
perror("NEdit: Internal error (fcntl1)");
if (flags & ERROR_DIALOGS) {
if (fcntl(stderrFD, F_SETFL, O_NONBLOCK) < 0)
perror("NEdit: Internal error (fcntl2)");
}
/* if there's nothing to write to the process' stdin, close it now */
if (input == NULL)
close(stdinFD);
/* Create a data structure for passing process information around
amongst the callback routines which will process i/o and completion */
cmdData = (shellCmdInfo *)XtMalloc(sizeof(shellCmdInfo));
window->shellCmdData = cmdData;
cmdData->flags = flags;
cmdData->stdinFD = stdinFD;
cmdData->stdoutFD = stdoutFD;
cmdData->stderrFD = stderrFD;
cmdData->childPid = childPid;
cmdData->outBufs = NULL;
cmdData->errBufs = NULL;
cmdData->input = input;
cmdData->inPtr = input;
cmdData->textW = textW;
cmdData->bannerIsUp = False;
cmdData->fromMacro = fromMacro;
cmdData->leftPos = replaceLeft;
cmdData->rightPos = replaceRight;
cmdData->inLength = inputLen;
/* Set up timer proc for putting up banner when process takes too long */
if (fromMacro)
cmdData->bannerTimeoutID = 0;
else
cmdData->bannerTimeoutID = XtAppAddTimeOut(context, BANNER_WAIT_TIME,
bannerTimeoutProc, window);
/* Set up timer proc for flushing output buffers periodically */
if ((flags & ACCUMULATE) || textW == NULL)
cmdData->flushTimeoutID = 0;
else
cmdData->flushTimeoutID = XtAppAddTimeOut(context, OUTPUT_FLUSH_FREQ,
flushTimeoutProc, window);
/* set up callbacks for activity on the file descriptors */
cmdData->stdoutInputID = XtAppAddInput(context, stdoutFD,
(XtPointer)XtInputReadMask, stdoutReadProc, window);
if (input != NULL)
cmdData->stdinInputID = XtAppAddInput(context, stdinFD,
(XtPointer)XtInputWriteMask, stdinWriteProc, window);
else
cmdData->stdinInputID = 0;
if (flags & ERROR_DIALOGS)
cmdData->stderrInputID = XtAppAddInput(context, stderrFD,
(XtPointer)XtInputReadMask, stderrReadProc, window);
else
cmdData->stderrInputID = 0;
/* If this was called from a macro, preempt the macro untill shell
command completes */
if (fromMacro)
PreemptMacro();
}
SSDataUI *create_ssd_ui(ExplorerUI *eui)
{
SSDataUI *ui;
Widget tab, fr, rc, rc1, wbut;
ui = xmalloc(sizeof(SSDataUI));
if (!ui) {
return NULL;
}
memset(ui, 0, sizeof(SSDataUI));
/* ------------ Tabs -------------- */
tab = CreateTab(eui->scrolled_window);
AddHelpCB(tab, "doc/UsersGuide.html#ssd-properties");
ui->top = tab;
/* ------------ Main tab -------------- */
ui->main_tp = CreateTabPage(tab, "Data");
ui->mw = CreateTable("SSD", ui->main_tp,
EXTRA_SS_ROWS, EXTRA_SS_COLS,
VISIBLE_SS_ROWS, VISIBLE_SS_COLS);
TableSSDInit(ui->mw);
TableSetDefaultColWidth(ui->mw, CELL_WIDTH);
TableSetDefaultColLabelAlignment(ui->mw, ALIGN_CENTER);
AddTableDrawCellCB(ui->mw, drawcellCB, ui);
AddTableLeaveCellCB(ui->mw, leaveCB, ui);
AddTableEnterCellCB(ui->mw, enterCB, ui);
AddTableLabelActivateCB(ui->mw, labelCB, ui);
ui->popup = CreatePopupMenu(ui->mw);
ui->delete_btn = CreateMenuButton(ui->popup, "Delete column", '\0', col_delete_cb, ui);
ui->index_btn = CreateMenuButton(ui->popup, "Set as index", '\0', index_cb, ui);
ui->unindex_btn = CreateMenuButton(ui->popup, "Unset index", '\0', unindex_cb, ui);
/* ------------ Column props -------------- */
ui->column_tp = CreateTabPage(tab, "Columns");
ui->col_sel = CreateColChoice(ui->column_tp, "Column:", LIST_TYPE_SINGLE);
AddListChoiceCB(ui->col_sel, col_cb, ui);
ui->col_label = CreateCSText(ui->column_tp, "Label:");
SetSensitive(ui->col_label->text, FALSE);
AddTextInputCB(ui->col_label, text_explorer_cb, eui);
/* ------------ Hotlink tab -------------- */
ui->hotlink_tp = CreateTabPage(tab, "Hotlink");
fr = CreateFrame(ui->hotlink_tp, "Hotlink");
rc = CreateVContainer(fr);
rc1 = CreateHContainer(rc);
ui->hotlink = CreateToggleButton(rc1, "Enabled");
ui->hotsrc = CreateOptionChoiceVA(rc1, "Source type:",
"Disk", SOURCE_DISK,
"Pipe", SOURCE_PIPE,
NULL);
rc1 = CreateHContainer(rc);
ui->hotfile = CreateTextItem(rc1, 20, "File name:");
wbut = CreateButton(rc1, "Browse...");
AddButtonCB(wbut, create_hotfiles_popup, ui);
return ui;
}
static int labelCB(TableEvent *event)
{
SSDataUI *ui = (SSDataUI *) event->anydata;
static int last_row, last_column;
int i;
if (!event || event->type != MOUSE_PRESS) {
return TRUE;
}
if (event->button == LEFT_BUTTON) {
TableCommitEdit(ui->mw, TRUE);
if (event->row_label) {
if (event->modifiers & CONTROL_MODIFIER) {
if (TableIsRowSelected(ui->mw, event->row)) {
TableDeselectRow(ui->mw, event->row);
} else {
TableSelectRow(ui->mw, event->row);
}
last_row = event->row;
} else
if ((event->modifiers & SHIFT_MODIFIER) && last_row >= 0) {
for (i = MIN2(last_row, event->row); i <= MAX2(last_row, event->row); i++) {
TableSelectRow(ui->mw, i);
}
} else {
TableDeselectAllCells(ui->mw);
TableSelectRow(ui->mw, event->row);
last_row = event->row;
}
last_column = -1;
} else {
if (event->modifiers & CONTROL_MODIFIER) {
if (TableIsColSelected(ui->mw, event->col)) {
TableDeselectCol(ui->mw, event->col);
} else {
TableSelectCol(ui->mw, event->col);
}
last_column = event->col;
} else
if ((event->modifiers & SHIFT_MODIFIER) && last_column >= 0) {
for (i = MIN2(last_column, event->col); i <= MAX2(last_column, event->col); i++) {
TableSelectCol(ui->mw, i);
}
} else {
TableDeselectAllCells(ui->mw);
TableSelectCol(ui->mw, event->col);
last_column = event->col;
}
last_row = -1;
}
}
if (event->button == RIGHT_BUTTON) {
ss_column *col;
if (!event->row_label) {
ui->cb_column = event->col;
}
col = ssd_get_col(ui->q, ui->cb_column);
SetSensitive(ui->delete_btn, col != NULL);
SetSensitive(ui->index_btn, col != NULL && ui->cb_column != 0 &&
(col->format == FFORMAT_NUMBER || col->format == FFORMAT_DATE));
SetSensitive(ui->unindex_btn, ui->cb_column == 0 && col != NULL &&
ssd_is_indexed(ui->q));
ShowMenu(ui->popup, event->udata);
}
return TRUE;
}
ButtonBox::ButtonBox(const int xCenter, const int yCenter)
: xCenter_(xCenter), yCenter_(yCenter) {
SetSensitive(false);
}
ButtonBox::ButtonBox()
: xCenter_(0), yCenter_(0) {
SetSensitive(false);
}
