indent Namespace Reference

Functions
	handle_spaces_per_tab name1 name2 op
	handle_indent_spaces name1 name2 op
	add_bindings txt
	set_tabstop txtt value
	get_tabstop txtt
	set_shiftwidth txtt value
	get_shiftwidth txtt
	set_current_indent_mode mode
	set_indent_mode txt mode
	get_indent_mode txt
	is_auto_indent_available txt
	check_reindent_for_unindent txtt index
	check_indent txtt index do_update
	line_contains_indentation txtt index
	get_match_indent txtt index
	get_start_of_line txtt index
	newline txtt index do_update
	backspace txtt index do_update
	get_previous_indent_space txtt index
	get_tag_count txtt tag start end
	format_text txtt startpos endpos ?add_separator?
	set_indent_expressions txtt indent unindent reindent
	update_auto_indent txtt w
	populate_indent_menu mnu
	create_menu w
	update_button w

Function Documentation

add_bindings()

indent::add_bindings			txt

Definition at line 80 of file indent.tcl.

  proc add_bindings {txt} {

    # Initialize the tabstop
    set_tabstop    $txt.t [preferences::get Editor/SpacesPerTab]
    set_shiftwidth $txt.t [preferences::get Editor/IndentSpaces]

    bind indent$txt <Any-Key>   { indent::check_indent %W insert 1 }
    bind indent$txt <Return>    { indent::newline      %W insert 1 }
    bind indent$txt <BackSpace> { indent::backspace    %W insert 1 }

    # Add the indentation tag into the bindtags list just after Text
    set text_index [lsearch [bindtags $txt.t] Text]
    bindtags $txt.t [linsert [bindtags $txt.t] [expr $text_index + 1] indent$txt]

  }

backspace()

indent::backspace			txtt index do_update

Definition at line 523 of file indent.tcl.

  proc backspace {txtt index do_update} {

    variable data

    # If the auto-indent feature was disabled, we are in vim start mode, or
    # the current language doesn't have an indent expression, quit now
    if {($data($txtt,mode) eq "OFF") || [vim::in_vim_mode $txtt]} {
      return $index
    }

    # Figure out the leading space
    set space ""
    if {[set endpos [lassign [$txtt tag prevrange __prewhite $index "$index linestart"] startpos]] ne ""} {
      if {[$txtt compare $endpos == "$index+1c"]} {
        set space [$txtt get $startpos $index]
      } else {
        return $index
      }
    } else {
      set space [$txtt get "$index linestart" "$index lineend"]
    }

    # If the leading whitespace only consists of spaces, attempt to delete to the previous tab
    if {([string map {{ } {}} $space] eq "")} {

      # Calculate the new indentation
      set shiftwidth   [get_shiftwidth $txtt]
      set tab_count    [expr [string length $space] / $shiftwidth]
      set indent_space [string repeat " " [expr $tab_count * $shiftwidth]]

      # Replace the whitespace with the appropriate amount of indentation space
      if {$indent_space ne $space} {
        $txtt fastreplace -update $do_update "$index linestart" $index $indent_space
        set offset [string length $indent_space]
        return [$txtt index "$index linestart+${offset}c"]
      }

    }

    return $index

  }

check_indent()

indent::check_indent			txtt index do_update

