2DPlot.c

Go to the documentation of this file.

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <math.h>
#include <direct.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "mgui.h"
#include "DAS_Spatram.h"
#include "dcl.h"
#include "dil.h"
#include "bil.h"
#include "DOAS.h"

dil DIL;
palette DPAL;
bil BIL; //Bortul Library Structure
omutemp OMUTEMP;
mtcl MTCL;

MOBJECT MDCreate_2DPlot(char *title);



/*****************************************************/
/*****************************************************/
/*
    Conversion of the x value of the draw area in CCD pixel  
*/
int D2D_X2Counts(int x)
{
    
        return (int)(( (x - 2 * OMUTEMP.oX) / (OMUTEMP.ptimeMat[OMUTEMP.dimx-1].ti_hour - OMUTEMP.ptimeMat[0].ti_hour + 1) ) / (OMUTEMP.COSTX) ); 

}
/*****************************************************/
/*****************************************************/
/*
    Conversion of the y value of the draw area in ADU counts 
*/

double D2D_Y2Counts(int y)
{

    return - OMUTEMP.COSTY * (y - OMUTEMP.oY) + OMUTEMP.tmin; 

}
/*****************************************************/


/*****************************************************
 *  This Callback handles the mouse input events
 *  in the Object
 *****************************************************/
void D2D_AreaInputTemp(MOBJECT obj, MEvent *pe, void *a_data)
{
    static int x1, y1, x2, y2, dx, dy;
    static int xp1, xp2, xp3, yp1, yp2, yp3, p, pol;
    char    buff[128];
    static int      s, f;
//  int     c;
    MOBJECT shell;

    switch (pe->type) 
    {
        
        case E_SELECT:

            break;
        case E_WINDOW_EXIT:

            break;
        case E_BUTTON_PRESS:
            break;
        case E_WINDOW_ENTER:
        case E_MOTION:
            shell = MObjectShell(obj);
            // Drag di un vertice del poligono
                if((pe->mouse.state & Button1Mask) && pol) 
                {
                    if(pol == 2)
                    {
                        MDrawXorLine(obj, xp1, yp1, xp2, yp2);
                        MDrawXorLine(obj, xp1, yp1, xp3, yp3);
                    }
                    pol = 2;
                    xp1 = pe->mouse.x;
                    yp1 = pe->mouse.y;

                }
                else
                {
                    if((pe->mouse.state & Button1Mask) && x1 > 0 && f) 
                    {
                    /*
                     * Erase the old line and draw the new one
                     * while dragging the mouse (draw in Xor mode)
                     */
                        if(f == 2)
                            MDrawXorBox(obj, x1, y1, (x2 - x1), (y2 - y1));
                        f = 2;
                        MDrawXorBox(obj, x1, y1, (pe->mouse.x - x1), (pe->mouse.y - y1));
                    }
                // Drag the box
                    if((pe->mouse.state & Button3Mask) && f == 4)
                    {
                    // Clear previous box
                        MDrawXorBox(obj, x1, y1, (x2 - x1), (y2 - y1));
                        x1 += (pe->mouse.x - dx); x2 += (pe->mouse.x - dx);
                        y1 += (pe->mouse.y - dy); y2 += (pe->mouse.y - dy);
                        MDrawXorBox(obj, x1, y1, (x2 - x1), (y2 - y1));
                        dx = pe->mouse.x;
                        dy = pe->mouse.y;
                    }
                    else
                    {
//                  MDrawXorBox(obj, x2 - 25, y2 - 25, 50, 50);

                        x2 = pe->mouse.x;
//                      BIL.BLENS.LocX = x2 / (int) BIL.BLENS.Pix;
                        y2 = pe->mouse.y;
//                      BIL.BLENS.LocY = y2 / (int) BIL.BLENS.Pix;

//                  MDrawXorBox(obj, LocX[s] - 25, LocY[s] - 25, 50, 50);
                        if(x2 >= 0 && x2 < (int) MObjectGetWidth(obj)  && 
                            y2 >= 0 && y2 < (int) MObjectGetHeight(obj) )
                            {
                                OMUTEMP.locx = (float)D2D_X2Counts(x2);
                                sprintf(buff, "%.1f", OMUTEMP.locx);
                                MObjectSetText(OMUTEMP.LBL_X, buff);
                                
                                OMUTEMP.locy = (float)D2D_Y2Counts(y2);
                                sprintf(buff, "%.1f", OMUTEMP.locy);
                                MObjectSetText(OMUTEMP.LBL_Y, buff);

                            }
                         
                    }
                }
            
            break;
        case E_BUTTON_RELEASE:
            break;
    }
}
/*****************************************************/


