/usr/lib/python2.7/dist-packages/wx-2.6-gtk2-unicode/wx/_core.py is in python-wxgtk2.6 2.6.3.2.2-5ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814 7815 7816 7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346 8347 8348 8349 8350 8351 8352 8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 8709 8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817 8818 8819 8820 8821 8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867 8868 8869 8870 8871 8872 8873 8874 8875 8876 8877 8878 8879 8880 8881 8882 8883 8884 8885 8886 8887 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105 9106 9107 9108 9109 9110 9111 9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144 9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158 9159 9160 9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184 9185 9186 9187 9188 9189 9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205 9206 9207 9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218 9219 9220 9221 9222 9223 9224 9225 9226 9227 9228 9229 9230 9231 9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252 9253 9254 9255 9256 9257 9258 9259 9260 9261 9262 9263 9264 9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308 9309 9310 9311 9312 9313 9314 9315 9316 9317 9318 9319 9320 9321 9322 9323 9324 9325 9326 9327 9328 9329 9330 9331 9332 9333 9334 9335 9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353 9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 9423 9424 9425 9426 9427 9428 9429 9430 9431 9432 9433 9434 9435 9436 9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448 9449 9450 9451 9452 9453 9454 9455 9456 9457 9458 9459 9460 9461 9462 9463 9464 9465 9466 9467 9468 9469 9470 9471 9472 9473 9474 9475 9476 9477 9478 9479 9480 9481 9482 9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518 9519 9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556 9557 9558 9559 9560 9561 9562 9563 9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642 9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662 9663 9664 9665 9666 9667 9668 9669 9670 9671 9672 9673 9674 9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685 9686 9687 9688 9689 9690 9691 9692 9693 9694 9695 9696 9697 9698 9699 9700 9701 9702 9703 9704 9705 9706 9707 9708 9709 9710 9711 9712 9713 9714 9715 9716 9717 9718 9719 9720 9721 9722 9723 9724 9725 9726 9727 9728 9729 9730 9731 9732 9733 9734 9735 9736 9737 9738 9739 9740 9741 9742 9743 9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763 9764 9765 9766 9767 9768 9769 9770 9771 9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821 9822 9823 9824 9825 9826 9827 9828 9829 9830 9831 9832 9833 9834 9835 9836 9837 9838 9839 9840 9841 9842 9843 9844 9845 9846 9847 9848 9849 9850 9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868 9869 9870 9871 9872 9873 9874 9875 9876 9877 9878 9879 9880 9881 9882 9883 9884 9885 9886 9887 9888 9889 9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914 9915 9916 9917 9918 9919 9920 9921 9922 9923 9924 9925 9926 9927 9928 9929 9930 9931 9932 9933 9934 9935 9936 9937 9938 9939 9940 9941 9942 9943 9944 9945 9946 9947 9948 9949 9950 9951 9952 9953 9954 9955 9956 9957 9958 9959 9960 9961 9962 9963 9964 9965 9966 9967 9968 9969 9970 9971 9972 9973 9974 9975 9976 9977 9978 9979 9980 9981 9982 9983 9984 9985 9986 9987 9988 9989 9990 9991 9992 9993 9994 9995 9996 9997 9998 9999 10000 10001 10002 10003 10004 10005 10006 10007 10008 10009 10010 10011 10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022 10023 10024 10025 10026 10027 10028 10029 10030 10031 10032 10033 10034 10035 10036 10037 10038 10039 10040 10041 10042 10043 10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080 10081 10082 10083 10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106 10107 10108 10109 10110 10111 10112 10113 10114 10115 10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204 10205 10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245 10246 10247 10248 10249 10250 10251 10252 10253 10254 10255 10256 10257 10258 10259 10260 10261 10262 10263 10264 10265 10266 10267 10268 10269 10270 10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281 10282 10283 10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298 10299 10300 10301 10302 10303 10304 10305 10306 10307 10308 10309 10310 10311 10312 10313 10314 10315 10316 10317 10318 10319 10320 10321 10322 10323 10324 10325 10326 10327 10328 10329 10330 10331 10332 10333 10334 10335 10336 10337 10338 10339 10340 10341 10342 10343 10344 10345 10346 10347 10348 10349 10350 10351 10352 10353 10354 10355 10356 10357 10358 10359 10360 10361 10362 10363 10364 10365 10366 10367 10368 10369 10370 10371 10372 10373 10374 10375 10376 10377 10378 10379 10380 10381 10382 10383 10384 10385 10386 10387 10388 10389 10390 10391 10392 10393 10394 10395 10396 10397 10398 10399 10400 10401 10402 10403 10404 10405 10406 10407 10408 10409 10410 10411 10412 10413 10414 10415 10416 10417 10418 10419 10420 10421 10422 10423 10424 10425 10426 10427 10428 10429 10430 10431 10432 10433 10434 10435 10436 10437 10438 10439 10440 10441 10442 10443 10444 10445 10446 10447 10448 10449 10450 10451 10452 10453 10454 10455 10456 10457 10458 10459 10460 10461 10462 10463 10464 10465 10466 10467 10468 10469 10470 10471 10472 10473 10474 10475 10476 10477 10478 10479 10480 10481 10482 10483 10484 10485 10486 10487 10488 10489 10490 10491 10492 10493 10494 10495 10496 10497 10498 10499 10500 10501 10502 10503 10504 10505 10506 10507 10508 10509 10510 10511 10512 10513 10514 10515 10516 10517 10518 10519 10520 10521 10522 10523 10524 10525 10526 10527 10528 10529 10530 10531 10532 10533 10534 10535 10536 10537 10538 10539 10540 10541 10542 10543 10544 10545 10546 10547 10548 10549 10550 10551 10552 10553 10554 10555 10556 10557 10558 10559 10560 10561 10562 10563 10564 10565 10566 10567 10568 10569 10570 10571 10572 10573 10574 10575 10576 10577 10578 10579 10580 10581 10582 10583 10584 10585 10586 10587 10588 10589 10590 10591 10592 10593 10594 10595 10596 10597 10598 10599 10600 10601 10602 10603 10604 10605 10606 10607 10608 10609 10610 10611 10612 10613 10614 10615 10616 10617 10618 10619 10620 10621 10622 10623 10624 10625 10626 10627 10628 10629 10630 10631 10632 10633 10634 10635 10636 10637 10638 10639 10640 10641 10642 10643 10644 10645 10646 10647 10648 10649 10650 10651 10652 10653 10654 10655 10656 10657 10658 10659 10660 10661 10662 10663 10664 10665 10666 10667 10668 10669 10670 10671 10672 10673 10674 10675 10676 10677 10678 10679 10680 10681 10682 10683 10684 10685 10686 10687 10688 10689 10690 10691 10692 10693 10694 10695 10696 10697 10698 10699 10700 10701 10702 10703 10704 10705 10706 10707 10708 10709 10710 10711 10712 10713 10714 10715 10716 10717 10718 10719 10720 10721 10722 10723 10724 10725 10726 10727 10728 10729 10730 10731 10732 10733 10734 10735 10736 10737 10738 10739 10740 10741 10742 10743 10744 10745 10746 10747 10748 10749 10750 10751 10752 10753 10754 10755 10756 10757 10758 10759 10760 10761 10762 10763 10764 10765 10766 10767 10768 10769 10770 10771 10772 10773 10774 10775 10776 10777 10778 10779 10780 10781 10782 10783 10784 10785 10786 10787 10788 10789 10790 10791 10792 10793 10794 10795 10796 10797 10798 10799 10800 10801 10802 10803 10804 10805 10806 10807 10808 10809 10810 10811 10812 10813 10814 10815 10816 10817 10818 10819 10820 10821 10822 10823 10824 10825 10826 10827 10828 10829 10830 10831 10832 10833 10834 10835 10836 10837 10838 10839 10840 10841 10842 10843 10844 10845 10846 10847 10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863 10864 10865 10866 10867 10868 10869 10870 10871 10872 10873 10874 10875 10876 10877 10878 10879 10880 10881 10882 10883 10884 10885 10886 10887 10888 10889 10890 10891 10892 10893 10894 10895 10896 10897 10898 10899 10900 10901 10902 10903 10904 10905 10906 10907 10908 10909 10910 10911 10912 10913 10914 10915 10916 10917 10918 10919 10920 10921 10922 10923 10924 10925 10926 10927 10928 10929 10930 10931 10932 10933 10934 10935 10936 10937 10938 10939 10940 10941 10942 10943 10944 10945 10946 10947 10948 10949 10950 10951 10952 10953 10954 10955 10956 10957 10958 10959 10960 10961 10962 10963 10964 10965 10966 10967 10968 10969 10970 10971 10972 10973 10974 10975 10976 10977 10978 10979 10980 10981 10982 10983 10984 10985 10986 10987 10988 10989 10990 10991 10992 10993 10994 10995 10996 10997 10998 10999 11000 11001 11002 11003 11004 11005 11006 11007 11008 11009 11010 11011 11012 11013 11014 11015 11016 11017 11018 11019 11020 11021 11022 11023 11024 11025 11026 11027 11028 11029 11030 11031 11032 11033 11034 11035 11036 11037 11038 11039 11040 11041 11042 11043 11044 11045 11046 11047 11048 11049 11050 11051 11052 11053 11054 11055 11056 11057 11058 11059 11060 11061 11062 11063 11064 11065 11066 11067 11068 11069 11070 11071 11072 11073 11074 11075 11076 11077 11078 11079 11080 11081 11082 11083 11084 11085 11086 11087 11088 11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120 11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 11135 11136 11137 11138 11139 11140 11141 11142 11143 11144 11145 11146 11147 11148 11149 11150 11151 11152 11153 11154 11155 11156 11157 11158 11159 11160 11161 11162 11163 11164 11165 11166 11167 11168 11169 11170 11171 11172 11173 11174 11175 11176 11177 11178 11179 11180 11181 11182 11183 11184 11185 11186 11187 11188 11189 11190 11191 11192 11193 11194 11195 11196 11197 11198 11199 11200 11201 11202 11203 11204 11205 11206 11207 11208 11209 11210 11211 11212 11213 11214 11215 11216 11217 11218 11219 11220 11221 11222 11223 11224 11225 11226 11227 11228 11229 11230 11231 11232 11233 11234 11235 11236 11237 11238 11239 11240 11241 11242 11243 11244 11245 11246 11247 11248 11249 11250 11251 11252 11253 11254 11255 11256 11257 11258 11259 11260 11261 11262 11263 11264 11265 11266 11267 11268 11269 11270 11271 11272 11273 11274 11275 11276 11277 11278 11279 11280 11281 11282 11283 11284 11285 11286 11287 11288 11289 11290 11291 11292 11293 11294 11295 11296 11297 11298 11299 11300 11301 11302 11303 11304 11305 11306 11307 11308 11309 11310 11311 11312 11313 11314 11315 11316 11317 11318 11319 11320 11321 11322 11323 11324 11325 11326 11327 11328 11329 11330 11331 11332 11333 11334 11335 11336 11337 11338 11339 11340 11341 11342 11343 11344 11345 11346 11347 11348 11349 11350 11351 11352 11353 11354 11355 11356 11357 11358 11359 11360 11361 11362 11363 11364 11365 11366 11367 11368 11369 11370 11371 11372 11373 11374 11375 11376 11377 11378 11379 11380 11381 11382 11383 11384 11385 11386 11387 11388 11389 11390 11391 11392 11393 11394 11395 11396 11397 11398 11399 11400 11401 11402 11403 11404 11405 11406 11407 11408 11409 11410 11411 11412 11413 11414 11415 11416 11417 11418 11419 11420 11421 11422 11423 11424 11425 11426 11427 11428 11429 11430 11431 11432 11433 11434 11435 11436 11437 11438 11439 11440 11441 11442 11443 11444 11445 11446 11447 11448 11449 11450 11451 11452 11453 11454 11455 11456 11457 11458 11459 11460 11461 11462 11463 11464 11465 11466 11467 11468 11469 11470 11471 11472 11473 11474 11475 11476 11477 11478 11479 11480 11481 11482 11483 11484 11485 11486 11487 11488 11489 11490 11491 11492 11493 11494 11495 11496 11497 11498 11499 11500 11501 11502 11503 11504 11505 11506 11507 11508 11509 11510 11511 11512 11513 11514 11515 11516 11517 11518 11519 11520 11521 11522 11523 11524 11525 11526 11527 11528 11529 11530 11531 11532 11533 11534 11535 11536 11537 11538 11539 11540 11541 11542 11543 11544 11545 11546 11547 11548 11549 11550 11551 11552 11553 11554 11555 11556 11557 11558 11559 11560 11561 11562 11563 11564 11565 11566 11567 11568 11569 11570 11571 11572 11573 11574 11575 11576 11577 11578 11579 11580 11581 11582 11583 11584 11585 11586 11587 11588 11589 11590 11591 11592 11593 11594 11595 11596 11597 11598 11599 11600 11601 11602 11603 11604 11605 11606 11607 11608 11609 11610 11611 11612 11613 11614 11615 11616 11617 11618 11619 11620 11621 11622 11623 11624 11625 11626 11627 11628 11629 11630 11631 11632 11633 11634 11635 11636 11637 11638 11639 11640 11641 11642 11643 11644 11645 11646 11647 11648 11649 11650 11651 11652 11653 11654 11655 11656 11657 11658 11659 11660 11661 11662 11663 11664 11665 11666 11667 11668 11669 11670 11671 11672 11673 11674 11675 11676 11677 11678 11679 11680 11681 11682 11683 11684 11685 11686 11687 11688 11689 11690 11691 11692 11693 11694 11695 11696 11697 11698 11699 11700 11701 11702 11703 11704 11705 11706 11707 11708 11709 11710 11711 11712 11713 11714 11715 11716 11717 11718 11719 11720 11721 11722 11723 11724 11725 11726 11727 11728 11729 11730 11731 11732 11733 11734 11735 11736 11737 11738 11739 11740 11741 11742 11743 11744 11745 11746 11747 11748 11749 11750 11751 11752 11753 11754 11755 11756 11757 11758 11759 11760 11761 11762 11763 11764 11765 11766 11767 11768 11769 11770 11771 11772 11773 11774 11775 11776 11777 11778 11779 11780 11781 11782 11783 11784 11785 11786 11787 11788 11789 11790 11791 11792 11793 11794 11795 11796 11797 11798 11799 11800 11801 11802 11803 11804 11805 11806 11807 11808 11809 11810 11811 11812 11813 11814 11815 11816 11817 11818 11819 11820 11821 11822 11823 11824 11825 11826 11827 11828 11829 11830 11831 11832 11833 11834 11835 11836 11837 11838 11839 11840 11841 11842 11843 11844 11845 11846 11847 11848 11849 11850 11851 11852 11853 11854 11855 11856 11857 11858 11859 11860 11861 11862 11863 11864 11865 11866 11867 11868 11869 11870 11871 11872 11873 11874 11875 11876 11877 11878 11879 11880 11881 11882 11883 11884 11885 11886 11887 11888 11889 11890 11891 11892 11893 11894 11895 11896 11897 11898 11899 11900 11901 11902 11903 11904 11905 11906 11907 11908 11909 11910 11911 11912 11913 11914 11915 11916 11917 11918 11919 11920 11921 11922 11923 11924 11925 11926 11927 11928 11929 11930 11931 11932 11933 11934 11935 11936 11937 11938 11939 11940 11941 11942 11943 11944 11945 11946 11947 11948 11949 11950 11951 11952 11953 11954 11955 11956 11957 11958 11959 11960 11961 11962 11963 11964 11965 11966 11967 11968 11969 11970 11971 11972 11973 11974 11975 11976 11977 11978 11979 11980 11981 11982 11983 11984 11985 11986 11987 11988 11989 11990 11991 11992 11993 11994 11995 11996 11997 11998 11999 12000 12001 12002 12003 12004 12005 12006 12007 12008 12009 12010 12011 12012 12013 12014 12015 12016 12017 12018 12019 12020 12021 12022 12023 12024 12025 12026 12027 12028 12029 12030 12031 12032 12033 12034 12035 12036 12037 12038 12039 12040 12041 12042 12043 12044 12045 12046 12047 12048 12049 12050 12051 12052 12053 12054 12055 12056 12057 12058 12059 12060 12061 12062 12063 12064 12065 12066 12067 12068 12069 12070 12071 12072 12073 12074 12075 12076 12077 12078 12079 12080 12081 12082 12083 12084 12085 12086 12087 12088 12089 12090 12091 12092 12093 12094 12095 12096 12097 12098 12099 12100 12101 12102 12103 12104 12105 12106 12107 12108 12109 12110 12111 12112 12113 12114 12115 12116 12117 12118 12119 12120 12121 12122 12123 12124 12125 12126 12127 12128 12129 12130 12131 12132 12133 12134 12135 12136 12137 12138 12139 12140 12141 12142 12143 12144 12145 12146 12147 12148 12149 12150 12151 12152 12153 12154 12155 12156 12157 12158 12159 12160 12161 12162 12163 12164 12165 12166 12167 12168 12169 12170 12171 12172 12173 12174 12175 12176 12177 12178 12179 12180 12181 12182 12183 12184 12185 12186 12187 12188 12189 12190 12191 12192 12193 12194 12195 12196 12197 12198 12199 12200 12201 12202 12203 12204 12205 12206 12207 12208 12209 12210 12211 12212 12213 12214 12215 12216 12217 12218 12219 12220 12221 12222 12223 12224 12225 12226 12227 12228 12229 12230 12231 12232 12233 12234 12235 12236 12237 12238 12239 12240 12241 12242 12243 12244 12245 12246 12247 12248 12249 12250 12251 12252 12253 12254 12255 12256 12257 12258 12259 12260 12261 12262 12263 12264 12265 12266 12267 12268 12269 12270 12271 12272 12273 12274 12275 12276 12277 12278 12279 12280 12281 12282 12283 12284 12285 12286 12287 12288 12289 12290 12291 12292 12293 12294 12295 12296 12297 12298 12299 12300 12301 12302 12303 12304 12305 12306 12307 12308 12309 12310 12311 12312 12313 12314 12315 12316 12317 12318 12319 12320 12321 12322 12323 12324 12325 12326 12327 12328 12329 12330 12331 12332 12333 12334 12335 12336 12337 12338 12339 12340 12341 12342 12343 12344 12345 12346 12347 12348 12349 12350 12351 12352 12353 12354 12355 12356 12357 12358 12359 12360 12361 12362 12363 12364 12365 12366 12367 12368 12369 12370 12371 12372 12373 12374 12375 12376 12377 12378 12379 12380 12381 12382 12383 12384 12385 12386 12387 12388 12389 12390 12391 12392 12393 12394 12395 12396 12397 12398 12399 12400 12401 12402 12403 12404 12405 12406 12407 12408 12409 12410 12411 12412 12413 12414 12415 12416 12417 12418 12419 12420 12421 12422 12423 12424 12425 12426 12427 12428 12429 12430 12431 12432 12433 12434 12435 12436 12437 12438 12439 12440 12441 12442 12443 12444 12445 12446 12447 12448 12449 12450 12451 12452 12453 12454 12455 12456 12457 12458 12459 12460 12461 12462 12463 12464 12465 12466 12467 12468 12469 12470 12471 12472 12473 12474 12475 12476 12477 12478 12479 12480 12481 12482 12483 12484 12485 12486 12487 12488 12489 12490 12491 12492 12493 12494 12495 12496 12497 12498 12499 12500 12501 12502 12503 12504 12505 12506 12507 12508 12509 12510 12511 12512 12513 12514 12515 12516 12517 12518 12519 12520 12521 12522 12523 12524 12525 12526 12527 12528 12529 12530 12531 12532 12533 12534 12535 12536 12537 12538 12539 12540 12541 12542 12543 12544 12545 12546 12547 12548 12549 12550 12551 12552 12553 12554 12555 12556 12557 12558 12559 12560 12561 12562 12563 12564 12565 12566 12567 12568 12569 12570 12571 12572 12573 12574 12575 12576 12577 12578 12579 12580 12581 12582 12583 12584 12585 12586 12587 12588 12589 12590 12591 12592 12593 12594 12595 12596 12597 12598 12599 12600 12601 12602 12603 12604 12605 12606 12607 12608 12609 12610 12611 12612 12613 12614 12615 12616 12617 12618 12619 12620 12621 12622 12623 12624 12625 12626 12627 12628 12629 12630 12631 12632 12633 12634 12635 12636 12637 12638 12639 12640 12641 12642 12643 12644 12645 12646 12647 12648 12649 12650 12651 12652 12653 12654 12655 12656 12657 12658 12659 12660 12661 12662 12663 12664 12665 12666 12667 12668 12669 12670 12671 12672 12673 12674 12675 12676 12677 12678 12679 12680 12681 12682 12683 12684 12685 12686 12687 12688 12689 12690 12691 12692 12693 12694 12695 12696 12697 12698 12699 12700 12701 12702 12703 12704 12705 12706 12707 12708 12709 12710 12711 12712 12713 12714 12715 12716 12717 12718 12719 12720 12721 12722 12723 12724 12725 12726 12727 12728 12729 12730 12731 12732 12733 12734 12735 12736 12737 12738 12739 12740 12741 12742 12743 12744 12745 12746 12747 12748 12749 12750 12751 12752 12753 12754 12755 12756 12757 12758 12759 12760 12761 12762 12763 12764 12765 12766 12767 12768 12769 12770 12771 12772 12773 12774 12775 12776 12777 12778 12779 12780 12781 12782 12783 12784 12785 12786 12787 12788 12789 12790 12791 12792 12793 12794 12795 12796 12797 12798 12799 12800 12801 12802 12803 12804 12805 12806 12807 12808 12809 12810 12811 12812 12813 12814 12815 12816 12817 12818 12819 12820 12821 12822 12823 12824 12825 12826 12827 12828 12829 12830 12831 12832 12833 12834 12835 12836 12837 12838 12839 12840 12841 12842 12843 12844 12845 12846 12847 12848 12849 12850 12851 12852 12853 12854 12855 12856 12857 12858 12859 12860 12861 12862 12863 12864 12865 12866 12867 12868 12869 12870 12871 12872 12873 12874 12875 12876 12877 12878 12879 12880 12881 12882 12883 12884 12885 12886 12887 12888 12889 12890 12891 12892 12893 12894 12895 12896 12897 12898 12899 12900 12901 12902 12903 12904 12905 12906 12907 12908 12909 12910 12911 12912 12913 12914 12915 12916 12917 12918 12919 12920 12921 12922 12923 12924 12925 12926 12927 12928 12929 12930 12931 12932 12933 12934 12935 12936 12937 12938 12939 12940 12941 12942 12943 12944 12945 12946 12947 12948 12949 12950 12951 12952 12953 12954 12955 12956 12957 12958 12959 12960 12961 12962 12963 12964 12965 12966 12967 12968 12969 12970 12971 12972 12973 12974 12975 12976 12977 12978 12979 12980 12981 12982 12983 12984 12985 12986 12987 12988 12989 12990 12991 12992 12993 12994 12995 12996 12997 12998 12999 13000 13001 13002 13003 13004 13005 13006 13007 13008 13009 13010 13011 13012 13013 13014 13015 13016 13017 13018 13019 13020 13021 13022 13023 13024 13025 13026 13027 13028 13029 13030 13031 13032 13033 13034 13035 13036 13037 13038 13039 13040 13041 13042 13043 13044 13045 13046 13047 13048 13049 13050 13051 13052 13053 13054 13055 13056 13057 13058 13059 13060 13061 13062 13063 13064 13065 13066 13067 13068 13069 13070 13071 13072 13073 13074 13075 13076 13077 13078 13079 13080 13081 13082 13083 13084 13085 13086 13087 13088 13089 13090 13091 13092 13093 13094 13095 13096 13097 13098 13099 13100 13101 13102 13103 13104 13105 13106 13107 13108 13109 13110 13111 13112 13113 13114 13115 13116 13117 13118 13119 13120 13121 13122 13123 13124 13125 13126 13127 13128 13129 13130 13131 13132 13133 13134 13135 13136 13137 13138 13139 13140 13141 13142 13143 13144 13145 13146 13147 13148 13149 13150 13151 13152 13153 13154 13155 13156 13157 13158 13159 13160 13161 13162 13163 13164 13165 13166 13167 13168 13169 13170 13171 13172 13173 13174 13175 13176 13177 13178 13179 13180 13181 13182 13183 13184 13185 13186 13187 13188 13189 13190 13191 13192 13193 13194 13195 13196 13197 13198 13199 13200 13201 13202 13203 13204 13205 13206 13207 13208 13209 13210 13211 13212 13213 13214 13215 13216 13217 13218 13219 13220 13221 13222 13223 13224 13225 13226 13227 13228 13229 13230 13231 13232 13233 13234 13235 13236 13237 13238 13239 13240 13241 13242 13243 13244 13245 13246 13247 13248 13249 13250 13251 13252 13253 13254 13255 13256 13257 13258 13259 13260 13261 13262 13263 13264 13265 13266 13267 13268 13269 13270 13271 13272 13273 13274 13275 13276 13277 13278 13279 13280 13281 13282 13283 13284 13285 13286 13287 13288 13289 13290 13291 13292 13293 13294 13295 13296 13297 13298 13299 13300 13301 13302 13303 13304 13305 13306 13307 13308 13309 13310 13311 13312 13313 13314 13315 13316 13317 13318 13319 13320 13321 13322 13323 13324 13325 13326 13327 13328 13329 13330 13331 13332 13333 13334 13335 13336 13337 13338 13339 13340 13341 13342 13343 13344 13345 13346 13347 13348 13349 13350 13351 13352 13353 13354 13355 13356 13357 13358 13359 13360 13361 13362 13363 13364 13365 13366 13367 13368 13369 13370 13371 13372 13373 13374 13375 13376 13377 13378 13379 13380 13381 13382 13383 13384 13385 13386 13387 13388 13389 13390 13391 13392 13393 13394 13395 13396 13397 13398 13399 13400 13401 13402 13403 13404 13405 13406 13407 13408 13409 13410 13411 13412 13413 13414 13415 13416 13417 13418 13419 13420 13421 13422 13423 13424 13425 13426 13427 13428 13429 13430 13431 13432 13433 13434 13435 13436 13437 13438 13439 13440 13441 13442 13443 13444 13445 13446 13447 13448 13449 13450 13451 13452 13453 13454 13455 13456 13457 13458 13459 13460 13461 13462 13463 13464 13465 13466 13467 13468 13469 13470 13471 13472 13473 13474 13475 13476 13477 13478 13479 13480 13481 13482 13483 13484 13485 13486 13487 13488 13489 13490 13491 13492 13493 13494 13495 13496 13497 13498 13499 13500 13501 13502 13503 13504 13505 13506 13507 13508 13509 13510 13511 13512 13513 13514 13515 13516 13517 13518 13519 13520 13521 13522 13523 13524 13525 13526 13527 13528 13529 13530 13531 13532 13533 13534 13535 13536 13537 13538 13539 13540 13541 13542 13543 13544 13545 13546 13547 13548 13549 13550 13551 13552 13553 13554 13555 13556 13557 13558 13559 13560 13561 13562 13563 13564 13565 13566 13567 13568 13569 13570 13571 13572 13573 13574 13575 13576 13577 13578 13579 13580 13581 13582 13583 13584 13585 13586 13587 13588 13589 13590 13591 13592 13593 13594 13595 13596 13597 13598 13599 13600 13601 13602 13603 13604 13605 13606 13607 13608 13609 13610 13611 13612 13613 13614 13615 13616 13617 13618 13619 13620 13621 13622 13623 13624 13625 13626 13627 13628 13629 13630 13631 13632 13633 13634 13635 13636 13637 13638 13639 13640 13641 13642 13643 13644 13645 13646 13647 13648 13649 13650 13651 13652 13653 13654 13655 13656 13657 13658 13659 13660 13661 13662 13663 13664 13665 13666 13667 13668 13669 13670 13671 13672 13673 13674 13675 13676 13677 13678 13679 13680 13681 13682 13683 13684 13685 13686 | # This file was created automatically by SWIG 1.3.27.
# Don't modify this file, modify the SWIG interface instead.
import _core_
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
if (name == "this"):
if isinstance(value, class_type):
self.__dict__[name] = value.this
if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
del value.thisown
return
method = class_type.__swig_setmethods__.get(name,None)
if method: return method(self,value)
if (not static) or hasattr(self,name) or (name == "thisown"):
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self,class_type,name,value):
return _swig_setattr_nondynamic(self,class_type,name,value,0)
def _swig_getattr(self,class_type,name):
method = class_type.__swig_getmethods__.get(name,None)
if method: return method(self)
raise AttributeError,name
import types
try:
_object = types.ObjectType
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0
del types
def _swig_setattr_nondynamic_method(set):
def set_attr(self,name,value):
if hasattr(self,name) or (name in ("this", "thisown")):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
#// Give a reference to the dictionary of this module to the C++ extension
#// code.
_core_._wxPySetDictionary(vars())
#// A little trick to make 'wx' be a reference to this module so wx.Names can
#// be used here.
import sys as _sys
wx = _sys.modules[__name__]
#----------------------------------------------------------------------------
def _deprecated(callable, msg=None):
"""
Create a wrapper function that will raise a DeprecationWarning
before calling the callable.
"""
if msg is None:
msg = "%s is deprecated" % callable
def deprecatedWrapper(*args, **kwargs):
import warnings
warnings.warn(msg, DeprecationWarning, stacklevel=2)
return callable(*args, **kwargs)
deprecatedWrapper.__doc__ = msg
return deprecatedWrapper
#----------------------------------------------------------------------------
NOT_FOUND = _core_.NOT_FOUND
VSCROLL = _core_.VSCROLL
HSCROLL = _core_.HSCROLL
CAPTION = _core_.CAPTION
DOUBLE_BORDER = _core_.DOUBLE_BORDER
SUNKEN_BORDER = _core_.SUNKEN_BORDER
RAISED_BORDER = _core_.RAISED_BORDER
BORDER = _core_.BORDER
SIMPLE_BORDER = _core_.SIMPLE_BORDER
STATIC_BORDER = _core_.STATIC_BORDER
TRANSPARENT_WINDOW = _core_.TRANSPARENT_WINDOW
NO_BORDER = _core_.NO_BORDER
DEFAULT_CONTROL_BORDER = _core_.DEFAULT_CONTROL_BORDER
DEFAULT_STATUSBAR_STYLE = _core_.DEFAULT_STATUSBAR_STYLE
TAB_TRAVERSAL = _core_.TAB_TRAVERSAL
WANTS_CHARS = _core_.WANTS_CHARS
POPUP_WINDOW = _core_.POPUP_WINDOW
CENTER_FRAME = _core_.CENTER_FRAME
CENTRE_ON_SCREEN = _core_.CENTRE_ON_SCREEN
CENTER_ON_SCREEN = _core_.CENTER_ON_SCREEN
CLIP_CHILDREN = _core_.CLIP_CHILDREN
CLIP_SIBLINGS = _core_.CLIP_SIBLINGS
ALWAYS_SHOW_SB = _core_.ALWAYS_SHOW_SB
RETAINED = _core_.RETAINED
BACKINGSTORE = _core_.BACKINGSTORE
COLOURED = _core_.COLOURED
FIXED_LENGTH = _core_.FIXED_LENGTH
LB_NEEDED_SB = _core_.LB_NEEDED_SB
LB_ALWAYS_SB = _core_.LB_ALWAYS_SB
LB_SORT = _core_.LB_SORT
LB_SINGLE = _core_.LB_SINGLE
LB_MULTIPLE = _core_.LB_MULTIPLE
LB_EXTENDED = _core_.LB_EXTENDED
LB_OWNERDRAW = _core_.LB_OWNERDRAW
LB_HSCROLL = _core_.LB_HSCROLL
PROCESS_ENTER = _core_.PROCESS_ENTER
PASSWORD = _core_.PASSWORD
CB_SIMPLE = _core_.CB_SIMPLE
CB_DROPDOWN = _core_.CB_DROPDOWN
CB_SORT = _core_.CB_SORT
CB_READONLY = _core_.CB_READONLY
RA_HORIZONTAL = _core_.RA_HORIZONTAL
RA_VERTICAL = _core_.RA_VERTICAL
RA_SPECIFY_ROWS = _core_.RA_SPECIFY_ROWS
RA_SPECIFY_COLS = _core_.RA_SPECIFY_COLS
RA_USE_CHECKBOX = _core_.RA_USE_CHECKBOX
RB_GROUP = _core_.RB_GROUP
RB_SINGLE = _core_.RB_SINGLE
SB_HORIZONTAL = _core_.SB_HORIZONTAL
SB_VERTICAL = _core_.SB_VERTICAL
RB_USE_CHECKBOX = _core_.RB_USE_CHECKBOX
ST_SIZEGRIP = _core_.ST_SIZEGRIP
ST_NO_AUTORESIZE = _core_.ST_NO_AUTORESIZE
FLOOD_SURFACE = _core_.FLOOD_SURFACE
FLOOD_BORDER = _core_.FLOOD_BORDER
ODDEVEN_RULE = _core_.ODDEVEN_RULE
WINDING_RULE = _core_.WINDING_RULE
TOOL_TOP = _core_.TOOL_TOP
TOOL_BOTTOM = _core_.TOOL_BOTTOM
TOOL_LEFT = _core_.TOOL_LEFT
TOOL_RIGHT = _core_.TOOL_RIGHT
OK = _core_.OK
YES_NO = _core_.YES_NO
CANCEL = _core_.CANCEL
YES = _core_.YES
NO = _core_.NO
NO_DEFAULT = _core_.NO_DEFAULT
YES_DEFAULT = _core_.YES_DEFAULT
ICON_EXCLAMATION = _core_.ICON_EXCLAMATION
ICON_HAND = _core_.ICON_HAND
ICON_QUESTION = _core_.ICON_QUESTION
ICON_INFORMATION = _core_.ICON_INFORMATION
ICON_STOP = _core_.ICON_STOP
ICON_ASTERISK = _core_.ICON_ASTERISK
ICON_MASK = _core_.ICON_MASK
ICON_WARNING = _core_.ICON_WARNING
ICON_ERROR = _core_.ICON_ERROR
FORWARD = _core_.FORWARD
BACKWARD = _core_.BACKWARD
RESET = _core_.RESET
HELP = _core_.HELP
MORE = _core_.MORE
SETUP = _core_.SETUP
SIZE_AUTO_WIDTH = _core_.SIZE_AUTO_WIDTH
SIZE_AUTO_HEIGHT = _core_.SIZE_AUTO_HEIGHT
SIZE_AUTO = _core_.SIZE_AUTO
SIZE_USE_EXISTING = _core_.SIZE_USE_EXISTING
SIZE_ALLOW_MINUS_ONE = _core_.SIZE_ALLOW_MINUS_ONE
SIZE_FORCE = _core_.SIZE_FORCE
PORTRAIT = _core_.PORTRAIT
LANDSCAPE = _core_.LANDSCAPE
PRINT_QUALITY_HIGH = _core_.PRINT_QUALITY_HIGH
PRINT_QUALITY_MEDIUM = _core_.PRINT_QUALITY_MEDIUM
PRINT_QUALITY_LOW = _core_.PRINT_QUALITY_LOW
PRINT_QUALITY_DRAFT = _core_.PRINT_QUALITY_DRAFT
ID_ANY = _core_.ID_ANY
ID_SEPARATOR = _core_.ID_SEPARATOR
ID_NONE = _core_.ID_NONE
ID_LOWEST = _core_.ID_LOWEST
ID_OPEN = _core_.ID_OPEN
ID_CLOSE = _core_.ID_CLOSE
ID_NEW = _core_.ID_NEW
ID_SAVE = _core_.ID_SAVE
ID_SAVEAS = _core_.ID_SAVEAS
ID_REVERT = _core_.ID_REVERT
ID_EXIT = _core_.ID_EXIT
ID_UNDO = _core_.ID_UNDO
ID_REDO = _core_.ID_REDO
ID_HELP = _core_.ID_HELP
ID_PRINT = _core_.ID_PRINT
ID_PRINT_SETUP = _core_.ID_PRINT_SETUP
ID_PREVIEW = _core_.ID_PREVIEW
ID_ABOUT = _core_.ID_ABOUT
ID_HELP_CONTENTS = _core_.ID_HELP_CONTENTS
ID_HELP_COMMANDS = _core_.ID_HELP_COMMANDS
ID_HELP_PROCEDURES = _core_.ID_HELP_PROCEDURES
ID_HELP_CONTEXT = _core_.ID_HELP_CONTEXT
ID_CLOSE_ALL = _core_.ID_CLOSE_ALL
ID_PREFERENCES = _core_.ID_PREFERENCES
ID_CUT = _core_.ID_CUT
ID_COPY = _core_.ID_COPY
ID_PASTE = _core_.ID_PASTE
ID_CLEAR = _core_.ID_CLEAR
ID_FIND = _core_.ID_FIND
ID_DUPLICATE = _core_.ID_DUPLICATE
ID_SELECTALL = _core_.ID_SELECTALL
ID_DELETE = _core_.ID_DELETE
ID_REPLACE = _core_.ID_REPLACE
ID_REPLACE_ALL = _core_.ID_REPLACE_ALL
ID_PROPERTIES = _core_.ID_PROPERTIES
ID_VIEW_DETAILS = _core_.ID_VIEW_DETAILS
ID_VIEW_LARGEICONS = _core_.ID_VIEW_LARGEICONS
ID_VIEW_SMALLICONS = _core_.ID_VIEW_SMALLICONS
ID_VIEW_LIST = _core_.ID_VIEW_LIST
ID_VIEW_SORTDATE = _core_.ID_VIEW_SORTDATE
ID_VIEW_SORTNAME = _core_.ID_VIEW_SORTNAME
ID_VIEW_SORTSIZE = _core_.ID_VIEW_SORTSIZE
ID_VIEW_SORTTYPE = _core_.ID_VIEW_SORTTYPE
ID_FILE1 = _core_.ID_FILE1
ID_FILE2 = _core_.ID_FILE2
ID_FILE3 = _core_.ID_FILE3
ID_FILE4 = _core_.ID_FILE4
ID_FILE5 = _core_.ID_FILE5
ID_FILE6 = _core_.ID_FILE6
ID_FILE7 = _core_.ID_FILE7
ID_FILE8 = _core_.ID_FILE8
ID_FILE9 = _core_.ID_FILE9
ID_OK = _core_.ID_OK
ID_CANCEL = _core_.ID_CANCEL
ID_APPLY = _core_.ID_APPLY
ID_YES = _core_.ID_YES
ID_NO = _core_.ID_NO
ID_STATIC = _core_.ID_STATIC
ID_FORWARD = _core_.ID_FORWARD
ID_BACKWARD = _core_.ID_BACKWARD
ID_DEFAULT = _core_.ID_DEFAULT
ID_MORE = _core_.ID_MORE
ID_SETUP = _core_.ID_SETUP
ID_RESET = _core_.ID_RESET
ID_CONTEXT_HELP = _core_.ID_CONTEXT_HELP
ID_YESTOALL = _core_.ID_YESTOALL
ID_NOTOALL = _core_.ID_NOTOALL
ID_ABORT = _core_.ID_ABORT
ID_RETRY = _core_.ID_RETRY
ID_IGNORE = _core_.ID_IGNORE
ID_ADD = _core_.ID_ADD
ID_REMOVE = _core_.ID_REMOVE
ID_UP = _core_.ID_UP
ID_DOWN = _core_.ID_DOWN
ID_HOME = _core_.ID_HOME
ID_REFRESH = _core_.ID_REFRESH
ID_STOP = _core_.ID_STOP
ID_INDEX = _core_.ID_INDEX
ID_BOLD = _core_.ID_BOLD
ID_ITALIC = _core_.ID_ITALIC
ID_JUSTIFY_CENTER = _core_.ID_JUSTIFY_CENTER
ID_JUSTIFY_FILL = _core_.ID_JUSTIFY_FILL
ID_JUSTIFY_RIGHT = _core_.ID_JUSTIFY_RIGHT
ID_JUSTIFY_LEFT = _core_.ID_JUSTIFY_LEFT
ID_UNDERLINE = _core_.ID_UNDERLINE
ID_INDENT = _core_.ID_INDENT
ID_UNINDENT = _core_.ID_UNINDENT
ID_ZOOM_100 = _core_.ID_ZOOM_100
ID_ZOOM_FIT = _core_.ID_ZOOM_FIT
ID_ZOOM_IN = _core_.ID_ZOOM_IN
ID_ZOOM_OUT = _core_.ID_ZOOM_OUT
ID_UNDELETE = _core_.ID_UNDELETE
ID_REVERT_TO_SAVED = _core_.ID_REVERT_TO_SAVED
ID_HIGHEST = _core_.ID_HIGHEST
OPEN = _core_.OPEN
SAVE = _core_.SAVE
HIDE_READONLY = _core_.HIDE_READONLY
OVERWRITE_PROMPT = _core_.OVERWRITE_PROMPT
FILE_MUST_EXIST = _core_.FILE_MUST_EXIST
MULTIPLE = _core_.MULTIPLE
CHANGE_DIR = _core_.CHANGE_DIR
ACCEL_ALT = _core_.ACCEL_ALT
ACCEL_CTRL = _core_.ACCEL_CTRL
ACCEL_SHIFT = _core_.ACCEL_SHIFT
ACCEL_NORMAL = _core_.ACCEL_NORMAL
PD_AUTO_HIDE = _core_.PD_AUTO_HIDE
PD_APP_MODAL = _core_.PD_APP_MODAL
PD_CAN_ABORT = _core_.PD_CAN_ABORT
PD_ELAPSED_TIME = _core_.PD_ELAPSED_TIME
PD_ESTIMATED_TIME = _core_.PD_ESTIMATED_TIME
PD_REMAINING_TIME = _core_.PD_REMAINING_TIME
PD_SMOOTH = _core_.PD_SMOOTH
PD_CAN_SKIP = _core_.PD_CAN_SKIP
DD_NEW_DIR_BUTTON = _core_.DD_NEW_DIR_BUTTON
DD_DEFAULT_STYLE = _core_.DD_DEFAULT_STYLE
MENU_TEAROFF = _core_.MENU_TEAROFF
MB_DOCKABLE = _core_.MB_DOCKABLE
NO_FULL_REPAINT_ON_RESIZE = _core_.NO_FULL_REPAINT_ON_RESIZE
FULL_REPAINT_ON_RESIZE = _core_.FULL_REPAINT_ON_RESIZE
LI_HORIZONTAL = _core_.LI_HORIZONTAL
LI_VERTICAL = _core_.LI_VERTICAL
WS_EX_VALIDATE_RECURSIVELY = _core_.WS_EX_VALIDATE_RECURSIVELY
WS_EX_BLOCK_EVENTS = _core_.WS_EX_BLOCK_EVENTS
WS_EX_TRANSIENT = _core_.WS_EX_TRANSIENT
WS_EX_THEMED_BACKGROUND = _core_.WS_EX_THEMED_BACKGROUND
WS_EX_PROCESS_IDLE = _core_.WS_EX_PROCESS_IDLE
WS_EX_PROCESS_UI_UPDATES = _core_.WS_EX_PROCESS_UI_UPDATES
MM_TEXT = _core_.MM_TEXT
MM_LOMETRIC = _core_.MM_LOMETRIC
MM_HIMETRIC = _core_.MM_HIMETRIC
MM_LOENGLISH = _core_.MM_LOENGLISH
MM_HIENGLISH = _core_.MM_HIENGLISH
MM_TWIPS = _core_.MM_TWIPS
MM_ISOTROPIC = _core_.MM_ISOTROPIC
MM_ANISOTROPIC = _core_.MM_ANISOTROPIC
MM_POINTS = _core_.MM_POINTS
MM_METRIC = _core_.MM_METRIC
CENTRE = _core_.CENTRE
CENTER = _core_.CENTER
HORIZONTAL = _core_.HORIZONTAL
VERTICAL = _core_.VERTICAL
BOTH = _core_.BOTH
LEFT = _core_.LEFT
RIGHT = _core_.RIGHT
UP = _core_.UP
DOWN = _core_.DOWN
TOP = _core_.TOP
BOTTOM = _core_.BOTTOM
NORTH = _core_.NORTH
SOUTH = _core_.SOUTH
WEST = _core_.WEST
EAST = _core_.EAST
ALL = _core_.ALL
ALIGN_NOT = _core_.ALIGN_NOT
ALIGN_CENTER_HORIZONTAL = _core_.ALIGN_CENTER_HORIZONTAL
ALIGN_CENTRE_HORIZONTAL = _core_.ALIGN_CENTRE_HORIZONTAL
ALIGN_LEFT = _core_.ALIGN_LEFT
ALIGN_TOP = _core_.ALIGN_TOP
ALIGN_RIGHT = _core_.ALIGN_RIGHT
ALIGN_BOTTOM = _core_.ALIGN_BOTTOM
ALIGN_CENTER_VERTICAL = _core_.ALIGN_CENTER_VERTICAL
ALIGN_CENTRE_VERTICAL = _core_.ALIGN_CENTRE_VERTICAL
ALIGN_CENTER = _core_.ALIGN_CENTER
ALIGN_CENTRE = _core_.ALIGN_CENTRE
ALIGN_MASK = _core_.ALIGN_MASK
STRETCH_NOT = _core_.STRETCH_NOT
SHRINK = _core_.SHRINK
GROW = _core_.GROW
EXPAND = _core_.EXPAND
SHAPED = _core_.SHAPED
FIXED_MINSIZE = _core_.FIXED_MINSIZE
TILE = _core_.TILE
ADJUST_MINSIZE = _core_.ADJUST_MINSIZE
BORDER_DEFAULT = _core_.BORDER_DEFAULT
BORDER_NONE = _core_.BORDER_NONE
BORDER_STATIC = _core_.BORDER_STATIC
BORDER_SIMPLE = _core_.BORDER_SIMPLE
BORDER_RAISED = _core_.BORDER_RAISED
BORDER_SUNKEN = _core_.BORDER_SUNKEN
BORDER_DOUBLE = _core_.BORDER_DOUBLE
BORDER_MASK = _core_.BORDER_MASK
BG_STYLE_SYSTEM = _core_.BG_STYLE_SYSTEM
BG_STYLE_COLOUR = _core_.BG_STYLE_COLOUR
BG_STYLE_CUSTOM = _core_.BG_STYLE_CUSTOM
DEFAULT = _core_.DEFAULT
DECORATIVE = _core_.DECORATIVE
ROMAN = _core_.ROMAN
SCRIPT = _core_.SCRIPT
SWISS = _core_.SWISS
MODERN = _core_.MODERN
TELETYPE = _core_.TELETYPE
VARIABLE = _core_.VARIABLE
FIXED = _core_.FIXED
NORMAL = _core_.NORMAL
LIGHT = _core_.LIGHT
BOLD = _core_.BOLD
ITALIC = _core_.ITALIC
SLANT = _core_.SLANT
SOLID = _core_.SOLID
DOT = _core_.DOT
LONG_DASH = _core_.LONG_DASH
SHORT_DASH = _core_.SHORT_DASH
DOT_DASH = _core_.DOT_DASH
USER_DASH = _core_.USER_DASH
TRANSPARENT = _core_.TRANSPARENT
STIPPLE = _core_.STIPPLE
STIPPLE_MASK = _core_.STIPPLE_MASK
STIPPLE_MASK_OPAQUE = _core_.STIPPLE_MASK_OPAQUE
BDIAGONAL_HATCH = _core_.BDIAGONAL_HATCH
CROSSDIAG_HATCH = _core_.CROSSDIAG_HATCH
FDIAGONAL_HATCH = _core_.FDIAGONAL_HATCH
CROSS_HATCH = _core_.CROSS_HATCH
HORIZONTAL_HATCH = _core_.HORIZONTAL_HATCH
VERTICAL_HATCH = _core_.VERTICAL_HATCH
JOIN_BEVEL = _core_.JOIN_BEVEL
JOIN_MITER = _core_.JOIN_MITER
JOIN_ROUND = _core_.JOIN_ROUND
CAP_ROUND = _core_.CAP_ROUND
CAP_PROJECTING = _core_.CAP_PROJECTING
CAP_BUTT = _core_.CAP_BUTT
CLEAR = _core_.CLEAR
XOR = _core_.XOR
INVERT = _core_.INVERT
OR_REVERSE = _core_.OR_REVERSE
AND_REVERSE = _core_.AND_REVERSE
COPY = _core_.COPY
AND = _core_.AND
AND_INVERT = _core_.AND_INVERT
NO_OP = _core_.NO_OP
NOR = _core_.NOR
EQUIV = _core_.EQUIV
SRC_INVERT = _core_.SRC_INVERT
OR_INVERT = _core_.OR_INVERT
NAND = _core_.NAND
OR = _core_.OR
SET = _core_.SET
WXK_BACK = _core_.WXK_BACK
WXK_TAB = _core_.WXK_TAB
WXK_RETURN = _core_.WXK_RETURN
WXK_ESCAPE = _core_.WXK_ESCAPE
WXK_SPACE = _core_.WXK_SPACE
WXK_DELETE = _core_.WXK_DELETE
WXK_START = _core_.WXK_START
WXK_LBUTTON = _core_.WXK_LBUTTON
WXK_RBUTTON = _core_.WXK_RBUTTON
WXK_CANCEL = _core_.WXK_CANCEL
WXK_MBUTTON = _core_.WXK_MBUTTON
WXK_CLEAR = _core_.WXK_CLEAR
WXK_SHIFT = _core_.WXK_SHIFT
WXK_ALT = _core_.WXK_ALT
WXK_CONTROL = _core_.WXK_CONTROL
WXK_MENU = _core_.WXK_MENU
WXK_PAUSE = _core_.WXK_PAUSE
WXK_CAPITAL = _core_.WXK_CAPITAL
WXK_PRIOR = _core_.WXK_PRIOR
WXK_NEXT = _core_.WXK_NEXT
WXK_END = _core_.WXK_END
WXK_HOME = _core_.WXK_HOME
WXK_LEFT = _core_.WXK_LEFT
WXK_UP = _core_.WXK_UP
WXK_RIGHT = _core_.WXK_RIGHT
WXK_DOWN = _core_.WXK_DOWN
WXK_SELECT = _core_.WXK_SELECT
WXK_PRINT = _core_.WXK_PRINT
WXK_EXECUTE = _core_.WXK_EXECUTE
WXK_SNAPSHOT = _core_.WXK_SNAPSHOT
WXK_INSERT = _core_.WXK_INSERT
WXK_HELP = _core_.WXK_HELP
WXK_NUMPAD0 = _core_.WXK_NUMPAD0
WXK_NUMPAD1 = _core_.WXK_NUMPAD1
WXK_NUMPAD2 = _core_.WXK_NUMPAD2
WXK_NUMPAD3 = _core_.WXK_NUMPAD3
WXK_NUMPAD4 = _core_.WXK_NUMPAD4
WXK_NUMPAD5 = _core_.WXK_NUMPAD5
WXK_NUMPAD6 = _core_.WXK_NUMPAD6
WXK_NUMPAD7 = _core_.WXK_NUMPAD7
WXK_NUMPAD8 = _core_.WXK_NUMPAD8
WXK_NUMPAD9 = _core_.WXK_NUMPAD9
WXK_MULTIPLY = _core_.WXK_MULTIPLY
WXK_ADD = _core_.WXK_ADD
WXK_SEPARATOR = _core_.WXK_SEPARATOR
WXK_SUBTRACT = _core_.WXK_SUBTRACT
WXK_DECIMAL = _core_.WXK_DECIMAL
WXK_DIVIDE = _core_.WXK_DIVIDE
WXK_F1 = _core_.WXK_F1
WXK_F2 = _core_.WXK_F2
WXK_F3 = _core_.WXK_F3
WXK_F4 = _core_.WXK_F4
WXK_F5 = _core_.WXK_F5
WXK_F6 = _core_.WXK_F6
WXK_F7 = _core_.WXK_F7
WXK_F8 = _core_.WXK_F8
WXK_F9 = _core_.WXK_F9
WXK_F10 = _core_.WXK_F10
WXK_F11 = _core_.WXK_F11
WXK_F12 = _core_.WXK_F12
WXK_F13 = _core_.WXK_F13
WXK_F14 = _core_.WXK_F14
WXK_F15 = _core_.WXK_F15
WXK_F16 = _core_.WXK_F16
WXK_F17 = _core_.WXK_F17
WXK_F18 = _core_.WXK_F18
WXK_F19 = _core_.WXK_F19
WXK_F20 = _core_.WXK_F20
WXK_F21 = _core_.WXK_F21
WXK_F22 = _core_.WXK_F22
WXK_F23 = _core_.WXK_F23
WXK_F24 = _core_.WXK_F24
WXK_NUMLOCK = _core_.WXK_NUMLOCK
WXK_SCROLL = _core_.WXK_SCROLL
WXK_PAGEUP = _core_.WXK_PAGEUP
WXK_PAGEDOWN = _core_.WXK_PAGEDOWN
WXK_NUMPAD_SPACE = _core_.WXK_NUMPAD_SPACE
WXK_NUMPAD_TAB = _core_.WXK_NUMPAD_TAB
WXK_NUMPAD_ENTER = _core_.WXK_NUMPAD_ENTER
WXK_NUMPAD_F1 = _core_.WXK_NUMPAD_F1
WXK_NUMPAD_F2 = _core_.WXK_NUMPAD_F2
WXK_NUMPAD_F3 = _core_.WXK_NUMPAD_F3
WXK_NUMPAD_F4 = _core_.WXK_NUMPAD_F4
WXK_NUMPAD_HOME = _core_.WXK_NUMPAD_HOME
WXK_NUMPAD_LEFT = _core_.WXK_NUMPAD_LEFT
WXK_NUMPAD_UP = _core_.WXK_NUMPAD_UP
WXK_NUMPAD_RIGHT = _core_.WXK_NUMPAD_RIGHT
WXK_NUMPAD_DOWN = _core_.WXK_NUMPAD_DOWN
WXK_NUMPAD_PRIOR = _core_.WXK_NUMPAD_PRIOR
WXK_NUMPAD_PAGEUP = _core_.WXK_NUMPAD_PAGEUP
WXK_NUMPAD_NEXT = _core_.WXK_NUMPAD_NEXT
WXK_NUMPAD_PAGEDOWN = _core_.WXK_NUMPAD_PAGEDOWN
WXK_NUMPAD_END = _core_.WXK_NUMPAD_END
WXK_NUMPAD_BEGIN = _core_.WXK_NUMPAD_BEGIN
WXK_NUMPAD_INSERT = _core_.WXK_NUMPAD_INSERT
WXK_NUMPAD_DELETE = _core_.WXK_NUMPAD_DELETE
WXK_NUMPAD_EQUAL = _core_.WXK_NUMPAD_EQUAL
WXK_NUMPAD_MULTIPLY = _core_.WXK_NUMPAD_MULTIPLY
WXK_NUMPAD_ADD = _core_.WXK_NUMPAD_ADD
WXK_NUMPAD_SEPARATOR = _core_.WXK_NUMPAD_SEPARATOR
WXK_NUMPAD_SUBTRACT = _core_.WXK_NUMPAD_SUBTRACT
WXK_NUMPAD_DECIMAL = _core_.WXK_NUMPAD_DECIMAL
WXK_NUMPAD_DIVIDE = _core_.WXK_NUMPAD_DIVIDE
WXK_WINDOWS_LEFT = _core_.WXK_WINDOWS_LEFT
WXK_WINDOWS_RIGHT = _core_.WXK_WINDOWS_RIGHT
WXK_WINDOWS_MENU = _core_.WXK_WINDOWS_MENU
WXK_COMMAND = _core_.WXK_COMMAND
WXK_SPECIAL1 = _core_.WXK_SPECIAL1
WXK_SPECIAL2 = _core_.WXK_SPECIAL2
WXK_SPECIAL3 = _core_.WXK_SPECIAL3
WXK_SPECIAL4 = _core_.WXK_SPECIAL4
WXK_SPECIAL5 = _core_.WXK_SPECIAL5
WXK_SPECIAL6 = _core_.WXK_SPECIAL6
WXK_SPECIAL7 = _core_.WXK_SPECIAL7
WXK_SPECIAL8 = _core_.WXK_SPECIAL8
WXK_SPECIAL9 = _core_.WXK_SPECIAL9
WXK_SPECIAL10 = _core_.WXK_SPECIAL10
WXK_SPECIAL11 = _core_.WXK_SPECIAL11
WXK_SPECIAL12 = _core_.WXK_SPECIAL12
WXK_SPECIAL13 = _core_.WXK_SPECIAL13
WXK_SPECIAL14 = _core_.WXK_SPECIAL14
WXK_SPECIAL15 = _core_.WXK_SPECIAL15
WXK_SPECIAL16 = _core_.WXK_SPECIAL16
WXK_SPECIAL17 = _core_.WXK_SPECIAL17
WXK_SPECIAL18 = _core_.WXK_SPECIAL18
WXK_SPECIAL19 = _core_.WXK_SPECIAL19
WXK_SPECIAL20 = _core_.WXK_SPECIAL20
PAPER_NONE = _core_.PAPER_NONE
PAPER_LETTER = _core_.PAPER_LETTER
PAPER_LEGAL = _core_.PAPER_LEGAL
PAPER_A4 = _core_.PAPER_A4
PAPER_CSHEET = _core_.PAPER_CSHEET
PAPER_DSHEET = _core_.PAPER_DSHEET
PAPER_ESHEET = _core_.PAPER_ESHEET
PAPER_LETTERSMALL = _core_.PAPER_LETTERSMALL
PAPER_TABLOID = _core_.PAPER_TABLOID
PAPER_LEDGER = _core_.PAPER_LEDGER
PAPER_STATEMENT = _core_.PAPER_STATEMENT
PAPER_EXECUTIVE = _core_.PAPER_EXECUTIVE
PAPER_A3 = _core_.PAPER_A3
PAPER_A4SMALL = _core_.PAPER_A4SMALL
PAPER_A5 = _core_.PAPER_A5
PAPER_B4 = _core_.PAPER_B4
PAPER_B5 = _core_.PAPER_B5
PAPER_FOLIO = _core_.PAPER_FOLIO
PAPER_QUARTO = _core_.PAPER_QUARTO
PAPER_10X14 = _core_.PAPER_10X14
PAPER_11X17 = _core_.PAPER_11X17
PAPER_NOTE = _core_.PAPER_NOTE
PAPER_ENV_9 = _core_.PAPER_ENV_9
PAPER_ENV_10 = _core_.PAPER_ENV_10
PAPER_ENV_11 = _core_.PAPER_ENV_11
PAPER_ENV_12 = _core_.PAPER_ENV_12
PAPER_ENV_14 = _core_.PAPER_ENV_14
PAPER_ENV_DL = _core_.PAPER_ENV_DL
PAPER_ENV_C5 = _core_.PAPER_ENV_C5
PAPER_ENV_C3 = _core_.PAPER_ENV_C3
PAPER_ENV_C4 = _core_.PAPER_ENV_C4
PAPER_ENV_C6 = _core_.PAPER_ENV_C6
PAPER_ENV_C65 = _core_.PAPER_ENV_C65
PAPER_ENV_B4 = _core_.PAPER_ENV_B4
PAPER_ENV_B5 = _core_.PAPER_ENV_B5
PAPER_ENV_B6 = _core_.PAPER_ENV_B6
PAPER_ENV_ITALY = _core_.PAPER_ENV_ITALY
PAPER_ENV_MONARCH = _core_.PAPER_ENV_MONARCH
PAPER_ENV_PERSONAL = _core_.PAPER_ENV_PERSONAL
PAPER_FANFOLD_US = _core_.PAPER_FANFOLD_US
PAPER_FANFOLD_STD_GERMAN = _core_.PAPER_FANFOLD_STD_GERMAN
PAPER_FANFOLD_LGL_GERMAN = _core_.PAPER_FANFOLD_LGL_GERMAN
PAPER_ISO_B4 = _core_.PAPER_ISO_B4
PAPER_JAPANESE_POSTCARD = _core_.PAPER_JAPANESE_POSTCARD
PAPER_9X11 = _core_.PAPER_9X11
PAPER_10X11 = _core_.PAPER_10X11
PAPER_15X11 = _core_.PAPER_15X11
PAPER_ENV_INVITE = _core_.PAPER_ENV_INVITE
PAPER_LETTER_EXTRA = _core_.PAPER_LETTER_EXTRA
PAPER_LEGAL_EXTRA = _core_.PAPER_LEGAL_EXTRA
PAPER_TABLOID_EXTRA = _core_.PAPER_TABLOID_EXTRA
PAPER_A4_EXTRA = _core_.PAPER_A4_EXTRA
PAPER_LETTER_TRANSVERSE = _core_.PAPER_LETTER_TRANSVERSE
PAPER_A4_TRANSVERSE = _core_.PAPER_A4_TRANSVERSE
PAPER_LETTER_EXTRA_TRANSVERSE = _core_.PAPER_LETTER_EXTRA_TRANSVERSE
PAPER_A_PLUS = _core_.PAPER_A_PLUS
PAPER_B_PLUS = _core_.PAPER_B_PLUS
PAPER_LETTER_PLUS = _core_.PAPER_LETTER_PLUS
PAPER_A4_PLUS = _core_.PAPER_A4_PLUS
PAPER_A5_TRANSVERSE = _core_.PAPER_A5_TRANSVERSE
PAPER_B5_TRANSVERSE = _core_.PAPER_B5_TRANSVERSE
PAPER_A3_EXTRA = _core_.PAPER_A3_EXTRA
PAPER_A5_EXTRA = _core_.PAPER_A5_EXTRA
PAPER_B5_EXTRA = _core_.PAPER_B5_EXTRA
PAPER_A2 = _core_.PAPER_A2
PAPER_A3_TRANSVERSE = _core_.PAPER_A3_TRANSVERSE
PAPER_A3_EXTRA_TRANSVERSE = _core_.PAPER_A3_EXTRA_TRANSVERSE
PAPER_DBL_JAPANESE_POSTCARD = _core_.PAPER_DBL_JAPANESE_POSTCARD
PAPER_A6 = _core_.PAPER_A6
PAPER_JENV_KAKU2 = _core_.PAPER_JENV_KAKU2
PAPER_JENV_KAKU3 = _core_.PAPER_JENV_KAKU3
PAPER_JENV_CHOU3 = _core_.PAPER_JENV_CHOU3
PAPER_JENV_CHOU4 = _core_.PAPER_JENV_CHOU4
PAPER_LETTER_ROTATED = _core_.PAPER_LETTER_ROTATED
PAPER_A3_ROTATED = _core_.PAPER_A3_ROTATED
PAPER_A4_ROTATED = _core_.PAPER_A4_ROTATED
PAPER_A5_ROTATED = _core_.PAPER_A5_ROTATED
PAPER_B4_JIS_ROTATED = _core_.PAPER_B4_JIS_ROTATED
PAPER_B5_JIS_ROTATED = _core_.PAPER_B5_JIS_ROTATED
PAPER_JAPANESE_POSTCARD_ROTATED = _core_.PAPER_JAPANESE_POSTCARD_ROTATED
PAPER_DBL_JAPANESE_POSTCARD_ROTATED = _core_.PAPER_DBL_JAPANESE_POSTCARD_ROTATED
PAPER_A6_ROTATED = _core_.PAPER_A6_ROTATED
PAPER_JENV_KAKU2_ROTATED = _core_.PAPER_JENV_KAKU2_ROTATED
PAPER_JENV_KAKU3_ROTATED = _core_.PAPER_JENV_KAKU3_ROTATED
PAPER_JENV_CHOU3_ROTATED = _core_.PAPER_JENV_CHOU3_ROTATED
PAPER_JENV_CHOU4_ROTATED = _core_.PAPER_JENV_CHOU4_ROTATED
PAPER_B6_JIS = _core_.PAPER_B6_JIS
PAPER_B6_JIS_ROTATED = _core_.PAPER_B6_JIS_ROTATED
PAPER_12X11 = _core_.PAPER_12X11
PAPER_JENV_YOU4 = _core_.PAPER_JENV_YOU4
PAPER_JENV_YOU4_ROTATED = _core_.PAPER_JENV_YOU4_ROTATED
PAPER_P16K = _core_.PAPER_P16K
PAPER_P32K = _core_.PAPER_P32K
PAPER_P32KBIG = _core_.PAPER_P32KBIG
PAPER_PENV_1 = _core_.PAPER_PENV_1
PAPER_PENV_2 = _core_.PAPER_PENV_2
PAPER_PENV_3 = _core_.PAPER_PENV_3
PAPER_PENV_4 = _core_.PAPER_PENV_4
PAPER_PENV_5 = _core_.PAPER_PENV_5
PAPER_PENV_6 = _core_.PAPER_PENV_6
PAPER_PENV_7 = _core_.PAPER_PENV_7
PAPER_PENV_8 = _core_.PAPER_PENV_8
PAPER_PENV_9 = _core_.PAPER_PENV_9
PAPER_PENV_10 = _core_.PAPER_PENV_10
PAPER_P16K_ROTATED = _core_.PAPER_P16K_ROTATED
PAPER_P32K_ROTATED = _core_.PAPER_P32K_ROTATED
PAPER_P32KBIG_ROTATED = _core_.PAPER_P32KBIG_ROTATED
PAPER_PENV_1_ROTATED = _core_.PAPER_PENV_1_ROTATED
PAPER_PENV_2_ROTATED = _core_.PAPER_PENV_2_ROTATED
PAPER_PENV_3_ROTATED = _core_.PAPER_PENV_3_ROTATED
PAPER_PENV_4_ROTATED = _core_.PAPER_PENV_4_ROTATED
PAPER_PENV_5_ROTATED = _core_.PAPER_PENV_5_ROTATED
PAPER_PENV_6_ROTATED = _core_.PAPER_PENV_6_ROTATED
PAPER_PENV_7_ROTATED = _core_.PAPER_PENV_7_ROTATED
PAPER_PENV_8_ROTATED = _core_.PAPER_PENV_8_ROTATED
PAPER_PENV_9_ROTATED = _core_.PAPER_PENV_9_ROTATED
PAPER_PENV_10_ROTATED = _core_.PAPER_PENV_10_ROTATED
DUPLEX_SIMPLEX = _core_.DUPLEX_SIMPLEX
DUPLEX_HORIZONTAL = _core_.DUPLEX_HORIZONTAL
DUPLEX_VERTICAL = _core_.DUPLEX_VERTICAL
ITEM_SEPARATOR = _core_.ITEM_SEPARATOR
ITEM_NORMAL = _core_.ITEM_NORMAL
ITEM_CHECK = _core_.ITEM_CHECK
ITEM_RADIO = _core_.ITEM_RADIO
ITEM_MAX = _core_.ITEM_MAX
HT_NOWHERE = _core_.HT_NOWHERE
HT_SCROLLBAR_FIRST = _core_.HT_SCROLLBAR_FIRST
HT_SCROLLBAR_ARROW_LINE_1 = _core_.HT_SCROLLBAR_ARROW_LINE_1
HT_SCROLLBAR_ARROW_LINE_2 = _core_.HT_SCROLLBAR_ARROW_LINE_2
HT_SCROLLBAR_ARROW_PAGE_1 = _core_.HT_SCROLLBAR_ARROW_PAGE_1
HT_SCROLLBAR_ARROW_PAGE_2 = _core_.HT_SCROLLBAR_ARROW_PAGE_2
HT_SCROLLBAR_THUMB = _core_.HT_SCROLLBAR_THUMB
HT_SCROLLBAR_BAR_1 = _core_.HT_SCROLLBAR_BAR_1
HT_SCROLLBAR_BAR_2 = _core_.HT_SCROLLBAR_BAR_2
HT_SCROLLBAR_LAST = _core_.HT_SCROLLBAR_LAST
HT_WINDOW_OUTSIDE = _core_.HT_WINDOW_OUTSIDE
HT_WINDOW_INSIDE = _core_.HT_WINDOW_INSIDE
HT_WINDOW_VERT_SCROLLBAR = _core_.HT_WINDOW_VERT_SCROLLBAR
HT_WINDOW_HORZ_SCROLLBAR = _core_.HT_WINDOW_HORZ_SCROLLBAR
HT_WINDOW_CORNER = _core_.HT_WINDOW_CORNER
HT_MAX = _core_.HT_MAX
MOD_NONE = _core_.MOD_NONE
MOD_ALT = _core_.MOD_ALT
MOD_CONTROL = _core_.MOD_CONTROL
MOD_SHIFT = _core_.MOD_SHIFT
MOD_WIN = _core_.MOD_WIN
UPDATE_UI_NONE = _core_.UPDATE_UI_NONE
UPDATE_UI_RECURSE = _core_.UPDATE_UI_RECURSE
UPDATE_UI_FROMIDLE = _core_.UPDATE_UI_FROMIDLE
#---------------------------------------------------------------------------
class Object(object):
"""
The base class for most wx objects, although in wxPython not
much functionality is needed nor exposed.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetClassName(*args, **kwargs):
"""
GetClassName(self) -> String
Returns the class name of the C++ class using wxRTTI.
"""
return _core_.Object_GetClassName(*args, **kwargs)
def Destroy(*args, **kwargs):
"""
Destroy(self)
Deletes the C++ object this Python object is a proxy for.
"""
return _core_.Object_Destroy(*args, **kwargs)
class ObjectPtr(Object):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Object
_core_.Object_swigregister(ObjectPtr)
_wxPySetDictionary = _core_._wxPySetDictionary
_wxPyFixStockObjects = _core_._wxPyFixStockObjects
cvar = _core_.cvar
EmptyString = cvar.EmptyString
#---------------------------------------------------------------------------
BITMAP_TYPE_INVALID = _core_.BITMAP_TYPE_INVALID
BITMAP_TYPE_BMP = _core_.BITMAP_TYPE_BMP
BITMAP_TYPE_ICO = _core_.BITMAP_TYPE_ICO
BITMAP_TYPE_CUR = _core_.BITMAP_TYPE_CUR
BITMAP_TYPE_XBM = _core_.BITMAP_TYPE_XBM
BITMAP_TYPE_XBM_DATA = _core_.BITMAP_TYPE_XBM_DATA
BITMAP_TYPE_XPM = _core_.BITMAP_TYPE_XPM
BITMAP_TYPE_XPM_DATA = _core_.BITMAP_TYPE_XPM_DATA
BITMAP_TYPE_TIF = _core_.BITMAP_TYPE_TIF
BITMAP_TYPE_GIF = _core_.BITMAP_TYPE_GIF
BITMAP_TYPE_PNG = _core_.BITMAP_TYPE_PNG
BITMAP_TYPE_JPEG = _core_.BITMAP_TYPE_JPEG
BITMAP_TYPE_PNM = _core_.BITMAP_TYPE_PNM
BITMAP_TYPE_PCX = _core_.BITMAP_TYPE_PCX
BITMAP_TYPE_PICT = _core_.BITMAP_TYPE_PICT
BITMAP_TYPE_ICON = _core_.BITMAP_TYPE_ICON
BITMAP_TYPE_ANI = _core_.BITMAP_TYPE_ANI
BITMAP_TYPE_IFF = _core_.BITMAP_TYPE_IFF
BITMAP_TYPE_MACCURSOR = _core_.BITMAP_TYPE_MACCURSOR
BITMAP_TYPE_ANY = _core_.BITMAP_TYPE_ANY
CURSOR_NONE = _core_.CURSOR_NONE
CURSOR_ARROW = _core_.CURSOR_ARROW
CURSOR_RIGHT_ARROW = _core_.CURSOR_RIGHT_ARROW
CURSOR_BULLSEYE = _core_.CURSOR_BULLSEYE
CURSOR_CHAR = _core_.CURSOR_CHAR
CURSOR_CROSS = _core_.CURSOR_CROSS
CURSOR_HAND = _core_.CURSOR_HAND
CURSOR_IBEAM = _core_.CURSOR_IBEAM
CURSOR_LEFT_BUTTON = _core_.CURSOR_LEFT_BUTTON
CURSOR_MAGNIFIER = _core_.CURSOR_MAGNIFIER
CURSOR_MIDDLE_BUTTON = _core_.CURSOR_MIDDLE_BUTTON
CURSOR_NO_ENTRY = _core_.CURSOR_NO_ENTRY
CURSOR_PAINT_BRUSH = _core_.CURSOR_PAINT_BRUSH
CURSOR_PENCIL = _core_.CURSOR_PENCIL
CURSOR_POINT_LEFT = _core_.CURSOR_POINT_LEFT
CURSOR_POINT_RIGHT = _core_.CURSOR_POINT_RIGHT
CURSOR_QUESTION_ARROW = _core_.CURSOR_QUESTION_ARROW
CURSOR_RIGHT_BUTTON = _core_.CURSOR_RIGHT_BUTTON
CURSOR_SIZENESW = _core_.CURSOR_SIZENESW
CURSOR_SIZENS = _core_.CURSOR_SIZENS
CURSOR_SIZENWSE = _core_.CURSOR_SIZENWSE
CURSOR_SIZEWE = _core_.CURSOR_SIZEWE
CURSOR_SIZING = _core_.CURSOR_SIZING
CURSOR_SPRAYCAN = _core_.CURSOR_SPRAYCAN
CURSOR_WAIT = _core_.CURSOR_WAIT
CURSOR_WATCH = _core_.CURSOR_WATCH
CURSOR_BLANK = _core_.CURSOR_BLANK
CURSOR_DEFAULT = _core_.CURSOR_DEFAULT
CURSOR_COPY_ARROW = _core_.CURSOR_COPY_ARROW
CURSOR_ARROWWAIT = _core_.CURSOR_ARROWWAIT
CURSOR_MAX = _core_.CURSOR_MAX
#---------------------------------------------------------------------------
class Size(object):
"""
wx.Size is a useful data structure used to represent the size of
something. It simply contains integer width and height
properties. In most places in wxPython where a wx.Size is
expected a (width, height) tuple can be used instead.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
width = property(_core_.Size_width_get, _core_.Size_width_set)
height = property(_core_.Size_height_get, _core_.Size_height_set)
x = width; y = height
def __init__(self, *args, **kwargs):
"""
__init__(self, int w=0, int h=0) -> Size
Creates a size object.
"""
newobj = _core_.new_Size(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_Size):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Test for equality of wx.Size objects.
"""
return _core_.Size___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Test for inequality of wx.Size objects.
"""
return _core_.Size___ne__(*args, **kwargs)
def __add__(*args, **kwargs):
"""
__add__(self, Size sz) -> Size
Add sz's proprties to this and return the result.
"""
return _core_.Size___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
"""
__sub__(self, Size sz) -> Size
Subtract sz's properties from this and return the result.
"""
return _core_.Size___sub__(*args, **kwargs)
def IncTo(*args, **kwargs):
"""
IncTo(self, Size sz)
Increments this object so that both of its dimensions are not less
than the corresponding dimensions of the size.
"""
return _core_.Size_IncTo(*args, **kwargs)
def DecTo(*args, **kwargs):
"""
DecTo(self, Size sz)
Decrements this object so that both of its dimensions are not greater
than the corresponding dimensions of the size.
"""
return _core_.Size_DecTo(*args, **kwargs)
def Set(*args, **kwargs):
"""
Set(self, int w, int h)
Set both width and height.
"""
return _core_.Size_Set(*args, **kwargs)
def SetWidth(*args, **kwargs):
"""SetWidth(self, int w)"""
return _core_.Size_SetWidth(*args, **kwargs)
def SetHeight(*args, **kwargs):
"""SetHeight(self, int h)"""
return _core_.Size_SetHeight(*args, **kwargs)
def GetWidth(*args, **kwargs):
"""GetWidth(self) -> int"""
return _core_.Size_GetWidth(*args, **kwargs)
def GetHeight(*args, **kwargs):
"""GetHeight(self) -> int"""
return _core_.Size_GetHeight(*args, **kwargs)
def IsFullySpecified(*args, **kwargs):
"""
IsFullySpecified(self) -> bool
Returns True if both components of the size are non-default values.
"""
return _core_.Size_IsFullySpecified(*args, **kwargs)
def SetDefaults(*args, **kwargs):
"""
SetDefaults(self, Size size)
Combine this size with the other one replacing the default components
of this object (i.e. equal to -1) with those of the other.
"""
return _core_.Size_SetDefaults(*args, **kwargs)
def Get(*args, **kwargs):
"""
Get() -> (width,height)
Returns the width and height properties as a tuple.
"""
return _core_.Size_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Size'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.width = val
elif index == 1: self.height = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Size, self.Get())
class SizePtr(Size):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Size
_core_.Size_swigregister(SizePtr)
#---------------------------------------------------------------------------
class RealPoint(object):
"""
A data structure for representing a point or position with floating
point x and y properties. In wxPython most places that expect a
wx.RealPoint can also accept a (x,y) tuple.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxRealPoint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
x = property(_core_.RealPoint_x_get, _core_.RealPoint_x_set)
y = property(_core_.RealPoint_y_get, _core_.RealPoint_y_set)
def __init__(self, *args, **kwargs):
"""
__init__(self, double x=0.0, double y=0.0) -> RealPoint
Create a wx.RealPoint object
"""
newobj = _core_.new_RealPoint(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_RealPoint):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Test for equality of wx.RealPoint objects.
"""
return _core_.RealPoint___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Test for inequality of wx.RealPoint objects.
"""
return _core_.RealPoint___ne__(*args, **kwargs)
def __add__(*args, **kwargs):
"""
__add__(self, RealPoint pt) -> RealPoint
Add pt's proprties to this and return the result.
"""
return _core_.RealPoint___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
"""
__sub__(self, RealPoint pt) -> RealPoint
Subtract pt's proprties from this and return the result
"""
return _core_.RealPoint___sub__(*args, **kwargs)
def Set(*args, **kwargs):
"""
Set(self, double x, double y)
Set both the x and y properties
"""
return _core_.RealPoint_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""
Get() -> (x,y)
Return the x and y properties as a tuple.
"""
return _core_.RealPoint_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.RealPoint'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.x = val
elif index == 1: self.y = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0.0, 0.0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.RealPoint, self.Get())
class RealPointPtr(RealPoint):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = RealPoint
_core_.RealPoint_swigregister(RealPointPtr)
#---------------------------------------------------------------------------
class Point(object):
"""
A data structure for representing a point or position with integer x
and y properties. Most places in wxPython that expect a wx.Point can
also accept a (x,y) tuple.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPoint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
x = property(_core_.Point_x_get, _core_.Point_x_set)
y = property(_core_.Point_y_get, _core_.Point_y_set)
def __init__(self, *args, **kwargs):
"""
__init__(self, int x=0, int y=0) -> Point
Create a wx.Point object
"""
newobj = _core_.new_Point(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_Point):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Test for equality of wx.Point objects.
"""
return _core_.Point___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Test for inequality of wx.Point objects.
"""
return _core_.Point___ne__(*args, **kwargs)
def __add__(*args, **kwargs):
"""
__add__(self, Point pt) -> Point
Add pt's proprties to this and return the result.
"""
return _core_.Point___add__(*args, **kwargs)
def __sub__(*args, **kwargs):
"""
__sub__(self, Point pt) -> Point
Subtract pt's proprties from this and return the result
"""
return _core_.Point___sub__(*args, **kwargs)
def __iadd__(*args, **kwargs):
"""
__iadd__(self, Point pt) -> Point
Add pt to this object.
"""
return _core_.Point___iadd__(*args, **kwargs)
def __isub__(*args, **kwargs):
"""
__isub__(self, Point pt) -> Point
Subtract pt from this object.
"""
return _core_.Point___isub__(*args, **kwargs)
def Set(*args, **kwargs):
"""
Set(self, long x, long y)
Set both the x and y properties
"""
return _core_.Point_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""
Get() -> (x,y)
Return the x and y properties as a tuple.
"""
return _core_.Point_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Point'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.x = val
elif index == 1: self.y = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Point, self.Get())
class PointPtr(Point):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Point
_core_.Point_swigregister(PointPtr)
#---------------------------------------------------------------------------
class Rect(object):
"""
A class for representing and manipulating rectangles. It has x, y,
width and height properties. In wxPython most palces that expect a
wx.Rect can also accept a (x,y,width,height) tuple.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxRect instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int x=0, int y=0, int width=0, int height=0) -> Rect
Create a new Rect object.
"""
newobj = _core_.new_Rect(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_Rect):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def GetX(*args, **kwargs):
"""GetX(self) -> int"""
return _core_.Rect_GetX(*args, **kwargs)
def SetX(*args, **kwargs):
"""SetX(self, int x)"""
return _core_.Rect_SetX(*args, **kwargs)
def GetY(*args, **kwargs):
"""GetY(self) -> int"""
return _core_.Rect_GetY(*args, **kwargs)
def SetY(*args, **kwargs):
"""SetY(self, int y)"""
return _core_.Rect_SetY(*args, **kwargs)
def GetWidth(*args, **kwargs):
"""GetWidth(self) -> int"""
return _core_.Rect_GetWidth(*args, **kwargs)
def SetWidth(*args, **kwargs):
"""SetWidth(self, int w)"""
return _core_.Rect_SetWidth(*args, **kwargs)
def GetHeight(*args, **kwargs):
"""GetHeight(self) -> int"""
return _core_.Rect_GetHeight(*args, **kwargs)
def SetHeight(*args, **kwargs):
"""SetHeight(self, int h)"""
return _core_.Rect_SetHeight(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""GetPosition(self) -> Point"""
return _core_.Rect_GetPosition(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""SetPosition(self, Point p)"""
return _core_.Rect_SetPosition(*args, **kwargs)
def GetSize(*args, **kwargs):
"""GetSize(self) -> Size"""
return _core_.Rect_GetSize(*args, **kwargs)
def SetSize(*args, **kwargs):
"""SetSize(self, Size s)"""
return _core_.Rect_SetSize(*args, **kwargs)
def IsEmpty(*args, **kwargs):
"""IsEmpty(self) -> bool"""
return _core_.Rect_IsEmpty(*args, **kwargs)
def GetTopLeft(*args, **kwargs):
"""GetTopLeft(self) -> Point"""
return _core_.Rect_GetTopLeft(*args, **kwargs)
def SetTopLeft(*args, **kwargs):
"""SetTopLeft(self, Point p)"""
return _core_.Rect_SetTopLeft(*args, **kwargs)
def GetBottomRight(*args, **kwargs):
"""GetBottomRight(self) -> Point"""
return _core_.Rect_GetBottomRight(*args, **kwargs)
def SetBottomRight(*args, **kwargs):
"""SetBottomRight(self, Point p)"""
return _core_.Rect_SetBottomRight(*args, **kwargs)
def GetLeft(*args, **kwargs):
"""GetLeft(self) -> int"""
return _core_.Rect_GetLeft(*args, **kwargs)
def GetTop(*args, **kwargs):
"""GetTop(self) -> int"""
return _core_.Rect_GetTop(*args, **kwargs)
def GetBottom(*args, **kwargs):
"""GetBottom(self) -> int"""
return _core_.Rect_GetBottom(*args, **kwargs)
def GetRight(*args, **kwargs):
"""GetRight(self) -> int"""
return _core_.Rect_GetRight(*args, **kwargs)
def SetLeft(*args, **kwargs):
"""SetLeft(self, int left)"""
return _core_.Rect_SetLeft(*args, **kwargs)
def SetRight(*args, **kwargs):
"""SetRight(self, int right)"""
return _core_.Rect_SetRight(*args, **kwargs)
def SetTop(*args, **kwargs):
"""SetTop(self, int top)"""
return _core_.Rect_SetTop(*args, **kwargs)
def SetBottom(*args, **kwargs):
"""SetBottom(self, int bottom)"""
return _core_.Rect_SetBottom(*args, **kwargs)
position = property(GetPosition, SetPosition)
size = property(GetSize, SetSize)
left = property(GetLeft, SetLeft)
right = property(GetRight, SetRight)
top = property(GetTop, SetTop)
bottom = property(GetBottom, SetBottom)
def Inflate(*args, **kwargs):
"""
Inflate(self, int dx, int dy) -> Rect
Increases the size of the rectangle.
The left border is moved farther left and the right border is moved
farther right by ``dx``. The upper border is moved farther up and the
bottom border is moved farther down by ``dy``. (Note the the width and
height of the rectangle thus change by ``2*dx`` and ``2*dy``,
respectively.) If one or both of ``dx`` and ``dy`` are negative, the
opposite happens: the rectangle size decreases in the respective
direction.
The change is made to the rectangle inplace, if instead you need a
copy that is inflated, preserving the original then make the copy
first::
copy = wx.Rect(*original)
copy.Inflate(10,15)
"""
return _core_.Rect_Inflate(*args, **kwargs)
def Deflate(*args, **kwargs):
"""
Deflate(self, int dx, int dy) -> Rect
Decrease the rectangle size. This method is the opposite of `Inflate`
in that Deflate(a,b) is equivalent to Inflate(-a,-b). Please refer to
`Inflate` for a full description.
"""
return _core_.Rect_Deflate(*args, **kwargs)
def OffsetXY(*args, **kwargs):
"""
OffsetXY(self, int dx, int dy)
Moves the rectangle by the specified offset. If dx is positive, the
rectangle is moved to the right, if dy is positive, it is moved to the
bottom, otherwise it is moved to the left or top respectively.
"""
return _core_.Rect_OffsetXY(*args, **kwargs)
def Offset(*args, **kwargs):
"""
Offset(self, Point pt)
Same as OffsetXY but uses dx,dy from Point
"""
return _core_.Rect_Offset(*args, **kwargs)
def Intersect(*args, **kwargs):
"""
Intersect(self, Rect rect) -> Rect
Returns the intersectsion of this rectangle and rect.
"""
return _core_.Rect_Intersect(*args, **kwargs)
def Union(*args, **kwargs):
"""
Union(self, Rect rect) -> Rect
Returns the union of this rectangle and rect.
"""
return _core_.Rect_Union(*args, **kwargs)
def __add__(*args, **kwargs):
"""
__add__(self, Rect rect) -> Rect
Add the properties of rect to this rectangle and return the result.
"""
return _core_.Rect___add__(*args, **kwargs)
def __iadd__(*args, **kwargs):
"""
__iadd__(self, Rect rect) -> Rect
Add the properties of rect to this rectangle, updating this rectangle.
"""
return _core_.Rect___iadd__(*args, **kwargs)
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Test for equality of wx.Rect objects.
"""
return _core_.Rect___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Test for inequality of wx.Rect objects.
"""
return _core_.Rect___ne__(*args, **kwargs)
def InsideXY(*args, **kwargs):
"""
InsideXY(self, int x, int y) -> bool
Return True if the point is (not strcitly) inside the rect.
"""
return _core_.Rect_InsideXY(*args, **kwargs)
def Inside(*args, **kwargs):
"""
Inside(self, Point pt) -> bool
Return True if the point is (not strcitly) inside the rect.
"""
return _core_.Rect_Inside(*args, **kwargs)
def Intersects(*args, **kwargs):
"""
Intersects(self, Rect rect) -> bool
Returns True if the rectangles have a non empty intersection.
"""
return _core_.Rect_Intersects(*args, **kwargs)
x = property(_core_.Rect_x_get, _core_.Rect_x_set)
y = property(_core_.Rect_y_get, _core_.Rect_y_set)
width = property(_core_.Rect_width_get, _core_.Rect_width_set)
height = property(_core_.Rect_height_get, _core_.Rect_height_set)
def Set(*args, **kwargs):
"""
Set(self, int x=0, int y=0, int width=0, int height=0)
Set all rectangle properties.
"""
return _core_.Rect_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""
Get() -> (x,y,width,height)
Return the rectangle properties as a tuple.
"""
return _core_.Rect_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Rect'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.x = val
elif index == 1: self.y = val
elif index == 2: self.width = val
elif index == 3: self.height = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0,0,0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Rect, self.Get())
class RectPtr(Rect):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Rect
_core_.Rect_swigregister(RectPtr)
def RectPP(*args, **kwargs):
"""
RectPP(Point topLeft, Point bottomRight) -> Rect
Create a new Rect object from Points representing two corners.
"""
val = _core_.new_RectPP(*args, **kwargs)
val.thisown = 1
return val
def RectPS(*args, **kwargs):
"""
RectPS(Point pos, Size size) -> Rect
Create a new Rect from a position and size.
"""
val = _core_.new_RectPS(*args, **kwargs)
val.thisown = 1
return val
def RectS(*args, **kwargs):
"""
RectS(Size size) -> Rect
Create a new Rect from a size only.
"""
val = _core_.new_RectS(*args, **kwargs)
val.thisown = 1
return val
def IntersectRect(*args, **kwargs):
"""
IntersectRect(Rect r1, Rect r2) -> Rect
Calculate and return the intersection of r1 and r2.
"""
return _core_.IntersectRect(*args, **kwargs)
#---------------------------------------------------------------------------
class Point2D(object):
"""
wx.Point2Ds represent a point or a vector in a 2d coordinate system
with floating point values.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPoint2D instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, double x=0.0, double y=0.0) -> Point2D
Create a w.Point2D object.
"""
newobj = _core_.new_Point2D(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetFloor(*args, **kwargs):
"""
GetFloor() -> (x,y)
Convert to integer
"""
return _core_.Point2D_GetFloor(*args, **kwargs)
def GetRounded(*args, **kwargs):
"""
GetRounded() -> (x,y)
Convert to integer
"""
return _core_.Point2D_GetRounded(*args, **kwargs)
def GetVectorLength(*args, **kwargs):
"""GetVectorLength(self) -> double"""
return _core_.Point2D_GetVectorLength(*args, **kwargs)
def GetVectorAngle(*args, **kwargs):
"""GetVectorAngle(self) -> double"""
return _core_.Point2D_GetVectorAngle(*args, **kwargs)
def SetVectorLength(*args, **kwargs):
"""SetVectorLength(self, double length)"""
return _core_.Point2D_SetVectorLength(*args, **kwargs)
def SetVectorAngle(*args, **kwargs):
"""SetVectorAngle(self, double degrees)"""
return _core_.Point2D_SetVectorAngle(*args, **kwargs)
def SetPolarCoordinates(self, angle, length):
self.SetVectorLength(length)
self.SetVectorAngle(angle)
def Normalize(self):
self.SetVectorLength(1.0)
def GetDistance(*args, **kwargs):
"""GetDistance(self, Point2D pt) -> double"""
return _core_.Point2D_GetDistance(*args, **kwargs)
def GetDistanceSquare(*args, **kwargs):
"""GetDistanceSquare(self, Point2D pt) -> double"""
return _core_.Point2D_GetDistanceSquare(*args, **kwargs)
def GetDotProduct(*args, **kwargs):
"""GetDotProduct(self, Point2D vec) -> double"""
return _core_.Point2D_GetDotProduct(*args, **kwargs)
def GetCrossProduct(*args, **kwargs):
"""GetCrossProduct(self, Point2D vec) -> double"""
return _core_.Point2D_GetCrossProduct(*args, **kwargs)
def __neg__(*args, **kwargs):
"""
__neg__(self) -> Point2D
the reflection of this point
"""
return _core_.Point2D___neg__(*args, **kwargs)
def __iadd__(*args, **kwargs):
"""__iadd__(self, Point2D pt) -> Point2D"""
return _core_.Point2D___iadd__(*args, **kwargs)
def __isub__(*args, **kwargs):
"""__isub__(self, Point2D pt) -> Point2D"""
return _core_.Point2D___isub__(*args, **kwargs)
def __imul__(*args, **kwargs):
"""__imul__(self, Point2D pt) -> Point2D"""
return _core_.Point2D___imul__(*args, **kwargs)
def __idiv__(*args, **kwargs):
"""__idiv__(self, Point2D pt) -> Point2D"""
return _core_.Point2D___idiv__(*args, **kwargs)
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Test for equality of wx.Point2D objects.
"""
return _core_.Point2D___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Test for inequality of wx.Point2D objects.
"""
return _core_.Point2D___ne__(*args, **kwargs)
x = property(_core_.Point2D_x_get, _core_.Point2D_x_set)
y = property(_core_.Point2D_y_get, _core_.Point2D_y_set)
def Set(*args, **kwargs):
"""Set(self, double x=0, double y=0)"""
return _core_.Point2D_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""
Get() -> (x,y)
Return x and y properties as a tuple.
"""
return _core_.Point2D_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Point2D'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.x = val
elif index == 1: self.y = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0.0, 0.0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Point2D, self.Get())
class Point2DPtr(Point2D):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Point2D
_core_.Point2D_swigregister(Point2DPtr)
def Point2DCopy(*args, **kwargs):
"""
Point2DCopy(Point2D pt) -> Point2D
Create a w.Point2D object.
"""
val = _core_.new_Point2DCopy(*args, **kwargs)
val.thisown = 1
return val
def Point2DFromPoint(*args, **kwargs):
"""
Point2DFromPoint(Point pt) -> Point2D
Create a w.Point2D object.
"""
val = _core_.new_Point2DFromPoint(*args, **kwargs)
val.thisown = 1
return val
#---------------------------------------------------------------------------
FromStart = _core_.FromStart
FromCurrent = _core_.FromCurrent
FromEnd = _core_.FromEnd
class InputStream(object):
"""Proxy of C++ InputStream class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyInputStream instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, PyObject p) -> InputStream"""
newobj = _core_.new_InputStream(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_InputStream):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def close(*args, **kwargs):
"""close(self)"""
return _core_.InputStream_close(*args, **kwargs)
def flush(*args, **kwargs):
"""flush(self)"""
return _core_.InputStream_flush(*args, **kwargs)
def eof(*args, **kwargs):
"""eof(self) -> bool"""
return _core_.InputStream_eof(*args, **kwargs)
def read(*args, **kwargs):
"""read(self, int size=-1) -> PyObject"""
return _core_.InputStream_read(*args, **kwargs)
def readline(*args, **kwargs):
"""readline(self, int size=-1) -> PyObject"""
return _core_.InputStream_readline(*args, **kwargs)
def readlines(*args, **kwargs):
"""readlines(self, int sizehint=-1) -> PyObject"""
return _core_.InputStream_readlines(*args, **kwargs)
def seek(*args, **kwargs):
"""seek(self, int offset, int whence=0)"""
return _core_.InputStream_seek(*args, **kwargs)
def tell(*args, **kwargs):
"""tell(self) -> int"""
return _core_.InputStream_tell(*args, **kwargs)
def Peek(*args, **kwargs):
"""Peek(self) -> char"""
return _core_.InputStream_Peek(*args, **kwargs)
def GetC(*args, **kwargs):
"""GetC(self) -> char"""
return _core_.InputStream_GetC(*args, **kwargs)
def LastRead(*args, **kwargs):
"""LastRead(self) -> size_t"""
return _core_.InputStream_LastRead(*args, **kwargs)
def CanRead(*args, **kwargs):
"""CanRead(self) -> bool"""
return _core_.InputStream_CanRead(*args, **kwargs)
def Eof(*args, **kwargs):
"""Eof(self) -> bool"""
return _core_.InputStream_Eof(*args, **kwargs)
def Ungetch(*args, **kwargs):
"""Ungetch(self, char c) -> bool"""
return _core_.InputStream_Ungetch(*args, **kwargs)
def SeekI(*args, **kwargs):
"""SeekI(self, long pos, int mode=FromStart) -> long"""
return _core_.InputStream_SeekI(*args, **kwargs)
def TellI(*args, **kwargs):
"""TellI(self) -> long"""
return _core_.InputStream_TellI(*args, **kwargs)
class InputStreamPtr(InputStream):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = InputStream
_core_.InputStream_swigregister(InputStreamPtr)
DefaultPosition = cvar.DefaultPosition
DefaultSize = cvar.DefaultSize
class OutputStream(object):
"""Proxy of C++ OutputStream class"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxOutputStream instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def write(*args, **kwargs):
"""write(self, PyObject obj)"""
return _core_.OutputStream_write(*args, **kwargs)
def LastWrite(*args, **kwargs):
"""LastWrite(self) -> size_t"""
return _core_.OutputStream_LastWrite(*args, **kwargs)
class OutputStreamPtr(OutputStream):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = OutputStream
_core_.OutputStream_swigregister(OutputStreamPtr)
#---------------------------------------------------------------------------
class FSFile(Object):
"""Proxy of C++ FSFile class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFSFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, InputStream stream, String loc, String mimetype, String anchor,
DateTime modif) -> FSFile
"""
newobj = _core_.new_FSFile(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self.thisown = 0 # It will normally be deleted by the user of the wx.FileSystem
def __del__(self, destroy=_core_.delete_FSFile):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def GetStream(*args, **kwargs):
"""GetStream(self) -> InputStream"""
return _core_.FSFile_GetStream(*args, **kwargs)
def GetMimeType(*args, **kwargs):
"""GetMimeType(self) -> String"""
return _core_.FSFile_GetMimeType(*args, **kwargs)
def GetLocation(*args, **kwargs):
"""GetLocation(self) -> String"""
return _core_.FSFile_GetLocation(*args, **kwargs)
def GetAnchor(*args, **kwargs):
"""GetAnchor(self) -> String"""
return _core_.FSFile_GetAnchor(*args, **kwargs)
def GetModificationTime(*args, **kwargs):
"""GetModificationTime(self) -> DateTime"""
return _core_.FSFile_GetModificationTime(*args, **kwargs)
class FSFilePtr(FSFile):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FSFile
_core_.FSFile_swigregister(FSFilePtr)
class CPPFileSystemHandler(object):
"""Proxy of C++ CPPFileSystemHandler class"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileSystemHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
class CPPFileSystemHandlerPtr(CPPFileSystemHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CPPFileSystemHandler
_core_.CPPFileSystemHandler_swigregister(CPPFileSystemHandlerPtr)
class FileSystemHandler(CPPFileSystemHandler):
"""Proxy of C++ FileSystemHandler class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyFileSystemHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> FileSystemHandler"""
newobj = _core_.new_FileSystemHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, FileSystemHandler)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _core_.FileSystemHandler__setCallbackInfo(*args, **kwargs)
def CanOpen(*args, **kwargs):
"""CanOpen(self, String location) -> bool"""
return _core_.FileSystemHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
"""OpenFile(self, FileSystem fs, String location) -> FSFile"""
return _core_.FileSystemHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
"""FindFirst(self, String spec, int flags=0) -> String"""
return _core_.FileSystemHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
"""FindNext(self) -> String"""
return _core_.FileSystemHandler_FindNext(*args, **kwargs)
def GetProtocol(*args, **kwargs):
"""GetProtocol(self, String location) -> String"""
return _core_.FileSystemHandler_GetProtocol(*args, **kwargs)
def GetLeftLocation(*args, **kwargs):
"""GetLeftLocation(self, String location) -> String"""
return _core_.FileSystemHandler_GetLeftLocation(*args, **kwargs)
def GetAnchor(*args, **kwargs):
"""GetAnchor(self, String location) -> String"""
return _core_.FileSystemHandler_GetAnchor(*args, **kwargs)
def GetRightLocation(*args, **kwargs):
"""GetRightLocation(self, String location) -> String"""
return _core_.FileSystemHandler_GetRightLocation(*args, **kwargs)
def GetMimeTypeFromExt(*args, **kwargs):
"""GetMimeTypeFromExt(self, String location) -> String"""
return _core_.FileSystemHandler_GetMimeTypeFromExt(*args, **kwargs)
class FileSystemHandlerPtr(FileSystemHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileSystemHandler
_core_.FileSystemHandler_swigregister(FileSystemHandlerPtr)
class FileSystem(Object):
"""Proxy of C++ FileSystem class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileSystem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> FileSystem"""
newobj = _core_.new_FileSystem(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_FileSystem):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def ChangePathTo(*args, **kwargs):
"""ChangePathTo(self, String location, bool is_dir=False)"""
return _core_.FileSystem_ChangePathTo(*args, **kwargs)
def GetPath(*args, **kwargs):
"""GetPath(self) -> String"""
return _core_.FileSystem_GetPath(*args, **kwargs)
def OpenFile(*args, **kwargs):
"""OpenFile(self, String location) -> FSFile"""
return _core_.FileSystem_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
"""FindFirst(self, String spec, int flags=0) -> String"""
return _core_.FileSystem_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
"""FindNext(self) -> String"""
return _core_.FileSystem_FindNext(*args, **kwargs)
def AddHandler(*args, **kwargs):
"""AddHandler(CPPFileSystemHandler handler)"""
return _core_.FileSystem_AddHandler(*args, **kwargs)
AddHandler = staticmethod(AddHandler)
def CleanUpHandlers(*args, **kwargs):
"""CleanUpHandlers()"""
return _core_.FileSystem_CleanUpHandlers(*args, **kwargs)
CleanUpHandlers = staticmethod(CleanUpHandlers)
def FileNameToURL(*args, **kwargs):
"""FileNameToURL(String filename) -> String"""
return _core_.FileSystem_FileNameToURL(*args, **kwargs)
FileNameToURL = staticmethod(FileNameToURL)
def URLToFileName(*args, **kwargs):
"""URLToFileName(String url) -> String"""
return _core_.FileSystem_URLToFileName(*args, **kwargs)
URLToFileName = staticmethod(URLToFileName)
class FileSystemPtr(FileSystem):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FileSystem
_core_.FileSystem_swigregister(FileSystemPtr)
def FileSystem_AddHandler(*args, **kwargs):
"""FileSystem_AddHandler(CPPFileSystemHandler handler)"""
return _core_.FileSystem_AddHandler(*args, **kwargs)
def FileSystem_CleanUpHandlers(*args, **kwargs):
"""FileSystem_CleanUpHandlers()"""
return _core_.FileSystem_CleanUpHandlers(*args, **kwargs)
def FileSystem_FileNameToURL(*args, **kwargs):
"""FileSystem_FileNameToURL(String filename) -> String"""
return _core_.FileSystem_FileNameToURL(*args, **kwargs)
def FileSystem_URLToFileName(*args, **kwargs):
"""FileSystem_URLToFileName(String url) -> String"""
return _core_.FileSystem_URLToFileName(*args, **kwargs)
class InternetFSHandler(CPPFileSystemHandler):
"""Proxy of C++ InternetFSHandler class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxInternetFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> InternetFSHandler"""
newobj = _core_.new_InternetFSHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def CanOpen(*args, **kwargs):
"""CanOpen(self, String location) -> bool"""
return _core_.InternetFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
"""OpenFile(self, FileSystem fs, String location) -> FSFile"""
return _core_.InternetFSHandler_OpenFile(*args, **kwargs)
class InternetFSHandlerPtr(InternetFSHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = InternetFSHandler
_core_.InternetFSHandler_swigregister(InternetFSHandlerPtr)
class ZipFSHandler(CPPFileSystemHandler):
"""Proxy of C++ ZipFSHandler class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxZipFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> ZipFSHandler"""
newobj = _core_.new_ZipFSHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def CanOpen(*args, **kwargs):
"""CanOpen(self, String location) -> bool"""
return _core_.ZipFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
"""OpenFile(self, FileSystem fs, String location) -> FSFile"""
return _core_.ZipFSHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
"""FindFirst(self, String spec, int flags=0) -> String"""
return _core_.ZipFSHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
"""FindNext(self) -> String"""
return _core_.ZipFSHandler_FindNext(*args, **kwargs)
class ZipFSHandlerPtr(ZipFSHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ZipFSHandler
_core_.ZipFSHandler_swigregister(ZipFSHandlerPtr)
def __wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs):
"""__wxMemoryFSHandler_AddFile_wxImage(String filename, Image image, long type)"""
return _core_.__wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs):
"""__wxMemoryFSHandler_AddFile_wxBitmap(String filename, Bitmap bitmap, long type)"""
return _core_.__wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_Data(*args, **kwargs):
"""__wxMemoryFSHandler_AddFile_Data(String filename, PyObject data)"""
return _core_.__wxMemoryFSHandler_AddFile_Data(*args, **kwargs)
def MemoryFSHandler_AddFile(filename, dataItem, imgType=-1):
"""
Add 'file' to the memory filesystem. The dataItem parameter can
either be a `wx.Bitmap`, `wx.Image` or a string that can contain
arbitrary data. If a bitmap or image is used then the imgType
parameter should specify what kind of image file it should be
written as, wx.BITMAP_TYPE_PNG, etc.
"""
if isinstance(dataItem, wx.Image):
__wxMemoryFSHandler_AddFile_wxImage(filename, dataItem, imgType)
elif isinstance(dataItem, wx.Bitmap):
__wxMemoryFSHandler_AddFile_wxBitmap(filename, dataItem, imgType)
elif type(dataItem) == str:
__wxMemoryFSHandler_AddFile_Data(filename, dataItem)
else:
raise TypeError, 'wx.Image, wx.Bitmap or string expected'
class MemoryFSHandler(CPPFileSystemHandler):
"""Proxy of C++ MemoryFSHandler class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMemoryFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> MemoryFSHandler"""
newobj = _core_.new_MemoryFSHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def RemoveFile(*args, **kwargs):
"""RemoveFile(String filename)"""
return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
RemoveFile = staticmethod(RemoveFile)
AddFile = staticmethod(MemoryFSHandler_AddFile)
def CanOpen(*args, **kwargs):
"""CanOpen(self, String location) -> bool"""
return _core_.MemoryFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
"""OpenFile(self, FileSystem fs, String location) -> FSFile"""
return _core_.MemoryFSHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
"""FindFirst(self, String spec, int flags=0) -> String"""
return _core_.MemoryFSHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
"""FindNext(self) -> String"""
return _core_.MemoryFSHandler_FindNext(*args, **kwargs)
class MemoryFSHandlerPtr(MemoryFSHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MemoryFSHandler
_core_.MemoryFSHandler_swigregister(MemoryFSHandlerPtr)
def MemoryFSHandler_RemoveFile(*args, **kwargs):
"""MemoryFSHandler_RemoveFile(String filename)"""
return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
IMAGE_ALPHA_TRANSPARENT = _core_.IMAGE_ALPHA_TRANSPARENT
IMAGE_ALPHA_THRESHOLD = _core_.IMAGE_ALPHA_THRESHOLD
IMAGE_ALPHA_OPAQUE = _core_.IMAGE_ALPHA_OPAQUE
#---------------------------------------------------------------------------
class ImageHandler(Object):
"""
This is the base class for implementing image file loading/saving, and
image creation from data. It is used within `wx.Image` and is not
normally seen by the application.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetName(*args, **kwargs):
"""GetName(self) -> String"""
return _core_.ImageHandler_GetName(*args, **kwargs)
def GetExtension(*args, **kwargs):
"""GetExtension(self) -> String"""
return _core_.ImageHandler_GetExtension(*args, **kwargs)
def GetType(*args, **kwargs):
"""GetType(self) -> long"""
return _core_.ImageHandler_GetType(*args, **kwargs)
def GetMimeType(*args, **kwargs):
"""GetMimeType(self) -> String"""
return _core_.ImageHandler_GetMimeType(*args, **kwargs)
def CanRead(*args, **kwargs):
"""CanRead(self, String name) -> bool"""
return _core_.ImageHandler_CanRead(*args, **kwargs)
def SetName(*args, **kwargs):
"""SetName(self, String name)"""
return _core_.ImageHandler_SetName(*args, **kwargs)
def SetExtension(*args, **kwargs):
"""SetExtension(self, String extension)"""
return _core_.ImageHandler_SetExtension(*args, **kwargs)
def SetType(*args, **kwargs):
"""SetType(self, long type)"""
return _core_.ImageHandler_SetType(*args, **kwargs)
def SetMimeType(*args, **kwargs):
"""SetMimeType(self, String mimetype)"""
return _core_.ImageHandler_SetMimeType(*args, **kwargs)
class ImageHandlerPtr(ImageHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ImageHandler
_core_.ImageHandler_swigregister(ImageHandlerPtr)
class PyImageHandler(ImageHandler):
"""
This is the base class for implementing image file loading/saving, and
image creation from data, all written in Python. To create a custom
image handler derive a new class from wx.PyImageHandler and provide
the following methods::
def DoCanRead(self, stream) --> bool
'''Check if this handler can read the image on the stream'''
def LoadFile(self, image, stream, verbose, index) --> bool
'''Load image data from the stream and load it into image.'''
def SaveFile(self, image, stream, verbose) --> bool
'''Save the iamge data in image to the stream using
this handler's image file format.'''
def GetImageCount(self, stream) --> int
'''If this image format can hold more than one image,
how many does the image on the stream have?'''
To activate your handler create an instance of it and pass it to
`wx.Image_AddHandler`. Be sure to call `SetName`, `SetType`, and
`SetExtension` from your constructor.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> PyImageHandler
This is the base class for implementing image file loading/saving, and
image creation from data, all written in Python. To create a custom
image handler derive a new class from wx.PyImageHandler and provide
the following methods::
def DoCanRead(self, stream) --> bool
'''Check if this handler can read the image on the stream'''
def LoadFile(self, image, stream, verbose, index) --> bool
'''Load image data from the stream and load it into image.'''
def SaveFile(self, image, stream, verbose) --> bool
'''Save the iamge data in image to the stream using
this handler's image file format.'''
def GetImageCount(self, stream) --> int
'''If this image format can hold more than one image,
how many does the image on the stream have?'''
To activate your handler create an instance of it and pass it to
`wx.Image_AddHandler`. Be sure to call `SetName`, `SetType`, and
`SetExtension` from your constructor.
"""
newobj = _core_.new_PyImageHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._SetSelf(self)
def _SetSelf(*args, **kwargs):
"""_SetSelf(self, PyObject self)"""
return _core_.PyImageHandler__SetSelf(*args, **kwargs)
class PyImageHandlerPtr(PyImageHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyImageHandler
_core_.PyImageHandler_swigregister(PyImageHandlerPtr)
class ImageHistogram(object):
"""Proxy of C++ ImageHistogram class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxImageHistogram instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> ImageHistogram"""
newobj = _core_.new_ImageHistogram(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def MakeKey(*args, **kwargs):
"""
MakeKey(byte r, byte g, byte b) -> unsigned long
Get the key in the histogram for the given RGB values
"""
return _core_.ImageHistogram_MakeKey(*args, **kwargs)
MakeKey = staticmethod(MakeKey)
def FindFirstUnusedColour(*args, **kwargs):
"""
FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
Find first colour that is not used in the image and has higher RGB
values than startR, startG, startB. Returns a tuple consisting of a
success flag and rgb values.
"""
return _core_.ImageHistogram_FindFirstUnusedColour(*args, **kwargs)
def GetCount(*args, **kwargs):
"""
GetCount(self, unsigned long key) -> unsigned long
Returns the pixel count for the given key. Use `MakeKey` to create a
key value from a RGB tripple.
"""
return _core_.ImageHistogram_GetCount(*args, **kwargs)
def GetCountRGB(*args, **kwargs):
"""
GetCountRGB(self, byte r, byte g, byte b) -> unsigned long
Returns the pixel count for the given RGB values.
"""
return _core_.ImageHistogram_GetCountRGB(*args, **kwargs)
def GetCountColour(*args, **kwargs):
"""
GetCountColour(self, Colour colour) -> unsigned long
Returns the pixel count for the given `wx.Colour` value.
"""
return _core_.ImageHistogram_GetCountColour(*args, **kwargs)
class ImageHistogramPtr(ImageHistogram):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ImageHistogram
_core_.ImageHistogram_swigregister(ImageHistogramPtr)
def ImageHistogram_MakeKey(*args, **kwargs):
"""
ImageHistogram_MakeKey(byte r, byte g, byte b) -> unsigned long
Get the key in the histogram for the given RGB values
"""
return _core_.ImageHistogram_MakeKey(*args, **kwargs)
class Image_RGBValue(object):
"""
An object that contains values for red, green and blue which represent
the value of a color. It is used by `wx.Image.HSVtoRGB` and
`wx.Image.RGBtoHSV`, which converts between HSV color space and RGB
color space.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxImage_RGBValue instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, byte r=0, byte g=0, byte b=0) -> Image_RGBValue
Constructor.
"""
newobj = _core_.new_Image_RGBValue(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
red = property(_core_.Image_RGBValue_red_get, _core_.Image_RGBValue_red_set)
green = property(_core_.Image_RGBValue_green_get, _core_.Image_RGBValue_green_set)
blue = property(_core_.Image_RGBValue_blue_get, _core_.Image_RGBValue_blue_set)
class Image_RGBValuePtr(Image_RGBValue):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Image_RGBValue
_core_.Image_RGBValue_swigregister(Image_RGBValuePtr)
class Image_HSVValue(object):
"""
An object that contains values for hue, saturation and value which
represent the value of a color. It is used by `wx.Image.HSVtoRGB` and
`wx.Image.RGBtoHSV`, which +converts between HSV color space and RGB
color space.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxImage_HSVValue instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, double h=0.0, double s=0.0, double v=0.0) -> Image_HSVValue
Constructor.
"""
newobj = _core_.new_Image_HSVValue(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
hue = property(_core_.Image_HSVValue_hue_get, _core_.Image_HSVValue_hue_set)
saturation = property(_core_.Image_HSVValue_saturation_get, _core_.Image_HSVValue_saturation_set)
value = property(_core_.Image_HSVValue_value_get, _core_.Image_HSVValue_value_set)
class Image_HSVValuePtr(Image_HSVValue):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Image_HSVValue
_core_.Image_HSVValue_swigregister(Image_HSVValuePtr)
class Image(Object):
"""
A platform-independent image class. An image can be created from
data, or using `wx.Bitmap.ConvertToImage`, or loaded from a file in a
variety of formats. Functions are available to set and get image
bits, so it can be used for basic image manipulation.
A wx.Image cannot be drawn directly to a `wx.DC`. Instead, a
platform-specific `wx.Bitmap` object must be created from it using the
`wx.BitmapFromImage` constructor. This bitmap can then be drawn in a
device context, using `wx.DC.DrawBitmap`.
One colour value of the image may be used as a mask colour which will
lead to the automatic creation of a `wx.Mask` object associated to the
bitmap object.
wx.Image supports alpha channel data, that is in addition to a byte
for the red, green and blue colour components for each pixel it also
stores a byte representing the pixel opacity. An alpha value of 0
corresponds to a transparent pixel (null opacity) while a value of 255
means that the pixel is 100% opaque.
Unlike RGB data, not all images have an alpha channel and before using
`GetAlpha` you should check if this image contains an alpha channel
with `HasAlpha`. Note that currently only images loaded from PNG files
with transparency information will have an alpha channel.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxImage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image
Loads an image from a file.
"""
newobj = _core_.new_Image(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_Image):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def Create(*args, **kwargs):
"""
Create(self, int width, int height, bool clear=True)
Creates a fresh image. If clear is ``True``, the new image will be
initialized to black. Otherwise, the image data will be uninitialized.
"""
return _core_.Image_Create(*args, **kwargs)
def Destroy(*args, **kwargs):
"""
Destroy(self)
Destroys the image data.
"""
return _core_.Image_Destroy(*args, **kwargs)
def Scale(*args, **kwargs):
"""
Scale(self, int width, int height) -> Image
Returns a scaled version of the image. This is also useful for scaling
bitmaps in general as the only other way to scale bitmaps is to blit a
`wx.MemoryDC` into another `wx.MemoryDC`.
"""
return _core_.Image_Scale(*args, **kwargs)
def ShrinkBy(*args, **kwargs):
"""
ShrinkBy(self, int xFactor, int yFactor) -> Image
Return a version of the image scaled smaller by the given factors.
"""
return _core_.Image_ShrinkBy(*args, **kwargs)
def Rescale(*args, **kwargs):
"""
Rescale(self, int width, int height) -> Image
Changes the size of the image in-place by scaling it: after a call to
this function, the image will have the given width and height.
Returns the (modified) image itself.
"""
return _core_.Image_Rescale(*args, **kwargs)
def Resize(*args, **kwargs):
"""
Resize(self, Size size, Point pos, int r=-1, int g=-1, int b=-1) -> Image
Changes the size of the image in-place without scaling it, by adding
either a border with the given colour or cropping as necessary. The
image is pasted into a new image with the given size and background
colour at the position pos relative to the upper left of the new
image. If red = green = blue = -1 then use either the current mask
colour if set or find, use, and set a suitable mask colour for any
newly exposed areas.
Returns the (modified) image itself.
"""
return _core_.Image_Resize(*args, **kwargs)
def SetRGB(*args, **kwargs):
"""
SetRGB(self, int x, int y, byte r, byte g, byte b)
Sets the pixel at the given coordinate. This routine performs
bounds-checks for the coordinate so it can be considered a safe way to
manipulate the data, but in some cases this might be too slow so that
the data will have to be set directly. In that case you will have to
get access to the image data using the `GetData` method.
"""
return _core_.Image_SetRGB(*args, **kwargs)
def SetRGBRect(*args, **kwargs):
"""
SetRGBRect(self, Rect rect, byte r, byte g, byte b)
Sets the colour of the pixels within the given rectangle. This routine
performs bounds-checks for the rectangle so it can be considered a
safe way to manipulate the data.
"""
return _core_.Image_SetRGBRect(*args, **kwargs)
def GetRed(*args, **kwargs):
"""
GetRed(self, int x, int y) -> byte
Returns the red intensity at the given coordinate.
"""
return _core_.Image_GetRed(*args, **kwargs)
def GetGreen(*args, **kwargs):
"""
GetGreen(self, int x, int y) -> byte
Returns the green intensity at the given coordinate.
"""
return _core_.Image_GetGreen(*args, **kwargs)
def GetBlue(*args, **kwargs):
"""
GetBlue(self, int x, int y) -> byte
Returns the blue intensity at the given coordinate.
"""
return _core_.Image_GetBlue(*args, **kwargs)
def SetAlpha(*args, **kwargs):
"""
SetAlpha(self, int x, int y, byte alpha)
Sets the alpha value for the given pixel. This function should only be
called if the image has alpha channel data, use `HasAlpha` to check
for this.
"""
return _core_.Image_SetAlpha(*args, **kwargs)
def GetAlpha(*args, **kwargs):
"""
GetAlpha(self, int x, int y) -> byte
Returns the alpha value for the given pixel. This function may only be
called for the images with alpha channel, use `HasAlpha` to check for
this.
The returned value is the *opacity* of the image, i.e. the value of 0
corresponds to the fully transparent pixels while the value of 255 to
the fully opaque pixels.
"""
return _core_.Image_GetAlpha(*args, **kwargs)
def HasAlpha(*args, **kwargs):
"""
HasAlpha(self) -> bool
Returns true if this image has alpha channel, false otherwise.
"""
return _core_.Image_HasAlpha(*args, **kwargs)
def InitAlpha(*args, **kwargs):
"""
InitAlpha(self)
Initializes the image alpha channel data. It is an error to call it if
the image already has alpha data. If it doesn't, alpha data will be by
default initialized to all pixels being fully opaque. But if the image
has a a mask colour, all mask pixels will be completely transparent.
"""
return _core_.Image_InitAlpha(*args, **kwargs)
def IsTransparent(*args, **kwargs):
"""
IsTransparent(self, int x, int y, byte threshold=IMAGE_ALPHA_THRESHOLD) -> bool
Returns ``True`` if this pixel is masked or has an alpha value less
than the spcified threshold.
"""
return _core_.Image_IsTransparent(*args, **kwargs)
def FindFirstUnusedColour(*args, **kwargs):
"""
FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
Find first colour that is not used in the image and has higher RGB
values than startR, startG, startB. Returns a tuple consisting of a
success flag and rgb values.
"""
return _core_.Image_FindFirstUnusedColour(*args, **kwargs)
def ConvertAlphaToMask(*args, **kwargs):
"""
ConvertAlphaToMask(self, byte threshold=IMAGE_ALPHA_THRESHOLD) -> bool
If the image has alpha channel, this method converts it to mask. All
pixels with alpha value less than ``threshold`` are replaced with the
mask colour and the alpha channel is removed. The mask colour is
chosen automatically using `FindFirstUnusedColour`.
If the image image doesn't have alpha channel, ConvertAlphaToMask does
nothing.
"""
return _core_.Image_ConvertAlphaToMask(*args, **kwargs)
def ConvertColourToAlpha(*args, **kwargs):
"""
ConvertColourToAlpha(self, byte r, byte g, byte b) -> bool
This method converts an image where the original alpha information is
only available as a shades of a colour (actually shades of grey)
typically when you draw anti-aliased text into a bitmap. The DC
drawing routines draw grey values on the black background although
they actually mean to draw white with differnt alpha values. This
method reverses it, assuming a black (!) background and white text.
The method will then fill up the whole image with the colour given.
"""
return _core_.Image_ConvertColourToAlpha(*args, **kwargs)
def SetMaskFromImage(*args, **kwargs):
"""
SetMaskFromImage(self, Image mask, byte mr, byte mg, byte mb) -> bool
Sets the image's mask so that the pixels that have RGB value of
``(mr,mg,mb)`` in ``mask`` will be masked in this image. This is done
by first finding an unused colour in the image, setting this colour as
the mask colour and then using this colour to draw all pixels in the
image who corresponding pixel in mask has given RGB value.
Returns ``False`` if ``mask`` does not have same dimensions as the
image or if there is no unused colour left. Returns ``True`` if the
mask was successfully applied.
Note that this method involves computing the histogram, which is
computationally intensive operation.
"""
return _core_.Image_SetMaskFromImage(*args, **kwargs)
def CanRead(*args, **kwargs):
"""
CanRead(String filename) -> bool
Returns True if the image handlers can read this file.
"""
return _core_.Image_CanRead(*args, **kwargs)
CanRead = staticmethod(CanRead)
def GetImageCount(*args, **kwargs):
"""
GetImageCount(String filename, long type=BITMAP_TYPE_ANY) -> int
If the image file contains more than one image and the image handler
is capable of retrieving these individually, this function will return
the number of available images.
"""
return _core_.Image_GetImageCount(*args, **kwargs)
GetImageCount = staticmethod(GetImageCount)
def LoadFile(*args, **kwargs):
"""
LoadFile(self, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool
Loads an image from a file. If no handler type is provided, the
library will try to autodetect the format.
"""
return _core_.Image_LoadFile(*args, **kwargs)
def LoadMimeFile(*args, **kwargs):
"""
LoadMimeFile(self, String name, String mimetype, int index=-1) -> bool
Loads an image from a file, specifying the image type with a MIME type
string.
"""
return _core_.Image_LoadMimeFile(*args, **kwargs)
def SaveFile(*args, **kwargs):
"""
SaveFile(self, String name, int type) -> bool
Saves an image in the named file.
"""
return _core_.Image_SaveFile(*args, **kwargs)
def SaveMimeFile(*args, **kwargs):
"""
SaveMimeFile(self, String name, String mimetype) -> bool
Saves an image in the named file.
"""
return _core_.Image_SaveMimeFile(*args, **kwargs)
def CanReadStream(*args, **kwargs):
"""
CanReadStream(InputStream stream) -> bool
Returns True if the image handlers can read an image file from the
data currently on the input stream, or a readable Python file-like
object.
"""
return _core_.Image_CanReadStream(*args, **kwargs)
CanReadStream = staticmethod(CanReadStream)
def LoadStream(*args, **kwargs):
"""
LoadStream(self, InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool
Loads an image from an input stream or a readable Python file-like
object. If no handler type is provided, the library will try to
autodetect the format.
"""
return _core_.Image_LoadStream(*args, **kwargs)
def LoadMimeStream(*args, **kwargs):
"""
LoadMimeStream(self, InputStream stream, String mimetype, int index=-1) -> bool
Loads an image from an input stream or a readable Python file-like
object, using a MIME type string to specify the image file format.
"""
return _core_.Image_LoadMimeStream(*args, **kwargs)
def Ok(*args, **kwargs):
"""
Ok(self) -> bool
Returns true if image data is present.
"""
return _core_.Image_Ok(*args, **kwargs)
def GetWidth(*args, **kwargs):
"""
GetWidth(self) -> int
Gets the width of the image in pixels.
"""
return _core_.Image_GetWidth(*args, **kwargs)
def GetHeight(*args, **kwargs):
"""
GetHeight(self) -> int
Gets the height of the image in pixels.
"""
return _core_.Image_GetHeight(*args, **kwargs)
def GetSize(*args, **kwargs):
"""
GetSize(self) -> Size
Returns the size of the image in pixels.
"""
return _core_.Image_GetSize(*args, **kwargs)
def GetSubImage(*args, **kwargs):
"""
GetSubImage(self, Rect rect) -> Image
Returns a sub image of the current one as long as the rect belongs
entirely to the image.
"""
return _core_.Image_GetSubImage(*args, **kwargs)
def Size(*args, **kwargs):
"""
Size(self, Size size, Point pos, int r=-1, int g=-1, int b=-1) -> Image
Returns a resized version of this image without scaling it by adding
either a border with the given colour or cropping as necessary. The
image is pasted into a new image with the given size and background
colour at the position ``pos`` relative to the upper left of the new
image. If red = green = blue = -1 then use either the current mask
colour if set or find, use, and set a suitable mask colour for any
newly exposed areas.
"""
return _core_.Image_Size(*args, **kwargs)
def Copy(*args, **kwargs):
"""
Copy(self) -> Image
Returns an identical copy of the image.
"""
return _core_.Image_Copy(*args, **kwargs)
def Paste(*args, **kwargs):
"""
Paste(self, Image image, int x, int y)
Pastes ``image`` into this instance and takes care of the mask colour
and any out of bounds problems.
"""
return _core_.Image_Paste(*args, **kwargs)
def GetData(*args, **kwargs):
"""
GetData(self) -> PyObject
Returns a string containing a copy of the RGB bytes of the image.
"""
return _core_.Image_GetData(*args, **kwargs)
def SetData(*args, **kwargs):
"""
SetData(self, buffer data)
Resets the Image's RGB data from a buffer of RGB bytes. Accepts
either a string or a buffer object holding the data and the length of
the data must be width*height*3.
"""
return _core_.Image_SetData(*args, **kwargs)
def GetDataBuffer(*args, **kwargs):
"""
GetDataBuffer(self) -> PyObject
Returns a writable Python buffer object that is pointing at the RGB
image data buffer inside the wx.Image. You need to ensure that you do
not use this buffer object after the image has been destroyed.
"""
return _core_.Image_GetDataBuffer(*args, **kwargs)
def SetDataBuffer(*args, **kwargs):
"""
SetDataBuffer(self, buffer data)
Sets the internal image data pointer to point at a Python buffer
object. This can save making an extra copy of the data but you must
ensure that the buffer object lives longer than the wx.Image does.
"""
return _core_.Image_SetDataBuffer(*args, **kwargs)
def GetAlphaData(*args, **kwargs):
"""
GetAlphaData(self) -> PyObject
Returns a string containing a copy of the alpha bytes of the image.
"""
return _core_.Image_GetAlphaData(*args, **kwargs)
def SetAlphaData(*args, **kwargs):
"""
SetAlphaData(self, buffer alpha)
Resets the Image's alpha data from a buffer of bytes. Accepts either
a string or a buffer object holding the data and the length of the
data must be width*height.
"""
return _core_.Image_SetAlphaData(*args, **kwargs)
def GetAlphaBuffer(*args, **kwargs):
"""GetAlphaBuffer(self) -> PyObject"""
return _core_.Image_GetAlphaBuffer(*args, **kwargs)
def SetAlphaBuffer(*args, **kwargs):
"""SetAlphaBuffer(self, buffer alpha)"""
return _core_.Image_SetAlphaBuffer(*args, **kwargs)
def SetMaskColour(*args, **kwargs):
"""
SetMaskColour(self, byte r, byte g, byte b)
Sets the mask colour for this image (and tells the image to use the
mask).
"""
return _core_.Image_SetMaskColour(*args, **kwargs)
def GetOrFindMaskColour(*args, **kwargs):
"""
GetOrFindMaskColour() -> (r,g,b)
Get the current mask colour or find a suitable colour.
"""
return _core_.Image_GetOrFindMaskColour(*args, **kwargs)
def GetMaskRed(*args, **kwargs):
"""
GetMaskRed(self) -> byte
Gets the red component of the mask colour.
"""
return _core_.Image_GetMaskRed(*args, **kwargs)
def GetMaskGreen(*args, **kwargs):
"""
GetMaskGreen(self) -> byte
Gets the green component of the mask colour.
"""
return _core_.Image_GetMaskGreen(*args, **kwargs)
def GetMaskBlue(*args, **kwargs):
"""
GetMaskBlue(self) -> byte
Gets the blue component of the mask colour.
"""
return _core_.Image_GetMaskBlue(*args, **kwargs)
def SetMask(*args, **kwargs):
"""
SetMask(self, bool mask=True)
Specifies whether there is a mask or not. The area of the mask is
determined by the current mask colour.
"""
return _core_.Image_SetMask(*args, **kwargs)
def HasMask(*args, **kwargs):
"""
HasMask(self) -> bool
Returns ``True`` if there is a mask active, ``False`` otherwise.
"""
return _core_.Image_HasMask(*args, **kwargs)
def Rotate(*args, **kwargs):
"""
Rotate(self, double angle, Point centre_of_rotation, bool interpolating=True,
Point offset_after_rotation=None) -> Image
Rotates the image about the given point, by ``angle`` radians. Passing
``True`` to ``interpolating`` results in better image quality, but is
slower. If the image has a mask, then the mask colour is used for the
uncovered pixels in the rotated image background. Otherwise, black
will be used as the fill colour.
Returns the rotated image, leaving this image intact.
"""
return _core_.Image_Rotate(*args, **kwargs)
def Rotate90(*args, **kwargs):
"""
Rotate90(self, bool clockwise=True) -> Image
Returns a copy of the image rotated 90 degrees in the direction
indicated by ``clockwise``.
"""
return _core_.Image_Rotate90(*args, **kwargs)
def Mirror(*args, **kwargs):
"""
Mirror(self, bool horizontally=True) -> Image
Returns a mirrored copy of the image. The parameter ``horizontally``
indicates the orientation.
"""
return _core_.Image_Mirror(*args, **kwargs)
def Replace(*args, **kwargs):
"""
Replace(self, byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
Replaces the colour specified by ``(r1,g1,b1)`` by the colour
``(r2,g2,b2)``.
"""
return _core_.Image_Replace(*args, **kwargs)
def ConvertToMono(*args, **kwargs):
"""
ConvertToMono(self, byte r, byte g, byte b) -> Image
Returns monochromatic version of the image. The returned image has
white colour where the original has ``(r,g,b)`` colour and black
colour everywhere else.
"""
return _core_.Image_ConvertToMono(*args, **kwargs)
def SetOption(*args, **kwargs):
"""
SetOption(self, String name, String value)
Sets an image handler defined option. For example, when saving as a
JPEG file, the option ``wx.IMAGE_OPTION_QUALITY`` is used, which is a
number between 0 and 100 (0 is terrible, 100 is very good).
"""
return _core_.Image_SetOption(*args, **kwargs)
def SetOptionInt(*args, **kwargs):
"""
SetOptionInt(self, String name, int value)
Sets an image option as an integer.
"""
return _core_.Image_SetOptionInt(*args, **kwargs)
def GetOption(*args, **kwargs):
"""
GetOption(self, String name) -> String
Gets the value of an image handler option.
"""
return _core_.Image_GetOption(*args, **kwargs)
def GetOptionInt(*args, **kwargs):
"""
GetOptionInt(self, String name) -> int
Gets the value of an image handler option as an integer. If the given
option is not present, the function returns 0.
"""
return _core_.Image_GetOptionInt(*args, **kwargs)
def HasOption(*args, **kwargs):
"""
HasOption(self, String name) -> bool
Returns true if the given option is present.
"""
return _core_.Image_HasOption(*args, **kwargs)
def CountColours(*args, **kwargs):
"""CountColours(self, unsigned long stopafter=(unsigned long) -1) -> unsigned long"""
return _core_.Image_CountColours(*args, **kwargs)
def ComputeHistogram(*args, **kwargs):
"""ComputeHistogram(self, ImageHistogram h) -> unsigned long"""
return _core_.Image_ComputeHistogram(*args, **kwargs)
def AddHandler(*args, **kwargs):
"""AddHandler(ImageHandler handler)"""
return _core_.Image_AddHandler(*args, **kwargs)
AddHandler = staticmethod(AddHandler)
def InsertHandler(*args, **kwargs):
"""InsertHandler(ImageHandler handler)"""
return _core_.Image_InsertHandler(*args, **kwargs)
InsertHandler = staticmethod(InsertHandler)
def RemoveHandler(*args, **kwargs):
"""RemoveHandler(String name) -> bool"""
return _core_.Image_RemoveHandler(*args, **kwargs)
RemoveHandler = staticmethod(RemoveHandler)
def GetHandlers(*args, **kwargs):
"""GetHandlers() -> PyObject"""
return _core_.Image_GetHandlers(*args, **kwargs)
GetHandlers = staticmethod(GetHandlers)
def GetImageExtWildcard(*args, **kwargs):
"""
GetImageExtWildcard() -> String
Iterates all registered wxImageHandler objects, and returns a string
containing file extension masks suitable for passing to file open/save
dialog boxes.
"""
return _core_.Image_GetImageExtWildcard(*args, **kwargs)
GetImageExtWildcard = staticmethod(GetImageExtWildcard)
def ConvertToBitmap(*args, **kwargs):
"""ConvertToBitmap(self, int depth=-1) -> Bitmap"""
return _core_.Image_ConvertToBitmap(*args, **kwargs)
def ConvertToMonoBitmap(*args, **kwargs):
"""ConvertToMonoBitmap(self, byte red, byte green, byte blue) -> Bitmap"""
return _core_.Image_ConvertToMonoBitmap(*args, **kwargs)
def RotateHue(*args, **kwargs):
"""
RotateHue(self, double angle)
Rotates the hue of each pixel of the image. Hue is a double in the
range -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
"""
return _core_.Image_RotateHue(*args, **kwargs)
def RGBtoHSV(*args, **kwargs):
"""
RGBtoHSV(Image_RGBValue rgb) -> Image_HSVValue
Converts a color in RGB color space to HSV color space.
"""
return _core_.Image_RGBtoHSV(*args, **kwargs)
RGBtoHSV = staticmethod(RGBtoHSV)
def HSVtoRGB(*args, **kwargs):
"""
HSVtoRGB(Image_HSVValue hsv) -> Image_RGBValue
Converts a color in HSV color space to RGB color space.
"""
return _core_.Image_HSVtoRGB(*args, **kwargs)
HSVtoRGB = staticmethod(HSVtoRGB)
def __nonzero__(self): return self.Ok()
class ImagePtr(Image):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Image
_core_.Image_swigregister(ImagePtr)
def ImageFromMime(*args, **kwargs):
"""
ImageFromMime(String name, String mimetype, int index=-1) -> Image
Loads an image from a file, using a MIME type string (such as
'image/jpeg') to specify image type.
"""
val = _core_.new_ImageFromMime(*args, **kwargs)
val.thisown = 1
return val
def ImageFromStream(*args, **kwargs):
"""
ImageFromStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image
Loads an image from an input stream, or any readable Python file-like
object.
"""
val = _core_.new_ImageFromStream(*args, **kwargs)
val.thisown = 1
return val
def ImageFromStreamMime(*args, **kwargs):
"""
ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image
Loads an image from an input stream, or any readable Python file-like
object, specifying the image format with a MIME type string.
"""
val = _core_.new_ImageFromStreamMime(*args, **kwargs)
val.thisown = 1
return val
def EmptyImage(*args, **kwargs):
"""
EmptyImage(int width=0, int height=0, bool clear=True) -> Image
Construct an empty image of a given size, optionally setting all
pixels to black.
"""
val = _core_.new_EmptyImage(*args, **kwargs)
val.thisown = 1
return val
def ImageFromBitmap(*args, **kwargs):
"""
ImageFromBitmap(Bitmap bitmap) -> Image
Construct an Image from a `wx.Bitmap`.
"""
val = _core_.new_ImageFromBitmap(*args, **kwargs)
val.thisown = 1
return val
def ImageFromData(*args, **kwargs):
"""
ImageFromData(int width, int height, buffer data) -> Image
Construct an Image from a buffer of RGB bytes. Accepts either a
string or a buffer object holding the data and the length of the data
must be width*height*3.
"""
val = _core_.new_ImageFromData(*args, **kwargs)
val.thisown = 1
return val
def ImageFromDataWithAlpha(*args, **kwargs):
"""
ImageFromDataWithAlpha(int width, int height, buffer data, buffer alpha) -> Image
Construct an Image from a buffer of RGB bytes with an Alpha channel.
Accepts either a string or a buffer object holding the data and the
length of the data must be width*height*3 bytes, and the length of the
alpha data must be width*height bytes.
"""
val = _core_.new_ImageFromDataWithAlpha(*args, **kwargs)
val.thisown = 1
return val
def Image_CanRead(*args, **kwargs):
"""
Image_CanRead(String filename) -> bool
Returns True if the image handlers can read this file.
"""
return _core_.Image_CanRead(*args, **kwargs)
def Image_GetImageCount(*args, **kwargs):
"""
Image_GetImageCount(String filename, long type=BITMAP_TYPE_ANY) -> int
If the image file contains more than one image and the image handler
is capable of retrieving these individually, this function will return
the number of available images.
"""
return _core_.Image_GetImageCount(*args, **kwargs)
def Image_CanReadStream(*args, **kwargs):
"""
Image_CanReadStream(InputStream stream) -> bool
Returns True if the image handlers can read an image file from the
data currently on the input stream, or a readable Python file-like
object.
"""
return _core_.Image_CanReadStream(*args, **kwargs)
def Image_AddHandler(*args, **kwargs):
"""Image_AddHandler(ImageHandler handler)"""
return _core_.Image_AddHandler(*args, **kwargs)
def Image_InsertHandler(*args, **kwargs):
"""Image_InsertHandler(ImageHandler handler)"""
return _core_.Image_InsertHandler(*args, **kwargs)
def Image_RemoveHandler(*args, **kwargs):
"""Image_RemoveHandler(String name) -> bool"""
return _core_.Image_RemoveHandler(*args, **kwargs)
def Image_GetHandlers(*args, **kwargs):
"""Image_GetHandlers() -> PyObject"""
return _core_.Image_GetHandlers(*args, **kwargs)
def Image_GetImageExtWildcard(*args, **kwargs):
"""
Image_GetImageExtWildcard() -> String
Iterates all registered wxImageHandler objects, and returns a string
containing file extension masks suitable for passing to file open/save
dialog boxes.
"""
return _core_.Image_GetImageExtWildcard(*args, **kwargs)
def Image_RGBtoHSV(*args, **kwargs):
"""
Image_RGBtoHSV(Image_RGBValue rgb) -> Image_HSVValue
Converts a color in RGB color space to HSV color space.
"""
return _core_.Image_RGBtoHSV(*args, **kwargs)
def Image_HSVtoRGB(*args, **kwargs):
"""
Image_HSVtoRGB(Image_HSVValue hsv) -> Image_RGBValue
Converts a color in HSV color space to RGB color space.
"""
return _core_.Image_HSVtoRGB(*args, **kwargs)
def InitAllImageHandlers():
"""
The former functionality of InitAllImageHanders is now done internal to
the _core_ extension module and so this function has become a simple NOP.
"""
pass
IMAGE_RESOLUTION_INCHES = _core_.IMAGE_RESOLUTION_INCHES
IMAGE_RESOLUTION_CM = _core_.IMAGE_RESOLUTION_CM
PNG_TYPE_COLOUR = _core_.PNG_TYPE_COLOUR
PNG_TYPE_GREY = _core_.PNG_TYPE_GREY
PNG_TYPE_GREY_RED = _core_.PNG_TYPE_GREY_RED
BMP_24BPP = _core_.BMP_24BPP
BMP_8BPP = _core_.BMP_8BPP
BMP_8BPP_GREY = _core_.BMP_8BPP_GREY
BMP_8BPP_GRAY = _core_.BMP_8BPP_GRAY
BMP_8BPP_RED = _core_.BMP_8BPP_RED
BMP_8BPP_PALETTE = _core_.BMP_8BPP_PALETTE
BMP_4BPP = _core_.BMP_4BPP
BMP_1BPP = _core_.BMP_1BPP
BMP_1BPP_BW = _core_.BMP_1BPP_BW
class BMPHandler(ImageHandler):
"""A `wx.ImageHandler` for \*.bmp bitmap files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxBMPHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> BMPHandler
A `wx.ImageHandler` for \*.bmp bitmap files.
"""
newobj = _core_.new_BMPHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class BMPHandlerPtr(BMPHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = BMPHandler
_core_.BMPHandler_swigregister(BMPHandlerPtr)
NullImage = cvar.NullImage
IMAGE_OPTION_FILENAME = cvar.IMAGE_OPTION_FILENAME
IMAGE_OPTION_BMP_FORMAT = cvar.IMAGE_OPTION_BMP_FORMAT
IMAGE_OPTION_CUR_HOTSPOT_X = cvar.IMAGE_OPTION_CUR_HOTSPOT_X
IMAGE_OPTION_CUR_HOTSPOT_Y = cvar.IMAGE_OPTION_CUR_HOTSPOT_Y
IMAGE_OPTION_RESOLUTION = cvar.IMAGE_OPTION_RESOLUTION
IMAGE_OPTION_RESOLUTIONX = cvar.IMAGE_OPTION_RESOLUTIONX
IMAGE_OPTION_RESOLUTIONY = cvar.IMAGE_OPTION_RESOLUTIONY
IMAGE_OPTION_RESOLUTIONUNIT = cvar.IMAGE_OPTION_RESOLUTIONUNIT
IMAGE_OPTION_QUALITY = cvar.IMAGE_OPTION_QUALITY
IMAGE_OPTION_BITSPERSAMPLE = cvar.IMAGE_OPTION_BITSPERSAMPLE
IMAGE_OPTION_SAMPLESPERPIXEL = cvar.IMAGE_OPTION_SAMPLESPERPIXEL
IMAGE_OPTION_COMPRESSION = cvar.IMAGE_OPTION_COMPRESSION
IMAGE_OPTION_IMAGEDESCRIPTOR = cvar.IMAGE_OPTION_IMAGEDESCRIPTOR
IMAGE_OPTION_PNG_FORMAT = cvar.IMAGE_OPTION_PNG_FORMAT
IMAGE_OPTION_PNG_BITDEPTH = cvar.IMAGE_OPTION_PNG_BITDEPTH
class ICOHandler(BMPHandler):
"""A `wx.ImageHandler` for \*.ico icon files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxICOHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> ICOHandler
A `wx.ImageHandler` for \*.ico icon files.
"""
newobj = _core_.new_ICOHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class ICOHandlerPtr(ICOHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ICOHandler
_core_.ICOHandler_swigregister(ICOHandlerPtr)
class CURHandler(ICOHandler):
"""A `wx.ImageHandler` for \*.cur cursor files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCURHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> CURHandler
A `wx.ImageHandler` for \*.cur cursor files.
"""
newobj = _core_.new_CURHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class CURHandlerPtr(CURHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CURHandler
_core_.CURHandler_swigregister(CURHandlerPtr)
class ANIHandler(CURHandler):
"""A `wx.ImageHandler` for \*.ani animated cursor files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxANIHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> ANIHandler
A `wx.ImageHandler` for \*.ani animated cursor files.
"""
newobj = _core_.new_ANIHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class ANIHandlerPtr(ANIHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ANIHandler
_core_.ANIHandler_swigregister(ANIHandlerPtr)
class PNGHandler(ImageHandler):
"""A `wx.ImageHandler` for PNG image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPNGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> PNGHandler
A `wx.ImageHandler` for PNG image files.
"""
newobj = _core_.new_PNGHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class PNGHandlerPtr(PNGHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PNGHandler
_core_.PNGHandler_swigregister(PNGHandlerPtr)
class GIFHandler(ImageHandler):
"""A `wx.ImageHandler` for GIF image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGIFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> GIFHandler
A `wx.ImageHandler` for GIF image files.
"""
newobj = _core_.new_GIFHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class GIFHandlerPtr(GIFHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GIFHandler
_core_.GIFHandler_swigregister(GIFHandlerPtr)
class PCXHandler(ImageHandler):
"""A `wx.ImageHandler` for PCX imager files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPCXHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> PCXHandler
A `wx.ImageHandler` for PCX imager files.
"""
newobj = _core_.new_PCXHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class PCXHandlerPtr(PCXHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PCXHandler
_core_.PCXHandler_swigregister(PCXHandlerPtr)
class JPEGHandler(ImageHandler):
"""A `wx.ImageHandler` for JPEG/JPG image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxJPEGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> JPEGHandler
A `wx.ImageHandler` for JPEG/JPG image files.
"""
newobj = _core_.new_JPEGHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class JPEGHandlerPtr(JPEGHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = JPEGHandler
_core_.JPEGHandler_swigregister(JPEGHandlerPtr)
class PNMHandler(ImageHandler):
"""A `wx.ImageHandler` for PNM image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPNMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> PNMHandler
A `wx.ImageHandler` for PNM image files.
"""
newobj = _core_.new_PNMHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class PNMHandlerPtr(PNMHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PNMHandler
_core_.PNMHandler_swigregister(PNMHandlerPtr)
class XPMHandler(ImageHandler):
"""A `wx.ImageHandler` for XPM image."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxXPMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> XPMHandler
A `wx.ImageHandler` for XPM image.
"""
newobj = _core_.new_XPMHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class XPMHandlerPtr(XPMHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = XPMHandler
_core_.XPMHandler_swigregister(XPMHandlerPtr)
class TIFFHandler(ImageHandler):
"""A `wx.ImageHandler` for TIFF image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxTIFFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> TIFFHandler
A `wx.ImageHandler` for TIFF image files.
"""
newobj = _core_.new_TIFFHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class TIFFHandlerPtr(TIFFHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TIFFHandler
_core_.TIFFHandler_swigregister(TIFFHandlerPtr)
QUANTIZE_INCLUDE_WINDOWS_COLOURS = _core_.QUANTIZE_INCLUDE_WINDOWS_COLOURS
QUANTIZE_FILL_DESTINATION_IMAGE = _core_.QUANTIZE_FILL_DESTINATION_IMAGE
class Quantize(object):
"""Performs quantization, or colour reduction, on a wxImage."""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxQuantize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Quantize(*args, **kwargs):
"""
Quantize(Image src, Image dest, int desiredNoColours=236, int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE) -> bool
Reduce the colours in the source image and put the result into the
destination image, setting the palette in the destination if
needed. Both images may be the same, to overwrite the source image.
"""
return _core_.Quantize_Quantize(*args, **kwargs)
Quantize = staticmethod(Quantize)
class QuantizePtr(Quantize):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Quantize
_core_.Quantize_swigregister(QuantizePtr)
def Quantize_Quantize(*args, **kwargs):
"""
Quantize_Quantize(Image src, Image dest, int desiredNoColours=236, int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE) -> bool
Reduce the colours in the source image and put the result into the
destination image, setting the palette in the destination if
needed. Both images may be the same, to overwrite the source image.
"""
return _core_.Quantize_Quantize(*args, **kwargs)
#---------------------------------------------------------------------------
class EvtHandler(Object):
"""Proxy of C++ EvtHandler class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxEvtHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> EvtHandler"""
newobj = _core_.new_EvtHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetNextHandler(*args, **kwargs):
"""GetNextHandler(self) -> EvtHandler"""
return _core_.EvtHandler_GetNextHandler(*args, **kwargs)
def GetPreviousHandler(*args, **kwargs):
"""GetPreviousHandler(self) -> EvtHandler"""
return _core_.EvtHandler_GetPreviousHandler(*args, **kwargs)
def SetNextHandler(*args, **kwargs):
"""SetNextHandler(self, EvtHandler handler)"""
return _core_.EvtHandler_SetNextHandler(*args, **kwargs)
def SetPreviousHandler(*args, **kwargs):
"""SetPreviousHandler(self, EvtHandler handler)"""
return _core_.EvtHandler_SetPreviousHandler(*args, **kwargs)
def GetEvtHandlerEnabled(*args, **kwargs):
"""GetEvtHandlerEnabled(self) -> bool"""
return _core_.EvtHandler_GetEvtHandlerEnabled(*args, **kwargs)
def SetEvtHandlerEnabled(*args, **kwargs):
"""SetEvtHandlerEnabled(self, bool enabled)"""
return _core_.EvtHandler_SetEvtHandlerEnabled(*args, **kwargs)
def ProcessEvent(*args, **kwargs):
"""ProcessEvent(self, Event event) -> bool"""
return _core_.EvtHandler_ProcessEvent(*args, **kwargs)
def AddPendingEvent(*args, **kwargs):
"""AddPendingEvent(self, Event event)"""
return _core_.EvtHandler_AddPendingEvent(*args, **kwargs)
def ProcessPendingEvents(*args, **kwargs):
"""ProcessPendingEvents(self)"""
return _core_.EvtHandler_ProcessPendingEvents(*args, **kwargs)
def Connect(*args, **kwargs):
"""Connect(self, int id, int lastId, int eventType, PyObject func)"""
return _core_.EvtHandler_Connect(*args, **kwargs)
def Disconnect(*args, **kwargs):
"""Disconnect(self, int id, int lastId=-1, wxEventType eventType=wxEVT_NULL) -> bool"""
return _core_.EvtHandler_Disconnect(*args, **kwargs)
def _setOORInfo(*args, **kwargs):
"""_setOORInfo(self, PyObject _self, bool incref=True)"""
return _core_.EvtHandler__setOORInfo(*args, **kwargs)
def Bind(self, event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
"""
Bind an event to an event handler.
:param event: One of the EVT_* objects that specifies the
type of event to bind,
:param handler: A callable object to be invoked when the
event is delivered to self. Pass None to
disconnect an event handler.
:param source: Sometimes the event originates from a
different window than self, but you still
want to catch it in self. (For example, a
button event delivered to a frame.) By
passing the source of the event, the event
handling system is able to differentiate
between the same event type from different
controls.
:param id: Used to spcify the event source by ID instead
of instance.
:param id2: Used when it is desirable to bind a handler
to a range of IDs, such as with EVT_MENU_RANGE.
"""
if source is not None:
id = source.GetId()
event.Bind(self, id, id2, handler)
def Unbind(self, event, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
"""
Disconencts the event handler binding for event from self.
Returns True if successful.
"""
if source is not None:
id = source.GetId()
return event.Unbind(self, id, id2)
class EvtHandlerPtr(EvtHandler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = EvtHandler
_core_.EvtHandler_swigregister(EvtHandlerPtr)
#---------------------------------------------------------------------------
class PyEventBinder(object):
"""
Instances of this class are used to bind specific events to event
handlers.
"""
def __init__(self, evtType, expectedIDs=0):
if expectedIDs not in [0, 1, 2]:
raise ValueError, "Invalid number of expectedIDs"
self.expectedIDs = expectedIDs
if type(evtType) == list or type(evtType) == tuple:
self.evtType = evtType
else:
self.evtType = [evtType]
def Bind(self, target, id1, id2, function):
"""Bind this set of event types to target."""
for et in self.evtType:
target.Connect(id1, id2, et, function)
def Unbind(self, target, id1, id2):
"""Remove an event binding."""
success = 0
for et in self.evtType:
success += target.Disconnect(id1, id2, et)
return success != 0
def __call__(self, *args):
"""
For backwards compatibility with the old EVT_* functions.
Should be called with either (window, func), (window, ID,
func) or (window, ID1, ID2, func) parameters depending on the
type of the event.
"""
assert len(args) == 2 + self.expectedIDs
id1 = wx.ID_ANY
id2 = wx.ID_ANY
target = args[0]
if self.expectedIDs == 0:
func = args[1]
elif self.expectedIDs == 1:
id1 = args[1]
func = args[2]
elif self.expectedIDs == 2:
id1 = args[1]
id2 = args[2]
func = args[3]
else:
raise ValueError, "Unexpected number of IDs"
self.Bind(target, id1, id2, func)
# These two are square pegs that don't fit the PyEventBinder hole...
def EVT_COMMAND(win, id, cmd, func):
win.Connect(id, -1, cmd, func)
def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
win.Connect(id1, id2, cmd, func)
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
EVENT_PROPAGATE_NONE = _core_.EVENT_PROPAGATE_NONE
EVENT_PROPAGATE_MAX = _core_.EVENT_PROPAGATE_MAX
def NewEventType(*args, **kwargs):
"""NewEventType() -> wxEventType"""
return _core_.NewEventType(*args, **kwargs)
wxEVT_NULL = _core_.wxEVT_NULL
wxEVT_FIRST = _core_.wxEVT_FIRST
wxEVT_USER_FIRST = _core_.wxEVT_USER_FIRST
wxEVT_COMMAND_BUTTON_CLICKED = _core_.wxEVT_COMMAND_BUTTON_CLICKED
wxEVT_COMMAND_CHECKBOX_CLICKED = _core_.wxEVT_COMMAND_CHECKBOX_CLICKED
wxEVT_COMMAND_CHOICE_SELECTED = _core_.wxEVT_COMMAND_CHOICE_SELECTED
wxEVT_COMMAND_LISTBOX_SELECTED = _core_.wxEVT_COMMAND_LISTBOX_SELECTED
wxEVT_COMMAND_LISTBOX_DOUBLECLICKED = _core_.wxEVT_COMMAND_LISTBOX_DOUBLECLICKED
wxEVT_COMMAND_CHECKLISTBOX_TOGGLED = _core_.wxEVT_COMMAND_CHECKLISTBOX_TOGGLED
wxEVT_COMMAND_MENU_SELECTED = _core_.wxEVT_COMMAND_MENU_SELECTED
wxEVT_COMMAND_TOOL_CLICKED = _core_.wxEVT_COMMAND_TOOL_CLICKED
wxEVT_COMMAND_SLIDER_UPDATED = _core_.wxEVT_COMMAND_SLIDER_UPDATED
wxEVT_COMMAND_RADIOBOX_SELECTED = _core_.wxEVT_COMMAND_RADIOBOX_SELECTED
wxEVT_COMMAND_RADIOBUTTON_SELECTED = _core_.wxEVT_COMMAND_RADIOBUTTON_SELECTED
wxEVT_COMMAND_SCROLLBAR_UPDATED = _core_.wxEVT_COMMAND_SCROLLBAR_UPDATED
wxEVT_COMMAND_VLBOX_SELECTED = _core_.wxEVT_COMMAND_VLBOX_SELECTED
wxEVT_COMMAND_COMBOBOX_SELECTED = _core_.wxEVT_COMMAND_COMBOBOX_SELECTED
wxEVT_COMMAND_TOOL_RCLICKED = _core_.wxEVT_COMMAND_TOOL_RCLICKED
wxEVT_COMMAND_TOOL_ENTER = _core_.wxEVT_COMMAND_TOOL_ENTER
wxEVT_LEFT_DOWN = _core_.wxEVT_LEFT_DOWN
wxEVT_LEFT_UP = _core_.wxEVT_LEFT_UP
wxEVT_MIDDLE_DOWN = _core_.wxEVT_MIDDLE_DOWN
wxEVT_MIDDLE_UP = _core_.wxEVT_MIDDLE_UP
wxEVT_RIGHT_DOWN = _core_.wxEVT_RIGHT_DOWN
wxEVT_RIGHT_UP = _core_.wxEVT_RIGHT_UP
wxEVT_MOTION = _core_.wxEVT_MOTION
wxEVT_ENTER_WINDOW = _core_.wxEVT_ENTER_WINDOW
wxEVT_LEAVE_WINDOW = _core_.wxEVT_LEAVE_WINDOW
wxEVT_LEFT_DCLICK = _core_.wxEVT_LEFT_DCLICK
wxEVT_MIDDLE_DCLICK = _core_.wxEVT_MIDDLE_DCLICK
wxEVT_RIGHT_DCLICK = _core_.wxEVT_RIGHT_DCLICK
wxEVT_SET_FOCUS = _core_.wxEVT_SET_FOCUS
wxEVT_KILL_FOCUS = _core_.wxEVT_KILL_FOCUS
wxEVT_CHILD_FOCUS = _core_.wxEVT_CHILD_FOCUS
wxEVT_MOUSEWHEEL = _core_.wxEVT_MOUSEWHEEL
wxEVT_NC_LEFT_DOWN = _core_.wxEVT_NC_LEFT_DOWN
wxEVT_NC_LEFT_UP = _core_.wxEVT_NC_LEFT_UP
wxEVT_NC_MIDDLE_DOWN = _core_.wxEVT_NC_MIDDLE_DOWN
wxEVT_NC_MIDDLE_UP = _core_.wxEVT_NC_MIDDLE_UP
wxEVT_NC_RIGHT_DOWN = _core_.wxEVT_NC_RIGHT_DOWN
wxEVT_NC_RIGHT_UP = _core_.wxEVT_NC_RIGHT_UP
wxEVT_NC_MOTION = _core_.wxEVT_NC_MOTION
wxEVT_NC_ENTER_WINDOW = _core_.wxEVT_NC_ENTER_WINDOW
wxEVT_NC_LEAVE_WINDOW = _core_.wxEVT_NC_LEAVE_WINDOW
wxEVT_NC_LEFT_DCLICK = _core_.wxEVT_NC_LEFT_DCLICK
wxEVT_NC_MIDDLE_DCLICK = _core_.wxEVT_NC_MIDDLE_DCLICK
wxEVT_NC_RIGHT_DCLICK = _core_.wxEVT_NC_RIGHT_DCLICK
wxEVT_CHAR = _core_.wxEVT_CHAR
wxEVT_CHAR_HOOK = _core_.wxEVT_CHAR_HOOK
wxEVT_NAVIGATION_KEY = _core_.wxEVT_NAVIGATION_KEY
wxEVT_KEY_DOWN = _core_.wxEVT_KEY_DOWN
wxEVT_KEY_UP = _core_.wxEVT_KEY_UP
wxEVT_HOTKEY = _core_.wxEVT_HOTKEY
wxEVT_SET_CURSOR = _core_.wxEVT_SET_CURSOR
wxEVT_SCROLL_TOP = _core_.wxEVT_SCROLL_TOP
wxEVT_SCROLL_BOTTOM = _core_.wxEVT_SCROLL_BOTTOM
wxEVT_SCROLL_LINEUP = _core_.wxEVT_SCROLL_LINEUP
wxEVT_SCROLL_LINEDOWN = _core_.wxEVT_SCROLL_LINEDOWN
wxEVT_SCROLL_PAGEUP = _core_.wxEVT_SCROLL_PAGEUP
wxEVT_SCROLL_PAGEDOWN = _core_.wxEVT_SCROLL_PAGEDOWN
wxEVT_SCROLL_THUMBTRACK = _core_.wxEVT_SCROLL_THUMBTRACK
wxEVT_SCROLL_THUMBRELEASE = _core_.wxEVT_SCROLL_THUMBRELEASE
wxEVT_SCROLL_CHANGED = _core_.wxEVT_SCROLL_CHANGED
wxEVT_SCROLL_ENDSCROLL = wxEVT_SCROLL_CHANGED
wxEVT_SCROLLWIN_TOP = _core_.wxEVT_SCROLLWIN_TOP
wxEVT_SCROLLWIN_BOTTOM = _core_.wxEVT_SCROLLWIN_BOTTOM
wxEVT_SCROLLWIN_LINEUP = _core_.wxEVT_SCROLLWIN_LINEUP
wxEVT_SCROLLWIN_LINEDOWN = _core_.wxEVT_SCROLLWIN_LINEDOWN
wxEVT_SCROLLWIN_PAGEUP = _core_.wxEVT_SCROLLWIN_PAGEUP
wxEVT_SCROLLWIN_PAGEDOWN = _core_.wxEVT_SCROLLWIN_PAGEDOWN
wxEVT_SCROLLWIN_THUMBTRACK = _core_.wxEVT_SCROLLWIN_THUMBTRACK
wxEVT_SCROLLWIN_THUMBRELEASE = _core_.wxEVT_SCROLLWIN_THUMBRELEASE
wxEVT_SIZE = _core_.wxEVT_SIZE
wxEVT_MOVE = _core_.wxEVT_MOVE
wxEVT_CLOSE_WINDOW = _core_.wxEVT_CLOSE_WINDOW
wxEVT_END_SESSION = _core_.wxEVT_END_SESSION
wxEVT_QUERY_END_SESSION = _core_.wxEVT_QUERY_END_SESSION
wxEVT_ACTIVATE_APP = _core_.wxEVT_ACTIVATE_APP
wxEVT_POWER = _core_.wxEVT_POWER
wxEVT_ACTIVATE = _core_.wxEVT_ACTIVATE
wxEVT_CREATE = _core_.wxEVT_CREATE
wxEVT_DESTROY = _core_.wxEVT_DESTROY
wxEVT_SHOW = _core_.wxEVT_SHOW
wxEVT_ICONIZE = _core_.wxEVT_ICONIZE
wxEVT_MAXIMIZE = _core_.wxEVT_MAXIMIZE
wxEVT_MOUSE_CAPTURE_CHANGED = _core_.wxEVT_MOUSE_CAPTURE_CHANGED
wxEVT_PAINT = _core_.wxEVT_PAINT
wxEVT_ERASE_BACKGROUND = _core_.wxEVT_ERASE_BACKGROUND
wxEVT_NC_PAINT = _core_.wxEVT_NC_PAINT
wxEVT_PAINT_ICON = _core_.wxEVT_PAINT_ICON
wxEVT_MENU_OPEN = _core_.wxEVT_MENU_OPEN
wxEVT_MENU_CLOSE = _core_.wxEVT_MENU_CLOSE
wxEVT_MENU_HIGHLIGHT = _core_.wxEVT_MENU_HIGHLIGHT
wxEVT_CONTEXT_MENU = _core_.wxEVT_CONTEXT_MENU
wxEVT_SYS_COLOUR_CHANGED = _core_.wxEVT_SYS_COLOUR_CHANGED
wxEVT_DISPLAY_CHANGED = _core_.wxEVT_DISPLAY_CHANGED
wxEVT_SETTING_CHANGED = _core_.wxEVT_SETTING_CHANGED
wxEVT_QUERY_NEW_PALETTE = _core_.wxEVT_QUERY_NEW_PALETTE
wxEVT_PALETTE_CHANGED = _core_.wxEVT_PALETTE_CHANGED
wxEVT_DROP_FILES = _core_.wxEVT_DROP_FILES
wxEVT_DRAW_ITEM = _core_.wxEVT_DRAW_ITEM
wxEVT_MEASURE_ITEM = _core_.wxEVT_MEASURE_ITEM
wxEVT_COMPARE_ITEM = _core_.wxEVT_COMPARE_ITEM
wxEVT_INIT_DIALOG = _core_.wxEVT_INIT_DIALOG
wxEVT_IDLE = _core_.wxEVT_IDLE
wxEVT_UPDATE_UI = _core_.wxEVT_UPDATE_UI
wxEVT_SIZING = _core_.wxEVT_SIZING
wxEVT_MOVING = _core_.wxEVT_MOVING
wxEVT_HIBERNATE = _core_.wxEVT_HIBERNATE
wxEVT_COMMAND_LEFT_CLICK = _core_.wxEVT_COMMAND_LEFT_CLICK
wxEVT_COMMAND_LEFT_DCLICK = _core_.wxEVT_COMMAND_LEFT_DCLICK
wxEVT_COMMAND_RIGHT_CLICK = _core_.wxEVT_COMMAND_RIGHT_CLICK
wxEVT_COMMAND_RIGHT_DCLICK = _core_.wxEVT_COMMAND_RIGHT_DCLICK
wxEVT_COMMAND_SET_FOCUS = _core_.wxEVT_COMMAND_SET_FOCUS
wxEVT_COMMAND_KILL_FOCUS = _core_.wxEVT_COMMAND_KILL_FOCUS
wxEVT_COMMAND_ENTER = _core_.wxEVT_COMMAND_ENTER
#
# Create some event binders
EVT_SIZE = wx.PyEventBinder( wxEVT_SIZE )
EVT_SIZING = wx.PyEventBinder( wxEVT_SIZING )
EVT_MOVE = wx.PyEventBinder( wxEVT_MOVE )
EVT_MOVING = wx.PyEventBinder( wxEVT_MOVING )
EVT_CLOSE = wx.PyEventBinder( wxEVT_CLOSE_WINDOW )
EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
EVT_PAINT = wx.PyEventBinder( wxEVT_PAINT )
EVT_NC_PAINT = wx.PyEventBinder( wxEVT_NC_PAINT )
EVT_ERASE_BACKGROUND = wx.PyEventBinder( wxEVT_ERASE_BACKGROUND )
EVT_CHAR = wx.PyEventBinder( wxEVT_CHAR )
EVT_KEY_DOWN = wx.PyEventBinder( wxEVT_KEY_DOWN )
EVT_KEY_UP = wx.PyEventBinder( wxEVT_KEY_UP )
EVT_HOTKEY = wx.PyEventBinder( wxEVT_HOTKEY, 1)
EVT_CHAR_HOOK = wx.PyEventBinder( wxEVT_CHAR_HOOK )
EVT_MENU_OPEN = wx.PyEventBinder( wxEVT_MENU_OPEN )
EVT_MENU_CLOSE = wx.PyEventBinder( wxEVT_MENU_CLOSE )
EVT_MENU_HIGHLIGHT = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT, 1)
EVT_MENU_HIGHLIGHT_ALL = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT )
EVT_SET_FOCUS = wx.PyEventBinder( wxEVT_SET_FOCUS )
EVT_KILL_FOCUS = wx.PyEventBinder( wxEVT_KILL_FOCUS )
EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
EVT_HIBERNATE = wx.PyEventBinder( wxEVT_HIBERNATE )
EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
EVT_INIT_DIALOG = wx.PyEventBinder( wxEVT_INIT_DIALOG )
EVT_SYS_COLOUR_CHANGED = wx.PyEventBinder( wxEVT_SYS_COLOUR_CHANGED )
EVT_DISPLAY_CHANGED = wx.PyEventBinder( wxEVT_DISPLAY_CHANGED )
EVT_SHOW = wx.PyEventBinder( wxEVT_SHOW )
EVT_MAXIMIZE = wx.PyEventBinder( wxEVT_MAXIMIZE )
EVT_ICONIZE = wx.PyEventBinder( wxEVT_ICONIZE )
EVT_NAVIGATION_KEY = wx.PyEventBinder( wxEVT_NAVIGATION_KEY )
EVT_PALETTE_CHANGED = wx.PyEventBinder( wxEVT_PALETTE_CHANGED )
EVT_QUERY_NEW_PALETTE = wx.PyEventBinder( wxEVT_QUERY_NEW_PALETTE )
EVT_WINDOW_CREATE = wx.PyEventBinder( wxEVT_CREATE )
EVT_WINDOW_DESTROY = wx.PyEventBinder( wxEVT_DESTROY )
EVT_SET_CURSOR = wx.PyEventBinder( wxEVT_SET_CURSOR )
EVT_MOUSE_CAPTURE_CHANGED = wx.PyEventBinder( wxEVT_MOUSE_CAPTURE_CHANGED )
EVT_LEFT_DOWN = wx.PyEventBinder( wxEVT_LEFT_DOWN )
EVT_LEFT_UP = wx.PyEventBinder( wxEVT_LEFT_UP )
EVT_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_MIDDLE_DOWN )
EVT_MIDDLE_UP = wx.PyEventBinder( wxEVT_MIDDLE_UP )
EVT_RIGHT_DOWN = wx.PyEventBinder( wxEVT_RIGHT_DOWN )
EVT_RIGHT_UP = wx.PyEventBinder( wxEVT_RIGHT_UP )
EVT_MOTION = wx.PyEventBinder( wxEVT_MOTION )
EVT_LEFT_DCLICK = wx.PyEventBinder( wxEVT_LEFT_DCLICK )
EVT_MIDDLE_DCLICK = wx.PyEventBinder( wxEVT_MIDDLE_DCLICK )
EVT_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_RIGHT_DCLICK )
EVT_LEAVE_WINDOW = wx.PyEventBinder( wxEVT_LEAVE_WINDOW )
EVT_ENTER_WINDOW = wx.PyEventBinder( wxEVT_ENTER_WINDOW )
EVT_MOUSEWHEEL = wx.PyEventBinder( wxEVT_MOUSEWHEEL )
EVT_MOUSE_EVENTS = wx.PyEventBinder([ wxEVT_LEFT_DOWN,
wxEVT_LEFT_UP,
wxEVT_MIDDLE_DOWN,
wxEVT_MIDDLE_UP,
wxEVT_RIGHT_DOWN,
wxEVT_RIGHT_UP,
wxEVT_MOTION,
wxEVT_LEFT_DCLICK,
wxEVT_MIDDLE_DCLICK,
wxEVT_RIGHT_DCLICK,
wxEVT_ENTER_WINDOW,
wxEVT_LEAVE_WINDOW,
wxEVT_MOUSEWHEEL
])
# Scrolling from wxWindow (sent to wxScrolledWindow)
EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP,
wxEVT_SCROLLWIN_BOTTOM,
wxEVT_SCROLLWIN_LINEUP,
wxEVT_SCROLLWIN_LINEDOWN,
wxEVT_SCROLLWIN_PAGEUP,
wxEVT_SCROLLWIN_PAGEDOWN,
wxEVT_SCROLLWIN_THUMBTRACK,
wxEVT_SCROLLWIN_THUMBRELEASE,
])
EVT_SCROLLWIN_TOP = wx.PyEventBinder( wxEVT_SCROLLWIN_TOP )
EVT_SCROLLWIN_BOTTOM = wx.PyEventBinder( wxEVT_SCROLLWIN_BOTTOM )
EVT_SCROLLWIN_LINEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEUP )
EVT_SCROLLWIN_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEDOWN )
EVT_SCROLLWIN_PAGEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEUP )
EVT_SCROLLWIN_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEDOWN )
EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
# Scrolling from wx.Slider and wx.ScrollBar
EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
wxEVT_SCROLL_BOTTOM,
wxEVT_SCROLL_LINEUP,
wxEVT_SCROLL_LINEDOWN,
wxEVT_SCROLL_PAGEUP,
wxEVT_SCROLL_PAGEDOWN,
wxEVT_SCROLL_THUMBTRACK,
wxEVT_SCROLL_THUMBRELEASE,
wxEVT_SCROLL_CHANGED,
])
EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
EVT_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM )
EVT_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP )
EVT_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN )
EVT_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP )
EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
EVT_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED )
EVT_SCROLL_ENDSCROLL = EVT_SCROLL_CHANGED
# Scrolling from wx.Slider and wx.ScrollBar, with an id
EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
wxEVT_SCROLL_BOTTOM,
wxEVT_SCROLL_LINEUP,
wxEVT_SCROLL_LINEDOWN,
wxEVT_SCROLL_PAGEUP,
wxEVT_SCROLL_PAGEDOWN,
wxEVT_SCROLL_THUMBTRACK,
wxEVT_SCROLL_THUMBRELEASE,
wxEVT_SCROLL_CHANGED,
], 1)
EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
EVT_COMMAND_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM, 1)
EVT_COMMAND_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1)
EVT_COMMAND_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1)
EVT_COMMAND_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP, 1)
EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
EVT_COMMAND_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED, 1)
EVT_COMMAND_SCROLL_ENDSCROLL = EVT_COMMAND_SCROLL_CHANGED
EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
EVT_CHOICE = wx.PyEventBinder( wxEVT_COMMAND_CHOICE_SELECTED, 1)
EVT_LISTBOX = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_SELECTED, 1)
EVT_LISTBOX_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, 1)
EVT_MENU = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 1)
EVT_MENU_RANGE = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 2)
EVT_SLIDER = wx.PyEventBinder( wxEVT_COMMAND_SLIDER_UPDATED, 1)
EVT_RADIOBOX = wx.PyEventBinder( wxEVT_COMMAND_RADIOBOX_SELECTED, 1)
EVT_RADIOBUTTON = wx.PyEventBinder( wxEVT_COMMAND_RADIOBUTTON_SELECTED, 1)
EVT_SCROLLBAR = wx.PyEventBinder( wxEVT_COMMAND_SCROLLBAR_UPDATED, 1)
EVT_VLBOX = wx.PyEventBinder( wxEVT_COMMAND_VLBOX_SELECTED, 1)
EVT_COMBOBOX = wx.PyEventBinder( wxEVT_COMMAND_COMBOBOX_SELECTED, 1)
EVT_TOOL = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 1)
EVT_TOOL_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 2)
EVT_TOOL_RCLICKED = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 1)
EVT_TOOL_RCLICKED_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 2)
EVT_TOOL_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TOOL_ENTER, 1)
EVT_CHECKLISTBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, 1)
EVT_COMMAND_LEFT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_CLICK, 1)
EVT_COMMAND_LEFT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_DCLICK, 1)
EVT_COMMAND_RIGHT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_CLICK, 1)
EVT_COMMAND_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_DCLICK, 1)
EVT_COMMAND_SET_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_SET_FOCUS, 1)
EVT_COMMAND_KILL_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_KILL_FOCUS, 1)
EVT_COMMAND_ENTER = wx.PyEventBinder( wxEVT_COMMAND_ENTER, 1)
EVT_IDLE = wx.PyEventBinder( wxEVT_IDLE )
EVT_UPDATE_UI = wx.PyEventBinder( wxEVT_UPDATE_UI, 1)
EVT_UPDATE_UI_RANGE = wx.PyEventBinder( wxEVT_UPDATE_UI, 2)
EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU )
#---------------------------------------------------------------------------
class Event(Object):
"""
An event is a structure holding information about an event passed to a
callback or member function. wx.Event is an abstract base class for
other event classes
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __del__(self, destroy=_core_.delete_Event):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def SetEventType(*args, **kwargs):
"""
SetEventType(self, wxEventType typ)
Sets the specific type of the event.
"""
return _core_.Event_SetEventType(*args, **kwargs)
def GetEventType(*args, **kwargs):
"""
GetEventType(self) -> wxEventType
Returns the identifier of the given event type, such as
``wxEVT_COMMAND_BUTTON_CLICKED``.
"""
return _core_.Event_GetEventType(*args, **kwargs)
def GetEventObject(*args, **kwargs):
"""
GetEventObject(self) -> Object
Returns the object (usually a window) associated with the event, if
any.
"""
return _core_.Event_GetEventObject(*args, **kwargs)
def SetEventObject(*args, **kwargs):
"""
SetEventObject(self, Object obj)
Sets the originating object, or in other words, obj is normally the
object that is sending the event.
"""
return _core_.Event_SetEventObject(*args, **kwargs)
def GetTimestamp(*args, **kwargs):
"""GetTimestamp(self) -> long"""
return _core_.Event_GetTimestamp(*args, **kwargs)
def SetTimestamp(*args, **kwargs):
"""SetTimestamp(self, long ts=0)"""
return _core_.Event_SetTimestamp(*args, **kwargs)
def GetId(*args, **kwargs):
"""
GetId(self) -> int
Returns the identifier associated with this event, such as a button
command id.
"""
return _core_.Event_GetId(*args, **kwargs)
def SetId(*args, **kwargs):
"""
SetId(self, int Id)
Set's the ID for the event. This is usually the ID of the window that
is sending the event, but it can also be a command id from a menu
item, etc.
"""
return _core_.Event_SetId(*args, **kwargs)
def IsCommandEvent(*args, **kwargs):
"""
IsCommandEvent(self) -> bool
Returns true if the event is or is derived from `wx.CommandEvent` else
it returns false. Note: Exists only for optimization purposes.
"""
return _core_.Event_IsCommandEvent(*args, **kwargs)
def Skip(*args, **kwargs):
"""
Skip(self, bool skip=True)
Called by an event handler, it controls whether additional event
handlers bound to this event will be called after the current event
handler returns. Skip(false) (the default setting) will prevent
additional event handlers from being called and control will be
returned to the sender of the event immediately after the current
handler has finished. Skip(True) will cause the event processing
system to continue searching for a handler function for this event.
"""
return _core_.Event_Skip(*args, **kwargs)
def GetSkipped(*args, **kwargs):
"""
GetSkipped(self) -> bool
Returns true if the event handler should be skipped, false otherwise.
:see: `Skip`
"""
return _core_.Event_GetSkipped(*args, **kwargs)
def ShouldPropagate(*args, **kwargs):
"""
ShouldPropagate(self) -> bool
Test if this event should be propagated to the parent window or not,
i.e. if the propagation level is currently greater than 0.
"""
return _core_.Event_ShouldPropagate(*args, **kwargs)
def StopPropagation(*args, **kwargs):
"""
StopPropagation(self) -> int
Stop the event from propagating to its parent window. Returns the old
propagation level value which may be later passed to
`ResumePropagation` to allow propagating the event again.
"""
return _core_.Event_StopPropagation(*args, **kwargs)
def ResumePropagation(*args, **kwargs):
"""
ResumePropagation(self, int propagationLevel)
Resume the event propagation by restoring the propagation level. (For
example, you can use the value returned by an earlier call to
`StopPropagation`.)
"""
return _core_.Event_ResumePropagation(*args, **kwargs)
def Clone(*args, **kwargs):
"""Clone(self) -> Event"""
return _core_.Event_Clone(*args, **kwargs)
class EventPtr(Event):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Event
_core_.Event_swigregister(EventPtr)
#---------------------------------------------------------------------------
class PropagationDisabler(object):
"""
Helper class to temporarily change an event not to propagate. Simply
create an instance of this class and then whe it is destroyed the
propogation of the event will be restored.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPropagationDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Event event) -> PropagationDisabler
Helper class to temporarily change an event not to propagate. Simply
create an instance of this class and then whe it is destroyed the
propogation of the event will be restored.
"""
newobj = _core_.new_PropagationDisabler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_PropagationDisabler):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
class PropagationDisablerPtr(PropagationDisabler):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PropagationDisabler
_core_.PropagationDisabler_swigregister(PropagationDisablerPtr)
class PropagateOnce(object):
"""
A helper class that will temporarily lower propagation level of an
event. Simply create an instance of this class and then whe it is
destroyed the propogation of the event will be restored.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPropagateOnce instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Event event) -> PropagateOnce
A helper class that will temporarily lower propagation level of an
event. Simply create an instance of this class and then whe it is
destroyed the propogation of the event will be restored.
"""
newobj = _core_.new_PropagateOnce(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_PropagateOnce):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
class PropagateOncePtr(PropagateOnce):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PropagateOnce
_core_.PropagateOnce_swigregister(PropagateOncePtr)
#---------------------------------------------------------------------------
class CommandEvent(Event):
"""
This event class contains information about command events, which
originate from a variety of simple controls, as well as menus and
toolbars.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent
This event class contains information about command events, which
originate from a variety of simple controls, as well as menus and
toolbars.
"""
newobj = _core_.new_CommandEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetSelection(*args, **kwargs):
"""
GetSelection(self) -> int
Returns item index for a listbox or choice selection event (not valid
for a deselection).
"""
return _core_.CommandEvent_GetSelection(*args, **kwargs)
def SetString(*args, **kwargs):
"""SetString(self, String s)"""
return _core_.CommandEvent_SetString(*args, **kwargs)
def GetString(*args, **kwargs):
"""
GetString(self) -> String
Returns item string for a listbox or choice selection event (not valid
for a deselection).
"""
return _core_.CommandEvent_GetString(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""
IsChecked(self) -> bool
This method can be used with checkbox and menu events: for the
checkboxes, the method returns true for a selection event and false
for a deselection one. For the menu events, this method indicates if
the menu item just has become checked or unchecked (and thus only
makes sense for checkable menu items).
"""
return _core_.CommandEvent_IsChecked(*args, **kwargs)
Checked = IsChecked
def IsSelection(*args, **kwargs):
"""
IsSelection(self) -> bool
For a listbox or similar event, returns true if it is a selection,
false if it is a deselection.
"""
return _core_.CommandEvent_IsSelection(*args, **kwargs)
def SetExtraLong(*args, **kwargs):
"""SetExtraLong(self, long extraLong)"""
return _core_.CommandEvent_SetExtraLong(*args, **kwargs)
def GetExtraLong(*args, **kwargs):
"""
GetExtraLong(self) -> long
Returns extra information dependant on the event objects type. If the
event comes from a listbox selection, it is a boolean determining
whether the event was a selection (true) or a deselection (false). A
listbox deselection only occurs for multiple-selection boxes, and in
this case the index and string values are indeterminate and the
listbox must be examined by the application.
"""
return _core_.CommandEvent_GetExtraLong(*args, **kwargs)
def SetInt(*args, **kwargs):
"""SetInt(self, int i)"""
return _core_.CommandEvent_SetInt(*args, **kwargs)
def GetInt(*args, **kwargs):
"""
GetInt(self) -> long
Returns the integer identifier corresponding to a listbox, choice or
radiobox selection (only if the event was a selection, not a
deselection), or a boolean value representing the value of a checkbox.
"""
return _core_.CommandEvent_GetInt(*args, **kwargs)
def GetClientData(*args, **kwargs):
"""
GetClientData(self) -> PyObject
Returns the client data object for a listbox or choice selection event, (if any.)
"""
return _core_.CommandEvent_GetClientData(*args, **kwargs)
def SetClientData(*args, **kwargs):
"""
SetClientData(self, PyObject clientData)
Associate the given client data with the item at position n.
"""
return _core_.CommandEvent_SetClientData(*args, **kwargs)
GetClientObject = GetClientData
SetClientObject = SetClientData
def Clone(*args, **kwargs):
"""Clone(self) -> Event"""
return _core_.CommandEvent_Clone(*args, **kwargs)
class CommandEventPtr(CommandEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CommandEvent
_core_.CommandEvent_swigregister(CommandEventPtr)
#---------------------------------------------------------------------------
class NotifyEvent(CommandEvent):
"""
An instance of this class (or one of its derived classes) is sent from
a control when the control's state is being changed and the control
allows that change to be prevented from happening. The event handler
can call `Veto` or `Allow` to tell the control what to do.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxNotifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent
An instance of this class (or one of its derived classes) is sent from
a control when the control's state is being changed and the control
allows that change to be prevented from happening. The event handler
can call `Veto` or `Allow` to tell the control what to do.
"""
newobj = _core_.new_NotifyEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Veto(*args, **kwargs):
"""
Veto(self)
Prevents the change announced by this event from happening.
It is in general a good idea to notify the user about the reasons for
vetoing the change because otherwise the applications behaviour (which
just refuses to do what the user wants) might be quite surprising.
"""
return _core_.NotifyEvent_Veto(*args, **kwargs)
def Allow(*args, **kwargs):
"""
Allow(self)
This is the opposite of `Veto`: it explicitly allows the event to be
processed. For most events it is not necessary to call this method as
the events are allowed anyhow but some are forbidden by default (this
will be mentioned in the corresponding event description).
"""
return _core_.NotifyEvent_Allow(*args, **kwargs)
def IsAllowed(*args, **kwargs):
"""
IsAllowed(self) -> bool
Returns true if the change is allowed (`Veto` hasn't been called) or
false otherwise (if it was).
"""
return _core_.NotifyEvent_IsAllowed(*args, **kwargs)
class NotifyEventPtr(NotifyEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = NotifyEvent
_core_.NotifyEvent_swigregister(NotifyEventPtr)
#---------------------------------------------------------------------------
class ScrollEvent(CommandEvent):
"""
A scroll event holds information about events sent from stand-alone
scrollbars and sliders. Note that scrolled windows do not send
instnaces of this event class, but send the `wx.ScrollWinEvent`
instead.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxScrollEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0, int pos=0,
int orient=0) -> ScrollEvent
"""
newobj = _core_.new_ScrollEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetOrientation(*args, **kwargs):
"""
GetOrientation(self) -> int
Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
the scrollbar.
"""
return _core_.ScrollEvent_GetOrientation(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> int
Returns the position of the scrollbar.
"""
return _core_.ScrollEvent_GetPosition(*args, **kwargs)
def SetOrientation(*args, **kwargs):
"""SetOrientation(self, int orient)"""
return _core_.ScrollEvent_SetOrientation(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""SetPosition(self, int pos)"""
return _core_.ScrollEvent_SetPosition(*args, **kwargs)
class ScrollEventPtr(ScrollEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ScrollEvent
_core_.ScrollEvent_swigregister(ScrollEventPtr)
#---------------------------------------------------------------------------
class ScrollWinEvent(Event):
"""
A wx.ScrollWinEvent holds information about scrolling and is sent from
scrolling windows.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxScrollWinEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent
A wx.ScrollWinEvent holds information about scrolling and is sent from
scrolling windows.
"""
newobj = _core_.new_ScrollWinEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetOrientation(*args, **kwargs):
"""
GetOrientation(self) -> int
Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
the scrollbar.
"""
return _core_.ScrollWinEvent_GetOrientation(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> int
Returns the position of the scrollbar for the thumb track and release
events. Note that this field can't be used for the other events, you
need to query the window itself for the current position in that case.
"""
return _core_.ScrollWinEvent_GetPosition(*args, **kwargs)
def SetOrientation(*args, **kwargs):
"""SetOrientation(self, int orient)"""
return _core_.ScrollWinEvent_SetOrientation(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""SetPosition(self, int pos)"""
return _core_.ScrollWinEvent_SetPosition(*args, **kwargs)
class ScrollWinEventPtr(ScrollWinEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ScrollWinEvent
_core_.ScrollWinEvent_swigregister(ScrollWinEventPtr)
#---------------------------------------------------------------------------
MOUSE_BTN_ANY = _core_.MOUSE_BTN_ANY
MOUSE_BTN_NONE = _core_.MOUSE_BTN_NONE
MOUSE_BTN_LEFT = _core_.MOUSE_BTN_LEFT
MOUSE_BTN_MIDDLE = _core_.MOUSE_BTN_MIDDLE
MOUSE_BTN_RIGHT = _core_.MOUSE_BTN_RIGHT
class MouseEvent(Event):
"""
This event class contains information about the events generated by
the mouse: they include mouse buttons press and release events and
mouse move events.
All mouse events involving the buttons use ``wx.MOUSE_BTN_LEFT`` for
the left mouse button, ``wx.MOUSE_BTN_MIDDLE`` for the middle one and
``wx.MOUSE_BTN_RIGHT`` for the right one. Note that not all mice have
a middle button so a portable application should avoid relying on the
events from it.
Note the difference between methods like `LeftDown` and `LeftIsDown`:
the former returns true when the event corresponds to the left mouse
button click while the latter returns true if the left mouse button is
currently being pressed. For example, when the user is dragging the
mouse you can use `LeftIsDown` to test whether the left mouse button
is (still) depressed. Also, by convention, if `LeftDown` returns true,
`LeftIsDown` will also return true in wxWidgets whatever the
underlying GUI behaviour is (which is platform-dependent). The same
applies, of course, to other mouse buttons as well.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMouseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType mouseType=wxEVT_NULL) -> MouseEvent
Constructs a wx.MouseEvent. Valid event types are:
* wxEVT_ENTER_WINDOW
* wxEVT_LEAVE_WINDOW
* wxEVT_LEFT_DOWN
* wxEVT_LEFT_UP
* wxEVT_LEFT_DCLICK
* wxEVT_MIDDLE_DOWN
* wxEVT_MIDDLE_UP
* wxEVT_MIDDLE_DCLICK
* wxEVT_RIGHT_DOWN
* wxEVT_RIGHT_UP
* wxEVT_RIGHT_DCLICK
* wxEVT_MOTION
* wxEVT_MOUSEWHEEL
"""
newobj = _core_.new_MouseEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def IsButton(*args, **kwargs):
"""
IsButton(self) -> bool
Returns true if the event was a mouse button event (not necessarily a
button down event - that may be tested using `ButtonDown`).
"""
return _core_.MouseEvent_IsButton(*args, **kwargs)
def ButtonDown(*args, **kwargs):
"""
ButtonDown(self, int but=MOUSE_BTN_ANY) -> bool
If the argument is omitted, this returns true if the event was any
mouse button down event. Otherwise the argument specifies which
button-down event shold be checked for (see `Button` for the possible
values).
"""
return _core_.MouseEvent_ButtonDown(*args, **kwargs)
def ButtonDClick(*args, **kwargs):
"""
ButtonDClick(self, int but=MOUSE_BTN_ANY) -> bool
If the argument is omitted, this returns true if the event was any
mouse double click event. Otherwise the argument specifies which
double click event to check for (see `Button` for the possible
values).
"""
return _core_.MouseEvent_ButtonDClick(*args, **kwargs)
def ButtonUp(*args, **kwargs):
"""
ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool
If the argument is omitted, this returns true if the event was any
mouse button up event. Otherwise the argument specifies which button
up event to check for (see `Button` for the possible values).
"""
return _core_.MouseEvent_ButtonUp(*args, **kwargs)
def Button(*args, **kwargs):
"""
Button(self, int button) -> bool
Returns true if the identified mouse button is changing state. Valid
values of button are:
==================== =====================================
wx.MOUSE_BTN_LEFT check if left button was pressed
wx.MOUSE_BTN_MIDDLE check if middle button was pressed
wx.MOUSE_BTN_RIGHT check if right button was pressed
wx.MOUSE_BTN_ANY check if any button was pressed
==================== =====================================
"""
return _core_.MouseEvent_Button(*args, **kwargs)
def ButtonIsDown(*args, **kwargs):
"""ButtonIsDown(self, int but) -> bool"""
return _core_.MouseEvent_ButtonIsDown(*args, **kwargs)
def GetButton(*args, **kwargs):
"""
GetButton(self) -> int
Returns the mouse button which generated this event or
wx.MOUSE_BTN_NONE if no button is involved (for mouse move, enter or
leave event, for example). Otherwise wx.MOUSE_BTN_LEFT is returned for
the left button down, up and double click events, wx.MOUSE_BTN_MIDDLE
and wx.MOUSE_BTN_RIGHT for the same events for the middle and the
right buttons respectively.
"""
return _core_.MouseEvent_GetButton(*args, **kwargs)
def ControlDown(*args, **kwargs):
"""
ControlDown(self) -> bool
Returns true if the control key was down at the time of the event.
"""
return _core_.MouseEvent_ControlDown(*args, **kwargs)
def MetaDown(*args, **kwargs):
"""
MetaDown(self) -> bool
Returns true if the Meta key was down at the time of the event.
"""
return _core_.MouseEvent_MetaDown(*args, **kwargs)
def AltDown(*args, **kwargs):
"""
AltDown(self) -> bool
Returns true if the Alt key was down at the time of the event.
"""
return _core_.MouseEvent_AltDown(*args, **kwargs)
def ShiftDown(*args, **kwargs):
"""
ShiftDown(self) -> bool
Returns true if the Shift key was down at the time of the event.
"""
return _core_.MouseEvent_ShiftDown(*args, **kwargs)
def CmdDown(*args, **kwargs):
"""
CmdDown(self) -> bool
"Cmd" is a pseudo key which is the same as Control for PC and Unix
platforms but the special "Apple" (a.k.a as "Command") key on
Macs. It often makes sense to use it instead of, say, `ControlDown`
because Cmd key is used for the same thing under Mac as Ctrl
elsewhere. The Ctrl key still exists, it's just not used for this
purpose. So for non-Mac platforms this is the same as `ControlDown`
and Macs this is the same as `MetaDown`.
"""
return _core_.MouseEvent_CmdDown(*args, **kwargs)
def LeftDown(*args, **kwargs):
"""
LeftDown(self) -> bool
Returns true if the left mouse button state changed to down.
"""
return _core_.MouseEvent_LeftDown(*args, **kwargs)
def MiddleDown(*args, **kwargs):
"""
MiddleDown(self) -> bool
Returns true if the middle mouse button state changed to down.
"""
return _core_.MouseEvent_MiddleDown(*args, **kwargs)
def RightDown(*args, **kwargs):
"""
RightDown(self) -> bool
Returns true if the right mouse button state changed to down.
"""
return _core_.MouseEvent_RightDown(*args, **kwargs)
def LeftUp(*args, **kwargs):
"""
LeftUp(self) -> bool
Returns true if the left mouse button state changed to up.
"""
return _core_.MouseEvent_LeftUp(*args, **kwargs)
def MiddleUp(*args, **kwargs):
"""
MiddleUp(self) -> bool
Returns true if the middle mouse button state changed to up.
"""
return _core_.MouseEvent_MiddleUp(*args, **kwargs)
def RightUp(*args, **kwargs):
"""
RightUp(self) -> bool
Returns true if the right mouse button state changed to up.
"""
return _core_.MouseEvent_RightUp(*args, **kwargs)
def LeftDClick(*args, **kwargs):
"""
LeftDClick(self) -> bool
Returns true if the event was a left button double click.
"""
return _core_.MouseEvent_LeftDClick(*args, **kwargs)
def MiddleDClick(*args, **kwargs):
"""
MiddleDClick(self) -> bool
Returns true if the event was a middle button double click.
"""
return _core_.MouseEvent_MiddleDClick(*args, **kwargs)
def RightDClick(*args, **kwargs):
"""
RightDClick(self) -> bool
Returns true if the event was a right button double click.
"""
return _core_.MouseEvent_RightDClick(*args, **kwargs)
def LeftIsDown(*args, **kwargs):
"""
LeftIsDown(self) -> bool
Returns true if the left mouse button is currently down, independent
of the current event type.
Please notice that it is not the same as LeftDown which returns true
if the left mouse button was just pressed. Rather, it describes the
state of the mouse button before the event happened.
This event is usually used in the mouse event handlers which process
"move mouse" messages to determine whether the user is (still)
dragging the mouse.
"""
return _core_.MouseEvent_LeftIsDown(*args, **kwargs)
def MiddleIsDown(*args, **kwargs):
"""
MiddleIsDown(self) -> bool
Returns true if the middle mouse button is currently down, independent
of the current event type.
"""
return _core_.MouseEvent_MiddleIsDown(*args, **kwargs)
def RightIsDown(*args, **kwargs):
"""
RightIsDown(self) -> bool
Returns true if the right mouse button is currently down, independent
of the current event type.
"""
return _core_.MouseEvent_RightIsDown(*args, **kwargs)
def Dragging(*args, **kwargs):
"""
Dragging(self) -> bool
Returns true if this was a dragging event (motion while a button is
depressed).
"""
return _core_.MouseEvent_Dragging(*args, **kwargs)
def Moving(*args, **kwargs):
"""
Moving(self) -> bool
Returns true if this was a motion event and no mouse buttons were
pressed. If any mouse button is held pressed, then this method returns
false and Dragging returns true.
"""
return _core_.MouseEvent_Moving(*args, **kwargs)
def Entering(*args, **kwargs):
"""
Entering(self) -> bool
Returns true if the mouse was entering the window.
"""
return _core_.MouseEvent_Entering(*args, **kwargs)
def Leaving(*args, **kwargs):
"""
Leaving(self) -> bool
Returns true if the mouse was leaving the window.
"""
return _core_.MouseEvent_Leaving(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the pixel position of the mouse in window coordinates when the
event happened.
"""
return _core_.MouseEvent_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
"""
GetPositionTuple() -> (x,y)
Returns the pixel position of the mouse in window coordinates when the
event happened.
"""
return _core_.MouseEvent_GetPositionTuple(*args, **kwargs)
def GetLogicalPosition(*args, **kwargs):
"""
GetLogicalPosition(self, DC dc) -> Point
Returns the logical mouse position in pixels (i.e. translated
according to the translation set for the DC, which usually indicates
that the window has been scrolled).
"""
return _core_.MouseEvent_GetLogicalPosition(*args, **kwargs)
def GetX(*args, **kwargs):
"""
GetX(self) -> int
Returns X coordinate of the physical mouse event position.
"""
return _core_.MouseEvent_GetX(*args, **kwargs)
def GetY(*args, **kwargs):
"""
GetY(self) -> int
Returns Y coordinate of the physical mouse event position.
"""
return _core_.MouseEvent_GetY(*args, **kwargs)
def GetWheelRotation(*args, **kwargs):
"""
GetWheelRotation(self) -> int
Get wheel rotation, positive or negative indicates direction of
rotation. Current devices all send an event when rotation is equal to
+/-WheelDelta, but this allows for finer resolution devices to be
created in the future. Because of this you shouldn't assume that one
event is equal to 1 line or whatever, but you should be able to either
do partial line scrolling or wait until +/-WheelDelta rotation values
have been accumulated before scrolling.
"""
return _core_.MouseEvent_GetWheelRotation(*args, **kwargs)
def GetWheelDelta(*args, **kwargs):
"""
GetWheelDelta(self) -> int
Get wheel delta, normally 120. This is the threshold for action to be
taken, and one such action (for example, scrolling one increment)
should occur for each delta.
"""
return _core_.MouseEvent_GetWheelDelta(*args, **kwargs)
def GetLinesPerAction(*args, **kwargs):
"""
GetLinesPerAction(self) -> int
Returns the configured number of lines (or whatever) to be scrolled
per wheel action. Defaults to three.
"""
return _core_.MouseEvent_GetLinesPerAction(*args, **kwargs)
def IsPageScroll(*args, **kwargs):
"""
IsPageScroll(self) -> bool
Returns true if the system has been setup to do page scrolling with
the mouse wheel instead of line scrolling.
"""
return _core_.MouseEvent_IsPageScroll(*args, **kwargs)
m_x = property(_core_.MouseEvent_m_x_get, _core_.MouseEvent_m_x_set)
m_y = property(_core_.MouseEvent_m_y_get, _core_.MouseEvent_m_y_set)
m_leftDown = property(_core_.MouseEvent_m_leftDown_get, _core_.MouseEvent_m_leftDown_set)
m_middleDown = property(_core_.MouseEvent_m_middleDown_get, _core_.MouseEvent_m_middleDown_set)
m_rightDown = property(_core_.MouseEvent_m_rightDown_get, _core_.MouseEvent_m_rightDown_set)
m_controlDown = property(_core_.MouseEvent_m_controlDown_get, _core_.MouseEvent_m_controlDown_set)
m_shiftDown = property(_core_.MouseEvent_m_shiftDown_get, _core_.MouseEvent_m_shiftDown_set)
m_altDown = property(_core_.MouseEvent_m_altDown_get, _core_.MouseEvent_m_altDown_set)
m_metaDown = property(_core_.MouseEvent_m_metaDown_get, _core_.MouseEvent_m_metaDown_set)
m_wheelRotation = property(_core_.MouseEvent_m_wheelRotation_get, _core_.MouseEvent_m_wheelRotation_set)
m_wheelDelta = property(_core_.MouseEvent_m_wheelDelta_get, _core_.MouseEvent_m_wheelDelta_set)
m_linesPerAction = property(_core_.MouseEvent_m_linesPerAction_get, _core_.MouseEvent_m_linesPerAction_set)
class MouseEventPtr(MouseEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MouseEvent
_core_.MouseEvent_swigregister(MouseEventPtr)
#---------------------------------------------------------------------------
class SetCursorEvent(Event):
"""
A SetCursorEvent is generated when the mouse cursor is about to be set
as a result of mouse motion. This event gives the application the
chance to perform specific mouse cursor processing based on the
current position of the mouse within the window. Use the `SetCursor`
method to specify the cursor you want to be displayed.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSetCursorEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int x=0, int y=0) -> SetCursorEvent
Construct a new `wx.SetCursorEvent`.
"""
newobj = _core_.new_SetCursorEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetX(*args, **kwargs):
"""
GetX(self) -> int
Returns the X coordinate of the mouse in client coordinates.
"""
return _core_.SetCursorEvent_GetX(*args, **kwargs)
def GetY(*args, **kwargs):
"""
GetY(self) -> int
Returns the Y coordinate of the mouse in client coordinates.
"""
return _core_.SetCursorEvent_GetY(*args, **kwargs)
def SetCursor(*args, **kwargs):
"""
SetCursor(self, Cursor cursor)
Sets the cursor associated with this event.
"""
return _core_.SetCursorEvent_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
"""
GetCursor(self) -> Cursor
Returns a reference to the cursor specified by this event.
"""
return _core_.SetCursorEvent_GetCursor(*args, **kwargs)
def HasCursor(*args, **kwargs):
"""
HasCursor(self) -> bool
Returns true if the cursor specified by this event is a valid cursor.
"""
return _core_.SetCursorEvent_HasCursor(*args, **kwargs)
class SetCursorEventPtr(SetCursorEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SetCursorEvent
_core_.SetCursorEvent_swigregister(SetCursorEventPtr)
#---------------------------------------------------------------------------
class KeyEvent(Event):
"""
This event class contains information about keypress and character
events. These events are only sent to the widget that currently has
the keyboard focus.
Notice that there are three different kinds of keyboard events in
wxWidgets: key down and up events and char events. The difference
between the first two is clear - the first corresponds to a key press
and the second to a key release - otherwise they are identical. Just
note that if the key is maintained in a pressed state you will
typically get a lot of (automatically generated) down events but only
one up so it is wrong to assume that there is one up event
corresponding to each down one.
Both key events provide untranslated key codes while the char event
carries the translated one. The untranslated code for alphanumeric
keys is always an upper case value. For the other keys it is one of
WXK_XXX values from the keycodes table. The translated key is, in
general, the character the user expects to appear as the result of the
key combination when typing the text into a text entry zone, for
example.
A few examples to clarify this (all assume that CAPS LOCK is unpressed
and the standard US keyboard): when the 'A' key is pressed, the key
down event key code is equal to ASCII A == 65. But the char event key
code is ASCII a == 97. On the other hand, if you press both SHIFT and
'A' keys simultaneously , the key code in key down event will still be
just 'A' while the char event key code parameter will now be 'A' as
well.
Although in this simple case it is clear that the correct key code
could be found in the key down event handler by checking the value
returned by `ShiftDown`, in general you should use EVT_CHAR for this
as for non alphanumeric keys or non-US keyboard layouts the
translation is keyboard-layout dependent and can only be done properly
by the system itself.
Another kind of translation is done when the control key is pressed:
for example, for CTRL-A key press the key down event still carries the
same key code 'A' as usual but the char event will have key code of 1,
the ASCII value of this key combination.
You may discover how the other keys on your system behave
interactively by running the KeyEvents sample in the wxPython demo and
pressing some keys while the blue box at the top has the keyboard
focus.
**Note**: If a key down event is caught and the event handler does not
call event.Skip() then the coresponding char event will not
happen. This is by design and enables the programs that handle both
types of events to be a bit simpler.
**Note for Windows programmers**: The key and char events in wxWidgets
are similar to but slightly different from Windows WM_KEYDOWN and
WM_CHAR events. In particular, Alt-x combination will generate a char
event in wxWidgets (unless it is used as an accelerator).
**Tip**: be sure to call event.Skip() for events that you don't
process in key event function, otherwise menu shortcuts may cease to
work under Windows.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType eventType=wxEVT_NULL) -> KeyEvent
Construct a new `wx.KeyEvent`. Valid event types are:
*
"""
newobj = _core_.new_KeyEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def ControlDown(*args, **kwargs):
"""
ControlDown(self) -> bool
Returns ``True`` if the Control key was down at the time of the event.
"""
return _core_.KeyEvent_ControlDown(*args, **kwargs)
def MetaDown(*args, **kwargs):
"""
MetaDown(self) -> bool
Returns ``True`` if the Meta key was down at the time of the event.
"""
return _core_.KeyEvent_MetaDown(*args, **kwargs)
def AltDown(*args, **kwargs):
"""
AltDown(self) -> bool
Returns ``True`` if the Alt key was down at the time of the event.
"""
return _core_.KeyEvent_AltDown(*args, **kwargs)
def ShiftDown(*args, **kwargs):
"""
ShiftDown(self) -> bool
Returns ``True`` if the Shift key was down at the time of the event.
"""
return _core_.KeyEvent_ShiftDown(*args, **kwargs)
def CmdDown(*args, **kwargs):
"""
CmdDown(self) -> bool
"Cmd" is a pseudo key which is the same as Control for PC and Unix
platforms but the special "Apple" (a.k.a as "Command") key on
Macs. It makes often sense to use it instead of, say, `ControlDown`
because Cmd key is used for the same thing under Mac as Ctrl
elsewhere. The Ctrl still exists, it's just not used for this
purpose. So for non-Mac platforms this is the same as `ControlDown`
and Macs this is the same as `MetaDown`.
"""
return _core_.KeyEvent_CmdDown(*args, **kwargs)
def HasModifiers(*args, **kwargs):
"""
HasModifiers(self) -> bool
Returns true if either CTRL or ALT keys was down at the time of the
key event. Note that this function does not take into account neither
SHIFT nor META key states (the reason for ignoring the latter is that
it is common for NUMLOCK key to be configured as META under X but the
key presses even while NUMLOCK is on should be still processed
normally).
"""
return _core_.KeyEvent_HasModifiers(*args, **kwargs)
def GetKeyCode(*args, **kwargs):
"""
GetKeyCode(self) -> int
Returns the virtual key code. ASCII events return normal ASCII values,
while non-ASCII events return values such as WXK_LEFT for the left
cursor key. See `wx.KeyEvent` for a full list of the virtual key
codes.
Note that in Unicode build, the returned value is meaningful only if
the user entered a character that can be represented in current
locale's default charset. You can obtain the corresponding Unicode
character using `GetUnicodeKey`.
"""
return _core_.KeyEvent_GetKeyCode(*args, **kwargs)
KeyCode = GetKeyCode
def GetUnicodeKey(*args, **kwargs):
"""
GetUnicodeKey(self) -> int
Returns the Unicode character corresponding to this key event. This
function is only meaningfule in a Unicode build of wxPython.
"""
return _core_.KeyEvent_GetUnicodeKey(*args, **kwargs)
GetUniChar = GetUnicodeKey
def GetRawKeyCode(*args, **kwargs):
"""
GetRawKeyCode(self) -> unsigned int
Returns the raw key code for this event. This is a platform-dependent
scan code which should only be used in advanced
applications. Currently the raw key codes are not supported by all
ports.
"""
return _core_.KeyEvent_GetRawKeyCode(*args, **kwargs)
def GetRawKeyFlags(*args, **kwargs):
"""
GetRawKeyFlags(self) -> unsigned int
Returns the low level key flags for this event. The flags are
platform-dependent and should only be used in advanced applications.
Currently the raw key flags are not supported by all ports.
"""
return _core_.KeyEvent_GetRawKeyFlags(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Find the position of the event, if applicable.
"""
return _core_.KeyEvent_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
"""
GetPositionTuple() -> (x,y)
Find the position of the event, if applicable.
"""
return _core_.KeyEvent_GetPositionTuple(*args, **kwargs)
def GetX(*args, **kwargs):
"""
GetX(self) -> int
Returns the X position (in client coordinates) of the event, if
applicable.
"""
return _core_.KeyEvent_GetX(*args, **kwargs)
def GetY(*args, **kwargs):
"""
GetY(self) -> int
Returns the Y position (in client coordinates) of the event, if
applicable.
"""
return _core_.KeyEvent_GetY(*args, **kwargs)
m_x = property(_core_.KeyEvent_m_x_get, _core_.KeyEvent_m_x_set)
m_y = property(_core_.KeyEvent_m_y_get, _core_.KeyEvent_m_y_set)
m_keyCode = property(_core_.KeyEvent_m_keyCode_get, _core_.KeyEvent_m_keyCode_set)
m_controlDown = property(_core_.KeyEvent_m_controlDown_get, _core_.KeyEvent_m_controlDown_set)
m_shiftDown = property(_core_.KeyEvent_m_shiftDown_get, _core_.KeyEvent_m_shiftDown_set)
m_altDown = property(_core_.KeyEvent_m_altDown_get, _core_.KeyEvent_m_altDown_set)
m_metaDown = property(_core_.KeyEvent_m_metaDown_get, _core_.KeyEvent_m_metaDown_set)
m_scanCode = property(_core_.KeyEvent_m_scanCode_get, _core_.KeyEvent_m_scanCode_set)
m_rawCode = property(_core_.KeyEvent_m_rawCode_get, _core_.KeyEvent_m_rawCode_set)
m_rawFlags = property(_core_.KeyEvent_m_rawFlags_get, _core_.KeyEvent_m_rawFlags_set)
class KeyEventPtr(KeyEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = KeyEvent
_core_.KeyEvent_swigregister(KeyEventPtr)
#---------------------------------------------------------------------------
class SizeEvent(Event):
"""
A size event holds information about size change events. The EVT_SIZE
handler function will be called when the window it is bound to has
been resized.
Note that the size passed is of the whole window: call
`wx.Window.GetClientSize` for the area which may be used by the
application.
When a window is resized, usually only a small part of the window is
damaged and and that area is all that is in the update region for the
next paint event. However, if your drawing depends on the size of the
window, you may need to clear the DC explicitly and repaint the whole
window. In which case, you may need to call `wx.Window.Refresh` to
invalidate the entire window.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Size sz=DefaultSize, int winid=0) -> SizeEvent
Construct a new ``wx.SizeEvent``.
"""
newobj = _core_.new_SizeEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetSize(*args, **kwargs):
"""
GetSize(self) -> Size
Returns the entire size of the window generating the size change
event.
"""
return _core_.SizeEvent_GetSize(*args, **kwargs)
def GetRect(*args, **kwargs):
"""GetRect(self) -> Rect"""
return _core_.SizeEvent_GetRect(*args, **kwargs)
def SetRect(*args, **kwargs):
"""SetRect(self, Rect rect)"""
return _core_.SizeEvent_SetRect(*args, **kwargs)
def SetSize(*args, **kwargs):
"""SetSize(self, Size size)"""
return _core_.SizeEvent_SetSize(*args, **kwargs)
m_size = property(_core_.SizeEvent_m_size_get, _core_.SizeEvent_m_size_set)
m_rect = property(_core_.SizeEvent_m_rect_get, _core_.SizeEvent_m_rect_set)
class SizeEventPtr(SizeEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SizeEvent
_core_.SizeEvent_swigregister(SizeEventPtr)
#---------------------------------------------------------------------------
class MoveEvent(Event):
"""
This event object is sent for EVT_MOVE event bindings when a window is
moved to a new position.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMoveEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Point pos=DefaultPosition, int winid=0) -> MoveEvent
Constructor.
"""
newobj = _core_.new_MoveEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the position of the window generating the move change event.
"""
return _core_.MoveEvent_GetPosition(*args, **kwargs)
def GetRect(*args, **kwargs):
"""GetRect(self) -> Rect"""
return _core_.MoveEvent_GetRect(*args, **kwargs)
def SetRect(*args, **kwargs):
"""SetRect(self, Rect rect)"""
return _core_.MoveEvent_SetRect(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""SetPosition(self, Point pos)"""
return _core_.MoveEvent_SetPosition(*args, **kwargs)
m_pos = property(GetPosition, SetPosition)
m_rect = property(GetRect, SetRect)
class MoveEventPtr(MoveEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MoveEvent
_core_.MoveEvent_swigregister(MoveEventPtr)
#---------------------------------------------------------------------------
class PaintEvent(Event):
"""
A paint event is sent when a window's contents needs to be repainted.
Note that in an EVT_PAINT handler the application must *always* create
a `wx.PaintDC` object, even if you do not use it. Otherwise MS
Windows assumes that the window has not been painted yet and will send
the event again, causing endless refreshes.
You can optimize painting by retrieving the rectangles that have been
damaged using `wx.Window.GetUpdateRegion` and/or `wx.RegionIterator`,
and only repainting these rectangles. The rectangles are in terms of
the client area, and are unscrolled, so you will need to do some
calculations using the current view position to obtain logical,
scrolled units.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, int Id=0) -> PaintEvent"""
newobj = _core_.new_PaintEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class PaintEventPtr(PaintEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PaintEvent
_core_.PaintEvent_swigregister(PaintEventPtr)
class NcPaintEvent(Event):
"""Proxy of C++ NcPaintEvent class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxNcPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, int winid=0) -> NcPaintEvent"""
newobj = _core_.new_NcPaintEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class NcPaintEventPtr(NcPaintEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = NcPaintEvent
_core_.NcPaintEvent_swigregister(NcPaintEventPtr)
#---------------------------------------------------------------------------
class EraseEvent(Event):
"""
An erase event is sent whenever the background of a window needs to be
repainted. To intercept this event use the EVT_ERASE_BACKGROUND event
binder. On some platforms, such as GTK+, this event is simulated
(simply generated just before the paint event) and may cause flicker.
To paint a custom background use the `GetDC` method and use the returned
device context if it is not ``None``, otherwise create a temporary
`wx.ClientDC` and draw on that.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxEraseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int Id=0, DC dc=None) -> EraseEvent
Constructor
"""
newobj = _core_.new_EraseEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetDC(*args, **kwargs):
"""
GetDC(self) -> DC
Returns the device context the event handler should draw upon. If
``None`` is returned then create a temporary `wx.ClientDC` and use
that instead.
"""
return _core_.EraseEvent_GetDC(*args, **kwargs)
class EraseEventPtr(EraseEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = EraseEvent
_core_.EraseEvent_swigregister(EraseEventPtr)
#---------------------------------------------------------------------------
class FocusEvent(Event):
"""
A focus event is sent when a window's focus changes. The window losing
focus receives an EVT_KILL_FOCUS event while the window gaining it
gets an EVT_SET_FOCUS event.
Notice that the set focus event happens both when the user gives focus
to the window (whether using the mouse or keyboard) and when it is
done from the program itself using `wx.Window.SetFocus`.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> FocusEvent
Constructor
"""
newobj = _core_.new_FocusEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetWindow(*args, **kwargs):
"""
GetWindow(self) -> Window
Returns the other window associated with this event, that is the
window which had the focus before for the EVT_SET_FOCUS event and the
window which is going to receive focus for the wxEVT_KILL_FOCUS event.
Warning: the window returned may be None!
"""
return _core_.FocusEvent_GetWindow(*args, **kwargs)
def SetWindow(*args, **kwargs):
"""SetWindow(self, Window win)"""
return _core_.FocusEvent_SetWindow(*args, **kwargs)
class FocusEventPtr(FocusEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FocusEvent
_core_.FocusEvent_swigregister(FocusEventPtr)
#---------------------------------------------------------------------------
class ChildFocusEvent(CommandEvent):
"""
wx.ChildFocusEvent notifies the parent that a child has received the
focus. Unlike `wx.FocusEvent` it is propagated up the window
heirarchy.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxChildFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Window win=None) -> ChildFocusEvent
Constructor
"""
newobj = _core_.new_ChildFocusEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetWindow(*args, **kwargs):
"""
GetWindow(self) -> Window
The window which has just received the focus.
"""
return _core_.ChildFocusEvent_GetWindow(*args, **kwargs)
class ChildFocusEventPtr(ChildFocusEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ChildFocusEvent
_core_.ChildFocusEvent_swigregister(ChildFocusEventPtr)
#---------------------------------------------------------------------------
class ActivateEvent(Event):
"""
An activate event is sent when a top-level window or the entire
application is being activated or deactivated.
A top-level window (a dialog or frame) receives an activate event when
is being activated or deactivated. This is indicated visually by the
title bar changing colour, and a subwindow gaining the keyboard focus.
An application is activated or deactivated when one of its frames
becomes activated, or a frame becomes inactivate resulting in all
application frames being inactive.
Please note that usually you should call event.Skip() in your handlers
for these events so the default handlers will still be called, as not
doing so can result in strange effects.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxActivateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType type=wxEVT_NULL, bool active=True, int Id=0) -> ActivateEvent
Constructor
"""
newobj = _core_.new_ActivateEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetActive(*args, **kwargs):
"""
GetActive(self) -> bool
Returns true if the application or window is being activated, false
otherwise.
"""
return _core_.ActivateEvent_GetActive(*args, **kwargs)
class ActivateEventPtr(ActivateEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ActivateEvent
_core_.ActivateEvent_swigregister(ActivateEventPtr)
#---------------------------------------------------------------------------
class InitDialogEvent(Event):
"""
A wx.InitDialogEvent is sent as a dialog is being initialised, or for
any window when `wx.Window.InitDialog` is called. Handlers for this
event can transfer data to the window, or anything else that should be
done before the user begins editing the form. The default handler
calls `wx.Window.TransferDataToWindow`.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxInitDialogEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int Id=0) -> InitDialogEvent
Constructor
"""
newobj = _core_.new_InitDialogEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class InitDialogEventPtr(InitDialogEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = InitDialogEvent
_core_.InitDialogEvent_swigregister(InitDialogEventPtr)
#---------------------------------------------------------------------------
class MenuEvent(Event):
"""
This class is used for a variety of menu-related events. Note that
these do not include menu command events, which are handled by sending
`wx.CommandEvent` objects.
The default handler for wx.EVT_MENU_HIGHLIGHT displays menu item help
text in the first field of the status bar.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType type=wxEVT_NULL, int winid=0, Menu menu=None) -> MenuEvent
Constructor
"""
newobj = _core_.new_MenuEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetMenuId(*args, **kwargs):
"""
GetMenuId(self) -> int
Returns the menu identifier associated with the event. This method
should be only used with the HIGHLIGHT events.
"""
return _core_.MenuEvent_GetMenuId(*args, **kwargs)
def IsPopup(*args, **kwargs):
"""
IsPopup(self) -> bool
Returns ``True`` if the menu which is being opened or closed is a
popup menu, ``False`` if it is a normal one. This method should only
be used with the OPEN and CLOSE events.
"""
return _core_.MenuEvent_IsPopup(*args, **kwargs)
def GetMenu(*args, **kwargs):
"""
GetMenu(self) -> Menu
Returns the menu which is being opened or closed. This method should
only be used with the OPEN and CLOSE events.
"""
return _core_.MenuEvent_GetMenu(*args, **kwargs)
class MenuEventPtr(MenuEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MenuEvent
_core_.MenuEvent_swigregister(MenuEventPtr)
#---------------------------------------------------------------------------
class CloseEvent(Event):
"""
This event class contains information about window and session close
events.
The handler function for EVT_CLOSE is called when the user has tried
to close a a frame or dialog box using the window manager controls or
the system menu. It can also be invoked by the application itself
programmatically, for example by calling the `wx.Window.Close`
function.
You should check whether the application is forcing the deletion of
the window using `CanVeto`. If it returns ``False``, you must destroy
the window using `wx.Window.Destroy`. If the return value is ``True``,
it is up to you whether you respond by destroying the window or not.
For example you may wish to display a message dialog prompting to save
files or to cancel the close.
If you don't destroy the window, you should call `Veto` to let the
calling code know that you did not destroy the window. This allows the
`wx.Window.Close` function to return ``True`` or ``False`` depending
on whether the close instruction was honored or not.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCloseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> CloseEvent
Constructor.
"""
newobj = _core_.new_CloseEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetLoggingOff(*args, **kwargs):
"""
SetLoggingOff(self, bool logOff)
Sets the 'logging off' flag.
"""
return _core_.CloseEvent_SetLoggingOff(*args, **kwargs)
def GetLoggingOff(*args, **kwargs):
"""
GetLoggingOff(self) -> bool
Returns ``True`` if the user is logging off or ``False`` if the
system is shutting down. This method can only be called for end
session and query end session events, it doesn't make sense for close
window event.
"""
return _core_.CloseEvent_GetLoggingOff(*args, **kwargs)
def Veto(*args, **kwargs):
"""
Veto(self, bool veto=True)
Call this from your event handler to veto a system shutdown or to
signal to the calling application that a window close did not happen.
You can only veto a shutdown or close if `CanVeto` returns true.
"""
return _core_.CloseEvent_Veto(*args, **kwargs)
def GetVeto(*args, **kwargs):
"""GetVeto(self) -> bool"""
return _core_.CloseEvent_GetVeto(*args, **kwargs)
def SetCanVeto(*args, **kwargs):
"""
SetCanVeto(self, bool canVeto)
Sets the 'can veto' flag.
"""
return _core_.CloseEvent_SetCanVeto(*args, **kwargs)
def CanVeto(*args, **kwargs):
"""
CanVeto(self) -> bool
Returns true if you can veto a system shutdown or a window close
event. Vetoing a window close event is not possible if the calling
code wishes to force the application to exit, and so this function
must be called to check this.
"""
return _core_.CloseEvent_CanVeto(*args, **kwargs)
class CloseEventPtr(CloseEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CloseEvent
_core_.CloseEvent_swigregister(CloseEventPtr)
#---------------------------------------------------------------------------
class ShowEvent(Event):
"""An EVT_SHOW event is sent when a window is shown or hidden."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxShowEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int winid=0, bool show=False) -> ShowEvent
An EVT_SHOW event is sent when a window is shown or hidden.
"""
newobj = _core_.new_ShowEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetShow(*args, **kwargs):
"""SetShow(self, bool show)"""
return _core_.ShowEvent_SetShow(*args, **kwargs)
def GetShow(*args, **kwargs):
"""GetShow(self) -> bool"""
return _core_.ShowEvent_GetShow(*args, **kwargs)
class ShowEventPtr(ShowEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ShowEvent
_core_.ShowEvent_swigregister(ShowEventPtr)
#---------------------------------------------------------------------------
class IconizeEvent(Event):
"""
An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
restored.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxIconizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int id=0, bool iconized=True) -> IconizeEvent
An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
restored.
"""
newobj = _core_.new_IconizeEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Iconized(*args, **kwargs):
"""
Iconized(self) -> bool
Returns ``True`` if the frame has been iconized, ``False`` if it has
been restored.
"""
return _core_.IconizeEvent_Iconized(*args, **kwargs)
class IconizeEventPtr(IconizeEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = IconizeEvent
_core_.IconizeEvent_swigregister(IconizeEventPtr)
#---------------------------------------------------------------------------
class MaximizeEvent(Event):
"""An EVT_MAXIMIZE event is sent when a frame is maximized or restored."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMaximizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int id=0) -> MaximizeEvent
An EVT_MAXIMIZE event is sent when a frame is maximized or restored.
"""
newobj = _core_.new_MaximizeEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class MaximizeEventPtr(MaximizeEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MaximizeEvent
_core_.MaximizeEvent_swigregister(MaximizeEventPtr)
#---------------------------------------------------------------------------
class DropFilesEvent(Event):
"""
This class is used for drop files events, that is, when files have
been dropped onto the window. This functionality is only available
under Windows. The window must have previously been enabled for
dropping by calling `wx.Window.DragAcceptFiles`.
Important note: this is a separate implementation to the more general
drag and drop implementation using `wx.FileDropTarget`, and etc. This
implementation uses the older, Windows message-based approach of
dropping files.
Use wx.EVT_DROP_FILES to bind an event handler to receive file drop
events.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxDropFilesEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the position at which the files were dropped.
"""
return _core_.DropFilesEvent_GetPosition(*args, **kwargs)
def GetNumberOfFiles(*args, **kwargs):
"""
GetNumberOfFiles(self) -> int
Returns the number of files dropped.
"""
return _core_.DropFilesEvent_GetNumberOfFiles(*args, **kwargs)
def GetFiles(*args, **kwargs):
"""
GetFiles(self) -> PyObject
Returns a list of the filenames that were dropped.
"""
return _core_.DropFilesEvent_GetFiles(*args, **kwargs)
class DropFilesEventPtr(DropFilesEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DropFilesEvent
_core_.DropFilesEvent_swigregister(DropFilesEventPtr)
#---------------------------------------------------------------------------
UPDATE_UI_PROCESS_ALL = _core_.UPDATE_UI_PROCESS_ALL
UPDATE_UI_PROCESS_SPECIFIED = _core_.UPDATE_UI_PROCESS_SPECIFIED
class UpdateUIEvent(CommandEvent):
"""
This class is used for EVT_UPDATE_UI pseudo-events which are sent by
wxWidgets to give an application the chance to update various user
interface elements.
Without update UI events, an application has to work hard to
check/uncheck, enable/disable, and set the text for elements such as
menu items and toolbar buttons. The code for doing this has to be
mixed up with the code that is invoked when an action is invoked for a
menu item or button.
With update UI events, you define an event handler to look at the
state of the application and change UI elements accordingly. wxWidgets
will call your handler functions in idle time, so you don't have to
worry where to call this code. In addition to being a clearer and more
declarative method, it also means you don't have to worry whether
you're updating a toolbar or menubar identifier. The same handler can
update a menu item and toolbar button, if the ID values are the same.
Instead of directly manipulating the menu or button, you call
functions in the event object, such as `Check`. wxWidgets will
determine whether such a call has been made, and which UI element to
update.
These events will work for popup menus as well as menubars. Just
before a menu is popped up, `wx.Menu.UpdateUI` is called to process
any UI events for the window that owns the menu.
If you find that the overhead of UI update processing is affecting
your application, you can do one or both of the following:
1. Call `wx.UpdateUIEvent.SetMode` with a value of
wx.UPDATE_UI_PROCESS_SPECIFIED, and set the extra style
wx.WS_EX_PROCESS_UPDATE_EVENTS for every window that should
receive update events. No other windows will receive update
events.
2. Call `wx.UpdateUIEvent.SetUpdateInterval` with a millisecond
value to set the delay between updates. You may need to call
`wx.Window.UpdateWindowUI` at critical points, for example when
a dialog is about to be shown, in case the user sees a slight
delay before windows are updated.
Note that although events are sent in idle time, defining a EVT_IDLE
handler for a window does not affect this because the events are sent
from an internal idle handler.
wxWidgets tries to optimize update events on some platforms. On
Windows and GTK+, events for menubar items are only sent when the menu
is about to be shown, and not in idle time.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxUpdateUIEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int commandId=0) -> UpdateUIEvent
Constructor
"""
newobj = _core_.new_UpdateUIEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetChecked(*args, **kwargs):
"""
GetChecked(self) -> bool
Returns ``True`` if the UI element should be checked.
"""
return _core_.UpdateUIEvent_GetChecked(*args, **kwargs)
def GetEnabled(*args, **kwargs):
"""
GetEnabled(self) -> bool
Returns ``True`` if the UI element should be enabled.
"""
return _core_.UpdateUIEvent_GetEnabled(*args, **kwargs)
def GetText(*args, **kwargs):
"""
GetText(self) -> String
Returns the text that should be set for the UI element.
"""
return _core_.UpdateUIEvent_GetText(*args, **kwargs)
def GetSetText(*args, **kwargs):
"""
GetSetText(self) -> bool
Returns ``True`` if the application has called `SetText`. For
wxWidgets internal use only.
"""
return _core_.UpdateUIEvent_GetSetText(*args, **kwargs)
def GetSetChecked(*args, **kwargs):
"""
GetSetChecked(self) -> bool
Returns ``True`` if the application has called `Check`. For wxWidgets
internal use only.
"""
return _core_.UpdateUIEvent_GetSetChecked(*args, **kwargs)
def GetSetEnabled(*args, **kwargs):
"""
GetSetEnabled(self) -> bool
Returns ``True`` if the application has called `Enable`. For wxWidgets
internal use only.
"""
return _core_.UpdateUIEvent_GetSetEnabled(*args, **kwargs)
def Check(*args, **kwargs):
"""
Check(self, bool check)
Check or uncheck the UI element.
"""
return _core_.UpdateUIEvent_Check(*args, **kwargs)
def Enable(*args, **kwargs):
"""
Enable(self, bool enable)
Enable or disable the UI element.
"""
return _core_.UpdateUIEvent_Enable(*args, **kwargs)
def SetText(*args, **kwargs):
"""
SetText(self, String text)
Sets the text for this UI element.
"""
return _core_.UpdateUIEvent_SetText(*args, **kwargs)
def SetUpdateInterval(*args, **kwargs):
"""
SetUpdateInterval(long updateInterval)
Sets the interval between updates in milliseconds. Set to -1 to
disable updates, or to 0 to update as frequently as possible. The
default is 0.
Use this to reduce the overhead of UI update events if your
application has a lot of windows. If you set the value to -1 or
greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
at appropriate points in your application, such as when a dialog is
about to be shown.
"""
return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
SetUpdateInterval = staticmethod(SetUpdateInterval)
def GetUpdateInterval(*args, **kwargs):
"""
GetUpdateInterval() -> long
Returns the current interval between updates in milliseconds. -1
disables updates, 0 updates as frequently as possible.
"""
return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
GetUpdateInterval = staticmethod(GetUpdateInterval)
def CanUpdate(*args, **kwargs):
"""
CanUpdate(Window win) -> bool
Returns ``True`` if it is appropriate to update (send UI update events
to) this window.
This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
events were last sent in idle time, and the update interval, to
determine whether events should be sent to this window now. By default
this will always return true because the update mode is initially
wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
events will be sent as often as possible. You can reduce the frequency
that events are sent by changing the mode and/or setting an update
interval.
"""
return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
CanUpdate = staticmethod(CanUpdate)
def ResetUpdateTime(*args, **kwargs):
"""
ResetUpdateTime()
Used internally to reset the last-updated time to the current time. It
is assumed that update events are normally sent in idle time, so this
is called at the end of idle processing.
"""
return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
ResetUpdateTime = staticmethod(ResetUpdateTime)
def SetMode(*args, **kwargs):
"""
SetMode(int mode)
Specify how wxWidgets will send update events: to all windows, or only
to those which specify that they will process the events.
The mode may be one of the following values:
============================= ==========================================
wxUPDATE_UI_PROCESS_ALL Send UI update events to all windows. This
is the default setting.
wxUPDATE_UI_PROCESS_SPECIFIED Send UI update events only to windows that
have the wx.WS_EX_PROCESS_UI_UPDATES extra
style set.
============================= ==========================================
"""
return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
"""
GetMode() -> int
Returns a value specifying how wxWidgets will send update events: to
all windows, or only to those which specify that they will process the
events.
"""
return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
class UpdateUIEventPtr(UpdateUIEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = UpdateUIEvent
_core_.UpdateUIEvent_swigregister(UpdateUIEventPtr)
def UpdateUIEvent_SetUpdateInterval(*args, **kwargs):
"""
UpdateUIEvent_SetUpdateInterval(long updateInterval)
Sets the interval between updates in milliseconds. Set to -1 to
disable updates, or to 0 to update as frequently as possible. The
default is 0.
Use this to reduce the overhead of UI update events if your
application has a lot of windows. If you set the value to -1 or
greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
at appropriate points in your application, such as when a dialog is
about to be shown.
"""
return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
def UpdateUIEvent_GetUpdateInterval(*args, **kwargs):
"""
UpdateUIEvent_GetUpdateInterval() -> long
Returns the current interval between updates in milliseconds. -1
disables updates, 0 updates as frequently as possible.
"""
return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
def UpdateUIEvent_CanUpdate(*args, **kwargs):
"""
UpdateUIEvent_CanUpdate(Window win) -> bool
Returns ``True`` if it is appropriate to update (send UI update events
to) this window.
This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
events were last sent in idle time, and the update interval, to
determine whether events should be sent to this window now. By default
this will always return true because the update mode is initially
wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
events will be sent as often as possible. You can reduce the frequency
that events are sent by changing the mode and/or setting an update
interval.
"""
return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
def UpdateUIEvent_ResetUpdateTime(*args, **kwargs):
"""
UpdateUIEvent_ResetUpdateTime()
Used internally to reset the last-updated time to the current time. It
is assumed that update events are normally sent in idle time, so this
is called at the end of idle processing.
"""
return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
def UpdateUIEvent_SetMode(*args, **kwargs):
"""
UpdateUIEvent_SetMode(int mode)
Specify how wxWidgets will send update events: to all windows, or only
to those which specify that they will process the events.
The mode may be one of the following values:
============================= ==========================================
wxUPDATE_UI_PROCESS_ALL Send UI update events to all windows. This
is the default setting.
wxUPDATE_UI_PROCESS_SPECIFIED Send UI update events only to windows that
have the wx.WS_EX_PROCESS_UI_UPDATES extra
style set.
============================= ==========================================
"""
return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
def UpdateUIEvent_GetMode(*args, **kwargs):
"""
UpdateUIEvent_GetMode() -> int
Returns a value specifying how wxWidgets will send update events: to
all windows, or only to those which specify that they will process the
events.
"""
return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
#---------------------------------------------------------------------------
class SysColourChangedEvent(Event):
"""
This class is used for EVT_SYS_COLOUR_CHANGED, which are generated
when the user changes the colour settings using the control
panel. This is only applicable under Windows.
The default event handler for this event propagates the event to child
windows, since Windows only sends the events to top-level windows. If
intercepting this event for a top-level window, remember to call
`Skip` so the the base class handler will still be executed, or to
pass the event on to the window's children explicitly.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSysColourChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> SysColourChangedEvent
Constructor
"""
newobj = _core_.new_SysColourChangedEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class SysColourChangedEventPtr(SysColourChangedEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SysColourChangedEvent
_core_.SysColourChangedEvent_swigregister(SysColourChangedEventPtr)
#---------------------------------------------------------------------------
class MouseCaptureChangedEvent(Event):
"""
An mouse capture changed event (EVT_MOUSE_CAPTURE_CHANGED) is sent to
a window that loses its mouse capture. This is called even if
`wx.Window.ReleaseMouse` was called by the application code. Handling
this event allows an application to cater for unexpected capture
releases which might otherwise confuse mouse handling code.
This event is implemented under Windows only.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMouseCaptureChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int winid=0, Window gainedCapture=None) -> MouseCaptureChangedEvent
Constructor
"""
newobj = _core_.new_MouseCaptureChangedEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetCapturedWindow(*args, **kwargs):
"""
GetCapturedWindow(self) -> Window
Returns the window that gained the capture, or ``None`` if it was a
non-wxWidgets window.
"""
return _core_.MouseCaptureChangedEvent_GetCapturedWindow(*args, **kwargs)
class MouseCaptureChangedEventPtr(MouseCaptureChangedEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MouseCaptureChangedEvent
_core_.MouseCaptureChangedEvent_swigregister(MouseCaptureChangedEventPtr)
#---------------------------------------------------------------------------
class DisplayChangedEvent(Event):
"""
An EVT_DISPLAY_CHANGED event is sent to all windows when the display
resolution has changed.
This event is implemented under Windows only.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxDisplayChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> DisplayChangedEvent"""
newobj = _core_.new_DisplayChangedEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
class DisplayChangedEventPtr(DisplayChangedEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DisplayChangedEvent
_core_.DisplayChangedEvent_swigregister(DisplayChangedEventPtr)
#---------------------------------------------------------------------------
class PaletteChangedEvent(Event):
"""
An EVT_PALETTE_CHANGED event is sent when the system palette has
changed, thereby giving each window a chance to redo their own to
match.
This event is implemented under Windows only.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPaletteChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int id=0) -> PaletteChangedEvent
An EVT_PALETTE_CHANGED event is sent when the system palette has
changed, thereby giving each window a chance to redo their own to
match.
This event is implemented under Windows only.
"""
newobj = _core_.new_PaletteChangedEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetChangedWindow(*args, **kwargs):
"""SetChangedWindow(self, Window win)"""
return _core_.PaletteChangedEvent_SetChangedWindow(*args, **kwargs)
def GetChangedWindow(*args, **kwargs):
"""GetChangedWindow(self) -> Window"""
return _core_.PaletteChangedEvent_GetChangedWindow(*args, **kwargs)
class PaletteChangedEventPtr(PaletteChangedEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PaletteChangedEvent
_core_.PaletteChangedEvent_swigregister(PaletteChangedEventPtr)
#---------------------------------------------------------------------------
class QueryNewPaletteEvent(Event):
"""
An EVT_QUERY_NEW_PALETE event indicates the window is getting keyboard
focus and should re-do its palette.
This event is implemented under Windows only.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxQueryNewPaletteEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int winid=0) -> QueryNewPaletteEvent
Constructor.
"""
newobj = _core_.new_QueryNewPaletteEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetPaletteRealized(*args, **kwargs):
"""
SetPaletteRealized(self, bool realized)
App should set this if it changes the palette.
"""
return _core_.QueryNewPaletteEvent_SetPaletteRealized(*args, **kwargs)
def GetPaletteRealized(*args, **kwargs):
"""GetPaletteRealized(self) -> bool"""
return _core_.QueryNewPaletteEvent_GetPaletteRealized(*args, **kwargs)
class QueryNewPaletteEventPtr(QueryNewPaletteEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = QueryNewPaletteEvent
_core_.QueryNewPaletteEvent_swigregister(QueryNewPaletteEventPtr)
#---------------------------------------------------------------------------
class NavigationKeyEvent(Event):
"""
EVT_NAVIGATION_KEY events are used to control moving the focus between
widgets, otherwise known as tab-traversal. You woudl normally not
catch navigation events in applications as there are already
appropriate handlers in `wx.Dialog` and `wx.Panel`, but you may find
it useful to send navigation events in certain situations to change
the focus in certain ways, although it's probably easier to just call
`wx.Window.Navigate`.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxNavigationKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> NavigationKeyEvent"""
newobj = _core_.new_NavigationKeyEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetDirection(*args, **kwargs):
"""
GetDirection(self) -> bool
Returns ``True`` if the direction is forward, ``False`` otherwise.
"""
return _core_.NavigationKeyEvent_GetDirection(*args, **kwargs)
def SetDirection(*args, **kwargs):
"""
SetDirection(self, bool forward)
Specify the direction that the navigation should take. Usually the
difference between using Tab and Shift-Tab.
"""
return _core_.NavigationKeyEvent_SetDirection(*args, **kwargs)
def IsWindowChange(*args, **kwargs):
"""
IsWindowChange(self) -> bool
Returns ``True`` if window change is allowed.
"""
return _core_.NavigationKeyEvent_IsWindowChange(*args, **kwargs)
def SetWindowChange(*args, **kwargs):
"""
SetWindowChange(self, bool ischange)
Specify if the navigation should be able to change parent windows.
For example, changing notebook pages, etc. This is usually implemented
by using Control-Tab.
"""
return _core_.NavigationKeyEvent_SetWindowChange(*args, **kwargs)
def IsFromTab(*args, **kwargs):
"""
IsFromTab(self) -> bool
Returns ``True`` if the navigation event is originated from the Tab
key.
"""
return _core_.NavigationKeyEvent_IsFromTab(*args, **kwargs)
def SetFromTab(*args, **kwargs):
"""
SetFromTab(self, bool bIs)
Set to true under MSW if the event was generated using the tab key.
This is required for proper navogation over radio buttons.
"""
return _core_.NavigationKeyEvent_SetFromTab(*args, **kwargs)
def SetFlags(*args, **kwargs):
"""
SetFlags(self, long flags)
Set the navigation flags to a combination of the following:
* wx.NavigationKeyEvent.IsBackward
* wx.NavigationKeyEvent.IsForward
* wx.NavigationKeyEvent.WinChange
* wx.NavigationKeyEvent.FromTab
"""
return _core_.NavigationKeyEvent_SetFlags(*args, **kwargs)
def GetCurrentFocus(*args, **kwargs):
"""
GetCurrentFocus(self) -> Window
Returns the child window which currenty has the focus. May be
``None``.
"""
return _core_.NavigationKeyEvent_GetCurrentFocus(*args, **kwargs)
def SetCurrentFocus(*args, **kwargs):
"""
SetCurrentFocus(self, Window win)
Set the window that has the focus.
"""
return _core_.NavigationKeyEvent_SetCurrentFocus(*args, **kwargs)
IsBackward = _core_.NavigationKeyEvent_IsBackward
IsForward = _core_.NavigationKeyEvent_IsForward
WinChange = _core_.NavigationKeyEvent_WinChange
FromTab = _core_.NavigationKeyEvent_FromTab
class NavigationKeyEventPtr(NavigationKeyEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = NavigationKeyEvent
_core_.NavigationKeyEvent_swigregister(NavigationKeyEventPtr)
#---------------------------------------------------------------------------
class WindowCreateEvent(CommandEvent):
"""
The EVT_WINDOW_CREATE event is sent as soon as the window object (the
underlying GUI object) exists.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindowCreateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Window win=None) -> WindowCreateEvent
The EVT_WINDOW_CREATE event is sent as soon as the window object (the
underlying GUI object) exists.
"""
newobj = _core_.new_WindowCreateEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetWindow(*args, **kwargs):
"""
GetWindow(self) -> Window
Returns the window that this event refers to.
"""
return _core_.WindowCreateEvent_GetWindow(*args, **kwargs)
class WindowCreateEventPtr(WindowCreateEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = WindowCreateEvent
_core_.WindowCreateEvent_swigregister(WindowCreateEventPtr)
class WindowDestroyEvent(CommandEvent):
"""
The EVT_WINDOW_DESTROY event is sent from the `wx.Window` destructor
when the GUI window is destroyed.
When a class derived from `wx.Window` is destroyed its destructor will
have already run by the time this event is sent. Therefore this event
will not usually be received at all by the window itself. Since it is
received after the destructor has run, an object should not try to
handle its own wx.WindowDestroyEvent, but it can be used to get
notification of the destruction of another window.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindowDestroyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Window win=None) -> WindowDestroyEvent
The EVT_WINDOW_DESTROY event is sent from the `wx.Window` destructor
when the GUI window is destroyed.
When a class derived from `wx.Window` is destroyed its destructor will
have already run by the time this event is sent. Therefore this event
will not usually be received at all by the window itself. Since it is
received after the destructor has run, an object should not try to
handle its own wx.WindowDestroyEvent, but it can be used to get
notification of the destruction of another window.
"""
newobj = _core_.new_WindowDestroyEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetWindow(*args, **kwargs):
"""
GetWindow(self) -> Window
Returns the window that this event refers to.
"""
return _core_.WindowDestroyEvent_GetWindow(*args, **kwargs)
class WindowDestroyEventPtr(WindowDestroyEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = WindowDestroyEvent
_core_.WindowDestroyEvent_swigregister(WindowDestroyEventPtr)
#---------------------------------------------------------------------------
class ContextMenuEvent(CommandEvent):
"""
This class is used for context menu events (EVT_CONTECT_MENU,) sent to
give the application a chance to show a context (popup) menu.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxContextMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, wxEventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> ContextMenuEvent
Constructor.
"""
newobj = _core_.new_ContextMenuEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the position (in screen coordinants) at which the menu should
be shown.
"""
return _core_.ContextMenuEvent_GetPosition(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""
SetPosition(self, Point pos)
Sets the position at which the menu should be shown.
"""
return _core_.ContextMenuEvent_SetPosition(*args, **kwargs)
class ContextMenuEventPtr(ContextMenuEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ContextMenuEvent
_core_.ContextMenuEvent_swigregister(ContextMenuEventPtr)
#---------------------------------------------------------------------------
IDLE_PROCESS_ALL = _core_.IDLE_PROCESS_ALL
IDLE_PROCESS_SPECIFIED = _core_.IDLE_PROCESS_SPECIFIED
class IdleEvent(Event):
"""
This class is used for EVT_IDLE events, which are generated and sent
when the application *becomes* idle. In other words, the when the
event queue becomes empty then idle events are sent to all windows (by
default) and as long as none of them call `RequestMore` then there are
no more idle events until after the system event queue has some normal
events and then becomes empty again.
By default, idle events are sent to all windows. If this is causing a
significant overhead in your application, you can call
`wx.IdleEvent.SetMode` with the value wx.IDLE_PROCESS_SPECIFIED, and
set the wx.WS_EX_PROCESS_IDLE extra window style for every window
which should receive idle events. Then idle events will only be sent
to those windows and not to any others.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxIdleEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> IdleEvent
Constructor
"""
newobj = _core_.new_IdleEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def RequestMore(*args, **kwargs):
"""
RequestMore(self, bool needMore=True)
Tells wxWidgets that more processing is required. This function can be
called by an EVT_IDLE handler for a window to indicate that the
application should forward the EVT_IDLE event once more to the
application windows. If no window calls this function during its
EVT_IDLE handler, then the application will remain in a passive event
loop until a new event is posted to the application by the windowing
system.
"""
return _core_.IdleEvent_RequestMore(*args, **kwargs)
def MoreRequested(*args, **kwargs):
"""
MoreRequested(self) -> bool
Returns ``True`` if the OnIdle function processing this event
requested more processing time.
"""
return _core_.IdleEvent_MoreRequested(*args, **kwargs)
def SetMode(*args, **kwargs):
"""
SetMode(int mode)
Static method for specifying how wxWidgets will send idle events: to
all windows, or only to those which specify that they will process the
events.
The mode can be one of the following values:
========================= ========================================
wx.IDLE_PROCESS_ALL Send idle events to all windows
wx.IDLE_PROCESS_SPECIFIED Send idle events only to windows that have
the wx.WS_EX_PROCESS_IDLE extra style
flag set.
========================= ========================================
"""
return _core_.IdleEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
"""
GetMode() -> int
Static method returning a value specifying how wxWidgets will send
idle events: to all windows, or only to those which specify that they
will process the events.
"""
return _core_.IdleEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
def CanSend(*args, **kwargs):
"""
CanSend(Window win) -> bool
Returns ``True`` if it is appropriate to send idle events to this
window.
This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
events should be sent to this window now. By default this will always
return ``True`` because the update mode is initially
wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.
"""
return _core_.IdleEvent_CanSend(*args, **kwargs)
CanSend = staticmethod(CanSend)
class IdleEventPtr(IdleEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = IdleEvent
_core_.IdleEvent_swigregister(IdleEventPtr)
def IdleEvent_SetMode(*args, **kwargs):
"""
IdleEvent_SetMode(int mode)
Static method for specifying how wxWidgets will send idle events: to
all windows, or only to those which specify that they will process the
events.
The mode can be one of the following values:
========================= ========================================
wx.IDLE_PROCESS_ALL Send idle events to all windows
wx.IDLE_PROCESS_SPECIFIED Send idle events only to windows that have
the wx.WS_EX_PROCESS_IDLE extra style
flag set.
========================= ========================================
"""
return _core_.IdleEvent_SetMode(*args, **kwargs)
def IdleEvent_GetMode(*args, **kwargs):
"""
IdleEvent_GetMode() -> int
Static method returning a value specifying how wxWidgets will send
idle events: to all windows, or only to those which specify that they
will process the events.
"""
return _core_.IdleEvent_GetMode(*args, **kwargs)
def IdleEvent_CanSend(*args, **kwargs):
"""
IdleEvent_CanSend(Window win) -> bool
Returns ``True`` if it is appropriate to send idle events to this
window.
This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
events should be sent to this window now. By default this will always
return ``True`` because the update mode is initially
wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.
"""
return _core_.IdleEvent_CanSend(*args, **kwargs)
#---------------------------------------------------------------------------
class PyEvent(Event):
"""
wx.PyEvent can be used as a base class for implementing custom event
types in Python. You should derived from this class instead of
`wx.Event` because this class is Python-aware and is able to transport
its Python bits safely through the wxWidgets event system and have
them still be there when the event handler is invoked.
:see: `wx.PyCommandEvent`
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, int winid=0, wxEventType eventType=wxEVT_NULL) -> PyEvent"""
newobj = _core_.new_PyEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._SetSelf(self)
def __del__(self, destroy=_core_.delete_PyEvent):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def _SetSelf(*args, **kwargs):
"""_SetSelf(self, PyObject self)"""
return _core_.PyEvent__SetSelf(*args, **kwargs)
def _GetSelf(*args, **kwargs):
"""_GetSelf(self) -> PyObject"""
return _core_.PyEvent__GetSelf(*args, **kwargs)
class PyEventPtr(PyEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyEvent
_core_.PyEvent_swigregister(PyEventPtr)
class PyCommandEvent(CommandEvent):
"""
wx.PyCommandEvent can be used as a base class for implementing custom
event types in Python, where the event shoudl travel up to parent
windows looking for a handler. You should derived from this class
instead of `wx.CommandEvent` because this class is Python-aware and is
able to transport its Python bits safely through the wxWidgets event
system and have them still be there when the event handler is invoked.
:see: `wx.PyEvent`
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, wxEventType eventType=wxEVT_NULL, int id=0) -> PyCommandEvent"""
newobj = _core_.new_PyCommandEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._SetSelf(self)
def __del__(self, destroy=_core_.delete_PyCommandEvent):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def _SetSelf(*args, **kwargs):
"""_SetSelf(self, PyObject self)"""
return _core_.PyCommandEvent__SetSelf(*args, **kwargs)
def _GetSelf(*args, **kwargs):
"""_GetSelf(self) -> PyObject"""
return _core_.PyCommandEvent__GetSelf(*args, **kwargs)
class PyCommandEventPtr(PyCommandEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyCommandEvent
_core_.PyCommandEvent_swigregister(PyCommandEventPtr)
class DateEvent(CommandEvent):
"""
This event class holds information about a date change event and is
used together with `wx.DatePickerCtrl`. It also serves as a base class
for `wx.calendar.CalendarEvent`. Bind these event types with
EVT_DATE_CHANGED.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxDateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, Window win, DateTime dt, wxEventType type) -> DateEvent"""
newobj = _core_.new_DateEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetDate(*args, **kwargs):
"""
GetDate(self) -> DateTime
Returns the date.
"""
return _core_.DateEvent_GetDate(*args, **kwargs)
def SetDate(*args, **kwargs):
"""
SetDate(self, DateTime date)
Sets the date carried by the event, normally only used by the library
internally.
"""
return _core_.DateEvent_SetDate(*args, **kwargs)
class DateEventPtr(DateEvent):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DateEvent
_core_.DateEvent_swigregister(DateEventPtr)
wxEVT_DATE_CHANGED = _core_.wxEVT_DATE_CHANGED
EVT_DATE_CHANGED = wx.PyEventBinder( wxEVT_DATE_CHANGED, 1 )
#---------------------------------------------------------------------------
PYAPP_ASSERT_SUPPRESS = _core_.PYAPP_ASSERT_SUPPRESS
PYAPP_ASSERT_EXCEPTION = _core_.PYAPP_ASSERT_EXCEPTION
PYAPP_ASSERT_DIALOG = _core_.PYAPP_ASSERT_DIALOG
PYAPP_ASSERT_LOG = _core_.PYAPP_ASSERT_LOG
PRINT_WINDOWS = _core_.PRINT_WINDOWS
PRINT_POSTSCRIPT = _core_.PRINT_POSTSCRIPT
class PyApp(EvtHandler):
"""
The ``wx.PyApp`` class is an *implementation detail*, please use the
`wx.App` class (or some other derived class) instead.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyApp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> PyApp
Create a new application object, starting the bootstrap process.
"""
newobj = _core_.new_PyApp(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PyApp, False)
self._setOORInfo(self, False)
def __del__(self, destroy=_core_.delete_PyApp):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
return _core_.PyApp__setCallbackInfo(*args, **kwargs)
def GetAppName(*args, **kwargs):
"""
GetAppName(self) -> String
Get the application name.
"""
return _core_.PyApp_GetAppName(*args, **kwargs)
def SetAppName(*args, **kwargs):
"""
SetAppName(self, String name)
Set the application name. This value may be used automatically by
`wx.Config` and such.
"""
return _core_.PyApp_SetAppName(*args, **kwargs)
def GetClassName(*args, **kwargs):
"""
GetClassName(self) -> String
Get the application's class name.
"""
return _core_.PyApp_GetClassName(*args, **kwargs)
def SetClassName(*args, **kwargs):
"""
SetClassName(self, String name)
Set the application's class name. This value may be used for
X-resources if applicable for the platform
"""
return _core_.PyApp_SetClassName(*args, **kwargs)
def GetVendorName(*args, **kwargs):
"""
GetVendorName(self) -> String
Get the application's vendor name.
"""
return _core_.PyApp_GetVendorName(*args, **kwargs)
def SetVendorName(*args, **kwargs):
"""
SetVendorName(self, String name)
Set the application's vendor name. This value may be used
automatically by `wx.Config` and such.
"""
return _core_.PyApp_SetVendorName(*args, **kwargs)
def GetTraits(*args, **kwargs):
"""
GetTraits(self) -> wxAppTraits
Return (and create if necessary) the app traits object to which we
delegate for everything which either should be configurable by the
user (then he can change the default behaviour simply by overriding
CreateTraits() and returning his own traits object) or which is
GUI/console dependent as then wx.AppTraits allows us to abstract the
differences behind the common facade.
:todo: Add support for overriding CreateAppTraits in wxPython.
"""
return _core_.PyApp_GetTraits(*args, **kwargs)
def ProcessPendingEvents(*args, **kwargs):
"""
ProcessPendingEvents(self)
Process all events in the Pending Events list -- it is necessary to
call this function to process posted events. This normally happens
during each event loop iteration.
"""
return _core_.PyApp_ProcessPendingEvents(*args, **kwargs)
def Yield(*args, **kwargs):
"""
Yield(self, bool onlyIfNeeded=False) -> bool
Process all currently pending events right now, instead of waiting
until return to the event loop. It is an error to call ``Yield``
recursively unless the value of ``onlyIfNeeded`` is True.
:warning: This function is dangerous as it can lead to unexpected
reentrancies (i.e. when called from an event handler it may
result in calling the same event handler again), use with
extreme care or, better, don't use at all!
:see: `wx.Yield`, `wx.YieldIfNeeded`, `wx.SafeYield`
"""
return _core_.PyApp_Yield(*args, **kwargs)
def WakeUpIdle(*args, **kwargs):
"""
WakeUpIdle(self)
Make sure that idle events are sent again.
:see: `wx.WakeUpIdle`
"""
return _core_.PyApp_WakeUpIdle(*args, **kwargs)
def IsMainLoopRunning(*args, **kwargs):
"""
IsMainLoopRunning() -> bool
Returns True if we're running the main loop, i.e. if the events can
currently be dispatched.
"""
return _core_.PyApp_IsMainLoopRunning(*args, **kwargs)
IsMainLoopRunning = staticmethod(IsMainLoopRunning)
def MainLoop(*args, **kwargs):
"""
MainLoop(self) -> int
Execute the main GUI loop, the function doesn't normally return until
all top level windows have been closed and destroyed.
"""
return _core_.PyApp_MainLoop(*args, **kwargs)
def Exit(*args, **kwargs):
"""
Exit(self)
Exit the main loop thus terminating the application.
:see: `wx.Exit`
"""
return _core_.PyApp_Exit(*args, **kwargs)
def ExitMainLoop(*args, **kwargs):
"""
ExitMainLoop(self)
Exit the main GUI loop during the next iteration of the main
loop, (i.e. it does not stop the program immediately!)
"""
return _core_.PyApp_ExitMainLoop(*args, **kwargs)
def Pending(*args, **kwargs):
"""
Pending(self) -> bool
Returns True if there are unprocessed events in the event queue.
"""
return _core_.PyApp_Pending(*args, **kwargs)
def Dispatch(*args, **kwargs):
"""
Dispatch(self) -> bool
Process the first event in the event queue (blocks until an event
appears if there are none currently)
"""
return _core_.PyApp_Dispatch(*args, **kwargs)
def ProcessIdle(*args, **kwargs):
"""
ProcessIdle(self) -> bool
Called from the MainLoop when the application becomes idle (there are
no pending events) and sends a `wx.IdleEvent` to all interested
parties. Returns True if more idle events are needed, False if not.
"""
return _core_.PyApp_ProcessIdle(*args, **kwargs)
def SendIdleEvents(*args, **kwargs):
"""
SendIdleEvents(self, Window win, IdleEvent event) -> bool
Send idle event to window and all subwindows. Returns True if more
idle time is requested.
"""
return _core_.PyApp_SendIdleEvents(*args, **kwargs)
def IsActive(*args, **kwargs):
"""
IsActive(self) -> bool
Return True if our app has focus.
"""
return _core_.PyApp_IsActive(*args, **kwargs)
def SetTopWindow(*args, **kwargs):
"""
SetTopWindow(self, Window win)
Set the *main* top level window
"""
return _core_.PyApp_SetTopWindow(*args, **kwargs)
def GetTopWindow(*args, **kwargs):
"""
GetTopWindow(self) -> Window
Return the *main* top level window (if it hadn't been set previously
with SetTopWindow(), will return just some top level window and, if
there not any, will return None)
"""
return _core_.PyApp_GetTopWindow(*args, **kwargs)
def SetExitOnFrameDelete(*args, **kwargs):
"""
SetExitOnFrameDelete(self, bool flag)
Control the exit behaviour: by default, the program will exit the main
loop (and so, usually, terminate) when the last top-level program
window is deleted. Beware that if you disable this behaviour (with
SetExitOnFrameDelete(False)), you'll have to call ExitMainLoop()
explicitly from somewhere.
"""
return _core_.PyApp_SetExitOnFrameDelete(*args, **kwargs)
def GetExitOnFrameDelete(*args, **kwargs):
"""
GetExitOnFrameDelete(self) -> bool
Get the current exit behaviour setting.
"""
return _core_.PyApp_GetExitOnFrameDelete(*args, **kwargs)
def SetUseBestVisual(*args, **kwargs):
"""
SetUseBestVisual(self, bool flag)
Set whether the app should try to use the best available visual on
systems where more than one is available, (Sun, SGI, XFree86 4, etc.)
"""
return _core_.PyApp_SetUseBestVisual(*args, **kwargs)
def GetUseBestVisual(*args, **kwargs):
"""
GetUseBestVisual(self) -> bool
Get current UseBestVisual setting.
"""
return _core_.PyApp_GetUseBestVisual(*args, **kwargs)
def SetPrintMode(*args, **kwargs):
"""SetPrintMode(self, int mode)"""
return _core_.PyApp_SetPrintMode(*args, **kwargs)
def GetPrintMode(*args, **kwargs):
"""GetPrintMode(self) -> int"""
return _core_.PyApp_GetPrintMode(*args, **kwargs)
def SetAssertMode(*args, **kwargs):
"""
SetAssertMode(self, int mode)
Set the OnAssert behaviour for debug and hybrid builds.
"""
return _core_.PyApp_SetAssertMode(*args, **kwargs)
def GetAssertMode(*args, **kwargs):
"""
GetAssertMode(self) -> int
Get the current OnAssert behaviour setting.
"""
return _core_.PyApp_GetAssertMode(*args, **kwargs)
def GetMacSupportPCMenuShortcuts(*args, **kwargs):
"""GetMacSupportPCMenuShortcuts() -> bool"""
return _core_.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)
GetMacSupportPCMenuShortcuts = staticmethod(GetMacSupportPCMenuShortcuts)
def GetMacAboutMenuItemId(*args, **kwargs):
"""GetMacAboutMenuItemId() -> long"""
return _core_.PyApp_GetMacAboutMenuItemId(*args, **kwargs)
GetMacAboutMenuItemId = staticmethod(GetMacAboutMenuItemId)
def GetMacPreferencesMenuItemId(*args, **kwargs):
"""GetMacPreferencesMenuItemId() -> long"""
return _core_.PyApp_GetMacPreferencesMenuItemId(*args, **kwargs)
GetMacPreferencesMenuItemId = staticmethod(GetMacPreferencesMenuItemId)
def GetMacExitMenuItemId(*args, **kwargs):
"""GetMacExitMenuItemId() -> long"""
return _core_.PyApp_GetMacExitMenuItemId(*args, **kwargs)
GetMacExitMenuItemId = staticmethod(GetMacExitMenuItemId)
def GetMacHelpMenuTitleName(*args, **kwargs):
"""GetMacHelpMenuTitleName() -> String"""
return _core_.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
GetMacHelpMenuTitleName = staticmethod(GetMacHelpMenuTitleName)
def SetMacSupportPCMenuShortcuts(*args, **kwargs):
"""SetMacSupportPCMenuShortcuts(bool val)"""
return _core_.PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs)
SetMacSupportPCMenuShortcuts = staticmethod(SetMacSupportPCMenuShortcuts)
def SetMacAboutMenuItemId(*args, **kwargs):
"""SetMacAboutMenuItemId(long val)"""
return _core_.PyApp_SetMacAboutMenuItemId(*args, **kwargs)
SetMacAboutMenuItemId = staticmethod(SetMacAboutMenuItemId)
def SetMacPreferencesMenuItemId(*args, **kwargs):
"""SetMacPreferencesMenuItemId(long val)"""
return _core_.PyApp_SetMacPreferencesMenuItemId(*args, **kwargs)
SetMacPreferencesMenuItemId = staticmethod(SetMacPreferencesMenuItemId)
def SetMacExitMenuItemId(*args, **kwargs):
"""SetMacExitMenuItemId(long val)"""
return _core_.PyApp_SetMacExitMenuItemId(*args, **kwargs)
SetMacExitMenuItemId = staticmethod(SetMacExitMenuItemId)
def SetMacHelpMenuTitleName(*args, **kwargs):
"""SetMacHelpMenuTitleName(String val)"""
return _core_.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
SetMacHelpMenuTitleName = staticmethod(SetMacHelpMenuTitleName)
def _BootstrapApp(*args, **kwargs):
"""
_BootstrapApp(self)
For internal use only
"""
return _core_.PyApp__BootstrapApp(*args, **kwargs)
def GetComCtl32Version(*args, **kwargs):
"""
GetComCtl32Version() -> int
Returns 400, 470, 471, etc. for comctl32.dll 4.00, 4.70, 4.71 or 0 if
it wasn't found at all. Raises an exception on non-Windows platforms.
"""
return _core_.PyApp_GetComCtl32Version(*args, **kwargs)
GetComCtl32Version = staticmethod(GetComCtl32Version)
class PyAppPtr(PyApp):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyApp
_core_.PyApp_swigregister(PyAppPtr)
def PyApp_IsMainLoopRunning(*args, **kwargs):
"""
PyApp_IsMainLoopRunning() -> bool
Returns True if we're running the main loop, i.e. if the events can
currently be dispatched.
"""
return _core_.PyApp_IsMainLoopRunning(*args, **kwargs)
def PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs):
"""PyApp_GetMacSupportPCMenuShortcuts() -> bool"""
return _core_.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)
def PyApp_GetMacAboutMenuItemId(*args, **kwargs):
"""PyApp_GetMacAboutMenuItemId() -> long"""
return _core_.PyApp_GetMacAboutMenuItemId(*args, **kwargs)
def PyApp_GetMacPreferencesMenuItemId(*args, **kwargs):
"""PyApp_GetMacPreferencesMenuItemId() -> long"""
return _core_.PyApp_GetMacPreferencesMenuItemId(*args, **kwargs)
def PyApp_GetMacExitMenuItemId(*args, **kwargs):
"""PyApp_GetMacExitMenuItemId() -> long"""
return _core_.PyApp_GetMacExitMenuItemId(*args, **kwargs)
def PyApp_GetMacHelpMenuTitleName(*args, **kwargs):
"""PyApp_GetMacHelpMenuTitleName() -> String"""
return _core_.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
def PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs):
"""PyApp_SetMacSupportPCMenuShortcuts(bool val)"""
return _core_.PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs)
def PyApp_SetMacAboutMenuItemId(*args, **kwargs):
"""PyApp_SetMacAboutMenuItemId(long val)"""
return _core_.PyApp_SetMacAboutMenuItemId(*args, **kwargs)
def PyApp_SetMacPreferencesMenuItemId(*args, **kwargs):
"""PyApp_SetMacPreferencesMenuItemId(long val)"""
return _core_.PyApp_SetMacPreferencesMenuItemId(*args, **kwargs)
def PyApp_SetMacExitMenuItemId(*args, **kwargs):
"""PyApp_SetMacExitMenuItemId(long val)"""
return _core_.PyApp_SetMacExitMenuItemId(*args, **kwargs)
def PyApp_SetMacHelpMenuTitleName(*args, **kwargs):
"""PyApp_SetMacHelpMenuTitleName(String val)"""
return _core_.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
def PyApp_GetComCtl32Version(*args, **kwargs):
"""
PyApp_GetComCtl32Version() -> int
Returns 400, 470, 471, etc. for comctl32.dll 4.00, 4.70, 4.71 or 0 if
it wasn't found at all. Raises an exception on non-Windows platforms.
"""
return _core_.PyApp_GetComCtl32Version(*args, **kwargs)
#---------------------------------------------------------------------------
def Exit(*args, **kwargs):
"""
Exit()
Force an exit of the application. Convenience for wx.GetApp().Exit()
"""
return _core_.Exit(*args, **kwargs)
def Yield(*args, **kwargs):
"""
Yield() -> bool
Yield to other apps/messages. Convenience for wx.GetApp().Yield()
"""
return _core_.Yield(*args, **kwargs)
def YieldIfNeeded(*args, **kwargs):
"""
YieldIfNeeded() -> bool
Yield to other apps/messages. Convenience for wx.GetApp().Yield(True)
"""
return _core_.YieldIfNeeded(*args, **kwargs)
def SafeYield(*args, **kwargs):
"""
SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool
This function is similar to `wx.Yield`, except that it disables the
user input to all program windows before calling `wx.Yield` and
re-enables it again afterwards. If ``win`` is not None, this window
will remain enabled, allowing the implementation of some limited user
interaction.
:Returns: the result of the call to `wx.Yield`.
"""
return _core_.SafeYield(*args, **kwargs)
def WakeUpIdle(*args, **kwargs):
"""
WakeUpIdle()
Cause the message queue to become empty again, so idle events will be
sent.
"""
return _core_.WakeUpIdle(*args, **kwargs)
def PostEvent(*args, **kwargs):
"""
PostEvent(EvtHandler dest, Event event)
Send an event to a window or other wx.EvtHandler to be processed
later.
"""
return _core_.PostEvent(*args, **kwargs)
def App_CleanUp(*args, **kwargs):
"""
App_CleanUp()
For internal use only, it is used to cleanup after wxWidgets when
Python shuts down.
"""
return _core_.App_CleanUp(*args, **kwargs)
def GetApp(*args, **kwargs):
"""
GetApp() -> PyApp
Return a reference to the current wx.App object.
"""
return _core_.GetApp(*args, **kwargs)
def SetDefaultPyEncoding(*args, **kwargs):
"""
SetDefaultPyEncoding(string encoding)
Sets the encoding that wxPython will use when it needs to convert a
Python string or unicode object to or from a wxString.
The default encoding is the value of ``locale.getdefaultlocale()[1]``
but please be aware that the default encoding within the same locale
may be slightly different on different platforms. For example, please
see http://www.alanwood.net/demos/charsetdiffs.html for differences
between the common latin/roman encodings.
"""
return _core_.SetDefaultPyEncoding(*args, **kwargs)
def GetDefaultPyEncoding(*args, **kwargs):
"""
GetDefaultPyEncoding() -> string
Gets the current encoding that wxPython will use when it needs to
convert a Python string or unicode object to or from a wxString.
"""
return _core_.GetDefaultPyEncoding(*args, **kwargs)
#----------------------------------------------------------------------
class PyOnDemandOutputWindow:
"""
A class that can be used for redirecting Python's stdout and
stderr streams. It will do nothing until something is wrriten to
the stream at which point it will create a Frame with a text area
and write the text there.
"""
def __init__(self, title = "wxPython: stdout/stderr"):
self.frame = None
self.title = title
self.pos = wx.DefaultPosition
self.size = (450, 300)
self.parent = None
def SetParent(self, parent):
"""Set the window to be used as the popup Frame's parent."""
self.parent = parent
def CreateOutputWindow(self, st):
self.frame = wx.Frame(self.parent, -1, self.title, self.pos, self.size,
style=wx.DEFAULT_FRAME_STYLE)
self.text = wx.TextCtrl(self.frame, -1, "",
style=wx.TE_MULTILINE|wx.TE_READONLY)
self.text.AppendText(st)
self.frame.Show(True)
EVT_CLOSE(self.frame, self.OnCloseWindow)
def OnCloseWindow(self, event):
if self.frame is not None:
self.frame.Destroy()
self.frame = None
self.text = None
# These methods provide the file-like output behaviour.
def write(self, text):
"""
Create the output window if needed and write the string to it.
If not called in the context of the gui thread then uses
CallAfter to do the work there.
"""
if self.frame is None:
if not wx.Thread_IsMain():
wx.CallAfter(self.CreateOutputWindow, text)
else:
self.CreateOutputWindow(text)
else:
if not wx.Thread_IsMain():
wx.CallAfter(self.text.AppendText, text)
else:
self.text.AppendText(text)
def close(self):
if self.frame is not None:
wx.CallAfter(self.frame.Close)
def flush(self):
pass
#----------------------------------------------------------------------
_defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__')
class App(wx.PyApp):
"""
The ``wx.App`` class represents the application and is used to:
* bootstrap the wxPython system and initialize the underlying
gui toolkit
* set and get application-wide properties
* implement the windowing system main message or event loop,
and to dispatch events to window instances
* etc.
Every application must have a ``wx.App`` instance, and all
creation of UI objects should be delayed until after the
``wx.App`` object has been created in order to ensure that the gui
platform and wxWidgets have been fully initialized.
Normally you would derive from this class and implement an
``OnInit`` method that creates a frame and then calls
``self.SetTopWindow(frame)``.
:see: `wx.PySimpleApp` for a simpler app class that can be used
directly.
"""
outputWindowClass = PyOnDemandOutputWindow
def __init__(self, redirect=_defRedirect, filename=None,
useBestVisual=False, clearSigInt=True):
"""
Construct a ``wx.App`` object.
:param redirect: Should ``sys.stdout`` and ``sys.stderr`` be
redirected? Defaults to True on Windows and Mac, False
otherwise. If `filename` is None then output will be
redirected to a window that pops up as needed. (You can
control what kind of window is created for the output by
resetting the class variable ``outputWindowClass`` to a
class of your choosing.)
:param filename: The name of a file to redirect output to, if
redirect is True.
:param useBestVisual: Should the app try to use the best
available visual provided by the system (only relevant on
systems that have more than one visual.) This parameter
must be used instead of calling `SetUseBestVisual` later
on because it must be set before the underlying GUI
toolkit is initialized.
:param clearSigInt: Should SIGINT be cleared? This allows the
app to terminate upon a Ctrl-C in the console like other
GUI apps will.
:note: You should override OnInit to do applicaition
initialization to ensure that the system, toolkit and
wxWidgets are fully initialized.
"""
wx.PyApp.__init__(self)
if wx.Platform == "__WXMAC__":
try:
import MacOS
if not MacOS.WMAvailable():
print """\
This program needs access to the screen. Please run with 'pythonw',
not 'python', and only when you are logged in on the main display of
your Mac."""
_sys.exit(1)
except SystemExit:
raise
except:
pass
# This has to be done before OnInit
self.SetUseBestVisual(useBestVisual)
# Set the default handler for SIGINT. This fixes a problem
# where if Ctrl-C is pressed in the console that started this
# app then it will not appear to do anything, (not even send
# KeyboardInterrupt???) but will later segfault on exit. By
# setting the default handler then the app will exit, as
# expected (depending on platform.)
if clearSigInt:
try:
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
except:
pass
# Save and redirect the stdio to a window?
self.stdioWin = None
self.saveStdio = (_sys.stdout, _sys.stderr)
if redirect:
self.RedirectStdio(filename)
# Use Python's install prefix as the default
wx.StandardPaths.Get().SetInstallPrefix(_sys.prefix)
# This finishes the initialization of wxWindows and then calls
# the OnInit that should be present in the derived class
self._BootstrapApp()
def __del__(self, destroy=wx.PyApp.__del__):
self.RestoreStdio() # Just in case the MainLoop was overridden
destroy(self)
def Destroy(self):
wx.PyApp.Destroy(self)
self.thisown = 0
def SetTopWindow(self, frame):
"""Set the \"main\" top level window"""
if self.stdioWin:
self.stdioWin.SetParent(frame)
wx.PyApp.SetTopWindow(self, frame)
def MainLoop(self):
"""Execute the main GUI event loop"""
wx.PyApp.MainLoop(self)
self.RestoreStdio()
def RedirectStdio(self, filename=None):
"""Redirect sys.stdout and sys.stderr to a file or a popup window."""
if filename:
_sys.stdout = _sys.stderr = open(filename, 'a')
else:
self.stdioWin = self.outputWindowClass()
_sys.stdout = _sys.stderr = self.stdioWin
def RestoreStdio(self):
try:
_sys.stdout, _sys.stderr = self.saveStdio
except:
pass
def SetOutputWindowAttributes(self, title=None, pos=None, size=None):
"""
Set the title, position and/or size of the output window if
the stdio has been redirected. This should be called before
any output would cause the output window to be created.
"""
if self.stdioWin:
if title is not None:
self.stdioWin.title = title
if pos is not None:
self.stdioWin.pos = pos
if size is not None:
self.stdioWin.size = size
# change from wx.PyApp_XX to wx.App_XX
App_GetMacSupportPCMenuShortcuts = _core_.PyApp_GetMacSupportPCMenuShortcuts
App_GetMacAboutMenuItemId = _core_.PyApp_GetMacAboutMenuItemId
App_GetMacPreferencesMenuItemId = _core_.PyApp_GetMacPreferencesMenuItemId
App_GetMacExitMenuItemId = _core_.PyApp_GetMacExitMenuItemId
App_GetMacHelpMenuTitleName = _core_.PyApp_GetMacHelpMenuTitleName
App_SetMacSupportPCMenuShortcuts = _core_.PyApp_SetMacSupportPCMenuShortcuts
App_SetMacAboutMenuItemId = _core_.PyApp_SetMacAboutMenuItemId
App_SetMacPreferencesMenuItemId = _core_.PyApp_SetMacPreferencesMenuItemId
App_SetMacExitMenuItemId = _core_.PyApp_SetMacExitMenuItemId
App_SetMacHelpMenuTitleName = _core_.PyApp_SetMacHelpMenuTitleName
App_GetComCtl32Version = _core_.PyApp_GetComCtl32Version
#----------------------------------------------------------------------------
class PySimpleApp(wx.App):
"""
A simple application class. You can just create one of these and
then then make your top level windows later, and not have to worry
about OnInit. For example::
app = wx.PySimpleApp()
frame = wx.Frame(None, title='Hello World')
frame.Show()
app.MainLoop()
:see: `wx.App`
"""
def __init__(self, redirect=False, filename=None,
useBestVisual=False, clearSigInt=True):
"""
:see: `wx.App.__init__`
"""
wx.App.__init__(self, redirect, filename, useBestVisual, clearSigInt)
def OnInit(self):
return True
# Is anybody using this one?
class PyWidgetTester(wx.App):
def __init__(self, size = (250, 100)):
self.size = size
wx.App.__init__(self, 0)
def OnInit(self):
self.frame = wx.Frame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
self.SetTopWindow(self.frame)
return True
def SetWidget(self, widgetClass, *args, **kwargs):
w = widgetClass(self.frame, *args, **kwargs)
self.frame.Show(True)
#----------------------------------------------------------------------------
# DO NOT hold any other references to this object. This is how we
# know when to cleanup system resources that wxWidgets is holding. When
# the sys module is unloaded, the refcount on sys.__wxPythonCleanup
# goes to zero and it calls the wx.App_CleanUp function.
class __wxPyCleanup:
def __init__(self):
self.cleanup = _core_.App_CleanUp
def __del__(self):
self.cleanup()
_sys.__wxPythonCleanup = __wxPyCleanup()
## # another possible solution, but it gets called too early...
## import atexit
## atexit.register(_core_.wxApp_CleanUp)
#----------------------------------------------------------------------------
#---------------------------------------------------------------------------
class EventLoop(object):
"""Proxy of C++ EventLoop class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxEventLoop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> EventLoop"""
newobj = _core_.new_EventLoop(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_EventLoop):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def Run(*args, **kwargs):
"""Run(self) -> int"""
return _core_.EventLoop_Run(*args, **kwargs)
def Exit(*args, **kwargs):
"""Exit(self, int rc=0)"""
return _core_.EventLoop_Exit(*args, **kwargs)
def Pending(*args, **kwargs):
"""Pending(self) -> bool"""
return _core_.EventLoop_Pending(*args, **kwargs)
def Dispatch(*args, **kwargs):
"""Dispatch(self) -> bool"""
return _core_.EventLoop_Dispatch(*args, **kwargs)
def IsRunning(*args, **kwargs):
"""IsRunning(self) -> bool"""
return _core_.EventLoop_IsRunning(*args, **kwargs)
def GetActive(*args, **kwargs):
"""GetActive() -> EventLoop"""
return _core_.EventLoop_GetActive(*args, **kwargs)
GetActive = staticmethod(GetActive)
def SetActive(*args, **kwargs):
"""SetActive(EventLoop loop)"""
return _core_.EventLoop_SetActive(*args, **kwargs)
SetActive = staticmethod(SetActive)
class EventLoopPtr(EventLoop):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = EventLoop
_core_.EventLoop_swigregister(EventLoopPtr)
def EventLoop_GetActive(*args, **kwargs):
"""EventLoop_GetActive() -> EventLoop"""
return _core_.EventLoop_GetActive(*args, **kwargs)
def EventLoop_SetActive(*args, **kwargs):
"""EventLoop_SetActive(EventLoop loop)"""
return _core_.EventLoop_SetActive(*args, **kwargs)
#---------------------------------------------------------------------------
class AcceleratorEntry(object):
"""
A class used to define items in an `wx.AcceleratorTable`. wxPython
programs can choose to use wx.AcceleratorEntry objects, but using a
list of 3-tuple of integers (flags, keyCode, cmdID) usually works just
as well. See `__init__` for of the tuple values.
:see: `wx.AcceleratorTable`
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxAcceleratorEntry instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int flags=0, int keyCode=0, int cmdID=0) -> AcceleratorEntry
Construct a wx.AcceleratorEntry.
"""
newobj = _core_.new_AcceleratorEntry(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_AcceleratorEntry):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def Set(*args, **kwargs):
"""
Set(self, int flags, int keyCode, int cmd)
(Re)set the attributes of a wx.AcceleratorEntry.
:see `__init__`
"""
return _core_.AcceleratorEntry_Set(*args, **kwargs)
def GetFlags(*args, **kwargs):
"""
GetFlags(self) -> int
Get the AcceleratorEntry's flags.
"""
return _core_.AcceleratorEntry_GetFlags(*args, **kwargs)
def GetKeyCode(*args, **kwargs):
"""
GetKeyCode(self) -> int
Get the AcceleratorEntry's keycode.
"""
return _core_.AcceleratorEntry_GetKeyCode(*args, **kwargs)
def GetCommand(*args, **kwargs):
"""
GetCommand(self) -> int
Get the AcceleratorEntry's command ID.
"""
return _core_.AcceleratorEntry_GetCommand(*args, **kwargs)
class AcceleratorEntryPtr(AcceleratorEntry):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = AcceleratorEntry
_core_.AcceleratorEntry_swigregister(AcceleratorEntryPtr)
class AcceleratorTable(Object):
"""
An accelerator table allows the application to specify a table of
keyboard shortcuts for menus or other commands. On Windows, menu or
button commands are supported; on GTK, only menu commands are
supported.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxAcceleratorTable instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(entries) -> AcceleratorTable
Construct an AcceleratorTable from a list of `wx.AcceleratorEntry`
items or or of 3-tuples (flags, keyCode, cmdID)
:see: `wx.AcceleratorEntry`
"""
newobj = _core_.new_AcceleratorTable(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_AcceleratorTable):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
def Ok(*args, **kwargs):
"""Ok(self) -> bool"""
return _core_.AcceleratorTable_Ok(*args, **kwargs)
class AcceleratorTablePtr(AcceleratorTable):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = AcceleratorTable
_core_.AcceleratorTable_swigregister(AcceleratorTablePtr)
def GetAccelFromString(*args, **kwargs):
"""GetAccelFromString(String label) -> AcceleratorEntry"""
return _core_.GetAccelFromString(*args, **kwargs)
#---------------------------------------------------------------------------
class VisualAttributes(object):
"""struct containing all the visual attributes of a control"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxVisualAttributes instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> VisualAttributes
struct containing all the visual attributes of a control
"""
newobj = _core_.new_VisualAttributes(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def __del__(self, destroy=_core_.delete_VisualAttributes):
"""__del__(self)"""
try:
if self.thisown: destroy(self)
except: pass
font = property(_core_.VisualAttributes_font_get, _core_.VisualAttributes_font_set)
colFg = property(_core_.VisualAttributes_colFg_get, _core_.VisualAttributes_colFg_set)
colBg = property(_core_.VisualAttributes_colBg_get, _core_.VisualAttributes_colBg_set)
class VisualAttributesPtr(VisualAttributes):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = VisualAttributes
_core_.VisualAttributes_swigregister(VisualAttributesPtr)
NullAcceleratorTable = cvar.NullAcceleratorTable
PanelNameStr = cvar.PanelNameStr
WINDOW_VARIANT_NORMAL = _core_.WINDOW_VARIANT_NORMAL
WINDOW_VARIANT_SMALL = _core_.WINDOW_VARIANT_SMALL
WINDOW_VARIANT_MINI = _core_.WINDOW_VARIANT_MINI
WINDOW_VARIANT_LARGE = _core_.WINDOW_VARIANT_LARGE
WINDOW_VARIANT_MAX = _core_.WINDOW_VARIANT_MAX
class Window(EvtHandler):
"""
wx.Window is the base class for all windows and represents any visible
object on the screen. All controls, top level windows and so on are
wx.Windows. Sizers and device contexts are not however, as they don't
appear on screen themselves.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=PanelNameStr) -> Window
Construct and show a generic Window.
"""
newobj = _core_.new_Window(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=PanelNameStr) -> bool
Create the GUI part of the Window for 2-phase creation mode.
"""
return _core_.Window_Create(*args, **kwargs)
def Close(*args, **kwargs):
"""
Close(self, bool force=False) -> bool
This function simply generates a EVT_CLOSE event whose handler usually
tries to close the window. It doesn't close the window itself,
however. If force is False (the default) then the window's close
handler will be allowed to veto the destruction of the window.
"""
return _core_.Window_Close(*args, **kwargs)
def Destroy(*args, **kwargs):
"""
Destroy(self) -> bool
Destroys the window safely. Frames and dialogs are not destroyed
immediately when this function is called -- they are added to a list
of windows to be deleted on idle time, when all the window's events
have been processed. This prevents problems with events being sent to
non-existent windows.
Returns True if the window has either been successfully deleted, or it
has been added to the list of windows pending real deletion.
"""
return _core_.Window_Destroy(*args, **kwargs)
def DestroyChildren(*args, **kwargs):
"""
DestroyChildren(self) -> bool
Destroys all children of a window. Called automatically by the
destructor.
"""
return _core_.Window_DestroyChildren(*args, **kwargs)
def IsBeingDeleted(*args, **kwargs):
"""
IsBeingDeleted(self) -> bool
Is the window in the process of being deleted?
"""
return _core_.Window_IsBeingDeleted(*args, **kwargs)
def SetTitle(*args, **kwargs):
"""
SetTitle(self, String title)
Sets the window's title. Applicable only to frames and dialogs.
"""
return _core_.Window_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
"""
GetTitle(self) -> String
Gets the window's title. Applicable only to frames and dialogs.
"""
return _core_.Window_GetTitle(*args, **kwargs)
def SetLabel(*args, **kwargs):
"""
SetLabel(self, String label)
Set the text which the window shows in its label if applicable.
"""
return _core_.Window_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""
GetLabel(self) -> String
Generic way of getting a label from any window, for identification
purposes. The interpretation of this function differs from class to
class. For frames and dialogs, the value returned is the title. For
buttons or static text controls, it is the button text. This function
can be useful for meta-programs such as testing tools or special-needs
access programs)which need to identify windows by name.
"""
return _core_.Window_GetLabel(*args, **kwargs)
def SetName(*args, **kwargs):
"""
SetName(self, String name)
Sets the window's name. The window name is used for ressource setting
in X, it is not the same as the window title/label
"""
return _core_.Window_SetName(*args, **kwargs)
def GetName(*args, **kwargs):
"""
GetName(self) -> String
Returns the windows name. This name is not guaranteed to be unique;
it is up to the programmer to supply an appropriate name in the window
constructor or via wx.Window.SetName.
"""
return _core_.Window_GetName(*args, **kwargs)
def SetWindowVariant(*args, **kwargs):
"""
SetWindowVariant(self, int variant)
Sets the variant of the window/font size to use for this window, if
the platform supports variants, for example, wxMac.
"""
return _core_.Window_SetWindowVariant(*args, **kwargs)
def GetWindowVariant(*args, **kwargs):
"""GetWindowVariant(self) -> int"""
return _core_.Window_GetWindowVariant(*args, **kwargs)
def SetId(*args, **kwargs):
"""
SetId(self, int winid)
Sets the identifier of the window. Each window has an integer
identifier. If the application has not provided one, an identifier
will be generated. Normally, the identifier should be provided on
creation and should not be modified subsequently.
"""
return _core_.Window_SetId(*args, **kwargs)
def GetId(*args, **kwargs):
"""
GetId(self) -> int
Returns the identifier of the window. Each window has an integer
identifier. If the application has not provided one (or the default Id
-1 is used) then an unique identifier with a negative value will be
generated.
"""
return _core_.Window_GetId(*args, **kwargs)
def NewControlId(*args, **kwargs):
"""
NewControlId() -> int
Generate a control id for the controls which were not given one.
"""
return _core_.Window_NewControlId(*args, **kwargs)
NewControlId = staticmethod(NewControlId)
def NextControlId(*args, **kwargs):
"""
NextControlId(int winid) -> int
Get the id of the control following the one with the given
autogenerated) id
"""
return _core_.Window_NextControlId(*args, **kwargs)
NextControlId = staticmethod(NextControlId)
def PrevControlId(*args, **kwargs):
"""
PrevControlId(int winid) -> int
Get the id of the control preceding the one with the given
autogenerated) id
"""
return _core_.Window_PrevControlId(*args, **kwargs)
PrevControlId = staticmethod(PrevControlId)
def SetSize(*args, **kwargs):
"""
SetSize(self, Size size)
Sets the size of the window in pixels.
"""
return _core_.Window_SetSize(*args, **kwargs)
def SetDimensions(*args, **kwargs):
"""
SetDimensions(self, int x, int y, int width, int height, int sizeFlags=SIZE_AUTO)
Sets the position and size of the window in pixels. The sizeFlags
parameter indicates the interpretation of the other params if they are
equal to -1.
======================== ======================================
wx.SIZE_AUTO A -1 indicates that a class-specific
default should be used.
wx.SIZE_USE_EXISTING Axisting dimensions should be used if
-1 values are supplied.
wxSIZE_ALLOW_MINUS_ONE Allow dimensions of -1 and less to be
interpreted as real dimensions, not
default values.
======================== ======================================
"""
return _core_.Window_SetDimensions(*args, **kwargs)
def SetRect(*args, **kwargs):
"""
SetRect(self, Rect rect, int sizeFlags=SIZE_AUTO)
Sets the position and size of the window in pixels using a wx.Rect.
"""
return _core_.Window_SetRect(*args, **kwargs)
def SetSizeWH(*args, **kwargs):
"""
SetSizeWH(self, int width, int height)
Sets the size of the window in pixels.
"""
return _core_.Window_SetSizeWH(*args, **kwargs)
def Move(*args, **kwargs):
"""
Move(self, Point pt, int flags=SIZE_USE_EXISTING)
Moves the window to the given position.
"""
return _core_.Window_Move(*args, **kwargs)
SetPosition = Move
def MoveXY(*args, **kwargs):
"""
MoveXY(self, int x, int y, int flags=SIZE_USE_EXISTING)
Moves the window to the given position.
"""
return _core_.Window_MoveXY(*args, **kwargs)
def SetBestFittingSize(*args, **kwargs):
"""
SetBestFittingSize(self, Size size=DefaultSize)
A 'Smart' SetSize that will fill in default size components with the
window's *best size* values. Also set's the minsize for use with sizers.
"""
return _core_.Window_SetBestFittingSize(*args, **kwargs)
def Raise(*args, **kwargs):
"""
Raise(self)
Raises the window to the top of the window hierarchy. In current
version of wxWidgets this works both for manage and child windows.
"""
return _core_.Window_Raise(*args, **kwargs)
def Lower(*args, **kwargs):
"""
Lower(self)
Lowers the window to the bottom of the window hierarchy. In current
version of wxWidgets this works both for manage and child windows.
"""
return _core_.Window_Lower(*args, **kwargs)
def SetClientSize(*args, **kwargs):
"""
SetClientSize(self, Size size)
This sets the size of the window client area in pixels. Using this
function to size a window tends to be more device-independent than
wx.Window.SetSize, since the application need not worry about what
dimensions the border or title bar have when trying to fit the window
around panel items, for example.
"""
return _core_.Window_SetClientSize(*args, **kwargs)
def SetClientSizeWH(*args, **kwargs):
"""
SetClientSizeWH(self, int width, int height)
This sets the size of the window client area in pixels. Using this
function to size a window tends to be more device-independent than
wx.Window.SetSize, since the application need not worry about what
dimensions the border or title bar have when trying to fit the window
around panel items, for example.
"""
return _core_.Window_SetClientSizeWH(*args, **kwargs)
def SetClientRect(*args, **kwargs):
"""
SetClientRect(self, Rect rect)
This sets the size of the window client area in pixels. Using this
function to size a window tends to be more device-independent than
wx.Window.SetSize, since the application need not worry about what
dimensions the border or title bar have when trying to fit the window
around panel items, for example.
"""
return _core_.Window_SetClientRect(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Get the window's position.
"""
return _core_.Window_GetPosition(*args, **kwargs)
def GetPositionTuple(*args, **kwargs):
"""
GetPositionTuple() -> (x,y)
Get the window's position.
"""
return _core_.Window_GetPositionTuple(*args, **kwargs)
def GetSize(*args, **kwargs):
"""
GetSize(self) -> Size
Get the window size.
"""
return _core_.Window_GetSize(*args, **kwargs)
def GetSizeTuple(*args, **kwargs):
"""
GetSizeTuple() -> (width, height)
Get the window size.
"""
return _core_.Window_GetSizeTuple(*args, **kwargs)
def GetRect(*args, **kwargs):
"""
GetRect(self) -> Rect
Returns the size and position of the window as a wx.Rect object.
"""
return _core_.Window_GetRect(*args, **kwargs)
def GetClientSize(*args, **kwargs):
"""
GetClientSize(self) -> Size
This gets the size of the window's 'client area' in pixels. The client
area is the area which may be drawn on by the programmer, excluding
title bar, border, scrollbars, etc.
"""
return _core_.Window_GetClientSize(*args, **kwargs)
def GetClientSizeTuple(*args, **kwargs):
"""
GetClientSizeTuple() -> (width, height)
This gets the size of the window's 'client area' in pixels. The client
area is the area which may be drawn on by the programmer, excluding
title bar, border, scrollbars, etc.
"""
return _core_.Window_GetClientSizeTuple(*args, **kwargs)
def GetClientAreaOrigin(*args, **kwargs):
"""
GetClientAreaOrigin(self) -> Point
Get the origin of the client area of the window relative to the
window's top left corner (the client area may be shifted because of
the borders, scrollbars, other decorations...)
"""
return _core_.Window_GetClientAreaOrigin(*args, **kwargs)
def GetClientRect(*args, **kwargs):
"""
GetClientRect(self) -> Rect
Get the client area position and size as a `wx.Rect` object.
"""
return _core_.Window_GetClientRect(*args, **kwargs)
def GetBestSize(*args, **kwargs):
"""
GetBestSize(self) -> Size
This function returns the best acceptable minimal size for the
window, if applicable. For example, for a static text control, it will
be the minimal size such that the control label is not truncated. For
windows containing subwindows (suzh aswx.Panel), the size returned by
this function will be the same as the size the window would have had
after calling Fit.
"""
return _core_.Window_GetBestSize(*args, **kwargs)
def GetBestSizeTuple(*args, **kwargs):
"""
GetBestSizeTuple() -> (width, height)
This function returns the best acceptable minimal size for the
window, if applicable. For example, for a static text control, it will
be the minimal size such that the control label is not truncated. For
windows containing subwindows (suzh aswx.Panel), the size returned by
this function will be the same as the size the window would have had
after calling Fit.
"""
return _core_.Window_GetBestSizeTuple(*args, **kwargs)
def InvalidateBestSize(*args, **kwargs):
"""
InvalidateBestSize(self)
Reset the cached best size value so it will be recalculated the next
time it is needed.
"""
return _core_.Window_InvalidateBestSize(*args, **kwargs)
def CacheBestSize(*args, **kwargs):
"""
CacheBestSize(self, Size size)
Cache the best size so it doesn't need to be calculated again, (at least until
some properties of the window change.)
"""
return _core_.Window_CacheBestSize(*args, **kwargs)
def GetBestFittingSize(*args, **kwargs):
"""
GetBestFittingSize(self) -> Size
This function will merge the window's best size into the window's
minimum size, giving priority to the min size components, and returns
the results.
"""
return _core_.Window_GetBestFittingSize(*args, **kwargs)
def GetAdjustedBestSize(*args, **kwargs):
"""
GetAdjustedBestSize(self) -> Size
This method is similar to GetBestSize, except in one
thing. GetBestSize should return the minimum untruncated size of the
window, while this method will return the largest of BestSize and any
user specified minimum size. ie. it is the minimum size the window
should currently be drawn at, not the minimal size it can possibly
tolerate.
"""
return _core_.Window_GetAdjustedBestSize(*args, **kwargs)
def Center(*args, **kwargs):
"""
Center(self, int direction=BOTH)
Centers the window. The parameter specifies the direction for
cetering, and may be wx.HORIZONTAL, wx.VERTICAL or wx.BOTH. It may
also include wx.CENTER_ON_SCREEN flag if you want to center the window
on the entire screen and not on its parent window. If it is a
top-level window and has no parent then it will always be centered
relative to the screen.
"""
return _core_.Window_Center(*args, **kwargs)
Centre = Center
def CenterOnScreen(*args, **kwargs):
"""
CenterOnScreen(self, int dir=BOTH)
Center on screen (only works for top level windows)
"""
return _core_.Window_CenterOnScreen(*args, **kwargs)
CenterOnScreen = wx._deprecated(CenterOnScreen)
CentreOnScreen = CenterOnScreen
def CenterOnParent(*args, **kwargs):
"""
CenterOnParent(self, int dir=BOTH)
Center with respect to the the parent window
"""
return _core_.Window_CenterOnParent(*args, **kwargs)
CentreOnParent = CenterOnParent
def Fit(*args, **kwargs):
"""
Fit(self)
Sizes the window so that it fits around its subwindows. This function
won't do anything if there are no subwindows and will only really work
correctly if sizers are used for the subwindows layout. Also, if the
window has exactly one subwindow it is better (faster and the result
is more precise as Fit adds some margin to account for fuzziness of
its calculations) to call window.SetClientSize(child.GetSize())
instead of calling Fit.
"""
return _core_.Window_Fit(*args, **kwargs)
def FitInside(*args, **kwargs):
"""
FitInside(self)
Similar to Fit, but sizes the interior (virtual) size of a
window. Mainly useful with scrolled windows to reset scrollbars after
sizing changes that do not trigger a size event, and/or scrolled
windows without an interior sizer. This function similarly won't do
anything if there are no subwindows.
"""
return _core_.Window_FitInside(*args, **kwargs)
def SetSizeHints(*args, **kwargs):
"""
SetSizeHints(self, int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1,
int incH=-1)
Allows specification of minimum and maximum window sizes, and window
size increments. If a pair of values is not set (or set to -1), the
default values will be used. If this function is called, the user
will not be able to size the window outside the given bounds (if it is
a top-level window.) Sizers will also inspect the minimum window size
and will use that value if set when calculating layout.
The resizing increments are only significant under Motif or Xt.
"""
return _core_.Window_SetSizeHints(*args, **kwargs)
def SetSizeHintsSz(*args, **kwargs):
"""
SetSizeHintsSz(self, Size minSize, Size maxSize=DefaultSize, Size incSize=DefaultSize)
Allows specification of minimum and maximum window sizes, and window
size increments. If a pair of values is not set (or set to -1), the
default values will be used. If this function is called, the user
will not be able to size the window outside the given bounds (if it is
a top-level window.) Sizers will also inspect the minimum window size
and will use that value if set when calculating layout.
The resizing increments are only significant under Motif or Xt.
"""
return _core_.Window_SetSizeHintsSz(*args, **kwargs)
def SetVirtualSizeHints(*args, **kwargs):
"""
SetVirtualSizeHints(self, int minW, int minH, int maxW=-1, int maxH=-1)
Allows specification of minimum and maximum virtual window sizes. If a
pair of values is not set (or set to -1), the default values will be
used. If this function is called, the user will not be able to size
the virtual area of the window outside the given bounds.
"""
return _core_.Window_SetVirtualSizeHints(*args, **kwargs)
def SetVirtualSizeHintsSz(*args, **kwargs):
"""
SetVirtualSizeHintsSz(self, Size minSize, Size maxSize=DefaultSize)
Allows specification of minimum and maximum virtual window sizes. If a
pair of values is not set (or set to -1), the default values will be
used. If this function is called, the user will not be able to size
the virtual area of the window outside the given bounds.
"""
return _core_.Window_SetVirtualSizeHintsSz(*args, **kwargs)
def GetMaxSize(*args, **kwargs):
"""GetMaxSize(self) -> Size"""
return _core_.Window_GetMaxSize(*args, **kwargs)
def GetMinSize(*args, **kwargs):
"""GetMinSize(self) -> Size"""
return _core_.Window_GetMinSize(*args, **kwargs)
def SetMinSize(*args, **kwargs):
"""
SetMinSize(self, Size minSize)
A more convenient method than `SetSizeHints` for setting just the
min size.
"""
return _core_.Window_SetMinSize(*args, **kwargs)
def SetMaxSize(*args, **kwargs):
"""
SetMaxSize(self, Size maxSize)
A more convenient method than `SetSizeHints` for setting just the
max size.
"""
return _core_.Window_SetMaxSize(*args, **kwargs)
def GetMinWidth(*args, **kwargs):
"""GetMinWidth(self) -> int"""
return _core_.Window_GetMinWidth(*args, **kwargs)
def GetMinHeight(*args, **kwargs):
"""GetMinHeight(self) -> int"""
return _core_.Window_GetMinHeight(*args, **kwargs)
def GetMaxWidth(*args, **kwargs):
"""GetMaxWidth(self) -> int"""
return _core_.Window_GetMaxWidth(*args, **kwargs)
def GetMaxHeight(*args, **kwargs):
"""GetMaxHeight(self) -> int"""
return _core_.Window_GetMaxHeight(*args, **kwargs)
def SetVirtualSize(*args, **kwargs):
"""
SetVirtualSize(self, Size size)
Set the the virtual size of a window in pixels. For most windows this
is just the client area of the window, but for some like scrolled
windows it is more or less independent of the screen window size.
"""
return _core_.Window_SetVirtualSize(*args, **kwargs)
def SetVirtualSizeWH(*args, **kwargs):
"""
SetVirtualSizeWH(self, int w, int h)
Set the the virtual size of a window in pixels. For most windows this
is just the client area of the window, but for some like scrolled
windows it is more or less independent of the screen window size.
"""
return _core_.Window_SetVirtualSizeWH(*args, **kwargs)
def GetVirtualSize(*args, **kwargs):
"""
GetVirtualSize(self) -> Size
Get the the virtual size of the window in pixels. For most windows
this is just the client area of the window, but for some like scrolled
windows it is more or less independent of the screen window size.
"""
return _core_.Window_GetVirtualSize(*args, **kwargs)
def GetVirtualSizeTuple(*args, **kwargs):
"""
GetVirtualSizeTuple() -> (width, height)
Get the the virtual size of the window in pixels. For most windows
this is just the client area of the window, but for some like scrolled
windows it is more or less independent of the screen window size.
"""
return _core_.Window_GetVirtualSizeTuple(*args, **kwargs)
def GetBestVirtualSize(*args, **kwargs):
"""
GetBestVirtualSize(self) -> Size
Return the largest of ClientSize and BestSize (as determined by a
sizer, interior children, or other means)
"""
return _core_.Window_GetBestVirtualSize(*args, **kwargs)
def Show(*args, **kwargs):
"""
Show(self, bool show=True) -> bool
Shows or hides the window. You may need to call Raise for a top level
window if you want to bring it to top, although this is not needed if
Show is called immediately after the frame creation. Returns True if
the window has been shown or hidden or False if nothing was done
because it already was in the requested state.
"""
return _core_.Window_Show(*args, **kwargs)
def Hide(*args, **kwargs):
"""
Hide(self) -> bool
Equivalent to calling Show(False).
"""
return _core_.Window_Hide(*args, **kwargs)
def Enable(*args, **kwargs):
"""
Enable(self, bool enable=True) -> bool
Enable or disable the window for user input. Note that when a parent
window is disabled, all of its children are disabled as well and they
are reenabled again when the parent is. Returns true if the window
has been enabled or disabled, false if nothing was done, i.e. if the
window had already been in the specified state.
"""
return _core_.Window_Enable(*args, **kwargs)
def Disable(*args, **kwargs):
"""
Disable(self) -> bool
Disables the window, same as Enable(false).
"""
return _core_.Window_Disable(*args, **kwargs)
def IsShown(*args, **kwargs):
"""
IsShown(self) -> bool
Returns true if the window is shown, false if it has been hidden.
"""
return _core_.Window_IsShown(*args, **kwargs)
def IsEnabled(*args, **kwargs):
"""
IsEnabled(self) -> bool
Returns true if the window is enabled for input, false otherwise.
"""
return _core_.Window_IsEnabled(*args, **kwargs)
def SetWindowStyleFlag(*args, **kwargs):
"""
SetWindowStyleFlag(self, long style)
Sets the style of the window. Please note that some styles cannot be
changed after the window creation and that Refresh() might need to be
called after changing the others for the change to take place
immediately.
"""
return _core_.Window_SetWindowStyleFlag(*args, **kwargs)
def GetWindowStyleFlag(*args, **kwargs):
"""
GetWindowStyleFlag(self) -> long
Gets the window style that was passed to the constructor or Create
method.
"""
return _core_.Window_GetWindowStyleFlag(*args, **kwargs)
SetWindowStyle = SetWindowStyleFlag; GetWindowStyle = GetWindowStyleFlag
def HasFlag(*args, **kwargs):
"""
HasFlag(self, int flag) -> bool
Test if the given style is set for this window.
"""
return _core_.Window_HasFlag(*args, **kwargs)
def IsRetained(*args, **kwargs):
"""
IsRetained(self) -> bool
Returns true if the window is retained, false otherwise. Retained
windows are only available on X platforms.
"""
return _core_.Window_IsRetained(*args, **kwargs)
def SetExtraStyle(*args, **kwargs):
"""
SetExtraStyle(self, long exStyle)
Sets the extra style bits for the window. Extra styles are the less
often used style bits which can't be set with the constructor or with
SetWindowStyleFlag()
"""
return _core_.Window_SetExtraStyle(*args, **kwargs)
def GetExtraStyle(*args, **kwargs):
"""
GetExtraStyle(self) -> long
Returns the extra style bits for the window.
"""
return _core_.Window_GetExtraStyle(*args, **kwargs)
def MakeModal(*args, **kwargs):
"""
MakeModal(self, bool modal=True)
Disables all other windows in the application so that the user can
only interact with this window. Passing False will reverse this
effect.
"""
return _core_.Window_MakeModal(*args, **kwargs)
def SetThemeEnabled(*args, **kwargs):
"""
SetThemeEnabled(self, bool enableTheme)
This function tells a window if it should use the system's "theme"
code to draw the windows' background instead if its own background
drawing code. This will only have an effect on platforms that support
the notion of themes in user defined windows. One such platform is
GTK+ where windows can have (very colourful) backgrounds defined by a
user's selected theme.
Dialogs, notebook pages and the status bar have this flag set to true
by default so that the default look and feel is simulated best.
"""
return _core_.Window_SetThemeEnabled(*args, **kwargs)
def GetThemeEnabled(*args, **kwargs):
"""
GetThemeEnabled(self) -> bool
Return the themeEnabled flag.
"""
return _core_.Window_GetThemeEnabled(*args, **kwargs)
def SetFocus(*args, **kwargs):
"""
SetFocus(self)
Set's the focus to this window, allowing it to receive keyboard input.
"""
return _core_.Window_SetFocus(*args, **kwargs)
def SetFocusFromKbd(*args, **kwargs):
"""
SetFocusFromKbd(self)
Set focus to this window as the result of a keyboard action. Normally
only called internally.
"""
return _core_.Window_SetFocusFromKbd(*args, **kwargs)
def FindFocus(*args, **kwargs):
"""
FindFocus() -> Window
Returns the window or control that currently has the keyboard focus,
or None.
"""
return _core_.Window_FindFocus(*args, **kwargs)
FindFocus = staticmethod(FindFocus)
def AcceptsFocus(*args, **kwargs):
"""
AcceptsFocus(self) -> bool
Can this window have focus?
"""
return _core_.Window_AcceptsFocus(*args, **kwargs)
def AcceptsFocusFromKeyboard(*args, **kwargs):
"""
AcceptsFocusFromKeyboard(self) -> bool
Can this window be given focus by keyboard navigation? if not, the
only way to give it focus (provided it accepts it at all) is to click
it.
"""
return _core_.Window_AcceptsFocusFromKeyboard(*args, **kwargs)
def GetDefaultItem(*args, **kwargs):
"""
GetDefaultItem(self) -> Window
Get the default child of this parent, i.e. the one which is activated
by pressing <Enter> such as the OK button on a wx.Dialog.
"""
return _core_.Window_GetDefaultItem(*args, **kwargs)
def SetDefaultItem(*args, **kwargs):
"""
SetDefaultItem(self, Window child) -> Window
Set this child as default, return the old default.
"""
return _core_.Window_SetDefaultItem(*args, **kwargs)
def SetTmpDefaultItem(*args, **kwargs):
"""
SetTmpDefaultItem(self, Window win)
Set this child as temporary default
"""
return _core_.Window_SetTmpDefaultItem(*args, **kwargs)
def Navigate(*args, **kwargs):
"""
Navigate(self, int flags=NavigationKeyEvent.IsForward) -> bool
Does keyboard navigation from this window to another, by sending a
`wx.NavigationKeyEvent`.
"""
return _core_.Window_Navigate(*args, **kwargs)
def MoveAfterInTabOrder(*args, **kwargs):
"""
MoveAfterInTabOrder(self, Window win)
Moves this window in the tab navigation order after the specified
sibling window. This means that when the user presses the TAB key on
that other window, the focus switches to this window.
The default tab order is the same as creation order. This function
and `MoveBeforeInTabOrder` allow to change it after creating all the
windows.
"""
return _core_.Window_MoveAfterInTabOrder(*args, **kwargs)
def MoveBeforeInTabOrder(*args, **kwargs):
"""
MoveBeforeInTabOrder(self, Window win)
Same as `MoveAfterInTabOrder` except that it inserts this window just
before win instead of putting it right after it.
"""
return _core_.Window_MoveBeforeInTabOrder(*args, **kwargs)
def GetChildren(*args, **kwargs):
"""
GetChildren(self) -> PyObject
Returns a list of the window's children. NOTE: Currently this is a
copy of the child window list maintained by the window, so the return
value of this function is only valid as long as the window's children
do not change.
"""
return _core_.Window_GetChildren(*args, **kwargs)
def GetParent(*args, **kwargs):
"""
GetParent(self) -> Window
Returns the parent window of this window, or None if there isn't one.
"""
return _core_.Window_GetParent(*args, **kwargs)
def GetGrandParent(*args, **kwargs):
"""
GetGrandParent(self) -> Window
Returns the parent of the parent of this window, or None if there
isn't one.
"""
return _core_.Window_GetGrandParent(*args, **kwargs)
def IsTopLevel(*args, **kwargs):
"""
IsTopLevel(self) -> bool
Returns true if the given window is a top-level one. Currently all
frames and dialogs are always considered to be top-level windows (even
if they have a parent window).
"""
return _core_.Window_IsTopLevel(*args, **kwargs)
def Reparent(*args, **kwargs):
"""
Reparent(self, Window newParent) -> bool
Reparents the window, i.e the window will be removed from its current
parent window (e.g. a non-standard toolbar in a wxFrame) and then
re-inserted into another. Available on Windows and GTK. Returns True
if the parent was changed, False otherwise (error or newParent ==
oldParent)
"""
return _core_.Window_Reparent(*args, **kwargs)
def AddChild(*args, **kwargs):
"""
AddChild(self, Window child)
Adds a child window. This is called automatically by window creation
functions so should not be required by the application programmer.
"""
return _core_.Window_AddChild(*args, **kwargs)
def RemoveChild(*args, **kwargs):
"""
RemoveChild(self, Window child)
Removes a child window. This is called automatically by window
deletion functions so should not be required by the application
programmer.
"""
return _core_.Window_RemoveChild(*args, **kwargs)
def FindWindowById(*args, **kwargs):
"""
FindWindowById(self, long winid) -> Window
Find a chld of this window by window ID
"""
return _core_.Window_FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
"""
FindWindowByName(self, String name) -> Window
Find a child of this window by name
"""
return _core_.Window_FindWindowByName(*args, **kwargs)
def GetEventHandler(*args, **kwargs):
"""
GetEventHandler(self) -> EvtHandler
Returns the event handler for this window. By default, the window is
its own event handler.
"""
return _core_.Window_GetEventHandler(*args, **kwargs)
def SetEventHandler(*args, **kwargs):
"""
SetEventHandler(self, EvtHandler handler)
Sets the event handler for this window. An event handler is an object
that is capable of processing the events sent to a window. By default,
the window is its own event handler, but an application may wish to
substitute another, for example to allow central implementation of
event-handling for a variety of different window classes.
It is usually better to use `wx.Window.PushEventHandler` since this sets
up a chain of event handlers, where an event not handled by one event
handler is handed to the next one in the chain.
"""
return _core_.Window_SetEventHandler(*args, **kwargs)
def PushEventHandler(*args, **kwargs):
"""
PushEventHandler(self, EvtHandler handler)
Pushes this event handler onto the event handler stack for the window.
An event handler is an object that is capable of processing the events
sent to a window. By default, the window is its own event handler, but
an application may wish to substitute another, for example to allow
central implementation of event-handling for a variety of different
window classes.
wx.Window.PushEventHandler allows an application to set up a chain of
event handlers, where an event not handled by one event handler is
handed to the next one in the chain. Use `wx.Window.PopEventHandler` to
remove the event handler.
"""
return _core_.Window_PushEventHandler(*args, **kwargs)
def PopEventHandler(*args, **kwargs):
"""
PopEventHandler(self, bool deleteHandler=False) -> EvtHandler
Removes and returns the top-most event handler on the event handler
stack. If deleteHandler is True then the wx.EvtHandler object will be
destroyed after it is popped.
"""
return _core_.Window_PopEventHandler(*args, **kwargs)
def RemoveEventHandler(*args, **kwargs):
"""
RemoveEventHandler(self, EvtHandler handler) -> bool
Find the given handler in the event handler chain and remove (but not
delete) it from the event handler chain, return True if it was found
and False otherwise (this also results in an assert failure so this
function should only be called when the handler is supposed to be
there.)
"""
return _core_.Window_RemoveEventHandler(*args, **kwargs)
def SetValidator(*args, **kwargs):
"""
SetValidator(self, Validator validator)
Deletes the current validator (if any) and sets the window validator,
having called wx.Validator.Clone to create a new validator of this
type.
"""
return _core_.Window_SetValidator(*args, **kwargs)
def GetValidator(*args, **kwargs):
"""
GetValidator(self) -> Validator
Returns a pointer to the current validator for the window, or None if
there is none.
"""
return _core_.Window_GetValidator(*args, **kwargs)
def Validate(*args, **kwargs):
"""
Validate(self) -> bool
Validates the current values of the child controls using their
validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra
style flag set, the method will also call Validate() of all child
windows. Returns false if any of the validations failed.
"""
return _core_.Window_Validate(*args, **kwargs)
def TransferDataToWindow(*args, **kwargs):
"""
TransferDataToWindow(self) -> bool
Transfers values to child controls from data areas specified by their
validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra
style flag set, the method will also call TransferDataToWindow() of
all child windows.
"""
return _core_.Window_TransferDataToWindow(*args, **kwargs)
def TransferDataFromWindow(*args, **kwargs):
"""
TransferDataFromWindow(self) -> bool
Transfers values from child controls to data areas specified by their
validators. Returns false if a transfer failed. If the window has
wx.WS_EX_VALIDATE_RECURSIVELY extra style flag set, the method will
also call TransferDataFromWindow() of all child windows.
"""
return _core_.Window_TransferDataFromWindow(*args, **kwargs)
def InitDialog(*args, **kwargs):
"""
InitDialog(self)
Sends an EVT_INIT_DIALOG event, whose handler usually transfers data
to the dialog via validators.
"""
return _core_.Window_InitDialog(*args, **kwargs)
def SetAcceleratorTable(*args, **kwargs):
"""
SetAcceleratorTable(self, AcceleratorTable accel)
Sets the accelerator table for this window.
"""
return _core_.Window_SetAcceleratorTable(*args, **kwargs)
def GetAcceleratorTable(*args, **kwargs):
"""
GetAcceleratorTable(self) -> AcceleratorTable
Gets the accelerator table for this window.
"""
return _core_.Window_GetAcceleratorTable(*args, **kwargs)
def RegisterHotKey(*args, **kwargs):
"""
RegisterHotKey(self, int hotkeyId, int modifiers, int keycode) -> bool
Registers a system wide hotkey. Every time the user presses the hotkey
registered here, this window will receive a hotkey event. It will
receive the event even if the application is in the background and
does not have the input focus because the user is working with some
other application. To bind an event handler function to this hotkey
use EVT_HOTKEY with an id equal to hotkeyId. Returns True if the
hotkey was registered successfully.
"""
return _core_.Window_RegisterHotKey(*args, **kwargs)
def UnregisterHotKey(*args, **kwargs):
"""
UnregisterHotKey(self, int hotkeyId) -> bool
Unregisters a system wide hotkey.
"""
return _core_.Window_UnregisterHotKey(*args, **kwargs)
def ConvertDialogPointToPixels(*args, **kwargs):
"""
ConvertDialogPointToPixels(self, Point pt) -> Point
Converts a point or size from dialog units to pixels. Dialog units
are used for maintaining a dialog's proportions even if the font
changes. For the x dimension, the dialog units are multiplied by the
average character width and then divided by 4. For the y dimension,
the dialog units are multiplied by the average character height and
then divided by 8.
"""
return _core_.Window_ConvertDialogPointToPixels(*args, **kwargs)
def ConvertDialogSizeToPixels(*args, **kwargs):
"""
ConvertDialogSizeToPixels(self, Size sz) -> Size
Converts a point or size from dialog units to pixels. Dialog units
are used for maintaining a dialog's proportions even if the font
changes. For the x dimension, the dialog units are multiplied by the
average character width and then divided by 4. For the y dimension,
the dialog units are multiplied by the average character height and
then divided by 8.
"""
return _core_.Window_ConvertDialogSizeToPixels(*args, **kwargs)
def DLG_PNT(*args, **kwargs):
"""
DLG_PNT(self, Point pt) -> Point
Converts a point or size from dialog units to pixels. Dialog units
are used for maintaining a dialog's proportions even if the font
changes. For the x dimension, the dialog units are multiplied by the
average character width and then divided by 4. For the y dimension,
the dialog units are multiplied by the average character height and
then divided by 8.
"""
return _core_.Window_DLG_PNT(*args, **kwargs)
def DLG_SZE(*args, **kwargs):
"""
DLG_SZE(self, Size sz) -> Size
Converts a point or size from dialog units to pixels. Dialog units
are used for maintaining a dialog's proportions even if the font
changes. For the x dimension, the dialog units are multiplied by the
average character width and then divided by 4. For the y dimension,
the dialog units are multiplied by the average character height and
then divided by 8.
"""
return _core_.Window_DLG_SZE(*args, **kwargs)
def ConvertPixelPointToDialog(*args, **kwargs):
"""ConvertPixelPointToDialog(self, Point pt) -> Point"""
return _core_.Window_ConvertPixelPointToDialog(*args, **kwargs)
def ConvertPixelSizeToDialog(*args, **kwargs):
"""ConvertPixelSizeToDialog(self, Size sz) -> Size"""
return _core_.Window_ConvertPixelSizeToDialog(*args, **kwargs)
def WarpPointer(*args, **kwargs):
"""
WarpPointer(self, int x, int y)
Moves the pointer to the given position on the window.
NOTE: This function is not supported under Mac because Apple Human
Interface Guidelines forbid moving the mouse cursor programmatically.
"""
return _core_.Window_WarpPointer(*args, **kwargs)
def CaptureMouse(*args, **kwargs):
"""
CaptureMouse(self)
Directs all mouse input to this window. Call wx.Window.ReleaseMouse to
release the capture.
Note that wxWindows maintains the stack of windows having captured the
mouse and when the mouse is released the capture returns to the window
which had had captured it previously and it is only really released if
there were no previous window. In particular, this means that you must
release the mouse as many times as you capture it.
"""
return _core_.Window_CaptureMouse(*args, **kwargs)
def ReleaseMouse(*args, **kwargs):
"""
ReleaseMouse(self)
Releases mouse input captured with wx.Window.CaptureMouse.
"""
return _core_.Window_ReleaseMouse(*args, **kwargs)
def GetCapture(*args, **kwargs):
"""
GetCapture() -> Window
Returns the window which currently captures the mouse or None
"""
return _core_.Window_GetCapture(*args, **kwargs)
GetCapture = staticmethod(GetCapture)
def HasCapture(*args, **kwargs):
"""
HasCapture(self) -> bool
Returns true if this window has the current mouse capture.
"""
return _core_.Window_HasCapture(*args, **kwargs)
def Refresh(*args, **kwargs):
"""
Refresh(self, bool eraseBackground=True, Rect rect=None)
Mark the specified rectangle (or the whole window) as "dirty" so it
will be repainted. Causes an EVT_PAINT event to be generated and sent
to the window.
"""
return _core_.Window_Refresh(*args, **kwargs)
def RefreshRect(*args, **kwargs):
"""
RefreshRect(self, Rect rect, bool eraseBackground=True)
Redraws the contents of the given rectangle: the area inside it will
be repainted. This is the same as Refresh but has a nicer syntax.
"""
return _core_.Window_RefreshRect(*args, **kwargs)
def Update(*args, **kwargs):
"""
Update(self)
Calling this method immediately repaints the invalidated area of the
window instead of waiting for the EVT_PAINT event to happen, (normally
this would usually only happen when the flow of control returns to the
event loop.) Notice that this function doesn't refresh the window and
does nothing if the window has been already repainted. Use Refresh
first if you want to immediately redraw the window (or some portion of
it) unconditionally.
"""
return _core_.Window_Update(*args, **kwargs)
def ClearBackground(*args, **kwargs):
"""
ClearBackground(self)
Clears the window by filling it with the current background
colour. Does not cause an erase background event to be generated.
"""
return _core_.Window_ClearBackground(*args, **kwargs)
def Freeze(*args, **kwargs):
"""
Freeze(self)
Freezes the window or, in other words, prevents any updates from
taking place on screen, the window is not redrawn at all. Thaw must be
called to reenable window redrawing. Calls to Freeze/Thaw may be
nested, with the actual Thaw being delayed until all the nesting has
been undone.
This method is useful for visual appearance optimization (for example,
it is a good idea to use it before inserting large amount of text into
a wxTextCtrl under wxGTK) but is not implemented on all platforms nor
for all controls so it is mostly just a hint to wxWindows and not a
mandatory directive.
"""
return _core_.Window_Freeze(*args, **kwargs)
def Thaw(*args, **kwargs):
"""
Thaw(self)
Reenables window updating after a previous call to Freeze. Calls to
Freeze/Thaw may be nested, so Thaw must be called the same number of
times that Freeze was before the window will be updated.
"""
return _core_.Window_Thaw(*args, **kwargs)
def PrepareDC(*args, **kwargs):
"""
PrepareDC(self, DC dc)
Call this function to prepare the device context for drawing a
scrolled image. It sets the device origin according to the current
scroll position.
"""
return _core_.Window_PrepareDC(*args, **kwargs)
def GetUpdateRegion(*args, **kwargs):
"""
GetUpdateRegion(self) -> Region
Returns the region specifying which parts of the window have been
damaged. Should only be called within an EVT_PAINT handler.
"""
return _core_.Window_GetUpdateRegion(*args, **kwargs)
def GetUpdateClientRect(*args, **kwargs):
"""
GetUpdateClientRect(self) -> Rect
Get the update rectangle region bounding box in client coords.
"""
return _core_.Window_GetUpdateClientRect(*args, **kwargs)
def IsExposed(*args, **kwargs):
"""
IsExposed(self, int x, int y, int w=1, int h=1) -> bool
Returns true if the given point or rectangle area has been exposed
since the last repaint. Call this in an paint event handler to
optimize redrawing by only redrawing those areas, which have been
exposed.
"""
return _core_.Window_IsExposed(*args, **kwargs)
def IsExposedPoint(*args, **kwargs):
"""
IsExposedPoint(self, Point pt) -> bool
Returns true if the given point or rectangle area has been exposed
since the last repaint. Call this in an paint event handler to
optimize redrawing by only redrawing those areas, which have been
exposed.
"""
return _core_.Window_IsExposedPoint(*args, **kwargs)
def IsExposedRect(*args, **kwargs):
"""
IsExposedRect(self, Rect rect) -> bool
Returns true if the given point or rectangle area has been exposed
since the last repaint. Call this in an paint event handler to
optimize redrawing by only redrawing those areas, which have been
exposed.
"""
return _core_.Window_IsExposedRect(*args, **kwargs)
def GetDefaultAttributes(*args, **kwargs):
"""
GetDefaultAttributes(self) -> VisualAttributes
Get the default attributes for an instance of this class. This is
useful if you want to use the same font or colour in your own control
as in a standard control -- which is a much better idea than hard
coding specific colours or fonts which might look completely out of
place on the user's system, especially if it uses themes.
"""
return _core_.Window_GetDefaultAttributes(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _core_.Window_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
def SetBackgroundColour(*args, **kwargs):
"""
SetBackgroundColour(self, Colour colour) -> bool
Sets the background colour of the window. Returns True if the colour
was changed. The background colour is usually painted by the default
EVT_ERASE_BACKGROUND event handler function under Windows and
automatically under GTK. Using `wx.NullColour` will reset the window
to the default background colour.
Note that setting the background colour may not cause an immediate
refresh, so you may wish to call `ClearBackground` or `Refresh` after
calling this function.
Using this function will disable attempts to use themes for this
window, if the system supports them. Use with care since usually the
themes represent the appearance chosen by the user to be used for all
applications on the system.
"""
return _core_.Window_SetBackgroundColour(*args, **kwargs)
def SetOwnBackgroundColour(*args, **kwargs):
"""SetOwnBackgroundColour(self, Colour colour)"""
return _core_.Window_SetOwnBackgroundColour(*args, **kwargs)
def SetForegroundColour(*args, **kwargs):
"""
SetForegroundColour(self, Colour colour) -> bool
Sets the foreground colour of the window. Returns True is the colour
was changed. The interpretation of foreground colour is dependent on
the window class; it may be the text colour or other colour, or it may
not be used at all.
"""
return _core_.Window_SetForegroundColour(*args, **kwargs)
def SetOwnForegroundColour(*args, **kwargs):
"""SetOwnForegroundColour(self, Colour colour)"""
return _core_.Window_SetOwnForegroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
"""
GetBackgroundColour(self) -> Colour
Returns the background colour of the window.
"""
return _core_.Window_GetBackgroundColour(*args, **kwargs)
def GetForegroundColour(*args, **kwargs):
"""
GetForegroundColour(self) -> Colour
Returns the foreground colour of the window. The interpretation of
foreground colour is dependent on the window class; it may be the text
colour or other colour, or it may not be used at all.
"""
return _core_.Window_GetForegroundColour(*args, **kwargs)
def InheritsBackgroundColour(*args, **kwargs):
"""InheritsBackgroundColour(self) -> bool"""
return _core_.Window_InheritsBackgroundColour(*args, **kwargs)
def UseBgCol(*args, **kwargs):
"""UseBgCol(self) -> bool"""
return _core_.Window_UseBgCol(*args, **kwargs)
def SetBackgroundStyle(*args, **kwargs):
"""
SetBackgroundStyle(self, int style) -> bool
Returns the background style of the window. The background style
indicates how the background of the window is drawn.
====================== ========================================
wx.BG_STYLE_SYSTEM The background colour or pattern should
be determined by the system
wx.BG_STYLE_COLOUR The background should be a solid colour
wx.BG_STYLE_CUSTOM The background will be implemented by the
application.
====================== ========================================
On GTK+, use of wx.BG_STYLE_CUSTOM allows the flicker-free drawing of
a custom background, such as a tiled bitmap. Currently the style has
no effect on other platforms.
:see: `GetBackgroundStyle`, `SetBackgroundColour`
"""
return _core_.Window_SetBackgroundStyle(*args, **kwargs)
def GetBackgroundStyle(*args, **kwargs):
"""
GetBackgroundStyle(self) -> int
Returns the background style of the window.
:see: `SetBackgroundStyle`
"""
return _core_.Window_GetBackgroundStyle(*args, **kwargs)
def HasTransparentBackground(*args, **kwargs):
"""
HasTransparentBackground(self) -> bool
Returns True if this window's background is transparent (as, for
example, for `wx.StaticText`) and should show the parent window's
background.
This method is mostly used internally by the library itself and you
normally shouldn't have to call it. You may, however, have to override
it in your custom control classes to ensure that background is painted
correctly.
"""
return _core_.Window_HasTransparentBackground(*args, **kwargs)
def SetCursor(*args, **kwargs):
"""
SetCursor(self, Cursor cursor) -> bool
Sets the window's cursor. Notice that the window cursor also sets it
for the children of the window implicitly.
The cursor may be wx.NullCursor in which case the window cursor will
be reset back to default.
"""
return _core_.Window_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
"""
GetCursor(self) -> Cursor
Return the cursor associated with this window.
"""
return _core_.Window_GetCursor(*args, **kwargs)
def SetFont(*args, **kwargs):
"""
SetFont(self, Font font) -> bool
Sets the font for this window.
"""
return _core_.Window_SetFont(*args, **kwargs)
def SetOwnFont(*args, **kwargs):
"""SetOwnFont(self, Font font)"""
return _core_.Window_SetOwnFont(*args, **kwargs)
def GetFont(*args, **kwargs):
"""
GetFont(self) -> Font
Returns the default font used for this window.
"""
return _core_.Window_GetFont(*args, **kwargs)
def SetCaret(*args, **kwargs):
"""
SetCaret(self, Caret caret)
Sets the caret associated with the window.
"""
return _core_.Window_SetCaret(*args, **kwargs)
def GetCaret(*args, **kwargs):
"""
GetCaret(self) -> Caret
Returns the caret associated with the window.
"""
return _core_.Window_GetCaret(*args, **kwargs)
def GetCharHeight(*args, **kwargs):
"""
GetCharHeight(self) -> int
Get the (average) character size for the current font.
"""
return _core_.Window_GetCharHeight(*args, **kwargs)
def GetCharWidth(*args, **kwargs):
"""
GetCharWidth(self) -> int
Get the (average) character size for the current font.
"""
return _core_.Window_GetCharWidth(*args, **kwargs)
def GetTextExtent(*args, **kwargs):
"""
GetTextExtent(String string) -> (width, height)
Get the width and height of the text using the current font.
"""
return _core_.Window_GetTextExtent(*args, **kwargs)
def GetFullTextExtent(*args, **kwargs):
"""
GetFullTextExtent(String string, Font font=None) ->
(width, height, descent, externalLeading)
Get the width, height, decent and leading of the text using the
current or specified font.
"""
return _core_.Window_GetFullTextExtent(*args, **kwargs)
def ClientToScreenXY(*args, **kwargs):
"""
ClientToScreenXY(int x, int y) -> (x,y)
Converts to screen coordinates from coordinates relative to this window.
"""
return _core_.Window_ClientToScreenXY(*args, **kwargs)
def ScreenToClientXY(*args, **kwargs):
"""
ScreenToClientXY(int x, int y) -> (x,y)
Converts from screen to client window coordinates.
"""
return _core_.Window_ScreenToClientXY(*args, **kwargs)
def ClientToScreen(*args, **kwargs):
"""
ClientToScreen(self, Point pt) -> Point
Converts to screen coordinates from coordinates relative to this window.
"""
return _core_.Window_ClientToScreen(*args, **kwargs)
def ScreenToClient(*args, **kwargs):
"""
ScreenToClient(self, Point pt) -> Point
Converts from screen to client window coordinates.
"""
return _core_.Window_ScreenToClient(*args, **kwargs)
def HitTestXY(*args, **kwargs):
"""
HitTestXY(self, int x, int y) -> int
Test where the given (in client coords) point lies
"""
return _core_.Window_HitTestXY(*args, **kwargs)
def HitTest(*args, **kwargs):
"""
HitTest(self, Point pt) -> int
Test where the given (in client coords) point lies
"""
return _core_.Window_HitTest(*args, **kwargs)
def GetBorder(*args):
"""
GetBorder(self, long flags) -> int
GetBorder(self) -> int
Get border for the flags of this window
"""
return _core_.Window_GetBorder(*args)
def UpdateWindowUI(*args, **kwargs):
"""
UpdateWindowUI(self, long flags=UPDATE_UI_NONE)
This function sends EVT_UPDATE_UI events to the window. The particular
implementation depends on the window; for example a wx.ToolBar will
send an update UI event for each toolbar button, and a wx.Frame will
send an update UI event for each menubar menu item. You can call this
function from your application to ensure that your UI is up-to-date at
a particular point in time (as far as your EVT_UPDATE_UI handlers are
concerned). This may be necessary if you have called
`wx.UpdateUIEvent.SetMode` or `wx.UpdateUIEvent.SetUpdateInterval` to
limit the overhead that wxWindows incurs by sending update UI events
in idle time.
"""
return _core_.Window_UpdateWindowUI(*args, **kwargs)
def PopupMenuXY(*args, **kwargs):
"""
PopupMenuXY(self, Menu menu, int x=-1, int y=-1) -> bool
Pops up the given menu at the specified coordinates, relative to this window,
and returns control when the user has dismissed the menu. If a menu item is
selected, the corresponding menu event is generated and will be processed as
usual. If the default position is given then the current position of the
mouse cursor will be used.
"""
return _core_.Window_PopupMenuXY(*args, **kwargs)
def PopupMenu(*args, **kwargs):
"""
PopupMenu(self, Menu menu, Point pos=DefaultPosition) -> bool
Pops up the given menu at the specified coordinates, relative to this window,
and returns control when the user has dismissed the menu. If a menu item is
selected, the corresponding menu event is generated and will be processed as
usual. If the default position is given then the current position of the
mouse cursor will be used.
"""
return _core_.Window_PopupMenu(*args, **kwargs)
def GetHandle(*args, **kwargs):
"""
GetHandle(self) -> long
Returns the platform-specific handle (as a long integer) of the
physical window. Currently on wxMac it returns the handle of the
toplevel parent of the window.
"""
return _core_.Window_GetHandle(*args, **kwargs)
def AssociateHandle(*args, **kwargs):
"""
AssociateHandle(self, long handle)
Associate the window with a new native handle
"""
return _core_.Window_AssociateHandle(*args, **kwargs)
def DissociateHandle(*args, **kwargs):
"""
DissociateHandle(self)
Dissociate the current native handle from the window
"""
return _core_.Window_DissociateHandle(*args, **kwargs)
def HasScrollbar(*args, **kwargs):
"""
HasScrollbar(self, int orient) -> bool
Does the window have the scrollbar for this orientation?
"""
return _core_.Window_HasScrollbar(*args, **kwargs)
def SetScrollbar(*args, **kwargs):
"""
SetScrollbar(self, int orientation, int position, int thumbSize, int range,
bool refresh=True)
Sets the scrollbar properties of a built-in scrollbar.
"""
return _core_.Window_SetScrollbar(*args, **kwargs)
def SetScrollPos(*args, **kwargs):
"""
SetScrollPos(self, int orientation, int pos, bool refresh=True)
Sets the position of one of the built-in scrollbars.
"""
return _core_.Window_SetScrollPos(*args, **kwargs)
def GetScrollPos(*args, **kwargs):
"""
GetScrollPos(self, int orientation) -> int
Returns the built-in scrollbar position.
"""
return _core_.Window_GetScrollPos(*args, **kwargs)
def GetScrollThumb(*args, **kwargs):
"""
GetScrollThumb(self, int orientation) -> int
Returns the built-in scrollbar thumb size.
"""
return _core_.Window_GetScrollThumb(*args, **kwargs)
def GetScrollRange(*args, **kwargs):
"""
GetScrollRange(self, int orientation) -> int
Returns the built-in scrollbar range.
"""
return _core_.Window_GetScrollRange(*args, **kwargs)
def ScrollWindow(*args, **kwargs):
"""
ScrollWindow(self, int dx, int dy, Rect rect=None)
Physically scrolls the pixels in the window and move child windows
accordingly. Use this function to optimise your scrolling
implementations, to minimise the area that must be redrawn. Note that
it is rarely required to call this function from a user program.
"""
return _core_.Window_ScrollWindow(*args, **kwargs)
def ScrollLines(*args, **kwargs):
"""
ScrollLines(self, int lines) -> bool
If the platform and window class supports it, scrolls the window by
the given number of lines down, if lines is positive, or up if lines
is negative. Returns True if the window was scrolled, False if it was
already on top/bottom and nothing was done.
"""
return _core_.Window_ScrollLines(*args, **kwargs)
def ScrollPages(*args, **kwargs):
"""
ScrollPages(self, int pages) -> bool
If the platform and window class supports it, scrolls the window by
the given number of pages down, if pages is positive, or up if pages
is negative. Returns True if the window was scrolled, False if it was
already on top/bottom and nothing was done.
"""
return _core_.Window_ScrollPages(*args, **kwargs)
def LineUp(*args, **kwargs):
"""
LineUp(self) -> bool
This is just a wrapper for ScrollLines(-1).
"""
return _core_.Window_LineUp(*args, **kwargs)
def LineDown(*args, **kwargs):
"""
LineDown(self) -> bool
This is just a wrapper for ScrollLines(1).
"""
return _core_.Window_LineDown(*args, **kwargs)
def PageUp(*args, **kwargs):
"""
PageUp(self) -> bool
This is just a wrapper for ScrollPages(-1).
"""
return _core_.Window_PageUp(*args, **kwargs)
def PageDown(*args, **kwargs):
"""
PageDown(self) -> bool
This is just a wrapper for ScrollPages(1).
"""
return _core_.Window_PageDown(*args, **kwargs)
def SetHelpText(*args, **kwargs):
"""
SetHelpText(self, String text)
Sets the help text to be used as context-sensitive help for this
window. Note that the text is actually stored by the current
wxHelpProvider implementation, and not in the window object itself.
"""
return _core_.Window_SetHelpText(*args, **kwargs)
def SetHelpTextForId(*args, **kwargs):
"""
SetHelpTextForId(self, String text)
Associate this help text with all windows with the same id as this
one.
"""
return _core_.Window_SetHelpTextForId(*args, **kwargs)
def GetHelpText(*args, **kwargs):
"""
GetHelpText(self) -> String
Gets the help text to be used as context-sensitive help for this
window. Note that the text is actually stored by the current
wxHelpProvider implementation, and not in the window object itself.
"""
return _core_.Window_GetHelpText(*args, **kwargs)
def SetToolTipString(*args, **kwargs):
"""
SetToolTipString(self, String tip)
Attach a tooltip to the window.
"""
return _core_.Window_SetToolTipString(*args, **kwargs)
def SetToolTip(*args, **kwargs):
"""
SetToolTip(self, ToolTip tip)
Attach a tooltip to the window.
"""
return _core_.Window_SetToolTip(*args, **kwargs)
def GetToolTip(*args, **kwargs):
"""
GetToolTip(self) -> ToolTip
get the associated tooltip or None if none
"""
return _core_.Window_GetToolTip(*args, **kwargs)
def SetDropTarget(*args, **kwargs):
"""
SetDropTarget(self, DropTarget dropTarget)
Associates a drop target with this window. If the window already has
a drop target, it is deleted.
"""
return _core_.Window_SetDropTarget(*args, **kwargs)
def GetDropTarget(*args, **kwargs):
"""
GetDropTarget(self) -> DropTarget
Returns the associated drop target, which may be None.
"""
return _core_.Window_GetDropTarget(*args, **kwargs)
def DragAcceptFiles(*args, **kwargs):
"""
DragAcceptFiles(self, bool accept)
Enables or disables eligibility for drop file events, EVT_DROP_FILES.
Only functional on Windows.
"""
return _core_.Window_DragAcceptFiles(*args, **kwargs)
def SetConstraints(*args, **kwargs):
"""
SetConstraints(self, LayoutConstraints constraints)
Sets the window to have the given layout constraints. If an existing
layout constraints object is already owned by the window, it will be
deleted. Pass None to disassociate and delete the window's current
constraints.
You must call SetAutoLayout to tell a window to use the constraints
automatically in its default EVT_SIZE handler; otherwise, you must
handle EVT_SIZE yourself and call Layout() explicitly. When setting
both a wx.LayoutConstraints and a wx.Sizer, only the sizer will have
effect.
"""
return _core_.Window_SetConstraints(*args, **kwargs)
def GetConstraints(*args, **kwargs):
"""
GetConstraints(self) -> LayoutConstraints
Returns a pointer to the window's layout constraints, or None if there
are none.
"""
return _core_.Window_GetConstraints(*args, **kwargs)
def SetAutoLayout(*args, **kwargs):
"""
SetAutoLayout(self, bool autoLayout)
Determines whether the Layout function will be called automatically
when the window is resized. It is called implicitly by SetSizer but
if you use SetConstraints you should call it manually or otherwise the
window layout won't be correctly updated when its size changes.
"""
return _core_.Window_SetAutoLayout(*args, **kwargs)
def GetAutoLayout(*args, **kwargs):
"""
GetAutoLayout(self) -> bool
Returns the current autoLayout setting
"""
return _core_.Window_GetAutoLayout(*args, **kwargs)
def Layout(*args, **kwargs):
"""
Layout(self) -> bool
Invokes the constraint-based layout algorithm or the sizer-based
algorithm for this window. See SetAutoLayout: when auto layout is on,
this function gets called automatically by the default EVT_SIZE
handler when the window is resized.
"""
return _core_.Window_Layout(*args, **kwargs)
def SetSizer(*args, **kwargs):
"""
SetSizer(self, Sizer sizer, bool deleteOld=True)
Sets the window to have the given layout sizer. The window will then
own the object, and will take care of its deletion. If an existing
layout sizer object is already owned by the window, it will be deleted
if the deleteOld parameter is true. Note that this function will also
call SetAutoLayout implicitly with a True parameter if the sizer is
non-None, and False otherwise.
"""
return _core_.Window_SetSizer(*args, **kwargs)
def SetSizerAndFit(*args, **kwargs):
"""
SetSizerAndFit(self, Sizer sizer, bool deleteOld=True)
The same as SetSizer, except it also sets the size hints for the
window based on the sizer's minimum size.
"""
return _core_.Window_SetSizerAndFit(*args, **kwargs)
def GetSizer(*args, **kwargs):
"""
GetSizer(self) -> Sizer
Return the sizer associated with the window by a previous call to
SetSizer or None if there isn't one.
"""
return _core_.Window_GetSizer(*args, **kwargs)
def SetContainingSizer(*args, **kwargs):
"""
SetContainingSizer(self, Sizer sizer)
This normally does not need to be called by application code. It is
called internally when a window is added to a sizer, and is used so
the window can remove itself from the sizer when it is destroyed.
"""
return _core_.Window_SetContainingSizer(*args, **kwargs)
def GetContainingSizer(*args, **kwargs):
"""
GetContainingSizer(self) -> Sizer
Return the sizer that this window is a member of, if any, otherwise None.
"""
return _core_.Window_GetContainingSizer(*args, **kwargs)
def InheritAttributes(*args, **kwargs):
"""
InheritAttributes(self)
This function is (or should be, in case of custom controls) called
during window creation to intelligently set up the window visual
attributes, that is the font and the foreground and background
colours.
By 'intelligently' the following is meant: by default, all windows use
their own default attributes. However if some of the parent's
attributes are explicitly changed (that is, using SetFont and not
SetOwnFont) and if the corresponding attribute hadn't been
explicitly set for this window itself, then this window takes the same
value as used by the parent. In addition, if the window overrides
ShouldInheritColours to return false, the colours will not be changed
no matter what and only the font might.
This rather complicated logic is necessary in order to accommodate the
different usage scenarios. The most common one is when all default
attributes are used and in this case, nothing should be inherited as
in modern GUIs different controls use different fonts (and colours)
than their siblings so they can't inherit the same value from the
parent. However it was also deemed desirable to allow to simply change
the attributes of all children at once by just changing the font or
colour of their common parent, hence in this case we do inherit the
parents attributes.
"""
return _core_.Window_InheritAttributes(*args, **kwargs)
def ShouldInheritColours(*args, **kwargs):
"""
ShouldInheritColours(self) -> bool
Return true from here to allow the colours of this window to be
changed by InheritAttributes, returning false forbids inheriting them
from the parent window.
The base class version returns false, but this method is overridden in
wxControl where it returns true.
"""
return _core_.Window_ShouldInheritColours(*args, **kwargs)
def PostCreate(self, pre):
"""
Phase 3 of the 2-phase create <wink!>
Call this method after precreating the window with the 2-phase create method.
"""
self.this = pre.this
self.thisown = pre.thisown
pre.thisown = 0
if hasattr(self, '_setOORInfo'):
self._setOORInfo(self)
if hasattr(self, '_setCallbackInfo'):
self._setCallbackInfo(self, self.__class__)
def SendSizeEvent(self):
self.GetEventhandler().ProcessEvent(wx.SizeEvent((-1,-1)))
class WindowPtr(Window):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Window
_core_.Window_swigregister(WindowPtr)
def PreWindow(*args, **kwargs):
"""
PreWindow() -> Window
Precreate a Window for 2-phase creation.
"""
val = _core_.new_PreWindow(*args, **kwargs)
val.thisown = 1
return val
def Window_NewControlId(*args, **kwargs):
"""
Window_NewControlId() -> int
Generate a control id for the controls which were not given one.
"""
return _core_.Window_NewControlId(*args, **kwargs)
def Window_NextControlId(*args, **kwargs):
"""
Window_NextControlId(int winid) -> int
Get the id of the control following the one with the given
autogenerated) id
"""
return _core_.Window_NextControlId(*args, **kwargs)
def Window_PrevControlId(*args, **kwargs):
"""
Window_PrevControlId(int winid) -> int
Get the id of the control preceding the one with the given
autogenerated) id
"""
return _core_.Window_PrevControlId(*args, **kwargs)
def Window_FindFocus(*args, **kwargs):
"""
Window_FindFocus() -> Window
Returns the window or control that currently has the keyboard focus,
or None.
"""
return _core_.Window_FindFocus(*args, **kwargs)
def Window_GetCapture(*args, **kwargs):
"""
Window_GetCapture() -> Window
Returns the window which currently captures the mouse or None
"""
return _core_.Window_GetCapture(*args, **kwargs)
def Window_GetClassDefaultAttributes(*args, **kwargs):
"""
Window_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _core_.Window_GetClassDefaultAttributes(*args, **kwargs)
def DLG_PNT(win, point_or_x, y=None):
"""
Convenience function for converting a Point or (x,y) in
dialog units to pixel units.
"""
if y is None:
return win.ConvertDialogPointToPixels(point_or_x)
else:
return win.ConvertDialogPointToPixels(wx.Point(point_or_x, y))
def DLG_SZE(win, size_width, height=None):
"""
Convenience function for converting a Size or (w,h) in
dialog units to pixel units.
"""
if height is None:
return win.ConvertDialogSizeToPixels(size_width)
else:
return win.ConvertDialogSizeToPixels(wx.Size(size_width, height))
def FindWindowById(*args, **kwargs):
"""
FindWindowById(long id, Window parent=None) -> Window
Find the first window in the application with the given id. If parent
is None, the search will start from all top-level frames and dialog
boxes; if non-None, the search will be limited to the given window
hierarchy. The search is recursive in both cases.
"""
return _core_.FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
"""
FindWindowByName(String name, Window parent=None) -> Window
Find a window by its name (as given in a window constructor or Create
function call). If parent is None, the search will start from all
top-level frames and dialog boxes; if non-None, the search will be
limited to the given window hierarchy. The search is recursive in both
cases.
If no window with such name is found, wx.FindWindowByLabel is called.
"""
return _core_.FindWindowByName(*args, **kwargs)
def FindWindowByLabel(*args, **kwargs):
"""
FindWindowByLabel(String label, Window parent=None) -> Window
Find a window by its label. Depending on the type of window, the label
may be a window title or panel item label. If parent is None, the
search will start from all top-level frames and dialog boxes; if
non-None, the search will be limited to the given window
hierarchy. The search is recursive in both cases.
"""
return _core_.FindWindowByLabel(*args, **kwargs)
def Window_FromHWND(*args, **kwargs):
"""Window_FromHWND(Window parent, unsigned long _hWnd) -> Window"""
return _core_.Window_FromHWND(*args, **kwargs)
def GetTopLevelWindows(*args, **kwargs):
"""
GetTopLevelWindows() -> PyObject
Returns a list of the the application's top-level windows, (frames,
dialogs, etc.) NOTE: Currently this is a copy of the list maintained
by wxWidgets, and so it is only valid as long as no top-level windows
are closed or new top-level windows are created.
"""
return _core_.GetTopLevelWindows(*args, **kwargs)
#---------------------------------------------------------------------------
class Validator(EvtHandler):
"""Proxy of C++ Validator class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxValidator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> Validator"""
newobj = _core_.new_Validator(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def Clone(*args, **kwargs):
"""Clone(self) -> Validator"""
return _core_.Validator_Clone(*args, **kwargs)
def Validate(*args, **kwargs):
"""Validate(self, Window parent) -> bool"""
return _core_.Validator_Validate(*args, **kwargs)
def TransferToWindow(*args, **kwargs):
"""TransferToWindow(self) -> bool"""
return _core_.Validator_TransferToWindow(*args, **kwargs)
def TransferFromWindow(*args, **kwargs):
"""TransferFromWindow(self) -> bool"""
return _core_.Validator_TransferFromWindow(*args, **kwargs)
def GetWindow(*args, **kwargs):
"""GetWindow(self) -> Window"""
return _core_.Validator_GetWindow(*args, **kwargs)
def SetWindow(*args, **kwargs):
"""SetWindow(self, Window window)"""
return _core_.Validator_SetWindow(*args, **kwargs)
def IsSilent(*args, **kwargs):
"""IsSilent() -> bool"""
return _core_.Validator_IsSilent(*args, **kwargs)
IsSilent = staticmethod(IsSilent)
def SetBellOnError(*args, **kwargs):
"""SetBellOnError(int doIt=True)"""
return _core_.Validator_SetBellOnError(*args, **kwargs)
SetBellOnError = staticmethod(SetBellOnError)
class ValidatorPtr(Validator):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Validator
_core_.Validator_swigregister(ValidatorPtr)
def Validator_IsSilent(*args, **kwargs):
"""Validator_IsSilent() -> bool"""
return _core_.Validator_IsSilent(*args, **kwargs)
def Validator_SetBellOnError(*args, **kwargs):
"""Validator_SetBellOnError(int doIt=True)"""
return _core_.Validator_SetBellOnError(*args, **kwargs)
class PyValidator(Validator):
"""Proxy of C++ PyValidator class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyValidator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> PyValidator"""
newobj = _core_.new_PyValidator(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PyValidator, 1)
self._setOORInfo(self)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class, int incref=True)"""
return _core_.PyValidator__setCallbackInfo(*args, **kwargs)
class PyValidatorPtr(PyValidator):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PyValidator
_core_.PyValidator_swigregister(PyValidatorPtr)
#---------------------------------------------------------------------------
class Menu(EvtHandler):
"""Proxy of C++ Menu class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, String title=EmptyString, long style=0) -> Menu"""
newobj = _core_.new_Menu(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def Append(*args, **kwargs):
"""Append(self, int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) -> MenuItem"""
return _core_.Menu_Append(*args, **kwargs)
def AppendSeparator(*args, **kwargs):
"""AppendSeparator(self) -> MenuItem"""
return _core_.Menu_AppendSeparator(*args, **kwargs)
def AppendCheckItem(*args, **kwargs):
"""AppendCheckItem(self, int id, String text, String help=EmptyString) -> MenuItem"""
return _core_.Menu_AppendCheckItem(*args, **kwargs)
def AppendRadioItem(*args, **kwargs):
"""AppendRadioItem(self, int id, String text, String help=EmptyString) -> MenuItem"""
return _core_.Menu_AppendRadioItem(*args, **kwargs)
def AppendMenu(*args, **kwargs):
"""AppendMenu(self, int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core_.Menu_AppendMenu(*args, **kwargs)
def AppendItem(*args, **kwargs):
"""AppendItem(self, MenuItem item) -> MenuItem"""
return _core_.Menu_AppendItem(*args, **kwargs)
def Break(*args, **kwargs):
"""Break(self)"""
return _core_.Menu_Break(*args, **kwargs)
def InsertItem(*args, **kwargs):
"""InsertItem(self, size_t pos, MenuItem item) -> MenuItem"""
return _core_.Menu_InsertItem(*args, **kwargs)
def Insert(*args, **kwargs):
"""
Insert(self, size_t pos, int id, String text, String help=EmptyString,
int kind=ITEM_NORMAL) -> MenuItem
"""
return _core_.Menu_Insert(*args, **kwargs)
def InsertSeparator(*args, **kwargs):
"""InsertSeparator(self, size_t pos) -> MenuItem"""
return _core_.Menu_InsertSeparator(*args, **kwargs)
def InsertCheckItem(*args, **kwargs):
"""InsertCheckItem(self, size_t pos, int id, String text, String help=EmptyString) -> MenuItem"""
return _core_.Menu_InsertCheckItem(*args, **kwargs)
def InsertRadioItem(*args, **kwargs):
"""InsertRadioItem(self, size_t pos, int id, String text, String help=EmptyString) -> MenuItem"""
return _core_.Menu_InsertRadioItem(*args, **kwargs)
def InsertMenu(*args, **kwargs):
"""InsertMenu(self, size_t pos, int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core_.Menu_InsertMenu(*args, **kwargs)
def PrependItem(*args, **kwargs):
"""PrependItem(self, MenuItem item) -> MenuItem"""
return _core_.Menu_PrependItem(*args, **kwargs)
def Prepend(*args, **kwargs):
"""Prepend(self, int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) -> MenuItem"""
return _core_.Menu_Prepend(*args, **kwargs)
def PrependSeparator(*args, **kwargs):
"""PrependSeparator(self) -> MenuItem"""
return _core_.Menu_PrependSeparator(*args, **kwargs)
def PrependCheckItem(*args, **kwargs):
"""PrependCheckItem(self, int id, String text, String help=EmptyString) -> MenuItem"""
return _core_.Menu_PrependCheckItem(*args, **kwargs)
def PrependRadioItem(*args, **kwargs):
"""PrependRadioItem(self, int id, String text, String help=EmptyString) -> MenuItem"""
return _core_.Menu_PrependRadioItem(*args, **kwargs)
def PrependMenu(*args, **kwargs):
"""PrependMenu(self, int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core_.Menu_PrependMenu(*args, **kwargs)
def Remove(*args, **kwargs):
"""Remove(self, int id) -> MenuItem"""
return _core_.Menu_Remove(*args, **kwargs)
def RemoveItem(*args, **kwargs):
"""RemoveItem(self, MenuItem item) -> MenuItem"""
return _core_.Menu_RemoveItem(*args, **kwargs)
def Delete(*args, **kwargs):
"""Delete(self, int id) -> bool"""
return _core_.Menu_Delete(*args, **kwargs)
def DeleteItem(*args, **kwargs):
"""DeleteItem(self, MenuItem item) -> bool"""
return _core_.Menu_DeleteItem(*args, **kwargs)
def Destroy(*args, **kwargs):
"""
Destroy(self)
Deletes the C++ object this Python object is a proxy for.
"""
return _core_.Menu_Destroy(*args, **kwargs)
def DestroyId(*args, **kwargs):
"""
DestroyId(self, int id) -> bool
Deletes the C++ object this Python object is a proxy for.
"""
return _core_.Menu_DestroyId(*args, **kwargs)
def DestroyItem(*args, **kwargs):
"""
DestroyItem(self, MenuItem item) -> bool
Deletes the C++ object this Python object is a proxy for.
"""
return _core_.Menu_DestroyItem(*args, **kwargs)
def GetMenuItemCount(*args, **kwargs):
"""GetMenuItemCount(self) -> size_t"""
return _core_.Menu_GetMenuItemCount(*args, **kwargs)
def GetMenuItems(*args, **kwargs):
"""GetMenuItems(self) -> PyObject"""
return _core_.Menu_GetMenuItems(*args, **kwargs)
def FindItem(*args, **kwargs):
"""FindItem(self, String item) -> int"""
return _core_.Menu_FindItem(*args, **kwargs)
def FindItemById(*args, **kwargs):
"""FindItemById(self, int id) -> MenuItem"""
return _core_.Menu_FindItemById(*args, **kwargs)
def FindItemByPosition(*args, **kwargs):
"""FindItemByPosition(self, size_t position) -> MenuItem"""
return _core_.Menu_FindItemByPosition(*args, **kwargs)
def Enable(*args, **kwargs):
"""Enable(self, int id, bool enable)"""
return _core_.Menu_Enable(*args, **kwargs)
def IsEnabled(*args, **kwargs):
"""IsEnabled(self, int id) -> bool"""
return _core_.Menu_IsEnabled(*args, **kwargs)
def Check(*args, **kwargs):
"""Check(self, int id, bool check)"""
return _core_.Menu_Check(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""IsChecked(self, int id) -> bool"""
return _core_.Menu_IsChecked(*args, **kwargs)
def SetLabel(*args, **kwargs):
"""SetLabel(self, int id, String label)"""
return _core_.Menu_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""GetLabel(self, int id) -> String"""
return _core_.Menu_GetLabel(*args, **kwargs)
def SetHelpString(*args, **kwargs):
"""SetHelpString(self, int id, String helpString)"""
return _core_.Menu_SetHelpString(*args, **kwargs)
def GetHelpString(*args, **kwargs):
"""GetHelpString(self, int id) -> String"""
return _core_.Menu_GetHelpString(*args, **kwargs)
def SetTitle(*args, **kwargs):
"""SetTitle(self, String title)"""
return _core_.Menu_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
"""GetTitle(self) -> String"""
return _core_.Menu_GetTitle(*args, **kwargs)
def SetEventHandler(*args, **kwargs):
"""SetEventHandler(self, EvtHandler handler)"""
return _core_.Menu_SetEventHandler(*args, **kwargs)
def GetEventHandler(*args, **kwargs):
"""GetEventHandler(self) -> EvtHandler"""
return _core_.Menu_GetEventHandler(*args, **kwargs)
def SetInvokingWindow(*args, **kwargs):
"""SetInvokingWindow(self, Window win)"""
return _core_.Menu_SetInvokingWindow(*args, **kwargs)
def GetInvokingWindow(*args, **kwargs):
"""GetInvokingWindow(self) -> Window"""
return _core_.Menu_GetInvokingWindow(*args, **kwargs)
def GetStyle(*args, **kwargs):
"""GetStyle(self) -> long"""
return _core_.Menu_GetStyle(*args, **kwargs)
def UpdateUI(*args, **kwargs):
"""UpdateUI(self, EvtHandler source=None)"""
return _core_.Menu_UpdateUI(*args, **kwargs)
def GetMenuBar(*args, **kwargs):
"""GetMenuBar(self) -> MenuBar"""
return _core_.Menu_GetMenuBar(*args, **kwargs)
def Attach(*args, **kwargs):
"""Attach(self, wxMenuBarBase menubar)"""
return _core_.Menu_Attach(*args, **kwargs)
def Detach(*args, **kwargs):
"""Detach(self)"""
return _core_.Menu_Detach(*args, **kwargs)
def IsAttached(*args, **kwargs):
"""IsAttached(self) -> bool"""
return _core_.Menu_IsAttached(*args, **kwargs)
def SetParent(*args, **kwargs):
"""SetParent(self, Menu parent)"""
return _core_.Menu_SetParent(*args, **kwargs)
def GetParent(*args, **kwargs):
"""GetParent(self) -> Menu"""
return _core_.Menu_GetParent(*args, **kwargs)
class MenuPtr(Menu):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Menu
_core_.Menu_swigregister(MenuPtr)
DefaultValidator = cvar.DefaultValidator
#---------------------------------------------------------------------------
class MenuBar(Window):
"""Proxy of C++ MenuBar class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenuBar instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self, long style=0) -> MenuBar"""
newobj = _core_.new_MenuBar(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def Append(*args, **kwargs):
"""Append(self, Menu menu, String title) -> bool"""
return _core_.MenuBar_Append(*args, **kwargs)
def Insert(*args, **kwargs):
"""Insert(self, size_t pos, Menu menu, String title) -> bool"""
return _core_.MenuBar_Insert(*args, **kwargs)
def GetMenuCount(*args, **kwargs):
"""GetMenuCount(self) -> size_t"""
return _core_.MenuBar_GetMenuCount(*args, **kwargs)
def GetMenu(*args, **kwargs):
"""GetMenu(self, size_t pos) -> Menu"""
return _core_.MenuBar_GetMenu(*args, **kwargs)
def Replace(*args, **kwargs):
"""Replace(self, size_t pos, Menu menu, String title) -> Menu"""
return _core_.MenuBar_Replace(*args, **kwargs)
def Remove(*args, **kwargs):
"""Remove(self, size_t pos) -> Menu"""
return _core_.MenuBar_Remove(*args, **kwargs)
def EnableTop(*args, **kwargs):
"""EnableTop(self, size_t pos, bool enable)"""
return _core_.MenuBar_EnableTop(*args, **kwargs)
def IsEnabledTop(*args, **kwargs):
"""IsEnabledTop(self, size_t pos) -> bool"""
return _core_.MenuBar_IsEnabledTop(*args, **kwargs)
def SetLabelTop(*args, **kwargs):
"""SetLabelTop(self, size_t pos, String label)"""
return _core_.MenuBar_SetLabelTop(*args, **kwargs)
def GetLabelTop(*args, **kwargs):
"""GetLabelTop(self, size_t pos) -> String"""
return _core_.MenuBar_GetLabelTop(*args, **kwargs)
def FindMenuItem(*args, **kwargs):
"""FindMenuItem(self, String menu, String item) -> int"""
return _core_.MenuBar_FindMenuItem(*args, **kwargs)
def FindItemById(*args, **kwargs):
"""FindItemById(self, int id) -> MenuItem"""
return _core_.MenuBar_FindItemById(*args, **kwargs)
def FindMenu(*args, **kwargs):
"""FindMenu(self, String title) -> int"""
return _core_.MenuBar_FindMenu(*args, **kwargs)
def Enable(*args, **kwargs):
"""Enable(self, int id, bool enable)"""
return _core_.MenuBar_Enable(*args, **kwargs)
def Check(*args, **kwargs):
"""Check(self, int id, bool check)"""
return _core_.MenuBar_Check(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""IsChecked(self, int id) -> bool"""
return _core_.MenuBar_IsChecked(*args, **kwargs)
def IsEnabled(*args, **kwargs):
"""IsEnabled(self, int id) -> bool"""
return _core_.MenuBar_IsEnabled(*args, **kwargs)
def SetLabel(*args, **kwargs):
"""SetLabel(self, int id, String label)"""
return _core_.MenuBar_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""GetLabel(self, int id) -> String"""
return _core_.MenuBar_GetLabel(*args, **kwargs)
def SetHelpString(*args, **kwargs):
"""SetHelpString(self, int id, String helpString)"""
return _core_.MenuBar_SetHelpString(*args, **kwargs)
def GetHelpString(*args, **kwargs):
"""GetHelpString(self, int id) -> String"""
return _core_.MenuBar_GetHelpString(*args, **kwargs)
def GetFrame(*args, **kwargs):
"""GetFrame(self) -> wxFrame"""
return _core_.MenuBar_GetFrame(*args, **kwargs)
def IsAttached(*args, **kwargs):
"""IsAttached(self) -> bool"""
return _core_.MenuBar_IsAttached(*args, **kwargs)
def Attach(*args, **kwargs):
"""Attach(self, wxFrame frame)"""
return _core_.MenuBar_Attach(*args, **kwargs)
def Detach(*args, **kwargs):
"""Detach(self)"""
return _core_.MenuBar_Detach(*args, **kwargs)
def SetAutoWindowMenu(*args, **kwargs):
"""SetAutoWindowMenu(bool enable)"""
return _core_.MenuBar_SetAutoWindowMenu(*args, **kwargs)
SetAutoWindowMenu = staticmethod(SetAutoWindowMenu)
def GetAutoWindowMenu(*args, **kwargs):
"""GetAutoWindowMenu() -> bool"""
return _core_.MenuBar_GetAutoWindowMenu(*args, **kwargs)
GetAutoWindowMenu = staticmethod(GetAutoWindowMenu)
class MenuBarPtr(MenuBar):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MenuBar
_core_.MenuBar_swigregister(MenuBarPtr)
def MenuBar_SetAutoWindowMenu(*args, **kwargs):
"""MenuBar_SetAutoWindowMenu(bool enable)"""
return _core_.MenuBar_SetAutoWindowMenu(*args, **kwargs)
def MenuBar_GetAutoWindowMenu(*args, **kwargs):
"""MenuBar_GetAutoWindowMenu() -> bool"""
return _core_.MenuBar_GetAutoWindowMenu(*args, **kwargs)
#---------------------------------------------------------------------------
class MenuItem(Object):
"""Proxy of C++ MenuItem class"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenuItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Menu parentMenu=None, int id=ID_ANY, String text=EmptyString,
String help=EmptyString, int kind=ITEM_NORMAL,
Menu subMenu=None) -> MenuItem
"""
newobj = _core_.new_MenuItem(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetMenu(*args, **kwargs):
"""GetMenu(self) -> Menu"""
return _core_.MenuItem_GetMenu(*args, **kwargs)
def SetMenu(*args, **kwargs):
"""SetMenu(self, Menu menu)"""
return _core_.MenuItem_SetMenu(*args, **kwargs)
def SetId(*args, **kwargs):
"""SetId(self, int id)"""
return _core_.MenuItem_SetId(*args, **kwargs)
def GetId(*args, **kwargs):
"""GetId(self) -> int"""
return _core_.MenuItem_GetId(*args, **kwargs)
def IsSeparator(*args, **kwargs):
"""IsSeparator(self) -> bool"""
return _core_.MenuItem_IsSeparator(*args, **kwargs)
def SetText(*args, **kwargs):
"""SetText(self, String str)"""
return _core_.MenuItem_SetText(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""GetLabel(self) -> String"""
return _core_.MenuItem_GetLabel(*args, **kwargs)
def GetText(*args, **kwargs):
"""GetText(self) -> String"""
return _core_.MenuItem_GetText(*args, **kwargs)
def GetLabelFromText(*args, **kwargs):
"""GetLabelFromText(String text) -> String"""
return _core_.MenuItem_GetLabelFromText(*args, **kwargs)
GetLabelFromText = staticmethod(GetLabelFromText)
def GetKind(*args, **kwargs):
"""GetKind(self) -> int"""
return _core_.MenuItem_GetKind(*args, **kwargs)
def SetKind(*args, **kwargs):
"""SetKind(self, int kind)"""
return _core_.MenuItem_SetKind(*args, **kwargs)
def SetCheckable(*args, **kwargs):
"""SetCheckable(self, bool checkable)"""
return _core_.MenuItem_SetCheckable(*args, **kwargs)
def IsCheckable(*args, **kwargs):
"""IsCheckable(self) -> bool"""
return _core_.MenuItem_IsCheckable(*args, **kwargs)
def IsSubMenu(*args, **kwargs):
"""IsSubMenu(self) -> bool"""
return _core_.MenuItem_IsSubMenu(*args, **kwargs)
def SetSubMenu(*args, **kwargs):
"""SetSubMenu(self, Menu menu)"""
return _core_.MenuItem_SetSubMenu(*args, **kwargs)
def GetSubMenu(*args, **kwargs):
"""GetSubMenu(self) -> Menu"""
return _core_.MenuItem_GetSubMenu(*args, **kwargs)
def Enable(*args, **kwargs):
"""Enable(self, bool enable=True)"""
return _core_.MenuItem_Enable(*args, **kwargs)
def IsEnabled(*args, **kwargs):
"""IsEnabled(self) -> bool"""
return _core_.MenuItem_IsEnabled(*args, **kwargs)
def Check(*args, **kwargs):
"""Check(self, bool check=True)"""
return _core_.MenuItem_Check(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""IsChecked(self) -> bool"""
return _core_.MenuItem_IsChecked(*args, **kwargs)
def Toggle(*args, **kwargs):
"""Toggle(self)"""
return _core_.MenuItem_Toggle(*args, **kwargs)
def SetHelp(*args, **kwargs):
"""SetHelp(self, String str)"""
return _core_.MenuItem_SetHelp(*args, **kwargs)
def GetHelp(*args, **kwargs):
"""GetHelp(self) -> String"""
return _core_.MenuItem_GetHelp(*args, **kwargs)
def GetAccel(*args, **kwargs):
"""GetAccel(self) -> AcceleratorEntry"""
return _core_.MenuItem_GetAccel(*args, **kwargs)
def SetAccel(*args, **kwargs):
"""SetAccel(self, AcceleratorEntry accel)"""
return _core_.MenuItem_SetAccel(*args, **kwargs)
def SetBitmap(*args, **kwargs):
"""SetBitmap(self, Bitmap bitmap)"""
return _core_.MenuItem_SetBitmap(*args, **kwargs)
def GetBitmap(*args, **kwargs):
"""GetBitmap(self) -> Bitmap"""
return _core_.MenuItem_GetBitmap(*args, **kwargs)
def SetFont(*args, **kwargs):
"""SetFont(self, Font font)"""
return _core_.MenuItem_SetFont(*args, **kwargs)
def GetFont(*args, **kwargs):
"""GetFont(self) -> Font"""
return _core_.MenuItem_GetFont(*args, **kwargs)
def SetTextColour(*args, **kwargs):
"""SetTextColour(self, Colour colText)"""
return _core_.MenuItem_SetTextColour(*args, **kwargs)
def GetTextColour(*args, **kwargs):
"""GetTextColour(self) -> Colour"""
return _core_.MenuItem_GetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
"""SetBackgroundColour(self, Colour colBack)"""
return _core_.MenuItem_SetBackgroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
"""GetBackgroundColour(self) -> Colour"""
return _core_.MenuItem_GetBackgroundColour(*args, **kwargs)
def SetBitmaps(*args, **kwargs):
"""SetBitmaps(self, Bitmap bmpChecked, Bitmap bmpUnchecked=wxNullBitmap)"""
return _core_.MenuItem_SetBitmaps(*args, **kwargs)
def SetDisabledBitmap(*args, **kwargs):
"""SetDisabledBitmap(self, Bitmap bmpDisabled)"""
return _core_.MenuItem_SetDisabledBitmap(*args, **kwargs)
def GetDisabledBitmap(*args, **kwargs):
"""GetDisabledBitmap(self) -> Bitmap"""
return _core_.MenuItem_GetDisabledBitmap(*args, **kwargs)
def SetMarginWidth(*args, **kwargs):
"""SetMarginWidth(self, int nWidth)"""
return _core_.MenuItem_SetMarginWidth(*args, **kwargs)
def GetMarginWidth(*args, **kwargs):
"""GetMarginWidth(self) -> int"""
return _core_.MenuItem_GetMarginWidth(*args, **kwargs)
def GetDefaultMarginWidth(*args, **kwargs):
"""GetDefaultMarginWidth() -> int"""
return _core_.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
GetDefaultMarginWidth = staticmethod(GetDefaultMarginWidth)
def IsOwnerDrawn(*args, **kwargs):
"""IsOwnerDrawn(self) -> bool"""
return _core_.MenuItem_IsOwnerDrawn(*args, **kwargs)
def SetOwnerDrawn(*args, **kwargs):
"""SetOwnerDrawn(self, bool ownerDrawn=True)"""
return _core_.MenuItem_SetOwnerDrawn(*args, **kwargs)
def ResetOwnerDrawn(*args, **kwargs):
"""ResetOwnerDrawn(self)"""
return _core_.MenuItem_ResetOwnerDrawn(*args, **kwargs)
class MenuItemPtr(MenuItem):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MenuItem
_core_.MenuItem_swigregister(MenuItemPtr)
def MenuItem_GetLabelFromText(*args, **kwargs):
"""MenuItem_GetLabelFromText(String text) -> String"""
return _core_.MenuItem_GetLabelFromText(*args, **kwargs)
def MenuItem_GetDefaultMarginWidth(*args, **kwargs):
"""MenuItem_GetDefaultMarginWidth() -> int"""
return _core_.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
#---------------------------------------------------------------------------
class Control(Window):
"""
This is the base class for a control or 'widget'.
A control is generally a small window which processes user input
and/or displays one or more item of data.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxControl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, Validator validator=DefaultValidator,
String name=ControlNameStr) -> Control
Create a Control. Normally you should only call this from a subclass'
__init__ as a plain old wx.Control is not very useful.
"""
newobj = _core_.new_Control(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, Validator validator=DefaultValidator,
String name=ControlNameStr) -> bool
Do the 2nd phase and create the GUI control.
"""
return _core_.Control_Create(*args, **kwargs)
def Command(*args, **kwargs):
"""
Command(self, CommandEvent event)
Simulates the effect of the user issuing a command to the item.
:see: `wx.CommandEvent`
"""
return _core_.Control_Command(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""
GetLabel(self) -> String
Return a control's text.
"""
return _core_.Control_GetLabel(*args, **kwargs)
def SetLabel(*args, **kwargs):
"""
SetLabel(self, String label)
Sets the item's text.
"""
return _core_.Control_SetLabel(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
class ControlPtr(Control):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Control
_core_.Control_swigregister(ControlPtr)
ControlNameStr = cvar.ControlNameStr
def PreControl(*args, **kwargs):
"""
PreControl() -> Control
Precreate a Control control for 2-phase creation
"""
val = _core_.new_PreControl(*args, **kwargs)
val.thisown = 1
return val
def Control_GetClassDefaultAttributes(*args, **kwargs):
"""
Control_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class ItemContainer(object):
"""
The wx.ItemContainer class defines an interface which is implemented
by all controls which have string subitems, each of which may be
selected, such as `wx.ListBox`, `wx.CheckListBox`, `wx.Choice` as well
as `wx.ComboBox` which implements an extended interface deriving from
this one.
It defines the methods for accessing the control's items and although
each of the derived classes implements them differently, they still
all conform to the same interface.
The items in a wx.ItemContainer have (non empty) string labels and,
optionally, client data associated with them.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxItemContainer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Append(*args, **kwargs):
"""
Append(self, String item, PyObject clientData=None) -> int
Adds the item to the control, associating the given data with the item
if not None. The return value is the index of the newly added item
which may be different from the last one if the control is sorted (e.g.
has wx.LB_SORT or wx.CB_SORT style).
"""
return _core_.ItemContainer_Append(*args, **kwargs)
def AppendItems(*args, **kwargs):
"""
AppendItems(self, List strings)
Apend several items at once to the control. Notice that calling this
method may be much faster than appending the items one by one if you
need to add a lot of items.
"""
return _core_.ItemContainer_AppendItems(*args, **kwargs)
def Insert(*args, **kwargs):
"""
Insert(self, String item, int pos, PyObject clientData=None) -> int
Insert an item into the control before the item at the ``pos`` index,
optionally associating some data object with the item.
"""
return _core_.ItemContainer_Insert(*args, **kwargs)
def Clear(*args, **kwargs):
"""
Clear(self)
Removes all items from the control.
"""
return _core_.ItemContainer_Clear(*args, **kwargs)
def Delete(*args, **kwargs):
"""
Delete(self, int n)
Deletes the item at the zero-based index 'n' from the control. Note
that it is an error (signalled by a `wx.PyAssertionError` exception if
enabled) to remove an item with the index negative or greater or equal
than the number of items in the control.
"""
return _core_.ItemContainer_Delete(*args, **kwargs)
def GetClientData(*args, **kwargs):
"""
GetClientData(self, int n) -> PyObject
Returns the client data associated with the given item, (if any.)
"""
return _core_.ItemContainer_GetClientData(*args, **kwargs)
def SetClientData(*args, **kwargs):
"""
SetClientData(self, int n, PyObject clientData)
Associate the given client data with the item at position n.
"""
return _core_.ItemContainer_SetClientData(*args, **kwargs)
def GetCount(*args, **kwargs):
"""
GetCount(self) -> int
Returns the number of items in the control.
"""
return _core_.ItemContainer_GetCount(*args, **kwargs)
def IsEmpty(*args, **kwargs):
"""
IsEmpty(self) -> bool
Returns True if the control is empty or False if it has some items.
"""
return _core_.ItemContainer_IsEmpty(*args, **kwargs)
def GetString(*args, **kwargs):
"""
GetString(self, int n) -> String
Returns the label of the item with the given index.
"""
return _core_.ItemContainer_GetString(*args, **kwargs)
def GetStrings(*args, **kwargs):
"""GetStrings(self) -> wxArrayString"""
return _core_.ItemContainer_GetStrings(*args, **kwargs)
def SetString(*args, **kwargs):
"""
SetString(self, int n, String s)
Sets the label for the given item.
"""
return _core_.ItemContainer_SetString(*args, **kwargs)
def FindString(*args, **kwargs):
"""
FindString(self, String s) -> int
Finds an item whose label matches the given string. Returns the
zero-based position of the item, or ``wx.NOT_FOUND`` if the string was not
found.
"""
return _core_.ItemContainer_FindString(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""
SetSelection(self, int n)
Sets the item at index 'n' to be the selected item.
"""
return _core_.ItemContainer_SetSelection(*args, **kwargs)
def GetSelection(*args, **kwargs):
"""
GetSelection(self) -> int
Returns the index of the selected item or ``wx.NOT_FOUND`` if no item
is selected.
"""
return _core_.ItemContainer_GetSelection(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
"""SetStringSelection(self, String s) -> bool"""
return _core_.ItemContainer_SetStringSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
"""
GetStringSelection(self) -> String
Returns the label of the selected item or an empty string if no item
is selected.
"""
return _core_.ItemContainer_GetStringSelection(*args, **kwargs)
def Select(*args, **kwargs):
"""
Select(self, int n)
This is the same as `SetSelection` and exists only because it is
slightly more natural for controls which support multiple selection.
"""
return _core_.ItemContainer_Select(*args, **kwargs)
class ItemContainerPtr(ItemContainer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ItemContainer
_core_.ItemContainer_swigregister(ItemContainerPtr)
#---------------------------------------------------------------------------
class ControlWithItems(Control,ItemContainer):
"""
wx.ControlWithItems combines the ``wx.ItemContainer`` class with the
wx.Control class, and is used for the base class of various controls
that have items.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxControlWithItems instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
class ControlWithItemsPtr(ControlWithItems):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ControlWithItems
_core_.ControlWithItems_swigregister(ControlWithItemsPtr)
#---------------------------------------------------------------------------
class SizerItem(Object):
"""
The wx.SizerItem class is used to track the position, size and other
attributes of each item managed by a `wx.Sizer`. In normal usage user
code should never need to deal directly with a wx.SizerItem, but
custom classes derived from `wx.PySizer` will probably need to use the
collection of wx.SizerItems held by wx.Sizer when calculating layout.
:see: `wx.Sizer`, `wx.GBSizerItem`
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSizerItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> SizerItem
Constructs an empty wx.SizerItem. Either a window, sizer or spacer
size will need to be set before this item can be used in a Sizer.
You will probably never need to create a wx.SizerItem directly as they
are created automatically when the sizer's Add, Insert or Prepend
methods are called.
:see: `wx.SizerItemSpacer`, `wx.SizerItemWindow`, `wx.SizerItemSizer`
"""
newobj = _core_.new_SizerItem(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def DeleteWindows(*args, **kwargs):
"""
DeleteWindows(self)
Destroy the window or the windows in a subsizer, depending on the type
of item.
"""
return _core_.SizerItem_DeleteWindows(*args, **kwargs)
def DetachSizer(*args, **kwargs):
"""
DetachSizer(self)
Enable deleting the SizerItem without destroying the contained sizer.
"""
return _core_.SizerItem_DetachSizer(*args, **kwargs)
def GetSize(*args, **kwargs):
"""
GetSize(self) -> Size
Get the current size of the item, as set in the last Layout.
"""
return _core_.SizerItem_GetSize(*args, **kwargs)
def CalcMin(*args, **kwargs):
"""
CalcMin(self) -> Size
Calculates the minimum desired size for the item, including any space
needed by borders.
"""
return _core_.SizerItem_CalcMin(*args, **kwargs)
def SetDimension(*args, **kwargs):
"""
SetDimension(self, Point pos, Size size)
Set the position and size of the space allocated for this item by the
sizer, and adjust the position and size of the item (window or
subsizer) to be within that space taking alignment and borders into
account.
"""
return _core_.SizerItem_SetDimension(*args, **kwargs)
def GetMinSize(*args, **kwargs):
"""
GetMinSize(self) -> Size
Get the minimum size needed for the item.
"""
return _core_.SizerItem_GetMinSize(*args, **kwargs)
def GetMinSizeWithBorder(*args, **kwargs):
"""
GetMinSizeWithBorder(self) -> Size
Get the minimum size needed for the item with space for the borders
added, if needed.
"""
return _core_.SizerItem_GetMinSizeWithBorder(*args, **kwargs)
def SetInitSize(*args, **kwargs):
"""SetInitSize(self, int x, int y)"""
return _core_.SizerItem_SetInitSize(*args, **kwargs)
def SetRatioWH(*args, **kwargs):
"""
SetRatioWH(self, int width, int height)
Set the ratio item attribute.
"""
return _core_.SizerItem_SetRatioWH(*args, **kwargs)
def SetRatioSize(*args, **kwargs):
"""
SetRatioSize(self, Size size)
Set the ratio item attribute.
"""
return _core_.SizerItem_SetRatioSize(*args, **kwargs)
def SetRatio(*args, **kwargs):
"""
SetRatio(self, float ratio)
Set the ratio item attribute.
"""
return _core_.SizerItem_SetRatio(*args, **kwargs)
def GetRatio(*args, **kwargs):
"""
GetRatio(self) -> float
Set the ratio item attribute.
"""
return _core_.SizerItem_GetRatio(*args, **kwargs)
def GetRect(*args, **kwargs):
"""
GetRect(self) -> Rect
Returns the rectangle that the sizer item should occupy
"""
return _core_.SizerItem_GetRect(*args, **kwargs)
def IsWindow(*args, **kwargs):
"""
IsWindow(self) -> bool
Is this sizer item a window?
"""
return _core_.SizerItem_IsWindow(*args, **kwargs)
def IsSizer(*args, **kwargs):
"""
IsSizer(self) -> bool
Is this sizer item a subsizer?
"""
return _core_.SizerItem_IsSizer(*args, **kwargs)
def IsSpacer(*args, **kwargs):
"""
IsSpacer(self) -> bool
Is this sizer item a spacer?
"""
return _core_.SizerItem_IsSpacer(*args, **kwargs)
def SetProportion(*args, **kwargs):
"""
SetProportion(self, int proportion)
Set the proportion value for this item.
"""
return _core_.SizerItem_SetProportion(*args, **kwargs)
def GetProportion(*args, **kwargs):
"""
GetProportion(self) -> int
Get the proportion value for this item.
"""
return _core_.SizerItem_GetProportion(*args, **kwargs)
SetOption = wx._deprecated(SetProportion, "Please use `SetProportion` instead.")
GetOption = wx._deprecated(GetProportion, "Please use `GetProportion` instead.")
def SetFlag(*args, **kwargs):
"""
SetFlag(self, int flag)
Set the flag value for this item.
"""
return _core_.SizerItem_SetFlag(*args, **kwargs)
def GetFlag(*args, **kwargs):
"""
GetFlag(self) -> int
Get the flag value for this item.
"""
return _core_.SizerItem_GetFlag(*args, **kwargs)
def SetBorder(*args, **kwargs):
"""
SetBorder(self, int border)
Set the border value for this item.
"""
return _core_.SizerItem_SetBorder(*args, **kwargs)
def GetBorder(*args, **kwargs):
"""
GetBorder(self) -> int
Get the border value for this item.
"""
return _core_.SizerItem_GetBorder(*args, **kwargs)
def GetWindow(*args, **kwargs):
"""
GetWindow(self) -> Window
Get the window (if any) that is managed by this sizer item.
"""
return _core_.SizerItem_GetWindow(*args, **kwargs)
def SetWindow(*args, **kwargs):
"""
SetWindow(self, Window window)
Set the window to be managed by this sizer item.
"""
return _core_.SizerItem_SetWindow(*args, **kwargs)
def GetSizer(*args, **kwargs):
"""
GetSizer(self) -> Sizer
Get the subsizer (if any) that is managed by this sizer item.
"""
return _core_.SizerItem_GetSizer(*args, **kwargs)
def SetSizer(*args, **kwargs):
"""
SetSizer(self, Sizer sizer)
Set the subsizer to be managed by this sizer item.
"""
return _core_.SizerItem_SetSizer(*args, **kwargs)
def GetSpacer(*args, **kwargs):
"""
GetSpacer(self) -> Size
Get the size of the spacer managed by this sizer item.
"""
return _core_.SizerItem_GetSpacer(*args, **kwargs)
def SetSpacer(*args, **kwargs):
"""
SetSpacer(self, Size size)
Set the size of the spacer to be managed by this sizer item.
"""
return _core_.SizerItem_SetSpacer(*args, **kwargs)
def Show(*args, **kwargs):
"""
Show(self, bool show)
Set the show item attribute, which sizers use to determine if the item
is to be made part of the layout or not. If the item is tracking a
window then it is shown or hidden as needed.
"""
return _core_.SizerItem_Show(*args, **kwargs)
def IsShown(*args, **kwargs):
"""
IsShown(self) -> bool
Is the item to be shown in the layout?
"""
return _core_.SizerItem_IsShown(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the current position of the item, as set in the last Layout.
"""
return _core_.SizerItem_GetPosition(*args, **kwargs)
def GetUserData(*args, **kwargs):
"""
GetUserData(self) -> PyObject
Returns the userData associated with this sizer item, or None if there
isn't any.
"""
return _core_.SizerItem_GetUserData(*args, **kwargs)
def SetUserData(*args, **kwargs):
"""
SetUserData(self, PyObject userData)
Associate a Python object with this sizer item.
"""
return _core_.SizerItem_SetUserData(*args, **kwargs)
class SizerItemPtr(SizerItem):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SizerItem
_core_.SizerItem_swigregister(SizerItemPtr)
def SizerItemWindow(*args, **kwargs):
"""
SizerItemWindow(Window window, int proportion, int flag, int border,
PyObject userData=None) -> SizerItem
Constructs a `wx.SizerItem` for tracking a window.
"""
val = _core_.new_SizerItemWindow(*args, **kwargs)
val.thisown = 1
return val
def SizerItemSpacer(*args, **kwargs):
"""
SizerItemSpacer(int width, int height, int proportion, int flag, int border,
PyObject userData=None) -> SizerItem
Constructs a `wx.SizerItem` for tracking a spacer.
"""
val = _core_.new_SizerItemSpacer(*args, **kwargs)
val.thisown = 1
return val
def SizerItemSizer(*args, **kwargs):
"""
SizerItemSizer(Sizer sizer, int proportion, int flag, int border,
PyObject userData=None) -> SizerItem
Constructs a `wx.SizerItem` for tracking a subsizer
"""
val = _core_.new_SizerItemSizer(*args, **kwargs)
val.thisown = 1
return val
class Sizer(Object):
"""
wx.Sizer is the abstract base class used for laying out subwindows in
a window. You cannot use wx.Sizer directly; instead, you will have to
use one of the sizer classes derived from it such as `wx.BoxSizer`,
`wx.StaticBoxSizer`, `wx.NotebookSizer`, `wx.GridSizer`, `wx.FlexGridSizer`
and `wx.GridBagSizer`.
The concept implemented by sizers in wxWidgets is closely related to
layout tools in other GUI toolkits, such as Java's AWT, the GTK
toolkit or the Qt toolkit. It is based upon the idea of the individual
subwindows reporting their minimal required size and their ability to
get stretched if the size of the parent window has changed. This will
most often mean that the programmer does not set the original size of
a dialog in the beginning, rather the dialog will assigned a sizer and
this sizer will be queried about the recommended size. The sizer in
turn will query its children, which can be normal windows or contorls,
empty space or other sizers, so that a hierarchy of sizers can be
constructed. Note that wxSizer does not derive from wxWindow and thus
do not interfere with tab ordering and requires very little resources
compared to a real window on screen.
What makes sizers so well fitted for use in wxWidgets is the fact that
every control reports its own minimal size and the algorithm can
handle differences in font sizes or different window (dialog item)
sizes on different platforms without problems. If for example the
standard font as well as the overall design of Mac widgets requires
more space than on Windows, then the initial size of a dialog using a
sizer will automatically be bigger on Mac than on Windows.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def _setOORInfo(*args, **kwargs):
"""_setOORInfo(self, PyObject _self)"""
return _core_.Sizer__setOORInfo(*args, **kwargs)
def Add(*args, **kwargs):
"""
Add(self, item, int proportion=0, int flag=0, int border=0,
PyObject userData=None) -> wx.SizerItem
Appends a child item to the sizer.
"""
return _core_.Sizer_Add(*args, **kwargs)
def Insert(*args, **kwargs):
"""
Insert(self, int before, item, int proportion=0, int flag=0, int border=0,
PyObject userData=None) -> wx.SizerItem
Inserts a new item into the list of items managed by this sizer before
the item at index *before*. See `Add` for a description of the parameters.
"""
return _core_.Sizer_Insert(*args, **kwargs)
def Prepend(*args, **kwargs):
"""
Prepend(self, item, int proportion=0, int flag=0, int border=0,
PyObject userData=None) -> wx.SizerItem
Adds a new item to the begining of the list of sizer items managed by
this sizer. See `Add` for a description of the parameters.
"""
return _core_.Sizer_Prepend(*args, **kwargs)
def Remove(*args, **kwargs):
"""
Remove(self, item) -> bool
Removes an item from the sizer and destroys it. This method does not
cause any layout or resizing to take place, call `Layout` to update
the layout on screen after removing a child from the sizer. The
*item* parameter can be either a window, a sizer, or the zero-based
index of an item to remove. Returns True if the child item was found
and removed.
"""
return _core_.Sizer_Remove(*args, **kwargs)
def Detach(*args, **kwargs):
"""
Detach(self, item) -> bool
Detaches an item from the sizer without destroying it. This method
does not cause any layout or resizing to take place, call `Layout` to
do so. The *item* parameter can be either a window, a sizer, or the
zero-based index of the item to be detached. Returns True if the child item
was found and detached.
"""
return _core_.Sizer_Detach(*args, **kwargs)
def GetItem(*args, **kwargs):
"""
GetItem(self, item) -> wx.SizerItem
Returns the `wx.SizerItem` which holds the *item* given. The *item*
parameter can be either a window, a sizer, or the zero-based index of
the item to be found.
"""
return _core_.Sizer_GetItem(*args, **kwargs)
def _SetItemMinSize(*args, **kwargs):
"""_SetItemMinSize(self, PyObject item, Size size)"""
return _core_.Sizer__SetItemMinSize(*args, **kwargs)
def SetItemMinSize(self, item, *args):
"""
SetItemMinSize(self, item, Size size)
Sets the minimum size that will be allocated for an item in the sizer.
The *item* parameter can be either a window, a sizer, or the
zero-based index of the item. If a window or sizer is given then it
will be searched for recursivly in subsizers if neccessary.
"""
if len(args) == 2:
# for backward compatibility accept separate width,height args too
return self._SetItemMinSize(item, args)
else:
return self._SetItemMinSize(item, args[0])
def AddItem(*args, **kwargs):
"""
AddItem(self, SizerItem item)
Adds a `wx.SizerItem` to the sizer.
"""
return _core_.Sizer_AddItem(*args, **kwargs)
def InsertItem(*args, **kwargs):
"""
InsertItem(self, int index, SizerItem item)
Inserts a `wx.SizerItem` to the sizer at the position given by *index*.
"""
return _core_.Sizer_InsertItem(*args, **kwargs)
def PrependItem(*args, **kwargs):
"""
PrependItem(self, SizerItem item)
Prepends a `wx.SizerItem` to the sizer.
"""
return _core_.Sizer_PrependItem(*args, **kwargs)
def AddMany(self, items):
"""
AddMany is a convenience method for adding several items
to a sizer at one time. Simply pass it a list of tuples,
where each tuple consists of the parameters that you
would normally pass to the `Add` method.
"""
for item in items:
if type(item) != type(()) or (len(item) == 2 and type(item[0]) == type(1)):
item = (item, )
self.Add(*item)
# for backwards compatibility only, please do not use in new code
def AddWindow(self, *args, **kw):
"""Compatibility alias for `Add`."""
return self.Add(*args, **kw)
def AddSizer(self, *args, **kw):
"""Compatibility alias for `Add`."""
return self.Add(*args, **kw)
def AddSpacer(self, *args, **kw):
"""Compatibility alias for `Add`."""
return self.Add(*args, **kw)
def PrependWindow(self, *args, **kw):
"""Compatibility alias for `Prepend`."""
return self.Prepend(*args, **kw)
def PrependSizer(self, *args, **kw):
"""Compatibility alias for `Prepend`."""
return self.Prepend(*args, **kw)
def PrependSpacer(self, *args, **kw):
"""Compatibility alias for `Prepend`."""
return self.Prepend(*args, **kw)
def InsertWindow(self, *args, **kw):
"""Compatibility alias for `Insert`."""
return self.Insert(*args, **kw)
def InsertSizer(self, *args, **kw):
"""Compatibility alias for `Insert`."""
return self.Insert(*args, **kw)
def InsertSpacer(self, *args, **kw):
"""Compatibility alias for `Insert`."""
return self.Insert(*args, **kw)
def RemoveWindow(self, *args, **kw):
"""Compatibility alias for `Remove`."""
return self.Remove(*args, **kw)
def RemoveSizer(self, *args, **kw):
"""Compatibility alias for `Remove`."""
return self.Remove(*args, **kw)
def RemovePos(self, *args, **kw):
"""Compatibility alias for `Remove`."""
return self.Remove(*args, **kw)
def SetDimension(*args, **kwargs):
"""
SetDimension(self, int x, int y, int width, int height)
Call this to force the sizer to take the given dimension and thus
force the items owned by the sizer to resize themselves according to
the rules defined by the parameter in the `Add`, `Insert` or `Prepend`
methods.
"""
return _core_.Sizer_SetDimension(*args, **kwargs)
def SetMinSize(*args, **kwargs):
"""
SetMinSize(self, Size size)
Call this to give the sizer a minimal size. Normally, the sizer will
calculate its minimal size based purely on how much space its children
need. After calling this method `GetMinSize` will return either the
minimal size as requested by its children or the minimal size set
here, depending on which is bigger.
"""
return _core_.Sizer_SetMinSize(*args, **kwargs)
def GetSize(*args, **kwargs):
"""
GetSize(self) -> Size
Returns the current size of the space managed by the sizer.
"""
return _core_.Sizer_GetSize(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the current position of the sizer's managed space.
"""
return _core_.Sizer_GetPosition(*args, **kwargs)
def GetMinSize(*args, **kwargs):
"""
GetMinSize(self) -> Size
Returns the minimal size of the sizer. This is either the combined
minimal size of all the children and their borders or the minimal size
set by SetMinSize, depending on which is bigger.
"""
return _core_.Sizer_GetMinSize(*args, **kwargs)
def GetSizeTuple(self):
return self.GetSize().Get()
def GetPositionTuple(self):
return self.GetPosition().Get()
def GetMinSizeTuple(self):
return self.GetMinSize().Get()
def RecalcSizes(*args, **kwargs):
"""
RecalcSizes(self)
Using the sizes calculated by `CalcMin` reposition and resize all the
items managed by this sizer. You should not need to call this directly as
it is called by `Layout`.
"""
return _core_.Sizer_RecalcSizes(*args, **kwargs)
def CalcMin(*args, **kwargs):
"""
CalcMin(self) -> Size
This method is where the sizer will do the actual calculation of its
children's minimal sizes. You should not need to call this directly as
it is called by `Layout`.
"""
return _core_.Sizer_CalcMin(*args, **kwargs)
def Layout(*args, **kwargs):
"""
Layout(self)
This method will force the recalculation and layout of the items
controlled by the sizer using the current space allocated to the
sizer. Normally this is called automatically from the owning window's
EVT_SIZE handler, but it is also useful to call it from user code when
one of the items in a sizer change size, or items are added or
removed.
"""
return _core_.Sizer_Layout(*args, **kwargs)
def Fit(*args, **kwargs):
"""
Fit(self, Window window) -> Size
Tell the sizer to resize the *window* to match the sizer's minimal
size. This is commonly done in the constructor of the window itself in
order to set its initial size to match the needs of the children as
determined by the sizer. Returns the new size.
For a top level window this is the total window size, not the client size.
"""
return _core_.Sizer_Fit(*args, **kwargs)
def FitInside(*args, **kwargs):
"""
FitInside(self, Window window)
Tell the sizer to resize the *virtual size* of the *window* to match the
sizer's minimal size. This will not alter the on screen size of the
window, but may cause the addition/removal/alteration of scrollbars
required to view the virtual area in windows which manage it.
:see: `wx.ScrolledWindow.SetScrollbars`, `SetVirtualSizeHints`
"""
return _core_.Sizer_FitInside(*args, **kwargs)
def SetSizeHints(*args, **kwargs):
"""
SetSizeHints(self, Window window)
Tell the sizer to set (and `Fit`) the minimal size of the *window* to
match the sizer's minimal size. This is commonly done in the
constructor of the window itself if the window is resizable (as are
many dialogs under Unix and frames on probably all platforms) in order
to prevent the window from being sized smaller than the minimal size
required by the sizer.
"""
return _core_.Sizer_SetSizeHints(*args, **kwargs)
def SetVirtualSizeHints(*args, **kwargs):
"""
SetVirtualSizeHints(self, Window window)
Tell the sizer to set the minimal size of the window virtual area to
match the sizer's minimal size. For windows with managed scrollbars
this will set them appropriately.
:see: `wx.ScrolledWindow.SetScrollbars`
"""
return _core_.Sizer_SetVirtualSizeHints(*args, **kwargs)
def Clear(*args, **kwargs):
"""
Clear(self, bool deleteWindows=False)
Clear all items from the sizer, optionally destroying the window items
as well.
"""
return _core_.Sizer_Clear(*args, **kwargs)
def DeleteWindows(*args, **kwargs):
"""
DeleteWindows(self)
Destroy all windows managed by the sizer.
"""
return _core_.Sizer_DeleteWindows(*args, **kwargs)
def GetChildren(*args, **kwargs):
"""
GetChildren(self) -> list
Returns a list of all the `wx.SizerItem` objects managed by the sizer.
"""
return _core_.Sizer_GetChildren(*args, **kwargs)
def Show(*args, **kwargs):
"""
Show(self, item, bool show=True, bool recursive=false) -> bool
Shows or hides an item managed by the sizer. To make a sizer item
disappear or reappear, use Show followed by `Layout`. The *item*
parameter can be either a window, a sizer, or the zero-based index of
the item. Use the recursive parameter to show or hide an item in a
subsizer. Returns True if the item was found.
"""
return _core_.Sizer_Show(*args, **kwargs)
def IsShown(*args, **kwargs):
"""
IsShown(self, item)
Determines if the item is currently shown. sizer. To make a sizer
item disappear or reappear, use Show followed by `Layout`. The *item*
parameter can be either a window, a sizer, or the zero-based index of
the item.
"""
return _core_.Sizer_IsShown(*args, **kwargs)
def Hide(self, item, recursive=False):
"""
A convenience method for `Show` (item, False, recursive).
"""
return self.Show(item, False, recursive)
def ShowItems(*args, **kwargs):
"""
ShowItems(self, bool show)
Recursively call `wx.SizerItem.Show` on all sizer items.
"""
return _core_.Sizer_ShowItems(*args, **kwargs)
class SizerPtr(Sizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Sizer
_core_.Sizer_swigregister(SizerPtr)
class PySizer(Sizer):
"""
wx.PySizer is a special version of `wx.Sizer` that has been
instrumented to allow the C++ virtual methods to be overloaded in
Python derived classes. You would derive from this class if you are
wanting to implement a custom sizer in Python code. Simply implement
`CalcMin` and `RecalcSizes` in the derived class and you're all set.
For example::
class MySizer(wx.PySizer):
def __init__(self):
wx.PySizer.__init__(self)
def CalcMin(self):
for item in self.GetChildren():
# calculate the total minimum width and height needed
# by all items in the sizer according to this sizer's
# layout algorithm.
...
return wx.Size(width, height)
def RecalcSizes(self):
# find the space allotted to this sizer
pos = self.GetPosition()
size = self.GetSize()
for item in self.GetChildren():
# Recalculate (if necessary) the position and size of
# each item and then call item.SetDimension to do the
# actual positioning and sizing of the items within the
# space alloted to this sizer.
...
item.SetDimension(itemPos, itemSize)
When `Layout` is called it first calls `CalcMin` followed by
`RecalcSizes` so you can optimize a bit by saving the results of
`CalcMin` and reusing them in `RecalcSizes`.
:see: `wx.SizerItem`, `wx.Sizer.GetChildren`
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPySizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> PySizer
Creates a wx.PySizer. Must be called from the __init__ in the derived
class.
"""
newobj = _core_.new_PySizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setCallbackInfo(self, PySizer);self._setOORInfo(self)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _core_.PySizer__setCallbackInfo(*args, **kwargs)
class PySizerPtr(PySizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PySizer
_core_.PySizer_swigregister(PySizerPtr)
#---------------------------------------------------------------------------
class BoxSizer(Sizer):
"""
The basic idea behind a box sizer is that windows will most often be
laid out in rather simple basic geometry, typically in a row or a
column or nested hierarchies of either. A wx.BoxSizer will lay out
its items in a simple row or column, depending on the orientation
parameter passed to the constructor.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxBoxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int orient=HORIZONTAL) -> BoxSizer
Constructor for a wx.BoxSizer. *orient* may be one of ``wx.VERTICAL``
or ``wx.HORIZONTAL`` for creating either a column sizer or a row
sizer.
"""
newobj = _core_.new_BoxSizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def GetOrientation(*args, **kwargs):
"""
GetOrientation(self) -> int
Returns the current orientation of the sizer.
"""
return _core_.BoxSizer_GetOrientation(*args, **kwargs)
def SetOrientation(*args, **kwargs):
"""
SetOrientation(self, int orient)
Resets the orientation of the sizer.
"""
return _core_.BoxSizer_SetOrientation(*args, **kwargs)
class BoxSizerPtr(BoxSizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = BoxSizer
_core_.BoxSizer_swigregister(BoxSizerPtr)
#---------------------------------------------------------------------------
class StaticBoxSizer(BoxSizer):
"""
wx.StaticBoxSizer derives from and functions identically to the
`wx.BoxSizer` and adds a `wx.StaticBox` around the items that the sizer
manages. Note that this static box must be created separately and
passed to the sizer constructor.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxStaticBoxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, StaticBox box, int orient=HORIZONTAL) -> StaticBoxSizer
Constructor. It takes an associated static box and the orientation
*orient* as parameters - orient can be either of ``wx.VERTICAL`` or
``wx.HORIZONTAL``.
"""
newobj = _core_.new_StaticBoxSizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def GetStaticBox(*args, **kwargs):
"""
GetStaticBox(self) -> StaticBox
Returns the static box associated with this sizer.
"""
return _core_.StaticBoxSizer_GetStaticBox(*args, **kwargs)
class StaticBoxSizerPtr(StaticBoxSizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = StaticBoxSizer
_core_.StaticBoxSizer_swigregister(StaticBoxSizerPtr)
#---------------------------------------------------------------------------
class GridSizer(Sizer):
"""
A grid sizer is a sizer which lays out its children in a
two-dimensional table with all cells having the same size. In other
words, the width of each cell within the grid is the width of the
widest item added to the sizer and the height of each grid cell is the
height of the tallest item. An optional vertical and/or horizontal
gap between items can also be specified (in pixels.)
Items are placed in the cells of the grid in the order they are added,
in row-major order. In other words, the first row is filled first,
then the second, and so on until all items have been added. (If
neccessary, additional rows will be added as items are added.) If you
need to have greater control over the cells that items are placed in
then use the `wx.GridBagSizer`.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int rows=1, int cols=0, int vgap=0, int hgap=0) -> GridSizer
Constructor for a wx.GridSizer. *rows* and *cols* determine the number
of columns and rows in the sizer - if either of the parameters is
zero, it will be calculated to from the total number of children in
the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
define extra space between all children.
"""
newobj = _core_.new_GridSizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def SetCols(*args, **kwargs):
"""
SetCols(self, int cols)
Sets the number of columns in the sizer.
"""
return _core_.GridSizer_SetCols(*args, **kwargs)
def SetRows(*args, **kwargs):
"""
SetRows(self, int rows)
Sets the number of rows in the sizer.
"""
return _core_.GridSizer_SetRows(*args, **kwargs)
def SetVGap(*args, **kwargs):
"""
SetVGap(self, int gap)
Sets the vertical gap (in pixels) between the cells in the sizer.
"""
return _core_.GridSizer_SetVGap(*args, **kwargs)
def SetHGap(*args, **kwargs):
"""
SetHGap(self, int gap)
Sets the horizontal gap (in pixels) between cells in the sizer
"""
return _core_.GridSizer_SetHGap(*args, **kwargs)
def GetCols(*args, **kwargs):
"""
GetCols(self) -> int
Returns the number of columns in the sizer, as specified in the constructor.
"""
return _core_.GridSizer_GetCols(*args, **kwargs)
def GetRows(*args, **kwargs):
"""
GetRows(self) -> int
Returns the number of rows in the sizer, as specified in the constructor.
"""
return _core_.GridSizer_GetRows(*args, **kwargs)
def GetVGap(*args, **kwargs):
"""
GetVGap(self) -> int
Returns the vertical gap (in pixels) between the cells in the sizer.
"""
return _core_.GridSizer_GetVGap(*args, **kwargs)
def GetHGap(*args, **kwargs):
"""
GetHGap(self) -> int
Returns the horizontal gap (in pixels) between cells in the sizer.
"""
return _core_.GridSizer_GetHGap(*args, **kwargs)
def CalcRowsCols(self):
"""
CalcRowsCols() -> (rows, cols)
Calculates how many rows and columns will be in the sizer based
on the current number of items and also the rows, cols specified
in the constructor.
"""
nitems = len(self.GetChildren())
rows = self.GetRows()
cols = self.GetCols()
assert rows != 0 or cols != 0, "Grid sizer must have either rows or columns fixed"
if cols != 0:
rows = (nitems + cols - 1) / cols
elif rows != 0:
cols = (nitems + rows - 1) / rows
return (rows, cols)
class GridSizerPtr(GridSizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GridSizer
_core_.GridSizer_swigregister(GridSizerPtr)
#---------------------------------------------------------------------------
FLEX_GROWMODE_NONE = _core_.FLEX_GROWMODE_NONE
FLEX_GROWMODE_SPECIFIED = _core_.FLEX_GROWMODE_SPECIFIED
FLEX_GROWMODE_ALL = _core_.FLEX_GROWMODE_ALL
class FlexGridSizer(GridSizer):
"""
A flex grid sizer is a sizer which lays out its children in a
two-dimensional table with all table cells in one row having the same
height and all cells in one column having the same width, but all
rows or all columns are not necessarily the same height or width as in
the `wx.GridSizer`.
wx.FlexGridSizer can also size items equally in one direction but
unequally ("flexibly") in the other. If the sizer is only flexible
in one direction (this can be changed using `SetFlexibleDirection`), it
needs to be decided how the sizer should grow in the other ("non
flexible") direction in order to fill the available space. The
`SetNonFlexibleGrowMode` method serves this purpose.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxFlexGridSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int rows=1, int cols=0, int vgap=0, int hgap=0) -> FlexGridSizer
Constructor for a wx.FlexGridSizer. *rows* and *cols* determine the
number of columns and rows in the sizer - if either of the parameters
is zero, it will be calculated to from the total number of children in
the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
define extra space between all children.
"""
newobj = _core_.new_FlexGridSizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def AddGrowableRow(*args, **kwargs):
"""
AddGrowableRow(self, size_t idx, int proportion=0)
Specifies that row *idx* (starting from zero) should be grown if there
is extra space available to the sizer.
The *proportion* parameter has the same meaning as the stretch factor
for the box sizers except that if all proportions are 0, then all
columns are resized equally (instead of not being resized at all).
"""
return _core_.FlexGridSizer_AddGrowableRow(*args, **kwargs)
def RemoveGrowableRow(*args, **kwargs):
"""
RemoveGrowableRow(self, size_t idx)
Specifies that row *idx* is no longer growable.
"""
return _core_.FlexGridSizer_RemoveGrowableRow(*args, **kwargs)
def AddGrowableCol(*args, **kwargs):
"""
AddGrowableCol(self, size_t idx, int proportion=0)
Specifies that column *idx* (starting from zero) should be grown if
there is extra space available to the sizer.
The *proportion* parameter has the same meaning as the stretch factor
for the box sizers except that if all proportions are 0, then all
columns are resized equally (instead of not being resized at all).
"""
return _core_.FlexGridSizer_AddGrowableCol(*args, **kwargs)
def RemoveGrowableCol(*args, **kwargs):
"""
RemoveGrowableCol(self, size_t idx)
Specifies that column *idx* is no longer growable.
"""
return _core_.FlexGridSizer_RemoveGrowableCol(*args, **kwargs)
def SetFlexibleDirection(*args, **kwargs):
"""
SetFlexibleDirection(self, int direction)
Specifies whether the sizer should flexibly resize its columns, rows,
or both. Argument *direction* can be one of the following values. Any
other value is ignored.
============== =======================================
wx.VERTICAL Rows are flexibly sized.
wx.HORIZONTAL Columns are flexibly sized.
wx.BOTH Both rows and columns are flexibly sized
(this is the default value).
============== =======================================
Note that this method does not trigger relayout.
"""
return _core_.FlexGridSizer_SetFlexibleDirection(*args, **kwargs)
def GetFlexibleDirection(*args, **kwargs):
"""
GetFlexibleDirection(self) -> int
Returns a value that specifies whether the sizer
flexibly resizes its columns, rows, or both (default).
:see: `SetFlexibleDirection`
"""
return _core_.FlexGridSizer_GetFlexibleDirection(*args, **kwargs)
def SetNonFlexibleGrowMode(*args, **kwargs):
"""
SetNonFlexibleGrowMode(self, int mode)
Specifies how the sizer should grow in the non-flexible direction if
there is one (so `SetFlexibleDirection` must have been called
previously). Argument *mode* can be one of the following values:
========================== =================================================
wx.FLEX_GROWMODE_NONE Sizer doesn't grow in the non flexible direction.
wx.FLEX_GROWMODE_SPECIFIED Sizer honors growable columns/rows set with
`AddGrowableCol` and `AddGrowableRow`. In this
case equal sizing applies to minimum sizes of
columns or rows (this is the default value).
wx.FLEX_GROWMODE_ALL Sizer equally stretches all columns or rows in
the non flexible direction, whether they are
growable or not in the flexbile direction.
========================== =================================================
Note that this method does not trigger relayout.
"""
return _core_.FlexGridSizer_SetNonFlexibleGrowMode(*args, **kwargs)
def GetNonFlexibleGrowMode(*args, **kwargs):
"""
GetNonFlexibleGrowMode(self) -> int
Returns the value that specifies how the sizer grows in the
non-flexible direction if there is one.
:see: `SetNonFlexibleGrowMode`
"""
return _core_.FlexGridSizer_GetNonFlexibleGrowMode(*args, **kwargs)
def GetRowHeights(*args, **kwargs):
"""
GetRowHeights(self) -> list
Returns a list of integers representing the heights of each of the
rows in the sizer.
"""
return _core_.FlexGridSizer_GetRowHeights(*args, **kwargs)
def GetColWidths(*args, **kwargs):
"""
GetColWidths(self) -> list
Returns a list of integers representing the widths of each of the
columns in the sizer.
"""
return _core_.FlexGridSizer_GetColWidths(*args, **kwargs)
class FlexGridSizerPtr(FlexGridSizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = FlexGridSizer
_core_.FlexGridSizer_swigregister(FlexGridSizerPtr)
class StdDialogButtonSizer(BoxSizer):
"""
A special sizer that knows how to order and position standard buttons
in order to conform to the current platform's standards. You simply
need to add each `wx.Button` to the sizer, and be sure to create the
buttons using the standard ID's. Then call `Realize` and the sizer
will take care of the rest.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxStdDialogButtonSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""__init__(self) -> StdDialogButtonSizer"""
newobj = _core_.new_StdDialogButtonSizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def AddButton(*args, **kwargs):
"""
AddButton(self, wxButton button)
Use this to add the buttons to this sizer. Do not use the `Add`
method in the base class.
"""
return _core_.StdDialogButtonSizer_AddButton(*args, **kwargs)
def Realize(*args, **kwargs):
"""
Realize(self)
This funciton needs to be called after all the buttons have been added
to the sizer. It will reorder them and position them in a platform
specifc manner.
"""
return _core_.StdDialogButtonSizer_Realize(*args, **kwargs)
def SetAffirmativeButton(*args, **kwargs):
"""SetAffirmativeButton(self, wxButton button)"""
return _core_.StdDialogButtonSizer_SetAffirmativeButton(*args, **kwargs)
def SetNegativeButton(*args, **kwargs):
"""SetNegativeButton(self, wxButton button)"""
return _core_.StdDialogButtonSizer_SetNegativeButton(*args, **kwargs)
def SetCancelButton(*args, **kwargs):
"""SetCancelButton(self, wxButton button)"""
return _core_.StdDialogButtonSizer_SetCancelButton(*args, **kwargs)
def GetAffirmativeButton(*args, **kwargs):
"""GetAffirmativeButton(self) -> wxButton"""
return _core_.StdDialogButtonSizer_GetAffirmativeButton(*args, **kwargs)
def GetApplyButton(*args, **kwargs):
"""GetApplyButton(self) -> wxButton"""
return _core_.StdDialogButtonSizer_GetApplyButton(*args, **kwargs)
def GetNegativeButton(*args, **kwargs):
"""GetNegativeButton(self) -> wxButton"""
return _core_.StdDialogButtonSizer_GetNegativeButton(*args, **kwargs)
def GetCancelButton(*args, **kwargs):
"""GetCancelButton(self) -> wxButton"""
return _core_.StdDialogButtonSizer_GetCancelButton(*args, **kwargs)
def GetHelpButton(*args, **kwargs):
"""GetHelpButton(self) -> wxButton"""
return _core_.StdDialogButtonSizer_GetHelpButton(*args, **kwargs)
class StdDialogButtonSizerPtr(StdDialogButtonSizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = StdDialogButtonSizer
_core_.StdDialogButtonSizer_swigregister(StdDialogButtonSizerPtr)
#---------------------------------------------------------------------------
class GBPosition(object):
"""
This class represents the position of an item in a virtual grid of
rows and columns managed by a `wx.GridBagSizer`. wxPython has
typemaps that will automatically convert from a 2-element sequence of
integers to a wx.GBPosition, so you can use the more pythonic
representation of the position nearly transparently in Python code.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGBPosition instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int row=0, int col=0) -> GBPosition
This class represents the position of an item in a virtual grid of
rows and columns managed by a `wx.GridBagSizer`. wxPython has
typemaps that will automatically convert from a 2-element sequence of
integers to a wx.GBPosition, so you can use the more pythonic
representation of the position nearly transparently in Python code.
"""
newobj = _core_.new_GBPosition(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetRow(*args, **kwargs):
"""GetRow(self) -> int"""
return _core_.GBPosition_GetRow(*args, **kwargs)
def GetCol(*args, **kwargs):
"""GetCol(self) -> int"""
return _core_.GBPosition_GetCol(*args, **kwargs)
def SetRow(*args, **kwargs):
"""SetRow(self, int row)"""
return _core_.GBPosition_SetRow(*args, **kwargs)
def SetCol(*args, **kwargs):
"""SetCol(self, int col)"""
return _core_.GBPosition_SetCol(*args, **kwargs)
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Compare GBPosition for equality.
"""
return _core_.GBPosition___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Compare GBPosition for inequality.
"""
return _core_.GBPosition___ne__(*args, **kwargs)
def Set(*args, **kwargs):
"""Set(self, int row=0, int col=0)"""
return _core_.GBPosition_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""Get(self) -> PyObject"""
return _core_.GBPosition_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.GBPosition'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.SetRow(val)
elif index == 1: self.SetCol(val)
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.GBPosition, self.Get())
row = property(GetRow, SetRow)
col = property(GetCol, SetCol)
class GBPositionPtr(GBPosition):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GBPosition
_core_.GBPosition_swigregister(GBPositionPtr)
class GBSpan(object):
"""
This class is used to hold the row and column spanning attributes of
items in a `wx.GridBagSizer`. wxPython has typemaps that will
automatically convert from a 2-element sequence of integers to a
wx.GBSpan, so you can use the more pythonic representation of the span
nearly transparently in Python code.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGBSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int rowspan=1, int colspan=1) -> GBSpan
Construct a new wxGBSpan, optionally setting the rowspan and
colspan. The default is (1,1). (Meaning that the item occupies one
cell in each direction.
"""
newobj = _core_.new_GBSpan(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetRowspan(*args, **kwargs):
"""GetRowspan(self) -> int"""
return _core_.GBSpan_GetRowspan(*args, **kwargs)
def GetColspan(*args, **kwargs):
"""GetColspan(self) -> int"""
return _core_.GBSpan_GetColspan(*args, **kwargs)
def SetRowspan(*args, **kwargs):
"""SetRowspan(self, int rowspan)"""
return _core_.GBSpan_SetRowspan(*args, **kwargs)
def SetColspan(*args, **kwargs):
"""SetColspan(self, int colspan)"""
return _core_.GBSpan_SetColspan(*args, **kwargs)
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Compare wxGBSpan for equality.
"""
return _core_.GBSpan___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Compare GBSpan for inequality.
"""
return _core_.GBSpan___ne__(*args, **kwargs)
def Set(*args, **kwargs):
"""Set(self, int rowspan=1, int colspan=1)"""
return _core_.GBSpan_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""Get(self) -> PyObject"""
return _core_.GBSpan_Get(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.GBSpan'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.SetRowspan(val)
elif index == 1: self.SetColspan(val)
else: raise IndexError
def __nonzero__(self): return self.Get() != (0,0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.GBSpan, self.Get())
rowspan = property(GetRowspan, SetRowspan)
colspan = property(GetColspan, SetColspan)
class GBSpanPtr(GBSpan):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GBSpan
_core_.GBSpan_swigregister(GBSpanPtr)
class GBSizerItem(SizerItem):
"""
The wx.GBSizerItem class is used to track the additional data about
items in a `wx.GridBagSizer` such as the item's position in the grid
and how many rows or columns it spans.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGBSizerItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self) -> GBSizerItem
Constructs an empty wx.GBSizerItem. Either a window, sizer or spacer
size will need to be set, as well as a position and span before this
item can be used in a Sizer.
You will probably never need to create a wx.GBSizerItem directly as they
are created automatically when the sizer's Add method is called.
"""
newobj = _core_.new_GBSizerItem(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetPos(*args, **kwargs):
"""
GetPos(self) -> GBPosition
Get the grid position of the item
"""
return _core_.GBSizerItem_GetPos(*args, **kwargs)
def GetPosTuple(self): return self.GetPos().Get()
def GetSpan(*args, **kwargs):
"""
GetSpan(self) -> GBSpan
Get the row and column spanning of the item
"""
return _core_.GBSizerItem_GetSpan(*args, **kwargs)
def GetSpanTuple(self): return self.GetSpan().Get()
def SetPos(*args, **kwargs):
"""
SetPos(self, GBPosition pos) -> bool
If the item is already a member of a sizer then first ensure that
there is no other item that would intersect with this one at the new
position, then set the new position. Returns True if the change is
successful and after the next Layout() the item will be moved.
"""
return _core_.GBSizerItem_SetPos(*args, **kwargs)
def SetSpan(*args, **kwargs):
"""
SetSpan(self, GBSpan span) -> bool
If the item is already a member of a sizer then first ensure that
there is no other item that would intersect with this one with its new
spanning size, then set the new spanning. Returns True if the change
is successful and after the next Layout() the item will be resized.
"""
return _core_.GBSizerItem_SetSpan(*args, **kwargs)
def Intersects(*args, **kwargs):
"""
Intersects(self, GBSizerItem other) -> bool
Returns True if this item and the other item instersect.
"""
return _core_.GBSizerItem_Intersects(*args, **kwargs)
def IntersectsPos(*args, **kwargs):
"""
IntersectsPos(self, GBPosition pos, GBSpan span) -> bool
Returns True if the given pos/span would intersect with this item.
"""
return _core_.GBSizerItem_IntersectsPos(*args, **kwargs)
def GetEndPos(*args, **kwargs):
"""
GetEndPos(self) -> GBPosition
Get the row and column of the endpoint of this item.
"""
return _core_.GBSizerItem_GetEndPos(*args, **kwargs)
def GetGBSizer(*args, **kwargs):
"""
GetGBSizer(self) -> GridBagSizer
Get the sizer this item is a member of.
"""
return _core_.GBSizerItem_GetGBSizer(*args, **kwargs)
def SetGBSizer(*args, **kwargs):
"""
SetGBSizer(self, GridBagSizer sizer)
Set the sizer this item is a member of.
"""
return _core_.GBSizerItem_SetGBSizer(*args, **kwargs)
class GBSizerItemPtr(GBSizerItem):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GBSizerItem
_core_.GBSizerItem_swigregister(GBSizerItemPtr)
DefaultSpan = cvar.DefaultSpan
def GBSizerItemWindow(*args, **kwargs):
"""
GBSizerItemWindow(Window window, GBPosition pos, GBSpan span, int flag,
int border, PyObject userData=None) -> GBSizerItem
Construct a `wx.GBSizerItem` for a window.
"""
val = _core_.new_GBSizerItemWindow(*args, **kwargs)
val.thisown = 1
return val
def GBSizerItemSizer(*args, **kwargs):
"""
GBSizerItemSizer(Sizer sizer, GBPosition pos, GBSpan span, int flag,
int border, PyObject userData=None) -> GBSizerItem
Construct a `wx.GBSizerItem` for a sizer
"""
val = _core_.new_GBSizerItemSizer(*args, **kwargs)
val.thisown = 1
return val
def GBSizerItemSpacer(*args, **kwargs):
"""
GBSizerItemSpacer(int width, int height, GBPosition pos, GBSpan span,
int flag, int border, PyObject userData=None) -> GBSizerItem
Construct a `wx.GBSizerItem` for a spacer.
"""
val = _core_.new_GBSizerItemSpacer(*args, **kwargs)
val.thisown = 1
return val
class GridBagSizer(FlexGridSizer):
"""
A `wx.Sizer` that can lay out items in a virtual grid like a
`wx.FlexGridSizer` but in this case explicit positioning of the items
is allowed using `wx.GBPosition`, and items can optionally span more
than one row and/or column using `wx.GBSpan`. The total size of the
virtual grid is determined by the largest row and column that items are
positioned at, adjusted for spanning.
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridBagSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
__init__(self, int vgap=0, int hgap=0) -> GridBagSizer
Constructor, with optional parameters to specify the gap between the
rows and columns.
"""
newobj = _core_.new_GridBagSizer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
self._setOORInfo(self)
def Add(*args, **kwargs):
"""
Add(self, item, GBPosition pos, GBSpan span=DefaultSpan, int flag=0,
int border=0, userData=None) -> wx.GBSizerItem
Adds an item to the sizer at the grid cell *pos*, optionally spanning
more than one row or column as specified with *span*. The remaining
args behave similarly to `wx.Sizer.Add`.
Returns True if the item was successfully placed at the given cell
position, False if something was already there.
"""
return _core_.GridBagSizer_Add(*args, **kwargs)
def AddItem(*args, **kwargs):
"""
Add(self, GBSizerItem item) -> wx.GBSizerItem
Add an item to the sizer using a `wx.GBSizerItem`. Returns True if
the item was successfully placed at its given cell position, False if
something was already there.
"""
return _core_.GridBagSizer_AddItem(*args, **kwargs)
def GetCellSize(*args, **kwargs):
"""
GetCellSize(self, int row, int col) -> Size
Get the size of the specified cell, including hgap and
vgap. Only valid after a Layout.
"""
return _core_.GridBagSizer_GetCellSize(*args, **kwargs)
def GetEmptyCellSize(*args, **kwargs):
"""
GetEmptyCellSize(self) -> Size
Get the size used for cells in the grid with no item.
"""
return _core_.GridBagSizer_GetEmptyCellSize(*args, **kwargs)
def SetEmptyCellSize(*args, **kwargs):
"""
SetEmptyCellSize(self, Size sz)
Set the size used for cells in the grid with no item.
"""
return _core_.GridBagSizer_SetEmptyCellSize(*args, **kwargs)
def GetItemPosition(*args):
"""
GetItemPosition(self, item) -> GBPosition
Get the grid position of the specified *item* where *item* is either a
window or subsizer that is a member of this sizer, or a zero-based
index of an item.
"""
return _core_.GridBagSizer_GetItemPosition(*args)
def SetItemPosition(*args):
"""
SetItemPosition(self, item, GBPosition pos) -> bool
Set the grid position of the specified *item* where *item* is either a
window or subsizer that is a member of this sizer, or a zero-based
index of an item. Returns True on success. If the move is not
allowed (because an item is already there) then False is returned.
"""
return _core_.GridBagSizer_SetItemPosition(*args)
def GetItemSpan(*args):
"""
GetItemSpan(self, item) -> GBSpan
Get the row/col spanning of the specified *item* where *item* is
either a window or subsizer that is a member of this sizer, or a
zero-based index of an item.
"""
return _core_.GridBagSizer_GetItemSpan(*args)
def SetItemSpan(*args):
"""
SetItemSpan(self, item, GBSpan span) -> bool
Set the row/col spanning of the specified *item* where *item* is
either a window or subsizer that is a member of this sizer, or a
zero-based index of an item. Returns True on success. If the move is
not allowed (because an item is already there) then False is returned.
"""
return _core_.GridBagSizer_SetItemSpan(*args)
def FindItem(*args):
"""
FindItem(self, item) -> GBSizerItem
Find the sizer item for the given window or subsizer, returns None if
not found. (non-recursive)
"""
return _core_.GridBagSizer_FindItem(*args)
def FindItemAtPosition(*args, **kwargs):
"""
FindItemAtPosition(self, GBPosition pos) -> GBSizerItem
Return the sizer item for the given grid cell, or None if there is no
item at that position. (non-recursive)
"""
return _core_.GridBagSizer_FindItemAtPosition(*args, **kwargs)
def FindItemAtPoint(*args, **kwargs):
"""
FindItemAtPoint(self, Point pt) -> GBSizerItem
Return the sizer item located at the point given in *pt*, or None if
there is no item at that point. The (x,y) coordinates in pt correspond
to the client coordinates of the window using the sizer for
layout. (non-recursive)
"""
return _core_.GridBagSizer_FindItemAtPoint(*args, **kwargs)
def CheckForIntersection(*args, **kwargs):
"""
CheckForIntersection(self, GBSizerItem item, GBSizerItem excludeItem=None) -> bool
Look at all items and see if any intersect (or would overlap) the
given *item*. Returns True if so, False if there would be no overlap.
If an *excludeItem* is given then it will not be checked for
intersection, for example it may be the item we are checking the
position of.
"""
return _core_.GridBagSizer_CheckForIntersection(*args, **kwargs)
def CheckForIntersectionPos(*args, **kwargs):
"""
CheckForIntersectionPos(self, GBPosition pos, GBSpan span, GBSizerItem excludeItem=None) -> bool
Look at all items and see if any intersect (or would overlap) the
given position and span. Returns True if so, False if there would be
no overlap. If an *excludeItem* is given then it will not be checked
for intersection, for example it may be the item we are checking the
position of.
"""
return _core_.GridBagSizer_CheckForIntersectionPos(*args, **kwargs)
class GridBagSizerPtr(GridBagSizer):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GridBagSizer
_core_.GridBagSizer_swigregister(GridBagSizerPtr)
#---------------------------------------------------------------------------
Left = _core_.Left
Top = _core_.Top
Right = _core_.Right
Bottom = _core_.Bottom
Width = _core_.Width
Height = _core_.Height
Centre = _core_.Centre
Center = _core_.Center
CentreX = _core_.CentreX
CentreY = _core_.CentreY
Unconstrained = _core_.Unconstrained
AsIs = _core_.AsIs
PercentOf = _core_.PercentOf
Above = _core_.Above
Below = _core_.Below
LeftOf = _core_.LeftOf
RightOf = _core_.RightOf
SameAs = _core_.SameAs
Absolute = _core_.Absolute
class IndividualLayoutConstraint(Object):
"""
Objects of this class are stored in the `wx.LayoutConstraints` class as
one of eight possible constraints that a window can be involved in.
You will never need to create an instance of
wx.IndividualLayoutConstraint, rather you should create a
`wx.LayoutConstraints` instance and use the individual contstraints
that it contains.
"""
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxIndividualLayoutConstraint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Set(*args, **kwargs):
"""
Set(self, int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN)
Sets the properties of the constraint. Normally called by one of the
convenience functions such as Above, RightOf, SameAs.
"""
return _core_.IndividualLayoutConstraint_Set(*args, **kwargs)
def LeftOf(*args, **kwargs):
"""
LeftOf(self, Window sibling, int marg=0)
Constrains this edge to be to the left of the given window, with an
optional margin. Implicitly, this is relative to the left edge of the
other window.
"""
return _core_.IndividualLayoutConstraint_LeftOf(*args, **kwargs)
def RightOf(*args, **kwargs):
"""
RightOf(self, Window sibling, int marg=0)
Constrains this edge to be to the right of the given window, with an
optional margin. Implicitly, this is relative to the right edge of the
other window.
"""
return _core_.IndividualLayoutConstraint_RightOf(*args, **kwargs)
def Above(*args, **kwargs):
"""
Above(self, Window sibling, int marg=0)
Constrains this edge to be above the given window, with an optional
margin. Implicitly, this is relative to the top edge of the other
window.
"""
return _core_.IndividualLayoutConstraint_Above(*args, **kwargs)
def Below(*args, **kwargs):
"""
Below(self, Window sibling, int marg=0)
Constrains this edge to be below the given window, with an optional
margin. Implicitly, this is relative to the bottom edge of the other
window.
"""
return _core_.IndividualLayoutConstraint_Below(*args, **kwargs)
def SameAs(*args, **kwargs):
"""
SameAs(self, Window otherW, int edge, int marg=0)
Constrains this edge or dimension to be to the same as the edge of the
given window, with an optional margin.
"""
return _core_.IndividualLayoutConstraint_SameAs(*args, **kwargs)
def PercentOf(*args, **kwargs):
"""
PercentOf(self, Window otherW, int wh, int per)
Constrains this edge or dimension to be to a percentage of the given
window, with an optional margin.
"""
return _core_.IndividualLayoutConstraint_PercentOf(*args, **kwargs)
def Absolute(*args, **kwargs):
"""
Absolute(self, int val)
Constrains this edge or dimension to be the given absolute value.
"""
return _core_.IndividualLayoutConstraint_Absolute(*args, **kwargs)
def Unconstrained(*args, **kwargs):
"""
Unconstrained(self)
Sets this edge or dimension to be unconstrained, that is, dependent on
other edges and dimensions from which this value can be deduced.
"""
return _core_.IndividualLayoutConstraint_Unconstrained(*args, **kwargs)
def AsIs(*args, **kwargs):
"""
AsIs(self)
Sets this edge or constraint to be whatever the window's value is at
the moment. If either of the width and height constraints are *as is*,
the window will not be resized, but moved instead. This is important
when considering panel items which are intended to have a default
size, such as a button, which may take its size from the size of the
button label.
"""
return _core_.IndividualLayoutConstraint_AsIs(*args, **kwargs)
def GetOtherWindow(*args, **kwargs):
"""GetOtherWindow(self) -> Window"""
return _core_.IndividualLayoutConstraint_GetOtherWindow(*args, **kwargs)
def GetMyEdge(*args, **kwargs):
"""GetMyEdge(self) -> int"""
return _core_.IndividualLayoutConstraint_GetMyEdge(*args, **kwargs)
def SetEdge(*args, **kwargs):
"""SetEdge(self, int which)"""
return _core_.IndividualLayoutConstraint_SetEdge(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, int v)"""
return _core_.IndividualLayoutConstraint_SetValue(*args, **kwargs)
def GetMargin(*args, **kwargs):
"""GetMargin(self) -> int"""
return _core_.IndividualLayoutConstraint_GetMargin(*args, **kwargs)
def SetMargin(*args, **kwargs):
"""SetMargin(self, int m)"""
return _core_.IndividualLayoutConstraint_SetMargin(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> int"""
return _core_.IndividualLayoutConstraint_GetValue(*args, **kwargs)
def GetPercent(*args, **kwargs):
"""GetPercent(self) -> int"""
return _core_.IndividualLayoutConstraint_GetPercent(*args, **kwargs)
def GetOtherEdge(*args, **kwargs):
"""GetOtherEdge(self) -> int"""
return _core_.IndividualLayoutConstraint_GetOtherEdge(*args, **kwargs)
def GetDone(*args, **kwargs):
"""GetDone(self) -> bool"""
return _core_.IndividualLayoutConstraint_GetDone(*args, **kwargs)
def SetDone(*args, **kwargs):
"""SetDone(self, bool d)"""
return _core_.IndividualLayoutConstraint_SetDone(*args, **kwargs)
def GetRelationship(*args, **kwargs):
"""GetRelationship(self) -> int"""
return _core_.IndividualLayoutConstraint_GetRelationship(*args, **kwargs)
def SetRelationship(*args, **kwargs):
"""SetRelationship(self, int r)"""
return _core_.IndividualLayoutConstraint_SetRelationship(*args, **kwargs)
def ResetIfWin(*args, **kwargs):
"""
ResetIfWin(self, Window otherW) -> bool
Reset constraint if it mentions otherWin
"""
return _core_.IndividualLayoutConstraint_ResetIfWin(*args, **kwargs)
def SatisfyConstraint(*args, **kwargs):
"""
SatisfyConstraint(self, LayoutConstraints constraints, Window win) -> bool
Try to satisfy constraint
"""
return _core_.IndividualLayoutConstraint_SatisfyConstraint(*args, **kwargs)
def GetEdge(*args, **kwargs):
"""
GetEdge(self, int which, Window thisWin, Window other) -> int
Get the value of this edge or dimension, or if this
is not determinable, -1.
"""
return _core_.IndividualLayoutConstraint_GetEdge(*args, **kwargs)
class IndividualLayoutConstraintPtr(IndividualLayoutConstraint):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = IndividualLayoutConstraint
_core_.IndividualLayoutConstraint_swigregister(IndividualLayoutConstraintPtr)
class LayoutConstraints(Object):
"""
**Note:** constraints are now deprecated and you should use sizers
instead.
Objects of this class can be associated with a window to define its
layout constraints, with respect to siblings or its parent.
The class consists of the following eight constraints of class
wx.IndividualLayoutConstraint, some or all of which should be accessed
directly to set the appropriate constraints.
* left: represents the left hand edge of the window
* right: represents the right hand edge of the window
* top: represents the top edge of the window
* bottom: represents the bottom edge of the window
* width: represents the width of the window
* height: represents the height of the window
* centreX: represents the horizontal centre point of the window
* centreY: represents the vertical centre point of the window
Most constraints are initially set to have the relationship
wxUnconstrained, which means that their values should be calculated by
looking at known constraints. The exceptions are width and height,
which are set to wxAsIs to ensure that if the user does not specify a
constraint, the existing width and height will be used, to be
compatible with panel items which often have take a default size. If
the constraint is ``wx.AsIs``, the dimension will not be changed.
:see: `wx.IndividualLayoutConstraint`, `wx.Window.SetConstraints`
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxLayoutConstraints instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
left = property(_core_.LayoutConstraints_left_get)
top = property(_core_.LayoutConstraints_top_get)
right = property(_core_.LayoutConstraints_right_get)
bottom = property(_core_.LayoutConstraints_bottom_get)
width = property(_core_.LayoutConstraints_width_get)
height = property(_core_.LayoutConstraints_height_get)
centreX = property(_core_.LayoutConstraints_centreX_get)
centreY = property(_core_.LayoutConstraints_centreY_get)
def __init__(self, *args, **kwargs):
"""__init__(self) -> LayoutConstraints"""
newobj = _core_.new_LayoutConstraints(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SatisfyConstraints(*args, **kwargs):
"""SatisfyConstraints(Window win) -> (areSatisfied, noChanges)"""
return _core_.LayoutConstraints_SatisfyConstraints(*args, **kwargs)
def AreSatisfied(*args, **kwargs):
"""AreSatisfied(self) -> bool"""
return _core_.LayoutConstraints_AreSatisfied(*args, **kwargs)
class LayoutConstraintsPtr(LayoutConstraints):
def __init__(self, this):
self.this = this
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = LayoutConstraints
_core_.LayoutConstraints_swigregister(LayoutConstraintsPtr)
#----------------------------------------------------------------------------
# Use Python's bool constants if available, make some if not
try:
True
except NameError:
__builtins__.True = 1==1
__builtins__.False = 1==0
def bool(value): return not not value
__builtins__.bool = bool
# workarounds for bad wxRTTI names
__wxPyPtrTypeMap['wxGauge95'] = 'wxGauge'
__wxPyPtrTypeMap['wxSlider95'] = 'wxSlider'
__wxPyPtrTypeMap['wxStatusBar95'] = 'wxStatusBar'
#----------------------------------------------------------------------------
# Load version numbers from __version__... Ensure that major and minor
# versions are the same for both wxPython and wxWidgets.
from __version__ import *
__version__ = VERSION_STRING
assert MAJOR_VERSION == _core_.MAJOR_VERSION, "wxPython/wxWidgets version mismatch"
assert MINOR_VERSION == _core_.MINOR_VERSION, "wxPython/wxWidgets version mismatch"
if RELEASE_VERSION != _core_.RELEASE_VERSION:
import warnings
warnings.warn("wxPython/wxWidgets release number mismatch")
#----------------------------------------------------------------------------
# Set wxPython's default string<-->unicode conversion encoding from
# the locale, but only if Python's default hasn't been changed. (We
# assume that if the user has customized it already then that is the
# encoding we need to use as well.)
#
# The encoding selected here is used when string or unicode objects
# need to be converted in order to pass them to wxWidgets. Please be
# aware that the default encoding within the same locale may be
# slightly different on different platforms. For example, please see
# http://www.alanwood.net/demos/charsetdiffs.html for differences
# between the common latin/roman encodings.
default = _sys.getdefaultencoding()
if default == 'ascii':
import locale
import codecs
try:
default = locale.getdefaultlocale()[1]
codecs.lookup(default)
except (ValueError, LookupError, TypeError):
default = _sys.getdefaultencoding()
del locale
del codecs
if default:
wx.SetDefaultPyEncoding(default)
del default
#----------------------------------------------------------------------------
class PyDeadObjectError(AttributeError):
pass
class _wxPyDeadObject(object):
"""
Instances of wx objects that are OOR capable will have their __class__
changed to this class when the C++ object is deleted. This should help
prevent crashes due to referencing a bogus C++ pointer.
"""
reprStr = "wxPython wrapper for DELETED %s object! (The C++ object no longer exists.)"
attrStr = "The C++ part of the %s object has been deleted, attribute access no longer allowed."
def __repr__(self):
if not hasattr(self, "_name"):
self._name = "[unknown]"
return self.reprStr % self._name
def __getattr__(self, *args):
if not hasattr(self, "_name"):
self._name = "[unknown]"
raise PyDeadObjectError(self.attrStr % self._name)
def __nonzero__(self):
return 0
class PyUnbornObjectError(AttributeError):
pass
class _wxPyUnbornObject(object):
"""
Some stock objects are created when the wx._core module is
imported, but their C++ instance is not created until the wx.App
object is created and initialized. These object instances will
temporarily have their __class__ changed to this class so an
exception will be raised if they are used before the C++ instance
is ready.
"""
reprStr = "wxPython wrapper for UNBORN object! (The C++ object is not initialized yet.)"
attrStr = "The C++ part of this object has not been initialized, attribute access not allowed."
def __repr__(self):
#if not hasattr(self, "_name"):
# self._name = "[unknown]"
return self.reprStr #% self._name
def __getattr__(self, *args):
#if not hasattr(self, "_name"):
# self._name = "[unknown]"
raise PyUnbornObjectError(self.attrStr) # % self._name )
def __nonzero__(self):
return 0
#----------------------------------------------------------------------------
def CallAfter(callable, *args, **kw):
"""
Call the specified function after the current and pending event
handlers have been completed. This is also good for making GUI
method calls from non-GUI threads. Any extra positional or
keyword args are passed on to the callable when it is called.
:see: `wx.FutureCall`
"""
app = wx.GetApp()
assert app is not None, 'No wx.App created yet'
if not hasattr(app, "_CallAfterId"):
app._CallAfterId = wx.NewEventType()
app.Connect(-1, -1, app._CallAfterId,
lambda event: event.callable(*event.args, **event.kw) )
evt = wx.PyEvent()
evt.SetEventType(app._CallAfterId)
evt.callable = callable
evt.args = args
evt.kw = kw
wx.PostEvent(app, evt)
#----------------------------------------------------------------------------
class FutureCall:
"""
A convenience class for `wx.Timer`, that calls the given callable
object once after the given amount of milliseconds, passing any
positional or keyword args. The return value of the callable is
availbale after it has been run with the `GetResult` method.
If you don't need to get the return value or restart the timer
then there is no need to hold a reference to this object. It will
hold a reference to itself while the timer is running (the timer
has a reference to self.Notify) but the cycle will be broken when
the timer completes, automatically cleaning up the wx.FutureCall
object.
:see: `wx.CallAfter`
"""
def __init__(self, millis, callable, *args, **kwargs):
self.millis = millis
self.callable = callable
self.SetArgs(*args, **kwargs)
self.runCount = 0
self.running = False
self.hasRun = False
self.result = None
self.timer = None
self.Start()
def __del__(self):
self.Stop()
def Start(self, millis=None, *args, **kwargs):
"""
(Re)start the timer
"""
self.hasRun = False
if millis is not None:
self.millis = millis
if args or kwargs:
self.SetArgs(*args, **kwargs)
self.Stop()
self.timer = wx.PyTimer(self.Notify)
self.timer.Start(self.millis, wx.TIMER_ONE_SHOT)
self.running = True
Restart = Start
def Stop(self):
"""
Stop and destroy the timer.
"""
if self.timer is not None:
self.timer.Stop()
self.timer = None
def GetInterval(self):
if self.timer is not None:
return self.timer.GetInterval()
else:
return 0
def IsRunning(self):
return self.timer is not None and self.timer.IsRunning()
def SetArgs(self, *args, **kwargs):
"""
(Re)set the args passed to the callable object. This is
useful in conjunction with Restart if you want to schedule a
new call to the same callable object but with different
parameters.
"""
self.args = args
self.kwargs = kwargs
def HasRun(self):
return self.hasRun
def GetResult(self):
return self.result
def Notify(self):
"""
The timer has expired so call the callable.
"""
if self.callable and getattr(self.callable, 'im_self', True):
self.runCount += 1
self.running = False
self.result = self.callable(*self.args, **self.kwargs)
self.hasRun = True
if not self.running:
# if it wasn't restarted, then cleanup
wx.CallAfter(self.Stop)
#----------------------------------------------------------------------------
# Control which items in this module should be documented by epydoc.
# We allow only classes and functions, which will help reduce the size
# of the docs by filtering out the zillions of constants, EVT objects,
# and etc that don't make much sense by themselves, but are instead
# documented (or will be) as part of the classes/functions/methods
# where they should be used.
class __DocFilter:
"""
A filter for epydoc that only allows non-Ptr classes and
fucntions, in order to reduce the clutter in the API docs.
"""
def __init__(self, globals):
self._globals = globals
def __call__(self, name):
import types
obj = self._globals.get(name, None)
if type(obj) not in [type, types.ClassType, types.FunctionType, types.BuiltinFunctionType]:
return False
if name.startswith('_') or name.endswith('Ptr') or name.startswith('EVT'):
return False
return True
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# Import other modules in this package that should show up in the
# "core" wx namespace
from _gdi import *
from _windows import *
from _controls import *
from _misc import *
# Fixup the stock objects since they can't be used yet. (They will be
# restored in wx.PyApp.OnInit.)
_core_._wxPyFixStockObjects()
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
|