ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/defaultfont.C
(Generate patch)

Comparing rxvt-unicode/src/defaultfont.C (file contents):
Revision 1.36 by pcg, Fri Mar 5 04:43:41 2004 UTC vs.
Revision 1.43 by pcg, Mon Mar 15 07:10:47 2004 UTC

… …
24#include "defaultfont.h" 24#include "defaultfont.h"
25 25
26#include <cstdlib> 26#include <cstdlib>
27 27
28#define DISPLAY r->display->display 28#define DISPLAY r->display->display
29#define GC r->TermWin.gc 29#define TGC r->TermWin.gc
30 30
31const struct rxvt_fallback_font { 31const struct rxvt_fallback_font {
32 codeset cs; 32 codeset cs;
33 const char *name; 33 const char *name;
34} fallback_fonts[] = { 34} fallback_fonts[] = {
… …
61# if XFT 61# if XFT
62 // prefer xft for complex scripts 62 // prefer xft for complex scripts
63 { CS_UNICODE, "xft:Kochi Gothic:antialias=false" }, 63 { CS_UNICODE, "xft:Kochi Gothic:antialias=false" },
64# endif 64# endif
65 { CS_JIS0201_1976_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0201*-0" }, 65 { CS_JIS0201_1976_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0201*-0" },
66 { CS_JIS0208_1983_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0208*-0" }, 66 { CS_JIS0208_1990_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0208*-0" },
67 { CS_JIS0212_1990_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0212*-0" }, 67 { CS_JIS0212_1990_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0212*-0" },
68#endif 68#endif
69 69
70#if ENCODING_CN || ENCODING_CN_EXT 70#if ENCODING_CN || ENCODING_CN_EXT
71# if XFT 71# if XFT
… …
194 else if (color >= 0) 194 else if (color >= 0)
195 { 195 {
196#if XFT 196#if XFT
197 XftDrawRect (d, &r->PixColors[color].c, x, y, w, h); 197 XftDrawRect (d, &r->PixColors[color].c, x, y, w, h);
198#else 198#else
199 XSetForeground (d.display->display, GC, r->PixColors[color]); 199 XSetForeground (d.display->display, TGC, r->PixColors[color]);
200 XFillRectangle (d.display->display, d, GC, x, y, w, h); 200 XFillRectangle (d.display->display, d, TGC, x, y, w, h);
201#endif 201#endif
202 } 202 }
203} 203}
204 204
205static const char *linedraw_cmds[128] = { 205static const char *linedraw_cmds[128 + 32] = {
206 "1hH", "2hH", "1vV", "2vV", 206 "1-", "2-", "1|", "2|",
207 0, 0, 0, 0, 207 0, 0, 0, 0,
208 0, 0, 0, 0, 208 0, 0, 0, 0,
209 "1HV", "2H1V", "1H2V", "2HV", 209 "1HV", "2H1V", "1H2V", "2HV",
210 210
211 // 2510 211 // 2510
212 "1hV", "2h1V", "1h2V", "2hV", 212 "1hV", "2h1V", "1h2V", "2hV",
213 "1Hv", "2H1v", "1H2v", "2Hv", 213 "1Hv", "2H1v", "1H2v", "2Hv",
214 "1hv", "2h1v", "1h2v", "2hv", 214 "1hv", "2h1v", "1h2v", "2hv",
215 "1HvV", "2H1vV", "1HV2v", "1Hv2V", 215 "1H|", "2H1|", "1HV2v", "1Hv2V",
216 216
217 // 2520 217 // 2520
218 "1H2vV", "2Hv1V", "2HV1v", "2HvV", 218 "1H2|", "2Hv1V", "2HV1v", "2H|",
219 "1hvV", "2h1vV", "1hV2v", "1hv2V", 219 "1h|", "2h1|", "1hV2v", "1hv2V",
220 "1h2vV", "2hv1V", "1v2hV", "2hvV", 220 "1h2|", "2hv1V", "1v2hV", "2h|",
221 "1hHV", "2h1HV", "2H1hV", "2hH1V", 221 "1-V", "2h1HV", "2H1hV", "2-1V",
222 222
223 // 2530 223 // 2530
224 "1hH2V", "2hV1H", "1h2HV", "2hHV", 224 "1-2V", "2hV1H", "1h2HV", "2-V",
225 "1hHv", "1vH2h", "1hv2H", "1v2hH", 225 "1-v", "1vH2h", "1hv2H", "1v2-",
226 "1hH2v", "1H2hv", "1h2Hv", "2hHv", 226 "1-2v", "1H2hv", "1h2Hv", "2-v",
227 "1hHvV", "1vVH2h", "1hvV2H", "1vV2hH", 227 "1-|", "1|H2h", "1h|2H", "1|2-",
228 228
229 // 2540 229 // 2540
230 "1hHV2v", "1hHv2V", "1hH2vV", "1HV2hv", 230 "1-V2v", "1-v2V", "1-2|", "1HV2hv",
231 "1hV2Hv", "1Hv2hV", "1hv2HV", "1V2hHv", 231 "1hV2Hv", "1Hv2hV", "1hv2HV", "1V2-v",
232 "1v2hHV", "1H2hvV", "1h2HvV", "2hHvV", 232 "1v2-V", "1H2h|", "1h2H|", "2-|",
233 0, 0, 0, 0, 233 0, 0, 0, 0,
234 234
235 // 2550 235 // 2550
236 0, 0, 0, 0, 236 0, 0, 0, 0,
237 0, 0, 0, 0, 237 0, 0, 0, 0,
… …
240 240
241 // 2560 241 // 2560
242 0, 0, 0, 0, 242 0, 0, 0, 0,
243 0, 0, 0, 0, 243 0, 0, 0, 0,
244 0, 0, 0, 0, 244 0, 0, 0, 0,
245 0, 0, 0, 0, 245 0, "A", "B", "C",
246 246
247 // 2570 247 // 2570
248 0, "1a", "1b", "1ab", 248 "D", "1/", "1\\", "1/\\",
249 "1h", "1v", "1H", "1V", 249 "1h", "1v", "1H", "1V",
250 "2h", "2v", "2H", "2V", 250 "2h", "2v", "2H", "2V",
251 "1h2H", "1v2V", "1H2h", "1V2v" 251 "1h2H", "1v2V", "1H2h", "1V2v",
252
253 // 2580
254 0, 0, 0, 0,
255 0, 0, 0, 0,
256 0, 0, 0, 0,
257 0, 0, 0, 0,
258
259 // 2590
260 0, 0, 0, 0,
261 0, 0, "k", "l",
262 "i", "ikl", "il", "ijk",
263 "ijl", "j", "jk", "jkl",
252 264
253 // to be done 265 // to be done
254}; 266};
255 267
256struct rxvt_font_default : rxvt_font { 268struct rxvt_font_default : rxvt_font {
… …
268 bool load (const rxvt_fontprop &prop) 280 bool load (const rxvt_fontprop &prop)
269 { 281 {
270 width = 1; height = 1; 282 width = 1; height = 1;
271 ascent = 1; descent = 0; 283 ascent = 1; descent = 0;
272 284
285 set_name ("built-in pseudofont");
286
273 return true; 287 return true;
274 } 288 }
275 289
276 bool has_codepoint (uint32_t unicode) 290 bool has_codepoint (unicode_t unicode)
277 { 291 {
278 if (unicode <= 0x001f) 292 if (unicode <= 0x001f)
279 return true; 293 return true;
280 294
281 if (unicode >= 0x0080 && unicode <= 0x009f) 295 if (unicode >= 0x0080 && unicode <= 0x009f)
282 return true; 296 return true;
283 297
284 if (unicode >= 0x2500 && unicode <= 0x257f 298 if (unicode >= 0x2500 && unicode <= 0x257f
285 && linedraw_cmds[unicode - 0x2500]) 299 && linedraw_cmds[unicode - 0x2500])
300 return true;
301
302 if (unicode >= 0x2580 && unicode <= 0x259f)
286 return true; 303 return true;
287 304
288 if (IS_COMPOSE (unicode)) 305 if (IS_COMPOSE (unicode))
289 return true; 306 return true;
290 307
… …
300 void draw (rxvt_drawable &d, int x, int y, 317 void draw (rxvt_drawable &d, int x, int y,
301 const text_t *text, int len, 318 const text_t *text, int len,
302 int fg, int bg); 319 int fg, int bg);
303}; 320};
304 321
322static void rect_stipple (Display *display, Drawable d, GC gc, int s1, int s2, int x, int y, int w, int h)
323{
324 XGCValues gcv;
325 char bm[2] = { s1, s2 };
326
327 gcv.fill_style = FillStippled;
328 gcv.stipple = XCreateBitmapFromData (display, d, bm, 2, 2);
329 gcv.ts_x_origin = x;
330 gcv.ts_y_origin = y;
331
332 if (!gcv.stipple)
333 return;
334
335 XChangeGC (display, gc, GCFillStyle | GCStipple | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
336 XFillRectangle (display, d, gc, x, y, w, h);
337
338 XFreePixmap (display, gcv.stipple);
339
340 gcv.fill_style = FillSolid;
341 XChangeGC (display, gc, GCFillStyle, &gcv);
342}
343
305void 344void
306rxvt_font_default::draw (rxvt_drawable &d, int x, int y, 345rxvt_font_default::draw (rxvt_drawable &d, int x, int y,
307 const text_t *text, int len, 346 const text_t *text, int len,
308 int fg, int bg) 347 int fg, int bg)
309{ 348{
310 clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg); 349 clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
311 350
312 XSetForeground (d.display->display, GC, r->PixColors[fg]); 351 XSetForeground (d.display->display, TGC, r->PixColors[fg]);
313 352
314 while (len--) 353 while (len--)
315 { 354 {
355#if ENABLE_COMBINING
316 compose_char *cc; 356 compose_char *cc;
357#endif
317 text_t t = *text++; 358 text_t t = *text++;
318 359
360 int W = r->TermWin.fwidth , w = (W - 1) / 2;
361 int H = r->TermWin.fheight, h = (H - 1) / 2;
362 int x0 = x, x1 = x + w, x2 = x + r->TermWin.fwidth ;
363 int y0 = y, y1 = y + h, y2 = y + r->TermWin.fheight;
364
319 // is it in our linedrawing table? 365 // is it in our linedrawing table?
320 if (t >= 0x2500 & t <= 0x2580 && linedraw_cmds[t - 0x2500]) 366 if (t >= 0x2500 & t <= 0x259f && linedraw_cmds[t - 0x2500])
321 { 367 {
322 const char *p = linedraw_cmds[t - 0x2500]; 368 const char *p = linedraw_cmds[t - 0x2500];
323 369
324 int x0 = x, x1 = x + (r->TermWin.fwidth - 1) / 2, x2 = x + r->TermWin.fwidth - 1;
325 int y0 = y, y1 = y + (r->TermWin.fheight - 1) / 2, y2 = y + r->TermWin.fheight - 1;
326
327 XGCValues gcv; 370 XGCValues gcv;
371
372 gcv.cap_style = CapNotLast;
373 XChangeGC (d.display->display, TGC, GCCapStyle, &gcv);
328 374
329 while (*p) 375 while (*p)
330 { 376 {
331 switch (*p++) 377 switch (*p++)
332 { 378 {
333 case '1': 379 case '1':
334 gcv.line_width = 0; 380 gcv.line_width = 0;
335 XChangeGC (d.display->display, GC, GCLineWidth, &gcv); 381 XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
336 break; 382 break;
337 383
338 case '2': 384 case '2':
339 gcv.line_width = 2; 385 gcv.line_width = 3;
340 XChangeGC (d.display->display, GC, GCLineWidth, &gcv); 386 XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
341 break; 387 break;
342 388
343 case 'h': XDrawLine (d.display->display, d, GC, x0, y1, x1, y1); break; 389 case 'h': XDrawLine (d.display->display, d, TGC, x0, y1, x1+1, y1 ); break;
344 case 'H': XDrawLine (d.display->display, d, GC, x1, y1, x2, y1); break; 390 case 'H': XDrawLine (d.display->display, d, TGC, x1, y1, x2 , y1 ); break;
391 case '-': XDrawLine (d.display->display, d, TGC, x0, y1, x2 , y1 ); break;
345 case 'v': XDrawLine (d.display->display, d, GC, x1, y0, x1, y1); break; 392 case 'v': XDrawLine (d.display->display, d, TGC, x1, y0, x1 , y1+1); break;
346 case 'V': XDrawLine (d.display->display, d, GC, x1, y1, x1, y2); break; 393 case 'V': XDrawLine (d.display->display, d, TGC, x1, y1, x1 , y2 ); break;
394 case '|': XDrawLine (d.display->display, d, TGC, x1, y0, x1 , y2 ); break;
395
347 case 'a': XDrawLine (d.display->display, d, GC, x0, y2, x2, y0); break; 396 case '/' : XDrawLine (d.display->display, d, TGC, x0, y2, x2 , y0 ); break;
348 case 'b': XDrawLine (d.display->display, d, GC, x0, y0, x2, y2); break; 397 case '\\': XDrawLine (d.display->display, d, TGC, x0, y0, x2 , y2 ); break;
398
399 case 'A': XDrawArc (d.display->display, d, TGC, x1 , y1 , W-1, H-1, 90*64, 90*64); break;
400 case 'B': XDrawArc (d.display->display, d, TGC, x1-W+1, y1 , W-1, H-1, 0*64, 90*64); break;
401 case 'C': XDrawArc (d.display->display, d, TGC, x1-W+1, y1-H+1, W-1, H-1, 0*64, -90*64); break;
402 case 'D': XDrawArc (d.display->display, d, TGC, x1 , y1-H+1, W-1, H-1, -90*64, -90*64); break;
403
404 case 'i': XFillRectangle (d.display->display, d, TGC, x0, y0, x1 - x0 + 1, y1 - y0 + 1); break;
405 case 'j': XFillRectangle (d.display->display, d, TGC, x1, y0, x2 - x1, y1 - y0 + 1); break;
406 case 'k': XFillRectangle (d.display->display, d, TGC, x0, y1, x1 - x0 + 1, y2 - y1); break;
407 case 'l': XFillRectangle (d.display->display, d, TGC, x1, y1, x2 - x1, y2 - y1); break;
349 } 408 }
350 } 409 }
351 410
352 gcv.line_width = 0; 411 gcv.line_width = 0;
353 XChangeGC (d.display->display, GC, GCLineWidth, &gcv); 412 XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
354 } 413 }
414
415#if ENABLE_COMBINING
355 else if (IS_COMPOSE (t) && (cc = rxvt_composite[t])) 416 else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
356 { 417 {
418 rxvt_font *f1 = (*fs)[fs->find_font (cc->c1)];
357 (*fs)[fs->find_font (cc->c1)]->draw (d, x, y, &(t = cc->c1), 1, fg, bg); 419 f1->draw (d, x, y, &(t = cc->c1), 1, fg, bg);
358 if (cc->c2 != NOCHAR) 420 if (cc->c2 != NOCHAR)
421 {
422 // prefer font of first character, for no good reasons
423 rxvt_font *f2 = f1->has_codepoint (cc->c2)
424 ? f1
425 : (*fs)[fs->find_font (cc->c2)];
426
359 (*fs)[fs->find_font (cc->c2)]->draw (d, x, y, &(t = cc->c2), 1, fg, -1); 427 f2->draw (d, x, y, &(t = cc->c2), 1, fg, -1);
360 } 428 }
429 }
430#endif
361 else 431 else
362 switch (t) 432 switch (t)
363 { 433 {
364 case ZERO_WIDTH_CHAR: 434 case ZERO_WIDTH_CHAR:
365 break; 435 break;
436
437 case 0x2580: XFillRectangle (d.display->display, d, TGC, x0, y0, W, y1 - y0 + 1); break;
438 case 0x2581: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 7 - 1) / 8, W, H - (H * 7 - 1) / 8); break;
439 case 0x2582: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 6 - 2) / 8, W, H - (H * 6 - 2) / 8); break;
440 case 0x2583: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 5 - 3) / 8, W, H - (H * 5 - 3) / 8); break;
441 case 0x2584: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 4 - 4) / 8, W, H - (H * 4 - 4) / 8); break;
442 case 0x2585: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 3 - 5) / 8, W, H - (H * 3 - 5) / 8); break;
443 case 0x2586: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 2 - 6) / 8, W, H - (H * 2 - 6) / 8); break;
444 case 0x2587: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 1 - 7) / 8, W, H - (H * 1 - 7) / 8); break;
445 case 0x2588: XFillRectangle (d.display->display, d, TGC, x0, y0, W, H); break;
446 case 0x2589: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 7 - 1) / 8, H); break;
447 case 0x258a: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 6 - 2) / 8, H); break;
448 case 0x258b: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 5 - 3) / 8, H); break;
449 case 0x258c: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 4 - 4) / 8, H); break;
450 case 0x258d: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 3 - 5) / 8, H); break;
451 case 0x258e: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 2 - 6) / 8, H); break;
452 case 0x258f: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 1 - 7) / 8, H); break;
453 case 0x2590: XFillRectangle (d.display->display, d, TGC, x1, y0, x2 - x1, H); break;
454
455 case 0x2591: rect_stipple (d.display->display, d, TGC, 0x00, 0x01, x0, y0, W, H); break;
456 case 0x2592: rect_stipple (d.display->display, d, TGC, 0x02, 0x01, x0, y0, W, H); break;
457 case 0x2593: rect_stipple (d.display->display, d, TGC, 0x01, 0x03, x0, y0, W, H); break;
458
459 case 0x2594: XFillRectangle (d.display->display, d, TGC, x0, y0, W, (H * 1 - 7) / 8); break;
460 case 0x2595: XFillRectangle (d.display->display, d, TGC, x0 + (W * 7 - 1) / 8, y0, W - (W * 7 - 1) / 8, H); break;
461
366 default: 462 default:
367 int w = 0; 463 int w = 0;
368 while (len > 0 && *text == NOCHAR) 464 while (len > 0 && *text == NOCHAR)
369 { 465 {
370 ++text; 466 ++text;
371 --len; 467 --len;
372 w += r->TermWin.fwidth; 468 w += r->TermWin.fwidth;
373 } 469 }
374 470
375 XDrawRectangle (d.display->display, d, GC, x + 2, y + 2, 471 XDrawRectangle (d.display->display, d, TGC, x + 2, y + 2,
376 w + r->TermWin.fwidth - 5, r->TermWin.fheight - 5); 472 w + r->TermWin.fwidth - 4, r->TermWin.fheight - 4);
377 x += w; 473 x += w;
378 } 474 }
379 475
380 x += r->TermWin.fwidth; 476 x += r->TermWin.fwidth;
381 } 477 }
… …
390 486
391 rxvt_fontprop properties (); 487 rxvt_fontprop properties ();
392 488
393 bool load (const rxvt_fontprop &prop); 489 bool load (const rxvt_fontprop &prop);
394 490
395 bool has_codepoint (uint32_t unicode); 491 bool has_codepoint (unicode_t unicode);
396 492
397 void draw (rxvt_drawable &d, int x, int y, 493 void draw (rxvt_drawable &d, int x, int y,
398 const text_t *text, int len, 494 const text_t *text, int len,
399 int fg, int bg); 495 int fg, int bg);
400 496
… …
647 f = 0; 743 f = 0;
648 } 744 }
649} 745}
650 746
651bool 747bool
652rxvt_font_x11::has_codepoint (uint32_t unicode) 748rxvt_font_x11::has_codepoint (unicode_t unicode)
653{ 749{
654 uint32_t ch = FROM_UNICODE (cs, unicode); 750 uint32_t ch = FROM_UNICODE (cs, unicode);
655 751
656 if (ch == NOCHAR) 752 if (ch == NOCHAR)
657 return false; 753 return false;
… …
719 { 815 {
720 const XChar2b *xc = enc_xchar2b (text, len, cs, slow); 816 const XChar2b *xc = enc_xchar2b (text, len, cs, slow);
721 817
722 if (bg == Color_bg && !slow) 818 if (bg == Color_bg && !slow)
723 { 819 {
724 XChangeGC (d.display->display, GC, GCForeground | GCBackground | GCFont, &v); 820 XChangeGC (d.display->display, TGC, GCForeground | GCBackground | GCFont, &v);
725 XDrawImageString16 (d.display->display, d, GC, x, y + base, xc, len); 821 XDrawImageString16 (d.display->display, d, TGC, x, y + base, xc, len);
726 } 822 }
727 else 823 else
728 { 824 {
729 clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg); 825 clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
730 826
731 XChangeGC (d.display->display, GC, GCForeground | GCFont, &v); 827 XChangeGC (d.display->display, TGC, GCForeground | GCFont, &v);
732 828
733 if (slow) 829 if (slow)
734 { 830 {
735 do 831 do
736 { 832 {
737 if (xc->byte1 || xc->byte2) 833 if (xc->byte1 || xc->byte2)
738 XDrawString16 (d.display->display, d, GC, x, y + base, xc, 1); 834 XDrawString16 (d.display->display, d, TGC, x, y + base, xc, 1);
739 835
740 x += r->TermWin.fwidth; 836 x += r->TermWin.fwidth;
741 xc++; len--; 837 xc++; len--;
742 } 838 }
743 while (len); 839 while (len);
744 } 840 }
745 else 841 else
746 XDrawString16 (d.display->display, d, GC, x, y + base, xc, len); 842 XDrawString16 (d.display->display, d, TGC, x, y + base, xc, len);
747 } 843 }
748 } 844 }
749 else 845 else
750 { 846 {
751 const char *xc = enc_char (text, len, cs, slow); 847 const char *xc = enc_char (text, len, cs, slow);
752 848
753 if (bg == Color_bg && !slow) 849 if (bg == Color_bg && !slow)
754 { 850 {
755 XChangeGC (d.display->display, GC, GCForeground | GCBackground | GCFont, &v); 851 XChangeGC (d.display->display, TGC, GCForeground | GCBackground | GCFont, &v);
756 XDrawImageString (d.display->display, d, GC, x, y + base, xc, len); 852 XDrawImageString (d.display->display, d, TGC, x, y + base, xc, len);
757 } 853 }
758 else 854 else
759 { 855 {
760 clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg); 856 clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
761 857
762 XChangeGC (d.display->display, GC, GCForeground | GCFont, &v); 858 XChangeGC (d.display->display, TGC, GCForeground | GCFont, &v);
763 859
764 if (slow) 860 if (slow)
765 { 861 {
766 do 862 do
767 { 863 {
768 if (*xc) 864 if (*xc)
769 XDrawString (d.display->display, d, GC, x, y + base, xc, 1); 865 XDrawString (d.display->display, d, TGC, x, y + base, xc, 1);
770 866
771 x += r->TermWin.fwidth; 867 x += r->TermWin.fwidth;
772 xc++; len--; 868 xc++; len--;
773 } 869 }
774 while (len); 870 while (len);
775 } 871 }
776 else 872 else
777 XDrawString (d.display->display, d, GC, x, y + base, xc, len); 873 XDrawString (d.display->display, d, TGC, x, y + base, xc, len);
778 } 874 }
779 } 875 }
780} 876}
781 877
782///////////////////////////////////////////////////////////////////////////// 878/////////////////////////////////////////////////////////////////////////////
… …
799 895
800 void draw (rxvt_drawable &d, int x, int y, 896 void draw (rxvt_drawable &d, int x, int y,
801 const text_t *text, int len, 897 const text_t *text, int len,
802 int fg, int bg); 898 int fg, int bg);
803 899
804 bool has_codepoint (uint32_t unicode); 900 bool has_codepoint (unicode_t unicode);
805 901
806protected: 902protected:
807 XftFont *f; 903 XftFont *f;
808}; 904};
809 905
… …
922 1018
923 return true; 1019 return true;
924} 1020}
925 1021
926bool 1022bool
927rxvt_font_xft::has_codepoint (uint32_t unicode) 1023rxvt_font_xft::has_codepoint (unicode_t unicode)
928{ 1024{
929 return XftCharExists (DISPLAY, f, unicode); 1025 return XftCharExists (DISPLAY, f, unicode);
930} 1026}
931 1027
932void 1028void
… …
1135 1231
1136 return true; 1232 return true;
1137} 1233}
1138 1234
1139int 1235int
1140rxvt_fontset::find_font (uint32_t unicode) 1236rxvt_fontset::find_font (unicode_t unicode)
1141{ 1237{
1142 for (unsigned int i = 0; i < fonts.size (); i++) 1238 for (unsigned int i = 0; i < fonts.size (); i++)
1143 { 1239 {
1144 rxvt_font *f = fonts[i]; 1240 rxvt_font *f = fonts[i];
1145 1241

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines