$TxtWidget tag configure keyword -font $EditorData(options,fonts,keywordFont)
    $TxtWidget tag configure pair -background red
    
    return
}

proc editorWindows::IsComment {line lineNum} {
    variable TxtWidget
    
    set a ""
    regexp "^( |\t)*\#" $line a
    
    if {$a != ""} {
        return [list $lineNum.[expr [string length $a]-1] $lineNum.[string length $line]]
    } else {
        regexp "^(.*\;( |\t)*)\#" $line a
        if {$a != ""} {
            $TxtWidget tag remove comment $lineNum.0 "$lineNum.0 lineend"
            set range [GetKeywordCoord $line $lineNum]
            if {$range != {} } {
                eval $TxtWidget tag add keyword $range
            } else {
                $TxtWidget tag remove keyword $lineNum.0 "$lineNum.0 lineend"
            }
            return [list $lineNum.[expr [string length $a]-1] $lineNum.[string length $line]]
        } else  {
            return {}
        }
    }
}

proc editorWindows::GetKeywordCoord {line lineNum} {
    global EditorData
    
    set name ""
    
    set temp [string trim $line \ \t\;\{\[\]\}]
    if {![scan $temp %s name]} {
        return {}
    }
    
    set nameStart [string first $name $line]
    set nameEnd [string wordend $line $nameStart]
    
    # is it keyword?
    if {[lsearch $EditorData(keywords) $name] != -1 || $name == "else" || $name == "elseif"} {
        return [list $lineNum.$nameStart $lineNum.$nameEnd]
    } else  {
        return {}
    }
}


proc editorWindows::GetTemplateKeyword { line } {
    global EditorData
    
    set a ""
    regexp "^( |\t|\;)*\[a-z\]+ $" $line a
    
    if {$a != ""} {
        # gets name
        set b ""
        regexp "^( |\t)*" $line b
        set nameStart [string length $b]
        set nameEnd [string length $a]
        set name [string range $a [string length $b] end]
        
        #return name without last space
        return [string range $name 0 [expr {[string length $name] - 2}]]
    } else {
        # check for else
        set a ""
        regexp "^( |\t)*\}( |\t)*else $" $line a
        
        if {$a != ""} {
            return "else"
        }
        
        # check for elseif
        set a ""
        regexp "^( |\t)*\}( |\t)*elseif $" $line a
        
        if {$a != ""} {
            return "elseif"
        }
    }
    
    return ""
}

proc editorWindows::setCursor {lineNum pos} {
    variable TxtWidget
    
    $TxtWidget mark set insert $lineNum.$pos
    $TxtWidget see insert
    focus $TxtWidget
    ReadCursor
    
    return
}

#reaction on changing tab size
proc editorWindows::onTabSize {} {
    variable TxtWidget
    global EditorData
    
    if {$TxtWidget != ""} {
        set size [expr {$EditorData(options,tabSize)*
            [font measure $EditorData(options,fonts,editorFont) -displayof $TxtWidget " "]}]
        $TxtWidget configure -tabs [list $size]
    }
    
    return
}

# reaction on change font
proc editorWindows::onFontChange {} {
    variable TxtWidget
    global EditorData
    
    if {$TxtWidget != ""} {
        $TxtWidget configure -font $EditorData(options,fonts,editorFont)
        ConfigureTags
    }
    
    return
}

proc editorWindows::onChangeFontSize {editWin} {
    global EditorData
    
    if {$editWin != ""} {
        $editWin configure -font editorFont
        $editWin tag configure comment -font commentFont -foreground blue
        $editWin tag configure keyword -font keywordFont
        $editWin tag configure pair -background red
        update
    }
    return
}

