.packageName <- "limmaGUI"
BChelp <- function()
{
  Try(help("backgroundCorrect",htmlhelp=TRUE))
}

GetBackgroundCorrectionMethod <- function()
{
  Try(ttGetBCMethod<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttGetBCMethod,"Background Correction Method"))
  Try(tkwm.deiconify(ttGetBCMethod))
  Try(tkgrab.set(ttGetBCMethod))
  Try(tkframe1 <- tkframe(ttGetBCMethod,borderwidth=2))
  Try(tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2))
  Try(tkframe4<-tkframe(tkframe1,borderwidth=2))

  Try(tkgrid(tklabel(tkframe1,text="    ")))

  Try(tkgrid(tklabel(tkframe2,text="Choose a method for background correction.",font=.limmaGUIglobals$limmaGUIfont2),column=2,rowspan=1,columnspan=3,sticky="w"))

  Try(if (!exists("BCMethod",envir=limmaGUIenvironment))
  {
    Try(BCMethod <- "subtract")
    Try(assign("BCMethod",BCMethod,limmaGUIenvironment))
  })
  Try(BCMethod <- get("BCMethod",envir=limmaGUIenvironment))

  Try(methBC <- tclVar(BCMethod))
  Try(none.but <- tkradiobutton(tkframe2,text="None",variable=methBC,value="none",font=.limmaGUIglobals$limmaGUIfont2))
  Try(subtract.but <- tkradiobutton(tkframe2,text="Subtract",variable=methBC,value="subtract",font=.limmaGUIglobals$limmaGUIfont2))
  Try(half.but <- tkradiobutton(tkframe2,text="Half",variable=methBC,value="half",font=.limmaGUIglobals$limmaGUIfont2))
  Try(minimum.but <- tkradiobutton(tkframe2,text="Minimum",variable=methBC,value="minimum",font=.limmaGUIglobals$limmaGUIfont2))
  Try(edwards.but <- tkradiobutton(tkframe2,text="Edwards",variable=methBC,value="edwards",font=.limmaGUIglobals$limmaGUIfont2))
    
  Try(tkgrid(none.but,column=2))
  Try(tkgrid(subtract.but,column=2))
  Try(tkgrid(half.but,column=2))
  Try(tkgrid(minimum.but,column=2))
  Try(tkgrid(edwards.but,column=2))
  Try(tkgrid.configure(none.but,subtract.but,half.but,minimum.but,edwards.but,sticky="w"))
  Try(tkgrid(tkframe2))
  Try(NewBCMethod <- "")
  onOK <- function()
  {
    Try(NewBCMethod<<-tclvalue(methBC));
    Try(tkgrab.release(ttGetBCMethod));
    Try(tkdestroy(ttGetBCMethod))
    Try(if (NewBCMethod==BCMethod)
      return())    
    Try(BCMethod <- NewBCMethod)
    Try(assign("BCMethod",BCMethod,limmaGUIenvironment))
    # Maybe update the status window!
    Try(tkfocus(.limmaGUIglobals$ttMain))  
  }
  Try(OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=function(){Try(tkgrab.release(ttGetBCMethod));Try(tkdestroy(ttGetBCMethod));NewBCMethod<-"";Try(tkfocus(.limmaGUIglobals$ttMain))},font=.limmaGUIglobals$limmaGUIfont2))
  Try(Help.but <- tkbutton(tkframe4,text=" Help ",command=BChelp,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframe4,text="                    ")))
  Try(tkgrid(OK.but,Cancel.but,Help.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="e"))
  Try(tkgrid.configure(Help.but,sticky="e"))  
  Try(tkgrid(tklabel(tkframe4,text="       ")))
  Try(tkgrid(tkframe4))
  Try(tkgrid(tkframe1))
  Try(tkfocus(OK.but))
  Try(tkbind(ttGetBCMethod, "<Return>",onOK))
  Try(tkbind(ttGetBCMethod, "<Destroy>", function() {Try(tkgrab.release(ttGetBCMethod));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttGetBCMethod))

  Try(tkdestroy(ttGetBCMethod))  

  return(NewBCMethod)
}
GetComponentsToExportInHTMLreport <- function(parameterizationIndex=NULL)
{

  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))  
  Try(LinearModelComputed  <- get("LinearModelComputed", envir=limmaGUIenvironment))
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))  

  Try(ttHTMLreportDialog<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttHTMLreportDialog))
  Try(tkgrab.set(ttHTMLreportDialog))
  Try(tkfocus(ttHTMLreportDialog))
  Try(tkwm.title(ttHTMLreportDialog,"HTML Report"))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),tklabel(ttHTMLreportDialog,text="    ")))


  Try(TargetsTcl           <- tclVar("1"))  
  Try(SpotTypesTcl         <- tclVar("1"))
  Try(LayoutTcl            <- tclVar("1"))
  Try(BackgroundCorrectionTcl <- tclVar("1"))
  Try(SpotWeightingTcl     <- tclVar("1"))
  Try(RawMATcl             <- tclVar("1"))
  Try(RawPrintTipGroupTcl  <- tclVar("1"))  
  Try(ScaleBoxPlotTcl      <- tclVar("1"))
  Try(if (NumParameterizations>0)
    Try(SpotTypesInLinearModelTcl <- tclVar("1"))
  else
    Try(SpotTypesInLinearModelTcl <- tclVar("0")))
  Try(if (NumParameterizations>0)
    Try(NormalizationInLinearModelTcl <- tclVar("1"))
  else
    Try(NormalizationInLinearModelTcl <- tclVar("0")))    
  Try(if (NumParameterizations>0)
    Try(DesignMatrixTcl      <- tclVar("1"))
  else
    Try(DesignMatrixTcl      <- tclVar("0")))
  Try(if (NumParameterizations>0 && ndups>1)    
    Try(DupCorTcl            <- tclVar("1"))  
  else
    Try(DupCorTcl            <- tclVar("0")))
  Try(if (NumParameterizations>0)  
    Try(Top50ToptablesTcl    <- tclVar("1"))    
  else
    Try(Top50ToptablesTcl    <- tclVar("0")))
  Try(CompleteToptablesTcl <- tclVar("0"))      
  Try(if (NumParameterizations>0)  
    Try(AvgMAPlotTcl <- tclVar("1"))
  else
    Try(AvgMAPlotTcl    <- tclVar("0")))
  Try(tStatisticBoxPlotsTcl <- tclVar("0"))  

  Try(TargetsCheckbox                     <- tkcheckbutton(ttHTMLreportDialog,variable=TargetsTcl))
  Try(SpotTypesCheckbox                   <- tkcheckbutton(ttHTMLreportDialog,variable=SpotTypesTcl))  
  Try(LayoutCheckbox                      <- tkcheckbutton(ttHTMLreportDialog,variable=LayoutTcl))    
  Try(BackgroundCorrectionCheckbox        <- tkcheckbutton(ttHTMLreportDialog,variable=BackgroundCorrectionTcl))      
  Try(SpotWeightingCheckbox               <- tkcheckbutton(ttHTMLreportDialog,variable=SpotWeightingTcl))      
  Try(RawMACheckbox                       <- tkcheckbutton(ttHTMLreportDialog,variable=RawMATcl))    
  Try(RawPrintTipGroupCheckbox            <- tkcheckbutton(ttHTMLreportDialog,variable=RawPrintTipGroupTcl))      
  Try(ScaleBoxPlotCheckbox                <- tkcheckbutton(ttHTMLreportDialog,variable=ScaleBoxPlotTcl))        
  Try(SpotTypesInLinearModelCheckbox      <- tkcheckbutton(ttHTMLreportDialog,variable=SpotTypesInLinearModelTcl))        
  Try(NormalizationInLinearModelCheckbox  <- tkcheckbutton(ttHTMLreportDialog,variable=NormalizationInLinearModelTcl))          
  Try(DesignMatrixCheckbox                <- tkcheckbutton(ttHTMLreportDialog,variable=DesignMatrixTcl))          
  Try(DupCorCheckbox                      <- tkcheckbutton(ttHTMLreportDialog,variable=DupCorTcl))            
  Try(Top50ToptablesCheckbox              <- tkcheckbutton(ttHTMLreportDialog,variable=Top50ToptablesTcl))              
  Try(CompleteToptablesCheckbox           <- tkcheckbutton(ttHTMLreportDialog,variable=CompleteToptablesTcl))                
  Try(AvgMAPlotCheckbox                   <- tkcheckbutton(ttHTMLreportDialog,variable=AvgMAPlotTcl))
  Try(tStatisticBoxPlotsCheckbox          <- tkcheckbutton(ttHTMLreportDialog,variable=tStatisticBoxPlotsTcl))                  

  Try(lbl2 <- tklabel(ttHTMLreportDialog,text="Components to be Included in the HTML Report",font=.limmaGUIglobals$limmaGUIfont2))
  tkgrid(tklabel(ttHTMLreportDialog,text="    "),lbl2)
  Try(tkgrid.configure(lbl2,columnspan=3,sticky="w"))
  tkgrid(tklabel(ttHTMLreportDialog,text="    "))
  
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="RNA Targets",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),TargetsCheckbox,currentLabel))
  Try(tkgrid.configure(TargetsCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Spot Types",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),SpotTypesCheckbox,currentLabel))
  Try(tkgrid.configure(SpotTypesCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Layout",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),LayoutCheckbox,currentLabel))
  Try(tkgrid.configure(LayoutCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Background Correction Method",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),BackgroundCorrectionCheckbox,currentLabel))
  Try(tkgrid.configure(BackgroundCorrectionCheckbox,sticky="e"));Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Spot Quality Weighting",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),SpotWeightingCheckbox,currentLabel))
  Try(tkgrid.configure(SpotWeightingCheckbox,sticky="e"));Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Color-Coded Raw M A Plots",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),RawMACheckbox,currentLabel))
  Try(tkgrid.configure(RawMACheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Print-Tip Group Loess Raw M A Plots",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),RawPrintTipGroupCheckbox,currentLabel))
  Try(tkgrid.configure(RawPrintTipGroupCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Within-Array Normalized M Box Plots",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),ScaleBoxPlotCheckbox,currentLabel))
  Try(tkgrid.configure(ScaleBoxPlotCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Spot Types Included In Linear Model",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),SpotTypesInLinearModelCheckbox,currentLabel))
  Try(tkgrid.configure(SpotTypesInLinearModelCheckbox,sticky="e"));Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Normalization Used In Linear Model",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),NormalizationInLinearModelCheckbox,currentLabel))
  Try(tkgrid.configure(NormalizationInLinearModelCheckbox,sticky="e"));Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Design Matrix (Parameterization)",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),DesignMatrixCheckbox,currentLabel))
  Try(tkgrid.configure(DesignMatrixCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Duplicate Correlation",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),DupCorCheckbox,currentLabel))
  Try(tkgrid.configure(DupCorCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Top 50 DE Genes",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),Top50ToptablesCheckbox,currentLabel))
  Try(tkgrid.configure(Top50ToptablesCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="Complete Lists of DE-Ranked Genes",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),CompleteToptablesCheckbox,currentLabel))
  Try(tkgrid.configure(CompleteToptablesCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="M A Plots (with fitted M values)",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),AvgMAPlotCheckbox,currentLabel))
  Try(tkgrid.configure(AvgMAPlotCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))
  Try(currentLabel <- tklabel(ttHTMLreportDialog,text="t Statistic Box Plots",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttHTMLreportDialog,text="    "),tStatisticBoxPlotsCheckbox,currentLabel))
  Try(tkgrid.configure(tStatisticBoxPlotsCheckbox,sticky="e"));  Try(tkgrid.configure(currentLabel,sticky="w",columnspan=2))

# Need to test whether arrays have been loaded and whether a linear model has been fit.

  if (NumParameterizations==0 || LinearModelComputed[parameterizationIndex]==FALSE)
  {
    Try(tkconfigure(SpotTypesInLinearModelCheckbox,state="disabled"))  
    Try(tkconfigure(NormalizationInLinearModelCheckbox,state="disabled"))      
    Try(tkconfigure(DesignMatrixCheckbox,state="disabled"))
    Try(tkconfigure(DupCorCheckbox,state="disabled"))  
    Try(tkconfigure(Top50ToptablesCheckbox,state="disabled"))    
    Try(tkconfigure(CompleteToptablesCheckbox,state="disabled"))      
    Try(tkconfigure(tStatisticBoxPlotsCheckbox,state="disabled"))
    Try(tkconfigure(AvgMAPlotCheckbox,state="disabled"))    
  }
  
  if (ndups<=1)
    Try(tkconfigure(DupCorCheckbox,state="disabled"))  
  
  tkgrid(tklabel(ttHTMLreportDialog,text="    "))
  tkgrid(tklabel(ttHTMLreportDialog,text="    "))
  ReturnVal <- list()
  onOK <- function()
  {
      if (tclvalue(TargetsTcl)=="1") ReturnVal[[1]] <- TRUE else ReturnVal[[1]] <- FALSE; attributes(ReturnVal)$names[1] <- "Targets"
      if (tclvalue(SpotTypesTcl)=="1") ReturnVal[[2]] <- TRUE else ReturnVal[[2]] <- FALSE; attributes(ReturnVal)$names[2] <- "SpotTypes"
      if (tclvalue(LayoutTcl)=="1") ReturnVal[[3]] <- TRUE else ReturnVal[[3]] <- FALSE; attributes(ReturnVal)$names[3] <- "Layout"      
      if (tclvalue(BackgroundCorrectionTcl)=="1") ReturnVal[[4]] <- TRUE else ReturnVal[[4]] <- FALSE; attributes(ReturnVal)$names[4] <- "BackgroundCorrection"      
      if (tclvalue(SpotWeightingTcl)=="1") ReturnVal[[5]] <- TRUE else ReturnVal[[5]] <- FALSE; attributes(ReturnVal)$names[5] <- "SpotWeighting"      
      if (tclvalue(RawMATcl)=="1") ReturnVal[[6]] <- TRUE else ReturnVal[[6]] <- FALSE; attributes(ReturnVal)$names[6] <- "RawMA"            
      if (tclvalue(RawPrintTipGroupTcl)=="1") ReturnVal[[7]] <- TRUE else ReturnVal[[7]] <- FALSE; attributes(ReturnVal)$names[7] <- "RawPrintTipGroup"                  
      if (tclvalue(ScaleBoxPlotTcl)=="1") ReturnVal[[8]] <- TRUE else ReturnVal[[8]] <- FALSE; attributes(ReturnVal)$names[8] <- "ScaleBoxPlot"                        
      if (tclvalue(SpotTypesInLinearModelTcl)=="1") ReturnVal[[9]] <- TRUE else ReturnVal[[9]] <- FALSE; attributes(ReturnVal)$names[9] <- "SpotTypesInLinearModel"      
      if (tclvalue(NormalizationInLinearModelTcl)=="1") ReturnVal[[10]] <- TRUE else ReturnVal[[10]] <- FALSE; attributes(ReturnVal)$names[10] <- "NormalizationInLinearModel"            
      if (tclvalue(DesignMatrixTcl)=="1") ReturnVal[[11]] <- TRUE else ReturnVal[[11]] <- FALSE; attributes(ReturnVal)$names[11] <- "DesignMatrix"                              
      if (tclvalue(DupCorTcl)=="1") ReturnVal[[12]] <- TRUE else ReturnVal[[12]] <- FALSE; attributes(ReturnVal)$names[12] <- "DupCor"                                    
      if (tclvalue(Top50ToptablesTcl)=="1") ReturnVal[[13]] <- TRUE else ReturnVal[[13]] <- FALSE; attributes(ReturnVal)$names[13] <- "Top50Toptables"                                          
      if (tclvalue(CompleteToptablesTcl)=="1") ReturnVal[[14]] <- TRUE else ReturnVal[[14]] <- FALSE; attributes(ReturnVal)$names[14] <- "CompleteToptables"      
      if (tclvalue(AvgMAPlotTcl)=="1") ReturnVal[[15]] <- TRUE else ReturnVal[[15]] <- FALSE; attributes(ReturnVal)$names[15] <- "AvgMAPlot"            
      if (tclvalue(tStatisticBoxPlotsTcl)=="1") ReturnVal[[16]] <- TRUE else ReturnVal[[16]] <- FALSE; attributes(ReturnVal)$names[16] <- "tStatisticBoxPlots"            
      
      Try(tkgrab.release(ttHTMLreportDialog));Try(tkdestroy(ttHTMLreportDialog));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- ReturnVal
  }
  onCancel <- function() {Try(tkgrab.release(ttHTMLreportDialog));Try(tkdestroy(ttHTMLreportDialog));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- list()}      
  OK.but <-tkbutton(ttHTMLreportDialog,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttHTMLreportDialog,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttHTMLreportDialog,text="    "),tklabel(ttHTMLreportDialog,text="    "),OK.but,Cancel.but,tklabel(ttHTMLreportDialog,text="    "),tklabel(ttHTMLreportDialog,text="    "))
  tkgrid.configure(OK.but,    sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  tkgrid(tklabel(ttHTMLreportDialog,text="    "),tklabel(ttHTMLreportDialog,text="    "),tklabel(ttHTMLreportDialog,text="    "),
       tklabel(ttHTMLreportDialog,text="    "),tklabel(ttHTMLreportDialog,text="    "))
  Try(tkfocus(ttHTMLreportDialog))
  Try(tkbind(ttHTMLreportDialog, "<Destroy>", function() {Try(tkgrab.release(ttHTMLreportDialog));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttHTMLreportDialog))

  return (ReturnVal)
}

###########################################################################################################################
# R2HTML Plot Function (Modified to accept a plotFunction argument, rather than using the main R Graphics Device)

"HTMLplotUsingFunction" <- function (Caption = "", File = .HTML.file, GraphRelativeDirectory = ".", GraphAbsoluteDirectory = NULL, GraphFileName = "", GraphSaveAs = "png", GraphBorder = 1,  Align = "center", plotFunction = NULL,Width=600,Height=600,PointSize=12,BG="white",res=72,...)
{
    if (is.null(GraphAbsoluteDirectory))
      GraphAbsoluteDirectory <- getwd()
    if (GraphFileName == "") {
        nowd <- date()
        GraphFileName <- paste("GRAPH_", substring(nowd, 5, 7), substring(nowd, 9, 10), "_", substring(nowd, 12, 13), substring(nowd, 15,  16), substring(nowd, 18, 19), sep = "")
    }
    GraphFileName <- paste(GraphFileName, ".", GraphSaveAs, sep = "")

#    AbsGraphFileName <- paste(GraphRelativeDirectory,.Platform$file.sep,GraphFileName,sep="")
    AbsGraphFileName <- file.path(GraphAbsoluteDirectory, GraphFileName)
    if (GraphSaveAs=="png") 
    {
      if (is.null(plotFunction))
        dev.print(png, file = AbsGraphFileName, width=Width,height=Height,pointsize=PointSize,bg=BG)
      else
      {
        Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows" && Sys.info()["sysname"] != "Darwin")  
          Try(bitmap(file = AbsGraphFileName,bg=BG,res=res))
        else
          Try(png(filename = AbsGraphFileName, width=Width,height=Height,pointsize=PointSize,bg=BG)))
        plotFunction()      
        dev.off()
      }
    }
    else if (GraphSaveAs=="jpg") 
    {
      if (is.null(plotFunction))
        dev.print(jpeg, file = AbsGraphFileName, width=Width,height=Height,pointsize=PointSize,bg=BG)
      else
      {
        Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows" && Sys.info()["sysname"] != "Darwin")  
          Try(bitmap(filename = AbsGraphFileName,bg=BG,res=res,type="jpeg"))
        else
          Try(jpeg(filename = AbsGraphFileName, width=Width,height=Height,pointsize=PointSize,bg=BG)))
        plotFunction()      
        dev.off()
      }
    }
    else if (GraphSaveAs=="gif") 
    {
      if (is.null(plotFunction))
        dev.print(gif, file = AbsGraphFileName, width=Width,height=Height,pointsize=PointSize,bg=BG)
      else
      {
        stop("When passing a plot function to HTMLplot, device must be jpg or png.")      
      }
    }
    else stop("GraphSaveAs must be either jpg, png or gif")
    cat(paste("<p align=", Align, "><img src='", paste(GraphRelativeDirectory,"/",GraphFileName,sep=""), "' border=", GraphBorder, ">", sep = "", collapse = ""), file = File, append = TRUE, sep = "")
    if (Caption != "") {
        cat(paste("<br><i>", Caption, "</i>"), file = File, append = TRUE, sep = "")
    }
    cat("</P>", file = File, append = TRUE, sep = "\n")
    try(assign(".HTML.graph", TRUE, env = get("HTMLenv", envir = .GlobalEnv)))
    invisible(return())
}

###########################################################################################################################

ExportHTMLreport <- function()
{
# We will use the R2HTML package, but with my own HTMLplot function.
# Will we need xtable or does R2HTML have its own HTMLtable function?
  Require("xtable")
  Require("R2HTML")

  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment))   
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))  
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(RG <- get("RG",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE)
  {
      Try(tkmessageBox(title="Export HTML Report",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  if (NumParameterizations>0)
  {
    Try(parameterizationIndex <- ChooseParameterization())
    Try(if (parameterizationIndex==0)    return()    )
    Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(ComponentsToExport <- GetComponentsToExportInHTMLreport(parameterizationIndex))
 }
 else
     Try(ComponentsToExport <- GetComponentsToExportInHTMLreport())
 
 
  if (length(ComponentsToExport)==0) return()

  Try(fileNameWithPath<- tkgetSaveFile(initialfile=limmaDataSetNameText,filetypes="{{HTML Files} {.html .htm}} {{All files} *}"))  
  Try(if (nchar(tclvalue(fileNameWithPath))==0)
    return())
  Try(path     <- tclvalue(tkfile.dir (tclvalue(fileNameWithPath))))
  Try(fileName <- tclvalue(tkfile.tail(tclvalue(fileNameWithPath))))
   
  Try(len <- nchar(fileName))
  if (len<4)
      Try(fileName <- paste(fileName,".html",sep=""))
  else if   ((tolower(substring(fileName,len-4,len))!=".html") &&
  (len<5 ||  (tolower(substring(fileName,len-4,len))!=".html")))
          Try(fileName <- paste(fileName,".html",sep=""))

  Try(fileNameWithoutExtension <- substring(fileName,1,nchar(fileName)-5))
                                                                
  Try(HTMLfilePath <- paste(path,.Platform$file.sep,fileNameWithoutExtension,"_files",sep=""))
  Try(HTMLfileRelativePath <- paste(fileNameWithoutExtension,"_files",sep=""))
  Try(dir.create(HTMLfilePath))
  
  Try(fileNameWithPath <- paste(path,"/",fileName,sep=""))                                                 

  Try(R2HTMLpath <- system.file(package="R2HTML","output"))
  Try(cssFileSource <- paste(R2HTMLpath,"/","R2HTML.css",sep=""))
  Try(cssFileDestination <- paste(path,"/","R2HTML.css",sep=""))  
  Try(R2HTMLlogoSource <- paste(R2HTMLpath,"/","R2HTMLlogo.gif",sep=""))
  Try(R2HTMLlogoDestination <- paste(path,"/","R2HTMLlogo.gif",sep=""))  
  Try(file.copy(cssFileSource,cssFileDestination,overwrite=TRUE))  
  Try(file.copy(R2HTMLlogoSource,R2HTMLlogoDestination,overwrite=TRUE))    

  Try(HTMLtarget <- HTMLInitFile(path,filename=fileNameWithoutExtension,Title=paste(limmaDataSetNameText,"- Statistical Microarray Analysis using LimmaGUI"), HTMLframe=FALSE,BackGroundColor="#FFFFFF"))

  Try(HTML.title(paste(limmaDataSetNameText,"- Statistical Microarray Analysis using LimmaGUI"),HR=1))

  Try(ExportTargets                    <- ComponentsToExport$Targets)  
  Try(ExportSpotTypes                  <- ComponentsToExport$SpotTypes)
  Try(ExportLayout                     <- ComponentsToExport$Layout)
  Try(ExportBackgroundCorrection       <- ComponentsToExport$BackgroundCorrection)
  Try(ExportSpotWeighting              <- ComponentsToExport$SpotWeighting)
  Try(ExportRawMA                      <- ComponentsToExport$RawMA)
  Try(ExportRawPrintTipGroup           <- ComponentsToExport$RawPrintTipGroup)  
  Try(ExportScaleBoxPlot               <- ComponentsToExport$ScaleBoxPlot)
  Try(ExportSpotTypesInLinearModel     <- ComponentsToExport$SpotTypesInLinearModel)  
  Try(ExportNormalizationInLinearModel <- ComponentsToExport$NormalizationInLinearModel)    
  Try(ExportDesignMatrix               <- ComponentsToExport$DesignMatrix)
  Try(ExportDupCor                     <- ComponentsToExport$DupCor)  
  Try(ExportTop50Toptables             <- ComponentsToExport$Top50Toptables)    
  Try(ExportCompleteToptables          <- ComponentsToExport$CompleteToptables)      
  Try(ExportAvgMAPlot                  <- ComponentsToExport$AvgMAPlot)    
  Try(ExporttStatisticBoxPlots         <- ComponentsToExport$tStatisticBoxPlots)      

  if (ExportRawMA || ExportRawPrintTipGroup || ExportScaleBoxPlot || ExportAvgMAPlot || ExporttStatisticBoxPlots)
  {
    Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows" && Sys.info()["sysname"] != "Darwin")  
    {
      Try(pngParams <- GetJpegOrPngX11Params(graphFileType="PNG"))  
      Try(if (length(pngParams)==0) return())
      Try(plotBG        <- pngParams$bg)
      Try(plotRes       <- pngParams$res)    
    }
    else
    {
      Try(pngParams <- GetJpegOrPngParams(graphFileType="PNG"))
      Try(if (length(pngParams)==0) return())    
      Try(plotWidth     <- pngParams$width)
      Try(plotHeight    <- pngParams$height)
      Try(plotPointSize <- pngParams$pointsize)
      Try(plotBG        <- pngParams$bg)
    })    
  }

  Try(HTML.title("Contents",HR=2))
  if (ExportTargets) Try(HTMLli(txt="<a href=\"#Targets\"><b>Targets</b></a>"))
  if (ExportSpotTypes) Try(HTMLli(txt="<a href=\"#SpotTypes\"><b>Spot Types</b></a>"))
  if (ExportLayout) Try(HTMLli(txt="<a href=\"#Layout\"><b>Layout</b></a>"))
  if (ExportBackgroundCorrection) Try(HTMLli(txt="<a href=\"#BackgroundCorrection\"><b>Background Correction</b></a>"))
  if (ExportSpotWeighting) Try(HTMLli(txt="<a href=\"#SpotWeighting\"><b>Spot Quality Weighting</b></a>"))
  if (ExportRawMA) Try(HTMLli(txt="<a href=\"#RawMA\"><b>Raw M A Plots</b></a>"))  
  if (ExportRawPrintTipGroup) Try(HTMLli(txt="<a href=\"#RawPrintTipGroup\"><b>Raw Print-Tip Group Loess M A Plots</b></a>"))    
  if (ExportScaleBoxPlot) Try(HTMLli(txt="<a href=\"#ScaleBoxPlot\"><b>M Box Plot for each Slide</b></a>"))      
  if (ExportSpotTypesInLinearModel) Try(HTMLli(txt="<a href=\"#SpotTypesInLinearModel\"><b>Spot Types Included In Linear Model</b></a>"))  
  if (ExportNormalizationInLinearModel) Try(HTMLli(txt="<a href=\"#NormalizationInLinearModel\"><b>Normalization Used In Linear Model</b></a>"))  
  if (ExportDesignMatrix) Try(HTMLli(txt="<a href=\"#DesignMatrix\"><b>Design Matrix</b></a>"))          
  if (ExportDupCor) Try(HTMLli(txt="<a href=\"#DupCor\"><b>Duplicate Correlation</b></a>"))          
  if (ExportTop50Toptables) Try(HTMLli(txt="<a href=\"#Top50Toptables\"><b>Tables of Top 50 Differentially Expressed Genes</b></a>"))            
  if (ExportCompleteToptables) Try(HTMLli(txt="<a href=\"#CompleteToptables\"><b>Complete Tables of Genes Ranked in order of Evidence for Differential Expression</b></a>")) 
  if (ExportAvgMAPlot) Try(HTMLli(txt="<a href=\"#AvgMAPlot\"><b>M A Plots (with fitted M values)</b></a>")) 
  if (ExporttStatisticBoxPlots) Try(HTMLli(txt="<a href=\"#tStatisticBoxPlots\"><b>Box Plots showing the Range of t Statistics for each Spot Type</b></a>")) 

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))    

  if (ExportTargets)
  {
    Try(Targets <- get("Targets",envir=limmaGUIenvironment))
    Try(displayVector <- rep("s",ncol(Targets)+1))
    Try(for (i in (0:ncol(Targets)))
      if (i==0 || colnames(Targets)[i]=="SlideNumber")
        displayVector[i] <- "d")
    Try(TargetsXtable <- xtable(Targets,display=displayVector))
    Try(HTML.title("<a name=\"Targets\">RNA Targets</a>",HR=2))
    Try(print(TargetsXtable,type="html",file=fileNameWithPath,append=TRUE))    
  }
  if (ExportSpotTypes)
  {
    Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
    Try(SpotTypesXtable <- xtable(SpotTypes))
    Try(HTML.title("<a name=\"SpotTypes\">Spot Types</a>",HR=2))
    Try(print(SpotTypesXtable,type="html",file=fileNameWithPath,append=TRUE))    
  }
  if (ExportLayout)
  {
    Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
    Try(layoutDataFrame <- data.frame(NumBlockRows=maLayout$ngrid.r,NumBlockColumns=maLayout$ngrid.c,
                                  NumRowsPerBlock=maLayout$nspot.r,NumColsPerBlock=maLayout$nspot.c))
    Try(layoutXtable <- xtable(layoutDataFrame,display=c("d","d","d","d","d")))
    Try(HTML.title("<a name=\"Layout\">Layout</a>",HR=2))
    Try(print(layoutXtable,type="html",file=fileNameWithPath,append=TRUE))    
  }
  if (ExportBackgroundCorrection)
  {
  	Try(if (!exists("BCMethod",envir=limmaGUIenvironment))
		{
			Try(BCMethod <- "subtract")
			Try(assign("BCMethod",BCMethod,limmaGUIenvironment))
		})
		Try(BCMethod <- get("BCMethod",envir=limmaGUIenvironment))
    Try(HTML.title("<a name=\"BackgroundCorrection\">Background Correction Method</a>",HR=2))
    Try(HTMLli(txt=paste("<b>Background Correction Method : </b> ",BCMethod)))
  }  
  if (ExportSpotWeighting)
  {
    Try(WeightingType     <- get("WeightingType",envir=limmaGUIenvironment))
    Try(HTML.title("<a name=\"SpotWeighting\">Spot Quality Weighting</a>",HR=2))
    Try(HTMLli(txt=paste("<b>Weighting Type : </b> ",WeightingType)))
  }  
  if (ExportRawMA)
  {
    Try(HTML.title("<a name=\"RawMA\">M A Plots Using Raw (Unnormalized) Data</a>",HR=2))
    Try(NumSlides      <- get("NumSlides",envir=limmaGUIenvironment))
    Try(SlideNamesVec  <- get("SlideNamesVec",envir=limmaGUIenvironment))    
    Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))    
    Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))    
    Try(MAraw <- get("MAraw",envir=limmaGUIenvironment))

    Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
    if (MA.Available$Raw)
      Try(MAraw <- get("MAraw",envir=limmaGUIenvironment))
    else          
    {
      Try (MAraw <- MA.RG(RG))
      Try(assign("MAraw",MAraw,limmaGUIenvironment))        
      Try(MA.Available$Raw <- TRUE)
      Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
      Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))              
    }              
  
    Try(PointTypes    <- SpotTypes$SpotType)
    Try(PointColors   <- SpotTypes$Color)
    Try(numPointTypes <- length(PointTypes))
    Try(cex           <- rep(0.6,numPointTypes))
    Try(for (i in (1:numPointTypes))
      if (tolower(PointTypes[i])=="gene"||PointTypes[i]=="cDNA")
      {
        Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
          cex[i] <- 0.3
        else
          cex[i] <- 0.1)
      })
    Try(cex    <- cex)
    Try(values <- PointTypes)
    Try(colVec <- PointColors)


    Try(for (slidenum in (1:NumSlides))
    {
      Try(plotTitle <- paste("M A Scatter Plot for ",SlideNamesVec[slidenum],sep=""))      
      Try(plotFunction <- function() plotMAlimmaGUI(MAraw,pch=16,cex=cex,array=slidenum,
          status=SpotTypeStatus,values=values,col=colVec,main=plotTitle,xlab="A",ylab="M"))    
      Try(HTMLplotUsingFunction(Caption = plotTitle, File=fileNameWithPath, GraphRelativeDirectory = HTMLfileRelativePath , 
        GraphAbsoluteDirectory = HTMLfilePath, GraphFileName = paste("plotMArawSlide",slidenum,sep=""), 
        GraphSaveAs = "png", GraphBorder = 1,  Align = "left", plotFunction=plotFunction,
        Width=plotWidth,Height=plotHeight,PointSize=plotPointSize,BG=plotBG,res=plotRes))
    })
  }
  
  if (ExportRawPrintTipGroup)
  {
    Try(HTML.title("<a name=\"RawPrintTipGroup\">Print-Tip Group M A Plots (With Loess Curves) Using Raw (Unnormalized Data)</a>",HR=2))
    Try(maLayout       <- get("maLayout",     envir=limmaGUIenvironment))
    Try(NumSlides      <- get("NumSlides",    envir=limmaGUIenvironment))
    Try(SlideNamesVec  <- get("SlideNamesVec",envir=limmaGUIenvironment))    
    Try(MAraw          <- get("MAraw",        envir=limmaGUIenvironment))

    Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
    if (MA.Available$Raw)
      Try(MAraw <- get("MAraw",envir=limmaGUIenvironment))
    else          
    {
      Try (MAraw <- MA.RG(RG))
      Try(assign("MAraw",MAraw,limmaGUIenvironment))        
      Try(MA.Available$Raw <- TRUE)
      Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
      Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))              
    }              
    
    Try(for (slidenum in (1:NumSlides)) 
    {
      Try(plotTitle <- paste("Print-Tip Group Loess M A Plots for ",SlideNamesVec[slidenum],sep=""))
      Try(plotFunction <- function() plotPrintTipLoess(MAraw,layout=maLayout,array=slidenum))
      Try(HTMLplotUsingFunction(Caption = plotTitle, File=fileNameWithPath, GraphRelativeDirectory = HTMLfileRelativePath , 
        GraphAbsoluteDirectory = HTMLfilePath, GraphFileName = paste("PrintTipLoessPlotSlide",slidenum,sep=""), 
        GraphSaveAs = "png", GraphBorder = 1,  Align = "left", plotFunction=plotFunction,
        Width=plotWidth,Height=plotHeight,PointSize=plotPointSize,BG=plotBG,res=plotRes))      
    })      
  }
  
  if (ExportScaleBoxPlot)
  {
    Try(HTML.title("<a name=\"ScaleBoxPlot\">M Box Plot Showing the Range of M Values for Each Slide</a>",HR=2))  
    Try(Require("sma"))
    Try(RG       <- get("RG",envir=limmaGUIenvironment))    
    Try(maLayout <- get("maLayout",     envir=limmaGUIenvironment))    
    Try(SlideNamesVec  <- get("SlideNamesVec",envir=limmaGUIenvironment))        
    Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
    if (MA.Available$WithinArrays)
      Try(MA <- get("MAwithinArrays",envir=limmaGUIenvironment))
    else          
    {
      Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
      {
        Try(WithinArrayNormalizationMethod <- "printtiploess")
        Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
      })
      Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))          
      if (WeightingType == "none")
        Try (MA <- normalizeWithinArrays(RG,maLayout,method=WithinArrayNormalizationMethod))
      else
        Try(MA <- normalizeWithinArrays(RG,weights=RG$weights,maLayout,method=WithinArrayNormalizationMethod))
      Try(assign("MAwithinArrays",MA,limmaGUIenvironment))
      Try(MA.Available$WithinArrays <- TRUE)
      Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
      Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
      Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text=paste("Available (using ",WithinArrayNormalizationMethod,")",sep=""),font=.limmaGUIglobals$limmaGUIfontTree))                
    }
    Try(plotTitle <- "M Box Plot for all slides with normalization within arrays only")
    Try(plotFunction <- function() plot.scale.box(MA$M,x.names=SlideNamesVec,xlab="Slide",ylab="M",main=plotTitle))
    Try(HTMLplotUsingFunction(Caption = plotTitle, File=fileNameWithPath, GraphRelativeDirectory = HTMLfileRelativePath , 
      GraphAbsoluteDirectory = HTMLfilePath, GraphFileName = "MScaleBoxPlot", 
      GraphSaveAs = "png", GraphBorder = 1,  Align = "left", plotFunction=plotFunction,
      Width=plotWidth,Height=plotHeight,PointSize=plotPointSize,BG=plotBG,res=plotRes))      
  }
  if (ExportSpotTypesInLinearModel)
  {
    Try(SpotTypesIncludedNamesVec <- GetSpotTypesIncludedNames(parameterizationTreeIndex))
    Try(SpotTypesInLinearModel <- data.frame(SpotTypes=SpotTypesIncludedNamesVec))
    Try(colnames(SpotTypesInLinearModel)[1] <- "Spot Types Included In Linear Model")
    Try(SpotTypesInLinearModelXtable <- xtable(SpotTypesInLinearModel))
    Try(HTML.title("<a name=\"SpotTypesInLinearModel\">Spot Types Included In Linear Model</a>",HR=2))
    Try(print(SpotTypesInLinearModelXtable,type="html",file=fileNameWithPath,append=TRUE))    
  }  
  if (ExportNormalizationInLinearModel)
  {
    if (NumParameterizations==0) break()    
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(WhetherToNormalizeWithinArrays  <- (ParameterizationList[[ParameterizationNameNode]])$WhetherToNormalizeWithinArrays)  
    Try(WhetherToNormalizeBetweenArrays <- (ParameterizationList[[ParameterizationNameNode]])$WhetherToNormalizeBetweenArrays)    
    Try(HTML.title("<a name=\"NormalizationInLinearModel\">Normalization Used In Linear Model</a>",HR=2))
    Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
    {
      Try(WithinArrayNormalizationMethod <- "printtiploess")
      Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
    })    
    Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))    
    Try(if ("WithinArrayNormalizationMethod" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Try(WithinArrayNormalizationMethod <- (ParameterizationList[[ParameterizationNameNode]])$WithinArrayNormalizationMethod)
    else
    {
      Try(ParameterizationList[[ParameterizationNameNode]][[WithinArrayNormalizationMethod]] <- WithinArrayNormalizationMethod)
      Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
    })
     
    Try(HTMLli(txt=paste("Within Arrays : ", WhetherToNormalizeWithinArrays," (",WithinArrayNormalizationMethod,")",sep="")))
    Try(HTMLli(txt=paste("Between Arrays : ",WhetherToNormalizeBetweenArrays,sep="")))
  }
  if (ExportDesignMatrix)
  {
    if (NumParameterizations==0) break()    
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
    Try(design <- designList$design)      
    Try(display <- rep("g",ncol(design)))
    Try(display <- c("d",display))
    Try(designXtable <- xtable(design,display=display))
    Try(HTML.title("<a name=\"DesignMatrix\">Design Matrix</a>",HR=2))
    Try(print(designXtable,type="html",file=fileNameWithPath,append=TRUE))    
  }
  if (ExportDupCor)
  {
    Try(ndups <- get("ndups",envir=limmaGUIenvironment))
    Try(if (ndups<=1) break())
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(dupcor <- (ParameterizationList[[ParameterizationNameNode]])$dupcor)
    Try(HTML.title("<a name=\"DupCor\">Duplicate Correlation</a>",HR=2))
    Try(HTMLli(txt=paste("Duplicate Correlation :",dupcor$cor)))    
  }
  
  if (ExportTop50Toptables)
  {
    Try(ndups <- get("ndups",envir=limmaGUIenvironment))
    Try(spacing <- GetReducedDuplicateSpacing(parameterizationTreeIndex))
    Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))  
    Try(if (NumParameterizations==0) break())
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
    Try(design <- designList$design)    
    Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
    Try(HTML.title(paste("<a name=\"Top50Toptables\">Top 50 Differentially Expressed Genes for each Parameter in Parameterization ",ParameterizationNamesVec[parameterizationIndex],"</a>",sep=""),HR=2))    
    Try(NumParameters         <- get("NumParameters",envir=limmaGUIenvironment))
    Try(if (nrow(design)==0)
    {
        Try(ParameterNamesVec <- c())
        if (NumParameters>0)
          for (i in (1:NumParameters)) 
            Try(ParameterNamesVec <- c(ParameterNamesVec,paste("Param",i)))              
    }
    else
        Try(ParameterNamesVec <- colnames(design)))
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    
    Try(Amatrix <- NULL)
    
    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
    Try(if ("Amatrix" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Amatrix <- (ParameterizationList[[ParameterizationNameNode]])$Amatrix)
    
    Try(if (is.null(Amatrix))
    {
      Try(MA <- get("MA",envir=limmaGUIenvironment))  
      Try(A <- MA$A)
      Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
      Try(numSpotTypes <- nrow(SpotTypes))
      Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
      Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
      Omit <- ""
      count <- 0
      Try(for (i in (1:numSpotTypes))
      {
        if (SpotTypesForLinearModel[i]==TRUE)
          next()
        count <- count + 1
        if (count>1)
          Omit <-paste(Omit,"|")
        else
          Omit <- "(" 
        Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
      })  
      Try(if (nchar(Omit)>0)
      {
        Try(Omit <- paste(Omit,")"))  
        Try(Omit <- eval(parse(text=Omit)))
        Try(A <- A[!Omit,])
      })

      Try(A <- unwrapdups(A,ndups=ndups,spacing=spacing))
    }
    else
      Try(A <- unwrapdups(Amatrix,ndups=ndups,spacing=spacing)))
    
    Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
    else
      Try(genelist <- get("genelist",limmaGUIenvironment)))   
  
    for (coef in (1:NumParameters))
    {
      Try(options(digits=3))
      Try(table1 <- toptable(coef=coef,number=50,genelist=genelist,A=A,fit=fit,eb=eb))
      Try(toptableDisplay <- rep("s",ncol(table1)+1))
      Try(toptableDisplay[1] <- "d")
      Try(for (i in (2:(ncol(table1)+1)))
      {                
        Try(if (tolower(colnames(table1)[i-1])=="block") toptableDisplay[i] <- "d")
        Try(if (tolower(colnames(table1)[i-1])=="column") toptableDisplay[i] <- "d")        
        Try(if (tolower(colnames(table1)[i-1])=="col") toptableDisplay[i] <- "d"   )             
        Try(if (tolower(colnames(table1)[i-1])=="row") toptableDisplay[i] <- "d"   )             
        Try(if (tolower(colnames(table1)[i-1])=="gridrow") toptableDisplay[i] <- "d")                        
        Try(if (tolower(colnames(table1)[i-1])=="gridcol") toptableDisplay[i] <- "d")                                
        Try(if (tolower(colnames(table1)[i-1])=="gridcolumn") toptableDisplay[i] <- "d")         
        Try(if (colnames(table1)[i-1]=="M")       toptableDisplay[i] <- "f")      
        Try(if (colnames(table1)[i-1]=="A")       toptableDisplay[i] <- "f")              
        Try(if (colnames(table1)[i-1]=="t")       toptableDisplay[i] <- "f")                      
        Try(if (colnames(table1)[i-1]=="P.Value") toptableDisplay[i] <- "e")                                            
        Try(if (colnames(table1)[i-1]=="B") toptableDisplay[i] <- "f")                                      
      })
#      Try(colnames(table1)[ncol(table1)-1] <- sprintf("%-10s",colnames(table1)[ncol(table1)-1]))
      Try(toptableXtable <- xtable(table1,display=toptableDisplay))
      Try(HTML.title(paste("Top 50 Differentially Expressed Genes for",ParameterNamesVec[coef]),HR=3))
      Try(print(toptableXtable,type="html",file=fileNameWithPath,append=TRUE))
    }
    
    # Now the Contrasts
    Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
    Try(ContrastsParameterizationNamesVec <- c() )
    Try(contrastNames <- list())
    Try (if (NumContrastParameterizations>0)
      Try(for (cp in (1:NumContrastParameterizations))
      {
          Try(ContrastsParameterizationNamesVec[cp] <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]]$contrastsParameterizationNameText)
          Try(contrastsMatrixInList <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]]$contrastsMatrixInList)
          Try(contrastsMatrix <- contrastsMatrixInList$contrasts)
          Try(contrastNames[[cp]] <- colnames(contrastsMatrix))        
          Try(fit <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]])$fit)
          Try(eb  <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]])$eb)           
          
          for (coef in (1:ncol(contrastsMatrix)))
          {
            Try(options(digits=3))
            Try(table1 <- toptable(coef=coef,number=50,genelist=genelist,A=A,fit=fit,eb=eb))
            Try(toptableDisplay <- rep("s",ncol(table1)+1))
            Try(toptableDisplay[1] <- "d")
            Try(for (i in (2:(ncol(table1)+1)))
            {                
              Try(if (tolower(colnames(table1)[i-1])=="block") toptableDisplay[i] <- "d")
              Try(if (tolower(colnames(table1)[i-1])=="column") toptableDisplay[i] <- "d")        
              Try(if (tolower(colnames(table1)[i-1])=="col") toptableDisplay[i] <- "d"   )             
              Try(if (tolower(colnames(table1)[i-1])=="row") toptableDisplay[i] <- "d"   )             
              Try(if (tolower(colnames(table1)[i-1])=="gridrow") toptableDisplay[i] <- "d")                        
              Try(if (tolower(colnames(table1)[i-1])=="gridcol") toptableDisplay[i] <- "d")                                
              Try(if (tolower(colnames(table1)[i-1])=="gridcolumn") toptableDisplay[i] <- "d")         
              Try(if (colnames(table1)[i-1]=="M")       toptableDisplay[i] <- "f")      
              Try(if (colnames(table1)[i-1]=="A")       toptableDisplay[i] <- "f")              
              Try(if (colnames(table1)[i-1]=="t")       toptableDisplay[i] <- "f")                      
              Try(if (colnames(table1)[i-1]=="P.Value") toptableDisplay[i] <- "e")                                            
              Try(if (colnames(table1)[i-1]=="B") toptableDisplay[i] <- "f")                                      
            })
      #      Try(colnames(table1)[ncol(table1)-1] <- sprintf("%-10s",colnames(table1)[ncol(table1)-1]))
            Try(toptableXtable <- xtable(table1,display=toptableDisplay))
            Try(HTML.title(paste("Top 50 Differentially Expressed Genes for ",colnames(contrastsMatrix)[coef]," [",ContrastsParameterizationNamesVec[cp],"]",sep=""),HR=3))
            Try(print(toptableXtable,type="html",file=fileNameWithPath,append=TRUE))                        
        }
      }))

    
  }
  if (ExportCompleteToptables) 
  {
    Try(ndups <- get("ndups",envir=limmaGUIenvironment))
    Try(spacing <- GetReducedDuplicateSpacing(parameterizationTreeIndex))
    if (NumParameterizations==0) break()    
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
    Try(design <- designList$design)    
    Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
    Try(HTML.title(paste("<a name=\"CompleteToptables\">Complete Tables of Genes Ranked in order of Evidence for Differential Expression for each Parameter in Parameterization ",ParameterizationNamesVec[parameterizationIndex],"</a>",sep=""),HR=2))     
    Try(NumParameters         <- get("NumParameters",envir=limmaGUIenvironment))
    Try(if (nrow(design)==0)
    {
        Try(ParameterNamesVec <- c())
        if (NumParameters>0)
          for (i in (1:NumParameters)) 
            Try(ParameterNamesVec <- c(ParameterNamesVec,paste("Param",i)))              
    }
    else
        Try(ParameterNamesVec <- colnames(design)))
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))

    Try(Amatrix <- NULL)
    Try(if ("Amatrix" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Amatrix <- (ParameterizationList[[ParameterizationNameNode]])$Amatrix)
    
    Try(if (is.null(Amatrix))
    {
      Try(MA <- get("MA",envir=limmaGUIenvironment))  
      Try(A <- MA$A)
      Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
      Try(numSpotTypes <- nrow(SpotTypes))
      Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
      Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
      Omit <- ""
      count <- 0
      Try(for (i in (1:numSpotTypes))
      {
        if (SpotTypesForLinearModel[i]==TRUE)
          next()
        count <- count + 1
        if (count>1)
          Omit <-paste(Omit,"|")
        else
          Omit <- "(" 
        Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
      })  
      Try(if (nchar(Omit)>0)
      {
        Try(Omit <- paste(Omit,")"))  
        Try(Omit <- eval(parse(text=Omit)))
        Try(A <- A[!Omit,])
      })

      Try(A <- unwrapdups(A,ndups=ndups,spacing=spacing))
    }
    else
      Try(A <- unwrapdups(Amatrix,ndups=ndups,spacing=spacing)))

    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
    Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
    else
      Try(genelist <- get("genelist",limmaGUIenvironment)))   
  
    for (coef in (1:NumParameters))
    {
      Try(options(digits=3))
      Try(table1 <- toptable(coef=coef,number=nrow(genelist),genelist=genelist,A=A,fit=fit,eb=eb))
#      Try(colnames(table1)[ncol(table1)-1] <- sprintf("%-10s",colnames(table1)[ncol(table1)-1]))
      Try(ToptableAbsoluteFilename <- paste(HTMLfilePath ,.Platform$file.sep,"CompleteToptable_Param",coef,".txt",sep=""))
      Try(ToptableRelativeFilename <- paste(HTMLfileRelativePath ,.Platform$file.sep,"CompleteToptable_Param",coef,".txt",sep=""))
      Try(write.table(table1,file=ToptableAbsoluteFilename,quote=FALSE,col.names=NA,sep="\t"))      
      Try(HTML.title(paste("Complete Table of Genes Ranked in order of Evidence for Differential Expression for ",ParameterNamesVec[coef]),HR=3))
      Try(HTMLli(txt=paste("<a href=\"",ToptableRelativeFilename,"\"><b>",paste("CompleteToptable_Param",coef,".txt",sep=""),"</b></a>",sep=""))) 
    }
    # Now the Contrasts
    Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
    Try(ContrastsParameterizationNamesVec <- c() )
    Try(contrastNames <- list())
    Try (if (NumContrastParameterizations>0)
      Try(for (cp in (1:NumContrastParameterizations))
      {
          Try(ContrastsParameterizationNamesVec[cp] <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]]$contrastsParameterizationNameText)
          Try(contrastsMatrixInList <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]]$contrastsMatrixInList)
          Try(contrastsMatrix <- contrastsMatrixInList$contrasts)
          Try(contrastNames[[cp]] <- colnames(contrastsMatrix))        
          Try(fit <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]])$fit)
          Try(eb  <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]])$eb)           
          for (coef in (1:ncol(contrastsMatrix)))
          {
            Try(options(digits=3))
            Try(table1 <- toptable(coef=coef,number=nrow(genelist),genelist=genelist,A=A,fit=fit,eb=eb))
      #      Try(colnames(table1)[ncol(table1)-1] <- sprintf("%-10s",colnames(table1)[ncol(table1)-1]))
            Try(ToptableAbsoluteFilename <- paste(HTMLfilePath ,.Platform$file.sep,"CompleteToptable_CP_",cp,"Param",coef,".txt",sep=""))
            Try(ToptableRelativeFilename <- paste(HTMLfileRelativePath ,.Platform$file.sep,"CompleteToptable_CP_",cp,"Param",coef,".txt",sep=""))
            Try(write.table(table1,file=ToptableAbsoluteFilename,quote=FALSE,col.names=NA,sep="\t"))      
            Try(HTML.title(paste("Complete Table of Genes Ranked in order of Evidence for Differential Expression for ",colnames(contrastsMatrix)[coef]," [",ContrastsParameterizationNamesVec[cp],"]",sep=""),HR=3))
            Try(HTMLli(txt=paste("<a href=\"",ToptableRelativeFilename,"\"><b>",paste("CompleteToptable_CP_",cp,"Param",coef,".txt",sep=""),"</b></a>",sep=""))) 

        }
      }))    
    
    
    
  }
  
  if (ExportAvgMAPlot)
  {
    Try(HTML.title(paste("<a name=\"AvgMAPlot\">M A Plots (with fitted M values) in Parameterization ",ParameterizationNamesVec[parameterizationIndex],"</a>",sep=""),HR=2))     
    if (NumParameterizations==0) break()    
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
    Try(design <- designList$design)    
    Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
    Try(NumParameters         <- get("NumParameters",envir=limmaGUIenvironment))
    Try(if (nrow(design)==0)
    {
        Try(ParameterNamesVec <- c())
        if (NumParameters>0)
          for (i in (1:NumParameters)) 
            Try(ParameterNamesVec <- c(ParameterNamesVec,paste("Param",i)))              
    }
    else
        Try(ParameterNamesVec <- colnames(design)))
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))

    Try(Amatrix <- NULL)
    Try(if ("Amatrix" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Amatrix <- (ParameterizationList[[ParameterizationNameNode]])$Amatrix)
    
    Try(if (is.null(Amatrix))
    {
      Try(MA <- get("MA",envir=limmaGUIenvironment))  
      Try(A <- MA$A)
      Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
      Try(numSpotTypes <- nrow(SpotTypes))
      Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
      Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
      Omit <- ""
      count <- 0
      Try(for (i in (1:numSpotTypes))
      {
        if (SpotTypesForLinearModel[i]==TRUE)
          next()
        count <- count + 1
        if (count>1)
          Omit <-paste(Omit,"|")
        else
          Omit <- "(" 
        Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
      })  
      Try(if (nchar(Omit)>0)
      {
        Try(Omit <- paste(Omit,")"))  
        Try(Omit <- eval(parse(text=Omit)))
        Try(A <- A[!Omit,])
      })

      Try(A <- unwrapdups(A,ndups=ndups,spacing=spacing))
    }
    else
      Try(A <- unwrapdups(Amatrix,ndups=ndups,spacing=spacing)))

    Try(meanA <- c())
    Try(for (i in (1:nrow(A))) 
    {
      Try(meanA[i] <- mean(A[i,]))
    })

    Try(A <- meanA)

    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
        
    Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
    else
      Try(genelist <- get("genelist",limmaGUIenvironment)))   
  
    for (coef in (1:NumParameters))
    {
      Try(HTML.title(paste("Average M A Plot showing DE genes for",ParameterNamesVec[coef]),HR=3))
      Try(plotTitle <- paste("Average M A Plot showing DE genes for",ParameterNamesVec[coef]))
      Try(if (NumParameters>1) 
        Try(M <- fit$coefficients[,coef])
      else 
        Try(M <- fit$coefficients))
      Try(numDEgenesLabeled   <- 10)
      Try(GeneLabelsMaxLength <- 10)
      Try(if (NumParameters>1) 
        Try(ord <- order(eb$lods[,coef],decreasing=TRUE))
      else 
        Try(ord <- order(eb$lods,decreasing=TRUE)))
      Try(topGenes <- ord[1:numDEgenesLabeled])
      
      Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
        Try(cex <- 0.3)
      else
        Try(cex <- 0.1))        
      AvgMAPlotFunction <- function()
      {
        Try(plot(A,M,pch=16,cex=cex,xlab="mean(A)",ylab=paste("M (",ParameterNamesVec[coef],")",sep=""),main=plotTitle))
        Try(text(A[topGenes],M[topGenes],labels=substr(genelist[topGenes,"Name"],1,GeneLabelsMaxLength),cex=0.8,col="blue"))
      }
      Try(HTMLplotUsingFunction(Caption = plotTitle, File=fileNameWithPath, GraphRelativeDirectory = HTMLfileRelativePath , 
        GraphAbsoluteDirectory = HTMLfilePath, GraphFileName = paste("AvgMAPlot",coef,sep=""), 
        GraphSaveAs = "png", GraphBorder = 1,  Align = "left", plotFunction=AvgMAPlotFunction,
        Width=plotWidth,Height=plotHeight,PointSize=plotPointSize,BG=plotBG,res=plotRes))      

    }
    
    # Now the Contrasts.
    
    Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
    Try(ContrastsParameterizationNamesVec <- c() )
    Try(contrastNames <- list())
    Try (if (NumContrastParameterizations>0)
      Try(for (cp in (1:NumContrastParameterizations))
      {
          Try(ContrastsParameterizationNamesVec[cp] <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]]$contrastsParameterizationNameText)
          Try(contrastsMatrixInList <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]]$contrastsMatrixInList)
          Try(contrastsMatrix <- contrastsMatrixInList$contrasts)
          Try(contrastNames[[cp]] <- colnames(contrastsMatrix))        
          Try(fit <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]])$fit)
          Try(eb  <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[cp]])$eb)           
          Try(NumContrasts <- ncol(contrastsMatrix))
          for (coef in (1:NumContrasts))
          {
            Try(HTML.title(paste("Average M A Plot showing DE genes for",  contrastNames[coef]),HR=3))
            Try(plotTitle <- paste("Average M A Plot showing DE genes for",contrastNames[coef]))
            Try(if (NumContrasts>1) 
              Try(M <- fit$coefficients[,coef])
            else 
              Try(M <- fit$coefficients))
            Try(numDEgenesLabeled   <- 10)
            Try(GeneLabelsMaxLength <- 10)
            Try(if (NumContrasts>1) 
              Try(ord <- order(eb$lods[,coef],decreasing=TRUE))
            else 
              Try(ord <- order(eb$lods,decreasing=TRUE)))
            Try(topGenes <- ord[1:numDEgenesLabeled])

            Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
              Try(cex <- 0.3)
            else
              Try(cex <- 0.1))  
            AvgMAPlotFunction2 <- function()
            {
              Try(plot(A,M,pch=16,cex=cex,xlab="mean(A)",ylab=paste("M (",contrastNames[coef],")",sep=""),main=plotTitle))
              Try(text(A[topGenes],M[topGenes],labels=substr(genelist[topGenes,"Name"],1,GeneLabelsMaxLength),cex=0.8,col="blue"))
            }
            Try(HTMLplotUsingFunction(Caption = plotTitle, File=fileNameWithPath, GraphRelativeDirectory = HTMLfileRelativePath , 
              GraphAbsoluteDirectory = HTMLfilePath, GraphFileName = paste("AvgMAPlot_CP_",cp,"_",coef,sep=""), 
              GraphSaveAs = "png", GraphBorder = 1,  Align = "left", plotFunction=AvgMAPlotFunction2,
              Width=plotWidth,Height=plotHeight,PointSize=plotPointSize,BG=plotBG,res=plotRes))      

          }
      }))    
  
  }
  
  if (ExporttStatisticBoxPlots) 
  {
    if (NumParameterizations==0) break()    
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
    Try(NumParameters         <- get("NumParameters",envir=limmaGUIenvironment))    
    Try(design <- designList$design)    
    Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
    Try(HTML.title(paste("<a name=\"tStatisticBoxPlots\">Box Plots showing the Range of t Statistics for each Spot Type, for each Parameter in Parameterization ",ParameterizationNamesVec[parameterizationIndex],"</a>",sep=""),HR=2))     
    Try(if (nrow(design)==0)
    {
        Try(ParameterNamesVec <- c())
        if (NumParameters>0)
          for (i in (1:NumParameters)) 
            Try(ParameterNamesVec <- c(ParameterNamesVec,paste("Param",i)))              
    }
    else
        Try(ParameterNamesVec <- colnames(design)))
    Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
    Try(ndups   <- get("ndups",envir=limmaGUIenvironment))    
    Try(spacing   <- get("spacing",envir=limmaGUIenvironment))       # Global version
    Try(spacing <- GetReducedDuplicateSpacing(parameterizationTreeIndex))

    Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
    else
      Try(genelist <- get("genelist",limmaGUIenvironment)))   
    Try(gal <- get("gal",envir=limmaGUIenvironment))
    Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))
        
    Try(ebayesStatistic <- "t")
    Try(SpotTypesIncludedNamesVec <- GetSpotTypesIncludedNames(parameterizationTreeIndex)) 
    Try(numSpotTypes <- length(SpotTypesIncludedNamesVec))
    
    for (coef in (1:NumParameters))
    {
      Try(options(digits=3))
      Try(HTML.title(paste("Box Plots showing the Range of t Statistics for each Spot Type, for Parameter ",ParameterNamesVec[coef],sep=""),HR=3))           
      # There is a heading HR=4 in the R2HTML cascaded style sheet.
      Try(for (SpotTypeIndex in (1:numSpotTypes))
      {
        Try(SpotType <- SpotTypesIncludedNamesVec[SpotTypeIndex])
        Try(HTML.title(paste("Box Plot(s) showing the Range of t Statistics for each Spot Type, for Parameter ",ParameterNamesVec[coef]," and Spot Type ",SpotType,".",sep=""),HR=3))           
        Try(gal2 <-      cbind(gal,SpotTypeStatus=SpotTypeStatus))
        Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
        Try(numSpotTypes <- nrow(SpotTypes))
        Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
        Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
        Omit <- ""
        count <- 0
        Try(for (i in (1:numSpotTypes))
        {
          if (SpotTypesForLinearModel[i]==TRUE)
            next()
          count <- count + 1
          if (count>1)
            Omit <-paste(Omit,"|")
          else
            Omit <- "("
          Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
        })  
        Try(if (nchar(Omit)>0)
        {
          Try(Omit <- paste(Omit,")"))
          Try(Omit <- eval(parse(text=Omit)))
          Try(genelist2 <- uniquegenelist(gal2[!Omit,],ndups=ndups,spacing=spacing))
        }
        else
          Try(genelist2 <- uniquegenelist(gal2,ndups=ndups,spacing=spacing)))
        Try(subGeneList <- genelist2[genelist2[,"SpotTypeStatus"]==SpotType,])
        Try(t1 <- table((subGeneList[,"Name"])))
        Try(SpotSubTypes <- dimnames(t1)[[1]])
        Try(numMatches <- length(SpotSubTypes))
        if (numMatches==0) next()
        Try(if (NumParameters>1)
          ebayesStatisticsVector <- eb[[ebayesStatistic]][,coef]
        else
          ebayesStatisticsVector <- eb[[ebayesStatistic]])
        Try(plotTitle <- paste("t Statistic Box Plot(s) for Spot Type",SpotType))
        Try(ylabel <- "t Statistic")
        Try(if (numMatches<=50)
        {
          Try(plotCommand <- "boxplot(")
          Try(for (i in (1:numMatches))
            plotCommand <- paste(plotCommand,"ebayesStatisticsVector[genelist2[,\"Name\"]==\"",SpotSubTypes[i],"\"],",sep=""))
          Try(plotCommand <- paste(plotCommand,"names=c(",sep=""))
          Try(
          if (numMatches>1)
            for (i in (1:(numMatches-1)))
              plotCommand <- paste(plotCommand,"\"",SpotSubTypes[i],"\"",",",sep=""))
          Try(plotCommand <- paste(plotCommand,"\"",SpotSubTypes[numMatches],"\"),",sep=""))
          Try(if (numMatches>1)
            Try(plotCommand <- paste(plotCommand,"ylab=\"",ylabel,"\",main=plotTitle)",sep=""))
          else
            Try(plotCommand <- paste(plotCommand,"xlab=\"",SpotType,"\",","ylab=\"",ylabel,"\",main=plotTitle)",sep="")))
        }
        else
        {
          Try(plotCommand <- "boxplot(")
          Try(plotCommand <- paste(plotCommand,"ebayesStatisticsVector[genelist2[,\"SpotTypeStatus\"]==\"",SpotType,"\"],",sep=""))
          Try(plotCommand <- paste(plotCommand,"xlab=\"",SpotType,"\",","names=\"",SpotType,"\",",sep=""))
          Try(plotCommand <- paste(plotCommand,"ylab=\"",ylabel,"\",main=plotTitle)",sep=""))    
        })

      #  tkmessageBox(message=plotCommand)

        plotEbayesBoxPlot <- function()
        {
          Try(if (numMatches>50) 
          {
            Try(numMatches <- 1)
            Try(opar<-par(bg="white",lab=c(numMatches,20,7)))
          }
          else
            Try(opar<-par(bg="white",cex.axis=0.7,las=2,plt=c(0.15,0.9,0.2,0.85),lab=c(numMatches,20,7))))

          Try(eval(parse(text=plotCommand)))
          Try(tempGraphPar <- par(opar))    
          Try(grid(NULL,col="navy"))
        }
        Try(HTMLplotUsingFunction(Caption = plotTitle, File=fileNameWithPath, GraphRelativeDirectory = HTMLfileRelativePath , 
          GraphAbsoluteDirectory = HTMLfilePath, GraphFileName = paste("tStatBPsP",coef,"_ST_",SpotTypeIndex,sep=""), 
          GraphSaveAs = "png", GraphBorder = 1,  Align = "left", plotFunction=plotEbayesBoxPlot,
          Width=plotWidth,Height=plotHeight,PointSize=plotPointSize,BG=plotBG,res=plotRes))      

      })      
    }
  }

  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(HTMLhr())
  Try(HTMLli(txt="This report was generated by "))
  Try(HTMLli(txt=paste("limmaGUI Version",getPackageVersion("limmaGUI"),"(by James Wettenhall), using")))
  Try(HTMLli(txt=paste("limma Version",getPackageVersion("limma"),"(by Gordon Smyth),")))
  Try(HTMLli(txt=paste("R2HTML Version",getPackageVersion("R2HTML"),"(by Eric Lecoutre) and ")))
  Try(HTMLli(txt=paste("xtable Version",getPackageVersion("xtable"),"(by David Dahl)")))
  Try(HTMLEndFile())
}
ImportMA <- function()
{
  Try(WD <- SetWD())
  Try(if (WD=="") return())
  Try(FileNames <- ImportMADialog())
  
  Try(if (length(FileNames)==0 || FileNames$MFile=="" || FileNames$AFile=="")
    return())

  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))        
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))

  Try(if (NumParameterizations>0)
    for (parameterizationIndex in (1:NumParameterizations))
    {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
      Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,ParameterizationNameNode))
      Try(assign("ParameterizationList",deleteItemFromList(ParameterizationList,ParameterizationNameNode),limmaGUIenvironment))         
    })

  Try(initGlobals())
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))        
  Try(MAtemp <- read.marrayTools(FileNames$MFile,FileNames$AFile))

  Try(WhetherImportedDataHasBeenNormalized <- tclvalue(tkmessageBox(title="Importing M A Data",
    message="Has this data been normalized?",icon="question",type="yesno")))

  Try(assign("MAimported",MAtemp,limmaGUIenvironment))
  
  Try(gal <- as.data.frame(MAtemp$genes))
  
  Try(ColumnsToBeRemoved <- c())
  Try(if (("grid.r" %in% tolower(colnames(gal))))
    Try(ColumnsToBeRemoved <- c(ColumnsToBeRemoved,match("grid.r",tolower(colnames(gal))))))
  Try(if (("grid.c" %in% tolower(colnames(gal))))
    Try(ColumnsToBeRemoved <- c(ColumnsToBeRemoved,match("grid.c",tolower(colnames(gal))))))
  Try(if (length(ColumnsToBeRemoved)>0 && !("block" %in% tolower(colnames(gal))))
  {
    Try(gal <- data.frame(Block=rep(0,nrow(gal)),gal))
    Try(ColumnsToBeRemoved <- ColumnsToBeRemoved + 1) #Inserting Block shifts existing columns to right.
  })
  Try(ncolGAL <- length(colnames(gal)))
  Try(for (i in (1:ncolGAL))
  {
    Try(if (tolower(colnames(gal)[i])=="spot.r")
      Try(colnames(gal)[i] <- "Row"))
    Try(if (tolower(colnames(gal)[i])=="spot.c")
      Try(colnames(gal)[i] <- "Column"))  
  })
  Try(if (length(ColumnsToBeRemoved)>0)
  {
    Try(if (("grid.r" %in% tolower(colnames(gal)))&&("grid.c" %in% tolower(colnames(gal))))
    {
      Try(GridRcol <- match("grid.r",tolower(colnames(gal))))
      Try(GridCcol <- match("grid.c",tolower(colnames(gal))))
      Try(gal[,"Block"] <- (gal[,GridRcol]-1)*4+gal[,GridCcol])
    })
    Try(gal <- gal[,setdiff(colnames(gal),colnames(gal)[ColumnsToBeRemoved])])
  })
  
  Try(assign("gal",gal,limmaGUIenvironment))
  Try(MAtemp$genes <- gal)
  Try(assign("MA",MAtemp,limmaGUIenvironment))
  Try(if (WhetherImportedDataHasBeenNormalized=="yes")
  {
    Try(assign("RawMADataWasImported",FALSE,limmaGUIenvironment))
    Try(assign("NormalizedMADataWasImported",TRUE,limmaGUIenvironment))
  } else
  {
    Try(assign("RawMADataWasImported",TRUE,limmaGUIenvironment))
    Try(assign("NormalizedMADataWasImported",FALSE,limmaGUIenvironment))
  })
  
  Try(RawMADataWasImported <- get("RawMADataWasImported",envir=limmaGUIenvironment))
  Try(NormalizedMADataWasImported <- get("NormalizedMADataWasImported",envir=limmaGUIenvironment))  
  
  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))  
  Try(MA.Available$Raw <- FALSE)
  Try(MA.Available$WithinArrays <- FALSE)
  Try(MA.Available$BetweenArrays <- FALSE)
  Try(MA.Available$Both <- FALSE)
      
  Try(if (RawMADataWasImported)
  {
    Try(assign("ArraysLoaded",TRUE,limmaGUIenvironment))
    Try(assign("MAraw",MAtemp,limmaGUIenvironment))  
    Try(MA.Available$Raw <- TRUE)
		Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
		Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
    
    Try(RGtmp <- list())
    Try(RGtmp$R <- 2^(.5*MAtemp$M+MAtemp$A))
    Try(RGtmp$G <- 2^(MAtemp$A-.5*MAtemp$M))
    Try(assign("RG",new("RGList",RGtmp),limmaGUIenvironment))
    Try(assign("RG.Available",TRUE,limmaGUIenvironment))  
  })
  
  Try(assign("maLayout",getLayout(MAtemp$genes),limmaGUIenvironment))
  Try(assign("Layout.Available",TRUE,limmaGUIenvironment))
  
  Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))  
  Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))    
  Try(if (MA.Available$Raw)
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree)))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))

  Try(tkdelete(.limmaGUIglobals$mainTree,"RG.Status"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"Layout.Status"))          
  
  Try(RG.Available     <- get("RG.Available" , envir=limmaGUIenvironment))  
  Try(Layout.Available <- get("Layout.Available" , envir=limmaGUIenvironment))      
  
  Try(if (RG.Available)  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))    )
  Try(if (Layout.Available)  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))    )
  
  Try(assign("SpotTypes" , data.frame(SpotType=I("gene"),ID=I("*"),Name=I("*"),Color=I("black")),limmaGUIenvironment))
  Try(SlideNamesVec <- colnames(MAtemp$M))
  Try(assign("SlideNamesVec",SlideNamesVec,limmaGUIenvironment))
  Try(assign("NumSlides",length(SlideNamesVec),limmaGUIenvironment))
  Try(UpdateSpotTypesStatus())          
  Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(GetlimmaDataSetName())
  Try(tkfocus(.limmaGUIglobals$ttMain))        

  return()  
}

ImportMADialog <- function()
{
  Try(MFile <- tclVar("No file is selected."))
  Try(AFile <- tclVar("No file is selected."))
  
  Try(ttImportMA <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttImportMA))
  Try(tkgrab.set(ttImportMA))
  Try(tkfocus(ttImportMA))
  Try(tkwm.title(ttImportMA,"Import M and A"))
  Try(tkgrid(tklabel(ttImportMA,text="    ")))
  Try(label1 <- tklabel(ttImportMA,text="Select Log Ratios (M) File and Log Intensities (A) File",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttImportMA,text="    "), label1))
  Try(tkgrid.configure(label1,columnspan=2))
  Try(tkgrid(tklabel(ttImportMA,text="    ")))
  Try(label2 <- tklabel(ttImportMA,text="Log Ratio (M) File:",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttImportMA,text="    "), label2))
  Try(tkgrid.configure(label2,columnspan=2))     
  Try(label3 <- tklabel(ttImportMA,bg="white",font=.limmaGUIglobals$limmaGUIfont2,
      textvariable=MFile))
  Try(tkgrid(tklabel(ttImportMA,text="    "), label3))
  Try(tkgrid.configure(label3,columnspan=2))       
  Try(tkgrid(tklabel(ttImportMA,text="    ")))
  Try(label4 <- tklabel(ttImportMA,text="Log Intensity (A) File:",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttImportMA,text="    "), label4))
  Try(tkgrid.configure(label4,columnspan=2))         
  Try(label5 <- tklabel(ttImportMA,bg="white",font=.limmaGUIglobals$limmaGUIfont2,
      textvariable=AFile))
  Try(tkgrid(tklabel(ttImportMA,text="    "), label5))
  Try(tkgrid.configure(label5,columnspan=2))           
  Try(tkgrid(tklabel(ttImportMA,text="    ")))
  Try(tkgrid(tklabel(ttImportMA,text="    ")))
  
  Try(SelectMFile <- function() {Try(tmp<-tclvalue(tkgetOpenFile()));Try(if(nchar(tmp))tclvalue(MFile)<-tmp)})
  Try(SelectMButton <- tkbutton(ttImportMA,text="Select M File",font=.limmaGUIglobals$limmaGUIfont2,command=SelectMFile))
  Try(SelectAFile <- function() {Try(tmp<-tclvalue(tkgetOpenFile()));Try(if(nchar(tmp))tclvalue(AFile)<-tmp)})
  Try(SelectAButton <- tkbutton(ttImportMA,text="Select A File",font=.limmaGUIglobals$limmaGUIfont2,command=SelectAFile))
  
  Try(tkgrid(tklabel(ttImportMA,text="    "),SelectMButton,SelectAButton,tklabel(ttImportMA,text="    ")))

  Try(tkgrid(tklabel(ttImportMA,text="    ")))  

  ReturnVal <- list()
  
  Try(onOK <- function() 
  {
    Try(if (tclvalue(MFile)=="No file is selected.") tclvalue(MFile) <- "")
    Try(if (tclvalue(AFile)=="No file is selected.") tclvalue(AFile) <- "")
    Try(ReturnVal <<- list(MFile=tclvalue(MFile),AFile=tclvalue(AFile)))
    Try(tkgrab.release(ttImportMA));Try(tkdestroy(ttImportMA));Try(tkfocus(.limmaGUIglobals$ttMain))
  })
  Try(OK.but     <- tkbutton(ttImportMA,text="   OK   ",font=.limmaGUIglobals$limmaGUIfont2,command=onOK))
  Try(onCancel <- function() {Try(tkgrab.release(ttImportMA));Try(tkdestroy(ttImportMA));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal<<-list())})
  Try(Cancel.but <- tkbutton(ttImportMA,text=" Cancel ",font=.limmaGUIglobals$limmaGUIfont2,command=onCancel))  

  Try(tkgrid(tklabel(ttImportMA,text="    "),OK.but,Cancel.but))    
  Try(tkgrid(tklabel(ttImportMA,text="    ")))  

  Try(tkbind(ttImportMA, "<Destroy>", function(){Try(tkgrab.release(ttImportMA));Try(tkfocus(.limmaGUIglobals$ttMain));return(list())}))
  Try(tkwait.window(ttImportMA))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  return(ReturnVal)
}



read.marrayTools <- function(MFile,AFile,path=NULL,verbose=TRUE,sep="\t",quote="\"",header=TRUE,...) {
#	Extracts a genelist, M and A from outputfiles from marrayTools (using gpTools or spotTools)
#	James Wettenhall
#	1 Mar 2004.

	if(missing(MFile) || missing(AFile)) {
		stop("Must specify input files")
	}

	if(!is.null(path)) MFile <- file.path(path,MFile)
	if(!is.null(path)) AFile <- file.path(path,AFile)

	ncols <- ncol(tmp<-read.table(MFile,nrows=10,as.is=TRUE,header=TRUE))

	# Assume that the last annotation column does not contain numerical data.
	column <- ncols
	while(column>=0 && is.numeric(tmp[2,column])) 
		column <- column - 1 
	if (column==0)
		stop("A gene (annotation) column is expected immediately to the left of the numerical data.")

	NumAnnotationColumns <- column

	nslides <- ncols - NumAnnotationColumns

	nspots <- length(readLines(MFile)) - 1

	M <- read.table(MFile,sep=sep,quote=quote,header=header,as.is=TRUE,...)
	if(verbose) 
		cat(paste("Read",MFile,"\n"))
	A <- read.table(AFile,sep=sep,quote=quote,header=header,as.is=TRUE,...)  
	if(verbose) 
		cat(paste("Read",AFile,"\n"))

	MA <- list()
	MA$genes <- M[,1:NumAnnotationColumns]

	M <- M[,(NumAnnotationColumns+1):ncols]
	A <- A[,(NumAnnotationColumns+1):ncols]

	MA$M <- M
	MA$A <- A

	new("MAList",MA)
}



if (data.class(try(require(limma),TRUE))=="try-error")
{
    tkmessageBox(title="An error has occured!",message=paste("Cannot find package limma"),icon="error",type="ok")
    stop("Cannot find package limma")
} 
if (require(limma)==FALSE)
{
    tkmessageBox(title="An error has occured!",message=paste("Cannot find package limma"),icon="error",type="ok")
    stop("Cannot find package limma")
}


Try <- function(expr) 
{
    if (data.class(result<-try(expr,TRUE))=="try-error")
    {
        tkmessageBox(title="An error has occured!",message=as.character(result),icon="error",type="ok")
    } 
    else 
    {
        return (result)
    }
}

TryReadImgProcFile <- function(expr) 
{
    if (data.class(result<-try(expr,TRUE))=="try-error")
    {
        tkmessageBox(title="Reading Image Processing Files Failed!",
          message="limmaGUI was unable to read the image processing files listed in the Targets file.",icon="error",type="ok")
    } 
    else 
    {
        return (result)
    }
}


Require <- function(pkg) 
{
    if (data.class(result<-try(.find.package(pkg),TRUE))=="try-error")
    {
        tkmessageBox(title="An error has occured!",message=paste("Cannot find package",pkg),icon="error",type="ok")
    } 
    else 
    {
        result <- Try(require(pkg,character.only=TRUE))
    }
    return (result)
}


TclRequire <- function(tclPkg)
{
    if ((data.class(result<-try(tclRequire(tclPkg),TRUE))=="try-error") || (is.logical(result) && result==FALSE))
    {
      limmaGUIglobals <- .limmaGUIglobals
      limmaGUIglobals$TclRequireFailed <- TRUE
      assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv)
      Try(winTitle<-"Tcl/Tk Extension(s) Not Found")
      Try(message<-paste("Cannot find Tcl/Tk package \"", tclPkg,
      "\".  limmaGUI cannot continue.\n\n",
      "limmaGUI requires the Tcl/Tk extensions, BWidget and Tktable.\n",
      "You must have Tcl/Tk installed on your computer, not just the minimal\n",
      "Tcl/Tk installation which comes with R (for Windows).  If you do have\n",
      "Tcl/Tk installed, including the extensions (e.g. using the ActiveTcl\n",
      "distribution in Windows), make sure that R can find the path to the\n",
      "Tcl library, e.g. C:\\Tcl\\lib (on Windows) or /usr/lib (on Linux/Unix)\n",
      "or /sw/lib on Mac OSX.\n\n",
      "If you don't know how to set environment variables in Windows, one way\n",
      "to make sure that R can find the Tcl/Tk extensions Tktable2.8 and bwidget1.6\n",
      "is to copy them from your ActiveTcl installation e.g. in C:\\Tcl\\lib into\n",
      "the Tcl subdirectory of your R installation.\n",
      "If you do understand how to set environment variables...\n",
      "make sure that you have the TCL_LIBRARY environment variable set to the\n",
      "appropriate path, e.g.C:\\Tcl\\lib\\tcl8.4 and the MY_TCLTK environment\n",
      "variable set to a non-empty string, e.g. \"Yes\".\n\n",
      "If using Windows, be sure to read the R for windows FAQ at\nhttp://www.stats.ox.ac.uk/pub/R/rw-FAQ.html\n\n",
      "If your Tcl/Tk extensions still can't be found, try\n",
      "addTclPath(\"<path to Tcl library>\").\nThis could be put in $HOME/.Rprofile\n\n",
      "If you need further instructions, please contact your system administrator\n",
      "and consider emailing r-help@stat.math.ethz.ch, or browse through the R-help\n",
      "archives for a similar question.\n\n",
      "The URLs for Tktable and BWidget are:\n",
      "http://tktable.sourceforge.net\n",
      "http://tcllib.sourceforge.net",      
      sep=""))
      
      # Don't make ttMain a parent of this, because we might want to use TclRequire before
      # defining ttMain.
      Try(ttTclTkExtension <- tktoplevel())
      onDestroy <- function()
      {
        if (exists(".limmaGUIglobals",envir=.GlobalEnv)&&"ttMain" %in% names(.limmaGUIglobals))
          try(tkdestroy(.limmaGUIglobals$ttMain),silent=TRUE)        
        else
          stop("Tcl/Tk extensions (Tktable and BWidget) not found!")
        stop("Aborted from limmaGUI.")
      }
	    Try(tkbind(ttTclTkExtension, "<Destroy>", onDestroy))
      Try(tkwm.title(ttTclTkExtension,winTitle))
      Try(tkwm.deiconify(ttTclTkExtension))
      Try(scr <- tkscrollbar(ttTclTkExtension, repeatinterval=5,
                             command=function(...)tkyview(txt,...)))
      Try(txt <- tktext(ttTclTkExtension,bg="white",yscrollcommand=function(...)tkset(scr,...)))
      Try(tkgrid(txt,scr,columnspan=2))
      Try(tkgrid.configure(scr,columnspan=1,sticky="ns"))
      Try(tkgrid.configure(txt,sticky="nsew"))
      Try(tkinsert(txt,"end",message))
      Try(tkconfigure(txt, state="disabled"))
      Try(tkfocus(txt))
      Try(onOK <- function() 
      {
        try(tkdestroy(ttTclTkExtension),silent=TRUE)
        if (exists(".limmaGUIglobals",envir=.GlobalEnv)&&"ttMain" %in% names(.limmaGUIglobals))
          try(tkdestroy(.limmaGUIglobals$ttMain),silent=TRUE)        
        else
          stop("Tcl/Tk extensions (Tktable and BWidget) not found!")
        Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))    
        Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
        if (limmaDataSetNameText!="Untitled")
        {
          Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled") LimmaFileName <- limmaDataSetNameText) # Local assignment only
          Try(mbVal <- tkmessageBox(title="Aborting from limmaGUI",
                message=paste("Save changes to ",LimmaFileName,"?",sep=""),
                icon="question",type="yesno",default="yes"))
          try(if (tclvalue(mbVal)=="yes")
              try(SaveLimmaFile(),silent=TRUE),silent=TRUE)
         }
         stop("Tcl/Tk extensions (Tktable and BWidget) not found!")
      })
      Try(OK.but <- tkbutton(ttTclTkExtension,text="  OK  ",command=onOK))  
      Try(tkgrid.configure(txt,columnspan=2))
      Try(tkgrid(tklabel(ttTclTkExtension,text="    ")))
      Try(tkgrid(tklabel(ttTclTkExtension,text="limmaGUI will now exit."),columnspan=2))
      Try(tkgrid(tklabel(ttTclTkExtension,text="    ")))      
      Try(tkgrid(OK.but))
      Try(tkgrid.configure(OK.but,sticky="e"))
      Try(tkgrid(tklabel(ttTclTkExtension,text="    ")))    
      Try(tkfocus(OK.but))
      Try(tkwait.window(ttTclTkExtension))            
    }
}

onDestroy <- function()
{
 Try(.JustAskedWhetherToSave <- get(".JustAskedWhetherToSave",envir=.GlobalEnv))    
 Try(if (.JustAskedWhetherToSave==FALSE)
 {
	 Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))    
	 Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
	 if (limmaDataSetNameText!="Untitled")
	 {
		 Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled") LimmaFileName <- limmaDataSetNameText) # Local assignment only
		 Try(mbVal <- tkmessageBox(title="Aborting from limmaGUI",
					 message=paste("Save changes to ",LimmaFileName,"?",sep=""),
					 icon="question",type="yesno",default="yes"))
		 try(if (tclvalue(mbVal)=="yes")
				 try(SaveLimmaFile(),silent=TRUE),silent=TRUE)              
	 }
	 Try(assign(".JustAskedWhetherToSave",TRUE,.GlobalEnv))
 })
}


limmaGUI <- function(BigfontsForlimmaGUIpresentation=FALSE)
{
  assign("limmaGUIenvironment",new.env(),.GlobalEnv)
  assign("Try",get("Try",envir=.GlobalEnv),limmaGUIenvironment)
  # This option is for when I give a Presentation/talk on limmaGUI and want large limmaGUIfonts.  Currently, there are
  # some limmaGUIfonts which limmaGUI can't control, like menus, so as well as changing BigfontsForlimmaGUIpresentation to TRUE here, I
  # Right-Click the Windows Desktop, click Properties (to get Display properties which can also be accessed
  # through the Control Panel) then click on Appearance, and then change the limmaGUIfont size for menu,window title, etc.)
  # Rather than change each limmaGUIfont (menu,window title,...) manually each time, I save the changes as a "scheme".  
  Try(limmaGUIglobals <- list())
  Try(if (BigfontsForlimmaGUIpresentation==TRUE)
    Try(limmaGUIglobals$limmaGUIpresentation <- TRUE)
  else
    Try(limmaGUIglobals$limmaGUIpresentation <- FALSE))
  Try(limmaGUIglobals$limmaDataSetNameTcl <- tclVar("Untitled"))
  Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))
  Try(initGlobals())

  Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=.GlobalEnv))
  limmaGUIglobals$Myhscale <- 1
  limmaGUIglobals$Myvscale <- 1
  assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv)

  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
  {
 
   Try(if (Sys.info()["sysname"]=="Darwin")
   {
     Try(addTclPath("/sw/lib/tcl8.4"))
     Try(addTclPath("/sw/lib"))
     Try(addTclPath("./lib"))
     Try(addTclPath("/sw/lib/tk8.4"))
     Try(addTclPath(paste(Sys.getenv("HOME"),.Platform$file.sep,"TkExtensions",sep="")))
   })    
   Try(addTclPath("/usr/local/lib"))
   Try(addTclPath("/usr/local/Tcl/lib"))
   Try(addTclPath("/usr/local/lib/Tcl"))
   Try(addTclPath("/usr/lib"))
   Try(addTclPath("/usr/lib/Tcl"))
   Try(addTclPath("/usr/local/ActiveTcl/lib"))
   Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=.GlobalEnv))
   Try(limmaGUIglobals$Myhscale <- 1)
   Try(limmaGUIglobals$Myvscale <- 1)
   Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))
 })

  Try(if (Sys.info()["sysname"] == "Windows") 
  {
   Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=.GlobalEnv))
   Try(limmaGUIglobals$Myhscale <- 1.6)
   Try(limmaGUIglobals$Myvscale <- 1.6)
   Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))
  })

  Try(if (Sys.info()["sysname"] == "Darwin" && !exists("X11", env=.GlobalEnv)) 
  {
    Try(addTclPath("/Library/Tcl"))
    Try(addTclPath("/Network/Library/Tcl"))
    Try(addTclPath("/System/Library/Tcl"))
    Try(addTclPath("/Library/Frameworks/Tcl"))
    Try(HOME <- Sys.getenv("HOME"))
    Try(if (nchar(HOME)>0)
    {
      Try(addTclPath(paste(HOME,"/Library/Tcl",sep="")))
      Try(addTclPath(paste(HOME,"/Network/Library/Tcl",sep="")))
      Try(addTclPath(paste(HOME,"/System/Library/Tcl",sep="")))
      Try(addTclPath(paste(HOME,"/Library/Frameworks/Tcl",sep="")))
    })
    Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=.GlobalEnv))
    Try(limmaGUIglobals$Myhscale <- 1)
    Try(limmaGUIglobals$Myvscale <- 1)
    Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))
  })

  Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=.GlobalEnv))
  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)
    Try(limmaGUIglobals$limmaGUIfont1 <- tkfont.create(family="times",size=48,weight="bold",slant="italic"))
  else
    Try(limmaGUIglobals$limmaGUIfont1 <- tkfont.create(family="times",size=24,weight="bold",slant="italic")))
  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)  
    Try(limmaGUIglobals$limmaGUIfont2 <- tkfont.create(family="arial",size=16))
  else
    Try(limmaGUIglobals$limmaGUIfont2 <- tkfont.create(family="arial",size=10)))
  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)  
    Try(limmaGUIglobals$limmaGUIfontTree <- tkfont.create(family="arial",size=14))
  else
    Try(limmaGUIglobals$limmaGUIfontTree <- tkfont.create(family="arial",size=10)))

  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)  
    Try(limmaGUIglobals$limmaGUIfontTable <- tkfont.create(family="arial",size=16))
  else
    Try(limmaGUIglobals$limmaGUIfontTable <- tkfont.create(family="arial",size=10)))
  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)  
    Try(limmaGUIglobals$limmaGUIfontTopTable <- tkfont.create(family="arial",size=12,weight="bold"))
  else
    Try(limmaGUIglobals$limmaGUIfontTopTable <- limmaGUIglobals$limmaGUIfontTable))

  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)    
    Try(limmaGUIglobals$limmaGUIfont2b <- tkfont.create(family="arial",size=16,weight="bold"))
  else
    Try(limmaGUIglobals$limmaGUIfont2b <- tkfont.create(family="arial",size=10,weight="bold")))

  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)  
    Try(limmaGUIglobals$limmaGUIfontCourier <- tkfont.create(family="courier",size=16))
  else
    Try(limmaGUIglobals$limmaGUIfontCourier <- tkfont.create(family="courier",size=10)))

  Try(limmaGUIglobals$mainTreeWidth <- 30)

  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)
    Try(limmaGUIglobals$ParameterizationTREEWidth <- 40)
  else
    Try(limmaGUIglobals$ParameterizationTREEWidth <- 30))

  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)  
  {
    Try(limmaGUIglobals$ParameterizationTREEHeight <- 20)
    Try(limmaGUIglobals$mainTreeHeight,20)
  }
  else
  {
    Try(limmaGUIglobals$ParameterizationTREEHeight <- 15)
    Try(limmaGUIglobals$mainTreeHeight <- 15)  
  })

  Try(limmaGUIglobals$oldOptions <- options(warn=-1)) # Otherwise R complains that I'm trying to set main in plots, i.e. set a plot title)

# Maybe it would be nice to eventually use the MainFrame widget from BWidget so we can have a nice toolbar etc.
  Try(limmaGUIglobals$ttMain <- tktoplevel())
  Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))

	Try(tkbind(.limmaGUIglobals$ttMain, "<Destroy>", onDestroy))

  TclRequire("BWidget")
  if ("TclRequireFailed" %in% names(.limmaGUIglobals))
    stop("Error occurred in TclRequire(\"BWidget\")")
  TclRequire("Tktable")
  if ("TclRequireFailed" %in% names(.limmaGUIglobals))  
    stop("Error occurred in TclRequire(\"Tktable\")")
  
  Try(if (.limmaGUIglobals$limmaGUIpresentation==FALSE)
    Try(mainFrame <- tkframe(.limmaGUIglobals$ttMain,relief="groove",borderwidth="2"))
  else
    Try(mainFrame <- tkframe(.limmaGUIglobals$ttMain)))    
  Try(if (.limmaGUIglobals$limmaGUIpresentation==FALSE)
  {
    Try(toolbarFrame <- tkframe(mainFrame,relief="groove",borderwidth="2"))
    Try(tb <- tkframe(toolbarFrame,relief="groove",borderwidth="2"))
    # The Bitmap::get stuff below requires the BWidget package.
    # I think this could be done more simply with something like :
    #   Try(newButton <- tkbutton(tb,image=tkcmd("Bitmap::get","new"),command=NewLimmaFile))
    Try(newButton <- .Tcl(paste("button",.Tk.subwin(tb),"-image [Bitmap::get new]",.Tcl.args(command=NewLimmaFile))))
    Try(openButton <- .Tcl(paste("button",.Tk.subwin(tb),"-image [Bitmap::get open]",.Tcl.args(command=OpenLimmaFile))))
    Try(saveButton <- .Tcl(paste("button",.Tk.subwin(tb),"-image [Bitmap::get save]",.Tcl.args(command=SaveLimmaFile))))  
    Try(tkgrid(newButton,openButton,saveButton,sticky="w"))
    Try(tkgrid(tb,sticky="nw"))
  #  Try(tkgrid(toolbarFrame,sticky="ew"))
    Try(tkgrid(toolbarFrame,sticky="w"))
  #  Try(tkgrid.configure(tb,sticky="w"))
  })
  
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(LimmaFileName <- get("LimmaFileName",limmaGUIenvironment))
  Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled") LimmaFileName <- limmaDataSetNameText) # Local assignment only 
  Try(tkwm.title(.limmaGUIglobals$ttMain,paste("LimmaGUI -",LimmaFileName)))
  Try(limmaGUIglobals <- .limmaGUIglobals)  
  Try(limmaGUIglobals$GALfileBoxTitle <- tclVar("Please select a GenePix Array List (GAL) file."))
  Try(limmaGUIglobals$GALfileNameTcl <- tclVar("No filename is selected at the moment.  Press the Select GAL File Button."))
  Try(limmaGUIglobals$TargetsfileBoxTitleTcl <- tclVar("Please select a tab-delimited file listing the microarray hybridizations."))
  Try(limmaGUIglobals$TargetsfileNameTcl <- tclVar("No filename is selected at the moment.  Press the Select Targets File Button."))
  Try(limmaGUIglobals$SpotTypesfileBoxTitleTcl <- tclVar("Please select a tab-delimited file listing the spot types."))
  Try(limmaGUIglobals$SpotTypesfileNameTcl <- tclVar("No filename is selected at the moment.  Press the Select Spot-Types File Button."))
  Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))
   
  Try(tkgrid(tklabel(mainFrame,text="         "),columnspan=3))
  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)
    Try(tkgrid(tklabel(mainFrame,text="LimmaGUI",font=.limmaGUIglobals$limmaGUIfont1),column=1,columnspan=3,sticky="ew"))
  else
    Try(tkgrid(tklabel(mainFrame,text="     LimmaGUI ",font=.limmaGUIglobals$limmaGUIfont1),column=2,sticky="ew")))
  Try(tkgrid(tklabel(mainFrame,text="Welcome to LimmaGUI, a package for Linear Modelling of Microarray Data",font=.limmaGUIglobals$limmaGUIfont2),columnspan=5))
  Try(tkgrid(tklabel(mainFrame,text="         "),columnspan=5))
  Try(tkgrid(tklabel(mainFrame,text="         "),columnspan=5))
  Try(limmaDataSetName.but <- tkbutton(mainFrame,text="Data Set Name",command=GetlimmaDataSetName,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(limmaDataSetName.but,column=2,columnspan=1))
  Try(tkgrid(tklabel(mainFrame,text="         "),columnspan=5))
  Try(mainTreeXScr <- tkscrollbar(mainFrame, repeatinterval=5,command=function(...)tkxview(.limmaGUIglobals$mainTree,...),orient="horizontal"))
  Try(mainTreeYScr <- tkscrollbar(mainFrame, repeatinterval=5,command=function(...)tkyview(.limmaGUIglobals$mainTree,...)))
  Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=.GlobalEnv))
  Try(limmaGUIglobals$mainTree <- tkwidget(mainFrame,"Tree",xscrollcommand=function(...)tkset(mainTreeXScr,...),yscrollcommand=function(...)tkset(mainTreeYScr,...),width=.limmaGUIglobals$mainTreeWidth,height=.limmaGUIglobals$mainTreeHeight,bg="white"))
  Try(LinModTreeXScr <- tkscrollbar(mainFrame, repeatinterval=5,command=function(...)tkxview(.limmaGUIglobals$ParameterizationTREE,...),orient="horizontal"))
  Try(LinModTreeYScr <- tkscrollbar(mainFrame, repeatinterval=5,command=function(...)tkyview(.limmaGUIglobals$ParameterizationTREE,...)))
  Try(limmaGUIglobals$ParameterizationTREE <- tkwidget(mainFrame,"Tree",xscrollcommand=function(...)tkset(LinModTreeXScr,...),yscrollcommand=function(...)tkset(LinModTreeYScr,...),width=.limmaGUIglobals$ParameterizationTREEWidth,height=.limmaGUIglobals$ParameterizationTREEHeight,bg="white"))
  Try(limmaGUIglobals$limmaDataSetNameTextLabel <- tklabel(mainFrame,text=limmaDataSetNameText,font=.limmaGUIglobals$limmaGUIfont2b))
  Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))
  Try(tkgrid(tklabel(mainFrame,text="    "),.limmaGUIglobals$limmaDataSetNameTextLabel,tklabel(mainFrame,text="    "),tklabel(mainFrame,text="PARAMETERIZATIONS",font=.limmaGUIglobals$limmaGUIfont2b),tklabel(mainFrame,text="                ")))
  Try(tkgrid(tklabel(mainFrame,text="    "),.limmaGUIglobals$mainTree,mainTreeYScr,.limmaGUIglobals$ParameterizationTREE,LinModTreeYScr))
  Try(tkconfigure(.limmaGUIglobals$limmaDataSetNameTextLabel,textvariable=.limmaGUIglobals$limmaDataSetNameTcl))
  Try(tkgrid.configure(.limmaGUIglobals$mainTree,rowspan=6,sticky="ns"))
  Try(tkgrid.configure(mainTreeYScr,rowspan=6,sticky="wns"))
  Try(tkgrid.configure(.limmaGUIglobals$ParameterizationTREE,rowspan=6,sticky="ns"))
  Try(tkgrid.configure(LinModTreeYScr,rowspan=6,sticky="wns"))
  Try(tkgrid(tklabel(mainFrame,text="    "),mainTreeXScr,tklabel(mainFrame,text="    "),LinModTreeXScr))
  Try(tkgrid.configure(mainTreeXScr,sticky="ewn"))
  Try(tkgrid.configure(LinModTreeXScr,sticky="ewn"))

  Try(tkgrid(tklabel(mainFrame,text="         "),columnspan=5))
  
  Try(tkgrid(mainFrame))

  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","RG" ,text="R and G",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","BC" ,text="Background Correction",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BC","BC.Status" ,text="subtract",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","WeightingType" ,text="Spot Quality Weighting",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WeightingType","WeightingType.Status" ,text="none",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","MA" ,text="M and A",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","Raw" ,text="Raw",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","WithinOnly" ,text="Within-Array Normalized",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","BetweenOnly" ,text="Between-Array Normalized",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","WithinAndBetween",text="Within and Between-Array Normalized",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Layout", text="Layout",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Parameterizations" ,text="Parameterizations",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations","Parameterizations.Status.1" ,text="None",font=.limmaGUIglobals$limmaGUIfontTree))

  # Menu code below was taken from Rcmdr (and slightly modified)

  Try(etc <- system.file("etc",package="limmaGUI"))
  Try(cat(paste("\nSearching for user-defined limmaGUI commands in",etc,"...\n")))
  Try(source.files <- list.files(etc, pattern="*.R$"))
    Try(for (file in source.files) {
        Try(source(file.path(etc, file)))
        Try(cat(paste("Sourced:", file, "\n")))
        })

  Try(topMenu <- tkmenu(.limmaGUIglobals$ttMain))
  Try(tkconfigure(.limmaGUIglobals$ttMain,menu=topMenu))
  Try(Menus <- read.table(file.path(system.file("etc",package="limmaGUI"),"limmaGUI-menus.txt"), as.is=TRUE))
  Try(for (m in 1:nrow(Menus)){
		Try(if (Menus[m, 1] == "menu") assign(Menus[m, 2], tkmenu(eval(parse(text=Menus[m, 3])), tearoff=FALSE)) 
		else if (Menus[m, 1] == "item") {
				if (Menus[m, 3] == "command")
						tkadd(eval(parse(text=Menus[m, 2])),"command", label=Menus[m, 4], command=eval(parse(text=Menus[m, 5])))
				else if (Menus[m, 3] == "cascade")
						tkadd(eval(parse(text=Menus[m, 2])),"cascade", label=Menus[m, 4], menu=eval(parse(text=Menus[m, 5])))
			  else if (Menus[m, 3] == "separator")
			      tkadd(eval(parse(text=Menus[m, 2])),"separator")
				else stop(paste("menu defintion error:", Menus[m, ], collapse=" "))
				}
		else stop(paste("menu defintion error:", Menus[m, ], collapse=" ")))
		})

  Try(limmaGUIglobals <- get(".limmaGUIglobals",envir=limmaGUIenvironment))
  Try(limmaGUIglobals$mainMenu <- topMenu)
  Try(assign(".limmaGUIglobals",limmaGUIglobals,.GlobalEnv))

  Try(if (.limmaGUIglobals$limmaGUIpresentation==FALSE)
  {
    Try(labelStatusBar <- tklabel(.limmaGUIglobals$ttMain,font=.limmaGUIglobals$limmaGUIfont2))
    Try(tkgrid(labelStatusBar,sticky="w"))
    Try(CurrentStatus <- tclVar("    "))
    Try(tkconfigure(labelStatusBar,textvariable=CurrentStatus))
    Try(tkbind(saveButton,"<Enter>",function() tclvalue(CurrentStatus) <- "Save the current Limma file."))
    Try(tkbind(saveButton,"<Leave>",function() tclvalue(CurrentStatus) <- "    "))
    Try(tkbind(openButton,"<Enter>",function() tclvalue(CurrentStatus) <- "Open an existing Limma file."))
    Try(tkbind(openButton,"<Leave>",function() tclvalue(CurrentStatus) <- "    "))
    Try(tkbind(newButton,"<Enter>",function() tclvalue(CurrentStatus) <- "Start a new Limma analysis."))
    Try(tkbind(newButton,"<Leave>",function() tclvalue(CurrentStatus) <- "    "))
  })
  
  #Try(tkwm.resizable(.limmaGUIglobals$ttMain,"true","false"))

  Try(tkbind(.limmaGUIglobals$ttMain, "<Control-N>", NewLimmaFile))
  Try(tkbind(.limmaGUIglobals$ttMain, "<Control-S>", SaveLimmaFile))
  Try(tkbind(.limmaGUIglobals$ttMain, "<Control-O>", OpenLimmaFile))
  Try(tkbind(.limmaGUIglobals$ttMain, "<Control-n>", NewLimmaFile))
  Try(tkbind(.limmaGUIglobals$ttMain, "<Control-s>", SaveLimmaFile))
  Try(tkbind(.limmaGUIglobals$ttMain, "<Control-o>", OpenLimmaFile))

  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(temp <- options(.limmaGUIglobals$oldOptions))
  invisible()
}

limmaGUIhelp <- function() 
{
    Try(limmaGUIhelpIndex <- file.path(system.file("doc",package="limmaGUI"),"index.html"))
    Try(browseURL(limmaGUIhelpIndex))
    Try(tkmessageBox(title="limmaGUI Help",message=paste("Opening limmaGUI help...\nIf nothing happens, please open :\n",limmaGUIhelpIndex,"\nyourself.",sep="")))
}

limmaHelp <- function() 
{
    Try(limmaHelpIndex <- file.path(system.file("doc",package="limma"),"usersguide.html"))
    Try(browseURL(limmaHelpIndex))
    Try(tkmessageBox(title="limma Help",message=paste("Opening limma help...\nIf nothing happens, please open :\n",limmaHelpIndex,"\nyourself.",sep="")))
}


getPackageVersion <- function(pkgName)
{
  DESCRIPTION <- readLines(paste(system.file(package=pkgName),"/DESCRIPTION",sep=""))
  lineNum <- grep("Version",DESCRIPTION)
  VersionLineWords <- strsplit(DESCRIPTION[lineNum]," ")[[1]]
  numWords <- length(VersionLineWords)
  VersionLineWords[numWords]
}

initGlobals <- function()
{
  assign("limmaGUIVersion",getPackageVersion("limmaGUI"),limmaGUIenvironment)
  assign("limmaVersion",getPackageVersion("limma"),limmaGUIenvironment)  
  assign("LimmaFileName","Untitled",limmaGUIenvironment)
  assign("maLayout",list(),limmaGUIenvironment)
  assign("MA" , list(M=matrix(data=0,nrow=1,ncol=1),A=matrix(data=0,nrow=1,ncol=1)),limmaGUIenvironment)
  assign("MAraw" , list(),limmaGUIenvironment)
  assign("MAwithinArrays" , list(),limmaGUIenvironment)
  assign("MAbetweenArrays" , list(),limmaGUIenvironment)  
  assign("MAboth" , list(),limmaGUIenvironment)    
  assign("RG" , 0,limmaGUIenvironment)
  assign("GALFile" , "",limmaGUIenvironment)
  assign("ParameterizationList" , list(),limmaGUIenvironment)
  assign("gal" , data.frame(),limmaGUIenvironment)
  assign("NumSlides" , 0,limmaGUIenvironment)
  assign("NumParameterizations", 0, limmaGUIenvironment)
  assign("ParameterizationNamesVec", c(), limmaGUIenvironment)
  assign("ParameterizationTreeIndexVec",c(), limmaGUIenvironment)
  assign("NumParameters" , 0,limmaGUIenvironment)
  assign("SlideNamesVec" , c(),limmaGUIenvironment)
  assign("Targets" , data.frame(),limmaGUIenvironment)
  assign("SpotTypes" , data.frame(),limmaGUIenvironment)
  assign("SpotTypeStatus" , c(),limmaGUIenvironment)
  assign("ndups" , 1,limmaGUIenvironment)
  assign("spacing" , 1,limmaGUIenvironment)
  assign("limmaDataSetNameText" , "Untitled",limmaGUIenvironment)
  Try(tclvalue(.limmaGUIglobals$limmaDataSetNameTcl) <- "Untitled")
  assign("ArraysLoaded",FALSE,limmaGUIenvironment)
  assign("LinearModelComputed",rep(FALSE,100),limmaGUIenvironment)  # Maximum of 100 parameterizations for now.
  assign("WeightingType","none", limmaGUIenvironment)
  assign("AreaLowerLimit",160, limmaGUIenvironment)
  assign("AreaUpperLimit",170, limmaGUIenvironment)
#  assign("FlagSpotWeighting", 0.1, limmaGUIenvironment)
  assign("MA.Available",list(Raw=FALSE,WithinArrays=FALSE,BetweenArrays=FALSE,Both=FALSE),limmaGUIenvironment)
  assign("RG.Available",FALSE,limmaGUIenvironment)
  assign("Layout.Available",FALSE,limmaGUIenvironment)  
  assign("numConnectedSubGraphs",1,limmaGUIenvironment)
  assign("connectedSubGraphs",list(),limmaGUIenvironment)  
  assign("NumRNATypes",2,limmaGUIenvironment)
  assign("WithinArrayNormalizationMethod","printtiploess",limmaGUIenvironment)
  assign(".JustAskedWhetherToSave",FALSE,.GlobalEnv)
  assign("MAimported",new("MAList"),limmaGUIenvironment)
  assign("RawMADataWasImported",FALSE,limmaGUIenvironment)  
  assign("NormalizedMADataWasImported",FALSE,limmaGUIenvironment)
  assign("BCMethod","subtract",limmaGUIenvironment)  
}

deleteItemFromList <- function(list1,itemName=NULL,index=NULL)
{
    if (is.null(index))
      index <- match(itemName,attributes(list1)$names)
    if (is.na(index))
        return(list1)
    len <- length(list1)
    newlist <- list()
    count <- 0
    for (i in (1:len))
        if (i!=index)
        {
            count <- count + 1
            if (!is.null(attributes(list1)$names[i]))
            {
              newlist <- c(newlist,list(foo=list1[[i]]))
              attributes(newlist)$names[count] <- attributes(list1)$names[i]
            }
            else
              newlist[[count]] <- list1[[i]]
        }
    return (newlist)    
}

SetLayoutParameters <- function()
{
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Layout Parameters",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))      
      return()
  }
  
  Try(gal <- get("gal",envir=limmaGUIenvironment))
  
  ttLayout<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttLayout)
  tkgrab.set(ttLayout)
  tkfocus(ttLayout)
  tkwm.title(ttLayout,"Layout Parameters")
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
  if (length(maLayout)==0)
  {
    Try(nspot.r <- tclVar(init="0"))
    Try(nspot.c <- tclVar(init="0"))
    Try(ngrid.r <- tclVar(init="0"))
    Try(ngrid.c <- tclVar(init="0"))
  }
  else
  {
    Try(nspot.r <- tclVar(init=paste(maLayout$nspot.r)))
    Try(nspot.c <- tclVar(init=paste(maLayout$nspot.c)))
    Try(ngrid.r <- tclVar(init=paste(maLayout$ngrid.r)))
    Try(ngrid.c <- tclVar(init=paste(maLayout$ngrid.c)))
  }
  tkgrid(tklabel(ttLayout,text="       "))
  entry.nspot.r <-tkentry(ttLayout,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=nspot.r,bg="white")
  entry.nspot.c <-tkentry(ttLayout,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=nspot.c,bg="white")
  entry.ngrid.r <-tkentry(ttLayout,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=ngrid.r,bg="white")
  entry.ngrid.c <-tkentry(ttLayout,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=ngrid.c,bg="white")

  GetFromGAL <- function()
  {
    Try(gal <- get("gal",envir=limmaGUIenvironment))
    tmpLayout <- getLayout(gal)
    tclvalue(nspot.r) <- tmpLayout$nspot.r
    tclvalue(nspot.c) <- tmpLayout$nspot.c
    tclvalue(ngrid.r) <- tmpLayout$ngrid.r
    tclvalue(ngrid.c) <- tmpLayout$ngrid.c
  }

  ReturnVal <- 0
  
  onOK <- function(){
        Try(assign("Layout.Available",TRUE,limmaGUIenvironment))
        Try(tkdelete(.limmaGUIglobals$mainTree,"Layout.Status"))        
        Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status",text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
        Try(assign("maLayout",list(ngrid.r=as.integer(tclvalue(ngrid.r)), ngrid.c=as.integer(tclvalue(ngrid.c)), nspot.r=as.integer(tclvalue(nspot.r)), nspot.c=as.integer(tclvalue(nspot.c))),limmaGUIenvironment))
        Try(tkgrab.release(ttLayout));Try(tkdestroy(ttLayout));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- 1}
  onCancel <- function() {Try(tkgrab.release(ttLayout));Try(tkdestroy(ttLayout));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- 0}        
  OK.but <-tkbutton(ttLayout,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  guess.but <-tkbutton(ttLayout,text="Determine from GAL file",command=GetFromGAL,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttLayout,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)

  tkgrid(tklabel(ttLayout,text="Number of rows of blocks",font=.limmaGUIglobals$limmaGUIfont2),entry.ngrid.r,sticky="w")
  tkgrid(tklabel(ttLayout,text="Number of columns of blocks",font=.limmaGUIglobals$limmaGUIfont2),entry.ngrid.c,sticky="w")
  tkgrid(tklabel(ttLayout,text="Number of rows per block",font=.limmaGUIglobals$limmaGUIfont2),entry.nspot.r,sticky="w")
  tkgrid(tklabel(ttLayout,text="Number of columns per block",font=.limmaGUIglobals$limmaGUIfont2),entry.nspot.c,sticky="w")
  tkgrid(guess.but)
  tkgrid(OK.but,Cancel.but)
  tkgrid(tklabel(ttLayout,text="    "))
  if (length(maLayout)==0 && length(gal)>0)
      GetFromGAL()
  Try(tkfocus(ttLayout))

  Try(tkbind(ttLayout, "<Destroy>", function() {Try(tkgrab.release(ttLayout));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttLayout))

  return(ReturnVal)
}


# This will be deleted soon, but it will remain a bit longer, just to make sure limmaGUI
# users are using limma 1.2.1 or later.
readGALlimmaGUI <- function(galfile=NULL,path=NULL,header=TRUE,sep="\t",quote="\"",skip=NULL,as.is=TRUE,fill=TRUE,...) {
# Read GenePix Allocation List (GAL) file
# Gordon Smyth
# 1 Mar 2003.  Last revised 16 Sept 2003.

  if(is.null(galfile)) {
    if(is.null(path)) path <- "."
    galfile <- dir(path=path,pattern="*\\.gal$")
    nfiles <- length(galfile)
    if(nfiles == 0) stop("Cannot find GAL file")
    if(nfiles > 1) {
      galfile <- galfile[1]
      warning(paste("More than one GAL file found. Reading",galfile))
    }
  }
  if(!is.null(path)) galfile <- file.path(path,galfile)
  if(is.null(skip)) {
    chunk <- readLines(galfile,n=100)
    skip <- intersect(grep("Name",chunk), grep("ID",chunk)) - 1
    n <- length(skip)
    if(n == 0) stop("Cannot find ID and Name columns in GAL file")
    if(n > 1) stop("Multiple lines with ID and Name labels")
  }
  read.table(galfile,header=header,sep=sep,quote=quote,skip=skip,as.is=as.is,comment.char="",fill=fill,...)
}


OpenGALFile <- function()
{
  Try(tmpGALFile <- tclvalue(tkgetOpenFile(filetypes="{{GAL Files} {.gal}} {{All files} *}")))
  Try(if (!nchar(tmpGALFile)) return())
  Try(assign("GALFile",tmpGALFile,limmaGUIenvironment))
  Try(GALFile <- get("GALFile",envir=limmaGUIenvironment))
  Try(tclvalue(.limmaGUIglobals$GALfileBoxTitle) <- "GenePix Array List (GAL) File")
  Try(tclvalue(.limmaGUIglobals$GALfileNameTcl) <-paste(GALFile))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(gal <- readGALlimmaGUI(galfile=GALFile,fill=TRUE))
  Try(gal$ID <- as.character(gal$ID))
  Try(gal$Name <- as.character(gal$Name))  
  Try(assign("gal",gal,limmaGUIenvironment))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))  
  Try(ArraysLoaded <- FALSE)
  Try(assign("ArraysLoaded",ArraysLoaded,limmaGUIenvironment))

  tkfocus(.limmaGUIglobals$ttMain)
}

OpenTargetsFile <- function()
{
  Try(tmpTargetsFile <- tclvalue(tkgetOpenFile(filetypes="{{Targets Files} {.txt}} {{All files} *}")))
  Try(if (!nchar(tmpTargetsFile)) return())
  Try(TargetsFile <- tmpTargetsFile)
  Try(assign("TargetsFile",TargetsFile,limmaGUIenvironment))
  Try(tclvalue(.limmaGUIglobals$TargetsfileBoxTitleTcl) <- paste("Targets File"))
  Try(tclvalue(.limmaGUIglobals$TargetsfileNameTcl) <- paste(TargetsFile))
  Try(Targets <- read.table(TargetsFile,header=TRUE,sep="\t",quote="\"",as.is=TRUE))
  Try(if (!("FileName" %in% colnames(Targets)) && !("FileNameCy3" %in% colnames(Targets) && "FileNameCy5" %in% colnames(Targets)))
  {
    Try(tkmessageBox(title="RNA Targets File Error",message="The RNA Targets file should have a \"FileName\" column (or for ImaGene, a \"FileNameCy3\" column and a \"FileNameCy5\" column).",icon="error"))
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return()
  })
  Try(if (!("SlideNumber" %in% colnames(Targets)) || !("Cy3" %in% colnames(Targets)) || !("Cy5" %in% colnames(Targets)))
  {
    Try(tkmessageBox(title="RNA Targets File Error",message="The RNA Targets file should have a \"SlideNumber\" column, a \"Cy3\" column and a \"Cy5\" column, where the Cy3 and Cy5 columns list the RNA types for the targets (e.g. \"wild type\" or \"mutant\").",icon="error"))
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return()
  })
    
  
  Try(assign("Targets",Targets,limmaGUIenvironment))
  Try(assign("NumSlides",nrow(Targets),limmaGUIenvironment))

  Try(ArraysLoaded <- FALSE)
  Try(assign("ArraysLoaded",ArraysLoaded,limmaGUIenvironment))

  Try(tkfocus(.limmaGUIglobals$ttMain))
}

OpenSpotTypesFile <- function()
{
  Try(tmpSpotTypesFile <- tclvalue(tkgetOpenFile(filetypes="{{Spot-Type Files} {.txt}} {{All files} *}")))
  Try(if (!nchar(tmpSpotTypesFile)) return())
  Try(SpotTypesFile <- tmpSpotTypesFile)
  Try(assign("SpotTypesFile",SpotTypesFile,limmaGUIenvironment))
  Try(tclvalue(.limmaGUIglobals$SpotTypesfileBoxTitleTcl) <- paste("Spot-Types File"))
  Try(tclvalue(.limmaGUIglobals$SpotTypesfileNameTcl) <- paste(SpotTypesFile))
  Try(SpotTypes <- read.table(SpotTypesFile,header=TRUE,sep="\t",quote="\"",as.is=TRUE,comment.char=""))
  Try(if (!("SpotType" %in% colnames(SpotTypes))||
      !("ID" %in% colnames(SpotTypes)) ||
      !("Name" %in% colnames(SpotTypes)) ||
      !(("Color" %in% colnames(SpotTypes))||("col" %in% colnames(SpotTypes)))
     )
  {
    Try(tkmessageBox(title="Spot Types",message=paste("Error: SpotTypes table should contain column headings \"SpotType\",",
      "\"ID\",\"Name\" and (\"Color\" or \"col\")."),icon="error"))
    return()
  })

  Try(for (i in (1:ncol(SpotTypes)))
  {
    if (colnames(SpotTypes)[i]=="col")
      colnames(SpotTypes)[i] <- "Color"
    if (colnames(SpotTypes)[i]=="cex")
      colnames(SpotTypes)[i] <- "PointSize"
  })

  Try(if (length(SpotTypes$SpotType)!=length(unique(SpotTypes$SpotType)))
  {
    Try(tkmessageBox(title="Spot Types",message=paste("Error: Each spot type in the SpotType column should be unique",
      "(but one spot type can have multiple spot sub-types, e.g. you could have a spot type \"ratio\" which matches ID's in the GAL file equivalent to \"Ratio_Control_*\", i.e. \"Ratio_Control_1\", \"Ratio_Control_2\", etc.)"),icon="error"))
    return()
  })
  Try(assign("SpotTypes",SpotTypes,limmaGUIenvironment))  
  Try(UpdateSpotTypesStatus())
  Try(ArraysLoaded <- FALSE)
  Try(assign("ArraysLoaded",ArraysLoaded,limmaGUIenvironment))
  Try(tkfocus(.limmaGUIglobals$ttMain))
}



GetImageProcessingFileType <- function()
{
  ttGetImageProcessingFileType<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetImageProcessingFileType)
  tkgrab.set(ttGetImageProcessingFileType)  
  Try(tkwm.title(ttGetImageProcessingFileType,"Type of Image Processing Files"))
  Try(fileTypeTcl <- tclVar("spot"))
  Try(tkframe1 <- tkframe(ttGetImageProcessingFileType,borderwidth=2))
  Try(tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2))
  Try(tkframe4<-tkframe(tkframe1,borderwidth=2))

  Try(tkgrid(tklabel(tkframe1,text="    ")))

  Try(tkgrid(tklabel(tkframe2,text="Which type of image-processing files are these?",font=.limmaGUIglobals$limmaGUIfont2),rowspan=1,columnspan=2,sticky="w"))
  Try(Spot.but <- tkradiobutton(tkframe2,text="Spot",variable=fileTypeTcl,value="spot",font=.limmaGUIglobals$limmaGUIfont2))
  Try(Spot.close.open.but <- tkradiobutton(tkframe2,text="Spot close/open",variable=fileTypeTcl,value="spot.close.open",font=.limmaGUIglobals$limmaGUIfont2))
  Try(GenePix.but <- tkradiobutton(tkframe2,text="GenePix",variable=fileTypeTcl,value="genepix",font=.limmaGUIglobals$limmaGUIfont2))
  Try(QuantArray.but <- tkradiobutton(tkframe2,text="QuantArray",variable=fileTypeTcl,value="quantarray",font=.limmaGUIglobals$limmaGUIfont2))
  Try(ImaGene.but <- tkradiobutton(tkframe2,text="ImaGene",variable=fileTypeTcl,value="imagene",font=.limmaGUIglobals$limmaGUIfont2))
  Try(ArrayVision.but <- tkradiobutton(tkframe2,text="ArrayVision",variable=fileTypeTcl,value="arrayvision",font=.limmaGUIglobals$limmaGUIfont2))  
  Try(Agilent.but <- tkradiobutton(tkframe2,text="Agilent",variable=fileTypeTcl,value="agilent",font=.limmaGUIglobals$limmaGUIfont2))
#  Try(SMD.but <- tkradiobutton(tkframe2,text="SMD (Stanford Microarray Database)",variable=fileTypeTcl,value="smd",font=.limmaGUIglobals$limmaGUIfont2))  
  
  Try(tkgrid(Spot.but))
  Try(tkgrid(Spot.close.open.but))
  Try(tkgrid(GenePix.but))  
  Try(tkgrid(QuantArray.but))    
  Try(tkgrid(ImaGene.but))
  Try(tkgrid(ArrayVision.but))  
  Try(tkgrid(Agilent.but))    
#  Try(tkgrid(SMD.but))  
  
  Try(tkgrid.configure(Spot.but,Spot.close.open.but,GenePix.but,QuantArray.but,ImaGene.but,ArrayVision.but,Agilent.but,sticky="w"))
#  Try(tkgrid.configure(Spot.but,Spot.close.open.but,GenePix.but,QuantArray.but,ImaGene.but,ArrayVision.but,Agilent.but,SMD.but,sticky="w"))
  Try(tkgrid(tkframe2))
  Try(ReturnVal <- "")
  onOK <- function()
  {
      Try(fileTypeVal <- as.character(tclvalue(fileTypeTcl)))
      Try(tkgrab.release(ttGetImageProcessingFileType));Try(tkdestroy(ttGetImageProcessingFileType));Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(ReturnVal <<- fileTypeVal)
  }
  onCancel <- function(){tkgrab.release(ttGetImageProcessingFileType);tkdestroy(ttGetImageProcessingFileType);tkfocus(.limmaGUIglobals$ttMain);ReturnVal <<- ""} 
  Try(OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframe4,text="                    ")))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="e"))
  Try(tkgrid(tklabel(tkframe4,text="       ")))
  Try(tkgrid(tkframe4))
  Try(tkgrid(tkframe1))
  Try(tkfocus(ttGetImageProcessingFileType))
  Try(tkbind(ttGetImageProcessingFileType, "<Destroy>", function(){tkgrab.release(ttGetImageProcessingFileType);tkfocus(.limmaGUIglobals$ttMain);} )) 
  Try(tkwait.window(ttGetImageProcessingFileType))
  return (ReturnVal)
}

ReadImageProcessingFiles <- function()
{
  Try(imageFileType <- GetImageProcessingFileType())
  Try(if (nchar(imageFileType)==0) return(0))

  Try(WeightingType     <- get("WeightingType",envir=limmaGUIenvironment))
#  Try(FlagSpotWeighting <- get("FlagSpotWeighting",envir=limmaGUIenvironment))  
  Try(AreaLowerLimit    <- get("AreaLowerLimit",envir=limmaGUIenvironment))
  Try(AreaUpperLimit    <- get("AreaUpperLimit",envir=limmaGUIenvironment))

  Try(if (imageFileType=="spot")
    Try(WhetherToUseBackgroundCorrection <- tclvalue(tkmessageBox(title="Background Correction",message="Use Background Correction (highly recommended) ?",type="yesnocancel",icon="question",default="yes")))
  else
    Try(WhetherToUseBackgroundCorrection <- tclvalue(tkmessageBox(title="Background Correction",message="Use Background Correction?",type="yesnocancel",icon="question",default="yes"))))
  Try(if (WhetherToUseBackgroundCorrection=="cancel")
    return(0))    
  Try(if (WhetherToUseBackgroundCorrection=="yes")
  {
    Try(GetBCReturnVal <- GetBackgroundCorrectionMethod())
    Try(if (GetBCReturnVal=="") return(0))
  })

  Try(WhetherToUseSpotQualityWeighting <- tkmessageBox(title="Spot Quality Weighting",message="Use Spot Quality Weighting?",type="yesnocancel",icon="question",default="no"))
  Try(WhetherToUseSpotQualityWeighting <- tclvalue(WhetherToUseSpotQualityWeighting))
  Try(if (WhetherToUseSpotQualityWeighting=="cancel")
    return(0))
  Try(if (WhetherToUseSpotQualityWeighting=="yes" && imageFileType!="spot" && imageFileType!="spot.close.open" && imageFileType!="genepix" && imageFileType!="quantarray")
    {
      Try(tkmessageBox(title="Spot Quality Weighting",message="Currently, spot quality weighting is only available for Spot, GenePix and QuantArray files.  Arrays will be processed without spot quality weighting.",icon="warning",type="ok"))
      Try(WhetherToUseSpotQualityWeighting <- "no")    
    })
        
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  
  Try(WeightingType <- "none")
  Try(assign("WeightingType",WeightingType,limmaGUIenvironment))
  Try(if (WhetherToUseSpotQualityWeighting=="yes")
  {
    if (imageFileType=="spot" || imageFileType=="spot.close.open")
    {
      if (GetWtAreaParams()==0)
      {
        Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
        return(0)
      }
      Try(AreaLowerLimit    <- get("AreaLowerLimit",envir=limmaGUIenvironment))
      Try(AreaUpperLimit    <- get("AreaUpperLimit",envir=limmaGUIenvironment))
    }
    if (imageFileType=="genepix")        
    {
      Try(GenePixFlagWeightings <- GetGenePixFlagWeightings())
      Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))      
      if (length(GenePixFlagWeightings)==0)
      {
        Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))         
        return(0)
      }
#      Try(FlagSpotWeighting <- get("FlagSpotWeighting",envir=limmaGUIenvironment))  
       Try(assign("WeightingType","wtflagsVec",limmaGUIenvironment))
    }
    if (imageFileType=="quantarray")
      Try(assign("WeightingType","wtIgnore.Filter",limmaGUIenvironment))
    if (imageFileType=="imagene")
      Try(assign("WeightingType","none",limmaGUIenvironment))      
    Try(WeightingType <- get("WeightingType",envir=limmaGUIenvironment))        
  })
  Try(TargetsFile <- get("TargetsFile",envir=limmaGUIenvironment))
  Try(if (!nchar(TargetsFile))  
  {
    tkmb <- tkmessageBox(title="ERROR",message="Please select a Targets file first, e.g. SwirlSample.txt",icon="warning",type="ok",default="ok")
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return(0)  
  })
  Try(Targets <- read.table(TargetsFile,header=TRUE,sep="\t",quote="\"",as.is=TRUE))
  Try(assign("Targets",Targets,limmaGUIenvironment))
  Try(if (!("FileName" %in% colnames(Targets)) && !("FileNameCy3" %in% colnames(Targets) && "FileNameCy5" %in% colnames(Targets)))
  {
    Try(tkmessageBox(title="RNA Targets File Error",message="The RNA Targets file should have a \"FileName\" column (or for ImaGene, a \"FileNameCy3\" column and a \"FileNameCy5\" column)."))
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return(0)
  })
  Try(if (!("FileName" %in% colnames(Targets)) && imageFileType!="imagene")
  {
    Try(tkmessageBox(title="RNA Targets File Error",message="The RNA Targets file should have a \"FileName\" column."))
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return(0)
  })  
  Try(if (imageFileType=="imagene" && !("FileNameCy3" %in% colnames(Targets) && "FileNameCy5" %in% colnames(Targets)))
  {
    Try(tkmessageBox(title="RNA Targets File Error",message="When using ImaGene, the RNA Targets file should have a \"FileNameCy3\" column and a \"FileNameCy5\" column."))
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return(0)
  })  
  Try(if ("FileName" %in% colnames(Targets))
    Try(slides <- Targets$FileName))
  Try(if ("FileNameCy3" %in% colnames(Targets) && "FileNameCy5" %in% colnames(Targets))
    Try(slides <- cbind(as.matrix(Targets[,"FileNameCy3"]),as.matrix(Targets[,"FileNameCy5"]))))
  Try(SlideNamesVec <- c())
  Try(assign("NumSlides",nrow(Targets),limmaGUIenvironment))
  Try(NumSlides <- get("NumSlides",envir=limmaGUIenvironment))
  Try(for (j in (1:NumSlides))
  {
      if ("Name" %in% colnames(Targets))
          SlideNamesVec[j] <- Targets[j,"Name"]
      else    
          SlideNamesVec[j] <- paste(Targets[j,"SlideNumber"])
  })
  Try(assign("SlideNamesVec",SlideNamesVec,limmaGUIenvironment))
  
  Try(filesExist <- file.exists(slides))
  Try(filesWhichDontExist <- slides[!filesExist])
  Try(if (length(filesWhichDontExist)>0)
    Try(for (i in (1:length(filesWhichDontExist)))
      Try(tkmessageBox(title="Error opening file",message=paste("Failed to open file: \"",filesWhichDontExist[i],"\"",sep=""),icon="error"))))
  Try(if (length(filesWhichDontExist)>0) 
  {
    Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
    return(0)
  })
  
  Try(if (WhetherToUseSpotQualityWeighting=="yes")
  {
    if (imageFileType=="spot")
        TryReadImgProcFile(RG<-read.maimages(slides,wt.fun=wtarea(ideal=c(AreaLowerLimit,AreaUpperLimit)),source="spot"))
    if (imageFileType=="spot.close.open")
        TryReadImgProcFile(RG<-read.maimages(slides,wt.fun=wtarea(ideal=c(AreaLowerLimit,AreaUpperLimit)),source="spot.close.open"))
    if (imageFileType=="genepix")   
        TryReadImgProcFile(RG<-read.maimages(slides,
        wt.fun=wtflags2(GenePixFlagWeightings),source="genepix"))
    if (imageFileType=="quantarray")
        TryReadImgProcFile(RG<-read.maimages(slides,wt.fun=wtIgnore.Filter,source="quantarray"))
  }
  else
      TryReadImgProcFile(RG<-read.maimages(slides,source=imageFileType)))
  Try(if (WhetherToUseBackgroundCorrection=="no")
    Try(RG <- backgroundCorrect(RG,method="none"))
  else
  {
    Try(if (!exists("BCMethod",envir=limmaGUIenvironment))
		{
		  Try(BCMethod <- "subtract")
		  Try(assign("BCMethod",BCMethod,limmaGUIenvironment))
		})
		Try(BCMethod <- get("BCMethod",envir=limmaGUIenvironment))
    Try(RG <- backgroundCorrect(RG,method=BCMethod))      
  })
  Try(assign("RG",RG,limmaGUIenvironment))
  Try(assign("RG.Available",TRUE,limmaGUIenvironment)  )
  Try(assign("MAimported",FALSE,limmaGUIenvironment))
  Try(tkdelete(.limmaGUIglobals$mainTree,"RG.Status"))        
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status",text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkdelete(.limmaGUIglobals$mainTree,"BC.Status"))        
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BC","BC.Status" ,text=BCMethod,font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkdelete(.limmaGUIglobals$mainTree,"WeightingType.Status"))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WeightingType","WeightingType.Status" ,text=WeightingType,font=.limmaGUIglobals$limmaGUIfontTree))

  # Let's automatically computed MAraw:

  Try(RG <- get("RG",envir=limmaGUIenvironment))
  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
  Try (MAraw <- MA.RG(RG))
  Try(assign("MAraw",MAraw,limmaGUIenvironment))
  Try(assign("MA",MAraw,limmaGUIenvironment))
  Try(MA.Available$Raw <- TRUE)
  Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
  Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))

  Try(ArraysLoaded <- TRUE)    
  Try(assign("ArraysLoaded",ArraysLoaded,limmaGUIenvironment))
  return (1)
}

GetGenePixFlagWeightings <- function()
{
  Try(ttGenePixFlagWeightings <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGenePixFlagWeightings))
  Try(tkgrab.set(ttGenePixFlagWeightings))
  Try(tkfocus(ttGenePixFlagWeightings))
  Try(tkwm.title(ttGenePixFlagWeightings,"GenePix Flag Weightings"))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="    ")))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="GenePix Flag Weightings",font=.limmaGUIglobals$limmaGUIfont2)))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="    ")))
  Try(GoodFlagWeightingTcl <- tclVar("1"))
  Try(entry.GoodFlagWeighting<-tkentry(ttGenePixFlagWeightings,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=GoodFlagWeightingTcl,bg="white"))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="Good (100)         ",font=.limmaGUIglobals$limmaGUIfont2),entry.GoodFlagWeighting,sticky="w"))
  Try(BadFlagWeightingTcl <- tclVar("0.1"))
  Try(entry.BadFlagWeighting<-tkentry(ttGenePixFlagWeightings,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=BadFlagWeightingTcl,bg="white"))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="Bad (-100)         ",font=.limmaGUIglobals$limmaGUIfont2),entry.BadFlagWeighting,sticky="w"))
  Try(NotFoundFlagWeightingTcl <- tclVar("0.1"))
  Try(entry.NotFoundFlagWeighting<-tkentry(ttGenePixFlagWeightings,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=NotFoundFlagWeightingTcl,bg="white"))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="Not Found (-50)    ",font=.limmaGUIglobals$limmaGUIfont2),entry.NotFoundFlagWeighting,sticky="w"))
  Try(AbsentFlagWeightingTcl <- tclVar("0.1"))
  Try(entry.AbsentFlagWeighting<-tkentry(ttGenePixFlagWeightings,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=AbsentFlagWeightingTcl,bg="white"))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="Absent (-75)       ",font=.limmaGUIglobals$limmaGUIfont2),entry.AbsentFlagWeighting,sticky="w"))
  Try(UnflaggedFlagWeightingTcl <- tclVar("1"))
  Try(entry.UnflaggedFlagWeighting<-tkentry(ttGenePixFlagWeightings,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=UnflaggedFlagWeightingTcl,bg="white"))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="Unflagged (0)       ",font=.limmaGUIglobals$limmaGUIfont2),entry.UnflaggedFlagWeighting,sticky="w"))

  ReturnVal <- list()
  
  onOK <- function()
  {
    Try(Good     <- as.numeric(tclvalue(GoodFlagWeightingTcl)))
    Try(Bad      <- as.numeric(tclvalue(BadFlagWeightingTcl)))
    Try(NotFound <- as.numeric(tclvalue(NotFoundFlagWeightingTcl)))
    Try(Absent   <- as.numeric(tclvalue(AbsentFlagWeightingTcl)))
    Try(Unflagged<- as.numeric(tclvalue(UnflaggedFlagWeightingTcl)))
    Try(tkgrab.release(ttGenePixFlagWeightings))
    Try(tkdestroy(ttGenePixFlagWeightings))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    Try(ReturnVal <<- list(Good=Good,Bad=Bad,NotFound=NotFound,Absent=Absent,Unflagged=Unflagged))
  }
  onCancel <- function() {Try(tkgrab.release(ttGenePixFlagWeightings));Try(tkdestroy(ttGenePixFlagWeightings));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- list())}
  OK.but <- tkbutton(ttGenePixFlagWeightings,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <- tkbutton(ttGenePixFlagWeightings,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="    ")))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid(tklabel(ttGenePixFlagWeightings,text="    ")))
  Try(tkfocus(ttGenePixFlagWeightings))
  Try(tkbind(ttGenePixFlagWeightings, "<Destroy>", function() {Try(tkgrab.release(ttGenePixFlagWeightings));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGenePixFlagWeightings))

  return (ReturnVal)
}

wtflags2 <- function(Weightings)
function(gpr)
{
  w <- rep(1,nrow(gpr))
  w[gpr[,"Flags"]==100]  <- Weightings$Good
  w[gpr[,"Flags"]==-100] <- Weightings$Bad
  w[gpr[,"Flags"]==-50]  <- Weightings$NotFound
  w[gpr[,"Flags"]==-75]  <- Weightings$Absent
  w[gpr[,"Flags"]==0]    <- Weightings$Unflagged
  w
}



tclArrayVar <- function()
{
    Try(n <- evalq(TclVarCount <- TclVarCount + 1, .TkRoot$env))
    Try(name <- paste("::RTcl", n,sep = ""))
    Try(l <- list(env = new.env()))
    Try(assign(name, NULL, envir = l$env))
    Try(reg.finalizer(l$env, function(env) tkcmd("unset", ls(env))))
    Try(class(l) <- "tclArrayVar")
    Try(.Tcl(paste("set ",name,"(0,0) \"\"",sep="")))
    l
}


GetDesignOrContrasts <- function(Design=FALSE,Contrasts=FALSE,NumContrasts=0,
  parameterizationIndex=0) # parameterizationIndex argument is for contrasts only
{ 
  Try(if ((Design==TRUE && Contrasts==TRUE) || (Design==FALSE && Contrasts==FALSE))
    tkmessageBox(title="GetDesignOrContrasts",message="Error: Only one of DesignOrContrasts and Contrasts should be set to TRUE",icon="error"))    

  Try(NumSlides     <- get("NumSlides",    envir=limmaGUIenvironment))
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(Targets       <- get("Targets",      envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(RawMADataWasImported<- get("RawMADataWasImported", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment)) 

  Try(if (Design==TRUE)
    Try(ReturnVal <- list(design=data.frame(),designCreatedFromDropDowns=FALSE))
  else
    Try(ReturnVal <- list(contrasts=data.frame(),contrastsCreatedFromDropDowns=FALSE)))

  
  Try(if (Contrasts==TRUE)
    ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      if (Design==TRUE)
        tkmessageBox(title="Design Matrix",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      else
        tkmessageBox(title="Contrasts Matrix",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")      
      Try(tkfocus(.limmaGUIglobals$ttMain))      
      return(ReturnVal)
  }

  GetDesignOrContrastsTable <- function(designOrContrastsFromDropDowns)
  {
    Try(ttDesignOrContrastsTable <- tktoplevel(.limmaGUIglobals$ttMain))
    Try(tkwm.deiconify(ttDesignOrContrastsTable))
    Try(tkgrab.set(ttDesignOrContrastsTable))
    Try(tkfocus(ttDesignOrContrastsTable))
    if (Design==TRUE)
      Try(tkwm.title(ttDesignOrContrastsTable,"Design Matrix"))
    else
      Try(tkwm.title(ttDesignOrContrastsTable,"Contrasts Matrix"))
    if (Design==TRUE)
    {
      Try(ReturnVal <- list(design=data.frame(),designCreatedFromDropDowns=FALSE))
      Try(designOrContrasts <- designOrContrastsFromDropDowns$design)
    }
    else
    {
      Try(ReturnVal <- list(contrasts=data.frame(),contrastsCreatedFromDropDowns=FALSE))
      Try(designOrContrasts <- designOrContrastsFromDropDowns$contrasts)
    }
    
#   Try(n <- evalq(TclVarCount <- TclVarCount + 1, .TkRoot$env))
#   Try(tclArrayName <- paste("::RTcl", n, sep = ""))
    Try(tclArrayVar1 <- tclArrayVar())
    Try(tclArrayName <- ls(tclArrayVar1$env)) # This wouldn't work if I'd used tclArray().  Should update this stuff!

    onOK <- function()
    {      
        Try(.Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<Leave>"))))
        if (Design==TRUE)
        {
          NumRows <- NumSlides
          NumCols <- NumParameters
        }
        else
        {
          NumRows <- NumParameters
          NumCols <- NumContrasts
        }
        Try(designOrContrasts <- as.data.frame(matrix(nrow=NumRows,ncol=NumCols)))
        Try(rownamesDesignOrContrasts <- c())
        for (i in (1:NumRows))
            Try(rownamesDesignOrContrasts[i] <- tclvalue(paste(tclArrayName,"(",i,",0)",sep="")))
        Try(colnamesDesignOrContrasts <- c())
        if (NumCols>0)
          for (j in (1:NumCols))
            Try(colnamesDesignOrContrasts[j] <- tclvalue(paste(tclArrayName,"(0,",j,")",sep="")))
        Try(rownames(designOrContrasts) <- rownamesDesignOrContrasts)
        Try(colnames(designOrContrasts) <- colnamesDesignOrContrasts)
        if (Design==TRUE)
        {
          Try(assign("SlideNamesVec",rownamesDesignOrContrasts,limmaGUIenvironment))
          Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))
        }
        if (NumCols>0)
          for (i in (1:NumRows))
            for (j in (1:NumCols))
                Try(designOrContrasts[i,j] <- as.numeric(tclvalue(paste(tclArrayName,"(",i,",",j,")",sep=""))))
        Try(tkgrab.release(ttDesignOrContrastsTable))
        Try(tkdestroy(ttDesignOrContrastsTable))
        Try(tkfocus(.limmaGUIglobals$ttMain))
        if (Design==TRUE)
          Try(ReturnVal <<- list(design=designOrContrasts,designCreatedFromDropDowns=FALSE))
        else
          Try(ReturnVal <<- list(contrasts=designOrContrasts,contrastsCreatedFromDropDowns=FALSE))        
    }
    onCancel <- function() 
    {
      Try(tkgrab.release(ttDesignOrContrastsTable))
      Try(tkdestroy(ttDesignOrContrastsTable))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      if (Design==TRUE) 
        ReturnVal <<- list(design=data.frame(),designCreatedFromDropDowns=FALSE)
      else
        ReturnVal <<- list(contrasts=data.frame(),contrastsCreatedFromDropDowns=FALSE)
    }       
    Try(OK.but <-tkbutton(ttDesignOrContrastsTable,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
    Try(Cancel.but <-tkbutton(ttDesignOrContrastsTable,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
    Try(tkgrid(tklabel(ttDesignOrContrastsTable,text="    ")))
    if (Design==TRUE)
      Try(PleaseEnterDesignOrContrastsLabel<-tklabel(ttDesignOrContrastsTable,text="Please enter the design matrix to be used for linear-modelling.",font=.limmaGUIglobals$limmaGUIfont2))
    else
      Try(PleaseEnterDesignOrContrastsLabel<-tklabel(ttDesignOrContrastsTable,text="Please enter the contrasts matrix to be used for linear-modelling.",font=.limmaGUIglobals$limmaGUIfont2))      
    Try(tkgrid(tklabel(ttDesignOrContrastsTable,text="    "),PleaseEnterDesignOrContrastsLabel))
    Try(tkgrid.configure(PleaseEnterDesignOrContrastsLabel,columnspan=2))
    Try(tkgrid(tklabel(ttDesignOrContrastsTable,text="    ")))
    if (Design==TRUE)
    {
      NumRows <- NumSlides
      NumCols <- NumParameters
    }
    else
    {
      NumRows <- NumParameters
      NumCols <- NumContrasts
    }
    
    if (Design==TRUE)
    {
      Try(if (nrow(designOrContrasts)==0)
      {
        Try(ParameterNamesVec <- c())
        if (NumParameters>0)
          for (i in (1:NumParameters)) 
            Try(ParameterNamesVec <- c(ParameterNamesVec,paste("Param ",i,sep="")))
      }
      else
          Try(ParameterNamesVec <- colnames(designOrContrasts)))
      Try(ColNamesVec <- ParameterNamesVec)
    }
    else
    {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))          
      Try(if (nrow(designOrContrasts)==0)
      {
        Try(ContrastsNamesVec <- c())
        if (NumContrasts>0)
          for (i in (1:NumContrasts)) 
            Try(ContrastsNamesVec <- c(ContrastsNamesVec,paste("Contrast ",i,sep="")))              
      }
      else
          Try(ContrastsNamesVec <- colnames(designOrContrasts)))      
      Try(ColNamesVec <- ContrastsNamesVec)
    }

    
    Try(rownamesDesignOrContrasts <- c())
    Try(myRarray <- "    ")
    for (i in (1:NumRows))
    {
        if (Design==TRUE)
          Try(RowName <- SlideNamesVec[i])
        else
          Try(RowName <- ParameterNamesVec[i])
        Try(rownamesDesignOrContrasts <- c(rownamesDesignOrContrasts,RowName))
        Try(myRarray <- c(myRarray,paste(RowName)))
    }
    if (NumCols>0)
      for (j in (1:NumCols))      
      {
        Try(myRarray <- c(myRarray,paste(ColNamesVec[j])))
        for (i in (1:NumRows))
        {          
            if (nrow(designOrContrasts)==0)
                Try(myRarray <- c(myRarray,"0"))
            else
                Try(myRarray <- c(myRarray,paste(designOrContrasts[i,j])))
        }      
      } 
      # This will give an error if tclArray doesn't exist.
      # .Tcl("unset tclArray")
      Try(dim(myRarray) <- c(NumRows+1,NumCols+1))
      if (NumCols>0)
        for (i in (0:NumRows))
          for (j in (0:NumCols))
          {
             # Modified to use tkcmd!
             Try(tkcmd("set",paste(tclArrayName,"(",i,",",j,")",sep=""),paste(myRarray[i+1,j+1])))             
          }

      # Below, can I just use tkwidget(ttDesignOrContrastsTable,"table",...) ?
      Try(table1 <- .Tk.subwin(ttDesignOrContrastsTable))
      Try(.Tcl(paste("table",.Tk.ID(table1),.Tcl.args(variable=tclArrayName,rows=paste(NumRows+1),cols=paste(NumCols+1),titlerows="0",titlecols="0",selectmode="extended",colwidth="13",background="white",rowseparator="\"\n\"",colseparator="\"\t\"",resizeborders="col",multiline="0"))))
      Try(tkgrid(tklabel(ttDesignOrContrastsTable,text="    "),table1))

      Try(tkcmd(.Tk.ID(table1),"width","0",paste(max(4,max(nchar(rownamesDesignOrContrasts))+2))))
      Try(if (nrow(designOrContrasts)>0)
      {     

        Try(for (j in (1:NumCols))      
          Try(tkcmd(.Tk.ID(table1),"width",paste(j),paste(max(4,max(nchar(ColNamesVec))+2,max(nchar(designOrContrasts[,j]))+2)))))
      })

#       if (Contrasts==TRUE)
#         Try(tkcmd(.Tk.ID(table1),"width","0","25"))

      Try(tkconfigure(table1,font=.limmaGUIglobals$limmaGUIfontTable))
      Try(tkgrid.configure(table1,columnspan=2))

      Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<<Copy>>"))))

      openDesignOrContrastsMatrixFile <- function()
      {
        Try(if (Design==TRUE)
          Try(DesignOrContrastsFileName <- tclvalue(tkgetOpenFile(filetypes="{{Design Matrix Files} {.txt}} {{All files} *}")))
        else
          Try(DesignOrContrastsFileName <- tclvalue(tkgetOpenFile(filetypes="{{Contrasts Matrix Files} {.txt}} {{All files} *}"))))
        Try(if (!nchar(DesignOrContrastsFileName)) return())
        Try(DesignOrContrastsTable <- read.table(DesignOrContrastsFileName,header=FALSE,sep="\t",quote="\"",as.is=TRUE))
        # This will give an error if tclArray doesn't exist.
        # .Tcl("unset tclArray")
        if (NumCols>0)
          for (i in (0:NumRows))
            for (j in (0:NumCols))
#             Try(.Tcl(paste("set ",tclArrayName,"(",i,",",j,") \"",DesignOrContrastsTable[i+1,j+1],"\"",sep="")))
              Try(tkcmd("set",paste(tclArrayName,"(",i,",",j,")",sep=""),paste(DesignOrContrastsTable[i+1,j+1])))
      }

      saveDesignOrContrastsMatrixFile <- function()
      {
        Try(DesignOrContrastsFileName <- tclvalue(tkgetSaveFile(filetypes="{{DesignOrContrasts Matrix Files} {.txt}} {{All files} *}")))
        Try(if (!nchar(DesignOrContrastsFileName)) return())
        Try(len <- nchar(DesignOrContrastsFileName))
        if (len<=4)
          Try(  DesignOrContrastsFileName <- paste(DesignOrContrastsFileName,".txt",sep=""))
        else if (substring(DesignOrContrastsFileName,len-3,len)!=".txt")
              Try(DesignOrContrastsFileName <- paste(DesignOrContrastsFileName,".txt",sep=""))
        Try(designOrContrasts <- as.data.frame(matrix(nrow=NumSlides,ncol=NumParameters)))
        Try(rownamesDesignOrContrasts <- c())
        Try(for (i in (1:NumRows))
            rownamesDesignOrContrasts[i] <- tclvalue(paste(tclArrayName,"(",i,",0)",sep="")))
        Try(colnamesDesignOrContrasts <- c())
        if (NumParameters>0)
          Try(for (j in (1:NumCols))
            colnamesDesignOrContrasts[j] <- tclvalue(paste(tclArrayName,"(0,",j,")",sep="")))
        Try(rownames(designOrContrasts) <- rownamesDesignOrContrasts)
        Try(colnames(designOrContrasts) <- colnamesDesignOrContrasts)
        if (NumParameters>0)
          Try(for (i in (1:NumRows))
            for (j in (1:NumParameters))
                designOrContrasts[i,j] <- as.numeric(tclvalue(paste(tclArrayName,"(",i,",",j,")",sep=""))))

        Try(write.table(designOrContrasts,file=DesignOrContrastsFileName,col.names=NA,sep="\t",quote=FALSE,row.names=TRUE))
      }

      Try(topMenu <- tkmenu(ttDesignOrContrastsTable, tearoff=FALSE))
      Try(fileMenu <- tkmenu(topMenu, tearoff=FALSE))
      Try(tkadd(fileMenu, "command", label="Open",      command=openDesignOrContrastsMatrixFile)) 
      Try(tkadd(fileMenu, "command", label="Save As",      command=saveDesignOrContrastsMatrixFile))
      Try(tkadd(topMenu,  "cascade", label="File",menu=fileMenu)) 

      Try(editMenu <- tkmenu(topMenu, tearoff=FALSE))
      Try(tkadd(editMenu, "command", label="Copy <Ctrl-C>",      command=copyFcn))
      Try(tkadd(topMenu,  "cascade", label="Edit",menu=editMenu))

      Try(tkconfigure(ttDesignOrContrastsTable,menu=topMenu))

      Try(BlankLabel1<-tklabel(ttDesignOrContrastsTable,text="    "))
      Try(tkgrid(BlankLabel1))
      Try(BlankLabel2<-tklabel(ttDesignOrContrastsTable,text="    "))
      Try(tkgrid(BlankLabel2,OK.but,Cancel.but))
      Try(tkgrid.configure(OK.but,sticky="e"))
      Try(tkgrid.configure(Cancel.but,sticky="w"))
      Try(BlankLabel3<-tklabel(ttDesignOrContrastsTable,text="    "))
      Try(tkgrid(BlankLabel3))

      Try(tkfocus(ttDesignOrContrastsTable))
      Try(tkbind(ttDesignOrContrastsTable, "<Destroy>", function() {Try(tkgrab.release(ttDesignOrContrastsTable));Try(tkfocus(.limmaGUIglobals$ttMain));}))
      Try(tkwait.window(ttDesignOrContrastsTable))
      return (ReturnVal)
  }

  OnAdvanced <- function()
  {
      Try(RawMADataWasImported <- get("RawMADataWasImported",envir=limmaGUIenvironment))
      Try(NormalizedMADataWasImported <- get("NormalizedMADataWasImported",envir=limmaGUIenvironment))
      Try(if (!RawMADataWasImported && !NormalizedMADataWasImported)
      {
        Try(designOrContrastsFromDropDowns <- GetDesignOrContrastsFromDropDowns())
        Try(ReturnValDesignOrContrastsTable <- GetDesignOrContrastsTable(designOrContrastsFromDropDowns)) # Returns designOrContrasts list object including designOrContrasts matrix as data.frame
      }
      else
      {        
        Try(ReturnValDesignOrContrastsTable <- GetDesignOrContrastsTable(list(design=data.frame(),designOrContrastsCreatedFromDropDowns=TRUE,TargetVector=c(),RNAType1=c(),RNAType2=c(),plusOrMinus=c()))) # Returns designOrContrasts list object including designOrContrasts matrix as data.frame
      })
      if (Design==TRUE)
        NumRows <- nrow(ReturnValDesignOrContrastsTable$design)
      else
        NumRows <- nrow(ReturnValDesignOrContrastsTable$contrasts)
      if (NumRows>0 ) # OK was clicked, not Cancel
      {
          Try(if (!RawMADataWasImported && !NormalizedMADataWasImported)
          {
            Try(tkgrab.release(ttDesignOrContrasts))
            Try(tkdestroy(ttDesignOrContrasts))
          })
          Try(tkfocus(.limmaGUIglobals$ttMain))
          ReturnVal <<- ReturnValDesignOrContrastsTable   # List contains designOrContrasts matrix as data.frame
      }   
  }

  Try(if (RawMADataWasImported || NormalizedMADataWasImported)
  {
    Try(GetParamsReturnVal <- GetNumParametersNoTargets())
    Try(if (GetParamsReturnVal==-1)
      return(ReturnVal))
    Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))
    OnAdvanced()
    return(ReturnVal)
  })

  if (Design==TRUE)
  {
    # We will try to determine the number of parameters to be estimated (one less than
    # the number of RNA targets).  For now, we'll assume column
    # names are Cy3 and Cy5, but later we can allow for Red, Green, RED, GREEN, CY5, CY3.

    Try(Cy3Targets <- as.vector(Targets["Cy3"])$Cy3)
    Try(Cy5Targets <- as.vector(Targets["Cy5"])$Cy5)

    Cy3Copy <- Cy3Targets
    Cy5Copy <- Cy5Targets

  #  Target <- Cy3Targets[1]
    TargetVector <- c(Cy3Targets[1])
    TargetsCounted <- 1
    for (i in (1:length(Cy3Targets)))
    {
      for (j in (1:length(TargetVector)))
      {
          if (Cy3Targets[i]==TargetVector[j])
            Cy3Copy[i]<-"Counted"
      }
      if (Cy3Copy[i]!="Counted")
      {
        TargetVector <- c(TargetVector,Cy3Targets[i])
        TargetsCounted <- TargetsCounted + 1
      }
    }
    for (i in (1:length(Cy5Targets)))
    {
      for (j in (1:length(TargetVector)))
      {
        if (Cy5Targets[i]==TargetVector[j])
          Cy5Copy[i]<-"Counted"
      }
      if (Cy5Copy[i]!="Counted")
      {
        TargetVector <- c(TargetVector,Cy5Targets[i])
        TargetsCounted <- TargetsCounted + 1
      }
    }

  # NumParameters should be OK as a global, because the number of parameters is the same, no matter what the 
  # parametrization (unless we start dealing with Scorecard Controls, but they would need a whole new Targets file).

  # We now allow for unconnected designOrContrastss.
  # The "graph" below is a network graph, not at plot.

    RNATypesGraph <- list()
    Try(for (i in (1:NumSlides))
      RNATypesGraph[[i]] <- c(Cy3Targets[i],Cy5Targets[i]))
    countConnectedSubGraphs <- function(graph)  
    {
      count <- 0  
      connectedSubGraphs <- list()
      while (length(graph))
      {
        open <- graph[[1]][1]
        closed <- c()
        while (length(open))
        {
          test <- open[1]
          if (length(open)>1)
            open <- open[2:length(open)]
          else
            open <- c()
          g <- 1
          if (!(test %in% closed))
          {
            closed <- c(closed,test)
            while (g <= length(graph))
              if (test %in% graph[[g]])
              {  
                n <- graph[[g]]
                open <- c(open,n[1],n[2])
                graph <- deleteItemFromList(graph,index=g)                
              }            
              else
                g <- g + 1
          }  
        }
        connectedSubGraphs <- c(connectedSubGraphs,list(closed))
        count <- count + 1
      }
      return (list(count=count,connectedSubGraphs=connectedSubGraphs))
    }

    Try(result <- countConnectedSubGraphs(RNATypesGraph))
    Try(numConnectedSubGraphs <- result$count)
    Try(connectedSubGraphs <- result$connectedSubGraphs)

    Try(assign("numConnectedSubGraphs",numConnectedSubGraphs,limmaGUIenvironment))
    Try(assign("connectedSubGraphs",connectedSubGraphs,limmaGUIenvironment))

    Try(assign("NumParameters", TargetsCounted - numConnectedSubGraphs,limmaGUIenvironment))
    Try(assign("NumRNATypes", TargetsCounted,limmaGUIenvironment))
    Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))    
    ParameterNamesVec <- c()
    if (NumParameters>0)
      for (i in (1:NumParameters))
        ParameterNamesVec <- c(ParameterNamesVec,paste("Param",i))
  }

  if (NumParameters<=0)
  {
    Try(tkmessageBox(title="At Least Two RNA Types Are Required",message="You must have at least two types of RNA in your Targets file.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    if (Design==TRUE)
      return(list(design=data.frame(),designCreatedFromDropDowns=FALSE))
    else
      return(list(contrasts=data.frame(),contrastsCreatedFromDropDowns=FALSE))    
  }
  
  if (Design==TRUE)
  {
    NumRows <- NumSlides
    NumCols <- NumParameters
  }
  else
  {
    NumRows <- NumParameters
    NumCols <- NumContrasts
  }

  if (Contrasts==TRUE)
  {
    Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
    Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))          
  }

  ttDesignOrContrasts<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttDesignOrContrasts)
  tkgrab.set(ttDesignOrContrasts)
  tkfocus(ttDesignOrContrasts)
  if (Design==TRUE)
    tkwm.title(ttDesignOrContrasts,"Parameters To Estimate")
  else
    tkwm.title(ttDesignOrContrasts,"Contrasts")  

  if (Design==TRUE)
    lbl2<-tklabel(ttDesignOrContrasts,text="Please specify pairs of RNA for which M parameters will be estimated",font=.limmaGUIglobals$limmaGUIfont2)
  else
    lbl2<-tklabel(ttDesignOrContrasts,text="Please specify pairs of parameters for which contrasts will be estimated",font=.limmaGUIglobals$limmaGUIfont2)  
  lbl3<-tklabel(ttDesignOrContrasts,text="                                                                    ")
  tkgrid(tklabel(ttDesignOrContrasts,text="       "),row=0,column=1,columnspan=1)
  tkgrid(tklabel(ttDesignOrContrasts,text="       "),row=0,column=4,columnspan=1)
  tkgrid(lbl2,row=1,column=2,columnspan=4,rowspan=1,sticky="ew");
  tkgrid.configure(lbl2,sticky="w")
  tkgrid(tklabel(ttDesignOrContrasts,text="         "),column=1)
  tkgrid(tklabel(ttDesignOrContrasts,text="         "))
  tkgrid(tklabel(ttDesignOrContrasts,text="         "),column=1)
#  plus<-tklabel(ttDesignOrContrasts,text="   +   ",font=.limmaGUIglobals$limmaGUIfont2)
#  minus<-tklabel(ttDesignOrContrasts,text="   -   ",font=.limmaGUIglobals$limmaGUIfont2)
#  tkgrid(plus,row=3, column=2,sticky="ew")
#  tkgrid(minus,row=3,column=6,sticky="ew")

  Try(if (Design==TRUE)
  {
    TclList1AsString <- "{"
    for (i in (1:TargetsCounted))
      TclList1AsString <- paste(TclList1AsString,"{",TargetVector[i],"} ",sep="")
    TclList1AsString <- paste(TclList1AsString,"}",sep="")
    TclList2AsString <- TclList1AsString
  }
  else
  {
    TclList1AsString <- "{"
    for (i in (1:NumParameters))
      TclList1AsString <- paste(TclList1AsString,"{",ParameterNamesVec[i],"} ",sep="")
    TclList1AsString <- paste(TclList1AsString,"}",sep="")
    TclList2AsString <- TclList1AsString
  })
  
  Try(if (Design==TRUE) 
    plusOrMinusTclListAsString <- "{{minus}}"
  else
    plusOrMinusTclListAsString <- "{{minus} {plus}}")
    
  combo1 <- c()
  combo2 <- c()
  combo3 <- c()    
  Try(if (NumCols>0)
    for (paramORcontrast in (1:NumCols))
    {
      Try(FirstDropDownColumn <- .Tk.subwin(ttDesignOrContrasts))
      combo1 <- c(combo1,FirstDropDownColumn)
      Try(.Tcl(paste("ComboBox",.Tk.ID(FirstDropDownColumn),"-editable false -values",TclList1AsString)))
      Try(SecondDropDownColumn <- .Tk.subwin(ttDesignOrContrasts))
      Try(combo2 <- c(combo2,SecondDropDownColumn))
      Try(.Tcl(paste("ComboBox",.Tk.ID(SecondDropDownColumn),"-editable false -values",TclList2AsString)))
      Try(plusOrMinusDropDown <- .Tk.subwin(ttDesignOrContrasts))
      Try(combo3 <- c(combo3,plusOrMinusDropDown))
      Try(.Tcl(paste("ComboBox",.Tk.ID(plusOrMinusDropDown),"-editable false -values",plusOrMinusTclListAsString)))
      Try(tkcmd(.Tk.ID(plusOrMinusDropDown),"setvalue","first"))
      Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)            
      {
       Try(tkconfigure(FirstDropDownColumn,width=10))
        Try(tkconfigure(SecondDropDownColumn,width=10))      
        Try(tkconfigure(plusOrMinusDropDown,width=10))              
      })
      if (Design==TRUE)
        Try(dropdownLabel <- paste("Parameter",paramORcontrast,"  "))
      else
        Try(dropdownLabel <- paste("Contrast",paramORcontrast, "  ")  )
      
      Try(tkgrid(tklabel(ttDesignOrContrasts,text=dropdownLabel,font=.limmaGUIglobals$limmaGUIfont2),row=2+paramORcontrast,
                        column=0,sticky="w"))
      Try(tkconfigure(FirstDropDownColumn,font=.limmaGUIglobals$limmaGUIfont2))
      Try(tkconfigure(SecondDropDownColumn,font=.limmaGUIglobals$limmaGUIfont2))
      Try(tkconfigure(plusOrMinusDropDown,font=.limmaGUIglobals$limmaGUIfont2))      
      Try(tkgrid(FirstDropDownColumn,row=2+paramORcontrast,column=2,columnspan=1,rowspan=1))
      Try(tkgrid(plusOrMinusDropDown,row=2+paramORcontrast,column=4,columnspan=1,rowspan=1))      
      Try(tkgrid(SecondDropDownColumn,row=2+paramORcontrast,column=6,columnspan=1,rowspan=1))

      Try(tkgrid(tklabel(ttDesignOrContrasts,text="    "),row=2+paramORcontrast,column=7))
    })
  tkgrid(tklabel(ttDesignOrContrasts,text="                                                 "),rowspan=1,columnspan=4);

  if (Design==TRUE)
    ReturnVal <- list(design=data.frame(),designCreatedFromDropDowns=TRUE,TargetVector=TargetVector,RNAType1=c(),RNAType2=c(),plusOrMinus=c())
  else
    ReturnVal <- list(contrasts=data.frame(),contrastsCreatedFromDropDowns=TRUE,TargetVector=c(),Param1=c(),Param2=c(),plusOrMinus=c())  
  
  GetDesignOrContrastsFromDropDowns <- function()
  {
   
    if (Design==TRUE)
    {
      NumRows <- NumSlides
      NumCols <- NumParameters
    }
    else
    {
      NumRows <- NumParameters
      NumCols <- NumContrasts
    }
    
    RNATypeOrParam1 <-c()
    RNATypeOrParam2 <-c()    
    plusOrMinusStringVec <- c("-","+")
    plusOrMinus <- c()
        
    if (NumCols>0)
      for (paramORcontrast in (1:NumCols))
      {
        # I think I wrote this code when I was an R Tcl/Tk beginner.  Check and update!
        # I think combo1 and combo2 should really be lists, not vectors!!!
        # *2 below, because the c() combines the tkwin objects which are acutally         
        # lists with 2 components: window ID and environment.

        selection1 <- tclvalue(.Tcl(paste(.Tk.ID(combo1[paramORcontrast*2-1]),"getvalue")))
        selection2 <- tclvalue(.Tcl(paste(.Tk.ID(combo2[paramORcontrast*2-1]),"getvalue")))        
        selection3 <- tclvalue(.Tcl(paste(.Tk.ID(combo3[paramORcontrast*2-1]),"getvalue")))                
        if (Design==TRUE)
        {        
          Try(if ((selection1=="-1")||(selection2=="-1")) 
            return (list(design=data.frame(),designCreatedFromDropDowns=TRUE,TargetVector=TargetVector,RNAType1=c(),RNAType2=c(),plusOrMinus=c())))
        }
        else
        {
          Try(if ((selection1=="-1")||(selection2=="-1"))
            return (list(contrasts=data.frame(),contrastsCreatedFromDropDowns=TRUE,TargetVector=c(),Param1=c(),Param2=c(),plusOrMinus=c())))
        }        
        RNATypeOrParam1 <- c(RNATypeOrParam1,as.numeric(selection1)+1)
        RNATypeOrParam2 <- c(RNATypeOrParam2,as.numeric(selection2)+1)
        plusOrMinus <- c(plusOrMinus,plusOrMinusStringVec[as.numeric(selection3)+1])
        
      }

    designOrContrasts <- as.data.frame(matrix(nrow=NumRows,ncol=NumCols))
    if (Design==TRUE)
      Try(rownames(designOrContrasts) <- SlideNamesVec)
    else
      Try(rownames(designOrContrasts) <- ParameterNamesVec)

    Try(if (Design==TRUE)    
    {
      ParameterNamesVec <- vector(length=NumParameters)
      if (NumParameters>0)
        for (j in (1:NumParameters))
              ParameterNamesVec[j] <- paste("(",TargetVector[RNATypeOrParam1[j]],")-(",TargetVector[RNATypeOrParam2[j]],")",sep="")
      colnames(designOrContrasts) <- ParameterNamesVec
    }
    else
    {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))            
      ContrastNamesVec <- vector(length=NumContrasts)    
      if (NumContrasts>0)
        for (j in (1:NumContrasts))          
          ContrastNamesVec[j] <- SimplifyContrastsExpression(paste("(",ParameterNamesVec[RNATypeOrParam1[j]],")",plusOrMinus[j],"(",ParameterNamesVec[RNATypeOrParam2[j]],")",sep=""))                                       
      colnames(designOrContrasts) <- ContrastNamesVec    
    })

    if (Design==TRUE)
    {
      ParamMatrix <- matrix(nrow=TargetsCounted,ncol=NumParameters)
      if (NumParameters>0)
        for (i in (1:NumParameters))
        { 
          for (j in (1:TargetsCounted))
            ParamMatrix[j,i] <- 0
          ParamMatrix[RNATypeOrParam1[i],i] <-  1
          ParamMatrix[RNATypeOrParam2[i],i] <- -1
        }
      Try(QR <- qr(ParamMatrix))
      Try(if (QR$rank!=ncol(QR$qr))
      {
        Try(tkmessageBox(title="Design Matrix",message=paste("Error:  Parameters are not linearly independent.\n\n",
          "Try entering independent parameters or click on the Advanced button to enter the design matrix directly.",sep=""),icon="error"))
        Try(return (list(design=data.frame(),designOrContrastsCreatedFromDropDowns=TRUE,TargetVector=TargetVector,RNAType1=c(),RNAType2=c(),plusOrMinus=c())))
      })
      RNATargetsVec <- vector(length=TargetsCounted)
      for (i in (1:NumSlides))
      {
        for (j in (1:TargetsCounted))
        { 
          RNATargetsVec[j] <- 0 
          if (paste(Cy5Targets[i])==paste(TargetVector[j]))
            RNATargetsVec[j] <- 1
          if (paste(Cy3Targets[i])==paste(TargetVector[j]))
            RNATargetsVec[j] <- -1
        }
        designOrContrasts[i,] <- qr.solve(ParamMatrix,RNATargetsVec)
      }
      designOrContrasts <- round(designOrContrasts,digits=8)
    }
    else # (Contrasts==TRUE)
    {
      Try(for (i in (1:NumParameters))
        for (j in (1:NumContrasts))
        {
          Try(designOrContrasts[i,j] <- 0)
          Try(if (RNATypeOrParam1[j]==i)  
            designOrContrasts[i,j] <- 1)
          Try(if (plusOrMinus[j]=="-")
          {
            Try(if(RNATypeOrParam2[j]==i)
              designOrContrasts[i,j] <- -1)         
          }
          else  # "+"
          {
            Try(if(RNATypeOrParam2[j]==i)
              designOrContrasts[i,j] <-  1)
          })
        })        
    }
    if (Design==TRUE)   
      return(list(design=designOrContrasts,designCreatedFromDropDowns=TRUE,TargetVector=TargetVector,RNAType1=RNATypeOrParam1,RNAType2=RNATypeOrParam2,plusOrMinus=plusOrMinus))  
    else
      return(list(contrasts=designOrContrasts,contrastsCreatedFromDropDowns=TRUE,TargetVector=c(),Param1=RNATypeOrParam1,Param2=RNATypeOrParam2,plusOrMinus=plusOrMinus))      
  }

  onOK <- function()
  {
    Try(designOrContrastsList <- GetDesignOrContrastsFromDropDowns())
    Try(if (Design==TRUE)
    {
      Try(if (nrow(designOrContrastsList$design)==0)
      {
        Try(tkmessageBox(title="Parameterization",message=paste("Error in creating parameterization from drop-down selection. ",
                       "Make sure you have selected an RNA pair for each parameter and that your parameters are linearly independent."),type="ok",icon="error"))                    
        Try(ReturnVal <<- list(design=data.frame(),designCreatedFromDropDowns=TRUE,TargetVector=TargetVector,RNAType1=c(),RNAType2=c(),plusOrMinus=c()))        
        return()
      }
      else
      {
          Try(tkgrab.release(ttDesignOrContrasts))
          Try(tkdestroy(ttDesignOrContrasts))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          Try(ReturnVal <<- designOrContrastsList)      
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      })
      
    })
    Try(if (Contrasts==TRUE)
    {   
      Try(if (nrow(designOrContrastsList$contrasts)==0)    
      {
        Try(tkmessageBox(title="Contrasts",message=paste("Error in creating contrasts matrix from drop-down selection. ",
                         "Make sure you have selected a parameter pair for each contrast."),type="ok",icon="error"))                    
        Try(ReturnVal <<- list(contrasts=data.frame(),contrastsCreatedFromDropDowns=TRUE,TargetVector=c(),Param1=c(),Param2=c(),plusOrMinus=c()))
        return()
      } 
      else
      {
        Try(tkgrab.release(ttDesignOrContrasts))
        Try(tkdestroy(ttDesignOrContrasts))
        Try(tkfocus(.limmaGUIglobals$ttMain))
        Try(ReturnVal <<- designOrContrastsList)
        Try(tkfocus(.limmaGUIglobals$ttMain))
        return()
      })
    })
  }
  onCancel <- function() 
  {
    Try(tkgrab.release(ttDesignOrContrasts))
    Try(tkdestroy(ttDesignOrContrasts))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    if (Design==TRUE)
      ReturnVal <<- list(design=data.frame(),designCreatedFromDropDowns=TRUE,TargetVector=TargetVector,RNAType1=c(),RNAType2=c(),plusOrMinus=c())
    else
      ReturnVal <<- list(contrasts=data.frame(),contrastsCreatedFromDropDowns=TRUE,TargetVector=c(),Param1=c(),Param2=c(),plusOrMinus=c())    
  }   
  Advanced.but <- tkbutton(ttDesignOrContrasts,text="Advanced...",command=OnAdvanced,font=.limmaGUIglobals$limmaGUIfont2)
  Try(OK.but <-tkbutton(ttDesignOrContrasts,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttDesignOrContrasts,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(OK.but,column=2,row=9+NumParameters))
  Try(tkgrid(Cancel.but,column=4,row=9+NumParameters))
  Try(tkgrid(Advanced.but,column=6,row=9+NumParameters))
  Try(tkgrid(tklabel(ttDesignOrContrasts,text="    ")))
      
  Try(tkfocus(ttDesignOrContrasts))
  
  Try(tkbind(ttDesignOrContrasts, "<Destroy>", function() {Try(tkgrab.release(ttDesignOrContrasts));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttDesignOrContrasts))
  return (ReturnVal)
}


SimplifyContrastsExpression <- function(string)
{
  RNATypesAndSign <- GetRNATypesFrom.ContrastsFromDropDowns.String(string)
  RNA1 <- RNATypesAndSign$RNA1
  RNA2 <- RNATypesAndSign$RNA2
  RNA3 <- RNATypesAndSign$RNA3
  RNA4 <- RNATypesAndSign$RNA4
  plusOrMinusSign <- RNATypesAndSign$plusOrMinusSign
  ReturnVal <- string
  
  if (RNA1==RNA3&&plusOrMinusSign=='-')
    ReturnVal <- paste("(",RNA4,")-(",RNA2,")",sep="")  
  if (RNA2==RNA4&&plusOrMinusSign=='-')  
    ReturnVal <- paste("(",RNA1,")-(",RNA3,")",sep="")  
  if (RNA1==RNA4&&plusOrMinusSign=='+')
    ReturnVal <- paste("(",RNA3,")-(",RNA2,")",sep="")    
  if (RNA2==RNA3&&plusOrMinusSign=='+')  
    ReturnVal <- paste("(",RNA1,")-(",RNA4,")",sep="")      
  return(ReturnVal)
  
}

GetRNATypesFrom.ContrastsFromDropDowns.String <- function(string)
{
  len <- nchar(string)
  string <- substr(string,3,len)
  # string == "a)-(b))-((b)-(c"
  len <- nchar(string)
  i <- 1
  while (substr(string,i,i)!=")" && (i<=len))
    i <- i + 1
  RNA1 <- substr(string,1,i-1)
  len <- nchar(string)
  string <- substr(string,i+3,len)
  len <- nchar(string)  
  i<-1
  while (substr(string,i,i)!=")" && (i<=len))
    i <- i + 1
  RNA2 <- substr(string,1,i-1)
  len <- nchar(string)
  plusOrMinusSign <- substr(string,i+2,i+2)
  string <- substr(string,i+5,len)
  len <- nchar(string)  
  i<-1
  while (substr(string,i,i)!=")" && (i<=len))
    i <- i + 1
  RNA3 <- substr(string,1,i-1)
  len <- nchar(string)
  string <- substr(string,i+3,len)
  len <- nchar(string)  
  i<-1
  while (substr(string,i,i)!=")" && (i<=len))
    i <- i + 1
  RNA4 <- substr(string,1,i-1)
  list(RNA1=RNA1,RNA2=RNA2,RNA3=RNA3,RNA4=RNA4,plusOrMinusSign=plusOrMinusSign)
}


GetParameterNames <- function(parameterizationTreeIndex)
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ParameterNamesVec <- c())
  if (NumParameters>0)
    for (i in (1:NumParameters))
    {
      Try(ParametersNameNode<- paste("PMFParams.",parameterizationTreeIndex,".",i,sep=""))
      Try(ParameterNamesVec[i] <- (ParameterizationList[[ParameterizationNameNode]])[[ParametersNameNode]])    
    }  
  return (ParameterNamesVec)
}

GetReducedDuplicateSpacing <- function(parameterizationTreeIndex)
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(spacing <- get("spacing",envir=limmaGUIenvironment))
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(gal     <- get("gal",envir=limmaGUIenvironment))
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))    
  Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
  Try(RG <- get("RG",envir=limmaGUIenvironment))
  Try(MA <- MA.RG(RG)) # Locally only.
  Try(oldNumRows <- nrow(MA$M))
  Try(Omit <- "")
  Try(count <- 0)
  Try(for (i in (1:numSpotTypes))
  {
    Try(if (SpotTypesForLinearModel[i]==TRUE)
      next())
    Try(count <- count + 1)
    Try(if (count>1)
      Try(Omit <-paste(Omit,"|"))
    else
      Try(Omit <- "("))
    Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
  })
  
  Try(if (nchar(Omit)>0)
  {
    Try(Omit <- paste(Omit,")"))
    Try(Omit <- eval(parse(text=Omit)))  
    MA$M <- MA$M[!Omit,]
    MA$A <- MA$A[!Omit,]  
  })
  
  Try(newNumRows <- nrow(MA$M))  
  Try(parameterizationSpacing <- spacing)
  Try(spacingCorrected <- 0)
  Try(if (oldNumRows/spacing==2  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/2;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==3  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/3;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==4  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/4;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==5  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/5;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==6  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/6;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==7  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/7;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==8  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/8;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==9  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/9;  spacingCorrected <- 1})      
  Try(if (oldNumRows/spacing==10 && oldNumRows!=newNumRows){ parameterizationSpacing <- newNumRows/10; spacingCorrected <- 1})  
  
  return (parameterizationSpacing)
}


GetContrastsParameterizationNames <- function(parameterizationTreeIndex)
{
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
  Try(ContrastsParameterizationNamesVec <- c())
  if (NumContrastParameterizations>0)
    for (i in (1:NumContrastParameterizations))
    {
      Try(ContrastsParameterizationNamesNode<- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",i,sep=""))
      Try(ContrastsParameterizationNamesVec[i] <- (ParameterizationList[[ParameterizationNameNode]])[[ContrastsParameterizationNamesNode]])    
    }  
  return (ContrastsParameterizationNamesVec)
}

GetSpotTypesIncludedNames <- function(parameterizationTreeIndex)
{
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  Try(SpotTypesForLinearModel <- (ParameterizationList[[ParameterizationNameNode]])$SpotTypesForLinearModel)
  
  count <- 0
  Try(SpotTypesIncludedNamesVec <- c())
  if (numSpotTypes>0)
    for (i in (1:numSpotTypes))
    {
      if (SpotTypesForLinearModel[i]==FALSE)
          next()
      count <- count + 1
      Try(SpotTypesNode<- paste("PMFSpotTypes.",parameterizationTreeIndex,".",i,sep=""))
      Try(SpotTypesIncludedNamesVec[count] <- (ParameterizationList[[ParameterizationNameNode]])[[SpotTypesNode]])    
    }  
  return (SpotTypesIncludedNamesVec)
}

HowManyDups <- function()
{
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(spacing <- get("spacing",envir=limmaGUIenvironment))    
  ttHowManyDups<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttHowManyDups)
  tkgrab.set(ttHowManyDups)
  tkfocus(ttHowManyDups)  
  tkwm.title(ttHowManyDups,"Number of Duplicates")

  tkframe1 <- tkframe(ttHowManyDups,relief="groove",borderwidth=2)
  tkframe2 <- tkframe(ttHowManyDups,relief="groove",borderwidth=2)
  
  tkgrid(tklabel(ttHowManyDups,text="    "))
  tkgrid(tklabel(ttHowManyDups,text="Looking at the GAL file will help you to answer these questions.",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
  tkgrid(tklabel(ttHowManyDups,text="    "))
  tkgrid(tklabel(tkframe1,text="How many prints of each gene are there?          ",font=.limmaGUIglobals$limmaGUIfont2),sticky="w")
  NumDups<- tclVar(paste(ndups))
  entry.NumDups<-tkentry(tkframe1,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=NumDups,bg="white")
  tkgrid(tklabel(tkframe1,text="Number of prints for each gene : ",font=.limmaGUIglobals$limmaGUIfont2),entry.NumDups,sticky="w")
  tkgrid(tkframe1,columnspan=2)
  tkgrid(tklabel(ttHowManyDups,text="    "))
  tkgrid(tklabel(tkframe2,text="What is the spacing between duplicate genes?  ",font=.limmaGUIglobals$limmaGUIfont2),sticky="w")
  Spacing<- tclVar(paste(spacing))
  entry.Spacing<-tkentry(tkframe2,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=Spacing,bg="white")
  tkgrid(tklabel(tkframe2,text="Spacing between duplicate genes : ",font=.limmaGUIglobals$limmaGUIfont2),entry.Spacing,sticky="w")
  tkgrid(tkframe2,columnspan=2)
  tkgrid(tklabel(ttHowManyDups,text="    "))
  ReturnVal <- 0
  onOK <- function()
  {
      ndups <- as.integer(tclvalue(NumDups))
      Try(assign("ndups",ndups,limmaGUIenvironment))
      spacing <- as.integer(tclvalue(Spacing))
      Try(assign("spacing",spacing,limmaGUIenvironment))
      Try(tkgrab.release(ttHowManyDups))
      Try(tkdestroy(ttHowManyDups))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- 1
  }
  onCancel <- function() {Try(tkgrab.release(ttHowManyDups));Try(tkdestroy(ttHowManyDups));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- 0}
  OK.but <-tkbutton(ttHowManyDups,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttHowManyDups,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but)
  tkgrid.configure(OK.but,sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  tkgrid(tklabel(ttHowManyDups,text="    "))
  Try(tkfocus(ttHowManyDups))
  Try(tkbind(ttHowManyDups, "<Destroy>", function() {Try(tkgrab.release(ttHowManyDups));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttHowManyDups))
  return (ReturnVal)
}

ViewDesignOrContrastsMatrixInTable <- function(DesignOrContrasts,designOrContrastsList,parameterizationIndex,contrastsParameterizationIndex=NULL)
{
  Try(if (DesignOrContrasts!="Design" && DesignOrContrasts!="Contrasts")
  {
    Try(tkmessageBox(title="View Design Or Contrasts Matrix In Table",message="Error: First argument must be \"Design\" or \"Contrasts\".",icon="error"))
    return()
  })

  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(NumSlides <- get("NumSlides",envir=limmaGUIenvironment))    
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  Try(ContrastsParameterizationNamesVec <- GetContrastsParameterizationNames(parameterizationTreeIndex))  
  Try(ttViewDesignOrContrastsTable <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttViewDesignOrContrastsTable))
  Try(tkgrab.set(ttViewDesignOrContrastsTable))
  Try(tkfocus(ttViewDesignOrContrastsTable))
  Try(if (DesignOrContrasts=="Design")
    Try(tkwm.title(ttViewDesignOrContrastsTable,paste("Design matrix for parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep="")))
  else
  {
    Try(tkwm.title(ttViewDesignOrContrastsTable,paste("Contrasts matrix for contrasts parameterization ", ContrastsParameterizationNamesVec[contrastsParameterizationIndex],
     " in parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep="")))  
  })
  Try(if (DesignOrContrasts=="Design")
    Try(designOrContrasts <- designOrContrastsList$design)
  else
    Try(designOrContrasts <- designOrContrastsList$contrasts))
    
  onClose <- function() {Try(.Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<Leave>"))));Try(tkgrab.release(ttViewDesignOrContrastsTable));Try(tkdestroy(ttViewDesignOrContrastsTable));Try(tkfocus(.limmaGUIglobals$ttMain))}

  Try(if (DesignOrContrasts=="Design")
  {
    NumRows <- NumSlides
    NumCols <- NumParameters
  }
  else # Contrasts
  {
    Try(NumContrasts <- ncol(designOrContrasts))
    NumRows <- NumParameters
    NumCols <- NumContrasts
  })
    
  if (is.null(colnames(designOrContrasts)))
  {
      Try(ColumnNamesVec <- c())
      if (NumCols>0)
        for (i in (1:NumCols)) 
          Try(if (DesignOrContrasts=="Design")
            Try(ColumnNamesVec <- c(ColumnNamesVec,paste("Param",i)))
          else
            Try(ColumnNamesVec <- c(ColumnNamesVec,paste("Contrast",i))))            
  }
  else
      Try(ColumnNamesVec <- colnames(designOrContrasts))

  Try(RowNamesVec <- c())
  Try(myRarray <- "    ")
  Try(for (i in (1:NumRows))
  {
      Try(if (DesignOrContrasts=="Design")      
      {
        Try(if(is.null(rownames(designOrContrasts)))
          Try(RowName <- SlideNamesVec[i])
        else
          Try(RowName <- rownames(designOrContrasts)[i]))        
      }
      else # Contrasts
      {
        Try(if (is.null(rownames(designOrContrasts)))
          Try(RowName <- paste("Param",i))
        else
          Try(RowName <- rownames(designOrContrasts)[i]))
      })
      Try(RowNamesVec <- c(RowNamesVec,RowName))
      Try(myRarray <- c(myRarray,paste(RowName)))
  })
  
  if (NumCols>0)
    for (j in (1:NumCols))      
    {
      Try(myRarray <- c(myRarray,paste(ColumnNamesVec[j])))
      for (i in (1:NumRows))
      {          
          if (nrow(designOrContrasts)==0)
              Try(myRarray <- c(myRarray,"0"))
          else
              Try(myRarray <- c(myRarray,paste(designOrContrasts[i,j])))
      }      
    }      

#      Try(n <- evalq(TclVarCount <- TclVarCount + 1, .TkRoot$env))
#      Try(tclArrayName <- paste("::RTcl", n, sep = ""))  
#      Try(l <- list(env = new.env()))
#      Try(assign(tclArrayName, NULL, envir = l$env))
#      Try(reg.finalizer(l$env, function(env) tkcmd("unset", ls(env))))
      Try(tclArrayVar1 <- tclArrayVar())
      Try(tclArrayName <- ls(tclArrayVar1$env))

      Try(dim(myRarray) <- c(NumRows+1,NumCols+1))

      # This will give an error if tclArray doesn't exist.
      # .Tcl("unset tclArray")
      if (NumCols>0)
        for (i in (0:NumRows))
          for (j in (0:NumCols))
             Try(tkcmd("set",paste(tclArrayName,"(",i,",",j,")",sep=""),paste(myRarray[i+1,j+1])))

      Try(table1 <- tkwidget(ttViewDesignOrContrastsTable,"table"))
      Try(tkconfigure(table1,variable=tclArrayName,rows=paste(NumRows+1),cols=paste(NumCols+1),
        titlerows="0",titlecols="0",selectmode="extended",colwidth="13",background="white",rowseparator="\"\n\"",
        colseparator="\"\t\"",resizeborders="col",multiline="0",
        xscrollcommand=function(...) tkset(xscr,...),yscrollcommand=function(...) tkset(yscr,...),state="disabled"))
      Try(xscr <- tkscrollbar(ttViewDesignOrContrastsTable,orient="horizontal", command=function(...)tkxview(table1,...)))
      Try(yscr <- tkscrollbar(ttViewDesignOrContrastsTable,command=function(...)tkyview(table1,...)))               
      Try(tkgrid(table1,yscr))
      Try(tkgrid.configure(yscr,sticky="nsw"))
      Try(tkconfigure(table1,font=.limmaGUIglobals$limmaGUIfontTable))
      Try(tkgrid(xscr,sticky="new"))
      Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<<Copy>>"))))


      Try(tkcmd(.Tk.ID(table1),"width","0",paste(max(4,max(nchar(rownames(designOrContrasts)))+2))))
      Try(for (j in (1:NumCols))      
        Try(tkcmd(.Tk.ID(table1),"width",paste(j),paste(max(4,nchar(colnames(designOrContrasts)[j])+2,max(nchar(designOrContrasts[,j]))+2)))))


      onSaveDesignOrContrastsMatrixAs <- function()
      {
        Try(if (DesignOrContrasts=="Design")        
          Try(DesignOrContrastsFileName <- tclvalue(tkgetSaveFile(filetypes="{{Design Matrix Files} {.txt}} {{All files} *}")))
        else
          Try(DesignOrContrastsFileName <- tclvalue(tkgetSaveFile(filetypes="{{Contrasts Matrix Files} {.txt}} {{All files} *}"))))         
        Try(if (!nchar(DesignOrContrastsFileName)) return())
        Try(len <- nchar(DesignOrContrastsFileName))
        if (len<=4)
          Try(DesignOrContrastsFileName <- paste(DesignOrContrastsFileName,".txt",sep=""))
        else if (substring(DesignOrContrastsFileName,len-3,len)!=".txt")
              Try(DesignOrContrastsFileName <- paste(DesignOrContrastsFileName,".txt",sep=""))
        Try(designOrContrasts <- as.data.frame(matrix(nrow=NumRows,ncol=NumCols)))
        Try(rownamesDesignOrContrasts <- c())
        Try(for (i in (1:NumRows))
            rownamesDesignOrContrasts[i] <- tclvalue(paste(tclArrayName,"(",i,",0)",sep="")))
        Try(colnamesdesignOrContrasts <- c())
        if (NumParameters>0)
          Try(for (j in (1:NumCols))
            colnamesdesignOrContrasts[j] <- tclvalue(paste(tclArrayName,"(0,",j,")",sep="")))
        Try(rownames(designOrContrasts) <- rownamesDesignOrContrasts)
        Try(colnames(designOrContrasts) <- colnamesdesignOrContrasts)
        if (NumParameters>0)
          Try(for (i in (1:NumRows))
            for (j in (1:NumParameters))
                designOrContrasts[i,j] <- as.numeric(tclvalue(paste(tclArrayName,"(",i,",",j,")",sep=""))))

        Try(write.table(designOrContrasts,file=DesignOrContrastsFileName,col.names=NA,sep="\t",quote=FALSE,row.names=TRUE))
      }



      Try(topMenu <- tkmenu(ttViewDesignOrContrastsTable, tearoff=FALSE))

      Try(fileMenu <- tkmenu(topMenu, tearoff=FALSE))
      Try(tkadd(fileMenu, "command", label="Save As",    command=onSaveDesignOrContrastsMatrixAs))       
      Try(tkadd(fileMenu, "command", label="Close",      command=onClose)) 
      Try(tkadd(topMenu,  "cascade", label="File",menu=fileMenu)) 
      Try(editMenu <- tkmenu(topMenu, tearoff=FALSE))
      Try(tkadd(editMenu, "command", label="Copy <Ctrl-C>",      command=copyFcn)) 
      Try(tkadd(topMenu,  "cascade", label="Edit",menu=editMenu)) 

      Try(tkconfigure(ttViewDesignOrContrastsTable,menu=topMenu))

      Try(tkfocus(ttViewDesignOrContrastsTable))
      Try(tkbind(ttViewDesignOrContrastsTable, "<Destroy>", function () {Try(tkgrab.release(ttViewDesignOrContrastsTable));Try(tkfocus(.limmaGUIglobals$ttMain))}))
      Try(tkwait.window(ttViewDesignOrContrastsTable))
}

ViewDesignOrContrastsMatrixAsPairs <- function(DesignOrContrasts,designOrContrastsList,parameterizationIndex,contrastsParameterizationIndex=NULL)
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  Try(ContrastsParameterizationNamesVec <- GetContrastsParameterizationNames(parameterizationTreeIndex))  
  Try(NumSlides <- get("NumSlides",envir=limmaGUIenvironment))    

  Try(if (DesignOrContrasts=="Design")
  {
    Try(designOrContrasts <- designOrContrastsList$design)
    NumRows <- NumSlides
    NumCols <- NumParameters
  }
  else # Contrasts
  {
    Try(designOrContrasts <- designOrContrastsList$contrasts)  
    Try(NumContrasts <- ncol(designOrContrasts))
    NumRows <- NumParameters
    NumCols <- NumContrasts
  })
    
  ttViewDesignOrContrastsAsPairs<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttViewDesignOrContrastsAsPairs)
  tkgrab.set(ttViewDesignOrContrastsAsPairs)
  tkfocus(ttViewDesignOrContrastsAsPairs)
  Try(if (DesignOrContrasts=="Design")
  {
    Try(tkwm.title(ttViewDesignOrContrastsAsPairs,paste("Parameters in parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep="")))
    Try(TitleLabel<-tklabel(ttViewDesignOrContrastsAsPairs,text=paste("Parameters in parameterization ",ParameterizationNamesVec[parameterizationIndex],sep=""),font=.limmaGUIglobals$limmaGUIfont2b))
  }
  else
  {
    Try(tkwm.title(ttViewDesignOrContrastsAsPairs,paste("Contrasts in contrasts parameterization ", ContrastsParameterizationNamesVec[contrastsParameterizationIndex],
     " in parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep="")))  
    Try(TitleLabel<-tklabel(ttViewDesignOrContrastsAsPairs,text=paste("Contrasts in contrasts parameterization ", ContrastsParameterizationNamesVec[contrastsParameterizationIndex],
     " in parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep=""),font=.limmaGUIglobals$limmaGUIfont2b))     
  })

  Try(tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    ")))    
  Try(tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    "),TitleLabel))
  Try(tkgrid.configure(TitleLabel,columnspan=4))
  Try(tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    ")))  
  Try(if (DesignOrContrasts=="Design")
    ParameterOrContrastLabel <- tklabel(ttViewDesignOrContrastsAsPairs,text="Parameter",font=.limmaGUIglobals$limmaGUIfont2b)
  else
    ParameterOrContrastLabel <- tklabel(ttViewDesignOrContrastsAsPairs,text="Contrast",font=.limmaGUIglobals$limmaGUIfont2b))
  # Note that plusOrMinus IS A VECTOR (can be different for each contrast).
  Try(if (DesignOrContrasts=="Contrasts")
    Try(plusOrMinus <- designOrContrastsList$plusOrMinus)
  else
    plusOrMinus <- rep("-",NumCols))
  Try(tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    "),
             ParameterOrContrastLabel))

  if (is.null(colnames(designOrContrasts)))
  {
      Try(ColumnNamesVec <- c())
      if (NumCols>0)
        for (i in (1:NumCols)) 
          Try(if (DesignOrContrasts=="Design")
            Try(ColumnNamesVec <- c(ColumnNamesVec,paste("Param",i)))
          else
            Try(ColumnNamesVec <- c(ColumnNamesVec,paste("Contrast",i))))            
  }
  else
      Try(ColumnNamesVec <- colnames(designOrContrasts))

  Try(RowNamesVec <- c())
  Try(for (i in (1:NumRows))
  {
      Try(if (DesignOrContrasts=="Design")      
      {
        Try(if(is.null(rownames(designOrContrasts)))
          Try(RowName <- SlideNamesVec[i])
        else
          Try(RowName <- rownames(designOrContrasts)[i]))        
      }
      else # Contrasts
      {
        Try(if (is.null(rownames(designOrContrasts)))
          Try(RowName <- paste("Param",i))
        else
          Try(RowName <- rownames(designOrContrasts)[i]))
      })
      Try(RowNamesVec <- c(RowNamesVec,RowName))
  })

  if (NumCols>0)
    for (i in (1:NumCols))
    {
      Try(if (DesignOrContrasts=="Design")
      {
        Try(FirstItemOfPair  <- paste(designOrContrastsList$TargetVector[designOrContrastsList$RNAType1[i]]))
        Try(SecondItemOfPair <- paste(designOrContrastsList$TargetVector[designOrContrastsList$RNAType2[i]]))      
      }
      else
      {
        Try(FirstItemOfPair  <- paste(RowNamesVec[designOrContrastsList$Param1[i]]))
        Try(SecondItemOfPair <- paste(RowNamesVec[designOrContrastsList$Param2[i]]))
      })
      Try(if (plusOrMinus[i]=="+") plusOrMinusText <- "plus" else plusOrMinusText <- "minus")
      Try(tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    "),
                 tklabel(ttViewDesignOrContrastsAsPairs,text=ColumnNamesVec[i],background="white",font=.limmaGUIglobals$limmaGUIfont2),
                 tklabel(ttViewDesignOrContrastsAsPairs,text="    "),
                 tklabel(ttViewDesignOrContrastsAsPairs,text=FirstItemOfPair,background="white",font=.limmaGUIglobals$limmaGUIfont2),
                 tklabel(ttViewDesignOrContrastsAsPairs,text="    "),
                 tklabel(ttViewDesignOrContrastsAsPairs,text=plusOrMinusText,font=.limmaGUIglobals$limmaGUIfont2,bg="white"),                 
                 tklabel(ttViewDesignOrContrastsAsPairs,text="    "),
                 tklabel(ttViewDesignOrContrastsAsPairs,text=SecondItemOfPair,background="white",font=.limmaGUIglobals$limmaGUIfont2),
                 tklabel(ttViewDesignOrContrastsAsPairs,text="    ")                 
                 ))
      Try(tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    ")))
    }
  tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="     "))
  
  Advanced.but <- tkbutton(ttViewDesignOrContrastsAsPairs,text="Advanced...",command=function() {ViewDesignOrContrastsMatrixInTable(DesignOrContrasts,designOrContrastsList,parameterizationIndex,contrastsParameterizationIndex)},font=.limmaGUIglobals$limmaGUIfont2)
  onOK <- function() {Try(tkgrab.release(ttViewDesignOrContrastsAsPairs));Try(tkdestroy(ttViewDesignOrContrastsAsPairs));Try(tkfocus(.limmaGUIglobals$ttMain))}
  OK.but <-tkbutton(ttViewDesignOrContrastsAsPairs,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    "),OK.but,Advanced.but)
  tkgrid(tklabel(ttViewDesignOrContrastsAsPairs,text="    "))
      
  Try(tkfocus(ttViewDesignOrContrastsAsPairs))
  
  Try(tkbind(ttViewDesignOrContrastsAsPairs, "<Destroy>", function() {Try(tkgrab.release(ttViewDesignOrContrastsAsPairs));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttViewDesignOrContrastsAsPairs))
}

ViewExistingContrastsParameterization <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="View Existing Contrasts Parameterization",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }
  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  
  Try(NumContrastParameterizations <- (ParameterizationList[[ParameterizationNameNode]])$NumContrastParameterizations)  
  
  if (NumContrastParameterizations==0)
  {
    Try(tkmessageBox(title="View Existing Contrasts Parameterization",message="There are no contrasts parameterizations available.  Select \"Compute Contrasts\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }
  Try(contrastsParameterizationIndex <- ChooseContrastsParameterization(parameterizationTreeIndex))
  Try(if (contrastsParameterizationIndex==0)    return()    )
  Try(ContrastsParameterizationTreeIndexVec <- ParameterizationList[[ParameterizationNameNode]]$ContrastsParameterizationTreeIndexVec)
  Try(contrastsParameterizationTreeIndex <- ContrastsParameterizationTreeIndexVec[contrastsParameterizationIndex])          
  Try(ContrastsParameterizationListNode <- paste("ContrastsParameterization.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex, sep=""))  
  Try(contrastsList <- (ParameterizationList[[ParameterizationNameNode]]$Contrasts[[ContrastsParameterizationListNode]])$contrastsMatrixInList)  
  Try(if (contrastsList$contrastsCreatedFromDropDowns==FALSE)
      Try(ViewDesignOrContrastsMatrixInTable(DesignOrContrasts="Contrasts",contrastsList,parameterizationIndex,contrastsParameterizationIndex))
  else
      Try(ViewDesignOrContrastsMatrixAsPairs(DesignOrContrasts="Contrasts",contrastsList,parameterizationIndex,contrastsParameterizationIndex)))
}


ViewExistingParameterization <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="View Existing Parameterization",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }
  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
  Try(if (designList$designCreatedFromDropDowns==FALSE)
      ViewDesignOrContrastsMatrixInTable(DesignOrContrasts="Design",designList,parameterizationIndex)
  else
      ViewDesignOrContrastsMatrixAsPairs(DesignOrContrasts="Design",designList,parameterizationIndex))
}

InitNewParameterization <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment)) 
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Create New Parameterization",
        message="No arrays have been loaded.  Please try New or Open from the File menu.",
        type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return(list(result="cancel"))
  }

  Try(SpotTypesForLinearModel <- GetSpotTypesForLinearModel())
  Try(if (length(SpotTypesForLinearModel)==0)
      return(list(result="cancel")))

  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(designList <- GetDesignOrContrasts(Design=TRUE))
  Try(if (nrow(designList$design)==0) return(list(result="cancel")))
  Try(designCreatedFromDropDowns <- designList$designCreatedFromDropDowns)
  Try(design <- designList$design)
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))        
  Try(ParameterNamesVec <- colnames(design))
  Try(ParameterizationNameText <- GetParameterizationName())
  Try(if (ParameterizationNameText=="GetParameterizationName.CANCEL") return(list(result="cancel")))
  Try(while (nchar(ParameterizationNameText)==0)
  {
      Try(tkmessageBox(title="Parameterization Name",message="Please enter a name for this parameterization (design matrix)",type="ok",icon="error"))
      Try(ParameterizationNameText <- GetParameterizationName())
      if (ParameterizationNameText=="GetParameterizationName.CANCEL") 
      {
          Try(tkfocus(.limmaGUIglobals$ttMain))          
          return(list(result="cancel"))
      }
  })
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(parameterizationIndex <- 0)
  Try(newParameterization <- 1)
  Try(if (ParameterizationNameText %in% ParameterizationNamesVec)
  {
      Try(parameterizationIndex <- match(ParameterizationNameText,ParameterizationNamesVec))
      Try(mbVal<-tclvalue(tkmessageBox(title="Parameterization Name",
        message="This parameterization name already exists.  Replace?",
        type="yesnocancel",icon="question")))
      Try(if (mbVal=="cancel") return(list(result="cancel")))
      Try(if (mbVal=="yes") newParameterization <- 0)
      Try(if (mbVal=="no") newParameterization <- 1)
  }
  else
      Try(newParameterization <- 1))

  Try(if (newParameterization==1)
  {
      Try(if (length(ParameterizationTreeIndexVec)!=NumParameterizations)
      {
          Try(tkmessageBox(title="Parameterizations",message="Length of ParameterizationTreeIndexVec is not equal to NumParameterizations.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return(list(result="cancel"))
      })
      Try(NumParameterizations <- NumParameterizations + 1)
      Try(parameterizationIndex <- NumParameterizations)
      Try(if (length(ParameterizationTreeIndexVec)==0)
          Try(parameterizationTreeIndex <- 1)
      else
          Try(parameterizationTreeIndex <- max(ParameterizationTreeIndexVec)+1))
      Try(ParameterizationTreeIndexVec[parameterizationIndex] <- parameterizationTreeIndex)

      Try(ParameterizationNamesVec <- c(ParameterizationNamesVec,ParameterizationNameText))
      Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
      Try(ParameterizationList[[ParameterizationNameNode]] <- list())
  }
  else # Replace existing parameterization with the same name.
  {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
      Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,ParameterizationNameNode))
      Try(ParameterizationList <- deleteItemFromList(ParameterizationList,paste("ParameterizationName.",
                                                                                    parameterizationTreeIndex,sep="")))
      Try(ParameterizationList[[ParameterizationNameNode]] <- list())
  })
  Try(assign("ParameterizationTreeIndexVec",ParameterizationTreeIndexVec,limmaGUIenvironment))
  Try(assign("ParameterizationNamesVec",ParameterizationNamesVec,limmaGUIenvironment))
  Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
  Try(assign("NumParameterizations",NumParameterizations,limmaGUIenvironment))

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 

  return(list(result="ok",parameterizationIndex=parameterizationIndex,
         parameterizationTreeIndex=parameterizationTreeIndex,
         ParameterizationNameText=ParameterizationNameText,
         ParameterNamesVec=ParameterNamesVec,
         SpotTypesForLinearModel=SpotTypesForLinearModel,
         designList=designList))
}

CreateTreeAndList <- function(parameterizationIndex,parameterizationTreeIndex,
    ParameterizationNameText,ParameterNamesVec,designList,SpotTypesForLinearModel)
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))        
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec     <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList         <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(design <- designList$design) 
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(spacing <- get("spacing",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(WeightingType <- get("WeightingType",envir=limmaGUIenvironment))
  Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))  
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(RG <- get("RG",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
 
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ParamMainFitNode   <- paste("ParamMainFit.",parameterizationTreeIndex,sep=""))
  Try(ParamContrastsNode <- paste("ParamContrasts.",parameterizationTreeIndex,sep=""))
  Try(PMFNoneNode <- paste("PMFNone.",parameterizationTreeIndex,sep=""))
  Try(PMFSpotTypesNode <- paste("PMFSpotTypes.",parameterizationTreeIndex,sep=""))  
  Try(PMFMANormMethodNode <- paste("PMFMANormMethod.",parameterizationTreeIndex,sep=""))    
  Try(PMFParamsNode <- paste("PMFParams.",parameterizationTreeIndex,sep=""))
  Try(PMFLinModNode <- paste("PMFLinMod.",parameterizationTreeIndex,sep=""))
  Try(PMFLinModStatusNode <- paste("PMFLinModStatus.",parameterizationTreeIndex,sep=""))
  Try(PMFEBayesNode <- paste("PMFEBayes.",parameterizationTreeIndex,sep=""))
  Try(PMFEBayesStatusNode <- paste("PMFEBayesStatus.",parameterizationTreeIndex,sep=""))
  Try(PMFDupCorNode <- paste("PMFDupCor.",parameterizationTreeIndex,sep=""))
  Try(PMFDupCorStatusNode <- paste("PMFDupCorStatus.",parameterizationTreeIndex,sep=""))

  Try(tkdelete(.limmaGUIglobals$mainTree,"Parameterizations"))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Parameterizations" ,text="Parameterizations",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(if (NumParameterizations>0)
  {
    Try(for (i in (1:NumParameterizations))
    {
      Try(ParameterizationsStatusNameNode <- paste("Parameterizations.Status.",i,sep=""))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations",ParameterizationsStatusNameNode ,text=ParameterizationNamesVec[i],font=.limmaGUIglobals$limmaGUIfontTree))
    })
  }
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations","Parameterizations.Status.1" ,text="None",font=.limmaGUIglobals$limmaGUIfontTree)))

  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end","root",ParameterizationNameNode ,text=ParameterizationNameText,font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[ParameterizationNameNode]] <- ParameterizationNameText)

  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParameterizationNameNode,ParamMainFitNode,text="Main fit",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[ParamMainFitNode]] <- "Main fit")

  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"1",ParameterizationNameNode,ParamContrastsNode,text="Contrasts",font=.limmaGUIglobals$limmaGUIfontTree))
  
  Try(ParameterizationList[[ParameterizationNameNode]][[ParamContrastsNode]] <- "Contrasts")

  # Here we are creating a parameterization, so initially there will be no contrasts, but we will still
  # have one contrasts node, labeled "none".
  Try(ContrastsParameterizationNamesNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".1",sep=""))
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParamContrastsNode,ContrastsParameterizationNamesNode,text="none",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[ContrastsParameterizationNamesNode]] <- "none") 

##################################################################################################################
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParamMainFitNode,PMFSpotTypesNode,text="Spot Type(s) Included",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[PMFSpotTypesNode]] <- "SpotTypes") 
    
  Try(if (numSpotTypes>0)
    for (i in (1:numSpotTypes))
    {
      Try(if (SpotTypesForLinearModel[i]==FALSE)
          next())
      Try(NewNode <- paste("PMFSpotTypes.",parameterizationTreeIndex,".",i,sep=""))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",PMFSpotTypesNode, NewNode,text=SpotTypes[i,"SpotType"],font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[NewNode]] <- SpotTypes[i,"SpotType"])
    })

# Insert SpotTypesForLinearModel vector (containing TRUEs and FALSEs)
  Try(ParameterizationList[[ParameterizationNameNode]][["SpotTypesForLinearModel"]] <- SpotTypesForLinearModel)

##################################################################################################################
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFMANormMethodNode,text="M A Normalization Method",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[PMFMANormMethodNode]] <- "MANormMethod") 
  Try(NewNode <- paste("PMFMANormMethod.",parameterizationTreeIndex,".",1,sep=""))
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",PMFMANormMethodNode, NewNode,text="Not available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[NewNode]] <- "Not available")

##################################################################################################################

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFParamsNode,text="Parameters",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFParamsNode]] <- "Parameters") 

      if (NumParameters>0)
        for (i in (1:NumParameters))
        {
          Try(NewNode <- paste("PMFParams.",parameterizationTreeIndex,".",i,sep=""))
          Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",PMFParamsNode, NewNode,text=ParameterNamesVec[i],font=.limmaGUIglobals$limmaGUIfontTree))
          Try(ParameterizationList[[ParameterizationNameNode]][[NewNode]] <- ParameterNamesVec[i])
        }

    # Insert design matrix list object (containing design matrix and a flag saying whether
    # the design matrix was created from drop-downs) into list version of tree.
      Try(ParameterizationList[[ParameterizationNameNode]][["designList"]] <- designList) 

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFLinModNode,text="Linear Model Fit",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFLinModNode]] <- "Linear Model Fit")

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFLinModNode,PMFLinModStatusNode,text="Not available",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFLinModStatusNode]] <- "Not available")

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFEBayesNode,text="Empirical Bayes Statistics",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFEBayesNode]] <- "Empirical Bayes Statistics")

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFEBayesNode,PMFEBayesStatusNode,text="Not available",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFEBayesStatusNode]] <- "Not available")

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFDupCorNode,text="Duplicate Correlation",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFDupCorNode]] <- "Duplicate Correlation")

      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFDupCorNode,PMFDupCorStatusNode,text="Not available",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(ParameterizationList[[ParameterizationNameNode]][[PMFDupCorStatusNode]] <- "Not available")

    # Insert NumContrastParameterizations into list version of parameterization tree.
      Try(ParameterizationList[[ParameterizationNameNode]][["NumContrastParameterizations"]] <- 0)

      Try(ParameterizationList[[ParameterizationNameNode]][["Contrasts"]] <- list())

      Try(ParameterizationList[[ParameterizationNameNode]][["ContrastsParameterizationTreeIndexVec"]] <- c()) 

      Try(assign("ParameterizationTreeIndexVec",ParameterizationTreeIndexVec,limmaGUIenvironment))
      Try(assign("ParameterizationNamesVec",ParameterizationNamesVec,limmaGUIenvironment))
      Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
      Try(assign("NumParameterizations",NumParameterizations,limmaGUIenvironment))

      Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
      return("ok")
}

CreateNewParameterization <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Create New Parameterization",
          message="No arrays have been loaded.  Please try New or Open from the File menu.",
          type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(InitNewParameterizationReturnVal <- InitNewParameterization())
  Try(if (InitNewParameterizationReturnVal$result=="cancel") return())
  Try(parameterizationIndex <- InitNewParameterizationReturnVal$parameterizationIndex)
  Try(parameterizationTreeIndex <- InitNewParameterizationReturnVal$parameterizationTreeIndex)
  Try(ParameterizationNameText <- InitNewParameterizationReturnVal$ParameterizationNameText) 
  Try(ParameterNamesVec <- InitNewParameterizationReturnVal$ParameterNamesVec)
  Try(designList <- InitNewParameterizationReturnVal$designList)
  Try(SpotTypesForLinearModel <- InitNewParameterizationReturnVal$SpotTypesForLinearModel)

  Try(CreateTreeAndList(parameterizationIndex,parameterizationTreeIndex,
    ParameterizationNameText,ParameterNamesVec,designList,SpotTypesForLinearModel))
}

ViewRNATargets <- function()
{
      Try(NumSlides <- get("NumSlides",envir=limmaGUIenvironment))
      Try(Targets <- get("Targets",envir=limmaGUIenvironment))      
      Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
      Try(RawMADataWasImported<- get("RawMADataWasImported", envir=limmaGUIenvironment))       
      Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))       
  
      if (RawMADataWasImported==TRUE || NormalizedMADataWasImported==TRUE)
      {
          Try(tkmessageBox(title="RNA Targets",message="MA Data was imported. Targets are unknown.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()      
      }
      if (ArraysLoaded==FALSE)
      {
          Try(tkmessageBox(title="RNA Targets",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      }
      if (nrow(Targets)==0)
      {
          Try(tkmessageBox(title="RNA Targets",message="No RNA targets have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      }

      Try(ttViewRNATargets <- tktoplevel(.limmaGUIglobals$ttMain))
      Try(tkwm.deiconify(ttViewRNATargets))
      Try(tkgrab.set(ttViewRNATargets))
      Try(tkfocus(ttViewRNATargets))
      Try(tkwm.title(ttViewRNATargets,"RNA Targets"))
      
#      Try(n <- evalq(TclVarCount <- TclVarCount + 1, .TkRoot$env))
#     Try(tclArrayName <- paste("::RTcl", n, sep = ""))
      Try(tclArrayVar1 <- tclArrayVar())
      Try(tclArrayName <- ls(tclArrayVar1$env))
      
      onClose <- function() {Try(tkgrab.release(ttViewRNATargets));Try(tkdestroy(ttViewRNATargets));Try(tkfocus(.limmaGUIglobals$ttMain))}
  
      Try(NumCols <- ncol(Targets))
      Try(NumRows <- nrow(Targets))
     
      Try(myRarray <- c())

      if (NumCols>0)
        for (j in (1:NumCols))      
        {
          Try(myRarray <- c(myRarray,paste(colnames(Targets)[j])))
          for (i in (1:NumRows))
          {          
              Try(myRarray <- c(myRarray,paste(Targets[i,j])))
          }      
        }      

          Try(dim(myRarray) <- c(NumRows+1,NumCols))

          # This will give an error if tclArray doesn't exist.
          # .Tcl("unset tclArray")
          if (NumRows>0 && NumCols>0)
            for (i in (0:NumRows))
              for (j in (1:NumCols))
#                 Try(.Tcl(paste("set ",tclArrayName,"(",i,",",j-1,") ",myRarray[i+1,j],sep="")))                 
                 Try(tkcmd("set",paste(tclArrayName,"(",i,",",j-1,")",sep=""),paste(myRarray[i+1,j])))
         
          # Below, I should just use tkwidget(ttViewRNATargets,"table",...) 
          Try(table1 <- .Tk.subwin(ttViewRNATargets))
          Try(.Tcl(paste("table",.Tk.ID(table1),.Tcl.args(variable=tclArrayName,rows=paste(NumRows+1),cols=paste(NumCols),titlerows="0",titlecols="0",selectmode="extended",colwidth="13",background="white",rowseparator="\"\n\"",colseparator="\"\t\"",resizeborders="col",multiline="0",
                titlerows=1,colstretchmode="unset",
                xscrollcommand=function(...) tkset(xscr,...),yscrollcommand=function(...) tkset(yscr,...),state="disabled"))))
          Try(xscr <- tkscrollbar(ttViewRNATargets,orient="horizontal", command=function(...)tkxview(table1,...)))
          Try(yscr <- tkscrollbar(ttViewRNATargets,command=function(...)tkyview(table1,...)))               
          Try(tkgrid(table1,yscr))
          Try(tkgrid.configure(yscr,sticky="nsw"))
          Try(tkgrid(xscr))
          Try(tkgrid.configure(xscr,sticky="new"))
          Try(tkconfigure(table1,font=.limmaGUIglobals$limmaGUIfontTable))

          for (j in (1:NumCols))      
            Try(tkcmd(.Tk.ID(table1),"width",paste(j-1),paste(max(4,nchar(colnames(Targets)[j])+2,max(nchar(Targets[,j]))+2))))

          Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<<Copy>>"))))

          saveTargetsFile <- function()
          {
            Try(TargetsFileName <- tclvalue(tkgetSaveFile(filetypes="{{RNA Targets Files} {.txt}} {{All files} *}")))
            Try(if (!nchar(TargetsFileName)) return())
            Try(len <- nchar(TargetsFileName))
            if (len<=4)
              Try(  TargetsFileName <- paste(TargetsFileName,".txt",sep=""))
            else if (substring(TargetsFileName,len-3,len)!=".txt")
                  Try(TargetsFileName <- paste(TargetsFileName,".txt",sep=""))
            Try(Targets <- matrix(nrow=NumRows,ncol=NumCols))
            Try(colnamesTargets <- c())
            if (NumCols>0)
              Try(for (j in (1:NumCols))
                colnamesTargets[j] <- tclvalue(paste(tclArrayName,"(0,",j-1,")",sep="")))
            Try(colnames(Targets) <- colnamesTargets)       
            if (NumRows>0 && NumCols>0)
              Try(for (i in (1:NumRows))
                 for (j in (1:NumCols))
                    Targets[i,j] <- tclvalue(paste(tclArrayName,"(",i,",",j-1,")",sep="")))

            Try(write.table(Targets,file=TargetsFileName,sep="\t",quote=FALSE,col.names=TRUE,row.names=FALSE))
          }


          Try(topMenu <- tkmenu(ttViewRNATargets, tearoff=FALSE))

          Try(topMenu <- tkmenu(ttViewRNATargets, tearoff=FALSE))
          Try(fileMenu <- tkmenu(topMenu, tearoff=FALSE))
          Try(tkadd(fileMenu, "command", label="Save As",   command=saveTargetsFile)) 
          Try(tkadd(fileMenu, "command", label="Close",   command=onClose)) 
          Try(tkadd(topMenu,  "cascade", label="File",menu=fileMenu)) # ) 

          Try(editMenu <- tkmenu(topMenu, tearoff=FALSE))
          Try(tkadd(editMenu, "command", label="Copy <Ctrl-C>",      command=copyFcn)) 
          Try(tkadd(topMenu,  "cascade", label="Edit",menu=editMenu)) 
                   
          Try(tkconfigure(ttViewRNATargets,menu=topMenu))

          Try(tkfocus(ttViewRNATargets))
          Try(tkbind(ttViewRNATargets, "<Destroy>", function() {Try(tkgrab.release(ttViewRNATargets));Try(tkfocus(.limmaGUIglobals$ttMain))}))
          Try(tkwait.window(ttViewRNATargets))
}

########################################################################################################
# Some C-style string searching functions, because I'm not very good at using regular expressions ;-) 

# Returns the index where needle is found in haystack or zero if not found.
nstrstr <- function(haystack,needle)
{
  lenHaystack <- nchar(haystack)
  lenNeedle   <- nchar(needle)
  if (lenHaystack < lenNeedle)
    return (0)
  if (lenHaystack == lenNeedle)
    return(haystack==needle)
  lenDiff <- lenHaystack-lenNeedle
  for (i in (1:lenDiff))
    if (needle==substr(haystack,i,i+lenNeedle-1))
      return(i)

  return (0)
}

strstr <- function(haystack,needle)
{
  strIndex <- nstrstr(haystack,needle)
  if (strIndex==0)
    return ("")
  return (substr(haystack,strIndex,nchar(haystack)))
}

#####################################################################################################

ViewSpotTypes <- function()
{
      Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))      
      Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
      Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))       
  
      if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
      {
          Try(tkmessageBox(title="Spot Types",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      }
      if (nrow(SpotTypes)==0)
      {
          Try(tkmessageBox(title="Spot Types",message="No spot types have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      }

      Try(ttViewSpotTypes <- tktoplevel(.limmaGUIglobals$ttMain))
      Try(tkwm.deiconify(ttViewSpotTypes))
      Try(tkgrab.set(ttViewSpotTypes))
      Try(tkfocus(ttViewSpotTypes))
      Try(tkwm.title(ttViewSpotTypes,"Spot Types"))

#      Try(n <- evalq(TclVarCount <- TclVarCount + 1, .TkRoot$env))
#     Try(tclArrayName <- paste("::RTcl", n, sep = ""))      
      Try(tclArrayVar1 <- tclArrayVar())
      Try(tclArrayName <- ls(tclArrayVar1$env))
      
      onOK <- function() 
      {
          Try(.Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<Leave>"))))

          NumRows <- as.integer(strsplit(tclvalue(tkcmd(table1,"configure","-rows"))," ")[[1]][5])-1
          NumCols <- as.integer(strsplit(tclvalue(tkcmd(table1,"configure","-cols"))," ")[[1]][5])
          
          Try(SpotTypes <- as.data.frame(matrix(nrow=NumRows,ncol=NumCols)))
          Try(colnamesSpotTypes <- c())
          if (NumCols>0)
            for (j in (1:NumCols))
              Try(colnamesSpotTypes[j] <- tclvalue(paste(tclArrayName,"(0,",j-1,")",sep="")))
          Try(colnames(SpotTypes) <- colnamesSpotTypes)
          if (NumRows>0 && NumCols>0)
            for (i in (1:NumRows))
               for (j in (1:NumCols))
                    Try(SpotTypes[i,j] <- tclvalue(paste(tclArrayName,"(",i,",",j-1,")",sep="")))
          Try(assign("SpotTypes",SpotTypes,limmaGUIenvironment))           
          tkconfigure(ttViewSpotTypes,cursor="watch")   
          Try(UpdateSpotTypesStatus())
          tkconfigure(ttViewSpotTypes,cursor="arrow")             
          Try(tkgrab.release(ttViewSpotTypes));Try(tkdestroy(ttViewSpotTypes));Try(tkfocus(.limmaGUIglobals$ttMain))
      }
      onCancel <- function() {Try(tkgrab.release(ttViewSpotTypes));Try(tkdestroy(ttViewSpotTypes));Try(tkfocus(.limmaGUIglobals$ttMain))}

#      Try(labelSpotTypes <- tklabel(ttViewSpotTypes,text=paste("Spot Types"),font=.limmaGUIglobals$limmaGUIfont2b))
#      Try(tkgrid(labelSpotTypes,column=2,columnspan=2))
#      Try(tkgrid(tklabel(ttViewSpotTypes,text="    ")))
  
      Try(NumCols <- ncol(SpotTypes))
      Try(NumRows <- nrow(SpotTypes))
     
      Try(myRarray <- c())

      if (NumCols>0)
        for (j in (1:NumCols))      
        {
          Try(myRarray <- c(myRarray,paste(colnames(SpotTypes)[j])))
          for (i in (1:NumRows))
          {          
              Try(myRarray <- c(myRarray,paste(SpotTypes[i,j])))
          }      
        }      

          Try(dim(myRarray) <- c(NumRows+1,NumCols))

          # This will give an error if tclArray doesn't exist.
          # .Tcl("unset tclArray")
          if (NumRows>0 && NumCols>0)
            for (i in (0:NumRows))
              for (j in (1:NumCols))
#                 Try(.Tcl(paste("set ",tclArrayName,"(",i,",",j-1,") ",myRarray[i+1,j],sep="")))
                Try(tkcmd("set",paste(tclArrayName,"(",i,",",j-1,")",sep=""),paste(myRarray[i+1,j])))                 
         
          # Below, I should just use tkwidget(ttViewSpotTypes,"table",...) 
          Try(table1 <- .Tk.subwin(ttViewSpotTypes))
          Try(.Tcl(paste("table",.Tk.ID(table1),.Tcl.args(variable=tclArrayName,rows=paste(NumRows+1),cols=paste(NumCols),titlerows="0",titlecols="0",selectmode="extended",colwidth="13",background="white",rowseparator="\"\n\"",colseparator="\"\t\"",resizeborders="col",multiline="0",
                titlerows=1,
                xscrollcommand=function(...) tkset(xscr,...),yscrollcommand=function(...) tkset(yscr,...)))))
          Try(xscr <- tkscrollbar(ttViewSpotTypes,orient="horizontal", command=function(...)tkxview(table1,...)))
          Try(yscr <- tkscrollbar(ttViewSpotTypes,command=function(...)tkyview(table1,...)))                
          Try(tkgrid(table1,yscr))
          Try(tkgrid.configure(yscr,sticky="nsw"))
          Try(tkgrid(xscr))
          Try(tkgrid.configure(xscr,sticky="new"))
          Try(tkconfigure(table1,font=.limmaGUIglobals$limmaGUIfontTable))

          for (j in (1:NumCols))      
            Try(tkcmd(.Tk.ID(table1),"width",paste(j-1),paste(max(4,nchar(colnames(SpotTypes)[j])+2,max(nchar(SpotTypes[,j]))+2))))

          Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(table1),"<<Copy>>"))))

          openSpotTypesFile <- function()
          {
            Try(SpotTypesFileName <- tclvalue(tkgetOpenFile(filetypes="{{Spot-Type Files} {.txt}} {{All files} *}")))
            Try(if (!nchar(SpotTypesFileName)) return())
            Try(SpotTypes <- read.table(SpotTypesFileName,header=FALSE,sep="\t",quote="\"",as.is=TRUE,comment.char=""))
            Try(NumRows <<- nrow(SpotTypes)-1)
            Try(NumCols <<- ncol(SpotTypes))            
            Try(tkconfigure(table1,rows=paste(NumRows+1),cols=paste(NumCols)))
            # This will give an error if tclArray doesn't exist.
            # .Tcl("unset tclArray")
            if (NumRows>0 && NumCols>0)
               for (i in (0:NumRows))
                 for (j in (1:NumCols))
#                   Try(.Tcl(paste("set ",tclArrayName,"(",i,",",j-1,") \"",SpotTypes[i+1,j],"\"",sep="")))
                   Try(tkcmd("set",paste(tclArrayName,"(",i,",",j-1,")",sep=""),paste(SpotTypes[i+1,j])))                   
          }

          saveSpotTypesFile <- function()
          {
            Try(SpotTypesFileName <- tclvalue(tkgetSaveFile(filetypes="{{Spot-Type Files} {.txt}} {{All files} *}")))
            Try(if (!nchar(SpotTypesFileName)) return())
            Try(len <- nchar(SpotTypesFileName))
            if (len<=4)
              Try(  SpotTypesFileName <- paste(SpotTypesFileName,".txt",sep=""))
            else if (substring(SpotTypesFileName,len-3,len)!=".txt")
                  Try(SpotTypesFileName <- paste(SpotTypesFileName,".txt",sep=""))
            Try(SpotTypes <- matrix(nrow=NumRows,ncol=NumCols))
            Try(colnamesSpotTypes <- c())
            if (NumCols>0)
              Try(for (j in (1:NumCols))
                colnamesSpotTypes[j] <- tclvalue(paste(tclArrayName,"(0,",j-1,")",sep="")))
            Try(colnames(SpotTypes) <- colnamesSpotTypes)       
            if (NumRows>0 && NumCols>0)
              Try(for (i in (1:NumRows))
                 for (j in (1:NumCols))
                    SpotTypes[i,j] <- tclvalue(paste(tclArrayName,"(",i,",",j-1,")",sep="")))

            Try(write.table(SpotTypes,file=SpotTypesFileName,sep="\t",quote=FALSE,col.names=TRUE,row.names=FALSE))
          }

          addRowFcn <- function()
          {         
            Try(tkinsert(table1,"rows","end","1"))
          }
          
          insertRowFcn <- function()
          {         
            if (data.class(result<-try(tkinsert(table1,"rows",paste(as.integer(tclvalue(tkindex(table1,"active","row")))),"-1"),TRUE))=="try-error")
            {
              Try(errorMessage <- strstr(as.character(result),"[tcl]"))
              Try(if (errorMessage=="")
                errorMessage <- result)
              Try(tkmessageBox(title="Failed to Insert Row",message=errorMessage,icon="error",type="ok"))
            }
          }
          
          deleteLastRowFcn <- function()
          {
            Try(tkdelete(table1,"rows","end","1"))  
          }
          
          deleteCurrentRowFcn <- function()
          {
            if (data.class(result<-try(tkdelete(table1,"rows",tclvalue(tkindex(table1,"active","row")),"1"),TRUE))=="try-error")
            {
              Try(errorMessage <- strstr(as.character(result),"[tcl]"))
              Try(if (errorMessage=="")
                errorMessage <- result)
              Try(tkmessageBox(title="Failed to Delete Row",message=errorMessage,icon="error",type="ok"))
            }
          }

          Try(topMenu <- tkmenu(ttViewSpotTypes, tearoff=FALSE))

          Try(topMenu <- tkmenu(ttViewSpotTypes, tearoff=FALSE))
          Try(fileMenu <- tkmenu(topMenu, tearoff=FALSE))
          Try(tkadd(fileMenu, "command", label="Open",      command=openSpotTypesFile)) 
          Try(tkadd(fileMenu, "command", label="Save As",   command=saveSpotTypesFile)) 
          Try(tkadd(topMenu,  "cascade", label="File",menu=fileMenu)) # ) 

          Try(editMenu <- tkmenu(topMenu, tearoff=FALSE))
          Try(tkadd(editMenu, "command", label="Copy <Ctrl-C>",      command=copyFcn)) 
          Try(tkadd(topMenu,  "cascade", label="Edit",menu=editMenu))
          
          Try(rowsMenu <- tkmenu(topMenu, tearoff=FALSE))
          Try(tkadd(rowsMenu, "command", label="Add Row",                            command=addRowFcn))
          Try(tkadd(rowsMenu, "command", label="Insert Row before Current Row",      command=insertRowFcn))          
          Try(tkadd(rowsMenu, "separator"))
          Try(tkadd(rowsMenu, "command", label="Delete Last Row",                    command=deleteLastRowFcn))
          Try(tkadd(rowsMenu, "command", label="Delete Current Row",                 command=deleteCurrentRowFcn))          
          Try(tkadd(topMenu,  "cascade", label="Rows",menu=rowsMenu))
          
          Try(columnsMenu <- tkmenu(topMenu, tearoff=FALSE))
          Try(editableColumnHeadings <- tclVar("0"))
          Try(tkadd(columnsMenu, "checkbutton",variable=editableColumnHeadings,label="Editable Column Headings",
                command=function() {if (tclvalue(editableColumnHeadings)=="1") tkconfigure(table1,titlerows=0) else tkconfigure(table1,titlerows=1)}))
          Try(tkadd(topMenu,  "cascade", label="Columns",menu=columnsMenu))
          
          Try(tkconfigure(ttViewSpotTypes,menu=topMenu))

          Try(BlankLabel1<-tklabel(ttViewSpotTypes,text="    "))
          Try(tkgrid(BlankLabel1))
          Try(BlankLabel2<-tklabel(ttViewSpotTypes,text="    "))
          Try(OKCancelFrame <- tkframe(ttViewSpotTypes)) 
          Try(OK.but <-tkbutton(OKCancelFrame,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
          Try(Cancel.but <-tkbutton(OKCancelFrame,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))      
          Try(tkgrid(OK.but,Cancel.but))
          Try(tkgrid.configure(OK.but,sticky="e"))
          Try(tkgrid.configure(Cancel.but,sticky="w"))          
          Try(tkgrid(OKCancelFrame))
          Try(BlankLabel3<-tklabel(ttViewSpotTypes,text="    "))
          Try(tkgrid(BlankLabel3))

          Try(tkfocus(ttViewSpotTypes))
          Try(tkbind(ttViewSpotTypes, "<Destroy>", function() {Try(tkgrab.release(ttViewSpotTypes));Try(tkfocus(.limmaGUIglobals$ttMain))}))
          Try(tkwait.window(ttViewSpotTypes))
}



ComputeContrasts <- function()
{
  # If we have a connected design, the number of parameters to be estimated initially is NumRNATypes - 1,
  # and the total number of possible contrasts is NumRNATypes Choose 2, so the number of additional contrasts
  # not covered in the Main Linear Model Fit is NumRNATypesChoose2 - (NumRNATypes-1).  This will be the default
  # number of columns of the contrasts matrix (for a connected design), unless this number is greater than 6.
  # In that case, it will be limited to 6 columns, and the user will have to add extra columns themselves.
  # (6 columns is  [ 5 Choose 2 - (5-1)  = 6 ] i.e. it is sufficient for 5 RNA types in a connected design.

  # For an unconnected design, the number of parameters estimated in the main linear model fit is 
  # NumRNATypes - NumSubGraphs (where the empty graph is not counted as a subgraph, and if there is 
  # only one connected graph, it is counted as one subgraph).
  # The total number of contrasts in this case is the sum of each of the numbers of contrasts for each
  # subgraph.  For each subgraph, the total number of contrasts is :
  # NumRNATypesSubgraph Choose 2, so the default number of columns of the contrasts matrix is :
  # TotalNumberOfContrasts = SUM_i ( NumRNATtypesSubgraph_i Choose 2 ) - (NumRNATTypes-NumSubGraphs)
  # But again we will limit it to a maximum of 6 for displaying the initial Tktable (but the user can add more).

  # In the same way as the GUI for entering the design matrix, we can have a simple drop-down interface and
  # an Advanced button.

  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))
  Try(Targets <- get("Targets",envir=limmaGUIenvironment))
  Try(NumRNATypes <- get("NumRNATypes",envir=limmaGUIenvironment))
  Try(numConnectedSubGraphs <- get("numConnectedSubGraphs",envir=limmaGUIenvironment))    
  Try(connectedSubGraphs <- get("connectedSubGraphs",envir=limmaGUIenvironment))        
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   

  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Compute Contrasts",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }
  
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Compute Contrasts",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)

  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Compute Contrasts",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

#  Try(tkmessageBox(message=paste("NumRNATypes :",NumRNATypes)))
#  Try(tkmessageBox(message=paste("NumParameters :",NumParameters)))
#  Try(tkmessageBox(message=paste("numConnectedSubGraphs :",numConnectedSubGraphs)))

  # The unique(vec) function in R returns a vector with duplicate entries removed.    
  Try(RNATypesInSubGraph <- c())
  Try(NumContrastsInSubGraph <- c())  
  Try(TotalNumContrasts <- 0)
  Try(for (i in (1:numConnectedSubGraphs))
  {
    Try(RNATypesInSubGraph[i] <- length(unique(connectedSubGraphs[[i]])))
    Try(NumContrastsInSubGraph[i] <- choose(RNATypesInSubGraph[i],2))
    Try(TotalNumContrasts <- TotalNumContrasts + NumContrastsInSubGraph[i])
#    Try(tkmessageBox(message=paste("RNATypesInSubGraph[",i,"] : ",RNATypesInSubGraph[i],sep="")))
#    for (j in (1:RNATypesInSubGraph[i]))
#      tkmessageBox(message=paste("RNATypesInSubgraph[",i,"][",j,"] = ",connectedSubGraphs[[i]][j],sep=""))
#    Try(tkmessageBox(message=paste("NumContrastsInSubGraph[",i,"] : ",NumContrastsInSubGraph[i],sep="")))    
  })
  
  Try(NumContrasts <- TotalNumContrasts - NumParameters)

#  Try(tkmessageBox(message=paste("TotalNumContrasts :",TotalNumContrasts)))    
#  Try(tkmessageBox(message=paste("NumContrasts :",NumContrasts)))  
  
  Try(if (NumContrasts<=0)
  {
    tkmessageBox(title="Compute Contrasts",message=paste("For this experiment, all possible RNA comparisons can be obtained from one parameterization.  There is no need to compute contrasts.",
                         "\n\nThis is either because there are only 2 RNA types, or there is an unconnected experimental design and there only 2 RNA types within each sub-experiment."),type="ok",icon="error")
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()
  })
  
  Try(NumContrasts <- min(NumContrasts,6))
  
  Try(contrastsMatrixInList <- GetDesignOrContrasts(Contrasts=TRUE,NumContrasts=NumContrasts,parameterizationIndex=parameterizationIndex))  
  Try(if (nrow(contrastsMatrixInList$contrasts)==0) return())
  Try(contrastsMatrix <- as.matrix(contrastsMatrixInList$contrasts))
  tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")     
  Try(contrastsFit <- contrasts.fit(fit,contrastsMatrix))
  Try(contrastsEbayes <- ebayes(contrastsFit))
  tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")       
  Try(contrastsParameterizationNameText <- GetContrastsParameterizationName())  
  Try(if (contrastsParameterizationNameText=="GetContrastsParameterizationName.CANCEL") return())
  tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")     
  Try(while (nchar(contrastsParameterizationNameText)==0)
  {
      Try(tkmessageBox(title="Contrasts Name",message="Please enter a name for this set of contrasts",type="ok",icon="error"))
      Try(contrastsParameterizationNameText <- GetContrastsParameterizationName())
      if (contrastsParameterizationNameText=="GetContrastsParameterizationName.CANCEL") 
      {
          Try(tkfocus(.limmaGUIglobals$ttMain))          
          return()
      }
  })
  
  Try(ContrastsParameterizationNamesVec <- GetContrastsParameterizationNames(parameterizationTreeIndex))

  Try(contrastsParameterizationIndex <- 0)
  Try(newContrastsParameterization <- 1)
  Try(if (contrastsParameterizationNameText %in% ContrastsParameterizationNamesVec)
  {
      Try(contrastsParameterizationIndex <- match(contrastsParameterizationNameText,ContrastsParameterizationNamesVec))
      Try(mbVal<-tclvalue(tkmessageBox(title="Contrasts Parameterization Name",message="This contrasts parameterization name already exists.  Replace?",type="yesnocancel",icon="question")))
      Try(if (mbVal=="cancel") return())
      Try(if (mbVal=="yes") newContrastsParameterization <- 0)
      Try(if (mbVal=="no") newContrastsParameterization <- 1)
  }
  else
      Try(newContrastsParameterization <- 1))

  Try(ContrastsParameterizationTreeIndexVec <- (ParameterizationList[[ParameterizationNameNode]])$ContrastsParameterizationTreeIndexVec)

  Try(NumContrastParameterizations <- (ParameterizationList[[ParameterizationNameNode]])$NumContrastParameterizations)

  if (newContrastsParameterization==1)
  {
      Try(if (length(ContrastsParameterizationTreeIndexVec)!=NumContrastParameterizations)
      {
          Try(tkmessageBox(title="Contrasts Parameterizations","Length of ContrastsParameterizationTreeIndexVec is not equal to NumContrastParameterizations.",type="ok",icon="error"))
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      })
      Try(NumContrastParameterizations <- NumContrastParameterizations + 1)
      Try(contrastsParameterizationIndex <- NumContrastParameterizations)
      Try(if (length(ContrastsParameterizationTreeIndexVec)==0)
          Try(contrastsParameterizationTreeIndex <- 1)
      else
          Try(contrastsParameterizationTreeIndex <- max(ContrastsParameterizationTreeIndexVec)+1))
      Try(ContrastsParameterizationTreeIndexVec[contrastsParameterizationIndex] <- contrastsParameterizationTreeIndex)

      Try(ContrastsParameterizationNamesVec <- c(ContrastsParameterizationNamesVec,contrastsParameterizationNameText))
      
      
      Try(ContrastsParameterizationNamesNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep=""))
      Try(ParameterizationList[[ParameterizationNameNode]][[ContrastsParameterizationNamesNode]] <- contrastsParameterizationNameText)  
  }
  else # Replace existing contrasts parameterization with the same name.
  {
      Try(contrastsParameterizationTreeIndex <- ContrastsParameterizationTreeIndexVec[contrastsParameterizationIndex])
      Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,paste("ContrastsParameterizationName.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep="")))
  }  
  
  Try(ParamContrastsNode <- paste("ParamContrasts.",parameterizationTreeIndex,sep=""))
  
  Try(ContrastsParameterizationNamesVec <- c(ContrastsParameterizationNamesVec,contrastsParameterizationNameText))

  Try(ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations <- NumContrastParameterizations)

  Try(ContrastsParameterizationNamesNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep=""))

  Try(ParameterizationList[[ParameterizationNameNode]][["Contrasts"]][[ContrastsParameterizationNamesNode]] <-
        list(fit=contrastsFit,eb=contrastsEbayes,contrastsMatrixInList=contrastsMatrixInList,contrastsParameterizationNameText=contrastsParameterizationNameText))
  
  Try(ParamContrastsNode <- paste("ParamContrasts.",parameterizationTreeIndex,sep=""))
  Try(ContrastsParameterizationNamesNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep=""))
  
  if (NumContrastParameterizations>0)
    Try(ContrastsNames <- colnames(contrastsMatrix))

  if (NumContrastParameterizations==1)
  {
    # This is the first one, so we have to delete "none"
    Try(NoneNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".1",sep=""))  
    Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,NoneNode))
  }  
  Try(ContrastsParameterizationNamesNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep=""))  
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamContrastsNode,ContrastsParameterizationNamesNode,text=contrastsParameterizationNameText,font=.limmaGUIglobals$limmaGUIfontTree))
  Try(NumContrastsInContrastParameterization <- length(ContrastsNames))
  Try(for (j in (1:NumContrastsInContrastParameterization))
    Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ContrastsParameterizationNamesNode,paste("Contrasts.",parameterizationIndex,".",contrastsParameterizationTreeIndex,".",j,sep=""),text=ContrastsNames[j],font=.limmaGUIglobals$limmaGUIfontTree)))          
  
  Try(ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations <- NumContrastParameterizations)
  Try(ParameterizationList[[ParameterizationNameNode]]$ContrastsParameterizationTreeIndexVec <- ContrastsParameterizationTreeIndexVec)

  Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
  tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")       
}

ComputeLinearModelFit <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))        
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(spacing <- get("spacing",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(WeightingType <- get("WeightingType",envir=limmaGUIenvironment))
  Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))  
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(RG <- get("RG",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Linear Model",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }
  
  SetLayoutParamReturnVal<-1
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))  
  if (length(maLayout)==0) SetLayoutParamReturnVal <-Try(SetLayoutParameters())
  if (SetLayoutParamReturnVal==0) return()  
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
  if (NumParameterizations>0)
  {
      Try(NewParameterizationMB <-tkmessageBox(title="Linear Model",message="Create a new parameterization?",type="yesnocancel",icon="question",default="yes"))
      Try(WhetherToCreateNewParameterization <- tclvalue(NewParameterizationMB))
  }
  else
      Try(WhetherToCreateNewParameterization <- "yes")

  if (WhetherToCreateNewParameterization=="cancel")
      return()
  
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  
  if (WhetherToCreateNewParameterization=="yes")
  {
    Try(InitNewParameterizationReturnVal <- InitNewParameterization())
    Try(if (InitNewParameterizationReturnVal$result=="cancel") return())
    Try(parameterizationIndex <- InitNewParameterizationReturnVal$parameterizationIndex)
    Try(parameterizationTreeIndex <- InitNewParameterizationReturnVal$parameterizationTreeIndex)
    Try(ParameterizationNameText <- InitNewParameterizationReturnVal$ParameterizationNameText) 
    Try(ParameterNamesVec <- InitNewParameterizationReturnVal$ParameterNamesVec)
    Try(designList <- InitNewParameterizationReturnVal$designList)
    Try(design <- designList$design) 
    Try(SpotTypesForLinearModel <- InitNewParameterizationReturnVal$SpotTypesForLinearModel)

    Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
    Try(ParameterizationNamesVec     <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
    Try(ParameterizationList         <- get("ParameterizationList",envir=limmaGUIenvironment))
    Try(NumParameterizations         <- get("NumParameterizations",envir=limmaGUIenvironment))
  
  }
  else # The user said, "No, don't create a new parameterization"
  {
    if (NumParameterizations==0)
    {
      Try(tkmessageBox(title="Use Existing Parameterization",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()  
    }  
    Try(parameterizationIndex <- ChooseParameterization())
    Try(if (parameterizationIndex==0)    return())
    Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(designList <-               (ParameterizationList[[ParameterizationNameNode]])$designList)  
    Try(design <- designList$design)
    Try(ParameterizationNameText <- (ParameterizationList[[ParameterizationNameNode]])[[ParameterizationNameNode]])      
    Try(ParameterNamesVec <- colnames(design))
    Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)

    Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,paste("ParameterizationName.",parameterizationTreeIndex,sep="")))
    Try(ParameterizationList <- deleteItemFromList(ParameterizationList,paste("ParameterizationName.",parameterizationTreeIndex,sep="")))
    Try(ParameterizationList[[ParameterizationNameNode]] <- list())
  }
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(CreateTreeAndList(parameterizationIndex,parameterizationTreeIndex,
    ParameterizationNameText,ParameterNamesVec,designList,SpotTypesForLinearModel))

  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec     <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList         <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(NumParameterizations         <- get("NumParameterizations",envir=limmaGUIenvironment))

  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ParamMainFitNode   <- paste("ParamMainFit.",parameterizationTreeIndex,sep=""))
  Try(ParamContrastsNode <- paste("ParamContrasts.",parameterizationTreeIndex,sep=""))
  Try(PMFNoneNode <- paste("PMFNone.",parameterizationTreeIndex,sep=""))
  Try(PMFSpotTypesNode <- paste("PMFSpotTypes.",parameterizationTreeIndex,sep=""))  
  Try(PMFMANormMethodNode <- paste("PMFMANormMethod.",parameterizationTreeIndex,sep=""))    
  Try(PMFParamsNode <- paste("PMFParams.",parameterizationTreeIndex,sep=""))
  Try(PMFLinModNode <- paste("PMFLinMod.",parameterizationTreeIndex,sep=""))
  Try(PMFLinModStatusNode <- paste("PMFLinModStatus.",parameterizationTreeIndex,sep=""))
  Try(PMFEBayesNode <- paste("PMFEBayes.",parameterizationTreeIndex,sep=""))
  Try(PMFEBayesStatusNode <- paste("PMFEBayesStatus.",parameterizationTreeIndex,sep=""))
  Try(PMFDupCorNode <- paste("PMFDupCor.",parameterizationTreeIndex,sep=""))
  Try(PMFDupCorStatusNode <- paste("PMFDupCorStatus.",parameterizationTreeIndex,sep=""))

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  
  Try(NormalizedMADataWasImported <- get("NormalizedMADataWasImported"))
  Try(if (!NormalizedMADataWasImported)
  {
		Try(NormalizeWithinArraysMB <-tkmessageBox(title="Normalization Within Arrays",message="Normalize Within Arrays?",type="yesnocancel",icon="question",default="yes"))
		Try(WhetherToNormalizeWithinArrays <- tclvalue(NormalizeWithinArraysMB))
		if (WhetherToNormalizeWithinArrays=="cancel")
				return()
		Try(if (WhetherToNormalizeWithinArrays=="yes")
		{
			Try(GetNormMethodVal<- GetNormalizationMethod())
			Try(if (GetNormMethodVal=="") return())
	  })
		Try(NormalizeBetweenArraysMB <-tkmessageBox(title="Normalization Between Arrays",message="Normalize Between Arrays?",type="yesnocancel",icon="question",default="no"))
		Try(WhetherToNormalizeBetweenArrays <- tclvalue(NormalizeBetweenArraysMB))
		if (WhetherToNormalizeBetweenArrays=="cancel")
				return()
  })
  Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
  {
    Try(WithinArrayNormalizationMethod <- "printtiploess")
    Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
  })
  Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
  Try(ParameterizationList[[ParameterizationNameNode]][["WithinArrayNormalizationMethod"]] <- WithinArrayNormalizationMethod)

  Try(if (!NormalizedMADataWasImported)
  {
    Try(ParameterizationList[[ParameterizationNameNode]][["WhetherToNormalizeWithinArrays"]] <- WhetherToNormalizeWithinArrays)
    Try(ParameterizationList[[ParameterizationNameNode]][["WhetherToNormalizeBetweenArrays"]] <- WhetherToNormalizeBetweenArrays)
  })
  
  Try(MANormMethodValueNode <- paste("PMFMANormMethod.",parameterizationTreeIndex,".",1,sep=""))
  Try(ParameterizationList[[ParameterizationNameNode]] <- 
            deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],MANormMethodValueNode))
  Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,MANormMethodValueNode))

  Try(if (!NormalizedMADataWasImported)
  {
    Try(if (WhetherToNormalizeWithinArrays=="yes" && WhetherToNormalizeBetweenArrays=="yes")
        MAnormalizationMethod <- paste("Within arrays (",WithinArrayNormalizationMethod,") and between arrays",sep=""))
    Try(if (WhetherToNormalizeWithinArrays=="yes" && WhetherToNormalizeBetweenArrays!="yes")
        MAnormalizationMethod <- paste("Within arrays (",WithinArrayNormalizationMethod,") only",sep=""))
    Try(if (WhetherToNormalizeWithinArrays!="yes" && WhetherToNormalizeBetweenArrays=="yes")
        MAnormalizationMethod <- "Between arrays only")
    Try(if (WhetherToNormalizeWithinArrays!="yes" && WhetherToNormalizeBetweenArrays!="yes")
        MAnormalizationMethod <- "No normalization")
  }
  else
    MAnormalizationMethod <- "Imported")
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",PMFMANormMethodNode, MANormMethodValueNode,text=MAnormalizationMethod,font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]][[MANormMethodValueNode]] <- MAnormalizationMethod)

  ####################################################################################################################
  
  HowManyDupsReturnVal<-1
  Try(HowManyDupsReturnVal <- HowManyDups())
  if (HowManyDupsReturnVal==0) return()

  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(spacing <- get("spacing",envir=limmaGUIenvironment))    

  Try(if (ndups>1)
  {
    Try(WhetherToCalculateDuplicateCorrelation <- tclvalue(tkmessageBox(title="Duplicate Correlation",
         message="Should limmaGUI calculate duplicate correlation? (If not, you will need to provide an estimate.)",
         type="yesnocancel",icon="question",default="yes")))
    Try(if (WhetherToCalculateDuplicateCorrelation=="cancel")
      return())
    GetDupCor <- function()
    {
      Try(if ("dupcor" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
        Try(dupcor <- ParameterizationList[[ParameterizationNameNode]]$dupcor$cor)
      else
        dupcor <- 0.75)

      Try(ttGetDupCor<-tktoplevel(.limmaGUIglobals$ttMain))
      Try(tkwm.deiconify(ttGetDupCor))
      Try(tkgrab.set(ttGetDupCor))
      Try(tkfocus(ttGetDupCor))
      Try(tkwm.title(ttGetDupCor,"Duplicate Correlation Estimate"))
      Try(tkgrid(tklabel(ttGetDupCor,text="    ")))
      Try(DupCorTcl <- tclVar(paste(dupcor)))
      Try(entry.DupCor <-tkentry(ttGetDupCor,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=DupCorTcl,bg="white"))
      Try(tkgrid(tklabel(ttGetDupCor,text="Enter an estimate for the duplicate correlation.",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2))
      Try(tkgrid(entry.DupCor,columnspan=2))
      Try(ReturnVal <- "ID_CancelFromGetDupCor")
      onOK <- function()
      {    
        Try(DupCorTxt <- tclvalue(DupCorTcl))
        Try(ReturnVal <<- DupCorTxt)
        Try(tkgrab.release(ttGetDupCor));Try(tkdestroy(ttGetDupCor));Try(tkfocus(.limmaGUIglobals$ttMain))
      }
      onCancel <- function()
      {    
        Try(ReturnVal <<- "ID_CancelFromGetDupCor")
        Try(tkgrab.release(ttGetDupCor));Try(tkdestroy(ttGetDupCor));Try(tkfocus(.limmaGUIglobals$ttMain))
      }     
      Try(OK.but <-tkbutton(ttGetDupCor,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
      Try(Cancel.but <-tkbutton(ttGetDupCor,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
      Try(tkgrid(tklabel(ttGetDupCor,text="    ")))
      Try(tkgrid(OK.but,Cancel.but))
      Try(tkgrid.configure(OK.but,sticky="e"))
      Try(tkgrid.configure(Cancel.but,sticky="w"))
      Try(tkgrid(tklabel(ttGetDupCor,text="       ")))
      Try(tkfocus(entry.DupCor))
      Try(tkbind(entry.DupCor, "<Return>",onOK))
      Try(tkbind(ttGetDupCor, "<Destroy>", function(){Try(tkgrab.release(ttGetDupCor));Try(tkfocus(.limmaGUIglobals$ttMain));return("ID_CancelFromGetDupCor")}))
      Try(tkwait.window(ttGetDupCor))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return (ReturnVal)          
    }
    Try(if (WhetherToCalculateDuplicateCorrelation=="no")    
    {
      Try(dupcorText <- GetDupCor())
      Try(if (dupcorText=="ID_CancelFromGetDupCor") return())
      Try(while (dupcorText=="" || inherits(try(dupcor <- eval(parse(text=dupcorText)),TRUE),"try-error"))
      {
        Try(tkmessageBox(title="Invalid Correlation Estimate",message="Please enter a decimal number for the duplicate correlation estimate.",icon="error",type="ok",default="ok"))
        Try(dupcorText <- GetDupCor())
        Try(if (dupcorText=="ID_CancelFromGetDupCor") return())
      })
      Try(dupcor <- list(cor=as.numeric(dupcorText),consensus=as.numeric(dupcorText)))
    })
  })
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
  Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
  {
    Try(WithinArrayNormalizationMethod <- "printtiploess")
    Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
  })
  Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))


  Try(if (!NormalizedMADataWasImported)
  {
		if (WhetherToNormalizeWithinArrays=="yes")
		{
				if (MA.Available$WithinArrays)
				{
					Try(MA <- get("MAwithinArrays",envir=limmaGUIenvironment))
					Try(assign("MA",MA,limmaGUIenvironment))
				}
				else          
				{
					if (WeightingType == "none")
						Try (MA <- normalizeWithinArrays(RG,maLayout,method=WithinArrayNormalizationMethod))
					else
						Try(MA <- normalizeWithinArrays(RG,weights=RG$weights,maLayout,method=WithinArrayNormalizationMethod))
					Try(assign("MA",MA,limmaGUIenvironment))        
					Try(assign("MAwithinArrays",MA,limmaGUIenvironment))
					Try(MA.Available$WithinArrays <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text=paste("Available (using ",WithinArrayNormalizationMethod,")",sep=""),font=.limmaGUIglobals$limmaGUIfontTree))        
				}
		}
		else
		{
				if (MA.Available$Raw)
				{
					Try(MA <- get("MAraw",envir=limmaGUIenvironment))
					Try(assign("MA",MA,limmaGUIenvironment))
				}
				else          
				{
					Try (MA <- MA.RG(RG))
					Try(assign("MA",MA,limmaGUIenvironment))        
					Try(assign("MAraw",MA,limmaGUIenvironment))
					Try(MA.Available$Raw <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
				}        
		}
		Try(MA <- get("MA",envir=limmaGUIenvironment))

		if (WhetherToNormalizeBetweenArrays=="yes") 
		{
			if (WhetherToNormalizeWithinArrays=="yes")
			{
				if (MA.Available$Both)
				{
					Try(MA <- get("MAboth",envir=limmaGUIenvironment))
					Try(assign("MA",MA,limmaGUIenvironment))                    
				}
				else
				{
					Try (MA <- normalizeBetweenArrays(MA))
					Try(assign("MA",MA,limmaGUIenvironment))        
					Try(assign("MAboth",MA,limmaGUIenvironment))
					Try(MA.Available$Both <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))                   
				}

			}
			else
			{
				if (MA.Available$BetweenArrays)
				{
					Try(MA <- get("MAbetweenArrays",envir=limmaGUIenvironment))
					Try(assign("MA",MA,limmaGUIenvironment))                    
				}
				else
				{
					Try (MA <- normalizeBetweenArrays(MA))
					Try(assign("MA",MA,limmaGUIenvironment))        
					Try(assign("MAbetweenArrays",MA,limmaGUIenvironment))
					Try(MA.Available$BetweenArrays <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))        
				}        
			}
		}      
		Try(MA <- get("MA",envir=limmaGUIenvironment))
  }  
  else
    Try(MA <- get("MAimported",envir=limmaGUIenvironment)))
  
  # NOW THAT WE HAVE NORMALIZED, IT IS TIME TO REMOVE SOME OF THE SPOTS (e.g. CONTROLS AND BLANKS)

  Try(SpotTypesIncluded <- c())
  Try(for (i in (1:numSpotTypes))
    if (SpotTypesForLinearModel[i]==TRUE)
      SpotTypesIncluded <- c(SpotTypesIncluded,SpotTypes[i,"SpotType"]))


  Try(oldNumRows <- nrow(MA$M))
  Omit <- ""
  count <- 0
  Try(for (i in (1:numSpotTypes))
  {
    if (SpotTypesForLinearModel[i]==TRUE)
      next()
    count <- count + 1
    if (count>1)
      Omit <-paste(Omit,"|")
    else
      Omit <- "("
    Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
  })
  
  Try(if (nchar(Omit)>0)
  {
    Omit <- paste(Omit,")")
    Try(Omit <- eval(parse(text=Omit)))  
    MA$M <- MA$M[!Omit,]
    MA$A <- MA$A[!Omit,]  
  })
  
# Below: We shouldn't save MA globally because it depends on the spot-type ommissions of this parameterization.  
#  Try(assign("MA",MA,limmaGUIenvironment)) 
  Try(newNumRows <- nrow(MA$M))
  Try(parameterizationSpacing <- spacing)
  Try(spacingCorrected <- 0)
  Try(if (oldNumRows/spacing==2  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/2;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==3  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/3;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==4  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/4;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==5  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/5;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==6  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/6;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==7  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/7;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==8  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/8;  spacingCorrected <- 1})
  Try(if (oldNumRows/spacing==9  && oldNumRows!=newNumRows) { parameterizationSpacing <- newNumRows/9;  spacingCorrected <- 1})      
  Try(if (oldNumRows/spacing==10 && oldNumRows!=newNumRows){ parameterizationSpacing <- newNumRows/10; spacingCorrected <- 1})
#  Try(if (spacingCorrected==1) tkmessageBox(title="Duplicate Spacing",message="Correcting duplicate spacing to allow for omitted spot types",icon="info"))

  Try(spacing <- parameterizationSpacing) # Local assignment only
  
  # I should delete the above code and just call GetReducedDuplicateSpacing.

  # Calling the A matrix, "A" would risk getting confused with another attribute starting with 'A'.
  Try(ParameterizationList[[ParameterizationNameNode]][["Amatrix"]] <- MA$A)
  
  if (ndups==1)
  {
    Try(fit <- lmFit(MA,as.matrix(design)))

    Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,PMFDupCorStatusNode))  
    Try(ParameterizationList[[ParameterizationNameNode]] <- 
            deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFDupCorStatusNode))
    Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFDupCorNode,PMFDupCorStatusNode,text="No duplicates",font=.limmaGUIglobals$limmaGUIfontTree))
    Try(ParameterizationList[[ParameterizationNameNode]] <- deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFDupCorStatusNode))
    Try(ParameterizationList[[ParameterizationNameNode]][[PMFDupCorStatusNode]] <- "No duplicates")

    Try(ParameterizationList[[ParameterizationNameNode]][["dupcor"]] <- 0)
  } else
  {
    Try(if (WhetherToCalculateDuplicateCorrelation=="yes")    # Otherwise user entered it (hopefully).
    {
      Try(dupcor <- dupcor.series(MA$M,as.matrix(design),ndups=ndups,spacing=spacing))
      Try(if (!("cor" %in% names(dupcor))) dupcor$cor <- dupcor$consensus)
    })
    Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,PMFDupCorStatusNode))  
    Try(ParameterizationList[[ParameterizationNameNode]] <- 
            deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFDupCorStatusNode))    
    Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFDupCorNode,PMFDupCorStatusNode,text=paste(dupcor$cor),font=.limmaGUIglobals$limmaGUIfontTree))
    Try(ParameterizationList[[ParameterizationNameNode]] <- deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFDupCorStatusNode))
    Try(ParameterizationList[[ParameterizationNameNode]][[PMFDupCorStatusNode]] <- paste(dupcor$cor))

    Try(ParameterizationList[[ParameterizationNameNode]][["dupcor"]] <- dupcor)

    Try(fit <- gls.series(MA$M,as.matrix(design),ndups=ndups,spacing=spacing,correlation=dupcor$cor))
  }

  Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,PMFLinModStatusNode))  
  Try(ParameterizationList[[ParameterizationNameNode]] <- 
            deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFLinModStatusNode))
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFLinModNode,PMFLinModStatusNode,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]] <- deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFLinModStatusNode))
  Try(ParameterizationList[[ParameterizationNameNode]][[PMFLinModStatusNode]] <- "Available")

  Try(ParameterizationList[[ParameterizationNameNode]][["fit"]] <- fit)

  Try(eb <- ebayes(fit))

  Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,PMFEBayesStatusNode))    
  Try(ParameterizationList[[ParameterizationNameNode]] <- 
            deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFEBayesStatusNode))
  Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFEBayesNode,PMFEBayesStatusNode,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(ParameterizationList[[ParameterizationNameNode]] <- deleteItemFromList(ParameterizationList[[ParameterizationNameNode]],PMFEBayesStatusNode))
  Try(ParameterizationList[[ParameterizationNameNode]][[PMFEBayesStatusNode]] <- "Available")

  Try(ParameterizationList[[ParameterizationNameNode]][["eb"]] <- eb)
  
  Try(gal <- get("gal",envir=limmaGUIenvironment))
  Try(if (ndups==1) 
  {
   if (nchar(Omit)>0)
     Try(ParameterizationList[[ParameterizationNameNode]][["genelist"]] <- gal[!Omit,])
   else
     Try(ParameterizationList[[ParameterizationNameNode]][["genelist"]] <- gal)
  }
  else  
  {
     if (nchar(Omit)>0)
       Try(ParameterizationList[[ParameterizationNameNode]][["genelist"]] <- uniquegenelist(gal[!Omit,],ndups=ndups,spacing=spacing))
     else
       Try(ParameterizationList[[ParameterizationNameNode]][["genelist"]] <- uniquegenelist(gal,ndups=ndups,spacing=spacing))
  })
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(LinearModelComputed <- get("LinearModelComputed",envir=limmaGUIenvironment))
  Try(LinearModelComputed[parameterizationIndex] <- TRUE)
  Try(assign("LinearModelComputed",LinearModelComputed,limmaGUIenvironment))

  Try(assign("ParameterizationTreeIndexVec",ParameterizationTreeIndexVec,limmaGUIenvironment))
  Try(assign("ParameterizationNamesVec",ParameterizationNamesVec,limmaGUIenvironment))
  Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
  Try(assign("NumParameterizations",NumParameterizations,limmaGUIenvironment))

  Try(if (ndups>1)
  {
    Try(msg <- paste("Duplicate Correlation : ",dupcor$cor,sep=""))
    Try(tkmessageBox(title="Duplicate Correlation",message=msg,icon="info",type="ok",default="ok"))
  })  
}

ChooseParameterization <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  
  ttChooseParameterization<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttChooseParameterization)
  tkgrab.set(ttChooseParameterization)  
  tkfocus(ttChooseParameterization)
  tkwm.title(ttChooseParameterization,"Choose a Parameterization")
  scr <- tkscrollbar(ttChooseParameterization, repeatinterval=5,
                       command=function(...)tkyview(tl,...))
  ## Safest to make sure scr exists before setting yscrollcommand
  tl<-tklistbox(ttChooseParameterization,height=4,selectmode="single",yscrollcommand=function(...)tkset(scr,...),background="white",font=.limmaGUIglobals$limmaGUIfont2)   
  lbl2<-tklabel(ttChooseParameterization,text="Which parameterization is this for?",font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttChooseParameterization,text="       "),row=0,column=1,columnspan=1)
  tkgrid(tklabel(ttChooseParameterization,text="       "),row=0,column=4,columnspan=1)
  tkgrid(lbl2,row=1,column=2,columnspan=2,rowspan=1);
  tkgrid.configure(lbl2,sticky="w")
  tkgrid(tklabel(ttChooseParameterization,text="         "),row=2,column=1)
  tkgrid(tl,row=2,column=2,columnspan=2,rowspan=4,sticky="ew")
  tkgrid(scr,row=2,column=3,columnspan=1,rowspan=4,sticky="wns")
  if (NumParameterizations>0)
    for (i in (1:NumParameterizations))
       tkinsert(tl,"end",ParameterizationNamesVec[i])
  tkselection.set(tl,0)

  ReturnVal <- 0
  onOK <- function()
  {
      Try(parameterizationIndex <- as.numeric(tclvalue(tkcurselection(tl)))+1)
      Try(tkgrab.release(ttChooseParameterization));Try(tkdestroy(ttChooseParameterization));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- parameterizationIndex
  }
  onCancel <- function() {Try(tkgrab.release(ttChooseParameterization));Try(tkdestroy(ttChooseParameterization));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- 0}
  OK.but <-tkbutton(ttChooseParameterization,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttChooseParameterization,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttChooseParameterization,text="    "))
  tkgrid(tklabel(ttChooseParameterization,text="    "),tklabel(ttChooseParameterization,text="    "),OK.but,Cancel.but)
  tkgrid.configure(OK.but,    sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  Try(tkbind(OK.but, "<Return>",onOK))  
  Try(tkbind(tl, "<Return>",onOK))    
  Try(tkbind(Cancel.but, "<Return>",onCancel))    
  tkgrid(tklabel(ttChooseParameterization,text="    "))
  Try(tkfocus(ttChooseParameterization))
  Try(tkbind(ttChooseParameterization, "<Destroy>", function() {Try(tkgrab.release(ttChooseParameterization));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttChooseParameterization))

  return (ReturnVal)
}


GetCoef <- function(parameterizationTreeIndex,whichCoef="onlyOne")
{
  # Firstly, NumParameters in main fit:
  Try(NumParameters     <- get("NumParameters",    envir=limmaGUIenvironment))        

  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))    
  Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
  Try(ContrastsParameterizationNamesVec <- c() )
  Try(contrastNames <- list())
  Try (if (NumContrastParameterizations>0)
    Try(for (i in (1:NumContrastParameterizations))
    {
      Try(ContrastsParameterizationNamesVec[i] <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[i]]$contrastsParameterizationNameText)
      Try(contrastsMatrixInList <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[i]]$contrastsMatrixInList)
      Try(contrastsMatrix <- contrastsMatrixInList$contrasts)
      Try(contrastNames[[i]] <- colnames(contrastsMatrix))
    }))

  Try(ttGetCoef<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGetCoef))
  Try(tkgrab.set(ttGetCoef)  )
  Try(tkfocus(ttGetCoef))
  Try(if (whichCoef=="onlyOne")    tkwm.title(ttGetCoef,"Choose a parameter"))
  Try(if (whichCoef=="heat")       tkwm.title(ttGetCoef,"Choose a parameter"))  
  Try(if (whichCoef=="first")      tkwm.title(ttGetCoef,"Choose the first parameter"))
  Try(if (whichCoef=="second")     tkwm.title(ttGetCoef,"Choose the second parameter"))            
  Try(scr <- tkscrollbar(ttGetCoef, repeatinterval=5,
                       command=function(...)tkyview(tl,...)))
  Try(xscr <- tkscrollbar(ttGetCoef, repeatinterval=5,
                       command=function(...)tkxview(tl,...) ,orient="horizontal"))                       
  ## Safest to make sure scr exists before setting yscrollcommand
  Try(tl<-tklistbox(ttGetCoef,height=4,selectmode="single",xscrollcommand=function(...)tkset(xscr,...),yscrollcommand=function(...)tkset(scr,...),background="white",font=.limmaGUIglobals$limmaGUIfont2)   )
  Try(if (whichCoef=="heat")
      lbl2<-tklabel(ttGetCoef,text="Draw a heat diagram relative to which parameter/contrast?",font=.limmaGUIglobals$limmaGUIfont2))
  Try(if (whichCoef=="onlyOne")
      lbl2<-tklabel(ttGetCoef,text="Which comparison parameter is this for?",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGetCoef,text="       "),row=0,column=1,columnspan=1))
  Try(if (whichCoef=="first")
      lbl2<-tklabel(ttGetCoef,text="Please select the first parameter            ",font=.limmaGUIglobals$limmaGUIfont2)  )
  Try(if (whichCoef=="second")
      lbl2<-tklabel(ttGetCoef,text="Please select the second parameter            ",font=.limmaGUIglobals$limmaGUIfont2)        )
  Try(tkgrid(tklabel(ttGetCoef,text="       "),row=0,column=4,columnspan=1))
  Try(tkgrid(lbl2,row=1,column=2,columnspan=2,rowspan=1))
  Try(tkgrid.configure(lbl2,sticky="w"))
  Try(tkgrid(tklabel(ttGetCoef,text="         "),row=2,column=1))
  Try(tkgrid(tl,row=2,column=2,columnspan=2,rowspan=4,sticky="ew"))
  Try(tkgrid(scr,row=2,column=4,columnspan=1,rowspan=4,sticky="wns"))
  Try(tkgrid(xscr,row=6,column=2,columnspan=2,sticky="wne"))
  
  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))

  coefIndexList <- list()

  if (NumParameters>0)
    Try(for (i in (1:NumParameters))     
    {
      Try(tkinsert(tl,"end",ParameterNamesVec[i]))
      Try(coefIndexList[[i]] <- list(coefOrContrastIndex=i,ContrastParameterizationIndex=0))
    })
  Try(currentIndex <- NumParameters+1)
  Try(if (NumContrastParameterizations>0)
    Try(for (i in (1:NumContrastParameterizations))
    {      
      Try(for (j in (1:length(contrastNames[[i]])))
      {
        Try(tkinsert(tl,"end",paste(contrastNames[[i]][j]," [",ContrastsParameterizationNamesVec[i],"]",sep="")))
        Try(coefIndexList[[currentIndex]] <- list(coefOrContrastIndex=j,ContrastParameterizationIndex=i))        
        Try(currentIndex <- currentIndex + 1)
      })
     }))


  Try(tkselection.set(tl,0))

  Try(ReturnVal <- list(coefIndex=0,parameterIsFromMainFit=TRUE,coefIndexList=coefIndexList))
  onOK <- function()
  {
      Try(parameterNum <- as.numeric(tclvalue(tkcurselection(tl)))+1)
      Try(tkgrab.release(ttGetCoef));Try(tkdestroy(ttGetCoef));Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(if (parameterNum<=NumParameters)
        Try(ReturnVal <<- list(coefIndex=parameterNum,parameterIsFromMainFit=TRUE,coefIndexList=coefIndexList))
      else
        Try(ReturnVal <<- list(coefIndex=parameterNum,parameterIsFromMainFit=FALSE,coefIndexList=coefIndexList)))
  }
  onCancel <- function() {Try(tkgrab.release(ttGetCoef));Try(tkdestroy(ttGetCoef));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- list(coefIndex=0,parameterIsFromMainFit=TRUE,coefIndexList=coefIndexList))}
  Try(OK.but <-tkbutton(ttGetCoef,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttGetCoef,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGetCoef,text="    ")))
  Try(tkgrid(tklabel(ttGetCoef,text="    "),tklabel(ttGetCoef,text="    "),OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))  
  Try(tkbind(OK.but, "<Return>",onOK))
  Try(tkbind(tl, "<Return>",onOK))    
  Try(tkbind(Cancel.but, "<Return>",onCancel))      
  Try(tkgrid(tklabel(ttGetCoef,text="    ")))
  Try(tkfocus(ttGetCoef))
  Try(tkbind(ttGetCoef, "<Destroy>", function() {Try(tkgrab.release(ttGetCoef));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGetCoef))

  return (ReturnVal)
}

showTopTable <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(spacing   <- get("spacing",envir=limmaGUIenvironment))
  Try(NumSlides <- get("NumSlides",envir=limmaGUIenvironment))
  Try(gal <- get("gal",envir=limmaGUIenvironment))
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment)) # for NumSlides=1
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="Top Table",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }
  
  if (NumParameterizations==0 && NumSlides>1)
  {
    Try(tkmessageBox(title="Top Table",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  
  Try(if (NumSlides>1)
  {
    Try(parameterizationIndex <- ChooseParameterization())
    Try(if (parameterizationIndex==0)    return())
    Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

    Try(spacing <- GetReducedDuplicateSpacing(parameterizationTreeIndex))
  
    Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))

    if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
    {
      Try(tkmessageBox(title="Top Table",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please select \"Compute Linear Model Fit\" from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
    }
  })

  Try(if (NumSlides>1)
  {
    GetCoefReturnVal <- GetCoef(parameterizationTreeIndex)
    if (GetCoefReturnVal$coefIndex==0) return()
    Try(coef <- (GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]])$coefOrContrastIndex)
    Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
    Try(ContrastParameterizationIndex <- GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]]$ContrastParameterizationIndex)
    Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
      Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
    else
      Try(genelist <- get("genelist",limmaGUIenvironment)))   
    Try(Amatrix <- NULL)
    Try(if ("Amatrix" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
        Amatrix <- (ParameterizationList[[ParameterizationNameNode]])$Amatrix)
    if (GetCoefReturnVal$parameterIsFromMainFit)
    {
      Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
      Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)    
    }
    else
    {
      Try(fit <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$fit)
      Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)    
      Try(ParameterNamesVec <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts))
      Try(NumParameters <- length(ParameterNamesVec))    
    }
  })
  
  Try(ttToptableDialog<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttToptableDialog))
  Try(tkgrab.set(ttToptableDialog))
  Try(tkfocus(ttToptableDialog))
  Try(tkwm.title(ttToptableDialog,"Toptable Options"))
  Try(tkgrid(tklabel(ttToptableDialog,text="    ")))
    
  Try(frame1 <- tkframe(ttToptableDialog,relief="groove",borderwidth=2))
  Try(HowManyQuestion1 <- tklabel(frame1,text="Number of genes in table:",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(HowManyQuestion1))
  Try(tkgrid.configure(HowManyQuestion1,columnspan=2,sticky="w"))
  
  Try(numberOfGenesTcl <- tclVar("3"))
  Try(Ten.but      <- tkradiobutton(frame1,text="10",variable=numberOfGenesTcl,value="1",font=.limmaGUIglobals$limmaGUIfont2))
  Try(Thirty.but   <- tkradiobutton(frame1,text="30",variable=numberOfGenesTcl,value="2",font=.limmaGUIglobals$limmaGUIfont2))
  Try(Fifty.but    <- tkradiobutton(frame1,text="50",variable=numberOfGenesTcl,value="3",font=.limmaGUIglobals$limmaGUIfont2))  
  Try(Hundred.but  <- tkradiobutton(frame1,text="100",variable=numberOfGenesTcl,value="4",font=.limmaGUIglobals$limmaGUIfont2))    
  Try(AllGenes.but <- tkradiobutton(frame1,text="All genes",variable=numberOfGenesTcl,value="5",font=.limmaGUIglobals$limmaGUIfont2))      
  
  Try(tkgrid(Ten.but,sticky="w"))
  Try(tkgrid(Thirty.but,sticky="w"))
  Try(tkgrid(Fifty.but,sticky="w"))
  Try(tkgrid(Hundred.but,sticky="w"))  
  Try(tkgrid(AllGenes.but,sticky="w"))  
  Try(tkgrid.configure(HowManyQuestion1,Ten.but,Thirty.but,Fifty.but,Hundred.but,AllGenes.but,sticky="w"))

  Try(frame2 <- tkframe(ttToptableDialog,relief="groove",borderwidth=2))
  Try(sortByLabel <- tklabel(frame2,text="Sort by:",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(sortByLabel))
  Try(tkgrid.configure(sortByLabel,sticky="w"))
  Try(if (NumSlides>1)
    Try(sortByTcl <- tclVar("B"))
  else
    Try(sortByTcl <- tclVar("M")))
  Try(M.but <- tkradiobutton(frame2,text="M",variable=sortByTcl,value="M",font=.limmaGUIglobals$limmaGUIfont2))
  Try(A.but <- tkradiobutton(frame2,text="A",variable=sortByTcl,value="A",font=.limmaGUIglobals$limmaGUIfont2))
  Try(T.but <- tkradiobutton(frame2,text="t statistic",variable=sortByTcl,value="T",font=.limmaGUIglobals$limmaGUIfont2))  
  Try(P.but <- tkradiobutton(frame2,text="P value",variable=sortByTcl,value="P",font=.limmaGUIglobals$limmaGUIfont2))    
  Try(B.but <- tkradiobutton(frame2,text="B statistic",variable=sortByTcl,value="B",font=.limmaGUIglobals$limmaGUIfont2))      
  
  Try(tkgrid(M.but,sticky="w"))
  Try(tkgrid(A.but,sticky="w"))
  Try(tkgrid(T.but,sticky="w"))
  Try(tkgrid(P.but,sticky="w"))  
  Try(tkgrid(B.but,sticky="w"))
  
  Try(if (NumSlides==1)
  {
    Try(tkconfigure(T.but,state="disabled"))
    Try(tkconfigure(P.but,state="disabled"))    
    Try(tkconfigure(B.but,state="disabled"))        
  })
  
  Try(tkgrid.configure(sortByLabel,M.but,A.but,T.but,P.but,B.but,sticky="w"))

  Try(frame3 <- tkframe(ttToptableDialog,relief="groove",borderwidth=2))
  Try(adjustMethodLabel <- tklabel(frame3,text="Adjust method:",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(adjustMethodLabel))
  Try(tkgrid.configure(adjustMethodLabel,sticky="w"))  
  Try(if (NumSlides>1)
    Try(adjustMethodTcl <- tclVar("holm"))
  else
    Try(adjustMethodTcl <- tclVar("none")))
  Try(bonferroni.but <- tkradiobutton(frame3,text="Bonferroni",variable=adjustMethodTcl,value="bonferroni",font=.limmaGUIglobals$limmaGUIfont2))
  Try(holm.but <- tkradiobutton(frame3,text="Holm",variable=adjustMethodTcl,value="holm",font=.limmaGUIglobals$limmaGUIfont2))
  Try(hochberg.but <- tkradiobutton(frame3,text="Hochberg",variable=adjustMethodTcl,value="hochberg",font=.limmaGUIglobals$limmaGUIfont2))  
  Try(hommel.but <- tkradiobutton(frame3,text="Hommel",variable=adjustMethodTcl,value="hommel",font=.limmaGUIglobals$limmaGUIfont2))    
  Try(fdr.but <- tkradiobutton(frame3,text="FDR",variable=adjustMethodTcl,value="fdr",font=.limmaGUIglobals$limmaGUIfont2))      
  Try(none.but <- tkradiobutton(frame3,text="None",variable=adjustMethodTcl,value="none",font=.limmaGUIglobals$limmaGUIfont2))      

  Try(tkgrid(bonferroni.but,sticky="w"))
  Try(tkgrid(holm.but,sticky="w"))
  Try(tkgrid(hochberg.but,sticky="w"))
  Try(tkgrid(hommel.but,sticky="w"))  
  Try(tkgrid(fdr.but,sticky="w"))
  Try(tkgrid(none.but,sticky="w"))  
  
  Try(if (NumSlides==1)
  {
		Try(tkconfigure(bonferroni.but,state="disabled"))
		Try(tkconfigure(holm.but,state="disabled"))
		Try(tkconfigure(hochberg.but,state="disabled"))
		Try(tkconfigure(hommel.but,state="disabled"))  
		Try(tkconfigure(fdr.but,state="disabled"))
		Try(tkconfigure(none.but,state="disabled"))    
  })
  
  Try(if (NumSlides>1)
    Try(totalGenes <- nrow(genelist))
  else
    Try(totalGenes <- nrow(gal)))
  Try(Abort <- 1)
  Try(numberOfGenes <- 0)
  Try(sortBy <- "B")
  Try(adjustMethod <- "holm")
  Try(onOK <- function()
  {     
      Try(NumGenesChoice <- as.numeric(tclvalue(numberOfGenesTcl)))
      Try(tkgrab.release(ttToptableDialog))
      Try(tkdestroy(ttToptableDialog))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(NumbersOfGenes <- c(10,30,50,100,totalGenes))
      Try(numberOfGenes <<- NumbersOfGenes[NumGenesChoice]      )
      Try(sortBy <<- tclvalue(sortByTcl))
      Try(adjustMethod <<- tclvalue(adjustMethodTcl))
      Try(Abort <<- 0)
  })

  Try(frame4 <- tkframe(ttToptableDialog,borderwidth=2))
  Try(onCancel <- function() {Try(tkgrab.release(ttToptableDialog));Try(tkdestroy(ttToptableDialog));Try(tkfocus(.limmaGUIglobals$ttMain));Abort <<- 1})
  Try(OK.but <-tkbutton(frame4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(frame4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  
  Try(tkgrid(tklabel(frame4,text="    "),OK.but,Cancel.but,tklabel(frame4,text="    ")))

  Try(tkgrid(tklabel(ttToptableDialog,text="    "),frame1,frame2,tklabel(ttToptableDialog,text="  ")))
  Try(tkgrid(tklabel(ttToptableDialog,text="    ")))
  Try(tkgrid(tklabel(ttToptableDialog,text="    "),frame3,frame4,tklabel(ttToptableDialog,text="  ")))
  Try(tkgrid(tklabel(ttToptableDialog,text="    ")))  
  Try(tkgrid.configure(frame1,frame3,sticky="w"))
#  Try(tkgrid.configure(frame4,sticky="s"))
  
  Try(tkfocus(ttToptableDialog))
  Try(tkbind(ttToptableDialog, "<Destroy>", function() {Try(tkgrab.release(ttToptableDialog));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttToptableDialog))
    
  Try(if (Abort==1) 
     return())
  
  Try(if (numberOfGenes==totalGenes) 
  {
      tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")
      Try(tkfocus(.limmaGUIglobals$ttMain))
  })

  Try(options(digits=3))
  
  Try(if (NumSlides==1)
  {
    Try(NormalizeNow())
    Try(MA <- get("MA",envir=limmaGUIenvironment))
    Try(Amatrix <- MA$A)
  })
  
  
  Try(if (is.null(Amatrix))
  {
    Try(MA <- get("MA",envir=limmaGUIenvironment))  
    Try(A <- MA$A)
    Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
    Try(numSpotTypes <- nrow(SpotTypes))
    Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
    Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
    Omit <- ""
    count <- 0
    Try(for (i in (1:numSpotTypes))
    {
      if (SpotTypesForLinearModel[i]==TRUE)
        next()
      count <- count + 1
      if (count>1)
        Omit <-paste(Omit,"|")
      else
        Omit <- "(" 
      Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
    })  
    Try(if (nchar(Omit)>0)
    {
      Try(Omit <- paste(Omit,")"))  
      Try(Omit <- eval(parse(text=Omit)))
      Try(A <- A[!Omit,])
    })

    Try(A <- unwrapdups(A,ndups=ndups,spacing=spacing))
  }
  else
    if (NumSlides>1)
      Try(A <- unwrapdups(Amatrix,ndups=ndups,spacing=spacing)))
  
  Try(if (NumSlides>1)
    Try(table1 <- toptable(coef=coef,number=numberOfGenes,genelist=genelist,A=A,fit=fit,eb=eb,adjust.method=adjustMethod,sort.by=sortBy))
  else
  {
    Try(GenesAndLogRatios <- data.frame(gal,M=as.vector(MA$M),A=as.vector(MA$A)))
    Try(if (sortBy=="M")
      Try(ord <- order(abs(MA$M),decreasing=TRUE)))
    Try(if (sortBy=="A")
      Try(ord <- order(abs(MA$A),decreasing=TRUE)))      
    Try(table1 <- GenesAndLogRatios[ord,])
    Try(table1 <- table1[1:numberOfGenes,])
  })
  
  Try(nrows <- nrow(table1))
  Try(ncols <- ncol(table1))  
  
  if (nrows <=100)
  {
    Try(ttToptableTable <- tktoplevel(.limmaGUIglobals$ttMain))
    Try(if (NumSlides>1)
      Try(tkwm.title(ttToptableTable,paste("Top",numberOfGenes,"Candidate Genes for Differential Expression for",ParameterNamesVec[coef],".",sep=" ")))
    else
      Try(tkwm.title(ttToptableTable,paste("Top",numberOfGenes,"Candidate Genes for Differential Expression for Slide",SlideNamesVec[1],".",sep=" "))))
    Try(toptableTable <- tkwidget(ttToptableTable,"table",
           xscrollcommand=function(...) tkset(xscr,...),yscrollcommand=function(...) tkset(yscr,...),
           rows=nrows+1,cols=ncols,titlerows=1,
           width=ncols,selectmode="extended",colwidth="13",background="white",
           rowseparator="\"\n\"",colseparator="\"\t\"",resizeborders="col",multiline="0",state="disabled",
           font=.limmaGUIglobals$limmaGUIfontTopTable))
    Try(xscr <-tkscrollbar(ttToptableTable,orient="horizontal", command=function(...)tkxview(toptableTable,...)))
    Try(yscr <- tkscrollbar(ttToptableTable,command=function(...)tkyview(toptableTable,...)))
    Try(tclArrayVar1 <- tclArrayVar())
    Try(tclArrayName <- ls(tclArrayVar1$env))
    Try(tkcmd("set",paste(tclArrayName,"0,0",sep=""),""))
    Try(for (j in (1:ncols))
        Try(tkcmd("set",paste(tclArrayName,"(",0,",",j-1,")",sep=""),colnames(table1)[j]))  )
    Try(for (i in (1:nrows))
      for (j in (1:ncols))
      {
        Try(if (is.numeric(table1[i,j]))
          item <- format(table1[i,j],digits=4)
        else
          item <- table1[i,j])
        Try(tkcmd("set",paste(tclArrayName,"(",i,",",j-1,")",sep=""),paste(item)))        
      })
    Try(tkgrid(toptableTable,yscr))
    Try(tkgrid.configure(toptableTable,sticky="news"))
    Try(tkgrid.configure(yscr,sticky="nsw"))
    Try(tkgrid(xscr,sticky="new"))
    Try(tkconfigure(toptableTable,bg="white",variable=tclArrayName))
    Try(for (i in (1:ncols))
    {
      if (tolower(colnames(table1)[i]) %in% c("block","row","column","gridrow","gridcolumn","gridcol","grid.row","grid.col","grid.column"))
      {
        Try(if (.limmaGUIglobals$limmaGUIpresentation==FALSE)
          Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),paste(max(4,nchar(colnames(table1)[i])+2))))
        else
          Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),paste(max(4,nchar(colnames(table1)[i]))))))        
        next()
      }
      if (colnames(table1)[i] %in% c("M","A","t","B"))
      {
        Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),"6"))
        next()
      }
      if (colnames(table1)[i] %in% c("P.Value"))
      {
        Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),"8"))
        next()
      }     
      if(tolower(colnames(table1)[i]) == "name")
      {
        Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),paste(min(30,max(6,max(nchar(table1[,i]))+2)))))
        next()
      }

      if(tolower(colnames(table1)[i]) == "id")
      {
        Try(if (.limmaGUIglobals$limmaGUIpresentation==FALSE)
          Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),paste(max(4,max(nchar(table1[,i]))+2))))
        else
          Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),paste(max(4,max(nchar(table1[,i])))))))
        next()
      }

      Try(tkcmd(.Tk.ID(toptableTable),"width",paste(i-1),paste(max(4,max(nchar(table1[,i]))+2))))
    })
	  Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(toptableTable),"<<Copy>>"))))    
  }
  else
  {
    Try(tkmessageBox(title="Large Toptable",message="Toptable is too big to display in a table widget, so it will be displayed in a text window instead.  You can save it as a tab-delimited text file and then import it into a spreadsheet program.",icon="info",type="ok"))
    Try(tempfile1 <- tempfile())
    Try(write.table(table1,file=tempfile1,quote=FALSE,col.names=NA,sep="\t"))
    Try(ttToptableTable <- tktoplevel(.limmaGUIglobals$ttMain))
    Try(if (NumSlides>1)
      Try(tkwm.title(ttToptableTable,paste("Top",numberOfGenes,"Candidate Genes for Differential Expression for",ParameterNamesVec[coef],".",sep=" ")))
    else
      Try(tkwm.title(ttToptableTable,paste("Top",numberOfGenes,"Candidate Genes for Differential Expression for Slide",SlideNamesVec[1],".",sep=" "))))
    Try(xscr <-tkscrollbar(ttToptableTable, repeatinterval=5,orient="horizontal",command=function(...)tkxview(txt,...)))
    Try(scr <- tkscrollbar(ttToptableTable, repeatinterval=5,command=function(...)tkyview(txt,...)))
    Try(txt <- tktext(ttToptableTable, bg="white", font="courier",xscrollcommand=function(...)tkset(xscr,...),yscrollcommand=function(...)tkset(scr,...),wrap="none",width=100))

    Try(copyText2 <- function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Copy>>"))))

    Try(editPopupMenu2 <- tkmenu(txt, tearoff=FALSE))
    Try(tkadd(editPopupMenu2, "command", label="Copy <Ctrl-C>",command=copyText2))

    RightClick2 <- function(x,y) # x and y are the mouse coordinates
    {
     rootx <- as.integer(tkwinfo("rootx",txt))
     rooty <- as.integer(tkwinfo("rooty",txt))
     xTxt <- as.integer(x)+rootx
     yTxt <- as.integer(y)+rooty
     .Tcl(paste("tk_popup",.Tcl.args(editPopupMenu2,xTxt,yTxt)))
    }
    Try(tkbind(txt, "<Button-3>",RightClick2))

    Try(tkpack(scr, side="right", fill="y"))
    Try(tkpack(xscr, side="bottom", fill="x"))
    Try(tkpack(txt, side="left", fill="both", expand="yes"))

    Try(chn <- tclvalue(tkcmd("open", tempfile1)))
    Try(tkinsert(txt, "end", tclvalue(tkcmd("read", chn))))
    Try(tkcmd("close", chn))
    Try(tkconfigure(txt, state="disabled"))
    Try(tkmark.set(txt,"insert","0.0"))
    Try(tkfocus(txt))

    Try(if (numberOfGenes==totalGenes)
        tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
	  Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Copy>>"))))        
  }
  
  
  SaveTopTable <- function()
  {
    Try(if (NumSlides>1)
      Try(TopTableFile <- tclvalue(tkgetSaveFile(initialfile=paste("toptable", coef,".txt",sep=""))))
    else
      Try(TopTableFile <- tclvalue(tkgetSaveFile(initialfile=paste("toptable1.txt",sep="")))))
    Try(if (!nchar(TopTableFile))
      return())
    Try(write.table(table1,file=TopTableFile,quote=FALSE,col.names=NA,sep="\t"))
  } 

	topMenu2 <- tkmenu(ttToptableTable)
	tkconfigure(ttToptableTable, menu=topMenu2)
	fileMenu2 <- tkmenu(topMenu2, tearoff=FALSE)
	tkadd(fileMenu2, "command", label="Save As",command=SaveTopTable) 
	tkadd(fileMenu2, "command", label="Close",command=function() tkdestroy(ttToptableTable))
	tkadd(topMenu2, "cascade", label="File",menu=fileMenu2) 
	editMenu2 <- tkmenu(topMenu2, tearoff=FALSE)
	tkadd(editMenu2, "command", label="Copy <Ctrl-C>",command=copyFcn)
	tkadd(topMenu2, "cascade", label="Edit",menu=editMenu2)

	Try(tkfocus(ttToptableTable))
  
}

GetSpotTypesForLinearModel <- function()
{
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))

  if (numSpotTypes==0)
  {
      tkmessageBox(message="Error: No spot types have been registered.",title="Spot Types For Linear Model",type="ok",icon="error");
      return()
  }

  ttGetSpotTypesForLinearModel<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetSpotTypesForLinearModel)
  tkgrab.set(ttGetSpotTypesForLinearModel)
  tkfocus(ttGetSpotTypesForLinearModel)
  tkwm.title(ttGetSpotTypesForLinearModel,"Spot Types to be Included in the Linear Model Fit")   
  
  Try(if (numSpotTypes>10)
  {
    Try(sw <- tkwidget(ttGetSpotTypesForLinearModel,"ScrolledWindow",relief="sunken",borderwidth=2))
    Try(sf <- tkwidget(sw,"ScrollableFrame"))
    Try(tkcmd(sw,"setwidget",sf))
    Try(subfID <- tclvalue(tkcmd(sf,"getframe")))
  }
  else
  {
    Try(sw <- tkframe(ttGetSpotTypesForLinearModel,borderwidth=2))
    Try(subfID <- .Tk.ID(sw))
  })
  Try(tkgrid(tklabel(ttGetSpotTypesForLinearModel,text="    "),tklabel(ttGetSpotTypesForLinearModel,text="    ")))

  IncludeSpotTypeTcl <- list()
  for (i in (1:numSpotTypes))
      Try(IncludeSpotTypeTcl[[i]] <- tclVar("1"))  # Initially, all checkboxes are checked.

  SpotTypeCheckbox <- list()
  for (i in (1:numSpotTypes))
      Try(SpotTypeCheckbox[[i]] <- tkcmd("checkbutton",paste(subfID,".cb",i,sep=""),variable=IncludeSpotTypeTcl[[i]]))
       
  Try(lbl2 <- tklabel(ttGetSpotTypesForLinearModel,text="Please Choose Spot Types to be Included in the Linear Model Fit",font=.limmaGUIglobals$limmaGUIfont2))
  tkgrid(lbl2)
  Try(tkgrid.configure(lbl2,columnspan=2,sticky="w"))
  tkgrid(tklabel(ttGetSpotTypesForLinearModel,text="    "))
  
  for (i in (1:numSpotTypes))
  {
      Try(blankLabel <- tkcmd("label",paste(subfID,".blank",i,sep=""),text="    ",font=.limmaGUIglobals$limmaGUIfont2))
      Try(currentLabel <- tkcmd("label",paste(subfID,".lab",i,sep=""),text=SpotTypes[i,"SpotType"],font=.limmaGUIglobals$limmaGUIfont2))
      Try(tkgrid(blankLabel,SpotTypeCheckbox[[i]],currentLabel))
      Try(tkgrid.configure(SpotTypeCheckbox[[i]],sticky="e"))
      Try(tkgrid.configure(currentLabel,sticky="w"))
  }

  Try(tkgrid(sw,columnspan=2,sticky="nsew"))
  
  tkgrid(tklabel(ttGetSpotTypesForLinearModel,text="    "))
  tkgrid(tklabel(ttGetSpotTypesForLinearModel,text="    "))
  ReturnVal <- c()
  onOK <- function()
  {
      ReturnVal <- rep(TRUE,numSpotTypes)
      for (i in (1:numSpotTypes))
        if (tclvalue(IncludeSpotTypeTcl[[i]])!="1")
            ReturnVal[i] <- FALSE
      Try(tkgrab.release(ttGetSpotTypesForLinearModel));Try(tkdestroy(ttGetSpotTypesForLinearModel));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- ReturnVal
  }
  onCancel <- function() {Try(tkgrab.release(ttGetSpotTypesForLinearModel));Try(tkdestroy(ttGetSpotTypesForLinearModel));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- c()}      
  OK.but <-tkbutton(ttGetSpotTypesForLinearModel,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetSpotTypesForLinearModel,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but,tklabel(ttGetSpotTypesForLinearModel,text="    "),tklabel(ttGetSpotTypesForLinearModel,text="    "))
  tkgrid.configure(OK.but,    sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  tkgrid(tklabel(ttGetSpotTypesForLinearModel,text="    "),tklabel(ttGetSpotTypesForLinearModel,text="    "),tklabel(ttGetSpotTypesForLinearModel,text="    "),
       tklabel(ttGetSpotTypesForLinearModel,text="    "),tklabel(ttGetSpotTypesForLinearModel,text="    "))
  Try(tkfocus(ttGetSpotTypesForLinearModel))
  Try(tkbind(ttGetSpotTypesForLinearModel, "<Destroy>", function() {Try(tkgrab.release(ttGetSpotTypesForLinearModel));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGetSpotTypesForLinearModel))

  return (ReturnVal)
}



GetSlideNum <- function()
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(if (min(nchar(gsub("[^0-9]","",SlideNamesVec))==nchar(SlideNamesVec))==TRUE)
    SlideNamesVec <- paste("Slide",SlideNamesVec))  
  Try(NumSlides <- get("NumSlides",envir=limmaGUIenvironment))
  ttGetSlideNum<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetSlideNum)
  tkgrab.set(ttGetSlideNum)
  tkfocus(ttGetSlideNum)
  tkwm.title(ttGetSlideNum,"Please Specify Slide")
  scr <- tkscrollbar(ttGetSlideNum, repeatinterval=5,
                       command=function(...)tkyview(tl,...))
  ## Safest to make sure scr exists before setting yscrollcommand
  tl<-tklistbox(ttGetSlideNum,height=4,selectmode="browse",yscrollcommand=function(...)tkset(scr,...),background="white",font=.limmaGUIglobals$limmaGUIfont2) 
  tkgrid(tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "),
       tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "))
  lbl2<-tklabel(ttGetSlideNum,text="Choose a slide",font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttGetSlideNum,text="    "),lbl2,tklabel(ttGetSlideNum,text="    "),
     tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "))
  tkgrid.configure(lbl2,sticky="w")
  tkgrid(tklabel(ttGetSlideNum,text="    "),row=2,column=0)
  tkgrid(tl,row=2,column=1,columnspan=2,rowspan=4,sticky="ew")
  tkgrid(scr,row=2,column=3,rowspan=4,sticky="wns")
  tkgrid(tklabel(ttGetSlideNum,text="    "),row=2,column=4)
  for (i in (1:NumSlides))
    tkinsert(tl,"end",SlideNamesVec[i])
  tkselection.set(tl,0)

  tkgrid(tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "),
     tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "))
  ReturnVal <- 0
  onOK <- function()
  {
      slidenum <- as.numeric(tclvalue(tkcurselection(tl)))+1
      Try(tkgrab.release(ttGetSlideNum));Try(tkdestroy(ttGetSlideNum));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- slidenum
  }
  onCancel <- function() {Try(tkgrab.release(ttGetSlideNum));Try(tkdestroy(ttGetSlideNum));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- 0}      
  OK.but <-tkbutton(ttGetSlideNum,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetSlideNum,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttGetSlideNum,text="    "),OK.but,Cancel.but,tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "))
  tkgrid.configure(OK.but,Cancel.but,sticky="w")
  tkgrid(tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "),
       tklabel(ttGetSlideNum,text="    "),tklabel(ttGetSlideNum,text="    "))
  Try(tkbind(OK.but, "<Return>",onOK))
  Try(tkbind(tl, "<Return>",onOK))    
  Try(tkbind(Cancel.but, "<Return>",onCancel))      
  Try(tkfocus(tl))
  Try(tkbind(ttGetSlideNum, "<Destroy>", function() {Try(tkgrab.release(ttGetSlideNum));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGetSlideNum))

  return (ReturnVal)
}


GetDEcutoff <- function()
{
  ttGetDEcutoff<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetDEcutoff)
  tkgrab.set(ttGetDEcutoff)  
  Try(tkwm.title(ttGetDEcutoff,"Cutoff for Differentially Expressed Genes"))
  Try(cutoffStatisticTcl <- tclVar("abs(t)"))
  Try(tkframe1 <- tkframe(ttGetDEcutoff,borderwidth=2))
  Try(tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2))
  Try(tkframe4<-tkframe(tkframe1,borderwidth=2))

  Try(tkgrid(tklabel(tkframe1,text="    ")))

  Try(tkgrid(tklabel(tkframe2,text="Choose a cutoff for differentially expressed genes.",font=.limmaGUIglobals$limmaGUIfont2),rowspan=1,columnspan=2,sticky="w"))

  Try(tStatistic.but <- tkradiobutton(tkframe2,text="Abs(t)",variable=cutoffStatisticTcl,value="abs(t)",font=.limmaGUIglobals$limmaGUIfont2))
  Try(BStatistic.but <- tkradiobutton(tkframe2,text="B",variable=cutoffStatisticTcl,value="B",font=.limmaGUIglobals$limmaGUIfont2))

  Try(tkgrid(tStatistic.but))
  Try(tkgrid(BStatistic.but))
  Try(tkgrid.configure(tStatistic.but,BStatistic.but,sticky="w"))
  Try(tkgrid(tklabel(tkframe2,text="    ")))
  Try(cutoffValueTcl <- tclVar("0"))
  Try(entry.cutoffValue<-tkentry(tkframe2,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=cutoffValueTcl,bg="white"))
  Try(tkgrid(tklabel(tkframe2,text="Cutoff value ",font=.limmaGUIglobals$limmaGUIfont2),entry.cutoffValue,sticky="w"))
  
  Try(tkgrid(tkframe2))
  Try(ReturnVal <- list())
  onOK <- function()
  {
      Try(cutoffStatisticVal <- as.character(tclvalue(cutoffStatisticTcl)))
      Try(cutoffValue <- as.numeric(tclvalue(cutoffValueTcl)))
      Try(tkgrab.release(ttGetDEcutoff));Try(tkdestroy(ttGetDEcutoff));Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(ReturnVal <<- list(cutoffStatistic=cutoffStatisticVal,cutoff=cutoffValue))
  }
  onCancel <- function(){tkgrab.release(ttGetDEcutoff);tkdestroy(ttGetDEcutoff);tkfocus(.limmaGUIglobals$ttMain);ReturnVal <<- list()} 
  Try(OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframe4,text="                    ")))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="e"))
  Try(tkgrid(tklabel(tkframe4,text="       ")))
  Try(tkgrid(tkframe4))
  Try(tkgrid(tkframe1))
  Try(tkfocus(ttGetDEcutoff))
  Try(tkbind(ttGetDEcutoff, "<Destroy>", function(){tkgrab.release(ttGetDEcutoff);tkfocus(.limmaGUIglobals$ttMain);} )) 
  Try(tkwait.window(ttGetDEcutoff))

  return (ReturnVal)
}

UpdateSpotTypesStatus <- function()
{
  Try(SpotTypes <- get("SpotTypes", envir=limmaGUIenvironment))
  Try(gal <- get("gal", envir=limmaGUIenvironment))
  Try(Status <- controlStatus(SpotTypes,gal))
  Try(assign("SpotTypeStatus", Status, limmaGUIenvironment))
}


ChooseEbayesStatistic <- function()
{
  ttChooseEbayesStatistic<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttChooseEbayesStatistic)
  tkgrab.set(ttChooseEbayesStatistic)
  tkfocus(ttChooseEbayesStatistic)
  tkwm.title(ttChooseEbayesStatistic,"Empirical Bayes Statistic")   
  Try(tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),tklabel(ttChooseEbayesStatistic,text="    ")))

  Try(EbayesStatisticTcl <- tclVar("t"))

  Try(tStatisticRadioButton <- tkradiobutton(ttChooseEbayesStatistic,variable=EbayesStatisticTcl,value="t"))
  Try(BStatisticRadioButton <- tkradiobutton(ttChooseEbayesStatistic,variable=EbayesStatisticTcl,value="lods"))  
  Try(PValueRadioButton     <- tkradiobutton(ttChooseEbayesStatistic,variable=EbayesStatisticTcl,value="p.value"))    
       
  Try(lbl2 <- tklabel(ttChooseEbayesStatistic,text="Please Choose an Empirical Bayes Statistic",font=.limmaGUIglobals$limmaGUIfont2))
  tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),lbl2)
  Try(tkgrid.configure(lbl2,columnspan=2,sticky="w"))
  tkgrid(tklabel(ttChooseEbayesStatistic,text="    "))
  
  Try(currentLabel <- tklabel(ttChooseEbayesStatistic,text="t Statistic",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),tStatisticRadioButton,currentLabel))
  Try(tkgrid.configure(tStatisticRadioButton,sticky="e"))
  Try(tkgrid.configure(currentLabel,sticky="w"))
  Try(currentLabel <- tklabel(ttChooseEbayesStatistic,text="B Statistic",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),BStatisticRadioButton,currentLabel))
  Try(tkgrid.configure(BStatisticRadioButton,sticky="e"))
  Try(tkgrid.configure(currentLabel,sticky="w"))
  Try(currentLabel <- tklabel(ttChooseEbayesStatistic,text="P Value",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),PValueRadioButton,currentLabel))
  Try(tkgrid.configure(PValueRadioButton,sticky="e"))
  Try(tkgrid.configure(currentLabel,sticky="w"))
  
  tkgrid(tklabel(ttChooseEbayesStatistic,text="    "))
  tkgrid(tklabel(ttChooseEbayesStatistic,text="    "))
  ReturnVal <- ""
  onOK <- function()
  {      
      Try(ReturnVal <- tclvalue(EbayesStatisticTcl))
      Try(tkgrab.release(ttChooseEbayesStatistic));Try(tkdestroy(ttChooseEbayesStatistic));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- ReturnVal
  }
  onCancel <- function() {Try(tkgrab.release(ttChooseEbayesStatistic));Try(tkdestroy(ttChooseEbayesStatistic));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- ""}      
  OK.but <-tkbutton(ttChooseEbayesStatistic,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttChooseEbayesStatistic,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),OK.but,Cancel.but,tklabel(ttChooseEbayesStatistic,text="    "),tklabel(ttChooseEbayesStatistic,text="    "))
  tkgrid.configure(OK.but,    sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  tkgrid(tklabel(ttChooseEbayesStatistic,text="    "),tklabel(ttChooseEbayesStatistic,text="    "),tklabel(ttChooseEbayesStatistic,text="    "),
       tklabel(ttChooseEbayesStatistic,text="    "),tklabel(ttChooseEbayesStatistic,text="    "))
  Try(tkfocus(ttChooseEbayesStatistic))
  Try(tkbind(ttChooseEbayesStatistic, "<Destroy>", function() {Try(tkgrab.release(ttChooseEbayesStatistic));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttChooseEbayesStatistic))

  return (ReturnVal)

}

ChooseSpotType <- function(parameterizationTreeIndex)
{
  # This function is designed to be used for selecting a spot type for which t Statistics box plots will be shown.
  # This means that the only available spot types should be those included in the linear model.
  
  
  Try(SpotTypesIncludedNamesVec <- GetSpotTypesIncludedNames(parameterizationTreeIndex)) 
  Try(numSpotTypes <- length(SpotTypesIncludedNamesVec))

  if (numSpotTypes==0)
  {
      tkmessageBox(message="Error: No spot types have been registered.",title="Choose Spot Type",type="ok",icon="error");
      return()
  }

  ttChooseSpotType<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttChooseSpotType)
  tkgrab.set(ttChooseSpotType)
  tkfocus(ttChooseSpotType)
  tkwm.title(ttChooseSpotType,"Spot Type for Empirical Bayes Statistics Box Plots")   
  Try(tkgrid(tklabel(ttChooseSpotType,text="    "),tklabel(ttChooseSpotType,text="    ")))

  Try(WhichSpotTypeTcl <- tclVar("1"))

  Try(if (numSpotTypes>10)
  {
    Try(sw <- tkwidget(ttChooseSpotType,"ScrolledWindow",relief="sunken",borderwidth=2))
    Try(sf <- tkwidget(sw,"ScrollableFrame"))
    Try(tkcmd(sw,"setwidget",sf))
    Try(subfID <- tclvalue(tkcmd(sf,"getframe")))
  }
  else
  {
    Try(sw <- tkframe(ttChooseSpotType,borderwidth=2))
    Try(subfID <- .Tk.ID(sw))
  })

  SpotTypeRadioButton <- list()
  for (i in (1:numSpotTypes))
      Try(SpotTypeRadioButton[[i]] <- tkcmd("radiobutton",paste(subfID,".rb",i,sep=""),variable=WhichSpotTypeTcl,value=paste(i)))
       
  Try(lbl2 <- tklabel(ttChooseSpotType,text="Please Choose a Spot Type for Empirical Bayes Statistics Box Plots",font=.limmaGUIglobals$limmaGUIfont2))
  tkgrid(tklabel(ttChooseSpotType,text="    "),lbl2)
  Try(tkgrid.configure(lbl2,columnspan=2,sticky="w"))
  tkgrid(tklabel(ttChooseSpotType,text="    "))
  
  for (i in (1:numSpotTypes))
  {
      Try(currentLabel <- tkcmd("label",paste(subfID,".lab1_",i,sep=""),text=SpotTypesIncludedNamesVec[i],font=.limmaGUIglobals$limmaGUIfont2))
      Try(tkgrid(tkcmd("label",paste(subfID,".lab2_",i,sep=""),text="    "),SpotTypeRadioButton[[i]],currentLabel))
      Try(tkgrid.configure(SpotTypeRadioButton[[i]],sticky="e"))
      Try(tkgrid.configure(currentLabel,sticky="w"))
  }
  
  Try(tkgrid(sw,columnspan=2,sticky="nsew"))  
  
  tkgrid(tklabel(ttChooseSpotType,text="    "))
  tkgrid(tklabel(ttChooseSpotType,text="    "))
  
  Try(OKCancelFrame <- tkframe(ttChooseSpotType,borderwidth=2))
  
  ReturnVal <- ""
  onOK <- function()
  {
      Try(radioButtonSelected <- as.integer(tclvalue(WhichSpotTypeTcl)))      
      Try(ReturnVal <- SpotTypesIncludedNamesVec[radioButtonSelected])
      Try(tkgrab.release(ttChooseSpotType));Try(tkdestroy(ttChooseSpotType));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- ReturnVal
  }
  onCancel <- function() {Try(tkgrab.release(ttChooseSpotType));Try(tkdestroy(ttChooseSpotType));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- ""}      
  OK.but <-tkbutton(OKCancelFrame,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(OKCancelFrame,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but)
  tkgrid.configure(OK.but,    sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  tkgrid(OKCancelFrame,columnspan=2)  
  tkgrid(tklabel(ttChooseSpotType,text="    "),tklabel(ttChooseSpotType,text="    "))
  Try(tkfocus(ttChooseSpotType))
  Try(tkbind(ttChooseSpotType, "<Destroy>", function() {Try(tkgrab.release(ttChooseSpotType));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttChooseSpotType))

  return (ReturnVal)

}

GetWtAreaParams <- function()
{
    ttWeightingwtArea <- tktoplevel(.limmaGUIglobals$ttMain)
    tkwm.deiconify(ttWeightingwtArea)
    tkgrab.set(ttWeightingwtArea)
    tkfocus(ttWeightingwtArea)
    tkwm.title(ttWeightingwtArea,"Good Spot Size")
    tkframe1 <- tkframe(ttWeightingwtArea)
    tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2)
    tkframe4 <- tkframe(tkframe1)
    tkgrid(tklabel(tkframe1,text="    "))
    tkgrid(tklabel(tkframe1,text="Please enter the area range for good spots",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
    tkgrid(tklabel(tkframe1,text="    "))
    tkgrid(tklabel(tkframe2,text="Area Range in Pixels",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
    AreaLowerLimitTcl <- tclVar(paste(160))
    AreaUpperLimitTcl <- tclVar(paste(170))
    tkgrid(tklabel(tkframe2,text="    "))
    entry.AreaLowerLimit <-tkentry(tkframe2,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=AreaLowerLimitTcl,bg="white")
    entry.AreaUpperLimit <-tkentry(tkframe2,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=AreaUpperLimitTcl,bg="white")
    tkgrid(tklabel(tkframe2,text="Lower area limit in pixels",font=.limmaGUIglobals$limmaGUIfont2),entry.AreaLowerLimit,sticky="w")
    tkgrid(tklabel(tkframe2,text="Upper area limit in pixels",font=.limmaGUIglobals$limmaGUIfont2),entry.AreaUpperLimit,sticky="w")
    tkgrid(tkframe2)
    tkgrid(tklabel(tkframe1,text="    "))
    ReturnVal <- 0
    AreaLowerLimitVal <- 0
    AreaUpperLimitVal <- 0
    onOK <- function()
    {
        Try(AreaLowerLimitVal <<- as.integer(tclvalue(AreaLowerLimitTcl)))
        Try(AreaUpperLimitVal <<- as.integer(tclvalue(AreaUpperLimitTcl)))
        Try(assign("AreaLowerLimit",AreaLowerLimitVal,limmaGUIenvironment))
        Try(assign("AreaUpperLimit",AreaUpperLimitVal,limmaGUIenvironment))
        Try(assign("WeightingType",paste("wtarea, Ideal=(",AreaLowerLimitVal,",",AreaUpperLimitVal,")",sep=""),limmaGUIenvironment))        
        Try(tkgrab.release(ttWeightingwtArea));Try(tkdestroy(ttWeightingwtArea));Try(tkfocus(.limmaGUIglobals$ttMain))
        ReturnVal <<- 1
    }
    onCancel <- function() {Try(tkgrab.release(ttWeightingwtArea));Try(tkdestroy(ttWeightingwtArea));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal<<-0}   
    Try(OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
    Try(Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
    Try(Help.but <- tkbutton(tkframe4,text=" Help ",command=function()help(wtarea,htmlhelp=TRUE),font=.limmaGUIglobals$limmaGUIfont2))
    Try(tkgrid(OK.but,Cancel.but,Help.but))
    Try(tkgrid.configure(Help.but,sticky="e"))
    tkgrid(tklabel(tkframe4,text="    "))
    tkgrid(tkframe4)
    tkgrid(tkframe1)
    Try(tkfocus(ttWeightingwtArea))
    Try(tkbind(ttWeightingwtArea, "<Destroy>", function() {Try(tkgrab.release(ttWeightingwtArea));Try(tkfocus(.limmaGUIglobals$ttMain));}))
    Try(tkwait.window(ttWeightingwtArea))

    return (ReturnVal)
}

#GetWtFlagParams <- function()
#{
#    ttWeightingwtFlag <- tktoplevel(.limmaGUIglobals$ttMain)
#    tkwm.deiconify(ttWeightingwtFlag)
#    tkgrab.set(ttWeightingwtFlag)
#    tkfocus(ttWeightingwtFlag)  
#    tkwm.title(ttWeightingwtFlag,"Weighting for Spots with Flag Values Less Than Zero")
#    tkframe1 <- tkframe(ttWeightingwtFlag)
#    tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2)
#    tkframe4 <- tkframe(tkframe1)
#    tkgrid(tklabel(tkframe1,text="    "))
#    tkgrid(tklabel(tkframe1,text="Please enter the weighting for spots with flag values less than zero",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
#    tkgrid(tklabel(tkframe1,text="    "))
#    tkgrid(tklabel(tkframe2,text="Spot Weighting",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
#    FlagSpotWeightingTcl <- tclVar(paste(0.1))
#    tkgrid(tklabel(tkframe2,text="    "))
#    entry.FlagSpotWeighting<-tkentry(tkframe2,width="12",font=.limmaGUIglobals$limmaGUIfont2,textvariable=FlagSpotWeightingTcl,bg="white")
#    tkgrid(tklabel(tkframe2,text="Weighting (relative to 1 for all other spots)",font=.limmaGUIglobals$limmaGUIfont2),entry.FlagSpotWeighting,sticky="w")
#    tkgrid(tkframe2)
#    tkgrid(tklabel(tkframe1,text="    "))
#    ReturnVal <- 0
#    FlagSpotWeightingVal <- 0
#    onOK <- function()
#    {
#        Try(FlagSpotWeightingVal <- as.numeric(tclvalue(FlagSpotWeightingTcl)))
#        Try(tkgrab.release(ttWeightingwtFlag));Try(tkdestroy(ttWeightingwtFlag));Try(tkfocus(.limmaGUIglobals$ttMain))
#        ReturnVal <<- 1
#    }
#    onCancel <- function() {Try(tkgrab.release(ttWeightingwtFlag));Try(tkdestroy(ttWeightingwtFlag));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal<<-0}   
#    OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
#    Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
#    tkgrid(OK.but,Cancel.but)
#    tkgrid(tklabel(tkframe4,text="    "))
#    tkgrid(tkframe4)
#    tkgrid(tkframe1)
#    Try(tkfocus(ttWeightingwtFlag))
#    Try(tkbind(ttWeightingwtFlag, "<Destroy>", function() {Try(tkgrab.release(ttWeightingwtFlag));Try(tkfocus(.limmaGUIglobals$ttMain));}))
#    Try(tkwait.window(ttWeightingwtFlag))
#    
#    Try(FlagSpotWeighting <- FlagSpotWeightingVal)
#    Try(assign("FlagSpotWeighting", FlagSpotWeighting,limmaGUIenvironment))
#
#    Try(assign("WeightingType",paste("wtflag, FlagSpotWeighting = ",FlagSpotWeighting,sep=""),limmaGUIenvironment))
#
#    return (ReturnVal)
#}

evalRcode <- function()
{
  # I really should file.remove / unlink i.e. DELETE the temporary file(s) I create! (OnDestroy, OnClose etc.)
  Try(wfile <- "")
  Try(ttEvalRcode <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttEvalRcode ,"Enter R code in this window and then click on Run"))
  Try(scrCode <- tkscrollbar(ttEvalRcode , repeatinterval=5,
                         command=function(...)tkyview(txt,...)))
  Try(xscrCode <- tkscrollbar(ttEvalRcode , repeatinterval=5,orient="horizontal",
                         command=function(...)tkxview(txt,...)))
  Try(txt <- tktext(ttEvalRcode , height=20,
            yscrollcommand=function(...)tkset(scrCode,...),
            xscrollcommand=function(...)tkset(xscrCode,...),
            wrap="none",width=100,bg="white",
              font=.limmaGUIglobals$limmaGUIfontCourier))
  Try(cutText <- function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Cut>>")))    )
  Try(copyText <- function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Copy>>"))))
  Try(pasteText <- function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Paste>>")))  )

  Try(editPopupMenu <- tkmenu(txt, tearoff=FALSE))
  Try(tkadd(editPopupMenu, "command", label="Cut <Ctrl-X>",command=cutText))
  Try(tkadd(editPopupMenu, "command", label="Copy <Ctrl-C>",command=copyText))
  Try(tkadd(editPopupMenu, "command", label="Paste <Ctrl-V>", command=pasteText))

  RightClick <- function(x,y) # x and y are the mouse coordinates
  {
   Try(rootx <- as.integer(tkwinfo("rootx",txt)))
   Try(rooty <- as.integer(tkwinfo("rooty",txt)))
   Try(xTxt <- as.integer(x)+rootx)
   Try(yTxt <- as.integer(y)+rooty)
   Try(.Tcl(paste("tk_popup",.Tcl.args(editPopupMenu,xTxt,yTxt))))
  }
  Try(tkbind(txt, "<Button-3>",RightClick))
  
  Try(tkpack(scrCode, side="right", fill="y"))
  Try(tkpack(xscrCode, side="bottom", fill="x"))
  Try(tkpack(txt, side="left", fill="both", expand="yes"))
  Try(tkfocus(txt))

  SaveRSourceFile <- function() 
  {
    Try(fileName <- tclvalue(tkgetSaveFile(initialfile=tclvalue(tkfile.tail(wfile)),initialdir=tclvalue(tkfile.dir(wfile)),
           filetypes="{{R Source Files} {.R}} {{All files} *}")))
    if (nchar(fileName)==0) return()
    Try(len <- nchar(fileName))
    if (len<=2)
      Try( fileName <- paste(fileName,".R",sep=""))
    else if (substring(fileName,len-1,len)!=".R")
      Try(fileName <- paste(fileName,".R",sep=""))
    Try(chn <- tkopen(fileName, "w"))
    Try(tkputs(chn, tclvalue(tkget(txt,"0.0","end"))))
    Try(tkclose(chn))
    Try(wfile <<- fileName)
    Try(tkfocus(txt))
  }

  OpenRSourceFile <- function() 
  {
    Try(fileName <- tclvalue(tkgetOpenFile(filetypes="{{R Source Files} {.R}} {{All files} *}")))
    if (nchar(fileName)==0) return()
    Try(chn <- tkopen(fileName, "r"))
    Try(tkinsert(txt, "0.0", tclvalue(tkread(chn))))
    Try(tkclose(chn))
    Try(wfile <<- fileName)
    Try(tkfocus(txt))
  }

  runOverall <- function(runType) {
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkconfigure(ttEvalRcode,cursor="watch"))
  Try(tkfocus(ttEvalRcode))
  Try(code <- tclvalue(tkget(txt,"0.0","end")))
  if (runType!="runTextOnly")
  {
     Try(LocalHScale <- .limmaGUIglobals$Myhscale)
     Try(LocalVScale <- .limmaGUIglobals$Myvscale)   

    Try(ttGraph<-tktoplevel(.limmaGUIglobals$ttMain))
    Try(tkwm.withdraw(ttGraph))
    Try(tkwm.title(ttGraph,"Graphical Results from R Code Evaluation"))
    Try(codeGraph <- paste("assign(\"plotFunction\",function () {\nopar<-par(bg=\"white\")\nTry({\n",code,"\n})\n\ntempGraphPar <- par(opar)\n},limmaGUIenvironment)\n",sep=""))
  }

  if (runType!="runGraphicsOnly")
  {
    Try(tmpEvalRcodeResults <- tempfile())  
    Try(RoutFileObject <- file(tmpEvalRcodeResults, open="wt"))
    Try(sink(RoutFileObject))
    Try(sink(RoutFileObject,type="message"))
    Try(e <- try(parse(text=code)))
    if (inherits(e, "try-error")) 
    {
      Try(tkmessageBox(message="Syntax error",icon="error"))
      Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
      Try(sink(type="message"))
      Try(sink())
      Try(try(close(RoutFileObject),TRUE))
      return()
    }
    e2 <- try(print(eval(e,envir=limmaGUIenvironment)))
    if (inherits(e2, "try-error"))
    {
      Try(tkmessageBox(title="An error occured while trying to evaluate your R code",message=as.character(e2),icon="error"))
      Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
      Try(sink(type="message"))
      Try(sink())
      Try(try(close(RoutFileObject),TRUE))
      return()      
    }
    Try(sink(type="message"))
    Try(sink())
    Try(try(close(RoutFileObject),TRUE))
  }


  if (runType!="runTextOnly")
  {
    Try(tmpEvalRcodeResultsGraph <- tempfile())
    Try(RoutFileObjectGraph <- file(tmpEvalRcodeResultsGraph,open="wt"))
    Try(sink(RoutFileObjectGraph))
    Try(sink(RoutFileObjectGraph,type="message"))
    Try(e3 <- try(parse(text=codeGraph)))
    if (inherits(e3, "try-error")) 
    {
      Try(tkmessageBox(message="Syntax error",icon="error"))
      Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
      Try(sink(type="message"))
      Try(sink())
      Try(close(RoutFileObjectGraph))
      return()
    }
    e4 <- try(print(eval(e3,envir=limmaGUIenvironment)))
    if (inherits(e4, "try-error"))
    {
      Try(tkmessageBox(message="An error occured while trying to plot the graph(s) for your R code",icon="error"))
      Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
      Try(sink(type="message"))
      Try(sink())
      Try(close(RoutFileObjectGraph))
      return()            
    }
    Try(sink(type="message"))
    Try(sink())
    Try(try(close(RoutFileObjectGraph),TRUE))
    Require("tkrplot")

    Try(plotFunction <- get("plotFunction",envir=limmaGUIenvironment))
    Try(imgLimmaGUI<-tkrplot(ttGraph,plotFunction,hscale=LocalHScale,vscale=LocalVScale))
    SetupPlotKeyBindings(tt=ttGraph,img=imgLimmaGUI)
    SetupPlotMenus(tt=ttGraph,initialfile="",plotFunction,img=imgLimmaGUI)  

    Try(tkgrid(imgLimmaGUI))
    Try(if (as.numeric(tclvalue(tkwinfo("reqheight",imgLimmaGUI)))<10)  # Nothing plotted.
      Try(tkdestroy(ttGraph))
    else
    {
      Try(tkwm.deiconify(ttGraph))
      Try(tkfocus(imgLimmaGUI))   
    })
    
    CopyToClip <- function()
    {
      Try(tkrreplot(imgLimmaGUI))
    }
  }

  if (runType!="runGraphicsOnly") 
  {
    Try(tt2 <-tktoplevel(.limmaGUIglobals$ttMain))
    Try(tkwm.title(tt2,"Text Results of R Code Evaluation"))
    Try(scr <- tkscrollbar(tt2, repeatinterval=5,
                         command=function(...)tkyview(txt2,...)))
    Try(xscr <- tkscrollbar(tt2, repeatinterval=5,orient="horizontal",
                           command=function(...)tkxview(txt2,...)))
    Try(txt2 <- tktext(tt2,height=20,bg="white",
    yscrollcommand=function(...)tkset(scr,...),
    xscrollcommand=function(...)tkset(xscr,...),
    wrap="none",width=100,font=.limmaGUIglobals$limmaGUIfontCourier))

    Try(copyText2 <- function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt2),"<<Copy>>"))))

    Try(editPopupMenu2 <- tkmenu(txt2, tearoff=FALSE))
    Try(tkadd(editPopupMenu2, "command", label="Copy <Ctrl-C>", command=copyText2))

    RightClick2 <- function(x,y) # x and y are the mouse coordinates
    {
     Try(rootx <- as.integer(tkwinfo("rootx",txt2)))
     Try(rooty <- as.integer(tkwinfo("rooty",txt2)))
     Try(xTxt <- as.integer(x)+rootx)
     Try(yTxt <- as.integer(y)+rooty)
     Try(.Tcl(paste("tk_popup",.Tcl.args(editPopupMenu2,xTxt,yTxt))))
    }
    Try(tkbind(txt2, "<Button-3>",RightClick2))

    Try(tkpack(scr, side="right", fill="y"))
    Try(tkpack(xscr, side="bottom", fill="x"))
    Try(tkpack(txt2, side="left", fill="both", expand="yes"))

    Try(chn <- tkopen(tmpEvalRcodeResults, "r"))
    Try(tkinsert(txt2, "0.0", tclvalue(tkread(chn))))
    Try(tkclose(chn))
    Try(tkfocus(tt2))
    SaveTextResults <- function()
    {
      Try(fileName<- tclvalue(tkgetSaveFile(initialfile="RcodeResults.txt",filetypes="{{Text Files} {.txt}} {{All files} *}")))
      Try(if (!nchar(fileName))        return())

      if (nchar(fileName)==0) return()
      Try(len <- nchar(fileName))
      if (len<=4)
        Try( fileName <- paste(fileName,".txt",sep=""))
      else if (substring(fileName,len-3,len)!=".txt")
      Try(fileName <- paste(fileName,".txt",sep=""))    
      Try(chn <- tkopen(fileName,"w"))
      Try(tkputs(chn, tclvalue(tkget(txt2,"0.0","end"))))
      Try(tkclose(chn))
    }

    Try(topMenu2 <- tkmenu(tt2))
    Try(tkconfigure(tt2, menu=topMenu2))
    Try(fileMenu2 <- tkmenu(topMenu2, tearoff=FALSE))
    Try(editMenu2 <- tkmenu(topMenu2, tearoff=FALSE))

    Try(tkadd(fileMenu2, "command", label="Save As",
    command=SaveTextResults))
    Try(tkadd(fileMenu2, "command", label="Close",
    command=function() tkdestroy(tt2)))
    Try(tkadd(topMenu2, "cascade", label="File",
    menu=fileMenu2))

    Try(tkadd(editMenu2, "command", label="Copy <Ctrl-C>",
    command=copyText2))
    Try(tkadd(topMenu2, "cascade", label="Edit",
    menu=editMenu2))

  }
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(tkconfigure(ttEvalRcode,cursor="arrow"))
  }

  Try(runTextOnly <- function() runOverall("runTextOnly"))
  Try(runGraphicsOnly <- function() runOverall("runGraphicsOnly"))
  Try(runTextAndGraphics <- function() runOverall("runTextAndGraphics"))

  MakeLimmaGUIMenu <- function()
  {
    Try(code <- tclvalue(tkget(txt,"0.0","end")))
    Try(codeGraph <- paste("assign(\"plotFunction\",function () {\nopar<-par(bg=\"white\")\nTry({\n",code,"\n})\n\ntempGraphPar <- par(opar)\n},limmaGUIenvironment)\n",sep=""))
    Try(menuNameObject <- GetMenuName())
    Try(if (length(menuNameObject)==0) return())    
    Try(addMenuItem(codeGraph,menuNameObject$MenuName,newMenu=TRUE,menuPosition="end",
      menuNameObject$MenuItemName,newMenuItem=TRUE,menuItemPosition="end",
            outputHasGraphics=TRUE))  
  }

  Try(HTMLhelp <- function() help.start())

  Try(topMenu <- tkmenu(ttEvalRcode ))
  Try(tkconfigure(ttEvalRcode , menu=topMenu))
  Try(fileMenu <- tkmenu(topMenu, tearoff=FALSE))
  Try(runMenu <- tkmenu(topMenu, tearoff=FALSE))
  Try(editMenu <- tkmenu(topMenu, tearoff=FALSE))
  Try(helpMenu <- tkmenu(topMenu, tearoff=FALSE))
  Try(tkadd(fileMenu, "command", label="Open",
  command=OpenRSourceFile))
  Try(tkadd(fileMenu, "command", label="Save As",
  command=SaveRSourceFile))
  Try(tkadd(fileMenu, "command", label="Close",
  command=function() tkdestroy(ttEvalRcode )))
  Try(tkadd(topMenu, "cascade", label="File",
  menu=fileMenu))
  Try(tkadd(editMenu, "command", label="Cut <Ctrl-X>",
  command=cutText))
  Try(tkadd(editMenu, "command", label="Copy <Ctrl-C>",
  command=copyText))
  Try(tkadd(editMenu, "command", label="Paste <Ctrl-V>",
  command=pasteText))
  Try(tkadd(topMenu, "cascade", label="Edit",
  menu=editMenu))
  Try(tkadd(runMenu,"command",label="Show Text Results only",
  command=runTextOnly))
  Try(tkadd(runMenu,"command",label="Show Graphical Results only",
  command=runGraphicsOnly))
  Try(tkadd(runMenu,"command",label="Show Text and Graphics",
  command=runTextAndGraphics))
  Try(tkadd(topMenu, "cascade", label="Run",
  menu=runMenu))
  
#  Try(menuMenu <- tkmenu(topMenu,tearoff=FALSE))
#  Try(tkadd(menuMenu,"command",label="Make limmaGUI Custom Menu Item",command=MakeLimmaGUIMenu))
#  Try(tkadd(topMenu,"cascade",label="Make limmaGUI Menu Item",menu=menuMenu))
  
  Try(tkadd(helpMenu,"command",label="HTML Help",
  command=HTMLhelp))
  Try(tkadd(topMenu,"cascade",label="Help",
  menu=helpMenu))
}

OpenGALandTargetsandSpotTypesfiles <- function()
{
  Try(ttGALandTargetsandSpotTypes<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGALandTargetsandSpotTypes))
  Try(tkgrab.set(ttGALandTargetsandSpotTypes))
  Try(tkfocus(ttGALandTargetsandSpotTypes))
  Try(tkwm.title(ttGALandTargetsandSpotTypes,"Open GAL and Targets and Spot Types Files"))
  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    ")))

  OpenTargetsFileAndSetCursor <- function()
  {
      Try(tkconfigure(ttGALandTargetsandSpotTypes,cursor="watch"))
      Try(tkfocus(ttGALandTargetsandSpotTypes))
      Try(OpenTargetsFile())
      Try(tkconfigure(ttGALandTargetsandSpotTypes,cursor="arrow"))  
      Try(tkfocus(ttGALandTargetsandSpotTypes))
  }

  OpenGALFileAndSetCursor <- function()
  {
      Try(tkconfigure(ttGALandTargetsandSpotTypes,cursor="watch"))
      Try(tkfocus(ttGALandTargetsandSpotTypes))
      Try(OpenGALFile())
      Try(tkconfigure(ttGALandTargetsandSpotTypes,cursor="arrow"))  
      Try(tkfocus(ttGALandTargetsandSpotTypes))
  }

  OpenSpotTypesFileAndSetCursor <- function()
  {
      Try(tkconfigure(ttGALandTargetsandSpotTypes,cursor="watch"))
      Try(tkfocus(ttGALandTargetsandSpotTypes))
      Try(OpenSpotTypesFile())
      Try(tkconfigure(ttGALandTargetsandSpotTypes,cursor="arrow"))  
      Try(tkfocus(ttGALandTargetsandSpotTypes))
  }

  Try(OpenGALFile.but <- tkbutton(ttGALandTargetsandSpotTypes, text="Select GAL File",command=OpenGALFile,font=.limmaGUIglobals$limmaGUIfont2))
  Try(OpenTargetsFile.but <- tkbutton(ttGALandTargetsandSpotTypes, text="Select Targets File",command=OpenTargetsFile,font=.limmaGUIglobals$limmaGUIfont2))
  Try(OpenSpotTypesFile.but <- tkbutton(ttGALandTargetsandSpotTypes, text="Select Spot-Types File",command=OpenSpotTypesFileAndSetCursor,font=.limmaGUIglobals$limmaGUIfont2))

  Try(GALfileBoxTitleLabel<-tklabel(ttGALandTargetsandSpotTypes,text=as.character(tclvalue(.limmaGUIglobals$GALfileBoxTitle)),font=.limmaGUIglobals$limmaGUIfont2))
  Try(GALfileNameLabel<-tklabel(ttGALandTargetsandSpotTypes,text=as.character(tclvalue(.limmaGUIglobals$GALfileNameTcl)),background="white",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkconfigure(GALfileBoxTitleLabel, textvariable=.limmaGUIglobals$GALfileBoxTitle))
  Try(tkconfigure(GALfileNameLabel, textvariable=.limmaGUIglobals$GALfileNameTcl))

  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    ")))
  Try(tkgrid(GALfileBoxTitleLabel,columnspan=4))
  Try(tkgrid(GALfileNameLabel,columnspan=4))

  Try(.limmaGUIglobals$TargetsfileBoxTitleTclLabel <- tklabel(ttGALandTargetsandSpotTypes,text=as.character(tclvalue(.limmaGUIglobals$TargetsfileBoxTitleTcl)),font=.limmaGUIglobals$limmaGUIfont2))
  Try(.limmaGUIglobals$TargetsfileNameTclLabel <- tklabel(ttGALandTargetsandSpotTypes,text=as.character(tclvalue(.limmaGUIglobals$TargetsfileNameTcl)),background="white",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkconfigure(.limmaGUIglobals$TargetsfileBoxTitleTclLabel, textvariable=.limmaGUIglobals$TargetsfileBoxTitleTcl))
  Try(tkconfigure(.limmaGUIglobals$TargetsfileNameTclLabel, textvariable=.limmaGUIglobals$TargetsfileNameTcl))

  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    ")))
  Try(tkgrid(.limmaGUIglobals$TargetsfileBoxTitleTclLabel,columnspan=4))
  Try(tkgrid(.limmaGUIglobals$TargetsfileNameTclLabel,columnspan=4))

  Try(.limmaGUIglobals$SpotTypesfileBoxTitleTclLabel <- tklabel(ttGALandTargetsandSpotTypes,text=as.character(tclvalue(.limmaGUIglobals$SpotTypesfileBoxTitleTcl)),font=.limmaGUIglobals$limmaGUIfont2))
  Try(.limmaGUIglobals$SpotTypesfileNameTclLabel <- tklabel(ttGALandTargetsandSpotTypes,text=as.character(tclvalue(.limmaGUIglobals$SpotTypesfileNameTcl)),background="white",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkconfigure(.limmaGUIglobals$SpotTypesfileBoxTitleTclLabel, textvariable=.limmaGUIglobals$SpotTypesfileBoxTitleTcl))
  Try(tkconfigure(.limmaGUIglobals$SpotTypesfileNameTclLabel, textvariable=.limmaGUIglobals$SpotTypesfileNameTcl))

  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    ")))
  Try(tkgrid(.limmaGUIglobals$SpotTypesfileBoxTitleTclLabel,columnspan=4))
  Try(tkgrid(.limmaGUIglobals$SpotTypesfileNameTclLabel,columnspan=4))
  
  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    ")))
  Try(tkgrid(OpenGALFile.but, OpenTargetsFile.but,OpenSpotTypesFile.but))
  Try(Abort <- 1)
  onOK <- function()
  {
      Try(gal     <- get("gal",envir=limmaGUIenvironment))
      Try(Targets <- get("Targets",envir=limmaGUIenvironment))  
      Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))    
      Try(if (length(gal)==0)
      {
        Try(tkmessageBox(title="GAL (GenePix Array List) File",message=paste("Either you did not specify a valid GAL (GenePix Array List) File",
          "or an error occurred while reading in the GAL file.  It should be in tab-delimited text format and it should include the column headings \"Block\", \"Column\", \"Row\", \"Name\" and \"ID\"."),icon="error"))        
        onCancel()
        return()
      })
      Try(if (length(Targets)==0)
      {
        Try(tkmessageBox(title="RNA Targets (Hybridizations) File",message=paste("Either you did not specify a valid RNA Targets (Hybridizations) File",
          "or an error occurred while reading in the Targets file.  It should be in tab-delimited text format and it should include the column headings \"SlideNumber\", \"FileName\", \"Cy3\" and \"Cy5\"",
          "(except for the case of ImaGene data which requires \"FileNameCy3\" and \"FileNameCy5\" column headings instead of \"FileName\".)"),icon="error"))
        onCancel()
        return()
      })
      Try(if (length(SpotTypes)==0)
      {
        Try(tkmessageBox(title="Spot Types",message=paste("Warning: You did not specify a valid spot types file, so limmaGUI will assume that all spots are genes."),icon="warning"))
        Try(assign("SpotTypes" , data.frame(SpotType=I("gene"),ID=I("*"),Name=I("*"),Color=I("black")),limmaGUIenvironment))
        Try(UpdateSpotTypesStatus())        
      })
      Try(tkgrab.release(ttGALandTargetsandSpotTypes));
      Try(tkdestroy(ttGALandTargetsandSpotTypes));
      Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(Abort <<- 0)
  }
  onCancel <- function() {Try(tkgrab.release(ttGALandTargetsandSpotTypes));Try(tkdestroy(ttGALandTargetsandSpotTypes));Try(tkfocus(.limmaGUIglobals$ttMain));Try(Abort<<-1)}
  Try(OK.but <-tkbutton(ttGALandTargetsandSpotTypes,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttGALandTargetsandSpotTypes,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    ")))
  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="    "),OK.but,Cancel.but))
  Try(tkgrid(tklabel(ttGALandTargetsandSpotTypes,text="       ")))
  Try(tkfocus(ttGALandTargetsandSpotTypes))
  Try(tkbind(ttGALandTargetsandSpotTypes, "<Destroy>", function() {Try(tkgrab.release(ttGALandTargetsandSpotTypes));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGALandTargetsandSpotTypes))
   
  if (Abort==1)
        return(0)

  #OK
  Try(ReturnVal<- ReadImageProcessingFiles())
  if (ReturnVal==0) return(0)
  Try(ReturnVal <- GetlimmaDataSetName())
  if (ReturnVal==0) return(0)        
  return(1)
 
}

GetlimmaDataSetName <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(ttGetlimmaDataSetName<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGetlimmaDataSetName))
  Try(tkgrab.set(ttGetlimmaDataSetName))
  Try(tkfocus(ttGetlimmaDataSetName))
  Try(tkwm.title(ttGetlimmaDataSetName,"Data Set Name"))
  Try(tkgrid(tklabel(ttGetlimmaDataSetName,text="    ")))
  if (limmaDataSetNameText=="Untitled")
      Try(limmaDataSetNameText <- "")
  Try(Local.limmaDataSetName <- tclVar(init=limmaDataSetNameText))
  Try(entry.limmaDataSetName <-tkentry(ttGetlimmaDataSetName,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=Local.limmaDataSetName,bg="white"))
  Try(tkgrid(tklabel(ttGetlimmaDataSetName,text="Please enter a name for this data set.",font=.limmaGUIglobals$limmaGUIfont2)))
  Try(tkgrid(entry.limmaDataSetName))
  onOK <- function()
  {    
      Try(limmaDataSetNameText <- tclvalue(Local.limmaDataSetName))
      if (nchar(limmaDataSetNameText)==0)
        limmaDataSetNameText <- "Untitled"
#      Try(tkwm.title(.limmaGUIglobals$ttMain,paste("LimmaGUI -",limmaDataSetNameText)))
      Try(assign("limmaDataSetNameText",limmaDataSetNameText,limmaGUIenvironment))
      Try(tclvalue(.limmaGUIglobals$limmaDataSetNameTcl) <- limmaDataSetNameText)
      Try(tkgrab.release(ttGetlimmaDataSetName));Try(tkdestroy(ttGetlimmaDataSetName));Try(tkfocus(.limmaGUIglobals$ttMain))
  }
  Try(OK.but <-tkbutton(ttGetlimmaDataSetName,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGetlimmaDataSetName,text="    ")))
  Try(tkgrid(OK.but))
  Try(tkgrid.configure(OK.but))
  Try(tkgrid(tklabel(ttGetlimmaDataSetName,text="       ")))
  Try(tkfocus(entry.limmaDataSetName))
  Try(tkbind(entry.limmaDataSetName, "<Return>",onOK))
  Try(tkbind(ttGetlimmaDataSetName, "<Destroy>", function(){Try(tkgrab.release(ttGetlimmaDataSetName));Try(tkfocus(.limmaGUIglobals$ttMain));return(0)}))
  Try(tkwait.window(ttGetlimmaDataSetName))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  return (1)
}

GetNumParametersNoTargets <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))
  Try(if (NumParameters==0) # Initialized value
    NumParameters <- 1) # Sensible default value for importing data without a Targets table.

  Try(ttGetNumParametersNoTargets<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGetNumParametersNoTargets))
  Try(tkgrab.set(ttGetNumParametersNoTargets))
  Try(tkwm.title(ttGetNumParametersNoTargets,"Number of Parameters to Estimate"))
  Try(tkgrid(tklabel(ttGetNumParametersNoTargets,text="    ")))
  Try(Local.NumParametersNoTargets <- tclVar(paste(NumParameters)))
  Try(entry.NumParametersNoTargets <-tkentry(ttGetNumParametersNoTargets,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=Local.NumParametersNoTargets,bg="white"))
  Try(tkgrid(tklabel(ttGetNumParametersNoTargets,text="Number of Parameters to Estimate:.",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2))
  Try(tkgrid(entry.NumParametersNoTargets,columnspan=2))

  ReturnVal <- -1
  onOK <- function()
  {
      Try(NumParameters <- as.numeric(tclvalue(Local.NumParametersNoTargets)))
      Try(if (is.na(NumParameters) || !is.numeric(NumParameters) || NumParameters<1)
      {
        Try(tkmessageBox(title="Invalid Number of Parameters",message="Please enter a valid number of parameters to estimate in the linear model.",icon="error"))
        Try(NumParameters <- 1)
        return()
      })               
      Try(assign("NumParameters",NumParameters,limmaGUIenvironment))
      Try(tkgrab.release(ttGetNumParametersNoTargets));Try(tkdestroy(ttGetNumParametersNoTargets));Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(ReturnVal <<- NumParameters)
  }
  onCancel <- function()
  {
      Try(tkgrab.release(ttGetNumParametersNoTargets));Try(tkdestroy(ttGetNumParametersNoTargets));Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(ReturnVal <<- -1)
  }
  Try(OK.but <-tkbutton(ttGetNumParametersNoTargets,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttGetNumParametersNoTargets,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGetNumParametersNoTargets,text="    ")))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))
  Try(tkgrid(tklabel(ttGetNumParametersNoTargets,text="       ")))
  Try(tkfocus(entry.NumParametersNoTargets))
  Try(tkbind(entry.NumParametersNoTargets, "<Return>",onOK))
  Try(tkbind(ttGetNumParametersNoTargets, "<Destroy>", function(){Try(tkgrab.release(ttGetNumParametersNoTargets));Try(tkfocus(.limmaGUIglobals$ttMain));Try(return("GetNumParametersNoTargets.CANCEL"))}))
  Try(tkwait.window(ttGetNumParametersNoTargets))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(return (ReturnVal))
}

GetParameterizationName <- function()
{
  Try(ttGetParameterizationName<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGetParameterizationName))
  Try(tkgrab.set(ttGetParameterizationName))
  Try(tkwm.title(ttGetParameterizationName,"Parameterization Name"))
  Try(tkgrid(tklabel(ttGetParameterizationName,text="    ")))
  Try(Local.ParameterizationName <- tclVar(init=""))
  Try(entry.ParameterizationName <-tkentry(ttGetParameterizationName,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=Local.ParameterizationName,bg="white"))
  Try(tkgrid(tklabel(ttGetParameterizationName,text="Please enter a name for this parameterization.",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2))
  Try(tkgrid(entry.ParameterizationName,columnspan=2))

  ReturnVal <- "GetParameterizationName.CANCEL"
  onOK <- function()
  {
      Try(ParameterizationNameText <- tclvalue(Local.ParameterizationName))
      Try(tkgrab.release(ttGetParameterizationName));Try(tkdestroy(ttGetParameterizationName));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- ParameterizationNameText
  }
  onCancel <- function()
  {
      Try(tkgrab.release(ttGetParameterizationName));Try(tkdestroy(ttGetParameterizationName));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- "GetParameterizationName.CANCEL"
  }
  Try(OK.but <-tkbutton(ttGetParameterizationName,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttGetParameterizationName,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGetParameterizationName,text="    ")))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))
  Try(tkgrid(tklabel(ttGetParameterizationName,text="       ")))
  Try(tkfocus(entry.ParameterizationName))
  Try(tkbind(entry.ParameterizationName, "<Return>",onOK))
  Try(tkbind(ttGetParameterizationName, "<Destroy>", function(){Try(tkgrab.release(ttGetParameterizationName));Try(tkfocus(.limmaGUIglobals$ttMain));Try(return("GetParameterizationName.CANCEL"))}))
  Try(tkwait.window(ttGetParameterizationName))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(return (ReturnVal))
}

GetContrastsParameterizationName <- function()
{
  Try(ttGetContrastsParameterizationName<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGetContrastsParameterizationName))
  Try(tkgrab.set(ttGetContrastsParameterizationName))
  Try(tkwm.title(ttGetContrastsParameterizationName,"Contrasts Name"))
  Try(tkgrid(tklabel(ttGetContrastsParameterizationName,text="    ")))
  Try(Local.ContrastsParameterizationName <- tclVar(init=""))
  Try(entry.ContrastsParameterizationName <-tkentry(ttGetContrastsParameterizationName,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=Local.ContrastsParameterizationName,bg="white"))
  Try(tkgrid(tklabel(ttGetContrastsParameterizationName,text="Please enter a name for this set of contrasts.",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2))
  Try(tkgrid(entry.ContrastsParameterizationName,columnspan=2))

  ReturnVal <- "GetContrastsParameterizationName.CANCEL"
  onOK <- function()
  {
      Try(contrastsParameterizationNameText <- tclvalue(Local.ContrastsParameterizationName))
      Try(tkgrab.release(ttGetContrastsParameterizationName));Try(tkdestroy(ttGetContrastsParameterizationName));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- contrastsParameterizationNameText
  }
  onCancel <- function()
  {
      Try(tkgrab.release(ttGetContrastsParameterizationName));Try(tkdestroy(ttGetContrastsParameterizationName));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- "GetContrastsParameterizationName.CANCEL"
  }
  Try(OK.but <-tkbutton(ttGetContrastsParameterizationName,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttGetContrastsParameterizationName,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGetContrastsParameterizationName,text="    ")))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))
  Try(tkgrid(tklabel(ttGetContrastsParameterizationName,text="       ")))
  Try(tkfocus(entry.ContrastsParameterizationName))
  Try(tkbind(entry.ContrastsParameterizationName, "<Return>",onOK))
  Try(tkbind(ttGetContrastsParameterizationName, "<Destroy>", function(){Try(tkgrab.release(ttGetContrastsParameterizationName));Try(tkfocus(.limmaGUIglobals$ttMain));Try(return("GetContrastsParameterizationName.CANCEL"))}))
  Try(tkwait.window(ttGetContrastsParameterizationName))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(return (ReturnVal))
}



NewLimmaFile <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))
  
  if (limmaDataSetNameText!="Untitled")
  {
      Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled")  LimmaFileName <- limmaDataSetNameText)  # Local assignment only
      Try(mbVal <- tkmessageBox(title="Start New Analysis",
            message=paste("Save changes to ",LimmaFileName,"?",sep=""),
            icon="question",type="yesnocancel",default="yes"))
      if (tclvalue(mbVal)=="yes")
          Try(SaveLimmaFile())
      if (tclvalue(mbVal)=="cancel")
      {
          Try(tkfocus(.limmaGUIglobals$ttMain))
          return()
      }
      Try(limmaDataSetNameText <- "Untitled")
  }
#  Try(tkmessageBox(title="Working Directory",message="After clicking OK, please select a working directory.",type="ok"))
  Try(WD <- SetWD())
  if (WD=="") return()

  Try(tkdelete(.limmaGUIglobals$mainTree,"RG"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"BC"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"WeightingType"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"MA"))  
  Try(tkdelete(.limmaGUIglobals$mainTree,"Layout"))    
  Try(tkdelete(.limmaGUIglobals$mainTree,"Parameterizations"))      
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","RG" ,text="R and G",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","BC" ,text="Background Correction",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BC","BC.Status" ,text="subtract",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","WeightingType" ,text="Spot Quality Weighting",font=.limmaGUIglobals$limmaGUIfontTree)) 
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WeightingType","WeightingType.Status" ,text="none",font=.limmaGUIglobals$limmaGUIfontTree))  
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","MA" ,text="M and A",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","Raw" ,text="Raw",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","WithinOnly" ,text="Within-Array Normalized",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","BetweenOnly" ,text="Between-Array Normalized",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","MA","WithinAndBetween",text="Within and Between-Array Normalized",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Layout", text="Layout",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Parameterizations" ,text="Parameterizations",font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations","Parameterizations.Status" ,text="None",font=.limmaGUIglobals$limmaGUIfontTree))


  if (NumParameterizations>0)
    for (parameterizationIndex in (1:NumParameterizations))
    {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
      Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,ParameterizationNameNode))
      Try(assign("ParameterizationList", deleteItemFromList(ParameterizationList,ParameterizationNameNode),limmaGUIenvironment))
    }
  Try(initGlobals())
  Try(LimmaFileName <- get("LimmaFileName",limmaGUIenvironment))
  Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled") LimmaFileName <- limmaDataSetNameText) # Local assignment only  
  Try(tkwm.title(.limmaGUIglobals$ttMain,paste("LimmaGUI -",LimmaFileName)))
  Try(tclvalue(.limmaGUIglobals$GALfileBoxTitle)     <- "Please select a GenePix Array List (GAL) file.")
  Try(tclvalue(.limmaGUIglobals$GALfileNameTcl)         <- "No filename is selected at the moment.  Press the Select GAL File Button.")
  Try(tclvalue(.limmaGUIglobals$TargetsfileBoxTitleTcl) <- "Please select a tab-delimited file listing the microarray hybridizations.")
  Try(tclvalue(.limmaGUIglobals$TargetsfileNameTcl)     <- "No filename is selected at the moment.  Press the Select Targets File Button.")
  Try(tclvalue(.limmaGUIglobals$SpotTypesfileBoxTitleTcl) <- "Please select a tab-delimited file listing the spot types.")
  Try(tclvalue(.limmaGUIglobals$SpotTypesfileNameTcl) <- "No filename is selected at the moment.  Press the Select Spot-Types File Button.")
  Try(OpenGALandTargetsandSpotTypesfiles())
  Try(tkfocus(.limmaGUIglobals$ttMain))
}

chooseDir <- function()
{
	Try(wd <- tclVar(getwd()))
	Try(ttChooseDir <- tktoplevel(.limmaGUIglobals$ttMain))
	Try(tkwm.title(ttChooseDir,"Choose working directory"))
	Try(tkwm.deiconify(ttChooseDir))
	Try(tkgrab.set(ttChooseDir))
	Try(tkgrid(tklabel(ttChooseDir,text="    ")))
	Try(label1 <- tklabel(ttChooseDir,text="Choose working directory (containing input files):",font=.limmaGUIglobals$limmaGUIfont2))
	Try(tkgrid(tklabel(ttChooseDir,text="    "),label1,sticky="w"))
	Try(tkgrid.configure(label1,columnspan=3))
	Try(tkgrid(tklabel(ttChooseDir,text="    ")))
	Try(onBrowse <- function() 
	{
	  Try(if (file.exists(tclvalue(wd))) initialdir<-gsub("/","\\\\",tclvalue(wd)) else initialdir<-gsub("/","\\\\",getwd()))
	  Try(dir1 <- tclvalue(tkchooseDirectory(title="Please choose a working directory for the Limma Analysis",initialdir=initialdir)))
		Try(if (nchar(dir1)>0) tclvalue(wd) <- dir1)
	})
	Try(ReturnVal <- "")
	Try(onOK <- function() {Try(DirChosen <- tclvalue(wd));Try(tkgrab.release(ttChooseDir));Try(tkdestroy(ttChooseDir)); Try(ReturnVal <<- DirChosen)})
	Try(onCancel <- function() {Try(tkgrab.release(ttChooseDir));Try(tkdestroy(ttChooseDir))})
	Try(Browse.but <- tkbutton(ttChooseDir,text="Browse",command=onBrowse,font=.limmaGUIglobals$limmaGUIfont2))
	Try(OK.but <- tkbutton(ttChooseDir,text="    OK    ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
	Try(Cancel.but <- tkbutton(ttChooseDir,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
	Try(entry1 <- tkentry(ttChooseDir,textvariable=wd,width=60))
	Try(tkgrid(tklabel(ttChooseDir,text="    "),entry1))
	Try(tkgrid.configure(entry1,columnspan=3))
  Try(tkgrid(tklabel(ttChooseDir,text="    "),row=3,column=4))
	Try(tkgrid(Browse.but,row=3,column=5))
  Try(tkgrid(tklabel(ttChooseDir,text="    "),row=3,column=6))
	Try(tkgrid(tklabel(ttChooseDir,text="    ")))
	Try(tkgrid(tklabel(ttChooseDir,text="    "),tklabel(ttChooseDir,text="    "),OK.but,Cancel.but))
	Try(tkgrid.configure(Cancel.but,sticky="w"))
	Try(tkgrid(tklabel(ttChooseDir,text="    ")))
	Try(tkfocus(entry1))
	Try(tkbind(ttChooseDir,"<Destroy>",function()tkgrab.release(ttChooseDir)))
	Try(tkbind(entry1,"<Return>",onOK))
	Try(tkwait.window(ttChooseDir))
	return(ReturnVal)	
}


SetWD <- function()
{
  WD <- chooseDir()
  if (!nchar(WD)) 
  {
      tkfocus(.limmaGUIglobals$ttMain)
      return("")
  }
  Try(setwd(WD))
  tkfocus(.limmaGUIglobals$ttMain)
  return(WD)
}

onExit <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))
  if (limmaDataSetNameText!="Untitled")
  {
      Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled")  LimmaFileName <- limmaDataSetNameText)  # Local assignment only
      Try(mbVal <- tkmessageBox(title="Exit limmaGUI",
            message=paste("Save changes to ",LimmaFileName,"?",sep=""),
            icon="question",type="yesnocancel",default="yes"))
      if (tclvalue(mbVal)=="yes")
          Try(SaveLimmaFile())
      if (tclvalue(mbVal)=="cancel")
          return()
  }
  Try(assign(".JustAskedWhetherToSave",TRUE,.GlobalEnv))
  try(tkdestroy(.limmaGUIglobals$ttMain),silent=TRUE)
}

DeleteParameterization <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))  
  
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Delete Parameterization",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return()    )
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  Try(LinearModelComputed[parameterizationIndex]<-FALSE)
  Try(assign("LinearModelComputed",LinearModelComputed,limmaGUIenvironment))
  
  ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep="")
  Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,ParameterizationNameNode))
  Try(ParameterizationList <- deleteItemFromList(ParameterizationList,ParameterizationNameNode))

  tempVec <- c()
  if (NumParameterizations>0)
    for (i in (1:NumParameterizations))
    {
      if (i!=parameterizationIndex)
          Try(tempVec <- c(tempVec,ParameterizationNamesVec[i]))
    }
  Try(ParameterizationNamesVec <- tempVec)

  tempVec2 <- c()
  if (NumParameterizations>0)
    for (i in (1:NumParameterizations))
    {
      if (i!=parameterizationTreeIndex)
          Try(tempVec2 <- c(tempVec2,ParameterizationTreeIndexVec[i]))
    }
  Try(ParameterizationTreeIndexVec <- tempVec2)

  Try(NumParameterizations <- NumParameterizations - 1)        
  
  Try(assign("ParameterizationTreeIndexVec",ParameterizationTreeIndexVec,limmaGUIenvironment))
  Try(assign("ParameterizationNamesVec",ParameterizationNamesVec,limmaGUIenvironment))
  Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
  Try(assign("NumParameterizations",NumParameterizations,limmaGUIenvironment))  

  Try(tkdelete(.limmaGUIglobals$mainTree,"Parameterizations"))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Parameterizations" ,text="Parameterizations",font=.limmaGUIglobals$limmaGUIfontTree))
  if (NumParameterizations>0)
  {
    for (i in (1:NumParameterizations))
    {
      Try(ParameterizationsStatusNameNode <- paste("Parameterizations.Status.",i,sep=""))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations",ParameterizationsStatusNameNode ,text=ParameterizationNamesVec[i],font=.limmaGUIglobals$limmaGUIfontTree))
    }
  } else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations","Parameterizations.Status.1" ,text="None",font=.limmaGUIglobals$limmaGUIfontTree)) 
}

ChooseContrastsParameterization <- function(parameterizationTreeIndex)
{
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
  Try(if (NumContrastParameterizations==0)
  {
    Try(tkmessageBox(title="Choose Contrasts Parameterization",message=paste("There are no contrasts parameterizations available for parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep=""),type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })      
  Try(ContrastsParameterizationNamesVec <- c() )
  Try(for (i in(1:NumContrastParameterizations))
    ContrastsParameterizationNamesVec[i] <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[i]]$contrastsParameterizationNameText)
  
  ttChooseContrastsParameterization<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttChooseContrastsParameterization)
  tkgrab.set(ttChooseContrastsParameterization)  
  tkfocus(ttChooseContrastsParameterization)
  tkwm.title(ttChooseContrastsParameterization,"Choose a Contrasts Parameterization")
  scr <- tkscrollbar(ttChooseContrastsParameterization, repeatinterval=5,
                       command=function(...)tkyview(tl,...))
  ## Safest to make sure scr exists before setting yscrollcommand
  tl<-tklistbox(ttChooseContrastsParameterization,height=4,selectmode="single",yscrollcommand=function(...)tkset(scr,...),background="white",font=.limmaGUIglobals$limmaGUIfont2)   
  lbl2<-tklabel(ttChooseContrastsParameterization,text="Which contrasts parameterization is this for?",font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttChooseContrastsParameterization,text="       "),row=0,column=1,columnspan=1)
  tkgrid(tklabel(ttChooseContrastsParameterization,text="       "),row=0,column=4,columnspan=1)
  tkgrid(lbl2,row=1,column=2,columnspan=2,rowspan=1);
  tkgrid.configure(lbl2,sticky="w")
  tkgrid(tklabel(ttChooseContrastsParameterization,text="         "),row=2,column=1)
  tkgrid(tl,row=2,column=2,columnspan=2,rowspan=4,sticky="ew")
  tkgrid(scr,row=2,column=3,columnspan=1,rowspan=4,sticky="wns")
  if (NumContrastParameterizations>0)
    for (i in (1:NumContrastParameterizations))
       tkinsert(tl,"end",ContrastsParameterizationNamesVec[i])
  tkselection.set(tl,0)

  ReturnVal <- 0
  onOK <- function()
  {
      Try(contrastsParameterizationIndex <- as.numeric(tclvalue(tkcurselection(tl)))+1)
      Try(tkgrab.release(ttChooseContrastsParameterization));Try(tkdestroy(ttChooseContrastsParameterization));Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- contrastsParameterizationIndex
  }
  onCancel <- function() {Try(tkgrab.release(ttChooseContrastsParameterization));Try(tkdestroy(ttChooseContrastsParameterization));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- 0}
  OK.but <-tkbutton(ttChooseContrastsParameterization,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttChooseContrastsParameterization,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttChooseContrastsParameterization,text="    "))
  tkgrid(tklabel(ttChooseContrastsParameterization,text="    "),tklabel(ttChooseContrastsParameterization,text="    "),OK.but,Cancel.but)
  tkgrid.configure(OK.but,    sticky="e")
  tkgrid.configure(Cancel.but,sticky="w")
  
  tkgrid(tklabel(ttChooseContrastsParameterization,text="    "))
  Try(tkfocus(ttChooseContrastsParameterization))
  Try(tkbind(ttChooseContrastsParameterization, "<Destroy>", function() {Try(tkgrab.release(ttChooseContrastsParameterization));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttChooseContrastsParameterization))

  return (ReturnVal)
}

DeleteContrastsParameterization <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  
  Try(if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Delete Contrasts Parameterization",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return()    )
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)

  Try(if (NumContrastParameterizations==0)
  {
    Try(tkmessageBox(title="Delete Contrasts Parameterization",message=paste("There are no contrasts parameterizations available for parameterization ",ParameterizationNamesVec[parameterizationIndex],".",sep=""),type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })  
  Try(contrastsParameterizationIndex <- ChooseContrastsParameterization(parameterizationTreeIndex))
  Try(if (contrastsParameterizationIndex==0)    return()    )
  Try(ContrastsParameterizationTreeIndexVec <- ParameterizationList[[ParameterizationNameNode]]$ContrastsParameterizationTreeIndexVec)
  Try(contrastsParameterizationTreeIndex <- ContrastsParameterizationTreeIndexVec[contrastsParameterizationIndex])          
  Try(ContrastsParameterizationTreeNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep=""))
  
  Try(ContrastsParameterizationListNode <- paste("ContrastsParameterization.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex, sep=""))  
  
  Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,ContrastsParameterizationTreeNode))
  Try(ParameterizationList[[ParameterizationNameNode]]$Contrasts <- deleteItemFromList(ParameterizationList[[ParameterizationNameNode]]$Contrasts,
                            ContrastsParameterizationListNode))
  Try(tempVec <- c())
  Try(if (NumContrastParameterizations>0)
    Try(for (i in (1:NumContrastParameterizations))
    {
      Try(if (i!=contrastsParameterizationTreeIndex)
          Try(tempVec <- c(tempVec,ContrastsParameterizationTreeIndexVec[i])))
    }))
  Try(ContrastsParameterizationTreeIndexVec <- tempVec)

  Try(ParameterizationList[[ParameterizationNameNode]]$ContrastsParameterizationTreeIndexVec <- ContrastsParameterizationTreeIndexVec)

  Try(NumContrastParameterizations <- NumContrastParameterizations - 1)        
  Try(ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations <- NumContrastParameterizations)  
  Try(ParamContrastsNode <- paste("ParamContrasts.",parameterizationTreeIndex,sep=""))
  Try(if (ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations==0)
    Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParamContrastsNode,paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".1",sep=""),text="none",font=.limmaGUIglobals$limmaGUIfontTree)))
  Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
}


OpenLimmaFile <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))
  Try(tempLimmaFileName <- tclvalue(tkgetOpenFile(filetypes="{{Limma Files} {.lma}} {{All files} *}")))
  if (!nchar(tempLimmaFileName)) 
  {
    tkfocus(.limmaGUIglobals$ttMain)
    return()
  }
  limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment)
  if (limmaDataSetNameText!="Untitled")
  {
      Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled")  LimmaFileName <- limmaDataSetNameText)  # Local assignment only
      mbVal <- tkmessageBox(title="Open File",
            message=paste("Save changes to ",LimmaFileName,"?",sep=""),
            icon="question",type="yesnocancel",default="yes")
      if (tclvalue(mbVal)=="yes")
          SaveLimmaFile()
      if (tclvalue(mbVal)=="cancel")
          return()
  }
  Try(LimmaFileName <- tempLimmaFileName)
  Try(assign("LimmaFileName",LimmaFileName,limmaGUIenvironment))
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))        
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))

# Using existing NumParameterizations, NOT the one loaded from the .lma file.
# (We haven't loaded it yet.)
  if (NumParameterizations>0)
    for (parameterizationIndex in (1:NumParameterizations))
    {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
      Try(tkdelete(.limmaGUIglobals$ParameterizationTREE,ParameterizationNameNode))
      Try(assign("ParameterizationList",deleteItemFromList(ParameterizationList,ParameterizationNameNode),limmaGUIenvironment))         
    }

  # Load the RData File whose name is "LimmaFileName"
  Try(rm(list=ls(limmaGUIenvironment),envir=limmaGUIenvironment))
  load(LimmaFileName,envir=limmaGUIenvironment)

  # The user may have changed the filename in the operating system since the last save.
  Try(LimmaFileName <- tempLimmaFileName)
  Try(assign("LimmaFileName",LimmaFileName,limmaGUIenvironment))
  
  Try(if(!exists("NormalizedMADataWasImported",envir=limmaGUIenvironment))
    Try(  assign("NormalizedMADataWasImported",FALSE,limmaGUIenvironment)))
  Try(if (!exists("BCMethod",envir=limmaGUIenvironment))
  {
		Try(BCMethod <- "subtract")
		Try(assign("BCMethod",BCMethod,limmaGUIenvironment))
  })
  Try(if (!exists("MAimported",envir=limmaGUIenvironment))
    Try(assign("MAimported",new("MAList"),limmaGUIenvironment)))
  Try(if (!exists("RawMADataWasImported",envir=limmaGUIenvironment))
    Try(assign("RawMADataWasImported",FALSE,limmaGUIenvironment)))
  Try(if (!exists("NormalizedMADataWasImported",envir=limmaGUIenvironment))
    Try(assign("NormalizedMADataWasImported",FALSE,limmaGUIenvironment)))
  
  Try(limmaDataSetNameText <- get("limmaDataSetNameText" , envir=limmaGUIenvironment))
  Try(NumParameterizations <- get("NumParameterizations", envir=limmaGUIenvironment))  
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec", envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(NumParameters <- get("NumParameters" , envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))

  Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))
  Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled") LimmaFileName <- limmaDataSetNameText) # Local assignment only 
  Try(tkwm.title(.limmaGUIglobals$ttMain,paste("LimmaGUI -",LimmaFileName)))
  Try(assign("limmaDataSetNameText",limmaDataSetNameText,limmaGUIenvironment))
  Try(tclvalue(.limmaGUIglobals$limmaDataSetNameTcl) <- limmaDataSetNameText)  

  if (NumParameterizations>0)
    for (parameterizationIndex in (1:NumParameterizations))
    {
      Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
      Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
      Try(ParamMainFitNode   <- paste("ParamMainFit.",parameterizationTreeIndex,sep=""))
      Try(ParamContrastsNode <- paste("ParamContrasts.",parameterizationTreeIndex,sep=""))
      Try(PMFNoneNode <- paste("PMFNone.",parameterizationTreeIndex,sep=""))
      Try(PMFSpotTypesNode <- paste("PMFSpotTypes.",parameterizationTreeIndex,sep=""))        
      Try(PMFMANormMethodNode <- paste("PMFMANormMethod.",parameterizationTreeIndex,sep=""))    
      Try(PMFParamsNode <- paste("PMFParams.",parameterizationTreeIndex,sep=""))
      Try(PMFLinModNode <- paste("PMFLinMod.",parameterizationTreeIndex,sep=""))
      Try(PMFLinModStatusNode <- paste("PMFLinModStatus.",parameterizationTreeIndex,sep=""))
      Try(PMFEBayesNode <- paste("PMFEBayes.",parameterizationTreeIndex,sep=""))
      Try(PMFEBayesStatusNode <- paste("PMFEBayesStatus.",parameterizationTreeIndex,sep=""))
      Try(PMFDupCorNode <- paste("PMFDupCor.",parameterizationTreeIndex,sep=""))
      Try(PMFDupCorStatusNode <- paste("PMFDupCorStatus.",parameterizationTreeIndex,sep=""))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end","root",ParameterizationNameNode ,text=ParameterizationNamesVec[parameterizationIndex],font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParameterizationNameNode,ParamMainFitNode,text="Main fit",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"1",ParameterizationNameNode,ParamContrastsNode,text="Contrasts",font=.limmaGUIglobals$limmaGUIfontTree))      
      Try(if (ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations==0)
        Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParamContrastsNode,paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".1",sep=""),text="none",font=.limmaGUIglobals$limmaGUIfontTree)))
          Try(ContrastsParameterizationTreeIndexVec <- ParameterizationList[[ParameterizationNameNode]]$ContrastsParameterizationTreeIndexVec)

      Try(if (ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations>0)
        for (contrastIndex in (1:ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations))        
        {
          Try(contrastsParameterizationTreeIndex <- ContrastsParameterizationTreeIndexVec[contrastIndex])
          Try(ContrastsParameterizationNamesNode <- paste("ContrastsParameterizationNames.",parameterizationTreeIndex,".",contrastsParameterizationTreeIndex,sep=""))
          Try(contrastsParameterizationNameText <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[contrastIndex]]$contrastsParameterizationNameText)
          Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamContrastsNode,ContrastsParameterizationNamesNode,text=contrastsParameterizationNameText,font=.limmaGUIglobals$limmaGUIfontTree))
          Try(contrastsMatrixInList <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[contrastIndex]]$contrastsMatrixInList)
          Try(contrastsMatrix <- contrastsMatrixInList$contrasts)          
          Try(ContrastsNames <- colnames(contrastsMatrix))          
          Try(NumContrasts <- ncol(contrastsMatrix))
          Try(for (contrast in (1:NumContrasts))
          {
            Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ContrastsParameterizationNamesNode,paste("Contrasts.",parameterizationIndex,".",contrastsParameterizationTreeIndex,".",contrast,sep=""),text=ContrastsNames[contrast],font=.limmaGUIglobals$limmaGUIfontTree))
          })
        })
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",ParamMainFitNode,PMFSpotTypesNode,text="Spot Type(s) Included",font=.limmaGUIglobals$limmaGUIfontTree))  
      Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)
      Try(if (numSpotTypes>0)
        for (i in (1:numSpotTypes))
        {
          if (SpotTypesForLinearModel[i]==FALSE)
              next()
          Try(NewNode <- paste("PMFSpotTypes.",parameterizationTreeIndex,".",i,sep=""))
          Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFSpotTypesNode, NewNode,text=SpotTypes[i,"SpotType"],font=.limmaGUIglobals$limmaGUIfontTree))
        })
          
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFMANormMethodNode,text="M A Normalization Method",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
      {
        Try(WithinArrayNormalizationMethod <- "printtiploess")
        Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
      })
      Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))      
      Try(if ("WithinArrayNormalizationMethod" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
        Try(WithinArrayNormalizationMethod <- (ParameterizationList[[ParameterizationNameNode]])$WithinArrayNormalizationMethod)
      else
      {
        Try(ParameterizationList[[ParameterizationNameNode]][["WithinArrayNormalizationMethod"]] <- WithinArrayNormalizationMethod)
        Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
      })      
      Try(MANormMethodValueNode <- paste("PMFMANormMethod.",parameterizationTreeIndex,".",1,sep=""))
      Try(if (ParameterizationList[[ParameterizationNameNode]][[MANormMethodValueNode]]=="Within arrays only")
        ParameterizationList[[ParameterizationNameNode]][[MANormMethodValueNode]] <- paste("Within arrays (",WithinArrayNormalizationMethod,") only",sep=""))
      Try(if (ParameterizationList[[ParameterizationNameNode]][[MANormMethodValueNode]]=="Within and between arrays")
        ParameterizationList[[ParameterizationNameNode]][[MANormMethodValueNode]] <- paste("Within arrays (",WithinArrayNormalizationMethod,") and between arrays",sep=""))
      Try(assign("ParameterizationList",ParameterizationList,limmaGUIenvironment))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",PMFMANormMethodNode, MANormMethodValueNode,
        text=(ParameterizationList[[ParameterizationNameNode]])[[MANormMethodValueNode]],
      font=.limmaGUIglobals$limmaGUIfontTree))        
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFParamsNode,text="Parameters",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFLinModNode,text="Linear Model Fit",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFLinModNode,PMFLinModStatusNode,text=
          (ParameterizationList[[ParameterizationNameNode]])[[PMFLinModStatusNode]],font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFEBayesNode,text="Empirical Bayes Statistics",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFEBayesNode,PMFEBayesStatusNode,text=
          (ParameterizationList[[ParameterizationNameNode]])[[PMFEBayesStatusNode]],font=.limmaGUIglobals$limmaGUIfontTree)) 
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",ParamMainFitNode,PMFDupCorNode,text="Duplicate Correlation",font=.limmaGUIglobals$limmaGUIfontTree))
      Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"0",PMFDupCorNode,PMFDupCorStatusNode,text=
          (ParameterizationList[[ParameterizationNameNode]])[[PMFDupCorStatusNode]],font=.limmaGUIglobals$limmaGUIfontTree)) 
      Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))      
      Try(if (NumParameters>0)
        for (i in (1:NumParameters))
        {
          Try(NewNode <- paste("PMFParams.",parameterizationIndex,".",i,sep=""))
          Try(tkinsert(.limmaGUIglobals$ParameterizationTREE,"end",PMFParamsNode, NewNode,text=ParameterNamesVec[i],font=.limmaGUIglobals$limmaGUIfontTree))
        })
    } 
      
  Try(tkdelete(.limmaGUIglobals$mainTree,"RG.Status"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"BC.Status"))  
  Try(tkdelete(.limmaGUIglobals$mainTree,"WeightingType.Status"))
  Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))  
  Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))    
  Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))      
  Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))        
  Try(tkdelete(.limmaGUIglobals$mainTree,"Layout.Status"))          
  Try(tkdelete(.limmaGUIglobals$mainTree,"Parameterizations"))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","root","Parameterizations" ,text="Parameterizations",font=.limmaGUIglobals$limmaGUIfontTree))  
  
  Try(RG.Available     <- get("RG.Available" , envir=limmaGUIenvironment))  
  Try(MA.Available     <- get("MA.Available" , envir=limmaGUIenvironment))    
  Try(Layout.Available <- get("Layout.Available" , envir=limmaGUIenvironment))      
  Try(WeightingType    <- get("WeightingType", envir=limmaGUIenvironment))
	Try(if (!exists("BCMethod",envir=limmaGUIenvironment))
	{
		Try(BCMethod <- "subtract")
		Try(assign("BCMethod",BCMethod,limmaGUIenvironment))
	})
	Try(BCMethod <- get("BCMethod",envir=limmaGUIenvironment))

  Try(tkinsert(.limmaGUIglobals$mainTree,"end","BC","BC.Status",text=BCMethod,font=.limmaGUIglobals$limmaGUIfontTree))
  Try(tkinsert(.limmaGUIglobals$mainTree,"end","WeightingType","WeightingType.Status",text=WeightingType,font=.limmaGUIglobals$limmaGUIfontTree))  
  Try(if (RG.Available)  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","RG","RG.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))    )
  Try(if (MA.Available$Raw)
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))  )
  Try(if (MA.Available$WithinArrays)  
  {
    Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
    {
      Try(WithinArrayNormalizationMethod <- "printtiploess")
      Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
    })
    Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text=paste("Available (using ",WithinArrayNormalizationMethod,")",sep=""),font=.limmaGUIglobals$limmaGUIfontTree))
  }
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))  )
  Try(if (MA.Available$BetweenArrays)  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))  )
  Try(if (MA.Available$Both)  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))  )
  Try(if (Layout.Available)  
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Layout","Layout.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))  )
  Try(if (NumParameterizations>0)
  {
    for (i in (1:NumParameterizations))
    {
      Try(ParameterizationsStatusNameNode <- paste("Parameterizations.Status.",i,sep=""))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations",ParameterizationsStatusNameNode ,text=ParameterizationNamesVec[i],font=.limmaGUIglobals$limmaGUIfontTree))
    }
  }
  else
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Parameterizations","Parameterizations.Status.1" ,text="None",font=.limmaGUIglobals$limmaGUIfontTree)))

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

}

SaveLimmaFile <- function()
{
  LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment)
  if (LimmaFileName=="Untitled")
  {
    SaveAsLimmaFile()
    try(tkfocus(.limmaGUIglobals$ttMain),silent=TRUE)
    return()
  }
  # Don't give an error if main window has been destroyed.
  try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"),silent=TRUE)  
#  tkmessageBox(message="About to save Limma File! (0)")  
  Try(save(list = ls(envir=limmaGUIenvironment), file=LimmaFileName, envir=limmaGUIenvironment))  
#  tkmessageBox(message="Limma File Saved! (1)")  
  try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"),silent=TRUE)
  try(tkfocus(.limmaGUIglobals$ttMain),silent=TRUE)
#  tkmessageBox(message="Limma File Saved! (2)")    
}    

SaveAsLimmaFile <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(LimmaFileName <- get("LimmaFileName",envir=limmaGUIenvironment))
  Try(if (LimmaFileName=="Untitled" && limmaDataSetNameText!="Untitled") LimmaFileName <- limmaDataSetNameText) # Local assignment only
  Try(tempLimmaFileName <- tclvalue(tkgetSaveFile(initialfile=LimmaFileName,filetypes="{{Limma Files} {.lma}} {{All files} *}")))
  if (!nchar(tempLimmaFileName)) 
  {
    try(tkfocus(.limmaGUIglobals$ttMain),silent=TRUE)
    return()
  }
  len <- nchar(tempLimmaFileName)
  if (len<=4)
      tempLimmaFileName <- paste(tempLimmaFileName,".lma",sep="")
  else if (substring(tempLimmaFileName,len-3,len)!=".lma")
        tempLimmaFileName <- paste(tempLimmaFileName,".lma",sep="")
  Try(LimmaFileName <- tempLimmaFileName)
  Try(assign("LimmaFileName",LimmaFileName,limmaGUIenvironment))
  # .limmaGUIglobals$ttMain may have been destroyed
  e <- try(tkfocus(.limmaGUIglobals$ttMain),silent=TRUE)
  if (!inherits(e, "try-error"))
    Try(tkwm.title(.limmaGUIglobals$ttMain,paste("LimmaGUI -",LimmaFileName)))
  try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"),silent=TRUE)    
  Try(save(list = ls(envir=limmaGUIenvironment), file=LimmaFileName, envir=limmaGUIenvironment))    
  try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"),silent=TRUE)
  try(tkfocus(.limmaGUIglobals$ttMain),silent=TRUE)
}

AboutLimmaGUI <- function()
{
    Try(tkmessageBox(title="About limmaGUI",message=paste("This is limmaGUI Version ",getPackageVersion("limmaGUI"),
                              ", using limma Version ",getPackageVersion("limma"),".  The limma package was developed by Gordon Smyth and the Graphical User Interface (GUI) was developed by James Wettenhall.",sep=""),type="ok",icon="info"))
}
NormalizeHelp <- function()
{
  Try(help("normalizeWithinArrays",htmlhelp=TRUE))
}

GetNormalizationMethod <- function()
{
  Try(ttGetNormalizationMethod<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttGetNormalizationMethod,"Normalization Method"))
  Try(tkwm.deiconify(ttGetNormalizationMethod))
  Try(tkgrab.set(ttGetNormalizationMethod))
  Try(tkframe1 <- tkframe(ttGetNormalizationMethod,borderwidth=2))
  Try(tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2))
  Try(tkframe4<-tkframe(tkframe1,borderwidth=2))

  Try(tkgrid(tklabel(tkframe1,text="    ")))

  Try(tkgrid(tklabel(tkframe2,text="Choose a method for within-array normalization.",font=.limmaGUIglobals$limmaGUIfont2),column=2,rowspan=1,columnspan=2,sticky="w"))

  Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
  {
    Try(WithinArrayNormalizationMethod <- "printtiploess")
    Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
  })
  Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))

  Try(methnorm <- tclVar(WithinArrayNormalizationMethod))

#  Try(none.but <- tkradiobutton(tkframe2,text="None",variable=methnorm,value="none",font=.limmaGUIglobals$limmaGUIfont2))
  Try(median.but <- tkradiobutton(tkframe2,text="Median",variable=methnorm,value="median",font=.limmaGUIglobals$limmaGUIfont2))
  Try(global.but <- tkradiobutton(tkframe2,text="Global loess",variable=methnorm,value="loess",font=.limmaGUIglobals$limmaGUIfont2))
  Try(printtip.but <- tkradiobutton(tkframe2,text="Print-tip group loess",variable=methnorm,value="printtiploess",font=.limmaGUIglobals$limmaGUIfont2))
  Try(composite.but <- tkradiobutton(tkframe2,text="Composite",variable=methnorm,value="composite",font=.limmaGUIglobals$limmaGUIfont2))
  Try(robustspline.but <- tkradiobutton(tkframe2,text="Robust Spline",variable=methnorm,value="robustspline",font=.limmaGUIglobals$limmaGUIfont2))
    
#  Try(tkgrid(none.but,column=2))
  Try(tkgrid(median.but,column=2))
  Try(tkgrid(global.but,column=2))
  Try(tkgrid(printtip.but,column=2))
  Try(tkgrid(composite.but,column=2))
  Try(tkgrid(robustspline.but,column=2))
#  Try(tkgrid.configure(none.but,median.but,global.but,printtip.but,composite.but,robustspline.but,sticky="w"))
  Try(tkgrid.configure(median.but,global.but,printtip.but,composite.but,robustspline.but,sticky="w"))
  Try(tkgrid(tkframe2))
  Try(NewNormalizationMethod <- "")
  onOK <- function()
  {
    Try(NewNormalizationMethod<<-tclvalue(methnorm));
    Try(tkgrab.release(ttGetNormalizationMethod));
    Try(tkdestroy(ttGetNormalizationMethod))
    Try(if (NewNormalizationMethod==WithinArrayNormalizationMethod)
      return())    
    Try(WithinArrayNormalizationMethod <- NewNormalizationMethod)
    Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
    Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
    Try(MA.Available$WithinArrays <- FALSE)
    Try(MA.Available$Both <- FALSE)
    Try(MA.Available$BetweenArrays <- FALSE)
    Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
    
    Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
    Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))
    Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))                   
    Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))
    Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Not Available",font=.limmaGUIglobals$limmaGUIfontTree))        

    Try(tkfocus(.limmaGUIglobals$ttMain))  
  }
  Try(OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=function(){Try(tkgrab.release(ttGetNormalizationMethod));Try(tkdestroy(ttGetNormalizationMethod));NewNormalizationMethod<-"";Try(tkfocus(.limmaGUIglobals$ttMain))},font=.limmaGUIglobals$limmaGUIfont2))
  Try(Help.but <- tkbutton(tkframe4,text=" Help ",command=NormalizeHelp,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframe4,text="                    ")))
  Try(tkgrid(OK.but,Cancel.but,Help.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="e"))
  Try(tkgrid.configure(Help.but,sticky="e"))  
  Try(tkgrid(tklabel(tkframe4,text="       ")))
  Try(tkgrid(tkframe4))
  Try(tkgrid(tkframe1))
  Try(tkfocus(OK.but))
  Try(tkbind(ttGetNormalizationMethod, "<Return>",onOK))
  Try(tkbind(ttGetNormalizationMethod, "<Destroy>", function() {Try(tkgrab.release(ttGetNormalizationMethod));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttGetNormalizationMethod))

  Try(tkdestroy(ttGetNormalizationMethod))  

# This return value below is not used.  The function above is used for its effect
# on WithinArrayNormalizationMethod in limmaGUIenvironment
  return(NewNormalizationMethod)
}

NormalizeNow <- function()
{
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
  
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   

  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
  {
    Try(WithinArrayNormalizationMethod <- "printtiploess")
    Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
  })
  Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))

  
  if (ArraysLoaded==FALSE)
  {
      Try(tkmessageBox(title="Normalization",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))      
      return()
  }
  
  if (NormalizedMADataWasImported==TRUE)
  {
      Try(tkmessageBox(title="Normalization",message="Normalized data was imported.  Impossible to recover raw data to renormalize.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))      
      return()
  }

  Try(RG <- get("RG",envir=limmaGUIenvironment))
  Try(SetLayoutParamReturnVal <- 1)
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
  Try(if (length(maLayout)==0) SetLayoutParamReturnVal <-Try(SetLayoutParameters()))
  Try(if (SetLayoutParamReturnVal==0) return())
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))

  Try(NormalizeWithinArraysMB <-tkmessageBox(title="Normalization Within Arrays",message="Normalize Within Arrays?",type="yesnocancel",icon="question",default="yes"))
  Try(WhetherToNormalizeWithinArrays <- tclvalue(NormalizeWithinArraysMB))
  if (WhetherToNormalizeWithinArrays=="cancel")
      return()
  Try(NormalizeBetweenArraysMB <-tkmessageBox(title="Normalization Between Arrays",message="Normalize Between Arrays?",type="yesnocancel",icon="question",default="no"))
  Try(WhetherToNormalizeBetweenArrays <- tclvalue(NormalizeBetweenArraysMB))
  if (WhetherToNormalizeBetweenArrays=="cancel")
    return()

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(WeightingType <- get("WeightingType",envir=limmaGUIenvironment))

  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))

	if (WhetherToNormalizeWithinArrays=="yes")
	{
			if (MA.Available$WithinArrays)
			{
				Try(MA <- get("MAwithinArrays",envir=limmaGUIenvironment))
				Try(assign("MA",MA,limmaGUIenvironment))
			}
			else          
			{
				if (WeightingType == "none")
					Try (MA <- normalizeWithinArrays(RG,maLayout,method=WithinArrayNormalizationMethod))
				else
					Try(MA <- normalizeWithinArrays(RG,weights=RG$weights,maLayout,method=WithinArrayNormalizationMethod))
				Try(assign("MA",MA,limmaGUIenvironment))        
				Try(assign("MAwithinArrays",MA,limmaGUIenvironment))
				Try(MA.Available$WithinArrays <- TRUE)
				Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
				Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
				Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text=paste("Available (using ",WithinArrayNormalizationMethod,")",sep=""),font=.limmaGUIglobals$limmaGUIfontTree))
			}
	}
	else
	{
			if (MA.Available$Raw)
			{
				Try(MA <- get("MAraw",envir=limmaGUIenvironment))
				Try(assign("MA",MA,limmaGUIenvironment))
			}
			else          
			{
				Try (MA <- MA.RG(RG))
				Try(assign("MA",MA,limmaGUIenvironment))        
				Try(assign("MAraw",MA,limmaGUIenvironment))
				Try(MA.Available$Raw <- TRUE)
				Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
				Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
				Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
			}        
	}
	Try(MA <- get("MA",envir=limmaGUIenvironment))

	if (WhetherToNormalizeBetweenArrays=="yes") 
	{
		if (WhetherToNormalizeWithinArrays=="yes")
		{
			if (MA.Available$Both)
			{
				Try(MA <- get("MAboth",envir=limmaGUIenvironment))
				Try(assign("MA",MA,limmaGUIenvironment))                    
			}
			else
			{
				Try (MA <- normalizeBetweenArrays(MA))
				Try(assign("MA",MA,limmaGUIenvironment))        
				Try(assign("MAboth",MA,limmaGUIenvironment))
				Try(MA.Available$Both <- TRUE)
				Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
				Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))
				Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))                   
			}

		}
		else
		{
			if (MA.Available$BetweenArrays)
			{
				Try(MA <- get("MAbetweenArrays",envir=limmaGUIenvironment))
				Try(assign("MA",MA,limmaGUIenvironment))                    
			}
			else
			{
				Try (MA <- normalizeBetweenArrays(MA))
				Try(assign("MA",MA,limmaGUIenvironment))        
				Try(assign("MAbetweenArrays",MA,limmaGUIenvironment))
				Try(MA.Available$BetweenArrays <- TRUE)
				Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
				Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))
				Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))        
			}        
		}
	}

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

}

AboutNormalization <- function()
{
  Try(winTitle<-"About Normalization")
  Try(message<-paste("Almost all cDNA data should be normalized within arrays.\n",
    "The default method of print-tip-group loess should be suitable for most data.\n",
    "If there is a significant difference in scale between the arrays (as seen by an M Box Plot by slide),\n",
    "then the data should be normalized between arrays as well.\n\n",
    
    "Use the M Box Plots and the M A Plots (with lowess curves) to see the effects of the normalization.\n\n",
    
    "The M A plot (with lowess curves) normalizes only for a single array with print-tip-group lowess\n",
    "normalization using the sma package, and the results are discarded after displaying the plot.\n",
    "This is designed to give a quick (but not as accurate) impression of the effects of normalization on\n",
    "one slide.\n\n",
    
    "The M Box Plot and the Color-Coded M A Plot both use the same normalization methods (from the\n",
    "limma package) which are used in the linear model. Here, you have to normalize within all arrays\n",
    "at once (which can be slow the first time), but the results will be recorded in the left status\n",
    "window, and as long as you don't change the within-array normalization method, your data will not\n",
    "need to be normalized again.  If you ask for a plot or a linear model requiring normalized M and A\n",
    "values, it should be much quicker the second time.\n",sep=""))
    
  Try(ttAboutNormalization  <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttAboutNormalization,winTitle))
  Try(tkwm.deiconify(ttAboutNormalization))
  Try(tkgrab.set(ttAboutNormalization))
  Try(scr <- tkscrollbar(ttAboutNormalization, repeatinterval=5,
                         command=function(...)tkyview(txt,...)))
  Try(txt <- tktext(ttAboutNormalization,bg="white",yscrollcommand=function(...)tkset(scr,...)))
  Try(tkgrid(txt,scr))
  Try(tkgrid.configure(scr,sticky="ns"))
  Try(tkgrid.configure(txt,sticky="nsew"))
  Try(tkinsert(txt,"end",message))
  Try(tkconfigure(txt, state="disabled"))
  Try(tkfocus(txt))
  Try(onOK <- function() {Try(tkgrab.release(ttAboutNormalization));tkdestroy(ttAboutNormalization)})
  Try(OK.but <- tkbutton(ttAboutNormalization,text="  Close  ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))  
  Try(tkgrid(tklabel(ttAboutNormalization,text="    ")))
  Try(tkgrid(OK.but))
  Try(tkgrid(tklabel(ttAboutNormalization,text="    ")))    
  Try(tkfocus(OK.but))
  Try(tkwait.window(ttAboutNormalization))
}

ExportMvalues <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
  
  Try(if (NormalizedMADataWasImported==FALSE)
  {
    Try(Which <- WithinBetweenOrBoth("M"))
    Try(if (Which=="") return())
		Try(if (MA.Available[[Which]]==FALSE) 
		{
			tkmessageBox(title="MA Object Unavailable",message="The MA object you requested is unavailable.  Click on \"Normalize / Update M and A\" from the \"Normalization\" menu.")
			return()
		})
		Try(if (Which=="Raw")           MA <- get("MAraw",envir=limmaGUIenvironment))
		Try(if (Which=="WithinArrays")  MA <- get("MAwithinArrays",envir=limmaGUIenvironment))  
		Try(if (Which=="BetweenArrays") MA <- get("MAbetweenArrays",envir=limmaGUIenvironment))    
		Try(if (Which=="Both")          MA <- get("MAboth",envir=limmaGUIenvironment))      
  }
  else
    Try(MA <- get("MAimported",envir=limmaGUIenvironment)))

	Try(FileName <- tclvalue(tkgetSaveFile(initialfile=paste(limmaDataSetNameText,"_M.txt",sep=""),filetypes="{{Tab-Delimited Text Files} {.txt}} {{All files} *}")))
	Try(if (!nchar(FileName)) return())
	Try(len <- nchar(FileName))
	if (len<=4)
		Try(FileName <- paste(FileName,".txt",sep=""))
	else if (substring(FileName,len-3,len)!=".txt")
				Try(FileName <- paste(FileName,".txt",sep=""))

	Try(write.table(MA$M,file=FileName,sep="\t",quote=FALSE,col.names=TRUE,row.names=FALSE))
}


ExportAvalues <- function()
{
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))     
  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))  

  Try(if (NormalizedMADataWasImported==FALSE)
  {
    Try(Which <- WithinBetweenOrBoth("A"))
    Try(if (Which=="") return())
		Try(if (MA.Available[[Which]]==FALSE) 
		{
			tkmessageBox(title="MA Object Unavailable",message="The MA object you requested is unavailable.  Click on \"Normalize / Update M and A\" from the \"Normalization\" menu.")
			return()
		})
		Try(if (Which=="Raw")           MA <- get("MAraw",envir=limmaGUIenvironment))
		Try(if (Which=="WithinArrays")  MA <- get("MAwithinArrays",envir=limmaGUIenvironment))  
		Try(if (Which=="BetweenArrays") MA <- get("MAbetweenArrays",envir=limmaGUIenvironment))    
		Try(if (Which=="Both")          MA <- get("MAboth",envir=limmaGUIenvironment))      
  }
  else
    Try(MA <- get("MAimported",envir=limmaGUIenvironment)))

  	Try(FileName <- tclvalue(tkgetSaveFile(initialfile=paste(limmaDataSetNameText,"_A.txt"),filetypes="{{Tab-Delimited Text Files} {.txt}} {{All files} *}")))
	Try(if (!nchar(FileName)) return())
	Try(len <- nchar(FileName))
	if (len<=4)
		Try(FileName <- paste(FileName,".txt",sep=""))
	else if (substring(FileName,len-3,len)!=".txt")
				Try(FileName <- paste(FileName,".txt",sep=""))

	Try(write.table(MA$A,file=FileName,sep="\t",quote=FALSE,col.names=TRUE,row.names=FALSE))
}


WithinBetweenOrBoth <- function(MorA="M")
{
  Try(ttWithinBetweenOrBoth <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttWithinBetweenOrBoth,paste("Export",MorA,"values.")))
  Try(tkwm.deiconify(ttWithinBetweenOrBoth))
  Try(tkgrab.set(ttWithinBetweenOrBoth))
  Try(tkfocus(ttWithinBetweenOrBoth))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    ")))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    "),tklabel(ttWithinBetweenOrBoth,text=paste("Which",MorA,"values should be exported"),font=.limmaGUIglobals$limmaGUIfont2),tklabel(ttWithinBetweenOrBoth,text="    ")))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    "),tklabel(ttWithinBetweenOrBoth,text="as tab-delimited text?",font=.limmaGUIglobals$limmaGUIfont2),tklabel(ttWithinBetweenOrBoth,text="    ")))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    ")))
  Try(WithinBetweenOrBothTcl <- tclVar("WithinArrays"))
  Try(frame1 <- tkframe(ttWithinBetweenOrBoth,relief="groove",borderwidth="2"))
  Try(tkgrid(tkradiobutton(frame1,text="Raw (Unnormalized)",variable=WithinBetweenOrBothTcl,value="Raw",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))
  Try(tkgrid(tkradiobutton(frame1,text="Within-Array Normalized",variable=WithinBetweenOrBothTcl,value="WithinArrays",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))
  Try(tkgrid(tkradiobutton(frame1,text="Between-Array Normalized",variable=WithinBetweenOrBothTcl,value="BetweenArrays",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))  
  Try(tkgrid(tkradiobutton(frame1,text="Within-Array and Between-Array Normalized",variable=WithinBetweenOrBothTcl,value="Both",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    "),frame1))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    ")))
  Try(tkframeOKCancel <- tkframe(ttWithinBetweenOrBoth))
  Try(ReturnVal <- "")
  Try(onOK <- function() { Try(ReturnVal <<- tclvalue(WithinBetweenOrBothTcl)); Try(tkdestroy(ttWithinBetweenOrBoth));Try(tkfocus(.limmaGUIglobals$ttMain))})
  Try(onCancel <- function() { Try(tkdestroy(ttWithinBetweenOrBoth));Try(ReturnVal <- "")})
  Try(OK.but     <- tkbutton(tkframeOKCancel,text="   OK   ",command=onOK,    font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <- tkbutton(tkframeOKCancel,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframeOKCancel,text="    "),columnspan=2))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))  
  Try(tkgrid(tklabel(tkframeOKCancel,text="    "),columnspan=2))
  Try(tkgrid(tklabel(ttWithinBetweenOrBoth,text="    "),tkframeOKCancel))
  
  Try(tkbind(ttWithinBetweenOrBoth, "<Destroy>", function() {Try(tkgrab.release(ttWithinBetweenOrBoth));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttWithinBetweenOrBoth))  
  
  return (ReturnVal)
}

GetGeneLabelsOptions <- function()
{
  Try(ttGeneLabelsOptions <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGeneLabelsOptions))
  Try(tkgrab.set(ttGeneLabelsOptions))
  Try(tkfocus(ttGeneLabelsOptions))
  Try(tkwm.title(ttGeneLabelsOptions,"D.E. Gene Labels"))
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       ")))
  Try(HowManyDEGenesTcl <- tclVar(paste(10)))
  Try(entry.HowManyDEGenes<-tkentry(ttGeneLabelsOptions,width="12",font=.limmaGUIglobals$limmaGUIfont2,
    textvariable=HowManyDEGenesTcl,bg="white"))
  Try(GeneLabelsMaxLengthTcl <- tclVar(paste(10)))
  Try(entry.GeneLabelsMaxLength<-tkentry(ttGeneLabelsOptions,width="12",font=.limmaGUIglobals$limmaGUIfont2,
    textvariable=GeneLabelsMaxLengthTcl,bg="white"))

  Try(ReturnVal <- list())
  onOK <- function()
  {
    Try(tkgrab.release(ttGeneLabelsOptions))
    Try(tkdestroy(ttGeneLabelsOptions))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    Try(galColName <- tclvalue(IDorNameTcl))
    Try(if (galColName=="Other")
      galColName <- tclvalue(OtherTcl))
    Try(ReturnVal <<- list(HowManyDEGeneLabels=as.integer(tclvalue(HowManyDEGenesTcl)),
                           GeneLabelsMaxLength=as.integer(tclvalue(GeneLabelsMaxLengthTcl)),
                           IDorName=galColName))
  }
  onCancel <- function() {Try(tkgrab.release(ttGeneLabelsOptions));Try(tkdestroy(ttGeneLabelsOptions));Try(tkfocus(.limmaGUIglobals$ttMain)); ReturnVal <<- list()}        

  Try(OK.but <-tkbutton(ttGeneLabelsOptions,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttGeneLabelsOptions,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))


  Try(pleaseLabel <- tklabel(ttGeneLabelsOptions,text="Please select D.E. gene labeling options.",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="    "),pleaseLabel,sticky="w"))
  Try(tkgrid.configure(pleaseLabel,columnspan=2))
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       ")))
  Try(numberLabel <- tklabel(ttGeneLabelsOptions,text="Number of labeled differentially expressed genes: ",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(numberLabel,row=3,column=1,columnspan=2))
  Try(tkgrid(entry.HowManyDEGenes,row=3,column=3,sticky="w"))
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="    "),row=3,column=4))
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),row=4))
  Try(tkgrid.configure(entry.HowManyDEGenes,sticky="w"))
  Try(maximumLabel <- tklabel(ttGeneLabelsOptions,text="Maximum length of gene labels: ",font=.limmaGUIglobals$limmaGUIfont2))

  Try(tkgrid(maximumLabel,row=5,column=1,columnspan=2))
  Try(tkgrid(entry.GeneLabelsMaxLength,row=5,column=3,sticky="w"))
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="    "),row=5,column=4))
  
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),row=6))
	Try(IDorNameTcl <- tclVar("Name"))
  Try(rb1 <- tkradiobutton(ttGeneLabelsOptions,text="Use Gene ID",variable=IDorNameTcl,value="ID",font=.limmaGUIglobals$limmaGUIfont2))
	Try(rb2 <- tkradiobutton(ttGeneLabelsOptions,text="Use Gene Name",variable=IDorNameTcl,value="Name",font=.limmaGUIglobals$limmaGUIfont2))
	Try(rb3 <- tkradiobutton(ttGeneLabelsOptions,text="Use Other:",variable=IDorNameTcl,value="Other",font=.limmaGUIglobals$limmaGUIfont2))


  Try(OtherTcl <- tclVar("Other"))
  Try(entry.Other <-tkentry(ttGeneLabelsOptions,width="20",textvariable=OtherTcl,font=.limmaGUIglobals$limmaGUIfont2))  

	Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),rb1,row=7))
	Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),rb2,row=8))	
	Try(tkgrid.configure(rb1,sticky="w",columnspan=2))
	Try(tkgrid.configure(rb2,sticky="w",columnspan=2))	

	Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),rb3,entry.Other,row=9))		
	Try(tkgrid.configure(rb3,sticky="w",columnspan=1))		
	Try(tkgrid.configure(entry.Other,sticky="w"))			
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),row=10))
  
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="       "),OK.but,Cancel.but,row=11))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))  
  Try(tkgrid(tklabel(ttGeneLabelsOptions,text="    "),row=12))

  Try(tkfocus(ttGeneLabelsOptions))
  
  Try(tkbind(ttGeneLabelsOptions, "<Destroy>", function() {Try(tkgrab.release(ttGeneLabelsOptions));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGeneLabelsOptions))

  return(ReturnVal)

}


MAPlotAvg <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(gal <- get("gal",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment))   
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(ndups   <- get("ndups",  envir=limmaGUIenvironment))  
  Try(spacing   <- get("spacing",envir=limmaGUIenvironment))       # Global version

  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="M A Plot (with fitted M values)",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }
  
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="M A Plot (with fitted M values)",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return()    )
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  Try(spacing <- GetReducedDuplicateSpacing(parameterizationTreeIndex))

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="M A Plot With Fitted M Values",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model Fit from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }
  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))

  GetCoefReturnVal <- GetCoef(parameterizationTreeIndex)
  if (GetCoefReturnVal$coefIndex==0) return()
  Try(coef <- (GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]])$coefOrContrastIndex)
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))

  Try(GeneLabelsOptions <- GetGeneLabelsOptions())
  Try(if (length(GeneLabelsOptions)==0) return())
  Try(numDEgenesLabeled   <- GeneLabelsOptions$HowManyDEGeneLabels)
  Try(GeneLabelsMaxLength <- GeneLabelsOptions$GeneLabelsMaxLength)
  Try(IDorName <- GeneLabelsOptions$IDorName)  

	Try(ShowColorCodedSpotTypes <- tclvalue(tkmessageBox(title="Color Coded Spot Types",message="Show color-coded spot types?",icon="question",type="yesnocancel")))
	Try(if (ShowColorCodedSpotTypes=="cancel") return())
	Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
	Try(SpotTypesForLinearModel <- (ParameterizationList[[ParameterizationNameNode]])$SpotTypesForLinearModel)
	Try(SelectedSpotTypes <- SpotTypes[SpotTypesForLinearModel,])
	Try(showLegend <- TRUE)
	Try(if (ShowColorCodedSpotTypes=="yes")
	{    
		Try(PlotSymbols <- SelectPlotSymbols(SelectedSpotTypes))
		if (length(PlotSymbols)==0)
				return()
		Try(showLegend  <- PlotSymbols$showLegend)
		Try(PlotSymbols <- PlotSymbols$PlotSymbols)

		Try(SpotTypeStatus <- get("SpotTypeStatus", envir=limmaGUIenvironment))
		Try(numSelectedSpotTypes <- nrow(SelectedSpotTypes))

		Try(pchAllNumeric <- TRUE)       
		Try(pchAllCharacter <- TRUE)
		for (i in (1:numSelectedSpotTypes))
		{
				Try(if (PlotSymbols[[i]]$pchIsNumeric==TRUE)
						Try(PlotSymbols[[i]]$pch <- as.numeric(PlotSymbols[[i]]$pch)))
				Try(pchAllNumeric <- (pchAllNumeric && PlotSymbols[[i]]$pchIsNumeric))
				Try(pchAllCharacter <- (pchAllCharacter && (!PlotSymbols[[i]]$pchIsNumeric)))
		}      

		Try(cex <- c())
		Try(colVec <- c())
		Try(if (pchAllNumeric || pchAllCharacter)
				Try(pch <- c())
		else
				Try(pch <- list()))

		for (i in (1:numSelectedSpotTypes))
		{
				Try(cex[i] <- PlotSymbols[[i]]$cex)
				Try(colVec[i] <- PlotSymbols[[i]]$col)  
				Try(if (pchAllNumeric || pchAllCharacter)
						Try(pch[i] <- PlotSymbols[[i]]$pch)
				else
						Try(pch[[i]] <- PlotSymbols[[i]]$pch))
		}      
		Try(values <- SelectedSpotTypes$SpotType)  
	})
  
  Try(plotTitle <- paste("Average MA Plot showing DE genes for",ParameterNamesVec[coef]))
  
  Try(plotLabels <- GetPlotLabels(plotTitle,"mean(A)","M"))
  Try(if (length(plotLabels)==0) return())
  Try(plotTitle <- plotLabels$plotTitle)
  Try(xLabel    <- plotLabels$xLabel)
  Try(yLabel    <- plotLabels$yLabel)

  Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
    Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
  else
    Try(genelist <- get("genelist",limmaGUIenvironment)))   

  Try(ContrastParameterizationIndex <- GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]]$ContrastParameterizationIndex)
  
  Try(Amatrix <- NULL)
  Try(if ("Amatrix" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
    Amatrix <- (ParameterizationList[[ParameterizationNameNode]])$Amatrix)

  Try(if (GetCoefReturnVal$parameterIsFromMainFit)
  {
    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  }
  else
  {
    Try(fit <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$fit)
    Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)    
    Try(ParameterNamesVec <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts))
    Try(NumParameters <- length(ParameterNamesVec))
  }) 
    
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))      
  
  Try(if (is.null(Amatrix))
  {                                                           
    Try(MA <- get("MA",envir=limmaGUIenvironment))
    Try(A <- MA$A)
    Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
    Try(numSpotTypes <- nrow(SpotTypes))
    Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
    Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
    Omit <- ""
    count <- 0
    Try(for (i in (1:numSpotTypes))
    {
      if (SpotTypesForLinearModel[i]==TRUE)
        next()
      count <- count + 1
      if (count>1)
        Omit <-paste(Omit,"|")
      else
        Omit <- "("  
      Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
    })  
    Try(if (nchar(Omit)>0)
    {     
      Try(Omit <- paste(Omit,")"))  
      Try(Omit <- eval(parse(text=Omit)))
      Try(A <- unwrapdups(A[!Omit,],ndups=ndups,spacing=spacing))
    }
    else
      Try(A <- unwrapdups(A,ndups=ndups,spacing=spacing)))
 }
 else
      Try(A <- unwrapdups(Amatrix,ndups=ndups,spacing=spacing)))

  Try(meanA <- c())

  for (i in (1:nrow(A))) 
  {
    Try(meanA[i] <- mean(A[i,]))
  }

  Try(A <- meanA)

  Try(if (NumParameters>1) 
    Try(M <- fit$coefficients[,coef])
  else 
    Try(M <- fit$coefficients))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(if (numDEgenesLabeled>0)
  {
    Try(if (NumParameters>1) 
      Try(ord <- order(eb$lods[,coef],decreasing=TRUE))
    else 
      Try(ord <- order(eb$lods,decreasing=TRUE)))
    Try(topGenes <- ord[1:numDEgenesLabeled])
  })
  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
   Try(cexScalar <- 0.3)
  else
    Try(cexScalar <- 0.1))
  Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)
  plotAvgMA <- function()
  {
    Try(opar<-par(bg="white"))

    Try(if (ShowColorCodedSpotTypes=="yes")
      Try(plot(A,M,pch=16,cex=0.3,xlab=xLabel,col="white",ylab=yLabel,main=plotTitle))
    else
      Try(plot(A,M,pch=16,cex=cexScalar,xlab=xLabel,ylab=yLabel,main=plotTitle)))
    Try(if (numDEgenesLabeled>0)      
      Try(text(A[topGenes],M[topGenes],labels=substr(as.character(genelist[topGenes,IDorName]),1,GeneLabelsMaxLength),cex=0.8,col="blue")))
    Try(if (ShowColorCodedSpotTypes=="yes") 
    {
      Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
#      Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
#     Try(PointTypes    <- SpotTypes$SpotType)
#     Try(PointColors   <- SpotTypes$Color)
#     Try(numPointTypes <- length(PointTypes))
#     Try(cex           <- rep(0.6,numPointTypes))
#     Try(for (i in (1:numPointTypes))
#       if (tolower(PointTypes[i])=="gene"||PointTypes[i]=="cDNA")
#       {
#         Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
#           cex[i] <- 0.3
#         else
#           cex[i] <- 0.1)
#       })
#     Try(values <- PointTypes)
#     Try(colVec <- PointColors)
      Try(numPointTypes <- nrow(SelectedSpotTypes))
      Try(pch <- as.list(pch))
      Try(cex <- rep(cex,length=numPointTypes))
      Try(for (i in (1:numPointTypes))
      {
        Try(if (SpotTypesForLinearModel[i]==FALSE)    
          next())
        Try(sel <- SpotTypeStatus == SelectedSpotTypes$SpotType[i])
        Try(points(A[sel],M[sel],col=colVec[i],pch=pch[[i]],cex=cex[i]))
      })
      Try(if (showLegend)
        Try(legend(min(A, na.rm = TRUE), pch = 16,
                max(M, na.rm = TRUE), legend = values, col = colVec, 
                cex = 0.9)))

    
    })      
    Try(tempGraphPar <- par(opar))
  }

   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))

  tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")    
  Try(tkfocus(.limmaGUIglobals$ttMain))  
  Try(ttAvgMAPlot <- tktoplevel(.limmaGUIglobals$ttMain))    
  Try(tkwm.title(ttAvgMAPlot,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttAvgMAPlot,plotAvgMA,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttAvgMAPlot,img=img))
  Try(SetupPlotMenus(tt=ttAvgMAPlot,initialfile=paste(limmaDataSetNameText,"MAPlotAvg",ParameterNamesVec[coef],sep=""),
                 plotFunction=plotAvgMA,img=img))
  
  tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")  
  Try(tkgrid(img))
  Try(tkfocus(ttAvgMAPlot))
}

MMPlot <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))  
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(gal <- get("gal",envir=limmaGUIenvironment)) 
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))     
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="M M Plot (with fitted M values)",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="M M Plot (with fitted M values)",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="M M Plot With Fitted M Values",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  if (NumParameters<=1) 
  {
      tkmessageBox(title="M M Plot With Fitted M Values",message="There is only one parameter in the linear model fit.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  } 
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ParameterNamesVec1  <- GetParameterNames(parameterizationTreeIndex))
  Try(ParameterNamesVec2  <- GetParameterNames(parameterizationTreeIndex))
  GetCoefReturnVal1 <- GetCoef(parameterizationTreeIndex,"first")
  if (GetCoefReturnVal1$coefIndex==0) return()
  Try(coef1 <- (GetCoefReturnVal1$coefIndexList[[GetCoefReturnVal1$coefIndex]])$coefOrContrastIndex)
  Try(ContrastParameterizationIndex1 <- GetCoefReturnVal1$coefIndexList[[GetCoefReturnVal1$coefIndex]]$ContrastParameterizationIndex)
  if (GetCoefReturnVal1$parameterIsFromMainFit)
  {
    Try(fit1 <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb1  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  }
  else
  {
    Try(fit1 <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex1]])$fit)
    Try(eb1  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex1]])$eb)    
    Try(ParameterNamesVec1 <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex1]])$contrastsMatrixInList$contrasts))
  }

  GetCoefReturnVal2 <- GetCoef(parameterizationTreeIndex,"second")
  if (GetCoefReturnVal2$coefIndex==0) return()
  Try(coef2 <- (GetCoefReturnVal2$coefIndexList[[GetCoefReturnVal2$coefIndex]])$coefOrContrastIndex)
  Try(ContrastParameterizationIndex2 <- GetCoefReturnVal2$coefIndexList[[GetCoefReturnVal2$coefIndex]]$ContrastParameterizationIndex)
  if (GetCoefReturnVal2$parameterIsFromMainFit)
  {
    Try(fit2 <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb2  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  }
  else
  {
    Try(fit2 <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex2]])$fit)
    Try(eb2  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex2]])$eb)    
    Try(ParameterNamesVec2 <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex2]])$contrastsMatrixInList$contrasts))
  }

  DEcutoff <- GetDEcutoff()
  if (length(DEcutoff)==0) return()
  
  cutoffStatistic <- DEcutoff$cutoffStatistic
  cutoff          <- DEcutoff$cutoff
        
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  # Include option for labelling top 10 or however many DE genes.

  if (cutoffStatistic=="abs(t)")
      sel <- (abs(eb1$t[,coef1])>cutoff | abs(eb2$t[,coef2])>cutoff)
  if (cutoffStatistic=="B")
      sel <- (abs(eb1$lods[,coef1])>cutoff | abs(eb2$lods[,coef2])>cutoff)
  
  Try(M1 <- fit1$coefficients[,coef1])
  Try(M2 <- fit2$coefficients[,coef2])
  
  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
   Try(cex <- 0.3)
  else
    Try(cex <- 0.1))  
  plotMM <- function()
  {
    Try(opar<-par(bg="white"))
    Try(plot(M1,M2,pch=16,cex=cex,,xlab=ParameterNamesVec1[coef1],ylab=ParameterNamesVec2[coef2],main=plotTitle))
    Try(points(M1[sel],M2[sel],col="blue"))
#    Try(text(M1[topGenes],M2[topGenes],labels=gal[topGenes,IDorName],cex=0.8,col="blue"))
    Try(tempGraphPar <- par(opar))
  }

   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   

  Try(plotTitle <- paste("M M Plot for",ParameterNamesVec1[coef1],"vs",ParameterNamesVec2[coef2],"showing DE genes with",cutoffStatistic,">",cutoff))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(plotTitle <- plotTitleList$plotTitle)  

  Try(ttMMPlot <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttMMPlot,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttMMPlot,plotMM,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttMMPlot,img=img))
  Try(SetupPlotMenus(tt=ttMMPlot,initialfile=paste(limmaDataSetNameText,"MMPlot",ParameterNamesVec1[coef1],"vs",ParameterNamesVec2[coef2],sep=""),
                 plotFunction=plotMM,img=img))
  
  tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")  
  tkgrid(img)
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  tkfocus(ttMMPlot)
}


GetParametersAndOrContrasts <- function(parameterizationTreeIndex,whatFor="heat")
{
  # Firstly, NumParameters in main fit:
  Try(NumParameters     <- get("NumParameters",    envir=limmaGUIenvironment))        
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))    
  Try(NumContrastParameterizations <- ParameterizationList[[ParameterizationNameNode]]$NumContrastParameterizations)
  Try(ContrastsParameterizationNamesVec <- c() )
  Try(contrastNames <- list())
  Try (if (NumContrastParameterizations>0)
    Try(for (i in (1:NumContrastParameterizations))
    {
      Try(ContrastsParameterizationNamesVec[i] <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[i]]$contrastsParameterizationNameText)
      Try(contrastsMatrixInList <- ParameterizationList[[ParameterizationNameNode]]$Contrasts[[i]]$contrastsMatrixInList)
      Try(contrastsMatrix <- contrastsMatrixInList$contrasts)
      Try(contrastNames[[i]] <- colnames(contrastsMatrix))
    }))

  Try(ttGetParametersAndOrContrasts<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttGetParametersAndOrContrasts))
  Try(tkgrab.set(ttGetParametersAndOrContrasts)  )
  Try(tkfocus(ttGetParametersAndOrContrasts))
  Try(tkwm.title(ttGetParametersAndOrContrasts,"Choose the parameters and/or contrasts"))
  Try(yscr <- tkscrollbar(ttGetParametersAndOrContrasts, repeatinterval=5,
                       command=function(...)tkyview(tl,...)))
  Try(xscr <- tkscrollbar(ttGetParametersAndOrContrasts, repeatinterval=5,
                       command=function(...)tkxview(tl,...) ,orient="horizontal"))                       
  Try(tl<-tklistbox(ttGetParametersAndOrContrasts,height=4,selectmode="multiple",xscrollcommand=function(...)tkset(xscr,...),yscrollcommand=function(...)tkset(yscr,...),background="white",font=.limmaGUIglobals$limmaGUIfont2)   )
  Try(if (whatFor=="heat")
    Try(lbl2<-tklabel(ttGetParametersAndOrContrasts,text=
      "Choose the parameters and/or contrasts to be included in the heat diagram.",font=.limmaGUIglobals$limmaGUIfont2)))
  Try(if (whatFor=="venn")
    Try(lbl2<-tklabel(ttGetParametersAndOrContrasts,text=
      "Choose one, two or three parameters and/or contrasts for the venn diagram.",font=.limmaGUIglobals$limmaGUIfont2)))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="       ")))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="       ")))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="    "),lbl2))
  Try(tkgrid.configure(lbl2,sticky="w"))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="         ")))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="    "),tl,yscr))
  Try(tkgrid.configure(tl,rowspan=4,sticky="ew"))
  Try(tkgrid.configure(yscr,rowspan=4,sticky="wns"))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="    "),xscr,sticky="wne"))
  
  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))

  coefIndexList <- list()

  if (NumParameters>0)
    Try(for (i in (1:NumParameters))     
    {
      Try(tkinsert(tl,"end",ParameterNamesVec[i]))
      Try(coefIndexList[[i]] <- list(coefOrContrastIndex=i,ContrastParameterizationIndex=0))
    })
  Try(currentIndex <- NumParameters+1)
  Try(if (NumContrastParameterizations>0)
    Try(for (i in (1:NumContrastParameterizations))
    {      
      Try(for (j in (1:length(contrastNames[[i]])))
      {
        Try(tkinsert(tl,"end",paste(contrastNames[[i]][j]," [",ContrastsParameterizationNamesVec[i],"]",sep="")))
        Try(coefIndexList[[currentIndex]] <- list(coefOrContrastIndex=j,ContrastParameterizationIndex=i))        
        Try(currentIndex <- currentIndex + 1)
      })
     }))


  Try(tkselection.set(tl,0,"end"))

  Try(ReturnVal <- list())
  onOK <- function()
  {
  
      Try(indicesSelected <- as.numeric(strsplit(tclvalue(tkcurselection(tl))," ")[[1]])+1)
      Try(numIndicesSelected <- length(indicesSelected))
      Try(ReturnVal <<- list())
      for (i in (1:numIndicesSelected))
      {
        Try(parameterNum <- indicesSelected[i])
        Try(tkgrab.release(ttGetParametersAndOrContrasts));Try(tkdestroy(ttGetParametersAndOrContrasts));Try(tkfocus(.limmaGUIglobals$ttMain))
        Try(if (parameterNum<=NumParameters)
          Try(ReturnVal[[i]] <<- list(coefIndex=parameterNum,parameterIsFromMainFit=TRUE,coefIndexList=coefIndexList))
        else
          Try(ReturnVal[[i]] <<- list(coefIndex=parameterNum,parameterIsFromMainFit=FALSE,coefIndexList=coefIndexList)))
      }
  }
  onCancel <- function() {Try(tkgrab.release(ttGetParametersAndOrContrasts));Try(tkdestroy(ttGetParametersAndOrContrasts));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- list())}
  Try(tkframeOKCancel <- tkframe(ttGetParametersAndOrContrasts))
  Try(OK.but     <- tkbutton(tkframeOKCancel,text="   OK   ",command=onOK,    font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <- tkbutton(tkframeOKCancel,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframeOKCancel,text="    "),columnspan=2))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))  
  Try(tkgrid(tklabel(tkframeOKCancel,text="    "),columnspan=2))
  Try(tkgrid(tklabel(ttGetParametersAndOrContrasts,text="    "),tkframeOKCancel))
  Try(tkfocus(ttGetParametersAndOrContrasts))
  Try(tkbind(ttGetParametersAndOrContrasts, "<Destroy>", function() {Try(tkgrab.release(ttGetParametersAndOrContrasts));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGetParametersAndOrContrasts))

  return (ReturnVal)
}

HeatDiagramDialog <- function(parameterName)
{
  Try(ttHeatDiagramDialog <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttHeatDiagramDialog,"Heat Diagram Options"))
  Try(tkwm.deiconify(ttHeatDiagramDialog))
  Try(tkgrab.set(ttHeatDiagramDialog))
  Try(tkfocus(ttHeatDiagramDialog))  
  Try(tkframe1 <- tkframe(ttHeatDiagramDialog))
  Try(tkgrid(tklabel(tkframe1,text="    ")))
  Try(tkgrid(tklabel(tkframe1,text="    "),
             tklabel(tkframe1,text="The absolute value of the (moderated) t statistic will be used to plot",
               font=.limmaGUIglobals$limmaGUIfont2)))
  Try(tkgrid(tklabel(tkframe1,text="    "),
             tklabel(tkframe1,text=paste("the heat diagram, relative to parameter ",parameterName,".",sep=""),font=.limmaGUIglobals$limmaGUIfont2),
             tklabel(tkframe1,text="    ")))
  Try(tkgrid(tklabel(tkframe1,text="    ")))
  Try(primaryCutoffTcl <- tclVar("4"))  
  Try(otherCutoffTcl   <- tclVar("3"))
  Try(entry.primaryCutoff <- tkentry(tkframe1,textvariable=primaryCutoffTcl,bg="white",width=10,font=.limmaGUIglobals$limmaGUIfont2))
  Try(entry.otherCutoff   <- tkentry(tkframe1,textvariable=otherCutoffTcl,  bg="white",width=10,font=.limmaGUIglobals$limmaGUIfont2))  
  Try(tkgrid(tklabel(tkframe1,text="    "),tklabel(tkframe1,text=paste("D.E. cutoff for parameter ",
    parameterName,":   ",sep=""),font=.limmaGUIglobals$limmaGUIfont2),entry.primaryCutoff,tklabel(tkframe1,text="    ")))
  Try(tkgrid(tklabel(tkframe1,text="    "),tklabel(tkframe1,text=
    "D.E. cutoff for other parameters:   ",font=.limmaGUIglobals$limmaGUIfont2),entry.otherCutoff,tklabel(tkframe1,text="    ")))
  Try(tkgrid.configure(entry.primaryCutoff,sticky="w"))
  Try(tkgrid.configure(entry.otherCutoff,sticky="w"))  
  Try(tkgrid(tklabel(tkframe1,text="    ")))    
  Try(tkgrid(tkframe1))
  Try(tkframeOKCancel <- tkframe(ttHeatDiagramDialog))
  ReturnVal <- list()
  onOK <- function()
  {
    Try(primaryCutoffVal <- as.numeric(tclvalue(primaryCutoffTcl)))
    Try(otherCutoffVal   <- as.numeric(tclvalue(otherCutoffTcl)))
    Try(tkgrab.release(ttHeatDiagramDialog))
    Try(tkdestroy(ttHeatDiagramDialog))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    Try(ReturnVal <<- list(primaryCutoff=primaryCutoffVal,otherCutoff=otherCutoffVal))
  }
  Try(onCancel <- function() {Try(tkgrab.release(ttHeatDiagramDialog));Try(tkdestroy(ttHeatDiagramDialog));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- list())})
  Try(OK.but <-tkbutton(tkframeOKCancel,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(tkframeOKCancel,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid(tklabel(tkframeOKCancel,text="    ")))
  Try(tkgrid(tkframeOKCancel))
  Try(tkfocus(entry.primaryCutoff))
  Try(tkbind(ttHeatDiagramDialog, "<Destroy>", function() {Try(tkgrab.release(ttHeatDiagramDialog));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttHeatDiagramDialog))
  
  return (ReturnVal)
  
}


HeatDiagramPlot <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))  
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
 
  Try(if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="Heat Diagram",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  })

  Try(if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Heat Diagram",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })  

  Try(if (NumParameters<=1)
  {
    Try(tkmessageBox(title="Heat Diagram",message="To plot a heat diagram, you need to have more than one parameter, i.e. more than two RNA types.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })  

  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Heat Diagram",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  GetCoefReturnVal <- GetCoef(parameterizationTreeIndex,"heat")
  if (GetCoefReturnVal$coefIndex==0) return()  
  Try(coef <- (GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]])$coefOrContrastIndex)
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))
  Try(ContrastParameterizationIndex <- GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]]$ContrastParameterizationIndex)
  if (GetCoefReturnVal$parameterIsFromMainFit)
  {
    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  }
  else
  {
    Try(fit <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$fit)
    Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)    
    Try(ParameterNamesVec <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts))
    Try(NumParameters <- length(ParameterNamesVec))    
  }

  Try(fitHD <- list())  
  Try(fitHD$coefficients <- as.matrix(as.matrix(fit$coefficients)[,coef]))
  Try(colnames(fitHD$coefficients) <- colnames(fit$coefficients)[coef])
  Try(ebHD <- list())
  Try(ebHD$t  <- as.matrix(as.matrix(eb$t)[,coef]))
  Try(colnames(ebHD$t) <- colnames(eb$t)[coef])  
  
  Try(ParametersAndOrContrasts <- GetParametersAndOrContrasts(parameterizationTreeIndex,whatFor="heat"))
  Try(NumParametersSelected <- length(ParametersAndOrContrasts))
  Try(if (NumParametersSelected==0)
    return())
  Try(coefList <- list())
  for (i in (1:NumParametersSelected))
  {
    Try(coefList[[i]] <- ((ParametersAndOrContrasts[[i]])$coefIndexList[[(ParametersAndOrContrasts[[i]])$coefIndex]])$coefOrContrastIndex)
    Try(ContrastParameterizationIndex <- ParametersAndOrContrasts[[i]]$coefIndexList[[ParametersAndOrContrasts[[i]]$coefIndex]]$ContrastParameterizationIndex)
    Try(if ((ParametersAndOrContrasts[[i]])$parameterIsFromMainFit)
    {
      Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
      Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
    }
    else
    {
      Try(fit <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$fit)
      Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)    
    })
    
    if (colnames(fit$coefficients)[coefList[[i]]]!=colnames(fitHD$coefficients)[1])
    {
      Try(fitHD$coefficients <- cbind(fitHD$coefficients,as.matrix(as.matrix(fit$coefficients)[,coefList[[i]]])))
      Try(ncolfitcoefs <- ncol(fitHD$coefficients))
      Try(colnames(fitHD$coefficients)[ncolfitcoefs] <- colnames(fit$coefficients)[coefList[[i]]])    
      Try(ebHD$t             <- cbind(ebHD$t,  as.matrix(as.matrix(eb$t)[,coefList[[i]]])))   
      Try(colnames(ebHD$t)[ncolfitcoefs] <- colnames(eb$t)[coefList[[i]]])      
    }
  }


  Try(HeatDiagramOptions <- HeatDiagramDialog(colnames(fitHD$coefficients)[1]))
  Try(if (length(HeatDiagramOptions)==0)
    return())
  Try(primaryCutoff <- HeatDiagramOptions$primaryCutoff)
  Try(otherCutoff   <- HeatDiagramOptions$otherCutoff)  
 
  Try(gal      <- get("gal",envir=limmaGUIenvironment))
  Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
    Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
  else
    Try(genelist <- get("genelist",limmaGUIenvironment)))   

  plotHD <- function() 
  {
    Try(opar<-par(bg="white"))
    Try(heatdiagram(abs(ebHD$t),fitHD$coefficients,primary=1,
      critical.primary=primaryCutoff,critical.other=otherCutoff,
      names=genelist[,"Name"],main=plotTitle))
    Try(TempGraphPar<-par(opar))    
  }
   Try(LocalHScale <- get("Myhscale",envir=.GlobalEnv)*1.5)
   Try(LocalVScale <- get("Myvscale",envir=.GlobalEnv)*0.5)   
   
  Try(plotTitle <- paste("Heat diagram relative to parameter",ParameterNamesVec[coef]))

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(plotTitle <- plotTitleList$plotTitle)  

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(ttHeatDiagramPlot <- tktoplevel(.limmaGUIglobals$ttMain))  
  tkwm.title(ttHeatDiagramPlot,plotTitle)
  Try(Require("tkrplot"))

  img <-tkrplot(ttHeatDiagramPlot,plotHD,hscale=LocalHScale,vscale=LocalVScale) 
  Try(SetupPlotKeyBindings(tt=ttHeatDiagramPlot,img=img))
  Try(SetupPlotMenus(tt=ttHeatDiagramPlot,initialfile=paste(limmaDataSetNameText,"HeatDiagram",sep=""),
                 plotFunction=plotHD,img=img))
  
  tkgrid(img)
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  tkfocus(ttHeatDiagramPlot)
}

ImageArrayPlotDialog <- function(slidenum)
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(NormalizedMADataWasImported <- get("NormalizedMADataWasImported",envir=limmaGUIenvironment))
  
  Try(if (NormalizedMADataWasImported==FALSE)
    Try(RCodeString <- "Mraw")
  else
    Try(RCodeString <- "M"))
  Try(ttImageArrayPlotDialog <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttImageArrayPlotDialog))
  Try(tkgrab.set(ttImageArrayPlotDialog))
  Try(tkfocus(ttImageArrayPlotDialog))
  Try(SlideName <- SlideNamesVec[slidenum])
  Try(tkwm.title(ttImageArrayPlotDialog,paste("Image Array Plot for Slide ",SlideName,sep="")))
  tkframe1 <- tkframe(ttImageArrayPlotDialog)
  tkframe2 <- tkframe(tkframe1,relief="groove",borderwidth=2)
  tkframe4 <- tkframe(tkframe1)
  tkgrid(tklabel(tkframe1,text="    "))
  tkgrid(tklabel(tkframe1,text="Please enter an R expression which you would like an image plot of.",font=.limmaGUIglobals$limmaGUIfont2))
  Try(if (NormalizedMADataWasImported==FALSE)
    tkgrid(tklabel(tkframe1,text="You may use R, Rb, G, Gb, Mraw, Araw, and any standard R functions.",font=.limmaGUIglobals$limmaGUIfont2))
  else
    tkgrid(tklabel(tkframe1,text="You may use M, A, and any standard R functions.",font=.limmaGUIglobals$limmaGUIfont2)))  
  tkgrid(tklabel(tkframe1,text="    "))
  tkgrid(tklabel(tkframe2,text="R expression for image array plot",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
  Try(Rexpression<- tclVar(RCodeString))
  tkgrid(tklabel(tkframe2,text="    "))
  entry.Rexpression<-tkentry(tkframe2,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=Rexpression,bg="white")
  tkgrid(tklabel(tkframe2,text="R expression : ",font=.limmaGUIglobals$limmaGUIfont2),entry.Rexpression,sticky="w")
  tkgrid(tkframe2)
  tkgrid(tklabel(tkframe1,text="    "))
  ReturnVal <- ""
  onOK <- function()
  {
    # OK
  
    Try(RexpressionVal <- tclvalue(Rexpression))
    Try(tkgrab.release(ttImageArrayPlotDialog))
    Try(tkdestroy(ttImageArrayPlotDialog))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    Try(ReturnVal <<- RexpressionVal)
  }
  Try(tkbind(entry.Rexpression, "<Return>",onOK))
  onCancel <- function() {Try(tkgrab.release(ttImageArrayPlotDialog));Try(tkdestroy(ttImageArrayPlotDialog));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- "")}        
  OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but)
  tkgrid(tklabel(tkframe4,text="    "))
  tkgrid(tkframe4)
  tkgrid(tkframe1)
  Try(tkfocus(entry.Rexpression))
  Try(tkbind(ttImageArrayPlotDialog, "<Destroy>", function() {Try(tkgrab.release(ttImageArrayPlotDialog));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttImageArrayPlotDialog))
  return (ReturnVal)
}

imageplotlimmaGUI <- function(z, layout=list(ngrid.r=12,ngrid.c=4,nspot.r=26,nspot.c=26), low=NULL, high=NULL, ncolors=123, zerocenter=NULL, zlim=NULL,mar=1,...) {
#  Image plot of spotted microarray data
#  Gordon Smyth
#  20 Nov 2001.  Last revised 27 Nov 2001.

#  Check input
  gr <- layout$ngrid.r
  gc <- layout$ngrid.c
  sr <- layout$nspot.r
  sc <- layout$nspot.c
  if(is.null(gr)||is.null(gc)||is.null(sr)||is.null(sc)) stop("Layout needs to contain components ngrid.r, ngrid.c, nspot.r and spot.c")
  if(length(z) != gr*gc*sr*sc) stop("Number of image spots does not agree with layout dimensions")

#  Check colours
  if(is.character(low)) low <- col2rgb(low)/255
  if(is.character(high)) high <- col2rgb(high)/255
  if(!is.null(low) && is.null(high)) high <- c(1,1,1) - low
  if(is.null(low) && !is.null(high)) low <- c(1,1,1) - high

#  Is zlim preset?
  if(!is.null(zlim)) {
    z <- pmax(zlim[1],z)
    z <- pmin(zlim[2],z)
  }

#  Plot differential expression from "green" to "red" or plot one variable from "white" to "blue"?
  zr <- range(z,na.rm=TRUE)
  zmax <- max(abs(zr))
  zmin <- zr[1]
  if(is.null(zerocenter)) zerocenter <- (zmin < 0)
  if(zerocenter) {
    if(is.null(low)) low <- c(0,1,0)
    if(is.null(high)) high <- c(1,0,0)
    if(is.null(zlim)) zlim <- c(-zmax,zmax)
  } else {
    if(is.null(low)) low <- c(1,1,1)
    if(is.null(high)) high <- c(0,0,1)
    if(is.null(zlim)) zlim <- c(zmin,zmax)
  }

#  Now make the plot
  col <- rgb( seq(low[1],high[1],len=ncolors), seq(low[2],high[2],len=ncolors), seq(low[3],high[3],len=ncolors) )
  dim(z) <- c(sc,sr,gc,gr)
  z <- aperm(z,perm=c(2,4,1,3))
  dim(z) <- c(gr*sr,gc*sc)
  old.par <- par(no.readonly = TRUE)
  on.exit(par(old.par))
  par(mar=rep(mar,4))
  image(0:(gr*sr),0:(gc*sc),z,zlim=zlim,col=col,axes=FALSE,...)
  for (igrid in 0:gc) lines( c(0,gr*sr), rep(igrid*sc,2) )
  for (igrid in 0:gr) lines( rep(igrid*sr,2), c(0,gc*sc) )
  invisible()
}



ImageArrayPlot <- function()
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(ParameterizationList <- get("ParameterizationList", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Image Array Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  SetLayoutParamReturnVal<-1
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
  if (length(maLayout)==0) SetLayoutParamReturnVal <-SetLayoutParameters()
  if (SetLayoutParamReturnVal==0)
    return()
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
  Try(slidenum <- GetSlideNum())
  if (slidenum==0)
      return()
  Try(SlideName <- SlideNamesVec[slidenum])      
  Try(MA    <- get("MA",envir=limmaGUIenvironment))          

  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
  Try(if (NormalizedMADataWasImported==FALSE)
  {
    Try(RG    <- get("RG",envir=limmaGUIenvironment))
		if (MA.Available$Raw)
			Try(MAraw <- get("MAraw",envir=limmaGUIenvironment))
		else          
		{
			Try (MAraw <- MA.RG(RG))
			Try(assign("MAraw",MAraw,limmaGUIenvironment))        
			Try(MA.Available$Raw <- TRUE)
			Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
			Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
			Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))            
		}              
  })
  
  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))

  if ((nrow(MA$M)>1))
  {
    Try(M <- MA$M)
    Try(A <- MA$A)
  }

  Try(if (NormalizedMADataWasImported==FALSE)
  {
		Try(Mraw <- MAraw$M[,slidenum])
		Try(Araw <- MAraw$A[,slidenum])
		Try(R <- RG$R[,slidenum])
		Try(Rb <- RG$Rb[,slidenum])
		Try(G <- RG$G[,slidenum])
		Try(Gb <- RG$Gb[,slidenum])
  })  
  
  Try(RexpressionVal <- ImageArrayPlotDialog(slidenum))
  Try(if (nchar(RexpressionVal)==0) return())

  Try(ExpressionContainsRed   <- length(grep("R",RexpressionVal))||length(grep("Rb",RexpressionVal)))
  Try(ExpressionContainsGreen <- length(grep("G",RexpressionVal))||length(grep("Gb",RexpressionVal)))
  
  Try(ExpressionContainsRedOnly   <- (ExpressionContainsRed && !ExpressionContainsGreen))
  Try(ExpressionContainsGreenOnly <- (ExpressionContainsGreen && !ExpressionContainsRed))

  Try(if (ExpressionContainsRedOnly || ExpressionContainsGreenOnly)
  {
    Try(if (ExpressionContainsRedOnly)
      Try(expr <- paste("imageplotlimmaGUI(",RexpressionVal,",layout=maLayout,low=\"white\",high=\"red\",mar=0)",sep="")))
    Try(if (ExpressionContainsGreenOnly)
      Try(expr <- paste("imageplotlimmaGUI(",RexpressionVal,",layout=maLayout,low=\"white\",high=\"green\",mar=0)",sep="")))
  }
  else
    Try(expr <- paste("imageplotlimmaGUI(",RexpressionVal,",layout=maLayout,mar=0)",sep="")))
  Try(exprResult <- try(parse(text=expr)))
  if (inherits(exprResult, "try-error")) 
  {
    tkmessageBox(message="Syntax error",icon="error")
    return()
  }
  Try(parPlotSize <- c())
  Try(usrCoords <- c())
  plotImageArray <- function() 
  {
    Try(eval(exprResult))  # Evaluate in default environment, i.e. parent.frame()
    Try(parPlotSize <<- par("plt"))
    Try(usrCoords   <<- par("usr"))
  }
  Try(LocalHScale <- .limmaGUIglobals$Myhscale)
  Try(LocalVScale <- .limmaGUIglobals$Myvscale)   

  Try(plotTitle <- paste("Image array plot of",RexpressionVal,"for Slide",SlideName,sep=" "))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")) 
  
  Try(ttImageArrayPlotGraph <- tktoplevel(.limmaGUIglobals$ttMain))

  Try(plotTitle <- plotTitleList$plotTitle)
  Try(tkwm.title(ttImageArrayPlotGraph,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttImageArrayPlotGraph,plotImageArray,hscale=LocalHScale,vscale=LocalVScale))
  Try(parPlotSize <- par("plt"))
  Try(usrCoords   <- par("usr"))
  Try(SetupPlotKeyBindings(tt=ttImageArrayPlotGraph,img=img))
  Try(plotMenus<-SetupPlotMenus(tt=ttImageArrayPlotGraph,initialfile=paste(limmaDataSetNameText,"ImagePlotSlide",SlideNamesVec[slidenum],sep=""),
               plotFunction=plotImageArray,img=img))
  Try(resizeMenu<-plotMenus$resizeMenu)
  Try(tkdelete(resizeMenu,"0"))
  Try(tkadd(resizeMenu, "command", label="Resize Window",command=function() {Resize(img=img,plotFunction=plotImageArray);Try(parPlotSize <<- par("plt"));Try(usrCoords   <<- par("usr"));  Try(tkconfigure(img,cursor="hand2"))}))

  tkgrid(img)
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  tkfocus(ttImageArrayPlotGraph)
  
  
  Try(tkconfigure(img,cursor="hand2"))
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
  Try(ngrid.r <- maLayout$ngrid.r)
  Try(ngrid.c <- maLayout$ngrid.c)  
  Try(nspot.r <- maLayout$nspot.r)    
  Try(nspot.c <- maLayout$nspot.c)      
  Try(gal <- get("gal",envir=limmaGUIenvironment))    
  OnLeftClick <- function(x,y)
  {
    Try(width  <- as.numeric(tclvalue(tkwinfo("reqwidth",img))))
    Try(height <- as.numeric(tclvalue(tkwinfo("reqheight",img))))
    
    Try(xMin <- parPlotSize[1] * width)
    Try(xMax <- parPlotSize[2] * width)
    Try(yMin <- parPlotSize[3] * height)
    Try(yMax <- parPlotSize[4] * height)
    
    Try(rangeX <- usrCoords[2] - usrCoords[1])
    Try(rangeY <- usrCoords[4] - usrCoords[3])

    Try(xClick <- as.numeric(x)+0.5)
    Try(yClick <- as.numeric(y)+0.5)
    Try(yClick <- height - yClick)

#    Try(tkmessageBox(message=paste("xClick: ",xClick,", yClick: ",yClick,sep="")))
#    Try(tkmessageBox(message=paste("xMin: ",xMin,", xMax: ",xMax,sep="")))
#    Try(tkmessageBox(message=paste("yMin: ",yMin,", yMax: ",yMax,sep="")))

    Try(xPlotCoord <- xClick / width)
    Try(yPlotCoord <- yClick / height)

#   Try(xPlotCoord <- usrCoords[1]+(xClick-xMin)*rangeX/(xMax-xMin))
#   Try(yPlotCoord <- usrCoords[3]+(yClick-yMin)*rangeY/(yMax-yMin))
       
#    Try(tkmessageBox(message=paste("xPlotCoord: ",xPlotCoord,", yPlotCoord: ",yPlotCoord,sep="")))
       
    # Assume image plot is plotted on its side (the default)       
    Try(blockRow    <- as.integer(xPlotCoord*ngrid.r)+1)
    Try(blockColumn <- as.integer(yPlotCoord*ngrid.c)+1)        
    Try(Block <- (blockRow-1) * maLayout$ngrid.c + blockColumn)
    
    # m mod n
    mod <- function(m,n) m-as.integer(m/n)*n
    Try(xCoordPixels <- as.integer(xPlotCoord*nspot.r*ngrid.r))
    Try(yCoordPixels <- as.integer(yPlotCoord*nspot.c*ngrid.c))
        
    Try(Column <- mod(yCoordPixels,nspot.c)+1)
    Try(Row    <- mod(xCoordPixels,nspot.r)+1)
    Try(gene <- gal[gal[,"Block"]==Block&gal[,"Row"]==Row&gal[,"Column"]==Column,])
    Try(tkmessageBox(title="Spot Information",message=paste("Block: ",Block,"; Row: ",Row,
                                              "; Column: ",Column,"; ID: ",gene$ID,"; Name: ",gene$Name,".",sep=""),icon="info"))
  }
  Try(tkbind(img, "<Button-1>",OnLeftClick))    
  
}


LogOddsPlot <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
 
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Log Odds Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Log Odds Plot",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return()    )
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Log Odds Plot",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
    Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
  else
    Try(genelist <- get("genelist",limmaGUIenvironment)))   
  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))
  GetCoefReturnVal <- GetCoef(parameterizationTreeIndex)
  if (GetCoefReturnVal$coefIndex==0) return()
  Try(coef <- (GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]])$coefOrContrastIndex)
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ContrastParameterizationIndex <- GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]]$ContrastParameterizationIndex)
  if (GetCoefReturnVal$parameterIsFromMainFit)
  {
    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  }
  else
  {
    Try(fit <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$fit)
    Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)    
    Try(ParameterNamesVec <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts))
    Try(NumParameters <- length(ParameterNamesVec))    
  }

  # Have to ask the user how many of the top DE genes they want labeled.
  Try(GeneLabelsOptions <- GetGeneLabelsOptions())
  Try(if (length(GeneLabelsOptions)==0) return())
  Try(numDEgenesLabeled   <- GeneLabelsOptions$HowManyDEGeneLabels)
  Try(GeneLabelsMaxLength <- GeneLabelsOptions$GeneLabelsMaxLength)
  Try(IDorName <- GeneLabelsOptions$IDorName)

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(if (numDEgenesLabeled>0)
  {
    Try(if (NumParameters>1)
        Try(ord <- order(eb$lods[,coef],decreasing=TRUE))
    else
        Try(ord <- order(eb$lods,decreasing=TRUE)))    
    Try(topGenes <- ord[1:numDEgenesLabeled])
  })
  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
    Try(cex <- 0.3)
  else
    Try(cex <- 0.1))  
  plotLogOdds <- function()
  {
    Try(opar<-par(bg="white"))
    if (NumParameters>1)
    {
      plot(fit$coef[,coef],eb$lods[,coef],pch=16,cex=cex,xlab=xLabel,ylab=yLabel,main=plotTitle)
      if (numDEgenesLabeled>0)
        text(fit$coef[topGenes,coef],eb$lods[topGenes,coef],labels=substr(as.character(genelist[topGenes,IDorName]),1,GeneLabelsMaxLength),cex=0.8,col="blue")
    }
    else
    {
      plot(fit$coef,eb$lods,pch=16,cex=cex,xlab=xLabel,ylab=yLabel,main=plotTitle)
      if (numDEgenesLabeled>0)
        text(fit$coef[topGenes],eb$lods[topGenes],labels=substring(as.character(genelist[topGenes,IDorName]),1,10),cex=0.8,col="blue")
    }
    Try(tempGraphPar <- par(opar))
  }
   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
  Try(plotTitle <- paste("Log Odds Plot for",ParameterNamesVec[coef]))
  Try(plotLabels <- GetPlotLabels(plotTitle,"Log Fold Change","Log Odds"))
  Try(if (length(plotLabels)==0) return())
  Try(plotTitle <- plotLabels$plotTitle)
  Try(xLabel    <- plotLabels$xLabel)
  Try(yLabel    <- plotLabels$yLabel)
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(plotTitle <- plotTitleList$plotTitle)

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))  
  Try(ttLogOddsPlot <- tktoplevel(.limmaGUIglobals$ttMain))  
  Try(tkwm.title(ttLogOddsPlot,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttLogOddsPlot,plotLogOdds,hscale=LocalHScale,vscale=LocalVScale))
  Try(SetupPlotKeyBindings(tt=ttLogOddsPlot,img=img))
  Try(SetupPlotMenus(tt=ttLogOddsPlot,initialfile=paste(limmaDataSetNameText,"LogOddsPlot",ParameterNamesVec[coef],sep=""),
                 plotFunction=plotLogOdds,img=img))
  
  Try(tkgrid(img))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(tkfocus(ttLogOddsPlot))

}


DupCorBoxPlot <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))    
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))

  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="Duplicate Correlation Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Duplicate Correlation Plot",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }     

  Try(if (ndups==1)
  {
    Try(tkmessageBox(title="Duplicate Correlation Plot",message="There are no duplicates.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })    

  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return()  )
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Duplicate Correlation Box Plot",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))    
  Try(dupcor <- (ParameterizationList[[ParameterizationNameNode]])$dupcor)

  if ((is.numeric(dupcor)) && (dupcor==0))
  {
      Try(tkmessageBox(title="Duplicate Correlation Box Plot",message="There are no duplicates.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()  
  }
  
  Try(if (!("cor.genes" %in% names(dupcor))&&!("all.correlations" %in% names(dupcor)))
  {
    Try(tkmessageBox(title="Duplicate Correlation Box Plot",message="Only available if limmaGUI calculates duplicate correlation (rather than the user)",type="ok",icon="error"))
    return()  
  })
  
  plotDupCor <- function()
  {
    Try(opar<-par(bg="white"))
    Try(if ("cor.genes" %in% names(dupcor))
      Try(boxplot(dupcor$cor.genes,main=plotTitle))
    else
      Try(boxplot(dupcor$all.correlations,main=plotTitle)))
    Try(opar<-par(bg="white")) 
  }
   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
  Try(plotTitle <- paste("Duplicate Correlation Box Plot"))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(plotTitle <- plotTitleList$plotTitle)    
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))  
  Try(ttDupCorBoxplot <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttDupCorBoxplot,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttDupCorBoxplot,plotDupCor,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttDupCorBoxplot,img=img))
  Try(SetupPlotMenus(tt=ttDupCorBoxplot,initialfile=paste(limmaDataSetNameText,"DupCorBoxPlot",sep=""),
                 plotFunction=plotDupCor,img=img))
  
  Try(tkgrid(img))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(ttDupCorBoxplot))  
}


QQTplot <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))        
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Quantile-Quantile t-Statistic Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))      
      return()
  }
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Quantile-Quantile t-Statistic Plot",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Quantile-Quantile t Statistic Plot",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))  
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  GetCoefReturnVal <- GetCoef(parameterizationTreeIndex)
  if (GetCoefReturnVal$coefIndex==0) return()
  Try(coef <- (GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]])$coefOrContrastIndex)
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ContrastParameterizationIndex <- GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]]$ContrastParameterizationIndex)
  if (GetCoefReturnVal$parameterIsFromMainFit)
  {
    Try(fit <- (ParameterizationList[[ParameterizationNameNode]])$fit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  }
  else
  {
    Try(fit <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$fit)
    Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)    
    Try(ParameterNamesVec <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts))
    Try(NumParameters <- length(ParameterNamesVec))    
  }
  
  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
    Try(cex <- 0.3)
  else
    Try(cex <- 0.1))    
  plotQQT <- function() 
  {
    Try(opar<-par(bg="white"))
    if (NumParameters>1) 
    {
      qqt(eb$t[,coef],df=fit$df+eb$df,pch=16,cex=cex,main=plotTitle)
    }
    else 
    {
      qqt(eb$t,df=fit$df+eb$df,pch=16,cex=cex,main=plotTitle)
    }
    abline(0,1) 
    Try(tempGraphPar <- par(opar))
  }
   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
  Try(plotTitle <- paste("Student's t Quantile-Quantile Plot for",ParameterNamesVec[coef]))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitle <- plotTitleList$plotTitle)

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(ttQQTplot <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttQQTplot,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttQQTplot,plotQQT,hscale=LocalHScale,vscale=LocalVScale))
  Try(SetupPlotKeyBindings(tt=ttQQTplot,img=img))
  Try(SetupPlotMenus(tt=ttQQTplot,initialfile=paste(limmaDataSetNameText,"QQTPlot",ParameterNamesVec[coef],sep=""),
                 plotFunction=plotQQT,img=img))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkgrid(img))
  Try(tkfocus(ttQQTplot))
}


MBoxPlot <- function()
{
  Try(SlideNamesVec   <- get("SlideNamesVec",envir=limmaGUIenvironment))  
  Try(ArraysLoaded    <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(WeightingType   <- get("WeightingType",envir=limmaGUIenvironment))
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="M Box Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  SetLayoutParamReturnVal<-1
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
  if (length(maLayout)==0) SetLayoutParamReturnVal <-SetLayoutParameters()
  if (SetLayoutParamReturnVal==0) return()
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
  ttMBoxPlot<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttMBoxPlot)
  tkgrab.set(ttMBoxPlot)
  tkfocus(ttMBoxPlot)  
  tkwm.title(ttMBoxPlot,"M Box Plot Options")
  plotby <- tclVar("Slide")
  tkframe1 <- tkframe(ttMBoxPlot,borderwidth=2)
  tkframe3 <- tkframe(tkframe1,relief="groove",borderwidth=2)
  tkframe4<-tkframe(tkframe1,borderwidth=2)  

  Abort <- 0
  plotbyval <- ""
  onOK <- function()
  {
      plotbyval <<- tclvalue(plotby)
      Try(tkgrab.release(ttMBoxPlot));Try(tkdestroy(ttMBoxPlot));Try(tkfocus(.limmaGUIglobals$ttMain))
      Abort <<-0
  }
  onCancel <- function() {Try(tkgrab.release(ttMBoxPlot));Try(tkdestroy(ttMBoxPlot));Try(tkfocus(.limmaGUIglobals$ttMain));Abort <<-1}
  OK.but <-tkbutton(tkframe4,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(tkframe4,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(tkframe1,text="                    "))
  tkgrid(tklabel(tkframe3,text="Plot by print-tip group or by slide?",
    font=.limmaGUIglobals$limmaGUIfont2),sticky="ew")
  PrintTip.but <- tkradiobutton(tkframe3,text="Print Tip Group",variable=plotby,value="PrintTip",font=.limmaGUIglobals$limmaGUIfont2)
  Slide.but <- tkradiobutton(tkframe3,text="Slide",variable=plotby,value="Slide",font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid.configure(PrintTip.but,sticky="w")
  tkgrid.configure(Slide.but,sticky="w")

  tkgrid(PrintTip.but)
  tkgrid(Slide.but)
  tkgrid(tkframe3,sticky="w")
  tkgrid(tkframe1)  
  tkgrid(tklabel(tkframe4,text="    "),sticky="ew")
  tkgrid(OK.but,Cancel.but)
  tkgrid(tkframe4,sticky="ew")
  tkfocus(ttMBoxPlot)
  tkbind(ttMBoxPlot, "<Destroy>", function() {Try(tkgrab.release(ttMBoxPlot));Try(tkfocus(.limmaGUIglobals$ttMain));})
  tkwait.window(ttMBoxPlot)
  
  if (Abort==1) return()
    slidenum <- 0

  if (plotbyval=="PrintTip")
  {
      slidenum <- GetSlideNum()
      if (slidenum==0)
          return()
  }

  Try(if (NormalizedMADataWasImported==FALSE)
  {
		Try(NormalizeWithinArraysMB <-tkmessageBox(title="Normalization Within Arrays",message="Normalize Within Arrays?",type="yesnocancel",icon="question",default="no"))
		Try(WhetherToNormalizeWithinArrays <- tclvalue(NormalizeWithinArraysMB))
		if (WhetherToNormalizeWithinArrays=="cancel")
				return()

		Try(NormalizeBetweenArraysMB <-tkmessageBox(title="Normalization Between Arrays",message="Normalize Between Arrays?",type="yesnocancel",icon="question",default="no"))
		Try(WhetherToNormalizeBetweenArrays <- tclvalue(NormalizeBetweenArraysMB))
		if (WhetherToNormalizeBetweenArrays=="cancel")
				return()

		Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
		Try(tkfocus(.limmaGUIglobals$ttMain))

		Try(RG <- get("RG",envir=limmaGUIenvironment))
		Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
		Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
		{
			Try(WithinArrayNormalizationMethod <- "printtiploess")
			Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
		})
		Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))

		Try(if (WhetherToNormalizeWithinArrays=="yes")
		{
				if (MA.Available$WithinArrays)
					Try(MA <- get("MAwithinArrays",envir=limmaGUIenvironment))
				else          
				{
					if (WeightingType == "none")
						Try (MA <- normalizeWithinArrays(RG,maLayout,method=WithinArrayNormalizationMethod))
					else
						Try(MA <- normalizeWithinArrays(RG,weights=RG$weights,maLayout,method=WithinArrayNormalizationMethod))
					Try(assign("MAwithinArrays",MA,limmaGUIenvironment))
					Try(MA.Available$WithinArrays <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))        
					Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
					Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text=paste("Available (using ",WithinArrayNormalizationMethod,")",sep=""),font=.limmaGUIglobals$limmaGUIfontTree))                

				}
		}
		else
		{
				if (MA.Available$Raw)
					Try(MA <- get("MAraw",envir=limmaGUIenvironment))
				else          
				{
					Try (MA <- MA.RG(RG))
					Try(assign("MAraw",MA,limmaGUIenvironment))
					Try(MA.Available$Raw <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))        
				}        
		})

		Try(if (WhetherToNormalizeBetweenArrays=="yes") 
		{
			if (WhetherToNormalizeWithinArrays=="yes")
			{
				if (MA.Available$Both)
					Try(MA <- get("MAboth",envir=limmaGUIenvironment))
				else
				{
					Try (MA <- normalizeBetweenArrays(MA))
					Try(assign("MAboth",MA,limmaGUIenvironment))
					Try(MA.Available$Both <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
				}

			}
			else
			{
				if (MA.Available$BetweenArrays)
					Try(MA <- get("MAbetweenArrays",envir=limmaGUIenvironment))
				else
				{
					Try (MA <- normalizeBetweenArrays(MA))
					Try(assign("MAbetweenArrays",MA,limmaGUIenvironment))
					Try(MA.Available$BetweenArrays <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))                
				}        
			}
		})
  }
  else
    Try(MA <- get("MAimported",envir=limmaGUIenvironment)))
  
  plot.scale.box0 <- function()
  {
      Try(Require("sma"))
      Try(if (plotbyval=="PrintTip")
      {
           Try(opar<-par(bg="white"))
           Try(plot.scale.box(MA$M[,slidenum],maLayout,col=rainbow(maLayout$ngrid.r*maLayout$ngrid.c),xlab="Print Tip Group",ylab="M",main=plotTitle))
           Try(tempGraphPar <- par(opar))
      }   
      else 
      {   
           Try(opar<-par(bg="white"))
           # Maybe allow las=2 as an option, i.e. vertical text labels for x axis.
           
           Try(if (min(nchar(gsub("[^0-9]","",SlideNamesVec))==nchar(SlideNamesVec))==TRUE)
             SlideNamesVec <- paste("Slide",SlideNamesVec))
           Try(plot.scale.box(MA$M,x.names=SlideNamesVec,xlab="Slide",ylab="M",main=plotTitle))
           Try(tempGraphPar <- par(opar))
      })
      Try(abline(0,0))
  }

   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
  if (plotbyval=="PrintTip")
  {
    if (NormalizedMADataWasImported==FALSE)
    {
			if (WhetherToNormalizeWithinArrays=="yes")
			{
					if (WhetherToNormalizeBetweenArrays=="yes")         
						Try(plotTitle <- paste("M Box Plot for slide ",SlideNamesVec[slidenum]," with normalization within and between arrays",sep=""))
					else
						Try(plotTitle <- paste("M Box Plot for slide ",SlideNamesVec[slidenum]," with normalization within arrays only",sep=""))
			}
			else
			{
					if (WhetherToNormalizeBetweenArrays=="yes")         
						 Try(plotTitle <- paste("M Box Plot for slide ",SlideNamesVec[slidenum]," with normalization between arrays only",sep=""))
					else
						 Try(plotTitle <- paste("M Box Plot for slide ",SlideNamesVec[slidenum]," with no normalization",sep=""))
			}
		}
		else
			Try(plotTitle <- paste("M Box Plot for slide ",SlideNamesVec[slidenum],sep=""))		
  }  
  else 
  {
    if (NormalizedMADataWasImported==FALSE)
    {
			if (WhetherToNormalizeWithinArrays=="yes")
			{
					if (WhetherToNormalizeBetweenArrays=="yes")         
						Try(plotTitle <- paste("M Box Plot for all slides with normalization within and between arrays",sep=""))
					else
						Try(plotTitle <- paste("M Box Plot for all slides with normalization within arrays only",sep=""))
			}
			else
			{
					if (WhetherToNormalizeBetweenArrays=="yes")         
						 Try(plotTitle <- paste("M Box Plot for all slides with normalization between arrays only",sep=""))
					else
						 Try(plotTitle <- paste("M Box Plot for all slides with no normalization",sep=""))
			}
		}
		else
			Try(plotTitle <- paste("M Box Plot for all slides"))
  }
      
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitle <- plotTitleList$plotTitle)

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))

  Try(ttMBoxPlotGraph <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkconfigure(ttMBoxPlotGraph,cursor="watch"))
  Try(tkwm.title(ttMBoxPlotGraph,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttMBoxPlotGraph,plot.scale.box0,hscale=LocalHScale,vscale=LocalVScale))
  Try(SetupPlotKeyBindings(tt=ttMBoxPlotGraph,img=img))
  Try(SetupPlotMenus(tt=ttMBoxPlotGraph,initialfile=paste(limmaDataSetNameText,"MBoxPlotSlide",SlideNamesVec[slidenum],sep=""),
                 plotFunction=plot.scale.box0,img=img))

  Try(tkgrid(img))
  Try(tkconfigure(ttMBoxPlotGraph,cursor="arrow"))  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  Try(tkfocus(ttMBoxPlotGraph))
}


PrintTipGroupMAPlot <- function()
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  Try(RG              <- get("RG", envir=limmaGUIenvironment))
  Try(MAraw           <- get("MAraw",envir=limmaGUIenvironment))  
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Print-Tip Group M A Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  SetLayoutParamReturnVal<-1
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
  if (length(maLayout)==0) 
    SetLayoutParamReturnVal <-SetLayoutParameters()
  if (SetLayoutParamReturnVal==0) 
    return()
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))        
  
  slidenum <- GetSlideNum()
  if (slidenum==0)
      return()

  Try(if (NormalizedMADataWasImported==TRUE)
    Try(MA <- get("MA",envir=limmaGUIenvironment))
  else
  {
		Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
		if (MA.Available$Raw)
			Try(MA <- get("MAraw",envir=limmaGUIenvironment))
		else          
		{
			Try (MA <- MA.RG(RG))
			Try(assign("MAraw",MA,limmaGUIenvironment))        
			Try(MA.Available$Raw <- TRUE)
			Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
			Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
			Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))            
		}              
  })
  PrintTipGroupPlot <- function()
  {
     Try(opar<-par(bg="white"))  
     plotPrintTipLoess(MA,layout=maLayout,array=slidenum)
     Try(tempGraphPar <- par(opar))  
  }
   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
  ttPrintTipGroupMAPlotGraph <- tktoplevel(.limmaGUIglobals$ttMain)

  Try(Require("tkrplot"))

  Try(plotTitle <- paste("Print-Tip Group M A Plots for slide ",SlideNamesVec[slidenum],sep=""))
  Try(tkwm.title(ttPrintTipGroupMAPlotGraph,plotTitle))
  Try(img <- tkrplot(ttPrintTipGroupMAPlotGraph,PrintTipGroupPlot,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttPrintTipGroupMAPlotGraph,img=img))
  Try(SetupPlotMenus(tt=ttPrintTipGroupMAPlotGraph,initialfile=paste(limmaDataSetNameText,"PrintTipGroupMAPlotSlide",SlideNamesVec[slidenum],sep=""),
                 plotFunction=PrintTipGroupPlot,img=img))
    
  tkgrid(img)
  tkfocus(ttPrintTipGroupMAPlotGraph)
}

MAPlot <- function()
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))

  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="M A Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(if (NormalizedMADataWasImported==FALSE)
  {
    Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))  
    Try(RG <- get("RG",envir=limmaGUIenvironment))
  }
  else
  {
    Try(MA <- get("MAimported",envir=limmaGUIenvironment))
    Try(RGtmp <- list())
    Try(RGtmp$R <- 2^(MA$M*.5+MA$A))
    Try(RGtmp$G <- 2^(MA$A-.5*MA$M))
    Try(RG <- new("RGList",RGtmp))    
  })
  
  SetLayoutParamReturnVal<-1
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
  if (length(maLayout)==0) 
    SetLayoutParamReturnVal <-SetLayoutParameters()
  if (SetLayoutParamReturnVal==0) 
    return()
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))        
  
  slidenum <- GetSlideNum()
  if (slidenum==0)
      return()

  Try(if (NormalizedMADataWasImported==FALSE)
  {
    Try(NormalizeWithinArrayMB <-tkmessageBox(title="Normalization Within A Single Array",message="Normalize Within Single Array (fast approximate method) ?",type="yesnocancel",icon="question",default="no"))
    Try(WhetherToNormalizeWithinArray <- tclvalue(NormalizeWithinArrayMB))
    if (WhetherToNormalizeWithinArray=="cancel")
        return()
  })

  Try(if (NormalizedMADataWasImported==FALSE)
    if (WhetherToNormalizeWithinArray=="no")
    {
      # We don't actually need MAraw in this plot.  But users may expect that plotting M and A in this will 
      # will create an MAraw object.
      Try (MAraw <- MA.RG(RG))
      Try(assign("MAraw",MAraw,limmaGUIenvironment))        
      Try(MA.Available$Raw <- TRUE)
      Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
      Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
      Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))            
    })

  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
    Try(cex <- 0.3)
  else
    Try(cex <- 0.1))  
  plot.print.tip.lowess0 <- function()
  {
     Try(Require("sma"))
     Try(opar<-par(bg="white"))
     
     Try(if (NormalizedMADataWasImported==FALSE)     
     {
       if (WhetherToNormalizeWithinArray=="yes")
          normval <- "p"
       else
         normval <- "n"
     }
      else
        normval <- "n")
      Try(plot.print.tip.lowess(RG,maLayout,pch=16,cex=cex,image=slidenum,norm=normval,main=plotTitle))
     Try(tempGraphPar <- par(opar))
  }
   Try(LocalHScale <- .limmaGUIglobals$Myhscale)
   Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
  Try(if (NormalizedMADataWasImported==FALSE)  
  {
    if (WhetherToNormalizeWithinArray=="yes")
      Try(plotTitle <- paste("M A Plot for slide ",SlideNamesVec[slidenum],
      " with normalization",sep=""))
    else
      Try(plotTitle <- paste("M A Plot for slide ",SlideNamesVec[slidenum],
      " with no normalization",sep=""))
  }
  else
      Try(plotTitle <- paste("M A Plot for slide ",SlideNamesVec[slidenum])))  
      
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(plotTitle <- plotTitleList$plotTitle)      

  Try(ttMAPlotGraph <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))          
  Try(tkconfigure(ttMAPlotGraph,cursor="watch"))        
  Try(tkfocus(.limmaGUIglobals$ttMain))  
  Try(Require("tkrplot"))
    
      
  Try(tkwm.title(ttMAPlotGraph,plotTitle))
  Try(img <-tkrplot(ttMAPlotGraph,plot.print.tip.lowess0,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttMAPlotGraph,img=img))
  Try(SetupPlotMenus(tt=ttMAPlotGraph,initialfile=paste(limmaDataSetNameText,"MAPlotSlide",SlideNamesVec[slidenum],sep=""),
                 plotFunction=plot.print.tip.lowess0,img=img))
  Try(tkgrid(img))
  Try(tkconfigure(ttMAPlotGraph,cursor="arrow"))        
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))          
  tkfocus(ttMAPlotGraph)
}


ChoosePlotSymbolByClicking <- function(spotType,cex)
{
  Try(ttChoosePlotSymbolByClicking<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttChoosePlotSymbolByClicking))
  Try(tkgrab.set(ttChoosePlotSymbolByClicking))
  Try(tkfocus(ttChoosePlotSymbolByClicking)  )
  Try(tkwm.title(ttChoosePlotSymbolByClicking,
       paste("Please Choose A Plot Symbol and Size for Points of type \"",spotType,"\" in the Plot",sep="")))
  Try(parPlotSize <- c())

  Try(Pex <- cex) 

  ChoosePlotSymbol <- function()
  {
      ##-------- Showing all the extra & some char graphics symbols ------------
      opar <- par (bg="white")
      ipch <- 1:(np <- 25+11); k <- floor(sqrt(np)); dd <- c(-1,1)/2
      rx <- dd + range(ix <- (ipch-1) %/% k)
      ry <- dd + range(iy <- 3 + (k-1)-(ipch-1) %% k)
      pch <- as.list(ipch)
      pch[25+ 1:11] <- as.list(c("*",".", "o","O","0","+","-",":","|","%","#"))
      Try(plot(rx, ry, type="n", axes=FALSE,xlim=c(-0.5,5.5),ylim=c(2.5,8.5),xaxs="i",yaxs="i",xlab = "", ylab = "",
          main = paste("Please choose a plot symbol and point size for spots of type \"",spotType,"\".",sep="")))
      Try(abline(v = ix, h = iy, col = "lightgray", lty = "dotted"))
      for(i in 1:np) {
       pc <- pch[[i]]
       Try(points(ix[i], iy[i], pch = pc, col = "red", bg = "yellow", cex = Pex))
       ## red symbols with a yellow interior (where available)
       Try(text(ix[i] - .3, iy[i], pc, col = "brown", cex = 1.2))
       parPlotSize <<- par("plt")
       par(opar)
      }
  }

  onUpdate <- function()
  {
    Try(Pex <<- as.numeric(tclvalue(PlotPointSize)))
    Try(tkrreplot(img))
  }

  Try(PlotPointSize <- tclVar(paste(Pex)))
  Try(entry.PlotPointSize <-tkentry(ttChoosePlotSymbolByClicking,width="20",textvariable=PlotPointSize,font=.limmaGUIglobals$limmaGUIfont2,bg="white"))
  Try(Update.but <- tkbutton(ttChoosePlotSymbolByClicking,text="Update",command=onUpdate,font=.limmaGUIglobals$limmaGUIfont2))
  Require("tkrplot")

  Try(LocalHScale <- .limmaGUIglobals$Myhscale)
  Try(LocalVScale <- .limmaGUIglobals$Myvscale)   

  Try(img <- tkrplot(ttChoosePlotSymbolByClicking,fun=ChoosePlotSymbol,hscale=2*LocalHScale/1.6,vscale=1.6 *LocalVScale/1.6))
  Try(tkgrid(img,columnspan=3))
  Try(label1 <- tklabel(ttChoosePlotSymbolByClicking,text="Plot point size : ",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(label1,entry.PlotPointSize,Update.but))
  Try(tkgrid.configure(label1,sticky="e"))
  Try(tkbind(entry.PlotPointSize,"<Return>",onUpdate))
  Try(tkgrid(tklabel(ttChoosePlotSymbolByClicking,text="    ")))

  Try(tkconfigure(img,cursor="hand2"))
  ReturnVal <- list()
  LeftClick <- function(x,y) # x and y are the mouse coordinates
  {
   Try(onUpdate())
   Try(width  <- as.integer(tclvalue(tkwinfo("width",img))))
   Try(height <- as.integer(tclvalue(tkwinfo("height",img))))

   xMin <- parPlotSize[1] * width
   xMax <- parPlotSize[2] * width
   yMin <- (1-parPlotSize[4]) * height
   yMax <- (1-parPlotSize[3]) * height

   x <- as.numeric(x)
   y <- as.numeric(y)

   xInt <- floor((x-xMin)*6/(xMax-xMin))
   yInt <- floor((y-yMin)*6/(yMax-yMin))

   if (xInt < 0 || xInt>5) return()
   if (yInt < 0 || yInt>5) return()

   pchNum <- (yInt + 1 + 6*xInt)
   pch <- c(as.character(1:25),'*','.','o','O','0','+','-',':','|','%','#')

   mbVal<-tkmessageBox(title="Plot Symbol and Size Chosen",message=paste("Use plot symbol ",pch[pchNum]," with plot point size ",as.numeric(tclvalue(PlotPointSize))," for spots of type \"",spotType,"\"?",sep=""),type="okcancel",icon="question")
   if (tclvalue(mbVal)=="cancel")
       return()
       
   ### onOK ###
   Try(tkgrab.release(ttChoosePlotSymbolByClicking))
   Try(tkdestroy(ttChoosePlotSymbolByClicking))
   Try(tkfocus(.limmaGUIglobals$ttMain))
   Try(ReturnVal <<- list(pch=pch[pchNum],cex=as.numeric(tclvalue(PlotPointSize)),pchIsNumeric=(pch<=25)))
  }
  onCancel <- function() {tkgrab.release(ttChoosePlotSymbolByClicking); tkdestroy(ttChoosePlotSymbolByClicking); tkfocus(.limmaGUIglobals$ttMain); ReturnVal <- list() }
  
  Try(tkbind(img, "<Button-1>",LeftClick))
  Try(tkbind(img, "<Enter>",   onUpdate))
  Try(tkbind(ttChoosePlotSymbolByClicking, "<Destroy>", function() {tkgrab.release(ttChoosePlotSymbolByClicking); tkfocus(.limmaGUIglobals$ttMain);}))

  Cancel.but <- tkbutton(ttChoosePlotSymbolByClicking,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  Try(tkgrid(tklabel(ttChoosePlotSymbolByClicking,text="    "),Cancel.but))
  Try(tkwait.window(ttChoosePlotSymbolByClicking))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  return (ReturnVal)
}

SelectPlotSymbols <- function(SpotTypes)
{
  # SpotTypes contains attribute SpotType, a vector of strings, e.g. c("gene","calibration","ratio")

  Try(if (.limmaGUIglobals$limmaGUIpresentation==TRUE)
    blankLabelText <- "  "
  else
    blankLabelText <- "    ")

  Try(ttSelectPlotSymbolsDialog<-tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.deiconify(ttSelectPlotSymbolsDialog))
  Try(tkgrab.set(ttSelectPlotSymbolsDialog))
  Try(tkfocus(ttSelectPlotSymbolsDialog))
  Try(tkwm.title(ttSelectPlotSymbolsDialog,"Plot point types"))
  Try(tkgrid(tklabel(ttSelectPlotSymbolsDialog,text=blankLabelText)))
 
  Try(PointTypes <- SpotTypes$SpotType)
  Try(PointColors <- SpotTypes$Color)
  Try(if ("PointSize"  %in% colnames(SpotTypes))
    PointSizes <- SpotTypes$PointSize
  else
    PointSizes <- c())
  Try(numPointTypes <- length(PointTypes))
  
  #label2 and 3 were separated onto 2 lines for Presentation.  See if they still look OK in normal font sizes.
  Try(label1 <- tklabel(ttSelectPlotSymbolsDialog,text="If desired, you may adjust the symbols, sizes and colors used for plot points.",font=.limmaGUIglobals$limmaGUIfont2))
  Try(if (.limmaGUIglobals$limmaGUIpresentation==FALSE && numPointTypes>10) # scrollable frame tends not to be wide enough.
  {
    Try(label2 <- tklabel(ttSelectPlotSymbolsDialog,text="The plot point symbol can be a character typed from the keyboard or a special symbol selected using the Browse button.",font=.limmaGUIglobals$limmaGUIfont2))
    Try(label3 <- tklabel(ttSelectPlotSymbolsDialog,text="    ",font=.limmaGUIglobals$limmaGUIfont2))  
  }
  else
  {
    Try(label2 <- tklabel(ttSelectPlotSymbolsDialog,text="The plot point symbol can be a character typed from the keyboard or ",font=.limmaGUIglobals$limmaGUIfont2))
    Try(label3 <- tklabel(ttSelectPlotSymbolsDialog,text="a special symbol selected using the Browse button.",font=.limmaGUIglobals$limmaGUIfont2))
  })
  Try(tkgrid(label1,columnspan=2))
  Try(tkgrid(label2,columnspan=2))
  Try(tkgrid(label3,columnspan=2))  
  Try(tkgrid(tklabel(ttSelectPlotSymbolsDialog,text=blankLabelText)))

  pchIsNumeric <- rep(TRUE,numPointTypes)

  PointTypeTcl <- list()
  for (i in (1:numPointTypes))
      Try(PointTypeTcl[[i]] <- tclVar(PointTypes[i]))

  textVariable.pch <- list()
  for (i in (1:numPointTypes))
      Try(textVariable.pch[[i]] <- tclVar("16"))

  textVariable.cex <- list()
  Try(for (i in (1:numPointTypes))
  {
    Try(if (length(PointSizes)>0)
      Try(textVariable.cex[[i]] <- tclVar(PointSizes[i]))
    else      
      Try(if (tolower(PointTypes[i]) =="gene"||PointTypes[i]=="cDNA")    
      {
          Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows") 
           Try(textVariable.cex[[i]] <- tclVar("0.3"))
          else
            Try(textVariable.cex[[i]] <- tclVar("0.1")))
      }
      else
      {
          Try(textVariable.cex[[i]] <- tclVar("0.6"))
      }))
  })

  textVariable.color <- list()
  for (i in (1:numPointTypes))
      Try(textVariable.color[[i]] <- tclVar(
      rgb(col2rgb(PointColors[i])["red",],col2rgb(PointColors[i])["green",],col2rgb(PointColors[i])["blue",],maxColorValue=255)      
        ))
      
  Try(if (numPointTypes>10)
  {
    TclRequire("BWidget")
    Try(sw <- tkwidget(ttSelectPlotSymbolsDialog,"ScrolledWindow",relief="sunken",borderwidth=2))
    Try(sf <- tkwidget(sw,"ScrollableFrame"))
    Try(tkcmd(sw,"setwidget",sf))
    Try(subfID <- tclvalue(tkcmd(sf,"getframe")))
  }
  else
  {
    Try(sw <- tkframe(ttSelectPlotSymbolsDialog,borderwidth=2))
    Try(subfID <- .Tk.ID(sw))
  })
      
  entry.pch <- list()
  for (i in (1:numPointTypes))
      Try(entry.pch[[i]] <- tkcmd("entry",paste(subfID,".pch",i,sep=""),width="10",font=.limmaGUIglobals$limmaGUIfont2,textvariable=textVariable.pch[[i]]))

  entry.cex <- list()
  for (i in (1:numPointTypes))
      Try(entry.cex[[i]] <- tkcmd("entry",paste(subfID,".cex",i,sep=""),width="10",font=.limmaGUIglobals$limmaGUIfont2,textvariable=textVariable.cex[[i]]))

  canvas.color <- list()
  for (i in (1:numPointTypes))
      Try(canvas.color[[i]] <- tkcmd("canvas",paste(subfID,".canvas",i,sep=""),width="80",height="25",bg=tclvalue(textVariable.color[[i]])))

  onBrowseColor <- function(indexPointType)
  {      
      Try(color <- tclvalue(.Tcl(paste("tk_chooseColor",.Tcl.args(initialcolor=tclvalue(textVariable.color[[indexPointType]]),title="Choose a color")))))
      if (nchar(color)==0)
          return()          
      Try(tclvalue(textVariable.color[[indexPointType]]) <- color)
      Try(tkcmd(paste(subfID,".canvas",indexPointType,sep=""),"configure",bg=color))
  }

  onBrowse <- function(indexPointType)
  {      
      Try(plotSymbolAndSize <- ChoosePlotSymbolByClicking(PointTypes[indexPointType],
                               as.numeric(tclvalue(textVariable.cex[[indexPointType]]))))
      if (length(plotSymbolAndSize)==0)
          return()          
      Try(tclvalue(textVariable.pch[[indexPointType]]) <- paste(plotSymbolAndSize$pch))
      Try(tclvalue(textVariable.cex[[indexPointType]]) <- paste(plotSymbolAndSize$cex))
      Try(pchIsNumeric[indexPointType] <- plotSymbolAndSize$pchIsNumeric)
  }
      
  for (i in (1:numPointTypes))
      eval(parse(text=paste("onBrowse",i," <- function() {onBrowse(",i,",)}",sep="")))

  for (i in (1:numPointTypes))
      eval(parse(text=paste("onBrowseColor",i," <- function() {onBrowseColor(",i,",)}",sep="")))

  button.browse <- list()
  for (i in (1:numPointTypes))
      Try(button.browse[[i]] <- tkcmd("button",paste(subfID,".browse",i,sep=""),text="Browse",command=eval(parse(text=paste("onBrowse",i,sep=""))),font=.limmaGUIglobals$limmaGUIfont2))

  button.browse.color <- list()
  for (i in (1:numPointTypes))
      Try(button.browse.color[[i]] <- tkcmd("button",paste(subfID,".browsecol",i,sep=""),text="Browse",command=eval(parse(text=paste("onBrowseColor",i,sep=""))),font=.limmaGUIglobals$limmaGUIfont2))
     
  Try(tkgrid(tkcmd("label",paste(subfID,".lab",1,sep=""),text=blankLabelText),
         tkcmd("label",paste(subfID,".lab",2,sep=""),text="Spot Type ",font=.limmaGUIglobals$limmaGUIfont2),
         tkcmd("label",paste(subfID,".lab",3,sep=""),text="Plot Point Symbol",font=.limmaGUIglobals$limmaGUIfont2),
         tkcmd("label",paste(subfID,".lab",4,sep=""),text="Plot Point Size  ",font=.limmaGUIglobals$limmaGUIfont2),
         tkcmd("label",paste(subfID,".lab",5,sep=""),text=blankLabelText),
         tkcmd("label",paste(subfID,".lab",6,sep=""),text=blankLabelText),
         tkcmd("label",paste(subfID,".lab",7,sep=""),text="Plot Point Color",font=.limmaGUIglobals$limmaGUIfont2),
         tkcmd("label",paste(subfID,".lab",8,sep=""),text=blankLabelText),         
         tkcmd("label",paste(subfID,".lab",9,sep=""),text=blankLabelText)))
         
  tkgrid(tkcmd("label",paste(subfID,".lab",10,sep=""),text=blankLabelText))

  for (i in (1:numPointTypes))
  {
      Try(tkgrid(tkcmd("label",paste(subfID,".lab",11,"_",i,sep=""),text=blankLabelText),
             tkcmd("label",paste(subfID,".lab",12,"_",i,sep=""),text=PointTypes[i],font=.limmaGUIglobals$limmaGUIfont2,bg="white"),
             entry.pch[[i]],entry.cex[[i]],button.browse[[i]],
             tkcmd("label",paste(subfID,".lab",13,"_",i,sep=""),text=blankLabelText),canvas.color[[i]],
             button.browse.color[[i]],
             tkcmd("label",paste(subfID,".lab",14,"_",i,sep=""),text=blankLabelText)))
      Try(tkgrid.configure(button.browse[[i]],sticky="w"))             
  }             

  tkgrid(sw,columnspan=2,sticky="nsew")
    
  Try(legendCheckboxTcl <- tclVar("1"))
  Try(legendCheckbox <- tkcheckbutton(ttSelectPlotSymbolsDialog,variable=legendCheckboxTcl))  
  Try(tkgrid(tklabel(ttSelectPlotSymbolsDialog,text=blankLabelText))  )
  Try(legendLabel <- tklabel(ttSelectPlotSymbolsDialog,text="Show Legend",font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(legendCheckbox,legendLabel))
  Try(tkgrid.configure(legendCheckbox,sticky="e"))
  Try(tkgrid.configure(legendLabel,sticky="w"))  
  Try(tkgrid(tklabel(ttSelectPlotSymbolsDialog,text=blankLabelText))  )
  
  ReturnVal <- list()
  onOK <- function()
  {
      Try(optVal <- options(warn=-1)) # Supress warning for testing if as.numeric(pch) gives NA.
      Try(ReturnVal <<- list())
      Try(for (i in (1:numPointTypes))
      {
          Try(if (is.na(as.numeric(tclvalue(textVariable.pch[[i]])))) 
              pchIsNumeric[i] <- FALSE
          else
              pchIsNumeric[i] <- TRUE)
      
          if (pchIsNumeric[i])
              Try(listToAdd <- list(pch=as.numeric(tclvalue(textVariable.pch[[i]])),
                                                 cex=as.numeric(tclvalue(textVariable.cex[[i]])),
                                                          col=tclvalue(textVariable.color[[i]]),
                                                          pchIsNumeric=pchIsNumeric[i]))
          else
              Try(listToAdd <- list(pch=tclvalue(textVariable.pch[[i]]),
                                                 cex=as.numeric(tclvalue(textVariable.cex[[i]])),
                                                 col=tclvalue(textVariable.color[[i]]),
                                                 pchIsNumeric=pchIsNumeric[i]))          
          Try(ReturnVal[[i]] <<- listToAdd)
      })
      Try(if (tclvalue(legendCheckboxTcl)=="1") 
        showLegend <- TRUE
      else
        showLegend <- FALSE)        
      Try(ReturnVal <<- list(PlotSymbols=ReturnVal,showLegend=showLegend))
      Try(tkgrab.release(ttSelectPlotSymbolsDialog))
      Try(tkdestroy(ttSelectPlotSymbolsDialog))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(options(optVal))
  }
  Try(onCancel <- function() {Try(tkgrab.release(ttSelectPlotSymbolsDialog));Try(tkdestroy(ttSelectPlotSymbolsDialog));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- list()})
  Try(OK.but <-tkbutton(ttSelectPlotSymbolsDialog,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <-tkbutton(ttSelectPlotSymbolsDialog,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(ttSelectPlotSymbolsDialog,text=blankLabelText))  )
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))
  Try(tkgrid(tklabel(ttSelectPlotSymbolsDialog,text=blankLabelText)))
  Try(tkfocus(ttSelectPlotSymbolsDialog))
  Try(tkbind(ttSelectPlotSymbolsDialog, "<Destroy>", function() {tkgrab.release(ttSelectPlotSymbolsDialog); tkfocus(.limmaGUIglobals$ttMain);}))
  Try(tkwait.window(ttSelectPlotSymbolsDialog))

  return (ReturnVal)
}

plotMAColorCoded <- function()
{
  Try(SlideNamesVec <- get("SlideNamesVec",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(SpotTypes     <- get("SpotTypes", envir=limmaGUIenvironment)) 

  Try(gal <- get("gal",envir=limmaGUIenvironment))    
  Try(WeightingType <- get("WeightingType",envir=limmaGUIenvironment))
  Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
  
  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="Color-Coded M A Plot",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(MA.Available <- get("MA.Available",envir=limmaGUIenvironment))
  Try(if (NormalizedMADataWasImported==FALSE)
  {
    Try(RG <- get("RG",envir=limmaGUIenvironment))  
    Try(MAraw <- get("MAraw",envir=limmaGUIenvironment))
  }
  else
  {
    Try(MA <- get("MAimported",envir=limmaGUIenvironment))  
  })

  if (nrow(SpotTypes)==0)
  {
      Try(tkmessageBox(title="Spot Types",message="No spot types have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(slidenum <- GetSlideNum())
  if (slidenum==0)
      return()

  Try(PlotSymbols <- SelectPlotSymbols(SpotTypes))  
  if (length(PlotSymbols)==0)
      return()
  Try(showLegend  <- PlotSymbols$showLegend)
  Try(PlotSymbols <- PlotSymbols$PlotSymbols)
    
  Try(SpotTypeStatus <- get("SpotTypeStatus", envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  
  Try(pchAllNumeric <- TRUE)       
  Try(pchAllCharacter <- TRUE)
  for (i in (1:numSpotTypes))
  {
      Try(if (PlotSymbols[[i]]$pchIsNumeric==TRUE)
          Try(PlotSymbols[[i]]$pch <- as.numeric(PlotSymbols[[i]]$pch)))
      Try(pchAllNumeric <- (pchAllNumeric && PlotSymbols[[i]]$pchIsNumeric))
      Try(pchAllCharacter <- (pchAllCharacter && (!PlotSymbols[[i]]$pchIsNumeric)))
  }      
      
  Try(cex <- c())
  Try(col <- c())
  Try(if (pchAllNumeric || pchAllCharacter)
      Try(pch <- c())
  else
      Try(pch <- list()))
        
  for (i in (1:numSpotTypes))
  {
  # Some of the i's below have been changed from numSpotTypes-i+1
      Try(cex[i] <- PlotSymbols[[i]]$cex)
      Try(col[i] <- PlotSymbols[[i]]$col)  
      Try(if (pchAllNumeric || pchAllCharacter)
          Try(pch[i] <- PlotSymbols[[i]]$pch)
      else
          Try(pch[[i]] <- PlotSymbols[[i]]$pch))
  }      
#  Try(values <- rev(SpotTypes$SpotType))
  Try(values <- SpotTypes$SpotType)
  
# For debugging
  Try(assign("values",values,limmaGUIenvironment))
  Try(assign("pch",pch,limmaGUIenvironment))
  Try(assign("cex",cex,limmaGUIenvironment))
  Try(assign("col",col,limmaGUIenvironment))   
   
  Try(if (NormalizedMADataWasImported==FALSE)
  {
		Try(NormalizeWithinArraysMB <-tkmessageBox(title="Normalization Within Arrays",message="Normalize Within Arrays?",type="yesnocancel",icon="question",default="no"))
		Try(WhetherToNormalizeWithinArrays <- tclvalue(NormalizeWithinArraysMB))
		if (WhetherToNormalizeWithinArrays=="cancel")
				return()

		Try(NormalizeBetweenArraysMB <-tkmessageBox(title="Normalization Between Arrays",message="Normalize Between Arrays?",type="yesnocancel",icon="question",default="no"))
		Try(WhetherToNormalizeBetweenArrays <- tclvalue(NormalizeBetweenArraysMB))
		if (WhetherToNormalizeBetweenArrays=="cancel")
				return()
	})
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))
  
  Try(if (NormalizedMADataWasImported==FALSE)
  {
		Try(if (!exists("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
		{
			Try(WithinArrayNormalizationMethod <- "printtiploess")
			Try(assign("WithinArrayNormalizationMethod",WithinArrayNormalizationMethod,limmaGUIenvironment))
		})
		Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
  
		SetLayoutParamReturnVal<-1
		Try(if (WhetherToNormalizeWithinArrays=="yes")
		{
				if (length(maLayout)==0) SetLayoutParamReturnVal <-Try(SetLayoutParameters())
				if (SetLayoutParamReturnVal==0) return()  
				Try(maLayout <- get("maLayout",envir=limmaGUIenvironment))    
				if (MA.Available$WithinArrays)
					Try(MA <- get("MAwithinArrays",envir=limmaGUIenvironment))
				else          
				{
					if (WeightingType == "none")
						Try (MA <- normalizeWithinArrays(RG,maLayout,method=WithinArrayNormalizationMethod))
					else
						Try(MA <- normalizeWithinArrays(RG,weights=RG$weights,maLayout,method=WithinArrayNormalizationMethod))
					Try(assign("MAwithinArrays",MA,limmaGUIenvironment))
					Try(MA.Available$WithinArrays <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))        
					Try(tkdelete(.limmaGUIglobals$mainTree,"WithinOnly.Status"))
					Try(WithinArrayNormalizationMethod <- get("WithinArrayNormalizationMethod",envir=limmaGUIenvironment))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinOnly","WithinOnly.Status" ,text=paste("Available (using ",WithinArrayNormalizationMethod,")",sep=""),font=.limmaGUIglobals$limmaGUIfontTree))                

				}
		}
		else
		{
				if (MA.Available$Raw)
					Try(MA <- get("MAraw",envir=limmaGUIenvironment))
				else          
				{
					Try (MA <- MA.RG(RG))
					Try(assign("MAraw",MA,limmaGUIenvironment))
					Try(MA.Available$Raw <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"Raw.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","Raw","Raw.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))        
				}        
		})

		Try(if (WhetherToNormalizeBetweenArrays=="yes") 
		{
			if (WhetherToNormalizeWithinArrays=="yes")
			{
				if (MA.Available$Both)
					Try(MA <- get("MAboth",envir=limmaGUIenvironment))
				else
				{
					Try (MA <- normalizeBetweenArrays(MA))
					Try(assign("MAboth",MA,limmaGUIenvironment))
					Try(MA.Available$Both <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"WithinAndBetween.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","WithinAndBetween","WithinAndBetween.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))
				}

			}
			else
			{
				if (MA.Available$BetweenArrays)
					Try(MA <- get("MAbetweenArrays",envir=limmaGUIenvironment))
				else
				{
					Try (MA <- normalizeBetweenArrays(MA))
					Try(assign("MAbetweenArrays",MA,limmaGUIenvironment))
					Try(MA.Available$BetweenArrays <- TRUE)
					Try(assign("MA.Available",MA.Available,limmaGUIenvironment))
					Try(tkdelete(.limmaGUIglobals$mainTree,"BetweenOnly.Status"))
					Try(tkinsert(.limmaGUIglobals$mainTree,"end","BetweenOnly","BetweenOnly.Status" ,text="Available",font=.limmaGUIglobals$limmaGUIfontTree))                
				}        
			}
		})          
  }) 

  Try(if (min(nchar(gsub("[^0-9]","",SlideNamesVec))==nchar(SlideNamesVec))==TRUE)
     SlideNamesVec <- paste("Slide",SlideNamesVec))
  Try(plotTitle <- paste("M A Plot for ",SlideNamesVec[slidenum],sep="")) 
  Try(if (NormalizedMADataWasImported==FALSE)
  {
		Try(if (WhetherToNormalizeWithinArrays=="no"&&WhetherToNormalizeBetweenArrays=="no")
			Try(plotTitle <- paste(plotTitle,"with no normalization")))
		Try(if (WhetherToNormalizeWithinArrays=="yes"&&WhetherToNormalizeBetweenArrays=="no")
			Try(plotTitle <- paste(plotTitle,"with normalization within arrays only")))    
		Try(if (WhetherToNormalizeWithinArrays=="no"&&WhetherToNormalizeBetweenArrays=="yes")
			Try(plotTitle <- paste(plotTitle,"with normalization between arrays only")))    
		Try(if (WhetherToNormalizeWithinArrays=="yes"&&WhetherToNormalizeBetweenArrays=="yes")
			Try(plotTitle <- paste(plotTitle,"with normalization within and between arrays only")))
  }) 
  Try(plotLabels <- GetPlotLabels(plotTitle,"A","M"))
  Try(if (length(plotLabels)==0) return())
  Try(plotTitle <- plotLabels$plotTitle)
  Try(xLabel    <- plotLabels$xLabel)
  Try(yLabel    <- plotLabels$yLabel)
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))
  Try(tkfocus(.limmaGUIglobals$ttMain))  

  Try(xlim <- c(min(MA$A[,slidenum],na.rm=TRUE),max(MA$A[,slidenum],na.rm=TRUE))) # For default x limits.
  
  plotMA0 <- function()
  {
     Try(opar<-par(bg="white"))
     Try(plotMA(MA,pch=pch,cex=cex,array=slidenum,status=SpotTypeStatus,values=values,
         col=col,main=plotTitle,xlab=xLabel,ylab=yLabel,legend=showLegend,xlim=xlim))
#     Try(title(main=plotTitle))
     Try(tempGraphPar <- par(opar))
  }
  Try(LocalHScale <- .limmaGUIglobals$Myhscale)
  Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
   
#  Try(LocalHScale <- LocalHScale * 1.25)
   
  Try(ttplotMAColorCodedGraph <- tktoplevel(.limmaGUIglobals$ttMain))

  Try(Require("tkrplot"))
  
  Try(tkwm.title(ttplotMAColorCodedGraph,plotTitle))
  Try(img <-tkrplot(ttplotMAColorCodedGraph,plotMA0,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttplotMAColorCodedGraph,img=img))
  Try(plotMenus<-SetupPlotMenus(tt=ttplotMAColorCodedGraph,initialfile=paste(limmaDataSetNameText,"plotMAColorCodedSlide",SlideNamesVec[slidenum],sep=""),
                 plotFunction=plotMA0,img=img))                 
  Try(resizeMenu<-plotMenus$resizeMenu)
  Try(tkadd(resizeMenu, "command", label="Resize Horizontal (A) Axis",command=function() {Try(GetNEWxlimReturnVal<-GetNEWxlim(xlim));if (length(GetNEWxlimReturnVal)==0) return() else xlim <<- GetNEWxlimReturnVal;Try(tkconfigure(img,cursor="watch"));Try(tkrreplot(img,fun=plotMA0,hscale=LocalHScale,vscale=LocalVScale));Try(tkconfigure(img,cursor="arrow"))}))
  Try(tkgrid(img))
  Try(tkfocus(ttplotMAColorCodedGraph))
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))  
}

GetNEWxlim <- function(xlim)
{
  ttGetNEWxlim<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetNEWxlim)
  tkgrab.set(ttGetNEWxlim)
  tkfocus(ttGetNEWxlim)  
  tkwm.title(ttGetNEWxlim,"Horizontal axis limits")
  tkgrid(tklabel(ttGetNEWxlim,text="    "))
  Try(xminTcl <- tclVar(init=format(xlim[1],digits=4)))
  Try(entry.xmin<-tkentry(ttGetNEWxlim,width="40",font=.limmaGUIglobals$limmaGUIfont2,textvariable=xminTcl,bg="white"))
  Try(tkgrid(tklabel(ttGetNEWxlim,text="X Axis Lower Limit : ",font=.limmaGUIglobals$limmaGUIfont2),entry.xmin))
  Try(tkgrid(tklabel(ttGetNEWxlim,text="    ")))
  Try(xmaxTcl <- tclVar(init=format(xlim[2],digits=4)))
  entry.xmax<-tkentry(ttGetNEWxlim,width="40",font=.limmaGUIglobals$limmaGUIfont2,textvariable=xmaxTcl,bg="white")
  tkgrid(tklabel(ttGetNEWxlim,text="X Axis Upper Limit :   ",font=.limmaGUIglobals$limmaGUIfont2),entry.xmax)
  tkgrid(tklabel(ttGetNEWxlim,text="    "))

  tkgrid.configure(entry.xmin,entry.xmax,columnspan=2)
  ReturnVal <- c()
  onOK <- function()
  {
      xmin <- as.numeric(tclvalue(xminTcl))
      xmax <- as.numeric(tclvalue(xmaxTcl))
      Try(tkgrab.release(ttGetNEWxlim))
      Try(tkdestroy(ttGetNEWxlim))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- c(xmin,xmax)
  }
  onCancel <- function() {Try(tkgrab.release(ttGetNEWxlim));Try(tkdestroy(ttGetNEWxlim));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- c()}
  OK.but <-tkbutton(ttGetNEWxlim,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetNEWxlim,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttGetNEWxlim,text="    "),OK.but,Cancel.but)
  tkgrid(tklabel(ttGetNEWxlim,text="    "))
  Try(tkbind(ttGetNEWxlim, "<Destroy>", function() {Try(tkgrab.release(ttGetNEWxlim));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkfocus(ttGetNEWxlim))
  Try(tkwait.window(ttGetNEWxlim))

  return (ReturnVal)
}


ebayesBoxPlots <- function()
{
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(NumParameters         <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(gal <- get("gal",envir=limmaGUIenvironment))
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))    

  if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="Empirical Bayes Statistics Box Plots",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }
  
  if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Empirical Bayes Statistics Box Plots",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  }  
  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])
  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Empirical Bayes Statistic Box Plot",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model Fit from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(ParameterNamesVec  <- GetParameterNames(parameterizationTreeIndex))
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(if ("genelist" %in% attributes(ParameterizationList[[ParameterizationNameNode]])$names)
    Try(genelist <- (ParameterizationList[[ParameterizationNameNode]])$genelist)
  else
    Try(genelist <- get("genelist",limmaGUIenvironment)))   
  GetCoefReturnVal <- GetCoef(parameterizationTreeIndex)
  if (GetCoefReturnVal$coefIndex==0) return()
  Try(coef <- (GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]])$coefOrContrastIndex)
  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))
  Try(ContrastParameterizationIndex <- GetCoefReturnVal$coefIndexList[[GetCoefReturnVal$coefIndex]]$ContrastParameterizationIndex)
  if (GetCoefReturnVal$parameterIsFromMainFit)
    Try(eb  <- (ParameterizationList[[ParameterizationNameNode]])$eb)
  else
  {
    Try(eb  <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb)        
    Try(ParameterNamesVec <- colnames(((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts))
    Try(NumParameters <- length(ParameterNamesVec))    
  }

  ebayesStatistic <- ChooseEbayesStatistic()
  if (ebayesStatistic=="")
    return()

  SpotType <- ChooseSpotType(parameterizationTreeIndex)
  if (SpotType=="")
    return()

### Now check (using table) how many spot sub-types there are for that spot type, e.g.
### for spot type "Calibration", there might be sub types "Calibration Control 1", ... "Calibration Control 6" 

  Try(ndups   <- get("ndups",envir=limmaGUIenvironment))
  Try(spacing   <- get("spacing",envir=limmaGUIenvironment))       # Global version
  Try(spacing <- GetReducedDuplicateSpacing(parameterizationTreeIndex))
  Try(gal2 <-      cbind(gal,SpotTypeStatus=SpotTypeStatus))
  Try(SpotTypes <- get("SpotTypes",envir=limmaGUIenvironment))
  Try(numSpotTypes <- nrow(SpotTypes))
  Try(SpotTypeStatus <- get("SpotTypeStatus",envir=limmaGUIenvironment))      
  Try(SpotTypesForLinearModel <- ParameterizationList[[ParameterizationNameNode]]$SpotTypesForLinearModel)  
  Omit <- ""
  count <- 0
  Try(for (i in (1:numSpotTypes))
  {
    if (SpotTypesForLinearModel[i]==TRUE)
      next()
    count <- count + 1
    if (count>1)
      Omit <-paste(Omit,"|")
    else
      Omit <- "("
    Try(Omit <- paste(Omit," (SpotTypeStatus==\"",SpotTypes[i,"SpotType"],"\")",sep=""))
  })  
  Try(if (nchar(Omit)>0)
  {
    Try(Omit <- paste(Omit,")"))
    Try(Omit <- eval(parse(text=Omit)))
    Try(genelist2 <- uniquegenelist(gal2[!Omit,],ndups=ndups,spacing=spacing))
  }
  else
    Try(genelist2 <- uniquegenelist(gal2,ndups=ndups,spacing=spacing)))
  Try(subGeneList <- genelist2[genelist2[,"SpotTypeStatus"]==SpotType,])
  Try(t1 <- table((subGeneList[,"Name"])))
  Try(SpotSubTypes <- dimnames(t1)[[1]])
  Try(numMatches <- length(SpotSubTypes))

  if (numMatches>50)
    Try(tkmessageBox(title="Ebayes Box Plots",message=paste("There are ",numMatches," sub-types of spot type \"",SpotType,
      "\".  Because there are so many sub-types for this spot type, only one overall box plot will be shown, rather ",
      "than plotting individual box plots for each sub-type.",sep="")))

  if (numMatches==0)
  {
    Try(tkmessageBox(title="Ebayes Box Plots",message=paste("No spots were found with spot type \"",SpotType,
      "\".",sep="")))
    return()
  }
      
  Try(if (NumParameters>1)
    ebayesStatisticsVector <- eb[[ebayesStatistic]][,coef]
  else
    ebayesStatisticsVector <- eb[[ebayesStatistic]])
  
  Try(plotTitle <- "")  
  Try(if (ebayesStatistic=="t")
  {
    plotTitle <- paste("t Statistic Box Plot(s) for Spot Type",SpotType)
    ylabel <- "t Statistic"
  })
  Try(if (ebayesStatistic=="lods")
  {
    plotTitle <- paste("B Statistic Box Plot(s) for Spot Type",SpotType)
    ylabel <- "B Statistic"    
  })
  Try(if (ebayesStatistic=="p.value")
  {
    plotTitle <- paste("P Value Box Plot(s) for Spot Type",SpotType)    
    ylabel <- "P Value"        
  })
  
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(plotTitleList <- GetPlotTitle(plotTitle)) 
  Try(if (length(plotTitleList)==0) return())
  Try(plotTitle <- plotTitleList$plotTitle)    
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))    
  
  Try(if (numMatches<=50)
  {
    Try(plotCommand <- "boxplot(")
    Try(for (i in (1:numMatches))
      plotCommand <- paste(plotCommand,"ebayesStatisticsVector[genelist2[,\"Name\"]==\"",SpotSubTypes[i],"\"],",sep=""))
    Try(plotCommand <- paste(plotCommand,"names=c(",sep=""))
    Try(
    if (numMatches>1)
      for (i in (1:(numMatches-1)))
        plotCommand <- paste(plotCommand,"\"",SpotSubTypes[i],"\"",",",sep=""))
    Try(plotCommand <- paste(plotCommand,"\"",SpotSubTypes[numMatches],"\"),",sep=""))
    Try(if (numMatches>1)
      Try(plotCommand <- paste(plotCommand,"ylab=\"",ylabel,"\",main=plotTitle)",sep=""))
    else
      Try(plotCommand <- paste(plotCommand,"xlab=\"",SpotType,"\",","ylab=\"",ylabel,"\",main=plotTitle)",sep="")))
  }
  else
  {
    Try(plotCommand <- "boxplot(")
    Try(plotCommand <- paste(plotCommand,"ebayesStatisticsVector[genelist2[,\"SpotTypeStatus\"]==\"",SpotType,"\"],",sep=""))
    Try(plotCommand <- paste(plotCommand,"xlab=\"",SpotType,"\",","names=\"",SpotType,"\",",sep=""))
    Try(plotCommand <- paste(plotCommand,"ylab=\"",ylabel,"\",main=plotTitle)",sep=""))    
  })
  
#  tkmessageBox(message=plotCommand)
  
  plotEbayesBoxPlot <- function()
  {
    Try(if (numMatches>50) 
    {
      Try(numMatches <- 1)
      Try(opar<-par(bg="white",lab=c(numMatches,20,7)))
    }
    else
      Try(opar<-par(bg="white",cex.axis=0.7,las=2,plt=c(0.15,0.9,0.2,0.85),lab=c(numMatches,20,7))))
      
    Try(eval(parse(text=plotCommand)))
    Try(tempGraphPar <- par(opar))    
    Try(grid(NULL,col="navy"))
  }

  Try(LocalHScale <- .limmaGUIglobals$Myhscale)
  Try(LocalVScale <- .limmaGUIglobals$Myvscale)   
  
  Try(ttEbayesBoxPlot <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttEbayesBoxPlot,plotTitle))
  Try(Require("tkrplot"))

  Try(img <-tkrplot(ttEbayesBoxPlot,plotEbayesBoxPlot,hscale=LocalHScale,vscale=LocalVScale) )
  Try(SetupPlotKeyBindings(tt=ttEbayesBoxPlot,img=img))
  Try(SetupPlotMenus(tt=ttEbayesBoxPlot,initialfile=paste(limmaDataSetNameText,"EBayesBoxPlot",ParameterNamesVec[coef],sep=""),
                 plotFunction=plotEbayesBoxPlot,img=img))
  
  tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")  
  Try(tkgrid(img))
  Try(tkfocus(ttEbayesBoxPlot))      
}

GetPlotLabels <- function(plottitle="",xlabel="",ylabel="")
{
  ttGetPlotLabels<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetPlotLabels)
  tkgrab.set(ttGetPlotLabels)
  tkfocus(ttGetPlotLabels)  
  tkwm.title(ttGetPlotLabels,"Plot title and axis labels")
  tkgrid(tklabel(ttGetPlotLabels,text="    "))
  TitleTcl <- tclVar(init=plottitle)
  entry.Title<-tkentry(ttGetPlotLabels,width="40",font=.limmaGUIglobals$limmaGUIfont2,textvariable=TitleTcl,bg="white")
  tkgrid(tklabel(ttGetPlotLabels,text="Plot Title : ",font=.limmaGUIglobals$limmaGUIfont2),entry.Title)
  tkgrid(tklabel(ttGetPlotLabels,text="    "))
  xLabelTcl <- tclVar(init=xlabel)
  entry.xLabel<-tkentry(ttGetPlotLabels,width="40",font=.limmaGUIglobals$limmaGUIfont2,textvariable=xLabelTcl,bg="white")
  tkgrid(tklabel(ttGetPlotLabels,text="X Axis Label : ",font=.limmaGUIglobals$limmaGUIfont2),entry.xLabel)
  tkgrid(tklabel(ttGetPlotLabels,text="    "))
  yLabelTcl <- tclVar(init=ylabel)
  entry.yLabel<-tkentry(ttGetPlotLabels,width="40",font=.limmaGUIglobals$limmaGUIfont2,textvariable=yLabelTcl,bg="white")
  tkgrid(tklabel(ttGetPlotLabels,text="Y Axis Label :   ",font=.limmaGUIglobals$limmaGUIfont2),entry.yLabel)
  tkgrid(tklabel(ttGetPlotLabels,text="    "))

  tkgrid.configure(entry.Title,entry.xLabel,entry.yLabel,columnspan=2)
  ReturnVal <- list()
  onOK <- function()
  {
      plotTitle <- tclvalue(TitleTcl)
      xLabel <- tclvalue(xLabelTcl)
      yLabel <- tclvalue(yLabelTcl)
      Try(tkgrab.release(ttGetPlotLabels))
      Try(tkdestroy(ttGetPlotLabels))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- list(plotTitle=plotTitle,xLabel=xLabel,yLabel=yLabel)
  }
  onCancel <- function() {Try(tkgrab.release(ttGetPlotLabels));Try(tkdestroy(ttGetPlotLabels));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- list()}
  OK.but <-tkbutton(ttGetPlotLabels,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetPlotLabels,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttGetPlotLabels,text="    "),OK.but,Cancel.but)
  tkgrid(tklabel(ttGetPlotLabels,text="    "))
  Try(tkbind(ttGetPlotLabels, "<Destroy>", function() {Try(tkgrab.release(ttGetPlotLabels));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkfocus(ttGetPlotLabels))
  Try(tkwait.window(ttGetPlotLabels))

  return (ReturnVal)
}

GetPlotTitle <- function(plottitle="")
{
  ttGetPlotTitle<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetPlotTitle)
  tkgrab.set(ttGetPlotTitle)
  tkfocus(ttGetPlotTitle)  
  tkwm.title(ttGetPlotTitle,"Plot title")
  tkgrid(tklabel(ttGetPlotTitle,text="    "))
  TitleTcl <- tclVar(init=plottitle)
  entry.Title<-tkentry(ttGetPlotTitle,width="50",font=.limmaGUIglobals$limmaGUIfont2,textvariable=TitleTcl,bg="white")
  tkgrid(tklabel(ttGetPlotTitle,text="Plot Title : ",font=.limmaGUIglobals$limmaGUIfont2),entry.Title)
  tkgrid(tklabel(ttGetPlotTitle,text="    "))

  tkgrid.configure(entry.Title,columnspan=2)
  ReturnVal <- list()
  onOK <- function()
  {
      plotTitle <- tclvalue(TitleTcl)
      Try(tkgrab.release(ttGetPlotTitle))
      Try(tkdestroy(ttGetPlotTitle))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- list(plotTitle=plotTitle)
  }
  onCancel <- function() {Try(tkgrab.release(ttGetPlotTitle));Try(tkdestroy(ttGetPlotTitle));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- list()}
  OK.but <-tkbutton(ttGetPlotTitle,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetPlotTitle,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(tklabel(ttGetPlotTitle,text="    "),OK.but,Cancel.but)
  tkgrid(tklabel(ttGetPlotTitle,text="    "))
  Try(tkbind(entry.Title, "<Return>",onOK))  
  Try(tkbind(ttGetPlotTitle, "<Destroy>", function() {Try(tkgrab.release(ttGetPlotTitle));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkfocus(ttGetPlotTitle))  
  Try(tkwait.window(ttGetPlotTitle))

  return (ReturnVal)
}


GetPlotSize <- function()
{
  Try(Myhscale <- .limmaGUIglobals$Myhscale)
  Try(Myvscale <- .limmaGUIglobals$Myvscale)
  ttGetPlotSize<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetPlotSize)
  tkgrab.set(ttGetPlotSize)
  tkfocus(ttGetPlotSize)  
  tkwm.title(ttGetPlotSize,"Plot size")
  tkgrid(tklabel(ttGetPlotSize,text="    "))
  tkgrid(tklabel(ttGetPlotSize,text="If desired, you may adjust the horizontal and vertical size of the plot.",font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
  tkgrid(tklabel(ttGetPlotSize,text="    "))
  HScaleTcl <- tclVar(paste(Myhscale))
  entry.HScale<-tkentry(ttGetPlotSize,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=HScaleTcl,bg="white")
  tkgrid(tklabel(ttGetPlotSize,text="Horizontal Scaling Factor : ",font=.limmaGUIglobals$limmaGUIfont2),entry.HScale,sticky="w")
  tkgrid(tklabel(ttGetPlotSize,text="    "))
  VScaleTcl <- tclVar(paste(Myvscale))
  entry.VScale<-tkentry(ttGetPlotSize,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=VScaleTcl,bg="white")
  tkgrid(tklabel(ttGetPlotSize,text="Vertical Scaling Factor :   ",font=.limmaGUIglobals$limmaGUIfont2),entry.VScale,sticky="w")
  tkgrid(tklabel(ttGetPlotSize,text="    "))
  ReturnVal <- 0
  HScale <- 0
  VScale <- 0
  onOK <- function()
  {
      HScale <<- as.numeric(tclvalue(HScaleTcl))
      VScale <<- as.numeric(tclvalue(VScaleTcl))
      Try(tkgrab.release(ttGetPlotSize))
      Try(tkdestroy(ttGetPlotSize))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      ReturnVal <<- list(HScale=HScale,VScale=VScale)
  }
  onCancel <- function() {Try(tkgrab.release(ttGetPlotSize));Try(tkdestroy(ttGetPlotSize));Try(tkfocus(.limmaGUIglobals$ttMain));ReturnVal <<- list()}
  OK.but <-tkbutton(ttGetPlotSize,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetPlotSize,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but)
  tkgrid(tklabel(ttGetPlotSize,text="    "))
  Try(tkfocus(ttGetPlotSize))
  Try(tkbind(ttGetPlotSize, "<Destroy>", function() {Try(tkgrab.release(ttGetPlotSize));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkbind(entry.HScale, "<Return>",function() tkfocus(entry.VScale))) 
  Try(tkbind(entry.VScale, "<Return>", onOK))
  Try(tkwait.window(ttGetPlotSize))

  return (ReturnVal)
}

SaveGraphAsJpeg <- function(initialfile,plotFunction)
{
  Try(jpegFileName <- tclvalue(tkgetSaveFile(initialfile=initialfile,filetypes="{{JPEG Files} {.jpg .jpeg}} {{All files} *}"))  )
  if (!nchar(jpegFileName)) 
    return()
  Try(len <- nchar(jpegFileName))
  if (len<4)
      Try(jpegFileName <- paste(jpegFileName,".jpg",sep=""))
  else if   ((tolower(substring(jpegFileName,len-3,len))!=".jpg") &&
  (len<5 || (tolower(substring(jpegFileName,len-4,len))!=".jpeg")))
        Try(jpegFileName <- paste(jpegFileName,".jpg",sep=""))

  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows" && Sys.info()["sysname"] != "Darwin")  
  {
    Try(jpegParams <- GetJpegOrPngX11Params(graphFileType="JPEG"))  
    Try(bitmap(file=jpegFileName,bg=jpegParams$bg,res=jpegParams$res,type="jpeg"))
  }
  else
  {
    Try(jpegParams <- GetJpegOrPngParams(graphFileType="JPEG"))
    if (length(jpegParams)==0) return()
    Try(jpeg(file=jpegFileName,width=jpegParams$width,height=jpegParams$height,pointsize=jpegParams$pointsize,bg=jpegParams$bg))
  })
  Try(plotFunction())
  Try(dev.off())
}

SaveGraphAsPNG <- function(initialfile,plotFunction)
{
  Try(pngFileName <- tclvalue(tkgetSaveFile(initialfile=initialfile,filetypes="{{PNG Files} {.png}} {{All files} *}"))  )
  if (!nchar(pngFileName)) 
    return()
  Try(len <- nchar(pngFileName))
  if (len<4)
      Try(pngFileName <- paste(pngFileName,".png",sep=""))
  else if   ((tolower(substring(pngFileName,len-3,len))!=".png"))
        Try(pngFileName <- paste(pngFileName,".png",sep=""))

  Try(if (exists("X11", env=.GlobalEnv) && Sys.info()["sysname"] != "Windows" && Sys.info()["sysname"] != "Darwin")  
  {
    Try(pngParams <- GetJpegOrPngX11Params(graphFileType="PNG"))  
    Try(bitmap(file=pngFileName,bg=pngParams$bg,res=pngParams$res))
  }
  else
  {
    Try(pngParams <- GetJpegOrPngParams(graphFileType="PNG"))
    if (length(pngParams)==0) return()
    Try(png(file=pngFileName,width=pngParams$width,height=pngParams$height,pointsize=pngParams$pointsize,bg=pngParams$bg))
  })
  Try(plotFunction())
  Try(dev.off())
}

SaveGraphAsPostscript <- function(initialfile,plotFunction)
{
  Try(psFileName <- tclvalue(tkgetSaveFile(initialfile=initialfile,filetypes="{{Postscript Files} {.ps .eps}} {{All files} *}"))  )
  if (!nchar(psFileName)) 
    return()
  Try(len <- nchar(psFileName))
  if (len<2)
      Try(psFileName <- paste(psFileName,".ps",sep=""))
  else if   ((tolower(substring(psFileName,len-2,len))!=".ps"))
        Try(psFileName <- paste(psFileName,".ps",sep=""))

  Try(postscript(file=psFileName,title=substring(psFileName,1,nchar(psFileName)-3)))
  Try(plotFunction())
  Try(dev.off())
}

SaveGraphAsPDF <- function(initialfile,plotFunction)
{
  Try(pdfFileName <- tclvalue(tkgetSaveFile(initialfile=initialfile,filetypes="{{PDF Files} {.pdf}} {{All files} *}"))  )
  if (!nchar(pdfFileName)) 
    return()
  Try(len <- nchar(pdfFileName))
  if (len<2)
      Try(pdfFileName <- paste(pdfFileName,".pdf",sep=""))
  else if   ((tolower(substring(pdfFileName,len-3,len))!=".pdf"))
        Try(pdfFileName <- paste(pdfFileName,".pdf",sep=""))

  Try(pdf(file=pdfFileName,title=substring(pdfFileName,1,nchar(pdfFileName)-4)))
  Try(plotFunction())
  Try(dev.off())
}


Resize <- function(img,plotFunction)
{
  Try(PlotSize <- GetPlotSize())
  Try(if (length(PlotSize)==0)      return())
  Try(LocalHScale <- PlotSize$HScale)
  Try(LocalVScale <- PlotSize$VScale)
  Try(tkconfigure(img,cursor="watch"))    
  Try(tkfocus(img))  
  Try(tkrreplot(img,fun=plotFunction,hscale=LocalHScale,vscale=LocalVScale))
  Try(tkconfigure(img,cursor="arrow"))        
}

CopyGraph <- function(img) Try(tkrreplot(img))  

SetupPlotKeyBindings <- function(tt,img)
{
  Try(tkbind(tt, "<Control-C>", function() CopyGraph(img)))  
  Try(tkbind(tt, "<Control-c>", function() CopyGraph(img)))  
}  

SetupPlotMenus <- function(tt,initialfile,plotFunction,img)
{
  Try(topMenu <- tkmenu(tt))
  Try(tkconfigure(tt, menu=topMenu))
  Try(fileMenu <- tkmenu(topMenu, tearoff=FALSE))
  Try(editMenu <- tkmenu(topMenu, tearoff=FALSE))
  Try(resizeMenu <- tkmenu(topMenu, tearoff=FALSE))  

  Try(tkadd(fileMenu, "command", label="Save As PNG",command=function() SaveGraphAsPNG(initialfile=initialfile,plotFunction=plotFunction))) # ) # ,font=limmaGUIfontMenu))
  Try(tkadd(fileMenu, "command", label="Save As JPEG",command=function() SaveGraphAsJpeg(initialfile=initialfile,plotFunction=plotFunction))) # ) # ,font=limmaGUIfontMenu))  
  Try(tkadd(fileMenu, "command", label="Save As Postscript",command=function() SaveGraphAsPostscript(initialfile=initialfile,plotFunction=plotFunction))) # ) # ,font=limmaGUIfontMenu))
  Try(tkadd(fileMenu, "command", label="Save As PDF",command=function() SaveGraphAsPDF(initialfile=initialfile,plotFunction=plotFunction))) # ) # ,font=limmaGUIfontMenu))    
  Try(tkadd(fileMenu, "separator"))
  Try(tkadd(fileMenu, "command", label="Close",command=function() tkdestroy(tt))) # ) # ,font=limmaGUIfontMenu))
  Try(tkadd(topMenu, "cascade", label="File",menu=fileMenu)) # ) # ,font=limmaGUIfontMenu))

  Try(tkadd(editMenu, "command", label="Copy <Ctrl-C>",command=function() CopyGraph(img=img))) # ) # ,font=limmaGUIfontMenu))
  Try(tkadd(topMenu, "cascade", label="Edit", menu=editMenu)) # ) # ,font=limmaGUIfontMenu))

  Try(tkadd(resizeMenu, "command", label="Resize Window",command=function() Resize(img=img,plotFunction=plotFunction))) # ) # ,font=limmaGUIfontMenu))
  Try(tkadd(topMenu, "cascade", label="Resize", menu=resizeMenu)) # ) # ,font=limmaGUIfontMenu))
  return (list(topMenu=topMenu,fileMenu=fileMenu,editMenu=editMenu,resizeMenu=resizeMenu))
}

GetJpegOrPngParams <- function(graphFileType)
{
  ttGetJpegOrPngParams<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetJpegOrPngParams)
  tkgrab.set(ttGetJpegOrPngParams)
  tkfocus(ttGetJpegOrPngParams)  
  tkwm.title(ttGetJpegOrPngParams,paste(graphFileType,"Image Parameters"))
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
  tkgrid(tklabel(ttGetJpegOrPngParams,text=paste(graphFileType,"Image Parameters"),font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
  WidthTcl <- tclVar(paste(600))
  entry.Width<-tkentry(ttGetJpegOrPngParams,width="10",font=.limmaGUIglobals$limmaGUIfont2,textvariable=WidthTcl,bg="white")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="Width   ",font=.limmaGUIglobals$limmaGUIfont2),entry.Width,tklabel(ttGetJpegOrPngParams,text="    "),sticky="w")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
  HeightTcl <- tclVar(paste(600))
  entry.Height<-tkentry(ttGetJpegOrPngParams,width="10",font=.limmaGUIglobals$limmaGUIfont2,textvariable=HeightTcl,bg="white")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="Height    ",font=.limmaGUIglobals$limmaGUIfont2),entry.Height,tklabel(ttGetJpegOrPngParams,text="    "),sticky="w")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
  BackgroundTcl <- tclVar("white")
  entry.Background<-tkentry(ttGetJpegOrPngParams,width="10",font=.limmaGUIglobals$limmaGUIfont2,textvariable=BackgroundTcl,bg="white")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="Background    ",font=.limmaGUIglobals$limmaGUIfont2),entry.Background,tklabel(ttGetJpegOrPngParams,text="    "),sticky="w")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
  PointSizeTcl <- tclVar(paste(12))
  entry.PointSize<-tkentry(ttGetJpegOrPngParams,width="10",font=.limmaGUIglobals$limmaGUIfont2,textvariable=PointSizeTcl,bg="white")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="Font Size    ",font=.limmaGUIglobals$limmaGUIfont2),entry.PointSize,tklabel(ttGetJpegOrPngParams,text="    "),sticky="w")
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
    
  ReturnVal <- list()
  Width <- 600
  Height <- 600
  Background <- "white"
  PointSize <- 12
  
  onOK <- function()
  {
      Try(Width  <<- as.numeric(tclvalue(WidthTcl)))
      Try(Height <<- as.numeric(tclvalue(HeightTcl)))
      Try(Background <<- tclvalue(BackgroundTcl))
      Try(PointSize <<- as.numeric(tclvalue(PointSizeTcl)))      
      Try(tkgrab.release(ttGetJpegOrPngParams))
      Try(tkdestroy(ttGetJpegOrPngParams))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(ReturnVal <<- list(width=Width,height=Height,pointsize=PointSize,bg=Background))
  }
  onCancel <- function() {Try(tkgrab.release(ttGetJpegOrPngParams));Try(tkdestroy(ttGetJpegOrPngParams));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- list())}
  OK.but <-tkbutton(ttGetJpegOrPngParams,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetJpegOrPngParams,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but)
  tkgrid(tklabel(ttGetJpegOrPngParams,text="    "))
  Try(tkfocus(ttGetJpegOrPngParams))
  Try(tkbind(ttGetJpegOrPngParams, "<Destroy>", function() {Try(tkgrab.release(ttGetJpegOrPngParams));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGetJpegOrPngParams))

  return (ReturnVal)
}

GetJpegOrPngX11Params <- function(graphFileType)
{
  ttGetJpegOrPngX11Params<-tktoplevel(.limmaGUIglobals$ttMain)
  tkwm.deiconify(ttGetJpegOrPngX11Params)
  tkgrab.set(ttGetJpegOrPngX11Params)
  tkfocus(ttGetJpegOrPngX11Params)  
  tkwm.title(ttGetJpegOrPngX11Params,paste(graphFileType,"Image Parameters"))
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="    "))
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text=paste(graphFileType,"Image Parameters"),font=.limmaGUIglobals$limmaGUIfont2),columnspan=2)
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="    "))
  BackgroundTcl <- tclVar("white")
  entry.Background<-tkentry(ttGetJpegOrPngX11Params,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=BackgroundTcl,bg="white")
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="Background    ",font=.limmaGUIglobals$limmaGUIfont2),entry.Background,sticky="w")
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="    "))
  ResolutionTcl <- tclVar("72")
  entry.Resolution<-tkentry(ttGetJpegOrPngX11Params,width="20",font=.limmaGUIglobals$limmaGUIfont2,textvariable=ResolutionTcl,bg="white")
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="Resolution    ",font=.limmaGUIglobals$limmaGUIfont2),entry.Resolution,sticky="w")
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="    "))
    
  ReturnVal <- list()
  Background <- "white"
  Resolution <- 72
  
  onOK <- function()
  {
      Try(Background <<- tclvalue(BackgroundTcl))
      Try(Resolution <<- as.numeric(tclvalue(ResolutionTcl)))
      Try(tkgrab.release(ttGetJpegOrPngX11Params))
      Try(tkdestroy(ttGetJpegOrPngX11Params))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      Try(ReturnVal <<- list(bg=Background,res=Resolution))
  }
  onCancel <- function() {Try(tkgrab.release(ttGetJpegOrPngX11Params));Try(tkdestroy(ttGetJpegOrPngX11Params));Try(tkfocus(.limmaGUIglobals$ttMain));Try(ReturnVal <<- list())}
  OK.but <-tkbutton(ttGetJpegOrPngX11Params,text="   OK   ",command=onOK,font=.limmaGUIglobals$limmaGUIfont2)
  Cancel.but <-tkbutton(ttGetJpegOrPngX11Params,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2)
  tkgrid(OK.but,Cancel.but)
  tkgrid(tklabel(ttGetJpegOrPngX11Params,text="    "))
  Try(tkfocus(ttGetJpegOrPngX11Params))
  Try(tkbind(ttGetJpegOrPngX11Params, "<Destroy>", function() {Try(tkgrab.release(ttGetJpegOrPngX11Params));Try(tkfocus(.limmaGUIglobals$ttMain));}))
  Try(tkwait.window(ttGetJpegOrPngX11Params))

  return (ReturnVal)
}

VennDiagramPlot <- function()
{
  Try(NumParameters <- get("NumParameters",envir=limmaGUIenvironment))  
  Try(ParameterizationList <- get("ParameterizationList",envir=limmaGUIenvironment))
  Try(NumParameterizations <- get("NumParameterizations",envir=limmaGUIenvironment))
  Try(ParameterizationNamesVec <- get("ParameterizationNamesVec",envir=limmaGUIenvironment))  
  Try(ParameterizationTreeIndexVec <- get("ParameterizationTreeIndexVec",envir=limmaGUIenvironment))  
  Try(ArraysLoaded  <- get("ArraysLoaded", envir=limmaGUIenvironment)) 
  Try(NormalizedMADataWasImported<- get("NormalizedMADataWasImported", envir=limmaGUIenvironment))   
  Try(LinearModelComputed <- get("LinearModelComputed", envir=limmaGUIenvironment))   
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))
 
  Try(if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      tkmessageBox(title="Venn Diagram",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error")
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  })

  Try(if (NumParameterizations==0)
  {
    Try(tkmessageBox(title="Venn Diagram",message="There are no parameterizations loaded.  Select \"Create New Parameterization\" or \"Compute Linear Model Fit\" from the \"Linear Model\" menu.",type="ok",icon="error"))
    Try(tkfocus(.limmaGUIglobals$ttMain))
    return()  
  })  

  Try(parameterizationIndex <- ChooseParameterization())
  Try(if (parameterizationIndex==0)    return())
  Try(parameterizationTreeIndex <- ParameterizationTreeIndexVec[parameterizationIndex])

  if (Try(LinearModelComputed[parameterizationIndex]==FALSE))
  {
      Try(tkmessageBox(title="Venn Diagram",message=paste("No linear model fit is available for ",ParameterizationNamesVec[parameterizationIndex],".  Please try Compute Linear Model from the Linear Model menu.",sep=""),type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  }

  Try(ParameterizationNameNode <- paste("ParameterizationName.",parameterizationTreeIndex,sep=""))

  Try(designList <- (ParameterizationList[[ParameterizationNameNode]])$designList)
  Try(design <- designList$design)      

  Try(tstats <- c())
  
  Try(ParametersAndOrContrasts <- GetParametersAndOrContrasts(parameterizationTreeIndex,whatFor="venn"))
  Try(NumParametersSelected <- length(ParametersAndOrContrasts))
  Try(if (NumParametersSelected==0)
    return())
    
  Try(include <- UpDownOrBoth())
  Try(if (include=="")
    return())
   
  Try(coefList <- list())
  Try(contrastsMatrix <- c())
  
#  Try(tkmessageBox(message=paste("NumParametersSelected :",NumParametersSelected)))
  
  for (i in (1:NumParametersSelected))
  {
    Try(coefList[[i]] <- ((ParametersAndOrContrasts[[i]])$coefIndexList[[(ParametersAndOrContrasts[[i]])$coefIndex]])$coefOrContrastIndex)
    Try(ContrastParameterizationIndex <- ParametersAndOrContrasts[[i]]$coefIndexList[[ParametersAndOrContrasts[[i]]$coefIndex]]$ContrastParameterizationIndex)
    Try(if ((ParametersAndOrContrasts[[i]])$parameterIsFromMainFit)
    {
      Try(tstat <- (ParameterizationList[[ParameterizationNameNode]])$eb$t)
      Try(tstat <- as.matrix(tstat))
      Try(if (ncol(tstat)>1)
        tstat <- tstat[,coefList[[i]]])
      Try(contrastsMatrix <- cbind(contrastsMatrix,as.matrix(rep(0,NumParameters))))
      Try(contrastsMatrix[coefList[[i]],ncol(contrastsMatrix)] <- 1)      
      Try(ParameterOrContrastName <- colnames(design)[coefList[[i]]])
    }
    else
    {
#     tkmessageBox(message="OK, we've come across something which looks like a contrast")
      Try(tstat <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$eb$t)
      Try(tstat <- as.matrix(tstat))
      Try(if (ncol(tstat)>1)
        tstat <- tstat[,coefList[[i]]])     
      Try(contrasts.matrix <- ((ParameterizationList[[ParameterizationNameNode]])$Contrasts[[ContrastParameterizationIndex]])$contrastsMatrixInList$contrasts)
#    Try(for (j in (1:ncol(contrasts.matrix)))
#      for (i in (1:nrow(contrasts.matrix)))
#        Try(tkmessageBox(message=paste("contrasts.matrix[",i,",",j,"] = ",contrasts.matrix[i,j],sep=""))))
#    Try(for (j in (1:ncol(contrasts.matrix)))      
#        Try(tkmessageBox(message=paste("colnames(contrasts.matrix)[",j,"] = ",colnames(contrasts.matrix)[j],sep=""))))        
      Try(contrastsMatrix <- cbind(contrastsMatrix,as.matrix(contrasts.matrix[,coefList[[i]]])))
      Try(ParameterOrContrastName <- colnames(contrasts.matrix)[coefList[[i]]])      
    })
    
    Try(if (length(tstats)==0) 
      Try(tstats <- as.matrix(tstat))
    else
    {
      Try(tstats <- cbind(tstats,  as.matrix(tstat)))
    })
    Try(colnames(tstats)[ncol(tstats)] <- ParameterOrContrastName)
  }
    
  Try(clas <- classifyTestsF(tstats,design=design,contrasts=contrastsMatrix))
  Try(vc   <- vennCounts(clas,include=include))
  
  plotVennDiagram <- function()
  {
    Try(opar<-par(bg="white"))
    Try(vennDiagramlimmaGUI(vc,include=include,cex=0.85,mar=rep(1,4)))
    Try(TempGraphPar<-par(opar))
  }
  
  Try(LocalHScale <- .limmaGUIglobals$Myhscale)
  Try(LocalVScale <- .limmaGUIglobals$Myvscale)   

  # FIXME: It'd be nice to list the one, two or three parameters.
  Try(plotTitle <- paste("Venn diagram for parameterization",ParameterizationNamesVec[parameterizationIndex]))

  # Also it'd be nice to allow user labels for the sets, if the default labels are too large.

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch")) 
  Try(tkfocus(.limmaGUIglobals$ttMain))
  Try(ttVennDiagramPlot <- tktoplevel(.limmaGUIglobals$ttMain))  
  Try(tkwm.title(ttVennDiagramPlot,plotTitle))
  Try(Require("tkrplot"))
  img <- tkrplot(ttVennDiagramPlot,plotVennDiagram,hscale=LocalHScale,vscale=LocalVScale) 
  Try(SetupPlotKeyBindings(tt=ttVennDiagramPlot,img=img))
  Try(SetupPlotMenus(tt=ttVennDiagramPlot,initialfile=paste(limmaDataSetNameText,"VennDiagram",sep=""),
                 plotFunction=plotVennDiagram,img=img))
  
  tkgrid(img)
  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow")) 
  tkfocus(ttVennDiagramPlot)  
  
}


UpDownOrBoth <- function()
{
  Try(ttUpDownOrBoth <- tktoplevel(.limmaGUIglobals$ttMain))
  Try(tkwm.title(ttUpDownOrBoth,"D.E. Genes to Include in Venn Diagram"))
  Try(tkwm.deiconify(ttUpDownOrBoth))
  Try(tkgrab.set(ttUpDownOrBoth))
  Try(tkfocus(ttUpDownOrBoth))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    ")))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    "),tklabel(ttUpDownOrBoth,text="Which differentially expressed genes should be",font=.limmaGUIglobals$limmaGUIfont2),tklabel(ttUpDownOrBoth,text="    ")))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    "),tklabel(ttUpDownOrBoth,text="included in the Venn diagram?",font=.limmaGUIglobals$limmaGUIfont2),tklabel(ttUpDownOrBoth,text="    ")))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    ")))
  Try(UpDownOrBothTcl <- tclVar("both"))
  Try(frame1 <- tkframe(ttUpDownOrBoth,relief="groove",borderwidth="2"))
  Try(tkgrid(tkradiobutton(frame1,text="Up-regulated genes",variable=UpDownOrBothTcl,value="up",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))
  Try(tkgrid(tkradiobutton(frame1,text="Down-regulated genes",variable=UpDownOrBothTcl,value="down",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))
  Try(tkgrid(tkradiobutton(frame1,text="Both",variable=UpDownOrBothTcl,value="both",font=.limmaGUIglobals$limmaGUIfont2),sticky="w"))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    "),frame1))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    ")))
  Try(tkframeOKCancel <- tkframe(ttUpDownOrBoth))
  Try(ReturnVal <- "")
  Try(onOK <- function() { Try(ReturnVal <<- tclvalue(UpDownOrBothTcl)); Try(tkdestroy(ttUpDownOrBoth));Try(tkfocus(.limmaGUIglobals$ttMain))})
  Try(onCancel <- function() { Try(tkdestroy(ttUpDownOrBoth));Try(ReturnVal <- "")})
  Try(OK.but     <- tkbutton(tkframeOKCancel,text="   OK   ",command=onOK,    font=.limmaGUIglobals$limmaGUIfont2))
  Try(Cancel.but <- tkbutton(tkframeOKCancel,text=" Cancel ",command=onCancel,font=.limmaGUIglobals$limmaGUIfont2))
  Try(tkgrid(tklabel(tkframeOKCancel,text="    "),columnspan=2))
  Try(tkgrid(OK.but,Cancel.but))
  Try(tkgrid.configure(OK.but,sticky="e"))
  Try(tkgrid.configure(Cancel.but,sticky="w"))  
  Try(tkgrid(tklabel(tkframeOKCancel,text="    "),columnspan=2))
  Try(tkgrid(tklabel(ttUpDownOrBoth,text="    "),tkframeOKCancel))
  
  Try(tkbind(ttUpDownOrBoth, "<Destroy>", function() {Try(tkgrab.release(ttUpDownOrBoth));Try(tkfocus(.limmaGUIglobals$ttMain))}))
  Try(tkwait.window(ttUpDownOrBoth))  
  
  return (ReturnVal)
}


vennDiagramlimmaGUI <- function(object,include="both",names,cex=1.5,mar=rep(1,4),...) {
# Plot Venn diagram
# Gordon Smyth and James Wettenhall
# 4 July 2003.  Last modified 23 September 2003.

  if(class(object) != "VennCounts") object <- vennCounts(object,include=include)
  nsets <- ncol(object)-1
  if(nsets > 3) stop("Can't plot Venn diagram for more than 3 sets")
  if(missing(names)) names <- colnames(object)[1:nsets]
  counts <- object[,"Counts"]
  theta <- 2*pi*(1:360)/360
  xcentres <- list(0,c(-1,1),c(-1,1,0))[[nsets]]
  ycentres <- list(0,c(0,0),c(1/sqrt(3),1/sqrt(3),-2/sqrt(3)))[[nsets]]
  r <- c(1.5,1.5,1.5)[nsets]
  xtext <- list(-1.2,c(-1.2,1.2),c(-1.2,1.2,0))[[nsets]]
  ytext <- list(1.8,c(1.8,1.8),c(2.4,2.4,-3))[[nsets]]
  opar <- par(mar=mar)
  on.exit(par(opar))
  plot(x=0,y=0,type="n",xlim=c(-4,4),ylim=c(-4,4),xlab="",ylab="",axes=FALSE,...)
  for(circle in 1:nsets) {
    lines(xcentres[circle]+r*cos(theta),ycentres[circle]+r*sin(theta))
    text(xtext[circle],ytext[circle],names[circle],cex=cex)
  }
  switch(nsets,
    {
      rect(-3,-2.5,3,2.5)
      text(2.3,-2.1,counts[1],cex=cex)
      text(0,0,counts[2],cex=cex)
    }, {
      rect(-3,-2.5,3,2.5)
        text(2.3,-2.1,counts[1],cex=cex)
      text(1.5,0.1,counts[2],cex=cex)
      text(-1.5,0.1,counts[3],cex=cex)
      text(0,0.1,counts[4],cex=cex)
    }, {
      rect(-3,-3.5,3,3.3)
      text(2.5,-3,counts[1],cex=cex)
      text(0,-1.7,counts[2],cex=cex)
      text(1.5,1,counts[3],cex=cex)
      text(.75,-.35,counts[4],cex=cex)
      text(-1.5,1,counts[5],cex=cex)
      text(-.75,-.35,counts[6],cex=cex)
      text(0,.9,counts[7],cex=cex)
      text(0,0,counts[8],cex=cex)
    }
  )
  invisible()
}


plotMAlimmaGUI <- function(MA,array=1,pch=16,status=NULL,
              values=c("gene","blank","buffer","utility","negative","calibration","ratio"),
              col=c("black","yellow","orange","pink","brown","blue","red"),
              cex=c(0.1,0.6,0.6,0.6,0.6,0.6,0.6),main=colnames(MA$M)[array],xlab="A",ylab="M",showLegend=TRUE,xlim=NULL) 
{
#  MA-plot
#  Gordon Smyth.  Modified by James Wettenhall to accept lists for pch.
#  7 April 2003.  Last modified 27 June 2003.

         x <- MA$A[,array]
         y <- MA$M[,array]
         if (is.list(pch)) 
             isListPCH <- TRUE 
         else 
             isListPCH <- FALSE
         pch <- as.list(pch)
         if (is.null(xlim))
         {
             xmin <- min(x,na.rm=TRUE)
             xmax <- max(x,na.rm=TRUE)
         }
         else
         {
             xmin <- xlim[1]
             xmax <- xlim[2]
         }
                  
         plot(x,y,xlab=xlab,ylab=ylab,main=main,type="n",xlim=c(xmin,xmax))
         if(is.null(status))
                 points(x,y,pch=pch[[1]],cex=cex[1])
         else {
                 nvalues <- length(values)
                 if (length(pch) < nvalues)
                     pch <- rep(pch,length=nvalues)
                 col <- rep(col,nvalues)
                 cex <- rep(cex,nvalues)
                 for (i in 1:nvalues) {
                         sel <- status==values[i]
                         points(x[sel],y[sel],pch=pch[[i]],cex=cex[i],col=col[i])
                 }
                 if (showLegend)
                 {
                   if (isListPCH)
                     legend(min(xmin,min(x,na.rm=TRUE)),max(y,na.rm=TRUE),pch=unlist(pch),legend=values,col=col,cex=0.9)
                   else
                     legend(min(xmin,min(x,na.rm=TRUE)),max(y,na.rm=TRUE),pch=unlist(pch),legend=values,col=col,cex=0.9)
                 }
         }
         invisible()
}


showGAL <- function()
{
  Try(gal <- get("gal",envir=limmaGUIenvironment))
  Try(limmaDataSetNameText <- get("limmaDataSetNameText",envir=limmaGUIenvironment))  
  Try(ArraysLoaded <- get("ArraysLoaded",envir=limmaGUIenvironment))
  Try(NormalizedMADataWasImported <- get("NormalizedMADataWasImported",envir=limmaGUIenvironment))
  
  Try(if (ArraysLoaded==FALSE && NormalizedMADataWasImported==FALSE)
  {
      Try(tkmessageBox(title="View Gene List",message="No arrays have been loaded.  Please try New or Open from the File menu.",type="ok",icon="error"))
      Try(tkfocus(.limmaGUIglobals$ttMain))
      return()
  })
  

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="watch"))

  Try(nrows <- nrow(gal))
  Try(ncols <- ncol(gal))  
  
	Try(tempfile1 <- tempfile())
	Try(write.table(gal,file=tempfile1,quote=FALSE,col.names=NA,sep="\t"))
	Try(ttGALTable <- tktoplevel(.limmaGUIglobals$ttMain))
	Try(tkwm.title(ttGALTable,"Gene List"))
	Try(xscr <-tkscrollbar(ttGALTable, repeatinterval=5,orient="horizontal",command=function(...)tkxview(txt,...)))
	Try(scr <- tkscrollbar(ttGALTable, repeatinterval=5,command=function(...)tkyview(txt,...)))
	Try(txt <- tktext(ttGALTable, bg="white", font="courier",xscrollcommand=function(...)tkset(xscr,...),yscrollcommand=function(...)tkset(scr,...),wrap="none",width=60))

	Try(copyText2 <- function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Copy>>"))))

	Try(editPopupMenu2 <- tkmenu(txt, tearoff=FALSE))
	Try(tkadd(editPopupMenu2, "command", label="Copy <Ctrl-C>",command=copyText2))

	RightClick2 <- function(x,y) # x and y are the mouse coordinates
	{
	 Try(rootx <- as.integer(tkwinfo("rootx",txt)))
	 Try(rooty <- as.integer(tkwinfo("rooty",txt)))
	 Try(xTxt <- as.integer(x)+rootx)
	 Try(yTxt <- as.integer(y)+rooty)
	 Try(.Tcl(paste("tk_popup",.Tcl.args(editPopupMenu2,xTxt,yTxt))))
	}
	Try(tkbind(txt, "<Button-3>",RightClick2))

	Try(tkpack(scr, side="right", fill="y"))
	Try(tkpack(xscr, side="bottom", fill="x"))
	Try(tkpack(txt, side="left", fill="both", expand="yes"))

	Try(chn <- tclvalue(tkcmd("open", tempfile1)))
	Try(tkinsert(txt, "end", tclvalue(tkcmd("read", chn))))
	Try(tkcmd("close", chn))
	Try(tkconfigure(txt, state="disabled"))
	Try(tkmark.set(txt,"insert","0.0"))
	Try(tkfocus(txt))

  Try(tkconfigure(.limmaGUIglobals$ttMain,cursor="arrow"))
  
  SaveGAL <- function()
  {
    Try(galFile <- tclvalue(tkgetSaveFile(initialfile=paste(limmaDataSetNameText,".gal",sep=""))))
    Try(if (!nchar(galFile))
      return())
    Try(write.table(gal,file=galFile,quote=FALSE,row.names=FALSE,sep="\t"))
  } 
  
	Try(copyFcn <-      function() .Tcl(paste("event","generate",.Tcl.args(.Tk.ID(txt),"<<Copy>>"))))

	Try(topMenu2 <- tkmenu(ttGALTable))
	Try(tkconfigure(ttGALTable, menu=topMenu2))
	Try(fileMenu2 <- tkmenu(topMenu2, tearoff=FALSE))
	Try(tkadd(fileMenu2, "command", label="Save As",command=SaveGAL))
	Try(tkadd(fileMenu2, "command", label="Close",command=function() tkdestroy(ttGALTable)))
	Try(tkadd(topMenu2, "cascade", label="File",menu=fileMenu2))
	Try(editMenu2 <- tkmenu(topMenu2, tearoff=FALSE))
	Try(tkadd(editMenu2, "command", label="Copy <Ctrl-C>",command=copyFcn))
	Try(tkadd(topMenu2, "cascade", label="Edit",menu=editMenu2))

	Try(tkfocus(ttGALTable))
  
}

.First.lib <- function(libname, pkgname, where) 
{
     ## Make sure the system can use tcltk
     capable <- capabilities()
     if(!capable["tcltk"]){
         stop(paste("The tcl/tk library is not available in your system.",
                    "Download/install the tcltk library from",
                    "www.tcl.tk/software/tcltk/"))
     }else{
         if(interactive()){
             out <- paste("Package tcltk not able to be loaded!")
             if (.Platform$OS.type == "windows")
                 out <- paste(out,"\nThe most likely cause of this",
                              "is that your Tcl/Tk installation is",
                              "misconfigured\nPlease see the R",
                              "Windows FAQ, question 3.6:\n",
                              "http://cran.r-project.org/bin/windows/contrib/rw-FAQ.html#Package%20TclTk%20does%20not%20work.")

             require("tcltk", character.only = TRUE) || stop(out)
         }
     }

  if (data.class(try(require(limma),TRUE))=="try-error")
  {
    tkmessageBox(title="An error has occured!",message=paste("Cannot find package limma"),icon="error",type="ok")
    stop("Cannot find package limma")
  } 
  if (require(limma)==FALSE)
  {
    tkmessageBox(title="An error has occured!",message=paste("Cannot find package limma"),icon="error",type="ok")
    stop("Cannot find package limma")
  }

  if (interactive())
  {
		if (.Platform$OS.type=="windows")
		{
			regPath  <- "HKEY_CURRENT_USER\\SOFTWARE\\ActiveState\\ActiveTcl"
			regPath2 <- "HKEY_LOCAL_MACHINE\\SOFTWARE\\ActiveState\\ActiveTcl"
			if(inherits(try(TclVersion <- tclvalue(tkcmd("registry","get",regPath,"CurrentVersion")),TRUE),"try-error")&&
				 inherits(try(TclVersion2 <- tclvalue(tkcmd("registry","get",regPath2,"CurrentVersion")),TRUE),"try-error"))
			{
				cat(paste("\nWarning: ActiveTcl could not be found in the Windows Registry.\n"))
				cat(paste("\nEither it has not been installed or it has not been installed with sufficient privileges.\n\n"))
				cat(paste("\nlimmaGUI requires the Tcl/Tk extensions Tktable and BWidget which are not distributed with R,\n"))
				cat(paste("\nbut they are distributed with ActiveTcl.\n"))
			}
			else
			{
				if (!inherits(try(TclVersion <- tclvalue(tkcmd("registry","get",regPath,"CurrentVersion")),TRUE),"try-error"))
				{
					regPath <- paste(regPath,TclVersion,sep="\\")
					TclPath <-  tclvalue(tkcmd("registry","get",regPath,""))
					cat(paste("\nActiveTcl was found in the Windows Registry (for CURRENT_USER), installed in",TclPath,sep="\n"))
					cat(paste("\nThis directory will be added to the Tcl search path to enable limmaGUI\n"))
					cat(paste("to find the Tktable and BWidget extensions.\n"))
					addTclPath(paste(gsub("\\\\","/",TclPath),"lib",sep="/"))
				}
				if (!inherits(try(TclVersion2 <- tclvalue(tkcmd("registry","get",regPath2,"CurrentVersion")),TRUE),"try-error"))      
				{
					regPath2 <- paste(regPath2,TclVersion2,sep="\\")
					TclPath2 <-  tclvalue(tkcmd("registry","get",regPath2,""))
					cat(paste("\nActiveTcl was found in the Windows Registry (for LOCAL_MACHINE), installed in",TclPath2,sep="\n"))
					cat(paste("\nThis directory will be added to the Tcl search path to enable limmaGUI\n"))
					cat(paste("to find the Tktable and BWidget extensions.\n"))
					addTclPath(paste(gsub("\\\\","/",TclPath2),"lib",sep="/"))
				}
			}
		}


		if ((.Platform$OS.type=="windows")&&(.Platform$GUI == "Rgui"))
		{
			winMenuAdd("limmaGUI");winMenuAddItem("limmaGUI","limmaGUI","limmaGUI()")
			cat(paste("\nlimmaGUI can be launched by typing limmaGUI() or by using the pull-down menu.\n"))
#  		if(!length(grep("^Biobase$", .packages()))&&!length(grep("^limma$", .packages()))) winMenuAdd("Vignettes")
#  		winMenuAddItem("Vignettes", "limmaGUI", "limmaGUIhelp()")

		}
		else
			cat(paste("\nlimmaGUI can be launched by typing limmaGUI()\n"))

# Note that running the whole limmaGUI() program while still within .First.lib seems to work in Windows,
# but I had problems in Linux, hence the .Platform$OS.type below...
    if (.Platform$OS.type=="windows")
    {
		  BeginLimmaGUI <- tclvalue(tkmessageBox(title="limmaGUI",message="Begin limmaGUI?",type="yesno",icon="question"))
		  if (BeginLimmaGUI=="yes") 
		  	limmaGUI()
		  else
				bringToTop(-1)
		}

	}
}

