[BACK]Return to dclock.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / win9x

Diff for /np2/win9x/dclock.cpp between versions 1.1.1.1 and 1.5

version 1.1.1.1, 2003/10/16 17:58:52 version 1.5, 2005/02/16 09:31:55
Line 8 Line 8
 #include        "palettes.h"  #include        "palettes.h"
   
   
         DCLOCK_T        dclock;          _DCLOCK         dclock;
         BYTE            dclock_dat[(DCLOCK_X * DCLOCK_Y / 8) + 4];          DCLOCKPAL       dclockpal;
         RGB32           dclock_pal[4];  
   
 static  BYTE dclocky[13] = {0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3};  
 #define DCLOCKY_MAX     13  
   
 static  DWORD   outcolors[4][16];  
 static  UINT16  outcolors16[4];  
   
   
 // ------------------------------------------------------------------ font1  // ------------------------------------------------------------------ font1
   
 static  BYTE clockchr1[11][16] = {  static const UINT8 clockchr1[11][16] = {
                         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},                          {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},
                         {0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x78,},                          {0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x78,},
                         {0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,},                          {0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,},
Line 34  static BYTE clockchr1[11][16] = { Line 27  static BYTE clockchr1[11][16] = {
                         {0x78, 0xcc, 0xcc, 0xcc, 0x78, 0xcc, 0xcc, 0xcc, 0x78,},                          {0x78, 0xcc, 0xcc, 0xcc, 0x78, 0xcc, 0xcc, 0xcc, 0x78,},
                         {0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x18, 0x70,}};                          {0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x18, 0x70,}};
   
 static  DCLOCK_POS dclockpos1[6] = {  static const DCPOS dclockpos1[6] = {
                                                 {&dclock_dat[0], (WORD)(~0x00fc), 0, 0},                                                  {dclock.dat + 0, (UINT16)(~0x00fc), 0, 0},
                                                 {&dclock_dat[0], (WORD)(~0xf801), 7, 0},                                                  {dclock.dat + 0, (UINT16)(~0xf801), 7, 0},
                                                 {&dclock_dat[2], (WORD)(~0x801f), 3, 0},                                                  {dclock.dat + 2, (UINT16)(~0x801f), 3, 0},
                                                 {&dclock_dat[3], (WORD)(~0x003f), 2, 0},                                                  {dclock.dat + 3, (UINT16)(~0x003f), 2, 0},
                                                 {&dclock_dat[4], (WORD)(~0xf003), 6, 0},                                                  {dclock.dat + 4, (UINT16)(~0xf003), 6, 0},
                                                 {&dclock_dat[5], (WORD)(~0xe007), 5, 0}};                                                  {dclock.dat + 5, (UINT16)(~0xe007), 5, 0}};
   
 static void resetfont1(void) {  static void resetfont1(void) {
   
         DWORD pat;          UINT32  pat;
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 53  static void resetfont1(void) { Line 46  static void resetfont1(void) {
                 else {                  else {
                         pat = 0x30008001;                          pat = 0x30008001;
                 }                  }
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*4+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 4 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*5+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 5 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*9+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 9 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*10+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + (10 * DCLOCK_YALIGN)) = pat;
         }          }
 }  }
   
   
 // ------------------------------------------------------------------ font2  // ------------------------------------------------------------------ font2
   
 // 5x9  // 5x9
 static  BYTE clockchr2[11][16] = {  static const UINT8 clockchr2[11][16] = {
                         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},                          {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},
                         {0x00, 0x00, 0x30, 0x48, 0x88, 0x88, 0x88, 0x88, 0x70,},                          {0x00, 0x00, 0x30, 0x48, 0x88, 0x88, 0x88, 0x88, 0x70,},
                         {0x10, 0x30, 0x10, 0x10, 0x10, 0x20, 0x20, 0x20, 0x20,},                          {0x10, 0x30, 0x10, 0x10, 0x10, 0x20, 0x20, 0x20, 0x20,},
Line 76  static BYTE clockchr2[11][16] = { Line 70  static BYTE clockchr2[11][16] = {
                         {0x38, 0x44, 0x44, 0x48, 0x30, 0x48, 0x88, 0x88, 0x70,},                          {0x38, 0x44, 0x44, 0x48, 0x30, 0x48, 0x88, 0x88, 0x70,},
                         {0x18, 0x24, 0x40, 0x44, 0x48, 0x38, 0x10, 0x20, 0x20,}};                          {0x18, 0x24, 0x40, 0x44, 0x48, 0x38, 0x10, 0x20, 0x20,}};
   
 static  DCLOCK_POS dclockpos2[6] = {  static const DCPOS dclockpos2[6] = {
                                                 {&dclock_dat[0], (WORD)(~0x00fc), 0, 0},                                                  {dclock.dat + 0, (UINT16)(~0x00fc), 0, 0},
                                                 {&dclock_dat[0], (WORD)(~0xf003), 6, 0},                                                  {dclock.dat + 0, (UINT16)(~0xf003), 6, 0},
                                                 {&dclock_dat[2], (WORD)(~0x00fc), 0, 0},                                                  {dclock.dat + 2, (UINT16)(~0x00fc), 0, 0},
                                                 {&dclock_dat[2], (WORD)(~0xf003), 6, 0},                                                  {dclock.dat + 2, (UINT16)(~0xf003), 6, 0},
                                                 {&dclock_dat[4], (WORD)(~0x00fc), 0, 0},                                                  {dclock.dat + 4, (UINT16)(~0x00fc), 0, 0},
                                                 {&dclock_dat[4], (WORD)(~0xf003), 6, 0}};                                                  {dclock.dat + 4, (UINT16)(~0xf003), 6, 0}};
   
 static void resetfont2(void) {  static void resetfont2(void) {
   
         DWORD pat;          UINT32  pat;
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 95  static void resetfont2(void) { Line 89  static void resetfont2(void) {
                 else {                  else {
                         pat = 0x00020002;                          pat = 0x00020002;
                 }                  }
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*4+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 4 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*5+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 5 * DCLOCK_YALIGN)) = pat;
                 pat <<= 1;                  pat <<= 1;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*9+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 9 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*10+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + (10 * DCLOCK_YALIGN)) = pat;
         }          }
 }  }
   
   
 // ------------------------------------------------------------------ font3  // ------------------------------------------------------------------ font3
   
 // 4x9  // 4x9
 static  BYTE clockchr3[11][16] = {  static const UINT8 clockchr3[11][16] = {
                         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},                          {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},
                         {0x60, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x60,},                          {0x60, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x60,},
                         {0x20, 0x60, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,},                          {0x20, 0x60, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,},
Line 119  static BYTE clockchr3[11][16] = { Line 114  static BYTE clockchr3[11][16] = {
                         {0x60, 0x90, 0x90, 0x90, 0x60, 0x90, 0x90, 0x90, 0x60,},                          {0x60, 0x90, 0x90, 0x90, 0x60, 0x90, 0x90, 0x90, 0x60,},
                         {0x60, 0x90, 0x90, 0x90, 0x70, 0x10, 0x90, 0x90, 0x60,}};                          {0x60, 0x90, 0x90, 0x90, 0x70, 0x10, 0x90, 0x90, 0x60,}};
   
 static  DCLOCK_POS dclockpos3[6] = {  static const DCPOS dclockpos3[6] = {
                                                 {&dclock_dat[0], (WORD)(~0x00f0), 0, 0},                                                  {dclock.dat + 0, (UINT16)(~0x00f0), 0, 0},
                                                 {&dclock_dat[0], (WORD)(~0x8007), 5, 0},                                                  {dclock.dat + 0, (UINT16)(~0x8007), 5, 0},
                                                 {&dclock_dat[1], (WORD)(~0xc003), 6, 0},                                                  {dclock.dat + 1, (UINT16)(~0xc003), 6, 0},
                                                 {&dclock_dat[2], (WORD)(~0x001e), 3, 0},                                                  {dclock.dat + 2, (UINT16)(~0x001e), 3, 0},
                                                 {&dclock_dat[3], (WORD)(~0x000f), 4, 0},                                                  {dclock.dat + 3, (UINT16)(~0x000f), 4, 0},
                                                 {&dclock_dat[4], (WORD)(~0x0078), 1, 0}};                                                  {dclock.dat + 4, (UINT16)(~0x0078), 1, 0}};
   
 static void resetfont3(void) {  static void resetfont3(void) {
   
         DWORD pat;          UINT32  pat;
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 138  static void resetfont3(void) { Line 133  static void resetfont3(void) {
                 else {                  else {
                         pat = 0x00400010;                          pat = 0x00400010;
                 }                  }
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*4+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 4 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*5+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 5 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*9+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 9 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*10+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + (10 * DCLOCK_YALIGN)) = pat;
         }          }
 }  }
   
   
 // ------------------------------------------------------------------ font4  // ------------------------------------------------------------------ font4
   
 // 5x8  // 5x8
 static  BYTE clockchr4[11][16] = {  static const UINT8 clockchr4[11][16] = {
                         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},                          {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},
                         {0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70,},                          {0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70,},
                         {0x00, 0x60, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70,},                          {0x00, 0x60, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70,},
Line 163  static BYTE clockchr4[11][16] = { Line 159  static BYTE clockchr4[11][16] = {
   
 static void resetfont4(void) {  static void resetfont4(void) {
   
         DWORD pat;          UINT32  pat;
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 172  static void resetfont4(void) { Line 168  static void resetfont4(void) {
                 else {                  else {
                         pat = 0x00040004;                          pat = 0x00040004;
                 }                  }
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*5+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 5 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*6+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 6 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*9+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 9 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*10+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + (10 * DCLOCK_YALIGN)) = pat;
         }          }
 }  }
   
   
 // ------------------------------------------------------------------ font5  // ------------------------------------------------------------------ font5
   
 static  BYTE clockchr5[11][16] = {  static const UINT8 clockchr5[11][16] = {
                         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},                          {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},
                         {0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70,},                          {0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70,},
                         {0x00, 0x00, 0x20, 0x60, 0x20, 0x20, 0x20, 0x20, 0x20,},                          {0x00, 0x00, 0x20, 0x60, 0x20, 0x20, 0x20, 0x20, 0x20,},
Line 194  static BYTE clockchr5[11][16] = { Line 191  static BYTE clockchr5[11][16] = {
                         {0x00, 0x00, 0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70,},                          {0x00, 0x00, 0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70,},
                         {0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x78, 0x10, 0x60,}};                          {0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x78, 0x10, 0x60,}};
   
 static  DCLOCK_POS dclockpos5[6] = {  static const DCPOS dclockpos5[6] = {
                                                 {&dclock_dat[0], (WORD)(~0x00f8), 0, 0},                                                  {dclock.dat + 0, (UINT16)(~0x00f8), 0, 0},
                                                 {&dclock_dat[0], (WORD)(~0xe003), 6, 0},                                                  {dclock.dat + 0, (UINT16)(~0xe003), 6, 0},
                                                 {&dclock_dat[2], (WORD)(~0x007c), 1, 0},                                                  {dclock.dat + 2, (UINT16)(~0x007c), 1, 0},
                                                 {&dclock_dat[2], (WORD)(~0xf001), 7, 0},                                                  {dclock.dat + 2, (UINT16)(~0xf001), 7, 0},
                                                 {&dclock_dat[4], (WORD)(~0x003e), 2, 0},                                                  {dclock.dat + 4, (UINT16)(~0x003e), 2, 0},
                                                 {&dclock_dat[5], (WORD)(~0x00f8), 0, 0}};                                                  {dclock.dat + 5, (UINT16)(~0x00f8), 0, 0}};
   
 static void resetfont5(void) {  static void resetfont5(void) {
   
         DWORD pat;          UINT32  pat;
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 213  static void resetfont5(void) { Line 210  static void resetfont5(void) {
                 else {                  else {
                         pat = 0x00030006;                          pat = 0x00030006;
                 }                  }
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*6+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 6 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*7+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 7 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*9+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 9 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*10+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + (10 * DCLOCK_YALIGN)) = pat;
         }          }
 }  }
   
   
 // ------------------------------------------------------------------ font6  // ------------------------------------------------------------------ font6
   
 // 4x6  // 4x6
 static  BYTE clockchr6[11][16] = {  static const UINT8 clockchr6[11][16] = {
                         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},                          {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,},
                         {0x00, 0x00, 0x00, 0x60, 0x90, 0x90, 0x90, 0x90, 0x60,},                          {0x00, 0x00, 0x00, 0x60, 0x90, 0x90, 0x90, 0x90, 0x60,},
                         {0x00, 0x00, 0x00, 0x20, 0x60, 0x20, 0x20, 0x20, 0x20,},                          {0x00, 0x00, 0x00, 0x20, 0x60, 0x20, 0x20, 0x20, 0x20,},
Line 236  static BYTE clockchr6[11][16] = { Line 234  static BYTE clockchr6[11][16] = {
                         {0x00, 0x00, 0x00, 0x60, 0x90, 0x60, 0x90, 0x90, 0x60,},                          {0x00, 0x00, 0x00, 0x60, 0x90, 0x60, 0x90, 0x90, 0x60,},
                         {0x00, 0x00, 0x00, 0x60, 0x90, 0x90, 0x70, 0x20, 0x40,}};                          {0x00, 0x00, 0x00, 0x60, 0x90, 0x90, 0x70, 0x20, 0x40,}};
   
 static  DCLOCK_POS dclockpos6[6] = {  static const DCPOS dclockpos6[6] = {
                                                 {&dclock_dat[0], (WORD)(~0x00f0), 0, 0},                                                  {dclock.dat + 0, (UINT16)(~0x00f0), 0, 0},
                                                 {&dclock_dat[0], (WORD)(~0x8007), 5, 0},                                                  {dclock.dat + 0, (UINT16)(~0x8007), 5, 0},
                                                 {&dclock_dat[1], (WORD)(~0x000f), 4, 0},                                                  {dclock.dat + 1, (UINT16)(~0x000f), 4, 0},
                                                 {&dclock_dat[2], (WORD)(~0x0078), 1, 0},                                                  {dclock.dat + 2, (UINT16)(~0x0078), 1, 0},
                                                 {&dclock_dat[3], (WORD)(~0x00f0), 0, 0},                                                  {dclock.dat + 3, (UINT16)(~0x00f0), 0, 0},
                                                 {&dclock_dat[3], (WORD)(~0x8007), 5, 0}};                                                  {dclock.dat + 3, (UINT16)(~0x8007), 5, 0}};
   
 static void resetfont6(void) {  static void resetfont6(void) {
   
         DWORD pat;          UINT32  pat;
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 255  static void resetfont6(void) { Line 253  static void resetfont6(void) {
                 else {                  else {
                         pat = 0x00000220;                          pat = 0x00000220;
                 }                  }
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*8+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + ( 8 * DCLOCK_YALIGN)) = pat;
                 *(DWORD *)(&dclock_dat[(DCLOCK_X/8)*10+1]) = pat;                  *(UINT32 *)(dclock.dat + 1 + (10 * DCLOCK_YALIGN)) = pat;
         }          }
 }  }
   
   
 // ------------------------------------------------------------------------  // ------------------------------------------------------------------------
   
 static DCLOCK_FNT dclock_font = {clockchr1[0], dclockpos1, resetfont1};  typedef struct {
 static DCLOCK_FNT fonttype[] =  const UINT8     *fnt;
   const DCPOS     *pos;
           void    (*init)(void);
   } DCLOCKFNT;
   
   static const DCLOCKFNT fonttype[] =
                                         {{clockchr1[0], dclockpos1, resetfont1},                                          {{clockchr1[0], dclockpos1, resetfont1},
                                          {clockchr2[0], dclockpos2, resetfont2},                                           {clockchr2[0], dclockpos2, resetfont2},
                                          {clockchr3[0], dclockpos3, resetfont3},                                           {clockchr3[0], dclockpos3, resetfont3},
Line 271  static DCLOCK_FNT fonttype[] = Line 275  static DCLOCK_FNT fonttype[] =
                                          {clockchr5[0], dclockpos5, resetfont5},                                           {clockchr5[0], dclockpos5, resetfont5},
                                          {clockchr6[0], dclockpos6, resetfont6}};                                           {clockchr6[0], dclockpos6, resetfont6}};
   
   
 // ------------------------------------------------------------------------  // ------------------------------------------------------------------------
   
 void dclock_init(void) {  void dclock_init(void) {
   
         pal_makegrad(dclock_pal, 4, np2oscfg.clk_color1, np2oscfg.clk_color2);          pal_makegrad(dclockpal.pal32, 4,
                                                                           np2oscfg.clk_color1, np2oscfg.clk_color2);
 }  }
   
 void dclock_init8(void) {  static void dclock_palset8(void) {
   
         BYTE    i, j;          UINT8   i;
         DWORD   work = 0;                                                       // vc++4.2          UINT8   j;
           UINT32  work = 0;                                                       // vc++4.2
   
         for (i=0; i<16; i++) {          for (i=0; i<16; i++) {
                 for (j=1; j<0x10; j<<=1) {                  for (j=1; j<0x10; j<<=1) {
Line 291  void dclock_init8(void) { Line 298  void dclock_init8(void) {
                         }                          }
                 }                  }
                 for (j=0; j<4; j++) {                  for (j=0; j<4; j++) {
                         outcolors[j][i] = work * (START_PALORG + j);                          dclockpal.pal8[j][i] = work * (START_PALORG + j);
                 }                  }
         }          }
 }  }
   
 void dclock_init16(void) {  static void dclock_palset16(void) {
   
         UINT    i;          UINT    i;
   
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 outcolors16[i] = scrnmng_makepal16(dclock_pal[i]);                  dclockpal.pal16[i] = scrnmng_makepal16(dclockpal.pal32[i]);
         }          }
 }  }
   
   void dclock_palset(UINT bpp) {
   
           switch(bpp) {
                   case 8:
                           dclock_palset8();
                           break;
   
                   case 16:
                           dclock_palset16();
                           break;
           }
   }
   
   
   
   
 void dclock_reset(void) {  void dclock_reset(void) {
   
   const DCLOCKFNT *fnt;
   
         ZeroMemory(&dclock, sizeof(dclock));          ZeroMemory(&dclock, sizeof(dclock));
         ZeroMemory(&dclock_dat, sizeof(dclock_dat));  
   
         if (np2oscfg.clk_x) {          if (np2oscfg.clk_x) {
                 if (np2oscfg.clk_x <= 4) {                  if (np2oscfg.clk_x <= 4) {
Line 322  void dclock_reset(void) { Line 345  void dclock_reset(void) {
                         np2oscfg.clk_x = 0;                          np2oscfg.clk_x = 0;
                 }                  }
         }          }
         if (np2oscfg.clk_fnt >= (sizeof(fonttype) / sizeof(DCLOCK_FNT))) {          if (np2oscfg.clk_fnt >= NELEMENTS(fonttype)) {
                 np2oscfg.clk_fnt = 0;                  np2oscfg.clk_fnt = 0;
         }          }
         dclock_font = fonttype[np2oscfg.clk_fnt];  
   
         dclock_font.init();          dclock.clk_x = np2oscfg.clk_x;
           fnt = fonttype + np2oscfg.clk_fnt;
           dclock.fnt = fnt->fnt;
           dclock.pos = fnt->pos;
           fnt->init();
         dclock_callback();          dclock_callback();
         dclock_redraw();          dclock_redraw();
 }  }
Line 335  void dclock_reset(void) { Line 361  void dclock_reset(void) {
 void dclock_callback(void) {  void dclock_callback(void) {
   
         int                     i;          int                     i;
         BYTE            count = 13;          UINT8           count = 13;
         BYTE            buf[8];          UINT8           buf[8];
         _SYSTIME        st;          _SYSTIME        st;
   
         if ((scrnmng_isfullscreen()) && (np2oscfg.clk_x)) {          if ((scrnmng_isfullscreen()) && (dclock.clk_x)) {
                 timemng_gettime(&st);                  timemng_gettime(&st);
                 buf[0] = (st.hour / 10) + 1;                  buf[0] = (st.hour / 10) + 1;
                 buf[1] = (st.hour % 10) + 1;                  buf[1] = (st.hour % 10) + 1;
                 buf[2] = (st.minute / 10) + 1;                  buf[2] = (st.minute / 10) + 1;
                 buf[3] = (st.minute % 10) + 1;                  buf[3] = (st.minute % 10) + 1;
                 if (np2oscfg.clk_x > 4) {                  if (dclock.clk_x > 4) {
                         buf[4] = (st.second / 10) + 1;                          buf[4] = (st.second / 10) + 1;
                         buf[5] = (st.second % 10) + 1;                          buf[5] = (st.second % 10) + 1;
                 }                  }
                 for (i=np2oscfg.clk_x; i--;) {                  for (i=dclock.clk_x; i--;) {
                         if (dclock.dclock_now[i] != buf[i]) {                          if (dclock.now[i] != buf[i]) {
                                 dclock.dclock_now[i] = buf[i];                                  dclock.now[i] = buf[i];
                                 dclock.dclock_flm[i] = count;                                  dclock.flm[i] = count;
                                 dclock.dclock_drawing |= (1 << i);                                  dclock.drawing |= (1 << i);
                                 count += 4;                                  count += 4;
                         }                          }
                 }                  }
Line 362  void dclock_callback(void) { Line 388  void dclock_callback(void) {
   
 void dclock_redraw(void) {  void dclock_redraw(void) {
   
         dclock.dclock_drawing = 0x3f;          dclock.drawing = 0x3f;
 }  }
   
 BOOL dclock_disp(void) {  BOOL dclock_disp(void) {
   
         return((dclock.dclock_drawing != 0) ||          return((dclock.drawing != 0) ||
                         (*(DWORD *)(&dclock.dclock_flm[0]) != 0) ||                          (*(UINT32 *)(dclock.flm + 0) != 0) ||
                         (*(DWORD *)(&dclock.dclock_flm[4]) != 0));                          (*(UINT32 *)(dclock.flm + 4) != 0));
 }  
   
 LABEL void __fastcall dclock_cntdown(BYTE value) {  
   
         __asm {  
                                 cmp             np2oscfg.clk_x, 0  
                                 je              dclock_cdn  
                                 cmp             dword ptr (dclock.dclock_flm), 0  
                                 jne             dclock_cdn  
                                 cmp             dword ptr (dclock.dclock_flm + 4), 0  
                                 jne             dclock_cdn  
                                 ret  
   
 dclock_cdn:             push    ecx  
                                 xor             edx, edx  
                                 cmp             cl, 0  
                                 jne             dclock_cdnlp  
                                 inc             cl  
 dclock_cdnlp:   movzx   eax, dclock[edx].dclock_flm  
                                 cmp             eax, 0  
                                 je              dclock_cdned  
                                 cmp             eax, DCLOCKY_MAX  
                                 jae             dclock_upabove  
                                 mov             ch, dclocky[eax]  
                                 sub             al, cl  
                                 jc              dclock_set0  
                                 cmp             ch, dclocky[eax]  
                                 je              dclock_outflm  
                                 jmp             dclock_setdraw  
   
 dclock_upabove: sub             al, cl  
                                 jc              dclock_set0  
                                 cmp             al, DCLOCKY_MAX  
                                 jae             dclock_outflm  
                                 jmp             dclock_setdraw  
 dclock_set0:    xor             eax, eax  
 dclock_setdraw: bts             dclock.dclock_drawing, dx  
 dclock_outflm:  mov             dclock[edx].dclock_flm, al  
 dclock_cdned:   inc             edx  
                                 cmp             dl, np2oscfg.clk_x  
                                 jc              dclock_cdnlp  
                                 pop             ecx  
                                 ret  
         }  
 }  
   
 LABEL void dclock_make(void) {  
   
         __asm {  
                                 cmp             np2oscfg.clk_x, 0  
                                 je              dclockmakeend  
                                 pushad  
                                 xor             ebx, ebx  
 makedclock_lp:  btr             dclock.dclock_drawing, bx  
                                 jc              makedclock_1  
 makedclock_ed:  inc             ebx  
                                 cmp             bl, np2oscfg.clk_x  
                                 jc              makedclock_lp  
                                 popad  
 dclockmakeend:  ret  
   
 makedclock_1:   mov             eax, dclock_font.dclock_put  
                                 lea             eax, [eax + ebx*8]  
                                 mov             edi, [eax]DCLOCK_POS.dclock_pos  
                                 mov             dx, [eax]DCLOCK_POS.dclock_mask  
                                 mov             cl, [eax]DCLOCK_POS.dclock_rolbit  
                                 movzx   eax, dclock[ebx].dclock_flm  
                                 cmp             eax, 0  
                                 je              makedclock_y0  
                                 cmp             eax, DCLOCKY_MAX  
                                 jb              makedclock_ani  
                                 movzx   eax, dclock[ebx].dclock_bak  
                                 jmp             makedclock0put  
   
 makedclock_y0:  movzx   eax, dclock[ebx].dclock_now  
                                 mov             dclock[ebx].dclock_bak, al  
   
 makedclock0put: mov             ch, 3  
 makedclock0_up: and             [edi], dx  
                                 add             edi, (DCLOCK_X / 8)  
                                 dec             ch  
                                 jne             makedclock0_up  
                                 shl             eax, 4  
                                 add             eax, dclock_font.dclock_fnt  
                                 mov             esi, eax  
                                 mov             ch, 9  
 makedclock0_dn: movzx   eax, byte ptr [esi]  
                                 ror             ax, cl  
                                 and             [edi], dx  
                                 or              [edi], ax  
                                 inc             esi  
                                 add             edi, (DCLOCK_X / 8)  
                                 dec             ch  
                                 jne             makedclock0_dn  
                                 jmp             makedclock_ed  
   
 makedclock_ani: movzx   eax, dclocky[eax]  
                                 push    eax  
                                 mov             ch, 3  
                                 sub             ch, al  
                                 je              makedclock_an2  
 makedclkani_up: and             [edi], dx  
                                 add             edi, (DCLOCK_X / 8)  
                                 dec             ch  
                                 jne             makedclkani_up  
 makedclock_an2: movzx   esi, dclock[ebx].dclock_now  
                                 shl             esi, 4  
                                 add             esi, dclock_font.dclock_fnt  
                                 mov             ch, 9  
 makedclkani_md: movzx   eax, byte ptr [esi]  
                                 ror             ax, cl  
                                 and             [edi], dx  
                                 or              [edi], ax  
                                 inc             esi  
                                 add             edi, (DCLOCK_X / 8)  
                                 dec             ch  
                                 jne             makedclkani_md  
                                 pop             eax  
   
                                 mov             ch, al  
                                 movzx   esi, dclock[ebx].dclock_bak  
                                 shl             esi, 4  
                                 sub             esi, eax  
                                 add             esi, 9  
                                 add             esi, dclock_font.dclock_fnt  
 makedclkani_dn: movzx   eax, byte ptr [esi]  
                                 ror             ax, cl  
                                 and             [edi], dx  
                                 or              [edi], ax  
                                 inc             esi  
                                 add             edi, (DCLOCK_X / 8)  
                                 dec             ch  
                                 jne             makedclkani_dn  
                                 jmp             makedclock_ed  
         }  
 }  
   
 LABEL void __fastcall dclock_out8(void *ptr, DWORD width) {  
   
         __asm {  
                                 pushad  
                                 mov             esi, offset dclock_dat  
                                 mov             edi, offset outcolors  
                                 mov             bh, 4  
 dclockout_lp1:  mov             bl, 3  
 dclockout_lp2:  mov             ebp, (DCLOCK_X/8)  
 dclockout_lp3:  movzx   eax, byte ptr [esi]  
                                 shr             eax, 4  
                                 mov             eax, [eax*4 + edi]  
                                 mov             [ecx], eax  
                                 movzx   eax, byte ptr [esi]  
                                 and             eax, 15  
                                 mov             eax, [eax*4 + edi]  
                                 mov             [ecx+4], eax  
                                 inc             esi  
                                 add             ecx, 8  
                                 dec             ebp  
                                 jne             dclockout_lp3  
                                 lea             ecx, [ecx + edx - DCLOCK_X]  
                                 dec             bl  
                                 jne             dclockout_lp2  
                                 add             edi, 4*16  
                                 dec             bh  
                                 jne             dclockout_lp1  
                                 popad  
                                 ret  
         }  
 }  
   
 LABEL void __fastcall dclock_out16(void *ptr, DWORD width) {  
   
         __asm {  
                                 pushad  
                                 mov             esi, offset dclock_dat  
                                 mov             edi, offset outcolors16  
                                 mov             bh, 4  
 dclockout_lp1:  mov             bl, 3  
 dclockout_lp2:  push    ebx  
                                 mov             ebp, (DCLOCK_X/8)  
 dclockout_lp3:  mov             bl, [esi]  
                                 mov             bh, 8  
 dclockout_lp4:  rcl             bl, 1  
                                 sbb             ax, ax  
                                 and             ax, [edi]  
                                 mov             [ecx], ax  
                                 add             ecx, 2  
                                 dec             bh  
                                 jne             dclockout_lp4  
                                 inc             esi  
                                 dec             ebp  
                                 jne             dclockout_lp3  
                                 pop             ebx  
                                 lea             ecx, [ecx + edx - DCLOCK_X*2]  
                                 dec             bl  
                                 jne             dclockout_lp2  
                                 add             edi, 2  
                                 dec             bh  
                                 jne             dclockout_lp1  
                                 popad  
                                 ret  
         }  
 }  }
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.5

RetroPC.NET-CVS <cvs@retropc.net>