ImageCanvas.cpp

#include <sstream>   
#include <iomanip>


#include <wx/scrolwin.h>
#ifdef   WIN32
#include <wx/image.h>
#endif //WIN32


#include "ImageCanvas.hh"

#include <Base/Image/ImageConvert.hh>
#include <Gui/StringConv.hh>
#include <Gui/ZoomFrame.hh>
#include <Gui/HistoFrame.hh>
#include <Gui/ImageLegendFrame.hh>
#include <Image/PyramidImage.hh>
#include <Gui/wxcompat.hh>


using namespace BIAS;
using namespace std;

BEGIN_EVENT_TABLE (ImageCanvas, wxScrolledWindow)
    EVT_PAINT       (ImageCanvas::OnPaint)
    EVT_ERASE_BACKGROUND       (ImageCanvas::OnErase)
    EVT_MOTION      (ImageCanvas::OnMouseMove)
    EVT_RIGHT_DOWN  (ImageCanvas::OnRightMouseButton)
    EVT_LEAVE_WINDOW(ImageCanvas::OnMouseLeave)
  EVT_ENTER_WINDOW(ImageCanvas::OnMouseEnter)
    //EVT_SIZE        (ImageCanvas::OnSize)
    EVT_KEY_DOWN    (ImageCanvas::OnKeyPress)
  EVT_LEFT_DCLICK (ImageCanvas::OnLeftMouseButton)
  EVT_LEFT_DOWN  (ImageCanvas::OnLeftMouseButton)
  EVT_MOUSEWHEEL (ImageCanvas::OnMouseWheel)
END_EVENT_TABLE()


//////////////////////////////////////////////////
ImageCanvas::
ImageCanvas(wxWindow* parent, wxStatusBar* sbar, int sbarid,
            wxWindowID id, const wxPoint& pos, const wxSize& size,
            long style, const wxString& name)
  : wxScrolledWindow(parent, id, pos, size, style, name), origim_()
{
  Bitmap_=(wxBitmap *)NULL;
  wximage_=(wxImage *)NULL;
  SBar_=sbar;
  SBarID_=sbarid;
  MyValueBarFrame_ = NULL;
  Title_=name;
  mousex_=mousey_=-1;
  DefaultZoom_=5;
  ClearDrawingContext_=true;
  ShowScaled_ = false;

  //HINT: If it sparks while having a sequence of mixed images
  //      (unsigned char/float) then do like it with MyHistoWin_
  //      done is (set to NULL in the beginning and by every
  //      use of zoomcanvas check if MyZoomWin_ initialized is)
  MyZoomWin_=new ZoomFrame(this, Title_);
  MyZoomWin_->Show(false);
  MyHistoWin_=NULL;
  ScaledImageSizeX_=0;
  ScaledImageSizeY_=0;
  width_ = height_ = lastwidth_ = lastheight_ = 0;
  KeepScrollPosition_ = false;
  SetHighScaleQuality(false);
  wxRoiImage_ = NULL;
  RoiBitmap_ = NULL;
  DrawRoi_ = false;
  SBarWidths_[0] = -2;
  if(SBar_ != NULL)
  {
    SBarWidths_[1] = 26 * SBar_->GetCharWidth();
  }
  else
  {
    SBarWidths_[1] = 350;
  }
}

//////////////////////////////////////////////////
ImageCanvas::
~ImageCanvas()
{
  if( wxRoiImage_!=NULL) { delete wxRoiImage_; wxRoiImage_ = NULL; }
  if (wximage_ != NULL) { delete wximage_; wximage_ = NULL; }
  if (RoiBitmap_!=NULL) { delete RoiBitmap_; RoiBitmap_ = NULL; }
  if (Bitmap_ != NULL) { delete Bitmap_; Bitmap_ = NULL; }
}

//////////////////////////////////////////////////
void ImageCanvas::
InitHisto(wxPoint pos, wxSize size)
{
  MyHistoWin_=new HistoFrame(this, _T("Image Histogram"), pos, size);
  MyHistoWin_->Show(true);
}
//////////////////////////////////////////////////
void ImageCanvas::
InitImageValueBar(wxPoint pos, wxSize size){
    MyValueBarFrame_=new ImageLegendFrame(this, _T("Image Legend"), pos, size);
    MyValueBarFrame_->SetLegendSize(120,400);
    MyValueBarFrame_->Show(true);
}
//////////////////////////////////////////////////
void ImageCanvas::
Show(PyramidImage<unsigned char>& pim, string name)
{
  Image<unsigned char> im;
  pim.GetSingleImage(im);
  Show(im, name);
}

