void
pause(int t)
{
int s;
Alt alts[NALT+1];
alts[TIMER].c = timerc;
alts[TIMER].v = nil;
alts[TIMER].op = CHANRCV;
alts[SUSPEND].c = suspc;
alts[SUSPEND].v = &s;
alts[SUSPEND].op = CHANRCV;
alts[RESHAPE].c = mousectl->resizec;
alts[RESHAPE].v = nil;
alts[RESHAPE].op = CHANRCV;
// avoid hanging up those writing ong mousec and kbdc
// so just accept it all and keep mouse up-to-date
alts[MOUSE].c = mousec;
alts[MOUSE].v = &mouse;
alts[MOUSE].op = CHANRCV;
alts[KBD].c = kbdc;
alts[KBD].v = nil;
alts[KBD].op = CHANRCV;
alts[NALT].op = CHANEND;
flushimage(display, 1);
for(;;)
switch(alt(alts)){
case SUSPEND:
if (!suspended && s) {
suspend(1);
} else if (suspended && !s) {
suspend(0);
lastmx = warp(mouse.xy, lastmx);
}
break;
case TIMER:
if(suspended)
break;
if((t -= tsleep) < 0)
return;
break;
case RESHAPE:
redraw(1);
break;
}
}
// Keymapper - a single instance of this class is used to generate Windows key
// events.
void doKeyEventWithModifiers(BYTE vkCode, BYTE modifierState, bool down)
{
KeyStateModifier ctrl(VK_CONTROL);
KeyStateModifier alt(VK_MENU);
KeyStateModifier shift(VK_SHIFT);
if (down) {
if (modifierState & 2) ctrl.press();
if (modifierState & 4) alt.press();
if (modifierState & 1) {
shift.press();
} else {
shift.release();
}
}
doKeyboardEvent(vkCode, down ? 0 : KEYEVENTF_KEYUP);
}
pl_consonne_1 (struct coroutine *k, expr a0)
{
expr nx[MAX_NEW_CONS];
int pnx, i;
struct process_list *alt_process;
pnx = 0;
begin_decl ();
decl_expr (&a0);
for (i=0; i<MAX_NEW_CONS; i++)
dle (nx[i]);
#ifdef TRACE
printf ("\nconsonne: a0 = "); print_expr (a0);
#endif
if (alt (k, 1, 0))
{
/* clause */
expr val_X, var_X;
alt_process = getpl (k) -> alt;
dle(val_X) dle(var_X)
val_X=UNDEF; var_X=mk_var(&val_X);
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, var_X, a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
pl_lettre_1 (k, var_X);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
pl_non_voyelle_1 (k, var_X);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, var_X);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
end (k);
free_expr ();
}
RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& desc, const Font* originalFontData, bool isPlatformFont, const UChar* characters, unsigned int length)
{
ASSERT(characters && (length==1||length==2));
UChar32 c = 0;
if (length==1) {
c = characters[0];
} else {
c = U16_GET_SUPPLEMENTARY(characters[0], characters[1]);
}
FontPlatformData alt(desc, desc.familyAt(0));
if (alt.font() && alt.font()->font()) {
alt.font()->setSpecificUnicodeChar(c);
return fontForPlatformData(alt);
} else {
return lastResortFallbackFont(desc);
}
}
void
writer(void *arg)
{
int lastpid;
Alt a[4];
Msg *s;
lastpid = (int)(uintptr)arg;
a[0].op = CHANRCV;
a[0].c = quit;
a[0].v = nil;
a[1].op = CHANRCV;
a[1].c = out;
a[1].v = &s;
a[2].op = CHANRCV;
a[2].c = forkc;
a[2].v = nil;
a[3].op = CHANEND;
for(;;)
switch(alt(a)){
case 0:
nread--;
if(nread <= 0)
goto done;
break;
case 1:
if(s->pid != lastpid){
lastpid = s->pid;
fprint(2, s->buf[1]=='='? "\n%d ...": "\n", lastpid);
}
fprint(2, "%s", s->buf);
free(s);
break;
case 2:
nread++;
break;
}
done:
exits(nil);
}
void
xfidallocthread(void *v)
{
Xfid *xfree, *x;
enum { Alloc, Free, N };
static Alt alts[N+1];
USED(v);
threadsetname("xfidallocthread");
alts[Alloc].c = cxfidalloc;
alts[Alloc].v = nil;
alts[Alloc].op = CHANRCV;
alts[Free].c = cxfidfree;
alts[Free].v = &x;
alts[Free].op = CHANRCV;
alts[N].op = CHANEND;
xfree = nil;
for(;;){
switch(alt(alts)){
case Alloc:
x = xfree;
if(x)
xfree = x->next;
else{
x = emalloc(sizeof(Xfid));
x->c = chancreate(sizeof(void(*)(Xfid*)), 0);
chansetname(x->c, "xc%p", x->c);
x->arg = x;
threadcreate(xfidctl, x->arg, STACK);
}
sendp(cxfidalloc, x);
break;
case Free:
x->next = xfree;
xfree = x;
break;
}
}
}
void
writer(void *)
{
Alt a[4];
Str *s;
int newpid;
a[0].op = CHANRCV;
a[0].c = quit;
a[0].v = nil;
a[1].op = CHANRCV;
a[1].c = out;
a[1].v = &s;
a[2].op = CHANRCV;
a[2].c = forkc;
a[2].v = &newpid;
a[3].op = CHANEND;
for(;;) {
switch(alt(a)){
case 0:
nread--;
if(nread <= 0)
goto done;
break;
case 1:
/* it's a nice null terminated thing */
fprint(2, "%s", s->buf);
free(s);
break;
case 2:
// procrfork(reader, (void*)newpid, 8192, 0);
nread++;
break;
}
}
done:
exits(nil);
}
/////////////////////////////////////////////////////////////////////////////
// test threads
/////////////////////////////////////////////////////////////////////////////
static void ThreadsTest()
{
CPLog1D problem;
CResults results(problem.GetDimensions());
// CSPUniform sp(problem.GetDimensions());
#if 0
CPFQuadratic pf(problem.GetDimensions());
CRegression reg(results, pf);
reg.SetRefreshRate(0.1);
reg.SetLocalizationHeight(2.0);
CMERegressionMAPMax me(reg);
CDFVarianceSamples var(reg, 1);
var.SetMinSamples(problem.GetDimensions());
CSPVOptimal sp(reg, var, 0);
CArtificialExperiment artexp(problem, sp, me, results);
#else
//CCrossEntropy alt(results, 0.9);
//CSPSA alt(results);
CRSPSA alt(results);
CArtificialExperiment artexp(problem, alt, alt, results);
#endif
CCPLConsole cplc;
CRepeatThreads rts(79, 100000, &cplc);
rts.AddThread(artexp);
CPLog1D problemBis;
CResults resultsBis(problemBis.GetDimensions());
CRSPSA altBis(resultsBis);
CArtificialExperiment artexpBis(problemBis, altBis, altBis, resultsBis);
rts.AddThread(artexpBis);
rts.Start();
rts.WaitForTermination();
}
void
writer(void *v)
{
int newpid;
Alt a[4];
Str *s;
a[0].op = CHANRCV;
a[0].c = quit;
a[0].v = nil;
a[1].op = CHANRCV;
a[1].c = out;
a[1].v = &s;
a[2].op = CHANRCV;
a[2].c = forkc;
a[2].v = &newpid;
a[3].op = CHANEND;
for(;;)
switch(alt(a)){
case 0: /* quit */
nread--;
if(nread <= 0)
goto done;
break;
case 1: /* out */
fprint(outf, "%s", s->buf);
free(s);
break;
case 2: /* forkc */
// procrfork(reader, (void*)newpid, Stacksize, 0);
nread++;
break;
}
done:
exits(nil);
}
static int
runop(int op, Channel *c, void *v, int nb)
{
int r;
Alt a[2];
/*
* we could do this without calling alt,
* but the only reason would be performance,
* and i'm not convinced it matters.
*/
a[0].op = op;
a[0].c = c;
a[0].v = v;
a[0].err = nil;
a[1].op = CHANEND;
if(nb)
a[1].op = CHANNOBLK;
switch(r=alt(a)){
case -1: /* interrupted */
return -1;
case 1: /* nonblocking, didn't accomplish anything */
assert(nb);
return 0;
case 0:
/*
* Okay, but return -1 if the op is done because of a close.
*/
if(a[0].err != nil)
return -1;
return 1;
default:
fprint(2, "ERROR: channel alt returned %d\n", r);
abort();
return -1;
}
}
static void
loop(void)
{
Rune r;
int n;
Alt a[] = {
{mc->c, &mc->Mouse, CHANRCV},
{kc->c, &r, CHANRCV},
{mc->resizec, &n, CHANRCV},
{nil, nil, CHANEND}
};
for(;;){
flushimage(display, 1);
switch(alt(a)){
case 0:
if((mc->buttons & 1) != 0)
winclick(mc);
if((mc->buttons & 2) != 0)
if(actw != nil && actw->tab->menu != nil)
actw->tab->menu(actw, mc);
if((mc->buttons & 4) != 0)
if(rmb() < 0)
return;
break;
case 1:
if(actw != nil && actw->tab->key != nil)
actw->tab->key(actw, r);
break;
case 2:
resize();
break;
}
}
}
Node *regexp(void) /* top-level parse of reg expr */
{
return (alt(concat(primary())));
}
void
winctl(void *arg)
{
print_func_entry();
Rune *rp, *bp, *kbdr;
int nr, nb, c, wid, i, npart, lastb;
char *s, *t, part[3];
Window *w;
Mousestate *mp, m;
enum { WKey, WMouse, WMouseread, WCtl, WCwrite, WCread, WWread, NWALT };
Alt alts[NWALT+1];
int walt;
Mousereadmesg mrm;
Conswritemesg cwm;
Consreadmesg crm;
Consreadmesg cwrm;
Stringpair pair;
Wctlmesg wcm;
char buf[4*12+1];
w = arg;
snprint(buf, sizeof buf, "winctl-id%d", w->id);
threadsetname(buf);
mrm.cm = chancreate(sizeof(Mouse), 0);
cwm.cw = chancreate(sizeof(Stringpair), 0);
crm.c1 = chancreate(sizeof(Stringpair), 0);
crm.c2 = chancreate(sizeof(Stringpair), 0);
cwrm.c1 = chancreate(sizeof(Stringpair), 0);
cwrm.c2 = chancreate(sizeof(Stringpair), 0);
alts[WKey].c = w->ck;
alts[WKey].v = &kbdr;
alts[WKey].op = CHANRCV;
alts[WMouse].c = w->mc.c;
alts[WMouse].v = &w->mc.Mouse;
alts[WMouse].op = CHANNOP; // XXXCHANRCV;
alts[WMouseread].c = w->mouseread;
alts[WMouseread].v = &mrm;
alts[WMouseread].op = CHANNOP; // XXXCHANSND;
alts[WCtl].c = w->cctl;
alts[WCtl].v = &wcm;
alts[WCtl].op = CHANRCV;
alts[WCwrite].c = w->conswrite;
alts[WCwrite].v = &cwm;
alts[WCwrite].op = CHANSND;
alts[WCread].c = w->consread;
alts[WCread].v = &crm;
alts[WCread].op = CHANSND;
alts[WWread].c = w->wctlread;
alts[WWread].v = &cwrm;
alts[WWread].op = CHANSND;
alts[NWALT].op = CHANEND;
npart = 0;
lastb = -1;
for(;;){
// TODO: mouses
if(0 && w->mouseopen && w->mouse.counter != w->mouse.lastcounter)
alts[WMouseread].op = CHANSND;
else
alts[WMouseread].op = CHANNOP;
if(w->deleted || !w->wctlready)
alts[WWread].op = CHANNOP;
else
alts[WWread].op = CHANSND;
/* this code depends on NL and EOT fitting in a single byte */
/* kind of expensive for each loop; worth precomputing? */
/*if(w->holding)
alts[WCread].op = CHANNOP;
else*/ if(npart || (w->rawing && w->nraw>0))
alts[WCread].op = CHANSND;
else
{
alts[WCread].op = CHANNOP;
for(i=w->qh; i<w->nr; i++){
c = w->run[i];
if(c=='\n' || c=='\004'){
alts[WCread].op = CHANSND;
break;
}
}
}
walt = alt(alts);
switch(walt){
case WKey:
for(i=0; kbdr[i]!=L'\0'; i++)
wkeyctl(w, kbdr[i]);
//wkeyctl(w, r);
/// while(nbrecv(w->ck, &r))
//wkeyctl(w, r);
break;
case WMouse:
if(w->mouseopen) {
w->mouse.counter++;
/* queue click events */
if(!w->mouse.qfull && lastb != w->mc.buttons) { /* add to ring */
mp = &w->mouse.queue[w->mouse.wi];
if(++w->mouse.wi == nelem(w->mouse.queue))
w->mouse.wi = 0;
if(w->mouse.wi == w->mouse.ri)
w->mouse.qfull = TRUE;
mp->Mouse = w->mc.Mouse;
mp->counter = w->mouse.counter;
lastb = w->mc.buttons;
}
} else
fprint(2, "MOUSECTL\n"); //wmousectl(w);
break;
case WMouseread:
/* send a queued event or, if the queue is empty, the current state */
/* if the queue has filled, we discard all the events it contained. */
/* the intent is to discard frantic clicking by the user during long latencies. */
w->mouse.qfull = FALSE;
if(w->mouse.wi != w->mouse.ri) {
m = w->mouse.queue[w->mouse.ri];
if(++w->mouse.ri == nelem(w->mouse.queue))
w->mouse.ri = 0;
} else
m = (Mousestate){w->mc.Mouse, w->mouse.counter};
w->mouse.lastcounter = m.counter;
send(mrm.cm, &m.Mouse);
continue;
case WCtl:
exits("WCtl can't do");
#if 0
if(wctlmesg(w, wcm.type, wcm.r, wcm.image) == Exited){
chanfree(crm.c1);
chanfree(crm.c2);
chanfree(mrm.cm);
chanfree(cwm.cw);
chanfree(cwrm.c1);
chanfree(cwrm.c2);
threadexits(nil);
}
#endif
continue;
case WCwrite:
recv(cwm.cw, &pair);
rp = pair.s;
nr = pair.ns;
bp = rp;
for(i=0; i<nr; i++) {
// See rio for the run conversion crap. For now, I'm not going to
// worry about it. This is designed to target Akaros too.
fprint(/*w->Console->out*/1, "%c", *bp++);
}
free(rp);
break;
case WCread:
recv(crm.c1, &pair);
t = pair.s;
nb = pair.ns;
i = npart;
npart = 0;
if(i)
memmove(t, part, i);
while(i<nb && (w->qh<w->nr || w->nraw>0)){
if(w->qh == w->nr){
wid = runetochar(t+i, &w->raw[0]);
w->nraw--;
runemove(w->raw, w->raw+1, w->nraw);
}else
wid = runetochar(t+i, &w->run[w->qh++]);
c = t[i]; /* knows break characters fit in a byte */
i += wid;
if(!w->rawing && (c == '\n' || c=='\004')){
if(c == '\004')
i--;
break;
}
}
if(i==nb && w->qh<w->nr && w->run[w->qh]=='\004')
w->qh++;
if(i > nb){
npart = i-nb;
memmove(part, t+nb, npart);
i = nb;
}
pair.s = t;
pair.ns = i;
send(crm.c2, &pair);
continue;
case WWread:
w->wctlready = 0;
recv(cwrm.c1, &pair);
if(w->deleted)
pair.ns = sprint(pair.s, "");
else{
s = "visible";
for(i=0; i<nhidden; i++)
if(hidden[i] == w){
s = "hidden";
break;
}
t = "notcurrent";
if(w == input)
t = "current";
pair.ns = snprint(pair.s, pair.ns, "%s %s ",t, s);
}
send(cwrm.c2, &pair);
continue;
}
}
print_func_exit();
}
int IgcPlay::startPlaying( const QString& startPoint,
const int skip,
const int playFactor )
{
int i_skip = skip;
m_factor = playFactor;
// Date from IGC file
QString date;
// Data from first B-Record
QString time0;
QString status0;
QString latDeg0;
QString lonDeg0;
QString latHem0;
QString lonHem0;
QString baroAlt0;
QString gssnAlt0;
QString fixAcc0;
QString satsInUse0;
// Data from second B-Record
QString time1;
QString status1;
QString latDeg1;
QString lonDeg1;
QString latHem1;
QString lonHem1;
QString baroAlt1;
QString gssnAlt1;
QString fixAcc1;
QString satsInUse1;
if( m_fileName.isEmpty() )
{
qWarning() << "IgcPlay::startPlaying: No file name is defined!";
return -1;
}
QFile file(m_fileName);
if( ! file.open(QIODevice::ReadOnly) )
{
qWarning() << "IgcPlay::startPlaying: Cannot open file" << m_fileName;
return -1;
}
QTextStream inStream(&file);
bool firstBRecord = true;
bool startPositionFound = false;
uint lineNo = 0;
uint bRecord = 0;
while( ! inStream.atEnd() )
{
lineNo++;
QString line = inStream.readLine().trimmed();
if( line.isEmpty() )
{
continue;
}
if( line.startsWith("HFDTE"))
{
// H-Record, Date, Example HFDTE270614
date = line.mid( 5 );
continue;
}
if( line.startsWith("B") == false )
{
// Ignore other records
continue;
}
bRecord++;
if( i_skip > 0 )
{
i_skip--;
continue;
}
if( startPoint.isEmpty() == false && startPositionFound == false )
{
if( line.mid(1, 6).startsWith(startPoint) == false )
{
// start point not yet reached
continue;
}
startPositionFound = true;
}
if( line.size() < 40 )
{
qWarning() << "Line:" << line << "B-Record to short!";
continue;
}
// qDebug() << "B:" << line;
// Only B-Records are taken into account
//
// 0 1 2 3
// 0 123456 78901234 567890123 4 56789 01234 567 89
// B 155706 5229791N 01331393E A 00000 00081 001 08
//
// Extract time
time1 = line.mid( 1, 6 );
// Extract coordinates
latHem1 = line.mid( 14, 1 );
lonHem1 = line.mid( 23, 1 );
latDeg1 = line.mid(7, 4) + "." + line.mid(11, 3);
lonDeg1 = line.mid(15, 5) + "." + line.mid(20, 3);
// Extract GPS fix status
status1 = line.mid( 24, 1 );
// Extract baro and GPS altitude
baroAlt1 = line.mid( 25, 5 );
gssnAlt1 = line.mid( 30, 5 );
// Extract fix accuracy
fixAcc1 = line.mid( 35, 3 );
// Extract sats in use
satsInUse1 = line.mid( 38, 2 );
if( firstBRecord == true )
{
// Store first extracted B-Record data and read the next one
firstBRecord = false;
time0 = time1;
status0 = status1;
latDeg0 = latDeg1;
lonDeg0 = lonDeg1;
latHem0 = latHem1;
lonHem0 = lonHem1;
baroAlt0 = baroAlt1;
gssnAlt0 = gssnAlt1;
fixAcc0 = fixAcc1;
satsInUse0 = satsInUse1;
continue;
}
// Calculate distance between coordinate points of B-Records
double lat0, lon0, lat1, lon1;
lat0 = latDeg0.left(2).toDouble() + latDeg0.mid(2).toDouble() / 60.;
if( latHem0 == "S" ) lat0 = -lat0;
lat1 = latDeg1.left(2).toDouble() + latDeg1.mid(2).toDouble() / 60.;
if( latHem1 == "S" ) lat1 = -lat1;
lon0 = lonDeg0.left(3).toDouble() + lonDeg0.mid(3).toDouble() / 60.;
if( lonHem0 == "W" ) lon0 = -lon0;
lon1 = lonDeg1.left(3).toDouble() + lonDeg1.mid(3).toDouble() / 60.;
if( lonHem1 == "W" ) lon1 = -lon1;
// Distance in meters
double distBetweenPoints = distC1( lat0, lon0, lat1, lon1);
// Calculate time difference in seconds between B-Records
QTime qtime0 = QTime::fromString( time0, "HHmmss");
QTime qtime1 = QTime::fromString( time1, "HHmmss");
if( ! qtime0.isValid() || ! qtime1.isValid() )
{
qWarning() << "Line:" << line << "B-Record time is wrong!";
continue;
}
int timeDiff = qtime0.secsTo( qtime1 );
qDebug() << "--Line=" << lineNo
<< "B-Record=" << bRecord
<< "Time=" << qtime1.toString(("HH:mm:ss"))
<< "TimeDiff=" << timeDiff;
// Check time difference, if negative, make it positive
if( timeDiff < 0 )
{
qWarning() << "TimeDiff is negative!" << timeDiff;
timeDiff = -timeDiff;
}
// Take over the new values as base for the next round.
time0 = time1;
status0 = status1;
latDeg0 = latDeg1;
lonDeg0 = lonDeg1;
latHem0 = latHem1;
lonHem0 = lonHem1;
baroAlt0 = baroAlt1;
gssnAlt0 = gssnAlt1;
fixAcc0 = fixAcc1;
satsInUse0 = satsInUse1;
// Check time difference, if zero something is wrong
if( timeDiff == 0 )
{
continue;
}
// Calculate speed in m/s
Speed speed( distBetweenPoints / (double) timeDiff );
// Calculate heading in degrees 0...360, if distance is > 0.5m
double bearing = 0.0;
if( distBetweenPoints > 0.5 )
{
bearing = getBearingWgs( lat0, lon0, lat1, lon1 );
}
/**
See http://www.nmea.de/nmea0183datensaetze.html
RMC - Recommended Minimum Navigation Information
12
1 2 3 4 5 6 7 8 9 10 11 | 13
| | | | | | | | | | | | |
$--RMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a,a*hh<CR><LF>
$GPRMC,132217.00,A,5228.19856,N,01408.32249,E,47.100,267.38,300710,,,A*58
Field Number:
1) UTC Time
2) Status, A = valid position, V = Navigation receiver warning
3) Latitude ddmm.mmm
4) Latitude hemisphere, N or S
5) Longitude dddmm.mm
6) Longitude hemisphere, E or W
7) Speed over ground, knots 0.0 ... 999.9
8) Course over ground, degrees true
9) UTC date of position fix, ddmmyy format
10) Magnetic Variation, degrees
11) Magnetic Variation direction, E or W
12) Signal integrity, A=Autonomous mode
13) Checksum, hh
*/
// Prepare RMC sentence
QString rmc = "$GPRMC," + time1 + "," + status1 + "," +
latDeg1 + "," + latHem1 + "," +
lonDeg1 + "," + lonHem1 + "," +
QString("%1").arg( speed.getKnots(), 0, 'f', 1 ) + "," +
QString("%1").arg( bearing, 0, 'f', 0 ) + "," +
date + ",,," + "A";
Sentence sentence;
sentence.send( rmc, m_fifo );
/**
GLL - Geographic Position - Latitude/Longitude
1 2 3 4 5 6 7
| | | | | | |
$--GLL,llll.ll,a,yyyyy.yy,a,hhmmss.ss,A*hh<CR><LF>
Field Number:
1) Latitude
2) N or S (North or South)
3) Longitude
4) E or W (East or West)
5) Universal Time Coordinated (UTC)
6) Status A - Data Valid, V - Data Invalid
7) Checksum
$GPGLL,4916.45,N,12311.12,W,225444,A
*/
#if 0
// Not necessary to send this.
QString ggl = "$GPGLL," +
latDeg1 + "," + latHem1 + "," +
lonDeg1 + "," + lonHem1 + "," +
time1 + "," +
status1;
sentence.send( ggl, m_fifo );
#endif
/**
GGA - Global Positioning System Fix Data, Time, Position and fix related data for a GPS receiver.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| | | | | | | | | | | | | | |
$--GGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*hh<CR><LF>
Field Number:
1) Universal Time Coordinated (UTC) of position fix, hhmmss format
2) Latitude, ddmm.mmmm format (leading zeros will be transmitted)
3) Latitude hemisphere, N or S
4) Longitude, dddmm.mmmm format (leading zeros will be transmitted)
5) Longitude hemisphere, E or W
6) GPS Quality Indicator,
0 - fix not available,
1 - GPS fix,
2 - Differential GPS fix
6 - Estimated
7) Number of satellites in view, 00 - 12
8) Horizontal Dilution of precision 0.5...99.9
9) Antenna Altitude above/below mean-sea-level (geoid)
10) Units of antenna altitude, meters
11) Geoidal separation, the difference between the WGS-84 earth
ellipsoid and mean-sea-level (geoid), "-" means mean-sea-level
below ellipsoid
12) Units of geoidal separation, meters
13) Age of differential GPS data, time in seconds since last SC104
type 1 or 9 update, null field when DGPS is not used
14) Differential reference station ID, 0000-1023
15) Checksum
$GPGGA,110959.00,5237.999230,N,01312.523391,E,1,14,1.6,81.4,M,43.0,M,,*54
*/
QString gga = "$GPGGA," +
time1 + "," +
latDeg1 + "," + latHem1 + "," +
lonDeg1 + "," + lonHem1 + "," +
"1," +
satsInUse1 + "," +
fixAcc1 + "," +
gssnAlt1 + ",M,0,M,,";
sentence.send( gga, m_fifo );
/**
Used by Garmin and Flarm devices
$PGRMZ,93,f,3*21
93,f Altitude in feet
3 Position fix dimensions 2 = FLARM barometric altitude
3 = GPS altitude
*/
Altitude alt(baroAlt1.toDouble());
QString rmz = "$PGRMZ," +
QString("%1").arg(alt.getFeet(), 0, 'f', 0) + ",f,2";
sentence.send( rmz, m_fifo );
// make a break defined by m_factor
usleep( timeDiff * 1000000 / m_factor);
}
file.close();
return 0;
}
void main()
{
char c;
int day,n,i,j,sum=0,stata[Nday];
double altemp,aztemp;
float hour,dis_;
dis_=interval;
struct data
{
float time[Nhour];
double alt;
double az;
};
data mydata[Nday];
for (i=0;i<Nday;i++) //初始化结构体
{
for (j=0;j<Nhour;j++)
{
mydata[i].time[j]=0;
}
}
for (day=firstday;day<=lastday;day++)
{
for (hour=sunrise,n=0;hour<=sundown;)
{
altemp=alt(day,hour,latitude,longitude);
aztemp=az(day,hour,latitude,longitude);
if (altemp>0 && aztemp>=0) //使太阳在地平线以上
{
mydata[day-1].alt=altemp;
mydata[day-1].az=aztemp;
}
else
{
hour=locate(day,hour,dis_);
continue;
}
hour=locate(day,hour,dis_);
mydata[day-1].time[n]=dataformat(hour);
if (n==Nhour-2)
{
printf("Oh My God!!!");
scanf("%d",&i);
}
printf(" n=%2d hour=%6.3f day=%3d \n",n,hour,day);
n++;
stata[day-1]=n;
}
sum=sum+n;
}
printf("\nCaculate Over!! Sum=%d KB\n\n\n\nWritting in the file.............\n\n",sum*2/1024);
FILE *fp; //文件写入部分
if ((fp=fopen("data.txt","w"))==NULL)
{
printf("Cannot open the file!!!\n");
}
fputs("\n\n******Generated by Neil******\n",fp);
fprintf(fp,"\nlatitude=%6.3f\nlongitude=%6.3f\nsunrise=%6.3f\nsundown=%6.3f\nstepinterval=%6.3f\nfirstday=%6d\nlastday=%6d\ndefinition=%6.5f\ninterval=%6.3f\nNday=%6d\n\n",latitude,longitude,sunrise,sundown,stepinterval,firstday,lastday,definition,interval,Nday); //输出宏定义量的值
for (i=0;i<Nday;i++)
{
for (j=0;j<Nhour;j++)
{
if (mydata[i].time[j]==0)
{
break;
}
//fprintf(fp,"day=%3d number=%2d hour=%4.0f \n",i+1,j+1,mydata[i].time[j]);
fprintf(fp,"code unsigned char Timedatas[%d].data[%d]=%4.0f\n",i,j,mydata[i].time[j]);
}
}
for (i=0;i<Nday;i++)
{
fprintf(fp,"day=%3d %d\n",i+1,stata[i]);
}
fputs("\n\n******Generated by Neil******\n",fp);
fclose(fp); //写入完毕
printf("Congrutulation !!!!!!\n\n******Generated by Neil******\n\n"); //以下是执行退出部分
printf("All work have been done well!!\n\nYou can Press Enter to close me.\n\n");
c=getchar();
if (c==13)
{
exit(0);
}
else printf("All work have done well!!\nYou can Press Enter to close me.\n");
}
/**
* Extract reference sequence region for motif discovery.
*
* The input is a VCF record that contains an indel.
*
* If the the indel has multiple alleles, it will examine all
* alleles.
*
* todo: is might be a good idea to combine this step with motif detection
* since there seems to be a need to have an iterative process here
* to ensure a good candidate motif is chosen. *
*/
void CandidateRegionExtractor::extract_regions_by_exact_alignment(bcf_hdr_t* h, bcf1_t* v, Variant& variant)
{
if (debug)
{
if (debug) std::cerr << "********************************************\n";
std::cerr << "EXTRACTIING REGION BY EXACT LEFT AND RIGHT ALIGNMENT\n\n";
}
VNTR& vntr = variant.vntr;
const char* chrom = bcf_get_chrom(h, v);
int32_t min_beg1 = bcf_get_pos1(v);
int32_t max_end1 = min_beg1;
if (debug)
{
bcf_print_liten(h, v);
}
//merge candidate search region
for (size_t i=1; i<bcf_get_n_allele(v); ++i)
{
std::string ref(bcf_get_alt(v, 0));
std::string alt(bcf_get_alt(v, i));
int32_t pos1 = bcf_get_pos1(v);
//this prevents introduction of flanks that do not harbour the repeat unit
trim(pos1, ref, alt);
int32_t end1 = pos1 + ref.size() - 1;
right_align(chrom, end1, ref, alt);
int32_t beg1 = end1 - ref.size() + 1;
left_align(chrom, beg1, ref, alt);
min_beg1 = beg1<min_beg1 ? beg1 : min_beg1;
max_end1 = end1>max_end1 ? end1 : max_end1;
int32_t seq_len;
char* seq = faidx_fetch_seq(fai, chrom, min_beg1-1, max_end1-1, &seq_len);
if (debug)
{
std::cerr << "EXACT REGION " << min_beg1 << "-" << max_end1 << " (" << max_end1-min_beg1+1 <<") from " << pos1 << ":" << ref << ":" << alt << "\n";
std::cerr << " " << seq << "\n";
}
if (seq_len) free(seq);
}
int32_t seq_len;
char* seq = faidx_fetch_seq(fai, chrom, min_beg1-1, max_end1-1, &seq_len);
if (debug)
{
std::cerr << "FINAL EXACT REGION " << min_beg1 << "-" << max_end1 << " (" << max_end1-min_beg1+1 <<") " << "\n";
std::cerr << " " << seq << "\n";
}
vntr.exact_repeat_tract = seq;
vntr.rid = bcf_get_rid(v);
vntr.exact_rbeg1 = min_beg1;
vntr.exact_rend1 = max_end1;
if (seq_len) free(seq);
}
int main(int argc, char ** argv)
{
int i;
int mode = 0;
if (argc == 2)
{
mode = argv[1][0] - '0';
if (mode < 0 || mode > 4)
{
mode = 0;
}
}
//mode:
// 0x00 D9 켜기
// 0x01 D8 켜기
// 0x02 D8 켜기, D10 블링킹
io_init();
for (i = 0; i < sizeof(pinmaps)/sizeof(struct led_pinmap); i++)
{
alt(pinmaps[i].module, pinmaps[i].bit, 0);
dir(pinmaps[i].module, pinmaps[i].bit, 1);
pinmaps[i].value = 1;
output(pinmaps[i].module, pinmaps[i].bit, pinmaps[i].value);
}
// Init
switch(mode)
{
case 0:
pinmaps[2].value = 0;
output(pinmaps[2].module, pinmaps[2].bit, pinmaps[2].value);
break;
case 1:
pinmaps[0].value = 0;
output(pinmaps[0].module, pinmaps[0].bit, pinmaps[0].value);
break;
case 2:
pinmaps[0].value = 0;
output(pinmaps[0].module, pinmaps[0].bit, pinmaps[0].value);
break;
}
// Blinking
while (1)
{
switch(mode)
{
case 1:
break;
case 2:
pinmaps[1].value = !pinmaps[1].value;
output(pinmaps[1].module, pinmaps[1].bit, pinmaps[1].value);
break;
case 3:
break;
}
usleep(500 * 1000);
}
io_exit();
return 0;
}
void
waitthread(void *v)
{
Waitmsg *w;
Command *c, *lc;
uint pid;
int found, ncmd;
Rune *cmd;
char *err;
Text *t;
Pid *pids, *p, *lastp;
enum { WErr, WKill, WWait, WCmd, NWALT };
Alt alts[NWALT+1];
USED(v);
threadsetname("waitthread");
pids = nil;
alts[WErr].c = cerr;
alts[WErr].v = &err;
alts[WErr].op = CHANRCV;
alts[WKill].c = ckill;
alts[WKill].v = &cmd;
alts[WKill].op = CHANRCV;
alts[WWait].c = cwait;
alts[WWait].v = &w;
alts[WWait].op = CHANRCV;
alts[WCmd].c = ccommand;
alts[WCmd].v = &c;
alts[WCmd].op = CHANRCV;
alts[NWALT].op = CHANEND;
command = nil;
for(;;){
switch(alt(alts)){
case WErr:
qlock(&row.lk);
warning(nil, "%s", err);
free(err);
flushimage(display, 1);
qunlock(&row.lk);
break;
case WKill:
found = FALSE;
ncmd = runestrlen(cmd);
for(c=command; c; c=c->next){
/* -1 for blank */
if(runeeq(c->name, c->nname-1, cmd, ncmd) == TRUE){
if(postnote(PNGROUP, c->pid, "kill") < 0)
warning(nil, "kill %S: %r\n", cmd);
found = TRUE;
}
}
if(!found)
warning(nil, "Kill: no process %S\n", cmd);
free(cmd);
break;
case WWait:
pid = w->pid;
lc = nil;
for(c=command; c; c=c->next){
if(c->pid == pid){
if(lc)
lc->next = c->next;
else
command = c->next;
break;
}
lc = c;
}
qlock(&row.lk);
t = &row.tag;
textcommit(t, TRUE);
if(c == nil){
/* helper processes use this exit status */
if(strncmp(w->msg, "libthread", 9) != 0){
p = emalloc(sizeof(Pid));
p->pid = pid;
strncpy(p->msg, w->msg, sizeof(p->msg));
p->next = pids;
pids = p;
}
}else{
if(search(t, c->name, c->nname)){
textdelete(t, t->q0, t->q1, TRUE);
textsetselect(t, 0, 0);
}
if(w->msg[0])
warning(c->md, "%.*S: exit %s\n", c->nname-1, c->name, w->msg);
flushimage(display, 1);
}
qunlock(&row.lk);
free(w);
Freecmd:
if(c){
if(c->iseditcmd)
sendul(cedit, 0);
free(c->text);
free(c->name);
fsysdelid(c->md);
free(c);
}
break;
case WCmd:
/* has this command already exited? */
lastp = nil;
for(p=pids; p!=nil; p=p->next){
if(p->pid == c->pid){
if(p->msg[0])
warning(c->md, "%s\n", p->msg);
if(lastp == nil)
pids = p->next;
else
lastp->next = p->next;
free(p);
goto Freecmd;
}
lastp = p;
}
c->next = command;
command = c;
qlock(&row.lk);
t = &row.tag;
textcommit(t, TRUE);
textinsert(t, 0, c->name, c->nname, TRUE);
textsetselect(t, 0, 0);
flushimage(display, 1);
qunlock(&row.lk);
break;
}
}
}
/*
* watch the exiting children
*/
Channel *twaitchan; /* chan(Waitreq) */
void
waitthread(void *v)
{
Alt a[3];
Waitmsg *w, **wq;
Waitreq *rq, r;
int i, nrq, nwq;
threadsetname("waitthread");
a[0].c = threadwaitchan();
a[0].v = &w;
a[0].op = CHANRCV;
a[1].c = twaitchan;
a[1].v = &r;
a[1].op = CHANRCV;
a[2].op = CHANEND;
nrq = 0;
nwq = 0;
rq = nil;
wq = nil;
dprint("wait: start\n");
for(;;){
cont2:;
dprint("wait: alt\n");
switch(alt(a)){
case 0:
dprint("wait: pid %d exited\n", w->pid);
for(i=0; i<nrq; i++){
if(rq[i].pid == w->pid){
dprint("wait: match with rq chan %p\n", rq[i].c);
sendp(rq[i].c, w);
rq[i] = rq[--nrq];
goto cont2;
}
}
if(i == nrq){
dprint("wait: queueing waitmsg\n");
wq = erealloc(wq, (nwq+1)*sizeof(wq[0]));
wq[nwq++] = w;
}
break;
case 1:
dprint("wait: req for pid %d chan %p\n", r.pid, r.c);
for(i=0; i<nwq; i++){
if(w->pid == r.pid){
dprint("wait: match with waitmsg\n");
sendp(r.c, w);
wq[i] = wq[--nwq];
goto cont2;
}
}
if(i == nwq){
dprint("wait: queueing req\n");
rq = erealloc(rq, (nrq+1)*sizeof(rq[0]));
rq[nrq] = r;
dprint("wait: queueing req pid %d chan %p\n", rq[nrq].pid, rq[nrq].c);
nrq++;
}
break;
}
}
}
/**
* @brief Creates an XsOutputConfigurationArray and pushes it to the sensor.
* @details
* - Configures the sensor with desired modules
* - Refer to xsdataidentifier.h
*/
void mtiG::configure(){
XsOutputConfigurationArray configArray;
if(mSettings.orientationData){ //Quaternion - containsOrientation
XsOutputConfiguration quat(XDI_Quaternion, mSettings.orientationFreq);// para pedir quaternion
configArray.push_back(quat);
}
if(mSettings.gpsData){
//LATITUDE E LONGITUDE -containsLatitudeLongitude
XsOutputConfiguration gps(XDI_LatLon, mSettings.gpsFreq);// para pedir gps, //XDI_Quaternion 06/04
configArray.push_back(gps);
XsOutputConfiguration gps_age(XDI_GpsAge, mSettings.gpsFreq);// para pedir gps, //XDI_Quaternion 06/04
configArray.push_back(gps_age);
XsOutputConfiguration gps_sol(XDI_GpsSol, mSettings.gpsFreq);// para pedir gps, //XDI_Quaternion 06/04
configArray.push_back(gps_sol);
XsOutputConfiguration gps_dop(XDI_GpsDop, mSettings.gpsFreq);// para pedir gps, //XDI_Quaternion 06/04
configArray.push_back(gps_dop);
}
if(mSettings.temperatureData){
//TEMPERATURA - containsTemperature
XsOutputConfiguration temp(XDI_Temperature, mSettings.temperatureFreq);
configArray.push_back(temp);
}
if(mSettings.accelerationData){
//ACCELERATION - containsCalibratedAcceleration
XsOutputConfiguration accel(XDI_Acceleration, mSettings.accelerationFreq);
configArray.push_back(accel);
}
if(mSettings.pressureData){
//PRESSURE - containsPressure
XsOutputConfiguration baro(XDI_BaroPressure, mSettings.pressureFreq);
configArray.push_back(baro);
}
if(mSettings.magneticData){
//MAGNETIC FIELD - containsCalibratedMagneticField
XsOutputConfiguration magnet(XDI_MagneticField, mSettings.magneticFreq);
configArray.push_back(magnet);
}
if(mSettings.altitudeData){
//ALTITUDE - containsAltitude
XsOutputConfiguration alt(XDI_AltitudeEllipsoid, mSettings.altitudeFreq);
configArray.push_back(alt);
}
if(mSettings.gyroscopeData){
//GYRO - containsCalibratedGyroscopeData
XsOutputConfiguration gyro(XDI_RateOfTurn, mSettings.gyroscopeFreq);
configArray.push_back(gyro);
}
if(mSettings.velocityData){
//VELOCIDADE XYZ
XsOutputConfiguration vel_xyz(XDI_VelocityXYZ, mSettings.velocityFreq);
configArray.push_back(vel_xyz);
}
// Puts configArray into the device, overwriting the current configuration
if (!device->setOutputConfiguration(configArray))
{
throw std::runtime_error("Could not configure MTmk4 device. Aborting.");
}
}
int
play(void)
{
int i;
Mouse om;
int s;
Rune r;
Alt alts[NALT+1];
alts[TIMER].c = timerc;
alts[TIMER].v = nil;
alts[TIMER].op = CHANRCV;
alts[MOUSE].c = mousec;
alts[MOUSE].v = &mouse;
alts[MOUSE].op = CHANRCV;
alts[SUSPEND].c = suspc;
alts[SUSPEND].v = &s;
alts[SUSPEND].op = CHANRCV;
alts[RESHAPE].c = mousectl->resizec;
alts[RESHAPE].v = nil;
alts[RESHAPE].op = CHANRCV;
alts[KBD].c = kbdc;
alts[KBD].v = &r;
alts[KBD].op = CHANRCV;
alts[NALT].op = CHANEND;
dt = 64;
lastmx = -1;
lastmx = movemouse();
choosepiece();
lastmx = warp(mouse.xy, lastmx);
for(;;)
switch(alt(alts)) {
case MOUSE:
if(suspended) {
om = mouse;
break;
}
if(lastmx < 0)
lastmx = mouse.xy.x;
if(mouse.xy.x > lastmx+DMOUSE) {
mright();
lastmx = mouse.xy.x;
}
if(mouse.xy.x < lastmx-DMOUSE) {
mleft();
lastmx = mouse.xy.x;
}
if(mouse.buttons&1 && !(om.buttons&1))
rleft();
if(mouse.buttons&2 && !(om.buttons&2))
if(drop(1))
return 1;
if(mouse.buttons&4 && !(om.buttons&4))
rright();
om = mouse;
break;
case SUSPEND:
if (!suspended && s)
suspend(1);
else if (suspended && !s) {
suspend(0);
lastmx = warp(mouse.xy, lastmx);
}
break;
case RESHAPE:
redraw(1);
break;
case KBD:
if(suspended)
break;
switch(r) {
case 'f':
case ';':
mright();
break;
case 'a':
case 'j':
mleft();
break;
case 'd':
case 'l':
rright();
break;
case 's':
case 'k':
rleft();
break;
case ' ':
if(drop(1))
return 1;
break;
}
break;
case TIMER:
if(suspended)
break;
dt -= tsleep;
if(dt < 0) {
i = 1;
dt = 16 * (points+nrand(10000)-5000) / 10000;
if(dt >= 32) {
i += (dt-32)/16;
dt = 32;
}
dt = 52-dt;
while(i-- > 0)
if(movepiece()==0 && ++fusst==40) {
if(drop(0))
return 1;
break;
}
}
break;
}
}
void keyEvent(rdr::U32 keysym, bool down, bool jap)
{
vnclog.Print(LL_INTWARN, " keysym 0x%x",keysym);
if (keysym>=XK_dead_grave && keysym <=XK_dead_belowdot)// && down)
{
keysymDead=keysym;
vnclog.Print(LL_INTWARN, " ************** DEAD KEY");
//we have a dead key
//Record dead key
return;
}
if ((keysym >= 32 && keysym <= 126) ||
(keysym >= 160 && keysym <= 255))
{
if (keysymDead!=0 && down)
{
vnclog.Print(LL_INTWARN, " Compose dead 0x%x 0x%x",keysymDead,keysym);
switch (keysymDead)
{
case XK_dead_grave:
switch(keysym)
{
case XK_A: keysym=XK_Agrave;break;
case XK_E: keysym=XK_Egrave;break;
case XK_I: keysym=XK_Igrave;break;
case XK_O: keysym=XK_Ograve;break;
case XK_U: keysym=XK_Ugrave;break;
case XK_a: keysym=XK_agrave;break;
case XK_e: keysym=XK_egrave;break;
case XK_i: keysym=XK_igrave;break;
case XK_o: keysym=XK_ograve;break;
case XK_u: keysym=XK_ugrave;break;
}
case XK_dead_acute:
switch(keysym)
{
case XK_A: keysym=XK_Aacute;break;
case XK_E: keysym=XK_Eacute;break;
case XK_I: keysym=XK_Iacute;break;
case XK_O: keysym=XK_Oacute;break;
case XK_U: keysym=XK_Uacute;break;
case XK_a: keysym=XK_aacute;break;
case XK_e: keysym=XK_eacute;break;
case XK_i: keysym=XK_iacute;break;
case XK_o: keysym=XK_oacute;break;
case XK_u: keysym=XK_uacute;break;
case XK_y: keysym=XK_yacute;break;
case XK_Y: keysym=XK_Yacute;break;
}
case XK_dead_circumflex:
switch(keysym)
{
case XK_A: keysym=XK_Acircumflex;break;
case XK_E: keysym=XK_Ecircumflex;break;
case XK_I: keysym=XK_Icircumflex;break;
case XK_O: keysym=XK_Ocircumflex;break;
case XK_U: keysym=XK_Ucircumflex;break;
case XK_a: keysym=XK_acircumflex;break;
case XK_e: keysym=XK_ecircumflex;break;
case XK_i: keysym=XK_icircumflex;break;
case XK_o: keysym=XK_ocircumflex;break;
case XK_u: keysym=XK_ucircumflex;break;
}
case XK_dead_tilde:
switch(keysym)
{
case XK_A : keysym=XK_Ntilde;break;
case XK_O : keysym=XK_Otilde;break;
case XK_a : keysym=XK_atilde;break;
case XK_n : keysym=XK_ntilde;break;
case XK_o : keysym=XK_otilde;break;
}
case XK_dead_diaeresis:
switch(keysym)
{
case XK_A: keysym=XK_Adiaeresis;break;
case XK_E: keysym=XK_Ediaeresis;break;
case XK_I: keysym=XK_Idiaeresis;break;
case XK_O: keysym=XK_Odiaeresis;break;
case XK_U: keysym=XK_Udiaeresis;break;
case XK_a: keysym=XK_adiaeresis;break;
case XK_e: keysym=XK_ediaeresis;break;
case XK_i: keysym=XK_idiaeresis;break;
case XK_o: keysym=XK_odiaeresis;break;
case XK_u: keysym=XK_udiaeresis;break;
case XK_y: keysym=XK_ydiaeresis;break;
}
case XK_dead_cedilla:
switch(keysym)
{
case XK_C: keysym=XK_Ccedilla;break;
case XK_c: keysym=XK_ccedilla;break;
}
}
keysymDead=0;
vnclog.Print(LL_INTWARN, " Composed 0x%x",keysym);
}
// ordinary Latin-1 character
SHORT s = VkKeyScan(keysym);
// [v1.0.2-jp1 fix] yak!'s patch
// This break Other keyboards, we need an easy way of fixing this
if (jap)
{
if (keysym==XK_kana_WO) {
s = 0x0130;
} else if (keysym==XK_backslash) {
s = 0x00e2;
} else if (keysym==XK_yen) {
s = 0x00dc;
}
}
vnclog.Print(LL_INTWARN, " SHORT s %i",s);
if (s == -1)
{
if (down) {
vnclog.Print(LL_INTWARN, "down");
// not a single keypress - try synthesizing dead chars.
{
vnclog.Print(LL_INTWARN, " Found key");
//Lookup ascii representation
int ascii=0;
#if 0
// 11 Dec 2008 jdp disabled since the viewer is sending unicode now
for (ascii=0;ascii<256;ascii++)
{
if (keysym==ascii_to_x[ascii]) break;
}
#endif
ascii = keysym;
if (ascii <= 255)
{
rdr::U8 a0=ascii/100;
ascii=ascii%100;
rdr::U8 a1=ascii/10;
ascii=ascii%10;
rdr::U8 a2=ascii;
KeyStateModifier shift(VK_SHIFT);
KeyStateModifier lshift(VK_LSHIFT);
KeyStateModifier rshift(VK_RSHIFT);
if (vncService::IsWin95()) {
shift.release();
} else {
lshift.release();
rshift.release();
}
vnclog.Print(LL_INTWARN, " Simulating ALT+%d%d%d\n", a0, a1 ,a2);
keybd_event(VK_MENU,MapVirtualKey( VK_MENU, 0 ), 0 ,0);
/**
Pressing the Alt+NNN combinations without leading zero (for example, Alt+20, Alt+130, Alt+221)
will insert characters from the Extended ASCII (or MS DOS ASCII, or OEM) table. The character
glyphs contained by this table depend on the language of Windows. See the table below for the
list of characters that can be inserted through the Alt+NNN combinations (without leading zero)
in English Windows.
Pressing the Alt+0NNN combinations will insert the ANSI characters corresponding to the activate
keyboard layout. Please see Windows Character Map utility (charmap.exe) for the possible Alt+0NNN
combinations.
Finally, the Alt+00NNN combinations (two leading zeros) will insert Unicode characters. The Unicode
codes of characters are displayed in Charmap.
**/
// jdp 11 December 2008 - Need the leading 0!
keybd_event(VK_NUMPAD0, MapVirtualKey(VK_NUMPAD0, 0), 0, 0);
keybd_event(VK_NUMPAD0, MapVirtualKey(VK_NUMPAD0, 0),KEYEVENTF_KEYUP,0);
keybd_event(VK_NUMPAD0+a0, MapVirtualKey(VK_NUMPAD0+a0, 0), 0, 0);
keybd_event(VK_NUMPAD0+a0, MapVirtualKey(VK_NUMPAD0+a0, 0),KEYEVENTF_KEYUP,0);
keybd_event(VK_NUMPAD0+a1, MapVirtualKey(VK_NUMPAD0+a1, 0),0,0);
keybd_event(VK_NUMPAD0+a1, MapVirtualKey(VK_NUMPAD0+a1, 0),KEYEVENTF_KEYUP, 0);
keybd_event(VK_NUMPAD0+a2, MapVirtualKey(VK_NUMPAD0+a2, 0) ,0, 0);
keybd_event(VK_NUMPAD0+a2, MapVirtualKey(VK_NUMPAD0+a2, 0),KEYEVENTF_KEYUP, 0);
keybd_event(VK_MENU, MapVirtualKey( VK_MENU, 0 ),KEYEVENTF_KEYUP, 0);
return;
}
}
vnclog.Print(LL_INTWARN, "ignoring unrecognised Latin-1 keysym 0x%x",keysym);
}
return;
}
/*if (s == -1) {
vnclog.Print(LL_INTWARN, "ignoring unrecognised Latin-1 keysym %d\n",
keysym);
keybd_event( VK_MENU, MapVirtualKey(VK_MENU, 0),0, 0);
keybd_event( VK_MENU, MapVirtualKey(VK_MENU, 0),KEYEVENTF_KEYUP, 0);
return;
}*/
BYTE vkCode = LOBYTE(s);
// 18 March 2008 jdp
// Correct the keymask shift state to cope with the capslock state
BOOL capslockOn = (GetKeyState(VK_CAPITAL) & 1) != 0;
BYTE modifierState = HIBYTE(s);
modifierState = capslockOn ? modifierState ^ 1 : modifierState;
KeyStateModifier ctrl(VK_CONTROL);
KeyStateModifier alt(VK_MENU);
KeyStateModifier shift(VK_SHIFT);
KeyStateModifier lshift(VK_LSHIFT);
KeyStateModifier rshift(VK_RSHIFT);
if (down) {
if (modifierState & 2) ctrl.press();
if (modifierState & 4) alt.press();
if (modifierState & 1) {
shift.press();
} else {
// [v1.0.2-jp1 fix] Even if "SHIFT + SPACE" are pressed, "SHIFT" is valid
if (vkCode == 0x20){
}
else{
if (vncService::IsWin95()) {
shift.release();
} else {
lshift.release();
rshift.release();
}
}
}
}
vnclog.Print(LL_INTINFO,
"latin-1 key: keysym %d(0x%x) vkCode 0x%x down %d capslockOn %d\n",
keysym, keysym, vkCode, down, capslockOn);
doKeyboardEvent(vkCode, down ? 0 : KEYEVENTF_KEYUP);
} else {
// see if it's a recognised keyboard key, otherwise ignore it
if (vkMap.find(keysym) == vkMap.end()) {
vnclog.Print(LL_INTWARN, "ignoring unknown keysym %d\n",keysym);
return;
}
BYTE vkCode = vkMap[keysym];
DWORD flags = 0;
if (extendedMap[keysym]) flags |= KEYEVENTF_EXTENDEDKEY;
if (!down) flags |= KEYEVENTF_KEYUP;
// vnclog.Print(LL_INTINFO,
// "keyboard key: keysym %d(0x%x) vkCode 0x%x ext %d down %d\n",
// keysym, keysym, vkCode, extendedMap[keysym], down);
if (down && (vkCode == VK_DELETE) &&
((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0) &&
((GetAsyncKeyState(VK_MENU) & 0x8000) != 0) &&
vncService::IsWinNT())
{
vnclog.Print(LL_INTINFO,
"CAD\n");
// If running under Vista and started from Session0 in Application mode
if (vncService::VersionMajor()>=6 && vncService::RunningFromExternalService() )
{
vnclog.Print(LL_INTINFO,
"Vista and runnning as system -> CAD\n");
// Try to run the special Vista cad.exe file...
HANDLE ThreadHandle2;
DWORD dwTId;
ThreadHandle2 = CreateThread(NULL, 0, Cadthread, NULL, 0, &dwTId);
CloseHandle(ThreadHandle2);
}
else if (vncService::VersionMajor()>=6)
{
vnclog.Print(LL_INTINFO,
"Vista and runnning as user -> Taskmgr\n");
WinExec("taskmgr.exe", SW_SHOWNORMAL);
}
else if (vncService::VersionMajor()<6 && vncService::RunningFromExternalService() )
{
vnclog.Print(LL_INTINFO,
"Not Vista and runnning as system, use old method\n");
vncService::SimulateCtrlAltDel();
}
else if (vncService::VersionMajor()<6)
{
vnclog.Print(LL_INTINFO,
"Not Vista and runnning as user -> Taskmgr\n");
WinExec("taskmgr.exe", SW_SHOWNORMAL);
}
return;
}
if (vncService::IsWin95()) {
switch (vkCode) {
case VK_RSHIFT: vkCode = VK_SHIFT; break;
case VK_RCONTROL: vkCode = VK_CONTROL; break;
case VK_RMENU: vkCode = VK_MENU; break;
}
}
doKeyboardEvent(vkCode, flags);
}
}
void
decproc(void*)
{
Pmsg playstate, newstate;
int fd;
Pacbuf *pb;
Alt a[3] = {
{empty, &pb, CHANNOP},
{playc, &newstate.m, CHANRCV},
{nil, nil, CHANEND},
};
threadsetname("decproc");
close(srvfd[1]);
newstate.cmd = playstate.cmd = Stop;
newstate.off = playstate.off = 0;
fd = -1;
for(;;){
switch(alt(a)){
case 0:
/* Play out next buffer (pb points to one already) */
assert(fd >= 0); /* Because we must be in Play mode */
pb->m = playstate.m;
pb->len = read(fd, pb->data, sizeof pb->data);
if(pb->len > 0){
sendp(full, pb);
break;
}
if(pb->len < 0){
if(debug & DbgPlayer)
fprint(2, "pac, error: %d\n", playstate.off);
pb->cmd = Error;
pb->len = snprint(pb->data, sizeof pb->data, "%s: %r", curfile);
sendp(full, pb);
}else{
/* Simple end of file */
sendp(empty, pb); /* Don't need buffer after all */
}
close(fd);
fd = -1;
if(debug & DbgPlayer)
fprint(2, "pac, eof: %d\n", playstate.off);
/* End of file, do next by falling through */
newstate.cmd = playstate.cmd;
newstate.off = playstate.off + 1;
case 1:
if((debug & DbgPac) && newstate.cmd)
fprint(2, "Pacproc: newstate %s-%d, playstate %s-%d\n",
statetxt[newstate.cmd], newstate.off,
statetxt[playstate.cmd], playstate.off);
/* Deal with an incoming command */
if(newstate.cmd == Pause || newstate.cmd == Resume){
/* Just pass them on, don't change local state */
pb = recvp(spare);
pb->m = newstate.m;
sendp(full, pb);
break;
}
/* Stop whatever we're doing */
if(fd >= 0){
if(debug & DbgPlayer)
fprint(2, "pac, stop\n");
/* Stop any active (pac) decoders */
close(fd);
fd = -1;
}
a[0].op = CHANNOP;
switch(newstate.cmd){
default:
sysfatal("decproc: unexpected newstate %d", newstate.cmd);
case Stop:
/* Wait for state to change */
break;
case Skip:
case Play:
fd = startplay(newstate.off);
if(fd >=0){
playstate = newstate;
a[0].op = CHANRCV;
continue; /* Start reading */
}
newstate.cmd = Stop;
}
pb = recvp(spare);
pb->m = newstate.m;
sendp(full, pb);
playstate = newstate;
}
}
}
int
nbnsfindname(uchar *serveripaddr, NbName name, uchar *ipaddr, ulong *ttlp)
{
NbnsMessage *nq;
Alt aa[3];
int tries = NbnsRetryBroadcast;
NbnsAlarm *a;
int rv;
NbnsMessage *response;
nq = nbnsmessagenamequeryrequestnew(0, serveripaddr == nil, name);
if (nq == nil)
return -1;
a = nbnsalarmnew();
if (a == nil) {
free(nq);
return -1;
}
aa[0].c = a->c;
aa[0].v = nil;
aa[0].op = CHANRCV;
aa[1].op = CHANRCV;
aa[2].op = CHANEND;
while (tries > 0) {
NbnsTransaction *t;
nq->id = nbnsnextid();
t = nbnstransactionnew(nq, serveripaddr);
aa[1].c = t->c;
aa[1].v = &response;
nbnsalarmset(a, NbnsTimeoutBroadcast);
for (;;) {
int i;
i = alt(aa);
if (i == 0) {
tries--;
break;
}
else if (i == 1) {
if (response->opcode == NbnsOpQuery) {
nbnstransactionfree(&t);
goto done;
}
nbnsmessagefree(&response);
}
}
nbnstransactionfree(&t);
}
done:
if (tries == 0)
rv = -1;
else {
if (response->rcode != 0)
rv = response->rcode;
else if (response->an == nil)
rv = -1;
else {
rv = 0;
v4tov6(ipaddr, response->an->rdata + 2);
if (ttlp)
*ttlp = response->an->ttl;
}
nbnsmessagefree(&response);
}
nbnsalarmfree(&a);
nbnsmessagefree(&nq);
return rv;
}
void
pcmproc(void*)
{
Pmsg localstate, newstate, prevstate;
int fd, n;
Pacbuf *pb, *b;
Alt a[3] = {
{full, &pb, CHANRCV},
{playout, &pb, CHANRCV},
{nil, nil, CHANEND},
};
/*
* This is the real-time proc.
* It gets its input from two sources, full data/control buffers from the decproc
* which mixes decoded data with control messages, and data buffers from the pcmproc's
* (*this* proc's) own internal playout buffer.
* When a command is received on the `full' channel containing a command that warrants
* an immediate change of audio source (e.g., to silence or to another number), we just
* toss everything in the pipeline -- i.e., the playout channel
* Finally, we report all state changes using `playupdate' (another message channel)
*/
threadsetname("pcmproc");
close(srvfd[1]);
fd = -1;
localstate.cmd = 0; /* Force initial playupdate */
newstate.cmd = Stop;
newstate.off = 0;
// rtsched();
boost();
for(;;){
if(newstate.m != localstate.m){
playupdate(newstate, nil);
localstate = newstate;
}
switch(alt(a)){
case 0:
/* buffer received from decproc */
if((debug & DbgPcm) && localstate.m != prevstate.m){
fprint(2, "pcm, full: %s-%d, local state is %s-%d\n",
statetxt[pb->cmd], pb->off,
statetxt[localstate.cmd], localstate.off);
prevstate.m = localstate.m;
}
switch(pb->cmd){
default:
sysfatal("pcmproc: unknown newstate: %s-%d", statetxt[pb->cmd], pb->off);
case Resume:
a[1].op = CHANRCV;
newstate.cmd = Play;
break;
case Pause:
a[1].op = CHANNOP;
newstate.cmd = Pause;
if(fd >= 0){
close(fd);
fd = -1;
}
break;
case Stop:
/* Dump all data in the buffer */
while(b = nbrecvp(playout))
if(b->cmd == Error){
playupdate(b->Pmsg, b->data);
sendp(spare, b);
}else
sendp(empty, b);
newstate.m = pb->m;
a[1].op = CHANRCV;
if(fd >= 0){
close(fd);
fd = -1;
}
break;
case Skip:
/* Dump all data in the buffer, then fall through */
while(b = nbrecvp(playout))
if(b->cmd == Error){
playupdate(pb->Pmsg, pb->data);
sendp(spare, pb);
}else
sendp(empty, b);
a[1].op = CHANRCV;
newstate.cmd = Play;
case Error:
case Play:
/* deal with at playout, just requeue */
sendp(playout, pb);
pb = nil;
localstate = newstate;
break;
}
/* If we still have a buffer, free it */
if(pb)
sendp(spare, pb);
break;
case 1:
/* internal buffer */
if((debug & DbgPlayer) && localstate.m != prevstate.m){
fprint(2, "pcm, playout: %s-%d, local state is %s-%d\n",
statetxt[pb->cmd], pb->off,
statetxt[localstate.cmd], localstate.off);
prevstate.m = localstate.m;
}
switch(pb->cmd){
default:
sysfatal("pcmproc: unknown newstate: %s-%d", statetxt[pb->cmd], pb->off);
case Error:
playupdate(pb->Pmsg, pb->data);
localstate = newstate;
sendp(spare, pb);
break;
case Play:
if(fd < 0 && (fd = open("/dev/audio", OWRITE)) < 0){
a[1].op = CHANNOP;
newstate.cmd = Pause;
pb->cmd = Error;
snprint(pb->data, sizeof(pb->data),
"/dev/audio: %r");
playupdate(pb->Pmsg, pb->data);
sendp(empty, pb);
break;
}
/* play out this buffer */
totbytes += pb->len;
totbuffers++;
n = write(fd, pb->data, pb->len);
if (n != pb->len){
if (debug & DbgPlayer)
fprint(2, "pcmproc: file %d: %r\n", pb->off);
if (n < 0)
sysfatal("pcmproc: write: %r");
}
newstate.m = pb->m;
sendp(empty, pb);
break;
}
break;
}
}
}
int main()
{
printf("Mallocing\n");
alt();
}
void
keyboardthread(void *v)
{
Rune r;
Timer *timer;
Text *t;
enum { KTimer, KKey, NKALT };
static Alt alts[NKALT+1];
USED(v);
alts[KTimer].c = nil;
alts[KTimer].v = nil;
alts[KTimer].op = CHANNOP;
alts[KKey].c = keyboardctl->c;
alts[KKey].v = &r;
alts[KKey].op = CHANRCV;
alts[NKALT].op = CHANEND;
timer = nil;
typetext = nil;
threadsetname("keyboardthread");
for(;;){
switch(alt(alts)){
case KTimer:
timerstop(timer);
t = typetext;
if(t!=nil && t->what==Tag){
winlock(t->w, 'K');
wincommit(t->w, t);
winunlock(t->w);
flushimage(display, 1);
}
alts[KTimer].c = nil;
alts[KTimer].op = CHANNOP;
break;
case KKey:
casekeyboard:
typetext = rowtype(&row, r, mouse->xy);
t = typetext;
if(t!=nil && t->col!=nil && !(r==Kdown || r==Kleft || r==Kright)) /* scrolling doesn't change activecol */
activecol = t->col;
if(t!=nil && t->w!=nil)
t->w->body.file->curtext = &t->w->body;
if(timer != nil)
timercancel(timer);
if(t!=nil && t->what==Tag) {
timer = timerstart(500);
alts[KTimer].c = timer->c;
alts[KTimer].op = CHANRCV;
}else{
timer = nil;
alts[KTimer].c = nil;
alts[KTimer].op = CHANNOP;
}
if(nbrecv(keyboardctl->c, &r) > 0)
goto casekeyboard;
flushimage(display, 1);
break;
}
}
}
// [[Rcpp::export]]
Rcpp::DataFrame vcf_body(std::string x, Rcpp::NumericVector stats) {
// Read in the fixed and genotype portion of the file.
// Stats contains:
// "meta", "header", "variants", "columns"
Rcpp::CharacterVector chrom(stats[2]);
Rcpp::IntegerVector pos(stats[2]);
Rcpp::StringVector id(stats[2]);
Rcpp::StringVector ref(stats[2]);
Rcpp::StringVector alt(stats[2]);
Rcpp::NumericVector qual(stats[2]);
Rcpp::StringVector filter(stats[2]);
Rcpp::StringVector info(stats[2]);
// if(stats[3])
Rcpp::CharacterMatrix gt(stats[2], stats[3] - 8);
std::string line; // String for reading file into
// Open file.
std::ifstream myfile;
myfile.open (x.c_str(), std::ios::in);
if (!myfile.is_open()){
Rcpp::Rcout << "Unable to open file";
}
// Iterate past meta.
int i = 0;
int j = 0;
while ( i < stats[0] ){
getline (myfile,line);
i++;
}
// Get header.
getline (myfile,line);
std::string header = line;
// Get body.
i = 0;
char buffer [50];
while ( getline (myfile,line) ){
Rcpp::checkUserInterrupt();
std::vector < std::string > temps = tabsplit(line, stats[3]);
if(temps[0] == "."){
chrom[i] = NA_STRING;
} else {
chrom[i] = temps[0];
}
if(temps[1] == "."){
pos[i] = NA_INTEGER;
} else {
pos[i] = atoi(temps[1].c_str());
}
if(temps[2] == "."){
id[i] = NA_STRING;
} else {
id[i] = temps[2];
}
if(temps[3] == "."){
ref[i] = NA_STRING;
} else {
ref[i] = temps[3];
}
if(temps[4] == "."){
alt[i] = NA_STRING;
} else {
alt[i] = temps[4];
}
if(temps[5] == "."){
qual[i] = NA_REAL;
} else {
qual[i] = atof(temps[5].c_str());
}
if(temps[6] == "."){
filter[i] = NA_STRING;
} else {
filter[i] = temps[6];
}
if(temps[7] == "."){
info[i] = NA_STRING;
} else {
info[i] = temps[7];
}
for(j=8; j<stats[3]; j++){
gt(i, j-8) = temps[j];
// body(i, j-8) = temps[j];
}
i++;
if( i % nreport == 0){
Rcpp::Rcout << "\rProcessed variant: " << i;
}
}
myfile.close();
Rcpp::Rcout << "\rProcessed variant: " << i;
Rcpp::Rcout << "\nAll variants processed\n";
Rcpp::DataFrame df1 = Rcpp::DataFrame::create(
Rcpp::_["CHROM"]= chrom,
Rcpp::_["POS"]= pos,
Rcpp::_["ID"] = id,
Rcpp::_["REF"] = ref,
Rcpp::_["ALT"] = alt,
Rcpp::_["QUAL"] = qual,
Rcpp::_["FILTER"] = filter,
Rcpp::_["INFO"] = info,
gt);
std::vector < std::string > temps = tabsplit(header, stats[3]);
temps[0].erase(0,1);
df1.names() = temps;
Rcpp::Rcout << "Rcpp::DataFrame created.\n";
return df1;
}
pl_lettre_1 (struct coroutine *k, expr a0)
{
expr nx[MAX_NEW_CONS];
int pnx, i;
struct process_list *alt_process;
pnx = 0;
begin_decl ();
decl_expr (&a0);
for (i=0; i<MAX_NEW_CONS; i++)
dle (nx[i]);
#ifdef TRACE
printf ("\nlettre: a0 = "); print_expr (a0);
#endif
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("a"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("a"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("b"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("b"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("c"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("c"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("d"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("d"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("e"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("e"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("f"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("f"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("g"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("g"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("h"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("h"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
if (alt (k, 1, 0))
{
/* clause */
alt_process = getpl (k) -> alt;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, nx[pnx++] = cons (symbol("i"),
0), a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, nx[pnx++] = cons (symbol("i"),
0));
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
end (k);
free_expr ();
}
void
mousethread(void *v)
{
Text *t, *argt;
int but;
uint q0, q1;
Window *w;
Plumbmsg *pm;
Mouse m;
char *act;
enum { MResize, MMouse, MPlumb, MWarnings, NMALT };
static Alt alts[NMALT+1];
USED(v);
threadsetname("mousethread");
alts[MResize].c = mousectl->resizec;
alts[MResize].v = nil;
alts[MResize].op = CHANRCV;
alts[MMouse].c = mousectl->c;
alts[MMouse].v = &mousectl->m;
alts[MMouse].op = CHANRCV;
alts[MPlumb].c = cplumb;
alts[MPlumb].v = ±
alts[MPlumb].op = CHANRCV;
alts[MWarnings].c = cwarn;
alts[MWarnings].v = nil;
alts[MWarnings].op = CHANRCV;
if(cplumb == nil)
alts[MPlumb].op = CHANNOP;
alts[NMALT].op = CHANEND;
for(;;){
qlock(&row.lk);
flushwarnings();
qunlock(&row.lk);
flushimage(display, 1);
switch(alt(alts)){
case MResize:
if(getwindow(display, Refnone) < 0)
error("attach to window");
draw(screen, screen->r, display->white, nil, ZP);
iconinit();
scrlresize();
rowresize(&row, screen->clipr);
break;
case MPlumb:
if(strcmp(pm->type, "text") == 0){
act = plumblookup(pm->attr, "action");
if(act==nil || strcmp(act, "showfile")==0)
plumblook(pm);
else if(strcmp(act, "showdata")==0)
plumbshow(pm);
}
plumbfree(pm);
break;
case MWarnings:
break;
case MMouse:
/*
* Make a copy so decisions are consistent; mousectl changes
* underfoot. Can't just receive into m because this introduces
* another race; see /sys/src/libdraw/mouse.c.
*/
m = mousectl->m;
qlock(&row.lk);
t = rowwhich(&row, m.xy);
if(t!=mousetext && mousetext!=nil && mousetext->w!=nil){
winlock(mousetext->w, 'M');
mousetext->eq0 = ~0;
wincommit(mousetext->w, mousetext);
winunlock(mousetext->w);
}
mousetext = t;
if(t == nil)
goto Continue;
w = t->w;
if(t==nil || m.buttons==0)
goto Continue;
but = 0;
if(m.buttons == 1)
but = 1;
else if(m.buttons == 2)
but = 2;
else if(m.buttons == 4)
but = 3;
barttext = t;
if(t->what==Body && ptinrect(m.xy, t->scrollr)){
if(but){
if(swapscrollbuttons){
if(but == 1)
but = 3;
else if(but == 3)
but = 1;
}
winlock(w, 'M');
t->eq0 = ~0;
textscroll(t, but);
winunlock(w);
}
goto Continue;
}
/* scroll buttons, wheels, etc. */
if(w != nil && (m.buttons & (8|16))){
if(m.buttons & 8)
but = Kscrolloneup;
else
but = Kscrollonedown;
winlock(w, 'M');
t->eq0 = ~0;
texttype(t, but);
winunlock(w);
goto Continue;
}
if(ptinrect(m.xy, t->scrollr)){
if(but){
if(t->what == Columntag)
rowdragcol(&row, t->col, but);
else if(t->what == Tag){
coldragwin(t->col, t->w, but);
if(t->w)
barttext = &t->w->body;
}
if(t->col)
activecol = t->col;
}
goto Continue;
}
if(m.buttons){
if(w)
winlock(w, 'M');
t->eq0 = ~0;
if(w)
wincommit(w, t);
else
textcommit(t, TRUE);
if(m.buttons & 1){
textselect(t);
if(w)
winsettag(w);
argtext = t;
seltext = t;
if(t->col)
activecol = t->col; /* button 1 only */
if(t->w!=nil && t==&t->w->body)
activewin = t->w;
}else if(m.buttons & 2){
if(textselect2(t, &q0, &q1, &argt))
execute(t, q0, q1, FALSE, argt);
}else if(m.buttons & 4){
if(textselect3(t, &q0, &q1))
look3(t, q0, q1, FALSE);
}
if(w)
winunlock(w);
goto Continue;
}
Continue:
qunlock(&row.lk);
break;
}
}
}
