home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2005 March / PCWELT_3_2005.ISO / pcwsoft / framework-2.2.exe / combobox.itk < prev    next >
Encoding:
Text File  |  2003-09-01  |  45.0 KB  |  1,444 lines
  1. # Combobox
  2. # ----------------------------------------------------------------------
  3. # Implements a Combobox widget. A Combobox has 2 basic styles: simple and
  4. # dropdown. Dropdowns display an entry field with an arrow button to the 
  5. # right of it. When the arrow button is pressed a selectable list of
  6. # items is popped up. A simple Combobox displays an entry field and a listbox 
  7. # just beneath it which is always displayed. In both types, if the user 
  8. # selects an item in the listbox, the contents of the entry field are 
  9. # replaced with the text from the selected item. If the Combobox is 
  10. # editable, the user can type in the entry field and when <Return> is
  11. # pressed the item will be inserted into the list.
  12. #
  13. # WISH LIST:
  14. #    This section lists possible future enhancements.  
  15. #
  16. #      Combobox 1.x:
  17. #          - convert bindings to bindtags.
  18. #
  19. # ----------------------------------------------------------------------
  20. #  ORIGINAL AUTHOR: John S. Sigler
  21. # ----------------------------------------------------------------------
  22. #  CURRENT MAINTAINER: Chad Smith    EMAIL: csmith@adc.com, itclguy@yahoo.com
  23. #
  24. #                    Copyright (c) 1995    John S. Sigler
  25. #                    Copyright (c) 1997    Mitch Gorman
  26. # ======================================================================
  27. # Permission is hereby granted, without written agreement and without
  28. # license or royalty fees, to use, copy, modify, and distribute this
  29. # software and its documentation for any purpose, provided that the
  30. # above copyright notice and the following two paragraphs appear in
  31. # all copies of this software.
  32. # 
  33. # IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  34. # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 
  35. # ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 
  36. # IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 
  37. # DAMAGE.
  38. #
  39. # THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 
  40. # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
  41. # FITNESS FOR A PARTICULAR PURPOSE.     THE SOFTWARE PROVIDED HEREUNDER IS
  42. # ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  43. # PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  44. # ======================================================================
  45.  
  46. #
  47. # Default resources.
  48. #
  49. option add *Combobox.borderWidth 2 widgetDefault
  50. option add *Combobox.labelPos wn widgetDefault
  51. option add *Combobox.listHeight 150 widgetDefault
  52. option add *Combobox.hscrollMode dynamic widgetDefault
  53. option add *Combobox.vscrollMode dynamic widgetDefault
  54.  
  55. #
  56. # Usual options.
  57. #
  58. itk::usual Combobox {
  59.     keep -background -borderwidth -cursor -foreground -highlightcolor \
  60.     -highlightthickness -insertbackground -insertborderwidth \
  61.     -insertofftime -insertontime -insertwidth -labelfont -popupcursor \
  62.     -selectbackground -selectborderwidth -selectforeground \
  63.     -textbackground -textfont
  64. }
  65.  
  66. # ------------------------------------------------------------------
  67. #                             COMBOBOX
  68. # ------------------------------------------------------------------
  69. itcl::class iwidgets::Combobox {
  70.     inherit iwidgets::Entryfield
  71.     
  72.     constructor {args} {}
  73.     destructor {}
  74.  
  75.     itk_option define -arrowrelief arrowRelief Relief raised
  76.     itk_option define -completion completion Completion true
  77.     itk_option define -dropdown dropdown Dropdown true
  78.     itk_option define -editable editable Editable true
  79.     itk_option define -grab grab Grab local
  80.     itk_option define -listheight listHeight Height 150
  81.     itk_option define -margin margin Margin 1
  82.     itk_option define -popupcursor popupCursor Cursor arrow
  83.     itk_option define -selectioncommand selectionCommand SelectionCommand {}
  84.     itk_option define -state state State normal
  85.     itk_option define -unique unique Unique true
  86.  
  87.     public method clear {{component all}}
  88.     public method curselection {}
  89.     public method delete {component first {last {}}}
  90.     public method get {{index {}}}
  91.     public method getcurselection {}
  92.     public method insert {component index args}
  93.     public method invoke {}
  94.     public method justify {direction}
  95.     public method see {index}
  96.     public method selection {option first {last {}}}
  97.     public method size {}
  98.     public method sort {{mode ascending}}
  99.     public method xview {args}
  100.     public method yview {args}
  101.  
  102.     protected method _addToList {}
  103.     protected method _createComponents {}
  104.     protected method _deleteList {first {last {}}}
  105.     protected method _deleteText {first {last {}}}
  106.     protected method _doLayout {{when later}}
  107.     protected method _drawArrow {}
  108.     protected method _dropdownBtnRelease {{window {}} {x 1} {y 1}}
  109.     protected method _ignoreNextBtnRelease {ignore}
  110.     protected method _next {}
  111.     protected method _packComponents {{when later}}
  112.     protected method _positionList {}
  113.     protected method _postList {}
  114.     protected method _previous {}
  115.     protected method _resizeArrow {}
  116.     protected method _selectCmd {}
  117.     protected method _toggleList {}
  118.     protected method _unpostList {}
  119.     protected method _commonBindings {}
  120.     protected method _dropdownBindings {}
  121.     protected method _simpleBindings {}
  122.     protected method _listShowing {{val ""}}
  123.  
  124.     private method _bs {}
  125.     private method _lookup {key}
  126.     private method _slbListbox {}
  127.     private method _stateSelect {}
  128.  
  129.     private variable _doit 0;
  130.     private variable _inbs 0;
  131.     private variable _inlookup 0;
  132.     private variable _currItem {};             ;# current selected item.
  133.     private variable _ignoreRelease false     ;# next button release ignored.
  134.     private variable _isPosted false;         ;# is the dropdown popped up.
  135.     private variable _repacking {}      ;# non-null => _packComponents pending.
  136.     private variable _grab                ;# used to restore grabs
  137.     private variable _next_prevFLAG 0 ;# Used in _lookup to fix SF Bug 501300
  138.     private common _listShowing
  139.     private common count 0
  140. }     
  141.  
  142. #
  143. # Provide a lowercase access method for the Combobox class.
  144. # 
  145. proc ::iwidgets::combobox {pathName args} {
  146.     uplevel ::iwidgets::Combobox $pathName $args
  147. }
  148.  
  149. # ------------------------------------------------------------------
  150. #                        CONSTRUCTOR
  151. # ------------------------------------------------------------------
  152. itcl::body iwidgets::Combobox::constructor {args} {
  153.     set _listShowing($this) 0
  154.     set _grab(window) ""
  155.     set _grab(status) ""
  156.  
  157.     # combobox is different as all components are created 
  158.     # after determining what the dropdown style is...
  159.  
  160.     # configure args
  161.     eval itk_initialize $args
  162.     
  163.     # create components that are dependent on options 
  164.     # (Scrolledlistbox, arrow button) and pack them.
  165.     if {$count == 0} {
  166.     image create bitmap downarrow -data {
  167.         #define down_width 16
  168.         #define down_height 16
  169.         static unsigned char down_bits[] = {
  170.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  171.         0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0xf8, 0x3f, 
  172.         0xf0, 0x1f, 0xe0, 0x0f, 0xc0, 0x07, 0x80, 0x03, 
  173.         0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  174.         };
  175.     }
  176.     image create bitmap uparrow -data {
  177.         #define up_width 16
  178.         #define up_height 16
  179.         static unsigned char up_bits[] = {
  180.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 
  181.         0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 
  182.         0xfc, 0x1f, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00,
  183.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  184.         };
  185.     }
  186.     }
  187.     incr count
  188.     _doLayout
  189. }
  190.  
  191. # ------------------------------------------------------------------
  192. #                           DESTRUCTOR
  193. # ------------------------------------------------------------------
  194. itcl::body iwidgets::Combobox::destructor {} {
  195.     # catch any repacking that may be waiting for idle time
  196.     if {$_repacking != ""} {
  197.     after cancel $_repacking
  198.     }
  199.     incr count -1
  200.     if {$count == 0} {
  201.     image delete uparrow
  202.     image delete downarrow
  203.     }
  204. }
  205.  
  206. # ================================================================
  207. #                            OPTIONS
  208. # ================================================================
  209.  
  210. # --------------------------------------------------------------------
  211. # OPTION:  -arrowrelief
  212. #
  213. # Relief style used on the arrow button.
  214. # --------------------------------------------------------------------
  215. itcl::configbody iwidgets::Combobox::arrowrelief {}
  216.  
  217. # --------------------------------------------------------------------
  218. # OPTION:  -completion
  219. #
  220. # Relief style used on the arrow button.
  221. # --------------------------------------------------------------------
  222. itcl::configbody iwidgets::Combobox::completion {
  223.     switch -- $itk_option(-completion) {
  224.     0 - no - false - off { }
  225.     1 - yes - true - on { }
  226.     default {
  227.         error "bad completion option \"$itk_option(-completion)\":\
  228.                        should be boolean"
  229.     }
  230.     }
  231. }
  232.  
  233. # --------------------------------------------------------------------
  234. # OPTION:  -dropdown  
  235. #
  236. # Boolean which determines the Combobox style: dropdown or simple.
  237. # Because the two style's lists reside in different toplevel widgets
  238. # this is more complicated than it should be.
  239. # --------------------------------------------------------------------
  240. itcl::configbody iwidgets::Combobox::dropdown {
  241.     switch -- $itk_option(-dropdown) {
  242.     1 - yes - true - on {
  243.         if {[winfo exists $itk_interior.list]} {
  244.         set vals [$itk_component(list) get 0 end]
  245.         destroy $itk_component(list)
  246.         _doLayout
  247.         if [llength $vals] {
  248.             eval insert list end $vals
  249.         }
  250.         }
  251.     }
  252.     0 - no - false - off {
  253.         if {[winfo exists $itk_interior.popup.list]} {
  254.         set vals [$itk_component(list) get 0 end]
  255.         catch {destroy $itk_component(arrowBtn)}
  256.         destroy $itk_component(popup)  ;# this deletes the list too
  257.         _doLayout
  258.         if [llength $vals] {
  259.             eval insert list end $vals
  260.         }
  261.         }
  262.     }
  263.     default {
  264.         error "bad dropdown option \"$itk_option(-dropdown)\":\
  265.                        should be boolean"
  266.     }
  267.     }
  268. }
  269.  
  270. # --------------------------------------------------------------------
  271. # OPTION: -editable     
  272. #
  273. # Boolean which allows/disallows user input to the entry field area.
  274. # --------------------------------------------------------------------
  275. itcl::configbody iwidgets::Combobox::editable {
  276.     switch -- $itk_option(-editable) {
  277.     1 - true - yes - on {
  278.         switch -- $itk_option(-state) {
  279.         normal {
  280.             $itk_component(entry) configure -state normal
  281.         }
  282.         }
  283.     }
  284.     0 - false - no - off {
  285.         $itk_component(entry) configure -state disabled
  286.     }
  287.     default {
  288.         error "bad editable option \"$itk_option(-editable)\":\
  289.                    should be boolean"
  290.     }
  291.     }
  292. }
  293.  
  294. # --------------------------------------------------------------------
  295. # OPTION:  -grab
  296. #
  297. # grab-state of megawidget
  298. # --------------------------------------------------------------------
  299. itcl::configbody iwidgets::Combobox::grab {
  300.     switch -- $itk_option(-grab) {
  301.     local { }
  302.     global { }
  303.     default {
  304.         error "bad grab value \"$itk_option(-grab)\":\
  305.                    must be global or local"
  306.     }
  307.     }
  308. }
  309.  
  310. # --------------------------------------------------------------------
  311. # OPTION: -listheight  
  312. #
  313. # Listbox height in pixels. (Need to integrate the scrolledlistbox
  314. # -visibleitems option here - at least for simple listbox.)
  315. # --------------------------------------------------------------------
  316. itcl::configbody iwidgets::Combobox::listheight {}
  317.  
  318. # --------------------------------------------------------------------
  319. # OPTION:  -margin
  320. #
  321. # Spacer between the entry field and arrow button of dropdown style
  322. # Comboboxes.
  323. # --------------------------------------------------------------------
  324. itcl::configbody iwidgets::Combobox::margin {
  325.     grid columnconfigure $itk_interior 0 -minsize $itk_option(-margin)
  326. }
  327.  
  328. # --------------------------------------------------------------------
  329. # OPTION:  -popupcursor
  330. #
  331. # Set the cursor for the popup list.
  332. # --------------------------------------------------------------------
  333. itcl::configbody iwidgets::Combobox::popupcursor {}
  334.  
  335. # --------------------------------------------------------------------
  336. # OPTION:  -selectioncommand
  337. #
  338. # Defines the proc to be called when an item is selected in the list.
  339. # --------------------------------------------------------------------
  340. itcl::configbody iwidgets::Combobox::selectioncommand {}
  341.  
  342. # --------------------------------------------------------------------
  343. # OPTION:  -state
  344. #
  345. # overall state of megawidget
  346. # --------------------------------------------------------------------
  347. itcl::configbody iwidgets::Combobox::state {
  348.     switch -- $itk_option(-state) {
  349.     disabled {
  350.         $itk_component(entry) configure -state disabled
  351.     }
  352.     normal {
  353.         switch -- $itk_option(-editable) {
  354.         1 - true - yes - on {
  355.             $itk_component(entry) configure -state normal
  356.         }
  357.         0 - false - no - off {
  358.             $itk_component(entry) configure -state disabled
  359.         }
  360.         }
  361.     }
  362.     readonly {
  363.       $itk_component(entry) configure -state readonly
  364.     }
  365.     default {
  366.         error "bad state value \"$itk_option(-state)\":\
  367.                    must be normal  or disabled"
  368.     }
  369.     }
  370.     if {[info exists itk_component(arrowBtn)]} {
  371.     $itk_component(arrowBtn) configure -state $itk_option(-state)
  372.     }
  373. }
  374.  
  375. # --------------------------------------------------------------------
  376. # OPTION: -unique  
  377. #
  378. # Boolean which disallows/allows adding duplicate items to the listbox.
  379. # --------------------------------------------------------------------
  380. itcl::configbody iwidgets::Combobox::unique {
  381.     # boolean error check
  382.     switch -- $itk_option(-unique) {
  383.     1 - true - yes - on { }
  384.     0 - false - no - off { }
  385.     default {
  386.         error "bad unique value \"$itk_option(-unique)\":\
  387.                    should be boolean"
  388.     }
  389.     }
  390. }
  391.  
  392. # =================================================================
  393. #                             METHODS
  394. # =================================================================
  395.  
  396. # ------------------------------------------------------
  397. #  PUBLIC METHOD: clear ?component?
  398. #
  399. #  Remove all elements from the listbox, all contents
  400. #  from the entry component, or both (if all).
  401. #
  402. # ------------------------------------------------------
  403. itcl::body iwidgets::Combobox::clear {{component all}} {
  404.     switch -- $component {
  405.     entry {
  406.         iwidgets::Entryfield::clear
  407.     }
  408.     list {
  409.         delete list 0 end
  410.     }
  411.     all {
  412.         delete list 0 end
  413.         iwidgets::Entryfield::clear
  414.     }
  415.     default {
  416.         error "bad Combobox component \"$component\":\
  417.                    must be entry, list, or all."
  418.     }
  419.     }
  420.     return
  421. }
  422.  
  423. # ------------------------------------------------------
  424. # PUBLIC METHOD: curselection
  425. #
  426. # Return the current selection index.
  427. #
  428. # ------------------------------------------------------
  429. itcl::body iwidgets::Combobox::curselection {} {
  430.     return [$itk_component(list) curselection]
  431. }
  432.  
  433. # ------------------------------------------------------
  434. # PUBLIC METHOD: delete component first ?last?
  435. #
  436. # Delete an item or items from the listbox OR delete
  437. # text from the entry field. First argument determines
  438. # which component deletion occurs in - valid values are
  439. # entry or list.
  440. #
  441. # ------------------------------------------------------
  442. itcl::body iwidgets::Combobox::delete {component first {last {}}} {
  443.     switch -- $component {
  444.     entry {
  445.         if {$last == {}} {
  446.           set last [expr {$first + 1}]
  447.         }
  448.         iwidgets::Entryfield::delete $first $last
  449.     }
  450.     list {
  451.         _deleteList $first $last
  452.     }
  453.     default {
  454.         error "bad Combobox component \"$component\":\
  455.                    must be entry or list."
  456.     }
  457.     }
  458. }
  459.  
  460. # ------------------------------------------------------
  461. # PUBLIC METHOD: get ?index?
  462. #
  463. #
  464. # Retrieve entry contents if no args OR use args as list 
  465. # index and retrieve list item at index .
  466. #
  467. # ------------------------------------------------------
  468. itcl::body iwidgets::Combobox::get {{index {}}} {
  469.     # no args means to get the current text in the entry field area
  470.     if {$index == {}} {
  471.     iwidgets::Entryfield::get
  472.     } else {
  473.     eval $itk_component(list) get $index
  474.     }
  475. }
  476.  
  477. # ------------------------------------------------------
  478. # PUBLIC METHOD: getcurselection
  479. #
  480. # Return currently selected item in the listbox. Shortcut
  481. # version of get curselection command combination.
  482. #
  483. # ------------------------------------------------------
  484. itcl::body iwidgets::Combobox::getcurselection {} {
  485.     return [$itk_component(list) getcurselection]
  486. }
  487.  
  488. # ------------------------------------------------------------------
  489. # PUBLIC METHOD: invoke
  490. #
  491. # Pops up or down a dropdown combobox.
  492. # 
  493. # ------------------------------------------------------------------
  494. itcl::body iwidgets::Combobox::invoke {} {
  495.     if {$itk_option(-dropdown)} {
  496.     return [_toggleList]
  497.     }
  498.     return 
  499. }
  500.  
  501. # ------------------------------------------------------------
  502. # PUBLIC METHOD: insert comonent index string ?string ...?
  503. #
  504. # Insert an item into the listbox OR text into the entry area.
  505. # Valid component names are entry or list.
  506. #
  507. # ------------------------------------------------------------
  508. itcl::body iwidgets::Combobox::insert {component index args} {
  509.     set nargs [llength $args]
  510.  
  511.     if {$nargs == 0} {
  512.     error "no value given for parameter \"string\" in function\
  513.                \"Combobox::insert\""
  514.     } 
  515.  
  516.     switch -- $component {
  517.     entry {
  518.         if { $nargs > 1} {
  519.         error "called function \"Combobox::insert entry\"\
  520.                        with too many arguments"
  521.         } else {
  522.         if {$itk_option(-state) == "normal"} {
  523.             eval iwidgets::Entryfield::insert $index $args
  524.             [itcl::code $this _lookup ""]
  525.         }
  526.         }
  527.     }
  528.     list {
  529.         if {$itk_option(-state) == "normal"} {
  530.         eval $itk_component(list) insert $index $args
  531.         }
  532.     }
  533.     default {
  534.         error "bad Combobox component \"$component\": must\
  535.                    be entry or list."
  536.     }
  537.     }
  538. }
  539.  
  540. # ------------------------------------------------------
  541. # PUBLIC METHOD: justify direction
  542. #
  543. # Wrapper for justifying the listbox items in one of
  544. # 4 directions:     top, bottom, left, or right.
  545. #
  546. # ------------------------------------------------------
  547. itcl::body iwidgets::Combobox::justify {direction} {
  548.     return [$itk_component(list) justify $direction]
  549. }
  550.  
  551. # ------------------------------------------------------------------
  552. # PUBLIC METHOD: see index
  553. #
  554. # Adjusts the view such that the element given by index is visible.
  555. # ------------------------------------------------------------------
  556. itcl::body iwidgets::Combobox::see {index} {
  557.     return [$itk_component(list) see $index]
  558. }
  559.  
  560. # ------------------------------------------------------------------
  561. # PUBLIC METHOD: selection option first ?last?
  562. #
  563. # Adjusts the selection within the listbox and changes the contents
  564. # of the entry component to be the value of the selected list item.
  565. # ------------------------------------------------------------------
  566. itcl::body iwidgets::Combobox::selection {option first {last {}}} {
  567.     # thin wrap
  568.     if {$option == "set"} {
  569.     $itk_component(list) selection clear 0 end
  570.     $itk_component(list) selection set $first
  571.     set rtn ""
  572.     } else {
  573.     set rtn [eval $itk_component(list) selection $option $first $last]
  574.     }
  575.     set _currItem $first
  576.  
  577.     # combobox additions
  578.     set theText [getcurselection]
  579.     if {$theText != [$itk_component(entry) get]} {
  580.     clear entry
  581.     if {$theText != ""} {
  582.         insert entry 0 $theText
  583.     }
  584.     }
  585.     return $rtn
  586. }
  587.  
  588. # ------------------------------------------------------------------
  589. # PUBLIC METHOD: size 
  590. #
  591. # Returns a decimal string indicating the total number of elements 
  592. # in the listbox.
  593. # ------------------------------------------------------------------
  594. itcl::body iwidgets::Combobox::size {} {
  595.     return [$itk_component(list) size]
  596. }
  597.  
  598. # ------------------------------------------------------
  599. # PUBLIC METHOD: sort ?mode?
  600. #
  601. # Sort the current list in either "ascending" or "descending" order.
  602. #
  603. #    jss: how should i handle selected items?
  604. #
  605. # ------------------------------------------------------
  606. itcl::body iwidgets::Combobox::sort {{mode ascending}} {
  607.     $itk_component(list) sort $mode
  608.     #     return [$itk_component(list) sort $mode]
  609. }
  610.  
  611.  
  612. # ------------------------------------------------------------------
  613. # PUBLIC METHOD: xview ?arg arg ...?
  614. #
  615. # Change or query the vertical position of the text in the list box.
  616. # ------------------------------------------------------------------
  617. itcl::body iwidgets::Combobox::xview {args} {
  618.     return [eval $itk_component(list) xview $args]
  619. }
  620.  
  621. # ------------------------------------------------------------------
  622. # PUBLIC METHOD: yview ?arg arg ...?
  623. #
  624. # Change or query the horizontal position of the text in the list box.
  625. # ------------------------------------------------------------------
  626. itcl::body iwidgets::Combobox::yview {args} {
  627.     return [eval $itk_component(list) yview $args]
  628. }
  629.  
  630. # ------------------------------------------------------
  631. # PROTECTED METHOD: _addToList
  632. #
  633. # Add the current item in the entry to the listbox.
  634. #
  635. # ------------------------------------------------------
  636. itcl::body iwidgets::Combobox::_addToList {} {
  637.     set input [get]
  638.     if {$input != ""} {
  639.     if {$itk_option(-unique)} {
  640.         # if item is already in list, select it and exit
  641.         set item [lsearch -exact [$itk_component(list) get 0 end] $input]
  642.         if {$item != -1} {
  643.         selection clear 0 end
  644.         if {$item != {}} {
  645.             selection set $item $item
  646.             set _currItem $item
  647.         }
  648.         return
  649.         }
  650.     }
  651.     # add the item to end of list
  652.     selection clear 0 end
  653.     insert list end $input
  654.     selection set end end
  655.     }
  656. }
  657.  
  658. # ------------------------------------------------------
  659. # PROTECTED METHOD:      _createComponents
  660. #
  661. # Create deferred combobox components and add bindings.
  662. #
  663. # ------------------------------------------------------
  664. itcl::body iwidgets::Combobox::_createComponents {} {
  665.     if {$itk_option(-dropdown)} {
  666.     # --- build a dropdown combobox ---
  667.  
  668.     # make the arrow childsite be on the right hand side
  669.  
  670.       #-------------------------------------------------------------
  671.     # BUG FIX: csmith (Chad Smith: csmith@adc.com), 3/4/99
  672.       #-------------------------------------------------------------
  673.     # The following commented line of code overwrites the -command
  674.     # option when passed into the constructor.  The order of calls
  675.     # in the constructor is:
  676.     #     1) eval itk_initalize $args (initializes -command)
  677.     #       2) _doLayout
  678.     #       3) _createComponents (overwrites -command)
  679.     # The solution is to only set the -command option if it hasn't
  680.     # already been set.  The following 4 lines of code do this.
  681.       #-------------------------------------------------------------
  682.     # ** configure -childsitepos e -command [code $this _addToList]
  683.       #-------------------------------------------------------------
  684.     configure -childsitepos e
  685.     if ![llength [cget -command]] {
  686.       configure -command [itcl::code $this _addToList]
  687.     }
  688.     
  689.     # arrow button to popup the list
  690.     itk_component add arrowBtn {
  691.         button $itk_interior.arrowBtn -borderwidth 2 \
  692.         -width 15 -height 15 -image downarrow \
  693.         -command [itcl::code $this _toggleList] -state $itk_option(-state)
  694.     } {
  695.         keep -background -borderwidth -cursor  -state \
  696.         -highlightcolor -highlightthickness
  697.         rename -relief -arrowrelief arrowRelief Relief
  698.         rename -highlightbackground -background background Background
  699.     }
  700.     
  701.     # popup list container
  702.     itk_component add popup {
  703.         toplevel $itk_interior.popup
  704.     } {
  705.         keep -background -cursor
  706.     }
  707.     wm withdraw $itk_interior.popup
  708.     
  709.     # the listbox
  710.     itk_component add list {
  711.         iwidgets::Scrolledlistbox $itk_interior.popup.list -exportselection no \
  712.         -vscrollmode dynamic -hscrollmode dynamic -selectmode browse
  713.     } {
  714.         keep -background -borderwidth -cursor -foreground \
  715.         -highlightcolor -highlightthickness \
  716.         -hscrollmode -selectbackground \
  717.         -selectborderwidth -selectforeground -textbackground \
  718.         -textfont -vscrollmode
  719.         rename -height -listheight listHeight Height
  720.         rename -cursor -popupcursor popupCursor Cursor
  721.     }
  722.     # mode specific bindings
  723.     _dropdownBindings
  724.  
  725.     # Ugly hack to avoid tk buglet revealed in _dropdownBtnRelease where 
  726.     # relief is used but not set in scrollbar.tcl. 
  727.     global tkPriv
  728.     set tkPriv(relief) raise
  729.  
  730.     } else {
  731.     # --- build a simple combobox ---
  732.     configure -childsitepos s
  733.     itk_component add list {
  734.         iwidgets::Scrolledlistbox $itk_interior.list -exportselection no \
  735.         -vscrollmode dynamic -hscrollmode dynamic 
  736.     } {
  737.         keep -background -borderwidth -cursor -foreground \
  738.         -highlightcolor -highlightthickness \
  739.         -hscrollmode -selectbackground \
  740.         -selectborderwidth -selectforeground -textbackground \
  741.         -textfont -visibleitems -vscrollmode 
  742.         rename -height -listheight listHeight Height
  743.     }
  744.     # add mode specific bindings
  745.     _simpleBindings
  746.     }
  747.  
  748.     # popup cursor applies only to the list within the combobox
  749.     configure -popupcursor $itk_option(-popupcursor)
  750.  
  751.     # add mode independent bindings
  752.     _commonBindings
  753. }
  754.  
  755. # ------------------------------------------------------
  756. # PROTECTED METHOD: _deleteList first ?last?
  757. #
  758. # Delete an item or items from the listbox. Called via 
  759. # "delete list args".
  760. #
  761. # ------------------------------------------------------
  762. itcl::body iwidgets::Combobox::_deleteList {first {last {}}} {
  763.  
  764.     if {$last == {}} {
  765.     set last $first
  766.     }
  767.     $itk_component(list) delete $first $last
  768.  
  769.     # remove the item if it is no longer in the list
  770.     set text [$this get]
  771.     if {$text != ""} {
  772.     set index [lsearch -exact [$itk_component(list) get 0 end] $text ]
  773.     if {$index == -1} {
  774.         clear entry
  775.     }
  776.     }
  777.     return
  778. }
  779.  
  780. # ------------------------------------------------------
  781. # PROTECTED METHOD: _deleteText first ?last?
  782. #
  783. # Renamed Entryfield delete method. Called via "delete entry args".
  784. #
  785. # ------------------------------------------------------
  786. itcl::body iwidgets::Combobox::_deleteText {first {last {}}} {
  787.     $itk_component(entry) configure -state normal 
  788.     set rtrn [delete $first $last]
  789.     switch -- $itk_option(-editable) {
  790.     0 - false - no - off {
  791.         $itk_component(entry) configure -state disabled
  792.     }
  793.     }
  794.     return $rtrn
  795. }
  796.  
  797. # ------------------------------------------------------
  798. # PROTECTED METHOD:      _doLayout ?when?
  799. #
  800. # Call methods to create and pack the Combobox components.
  801. #
  802. # ------------------------------------------------------
  803. itcl::body iwidgets::Combobox::_doLayout {{when later}} {
  804.     _createComponents
  805.     _packComponents $when
  806. }
  807.  
  808.  
  809. # ------------------------------------------------------
  810. # PROTECTED METHOD:      _drawArrow 
  811. #
  812. # Draw the arrow button. Determines packing according to
  813. # -labelpos.
  814. #
  815. # ------------------------------------------------------
  816. itcl::body iwidgets::Combobox::_drawArrow {} {
  817.     set flip false
  818.     set relief ""
  819.     set fg [cget -foreground]
  820.     if {$_isPosted} {
  821.     set flip true
  822.     set relief "-relief sunken"
  823.     } else {
  824.     set relief "-relief $itk_option(-arrowrelief)"
  825.     }
  826.  
  827.     if {$flip} {
  828.     #     
  829.     #                draw up arrow
  830.     #
  831.     eval $itk_component(arrowBtn) configure -image uparrow $relief
  832.     } else {
  833.     #     
  834.     #                draw down arrow
  835.     #
  836.     eval $itk_component(arrowBtn) configure -image downarrow $relief
  837.     }
  838. }
  839.  
  840. # ------------------------------------------------------
  841. # PROTECTED METHOD: _dropdownBtnRelease window x y
  842. #
  843. # Event handler for button releases while a dropdown list
  844. # is posted.
  845. #
  846. # ------------------------------------------------------
  847. itcl::body iwidgets::Combobox::_dropdownBtnRelease {{window {}} {x 1} {y 1}} {
  848.  
  849.     # if it's a scrollbar then ignore the release
  850.     if {($window == [$itk_component(list) component vertsb]) ||
  851.     ($window == [$itk_component(list) component horizsb])} {
  852.     return
  853.     }
  854.  
  855.     # 1st release allows list to stay up unless we are in listbox
  856.     if {$_ignoreRelease} {
  857.     _ignoreNextBtnRelease false
  858.     return
  859.     }
  860.     
  861.     # should I use just the listbox or also include the scrollbars
  862.     if { ($x >= 0) && ($x < [winfo width [_slbListbox]])
  863.      && ($y >= 0) && ($y < [winfo height [_slbListbox]])} {
  864.     _stateSelect
  865.     }
  866.     
  867.     _unpostList
  868.  
  869.     # execute user command
  870.     if {$itk_option(-selectioncommand) != ""} {
  871.     uplevel #0 $itk_option(-selectioncommand)
  872.     }
  873. }
  874.  
  875. # ------------------------------------------------------
  876. # PROTECTED METHOD: _ignoreNextBtnRelease ignore
  877. #
  878. # Set private variable _ignoreRelease. If this variable
  879. # is true then the next button release will not remove
  880. # a dropdown list.
  881. #
  882. # ------------------------------------------------------
  883. itcl::body iwidgets::Combobox::_ignoreNextBtnRelease {ignore} {
  884.     set _ignoreRelease $ignore
  885. }
  886.  
  887. # ------------------------------------------------------
  888. # PROTECTED METHOD:      _next
  889. #
  890. # Select the next item in the list.
  891. #
  892. # ------------------------------------------------------
  893. itcl::body iwidgets::Combobox::_next {} {
  894.  
  895.     set _next_prevFLAG 1
  896.  
  897.     if {[size] <= 1} {
  898.     return
  899.     }
  900.     set i [curselection]
  901.     if {($i == {}) || ($i == ([size]-1)) } {
  902.     set i 0
  903.     } else {
  904.     incr i
  905.     }
  906.     selection clear 0 end
  907.     selection set $i $i
  908.     see $i
  909.     set _currItem $i
  910. }
  911.  
  912. # ------------------------------------------------------
  913. # PROTECTED METHOD:      _packComponents ?when?
  914. #
  915. # Pack the components of the combobox and add bindings.
  916. #
  917. # ------------------------------------------------------
  918. itcl::body iwidgets::Combobox::_packComponents {{when later}} {
  919.     if {$when == "later"} {
  920.     if {$_repacking == ""} {
  921.         set _repacking [after idle [itcl::code $this _packComponents now]]
  922.         return
  923.     }
  924.     } elseif {$when != "now"} {
  925.     error "bad option \"$when\": should be now or later"
  926.     }
  927.  
  928.     if {$itk_option(-dropdown)} {
  929.     grid configure $itk_component(list) -row 1 -column 0 -sticky news
  930.     _resizeArrow
  931.         grid config $itk_component(arrowBtn) -row 0 -column 1 -sticky nsew
  932.     } else {
  933.     # size and pack list hack
  934.     grid configure $itk_component(entry) -row 0 -column 0 -sticky ew
  935.     grid configure $itk_component(efchildsite) -row 1 -column 0 -sticky nsew
  936.     grid configure $itk_component(list) -row 0 -column 0 -sticky nsew
  937.  
  938.     grid rowconfigure $itk_component(efchildsite) 1 -weight 1
  939.     grid columnconfigure $itk_component(efchildsite) 0 -weight 1
  940.     }
  941.     set _repacking ""
  942. }
  943.  
  944. # ------------------------------------------------------
  945. # PROTECTED METHOD:      _positionList
  946. #
  947. # Determine the position (geometry) for the popped up list
  948. # and map it to the screen.
  949. #
  950. # ------------------------------------------------------
  951. itcl::body iwidgets::Combobox::_positionList {} {
  952.  
  953.     set x [winfo rootx $itk_component(entry) ]
  954.     set y [expr {[winfo rooty $itk_component(entry) ] + \
  955.            [winfo height $itk_component(entry) ]}]
  956.     set w [winfo width $itk_component(entry) ]
  957.     set h [winfo height [_slbListbox] ]
  958.     set sh [winfo screenheight .]
  959.  
  960.     if {(($y+$h) > $sh) && ($y > ($sh/2))} {
  961.     set y [expr {[winfo rooty $itk_component(entry) ] - $h}]
  962.     }
  963.     
  964.     $itk_component(list) configure -width $w
  965.     wm overrideredirect $itk_component(popup) 0
  966.     wm geometry $itk_component(popup) +$x+$y
  967.     wm overrideredirect $itk_component(popup) 1
  968. }
  969.  
  970. # ------------------------------------------------------
  971. # PROTECTED METHOD:      _postList
  972. #
  973. # Pop up the list in a dropdown style Combobox.
  974. #
  975. # ------------------------------------------------------
  976. itcl::body iwidgets::Combobox::_postList {} {
  977.     if {[$itk_component(list) size] == ""} {
  978.     return
  979.     }
  980.  
  981.     set _isPosted true
  982.     _positionList
  983.  
  984.     # map window and do a grab
  985.     wm deiconify $itk_component(popup)
  986.     _listShowing -wait
  987.  
  988.     # Added by csmith, 12/19/00.  Thanks to Erik Leunissen for
  989.     # finding this problem.  We need to restore any previous
  990.     # grabs after the dropdown listbox is withdrawn.  To do this,
  991.     # save the currently grabbed window.  It is then restored in
  992.     # the _unpostList method.
  993.     set _grab(window) [::grab current]
  994.     if {$_grab(window) != ""} {
  995.       set _grab(status) [::grab status $_grab(window)]
  996.     }
  997.  
  998.     # Now grab the dropdown listbox.
  999.     if {$itk_option(-grab) == "global"} {
  1000.     ::grab -global $itk_component(popup) 
  1001.     } else {
  1002.     ::grab $itk_component(popup) 
  1003.     }
  1004.     raise $itk_component(popup)
  1005.     focus $itk_component(popup)
  1006.     _drawArrow
  1007.  
  1008.     # Added by csmith, 10/26/00.  This binding keeps the listbox
  1009.     # from staying mapped if the window in which the combobox
  1010.     # is packed is iconified.
  1011.     bind $itk_component(entry) <Unmap> [itcl::code $this _unpostList]
  1012. }
  1013.  
  1014. # ------------------------------------------------------
  1015. # PROTECTED METHOD:       _previous
  1016. #
  1017. # Select the previous item in the list. Wraps at front
  1018. # and end of list. 
  1019. #
  1020. # ------------------------------------------------------
  1021. itcl::body iwidgets::Combobox::_previous {} {
  1022.  
  1023.     set _next_prevFLAG 1
  1024.  
  1025.     if {[size] <= 1} {
  1026.     return
  1027.     }
  1028.     set i [curselection]
  1029.     if {$i == "" || $i == 0} {
  1030.     set i [expr {[size] - 1}]
  1031.     } else {
  1032.     incr i -1
  1033.     }
  1034.     selection clear 0 end
  1035.     selection set $i $i
  1036.     see $i
  1037.     set _currItem $i
  1038. }
  1039.  
  1040. # ------------------------------------------------------
  1041. # PROTECTED METHOD:      _resizeArrow
  1042. #
  1043. # Recalculate the arrow button size and then redraw it.
  1044. #
  1045. # ------------------------------------------------------
  1046. itcl::body iwidgets::Combobox::_resizeArrow {} {
  1047.     set bw [expr {[$itk_component(arrowBtn) cget -borderwidth]+ \
  1048.         [$itk_component(arrowBtn) cget -highlightthickness]}]
  1049.     set newHeight [expr {[winfo reqheight $itk_component(entry)]-(2*$bw) - 2}]
  1050.     $itk_component(arrowBtn) configure -width $newHeight -height $newHeight
  1051.     _drawArrow
  1052. }
  1053.  
  1054. # ------------------------------------------------------
  1055. # PROTECTED METHOD:      _selectCmd
  1056. #
  1057. # Called when list item is selected to insert new text 
  1058. # in entry, and call user -command callback if defined.
  1059. #
  1060. # ------------------------------------------------------
  1061. itcl::body iwidgets::Combobox::_selectCmd {} {
  1062.     $itk_component(entry) configure -state normal
  1063.     
  1064.     set _currItem [$itk_component(list) curselection]
  1065.     set item [$itk_component(list) getcurselection]
  1066.     clear entry
  1067.     $itk_component(entry) insert 0 $item
  1068.     switch -- $itk_option(-editable) {
  1069.     0 - false - no - off {
  1070.         $itk_component(entry) configure -state disabled
  1071.     }
  1072.     }
  1073. }
  1074.  
  1075. # ------------------------------------------------------
  1076. # PROTECTED METHOD:     _toggleList
  1077. #
  1078. # Post or unpost the dropdown listbox (toggle).
  1079. #
  1080. # ------------------------------------------------------
  1081. itcl::body iwidgets::Combobox::_toggleList {} {
  1082.     if {[winfo ismapped $itk_component(popup)] } {
  1083.     _unpostList
  1084.     } else {
  1085.     _postList
  1086.     }
  1087. }
  1088.  
  1089. # ------------------------------------------------------
  1090. # PROTECTED METHOD:      _unpostList
  1091. #
  1092. # Unmap the listbox (pop it down).
  1093. #
  1094. # ------------------------------------------------------
  1095. itcl::body iwidgets::Combobox::_unpostList {} {
  1096.     # Determine if event occured in the scrolledlistbox and, if it did, 
  1097.     # don't unpost it. (A selection in the list unposts it correctly and 
  1098.     # in the scrollbar we don't want to unpost it.)
  1099.     set x [winfo x $itk_component(list)]
  1100.     set y [winfo y $itk_component(list)]
  1101.     set w [winfo width $itk_component(list)]
  1102.     set h [winfo height $itk_component(list)]
  1103.  
  1104.     wm withdraw $itk_component(popup)
  1105.     ::grab release $itk_component(popup)    
  1106.  
  1107.     # Added by csmith, 12/19/00.  Thanks to Erik Leunissen for finding
  1108.     # this problem.  We need to restore any previous grabs when the
  1109.     # dropdown listbox is unmapped.
  1110.     if {$_grab(window) != ""} {
  1111.       if {$_grab(status) == "global"} {
  1112.         ::grab -global $_grab(window)
  1113.       } else {
  1114.     ::grab $_grab(window)
  1115.       }
  1116.       set _grab(window) ""
  1117.       set _grab(status) ""
  1118.     }
  1119.  
  1120.     # Added by csmith, 10/26/00.  This binding resets the binding
  1121.     # created in _postList - see that method for further details.
  1122.     bind $itk_component(entry) <Unmap> {}
  1123.     
  1124.     set _isPosted false
  1125.     
  1126.     $itk_component(list) selection clear 0 end
  1127.     if {$_currItem != {}} {
  1128.     $itk_component(list) selection set $_currItem $_currItem
  1129.     $itk_component(list) activate $_currItem
  1130.     }
  1131.  
  1132.     switch -- $itk_option(-editable) {
  1133.     1 - true - yes - on {
  1134.         $itk_component(entry) configure -state normal
  1135.     }
  1136.     0 - false - no - off {
  1137.         $itk_component(entry) configure -state disabled
  1138.     }
  1139.     }
  1140.  
  1141.     _drawArrow
  1142.     update
  1143. }
  1144.  
  1145. # ------------------------------------------------------
  1146. # PROTECTED METHOD:      _commonBindings
  1147. #
  1148. # Bindings that are used by both simple and dropdown
  1149. # style Comboboxes.
  1150. #
  1151. # ------------------------------------------------------
  1152. itcl::body iwidgets::Combobox::_commonBindings {} {
  1153.     bind $itk_component(entry) <KeyPress-BackSpace> [itcl::code $this _bs]
  1154.     bind $itk_component(entry) <KeyRelease> [itcl::code $this _lookup %K]
  1155.     bind $itk_component(entry) <Down>       [itcl::code $this _next]
  1156.     bind $itk_component(entry) <Up>         [itcl::code $this _previous]
  1157.     bind $itk_component(entry) <Control-n>  [itcl::code $this _next]
  1158.     bind $itk_component(entry) <Control-p>  [itcl::code $this _previous]
  1159.     bind [_slbListbox]         <Control-n>  [itcl::code $this _next]
  1160.     bind [_slbListbox]         <Control-p>  [itcl::code $this _previous]
  1161. }
  1162.  
  1163.  
  1164. # ------------------------------------------------------
  1165. # PROTECTED METHOD: _dropdownBindings
  1166. #
  1167. # Bindings used only by the dropdown type Combobox.
  1168. #
  1169. # ------------------------------------------------------
  1170. itcl::body iwidgets::Combobox::_dropdownBindings {} {
  1171.     bind $itk_component(popup)  <Escape> [itcl::code $this _unpostList]
  1172.     bind $itk_component(popup)  <space>  \
  1173.     "[itcl::code $this _stateSelect]; [itcl::code $this _unpostList]"
  1174.     bind $itk_component(popup)  <Return> \
  1175.     "[itcl::code $this _stateSelect]; [itcl::code $this _unpostList]"
  1176.     bind $itk_component(popup)  <ButtonRelease-1> \
  1177.         [itcl::code $this _dropdownBtnRelease %W %x %y]
  1178.  
  1179.     bind $itk_component(list)  <Map> \
  1180.     [itcl::code $this _listShowing 1]
  1181.     bind $itk_component(list)  <Unmap> \
  1182.         [itcl::code $this _listShowing 0]
  1183.  
  1184.     # once in the listbox, we drop on the next release (unless in scrollbar)
  1185.     bind [_slbListbox]   <Enter>   \
  1186.     [itcl::code $this _ignoreNextBtnRelease false]
  1187.  
  1188.     bind $itk_component(arrowBtn) <3>          [itcl::code $this _next]
  1189.     bind $itk_component(arrowBtn) <Shift-3>    [itcl::code $this _previous]
  1190.     bind $itk_component(arrowBtn) <Down>       [itcl::code $this _next]
  1191.     bind $itk_component(arrowBtn) <Up>         [itcl::code $this _previous]
  1192.     bind $itk_component(arrowBtn) <Control-n>  [itcl::code $this _next]
  1193.     bind $itk_component(arrowBtn) <Control-p>  [itcl::code $this _previous]
  1194.     bind $itk_component(arrowBtn) <Shift-Down> [itcl::code $this _toggleList]
  1195.     bind $itk_component(arrowBtn) <Shift-Up>   [itcl::code $this _toggleList]
  1196.     bind $itk_component(arrowBtn) <Return>     [itcl::code $this _toggleList]
  1197.     bind $itk_component(arrowBtn) <space>      [itcl::code $this _toggleList]
  1198.  
  1199.     bind $itk_component(entry)    <Configure>  [itcl::code $this _resizeArrow]
  1200.     bind $itk_component(entry)    <Shift-Down> [itcl::code $this _toggleList]
  1201.     bind $itk_component(entry)    <Shift-Up>   [itcl::code $this _toggleList]
  1202. }
  1203.  
  1204. # ------------------------------------------------------
  1205. # PROTECTED METHOD: _simpleBindings
  1206. #
  1207. # Bindings used only by the simple type Comboboxes.
  1208. #
  1209. # ------------------------------------------------------
  1210. itcl::body iwidgets::Combobox::_simpleBindings {} {
  1211.     bind [_slbListbox]         <ButtonRelease-1> [itcl::code $this _stateSelect]
  1212.     bind [_slbListbox]         <space>     [itcl::code $this _stateSelect]
  1213.     bind [_slbListbox]         <Return>    [itcl::code $this _stateSelect]
  1214.     bind $itk_component(entry) <Escape>     ""
  1215.     bind $itk_component(entry) <Shift-Down> ""
  1216.     bind $itk_component(entry) <Shift-Up>   ""
  1217.     bind $itk_component(entry) <Configure>  ""
  1218. }
  1219.  
  1220. # ------------------------------------------------------
  1221. # PROTECTED METHOD: _listShowing ?val?
  1222. #
  1223. # Used instead of "tkwait visibility" to make sure that
  1224. # the dropdown list is visible.     Whenever the list gets
  1225. # mapped or unmapped, this method is called to keep
  1226. # track of it.    When it is called with the value "-wait",
  1227. # it waits for the list to be mapped.
  1228. # ------------------------------------------------------
  1229. itcl::body iwidgets::Combobox::_listShowing {{val ""}} {
  1230.     if {$val == ""} {
  1231.     return $_listShowing($this)
  1232.     } elseif {$val == "-wait"} {
  1233.     while {!$_listShowing($this)} {
  1234.         tkwait variable [itcl::scope _listShowing($this)]
  1235.     }
  1236.     return
  1237.     }
  1238.     set _listShowing($this) $val
  1239. }
  1240.  
  1241. # ------------------------------------------------------
  1242. # PRIVATE METHOD:     _slbListbox
  1243. #
  1244. # Access the tk listbox window out of the scrolledlistbox.
  1245. #
  1246. # ------------------------------------------------------
  1247. itcl::body iwidgets::Combobox::_slbListbox {} {
  1248.     return [$itk_component(list) component listbox]
  1249. }
  1250.  
  1251. # ------------------------------------------------------
  1252. # PRIVATE METHOD:     _stateSelect
  1253. #
  1254. # only allows a B1 release in the listbox to have an effect if -state is
  1255. #    normal.
  1256. #
  1257. # ------------------------------------------------------
  1258. itcl::body iwidgets::Combobox::_stateSelect {} {
  1259.     switch --  $itk_option(-state) {
  1260.     normal {
  1261.         [itcl::code $this _selectCmd]
  1262.     }
  1263.     }
  1264. }
  1265.  
  1266. # ------------------------------------------------------
  1267. # PRIVATE METHOD:     _bs
  1268. #
  1269. # A part of the auto-completion code, this function sets a flag when the
  1270. #    Backspace key is hit and there is a selection in the entry field.
  1271. # Note that it's probably buggy to assume that a selection being present
  1272. #    means that that selection came from auto-completion.
  1273. #
  1274. # ------------------------------------------------------
  1275. itcl::body iwidgets::Combobox::_bs {} {
  1276.     #
  1277.     #        exit if completion is turned off
  1278.     #
  1279.     switch -- $itk_option(-completion) {
  1280.     0 - no - false - off {
  1281.         return
  1282.     }
  1283.     }
  1284.     #
  1285.     #        critical section flag.  it ain't perfect, but for most usage it'll
  1286.     #        keep us from being in this code "twice" at the same time
  1287.     #        (auto-repeated keystrokes are a pain!)
  1288.     #
  1289.     if {$_inbs} {
  1290.     return
  1291.     } else {
  1292.     set _inbs 1
  1293.     }
  1294.  
  1295.     #
  1296.     #        set the _doit flag if there is a selection set in the entry field
  1297.     #
  1298.     set _doit 0
  1299.     if [$itk_component(entry) selection present] {
  1300.     set _doit 1
  1301.     }
  1302.  
  1303.     #
  1304.     #        clear the semaphore and return
  1305.     #
  1306.     set _inbs 0
  1307. }
  1308.  
  1309. # ------------------------------------------------------
  1310. # PRIVATE METHOD:     _lookup
  1311. #
  1312. # handles auto-completion of text typed (or insert'd) into the entry field.
  1313. #
  1314. # ------------------------------------------------------
  1315. itcl::body iwidgets::Combobox::_lookup {key} {
  1316.  
  1317.     #
  1318.     # Don't process auto-completion stuff if navigation key was released
  1319.     # Fixes SF bug 501300
  1320.     #
  1321.     if {$_next_prevFLAG} {
  1322.         set _next_prevFLAG 0
  1323.         return
  1324.     }
  1325.  
  1326.     #
  1327.     #        exit if completion is turned off
  1328.     #
  1329.     switch -- $itk_option(-completion) {
  1330.     0 - no - false - off {
  1331.         return
  1332.     }
  1333.     }
  1334.  
  1335.     #
  1336.     #        critical section flag.  it ain't perfect, but for most usage it'll
  1337.     #        keep us from being in this code "twice" at the same time
  1338.     #        (auto-repeated keystrokes are a pain!)
  1339.     #
  1340.     if {$_inlookup} {
  1341.     return
  1342.     } else {
  1343.     set _inlookup 1
  1344.     }
  1345.  
  1346.     #
  1347.     #        if state of megawidget is disabled, or the entry is not editable,
  1348.     #        clear the semaphore and exit
  1349.     #
  1350.     if {$itk_option(-state) == "disabled" \
  1351.         || [lsearch {on 1 true yes} $itk_option(-editable)] == -1} {
  1352.     set _inlookup 0
  1353.     return
  1354.     }
  1355.  
  1356.     #
  1357.     #        okay, *now* we can get to work
  1358.     #        the _bs function is called on keyPRESS of BackSpace, and will set
  1359.     #        the _doit flag if there's a selection set in the entryfield.  If
  1360.     #        there is, we're assuming that it's generated by completion itself
  1361.     #        (this is probably a Bad Assumption), so we'll want to whack the
  1362.     #        selected text, as well as the character immediately preceding the
  1363.     #        insertion cursor.
  1364.     #
  1365.     if {$key == "BackSpace"} {
  1366.     if {$_doit} {
  1367.         set first [expr {[$itk_component(entry) index insert] -1}]
  1368.         $itk_component(entry) delete $first end
  1369.         $itk_component(entry) icursor $first
  1370.     }
  1371.     }
  1372.  
  1373.     #
  1374.     #        get the text left in the entry field, and its length.  if
  1375.     #        zero-length, clear the selection in the listbox, clear the
  1376.     #        semaphore, and boogie.
  1377.     #
  1378.     set text [get]
  1379.     set len [string length $text]
  1380.     if {$len == 0} {
  1381.     $itk_component(list) selection clear 0 end
  1382.     set _inlookup 0
  1383.     return
  1384.     }
  1385.  
  1386.     # No need to do lookups for Shift keys or Arrows.  The up/down
  1387.     # arrow keys should walk up/down the listbox entries.
  1388.     switch $key {
  1389.       Shift_L - Shift_R - Up - Down - Left - Right {
  1390.         set _inlookup 0
  1391.         return
  1392.       }
  1393.       default { }
  1394.     }
  1395.  
  1396.     # Added by csmith 12/11/01 to resolve SF ticket #474817.  It's an unusual
  1397.     # circumstance, but we need to make sure the character passed into this
  1398.     # method matches the last character in the entry's text string.  It's
  1399.     # possible to type fast enough that the _lookup method gets invoked
  1400.     # *after* multiple characters have been typed and *before* the first
  1401.     # character has been processed.  For example, you can type "bl" very
  1402.     # quickly, and by the time the interpreter processes "b", the "l" has
  1403.     # already been placed in the entry field.  This causes problems as noted
  1404.     # in the SF ticket.
  1405.     #
  1406.     # Thus, if the character currently being processed does not match the
  1407.     # last character in the entry field, reset the _inlookup flag and return.
  1408.     # Also, note that we're only concerned with single characters here, not
  1409.     # keys such as backspace, delete, etc.
  1410.     if {$key != [string range $text end end] && [string match ? $key]} {
  1411.       set _inlookup 0
  1412.       return
  1413.     }
  1414.  
  1415.     #
  1416.     #        okay, so we have to do a lookup.  find the first match in the
  1417.     #        listbox to the text we've got in the entry field (glob).
  1418.     #        if one exists, clear the current listbox selection, and set it to
  1419.     #        the one we just found, making that one visible in the listbox.
  1420.     #        then, pick off the text from the listbox entry that hadn't yet been
  1421.     #        entered into the entry field.  we need to tack that text onto the
  1422.     #        end of the entry field, select it, and then set the insertion cursor
  1423.     #        back to just before the point where we just added that text.
  1424.     #        if one didn't exist, then just clear the listbox selection
  1425.     #
  1426.     set item [lsearch [$itk_component(list) get 0 end] "$text*" ]
  1427.     if {$item != -1} {
  1428.     $itk_component(list) selection clear 0 end
  1429.     $itk_component(list) selection set $item $item
  1430.     see $item
  1431.     set remainder [string range [$itk_component(list) get $item] $len end]
  1432.     $itk_component(entry) insert end $remainder
  1433.     $itk_component(entry) selection range $len end
  1434.     $itk_component(entry) icursor $len
  1435.     } else {
  1436.     $itk_component(list) selection clear 0 end
  1437.     }
  1438.     #
  1439.     #        clear the semaphore and return
  1440.     #
  1441.     set _inlookup 0
  1442.     return
  1443. }
  1444.