xshmimg.C

Go to the documentation of this file.

/* Gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 * 
 * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
 *
 * Authors: Percy Zahl <zahl@users.sf.net>
 * additional features: Andreas Klust <klust@users.sf.net>
 * WWW Home: http://gxsm.sf.net
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 */

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */

#include <iostream>
#include <fstream>

#include <gdk-pixbuf/gdk-pixbuf.h>

#include "xshmimg.h"
#include "util.h"

#include "glbvars.h"

ShmImage2D::ShmImage2D(GtkWidget* area, 
                       int Width, int Height, 
                       int xorigin, int yorigin
                       ){
  x0 = xorigin; 
  y0 = yorigin;
  maxcol  = 0;
  ZoomFac = 1;
  imgarea = area;

  MkPalette();

  gdk_pixbuf     = NULL;
  gitem_image    = NULL;
  gitem_red_line = NULL;

  // Setup Red Line Position
  red_line_points = gnome_canvas_points_new (2);
  red_line_points->coords[0] = x0;
  red_line_points->coords[2] = x0+Width;
  red_line_points->coords[1] = red_line_points->coords[3] = y0;

  Resize(Width, Height);
}

void ShmImage2D::Resize(int Width, int Height){
  XSM_DEBUG(DBG_L3, "ShmImage2D::Resize" << Width << "x" << Height );
  width  = Width;
  height = Height;

  
  red_line_points->coords[2] = red_line_points->coords[0] + width;
  red_line_points->coords[1] = red_line_points->coords[3] = y0;

  // Setup Image
  GdkPixbuf *gdk_pixbufold=gdk_pixbuf;

  gdk_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
  bpp        = gdk_pixbuf_get_bits_per_sample(gdk_pixbuf) * gdk_pixbuf_get_n_channels(gdk_pixbuf) / 8;
  rowstride  = gdk_pixbuf_get_rowstride(gdk_pixbuf);
  pixels     = gdk_pixbuf_get_pixels(gdk_pixbuf);

  if (!gitem_image)
          gitem_image = gnome_canvas_item_new (gnome_canvas_root( GNOME_CANVAS(imgarea)),
                                               gnome_canvas_pixbuf_get_type(),
                                               "pixbuf", gdk_pixbuf,
                                               NULL);
  gnome_canvas_item_lower (gitem_image, 1);
  if (gdk_pixbufold)
          gdk_pixbuf_unref (gdk_pixbufold);

  if (!gitem_red_line){
          gitem_red_line = gnome_canvas_item_new (gnome_canvas_root( GNOME_CANVAS(imgarea)),
                                                  GNOME_TYPE_CANVAS_LINE,
                                                  "points", red_line_points,
                                                  "fill_color","red",
                                                  "width_pixels",ZoomFac,
                                                  NULL);
  }else{
          gnome_canvas_item_set (gitem_red_line, 
                                 "points", red_line_points,
                                 "width_pixels",ZoomFac,
                                 NULL);
  }

  XSM_DEBUG(DBG_L3, "ShmImage2D::Resize done" );
}

ShmImage2D::~ShmImage2D(){
        gtk_object_destroy (GTK_OBJECT(gitem_image));
        gtk_object_destroy (GTK_OBJECT(gitem_red_line));
        gnome_canvas_points_free (red_line_points);
        gdk_pixbuf_unref (gdk_pixbuf);
}


void ShmImage2D::MkPalette(char *name){
        // Make Color Look Up Table fpr Grey-Scale -> TrueColor
        unsigned long r, g, b, cval;
  
        if (name){
                std::ifstream cpal;
                char pline[256];
                int nx,ny;
                cpal.open(name, std::ios::in);
                if(cpal.good()){
                        cpal.getline(pline, 255);
                        cpal.getline(pline, 255);
                        cpal >> nx >> ny;
                        cpal.getline(pline, 255);
                        cpal.getline(pline, 255);
                        
                        for(maxcol = MIN(nx, IMGMAXCOLORENTRYS), cval=0; cval<maxcol; ++cval){
                                cpal >> r >> g >> b;
                                if (WORDS_BIGENDIAN)
                                        ULColorTable[cval] = (r << 16) | (g << 8) | b ;
                                else
                                        ULColorTable[cval] = (b << 16) | (g << 8) | r ;
                        }
                        return;
                }
                XSM_SHOW_ALERT(ERR_SORRY, ERR_PALFILEREAD, name, 1);
        }
        // default grey and fallback mode:
        for (maxcol=64, cval=0; cval<maxcol; ++cval){
                r = b = g = cval * 255 / maxcol; 
                ULColorTable[cval] = (b << 16) | (g << 8) | r ;
        }
        
        // red/blue entries at end
        if (WORDS_BIGENDIAN){
                ULColorTable[IMGMAXCOLORENTRYS  ] = (255 << 16) | (0 << 8) | 0 ;
                ULColorTable[IMGMAXCOLORENTRYS+1] = (0 << 16) | (0 << 8) | 255 ;
        } else {
                ULColorTable[IMGMAXCOLORENTRYS  ] = (0 << 16) | (0 << 8) | 255 ;
                ULColorTable[IMGMAXCOLORENTRYS+1] = (255 << 16) | (0 << 8) | 0 ;
        }
}

void ShmImage2D::saveimage(gchar *name){
// why are these not existent, but in the docu???
//      gdk_pixbuf_save (gdk_pixbuf, name, "jpeg", NULL);
//      gdk_pixbuf_save (gdk_pixbuf, name, "png", NULL);
}

void ShmImage2D::ShowPic(int xs, int ys){ 
        gnome_canvas_item_set (gitem_image,
                               "pixbuf", gdk_pixbuf,
                               NULL);
        
        red_line_points->coords[1] = red_line_points->coords[3] = y0;
        gnome_canvas_item_set (gitem_red_line, "points", red_line_points, NULL);

}

void ShmImage2D::ShowSubPic(int xs, int ys, int w, int h){ 
        xs*=ZoomFac; ys*=ZoomFac;
        w*=ZoomFac; h*=ZoomFac;
        if (xs >= width || ys >= height || w > width || h > height)
                return;
        
        // look for:
        //  ArtUta *uta=art_uta_new(xs,ys,xs+w,ys+h);
        // // gnome_canvas_update_now(canvas);
        //  gnome_canvas_request_redraw_uta(GNOME_CANVAS(imgarea), uta);
        //  art_uta_free(uta);
        // geht so nicht :=(
        
        // Trick: rote Markierungslinie erzwingt bei Verschiebung
        // Refresh des darunter liegenden Bereiches...
        if (h>ZoomFac){
                gnome_canvas_item_set (gitem_image,
                                       "pixbuf", gdk_pixbuf,
                                       NULL);
        }
        
        red_line_points->coords[1] = red_line_points->coords[3] = ys+y0 + .5*ZoomFac;
        gnome_canvas_item_set (gitem_red_line,
                               "points", red_line_points, 
                               "width_pixels", ZoomFac+1,
                               NULL);
}

void ShmImage2D::PutPixel(unsigned long x, unsigned long y, unsigned long val){
        ((U24*)(pixels + rowstride*y + bpp*x))->rgb = ULColorTable[val];
}

---