workbench/prefs/locale/page_timezone.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /*********************************************************************************************/
  10
  11 #include "global.h"
  12 #include <stdio.h>
  13
  14 #include "earthmap_small_image.c"
  15 #include "timezones_small_image.c"
  16
  17 /*********************************************************************************************/
  18
  19 #define DOUBLE_ARROWS           1
  20
  21 #define CONTINENT_RED           18
  22 #define CONTINENT_GREEN         114
  23 #define CONTINENT_BLUE          58
  24
  25 #define OCEAN_RED               21
  26 #define OCEAN_GREEN             18
  27 #define OCEAN_BLUE              114
  28
  29 #define SELECTED_INTENSITY_INC  80
  30
  31 #define GAD_DEC                 1000
  32 #define GAD_INC                 1001
  33 #define GAD_TEXT                1002
  34
  35 /*********************************************************************************************/
  36
  37 #define NUM_TIMEZONES 36
  38
  39 static struct timezone
  40 {
  41     WORD id;
  42     WORD minoffset;
  43     WORD pen;
  44 }
  45 timezone_table[NUM_TIMEZONES] =
  46 {
  47     {  0,   0           }, /* Z :    0:00 */
  48     {  1,   1 * 60      }, /* A : +  1:00 */
  49     {  2,   2 * 60      }, /* B : +  2:00 */
  50     {  3,   3 * 60      }, /* C : +  3:00 */
  51     {  4,   3 * 60 + 30 }, /* C*: +  3:30 */
  52     {  5,   4 * 60      }, /* D : +  4:00 */
  53     {  6,   4 * 60 + 30 }, /* D*: +  4:30 */
  54     {  7,   5 * 60      }, /* E : +  5:00 */
  55     {  8,   5 * 60 + 30 }, /* E*: +  5:30 */
  56     {  9,   6 * 60      }, /* F : +  6:00 */
  57     { 10,   6 * 60 + 30 }, /* F*: +  6:30 */
  58     { 11,   7 * 60      }, /* G : +  7:00 */
  59     { 12,   8 * 60      }, /* H : +  8:00 */
  60     { 13,   9 * 60      }, /* I : +  9:00 */
  61     { 14,   9 * 60 + 30 }, /* I*: +  9:30 */
  62     { 15,  10 * 60      }, /* K : + 10:00 */
  63     { 16,  10 * 60 + 30 }, /* K*: + 10:30 */
  64     { 17,  11 * 60      }, /* L : + 11:00 */
  65     { 18,  11 * 60 + 30 }, /* L*: + 11:30 */
  66     { 19,  12 * 60      }, /* M : + 12:00 */
  67     { 20,  13 * 60      }, /* M*: + 13:00 */
  68     { 35, -12 * 60      }, /* Y : - 12:00 */
  69     { 34, -11 * 60      }, /* X : - 11:00 */
  70     { 33, -10 * 60      }, /* W : - 10:00 */
  71     { 32,  -9 * 60 - 30 }, /* V*: -  9:30 */
  72     { 31,  -9 * 60      }, /* V : -  9:00 */
  73     { 30,  -8 * 60 - 30 }, /* U*: -  8:30 */
  74     { 29,  -8 * 60      }, /* U : -  8:00 */
  75     { 28,  -7 * 60      }, /* T : -  7:00 */
  76     { 27,  -6 * 60      }, /* S : -  6:00 */
  77     { 26,  -5 * 60      }, /* R : -  5:00 */
  78     { 25,  -4 * 60      }, /* Q : -  4:00 */
  79     { 24,  -3 * 60 - 30 }, /* P*: -  3:30 */
  80     { 23,  -3 * 60      }, /* P : -  3:00 */
  81     { 22,  -2 * 60      }, /* O : -  2:00 */
  82     { 21,  -1 * 60      }, /* N : -  1:00 */
  83
  84 };
  85
  86 /*********************************************************************************************/
  87
  88 static struct Gadget *gadlist, *textgad, *gad;
  89 static WORD minwidth, minheight;
  90 static WORD domleft, domtop, domwidth, domheight;
  91 static WORD active_timezone;
  92 static BOOL init_done;
  93
  94 static UBYTE timezones_chunky[TIMEZONES_SMALL_WIDTH * TIMEZONES_SMALL_HEIGHT];
  95 static UBYTE earthmap_chunky[EARTHMAP_SMALL_WIDTH * EARTHMAP_SMALL_HEIGHT];
  96 static UBYTE *earthmap_chunky_remapped;
  97
  98 static ULONG earthmap_coltab[256];
  99 static WORD  remaptable[256];
 100 static UBYTE timezone_text[256];
 101 static WORD  pen2index[NUM_TIMEZONES];
 102
 103 static BOOL pens_alloced, page_active;
 104
 105 /*********************************************************************************************/
 106
 107 #if EARTHMAP_SMALL_PACKED || TIMEZONES_SMALL_PACKED
 108
 109 static UBYTE *unpack_byterun1(UBYTE *source, UBYTE *dest, LONG unpackedsize)
 110 {
 111     UBYTE r;
 112     BYTE c;
 113
 114     for(;;)
 115     {
 116         c = (BYTE)(*source++);
 117         if (c >= 0)
 118         {
 119             while(c-- >= 0)
 120             {
 121                 *dest++ = *source++;
 122                 if (--unpackedsize <= 0) return source;
 123             }
 124         }
 125         else if (c != -128)
 126         {
 127             c = -c;
 128             r = *source++;
 129
 130             while(c-- >= 0)
 131             {
 132                 *dest++ = r;
 133                 if (--unpackedsize <= 0) return source;
 134             }
 135         }
 136     }
 137
 138 }
 139
 140 #endif
 141
 142 /*********************************************************************************************/
 143
 144 static LONG timezone_init(void)
 145 {
 146     WORD i;
 147
 148     if (!truecolor)
 149     {
 150         earthmap_chunky_remapped = AllocVec(EARTHMAP_SMALL_WIDTH * EARTHMAP_SMALL_HEIGHT, MEMF_PUBLIC);
 151         if (!earthmap_chunky_remapped) return FALSE;
 152     }
 153
 154 #if EARTHMAP_SMALL_PACKED
 155     unpack_byterun1(earthmap_small_data, earthmap_chunky, EARTHMAP_SMALL_WIDTH * EARTHMAP_SMALL_HEIGHT);
 156 #endif
 157 #if TIMEZONES_SMALL_PACKED
 158     unpack_byterun1(timezones_small_data, timezones_chunky, TIMEZONES_SMALL_WIDTH * TIMEZONES_SMALL_HEIGHT);
 159 #endif
 160
 161
 162     for(i = 0; i < EARTHMAP_SMALL_COLORS; i++)
 163     {
 164         static struct TagItem   obp_tags[] =
 165         {
 166             {OBP_Precision, PRECISION_IMAGE },
 167             {OBP_FailIfBad, FALSE           },
 168             {TAG_DONE                       }
 169         };
 170         ULONG                   rgb = earthmap_small_pal[i];
 171         ULONG                   r = (rgb & 0xFF0000) >> 16;
 172         ULONG                   g = (rgb & 0x00FF00) >> 8;
 173         ULONG                   b = (rgb & 0x0000FF);
 174         ULONG                   a = (r + g + b) / 3;
 175
 176         r = (a * OCEAN_RED   + (255 - a) * CONTINENT_RED  ) / 255;
 177         g = (a * OCEAN_GREEN + (255 - a) * CONTINENT_GREEN) / 255;
 178         b = (a * OCEAN_BLUE  + (255 - a) * CONTINENT_BLUE ) / 255;
 179
 180         rgb = (r << 16) + (g << 8) + b;
 181
 182         earthmap_coltab[i] = rgb;
 183
 184         if (!truecolor)
 185         {
 186             remaptable[i] = ObtainBestPenA(scr->ViewPort.ColorMap,
 187                                            r * 0x01010101,
 188                                            g * 0x01010101,
 189                                            b * 0x01010101,
 190                                            obp_tags);
 191         }
 192
 193         r += SELECTED_INTENSITY_INC; if (r > 255) r = 255;
 194         g += SELECTED_INTENSITY_INC; if (g > 255) g = 255;
 195         b += SELECTED_INTENSITY_INC; if (b > 255) b = 255;
 196
 197         rgb = (r << 16) + (g << 8) + b;
 198
 199         earthmap_coltab[128 + i] = rgb;
 200
 201         if (!truecolor)
 202         {
 203             remaptable[128 + i] = ObtainBestPenA(scr->ViewPort.ColorMap,
 204                                                  r * 0x01010101,
 205                                                  g * 0x01010101,
 206                                                  b * 0x01010101,
 207                                                  obp_tags);
 208         }
 209
 210     }
 211
 212     if (!truecolor) pens_alloced = TRUE;
 213
 214     /* For each timezone find out, with which pen (index) it is
 215        represented in the timezones image */
 216
 217     for(i = 0; i < NUM_TIMEZONES; i++)
 218     {
 219         WORD id = timezone_table[i].id;
 220         WORD i2;
 221         ULONG r = ((id & 0x30) >> 4) * 64;
 222         ULONG g = ((id & 0x0C) >> 2) * 64;
 223         ULONG b = ((id & 0x03)     ) * 64;
 224         ULONG rgb = (r << 16) + (g << 8) + b;
 225
 226         timezone_table[i].pen = -1;
 227         for(i2 = 0; i2 < TIMEZONES_SMALL_COLORS; i2++)
 228         {
 229             if (timezones_small_pal[i2] == rgb)
 230             {
 231                 timezone_table[i].pen = i2;
 232                 break;
 233             }
 234         }
 235
 236         pen2index[id] = i;
 237     }
 238
 239     init_done = TRUE;
 240
 241     return TRUE;
 242 }
 243
 244 /*********************************************************************************************/
 245
 246 static void ClearEarthmapSelection(void)
 247 {
 248     LONG l;
 249
 250     for(l = 0; l < EARTHMAP_SMALL_WIDTH * EARTHMAP_SMALL_HEIGHT; l++)
 251     {
 252         earthmap_chunky[l] &= 127;
 253     }
 254 }
 255
 256 /*********************************************************************************************/
 257
 258 static void SetEarthmapSelection(UBYTE timezonespen)
 259 {
 260     LONG l;
 261
 262     for(l = 0; l < EARTHMAP_SMALL_WIDTH * EARTHMAP_SMALL_HEIGHT; l++)
 263     {
 264         if (timezones_chunky[l] == timezonespen) earthmap_chunky[l] |= 128;
 265     }
 266 }
 267
 268 /*********************************************************************************************/
 269
 270 static void RepaintEarthmap(void)
 271 {
 272     if (page_active)
 273     {
 274         CONST_STRPTR fmt;
 275         WORD   minoffset;
 276
 277         minoffset = timezone_table[active_timezone].minoffset;
 278         if (minoffset < 0) minoffset = -minoffset;
 279
 280         if (truecolor)
 281         {
 282             WriteLUTPixelArray(earthmap_chunky,
 283                                0,
 284                                0,
 285                                EARTHMAP_SMALL_WIDTH,
 286                                win->RPort,
 287                                earthmap_coltab,
 288                                domleft + 1,
 289                                domtop  + 1,
 290                                EARTHMAP_SMALL_WIDTH,
 291                                EARTHMAP_SMALL_HEIGHT,
 292                                CTABFMT_XRGB8);
 293         }
 294         else
 295         {
 296             LONG l;
 297
 298             for(l = 0; l < EARTHMAP_SMALL_WIDTH * EARTHMAP_SMALL_HEIGHT; l++)
 299             {
 300                 earthmap_chunky_remapped[l] = remaptable[earthmap_chunky[l]];
 301             }
 302
 303             WriteChunkyPixels(win->RPort,
 304                               domleft + 1,
 305                               domtop  + 1,
 306                               domleft + 1 + EARTHMAP_SMALL_WIDTH  - 1,
 307                               domtop  + 1 + EARTHMAP_SMALL_HEIGHT - 1,
 308                               earthmap_chunky_remapped,
 309                               EARTHMAP_SMALL_WIDTH);
 310         }
 311
 312         if (minoffset == 60)
 313         {
 314             fmt = MSG(MSG_TIMEZONE_1HOUR);
 315         }
 316         else if (minoffset % 60)
 317         {
 318             fmt = MSG(MSG_TIMEZONE_HOURSMINS);
 319         }
 320         else
 321         {
 322             fmt = MSG(MSG_TIMEZONE_HOURS);
 323         }
 324
 325         sprintf(timezone_text, fmt, minoffset / 60, minoffset % 60);
 326
 327         GT_SetGadgetAttrs(textgad, win, NULL, GTTX_Text, (IPTR)timezone_text,
 328                                               TAG_DONE);
 329
 330     } /* if (page_active) */
 331 }
 332
 333 /*********************************************************************************************/
 334
 335 static void scroll_timezone(WORD delta)
 336 {
 337     active_timezone += delta;
 338
 339     if (active_timezone < 0)
 340     {
 341         active_timezone = NUM_TIMEZONES - 1;
 342     }
 343     else if (active_timezone >= NUM_TIMEZONES)
 344     {
 345         active_timezone = 0;
 346     }
 347
 348     ClearEarthmapSelection();
 349     SetEarthmapSelection(timezone_table[active_timezone].pen);
 350     RepaintEarthmap();
 351 }
 352
 353 /*********************************************************************************************/
 354
 355 static LONG timezone_input(struct IntuiMessage *msg)
 356 {
 357     LONG retval = FALSE;
 358
 359     if ((msg->Class == IDCMP_MOUSEBUTTONS) && (msg->Code == SELECTDOWN))
 360     {
 361         WORD x = msg->MouseX - (domleft + 1);
 362         WORD y = msg->MouseY - (domtop + 1);
 363
 364         if ((x >= 0) &&
 365             (y >= 0) &&
 366             (x <= domwidth - 2) &&
 367             (y <= domheight - 2))
 368         {
 369             ULONG timezonergb;
 370             LONG timezoneid;
 371             UBYTE timezonepen;
 372
 373             retval = TRUE;
 374
 375             timezonepen = timezones_chunky[y * TIMEZONES_SMALL_WIDTH + x];
 376             timezonergb = timezones_small_pal[timezonepen];
 377             timezoneid =  (timezonergb & 0xC00000) >> (16 + 2);
 378             timezoneid += (timezonergb & 0x00C000) >> (8 + 4);
 379             timezoneid += (timezonergb & 0x0000C0) >> (0 + 6);
 380
 381             if ((timezoneid >= 0) && (timezoneid < NUM_TIMEZONES))
 382             {
 383                 active_timezone = pen2index[timezoneid];
 384
 385                 /* AmigaOS seems to have the sign the other way round, therefore the "-" */
 386
 387                 localeprefs.lp_GMTOffset = -timezone_table[active_timezone].minoffset;
 388
 389                 ClearEarthmapSelection();
 390                 SetEarthmapSelection(timezonepen);
 391                 RepaintEarthmap();
 392
 393             }
 394
 395         }
 396
 397     }
 398     else if ((msg->Class == IDCMP_RAWKEY))
 399     {
 400         switch(msg->Code)
 401         {
 402             case CURSORLEFT:
 403                 scroll_timezone(-1);
 404                 retval = TRUE;
 405                 break;
 406
 407             case CURSORRIGHT:
 408                 scroll_timezone(1);
 409                 retval = TRUE;
 410                 break;
 411
 412         }
 413     }
 414     else if ((msg->Class == IDCMP_GADGETUP))
 415     {
 416         struct Gadget *gad = (struct Gadget *)msg->IAddress;
 417
 418         switch(gad->GadgetID)
 419         {
 420             case GAD_DEC:
 421                 scroll_timezone(-1);
 422                 retval = TRUE;
 423                 break;
 424
 425             case GAD_INC:
 426                 scroll_timezone(1);
 427                 retval = TRUE;
 428                 break;
 429         }
 430     }
 431
 432     return retval;
 433 }
 434
 435 /*********************************************************************************************/
 436
 437 static void timezone_cleanup(void)
 438 {
 439     WORD i;
 440
 441     if (earthmap_chunky_remapped)
 442     {
 443         FreeVec(earthmap_chunky_remapped);
 444         earthmap_chunky_remapped = NULL;
 445     }
 446
 447     if (pens_alloced)
 448     {
 449         for(i = 0; i < EARTHMAP_SMALL_COLORS; i++)
 450         {
 451             if (remaptable[i]       != -1) ReleasePen(scr->ViewPort.ColorMap, remaptable[i]);
 452             if (remaptable[128 + i] != -1) ReleasePen(scr->ViewPort.ColorMap, remaptable[128 + i]);
 453         }
 454         pens_alloced = FALSE;
 455     }
 456
 457     if (gadlist) FreeGadgets(gadlist);
 458     gadlist = NULL;
 459 }
 460
 461 /*********************************************************************************************/
 462
 463 static LONG timezone_makegadgets(void)
 464 {
 465     struct NewGadget ng;
 466     WORD w;
 467
 468     w = dri->dri_Font->tf_XSize + 8;
 469
 470     gad = CreateContext(&gadlist);
 471
 472     ng.ng_LeftEdge   = domleft;
 473     ng.ng_TopEdge    = domtop + EARTHMAP_SMALL_HEIGHT + 2 + SPACE_Y;
 474     ng.ng_Width      = w;
 475     ng.ng_Height     = dri->dri_Font->tf_YSize + BUTTON_EXTRAHEIGHT;
 476     ng.ng_GadgetText = "<";
 477     ng.ng_TextAttr   = 0;
 478     ng.ng_GadgetID   = GAD_DEC;
 479     ng.ng_Flags      = 0;
 480     ng.ng_VisualInfo = vi;
 481
 482     gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 483
 484 #if DOUBLE_ARROWS
 485     ng.ng_LeftEdge   = domleft + domwidth - w - w;
 486
 487     gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 488 #endif
 489
 490     ng.ng_LeftEdge   = domleft + domwidth - w;
 491     ng.ng_GadgetText = ">";
 492     ng.ng_GadgetID   = GAD_INC;
 493
 494     gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 495
 496 #if DOUBLE_ARROWS
 497     ng.ng_LeftEdge   = domleft + w;
 498
 499     gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 500 #endif
 501
 502
 503 #if DOUBLE_ARROWS
 504     ng.ng_LeftEdge   = domleft + w * 2 + SPACE_X;
 505     ng.ng_Width      = domwidth - w * 4 - SPACE_X * 2;
 506 #else
 507     ng.ng_LeftEdge   = domleft + w + SPACE_X;
 508     ng.ng_Width      = domwidth - w * 2 - SPACE_X * 2;
 509 #endif
 510     ng.ng_GadgetID   = GAD_TEXT;
 511     ng.ng_GadgetText = NULL;
 512
 513     gad = textgad = CreateGadget(TEXT_KIND, gad, &ng, GTTX_Border       , TRUE          ,
 514                                                       GTTX_Clipped      , TRUE          ,
 515                                                       GTTX_Text         , (IPTR)"hello" ,
 516                                                       GTTX_Justification, GTJ_CENTER    ,
 517                                                       TAG_DONE);
 518     return gad ? TRUE : FALSE;
 519 }
 520
 521 /*********************************************************************************************/
 522
 523 static void timezone_prefs_changed(void)
 524 {
 525     WORD i;
 526
 527     for(i = 0; i < NUM_TIMEZONES; i++)
 528     {
 529         /* AmigaOS seems to have the sign the other way round, therefore the "-" */
 530
 531         if (-localeprefs.lp_GMTOffset == timezone_table[i].minoffset)
 532         {
 533             active_timezone = i;
 534             break;
 535         }
 536     }
 537
 538     if (init_done)
 539     {
 540         ClearEarthmapSelection();
 541         SetEarthmapSelection(timezone_table[active_timezone].pen);
 542         RepaintEarthmap();
 543     }
 544
 545 }
 546
 547 /*********************************************************************************************/
 548
 549 static void DrawEarthmapFrame(void)
 550 {
 551     SetDrMd(win->RPort, JAM1);
 552
 553     SetAPen(win->RPort, dri->dri_Pens[SHADOWPEN]);
 554
 555     RectFill(win->RPort, domleft,
 556                          domtop,
 557                          domleft + domwidth - 2,
 558                          domtop);
 559
 560     RectFill(win->RPort, domleft,
 561                          domtop + 1,
 562                          domleft,
 563                          domtop + EARTHMAP_SMALL_HEIGHT + 2 - 1);
 564
 565     SetAPen(win->RPort, dri->dri_Pens[SHINEPEN]);
 566
 567     RectFill(win->RPort, domleft + domwidth - 1,
 568                          domtop,
 569                          domleft + domwidth - 1,
 570                          domtop + EARTHMAP_SMALL_HEIGHT + 2 - 1);
 571
 572     RectFill(win->RPort, domleft + 1,
 573                          domtop + EARTHMAP_SMALL_HEIGHT + 2 - 1,
 574                          domleft + domwidth - 2,
 575                          domtop + EARTHMAP_SMALL_HEIGHT + 2 - 1);
 576 }
 577
 578 /*********************************************************************************************/
 579
 580 LONG page_timezone_handler(LONG cmd, IPTR param)
 581 {
 582     LONG retval = TRUE;
 583
 584     switch(cmd)
 585     {
 586         case PAGECMD_INIT:
 587             retval = timezone_init();
 588             break;
 589
 590         case PAGECMD_LAYOUT:
 591             minwidth  = EARTHMAP_SMALL_WIDTH + 2;
 592             minheight = EARTHMAP_SMALL_HEIGHT + 2 + dri->dri_Font->tf_YSize + BUTTON_EXTRAHEIGHT + SPACE_Y;
 593             break;
 594
 595         case PAGECMD_GETMINWIDTH:
 596             retval = minwidth;
 597             break;
 598
 599         case PAGECMD_GETMINHEIGHT:
 600             retval = minheight;
 601             break;
 602
 603         case PAGECMD_SETDOMLEFT:
 604             domleft = param;
 605             break;
 606
 607         case PAGECMD_SETDOMTOP:
 608             domtop = param;
 609             break;
 610
 611         case PAGECMD_SETDOMWIDTH:
 612             /* domwidth = param; */
 613             domwidth = minwidth;
 614             domleft += (param - minwidth ) /2;
 615             break;
 616
 617         case PAGECMD_SETDOMHEIGHT:
 618             /* domheight = param; */
 619             domheight = minheight;
 620             domtop += (param - minheight) / 2;
 621             break;
 622
 623         case PAGECMD_MAKEGADGETS:
 624             retval = timezone_makegadgets();
 625             break;
 626
 627         case PAGECMD_ADDGADGETS:
 628             if (!page_active)
 629             {
 630                 DrawEarthmapFrame();
 631
 632                 AddGList(win, gadlist, -1, -1, NULL);
 633                 GT_RefreshWindow(win, NULL);
 634                 RefreshGList(gadlist, win, NULL, -1);
 635
 636                 ClearEarthmapSelection();
 637                 SetEarthmapSelection(timezone_table[active_timezone].pen);
 638
 639                 page_active = TRUE;
 640
 641                 RepaintEarthmap();
 642             }
 643             break;
 644
 645         case PAGECMD_REMGADGETS:
 646             if (page_active)
 647             {
 648                 if (gadlist) RemoveGList(win, gadlist, -1);
 649
 650                 page_active = FALSE;
 651             }
 652             break;
 653
 654         case PAGECMD_REFRESH:
 655             DrawEarthmapFrame();
 656             RepaintEarthmap();
 657             break;
 658
 659         case PAGECMD_HANDLEINPUT:
 660             retval = timezone_input((struct IntuiMessage *)param);
 661             break;
 662
 663         case PAGECMD_PREFS_CHANGED:
 664             timezone_prefs_changed();
 665             break;
 666
 667         case PAGECMD_CLEANUP:
 668             timezone_cleanup();
 669             break;
 670     }
 671
 672     return retval;
 673
 674 }