//////////////////////////////////////////////////
void ImageCanvas::
Show(BIAS::Image<unsigned char>& im, string name)
{
  if (im.GetColorModel()!= ImageBase::CM_RGB
      && im.GetColorModel() != ImageBase::CM_PGR_XB3_F7M3_GBRG){
    Image<unsigned char> tmpim;
    if (ImageConvert::Convert(im, tmpim, ImageBase::CM_RGB)!=0){
      BIASERR("error converting");
    }
    BIASDOUT(D_IC_IM,"Show(im,name) called Show(im,tmpim,name)");
    Show(im, tmpim, name);
  } else {
    BIASDOUT(D_IC_IM,"Show(im,name) called Show(im,im,name)");
    if(im.IsPlanar())
    {
      Image<unsigned char>
        tmpIm;
        if(ImageConvert::Convert(im, tmpIm, ImageBase::CM_RGB) != 0)
        {
          BIASERR("error converting");
        }
        BIASDOUT(D_IC_IM,"Show(im,name) called Show(im,tmpIm,name)");
        Show(im, tmpIm, name);
    }
    else
    {
      Show(im, im, name);
    }
  }

}

//////////////////////////////////////////////////
void ImageCanvas::
Show(BIAS::ImageBase& origim,
     BIAS::Image<unsigned char>& scaledrgbim,
     std::string name)
{
  origim_mutex_.Lock();
  BIASDOUT(D_IC_IM,"Adress of origim: "<<&origim);
  if(&origim_!=&origim) //only copy if not already the same
    origim_ = origim;

  origim_mutex_.Unlock();

  if(&rgbim_!=&scaledrgbim)
    rgbim_=scaledrgbim;

  BIASDOUT(D_IC_IM,"Adress of rgbim_: "<<&rgbim_);

  width_  = origim_.GetWidth ();
  height_ = origim_.GetHeight();

  //// rgb display image may have other size, e.g. 3*width for X3B
  //width_  = max(origim.GetWidth (), scaledrgbim.GetWidth () );
  //height_ = max(origim.GetHeight(), scaledrgbim.GetHeight() );

  ImageName_ = name;
  wxPoint scrolledP(0,0),origP(0,0);

  if(KeepScrollPosition_){
    scrolledP = this->CalcScrolledPosition(origP);

    scrolledP.x = -scrolledP.x;
    scrolledP.y = -scrolledP.y;

    if(ShowScaled_){
      if((scrolledP.x > ScaledImageSizeX_) || (scrolledP.y > ScaledImageSizeY_)){
        scrolledP.x = 0;
        scrolledP.y = 0;
      }
    }else{
      if((scrolledP.x > (int)width_) || (scrolledP.y > (int)height_)){
        scrolledP.x = 0;
        scrolledP.y = 0;
      }
    }
  }
  //reset scrollings of image dimension changed
  if(width_ !=lastwidth_ || height_ != lastheight_){
    scrolledP.x = scrolledP.y = 0;
  }

  if(ShowScaled_) {
    // adjust virtual size and scrollbars to requested scaled image size
    SetVirtualSize(    ScaledImageSizeX_ , ScaledImageSizeY_);
    SetScrollbars(1, 1, ScaledImageSizeX_,ScaledImageSizeY_,scrolledP.x,scrolledP.y);
  }
  else{
    SetScrollbars(1, 1, width_, height_,scrolledP.x,scrolledP.y);
  }
  wxbitmap_mutex_.Lock();
  if (wximage_ != NULL){
    delete wximage_; wximage_ = NULL;
  }
  wximage_ =new wxImage(rgbim_.GetWidth(), rgbim_.GetHeight(),
                        rgbim_.GetImageData(), true); //don't delete array

#ifndef __APPLE__ // core dumps under mac os x 10.5
  //if roi is mask store mask
  if((origim_.GetROI())&&(origim_.GetROI()->GetROIType()==ROI_Mask))
    {
      if (wxRoiImage_ != NULL) {
        delete wxRoiImage_; wxRoiImage_ = NULL;
      }
      origim_.GetROI()->GetMaskImage(roimask_);
      //  bunt malloc is deleted in destructor of wxImage!
      unsigned char* bunt =(unsigned char*) malloc(3*origim_.GetWidth()*origim_.GetHeight());
      unsigned num = origim_.GetWidth()*origim_.GetHeight();
      unsigned char* alphaimg = roimask_.GetImageData();
      for(unsigned p=0;p<num; p++)
        {
          bunt[p*3]=0;
          bunt[p*3+1]=255;
          bunt[p*3+2]=255;
          if(alphaimg[p]!=0) alphaimg[p]=128;
        }
      //passing false as forth argument makes wxImage delete bunt
      wxRoiImage_ = new wxImage(origim_.GetWidth(), origim_.GetHeight(),
                                bunt,false);
      wxRoiImage_->InitAlpha();
      wxRoiImage_->SetAlpha(alphaimg,true); //don't delete array

    }
  else{
    delete wxRoiImage_; wxRoiImage_ = NULL;
    roimask_.Init(4,4,1);
  }
#endif // __APPLE__

  wxbitmap_mutex_.Unlock();
  if (MyZoomWin_->IsShown()) {
    //BIAS_MUTEX_LOCK(origim_mutex_);
    MyZoomWin_->NewImage(origim_, rgbim_, AsciiToWx(ImageName_));
    //BIAS_MUTEX_UNLOCK(origim_mutex_);
  }
  if(MyHistoWin_!=NULL){
    if (MyHistoWin_->IsShown()) {
      //BIAS_MUTEX_LOCK(origim_mutex_);
      MyHistoWin_->NewImage(origim_, AsciiToWx(ImageName_));
      //BIAS_MUTEX_UNLOCK(origim_mutex_);
    }
  }
  //show value bar frame
  if(MyValueBarFrame_!=NULL){
    if (MyValueBarFrame_->IsShown()) {
        //BIAS_MUTEX_LOCK(origim_mutex_);
        MyValueBarFrame_->SetImage(origim_);
        //BIAS_MUTEX_UNLOCK(origim_mutex_);
    }
  }

  if (mousex_>=0 && mousey_>=0){
    UpdateStatusBar((unsigned)mousex_, (unsigned)mousey_);
  }


  lastwidth_=width_;
  lastheight_=height_;

#ifdef WIN32
  this->Refresh();
#else
  wxPaintEvent pe;
  wxPostEvent(this->GetEventHandler(),pe);
#endif

}
//////////////////////////////////////////////////
wxPoint ImageCanvas::
GetHistoPos()
{
  if(MyHistoWin_ != NULL)
    return MyHistoWin_->GetPosition();
  else
    return wxPoint(10,10);
}
//////////////////////////////////////////////////
wxSize ImageCanvas::
GetHistoSize()
{
  if(MyHistoWin_ != NULL)
    return MyHistoWin_->GetSize();
  else
    return wxSize(300,250);
}
//////////////////////////////////////////////////
wxPoint ImageCanvas::
GetValueBarPos()
{
  if(MyValueBarFrame_ != NULL)
    return MyValueBarFrame_->GetPosition();
  else
    return wxPoint(10,10);
}
//////////////////////////////////////////////////
wxSize ImageCanvas::
GetValueBarSize()
{
  if(MyValueBarFrame_ != NULL)
    return MyValueBarFrame_->GetSize();
  else
    return wxSize(300,250);
}

