<key> | <overview>

!xyWiz


MANAGING THE BASICS
!!! manages session startup/shutdown, file opening/closing, dir navigation, view mode, and--optionally, after customization--configuration/reconfiguration.
9176

Smart search/search&replace utility !^v does crossfile searches and ci's, block ci/cv's, wildcard-in-replace-string-too ci/cv's as well as garden-variety searches and ci/cv's. It also can count instances of a string and represent function symbols on the CMline for xpl s&r operations.
8427

!B brings most block operations under one umbrella--defined or assigned (s/gs @0-@9/@A-@Z) block operations--and adds interactivity and new options. Use !B modules as well to manage the !OutBack command and character buffers.
8282

other editing aids
!CX streamlines use of xyWrite's efficient spellcheck-to/correct-from-a-TMP-file-of-suspicious-words feature.
1107

Learn the size of any file without switching windows from a displayed file, or ... if the arg !CHC receives isn't an existing file and a file is displayed, !CHC reports cursor position plus displayed file's displayed and stored sizes--unless text is blocked, in which case !CHC reports block char and word counts.
844

!CC deals with case three ways: Supplements default au, toggles uc and lc, or caps the entire preceding word or paragraph.
545

!FIND searches each logical drive in your system for the file(s) you designate on the CMline.
796

!EN performs one crossfile procedure per run determined by the path and action_code you designate on the CMline.
509+540+(varies)

!HO scrolls through a displayed file--look, Ma, no hands!--from the cursor position to the end.
376

!FMT lets you eliminate alignment keys.
718

etc
!RM renames or (if the dos you use supports the command) moves the displayed file to the name you give on the CMline and offers to reopen the file under the new name.
2436

!W manages xyWindows.
1523

!MODES generates a tmp file of one-line MD (screen color) samples--current MDs, then the modal spectrum, forming a nicely representative preview for learning and/or changing MD defaults.
2695

!PATH converts spaces in a CMline string to : or \ as appropriate for operations not incorporated in !xyWiz utilities.
997

!GI launches external apps, including win9x apps. It must be customized before use.
433

!PB helps you transfer text between xyWrite and win9x if you use NoteTab or like freeware. You may need to customize before use.
826

Want to know what day of the week your birthday falls on in 3001? What day it fell on in 1001? !D reports day and date--today's or any other--in a prompt and optionally in text.
1983

!NYC issues as a prompt the number of a street near the designated address on many Manhattan north-south thoroughfares.
3564

'net assistants
!NOSEE'EM does three related tasks: conceals all html tags in «pr codes»/converts some iso8859 char entities to near-ascii, reverses the concealment, or kills all hidden tags.
732

!YET_ANOTHER_TAG_STRIPPER strips most html tags and converts iso8859 char entities to ascii and a few html tags, including URLs, to xyWrite formatting.
1437

!URLMGR grabs and archives URLs to a file named NEWSITES.HTM that it creates if it didn't exist.
1703

!ISO8859 is a two-way ascii<>ISO-Latin-1 (iso8859-1) char entities converter normally run by !xyWiz pgms, not directly.
4204

