~ubuntu-branches/ubuntu/trusty/xterm/trusty : revision 22

1

/* $XTermId: fontutils.c,v 1.278 2008/12/30 17:32:06 tom Exp $ */

1

/* $XTermId: fontutils.c,v 1.287 2009/01/27 01:57:22 tom Exp $ */

2

3

/************************************************************

4

5

6

7

8

545

static int

546

same_font_size(XtermWidget xw, XFontStruct * nfs, XFontStruct * bfs)

547

{

548

TScreen *screen = TScreenOf(xw);

548

549

TRACE(("same_font_size height %d/%d, min %d/%d max %d/%d\n",

549

550

nfs->ascent + nfs->descent,

550

551

bfs->ascent + bfs->descent,

551

552

nfs->min_bounds.width, bfs->min_bounds.width,

552

553

nfs->max_bounds.width, bfs->max_bounds.width));

553

return xw->screen.free_bold_box

554

return screen->free_bold_box

554

555

|| ((nfs->ascent + nfs->descent) == (bfs->ascent + bfs->descent)

555

556

&& (nfs->min_bounds.width == bfs->min_bounds.width

556

557

|| nfs->min_bounds.width == bfs->min_bounds.width + 1)

686

687

Bool code = False;

687

688

TScreen *screen = TScreenOf(xw);

688

689

if (name != 0

690

&& (result->fs = XLoadQueryFont(screen->display, name)) != 0) {

691

code = True;

692

if (EmptyFont(result->fs)) {

693

result = xtermCloseFont(xw, result);

694

code = False;

695

} else {

696

result->fn = x_strdup(name);

690

if (name != 0) {

691

if ((result->fs = XLoadQueryFont(screen->display, name)) != 0) {

692

code = True;

693

if (EmptyFont(result->fs)) {

694

result = xtermCloseFont(xw, result);

695

code = False;

696

} else {

697

result->fn = x_strdup(name);

698

}

699

} else if (strcmp(name, DEFFONT)) {

700

#if OPT_RENDERFONT

701

if (!UsingRenderFont(xw))

702

#endif

703

fprintf(stderr, "%s: cannot load font %s\n", ProgramName, name);

704

code = xtermOpenFont(xw, DEFFONT, result);

697

705

}

698

706

}

699

707

return code;

770

778

Bool doresize,

771

779

int fontnum)

772

780

{

773

TScreen *screen = &(xw->screen);

781

TScreen *screen = TScreenOf(xw);

774

782

VTwin *win = WhichVWin(screen);

775

783

776

784

VTFontNames myfonts;

780

788

Pixel new_revers;

781

789

char *tmpname = NULL;

782

790

char normal[MAX_FONTNAME];

783

Bool proportional = False;

791

Boolean proportional = False;

784

792

785

793

memset(&myfonts, 0, sizeof(myfonts));

786

794

memset(fnts, 0, sizeof(fnts));

1133

1141

* correspond to the VT100 resources.

1134

1142

*/

1135

1143

static Bool

1136

xtermLoadVTFonts(XtermWidget w, char *myName, char *myClass)

1144

xtermLoadVTFonts(XtermWidget xw, char *myName, char *myClass)

1137

1145

{

1138

1146

static Bool initialized = False;

1139

1147

static SubResourceRec original, referenceRec, subresourceRec;

1159

1167

};

1160

1168

Cardinal n, m;

1161

1169

Bool status = True;

1170

TScreen *screen = TScreenOf(xw);

1162

1171

1163

1172

if (!initialized) {

1164

1173

1165

1174

initialized = True;

1166

1175

TRACE(("xtermLoadVTFonts saving original\n"));

1167

original.default_font = w->misc.default_font;

1168

COPY_MENU_FONTS(w->screen, original);

1176

original.default_font = xw->misc.default_font;

1177

COPY_MENU_FONTS(xw->screen, original);

1169

1178

}

1170

1179

1171

1180

