Return to styleparser.c CVS log | Up to [Public] / Amaya / amaya |
1.1 cvs 1: /* 2: * 3: * (c) COPYRIGHT MIT and INRIA, 1996. 4: * Please first read the full copyright statement in file COPYRIGHT. 5: * 6: */ 7: 8: /* 9: * Everything directly linked to the CSS syntax should now hopefully 10: * be contained in this module. 11: * 12: * Author: I. Vatton 13: * 14: */ 15: 16: /* Included headerfiles */ 17: #define THOT_EXPORT extern 18: #include "amaya.h" 19: #include "css.h" 20: #include "undo.h" 1.25 cvs 21: #include "fetchHTMLname.h" 1.1 cvs 22: 23: typedef struct _BackgroundImageCallbackBlock 24: { 25: Element el; 26: PSchema tsch; 27: union 28: { 29: PresentationContextBlock specific; 30: GenericContextBlock generic; 31: } context; 32: } 33: BackgroundImageCallbackBlock, *BackgroundImageCallbackPtr; 34: 35: #include "AHTURLTools_f.h" 36: #include "HTMLpresentation_f.h" 37: #include "HTMLimage_f.h" 38: #include "UIcss_f.h" 39: #include "css_f.h" 1.24 cvs 40: #include "fetchHTMLname_f.h" 1.1 cvs 41: #include "html2thot_f.h" 42: #include "styleparser_f.h" 43: 44: #define MAX_BUFFER_LENGTH 200 45: /* 46: * A PropertyParser is a function used to parse the 47: * description substring associated to a given style attribute 48: * e.g. : "red" for a color attribute or "12pt bold helvetica" 49: * for a font attribute. 50: */ 51: #ifdef __STDC__ 1.17 cvs 52: typedef STRING (*PropertyParser) (Element element, 1.1 cvs 53: PSchema tsch, 54: PresentationContext context, 55: STRING cssRule, 56: CSSInfoPtr css, 1.14 cvs 57: ThotBool isHTML); 1.1 cvs 58: #else 1.17 cvs 59: typedef STRING (*PropertyParser) (); 1.1 cvs 60: #endif 61: 62: /* Description of the set of CSS properties supported */ 63: typedef struct CSSProperty 64: { 65: STRING name; 1.25 cvs 66: PropertyParser parsing_function; 1.1 cvs 67: } 68: CSSProperty; 69: 70: #include "HTMLstyleColor.h" 71: 72: struct unit_def 73: { 74: STRING sign; 75: unsigned int unit; 76: }; 77: 78: static struct unit_def CSSUnitNames[] = 79: { 1.18 cvs 80: {TEXT ("pt"), STYLE_UNIT_PT}, 81: {TEXT ("pc"), STYLE_UNIT_PC}, 82: {TEXT ("in"), STYLE_UNIT_IN}, 83: {TEXT ("cm"), STYLE_UNIT_CM}, 84: {TEXT ("mm"), STYLE_UNIT_MM}, 85: {TEXT ("em"), STYLE_UNIT_EM}, 86: {TEXT ("px"), STYLE_UNIT_PX}, 87: {TEXT ("ex"), STYLE_UNIT_XHEIGHT}, 88: {TEXT ("%"), STYLE_UNIT_PERCENT} 1.1 cvs 89: }; 90: 91: #define NB_UNITS (sizeof(CSSUnitNames) / sizeof(struct unit_def)) 92: 93: /*---------------------------------------------------------------------- 94: ----------------------------------------------------------------------*/ 95: #ifdef __STDC__ 1.7 cvs 96: static unsigned int hexa_val (CHAR_T c) 1.1 cvs 97: #else 98: static unsigned int hexa_val (c) 1.7 cvs 99: CHAR_T c; 1.1 cvs 100: #endif 101: { 102: if (c >= '0' && c <= '9') 103: return (c - '0'); 104: if (c >= 'a' && c <= 'f') 105: return (c - 'a' + 10); 106: if (c >= 'A' && c <= 'F') 107: return (c - 'A' + 10); 108: return (0); 109: } 110: 111: /*---------------------------------------------------------------------- 112: SkipWord: 113: ----------------------------------------------------------------------*/ 114: #ifdef __STDC__ 115: static STRING SkipWord (STRING ptr) 116: #else 117: static STRING SkipWord (ptr) 118: STRING ptr; 119: #endif 120: { 121: while (isalnum(*ptr) || *ptr == '-' || *ptr == '%') 122: ptr++; 123: return (ptr); 124: } 125: 126: /*---------------------------------------------------------------------- 1.13 cvs 127: SkipBlanksAndComments: 128: ----------------------------------------------------------------------*/ 129: #ifdef __STDC__ 1.23 cvs 130: STRING SkipBlanksAndComments (STRING ptr) 1.13 cvs 131: #else 1.23 cvs 132: STRING SkipBlanksAndComments (ptr) 133: STRING ptr; 1.13 cvs 134: #endif 135: { 136: ptr = TtaSkipBlanks (ptr); 137: while (ptr[0] == '/' && ptr[1] == '*') 138: { 139: /* look for the end of the comment */ 140: ptr = &ptr[2]; 141: while (ptr[0] != EOS && (ptr[0] != '*' || ptr[1] != '/')) 142: ptr++; 143: if (ptr[0] != EOS) 144: ptr = &ptr[2]; 145: ptr = TtaSkipBlanks (ptr); 146: } 147: return (ptr); 148: } 149: 150: /*---------------------------------------------------------------------- 1.1 cvs 151: SkipQuotedString: 152: ----------------------------------------------------------------------*/ 153: #ifdef __STDC__ 1.7 cvs 154: static STRING SkipQuotedString (STRING ptr, CHAR_T quote) 1.1 cvs 155: #else 156: static STRING SkipQuotedString (ptr, quote) 157: STRING ptr; 1.7 cvs 158: CHAR_T quote; 1.1 cvs 159: #endif 160: { 1.14 cvs 161: ThotBool stop; 1.1 cvs 162: 163: stop = FALSE; 164: while (!stop) 165: { 166: if (*ptr == quote) 167: { 168: ptr++; 169: stop = TRUE; 170: } 171: else if (*ptr == EOS) 172: stop = TRUE; 173: else if (*ptr == '\\') 174: /* escape character */ 175: { 176: ptr++; 177: if ((*ptr >= '0' && *ptr <= '9') || (*ptr >= 'A' && *ptr <= 'F') || 178: (*ptr >= 'a' && *ptr <= 'f')) 179: { 180: ptr++; 181: if ((*ptr >= '0' && *ptr <= '9') || (*ptr >= 'A' && *ptr <= 'F') || 182: (*ptr >= 'a' && *ptr <= 'f')) 183: ptr++; 184: } 185: else 186: ptr++; 187: } 188: else 189: ptr++; 190: } 191: return (ptr); 192: } 193: 194: /*---------------------------------------------------------------------- 195: SkipProperty: 196: ----------------------------------------------------------------------*/ 197: #ifdef __STDC__ 198: STRING SkipProperty (STRING ptr) 199: #else 200: STRING SkipProperty (ptr) 201: STRING ptr; 202: #endif 203: { 204: while (*ptr != EOS && *ptr != ';' && *ptr != '}') 205: ptr++; 206: return (ptr); 207: } 208: 209: /*---------------------------------------------------------------------- 210: ParseCSSUnit : 211: parse a CSS Unit substring and returns the corresponding 212: value and its unit. 213: ----------------------------------------------------------------------*/ 214: #ifdef __STDC__ 215: static STRING ParseCSSUnit (STRING cssRule, PresentationValue *pval) 216: #else 217: static STRING ParseCSSUnit (cssRule, pval) 218: STRING cssRule; 219: PresentationValue *pval; 220: #endif 221: { 222: int val = 0; 223: int minus = 0; 224: int valid = 0; 225: int f = 0; 226: unsigned int uni; 1.14 cvs 227: ThotBool real = FALSE; 1.1 cvs 228: 229: pval->typed_data.unit = STYLE_UNIT_REL; 230: pval->typed_data.real = FALSE; 1.13 cvs 231: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 232: if (*cssRule == '-') 233: { 234: minus = 1; 235: cssRule++; 1.13 cvs 236: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 237: } 238: 239: if (*cssRule == '+') 240: { 241: cssRule++; 1.13 cvs 242: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 243: } 244: 245: while ((*cssRule >= '0') && (*cssRule <= '9')) 246: { 247: val *= 10; 248: val += *cssRule - '0'; 249: cssRule++; 250: valid = 1; 251: } 252: 253: if (*cssRule == '.') 254: { 255: real = TRUE; 256: f = val; 257: val = 0; 258: cssRule++; 259: /* keep only 3 digits */ 260: if (*cssRule >= '0' && *cssRule <= '9') 261: { 262: val = (*cssRule - '0') * 100; 263: cssRule++; 264: if (*cssRule >= '0' && *cssRule <= '9') 265: { 266: val += (*cssRule - '0') * 10; 267: cssRule++; 268: if ((*cssRule >= '0') && (*cssRule <= '9')) 269: { 270: val += *cssRule - '0'; 271: cssRule++; 272: } 273: } 274: 275: while (*cssRule >= '0' && *cssRule <= '9') 276: cssRule++; 277: valid = 1; 278: } 279: } 280: 281: if (!valid) 282: { 283: cssRule = SkipWord (cssRule); 284: pval->typed_data.unit = STYLE_UNIT_INVALID; 285: pval->typed_data.value = 0; 286: } 287: else 288: { 1.13 cvs 289: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 290: for (uni = 0; uni < NB_UNITS; uni++) 291: { 292: if (!ustrncasecmp (CSSUnitNames[uni].sign, cssRule, 293: ustrlen (CSSUnitNames[uni].sign))) 294: { 295: pval->typed_data.unit = CSSUnitNames[uni].unit; 296: pval->typed_data.real = real; 297: if (real) 298: { 299: if (minus) 300: pval->typed_data.value = -(f * 1000 + val); 301: else 302: pval->typed_data.value = f * 1000 + val; 303: } 304: else 305: { 306: if (minus) 307: pval->typed_data.value = -val; 308: else 309: pval->typed_data.value = val; 310: } 311: return (cssRule + ustrlen (CSSUnitNames[uni].sign)); 312: } 313: } 314: 315: /* not in the list of predefined units */ 316: pval->typed_data.unit = STYLE_UNIT_REL; 317: pval->typed_data.real = real; 318: if (real) 319: { 320: if (minus) 321: pval->typed_data.value = -(f * 1000 + val); 322: else 323: pval->typed_data.value = f * 1000 + val; 324: } 325: else 326: { 327: if (minus) 328: pval->typed_data.value = -val; 329: else 330: pval->typed_data.value = val; 331: } 332: } 333: return (cssRule); 334: } 335: 336: /************************************************************************ 337: * * 338: * PARSING FUNCTIONS * 339: * * 340: ************************************************************************/ 341: 342: /************************************************************************ 343: * * 344: * CORE OF THE CSS PARSER : THESE TAKE THE CSS STRINGS * 345: * PRODUCE THE CORECT DRIVER CONTEXT, AND DO THE PARSING * 346: * * 347: ************************************************************************/ 348: 349: /*---------------------------------------------------------------------- 350: ParseCSSBorderTopWidth : parse a CSS BorderTopWidth 351: attribute string. 352: ----------------------------------------------------------------------*/ 353: #ifdef __STDC__ 354: static STRING ParseCSSBorderTopWidth (Element element, PSchema tsch, 1.14 cvs 355: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 356: #else 357: static STRING ParseCSSBorderTopWidth (element, tsch, context, cssRule, css, isHTML) 358: Element element; 359: PSchema tsch; 360: PresentationContext context; 361: STRING cssRule; 362: CSSInfoPtr css; 1.14 cvs 363: ThotBool isHTML; 1.1 cvs 364: #endif 365: { 366: cssRule = SkipProperty (cssRule); 367: return (cssRule); 368: } 369: 370: /*---------------------------------------------------------------------- 371: ParseCSSBorderRightWidth : parse a CSS BorderRightWidth 372: attribute string. 373: ----------------------------------------------------------------------*/ 374: #ifdef __STDC__ 375: static STRING ParseCSSBorderRightWidth (Element element, PSchema tsch, 1.14 cvs 376: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 377: #else 378: static STRING ParseCSSBorderRightWidth (element, tsch, context, cssRule, css, isHTML) 379: Element element; 380: PSchema tsch; 381: PresentationContext context; 382: STRING cssRule; 383: CSSInfoPtr css; 1.14 cvs 384: ThotBool isHTML; 1.1 cvs 385: #endif 386: { 387: cssRule = SkipProperty (cssRule); 388: return (cssRule); 389: } 390: 391: /*---------------------------------------------------------------------- 392: ParseCSSBorderBottomWidth : parse a CSS BorderBottomWidth 393: attribute string. 394: ----------------------------------------------------------------------*/ 395: #ifdef __STDC__ 396: static STRING ParseCSSBorderBottomWidth (Element element, PSchema tsch, 1.14 cvs 397: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 398: #else 399: static STRING ParseCSSBorderBottomWidth (element, tsch, context, cssRule, css, isHTML) 400: Element element; 401: PSchema tsch; 402: PresentationContext context; 403: STRING cssRule; 404: CSSInfoPtr css; 1.14 cvs 405: ThotBool isHTML; 1.1 cvs 406: #endif 407: { 408: cssRule = SkipProperty (cssRule); 409: return (cssRule); 410: } 411: 412: /*---------------------------------------------------------------------- 413: ParseCSSBorderLeftWidth : parse a CSS BorderLeftWidth 414: attribute string. 415: ----------------------------------------------------------------------*/ 416: #ifdef __STDC__ 417: static STRING ParseCSSBorderLeftWidth (Element element, PSchema tsch, 1.14 cvs 418: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 419: #else 420: static STRING ParseCSSBorderLeftWidth (element, tsch, context, cssRule, css, isHTML) 421: Element element; 422: PSchema tsch; 423: PresentationContext context; 424: STRING cssRule; 425: CSSInfoPtr css; 1.14 cvs 426: ThotBool isHTML; 1.1 cvs 427: #endif 428: { 429: cssRule = SkipProperty (cssRule); 430: return (cssRule); 431: } 432: 433: /*---------------------------------------------------------------------- 434: ParseCSSBorderWidth : parse a CSS BorderWidth 435: attribute string. 436: ----------------------------------------------------------------------*/ 437: #ifdef __STDC__ 438: static STRING ParseCSSBorderWidth (Element element, PSchema tsch, 1.14 cvs 439: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 440: #else 441: static STRING ParseCSSBorderWidth (element, tsch, context, cssRule, css, isHTML) 442: Element element; 443: PSchema tsch; 444: PresentationContext context; 445: STRING cssRule; 446: CSSInfoPtr css; 1.14 cvs 447: ThotBool isHTML; 1.1 cvs 448: #endif 449: { 450: cssRule = SkipProperty (cssRule); 451: return (cssRule); 452: } 453: 454: /*---------------------------------------------------------------------- 455: ParseCSSBorderTop : parse a CSS BorderTop 456: attribute string. 457: ----------------------------------------------------------------------*/ 458: #ifdef __STDC__ 459: static STRING ParseCSSBorderTop (Element element, PSchema tsch, 1.14 cvs 460: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 461: #else 462: static STRING ParseCSSBorderTop (element, tsch, context, cssRule, css, isHTML) 463: Element element; 464: PSchema tsch; 465: PresentationContext context; 466: STRING cssRule; 467: CSSInfoPtr css; 1.14 cvs 468: ThotBool isHTML; 1.1 cvs 469: #endif 470: { 471: cssRule = SkipProperty (cssRule); 472: return (cssRule); 473: } 474: 475: /*---------------------------------------------------------------------- 476: ParseCSSBorderRight : parse a CSS BorderRight 477: attribute string. 478: ----------------------------------------------------------------------*/ 479: #ifdef __STDC__ 480: static STRING ParseCSSBorderRight (Element element, PSchema tsch, 1.14 cvs 481: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 482: #else 483: static STRING ParseCSSBorderRight (element, tsch, context, cssRule, css, isHTML) 484: Element element; 485: PSchema tsch; 486: PresentationContext context; 487: STRING cssRule; 488: CSSInfoPtr css; 1.14 cvs 489: ThotBool isHTML; 1.1 cvs 490: #endif 491: { 492: cssRule = SkipProperty (cssRule); 493: return (cssRule); 494: } 495: 496: /*---------------------------------------------------------------------- 497: ParseCSSBorderBottom : parse a CSS BorderBottom 498: attribute string. 499: ----------------------------------------------------------------------*/ 500: #ifdef __STDC__ 501: static STRING ParseCSSBorderBottom (Element element, PSchema tsch, 1.14 cvs 502: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 503: #else 504: static STRING ParseCSSBorderBottom (element, tsch, context, cssRule, css, isHTML) 505: Element element; 506: PSchema tsch; 507: PresentationContext context; 508: STRING cssRule; 509: CSSInfoPtr css; 1.14 cvs 510: ThotBool isHTML; 1.1 cvs 511: #endif 512: { 513: cssRule = SkipProperty (cssRule); 514: return (cssRule); 515: } 516: 517: /*---------------------------------------------------------------------- 518: ParseCSSBorderLeft : parse a CSS BorderLeft 519: attribute string. 520: ----------------------------------------------------------------------*/ 521: #ifdef __STDC__ 522: static STRING ParseCSSBorderLeft (Element element, PSchema tsch, 1.14 cvs 523: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 524: #else 525: static STRING ParseCSSBorderLeft (element, tsch, context, cssRule, css, isHTML) 526: Element element; 527: PSchema tsch; 528: PresentationContext context; 529: STRING cssRule; 530: CSSInfoPtr css; 1.14 cvs 531: ThotBool isHTML; 1.1 cvs 532: #endif 533: { 534: cssRule = SkipProperty (cssRule); 535: return (cssRule); 536: } 537: 538: /*---------------------------------------------------------------------- 539: ParseCSSBorderColor : parse a CSS border-color 540: attribute string. 541: ----------------------------------------------------------------------*/ 542: #ifdef __STDC__ 543: static STRING ParseCSSBorderColor (Element element, PSchema tsch, 1.14 cvs 544: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 545: #else 546: static STRING ParseCSSBorderColor (element, tsch, context, cssRule, css, isHTML) 547: Element element; 548: PSchema tsch; 549: PresentationContext context; 550: STRING cssRule; 551: CSSInfoPtr css; 1.14 cvs 552: ThotBool isHTML; 1.1 cvs 553: #endif 554: { 555: cssRule = SkipProperty (cssRule); 556: return (cssRule); 557: } 558: 559: /*---------------------------------------------------------------------- 560: ParseCSSBorderStyle : parse a CSS border-style 561: attribute string. 562: ----------------------------------------------------------------------*/ 563: #ifdef __STDC__ 564: static STRING ParseCSSBorderStyle (Element element, PSchema tsch, 1.14 cvs 565: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 566: #else 567: static STRING ParseCSSBorderStyle (element, tsch, context, cssRule, css, isHTML) 568: Element element; 569: PSchema tsch; 570: PresentationContext context; 571: STRING cssRule; 572: CSSInfoPtr css; 1.14 cvs 573: ThotBool isHTML; 1.1 cvs 574: #endif 575: { 576: cssRule = SkipProperty (cssRule); 577: return (cssRule); 578: } 579: 580: /*---------------------------------------------------------------------- 581: ParseCSSBorder : parse a CSS border 582: attribute string. 583: ----------------------------------------------------------------------*/ 584: #ifdef __STDC__ 585: static STRING ParseCSSBorder (Element element, PSchema tsch, 1.14 cvs 586: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 587: #else 588: static STRING ParseCSSBorder (element, tsch, context, cssRule, css, isHTML) 589: Element element; 590: PSchema tsch; 591: PresentationContext context; 592: STRING cssRule; 593: CSSInfoPtr css; 1.14 cvs 594: ThotBool isHTML; 1.1 cvs 595: #endif 596: { 597: cssRule = SkipProperty (cssRule); 598: return (cssRule); 599: } 600: 601: /*---------------------------------------------------------------------- 602: ParseCSSClear : parse a CSS clear attribute string 603: ----------------------------------------------------------------------*/ 604: #ifdef __STDC__ 605: static STRING ParseCSSClear (Element element, PSchema tsch, 1.14 cvs 606: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 607: #else 608: static STRING ParseCSSClear (element, tsch, context, cssRule, css, isHTML) 609: Element element; 610: PSchema tsch; 611: PresentationContext context; 612: STRING cssRule; 613: CSSInfoPtr css; 1.14 cvs 614: ThotBool isHTML; 1.1 cvs 615: #endif 616: { 617: cssRule = SkipProperty (cssRule); 618: return (cssRule); 619: } 620: 621: /*---------------------------------------------------------------------- 622: ParseCSSDisplay : parse a CSS display attribute string 623: ----------------------------------------------------------------------*/ 624: #ifdef __STDC__ 625: static STRING ParseCSSDisplay (Element element, PSchema tsch, 1.14 cvs 626: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 627: #else 628: static STRING ParseCSSDisplay (element, tsch, context, cssRule, css, isHTML) 629: Element element; 630: PSchema tsch; 631: PresentationContext context; 632: STRING cssRule; 633: CSSInfoPtr css; 1.14 cvs 634: ThotBool isHTML; 1.1 cvs 635: #endif 636: { 637: PresentationValue pval; 638: 639: pval.typed_data.unit = STYLE_UNIT_REL; 640: pval.typed_data.real = FALSE; 1.13 cvs 641: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 642: if (!ustrncasecmp (cssRule, TEXT("block"), 5)) 1.1 cvs 643: { 644: pval.typed_data.value = STYLE_NOTINLINE; 645: TtaSetStylePresentation (PRLine, element, tsch, context, pval); 646: cssRule = SkipWord (cssRule); 647: } 1.17 cvs 648: else if (!ustrncasecmp (cssRule, TEXT("inline"), 6)) 1.1 cvs 649: { 650: pval.typed_data.value = STYLE_INLINE; 651: TtaSetStylePresentation (PRLine, element, tsch, context, pval); 652: cssRule = SkipWord (cssRule); 653: } 1.17 cvs 654: else if (!ustrncasecmp (cssRule, TEXT("none"), 4)) 1.1 cvs 655: { 656: pval.typed_data.value = STYLE_HIDE; 657: TtaSetStylePresentation (PRVisibility, element, tsch, context, pval); 658: cssRule = SkipWord (cssRule); 659: } 1.17 cvs 660: else if (!ustrncasecmp (cssRule, TEXT("list-item"), 9)) 1.1 cvs 661: cssRule = SkipProperty (cssRule); 662: else 663: fprintf (stderr, "invalid display value %s\n", cssRule); 1.34 cvs 664: 1.1 cvs 665: return (cssRule); 666: } 667: 668: /*---------------------------------------------------------------------- 669: ParseCSSFloat : parse a CSS float attribute string 670: ----------------------------------------------------------------------*/ 671: #ifdef __STDC__ 672: static STRING ParseCSSFloat (Element element, PSchema tsch, 1.14 cvs 673: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 674: #else 675: static STRING ParseCSSFloat (element, tsch, context, cssRule, css, isHTML) 676: Element element; 677: PSchema tsch; 678: PresentationContext context; 679: STRING cssRule; 680: CSSInfoPtr css; 1.14 cvs 681: ThotBool isHTML; 1.1 cvs 682: #endif 683: { 684: cssRule = SkipProperty (cssRule); 685: return (cssRule); 686: } 687: 688: /*---------------------------------------------------------------------- 689: ParseCSSLetterSpacing : parse a CSS letter-spacing 690: attribute string. 691: ----------------------------------------------------------------------*/ 692: #ifdef __STDC__ 693: static STRING ParseCSSLetterSpacing (Element element, PSchema tsch, 1.14 cvs 694: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 695: #else 696: static STRING ParseCSSLetterSpacing (element, tsch, context, cssRule, css, isHTML) 697: Element element; 698: PSchema tsch; 699: PresentationContext context; 700: STRING cssRule; 701: CSSInfoPtr css; 1.14 cvs 702: ThotBool isHTML; 1.1 cvs 703: #endif 704: { 705: cssRule = SkipProperty (cssRule); 706: return (cssRule); 707: } 708: 709: /*---------------------------------------------------------------------- 710: ParseCSSListStyleType : parse a CSS list-style-type 711: attribute string. 712: ----------------------------------------------------------------------*/ 713: #ifdef __STDC__ 714: static STRING ParseCSSListStyleType (Element element, PSchema tsch, 1.14 cvs 715: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 716: #else 717: static STRING ParseCSSListStyleType (element, tsch, context, cssRule, css, isHTML) 718: Element element; 719: PSchema tsch; 720: PresentationContext context; 721: STRING cssRule; 722: CSSInfoPtr css; 1.14 cvs 723: ThotBool isHTML; 1.1 cvs 724: #endif 725: { 726: cssRule = SkipProperty (cssRule); 727: return (cssRule); 728: } 729: 730: /*---------------------------------------------------------------------- 731: ParseCSSListStyleImage : parse a CSS list-style-image 732: attribute string. 733: ----------------------------------------------------------------------*/ 734: #ifdef __STDC__ 735: static STRING ParseCSSListStyleImage (Element element, PSchema tsch, 1.14 cvs 736: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 737: #else 738: static STRING ParseCSSListStyleImage (element, tsch, context, cssRule, css, isHTML) 739: Element element; 740: PSchema tsch; 741: PresentationContext context; 742: STRING cssRule; 743: CSSInfoPtr css; 1.14 cvs 744: ThotBool isHTML; 1.1 cvs 745: #endif 746: { 747: cssRule = SkipProperty (cssRule); 748: return (cssRule); 749: } 750: 751: /*---------------------------------------------------------------------- 752: ParseCSSListStylePosition : parse a CSS list-style-position 753: attribute string. 754: ----------------------------------------------------------------------*/ 755: #ifdef __STDC__ 756: static STRING ParseCSSListStylePosition (Element element, PSchema tsch, 1.14 cvs 757: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 758: #else 759: static STRING ParseCSSListStylePosition (element, tsch, context, cssRule, css, isHTML) 760: Element element; 761: PSchema tsch; 762: PresentationContext context; 763: STRING cssRule; 764: CSSInfoPtr css; 1.14 cvs 765: ThotBool isHTML; 1.1 cvs 766: #endif 767: { 768: cssRule = SkipProperty (cssRule); 769: return (cssRule); 770: } 771: 772: /*---------------------------------------------------------------------- 773: ParseCSSListStyle : parse a CSS list-style 774: attribute string. 775: ----------------------------------------------------------------------*/ 776: #ifdef __STDC__ 777: static STRING ParseCSSListStyle (Element element, PSchema tsch, 1.14 cvs 778: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 779: #else 780: static STRING ParseCSSListStyle (element, tsch, context, cssRule, css, isHTML) 781: Element element; 782: PSchema tsch; 783: PresentationContext context; 784: STRING cssRule; 785: CSSInfoPtr css; 1.14 cvs 786: ThotBool isHTML; 1.1 cvs 787: #endif 788: { 789: cssRule = SkipProperty (cssRule); 790: return (cssRule); 791: } 792: 793: /*---------------------------------------------------------------------- 794: ParseCSSTextAlign : parse a CSS text-align 795: attribute string. 796: ----------------------------------------------------------------------*/ 797: #ifdef __STDC__ 798: static STRING ParseCSSTextAlign (Element element, PSchema tsch, 1.14 cvs 799: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 800: #else 801: static STRING ParseCSSTextAlign (element, tsch, context, cssRule, css, isHTML) 802: Element element; 803: PSchema tsch; 804: PresentationContext context; 805: STRING cssRule; 806: CSSInfoPtr css; 1.14 cvs 807: ThotBool isHTML; 1.1 cvs 808: #endif 809: { 810: PresentationValue align; 811: PresentationValue justify; 812: 813: align.typed_data.value = 0; 814: align.typed_data.unit = STYLE_UNIT_REL; 815: align.typed_data.real = FALSE; 816: justify.typed_data.value = 0; 817: justify.typed_data.unit = STYLE_UNIT_REL; 818: justify.typed_data.real = FALSE; 819: 1.13 cvs 820: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 821: if (!ustrncasecmp (cssRule, TEXT("left"), 4)) 1.1 cvs 822: { 823: align.typed_data.value = AdjustLeft; 824: cssRule = SkipWord (cssRule); 825: } 1.17 cvs 826: else if (!ustrncasecmp (cssRule, TEXT("right"), 5)) 1.1 cvs 827: { 828: align.typed_data.value = AdjustRight; 829: cssRule = SkipWord (cssRule); 830: } 1.17 cvs 831: else if (!ustrncasecmp (cssRule, TEXT("center"), 6)) 1.1 cvs 832: { 833: align.typed_data.value = Centered; 834: cssRule = SkipWord (cssRule); 835: } 1.17 cvs 836: else if (!ustrncasecmp (cssRule, TEXT("justify"), 7)) 1.1 cvs 837: { 838: justify.typed_data.value = Justified; 839: cssRule = SkipWord (cssRule); 840: } 841: else 842: { 843: fprintf (stderr, "invalid align value\n"); 844: return (cssRule); 845: } 846: 847: /* 848: * install the new presentation. 849: */ 850: if (align.typed_data.value) 851: { 852: TtaSetStylePresentation (PRAdjust, element, tsch, context, align); 853: } 854: if (justify.typed_data.value) 855: { 856: TtaSetStylePresentation (PRJustify, element, tsch, context, justify); 857: TtaSetStylePresentation (PRHyphenate, element, tsch, context, justify); 858: } 859: return (cssRule); 860: } 861: 862: /*---------------------------------------------------------------------- 863: ParseCSSTextIndent : parse a CSS text-indent 864: attribute string. 865: ----------------------------------------------------------------------*/ 866: #ifdef __STDC__ 867: static STRING ParseCSSTextIndent (Element element, PSchema tsch, 1.14 cvs 868: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 869: #else 870: static STRING ParseCSSTextIndent (element, tsch, context, cssRule, css, isHTML) 871: Element element; 872: PSchema tsch; 873: PresentationContext context; 874: STRING cssRule; 875: CSSInfoPtr css; 1.14 cvs 876: ThotBool isHTML; 1.1 cvs 877: #endif 878: { 879: PresentationValue pval; 880: 1.13 cvs 881: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 882: cssRule = ParseCSSUnit (cssRule, &pval); 883: if (pval.typed_data.unit == STYLE_UNIT_INVALID) 884: return (cssRule); 885: /* install the attribute */ 886: TtaSetStylePresentation (PRIndent, element, tsch, context, pval); 887: return (cssRule); 888: } 889: 890: /*---------------------------------------------------------------------- 891: ParseCSSTextTransform : parse a CSS text-transform 892: attribute string. 893: ----------------------------------------------------------------------*/ 894: #ifdef __STDC__ 895: static STRING ParseCSSTextTransform (Element element, PSchema tsch, 1.14 cvs 896: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 897: #else 898: static STRING ParseCSSTextTransform (element, tsch, context, cssRule, css, isHTML) 899: Element element; 900: PSchema tsch; 901: PresentationContext context; 902: STRING cssRule; 903: CSSInfoPtr css; 1.14 cvs 904: ThotBool isHTML; 1.1 cvs 905: #endif 906: { 907: cssRule = SkipProperty (cssRule); 908: return (cssRule); 909: } 910: 911: /*---------------------------------------------------------------------- 912: ParseCSSVerticalAlign : parse a CSS vertical-align 913: attribute string. 914: ----------------------------------------------------------------------*/ 915: #ifdef __STDC__ 916: static STRING ParseCSSVerticalAlign (Element element, PSchema tsch, 1.14 cvs 917: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 918: #else 919: static STRING ParseCSSVerticalAlign (element, tsch, context, cssRule, css, isHTML) 920: Element element; 921: PSchema tsch; 922: PresentationContext context; 923: STRING cssRule; 924: CSSInfoPtr css; 1.14 cvs 925: ThotBool isHTML; 1.1 cvs 926: #endif 927: { 928: cssRule = SkipProperty (cssRule); 929: return (cssRule); 930: } 931: 932: /*---------------------------------------------------------------------- 933: ParseCSSWhiteSpace : parse a CSS white-space 934: attribute string. 935: ----------------------------------------------------------------------*/ 936: #ifdef __STDC__ 937: static STRING ParseCSSWhiteSpace (Element element, PSchema tsch, 1.14 cvs 938: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 939: #else 940: static STRING ParseCSSWhiteSpace (element, tsch, context, cssRule, css, isHTML) 941: Element element; 942: PSchema tsch; 943: PresentationContext context; 944: STRING cssRule; 945: CSSInfoPtr css; 1.14 cvs 946: ThotBool isHTML; 1.1 cvs 947: #endif 948: { 1.13 cvs 949: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 950: if (!ustrncasecmp (cssRule, TEXT("normal"), 6)) 1.1 cvs 951: cssRule = SkipWord (cssRule); 1.17 cvs 952: else if (!ustrncasecmp (cssRule, TEXT("pre"), 3)) 1.1 cvs 953: cssRule = SkipWord (cssRule); 954: else 955: return (cssRule); 956: return (cssRule); 957: } 958: 959: /*---------------------------------------------------------------------- 960: ParseCSSWordSpacing : parse a CSS word-spacing 961: attribute string. 962: ----------------------------------------------------------------------*/ 963: #ifdef __STDC__ 964: static STRING ParseCSSWordSpacing (Element element, PSchema tsch, 1.14 cvs 965: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 966: #else 967: static STRING ParseCSSWordSpacing (element, tsch, context, cssRule, css, isHTML) 968: Element element; 969: PSchema tsch; 970: PresentationContext context; 971: STRING cssRule; 972: CSSInfoPtr css; 1.14 cvs 973: ThotBool isHTML; 1.1 cvs 974: #endif 975: { 976: cssRule = SkipProperty (cssRule); 977: return (cssRule); 978: } 979: 980: /*---------------------------------------------------------------------- 1.25 cvs 981: ParseCSSLineSpacing : parse a CSS font leading string 982: we expect the input string describing the attribute to be 983: value% or value 984: ----------------------------------------------------------------------*/ 985: #ifdef __STDC__ 986: static STRING ParseCSSLineSpacing (Element element, PSchema tsch, 987: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 988: #else 989: static STRING ParseCSSLineSpacing (element, tsch, context, cssRule, css, isHTML) 990: Element element; 991: PSchema tsch; 992: PresentationContext context; 993: STRING cssRule; 994: CSSInfoPtr css; 995: ThotBool isHTML; 996: #endif 997: { 998: PresentationValue lead; 999: 1000: cssRule = ParseCSSUnit (cssRule, &lead); 1001: if (lead.typed_data.unit == STYLE_UNIT_INVALID) 1002: { 1003: /* invalid line spacing */ 1004: return (cssRule); 1005: } 1006: /* install the new presentation */ 1007: TtaSetStylePresentation (PRLineSpacing, element, tsch, context, lead); 1008: return (cssRule); 1009: } 1010: 1011: /*---------------------------------------------------------------------- 1.1 cvs 1012: ParseCSSFontSize : parse a CSS font size attr string 1013: we expect the input string describing the attribute to be 1014: xx-small, x-small, small, medium, large, x-large, xx-large 1015: or an absolute size, or an imcrement relative to the parent 1016: ----------------------------------------------------------------------*/ 1017: #ifdef __STDC__ 1018: static STRING ParseCSSFontSize (Element element, PSchema tsch, 1.14 cvs 1019: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1020: #else 1021: static STRING ParseCSSFontSize (element, tsch, context, cssRule, css, isHTML) 1022: Element element; 1023: PSchema tsch; 1024: PresentationContext context; 1025: STRING cssRule; 1026: CSSInfoPtr css; 1.14 cvs 1027: ThotBool isHTML; 1.1 cvs 1028: #endif 1029: { 1030: PresentationValue pval; 1.25 cvs 1031: STRING ptr = NULL; 1.14 cvs 1032: ThotBool real; 1.1 cvs 1033: 1034: pval.typed_data.real = FALSE; 1.13 cvs 1035: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 1036: if (!ustrncasecmp (cssRule, TEXT("larger"), 6)) 1.1 cvs 1037: { 1038: pval.typed_data.unit = STYLE_UNIT_PERCENT; 1039: pval.typed_data.value = 130; 1040: cssRule = SkipWord (cssRule); 1041: } 1.17 cvs 1042: else if (!ustrncasecmp (cssRule, TEXT("smaller"), 7)) 1.1 cvs 1043: { 1044: pval.typed_data.unit = STYLE_UNIT_PERCENT; 1045: pval.typed_data.value = 80; 1046: cssRule = SkipWord (cssRule); 1047: } 1.17 cvs 1048: else if (!ustrncasecmp (cssRule, TEXT("xx-small"), 8)) 1.1 cvs 1049: { 1050: pval.typed_data.unit = STYLE_UNIT_REL; 1051: pval.typed_data.value = 1; 1052: cssRule = SkipWord (cssRule); 1053: } 1.17 cvs 1054: else if (!ustrncasecmp (cssRule, TEXT("x-small"), 7)) 1.1 cvs 1055: { 1056: pval.typed_data.unit = STYLE_UNIT_REL; 1057: pval.typed_data.value = 2; 1058: cssRule = SkipWord (cssRule); 1059: } 1.17 cvs 1060: else if (!ustrncasecmp (cssRule, TEXT("small"), 5)) 1.1 cvs 1061: { 1062: pval.typed_data.unit = STYLE_UNIT_REL; 1063: pval.typed_data.value = 3; 1064: cssRule = SkipWord (cssRule); 1065: } 1.17 cvs 1066: else if (!ustrncasecmp (cssRule, TEXT("medium"), 6)) 1.1 cvs 1067: { 1068: pval.typed_data.unit = STYLE_UNIT_REL; 1069: pval.typed_data.value = 4; 1070: cssRule = SkipWord (cssRule); 1071: } 1.17 cvs 1072: else if (!ustrncasecmp (cssRule, TEXT("large"), 5)) 1.1 cvs 1073: { 1074: pval.typed_data.unit = STYLE_UNIT_REL; 1075: pval.typed_data.value = 5; 1076: cssRule = SkipWord (cssRule); 1077: } 1.17 cvs 1078: else if (!ustrncasecmp (cssRule, TEXT("x-large"), 7)) 1.1 cvs 1079: { 1080: pval.typed_data.unit = STYLE_UNIT_REL; 1081: pval.typed_data.value = 6; 1082: cssRule = SkipWord (cssRule); 1083: } 1.17 cvs 1084: else if (!ustrncasecmp (cssRule, TEXT("xx-large"), 8)) 1.1 cvs 1085: { 1086: pval.typed_data.unit = STYLE_UNIT_REL; 1087: pval.typed_data.value = 7; 1088: cssRule = SkipWord (cssRule); 1089: } 1090: else 1091: { 1.25 cvs 1092: /* look for a '/' within the current cssRule */ 1093: ptr = ustrchr (cssRule, TEXT('/')); 1094: if (ptr != NULL) 1095: { 1096: /* keep the line spacing rule */ 1097: ptr[0] = EOS; 1098: ptr = &ptr[1]; 1099: } 1.1 cvs 1100: cssRule = ParseCSSUnit (cssRule, &pval); 1101: if (pval.typed_data.unit == STYLE_UNIT_INVALID || 1102: pval.typed_data.value < 0) 1103: return (cssRule); 1104: if (pval.typed_data.unit == STYLE_UNIT_REL && pval.typed_data.value > 0) 1105: /* CSS relative sizes have to be higher than Thot ones */ 1106: pval.typed_data.value += 1; 1107: else 1108: { 1109: real = pval.typed_data.real; 1110: if (pval.typed_data.unit == STYLE_UNIT_EM) 1111: { 1112: if (real) 1113: { 1114: pval.typed_data.value /= 10; 1.11 cvs 1115: pval.typed_data.real = FALSE; 1.1 cvs 1116: real = FALSE; 1117: } 1118: else 1119: pval.typed_data.value *= 100; 1120: pval.typed_data.unit = STYLE_UNIT_PERCENT; 1121: } 1122: } 1.25 cvs 1123: 1.1 cvs 1124: } 1125: 1.25 cvs 1126: /* install the presentation style */ 1.1 cvs 1127: TtaSetStylePresentation (PRSize, element, tsch, context, pval); 1.25 cvs 1128: 1129: if (ptr != NULL) 1130: cssRule = ParseCSSLineSpacing (element, tsch, context, ptr, css, isHTML); 1.1 cvs 1131: return (cssRule); 1132: } 1133: 1134: /*---------------------------------------------------------------------- 1135: ParseCSSFontFamily : parse a CSS font family string 1136: we expect the input string describing the attribute to be 1137: a common generic font style name 1138: ----------------------------------------------------------------------*/ 1139: #ifdef __STDC__ 1140: static STRING ParseCSSFontFamily (Element element, PSchema tsch, 1.14 cvs 1141: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1142: #else 1143: static STRING ParseCSSFontFamily (element, tsch, context, cssRule, css, isHTML) 1144: Element element; 1145: PSchema tsch; 1146: PresentationContext context; 1147: STRING cssRule; 1148: CSSInfoPtr css; 1.14 cvs 1149: ThotBool isHTML; 1.1 cvs 1150: #endif 1151: { 1152: PresentationValue font; 1.7 cvs 1153: CHAR_T quoteChar; 1.1 cvs 1154: 1155: font.typed_data.value = 0; 1156: font.typed_data.unit = STYLE_UNIT_REL; 1157: font.typed_data.real = FALSE; 1.13 cvs 1158: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1159: if (*cssRule == '"' || *cssRule == '\'') 1160: { 1161: quoteChar = *cssRule; 1162: cssRule++; 1163: } 1164: else 1165: quoteChar = '\0'; 1166: 1.17 cvs 1167: if (!ustrncasecmp (cssRule, TEXT("times"), 5)) 1.1 cvs 1168: font.typed_data.value = STYLE_FONT_TIMES; 1.17 cvs 1169: else if (!ustrncasecmp (cssRule, TEXT("serif"), 5)) 1.1 cvs 1170: font.typed_data.value = STYLE_FONT_TIMES; 1.17 cvs 1171: else if (!ustrncasecmp (cssRule, TEXT("helvetica"), 9) || 1172: !ustrncasecmp (cssRule, TEXT("verdana"), 7)) 1.1 cvs 1173: font.typed_data.value = STYLE_FONT_HELVETICA; 1.17 cvs 1174: else if (!ustrncasecmp (cssRule, TEXT("sans-serif"), 10)) 1.1 cvs 1175: font.typed_data.value = STYLE_FONT_HELVETICA; 1.17 cvs 1176: else if (!ustrncasecmp (cssRule, TEXT("courier"), 7)) 1.1 cvs 1177: font.typed_data.value = STYLE_FONT_COURIER; 1.17 cvs 1178: else if (!ustrncasecmp (cssRule, TEXT("monospace"), 9)) 1.1 cvs 1179: font.typed_data.value = STYLE_FONT_COURIER; 1180: else 1181: /* unknown font name. Skip it */ 1182: { 1183: if (quoteChar) 1184: cssRule = SkipQuotedString (cssRule, quoteChar); 1185: else 1186: cssRule = SkipWord (cssRule); 1.13 cvs 1187: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1188: if (*cssRule == ',') 1189: { 1190: cssRule++; 1191: cssRule = ParseCSSFontFamily (element, tsch, context, cssRule, css, isHTML); 1192: return (cssRule); 1193: } 1194: } 1195: 1196: if (font.typed_data.value != 0) 1197: { 1198: cssRule = SkipProperty (cssRule); 1199: /* install the new presentation */ 1200: TtaSetStylePresentation (PRFont, element, tsch, context, font); 1201: } 1202: return (cssRule); 1203: } 1204: 1205: /*---------------------------------------------------------------------- 1206: ParseCSSFontWeight : parse a CSS font weight string 1207: we expect the input string describing the attribute to be 1.20 cvs 1208: normal, bold, bolder, lighter, 100, 200, 300, ... 900, inherit. 1.1 cvs 1209: ----------------------------------------------------------------------*/ 1210: #ifdef __STDC__ 1211: static STRING ParseCSSFontWeight (Element element, PSchema tsch, 1.14 cvs 1212: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1213: #else 1214: static STRING ParseCSSFontWeight (element, tsch, context, cssRule, css, isHTML) 1215: Element element; 1216: PSchema tsch; 1217: PresentationContext context; 1218: STRING cssRule; 1219: CSSInfoPtr css; 1.14 cvs 1220: ThotBool isHTML; 1.1 cvs 1221: #endif 1222: { 1.20 cvs 1223: PresentationValue weight; 1.1 cvs 1224: 1225: weight.typed_data.value = 0; 1226: weight.typed_data.unit = STYLE_UNIT_REL; 1227: weight.typed_data.real = FALSE; 1.13 cvs 1228: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 1229: if (!ustrncasecmp (cssRule, TEXT("100"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1230: { 1231: weight.typed_data.value = -3; 1232: cssRule = SkipWord (cssRule); 1233: } 1.17 cvs 1234: else if (!ustrncasecmp (cssRule, TEXT("200"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1235: { 1236: weight.typed_data.value = -2; 1237: cssRule = SkipWord (cssRule); 1238: } 1.17 cvs 1239: else if (!ustrncasecmp (cssRule, TEXT("300"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1240: { 1241: weight.typed_data.value = -1; 1242: cssRule = SkipWord (cssRule); 1243: } 1.17 cvs 1244: else if (!ustrncasecmp (cssRule, TEXT("normal"), 6) || 1245: (!ustrncasecmp (cssRule, TEXT("400"), 3) && !isalpha (cssRule[3]))) 1.1 cvs 1246: { 1247: weight.typed_data.value = 0; 1248: cssRule = SkipWord (cssRule); 1249: } 1.17 cvs 1250: else if (!ustrncasecmp (cssRule, TEXT("500"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1251: { 1252: weight.typed_data.value = +1; 1253: cssRule = SkipWord (cssRule); 1254: } 1.17 cvs 1255: else if (!ustrncasecmp (cssRule, TEXT("600"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1256: { 1257: weight.typed_data.value = +2; 1258: cssRule = SkipWord (cssRule); 1259: } 1.17 cvs 1260: else if (!ustrncasecmp (cssRule, TEXT("bold"), 4) || 1261: (!ustrncasecmp (cssRule, TEXT("700"), 3) && !isalpha (cssRule[3]))) 1.1 cvs 1262: { 1263: weight.typed_data.value = +3; 1264: cssRule = SkipWord (cssRule); 1265: } 1.17 cvs 1266: else if (!ustrncasecmp (cssRule, TEXT("800"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1267: { 1268: weight.typed_data.value = +4; 1269: cssRule = SkipWord (cssRule); 1270: } 1.17 cvs 1271: else if (!ustrncasecmp (cssRule, TEXT("900"), 3) && !isalpha (cssRule[3])) 1.1 cvs 1272: { 1273: weight.typed_data.value = +5; 1274: cssRule = SkipWord (cssRule); 1275: } 1.17 cvs 1276: else if (!ustrncasecmp (cssRule, TEXT("inherit"), 7) || 1277: !ustrncasecmp (cssRule, TEXT("bolder"), 6) || 1278: !ustrncasecmp (cssRule, TEXT("lighter"), 7)) 1.1 cvs 1279: { 1280: /* not implemented */ 1281: cssRule = SkipWord (cssRule); 1282: return (cssRule); 1283: } 1284: else 1285: return (cssRule); 1286: 1287: /* 1.20 cvs 1288: * Here we have to reduce since only two font weight values are supported 1.1 cvs 1289: * by the Thot presentation API. 1290: */ 1.20 cvs 1291: if (weight.typed_data.value > 0) 1292: weight.typed_data.value = STYLE_WEIGHT_BOLD; 1293: else 1294: weight.typed_data.value = STYLE_WEIGHT_NORMAL; 1.1 cvs 1295: 1296: /* install the new presentation */ 1.21 cvs 1297: TtaSetStylePresentation (PRWeight, element, tsch, context, weight); 1.1 cvs 1298: return (cssRule); 1299: } 1300: 1301: /*---------------------------------------------------------------------- 1302: ParseCSSFontVariant : parse a CSS font variant string 1303: we expect the input string describing the attribute to be 1304: normal or small-caps 1305: ----------------------------------------------------------------------*/ 1306: #ifdef __STDC__ 1307: static STRING ParseCSSFontVariant (Element element, PSchema tsch, 1.14 cvs 1308: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1309: #else 1310: static STRING ParseCSSFontVariant (element, tsch, context, cssRule, css, isHTML) 1311: Element element; 1312: PSchema tsch; 1313: PresentationContext context; 1314: STRING cssRule; 1315: CSSInfoPtr css; 1.14 cvs 1316: ThotBool isHTML; 1.1 cvs 1317: #endif 1318: { 1319: PresentationValue style; 1320: 1321: style.typed_data.value = 0; 1322: style.typed_data.unit = STYLE_UNIT_REL; 1323: style.typed_data.real = FALSE; 1.13 cvs 1324: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 1325: if (!ustrncasecmp (cssRule, TEXT("small-caps"), 10)) 1.1 cvs 1326: { 1327: /* Not supported yet */ 1328: cssRule = SkipWord (cssRule); 1329: } 1.17 cvs 1330: else if (!ustrncasecmp (cssRule, TEXT("normal"), 6)) 1.1 cvs 1331: { 1332: /* Not supported yet */ 1333: cssRule = SkipWord (cssRule); 1334: } 1.17 cvs 1335: else if (!ustrncasecmp (cssRule, TEXT("inherit"), 7)) 1.1 cvs 1336: { 1337: /* Not supported yet */ 1338: cssRule = SkipWord (cssRule); 1339: } 1340: else 1341: return (cssRule); 1342: 1343: return (cssRule); 1344: } 1345: 1346: 1347: /*---------------------------------------------------------------------- 1348: ParseCSSFontStyle : parse a CSS font style string 1349: we expect the input string describing the attribute to be 1350: italic, oblique or normal 1351: ----------------------------------------------------------------------*/ 1352: #ifdef __STDC__ 1353: static STRING ParseCSSFontStyle (Element element, PSchema tsch, 1.14 cvs 1354: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1355: #else 1356: static STRING ParseCSSFontStyle (element, tsch, context, cssRule, css, isHTML) 1357: Element element; 1358: PSchema tsch; 1359: PresentationContext context; 1360: STRING cssRule; 1361: CSSInfoPtr css; 1.14 cvs 1362: ThotBool isHTML; 1.1 cvs 1363: #endif 1364: { 1365: PresentationValue style; 1366: PresentationValue size; 1367: 1368: style.typed_data.value = 0; 1369: style.typed_data.unit = STYLE_UNIT_REL; 1370: style.typed_data.real = FALSE; 1371: size.typed_data.value = 0; 1372: size.typed_data.unit = STYLE_UNIT_REL; 1373: size.typed_data.real = FALSE; 1.13 cvs 1374: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 1375: if (!ustrncasecmp (cssRule, TEXT("italic"), 6)) 1.1 cvs 1376: { 1377: style.typed_data.value = STYLE_FONT_ITALICS; 1378: cssRule = SkipWord (cssRule); 1379: } 1.17 cvs 1380: else if (!ustrncasecmp (cssRule, TEXT("oblique"), 7)) 1.1 cvs 1381: { 1382: style.typed_data.value = STYLE_FONT_OBLIQUE; 1383: cssRule = SkipWord (cssRule); 1384: } 1.17 cvs 1385: else if (!ustrncasecmp (cssRule, TEXT("normal"), 6)) 1.1 cvs 1386: { 1387: style.typed_data.value = STYLE_FONT_ROMAN; 1388: cssRule = SkipWord (cssRule); 1389: } 1390: else 1391: { 1392: /* invalid font style */ 1393: return (cssRule); 1394: } 1395: 1396: /* 1397: * install the new presentation. 1398: */ 1399: if (style.typed_data.value != 0) 1.20 cvs 1400: TtaSetStylePresentation (PRStyle, element, tsch, context, style); 1.1 cvs 1401: if (size.typed_data.value != 0) 1402: { 1403: PresentationValue previous_size; 1404: 1405: if (!TtaGetStylePresentation (PRSize, element, tsch, context, &previous_size)) 1406: { 1407: /* !!!!!!!!!!!!!!!!!!!!!!!! Unite + relatif !!!!!!!!!!!!!!!! */ 1408: size.typed_data.value += previous_size.typed_data.value; 1409: TtaSetStylePresentation (PRSize, element, tsch, context, size); 1410: } 1411: else 1412: { 1413: size.typed_data.value = 10; 1414: TtaSetStylePresentation (PRSize, element, tsch, context, size); 1415: } 1416: } 1417: return (cssRule); 1418: } 1419: 1420: /*---------------------------------------------------------------------- 1421: ParseCSSFont : parse a CSS font attribute string 1422: we expect the input string describing the attribute to be 1423: !!!!!! 1424: ----------------------------------------------------------------------*/ 1425: #ifdef __STDC__ 1426: static STRING ParseCSSFont (Element element, PSchema tsch, 1.14 cvs 1427: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1428: #else 1429: static STRING ParseCSSFont (element, tsch, context, cssRule, css, isHTML) 1430: Element element; 1431: PSchema tsch; 1432: PresentationContext context; 1433: STRING cssRule; 1434: CSSInfoPtr css; 1.14 cvs 1435: ThotBool isHTML; 1.1 cvs 1436: #endif 1437: { 1438: STRING ptr; 1439: 1.13 cvs 1440: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 1441: if (!ustrncasecmp (cssRule, TEXT("caption"), 7)) 1.1 cvs 1442: ; 1.17 cvs 1443: else if (!ustrncasecmp (cssRule, TEXT("icon"), 4)) 1.1 cvs 1444: ; 1.17 cvs 1445: else if (!ustrncasecmp (cssRule, TEXT("menu"), 4)) 1.1 cvs 1446: ; 1.17 cvs 1447: else if (!ustrncasecmp (cssRule, TEXT("message-box"), 11)) 1.1 cvs 1448: ; 1.17 cvs 1449: else if (!ustrncasecmp (cssRule, TEXT("small-caption"), 13)) 1.1 cvs 1450: ; 1.17 cvs 1451: else if (!ustrncasecmp (cssRule, TEXT("status-bar"), 10)) 1.1 cvs 1452: ; 1453: else 1454: { 1455: ptr = cssRule; 1456: cssRule = ParseCSSFontStyle (element, tsch, context, cssRule, css, isHTML); 1457: if (ptr == cssRule) 1458: cssRule = ParseCSSFontVariant (element, tsch, context, cssRule, css, isHTML); 1459: if (ptr == cssRule) 1460: cssRule = ParseCSSFontWeight (element, tsch, context, cssRule, css, isHTML); 1461: cssRule = ParseCSSFontSize (element, tsch, context, cssRule, css, isHTML); 1462: if (*cssRule == '/') 1463: { 1464: cssRule++; 1.13 cvs 1465: SkipBlanksAndComments (cssRule); 1.1 cvs 1466: cssRule = SkipWord (cssRule); 1467: } 1468: cssRule = ParseCSSFontFamily (element, tsch, context, cssRule, css, isHTML); 1.13 cvs 1469: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1470: while (*cssRule != ';' && *cssRule != EOS) 1471: { 1472: /* now skip remainding info */ 1473: cssRule++; 1474: } 1475: } 1476: return (cssRule); 1477: } 1478: 1479: /*---------------------------------------------------------------------- 1480: ParseCSSTextDecoration : parse a CSS text decor string 1481: we expect the input string describing the attribute to be 1482: underline, overline, line-through, box, shadowbox, box3d, 1483: cartouche, blink or none 1484: ----------------------------------------------------------------------*/ 1485: #ifdef __STDC__ 1486: static STRING ParseCSSTextDecoration (Element element, PSchema tsch, 1.14 cvs 1487: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1488: #else 1489: static STRING ParseCSSTextDecoration (element, tsch, context, cssRule, css, isHTML) 1490: Element element; 1491: PSchema tsch; 1492: PresentationContext context; 1493: STRING cssRule; 1494: CSSInfoPtr css; 1.14 cvs 1495: ThotBool isHTML; 1.1 cvs 1496: #endif 1497: { 1498: PresentationValue decor; 1499: 1500: decor.typed_data.value = 0; 1501: decor.typed_data.unit = STYLE_UNIT_REL; 1502: decor.typed_data.real = FALSE; 1.13 cvs 1503: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 1504: if (!ustrncasecmp (cssRule, TEXT("underline"), ustrlen (TEXT("underline")))) 1.1 cvs 1505: { 1506: decor.typed_data.value = Underline; 1507: cssRule = SkipWord (cssRule); 1508: } 1.17 cvs 1509: else if (!ustrncasecmp (cssRule, TEXT("overline"), ustrlen (TEXT("overline")))) 1.1 cvs 1510: { 1511: decor.typed_data.value = Overline; 1512: cssRule = SkipWord (cssRule); 1513: } 1.17 cvs 1514: else if (!ustrncasecmp (cssRule, TEXT("line-through"), ustrlen (TEXT("line-through")))) 1.1 cvs 1515: { 1516: decor.typed_data.value = CrossOut; 1517: cssRule = SkipWord (cssRule); 1518: } 1.17 cvs 1519: else if (!ustrncasecmp (cssRule, TEXT("box"), ustrlen (TEXT("box")))) 1.1 cvs 1520: { 1521: /* the box text-decoration attribute is not yet supported */ 1522: cssRule = SkipWord (cssRule); 1523: } 1.17 cvs 1524: else if (!ustrncasecmp (cssRule, TEXT("boxshadow"), ustrlen (TEXT("boxshadow")))) 1.1 cvs 1525: { 1526: /* the boxshadow text-decoration attribute is not yet supported */ 1527: cssRule = SkipWord (cssRule); 1528: } 1.17 cvs 1529: else if (!ustrncasecmp (cssRule, TEXT("box3d"), ustrlen (TEXT("box3d")))) 1.1 cvs 1530: { 1531: /* the box3d text-decoration attribute is not yet supported */ 1532: cssRule = SkipWord (cssRule); 1533: } 1.17 cvs 1534: else if (!ustrncasecmp (cssRule, TEXT("cartouche"), ustrlen (TEXT("cartouche")))) 1.1 cvs 1535: { 1536: /*the cartouche text-decoration attribute is not yet supported */ 1537: cssRule = SkipWord (cssRule); 1538: } 1.17 cvs 1539: else if (!ustrncasecmp (cssRule, TEXT("blink"), ustrlen (TEXT("blink")))) 1.1 cvs 1540: { 1541: /*the blink text-decoration attribute will not be supported */ 1542: cssRule = SkipWord (cssRule); 1543: } 1.17 cvs 1544: else if (!ustrncasecmp (cssRule, TEXT("none"), ustrlen (TEXT("none")))) 1.1 cvs 1545: { 1546: decor.typed_data.value = NoUnderline; 1547: cssRule = SkipWord (cssRule); 1548: } 1549: else 1550: { 1551: fprintf (stderr, "invalid text decoration\n"); 1552: return (cssRule); 1553: } 1554: 1555: /* 1556: * install the new presentation. 1557: */ 1558: if (decor.typed_data.value) 1559: { 1560: TtaSetStylePresentation (PRUnderline, element, tsch, context, decor); 1561: } 1562: return (cssRule); 1563: } 1564: 1565: /*---------------------------------------------------------------------- 1566: ParseCSSColor : parse a CSS color attribute string 1567: we expect the input string describing the attribute to be 1568: either a color name, a 3 tuple or an hexadecimal encoding. 1569: The color used will be approximed from the current color 1570: table 1571: ----------------------------------------------------------------------*/ 1572: #ifdef __STDC__ 1573: static STRING ParseCSSColor (STRING cssRule, PresentationValue * val) 1574: #else 1575: static STRING ParseCSSColor (cssRule, val) 1576: STRING cssRule; 1577: PresentationValue *val; 1578: #endif 1579: { 1.7 cvs 1580: CHAR_T colname[100]; 1.1 cvs 1581: unsigned short redval = (unsigned short) -1; 1582: unsigned short greenval = 0; /* composant of each RGB */ 1583: unsigned short blueval = 0; /* default to red if unknown ! */ 1584: unsigned int i, len; 1585: int r, g, b; 1586: int best = 0; /* best color in list found */ 1.14 cvs 1587: ThotBool failed; 1.1 cvs 1588: 1.13 cvs 1589: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1590: val->typed_data.unit = STYLE_UNIT_INVALID; 1591: val->typed_data.real = FALSE; 1592: val->typed_data.value = 0; 1593: failed = TRUE; 1594: /* 1595: * first parse the attribute string 1596: * NOTE : this can't lookup for color name in 1597: * cause we try first to lokup color name from digits 1598: * [0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f] 1599: */ 1600: if ((*cssRule == '#') || 1601: (isxdigit (cssRule[0]) && isxdigit (cssRule[1]) && 1602: isxdigit (cssRule[2]))) 1603: { 1604: if (*cssRule == '#') 1605: cssRule++; 1606: failed = FALSE; 1607: /* we expect an hexa encoding like F00 or FF0000 */ 1608: if ((!isxdigit (cssRule[0])) || (!isxdigit (cssRule[1])) || 1609: (!isxdigit (cssRule[2]))) 1610: { 1611: fprintf (stderr, "Invalid color encoding %s\n", cssRule - 1); 1612: failed = TRUE; 1613: } 1614: else if (!isxdigit (cssRule[3])) 1615: { 1616: /* encoded as on 3 digits #F0F */ 1617: redval = hexa_val (cssRule[0]) * 16 + hexa_val (cssRule[0]); 1618: greenval = hexa_val (cssRule[1]) * 16 + hexa_val (cssRule[1]); 1619: blueval = hexa_val (cssRule[2]) * 16 + hexa_val (cssRule[2]); 1.13 cvs 1620: cssRule = &cssRule[3]; 1.1 cvs 1621: } 1622: else if ((!isxdigit (cssRule[4])) || (!isxdigit (cssRule[5]))) 1623: fprintf (stderr, "Invalid color encoding %s\n", cssRule - 1); 1624: else 1625: { 1626: /* encoded as on 3 digits #FF00FF */ 1627: redval = hexa_val (cssRule[0]) * 16 + hexa_val (cssRule[1]); 1628: greenval = hexa_val (cssRule[2]) * 16 + hexa_val (cssRule[3]); 1629: blueval = hexa_val (cssRule[4]) * 16 + hexa_val (cssRule[5]); 1.13 cvs 1630: cssRule = &cssRule[6]; 1.1 cvs 1631: } 1632: } 1.17 cvs 1633: else if (!ustrncasecmp (cssRule, TEXT("rgb"), 3)) 1.1 cvs 1634: { 1.13 cvs 1635: cssRule = &cssRule[3]; 1636: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1637: if (*cssRule == '(') 1638: { 1639: cssRule++; 1.13 cvs 1640: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1641: failed = FALSE; 1642: if (*cssRule == '%') 1643: { 1644: /* encoded as rgb(%red,%green,&blue) */ 1.17 cvs 1645: usscanf (cssRule, TEXT("%%%d"), &r); 1646: while (*cssRule != EOS && *cssRule != TEXT(',')) 1.1 cvs 1647: cssRule++; 1648: cssRule++; 1.17 cvs 1649: usscanf (cssRule, TEXT("%%%d"), &g); 1650: while (*cssRule != EOS && *cssRule != TEXT(',')) 1.1 cvs 1651: cssRule++; 1652: cssRule++; 1.17 cvs 1653: usscanf (cssRule, TEXT("%%%d"), &b); 1.1 cvs 1654: redval = (unsigned short)(r * 255 / 100); 1655: greenval = (unsigned short)(g * 255 / 100); 1656: blueval = (unsigned short)(b * 255 / 100); 1657: } 1658: else 1659: { 1660: /* encoded as rgb(red,green,blue) */ 1.17 cvs 1661: usscanf (cssRule, TEXT("%d"), &r); 1662: while (*cssRule != EOS && *cssRule != TEXT(',')) 1.1 cvs 1663: cssRule++; 1664: cssRule++; 1.17 cvs 1665: usscanf (cssRule, TEXT("%d"), &g); 1666: while (*cssRule != EOS && *cssRule != TEXT(',')) 1.1 cvs 1667: cssRule++; 1668: cssRule++; 1.17 cvs 1669: usscanf (cssRule, TEXT("%d"), &b); 1.1 cvs 1670: redval = (unsigned short)r; 1671: greenval = (unsigned short)g; 1672: blueval = (unsigned short)b; 1673: } 1674: /* search the rgb end */ 1675: while (*cssRule != EOS && *cssRule != ')') 1676: cssRule++; 1677: cssRule++; 1678: } 1679: else 1680: cssRule = SkipProperty (cssRule); 1681: } 1682: else if (isalpha (*cssRule)) 1683: { 1684: /* we expect a color name like "red", store it in colname */ 1685: len = sizeof (colname) - 1; 1686: for (i = 0; i < len && cssRule[i] != EOS; i++) 1687: { 1688: if (!isalnum (cssRule[i]) && cssRule[i] != EOS) 1689: { 1690: cssRule += i; 1691: break; 1692: } 1693: colname[i] = cssRule[i]; 1694: } 1695: colname[i] = EOS; 1696: 1697: /* Lookup the color name in our own color name database */ 1698: for (i = 0; i < NBCOLORNAME; i++) 1699: if (!ustrcasecmp (ColornameTable[i].name, colname)) 1700: { 1701: redval = ColornameTable[i].red; 1702: greenval = ColornameTable[i].green; 1703: blueval = ColornameTable[i].blue; 1704: failed = FALSE; 1705: i = NBCOLORNAME; 1706: } 1.23 cvs 1707: /******** Lookup the color name in Thot color name database 1.1 cvs 1708: if (failed) 1709: { 1710: TtaGiveRGB (colname, &redval, &greenval, &blueval); 1711: failed = FALSE; 1712: } 1.23 cvs 1713: **********/ 1.1 cvs 1714: } 1715: 1716: if (failed) 1.25 cvs 1717: { 1718: val->typed_data.value = 0; 1719: val->typed_data.unit = STYLE_UNIT_INVALID; 1720: } 1.1 cvs 1721: else 1722: { 1723: best = TtaGetThotColor (redval, greenval, blueval); 1724: val->typed_data.value = best; 1.26 cvs 1725: val->typed_data.unit = STYLE_UNIT_REL; 1.1 cvs 1726: } 1727: val->typed_data.real = FALSE; 1728: return (cssRule); 1729: } 1730: 1731: /*---------------------------------------------------------------------- 1732: ParseCSSHeight : parse a CSS height attribute 1733: ----------------------------------------------------------------------*/ 1734: #ifdef __STDC__ 1735: static STRING ParseCSSHeight (Element element, PSchema tsch, 1.14 cvs 1736: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1737: #else 1738: static STRING ParseCSSHeight (element, tsch, context, cssRule, css, isHTML) 1739: Element element; 1740: PSchema tsch; 1741: PresentationContext context; 1742: STRING cssRule; 1743: CSSInfoPtr css; 1.14 cvs 1744: ThotBool isHTML; 1.1 cvs 1745: #endif 1746: { 1.13 cvs 1747: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1748: 1749: /* first parse the attribute string */ 1.17 cvs 1750: if (!ustrcasecmp (cssRule, TEXT("auto"))) 1.1 cvs 1751: { 1752: cssRule = SkipWord (cssRule); 1753: /* ParseCSSHeight : auto */ 1754: return (cssRule); 1755: } 1756: else 1757: cssRule = SkipProperty (cssRule); 1758: return (cssRule); 1759: } 1760: 1761: /*---------------------------------------------------------------------- 1762: ParseCSSWidth : parse a CSS width attribute 1763: ----------------------------------------------------------------------*/ 1764: #ifdef __STDC__ 1765: static STRING ParseCSSWidth (Element element, PSchema tsch, 1.14 cvs 1766: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1767: #else 1768: static STRING ParseCSSWidth (element, tsch, context, cssRule, css, isHTML) 1769: Element element; 1770: PSchema tsch; 1771: PresentationContext context; 1772: STRING cssRule; 1773: CSSInfoPtr css; 1.14 cvs 1774: ThotBool isHTML; 1.1 cvs 1775: #endif 1776: { 1.13 cvs 1777: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1778: 1779: /* first parse the attribute string */ 1.17 cvs 1780: if (!ustrcasecmp (cssRule, TEXT("auto"))) 1.1 cvs 1781: { 1782: cssRule = SkipWord (cssRule); 1783: return (cssRule); 1784: } 1785: else 1786: cssRule = SkipProperty (cssRule); 1787: return (cssRule); 1788: } 1789: 1790: /*---------------------------------------------------------------------- 1791: ParseCSSMarginTop : parse a CSS margin-top attribute 1792: ----------------------------------------------------------------------*/ 1793: #ifdef __STDC__ 1794: static STRING ParseCSSMarginTop (Element element, PSchema tsch, 1.14 cvs 1795: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1796: #else 1797: static STRING ParseCSSMarginTop (element, tsch, context, cssRule, css, isHTML) 1798: Element element; 1799: PSchema tsch; 1800: PresentationContext context; 1801: STRING cssRule; 1802: CSSInfoPtr css; 1.14 cvs 1803: ThotBool isHTML; 1.1 cvs 1804: #endif 1805: { 1806: PresentationValue margin; 1807: 1.13 cvs 1808: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1809: /* first parse the attribute string */ 1810: cssRule = ParseCSSUnit (cssRule, &margin); 1.3 cvs 1811: if (margin.typed_data.unit != STYLE_UNIT_INVALID && margin.typed_data.value != 0) 1.1 cvs 1812: { 1813: TtaSetStylePresentation (PRTMargin, element, tsch, context, margin); 1814: if (margin.typed_data.value < 0) 1815: TtaSetStylePresentation (PRVertOverflow, element, tsch, context, margin); 1816: } 1817: return (cssRule); 1818: } 1819: 1820: /*---------------------------------------------------------------------- 1821: ParseCSSMarginBottom : parse a CSS margin-bottom 1822: attribute 1823: ----------------------------------------------------------------------*/ 1824: #ifdef __STDC__ 1825: static STRING ParseCSSMarginBottom (Element element, PSchema tsch, 1.14 cvs 1826: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1827: #else 1828: static STRING ParseCSSMarginBottom (element, tsch, context, cssRule, css, isHTML) 1829: Element element; 1830: PSchema tsch; 1831: PresentationContext context; 1832: STRING cssRule; 1833: CSSInfoPtr css; 1.14 cvs 1834: ThotBool isHTML; 1.1 cvs 1835: #endif 1836: { 1837: PresentationValue margin; 1838: 1.13 cvs 1839: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1840: /* first parse the attribute string */ 1841: cssRule = ParseCSSUnit (cssRule, &margin); 1842: margin.typed_data.value = - margin.typed_data.value; 1843: /*if (margin.typed_data.unit != STYLE_UNIT_INVALID) 1844: TtaSetStylePresentation (PRBMargin, element, tsch, context, margin)*/; 1845: return (cssRule); 1846: } 1847: 1848: /*---------------------------------------------------------------------- 1849: ParseCSSMarginLeft : parse a CSS margin-left 1850: attribute string. 1851: ----------------------------------------------------------------------*/ 1852: #ifdef __STDC__ 1853: static STRING ParseCSSMarginLeft (Element element, PSchema tsch, 1.14 cvs 1854: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1855: #else 1856: static STRING ParseCSSMarginLeft (element, tsch, context, cssRule, css, isHTML) 1857: Element element; 1858: PSchema tsch; 1859: PresentationContext context; 1860: STRING cssRule; 1861: CSSInfoPtr css; 1.14 cvs 1862: ThotBool isHTML; 1.1 cvs 1863: #endif 1864: { 1865: PresentationValue margin; 1866: 1.13 cvs 1867: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1868: /* first parse the attribute string */ 1869: cssRule = ParseCSSUnit (cssRule, &margin); 1.3 cvs 1870: if (margin.typed_data.unit != STYLE_UNIT_INVALID && margin.typed_data.value != 0) 1.1 cvs 1871: { 1872: TtaSetStylePresentation (PRLMargin, element, tsch, context, margin); 1873: if (margin.typed_data.value < 0) 1874: TtaSetStylePresentation (PRHorizOverflow, element, tsch, context, margin); 1875: TtaSetStylePresentation (PRRMargin, element, tsch, context, margin); 1876: } 1877: return (cssRule); 1878: } 1879: 1880: /*---------------------------------------------------------------------- 1881: ParseCSSMarginRight : parse a CSS margin-right 1882: attribute string. 1883: ----------------------------------------------------------------------*/ 1884: #ifdef __STDC__ 1885: static STRING ParseCSSMarginRight (Element element, PSchema tsch, 1.14 cvs 1886: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1887: #else 1888: static STRING ParseCSSMarginRight (element, tsch, context, cssRule, css, isHTML) 1889: Element element; 1890: PSchema tsch; 1891: PresentationContext context; 1892: STRING cssRule; 1893: CSSInfoPtr css; 1.14 cvs 1894: ThotBool isHTML; 1.1 cvs 1895: #endif 1896: { 1897: PresentationValue margin; 1898: 1.13 cvs 1899: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1900: /* first parse the attribute string */ 1901: cssRule = ParseCSSUnit (cssRule, &margin); 1902: /*if (margin.typed_data.unit != STYLE_UNIT_INVALID) 1903: TtaSetStylePresentation (PRRMargin, element, tsch, context, margin)*/; 1904: return (cssRule); 1905: } 1906: 1907: /*---------------------------------------------------------------------- 1908: ParseCSSMargin : parse a CSS margin attribute string. 1909: ----------------------------------------------------------------------*/ 1910: #ifdef __STDC__ 1911: static STRING ParseCSSMargin (Element element, PSchema tsch, 1.14 cvs 1912: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1913: #else 1914: static STRING ParseCSSMargin (element, tsch, context, cssRule, css, isHTML) 1915: Element element; 1916: PSchema tsch; 1917: PresentationContext context; 1918: STRING cssRule; 1919: CSSInfoPtr css; 1.14 cvs 1920: ThotBool isHTML; 1.1 cvs 1921: #endif 1922: { 1923: STRING ptrT, ptrR, ptrB, ptrL; 1924: 1.13 cvs 1925: ptrT = SkipBlanksAndComments (cssRule); 1.1 cvs 1926: /* First parse Margin-Top */ 1927: ptrR = ParseCSSMarginTop (element, tsch, context, ptrT, css, isHTML); 1.13 cvs 1928: ptrR = SkipBlanksAndComments (ptrR); 1.1 cvs 1929: if (*ptrR == ';' || *ptrR == EOS || *ptrR == ',') 1930: { 1931: cssRule = ptrR; 1932: /* apply the Margin-Top to all */ 1933: ptrR = ParseCSSMarginRight (element, tsch, context, ptrT, css, isHTML); 1934: ptrR = ParseCSSMarginBottom (element, tsch, context, ptrT, css, isHTML); 1935: ptrR = ParseCSSMarginLeft (element, tsch, context, ptrT, css, isHTML); 1936: } 1937: else 1938: { 1939: /* parse Margin-Right */ 1940: ptrB = ParseCSSMarginRight (element, tsch, context, ptrR, css, isHTML); 1.13 cvs 1941: ptrB = SkipBlanksAndComments (ptrB); 1.1 cvs 1942: if (*ptrB == ';' || *ptrB == EOS || *ptrB == ',') 1943: { 1944: cssRule = ptrB; 1945: /* apply the Margin-Top to Margin-Bottom */ 1946: ptrB = ParseCSSMarginBottom (element, tsch, context, ptrT, css, isHTML); 1947: /* apply the Margin-Right to Margin-Left */ 1948: ptrB = ParseCSSMarginLeft (element, tsch, context, ptrR, css, isHTML); 1949: } 1950: else 1951: { 1952: /* parse Margin-Bottom */ 1953: ptrL = ParseCSSMarginBottom (element, tsch, context, ptrB, css, isHTML); 1.13 cvs 1954: ptrL = SkipBlanksAndComments (ptrL); 1.1 cvs 1955: if (*ptrL == ';' || *ptrL == EOS || *ptrL == ',') 1956: { 1957: cssRule = ptrL; 1958: /* apply the Margin-Right to Margin-Left */ 1959: ptrL = ParseCSSMarginLeft (element, tsch, context, ptrR, css, isHTML); 1960: } 1961: else 1962: /* parse Margin-Left */ 1963: cssRule = ParseCSSMarginLeft (element, tsch, context, ptrL, css, isHTML); 1.13 cvs 1964: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 1965: } 1966: } 1967: return (cssRule); 1968: } 1969: 1970: /*---------------------------------------------------------------------- 1971: ParseCSSPaddingTop : parse a CSS PaddingTop 1972: attribute string. 1973: ----------------------------------------------------------------------*/ 1974: #ifdef __STDC__ 1975: static STRING ParseCSSPaddingTop (Element element, PSchema tsch, 1.14 cvs 1976: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1977: #else 1978: static STRING ParseCSSPaddingTop (element, tsch, context, cssRule, css, isHTML) 1979: Element element; 1980: PSchema tsch; 1981: PresentationContext context; 1982: STRING cssRule; 1983: CSSInfoPtr css; 1.14 cvs 1984: ThotBool isHTML; 1.1 cvs 1985: #endif 1986: { 1987: cssRule = SkipProperty (cssRule); 1988: return (cssRule); 1989: } 1990: 1991: /*---------------------------------------------------------------------- 1992: ParseCSSPaddingRight : parse a CSS PaddingRight 1993: attribute string. 1994: ----------------------------------------------------------------------*/ 1995: #ifdef __STDC__ 1996: static STRING ParseCSSPaddingRight (Element element, PSchema tsch, 1.14 cvs 1997: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 1998: #else 1999: static STRING ParseCSSPaddingRight (element, tsch, context, cssRule, css, isHTML) 2000: Element element; 2001: PSchema tsch; 2002: PresentationContext context; 2003: STRING cssRule; 2004: CSSInfoPtr css; 1.14 cvs 2005: ThotBool isHTML; 1.1 cvs 2006: #endif 2007: { 2008: cssRule = SkipProperty (cssRule); 2009: return (cssRule); 2010: } 2011: 2012: 2013: /*---------------------------------------------------------------------- 2014: ParseCSSPaddingBottom : parse a CSS PaddingBottom 2015: attribute string. 2016: ----------------------------------------------------------------------*/ 2017: #ifdef __STDC__ 2018: static STRING ParseCSSPaddingBottom (Element element, PSchema tsch, 1.14 cvs 2019: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2020: #else 2021: static STRING ParseCSSPaddingBottom (element, tsch, context, cssRule, css, isHTML) 2022: Element element; 2023: PSchema tsch; 2024: PresentationContext context; 2025: STRING cssRule; 2026: CSSInfoPtr css; 1.14 cvs 2027: ThotBool isHTML; 1.1 cvs 2028: #endif 2029: { 2030: cssRule = SkipProperty (cssRule); 2031: return (cssRule); 2032: } 2033: 2034: /*---------------------------------------------------------------------- 2035: ParseCSSPaddingLeft : parse a CSS PaddingLeft 2036: attribute string. 2037: ----------------------------------------------------------------------*/ 2038: #ifdef __STDC__ 2039: static STRING ParseCSSPaddingLeft (Element element, PSchema tsch, 1.14 cvs 2040: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2041: #else 2042: static STRING ParseCSSPaddingLeft (element, tsch, context, cssRule, css, isHTML) 2043: Element element; 2044: PSchema tsch; 2045: PresentationContext context; 2046: STRING cssRule; 2047: CSSInfoPtr css; 1.14 cvs 2048: ThotBool isHTML; 1.1 cvs 2049: #endif 2050: { 2051: cssRule = SkipProperty (cssRule); 2052: return (cssRule); 2053: } 2054: 2055: /*---------------------------------------------------------------------- 2056: ParseCSSPadding : parse a CSS padding attribute string. 2057: ----------------------------------------------------------------------*/ 2058: #ifdef __STDC__ 2059: static STRING ParseCSSPadding (Element element, PSchema tsch, 1.14 cvs 2060: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2061: #else 2062: static STRING ParseCSSPadding (element, tsch, context, cssRule, css, isHTML) 2063: Element element; 2064: PSchema tsch; 2065: PresentationContext context; 2066: STRING cssRule; 2067: CSSInfoPtr css; 1.14 cvs 2068: ThotBool isHTML; 1.1 cvs 2069: #endif 2070: { 2071: cssRule = SkipProperty (cssRule); 2072: return (cssRule); 2073: } 2074: 2075: /*---------------------------------------------------------------------- 2076: ParseCSSForeground : parse a CSS foreground attribute 2077: ----------------------------------------------------------------------*/ 2078: #ifdef __STDC__ 2079: static STRING ParseCSSForeground (Element element, PSchema tsch, 1.14 cvs 2080: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2081: #else 2082: static STRING ParseCSSForeground (element, tsch, context, cssRule, css, isHTML) 2083: Element element; 2084: PSchema tsch; 2085: PresentationContext context; 2086: STRING cssRule; 2087: CSSInfoPtr css; 1.14 cvs 2088: ThotBool isHTML; 1.1 cvs 2089: #endif 2090: { 2091: PresentationValue best; 2092: 2093: cssRule = ParseCSSColor (cssRule, &best); 1.25 cvs 2094: if (best.typed_data.unit != STYLE_UNIT_INVALID) 2095: /* install the new presentation */ 2096: TtaSetStylePresentation (PRForeground, element, tsch, context, best); 1.1 cvs 2097: return (cssRule); 2098: } 2099: 2100: /*---------------------------------------------------------------------- 2101: ParseCSSBackgroundColor : parse a CSS background color attribute 2102: ----------------------------------------------------------------------*/ 2103: #ifdef __STDC__ 2104: static STRING ParseCSSBackgroundColor (Element element, PSchema tsch, 1.14 cvs 2105: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2106: #else 2107: static STRING ParseCSSBackgroundColor (element, tsch, context, cssRule, css, isHTML) 2108: Element element; 2109: PSchema tsch; 2110: PresentationContext context; 2111: STRING cssRule; 2112: CSSInfoPtr css; 1.14 cvs 2113: ThotBool isHTML; 1.1 cvs 2114: #endif 2115: { 2116: PresentationValue best; 2117: unsigned int savedtype = 0; 1.14 cvs 2118: ThotBool moved; 1.1 cvs 2119: 2120: /* move the BODY rule to the HTML element */ 2121: moved = (context->type == HTML_EL_BODY && isHTML); 2122: if (moved) 2123: { 2124: if (element) 2125: element = TtaGetMainRoot (context->doc); 2126: else 2127: { 2128: savedtype = context->type; 2129: context->type = HTML_EL_HTML; 2130: } 2131: } 2132: 2133: best.typed_data.unit = STYLE_UNIT_INVALID; 2134: best.typed_data.real = FALSE; 1.17 cvs 2135: if (!ustrncasecmp (cssRule, TEXT("transparent"), ustrlen (TEXT("transparent")))) 1.1 cvs 2136: { 2137: best.typed_data.value = STYLE_PATTERN_NONE; 2138: best.typed_data.unit = STYLE_UNIT_REL; 2139: TtaSetStylePresentation (PRFillPattern, element, tsch, context, best); 2140: } 2141: else 2142: { 2143: cssRule = ParseCSSColor (cssRule, &best); 2144: if (best.typed_data.unit != STYLE_UNIT_INVALID) 2145: { 2146: /* install the new presentation. */ 2147: TtaSetStylePresentation (PRBackground, element, tsch, context, best); 2148: /* thot specificity : need to set fill pattern for background color */ 2149: best.typed_data.value = STYLE_PATTERN_BACKGROUND; 2150: best.typed_data.unit = STYLE_UNIT_REL; 2151: TtaSetStylePresentation (PRFillPattern, element, tsch, context, best); 2152: best.typed_data.value = 1; 2153: best.typed_data.unit = STYLE_UNIT_REL; 2154: TtaSetStylePresentation (PRShowBox, element, tsch, context, best); 2155: } 2156: } 2157: cssRule = SkipWord (cssRule); 2158: 2159: /* restore the refered element */ 2160: if (moved && !element) 2161: context->type = savedtype; 2162: return (cssRule); 2163: } 2164: 2165: /*---------------------------------------------------------------------- 2166: ParseCSSBackgroundImageCallback : Callback called asynchronously by 2167: FetchImage when a background image has been fetched. 2168: ----------------------------------------------------------------------*/ 2169: #ifdef __STDC__ 2170: void ParseCSSBackgroundImageCallback (Document doc, Element element, STRING file, 2171: void *extra) 2172: #else 2173: void ParseCSSBackgroundImageCallback (doc, element, file, extra) 2174: Document doc; 2175: Element element; 2176: STRING file; 2177: void *extra; 2178: #endif 2179: { 1.34 cvs 2180: DisplayMode dispMode; 2181: BackgroundImageCallbackPtr callblock = (BackgroundImageCallbackPtr) extra; 2182: Element el; 2183: PSchema tsch; 2184: PresentationContext context; 2185: PresentationValue image; 2186: PresentationValue repeat; 2187: PresentationValue value; 1.1 cvs 2188: 1.34 cvs 2189: if (callblock == NULL) 2190: return; 1.1 cvs 2191: 1.34 cvs 2192: /* avoid too many redisplay */ 2193: dispMode = TtaGetDisplayMode (doc); 2194: if (dispMode == DisplayImmediately) 2195: TtaSetDisplayMode (doc, DeferredDisplay); 2196: 2197: el = callblock->el; 2198: tsch = callblock->tsch; 2199: context = &callblock->context.specific; 2200: 2201: /* Ok the image was fetched, finish the background-image handling */ 2202: image.pointer = file; 2203: TtaSetStylePresentation (PRBackgroundPicture, el, tsch, context, image); 1.1 cvs 2204: 1.34 cvs 2205: /* If there is no default repeat mode, enforce a V-Repeat */ 2206: if (TtaGetStylePresentation (PRPictureMode, el, tsch, context, &repeat) < 0) 2207: { 2208: repeat.typed_data.value = STYLE_REPEAT; 2209: repeat.typed_data.unit = STYLE_UNIT_REL; 2210: repeat.typed_data.real = FALSE; 2211: TtaSetStylePresentation (PRPictureMode, el, tsch, context, repeat); 2212: } 2213: 2214: /* If there is no default repeat mode, enforce a V-Repeat */ 2215: value.typed_data.value = 1; 2216: value.typed_data.unit = STYLE_UNIT_REL; 2217: value.typed_data.real = FALSE; 2218: TtaSetStylePresentation (PRShowBox, el, tsch, context, value); 2219: 2220: TtaFreeMemory (callblock); 2221: /* restore the display mode */ 2222: if (dispMode == DisplayImmediately) 2223: TtaSetDisplayMode (doc, dispMode); 1.1 cvs 2224: } 2225: 2226: 2227: /*---------------------------------------------------------------------- 2228: GetCSSBackgroundURL searches a CSS BackgroundImage url within 2229: the styleString. 2230: Returns NULL or a new allocated url string. 2231: ----------------------------------------------------------------------*/ 2232: #ifdef __STDC__ 2233: STRING GetCSSBackgroundURL (STRING styleString) 2234: #else 2235: STRING GetCSSBackgroundURL (styleString) 2236: STRING styleString; 2237: #endif 2238: { 2239: STRING b, e, ptr; 2240: int len; 2241: 2242: ptr = NULL; 1.17 cvs 2243: b = ustrstr (styleString, TEXT("url")); 1.1 cvs 2244: if (b != NULL) 2245: { 2246: b += 3; 1.13 cvs 2247: b = SkipBlanksAndComments (b); 1.1 cvs 2248: if (*b == '(') 2249: { 2250: b++; 1.13 cvs 2251: b = SkipBlanksAndComments (b); 1.1 cvs 2252: /*** Caution: Strings can either be written with double quotes or 2253: with single quotes. Only double quotes are handled here. 2254: Escaped quotes are not handled. See function SkipQuotedString */ 2255: if (*b == '"') 2256: { 2257: b++; 2258: /* search the url end */ 2259: e = b; 2260: while (*e != EOS && *e != '"') 2261: e++; 2262: } 2263: else 2264: { 2265: /* search the url end */ 2266: e = b; 2267: while (*e != EOS && *e != ')') 2268: e++; 2269: } 2270: if (*e != EOS) 2271: { 2272: len = (int)(e - b); 2273: ptr = (STRING) TtaGetMemory (len+1); 2274: ustrncpy (ptr, b, len); 2275: ptr[len] = EOS; 2276: } 2277: } 2278: } 2279: return (ptr); 2280: } 2281: 2282: 2283: /*---------------------------------------------------------------------- 2284: ParseCSSBackgroundImage : parse a CSS BackgroundImage 2285: attribute string. 2286: ----------------------------------------------------------------------*/ 2287: #ifdef __STDC__ 2288: static STRING ParseCSSBackgroundImage (Element element, PSchema tsch, 1.14 cvs 2289: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2290: #else 2291: static STRING ParseCSSBackgroundImage (element, tsch, context, cssRule, css, isHTML) 2292: Element element; 2293: PSchema tsch; 2294: PresentationContext context; 2295: STRING cssRule; 2296: CSSInfoPtr css; 1.14 cvs 2297: ThotBool isHTML; 1.1 cvs 2298: #endif 2299: { 2300: Element el; 2301: GenericContext gblock; 2302: PresentationContextBlock *sblock; 2303: BackgroundImageCallbackPtr callblock; 2304: PresentationValue image, value; 2305: STRING url; 2306: STRING bg_image; 1.25 cvs 2307: CHAR_T saved; 1.1 cvs 2308: STRING base; 1.25 cvs 2309: CHAR_T tempname[MAX_LENGTH]; 2310: CHAR_T imgname[MAX_LENGTH]; 1.1 cvs 2311: unsigned int savedtype = 0; 1.14 cvs 2312: ThotBool moved; 1.1 cvs 2313: 2314: /* default element for FetchImage */ 2315: el = TtaGetMainRoot (context->doc); 2316: /* move the BODY rule to the HTML element */ 2317: moved = (context->type == HTML_EL_BODY && isHTML); 2318: if (moved) 2319: { 2320: if (element) 2321: element = el; 2322: else 2323: { 2324: savedtype = context->type; 2325: context->type = HTML_EL_HTML; 2326: } 2327: } 2328: else if (element) 2329: el = element; 2330: 2331: url = NULL; 1.13 cvs 2332: cssRule = SkipBlanksAndComments (cssRule); 1.17 cvs 2333: if (!ustrncasecmp (cssRule, TEXT("url"), 3)) 1.1 cvs 2334: { 2335: cssRule += 3; 1.13 cvs 2336: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 2337: if (*cssRule == '(') 2338: { 2339: cssRule++; 1.13 cvs 2340: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 2341: /*** Caution: Strings can either be written with double quotes or 2342: with single quotes. Only double quotes are handled here. 2343: Escaped quotes are not handled. See function SkipQuotedString */ 2344: if (*cssRule == '"') 2345: { 2346: cssRule++; 2347: base = cssRule; 2348: while (*cssRule != EOS && *cssRule != '"') 2349: cssRule++; 2350: } 2351: else 2352: { 2353: base = cssRule; 2354: while (*cssRule != EOS && *cssRule != ')') 2355: cssRule++; 2356: } 2357: saved = *cssRule; 2358: *cssRule = EOS; 2359: url = TtaStrdup (base); 2360: *cssRule = saved; 2361: if (saved == '"') 2362: /* we need to skip two characters */ 2363: cssRule++; 2364: } 2365: cssRule++; 2366: 2367: if (context->destroy) 2368: { 2369: /* remove the background image PRule */ 2370: image.pointer = NULL; 2371: TtaSetStylePresentation (PRBackgroundPicture, element, tsch, context, image); 2372: if (TtaGetStylePresentation (PRFillPattern, element, tsch, context, &value) < 0) 2373: { 2374: /* there is no FillPattern rule -> remove ShowBox rule */ 2375: value.typed_data.value = 1; 2376: value.typed_data.unit = STYLE_UNIT_REL; 2377: value.typed_data.real = FALSE; 2378: TtaSetStylePresentation (PRShowBox, element, tsch, context, value); 2379: } 2380: } 2381: else if (url) 2382: { 1.30 cvs 2383: bg_image = TtaGetEnvString ("ENABLE_BG_IMAGES"); 1.17 cvs 2384: if (bg_image == NULL || !ustrcasecmp (bg_image, TEXT("yes"))) 1.1 cvs 2385: { 2386: callblock = (BackgroundImageCallbackPtr) TtaGetMemory(sizeof(BackgroundImageCallbackBlock)); 2387: if (callblock != NULL) 2388: { 2389: callblock->el = element; 2390: callblock->tsch = tsch; 2391: if (element == NULL) 1.18 cvs 2392: { 2393: gblock = (GenericContext) context; 2394: memcpy (&callblock->context.generic, gblock, 2395: sizeof (GenericContextBlock)); 2396: } 2397: else 2398: { 2399: sblock = context; 2400: memcpy (&callblock->context.specific, sblock, 2401: sizeof(PresentationContextBlock)); 2402: } 2403: 2404: /* check if the image url is related to an external CSS */ 2405: if (css != NULL && css->category == CSS_EXTERNAL_STYLE) 2406: { 2407: NormalizeURL (url, 0, tempname, imgname, css->url); 2408: /* fetch and display background image of element */ 1.33 cvs 2409: FetchImage (context->doc, el, tempname, AMAYA_LOAD_IMAGE, 1.18 cvs 2410: ParseCSSBackgroundImageCallback, callblock); 2411: } 2412: else 1.33 cvs 2413: FetchImage (context->doc, el, url, AMAYA_LOAD_IMAGE, 1.18 cvs 2414: ParseCSSBackgroundImageCallback, callblock); 2415: } 2416: } 2417: 2418: if (url) 2419: TtaFreeMemory (url); 2420: } 2421: } 2422: 2423: /* restore the refered element */ 2424: if (moved && !element) 2425: context->type = savedtype; 2426: return (cssRule); 2427: } 2428: 2429: /*---------------------------------------------------------------------- 2430: ParseCSSBackgroundRepeat : parse a CSS BackgroundRepeat 2431: attribute string. 2432: ----------------------------------------------------------------------*/ 2433: #ifdef __STDC__ 2434: static STRING ParseCSSBackgroundRepeat (Element element, PSchema tsch, 2435: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 2436: #else 2437: static STRING ParseCSSBackgroundRepeat (element, tsch, context, cssRule, css, isHTML) 2438: Element element; 2439: PSchema tsch; 2440: PresentationContext context; 2441: STRING cssRule; 2442: CSSInfoPtr css; 2443: ThotBool isHTML; 2444: #endif 2445: { 2446: PresentationValue repeat; 2447: unsigned int savedtype = 0; 2448: ThotBool moved; 2449: 2450: /* move the BODY rule to the HTML element */ 2451: moved = (context->type == HTML_EL_BODY && isHTML); 2452: if (moved) 2453: { 2454: if (element) 2455: element = TtaGetMainRoot (context->doc); 2456: else 2457: { 2458: savedtype = context->type; 2459: context->type = HTML_EL_HTML; 2460: } 2461: } 2462: 2463: repeat.typed_data.value = STYLE_REALSIZE; 2464: repeat.typed_data.unit = STYLE_UNIT_REL; 2465: repeat.typed_data.real = FALSE; 2466: cssRule = SkipBlanksAndComments (cssRule); 2467: if (!ustrncasecmp (cssRule, TEXT("no-repeat"), 9)) 2468: repeat.typed_data.value = STYLE_REALSIZE; 2469: else if (!ustrncasecmp (cssRule, TEXT("repeat-y"), 8)) 2470: repeat.typed_data.value = STYLE_VREPEAT; 2471: else if (!ustrncasecmp (cssRule, TEXT("repeat-x"), 8)) 2472: repeat.typed_data.value = STYLE_HREPEAT; 2473: else if (!ustrncasecmp (cssRule, TEXT("repeat"), 6)) 2474: repeat.typed_data.value = STYLE_REPEAT; 2475: else 2476: return (cssRule); 2477: 2478: /* install the new presentation */ 2479: TtaSetStylePresentation (PRPictureMode, element, tsch, context, repeat); 2480: cssRule = SkipWord (cssRule); 2481: 2482: /* restore the refered element */ 2483: if (moved && !element) 2484: context->type = savedtype; 2485: return (cssRule); 2486: } 2487: 2488: /*---------------------------------------------------------------------- 2489: ParseCSSBackgroundAttachment : parse a CSS BackgroundAttachment 2490: attribute string. 2491: ----------------------------------------------------------------------*/ 2492: #ifdef __STDC__ 2493: static STRING ParseCSSBackgroundAttachment (Element element, PSchema tsch, 2494: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 2495: #else 2496: static STRING ParseCSSBackgroundAttachment (element, tsch, context, cssRule, css, isHTML) 2497: Element element; 2498: PSchema tsch; 2499: PresentationContext context; 2500: STRING cssRule; 2501: CSSInfoPtr css; 2502: ThotBool isHTML; 2503: #endif 2504: { 2505: unsigned int savedtype = 0; 2506: ThotBool moved; 1.1 cvs 2507: 1.18 cvs 2508: /* move the BODY rule to the HTML element */ 2509: moved = (context->type == HTML_EL_BODY && isHTML); 2510: if (moved) 2511: { 2512: if (element) 2513: element = TtaGetMainRoot (context->doc); 2514: else 2515: { 2516: savedtype = context->type; 2517: context->type = HTML_EL_HTML; 1.1 cvs 2518: } 2519: } 2520: 1.18 cvs 2521: cssRule = SkipBlanksAndComments (cssRule); 2522: if (!ustrncasecmp (cssRule, TEXT("scroll"), 6)) 2523: cssRule = SkipWord (cssRule); 2524: else if (!ustrncasecmp (cssRule, TEXT("fixed"), 5)) 2525: cssRule = SkipWord (cssRule); 2526: 1.1 cvs 2527: /* restore the refered element */ 2528: if (moved && !element) 2529: context->type = savedtype; 1.18 cvs 2530: return (cssRule); 1.1 cvs 2531: } 2532: 2533: /*---------------------------------------------------------------------- 1.18 cvs 2534: ParseCSSBackgroundPosition : parse a CSS BackgroundPosition 1.1 cvs 2535: attribute string. 2536: ----------------------------------------------------------------------*/ 2537: #ifdef __STDC__ 1.18 cvs 2538: static STRING ParseCSSBackgroundPosition (Element element, PSchema tsch, 1.14 cvs 2539: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 1.1 cvs 2540: #else 1.18 cvs 2541: static STRING ParseCSSBackgroundPosition (element, tsch, context, cssRule, css, isHTML) 1.1 cvs 2542: Element element; 2543: PSchema tsch; 2544: PresentationContext context; 2545: STRING cssRule; 2546: CSSInfoPtr css; 1.14 cvs 2547: ThotBool isHTML; 1.1 cvs 2548: #endif 2549: { 1.18 cvs 2550: PresentationValue repeat; 2551: unsigned int savedtype = 0; 2552: ThotBool moved; 2553: ThotBool ok; 1.1 cvs 2554: 2555: /* move the BODY rule to the HTML element */ 2556: moved = (context->type == HTML_EL_BODY && isHTML); 2557: if (moved) 2558: { 2559: if (element) 2560: element = TtaGetMainRoot (context->doc); 2561: else 2562: { 2563: savedtype = context->type; 2564: context->type = HTML_EL_HTML; 2565: } 2566: } 2567: 1.18 cvs 2568: cssRule = SkipBlanksAndComments (cssRule); 2569: ok = TRUE; 2570: if (!ustrncasecmp (cssRule, TEXT("left"), 4)) 2571: cssRule = SkipWord (cssRule); 2572: else if (!ustrncasecmp (cssRule, TEXT("right"), 5)) 2573: cssRule = SkipWord (cssRule); 2574: else if (!ustrncasecmp (cssRule, TEXT("center"), 6)) 2575: cssRule = SkipWord (cssRule); 2576: else if (!ustrncasecmp (cssRule, TEXT("top"), 3)) 2577: cssRule = SkipWord (cssRule); 2578: else if (!ustrncasecmp (cssRule, TEXT("bottom"), 6)) 2579: cssRule = SkipWord (cssRule); 2580: else if (isdigit (*cssRule)) 2581: cssRule = SkipWord (cssRule); 2582: else 2583: ok = FALSE; 2584: 2585: if (ok) 2586: { 2587: /* force realsize for the background image */ 2588: repeat.typed_data.value = STYLE_REALSIZE; 2589: repeat.typed_data.unit = STYLE_UNIT_REL; 2590: repeat.typed_data.real = FALSE; 2591: TtaSetStylePresentation (PRPictureMode, element, tsch, context, repeat); 2592: } 2593: 2594: /* restore the refered element */ 2595: if (moved && !element) 2596: context->type = savedtype; 2597: return (cssRule); 2598: } 2599: 2600: /*---------------------------------------------------------------------- 2601: ParseCSSBackground : parse a CSS background attribute 2602: ----------------------------------------------------------------------*/ 2603: #ifdef __STDC__ 2604: static STRING ParseCSSBackground (Element element, PSchema tsch, 2605: PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 2606: #else 2607: static STRING ParseCSSBackground (element, tsch, context, cssRule, css, isHTML) 2608: Element element; 2609: PSchema tsch; 2610: PresentationContext context; 2611: STRING cssRule; 2612: CSSInfoPtr css; 2613: ThotBool isHTML; 2614: #endif 2615: { 2616: STRING ptr; 2617: 1.13 cvs 2618: cssRule = SkipBlanksAndComments (cssRule); 1.18 cvs 2619: while (*cssRule != ';' && *cssRule != EOS && *cssRule != ',') 2620: { 2621: /* perhaps a Backgroud Image */ 2622: if (!ustrncasecmp (cssRule, TEXT("url"), 3)) 2623: cssRule = ParseCSSBackgroundImage (element, tsch, context, cssRule, css, isHTML); 2624: /* perhaps a Background Attachment */ 2625: else if (!ustrncasecmp (cssRule, TEXT("scroll"), 6) || 2626: !ustrncasecmp (cssRule, TEXT("fixed"), 5)) 2627: cssRule = ParseCSSBackgroundAttachment (element, tsch, context, cssRule, css, isHTML); 2628: /* perhaps a Background Repeat */ 2629: else if (!ustrncasecmp (cssRule, TEXT("no-repeat"), 9) || 2630: !ustrncasecmp (cssRule, TEXT("repeat-y"), 8) || 2631: !ustrncasecmp (cssRule, TEXT("repeat-x"), 8) || 2632: !ustrncasecmp (cssRule, TEXT("repeat"), 6)) 2633: cssRule = ParseCSSBackgroundRepeat (element, tsch, context, cssRule, css, isHTML); 2634: /* perhaps a Background Position */ 2635: else if (!ustrncasecmp (cssRule, TEXT("left"), 4) || 2636: !ustrncasecmp (cssRule, TEXT("right"), 5) || 2637: !ustrncasecmp (cssRule, TEXT("center"), 6) || 2638: !ustrncasecmp (cssRule, TEXT("top"), 3) || 2639: !ustrncasecmp (cssRule, TEXT("bottom"), 6) || 2640: isdigit (*cssRule)) 2641: cssRule = ParseCSSBackgroundPosition (element, tsch, context, cssRule, css, isHTML); 2642: /* perhaps a Background Color */ 2643: else 2644: { 2645: /* check if the rule has been found */ 2646: ptr = cssRule; 2647: cssRule = ParseCSSBackgroundColor (element, tsch, context, cssRule, css, isHTML); 2648: if (ptr== cssRule) 2649: /* rule not found */ 2650: cssRule = SkipProperty (cssRule); 2651: } 2652: cssRule = SkipBlanksAndComments (cssRule); 2653: } 2654: return (cssRule); 2655: } 2656: 2657: 2658: 2659: /************************************************************************ 2660: * * 2661: * FUNCTIONS STYLE DECLARATIONS * 2662: * * 2663: ************************************************************************/ 2664: /* 2665: * NOTE : Long attribute name MUST be placed before shortened ones ! 2666: * e.g. "FONT-SIZE" must be placed before "FONT" 2667: */ 2668: static CSSProperty CSSProperties[] = 2669: { 2670: {TEXT ("font-family"), ParseCSSFontFamily}, 2671: {TEXT ("font-style"), ParseCSSFontStyle}, 2672: {TEXT ("font-variant"), ParseCSSFontVariant}, 2673: {TEXT ("font-weight"), ParseCSSFontWeight}, 2674: {TEXT ("font-size"), ParseCSSFontSize}, 2675: {TEXT ("font"), ParseCSSFont}, 2676: 2677: {TEXT ("color"), ParseCSSForeground}, 2678: {TEXT ("background-color"), ParseCSSBackgroundColor}, 2679: {TEXT ("background-image"), ParseCSSBackgroundImage}, 2680: {TEXT ("background-repeat"), ParseCSSBackgroundRepeat}, 2681: {TEXT ("background-attachment"), ParseCSSBackgroundAttachment}, 2682: {TEXT ("background-position"), ParseCSSBackgroundPosition}, 2683: {TEXT ("background"), ParseCSSBackground}, 2684: 2685: {TEXT ("word-spacing"), ParseCSSWordSpacing}, 2686: {TEXT ("letter-spacing"), ParseCSSLetterSpacing}, 2687: {TEXT ("text-decoration"), ParseCSSTextDecoration}, 2688: {TEXT ("vertical-align"), ParseCSSVerticalAlign}, 2689: {TEXT ("text-transform"), ParseCSSTextTransform}, 2690: {TEXT ("text-align"), ParseCSSTextAlign}, 2691: {TEXT ("text-indent"), ParseCSSTextIndent}, 2692: {TEXT ("line-height"), ParseCSSLineSpacing}, 2693: 2694: {TEXT ("margin-top"), ParseCSSMarginTop}, 2695: {TEXT ("margin-right"), ParseCSSMarginRight}, 2696: {TEXT ("margin-bottom"), ParseCSSMarginBottom}, 2697: {TEXT ("margin-left"), ParseCSSMarginLeft}, 2698: {TEXT ("margin"), ParseCSSMargin}, 2699: 2700: {TEXT ("padding-top"), ParseCSSPaddingTop}, 2701: {TEXT ("padding-right"), ParseCSSPaddingRight}, 2702: {TEXT ("padding-bottom"), ParseCSSPaddingBottom}, 2703: {TEXT ("padding-left"), ParseCSSPaddingLeft}, 2704: {TEXT ("padding"), ParseCSSPadding}, 2705: 2706: {TEXT ("border-top-width"), ParseCSSBorderTopWidth}, 2707: {TEXT ("border-right-width"), ParseCSSBorderRightWidth}, 2708: {TEXT ("border-bottom-width"), ParseCSSBorderBottomWidth}, 2709: {TEXT ("border-left-width"), ParseCSSBorderLeftWidth}, 2710: {TEXT ("border-width"), ParseCSSBorderWidth}, 2711: {TEXT ("border-color"), ParseCSSBorderColor}, 2712: {TEXT ("border-style"), ParseCSSBorderStyle}, 2713: {TEXT ("border-top"), ParseCSSBorderTop}, 2714: {TEXT ("border-right"), ParseCSSBorderRight}, 2715: {TEXT ("border-bottom"), ParseCSSBorderBottom}, 2716: {TEXT ("border-left"), ParseCSSBorderLeft}, 2717: {TEXT ("border"), ParseCSSBorder}, 2718: 2719: {TEXT ("width"), ParseCSSWidth}, 2720: {TEXT ("height"), ParseCSSHeight}, 2721: {TEXT ("float"), ParseCSSFloat}, 2722: {TEXT ("clear"), ParseCSSClear}, 2723: 2724: {TEXT ("display"), ParseCSSDisplay}, 2725: {TEXT ("white-space"), ParseCSSWhiteSpace}, 2726: 2727: {TEXT ("list-style-type"), ParseCSSListStyleType}, 2728: {TEXT ("list-style-image"), ParseCSSListStyleImage}, 2729: {TEXT ("list-style-position"), ParseCSSListStylePosition}, 2730: {TEXT ("list-style"), ParseCSSListStyle} 2731: }; 2732: #define NB_CSSSTYLEATTRIBUTE (sizeof(CSSProperties) / sizeof(CSSProperty)) 2733: 2734: /*---------------------------------------------------------------------- 2735: ParseCSSRule : parse a CSS Style string 2736: we expect the input string describing the style to be of the 2737: form : PRORPERTY : DESCRIPTION [ ; PROPERTY : DESCRIPTION ] * 2738: but tolerate incorrect or incomplete input 2739: ----------------------------------------------------------------------*/ 2740: #ifdef __STDC__ 2741: static void ParseCSSRule (Element element, PSchema tsch, PresentationContext context, STRING cssRule, CSSInfoPtr css, ThotBool isHTML) 2742: #else 2743: static void ParseCSSRule (element, tsch, context, cssRule, css, isHTML) 2744: Element element; 2745: PSchema tsch; 2746: PresentationContext context; 2747: STRING cssRule; 2748: CSSInfoPtr css; 2749: ThotBool isHTML; 2750: #endif 2751: { 1.34 cvs 2752: DisplayMode dispMode; 1.18 cvs 2753: STRING p = NULL; 2754: int lg; 1.34 cvs 2755: unsigned int i; 1.18 cvs 2756: ThotBool found; 2757: 1.34 cvs 2758: /* avoid too many redisplay */ 2759: dispMode = TtaGetDisplayMode (context->doc); 2760: if (dispMode == DisplayImmediately) 2761: TtaSetDisplayMode (context->doc, DeferredDisplay); 2762: 1.18 cvs 2763: while (*cssRule != EOS) 2764: { 2765: cssRule = SkipBlanksAndComments (cssRule); 2766: 2767: found = FALSE; 2768: /* look for the type of property */ 2769: for (i = 0; i < NB_CSSSTYLEATTRIBUTE && !found; i++) 2770: { 2771: lg = ustrlen (CSSProperties[i].name); 2772: if (!ustrncasecmp (cssRule, CSSProperties[i].name, lg)) 2773: { 2774: cssRule += lg; 2775: found = TRUE; 2776: i--; 2777: } 2778: } 2779: 2780: if (i == NB_CSSSTYLEATTRIBUTE) 2781: cssRule = SkipProperty (cssRule); 2782: else 2783: { 2784: /* update index and skip the ":" indicator if present */ 2785: cssRule = SkipBlanksAndComments (cssRule); 2786: if (*cssRule == ':') 2787: { 2788: cssRule++; 2789: cssRule = SkipBlanksAndComments (cssRule); 2790: } 2791: /* try to parse the attribute associated to this attribute */ 2792: if (CSSProperties[i].parsing_function != NULL) 2793: { 1.34 cvs 2794: p = CSSProperties[i].parsing_function (element, tsch, context, cssRule, css, isHTML); 2795: /* update index and skip the ";" separator if present */ 2796: cssRule = p; 1.18 cvs 2797: } 2798: } 2799: /* next property */ 2800: cssRule = SkipBlanksAndComments (cssRule); 2801: if (*cssRule == ',' || *cssRule == ';') 2802: { 2803: cssRule++; 2804: cssRule = SkipBlanksAndComments (cssRule); 2805: } 2806: } 1.34 cvs 2807: 2808: /* restore the display mode */ 2809: if (dispMode == DisplayImmediately) 2810: TtaSetDisplayMode (context->doc, dispMode); 1.18 cvs 2811: } 1.1 cvs 2812: 2813: 2814: /*---------------------------------------------------------------------- 1.18 cvs 2815: PToCss : translate a PresentationSetting to the 2816: equivalent CSS string, and add it to the buffer given as the 2817: argument. It is used when extracting the CSS string from actual 2818: presentation. 2819: 2820: All the possible values returned by the presentation drivers are 2821: described in thotlib/include/presentation.h 2822: -----------------------------------------------------------------------*/ 1.1 cvs 2823: #ifdef __STDC__ 1.18 cvs 2824: void PToCss (PresentationSetting settings, STRING buffer, int len) 1.1 cvs 2825: #else 1.18 cvs 2826: void PToCss (settings, buffer, len) 2827: PresentationSetting settings; 2828: STRING param; 2829: int len 1.1 cvs 2830: #endif 2831: { 1.18 cvs 2832: float fval = 0; 2833: unsigned short red, green, blue; 2834: int add_unit = 0; 2835: unsigned int unit, i; 2836: ThotBool real = FALSE; 2837: 2838: buffer[0] = EOS; 2839: if (len < 40) 2840: return; 2841: 2842: unit = settings->value.typed_data.unit; 2843: if (settings->value.typed_data.real) 2844: { 2845: real = TRUE; 2846: fval = (float) settings->value.typed_data.value; 2847: fval /= 1000; 2848: } 1.1 cvs 2849: 1.18 cvs 2850: switch (settings->type) 1.1 cvs 2851: { 1.18 cvs 2852: case PRVisibility: 2853: break; 2854: case PRFont: 2855: switch (settings->value.typed_data.value) 2856: { 2857: case STYLE_FONT_HELVETICA: 2858: ustrcpy (buffer, TEXT("font-family: helvetica")); 2859: break; 2860: case STYLE_FONT_TIMES: 2861: ustrcpy (buffer, TEXT("font-family: times")); 2862: break; 2863: case STYLE_FONT_COURIER: 2864: ustrcpy (buffer, TEXT("font-family: courier")); 2865: break; 2866: } 2867: break; 2868: case PRStyle: 2869: switch (settings->value.typed_data.value) 2870: { 2871: case STYLE_FONT_ROMAN: 2872: ustrcpy (buffer, TEXT("font-style: normal")); 2873: break; 2874: case STYLE_FONT_ITALICS: 2875: ustrcpy (buffer, TEXT("font-style: italic")); 2876: break; 2877: case STYLE_FONT_OBLIQUE: 2878: ustrcpy (buffer, TEXT("font-style: oblique")); 2879: break; 1.20 cvs 2880: } 2881: break; 2882: case PRWeight: 2883: switch (settings->value.typed_data.value) 2884: { 2885: case STYLE_WEIGHT_BOLD: 2886: ustrcpy (buffer, TEXT("font-weight: bold")); 2887: break; 2888: case STYLE_WEIGHT_NORMAL: 2889: ustrcpy (buffer, TEXT("font-weight: normal")); 1.18 cvs 2890: break; 2891: } 2892: break; 2893: case PRSize: 2894: if (unit == STYLE_UNIT_REL) 2895: { 2896: if (real) 2897: { 2898: usprintf (buffer, TEXT("font-size: %g"), fval); 2899: add_unit = 1; 2900: } 2901: else 2902: switch (settings->value.typed_data.value) 2903: { 2904: case 1: 2905: ustrcpy (buffer, TEXT("font-size: xx-small")); 2906: break; 2907: case 2: 2908: ustrcpy (buffer, TEXT("font-size: x-small")); 2909: break; 2910: case 3: 2911: ustrcpy (buffer, TEXT("font-size: small")); 2912: break; 2913: case 4: 2914: ustrcpy (buffer, TEXT("font-size: medium")); 2915: break; 2916: case 5: 2917: ustrcpy (buffer, TEXT("font-size: large")); 2918: break; 2919: case 6: 2920: ustrcpy (buffer, TEXT("font-size: x-large")); 2921: break; 2922: case 7: 2923: case 8: 2924: case 9: 2925: case 10: 2926: case 11: 2927: case 12: 2928: ustrcpy (buffer, TEXT("font-size: xx-large")); 2929: break; 2930: } 2931: } 2932: else 2933: { 2934: if (real) 2935: usprintf (buffer, TEXT("font-size: %g"), fval); 2936: else 2937: usprintf (buffer, TEXT("font-size: %d"), settings->value.typed_data.value); 2938: add_unit = 1; 2939: } 2940: break; 2941: case PRUnderline: 2942: switch (settings->value.typed_data.value) 2943: { 2944: case STYLE_UNDERLINE: 2945: ustrcpy (buffer, TEXT("text-decoration: underline")); 2946: break; 2947: case STYLE_OVERLINE: 2948: ustrcpy (buffer, TEXT("text-decoration: overline")); 2949: break; 2950: case STYLE_CROSSOUT: 2951: ustrcpy (buffer, TEXT("text-decoration: line-through")); 2952: break; 2953: } 2954: break; 2955: case PRIndent: 2956: if (real) 2957: usprintf (buffer, TEXT("text-indent: %g"), fval); 2958: else 2959: usprintf (buffer, TEXT("text-indent: %d"), settings->value.typed_data.value); 2960: add_unit = 1; 2961: break; 2962: case PRLineSpacing: 2963: if (real) 2964: usprintf (buffer, TEXT("line-height: %g"), fval); 1.1 cvs 2965: else 1.18 cvs 2966: usprintf (buffer, TEXT("line-height: %d"), settings->value.typed_data.value); 2967: add_unit = 1; 2968: break; 2969: case PRJustify: 2970: if (settings->value.typed_data.value == STYLE_JUSTIFIED) 2971: usprintf (buffer, TEXT("text-align: justify")); 2972: break; 2973: case PRAdjust: 2974: switch (settings->value.typed_data.value) 1.1 cvs 2975: { 1.18 cvs 2976: case STYLE_ADJUSTLEFT: 2977: ustrcpy (buffer, TEXT("text-align: left")); 2978: break; 2979: case STYLE_ADJUSTRIGHT: 2980: ustrcpy (buffer, TEXT("text-align: right")); 2981: break; 2982: case STYLE_ADJUSTCENTERED: 2983: ustrcpy (buffer, TEXT("text-align: center")); 2984: break; 2985: case STYLE_ADJUSTLEFTWITHDOTS: 2986: ustrcpy (buffer, TEXT("text-align: left")); 2987: break; 1.1 cvs 2988: } 1.18 cvs 2989: break; 2990: case PRHyphenate: 2991: break; 2992: case PRFillPattern: 2993: break; 2994: case PRBackground: 2995: TtaGiveThotRGB (settings->value.typed_data.value, &red, &green, &blue); 2996: usprintf (buffer, TEXT("background-color: #%02X%02X%02X"), red, green, blue); 2997: break; 2998: case PRForeground: 2999: TtaGiveThotRGB (settings->value.typed_data.value, &red, &green, &blue); 3000: usprintf (buffer, TEXT("color: #%02X%02X%02X"), red, green, blue); 3001: break; 3002: case PRTMargin: 3003: if (real) 3004: usprintf (buffer, TEXT("marging-top: %g"), fval); 3005: else 3006: usprintf (buffer, TEXT("marging-top: %d"), settings->value.typed_data.value); 3007: add_unit = 1; 3008: break; 3009: case PRLMargin: 3010: if (real) 3011: usprintf (buffer, TEXT("margin-left: %g"), fval); 3012: else 3013: usprintf (buffer, TEXT("margin-left: %d"), settings->value.typed_data.value); 3014: add_unit = 1; 3015: break; 3016: case PRHeight: 3017: if (real) 3018: usprintf (buffer, TEXT("height: %g"), fval); 3019: else 3020: usprintf (buffer, TEXT("height: %d"), settings->value.typed_data.value); 3021: add_unit = 1; 3022: break; 3023: case PRWidth: 3024: if (real) 3025: usprintf (buffer, TEXT("width: %g"), fval); 1.1 cvs 3026: else 1.18 cvs 3027: usprintf (buffer, TEXT("width: %d"), settings->value.typed_data.value); 3028: add_unit = 1; 3029: break; 3030: case PRLine: 3031: if (settings->value.typed_data.value == STYLE_INLINE) 3032: ustrcpy (buffer, TEXT("display: inline")); 3033: else if (settings->value.typed_data.value == STYLE_NOTINLINE) 3034: ustrcpy (buffer, TEXT("display: block")); 3035: break; 3036: case PRBackgroundPicture: 3037: if (settings->value.pointer != NULL) 1.19 cvs 3038: usprintf (buffer, TEXT("background-image: url(%s)"), (STRING)(settings->value.pointer)); 1.1 cvs 3039: else 1.18 cvs 3040: usprintf (buffer, TEXT("background-image: none")); 3041: break; 3042: case PRPictureMode: 3043: switch (settings->value.typed_data.value) 1.1 cvs 3044: { 1.18 cvs 3045: case STYLE_REALSIZE: 3046: usprintf (buffer, TEXT("background-repeat: no-repeat")); 3047: break; 3048: case STYLE_REPEAT: 3049: usprintf (buffer, TEXT("background-repeat: repeat")); 3050: break; 3051: case STYLE_VREPEAT: 3052: usprintf (buffer, TEXT("background-repeat: repeat-y")); 3053: break; 3054: case STYLE_HREPEAT: 3055: usprintf (buffer, TEXT("background-repeat: repeat-x")); 3056: break; 1.1 cvs 3057: } 1.18 cvs 3058: break; 3059: default: 3060: break; 1.1 cvs 3061: } 3062: 1.18 cvs 3063: if (add_unit) 1.1 cvs 3064: { 1.18 cvs 3065: /* add the unit string to the CSS string */ 3066: for (i = 0; i < NB_UNITS; i++) 1.1 cvs 3067: { 1.18 cvs 3068: if (CSSUnitNames[i].unit == unit) 1.1 cvs 3069: { 1.18 cvs 3070: ustrcat (buffer, CSSUnitNames[i].sign); 3071: break; 1.1 cvs 3072: } 3073: } 3074: } 3075: } 3076: 3077: /*---------------------------------------------------------------------- 1.18 cvs 3078: ParseHTMLSpecificStyle : parse and apply a CSS Style string. 3079: This function must be called when a specific style is applied to an 3080: element. 1.1 cvs 3081: ----------------------------------------------------------------------*/ 3082: #ifdef __STDC__ 1.14 cvs 3083: void ParseHTMLSpecificStyle (Element el, STRING cssRule, Document doc, ThotBool destroy) 1.1 cvs 3084: #else 3085: void ParseHTMLSpecificStyle (el, cssRule, doc, destroy) 3086: Element elem; 3087: STRING cssRule; 3088: Document doc; 1.14 cvs 3089: ThotBool destroy; 1.1 cvs 3090: #endif 3091: { 3092: PresentationContext context; 3093: ElementType elType; 1.14 cvs 3094: ThotBool isHTML; 1.1 cvs 3095: 3096: /* A rule applying to BODY is really meant to address HTML */ 3097: elType = TtaGetElementType (el); 1.17 cvs 3098: isHTML = (ustrcmp(TtaGetSSchemaName (elType.ElSSchema), TEXT("HTML")) == 0); 1.1 cvs 3099: /* create the context of the Specific presentation driver */ 3100: context = TtaGetSpecificStyleContext (doc); 3101: if (context == NULL) 3102: return; 3103: context->type = elType.ElTypeNum; 3104: context->destroy = destroy; 3105: /* Call the parser */ 3106: ParseCSSRule (el, NULL, (PresentationContext) context, cssRule, NULL, isHTML); 3107: /* free the context */ 3108: TtaFreeMemory(context); 3109: } 3110: 3111: /*---------------------------------------------------------------------- 1.25 cvs 3112: ParseGenericSelector : Create a generic context for a given 1.1 cvs 3113: selector string. If the selector is made of multiple comma- 3114: separated selector items, it parses them one at a time and 3115: return the end of the selector string to be handled or NULL 3116: ----------------------------------------------------------------------*/ 3117: #ifdef __STDC__ 1.25 cvs 3118: static STRING ParseGenericSelector (STRING selector, STRING cssRule, 1.1 cvs 3119: GenericContext ctxt, Document doc, CSSInfoPtr css) 3120: #else 1.25 cvs 3121: static STRING ParseGenericSelector (selector, cssRule, ctxt, doc, css) 1.1 cvs 3122: STRING selector; 3123: STRING cssRule; 3124: GenericContext ctxt; 3125: Document doc; 3126: CSSInfoPtr css; 3127: #endif 3128: { 3129: ElementType elType; 3130: PSchema tsch; 1.25 cvs 3131: AttributeType attrType; 3132: CHAR_T sel[MAX_ANCESTORS * 50]; 3133: STRING deb, cur; 3134: STRING structName; 3135: STRING names[MAX_ANCESTORS]; 3136: STRING ids[MAX_ANCESTORS]; 3137: STRING classes[MAX_ANCESTORS]; 3138: STRING pseudoclasses[MAX_ANCESTORS]; 3139: STRING attrs[MAX_ANCESTORS]; 3140: STRING attrvals[MAX_ANCESTORS]; 1.35 cvs 3141: int i, j, k, max, maxAttr; 1.25 cvs 3142: ThotBool isHTML; 1.1 cvs 3143: 3144: sel[0] = EOS; 3145: for (i = 0; i < MAX_ANCESTORS; i++) 3146: { 1.25 cvs 3147: names[i] = NULL; 3148: ids[i] = NULL; 3149: classes[i] = NULL; 3150: pseudoclasses[i] = NULL; 3151: attrs[i] = NULL; 3152: attrvals[i] = NULL; 3153: 3154: ctxt->name[i] = 0; 3155: ctxt->names_nb[i] = 0; 3156: ctxt->attrType[i] = 0; 3157: ctxt->attrText[i] = NULL; 1.1 cvs 3158: } 1.25 cvs 3159: ctxt->box = 0; 3160: ctxt->type = 0; 3161: 1.13 cvs 3162: selector = SkipBlanksAndComments (selector); 1.27 cvs 3163: cur = &sel[0]; 1.25 cvs 3164: max = 0; /* number of loops */ 1.1 cvs 3165: while (1) 3166: { 1.27 cvs 3167: deb = cur; 1.25 cvs 3168: /* copy an item of the selector into sel[] */ 1.1 cvs 3169: /* put one word in the sel buffer */ 3170: while (*selector != EOS && *selector != ',' && 3171: *selector != '.' && *selector != ':' && 3172: *selector != '#' && !TtaIsBlank (selector)) 3173: *cur++ = *selector++; 1.25 cvs 3174: *cur++ = EOS; /* close the first string in sel[] */ 3175: if (deb[0] != EOS) 1.27 cvs 3176: names[0] = deb; 1.25 cvs 3177: else 1.27 cvs 3178: names[0] = NULL; 3179: classes[0] = NULL; 3180: pseudoclasses[0] = NULL; 3181: ids[0] = NULL; 3182: attrs[0] = NULL; 3183: attrvals[0] = NULL; 1.25 cvs 3184: 1.27 cvs 3185: /* now names[0] points to the beginning of the parsed item 1.25 cvs 3186: and cur to the next chain to be parsed */ 1.1 cvs 3187: if (*selector == ':' || *selector == '.' || *selector == '#') 1.25 cvs 3188: /* keep the element name which precedes the id or 3189: pseudo class or the class */ 1.27 cvs 3190: deb = cur; 1.1 cvs 3191: 3192: if (*selector == '.') 3193: { 1.25 cvs 3194: /* copy into sel[] the class */ 1.27 cvs 3195: classes[0] = cur; 1.1 cvs 3196: selector++; 3197: while (*selector != EOS && *selector != ',' && 3198: *selector != '.' && *selector != ':' && 3199: !TtaIsBlank (selector)) 3200: *cur++ = *selector++; 3201: *cur++ = EOS; 3202: } 3203: else if (*selector == ':') 3204: { 1.25 cvs 3205: /* copy into sel[] the pseudoclass */ 1.27 cvs 3206: pseudoclasses[0]= cur; 1.1 cvs 3207: selector++; 3208: while (*selector != EOS && *selector != ',' && 3209: *selector != '.' && *selector != ':' && 3210: !TtaIsBlank (selector)) 3211: *cur++ = *selector++; 3212: *cur++ = EOS; 3213: } 3214: else if (*selector == '#') 3215: { 1.25 cvs 3216: /* copy into sel[] the attribute */ 1.27 cvs 3217: ids[0] = cur; 1.1 cvs 3218: selector++; 3219: while (*selector != EOS && *selector != ',' && 3220: *selector != '.' && *selector != ':' && 3221: !TtaIsBlank (selector)) 3222: *cur++ = *selector++; 3223: *cur++ = EOS; 3224: } 1.25 cvs 3225: else if (*selector == '[') 1.1 cvs 3226: { 1.25 cvs 3227: /* copy into sel[] the attribute */ 1.27 cvs 3228: attrs[0] = cur; 1.25 cvs 3229: selector++; 3230: while (*selector != EOS && *selector != ']' && *selector != '=') 3231: *cur++ = *selector++; 3232: if (*cur == '=') 3233: { 3234: /* there is a value "xxxx" */ 3235: *cur++ = EOS; 3236: while (*selector != EOS && *selector != ']' && *selector != '"') 3237: selector++; 3238: if (*selector != EOS) 3239: { 3240: /* we are now parsing the attribute value */ 1.27 cvs 3241: attrvals[0] = cur; 1.25 cvs 3242: selector++; 3243: while (*selector != EOS && *selector != '"') 3244: *cur++ = *selector++; 3245: if (*selector != EOS) 3246: selector++; 3247: } 3248: } 3249: *cur++ = EOS; 1.1 cvs 3250: } 3251: 1.27 cvs 3252: selector = SkipBlanksAndComments (selector); 1.1 cvs 3253: 1.25 cvs 3254: /* is it a multi-level selector? */ 1.1 cvs 3255: if (*selector == EOS) 3256: /* end of the selector */ 3257: break; 3258: else if (*selector == ',') 3259: { 3260: /* end of the current selector */ 3261: selector++; 3262: break; 3263: } 1.25 cvs 3264: else 3265: { 3266: /* shifts the list to make room for the new name */ 3267: max++; /* a new level in ancestor tables */ 3268: if (max == MAX_ANCESTORS) 3269: /* abort the CSS parsing */ 3270: return (selector); 3271: for (i = max; i > 0; i--) 3272: { 3273: names[i] = names[i - 1]; 3274: ids[i] = ids[i - 1]; 3275: classes[i] = classes[i - 1]; 3276: attrs[i] = attrs[i - 1]; 3277: attrvals[i] = attrvals[i - 1]; 3278: pseudoclasses[i] = pseudoclasses[i - 1]; 3279: } 3280: } 1.1 cvs 3281: } 3282: 3283: /* Now set up the context block */ 1.25 cvs 3284: i = 0; 3285: k = 0; 3286: j = 0; 1.35 cvs 3287: maxAttr = 0; 1.25 cvs 3288: while (i <= max) 3289: { 3290: if (names[i]) 3291: { 3292: /* get the new element type of this name */ 3293: GIType (names[i], &elType, doc); 3294: if (i == 0) 3295: { 3296: /* Store the element type */ 3297: ctxt->type = elType.ElTypeNum; 1.32 cvs 3298: ctxt->name[0] = elType.ElTypeNum; 3299: ctxt->names_nb[0] = 0; 1.25 cvs 3300: ctxt->schema = elType.ElSSchema; 1.27 cvs 3301: k++; 1.25 cvs 3302: } 3303: else if (elType.ElTypeNum != 0) 3304: { 3305: /* look at the current context to see if the type is already 3306: stored */ 3307: j = 0; 1.32 cvs 3308: while (j < k && ctxt->name[j] != elType.ElTypeNum) 1.25 cvs 3309: j++; 3310: if (j == k) 3311: { 3312: /* add a new entry */ 3313: k++; 3314: ctxt->name[j] = elType.ElTypeNum; 3315: if (j != 0) 3316: ctxt->names_nb[j] = 1; 3317: } 3318: else 3319: /* increment the number of ancestor levels */ 3320: ctxt->names_nb[j]++; 3321: } 3322: else 3323: { 3324: /* add a new entry */ 3325: j = k; 3326: k++; 3327: } 3328: } 1.1 cvs 3329: else 1.25 cvs 3330: { 3331: /* add a new entry */ 3332: j = k; 3333: k++; 3334: } 3335: 1.35 cvs 3336: if (classes[i] || pseudoclasses[i] || ids[i] || attrs[i]) 3337: if (maxAttr > 0) 3338: /* Thot is not able to manage this kind of selector -> abort */ 3339: return (selector); 3340: else 3341: maxAttr++; 1.1 cvs 3342: 1.25 cvs 3343: /* store attributes information */ 3344: if (classes[i]) 3345: { 3346: ctxt->attrText[j] = classes[i]; 3347: ctxt->attrType[j] = HTML_ATTR_Class; 3348: } 3349: else if (pseudoclasses[i]) 3350: { 3351: ctxt->attrText[j] = pseudoclasses[i]; 3352: ctxt->attrType[j] = HTML_ATTR_PseudoClass; 3353: } 3354: else if (ids[i]) 3355: { 3356: ctxt->attrText[j] = ids[i]; 3357: ctxt->attrType[j] = HTML_ATTR_ID; 3358: } 3359: else if (attrs[i]) 3360: { 3361: MapHTMLAttribute (attrs[i], &attrType, names[i], doc); 3362: ctxt->attrText[j] = attrvals[i]; 3363: ctxt->attrType[j] = attrType.AttrTypeNum; 3364: } 3365: i++; 1.1 cvs 3366: } 3367: 1.25 cvs 3368: /* sort the list of ancestors by name order */ 3369: max = k; 3370: i = 1; 3371: while (i < max) 1.28 cvs 3372: { 3373: for (k = i + 1; k < max; k++) 3374: if (ctxt->name[i] > ctxt->name[k]) 3375: { 3376: j = ctxt->name[i]; 3377: ctxt->name[i] = ctxt->name[k]; 3378: ctxt->name[k] = j; 3379: j = ctxt->names_nb[i]; 3380: ctxt->names_nb[i] = ctxt->names_nb[k]; 3381: ctxt->names_nb[k] = j; 3382: j = ctxt->attrType[i]; 3383: ctxt->attrType[i] = ctxt->attrType[k]; 3384: ctxt->attrType[k] = j; 3385: cur = ctxt->attrText[i]; 3386: ctxt->attrText[i] = ctxt->attrText[k]; 3387: ctxt->attrText[k] = cur; 3388: } 3389: i++; 3390: } 1.25 cvs 3391: 3392: /* Get the schema name of the main element */ 3393: if (ctxt->schema == NULL) 1.1 cvs 3394: ctxt->schema = TtaGetDocumentSSchema (doc); 1.17 cvs 3395: isHTML = (ustrcmp(TtaGetSSchemaName (ctxt->schema), TEXT("HTML")) == 0); 1.1 cvs 3396: tsch = GetPExtension (doc, ctxt->schema, css); 3397: structName = TtaGetSSchemaName (ctxt->schema); 3398: if (cssRule) 3399: ParseCSSRule (NULL, tsch, (PresentationContext) ctxt, cssRule, css, isHTML); 3400: return (selector); 3401: } 3402: 3403: /*---------------------------------------------------------------------- 3404: ParseStyleDeclaration : parse one HTML style declaration 3405: stored in the header of a HTML document 3406: We expect the style string to be of the form : 3407: [ 3408: e.g: pinky, awful { color: pink, font-family: helvetica } 3409: ----------------------------------------------------------------------*/ 3410: #ifdef __STDC__ 1.14 cvs 3411: static void ParseStyleDeclaration (Element el, STRING cssRule, Document doc, CSSInfoPtr css, ThotBool destroy) 1.1 cvs 3412: #else 3413: static void ParseStyleDeclaration (el, cssRule, doc, css, destroy) 3414: Element el; 3415: STRING cssRule; 3416: Document doc; 3417: CSSInfoPtr css; 1.14 cvs 3418: ThotBool destroy; 1.1 cvs 3419: #endif 3420: { 3421: GenericContext ctxt; 3422: STRING decl_end; 3423: STRING sel_end; 3424: STRING selector; 1.7 cvs 3425: CHAR_T saved1; 3426: CHAR_T saved2; 1.1 cvs 3427: 3428: /* separate the selectors string */ 1.13 cvs 3429: cssRule = SkipBlanksAndComments (cssRule); 1.1 cvs 3430: decl_end = cssRule; 3431: while ((*decl_end != EOS) && (*decl_end != '{')) 3432: decl_end++; 3433: if (*decl_end == EOS) 3434: return; 3435: /* verify and clean the selector string */ 3436: sel_end = decl_end - 1; 1.18 cvs 3437: while (*sel_end == SPACE || *sel_end == BSPACE || 3438: *sel_end == EOL || *sel_end == __CR__) 1.1 cvs 3439: sel_end--; 3440: sel_end++; 3441: saved1 = *sel_end; 3442: *sel_end = EOS; 3443: selector = cssRule; 3444: 3445: /* now, deal with the content ... */ 3446: decl_end++; 3447: cssRule = decl_end; 3448: while (*decl_end != EOS && *decl_end != '}') 3449: decl_end++; 3450: if (*decl_end == EOS) 3451: { 3452: fprintf (stderr, "Invalid STYLE declaration : %s\n", cssRule); 3453: return; 3454: } 3455: saved2 = *decl_end; 3456: *decl_end = EOS; 3457: 3458: /* 3459: * parse the style attribute string and install the corresponding 3460: * presentation attributes on the new element 3461: */ 3462: ctxt = TtaGetGenericStyleContext (doc); 3463: if (ctxt == NULL) 3464: return; 3465: ctxt->destroy = destroy; 3466: 3467: while ((selector != NULL) && (*selector != EOS)) 1.25 cvs 3468: selector = ParseGenericSelector (selector, cssRule, ctxt, doc, css); 1.1 cvs 3469: TtaFreeMemory (ctxt); 3470: 3471: /* restore the string to its original form ! */ 3472: *sel_end = saved1; 3473: *decl_end = saved2; 3474: } 3475: 3476: /************************************************************************ 3477: * * 3478: * EVALUATION FUNCTIONS / CASCADING AND OVERLOADING * 3479: * * 3480: ************************************************************************/ 3481: 3482: /*---------------------------------------------------------------------- 3483: IsImplicitClassName : return wether the Class name is an 3484: implicit one, eg "H1" or "H2 EM" meaning it's a GI name 3485: or an HTML context name. 3486: ----------------------------------------------------------------------*/ 3487: #ifdef __STDC__ 3488: int IsImplicitClassName (STRING class, Document doc) 3489: #else 3490: int IsImplicitClassName (class, doc) 3491: STRING class; 3492: Document doc; 3493: #endif 3494: { 1.25 cvs 3495: CHAR_T name[200]; 3496: STRING cur = name, first; 3497: CHAR_T save; 1.1 cvs 3498: SSchema schema; 3499: 3500: /* make a local copy */ 3501: ustrncpy (name, class, 199); 3502: name[199] = 0; 3503: 3504: /* loop looking if each word is a GI */ 3505: while (*cur != 0) 3506: { 3507: first = cur; 3508: cur = SkipWord (cur); 3509: save = *cur; 3510: *cur = 0; 3511: schema = NULL; 3512: if (MapGI (first, &schema, doc) == -1) 3513: { 3514: return (0); 3515: } 3516: *cur = save; 1.13 cvs 3517: cur = SkipBlanksAndComments (cur); 1.1 cvs 3518: } 3519: return (1); 3520: } 3521: 3522: /************************************************************************ 3523: * * 3524: * Functions Needed for support of HTML 3.2 : translate to CSS equiv * 3525: * * 3526: ************************************************************************/ 3527: 3528: /*---------------------------------------------------------------------- 3529: HTMLSetBackgroundColor : 3530: ----------------------------------------------------------------------*/ 3531: #ifdef __STDC__ 3532: void HTMLSetBackgroundColor (Document doc, Element el, STRING color) 3533: #else 3534: void HTMLSetBackgroundColor (doc, el, color) 3535: Document doc; 3536: Element el; 3537: STRING color; 3538: #endif 3539: { 1.7 cvs 3540: CHAR_T css_command[100]; 1.1 cvs 3541: 1.17 cvs 3542: usprintf (css_command, TEXT("background-color: %s"), color); 1.1 cvs 3543: ParseHTMLSpecificStyle (el, css_command, doc, FALSE); 3544: } 3545: 3546: /*---------------------------------------------------------------------- 3547: HTMLSetBackgroundImage : 3548: repeat = repeat value 3549: image = url of background image 3550: ----------------------------------------------------------------------*/ 3551: #ifdef __STDC__ 3552: void HTMLSetBackgroundImage (Document doc, Element el, int repeat, STRING image) 3553: #else 3554: void HTMLSetBackgroundImage (doc, el, repeat, image) 3555: Document doc; 3556: Element el; 3557: int repeat; 3558: STRING image; 3559: #endif 3560: { 1.7 cvs 3561: CHAR_T css_command[400]; 1.1 cvs 3562: 3563: /******* check buffer overflow ********/ 1.17 cvs 3564: usprintf (css_command, TEXT("background-image: url(%s); background-repeat: "), image); 1.1 cvs 3565: if (repeat == STYLE_REPEAT) 1.17 cvs 3566: ustrcat (css_command, TEXT("repeat")); 1.1 cvs 3567: else if (repeat == STYLE_HREPEAT) 1.17 cvs 3568: ustrcat (css_command, TEXT("repeat-x")); 1.1 cvs 3569: else if (repeat == STYLE_VREPEAT) 1.17 cvs 3570: ustrcat (css_command, TEXT("repeat-y")); 1.1 cvs 3571: else 1.17 cvs 3572: ustrcat (css_command, TEXT("no-repeat")); 1.1 cvs 3573: ParseHTMLSpecificStyle (el, css_command, doc, FALSE); 3574: } 3575: 3576: /*---------------------------------------------------------------------- 3577: HTMLSetForegroundColor : 3578: ----------------------------------------------------------------------*/ 3579: #ifdef __STDC__ 3580: void HTMLSetForegroundColor (Document doc, Element el, STRING color) 3581: #else 3582: void HTMLSetForegroundColor (doc, el, color) 3583: Document doc; 3584: Element el; 3585: STRING color; 3586: #endif 3587: { 1.7 cvs 3588: CHAR_T css_command[100]; 1.1 cvs 3589: 1.17 cvs 3590: usprintf (css_command, TEXT("color: %s"), color); 1.1 cvs 3591: ParseHTMLSpecificStyle (el, css_command, doc, FALSE); 3592: } 3593: 3594: /*---------------------------------------------------------------------- 3595: HTMLResetBackgroundColor : 3596: ----------------------------------------------------------------------*/ 3597: #ifdef __STDC__ 3598: void HTMLResetBackgroundColor (Document doc, Element el) 3599: #else 3600: void HTMLResetBackgroundColor (doc, el) 3601: Document doc; 3602: Element el; 3603: #endif 3604: { 1.7 cvs 3605: CHAR_T css_command[100]; 1.1 cvs 3606: 1.36 cvs 3607: usprintf (css_command, TEXT("background: red")); 1.1 cvs 3608: ParseHTMLSpecificStyle (el, css_command, doc, TRUE); 3609: } 3610: 3611: /*---------------------------------------------------------------------- 3612: HTMLResetBackgroundImage : 3613: ----------------------------------------------------------------------*/ 3614: #ifdef __STDC__ 3615: void HTMLResetBackgroundImage (Document doc, Element el) 3616: #else 3617: void HTMLResetBackgroundImage (doc, el) 3618: Document doc; 3619: Element el; 3620: #endif 3621: { 1.7 cvs 3622: CHAR_T css_command[1000]; 1.1 cvs 3623: 1.17 cvs 3624: usprintf (css_command, TEXT("background-image: url(xx); background-repeat: repeat")); 1.1 cvs 3625: ParseHTMLSpecificStyle (el, css_command, doc, TRUE); 3626: } 3627: 3628: /*---------------------------------------------------------------------- 3629: HTMLResetForegroundColor : 3630: ----------------------------------------------------------------------*/ 3631: #ifdef __STDC__ 3632: void HTMLResetForegroundColor (Document doc, Element el) 3633: #else 3634: void HTMLResetForegroundColor (doc, el) 3635: Document doc; 3636: Element el; 3637: #endif 3638: { 1.7 cvs 3639: CHAR_T css_command[100]; 1.1 cvs 3640: 1.36 cvs 3641: /* it's not necessary to well know the current color but it must be valid */ 3642: usprintf (css_command, TEXT("color: red")); 1.1 cvs 3643: ParseHTMLSpecificStyle (el, css_command, doc, TRUE); 3644: } 3645: 3646: /*---------------------------------------------------------------------- 3647: HTMLSetAlinkColor : 3648: ----------------------------------------------------------------------*/ 3649: #ifdef __STDC__ 3650: void HTMLSetAlinkColor (Document doc, STRING color) 3651: #else 3652: void HTMLSetAlinkColor (doc, color) 3653: Document doc; 3654: STRING color; 3655: #endif 3656: { 1.7 cvs 3657: CHAR_T css_command[100]; 1.1 cvs 3658: 1.37 cvs 3659: usprintf (css_command, TEXT("a:link { color : %s }"), color); 1.1 cvs 3660: ApplyCSSRules (NULL, css_command, doc, FALSE); 3661: } 3662: 3663: /*---------------------------------------------------------------------- 3664: HTMLSetAactiveColor : 3665: ----------------------------------------------------------------------*/ 3666: #ifdef __STDC__ 3667: void HTMLSetAactiveColor (Document doc, STRING color) 3668: #else 3669: void HTMLSetAactiveColor (doc, color) 3670: Document doc; 3671: STRING color; 3672: #endif 3673: { 1.7 cvs 3674: CHAR_T css_command[100]; 1.1 cvs 3675: 1.37 cvs 3676: usprintf (css_command, TEXT("a:active { color : %s }"), color); 1.1 cvs 3677: ApplyCSSRules (NULL, css_command, doc, FALSE); 3678: } 3679: 3680: /*---------------------------------------------------------------------- 3681: HTMLSetAvisitedColor : 3682: ----------------------------------------------------------------------*/ 3683: #ifdef __STDC__ 3684: void HTMLSetAvisitedColor (Document doc, STRING color) 3685: #else 3686: void HTMLSetAvisitedColor (doc, color) 3687: Document doc; 3688: STRING color; 3689: #endif 3690: { 1.7 cvs 3691: CHAR_T css_command[100]; 1.1 cvs 3692: 1.37 cvs 3693: usprintf (css_command, TEXT("a:visited { color : %s }"), color); 1.1 cvs 3694: ApplyCSSRules (NULL, css_command, doc, FALSE); 3695: } 3696: 3697: /*---------------------------------------------------------------------- 3698: HTMLResetAlinkColor : 3699: ----------------------------------------------------------------------*/ 3700: #ifdef __STDC__ 3701: void HTMLResetAlinkColor (Document doc) 3702: #else 3703: void HTMLResetAlinkColor (doc) 3704: Document doc; 3705: #endif 3706: { 1.7 cvs 3707: CHAR_T css_command[100]; 1.1 cvs 3708: 1.37 cvs 3709: usprintf (css_command, TEXT("a:link { color : red }")); 1.1 cvs 3710: ApplyCSSRules (NULL, css_command, doc, TRUE); 3711: } 3712: 3713: /*---------------------------------------------------------------------- 3714: HTMLResetAactiveColor : 3715: ----------------------------------------------------------------------*/ 3716: #ifdef __STDC__ 3717: void HTMLResetAactiveColor (Document doc) 3718: #else 3719: void HTMLResetAactiveColor (doc) 3720: Document doc; 3721: #endif 3722: { 1.7 cvs 3723: CHAR_T css_command[100]; 1.1 cvs 3724: 1.37 cvs 3725: usprintf (css_command, TEXT("a:active { color : red }")); 1.1 cvs 3726: ApplyCSSRules (NULL, css_command, doc, TRUE); 3727: } 3728: 3729: /*---------------------------------------------------------------------- 3730: HTMLResetAvisitedColor : 3731: ----------------------------------------------------------------------*/ 3732: #ifdef __STDC__ 3733: void HTMLResetAvisitedColor (Document doc) 3734: #else 3735: void HTMLResetAvisitedColor (doc) 3736: Document doc; 3737: #endif 3738: { 1.7 cvs 3739: CHAR_T css_command[100]; 1.1 cvs 3740: 1.37 cvs 3741: usprintf (css_command, TEXT("a:visited { color : red }")); 1.1 cvs 3742: ApplyCSSRules (NULL, css_command, doc, TRUE); 3743: } 3744: 3745: /*---------------------------------------------------------------------- 3746: ApplyCSSRules: parse an CSS Style description stored in the 3747: header of a HTML document. 3748: ----------------------------------------------------------------------*/ 3749: #ifdef __STDC__ 1.14 cvs 3750: void ApplyCSSRules (Element el, STRING cssRule, Document doc, ThotBool destroy) 1.1 cvs 3751: #else 3752: void ApplyCSSRules (el, cssRule, doc, destroy) 3753: Element el; 3754: STRING cssRule; 3755: Document doc; 1.14 cvs 3756: ThotBool destroy; 1.1 cvs 3757: #endif 3758: { 3759: CSSInfoPtr css; 3760: 3761: css = SearchCSS (doc, NULL); 3762: if (css == NULL) 3763: /* create the document css */ 3764: css = AddCSS (doc, doc, CSS_DOCUMENT_STYLE, NULL, NULL); 3765: ParseStyleDeclaration (el, cssRule, doc, css, destroy); 3766: } 3767: 3768: /*---------------------------------------------------------------------- 3769: ReadCSSRules : is the front-end function called by the HTML parser 3770: when detecting a <STYLE TYPE="text/css"> indicating it's the 3771: beginning of a CSS fragment or when reading a file .css. 3772: 3773: The CSS parser has to handle <!-- ... --> constructs used to 3774: prevent prehistoric browser from displaying the CSS as a text 3775: content. It will stop on any sequence "<x" where x is different 3776: from ! and will return x as to the caller. Theorically x should 3777: be equal to / for the </STYLE> end of style. 3778: 3779: The parameter doc gives the document tree that contains CSS information. 3780: The parameter docRef gives the document to which CSS are to be applied. 3781: This function uses the current css context or creates it. It's able 1.23 cvs 3782: to work on the given buffer or call GetNextChar to read the parsed 1.1 cvs 3783: file. 3784: Parameter withUndo indicates whether the changes made in the document 3785: structure and content have to be registered in the Undo queue or not 3786: ----------------------------------------------------------------------*/ 3787: #ifdef __STDC__ 1.18 cvs 3788: CHAR_T ReadCSSRules (Document docRef, CSSInfoPtr css, STRING buffer, ThotBool withUndo) 1.1 cvs 3789: #else 1.18 cvs 3790: CHAR_T ReadCSSRules (docRef, css, buffer, withUndo) 1.1 cvs 3791: Document docRef; 3792: CSSInfoPtr css; 3793: STRING buffer; 1.14 cvs 3794: ThotBool withUndo; 1.1 cvs 3795: #endif 3796: { 1.13 cvs 3797: CHAR_T c; 1.31 cvs 3798: STRING cssRule, base; 1.6 cvs 3799: DisplayMode dispMode; 1.19 cvs 3800: int index; 1.1 cvs 3801: int CSSindex; 3802: int CSScomment; 3803: int import; 3804: int openRule; 1.14 cvs 3805: ThotBool HTMLcomment; 3806: ThotBool toParse, eof; 1.36 cvs 3807: ThotBool ignoreMedia, media; 1.25 cvs 3808: ThotBool noRule; 1.1 cvs 3809: 3810: CSScomment = MAX_CSS_LENGTH; 3811: HTMLcomment = FALSE; 3812: CSSindex = 0; 3813: toParse = FALSE; 3814: noRule = FALSE; 1.36 cvs 3815: media = FALSE; 1.1 cvs 3816: ignoreMedia = FALSE; 3817: import = MAX_CSS_LENGTH; 3818: eof = FALSE; 3819: openRule = 0; 3820: c = SPACE; 3821: index = 0; 1.6 cvs 3822: /* avoid too many redisplay */ 3823: dispMode = TtaGetDisplayMode (docRef); 3824: if (dispMode == DisplayImmediately) 3825: TtaSetDisplayMode (docRef, DeferredDisplay); 1.18 cvs 3826: 3827: /* look for the CSS context */ 3828: if (css == NULL) 3829: css = SearchCSS (docRef, NULL); 3830: if (css == NULL) 3831: css = AddCSS (docRef, docRef, CSS_DOCUMENT_STYLE, NULL, NULL); 1.1 cvs 3832: 1.25 cvs 3833: while (CSSindex < MAX_CSS_LENGTH && c != EOS && !eof) 1.1 cvs 3834: { 1.23 cvs 3835: c = buffer[index++]; 3836: eof = (c == EOS); 1.1 cvs 3837: CSSbuffer[CSSindex] = c; 1.13 cvs 3838: if (CSScomment == MAX_CSS_LENGTH || c == '*' || c == '/' || c == '<') 1.1 cvs 3839: { 1.5 cvs 3840: /* we're not within a comment or we're parsing * or / */ 3841: switch (c) 1.1 cvs 3842: { 1.5 cvs 3843: case '@': 3844: /* perhaps an import primitive */ 3845: import = CSSindex; 3846: break; 3847: case ';': 1.36 cvs 3848: if (import != MAX_CSS_LENGTH && !media) 1.5 cvs 3849: { 1.17 cvs 3850: if (ustrncasecmp (&CSSbuffer[import+1], TEXT("import"), 6)) 1.5 cvs 3851: /* it's not an import */ 3852: import = MAX_CSS_LENGTH; 3853: /* save the text */ 3854: noRule = TRUE; 3855: } 3856: break; 3857: case '*': 1.13 cvs 3858: if (CSScomment == MAX_CSS_LENGTH && 3859: CSSindex > 0 && CSSbuffer[CSSindex - 1] == '/') 1.5 cvs 3860: /* start a comment */ 3861: CSScomment = CSSindex - 1; 3862: break; 3863: case '/': 1.8 cvs 3864: if (CSSindex > 1 && 1.13 cvs 3865: CSScomment != MAX_CSS_LENGTH && 3866: CSSbuffer[CSSindex - 1] == '*') 1.5 cvs 3867: { 1.25 cvs 3868: /* close a comment:and ignore its contents */ 3869: CSSindex = CSScomment - 1; /* will be incremented later */ 1.5 cvs 3870: CSScomment = MAX_CSS_LENGTH; 3871: } 1.25 cvs 3872: else if (CSScomment == MAX_CSS_LENGTH && 3873: CSSindex > 0 && 3874: CSSbuffer[CSSindex - 1] == '<') 1.5 cvs 3875: { 3876: /* this is the closing tag ! */ 3877: CSSindex -= 2; /* remove </ from the CSS string */ 1.13 cvs 3878: noRule = TRUE; 1.8 cvs 3879: } 1.5 cvs 3880: break; 3881: case '<': 1.25 cvs 3882: if (CSScomment == MAX_CSS_LENGTH) 1.5 cvs 3883: { 1.25 cvs 3884: /* only if we're not parsing a comment */ 3885: c = buffer[index++]; 3886: eof = (c == EOS); 3887: if (c == '!') 3888: { 3889: /* CSS within an HTML comment */ 3890: HTMLcomment = TRUE; 3891: CSSindex++; 3892: CSSbuffer[CSSindex] = c; 3893: } 3894: else if (c == EOS) 3895: CSSindex++; 1.5 cvs 3896: } 3897: break; 3898: case '-': 3899: if (CSSindex > 0 && CSSbuffer[CSSindex - 1] == '-' && HTMLcomment) 3900: /* CSS within an HTML comment */ 3901: noRule = TRUE; 3902: break; 3903: case '>': 3904: if (HTMLcomment) 3905: noRule = TRUE; 3906: break; 1.36 cvs 3907: case ' ': 3908: if (import != MAX_CSS_LENGTH && openRule == 0) 3909: media = !ustrncmp (&CSSbuffer[import+1], TEXT("media"), 5); 3910: break; 1.5 cvs 3911: case '{': 3912: openRule++; 1.36 cvs 3913: if (import != MAX_CSS_LENGTH && openRule == 1 && media) 1.5 cvs 3914: { 3915: /* is it the screen concerned? */ 3916: CSSbuffer[CSSindex+1] = EOS; 1.25 cvs 3917: if (TtaIsPrinting ()) 3918: base = ustrstr (&CSSbuffer[import], TEXT("print")); 3919: else 3920: base = ustrstr (&CSSbuffer[import], TEXT("screen")); 1.5 cvs 3921: if (base == NULL) 3922: ignoreMedia = TRUE; 3923: noRule = TRUE; 3924: } 3925: break; 3926: case '}': 3927: openRule--; 3928: if (import != MAX_CSS_LENGTH && openRule == 0) 3929: { 3930: import = MAX_CSS_LENGTH; 3931: noRule = TRUE; 3932: ignoreMedia = FALSE; 1.36 cvs 3933: media = FALSE; 1.12 cvs 3934: } 1.5 cvs 3935: else 3936: toParse = TRUE; 3937: break; 3938: default: 3939: break; 1.1 cvs 3940: } 3941: } 1.18 cvs 3942: if (c != __CR__) 1.13 cvs 3943: CSSindex++; 1.12 cvs 3944: 1.29 cvs 3945: if (CSSindex >= MAX_CSS_LENGTH && CSScomment < MAX_CSS_LENGTH) 3946: /* we're still parsing a comment: remove the text comment */ 3947: CSSindex = CSScomment; 3948: 1.25 cvs 3949: if (CSSindex >= MAX_CSS_LENGTH || toParse || noRule) 1.1 cvs 3950: { 3951: CSSbuffer[CSSindex] = EOS; 3952: /* parse a not empty string */ 3953: if (CSSindex > 0) 3954: { 3955: /* apply CSS rule if it's not just a saving of text */ 3956: if (!noRule && !ignoreMedia) 1.18 cvs 3957: ParseStyleDeclaration (NULL, CSSbuffer, docRef, css, FALSE); 1.1 cvs 3958: else if (import != MAX_CSS_LENGTH && 1.17 cvs 3959: !ustrncasecmp (&CSSbuffer[import+1], TEXT("import"), 6)) 1.1 cvs 3960: { 3961: /* import section */ 3962: cssRule = &CSSbuffer[import+7]; 3963: cssRule = TtaSkipBlanks (cssRule); 1.17 cvs 3964: if (!ustrncasecmp (cssRule, TEXT("url"), 3)) 1.1 cvs 3965: { 1.13 cvs 3966: cssRule = &cssRule[3]; 1.1 cvs 3967: cssRule = TtaSkipBlanks (cssRule); 3968: if (*cssRule == '(') 3969: { 3970: cssRule++; 3971: cssRule = TtaSkipBlanks (cssRule); 3972: base = cssRule; 3973: while (*cssRule != EOS && *cssRule != ')') 3974: cssRule++; 3975: *cssRule = EOS; 1.38 cvs 3976: LoadStyleSheet (base, docRef, NULL, css, css->media[docRef]); 1.1 cvs 3977: } 3978: } 3979: /*** Caution: Strings can either be written with double quotes or 3980: with single quotes. Only double quotes are handled here. 3981: Escaped quotes are not handled. See function SkipQuotedString */ 3982: else if (*cssRule == '"') 3983: { 3984: cssRule++; 3985: base = cssRule; 3986: while (*cssRule != EOS && *cssRule != '"') 3987: cssRule++; 3988: *cssRule = EOS; 1.38 cvs 3989: LoadStyleSheet (base, docRef, NULL, css, css->media[docRef]); 1.1 cvs 3990: } 3991: import = MAX_CSS_LENGTH; 3992: } 3993: } 3994: toParse = FALSE; 3995: noRule = FALSE; 3996: CSSindex = 0; 3997: } 3998: } 1.6 cvs 3999: /* restore the display mode */ 4000: if (dispMode == DisplayImmediately) 4001: TtaSetDisplayMode (docRef, dispMode); 1.1 cvs 4002: return (c); 4003: }