Withdrawn (I've used Windows Commander for these jobs for years): !EZ managed installed format conversion utilities--uu/xxen/decoding, pkZip/pkUnzip, Mime64, etc.
5077

Withdrawn (I haven't upgraded to Opera 5): BETA: !OCC converts the Opera 4 browser cache record to a surfable cache toc. It must be customized before use.
5748

!M and !*.MOD
!M moderates !*.MOD, which contain code for narrow-focus pgms.
1136

!xyWiz help
_XYWIZ.DOC: xyWrite version of this documentation
78726

PREPWIZ.HOW: customization tips
14228

PREP!HL3.WIZ: sets up optional !xyWiz Help frames--a !B front end and a special color chart
6088

PREP_KB3.DOC: !xyWiz custom .kbd assignments summary
34743

    
 
Anytime you need to type a path, !xyWiz pgms let you type
a pseudopath: substitute a space for : and \ (just one for :\).
c perl lib perl5 auto getopt long
becomes
c:\perl\lib\perl5\auto\getopt\long
 
IN ALL INSTRUCTIONS:
  default.kbd
<BC> = clear command line<F5>
<XC> = execute <F9>
<CC> = text/CMline toggle <F10>
<XD> = cancel define <F3>
<NX> = window func next screen <Alt+F10>
<GT> = GoText
<CM> = toggle view <Shift+F9>/<Ctrl+F9>
[bracketed] = optional
 
IN INTERACTIVE YES/NO SITUATIONS in !xyWiz pgms,
as a rule you'll see an XC|BC prompt:
 <XC>--default kbd <F9>--executes
 <BC>--default kbd <F5>--cancels

A reminder: Func XC substitute $X (documented in _xyWiz.doc), which you must use to launch !xyWiz pgms not assigned to keys, relieves you of the necessity of typing "run", launches Help frames too, and puts !xyWise resources at !xyWiz's disposal. Trying to run a !xyWiz pgm with a run command plus XC or Enter instead of $X, or trying to load !xyWise Help frames by tapping a func HL key, generates a No Save Get error.
On exit, all pgms restore the Insert/Overstrike state and where appropriate the command the last run of &C recorded and if they have nothing better to say in a prompt report the name of the pgm that just ran.
 
 
  


MODULES

!!!
 
!!! manages file opening/closing and dir navigation and session startup/shutdown and, if you're so inclined, configuration/reconfiguration. As a session shutdown/startup manager, !!! can record the files open when you quit, and next session reopen the file(s) you were working on when you quit optionally after setting up the next session with your default configuration.

Between startup and shutdown, !!! opens and closes files--with many options. Its central concept is that the screen should be occupied at all times by a file or a dir list. It opens old and new files and navigates from dir lists and trees and when it closes a file, whatever the active subdir, it lists that file's dir--not the directory that's now active unless the file happens to be in it. It runs several fruitful tests when it opens a file.

!!! wants two keys (in unshifted positions if possible) for sure, and for full functionality two more. Not to worry--one !!! module by itself replaces CM (default kbd Shift+ and Ctrl+F9), TP, SP, NM, etc keys.

bailout !!!

When you tap the bailout !!! key, !!! offers several choices, not all included in bailout prompts, and waits for confirmation:
confirm   whether or not a file is displayed
<BC> cancel bailout
<-> drop temporarily to system prompt
<+> quit xyW / at next startup, reopen open file(s), cursor at this position, and reactivate the subdir now active on each logical drive (!!! lets you save or abort each open file before it quits xyW)
if no file is displayed <-|-> a file is displayed
<CC> close this window <-|-> abort edits since last save ...

if !!! doesn't suspect file of being binary and same file isn't open in another window:
<XC> quit xyW / at next startup, reactivate only the subdir now active on each logical drive (if file open in another window, !!! displays it and exits) <-|->
store with eof ...
<NX> close windows #9-#3 with no open file <-|->
store with no eof ...
<^>   <-|->
store with eof, load hardware printer driver, print hard copy, reload default print driver ...
... whatever: Leave file's dir listed (cursor on name of file)--not necessarily the active dir--ready for the next !!! can open'er operation. If a file is open in the adjacent window, go to that window.
<=>   <-|-> If file has an extension and one that's not .HTM: store with eof and tyf with MAIL.PRN, reload default printer driver, display new email copy (where "default" driver is the one in $PR3.LIB 0 position; if 0 position is vacant your hardware print driver; see PREPWISE.HOW).
*
!!! will abort on demand but won't store a file that is also open in another window or a file it suspects of being binary.

When you use !!! to quit xyWrite, whether or not you indicate that you want to start up the next session where you shut this one down, !!! generates two stsgt files for continuity, CONFIG.!KH and WAS.!KH. The latter records your at-exit @s/gs. CONFIG.!KH contains the name of the directory that's active on each drive, and if you want files reopened next session it lists them. At the next startup !CONFIG.LIB reactivates the active drives and if you indicated you wanted files reopened reopens them, and ldsgts your at-exit @s/gs.

To zap the invisible eof xyWrite adds automatically--a no-no on the 'net and in some other situations--!!! invokes an !O.LIB procedure to "do" the !xyWise pgm FIZFIX1A.EXE. !FIZFIX.TMP is a macro FIZFIX1A normally creates each run that self-destructs when the !O.LIB proc runs it. I've closed files thousands of times uneventfully using the zap-eof option. This advice is based on a one-time occurrence that interfered with smooth FIZFIX1A operation for two weeks till I stumbled on the cause:
If xyWrite ever crashes when you zap an eof, delete any !FIZFIX.TMP that may be left behind in the active directory, if necessary first toggling off the read-only attribute with your file manager.

<!!! bailout> key
00=BC,!,!,!, ,[ibm ascii 234],$X bail out: close file & list its dir, or quit xyW
!!! bailout modules ignore the at-launch CMline arg; usually what's on the CMline then is something you wouldn't want to archive, so I suggest BC, not &C, for this !!! key.
!!! can open'er

If you tap the other base !!! key--the can open'er--with a blank screen it lists the active dir.

While a file is displayed, the base !!! key cycles through views, SP to XP to NM to SP, freeing up keys where you may have these functions or func CM assigned. !!! retains what's on the CMline while you cycle views, which gives the key a secondary purpose with a file displayed: replace @Command with a new string. Type it on the CMline, then tap the !!! key (three times to cycle back to the original view mode). To overwrite @C with the top @B archived command (if it doesn't match @C), clear the CMline before you tap the key. (Of course to display a different archived command, tap an !OutBack rotate-@Buffer key.)

With a dir listed ...
... and any string on the CMline an unlikely file name,
when you tap the base !!! key, if the cursor points to ...
... an adjacent <DIR>: list it
  • offer to cd to it:
  • if user responds XC, cd and list it
  • otherwise, exit !!! with dir listed and ed on CMline nb: if the adjacent subdir contains no files, !!! misfires.
      ... a file name:
          open it

  • to neutralize display conflicts, xlate if extension .EXE, .COM, .ZIP, .DLL, or other common binary ext
  • offer to "do" it with the arg that !!! found on the CMline if file is .EXE or .COM
  • edp if the first char in the name is !
  • otherwise, edit it
  • if the stored length is significantly longer than the displayed length, let !!! "do" FIZFIZ1A to zap destructive midfile eof if present? (test not performed on apparent xpl files since they often generate a false positive)
  • if file is already open in another window, proceed?
  • if file is already open in another window or appears to be binary or if arg was R, offer to switch to read-only
  • if file has linefeeds or carriage returns instead of DOS newlines, offer to convert them to newlines and reduce excess newlines to double spaces
  • if file is html, offer to
    • strip tags, keeping only URLs--i.e., run !Yet_Another_Tag_Stripper
    • or to hide tags temporarily--i.e., run !NoSee'em
    • or to render in browser if !!! has been configured to do so
  • if file is xpl, lowercase most code in the event the file has been saved by xyWrite 4
  • if file is zipped, offer to run !EZ to PKunzip it
  • exit !!! with file displayed and neutral command on CMline (which you might want to change in code)
... but if the string on the CMline might be a file name
!!! can open'er is a kinda dumb smart file opener
  • If the file you want is above or below the displayed part of the dir list and has no extension, use !^v to search it. But how do you search filename.ext conveniently in a dir list where a varying number of spaces represent the dot? Try this: Unless the file name begins with an exclamation mark, type filename.ext on the CMline and tap your !!! key. !!! searches filename.ext in dir list form (substituting spaces for the dot). If filename.ext is precise, !!! finds the name and opens the file. If the search fails, !!! attempts a fuzzy search. Then you could find yourself with a screen that contains the file you want or another file or no file. (If the name has a leading !, try omitting it, or use !^v with the leading ! escaped or represented by a WS , and substitute WW for the dot.)
  • *
    @C tip: If the displayed string on the CMline isn't what you want there and a recent command is, if you tap your @C->CMline key (BC$P) you may find that @C is what you wanted. When a dir is listed, the cursor points at a file you want to open, and "ed" is on the CMline, you have three options:
    • If you simply execute the "ed," when the file is open the CMline will be blank but @C still will be @C.
    • If you use !!! can open'er to open the file, @C will be the top @B command and will be the string on the CMline.
    • If you overwrite "ed" by striking your BC$P key, then use !!! can open'er, when the file is open !!! writes that @C to the CMline.

    <!!! can open'er> key
    00=&C,!,!,!,$X in dir list, search filename+extension
    or open file
    or list adjacent dir
    or cd;
    if file is displayed, cycle view
    When you strike the can open'er key, if the string on the CMline is or could be a file name !!! searches it; if the search fails !!! exits. Otherwise, what's on the CMline should be irrelevant.
    !!! edit

    No matter what's displayed--file, dir, or nothing--and no matter what your nw default, if you have another window available and type a path or pseudopath (spaces substituted for :\ and \) and file name on the CMline and tap the
    <!!! edit>
    key, !!! opens the file if it exists or creates a new file with that name if it doesn't.


    <!!! edit> key
    00=&C,!,!,!, ,[ibm ascii 240],$X edit or create the file named on the CMline

    !!! dir display services

    And no matter what is displayed--file, dir, or nothing--and no matter what your nw default, if you have another window available, the
    <!!! *>
    key fine tunes dir display and settings. This key has all kinds of options that I hardly ever use, but I use its two basic options--the first two listed--constantly; they make getting around a drive phenomenally easy.

    To list a dir

    Clear the CMline and type the designation conventionally or as a pseudopath and tap the <!!! *> key:

    <BC>c dl zips <!!! *>
    If C: is the active drive:
    <BC>dl zips <!!! *>
    To tree a drive

    Before or after you tap the <!!! *> key type the letter on the CMline:

    <BC>c <!!! *>
    Or drive and dir display preference [explained below]:
    <BC>c+d <!!! *>
    Or drive and just + to change the type of dir display during !!!'s run:
    <BC>c+ <!!! *>
    With the tree displayed, !!! writes "dir" to the CMline. To exit, clear the CMline. Or first cursor up or down or PgUp or PgDn and point to a subdir you want and execute the "dir," in which case before exiting !!! lists the subdir and writes "ed" to the CMline. Or, to change the command from dir to cd, type a right angle bracket >; !!! then offers to list that dir or any other in the tree you choose.

    To cd to another subdir

    Clear the CMline and type the path conventionally or as a pseudopath followed by a equal = and tap the <!!! *> key:

    <BC>c dl email = <!!! *>
    To change sort order before !!! lists the dir

    Clue in !!! with a + and a letter abbreviation for your sort preference ...

    <BC>c dl email +l <!!! *>
    <BC>c dl zips +d <!!! *>
    <BC>c upload +x <!!! *>
    <BC>c dl zips +a <!!! *>
    ... where
    +l = dirL (directory Long)
    +d = dsort by Date, most recent first (default)
    +x = dsort by eXtension
    +a = dsort Alphabetically
    If +l (dirL), !!! gives you an opportunity to change sort order too during the run. If you affix only a + to the subdir path or pseudopath ...
    <BC>c dl email +<!!! *>
    ... !!! prompts you for sort order.

    *
    If you clear the CMline before tapping the <!!! *> key or give it an arg it doesn't recognize, !!! asks first if you want a tree. If yes, type the drive letter. If not, to cancel tap your <BC> key, in which case !!! asks if you want to list a dir. If you type a drive letter, !!! lists the active subdir on that drive. If you cancel <BC>, !!! offers to change drives: type a letter or, to exit !!!, cancel <BC>.


    <!!! dir services> key
    00=&C,!,!,!, ,*,$X tree the drive or list/cd to the designated dir

    !!! reconfigure session

    If you use xyWrite for mutually exclusive purposes--say, as a front end for dtp, for your compiler, and the Web (i.e., as an html editor), and have a different keyboard map, Help file, format settings, etc, for each--you can use !!! to reconfigure a session, but you first must edit startup.int: see prepWiz.how.

    After editing startup.int per instructions in prep!Wiz.how, to reconfigure during a session you would clear the CMline and issue any of these commands ...

    <BC>!!! x <!xyWise>
    <BC>!!! q <!xyWise>
    <BC>!!! c <!xyWise>
    <BC>!!! h <!xyWise>
    <BC>!!! 4 <!xyWise>

    <!!! session reconfiguration> keys

    Those commands alternatively could be written to custom.kb3 as:
    00=&C,!,!,!, ,x,$X
    00=&C,!,!,!, ,q,$X
    00=&C,!,!,!, ,c,$X
    00=&C,!,!,!, ,h,$X
    00=&C,!,!,!, ,4,$X

    !^V
     
    !^v is a smart search/search&replace utility that in addition to streamlining
     garden-variety se[a]rches and ci[a]/cv[a]s
    and
     crossfile se[a]s and ci[a]s
    can do
     wildcard-in-both-search-and-replace-string s&r's
     search and replace blocked text
    and can
     count number of instances of a string in a file or in a subdir
     represent function symbols on the CMline for xpl s&r operations
    !^v local se[a]/seb[a]

    For a local se[a]/seb[a], clear CMline, type string with no command and a delimiter only after the last char, only if the last char is a space, and tap the !^v key. !^v inserts delimiters. If the string contains no space it uses space; if space is present !^v tries underscore _; if the string contains an underscore !^v reverts to vertical |. If | doesn't work either !^v tries [ibm ascii 22] and if that fails !^v exits.
    <BC>quick red fox<!^v se>
    becomes
    CMse _quick red fox_

    <BC>quick red fox _<!^v se>
    becomes
    CMse _quick red fox _
    se[a]/seb[a] toggle: !^v's name derives from the original module. If a local search fails, !^v searches back, and !^v se[a]/seb[a] keys toggle the direction of an existing search command (up or down, ^ or v). When you tap the key, if what's on the CMline doesn't begin with a search command, !^v searches the string it finds there. Once you've invoked !^v and the se command is on CMline, to search again execute as usual. To reverse the direction, tap !^v key again.

    If a target string is found farther than 1024 chars from the original cursor position--i.e., probably not on the same screen--and if the original cursor position wasn't within 1024 chars of the top or bottom of the file, !^v writes a jmp-to-original-cursor-position bookmark to the delete buffer @D. !^v has a special key to pop these commands from @D. When your !OutBack rescue-chars key inserts [ibm ascii 244+ibm ascii 22], that's the beginning of a bookmark. To clear it, backspace the [ibm ascii 244+ibm ascii 22] and tap your pop bookmark key. Once flushed, a bookmark can be retained only by adding it to the @B buffer by tapping the !OutBack keep-command ($K) key, and with each char deleted or backspaced !OutBack nibbles @D's tail to keep it at a default 253-max chars. (If you don't use !OutBack's char cache and do use @D for other purposes, you'll find the bookmarks prefixed to your s/g @D.)

    !^v crossfile se[a]

    !^v makes it easy not only to search files across a directory, but to work on files you open and then resume the crossfile search.

    Launch crossfile searches the same way as local searches--same key too--except you must of course also let !^v know where to search: Clear the CMline, type path or pseudopath (spaces for : and \) with wildcard * and the search string. !^v transforms

    <BC>c x3 !*.* quick red fox <!^v se>
    to
    CM se c:\x3\!*.* _quick red fox_
    and executes the command--but only after !^v writes the crossfile se[a] command to @C and archives it to buffer @B. After halting a crossfile search, you'll find that the @C command is:
    CM se _quick red fox_quick red fox_
    That command too is archived to @B. To search the string left of the center delimiter, you can simply execute, but the duplication lets you easily edit the second instance and change the se command to cv/i[a]. If you do that you might want to <Keep> the edited cv command and <Kill> (!OutBack keys) the se command !^v built.

    To resume the search--even with the file (or a dir) still displayed--tap your !OutBack <reverse command @Buffer> key to bring the crossfile search command back to the CMline. As you know, if you execute xyWrite will tell you to close the file (at least it does if d nw=0). So do not execute. Instead, tap the !^v search key. If a file is displayed, !^v asks whether to save before it aborts to clear the screen and resume the crossfile search: Execute the save or clear the CMline.

    xyWrite won't search a string crossfile that uses space as delimiters. If your search string contains no spaces !^v uses other delimiters.

    !^v local and crossfile string counter

    Local: !^v counts instances of a string in a displayed file and in a prompt reports the number above the cursor position, the number ahead, and the total--

    nn total | nn above | ahead nn
    --when you append a # switch ( /#)--space required--to the search string:
    <BC>quick red fox /#<!^v se>
    Crossfile: !^v counts the number of instances of a string in each file in a wildcard search and reports the total for each at the top of a file named how_many.$. If how_many.$ doesn't exist, !^v creates a tmp how_many.$ (if you abort, the file won't be on disk). To count instances (using a pseudopath for c:\2www\*.htm):
    <BC>c 2www *.htm quick red fox /#<!^v se>
    !^v will count instances of quick red fox in *.htm in the c:\2www subdir.


    !^v se/seb exceptions

    Customization: Ambiguous delimiter situations can cause !^v to fail; you'll have to search such strings manually. But if _ and | both occur often in strings you search, consider replacing one of the hard-coded delimiters with a never-used char in !^v code (PREPWIZ.HOW has a tech note on this); if you do, dedicate a key to the unusual delimiter.

    Escape sequences: Because of some arcane !xyWise workings, strings that begin with an exclamation mark don't reach !xyWiz pgms. To search one, prefix a slash / so the string begins "/!". To search "!!!":

    <BC>/!!! <!^v se>
    To search a string that actually begins "/!", duplicate the escape:
    <BC>//!!! <!^v se>
    Because of !^v's own workings, a search string that begins with "se," "sea," or "seb" won't work. When you need to use one, prefix a slash / so the string begins "/se". To search "se whatever":
    <BC>/se whatever<!^v se>
    To search a string that actually begins "/se", duplicate the escape. To search "/se whatever":
    <BC>//se whatever<!^v se>
    To search a string that contains an asterisk followed by a space or dot . ("*." or "* "), escape the two chars by separating them with a slash.
    <BC>se _what */. ever_<XC>
    <BC>se _what */ ever_<XC>
    become
    <BC>se _what *. ever_<XC>
    <BC>se _what * ever_<XC>
    To search a string that ends with " /#" when you don't want to count instances of the string, dup the escape:
    <BC>quick red fox //#<!^v se>

    <!^v search> (local, crossfile, and string count) and related keys

    You may be able to do without a seb key because of the se/seb toggle.

    00=&C,!,^,v, ,s,$X all ignore-case search options
    00=&C,!,^,v, ,S,$X all case-sensitive search options
    00=&C,!,^,v, ,b,$X seb (the se[a]/seb[a] toggle
    may make seb keys unnecessary)
    00=&C,!,^,v, ,B,$X seba (")
    00=&C,!,^,v, ,[ibm ascii 22],$X pop @D !^v search bookmark or !CHC data

    !^v local and crossfile ci[a]/cv[a]s

    For any local ci[a]/cv[a], clear CMline, type string with no command, use a delimiter only

    • to separate ci[a]/cv[a] strings
    • again after the last char only if
      • the last char in the replace string is a space or
      • you're deleting all text that matches the se string
    and tap the appropriate !^v ci/v[a] key. !^v inserts delimiters. If the string contains neither underscore _ nor vertical | !^v tries to use space. If it can't, it tries underscore _. If that fails !^v reverts to |, and if | doesn't work either !^v exits. !^v can get confused when it sees both _ and |. If both often occur in your s&r strings, review search section customization note above.
    <BC>lazy brown dog_quick red fox<!^v cv>
    If replace text is plain vanilla as above, e.g., if you haven't started a text block, and if the only file to be processed is the one that's on screen, !^v executes and passes control to xyWrite as
    CMcv _lazy brown dog_quick red fox_<XC>
    Stifle that yawn. Here comes the geewhiz stuff. !^v ci/v[a] accepts replace as well as search strings that contain wildcards, and does ci/v[a] operations, including search wildcard_replace wildcard, in the open file or across a subdirectory. And !^v s&r's text blocks in the displayed file. Yep, you can stop envying xyWrite 4's advanced s&r options.

    In the case of block and search wildcard_replace wildcard operations, "ci[a]" stretches poetic license. Actually, !^v's "ci[a]" speed resembles ch[a]'s, but v3 ch[a] is so little used--for good reason, the speed being as syrupy as a v4 ci--I'm not sure v3 users would recognize the command.

    When a text block exists, !^v effects changes only within its boundaries (roughly: it may over- or undershoot the block end slightly; as ever, cv[a] is safer than ci[a]). !^v assumes an incomplete block should end at the cursor position and defines there. You may search wildcard_replace wildcard within a block as well as to the end of the file or crossfile.

    The only usage difference between local and crossfile s&r is that to search & replace across a subdir you must of course tell !^v where to act: Clear the CMline, type the path or pseudopath (spaces for : and \) with wildcard * and the s&r string. Follow standard delimiter guidelines and tap the usual !^v ci/v[a] key. !^v ci (using case autodetection option--details below) transforms

    <BC>*.* Quick Red Fox|quick red fox<!^v ^ ci>
    to (in effect):
    CM cia *.* |Quick Red Fox|quick red fox|
    You may search wildcard_replace wildcard crossfile as well as to the end of the file or within a block.

    Crossfile, !^v detects several varieties of binary files and before processing each requests confirmation. Options:
    Execute [default F9]     Process the file
    Del Process the file, disable future warnings during the run
    any other key Skip processing this file and abort it
     
    In crossfile s&rs you'll be asked whether you want to save each file where !^v makes changes: XC saves, BC aborts. !^v ends with files within the scope of the wildcard path listed and the ci/v[a] command on the CMline.

    crossfile and local cv[a] options are standard:
    [s] change and Stop here
    [y] Yes, change and proceed to next instance
    [n] No change, proceed to next
    [q] no change, Quit here
    [a] no change, Abort operation at original cursor position
    Again, usage is the same for other ci/v[a]s and those that use replace string wildcards. !^v--like xyW4--requires matched wildcards either side of the center delimiter. !^v takes them in the order it finds them. You can of course mix types of wildcards:
    <BC>987 WN WN WN 321 ihg WW cba_123 WN WN WN 789 abc WW ghi <!^v ci/v[a]>
    changes
    987456321 ihgdefcba
    to:
    123456789 abcdefghi
    Because !^v expands replace-string wildcards on the CMline in a cv[a], WW (s) may cause an overflow that's purely cosmetic. !^v replaces with the whole string even when the CMline can't hold it all.

    wildcard replace options:

    • To protect text from replacement, at the end of your replace string type an ascii char 249 ·, then text you want not to replace if it occurs within a found wildcard.
    • To restrict the number of characters processed as a string wildcard (WW ), at the end of your replace string type an ascii char 249 · (new 249 if you're protecting text) and the number.
    <BC>wildcard goo|foo wildcard[·nn·boo]<!^v>
    E.g., in each instance,
    <BC><img src=" WW " alt=" WW " _<img src=" WW " alt=" WW " ·40·@ny <!^v>
    !^v acts only if each wildcard is 40 or fewer chars and doesn't contain the sequence "@ny".

    Caution: On exit, after a local replace_wildcard s&r !^v leaves the ci/cv[a] command it built from your raw string on the CMline. If you've left some instances unchanged and execute one of these informational commands in plain xyWrite 3, WW s will be changed to W, WX s to X, etc. After a crossfile replace_wildcard s&r, the CMline string follows the form of a crossfile se[a]; executing normally generates an error msg.

    !^v accepts the functional wildcards ...

    WW string up to 80 chars
    WL letter
    WN number
    WA letter or number
    WS separator
    WX any char
    (no, not the evanescent WC )

    !^v ci/cv exceptions

    Escape sequences: The search prefix and asterisk escape sequences noted above apply as well to ci/v strings; !^v ci/v[a] is indifferent to the end " /#" sequence.

    Whether or not an s&r string contains wildcards, to use ascii char 249 · (with no exclusionary significance if the string does contain wildcards), escape it with a dollar sign $:

    Ambiguity confuses !^v. Mixed !^v reserved delimiters in an s&r string may work or you may have to do the change manually or may not be able to do a !^v replace_wildcard or block s&r.

    If you're excluding a single space, vertical |, or underscore _ in a wildcard s&r, don't use that char as the delimiter too. If excluding text and designating a length restriction, type the exclusionary string first. If the string you want to skip is numeric and you omit a length restriction, the proc will interpret the numeric as a length restriction unless you give !^v a dummy--unrealistically long--length restriction after the exclusionary string.

    Trailing spaces always present a "challenge" to info passed via CMline arg. !^v assumes that an ascii char 249 · at the end of the replace string means that you want to reject found wildcard strings that contain one space. To reject a replacement string that contains more than one space, after the ascii char 249 · plus whatever number of spaces type another · --

    · ·
    --even if you don't want the number of chars restricted.

    !^v search wildcard_replace wildcard operations had a troubled youth, but the current !w!w! procedure, rewritten from scratch (PREPWIZ.HOW contains a tech note on including it in your own pgms), so far seems rock solid if less ambitious than before. What !^v loses in reach it gains in reliability. !^v s&r's worst prob now is confusion over mixed delimiters, unrelated to replace wildcards. That said:

    Known bugs: In a WW |WW s&r, if two strings near each other fulfill the search criteria !^v may crash: The rest of the s&r is aborted and a ctrl char, usually ascii 18, follows the search command.

    !^v treats contiguous wildcards as a unit. If you want to

    ci _WN WN october_WN november_
    and !^v finds 31 october, it uses 31 november, not 3 november, as the replace string.

    And remember the xyWrite idiosyncrasy noted in _xyWise.doc: EDITOR counts nulls it doesn't display on the CMline, so mentally add one char to the length of your s&r string for the invisible null each wildcard and newline contains.


    <!^v ci/v[a]> (ordinary, block, wildcard, & crossfile) keys
    00=&C,!,^,v, ,v,$X
    00=&C,!,^,v, ,i,$X
    00=&C,!,^,v, ,V,$X
    00=&C,!,^,v, ,I,$X
    cv
    ci
    cva
    cia


    !^v: convert two chars to a function symbol for xpl se, ci/v etc

    !^v converts the two chars that precede the cursor on the CMline to a function symbol for a search or ci/cv in xpl or--if it receives no arg--two chars typed on the fly. !^v records the command to @C and archive @B, so if you ...

    <BC>se _gt<!^v F>
    ... the archive records
    se _ Ç}
    without the end delimiter. (The apparent space before Ç, ü, or é at the beginning of any func symbol is a null.) To construct a complete command for reuse, type the command and string and leave cursor immediately after the two chars you want to convert, e.g.:
    <BC>sea _gt_<!^v F>
               ^ before tapping <!^v>, cursor back to position
                 immediately after symbol's ascii representation
    After you tap <!^v F>, the CMline and @B archive entry will read:
    sea _ Ç}_
    When you execute, the command will locate instances of GT . !^v converts one symbol per pass. To build a cv or ci command, type and execute a command like this:
    <BC>cia _&p_&x_<!^v F>
                  ^ cursor here
    The command line and archive will then read:
    cia _ ü[ibm ascii 229]_&x_
    Position the cursor immediately after the latter char of the second func symbol, and tap the <!^v> key again ...
    <BC>cia _ ü[ibm ascii 229]_&x_<!^v F>
                                 ^ cursor here
    Your full ci command will have replaced the earlier command in @B:
    cia _ ü[ibm ascii 229]_ ü[ibm ascii 245]_
    Tip: Using case-sensitive commands habitually with func symbols is a good practice; e.g.,
    ci _ER_LE_
    becomes:
    ci _ Çy_ ü#_
    Executing the command changes all CI s as well as ER s to LE because:
    CI = [null]ÇY
    ER = [null]Çy
    If the cursor is in text when you tap <!^v F>, !^v pfuns the two chars that precede the cursor. The *.kbd macro below does the same thing and I use it just because it's lower-tech, but applying !^v instead does save you one key assignment. Whatever, when you tap the !^v func symbol key, heed cursor location.

    The !^v func symbol module owes its form to Robert Holmgren's breakthrough work with nulls in xyWrite. While equally effective, my previous func symbol converter relied on tables so was comparatively huge; it used no parsing, so did have the virtue of working in all xyWrite 3 releases.

    <!^v func symbol> key
    00=&C,!,^,v, ,F,$X
    ;

    00=GTXDDFCLCLDFSV,c,XD
    GH$ISILB,p,f,u,n, , ,CL$PCIXC
    RCDFDFSV,c,XDGHCR$S$OGTCLCR
    convert the two chars that precede
    cursor to func symbol on CMline or in text

    kbd macro: convert the two chars that precede cursor in text only to func symbol



    reducing the number of <!^v> key assignments

    To be fully functional, !^v needs 10 key assignments. Two kbd options reduce the number at a price in functionality. (And know that some !^v options tax memory: If I detect trouble that shortening !^v could help, code that enables key reduction will be the first to go.) seb and seba keys are the the most expendable, then the case-sensitive keys.

    You can use one key for all !^v options--

    00=&C,!,^,v,$X          state intent on the fly
    --if you're willing to tell !^v your intent after each launch. This half defeats !^v's purpose and can be confusing because a prompt is too short to cover the options:
    Pop Func|cap only if Abs: Se seB cI cV ?
    !^v wants a single-char response, the capped char in each token; except for Func symbol conversion or Pop bookmark, cap the char in your response only if you want the operation to be case-sensitive:
    S = Sea
    B = seBa
    I = cIa
    V = cVa
    s = se
    b = seb
    i = ci
    v = cv
    f = convert Func symbol
    p = Pop bookmark
    BC = exit the pgm (unlisted in prompt)
    If you're continuing a !^v operation--e.g., resuming a crossfile search or toggling a se/b command--type the char you used to initiate the action. To do a func symbol conversion, ignore the interface's search/s&r implications; if a CMline func symbol conversion, you'll have to respond twice: If you launched from a clean CMline to input chars on the fly, the @Command !^v shows you will be extraneous; after typing F, BC to get a clean CMline. If the string on the CMline contains the chars you want converted, XC.

    Another !^v custom.kb3 option reduces the number of se/s&r assignments to three or four (plus func symbol and pop bookmark keys). If you insert an extra carat into the .kbd sequence and !^v finds any cap in the search or s/r string it automatically makes the command case-sensitive--but to search or s&r lower-case text case-sensitively, e.g., you must then edit the command manually to make se sea, and some chars you may not expect to will turn the command case-sensitive. That reduces se/s&r !^v .kbd assignments to se, ci, and cv keys:

    00=&C,!,^,v, ,^,s,$X
    00=&C,!,^,v, ,^,b,$X
    00=&C,!,^,v, ,^,v,$X
    00=&C,!,^,v, ,^,i,$X

    all search options
    seb/seba (optional?)
    cv/cva
    ci/cia
    *
    It's up to you. From my xyW day one, my custom.kb3 never has been related in any way to the default.kb3 map--even my alphanumeric keypad is unorthodox. Searches and s&rs are as fundamental to text processing as block operations, and to max out search features I don't blink at devoting a sixth of available Fkey positions to !^v options. If you want to use !^v and that seems excessive to you, use one !^v key and put up with endless interaction, or use ^ with !^v args and edit commands when necessary.
    !B
     
    !B consolidates all known block operations except spellcheck and cv[a]/ci[a]--general or assigned block operations (s/gs @0-@9/@A-@Z)--and makes interactivity uniform. !B custom.kb3 args are case-sensitive!
    !B defined-block options

    If no define has been started when you tap the base !B key, !B starts one.

    *.kb3:
         00=&C,!,b, ,#,$X ; DF ... DF/RD  

    Move the cursor to the end of the block. !B presents an array of block operations you can do now, depending on which key you tap. Each defines block end, then transforms the block in some way:

    Delete block to "clipboard." If you tap the !B base key again, !B removes the block from the screen--warning you first if the block is dangerously long and giving you the option of exiting, and issuing an error msg if the cursor is outside the block. Func UD (default kbd <Alt F3>) retrieves the block at the present cursor position (=CP) or anywhere else--not just the file in this window. Thus you can replace func MV, CP, and RD key assignments with the !B base key, and func DF too if you add to your *.kbd !B keys that complete the define and do other operations.

    *.kb3:
         00=&C,!,b, ,#,$X

    00=UD
    00=DB
    00=DE
    ; DF ... DF/RD
    ; and remember:
    ; restore removed block
    ; jmp->block beginning
    ; jmp->block end
     

    Overwrite currently blocked text with the contents of the clipboard (as a gui Ctrl+V or Shift+Ins does when a block is defined).

    *.kb3:
         00=&C,!,b, ,=,$X ; overwrite new block with clipboard blk  

    Get block's word and character count.

    *.kb3:
         00=&C,!,b, ,w,$X ; char & word count  

    Embrace block with «MD??»mode codes«MDNM». Prompt offers options (freeing seven keys that set mode) and offers to make «MDRV» !xyWWWiz !4www-compliant (pretag for html img). All «MDNM» close codes observe !4www protocols.

    *.kb3:
         00=&C,!,b, ,[ibm ascii 15],$X ; embrace with «MD??»mode codes«MDNM»  

    Embrace block with «ct??»/«ec» column table deltas. Prompt asks number of columns: Create one «coN» for each, and spec the «ct??» for equal-width cols.

    *.kb3:
         00=&C,!,b, ,[ibm ascii 155],$X ; insert «ct??»/«ec» and «coN» deltas  

    Embrace block with «ipNN»/«ip0» indent deltas. Prompt asks whether the indent needs to be !xyWWWiz !4www-compliant (pretags for html lists).

    *.kb3:
         00=&C,!,b, ,h,$X ; insert «ipNN»/«ip0» deltas  

    Before you tap the key that launches any of the next three modules, clear the command line and type the name of the target file:

    Save as designated file (sad).

    *.kb3:
         00=&C,!,b, ,d,$X ; sad->file named on CMline  

    Prefix to designated file.

    *.kb3:
         00=&C,!,b, ,a,$X ; append->file named on CMline  

    Append to designated file.

    *.kb3:
         00=&C,!,b, ,p,$X ; prefix->file named on CMline
     
    ci/cia/cv/cva within block

    Insert block at CMline cp.

    *.kb3:
         00=&C,!,b, ,g,$X
    00=DFSV,c,XDGHSI$PCI
    ; block->CMline
    ; block->CMline (!xyWise alternative)
     

    Sort block.

    *.kb3:
         00=&C,!,b, ,s,$X ; sort  

    Change block's case.

    *.kb3:
         00=&C,!,b, ,c,$X ; change case  

    Cap block.

    *.kb3:
         00=&C,!,b, ,u,$X ; cap  

    Lower case block.

    *.kb3:
         00=&C,!,b, ,l,$X ; lc  

    C/lc block: lc except initial char of most >2-char words (titles). (editing note in PREPWIZ.HOW)

    *.kb3:
         00=&C,!,b, ,%,$X ; c/lc  

    Type block to disk.

    *.kb3:
         00=&C,!,b, ,f,$X ; tyf->FILENAME.TFB  

    Type block to printer [untested].

    *.kb3:
         00=&C,!,b, ,t,$X ; ty->printer [untested!]  

    !B prompts for s/gs @0-@9/@A-@Z (@?):
    sV v save block to @? (SV)

    *.kb3:
         00=&C,!,b, ,-,$X ; save->@<?> (func SV)  

    Px p prefix block to @?

    *.kb3:
         00=&C,!,b, ,^,$X ; prefix->@<?>  

    Ad a append block to @? (AD)

    *.kb3:
         00=&C,!,b, ,&,$X ; append->@<?> (func AD)  

    The define state is irrelevant to the next two options; existing block will be unblocked:
    Start block at cursor position and jump max safe number of chars for RD or, if @C is a number, jmp that many chars.

    *.kb3:
         00=&C,!,b, ,j,$X ; define & jmp @C num of or 24499 chars  

    Start block at cursor position and jump more chars than are safe for RD (e.g., to append or sad, then cancel define)

    *.kb3:
         00=&C,!,b, ,J,$X ; define & jmp 34999 chars  

    !B assigned-block operations

    When you use an arg that relates to blocks assigned to s/gs @0-@9/@A-@Z, !B asks which @s/g (here "@?"). The define state is irrelevant except for SV, AD, and prefix to @?. (Use !B modules to manage the !OutBack @B command archive and reinitialize @B and @D [delete] buffers as well as the @C [current command] buffer. !OutBack options are documented in _xyWise.doc.)

    Insert @? in text at cursor position. To insert CMline string in text, answer c. Frees up 36 default.kbd keys for better use by making an @0-@9/@A-@Z table unnecessary.

    *.kb3:
         00=&C,!,b, ,+,$X ; @<?>->text (func @0-@9/@A-@Z)  

    Insert @? at command line cursor position.

    *.kb3:
         00=&C,!,b, ,/,$X ; @<?>->CMline  

    Copy command line string to @?

    *.kb3:
         00=&C,!,b, ,\,$X ; CMline->@<?>  

    Remove @? or reinitialize @B, @C, @D.

    *.kb3:
         00=&C,!,b, ,z,$X ; zap @<?> or reinitialize @B, @C, @D  

    !B func SD and SK substitutes are more forthcoming than the unadorned xyWrite functions if you can be patient with the prompt's inscrutable abbreviations for the options described here:

    !B func SD presents the usual SD readout plus an interactive @dir.

    *.kb3:
         00=&C,!,b, ,*,$X ; (func SD)  

    !B func SK presents the usual SK readout plus @? options.

    *.kb3:
         00=&C,!,b, ,@,$X ; (func SK)  

    !B SD and SK assigned block menu.
    Unless noted, the define state is irrelevant:
    Zap ? @ >tX ^Cl cL sV Px Ad
    Those enigmatic abbreviations deconstructed:

    prompt     type     result
    Zap z remove @? or reinitialize @B, @C, or @D
    ? ? @ dir (interactive func SD)
    @ @ @? readout (interactive func SK)
    tX x @? to text (interactive func @0-@9/@A-@Z)
    Cl c @? to CMline
    cL l CMline string to @?
    If block has been started:
    sV v define end here and save block to @? (SV)
    Px p define end here and prefix block to @?
    Ad a define end here and append block to @? (AD)

    Alternative to assigning !B kbd sequences, use the SD and SK substitutes for @? operations, and Help Frame @ (set up by PREP!HL3.WIZ) lists many !B options, launches !B after you choose one and execute, and feeds !B the command that was on the CMline when you tapped the Frame @ key, a string !B needs in some cases.

    *.kb3:
         00=&C,@,$X ; Frame @ (!B front end)  
    !FIND

    Clear the CMline, type the name of a file or files (wildcards ok) you want to locate, and tap your !find key: !find searches each logical drive in your system for the file(s) and lists all that fit the description. At exit !find reverts to the drive where you started; to call a listed file, execute a [d]: to activate to the drive that contains it, place your cursor on the file name in the list, and execute an edit command.


    <!find> key

    If you don't dedicate a CUSTOM.KB3 key to !EN.MOD module !FIND--
    00=&C,!,M, ,!,f,i,n,d, ,$P$X
    --you'll find it easier to run it and all !*.MOD pgms if you create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!find [file name]<!*.MOD>
    ; <!*.MOD> key
    !EN

    !en performs one crossfile procedure per run determined by the path and action_code you indicate in CMline switches. (For crossfile ci[a]s, use !^v.) !en is modular so you can add crossfile tasks to the simple-minded demos herewith along with their action_codes:

     a template for new crossfile procedures
    CLN convert carriage returns and linefeeds to newlines (mistakenly called carriage returns by xyW docs)
    N_L convert newlines to linefeeds
    T_S time-stamp files in path with the time now
    HTM surf your www cache subdir: inventories files in your cache to a new htm file you can load with your browser
    _T1 not for running (unless you have Type 1 fonts in \T1 and \T1\PFM that must be registered to ATM manually)! The module opens each .PFB binary, collects the font's full name, tests whether a matching .PFB exists, and records the info in an adjacent file in a form that can be edited easily for use in win.ini and atm.ini.

    For help adding new crossfile procedures see _myWiz.doc (bundled with _xyWise.ref in the xplWise package).

    To launch, clear CMline, type pseudopath (!en will fill in spaces before the wildcard with : and/or \) or path and action_code, and tap your !en or <!*.MOD> key (in the latter case, type !en before the path or pseudopath):

    BC [!en] en_*scope action_code
    e.g., to time stamp certain files in this subdir:
    <BC>c:\this\!*.* t_s <!en key>
    OR
    <BC>!en c:\this\!*.* t_s <!*.MOD key>
    If !en suspects that the file it just opened may be a binary it asks if you want to continue processing this particular file. Options:
    XC [Execute: default F9] Process the file
    RC [Del: !xyWise &D] Process the file, disable future warnings during the run
    any other key Skip this file--abort and proceed to next


    <!en> key

    !EN code can be found in !EN.MOD. If you don't dedicate a CUSTOM.KB3 key to !EN--

    00=&C,!,M, ,!,e,n, ,$P$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X
     
    <BC>!en path action_code <!*.MOD>
    ; <!*.MOD> key
    !CX

    If interactive spellchecking turns you on, !CX is not for you. !CX exploits xyWrite's option to spellcheck to a TMP file of suspicious words where you edit errors, and xyWrite corrects the file from that list.

    If no file is open when you launch !CX and you give a file name as an arg, xyWrite spell checks that file. If you launch !CX from a displayed file, !CX asks whether to save the file before !CX aborts it and instructs xyWrite to create the TMP correction file.

    !CX exits leaving the TMP correction file displayed and every entry dup'd. If the word is incorrect, fix the duplicate. If ok, you can leave the two-word paragraph as is, but if you delete the graf the fix is quicker.

    When you've finished editing the correction file, relaunch !CX. If no file is open, give the name of the correction file as the arg. !CX fixes the original file, deletes the TMP correction file, and reopens the corrected original (xyWrite closes it after fixing it). !CX reads pseudopaths, so ...

    <BC>c 2www _xywiz.how<!CX>
    ... spell checks and corrects c:\2www\_xywiz.how.


    <!cx> key

    If you don't dedicate a CUSTOM.KB3 key to the !01.MOD module !CX--

    00=&C,!,M, ,!,c,x, ,$P$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X
     
    <BC>!cx <!*.MOD>
    ; <!*.MOD> key
    !CHC

    If you designate a file name as the arg (full path or pseudopath), !CHC reports the file's stored size--i.e., learn the size of any file without switching windows from a displayed file.

    If the arg isn't an existing file and a file is displayed, !CHC reports cursor position plus displayed file's displayed and stored sizes--unless text is blocked, in which case !CHC reports block char and word counts. !B w performs a similar operation, but if a define is unresolved !B completes the block; !CHC leaves an unresolved define open-ended.

    !CHC issues the report as a prompt and writes it to the top of delete buffer @D. After a key press erases the prompt, you can pop it from @D and put it on the CMline by tapping the !^v retrieve jmp bookmark key or, to bring the info into text, press the !OutBack &G key (rescue deleted chars; you'll get delimiters at the beginning and end of the data). If you don't use !OutBack and do use @D for other purposes, you'll find a !CHC report prefixed to your s/g @D. !CONFIG.LIB initializes @D, so if you haven't assigned &G to a key you can see the !CHC report with the !B @ key <d> or func SK <d>.

    <BC>c 2www _xywiz.htm<!chc>
    ... gets c:\2www\_xywiz.htm's size no matter what is displayed. Or issue this command ...
    <BC>!CHC [file name] <!*.MOD>
    ... or just tap your !CHC key with a file displayed, with text blocked or not.


    <!chc> key

    If you don't dedicate a CUSTOM.KB3 key to the !01.MOD module !CHC--

    00=&C,!,M, ,!,c,h,c, ,$P$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!chc<!*.MOD>
    <BC>!chc d wiz _xywiz.doc<!*.MOD>
    ; <!*.MOD> key
    Also, NB:
    00=&C,!,^,v, ,[ibm ascii 22],$X pop @D !CHC data or !^v search bookmark
    !RM

    !RM renames or (if your target path is on another drive and the dos in use supports MOVE) moves the displayed file, or a file designated by cursor position in displayed dir list, or--if screen is bare--the last displayed file if it was in the active subdir, to the new name you give !RM as an arg and offers to open the renamed file. If arg's (new name's) last char is \, the same file name will be used--nb!!!: otherwise if file name is omitted !RM believes the last subdir in the path is a file name and uses a kludge to recover from the error, assuming the intent was to use the file name as the new name. !RM reads pseudopaths, so assuming C:\WISE&\_XYWIZ.HOW is displayed ...
    <BC>c 2www prepwiz.how<!rm>
    ... renames the file to the c:\2www subdir as PREPWIZ.HOW and gives you a chance to pick up where you left off. If the target is similar, use $P øile key--
    33=GH,ø,$P
    --to put current name on the CMline, edit it to target name, and tap <!rm>:


    <!rm> key

    In cases where the CMline string at launch is critical to a pgm but won't be needed past the end of the run and would be unwelcome as @C, instead of starting the custom.kb3 sequence with &C, you can use a *.kb3 trick that keeps the old CMline string. Although this example ends with Overstrike turned on, at the end of !RM's run !xyWise will reapply the TI state in effect the last time &C was used.

    If you don't dedicate a custom.kb3 key to the !01.MOD module !RM--

    00=$IGHLBSI,!,M, ,!,r,m, ,$O$X
    --you'll find it easier to run !RM and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!rm c x3 newname<!*.MOD>
    ; <!*.MOD> key
    !CC

    !cc deals with case three ways:
    • Supplements default au.
      • if command is already cc, cc's previous word's first char
      • if command is anything else, changes case of char under cursor; key sequence controls whether @C or cc is left on CMline
    • Toggles uc and lc.
    • Caps the preceding word or paragraph and restores @C.
    Of course, once !cc puts a case change command on the CMline, XC executes the command subsequently.

    <!cc> keys

       00=&C,!,M, ,!,c,c,$X replace CMline $ with cc
    00=&C,!,M, ,!,c,c, ,$P$X cc char, restore @C unless CMline $ is ed

    If you don't dedicate CUSTOM.KB3 keys to !01.MOD module !CC, you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key--

       00=&C,!,M, ,$P$X ; <!*.MOD> key

    --but !cc should be on dedicated keys if you need it at all, and certainly the next two should be:

    These are shifted space (cap word) and return (cap paragraph) keys. Include func AR if you use a late xyWrite 3 that requires it.

    57=AR&C,!,M, ,!,c,c, ,^,GT, ,$X cap preceding word
    28=AR&C,!,M, ,!,c,c, ,^,GT,[ibm ascii 13],$X cap preceding graf

    !GI (requires customization before use)

    With a file open in xyW3 that you want to see with another app, including Windows apps, clear the CMline, type a one-char !GI code for the other app, and tap your !GI key; e.g., to render the open file with Opera:

    <BC>o<!GI key>
    !GI offers to abort the open file without saving (so you could, e.g., open a .JPG file, type your browser's app code and !gi key, and view the .JPG safely) and passes the name to other app, launching it if it's not already open.

    As is, however, !GI is useless to you. See PREPWIZ.HOW for customization help.

    !GI as is is set up so in one instance instead of asking the other app to display the file that's open in xyWrite, it asks Opera (change if you use another browser) to render the !xyWWWiz Quick Reference WWW-safe HTML Color Chart.

    <!gi> key

    If you don't dedicate a CUSTOM.KB3 key to !01.MOD module !GI--

    00=&C,!,M, ,!,g,i, ,$P$X
    --you'll find it easier to run it and all !*.MOD pgms if you create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!gi<!*.MOD>
    ; <!*.MOD> key
    !PB (wants customization)

    The NoteTab use-file-as-pasteboard feature is one of that Windows text editor's many nice tools: While NoteTab is open, if you've declared a file a pasteboard file every clip you block in any win95 app is pasted to the NoteTab file automatically.

    If you prefer xyWrite full-screen, the feature is a handy vehicle for transferring text between win9x and xyW3. The !pb module copies text between a dedicated Notetab pasteboard text file and any other file, but wants customization before use. !pb assumes a pasteboard file named PB and a default clip delimiter line that begins with three colons:
    :::
    You can set the default delimiter in NoteTab, or in !pb change the delimiter or change the assumed name of or prefix a path to name of the pasteboard file; details in PREPWIZ.HOW.

    When you launch !pb, a file must be open in the active window. That file can be PB or the source/target file. If the displayed file is PB and the adjoining window contains no file, !pb exits. If PB isn't open in any window at launch, !pb opens PB in an adjacent window; if PB doesn't exist, !pb creates it.

    What text !pb copies depends on what is or is not defined when you launch:

    • If no text is defined in either file, !pb copies the last item in PB, as defined by the default delimiter, to the source/target file at the cursor position. To copy a different clip from PB, open PB before launch and block that text.
    • If text is defined in the source/target file: If !pb opens PB, !pb copies the block to the top of PB. If you opened PB, !pb copies at the cursor position in PB.
    • In either file, if a text block has been started but not completed !pb searches the next default delimiter and ends the block after the delimiter. If !pb finds no delimiter it finishes the block at eof.
    • If the block is dangerously long, !PB asks if you want to risk losing the text. If you decline, !pb exits.
    • On exit, !pb leaves both files displayed, the copied text still blocked in the source file.
    • If PB is the source file, decide after !pb exits whether to save target.
    • If PB is the target file, !pb saves PB less the xyW-generated eof ascii 26. If NoteTab is open with PB displayed when you do this, when you next engage NoteTab, it will note (unless you've configured it not to) that another app has changed PB and ask whether to update it.
    • If your system declares a sharing violation and refuses to save PB, uh ... sorry. The fix is probably a simple matter of changing some Windows setting everyone else knows, but I don't.

    <!pb> key

    If you don't dedicate a CUSTOM.KB3 key to the !&.MOD module !PB--
    00=&C,!,M, ,p,$X
    --you'll find it easier to run them and all !*.MOD pgms if you create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>p<!*.MOD>
    ; <!*.MOD> key
    !D

    Herb Tyson laments in "XyWrite Revealed" the lack of a xyW3 «va$da» variable, then offers an algorithm that prefixes the day of the week to any date input on the fly. I couldn't hope to write such an algorithm, so !xyWiz borrows and condenses The Herb's to create a day and date «va$da» s/g that displays today's or any other as a prompt, and if the cursor was located in text when you invoked !d inserts it there. !d expects to find a date on the CMline:
    <BC>!d [d mmm yyyy] <!*.MOD>
    mmm d, yyyy is OK too and months may be spelled out or abbreviated, but the year must be four digits and the last token. If !d finds nothing on the CMline it considers a date and a file or dir is displayed, !d uses the today command to assemble today's day and date. If !d doesn't understand the date it finds it asks for on-the-fly input. Output style is Dddd, d Mmmm yyyy:
    Sunday, 31 December 2000
    Monday, 1 January 2001
    What's good enough for Strunk & White is good enough for me.

    <!d> key

    If you don't dedicate a CUSTOM.KB3 key to !01.MOD module !D--
    00=&C,!,M, ,!,d, ,$P$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!d jan 1 2001<!*.MOD>
    ; <!*.MOD> key
    !NYC

    !NYC reports in a prompt the number of a street near an address on several Manhattan north-south thoroughfares usually north of Houston (HOUSE-ton to you, pardner) Street. Clear the CMline, type the house number and an abbreviation or full name from the left-hand column, and tap your xyWise key:
    <BC>!nyc [house_number name_of_thoroughfare] <!*.MOD>
    e.g.,
    <BC>!nyc 420 lex <!*.MOD>
    <BC>!nyc 158 a <!*.MOD>
    <BC>!nyc 853 7 <!*.MOD>
    br [Broadway] (north of 8th Street)
    riv [Riverside Drive]
    cpw [Central Park West]
      avenues:
    1-11 [First through Eleventh]
    a-d [Alphabet City]
    ams [Amsterdam]
    aud [Audubon]
    col [Columbus]
    con [Convent]
    edg [Edgecombe]
    ft [Ft Washington]
    len [Lenox]
    lex [Lexington]
    mad [Madison]
    man [Manhattan]
    park [Park]
    ple [Pleasant]
    st [St Nicholas]
    wad [Wadsworth]
    wes [West End]
    york [York]

    <!nyc> key

    You'll find it easy to run !01.MOD module !NYC and all !*.MOD pgms if you create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!nyc 1445 br <!*.MOD>

    Or dedicate an !nyc key:

    00=&C,!,M, ,!,n,y,c, ,$P$X
    ; <!*.MOD> key
    !PATH

    Never again type : or \ in a path. Type something like this on the CMline and tap !PATH key ...
    <BC>c projects 2001 dec week4 <!path>
    ... and !PATH returns:
    CM        c:\projects\2001\dec\week4
    (with space at beginning of the line for you to supply a command).

    At the end of the pseudopath type = plus a char !PATH recognizes and !PATH adds a command and executes. E.g.:

    <BC>c projects 2001 dec week4=k <!path>
    becomes
    CM mkdir c:\projects\2001\dec\week4
    Pseudopath functionality is built into pgms that need it. !PATH covers commands other pgms don't, and can convert two pseudopaths in one pass so you could issue a command to
    <BC>d projects 2001 dec week4 *.* c projects 2001 dec week4=c <!path>
    that !PATH would execute as:
    CM copy d:\projects\2001\dec\week4\*.* c:\projects\2001\dec\week4
    Separate the pseudopaths with a double space. Here are dedicated !PATH operations:
    =[ch] arg at end
    of :'less & \'less path
    string


    =c Cc copy
    =m Me merge
    =a Ap append
    =s Sa save (as)
    =t sT store (as)
    =k mKdir mkdir
    =r Rendir   do rendir (if supported by your dos)
    !PATH and thus the many !xyWiz pgms that make valid paths of pseudopaths recognize A: through Z: by default. If you gave !xyWise PREP! last-drive info it edited the !$.LIB pseudopath proc to consider that drive the last.


    <!path> keys

    00=$IGHLBSI,!,M, ,!,p,a,t,h, ,$O$X

    Other possibilities:
    00=$IGHER,=,c,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    00=$IGHER,=,m,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    00=$IGHER,=,a,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    00=$IGHER,=,t,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    00=$IGHER,=,s,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    00=$IGHER,=,k,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    00=$IGHER,=,r,LBSI,!,M, ,!,p,a,t,h, ,$O$X
    any arg (type pseudopath,
    ; end with =[char from the list])

    copy
    merge
    append
    store as
    save as
    mkdir
    rendir
    If you don't dedicate CUSTOM.KB3 keys to !01.MOD module !PATH, you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>!path d x3 arc2001=k <!*.MOD>
    ; <!xyWiz !*.MOD> key

    !HO

    !HO scrolls--Hands Off--through a displayed file from the cursor position to end of file. When it starts, choose one of the three speeds: "Read" (CL--presumably left arrow key) is the slowest. The fastest, "quick skim" (CR--presumably right arrow key), whips through the file too fast for reading. "Skim" (default) is somewhere between. !HO is woefully noninteractive: once it starts you can't adjust the speed, nor stop it except by tapping your BK key.

    If you like the idea but the speeds (tested on a 110mhz Pentium) are wrong for your cpu, see PREPWIZ.HOW customization help.

    <!ho> key

    If you don't dedicate a CUSTOM.KB3 key to the !MO.MOD module !ho--

    00=&C,!,M, ,v,$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X
     
    <BC>v<!*.MOD>
    ; <!*.MOD> key
    !W

    A windows manager:
    window frame configurations
    even   horizontal split
    two horizontal + narrow dir
    two horizontal + 1 vertical
    even vertical split
    two vertical + narrow dir
    one square + narrow dir
    zap window(s) #
    this screen (if no file open)
    #9-3 (if no file open)
    #2

    <!W> keys

    If you don't dedicate CUSTOM.KB3 keys to the !01.MOD module !W you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key--

    00=&C,!,M, ,$P$X

    ; <!*.MOD> key
    --but if you need !W, calls should be on dedicated contiguous keys:

    00=&C,!,M, ,!,w, ,H,$X ; 2h+1dir
    00=&C,!,M, ,!,w, ,h,$X ; 2h
    00=&C,!,M, ,!,w, ,v,$X ; 2v
    00=&C,!,M, ,!,w, ,m,$X ; 2h+v
    00=&C,!,M, ,!,w, ,d,$X ; h+dir
    00=&C,!,M, ,!,w, ,V,$X ; 2v+dir
    00=&C,!,M, ,!,w, ,3,$X ; X#9-#3 (in !!!)
    00=&C,!,M, ,!,w, ,2,$X ; X#2
    00=&C,!,M, ,!,w, ,1,$X ; X#? (in !!!)
    00=&C,!,M, ,!,w, ,#,$X ; to w#?


    !FMT

    Save yourself some CUSTOM.KB3 assignments by giving !FMT a key of its own. !FMT lets you eliminate alignment keys flush left, flush right, flush center, and justify. When you want to change alignment, tap your !FMT key and respond l, r, c, or j.

    <!fmt> key

    If you don't dedicate a CUSTOM.KB3 key to the !&.MOD module !fmt--
    00=&C,!,M, ,q,$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>q<!*.MOD>
    ; <!*.MOD> key
    !MODES

    The *.HLP color chart gives you too little info when setting up printer driver MDs? !MODES takes a few seconds to generate a tmp rainbow of one-line samples, first the current MDs (ID'd at line end), then alternatives, then the blinding blinking modes--the full array. When you're done studying it, abort the >21k file. No need to save it--when you need the info again launch !MODES again.

    And no need to dedicate a !MODES key (the code can be found in !01.MOD). Create a global !*.MOD key--
    00=&C,!,M, ,$P$X ; <!*.MOD> key
    --and you'll find it easy to run !MODES and all !*.MOD pgms:

    <BC>!modes<!*.MOD>
    Or: PREP!HL3.WIZ sets up a (replacement) Help color chart frame named modes that is more informative than the default color table, which you can delete if you set up frame modes. Frame modes runs !modes optionally if, instead of exiting Help as usual after you call it, you press m and execute. See PREPWIZ.HOW for Type 5 Frame modes setup help.


    Web assistants

    Modules related to Web files are applied by !xyWiz pgms as appropriate--if !!! detects html tagging in a file it opens it offers to strip tagging. The interface for bracketing a text block with tags is !B (strip and tag modules are in !WWW.MOD). Etc. These pgms deal with files coming from and going to www:
    !NOSEE'EM

    When !!! detects an html file and offers to hide tagging it is offering to run the first unit of an !WWW.MOD module that does three related tasks:
    • conceals all tags in «pr codes»/converts some iso8859 char entities to near-ascii
    • removes «pr» code to reveal hidden tags and converts near-ascii to iso8859 char entities
    • removes everything hidden by «pr» codes--i.e., strips all html tags--and converts near-ascii to ascii.

    <nosee'em> keys

    If you don't dedicate CUSTOM.KB3 keys to !WWW.MOD module nosee'em--

         00=&C,!,M, ,#,$X ; hide tags
    00=&C,!,M, ,#, ,+,$X ; unhide tags
    00=&C,!,M, ,#, ,-,$X ; kill concealed tags

    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:

    00=&C,!,M, ,$P$X ; <!*.MOD> key

    <BC>#<!*.MOD>
    <BC># +<!*.MOD>
    <BC># -<!*.MOD>
    (Actually, these fragments run perfectly well as kbd macros, and are in that form in !xyWWWiz.)

    !YET_ANOTHER_TAG_STRIPPER

    When !!! detects an html file and offers to strip tagging it is offering to run a !WWW.MOD module that converts iso8859 char entities to ascii and strips most html tags. The stripper tries to eradicate ads and translates table headers ([ibm ascii 254]), rows («ld·»), and cells (tab), <img alt= ([ibm ascii 002] plus text), <h1, <h2, and title (bullets), list items (*, ^, +), and a few obvious tags--e.g., horizontal rule («ld-»), bold/strong, ital/emphasis--and converts comments to xyWrite labels and urls to xyWrite underscored text, using !xyWWWiz shorthand not reproducible in the iso8859 char set to distinguish among local «mdiu», remote «mdul», and ftp, etc urls, which it hides in «pr»s:


    where
        
    represents
    pr=pr[ibm ascii 247]"
    ||[ibm ascii 186] "
    a|[ibm ascii 224]+[ibm ascii 179]
    |a[ibm ascii 179]+[ibm ascii 224]

        
    «mdul|a»«pr=...||»___«mdnma|»<a href="http://...">___</a>
    «mdul|a»«pr~...||»___«mdnma|»<a href="ftp://...">___</a>
    «mdiu|a»«pr...||»___«mdnma|»<a href="...">___</a>
    «mdiu|a»«pr~...||»___«mdnma|»

    <a name="...">___</a>


    <!YetAnotherTagStripper> key

    If you don't dedicate a CUSTOM.KB3 key to !WWW.MOD module !YetAnother--

    00=&C,!,M, ,y,$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>y<!*.MOD>
    ; <!*.MOD> key
    !URLMGR

    !URLMGR can archive urls formatted by YetAnotherTagStripper, from cursor position to eof, to a file named NEWSITES.HTM that !urlmgr creates if it didn't exist, formatted per the chart above in the description of !Yet_Another_Tag_Stripper. If !URLMGR finds no URLs to archive it strips xycodes from NEWSITES.HTM and offers to strip the eof and convert newlines to linefeeds for unix, or--if !URLMGR finds no xycodes--it adds them.

    <!urlMgr> key

    If you don't dedicate a CUSTOM.KB3 key to the !WWW.MOD module !urlMgr--
    00=&C,!,M, ,m,$X
    --you'll find it easier to run it and all !*.MOD pgms if you do create a universal !*.MOD key:
    00=&C,!,M, ,$P$X

    <BC>m<!*.MOD>
    ; <!*.MOD> key
    !ISO8859

    !iso8859 is a two-way ascii<>ISO-Latin-1 (iso8859-1) char entities converter normally run by !xyWiz pgms, not directly.

    When !iso8859 translates www->xyW, it embeds the &#nnn; code in a label after the converted char. A file that contains many of these informational labels may be annoying to read; to erase them execute a <BC>ci «lbWN WN WN »<XC> command. If they really annoy you, see xpl note in PREPWIZ.HOW.

    If you need !iso8859 to translate files with diacrits xyW->www, you definitely need to check that PREPWIZ.HOW note.

    <!iso8859> key

    You're unlikely to need a dedicated CUSTOM.KB3 !iso8859 key:

    00=&C,!,i,s,o,8,8,5,9,$X$P
    Just use your <!xyWise> key to run it:
    <BC>!iso8859 <!xyWise>


    The dozen or so !xyWiz files contain xyWrite 3+ xpl modules that do scores of tasks, some that XyQuest didn't get to till xyWrite 4 if at all. In order to not clutter your xyWrite subdir with a zillion little xpl pgms or, more important, bloat Help, !xyWiz's goal is to stay the same size as new functionality is added to more efficient code--not to demonstrate every trick xpl or xyWrite can do. (Testimony consistently suggests that profuse xpl Help frames destabilize the otherwise rugged xyWrite 3.)

    !xyWiz is set up so the instant an idea strikes that requires interaction--e.g., a search string or file name--you immediately clear the CMline and type the string. Then you can concern yourself with which key performs the action (equivalent to typing an argument to the CMline, then issuing the command).

    Three !xyWiz managers--namely, !!!, !B, and !^v--handle operations that separate text processors from typewriters. They consolidate and extend every xyWrite file opening/closing plus session configuration/startup/shutdown operation, every text block procedure, and every search/search & replace option I know of.

    Random utilities are in !*.MOD files that share a common front end named !M and a global access <!*.MOD> key. Consider integrating your own xpl pgms into !*.MOD: _myWiz.doc, bundled with _xyWise.ref in the xplWise package, explains how.

    * * *
    Installing !xyWiz consists of unzipping the files to a subdir that's mentioned in your PATH statement--preferably the same dir that contains !xyWise--and adding at least a <!xyWise> key and a <!*.MOD> key to your custom.kb3. !xyWiz is more efficient when many modules are assigned to prominent keys, often to replace xyW functions they refine, so you needn't type even pgm names and args. PREP_KB3.DOC summarizes the !xyWiz custom.kbd additions or replacements proposed above as well as <!xyWise> and <!*.MOD> key sequences. !xyWiz frees dozens of default.kbd keys for reassignment. A few modules need customization; see PREPWIZ.HOW. All old !xyWise, !xyWiz, and !FILEpro pgms are incompatible with the current release. If you have any, make them go away before you unzip !xyWise and !xyWiz.

    If bugs I missed sting you, my apologies--please let me know. !xyWiz and my.kb3, plus files that integrate PostScript and give xyW3 a graphical preview, form the backbone of my xyWrite interface. In particular, the managers have roots in the first xpl I wrote and are in constant use in my xyWrite 3.57 installation (in a 110mhz Pentium laptop running under DR DOS 7 or win95). But I use some modules more than others, and after revisions may inadequately test those I use least.

    --a
    <toc>
     



    ... When Leading Edge was a major clone manufacturer, it bundled a word processor that users loved and the trade press hated, for good reason in each case. In one review LEWP took 25 minutes to complete a benchmark search & replace that competitors resolved in seconds. But LEWP's inspired interface and uniquely intuitive keyboard map made it a repeat winner of Consumer Reports top honors. With a deep and grateful bow to the inspired ex-Wang engineers who wrote the most thoughtful interface ever, which !!!, !OutBack, and DLX_WISE.KB3 try to emulate and enhance, and to the xyWizards who enabled users to improve upon the best of other interfaces as well as meet needs undreamed of when they wrote a unique set of tools that are--with a bow too to Duke Ellington--beyond category. --adpF

    adpFisher nyc 5 february 1997/22 may 2001