//////////////////////////////////////////////////
void ImageCanvas::
ShowHistogramm(ImageBase& image, wxPoint pos, wxSize size)
{
  if(MyHistoWin_==NULL)
      InitHisto(pos, size);

  if (!image.IsEmpty()){
    MyHistoWin_->NewImage(image, AsciiToWx(ImageName_));
    MyHistoWin_->Show(true);
  }
  else{
    BIASERR("Hey, no image saved in image!");
  }
}

//////////////////////////////////////////////////
void ImageCanvas::
ShowHistogramm(wxPoint pos, wxSize size)
{
  if(MyHistoWin_==NULL)
    InitHisto(pos, size);

  if (!origim_.IsEmpty()){
    MyHistoWin_->NewImage(origim_, AsciiToWx(ImageName_));
    MyHistoWin_->Show(true);
  }
  else{
    BIASERR("Hey, no image saved in origim_!");
  }
}

//////////////////////////////////////////////////
void ImageCanvas::
ShowImageValueBar(ImageBase& image,  wxPoint pos, wxSize size)
{
    if(MyValueBarFrame_==NULL)
        InitImageValueBar(pos, size);
    if (!origim_.IsEmpty()){
        MyValueBarFrame_->SetSize(size);
        MyValueBarFrame_->SetPosition(pos);
        MyValueBarFrame_->SetImage(image);
        MyValueBarFrame_->Show(true);
    }
}

