Files @ r28396:ef195b601c72
Branch filter:

Location: cpp/openttd-patchpack/source/src/gfx.cpp - annotation

Peter Nelson
Fix: Pass townnameparts as parameter when testing townname based companyname. (#11685)

Length of returned string could vary and pass/fail the length check with a different
string than the final selection.
   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r9111:983de9c5a848
r6179:c0508e7aefec
r5584:545d748cc681
r20451:b5d6ba20db90
r17969:8bce9c292da9
r8123:dde0a9a84019
r6937:bea726150bf3
r7170:38b143754b40
r8114:866ed489ed98
r8270:c2ec53375c9d
r14228:592af9c022e2
r9898:bbef3303e005
r26434:8e267535a2cf
r12363:a1aeeb108457
r15095:a1fdff095c29
r26144:b9833b487524
r27400:742251af6ade
r26434:8e267535a2cf
r5584:545d748cc681
r22167:098e772ecba0
r8264:d493cb51fe8a
r8264:d493cb51fe8a
r8264:d493cb51fe8a
r21383:942c32fb8b0e
r21383:942c32fb8b0e
r6179:c0508e7aefec
r5636:6c8aae9c58e6
r21421:7897be36f196
r5636:6c8aae9c58e6
r6179:c0508e7aefec
r6179:c0508e7aefec
r27737:728d55b97775
r8857:5317aca8d1c7
r8857:5317aca8d1c7
r8857:5317aca8d1c7
r8857:5317aca8d1c7
r5636:6c8aae9c58e6
r8249:a0dc5dc66483
r25710:60c9c8536270
r11222:f66b1fc27a15
r11223:d5864a79dfb6
r27371:b9ad4c1bff08
r23680:22892a275fd4
r13693:eeeac228d9d9
r13498:598a539466dc
r8123:dde0a9a84019
r25725:e1fbdd2a5f81
r23607:36c15679007d
r23607:36c15679007d
r5584:545d748cc681
r27737:728d55b97775
r7545:2cbf405181b3
r27112:f42d2af96b0b
r27112:f42d2af96b0b
r27112:f42d2af96b0b
r27112:f42d2af96b0b
r24794:5703ff4448b2
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r5584:545d748cc681
r11082:09fb79759019
r27106:2d95beb51290
r5584:545d748cc681
r15175:66e0817dc450
r15175:66e0817dc450
r15175:66e0817dc450
r8985:72eff2815e83
r23607:36c15679007d
r19177:5af5e9926930
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r21124:6022cb131374
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9898:bbef3303e005
r14228:592af9c022e2
r5584:545d748cc681
r6951:4f69e3e27c06
r6179:c0508e7aefec
r21436:38079fc3bcd8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r11085:c87a330fb4c2
r9607:03e00693be33
r11082:09fb79759019
r9607:03e00693be33
r11085:c87a330fb4c2
r9607:03e00693be33
r11082:09fb79759019
r5584:545d748cc681
r21124:6022cb131374
r6878:61440e99046f
r6878:61440e99046f
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6624:8e8cb5121304
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6937:bea726150bf3
r5584:545d748cc681
r9607:03e00693be33
r9607:03e00693be33
r27737:728d55b97775
r9607:03e00693be33
r9607:03e00693be33
r11085:c87a330fb4c2
r11085:c87a330fb4c2
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r27737:728d55b97775
r9607:03e00693be33
r9607:03e00693be33
r9607:03e00693be33
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24597:afde5721a3b6
r24597:afde5721a3b6
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r27737:728d55b97775
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r27737:728d55b97775
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r24036:c554f8162b01
r20145:0db6f885542d
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20867:4c73931375e5
r20146:d805359147ef
r27737:728d55b97775
r20146:d805359147ef
r21124:6022cb131374
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r22151:340fa20ac2f5
r22151:340fa20ac2f5
r22151:340fa20ac2f5
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r22149:1c4835fbc88a
r22201:5ce5b50935d0
r22149:1c4835fbc88a
r22149:1c4835fbc88a
r20146:d805359147ef
r20146:d805359147ef
r24597:afde5721a3b6
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r22149:1c4835fbc88a
r22149:1c4835fbc88a
r22150:55253c66c9e8
r22150:55253c66c9e8
r22149:1c4835fbc88a
r22149:1c4835fbc88a
r22149:1c4835fbc88a
r22149:1c4835fbc88a
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r23838:bfeaabaa7b1d
r20146:d805359147ef
r20867:4c73931375e5
r20146:d805359147ef
r20146:d805359147ef
r20146:d805359147ef
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20867:4c73931375e5
r5584:545d748cc681
r6948:a40a825a4044
r20145:0db6f885542d
r20867:4c73931375e5
r20145:0db6f885542d
r5584:545d748cc681
r5584:545d748cc681
r11082:09fb79759019
r7651:88ef02a1f707
r7651:88ef02a1f707
r20145:0db6f885542d
r20146:d805359147ef
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r20145:0db6f885542d
r7651:88ef02a1f707
r7651:88ef02a1f707
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r17647:d4b47933b13c
r7643:9ec38df7caf3
r11082:09fb79759019
r11082:09fb79759019
r11082:09fb79759019
r7643:9ec38df7caf3
r11082:09fb79759019
r11082:09fb79759019
r11082:09fb79759019
r11082:09fb79759019
r11082:09fb79759019
r11082:09fb79759019
r7643:9ec38df7caf3
r7643:9ec38df7caf3
r11087:d97e4868e4c8
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r28212:27c374342e82
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r16894:4e74032de978
r16894:4e74032de978
r16896:7d6e4876f558
r16896:7d6e4876f558
r23984:68c55dd06ad8
r16894:4e74032de978
r17637:0d7e49507a12
r17637:0d7e49507a12
r11087:d97e4868e4c8
r11087:d97e4868e4c8
r5584:545d748cc681
r12163:3f9efbd13983
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20523:5dafe87c5a9a
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r23599:b4bf61c1f787
r20451:b5d6ba20db90
r23599:b4bf61c1f787
r20451:b5d6ba20db90
r23599:b4bf61c1f787
r23599:b4bf61c1f787
r20451:b5d6ba20db90
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20523:5dafe87c5a9a
r20452:fd8249cd9588
r23607:36c15679007d
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r28038:cee5bc8943d9
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r26578:600ca52b97e6
r26578:600ca52b97e6
r21368:28b548873115
r21368:28b548873115
r23599:b4bf61c1f787
r23599:b4bf61c1f787
r28038:cee5bc8943d9
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r21368:28b548873115
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20463:0092c8f7395a
r20451:b5d6ba20db90
r21657:3a07e4f14efa
r20451:b5d6ba20db90
r23598:7da4fa077a86
r23598:7da4fa077a86
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r23598:7da4fa077a86
r23598:7da4fa077a86
r23598:7da4fa077a86
r20451:b5d6ba20db90
r20452:fd8249cd9588
r20463:0092c8f7395a
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20463:0092c8f7395a
r20463:0092c8f7395a
r20463:0092c8f7395a
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r26578:600ca52b97e6
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r21368:28b548873115
r21368:28b548873115
r26578:600ca52b97e6
r21368:28b548873115
r21368:28b548873115
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20452:fd8249cd9588
r20451:b5d6ba20db90
r28141:3bc9b3b6a9b4
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r20451:b5d6ba20db90
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r23940:fb62ef155ce0
r23940:fb62ef155ce0
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r18420:dd047dbfb7e6
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r11416:46dd592974ed
r27288:52957325547f
r11416:46dd592974ed
r20538:8bef30d1ed50
r28167:b14ea36d49e5
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r20462:7ee7f450b05b
r28025:9116d6e411b0
r20456:0170ff7ae55b
r23599:b4bf61c1f787
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r23940:fb62ef155ce0
r23940:fb62ef155ce0
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r18420:dd047dbfb7e6
r20538:8bef30d1ed50
r20538:8bef30d1ed50
r11416:46dd592974ed
r18420:dd047dbfb7e6
r11416:46dd592974ed
r27413:b706f5407370
r11416:46dd592974ed
r11416:46dd592974ed
r11416:46dd592974ed
r15610:623a23fb6560
r9682:4ecd68d88958
r9682:4ecd68d88958
r9682:4ecd68d88958
r9682:4ecd68d88958
r27288:52957325547f
r20456:0170ff7ae55b
r28162:594ad3dc2dc9
r20772:bf3b8b08485d
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r9682:4ecd68d88958
r9682:4ecd68d88958
r27413:b706f5407370
r9682:4ecd68d88958
r9682:4ecd68d88958
r15610:623a23fb6560
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r27413:b706f5407370
r23553:9f01781fc43d
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r20330:9b5e242a7ad7
r15610:623a23fb6560
r12889:4dac96280866
r12889:4dac96280866
r12889:4dac96280866
r12889:4dac96280866
r12889:4dac96280866
r12889:4dac96280866
r22201:5ce5b50935d0
r12889:4dac96280866
r12889:4dac96280866
r9682:4ecd68d88958
r18931:8df96aa03d81
r18931:8df96aa03d81
r18931:8df96aa03d81
r18931:8df96aa03d81
r18931:8df96aa03d81
r18931:8df96aa03d81
r27288:52957325547f
r18931:8df96aa03d81
r22201:5ce5b50935d0
r18931:8df96aa03d81
r18931:8df96aa03d81
r18931:8df96aa03d81
r11433:03825b37bea9
r11433:03825b37bea9
r11433:03825b37bea9
r11433:03825b37bea9
r11433:03825b37bea9
r11433:03825b37bea9
r11433:03825b37bea9
r11433:03825b37bea9
r23940:fb62ef155ce0
r23940:fb62ef155ce0
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r18420:dd047dbfb7e6
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r27288:52957325547f
r15586:ce27c3bf8845
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r23599:b4bf61c1f787
r20456:0170ff7ae55b
r20953:64db27cf67a7
r26363:e03106ccb2d5
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r23599:b4bf61c1f787
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r23940:fb62ef155ce0
r23940:fb62ef155ce0
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r18420:dd047dbfb7e6
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r18420:dd047dbfb7e6
r15586:ce27c3bf8845
r27413:b706f5407370
r15586:ce27c3bf8845
r15586:ce27c3bf8845
r15610:623a23fb6560
r15610:623a23fb6560
r8121:d05602c69734
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15266:9249eb0a8ece
r15613:193c12018337
r15613:193c12018337
r27288:52957325547f
r5584:545d748cc681
r20456:0170ff7ae55b
r20456:0170ff7ae55b
r5584:545d748cc681
r5584:545d748cc681
r9773:820f87546490
r23023:7b8669afd1db
r27288:52957325547f
r12247:7a83d651bc47
r12247:7a83d651bc47
r12247:7a83d651bc47
r26573:6582b7725071
r12247:7a83d651bc47
r27413:b706f5407370
r12247:7a83d651bc47
r12247:7a83d651bc47
r12247:7a83d651bc47
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r26698:959ec0cf0684
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r27288:52957325547f
r20613:8e39d5a2a85b
r27288:52957325547f
r27288:52957325547f
r27288:52957325547f
r27288:52957325547f
r20613:8e39d5a2a85b
r27288:52957325547f
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20613:8e39d5a2a85b
r20653:cbfc7f1af4ff
r20653:cbfc7f1af4ff
r20653:cbfc7f1af4ff
r20653:cbfc7f1af4ff
r27288:52957325547f
r20653:cbfc7f1af4ff
r27288:52957325547f
r20653:cbfc7f1af4ff
r27288:52957325547f
r20653:cbfc7f1af4ff
r20653:cbfc7f1af4ff
r27901:d0a1e7017e52
r20653:cbfc7f1af4ff
r20653:cbfc7f1af4ff
r20653:cbfc7f1af4ff
r9773:820f87546490
r9773:820f87546490
r25320:6bbcfa7c9984
r23940:fb62ef155ce0
r23940:fb62ef155ce0
r9773:820f87546490
r27737:728d55b97775
r8737:36bd0e7321ea
r11087:d97e4868e4c8
r25320:6bbcfa7c9984
r25320:6bbcfa7c9984
r28167:b14ea36d49e5
r25320:6bbcfa7c9984
r8737:36bd0e7321ea
r8737:36bd0e7321ea
r15610:623a23fb6560
r12247:7a83d651bc47
r12247:7a83d651bc47
r23023:7b8669afd1db
r24251:23aaa17e40da
r12247:7a83d651bc47
r12247:7a83d651bc47
r12247:7a83d651bc47
r18462:a1ba75a7f741
r12247:7a83d651bc47
r27106:2d95beb51290
r12247:7a83d651bc47
r23607:36c15679007d
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r17818:abbc5e1a4eaa
r17818:abbc5e1a4eaa
r12247:7a83d651bc47
r24597:afde5721a3b6
r24597:afde5721a3b6
r12247:7a83d651bc47
r12247:7a83d651bc47
r12247:7a83d651bc47
r12247:7a83d651bc47
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r21823:934ee4e81d60
r18462:a1ba75a7f741
r9773:820f87546490
r9773:820f87546490
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r9773:820f87546490
r9773:820f87546490
r18462:a1ba75a7f741
r5584:545d748cc681
r15095:a1fdff095c29
r7928:a80e7e05d6c5
r28330:f8a96633c381
r28330:f8a96633c381
r28330:f8a96633c381
r5668:e62c2fbafb7b
r21819:cc6df44efba2
r21819:cc6df44efba2
r21819:cc6df44efba2
r27106:2d95beb51290
r21819:cc6df44efba2
r27106:2d95beb51290
r5584:545d748cc681
r27106:2d95beb51290
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r28330:f8a96633c381
r28330:f8a96633c381
r28330:f8a96633c381
r18462:a1ba75a7f741
r21819:cc6df44efba2
r21819:cc6df44efba2
r21819:cc6df44efba2
r27106:2d95beb51290
r21819:cc6df44efba2
r27106:2d95beb51290
r18462:a1ba75a7f741
r27106:2d95beb51290
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r25984:e5fd5e0b5e49
r5584:545d748cc681
r25984:e5fd5e0b5e49
r6852:5b6b567a9e32
r5584:545d748cc681
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r6804:418e2c5cd7f4
r5584:545d748cc681
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r23607:36c15679007d
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r24597:afde5721a3b6
r24597:afde5721a3b6
r24597:afde5721a3b6
r24597:afde5721a3b6
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21118:2c438482bb22
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21119:79131492dfcb
r18462:a1ba75a7f741
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21118:2c438482bb22
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21118:2c438482bb22
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21119:79131492dfcb
r18462:a1ba75a7f741
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21119:79131492dfcb
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21118:2c438482bb22
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21124:6022cb131374
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r23535:9604c18808f0
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r21124:6022cb131374
r18462:a1ba75a7f741
r18462:a1ba75a7f741
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r26144:b9833b487524
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r27737:728d55b97775
r25984:e5fd5e0b5e49
r26144:b9833b487524
r26144:b9833b487524
r26144:b9833b487524
r25984:e5fd5e0b5e49
r26147:b775ce6223ef
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r27106:2d95beb51290
r26144:b9833b487524
r26711:a4f8e9c41dea
r27737:728d55b97775
r26144:b9833b487524
r26711:a4f8e9c41dea
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r26144:b9833b487524
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r26144:b9833b487524
r26144:b9833b487524
r26144:b9833b487524
r25984:e5fd5e0b5e49
r26711:a4f8e9c41dea
r26711:a4f8e9c41dea
r26147:b775ce6223ef
r26147:b775ce6223ef
r26147:b775ce6223ef
r26711:a4f8e9c41dea
r26711:a4f8e9c41dea
r26147:b775ce6223ef
r26147:b775ce6223ef
r26147:b775ce6223ef
r26147:b775ce6223ef
r25984:e5fd5e0b5e49
r26144:b9833b487524
r26144:b9833b487524
r26144:b9833b487524
r25984:e5fd5e0b5e49
r26147:b775ce6223ef
r26147:b775ce6223ef
r27737:728d55b97775
r26147:b775ce6223ef
r26711:a4f8e9c41dea
r26147:b775ce6223ef
r26147:b775ce6223ef
r26147:b775ce6223ef
r26147:b775ce6223ef
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r25984:e5fd5e0b5e49
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r21118:2c438482bb22
r18615:58609f373bce
r18615:58609f373bce
r18615:58609f373bce
r18615:58609f373bce
r18615:58609f373bce
r5584:545d748cc681
r23357:ee1931a5afcf
r23357:ee1931a5afcf
r18615:58609f373bce
r13693:eeeac228d9d9
r13693:eeeac228d9d9
r13693:eeeac228d9d9
r19156:25ebf63399f9
r5584:545d748cc681
r5584:545d748cc681
r9773:820f87546490
r9773:820f87546490
r9773:820f87546490
r9773:820f87546490
r9773:820f87546490
r9773:820f87546490
r27737:728d55b97775
r5584:545d748cc681
r9773:820f87546490
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r24597:afde5721a3b6
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r14022:b29f3a76f3c3
r20303:6adbc75a1297
r20304:8660c225f9a8
r23023:7b8669afd1db
r23023:7b8669afd1db
r20303:6adbc75a1297
r20303:6adbc75a1297
r20304:8660c225f9a8
r20303:6adbc75a1297
r20304:8660c225f9a8
r20304:8660c225f9a8
r20304:8660c225f9a8
r20303:6adbc75a1297
r20303:6adbc75a1297
r20304:8660c225f9a8
r20304:8660c225f9a8
r20303:6adbc75a1297
r20303:6adbc75a1297
r20303:6adbc75a1297
r5584:545d748cc681
r6247:96e840dbefcc
r5584:545d748cc681
r15040:2d5282cc0907
r26711:a4f8e9c41dea
r8985:72eff2815e83
r6179:c0508e7aefec
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6179:c0508e7aefec
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6247:96e840dbefcc
r5584:545d748cc681
r24901:373764ef362c
r24901:373764ef362c
r24901:373764ef362c
r11393:7f81c686e5e2
r23607:36c15679007d
r11393:7f81c686e5e2
r5584:545d748cc681
r21124:6022cb131374
r5584:545d748cc681
r11249:3a4ef570bee2
r21436:38079fc3bcd8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6247:96e840dbefcc
r5584:545d748cc681
r24901:373764ef362c
r24901:373764ef362c
r24901:373764ef362c
r11393:7f81c686e5e2
r23607:36c15679007d
r11393:7f81c686e5e2
r21124:6022cb131374
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6179:c0508e7aefec
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r5584:545d748cc681
r22421:6d5ffefaabce
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r27737:728d55b97775
r5584:545d748cc681
r6179:c0508e7aefec
r11249:3a4ef570bee2
r5584:545d748cc681
r6179:c0508e7aefec
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r5584:545d748cc681
r21436:38079fc3bcd8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9898:bbef3303e005
r14228:592af9c022e2
r5584:545d748cc681
r6999:a48d4241d92d
r5584:545d748cc681
r21436:38079fc3bcd8
r5584:545d748cc681
r5584:545d748cc681
r17098:afa706d65a49
r7545:2cbf405181b3
r7545:2cbf405181b3
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r7545:2cbf405181b3
r6247:96e840dbefcc
r5584:545d748cc681
r5584:545d748cc681
r8981:9a06c748f5e0
r8981:9a06c748f5e0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8981:9a06c748f5e0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6179:c0508e7aefec
r5584:545d748cc681
r5584:545d748cc681
r8985:72eff2815e83
r8981:9a06c748f5e0
r5584:545d748cc681
r5584:545d748cc681
r6179:c0508e7aefec
r8981:9a06c748f5e0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r26829:f1ebd010c392
r6179:c0508e7aefec
r5584:545d748cc681
r5584:545d748cc681
r8985:72eff2815e83
r26829:f1ebd010c392
r5584:545d748cc681
r6179:c0508e7aefec
r6179:c0508e7aefec
r8981:9a06c748f5e0
r5584:545d748cc681
r26829:f1ebd010c392
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8985:72eff2815e83
r26829:f1ebd010c392
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8981:9a06c748f5e0
r15178:e0bec1c097b3
r5584:545d748cc681
r19177:5af5e9926930
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17098:afa706d65a49
r24260:96fd6d38eebd
r24260:96fd6d38eebd
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r19944:25a78576fb5e
r7545:2cbf405181b3
r24260:96fd6d38eebd
r7545:2cbf405181b3
r7545:2cbf405181b3
r24260:96fd6d38eebd
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8981:9a06c748f5e0
r8981:9a06c748f5e0
r5584:545d748cc681
r8985:72eff2815e83
r5584:545d748cc681
r8981:9a06c748f5e0
r8981:9a06c748f5e0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17389:80d374d6031a
r5584:545d748cc681
r8985:72eff2815e83
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17098:afa706d65a49
r7545:2cbf405181b3
r7545:2cbf405181b3
r7545:2cbf405181b3
r17098:afa706d65a49
r7545:2cbf405181b3
r6247:96e840dbefcc
r5584:545d748cc681
r24260:96fd6d38eebd
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15613:193c12018337
r15613:193c12018337
r5584:545d748cc681
r5584:545d748cc681
r21124:6022cb131374
r5584:545d748cc681
r5584:545d748cc681
r6624:8e8cb5121304
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6937:bea726150bf3
r6878:61440e99046f
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r24521:57ec498b9221
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r27106:2d95beb51290
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r5584:545d748cc681
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r24597:afde5721a3b6
r24597:afde5721a3b6
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r5584:545d748cc681
r22421:6d5ffefaabce
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r22421:6d5ffefaabce
r15707:d8c7fbf1db5d
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r22421:6d5ffefaabce
r15707:d8c7fbf1db5d
r5584:545d748cc681
r5584:545d748cc681
r6247:96e840dbefcc
r5584:545d748cc681
r6138:b11eea571618
r6138:b11eea571618
r23607:36c15679007d
r5584:545d748cc681
r22421:6d5ffefaabce
r5584:545d748cc681
r6138:b11eea571618
r6138:b11eea571618
r5584:545d748cc681
r5584:545d748cc681
r6247:96e840dbefcc
r5584:545d748cc681
r15542:f6c6d0f8689e
r5584:545d748cc681
r15542:f6c6d0f8689e
r5584:545d748cc681
r5584:545d748cc681
r15707:d8c7fbf1db5d
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22421:6d5ffefaabce
r22420:c59d84ae4aab
r22421:6d5ffefaabce
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r22420:c59d84ae4aab
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r14309:f445232b17f6
r5584:545d748cc681
r6179:c0508e7aefec
r5584:545d748cc681
r6179:c0508e7aefec
r5668:e62c2fbafb7b
r5584:545d748cc681
r5584:545d748cc681
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r15707:d8c7fbf1db5d
r6138:b11eea571618
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r22421:6d5ffefaabce
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r22011:0dc7eed331dd
r27486:1f3330e09b1a
r27486:1f3330e09b1a
r24440:3295012a081c
r24440:3295012a081c
r24440:3295012a081c
r24440:3295012a081c
r24440:3295012a081c
r27486:1f3330e09b1a
r24440:3295012a081c
r27486:1f3330e09b1a
r27486:1f3330e09b1a
r24440:3295012a081c
r24440:3295012a081c
r24440:3295012a081c
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r27487:4d1c2a7bde00
r22011:0dc7eed331dd
r27487:4d1c2a7bde00
r27487:4d1c2a7bde00
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r27487:4d1c2a7bde00
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r27487:4d1c2a7bde00
r27487:4d1c2a7bde00
r22011:0dc7eed331dd
r22011:0dc7eed331dd
r7360:f8480e88e130
r5584:545d748cc681
r21436:38079fc3bcd8
r5584:545d748cc681
r5584:545d748cc681
r8171:ff11fcdf6589
r5584:545d748cc681
r21436:38079fc3bcd8
r23630:58df4dafed3e
r25655:1030dcb7eb52
r5584:545d748cc681
r8171:ff11fcdf6589
r5584:545d748cc681
r5584:545d748cc681
r23630:58df4dafed3e
r5584:545d748cc681
r23630:58df4dafed3e
r5584:545d748cc681
r24794:5703ff4448b2
r24794:5703ff4448b2
r24794:5703ff4448b2
r24794:5703ff4448b2
r24794:5703ff4448b2
r24794:5703ff4448b2
r24794:5703ff4448b2
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r24794:5703ff4448b2
r26581:78b3ad91bfd1
r24794:5703ff4448b2
r24794:5703ff4448b2
r27737:728d55b97775
r27112:f42d2af96b0b
r27112:f42d2af96b0b
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r24794:5703ff4448b2
r24970:1ff44d19fa4a
r26434:8e267535a2cf
r26434:8e267535a2cf
r26581:78b3ad91bfd1
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r26581:78b3ad91bfd1
r26434:8e267535a2cf
r27112:f42d2af96b0b
r27112:f42d2af96b0b
r26581:78b3ad91bfd1
r26434:8e267535a2cf
r28281:c4600c8a8dfe
r26581:78b3ad91bfd1
r28283:5799e5296538
r27112:f42d2af96b0b
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r28283:5799e5296538
r28283:5799e5296538
r27112:f42d2af96b0b
r26581:78b3ad91bfd1
r28286:e864898ab7d3
r28286:e864898ab7d3
r26581:78b3ad91bfd1
r28317:2ce013b13bc5
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r27112:f42d2af96b0b
r26434:8e267535a2cf
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r26581:78b3ad91bfd1
r26434:8e267535a2cf
r28318:2b59200cbbcd
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r26434:8e267535a2cf
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
r24970:1ff44d19fa4a
/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */

/** @file gfx.cpp Handling of drawing text and other gfx related stuff. */

#include "stdafx.h"
#include "gfx_layout.h"
#include "progress.h"
#include "zoom_func.h"
#include "blitter/factory.hpp"
#include "video/video_driver.hpp"
#include "strings_func.h"
#include "settings_type.h"
#include "network/network.h"
#include "network/network_func.h"
#include "window_gui.h"
#include "window_func.h"
#include "newgrf_debug.h"
#include "core/backup_type.hpp"
#include "core/container_func.hpp"
#include "viewport_func.h"

#include "table/string_colours.h"
#include "table/sprites.h"
#include "table/control_codes.h"

#include "safeguards.h"

byte _dirkeys;        ///< 1 = left, 2 = up, 4 = right, 8 = down
bool _fullscreen;
byte _support8bpp;
CursorVars _cursor;
bool _ctrl_pressed;   ///< Is Ctrl pressed?
bool _shift_pressed;  ///< Is Shift pressed?
uint16_t _game_speed = 100; ///< Current game-speed; 100 is 1x, 0 is infinite.
bool _left_button_down;     ///< Is left mouse button pressed?
bool _left_button_clicked;  ///< Is left mouse button clicked?
bool _right_button_down;    ///< Is right mouse button pressed?
bool _right_button_clicked; ///< Is right mouse button clicked?
DrawPixelInfo _screen;
bool _screen_disable_anim = false;   ///< Disable palette animation (important for 32bpp-anim blitter during giant screenshot)
std::atomic<bool> _exit_game;
GameMode _game_mode;
SwitchMode _switch_mode;  ///< The next mainloop command.
std::chrono::steady_clock::time_point _switch_mode_time; ///< The time when the switch mode was requested.
PauseMode _pause_mode;

static byte _stringwidth_table[FS_END][224]; ///< Cache containing width of often used characters. @see GetCharacterWidth()
DrawPixelInfo *_cur_dpi;

static void GfxMainBlitterViewport(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub = nullptr, SpriteID sprite_id = SPR_CURSOR_MOUSE);
static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub = nullptr, SpriteID sprite_id = SPR_CURSOR_MOUSE, ZoomLevel zoom = ZOOM_LVL_NORMAL);

