# Just Launched: You can now import projects and releases from Google Code onto SourceForge

We are excited to release new functionality to enable a 1-click import from Google Code onto the Allura platform on SourceForge. You can import tickets, wikis, source, releases, and more with a few simple steps.

## [6fe32e]: changelog.txt Maximize Restore History

Parent: [2c229c] (diff)

Child: [fd2585] (diff)

### changelog.txt    1308 lines (1212 with data), 77.8 kB

  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 #--------------------------------- PyPE 2.3 ---------------------------------- (fixed) setup.py for non-Windows platforms. (added) embedded Python shell. Uses the platform-defined 'python' to run an interpreter in another process. Because the interpreter is not running in the same process, it is not susceptible to the 'while 1:pass' issue that other in-process interpreters seem to have. wxPython and Tk should work without issue in this shell. You get syntax highlighting. (added) embedded command shell. You get a shell to either 'cmd' on Windows, or '/bin/sh' on *nix. Note: The above two shells replace the old shell tab in the bottom toolbar, and act like documents. (changed) When using "Replace All" and "Replace in Selection", you will now notice that your view is constantly updated as the replacements are advancing. You can stop the replacement by closing the replace bar (via the "close" button, hitting "escape" while one of the replace bar text entries has focus, or by attempting to close the document - it will cancel the replacement whether you actually close the document or not)). (fixed) the title for the trigger setting dialog. (added) menu items for TeX/LaTeX support and made it easier to add support for more languages in the future. Will probably at some time attempt to integrate a version of the STCStyleEditor into PyPE, along with a menu to customize which languages to show in the Open dialog, as well as the Syntax Highlighting and various save/load settings menus. (updated) the STCStyleEditor.py to the most recent version shipped with the wxPython 2.6 Docs and Demos. (replaced) the STCStyleEditor.py for style changes. When running along with threads (which weren't accessing the GUI), it tended to crash Python and wxPython. I can supply a proof-of-concept minimal application which crashes the STC quite reliably. I've replaced it with a work-alike which doesn't use wxFileConfig, and should do essentially everything STCStyleEditor does for style changes. (added) a better/stronger slow parser. This slow parser offers docstrings, better support for multi-line function signature definitions, and a correct hierarchical source tree. It will do its job in a background thread, unless your code has a syntax error, in which case it will switch to the fast parser. Note: the slow parser can be 3-100 times slower than the fast parser, depending on the structure of the document. (added) full style support for Pyrex (gets its own entries in the stc-styles file. (changed) embedded Python shell to be faster when sending code to the underlying shell. (fixed) embedded Python shell to not duplicate '... ' and '>>> ' prompt prefixes. (changed) in the embedded Python shell, numpad enter is the same as the normal enter, and ctrl+enter sends the current contents of the buffer plus a line feed, regardless of the Python parsing or not (to handle raw_input from the underlying shell). (added) spell checker with support for custom dictionaries, a very simple spelling suggester, and alternate user-defined alphabets (for languages where this makes sense), see the readme. (fixed) Options->Title Options will now also update the title whenever you switch documents. (changed) made all of the block submenus for options (Line Ending, Long Line Indicator, Default Highlighting, Toolbar, and Caret Options) into blocks of data, which reduced the number of global ids significantly. (contemplating) switching to ReStructured Text for the help file, then using the ReST to generate an HTML help file, which then gets viewed via the Help. PyPE could definitely use better documentation. (added) try/except, try/finally, and try/except/finally wrapping of selected code to new Transforms menu. (changed) moved code transformations indenting, wrapping, commenting, and perform trigger to the new transforms menu, from the edit menu. (added) code path for 'insert comment' for C/C++, HTML/XML, and LaTeX. (added) code path for 'comment/uncomment selection' for LaTeX. (added) sample_alphabet.txt for english and sample_dictionary.txt from Scowl 6 english-words.10 for examples of input. (updated) auto-indent/dedent code for break/continue and the forthcoming 'with' statement. (added) \section, \subsection, \subsubsection, \label, and %todo: support for latex. (added) \\todo: support for C/C++ (wanted) a decent parser for C/C++ (fixed) pasting in Python/command shells to properly handle pasting of text without line endings. (added) Options->Save preferences to save your current preferences (some slight protection against OS crash, etc.) #-------------------------------- PyPE 2.2.2 --------------------------------- (added) Ability to have the toolbar hidden, on the top, or on the left side. Feature thanks to Dave Schuyler. (added) Ability to use tabs inside the shell combobox. On some platforms it will show a box glyph, but it will send an actual tab character to the program. Now interactive Python sessions (without syntax highlighting) are a bit better. Note: future versions of the shell will be much better. (changed) The 'search' tab now has separated the 'path' and 'filename' portions of results when used in the table version. (added) Ability to automatically forward open document requests to a single running PyPE instance. Uses a socket listening on 127.0.0.1, port 9999. See the readme/help for details. (fixed) Segfaults on linux were caused by an icon size mismatch. This has been fixed. A big thank you to Michele Petrazzo for figuring out where the problem was (I don't have a linux box for testing). #-------------------------------- PyPE 2.2.1 --------------------------------- (fixed) exception when opening any document (new or old). #--------------------------------- PyPE 2.2 ---------------------------------- (removed) a debug statement or two. (added) installation section to readme. (fixed) a bug where new saved documents wouldn't close, and their states wouldn't be saved. (changed) when switching to a different document (for any reason), PyPE now selects the editor portion of the window. Previously if one selected the tab of a document, or a document in the document tab, it would keep those particular items selected, resulting in strange arrow/typing behavior. (fixed) when changing menu item names, previously one needed to choose a hotkey in order to make name changes stick (then clearing the hotkey if necessary). Now your changes will take effect as long as you keep clicking 'OK'. (changed) tweaked the C/C++ indentation on {} rules to more closely match the most common style guides. (added) 'public' keyword to pyrex syntax highlighting. (changed) When selecting an item from the results in the 'search' tab, the exact item that was found will be selected if possible. Possible incorrect selection conditions: * if the file contents have changed, the same line number where the match was originally found will be selected, if it exists * if one is searching for a string that is quoted or commented, and something that matches is discovered before the quote or comment, that earlier match will be shown instead (fixed) currently untitled documents will now have their 'file name' displayed in the search results. (fixed) choosing an untitled document in the 'search' tab will now go to the proper file. (fixed) the search tab will now not duplicate entries in the 'selected text', 'current file', 'current file with includes', or 'open files' scopes when multiple paths are listed in "Directories", and will actually produce results when there is nothing in "Directories". (fixed) searching in currently open unicode files (it works now), unicode files on disk still have issues. (changed) the 'to be searched for' string in the 'search' tab now supports string escaping like the find/replace bars. (changed) if your search string for the 'search' tab includes at least one line ending, then multiline will be automatically enabled during the search, but will not be shown in the options. (added) for unicode-enabled versions: PyPE will respect the "Encoding declaration" during file load, as specified in the "Python Reference Manual" aka the "Language Reference", if no Byte Order Mark (BOM) is present. It will also alert the user to any failure in decoding the loaded file. (added) for unicode-enabled versions: if Document->Encodings is set to 'other', PyPE will attempt to encode the file as specified in the "Encoding declaration", and will alert the user on failure to encode the file. Note: PyPE will not add/alter/change the encoding declaration, but it will respect them. (added) for unicode-enabled versions: a tab next to Shell which produces the repr() of a given block of text. Not a huge feature, but convenient for working with unicode and Python consoles. (added) View->Go to position for jumping to a particular position in a file. Note that this may be slow on large files because Scintilla uses an internal utf-8 representation. This means that in order to find the current position in the file, one must necessarily iterate up to that position to discover all multibyte characters. This is further uglified by Scintilla considering Windows line endings '\r\n' as a single character in stc.GetPositionAfter(). (changed) non-unicode versions of PyPE will use history.txt and menu.txt to store preferences. unicode enabled versions of PyPE will use history.u.txt and menu.u.txt to store preferences. (added) Options->Findbar below editor option, when unchecked, find/replace bars will be above the editor instead of below it. (added) shell command support and interaction embedded in PyPE, or embedded within a new terminal (on Windows, the terminal only exists if necessary, on other platforms, it uses xterm so the terminal may exist even if it is not necessary). (fixed) creating a new document (via menu or hotkey) will now focus the cursor in the new document. (fixed) selecting search context (directories, current files, etc.) in the search tab will now disable options which are not relevant to the current search context. (updated) readme.txt #-------------------------------- PyPE 2.1.1 --------------------------------- (fixed) a bug where PyPE would fail to load if the user had run certain PyPE beta releases. (fixed) a bug where win and win-unicode versions would fail to load if PyPE couldn't find your home directory. #--------------------------------- PyPE 2.1 ---------------------------------- (fixed) a bug when saving a file at the root of a drive on Windows wouldn't quite work. (fixed) a bug that would cause windows-unicode using versions of PyPE to not realize they were unicode-enabled when they were installed in a path without '-unicode' contained in them. (changed) PyPE no longer saves state information (bookmarks, folding, etc.) about a document if the document is different from what is on disk. (changed) Opening a document that has a different md5 than what PyPE last saw now ignores saved cursor position information, bookmarks, and folding for that opened document. (fixed) broken state saving when documents are closed individually. (changed) increased the recent document memory from 64 to 128 documents. (added) portion to parser to pull out cdef names for Pyrex files. (added) keywords and filename masks for Pyrex files (uses the Python lexer and settings). (added) auto-indent/dedent on 'enter' keypress for C code, based on curly braces '{}' and the existence of 'return' as the first non-whitespace item on the line. (fixed) an issue where documents listed in the documents tab would not have their modified '*' prefix set or reset properly unless the document was dragged around (and sometimes not even then). (fixed) updated definition of findbar.ReplaceBar.setup to make findbar.FindBar.setup unnecessary. (changed) renamed Document->Indent Width to Document->Set Indent Width, which may remove the hotkey if someone had one bound to that menu item. (fixed) Settings loading/saving options in per-document settings. (added) Jumping forward and backward to matched parens, braces, etc. See View->Jump Forward and View->Jump Backward (if you use these, you should set a hotkey or two). (added) Triggers functionality. Works in a similar fashion to TextMate's triggers, and can be used in a similar fashion to TextMate's Smart typing. (removed) unused code relating to the browsable source tree, which fixes some bugs for those using a recent version of wxPython. (added) option to relocate the Todo tab to between the Line and Documents tab, see Options->Wide Todo . (fixed) when double-clicking on a result in the Search tab, will now make sure that the line is actually displayed, unfolding if necessary. (added) optional toolbar with many common functions. Check Options->Show Toolbar . (added) '//' commenting for C/C++. I had also added '' commenting for xml/html, but I have disabled it due to the fact that that such comments do not nest (which is also why I went with '//' for C/C++ instead of /* */). (added) filters to browse tab (previous wxPython versions didn't really support multiple filters per entry very well). #------------------------------ PyPE 2.0 Beta 3 ------------------------------ (fixed) if saving the results of find-in-files requires unicode, it will automatically encode the output file into utf-8, which only matters on systems with unicode filenames and/or file contents. (removed) saving the results of find-in-files. (fixed) behavior of ctrl+f when text is selected to insert escaped text (when the selected text is not unicode and escapes are necessary). (fixed) find-as-you-type in the findbar, it was broken after I added shift+enter for 'find previous'. (fixed) Document->Indent Width works again. (changed) todo list now uses table object from find in files. (fixed) sorting and clicking on todo items. (fixed) off-by-1 numbering error on line numbers for find in files items. (changed) multiline search in find in files now produces line numbers and multiple results. (fixed) workspace saving that would destroy other workspaces. (fixed) bug where reducing the size of the bottom toolbar would crash the editor. (added) find in files features with help from Dave Schuyler: (added) various scopes in which to search: selected text, current file, current file with includes (works for Python and C files), open files, directories, and tags in directories. (added) options when searching: whole word, quoted, and commented. (added) filename and extension exclusion. (added) viewing results as a table or tree, in addition to plain text. (changed) name of "find in files" to "search", in order to be more representative of what the tab is currently capable of. -- beginning of find in files features written or helped by Dave Schuyler (added) findbar features with help from Dave Schuyler: (updated) the behavior of smartcasing to be 'more smart', updated the readme. (changed) find/replace bars now remember their status per-document. (changed) find/replace bars now have a history of search/replace terms. -- end of findbar features written or helped by Dave Schuyler (fixed) saving of files with unicode characters (was caused by writing unicode strings to standard out without converting them to an ascii representation first). Now uses a string.encode('utf8') before writing to standard out. (added) wx.Yield() calls to the bit that handles the discovery of Python imports in the find in files tab for PyPE responsiveness during large file scans. (fixed) printing of status messages to the log tab now occur even if the log does not yet exist (users get to see some startup messages now). (fixed) keyboard navigation of the find/replace bars to be cyclic. (added) ability to clear the find/replace history of the find/replace bars. (fixed) parsing of C files in search tab. (fixed) search "current file and includes" for Python files to not try files multiple times. (added) window title now includes filenames (thanks Dave Schuyler). (fixed) behavior of caret options, will now update all editor controls when settings are changed. (added) ability to disable find/replace bar history. (added) ability to change what the title bar displays. (moved) all editor-global options to a new 'Options' menu, any previous hotkeys for these options are lost. Original locations of affected options: Edit->Enable File Drops, View->Editor on Top, View->Editor on Left, View->Caret Options, View->Set Caret M Value, View->Set Caret N Value, Document->Save Settings, Help->Change Menus, Edit->Use Findbar History, Edit->Clear Findbar History, View->Title Options. (fixed) bug with find and replace bars and unicode. (changed) find/replace bars now use the compiler module to discover the actual strings when Python-style string constants are used, removing PyPE's reliance on 'eval'. (fixed) the construction of binary distribution to force compression on the library.zip file, drastically reducing the size from nearly 7 megs to just over 4 megs. Not quite as good as PyPE 1.9.3's 3 megs, but wxPython has grown somewhat, as has PyPE's reliance on additional wxPython widgets. (note) I will begin posting md5 and sha1 checksums in the sourceforge notes as requested by a user. (changed) the names and descriptions of some items in the Options menu. (added) per-filetype document preferences (everything in the Document menu except for "line ending" and "syntax highlighting"), savable and loadable via Options->Save Settings and Options->Load Settings respectively. If a document without any previous preferences is loaded, it gets these settings loaded by default. Individual documents will remember any settings that are set for them, and can be reset via Options->Load Settings. (fixed) the display of help text in the status bar for some menu options. #------------------------------ PyPE 2.0 Beta 2 ------------------------------ (fixed) Todo no longer includes http, ftp, mailto, news, gopher, and telnet. (fixed) Bug when opening non-existent files. (fixed) When one indents/dedents selected text, the selection will change to select the entirety of all lines covered (similar to the way comment/uncomment does). (removed) Find/Replace dialog. (added) Replace bar with 'replace' and 'replace all' functionality. (added) "Escape" key now closes find bar or replace bar, if any of their text entry locations have focus. (added) Option to disable drag and drop file support on the editor window, though it is still enabled other places. (added) Help information about Edit->Enable File Drops (added) Ability to replace a workspace during save of workspace. (added) Find in files tab to the notebook on the bottom bar. (removed) Find in files dialog. (added) Ability to save the results of a 'find in files' search to a text file. (added) Option to move bottom bar to the top, and/or right bar to the left. (added) Smart Case replacements. When the replacement string is as long as the replaced string, and smart case is enabled, it will automatically adjust the case of all replacement strings. See the readme for more information. (added) Replace in selection. When used with "replace all", will perform a "replace all" only on everything in the selection when the button was clicked. (fixed) removed reporting of exception when PyPE attempts to change to a path that doesn't exist anymore. (removed) some unused blocks of code. (removed) some unused ids. (moved) "next/previous tab" entries to "View" menu (for hotkey support). (fixed) Issue when PyPE is running during daylight savings time changes (known bug for over a year) where user would be notified that all documents currently open have had the on-disk versions changed. Only documents that are actually different from their on-disk versions will cause a notification. (fixed) Issue when someone saves a file with identical content over a file that is currently open but unchanged. (fixed) When loading/saving files on any platform where the filesystem is case-insensitive, but case-preserving, PyPE will respect the capitalization of files (users may need to clear out their .pype profiles to get full use of this). (fixed) When saving a document, the icon for the document above the editor will be the same as in the documents tab. (fixed) When saving the last document, which happens to be unnamed, will no longer change the current document selection. (added) Caret 'sloppiness', which restricts the cursor position as you are typing or moving the caret. Check out View->Caret Options (of which there are 5). (changed) The layout of the find/replace bars. (added) repeated ctrl+f commands will perform repeated find next operations. (changed) F3 will now only find next if there already existed a find/replace bar, no longer creating one if it did not exist. (changed) ctrl+f/r will insert selected text into the 'to find' text. (changed) if there is already text in the 'to find' text in the find/replace bar, and no text is selected in the editor, then the 'to find' text will not be replaced. (changed) if there is no text in the 'to find' text in the find/replace bar, and the cursor is on a word, it will be inserted into the 'to find' text box. (added) if the 'to find' box has focus, shift+enter will find previous. (fixed) encodings changing code for unicode builds. (fixed) detection of unicode for newer versions of wxPython. (added) ability to disable wrapping during find. (fixed) nameerror during the opening of a document when a previous version of PyPE had never been run. #------------------------------ PyPE 2.0 Beta 1 ------------------------------ (changed) Pulled source tree from being per-document to being shared among all documents, tree is rebuilt on document switch. (changed) Each document gets its own tree, but it shares the same visible area, using .Show() and .Hide() tricks so that only one is visible at one time (the one for the current document). Tree is not rebuilt on document swap. (fixed) On document refresh, tree is destroyed and rebuilt, fix for the non-removal of some removed functions/classes from the tree after they had been deleted from the document. (fixed) a bug involving non-reloaded but modified files not asking for save on document close or PyPE exit. (removed) pathmarks menu. (removed) shell commands menu. (added) browsable filesystem tab. (added) pathmarks to browsable filesystem tab. (added) document list tab, drag and drop reordering of documents. (removed) tabs menu (use the document list) (added) icons for documents wherever possible. (added) logging mechanism (for bug reports and whatnot). (added) most status bar updates go to the log. (added) second browsable source tree, one sorted by line, the other sorted by name. (added) find-bar per document (try ctrl-f). (fixed) redraw of document editor after transition between dirty/nondirty and opening new files. (moved) much of the non-main window code to a plugins directory. Functionality should be unchanged, but easier to edit. (changed) started transition to wx namespace. (added) 'todos' can now have any category. (removed) code snippets, may appear in a later PyPE release if people want snippets. (fixed) wrap selected text, now uses textwrap for paragraph wrapping. (added) workspace management, can now save and load a document listing, try it! (fixed) parser now (poorly) understands __init__ and __new__, tooltips will now show __init__ and/or __new__ methods when available for a class. (fixed) main window and all sub windows now remember size and position. (fixed) line and column indicators when the keyboard is not used to move the cursor. (updated) documentation, AKA readme.txt. #-------------------------------- PyPE 1.9.3 --------------------------------- (changed) find now searches from the current cursor position, rather than the beginning (search down) or end (search up). (removed) event binding for EVT_STC_POSCHANGED, which has been removed in 2.5.1.5. (fixed) a bug that resulted from opening an empty file. (fixed) a bug that resulted from opening a file without line endings. #-------------------------------- PyPE 1.9.2 --------------------------------- (improved) the find and find/replace dialogs will now remember the case, whole word setting, and direction (if applicable) for the last time the find/replace button was pressed. (fixed) various refresh bugs have been fixed. (fixed) syntax highlighting bug in PyPE 1.9.1 #-------------------------------- PyPE 1.9.1 --------------------------------- (improved) the speed of PyPE closing down with many documents open. (fixed) old hotkeys and menu items that are no longer being used are now removed upon restarting PyPE. (fixed) The #!/ shortcut at the beginning of pype.py now points to: '#!/usr/bin/env python', which should find Python on most every *nix system. (fixed) a bug reported by Denis Dube when using the binary in which running 'pype.exe ' would result in syntax highlighting not being available. #--------------------------------- PyPE 1.9 ---------------------------------- (fixed) a bug that resulted in PyPE closing down without warning if the Find or Find/Replace dialog was attempted to be open while another was already opened. (added) a dialog and support code for changing menu item names and hot-key bindings. This has been in the works for a while, and hopefully will get some use. Even though the description of this change is only a few lines long, the implementation is over 250 lines. The current implementation is limited to adding hotkeys to items that are in the main menus and do not contain submenus. Any hotkey combination desired will likely work (Shift+Tab seems to have a problem due to the automatic button/entry navigation in dialogs, and likely other platform-specific key combinations will not work). (cleaned) out most (if not all) old hotkey-support in OnKeyPressed, now all menu hotkeys are a dictionary lookup. (fixed) maximizing and restoring will now result in more stable browsable source tree widths. (changed) parsing has been moved back into the core process and is multiplexed with wxYield() calls. External parsing is not required with the fast parser and wxYield. If you want to know why it was moved to an external process previously, check the changelog.txt included with PyPE. By not doing any external IO, polling files, spawning processes, etc., parsing the file and updating all the requisite information is roughly twice as fast as it was in 1.8.2. (tossed) all the unused external process parser stuff. No need for it now. (information and change) there are now two things that can occur that take up a measurable amount of time in-process: parsing and finding in files. Both call wxYield() in order to offer the the GUI some time to update if needed. Great pains have been taken so that 'find in files' will not occur during a wxYield call of the parser, nor will two 'find in files' occur simultaneously. (fixed) the listbox control in 'find in files' seemed to have issues with tabs displaying correctly. On display they are automatically replaced with the PyPE's default number of spaces per tab. (fixed) the forgotten re import that allows for regular expression searches in 'find in file' (fixed) 'replace all' will now be considered a single modification for the purpose of undo/redo. (now included) is a modified version of wxProject.py that supports the file list as a dragNdrop file source. For those who want a /really/ ghetto project manager, this version of wxProject.py is for you. Does not work properly when run with a unicode-enabled wxPython. I have no idea why. (received) patches to PyPE from Relja Stanisavljevic (no SFID given), which resulted in the following (after fixes were applied): 1. 'Find Again' menu item and functionality. 2. Untitled documents now have unique numbers, tabs are now named 3. Comment and uncomment code does the right thing for indented blocks. A big thank you goes out to Relja Stanisavljevic. #-------------------------------- PyPE 1.8.2 --------------------------------- (added) an option to allow PyPE to save cursor position information in a document. Even though I don't use such a thing (and loathe it), others may like such a feature. (fixed) a bug with the backlog of saved states that would crash PyPE on load when enough documents had been opened. #-------------------------------- PyPE 1.8.1 --------------------------------- (fixed) a bug with 'Open Last', in that it wouldn't actually open the documents that were open when PyPE was last closed. (fixed) a bug described here: 1. Open some documents 2. Close PyPE (saving if required) 3. Open PyPE (don't load any documents) 4. Close PyPE 5. Open PyPE. A user would notice that no documents closed in step 2 will have their states saved. As they are recently open documents, they (in version 1.8.1 and on) become part of the 64 most recent that get their states saved in addition to those documents closed when PyPE closes. (fixed) Updated some methods in the most recent queue to follow the dictionary standard of mapping(zip(map_instance.keys(), map_instance.values())) producing an equivalency to the original map_instance. (fixed) When calltips are shown, the class/method hierarchy for the function prototypes are now in the proper case (they were previously all in lowercase). #--------------------------------- PyPE 1.8 ---------------------------------- (information) the bug that was fixed in PyPE 1.7.3 removed every file in the path '/.pype', including the history.txt that kept user profile information. During the update, sourceforge went down for maintenance, and I was expected at a friend's party. It was eventually uploaded. (added) Every per-document setting that can be set, will be perserved if PyPE was closed with the document open. (added) The 64 most recently closed documents will have their state information saved, just like if PyPE was closed with them open. These 64 documents are in addition to those with states saved when PyPE closes. (removed) the ability to hide the fold margin (which had a bug in it since its introduction anyways). Hiding the fold margin when code is folded can lead to data corruption. If one hits 'return' on a folded line, all hidden lines that are hidden through the result of the fold are deleted. If the margin were hidden, then it would be impossible to either fold or unfold, so I just got rid of the ability to hide the margin. (fixed) shell commands can now have arguments. This has likely been a long standing bug. (changed) made the default syntax highlighting for a new document to be set by the user, defaulting to python. (fixed) PyPE has a new icon and is set up to use the new icon in the titlebar and taskbar (on platforms where this makes sense). (added) Find in files dialog as requested by user francescoa at sourceforge. (added) Save information about the last 10 unique values in each entry in the find in files dialog. (fixed) bug https://sourceforge.net/tracker/index.php?func=detail&aid=856727&group_id=85104&atid=574958 #-------------------------------- PyPE 1.7.3 --------------------------------- (fixed) a stupid bug that was caused by fixing a stupid bug. #-------------------------------- PyPE 1.7.2 --------------------------------- (fixed) I forgot to remove a debug line that keeps copies of every document that gets parsed in a user's profile. (fixed) a bug when dedenting a single line with the cursor near the beginning of the line. (fixed) a bug that wasn't causing any harm, but was slowing down the loading of PyPE. #-------------------------------- PyPE 1.7.1 --------------------------------- (fixed) a bug with the 'fold all' menu command that stopped all of the document from being folded. #--------------------------------- PyPE 1.7 ---------------------------------- (added) When reloading from disk, a document's browsable source tree, etc., will be updated. (fixed) various problems with the window not being redrawn. (fixed) some indent/dedent problems. (added) SPE-style per-document todo list. (updated) the readme.txt that is included with PyPE. (changed) the default styling for unknown extensions is now plain text. (changed) the exceptDialog to show a scrolled text dialog, for easy copy/paste bug reports. (fixed) Thanks once again to Villy Dachev, any time the PyPE executable (or the source version was run with the python binary) was run from a path that contained spaces, it used to have some SERIOUS issues. They have all been resolved. (fixed) a problem when one's user profile was not stored in a path containing spaces, resulting in a file not being parsed. (cleaned) up some parser spawning code. (added) notification to warn users when they attempt to run a script who'se path contains unicode characters. (fixed) a difficult to track down bug involving running the source version. It was the result of taking the location of the PyPE source as sys.argv[0], which only gives the relative path given the original path when running PyPE. Too many hours were spent tracking this bug down. This was likely a long standing bug. #------------------------------ PyPE 1.7-test3 ------------------------------- (fixed) 2 problems pointed out by Villy Dachev, and added one feature: (fixed) a problem with external document modification and refreshing. (fixed) a problem with running external scripts in the windows binary. Users should check this one some more. (added) a 'fold all' function to the 'Document' menu. #------------------------------ PyPE 1.7-test2 ------------------------------- (fixed) after using 'save as' or attempting to save a document that was previously unnamed, PyPE would leave capital letters in the document name within the document tab, even when the operating system is case agnostic. This is now fixed. On systems where case does not matter, the file names will be consistent in the document tabs. No change for systems that care about case in file names. This has been a long-standing visual bug that was never noticed. (fixed) a bug with indentation. Previously it would always indent using the default indent during indent/dedent operations (including when hitting return after a function def, while, etc). This has been fixed so that indent/dedent uses the document specified indent. (changed) Rather than ALWAYS indenting/dedenting the indent width, the first indent/dedent operation will indent/dedent to the closest proper indentation position. That is, if your indent width is k, after indent/dedent operations, the indentation of a line will be 0 mod k. (fixed) the text entry dialogs for various numbers in the document tab would not validate the result, making sure they were > 0, even when such a number was asked. They now check. If the returned value is <= 0, it will keep the previous value. (added) when closing down PyPE with open documents, PyPE will remember which lines were folded and which weren't. (added) a function to unfold all lines in a document to the 'Document' menu. (changed) a slight 'Document' menu reorganization. (tossed) some unused dialog box code. #------------------------------- PyPE 1.7-test ------------------------------- (changed) when source files are larger than 512k, the slow parser will never be called. Why? Because the slow parser runs around 25 seconds (on my machine) on such a large piece of Python source, and it stops being useful if you have to wait so long. (made faster) Thanks to the input of Jeff Grimmett (no sourceforge id given), the fast parser is even faster. He offered a two-pass method that beat my previous single-pass method by a significant margin. After more than a dozen emails back and forth, along with heavy optimization, which one is faster is still up for debate (there are some inputs where one is ~5% faster, then on others the other is ~5% faster). All told, the new fast parser is around 30% faster than the original fast parser, and includes support for pulling out calltips, and better function/class listings in the browsable source tree. Most all the modifications to the parsing for this release is due to the dialog between Jeff and I. (fixed) Sometimes parsing would fail due to ambiguous line endings. This has been fixed. All line endings upon load, save, and parsing, are automatically converted to the most dominant line ending format. (fixed) fast parsing would ignore tabs, thinking they were not whitespace. Now it is converted before parsing to spaces, as given by spaces_per_tab in configuration.py (fixed) While I am uncertain whether Python supports unicode in function, class, or variable declarations, fast parsing will not behave any differently when using unicode or not. (changed) both parsers now generate a better browsable tree. The tree now contains more information about function calls. It also sorts based on the names of a function/class, without the leading 'class' or 'def', and ignores case. (moved) all the user-changeable configuration in configuration.py to the top of the file for easy access. (fixed) when hitting enter on a line with a return or pass statement, the next line will be dedented properly. (changed) the way calltips are cancelled. They are cancelled less often, which is definitely better. (changed) due to the fact that the fast parser produces basically everything about the python source (except for docstrings and multi-line calltip definitions), PyPE will now use, by default, the fast parser to deal with parsing. This is preferred, if only because now tree updates can happen in under 2 seconds for the majority of source files (on my Celeron 400). (increased) the size of the browsable source tree when "Show/hide tree" is used (whether by the menu or hotkey). (added) a command to hide all the browsable source trees. Check the 'View' menu. (fixed) resizing the window doesn't change the size of the browsable source trees. Every open document will have their browsable source tree keep their sizes during window resize. It only updates the document that is currently visible (so no worries about 20 documents slowing down window resize). (fixed) a bug when using bookmarks. When going to a bookmark, PyPE will make sure that the line containing the bookmark is visible. (changed) basically all those configuration options that were to be edited in configuration.py have been removed. They are now available in the 'document' menu. (added) option to view/not view line numbers. (added) option to view/not view bookmark margin. (added) option to view/not view fold margin. (added) option to view/not view indentation guide. (added) option to view/not use tabs. (added) option to view/not wrap long lines. (added) option to change indent width. (added) option to change the tab character's width. (added) option to change the long line column number. (added) option to change the long line column indicator. (added) option to view/change the current line endings. (added) option to sort the browsable source tree by name or line number. (added) per-document autocomplete. Rather than autocomplete being a global setting, it is now a per-document setting. (moved) location of encoding and syntax highlighting submenus to the document menu. #------------------------------- PyPE 1.6.5.4 -------------------------------- (fixed) a bug when opening up multiple documents that are in the root of a drive in Windows. Thank you once again francescoa@sourceforge's for the bug report and pointing out where it was messing up. #------------------------------- PyPE 1.6.5.3 -------------------------------- (fixed) a bug when starting up PyPE with more than one relative paths to files as arguments. Thanks francescoa@sourceforge's for the bug report. (discovered) the reason why on some linux systems splitting the window would not display the source. Thank you Patrick Installe (did not email through sf) It turns out to not be a bug with wxPython on linux, but instead it is the result of one's theme in linux changing how many pixels for each window is required to be displayed. #------------------------------- PyPE 1.6.5.2 -------------------------------- (fixed) a bug when creating a newline with tabs disabled and the cursor was in or immediately to the right of indentation. (fixed) on linux, opening a document would not display the source, this is seemingly a bug in wxSplitterWindow on linux. The split argument I give is negative, so it should result in a size for the right panel. It instead makes the left window non-existent. The negative argument has been replaced with a positive argument based on the current notebook size. No guarantees on whether either window will be created when the notebook is smaller than 25 pixels wide. (should have been fixed) seemingly, some of you are having problems opening files in the root of a drive as well as opening relative paths (in windows). This has been working for me since PyPE 1.6.2, but I've added in one more thing. If you STILL can't open relative paths or a file in the root of a drive, then the combination of: os.path.normcase(os.path.normpath(os.path.realpath(os.path.join(os.getcwd(), i)))) is not sufficient to get the real and normalized path on Windows. #------------------------------- PyPE 1.6.5.1 -------------------------------- (fixed) a small bug with the syntax highlighting submenu not updating what highlighting is being used in non-unicode versions. #-------------------------------- PyPE 1.6.5 --------------------------------- (changed) untitled documents are now labeled as such, rather than not having a name at all on the tab. (fixed) a bug where saving a new document, without any changes, would cause the tab to not be updated. (fixed) a bug where saving a new document would not add the file to the list of recently open documents. (fixed) when reloading a document from disk, PyPE used to allow one to undo to a point mid-STC.SetText where the document was empty. This has been fixed. (made better) for those platforms that support radio items in the menu (wxMSW and wxGTK according to the docs), the syntax highlighting and encodings submenus will display a mark next to the current document's syntax highlighting and encoding. (fixed) previously when opening a document in windows, an msdos console would make a momentary appearance, then disappear. This has been fixed with the use of os.spawnv(). Woo. Thanks Luc Perrin (leblin@sourceforge) for pointing out the popping of the msdos prompt, I had gotten used to it, and didn't realize it bothered people. (two more bugs pointed out by Villy Dachev (labrett@sourceforge)): (fixed) even if tabs were turned on, if one were to create a new line (through the use of enter) while the cursor was in the indentation portion of a line, spaces would be inserted, rather than tabs. Now tabs are inserted. (fixed) if tabs were turned on, the search for whether or not a new line (when hitting enter) should be indented more, would stretch to a previous line. This has been fixed, and the search is only ever on the current line. #------------------------------ PyPE 1.6.5-test ------------------------------ (NOTES REGARDING UNICODE SUPPORT) I got some advice from a user who made their PyPE support utf-8 encodings, did some modification to PyPE, and have actually implemented the required pieces to give PyPE unicode support. PyPE now supports the encodings; ascii, utf-7, utf-8, utf-16, utf-16-be, and utf-16-le, when using a version of wxPython that includes unicode support. If you don't get the 'encodings' submenu in the 'edit' menu, then your version of wxPython does not support unicode. In wxPython version 2.4.2.4u, there exists a bug in reverse searching through unicode files, so I've forced it to only search forwards. It should be fixed when the STC gets updated with the latest scintilla (probably in the next version of wxPython). There also exists multiple display bugs with multibyte unicode characters, one of them is listed here: http://sourceforge.net/tracker/index.php?func=detail&aid=828217&group_id=9863&atid=109863 I'm sorry about the visual bugs, but there is nothing I can do about it. Other than that, unicode seems to work pretty well. Bug reports from unicode users would be great. (changed) the standard behavior of home and end when word-wrap is enabled. I didn't like that hitting 'home' would send you to the beginning of the entire line, rather than the displayed line, so a little spelunking into the STC docs resulted in an addition to the OnWrapL code. (removed) previously there had been a STC-default keybinding of CTRL-T to swap the current line and the one above it. I've accidentally hit that one a few times (I'm a user of mozilla tabs), so I made the default to remove it. Again in configuration.py, just set REM_SWAP to 0 to enable it. (added) when quitting PyPE with documents open, intra-document bookmarks are also saved (check the 'view' menu for bookmark stuff) and are re-set if those documents are loaded during the next execution of PyPE (with '--last' command line option, using file->Open Last, or even opening any file that was open during program exit using any method). (added) due to some tips from Villy Dachev (labrett@sourceforge), pointing out some unicode stuff...it turns out that unicode was very easy to add. I just needed to check for the BOM characters at the beginning of a unicode encoded file and decode the file, then re-encode it when saving to a file. There is graceful unicode conversion for standard ascii files when unicode text is inserted into them. That is, they are automatically saved as utf-8. (added) encodings sumbenu to 'edit' menu. This menu will allow you to change the encoding of the current file to another. Changing from utf-16 to utf-8 (for languages that support it) will reduce the storage requirements by about 1/2. (added) a statusbar field to display the text encoding of the current file. (removed) information about lexers in pype.py (moved) 'style' menu into a 'syntax highlighting' submenu of 'view'. (found) nifty bug. Hitting ctrl+ will let you view the tab to the right of the current tab. Hitting Ctrl+del on a US keymap, or Ctrl+ when numlock is off will also switch tabs. It is nifty. (fixed) when tabs are enabled, creating a newline should insert tabs. (added) a variable called spaces_per_tab in configuration.py, which, when tabs are enabled, replace that many spaces with a tab when creating a new line, during indentation, etc., and will display tabs as that many spaces wide. #-------------------------------- PyPE 1.6.4 --------------------------------- (NOTES REGARDING UNICODE SUPPORT) I have little (or really no) experience when it comes to unicode support in Python. I had mistakenly assumed that creating a binary using the unicode-supporting wxPython would have been sufficient to support unicode out of the box. Unfortunately, this is not the case. There is encoding and decoding that must be done on either end, and one must know which encoding to use in order to properly support unicode. As that adds additional complication to PyPE, and to the handling of ALL files, regardless of what extended text is supported, I'll not be producing a binary with partial unicode support. Those that have tried saving unicode files in 1.6.3 will notice the problem during saving, and the fact that it doesn't work. While I am not ruling out the possibility of PyPE fully supporting unicode in the future, I don't believe I will be implementing it. My apologies. (NOTES REGARDING DOCUMENTATION) I know that the documentation is out of date. I will update it when I get around to it. I prefer to make PyPE better than to spend my time updating the documentation. (NOTES REGARDING VERSION REQUIREMENTS) I have changed the wxPython version required. This is because the wxSTC has a known bug in version 2.4.1.2 that causes PyPE to exit without warning, possibly causing data loss. This is bad. The wxSTC that is included with wxPython version 2.4.2.4 doesn't have this fatal bug. #The below bugs/suggestions were reported by francescoa in the PyPE forums at #Sourceforge or in email. I have added the features or fixed the bugs. (fixed) a bug involving pasting to code snippets. (fixed) a bug involving changing code snippet focus and tab focus (they would do so simultaneously when changing code snippet focus). (fixed) running the currently open script in windows when the path to the file contains spaces. (removed) an import that was not used. (added) when using the find/replace dialog, the word that is currently under the cursor will be inserted into the find/replace dialog find text. (fixed) the find dialog will now find up or down, depending on the radio item in the dialog. Previously it would ignore the 'up' or 'down' choice. (added) bookmarks within a file, for quickly and easily bookmarking certain locations for later perusal. #end of bugs/suggestions reported by francescoa (replaced) Added file over-write confirmation dialog. (removed) checkbox for 'readonly' files. There seems to be no way to get the status of that 'open file in read-only mode'. Which is completely retarded. (cleaned) replaced the indent/dedent code with a call to the STC command for indent/dedent. (replaced) the aforementioned calls to the STC indent/dedent with my previous code. I prefer the behavior of my code to that of the STC indent/dedent code. (made better) the dirty flag on the each open document is now consistent with the last time the user saved thanks to EVT_KEY_UP, STC.SetSavePoint(), and STC.GetModify(). It is now more accurate and does not rely on the numerous hacks I did before to make it work. (fixed) a bug that occurred on windows machines when PyPE would try to delete the temporary parsing output when it was still opened by the parser. (added) a statusbar field that displays the current line and column. It is only updated when a key is released (EVT_STC_POSCHANGED doesn't seem to work). To update the display if it is not being updated, tap the CTRL key. (added) events in the statusbar now have a timestamp when they occur. (moved) code for wrapping lines into configuration.py (added) ability to open all the documents previously open in your last PyPE session if you quit PyPE with those documents saved and have their tabs open. You can force this behavior on PyPE startup with the FIRST argument on the command line being '--last'. (changed) removed the various 'shortcuts' for generating the menus that ended up taking more lines and being more difficult to edit. While not reducing the number of lines (significantly), it does increase readability of the menu code. (changed) realized that the ID definitions are only required when you need to compare event id numbers. When you don't care, and just want an event to be posted, then event declarations are functionally useless. Cleaned up a lot of global definitions. Will likely have to re-insert such definitions for the likely future feature addition of user-definable key-bindings. (fixed, changed, added) more than a handful of other things that I didn't remember writing down in this changelog. #-------------------------------- PyPE 1.6.3 --------------------------------- (fixed) a visual bug that existed from the beginning. When saving, it used to say 'open' on the button...now it says 'save'. No big deal. But still neat. (fixed) a problem with paths on windows systems with recursive environment variables (like HOME=%USERPROFILE%). (known bug) there exists a bug in automatic word wrapping. This is within wxSTC, not PyPE. For an example of this bug in action, I've provided some code in the wxWindows bug page here: http://sourceforge.net/tracker/index.php?func=detail&aid=816227&group_id=9863&atid=109863 (slight refactor) I didn't like the repeated 'parent' references for different items when it wasn't so much a 'parent' as much as it was referring to the actual topmost frame of the application (especially when such references called functions that only existed in the topmost frame). I've changed such references from 'parent' to 'root', where it makes sense, as well as creating some other names in other classes where appropriate. (fixed) a bug involving creating a dialog describing an exception when an exception occurred. (fixed) a few tiny bugs in find/replace (one would only notice the non-fatal bugs if one switched tabs during a find/replace dialog). (fixed) aforementioned bug from the 1.6 changelog with recently open files. I completely forgot about it until I was reading the older changelogs today to remember how far PyPE has come. #-------------------------------- PyPE 1.6.2 --------------------------------- (fixed) apparently the textwrap module in Python 2.3 doesn't work the way I wanted it to. As a result, text wrapping with Python 2.3 and the Windows binary didn't work in PyPE 1.6.1. I've removed the code responsible, and it should work identically between Python 2.2 and Python 2.3. #-------------------------------- PyPE 1.6.1 --------------------------------- (fixed) small overflow error when creating unique temporary file for parsing. Unnoticed due to testing with python 2.3 which automatically casts overflowed ints to longs. (added) modifying word wrapping support. Python 2.3 and Windows binary users of PyPE will use the textwrap module that is included with Python 2.3, everyone else gets the featureless 'wrap on newline or spaces' line wrapper. The included gpl.txt has now been wrapped using this feature. Check the edit menu. (added) non-modifying word wrapping support. Went looking through the STC documentation and found support for it. Check the edit menu. (added) some small pieces that will allow future state information to be displayed in a field within the statusbar. #--------------------------------- PyPE 1.6 ---------------------------------- (please note) I am going on vacation from September 3 to September 14. Any bug reports will be silently ignored until at least the 15th. If you have problems using 1.6, try using 1.5.1 until I get back to you. (made better) user profile path discovery. Thanks Erik Lechak. (fixed) if the user profile cannot be saved, you will get a dialog informing you of this. Previously, this was not the case, it would be silently ignored. (fixed) there was a bug in the recently open documents menu that would cause certain documents to be placed in the menu, and others not to be. From now on, any document opened will be placed in the menu. The document will have the file name and path normalized, as per os.path.normcase and os.path.normpath. This will result in duplicate file entries until the menu gets cleared out of old entries for Windows users, as the menu thinks there is a difference between c:\doc.txt and C:\Doc.TXT on Windows. You can speed this up by dragging and dropping 9 random text files onto PyPE. (fixed) a foolish bug that stopped me from using map anywhere in PyPE, I had assigned map to be a mapping for the find/replace dialog stuff. (changed) Code snippets are now optionally turned off in the view menu. In turning off code snippets, then closing down and starting back up PyPE, you will no longer have a code snippet bar on the left side, nor will the hot keys work. For those people who use code snippets, I'll do my best to not remove the functionality, and keep it an option, but may arbitrarily remove it in the 2.x series, if development proceeds that far. (added) goto line as a menu command and hotkey. I've been wanting it for a while, and it was requested by another user. So I added it. (added) the option to add a search path for modules. This is a setting that will be saved, and is of primary use for those using the windows binary on a system with Python installed. To tell the truth, I've been using the binary for a while; it starts up faster. This addition makes the binary as powerful as the source version. To remove paths from the module search, one must delve into the history.txt file. I really should write an abstracted class to handle pathmarks, shell commands and module paths...maybe in a later version. (fixed) inserted a minor change that fixed the autoindent for lines that contain slices. (changed) hitting F5 will now cause the slow parser to do its magic, and if it fails (due to a syntax error), the fast parser will kick in. If you always want the fast parser to work, just leave a syntax error in your source until just before you run it. When opening multiple files, they will be parsed in series with the slow parser. (cleaned up) some imports, variable declarations, etc. (tried to change but failed) I had attempted to make all parsing occur in the background with an additional thread so that the GUI wouldn't seize up. Unfortunately, there seems to be a bug with either Python garbage collection, wxStyledTextCtrl, or STCStyleEditor.py. How do I know? Because doing any operation that causes garbage to be generated (for the garbage collector to collect) while updating the wxStyledTextCtrl component with the STCStyleEditor module causes a garbage collection error in both Python 2.2 and Python 2.3. Certainly I can spend a few weeks testing and inserting locks around portions that could cause problems, but I will not. On the upside, I'm really good at creating new events, event handlers, and other such things, so if there ever is a need for background processing (IE the garbage collection error gets fixed), It'll be a 5-minute job. (finally succeeded) the trick to getting background parsing lay within the use of os.popen4. Keeping the parsing out of process fixed the problem I was having, and I could even use some threads to wait for the child.stdout.read() to complete. Works fabulously. It takes about 110% as long to do it as an external process (through the use of a=repr(obj), eval(a) and pipes), but that is OK as it no longer delays the GUI. Ah HAH! Spelunkers into the code will notice that I'm actually calling the editor itself...with an argument of '--parse', and I've also done away with runscript.py, by calling the editor itself using '--exec' as an argument. (changed parsing) the current parsing method does not use pipes or threads, and also limits itself to parsing one file at any one time (I've dropped 20 files onto PyPE with the threading approach, and PyPE would not respond for a while). Now PyPE is always responsive (as long as your processor has available cycles). (fixed) it seems as though runscript.py was never included in the windows-only version of PyPE. No worries, it is now a part of the editor, so should just work. (fixed) there seemed to be a long-standing bug in calling PyPE with relative command line arguments for files to open. This has been fixed. There is a minor bug relating to the recently open files menu, but that'll be fixed when I get back from vacation. (fixed) my constant misspellings of hierarchy, I had been incorrectly spelling it as hierarchy. Misspelling pointed out by my wife. #-------------------------------- PyPE 1.5.1 --------------------------------- (fixed) a little bug with autoindent after [else, try, except, finally] statements. I forgot to add them into the autoindent stuff. (fixed) another little bug with autoindent. It wouldn't autoindent after a [if, else, etc.] if the cursor was after the last character in the document. (fixed) another little problem with autoindent. Had to do with certain kinds of nested declarations. Damn, autoindent is almost more trouble than it is worth. #--------------------------------- PyPE 1.5 ---------------------------------- (fixed) a little problem when finding line endings in some ambiguous files. Ambiguous files being files lacking any sort of line endings. (fixed) autocompletion popping up during typing in strings and comments. Now it doesn't. It would before. A single line change. (removed) keywords from the autocomplete stuff. Why? Because having to hit return twice for the keywords [raise, return, pass] was annoying as hell. (removed) duplicate "import keyword" statement in parsers.slow_parser (fixed) autoindentation after a definition works better. Not quite as good as idle yet, but getting there. (fixed) remember when you would hit 'F5' with the browsable source tree expanded and it would remove all your expansions? This was due to clearing and reconstructing the tree. Due to a user asking, "could you stop this", I've altered PyPE to remove this bulk clear and reconstruction. It now updates the data as necessary, only removing or adding nodes as needed. It is nifty. (fixed) with the introduction of the 'remember the last path that was open' when starting up PyPE again functionality, it introduced a bug. If one attempted to use a pathmark or use the recently opened documents menu, it wouldn't clear the last open path. This has now been remedied. Any time you open a document using the recent menu, or use a pathmark, it will now change it properly (instead of forcing you to hit 'cancel' in the open dialog, then try to open again). In other words, it works like you expect it to now. (stymied) Autoindent like idle does is going to be hard. This is because idle actually does a large amount of parsing. I have a feeling this is why it is sometimes sluggish. I could be wrong. (good enough) I think the current autoindent code works just fine for most things. It certainly isn't as complete as idle, but I think it would be out of line for the entire document to be parsed at every newline insertion. Unless the need bites me, I'm not going to insert dedent code for [raise, return, pass] (fixed) Dedenting on a single line will now keep your cursor in the original relative position to the remaining of the line. It will also remove partial indentations before removing a full indentation. #-------------------------------- PyPE 1.4.2 --------------------------------- (fixed) some stupid bugs with loading and saving of history/pathmarks/shell commands into history.txt. Sorry about that. The 1.4 series of PyPE has proven itself to be the buggiest series ever. *grumble* #-------------------------------- PyPE 1.4.1 --------------------------------- (fixed) a problem with pathmarks introduced by the 'remember the last path you were in when PyPE last closed' addition. Yes, this fix gets it's own version. #--------------------------------- PyPE 1.4 ---------------------------------- (added) in commenting/uncommenting feature thanks to Mark Tipton's adaptation of some codeEditor code. (added) in a few things to give the parsers a couple more options. The slow parser is still slow. It may be replaced by one that uses the compiler module. (change) there is a new 'slow' parser in included with PyPE parsers module. Instead of using the standard parser python module, it uses the compiler module. This is better for a few reasons; it is faster, all the information that is needed for the browsable source tree, autocompletion, and even docstrings (for pulling out tooltips) are available. Speaking of which... (submissions by Mark Tipton) cmt-001 - 08/06/2003: Added code to configuration.py to create a configuration directory to store user-related configuration information. Added code to pype.py to store an opened file history that is displayed at the bottom of the file menu and that saves the directory of the last file opened and starts there the next time you start pype. cmt-002 - 08/06/2003: I couldn't get the 'runScript' function to work on Linux. It seemed to be related to files and directories with spaces in the name. The function was drastically modified (actually completely replaced) using code from PythonCard's codeEditor and seems to work on both Linux and Windows XP. (changed) now pathmarks, shell commands (as well as the new history.txt) are stored in /.pype, where HOME is an environment variable set to be the path of your home directory, or the directory in which PyPE is currently running if the HOME environment variable is not set. (cleanup) After discovering that wxMenu will handle the majority of one's accelerator hotkey needs, I've cleaned up a bit of the code, removing some of what was remaining in MainWindow.OnKeyPressed. Here's hoping that I don't forget to test some hotkey by the time 1.4 is released. (fixed) a few minor misspellings in some comments. (added) some help stuff. (added) a native win32 build of PyPE due to request, thanks to py2exe. I'll try to remember to build a win32 native version every time. If someone out there in linuxland wants to build a linux native version using Gordon McMillan's Installer (available at http://www.mcmillan-inc.com/install1.html), I would happily post it. #-------------------------------- PyPE 1.3.1 --------------------------------- (added) a version checker to PyPE. If you are running a version of wxPython before 2.4.1.2, and PyPE worked before I added this, please email me with the version string of wxPython you were using, which can be found by running this (without the single quotes) python -c "import wx;print wx.VERSION_STRING" To email me, head to http://www.ics.uci.edu/~jcarlson/contact.html #--------------------------------- PyPE 1.3 ---------------------------------- (confirmed) As believed, PyPE 1.2 and later work with Python 2.3. No worries about upgrading, but no requirements either. I'll be developing with 2.2, but will test all releases from now on with 2.3 as well. I don't foresee any issues involved with the transition to Python 2.3 in the future. In the next 6 months, if I happen to use features added in Python 2.3 (like enumerate), I will make sure to include a work-alike for those of us who migrate a few months after a Python release. (changed) now when you open a .txt file the text styling will be used. (changed) the text style now uses a monospaced font (because non-monospaced text in an editor like PyPE is just plain ugly). (fixed) a little bug in MainWindow.OnDrop, where a failed file open should open up a dialog explaining why the open failed, but would instead cause another exception. Ick. (added) a very rudimentary hierarchical python parser. It only pays attention to leading spaces in function and class definitions. That is why I call it rudimentary. All bug reports regarding the hierarchical python parser will be ignored. Patches for making the parser better will be merged, likely used, and properly attributed. (added) "autocompletion" dropdown for keyword/function/method completion. Accessible via CTRL-. (added) a browsable source tree per open document. Check the view menu. It uses an iterative method rather than a recursive method which could go beyond the interpreter's recursion limit for very deep source files. (left in) the stub for adding tooltips. I dig tooltips, but I don't really want to add the code for sucking tooltips out of the first line of a method or module's docstring. Maybe 1.4, maybe. (fixed) a bug with dropping files to open onto an already open document. (fixed) a bug where cut/paste/undo/redo by keyboard wouldn't mark the document as being 'dirty' with the little asterisk next to the file name. Now whenever one uses cut/paste/undo/redo causes the document to become dirty, even when nothing actually changes. I think this is better. (discovered) window.SetFocus(), a nice little thing that gives keyboard focus to objects derived from wxWindow (most everything is), thanks to oZt that popped into the #python channel who was looking for such a thing, that made me curious as well. Now things like double-clicking on code-snippets and on the browsable source tree will now give source editor focus. Sweet. (fixed) some bugs with portions of the window not redrawing. (added) two parsers for the browsable source tree. A fast one, and an accurate one. The fast one can parse PyPE 1.3 in .08 seconds. The accurate one can parse PyPE 1.3 in 4 seconds. These times are on my PII-400. By default, the fast one will be in use, this is for two reasons; the first being speed (no one wants a slow source browser refresh), the second being that the slow parser (which uses the parser module) dies during the creation of the syntax tree if there are any syntax errors in your source, making it somewhat useless during development. If anyone can offer anything better than either for what they are doing, I would be very happy to give you credit for your work. Any bug reports on the fast parser being inaccurate will be ignored. Any bug reports on the slow parser being slow or not working on non-working code will be ignored. If you'd like to test the parsers, give this a try: './parsers.py pype.py' to find out how fast either would take to parse PyPE on your system. One thing to note is that the slow parser, because it uses the parser module, has a few problems with line numbers (many lines that are in triple quoted strings are considered one line, and comment lines are discarded completely), so the slow parser uses the fast parser to get line numbers. Kinda funny really. The accurate one (in terms of hierarchy) is completely off in terms of line numbers. HAH! (fixed) a little bug regarding comment insertion. If one would hit cancel, it would have caused an exception...that was ignored. (confirmed) still works with Python 2.2 and 2.3. #--------------------------------- PyPE 1.2 ---------------------------------- (changed) pathmarks are always saved on program exit. (added) command line argument support with the use of os.path.abspath for all the relational and absolute path references for all systems. I like when what I need has already been implemented. Multiple file arguments also just work. (fixed) a bug with path normalization and whether a file was open already. (forgot) to remove some of the drag and drop stuff in the previous version... (added) drag and drop file support. Enabled by default, but can be disabled in the text-editing portion for text dnd support. Why don't I just write a control for dnd text and files? Because I REALLY don't want to, and don't know if it can even be done (I have a feeling it can be, just not with wxFileDropTarget and wxTextDropTarget). (discovered) os.linesep, a great little declaration that has replaced a few if then elif then else statements in configuration.py. I knew there had to be something like that in the os module. (added) an 'open module' functionality similar to what I remember of older IDLE, though this one searches in an identical fashion to the way an 'import' statement would in later versions of Python, that is, it includes hierarchical module importing, as well as the current path in the search for a module. (cleaned) some duplicated code out. Opening a file, a module, or dropping a file onto PyPE causes the same code to run. Isn't that nice? I think so. Code duplication leads to bugs. Bugs are bad. (fixed) save as dialog would offer multiple wildcards, made it give *.* instead so that I wouldn't have to write automatic file extension code for right now. This may actually be added by the time this minor release is released. (fixed) if you loaded a document and undo once, it will clear the document. I kept forgetting to get rid of this, but thanks to the project's first official bug report on sourceforge, I had the reason to add the line required to pype.PythonSTC.SetText - thanks anonymous bug poster. (fixed) that REALLY ugly code for changing style update information. It used to create an entirely new page, load the text, copy all the state information (except for undo), then replace the current page. It has now been replaced by the same style change that is done upon loading, and it just works. I like it when that happens. No messy copying, wxStyledTextCtrl just works. (made pretty) the menu item hotkeys used to be vertically aligned as best I could by hand...then I noticed how they do menus in the wxPython demo; tabs. Repaired all the menu items with tabs, and now they are consistent, if not pretty (insert maniacal laugh). (made better) you know how pathmarks used to always have that menu that was filled up, even when no pathmarks were being used? Not anymore. They now change as your pathmarks are changing. How's that for spiffy? Idea thanks to the wxPython demo app. (fixed) previously when one would go step by step in the find/replace dialog, it wouldn't select the next found object when a replacement had been made. This has been fixed. (fixed) small bug that caused an exception after finding and replacing all, it wouldn't kill PyPE, but it was a foolish mistake. (added) code snippet support. See the FAQ portion of the readme for how to use it. They are available as menu commands in the lower portion of the view menu. (fixed) when adding or deleting pathmarks, when the window pops up again, it used to select the first entry every time, it now selects the previously selected entry. This should stop you from losing your first pathmark if you accidentally hit 'OK' on a deletion. (added) shell command execution support. Uses os.spawnv in windows, os.spawnvp everywhere else that supports it. The windows version is not able to scan your paths to find an executable (hence why it is 'v' and not 'vp'). Whether this is a limitation of something in windows, python or otherwise, I have no idea. Just don't blame me. Dynamic menus abound. (cleaned) up some exception dialog stuff. Removed some duplicated code. (reorganized) the menus somewhat. Items have been relocated to menus that are much more intuitive. (changed) along with pathmarks; code snippets and shell commands are saved at program exit. All three are stored in pathmarks.py #--------------------------------- PyPE 1.1 ---------------------------------- (cleaned) I did some house cleaning and started using wxNewId to generate event ids rather than doing them manually. This required a few tweaks to the menu generation code, but it cleaned up nicely. It is also quite consistent now (wheee, consistency). (cleaned) I also added a few more functions to deal with previously opened files easier. (added) wxSplitterWindow control to hold some extra goodies on the left of the window. Just wait for what I have in store for you. As the controls that I have added do not support keypress events (other than the menu alt-commands), hot-keys are only useful when a document is open, or when you haven't touched the splitter bar or other controls after documents have been closed. (confirmed) The line ending corruption fix for 1.0.1 seem to be working great. (fixed) Discovered and removed a bug when inserting a comment would mess up line endings in the surrounding lines, making it look like there was an extra blank line inserted on windows systems. Replaced a '+1' with '+len(win.format)'. I like easy fixes. (tweaked) Line ending detection so that it does something a bit more intelligent. It works better on strange files now. (fixed) undoing and redoing previously wouldn't mark the document as being 'dirty', this is fixed and merged with the code for cut and paste making the document dirty through the use of a dictionary. This brings up the question as to whether or not ALL keypress events should just be a dictionary lookup rather than a sequence of if, elif, else statements. They probably should. Maybe in the next minor version. (removed) the aforementioned splitter window for now. (cleaned) up the handling of many of the hotkeys that are used via a ctrl- combinations. Basically all but two of the ctrl hotkeys are in a dictionary for O(1) lookups. I like that. (reorganized) some of the menu command locations. (added) pathmark support. Viewing pathmarks, editing pathmarks, deleting pathmarks and saving pathmarks to the configuration file. MMM, pathmarks. (added) more status bar text updates, like closing, opening, creating new, and other such things. I like updates. (fixed) undoing and redoing of changing tabs is now done by the entire block that was tabbed/untabbed, not by the individual line as before. (discovered) how to use the shift and control clicking of the scope-based collapseable blocks. Updated the help to explain how they work. (contemplated) adding drag and drop support. After spending some time mucking around it, I have decided it can wait until the next minor release. (contemplated) adding code snippet support. It's where you have a listing of named code snippets that double clicking will cause to replace the current selection (or insert at the current cursor position). I'm trying to decide how/where to place the code snippets. I've come to enjoy having a full screen for editing code, and to lose some of it to code snippets, almost seems strange. It'll probably be in the next point release with file drag and drop support. #-------------------------------- PyPE 1.0.1 --------------------------------- (fixed) Thanks to a message from Lunar Linux guru Jeff Hodges, I was turned on to Pychecker.sourceforge.net and have discovered two previously unknown unpassed arguments to functions. While pychecker is useful, it returns a lot of variable not used errors. I'll use it before every .n version release after I do a couple more feature additions. (fixed) Also thanks to Jeff Hodges, I discovered a bug in 1.0 that will tend to produce line endings that are \r\r\n...which is wrong, for ANY system. It is now fixed. It had to do with reading and writing files in ascii mode, not in binary mode. Apparently it makes a difference in terms of line endings. Who knew? #--------------------------------- PyPE 1.0 ---------------------------------- Initial version