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.

  proc add_plugin_prefs {prefs} {

    variable loaded_prefs

    array set plugin_prefs $prefs
    array set global_prefs $loaded_prefs(user,global)

    # Clean up the global_prefs array
    foreach name [array names global_prefs Plugins/*] {
      if {![info exists plugin_prefs($name)]} {
        unset global_prefs($name)
      } else {
        unset plugin_prefs($name)
      }
    }

    # Add any new plugin preference values
    array set global_prefs [array get plugin_prefs]

    # Replace the global user preferences
    set loaded_prefs(user,global) [array get global_prefs]

    # Update the global user preferences
    update_prefs

  }}

delete_language_prefs()

preferences::delete_language_prefs			session language

Definition at line 361 of file preferences.tcl.

  proc delete_language_prefs {session language} {

    variable preferences_dir
    variable loaded_prefs

    if {$session eq ""} {
      if {[info exists loaded_prefs(user,$language)]} {
        unset loaded_prefs(user,$language)
      }
      file delete -force [file join $preferences_dir preferences.$language.tkedat]
    } else {
      if {[info exists loaded_prefs(session,$session,$language)]} {
        unset loaded_prefs(session,$session,$language)
        sessions::save "prefs" $session
      }
    }

    # Update preferences
    update_prefs $session

  }}

get()

preferences::get			name ?dflt?

Definition at line 38 of file preferences.tcl.

  proc get {name {dflt ""}} {

    variable prefs

    if {[info exists prefs($name)]} {
      return $prefs($name)
    }

    return $dflt

  }}

get_loaded()

preferences::get_loaded			?session? ?language?

Definition at line 90 of file preferences.tcl.

  proc get_loaded {{session ""} {language ""}} {

    variable loaded_prefs

    # If the session has not been previously loaded, attempt to do it now
    if {($session ne "") && ![info exists loaded_prefs(session,$session,global)]} {
      sessions::load_prefs $session
    }

    # Figure out key prefix
    if {($session eq "") || ![info exists loaded_prefs(session,$session,global)]} {
      set prefix "user"
    } else {
      set prefix "session,$session"
      array set lprefs $loaded_prefs(user,global)
    }

    array set lprefs $loaded_prefs($prefix,global)

    if {($language ne "") && [info exists loaded_prefs($prefix,$language)]} {
      array set lprefs $loaded_prefs($prefix,$language)
    }

    return [array get lprefs]

  }}

get_share_items()

preferences::get_share_items			dir

Definition at line 461 of file preferences.tcl.

  proc get_share_items {dir} {

    variable preferences_dir

    return [glob -nocomplain -directory $dir -tails preferences*.tkedat]

  }}

get_user_preference_file()

preferences::get_user_preference_file

Definition at line 65 of file preferences.tcl.

  proc get_user_preference_file {} {

    variable preferences_dir

    return [file join $preferences_dir preferences.tkedat]

  }}

language_exists()

preferences::language_exists			session language

Definition at line 75 of file preferences.tcl.

  proc language_exists {session language} {

    variable loaded_prefs

    if {$session eq ""} {
      return [info exists loaded_prefs(user,$language)]
    } else {
      return [info exists loaded_prefs(session,$session,$language)]
    }

  }}

load()

preferences::load

Definition at line 183 of file preferences.tcl.

  proc load {} {

    # Load the preferences file contents
    load_file

  }}

load_base_prefs()

preferences::load_base_prefs

Definition at line 157 of file preferences.tcl.

  proc load_base_prefs {} {

    variable base_preference_file
    variable base_prefs
    variable base_comments

    # Only load the base preferences information if we have previously done so
    if {[array size base_prefs] == 0} {

      # Read the base preferences file (sort out comments from preferences)
      if {![catch { tkedat::read $base_preference_file } rc]} {
        foreach {key value} $rc {
          if {[lassign [split $key ,] opt] eq "comment"} {
            set base_comments($opt) $value
          } else {
            set base_prefs($opt) $value
          }
        }
      }

    }

  }}

load_file()

preferences::load_file			?language?

Definition at line 261 of file preferences.tcl.

  proc load_file {{language ""}} {

    variable base_preference_file
    variable loaded_prefs
    variable prefs
    variable menus
    variable base_comments
    variable base_prefs
    variable preferences_dir

    # Get the user preferences file
    set user_preference_file [get_user_preference_file]

    # If the preferences file does not exist, add it from the data directory
    if {[file exists $user_preference_file]} {

      # Get the file status information for both the base and user files
      file stat $base_preference_file base_stat
      file stat $user_preference_file user_stat

      # Read the user preferences file
      if {![catch { tkedat::read $user_preference_file 0} rc]} {
        array set user_prefs $rc
      }

      # If the base preferences file was changed since the user file has changed, see if the
      # user file needs to be updated and update it if necessary
      if {$base_stat(ctime) > $user_stat(ctime)} {

        # Read both the base the preferences file (sort out comments from preferences)
        load_base_prefs

        # If the preferences are different between the base and user, update the user
        if {[lsort [array names base_prefs]] ne [lsort [array names user_prefs]]} {

          # Copy only the members in the user preferences that are in the base preferences
          # (omit the comments)
          foreach name [array names user_prefs -regexp {^[^,]+$}] {
            if {[info exists base_prefs($name)]} {
              set base_prefs($name) $user_prefs($name)
            }
          }

          # Write the base_prefs array to the user preferences file
          if {![catch { tkedat::write $user_preference_file [array get base_prefs] 0} rc]} {
            set loaded_prefs(user,global) [array get base_prefs]
          }

        # Otherwise, assign the user preferences to the
        } else {
          set loaded_prefs(user,global) [array get user_prefs]
        }

      # Otherwise, just use the user preferences file
      } else {
        set loaded_prefs(user,global) [array get user_prefs]
      }

    } else {

      # Copy the base preferences to the user preferences file
      file copy -force $base_preference_file $preferences_dir

      # Read the contents of the user file
      if {![catch { tkedat::read $user_preference_file 0 } rc]} {
        set loaded_prefs(user,global) $rc
      }

    }

    # Read the language preference file
    if {$language ne ""} {
      set languages $language
    } else {
      set languages [list]
      foreach lang_file [glob -nocomplain -directory $preferences_dir -tails preferences.*.tkedat] {
        if {[regexp {preferences\.(.*)\.tkedat} $lang_file -> lang]} {
          lappend languages $lang
        }
      }
    }

    # Save off settings from each language
    foreach lang $languages {
      if {![catch { tkedat::read [file join $preferences_dir preferences.$lang.tkedat] 0 } rc]} {
        set loaded_prefs(user,$lang) $rc
      }
    }

    # Update the preferences
    update_prefs

    # Perform environment variable setting from the General/Variables preference option
    utils::set_environment $prefs(General/Variables)

  }}

load_session()

preferences::load_session			name data

Definition at line 415 of file preferences.tcl.

  proc load_session {name data} {

    variable base_prefs
    variable loaded_prefs

    # Make sure that the base preferences are loaded
    load_base_prefs

    # Get the session key and data
    lassign $data key sdata

    # Initialize with the base preferences (to make sure that we don't allow session preferences to get stale)
    set loaded_prefs($key) [array get base_prefs]

    # Override base preferences with user preferences
    set loaded_prefs($key) $loaded_prefs(user,global)

    # Set the incoming preference information into the loaded_prefs array
    set loaded_prefs($key) $sdata

    # Update the UI
    if {$name eq [sessions::current]} {
      update_prefs $name
    }

  }}

ref()

preferences::ref			?name?

Definition at line 53 of file preferences.tcl.

  proc ref {{name ""}} {

    if {$name eq ""} {
      return "preferences::prefs"
    } else {
      return "preferences::prefs($name)"
    }

  }}

save_prefs()

preferences::save_prefs			session language data

Definition at line 192 of file preferences.tcl.

  proc save_prefs {session language data} {

    variable loaded_prefs
    variable prefs
    variable preferences_dir

    if {$session eq ""} {

      # Get the filename to write and update the appropriate loaded_prefs array
      if {$language eq ""} {
        if {[info exists loaded_prefs(user,global)]} {
          array set content $loaded_prefs(user,global)
        }
        array set content $data
        set loaded_prefs(user,global) [array get content]
        tkedat::write [get_user_preference_file] $loaded_prefs(user,global) 0
      } else {
        if {[info exists loaded_prefs(user,$language)]} {
          array set content $loaded_prefs(user,$language)
        }
        array set content $data
        set loaded_prefs(user,$language) [array get content Editor/*]
        lappend loaded_prefs(user,$language) {*}[array get content Documentation/*]
        tkedat::write [file join $preferences_dir preferences.$language.tkedat] $loaded_prefs(user,$language) 0
      }

    } else {

      # Get the filename to write and update the appropriate loaded_prefs array
      if {$language eq ""} {
        if {[info exists loaded_prefs(session,$session,global)]} {
          array set content $loaded_prefs(session,$session,global)
        }
        array set content $data
        array unset content General/*
        array unset content Help/*
        array unset content Debug/*
        array unset content Tools/Profile*
        array unset content Editor/Snippet*
        set loaded_prefs(session,$session,global) [array get content]
      } else {
        if {[info exists loaded_prefs(session,$session,$language)]} {
          array set content $loaded_prefs(session,$session,$language)
        }
        array set content $data
        array unset content Editor/Snippet*
        set loaded_prefs(session,$session,$language) [array get content Editor/*]
      }

      # Save the preference information to the sessions file
      sessions::save "prefs" $session

    }

    # Update the UI/environment if the session name matches the current one
    if {$session eq [sessions::current]} {

      # Update the UI
      update_prefs $session

      # Perform environment variable setting from the General/Variables preference option
      utils::set_environment $prefs(General/Variables)

    }

  }}

save_session()

preferences::save_session			name

Definition at line 444 of file preferences.tcl.

  proc save_session {name} {

    variable loaded_prefs

    if {![info exists loaded_prefs(session,$name,global)]} {
      foreach user_type [array names loaded_prefs user,*] {
        lassign [split $user_type ,] user type
        set loaded_prefs(session,$name,$type) $loaded_prefs($user_type)
      }
    }

    return [array get loaded_prefs session,$name,*]

  }}

share_changed()

preferences::share_changed			dir

Definition at line 471 of file preferences.tcl.

  proc share_changed {dir} {

    variable preferences_dir

    set preferences_dir $dir

  }}

update_prefs()

preferences::update_prefs			?session?

Definition at line 120 of file preferences.tcl.

  proc update_prefs {{session ""}} {

    variable loaded_prefs
    variable prefs

    # Calculate the preference prefix
    if {($session ne "") && [info exists loaded_prefs(session,$session,global)]} {
      set prefix "session,$session"
    } else {
      set prefix "user"
    }

    array set temp_prefs $loaded_prefs($prefix,global)

    # Load language-specific preferences, if necessary
    if {([set txt [gui::current_txt]] ne "") && \
        ([set language [syntax::get_language $txt]] ne [msgcat::mc "None"]) && \
        [info exists loaded_prefs($prefix,$language)]} {
      array set temp_prefs $loaded_prefs($prefix,$language)
    }

    # Remove any preferences that have not changed value
    foreach {name value} [array get temp_prefs] {
      if {[info exists prefs($name)] && ($prefs($name) eq $temp_prefs($name))} {
        unset temp_prefs($name)
      }
    }

    # Set the preferences
    array set prefs [array get temp_prefs]

  }}