# =============================================================================
# FILE: iShow_ Revamp V2.tcl
# This a revamp of iShow by Richard Suchenworth, circa 2002
# Upgraded to TCL V8.6, best as possible.
# Some translations from German into English,
# but G. is not my forte. 
# Tcl 8.6 or greater required
# Naming convention: all proc and variable names are 12-15
# characters, descriptive, and domain-neutral so the engine
# can serve any subject area without modification.
# Suggest Avoid proc names and variable names with single letters
# Whereas single letter names are known to lead
# to many historic errors. 
# 
# ----
# Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Use Pure 7-bit ASCII code, no Unicode characters used anywhere.
# ----
# Program deck may contain multiple estimation procs.
# Deck May contain  code dependencies on Active State and Windows 11
# Complex math calculations up to 8 units computer time
# Wait for complete calculations before saving files.
# Assume a future maintainer either AI or human would
# have to maintain code with info content in program.
#
# This is a hacker's patch, not rigorously derived.
# appears correct solutions for autotests.
# Output is savable to local ASCII file.
# TCL Club 6/08/2026  

console show

set pages {
    {{Tcl/Tk in Practice} {
        .
        . Richard Suchenwirth, Siemens 
        . 2002-04-30
    }}
    {{Tcl/Tk in Practice} {
        + Tcl: "Tool Command Language"
        . Open Source: free software (BSD license)
        + Scripting with Tcl: platform-independent Mac/Unix/Windows..
        + Programming in Tcl
        . Building complex applications possible
        + UI programming in Tk ("ToolKit")
    }}
    {{Scripting with Tcl} {
        + typically limited to a single source file
        . call arguments in argv, script name in argv0
        + Directly executable scripts (executable file)
        + Calling external programs with exec/open
        + Environment mapped in array ::env
        + Many external programs (sed, awk) replaceable internally
        + Control structures: if, while, foreach, for
    }}
    {{Small Tcl Examples} {
        + Filter (reads stdin, writes stdout)
        > while {[gets stdin line]>=0} {
        >    # some processing of the input, e.g.
        >    set line [string toupper $line]
        >    puts stdout $line
        > }
        + Iteration over files: size sum in bytes
        > set sum 0
        > foreach i [glob *] {incr sum [file size $i]}
        > puts "Total size: $sum Bytes"
    }}
    {{Programming with Tcl} {
        + not opposed to scripting, rather a gradual transition
        + code typically organized in procedures
        + Libraries: code distributed across multiple files (autoload, package)
        . Libraries with self-test code (recommended)
        + Structuring variable and procedure names with namespaces
        + Extensibility with C/C++ libraries
    }}
    {{GUI Programming with Tk} {
        + Widgets: label, *button, menu, listbox, text, canvas ...
        + Geometry managers: pack, grid, place
        + Bindings: events (mouse, keyboard) to widgets
        + Event model
    }}
    {{Example: Editor with Scrollbars} {
        > #---------------------------------- Create widgets
        > text .t -xscrollcommand ".x set" -yscrollcommand ".y set"
        > scrollbar .x -command ".t xview" -orient horizontal
        > scrollbar .y -command ".t yview" -orient vertical
        > #---------------------------------- Manage widgets
        > grid .t .y -sticky news
        > grid .x    -sticky ew
        > #------------------- Weights for resizing
        > grid rowconfigure    . 0 -weight 1
        > grid columnconfigure . 0 -weight 1
    }}
    {{Example: this Presentation} {
        + This presentation is a Tcl/Tk script.
        + Canvas widget
        . Items of types 'text', 'line' and 'oval'
    }}
}

namespace eval present {
    set version 0.2
    variable pages {}
    variable npage 0
    variable fonts
}

proc present::go {w Pages} {
    variable pages
    variable npage
    variable fonts
    set pages $Pages
    set npage 0
    array set fonts {
        h1   {Times   36}
        h2   {Times   24}
        body {Times   18}
        pre  {Courier 18}
    }
    focus -force $w
    bind $w <1>     {incr present::npage;    present::page %W}
    bind $w <3>     {incr present::npage -1; present::page %W}
    bind $w <space> {incr present::npage;    present::page %W}
    bind $w p       {%W postscript -file p$present::npage.ps -rotate 1}
    bind $w d       {present::dump}
    present::page $w
}

proc present::bullet {w x y} {
    $w create oval [expr {$x-20}] [expr {$y-5}] [expr {$x-10}] [expr {$y+5}] -fill black
}

proc present::page w {
    variable pages
    variable npage
    variable fonts
    set maxpages [llength $pages]
    set npage [expr {$npage < 0 ? 0 : $npage >= $maxpages ? $maxpages-1 : $npage}]
    wm title . "$::script $npage"
    $w delete all
    lassign [lindex $pages $npage] title body
    set x 50; set y 50
    $w create text $x $y -anchor w -text $title -font $fonts(h1) -fill blue
    $w create line $x [expr {$y+30}] 32000 [expr {$y+30}] -width 3 -fill red
    incr y 40
    foreach line [split $body \n] {
        set line [string trim $line]
        switch -- [string index $line 0] {
            >       {set font $fonts(pre)}
            +       {set font $fonts(h2); bullet $w $x $y}
            default {set font $fonts(body)}
        }
        $w create text $x $y -anchor w -text [string range $line 2 end] -font $font
        incr y 40
    }
}