/****************************************************************/
void D2D_AssignOrigin(MOBJECT obj)
{

    OMUTEMP.wsize = MObjectGetWidth(obj);
    OMUTEMP.hsize = MObjectGetHeight(obj);

    OMUTEMP.oX = 10;         //Origine asse X
    OMUTEMP.oY = OMUTEMP.hsize - 10; //Origine asse Y
    OMUTEMP.eX = OMUTEMP.wsize - 10; //Fine asse X
    OMUTEMP.eY = 10;         //Fine asse Y


}
/****************************************************************/

/****************************************************************/
void D2D_PlotAxis(MOBJECT ob, int sx, int sy, int ex, int ey, MTColor col)
{

    //Axis Y Left
    //DrawArea
    MDrawLine(ob, sx, sy, sx, ey, col);
    //Image
//  DrawYLine(mim, sx, ey, sy, 0,0,0);

    //Axis X Down
    //DrawArea
    MDrawLine(ob, sx, sy, ex, sy, col);
//  DrawXLine(mim, sy, sx, ex + 1, 0,0,0);
    
    //Axis X Up
    //DrawArea
    MDrawLine(ob, sx, ey, ex, ey, col);
//  DrawXLine(mim, sx, sx, ex, 0,0,0);
    
    //Axis Y Right
    //DrawArea
    MDrawLine(ob, ex, sy, ex, ey, col);
//  DrawYLine(mim, ex, ey, sy, 0,0,0);

}
/****************************************************************/  


/****************************************************************/  

void D2D_PlotGrid(MOBJECT ob, MIMAGE mim, int sx, int sy, int ex, int ey, int nx, int ny)
{
    int X1, X, Y1, Y;
    int j;
    double incry, incrx;
    // Y Grid
    incry = (sy - ey) / ny;
    for(j = 1; j < ny; j++)
    {
        X = sx +1 ; 
        Y = sy - ((int)incry * j);
        X1 = ex;
        Y1 = sy - ((int)incry * j);
        MDrawLine(ob, X, Y, X1, Y1, MTCL.white);
//      DrawXLine(mim, Y, X, X1, 255,255,255);

    }
    //X Grid
    incrx = (double)(ex - sx) / nx;
    for(j = 1; j < nx; j++)
    {
        X = sx + 1 + ((int)incrx * j); 
        Y = sy;
        X1 = sx + 1 + ((int)incrx * j);
        Y1 = ey + 1;
        if(j == (nx/2))
        {
            MDrawLine(ob, X, Y, X1, Y1, MTCL.green);
//          DrawYLine(mim, X, Y1, Y, 0, 255, 0);
        }
        else
        {
            MDrawLine(ob, X, Y, X1, Y1, MTCL.white);
//          DrawYLine(mim, X, Y1, Y, 255,255,255);
        }
    }
}

