diff --git a/schainpy2/Graphics/schainPlot.py b/schainpy2/Graphics/schainPlot.py
index e19ffdc..febfb8e 100644
--- a/schainpy2/Graphics/schainPlot.py
+++ b/schainpy2/Graphics/schainPlot.py
@@ -1,4 +1,5 @@
 import numpy
+import datetime
 from schainPlotLib import Driver
 
 class Figure:
@@ -14,10 +15,15 @@ class Figure:
     overplot = None
     xmin = None
     xmax = None
+    ymin = None
+    ymax = None
     minvalue = None
     maxvalue = None
+    deltax = None
+    deltay = None
     frameObjList = []
-    figtitle = ""
+    figuretitle = ""
+    xrangestep = None
     
     def __init__(self,idfigure, nframes, wintitle, xw=600, yw=800, overplot=0, driver='plplot', colorbar= True, colormap=None, *args):
         self.idfigure = idfigure
@@ -35,6 +41,7 @@ class Figure:
         self.drvObj = Driver(driver, idfigure, xw, yw, wintitle, overplot, colorbar, colormap)
         
         self.drvObj.driver.setFigure()
+        self.drvObj.driver.setColormap(colormap)
         
     
     def __openDriver(self):
@@ -49,12 +56,20 @@ class Figure:
     def __initFigure(self):
         nrows, ncolumns = self.getSubplots()
         self.drvObj.driver.openFigure()
-        self.drvObj.driver.setFigTitle(self.figtitle)
+        self.drvObj.driver.setFigTitle(self.figuretitle)
         self.drvObj.driver.setSubPlots(nrows, ncolumns)
     
     def __isOutOfXRange(self,x):
+        
+        if ((x>=self.xmin) and (x<self.xmax)):
+            return 0
+
         return 1
     
+    def changeXRange(self,x):
+        
+        pass
+    
     def __refresh(self):
         self.drvObj.driver.refresh()
     
@@ -101,6 +116,7 @@ class Figure:
                 self.driverObj.closePage()
                 self.__isFigureOpen = False
         
+        
         self.__initFigure()
 
         for channel in channelList:
@@ -135,32 +151,20 @@ class Figure:
 
     
     def plotPcolor(self,data, 
-                            x=None, 
-                            y=None, 
-                            channelList=None, 
-                            xmin=None, 
-                            xmax=None, 
-                            ymin=None, 
-                            ymax=None,
-                            minvalue=None, 
-                            maxvalue=None, 
-                            figuretitle=None,
-                            deltax=None, 
-                            save=False, 
-                            gpath='./'):
-#                    data,
-#                    currenttime,
-#                    range,
-#                    starttime,
-#                    endtime,
-#                    minrange,
-#                    maxrange,
-#                    minvalue,
-#                    maxvalue,
-#                    figuretitle,
-#                    interval,
-#                    save,
-#                    gpath):
+                    x=None, 
+                    y=None, 
+                    channelList=None, 
+                    xmin=None, 
+                    xmax=None, 
+                    ymin=None, 
+                    ymax=None,
+                    minvalue=None, 
+                    maxvalue=None, 
+                    figuretitle=None,
+                    xrangestep=None, 
+                    save=False, 
+                    gpath='./'):
+
         
         if figuretitle == None:
             self.figuretitle = ""
@@ -175,31 +179,55 @@ class Figure:
             
         if not(self.__isConfig):
             
-            self.setParms(data,x,y,xmin,xmax,ymin,ymax,minvalue,maxvalue,deltax)
-            
+            self.setParms(data,x,y,xmin,xmax,ymin,ymax,minvalue,maxvalue,xrangestep)
            
-            
-#            if self.xmin == None: self.xmin = numpy.min(x)
-#            if self.xmax == None: self.xmax = numpy.max(x)
-            
-            
             self.createFrames()
             self.__isConfig = True
         
-        if not(self.__isOutOfXRange(x)):
-            self.__changeXRange(x)
+        if (self.__isOutOfXRange(x)):
             
-            if self.__isFigureOpen:
-                self.driverObj.closePage()
-                self.__isFigureOpen = False
+            if not(self.changeXRange(x)):
+                return 0
+            
+            self.__isFigureOpen = False
+            
+#            if self.__isFigureOpen:
+#                self.driverObj.closePage()
+#                self.__isFigureOpen = False
         