Definition at line 249 of file indent.tcl.

  proc check_indent {txtt index do_update} {

    variable data

    # If the auto-indent feature was disabled, we are in vim start mode, or
    # the current language doesn't have an indent expression, quit now
    if {($data($txtt,mode) ne "IND+") || [vim::in_vim_mode $txtt]} {
      return $index
    }

    # If the current line contains an unindent expression, is not within a comment or string,
    # and is preceded in the line by only whitespace, replace the whitespace with the proper
    # indentation whitespace.
    if {([set endpos [lassign [$txtt tag prevrange __unindent $index] startpos]] ne "") && [$txtt compare $endpos >= $index]} {

      if {[string trim [set space [$txtt get "$index linestart" $startpos]]] eq ""} {

        # Find the matching indentation index
        if {[set tindex [get_match_indent $txtt $startpos]] ne ""} {
          set indent_space [get_start_of_line $txtt $tindex]
        } else {
          set indent_space [get_start_of_line $txtt $index]
        }

        # Replace the whitespace with the appropriate amount of indentation space
        if {$indent_space ne $space} {
          $txtt fastreplace -update $do_update "$index linestart" $startpos $indent_space
          set offset [expr [lindex [split $index .] 1] + ([string length $indent_space] - [lindex [split $startpos .] 1])]
          return [$txtt index "$index linestart+${offset}c"]
        }

      }

    } elseif {(([set endpos [lassign [$txtt tag prevrange __reindent $index] startpos]] ne "") && [$txtt compare $endpos == $index]) && [set type [check_reindent_for_unindent $txtt $startpos]]} {

      if {[string trim [set space [$txtt get "$index linestart" $startpos]]] eq ""} {

        if {$type == 1} {

          # Get the starting whitespace of the previous line
          set indent_space [get_start_of_line $txtt [$txtt index "$index-1l lineend"]]

          # Check to see if the previous line contained a reindent
          if {[$txtt compare "$index-1l linestart" > [lindex [$txtt tag prevrange __reindent "$index linestart"] 0]]} {
            set indent_space [string range $indent_space [get_shiftwidth $txtt] end]
          }

        } else {

          # Set the indentation space to the same as the reindentStart line
          set indent_space [get_start_of_line $txtt [lindex [$txtt tag prevrange __reindentStart $index] 0]]

        }

        # Replace the whitespace with the appropriate amount of indentation space
        if {$indent_space ne $space} {
          $txtt fastreplace -update $do_update "$index linestart" $startpos $indent_space
          set offset [expr [lindex [split $index .] 1] + ([string length $indent_space] - [lindex [split $startpos .] 1])]
          return [$txtt index "$index linestart+${offset}c"]
        }

      }

    }

    return $index

  }

check_reindent_for_unindent()

indent::check_reindent_for_unindent			txtt index

Definition at line 216 of file indent.tcl.

  proc check_reindent_for_unindent {txtt index} {

    if {[set spos [lindex [$txtt tag prevrange __reindentStart $index] 0]] ne ""} {

      # If the starting reindent is also an indent, return 1
      if {[lsearch [$txtt tag names $spos] __indent*] != -1} {
        return 2
      }

      # Get the starting position of the previous reindent string
      set rpos [lindex [$txtt tag prevrange __reindent $index] 0]

      if {($rpos ne "") && [$txtt compare $rpos > $spos]} {

        # Find the indent symbol that is just before the reindentStart symbol
        while {([lassign [$txtt tag prevrange __indent $index] ipos] ne "") && [$txtt compare $ipos > $spos]} {
          set index $ipos
        }

        return [$txtt compare $index < $rpos]

      }

    }

    return 0

  }

create_menu()

indent::create_menu			w

Definition at line 758 of file indent.tcl.

  proc create_menu {w} {

    # Create the menubutton menu
    set mnu [menu ${w}Menu -tearoff 0]

    # Populate the indent menu
    populate_indent_menu $mnu

    # Register the menu
    theme::register_widget $mnu menus

    return $mnu

  }

format_text()

indent::format_text			txtt startpos endpos ?add_separator?

