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.32 by pcg, Thu Mar 4 00:59:10 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;
294
280 if (unicode >= 0x0080 && unicode <= 0x009f) 295 if (unicode >= 0x0080 && unicode <= 0x009f)
281 return true; 296 return true;
282 297
283 if (unicode >= 0x2500 && unicode <= 0x257f 298 if (unicode >= 0x2500 && unicode <= 0x257f
284 && linedraw_cmds[unicode - 0x2500]) 299 && linedraw_cmds[unicode - 0x2500])
300 return true;
301
302 if (unicode >= 0x2580 && unicode <= 0x259f)
303 return true;
304
305 if (IS_COMPOSE (unicode))
285 return true; 306 return true;
286 307
287 switch (unicode) 308 switch (unicode)
288 { 309 {
289 case ZERO_WIDTH_CHAR: 310 case ZERO_WIDTH_CHAR:
… …
296 void draw (rxvt_drawable &d, int x, int y, 317 void draw (rxvt_drawable &d, int x, int y,
297 const text_t *text, int len, 318 const text_t *text, int len,
298 int fg, int bg); 319 int fg, int bg);
299}; 320};
300 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
301void 344void
302rxvt_font_default::draw (rxvt_drawable &d, int x, int y, 345rxvt_font_default::draw (rxvt_drawable &d, int x, int y,
303 const text_t *text, int len, 346 const text_t *text, int len,
304 int fg, int bg) 347 int fg, int bg)
305{ 348{
306 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);
307 350
308 XSetForeground (d.display->display, GC, r->PixColors[fg]); 351 XSetForeground (d.display->display, TGC, r->PixColors[fg]);
309 352
310 while (len--) 353 while (len--)
311 { 354 {
355#if ENABLE_COMBINING
356 compose_char *cc;
357#endif
312 text_t t = *text++; 358 text_t t = *text++;
313 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
314 // is it in our linedrawing table? 365 // is it in our linedrawing table?
315 if (t >= 0x2500 & t <= 0x2580 && linedraw_cmds[t - 0x2500]) 366 if (t >= 0x2500 & t <= 0x259f && linedraw_cmds[t - 0x2500])
316 { 367 {
317 const char *p = linedraw_cmds[t - 0x2500]; 368 const char *p = linedraw_cmds[t - 0x2500];
318 369
319 int x0 = x, x1 = x + (r->TermWin.fwidth - 1) / 2, x2 = x + r->TermWin.fwidth - 1;
320 int y0 = y, y1 = y + (r->TermWin.fheight - 1) / 2, y2 = y + r->TermWin.fheight - 1;
321
322 XGCValues gcv; 370 XGCValues gcv;
371
372 gcv.cap_style = CapNotLast;
373 XChangeGC (d.display->display, TGC, GCCapStyle, &gcv);
323 374
324 while (*p) 375 while (*p)
325 { 376 {
326 switch (*p++) 377 switch (*p++)
327 { 378 {
328 case '1': 379 case '1':
329 gcv.line_width = 0; 380 gcv.line_width = 0;
330 XChangeGC (d.display->display, GC, GCLineWidth, &gcv); 381 XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
331 break; 382 break;
332 383
333 case '2': 384 case '2':
334 gcv.line_width = 2; 385 gcv.line_width = 3;
335 XChangeGC (d.display->display, GC, GCLineWidth, &gcv); 386 XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
336 break; 387 break;
337 388
338 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;
339 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;
340 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;
341 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
342 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;
343 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;
344 } 408 }
345 } 409 }
346 410
347 gcv.line_width = 0; 411 gcv.line_width = 0;
348 XChangeGC (d.display->display, GC, GCLineWidth, &gcv); 412 XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
413 }
414
415#if ENABLE_COMBINING
416 else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
349 } 417 {
418 rxvt_font *f1 = (*fs)[fs->find_font (cc->c1)];
419 f1->draw (d, x, y, &(t = cc->c1), 1, fg, bg);
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
427 f2->draw (d, x, y, &(t = cc->c2), 1, fg, -1);
428 }
429 }
430#endif
350 else 431 else
351 switch (t) 432 switch (t)
352 { 433 {
353 case ZERO_WIDTH_CHAR: 434 case ZERO_WIDTH_CHAR:
354 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
355 default: 462 default:
356 int w = 0; 463 int w = 0;
357 while (len > 0 && *text == NOCHAR) 464 while (len > 0 && *text == NOCHAR)
358 { 465 {
359 ++text; 466 ++text;
360 --len; 467 --len;
361 w += r->TermWin.fwidth; 468 w += r->TermWin.fwidth;
362 } 469 }
363 470
364 XDrawRectangle (d.display->display, d, GC, x + 2, y + 2, 471 XDrawRectangle (d.display->display, d, TGC, x + 2, y + 2,
365 w + r->TermWin.fwidth - 5, r->TermWin.fheight - 5); 472 w + r->TermWin.fwidth - 4, r->TermWin.fheight - 4);
366 x += w; 473 x += w;
367 } 474 }
368 475
369 x += r->TermWin.fwidth; 476 x += r->TermWin.fwidth;
370 } 477 }
… …
379 486
380 rxvt_fontprop properties (); 487 rxvt_fontprop properties ();
381 488
382 bool load (const rxvt_fontprop &prop); 489 bool load (const rxvt_fontprop &prop);
383 490
384 bool has_codepoint (uint32_t unicode); 491 bool has_codepoint (unicode_t unicode);
385 492
386 void draw (rxvt_drawable &d, int x, int y, 493 void draw (rxvt_drawable &d, int x, int y,
387 const text_t *text, int len, 494 const text_t *text, int len,
388 int fg, int bg); 495 int fg, int bg);
389 496
… …
636 f = 0; 743 f = 0;
637 } 744 }
638} 745}
639 746
640bool 747bool
641rxvt_font_x11::has_codepoint (uint32_t unicode) 748rxvt_font_x11::has_codepoint (unicode_t unicode)
642{ 749{
643 uint32_t ch = FROM_UNICODE (cs, unicode); 750 uint32_t ch = FROM_UNICODE (cs, unicode);
644 751
645 if (ch == NOCHAR) 752 if (ch == NOCHAR)
646 return false; 753 return false;
… …
708 { 815 {
709 const XChar2b *xc = enc_xchar2b (text, len, cs, slow); 816 const XChar2b *xc = enc_xchar2b (text, len, cs, slow);
710 817
711 if (bg == Color_bg && !slow) 818 if (bg == Color_bg && !slow)
712 { 819 {
713 XChangeGC (d.display->display, GC, GCForeground | GCBackground | GCFont, &v); 820 XChangeGC (d.display->display, TGC, GCForeground | GCBackground | GCFont, &v);
714 XDrawImageString16 (d.display->display, d, GC, x, y + base, xc, len); 821 XDrawImageString16 (d.display->display, d, TGC, x, y + base, xc, len);
715 } 822 }
716 else 823 else
717 { 824 {
718 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);
719 826
720 XChangeGC (d.display->display, GC, GCForeground | GCFont, &v); 827 XChangeGC (d.display->display, TGC, GCForeground | GCFont, &v);
721 828
722 if (slow) 829 if (slow)
723 { 830 {
724 do 831 do
725 { 832 {
726 if (xc->byte1 || xc->byte2) 833 if (xc->byte1 || xc->byte2)
727 XDrawString16 (d.display->display, d, GC, x, y + base, xc, 1); 834 XDrawString16 (d.display->display, d, TGC, x, y + base, xc, 1);
728 835
729 x += r->TermWin.fwidth; 836 x += r->TermWin.fwidth;
730 xc++; len--; 837 xc++; len--;
731 } 838 }
732 while (len); 839 while (len);
733 } 840 }
734 else 841 else
735 XDrawString16 (d.display->display, d, GC, x, y + base, xc, len); 842 XDrawString16 (d.display->display, d, TGC, x, y + base, xc, len);
736 } 843 }
737 } 844 }
738 else 845 else
739 { 846 {
740 const char *xc = enc_char (text, len, cs, slow); 847 const char *xc = enc_char (text, len, cs, slow);
741 848
742 if (bg == Color_bg && !slow) 849 if (bg == Color_bg && !slow)
743 { 850 {
744 XChangeGC (d.display->display, GC, GCForeground | GCBackground | GCFont, &v); 851 XChangeGC (d.display->display, TGC, GCForeground | GCBackground | GCFont, &v);
745 XDrawImageString (d.display->display, d, GC, x, y + base, xc, len); 852 XDrawImageString (d.display->display, d, TGC, x, y + base, xc, len);
746 } 853 }
747 else 854 else
748 { 855 {
749 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);
750 857
751 XChangeGC (d.display->display, GC, GCForeground | GCFont, &v); 858 XChangeGC (d.display->display, TGC, GCForeground | GCFont, &v);
752 859
753 if (slow) 860 if (slow)
754 { 861 {
755 do 862 do
756 { 863 {
757 if (*xc) 864 if (*xc)
758 XDrawString (d.display->display, d, GC, x, y + base, xc, 1); 865 XDrawString (d.display->display, d, TGC, x, y + base, xc, 1);
759 866
760 x += r->TermWin.fwidth; 867 x += r->TermWin.fwidth;
761 xc++; len--; 868 xc++; len--;
762 } 869 }
763 while (len); 870 while (len);
764 } 871 }
765 else 872 else
766 XDrawString (d.display->display, d, GC, x, y + base, xc, len); 873 XDrawString (d.display->display, d, TGC, x, y + base, xc, len);
767 } 874 }
768 } 875 }
769} 876}
770 877
771///////////////////////////////////////////////////////////////////////////// 878/////////////////////////////////////////////////////////////////////////////
… …
788 895
789 void draw (rxvt_drawable &d, int x, int y, 896 void draw (rxvt_drawable &d, int x, int y,
790 const text_t *text, int len, 897 const text_t *text, int len,
791 int fg, int bg); 898 int fg, int bg);
792 899
793 bool has_codepoint (uint32_t unicode); 900 bool has_codepoint (unicode_t unicode);
794 901
795protected: 902protected:
796 XftFont *f; 903 XftFont *f;
797}; 904};
798 905
… …
911 1018
912 return true; 1019 return true;
913} 1020}
914 1021
915bool 1022bool
916rxvt_font_xft::has_codepoint (uint32_t unicode) 1023rxvt_font_xft::has_codepoint (unicode_t unicode)
917{ 1024{
918 return XftCharExists (DISPLAY, f, unicode); 1025 return XftCharExists (DISPLAY, f, unicode);
919} 1026}
920 1027
921void 1028void
… …
1017 f = new rxvt_font_x11; 1124 f = new rxvt_font_x11;
1018 } 1125 }
1019 else 1126 else
1020 f = new rxvt_font_x11; 1127 f = new rxvt_font_x11;
1021 1128
1129 f->fs = this;
1022 f->set_term (r); 1130 f->set_term (r);
1023 f->set_name (strdup (name)); 1131 f->set_name (strdup (name));
1024 1132
1025 f->cs = cs; 1133 f->cs = cs;
1026 f->loaded = false; 1134 f->loaded = false;
… …
1097 1205
1098bool 1206bool
1099rxvt_fontset::populate (const char *desc) 1207rxvt_fontset::populate (const char *desc)
1100{ 1208{
1101 clear (); 1209 clear ();
1102 printf ("P(%s)\n",desc);
1103 1210
1104 fonts.push_back (new_font (0, CS_UNICODE)); 1211 fonts.push_back (new_font (0, CS_UNICODE));
1105 realize_font (0); 1212 realize_font (0);
1106 1213
1107 add_fonts (desc); 1214 add_fonts (desc);
… …
1124 1231
1125 return true; 1232 return true;
1126} 1233}
1127 1234
1128int 1235int
1129rxvt_fontset::find_font (uint32_t unicode) 1236rxvt_fontset::find_font (unicode_t unicode)
1130{ 1237{
1131 for (unsigned int i = 0; i < fonts.size (); i++) 1238 for (unsigned int i = 0; i < fonts.size (); i++)
1132 { 1239 {
1133 rxvt_font *f = fonts[i]; 1240 rxvt_font *f = fonts[i];
1134 1241

Diff Legend

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