//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ¿
// do_user_interaction ³
// ³
// Entry point from client module called on startup operation. ³
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ�
void do_user_interaction()
{
int cursor;
float t1, t2;
Editable *e;
static int inited = 0;
char file[16];
char path[128];
char buff[32];
gfx_get_mform(cursor);
gfx_set_mform(C_ARROW,0);
gfx_report("");
gfx_prompt("");
gfx_prompt("");
// Force mtl_pathname to point to process directory with ESPORT.VGP
// as the filename.
gfx_get_paths(GFX_PROCESS_PATH,0,path,file);
strcpy(mtl_palpath,path);
strcpy(mtl_palname,"ESPORT.VGP");
strcpy(log_fname,path);
strcat(log_fname,"\\ESPORT.LOG");
if (! inited)
{
char buff[256];
strcpy(buff,path);
strcat(buff,"\\");
strcat(buff,"ESPORT.INI");
load_from_ini(buff);
init_dialog(Escher, Escher_edit, NULL);
inited = 1;
}
do_export=loop_done=0;
gfx_get_paths(GFX_3DS_PATH,0,path,file);
if (strstr(file,".3DS"))
{
*strstr(file,".3DS")=0;
strcpy(scene_name,file);
strcat(file,".IFF");
strcpy(output_name,file);
strcpy(output_path,path);
}
Escher[TARGET].text=output_name;
ready_dialog(Escher, Escher_edit, NULL, Escher_feel, Escher_rad,
NULL, NULL);
init_editable(&Escher[SCN_NAME], scene_name);
sprintf(buff,"%f",scale_3ds);
init_editable(&Escher[SCAL_3DS], buff);
sprintf(buff,"%f",scale_esh);
init_editable(&Escher[SCAL_ESH], buff);
Escher[INC_CAMS].radio = (cameras_flag) ? 1 : 0;
Escher[INC_LGTS].radio = (lights_flag) ? 1 : 0;
Escher[KEYFRAME].radio = (keys_flag) ? 1 : 0;
Escher[FLAGS_0].radio = (object_flags & ESCH_MSH_APP0) ? 1 : 0;
Escher[FLAGS_1].radio = (object_flags & ESCH_MSH_APP1) ? 1 : 0;
Escher[FLAGS_2].radio = (object_flags & ESCH_MSH_APP2) ? 1 : 0;
Escher[FLAGS_3].radio = (object_flags & ESCH_MSH_APP3) ? 1 : 0;
Escher[FLAGS_4].radio = (object_flags & ESCH_MSH_APP4) ? 1 : 0;
Escher[FLAGS_5].radio = (object_flags & ESCH_MSH_APP5) ? 1 : 0;
Escher[FLAGS_6].radio = (object_flags & ESCH_MSH_APP6) ? 1 : 0;
Escher[FLAGS_7].radio = (object_flags & ESCH_MSH_APP7) ? 1 : 0;
Escher[FLAGS_8].radio = (object_flags & ESCH_MSH_APP8) ? 1 : 0;
Escher[FLAGS_9].radio = (object_flags & ESCH_MSH_APP9) ? 1 : 0;
Escher[FLAGS_A].radio = (object_flags & ESCH_MSH_APPA) ? 1 : 0;
Escher[FLAGS_B].radio = (object_flags & ESCH_MSH_APPB) ? 1 : 0;
Escher[FLAGS_C].radio = (object_flags & ESCH_MSH_APPC) ? 1 : 0;
Escher[FLAGS_D].radio = (object_flags & ESCH_MSH_APPD) ? 1 : 0;
Escher[FLAGS_E].radio = (object_flags & ESCH_MSH_APPE) ? 1 : 0;
Escher[FLAGS_F].radio = (object_flags & ESCH_MSH_APPF) ? 1 : 0;
startover: ;
while (!loop_done)
{
center_dialog(Escher);
save_under_dialog(Escher);
draw_dialog(Escher);
do_dialog(Escher, -1);
}
if (do_export)
{
e=(Editable*)Escher[SCAL_3DS].text;
t1=atof(e->string);
if (t1 <= 0.0)
{
gfx_continu_line("Scale values must be positive and non-zero");
loop_done=0;
goto startover;
}
e=(Editable*)Escher[SCAL_ESH].text;
t2=atof(e->string);
if (t2 <= 0.0)
{
gfx_continu_line("Scale values must be positive and non-zero");
loop_done=0;
goto startover;
}
scale_3ds = t1;
scale_esh = t2;
scale_3ds2esch = t2 / t1;
e=(Editable*)Escher[SCN_NAME].text;
strncpy(scene_name,e->string,16);
object_flags=0;
if (Escher[FLAGS_0].radio)
object_flags |= ESCH_MSH_APP0;
if (Escher[FLAGS_1].radio)
object_flags |= ESCH_MSH_APP1;
if (Escher[FLAGS_2].radio)
object_flags |= ESCH_MSH_APP2;
if (Escher[FLAGS_3].radio)
object_flags |= ESCH_MSH_APP3;
if (Escher[FLAGS_4].radio)
object_flags |= ESCH_MSH_APP4;
if (Escher[FLAGS_5].radio)
object_flags |= ESCH_MSH_APP5;
if (Escher[FLAGS_6].radio)
object_flags |= ESCH_MSH_APP6;
if (Escher[FLAGS_7].radio)
object_flags |= ESCH_MSH_APP7;
if (Escher[FLAGS_8].radio)
object_flags |= ESCH_MSH_APP8;
if (Escher[FLAGS_9].radio)
object_flags |= ESCH_MSH_APP9;
if (Escher[FLAGS_A].radio)
object_flags |= ESCH_MSH_APPA;
if (Escher[FLAGS_B].radio)
object_flags |= ESCH_MSH_APPB;
if (Escher[FLAGS_C].radio)
object_flags |= ESCH_MSH_APPC;
if (Escher[FLAGS_D].radio)
object_flags |= ESCH_MSH_APPD;
if (Escher[FLAGS_E].radio)
object_flags |= ESCH_MSH_APPE;
if (Escher[FLAGS_F].radio)
object_flags |= ESCH_MSH_APPF;
cameras_flag = (Escher[INC_CAMS].radio) ? 1 : 0;
lights_flag = (Escher[INC_LGTS].radio) ? 1 : 0;
keys_flag = (Escher[KEYFRAME].radio) ? 1 : 0;
export();
}
int
main(int argc, char **argv)
{
int c;
int sts;
int sep = __pmPathSeparator();
int use_localtime = 0;
int isdaemon = 0;
char *pmnsfile = PM_NS_DEFAULT;
char *username;
char *logfile = "pmlogger.log";
/* default log (not archive) file name */
char *endnum;
int i;
task_t *tp;
optcost_t ocp;
__pmFdSet readyfds;
char *p;
char *runtime = NULL;
int ctx; /* handle corresponding to ctxp below */
__pmContext *ctxp; /* pmlogger has just this one context */
int niter;
pid_t target_pid = 0;
__pmGetUsername(&username);
/*
* Warning:
* If any of the pmlogger options change, make sure the
* corresponding changes are made to pmnewlog when pmlogger
* options are passed through from the control file
*/
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'c': /* config file */
if (access(opts.optarg, F_OK) == 0)
configfile = opts.optarg;
else {
/* does not exist as given, try the standard place */
char *sysconf = pmGetConfig("PCP_VAR_DIR");
int sz = strlen(sysconf)+strlen("/config/pmlogger/")+strlen(opts.optarg)+1;
if ((configfile = (char *)malloc(sz)) == NULL)
__pmNoMem("config file name", sz, PM_FATAL_ERR);
snprintf(configfile, sz,
"%s%c" "config%c" "pmlogger%c" "%s",
sysconf, sep, sep, sep, opts.optarg);
if (access(configfile, F_OK) != 0) {
/* still no good, error handling happens below */
free(configfile);
configfile = opts.optarg;
}
}
break;
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'h': /* hostname for PMCD to contact */
pmcd_host_conn = opts.optarg;
break;
case 'l': /* log file name */
logfile = opts.optarg;
break;
case 'L': /* linger if not primary logger */
linger = 1;
break;
case 'm': /* note for port map file */
note = opts.optarg;
isdaemon = ((strcmp(note, "pmlogger_check") == 0) ||
(strcmp(note, "pmlogger_daily") == 0));
break;
case 'n': /* alternative name space file */
pmnsfile = opts.optarg;
break;
case 'p':
target_pid = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: invalid process identifier (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else if (!__pmProcessExists(target_pid)) {
pmprintf("%s: PID error - no such process (%d)\n",
pmProgname, target_pid);
opts.errors++;
}
break;
case 'P': /* this is the primary pmlogger */
primary = 1;
isdaemon = 1;
break;
case 'r': /* report sizes of pmResult records */
rflag = 1;
break;
case 's': /* exit size */
sts = ParseSize(opts.optarg, &exit_samples, &exit_bytes, &exit_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for exit size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (exit_time.tv_sec > 0) {
__pmAFregister(&exit_time, NULL, run_done_callback);
}
break;
case 'T': /* end time */
runtime = opts.optarg;
break;
case 't': /* change default logging interval */
if (pmParseInterval(opts.optarg, &delta, &p) < 0) {
pmprintf("%s: illegal -t argument\n%s", pmProgname, p);
free(p);
opts.errors++;
}
break;
case 'U': /* run as named user */
username = opts.optarg;
isdaemon = 1;
break;
case 'u': /* flush output buffers after each fetch */
/*
* all archive write I/O is unbuffered now, so maintain -u
* for backwards compatibility only
*/
break;
case 'v': /* volume switch after given size */
sts = ParseSize(opts.optarg, &vol_switch_samples, &vol_switch_bytes,
&vol_switch_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for volume size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (vol_switch_time.tv_sec > 0) {
vol_switch_afid = __pmAFregister(&vol_switch_time, NULL,
vol_switch_callback);
}
break;
case 'V':
archive_version = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || archive_version != PM_LOG_VERS02) {
pmprintf("%s: -V requires a version number of %d\n",
pmProgname, PM_LOG_VERS02);
opts.errors++;
}
break;
case 'x': /* recording session control fd */
rsc_fd = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || rsc_fd < 0) {
pmprintf("%s: -x requires a non-negative numeric argument\n", pmProgname);
opts.errors++;
}
else {
time(&rsc_start);
}
break;
case 'y':
use_localtime = 1;
break;
case '?':
default:
opts.errors++;
break;
}
}
if (primary && pmcd_host != NULL) {
pmprintf(
"%s: -P and -h are mutually exclusive; use -P only when running\n"
"%s on the same (local) host as the PMCD to which it connects.\n",
pmProgname, pmProgname);
opts.errors++;
}
if (!opts.errors && opts.optind != argc - 1) {
pmprintf("%s: insufficient arguments\n", pmProgname);
opts.errors++;
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (rsc_fd != -1 && note == NULL) {
/* add default note to indicate running with -x */
static char xnote[10];
snprintf(xnote, sizeof(xnote), "-x %d", rsc_fd);
note = xnote;
}
/* if we are running as a daemon, change user early */
if (isdaemon)
__pmSetProcessIdentity(username);
__pmOpenLog("pmlogger", logfile, stderr, &sts);
if (sts != 1) {
fprintf(stderr, "%s: Warning: log file (%s) creation failed\n", pmProgname, logfile);
/* continue on ... writing to stderr */
}
/* base name for archive is here ... */
archBase = argv[opts.optind];
if (pmcd_host_conn == NULL)
pmcd_host_conn = "local:";
/* initialise access control */
if (__pmAccAddOp(PM_OP_LOG_ADV) < 0 ||
__pmAccAddOp(PM_OP_LOG_MAND) < 0 ||
__pmAccAddOp(PM_OP_LOG_ENQ) < 0) {
fprintf(stderr, "%s: access control initialisation failed\n", pmProgname);
exit(1);
}
if (pmnsfile != PM_NS_DEFAULT) {
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n", pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
if ((ctx = pmNewContext(PM_CONTEXT_HOST, pmcd_host_conn)) < 0) {
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n", pmProgname, pmcd_host_conn, pmErrStr(ctx));
exit(1);
}
pmcd_host = (char *)pmGetContextHostName(ctx);
if (strlen(pmcd_host) == 0) {
fprintf(stderr, "%s: pmGetContextHostName(%d) failed\n",
pmProgname, ctx);
exit(1);
}
if (rsc_fd == -1) {
/* no -x, so register client id with pmcd */
__pmSetClientIdArgv(argc, argv);
}
/*
* discover fd for comms channel to PMCD ...
*/
if ((ctxp = __pmHandleToPtr(ctx)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n", pmProgname, ctx);
exit(1);
}
pmcdfd = ctxp->c_pmcd->pc_fd;
PM_UNLOCK(ctxp->c_lock);
if (configfile != NULL) {
if ((yyin = fopen(configfile, "r")) == NULL) {
fprintf(stderr, "%s: Cannot open config file \"%s\": %s\n",
pmProgname, configfile, osstrerror());
exit(1);
}
}
else {
/* **ANY** Lex would read from stdin automagically */
configfile = "<stdin>";
}
__pmOptFetchGetParams(&ocp);
ocp.c_scope = 1;
__pmOptFetchPutParams(&ocp);
/* prevent early timer events ... */
__pmAFblock();
if (yyparse() != 0)
exit(1);
if (configfile != NULL)
fclose(yyin);
yyend();
#ifdef PCP_DEBUG
fprintf(stderr, "Config parsed\n");
#endif
fprintf(stderr, "Starting %slogger for host \"%s\" via \"%s\"\n",
primary ? "primary " : "", pmcd_host, pmcd_host_conn);
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "optFetch Cost Parameters: pmid=%d indom=%d fetch=%d scope=%d\n",
ocp.c_pmid, ocp.c_indom, ocp.c_fetch, ocp.c_scope);
fprintf(stderr, "\nAfter loading config ...\n");
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_numvalid == 0)
continue;
fprintf(stderr, " state: %sin log, %savail, %s, %s",
PMLC_GET_INLOG(tp->t_state) ? "" : "not ",
PMLC_GET_AVAIL(tp->t_state) ? "" : "un",
PMLC_GET_MAND(tp->t_state) ? "mand" : "adv",
PMLC_GET_ON(tp->t_state) ? "on" : "off");
fprintf(stderr, " delta: %ld usec",
(long)1000 * tp->t_delta.tv_sec + tp->t_delta.tv_usec);
fprintf(stderr, " numpmid: %d\n", tp->t_numpmid);
for (i = 0; i < tp->t_numpmid; i++) {
fprintf(stderr, " %s (%s):\n", pmIDStr(tp->t_pmidlist[i]), tp->t_namelist[i]);
}
__pmOptFetchDump(stderr, tp->t_fetch);
}
}
#endif
if (!primary && tasklist == NULL && !linger) {
fprintf(stderr, "Nothing to log, and not the primary logger instance ... good-bye\n");
exit(1);
}
if ((sts = __pmLogCreate(pmcd_host, archBase, archive_version, &logctl)) < 0) {
fprintf(stderr, "__pmLogCreate: %s\n", pmErrStr(sts));
exit(1);
}
else {
/*
* try and establish $TZ from the remote PMCD ...
* Note the label record has been set up, but not written yet
*/
char *name = "pmcd.timezone";
pmID pmid;
pmResult *resp;
__pmtimevalNow(&epoch);
sts = pmUseContext(ctx);
if (sts >= 0)
sts = pmLookupName(1, &name, &pmid);
if (sts >= 0)
sts = pmFetch(1, &pmid, &resp);
if (sts >= 0) {
if (resp->vset[0]->numval > 0) { /* pmcd.timezone present */
strcpy(logctl.l_label.ill_tz, resp->vset[0]->vlist[0].value.pval->vbuf);
/* prefer to use remote time to avoid clock drift problems */
epoch = resp->timestamp; /* struct assignment */
if (! use_localtime)
pmNewZone(logctl.l_label.ill_tz);
}
#ifdef PCP_DEBUG
else if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr,
"main: Could not get timezone from host %s\n",
pmcd_host);
}
#endif
pmFreeResult(resp);
}
}
/* do ParseTimeWindow stuff for -T */
if (runtime) {
struct timeval res_end; /* time window end */
struct timeval start;
struct timeval end;
struct timeval last_delta;
char *err_msg; /* parsing error message */
time_t now;
struct timeval now_tv;
time(&now);
now_tv.tv_sec = now;
now_tv.tv_usec = 0;
start = now_tv;
end.tv_sec = INT_MAX;
end.tv_usec = INT_MAX;
sts = __pmParseTime(runtime, &start, &end, &res_end, &err_msg);
if (sts < 0) {
fprintf(stderr, "%s: illegal -T argument\n%s", pmProgname, err_msg);
exit(1);
}
last_delta = res_end;
tsub(&last_delta, &now_tv);
__pmAFregister(&last_delta, NULL, run_done_callback);
last_stamp = res_end;
}
fprintf(stderr, "Archive basename: %s\n", archBase);
#ifndef IS_MINGW
/* detach yourself from the launching process */
if (isdaemon)
setpgid(getpid(), 0);
#endif
/* set up control port */
init_ports();
__pmFD_ZERO(&fds);
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0)
__pmFD_SET(ctlfds[i], &fds);
}
#ifndef IS_MINGW
__pmFD_SET(pmcdfd, &fds);
#endif
if (rsc_fd != -1)
__pmFD_SET(rsc_fd, &fds);
numfds = maxfd() + 1;
if ((sts = do_preamble()) < 0)
fprintf(stderr, "Warning: problem writing archive preamble: %s\n",
pmErrStr(sts));
sts = 0; /* default exit status */
parse_done = 1; /* enable callback processing */
__pmAFunblock();
for ( ; ; ) {
int nready;
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "before __pmSelectRead(%d,...): run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
niter = 0;
while (log_alarm && niter++ < 10) {
__pmAFblock();
log_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: log_alarm\n");
#endif
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_alarm) {
tp->t_alarm = 0;
do_work(tp);
}
}
__pmAFunblock();
}
if (vol_switch_alarm) {
__pmAFblock();
vol_switch_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: vol_switch_alarm\n");
#endif
newvolume(VOL_SW_TIME);
__pmAFunblock();
}
if (run_done_alarm) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: run_done_alarm\n");
#endif
run_done(0, NULL);
/*NOTREACHED*/
}
__pmFD_COPY(&readyfds, &fds);
nready = __pmSelectRead(numfds, &readyfds, NULL);
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "__pmSelectRead(%d,...) done: nready=%d run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, nready, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
__pmAFblock();
if (nready > 0) {
/* handle request on control port */
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0 && __pmFD_ISSET(ctlfds[i], &readyfds)) {
if (control_req(ctlfds[i])) {
/* new client has connected */
__pmFD_SET(clientfd, &fds);
if (clientfd >= numfds)
numfds = clientfd + 1;
}
}
}
if (clientfd >= 0 && __pmFD_ISSET(clientfd, &readyfds)) {
/* process request from client, save clientfd in case client
* closes connection, resetting clientfd to -1
*/
int fd = clientfd;
if (client_req()) {
/* client closed connection */
__pmFD_CLR(fd, &fds);
__pmCloseSocket(clientfd);
clientfd = -1;
numfds = maxfd() + 1;
qa_case = 0;
}
}
#ifndef IS_MINGW
if (pmcdfd >= 0 && __pmFD_ISSET(pmcdfd, &readyfds)) {
/*
* do not expect this, given synchronous commumication with the
* pmcd ... either pmcd has terminated, or bogus PDU ... or its
* Win32 and we are operating under the different conditions of
* our AF.c implementation there, which has to deal with a lack
* of signal support on Windows - race condition exists between
* this check and the async event timer callback.
*/
__pmPDU *pb;
__pmPDUHdr *php;
sts = __pmGetPDU(pmcdfd, ANY_SIZE, TIMEOUT_NEVER, &pb);
if (sts <= 0) {
if (sts < 0)
fprintf(stderr, "Error: __pmGetPDU: %s\n", pmErrStr(sts));
disconnect(sts);
}
else {
php = (__pmPDUHdr *)pb;
fprintf(stderr, "Error: Unsolicited %s PDU from PMCD\n",
__pmPDUTypeStr(php->type));
disconnect(PM_ERR_IPC);
}
if (sts > 0)
__pmUnpinPDUBuf(pb);
}
#endif
if (rsc_fd >= 0 && __pmFD_ISSET(rsc_fd, &readyfds)) {
/*
* some action on the recording session control fd
* end-of-file means launcher has quit, otherwise we
* expect one of these commands
* V<number>\n - version
* F<folio>\n - folio name
* P<name>\n - launcher's name
* R\n - launcher can replay
* D\n - detach from launcher
* Q\n - quit pmlogger
*/
char rsc_buf[MAXPATHLEN];
char *rp = rsc_buf;
char myc;
int fake_x = 0;
for (rp = rsc_buf; ; rp++) {
if (read(rsc_fd, &myc, 1) <= 0) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "recording session control: eof\n");
#endif
if (rp != rsc_buf) {
*rp = '\0';
fprintf(stderr, "Error: incomplete recording session control message: \"%s\"\n", rsc_buf);
}
fake_x = 1;
break;
}
if (rp >= &rsc_buf[MAXPATHLEN]) {
fprintf(stderr, "Error: absurd recording session control message: \"%100.100s ...\"\n", rsc_buf);
fake_x = 1;
break;
}
if (myc == '\n') {
*rp = '\0';
break;
}
*rp = myc;
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
if (fake_x == 0)
fprintf(stderr, "recording session control: \"%s\"\n", rsc_buf);
}
#endif
if (fake_x)
do_dialog('X');
else if (strcmp(rsc_buf, "Q") == 0 ||
strcmp(rsc_buf, "D") == 0 ||
strcmp(rsc_buf, "?") == 0)
do_dialog(rsc_buf[0]);
else if (rsc_buf[0] == 'F')
folio_name = strdup(&rsc_buf[1]);
else if (rsc_buf[0] == 'P')
rsc_prog = strdup(&rsc_buf[1]);
else if (strcmp(rsc_buf, "R") == 0)
rsc_replay = 1;
else if (rsc_buf[0] == 'V' && rsc_buf[1] == '0') {
/*
* version 0 of the recording session control ...
* this is all we grok at the moment
*/
;
}
else {
fprintf(stderr, "Error: illegal recording session control message: \"%s\"\n", rsc_buf);
do_dialog('X');
}
}
}
else if (vol_switch_flag) {
newvolume(VOL_SW_SIGHUP);
vol_switch_flag = 0;
}
else if (nready < 0 && neterror() != EINTR)
fprintf(stderr, "Error: select: %s\n", netstrerror());
__pmAFunblock();
if (target_pid && !__pmProcessExists(target_pid))
exit(EXIT_SUCCESS);
if (exit_code)
break;
}
exit(exit_code);
}
int raine_file_select_ex( char *message, char *path, char *ext, int size,int width, int height)
{
char buf[512];
int ret;
char *p;
if (width == -1)
width = 305;
#ifdef HAVE_DIR_LIST
if (height == -1)
height = 161;
#else
if (height == -1)
height = 189;
#endif
/* for fs_dlist_proc() */
ASSERT(size >= 4 * uwidth_max(U_CURRENT));
ustrcpy(updir, empty_string);
file_selector[FS_MESSAGE].dp = (char *)message;
file_selector[FS_EDIT].d1 = size/uwidth_max(U_CURRENT) - 1;
file_selector[FS_EDIT].dp = path;
file_selector[FS_OK].dp = (void*)raine_get_config_text("OK");
file_selector[FS_CANCEL].dp = (void*)raine_get_config_text("Cancel");
fext = ext;
if (!ugetc(path)) {
if (!getcwd(buf, sizeof(buf)))
buf[0]=0;
do_uconvert(buf, U_ASCII, path, U_CURRENT, size);
fix_filename_case(path);
fix_filename_slashes(path);
put_backslash(path);
}
clear_keybuf();
do {
} while (gui_mouse_b());
stretch_dialog(file_selector, width, height);
centre_dialog(file_selector);
// Stupid correction of the allegro colors...
file_selector[FS_FILES].fg = CGUI_COL_TEXT_1;
file_selector[FS_FILES].bg = CGUI_BOX_COL_MIDDLE;
#ifdef HAVE_DIR_LIST /* not all platforms need a directory list */
file_selector[FS_DISKS].fg = CGUI_COL_TEXT_1;
file_selector[FS_DISKS].bg = CGUI_BOX_COL_MIDDLE;
#endif
ret = do_dialog(file_selector, FS_EDIT);
if (ret == FS_CANCEL)
return FALSE;
p = get_extension(path);
if ((!ugetc(p)) && (ext) && (!ustrpbrk(ext, uconvert_ascii(" ,;", NULL)))) {
p += usetc(p, '.');
ustrcpy(p, ext);
}
return TRUE;
}
void start_editor() {
int ret;
// Colors initialization
for (ret=1; edit_dialog[ret].proc; ret++) {
edit_dialog[ret].fg = colors[black];
edit_dialog[ret].bg = ((edit_dialog[ret].proc==d_edit_proc) ? colors[white] : colors[gray]);
}
edit_dialog[0].bg = colors[darkgray];
edit_dialog[5].dp = datafile[DATA_SCREEN].dat;
for (ret=1; mapedit_dialog[ret].proc; ret++) {
mapedit_dialog[ret].fg = colors[black];
mapedit_dialog[ret].bg = ((mapedit_dialog[ret].proc==d_list_proc) ? colors[white] : colors[gray]);
}
mapedit_dialog[0].bg = colors[darkgray];
// Default game values
game.row_x = game.row_y = 25;
game.tiles = game.row_x * game.row_y;
game.turns = 10;
game.points_tile = 1;
game.points_city = 10;
game.fog = game.hide = 0xff;
game.cross = 0;
game.turn = -1;
game.turns = 10;
game.player = 0;
game.pane_x = game.pane_y = 0;
game.powerup_i=(unsigned short)-1;
game.powerup_v=0;
game.random=0xffff;
strcpy(game.name, "Scenario");
strcpy(game.description, "Scenario description");
// Default players values
for (ret=0; ret<8; ret++) {
sprintf(players[ret].name, "Player %d", ret);
players[ret].reser_t = players[ret].resou_t = players[ret].reser_c = players[ret].resou_c = players[ret].resources = players[ret].reserves = players[ret].points = 0;
players[ret].reser_max = 50;
players[ret].effect = 100;
}
player=0;
for (ret=0; ret<2500; ret++) {
matrix[ret].info = 0x08;
matrix[ret].fog = 0xff;
}
while (1) {
sprintf(x_sectors, "%d", game.row_x);
sprintf(y_sectors, "%d", game.row_y);
sprintf(turns, "%d", game.turns);
sprintf(sector_points, "%d", game.points_tile);
sprintf(base_points, "%d", game.points_city);
sprintf(strbuf, "Name #%d", player+1);
strcpy(play.name, players[player].name);
sprintf(play.reser_t, "%d", players[player].reser_t);
sprintf(play.resou_t, "%d", players[player].resou_t);
sprintf(play.reser_c, "%d", players[player].reser_c);
sprintf(play.resou_c, "%d", players[player].resou_c);
sprintf(play.resources, "%d", players[player].resources);
sprintf(play.reserves, "%d", players[player].reserves);
sprintf(play.points, "%d", players[player].points);
sprintf(play.reser_max, "%d", players[player].reser_max);
sprintf(play.effect, "%d", players[player].effect);
edit_dialog[B_FOG].flags = (game.fog ? 0 : D_SELECTED);
edit_dialog[B_HIDE].flags = (game.hide ? 0 : D_SELECTED);
edit_dialog[B_CROSS].flags = (game.cross ? D_SELECTED : 0);
show_mouse(screen);
ret = do_dialog(edit_dialog, -1);
switch (ret) {
case B_SAVE:
save_frame();
save_scenario(SL_SCENARIO);
break;
case B_LOAD:
load_scenario(SL_SCENARIO);
break;
case B_EXIT:
if (alert("Save the current scenario?", NULL, NULL, "&Yes", "&No", 'y', 'n')==1) save_scenario(SL_SCENARIO);
return;
case B_MAP:
save_frame();
for(ret=0; ret<game.tiles; ret++) matrix[ret].fog = 0xFF;
start_mapedit();
for(ret=0; ret<game.tiles; ret++) matrix[ret].fog = 0;
break;
case B_2NEXT:
save_frame();
players[(player+1)&0x07] = players[player];
break;
case B_2REST:
save_frame();
for (ret=player+1; ret<8; ret++) players[ret]=players[player];
break;
case B_2ALL:
save_frame();
for (ret=0; ret<8; ret++) players[ret]=players[player];
break;
case B_NEXT:
save_frame();
player++;
if (player>7) player=0;
break;
case B_PREV:
save_frame();
player--;
if (player<0) player=7;
break;
}
}
}
int main(int argc, char **argv) {
int ret;
char strbuf[256];
allegro_init();
set_color_depth(24);
if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0)) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Allegro says: %s\n", allegro_error);
return 1;
}
install_timer();
install_keyboard();
install_mouse();
if (install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL)==-1) printf("No sounds avaible.\n");
graph_init();
srand(time(0));
set_keyboard_rate(100, 150);
gui_bg_color = colors[gray];
gui_fg_color = colors[black];
LOCK_VARIABLE(counter);
LOCK_FUNCTION(game_timer);
install_int_ex(game_timer, BPS_TO_TIMER(6));
if (argv[0][0]!='\0') {
char *path;
for (path=argv[0]; *path; path++) /* nothing */;
if (path!=argv[0]) {
for (;*path!='/' && path>=argv[0]; path--);
path++;
*path = '\0';
chdir(argv[0]);
}
}
if ((datafile = load_datafile("data.dat"))==NULL) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Datafile data.dat not found\n");
return 1;
}
font = datafile[DATA_FONT].dat;
gui_font_baseline = 1;
main_dialog[0].bg = colors[darkgray];
main_dialog[1].dp = datafile[DATA_SCREEN].dat;
main_dialog[2].dp = datafile[DATA_LOGO].dat;
for (ret=1; main_dialog[ret].proc; ret++) {
main_dialog[ret].fg = colors[black];
main_dialog[ret].bg = colors[gray];
}
while(1) {
text_mode(-1);
switch (do_dialog(main_dialog, -1)) {
case DMAIN_START:
ret = start_game();
if (ret==GAME_ABORT) break;
if (ret==GAME_END) {
int i;
ret=0;
for (i=1; i<8; i++) if (players[i].points > players[ret].points) ret = i;
}
scare_mouse();
clear_to_color(screen, colors[darkgray]);
unscare_mouse();
sprintf(strbuf, "The winner is %s!!!", players[ret].name);
alert("GAME OVER", strbuf, NULL, "OK", NULL, 0, 0);
report();
break;
case DMAIN_EDIT:
start_editor();
break;
case DMAIN_EXIT:
remove_sound();
return 0;
}
}
return 0;
}
/* TODO: Take auth_entry from data. --jonas */
void
do_auth_dialog(struct session *ses, void *data)
{
/* [gettext_accelerator_context(do_auth_dialog)] */
struct dialog *dlg;
struct dialog_data *dlg_data;
struct terminal *term = ses->tab->term;
struct auth_entry *a = get_invalid_auth_entry();
unsigned char sticker[MAX_STR_LEN], *text;
int sticker_len;
if (!a || a->blocked) return;
text = get_uri_string(a->uri, URI_HTTP_AUTH);
if (!text) return;
#ifdef CONFIG_FORMHIST
{
unsigned char *user = get_form_history_value(text, (unsigned char *)"user");
unsigned char *password = get_form_history_value(text, (unsigned char *)"password");
if (user) {
strncpy((char *)a->user, (const char *)user, AUTH_USER_MAXLEN - 1);
}
if (password) {
strncpy((char *)a->password, (const char *)password, AUTH_PASSWORD_MAXLEN - 1);
}
}
#endif
sticker_len = snprintf((char *)sticker, sizeof(sticker),
(const char *)_("Authentication required for %s at %s", term),
a->realm, text);
mem_free(text);
if (sticker_len < 0 || sticker_len > MAX_STR_LEN) return;
#define AUTH_WIDGETS_COUNT 5
/* + 1 to leave room for the '\0'. */
dlg = calloc_dialog(AUTH_WIDGETS_COUNT, sticker_len + 1);
if (!dlg) return;
a->blocked = 1;
/* This function is used for at least HTTP and FTP, so don't
* name the protocol here. Consider also what an FTP server
* behind an HTTP proxy should be called. */
dlg->title = _("Authentication required", term);
dlg->layouter = generic_dialog_layouter;
text = get_dialog_offset(dlg, AUTH_WIDGETS_COUNT);
memcpy(text, sticker, sticker_len); /* calloc_dialog has stored '\0' */
dlg->udata = (void *) ses;
dlg->udata2 = a;
add_dlg_text(dlg, text, ALIGN_LEFT, 0);
add_dlg_field_float(dlg, _("Login", term), 0, 0, NULL, AUTH_USER_MAXLEN, a->user, NULL);
add_dlg_field_float_pass(dlg, _("Password", term), 0, 0, NULL, AUTH_PASSWORD_MAXLEN, a->password);
add_dlg_ok_button(dlg, _("~OK", term), B_ENTER, auth_ok, dlg);
add_dlg_ok_button(dlg, _("~Cancel", term), B_ESC, auth_cancel, a);
add_dlg_end(dlg, AUTH_WIDGETS_COUNT);
dlg_data = do_dialog(term, dlg, getml(dlg, (void *) NULL));
/* When there's some username, but no password, automagically jump to
* the password. */
if (dlg_data && a->user[0] && !a->password[0])
select_widget_by_id(dlg_data, 1);
}
int main(int argc, char *argv[])
{
char buf[256];
int i;
/* initialise everything */
if (allegro_init() != 0)
return 1;
install_keyboard();
install_mouse();
install_timer();
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0) != 0) {
if (set_gfx_mode(GFX_SAFE, 640, 480, 0, 0) != 0) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
return 1;
}
}
/* load the datafile */
replace_filename(buf, argv[0], "example.dat", sizeof(buf));
datafile = load_datafile(buf);
if (!datafile) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Error loading %s!\n", buf);
return 1;
}
set_palette(datafile[THE_PALETTE].dat);
/* set up colors */
gui_fg_color = makecol(0, 0, 0);
gui_mg_color = makecol(128, 128, 128);
gui_bg_color = makecol(200, 240, 200);
set_dialog_color(the_dialog, gui_fg_color, gui_bg_color);
/* white color for d_clear_proc and the d_?text_procs */
the_dialog[0].bg = makecol(255, 255, 255);
for (i = 4; the_dialog[i].proc; i++) {
if (the_dialog[i].proc == d_text_proc ||
the_dialog[i].proc == d_ctext_proc ||
the_dialog[i].proc == d_rtext_proc)
{
the_dialog[i].bg = the_dialog[0].bg;
}
}
/* fill in bitmap pointers */
the_dialog[BITMAP_OBJECT].dp = datafile[SILLY_BITMAP].dat;
the_dialog[ICON_OBJECT].dp = datafile[SILLY_BITMAP].dat;
/* shift the dialog 2 pixels away from the border */
position_dialog(the_dialog, 2, 2);
/* do the dialog */
do_dialog(the_dialog, -1);
unload_datafile(datafile);
return 0;
}
int do_options_dialog()
{
int
i,
ret;
static bool init_colors = true;
// initialize dialog
int
ply_settings[6] = {1, 2, 3, 4, 6, 8};
// colors
if (init_colors)
{
int
colors[3];
colors[0] = makecol(0,0,0);
colors[1] = makecol(200, 200, 200);
colors[2] = makecol(50, 50, 50);
for (i = 0; options_dialog[i].proc; i++)
{
options_dialog[i].fg = colors[options_dialog[i].fg];
options_dialog[i].bg = colors[options_dialog[i].bg];
}
init_colors = false;
}
// initialize dialog from global variables
for (i = FIRST_RADIO_PLY; i <= LAST_RADIO_PLY; i++)
{
if (ply == ply_settings[i - FIRST_RADIO_PLY])
{
options_dialog[i].flags |= D_SELECTED;
}
else
options_dialog[i].flags &= ~D_SELECTED;
}
if (computer_player[0])
{
options_dialog[FIRST_RADIO_PL1].flags &= ~D_SELECTED;
options_dialog[FIRST_RADIO_PL1 + 1].flags |= D_SELECTED;
}
else
{
options_dialog[FIRST_RADIO_PL1].flags |= D_SELECTED;
options_dialog[FIRST_RADIO_PL1 + 1].flags &= ~D_SELECTED;
}
if (computer_player[1])
{
options_dialog[FIRST_RADIO_PL2].flags &= ~D_SELECTED;
options_dialog[FIRST_RADIO_PL2 + 1].flags |= D_SELECTED;
}
else
{
options_dialog[FIRST_RADIO_PL2].flags |= D_SELECTED;
options_dialog[FIRST_RADIO_PL2 + 1].flags &= ~D_SELECTED;
}
// if any keys pressed, read it out
clear_kbd(KEY_ESC);
ret = do_dialog(options_dialog, -1);
clear_kbd(KEY_ESC);
// check out if the ok or cancel button was clicked
if (ret == OK_BUTTON)
{
// set all options
// find out which radio button was selected
for (i = FIRST_RADIO_PLY; i <= LAST_RADIO_PLY ; i++)
{
if (options_dialog[i].flags & D_SELECTED)
{
// set ply setting,
ply = ply_settings[i - FIRST_RADIO_PLY];
// allegro_message("Difficulty set to ply %d\n", ply);
break;
}
}
// find out player/computer settings
computer_player[0] =
!(options_dialog[FIRST_RADIO_PL1].flags & D_SELECTED);
computer_player[1] =
!(options_dialog[FIRST_RADIO_PL2].flags & D_SELECTED);
// save settings
file.save_settings();
}
// if we leave this dialog, go back to the game dialog.
// this can be recursive, but hopefully that will be ok.
return do_game_dialog();
}
static int setup (void)
{
#define RESOLUTION_LIST 4
#define COLOUR_LIST 6
#define ZBUFFER_LIST 8
#define WINDOWED_BOX 9
#define DOUBLEBUFFER_BOX 10
#define BUTTON_OK 11
DIALOG dlg[] = {
/* proc x y w h fg bg key flags d1 d2 dp */
{ d_shadow_box_proc, 0, 0, 320, 200, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL },
{ d_ctext_proc, 160, 10, 0, 0, 0, 0, 0, 0, 0, 0, "____________", NULL, NULL },
{ d_ctext_proc, 160, 8, 0, 0, 0, 0, 0, 0, 0, 0, "OpenGL Setup", NULL, NULL },
{ d_text_proc, 10, 30, 0, 0, 0, 0, 0, 0, 0, 0, "Resolution", NULL, NULL },
{ d_list_proc, 10, 40, 96, 52, 0, 0, 0, 0, 0, 0, resolution_lister, NULL, NULL },
{ d_text_proc, 120, 30, 0, 0, 0, 0, 0, 0, 0, 0, "Colour depth", NULL, NULL },
{ d_list_proc, 120, 40, 96, 48, 0, 0, 0, 0, 0, 0, colour_depth_lister, NULL, NULL },
{ d_text_proc, 10, 104, 96, 48, 0, 0, 0, 0, 0, 0, "Z buffer", NULL, NULL },
{ d_list_proc, 10, 114, 96, 48, 0, 0, 0, 0, 0, 0, zbuffer_depth_lister, NULL, NULL },
{ d_check_proc, 10, 170, 96, 8, 0, 0, 0, 0, 1, 0, "Windowed", NULL, NULL },
{ d_check_proc, 10, 180, 128, 8, 0, 0, 0,D_SELECTED, 1, 0, "Double Buffered", NULL, NULL },
{ d_button_proc, 220, 150, 96, 18, 0, 0, 0, D_EXIT, 0, 0, "Ok", NULL, NULL },
{ d_button_proc, 220, 174, 96, 18, 0, 0, 0, D_EXIT, 0, 0, "Exit", NULL, NULL },
{ d_yield_proc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL },
{ NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL }
};
int x;
if (mode == AGL_WINDOWED)
dlg[WINDOWED_BOX].flags |= D_SELECTED;
centre_dialog (dlg);
set_dialog_color (dlg, makecol(0, 0, 0), makecol(255, 255, 255));
if (secs) {
textprintf_centre_ex(screen, font, SCREEN_W / 2, SCREEN_H / 2 + 110,
makecol(255, 255, 255), 0,
"Frames: %i, Seconds: %i, FPS: %f",
frames, secs, (float)frames / (float)secs);
}
x = do_dialog (dlg, 4);
allegro_gl_clear_settings();
allegro_gl_set(AGL_COLOR_DEPTH, colour_depths[dlg[COLOUR_LIST].d1].depth);
allegro_gl_set(AGL_Z_DEPTH, zbuffer_depths[dlg[ZBUFFER_LIST].d1].depth);
allegro_gl_set(AGL_DOUBLEBUFFER,
(dlg[DOUBLEBUFFER_BOX].flags & D_SELECTED) ? 1 : 0);
allegro_gl_set(AGL_RENDERMETHOD, 1);
mode = ((dlg[WINDOWED_BOX].flags & D_SELECTED)
? AGL_WINDOWED : AGL_FULLSCREEN);
allegro_gl_set(mode, TRUE);
allegro_gl_set(AGL_SUGGEST, AGL_COLOR_DEPTH | AGL_Z_DEPTH
| AGL_DOUBLEBUFFER | AGL_RENDERMETHOD | mode);
width = resolutions[dlg[RESOLUTION_LIST].d1].w;
height = resolutions[dlg[RESOLUTION_LIST].d1].h;
return (x == BUTTON_OK);
}
static void block_edit_item(struct dialog_data *dlg, void *data, void (*ok_fn)(struct dialog_data *, void *, void *, struct list_description *), void *ok_arg, unsigned char dlg_title)
{
/*Copied from types.c */
/*Data is a new item generated by the "default" function*/
struct block *neww=(struct block*)data;
struct terminal *term=dlg->win->term;
struct dialog *d;
struct assoc_ok_struct *s;
unsigned char *url;
/*Allocate space for dialog, 4 items followed by 1 string*/
d = mem_alloc(sizeof(struct dialog) + 4 * sizeof(struct dialog_item) + 1 * MAX_STR_LEN);
memset(d, 0, sizeof(struct dialog) + 4 * sizeof(struct dialog_item) + 1 * MAX_STR_LEN);
/*Set up this string */
url=(unsigned char *)&d->items[4];
if (neww->url)safe_strncpy(url,neww->url,MAX_STR_LEN);
/* Create the dialog */
s = mem_alloc(sizeof(struct assoc_ok_struct));
s->fn=ok_fn;
s->data=ok_arg;
s->dlg=dlg;
switch (dlg_title)
{
case TITLE_EDIT:
d->title=TEXT_(T_BLOCK_EDIT);
break;
case TITLE_ADD:
d->title=TEXT_(T_BLOCK_ADD);
break;
default:
internal("Unsupported dialog title.\n");
}
d->udata=data;
d->udata2=s;
d->fn = block_edit_item_fn;
d->abort=block_edit_abort;
d->refresh=block_edit_done;
d->refresh_data = d;
d->items[0].type = D_FIELD;
d->items[0].dlen = MAX_STR_LEN;
d->items[0].data = url;
d->items[0].fn = check_nonempty;
d->items[1].type = D_BUTTON;
d->items[1].gid = B_ENTER;
d->items[1].fn = ok_dialog;
d->items[1].text = TEXT_(T_OK);
d->items[2].type = D_BUTTON;
d->items[2].gid = B_ESC;
d->items[2].text = TEXT_(T_CANCEL);
d->items[2].fn = cancel_dialog;
d->items[3].type = D_END;
do_dialog(term, d, getml(d, NULL));
}
int do_game_dialog()
{
int
i,
ret;
static bool first_time = true;
static bool init_colors = true;
// initialize dialog
// allegro_message("do_game_dialog: %d %d\n", first_time, init_colors);
// colors
if (init_colors)
{
int
colors[3];
colors[0] = makecol(0,0,0);
colors[1] = makecol(200, 200, 200);
colors[2] = makecol(50, 50, 50);
for (i = 0; game_dialog[i].proc; i++)
{
game_dialog[i].fg = colors[game_dialog[i].fg];
game_dialog[i].bg = colors[game_dialog[i].bg];
}
init_colors = false;
// also initialize the colors of the 'standard' allegro dialogs
gui_fg_color = colors[1];
gui_bg_color = colors[0];
}
// if any keys pressed, read it out
clear_kbd(KEY_ESC);
ret = do_dialog(game_dialog, -1);
clear_kbd(KEY_ESC);
// if user exited by escape, determine what to do.
if (ret < 0)
{
if (game_dialog[GAME_RESUME].flags & D_DISABLED)
ret = GAME_QUIT;
else
ret = GAME_RESUME;
}
// allegro_message("end game_dialog, return value %d\n", ret);
// reset quit flag, used to request this menu
quit = 0;
// check out if the resume game button was clicked
if (ret == GAME_RESUME)
{
return ret;
}
// check out if the new game button was clicked
if (ret == GAME_NEW)
{
// first time? enable resume game button
if (first_time)
{
game_dialog[GAME_RESUME].flags ^= D_DISABLED;
first_time = false; // we just started our first game
}
aap.init(); // reset the game board
draw.remember(aap); // don't flip stones upon first draw
logfile.init(); // reset the log
// load settings
// they are saved each time you leave the options menu,
// so it should be safe to load them for each new game too.
file.load_settings();
who = who_starts;
win_message = 0;
// leave other options as they are
return ret;
}
// check out if the resume game button was clicked
if (ret == GAME_OPTIONS)
{
// this is going to be a very scary recursive dialog thing
// but hopefully it will simply work :-) No guts, no glory.
clear_keybuf();
return do_options_dialog();
}
// quit button
if (ret == GAME_QUIT)
{
// shutdown graphics
draw.shutdown_graphics();
// end game, the rough way.
// correction. The rough way gives problems with destructors of
// string in the File object, apparently. Try the 'nice way'
// instead.
exit_program = 1;
return ret;
}
if (ret == GAME_SAVE)
{
// -1 = cancel, 0 = error
int sval = file.save(who, &aap, &logfile);
if (!sval)
{
allegro_message("An error occurred while saving the game.\n");
}
if (sval <= 0)
{
// error or cancel
return do_game_dialog();
}
return ret;
}
if (ret == GAME_LOAD)
{
int lval = file.load(who, &aap, &logfile);
if (!lval)
{
allegro_message("An error occurred while loading the game.\n");
}
if (lval <= 0)
{
// cancel or error
return do_game_dialog();
}
// success
draw.remember(aap);
// first time? enable resume game button
if (first_time)
{
game_dialog[GAME_RESUME].flags ^= D_DISABLED;
first_time = false; // we just started our first game
}
}
return ret;
}
int main(int argc, char *argv[])
{
static char config_override[] = "[system]\nkeyboard = \n";
RGB black_rgb = {0, 0, 0, 0};
DATAFILE *font_data;
int c;
if (allegro_init() != 0)
exit(EXIT_FAILURE);
if (argc > 1) {
if (strcmp(argv[1], "--split-altgr") == 0) {
split_altgr = TRUE;
}
else {
allegro_message("Error: unrecognized option\n");
exit(EXIT_FAILURE);
}
}
install_mouse();
install_timer();
push_config_state();
override_config_data(config_override, sizeof(config_override));
install_keyboard();
pop_config_state();
memcpy(orig_key_ascii_table, _key_ascii_table, sizeof(orig_key_ascii_table));
memcpy(orig_key_capslock_table, _key_capslock_table, sizeof(orig_key_capslock_table));
memcpy(orig_key_shift_table, _key_shift_table, sizeof(orig_key_shift_table));
memcpy(orig_key_control_table, _key_control_table, sizeof(orig_key_control_table));
memcpy(orig_key_altgr_lower_table, _key_altgr_lower_table, sizeof(orig_key_altgr_lower_table));
memcpy(orig_key_altgr_upper_table, _key_altgr_upper_table, sizeof(orig_key_altgr_upper_table));
memcpy(orig_key_accent1_lower_table, _key_accent1_lower_table, sizeof(orig_key_accent1_lower_table));
memcpy(orig_key_accent1_upper_table, _key_accent1_upper_table, sizeof(orig_key_accent1_upper_table));
memcpy(orig_key_accent2_lower_table, _key_accent2_lower_table, sizeof(orig_key_accent2_lower_table));
memcpy(orig_key_accent2_upper_table, _key_accent2_upper_table, sizeof(orig_key_accent2_upper_table));
memcpy(orig_key_accent3_lower_table, _key_accent3_lower_table, sizeof(orig_key_accent3_lower_table));
memcpy(orig_key_accent3_upper_table, _key_accent3_upper_table, sizeof(orig_key_accent3_upper_table));
memcpy(orig_key_accent4_lower_table, _key_accent4_lower_table, sizeof(orig_key_accent4_lower_table));
memcpy(orig_key_accent4_upper_table, _key_accent4_upper_table, sizeof(orig_key_accent4_upper_table));
memcpy(my_key_ascii_table, _key_ascii_table, sizeof(my_key_ascii_table));
memcpy(my_key_capslock_table, _key_capslock_table, sizeof(my_key_capslock_table));
memcpy(my_key_shift_table, _key_shift_table, sizeof(my_key_shift_table));
memcpy(my_key_control_table, _key_control_table, sizeof(my_key_control_table));
memcpy(my_key_altgr_lower_table, _key_altgr_lower_table, sizeof(my_key_altgr_lower_table));
memcpy(my_key_altgr_upper_table, _key_altgr_upper_table, sizeof(my_key_altgr_upper_table));
memcpy(my_key_accent1_lower_table, _key_accent1_lower_table, sizeof(my_key_accent1_lower_table));
memcpy(my_key_accent1_upper_table, _key_accent1_upper_table, sizeof(my_key_accent1_upper_table));
memcpy(my_key_accent2_lower_table, _key_accent2_lower_table, sizeof(my_key_accent2_lower_table));
memcpy(my_key_accent2_upper_table, _key_accent2_upper_table, sizeof(my_key_accent2_upper_table));
memcpy(my_key_accent3_lower_table, _key_accent3_lower_table, sizeof(my_key_accent3_lower_table));
memcpy(my_key_accent3_upper_table, _key_accent3_upper_table, sizeof(my_key_accent3_upper_table));
memcpy(my_key_accent4_lower_table, _key_accent4_lower_table, sizeof(my_key_accent4_lower_table));
memcpy(my_key_accent4_upper_table, _key_accent4_upper_table, sizeof(my_key_accent4_upper_table));
_key_ascii_table = my_key_ascii_table;
_key_capslock_table = my_key_capslock_table;
_key_shift_table = my_key_shift_table;
_key_control_table = my_key_control_table;
_key_altgr_lower_table = my_key_altgr_lower_table;
_key_altgr_upper_table = my_key_altgr_upper_table;
_key_accent1_lower_table = my_key_accent1_lower_table;
_key_accent1_upper_table = my_key_accent1_upper_table;
_key_accent2_lower_table = my_key_accent2_lower_table;
_key_accent2_upper_table = my_key_accent2_upper_table;
_key_accent3_lower_table = my_key_accent3_lower_table;
_key_accent3_upper_table = my_key_accent3_upper_table;
_key_accent4_lower_table = my_key_accent4_lower_table;
_key_accent4_upper_table = my_key_accent4_upper_table;
edit_menu[0].dp = _key_ascii_table;
edit_menu[1].dp = _key_capslock_table;
edit_menu[2].dp = _key_shift_table;
edit_menu[3].dp = _key_control_table;
edit_menu[4].dp = _key_altgr_lower_table;
edit_menu[5].dp = _key_altgr_upper_table;
edit_menu[6].dp = _key_accent1_lower_table;
edit_menu[7].dp = _key_accent1_upper_table;
edit_menu[8].dp = _key_accent2_lower_table;
edit_menu[9].dp = _key_accent2_upper_table;
edit_menu[10].dp = _key_accent3_lower_table;
edit_menu[11].dp = _key_accent3_upper_table;
edit_menu[12].dp = _key_accent4_lower_table;
edit_menu[13].dp = _key_accent4_upper_table;
if (!split_altgr)
edit_menu[5].flags = D_DISABLED;
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0) != 0) {
if (set_gfx_mode(GFX_SAFE, 640, 480, 0, 0) != 0) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
return 1;
}
}
set_palette(desktop_palette);
set_color(0, &black_rgb);
gui_fg_color = palette_color[255];
gui_bg_color = palette_color[16];
/* We set up colors to match screen color depth (in case it changed) */
for (c = 0; main_dlg[c].proc; c++) {
main_dlg[c].fg = palette_color[main_dlg[c].fg];
main_dlg[c].bg = palette_color[main_dlg[c].bg];
}
for (c = 0; ascii_dlg[c].proc; c++) {
ascii_dlg[c].fg = palette_color[ascii_dlg[c].fg];
ascii_dlg[c].bg = palette_color[ascii_dlg[c].bg];
}
for (c = 0; editor_dlg[c].proc; c++) {
editor_dlg[c].fg = palette_color[editor_dlg[c].fg];
editor_dlg[c].bg = palette_color[editor_dlg[c].bg];
}
for (c = 0; accent_dlg[c].proc; c++) {
accent_dlg[c].fg = palette_color[accent_dlg[c].fg];
accent_dlg[c].bg = palette_color[accent_dlg[c].bg];
}
_key_standard_kb = FALSE;
font_data = load_datafile_object ("keyconf.dat", "BASE_FONT");
if (font_data)
font = font_data->dat;
do_dialog(main_dlg, -1);
if (font_data)
unload_datafile_object(font_data);
return 0;
}
/* accent setting function */
int accenter(char *title, int flag)
{
int ret;
accent_dlg[1].dp = title;
accent_dlg[2].d2 = 0;
accent_dlg[6].flags = accent_dlg[7].flags = 0;
accent_dlg[8].flags = accent_dlg[9].flags = 0;
if (flag == KB_ACCENT1_FLAG) {
accent_dlg[2].d1 = _key_accent1;
if (_key_accent1_flag == 0) accent_dlg[6].flags = D_SELECTED;
else if (_key_accent1_flag == 1) accent_dlg[7].flags = D_SELECTED;
else if (_key_accent1_flag == 2) accent_dlg[8].flags = D_SELECTED;
else if (_key_accent1_flag == 4) accent_dlg[9].flags = D_SELECTED;
}
else if (flag == KB_ACCENT2_FLAG) {
accent_dlg[2].d1 = _key_accent2;
if (_key_accent2_flag == 0) accent_dlg[6].flags = D_SELECTED;
else if (_key_accent2_flag == 1) accent_dlg[7].flags = D_SELECTED;
else if (_key_accent2_flag == 2) accent_dlg[8].flags = D_SELECTED;
else if (_key_accent2_flag == 4) accent_dlg[9].flags = D_SELECTED;
}
else if (flag == KB_ACCENT3_FLAG) {
accent_dlg[2].d1 = _key_accent3;
if (_key_accent3_flag == 0) accent_dlg[6].flags = D_SELECTED;
else if (_key_accent3_flag == 1) accent_dlg[7].flags = D_SELECTED;
else if (_key_accent3_flag == 2) accent_dlg[8].flags = D_SELECTED;
else if (_key_accent3_flag == 4) accent_dlg[9].flags = D_SELECTED;
}
else if (flag == KB_ACCENT4_FLAG) {
accent_dlg[2].d1 = _key_accent4;
if (_key_accent4_flag == 0) accent_dlg[6].flags = D_SELECTED;
else if (_key_accent4_flag == 1) accent_dlg[7].flags = D_SELECTED;
else if (_key_accent4_flag == 2) accent_dlg[8].flags = D_SELECTED;
else if (_key_accent4_flag == 4) accent_dlg[9].flags = D_SELECTED;
}
ret = do_dialog(accent_dlg, -1);
if ((ret == 2) || (ret == 3)) {
if (flag == KB_ACCENT1_FLAG) {
_key_accent1 = accent_dlg[2].d1;
if (accent_dlg[6].flags & D_SELECTED) _key_accent1_flag = 0;
else if (accent_dlg[7].flags & D_SELECTED) _key_accent1_flag = 1;
else if (accent_dlg[8].flags & D_SELECTED) _key_accent1_flag = 2;
else if (accent_dlg[9].flags & D_SELECTED) _key_accent1_flag = 4;
}
else if (flag == KB_ACCENT2_FLAG) {
_key_accent2 = accent_dlg[2].d1;
if (accent_dlg[6].flags & D_SELECTED) _key_accent2_flag = 0;
else if (accent_dlg[7].flags & D_SELECTED) _key_accent2_flag = 1;
else if (accent_dlg[8].flags & D_SELECTED) _key_accent2_flag = 2;
else if (accent_dlg[9].flags & D_SELECTED) _key_accent2_flag = 4;
}
else if (flag == KB_ACCENT3_FLAG) {
_key_accent3 = accent_dlg[2].d1;
if (accent_dlg[6].flags & D_SELECTED) _key_accent3_flag = 0;
else if (accent_dlg[7].flags & D_SELECTED) _key_accent3_flag = 1;
else if (accent_dlg[8].flags & D_SELECTED) _key_accent3_flag = 2;
else if (accent_dlg[9].flags & D_SELECTED) _key_accent3_flag = 4;
}
else if (flag == KB_ACCENT4_FLAG) {
_key_accent4 = accent_dlg[2].d1;
if (accent_dlg[6].flags & D_SELECTED) _key_accent4_flag = 0;
else if (accent_dlg[7].flags & D_SELECTED) _key_accent4_flag = 1;
else if (accent_dlg[8].flags & D_SELECTED) _key_accent4_flag = 2;
else if (accent_dlg[9].flags & D_SELECTED) _key_accent4_flag = 4;
}
}
return D_REDRAW;
}
static void
run(const gchar *name
, gint nparams
, const GimpParam *param
, gint *nreturn_vals
, GimpParam **return_vals)
{
wr_huesat_val_t l_cuvals;
WrDialog *wcd = NULL;
gint32 l_image_id = -1;
gint32 l_drawable_id = -1;
gint32 l_handled_drawable_id = -1;
/* Get the runmode from the in-parameters */
GimpRunMode run_mode = param[0].data.d_int32;
/* status variable, use it to check for errors in invocation usualy only
during non-interactive calling */
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
/*always return at least the status to the caller. */
static GimpParam values[2];
INIT_I18N();
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_DRAWABLE;
values[1].data.d_int32 = -1;
*nreturn_vals = 2;
*return_vals = values;
/* the Iterator Stuff */
if (strcmp (name, PLUG_IN_ITER_NAME) == 0)
{
gint32 len_struct;
gint32 total_steps;
gdouble current_step;
wr_huesat_val_t cval; /* current values while iterating */
wr_huesat_val_t cval_from, cval_to; /* start and end values */
/* Iterator procedure for animated calls is usually called from
* "plug_in_gap_layers_run_animfilter"
* (always run noninteractive)
*/
if ((run_mode == GIMP_RUN_NONINTERACTIVE) && (nparams == 4))
{
total_steps = param[1].data.d_int32;
current_step = param[2].data.d_float;
len_struct = param[3].data.d_int32;
if(len_struct == sizeof(cval))
{
/* get _FROM and _TO data,
* This data was stored by plug_in_gap_layers_run_animfilter
*/
gimp_get_data(PLUG_IN_DATA_ITER_FROM, &cval_from);
gimp_get_data(PLUG_IN_DATA_ITER_TO, &cval_to);
memcpy(&cval, &cval_from, sizeof(cval));
p_delta_gint32 (&cval.hue_range, cval_from.hue_range, cval_to.hue_range, total_steps, current_step);
p_delta_gdouble(&cval.hue_offset, cval_from.hue_offset, cval_to.hue_offset, total_steps, current_step);
p_delta_gdouble(&cval.lightness, cval_from.lightness, cval_to.lightness, total_steps, current_step);
p_delta_gdouble(&cval.saturation, cval_from.saturation, cval_to.saturation, total_steps, current_step);
gimp_set_data(PLUG_IN_NAME, &cval, sizeof(cval));
}
else status = GIMP_PDB_CALLING_ERROR;
}
else status = GIMP_PDB_CALLING_ERROR;
values[0].data.d_status = status;
return;
}
/* get image and drawable */
l_image_id = param[1].data.d_int32;
l_drawable_id = param[2].data.d_drawable;
if(status == GIMP_PDB_SUCCESS)
{
/* how are we running today? */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Initial values */
l_cuvals.hue_range = 0;
l_cuvals.hue_offset = 0;
l_cuvals.lightness = 0;
l_cuvals.saturation = 0;
/* Get information from the dialog */
wcd = do_dialog(&l_cuvals);
wcd->show_progress = TRUE;
break;
case GIMP_RUN_NONINTERACTIVE:
/* check to see if invoked with the correct number of parameters */
if (nparams >= 7)
{
wcd = g_malloc (sizeof (WrDialog));
wcd->run = TRUE;
wcd->show_progress = FALSE;
l_cuvals.hue_range = param[3].data.d_int32;
l_cuvals.hue_offset = param[4].data.d_float;
l_cuvals.lightness = param[5].data.d_float;
l_cuvals.saturation = param[6].data.d_float;
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
wcd = g_malloc (sizeof (WrDialog));
wcd->run = TRUE;
wcd->show_progress = TRUE;
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_NAME, &l_cuvals);
break;
default:
break;
}
}
if (wcd == NULL)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
/* Run the main function */
if(wcd->run)
{
gimp_image_undo_group_start (l_image_id);
p_run_huesat_tool(l_drawable_id, &l_cuvals);
l_handled_drawable_id = l_drawable_id;
gimp_image_undo_group_end (l_image_id);
/* Store variable states for next run */
if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_set_data(PLUG_IN_NAME, &l_cuvals, sizeof(l_cuvals));
}
}
else
{
status = GIMP_PDB_EXECUTION_ERROR; /* dialog ended with cancel button */
}
/* If run mode is interactive, flush displays, else (script) don't
do it, as the screen updates would make the scripts slow */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
{
gimp_displays_flush ();
}
}
values[0].data.d_status = status;
values[1].data.d_int32 = l_handled_drawable_id; /* return the id of handled layer */
} /* end run */
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ¿
// do_mtl ³
// ³
// Do material's dialog. ³
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ�
void do_mtl()
{
int sizex, sizey;
Editable *e;
static int inited = 0;
char buff[32];
if (! inited)
{
init_dialog(EschMtl, EschMtl_edit, NULL);
inited = 1;
}
loop_done=0;
EschMtl[PALETTE].text=mtl_palname;
EschMtl[PALETTE].radio=0;
EschMtl[COMPRESS].radio = (mtl_compress) ? 1 : 0;
ready_dialog(EschMtl, EschMtl_edit, NULL, EschMtl_feel, EschMtl_rad,
NULL, NULL);
sprintf(buff,"%d",mtl_sizex);
init_editable(&EschMtl[SIZEX], buff);
sprintf(buff,"%d",mtl_sizey);
init_editable(&EschMtl[SIZEY], buff);
startover:
;
while (!loop_done)
{
center_dialog(EschMtl);
save_under_dialog(EschMtl);
draw_dialog(EschMtl);
do_dialog(EschMtl, -1);
}
e=(Editable*)EschMtl[SIZEX].text;
sizex=atoi(e->string);
switch(sizex) {
case 16:
case 32:
case 64:
case 128:
case 256:
break;
default:
gfx_continu_line("X Size must be 16, 32, 64, 128, or 256");
loop_done=0;
goto startover;
}
e=(Editable*)EschMtl[SIZEY].text;
sizey=atoi(e->string);
switch(sizey) {
case 16:
case 32:
case 64:
case 128:
case 256:
break;
default:
gfx_continu_line("Y Size must be 16, 32, 64, 128, or 256");
loop_done=0;
goto startover;
}
mtl_sizex=sizex;
mtl_sizey=sizey;
mtl_compress = (EschMtl[COMPRESS].radio) ? 1 : 0;
}
static Boolean
do_choice(Widget w,
SharedFontSelData *data,
XmListCallbackStruct *call_data,
enum ListSpecifier which)
{
char *sel;
XmStringGetLtoR(call_data->item, XmSTRING_DEFAULT_CHARSET, &sel);
if (!data->sel[which])
data->sel[which] = XtNewString(sel);
else
{
XtFree(data->sel[which]);
if (!strcmp(data->sel[which], sel))
{
/* unselecting current selection */
data->sel[which] = NULL;
if (w)
XmListDeselectItem(w, call_data->item);
}
else
data->sel[which] = XtNewString(sel);
}
XtFree(sel);
fill_lists(which, data);
/* If there is a font selection, we display it. */
if (data->sel[ENCODING]
&& data->sel[NAME]
&& data->sel[STYLE]
&& data->sel[SIZE]
&& strcmp(data->sel[ENCODING], wild)
&& strcmp(data->sel[NAME], wild)
&& strcmp(data->sel[STYLE], wild)
&& strcmp(data->sel[SIZE], wild))
{
int i;
if (data->font_name)
XtFree(data->font_name);
data->font_name = NULL;
for (i = 0; i < data->num; i++)
{
if (match(data, ENCODING, i)
&& match(data, NAME, i)
&& match(data, STYLE, i)
&& match(data, SIZE, i))
{
data->font_name = XtNewString(fn(data, i));
break;
}
}
if (data->font_name)
{
XmTextSetString(data->name, data->font_name);
display_sample(data);
}
else
do_dialog(VIM_ERROR,
(char_u *)_("Error"),
(char_u *)_("Invalid font specification"),
(char_u *)_("&Dismiss"), 1, NULL);
return True;
}
else
{
int n;
XmString str;
Arg args[4];
char *msg = _("no specific match");
n = 0;
str = XmStringCreateLocalized(msg);
XtSetArg(args[n], XmNlabelString, str); ++n;
XtSetValues(data->sample, args, n);
apply_fontlist(data->sample);
XmTextSetString(data->name, msg);
XmStringFree(str);
return False;
}
}