Definition at line 608 of file indent.tcl.

  proc format_text {txtt startpos endpos {add_separator 1}} {

    variable data

    # Create a separator
    if {$add_separator} {
      $txtt edit separator
    }

    # If we are the first line containing non-whitespace, preserve the indentation
    if {([$txtt tag prevrange __prewhite "$startpos linestart"] eq "") || \
        ([string trim [$txtt get "$startpos linestart" $startpos]] ne "")} {
      set curpos [$txtt index "$startpos+1l linestart"]
    } else {
      set curpos [$txtt index "$startpos linestart"]
    }

    set endpos       [$txtt index $endpos]
    set indent_space ""
    set shiftwidth   [get_shiftwidth $txtt]

    while {[$txtt compare $curpos < $endpos]} {

      if {$curpos ne "1.0"} {

        # If the current line contains an unindent expression, is not within a comment or string,
        # and is preceded in the line by only whitespace, replace the whitespace with the proper
        # indentation whitespace.
        if {[set epos [lassign [$txtt tag nextrange __unindent $curpos "$curpos lineend"] spos]] ne ""} {
          if {[set tindex [get_match_indent $txtt $spos]] ne ""} {
            if {[$txtt compare "$tindex linestart" == "$spos linestart"]} {
              set indent_space [get_start_of_line $txtt "$tindex-1l lineend"]
              if {[line_contains_indentation $txtt "$tindex-1l lineend"]} {
                append indent_space [string repeat " " $shiftwidth]
              }
            } else {
              set indent_space [get_start_of_line $txtt $tindex]
            }
          } else {
            set indent_space [get_start_of_line $txtt $epos]
          }

        } elseif {([set epos [lassign [$txtt tag nextrange __reindent $curpos "$curpos lineend"] spos]] ne "") && [check_reindent_for_unindent $txtt $spos]} {
          set indent_space [get_start_of_line $txtt [$txtt index "$curpos-1l lineend"]]
          if {[string trim [$txtt get "$curpos linestart" $spos]] eq ""} {
            if {[$txtt compare "$curpos-1l linestart" > [lindex [$txtt tag prevrange __reindent "$curpos linestart"] 1]]} {
              set indent_space [string range $indent_space $shiftwidth end]
            }
          }

        } else {
          set indent_space [get_start_of_line $txtt [$txtt index "$curpos-1l lineend"]]
          if {[line_contains_indentation $txtt "$curpos-1l lineend"]} {
            append indent_space [string repeat " " $shiftwidth]
          }
        }

      }

      # Remove any leading whitespace and update indentation level
      # (if the first non-whitespace char is a closing bracket)
      set whitespace ""
      if {[lsearch [$txtt tag names $curpos] __prewhite] != -1} {
        set whitespace [string range [$txtt get {*}[$txtt tag nextrange __prewhite $curpos]] 0 end-1]
      }

      # Replace the leading whitespace with the calculated amount of indentation space
      if {$whitespace ne $indent_space} {
        $txtt replace $curpos "$curpos+[string length $whitespace]c" $indent_space
      }

      # Adjust the startpos
      set curpos [$txtt index "$curpos+1l linestart"]

    }

    # Create a separator
    $txtt edit separator

    # Perform syntax highlighting
    $txtt syntax highlight $startpos $endpos

  }

get_indent_mode()

indent::get_indent_mode			txt

Definition at line 192 of file indent.tcl.

  proc get_indent_mode {txt} {

    variable data

    if {![info exists data($txt.t,mode)]} {
      return "OFF"
    } else {
      return [lindex $data($txt.t,mode) 0]
    }

  }

get_match_indent()

indent::get_match_indent			txtt index

Definition at line 343 of file indent.tcl.

  proc get_match_indent {txtt index} {

    set count 1

    lassign [$txtt tag prevrange __indent   $index] sfirst slast
    lassign [$txtt tag prevrange __unindent $index] ofirst olast

    if {($olast ne "") && [$txtt compare $olast >= $index]} {
      set olast $index
    }

    while {($ofirst ne "") && ($sfirst ne "")} {
      if {[$txtt compare $sfirst > $ofirst]} {
        if {[incr count -1] == 0} {
          return $sfirst
        }
        lassign [$txtt tag prevrange __indent $sfirst] sfirst slast
      } else {
        incr count
        lassign [$txtt tag prevrange __unindent $ofirst] ofirst olast
      }
    }

    while {$sfirst ne ""} {
      if {[incr count -1] == 0} {
        return $sfirst
      }
      lassign [$txtt tag prevrange __indent $sfirst] sfirst slast
    }

    return ""

  }

get_previous_indent_space()

indent::get_previous_indent_space			txtt index

Definition at line 568 of file indent.tcl.

  proc get_previous_indent_space {txtt index} {

    variable data

    if {($data($txtt,mode) eq "OFF") || \
        [vim::in_vim_mode $txtt] || \
        ([lindex [split $index .] 0] == 1)} {
      return 0
    }

    if {[set range [$txtt tag prevrange __prewhite "$index-1l lineend"]] ne ""} {
      return [string range [$txtt get {*}$range] 0 end-1]
    } else {
      return ""
    }

  }

get_shiftwidth()

indent::get_shiftwidth			txtt

