#
# This example creates a dialog-like window
# with which one can 
#
# We might want to put this in a dialog.
#

#
# Update the degrees of freedom on the plot.
#
# Make the left and right be event-driven rather
#  than retrieving their values each time.
#
tdist <- function() 
{
   # Change if we remove the slider.
  numPanels <- 4

  panel <- .JNew("JPanel")
  panel$setLayout(.JNew("GridLayout", as.integer(numPanels), as.integer(1)))

    panel1 <- .JNew("JPanel")

    group <- .JNew("ButtonGroup")
    buttons <- list()
    for(i in c("Left", "Right")) {
         b <- .JNew("JRadioButton", i)
         group$add(b)
         panel1$add(b)
         buttons[[i]] <- b
    }

    buttons[["Left"]]$setSelected(TRUE)
   
    panel2 <- .JNew("JPanel")
    panel2$setLayout(.JNew("BorderLayout"))

    tmpPanel <- .JNew("JPanel")
    tmpPanel$setLayout(.JNew("BorderLayout"))

      tmp <- .JNew("JLabel", "d.f.")
      tmp$setHorizontalAlignment(.Java("SwingConstants", "CENTER"))
      df <- .JNew("JTextField", as.integer(3))
      df$setText("30")

    tmpPanel$add("West", tmp)
    tmpPanel$add("East", df)

  panel2$add("West", tmpPanel)

    tmpPanel <- .JNew("JPanel")
      tmp <- .JNew("JLabel", "t-value")
      tvalue <- .JNew("JTextField", as.integer(7))
      tvalue$setText("0.0")
    tmpPanel$add("West", tmp)
    tmpPanel$add("East", tvalue)

   panel2$add("Center", tmpPanel)


  panel3 <- .JNew("JPanel")
  panel3$setLayout(.JNew("BorderLayout"))

  go <- .JNew("JButton", "Compute")
  panel3$add("West", go)

   tmpPanel <- .JNew("JPanel")
      tmpPanel$add(.JNew("JLabel", "Probability"))
      pvalue <- .JNew("JTextField", as.integer(6))
      tmpPanel$add(pvalue)


  panel3$add("Center", tmpPanel)

  panel$add(panel1)
  panel$add(panel2)
  panel$add(panel3)

  slider <- .JNew("JSlider")
   slider$setMinimum(as.integer(0))
   slider$setMaximum(as.integer(1000))

    # transforms a value on the t-value scale to the internal slider 
    # scale
  toSlider <- function(val) {
     as.integer((val + 3.5)*1000/7)
  }

    # transforms a value on the the internal slider 
    # to the t-value scale.
  fromSlider <- function(val) {
     (val*7/1000 - 3.5)
  }


    # Create the ticks for the slider: start at -3.5 and have
    # every .5 units and one at 0.
   ticks <- .JNew("Hashtable")
   for(i in c(0,seq(3.5, .5, by=-0.5))) {
     ticks$put(toSlider(i), .JNew("JLabel", as.character(i)))
     if(i != 0)
       ticks$put(toSlider(-i), .JNew("JLabel", as.character(-i)))
   }

   slider$setPaintLabels(T)
   slider$setPaintTicks(T)
   slider$setPaintTrack(T)
   slider$setLabelTable(ticks)
     # Start in the center
   slider$setValue(as.integer(500))

  panel$add(slider)


  win <- .JNew("GenericFrame", panel)


 x <- seq(-3.5, 3.5, by=0.005)

   # wipes out the contents of the plot, but leaves the axis, etc.
 clear <- function() {
    polygon(c(-3.5,3.5,3.5,-3.5), c(0,0, .38, .38), col="white", border="white")
 }

 initialized <- F
 drawArea <- function(val, df=5, left=T) {
   if(!initialized) {
     plot(x, dt(x,df = df), pch=".")
     initialized <<- T
   } else {
     clear()
     points(x, dt(x,df = df), pch=".")
   }
   

   if(left)
     x <- x[x<=val]  
   else
     x <- rev(x[x>=val])

   polygon(c(x, val, ifelse(left,-3.5, 3.5)), c(dt(x,df=df),0,0), col="gray", border="red")
 }

 getIsLeft <- function() {
   left <<- buttons[["Left"]]$isSelected()
  left
 }

 stateChanged <- function(ev, df=5, left=T) {
#cat("In state changed",df,"\n")
    val <- fromSlider(slider$getValue())
    if(missing(left))
      left <- getIsLeft()
    drawArea(val, df, left)
    setValue(val, F)
 }

 setValue <- function(value, updateSlider=T) {

   df <- as.integer(df$getText())
   val <- pt(value, df)

   left <- getIsLeft()
   if(!left)
      val <- 1 - val

   pvalue$setText(as.character(round(val,5)))

   val <- as.character(round(value, 5))
   tvalue$setText(val)

   if(updateSlider) {
     slider$setValue(toSlider(value))
   }
 }

  # This function can see the variables above.
 actionPerformed <- function(ev) {

#  if(javaIs(ev$getSource(), "JRadioButton")) {
#    getIsLeft()
#    return()
#  }


   left <- getIsLeft()
     
   value <- as.numeric(tvalue$getText())

   setValue(value, T)

     # display the plot
#   drawArea(value, df, left)
 }
 

  # Setup the event handlers.
  # First, export this object to the foreign reference 
  # manager so that the Java engine can resolve it when calling
  # back to an R function/method.

 obj <- list(actionPerformed=actionPerformed, stateChanged = stateChanged)
 ref <- foreignReference(obj)


   # Now, ensure that the R-reference listener classes that we need
   # are available. Dynamically compile them if necessary.
 jdynamicCompile("java.awt.event.ActionListener", "RButtonListener")
 jdynamicCompile("javax.swing.event.ChangeListener", "RSliderListener")

   # Add the listener for the compute button.
 l <- .JavaConstructor("RButtonListener", ref)
 go$addActionListener(l)

   # Add the listener for the slider drags.
 slider$addChangeListener(.JavaConstructor("RSliderListener", ref))


#  for(i in buttons) {
#    buttons$addActionListener(l)
#  }


 return(ref)
}