snow/dockapps
1
0
Fork 0
Code Issues Releases Activity
dockapps/wmglobe/src/wmgutil.c

2358 lines
52 KiB
C
Raw Normal View History

wmglobe: Add version 0.5 to repository. From http://web.cs.mun.ca/~gstarkes/wmaker/dockapps/files/wmglobe-0.5.tar.gz
2016-12-27 19:22:04 +00:00
/* WMGlobe 0.5 - All the Earth on a WMaker Icon
* copyright (C) 1998,99 Jerome Dumonteil <jerome.dumonteil@capway.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***************************************************************************/
/*
* I used many functions of wmgeneral.c ("openXwindow")
* for the main function of wmglobe.c
* wmgeneral.c was taken from wmaker applet wmtune-1.0 :
* Author: Martijn Pieterse (pieterse@xs4all.nl)
*
* wmglobe.c uses functions of : Xglobe, Xearth, wmgeneral, wmaker/wrlib
***************************************************************************/
#include "wmglobe.h"
#include "zapnum.xpm"
#include "zaptxt.xpm"
#include "zapnum.h"
#include "scrpos.xpm"
#include "scrtime.xpm"
#include "scrdiv.xpm"
static void move_earth(double vla, double vlo);
static int flush_expose(Window w);
static void mqparam();
static double getdegre(char *val);
static void screen_1();
static void screen_2();
static void screen_3();
static void screen_4();
static void screen_5();
static void screen_6();
static void screen_7();
static void write_icon(char *txt, int x, int y);
static void chiffre(int ch, int xx, int yy);
static int lettre(char c, int xx, int yy);
static void display_pos(double la, double lo);
static void display_date(double la, double lo);
static void release_but(int ckm);
static void press_but(int ckm);
static void display_zoom();
static void display_light();
static void display_accel();
static void display_dlat();
static void display_type();
static void move_delay(int factor);
static void move_zoom(int factor);
static void move_light(int factor);
static void move_dawn(int factor);
static void move_accel(int factor);
static void move_dlat(int factor);
static void move_dlong(int factor);
/* ------------------------------------------------------------------------ */
/*
* TIME FUNCTIONS
*/
/* ------------------------------------------------------------------------ */
struct timeval diftimev(struct timeval t1, struct timeval t2)
{
t1.tv_usec -= t2.tv_usec;
if (t1.tv_usec < 0) {
t1.tv_usec += 1000000;
t1.tv_sec--;
}
t1.tv_sec -= t2.tv_sec;
return t1;
}
/* ------------------------------------------------------------------------ */
struct timeval addtimev(struct timeval t1, struct timeval t2)
{
t1.tv_usec += t2.tv_usec;
if (t1.tv_usec >= 1000000) {
t1.tv_usec -= 1000000;
t1.tv_sec++;
}
t1.tv_sec += t2.tv_sec;
return t1;
}
/* ------------------------------------------------------------------------ */
struct timeval getimev()
{
struct timeval tv;
struct timezone tz;
gettimeofday(&tv, &tz);
return tv;
}
/* ------------------------------------------------------------------------ */
/*
* INIT FUNCTIONS
*
* defaults, commandline
* init of pixmap for screenpos and numbers displaying
*/
/* ------------------------------------------------------------------------ */
void loadxpm(Window draw)
{
XpmCreatePixmapFromData(dpy, draw, scrpos_xpm, &(screenpos.pixmap),
&(screenpos.mask), &(screenpos.attributes));
XpmCreatePixmapFromData(dpy, draw, scrtime_xpm, &(scrdate.pixmap),
&(scrdate.mask), &(scrdate.attributes));
XpmCreatePixmapFromData(dpy, draw, zapnum_xpm, &(numpix.pixmap),
&(numpix.mask), &(numpix.attributes));
XpmCreatePixmapFromData(dpy, draw, zaptxt_xpm, &(txtpix.pixmap),
&(txtpix.mask), &(txtpix.attributes));
XpmCreatePixmapFromData(dpy, draw, scrdiv_xpm, &(scrdiv.pixmap),
&(scrdiv.mask), &(scrdiv.attributes));
return;
}
/* ------------------------------------------------------------------------ */
void set_defaults()
{
firstTime = TRUE;
dayfile = NULL;
use_nightmap = FALSE;
nightfile = NULL;
oknimap = DEFAULT_NIGHTMAP;
p_type = PTSUNREL;
delay = DEFAULT_DELAY;
tini = getimev();
tbase = tini;
tsunpos = 0;
tlast.tv_sec = 0;
tlast.tv_usec = 0;
do_something = TRUE;
time_multi = 1.0;
v_lat = DEFAULT_V_LAT / 180. * PI;
v_long = DEFAULT_V_LONG / 180. * PI;
dv_lat = DEFAULT_V_LAT;
dv_long = DEFAULT_V_LONG;
old_dvlat = DEFAULT_V_LAT;
old_dvlong = DEFAULT_V_LONG;
iop = 0;
dlat = 0.0;
dlong = 0.0;
addlat = 0.0;
addlong = 0.0;
radius = 1000.0;
sun_long = 0.0;
sun_lat = 0.0;
fov = 0.5 * PI / 180.;
sens = DEFAULT_SENS;
zoom = DEFAULT_ZOOM;
ambient_light = DEFAULT_LIGHT;
dawn = DEFAULT_DAWN;
typecadre = DEFAULT_BORDER;
fun = FALSE;
funx = 0;
funy = 0;
dpy_name = NULL;
onlyshape = TRUE;
option_iw = WithdrawnState;
stoprand = FALSE;
solution = FALSE;
proj_dist = DIAMETRE / tan(fov);
noir.red = 0;
noir.green = 0;
noir.blue = 0;
noir.alpha = 255;
md[0] = (MPO *) malloc(sizeof(MPO));
md[1] = (MPO *) malloc(sizeof(MPO));
md[2] = (MPO *) malloc(sizeof(MPO));
md[3] = (MPO *) malloc(sizeof(MPO));
mn[0] = (MPO *) malloc(sizeof(MPO));
mn[1] = (MPO *) malloc(sizeof(MPO));
mn[2] = (MPO *) malloc(sizeof(MPO));
mn[3] = (MPO *) malloc(sizeof(MPO));
#ifdef DEBUG
minhz = 1.;
#endif
return;
}
/* ------------------------------------------------------------------------ */
static double getdegre(char *val)
{
double d, m, s;
if (strchr(val, '<EFBFBD>') != NULL || strchr(val, 'd') != NULL
|| strchr(val, 'D') != NULL || strchr(val, ':') != NULL) {
d = m = s = 0;
sscanf(val, "%lf%*c%lf%*c%lf", &d, &m, &s);
if (d >= 0.)
return d + m / 60. + s / 3600.;
else
return d - m / 60. - s / 3600.;
} else {
return atof(val);
}
}
/* ------------------------------------------------------------------------ */
static void mqparam()
{
printf("error in parameters\n");
exit(1);
}
/* ------------------------------------------------------------------------ */
void cmdline(int argc, char *argv[])
{
int i, j;
if (argc > 0) {
for (i = 1; i < argc; i++) {
j = 0;
/* ---------------------------------------------------- */
if (strcasecmp(argv[i], "-v") == 0
|| strcasecmp(argv[i], "-version") == 0) {
printf("%s\n", WMGVERSION);
exit(0);
}
/* ---------------------------------------------------- */
if (strcasecmp(argv[i], "-w") == 0
|| strcasecmp(argv[i], "-wmaker") == 0) {
option_iw = WithdrawnState;
j = 1;
}
/* ---------------------------------------------------- */
if (strcasecmp(argv[i], "-i") == 0
|| strcasecmp(argv[i], "-iconic") == 0) {
option_iw = IconicState;
j = 1;
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-s") == 0 ||
strcasecmp(argv[i], "-shape") == 0)) {
onlyshape = TRUE;
j = 1;
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-d") == 0
|| strcasecmp(argv[i], "-display") == 0)) {
i++;
if (i < argc) {
j = 1;
dpy_name = argv[i];
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-rand") == 0
|| strcasecmp(argv[i], "-random") == 0)) {
p_type = PTRANDOM;
srandom(((int) time(NULL)) + ((int) getpid()));
j = 1;
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-oz") == 0
|| strcasecmp(argv[i], "-austral") == 0)) {
sens = -1;
j = 1;
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-map") == 0) {
i++;
if (i < argc) {
j = 1;
free(dayfile);
if ((dayfile = (char *) malloc(strlen(argv[i]) + 1)) == NULL) {
fprintf(stderr, "erreur memoire options map\n");
exit(1);
};
strcpy(dayfile, argv[i]);
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-nimap") == 0
|| strcasecmp(argv[i], "-nightmap") == 0
|| strcasecmp(argv[i], "-night") == 0)) {
i++;
if (i < argc) {
j = 1;
free(nightfile);
if ((nightfile = (char *) malloc(strlen(argv[i]) + 1)) == NULL) {
fprintf(stderr, "erreur memoire options nimap\n");
exit(1);
};
strcpy(nightfile, argv[i]);
use_nightmap = TRUE;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-accel") == 0
|| strcasecmp(argv[i], "-accell") == 0
|| strcasecmp(argv[i], "-acc") == 0
|| strcasecmp(argv[i], "-multi") == 0)) {
i++;
if (i < argc) {
j = 1;
time_multi = atof(argv[i]);
if (time_multi < 1.0)
time_multi = 1.0;
if (time_multi > MAX_MULTI_COEF)
time_multi = MAX_MULTI_COEF;
if (time_multi > 24.0)
time_multi = floor(time_multi);
else
time_multi = floor(time_multi * 10.0) / 10.0;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-nonimap") == 0
|| strcasecmp(argv[i], "-nonightmap") == 0
|| strcasecmp(argv[i], "-nonight") == 0
|| strcasecmp(argv[i], "-nomap") == 0)) {
j = 1;
use_nightmap = FALSE;
oknimap = FALSE;
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-zoom") == 0) {
i++;
if (i < argc) {
j = 1;
zoom = atof(argv[i]);
if (zoom < ZOOM_MIN)
zoom = ZOOM_MIN;
if (zoom > ZOOM_MAX)
zoom = ZOOM_MAX;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-dawn") == 0) {
i++;
if (i < argc) {
j = 1;
dawn = atof(argv[i]);
dawn = MAX(0.0, dawn);
dawn = MIN(1.0, dawn);
dawn = (1.0 - dawn / 2.0);
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-delay") == 0) {
i++;
if (i < argc) {
j = 1;
delay = atof(argv[i]);
if (delay < 0)
delay = 0;
if (delay > MAX_DELAY_SEC)
delay = MAX_DELAY_SEC;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-dlat") == 0
|| strcasecmp(argv[i], "-lat") == 0
|| strcasecmp(argv[i], "-dlatitude") == 0)) {
i++;
if (i < argc) {
j = 1;
dlat = getdegre(argv[i]);
if (dlat < -MAX_DELTA_LONG)
dlat = -MAX_DELTA_LONG;
if (dlat > MAX_DELTA_LONG)
dlat = MAX_DELTA_LONG;
p_type = PTFIXED;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-dlong") == 0
|| strcasecmp(argv[i], "-long") == 0
|| strcasecmp(argv[i], "-dlongitude") == 0)) {
i++;
if (i < argc) {
j = 1;
dlong = getdegre(argv[i]);
if (dlong < -MAX_DELTA_LONG)
dlong = -MAX_DELTA_LONG;
if (dlong > MAX_DELTA_LONG)
dlong = MAX_DELTA_LONG;
p_type = PTFIXED;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-light") == 0) {
i++;
if (i < argc) {
j = 1;
ambient_light = atof(argv[i]);
if (ambient_light < 0.)
ambient_light = 0.;
if (ambient_light > 1.)
ambient_light = 1.;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-time") == 0) {
i++;
if (i < argc) {
j = 1;
tbase.tv_sec = atoi(argv[i]);
tbase.tv_usec = 0;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-bord") == 0
|| strcasecmp(argv[i], "-border") == 0)) {
i++;
if (i < argc) {
j = 1;
typecadre = atoi(argv[i]);
if (typecadre < 0)
typecadre = 0;
if (typecadre > 2)
typecadre = 2;
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && strcasecmp(argv[i], "-fun") == 0) {
fun = TRUE;
i++;
if (i < argc) {
funx = atoi(argv[i]);
i++;
if (i < argc) {
j = 1;
funy = atoi(argv[i]);
} else {
mqparam();
i--;
}
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && (strcasecmp(argv[i], "-pos") == 0
|| strcasecmp(argv[i], "-position") == 0
|| strcasecmp(argv[i], "-fixed") == 0)) {
p_type = PTFIXED;
i++;
if (i < argc) {
addlat = getdegre(argv[i]);
i++;
if (i < argc) {
j = 1;
addlong = getdegre(argv[i]);
} else {
mqparam();
i--;
}
} else {
mqparam();
i--;
}
}
/* ---------------------------------------------------- */
if (!j && argv[i][0] == '-') {
printf("%s\n", WMGVERSION);
printf("\n");
printf("-v : version -h : this help message !\n");
printf("-zoom zoom_value : changing apparent size in icon\n");
printf("-pos latitude long. : fixed initial position (default=follow sun)\n");
printf("-rand : random position at every refresh\n");
printf("-map map_file : use this map for rendering\n");
printf("-nimap night_file : and this one for the dark side of earth\n");
printf("-nonimap : don't use the default night map\n");
printf("-delay seconds : time between refresh of image\n");
printf("-dlat delta_lat : latitude speed of point of view (default=follow sun)\n");
printf("-dlong delta_long : the same for longitude\n");
printf("-light light_value : level of light for dark side of earth\n");
printf("-dawn dawn_value : level of continuity for dawn limit\n");
printf("-bord border_num : 0 1 or 2 , type of icon border.\n");
printf("-accel time_multi : time accelerator\n");
printf("-time seconds : time to display in seconds since 01-01-1970\n");
printf("-oz : start in \"austral\" mode (for \"down under\" people)\n");
printf("-fun dx dy : offset of vision... almost useless\n");
printf("-w -shape : set by default (WMaker dockable application)\n");
printf("-d display : display (WindowMaker not needed on the server side)\n");
printf("left button : change longitude, with shift key, change latitude too\n");
printf("middle button : zoom in, shift + middle button : zoom out\n");
printf("right button : access to a few screens of parameters\n");
exit(0);
}
/* ------------------------------------------------------------------------ */
}
}
return;
}
/****************************************************************************
* X functions, mouse selection
*
*/
/* ------------------------------------------------------------------------ */
static int flush_expose(Window w)
{
XEvent dummy;
int i = 0;
while (XCheckTypedWindowEvent(dpy, w, Expose, &dummy))
i++;
return i;
}
/* ------------------------------------------------------------------------ */
void RedrawWindowXYWH(int x, int y, int w, int h)
{
flush_expose(iconwin);
XCopyArea(dpy, wmg.pixmap, iconwin, NormalGC, x, y, w, h, x, y);
flush_expose(win);
XCopyArea(dpy, wmg.pixmap, win, NormalGC, x, y, w, h, x, y);
return;
}
/* ------------------------------------------------------------------------ */
void AddMouseRegion(int index, int left, int top, int right, int bottom)
{
if (index < MAX_MOUSE_REGION) {
mouse_region[index].enable = 1;
mouse_region[index].top = top;
mouse_region[index].left = left;
mouse_region[index].bottom = bottom;
mouse_region[index].right = right;
}
return;
}
/* ------------------------------------------------------------------------ */
int CheckMouseRegion(int x, int y)
{
int i;
int found;
found = 0;
for (i = 0; i < MAX_MOUSE_REGION && !found; i++) {
if (mouse_region[i].enable &&
x <= mouse_region[i].right &&
x >= mouse_region[i].left &&
y <= mouse_region[i].bottom &&
y >= mouse_region[i].top)
found = 1;
}
if (!found)
return -1;
return (i - 1);
}
/* ------------------------------------------------------------------------ */
/*
* GRAPHIC : pixmap writing of letters & numbers
*
*/
/* ------------------------------------------------------------------------ */
static void chiffre(int ch, int xx, int yy)
{
XCopyArea(dpy, numpix.pixmap, wmg.pixmap, NormalGC,
zapnum[ch][0], zapnum[ch][1], zapnum[ch][2], zapnum[ch][3], xx, yy);
return;
}
/* ------------------------------------------------------------------------ */
static int lettre(char c, int xx, int yy)
{
int i;
if (c == '<EFBFBD>')
i = 288;
else
switch (toupper(c)) {
case '0':
i = 0;
break;
case '1':
i = 6;
break;
case '2':
i = 12;
break;
case '3':
i = 18;
break;
case '4':
i = 24;
break;
case '5':
i = 30;
break;
case '6':
i = 36;
break;
case '7':
i = 42;
break;
case '8':
i = 48;
break;
case '9':
i = 54;
break;
case '+':
i = 60;
break;
case 'A':
i = 66;
break;
case 'B':
i = 72;
break;
case 'C':
i = 78;
break;
case 'D':
i = 84;
break;
case 'E':
i = 90;
break;
case 'F':
i = 96;
break;
case 'G':
i = 102;
break;
case 'H':
i = 108;
break;
case 'I':
i = 114;
break;
case 'J':
i = 120;
break;
case 'K':
i = 126;
break;
case 'L':
i = 132;
break;
case 'M':
i = 138;
break;
case 'N':
i = 144;
break;
case 'O':
i = 150;
break;
case 'P':
i = 156;
break;
case 'Q':
i = 162;
break;
case 'R':
i = 168;
break;
case 'S':
i = 174;
break;
case 'T':
i = 180;
break;
case 'U':
i = 186;
break;
case 'V':
i = 192;
break;
case 'W':
i = 198;
break;
case 'X':
i = 204;
break;
case 'Y':
i = 210;
break;
case 'Z':
i = 216;
break;
case ' ':
i = 222;
break;
case ':':
i = 228;
break;
case '/':
i = 234;
break;
case '!':
i = 240;
break;
case '*':
i = 246;
break;
case '-':
i = 252;
break;
case '.':
i = 258;
break;
case '=':
i = 264;
break;
case '#':
i = 270;
break;
case '<':
i = 276;
break;
case '>':
i = 282;
break;
case '"':
i = 294;
break;
case '\'':
i = 300;
break;
case ',':
i = 306;
break;
case '@':
i = 312;
break;
case '(':
i = 318;
break;
case ')':
i = 324;
break;
case '&':
i = 330;
break;
case '~':
i = 336;
break;
case '<EFBFBD>':
i = 342;
break;
case '<EFBFBD>':
i = 348;
break;
case '{':
i = 354;
break;
case '}':
i = 360;
break;
case '[':
i = 366;
break;
case ']':
i = 372;
break;
case '\\':
i = 378;
break;
case '|':
i = 384;
break;
case '?':
i = 390;
break;
case '%':
i = 396;
break;
default:
i = 222;
break;
}
XCopyArea(dpy, txtpix.pixmap, wmg.pixmap, NormalGC,
i, 0, 6, 10, xx, yy);
return xx + 6;
}
/* ------------------------------------------------------------------------ */
static void write_icon(char *txt, int x, int y)
{
int p, ok;
p = 0;
#ifdef DEBUG
fprintf(stdout, "%s_\n", txt);
#endif
ok = TRUE;
while (ok) {
if (txt[p] == '\0' || x > DIAMETRE - 5) {
ok = FALSE;
} else {
x = lettre(txt[p], x, y);
p++;
}
}
return;
}
/* ------------------------------------------------------------------------ */
static void press_but(int ckm)
{
switch (ckm) {
case 5:
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 38, 20, 9, 2, 52);
RedrawWindowXYWH(2, 52, 20, 9);
break;
case 6:
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
20, 38, 20, 9, 22, 52);
RedrawWindowXYWH(22, 52, 20, 9);
break;
case 7:
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
40, 38, 20, 9, 42, 52);
RedrawWindowXYWH(42, 52, 20, 9);
break;
default:
break;
}
return;
}
/* ------------------------------------------------------------------------ */
static void release_but(int ckm)
{
switch (ckm) {
case 5:
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 28, 20, 9, 2, 52);
RedrawWindowXYWH(2, 52, 20, 9);
break;
case 6:
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
20, 28, 20, 9, 22, 52);
RedrawWindowXYWH(22, 52, 20, 9);
break;
case 7:
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
40, 28, 20, 9, 42, 52);
RedrawWindowXYWH(42, 52, 20, 9);
break;
default:
break;
}
return;
}
/* ------------------------------------------------------------------------ */
/*
* MENU SELECTION & ACTIONS
*/
/* ------------------------------------------------------------------------ */
void screen_back()
{
AddMouseRegion(0, 0, 0, 0, 0);
if (p_type == PTRANDOM) {
stoprand = STOP_RANDOM_FACTOR;
addlong = dv_long;
addlat = dv_lat;
}
gotoscr = 1;
while (gotoscr != 0) {
switch (gotoscr) {
case 1:
screen_1();
break;
case 2:
screen_2();
break;
case 3:
screen_3();
break;
case 4:
screen_4();
break;
case 5:
screen_5();
break;
case 6:
screen_6();
break;
case 7:
screen_7();
break;
default:
break;
}
XFlush(dpy);
}
/*
* put old environment
*/
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, pixmask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, pixmask, ShapeSet);
AddMouseRegion(0, 5, 5, DIAMETRE - 4, DIAMETRE - 4);
stoprand = FALSE;
do_something = TRUE;
return;
}
/* ------------------------------------------------------------------------ */
static void display_pos(double la, double lo)
{
int c, i, j, k, l, neg;
if (la > 0) {
neg = 10;
} else {
neg = 11;
la *= -1;
}
i = floor(la / 10.0);
la -= 10 * i;
j = floor(la);
la -= j;
la *= 60;
k = floor(la / 10.0);
la -= 10 * k;
l = floor(la);
if (i == 0) {
i = neg;
neg = 10;
}
chiffre(neg, platd[1][0], platd[1][1]);
chiffre(i, platd[2][0], platd[2][1]);
chiffre(j, platd[3][0], platd[3][1]);
chiffre(k, platm[0][0], platd[0][1]);
chiffre(l, platm[1][0], platd[1][1]);
if (lo > 0) {
neg = 12;
} else {
neg = 11;
lo *= -1;
}
c = floor(lo / 100.0);
lo -= c * 100;
if (c > 0) {
if (neg == 11)
neg = 13;
} else {
if (neg == 11) {
c = neg;
} else {
c = 10;
}
neg = 12;
}
i = floor(lo / 10.0);
lo -= 10 * i;
j = floor(lo);
lo -= j;
lo *= 60;
k = floor(lo / 10.0);
lo -= 10 * k;
l = floor(lo);
if (i == 0 && c > 9) {
i = c;
c = 10;
}
chiffre(neg, plongd[0][0], plongd[0][1]);
chiffre(c, plongd[1][0], plongd[1][1]);
chiffre(i, plongd[2][0], plongd[2][1]);
chiffre(j, plongd[3][0], plongd[3][1]);
chiffre(k, plongm[0][0], plongm[0][1]);
chiffre(l, plongm[1][0], plongm[1][1]);
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
return;
}
/* ------------------------------------------------------------------------ */
void rotation_terre(int x, int y, int lat_flag)
{
/*
* earth rotate after (while) a clic
*/
double mx, my;
mx = (double) ((double) x - DIAMETRE / 2 + 0.5) / zoom * cos(v_lat) * sens;
if (lat_flag) {
my = -(double) ((double) y - DIAMETRE / 2 + 0.5) * sens / zoom;
if (my > 0.0)
my += ABS(sin(v_lat) * ((double) x - DIAMETRE / 2 + 0.5) / zoom);
else
my -= ABS(sin(v_lat) * ((double) x - DIAMETRE / 2 + 0.5) / zoom);
} else {
my = 0;
}
if (p_type == PTRANDOM) {
stoprand = STOP_RANDOM_FACTOR;
addlong = dv_long;
addlat = dv_lat;
}
addlong += mx * RATIO_ROTATE;
addlat += my * RATIO_ROTATE;
do_something = TRUE;
return;
}
/* ------------------------------------------------------------------------ */
static void move_earth(double vla, double vlo)
{
addlat += vla;
addlong += vlo;
switch (p_type) {
case PTSUNREL:
setViewPos(sun_lat * 180. / PI + addlat,
sun_long * 180. / PI + addlong);
break;
case PTFIXED:
case PTRANDOM:
setViewPos(addlat, addlong);
break;
default:
break;
}
display_pos(dv_lat, dv_long);
return;
}
/* ------------------------------------------------------------------------ */
static void screen_1()
{
int ok, ckm, sensadd, waitrel, not3;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 1\n");
#endif
tin = getimev();
waitrel = 0;
ckm = 0;
sensadd = 1;
not3 = TRUE;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, screenpos.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, screenpos.mask, ShapeSet);
XCopyArea(dpy, screenpos.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
AddMouseRegion(1, platd[0][0], platd[0][1], platd[3][0] + 9, platd[3][1] + 12);
AddMouseRegion(2, platm[0][0], platm[0][1], platm[1][0] + 9, platm[1][1] + 12);
AddMouseRegion(3, plongd[0][0], plongd[0][1], plongd[3][0] + 9, plongd[3][1] + 12);
AddMouseRegion(4, plongm[0][0], plongm[0][1], plongm[1][0] + 9, plongm[1][1] + 12);
AddMouseRegion(5, 1, 51, 21, 61);
AddMouseRegion(6, 22, 51, 41, 61);
AddMouseRegion(7, 42, 51, 62, 61);
display_pos(dv_lat, dv_long);
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
not3 = TRUE;
sensadd = 1;
break;
case 2:
not3 = TRUE;
sensadd = -1;
break;
case 3:
not3 = FALSE;
if (ckm < 5)
gotoscr = 0;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel && not3) {
if (ckm == 1) {
move_earth(sens * sensadd * 1.0, 0.0);
usleep(VAL_USLEEP);
}
if (ckm == 2) {
move_earth(sens * sensadd * 1.0 / 60.0, 0.0);
usleep(VAL_USLEEP);
}
if (ckm == 3) {
move_earth(0.0, sens * sensadd * 1.0);
usleep(VAL_USLEEP);
}
if (ckm == 4) {
move_earth(0.0, sens * sensadd * 1.0 / 60.0);
usleep(VAL_USLEEP);
}
}
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 1)
gotoscr = 0;
if (gotoscr != 1)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
static void display_date(double la, double lo)
{
char datest[32];
time_t t;
int i, j;
write_icon(" time :", 2, 2);
RedrawWindowXYWH(2, 2, DIAMETRE - 1, DIAMETRE - 1);
write_icon(" GMT+long.", 2, 14);
RedrawWindowXYWH(2, 14, DIAMETRE - 1, DIAMETRE - 1);
t = trend.tv_sec;
t += (int) (floor((lo + 7.5) / 15.0) * 3600);
/*** pb near 2038 ***/
strftime(datest, 30, "%x", gmtime(&t));
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 26);
RedrawWindowXYWH(2, 26, DIAMETRE - 1, DIAMETRE - 1);
strftime(datest, 30, "%X", gmtime(&t));
i = 10 - strlen(datest);
if (i < 0) {
i = 0;
while (datest[i] != '\0') {
if (datest[i] != ' ') {
i++;
} else {
j = i;
do {
datest[j] = datest[j + 1];
j++;
}
while (datest[j - 1] != '\0');
}
}
i = 0;
} else {
i = i / 2;
}
write_icon(datest, 2 + i * 6, 38);
RedrawWindowXYWH(2, 38, DIAMETRE - 1, DIAMETRE - 1);
return;
}
/* ------------------------------------------------------------------------ */
static void screen_2()
{
int ok, ckm, waitrel;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 2\n");
#endif
tin = getimev();
waitrel = 0;
ckm = 0;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XCopyArea(dpy, scrdate.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
display_date(dv_lat, dv_long);
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
break;
case 2:
break;
case 3:
if (ckm < 5)
gotoscr = 0;
break;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 2)
gotoscr = 0;
if (gotoscr != 2)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
static void display_zoom()
{
char datest[32], dstr[32];
int i;
write_icon(" delay :", 2, 2);
RedrawWindowXYWH(2, 2, DIAMETRE - 1, DIAMETRE - 1);
sprintf(dstr, "%f", delay);
dstr[8] = '\0';
i = strlen(dstr) - 1;
while (i > 0) {
if (dstr[i] == '0') {
dstr[i] = '\0';
i--;
} else {
i = 0;
}
}
i = strlen(dstr) - 1;
if (dstr[i] == '.')
dstr[i] = '\0';
sprintf(datest, "%s s", dstr);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 14);
RedrawWindowXYWH(2, 14, DIAMETRE - 1, DIAMETRE - 1);
write_icon(" zoom :", 2, 26);
RedrawWindowXYWH(2, 26, DIAMETRE - 1, DIAMETRE - 1);
sprintf(datest, "%.3f", zoom);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 38);
RedrawWindowXYWH(2, 38, DIAMETRE - 1, DIAMETRE - 1);
return;
}
/* ------------------------------------------------------------------------ */
static void move_delay(int factor)
{
if (factor == 1) {
if (delay < (double) VAL_USLEEP / 1000000)
delay = (double) VAL_USLEEP / 1000000;
else if (delay < 0.1) {
delay += 0.01;
if (delay > 0.1)
delay = 0.2;
} else if (delay < 1.) {
delay += 0.1;
if (delay > 1.0)
delay = 2.;
} else if (delay < 60.)
delay += 1.;
else if (delay < 300.)
delay += 10.;
else if (delay < 3600.)
delay += 60.;
else if (delay < MAX_DELAY_SEC)
delay += 360.;
if (delay > MAX_DELAY_SEC)
delay = MAX_DELAY_SEC;
} else {
if (delay > 3600.)
delay -= 360.;
else if (delay > 300.)
delay -= 60.;
else if (delay > 60.)
delay -= 10.;
else if (delay > 1.)
delay -= 1.;
else if (delay > 0.1)
delay -= 0.1;
else if (delay > (double) VAL_USLEEP / 1000000)
delay -= 0.01;
else
delay = 0.0;
if (delay < (double) VAL_USLEEP / 1000000)
delay = 0.0;
}
tdelay.tv_sec = (int) floor(delay);
tdelay.tv_usec = (int) ((delay - tdelay.tv_sec) * 1000000);
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 14);
display_zoom();
return;
}
/* ------------------------------------------------------------------------ */
void zooming(int facto)
{
if (facto)
zoom /= ZOOM_FACTOR;
else
zoom *= ZOOM_FACTOR;
zoom = MAX(zoom, ZOOM_MIN);
zoom = MIN(zoom, ZOOM_MAX);
if (p_type == PTRANDOM) {
addlong = dv_long;
addlat = dv_lat;
stoprand = STOP_RANDOM_FACTOR;
}
calcDistance();
do_something = TRUE;
return;
}
/* ------------------------------------------------------------------------ */
static void move_zoom(int factor)
{
if (factor == -1)
zooming(1);
else
zooming(0);
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 38);
display_zoom();
return;
}
/* ------------------------------------------------------------------------ */
static void screen_3()
{
int ok, ckm, waitrel, sensadd, not3;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 3\n");
#endif
tin = getimev();
waitrel = 0;
ckm = 0;
sensadd = 0;
not3 = TRUE;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XCopyArea(dpy, scrdate.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
AddMouseRegion(1, 2, 14, DIAMETRE - 2, 25);
AddMouseRegion(2, 2, 38, DIAMETRE - 2, 49);
display_zoom();
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
not3 = TRUE;
sensadd = 1;
break;
case 2:
not3 = TRUE;
sensadd = -1;
break;
case 3:
not3 = FALSE;
if (ckm < 5)
gotoscr = 0;
break;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel && not3) {
if (ckm == 1) {
move_delay(sensadd);
usleep(2 * VAL_USLEEP);
}
if (ckm == 2) {
move_zoom(sensadd);
usleep(VAL_USLEEP);
}
}
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 3)
gotoscr = 0;
if (gotoscr != 3)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
static void display_light()
{
char datest[32];
int i;
write_icon(" light :", 2, 2);
RedrawWindowXYWH(2, 2, DIAMETRE - 1, DIAMETRE - 1);
sprintf(datest, "%.2f", ambient_light);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 14);
RedrawWindowXYWH(2, 14, DIAMETRE - 1, DIAMETRE - 1);
write_icon(" dawn :", 2, 26);
RedrawWindowXYWH(2, 26, DIAMETRE - 1, DIAMETRE - 1);
dawn = (1.0 - dawn) * 2.0;
sprintf(datest, "%.2f", dawn);
dawn = (1.0 - dawn / 2.0);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 38);
RedrawWindowXYWH(2, 38, DIAMETRE - 1, DIAMETRE - 1);
return;
}
/* ------------------------------------------------------------------------ */
static void move_light(int factor)
{
ambient_light += factor / 20.0;
ambient_light = MAX(0.0, ambient_light);
ambient_light = MIN(1.0, ambient_light);
aml = (int) floor(ambient_light * 256);
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 14);
display_light();
return;
}
/* ------------------------------------------------------------------------ */
static void move_dawn(int factor)
{
dawn = (1.0 - dawn) * 2.0;
dawn += factor / 20.0;
dawn = MAX(0.0, dawn);
dawn = MIN(1.0, dawn);
dawn = (1.0 - dawn / 2.0);
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 38);
display_light();
return;
}
/* ------------------------------------------------------------------------ */
static void screen_4()
{
int ok, ckm, waitrel, sensadd, not3;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 4\n");
#endif
tin = getimev();
waitrel = 0;
ckm = 0;
sensadd = 0;
not3 = TRUE;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XCopyArea(dpy, scrdate.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
AddMouseRegion(1, 2, 14, DIAMETRE - 2, 25);
AddMouseRegion(2, 2, 38, DIAMETRE - 2, 49);
display_light();
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
not3 = TRUE;
sensadd = 1;
break;
case 2:
not3 = TRUE;
sensadd = -1;
break;
case 3:
not3 = FALSE;
if (ckm < 5)
gotoscr = 0;
break;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel && not3) {
if (ckm == 1) {
move_light(sensadd);
usleep(VAL_USLEEP);
}
if (ckm == 2) {
move_dawn(sensadd);
usleep(VAL_USLEEP);
}
}
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 4)
gotoscr = 0;
if (gotoscr != 4)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
static void display_accel()
{
char datest[32];
int i;
write_icon(" accel :", 2, 2);
RedrawWindowXYWH(2, 2, DIAMETRE - 1, DIAMETRE - 1);
if (time_multi < 24.0)
sprintf(datest, "%.1f", time_multi);
else
sprintf(datest, "%.0f", time_multi);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 14);
RedrawWindowXYWH(2, 14, DIAMETRE - 1, DIAMETRE - 1);
write_icon("night map:", 2, 26);
RedrawWindowXYWH(2, 26, DIAMETRE - 1, DIAMETRE - 1);
if (use_nightmap)
write_icon(" yes ", 2, 38);
else
write_icon(" no ", 2, 38);
RedrawWindowXYWH(2, 38, DIAMETRE - 1, DIAMETRE - 1);
return;
}
/* ------------------------------------------------------------------------ */
static void move_accel(int factor)
{
if (factor == 1) {
if (time_multi < 1.0)
time_multi = 1.0;
if (time_multi < 24.0)
time_multi += 0.2;
else if (time_multi < 60.0) {
time_multi = floor(time_multi);
time_multi += 1.0;
} else if (time_multi < 120.0) {
time_multi = floor(time_multi);
time_multi += 2.0;
} else if (time_multi < 240.0) {
time_multi = floor(time_multi);
time_multi += 4.0;
} else if (time_multi < 600.0) {
time_multi = floor(time_multi);
time_multi += 10.0;
} else if (time_multi < 1200.0) {
time_multi = floor(time_multi);
time_multi += 20.0;
} else if (time_multi < 2400.0) {
time_multi = floor(time_multi);
time_multi += 40.0;
} else if (time_multi < 6000.0) {
time_multi = floor(time_multi);
time_multi += 100.0;
} else if (time_multi < 12000.0) {
time_multi = floor(time_multi);
time_multi += 200.0;
} else if (time_multi < 24000.0) {
time_multi = floor(time_multi);
time_multi += 400.0;
} else if (time_multi < 60000.0) {
time_multi = floor(time_multi);
time_multi += 1000.0;
} else if (time_multi < 120000.0) {
time_multi = floor(time_multi);
time_multi += 2000.0;
} else if (time_multi < 240000.0) {
time_multi = floor(time_multi);
time_multi += 4000.0;
} else {
time_multi = floor(time_multi);
time_multi += 8000.0;
}
if (time_multi > MAX_MULTI_COEF)
time_multi = MAX_MULTI_COEF;
} else {
if (time_multi < 24.1)
time_multi -= 0.2;
else if (time_multi < 60.2) {
time_multi = floor(time_multi);
time_multi -= 1.0;
} else if (time_multi < 121.0) {
time_multi = floor(time_multi);
time_multi -= 2.0;
} else if (time_multi < 241.0) {
time_multi = floor(time_multi);
time_multi -= 4.0;
} else if (time_multi < 601.0) {
time_multi = floor(time_multi);
time_multi -= 10.0;
} else if (time_multi < 1201.0) {
time_multi = floor(time_multi);
time_multi -= 20.0;
} else if (time_multi < 2401.0) {
time_multi = floor(time_multi);
time_multi -= 40.0;
} else if (time_multi < 6001.0) {
time_multi = floor(time_multi);
time_multi -= 100.0;
} else if (time_multi < 12001.0) {
time_multi = floor(time_multi);
time_multi -= 200.0;
} else if (time_multi < 24001.0) {
time_multi = floor(time_multi);
time_multi -= 400.0;
} else if (time_multi < 60001.0) {
time_multi = floor(time_multi);
time_multi -= 1000.0;
} else if (time_multi < 120001.0) {
time_multi = floor(time_multi);
time_multi -= 2000.0;
} else if (time_multi < 240001.0) {
time_multi = floor(time_multi);
time_multi -= 4000.0;
} else {
time_multi = floor(time_multi);
time_multi -= 8000.0;
}
if (time_multi > 24.0)
time_multi = floor(time_multi);
if (time_multi < 1.0)
time_multi = 1.0;
}
tini = tlast;
tbase = trend;
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 14);
display_accel();
return;
}
/* ------------------------------------------------------------------------ */
static void screen_5()
{
int ok, ckm, waitrel, sensadd, not3;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 5\n");
#endif
tin = getimev();
waitrel = 0;
ckm = 0;
sensadd = 0;
not3 = TRUE;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XCopyArea(dpy, scrdate.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
AddMouseRegion(1, 2, 14, DIAMETRE - 2, 25);
AddMouseRegion(2, 2, 38, DIAMETRE - 2, 49);
display_accel();
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
not3 = TRUE;
sensadd = 1;
break;
case 2:
not3 = TRUE;
sensadd = -1;
break;
case 3:
not3 = FALSE;
if (ckm < 5)
gotoscr = 0;
break;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel && not3) {
if (ckm == 1) {
move_accel(sensadd);
usleep(VAL_USLEEP);
}
if (ckm == 2) {
not3 = FALSE;
if (use_nightmap) {
use_nightmap = FALSE;
display_accel();
} else {
if (use_nmap_ini) {
use_nightmap = TRUE;
display_accel();
}
}
usleep(VAL_USLEEP);
}
}
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 5)
gotoscr = 0;
if (gotoscr != 5)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
static void display_dlat()
{
char datest[32];
int i, d, m, nega, nego;
write_icon(" dlat :", 2, 2);
RedrawWindowXYWH(2, 2, DIAMETRE - 1, DIAMETRE - 1);
if (dlat < 0.0) {
nega = TRUE;
dlat *= -1;
} else
nega = FALSE;
m = (int) floor((dlat - floor(dlat)) * 60.0);
d = (int) floor(dlat);
if (nega) {
sprintf(datest, "-%d<>%02d'", d, m);
dlat *= -1;
} else
sprintf(datest, "%d<>%02d'", d, m);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 14);
RedrawWindowXYWH(2, 14, DIAMETRE - 1, DIAMETRE - 1);
write_icon(" dlong :", 2, 26);
RedrawWindowXYWH(2, 26, DIAMETRE - 1, DIAMETRE - 1);
if (dlong < 0.0) {
nego = TRUE;
dlong *= -1;
} else
nego = FALSE;
m = (int) floor((dlong - floor(dlong)) * 60.0);
d = (int) floor(dlong);
if (nego) {
sprintf(datest, "-%d<>%02d'", d, m);
dlong *= -1;
} else
sprintf(datest, "%d<>%02d'", d, m);
i = 10 - strlen(datest);
if (i < 0)
i = 0;
else
i = i / 2;
write_icon(datest, 2 + i * 6, 38);
RedrawWindowXYWH(2, 38, DIAMETRE - 1, DIAMETRE - 1);
return;
}
/* ------------------------------------------------------------------------ */
static void move_dlat(int factor)
{
dlat += factor / 4.0;
if (dlat > MAX_DELTA_LONG)
dlat = MAX_DELTA_LONG;
if (dlat < -MAX_DELTA_LONG)
dlat = -MAX_DELTA_LONG;
if (dlat < 0.25 && dlat > -0.25)
dlat = 0;
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 14);
if (dlat != 0.)
p_type = PTFIXED;
display_dlat();
return;
}
/* ------------------------------------------------------------------------ */
static void move_dlong(int factor)
{
dlong += factor / 4.0;
if (dlong > MAX_DELTA_LONG)
dlong = MAX_DELTA_LONG;
if (dlong < -MAX_DELTA_LONG)
dlong = -MAX_DELTA_LONG;
if (dlong < 0.25 && dlong > -0.25)
dlong = 0;
XCopyArea(dpy, scrdiv.pixmap, wmg.pixmap, NormalGC,
0, 15, 60, 10, 2, 38);
if (dlong != 0.)
p_type = PTFIXED;
display_dlat();
return;
}
/* ------------------------------------------------------------------------ */
static void screen_6()
{
int ok, ckm, waitrel, sensadd, not3;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 6\n");
#endif
tin = getimev();
waitrel = 0;
sensadd = 0;
ckm = 0;
not3 = TRUE;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XCopyArea(dpy, scrdate.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
AddMouseRegion(1, 2, 14, DIAMETRE - 2, 25);
AddMouseRegion(2, 2, 38, DIAMETRE - 2, 49);
display_dlat();
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
not3 = TRUE;
sensadd = 1;
break;
case 2:
not3 = TRUE;
sensadd = -1;
break;
case 3:
not3 = FALSE;;
if (ckm < 5)
gotoscr = 0;
break;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel && not3) {
if (ckm == 1 && p_type != PTRANDOM) {
move_dlat(sensadd);
usleep(VAL_USLEEP);
}
if (ckm == 2 && p_type != PTRANDOM) {
move_dlong(sensadd);
usleep(VAL_USLEEP);
}
}
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 6)
gotoscr = 0;
if (gotoscr != 6)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
static void display_type()
{
char c, cc, mess[12];
write_icon(" view :", 2, 2);
RedrawWindowXYWH(2, 2, DIAMETRE - 1, DIAMETRE - 1);
if (p_type == PTFIXED) {
c = '>';
cc = '<';
} else {
c = ' ';
cc = ' ';
}
sprintf(mess, "%c move %c", c, cc);
write_icon(mess, 2, 14);
RedrawWindowXYWH(2, 14, DIAMETRE - 1, DIAMETRE - 1);
if (p_type == PTSUNREL) {
c = '>';
cc = '<';
} else {
c = ' ';
cc = ' ';
}
sprintf(mess, "%c sun %c", c, cc);
write_icon(mess, 2, 26);
RedrawWindowXYWH(2, 26, DIAMETRE - 1, DIAMETRE - 1);
if (p_type == PTRANDOM) {
c = '>';
cc = '<';
} else {
c = ' ';
cc = ' ';
}
sprintf(mess, "%c random %c", c, cc);
write_icon(mess, 2, 38);
RedrawWindowXYWH(2, 38, DIAMETRE - 1, DIAMETRE - 1);
return;
}
/* ------------------------------------------------------------------------ */
static void screen_7()
{
int ok, ckm, waitrel, sensadd, not3;
struct timeval tin;
#ifdef DEBUG
fprintf(stdout, "scr 7\n");
#endif
tin = getimev();
waitrel = 0;
sensadd = 0;
ckm = 0;
not3 = TRUE;
XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XShapeCombineMask(dpy, iconwin, ShapeBounding, 0, 0, scrdate.mask, ShapeSet);
XCopyArea(dpy, scrdate.pixmap, wmg.pixmap, NormalGC, 0, 0, DIAMETRE, DIAMETRE, 0, 0);
AddMouseRegion(1, 2, 14, DIAMETRE - 2, 25);
AddMouseRegion(2, 2, 26, DIAMETRE - 2, 37);
AddMouseRegion(3, 2, 38, DIAMETRE - 2, 49);
display_type(0);
ok = TRUE;
while (ok) {
while (XPending(dpy)) {
XNextEvent(dpy, &Event);
switch (Event.type) {
case Expose:
RedrawWindowXYWH(0, 0, DIAMETRE, DIAMETRE);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
break;
case ButtonPress:
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
waitrel = 1;
press_but(ckm);
switch (Event.xbutton.button) {
case 1:
not3 = TRUE;
if (ckm < 4 && ckm > 0)
sensadd = ckm;
break;
case 2:
not3 = TRUE;
break;
case 3:
not3 = FALSE;
if (ckm < 5)
gotoscr = 0;
break;
default:
break;
}
break;
case ButtonRelease:
release_but(ckm);
waitrel = ckm;
ckm = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
if (waitrel == ckm) {
switch (ckm) {
case 5:
gotoscr--;
if (gotoscr == 0)
gotoscr = NUM_SCREEN;
break;
case 6:
gotoscr++;
if (gotoscr > NUM_SCREEN)
gotoscr = 1;
break;
case 7:
gotoscr = 0;
default:
break;
}
}
ckm = 0;
waitrel = 0;
tin = getimev();
break;
default:
break;
}
}
usleep(VAL_USLEEP_SHORT);
if (waitrel && not3 && sensadd) {
if (sensadd == 2) {
if (p_type != PTSUNREL) {
p_type = PTSUNREL;
dlat = 0;
dlong = 0;
display_type();
}
}
if (sensadd == 1) {
if (p_type != PTFIXED) {
p_type = PTFIXED;
display_type();
}
}
if (sensadd == 3) {
if (p_type != PTRANDOM) {
p_type = PTRANDOM;
dlat = 0;
dlong = 0;
display_type();
}
}
}
sensadd = 0;
if (waitrel == 0 && diftimev(getimev(), tin).tv_sec > SCREEN_WAIT && gotoscr == 7)
gotoscr = 0;
if (gotoscr != 7)
ok = FALSE;
}
return;
}
/* ------------------------------------------------------------------------ */
Reference in a new issue Copy permalink