+        if not(self.__isFigureOpen):
+
+            
             self.__initFigure()
+            self.__isFigureOpen = True
+        
+            for channel in channelList:
+                frameObj = self.frameObjList[channel]
+                frameObj.init(xmin=self.xmin,
+                              xmax=self.xmax,
+                              ymin=self.ymin,
+                              ymax=self.ymax,
+                              minvalue=self.minvalue,
+                              maxvalue=self.maxvalue,
+                              deltax=self.deltax,
+                              deltay=self.deltay)
+        
+        for channel in channelList:
+            dataCh = data[channel,:]
+            frameObj = self.frameObjList[channel]
+#            frameObj.clearData()
+            frameObj.plot(x, y, dataCh)
+            
+#            frameObj.refresh()
+        self.__refresh()
+            
 
     
 class Frame:
     nplots = None
     plotObjList = []
     title = ""
+    
     def __init__(self,drvObj, idframe):
         self.drvObj = drvObj
         self.idframe = idframe
@@ -211,22 +239,25 @@ class Frame:
     def getScreenPosMainPlot(self):
         raise ValueError, "No implemented"
 
+    def getScreenPosGraph1(self):
+        raise ValueError, "No implemented"
+    
     def getScreenPos(self, nplot):
         
         if nplot == 0:
             xi, yi, xw, yw = self.getScreenPosMainPlot()
+        
+        if nplot == 1:
+            xi, yi, xw, yw = self.getScreenPosGraph1()
+            
         return xi, yi, xw, yw
     
     
-    def init(self, xmin, xmax, ymin, ymax, minvalue, maxvalue):   
+    def init(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax=None, deltay=None):   
          
         for plotObj in self.plotObjList:
-            plotObj.plotBox(xmin, xmax, ymin, ymax, minvalue, maxvalue)
-#            plotObj.setLabels() # ? evaluar si conviene colocarlo dentro del plotbox
-    
-    def refresh(self):
-        for plotObj in self.plotObjList:
-            plotObj.refresh()
+            plotObj.plotBox(xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax, deltay)
+
 
 class Plot:
     title = ""
@@ -251,9 +282,6 @@ class Plot:
         self.xw = xw
         self.yw = yw
 
-#    def setLabels(self):
-#        self.drvObj.driver.setPlotLabels(self.xlabel, self.ylabel, self.title)
-
     def plotBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue):
         self.xmin = xmin
         self.xmax = xmax
@@ -278,6 +306,26 @@ class Plot:
                                    self.timefmt)
         
         self.drvObj.driver.setPlotLabels(self.xlabel, self.ylabel, self.title)
+    
+    def plotPcolor(self, x, y, z, deltax, deltay, getGrid):
+        
+        self.drvObj.driver.pcolor(self.idframe, 
+                                  self.xpos, 
+                                  self.ypos, 
+                                  z, 
+                                  x, 
+                                  y, 
+                                  self.xmin, 
+                                  self.xmax, 
+                                  self.ymin, 
+                                  self.ymax, 
+                                  self.minvalue, 
+                                  self.maxvalue, 
+                                  deltax, 
+                                  deltay, 
+                                  getGrid,
+                                  self.xaxisastime,
+                                  self.timefmt)
         
     def plotBasicLine(self,x, y, color):
         """
@@ -288,7 +336,5 @@ class Plot:
             
             color: 
         """
-        self.drvObj.driver.basicLine(x, y, self.xmin, self.xmax, self.ymin, self.ymax, color, self.idframe, self.xpos, self.ypos)
-
-        
+        self.drvObj.driver.basicLine(self.idframe, self.xpos, self.ypos, x, y, self.xmin, self.xmax, self.ymin, self.ymax, color)
         
\ No newline at end of file
diff --git a/schainpy2/Graphics/schainPlotLib.py b/schainpy2/Graphics/schainPlotLib.py
index 45cf74c..29e751a 100644
--- a/schainpy2/Graphics/schainPlotLib.py
+++ b/schainpy2/Graphics/schainPlotLib.py
@@ -16,7 +16,8 @@ class PlplotDriver:
     
     __isDriverOpen = False
     pldriver = None