static ReusableBuffer<uint8_t> _cursor_backup;

ZoomLevel _gui_zoom  = ZOOM_LVL_OUT_4X;     ///< GUI Zoom level
ZoomLevel _font_zoom = _gui_zoom;           ///< Sprite font Zoom level (not clamped)
int _gui_scale       = MIN_INTERFACE_SCALE; ///< GUI scale, 100 is 100%.
int _gui_scale_cfg;                         ///< GUI scale in config.

/**
 * The rect for repaint.
 *
 * This rectangle defines the area which should be repaint by the video driver.
 *
 * @ingroup dirty
 */
static Rect _invalid_rect;
static const byte *_colour_remap_ptr;
static byte _string_colourremap[3]; ///< Recoloursprite for stringdrawing. The grf loader ensures that #SpriteType::Font sprites only use colours 0 to 2.

static const uint DIRTY_BLOCK_HEIGHT   = 8;
static const uint DIRTY_BLOCK_WIDTH    = 64;

static uint _dirty_bytes_per_line = 0;
static byte *_dirty_blocks = nullptr;
extern uint _dirty_block_colour;

void GfxScroll(int left, int top, int width, int height, int xo, int yo)
{
	Blitter *blitter = BlitterFactory::GetCurrentBlitter();

	if (xo == 0 && yo == 0) return;

	if (_cursor.visible) UndrawMouseCursor();

	if (_networking) NetworkUndrawChatMessage();

	blitter->ScrollBuffer(_screen.dst_ptr, left, top, width, height, xo, yo);
	/* This part of the screen is now dirty. */
	VideoDriver::GetInstance()->MakeDirty(left, top, width, height);
}