Definition at line 147 of file indent.tcl.

  proc get_shiftwidth {txtt} {

    variable shiftwidths

    if {[info exists shiftwidths($txtt)]} {
      return $shiftwidths($txtt)
    }

    return -code error "Shiftwidth information for $txtt does not exist"

  }

get_start_of_line()

indent::get_start_of_line			txtt index

Definition at line 380 of file indent.tcl.

  proc get_start_of_line {txtt index} {

    # Ignore whitespace
    if {[lsearch [$txtt tag names "$index linestart"] __prewhite] == -1} {
      if {[set range [$txtt tag prevrange __prewhite "$index lineend"]] ne ""} {
        set index [$txtt index "[lindex $range 1] lineend"]
      } else {
        set index 1.0
      }
    }

    # Find an ending bracket on the current line
    set win_type       "none"
    set startpos(none) "$index linestart"
    foreach type [list curlyR parenR squareR angledR] {
      if {([lassign [$txtt tag prevrange __$type $index] startpos($type)] ne "") && \
          [$txtt compare $startpos($type) >= "$index linestart"] && \
          [$txtt compare $startpos($type) >= $startpos($win_type)]} {
        set win_type $type
      }
    }

    # If we could not find a right bracket, we have found the line that we are looking for
    if {$win_type eq "none"} {
      if {[lsearch [$txtt tag names "$index linestart"] __prewhite] != -1} {
        return [string range [$txtt get {*}[$txtt tag nextrange __prewhite "$index linestart"]] 0 end-1]
      } else {
        return ""
      }

    # Otherwise, jump the insertion cursor to the line containing the matching bracket and
    # do the search again.
    } else {
      array set other_type [list curlyR curlyL parenR parenL squareR squareL angledR angledL]
      if {[set match_index [ctext::getMatchBracket [winfo parent $txtt] $other_type($win_type) $startpos($win_type)]] ne ""} {
        return [get_start_of_line $txtt $match_index]
      } elseif {[lsearch [$txtt tag names "$index linestart"] __prewhite] != -1} {
        return [string range [$txtt get {*}[$txtt tag nextrange __prewhite "$index linestart"]] 0 end-1]
      } else {
        return ""
      }
    }

  }

get_tabstop()

indent::get_tabstop			txtt

Definition at line 117 of file indent.tcl.

  proc get_tabstop {txtt} {

    variable tabstops

    if {[info exists tabstops($txtt)]} {
      return $tabstops($txtt)
    }

    return -code error "Tabstop information for $txtt does not exist"

  }

get_tag_count()

indent::get_tag_count			txtt tag start end

Definition at line 588 of file indent.tcl.

  proc get_tag_count {txtt tag start end} {

    variable data

    # Initialize the indent_level
    set count 0

    # Count all tags that are not within comments or are escaped
    while {[set range [$txtt tag nextrange __$tag $start $end]] ne ""} {
      incr count
      set start [lindex $range 1]
    }

    return $count

  }

handle_indent_spaces()

indent::handle_indent_spaces			name1 name2 op

Definition at line 64 of file indent.tcl.

  proc handle_indent_spaces {name1 name2 op} {

    variable shiftwidths

    foreach txtt [array names shiftwidths] {
      if {[winfo exists $txtt]} {
        set_shiftwidth $txtt [preferences::get Editor/IndentSpaces]
      } else {
        unset shiftwidths($txtt)
      }
    }

  }

handle_spaces_per_tab()

indent::handle_spaces_per_tab			name1 name2 op

Definition at line 46 of file indent.tcl.

  proc handle_spaces_per_tab {name1 name2 op} {

    variable tabstops

    foreach txtt [array names tabstops] {
      if {[winfo exists $txtt]} {
        set_tabstop $txtt [preferences::get Editor/SpacesPerTab]
      } else {
        unset tabstops($txtt)
      }
    }

  }

is_auto_indent_available()

indent::is_auto_indent_available			txt

Definition at line 206 of file indent.tcl.

  proc is_auto_indent_available {txt} {

    variable data

    return $data($txt.t,auto,avail)

  }

line_contains_indentation()

indent::line_contains_indentation			txtt index

