![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to text.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / libsrc|
Return to text.h CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / libsrc |
1.1 ! root 1: /* $Header: text.h,v 10.1 86/11/19 10:46:56 jg Exp $ */ ! 2: /* text.h - macros and global data used by X text functions ! 3: * ! 4: * Author: ! 5: * Dan Stone & Scott Bates ! 6: * Brown University ! 7: * IRIS, Box 1946 ! 8: * Providence, RI 02912 ! 9: * ! 10: * ! 11: * Copyright (c) 1986 Brown University ! 12: * ! 13: * Permission to use, copy, modify and distribute this software and its ! 14: * documentation for any purpose and without fee is hereby granted, provided ! 15: * that the above copyright notice appear in all copies, and that both ! 16: * that copyright notice and this permission notice appear in supporting ! 17: * documentation, and that the name of Brown University not be used in ! 18: * advertising or publicity pertaining to distribution of the software ! 19: * without specific, written prior permission. Brown University makes no ! 20: * representations about the suitability of this software for any purpose. ! 21: * It is provided "as-is" without express or implied warranty. ! 22: */ ! 23: ! 24: /* ! 25: * Macros for all the combination rules which can be used. ! 26: */ ! 27: ! 28: #define GXcopy_OP(src, dst) dst = (src) ! 29: #define GXor_OP(src, dst) dst = (dst) | (src) ! 30: #define GXxor_OP(src, dst) dst = (dst) ^ (src) ! 31: #define GXand_OP(src, dst) dst = (dst) & (src) ! 32: #define GXcopyInverted_OP(src, dst) dst = ~(src) ! 33: #define GXorInverted_OP(src, dst) dst = (dst) | ~(src) ! 34: #define GXequiv_OP(src, dst) dst = (dst) ^ ~(src) ! 35: #define GXandInverted_OP(src, dst) dst = (dst) & ~(src) ! 36: #define GXorReverse_OP(src, dst) dst = (~(dst) | (src)) ! 37: #define GXandReverse_OP(src, dst) dst = (~(dst) & (src)) ! 38: #define GXinvert_OP(src, dst) dst = ~(dst) ! 39: #define GXnand_OP(src, dst) dst = (~(dst) | ~(src)) ! 40: #define GXnor_OP(src, dst) dst = (~(dst) & ~(src)) ! 41: #define GXclear_OP(src, dst) dst = 0 ! 42: #define GXset_OP(src, dst) dst = 0xFFFF ! 43: #define GXnoop_OP(src, dst) dst = dst ! 44: ! 45: #define GXcopy_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 46: ((src) & mask) ! 47: #define GXor_MASK(src, dst, mask) dst = ((dst) | ((src) & mask)) ! 48: #define GXxor_MASK(src, dst, mask) dst = ((dst) ^ ((src) & mask)) ! 49: #define GXand_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 50: (((dst) & (src)) & mask) ! 51: #define GXcopyInverted_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 52: (~(src) & mask) ! 53: #define GXorInverted_MASK(src, dst, mask) dst = ((dst) | (~(src) & mask)) ! 54: #define GXequiv_MASK(src, dst, mask) dst = ((dst) ^ (~(src) & mask)) ! 55: #define GXandInverted_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 56: (((dst) & ~(src)) & mask) ! 57: #define GXandReverse_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 58: ((~(dst) & (src)) & mask) ! 59: #define GXorReverse_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 60: ((~(dst) | (src)) & mask) ! 61: #define GXinvert_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 62: (~(dst) & (mask)) ! 63: #define GXnor_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 64: ((~(dst) & ~(src)) & mask) ! 65: #define GXnand_MASK(src, dst, mask) dst = ((dst) & ~(mask)) | \ ! 66: ((~(dst) | ~(src)) & mask) ! 67: #define GXclear_MASK(src, dst, mask) dst = 0 ! 68: #define GXset_MASK(src, dst, mask) dst = 0xFFFF ! 69: #define GXnoop_MASK(src, dst, mask) dst = dst ! 70: ! 71: #ifndef BPL ! 72: #define BPL 32 ! 73: #define LOG2_BPL 5 ! 74: #define MOD_BPL(value) ((value) & (BPL - 1)) ! 75: #define DIV_BPL(value) ((value) >> LOG2_BPL) ! 76: #define MUL_BPL(value) ((value) << LOG2_BPL) ! 77: ! 78: /* ! 79: * Macro to convert Bits to Longs. ! 80: */ ! 81: ! 82: #define BTOL(bits) (DIV_BPL((bits) + (BPL - 1))) ! 83: ! 84: #define MUL_4(n) ((n) << 2) ! 85: #define DIV_4(n) ((n) >> 2) ! 86: #endif BPL ! 87: ! 88: #define SRC ((u_short *)src) ! 89: #define SRCPL ((u_short *)(src + 2)) ! 90: #define DST ((u_short *)dst) ! 91: #define DSTPL ((u_short *)(dst + 2)) ! 92: ! 93: /* ! 94: * Masks for to protect the left portion of a short. That portion that should ! 95: * not be changed. ! 96: */ ! 97: ! 98: static u_short leftmask_lib[] = { ! 99: 0xFFFF,0x7FFF,0x3FFF,0x1FFF, ! 100: 0x0FFF,0x07FF,0x03FF,0x01FF, ! 101: 0x00FF,0x007F,0x003F,0x001F, ! 102: 0x000F,0x0007,0x0003,0x0001, ! 103: 0x0000 ! 104: }; ! 105: ! 106: /* ! 107: * Masks for to protect the right portion of a short. That portion that should ! 108: * not be changed. ! 109: */ ! 110: ! 111: static u_short rightmask_lib[] = { ! 112: 0xFFFF,0x8000,0xC000,0xE000, ! 113: 0xF000,0xF800,0xFC00,0xFE00, ! 114: 0xFF00,0xFF80,0xFFC0,0xFFE0, ! 115: 0xFFF0,0xFFF8,0xFFFC,0xFFFE, ! 116: 0x0000 ! 117: }; ! 118: ! 119: /* ! 120: * This macro is used to copy characters from the fonts character bitmaps ! 121: * to the offscreen bitmap. Later the offscreen bitmap is copied to the screen ! 122: * using the bltter. ! 123: * ! 124: * The CopyText_LOOP is an optimization, of a more general bitblt loop. ! 125: * Because most text characters are less than 16 bits wide the CopyText_LOOP ! 126: * has 2 special inner loops for this size character image. A character ! 127: * image thats less than 16 bits wide can only span at most 2 destination ! 128: * shorts, so the 2 special inner loops are designed for 1 destination and ! 129: * 2 destination shorts changing per line. IF more than 2 destination words ! 130: * are to change then the general purpose loop is used. ! 131: * ! 132: * Some special notes: ! 133: * ! 134: * bitptr - A long integer that "points to" or "indexes into" one offscreen ! 135: * buffer scanline. As if one scanline was an array of bits. ! 136: * ! 137: * src,dst - Are unsigned CHAR pointers and are cast to unsigned shorts ! 138: * when used as pointers. Why? IF src was an unsigned SHORT ! 139: * pointer and src += n was done, the current RT compiler ! 140: * would generate 2 extra assembly language instructions, ! 141: * one to shift n left (multiply by 2) and the other to ! 142: * compute the address. ! 143: * ! 144: * The offscreen buffer is the destination. ! 145: * ! 146: * Here is the algorithm for the CopyText_LOOP: ! 147: * ! 148: * FOREACH character DO ! 149: * IF the character is not printable THEN ! 150: * continue ! 151: * IF the character is wider than zero THEN ! 152: * set start_dst = To the destination short which contains the first ! 153: * bit to be changed. ! 154: * set shift = The first bit within start_dst to be changed. ! 155: * Increment bitptr past the current character. ! 156: * IF bitptr is beyond the last bit in the destination THEN ! 157: * Decrement bitptr back to its previous value. ! 158: * Decrement the character count. ! 159: * Break out of the loop. ! 160: * ENDIF ! 161: * ! 162: * Set the right mask using the right mask library and the NEW bitptr. ! 163: * Calculate the source pointer. ! 164: * Calculate the destination pointer. ! 165: * Calculate the number of shorts changed in the destination. ! 166: * ! 167: * IF no shifting needed THEN ! 168: * IF 1 destination short changed THEN ! 169: * FOREACH scanline DO ! 170: * Use the edge macro (see above) to combine src, dst and ! 171: * mask. ! 172: * Increment the source to the next scanline. ! 173: * Increment the destination to the next scanline. ! 174: * ENDFOR ! 175: * ELSE IF 2 destination shorts changed THEN ! 176: * FOREACH scanline DO ! 177: * Use the macro (see above) to combine src and dst. ! 178: * Use the edge macro (see above) to combine src+2, dst+2 ! 179: * and mask. ! 180: * Increment the source to the next scanline. ! 181: * Increment the destination to the next scanline. ! 182: * ENDFOR ! 183: * ELSE ! 184: * Calculate the amount to decrement the dst to get back ! 185: * to the first scanline next short(the + 2). ! 186: * Calculate the amount to decrement the src to get back ! 187: * to the first scanline next short(the + 2). ! 188: * FOREACH short in the destination DO ! 189: * FOREACH scanline DO ! 190: * Use the macro (see above) to combine src and dst. ! 191: * Increment the source to the next scanline. ! 192: * Increment the destination to the next scanline. ! 193: * ENDFOR ! 194: * Decrement dst back to the first scanline, next short. ! 195: * Decrement src back to the first scanline, next short. ! 196: * Reset the number of scanlines (height). ! 197: * ENDFOR ! 198: * FOREACH scanline DO ! 199: * Use the edge macro to combine src, dst and mask. ! 200: * Increment the source to the next scanline. ! 201: * Increment the destination to the next scanline. ! 202: * ENDFOR ! 203: * ENDIF ! 204: * ELSE ! 205: * Get the left mask from the left mask library using shift. ! 206: * IF 1 destination short changed THEN ! 207: * Combine left and right masks. ! 208: * FOREACH scanline DO ! 209: * Use the edge macro (see above) to combine src shifted, ! 210: * with dst and mask. ! 211: * Increment the source to the next scanline. ! 212: * Increment the destination to the next scanline. ! 213: * ENDFOR ! 214: * ELSE IF 2 destination shorts changed THEN ! 215: * Set the inverse of shift = 16 - shift. ! 216: * IF the src bitmap is only 1 short wide THEN ! 217: * FOREACH scanline DO ! 218: * Use the edge macro (see above) to combine src ! 219: * shifted, with dst and left mask. ! 220: * Use the edge macro (see above) to combine src ! 221: * inversely shifted with dst+2 and right mask. ! 222: * Increment the source to the next scanline. ! 223: * Increment the destination to the next scanline. ! 224: * ENDFOR ! 225: * ELSE # src bitmap is wider than 1 short and the 2nd short ! 226: * # may have useful info in it. ! 227: * FOREACH scanline DO ! 228: * Use the edge macro (see above) to combine src ! 229: * shifted with dst and left mask. ! 230: * Use the edge macro (see above) to combine src ! 231: * shifted, src+2 inversely shifted with ! 232: * dst+2 and right mask. ! 233: * Increment the source to the next scanline. ! 234: * Increment the destination to the next scanline. ! 235: * ENDFOR ! 236: * ELSE ! 237: * Calculate the amount to decrement the dst to get back ! 238: * to the first scanline next short(the + 2). ! 239: * Calculate the amount to decrement the src to get back ! 240: * to the first scanline next short(the + 2). ! 241: * # Deal with the left edge. ! 242: * FOREACH scanline DO ! 243: * Use the edge macro (see above) to combine src shifted ! 244: * with dst and left mask. ! 245: * Increment the source to the next scanline. ! 246: * Increment the destination to the next scanline. ! 247: * ENDFOR ! 248: * # Now deal with the shorts between the left edge and right ! 249: * # edge. ! 250: * FOREACH short in the destination DO ! 251: * FOREACH scanline DO ! 252: * Use the macro (see above) to combine src inversely ! 253: * shifted or'ed with src+2 shifted with dst. ! 254: * Increment the source to the next scanline. ! 255: * Increment the destination to the next scanline. ! 256: * ENDFOR ! 257: * Decrement dst back to the first scanline, next short. ! 258: * Decrement src back to the first scanline, next short. ! 259: * Reset the number of scanlines (height). ! 260: * ENDFOR ! 261: * IF the number of destination shorts == the number of ! 262: * shorts wide the src is THEN ! 263: * # We have incremented to the last short in the src ! 264: * # scanline and should not use src+2. ! 265: * FOREACH scanline DO ! 266: * Use the edge macro to combine src inversely shifted, ! 267: * with dst and right mask. ! 268: * Increment the source to the next scanline. ! 269: * Increment the destination to the next scanline. ! 270: * ENDFOR ! 271: * ELSE ! 272: * FOREACH scanline DO ! 273: * Use the edge macro to combine src inversely shifted ! 274: * or'ed with src+2 shifted, with dst and right ! 275: * mask. ! 276: * Increment the source to the next scanline. ! 277: * Increment the destination to the next scanline. ! 278: * ENDFOR ! 279: * ENDIF ! 280: * ENDIF ! 281: * ENDIF ! 282: * ENDIF ! 283: * ENDFOR ! 284: * ! 285: * NOTE: Make sure ch_pad is not added to the last character copied. ! 286: */ ! 287: ! 288: #define CopyText_LOOP(EDGE_OP, OP) { \ ! 289: for (i = ch_count + 1; --i; ) { \ ! 290: if ((c = (int)(*string++)) < font->first || c > font->last) \ ! 291: continue; /* Character is unprintable. */ \ ! 292: if (char_widths[c] > 0) { \ ! 293: shift = bitptr & 0x0F; \ ! 294: start_dst = DIV_BPW(bitptr); \ ! 295: if (((bitptr += char_widths[c]) + ch_pad) > maxbitptr){ \ ! 296: bitptr -= char_widths[c]; \ ! 297: ch_count -= i; \ ! 298: break; /* Overflow: Get out of the loop */ \ ! 299: } \ ! 300: rtmask = rightmask_lib[bitptr & 0x0F]; \ ! 301: src = (u_char *)(chrs_data) + (shorts_per_char * \ ! 302: (c - font->first)); \ ! 303: dst = (u_char *)buf_bm->data + MUL_2(start_dst); \ ! 304: ndst_shorts = DIV_BPW(bitptr - 1) - start_dst + 1; \ ! 305: height = ht_plus1; \ ! 306: if (shift == 0) { \ ! 307: if (ndst_shorts == 1) { \ ! 308: while (--height) { \ ! 309: EDGE_OP(*SRC, *DST, rtmask); \ ! 310: dst += dst_nextline; \ ! 311: src += src_nextline; \ ! 312: } \ ! 313: } else if (ndst_shorts == 2) { \ ! 314: while (--height) { \ ! 315: OP(*SRC, *DST); \ ! 316: EDGE_OP(*SRCPL, *DSTPL, rtmask); \ ! 317: dst += dst_nextline; \ ! 318: src += src_nextline; \ ! 319: } \ ! 320: } else { \ ! 321: height = font->height; \ ! 322: dst_nextcol = (height*dst_nextline) - 2; \ ! 323: src_nextcol = (height*src_nextline) - 2; \ ! 324: height++; \ ! 325: while (--ndst_shorts > 0) { \ ! 326: while (--height) { \ ! 327: OP(*SRC, *DST); \ ! 328: dst += dst_nextline; \ ! 329: src += src_nextline; \ ! 330: } \ ! 331: dst -= dst_nextcol; \ ! 332: src -= src_nextcol; \ ! 333: height = ht_plus1; \ ! 334: } \ ! 335: while (--height) { \ ! 336: EDGE_OP(*SRC, *DST, rtmask); \ ! 337: dst += dst_nextline; \ ! 338: src += src_nextline; \ ! 339: } \ ! 340: } \ ! 341: } else { \ ! 342: leftmask = leftmask_lib[shift]; \ ! 343: if (ndst_shorts == 1) { \ ! 344: leftmask &= rtmask; \ ! 345: while (--height) { \ ! 346: EDGE_OP((*SRC >> shift), *DST, leftmask); \ ! 347: dst += dst_nextline; \ ! 348: src += src_nextline; \ ! 349: } \ ! 350: } else if (ndst_shorts == 2) { \ ! 351: inv_shift = BPW - shift; \ ! 352: if (chrs_nshorts == 1) { \ ! 353: while (--height) { \ ! 354: EDGE_OP((*SRC >> shift), *DST, leftmask); \ ! 355: EDGE_OP(*(SRC) << inv_shift, *(DSTPL), rtmask); \ ! 356: dst += dst_nextline; \ ! 357: src += src_nextline; \ ! 358: } \ ! 359: } else { \ ! 360: while (--height) { \ ! 361: EDGE_OP((*SRC >> shift), *DST, leftmask); \ ! 362: EDGE_OP((*SRC<<inv_shift)|(*(SRCPL)>>shift), \ ! 363: *(DSTPL), rtmask); \ ! 364: dst += dst_nextline; \ ! 365: src += src_nextline; \ ! 366: } \ ! 367: } \ ! 368: } else { \ ! 369: height = font->height; \ ! 370: dst_nextcol = (height*dst_nextline) - 2; \ ! 371: src_nextcol = (height*src_nextline) - 2; \ ! 372: height++; \ ! 373: while (--height) { \ ! 374: EDGE_OP((*SRC >> shift), *DST, leftmask); \ ! 375: dst += dst_nextline; \ ! 376: src += src_nextline; \ ! 377: } \ ! 378: dst -= dst_nextcol; \ ! 379: src -= (src_nextcol + 2); \ ! 380: inv_shift = BPW - shift; \ ! 381: nsrc_shorts = ndst_shorts - 1; \ ! 382: while (--ndst_shorts > 1) { \ ! 383: height = ht_plus1; \ ! 384: while (--height) { \ ! 385: OP((*SRC<<inv_shift)|(*(SRCPL)>>shift),*DST); \ ! 386: dst += dst_nextline; \ ! 387: src += src_nextline; \ ! 388: } \ ! 389: dst -= dst_nextcol; \ ! 390: src -= src_nextcol; \ ! 391: } \ ! 392: height = ht_plus1; \ ! 393: if (nsrc_shorts == chrs_nshorts) { \ ! 394: while (--height) { \ ! 395: EDGE_OP((*SRC << inv_shift), *DST, rtmask); \ ! 396: dst += dst_nextline; \ ! 397: src += src_nextline; \ ! 398: } \ ! 399: } else { \ ! 400: while (--height) { \ ! 401: EDGE_OP((*SRC << inv_shift) | (*(SRCPL) >> \ ! 402: shift), *DST, rtmask); \ ! 403: dst += dst_nextline; \ ! 404: src += src_nextline; \ ! 405: } \ ! 406: } \ ! 407: } \ ! 408: } \ ! 409: bitptr += ch_pad; \ ! 410: } \ ! 411: if (c == font->space) { \ ! 412: if ((bitptr += sp_pad) > maxbitptr) { \ ! 413: bitptr -= sp_pad; \ ! 414: ch_count -= i; \ ! 415: break; /* Overflow: Get out of the loop. */ \ ! 416: } \ ! 417: } \ ! 418: } \ ! 419: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.