//////////////////////////////////////////////////
void ImageCanvas::
ShowImageValueBar(wxPoint pos, wxSize size)
{
    if(MyValueBarFrame_==NULL)
        InitImageValueBar(pos, size);
    if (!origim_.IsEmpty()){
        MyValueBarFrame_->SetSize(size);
        MyValueBarFrame_->SetPosition(pos);
        MyValueBarFrame_->SetImage(origim_);
        MyValueBarFrame_->Show(true);
    }
}

//////////////////////////////////////////////////
void ImageCanvas::
Zoom(unsigned x, unsigned y)
{
  //BIAS_MUTEX_LOCK(origim_mutex_);
  MyZoomWin_->NewImage(origim_, rgbim_, AsciiToWx(ImageName_));
  //BIAS_MUTEX_UNLOCK(origim_mutex_);
  MyZoomWin_->SetZoom(DefaultZoom_);
  MyZoomWin_->Show(true);

  if (ShowScaled_ && ScaledImageSizeX_>0 && ScaledImageSizeY_>0) {
    MyZoomWin_->NewCoo((int)((float)x * ((float)width_ / (float)ScaledImageSizeX_)),
      (int)((float)y *((float)height_/(float)ScaledImageSizeY_)));
  }
  else MyZoomWin_->NewCoo(x, y);
}

//////////////////////////////////////////////////
void ImageCanvas::
UpdateStatusBar(unsigned x, unsigned y)
{

  // check if there is nothing to do:
  if (SBar_==NULL) return;
  if(Bitmap_==NULL) return;

  // TODO: do we really need these lockings?
  //BIAS_MUTEX_LOCK(wxbitmap_mutex_);

  BIASASSERT(SBar_   != NULL);
  BIASASSERT(Bitmap_ != NULL);
  if ((x>=0) && (x<width_) && (y>=0) && (y<height_))
  {

    ostringstream os;
    //displate coordinate:
    os << "("<<setw(3)<<x<<", "<<setw(3)<<y<<") : (";

    // determine pixel type relying on storage type
    // dynamic_check to BIAS::Image<T> does not work because base image is
    // loaded

    origim_mutex_.Lock();
    {
      for (unsigned int channel=0;
           channel<origim_.GetChannelCount();
           channel++){
        if (channel!=0)
          os <<","; // no comma before first value
        BIAS::ImageBase::PrintPixelValue(origim_, x,y, (unsigned short)channel, os );
      }
    }
    origim_mutex_.Unlock();
    os <<")";
    SBar_->SetStatusText(AsciiToWx(os.str()), SBarID_);
    if(SBar_->GetFieldsCount() == 2)
    {
      SBarWidths_[1] = max(SBarWidths_[1], ((int)(os.str().size()) * SBar_->GetCharWidth()));
      SBar_->SetStatusWidths(SBar_->GetFieldsCount(), SBarWidths_);
    }
  }
  //BIAS_MUTEX_UNLOCK(wxbitmap_mutex_);
}

//////////////////////////////////////////////////
bool ImageCanvas::
GetMousePos(int& x, int& y)
{
  x= mousex_; y=mousey_;
  return ((mousex_>=0) && (mousey_>=0));
}

//////////////////////////////////////////////////
bool ImageCanvas::
HistogrammIsShown()
{
  if(MyHistoWin_!=NULL && MyHistoWin_->IsShown())
    return true;
  else
    return false;
}

//////////////////////////////////////////////////
bool ImageCanvas::
ImageValueBarIsShown()
{
  if(MyValueBarFrame_!=NULL && MyValueBarFrame_->IsShown())
    return true;
  else
    return false;
}

//////////////////////////////////////////////////
void ImageCanvas::
HideImageValueBar(){
    if(MyValueBarFrame_!=NULL && MyValueBarFrame_->IsShown())
        MyValueBarFrame_->Hide();
}

void ImageCanvas::
KeepScrollPosition(bool flag)
{
  KeepScrollPosition_ = flag;
}