-    
+    __xg = None
+    __yg = None
     def __init__(self, idfigure, xw, yw, wintitle, overplot, colormap, colorbar):
         
         if idfigure == None:
@@ -97,7 +98,7 @@ class PlplotDriver:
         plplot.plschr(0.0,szchar)
         plplot.plmtex("t",-1., 0.5, 0.5, title)
     
-    def colorbar(self, minvalue, maxvalue, xpos, ypos):
+    def plotColorbar(self, minvalue, maxvalue, xpos, ypos):
 #        plplot.pladv(id)
 #        plplot.plschr(0.0,szchar-0.05)
         xmin = 0; xmax = 1
@@ -120,7 +121,63 @@ class PlplotDriver:
                        float(xmax),
                        float(ymin),
                        float(ymax))
+    
+    
+    def __getGrid(self, x, y, deltax=None, deltay=None):        
+        
+        if not(len(x)>0 and len(y)>0):
+            raise ValueError, "x axis and y axis are empty"
+        
+        if deltax == None: deltax = x[-1] - x[-2]
+        if deltay == None: deltay = y[-1] - y[-2]
+        
+        x1 = numpy.append(x, x[-1] + deltax)
+        y1 = numpy.append(y, y[-1] + deltay)
+        
+        xg = (numpy.multiply.outer(x1, numpy.ones(len(y1))))
+        yg = (numpy.multiply.outer(numpy.ones(len(x1)), y1))
+        
+        return xg, yg
+    
+    
+    def pcolor(self, id, xpos, ypos, data, x, y, xmin, xmax, ymin, ymax, zmin, zmax, deltax=None, deltay=None, getGrid=True, xaxisastime = False, timefmt="%H:%M"):
+        
+        plplot.pladv(id)
+        plplot.plvpor(xpos[0], xpos[1], ypos[0], ypos[1])
+        plplot.plwind(float(xmin),float(xmax), float(ymin), float(ymax))
         
+        if xaxisastime:
+            timedelta = (xmax - xmin + 1)/8.
+        
+        if getGrid:
+            self.__xg, self.__yg = self.__getGrid(x, y, deltax, deltay)
+        
+        xmin = x[0] 
+        xmax = xmin + deltax
+        
+        plplot.plimagefr(data, 
+                         float(xmin), 
+                         float(xmax), 
+                         float(ymin), 
+                         float(ymax), 
+                         0., 
+                         0., 
+                         float(zmin), 
+                         float(zmax), 
+                         plplot.pltr2, 
+                         self.__xg, 
+                         self.__yg)
+        
+        if xaxisastime:
+            plplot.pltimefmt(timefmt)
+            xopt = "bcstd"
+            yopt = "bcst"
+            plplot.plbox(xopt, timedelta, 3, yopt, 0.0, 0)
+        else:
+            xopt = "bcst"
+            yopt = "bcst"
+            plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
+    
     
     def plotBox(self, id, xpos, ypos, xmin, xmax, ymin, ymax, minvalue, maxvalue, xopt, yopt, szchar=0.6, xaxisastime = False, timefmt="%H:%M"):
         """
@@ -140,7 +197,7 @@ class PlplotDriver:
     def refresh(self):
         plplot.plflush() 
         
-    def basicLine(self, x, y, xmin, xmax, ymin, ymax, color, id, xpos, ypos):
+    def basicLine(self, id, xpos, ypos, x, y, xmin, xmax, ymin, ymax, color):
         
         """
         Inputs:
@@ -174,6 +231,180 @@ class PlplotDriver:
         plplot.plline(x, y)
         plplot.plcol0(1)
         plplot.plbox("bcst", 0.0, 0, "bcst", 0.0, 0)
