source: tol/tolbaseBLT/lib/toltk/fusearch.tcl @ 56ade3b

1941-docker-image-to-testdevel
Last change on this file since 56ade3b was 56ade3b, checked in by Jorge Pérez <josp.jorge@…>, 10 years ago

fixes #1932, se ha creado la rama trunk/tolbaseBLT copia de trunk/tolbase

git-svn-id: ​https://www.tol-project.org/svn/tolp/trunk@7330 be4846ae-f051-483a-831f-b64e7d08527f
  • Property mode set to 100644
File size: 22.2 KB
Line 
1#/////////////////////////////////////////////////////////////////////////////
2# FILE    : fusearch.tcl
3# PURPOSE : This file contains a namespace called funcSearch with its
4#           functions. It's for creating a form that allows to look for a
5#           function giving some parameters: name, grammar, parameters,
6#           description, etc.
7#/////////////////////////////////////////////////////////////////////////////
8
9
10#/////////////////////////////////////////////////////////////////////////////
11# TESTING
12#/////////////////////////////////////////////////////////////////////////////
13# Put if {1} for testing this file.
14if {0} {
15  package require Tk
16  package require BWidget
17  # force BWidget autoload
18  Bitmap::use
19  set toltk_script_path [file dirname [info script]]
20  set toltk_images_path [file join ${toltk_script_path} images]
21  if { [lsearch $Bitmap::path $toltk_images_path] == -1 } {
22    lappend Bitmap::path [file join $toltk_script_path images]
23  }
24  package require msgcat
25  namespace import msgcat::*
26  ::msgcat::mclocale es
27  ::msgcat::mcload [file join $toltk_script_path msgs]
28 
29  source [file join $toltk_script_path "mclistbox.tcl"]
30  namespace import ::mclistbox::*
31}
32
33package require blistboxplus
34package require beditselector
35
36
37#/////////////////////////////////////////////////////////////////////////////
38namespace eval funcSearch {
39#
40# PURPOSE: The purpose of this namespace is organize code and functions.
41#          It also stotres a special namespace is created for each instance
42#          of funcSearch.
43# VARIABLES:
44#   tmpOpt -> array with information functions search
45#     grammars,PRO -> procedure created for grammar editSelector
46#     var,grammars -> grammars of searched function
47#     var,name     -> name's substring of searched function
48#     var,numPars  -> numbers of params of searched function
49#     var,desc     -> description's substring of searched function
50#     var,par$i,grammar -> grammar of any param of searched function
51#     var,par$i,name    -> name's substring of any param of searched function
52#     widget,res   -> mclistbox path where results are shown
53#   iniconfig -> name of funcSearch in ini file
54#   widget -> contains the widget
55#     widget(fr) -> Main frame of the document
56#   sensitive -> has a value 1 if the user has selected case sensitive search
57#
58#/////////////////////////////////////////////////////////////////////////////
59  variable tmpOpt
60  variable widget
61  variable sensitive
62  variable iniconfig
63}
64
65
66#/////////////////////////////////////////////////////////////////////////////
67proc ::funcSearch::Show {} {
68#
69# PURPOSE: Shows the function search dialog
70#
71#/////////////////////////////////////////////////////////////////////////////
72  variable widget   
73  if { [info exist widget(document)] && [winfo exists $widget(document)] } {
74    if { [$widget(document) cget -state] eq "minimized" } {
75      $widget(document) restore
76    }
77    $widget(document) raise
78  } else {
79    Create
80  }
81}
82
83
84#/////////////////////////////////////////////////////////////////////////////
85proc ::funcSearch::Create {} {
86#
87# PURPOSE: Creates the function search dialog
88#
89# PARAMETERS:
90#   path: path of dialgo's parent
91#
92#/////////////////////////////////////////////////////////////////////////////
93  global toltk_options
94  variable tmpOpt
95  variable widget
96  variable sensitive
97  variable iniconfig
98 
99  # Name of function search's section in ini file
100  set iniconfig "FunctionSearch"
101   
102  # Create the widget
103  set widget(document) [::project::CreateForm \
104    -iniconfig $iniconfig -title [mc "Functions Search"] \
105    -helpkey "Tb4Fus" -closecmd [list ::funcSearch::Destroy]]
106  set widget(fr) [$widget(document) getframe]
107           
108  label $widget(fr).limg -image [::Bitmap::get search]
109  label $widget(fr).lfind -text [mc "Search functions"]... \
110                 -font $toltk_options(fonts,Title1)
111   
112  # Obtain the complete list of grammars
113  set lst [::tol::info grammars]
114  set txt [mc "of grammars"]:
115  # Beditselector of grammars
116  set tmpOpt(grammars,PRO) [beditselector $widget(fr).bes -label $txt \
117                -list $lst -width 30 -readonly false -readonly true ]
118  set lgra [$tmpOpt(grammars,PRO) get label]
119  set egra [$tmpOpt(grammars,PRO) get entry]
120  set bgra [$tmpOpt(grammars,PRO) get button]
121   
122  # Criteria search by name
123  label $widget(fr).lname -text [mc "whose name contains"]:
124  entry $widget(fr).ename -width 18 -textvariable ::funcSearch::tmpOpt(var,name)
125  bind  $widget(fr).ename <Return> [list ::funcSearch::Search]
126  bind  $widget(fr).ename <Control-g> [list ::funcSearch::Search]
127
128  # Criteria search by description   
129  label $widget(fr).ldesc -text [mc "whose description contains"]:
130  entry $widget(fr).edesc -width 18 -textvariable ::funcSearch::tmpOpt(var,desc)
131  bind  $widget(fr).edesc <Return> [list ::funcSearch::Search ]
132  bind  $widget(fr).edesc <Control-g> [list ::funcSearch::Search ]
133
134  # Case sensitive search 
135  checkbutton $widget(fr).cs -text [mc "Case sensitive"] \
136                    -variable ::funcSearch::sensitive
137
138  # Scrolled window for criteria search by params. NOT IMPLEMENTED
139if {0} { 
140  set sw [ScrolledWindow $widget(fr).sw]
141  #set sf [ScrollableFrame $w.sw.fr -constrainedwidth 1 -height 80 -width 560]
142  set sf [ScrollableFrame $widget(fr).sw.fr -constrainedwidth 0 -height 80 -width 560]
143  $sw setwidget $sf
144  set fr [$sf getframe]   
145  label $widget(fr).lpars -text [mc "and with at least"]
146  frame $widget(fr).fg
147  set widget(spinbox) [SpinBox $widget(fr).fg.sbpars -range {0 8} -width 4 \
148          -justify right -editable false\
149          -textvariable ::funcSearch::tmpOpt(var,numPars) \
150          -modifycmd [list ::funcSearch::CheckPar $fr]]
151  label $widget(fr).fg.lpars -text [mc "parameters"]
152  #grid $w.fg.sbpars $w.fg.lpars -sticky nw -padx 2
153} 
154  # Button box with
155  set widget(bbox) \
156          [ButtonBox $widget(fr).bb -orient horizontal -spacing 10 \
157           -padx 0 -pady 0 -homogeneous false]
158  $widget(bbox) add -text [mc "Find"] -relief link \
159          -helptext "[mc "Find"] (Ctrl+G)" -image [::Bitmap::get bfind] \
160          -compound left -padx 5 -pady 1 -command [list ::funcSearch::Search]
161  $widget(bbox) add  -relief link -helptext [mc "Cancel"] \
162          -image [::Bitmap::get cancelx] -text [mc Cancel] \
163          -compound left -padx 5 -pady 1 -command [list ::funcSearch::Destroy]
164
165  Separator $widget(fr).sep -orient horizontal -relief ridge
166 
167  # Grid of results
168  set f [frame $widget(fr).fres -bd 2]
169   
170  scrollbar $f.sy -command "$f.mclbres yview"
171  scrollbar $f.sx -orient horizontal -command "$f.mclbres xview"
172  set name        [mc "Name"]
173  set content     [mc "Content"]
174  set path        [mc "Path"]
175  set description [mc "Description"]     
176   
177  set tmpOpt(widget,res) [blistboxplus $f.mclbres \
178      -cols "$name $content $path $description"\
179      -background white -yscrollcommand "$f.sy set" \
180      -xscrollcommand "$f.sx set" -selectmode multiple -background white \
181      -highlightthickness 0 -borderwidth 2 -linewidth 2 \
182      -exportselection false -border 0 -height 0 -readonly true \
183      -colkeypress $name]
184
185  set lb $tmpOpt(widget,res)
186  set lbMenu [$lb getMenu]
187 
188  $lbMenu insert 0 separator
189  $lbMenu insert 0 command -label [mc "View definition"] \
190            -command  [list ::funcSearch::ViewDefinition] -accelerator CTRL+W
191         
192  # binds of listboxplus
193  $tmpOpt(widget,res) bind all <Control-KeyRelease> \
194    +[list ::funcSearch::OnControlKey $tmpOpt(widget,res) %K %k]
195 
196  # blisboxplus auto-adjust width of columns without configured width
197  #$lb column configure [mc "Name"]        -width [expr 18*7]
198  #$lb column configure [mc "Content"]     -width [expr 35*7]
199  $lb column configure [mc "Path"]        -width [expr 15*7]
200   
201  grid $f.mclbres      -sticky news
202   
203  grid columnconfigure $f 0 -weight 1
204  grid rowconfigure    $f 0 -weight 1
205
206  frame $widget(fr).f                                                            -width 25
207  grid  $widget(fr).limg $widget(fr).lfind -                 -                 - -sticky nw -pady 5
208  grid  ^                $widget(fr).f     $widget(fr).bes   -                 - -sticky nw -pady 0 -padx 1
209  grid  ^                ^                 $widget(fr).lname $widget(fr).ename - -sticky nw -pady 1
210  grid  ^                ^                 $widget(fr).ldesc $widget(fr).edesc - -sticky nw -pady 1
211  grid  ^                ^                 $widget(fr).cs    -                 - -sticky nw -pady 1
212  grid  ^                ^                 $widget(bbox)     -                 - -sticky nws
213  grid  $widget(fr).sep  -                 -                 -                 - -sticky new -pady 5
214  grid  $widget(fr).fres -                 -                 -                 - -sticky news 
215
216  grid columnconfigure $widget(fr) 4 -weight 1
217  grid rowconfigure    $widget(fr) 7 -weight 1
218 
219  # establish initial focus
220  focus $widget(fr).ename
221 
222  ::funcSearch::ReadIni       
223}
224
225
226#/////////////////////////////////////////////////////////////////////////////
227proc ::funcSearch::OnControlKey {_lb keysym keycode } {
228#
229# PURPOSE: Control of the binds of accelerator keys of listbox
230#
231# PARAMETERS: _lb -> self
232#             keysym -> The keysym corresponding to the event,
233#                       substituted as a textual string
234#             keycode -> The keycode field from the event
235#
236#/////////////////////////////////////////////////////////////////////////////
237  switch [string toupper $keysym] {
238    G {
239      ::funcSearch::Search
240      }
241    W {
242      ::funcSearch::ViewDefinition
243    }
244  }
245} 
246
247#/////////////////////////////////////////////////////////////////////////////
248proc ::funcSearch::ViewDefinition { } {
249#
250# PURPOSE: Show the file and function selected on results listbox. It works
251#          only when an unique function has been selected.
252#
253#/////////////////////////////////////////////////////////////////////////////
254  variable tmpOpt
255
256  set lb $tmpOpt(widget,res)
257  set lbMenu [$lb getMenu]
258  # rows selected
259  set lbrow [$lb selection get]
260  # verifies that only a column has been selected
261  if {[llength $lbrow] == 1 } {
262    set selected [$lb get $lbrow]    ;# get his content   
263    set objName [lindex $selected 0] ;# name of function
264    set path [lindex $selected 2]    ;# path of function   
265    # verifies if that function has path
266    if {$path != ""} {
267      # the grammar is the first element of column content
268      set grammar [lindex [lindex $selected 1] 0]
269      # call to ViewDefinition
270      ::TolInspector::ViewDefinition $objName $path $grammar
271    } else {
272      tk_messageBox -type ok -icon warning\
273        -message [mc "Object %1\$s is not defined in a tol file" $objName]\
274        -parent $tmpOpt(widget,res) -title [mc Warning]
275    }
276  }
277}
278
279
280#/////////////////////////////////////////////////////////////////////////////
281proc ::funcSearch::Search {} {
282#
283# PURPOSE: Looks for all functions that matches the criteriums introduced in
284#          search dialog, shows the results and hides the dialog.
285#
286# PARAMETERS:
287#    dialog: Functions search  path
288#
289#/////////////////////////////////////////////////////////////////////////////
290  variable tmpOpt
291  variable sensitive
292  variable widget
293 
294  set search 0
295  set tmpOpt(var,grammars) [$tmpOpt(grammars,PRO) cget -sel]
296
297  # Verify that the search can be made
298  if { $tmpOpt(var,grammars) == "" } {
299    set search 1 ;# There isn't grammars where search
300  }
301  if { ($tmpOpt(var,name) == "") && ($tmpOpt(var,desc) == "") } {
302    set search 2 ;# There aren't sufficient criteria search
303  }
304  if { [ catch { regexp "(.*)$tmpOpt(var,name)(.*)" "dummysrting" } ] } {
305     set search 3 ;# Criteria search for the name are incorrect
306  }
307  if { [ catch { regexp "(.*)$tmpOpt(var,desc)(.*)" "dummysrting" } ] } {
308     set search 4 ;# Criteria search for the description are incorrect
309  } 
310  if {$search == 0} {  ;# The search can be made
311    . configure -cursor watch
312    update
313    if {$sensitive} { ;# Case sensitive search
314      # Verify grammars and names of functions
315      foreach gra $tmpOpt(var,grammars) {     
316        set result($gra) [::tol::info functions $gra]
317        foreach f $result($gra) {
318          if {![regexp "(.*)$tmpOpt(var,name)(.*)" $f]} {               
319            set pos [lsearch $result($gra) $f]
320            set result($gra) [lreplace $result($gra) $pos $pos]
321          }
322        }
323      }   
324      # Verify if the functions are in the included files     
325      set resultIncluded [::tol::info var Code]
326      foreach f $resultIncluded {
327        set fU [string toupper $f]
328        if {![regexp "(.*)$tmpOpt(var,name)(.*)" $f]} {
329          set pos [lsearch $resultIncluded $f]
330          set resultIncluded [lreplace $resultIncluded $pos $pos]
331        }
332      }
333      # discard duplicated functions
334      set resultIncludedNoDup ""
335      foreach func $resultIncluded {
336        set dup 0 ;# no duplicated
337        foreach gra $tmpOpt(var,grammars) {
338          if { [lsearch -exact $result($gra) $func] != -1 } {
339            set dup 1
340          }
341        }
342        if {$dup == 0} { ;# it is inserted if it isn't duplicate
343          lappend resultIncludedNoDup $func
344        }
345      }
346      # Look for in the description and I keep name, content, path
347      # and description
348      set funcs ""
349      foreach gra [array names result] {
350        foreach f $result($gra) {
351          set inf [TclInfoFun $gra $f]
352          # Verify description
353          if {[regexp "(.*)$tmpOpt(var,desc)(.*)" [lindex $inf 3]]} {
354            lappend funcs \
355              [list $f [lindex $inf 5] [lindex $inf 1] [lindex $inf 3]]
356          }
357        }
358      }
359      # For the functions on inluded files, search in the description,
360      # I verify the type of the function, and keep name, content, path 
361      # and description
362      set funcsIncluded ""
363      foreach f $resultIncludedNoDup {       
364        set inf [::tol::info var [list Code $f]]
365                #puts "funcSearch::Search: inf = $inf"
366        if { [ContentCodeGrammar [array names result] [lindex $inf 2] ] } {
367          if {[regexp "(.*)$tmpOpt(var,desc)(.*)" [lindex $inf 4]]} {
368            lappend funcsIncluded \
369              [list $f [lindex $inf 2] [lindex $inf 3] [lindex $inf 4]]
370          }
371        }
372      }
373    # No case sensitive search
374    } else {
375      set tU  "[string toupper $tmpOpt(var,grammars) ]"
376      # Verify grammars and names of functions
377      foreach gra $tmpOpt(var,grammars) {     
378        set result($gra) [::tol::info functions $gra]
379        foreach f $result($gra) {
380          set rU [string toupper $result($gra)]
381          set fU [string toupper $f]
382          set tU [string toupper $tmpOpt(var,name)]
383          if {![regexp "(.*)${tU}(.*)" $fU]} {
384            set pos [lsearch $result($gra) $f]
385            set result($gra) [lreplace $result($gra) $pos $pos]
386          }
387        }
388      }
389     
390      # Verify if the functions are in the included archives     
391      set resultIncluded [::tol::info var Code]   
392      foreach f $resultIncluded {
393        set fU [string toupper $f]
394        if {![regexp "(.*)${tU}(.*)" $fU]} {
395          set pos [lsearch $resultIncluded $f]
396          set resultIncluded [lreplace $resultIncluded $pos $pos]
397        }
398      }
399      # discard duplicated functions
400      set resultIncludedNoDup ""
401      foreach func $resultIncluded {
402        set dup 0 ;# no duplicated
403        foreach gra $tmpOpt(var,grammars) {
404          if { [lsearch -exact $result($gra) $func] != -1 } {
405            set dup 1
406          }
407        }
408        if {$dup == 0} { ;# it is inserted if it isn't duplicate
409          lappend resultIncludedNoDup $func
410        }
411      }
412      # Look for in the description and I keep name, content, path
413      # and description
414      set funcs ""
415      foreach gra [array names result] {
416        foreach f $result($gra) {             
417          set inf [TclInfoFun $gra $f]         
418          set iU [string toupper $inf]
419          set tU [string toupper $tmpOpt(var,desc)]
420          if {[regexp "(.*)${tU}(.*)" [lindex $iU 3]]} {
421            #Tolcon_Trace "Content: [lindex $inf 0]"
422            lappend funcs \
423              [list $f [lindex $inf 5] [lindex $inf 1] [lindex $inf 3]]
424          }
425        }
426      }
427      # For the functions on inluded files, search in the description,
428      # I verify the type of the function, and keep name, content, path 
429      # and description
430      set funcsIncluded ""
431      foreach f $resultIncludedNoDup {     
432        set inf [::tol::info var [list Code $f]]
433                #puts "funcSearch::Search: inf = $inf"
434        set iU [string toupper $inf]
435        set tU [string toupper $tmpOpt(var,desc)]
436        if { [ContentCodeGrammar [array names result] [lindex $inf 2] ] } {
437          if {[regexp "(.*)${tU}(.*)" [lindex $iU 4]]} {
438            lappend funcs \
439              [list $f [lindex $inf 2] [lindex $inf 3] [lindex $inf 4]]
440          }
441        } 
442      }
443    }
444    . configure -cursor ""
445    update
446    set some [ShowResults $funcs $funcsIncluded]
447    if { $some eq 0 } {
448      tk_messageBox -type ok -icon info\
449        -message [mc "Has not been any coincident result"]\
450        -parent $tmpOpt(widget,res) -title [mc Message]
451    }
452  } else {
453    # Show the error messages
454    switch -exact -- $search {
455    1 {
456      tk_messageBox -type ok -icon warning\
457        -message [mc "There isn't grammars where search"]\
458        -parent $tmpOpt(widget,res) -title [mc Warning]
459      }
460    2 {
461      tk_messageBox -type ok -icon warning\
462        -message [mc "There aren't sufficient criteria search"]\
463        -parent $tmpOpt(widget,res) -title [mc Warning]
464      }
465    3 {
466      tk_messageBox -type ok -icon warning\
467        -message [mc "Criteria search for the name are incorrect"]\
468        -parent $tmpOpt(widget,res) -title [mc Warning]
469      }
470    4 {
471      tk_messageBox -type ok -icon warning\
472        -message [mc "Criteria search for the description are incorrect"]\
473        -parent $tmpOpt(widget,res) -title [mc Warning]
474      }
475    }
476  }
477}
478
479
480
481#/////////////////////////////////////////////////////////////////////////////
482proc ::funcSearch::ContentCodeGrammar {gr content} {
483#
484# PURPOSE: Return if a description of a grammar is of the type indicated
485#          in a list of grammars
486#
487# PARAMETERS:
488#   gr : List of grammars
489#   content: Description of function. His first word will be the grammar.
490#         
491# RETURN: Return 1 if the first word in content is of the list of grammar.
492#
493#/////////////////////////////////////////////////////////////////////////////
494  set hasit 0
495  set grammarContent [lindex $content 0]
496  foreach g $gr {
497    if {$g == $grammarContent} {
498      set hasit 1
499    }
500  }
501  return $hasit
502}
503
504
505#/////////////////////////////////////////////////////////////////////////////
506proc ::funcSearch::ShowResults {funcs funcsIncluded} {
507#
508# PURPOSE:
509#
510# PARAMETERS:
511#   funcs: List of functions of Tol grammars that match the search criteriums
512#   funcsIncluded: List of functions of included files that match the search
513#                  criteriums
514# RETURN: 1 if has been some result, 0 in opposite case
515#
516#/////////////////////////////////////////////////////////////////////////////
517  variable tmpOpt       
518  set some 0
519  set lb $tmpOpt(widget,res)   
520  $lb clear
521  foreach funInfo $funcs {
522    $lb insert end $funInfo
523    set some 1
524  }   
525  foreach funInfo $funcsIncluded {
526    $lb insert end $funInfo
527    set some 1
528  }   
529  return $some
530}
531
532
533#/////////////////////////////////////////////////////////////////////////////
534proc ::funcSearch::Destroy {} {
535#
536# PURPOSE: Hides functions search document.
537#
538#/////////////////////////////////////////////////////////////////////////////
539  variable widget
540  variable tmpOpt
541  ::funcSearch::WriteIni
542  array unset tmpOpt
543  destroy $widget(document)
544  array unset widget
545  return 1
546}
547
548
549#/////////////////////////////////////////////////////////////////////////////
550proc ::funcSearch::CheckPar {f} {
551#
552# PURPOSE: Function that checks that a certain fuction has at least a number
553#          of parameters. NOT IMPLEMENTED.
554#
555# PARAMETERS:
556#   f: Function to evaluate.
557#
558#/////////////////////////////////////////////////////////////////////////////
559  variable tmpOpt
560  variable widget   
561   
562  set lst [::tol::info grammars]
563  #puts "lst: $lst"
564  set num $tmpOpt(var,numPars)
565  #puts "num: $num"
566  # NO funciona correctamente
567  #  for {set i 1} {$i <= [expr $num+1]} {incr i} {
568  #    destroy $f.f$i $f.lt$i $f.lb$i $f.lc$i $f.e$i
569  #  }
570  # destruimos los elementos hasta el maximo de elementos que pueda contener
571  #puts " rango: [lindex [$widget(spinbox) cget -range] 1]"
572  for {set i 1} {$i <= [lindex [$widget(spinbox) cget -range] 1]} {incr i} {
573      destroy $f.f$i $f.lt$i $f.lb$i $f.lc$i $f.e$i
574  }
575  for {set i 1} {$i <= $num} {incr i} {
576    frame    $f.f$i -width 15
577    label    $f.lt$i -text [mc "in which one is of type"]:
578    ComboBox $f.lb$i -values $lst -width 12 -height 5\
579             -textvariable ::funcSearch::tmpOpt(var,par$i,grammar)
580    label    $f.lc$i -text " [mc {and whose name contains}]:"
581    entry    $f.e$i -width 18 -textvariable ::funcSearch::tmpOpt(var,par$i,name)
582    grid $f.f$i $f.lt$i $f.lb$i $f.lc$i $f.e$i -sticky nw -pady 2
583 }
584 grid columnconfigure $f 4 -weight 1
585}
586
587
588#/////////////////////////////////////////////////////////////////////////////
589proc ::funcSearch::WriteIni {} {
590#
591# PURPOSE: Write in ini file the grammars selected
592#
593#/////////////////////////////////////////////////////////////////////////////
594  variable iniconfig
595  variable tmpOpt
596  set wini ::iniFile::Write
597  $wini $iniconfig grammars [$tmpOpt(grammars,PRO) curselection]
598}
599
600#/////////////////////////////////////////////////////////////////////////////
601proc ::funcSearch::ReadIni {} {
602#
603# PURPOSE: Read from ini file the grammars selected. If don't read any
604#          selected grammar, selects all grammars by default
605#
606#/////////////////////////////////////////////////////////////////////////////
607  variable iniconfig
608  variable tmpOpt
609  # read saved grammars
610  set rini ::iniFile::Read
611  set grammars [$rini $iniconfig grammars ""]
612  if {[llength $grammars] eq 0} {
613    # selects all grammars
614    $tmpOpt(grammars,PRO) selectAll
615  } else {
616    # gets the loaded grammars
617    $tmpOpt(grammars,PRO) configure -sel $grammars
618  }
619}
620
621
622#/////////////////////////////////////////////////////////////////////////////
623proc ::funcSearch::SearchWord { word } {
624#
625# PURPOSE: Performs a search of a word by name of functions
626#
627# PARAMETERS:
628#  dialog ->  Mdi child of function search
629#  word ->    Word to search
630#
631#/////////////////////////////////////////////////////////////////////////////
632  variable tmpOpt
633 
634  set tmpOpt(var,name) $word
635  ::funcSearch::Search
636}
Note: See TracBrowser for help on using the repository browser.