drawTv_tv.c

Go to the documentation of this file.

/*********
 * Copyright (c) 2003, Division of Imaging Science and Biomedical Engineering,
 * University of Manchester, UK.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, 
 * are permitted provided that the following conditions are met:
 * 
 *   . Redistributions of source code must retain the above copyright notice, 
 *     this list of conditions and the following disclaimer.
 *    
 *   . Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation 
 *     and/or other materials provided with the distribution.
 * 
 *   . Neither the name of the University of Manchester nor the names of its
 *     contributors may be used to endorse or promote products derived from this 
 *     software without specific prior written permission.
 * 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 * POSSIBILITY OF SUCH DAMAGE.
 *
 **********
 *
 * Program :    TINA
 * File    :  $Source: /home/tina/cvs/tina-tools/tinatool/draw/drawTv_tv.c,v $
 * Date    :  $Date: 2008/12/02 22:04:19 $
 * Version :  $Revision: 1.3 $
 * CVS Id  :  $Id: drawTv_tv.c,v 1.3 2008/12/02 22:04:19 paul Exp $
 *
 * Author  : Legacy TINA
 *
 * Notes :
 * Tv ('logical' display device) creation & installation
 * Basic tv creation and installation on tv_screens.
 *
 *
 *********
*/

#include "drawTv_tv.h"

#if HAVE_CONFIG_H
  #include <config.h>
#endif

#include <stdio.h>
#include <string.h>
#include <tina/sys/sysDef.h>
#include <tina/sys/sysPro.h>
#include <tina/math/mathDef.h>
#include <tina/math/mathPro.h>
#include <tina/geometry/geomDef.h>
#include <tina/geometry/geomPro.h>
#include <tinatool/draw/draw_TvDef.h>
#include <tinatool/draw/draw_TvPro.h>
#include <tinatool/gphx/gphxPro.h>
#include <tinatool/wdgts/wdgtsPro.h>

/* EXTERNS
extern void picture_free();
extern void tv_screen_cmap_find_and_install();
extern void tv_screen_named_font_set();
extern void tv_screen_set_op();
extern void tv_screen_set_linewidth();
extern void tv_screen_save_size();
extern void tv_screen_tv_set();
extern void tv_screen_background_set();
extern void tw_tool_title_reset();
*/

void    tv_free_background(Tv * tv)
{
    if (tv == NULL)
        return;
    if (tv->backsave)
    {
        picture_free(tv->background);
        tv->background = NULL;
    }
}

void    tv_repaint(Tv * tv)
{
    if (tv == NULL || tv->tv_screen == NULL)
        return;

    if (tv->backsave && tv->paint_mode == FULL_PAINT)
    {
        if (tv->background == NULL)
        {
            tv_erase(tv);
            tv->backdraw(tv, tv->drawdata);
            tv->background = tv_get_picture(tv);
        } else
            tv_show_picture(tv, tv->background);
    } else
        tv_erase(tv);

    switch (tv->paint_mode)
    {
    case FULL_PAINT:
        tv->fulldraw(tv, tv->drawdata);
        break;
    case SKEL_PAINT:
        tv->skeldraw(tv, tv->drawdata);
        break;
    }
}

Tv     *tv_create(char *label)
{
    Tv     *tv = ts_ralloc(Tv);

    (void) strcpy(tv->label, label);

    tv->clone = 0;

    tv->tv_screen = NULL;
    tv->width = tv->height = 256;
    tv->init = null_function;

    tv->overlay_on = false;
    tv->color = black;          /* index into
                                 * tv->cmap_data_visible->std_lut[] */
    tv->op = rop_copy;
    tv->linewidth = 0;
    tv->linestyle = line_solid;
    *tv->font_name = '\0';      /* length STRING128 */
    tv->draw = NULL;

    tv->activity = 0;
    tv->proj3type = ORTH;
    tv->paint_mode = FULL_PAINT;
    tv->mouse = null_mouse();
    tv->mouse_reset = null_function;
    tv->pick = null_pick();
    tv->pick_reset = null_function;
    tv->backdraw = tv->fulldraw = tv->skeldraw = null_function;
    tv->drawdata = NULL;
    tv->backsave = false;
    tv->background = NULL;

    tv->ul = vec2_zero();
    tv->lr = vec2((float) tv->width, (float) tv->height);

    tv->movie = NULL;

    tv_camera3(tv, vec3_zero(), 1.0, 3.0, vec3_ez(), vec3_ey());
    tv->axis_set = false;
    tv_set_proj3_orth(tv);
    tv_camera2(tv, vec2(128.0, 128.0), 128.0, vec2_ey());
    tv_set_proj2(tv);

    /* tv's colormap info. */
    tv->cmap_data_visible = NULL;
    tv->cmap_create_fn = tv_standard_cmap_create;

    /* zbuffering option * */
    tv->zbuff = NULL;

    return (tv);
}