/**
 * Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
 *
 * @pre dpi->zoom == ZOOM_LVL_NORMAL, right >= left, bottom >= top
 * @param left Minimum X (inclusive)
 * @param top Minimum Y (inclusive)
 * @param right Maximum X (inclusive)
 * @param bottom Maximum Y (inclusive)
 * @param colour A 8 bit palette index (FILLRECT_OPAQUE and FILLRECT_CHECKER) or a recolour spritenumber (FILLRECT_RECOLOUR)
 * @param mode
 *         FILLRECT_OPAQUE:   Fill the rectangle with the specified colour
 *         FILLRECT_CHECKER:  Like FILLRECT_OPAQUE, but only draw every second pixel (used to grey out things)
 *         FILLRECT_RECOLOUR:  Apply a recolour sprite to every pixel in the rectangle currently on screen
 */
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
{
	Blitter *blitter = BlitterFactory::GetCurrentBlitter();
	const DrawPixelInfo *dpi = _cur_dpi;
	void *dst;
	const int otop = top;
	const int oleft = left;

	if (dpi->zoom != ZOOM_LVL_NORMAL) return;
	if (left > right || top > bottom) return;
	if (right < dpi->left || left >= dpi->left + dpi->width) return;
	if (bottom < dpi->top || top >= dpi->top + dpi->height) return;

	if ( (left -= dpi->left) < 0) left = 0;
	right = right - dpi->left + 1;
	if (right > dpi->width) right = dpi->width;
	right -= left;
	assert(right > 0);

	if ( (top -= dpi->top) < 0) top = 0;
	bottom = bottom - dpi->top + 1;
	if (bottom > dpi->height) bottom = dpi->height;
	bottom -= top;
	assert(bottom > 0);

	dst = blitter->MoveTo(dpi->dst_ptr, left, top);

	switch (mode) {
		default: // FILLRECT_OPAQUE
			blitter->DrawRect(dst, right, bottom, (uint8_t)colour);
			break;

		case FILLRECT_RECOLOUR:
			blitter->DrawColourMappingRect(dst, right, bottom, GB(colour, 0, PALETTE_WIDTH));
			break;

		case FILLRECT_CHECKER: {
			byte bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1;
			do {
				for (int i = (bo ^= 1); i < right; i += 2) blitter->SetPixel(dst, i, 0, (uint8_t)colour);
				dst = blitter->MoveTo(dst, 0, 1);
			} while (--bottom > 0);
			break;
		}
	}
}

typedef std::pair<Point, Point> LineSegment;

/**
 * Make line segments from a polygon defined by points, translated by an offset.
 * Entirely horizontal lines (start and end at same Y coordinate) are skipped, as they are irrelevant to scanline conversion algorithms.
 * Generated line segments always have the lowest Y coordinate point first, i.e. original direction is lost.
 * @param shape The polygon to convert.
 * @param offset Offset vector subtracted from all coordinates in the shape.
 * @return Vector of undirected line segments.
 */
static std::vector<LineSegment> MakePolygonSegments(const std::vector<Point> &shape, Point offset)
{
	std::vector<LineSegment> segments;
	if (shape.size() < 3) return segments; // fewer than 3 will always result in an empty polygon
	segments.reserve(shape.size());

	/* Connect first and last point by having initial previous point be the last */
	Point prev = shape.back();
	prev.x -= offset.x;
	prev.y -= offset.y;
	for (Point pt : shape) {
		pt.x -= offset.x;
		pt.y -= offset.y;
		/* Create segments for all non-horizontal lines in the polygon.
		 * The segments always have lowest Y coordinate first. */
		if (prev.y > pt.y) {
			segments.emplace_back(pt, prev);
		} else if (prev.y < pt.y) {
			segments.emplace_back(prev, pt);
		}
		prev = pt;
	}

	return segments;
}

/**
 * Fill a polygon with colour.
 * The odd-even winding rule is used, i.e. self-intersecting polygons will have holes in them.
 * Left and top edges are inclusive, right and bottom edges are exclusive.
 * @note For rectangles the GfxFillRect function will be faster.
 * @pre dpi->zoom == ZOOM_LVL_NORMAL
 * @param shape List of points on the polygon.
 * @param colour An 8 bit palette index (FILLRECT_OPAQUE and FILLRECT_CHECKER) or a recolour spritenumber (FILLRECT_RECOLOUR).
 * @param mode
 *         FILLRECT_OPAQUE:   Fill the polygon with the specified colour.
 *         FILLRECT_CHECKER:  Fill every other pixel with the specified colour, in a checkerboard pattern.
 *         FILLRECT_RECOLOUR: Apply a recolour sprite to every pixel in the polygon.
 */
void GfxFillPolygon(const std::vector<Point> &shape, int colour, FillRectMode mode)
{
	Blitter *blitter = BlitterFactory::GetCurrentBlitter();
	const DrawPixelInfo *dpi = _cur_dpi;
	if (dpi->zoom != ZOOM_LVL_NORMAL) return;

	std::vector<LineSegment> segments = MakePolygonSegments(shape, Point{ dpi->left, dpi->top });

	/* Remove segments appearing entirely above or below the clipping area. */
	segments.erase(std::remove_if(segments.begin(), segments.end(), [dpi](const LineSegment &s) { return s.second.y <= 0 || s.first.y >= dpi->height; }), segments.end());

	/* Check that this wasn't an empty shape (all points on a horizontal line or outside clipping.) */
	if (segments.empty()) return;

	/* Sort the segments by first point Y coordinate. */
	std::sort(segments.begin(), segments.end(), [](const LineSegment &a, const LineSegment &b) { return a.first.y < b.first.y; });

	/* Segments intersecting current scanline. */
	std::vector<LineSegment> active;
	/* Intersection points with a scanline.
	 * Kept outside loop to avoid repeated re-allocations. */
	std::vector<int> intersections;
	/* Normal, reasonable polygons don't have many intersections per scanline. */
	active.reserve(4);
	intersections.reserve(4);

	/* Scan through the segments and paint each scanline. */
	int y = segments.front().first.y;
	std::vector<LineSegment>::iterator nextseg = segments.begin();
	while (!active.empty() || nextseg != segments.end()) {
		/* Clean up segments that have ended. */
		active.erase(std::remove_if(active.begin(), active.end(), [y](const LineSegment &s) { return s.second.y == y; }), active.end());

		/* Activate all segments starting on this scanline. */
		while (nextseg != segments.end() && nextseg->first.y == y) {
			active.push_back(*nextseg);
			++nextseg;
		}

		/* Check clipping. */
		if (y < 0) {
			++y;
			continue;
		}
		if (y >= dpi->height) return;

		/*  Intersect scanline with all active segments. */
		intersections.clear();
		for (const LineSegment &s : active) {
			const int sdx = s.second.x - s.first.x;
			const int sdy = s.second.y - s.first.y;
			const int ldy = y - s.first.y;
			const int x = s.first.x + sdx * ldy / sdy;
			intersections.push_back(x);
		}

		/* Fill between pairs of intersections. */
		std::sort(intersections.begin(), intersections.end());
		for (size_t i = 1; i < intersections.size(); i += 2) {
			/* Check clipping. */
			const int x1 = std::max(0, intersections[i - 1]);
			const int x2 = std::min(intersections[i], dpi->width);
			if (x2 < 0) continue;
			if (x1 >= dpi->width) continue;

			/* Fill line y from x1 to x2. */
			void *dst = blitter->MoveTo(dpi->dst_ptr, x1, y);
			switch (mode) {
				default: // FILLRECT_OPAQUE
					blitter->DrawRect(dst, x2 - x1, 1, (uint8_t)colour);
					break;
				case FILLRECT_RECOLOUR:
					blitter->DrawColourMappingRect(dst, x2 - x1, 1, GB(colour, 0, PALETTE_WIDTH));
					break;
				case FILLRECT_CHECKER:
					/* Fill every other pixel, offset such that the sum of filled pixels' X and Y coordinates is odd.
					 * This creates a checkerboard effect. */
					for (int x = (x1 + y) & 1; x < x2 - x1; x += 2) {
						blitter->SetPixel(dst, x, 0, (uint8_t)colour);
					}
					break;
			}
		}

		/* Next line */
		++y;
	}
}