int D2D_findmaxmin(float plotmat[], int xinf, int xsup, int yinf, int ysup)
{   

    int t, j, er = 0;
    
    float low = 65535;
    float high= -65535;
/*
    for(t = xinf; t < xsup; t++)
    {
        for(j = yinf; j < ysup; j++)
        {
            if(plotmat[t * xsup + j] < low) low = plotmat[t * xsup + j];
            if(plotmat[t * xsup + j] > high) high = plotmat[t * xsup + j];
        }
    }
    OMUTEMP.tmin = low;
    OMUTEMP.tmax = high;
    return 0;
*/
    for(t = xinf; t < xsup; t++)
    {
        for(j = yinf; j < ysup; j++)
        {
            er = MTButtonGetActivationStatus(OMUTEMP.tgb[j%ysup]);
            if (er)
            {

            if(plotmat[t * ysup + j] < low) low = plotmat[t * ysup + j];
            if(plotmat[t * ysup + j] > high) high = plotmat[t * ysup + j];
        
            }
        }
    }
    OMUTEMP.tmin = low ;
    OMUTEMP.tmax = high + (float) 0.5;
    
/*
    for(t = 0 ; t < idx ; t++)
    {
        for(j = 0; j < idy ; j++)
        {   
            er = MTButtonGetActivationStatus(OMUTEMP.tgb[j%idy]);
            if (er)
            {

                X = (int) (ox + (t *  costx));
                Y = (int) (oy - abs((int)((double)(plotmat[t * idy + j] - min) / costy)));
                //Y = (int) (oy - ((plotmat[t * idx + j] - min) / costy));
                X1 = (int) (ox + (t + 1) * costx);
                Y1 = (int) (oy - abs((int)((double)(plotmat[t * idy + j + idy] - min) / costy)));
                //Y1 = (int) (oy - ((plotmat[t * idx + j + 1] - min) / costy));
                MDrawLine(obj, X, Y, X1, Y1, pe[j]);        
            }
        }
    }

  */
    return 0;
}

/****************************************************************/  
void D2D_PoslblX(MOBJECT lbl, int xs, int xe, int xc)
{
    int xd, i,k, xinf,xsup;
    char buf[16];
    int linter;
    double linterinf, lintersup;

    

    if (xc)
    {
        k = (sizeof OMUTEMP.lblx / sizeof OMUTEMP.lblx[0] ); // number of labels
        
        MObjectMap(OMUTEMP.lblx[0]);
        sprintf(buf,"%d", xs);
        MObjectSetText(OMUTEMP.lblx[0], buf);
        
        MObjectMap(OMUTEMP.lblx[k/2]);
        sprintf(buf,"%d", xc);
        MObjectSetText(OMUTEMP.lblx[k/2], buf);

        MObjectMap(OMUTEMP.lblx[k-1]);
        sprintf(buf,"%d", xe);
        MObjectSetText(OMUTEMP.lblx[k -1], buf);
        

        xinf = xc - xs;
        xsup = xe - xc;
        
        linterinf = (double)xinf / (k/2);
        lintersup = (double)xsup / (k/2);

        for (i = k/2 - 1 ;i> 0; i--)
        {
            MObjectMap(OMUTEMP.lblx[i]);
            sprintf(buf,"%.0lf", xc - ((k/2 - i) * linterinf) );
            MObjectSetText(OMUTEMP.lblx[i], buf);   
        }
        for (i = k/2 + 1 ;i< k - 1; i++)
        {
            MObjectMap(OMUTEMP.lblx[i]);
            sprintf(buf,"%.0lf", xc + ((i - k/2) * lintersup) );
            MObjectSetText(OMUTEMP.lblx[i], buf);   
        }

    }
    else
    {
        xd = xe - xs + 1;
        linter = xd / (sizeof OMUTEMP.lblx / sizeof OMUTEMP.lblx[0] - 1);
        k = (sizeof OMUTEMP.lblx / sizeof OMUTEMP.lblx[0] );

        MObjectMap(OMUTEMP.lblx[k/2]);
        xc = xd / 2;
        sprintf(buf,"%d", xc);
        MObjectSetText(OMUTEMP.lblx[k/2], buf);
    }

}
/****************************************************************/  


/****************************************************************/  

