view.c

seismic software,very useful

    switch (view->rate ){
       case VIEW_RATE_ALL:
        block = 1;
        break;
       case VIEW_RATE_TENTHS:
        block = 10;
        break;
       case VIEW_RATE_EACH:
        block = 10000;
        break;
    }
    switch (view->movie ){
        /* front */
       case MOVIE_FRONT:
        block = MapSize(view->map[AXIS_DEEP]) / block;
        block = block > 0 ? block : 1;
        MapSetFrame(view->map[AXIS_DEEP],
                    MapMap(view->map[AXIS_DEEP],
                           MapFrame1(view->map[AXIS_DEEP])));
        RENDER_ATTR(1, 0, 0, 0, 1, 0, 0, 0, 0, 0);
        RenderHorz(data, view->map[AXIS_ACROSS],
                   view->map[AXIS_DOWN], view->map[AXIS_DEEP],
                   view->map[AXIS_4D], view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_DEEP]) -
                   MapFrame1(view->map[AXIS_DEEP]),
                   view->margins[MARGIN_TOP] + MapFrame1(view->map[AXIS_DEEP]),
                   render, view->margins, _attr_);
        if( MapFrame1(view->map[AXIS_DEEP])
            && (MapFrame1(view->map[AXIS_DEEP]) % block) == 0 ){
            RenderDraw();
        }
        if( MapFrame1(view->map[AXIS_DEEP]) < MapSize(view->map[AXIS_DEEP]) - 1 ){
            UITimer(1, ViewDrawTranspCallback);
        }else{
            RenderDraw();
            MapRestoreFrame(view->map[AXIS_DEEP]);
            TymeEnd(MapSize(view->map[AXIS_DOWN]) *
                    MapSize(view->map[AXIS_ACROSS]) *
                    MapSize(view->map[AXIS_DEEP]));
            DrawWatch(0);
        }
        MapSetFrame1(view->map[AXIS_DEEP], MapFrame1(view->map[AXIS_DEEP]) + 1);
        break;
        /* side */
       case MOVIE_SIDE:
        block = MapSize(view->map[AXIS_ACROSS]) / block;
        block = block > 0 ? block : 1;
        MapSetFrame(view->map[AXIS_ACROSS],
                    MapMap(view->map[AXIS_ACROSS],
                           MapFrame1(view->map[AXIS_ACROSS])));
        RENDER_ATTR(1, 1, 0, 0, 1, 0, 0, 0, 0, 0);
        RenderVert(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
                   view->map[AXIS_ACROSS], view->map[AXIS_4D],
                   view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT] +
                   MapFrame1(view->map[AXIS_ACROSS]),
                   MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP],
                   render, view->margins, _attr_);
        if( MapFrame1(view->map[AXIS_ACROSS])
            && MapFrame1(view->map[AXIS_ACROSS]) % block == 0)
            RenderDraw();
        if( MapFrame1(view->map[AXIS_ACROSS]) <
            MapSize(view->map[AXIS_ACROSS]) - 1 ){
            UITimer(1, ViewDrawTranspCallback);
        }else{
            RenderDraw();
            MapRestoreFrame(view->map[AXIS_ACROSS]);
            TymeEnd(MapSize(view->map[AXIS_DOWN]) *
                    MapSize(view->map[AXIS_ACROSS]) *
                    MapSize(view->map[AXIS_DEEP]));
            DrawWatch(0);
        }
        MapSetFrame1(view->map[AXIS_ACROSS],
                     MapFrame1(view->map[AXIS_ACROSS]) + 1);
        break;
        /* top */
       case MOVIE_TOP:
        block = MapSize(view->map[AXIS_DOWN]) / block;
        block = block > 0 ? block : 1;
        MapSetFrame(view->map[AXIS_DOWN],
                    MapMap(view->map[AXIS_DOWN],
                           MapFrame1(view->map[AXIS_DOWN])));
        RENDER_ATTR(1, 1, 0, 0, 1, 0, 0, 0, 0, 0);
        RenderHorz(data, view->map[AXIS_ACROSS],
                   view->map[AXIS_DEEP], view->map[AXIS_DOWN],
                   view->map[AXIS_4D], view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT],
                   view->margins[MARGIN_TOP] + MapFrame1(view->map[AXIS_DOWN]),
                   render, view->margins, _attr_);
        if( MapFrame1(view->map[AXIS_DOWN]) != MapSize(view->map[AXIS_DOWN]) - 1
            && MapFrame1(view->map[AXIS_DOWN]) % block == 0 ){
            RenderDraw();
        }
        if( MapFrame1(view->map[AXIS_DOWN]) > 0 ){
            UITimer(1, ViewDrawTranspCallback);
        }else{
            RenderDraw();
            MapRestoreFrame(view->map[AXIS_DOWN]);
            TymeEnd(MapSize(view->map[AXIS_DOWN]) *
                    MapSize(view->map[AXIS_ACROSS]) *
                    MapSize(view->map[AXIS_DEEP]));
            DrawWatch(0);
        }
        MapSetFrame1(view->map[AXIS_DOWN], MapFrame1(view->map[AXIS_DOWN]) - 1);
        break;
    }
}