/**
 * Check line clipping by using a linear equation and draw the visible part of
 * the line given by x/y and x2/y2.
 * @param video Destination pointer to draw into.
 * @param x X coordinate of first point.
 * @param y Y coordinate of first point.
 * @param x2 X coordinate of second point.
 * @param y2 Y coordinate of second point.
 * @param screen_width With of the screen to check clipping against.
 * @param screen_height Height of the screen to check clipping against.
 * @param colour Colour of the line.
 * @param width Width of the line.
 * @param dash Length of dashes for dashed lines. 0 means solid line.
 */
static inline void GfxDoDrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, uint8_t colour, int width, int dash = 0)
{
	Blitter *blitter = BlitterFactory::GetCurrentBlitter();

	assert(width > 0);

	if (y2 == y || x2 == x) {
		/* Special case: horizontal/vertical line. All checks already done in GfxPreprocessLine. */
		blitter->DrawLine(video, x, y, x2, y2, screen_width, screen_height, colour, width, dash);
		return;
	}

	int grade_y = y2 - y;
	int grade_x = x2 - x;

	/* Clipping rectangle. Slightly extended so we can ignore the width of the line. */
	int extra = (int)CeilDiv(3 * width, 4); // not less then "width * sqrt(2) / 2"
	Rect clip = { -extra, -extra, screen_width - 1 + extra, screen_height - 1 + extra };

	/* prevent integer overflows. */
	int margin = 1;
	while (INT_MAX / abs(grade_y) < std::max(abs(clip.left - x), abs(clip.right - x))) {
		grade_y /= 2;
		grade_x /= 2;
		margin  *= 2; // account for rounding errors
	}

	/* Imagine that the line is infinitely long and it intersects with
	 * infinitely long left and right edges of the clipping rectangle.
	 * If both intersection points are outside the clipping rectangle
	 * and both on the same side of it, we don't need to draw anything. */
	int left_isec_y = y + (clip.left - x) * grade_y / grade_x;
	int right_isec_y = y + (clip.right - x) * grade_y / grade_x;
	if ((left_isec_y > clip.bottom + margin && right_isec_y > clip.bottom + margin) ||
			(left_isec_y < clip.top - margin && right_isec_y < clip.top - margin)) {
		return;
	}

	/* It is possible to use the line equation to further reduce the amount of
	 * work the blitter has to do by shortening the effective line segment.
	 * However, in order to get that right and prevent the flickering effects
	 * of rounding errors so much additional code has to be run here that in
	 * the general case the effect is not noticeable. */

	blitter->DrawLine(video, x, y, x2, y2, screen_width, screen_height, colour, width, dash);
}

/**
 * Align parameters of a line to the given DPI and check simple clipping.
 * @param dpi Screen parameters to align with.
 * @param x X coordinate of first point.
 * @param y Y coordinate of first point.
 * @param x2 X coordinate of second point.
 * @param y2 Y coordinate of second point.
 * @param width Width of the line.
 * @return True if the line is likely to be visible, false if it's certainly
 *         invisible.
 */
static inline bool GfxPreprocessLine(DrawPixelInfo *dpi, int &x, int &y, int &x2, int &y2, int width)
{
	x -= dpi->left;
	x2 -= dpi->left;
	y -= dpi->top;
	y2 -= dpi->top;

	/* Check simple clipping */
	if (x + width / 2 < 0           && x2 + width / 2 < 0          ) return false;
	if (y + width / 2 < 0           && y2 + width / 2 < 0          ) return false;
	if (x - width / 2 > dpi->width  && x2 - width / 2 > dpi->width ) return false;
	if (y - width / 2 > dpi->height && y2 - width / 2 > dpi->height) return false;
	return true;
}

void GfxDrawLine(int x, int y, int x2, int y2, int colour, int width, int dash)
{
	DrawPixelInfo *dpi = _cur_dpi;
	if (GfxPreprocessLine(dpi, x, y, x2, y2, width)) {
		GfxDoDrawLine(dpi->dst_ptr, x, y, x2, y2, dpi->width, dpi->height, colour, width, dash);
	}
}

void GfxDrawLineUnscaled(int x, int y, int x2, int y2, int colour)
{
	DrawPixelInfo *dpi = _cur_dpi;
	if (GfxPreprocessLine(dpi, x, y, x2, y2, 1)) {
		GfxDoDrawLine(dpi->dst_ptr,
				UnScaleByZoom(x, dpi->zoom), UnScaleByZoom(y, dpi->zoom),
				UnScaleByZoom(x2, dpi->zoom), UnScaleByZoom(y2, dpi->zoom),
				UnScaleByZoom(dpi->width, dpi->zoom), UnScaleByZoom(dpi->height, dpi->zoom), colour, 1);
	}
}

/**
 * Draws the projection of a parallelepiped.
 * This can be used to draw boxes in world coordinates.
 *
 * @param x   Screen X-coordinate of top front corner.
 * @param y   Screen Y-coordinate of top front corner.
 * @param dx1 Screen X-length of first edge.
 * @param dy1 Screen Y-length of first edge.
 * @param dx2 Screen X-length of second edge.
 * @param dy2 Screen Y-length of second edge.
 * @param dx3 Screen X-length of third edge.
 * @param dy3 Screen Y-length of third edge.
 */
void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3)
{
	/*           ....
	 *         ..    ....
	 *       ..          ....
	 *     ..                ^
	 *   <--__(dx1,dy1)    /(dx2,dy2)
	 *   :    --__       /   :
	 *   :        --__ /     :
	 *   :            *(x,y) :
	 *   :            |      :
	 *   :            |     ..
	 *    ....        |(dx3,dy3)
	 *        ....    | ..
	 *            ....V.
	 */

	static const byte colour = PC_WHITE;

	GfxDrawLineUnscaled(x, y, x + dx1, y + dy1, colour);
	GfxDrawLineUnscaled(x, y, x + dx2, y + dy2, colour);
	GfxDrawLineUnscaled(x, y, x + dx3, y + dy3, colour);

	GfxDrawLineUnscaled(x + dx1, y + dy1, x + dx1 + dx2, y + dy1 + dy2, colour);
	GfxDrawLineUnscaled(x + dx1, y + dy1, x + dx1 + dx3, y + dy1 + dy3, colour);
	GfxDrawLineUnscaled(x + dx2, y + dy2, x + dx2 + dx1, y + dy2 + dy1, colour);
	GfxDrawLineUnscaled(x + dx2, y + dy2, x + dx2 + dx3, y + dy2 + dy3, colour);
	GfxDrawLineUnscaled(x + dx3, y + dy3, x + dx3 + dx1, y + dy3 + dy1, colour);
	GfxDrawLineUnscaled(x + dx3, y + dy3, x + dx3 + dx2, y + dy3 + dy2, colour);
}

/**
 * Draw the outline of a Rect
 * @param r Rect to draw.
 * @param colour Colour of the outline.
 * @param width Width of the outline.
 * @param dash Length of dashes for dashed lines. 0 means solid lines.
 */
void DrawRectOutline(const Rect &r, int colour, int width, int dash)
{
	GfxDrawLine(r.left,  r.top,    r.right, r.top,    colour, width, dash);
	GfxDrawLine(r.left,  r.top,    r.left,  r.bottom, colour, width, dash);
	GfxDrawLine(r.right, r.top,    r.right, r.bottom, colour, width, dash);
	GfxDrawLine(r.left,  r.bottom, r.right, r.bottom, colour, width, dash);
}

/**
 * Set the colour remap to be for the given colour.
 * @param colour the new colour of the remap.
 */
static void SetColourRemap(TextColour colour)
{
	if (colour == TC_INVALID) return;

	/* Black strings have no shading ever; the shading is black, so it
	 * would be invisible at best, but it actually makes it illegible. */
	bool no_shade   = (colour & TC_NO_SHADE) != 0 || colour == TC_BLACK;
	bool raw_colour = (colour & TC_IS_PALETTE_COLOUR) != 0;
	colour &= ~(TC_NO_SHADE | TC_IS_PALETTE_COLOUR | TC_FORCED);

	_string_colourremap[1] = raw_colour ? (byte)colour : _string_colourmap[colour];
	_string_colourremap[2] = no_shade ? 0 : 1;
	_colour_remap_ptr = _string_colourremap;
}

/**
 * Drawing routine for drawing a laid out line of text.
 * @param line      String to draw.
 * @param y         The top most position to draw on.
 * @param left      The left most position to draw on.
 * @param right     The right most position to draw on.
 * @param align     The alignment of the string when drawing left-to-right. In the
 *                  case a right-to-left language is chosen this is inverted so it
 *                  will be drawn in the right direction.
 * @param underline Whether to underline what has been drawn or not.
 * @param truncation Whether to perform string truncation or not.
 *
 * @return In case of left or center alignment the right most pixel we have drawn to.
 *         In case of right alignment the left most pixel we have drawn to.
 */