+    
+    def setColormap(self, colormap="gray"):
+    
+        if colormap == None:
+            return
+            
+        ncolor = None
+        rgb_lvl = None
+        
+        # Routine for defining a specific color map 1 in HLS space.
+        # if gray is true, use basic grayscale variation from half-dark to light.
+        # otherwise use false color variation from blue (240 deg) to red (360 deg).
+    
+        # Independent variable of control points.
+        i = numpy.array((0., 1.))
+        if colormap=="gray":
+            ncolor = 256
+            # Hue for control points.  Doesn't matter since saturation is zero.
+            h = numpy.array((0., 0.))
+            # Lightness ranging from half-dark (for interest) to light.
+            l = numpy.array((0.5, 1.))
+            # Gray scale has zero saturation
+            s = numpy.array((0., 0.))
+            
+            # number of cmap1 colours is 256 in this case.
+            plplot.plscmap1n(ncolor)
+            # Interpolate between control points to set up cmap1.
+            plplot.plscmap1l(0, i, h, l, s)
+            
+            return None
+        
+        if colormap == 'jet':
+            ncolor = 256          
+            pos = numpy.zeros((ncolor))
+            r = numpy.zeros((ncolor))
+            g = numpy.zeros((ncolor))
+            b = numpy.zeros((ncolor))
+            
+            for i in range(ncolor):
+                if(i <= 35.0/100*(ncolor-1)): rf = 0.0
+                elif (i <= 66.0/100*(ncolor-1)): rf = (100.0/31)*i/(ncolor-1) - 35.0/31
+                elif (i <= 89.0/100*(ncolor-1)): rf = 1.0
+                else: rf = (-100.0/22)*i/(ncolor-1) + 111.0/22
+        
+                if(i <= 12.0/100*(ncolor-1)): gf = 0.0
+                elif(i <= 38.0/100*(ncolor-1)): gf = (100.0/26)*i/(ncolor-1) - 12.0/26
+                elif(i <= 64.0/100*(ncolor-1)): gf = 1.0
+                elif(i <= 91.0/100*(ncolor-1)): gf = (-100.0/27)*i/(ncolor-1) + 91.0/27
+                else: gf = 0.0
+        
+                if(i <= 11.0/100*(ncolor-1)): bf = (50.0/11)*i/(ncolor-1) + 0.5
+                elif(i <= 34.0/100*(ncolor-1)): bf = 1.0
+                elif(i <= 65.0/100*(ncolor-1)): bf = (-100.0/31)*i/(ncolor-1) + 65.0/31
+                else: bf = 0           
+                
+                r[i] = rf
+                g[i] = gf
+                b[i] = bf
+            
+                pos[i] = float(i)/float(ncolor-1)
+            
+    
+            plplot.plscmap1n(ncolor)
+            plplot.plscmap1l(1, pos, r, g, b)
+        
+        
+        
+        if colormap=="br_green":
+            ncolor = 256
+            # Hue ranges from blue (240 deg) to red (0 or 360 deg)
+            h = numpy.array((240., 0.))
+            # Lightness and saturation are constant (values taken from C example).
+            l = numpy.array((0.6, 0.6))
+            s = numpy.array((0.8, 0.8))
+    
+            # number of cmap1 colours is 256 in this case.
+            plplot.plscmap1n(ncolor)
+            # Interpolate between control points to set up cmap1.
+            plplot.plscmap1l(0, i, h, l, s)
+            
+            return None
+        
+        if colormap=="tricolor":
+            ncolor = 3
+            # Hue ranges from blue (240 deg) to red (0 or 360 deg)
+            h = numpy.array((240., 0.))
+            # Lightness and saturation are constant (values taken from C example).
+            l = numpy.array((0.6, 0.6))
+            s = numpy.array((0.8, 0.8))
+    
+            # number of cmap1 colours is 256 in this case.
+            plplot.plscmap1n(ncolor)
+            # Interpolate between control points to set up cmap1.
+            plplot.plscmap1l(0, i, h, l, s)
+            
+            return None
+        
+        if colormap == 'rgb' or colormap == 'rgb666':
+            
+            color_sz = 6
+            ncolor = color_sz*color_sz*color_sz
+            pos = numpy.zeros((ncolor))
+            r = numpy.zeros((ncolor))
+            g = numpy.zeros((ncolor))
+            b = numpy.zeros((ncolor))
+            ind = 0
+            for ri in range(color_sz):
+                for gi in range(color_sz):
+                    for bi in range(color_sz):
+                        r[ind] = ri/(color_sz-1.0)
+                        g[ind] = gi/(color_sz-1.0)
+                        b[ind] = bi/(color_sz-1.0)
+                        pos[ind] = ind/(ncolor-1.0)
+                        ind += 1
+            rgb_lvl = [6,6,6]  #Levels for RGB colors
+            
+        if colormap == 'rgb676':
+            ncolor = 6*7*6
+            pos = numpy.zeros((ncolor))
+            r = numpy.zeros((ncolor))
+            g = numpy.zeros((ncolor))
+            b = numpy.zeros((ncolor))
+            ind = 0
+            for ri in range(8):
+                for gi in range(8):
+                    for bi in range(4):
+                        r[ind] = ri/(6-1.0)
+                        g[ind] = gi/(7-1.0)
+                        b[ind] = bi/(6-1.0)
+                        pos[ind] = ind/(ncolor-1.0)
+                        ind += 1
+            rgb_lvl = [6,7,6]  #Levels for RGB colors
+        
+        if colormap == 'rgb685':
+            ncolor = 6*8*5
+            pos = numpy.zeros((ncolor))
+            r = numpy.zeros((ncolor))
+            g = numpy.zeros((ncolor))
+            b = numpy.zeros((ncolor))
+            ind = 0
+            for ri in range(8):
+                for gi in range(8):
+                    for bi in range(4):
+                        r[ind] = ri/(6-1.0)
+                        g[ind] = gi/(8-1.0)
+                        b[ind] = bi/(5-1.0)
+                        pos[ind] = ind/(ncolor-1.0)
+                        ind += 1
+            rgb_lvl = [6,8,5]  #Levels for RGB colors
+                        
+        if colormap == 'rgb884':
+            ncolor = 8*8*4
+            pos = numpy.zeros((ncolor))
+            r = numpy.zeros((ncolor))
+            g = numpy.zeros((ncolor))
+            b = numpy.zeros((ncolor))
+            ind = 0
+            for ri in range(8):
+                for gi in range(8):
+                    for bi in range(4):
+                        r[ind] = ri/(8-1.0)
+                        g[ind] = gi/(8-1.0)
+                        b[ind] = bi/(4-1.0)
+                        pos[ind] = ind/(ncolor-1.0)
+                        ind += 1
+            rgb_lvl = [8,8,4]  #Levels for RGB colors
+        
+        if ncolor == None:
+            raise ValueError, "The colormap selected is not valid"
+        
+        plplot.plscmap1n(ncolor)
+        plplot.plscmap1l(1, pos, r, g, b)
+        
+        return rgb_lvl
 
 
 class MplDriver:
