home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / tcl / xf2.3-p / xf2 / xf2.3 / src / xffsBox.tcl < prev    next >
Encoding:
Text File  |  1994-05-22  |  32.0 KB  |  975 lines
  1. # XFNoParsing
  2. # Program: template
  3. # Description: file selector box
  4. #
  5. # $Header: xffsBox.tcl[2.3] Wed Mar 10 12:05:54 1993 garfield@garfield frozen $
  6.  
  7. global xfFSBox
  8. set xfFSBox(activeBackground) ""
  9. set xfFSBox(activeForeground) ""
  10. set xfFSBox(background) ""
  11. set xfFSBox(font) ""
  12. set xfFSBox(foreground) ""
  13. set xfFSBox(scrollActiveForeground) ""
  14. set xfFSBox(scrollBackground) ""
  15. set xfFSBox(scrollForeground) ""
  16. set xfFSBox(showPixmap) 0
  17. set xfFSBox(name) ""
  18. set xfFSBox(path) [pwd]
  19. set xfFSBox(pattern) *
  20. set xfFSBox(all) 0
  21. set xfFSBox(button) 0
  22. set xfFSBox(extensions) 0
  23. set xfFSBox(internalPath) [pwd]
  24.  
  25. proc XFFSBox {{xfFSBoxMessage "Select file:"} {xfFSBoxFileName ""} {xfFSBoxActionOk ""} {xfFSBoxActionCancel ""}} {# xf ignore me 5
  26. ##########
  27. # Procedure: XFFSBox
  28. # Description: show file selector box
  29. # Arguments: xfFSBoxMessage - the text to display
  30. #            xfFSBoxFileName - a file name that should be selected
  31. #            xfFSBoxActionOk - the action that should be performed on ok
  32. #            xfFSBoxActionCancel - the action that should be performed on cancel
  33. # Returns: the filename that was selected, or nothing
  34. # Sideeffects: none
  35. ##########
  36. # 
  37. # global xfFSBox(activeBackground) - active background color
  38. # global xfFSBox(activeForeground) - active foreground color
  39. # global xfFSBox(background) - background color
  40. # global xfFSBox(font) - text font
  41. # global xfFSBox(foreground) - foreground color
  42. # global xfFSBox(extensions) - scan directory for extensions
  43. # global xfFSBox(scrollActiveForeground) - scrollbar active background color
  44. # global xfFSBox(scrollBackground) - scrollbar background color
  45. # global xfFSBox(scrollForeground) - scrollbar foreground color
  46. # global xfFSBox(scrollSide) - side where scrollbar is located
  47.  
  48.   global xfFSBox
  49.  
  50.   set tmpButtonOpt ""
  51.   set tmpFrameOpt ""
  52.   set tmpMessageOpt ""
  53.   set tmpScaleOpt ""
  54.   set tmpScrollOpt ""
  55.   if {"$xfFSBox(activeBackground)" != ""} {
  56.     append tmpButtonOpt "-activebackground \"$xfFSBox(activeBackground)\" "
  57.   }
  58.   if {"$xfFSBox(activeForeground)" != ""} {
  59.     append tmpButtonOpt "-activeforeground \"$xfFSBox(activeForeground)\" "
  60.   }
  61.   if {"$xfFSBox(background)" != ""} {
  62.     append tmpButtonOpt "-background \"$xfFSBox(background)\" "
  63.     append tmpFrameOpt "-background \"$xfFSBox(background)\" "
  64.     append tmpMessageOpt "-background \"$xfFSBox(background)\" "
  65.   }
  66.   if {"$xfFSBox(font)" != ""} {
  67.     append tmpButtonOpt "-font \"$xfFSBox(font)\" "
  68.     append tmpMessageOpt "-font \"$xfFSBox(font)\" "
  69.   }
  70.   if {"$xfFSBox(foreground)" != ""} {
  71.     append tmpButtonOpt "-foreground \"$xfFSBox(foreground)\" "
  72.     append tmpMessageOpt "-foreground \"$xfFSBox(foreground)\" "
  73.   }
  74.   if {"$xfFSBox(scrollActiveForeground)" != ""} {
  75.     append tmpScrollOpt "-activeforeground \"$xfFSBox(scrollActiveForeground)\" "
  76.   }
  77.   if {"$xfFSBox(scrollBackground)" != ""} {
  78.     append tmpScrollOpt "-background \"$xfFSBox(scrollBackground)\" "
  79.   }
  80.   if {"$xfFSBox(scrollForeground)" != ""} {
  81.     append tmpScrollOpt "-foreground \"$xfFSBox(scrollForeground)\" "
  82.   }
  83.  
  84.   if {[file exists [file tail $xfFSBoxFileName]] &&
  85.       [XFIsAFile [file tail $xfFSBoxFileName]]} {
  86.     set xfFSBox(name) [file tail $xfFSBoxFileName]
  87.   } {
  88.     set xfFSBox(name) ""
  89.   }
  90.   if {[file exists $xfFSBoxFileName] && [XFIsADir $xfFSBoxFileName]} {
  91.     set xfFSBox(path) $xfFSBoxFileName
  92.   } {
  93.     if {"[file dirname $xfFSBoxFileName]" != "."} {
  94.       set xfFSBox(path) [file dirname $xfFSBoxFileName]
  95.     }
  96.   }
  97.   if {$xfFSBox(showPixmap)} {
  98.     set xfFSBox(path) [string trimleft $xfFSBox(path) @]
  99.   }
  100.   if {"$xfFSBox(path)" != "" && [file exists $xfFSBox(path)] &&
  101.       [XFIsADir $xfFSBox(path)]} {
  102.     set xfFSBox(internalPath) $xfFSBox(path)
  103.   } {
  104.     if {"$xfFSBox(internalPath)" == "" ||
  105.         ![file exists $xfFSBox(internalPath)]} {
  106.       set xfFSBox(internalPath) [pwd]
  107.     }
  108.   }
  109.   # build widget structure
  110.  
  111.   XFTmpltToplevel .xfFSBox 350x300 {XF file select}
  112.  
  113.   label .xfFSBox.message1 \
  114.     -anchor c \
  115.     -relief raised \
  116.     -text "$xfFSBoxMessage"
  117.   catch ".xfFSBox.message1 config $tmpMessageOpt"
  118.  
  119.   frame .xfFSBox.frame1 \
  120.     -borderwidth 0 \
  121.     -relief raised
  122.   catch ".xfFSBox.frame1 config $tmpFrameOpt"
  123.  
  124.   button .xfFSBox.frame1.ok \
  125.     -text "OK" \
  126.     -command "
  127.       global xfFSBox
  128.       set xfFSBox(name) \[.xfFSBox.file.file get\]
  129.       if {$xfFSBox(showPixmap)} {
  130.         set xfFSBox(path) @\[.xfFSBox.path.path get\]
  131.       } {
  132.         set xfFSBox(path) \[.xfFSBox.path.path get\]
  133.       }
  134.       set xfFSBox(internalPath) \[.xfFSBox.path.path get\]
  135.       $xfFSBoxActionOk
  136.       if {\"\[info commands XFDestroy\]\" != \"\"} {
  137.         catch {XFDestroy .xfFSBox}
  138.       } {
  139.         catch {destroy .xfFSBox}
  140.       }"
  141.   catch ".xfFSBox.frame1.ok config $tmpButtonOpt"
  142.  
  143.   button .xfFSBox.frame1.rescan \
  144.     -text "Rescan" \
  145.     -command {
  146.       global xfFSBox
  147.       XFFSBoxFSShow [.xfFSBox.path.path get] \
  148.         [.xfFSBox.pattern.pattern get] $xfFSBox(all)}
  149.   catch ".xfFSBox.frame1.rescan config $tmpButtonOpt"
  150.  
  151.   button .xfFSBox.frame1.cancel \
  152.     -text "Cancel" \
  153.     -command "
  154.       global xfFSBox
  155.       set xfFSBox(name) {}
  156.       set xfFSBox(path) {}
  157.       $xfFSBoxActionCancel
  158.       if {\"\[info commands XFDestroy\]\" != \"\"} {
  159.         catch {XFDestroy .xfFSBox}
  160.       } {
  161.         catch {destroy .xfFSBox}
  162.       }"
  163.   catch ".xfFSBox.frame1.cancel config $tmpButtonOpt"
  164.  
  165.   if {$xfFSBox(showPixmap)} {
  166.     frame .xfFSBox.frame2 \
  167.       -borderwidth 0 \
  168.       -relief raised
  169.     catch ".xfFSBox.frame2 config $tmpFrameOpt"
  170.  
  171.     scrollbar .xfFSBox.frame2.scrollbar3 \
  172.       -command {.xfFSBox.frame2.canvas2 xview} \
  173.       -orient {horizontal} \
  174.       -relief {raised}
  175.     catch ".xfFSBox.frame2.scrollbar3 config $tmpScrollOpt"
  176.  
  177.     scrollbar .xfFSBox.frame2.scrollbar1 \
  178.       -command {.xfFSBox.frame2.canvas2 yview} \
  179.       -relief {raised}
  180.     catch ".xfFSBox.frame2.scrollbar1 config $tmpScrollOpt"
  181.  
  182.     canvas .xfFSBox.frame2.canvas2 \
  183.       -confine {true} \
  184.       -relief {raised} \
  185.       -scrollregion {0c 0c 20c 20c} \
  186.       -width {100} \
  187.       -xscrollcommand {.xfFSBox.frame2.scrollbar3 set} \
  188.       -yscrollcommand {.xfFSBox.frame2.scrollbar1 set}
  189.     catch ".xfFSBox.frame2.canvas2 config $tmpFrameOpt"
  190.  
  191.     .xfFSBox.frame2.canvas2 addtag currentBitmap withtag [.xfFSBox.frame2.canvas2 create bitmap 5 5 -anchor nw]
  192.   }
  193.  
  194.   frame .xfFSBox.path \
  195.     -borderwidth 0 \
  196.     -relief raised
  197.   catch ".xfFSBox.path config $tmpFrameOpt"
  198.  
  199.   frame .xfFSBox.path.paths \
  200.     -borderwidth 2 \
  201.     -relief raised
  202.   catch ".xfFSBox.path.paths config $tmpFrameOpt"
  203.  
  204.   menubutton .xfFSBox.path.paths.paths \
  205.     -borderwidth 0 \
  206.     -menu ".xfFSBox.path.paths.paths.menu" \
  207.     -relief flat \
  208.     -text "Pathname:"
  209.   catch ".xfFSBox.path.paths.paths config $tmpButtonOpt"
  210.  
  211.   menu .xfFSBox.path.paths.paths.menu
  212.   catch ".xfFSBox.path.paths.paths.menu config $tmpButtonOpt"
  213.  
  214.   .xfFSBox.path.paths.paths.menu add command \
  215.      -label "[string trimright $xfFSBox(internalPath) {/@}]" \
  216.      -command "
  217.        global xfFSBox
  218.        XFFSBoxFSShow \[.xfFSBox.path.path get\] \
  219.          \[.xfFSBox.pattern.pattern get\] \$xfFSBox(all)
  220.        .xfFSBox.path.path delete 0 end
  221.        .xfFSBox.path.path insert 0 [string trimright $xfFSBox(internalPath) {/@}]"
  222.  
  223.   entry .xfFSBox.path.path \
  224.     -relief raised
  225.   catch ".xfFSBox.path.path config $tmpMessageOpt"
  226.  
  227.   if {![XFIsADir $xfFSBox(internalPath)]} {
  228.     set $xfFSBox(internalPath) [pwd]
  229.   }
  230.   .xfFSBox.path.path insert 0 $xfFSBox(internalPath)
  231.  
  232.   frame .xfFSBox.pattern \
  233.     -borderwidth 0 \
  234.     -relief raised
  235.   catch ".xfFSBox.pattern config $tmpFrameOpt"
  236.  
  237.   frame .xfFSBox.pattern.patterns \
  238.     -borderwidth 2 \
  239.     -relief raised
  240.   catch ".xfFSBox.pattern.patterns config $tmpFrameOpt"
  241.  
  242.   menubutton .xfFSBox.pattern.patterns.patterns \
  243.     -borderwidth 0 \
  244.     -menu ".xfFSBox.pattern.patterns.patterns.menu" \
  245.     -relief flat \
  246.     -text "Selection pattern:"
  247.   catch ".xfFSBox.pattern.patterns.patterns config $tmpButtonOpt"
  248.  
  249.   menu .xfFSBox.pattern.patterns.patterns.menu
  250.   catch ".xfFSBox.pattern.patterns.patterns.menu config $tmpButtonOpt"
  251.  
  252.   .xfFSBox.pattern.patterns.patterns.menu add checkbutton \
  253.     -label "Scan extensions" \
  254.     -variable xfFSBox(extensions) \
  255.     -command {
  256.       global xfFSBox
  257.       XFFSBoxFSShow [.xfFSBox.path.path get] \
  258.         [.xfFSBox.pattern.pattern get] $xfFSBox(all)}
  259.  
  260.   entry .xfFSBox.pattern.pattern \
  261.     -relief raised
  262.   catch ".xfFSBox.pattern.pattern config $tmpMessageOpt"
  263.  
  264.   .xfFSBox.pattern.pattern insert 0 $xfFSBox(pattern)
  265.   
  266.   frame .xfFSBox.files \
  267.     -borderwidth 0 \
  268.     -relief raised
  269.   catch ".xfFSBox.files config $tmpFrameOpt"
  270.  
  271.   scrollbar .xfFSBox.files.vscroll \
  272.     -relief raised \
  273.     -command ".xfFSBox.files.files yview"
  274.   catch ".xfFSBox.files.vscroll config $tmpScrollOpt"
  275.  
  276.   scrollbar .xfFSBox.files.hscroll \
  277.     -orient horiz \
  278.     -relief raised \
  279.     -command ".xfFSBox.files.files xview"
  280.   catch ".xfFSBox.files.hscroll config $tmpScrollOpt"
  281.  
  282.   listbox .xfFSBox.files.files \
  283.     -exportselection false \
  284.     -relief raised \
  285.     -xscrollcommand ".xfFSBox.files.hscroll set" \
  286.     -yscrollcommand ".xfFSBox.files.vscroll set"
  287.   catch ".xfFSBox.files.files config $tmpMessageOpt"
  288.  
  289.   frame .xfFSBox.file \
  290.     -borderwidth 0 \
  291.     -relief raised
  292.   catch ".xfFSBox.file config $tmpFrameOpt"
  293.  
  294.   label .xfFSBox.file.labelfile \
  295.     -relief raised \
  296.     -text "Filename:"
  297.   catch ".xfFSBox.file.labelfile config $tmpMessageOpt"
  298.  
  299.   entry .xfFSBox.file.file \
  300.     -relief raised
  301.   catch ".xfFSBox.file.file config $tmpMessageOpt"
  302.  
  303.   .xfFSBox.file.file delete 0 end
  304.   .xfFSBox.file.file insert 0 $xfFSBox(name)
  305.   
  306.   checkbutton .xfFSBox.pattern.all \
  307.     -offvalue 0 \
  308.     -onvalue 1 \
  309.     -text "Show all files" \
  310.     -variable xfFSBox(all) \
  311.     -command {
  312.       global xfFSBox
  313.       XFFSBoxFSShow [.xfFSBox.path.path get] \
  314.         [.xfFSBox.pattern.pattern get] $xfFSBox(all)}
  315.   catch ".xfFSBox.pattern.all config $tmpButtonOpt"
  316.  
  317.   XFFSBoxFSShow $xfFSBox(internalPath) $xfFSBox(pattern) $xfFSBox(all)
  318.  
  319.   # bindings
  320.   bind .xfFSBox.files.files <Double-Button-1> "
  321.     XFFSBoxFSFileSelectDouble %W $xfFSBox(showPixmap) \{$xfFSBoxActionOk\} %y"
  322.   bind .xfFSBox.files.files <ButtonPress-1> "
  323.     XFFSBoxFSFileSelect %W $xfFSBox(showPixmap) %y"
  324.   bind .xfFSBox.files.files <Button1-Motion> "
  325.     XFFSBoxFSFileSelect %W $xfFSBox(showPixmap) %y"
  326.   bind .xfFSBox.files.files <Shift-Button1-Motion> "
  327.     XFFSBoxFSFileSelect %W $xfFSBox(showPixmap) %y"
  328.   bind .xfFSBox.files.files <Shift-ButtonPress-1> "
  329.     XFFSBoxFSFileSelect %W $xfFSBox(showPixmap) %y"
  330.  
  331.   bind .xfFSBox.path.path <Tab> {
  332.     XFFSBoxFSNameComplete path}
  333.   bind .xfFSBox.path.path <Return> {
  334.     global tkVersion
  335.     global xfFSBox
  336.     XFFSBoxFSShow [.xfFSBox.path.path get] \
  337.       [.xfFSBox.pattern.pattern get] $xfFSBox(all)
  338.     XFFSBoxFSInsertPath
  339.     if {$tkVersion >= 3.0} {
  340.       .xfFSBox.file.file icursor end
  341.     } {
  342.       .xfFSBox.file.file cursor end
  343.     }
  344.     focus .xfFSBox.file.file}
  345.   catch "bind .xfFSBox.path.path <Up> {}"
  346.   bind .xfFSBox.path.path <Down> {
  347.     global tkVersion
  348.     if {$tkVersion >= 3.0} {
  349.       .xfFSBox.file.file icursor end
  350.     } {
  351.       .xfFSBox.file.file cursor end
  352.     }
  353.     focus .xfFSBox.file.file}
  354.  
  355.   bind .xfFSBox.file.file <Tab> {
  356.     XFFSBoxFSNameComplete file}
  357.   bind .xfFSBox.file.file <Return> "
  358.     global xfFSBox
  359.     set xfFSBox(name) \[.xfFSBox.file.file get\]
  360.     if {$xfFSBox(showPixmap)} {
  361.       set xfFSBox(path) @\[.xfFSBox.path.path get\]
  362.     } {
  363.       set xfFSBox(path) \[.xfFSBox.path.path get\]
  364.     }
  365.     set xfFSBox(internalPath) \[.xfFSBox.path.path get\]
  366.     $xfFSBoxActionOk
  367.     if {\"\[info commands XFDestroy\]\" != \"\"} {
  368.       catch {XFDestroy .xfFSBox}
  369.     } {
  370.       catch {destroy .xfFSBox}
  371.     }"
  372.   bind .xfFSBox.file.file <Up> {
  373.     global tkVersion
  374.     if {$tkVersion >= 3.0} {
  375.       .xfFSBox.path.path icursor end
  376.     } {
  377.       .xfFSBox.path.path cursor end
  378.     }
  379.     focus .xfFSBox.path.path}
  380.   bind .xfFSBox.file.file <Down> {
  381.     global tkVersion
  382.     if {$tkVersion >= 3.0} {
  383.       .xfFSBox.pattern.pattern icursor end
  384.     } {
  385.       .xfFSBox.pattern.pattern cursor end
  386.     }
  387.     focus .xfFSBox.pattern.pattern}
  388.  
  389.   bind .xfFSBox.pattern.pattern <Return> {
  390.     global xfFSBox
  391.     XFFSBoxFSShow [.xfFSBox.path.path get] \
  392.       [.xfFSBox.pattern.pattern get] $xfFSBox(all)}
  393.   bind .xfFSBox.pattern.pattern <Up> {
  394.     global tkVersion
  395.     if {$tkVersion >= 3.0} {
  396.       .xfFSBox.file.file icursor end
  397.     } {
  398.       .xfFSBox.file.file cursor end
  399.     }
  400.     focus .xfFSBox.file.file}
  401.   catch "bind .xfFSBox.pattern.pattern <Down> {}"
  402.  
  403.   # packing
  404.   pack append .xfFSBox.files \
  405.               .xfFSBox.files.vscroll "$xfFSBox(scrollSide) filly" \
  406.               .xfFSBox.files.hscroll {bottom fillx} \
  407.               .xfFSBox.files.files {left fill expand}
  408.   pack append .xfFSBox.file \
  409.               .xfFSBox.file.labelfile {left} \
  410.               .xfFSBox.file.file {left fill expand}
  411.   pack append .xfFSBox.frame1 \
  412.               .xfFSBox.frame1.ok {left fill expand} \
  413.               .xfFSBox.frame1.rescan {left fill expand} \
  414.               .xfFSBox.frame1.cancel {left fill expand}
  415.   pack append .xfFSBox.path.paths \
  416.               .xfFSBox.path.paths.paths {left}
  417.   pack append .xfFSBox.pattern.patterns \
  418.               .xfFSBox.pattern.patterns.patterns {left}
  419.   pack append .xfFSBox.path \
  420.               .xfFSBox.path.paths {left} \
  421.               .xfFSBox.path.path {left fill expand}
  422.   pack append .xfFSBox.pattern \
  423.               .xfFSBox.pattern.patterns {left} \
  424.               .xfFSBox.pattern.all {right fill} \
  425.               .xfFSBox.pattern.pattern {left fill expand}
  426.   if {$xfFSBox(showPixmap)} {
  427.     pack append .xfFSBox.frame2 \
  428.                 .xfFSBox.frame2.scrollbar1 {left filly} \
  429.                 .xfFSBox.frame2.canvas2 {top expand fill} \
  430.                 .xfFSBox.frame2.scrollbar3 {top fillx} 
  431.  
  432.     pack append .xfFSBox \
  433.                 .xfFSBox.message1 {top fill} \
  434.                 .xfFSBox.frame1 {bottom fill} \
  435.                 .xfFSBox.pattern {bottom fill} \
  436.                 .xfFSBox.file {bottom fill} \
  437.                 .xfFSBox.path {bottom fill} \
  438.                 .xfFSBox.frame2 {right fill} \
  439.                 .xfFSBox.files {left fill expand}
  440.   } {
  441.     pack append .xfFSBox \
  442.                 .xfFSBox.message1 {top fill} \
  443.                 .xfFSBox.frame1 {bottom fill} \
  444.                 .xfFSBox.pattern {bottom fill} \
  445.                 .xfFSBox.file {bottom fill} \
  446.                 .xfFSBox.path {bottom fill} \
  447.                 .xfFSBox.files {left fill expand}
  448.   }
  449.  
  450.   if {"$xfFSBoxActionOk" == "" && "$xfFSBoxActionCancel" == ""} {
  451.     # wait for the box to be destroyed
  452.     update idletask
  453.     grab .xfFSBox
  454.     tkwait window .xfFSBox
  455.  
  456.     if {"[string trim $xfFSBox(path)]" != "" ||
  457.         "[string trim $xfFSBox(name)]" != ""} {
  458.       if {"[string trimleft [string trim $xfFSBox(name)] /]" == ""} {
  459.         return [string trimright [string trim $xfFSBox(path)] /]
  460.       } {
  461.         return [string trimright [string trim $xfFSBox(path)] /]/[string trimleft [string trim $xfFSBox(name)] /]
  462.       }
  463.     }
  464.   }
  465. }
  466.  
  467. ##########
  468. # Procedure: XFFSBoxFSFileSelect
  469. # Description: select file name
  470. # Arguments: xfFSBoxW - the widget
  471. #            xfFSBoxShowPixmap - show pixmaps
  472. #            xfFSBoxY - the y position in the listbox
  473. # Returns: none
  474. # Sideeffects: none
  475. ##########
  476. proc XFFSBoxFSFileSelect {xfFSBoxW xfFSBoxShowPixmap xfFSBoxY} {# xf ignore me 6
  477.   global xfFSBox
  478.  
  479.   XFFSBoxBindSelectOne $xfFSBoxW $xfFSBoxY
  480.   set xfFSBoxNearest [$xfFSBoxW nearest $xfFSBoxY]
  481.   if {$xfFSBoxNearest >= 0} {
  482.     set xfFSBoxTmpEntry [$xfFSBoxW get $xfFSBoxNearest]
  483.     if {"[string index $xfFSBoxTmpEntry \
  484.           [expr [string length $xfFSBoxTmpEntry]-1]]" == "/" ||
  485.         "[string index $xfFSBoxTmpEntry \
  486.           [expr [string length $xfFSBoxTmpEntry]-1]]" == "@"} {
  487.       set xfFSBoxFileName [string range $xfFSBoxTmpEntry 0 \
  488.             [expr [string length $xfFSBoxTmpEntry]-2]]
  489.       if {![XFIsADir [string trimright $xfFSBox(internalPath)/$xfFSBoxFileName @]] &&
  490.           ![XFIsASymlink [string trimright $xfFSBox(internalPath)/$xfFSBoxFileName @]]} {
  491.         set xfFSBoxFileName $xfFSBoxTmpEntry
  492.       }
  493.     } {
  494.       if {"[string index $xfFSBoxTmpEntry \
  495.             [expr [string length $xfFSBoxTmpEntry]-1]]" == "*"} {
  496.         set xfFSBoxFileName [string range $xfFSBoxTmpEntry 0 \
  497.           [expr [string length $xfFSBoxTmpEntry]-2]]
  498.         if {![file executable $xfFSBox(internalPath)/$xfFSBoxFileName]} {
  499.           set xfFSBoxFileName $xfFSBoxTmpEntry
  500.         }
  501.       } {
  502.         set xfFSBoxFileName $xfFSBoxTmpEntry
  503.       }
  504.     }
  505.     if {![XFIsADir [string trimright $xfFSBox(internalPath)/$xfFSBoxFileName @]]} {
  506.       set xfFSBox(name) $xfFSBoxFileName
  507.       .xfFSBox.file.file delete 0 end
  508.       .xfFSBox.file.file insert 0 $xfFSBox(name)
  509.       if {$xfFSBoxShowPixmap} {
  510.         catch ".xfFSBox.frame2.canvas2 itemconfigure currentBitmap -bitmap \"@$xfFSBox(internalPath)/$xfFSBox(name)\""
  511.       }
  512.     }
  513.   }
  514. }
  515.  
  516. ##########
  517. # Procedure: XFFSBoxFSFileSelectDouble
  518. # Description: select file when double clicked
  519. # Arguments: xfFSBoxW - the widget
  520. #            xfFSBoxShowPixmap - show pixmaps
  521. #            xfFSBoxAction - the action bound to the ok button
  522. #            xfFSBoxY - the y position in the listbox
  523. # Returns: none
  524. # Sideeffects: none
  525. ##########
  526. proc XFFSBoxFSFileSelectDouble {xfFSBoxW xfFSBoxShowPixmap xfFSBoxAction xfFSBoxY} {# xf ignore me 6
  527.   global xfFSBox
  528.  
  529.   XFFSBoxBindSelectOne $xfFSBoxW $xfFSBoxY
  530.   set xfFSBoxNearest [$xfFSBoxW nearest $xfFSBoxY]
  531.   if {$xfFSBoxNearest >= 0} {
  532.     set xfFSBoxTmpEntry [$xfFSBoxW get $xfFSBoxNearest]
  533.     if {"$xfFSBoxTmpEntry" == "../"} {
  534.       set xfFSBoxTmpEntry [string trimright [string trim $xfFSBox(internalPath)] "@/"]
  535.       if {"$xfFSBoxTmpEntry" == ""} {
  536.         return
  537.       }
  538.       XFFSBoxFSShow [file dirname $xfFSBoxTmpEntry] \
  539.         [.xfFSBox.pattern.pattern get] $xfFSBox(all)
  540.       .xfFSBox.path.path delete 0 end
  541.       .xfFSBox.path.path insert 0 $xfFSBox(internalPath)
  542.     } {
  543.       if {"[string index $xfFSBoxTmpEntry \
  544.             [expr [string length $xfFSBoxTmpEntry]-1]]" == "/" ||
  545.           "[string index $xfFSBoxTmpEntry \
  546.             [expr [string length $xfFSBoxTmpEntry]-1]]" == "@"} {
  547.         set xfFSBoxFileName [string range $xfFSBoxTmpEntry 0 \
  548.               [expr [string length $xfFSBoxTmpEntry]-2]]
  549.         if {![XFIsADir [string trimright $xfFSBox(internalPath)/$xfFSBoxFileName @]] &&
  550.             ![XFIsASymlink [string trimright $xfFSBox(internalPath)/$xfFSBoxFileName @]]} {
  551.           set xfFSBoxFileName $xfFSBoxTmpEntry
  552.         }
  553.       } {
  554.         if {"[string index $xfFSBoxTmpEntry \
  555.               [expr [string length $xfFSBoxTmpEntry]-1]]" == "*"} {
  556.           set xfFSBoxFileName [string range $xfFSBoxTmpEntry 0 \
  557.                 [expr [string length $xfFSBoxTmpEntry]-2]]
  558.           if {![file executable $xfFSBox(internalPath)/$xfFSBoxFileName]} {
  559.             set xfFSBoxFileName $xfFSBoxTmpEntry
  560.           }
  561.         } {
  562.           set xfFSBoxFileName $xfFSBoxTmpEntry
  563.         }
  564.       }
  565.       if {[XFIsADir [string trimright $xfFSBox(internalPath)/$xfFSBoxFileName @]]} {
  566.         set xfFSBox(internalPath) "[string trimright $xfFSBox(internalPath) {/@}]/$xfFSBoxFileName"
  567.         XFFSBoxFSShow $xfFSBox(internalPath) \
  568.           [.xfFSBox.pattern.pattern get] $xfFSBox(all)
  569.         .xfFSBox.path.path delete 0 end
  570.         .xfFSBox.path.path insert 0 $xfFSBox(internalPath)
  571.       } {
  572.         set xfFSBox(name) $xfFSBoxFileName
  573.         if {$xfFSBoxShowPixmap} {
  574.           set xfFSBox(path) @$xfFSBox(internalPath)
  575.         } {
  576.           set xfFSBox(path) $xfFSBox(internalPath)
  577.         }
  578.         if {"$xfFSBoxAction" != ""} {
  579.           eval "global xfFSBox; $xfFSBoxAction"
  580.         }
  581.         if {"[info commands XFDestroy]" != ""} {
  582.           catch {XFDestroy .xfFSBox}
  583.         } {
  584.           catch {destroy .xfFSBox}
  585.         }
  586.       }
  587.     }
  588.   }
  589. }
  590.  
  591. ##########
  592. # Procedure: XFFSBoxFSInsertPath
  593. # Description: insert current pathname into menu
  594. # Arguments: none
  595. # Returns: none
  596. # Sideeffects: none
  597. ##########
  598. proc XFFSBoxFSInsertPath {} {# xf ignore me 6
  599.   global xfFSBox
  600.  
  601.   set xfFSBoxLast [.xfFSBox.path.paths.paths.menu index last]
  602.   set xfFSBoxNewEntry [string trimright [.xfFSBox.path.path get] "/@"]
  603.   for {set xfFSBoxCounter 0} {$xfFSBoxCounter <= $xfFSBoxLast} {incr xfFSBoxCounter 1} {
  604.     if {"$xfFSBoxNewEntry" == \
  605.           "[lindex [.xfFSBox.path.paths.paths.menu entryconfigure \
  606.                     $xfFSBoxCounter -label] 4]"} {
  607.       return
  608.     }
  609.   }
  610.   if {$xfFSBoxLast < 9} {
  611.     .xfFSBox.path.paths.paths.menu add command \
  612.       -label "$xfFSBoxNewEntry" \
  613.       -command "
  614.         global xfFSBox
  615.         XFFSBoxFSShow $xfFSBoxNewEntry \
  616.           \[.xfFSBox.pattern.pattern get\] \$xfFSBox(all)
  617.         .xfFSBox.path.path delete 0 end
  618.         .xfFSBox.path.path insert 0 $xfFSBoxNewEntry"
  619.   } {
  620.     for {set xfFSBoxCounter 0} {$xfFSBoxCounter < $xfFSBoxLast} {incr xfFSBoxCounter 1} {
  621.       .xfFSBox.path.paths.paths.menu entryconfigure \
  622.         $xfFSBoxCounter -label \
  623.           [lindex [.xfFSBox.path.paths.paths.menu entryconfigure \
  624.             [expr $xfFSBoxCounter+1] -label] 4]
  625.       .xfFSBox.path.paths.paths.menu entryconfigure $xfFSBoxCounter \
  626.         -command "
  627.           global xfFSBox
  628.           XFFSBoxFSShow [lindex [.xfFSBox.path.paths.paths.menu entryconfigure \
  629.             [expr $xfFSBoxCounter+1] -label] 4] \
  630.             \[.xfFSBox.pattern.pattern get\] \$xfFSBox(all)
  631.           .xfFSBox.path.path delete 0 end
  632.           .xfFSBox.path.path insert 0 [lindex \
  633.             [.xfFSBox.path.paths.paths.menu entryconfigure \
  634.               [expr $xfFSBoxCounter+1] -label] 4]"
  635.     }
  636.     .xfFSBox.path.paths.paths.menu entryconfigure $xfFSBoxLast \
  637.       -label "$xfFSBoxNewEntry"
  638.     .xfFSBox.path.paths.paths.menu entryconfigure $xfFSBoxCounter \
  639.       -command "
  640.         global xfFSBox
  641.         XFFSBoxFSShow \[.xfFSBox.path.path get\] \
  642.           \[.xfFSBox.pattern.pattern get\] \$xfFSBox(all)
  643.         .xfFSBox.path.path delete 0 end
  644.         .xfFSBox.path.path insert 0 $xfFSBoxNewEntry"
  645.   }
  646. }
  647.  
  648. ##########
  649. # Procedure: XFFSBoxFSNameComplete
  650. # Description: perform name completion for fs box
  651. # Arguments: xfFSBoxType - the type we want to complete (path or file)
  652. # Returns: none
  653. # Sideeffects: none
  654. ##########
  655. proc XFFSBoxFSNameComplete {xfFSBoxType} {# xf ignore me 6
  656.   global tkVersion
  657.   global xfFSBox
  658.  
  659.   set xfFSBoxNewFile ""
  660.   if {"$xfFSBoxType" == "path"} {
  661.     set xfFSBoxDirName [file dirname [.xfFSBox.path.path get]]
  662.     set xfFSBoxFileName [file tail [.xfFSBox.path.path get]]
  663.   } {
  664.     set xfFSBoxDirName [file dirname [.xfFSBox.path.path get]/]
  665.     set xfFSBoxFileName [file tail [.xfFSBox.file.file get]]
  666.   }
  667.  
  668.   set xfFSBoxNewFile ""
  669.   if {[XFIsADir [string trimright $xfFSBoxDirName @]]} {
  670.     catch "glob -nocomplain $xfFSBoxDirName/${xfFSBoxFileName}*" xfFSBoxResult
  671.     foreach xfFSBoxCounter $xfFSBoxResult {
  672.       if {"$xfFSBoxNewFile" == ""} {
  673.         set xfFSBoxNewFile [file tail $xfFSBoxCounter]
  674.       } {
  675.         if {"[string index [file tail $xfFSBoxCounter] 0]" !=
  676.             "[string index $xfFSBoxNewFile 0]"} {
  677.           set xfFSBoxNewFile ""
  678.           break
  679.         }
  680.         set xfFSBoxCounter1 0
  681.         set xfFSBoxTmpFile1 $xfFSBoxNewFile
  682.         set xfFSBoxTmpFile2 [file tail $xfFSBoxCounter]
  683.         set xfFSBoxLength1 [string length $xfFSBoxTmpFile1]
  684.         set xfFSBoxLength2 [string length $xfFSBoxTmpFile2]
  685.         set xfFSBoxNewFile ""
  686.         if {$xfFSBoxLength1 > $xfFSBoxLength2} {
  687.           set xfFSBoxLength1 $xfFSBoxLength2
  688.         }
  689.         while {$xfFSBoxCounter1 < $xfFSBoxLength1} {
  690.           if {"[string index $xfFSBoxTmpFile1 $xfFSBoxCounter1]" == \
  691.                 "[string index $xfFSBoxTmpFile2 $xfFSBoxCounter1]"} {
  692.             append xfFSBoxNewFile [string index $xfFSBoxTmpFile1 $xfFSBoxCounter1]
  693.           } {
  694.             break
  695.           }
  696.           incr xfFSBoxCounter1 1
  697.         }
  698.       }
  699.     }
  700.   }
  701.   if {"$xfFSBoxNewFile" != ""} {
  702.     if {[XFIsADir [string trimright $xfFSBoxDirName/$xfFSBoxNewFile @]] ||
  703.         ![XFIsAFile [string trimright $xfFSBoxDirName/$xfFSBoxNewFile @]]} {
  704.       if {[XFIsADir [string trimright $xfFSBoxDirName/$xfFSBoxNewFile @]]} {
  705.         if {"$xfFSBoxDirName" == "/"} {
  706.           .xfFSBox.path.path delete 0 end
  707.           .xfFSBox.path.path insert 0 "/[string trimright [string trim $xfFSBoxNewFile /] @]/"
  708.         } {
  709.           .xfFSBox.path.path delete 0 end
  710.           .xfFSBox.path.path insert 0 "[string trimright $xfFSBoxDirName /]/[string trimright [string trim $xfFSBoxNewFile /] @]/"
  711.         }
  712.         XFFSBoxFSShow [.xfFSBox.path.path get] \
  713.           [.xfFSBox.pattern.pattern get] $xfFSBox(all)
  714.         XFFSBoxFSInsertPath
  715.       } {
  716.         .xfFSBox.path.path delete 0 end
  717.         .xfFSBox.path.path insert 0 "[string trimright $xfFSBoxDirName /]/[string trimright [string trim $xfFSBoxNewFile /] @]"
  718.       }
  719.     } {
  720.       .xfFSBox.path.path delete 0 end
  721.       .xfFSBox.path.path insert 0 "[string trimright $xfFSBoxDirName {@/}]/"
  722.       .xfFSBox.file.file delete 0 end
  723.       .xfFSBox.file.file insert 0 $xfFSBoxNewFile
  724.       if {$tkVersion >= 3.0} {
  725.         .xfFSBox.file.file icursor end
  726.       } {
  727.         .xfFSBox.file.file cursor end
  728.       }
  729.       focus .xfFSBox.file.file
  730.     }
  731.   }
  732. }
  733.  
  734. ##########
  735. # Procedure: XFFSBoxFSShow
  736. # Description: show the file list
  737. # Arguments: xfFSBoxPath - the path to show
  738. #            xfFSBoxPattern - selection pattern
  739. #            xfFSBoxAll - show all files
  740. # Returns: none
  741. # Sideeffects: none
  742. ##########
  743. proc XFFSBoxFSShow {xfFSBoxPath xfFSBoxPattern xfFSBoxAll} {# xf ignore me 6
  744.   global xfFSBox
  745.  
  746.   set tmpButtonOpt ""
  747.   if {"$xfFSBox(activeBackground)" != ""} {
  748.     append tmpButtonOpt "-activebackground \"$xfFSBox(activeBackground)\" "
  749.   }
  750.   if {"$xfFSBox(activeForeground)" != ""} {
  751.     append tmpButtonOpt "-activeforeground \"$xfFSBox(activeForeground)\" "
  752.   }
  753.   if {"$xfFSBox(background)" != ""} {
  754.     append tmpButtonOpt "-background \"$xfFSBox(background)\" "
  755.   }
  756.   if {"$xfFSBox(font)" != ""} {
  757.     append tmpButtonOpt "-font \"$xfFSBox(font)\" "
  758.   }
  759.   if {"$xfFSBox(foreground)" != ""} {
  760.     append tmpButtonOpt "-foreground \"$xfFSBox(foreground)\" "
  761.   }
  762.  
  763.   set xfFSBox(pattern) $xfFSBoxPattern
  764.   if {[file exists $xfFSBoxPath] && [file readable $xfFSBoxPath] &&
  765.       [XFIsADir $xfFSBoxPath]} {
  766.     set xfFSBox(internalPath) $xfFSBoxPath
  767.   } {
  768.     if {[file exists $xfFSBoxPath] && [file readable $xfFSBoxPath] &&
  769.         [XFIsAFile $xfFSBoxPath]} {
  770.       set xfFSBox(internalPath) [file dirname $xfFSBoxPath]
  771.       .xfFSBox.file.file delete 0 end
  772.       .xfFSBox.file.file insert 0 [file tail $xfFSBoxPath]
  773.       set xfFSBoxPath $xfFSBox(internalPath)
  774.     } {
  775.       while {"$xfFSBoxPath" != "" && "$xfFSBoxPath" != "/" &&
  776.              ![file isdirectory $xfFSBoxPath]} {
  777.         set xfFSBox(internalPath) [file dirname $xfFSBoxPath]
  778.          set xfFSBoxPath $xfFSBox(internalPath)
  779.       }
  780.     }
  781.   }
  782.   if {"$xfFSBoxPath" == ""} {
  783.     set xfFSBoxPath "/"
  784.     set xfFSBox(internalPath) "/"
  785.   }
  786.   .xfFSBox.path.path delete 0 end
  787.   .xfFSBox.path.path insert 0 $xfFSBox(internalPath)
  788.  
  789.   if {[.xfFSBox.files.files size] > 0} {
  790.     .xfFSBox.files.files delete 0 end
  791.   }
  792.   if {$xfFSBoxAll} {
  793.     if {[catch "exec ls -F -a $xfFSBoxPath" xfFSBoxResult]} {
  794.       puts stderr "$xfFSBoxResult"
  795.     }
  796.   } {
  797.     if {[catch "exec ls -F $xfFSBoxPath" xfFSBoxResult]} {
  798.       puts stderr "$xfFSBoxResult"
  799.     }
  800.   }
  801.   set xfFSBoxElementList [lsort $xfFSBoxResult]
  802.  
  803.   foreach xfFSBoxCounter [winfo children .xfFSBox.pattern.patterns.patterns] {
  804.     if {[string length [info commands XFDestroy]] > 0} {
  805.       catch {XFDestroy $xfFSBoxCounter}
  806.     } {
  807.       catch {destroy $xfFSBoxCounter}
  808.     }
  809.   }
  810.   menu .xfFSBox.pattern.patterns.patterns.menu
  811.   catch ".xfFSBox.pattern.patterns.patterns.menu config $tmpButtonOpt"
  812.  
  813.   if {$xfFSBox(extensions)} {
  814.     .xfFSBox.pattern.patterns.patterns.menu add command \
  815.       -label "*" \
  816.       -command {
  817.         global xfFSBox
  818.         set xfFSBox(pattern) "*"
  819.         .xfFSBox.pattern.pattern delete 0 end
  820.         .xfFSBox.pattern.pattern insert 0 $xfFSBox(pattern)
  821.         XFFSBoxFSShow [.xfFSBox.path.path get] $xfFSBox(pattern) \
  822.           $xfFSBox(all)}
  823.   }
  824.  
  825.   if {"$xfFSBoxPath" != "/"} {
  826.     .xfFSBox.files.files insert end "../"
  827.   }
  828.   foreach xfFSBoxCounter $xfFSBoxElementList {
  829.     if {[string match $xfFSBoxPattern $xfFSBoxCounter] ||
  830.         [XFIsADir [string trimright $xfFSBoxPath/$xfFSBoxCounter "/@"]]} {
  831.       if {"$xfFSBoxCounter" != "../" &&
  832.           "$xfFSBoxCounter" != "./"} {
  833.         .xfFSBox.files.files insert end $xfFSBoxCounter
  834.       }
  835.     }
  836.  
  837.     if {$xfFSBox(extensions)} {
  838.       catch "file rootname $xfFSBoxCounter" xfFSBoxRootName
  839.       catch "file extension $xfFSBoxCounter" xfFSBoxExtension
  840.       set xfFSBoxExtension [string trimright $xfFSBoxExtension "/*@"]
  841.       if {"$xfFSBoxExtension" != "" && "$xfFSBoxRootName" != ""} {
  842.         set xfFSBoxInsert 1
  843.         set xfFSBoxLast [.xfFSBox.pattern.patterns.patterns.menu index last]
  844.         for {set xfFSBoxCounter1 0} {$xfFSBoxCounter1 <= $xfFSBoxLast} {incr xfFSBoxCounter1 1} {
  845.           if {"*$xfFSBoxExtension" == \
  846.                 "[lindex [.xfFSBox.pattern.patterns.patterns.menu entryconfigure \
  847.                         $xfFSBoxCounter1 -label] 4]"} {
  848.             set xfFSBoxInsert 0
  849.           }
  850.         }
  851.     if {$xfFSBoxInsert} {
  852.           .xfFSBox.pattern.patterns.patterns.menu add command \
  853.             -label "*$xfFSBoxExtension" \
  854.             -command "
  855.               global xfFSBox
  856.               set xfFSBox(pattern) \"*$xfFSBoxExtension\"
  857.               .xfFSBox.pattern.pattern delete 0 end
  858.               .xfFSBox.pattern.pattern insert 0 \$xfFSBox(pattern)
  859.               XFFSBoxFSShow \[.xfFSBox.path.path get\] \$xfFSBox(pattern) \
  860.                 \$xfFSBox(all)"
  861.         }
  862.       }
  863.     }
  864.   }
  865.   if {$xfFSBox(extensions)} {
  866.     .xfFSBox.pattern.patterns.patterns.menu add separator
  867.   }
  868.   if {$xfFSBox(extensions) || 
  869.       "[.xfFSBox.pattern.patterns.patterns.menu index last]" == "none"} {
  870.     .xfFSBox.pattern.patterns.patterns.menu add checkbutton \
  871.       -label "Scan extensions" \
  872.       -variable "xfFSBox(extensions)" \
  873.       -command {
  874.         global xfFSBox
  875.         XFFSBoxFSShow [.xfFSBox.path.path get] \
  876.           [.xfFSBox.pattern.pattern get] $xfFSBox(all)}
  877.   }
  878. }
  879.  
  880. ##########
  881. # Procedure: XFFSBoxBindSelectOne
  882. # Description: action to select the current list item
  883. # Arguments: xfFSBoxW - the widget
  884. #            xfFSBoxY - the y position in the listbox
  885. # Returns: none
  886. # Sideeffects: none
  887. ##########
  888. proc XFFSBoxBindSelectOne {xfFSBoxW xfFSBoxY} {# xf ignore me 6
  889.  
  890.   set xfFSBoxNearest [$xfFSBoxW nearest $xfFSBoxY]
  891.   if {$xfFSBoxNearest >= 0} {
  892.     $xfFSBoxW select from $xfFSBoxNearest
  893.     $xfFSBoxW select to $xfFSBoxNearest
  894.   }
  895. }
  896.  
  897. proc XFIsADir {pathName} {# xf ignore me 5
  898. ##########
  899. # Procedure: XFIsADir
  900. # Description: check if name is a directory (including symbolic links)
  901. # Arguments: pathName - the path to check
  902. # Returns: 1 if its a directory, otherwise 0
  903. # Sideeffects: none
  904. ##########
  905.  
  906.   if {[file isdirectory $pathName]} {
  907.     return 1
  908.   } {
  909.     catch "file type $pathName" fileType
  910.     if {"$fileType" == "link"} {
  911.       if {[catch "file readlink $pathName" linkName]} {
  912.         return 0
  913.       }
  914.       catch "file type $linkName" fileType
  915.       while {"$fileType" == "link"} {
  916.         if {[catch "file readlink $linkName" linkName]} {
  917.           return 0
  918.         }
  919.         catch "file type $linkName" fileType
  920.       }
  921.       return [file isdirectory $linkName]
  922.     }
  923.   }
  924.   return 0
  925. }
  926.  
  927. proc XFIsAFile {fileName} {# xf ignore me 5
  928. ##########
  929. # Procedure: XFIsAFile
  930. # Description: check if filename is a file (including symbolic links)
  931. # Arguments: fileName - the filename to check
  932. # Returns: 1 if its a file, otherwise 0
  933. # Sideeffects: none
  934. ##########
  935.  
  936.   if {[file isfile $fileName]} {
  937.     return 1
  938.   } {
  939.     catch "file type $fileName" fileType
  940.     if {"$fileType" == "link"} {
  941.       if {[catch "file readlink $fileName" linkName]} {
  942.         return 0
  943.       }
  944.       catch "file type $linkName" fileType
  945.       while {"$fileType" == "link"} {
  946.         if {[catch "file readlink $linkName" linkName]} {
  947.           return 0
  948.         }
  949.         catch "file type $linkName" fileType
  950.       }
  951.       return [file isfile $linkName]
  952.     }
  953.   }
  954.   return 0
  955. }
  956.  
  957. proc XFIsASymlink {fileName} {# xf ignore me 5
  958. ##########
  959. # Procedure: XFIsASymlink
  960. # Description: check if filename is a symbolic link
  961. # Arguments: fileName - the path/filename to check
  962. # Returns: none
  963. # Sideeffects: none
  964. ##########
  965.  
  966.   catch "file type $fileName" fileType
  967.   if {"$fileType" == "link"} {
  968.     return 1
  969.   }
  970.   return 0
  971. }
  972.  
  973. # eof
  974.  
  975.