static int DrawLayoutLine(const ParagraphLayouter::Line &line, int y, int left, int right, StringAlignment align, bool underline, bool truncation)
{
	if (line.CountRuns() == 0) return 0;

	int w = line.GetWidth();
	int h = line.GetLeading();

	/*
	 * The following is needed for truncation.
	 * Depending on the text direction, we either remove bits at the rear
	 * or the front. For this we shift the entire area to draw so it fits
	 * within the left/right bounds and the side we do not truncate it on.
	 * Then we determine the truncation location, i.e. glyphs that fall
	 * outside of the range min_x - max_x will not be drawn; they are thus
	 * the truncated glyphs.
	 *
	 * At a later step we insert the dots.
	 */

	int max_w = right - left + 1; // The maximum width.

	int offset_x = 0;  // The offset we need for positioning the glyphs
	int min_x = left;  // The minimum x position to draw normal glyphs on.
	int max_x = right; // The maximum x position to draw normal glyphs on.

	truncation &= max_w < w;         // Whether we need to do truncation.
	int dot_width = 0;               // Cache for the width of the dot.
	const Sprite *dot_sprite = nullptr; // Cache for the sprite of the dot.

	if (truncation) {
		/*
		 * Assumption may be made that all fonts of a run are of the same size.
		 * In any case, we'll use these dots for the abbreviation, so even if
		 * another size would be chosen it won't have truncated too little for
		 * the truncation dots.
		 */
		FontCache *fc = line.GetVisualRun(0).GetFont()->fc;
		GlyphID dot_glyph = fc->MapCharToGlyph('.');
		dot_width = fc->GetGlyphWidth(dot_glyph);
		dot_sprite = fc->GetGlyph(dot_glyph);

		if (_current_text_dir == TD_RTL) {
			min_x += 3 * dot_width;
			offset_x = w - 3 * dot_width - max_w;
		} else {
			max_x -= 3 * dot_width;
		}

		w = max_w;
	}

	/* In case we have a RTL language we swap the alignment. */
	if (!(align & SA_FORCE) && _current_text_dir == TD_RTL && (align & SA_HOR_MASK) != SA_HOR_CENTER) align ^= SA_RIGHT;

	/* right is the right most position to draw on. In this case we want to do
	 * calculations with the width of the string. In comparison right can be
	 * seen as lastof(todraw) and width as lengthof(todraw). They differ by 1.
	 * So most +1/-1 additions are to move from lengthof to 'indices'.
	 */
	switch (align & SA_HOR_MASK) {
		case SA_LEFT:
			/* right + 1 = left + w */
			right = left + w - 1;
			break;

		case SA_HOR_CENTER:
			left  = RoundDivSU(right + 1 + left - w, 2);
			/* right + 1 = left + w */
			right = left + w - 1;
			break;

		case SA_RIGHT:
			left = right + 1 - w;
			break;

		default:
			NOT_REACHED();
	}

	const uint shadow_offset = ScaleGUITrad(1);

	TextColour colour = TC_BLACK;
	bool draw_shadow = false;
	for (int run_index = 0; run_index < line.CountRuns(); run_index++) {
		const ParagraphLayouter::VisualRun &run = line.GetVisualRun(run_index);
		const Font *f = run.GetFont();

		FontCache *fc = f->fc;
		colour = f->colour;
		SetColourRemap(colour);

		DrawPixelInfo *dpi = _cur_dpi;
		int dpi_left  = dpi->left;
		int dpi_right = dpi->left + dpi->width - 1;

		draw_shadow = fc->GetDrawGlyphShadow() && (colour & TC_NO_SHADE) == 0 && colour != TC_BLACK;

		for (int i = 0; i < run.GetGlyphCount(); i++) {
			GlyphID glyph = run.GetGlyphs()[i];

			/* Not a valid glyph (empty) */
			if (glyph == 0xFFFF) continue;

			int begin_x = (int)run.GetPositions()[i * 2]     + left - offset_x;
			int end_x   = (int)run.GetPositions()[i * 2 + 2] + left - offset_x  - 1;
			int top     = (int)run.GetPositions()[i * 2 + 1] + y;

			/* Truncated away. */
			if (truncation && (begin_x < min_x || end_x > max_x)) continue;

			const Sprite *sprite = fc->GetGlyph(glyph);
			/* Check clipping (the "+ 1" is for the shadow). */
			if (begin_x + sprite->x_offs > dpi_right || begin_x + sprite->x_offs + sprite->width /* - 1 + 1 */ < dpi_left) continue;

			if (draw_shadow && (glyph & SPRITE_GLYPH) == 0) {
				SetColourRemap(TC_BLACK);
				GfxMainBlitter(sprite, begin_x + shadow_offset, top + shadow_offset, BM_COLOUR_REMAP);
				SetColourRemap(colour);
			}
			GfxMainBlitter(sprite, begin_x, top, BM_COLOUR_REMAP);
		}
	}

	if (truncation) {
		int x = (_current_text_dir == TD_RTL) ? left : (right - 3 * dot_width);
		for (int i = 0; i < 3; i++, x += dot_width) {
			if (draw_shadow) {
				SetColourRemap(TC_BLACK);
				GfxMainBlitter(dot_sprite, x + shadow_offset, y + shadow_offset, BM_COLOUR_REMAP);
				SetColourRemap(colour);
			}
			GfxMainBlitter(dot_sprite, x, y, BM_COLOUR_REMAP);
		}
	}

	if (underline) {
		GfxFillRect(left, y + h, right, y + h + WidgetDimensions::scaled.bevel.top - 1, _string_colourremap[1]);
	}

	return (align & SA_HOR_MASK) == SA_RIGHT ? left : right;
}

/**
 * Draw string, possibly truncated to make it fit in its allocated space
 *
 * @param left   The left most position to draw on.
 * @param right  The right most position to draw on.
 * @param top    The top most position to draw on.
 * @param str    String to draw.
 * @param colour Colour used for drawing the string, for details see _string_colourmap in
 *               table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h
 * @param align  The alignment of the string when drawing left-to-right. In the
 *               case a right-to-left language is chosen this is inverted so it
 *               will be drawn in the right direction.
 * @param underline Whether to underline what has been drawn or not.
 * @param fontsize The size of the initial characters.
 * @return In case of left or center alignment the right most pixel we have drawn to.
 *         In case of right alignment the left most pixel we have drawn to.
 */