diff --git a/schainpy2/Graphics/schainPlotTypes.py b/schainpy2/Graphics/schainPlotTypes.py
index aea1a8c..1536d4d 100644
--- a/schainpy2/Graphics/schainPlotTypes.py
+++ b/schainpy2/Graphics/schainPlotTypes.py
@@ -1,11 +1,11 @@
-import nump
+import numpy
 import datetime
 import time
 from schainPlot import *
 #from schainPlotLib import Driver
 
 
-class RTIFigure:
+class RTIFigure(Figure):
     overplot = 1
     xw = 700
     yw = 650
@@ -16,6 +16,7 @@ class RTIFigure:
     maxrange = None
     minvalue = None
     maxvalue = None
+    xrangestepinsecs = None
     
     
     def __init__(self, idfigure, nframes, wintitle, driver, colormap="br_green", colorbar= True, showprofile=False):
@@ -28,62 +29,102 @@ class RTIFigure:
         self.driver = driver
         self.drvObj = Driver(self.driver, self.idfigure, self.xw, self.yw, self.wintitle, self.overplot, self.colormap, self.colorbar)
         self.drvObj.driver.setFigure()
+        self.drvObj.driver.setColormap(colormap)
     
     def getSubplots(self):
         nrows = self.nframes 
         ncolumns = 1
         return nrows, ncolumns
     
