bool VDLoopThrottle::Delay() {
float desiredRatio = mThrottleFactor;
if (desiredRatio >= 1.0f)
return true;
if (desiredRatio <= 0.0f) {
::Sleep(100);
return false;
}
uint32 total = mActiveTimeWindowSum + mWaitTimeWindowSum;
if (total > 0) {
float delta = mActiveTimeWindowSum - total * mThrottleFactor;
mWaitTime += delta * (0.1f / 16.0f);
}
if (mWaitTime > 0) {
int delayTime = VDRoundToInt(mWaitTime);
if (delayTime > 1000)
delayTime = 1000;
BeginWait();
::Sleep(delayTime);
EndWait();
}
return true;
}
/*
** 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();
}
/**
* @param hwndParent - parent window handle.
*/
CWaitDialog::CWaitDialog(HWND hwndParent)
{
InitVars();
BeginWait(hwndParent);
}