if (myName == 0 || *myName == 0) {

1172

1181

TRACE(("xtermLoadVTFonts restoring original\n"));

1173

w->misc.default_font = original.default_font;

1174

COPY_MENU_FONTS(original, w->screen);

1182

xw->misc.default_font = original.default_font;

1183

COPY_MENU_FONTS(original, xw->screen);

1175

1184

for (n = 0; n < XtNumber(original.menu_font_names); ++n)

1176

w->screen.MenuFontName(n) = original.MenuFontName(n);

1185

screen->MenuFontName(n) = original.MenuFontName(n);

1177

1186

} else {

1178

1187

TRACE(("xtermLoadVTFonts(%s, %s)\n", myName, myClass));

1179

1188

1180

1189

memset(&subresourceRec, 0, sizeof(subresourceRec));

1181

XtGetSubresources((Widget) w, (XtPointer) &subresourceRec,

1190

XtGetSubresources((Widget) xw, (XtPointer) &subresourceRec,

1182

1191

myName, myClass,

1183

1192

font_resources,

1184

1193

(Cardinal) XtNumber(font_resources),

1189

1198

/*

1190

1199

* If a particular resource value was not found, use the original.

1191

1200

*/

1192

MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_n);

1193

MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_b);

1201

MERGE_SUBFONT(xw->misc, subresourceRec, default_font.f_n);

1202

MERGE_SUBFONT(xw->misc, subresourceRec, default_font.f_b);

1194

1203

#if OPT_WIDE_CHARS

1195

MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_w);

1196

MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_wb);

1204

MERGE_SUBFONT(xw->misc, subresourceRec, default_font.f_w);

1205

MERGE_SUBFONT(xw->misc, subresourceRec, default_font.f_wb);

1197

1206

#endif

1198

1207

for (n = fontMenu_font1; n <= fontMenu_lastBuiltin; ++n)

1199

MERGE_SUBFONT(w->screen, subresourceRec, MenuFontName(n));

1208

MERGE_SUBFONT(xw->screen, subresourceRec, MenuFontName(n));

1200

1209

1201

1210

/*

1202

1211

* Finally, copy the subresource data to the widget.

1203

1212

*/

1204

w->misc.default_font = subresourceRec.default_font;

1205

COPY_MENU_FONTS(subresourceRec, w->screen);

1206

w->screen.MenuFontName(fontMenu_default) = w->misc.default_font.f_n;

1207

w->screen.menu_font_names[0][fBold] = w->misc.default_font.f_b;

1213

xw->misc.default_font = subresourceRec.default_font;

1214

COPY_MENU_FONTS(subresourceRec, xw->screen);

1215

screen->MenuFontName(fontMenu_default) = xw->misc.default_font.f_n;

1216

screen->menu_font_names[0][fBold] = xw->misc.default_font.f_b;

1208

1217

#if OPT_WIDE_CHARS

1209

w->screen.menu_font_names[0][fWide] = w->misc.default_font.f_w;

1210

w->screen.menu_font_names[0][fWBold] = w->misc.default_font.f_wb;

1218

screen->menu_font_names[0][fWide] = xw->misc.default_font.f_w;

1219

screen->menu_font_names[0][fWBold] = xw->misc.default_font.f_wb;

1211

1220

#endif

1212