/* callback to draw entire view */
void ViewDrawAll(void)
{
    extern View view;

    if( !view ){
        return;
    }

    if( UIFirst() ){
        MainFirst();
    }
    ColorbarDraw();
    ViewDraw(view, DRAW_ALL);
    if( view->style != VIEW_TRANSP ){
        RenderDraw();
    }
}

/* callback to draw only current movie frame panel plus crosslines */
void ViewDrawMovie(void)
{
    int      h0, v0, nh, nv, mode = 0;
    extern View view;
    Map      map;

    if( !view ){
        return;
    }
    map = ViewMovieMap(view);
    MapNextFrame(map);
    if( MovieCache() ){
        mode = DrawPixmap(MapFrame(map));
    }
    mode = (1 - mode) * DRAW_IMAGE;
    switch (view->movie ){
       case MOVIE_TOP:
        ViewDraw(view, DRAW_TOP | mode);
        break;
       case MOVIE_SIDE:
        ViewDraw(view, DRAW_SIDE | mode);
        break;
       case MOVIE_FRONT:
        ViewDraw(view, DRAW_FRONT | mode);
        break;
    }
    if( mode ){
        RenderDraw();
        if( MovieCache() ){
            DrawSavePixmap(MapFrame(map));
        }
    }
#ifdef XAW
    if( MovieRun() ){
        UITimer(MovieDelay() + 1, ViewDrawMovie);
    }
#endif
#ifdef XM
    if( MovieRun() ){
        UITimer(MovieDelay() * 10 + 1, ViewDrawMovie);
    }
#endif
    UIWakeup();
}

/* set movie option */
void ViewSetMovie(int movie)
{
    extern View view;
    Map      map;

    if( !view ){
        return;
    }
    view->movie = movie;
    map = ViewMovieMap(view);
    DrawFreePixmaps();

    if( view->style == VIEW_TRANSP ){
        ViewDraw(view, DRAW_ALL);
    }
}

/* initialize movie bounds */
void ViewMovieFullBounds(void)
{
    int      imap;
    extern View view;

    MovieOff();
    for( imap = 1; imap < VIEW_NAXIS; imap++ ){
        MapSetFrameBounds(view->map[imap], MapFirst(view->map[imap]),
                          MapLast(view->map[imap]));
        MapSetDmovie(view->map[imap], 1);
    }
}

/* one of 3d views? */
int View3D(void)
{
    extern View view;

    switch (view->style ){
       case VIEW_THREE:
       case VIEW_CUBE:
       case VIEW_FENCE:
        return (1);
        break;
       default:
        return (0);
        break;
    }
}

/* OK to turn on movie */
int ViewMovieOK(void)
{
    extern View view;

    switch (view->style ){
       case VIEW_CUBE:
       case VIEW_THREE:
       case VIEW_FRONT:
       case VIEW_SIDE:
       case VIEW_TOP:
        return (1);
        break;
       default:
        return (0);
        break;
    }
}

