PImageCanvas.cxx

//==============================================================================
// File:        PImageCanvas.cxx
//
// Copyright (c) 2017, Phil Harvey, Queen's University
//==============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <X11/StringDefs.h>
#include <Xm/DrawingA.h>
#include "ImageData.h"
#include "PImageCanvas.h"
#include "PImageWindow.h"
#include "PHitInfoWindow.h"
#include "PResourceManager.h"
#include "PDrawXPixmap.h"
#include "PDrawPostscriptFile.h"
#include "PMenu.h"
#include "AgedWindow.h"

const short kPrintScaling       = 10;   // coordinate scaling for printed images
const short kLabelClickMargin   = 8;


//----------------------------------------------------------------------------------------------
// PImageCanvas constructor
//
PImageCanvas::PImageCanvas(PImageWindow *owner, Widget canvas, EventMask eventMask)
{
    ImageData   *data = owner->GetData();
    
    mDpy            = data->display;
    mOwner          = owner;
    mWidth          = 0;
    mHeight         = 0;
    mCanvasWidth    = 0;
    mCanvasHeight   = 0;
    mDrawable       = 0;
    mCanvas         = NULL;
    mEventMask      = eventMask;
    mDrawLabel      = 1;
    mAllowLabel     = 1;
    mLabelText      = NULL;
    mLabelHeight    = 0;
    mDirty          = kDirtyPix;
    mTimer          = 0;

    SetCanvas(canvas);
    
    owner->SetImage(this);
    
    data->mSpeaker->AddListener(this);
}

PImageCanvas::~PImageCanvas()
{
    if (mDrawable) delete mDrawable;
    
    if (mCanvas) {
        XtRemoveCallback(mCanvas, XmNexposeCallback, (XtCallbackProc)CanvasExposeProc, this);
        XtRemoveCallback(mCanvas, XmNresizeCallback, (XtCallbackProc)CanvasResizeProc, this);
        
        if (mEventMask) {
            XtRemoveEventHandler(mCanvas, mEventMask, FALSE, (XtEventHandler)CanvasMotionProc, this);
        }
    }
}

void PImageCanvas::Listen(int message, void *dataPt)
{
    switch (message) {
        case kMessageLabelChanged:
            if (mDrawLabel) {
                SetDirty();
            }
            break;
        case kMessageSmoothTextChanged:
            if (mLabelText) {
                SetDirty();
            }
            break;
    }
}
    
// this timer is used by derived object for delayed grabs
static void timerProc(PImageCanvas *thisCanvas)
{
    XButtonEvent evt;
    evt.type = kTimerEvent;
    thisCanvas->HandleEvents((XEvent *)&evt);
}

void PImageCanvas::ArmTimer(unsigned millisec)
{
    ImageData *data = mOwner->GetData();
    if (data->the_app) {
        mTimer = XtAppAddTimeOut(data->the_app, millisec, (XtTimerCallbackProc)timerProc, this);
    }
}   

void PImageCanvas::ResetTimer()
{
    if (mTimer) {
        XtRemoveTimeOut(mTimer);
        mTimer = 0;
    }
}   

// SetDirty - mark the image as needing redrawing
void PImageCanvas::SetDirty(int flag)
{
    mDirty |= flag;             // set our dirty flags
    mOwner->SetDirty(flag);     // set our owner's dirty flag
}

/* must be called AFTER widget is realized */
void PImageCanvas::SetCursor(int type)
{
    /* define the cursor for our image */
    XDefineCursor(mDpy, XtWindow(mCanvas), PResourceManager::sResource.cursor[type]);
}

void PImageCanvas::SetCursorForPos(int x, int y)
{
    if (IsInLabel(x,y)) {
        if (IsLabelOn()) {
            SetCursor(CURSOR_ARROW_DOWN);
        } else {
            SetCursor(CURSOR_ARROW_UP);
        }
    } else {
        XUndefineCursor(mDpy, XtWindow(mCanvas));
    }
}

