/*!
* \return Woolz error code.
* \ingroup WlzBoundary
* \brief decomposes a boundary into it's component polygons.
* \param bndObj Given boundary.
* \param dstNumObjs Destination pointer for the number of polygons.
* \param dstObjArray Destination pointer for the array of polygons.
*/
WlzErrorNum WlzBoundaryToPolyObjArray(
WlzObject *bndObj,
int *dstNumObjs,
WlzObject ***dstObjArray)
{
WlzErrorNum errNum=WLZ_ERR_NONE;
WlzDomain domain;
WlzValues values;
WlzObject *obj, **objs;
WlzPolygonDomain **polyArray;
int i, numPolys;
/* check inputs */
if( bndObj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else if((dstNumObjs == NULL) || (dstObjArray == NULL)){
errNum = WLZ_ERR_PARAM_NULL;
}
else {
/* generate array of poly domains */
errNum = WlzBoundObjToPolyDomArray(bndObj, &numPolys, &polyArray);
}
/* convert to polygon objects */
if( errNum == WLZ_ERR_NONE ){
if((objs = (WlzObject **) AlcMalloc(sizeof(WlzObject *)*numPolys)) == NULL){
errNum = WLZ_ERR_MEM_ALLOC;
for(i=0; i < numPolys; i++){
WlzFreePolyDmn(polyArray[i]);
}
AlcFree(polyArray);
numPolys = 0;
}
else {
for(i=0; i < numPolys; i++){
domain.poly = polyArray[i];
values.core = NULL;
obj = WlzMakeMain(WLZ_2D_POLYGON, domain, values,
NULL, NULL, &errNum);
objs[i] = WlzAssignObject(obj, NULL);
WlzFreePolyDmn(polyArray[i]);
}
AlcFree(polyArray);
}
}
*dstNumObjs = numPolys;
*dstObjArray = objs;
return errNum;
}
void MAPaintTabletQuit(
ThreeDViewStruct *view_struct)
{
/* do nothing if tablet NULL */
if( !tablet ){
return;
}
/* stop the tablet */
TabletStop(tablet);
/* remove it as an input source */
XtRemoveInput(tabletInputId);
/* close it */
TabletClose(tablet);
tablet = NULL;
/* clear the global polyline */
if( tabletPoly ){
WlzFreePolyDmn(tabletPoly);
tabletPoly = NULL;
}
return;
}
/*!
* \ingroup WlzAllocation
* \brief Recursively free a boundary list.
*
* \return Error number, values: WLZ_ERR_NONE and from WlzUnlink().
* \param b Boundary list structure to be freed (note this will call WlzFreeBoundList recursively).
* \par Source:
* WlzFreeSpace.c
*/
WlzErrorNum WlzFreeBoundList(WlzBoundList *b)
{
WlzErrorNum errNum = WLZ_ERR_NONE;
/* check the object pointer and linkcount */
if (b == NULL){
return( WLZ_ERR_NONE );
}
if( WlzUnlink(&(b->linkcount), &errNum) ){
errNum |= WlzFreePolyDmn(b->poly);
errNum |= WlzFreeBoundList(b->next);
errNum |= WlzFreeBoundList(b->down);
AlcFree((void *) b);
}
return( errNum );
}
static void TabletPolyNextPoint(
int x,
int y)
{
int lastVtx;
WlzPolygonDomain *tmpPoly;
/* create the polygon if required */
if( tabletPoly == NULL ){
tabletPoly = WlzMakePolygonDomain(WLZ_POLYGON_INT,
0, NULL, 256, 1, NULL);
tabletPoly->vtx[0].vtX = x;
tabletPoly->vtx[0].vtY = y;
tabletPoly->nvertices = 1;
return;
}
/* check if this point differs from the last */
lastVtx = tabletPoly->nvertices;
if((tabletPoly->vtx[lastVtx-1].vtX == x) &&
(tabletPoly->vtx[lastVtx-1].vtY == y)){
return;
}
/* check if more points needed */
if( lastVtx >= tabletPoly->maxvertices ){
tmpPoly = WlzMakePolygonDomain(WLZ_POLYGON_INT, lastVtx,
tabletPoly->vtx,
lastVtx + 256, 1, NULL);
WlzFreePolyDmn(tabletPoly);
tabletPoly = tmpPoly;
}
/* add the next point */
tabletPoly->vtx[lastVtx].vtX = x;
tabletPoly->vtx[lastVtx].vtY = y;
tabletPoly->nvertices++;
return;
}
/*!
* \return Woolz error code.
* \ingroup WlzDomainOps
* \brief Creates a new boundary list containing only the boundaries
* in the given bounary list who's polygons intersect the given
* pixel domain.
* \param gBnd Given boundary list pointer.
* \param gDom Given pixel domain.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzBoundList *WlzDomFill3DDoBound2D(
WlzBoundList *gBnd,
WlzDomain gDom,
WlzErrorNum *dstErr)
{
WlzBoundList *rBnd = NULL,
*pBnd = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
while(gBnd)
{
int isn = 0;
WlzPolygonDomain *gPly;
if((gPly = gBnd->poly) != NULL)
{
int i;
WlzIVertex2 *vtx;
vtx = gPly->vtx;
for(i = 0; i < gPly->nvertices; ++i)
{
isn = WlzInsideDomain2D(gDom.i, vtx[i].vtY, vtx[i].vtX, NULL);
if(isn)
{
break;
}
}
}
if(isn)
{
WlzPolygonDomain *nPly;
WlzBoundList *nBnd = NULL;
/* Copy Boundary. */
nPly = WlzMakePolygonDomain(gPly->type, gPly->nvertices, gPly->vtx,
gPly->maxvertices, 1, &errNum);
if(nPly)
{
nBnd = WlzMakeBoundList(gBnd->type, gBnd->wrap, nPly, &errNum);
if(rBnd == NULL)
{
rBnd = nBnd;
}
if(pBnd)
{
pBnd->next = nBnd;
}
pBnd = nBnd;
}
if((nBnd == NULL) && nPly)
{
(void )WlzFreePolyDmn(nPly);
}
/* Do down boundaries. */
if((errNum == WLZ_ERR_NONE) && (gBnd->down != NULL))
{
nBnd->down = WlzDomFill3DDoBound2D(gBnd->down, gDom, dstErr);
if(nBnd->down)
{
nBnd->down->up = nBnd;
}
}
}
gBnd = gBnd->next;
}
if(dstErr)
{
*dstErr = errNum;
}
return(rBnd);
}
/*!
* \ingroup WlzAllocation
* \brief Free space allocated to a woolz object.
*
* \return Error number, values: WLZ_ERR_NONE, WLZ_ERR_MEM_FREE
* \param obj Object to be freed.
* \par Source:
* WlzFreeSpace.c
*/
WlzErrorNum WlzFreeObj(WlzObject *obj)
{
int i;
WlzCompoundArray *ca = (WlzCompoundArray *) obj;
WlzErrorNum errNum = WLZ_ERR_NONE;
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_FN|WLZ_DBG_LVL_1),
("WlzFreeObj FE %p\n",
obj));
/* check the object pointer and linkcount */
if (obj == NULL){
return( WLZ_ERR_NONE );
}
if( WlzUnlink(&(obj->linkcount), &errNum) ){ /* Check linkcount */
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_2D_DOMAINOBJ "
"%p %d %p %d %p\n",
obj, (obj->domain.i),
(obj->domain.i?obj->domain.i->linkcount: 0),
(obj->values.core),
((obj->values.core)? obj->values.core->linkcount: 0),
(obj->plist)));
errNum = WlzFreeDomain(obj->domain);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL)) {
if(WlzGreyTableIsTiled(obj->values.core->type) == WLZ_GREY_TAB_TILED) {
errNum = WlzFreeTiledValues(obj->values.t);
}
else {
errNum = WlzFreeValueTb(obj->values.v);
}
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreePropertyList(obj->plist);
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_3D_DOMAINOBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_3D_DOMAINOBJ %p, "
"%d %p %d %p\n",
obj, obj->domain.i,
(obj->domain.p? obj->domain.p->linkcount: 0),
obj->values.core,
(obj->values.core? obj->values.core->linkcount: 0),
obj->plist));
errNum = WlzFreePlaneDomain(obj->domain.p);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL)){
if(WlzGreyTableIsTiled(obj->values.core->type) == WLZ_GREY_TAB_TILED) {
errNum = WlzFreeTiledValues(obj->values.t);
}
else {
errNum = WlzFreeVoxelValueTb(obj->values.vox);
}
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreePropertyList(obj->plist);
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_TRANS_OBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_TRANS_OBJ %p, "
"%d %p %d %p\n",
obj, obj->domain.t,
((obj->domain.t)?(obj->domain.t)->linkcount: 0),
obj->values.obj,
((obj->values.obj)?(obj->values.obj)->linkcount: 0),
obj->plist));
if( WlzFreeAffineTransform(obj->domain.t) ||
WlzFreeObj(obj->values.obj) ||
WlzFreePropertyList(obj->plist) ||
WlzFreeObj(obj->assoc) ){
errNum = WLZ_ERR_MEM_FREE;
}
break;
case WLZ_2D_POLYGON:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_2D_POLYGON %p\n",
obj, obj->domain.poly));
errNum = WlzFreePolyDmn(obj->domain.poly);
break;
case WLZ_BOUNDLIST:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_BOUNDLIST %p\n",
obj, obj->domain.b));
errNum = WlzFreeBoundList(obj->domain.b);
break;
case WLZ_CONTOUR:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CONTOUR %p\n",
obj, obj->domain.ctr));
errNum = WlzFreeContour(obj->domain.ctr);
break;
case WLZ_CONV_HULL:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CONV_HULL %p %p\n",
obj, obj->domain.core, obj->values.core));
if(obj->domain.core) {
switch(obj->domain.core->type) {
case WLZ_CONVHULL_DOMAIN_2D:
errNum = WlzFreeConvexHullDomain2(obj->domain.cvh2);
break;
case WLZ_CONVHULL_DOMAIN_3D:
errNum = WlzFreeConvexHullDomain3(obj->domain.cvh3);
break;
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
break;
case WLZ_CMESH_2D:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CMESH_2D %p, "
"%d %p %d %p\n",
obj, obj->domain.cm2,
((obj->domain.cm2)? (obj->domain.cm2)->linkcount: 0),
obj->values.x,
((obj->values.x)? (obj->values.x)->linkcount: 0),
obj->plist));
errNum = WlzCMeshFree2D(obj->domain.cm2);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreeIndexedValues(obj->values.x);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_CMESH_2D5:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CMESH_2D5 %p, "
"%d %p %d %p\n",
obj, obj->domain.cm2d5,
((obj->domain.cm2d5)? (obj->domain.cm2d5)->linkcount: 0),
obj->values.x,
((obj->values.x)? (obj->values.x)->linkcount: 0),
obj->plist));
errNum = WlzCMeshFree2D5(obj->domain.cm2d5);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreeIndexedValues(obj->values.x);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_CMESH_3D:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CMESH_3D %p, "
"%d %p %d %p\n",
obj, obj->domain.cm3,
((obj->domain.cm3)?(obj->domain.cm3)->linkcount: 0),
obj->values.x,
((obj->values.x)?(obj->values.x)->linkcount: 0),
obj->plist));
errNum = WlzCMeshFree3D(obj->domain.cm3);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreeIndexedValues(obj->values.x);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_POINTS:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_POINTS %p\n",
obj, obj->domain.pts));
errNum = WlzFreeDomain(obj->domain);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreePointValues(obj->values.pts);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_HISTOGRAM:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CONV_HULL %p\n",
obj, obj->domain.hist));
errNum = WlzFreeDomain(obj->domain);
break;
case WLZ_RECTANGLE:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_RECTANGLE %p\n",
obj, obj->domain.r));
errNum = WlzFreeDomain(obj->domain);
break;
case WLZ_AFFINE_TRANS:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_AFFINE_TRANS\n",
obj));
errNum = WlzFreeAffineTransform(obj->domain.t);
break;
case WLZ_LUT:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_LUT\n",
obj));
errNum = WlzFreeDomain(obj->domain);
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzFreeLUTValues(obj->values);
}
break;
case WLZ_COMPOUND_ARR_1:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_COMPOUND_ARR_1\n",
ca));
for (i=0; i<ca->n; i++){
if( WlzFreeObj(ca->o[i]) != WLZ_ERR_NONE ){
errNum = WLZ_ERR_MEM_FREE;
}
}
break;
case WLZ_COMPOUND_ARR_2:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_COMPOUND_ARR_2\n",
ca));
for (i=0; i<ca->n; i++){
if( WlzFreeObj(ca->o[i]) != WLZ_ERR_NONE ){
errNum = WLZ_ERR_MEM_FREE;
}
}
break;
case WLZ_PROPERTY_OBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_PROPERTY_OBJ\n",
obj));
errNum = WlzFreePropertyList(obj->plist);
break;
case WLZ_EMPTY_OBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_EMPTY_OBJ\n",
obj));
break;
default:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p %d\n",
obj, (int )(obj->type)));
errNum = WLZ_ERR_OBJECT_TYPE;
break;
} /* End of switch */
AlcFree((void *) obj);
}
return( errNum );
}
/*!
* \ingroup WlzAllocation
* \brief Free a planedomain
*
* \return Error number, values: WLZ_ERR_NONE and errors from
WlzFreeAffineTransform(), WlzFreeDomain(), WlzFreeBoundList(),
WlzFreePolyDmn().
* \param planedm Pointer to planedomain structure to be freed.
* \par Source:
* WlzFreeSpace.c
*/
WlzErrorNum WlzFreePlaneDomain(WlzPlaneDomain *planedm)
{
WlzDomain *domains;
int nplanes;
WlzErrorNum errNum = WLZ_ERR_NONE;
/* check the object pointer and linkcount */
if (planedm == NULL){
return( WLZ_ERR_NONE );
}
if( WlzUnlink(&(planedm->linkcount), &errNum) ){
nplanes = planedm->lastpl - planedm->plane1 + 1;
domains = planedm->domains;
switch( planedm->type ){
case WLZ_PLANEDOMAIN_DOMAIN:
while( nplanes-- ){
errNum |= WlzFreeDomain( *domains );
domains++;
}
break;
case WLZ_PLANEDOMAIN_POLYGON:
while( nplanes-- ){
errNum |= WlzFreePolyDmn((*domains).poly);
domains++;
}
break;
case WLZ_PLANEDOMAIN_BOUNDLIST:
while( nplanes-- ){
errNum |= WlzFreeBoundList((*domains).b);
domains++;
}
break;
case WLZ_PLANEDOMAIN_HISTOGRAM:
while( nplanes-- ){
errNum |= WlzFreeDomain(*domains);
domains++;
}
break;
case WLZ_PLANEDOMAIN_AFFINE:
while( nplanes-- ){
errNum |= WlzFreeAffineTransform((*domains).t);
domains++;
}
break;
default:
return( WLZ_ERR_PLANEDOMAIN_TYPE );
}
AlcFree((void *) planedm->domains);
AlcFree((void *) planedm);
}
return( errNum );
}
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;
}
void MAPaintTabletInit(
ThreeDViewStruct *view_struct)
{
TabletEvent event;
int quitFlag;
Widget dialog;
XmString text, title;
WlzDVertex2 tabVtxs[2], wlzVtxs[2];
Widget slider;
WlzAffineTransform *trans;
/* ignore if already open */
if( tablet ){
return;
}
/* open the tablet */
if( (tablet = TabletOpen(WACOM_IV_TABLET_TYPE,
"/dev/term/b", NULL)) == NULL ){
HGU_XmUserError(globals.topl,
"Open Wacom Tablet:\n"
" Failed to open the tablet, please check\n"
" the tablet is connected to serial line b\n"
" and switched on, then try again.",
XmDIALOG_FULL_APPLICATION_MODAL);
return;
}
/* set tilt mode and start the tablet */
TabletSetMode(tablet, TABLET_TILTMODE_MASK);
tablet->cntrlMode2 |= TABLET_CORRECT_TILT_MASK;
tablet->cntrlMode2 |= TABLET_TRANSFORM_MASK;
TabletStart(tablet);
/* if the tablet needs the coordinates set then do so here */
if( !view_struct->tablet_initialised ){
/* get first coordinate */
/* put up an application modal dialog to request first
coordinate */
dialog = XmCreateMessageDialog(view_struct->canvas,
"MAPaint Message", NULL, 0);
XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_OK_BUTTON));
XtSetSensitive(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON),
False);
text = XmStringCreateLtoR("Input tablet reference point 1 please",
XmSTRING_DEFAULT_CHARSET);
title = XmStringCreateSimple("MAPaint Tablet Message");
XtVaSetValues(dialog,
XmNmessageString, text,
XmNdialogTitle, title,
XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
NULL);
XmStringFree( text );
XmStringFree( title );
/* popup widget and process events */
XtManageChild( dialog );
XSync(XtDisplay(view_struct->canvas), False);
quitFlag = 0;
while( quitFlag < 100 ){
if((XtAppPending(globals.app_con) > 0) ){
XtAppProcessEvent(globals.app_con, XtIMAll);
}
else {
XSync(XtDisplay(view_struct->canvas), False);
usleep(1000);
quitFlag++;
}
}
quitFlag = 0;
while( !quitFlag ){
if( TabletNextEvent(tablet, &event) == TABLET_ERR_NONE ){
if(event.buttonPressed &&
((event.buttons == 1) || (event.buttons == 3))){
tabVtxs[0].vtX = event.x;
tabVtxs[0].vtY = event.y;
quitFlag = 1;
XBell(XtDisplay(view_struct->canvas), 100);
XFlush(XtDisplay(view_struct->canvas));
}
}
else {
TabletClose(tablet);
tablet = NULL;
XtDestroyWidget(dialog);
return;
}
}
/* get second coordinate */
text = XmStringCreateLtoR("Input tablet reference point 2 please",
XmSTRING_DEFAULT_CHARSET);
XtVaSetValues(dialog,
XmNmessageString, text,
NULL);
XmStringFree( text );
/* popup widget and process events */
XtManageChild( dialog );
XSync(XtDisplay(view_struct->canvas), False);
while( (XtAppPending(globals.app_con) > 0) ){
XtAppProcessEvent(globals.app_con, XtIMAll);
XSync(XtDisplay(view_struct->canvas), False);
}
quitFlag = 0;
sleep(1);
TabletClearEvents(tablet);
while( !quitFlag ){
if( TabletNextEvent(tablet, &event) == TABLET_ERR_NONE ){
if(event.buttonPressed &&
((event.buttons == 1) || (event.buttons == 3))){
tabVtxs[1].vtX = event.x;
tabVtxs[1].vtY = event.y;
quitFlag = 1;
XBell(XtDisplay(view_struct->canvas), 100);
XFlush(XtDisplay(view_struct->canvas));
}
}
else {
TabletClose(tablet);
XtDestroyWidget(dialog);
tablet = NULL;
return;
}
}
TabletStop(tablet);
XtDestroyWidget(dialog);
usleep(10000);
TabletClearEvents(tablet);
/* set the reference coordinates */
view_struct->ref1.vtX = tabVtxs[0].vtX;
view_struct->ref1.vtY = tabVtxs[0].vtY;
view_struct->ref2.vtX = tabVtxs[1].vtX;
view_struct->ref2.vtY = tabVtxs[1].vtY;
}
else {
tabVtxs[0].vtX = view_struct->ref1.vtX;
tabVtxs[0].vtY = view_struct->ref1.vtY;
tabVtxs[1].vtX = view_struct->ref2.vtX;
tabVtxs[1].vtY = view_struct->ref2.vtY;
}
/* set tablet transform parameters */
if((slider = XtNameToWidget(tablet_controls, "*.x1")) )
{
wlzVtxs[0].vtX = HGU_XmGetSliderValue(slider);
}
if((slider = XtNameToWidget(tablet_controls, "*.y1")) )
{
wlzVtxs[0].vtY = HGU_XmGetSliderValue(slider);
}
if((slider = XtNameToWidget(tablet_controls, "*.x2")) )
{
wlzVtxs[1].vtX = HGU_XmGetSliderValue(slider);
}
if( (slider = XtNameToWidget(tablet_controls, "*.y2")))
{
wlzVtxs[1].vtY = HGU_XmGetSliderValue(slider);
}
trans = WlzAffineTransformLSq2D(2, tabVtxs, 2, wlzVtxs, 0, NULL,
WLZ_TRANSFORM_2D_NOSHEAR, NULL);
tablet->xTrans[0] = trans->mat[0][0];
tablet->xTrans[1] = trans->mat[0][1];
tablet->xTrans[2] = trans->mat[0][2];
tablet->yTrans[0] = trans->mat[1][0];
tablet->yTrans[1] = trans->mat[1][1];
tablet->yTrans[2] = trans->mat[1][2];
WlzFreeAffineTransform(trans);
view_struct->tablet_initialised = 1;
/* initialise the globals */
modifiers = 0;
tabletDrawingFlag = 0;
quitDrawingTrigger = 0;
if( tabletPoly ){
WlzFreePolyDmn(tabletPoly);
tabletPoly = NULL;
}
/* now add the tablet stream as an event input source */
TabletStart(tablet);
TabletClearEvents(tablet);
tabletInputId = XtAppAddInput(globals.app_con, tablet->fd,
(XtPointer) XtInputReadMask,
tabletInputProc, (XtPointer) view_struct);
return;
}
void conformal_input_cb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
ThreeDViewStruct *view_struct = (ThreeDViewStruct *) client_data;
WlzThreeDViewStruct *wlzViewStr= view_struct->wlzViewStr;
XmAnyCallbackStruct *cbs = (XmAnyCallbackStruct *) call_data;
int x, y;
int i;
WlzPolygonDomain *startPoly;
WlzFVertex2 fpVtx, *fvtxs;
WlzObject *polygon;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* switch on event type */
switch( cbs->event->type ){
case ButtonPress:
switch( cbs->event->xbutton.button ){
case Button1:
specialTriggered = 1;
/* get the polyline, rescale as required */
fpVtx.vtX = cbs->event->xbutton.x;
fpVtx.vtY = cbs->event->xbutton.y;
fvtxs = &fpVtx;
startPoly = WlzAssignPolygonDomain(
WlzMakePolygonDomain(WLZ_POLYGON_FLOAT, 1,
(WlzIVertex2 *) fvtxs,
1, 1, NULL), &errNum);
if( confPoly ){
WlzFreePolyDmn(confPoly);
}
globals.paint_action_quit_flag = 0;
confPoly = HGU_XGetPolyDomain(XtDisplay(view_struct->canvas),
XtWindow(view_struct->canvas),
0, NULL, startPoly);
WlzFreePolyDmn(startPoly);
if( confPoly == NULL ){
break;
}
/* convert to an 8-connected polyline */
if((polygon = WlzPolyTo8Polygon(confPoly, 1, &errNum))){
WlzFreePolyDmn(confPoly);
if((confPoly = WlzAssignPolygonDomain(
WlzMakePolygonDomain(WLZ_POLYGON_INT,
polygon->domain.poly->nvertices,
polygon->domain.poly->vtx,
polygon->domain.poly->nvertices,
1, &errNum), NULL))){
confPoly->type = WLZ_POLYGON_FLOAT;
fvtxs = (WlzFVertex2 *) confPoly->vtx;
for(i=0; i < confPoly->nvertices; i++){
fvtxs[i].vtX = (float) confPoly->vtx[i].vtX;
fvtxs[i].vtY = (float) confPoly->vtx[i].vtY;
}
}
}
/* determine the conformal approximate coordinate mesh */
conformalCalculateMeshCb(w, client_data, call_data);
/* display the polyline and mesh */
conformalDisplayPolysCb(w, client_data, call_data);
break;
case Button2:
break;
case Button3: /* unused */
default:
break;
}
break;
case ButtonRelease:
switch( cbs->event->xbutton.button ){
case Button1:
break;
case Button2:
x = cbs->event->xbutton.x / wlzViewStr->scale;
y = cbs->event->xbutton.y / wlzViewStr->scale;
display_pointer_feedback_information(view_struct, x, y);
break;
case Button3:
/* check if have been drawing */
if( specialTriggered ){
specialTriggered = 0;
break;
}
/* revert to normal mode */
view_struct->noPaintingFlag = 0;
view_struct->titleStr = "Section view";
set_view_dialog_title(view_struct->dialog,
wlzViewStr->theta,
wlzViewStr->phi);
/* set sensitivities */
XtSetSensitive(view_struct->controls, True);
XtSetSensitive(view_struct->slider, True);
setControlButtonsSensitive(view_struct, True);
/* swap the callbacks to special mode */
XtRemoveCallback(view_struct->canvas, XmNexposeCallback,
conformalDisplayPolysCb, view_struct);
XtRemoveCallback(view_struct->canvas, XmNinputCallback,
conformal_input_cb, client_data);
XtAddCallback(view_struct->canvas, XmNinputCallback,
canvas_input_cb, client_data);
/* clear the polyline */
if( confPoly ){
WlzFreePolyDmn(confPoly);
confPoly = NULL;
}
break;
default:
break;
}
break;
case MotionNotify:
if( cbs->event->xmotion.state & Button1Mask ){
}
if( cbs->event->xmotion.state & Button2Mask )
{
x = cbs->event->xmotion.x / wlzViewStr->scale;
y = cbs->event->xmotion.y / wlzViewStr->scale;
display_pointer_feedback_information(view_struct, x, y);
}
break;
case KeyPress:
switch( XLookupKeysym(&(cbs->event->xkey), 0) ){
case XK_Right:
case XK_KP_Right:
case XK_f:
break;
case XK_Up:
case XK_p:
break;
case XK_Left:
case XK_KP_Left:
case XK_b:
break;
case XK_Down:
case XK_n:
break;
}
break;
default:
break;
}
if( errNum != WLZ_ERR_NONE ){
MAPaintReportWlzError(globals.topl, "conformal_input_cb", errNum);
}
return;
}