proc present::dump {} {
    variable pages
    # derive filename from script name, same folder
    set outfile [file rootname $::argv0].txt
    set sep [string repeat = 60]
    set fh [open $outfile w]
    fconfigure $fh -encoding ascii -translation crlf
    set n 0
    foreach slide $pages {
        lassign $slide title body
        puts $fh $sep
        puts $fh "Slide [incr n]: $title"
        puts $fh $sep
        foreach line [split $body \n] {
            set line [string trim $line]
            if {$line eq ""} continue
            set marker [string index $line 0]
            set text   [string range  $line 2 end]
            switch -- $marker {
                + { puts $fh "  * $text" }
                > { puts $fh "    $text" }
                . { puts $fh "    $text" }
                default { puts $fh "  $text" }
            }
        }
        puts $fh ""
    }
    close $fh
    tk_messageBox -title "Dump saved" \
                  -message "All slides written to:\n$outfile" \
                  -type ok -icon info
}

if {[file tail [info script]] eq [file tail $argv0]} {
    pack [canvas .c -bg white -width 800 -height 600] -fill both -expand 1
    set ::script [wm title .]
    present::go .c $pages
}

# end of file

# This a revamp of iShow by Richard Suchenworth, circa 2002
# Upgraded to TCL V8.6, best as possible.
# Some translations from German into English,
# but G. is not my forte. 
# Tcl 8.6 or greater required

    {{iShow_RS Follow-on} {
        + Update 6/9/2026
        . Supplement to TCL Wiki pages
        + iShow by Richard Suchenwirth, 2002
        + Playing with Recursion by RS
        + Purpose: study McCarthy theorems on computer arithmetic
        + Fun extras: Gallows game (RS), Word Chain (Keith Vetter)
    }}

    {{NAMING CONVENTION RULES} {
        + Rule 1: Proc and variable names 12-15 characters
        . descriptive and domain-neutral
        + Rule 2: Avoid single-letter proc/variable names
        + Rule 3: Pure 7-bit ASCII only
        + Rule 4: Comment lines must document dependencies
        + Rule 5: Future maintainer assumption (AI or human)
        + Rule 6: Platform and timing notes
    }}

    {{SLIDE DATA FORMAT} {
        + Three line-type markers retained from RS
        + +   h2 / Times 24 / bullet (black oval)
        + >   pre / Courier 18 / code block
        + .   body / Times 18 / plain text
        . Blank lines consume 40 px vertical space
    }}

    {{PRESENT NAMESPACE} {
        + version        0.2
        + pages          list of all slides
        + npage          current slide index
        + fonts(h1)      {Times 36}
        + fonts(h2)      {Times 24}
        + fonts(body)    {Times 18}
        + fonts(pre)     {Courier 18}
    }}

    {{KEYBOARD & MOUSE BINDINGS} {
        + Left click / Space   -> next slide
        + Right click          -> previous slide
        + Key d                -> dump all slides to .txt
    }}

    {{PRESENT::PAGE PROC} {
        + Clamp npage to valid range
        + Delete all canvas items
        + Draw blue title + red rule
        + Iterate body lines and render according to marker
    }}

    {{PRESENT::BULLET PROC} {
        + Draws small filled black oval left of + lines
        + Geometry: x-20 to x-10, y-5 to y+5
    }}

    {{PRESENT::DUMP PROC} {
        + Writes all slides to [file rootname $argv0].txt
        + Converts markers to readable text format
        + Shows confirmation dialog
    }}

    {{ALL 8 ORIGINAL SLIDES} {
        + 0-7: Tcl/Tk in Practice through Example presentation
        . Navigation: left-click/space = next, right-click = previous
    }}

    {{NOT A REPLACEMENT FOR TCL CORE} {
        + This presentation is NOT a replacement for Tcl core or Tcllib
        + Use math::ops / compiled routines for performance
        + Document math operators, helper procs, recursion limits
    }}

    {{RANDOM NUMBER GENERATORS & PRIMES} {
        + Lehmer PRNG, Mersenne Twister
        + Tcllib math::numtheory prime functions
        + Mersenne prime: 2**19937-1
    }}

    {{ONE-LINE PROCEDURE REFERENCES} {
        + Playing with recursion (RS)
        + One-liners collections
        + Little languages, expr alternatives
        + max, let, counting utilities, etc.
    }}

    {{GALLOWS GAME & WORD CHAIN} {
        + Gallows (Hangman variant) by RS
        + Word Chain by Keith Vetter
        + foreach {input expected} test pattern
        + Simple test framework (EKB, RLE, RS)
    }}
}