void PImageCanvas::SetCanvas(Widget canvas)
{
    mCanvas = canvas;
    
    if (canvas) {
        mDpy = XtDisplay(canvas);
        
        if (mDrawable) delete mDrawable;
        mDrawable = new PDrawXPixmap(mDpy, mOwner->GetData()->gc,
                                     DefaultDepthOfScreen(XtScreen(canvas)), canvas);
        
        XtAddCallback(canvas, XmNexposeCallback, (XtCallbackProc)CanvasExposeProc, this);
        XtAddCallback(canvas, XmNresizeCallback, (XtCallbackProc)CanvasResizeProc, this);
        
        if (mEventMask) {
            XtAddEventHandler(canvas, mEventMask, FALSE, (XtEventHandler)CanvasMotionProc, this);
        }
    }
}

// GetCanvasSize - get size of our canvas
// - returns non-zero (width of canvas) if canvas is realized
int PImageCanvas::GetCanvasSize()
{
    // return zero if our widget isn't available or isn't realized
    if (!mCanvas || !XtIsRealized(mCanvas)) return(0);

    // get the current size of the canvas
    Arg         wargs[10];
    Dimension   width,height;
    XtSetArg(wargs[0],XtNwidth, &width);
    XtSetArg(wargs[1],XtNheight,&height);
    XtGetValues(mCanvas,wargs,2);

    if (mCanvasWidth!=width || mCanvasHeight!=height) {
        ImageData   *data = mOwner->GetData();
        mCanvasWidth = mWidth = width;
        mCanvasHeight = mHeight = height;
        if (data->show_label) {
            mHeight -= GetScaling() * mLabelHeight;
            // handle case where mHeight is negative (remember, this is unsigned math)
            if (mHeight > height) mHeight = 0;
        }
        mDirty |= kDirtyPix;    // flag indicates pixmap requires redrawing
        Resize();               // call this whenever the image size changes
    }
    return((int)width);
}

void PImageCanvas::CanvasExposeProc(Widget w, PImageCanvas *anImage, XmDrawingAreaCallbackStruct *call_data)
{
    XExposeEvent  * event = (XExposeEvent *)call_data->event;

    if (!anImage->mCanvasWidth) {
        anImage->GetCanvasSize();
    }
    // if pixmap is available and doesn't require drawing, copy the exposed area to screen
    if (!anImage->IsDirty() &&
         anImage->mDrawable->CopyArea(event->x,event->y,event->width,event->height,XtWindow(anImage->mCanvas)))
    {
        if (event->count == 0) {
            // call this routine after last copy to screen
            anImage->AfterDrawing();
        }
    } else if (event->count == 0) { // only draw on last expose event
        // pixmap is dirty or unavailable -- draw the image from scratch
        anImage->Draw();
    }
}

void PImageCanvas::CanvasResizeProc(Widget w, PImageCanvas *anImage, XmDrawingAreaCallbackStruct *call_data)
{
    int wasDrawn = (anImage->mCanvasWidth != 0);

    if (anImage->GetCanvasSize()) {
        if (wasDrawn) {
            // clear the canvas on the screen until we can redraw it
            //(causes flickering) XClearArea(anImage->mDpy,XtWindow(w),0,0,0,0,TRUE);
        }
    }
}

void PImageCanvas::CanvasMotionProc(Widget w, PImageCanvas *anImage, XEvent *event)
{
    // are we waiting for a window to be selected?
    if (PImageWindow::IsPendingRaise()) {
        // must look for button presses too, in case the window manager
        // doesn't raise the window on a button click
        if (event->type == ButtonPress) {
            anImage->mOwner->WasRaised();
        }
    } else {
        // handle events normally
        anImage->HandleEvents(event);
    }
}

// Print - print image to postscript file
int PImageCanvas::Print(char *filename, int flags)
{
    int printOK = 0;
    
    PDrawPostscriptFile drawable(filename, (flags & kPrintLandscape));
    
    PDrawable *oldDrawable = mDrawable;
    int oldWidth = mWidth;
    int oldHeight = mHeight;
    int oldCanvasWidth = mCanvasWidth;
    int oldCanvasHeight = mCanvasHeight;
    
    mDrawable = &drawable;
    
    // change scaling to improve printed resolution
    drawable.SetScaling(kPrintScaling);
    mWidth *= kPrintScaling;
    mHeight *= kPrintScaling;
    mCanvasWidth *= kPrintScaling;
    mCanvasHeight *= kPrintScaling;
    Resize();       // call this whenever the image size changes
    
    // draw image to postscript file
    if (drawable.BeginDrawing(mCanvasWidth,mCanvasHeight)) {
        Prepare();
        DrawSelf();
        drawable.EndDrawing();
        printOK = 1;
    }
    
    // restore original settings
    mDrawable = oldDrawable;
    mWidth = oldWidth;
    mHeight = oldHeight;
    mCanvasWidth = oldCanvasWidth;
    mCanvasHeight = oldCanvasHeight;
    Resize();       // call this whenever the image size changes
    
    return(printOK);
}