Definition at line 320 of file indent.tcl.

  proc line_contains_indentation {txtt index} {

    # Ignore whitespace
    if {[lsearch [$txtt tag names "$index linestart"] __prewhite] == -1} {
      if {[set range [$txtt tag prevrange __prewhite "$index lineend"]] ne ""} {
        set index [$txtt index "[lindex $range 1] lineend"]
      } else {
        set index 1.0
      }
    }

    # Check to see if the current line contains an indentation symbol towards the end of the line
    if {[lassign [$txtt tag prevrange __indent $index "$index linestart"] ipos] ne ""} {
      return [expr {([lassign [$txtt tag prevrange __unindent $index] upos] eq "") || [$txtt compare $ipos > $upos]}]
    }

    # Returns true if we have a reindent symbol in the current line
    return [expr {[lassign [$txtt tag prevrange __reindent $index "$index linestart"] ipos] ne ""}]

  }

newline()

indent::newline			txtt index do_update

Definition at line 428 of file indent.tcl.

  proc newline {txtt index do_update} {

    variable data

    # If the auto-indent feature was disabled, we are in vim start mode,
    # or the current language doesn't have an indent expression, quit now
    if {($data($txtt,mode) eq "OFF") || [vim::in_vim_mode $txtt]} {
      if {[$txtt cget -autoseparators]} {
        $txtt edit separator
      }
      return $index
    }

    # If we do not need smart indentation, use the previous space
    if {$data($txtt,mode) eq "IND"} {

      set indent_space [get_previous_indent_space $txtt $index]

    # Otherwise, do smart indentation
    } else {

      # Get the current indentation level
      set indent_space [get_start_of_line $txtt [$txtt index "$index-1l lineend"]]

      # If the previous line indicates an indentation is required,
      if {[line_contains_indentation $txtt "$index-1l lineend"]} {
        append indent_space [string repeat " " [get_shiftwidth $txtt]]
      }

    }

    # Create an index to restore the insertion cursor, if necessary
    set restore_insert ""

    # Remove any leading whitespace and update indentation level
    # (if the first non-whitespace char is a closing bracket)
    if {[lsearch [$txtt tag names "$index linestart"] __prewhite] != -1} {

      lassign [$txtt tag nextrange __prewhite "$index linestart"] startpos endpos

      # If the first non-whitespace characters match an unindent pattern,
      # lessen the indentation by one
      if {[lsearch [$txtt tag names "$endpos-1c"] __unindent*] != -1} {
        $txtt fastinsert -update 0 insert "$indent_space\n"
        set startpos [$txtt index $startpos+1l]
        set endpos   [$txtt index $endpos+1l]
        set restore_insert [$txtt index insert-1c]
        if {$data($txtt,mode) eq "IND+"} {
          set indent_space [string range $indent_space [get_shiftwidth $txtt] end]
        }

      # Otherwise, if the first non-whitepace characters match a reindent pattern, lessen the
      # indentation by one
      } elseif {([lsearch [$txtt tag names "$endpos-1c"] __reindent*] != -1) && [check_reindent_for_unindent $txtt [lindex [$txtt tag prevrange __reindent $endpos] 0]]} {
        # $txtt insert insert "$indent_space\n"
        # set restore_insert [$txtt index insert-1c]
        if {$data($txtt,mode) eq "IND+"} {
          set indent_space [string range $indent_space [get_shiftwidth $txtt] end]
        }
      }

      # See if we are deleting a multicursor
      set mcursor [lsearch [$txtt tag names $index] "mcursor"]

      # Delete the whitespace
      $txtt fastdelete -update [expr {($do_update && ($indent_space eq "")) ? 1 : 0}] $startpos "$endpos-1c"

      # If the newline was from a multicursor, we need to re-add the tag since we have deleted it
      if {$mcursor != -1} {
        $txtt tag add mcursor $index
      }

    }

    # Insert leading whitespace to match current indentation level
    if {$indent_space ne ""} {
      $txtt fastinsert -update $do_update "$index linestart" $indent_space
    }

    # If we need to restore the insertion cursor, do it now
    if {$restore_insert ne ""} {
      ::tk::TextSetCursor $txtt $restore_insert
    }

    # If autoseparators are called for, add it now
    if {[$txtt cget -autoseparators]} {
      $txtt edit separator
    }

    return [$txtt index "$index+[string length $indent_space]c"]

  }

populate_indent_menu()

indent::populate_indent_menu			mnu