int DrawString(int left, int right, int top, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
{
	/* The string may contain control chars to change the font, just use the biggest font for clipping. */
	int max_height = std::max({GetCharacterHeight(FS_SMALL), GetCharacterHeight(FS_NORMAL), GetCharacterHeight(FS_LARGE), GetCharacterHeight(FS_MONO)});

	/* Funny glyphs may extent outside the usual bounds, so relax the clipping somewhat. */
	int extra = max_height / 2;

	if (_cur_dpi->top + _cur_dpi->height + extra < top || _cur_dpi->top > top + max_height + extra ||
			_cur_dpi->left + _cur_dpi->width + extra < left || _cur_dpi->left > right + extra) {
		return 0;
	}

	Layouter layout(str, INT32_MAX, colour, fontsize);
	if (layout.empty()) return 0;

	return DrawLayoutLine(*layout.front(), top, left, right, align, underline, true);
}

/**
 * Draw string, possibly truncated to make it fit in its allocated space
 *
 * @param left   The left most position to draw on.
 * @param right  The right most position to draw on.
 * @param top    The top most position to draw on.
 * @param str    String to draw.
 * @param colour Colour used for drawing the string, for details see _string_colourmap in
 *               table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h
 * @param align  The alignment of the string when drawing left-to-right. In the
 *               case a right-to-left language is chosen this is inverted so it
 *               will be drawn in the right direction.
 * @param underline Whether to underline what has been drawn or not.
 * @param fontsize The size of the initial characters.
 * @return In case of left or center alignment the right most pixel we have drawn to.
 *         In case of right alignment the left most pixel we have drawn to.
 */
int DrawString(int left, int right, int top, StringID str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
{
	return DrawString(left, right, top, GetString(str), colour, align, underline, fontsize);
}

/**
 * Calculates height of string (in pixels). The string is changed to a multiline string if needed.
 * @param str string to check
 * @param maxw maximum string width
 * @return height of pixels of string when it is drawn
 */
int GetStringHeight(std::string_view str, int maxw, FontSize fontsize)
{
	assert(maxw > 0);
	Layouter layout(str, maxw, TC_FROMSTRING, fontsize);
	return layout.GetBounds().height;
}

/**
 * Calculates height of string (in pixels). The string is changed to a multiline string if needed.
 * @param str string to check
 * @param maxw maximum string width
 * @return height of pixels of string when it is drawn
 */
int GetStringHeight(StringID str, int maxw)
{
	return GetStringHeight(GetString(str), maxw);
}

/**
 * Calculates number of lines of string. The string is changed to a multiline string if needed.
 * @param str string to check
 * @param maxw maximum string width
 * @return number of lines of string when it is drawn
 */
int GetStringLineCount(StringID str, int maxw)
{
	Layouter layout(GetString(str), maxw);
	return (uint)layout.size();
}

/**
 * Calculate string bounding box for multi-line strings.
 * @param str        String to check.
 * @param suggestion Suggested bounding box.
 * @return Bounding box for the multi-line string, may be bigger than \a suggestion.
 */
Dimension GetStringMultiLineBoundingBox(StringID str, const Dimension &suggestion)
{
	Dimension box = {suggestion.width, (uint)GetStringHeight(str, suggestion.width)};
	return box;
}

/**
 * Calculate string bounding box for multi-line strings.
 * @param str        String to check.
 * @param suggestion Suggested bounding box.
 * @return Bounding box for the multi-line string, may be bigger than \a suggestion.
 */
Dimension GetStringMultiLineBoundingBox(std::string_view str, const Dimension &suggestion)
{
	Dimension box = {suggestion.width, (uint)GetStringHeight(str, suggestion.width)};
	return box;
}

/**
 * Draw string, possibly over multiple lines.
 *
 * @param left   The left most position to draw on.
 * @param right  The right most position to draw on.
 * @param top    The top most position to draw on.
 * @param bottom The bottom most position to draw on.
 * @param str    String to draw.
 * @param colour Colour used for drawing the string, for details see _string_colourmap in
 *               table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h
 * @param align  The horizontal and vertical alignment of the string.
 * @param underline Whether to underline all strings
 * @param fontsize The size of the initial characters.
 *
 * @return If \a align is #SA_BOTTOM, the top to where we have written, else the bottom to where we have written.
 */
int DrawStringMultiLine(int left, int right, int top, int bottom, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
{
	int maxw = right - left + 1;
	int maxh = bottom - top + 1;

	/* It makes no sense to even try if it can't be drawn anyway, or
	 * do we really want to support fonts of 0 or less pixels high? */
	if (maxh <= 0) return top;

	Layouter layout(str, maxw, colour, fontsize);
	int total_height = layout.GetBounds().height;
	int y;
	switch (align & SA_VERT_MASK) {
		case SA_TOP:
			y = top;
			break;

		case SA_VERT_CENTER:
			y = RoundDivSU(bottom + top - total_height, 2);
			break;

		case SA_BOTTOM:
			y = bottom - total_height;
			break;

		default: NOT_REACHED();
	}

	int last_line = top;
	int first_line = bottom;

	for (const auto &line : layout) {

		int line_height = line->GetLeading();
		if (y >= top && y + line_height - 1 <= bottom) {
			last_line = y + line_height;
			if (first_line > y) first_line = y;

			DrawLayoutLine(*line, y, left, right, align, underline, false);
		}
		y += line_height;
	}

	return ((align & SA_VERT_MASK) == SA_BOTTOM) ? first_line : last_line;
}

/**
 * Draw string, possibly over multiple lines.
 *
 * @param left   The left most position to draw on.
 * @param right  The right most position to draw on.
 * @param top    The top most position to draw on.
 * @param bottom The bottom most position to draw on.
 * @param str    String to draw.
 * @param colour Colour used for drawing the string, for details see _string_colourmap in
 *               table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h
 * @param align  The horizontal and vertical alignment of the string.
 * @param underline Whether to underline all strings
 * @param fontsize The size of the initial characters.
 *
 * @return If \a align is #SA_BOTTOM, the top to where we have written, else the bottom to where we have written.
 */
int DrawStringMultiLine(int left, int right, int top, int bottom, StringID str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
{
	return DrawStringMultiLine(left, right, top, bottom, GetString(str), colour, align, underline, fontsize);
}

/**
 * Return the string dimension in pixels. The height and width are returned
 * in a single Dimension value. TINYFONT, BIGFONT modifiers are only
 * supported as the first character of the string. The returned dimensions
 * are therefore a rough estimation correct for all the current strings
 * but not every possible combination
 * @param str string to calculate pixel-width
 * @param start_fontsize Fontsize to start the text with
 * @return string width and height in pixels
 */
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
{
	Layouter layout(str, INT32_MAX, TC_FROMSTRING, start_fontsize);
	return layout.GetBounds();
}

/**
 * Get bounding box of a string. Uses parameters set by #SetDParam if needed.
 * Has the same restrictions as #GetStringBoundingBox(std::string_view str, FontSize start_fontsize).
 * @param strid String to examine.
 * @return Width and height of the bounding box for the string in pixels.
 */
Dimension GetStringBoundingBox(StringID strid, FontSize start_fontsize)
{
	return GetStringBoundingBox(GetString(strid), start_fontsize);
}

/**
 * Get maximum width of a list of strings.
 * @param list List of strings, terminated with INVALID_STRING_ID.
 * @param fontsize Font size to use.
 * @return Width of longest string within the list.
 */
uint GetStringListWidth(const StringID *list, FontSize fontsize)
{
	uint width = 0;
	for (const StringID *str = list; *str != INVALID_STRING_ID; str++) {
		width = std::max(width, GetStringBoundingBox(*str, fontsize).width);
	}
	return width;
}

/**
 * Get the leading corner of a character in a single-line string relative
 * to the start of the string.
 * @param str String containing the character.
 * @param ch Pointer to the character in the string.
 * @param start_fontsize Font size to start the text with.
 * @return Upper left corner of the glyph associated with the character.
 */
Point GetCharPosInString(std::string_view str, const char *ch, FontSize start_fontsize)
{
	/* Ensure "ch" is inside "str" or at the exact end. */
	assert(ch >= str.data() && (ch - str.data()) <= static_cast<ptrdiff_t>(str.size()));
	auto it_ch = str.begin() + (ch - str.data());

	Layouter layout(str, INT32_MAX, TC_FROMSTRING, start_fontsize);
	return layout.GetCharPosition(it_ch);
}

/**
 * Get the character from a string that is drawn at a specific position.
 * @param str String to test.
 * @param x Position relative to the start of the string.
 * @param start_fontsize Font size to start the text with.
 * @return Index of the character position or -1 if there is no character at the position.
 */
ptrdiff_t GetCharAtPosition(std::string_view str, int x, FontSize start_fontsize)
{
	if (x < 0) return -1;

	Layouter layout(str, INT32_MAX, TC_FROMSTRING, start_fontsize);
	return layout.GetCharAtPosition(x, 0);
}

/**
 * Draw single character horizontally centered around (x,y)
 * @param c           Character (glyph) to draw
 * @param r           Rectangle to draw character within
 * @param colour      Colour to use, for details see _string_colourmap in
 *                    table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h
 */
void DrawCharCentered(char32_t c, const Rect &r, TextColour colour)
{
	SetColourRemap(colour);
	GfxMainBlitter(GetGlyph(FS_NORMAL, c),
		CenterBounds(r.left, r.right, GetCharacterWidth(FS_NORMAL, c)),
		CenterBounds(r.top, r.bottom, GetCharacterHeight(FS_NORMAL)),
		BM_COLOUR_REMAP);
}

/**
 * Get the size of a sprite.
 * @param sprid Sprite to examine.
 * @param[out] offset Optionally returns the sprite position offset.
 * @param zoom The zoom level applicable to the sprite.
 * @return Sprite size in pixels.
 * @note The size assumes (0, 0) as top-left coordinate and ignores any part of the sprite drawn at the left or above that position.
 */
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
{
	const Sprite *sprite = GetSprite(sprid, SpriteType::Normal);

	if (offset != nullptr) {
		offset->x = UnScaleByZoom(sprite->x_offs, zoom);
		offset->y = UnScaleByZoom(sprite->y_offs, zoom);
	}

	Dimension d;
	d.width  = std::max<int>(0, UnScaleByZoom(sprite->x_offs + sprite->width, zoom));
	d.height = std::max<int>(0, UnScaleByZoom(sprite->y_offs + sprite->height, zoom));
	return d;
}

/**
 * Helper function to get the blitter mode for different types of palettes.
 * @param pal The palette to get the blitter mode for.
 * @return The blitter mode associated with the palette.
 */
static BlitterMode GetBlitterMode(PaletteID pal)
{
	switch (pal) {
		case PAL_NONE:          return BM_NORMAL;
		case PALETTE_CRASH:     return BM_CRASH_REMAP;
		case PALETTE_ALL_BLACK: return BM_BLACK_REMAP;
		default:                return BM_COLOUR_REMAP;
	}
}

/**
 * Draw a sprite in a viewport.
 * @param img  Image number to draw
 * @param pal  Palette to use.
 * @param x    Left coordinate of image in viewport, scaled by zoom
 * @param y    Top coordinate of image in viewport, scaled by zoom
 * @param sub  If available, draw only specified part of the sprite
 */
void DrawSpriteViewport(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub)
{
	SpriteID real_sprite = GB(img, 0, SPRITE_WIDTH);
	if (HasBit(img, PALETTE_MODIFIER_TRANSPARENT)) {
		pal = GB(pal, 0, PALETTE_WIDTH);
		_colour_remap_ptr = GetNonSprite(pal, SpriteType::Recolour) + 1;
		GfxMainBlitterViewport(GetSprite(real_sprite, SpriteType::Normal), x, y, pal == PALETTE_TO_TRANSPARENT ? BM_TRANSPARENT : BM_TRANSPARENT_REMAP, sub, real_sprite);
	} else if (pal != PAL_NONE) {
		if (HasBit(pal, PALETTE_TEXT_RECOLOUR)) {
			SetColourRemap((TextColour)GB(pal, 0, PALETTE_WIDTH));
		} else {
			_colour_remap_ptr = GetNonSprite(GB(pal, 0, PALETTE_WIDTH), SpriteType::Recolour) + 1;
		}
		GfxMainBlitterViewport(GetSprite(real_sprite, SpriteType::Normal), x, y, GetBlitterMode(pal), sub, real_sprite);
	} else {
		GfxMainBlitterViewport(GetSprite(real_sprite, SpriteType::Normal), x, y, BM_NORMAL, sub, real_sprite);
	}
}

/**
 * Draw a sprite, not in a viewport
 * @param img  Image number to draw
 * @param pal  Palette to use.
 * @param x    Left coordinate of image in pixels
 * @param y    Top coordinate of image in pixels
 * @param sub  If available, draw only specified part of the sprite
 * @param zoom Zoom level of sprite
 */
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
{
	SpriteID real_sprite = GB(img, 0, SPRITE_WIDTH);
	if (HasBit(img, PALETTE_MODIFIER_TRANSPARENT)) {
		pal = GB(pal, 0, PALETTE_WIDTH);
		_colour_remap_ptr = GetNonSprite(pal, SpriteType::Recolour) + 1;
		GfxMainBlitter(GetSprite(real_sprite, SpriteType::Normal), x, y, pal == PALETTE_TO_TRANSPARENT ? BM_TRANSPARENT : BM_TRANSPARENT_REMAP, sub, real_sprite, zoom);
	} else if (pal != PAL_NONE) {
		if (HasBit(pal, PALETTE_TEXT_RECOLOUR)) {
			SetColourRemap((TextColour)GB(pal, 0, PALETTE_WIDTH));
		} else {
			_colour_remap_ptr = GetNonSprite(GB(pal, 0, PALETTE_WIDTH), SpriteType::Recolour) + 1;
		}
		GfxMainBlitter(GetSprite(real_sprite, SpriteType::Normal), x, y, GetBlitterMode(pal), sub, real_sprite, zoom);
	} else {
		GfxMainBlitter(GetSprite(real_sprite, SpriteType::Normal), x, y, BM_NORMAL, sub, real_sprite, zoom);
	}
}

/**
 * The code for setting up the blitter mode and sprite information before finally drawing the sprite.
 * @param sprite The sprite to draw.
 * @param x The X location to draw.
 * @param y The Y location to draw.
 * @param mode The settings for the blitter to pass.
 * @param sub Whether to only draw a sub set of the sprite.
 * @param zoom The zoom level at which to draw the sprites.
 * @param dst Optional parameter for a different blitting destination.
 * @tparam ZOOM_BASE The factor required to get the sub sprite information into the right size.
 * @tparam SCALED_XY Whether the X and Y are scaled or unscaled.
 */
template <int ZOOM_BASE, bool SCALED_XY>
static void GfxBlitter(const Sprite * const sprite, int x, int y, BlitterMode mode, const SubSprite * const sub, SpriteID sprite_id, ZoomLevel zoom, const DrawPixelInfo *dst = nullptr)
{
	const DrawPixelInfo *dpi = (dst != nullptr) ? dst : _cur_dpi;
	Blitter::BlitterParams bp;

	if (SCALED_XY) {
		/* Scale it */
		x = ScaleByZoom(x, zoom);
		y = ScaleByZoom(y, zoom);
	}

	/* Move to the correct offset */
	x += sprite->x_offs;
	y += sprite->y_offs;

	if (sub == nullptr) {
		/* No clipping. */
		bp.skip_left = 0;
		bp.skip_top = 0;
		bp.width = UnScaleByZoom(sprite->width, zoom);
		bp.height = UnScaleByZoom(sprite->height, zoom);
	} else {
		/* Amount of pixels to clip from the source sprite */
		int clip_left   = std::max(0,                   -sprite->x_offs +  sub->left        * ZOOM_BASE );
		int clip_top    = std::max(0,                   -sprite->y_offs +  sub->top         * ZOOM_BASE );
		int clip_right  = std::max(0, sprite->width  - (-sprite->x_offs + (sub->right + 1)  * ZOOM_BASE));
		int clip_bottom = std::max(0, sprite->height - (-sprite->y_offs + (sub->bottom + 1) * ZOOM_BASE));

		if (clip_left + clip_right >= sprite->width) return;
		if (clip_top + clip_bottom >= sprite->height) return;

		bp.skip_left = UnScaleByZoomLower(clip_left, zoom);
		bp.skip_top = UnScaleByZoomLower(clip_top, zoom);
		bp.width = UnScaleByZoom(sprite->width - clip_left - clip_right, zoom);
		bp.height = UnScaleByZoom(sprite->height - clip_top - clip_bottom, zoom);

		x += ScaleByZoom(bp.skip_left, zoom);
		y += ScaleByZoom(bp.skip_top, zoom);
	}

	/* Copy the main data directly from the sprite */
	bp.sprite = sprite->data;
	bp.sprite_width = sprite->width;
	bp.sprite_height = sprite->height;
	bp.top = 0;
	bp.left = 0;

	bp.dst = dpi->dst_ptr;
	bp.pitch = dpi->pitch;
	bp.remap = _colour_remap_ptr;

	assert(sprite->width > 0);
	assert(sprite->height > 0);

	if (bp.width <= 0) return;
	if (bp.height <= 0) return;

	y -= SCALED_XY ? ScaleByZoom(dpi->top, zoom) : dpi->top;
	int y_unscaled = UnScaleByZoom(y, zoom);
	/* Check for top overflow */
	if (y < 0) {
		bp.height -= -y_unscaled;
		if (bp.height <= 0) return;
		bp.skip_top += -y_unscaled;
		y = 0;
	} else {
		bp.top = y_unscaled;
	}

	/* Check for bottom overflow */
	y += SCALED_XY ? ScaleByZoom(bp.height - dpi->height, zoom) : ScaleByZoom(bp.height, zoom) - dpi->height;
	if (y > 0) {
		bp.height -= UnScaleByZoom(y, zoom);
		if (bp.height <= 0) return;
	}

	x -= SCALED_XY ? ScaleByZoom(dpi->left, zoom) : dpi->left;
	int x_unscaled = UnScaleByZoom(x, zoom);
	/* Check for left overflow */
	if (x < 0) {
		bp.width -= -x_unscaled;
		if (bp.width <= 0) return;
		bp.skip_left += -x_unscaled;
		x = 0;
	} else {
		bp.left = x_unscaled;
	}

	/* Check for right overflow */
	x += SCALED_XY ? ScaleByZoom(bp.width - dpi->width, zoom) : ScaleByZoom(bp.width, zoom) - dpi->width;
	if (x > 0) {
		bp.width -= UnScaleByZoom(x, zoom);
		if (bp.width <= 0) return;
	}

	assert(bp.skip_left + bp.width <= UnScaleByZoom(sprite->width, zoom));
	assert(bp.skip_top + bp.height <= UnScaleByZoom(sprite->height, zoom));

	/* We do not want to catch the mouse. However we also use that spritenumber for unknown (text) sprites. */
	if (_newgrf_debug_sprite_picker.mode == SPM_REDRAW && sprite_id != SPR_CURSOR_MOUSE) {
		Blitter *blitter = BlitterFactory::GetCurrentBlitter();
		void *topleft = blitter->MoveTo(bp.dst, bp.left, bp.top);
		void *bottomright = blitter->MoveTo(topleft, bp.width - 1, bp.height - 1);

		void *clicked = _newgrf_debug_sprite_picker.clicked_pixel;

		if (topleft <= clicked && clicked <= bottomright) {
			uint offset = (((size_t)clicked - (size_t)topleft) / (blitter->GetScreenDepth() / 8)) % bp.pitch;
			if (offset < (uint)bp.width) {
				include(_newgrf_debug_sprite_picker.sprites, sprite_id);
			}
		}
	}

	BlitterFactory::GetCurrentBlitter()->Draw(&bp, mode, zoom);
}

/**
 * Draws a sprite to a new RGBA buffer (see Colour union) instead of drawing to the screen.
 *
 * @param spriteId The sprite to draw.
 * @param zoom The zoom level at which to draw the sprites.
 * @return Pixel buffer, or nullptr if an 8bpp blitter is being used.
 */
std::unique_ptr<uint32_t[]> DrawSpriteToRgbaBuffer(SpriteID spriteId, ZoomLevel zoom)
{
	/* Invalid zoom level requested? */
	if (zoom < _settings_client.gui.zoom_min || zoom > _settings_client.gui.zoom_max) return nullptr;

	Blitter *blitter = BlitterFactory::GetCurrentBlitter();
	if (blitter->GetScreenDepth() != 8 && blitter->GetScreenDepth() != 32) return nullptr;

	/* Gather information about the sprite to write, reserve memory */
	const SpriteID real_sprite = GB(spriteId, 0, SPRITE_WIDTH);
	const Sprite *sprite = GetSprite(real_sprite, SpriteType::Normal);
	Dimension dim = GetSpriteSize(real_sprite, nullptr, zoom);
	size_t dim_size = static_cast<size_t>(dim.width) * dim.height;
	std::unique_ptr<uint32_t[]> result(new uint32_t[dim_size]);
	/* Set buffer to fully transparent. */
	MemSetT(result.get(), 0, dim_size);

	/* Prepare new DrawPixelInfo - Normally this would be the screen but we want to draw to another buffer here.
	 * Normally, pitch would be scaled screen width, but in our case our "screen" is only the sprite width wide. */
	DrawPixelInfo dpi;
	dpi.dst_ptr = result.get();
	dpi.pitch = dim.width;
	dpi.left = 0;
	dpi.top = 0;
	dpi.width = dim.width;
	dpi.height = dim.height;
	dpi.zoom = zoom;

	dim_size = static_cast<size_t>(dim.width) * dim.height;

	/* If the current blitter is a paletted blitter, we have to render to an extra buffer and resolve the palette later. */
	std::unique_ptr<byte[]> pal_buffer{};
	if (blitter->GetScreenDepth() == 8) {
		pal_buffer.reset(new byte[dim_size]);
		MemSetT(pal_buffer.get(), 0, dim_size);

		dpi.dst_ptr = pal_buffer.get();
	}

	/* Temporarily disable screen animations while blitting - This prevents 40bpp_anim from writing to the animation buffer. */
	Backup<bool> disable_anim(_screen_disable_anim, true, FILE_LINE);
	GfxBlitter<1, true>(sprite, 0, 0, BM_NORMAL, nullptr, real_sprite, zoom, &dpi);
	disable_anim.Restore();

	if (blitter->GetScreenDepth() == 8) {
		/* Resolve palette. */
		uint32_t *dst = result.get();
		const byte *src = pal_buffer.get();
		for (size_t i = 0; i < dim_size; ++i) {
			*dst++ = _cur_palette.palette[*src++].data;
		}
	}

	return result;
}

static void GfxMainBlitterViewport(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub, SpriteID sprite_id)
{
	GfxBlitter<ZOOM_LVL_BASE, false>(sprite, x, y, mode, sub, sprite_id, _cur_dpi->zoom);
}

static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub, SpriteID sprite_id, ZoomLevel zoom)
{
	GfxBlitter<1, true>(sprite, x, y, mode, sub, sprite_id, zoom);
}

/**
 * Initialize _stringwidth_table cache
 * @param monospace Whether to load the monospace cache or the normal fonts.
 */
void LoadStringWidthTable(bool monospace)
{
	ClearFontCache();

	for (FontSize fs = monospace ? FS_MONO : FS_BEGIN; fs < (monospace ? FS_END : FS_MONO); fs++) {
		for (uint i = 0; i != 224; i++) {
			_stringwidth_table[fs][i] = GetGlyphWidth(fs, i + 32);
		}
	}
}

/**
 * Return width of character glyph.
 * @param size  Font of the character
 * @param key   Character code glyph
 * @return Width of the character glyph
 */
byte GetCharacterWidth(FontSize size, char32_t key)
{
	/* Use _stringwidth_table cache if possible */
	if (key >= 32 && key < 256) return _stringwidth_table[size][key - 32];

	return GetGlyphWidth(size, key);
}

/**
 * Return the maximum width of single digit.
 * @param size  Font of the digit
 * @return Width of the digit.
 */
byte GetDigitWidth(FontSize size)
{
	byte width = 0;
	for (char c = '0'; c <= '9'; c++) {
		width = std::max(GetCharacterWidth(size, c), width);
	}
	return width;
}

/**
 * Determine the broadest digits for guessing the maximum width of a n-digit number.
 * @param[out] front Broadest digit, which is not 0. (Use this digit as first digit for numbers with more than one digit.)
 * @param[out] next Broadest digit, including 0. (Use this digit for all digits, except the first one; or for numbers with only one digit.)
 * @param size  Font of the digit
 */
void GetBroadestDigit(uint *front, uint *next, FontSize size)
{
	int width = -1;
	for (char c = '9'; c >= '0'; c--) {
		int w = GetCharacterWidth(size, c);
		if (w > width) {
			width = w;
			*next = c - '0';
			if (c != '0') *front = c - '0';
		}
	}
}

void ScreenSizeChanged()
{
	_dirty_bytes_per_line = CeilDiv(_screen.width, DIRTY_BLOCK_WIDTH);
	_dirty_blocks = ReallocT<byte>(_dirty_blocks, static_cast<size_t>(_dirty_bytes_per_line) * CeilDiv(_screen.height, DIRTY_BLOCK_HEIGHT));

	/* check the dirty rect */
	if (_invalid_rect.right >= _screen.width) _invalid_rect.right = _screen.width;
	if (_invalid_rect.bottom >= _screen.height) _invalid_rect.bottom = _screen.height;

	/* screen size changed and the old bitmap is invalid now, so we don't want to undraw it */
	_cursor.visible = false;
}

void UndrawMouseCursor()
{
	/* Don't undraw mouse cursor if it is handled by the video driver. */
	if (VideoDriver::GetInstance()->UseSystemCursor()) return;

	/* Don't undraw the mouse cursor if the screen is not ready */
	if (_screen.dst_ptr == nullptr) return;

	if (_cursor.visible) {
		Blitter *blitter = BlitterFactory::GetCurrentBlitter();
		_cursor.visible = false;
		blitter->CopyFromBuffer(blitter->MoveTo(_screen.dst_ptr, _cursor.draw_pos.x, _cursor.draw_pos.y), _cursor_backup.GetBuffer(), _cursor.draw_size.x, _cursor.draw_size.y);
		VideoDriver::GetInstance()->MakeDirty(_cursor.draw_pos.x, _cursor.draw_pos.y, _cursor.draw_size.x, _cursor.draw_size.y);
	}
}

void DrawMouseCursor()
{
	/* Don't draw mouse cursor if it is handled by the video driver. */
	if (VideoDriver::GetInstance()->UseSystemCursor()) return;

	/* Don't draw the mouse cursor if the screen is not ready */
	if (_screen.dst_ptr == nullptr) return;

	Blitter *blitter = BlitterFactory::GetCurrentBlitter();

	/* Redraw mouse cursor but only when it's inside the window */
	if (!_cursor.in_window) return;

	/* Don't draw the mouse cursor if it's already drawn */
	if (_cursor.visible) {
		if (!_cursor.dirty) return;
		UndrawMouseCursor();
	}

	/* Determine visible area */
	int left = _cursor.pos.x + _cursor.total_offs.x;
	int width = _cursor.total_size.x;
	if (left < 0) {
		width += left;
		left = 0;
	}
	if (left + width > _screen.width) {
		width = _screen.width - left;
	}
	if (width <= 0) return;

	int top = _cursor.pos.y + _cursor.total_offs.y;
	int height = _cursor.total_size.y;
	if (top < 0) {
		height += top;
		top = 0;
	}
	if (top + height > _screen.height) {
		height = _screen.height - top;
	}
	if (height <= 0) return;

	_cursor.draw_pos.x = left;
	_cursor.draw_pos.y = top;
	_cursor.draw_size.x = width;
	_cursor.draw_size.y = height;

	uint8_t *buffer = _cursor_backup.Allocate(blitter->BufferSize(_cursor.draw_size.x, _cursor.draw_size.y));

	/* Make backup of stuff below cursor */
	blitter->CopyToBuffer(blitter->MoveTo(_screen.dst_ptr, _cursor.draw_pos.x, _cursor.draw_pos.y), buffer, _cursor.draw_size.x, _cursor.draw_size.y);

	/* Draw cursor on screen */
	_cur_dpi = &_screen;
	for (uint i = 0; i < _cursor.sprite_count; ++i) {
		DrawSprite(_cursor.sprite_seq[i].sprite, _cursor.sprite_seq[i].pal, _cursor.pos.x + _cursor.sprite_pos[i].x, _cursor.pos.y + _cursor.sprite_pos[i].y);
	}

	VideoDriver::GetInstance()->MakeDirty(_cursor.draw_pos.x, _cursor.draw_pos.y, _cursor.draw_size.x, _cursor.draw_size.y);

	_cursor.visible = true;
	_cursor.dirty = false;
}

/**
 * Repaints a specific rectangle of the screen.
 *
 * @param left,top,right,bottom The area of the screen that needs repainting
 * @pre The rectangle should have been previously marked dirty with \c AddDirtyBlock.
 * @see AddDirtyBlock
 * @see DrawDirtyBlocks
 * @ingroup dirty
 *
 */
void RedrawScreenRect(int left, int top, int right, int bottom)
{
	assert(right <= _screen.width && bottom <= _screen.height);
	if (_cursor.visible) {
		if (right > _cursor.draw_pos.x &&
				left < _cursor.draw_pos.x + _cursor.draw_size.x &&
				bottom > _cursor.draw_pos.y &&
				top < _cursor.draw_pos.y + _cursor.draw_size.y) {
			UndrawMouseCursor();
		}
	}

	if (_networking) NetworkUndrawChatMessage();

	DrawOverlappedWindowForAll(left, top, right, bottom);

	VideoDriver::GetInstance()->MakeDirty(left, top, right - left, bottom - top);
}

/**
 * Repaints the rectangle blocks which are marked as 'dirty'.
 *
 * @see AddDirtyBlock
 *
 * @ingroup dirty
 */
void DrawDirtyBlocks()
{
	byte *b = _dirty_blocks;
	const int w = Align(_screen.width,  DIRTY_BLOCK_WIDTH);
	const int h = Align(_screen.height, DIRTY_BLOCK_HEIGHT);
	int x;
	int y;

	y = 0;
	do {
		x = 0;
		do {
			if (*b != 0) {
				int left;
				int top;
				int right = x + DIRTY_BLOCK_WIDTH;
				int bottom = y;
				byte *p = b;
				int h2;

				/* First try coalescing downwards */
				do {
					*p = 0;
					p += _dirty_bytes_per_line;
					bottom += DIRTY_BLOCK_HEIGHT;
				} while (bottom != h && *p != 0);

				/* Try coalescing to the right too. */
				h2 = (bottom - y) / DIRTY_BLOCK_HEIGHT;
				assert(h2 > 0);
				p = b;

				while (right != w) {
					byte *p2 = ++p;
					int i = h2;
					/* Check if a full line of dirty flags is set. */
					do {
						if (!*p2) goto no_more_coalesc;
						p2 += _dirty_bytes_per_line;
					} while (--i != 0);

					/* Wohoo, can combine it one step to the right!
					 * Do that, and clear the bits. */
					right += DIRTY_BLOCK_WIDTH;

					i = h2;
					p2 = p;
					do {
						*p2 = 0;
						p2 += _dirty_bytes_per_line;
					} while (--i != 0);
				}
				no_more_coalesc:

				left = x;
				top = y;

				if (left   < _invalid_rect.left  ) left   = _invalid_rect.left;
				if (top    < _invalid_rect.top   ) top    = _invalid_rect.top;
				if (right  > _invalid_rect.right ) right  = _invalid_rect.right;
				if (bottom > _invalid_rect.bottom) bottom = _invalid_rect.bottom;

				if (left < right && top < bottom) {
					RedrawScreenRect(left, top, right, bottom);
				}

			}
		} while (b++, (x += DIRTY_BLOCK_WIDTH) != w);
	} while (b += -(int)(w / DIRTY_BLOCK_WIDTH) + _dirty_bytes_per_line, (y += DIRTY_BLOCK_HEIGHT) != h);

	++_dirty_block_colour;
	_invalid_rect.left = w;
	_invalid_rect.top = h;
	_invalid_rect.right = 0;
	_invalid_rect.bottom = 0;
}

/**
 * Extend the internal _invalid_rect rectangle to contain the rectangle
 * defined by the given parameters. Note the point (0,0) is top left.
 *
 * @param left The left edge of the rectangle
 * @param top The top edge of the rectangle
 * @param right The right edge of the rectangle
 * @param bottom The bottom edge of the rectangle
 * @see DrawDirtyBlocks
 * @ingroup dirty
 *
 */
void AddDirtyBlock(int left, int top, int right, int bottom)
{
	byte *b;
	int width;
	int height;

	if (left < 0) left = 0;
	if (top < 0) top = 0;
	if (right > _screen.width) right = _screen.width;
	if (bottom > _screen.height) bottom = _screen.height;

	if (left >= right || top >= bottom) return;

	if (left   < _invalid_rect.left  ) _invalid_rect.left   = left;
	if (top    < _invalid_rect.top   ) _invalid_rect.top    = top;
	if (right  > _invalid_rect.right ) _invalid_rect.right  = right;
	if (bottom > _invalid_rect.bottom) _invalid_rect.bottom = bottom;

	left /= DIRTY_BLOCK_WIDTH;
	top  /= DIRTY_BLOCK_HEIGHT;

	b = _dirty_blocks + top * _dirty_bytes_per_line + left;

	width  = ((right  - 1) / DIRTY_BLOCK_WIDTH)  - left + 1;
	height = ((bottom - 1) / DIRTY_BLOCK_HEIGHT) - top  + 1;

	assert(width > 0 && height > 0);

	do {
		int i = width;

		do b[--i] = 0xFF; while (i != 0);

		b += _dirty_bytes_per_line;
	} while (--height != 0);
}

/**
 * This function mark the whole screen as dirty. This results in repainting
 * the whole screen. Use this with care as this function will break the
 * idea about marking only parts of the screen as 'dirty'.
 * @ingroup dirty
 */
void MarkWholeScreenDirty()
{
	AddDirtyBlock(0, 0, _screen.width, _screen.height);
}

/**
 * Set up a clipping area for only drawing into a certain area. To do this,
 * Fill a DrawPixelInfo object with the supplied relative rectangle, backup
 * the original (calling) _cur_dpi and assign the just returned DrawPixelInfo
 * _cur_dpi. When you are done, give restore _cur_dpi's original value
 * @param *n the DrawPixelInfo that will be the clipping rectangle box allowed
 * for drawing
 * @param left,top,width,height the relative coordinates of the clipping
 * rectangle relative to the current _cur_dpi. This will most likely be the
 * offset from the calling window coordinates
 * @return return false if the requested rectangle is not possible with the
 * current dpi pointer. Only continue of the return value is true, or you'll
 * get some nasty results
 */
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height)
{
	Blitter *blitter = BlitterFactory::GetCurrentBlitter();
	const DrawPixelInfo *o = _cur_dpi;

	n->zoom = ZOOM_LVL_NORMAL;

	assert(width > 0);
	assert(height > 0);

	if ((left -= o->left) < 0) {
		width += left;
		if (width <= 0) return false;
		n->left = -left;
		left = 0;
	} else {
		n->left = 0;
	}

	if (width > o->width - left) {
		width = o->width - left;
		if (width <= 0) return false;
	}
	n->width = width;

	if ((top -= o->top) < 0) {
		height += top;
		if (height <= 0) return false;
		n->top = -top;
		top = 0;
	} else {
		n->top = 0;
	}

	n->dst_ptr = blitter->MoveTo(o->dst_ptr, left, top);
	n->pitch = o->pitch;

	if (height > o->height - top) {
		height = o->height - top;
		if (height <= 0) return false;
	}
	n->height = height;

	return true;
}

/**
 * Update cursor dimension.
 * Called when changing cursor sprite resp. reloading grfs.
 */
void UpdateCursorSize()
{
	/* Ignore setting any cursor before the sprites are loaded. */
	if (GetMaxSpriteID() == 0) return;

	static_assert(lengthof(_cursor.sprite_seq) == lengthof(_cursor.sprite_pos));
	assert(_cursor.sprite_count <= lengthof(_cursor.sprite_seq));
	for (uint i = 0; i < _cursor.sprite_count; ++i) {
		const Sprite *p = GetSprite(GB(_cursor.sprite_seq[i].sprite, 0, SPRITE_WIDTH), SpriteType::Normal);
		Point offs, size;
		offs.x = UnScaleGUI(p->x_offs) + _cursor.sprite_pos[i].x;
		offs.y = UnScaleGUI(p->y_offs) + _cursor.sprite_pos[i].y;
		size.x = UnScaleGUI(p->width);
		size.y = UnScaleGUI(p->height);

		if (i == 0) {
			_cursor.total_offs = offs;
			_cursor.total_size = size;
		} else {
			int right  = std::max(_cursor.total_offs.x + _cursor.total_size.x, offs.x + size.x);
			int bottom = std::max(_cursor.total_offs.y + _cursor.total_size.y, offs.y + size.y);
			if (offs.x < _cursor.total_offs.x) _cursor.total_offs.x = offs.x;
			if (offs.y < _cursor.total_offs.y) _cursor.total_offs.y = offs.y;
			_cursor.total_size.x = right  - _cursor.total_offs.x;
			_cursor.total_size.y = bottom - _cursor.total_offs.y;
		}
	}

	_cursor.dirty = true;
}

/**
 * Switch cursor to different sprite.
 * @param cursor Sprite to draw for the cursor.
 * @param pal Palette to use for recolouring.
 */
static void SetCursorSprite(CursorID cursor, PaletteID pal)
{
	if (_cursor.sprite_count == 1 && _cursor.sprite_seq[0].sprite == cursor && _cursor.sprite_seq[0].pal == pal) return;

	_cursor.sprite_count = 1;
	_cursor.sprite_seq[0].sprite = cursor;
	_cursor.sprite_seq[0].pal = pal;
	_cursor.sprite_pos[0].x = 0;
	_cursor.sprite_pos[0].y = 0;

	UpdateCursorSize();
}

static void SwitchAnimatedCursor()
{
	const AnimCursor *cur = _cursor.animate_cur;

	if (cur == nullptr || cur->sprite == AnimCursor::LAST) cur = _cursor.animate_list;

	SetCursorSprite(cur->sprite, _cursor.sprite_seq[0].pal);

	_cursor.animate_timeout = cur->display_time;
	_cursor.animate_cur     = cur + 1;
}

void CursorTick()
{
	if (_cursor.animate_timeout != 0 && --_cursor.animate_timeout == 0) {
		SwitchAnimatedCursor();
	}
}

/**
 * Set or unset the ZZZ cursor.
 * @param busy Whether to show the ZZZ cursor.
 */
void SetMouseCursorBusy(bool busy)
{
	if (busy) {
		if (_cursor.sprite_seq[0].sprite == SPR_CURSOR_MOUSE) SetMouseCursor(SPR_CURSOR_ZZZ, PAL_NONE);
	} else {
		if (_cursor.sprite_seq[0].sprite == SPR_CURSOR_ZZZ) SetMouseCursor(SPR_CURSOR_MOUSE, PAL_NONE);
	}
}

/**
 * Assign a single non-animated sprite to the cursor.
 * @param sprite Sprite to draw for the cursor.
 * @param pal Palette to use for recolouring.
 * @see SetAnimatedMouseCursor
 */
void SetMouseCursor(CursorID sprite, PaletteID pal)
{
	/* Turn off animation */
	_cursor.animate_timeout = 0;
	/* Set cursor */
	SetCursorSprite(sprite, pal);
}

/**
 * Assign an animation to the cursor.
 * @param table Array of animation states.
 * @see SetMouseCursor
 */
void SetAnimatedMouseCursor(const AnimCursor *table)
{
	_cursor.animate_list = table;
	_cursor.animate_cur = nullptr;
	_cursor.sprite_seq[0].pal = PAL_NONE;
	SwitchAnimatedCursor();
}

/**
 * Update cursor position based on a relative change.
 *
 * @param delta_x How much change in the X position.
 * @param delta_y How much change in the Y position.
 */
void CursorVars::UpdateCursorPositionRelative(int delta_x, int delta_y)
{
	assert(this->fix_at);

	this->delta.x = delta_x;
	this->delta.y = delta_y;
}

/**
 * Update cursor position on mouse movement.
 * @param x New X position.
 * @param y New Y position.
 * @return true, if the OS cursor position should be warped back to this->pos.
 */
bool CursorVars::UpdateCursorPosition(int x, int y)
{
	this->delta.x = x - this->pos.x;
	this->delta.y = y - this->pos.y;

	if (this->fix_at) {
		return this->delta.x != 0 || this->delta.y != 0;
	} else if (this->pos.x != x || this->pos.y != y) {
		this->dirty = true;
		this->pos.x = x;
		this->pos.y = y;
	}

	return false;
}

bool ChangeResInGame(int width, int height)
{
	return (_screen.width == width && _screen.height == height) || VideoDriver::GetInstance()->ChangeResolution(width, height);
}

bool ToggleFullScreen(bool fs)
{
	bool result = VideoDriver::GetInstance()->ToggleFullscreen(fs);
	if (_fullscreen != fs && _resolutions.empty()) {
		Debug(driver, 0, "Could not find a suitable fullscreen resolution");
	}
	return result;
}

void SortResolutions()
{
	std::sort(_resolutions.begin(), _resolutions.end());
}

/**
 * Resolve GUI zoom level, if auto-suggestion is requested.
 */
void UpdateGUIZoom()
{
	/* Determine real GUI zoom to use. */
	if (_gui_scale_cfg == -1) {
		_gui_scale = VideoDriver::GetInstance()->GetSuggestedUIScale();
	} else {
		_gui_scale = Clamp(_gui_scale_cfg, MIN_INTERFACE_SCALE, MAX_INTERFACE_SCALE);
	}

	int8_t new_zoom = ScaleGUITrad(1) <= 1 ? ZOOM_LVL_OUT_4X : ScaleGUITrad(1) >= 4 ? ZOOM_LVL_MIN : ZOOM_LVL_OUT_2X;
	/* Font glyphs should not be clamped to min/max zoom. */
	_font_zoom = static_cast<ZoomLevel>(new_zoom);
	/* Ensure the gui_zoom is clamped between min/max. */
	new_zoom = Clamp(new_zoom, _settings_client.gui.zoom_min, _settings_client.gui.zoom_max);
	_gui_zoom = static_cast<ZoomLevel>(new_zoom);
}

/**
 * Resolve GUI zoom level and adjust GUI to new zoom, if auto-suggestion is requested.
 * @param automatic Set if the change is occuring due to OS DPI scaling being changed.
 * @returns true when the zoom level has changed, caller must call ReInitAllWindows(true)
 * after resizing the application's window/buffer.
 */
bool AdjustGUIZoom(bool automatic)
{
	ZoomLevel old_gui_zoom = _gui_zoom;
	ZoomLevel old_font_zoom = _font_zoom;
	int old_scale = _gui_scale;
	UpdateGUIZoom();
	if (old_scale == _gui_scale && old_gui_zoom == _gui_zoom) return false;

	/* Update cursors if sprite zoom level has changed. */
	if (old_gui_zoom != _gui_zoom) {
		VideoDriver::GetInstance()->ClearSystemSprites();
		UpdateCursorSize();
	}
	if (old_font_zoom != _font_zoom) {
		GfxClearFontSpriteCache();
	}
	ClearFontCache();
	LoadStringWidthTable();

	SetupWidgetDimensions();
	UpdateAllVirtCoords();

	/* Adjust all window sizes to match the new zoom level, so that they don't appear
	   to move around when the application is moved to a screen with different DPI. */
	auto zoom_shift = old_gui_zoom - _gui_zoom;
	for (Window *w : Window::Iterate()) {
		if (automatic) {
			w->left   = (w->left   * _gui_scale) / old_scale;
			w->top    = (w->top    * _gui_scale) / old_scale;
		}
		if (w->viewport != nullptr) {
			w->viewport->zoom = static_cast<ZoomLevel>(Clamp(w->viewport->zoom - zoom_shift, _settings_client.gui.zoom_min, _settings_client.gui.zoom_max));
		}
	}

	return true;
}

void ChangeGameSpeed(bool enable_fast_forward)
{
	if (enable_fast_forward) {
		_game_speed = _settings_client.gui.fast_forward_speed_limit;
	} else {
		_game_speed = 100;
	}
}