void D2D_PoslblY(float l, float h)
{

    float yd, i;
    int k;
    char buf[16];
    float lintery;
    yd = h - l;
    lintery = yd / (sizeof OMUTEMP.lbly / sizeof OMUTEMP.lbly[0] );
    
    k=sizeof OMUTEMP.lbly / sizeof OMUTEMP.lbly[0] ;
    for (i =l;i<= h;i+=lintery)
    {
        sprintf(buf,"%.1lf", i);
        if(k==1)
            sprintf(buf,"%.1lf", h);
        MObjectSetText(OMUTEMP.lbly[k-1], buf);
        k--;
    }
}
/****************************************************************/  
void D2D_PlotSpectrum(MOBJECT obj, float plotmat[], int idx, 
                  int idy, unsigned long pe[], double costx, double costy, int min, int max,
                  int ox, int oy)  
{
    int t, j, k = 0,er = 0;
    int X1, X, Y1, Y;

    for(t = 0 ; t < idx ; t++)
    {
        for(j = 0; j < idy ; j++)
        {   
            er = MTButtonGetActivationStatus(OMUTEMP.tgb[j%idy]);
            if (er)
            {

                X = (int) (ox + (t *  costx));
                Y = (int) (oy - abs((int)((double)(plotmat[t * idy + j] - min) / costy)));
                //Y = (int) (oy - ((plotmat[t * idx + j] - min) / costy));
                X1 = (int) (ox + (t + 1) * costx);
                Y1 = (int) (oy - abs((int)((double)(plotmat[t * idy + j + idy] - min) / costy)));
                //Y1 = (int) (oy - ((plotmat[t * idx + j + 1] - min) / costy));
                MDrawLine(obj, X, Y, X1, Y1, pe[j]);        
            }
        }
    }
}
/****************************************************************/  

void ToggleButtCB(MOBJECT p, MVALUE od, void *ad)
{

    RefreshDrArea(OMUTEMP.drawarea000);
    MObjectRedraw(OMUTEMP.drawarea000);

}

int RefreshDrArea(MOBJECT obj)
{
    maxplotw = MObjectGetWidth(obj); 
    maxploth = MObjectGetHeight(obj); 
    
    //Assign limits to the Drawing coordinates
    D2D_AssignOrigin(obj);
    //Plot the axes
    D2D_PlotAxis(obj, OMUTEMP.oX, OMUTEMP.oY, OMUTEMP.eX,OMUTEMP.eY, MTCL.black);
    //Plot grid
    D2D_PlotGrid(obj, BIL.BLENS.Imim, OMUTEMP.oX, OMUTEMP.oY, OMUTEMP.eX,OMUTEMP.eY, 24, 10);

    D2D_findmaxmin(OMUTEMP.pTempMat, 0, OMUTEMP.dimx, 0, OMUTEMP.dimy);

//  OMUTEMP.tmin = 0;
//  OMUTEMP.tmax = 50;

    D2D_PoslblY(OMUTEMP.tmin, OMUTEMP.tmax);


    D2D_PoslblX(OMUTEMP.lblx, (int) OMUTEMP.ptimeMat[0].ti_hour, (int) OMUTEMP.ptimeMat[OMUTEMP.dimx-1].ti_hour, (int)(OMUTEMP.ptimeMat[0].ti_hour + OMUTEMP.ptimeMat[OMUTEMP.dimx-1].ti_hour + 1)/2);


    //Calculation of the adaptive parameters
    OMUTEMP.COSTY = (double)(OMUTEMP.tmax - OMUTEMP.tmin) / (double)(OMUTEMP.oY - OMUTEMP.eY);
    OMUTEMP.COSTX = (double)(OMUTEMP.eX - OMUTEMP.oX) / (double) (OMUTEMP.dimx);

    D2D_PlotSpectrum(obj, OMUTEMP.pTempMat, OMUTEMP.dimx, OMUTEMP.dimy, MTCL.PLColor, OMUTEMP.COSTX,
        OMUTEMP.COSTY,  (int)OMUTEMP.tmin, (int)OMUTEMP.tmax, OMUTEMP.oX, OMUTEMP.oY);


    return 0;
}

