conftooldlg.tcl

This Source-Navigator, an IDE for C/C++/Fortran/Java/Tcl/PHP/Python and a host of other languages.

            ${UserGenList} delete 0 end

            # Set new entries.
            set tmpcmd "${UserGenList} insert end ${includes}"
            eval ${tmpcmd}
        }
    }

    method DefinesPage {leaf} {

        # User macro definitions
        set UserMacroLabel [label ${leaf}.deflbl -text [get_indep String\
          IDEBRMacroDefinesLabel]]

	set UserDefsFrame [frame $leaf.userdeffr -relief sunken\
		-borderwidth 2]
	scrollbar $UserDefsFrame.vertsb -orient vertical \
		-relief flat -borderwidth 1 -highlightthickness 0

        set UserDefsList [listbox $UserDefsFrame.deflbx -height 6 \
		-yscrollcommand "scrollListbox $UserDefsFrame.vertsb"]
        bind ${UserDefsList} <ButtonRelease-1> "${this} cb_defselect"
	$UserDefsFrame.vertsb configure -command "$UserDefsList yview"

	grid $UserDefsList -row 1 -column 1 -sticky news
	grid $UserDefsFrame.vertsb -row 1 -column 2 -sticky ns
	grid columnconfigure $UserDefsFrame 1 -weight 1
	grid rowconfigure $UserDefsFrame 1 -weight 1

        #The Buttons
        set DefDelButt [button ${leaf}.dbut -text [get_indep String\
          IDEBRDeleteMacro] -under [get_indep Pos IDEBRDeleteMacro] -width 11\
          -command " ${this} cb_deldef "]
        set DefNewButt [button ${leaf}.nubut -text [get_indep String\
          IDEBRCreateMacro] -under [get_indep Pos IDEBRCreateMacro] -width 11\
          -command " ${this} cb_newdef "]
        set DefSetButt [button ${leaf}.abut -text [get_indep String\
          IDEBRChangeMacro] -under [get_indep Pos IDEBRChangeMacro] -width 11\
          -command " ${this} cb_setdef "]

        #The macro entry widget
        set EditDef [entry ${leaf}.editdef -textvariable \
		[itcl::scope editdefbox]]

	trace variable [itcl::scope editdefbox] w "[itcl::code $this EditDefBoxChanged]"

        grid rowconfigure ${leaf} 1 -minsize 10
        grid columnconfigure ${leaf} 0 -minsize 10

        grid ${UserMacroLabel} -row 2 -column 1 -sticky w
        grid ${UserDefsFrame} -row 3 -column 1 -rowspan 3 -sticky we

        grid rowconfigure ${leaf} 6 -minsize 10

        grid ${EditDef} -row 7 -column 1 -sticky we

        grid ${DefNewButt} -column 3 -row 3
        grid ${DefDelButt} -column 3 -row 4
        grid ${DefSetButt} -column 3 -row 5
        grid columnconfigure ${leaf} 2 -minsize 10


        grid rowconfigure ${leaf} 8 -weight 10
        grid columnconfigure ${leaf} 9 -minsize 10
        grid columnconfigure ${leaf} 1 -weight 10
        grid rowconfigure ${leaf} 3 -weight 10
        grid rowconfigure ${leaf} 4 -weight 10
        grid rowconfigure ${leaf} 5 -weight 10
        grid rowconfigure ${leaf} 9 -minsize 10

        DefHandleState
    }

    method SetDefinesList {{defines ""}} {

        if {${defines}==""} {
            # Lets checks the build object
            set defines [$itk_option(-buildtarget) GetUserDefines $itk_option(-rule)]
        } else {
            if {${defines}=="<%none%>"} {
                set defines ""
            }
            # Set define in build object
            $itk_option(-buildtarget) SetUserDefines $itk_option(-rule) ${defines}
        }

        if {${defines}!=""} {
            # Populate defines listbox with defines.
            foreach define ${defines} {
                ${UserDefsList} insert end ${define}
            }
        }
    }

    method EditDefBoxChanged {{dummyarg1 ""} {dummyarg2 ""} {dummyargs ""}} {
        set entry_value [${EditDef} get]

        # Check to see if new Entry box value
        # matches any list box values.
        # Why? so it can be selected from the list
        set matched 0

        set itemnum -1

        foreach item [${UserDefsList} get 0 end] {
            incr itemnum
            if {${item}==${entry_value}} {
                set matched 1
                break

            }
        }

        if {${matched}} {
            ${UserDefsList} selection clear 0 end
            ${UserDefsList} selection set ${itemnum}
        }
        DefHandleState
    }

    method DefHandleState {{selected ""} {entered ""}} {

        # Get Listbox selection
        set selection [${UserDefsList} curselect]
        if {${selected} == "" && ${selection} != ""} {
            set selected [${UserDefsList} get ${selection}]
        }

        # Get Text Widget contents.
        if {${entered}==""} {
            set entered [${EditDef} get]
        }

        #Nothing selected. nothing entered
        if {${selected}=="" && ${entered}==""} {
            ${DefNewButt} configure -state disabled -default normal
            ${DefDelButt} configure -state disabled -default normal
            ${DefSetButt} configure -state disabled -default normal
            bind $itk_component(hull) <Return> "${okbutt} invoke"
            return
        }

        #Nothing selected. something entered
        if {${selected}=="" && ${entered}!=""} {
            ${DefNewButt} configure -state normal -default active
            bind $itk_component(hull) <Return> "${DefNewButt} invoke"
            ${DefDelButt} configure -state disabled -default normal
            ${DefSetButt} configure -state disabled -default normal
            return
        }

        #something selected. something entered (matching)
        if {${selected}!="" && ${entered}==${selected}} {
            ${DefNewButt} configure -state disabled -default normal
            ${DefDelButt} configure -state normal -default active
            bind $itk_component(hull) <Return> "${DefDelButt} invoke"
            ${DefSetButt} configure -state disabled -default normal
            return
        }

        #Something selected. Something entered (not matching)
        if {${selected}!="" && ${entered}!="" && ${selected}!=${entered}} {
            ${DefNewButt} configure -state normal -default active
            bind $itk_component(hull) <Return> "${DefNewButt} invoke"
            ${DefDelButt} configure -state disabled -default normal
            ${DefSetButt} configure -state normal -default normal
            return
        }

        #Something selected. Something entered (not matching)
        if {${selected} != "" && ${entered} == ""} {
            ${DefNewButt} configure -state disabled -default active
            bind $itk_component(hull) <Return> "$okbutt invoke"
            ${DefDelButt} configure -state disabled -default normal
            ${DefSetButt} configure -state disabled -default normal
            return
        }

    }

    method cb_newdef {} {

        # Get the new macro from the edit box.
        set new_def [${EditDef} get]

        # Add it to the macros list.
        ${UserDefsList} insert end "${new_def}"
        ${UserDefsList} selection clear 0 end
        ${UserDefsList} selection set end

        # Clean the edit box.
        ${EditDef} delete 0 end

        # Update the state of the buttons.
        EditDefBoxChanged
    }

    method cb_setdef {} {
        set new_def [${EditDef} get]

        set selected [${UserDefsList} curselect]
        ${UserDefsList} delete ${selected}
        ${UserDefsList} insert ${selected} ${new_def}
        EditDefBoxChanged
    }

    method cb_deldef {} {
        set selected [${UserDefsList} curselect]

        if {${selected} != ""} {
            ${UserDefsList} delete ${selected}

            ${EditDef} delete 0 end
        }
        DefHandleState
    }

    method cb_defselect {} {
        set selection [${UserDefsList} curselect]

        if {${selection} != ""} {
            set editdefbox [${UserDefsList} get ${selection}]
        }
        DefHandleState
    }

    method cb_addincpath {} {
        set include_path [Editor&::DirDialog $itk_component(hull) -title "Add Include\
          Path:"]

        # Check that a path was selected
        if {${include_path}!=""} {
            #TODO: check it's unique

            ${UserGenList} insert end ${include_path}
        }
    }

    method ok_cb {} {

        SaveData

	deactivate 1
    }

    method SaveData {} {

        # debug settings
        SetDebugFlags $debugLookUp([${debugLBX} get])

        # optimization settings
        SetOptimizationFlags $optimizeLookUp([${optimizeLBX} get])

        # code generation settings
        SetCodeGenerationFlags $codeLookUp([${codeLBX} get])

        # Warning level settings
        SetWarningFlags $warnLookUp([${warnLBX} get])

        # User defined compiler flags
        $itk_option(-buildtarget) SetToolChainFlags $itk_option(-rule) UserFlags [${uflagsENT} get]

        # Compiler tool.
        SetCompilerLocation [[${exeLEB} component entry] get]

        # Save Auto Includes
        SetGeneratedIncludes [${AutoGenList} get 0 end]

        # Save User Includes
        #(Pass it a secret message in they are no includes)
        set includes [${UserGenList} get 0 end]
        if {${includes}==""} {
            set includes "<%none%>"
        }
        SetUserIncludes ${includes}

        # Save Defines
        #(Pass it a secret message in they are no defines)
        set defines [${UserDefsList} get 0 end]
        if {${defines}==""} {
            set defines "<%none%>"
        }
        SetDefinesList ${defines}
    }


    method cancel_cb {} {
	deactivate 0
    }

    method DestroyDialog {} {
        # Delete all the objects.
        itcl::delete object $itk_component(hull)
    }
}

proc GenerateIncludePaths {srcfiles} {

    # Check paf_db_iu exists
    if {[info command paf_db_iu]==""} {
        # The Includes database hasn't been created.
        return ""
    }

    set all_includefiles ""
    set all_includepaths ""

    # Get the included files for each source file
    foreach srcfile ${srcfiles} {
        set includefiles [paf_db_iu seq -col 0 -end ${srcfile}]
        set all_includefiles [concat ${all_includefiles} ${srcfile}]
    }

    # Strip them down to the paths
    foreach includefile ${all_includefiles} {
        set includepath [file dirname ${includefile}]
        set all_includepaths [concat ${all_includepaths} ${includepath}]
    }

    # Remove and duplicates
    set all_includepaths [lsort ${all_includepaths}]
    set all_includepaths [lunique ${all_includepaths}]

    return ${all_includepaths}
}

proc TestIt {tc} {
    snIdeToolsDlg tst
    tst configure -toolchain ${tc} -ruleSuffix CC
    tst CreateDialog
}