//---------------------------------------------------------------------------------------
// Draw
//
void PImageCanvas::Draw()
{
    // get our canvas dimensions if not done yet
    if (!mCanvasWidth) {
        if (!GetCanvasSize()) return;   // return if widget not realized
    }
    if (mDrawable->BeginDrawing(mCanvasWidth, mCanvasHeight)) {
        Prepare();
        // set dirty pixmap flag too if we have arrived here without a pixmap
        if (!mDrawable->HasPixmap()) {
            mDirty |= kDirtyPix;
        }
        DrawSelf();
        mDrawable->EndDrawing();
        // copy the image to the screen
        mDrawable->CopyArea(0,0,mCanvasWidth,mCanvasHeight,XtWindow(mCanvas));
        // reset all dirty flags since we have just successfully drawn ourself
        mDirty = 0;
        AfterDrawing();     // call this after any drawing to screen
    }
}

//---------------------------------------------------------------------------------------
// DrawLabel
//
void PImageCanvas::DrawLabel(int x,int y,ETextAlign_q align)
{
    if (mLabelText && mLabelHeight) {
        SetForeground(TEXT_COL);
        y -= GetScaling() * mLabelHeight;
        for (TextSpec *ts=mLabelText; ts->string; ++ts) {
            SetFont(ts->font);
#ifdef ANTI_ALIAS
            SetFont(ts->xftFont);
#endif
            y += GetScaling() * GetFontAscent();
            DrawString(x, y, ts->string, align);
            y += GetScaling() * GetFontDescent();
        }
    }
}

//---------------------------------------------------------------------------------------
// Prepare - prepare to draw into canvas
//
void PImageCanvas::Prepare()
{
    // resize drawing area according to current label size
    ImageData *data = mOwner->GetData();
#ifdef ANTI_ALIAS
    mDrawable->SetSmoothText(data->smooth & kSmoothText);
    mDrawable->SetSmoothLines(data->smooth & kSmoothLines);
#endif
    int newHeight;
    if (mDrawLabel && data->show_label) {
        AgedWindow *mainWindow = mOwner->GetData()->mMainWindow;
        mLabelText = mainWindow->GetLabelText();
        newHeight = mainWindow->GetLabelHeight();
    } else {
        mLabelText = NULL;
        newHeight = 0;
    }
    // get current number of lines in label
    if (mLabelHeight != newHeight) {
        // calculate new image height
        mHeight = mCanvasHeight - GetScaling() * newHeight;
        if (mHeight > mCanvasHeight) mHeight = 0;
        mLabelHeight = newHeight;
        Resize();   // call this whenever the image size changes
    }
}


//---------------------------------------------------------------------------------------
// DrawSelf
//
void PImageCanvas::DrawSelf()
{
    // clear the canvas with the background colour */
    SetForeground(BKG_COL);
    FillRectangle(0, 0, mCanvasWidth, mCanvasHeight);

    if (mLabelText) {
        DrawLabel(mCanvasWidth/2, mCanvasHeight-2*GetScaling(), kTextAlignBottomCenter);
    }
}

int PImageCanvas::IsInLabel(int x, int y)
{
    if (mAllowLabel) {
        return(mOwner->GetData()->show_label && (y > mCanvasHeight - mLabelHeight - kLabelClickMargin));
    } else {
        return(0);
    }
}

void PImageCanvas::ShowLabel(int on)
{
    if (mDrawLabel != on) {
        mDrawLabel = on;
        if (mCanvas && XtIsRealized(mCanvas)) {
            Prepare();  // do this now so any subsequent cursor changes will use new configuration
            SetDirty(); // redraw ourself
        }
    }
}

void PImageCanvas::AllowLabel(int on)
{
    mAllowLabel = on;
    if (!on) ShowLabel(on);
}