//////////////////////////////////////////////////
void ImageCanvas::
RaiseZoomWindow(const bool raise_or_lower)
{
  if (MyZoomWin_->IsShown()){
    if (raise_or_lower){
      MyZoomWin_->Raise();
    } else {
      MyZoomWin_->Lower();
    }
  }
}

//////////////////////////////////////////////////
void ImageCanvas::
OnErase(wxEraseEvent& )
{}

//////////////////////////////////////////////////
void ImageCanvas::
OnPaint(wxPaintEvent & event)
{

  wxScrolledWindow::WXCOMPAT_ScW_OnPaint(event);
  wxBufferedPaintDC dc(this);

  // documentation of wxBufferedPaintDC says:
  // "you probably do not want to call PrepareDC [...] as it already does this
  // internally for the real underlying wxPaintDC"
  // but scrolling the canvas leads to broken areas!!!
  // however, problem can be fixed by calling PrepareDC()
  PrepareDC(dc);

  wxbitmap_mutex_.Lock();
  if (wximage_ && wximage_->IsOk()){
    if (Bitmap_ != NULL) {
      delete Bitmap_; Bitmap_ = NULL;
    }
    if (ShowScaled_ && ScaledImageSizeX_>0 && ScaledImageSizeY_>0)  {
      wximage_->Rescale(ScaledImageSizeX_, ScaledImageSizeY_,
                        UseHighScaleQuality_ ? wxIMAGE_QUALITY_HIGH : wxIMAGE_QUALITY_NORMAL);
    }
    Bitmap_ = new wxBitmap( *wximage_ );
  }

#ifndef __APPLE__ // core dumps under mc os x 10.5
  if (wxRoiImage_ && wxRoiImage_->IsOk()){
    if (RoiBitmap_ != NULL) {
      delete RoiBitmap_; RoiBitmap_ = NULL;
    }
    if (ShowScaled_ && ScaledImageSizeX_>0 && ScaledImageSizeY_>0)  {
      wxRoiImage_->Rescale(ScaledImageSizeX_, ScaledImageSizeY_,
                           UseHighScaleQuality_ ? wxIMAGE_QUALITY_HIGH : wxIMAGE_QUALITY_NORMAL);
    }
    RoiBitmap_ = new wxBitmap( *wxRoiImage_ );
  }
#endif // __APPLE__

  if (Bitmap_ && Bitmap_->IsOk() && dc.IsOk()) {
    // since now using double buffering, turning off
    // clearing is actually unnecessary
    if (ClearDrawingContext_) {
      dc.Clear();
    }
    dc.DrawBitmap( *Bitmap_, 0, 0,false );

#ifndef __APPLE__ // core dumps under mc os x 10.5
    if(DrawRoi_)
    {
      PaintRoiOnDc_(dc);
    }//if draw roi
#endif
  }
  wxbitmap_mutex_.Unlock();
  //wxPostEvent(this->GetParent()->GetEventHandler(), event);
}

//////////////////////////////////////////////////
void ImageCanvas::
PaintRoiOnDc_(wxBufferedPaintDC& dc)
{
  ROI* tmpRoi = origim_.GetROI();
  if(!tmpRoi) return;

  wxPen pen(wxColor(0,255,255,128));
  dc.SetPen(pen);
  switch(tmpRoi->GetROIType())
  {
  case ROI_Corners:
    {
      unsigned ulx,uly,lrx,lry;
      tmpRoi->GetCorners(ulx,uly,lrx,lry);
      if(!((ulx==0)&&(uly==0)&&
        (lrx==origim_.GetWidth())&&(lry==origim_.GetHeight())))
      {
        wxPen pen(wxColor(0,255,255,128));
        if(ShowScaled_)
        {
          double sx = (double)ScaledImageSizeX_/(double)origim_.GetWidth();
          double sy = (double)ScaledImageSizeY_/(double)origim_.GetHeight();
          ulx = (unsigned)(double(ulx)* sx);
          uly = (unsigned)(double(uly)* sy);
          lrx = (unsigned)(double(lrx)* sx);
          lry = (unsigned)(double(lry)* sy);
        }
        dc.DrawLine(ulx,uly,lrx,uly);
        dc.DrawLine(lrx,uly,lrx,lry);
        dc.DrawLine(lrx,lry,ulx,lry);
        dc.DrawLine(ulx,lry,ulx,uly);
      } //if size valid
      break;
    }  //case
  case ROI_Mask:
    {
      //pixel not in the ROI is set to UCHAR_MAX and every other pixel to 0
      if(RoiBitmap_)
        dc.DrawBitmap(*RoiBitmap_,0,0);
    }
    break;
  case ROI_Rows:
    {
      vector<unsigned> start, end;
      if (!tmpRoi->GetRows(start, end)){
        BIASERR("should never happen");
        BIASABORT;
      }
      if (start.size()!=end.size() || start.size()!=origim_.GetHeight()){
        BIASERR("invalid roi");
        BIASABORT;
      }
      double sx = 1.0, sy = 1.0;
      if(ShowScaled_){
        sx = (double)ScaledImageSizeX_/(double)origim_.GetWidth();
        sy = (double)ScaledImageSizeY_/(double)origim_.GetHeight();
      }
      const unsigned height = origim_.GetHeight();
      for (unsigned y=0; y<height; y++){
        if (start[y]!=0 || end[y]!=0){
          unsigned tx = (unsigned)rint(sx*(double)(start[y]));
          unsigned ty = (unsigned)rint(sy*(double)(y));
          dc.DrawPoint(tx, ty);
          tx = (unsigned)rint(sx*(double)(end[y]));
          dc.DrawPoint(tx, ty);
        }
      }
    }
    break;
  case ROI_Points:
  default:
    BIASWARN("imagecanvas::PaintRoiOnDc_ : exotic ROI type not handled! ");
    break;
  }

}