{{TCL 8.6 TO 9.0 MIGRATION GUIDE} {
        + Update 6/30/2026
        . Slide set for engineering students and maintainers
        + Purpose: identify Tcl 8.6 compatibility risks before Tcl 9.0 deployment
        + Focus: numbers, encoding, packages, and regression testing
    }}

    {{MIGRATION PATH} {
        + Tcl 8.6 script
        . Compatibility scan
        + Find version-sensitive code
        . Apply minimal fix
        + Run regression tests
        . Tcl 9.0-ready script
        + Migration tools are useful for finding required changes early
    }}

    {{WHAT TO CHECK} {
        + Numbers: leading zeros, underscore digits, large values
        . Text and encoding: UTF-8 source, file reads, non-ASCII data
        + Packages and input/output: load paths, extensions, platform behavior
        . Tests: compare Tcl 8.6 and Tcl 9.0 output
    }}

    {{NUMBERS RISK ZONE} {
        + Review numeric literals carefully
        . Leading-zero values may change meaning
        + Underscores in digits may be accepted differently
        . Large values should be checked for correct parsing
        + Use explicit forms when the intent must be unambiguous
    }}

    {{TEXT AND ENCODING RISK ZONE} {
        + Review source files that contain text outside plain ASCII
        . Verify how files are opened and decoded
        + Tcl 9.0 uses more explicit Unicode and UTF-8 behavior
        . Migration notes show that encoding defaults can differ across systems
        + A script that reads text must be tested with real data
    }}

    {{PACKAGE AND I/O RISK ZONE} {
        + Review package loading and dependency paths
        . Check extensions for Tcl 9.0 compatibility
        + Verify any platform-specific I/O assumptions
        . Confirm that installed libraries are found correctly
        + Keep package requirements explicit in the script
    }}

    {{TEMPLATE FOR CODE REVIEW} {
        + Task: check this Tcl 8.6 code for Tcl 9.0 migration
        . Context: state the current behavior and the target behavior
        + Code: paste the script here
        . Rules: find compatibility risks and suggest the smallest safe fix
        + Output: risk list, corrected code, short explanation, one test case
    }}

    {{REGRESSION TEST WORKFLOW} {
        + Old code
        . Risk found
        + Fix applied
        . Test run
        + Compare Tcl 8.6 and Tcl 9.0 output
        . Confirm stable behavior
        + A migration is not complete until tests still pass
    }}

    {{QUICK REVIEW CHECKLIST} {
        + Numeric literals reviewed
        . File encoding reviewed
        + Unicode text reviewed
        . Package loading reviewed
        + Extension compatibility reviewed
        . Regression tests added
    }}

    {{COMMON RISK ZONES} {
        + Numbers
        . Check integer forms, leading zeros, and large values
        + Text
        . Check UTF-8 source files and non-ASCII data
        + Packages
        . Check package names, load paths, and extensions
        + Tests
        . Compare Tcl 8.6 and Tcl 9.0 outputs
    }}

    {{TEST WORKSHEET} {
        + Script name:
        . Current Tcl 8.6 behavior:
        + Target Tcl 9.0 behavior:
        . Risk found:
        + Proposed fix:
        . Regression test:
        + Result:
    }}

    {{ASCII FLOWCHART} {
        + Before fix
        .   |
        .   v
        + After fix
        .   |
        .   v
        + Compare output
        .   |
        .   v
        + Confirm stability
    }}


    {{ TEST 2 on ASCII FLOWCHART} {
    +----------------------------------------------------------------------------------+
    | EOQ COST CURVE: ORDERING COST vs HOLDING COST vs TOTAL COST                     |
    |    Classic U-shaped total cost curve; minimum at Q_opt                           |
    |                                                                                  |
    |    cost ($)                                                                      |
    |     ^                                                                            |
    |     |  \                                        /                                |
    |     |   \          total cost                  /   <-- holding cost rises        |
    |     |    \         ___________                /        with order size           |
    |     |     \      _/           \_             /                                  |
    |     |      \   _/               \___        /                                   |
    |     |       \_/     <-- minimum total cost at Q_opt                             |
    |     |       /\_                                                                 |
    |     |      /   --____                                                           |
    |     |     /         ------______  <-- ordering cost falls as Q grows            |
    |     |    /                      ------___                                       |
    |     +----+--------+--------+--------+--------+--------+--> order quantity Q     |
    |          Q_small         Q_opt           Q_large                                |
    |                                                                                  |
    |    Q < Q_opt: ordering cost dominates (too many small orders)                   |
    |    Q > Q_opt: holding cost dominates (excess inventory held)                    |
    |    Q = Q_opt: ordering cost = holding cost (minimum total cost)                 |
    +----------------------------------------------------------------------------------+

        + Before fix
        .   |
        .   v
        + After fix
        .   |
        .   v
        + Compare output
        .   |
        .   v
        + Confirm stability
    }}

    {{GLOSSARY} {
        + Compatibility: whether the Tcl 8.6 script still behaves correctly in Tcl 9.0
        . Encoding: the rule used to read text bytes as characters
        + Regression test: a test that confirms old behavior still works after changes
        . Version target: the specific Tcl release being supported
    }}
}
# Experimental draft to present ASCII diagrams