TKE  3.6
Advanced code editor for programmers
preferences Namespace Reference

Functions

 get name ?dflt?
 
 ref ?name?
 
 get_user_preference_file
 
 language_exists session language
 
 get_loaded ?session? ?language?
 
 update_prefs ?session?
 
 load_base_prefs
 
 load
 
 save_prefs session language data
 
 load_file ?language?
 
 delete_language_prefs session language
 
 add_plugin_prefs prefs
 
 load_session name data
 
 save_session name
 
 get_share_items dir
 
 share_changed dir
 

Function Documentation

§ add_plugin_prefs()

preferences::add_plugin_prefs   prefs  

Definition at line 386 of file preferences.tcl.

386  proc add_plugin_prefs {prefs} {
387 
388  variable loaded_prefs
389 
390  array set plugin_prefs $prefs
391  array set global_prefs $loaded_prefs(user,global)
392 
393  # Clean up the global_prefs array
394  foreach name [array names global_prefs Plugins/*] {
395  if {![info exists plugin_prefs($name)]} {
396  unset global_prefs($name)
397  } else {
398  unset plugin_prefs($name)
399  }
400  }
401 
402  # Add any new plugin preference values
403  array set global_prefs [array get plugin_prefs]
404 
405  # Replace the global user preferences
406  set loaded_prefs(user,global) [array get global_prefs]
407 
408  # Update the global user preferences
409  update_prefs
410 
411  }}

§ delete_language_prefs()

preferences::delete_language_prefs   session language  

Definition at line 361 of file preferences.tcl.

361  proc delete_language_prefs {session language} {
362 
363  variable preferences_dir
364  variable loaded_prefs
365 
366  if {$session eq ""} {
367  if {[info exists loaded_prefs(user,$language)]} {
368  unset loaded_prefs(user,$language)
369  }
370  file delete -force [file join $preferences_dir preferences.$language.tkedat]
371  } else {
372  if {[info exists loaded_prefs(session,$session,$language)]} {
373  unset loaded_prefs(session,$session,$language)
374  sessions::save "prefs" $session
375  }
376  }
377 
378  # Update preferences
379  update_prefs $session
380 
381  }}

§ get()

preferences::get   name ?dflt?  

Definition at line 38 of file preferences.tcl.

38  proc get {name {dflt ""}} {
39 
40  variable prefs
41 
42  if {[info exists prefs($name)]} {
43  return $prefs($name)
44  }
45 
46  return $dflt
47 
48  }}

§ get_loaded()

preferences::get_loaded   ?session? ?language?  

Definition at line 90 of file preferences.tcl.

90  proc get_loaded {{session ""} {language ""}} {
91 
92  variable loaded_prefs
93 
94  # If the session has not been previously loaded, attempt to do it now
95  if {($session ne "") && ![info exists loaded_prefs(session,$session,global)]} {
96  sessions::load_prefs $session
97  }
98 
99  # Figure out key prefix
100  if {($session eq "") || ![info exists loaded_prefs(session,$session,global)]} {
101  set prefix "user"
102  } else {
103  set prefix "session,$session"
104  array set lprefs $loaded_prefs(user,global)
105  }
106 
107  array set lprefs $loaded_prefs($prefix,global)
108 
109  if {($language ne "") && [info exists loaded_prefs($prefix,$language)]} {
110  array set lprefs $loaded_prefs($prefix,$language)
111  }
112 
113  return [array get lprefs]
114 
115  }}

§ get_share_items()

preferences::get_share_items   dir  

Definition at line 461 of file preferences.tcl.

461  proc get_share_items {dir} {
462 
463  variable preferences_dir
464 
465  return [glob -nocomplain -directory $dir -tails preferences*.tkedat]
466 
467  }}

§ get_user_preference_file()

preferences::get_user_preference_file

Definition at line 65 of file preferences.tcl.

65  proc get_user_preference_file {} {
66 
67  variable preferences_dir
68 
69  return [file join $preferences_dir preferences.tkedat]
70 
71  }}

§ language_exists()

preferences::language_exists   session language  

Definition at line 75 of file preferences.tcl.

75  proc language_exists {session language} {
76 
77  variable loaded_prefs
78 
79  if {$session eq ""} {
80  return [info exists loaded_prefs(user,$language)]
81  } else {
82  return [info exists loaded_prefs(session,$session,$language)]
83  }
84 
85  }}

§ load()

preferences::load

Definition at line 183 of file preferences.tcl.

183  proc load {} {
184 
185  # Load the preferences file contents
186  load_file
187 
188  }}

§ load_base_prefs()

preferences::load_base_prefs

Definition at line 157 of file preferences.tcl.

157  proc load_base_prefs {} {
158 
159  variable base_preference_file
160  variable base_prefs
161  variable base_comments
162 
163  # Only load the base preferences information if we have previously done so
164  if {[array size base_prefs] == 0} {
165 
166  # Read the base preferences file (sort out comments from preferences)
167  if {![catch { tkedat::read $base_preference_file } rc]} {
168  foreach {key value} $rc {
169  if {[lassign [split $key ,] opt] eq "comment"} {
170  set base_comments($opt) $value
171  } else {
172  set base_prefs($opt) $value
173  }
174  }
175  }
176 
177  }
178 
179  }}

§ load_file()

preferences::load_file   ?language?  

Definition at line 261 of file preferences.tcl.

261  proc load_file {{language ""}} {
262 
263  variable base_preference_file
264  variable loaded_prefs
265  variable prefs
266  variable menus
267  variable base_comments
268  variable base_prefs
269  variable preferences_dir
270 
271  # Get the user preferences file
272  set user_preference_file [get_user_preference_file]
273 
274  # If the preferences file does not exist, add it from the data directory
275  if {[file exists $user_preference_file]} {
276 
277  # Get the file status information for both the base and user files
278  file stat $base_preference_file base_stat
279  file stat $user_preference_file user_stat
280 
281  # Read the user preferences file
282  if {![catch { tkedat::read $user_preference_file 0} rc]} {
283  array set user_prefs $rc
284  }
285 
286  # If the base preferences file was changed since the user file has changed, see if the
287  # user file needs to be updated and update it if necessary
288  if {$base_stat(ctime) > $user_stat(ctime)} {
289 
290  # Read both the base the preferences file (sort out comments from preferences)
291  load_base_prefs
292 
293  # If the preferences are different between the base and user, update the user
294  if {[lsort [array names base_prefs]] ne [lsort [array names user_prefs]]} {
295 
296  # Copy only the members in the user preferences that are in the base preferences
297  # (omit the comments)
298  foreach name [array names user_prefs -regexp {^[^,]+$}] {
299  if {[info exists base_prefs($name)]} {
300  set base_prefs($name) $user_prefs($name)
301  }
302  }
303 
304  # Write the base_prefs array to the user preferences file
305  if {![catch { tkedat::write $user_preference_file [array get base_prefs] 0} rc]} {
306  set loaded_prefs(user,global) [array get base_prefs]
307  }
308 
309  # Otherwise, assign the user preferences to the
310  } else {
311  set loaded_prefs(user,global) [array get user_prefs]
312  }
313 
314  # Otherwise, just use the user preferences file
315  } else {
316  set loaded_prefs(user,global) [array get user_prefs]
317  }
318 
319  } else {
320 
321  # Copy the base preferences to the user preferences file
322  file copy -force $base_preference_file $preferences_dir
323 
324  # Read the contents of the user file
325  if {![catch { tkedat::read $user_preference_file 0 } rc]} {
326  set loaded_prefs(user,global) $rc
327  }
328 
329  }
330 
331  # Read the language preference file
332  if {$language ne ""} {
333  set languages $language
334  } else {
335  set languages [list]
336  foreach lang_file [glob -nocomplain -directory $preferences_dir -tails preferences.*.tkedat] {
337  if {[regexp {preferences\.(.*)\.tkedat} $lang_file -> lang]} {
338  lappend languages $lang
339  }
340  }
341  }
342 
343  # Save off settings from each language
344  foreach lang $languages {
345  if {![catch { tkedat::read [file join $preferences_dir preferences.$lang.tkedat] 0 } rc]} {
346  set loaded_prefs(user,$lang) $rc
347  }
348  }
349 
350  # Update the preferences
351  update_prefs
352 
353  # Perform environment variable setting from the General/Variables preference option
354  utils::set_environment $prefs(General/Variables)
355 
356  }}

§ load_session()

preferences::load_session   name data  

Definition at line 415 of file preferences.tcl.

415  proc load_session {name data} {
416 
417  variable base_prefs
418  variable loaded_prefs
419 
420  # Make sure that the base preferences are loaded
421  load_base_prefs
422 
423  # Get the session key and data
424  lassign $data key sdata
425 
426  # Initialize with the base preferences (to make sure that we don't allow session preferences to get stale)
427  set loaded_prefs($key) [array get base_prefs]
428 
429  # Override base preferences with user preferences
430  set loaded_prefs($key) $loaded_prefs(user,global)
431 
432  # Set the incoming preference information into the loaded_prefs array
433  set loaded_prefs($key) $sdata
434 
435  # Update the UI
436  if {$name eq [sessions::current]} {
437  update_prefs $name
438  }
439 
440  }}

§ ref()

preferences::ref   ?name?  

Definition at line 53 of file preferences.tcl.

53  proc ref {{name ""}} {
54 
55  if {$name eq ""} {
56  return "preferences::prefs"
57  } else {
58  return "preferences::prefs($name)"
59  }
60 
61  }}

§ save_prefs()

preferences::save_prefs   session language data  

Definition at line 192 of file preferences.tcl.

192  proc save_prefs {session language data} {
193 
194  variable loaded_prefs
195  variable prefs
196  variable preferences_dir
197 
198  if {$session eq ""} {
199 
200  # Get the filename to write and update the appropriate loaded_prefs array
201  if {$language eq ""} {
202  if {[info exists loaded_prefs(user,global)]} {
203  array set content $loaded_prefs(user,global)
204  }
205  array set content $data
206  set loaded_prefs(user,global) [array get content]
207  tkedat::write [get_user_preference_file] $loaded_prefs(user,global) 0
208  } else {
209  if {[info exists loaded_prefs(user,$language)]} {
210  array set content $loaded_prefs(user,$language)
211  }
212  array set content $data
213  set loaded_prefs(user,$language) [array get content Editor/*]
214  lappend loaded_prefs(user,$language) {*}[array get content Documentation/*]
215  tkedat::write [file join $preferences_dir preferences.$language.tkedat] $loaded_prefs(user,$language) 0
216  }
217 
218  } else {
219 
220  # Get the filename to write and update the appropriate loaded_prefs array
221  if {$language eq ""} {
222  if {[info exists loaded_prefs(session,$session,global)]} {
223  array set content $loaded_prefs(session,$session,global)
224  }
225  array set content $data
226  array unset content General/*
227  array unset content Help/*
228  array unset content Debug/*
229  array unset content Tools/Profile*
230  array unset content Editor/Snippet*
231  set loaded_prefs(session,$session,global) [array get content]
232  } else {
233  if {[info exists loaded_prefs(session,$session,$language)]} {
234  array set content $loaded_prefs(session,$session,$language)
235  }
236  array set content $data
237  array unset content Editor/Snippet*
238  set loaded_prefs(session,$session,$language) [array get content Editor/*]
239  }
240 
241  # Save the preference information to the sessions file
242  sessions::save "prefs" $session
243 
244  }
245 
246  # Update the UI/environment if the session name matches the current one
247  if {$session eq [sessions::current]} {
248 
249  # Update the UI
250  update_prefs $session
251 
252  # Perform environment variable setting from the General/Variables preference option
253  utils::set_environment $prefs(General/Variables)
254 
255  }
256 
257  }}

§ save_session()

preferences::save_session   name  

Definition at line 444 of file preferences.tcl.

444  proc save_session {name} {
445 
446  variable loaded_prefs
447 
448  if {![info exists loaded_prefs(session,$name,global)]} {
449  foreach user_type [array names loaded_prefs user,*] {
450  lassign [split $user_type ,] user type
451  set loaded_prefs(session,$name,$type) $loaded_prefs($user_type)
452  }
453  }
454 
455  return [array get loaded_prefs session,$name,*]
456 
457  }}

§ share_changed()

preferences::share_changed   dir  

Definition at line 471 of file preferences.tcl.

471  proc share_changed {dir} {
472 
473  variable preferences_dir
474 
475  set preferences_dir $dir
476 
477  }}

§ update_prefs()

preferences::update_prefs   ?session?  

Definition at line 120 of file preferences.tcl.

120  proc update_prefs {{session ""}} {
121 
122  variable loaded_prefs
123  variable prefs
124 
125  # Calculate the preference prefix
126  if {($session ne "") && [info exists loaded_prefs(session,$session,global)]} {
127  set prefix "session,$session"
128  } else {
129  set prefix "user"
130  }
131 
132  array set temp_prefs $loaded_prefs($prefix,global)
133 
134  # Load language-specific preferences, if necessary
135  if {([set txt [gui::current_txt]] ne "") && \
136  ([set language [syntax::get_language $txt]] ne [msgcat::mc "None"]) && \
137  [info exists loaded_prefs($prefix,$language)]} {
138  array set temp_prefs $loaded_prefs($prefix,$language)
139  }
140 
141  # Remove any preferences that have not changed value
142  foreach {name value} [array get temp_prefs] {
143  if {[info exists prefs($name)] && ($prefs($name) eq $temp_prefs($name))} {
144  unset temp_prefs($name)
145  }
146  }
147 
148  # Set the preferences
149  array set prefs [array get temp_prefs]
150 
151  }}