//////////////////////////////////////////////////
void ImageCanvas::
OnMouseWheel(wxMouseEvent &event){
   if(event.AltDown() && event.GetWheelRotation() > 0){
     ShowScaled_ =true; 
     ScaledImageSizeX_ = (int)(ScaledImageSizeX_ * 1.1);
     ScaledImageSizeY_ = (int)(ScaledImageSizeY_ * 1.1);
   }
   else if(event.AltDown() && event.GetWheelRotation() < 0){
     ShowScaled_ =true; 
     ScaledImageSizeX_ = (int)(ScaledImageSizeX_ * 0.9);
     ScaledImageSizeY_ = (int)(ScaledImageSizeY_ * 0.9);
   }
   //   cout<<"Mouse wheel"<<endl;
   wxPaintEvent e;
   OnPaint(e);
   event.Skip();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnMouseLeave(wxMouseEvent &event)
{
  if (SBar_) SBar_->SetStatusText(wxT(""), SBarID_);
  mousex_=mousey_=-1;
  event.Skip();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnMouseEnter(wxMouseEvent &event)
{
  //if (SBar_) SBar_->SetStatusText(wxT("Test"), 0);
  //mousex_=mousey_=-1;
  //event.Skip();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnMouseMove(wxMouseEvent &event)
{
  wxClientDC dc(this);
  PrepareDC(dc);
  if (GetParent()) GetParent()->PrepareDC(dc);
  wxPoint pos = event.GetPosition();
  mousex_ = dc.DeviceToLogicalX( pos.x );
  mousey_ = dc.DeviceToLogicalY( pos.y );

  if (ShowScaled_) {
    // if we are in scaled mode, correct coordinates by scale !
    double w = ScaledImageSizeX_, h = ScaledImageSizeY_;
    double ow = origim_.GetWidth(), oh = origim_.GetHeight();
    double ratiox = ow/w , ratioy = oh/h;
    mousex_ = (int)(mousex_ * ratiox);
    mousey_ = (int)(mousey_ * ratioy);
  }
  UpdateStatusBar((unsigned)mousex_, (unsigned)mousey_);
  //event.Skip();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnRightMouseButton(wxMouseEvent &event)
{
  wxClientDC dc(this);
  PrepareDC(dc);
  wxPoint pos = event.GetPosition();
  unsigned x = (unsigned) dc.DeviceToLogicalX( pos.x );
  unsigned y = (unsigned) dc.DeviceToLogicalY( pos.y );
  Zoom(x, y);
  MyZoomWin_->Raise();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnLeftMouseButton(wxMouseEvent &event)
{
  event.ResumePropagation(wxEVENT_PROPAGATE_MAX);
  event.Skip();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnSize(wxSizeEvent& event)
{
  Fit();
  event.Skip();
}

//////////////////////////////////////////////////
void ImageCanvas::
OnKeyPress(wxKeyEvent &event)
{
  event.ResumePropagation(wxEVENT_PROPAGATE_MAX);
  //  cerr <<"ImageCanvas::OnKeyPress\n";
  event.Skip();
}