-    def setParms(self, data, x, y, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax):
-        
-        if minvalue == None: minvalue = numpy.min(data)
-        if maxvalue == None: maxvalue = numpy.max(data)
-        
-        utcdatetime = datetime.datetime.utcfromtimestamp(x)
-        startdatetime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmin.hour,xmin.minute, xmin.second)
-        enddatetime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmax.hour,xmax.minute, xmax.second)
-        deltatime = 0
-        if timezone == "lt": deltatime = time.timezone
-        startTimeInSecs = time.mktime(startdatetime.timetuple()) - deltatime
-        endTimeInSecs = time.mktime(enddatetime.timetuple()) - deltatime
+    def setParms(self, data, x, y, xmin, xmax, ymin, ymax, minvalue, maxvalue, xrangestep):
+        
         self.starttime = xmin
         self.endtime = xmax
-        self.xmin = startTimeInSecs
-        self.xmax = self.xmin + interval
-
         
+        cdatetime = datetime.datetime.utcfromtimestamp(x) #siempre en localtime
+        
+        mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,self.starttime.hour,self.starttime.minute,self.starttime.second)
+        if ((xrangestep == 0) or (xrangestep == None)):
+            maxdatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,self.endtime.hour,self.endtime.minute,self.endtime.second)
+            self.xrangestepinsecs = time.mktime(maxdatetime.timetuple()) - time.mktime(mindatetime.timetuple())
+            npoints = 1000.
+        if xrangestep == 1:
+            maxdatetime = mindatetime + datetime.timedelta(hours=1)
+            self.xrangestepinsecs = 60*60.
+            npoints = 500.
+        if xrangestep == 2:
+            maxdatetime = mindatetime + datetime.timedelta(minutes=1)
+            self.xrangestepinsecs = 60.
+            npoints = 250.
+        if xrangestep == 3:
+            maxdatetime = mindatetime + datetime.timedelta(seconds=1)
+            self.xrangestepinsecs = 1.
+            npoints = 125.
+            
+        xmin = time.mktime(mindatetime.timetuple())
+        xmax = time.mktime(maxdatetime.timetuple())
+        
+        deltax = (xmax-xmin) / npoints
         
-        if ymin == None: ymin = numpy.min(y) 
-        if ymin == None: ymax = numpy.max(y)
         
-        starttime = None
-        endtime = None
-        minrange = None
-        maxrange = None
-        minvalue = None
-        maxvalue = None
+        if ymin == None: ymin = numpy.min(y)
+        if ymax == None: ymax = numpy.max(y)
         
+        if minvalue == None: minvalue = 0.
+        if maxvalue == None: maxvalue = 50.
         
-        self.xmin = s
-        self.xmax = self.starttime + timeinterval
-        self.ymin = minrange
-        self.ymax = maxrange
+        self.xmin = xmin
+        self.xmax = xmax
+        self.minrange = ymin
+        self.maxrange = ymax
+        self.ymin = ymin
+        self.ymax = ymax
         self.minvalue = minvalue
         self.maxvalue = maxvalue
+        self.xrangestep = xrangestep
+        self.deltax = deltax
+        
+    
+    def changeXRange(self,x):
+        
+        cdatetime = datetime.datetime.utcfromtimestamp(x) #siempre en localtime
+        
+        if ((cdatetime.time()>=self.starttime) and (cdatetime.time()<self.endtime)):
+            if self.xrangestep == 1:
+                mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,cdatetime.hour,self.starttime.minute,self.starttime.second)
+                
+            if self.xrangestep == 2:
+                mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,cdatetime.hour,cdatetime.minute,self.starttime.second)
+                
+            if self.xrangestep == 3:
+                mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,cdatetime.hour,cdatetime.minute,cdatetime.second)
 
+#            mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,self.starttime.hour,self.starttime.minute,self.starttime.second)
+            self.xmin = time.mktime(mindatetime.timetuple()) - time.timezone
+            self.xmax = self.xmin + self.xrangestepinsecs
+            
+            self.figuretitle = "%s: %s - %s"%(self.figuretitle,
+                                              datetime.datetime.utcfromtimestamp(self.xmin).strftime("%d-%b-%Y %H:%M:%S"), 
+                                              datetime.datetime.utcfromtimestamp(self.xmax).strftime("%d-%b-%Y %H:%M:%S"))
+        
+        
+            return 1
+        
+        return 0
+        
     
     def createFrames(self):
         for frame in range(self.nframes):
