int
main
(
int argc,
char** argv
)
{
JTextProgressDisplay pg;
JStopWatch timer;
pg.FixedLengthProcessBeginning(6, "Calculating scores...", kJTrue, kJFalse);
timer.StartTimer();
long i;
for (i=1;i<=6;i++)
{
JWait(2.0);
if (!pg.IncrementProgress())
{
break;
}
}
timer.StopTimer();
pg.ProcessFinished();
JString timeString = timer.PrintTimeInterval();
cout << timeString;
pg.VariableLengthProcessBeginning("Processing examples...", kJTrue, kJFalse);
for (i=1;i<=6;i++)
{
JWait(2.0);
if (!pg.IncrementProgress(JString(i)))
{
break;
}
}
pg.ProcessFinished();
return 0;
}
void
TestPGTask::Perform
(
const Time delta,
Time* maxSleepTime
)
{
JBoolean keepGoing = kJTrue;
if (TimeToPerform(delta, maxSleepTime))
{
JWait(0.5); // simulate massive, greedy number crunching
itsCounter++;
keepGoing = itsPG->IncrementProgress();
}
else
{
keepGoing = itsPG->ProcessContinuing();
}
if (!keepGoing || itsCounter >= kStepCount)
{
itsPG->ProcessFinished();
jdelete this; // safe to commit suicide as last action
}
}
void
JXApplication::PerformTasks
(
const JBoolean hadEvents,
const JBoolean allowSleep
)
{
if (!hadEvents)
{
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
if (allowSleep)
{
JWait(itsMaxSleepTime / 1000.0);
}
}
else if (hadEvents &&
itsCurrentTime - itsLastIdleTime > itsMaxSleepTime)
{
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
}
else
{
PerformUrgentTasks();
}
}
void
JXTabGroup::ScrollWait
(
const JFloat delta
)
const
{
(GetWindow())->Update();
JWait(delta);
}
void
SMTPMessage::BlockUntilOkOrFail()
{
if (itsIsFinished)
{
return;
}
if (itsTimeoutTask != NULL)
{
JGetUserNotification()->ReportError("Connection to SMTP server timed out.");
Broadcast(SendFailure());
// itsLink = NULL;
delete this;
return;
}
JBoolean success = kJFalse;
itsIsFinished = kJFalse;
itsIsTryingToQuit = kJTrue;
JSize i = 1;
while((i <= 30) && !itsIsFinished)
{
do
{
itsSomethingRead = kJFalse;
ACE_Time_Value timeout(0);
(ACE_Reactor::instance())->handle_events(timeout);
ACE_Reactor::check_reconfiguration(NULL);
// itsLink->handle_input(0);
}
while (itsSomethingRead);// && !itsIsFinished);
JWait(2);
i++;
}
if (itsIsFinished)
{
delete this;
}
}
int
main
(
int argc,
char* argv[]
)
{
if (argc == 1)
{
char buffer[BUFSIZ];
while (1)
{
ssize_t count = read(0, buffer, sizeof(buffer));
if (count < 0 && jerrno() == EINTR)
{
// keep going
}
else if (count <= 0)
{
break;
}
else
{
// cerr << count << endl;
cout.write(buffer, count);
JWait(0.01);
}
}
return 0;
}
JProcess* p;
int fromFD;
const JError err = JProcess::Create(&p, argv[1],
kJIgnoreConnection, NULL,
kJForceNonblockingPipe, &fromFD,
kJAttachToFromFD, NULL);
if (err.OK())
{
char buffer[BUFSIZ];
while (1)
{
ssize_t count = read(fromFD, buffer, sizeof(buffer));
if (count < 0 && jerrno() == EINTR)
{
// keep going
}
else if (count <= 0)
{
break;
}
else
{
// cerr << count << endl;
cout.write(buffer, count);
JWait(0.02);
}
}
/*
ProcessLink* link = new ProcessLink(fromFD);
assert( link != NULL );
ACE_Time_Value delta(20);
ACE_Reactor::instance()->run_reactor_event_loop(delta);
link->Dump();
delete link;
*/
return 0;
}
else
{
JInitCore();
err.ReportIfError();
return 1;
}
}
JBoolean
JXApplication::HandleOneEventForWindow
(
JXWindow* window,
const JBoolean origAllowSleep,
const JBoolean do_tasks
)
{
const JBoolean origHadBlockingWindowFlag = itsHadBlockingWindowFlag;
itsHasBlockingWindowFlag = kJTrue;
itsHadBlockingWindowFlag = kJFalse; // req'd by JXWindow
if (itsIdleTaskStack->IsEmpty())
{
PushIdleTaskStack();
}
UpdateCurrentTime();
const JBoolean allowSleep =
JI2B(origAllowSleep && HandleCustomEventWhileBlocking());
UpdateCurrentTime();
JBoolean windowHasEvents = kJFalse;
const JXDisplay* uiDisplay = window->GetDisplay();
Window eventWindow [ kEventWindowCount ];
eventWindow[0] = window->GetXWindow();
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
JXMenuManager* menuMgr = display->GetMenuManager();
if (!origHadBlockingWindowFlag)
{
menuMgr->CloseCurrentMenus();
}
JXWindow* mouseContainer;
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
// get mouse and keyboard grabbers -- for menus inside blocking window
eventWindow[1] = eventWindow[2] = None;
JXWindow* grabber;
if (display == uiDisplay && display->GetMouseGrabber(&grabber) &&
menuMgr->IsMenuForWindow(grabber, window))
{
eventWindow[1] = grabber->GetXWindow();
}
if (display == uiDisplay && display->GetKeyboardGrabber(&grabber) &&
menuMgr->IsMenuForWindow(grabber, window))
{
eventWindow[2] = grabber->GetXWindow();
}
// process one event
XEvent xEvent;
if (display == uiDisplay &&
XCheckIfEvent(*display, &xEvent, GetNextWindowEvent,
reinterpret_cast<char*>(eventWindow)))
{
windowHasEvents = kJTrue;
if (xEvent.type != MotionNotify)
{
itsLastIdleTime = itsCurrentTime;
}
display->HandleEvent(xEvent, itsCurrentTime);
}
#if 0
// cd: background event check is now done as part of window event check
// to give better update responsiveness when dragging a window
else if (XCheckIfEvent(*display, &xEvent, GetNextBkgdEvent, NULL))
{
display->HandleEvent(xEvent, itsCurrentTime);
}
#endif
else if (display == uiDisplay &&
display->GetMouseContainer(&mouseContainer) &&
mouseContainer == window)
{
display->Idle(itsCurrentTime);
}
else
{
display->Update();
}
// discard mouse and keyboard events
DiscardEventInfo discardInfo(display, NULL);
if (display == uiDisplay)
{
discardInfo.eventWindow = eventWindow;
}
while (XCheckIfEvent(*display, &xEvent, DiscardNextEvent,
reinterpret_cast<char*>(&discardInfo)))
{ };
}
else if (display == uiDisplay &&
display->GetMouseContainer(&mouseContainer) &&
mouseContainer == window)
{
display->Idle(itsCurrentTime);
}
else
{
display->Update();
}
}
// Perform idle tasks when we don't receive any events and
// during long intervals of "mouse moved".
if (do_tasks)
{
if (!windowHasEvents)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
if (allowSleep)
{
JWait(itsMaxSleepTime / 1000.0);
}
}
else if (windowHasEvents &&
itsCurrentTime - itsLastIdleTime > itsMaxSleepTime)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
}
else
{
PerformPermanentTasks();
PerformUrgentTasks();
}
}
itsHasBlockingWindowFlag = kJFalse;
itsHadBlockingWindowFlag = kJTrue;
return windowHasEvents;
}
void
JXApplication::HandleOneEvent()
{
itsHadBlockingWindowFlag = kJFalse;
UpdateCurrentTime();
const JBoolean allowSleep = HandleCustomEvent();
UpdateCurrentTime();
JBoolean hasEvents = kJFalse;
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
hasEvents = kJTrue;
// get the next event
XEvent xEvent;
XNextEvent(*display, &xEvent);
if (xEvent.type != MotionNotify)
{
itsLastIdleTime = itsCurrentTime;
}
// dispatch the event
display->HandleEvent(xEvent, itsCurrentTime);
}
else
{
display->Idle(itsCurrentTime);
}
}
PopAllIdleTaskStack();
// Perform idle tasks when we don't receive any events and
// during long intervals of "mouse moved".
if (!hasEvents)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
if (allowSleep)
{
JWait(itsMaxSleepTime / 1000.0);
}
}
else if (hasEvents &&
itsCurrentTime - itsLastIdleTime > itsMaxSleepTime)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
}
else
{
PerformPermanentTasks();
PerformUrgentTasks();
}
}
JError
JExecute
(
const JCharacter* argv[],
const JSize size,
pid_t* childPID,
const JExecuteAction toAction,
int* toFD,
const JExecuteAction origFromAction,
int* fromFD,
const JExecuteAction errAction,
int* errFD
)
{
assert( size > sizeof(JCharacter*) );
assert( argv[ (size/sizeof(JCharacter*)) - 1 ] == NULL );
const JExecuteAction fromAction =
(origFromAction == kJForceNonblockingPipe ? kJCreatePipe : origFromAction);
assert( toAction != kJTossOutput && toAction != kJAttachToFromFD &&
toAction != kJForceNonblockingPipe );
assert( fromAction != kJAttachToFromFD );
assert( errAction != kJForceNonblockingPipe );
assert( (toAction != kJCreatePipe && toAction != kJAttachToFD) ||
toFD != NULL );
assert( (fromAction != kJCreatePipe && fromAction != kJAttachToFD) ||
fromFD != NULL );
assert( (errAction != kJCreatePipe && errAction != kJAttachToFD) ||
errFD != NULL );
JString progName;
if (!JProgramAvailable(argv[0], &progName))
{
return JProgramNotAvailable(argv[0]);
}
argv[0] = progName.GetCString();
int fd[3][2];
if (toAction == kJCreatePipe)
{
const JError err = JCreatePipe(fd[0]);
if (!err.OK())
{
return err;
}
}
if (fromAction == kJCreatePipe)
{
const JError err = JCreatePipe(fd[1]);
if (!err.OK())
{
if (toAction == kJCreatePipe)
{
close(fd[0][0]);
close(fd[0][1]);
}
return err;
}
}
if (errAction == kJCreatePipe)
{
const JError err = JCreatePipe(fd[2]);
if (!err.OK())
{
if (toAction == kJCreatePipe)
{
close(fd[0][0]);
close(fd[0][1]);
}
if (fromAction == kJCreatePipe)
{
close(fd[1][0]);
close(fd[1][1]);
}
return err;
}
}
pid_t pid;
const JError err = JThisProcess::Fork(&pid);
if (!err.OK())
{
if (toAction == kJCreatePipe)
{
close(fd[0][0]);
close(fd[0][1]);
}
if (fromAction == kJCreatePipe)
{
close(fd[1][0]);
close(fd[1][1]);
}
if (errAction == kJCreatePipe)
{
close(fd[2][0]);
close(fd[2][1]);
}
return err;
}
// child
else if (pid == 0)
{
const int stdinFD = fileno(stdin);
if (toAction == kJCreatePipe)
{
dup2(fd[0][0], stdinFD);
close(fd[0][0]);
close(fd[0][1]);
}
else if (toAction == kJAttachToFD)
{
dup2(*toFD, stdinFD);
close(*toFD);
}
const int stdoutFD = fileno(stdout);
if (fromAction == kJCreatePipe)
{
dup2(fd[1][1], stdoutFD);
close(fd[1][0]);
close(fd[1][1]);
}
else if (fromAction == kJAttachToFD)
{
dup2(*fromFD, stdoutFD);
close(*fromFD);
}
else if (fromAction == kJTossOutput)
{
FILE* nullFile = fopen("/dev/null", "a");
int nullfd = fileno(nullFile);
dup2(nullfd, stdoutFD);
fclose(nullFile);
}
const int stderrFD = fileno(stderr);
if (errAction == kJCreatePipe)
{
dup2(fd[2][1], stderrFD);
close(fd[2][0]);
close(fd[2][1]);
}
else if (errAction == kJAttachToFD)
{
dup2(*errFD, stderrFD);
close(*errFD);
}
else if (errAction == kJTossOutput)
{
FILE* nullFile = fopen("/dev/null", "a");
int nullfd = fileno(nullFile);
dup2(nullfd, stderrFD);
fclose(nullFile);
}
else if (errAction == kJAttachToFromFD && fromAction != kJIgnoreConnection)
{
dup2(stdoutFD, stderrFD);
}
ACE_OS::execvp(argv[0], const_cast<char* const*>(argv));
cerr << "Unable to run program \"" << argv[0] << '"' << endl;
cerr << endl;
cerr << "JExecute()::execvp() failed" << endl;
cerr << "Errno value: " << jerrno() << endl;
JThisProcess::Exit(1);
return JNoError();
}
// parent
else
{
if (origFromAction == kJForceNonblockingPipe)
{
pid_t pid2;
const JError err2 = JThisProcess::Fork(&pid2);
if (err2.OK() && pid2 == 0)
{
for (int i=0; i<150; i++)
{
JWait(0.1);
int value = fcntl(fd[1][1], F_GETFL, 0);
if (value & O_NONBLOCK)
{
cerr << "turning off nonblocking for cout: " << value << endl;
fcntl(fd[1][1], F_SETFL, value & (~ O_NONBLOCK));
}
}
JThisProcess::Exit(0);
return JNoError();
}
JProcess* p = new JProcess(pid2);
p->KillAtExit(kJTrue);
}
if (toAction == kJCreatePipe)
{
close(fd[0][0]);
*toFD = fd[0][1];
}
if (fromAction == kJCreatePipe)
{
close(fd[1][1]);
*fromFD = fd[1][0];
}
if (errAction == kJCreatePipe)
{
close(fd[2][1]);
*errFD = fd[2][0];
}
if (childPID == NULL)
{
return JWaitForChild(pid);
}
else
{
*childPID = pid;
return JNoError();
}
}
}