proc editorWindows::GetOpenPair {symbol {index ""}} {
    variable TxtWidget
    
    if {$index == ""} {
        set index "insert"
    } else  {
        set index "$index"
    }
    
    set count -1
    
    switch $symbol {
        "\}" {set rexp {(^[ \t\;]*#)|(\{)|(\\)|(\})}}
        "\]" {set rexp {(^[ \t\;]*#)|(\[)|(\\)|(\])}}
        "\)" {set rexp {(^[ \t\;]*#)|(\()|(\\)|(\))}}
    }
    while {$count != 0} {
        set index [$TxtWidget search -backwards -regexp $rexp "$index" "1.0"]
        
        if {$index == ""} {
            break
        }
        #check for quoting
        if {[$TxtWidget get "$index -1c"] != "\\"} {
            switch [$TxtWidget get $index] {
                "\{" {incr count}
                "\[" {incr count}
                "\(" {incr count}
                "\}" {incr count -1}
                "\]" {incr count -1}
                "\)" {incr count -1}
            }
        }
    }
    
    if {$count == 0} {
        return $index
    } else  {
        return ""
    }
}



proc editorWindows::GetClosePair {symbol {index ""}} {
    variable TxtWidget
    
    if {$index == ""} {
        set index "insert"
    }
    
    set count 1
    
    switch $symbol {
        "\{" {set rexp {(^[ \t\;]*#)|(\})|(\{)|(\\)}}
        "\[" {set rexp {(^[ \t\;]*#)|(\[)|(\\)|(\])}}
        "\(" {set rexp {(^[ \t\;]*#)|(\()|(\\)|(\))}}
    }
    while {$count != 0} {
        set index [$TxtWidget search -regexp $rexp "$index +1c" end ]
        if {$index == ""} {
            break
        }
        switch -- [$TxtWidget get $index] {
            "\{" {incr count}
            "\[" {incr count}
            "\(" {incr count}
            "\}" {incr count -1}
            "\]" {incr count -1}
            "\)" {incr count -1}
            "\\" {set index "$index +1ch"}
            default {
                #this is a comment line
                set index [$TxtWidget index "$index lineend"]
            }
        }
        if {[$TxtWidget compare $index >= "end-1c"]} {
            break
        }
    }
    if {$count == 0} {
        return [$TxtWidget index $index]
    } else  {
        return ""
    }
}

#process line for openSymbol
proc editorWindows::ProcessLineForOpenSymbol {line symbol countName} {
    upvar $countName count
    
    switch -- $symbol {
        "\}" {
            set openSymbol "\{"
        }
        "\]" {
            set openSymbol "\["
        }
        "\)" {
            set openSymbol "\("
        }
    }
    
    #process line
    for {set i [expr {[string length $line] - 1}]} {$i >= 0} {incr i -1} {
        set curChar [string index $line $i]
        
        if {$curChar == $openSymbol} {
            # increment count
            if {[string index $line [expr {$i - 1}]] == "\\"} {
                #skip it
                incr i -1
            } else  {
                incr count
                if {$count > 0} {
                    return $i
                }
            }
        } elseif {$curChar == $symbol } {
            # decrement count
            if {[string index $line [expr {$i - 1}]] == "\\"} {
                #skip it
                incr i -1
            } else  {
                incr count -1
            }
        }
    }
    
    return ""
}


#process line for closeSymbol
proc editorWindows::ProcessLineForCloseSymbol {line symbol countName} {
    upvar $countName count
    
    switch -- $symbol {
        "\{" {
            set closeSymbol "\}"
        }
        "\[" {
            set closeSymbol "\]"
        }
        "\(" {
            set closeSymbol "\)"
        }
    }
    
    #process line
    set len [string length $line]
    for {set i 0} {$i < $len} {incr i } {
        set curChar [string index $line $i]
        
        if {$curChar == $closeSymbol} {
            # increment count
            incr count
            if {$count > 0} {
                return $i
            }
        } elseif {$curChar == $symbol } {
            # decrement count
            incr count -1
        } elseif {$curChar == "\\"} {
            #skip next symbol
            incr i
        }
    }
    
    return ""
}

# count braces in text
proc editorWindows::CountBraces {text {count 0}} {
    set rexp_open {\{}
    set rexp_close {\}}
    #ignore comment lines
    regsub -all {^[ \t\;]#[^\n]*} $text "" dummy
    #ignore quoted braces
    regsub -all {(\\\\)} $dummy "" dummy
    regsub -all {(\\\{|\\\})} $dummy "" text
    set openBraces [regsub -all $rexp_open $text "*" dummy]
    set closeBraces [regsub -all $rexp_close $text "*" dummy]
    return [expr $openBraces - $closeBraces]
}

# colorize pair
proc editorWindows::ColorizePair {} {
    variable TxtWidget
    
    $TxtWidget tag remove pair 0.0 end
    
    #get current char
    set curChar [$TxtWidget get insert]
    
    switch -- $curChar {
        "\}" {
            set result [GetOpenPair "\}"]
            if {$result != ""} {
                $TxtWidget tag add pair $result "$result +1ch"
            }
        }
        "\]" {
            set result [GetOpenPair "\]"]
            if {$result != ""} {
                $TxtWidget tag add pair $result "$result +1ch"
            }
        }
        "\)" {
            set result [GetOpenPair "\)"]
            if {$result != ""} {
                $TxtWidget tag add pair $result "$result +1ch"
            }
        }
        "\{" {
            set result [GetClosePair "\{"]
            if {$result != ""} {
                $TxtWidget tag add pair $result "$result +1ch"
            }
        }
        "\[" {
            set result [GetClosePair "\["]
            if {$result != ""} {
                $TxtWidget tag add pair $result "$result +1ch"
            }
        }
        "\(" {
            set result [GetClosePair "\("]
            if {$result != ""} {
                $TxtWidget tag add pair $result "$result +1ch"
            }
        }
        default {return}
    }
}