-            frameObj = ScopeFrame(self.drvObj,frame + 1)
+            frameObj = RTIFrame(self.drvObj,frame + 1, self.colorbar, self.showprofile)
             self.frameObjList.append(frameObj)
 
 class RTIFrame(Frame):
-    def __init__(self,drvObj,idframe,colorbar,showProfile):
+    def __init__(self,drvObj,idframe,colorbar,showprofile):
         self.drvObj = drvObj
         self.idframe = idframe
         self.nplots = 1
         
-        if showProfile:
+        if showprofile:
             self.nplots += 1
         
         self.colorbar = colorbar
@@ -95,7 +136,7 @@ class RTIFrame(Frame):
         
         idplot = 0
         xi, yi, xw, yw = self.getScreenPos(idplot)
-        plotObj = RTIPlot(self.drvObj, self.idframe, idplot, xi, yi, xw, yw)
+        plotObj = RTIPlot(self.drvObj, self.idframe, idplot, xi, yi, xw, yw, self.colorbar)
         plotObjList.append(plotObj)
         
         if self.showprofile:
@@ -134,9 +175,28 @@ class RTIFrame(Frame):
         
         return xi, yi, xw, yw
     
+    def plot(self, currenttime, range, data):
+#        for plotObj in self.plotObjList:
+#            plotObj.plot(currenttime, range, data)
+            
+        plotObj = self.plotObjList[0]
+        plotObj.plot(currenttime,range,data)
+        
+        if self.showprofile:
+            plotObj = self.plotObjList[1]
+            plotObj.plot(data,range)
+    
 
-class RTIPlot:
-    def __init__(self,drvObj, idframe, idplot, xi, yi, xw, yw):
+class RTIPlot(Plot):
+    deltax = None
+    deltay = None
+    xrange = [None,None]
+    xminpos = None
+    xmaxpos = None
+    xg = None
+    yg = None
+    
+    def __init__(self,drvObj, idframe, idplot, xi, yi, xw, yw, colorbar):
         self.drvObj = drvObj
         self.idframe = idframe
         self.idplot = idplot
@@ -144,6 +204,7 @@ class RTIPlot:
         self.yi = yi
         self.xw = xw
         self.yw = yw
+        self.colorbar = colorbar
         
         if self.colorbar:
             cbxi = xw + 0.03
@@ -162,16 +223,19 @@ class RTIPlot:
         
         self.szchar = 1.0
         self.title = "Channel %d"%self.idframe
-        self.xlabel = "x-axis"
-        self.ylabel = "y-axis"
+        self.xlabel = "Local Time"
+        self.ylabel = "Range (Km)"
+
     
-    def plotBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue):
+    def plotBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax=None, deltay=None):
         self.xmin = xmin
         self.xmax = xmax
         self.ymin = ymin
         self.ymax = ymax
         self.minvalue = minvalue
         self.maxvalue = maxvalue
+        self.deltax = deltax
+        self.deltay = deltay
         
         self.drvObj.driver.plotBox(self.idframe, 
                                    self.xpos, 
@@ -191,15 +255,26 @@ class RTIPlot:
         self.drvObj.driver.setPlotLabels(self.xlabel, self.ylabel, self.title)
         
         if self.colorbar:
-            self.drvObj.driver.colorbar(minvalue, maxvalue, self.cbxpos,self.cbypos)
+            self.drvObj.driver.plotColorbar(minvalue, maxvalue, self.cbxpos,self.cbypos)
             
-    
-    def plot(self):
-        pass
-
-
-
 
+    
+    def plot(self, currenttime, range, data):
+        
+        if self.xmaxpos == None:
+            self.xmaxpos = currenttime
+            
+        if currenttime >= self.xmaxpos:
+            
+            self.xminpos = currenttime
+            self.xmaxpos = currenttime + self.deltax           
+            x = [currenttime]
+            y = range
+            z = numpy.reshape(data, (1,-1))
+            getGrid = True
+            
+            self.plotPcolor(x, y, z, self.deltax, self.deltay, getGrid)
+            
 
 class ScopeFigure(Figure):
     overplot = 0