/* set view option */
void ViewSetStyle(int style)
{
    extern View view;
    int      size;

    if( !view ){
        return;
    }

    if( style == view->style ){
        return;
    }

    view->style = style;
    /* shape defaults with view style */
    /* set movie directions too */
    switch (style ){
       case VIEW_TRANSP:
        view->shape = SHAPE_PIXEL;
        view->movie = MOVIE_SIDE;
        break;
       case VIEW_FRONT:
        view->movie = MOVIE_FRONT;
        break;
       case VIEW_SIDE:
        view->movie = MOVIE_SIDE;
/*--------------------------------------------------------------------*\
        if( view->map[AXIS_DEEP]->first > view->map[AXIS_DEEP]->last ){
            MapFlip(view->map[AXIS_DEEP]);
        }
\*--------------------------------------------------------------------*/
        break;
       case VIEW_TOP:
        view->movie = MOVIE_TOP;
        break;
    }
    MovieOff();
    ViewSize(view);
    MapSetTics( view->map[0] );
    MapSetTics( view->map[1] );
    MapSetTics( view->map[2] );
    MapSetTics( view->map[3] );
    MapSetTics( view->map[4] );
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* set fence mode */
void ViewSetFence(int mode)
{
    extern View view;

    if( !view ){
        return;
    }
    view->fence = mode;
    view->style = VIEW_FENCE;
    DrawFreePixmaps();
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* set transparency draw rate */
void ViewSetTranspRate(int mode)
{
    extern View view;

    if( !view ){
        return;
    }
    if( view->rate == mode ){
        return;
    }
    view->rate = mode;
}

/* set shape mode */
void ViewSetShape(int shape)
{
    extern View view;

    if( !view ){
        return;
    }
    if( view->shape != shape ){
        view->shape = shape;
        ViewSize(view);
        ViewDraw(view, DRAW_ALL);
        RenderDraw();
    }
}

/* set fence mode */
void ViewToggleFence(int mode)
{
    extern View view;

    if( !view ){
        return;
    }
    view->fence ^= mode;
    view->style = VIEW_FENCE;
    DrawFreePixmaps();
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* set two cross line frames */
void ViewSetFrames(int x, int y)
{
    extern View view;
    Map      map;
    PickPoint_ pick;
    int      iaxis;

    if( !view ){
        return;
    }
    /* undefined views */
    switch (view->style ){
       case VIEW_FRONT:
       case VIEW_SIDE:
       case VIEW_TOP:
       case VIEW_XSEC:
       case VIEW_ARRAY:
       case VIEW_TRANSP:
        return;
    }
    /* translate pick */
    PickDecode(x, y, &pick, 1);
    /* reset frames */
    for( iaxis = 1; iaxis < VIEW_NAXIS; iaxis++ ){
        map = view->map[iaxis];
        MapSetFrame(map, pick.index[AxisDir(MapAxis(map))]);
    }
    DrawFreePixmaps();
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* set frame from slider */
void ViewSetFrame(int index, int mode)
{
    extern View view;
    Map      map;
    int      frame;

    map = ViewMovieMap(view);
    if( mode == FRAME_PERCENT ){
        frame = MapLow(map) + (index * (MapHigh(map) - MapLow(map))) / 100;
    }
    MapSetFrame(map, frame);
    if( view->style == VIEW_ARRAY ){
        RenderClear();
        DrawClear();
    }
    switch (view->movie ){
       case MOVIE_TOP:
        ViewDraw(view, DRAW_TOP);
        break;
       case MOVIE_SIDE:
        ViewDraw(view, DRAW_SIDE);
        break;
       case MOVIE_FRONT:
        ViewDraw(view, DRAW_FRONT);
        break;
    }
    RenderDraw();
}

/* set pick mode */
void ViewSetPick(int pick)
{
    extern View view;

    if( !view ){
        return;
    }
    if( pick != view->showpicks ){
        PickDrawAll(pick);
    }
    view->showpicks = pick;
    PikDraw(NO_INDEX, view->showpicks);
}

/* toggle pick mode */
void ViewTogglePick(void)