1221

} else {

1213

1222

TRACE(("...no resources found\n"));

1246

1255

Bool

1247

1256

xtermLoadWideFonts(XtermWidget xw, Bool nullOk)

1248

1257

{

1249

TScreen *screen = &(xw->screen);

1258

TScreen *screen = TScreenOf(xw);

1250

1259

Bool result;

1251

1260

1252

1261

if (EmptyFont(screen->fnts[fWide].fs)) {

1273

1282

* Restore the default fonts, i.e., if we had switched to wide-fonts.

1274

1283

*/

1275

1284

Bool

1276

xtermLoadDefaultFonts(XtermWidget w)

1285

xtermLoadDefaultFonts(XtermWidget xw)

1277

1286

{

1278

1287

Bool result;

1279

result = xtermLoadVTFonts(w, NULL, NULL);

1288

result = xtermLoadVTFonts(xw, NULL, NULL);

1280

1289

TRACE(("xtermLoadDefaultFonts:%d\n", result));

1281

1290

return result;

1282

1291

}

1291

1300

{

1292

1301

static char empty[] = ""; /* appease strict compilers */

1293

1302

1294

if (IsXtermWidget(w)) {

1295

XtermWidget xw = (XtermWidget) w;

1303

XtermWidget xw;

1304

1305

if ((xw = getXtermWidget(w)) != 0) {

1306

TScreen *screen = TScreenOf(xw);

1296

1307

char buf[80];

1297

1308

char *myName = (*param_count > 0) ? params[0] : empty;

1298

1309

char *convert = (*param_count > 1) ? params[1] : myName;

1310

1321

* it is less surprising to do that (if the font-switching can be

1311

1322

* undone) than to switch to "Default".

1312

1323

*/

1313

int font_number = xw->screen.menu_font_number;

1324

int font_number = screen->menu_font_number;

1314

1325

if (font_number > fontMenu_lastBuiltin)

1315

1326

font_number = fontMenu_lastBuiltin;

1316

1327

for (n = 0; n < NMENUFONTS; ++n)

1317

xw->screen.menu_font_sizes[n] = 0;

1328

screen->menu_font_sizes[n] = 0;

1318

1329

SetVTFont(xw, font_number, True,

1319

1330

((font_number == fontMenu_default)

1320

1331

? &(xw->misc.default_font)

1471

1482

XFontStruct * font,

1472

1483

int sbwidth)

1473

1484

{

1474

TScreen *screen = &(xw->screen);

1485

TScreen *screen = TScreenOf(xw);

1475

1486

1476

1487

int i, j, width, height;

1477

1488

1555

1566

break;

1556

1567

}

1557

1568

#endif

1558

xw->misc.face_size[fontnum] = face_size;

1569

xw->misc.face_size[fontnum] = (float) face_size;

1559

1570

}

1560

1571

1561

1572

/*

1700

1711

j = 2 * screen->border;

1701

1712

width = MaxCols(screen) * win->f_width + i;

1702

1713

height = MaxRows(screen) * win->f_height + j;

1703

win->fullwidth = width;

1704

win->fullheight = height;

1714

win->fullwidth = (Dimension) width;

1715

win->fullheight = (Dimension) height;

1705

1716

win->width = width - i;

1706

1717

win->height = height - j;

1707

1718

1720

1731

void

1721

1732

xtermSaveFontInfo(TScreen * screen, XFontStruct * font)

1722

1733

{

1723

screen->fnt_wide = (font->max_bounds.width);

1724

screen->fnt_high = (font->ascent + font->descent);

1734

screen->fnt_wide = (Dimension) (font->max_bounds.width);

1735

screen->fnt_high = (Dimension) (font->ascent + font->descent);

1725

1736

TRACE(("xtermSaveFontInfo %dx%d\n", screen->fnt_high, screen->fnt_wide));

1726

1737

}

1727

1738

1731

1742

void

1732

1743

xtermUpdateFontInfo(XtermWidget xw, Bool doresize)

1733

1744

{

1734

TScreen *screen = &(xw->screen);

1745

TScreen *screen = TScreenOf(xw);

1735

1746

1736

1747

int scrollbar_width;

1737

1748

VTwin *win = &(screen->fullVwin);

1767

1778

Bool

1768

1779

xtermMissingChar(XtermWidget xw, unsigned ch, XFontStruct * font)

1769

1780

{

1781

TScreen *screen = TScreenOf(xw);

1782

1770

1783

if (font != 0

1771

1784

&& font->per_char != 0

1772

1785

&& !font->all_chars_exist) {

1797

1810

}

1798

1811

}

1799

1812

if (xtermIsDecGraphic(ch)

1800

&& xw->screen.force_box_chars) {

1813

&& screen->force_box_chars) {

1801

1814

TRACE(("xtermMissingChar %#04x (forced off)\n", ch));

1802

1815

return True;

1803

1816

}

1820

1833

/*

1821

1834

* ...since we'll scale the values anyway.

1822

1835

*/

1823

#define SCALE_X(n) n = (n * (font_width-1)) / (BOX_WIDE-1)

1824

#define SCALE_Y(n) n = (n * (font_height-1)) / (BOX_HIGH-1)

1836

#define SCALE_X(n) n = (n * (((int) font_width) - 1)) / (BOX_WIDE-1)

1837

#define SCALE_Y(n) n = (n * (((int) font_height) - 1)) / (BOX_HIGH-1)

1825

1838

1826

1839

#define SEG(x0,y0,x1,y1) x0,y0, x1,y1

1827

1840

1838

1851

int y,

1839

1852

int cells)

1840

1853

{

1841

TScreen *screen = &(xw->screen);

1854

TScreen *screen = TScreenOf(xw);

1842

1855

/* *INDENT-OFF* */

1843

1856

static const short glyph_ht[] = {

1844

1857

SEG(1*BOX_WIDE/10, 0, 1*BOX_WIDE/10,5*MID_HIGH/6), /* H */

2017

2030

CgsEnum cgsId = (ch == 2) ? gcDots : gcLine;

2018

2031

VTwin *cgsWin = WhichVWin(screen);

2019

2032

const short *p;

2020

unsigned font_width = ((flags & DOUBLEWFONT) ? 2 : 1) * screen->fnt_wide;

2021

unsigned font_height = ((flags & DOUBLEHFONT) ? 2 : 1) * screen->fnt_high;

2033

unsigned font_width = (unsigned) (((flags & DOUBLEWFONT) ? 2 : 1) * screen->fnt_wide);

2034

unsigned font_height = (unsigned) (((flags & DOUBLEHFONT) ? 2 : 1) * screen->fnt_high);

2022

2035

2023

2036

if (cells > 1)

2024

font_width *= cells;

2037

font_width *= (unsigned) cells;

2025

2038

2026

2039

#if OPT_WIDE_CHARS

2027

2040

/*

2121

2134

Convex, CoordModeOrigin);

2122

2135

} else if (ch == 7) { /* degrees */

2123

2136

unsigned width = (BOX_WIDE / 3);

2124

int x_coord = MID_WIDE - (width / 2);

2125

int y_coord = MID_HIGH - width;

2137

int x_coord = MID_WIDE - (int) (width / 2);

2138

int y_coord = MID_HIGH - (int) width;

2126

2139

2127

2140

SCALE_X(x_coord);

2128

2141

SCALE_Y(y_coord);

2135

2148

360 * 64);

2136

2149

} else if (ch == 0x1f) { /* bullet */

2137

2150

unsigned width = 7 * BOX_WIDE / 10;

2138

int x_coord = MID_WIDE - (width / 3);

2139

int y_coord = MID_HIGH - (width / 3);

2151

int x_coord = MID_WIDE - (int) (width / 3);

2152

int y_coord = MID_HIGH - (int) (width / 3);

2140

2153

2141

2154

SCALE_X(x_coord);

2142

2155

SCALE_Y(y_coord);

2149

2162

360 * 64);

2150

2163

} else if (ch < (sizeof(lines) / sizeof(lines[0]))

2151

2164

&& (p = lines[ch]) != 0) {

2152

unsigned coord[4];

2165

int coord[4];

2153

2166

int n = 0;

2154

2167

while (*p >= 0) {

2155

2168

coord[n++] = *p++;

2186

2199

Bool result = False;

2187

2200

2188

2201

if (font != 0) {

2189

if (!XftGlyphExists(xw->screen.display, font, wc)) {

2202

TScreen *screen = TScreenOf(xw);

2203

if (!XftGlyphExists(screen->display, font, wc)) {

2190

2204

#if OPT_WIDE_CHARS

2191

2205

TRACE(("xtermXftMissing %d (dec=%#x, ucs=%#x)\n",

2192

2206

wc, ucs2dec(wc), dec2ucs(wc)));

2345

2359

break;

2346

2360

}

2347

2361

}

2362

if (!result) {

2363

Boolean broken_fonts = True;

2364

TScreen *screen = TScreenOf(xw);

2365

int first = screen->menu_font_sizes[0];

2366

2367

lookupFontSizes(xw);

2368

for (n = 0; n < NMENUFONTS; n++) {

2369

if (screen->menu_font_sizes[n] > 0

2370

&& screen->menu_font_sizes[n] != first) {

2371

broken_fonts = False;

2372

break;

2373

}

2374

}

2375

2376

/*

2377

* Workaround for breakage in font-packages - check if all of the

2378

* bitmap font sizes are the same, and if we're using TrueType

2379

* fonts.

2380

*/

2381

if (broken_fonts) {

2382

float lo_value = (float) 9.0e9;

2383

float hi_value = (float) 0.0;

2384

float value;

2385

2386

TRACE(("bitmap fonts are broken - set faceSize resources\n"));

2387

for (n = 0; n < NMENUFONTS; n++) {

2388

value = xw->misc.face_size[n];

2389

if (value > 0.0) {

2390

if (lo_value > value)

2391

lo_value = value;

2392

if (hi_value < value)

2393

hi_value = value;

2394

}

2395

}

2396

2397

if (hi_value <= 0.0)

2398

sscanf(DEFFACESIZE, "%f", &value);

2399

else

2400

value = (float) ((hi_value + lo_value) / 2.0);

2401

if (value <= 0)

2402

value = (float) 14.0;

2403

2404

for (n = 0; n < NMENUFONTS; n++) {

2405

TRACE(("setting faceSize%d %.1f\n", n, value));

2406

xw->misc.face_size[n] = value;

2407

value = (float) (value * 1.1);

2408

}

2409

result = True;

2410

}

2411

}

2348

2412

}

2349

2413

return result;

2350

2414

}

2430

2494

String * params GCC_UNUSED,

2431

2495

Cardinal *param_count GCC_UNUSED)

2432

2496

{

2433

if (IsXtermWidget(w)) {

2434

XtermWidget xw = (XtermWidget) w;

2497

XtermWidget xw;

2435

2498

2499

TRACE(("Handle larger-vt-font for %p\n", w));

2500

if ((xw = getXtermWidget(w)) != 0) {

2436

2501

if (xw->misc.shift_fonts) {

2437

TScreen *screen = &xw->screen;

2502

TScreen *screen = TScreenOf(xw);

2438

2503

int m;

2439

2504

2440

2505

m = lookupRelativeFontSize(xw, screen->menu_font_number, 1);

2454

2519

String * params GCC_UNUSED,

2455

2520

Cardinal *param_count GCC_UNUSED)

2456

2521

{

2457

if (IsXtermWidget(w)) {

2458

XtermWidget xw = (XtermWidget) w;

2522

XtermWidget xw;

2459

2523

2524

TRACE(("Handle smaller-vt-font for %p\n", w));

2525

if ((xw = getXtermWidget(w)) != 0) {

2460

2526

if (xw->misc.shift_fonts) {

2461

TScreen *screen = &xw->screen;

2527

TScreen *screen = TScreenOf(xw);

2462

2528

int m;

2463

2529

2464

2530

m = lookupRelativeFontSize(xw, screen->menu_font_number, -1);

2523

2589

String * params,

2524

2590

Cardinal *param_count)

2525

2591

{

2526

if (IsXtermWidget(w)) {

2592

XtermWidget xw;

2593

2594

if ((xw = getXtermWidget(w)) != 0) {

2527

2595

int fontnum;

2528

2596

VTFontNames fonts;

2529

2597

2582

2650

}

2583

2651

}

2584

2652

2585

SetVTFont((XtermWidget) w, fontnum, True, &fonts);

2653

SetVTFont(xw, fontnum, True, &fonts);

2586

2654

}

2587

2655

}

2588

2656

2592

2660

Bool doresize,

2593

2661

const VTFontNames * fonts)

2594

2662

{

2595

TScreen *screen = &xw->screen;

2663

TScreen *screen = TScreenOf(xw);

2596

2664

2597

2665

TRACE(("SetVTFont(which=%d, f_n=%s, f_b=%s)\n", which,

2598

2666

(fonts && fonts->f_n) ? fonts->f_n : "<null>",