Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/vtterm.c

Diff of /trunk/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 4769 by doda, Tue Dec 6 10:01:20 2011 UTC revision 4770 by doda, Tue Dec 6 10:20:48 2011 UTC
# Line 3395  BOOL XsParseColor(char *colspec, COLORRE Line 3395  BOOL XsParseColor(char *colspec, COLORRE
3395  void XsProcColor(int mode, unsigned int ColorNumber, char *ColorSpec) {  void XsProcColor(int mode, unsigned int ColorNumber, char *ColorSpec) {
3396          COLORREF color;          COLORREF color;
3397          char StrBuff[256];          char StrBuff[256];
3398            unsigned int colornum = CS_UNSPEC;
3399          int len;          int len;
3400    
3401          switch (mode) {          switch (mode) {
3402            case 4:
3403                    if (ColorNumber <= 255) {
3404                            colornum = ColorNumber;
3405                    }
3406                    break;
3407            case 5:
3408                    switch (ColorNumber) {
3409                    case 0:
3410                            colornum = CS_VT_BOLDFG;
3411                            break;
3412                    case 1:
3413                            // Underline -- not supported.
3414                            // colornum = CS_VT_UNDERFG;
3415                            break;
3416                    case 2:
3417                            colornum = CS_VT_BLINKFG;
3418                            break;
3419                    case 3:
3420                            colornum = CS_VT_REVERSEBG;
3421                            break;
3422                    }
3423                    break;
3424          case 10:          case 10:
3425                  ColorNumber = CS_VT_NORMALFG;                  colornum = CS_VT_NORMALFG;
3426                  break;                  break;
3427          case 11:          case 11:
3428                  ColorNumber = CS_VT_NORMALBG;                  colornum = CS_VT_NORMALBG;
3429                  break;                  break;
3430          case 15:          case 15:
3431                  ColorNumber = CS_TEK_FG;                  colornum = CS_TEK_FG;
3432                  break;                  break;
3433          case 16:          case 16:
3434                  ColorNumber = CS_TEK_BG;                  colornum = CS_TEK_BG;
3435                  break;                  break;
3436          }          }
3437    
3438          switch (mode) {          if (colornum != CS_UNSPEC) {
3439          case 4:                  if (strcmp(ColorSpec, "?") == 0) {
3440                  if ((ts.ColorFlag & CF_XTERM256) && ColorNumber <= 255) {                          color = DispGetColor(colornum);
3441                          if (strcmp(ColorSpec, "?") == 0) {                          if (mode == 4 || mode == 5) {
                                 color = DispGetColor(ColorNumber);  
3442                                  len =_snprintf_s_l(StrBuff, sizeof(StrBuff), _TRUNCATE,                                  len =_snprintf_s_l(StrBuff, sizeof(StrBuff), _TRUNCATE,
3443                                          "4;%d;rgb:%02x/%02x/%02x", CLocale, ColorNumber,                                          "%d;%d;rgb:%02x/%02x/%02x", CLocale, mode, ColorNumber,
3444                                          GetRValue(color), GetGValue(color), GetBValue(color));                                          GetRValue(color), GetGValue(color), GetBValue(color));
                                 SendOSCstr(StrBuff, len);  
3445                          }                          }
3446                          else if (XsParseColor(ColorSpec, &color)) {                          else {
3447                                  DispSetColor(ColorNumber, color);                                  len =_snprintf_s_l(StrBuff, sizeof(StrBuff), _TRUNCATE,
3448                                            "%d;rgb:%02x/%02x/%02x", CLocale, mode,
3449                                            GetRValue(color), GetGValue(color), GetBValue(color));
3450                          }                          }
                 }  
                 break;  
         case 10:  
         case 11:  
         case 15:  
         case 16:  
                 if (strcmp(ColorSpec, "?") == 0) {  
                         color = DispGetColor(ColorNumber);  
                         len =_snprintf_s_l(StrBuff, sizeof(StrBuff), _TRUNCATE,  
                                 "%d;rgb:%02x/%02x/%02x", CLocale, mode,  
                                 GetRValue(color), GetGValue(color), GetBValue(color));  
3451                          SendOSCstr(StrBuff, len);                          SendOSCstr(StrBuff, len);
3452                  }                  }
3453                  else if (XsParseColor(ColorSpec, &color)) {                  else if (XsParseColor(ColorSpec, &color)) {
3454                          DispSetColor(ColorNumber, color);                          DispSetColor(colornum, color);
3455                    }
3456            }
3457    }
3458    
3459    void XsResetColor(int mode, unsigned int color)
3460    {
3461            switch (mode) {
3462            case 104:
3463                    if (color < 256) {
3464                            DispResetColor(color);
3465                  }                  }
3466                  break;                  break;
3467            case 105:
3468                    switch (color) {
3469                    case 0:
3470                            DispResetColor(CS_VT_BOLDFG);
3471                            break;
3472                    case 1:
3473                            // Underline -- not supported.
3474                            // DispResetColor(CS_VT_UNDERFG);
3475                            break;
3476                    case 2:
3477                            DispResetColor(CS_VT_BLINKFG);
3478                            break;
3479                    case 3:
3480                            DispResetColor(CS_VT_REVERSEBG);
3481                            break;
3482                    }
3483                    break;
3484            case 110:
3485                    DispResetColor(CS_VT_NORMALFG);
3486                    break;
3487            case 111:
3488                    DispResetColor(CS_VT_NORMALBG);
3489                    break;
3490            case 115:
3491                    DispResetColor(CS_TEK_FG);
3492                    break;
3493            case 116:
3494                    DispResetColor(CS_TEK_FG);
3495                    break;
3496          }          }
3497  }  }
3498    
# Line 3514  void XSequence(BYTE b) Line 3565  void XSequence(BYTE b)
3565    
3566          switch (XsParseMode) {          switch (XsParseMode) {
3567            case ModeXsFirst:            case ModeXsFirst:
3568                  if (isdigit(b)) {                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */
3569                            switch (Param[1]) {
3570                            case 104:
3571                                    DispResetColor(CS_ALL);
3572                                    break;
3573                            case 110:
3574                            case 111:
3575                            case 115:
3576                            case 116:
3577                                    XsResetColor(Param[1], 0);
3578                                    break;
3579                            }
3580                            ParseMode = ModeFirst;
3581                            XsParseMode = ModeXsFirst;
3582                    }
3583                    else if (b == ESC) { /* Escape */
3584                            PrevMode = ModeXsFirst;
3585                            XsParseMode = ModeXsEsc;
3586                    }
3587                    else if (b <= US) { /* Other control character -- invalid sequence */
3588                            ParseMode = ModeFirst;
3589                            XsParseMode = ModeXsFirst;
3590                    }
3591                    else if (isdigit(b)) {
3592                          Param[1] = Param[1]*10 + b - '0';                          Param[1] = Param[1]*10 + b - '0';
3593                  }                  }
3594                  else if (b == ';') {                  else if (b == ';') {
# Line 3522  void XSequence(BYTE b) Line 3596  void XSequence(BYTE b)
3596                          StrLen = 0;                          StrLen = 0;
3597                          switch (Param[1]) {                          switch (Param[1]) {
3598                          case 4:                          case 4:
3599                            case 5:
3600                            case 104:
3601                            case 105:
3602                                  ColorNumber = 0;                                  ColorNumber = 0;
3603                                  XsParseMode = ModeXsColorNum;                                  XsParseMode = ModeXsColorNum;
3604                                  break;                                  break;
# Line 3547  void XSequence(BYTE b) Line 3624  void XSequence(BYTE b)
3624                                  }                                  }
3625                                  XsParseMode = ModeXsString;                                  XsParseMode = ModeXsString;
3626                                  break;                                  break;
3627                            case 110:
3628                            case 111:
3629                            case 115:
3630                            case 116:
3631                                    XsResetColor(Param[1], 0);
3632                                    break;
3633                          default:                          default:
3634                                  XsParseMode = ModeXsString;                                  XsParseMode = ModeXsString;
3635                          }                          }
# Line 3617  void XSequence(BYTE b) Line 3700  void XSequence(BYTE b)
3700                  }                  }
3701                  break;                  break;
3702            case ModeXsColorNum:            case ModeXsColorNum:
3703                  if (isdigit(b)) {                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */
3704                            if (Param[1] == 104 || Param[1] == 105) {
3705                                    XsResetColor(Param[1], ColorNumber);
3706                            }
3707                            ColorNumber = 0;
3708                            ParseMode = ModeFirst;
3709                            XsParseMode = ModeXsFirst;
3710                    }
3711                    else if (b == ESC) { /* Escape */
3712                            PrevMode = ModeXsColorNum;
3713                            XsParseMode = ModeXsEsc;
3714                    }
3715                    else if (b <= US) { /* Other control character -- invalid sequence */
3716                            ParseMode = ModeFirst;
3717                            XsParseMode = ModeXsFirst;
3718                    }
3719                    else if (isdigit(b)) {
3720                          ColorNumber = ColorNumber*10 + b - '0';                          ColorNumber = ColorNumber*10 + b - '0';
3721                  }                  }
3722                  else if (b == ';') {                  else if (b == ';') {
3723                          XsParseMode = ModeXsColorSpec;                          if (Param[1] == 104 || Param[1] == 105) {
3724                                    XsResetColor(Param[1], ColorNumber);
3725                                    ColorNumber = 0;
3726                            }
3727                            else {
3728                                    XsParseMode = ModeXsColorSpec;
3729                            }
3730                  }                  }
3731                  else {                  else {
3732                          XsParseMode = ModeXsIgnore;                          XsParseMode = ModeXsIgnore;
# Line 3653  void XSequence(BYTE b) Line 3758  void XSequence(BYTE b)
3758    
3759                          switch (Param[1]) {                          switch (Param[1]) {
3760                          case 4:                          case 4:
3761                            case 5:
3762                                  XsParseMode = ModeXsColorNum;                                  XsParseMode = ModeXsColorNum;
3763                                  break;                                  break;
3764                          case 10:                          case 10:
Legend:
Removed from v.4769  
changed lines
  Added in v.4770
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help