// utility to create image canvas plus specified scrollbars
void PImageCanvas::CreateCanvas(char *name, int scrollBarMask)
{
    int             n;
    Arg             wargs[16];
    unsigned char   attach;
    Widget          topWidget;
    
    if (mOwner->GetMenu()) {
        topWidget = mOwner->GetMenu()->GetWidget();
    } else {
        topWidget = 0;
    }
    // get right attachment of top widget
    if (topWidget) {
        n = 0;
        XtSetArg(wargs[n], XmNrightAttachment, &attach);  ++n;
        XtGetValues(topWidget, wargs, n);
    }
    
    if (scrollBarMask & kScrollLeftMask) {
        n = 0;
        if (topWidget) {
            XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET);  ++n;
            XtSetArg(wargs[n], XmNtopWidget, topWidget); ++n;
        } else {
            XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM);  ++n;
        }
        XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM);  ++n;
        XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM);  ++n;
        XtSetArg(wargs[n], XmNwidth, 15); ++n;
        XtSetArg(wargs[n], XmNorientation, XmVERTICAL);  ++n;
        mOwner->NewScrollBar(kScrollLeft,"agedScroll1",wargs,n);
    }
    if (scrollBarMask & kScrollRightMask) {
        n = 0;
        if (topWidget && attach==XmATTACH_FORM) {
            XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET);  ++n;
            XtSetArg(wargs[n], XmNtopWidget, topWidget); ++n;
        } else {
            XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM);  ++n;
        }
        XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM);  ++n;
        XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM);  ++n;
        XtSetArg(wargs[n], XmNwidth, 15); ++n;
        XtSetArg(wargs[n], XmNorientation, XmVERTICAL);  ++n;
        mOwner->NewScrollBar(kScrollRight,"agedScroll2",wargs,n);
    }
    if (scrollBarMask & kScrollBottomMask) {
        n = 0;
        if (scrollBarMask & kScrollLeftMask) {
            XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_WIDGET);  ++n;
            XtSetArg(wargs[n], XmNleftWidget, mOwner->GetScrollBar(kScrollLeft)->GetWidget()); ++n;
        } else {
            XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM);  ++n;
        }
        if (scrollBarMask & kScrollRightMask) {
            XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_WIDGET);  ++n;
            XtSetArg(wargs[n], XmNrightWidget, mOwner->GetScrollBar(kScrollRight)->GetWidget()); ++n;
        } else {
            XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM);  ++n;
        }
        XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM);  ++n;
        XtSetArg(wargs[n], XmNheight, 15); ++n;
        XtSetArg(wargs[n], XmNorientation, XmHORIZONTAL);  ++n;
        mOwner->NewScrollBar(kScrollBottom,"agedScroll3",wargs,n);
    }
    
    // finally create canvas
    n = 0;
    if (topWidget && attach==XmATTACH_FORM) {
        XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET);  ++n;
        XtSetArg(wargs[n], XmNtopWidget, topWidget);  ++n;
    } else {
        // attach top to form if no top widget, or if top widget doesn't span form
        XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM);  ++n;
    }
    if (scrollBarMask & kScrollLeftMask) {
        XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_WIDGET);  ++n;
        XtSetArg(wargs[n], XmNleftWidget, mOwner->GetScrollBar(kScrollLeft)->GetWidget()); ++n;
    } else {
        XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM);  ++n;
    }
    if (scrollBarMask & kScrollBottomMask) {
        XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_WIDGET);  ++n;
        XtSetArg(wargs[n], XmNbottomWidget, mOwner->GetScrollBar(kScrollBottom)->GetWidget()); ++n;
    } else {
        XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM);  ++n;
    }
    if (scrollBarMask & kScrollRightMask) {
        XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_WIDGET);  ++n;
        XtSetArg(wargs[n], XmNrightWidget, mOwner->GetScrollBar(kScrollRight)->GetWidget()); ++n;
    } else {
        XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM);  ++n;
    }
    Widget canvas = XtCreateManagedWidget(name, xmDrawingAreaWidgetClass, mOwner->GetMainPane(), wargs, n);
    
    SetCanvas(canvas);

    /* set up this as the default scrollbar handler */
    mOwner->SetScrollHandler(this);
    SetScrolls();
}