Definition at line 738 of file indent.tcl.

  proc populate_indent_menu {mnu} {

    variable langs

    # Clear the menu
    $mnu delete 0 end

    # Populate the menu with the available languages
    foreach {lbl mode} [list [msgcat::mc "No Indent"] "OFF" [msgcat::mc "Auto-Indent"] "IND" [msgcat::mc "Smart Indent"] "IND+"] {
      $mnu add radiobutton -label $lbl -variable indent::current_indent \
        -value $mode -command [list indent::set_current_indent_mode $mode]
    }

    return $mnu

  }

set_current_indent_mode()

indent::set_current_indent_mode			mode

Definition at line 161 of file indent.tcl.

  proc set_current_indent_mode {mode} {

    set_indent_mode [gui::current_txt] $mode

  }

set_indent_expressions()

indent::set_indent_expressions			txtt indent unindent reindent

Definition at line 694 of file indent.tcl.

  proc set_indent_expressions {txtt indent unindent reindent} {

    variable data

    # Update the auto-indent settings
    set data($txtt,auto,avail)  [expr {$indent ne ""}]
    set data($txtt,auto,enable) 1

    # Set the default indentation mode
    if {[preferences::get Editor/EnableAutoIndent]} {
      if {($indent ne "") && [$txtt cget -highlight]} {
        set data($txtt,mode) "IND+"
      } else {
        set data($txtt,mode) "IND"
      }
    } else {
      set data($txtt,mode) "OFF"
    }

  }

set_indent_mode()

indent::set_indent_mode			txt mode

Definition at line 169 of file indent.tcl.

  proc set_indent_mode {txt mode} {

    variable data
    variable indent_mode_map
    variable current_indent

    # Set the current mode
    set data($txt.t,mode) $indent_mode_map($mode)
    set current_indent    $indent_mode_map($mode)

    # Set the text widget's indent mode
    folding::add_folds $txt 1.0 end

    # Update the menu button
    $gui::widgets(info_indent) configure -text $mode

    # Set the focus back to the text widget
    catch { gui::set_txt_focus [gui::last_txt_focus]}

  }

set_shiftwidth()

indent::set_shiftwidth			txtt value

Definition at line 131 of file indent.tcl.

  proc set_shiftwidth {txtt value} {

    variable shiftwidths

    # Check to make sure that the value is an integer
    if {![string is integer $value]} {
      return -code error "Shiftwidth value is not an integer"
    }

    # Save the shiftwidth value
    set shiftwidths($txtt) $value

  }

set_tabstop()

indent::set_tabstop			txtt value

Definition at line 98 of file indent.tcl.

  proc set_tabstop {txtt value} {

    variable tabstops

    # Check to make sure that the value is an integer
    if {![string is integer $value]} {
      return -code error "Tabstop value is not an integer"
    }

    # Save the tabstop value
    set tabstops($txtt) $value

    # Set the text widget tabstop value
    $txtt configure -tabs [list [expr $value * [font measure [$txtt cget -font] 0]] left]

  }

update_auto_indent()

indent::update_auto_indent			txtt w

Definition at line 718 of file indent.tcl.

  proc update_auto_indent {txtt w} {

    variable data
    variable current_indent

    set data($txtt,auto,enable) [expr [$txtt cget -highlight] && $data($txtt,auto,avail)]
    set state                   [expr {$data($txtt,auto,enable) ? "normal" : "disabled"}]

    if {!$data($txtt,auto,enable) && ($data($txtt,mode) eq "IND+")} {
      set data($txtt,mode) "IND"
    }

    set current_indent $data($txtt,mode)

    ${w}Menu entryconfigure [msgcat::mc "Smart Indent"] -state $state

  }

update_button()

indent::update_button			w

Definition at line 775 of file indent.tcl.

  proc update_button {w} {

    variable data
    variable current_indent

    # Get the current text widget
    set txtt [gui::current_txt].t

    # Configure the menubutton
    if {[info exists data($txtt,mode)]} {
      $w configure -text [set current_indent $data($txtt,mode)]
    }

    # Update the selectable state of the button
    ${w}Menu entryconfigure [msgcat::mc "Smart Indent"] -state [expr {[$txtt cget -highlight] ? "normal" : "disabled"}]

  }