/*!
* \ingroup WlzBoundary
* \brief Convert the input boundary list to a domain object.
Use WlzBoundaryToObj if conversion of a 3D stack of boundary list is required
or if the boundary is available as a first class object.
*
* \return Domain object corresponding to the input boundary domain,
NULL on error.
* \param bound Input boundary list domain.
* \param fillMode Polyline fill mode, see WlzPolyToObj().
* \param dstNum Error return.
* \par Source:
* WlzBoundToObj.c
*/
WlzObject *WlzBoundToObj(
WlzBoundList *bound,
WlzPolyFillMode fillMode,
WlzErrorNum *dstNum)
{
WlzObject *obj, *selfobj = NULL, *nextobj, *downobj;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check input */
if( bound == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
/* find object corresponding to the current boundary */
if( errNum == WLZ_ERR_NONE ){
if( bound->poly != NULL ){
selfobj = WlzPolyToObj(bound->poly, fillMode, &errNum);
}
else {
selfobj = NULL;
}
}
if( (errNum == WLZ_ERR_NONE) && (selfobj != NULL)
&& (bound->type != WLZ_BOUNDLIST_PIECE)
&& (fillMode != WLZ_VERTEX_FILL) ){
obj = WlzErosion(selfobj, WLZ_4_CONNECTED, &errNum);
WlzFreeObj(selfobj);
selfobj = obj;
}
/* add object corresponding to next */
if( (errNum == WLZ_ERR_NONE) && bound->next ){
nextobj = WlzBoundToObj(bound->next, fillMode, &errNum);
if( selfobj == NULL ){
selfobj = nextobj;
}
else {
if( (errNum == WLZ_ERR_NONE) && (nextobj != NULL) ){
obj = WlzUnion2(selfobj, nextobj, &errNum);
WlzFreeObj(nextobj);
WlzFreeObj(selfobj);
selfobj = obj;
}
}
}
/* remove object corresponding to down */
if( (errNum == WLZ_ERR_NONE) && bound->down ){
downobj = WlzBoundToObj(bound->down, fillMode, &errNum);
if( downobj != NULL ){
if( selfobj != NULL ){
if( fillMode != WLZ_VERTEX_FILL ){
obj = WlzDiffDomain(selfobj, downobj, &errNum);
}
else {
obj = WlzUnion2(selfobj, downobj, &errNum);
}
WlzFreeObj(selfobj);
selfobj = obj;
}
WlzFreeObj(downobj);
}
}
/* return object */
if( dstNum ){
*dstNum = errNum;
}
return(selfobj);
}
/*!
* \ingroup WlzValuesUtils
* \brief Set the value maskVal within the domain given by the
* mask object. The mask object can be a 2D, 3D, polygon
* or boundary object. A 3D mask with a 2D object is an
* error. A 2D mask with a 3D object will be applied to
* each plane in turn.
*
* \return New object with the same domain as the input object but
with values in the intersection with the mask domain set to the mask
value. NULL on error.
* \param obj Input object
* \param mask Mask object.
* \param maskVal mask value.
* \param dstErr Error return.
* \par Source:
* WlzGreyMask.c
*/
WlzObject *WlzGreyMask(
WlzObject *obj,
WlzObject *mask,
WlzPixelV maskVal,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObject *tmpMask, *obj1;
WlzValues values;
WlzPixelV tmpMaskval;
WlzIntervalWSpace iwsp;
WlzGreyWSpace gwsp;
WlzGreyP gptr;
int i;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check obj */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
break;
case WLZ_3D_DOMAINOBJ:
return WlzGreyMask3d(obj, mask, maskVal, dstErr);
case WLZ_TRANS_OBJ:
if((values.obj = WlzGreyMask(obj->values.obj, mask, maskVal,
&errNum)) != NULL){
return WlzMakeMain(WLZ_TRANS_OBJ, obj->domain, values,
NULL, NULL, dstErr);
}
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* check the mask */
if( errNum == WLZ_ERR_NONE ){
if( mask == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
values.core = NULL;
switch( mask->type ){
case WLZ_2D_DOMAINOBJ:
tmpMask = WlzMakeMain(WLZ_2D_DOMAINOBJ, mask->domain, values,
NULL, NULL, &errNum);
break;
case WLZ_TRANS_OBJ:
tmpMask = WlzMakeMain(WLZ_2D_DOMAINOBJ, mask->values.obj->domain,
values, NULL, NULL, &errNum);
break;
case WLZ_EMPTY_OBJ:
return WlzMakeMain(WLZ_2D_DOMAINOBJ, obj->domain, obj->values,
NULL, NULL, dstErr);
case WLZ_2D_POLYGON:
tmpMask = WlzPolyToObj(mask->domain.poly, WLZ_SIMPLE_FILL, &errNum);
break;
case WLZ_BOUNDLIST:
tmpMask = WlzBoundToObj(mask->domain.b, WLZ_SIMPLE_FILL, &errNum);
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
if( errNum == WLZ_ERR_NONE ){
tmpMask = WlzAssignObject(tmpMask, NULL);
}
}
}
/* copy input obj and setvalues in the intersection */
if(errNum == WLZ_ERR_NONE){
if((rtnObj = WlzNewGrey(obj, &errNum)) != NULL){
if((obj1 = WlzIntersect2(obj, tmpMask, &errNum)) != NULL){
obj1->values = WlzAssignValues(rtnObj->values, NULL);
errNum = WlzInitGreyScan(obj1, &iwsp, &gwsp);
WlzValueConvertPixel(&tmpMaskval, maskVal, gwsp.pixeltype);
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE)){
gptr = gwsp.u_grintptr;
switch( gwsp.pixeltype ){
case WLZ_GREY_INT:
for(i=0; i<iwsp.colrmn; i++, gptr.inp++){
*gptr.inp = tmpMaskval.v.inv;
}
break;
case WLZ_GREY_SHORT:
for(i=0; i<iwsp.colrmn; i++, gptr.shp++){
*gptr.shp = tmpMaskval.v.shv;
}
break;
case WLZ_GREY_UBYTE:
for(i=0; i<iwsp.colrmn; i++, gptr.ubp++){
*gptr.ubp = tmpMaskval.v.ubv;
}
break;
case WLZ_GREY_FLOAT:
for(i=0; i<iwsp.colrmn; i++, gptr.flp++){
*gptr.flp = tmpMaskval.v.flv;
}
break;
case WLZ_GREY_DOUBLE:
for(i=0; i<iwsp.colrmn; i++, gptr.dbp++){
*gptr.dbp = tmpMaskval.v.dbv;
}
break;
case WLZ_GREY_RGBA:
for(i=0; i<iwsp.colrmn; i++, gptr.rgbp++){
*gptr.rgbp = tmpMaskval.v.rgbv;
}
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
WlzFreeObj(obj1);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
WlzFreeObj(tmpMask);
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
static WlzObject *WlzGreyTemplate3d(
WlzObject *obj,
WlzObject *tmpl,
WlzPixelV tmplVal,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObject *tmpObj = NULL, *obj1 = NULL, *obj2 = NULL;
WlzDomain domain, *domains;
WlzValues values, *valuess;
WlzPlaneDomain *pdom;
int p;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check the object - it is non-NULL and 3D but the
domain needs checking */
if( obj->domain.p == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else {
switch( obj->domain.p->type ){
case WLZ_2D_DOMAINOBJ:
/* check there is a valuetable */
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
} else if( WlzGreyTableIsTiled(obj->values.core->type) ){
errNum = WLZ_ERR_VALUES_TYPE;
}
break;
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
/* check the template and create the return object */
if( errNum == WLZ_ERR_NONE ){
if( tmpl == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
values.core = NULL;
switch( tmpl->type ){
case WLZ_2D_DOMAINOBJ:
pdom = obj->domain.p;
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
pdom->plane1, pdom->lastpl,
pdom->line1, pdom->lastpl,
pdom->kol1, pdom->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = pdom->voxel_size[0];
domain.p->voxel_size[1] = pdom->voxel_size[1];
domain.p->voxel_size[2] = pdom->voxel_size[2];
for(p=pdom->plane1; p <= pdom->lastpl; p++){
domain.p->domains[p - pdom->plane1] = WlzAssignDomain(tmpl->domain,
NULL);
}
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
break;
case WLZ_2D_POLYGON:
pdom = obj->domain.p;
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
pdom->plane1, pdom->lastpl,
pdom->line1, pdom->lastpl,
pdom->kol1, pdom->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = pdom->voxel_size[0];
domain.p->voxel_size[1] = pdom->voxel_size[1];
domain.p->voxel_size[2] = pdom->voxel_size[2];
obj1 = WlzPolyToObj(tmpl->domain.poly, WLZ_SIMPLE_FILL, &errNum);
for(p=pdom->plane1; p <= pdom->lastpl; p++){
domain.p->domains[p - pdom->plane1] = WlzAssignDomain(obj1->domain,
NULL);
}
WlzFreeObj(obj1);
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
break;
case WLZ_BOUNDLIST:
pdom = obj->domain.p;
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
pdom->plane1, pdom->lastpl,
pdom->line1, pdom->lastpl,
pdom->kol1, pdom->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = pdom->voxel_size[0];
domain.p->voxel_size[1] = pdom->voxel_size[1];
domain.p->voxel_size[2] = pdom->voxel_size[2];
obj1 = WlzBoundToObj(tmpl->domain.b, WLZ_SIMPLE_FILL, &errNum);
for(p=pdom->plane1; p <= pdom->lastpl; p++){
domain.p->domains[p - pdom->plane1] = WlzAssignDomain(obj1->domain,
NULL);
}
WlzFreeObj(obj1);
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
break;
case WLZ_3D_DOMAINOBJ:
if( tmpl->domain.p ){
switch( tmpl->domain.p->type ){
case WLZ_2D_DOMAINOBJ:
domain.p = tmpl->domain.p;
break;
case WLZ_PLANEDOMAIN_POLYGON:
case WLZ_PLANEDOMAIN_CONV_HULL:
pdom = tmpl->domain.p;
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
pdom->plane1, pdom->lastpl,
pdom->line1, pdom->lastpl,
pdom->kol1, pdom->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = pdom->voxel_size[0];
domain.p->voxel_size[1] = pdom->voxel_size[1];
domain.p->voxel_size[2] = pdom->voxel_size[2];
for(p=pdom->plane1; p <= pdom->lastpl; p++){
if( pdom->domains[p-pdom->plane1].core ){
obj1 = WlzPolyToObj(pdom->domains[p-pdom->plane1].poly,
WLZ_SIMPLE_FILL, &errNum);
domain.p->domains[p - pdom->plane1] =
WlzAssignDomain(obj1->domain, NULL);
}
WlzFreeObj(obj1);
}
values.core = NULL;
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
break;
case WLZ_PLANEDOMAIN_BOUNDLIST:
pdom = tmpl->domain.p;
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
pdom->plane1, pdom->lastpl,
pdom->line1, pdom->lastpl,
pdom->kol1, pdom->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = pdom->voxel_size[0];
domain.p->voxel_size[1] = pdom->voxel_size[1];
domain.p->voxel_size[2] = pdom->voxel_size[2];
for(p=pdom->plane1; p <= pdom->lastpl; p++){
if( pdom->domains[p-pdom->plane1].core ){
obj1 = WlzBoundToObj(pdom->domains[p-pdom->plane1].b,
WLZ_SIMPLE_FILL, &errNum);
domain.p->domains[p - pdom->plane1] =
WlzAssignDomain(obj1->domain, NULL);
}
WlzFreeObj(obj1);
}
values.core = NULL;
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
break;
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
if( errNum == WLZ_ERR_NONE ){
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
}
else {
errNum = WLZ_ERR_DOMAIN_NULL;
}
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
}
/* now we have a 3D obj and 3D template so run through the template
and map values as required, note we must check that all the valuetables
have the same type ie switch to obj type if necessary */
if( errNum == WLZ_ERR_NONE ){
WlzDomain *objDoms;
WlzValues *objVals;
WlzGreyType gtype=WLZ_GREY_UBYTE;
/* attach a voxel table with empty values list */
values.vox = WlzMakeVoxelValueTb(obj->values.vox->type,
rtnObj->domain.p->plane1,
rtnObj->domain.p->lastpl,
obj->values.vox->bckgrnd,
NULL, NULL);
rtnObj->values = WlzAssignValues(values, NULL);
/* set some local variables */
pdom = rtnObj->domain.p;
domains = rtnObj->domain.p->domains;
valuess = rtnObj->values.vox->values;
objDoms = obj->domain.p->domains;
objVals = obj->values.vox->values;
/* calculate the new valuetables */
for(p=pdom->plane1; p <= pdom->lastpl; p++, domains++, valuess++){
if(((*domains).core)){
if((p >= obj->domain.p->plane1) &&
(p <= obj->domain.p->lastpl) &&
(objDoms[p - obj->domain.p->plane1].core) ){
tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ,
objDoms[p - obj->domain.p->plane1],
objVals[p - obj->domain.p->plane1],
NULL, NULL, NULL);
gtype = WlzGreyTableTypeToGreyType(tmpObj->values.core->type, NULL);
}
else {
tmpObj = WlzMakeEmpty(NULL);
}
tmpObj = WlzAssignObject(tmpObj, NULL);
values.core = NULL;
obj1 = WlzAssignObject(
WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, values,
NULL, NULL, NULL), NULL);
if((obj2 = WlzGreyTemplate(tmpObj, obj1, tmplVal, &errNum)) != NULL){
*valuess = WlzAssignValues(obj2->values, NULL);
WlzFreeObj(obj2);
}
WlzFreeObj(obj1);
WlzFreeObj(tmpObj);
}
}
/* now check all valuetables have the same grey type */
domains = rtnObj->domain.p->domains;
valuess = rtnObj->values.vox->values;
for(p=pdom->plane1; p <= pdom->lastpl; p++, domains++, valuess++){
if((*domains).core &&
(WlzGreyTableTypeToGreyType((*valuess).core->type, NULL) != gtype)){
obj1 = WlzAssignObject(
WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, *valuess,
NULL, NULL, NULL), NULL);
if((obj2 = WlzConvertPix(obj1, gtype, &errNum)) != NULL){
/* substitute the valuetable in the voxel table array */
WlzFreeValues(*valuess);
*valuess = WlzAssignValues(obj2->values, NULL);
WlzFreeObj(obj2);
}
WlzFreeObj(obj1);
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \ingroup WlzValuesUtils
* \brief
*
* \return New object with the same domain <tt>tmpl</tt> but
values in the intersection with <tt>obj</tt> set to those of the object.
Returns NULL on error.
* \param obj Input object to which the template is applied
* \param tmpl Template object
* \param tmplVal Template value for regions in the template
not in the original object
* \param dstErr Error return.
* \par Source:
* WlzGreyTemplate.c
*/
WlzObject *WlzGreyTemplate(
WlzObject *obj,
WlzObject *tmpl,
WlzPixelV tmplVal,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObject *obj1, *obj2;
WlzValues values;
WlzPixelV bckgrnd;
WlzObjectType type;
WlzGreyType gtype=WLZ_GREY_UBYTE;
WlzIntervalWSpace iwsp1, iwsp2;
WlzGreyWSpace gwsp1, gwsp2;
int size;
WlzErrorNum errNum = WLZ_ERR_NONE;
/* check obj */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( WlzGreyTableIsTiled(obj->values.core->type) ){
errNum = WLZ_ERR_VALUES_TYPE;
} else {
bckgrnd = WlzGetBackground(obj, &errNum);
}
if(errNum == WLZ_ERR_NONE) {
gtype = WlzGreyTableTypeToGreyType(obj->values.core->type, NULL);
}
break;
case WLZ_3D_DOMAINOBJ:
return WlzGreyTemplate3d(obj, tmpl, tmplVal, dstErr);
case WLZ_TRANS_OBJ:
if((values.obj = WlzGreyTemplate(obj->values.obj, tmpl,
tmplVal, &errNum)) != NULL){
return WlzMakeMain(WLZ_TRANS_OBJ, obj->domain, values,
NULL, NULL, dstErr);
}
break;
case WLZ_EMPTY_OBJ:
bckgrnd.type = WLZ_GREY_UBYTE;
bckgrnd.v.ubv = 0;
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* check the template */
if( errNum == WLZ_ERR_NONE ){
if( tmpl == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
values.core = NULL;
switch( tmpl->type ){
case WLZ_2D_DOMAINOBJ:
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, tmpl->domain, values,
NULL, NULL, &errNum);
break;
case WLZ_TRANS_OBJ:
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, tmpl->values.obj->domain,
values, NULL, NULL, &errNum);
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
case WLZ_2D_POLYGON:
rtnObj = WlzPolyToObj(tmpl->domain.poly, WLZ_SIMPLE_FILL, &errNum);
break;
case WLZ_BOUNDLIST:
rtnObj = WlzBoundToObj(tmpl->domain.b, WLZ_SIMPLE_FILL, &errNum);
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
}
/* attach a value table to the template and set to the template value,
note the background is set to the input object or zero if empty */
if( errNum == WLZ_ERR_NONE ){
type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gtype, NULL);
if((values.v = WlzNewValueTb(rtnObj, type, bckgrnd, &errNum)) != NULL){
rtnObj->values = WlzAssignValues(values, NULL);
errNum = WlzGreySetValue(rtnObj, tmplVal);
}
}
/* copy input obj values within the intersection */
if( errNum == WLZ_ERR_NONE ){
if((obj->type != WLZ_EMPTY_OBJ) ){
if( (obj1 = WlzIntersect2(obj, rtnObj, &errNum)) ){
obj1->values = WlzAssignValues(rtnObj->values, NULL);
obj2 = WlzMakeMain(obj1->type, obj1->domain, obj->values,
NULL, NULL, NULL);
errNum = WlzInitGreyScan(obj1, &iwsp1, &gwsp1);
errNum = WlzInitGreyScan(obj2, &iwsp2, &gwsp2);
switch( gwsp1.pixeltype ){
case WLZ_GREY_INT:
size = sizeof(int);
break;
case WLZ_GREY_SHORT:
size = sizeof(short);
break;
case WLZ_GREY_UBYTE:
size = sizeof(WlzUByte);
break;
case WLZ_GREY_FLOAT:
size = sizeof(float);
break;
case WLZ_GREY_DOUBLE:
size = sizeof(double);
break;
case WLZ_GREY_RGBA:
size = sizeof(WlzUInt);
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp1)) == WLZ_ERR_NONE)){
(void) WlzNextGreyInterval(&iwsp2);
memcpy((void *) gwsp1.u_grintptr.inp,
(const void *) gwsp2.u_grintptr.inp,
size * iwsp1.colrmn);
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
WlzFreeObj(obj2);
WlzFreeObj(obj1);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
void MAPaintTabletCb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
ThreeDViewStruct *view_struct = (ThreeDViewStruct *) client_data;
XmAnyCallbackStruct *cbs = (XmAnyCallbackStruct *) call_data;
WlzObject *obj, *obj1;
switch( cbs->event->type ){
case ButtonPress:
switch( cbs->event->xbutton.button ){
case Button1:
case Button2:
/* do nothing if shift pressed - magnify option */
if( cbs->event->xbutton.state & ButtonStateIgnoreMask ){
break;
}
break;
default:
break;
}
break;
case ButtonRelease:
switch( cbs->event->xbutton.button ){
case Button1:
case Button2:
break;
case Button3:
if( tabletDrawingFlag ){
if( quitDrawingTrigger ){
tabletDrawingFlag = 0;
quitDrawingTrigger = 0;
}
/* install the new domain */
if( tabletPoly ){
obj = WlzPolyToObj(tabletPoly, WLZ_SIMPLE_FILL, NULL);
/* reset the painted object and redisplay */
if( obj ){
obj1 =
WlzShiftObject(obj,
view_struct->painted_object->domain.i->kol1,
view_struct->painted_object->domain.i->line1,
0, NULL);
setDomainIncrement(obj1, view_struct, currDomain, delFlag);
WlzFreeObj( obj );
WlzFreeObj( obj1 );
}
WlzFreePolyDmn(tabletPoly);
tabletPoly = NULL;
}
}
break;
}
break;
case MotionNotify:
break;
case KeyPress:
/* check for modifier key events */
switch( XLookupKeysym(&(cbs->event->xkey), 0) ){
case XK_Shift_L:
case XK_Shift_R:
modifiers |= ShiftMask;
break;
case XK_Control_L:
case XK_Control_R:
modifiers |= ControlMask;
break;
case XK_Meta_L:
case XK_Meta_R:
modifiers |= Mod4Mask;
break;
case XK_Alt_L:
case XK_Alt_R:
modifiers |= Mod1Mask;
break;
}
break;
case KeyRelease:
/* check for modifier key events */
switch( XLookupKeysym(&(cbs->event->xkey), 0) ){
case XK_Shift_L:
case XK_Shift_R:
modifiers &= ~ShiftMask;
break;
case XK_Control_L:
case XK_Control_R:
modifiers &= ~ControlMask;
break;
case XK_Meta_L:
case XK_Meta_R:
modifiers &= ~Mod4Mask;
break;
case XK_Alt_L:
case XK_Alt_R:
modifiers &= ~Mod1Mask;
break;
}
break;
case TabletButtonPress:
switch( cbs->event->xbutton.button ){
case Button1:
case Button2:
/* set the drawing flag */
if( !tabletDrawingFlag ){
/* save the current domain selection and meta button state */
currDomain = globals.current_domain;
delFlag = ((modifiers & Mod1Mask) ||
(cbs->event->xbutton.button == Button2));
tabletDrawingFlag = 1;
}
/* set the next point */
TabletPolyNextPoint(cbs->event->xbutton.x, cbs->event->xbutton.y);
break;
case Button3:
if( tabletDrawingFlag ){
quitDrawingTrigger = 1;
}
else {
canvas_2D_painting_cb(w, client_data, call_data);
}
break;
}
break;
case TabletButtonRelease:
switch( cbs->event->xbutton.button ){
case Button1:
case Button2:
break;
case Button3:
if( tabletDrawingFlag ){
if( quitDrawingTrigger ){
tabletDrawingFlag = 0;
quitDrawingTrigger = 0;
}
/* install the new domain */
if( tabletPoly ){
obj = WlzPolyToObj(tabletPoly, WLZ_SIMPLE_FILL, NULL);
/* reset the painted object and redisplay */
if( obj ){
obj1 =
WlzShiftObject(obj,
view_struct->painted_object->domain.i->kol1,
view_struct->painted_object->domain.i->line1,
0, NULL);
setDomainIncrement(obj1, view_struct, currDomain, delFlag);
WlzFreeObj( obj );
WlzFreeObj( obj1 );
}
WlzFreePolyDmn(tabletPoly);
tabletPoly = NULL;
}
}
else {
canvas_2D_painting_cb(w, client_data, call_data);
}
break;
}
break;
case TabletMotionNotify:
if( tabletDrawingFlag ){
if( cbs->event->xmotion.state & (Button1Mask|Button2Mask) ){
/* if buttons 1 or 2 pressed then set next point */
TabletPolyNextPoint(cbs->event->xmotion.x, cbs->event->xmotion.y);
}
else {
/* rubber band from last point */
/* don't need this since the user is looking at the tablet */
}
}
else {
canvas_2D_painting_cb(w, client_data, call_data);
}
break;
default:
break;
}
return;
}