Tv     *tv_clone(Tv * tv)
{
    char    clone[16];
    Tv     *tv_new;

    if (tv == NULL)
        return (NULL);

    tv_new = ts_ralloc(Tv);
    *tv_new = *tv;
    tv_new->pick.picklist = NULL;
    tv_new->clone = ++(tv->clone);
    (void) sprintf(clone, "%-8d", tv_new->clone);
    (void) string_append(tv_new->label, tv->label, " clone ", clone, NULL);
    tv_new->tv_screen = NULL;
    tv_new->movie = NULL;
    tv_new->background = NULL;
    tv_new->zbuff = NULL;
    tv_new->message_fn = NULL;
    tv_new->message_data = NULL;
    tv_new->header_fn = NULL;
    tv_new->header_data = NULL;
    return (tv_new);
}

void    tv_install(Tv * tv, void *tv_screen)
{
    void   *owner;
    Tv     *tv_screen_tv_get();
    void   *tv_screen_owner_get();

    if (tv && tv_screen)
    {
        /* Uninstall OLD tv_screen (loses link to its tv) */
        if (tv->tv_screen)
        {
            tv_set_header(tv, "uninstalled");
            tv_set_message(tv, "null");
            tv_header_function_set(tv, NULL, NULL);
            tv_message_function_set(tv, (void (*) ()) NULL, NULL);
            tv_screen_tv_set(tv->tv_screen, (Tv *) NULL);
        }
        if (tv_screen_tv_get(tv_screen))
        {
            (tv_screen_tv_get(tv_screen))->tv_screen = NULL;
        }
        tv_screen_save_size(tv_screen);

        tv->tv_screen = tv_screen;
        tv_screen_tv_set(tv_screen, tv);

        owner = tv_screen_owner_get(tv_screen);
        tv_header_function_set(tv, (void (*) ()) tw_tool_title_reset, owner);

        tv_screen_cmap_find_and_install(tv, tv_screen);
        tv_screen_color_set(tv->tv_screen, tv->cmap_data_visible->std_lut[tv->color]);
        tv_screen_background_set(tv->tv_screen, tv->cmap_data_visible->std_lut[bkgrnd]);

        (void) tv_screen_set_op(tv->tv_screen, tv->op);
        tv_screen_set_linewidth(tv->tv_screen, tv->linewidth);
        tv_screen_set_linestyle(tv->tv_screen, tv->linestyle);
        tv_screen_named_font_set(tv->tv_screen, tv->font_name);
        tv_set_proj3(tv, tv->proj3type);
        (void) tv_set_activity(tv, tv->activity);       /* sets message */
        tv_rescale(tv);
        tv_free_background(tv); /* Ie image */
        if(tv->zbuff)
            tv_set_zbuff(tv, tv->zbuff->zmin, tv->zbuff->zmax);
        tv_repaint(tv);
    }
}

void    tv_install_clone(Tv * tv, void *tv_screen)
{
    Tv     *tv_new;

    if (tv && tv_screen)
    {
        tv_new = tv_clone(tv);
        tv_install(tv_new, tv_screen);
    }
}

void    tv_set_message(Tv * tv, char *name)
{
    if (tv == NULL || tv->message_fn == NULL)
        return;

    tv->message_fn(tv->message_data, name);
}

void    tv_message_function_set(Tv * tv, void (*func) ( /* ??? */ ), void *data)
{
    if (tv == NULL)
        return;
    tv->message_fn = func;
    tv->message_data = data;
    (void) tv_set_activity_message(tv);
}

void    tv_set_header(Tv * tv, char *name)
{
    if (tv == NULL || tv->header_fn == NULL)
        return;

    tv->header_fn(tv->header_data, name);
}

void    tv_header_function_set(Tv * tv, void (*func) ( /* ??? */ ), void *data)
{
    if (tv == NULL)
        return;
    tv->header_fn = func;
    tv->header_data = data;
    tv_set_header(tv, tv->label);
}

Tv     *tv_open(void *tv_screen, char *label)
{
    Tv     *tv = NULL;

    if (tv_screen)
    {
        tv = tv_create(label);
        tv_install(tv, tv_screen);
    }
    return (tv);
}

static void tv_dummy_calls(void)
{                               /* for separate library complilation */
    Tv     *tv = (Tv *) NULL;
    double  zoom = 0.0;

    tv_zoom(tv, zoom);
    (void) tv_cmap_create(tv);
    (void) tv_get_im_roi(tv);
    (void) tv_get_next();
    tv_init(tv);
}

---