int DrawAreaTempCB(MOBJECT obj, MEvent *pexp, void *a_data)
{
    
    int er =0;

    er = RefreshDrArea(obj);

    return er;
                  
}

MOBJECT MDCreate_2DPlot(char * title)
{
    MOBJECT _shell000;
    
    MOBJECT _rowform000;
//  MOBJECT _tablefrm000;
    MOBJECT _colform000;
    MOBJECT _rowform001;
//  MOBJECT _tablefrm001;
    MOBJECT _rowform002;
    MOBJECT _tablefrm002;
    MOBJECT _colform001;
    MOBJECT _scrollbar000;
    MOBJECT _rowform004;
    MOBJECT _rowform005;
    MOBJECT _rowform006;
    MOBJECT _rowform007;
    MOBJECT _scrollbar001;

    MOBJECT lbl, tb;
    MOBJECT rowfrm;

    int i;

    _shell000 = MCreateShell(title, 0);
    MObjectSetBackgroundRGB(_shell000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);
    MObjectSetShadow(_shell000, WS_SHADOW_IN, 0, 0);

    _rowform000 = MCreateRowForm(_shell000);
    MTopAttach(_rowform000, F_ATT_FORM, 1, NULL);
    MObjectAlign(_rowform000, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetBackgroundRGB(_rowform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);
    MObjectSetResize(_rowform000, True, True);

    tb = MCreateTableForm(_rowform000, 7);
    MFormSetSpacing(tb, 1);
    MObjectSetBackgroundRGB(tb, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

//  _label000 = MCreateLabel(_tablefrm000, "Measurement Header", HELV_SMALL);
//  MObjectSetForegroundRGB(_label000, 255, 255, 0);

    _colform000 = MCreateColForm(_rowform000);
    MFormSetSpacing(_colform000, 1);
    MObjectSetBackgroundRGB(_colform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);
    MObjectSetResize(_colform000, True, True);

    _rowform001 = MCreateRowForm(_colform000);
    MFormSetSpacing(_rowform001, 1);
    MObjectAlign(_rowform001, LEFT_ALIGN, TOP_ALIGN);
    MObjectSetBackgroundRGB(_rowform001, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);
    MObjectSetResize(_rowform001, False, False);

    lbl = MCreateLabel(_rowform001, "Select Channel", HELV_SMALL);
    MObjectAlign(lbl, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_lblUP[0], DPAL.DB_FG_lblUP[1], DPAL.DB_FG_lblUP[2]);
    MObjectSetBackgroundRGB(lbl, DPAL.DB_BG_lblUP[0], DPAL.DB_BG_lblUP[1], DPAL.DB_BG_lblUP[2]);
    MObjectSetTransparency(lbl, 0);
    MObjectSetShadow(lbl, WS_SHADOW_OUT, 1, 0);
    MObjectSetResize(lbl, False, False);

    tb = MCreateTableForm(_rowform001, 1);
    MFormSetSpacing(tb, 1);
    MTableFormSetColAlign(tb, 0, CENTER_ALIGN);
    MObjectAlign(tb, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetBackgroundRGB(tb, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);
    MObjectSetResize(tb, False, False);

        OMUTEMP.tgb[0] = MCreateTButton(tb, " Optic ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[0], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[0], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[0], 0);
        MTButtonSetCallback(OMUTEMP.tgb[0], ToggleButtCB, 0);

        OMUTEMP.tgb[1] = MCreateTButton(tb, "Int SX ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[1], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[1], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[1], 0);
        MTButtonSetCallback(OMUTEMP.tgb[1], ToggleButtCB, 0);

        OMUTEMP.tgb[2] = MCreateTButton(tb, "Out SX ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[2], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[2], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[2], 0);
        MTButtonSetCallback(OMUTEMP.tgb[2], ToggleButtCB, 0);

        OMUTEMP.tgb[3] = MCreateTButton(tb, "Int DX ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[3], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[3], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[3], 0);
        MTButtonSetCallback(OMUTEMP.tgb[3], ToggleButtCB, 0);

        OMUTEMP.tgb[4] = MCreateTButton(tb, "Out DX ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[4], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[4], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[4], 0);
        MTButtonSetCallback(OMUTEMP.tgb[4], ToggleButtCB, 0);

        OMUTEMP.tgb[5] = MCreateTButton(tb, "Grating", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[5], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[5], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[5], 0);
        MTButtonSetCallback(OMUTEMP.tgb[5], ToggleButtCB, 0);

        OMUTEMP.tgb[6] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[6], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[6], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[6], 0);
        MTButtonSetCallback(OMUTEMP.tgb[6], ToggleButtCB, 0);

        OMUTEMP.tgb[7] = MCreateTButton(tb, "Elect. ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[7], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[7], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[7], 0);
        MTButtonSetCallback(OMUTEMP.tgb[7], ToggleButtCB, 0);

        OMUTEMP.tgb[8] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[8], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[8], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[8], 0);
        MTButtonSetCallback(OMUTEMP.tgb[8], ToggleButtCB, 0);

        OMUTEMP.tgb[9] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[9], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[9], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[9], 0);

        OMUTEMP.tgb[10] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[10], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[10], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[10], 0);

        OMUTEMP.tgb[11] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[11], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[11], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[11], 0);

        OMUTEMP.tgb[12] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[12], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[12], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[12], 0);

        OMUTEMP.tgb[13] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[13], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[13], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[13], 0);

        OMUTEMP.tgb[14] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[14], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[14], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[14], 0);

        OMUTEMP.tgb[15] = MCreateTButton(tb, "Spare  ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[15], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[15], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[15], 0);

        OMUTEMP.tgb[16] = MCreateTButton(tb, "CCD    ", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[16], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[16], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[16], 0);


    lbl = MCreateLabel(_rowform001, "Percent", HELV_SMALL);
    MObjectAlign(lbl, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_lblUP[0], DPAL.DB_FG_lblUP[1], DPAL.DB_FG_lblUP[2]);
    MObjectSetBackgroundRGB(lbl, DPAL.DB_BG_lblUP[0], DPAL.DB_BG_lblUP[1], DPAL.DB_BG_lblUP[2]);
    MObjectSetTransparency(lbl, 0);
    MObjectSetShadow(lbl, WS_SHADOW_OUT, 1, 0);
    MObjectSetResize(lbl, False, False);

    tb = MCreateTableForm(_rowform001, 1);
    MFormSetSpacing(tb, 1);
    MTableFormSetColAlign(tb, 0, CENTER_ALIGN);
    MObjectAlign(tb, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetBackgroundRGB(tb, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);
    MObjectSetResize(tb, False, False);

        OMUTEMP.tgb[17] = MCreateTButton(tb, "Pwr CCD", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[17], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[17], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[17], 0);

        OMUTEMP.tgb[18] = MCreateTButton(tb, "Pwr Pelt", HELV_SMALL);
        MObjectSetBackgroundRGB(OMUTEMP.tgb[18], DPAL.DB_BG_RButt[0], DPAL.DB_BG_RButt[1], DPAL.DB_BG_RButt[2]);
        MObjectSetForegroundRGB(OMUTEMP.tgb[18], DPAL.DB_FG_RButt[0], DPAL.DB_FG_RButt[1], DPAL.DB_FG_RButt[2]);
        MObjectSetTransparency(OMUTEMP.tgb[18], 0);


        
        
    _rowform002 = MCreateRowForm(_colform000);
    MObjectSetFGColorFromParent(_rowform002, False);
    MObjectSetResize(_rowform002, True, True);
/*
    _label002 = MCreateLabel(_rowform002, "VarY -> Blu Line", HELV_SMALL);
    MObjectAlign(_label002, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetForegroundRGB(_label002, 255, 255, 0);
    MObjectSetBackgroundRGB(_label002, 117, 117, 169);
    MObjectSetTransparency(_label002, 0);
    MObjectSetShadow(_label002, WS_SHADOW_IN, 1, 0);
    MObjectSetResize(_label002, False, False);
*/
    _tablefrm002 = MCreateTableForm(_rowform002, 2);
    MFormSetSpacing(_tablefrm002, 1);
//  MTableFormShowGrid(_tablefrm002);
    MObjectAlign(_tablefrm002, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetResize(_tablefrm002, True, True);

    _colform001 = MCreateColForm(_tablefrm002);

    _scrollbar000 = MCreateScrollBar(_colform001, SBT_VERT, 10, 110);
    MScrollBarSetSliderColorShift(_scrollbar000, 50);

    rowfrm = MCreateRowForm(_colform001);
    MFormSetSpacing(rowfrm, 1);
    MObjectSetForegroundRGB(rowfrm, DPAL.DB_FG_lblUP[0], DPAL.DB_FG_lblUP[1], DPAL.DB_FG_lblUP[2]);
    MObjectSetBackgroundRGB(rowfrm, DPAL.DB_BG_lblUP[0], DPAL.DB_BG_lblUP[1], DPAL.DB_BG_lblUP[2]);
    MObjectSetResize(rowfrm, False, True);

    for (i=0;i<11;i++)
    {
        OMUTEMP.lbly[i] = MCreateLabel(rowfrm, "-------", HELV_SMALL);
        MObjectSetForegroundRGB(OMUTEMP.lbly[i], DPAL.DB_FG_Albl[0], DPAL.DB_FG_Albl[1], DPAL.DB_FG_Albl[2]);
        MObjectSetBackgroundRGB(OMUTEMP.lbly[i], DPAL.DB_BG_Albl[0], DPAL.DB_BG_Albl[1], DPAL.DB_BG_Albl[2]);
        MObjectSetShadow(OMUTEMP.lbly[i], WS_SHADOW_IN, 1, 0);
        MObjectSetResize(OMUTEMP.lbly[i], True, False);
        MObjectSetTransparency(OMUTEMP.lbly[i], 0);
    }

    _rowform004 = MCreateRowForm(_tablefrm002);

        OMUTEMP.drawarea000 = MCreateDrawArea(_rowform004, 763, 350);
        MObjectSetResize(OMUTEMP.drawarea000, True, True);
        MDrawAreaSetInputCallback(OMUTEMP.drawarea000, D2D_AreaInputTemp, NULL);
        MDrawAreaSetExposeCallback(OMUTEMP.drawarea000, DrawAreaTempCB, NULL);

    _rowform005 = MCreateRowForm(_tablefrm002);
    MFormSetSpacing(_rowform005, 1);
    MObjectSetResize(_rowform005, False, False);

            tb = MCreateTableForm(_rowform005, 2);
            MFormSetSpacing(tb, 1);
        //  MTableFormShowGrid(_tablefrm002);
            MObjectAlign(tb, CENTER_ALIGN, TOP_ALIGN);
            MObjectSetResize(tb, True, True);

                lbl = MCreateLabel(tb, "X:", HELV_SMALL);
                MObjectAlign(lbl, CENTER_ALIGN, TOP_ALIGN);
                MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
                MObjectSetBackgroundRGB(lbl, DPAL.DB_BG_Plbl[0], DPAL.DB_BG_Plbl[1], DPAL.DB_BG_Plbl[2]);
                MObjectSetTransparency(lbl, 0);
                MObjectSetShadow(lbl, WS_SHADOW_OUT, 1, 0);
                MObjectSetResize(lbl, False, False);
                
                OMUTEMP.LBL_X = MCreateLabel(tb, "xxxx", HELV_SMALL);
                MObjectAlign(OMUTEMP.LBL_X, CENTER_ALIGN, TOP_ALIGN);
                MObjectSetForegroundRGB(OMUTEMP.LBL_X, DPAL.DB_FG_Albl[0], DPAL.DB_FG_Albl[1], DPAL.DB_FG_Albl[2]);
                MObjectSetBackgroundRGB(OMUTEMP.LBL_X, DPAL.DB_BG_Albl[0], DPAL.DB_BG_Albl[1], DPAL.DB_BG_Albl[2]);
                MObjectSetTransparency(OMUTEMP.LBL_X, 0);
                MObjectSetShadow(OMUTEMP.LBL_X, WS_SHADOW_OUT, 1, 0);
                MObjectSetResize(OMUTEMP.LBL_X, False, False);

                lbl = MCreateLabel(tb, "Y:", HELV_SMALL);
                MObjectAlign(lbl, CENTER_ALIGN, TOP_ALIGN);
                MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
                MObjectSetBackgroundRGB(lbl, DPAL.DB_BG_Plbl[0], DPAL.DB_BG_Plbl[1], DPAL.DB_BG_Plbl[2]);
                MObjectSetTransparency(lbl, 0);
                MObjectSetShadow(lbl, WS_SHADOW_OUT, 1, 0);
                MObjectSetResize(lbl, False, False);

                OMUTEMP.LBL_Y = MCreateLabel(tb, "yyyy", HELV_SMALL);
                MObjectAlign(OMUTEMP.LBL_Y, CENTER_ALIGN, TOP_ALIGN);
                MObjectSetForegroundRGB(OMUTEMP.LBL_Y, DPAL.DB_FG_Albl[0], DPAL.DB_FG_Albl[1], DPAL.DB_FG_Albl[2]);
                MObjectSetBackgroundRGB(OMUTEMP.LBL_Y, DPAL.DB_BG_Albl[0], DPAL.DB_BG_Albl[1], DPAL.DB_BG_Albl[2]);
                MObjectSetTransparency(OMUTEMP.LBL_Y, 0);
                MObjectSetShadow(OMUTEMP.LBL_Y, WS_SHADOW_OUT, 1, 0);
                MObjectSetResize(OMUTEMP.LBL_Y, False, False);


    _rowform006 = MCreateRowForm(_tablefrm002);
    MFormSetSpacing(_rowform006, 1);
    MObjectSetResize(_rowform006, True, True);

    tb = MCreateTableForm(_rowform006, (sizeof OMUTEMP.lblx / sizeof OMUTEMP.lblx[0]));
    MFormSetSpacing(tb, 1);
//  MTableFormShowGrid(_tablefrm003);
    MObjectSetBackgroundRGB(tb, 120, 177, 218);
    MObjectSetResize(tb, True, False);


    for (i=0;i<(sizeof OMUTEMP.lblx / sizeof OMUTEMP.lblx[0]);i++)
    {
        OMUTEMP.lblx[i] = MCreateLabel(tb, "-----", HELV_SMALL);
        MObjectSetForegroundRGB(OMUTEMP.lblx[i], DPAL.DB_FG_Albl[0], DPAL.DB_FG_Albl[1], DPAL.DB_FG_Albl[2]);
        MObjectSetBackgroundRGB(OMUTEMP.lblx[i], DPAL.DB_BG_Albl[0], DPAL.DB_BG_Albl[1], DPAL.DB_BG_Albl[2]);
        MObjectSetShadow(OMUTEMP.lblx[i], WS_SHADOW_IN, 1, 0);
        MObjectSetResize(OMUTEMP.lblx[i], False, False);
        MObjectSetTransparency(OMUTEMP.lblx[i], 0);
        MObjectUnmap(OMUTEMP.lblx[i]);
    }

    _rowform007 = MCreateRowForm(_rowform006);

    _scrollbar001 = MCreateScrollBar(_rowform007, SBT_HOR, 10, 110);


//  MShellRealize( _shell000);

    return _shell000;
}