WM_LTANNEVENT Message ( - Raster Imaging C API Help

WM_LTANNEVENT Message (

When received, the WM_LTANNEVENT message indicates that an annotation event has occurred. The message parameters contain the following information:

  1. One message is sent before the action is done. Setting the nChange field to SUCCESS_NO_CHANGE prevents the change, and cancels the "after" event. Returning SUCCESS_CHANGE allows both the change to take place, and the ‘after’ message to be sent.

  1. A second messages is sent after the action is done. The return value of this message is ignored.

LTANNEVENT_HIGHLIGHT

[27] Indicates that part or all of the annotation object (EXCEPT for the rotated ellipse, protractor, ruler, and cross product objects, which do not send this message) is about to be drawn with a highlight. This can occur due to selecting the object, changing the object using automation, or changing the object by making calls to L_AnnDefine. The lParam argument points to a variable of type pANNHILIGHT.

This message gets sent for all objects EXCEPT:

Rotated Ellipse--does not get fired if ellipse is rotated

Protractor

Ruler

Cross product

The highlight behavior can be customized by changing the ppts array. For example, if the annotation object is a rectangle, uCount will be 4 and ppts will be an array of four coordinates (client coordinates) that correspond the corners of the rectangle. Modifying the four points will change the way the rectangle is highlighted.

This message is also useful for updating information about an annotation in real time.

For example, if you are doing a resize/rotate on a rectangle, you can use this event to display the size and angle as it changes.

LTANNEVENT_MENUFIRST

[256]

LTANNEVENT_MENULAST

[511] User defined menu. Refer to the Comments section below.

Comments:

For all notifications in the LTANNEVENT_MENUFIRST to LTANNEVENT_MENULAST range, lParam is the handle to the selected object or the automation object. The process works as follows:

1. When the right mouse button is clicked in design mode, the automation menu is displayed. Before it is displayed however, the WM_LTANNEVENT message is sent with the LTANNEVENT_MENU notification.
2. At this point the menu handle can be changed and menu items can be added to it. The command IDs must be between LTANNEVENT_MENUFIRST and LTANNEVENT_MENULAST. After the WM_LTANNEVENT message is processed, the modified menu is displayed.
3. If a standard automation menu item is selected (Undo, Delete, Copy, etc.), the command is processed automatically, and the LTANNEVENT_AUTOITEMCHANGED or LTANNEVENT_AUTOCHANGED notifications are sent.
4. If a user defined menu item is selected, the WM_LTANNEVENT message is sent with wParam containing the selected command ID. The lParam contains the handle to the object(s) selected. LParam can have the following values:
  a. The handle to the automation object.
    In one case no objects are selected and you should change some properties of the automation object.
    In the other case one or more objects are selected and you should change the selected object(s).
  b. The handle to a selected object. In this case you should change the selected object.

You can add submenus by calling CreatePopupMenu and AddMenu. Menu items are generally different, depending on the object selected.

The default automation menus send LTANNEVENT_AUTOITEMCHANGED and LTANNEVENT_AUTOCHANGED notifications. If your program relies on them, make sure you send LTANNEVENT_AUTOITEMCHANGED to every object with changed properties, and LTANNEVENT_AUTOCHANGED to every object with changed coordinates.

If you create a Popup menu and add it to the automation menu, it will be destroyed automatically when the window goes away. Do not destroy the menu after adding it to the automation menu.

Example

The following example is a function that can be used to display all the annotation events
To use this, call the function
L_VOID DebugLtAnnEvent(int nID, LPARAM lParam)
in your annotation program when processing the WM_LTANNEVENT message.
Pass wParam for the first argument, and lParam for the second argument.

L_TCHAR *aChangeToString[ANNCHANGE_LAST]; 
L_TCHAR *annGetObjectString(L_UINT uObjectType) 
{ 
   L_TCHAR *pszType = TEXT("Unknown"); 
   switch(uObjectType) 
   { 
      case ANNOBJECT_CONTAINER: 
      pszType = TEXT("ANNOBJECT_CONTAINER"); 
      break; 
      case ANNOBJECT_POINTER: 
      pszType = TEXT("ANNOBJECT_POINTER"); 
      break; 
      case ANNOBJECT_AUDIO: 
      pszType = TEXT("ANNOBJECT_AUDIO"); 
      break; 
      case ANNOBJECT_BUTTON: 
      pszType = TEXT("ANNOBJECT_BUTTON"); 
      break; 
      case ANNOBJECT_ELLIPSE: 
      pszType = TEXT("ANNOBJECT_ELLIPSE"); 
      break; 
      case ANNOBJECT_FREEHAND: 
      pszType = TEXT("ANNOBJECT_FREEHAND"); 
      break; 
      case ANNOBJECT_HILITE: 
      pszType = TEXT("ANNOBJECT_HILITE"); 
      break; 
      case ANNOBJECT_HOTSPOT: 
      pszType = TEXT("ANNOBJECT_HOTSPOT"); 
      break; 
      case ANNOBJECT_LINE: 
      pszType = TEXT("ANNOBJECT_LINE"); 
      break; 
      case ANNOBJECT_NOTE: 
      pszType = TEXT("ANNOBJECT_NOTE"); 
      break; 
      case ANNOBJECT_POLYGON: 
      pszType = TEXT("ANNOBJECT_POLYGON"); 
      break; 
      case ANNOBJECT_POLYLINE: 
      pszType = TEXT("ANNOBJECT_POLYLINE"); 
      break; 
      case ANNOBJECT_RECT: 
      pszType = TEXT("ANNOBJECT_RECT"); 
      break; 
      case ANNOBJECT_REDACT: 
      pszType = TEXT("ANNOBJECT_REDACT"); 
      break; 
      case ANNOBJECT_STAMP: 
      pszType = TEXT("ANNOBJECT_STAMP"); 
      break; 
      case ANNOBJECT_TEXT: 
      pszType = TEXT("ANNOBJECT_TEXT"); 
      break; 
      case ANNOBJECT_AUTOMATION: 
      pszType = TEXT("ANNOBJECT_AUTOMATION"); 
      break; 
      case ANNOBJECT_RULER: 
      pszType = TEXT("ANNOBJECT_RULER"); 
      break; 
      case ANNOBJECT_CROSSPRODUCT: 
      pszType = TEXT("ANNOBJECT_CROSSPRODUCT"); 
      break; 
      case ANNOBJECT_POINT: 
      pszType = TEXT("ANNOBJECT_POINT"); 
      break; 
      case ANNOBJECT_PROTRACTOR: 
      pszType = TEXT("ANNOBJECT_PROTRACTOR"); 
      break; 
      case ANNOBJECT_VIDEO: 
      pszType = TEXT("ANNOBJECT_VIDEO"); 
      break; 
      case ANNOBJECT_PUSHPIN: 
      pszType = TEXT("ANNOBJECT_PUSHPIN"); 
      break; 
      case ANNOBJECT_FREEHANDHOTSPOT: 
      pszType = TEXT("ANNOBJECT_FREEHANDHOTSPOT"); 
      break; 
      case ANNOBJECT_CURVE: 
      pszType = TEXT("ANNOBJECT_CURVE"); 
      break; 
      case ANNOBJECT_CURVECLOSED: 
      pszType = TEXT("ANNOBJECT_CURVECLOSED"); 
      break; 
      case ANNOBJECT_ENCRYPT: 
      pszType = TEXT("ANNOBJECT_ENCRYPT"); 
      break; 
   } 
   return pszType; 
} 
L_VOID LoadChangeToStringTable() 
{ 
   aChangeToString[ANNCHANGE_TAG]   = TEXT("ANNCHANGE_TAG"); 
   aChangeToString[ANNCHANGE_VISIBLE]   = TEXT("ANNCHANGE_VISIBLE"); 
   aChangeToString[ANNCHANGE_SELECTED]    = TEXT("ANNCHANGE_SELECTED"); 
   aChangeToString[ANNCHANGE_FONT_BOLD]   = TEXT("ANNCHANGE_FONT_BOLD"); 
   aChangeToString[ANNCHANGE_FONT_ITALIC]   = TEXT("ANNCHANGE_FONT_ITALIC"); 
   aChangeToString[ANNCHANGE_FONT_STRIKETHROUGH]   = TEXT("ANNCHANGE_FONT_STRIKETHROUGH"); 
   aChangeToString[ANNCHANGE_FONT_UNDERLINE]   = TEXT("ANNCHANGE_FONT_UNDERLINE"); 
   aChangeToString[ANNCHANGE_LINEWIDTH]   = TEXT("ANNCHANGE_LINEWIDTH"); 
   aChangeToString[ANNCHANGE_LINESTYLE]    = TEXT("ANNCHANGE_LINESTYLE"); 
   aChangeToString[ANNCHANGE_FILLPATTERN]   = TEXT("ANNCHANGE_FILLPATTERN"); 
   aChangeToString[ANNCHANGE_FILLMODE]   = TEXT("ANNCHANGE_FILLMODE"); 
   aChangeToString[ANNCHANGE_POLYFILLMODE]   = TEXT("ANNCHANGE_POLYFILLMODE"); 
   aChangeToString[ANNCHANGE_FONT_SIZE]   = TEXT("ANNCHANGE_FONT_SIZE"); 
   aChangeToString[ANNCHANGE_FORECOLOR]   = TEXT("ANNCHANGE_FORECOLOR"); 
   aChangeToString[ANNCHANGE_BACKCOLOR]   = TEXT("ANNCHANGE_BACKCOLOR"); 
   aChangeToString[ANNCHANGE_TRANSPARENT_COLOR]   = TEXT("ANNCHANGE_TRANSPARENT_COLOR"); 
   aChangeToString[ANNCHANGE_TRANSPARENT]   = TEXT("ANNCHANGE_TRANSPARENT"); 
   aChangeToString[ANNCHANGE_FONT_NAME]   = TEXT("ANNCHANGE_FONT_NAME"); 
   aChangeToString[ANNCHANGE_TEXT]    = TEXT("ANNCHANGE_TEXT"); 
   aChangeToString[ANNCHANGE_ROP2]   = TEXT("ANNCHANGE_ROP2"); 
   aChangeToString[ANNCHANGE_BITMAP]   = TEXT("ANNCHANGE_BITMAP"); 
   aChangeToString[ANNCHANGE_BITMAP2]    = TEXT("ANNCHANGE_BITMAP2"); 
   aChangeToString[ANNCHANGE_METAFILE]   = TEXT("ANNCHANGE_METAFILE"); 
   aChangeToString[ANNCHANGE_METAFILE2]   = TEXT("ANNCHANGE_METAFILE2"); 
   aChangeToString[ANNCHANGE_NAME_FORECOLOR]   = TEXT("ANNCHANGE_NAME_FORECOLOR"); 
   aChangeToString[ANNCHANGE_NAME_BACKCOLOR]   = TEXT("ANNCHANGE_NAME_BACKCOLOR"); 
   aChangeToString[ANNCHANGE_NAME_SHOWNAME]   = TEXT("ANNCHANGE_NAME_SHOWNAME"); 
   aChangeToString[ANNCHANGE_NAME_OFFSET]   = TEXT("ANNCHANGE_NAME_OFFSET"); 
   aChangeToString[ANNCHANGE_NAME_RESTRICT]   = TEXT("ANNCHANGE_NAME_RESTRICT"); 
   aChangeToString[ANNCHANGE_NAME_BACKTRANSPARENT]   = TEXT("ANNCHANGE_NAME_BACKTRANSPARENT"); 
   aChangeToString[ANNCHANGE_NAME_TEXT]   = TEXT("ANNCHANGE_NAME_TEXT"); 
   aChangeToString[ANNCHANGE_NAME_FONT_NAME]   = TEXT("ANNCHANGE_NAME_FONT_NAME"); 
   aChangeToString[ANNCHANGE_NAME_FONT_BOLD]   = TEXT("ANNCHANGE_NAME_FONT_BOLD"); 
   aChangeToString[ANNCHANGE_NAME_FONT_ITALIC]   = TEXT("ANNCHANGE_NAME_FONT_ITALIC"); 
   aChangeToString[ANNCHANGE_NAME_FONT_STRIKEOUT]   = TEXT("ANNCHANGE_NAME_FONT_STRIKEOUT"); 
   aChangeToString[ANNCHANGE_NAME_FONT_UNDERLINE]   = TEXT("ANNCHANGE_NAME_FONT_UNDERLINE"); 
   aChangeToString[ANNCHANGE_NAME_FONT_SIZE]   = TEXT("ANNCHANGE_NAME_FONT_SIZE"); 
   aChangeToString[ANNCHANGE_POINT_USE_BITMAP]   = TEXT("ANNCHANGE_POINT_USE_BITMAP"); 
   aChangeToString[ANNCHANGE_POINT_RADIUS]   = TEXT("ANNCHANGE_POINT_RADIUS"); 
   aChangeToString[ANNCHANGE_POINT_BORDER_COLOR]   = TEXT("ANNCHANGE_POINT_BORDER_COLOR"); 
   aChangeToString[ANNCHANGE_POINT_FILL_COLOR]   = TEXT("ANNCHANGE_POINT_FILL_COLOR"); 
   aChangeToString[ANNCHANGE_POINT_TRANSPARENT_FILL]   = TEXT("ANNCHANGE_POINT_TRANSPARENT_FILL"); 
   aChangeToString[ANNCHANGE_POINT_FIXED_SIZE]   = TEXT("ANNCHANGE_POINT_FIXED_SIZE"); 
   aChangeToString[ANNCHANGE_SHOW_DEFAULT_HANDLES]   = TEXT("ANNCHANGE_SHOW_DEFAULT_HANDLES"); 
   aChangeToString[ANNCHANGE_GAP_DEFAULT_HANDLES]   = TEXT("ANNCHANGE_GAP_DEFAULT_HANDLES"); 
   aChangeToString[ANNCHANGE_HYPERLINK]   = TEXT("ANNCHANGE_HYPERLINK"); 
   aChangeToString[ANNCHANGE_GAUGELENGTH]   = TEXT("ANNCHANGE_GAUGELENGTH"); 
   aChangeToString[ANNCHANGE_BITMAP_DPI_X]   = TEXT("ANNCHANGE_BITMAP_DPI_X"); 
   aChangeToString[ANNCHANGE_BITMAP_DPI_Y]   = TEXT("ANNCHANGE_BITMAP_DPI_Y"); 
   aChangeToString[ANNCHANGE_RULER_UNIT]   = TEXT("ANNCHANGE_RULER_UNIT"); 
   aChangeToString[ANNCHANGE_RULER_SHOW_FLAGS]   = TEXT("ANNCHANGE_RULER_SHOW_FLAGS"); 
   aChangeToString[ANNCHANGE_PROTRACTOR]   = TEXT("ANNCHANGE_PROTRACTOR"); 
   aChangeToString[ANNCHANGE_ENCRYPTOR_TYPE]   = TEXT("ANNCHANGE_ENCRYPTOR_TYPE"); 
   aChangeToString[ANNCHANGE_ENCRYPTOR_KEY]   = TEXT("ANNCHANGE_ENCRYPTOR_KEY"); 
   aChangeToString[ANNCHANGE_ENCRYPTOR_NEVER_ENCRYPTED]  = TEXT("ANNCHANGE_ENCRYPTOR_NEVER_ENCRYPTED"); 
   aChangeToString[ANNCHANGE_ENCRYPTOR_BITMAP]   = TEXT("ANNCHANGE_ENCRYPTOR_BITMAP"); 
   aChangeToString[ANNCHANGE_MOVE]   = TEXT("ANNCHANGE_MOVE"); 
   aChangeToString[ANNCHANGE_MOVE_POINT]   = TEXT("ANNCHANGE_MOVE_POINT"); 
   aChangeToString[ANNCHANGE_RESIZE]   = TEXT("ANNCHANGE_RESIZE"); 
   aChangeToString[ANNCHANGE_ROTATE]   = TEXT("ANNCHANGE_ROTATE"); 
   aChangeToString[ANNCHANGE_RESIZE_ROTATE]   = TEXT("ANNCHANGE_RESIZE_ROTATE"); 
   aChangeToString[ANNCHANGE_UNDO]    = TEXT("ANNCHANGE_UNDO"); 
   aChangeToString[ANNCHANGE_CUT]    = TEXT("ANNCHANGE_CUT"); 
   aChangeToString[ANNCHANGE_PASTE]   = TEXT("ANNCHANGE_PASTE"); 
   aChangeToString[ANNCHANGE_DELETE]   = TEXT("ANNCHANGE_DELETE"); 
   aChangeToString[ANNCHANGE_SELECT_ALL]   = TEXT("ANNCHANGE_SELECT_ALL"); 
   aChangeToString[ANNCHANGE_BRING_TO_FRONT]   = TEXT("ANNCHANGE_BRING_TO_FRONT"); 
   aChangeToString[ANNCHANGE_BRING_TO_BACK]    = TEXT("ANNCHANGE_BRING_TO_BACK"); 
   aChangeToString[ANNCHANGE_LOCK]                       = TEXT("ANNCHANGE_LOCK"); 
   aChangeToString[ANNCHANGE_UNLOCK]   = TEXT("ANNCHANGE_UNLOCK"); 
   aChangeToString[ANNCHANGE_LOCK_SELECTED]   = TEXT("ANNCHANGE_LOCK_SELECTED"); 
   aChangeToString[ANNCHANGE_UNLOCK_SELECTED]   = TEXT("ANNCHANGE_UNLOCK_SELECTED"); 
   aChangeToString[ANNCHANGE_INSERT]   = TEXT("ANNCHANGE_INSERT"); 
   aChangeToString[ANNCHANGE_NOTE_BACKCOLOR]    = TEXT("ANNCHANGE_NOTE_BACKCOLOR"); 
   aChangeToString[ANNCHANGE_HILITE_BACKCOLOR]   = TEXT("ANNCHANGE_HILITE_BACKCOLOR"); 
   aChangeToString[ANNCHANGE_REDACT_BACKCOLOR]   = TEXT("ANNCHANGE_REDACT_BACKCOLOR"); 
   aChangeToString[ANNCHANGE_ENCRYPT_METAFILE]   = TEXT("ANNCHANGE_ENCRYPT_METAFILE"); 
   aChangeToString[ANNCHANGE_DECRYPT_METAFILE]   = TEXT("ANNCHANGE_DECRYPT_METAFILE"); 
   aChangeToString[ANNCHANGE_HOTSPOT_METAFILE]   = TEXT("ANNCHANGE_HOTSPOT_METAFILE"); 
} 
 
L_INT DebugLtAnnEvent_AutoItemChanging(HANNOBJECT hObject, L_TCHAR szMsg[], LPARAM lParam) 
{ 
   pANNCHANGEPARAM pAnnChangeParam = (pANNCHANGEPARAM)lParam; 
   L_UINT uType; 
   L_TCHAR szTemp[200]; 
    
   L_AnnGetType(hObject, &uType); 
    
   wsprintf(szMsg, TEXT("LTANNEVENT_AUTOITEMCHANGING: uChange[%25s] "), aChangeToString[pAnnChangeParam->uChange]); 
   switch (pAnnChangeParam->uUnionType) 
   { 
      case ANNTYPE_NONE: 
      lstrcpy(szTemp, TEXT("")); 
      break; 
      case ANNTYPE_COLORREF: 
      wsprintf(szTemp, TEXT("crColor[0x%x]"), pAnnChangeParam->u.crColor); 
      break; 
       
      case ANNTYPE_UINT32: 
      wsprintf(szTemp, TEXT("uUint32[%d]"), pAnnChangeParam->u.uUint32); 
      break; 
       
      case ANNTYPE_BOOL: 
      wsprintf(szTemp, TEXT("bBool[%s]"), pAnnChangeParam->u.bBool ? TEXT("TRUE") : TEXT("FALSE")); 
      break; 
       
      case ANNTYPE_DOUBLE: 
      wsprintf(szTemp, TEXT("dDouble[%f]"), pAnnChangeParam->u.dDouble); 
      break; 
       
      case ANNTYPE_UINT: 
      wsprintf(szTemp, TEXT("uUint[%d]"), pAnnChangeParam->u.uUint); 
      break; 
       
      case ANNTYPE_LPCSTR: 
      wsprintf(szTemp, TEXT("pszString[%s]"), pAnnChangeParam->u.pszString); 
      break; 
       
      case ANNTYPE_ANNPOINT: 
      wsprintf(szTemp, TEXT("apt[%f, %f]"), pAnnChangeParam->u.apt.x, pAnnChangeParam->u.apt.y); 
      break; 
       
      case ANNTYPE_BITMAP: 
      wsprintf(szTemp, TEXT("pBitmapHandle Width[%d]  Height[%d] BitsPerPixel[%d]"), 
      pAnnChangeParam->u.pBitmapHandle->Width, 
      pAnnChangeParam->u.pBitmapHandle->Height, 
      pAnnChangeParam->u.pBitmapHandle->BitsPerPixel 
      ); 
      break; 
      case ANNTYPE_HMETAFILE: 
      wsprintf(szTemp, TEXT("hMetafile [0x%x]"), pAnnChangeParam->u.hMetafile); 
      break; 
      case ANNTYPE_RULER_UNIT: 
      { 
         L_TCHAR *pszUnit; 
         switch(pAnnChangeParam->u.AnnRulerUnit.uUnit) 
         { 
            case ANNUNIT_INCHES: 
            pszUnit = TEXT("ANNUNIT_INCHES"); 
            break; 
            case ANNUNIT_FEET : 
            pszUnit = TEXT("ANNUNIT_FEET"); 
            break; 
            case ANNUNIT_YARDS : 
            pszUnit = TEXT("ANNUNIT_YARDS"); 
            break; 
            case ANNUNIT_MICROMETERS: 
            pszUnit = TEXT("ANNUNIT_MICROMETERS"); 
            break; 
            case ANNUNIT_MILLIMETERS: 
            pszUnit = TEXT("ANNUNIT_MILLIMETERS"); 
            break; 
            case ANNUNIT_CENTIMETERS: 
            pszUnit = TEXT("ANNUNIT_CENTIMETERS"); 
            break; 
            case ANNUNIT_METERS: 
            pszUnit = TEXT("ANNUNIT_METERS"); 
            break; 
            case ANNUNIT_TWIPS: 
            pszUnit = TEXT("ANNUNIT_TWIPS"); 
            break; 
            case ANNUNIT_POINTS: 
            pszUnit = TEXT("ANNUNIT_POINTS"); 
            break; 
            case ANNUNIT_PIXELS: 
            pszUnit = TEXT("ANNUNIT_PIXELS"); 
            break; 
default: 
            pszUnit = TEXT("Unknown Type"); 
            break; 
         } 
         wsprintf(szTemp, TEXT("uUnit[%s] pAbbrev[%s] uPrecision[%d]"), 
         pszUnit, 
         pAnnChangeParam->u.AnnRulerUnit.pAbbrev ? pAnnChangeParam->u.AnnRulerUnit.pAbbrev: TEXT(""), 
         pAnnChangeParam->u.AnnRulerUnit.uPrecision 
         ); 
         break; 
      } 
      case ANNTYPE_HYPERLINK: 
      { 
         L_TCHAR *pszType; 
         switch(pAnnChangeParam->u.AnnHyperlink.uLinkType) 
         { 
            case ANNLINK_NONE: 
            pszType = TEXT("ANNLINK_NONE"); 
            break; 
            case ANNLINK_LTANNEVENT: 
            pszType = TEXT("ANNLINK_LTANNEVENT"); 
            break; 
            case ANNLINK_USERMSG: 
            pszType = TEXT("ANNLINK_USERMSG"); 
            break; 
            case ANNLINK_RUN: 
            pszType = TEXT("ANNLINK_RUN"); 
            break; 
            case ANNLINK_WEBPAGE: 
            pszType = TEXT("ANNLINK_WEBPAGE"); 
            break; 
default: 
            pszType = TEXT("Unknown Type"); 
            break; 
         } 
         wsprintf(szTemp, TEXT("uType[%s] uLinkMsg[%d] uLinkParam[%d] pLink[%s]"), 
         pszType, 
         pAnnChangeParam->u.AnnHyperlink.uLinkMsg, 
         pAnnChangeParam->u.AnnHyperlink.uLinkParam, 
         pAnnChangeParam->u.AnnHyperlink.pLinkText ? pAnnChangeParam->u.AnnHyperlink.pLinkText : TEXT("") 
         ); 
         break; 
      } 
      case ANNTYPE_PROTRACTOR: 
      { 
         L_TCHAR *pszAngleUnit; 
         switch(pAnnChangeParam->u.AnnProtractor.uAngleUnit) 
         { 
            case ANNANGLE_DEGREES: 
            pszAngleUnit = TEXT("ANNANGLE_DEGREES"); 
            break; 
            case ANNANGLE_RADIANS: 
            pszAngleUnit = TEXT("ANNANGLE_RADIANS"); 
            break; 
default: 
            pszAngleUnit = TEXT("Unknown Angle Unit"); 
            break; 
         } 
         wsprintf(szTemp, TEXT("bAcute[%s] AngleUnit[%s] pszAbbrev[%s] uPrecision[%d] dArcRadius[%f]"), 
         pAnnChangeParam->u.AnnProtractor.bAcute ? TEXT("TRUE") : TEXT("FALSE"), 
         pszAngleUnit, 
         pAnnChangeParam->u.AnnProtractor.pszAbbrev ? pAnnChangeParam->u.AnnProtractor.pszAbbrev : TEXT(""), 
         pAnnChangeParam->u.AnnProtractor.uAnglePrecision, 
         pAnnChangeParam->u.AnnProtractor.dArcRadius 
         ); 
         break; 
      } 
       
      case ANNTYPE_MOVE: 
      { 
         L_TCHAR *pszState; 
         switch(pAnnChangeParam->u.AnnMove.nState) 
         { 
            case STATE_BEGIN: 
            pszState = TEXT("STATE_BEGIN"); 
            break; 
            case STATE_UPDATE: 
            pszState = TEXT("STATE_UPDATE"); 
            break; 
            case STATE_END: 
            pszState = TEXT("STATE_END"); 
            break; 
default: 
            pszState = TEXT("Unknown State"); 
            break; 
         } 
          
         wsprintf(szTemp, TEXT("State[%12s] (dx,dy)(%3d,%3d)"), 
         pszState, 
         pAnnChangeParam->u.AnnMove.pt.x, 
         pAnnChangeParam->u.AnnMove.pt.y 
         ); 
         break; 
      } 
       
      case ANNTYPE_MOVE_POINT: 
      { 
         L_TCHAR *pszState; 
         switch(pAnnChangeParam->u.AnnMovePoint.nState) 
         { 
            case STATE_BEGIN: 
            pszState = TEXT("STATE_BEGIN"); 
            break; 
            case STATE_UPDATE: 
            pszState = TEXT("STATE_UPDATE"); 
            break; 
            case STATE_END: 
            pszState = TEXT("STATE_END"); 
            break; 
default: 
            pszState = TEXT("Unknown State"); 
            break; 
         } 
          
         wsprintf(szTemp, TEXT("State[%s] Point(%f,%f) Index[%d] (dx,dy)(%d,%d)"), 
         pszState, 
         pAnnChangeParam->u.AnnMovePoint.apt.x, 
         pAnnChangeParam->u.AnnMovePoint.apt.y, 
         pAnnChangeParam->u.AnnMovePoint.uIndex, 
         pAnnChangeParam->u.AnnMovePoint.pt.x, 
         pAnnChangeParam->u.AnnMovePoint.pt.y 
         ); 
         break; 
      } 
      case ANNTYPE_RESIZE_ROTATE: 
      { 
         L_TCHAR *pszState; 
         switch(pAnnChangeParam->u.AnnResizeRotate.nState) 
         { 
            case STATE_BEGIN: 
            pszState = TEXT("STATE_BEGIN"); 
            break; 
            case STATE_UPDATE: 
            pszState = TEXT("STATE_UPDATE"); 
            break; 
            case STATE_END: 
            pszState = TEXT("STATE_END"); 
            break; 
default: 
            pszState = TEXT("Unknown State"); 
            break; 
         } 
          
         wsprintf(szTemp, TEXT("State[%s] AnnXForm\n\tr11[%10.3f] r12[%10.3f]\n\tr21[%10.3f] r22[%10.3f]\n\t tx[%10.3f]  ty[%10.3f]\n\tdAngle[%10.3f]"), 
         pszState, 
         pAnnChangeParam->u.AnnResizeRotate.pAnnXForm->r11, 
         pAnnChangeParam->u.AnnResizeRotate.pAnnXForm->r12, 
         pAnnChangeParam->u.AnnResizeRotate.pAnnXForm->r21, 
         pAnnChangeParam->u.AnnResizeRotate.pAnnXForm->r22, 
         pAnnChangeParam->u.AnnResizeRotate.pAnnXForm->tx, 
         pAnnChangeParam->u.AnnResizeRotate.pAnnXForm->ty, 
         pAnnChangeParam->u.AnnResizeRotate.dAngle 
         ); 
         break; 
      } 
      case ANNTYPE_HANNOBJECT: 
      { 
         wsprintf(szTemp, TEXT("hContainer[0x%x]"), pAnnChangeParam->u.hObject); 
         break; 
      } 
       
default: 
      lstrcpy(szTemp, TEXT("Unknown Type")); 
   } 
    
   lstrcat(szMsg, szTemp); 
   lstrcat(szMsg, pAnnChangeParam->bAfter ? TEXT("--After ") : TEXT("--Before")); 
   if (pAnnChangeParam->uFlags) 
   { 
      L_TCHAR szFlags[300]; 
      wsprintf(szFlags, TEXT(" uFlags[0x%03x]"), pAnnChangeParam->uFlags); 
      if (pAnnChangeParam->uFlags & ANNCHANGE_FLAG_UNDO) 
         lstrcat(szFlags, TEXT("ANNCHANGE_FLAG_UNDO,")); 
      if (pAnnChangeParam->uFlags & ANNCHANGE_FLAG_CUT) 
         lstrcat(szFlags, TEXT("ANNCHANGE_FLAG_CUT,")); 
      if (pAnnChangeParam->uFlags & ANNCHANGE_FLAG_PASTE) 
         lstrcat(szFlags, TEXT("ANNCHANGE_FLAG_PASTE,")); 
      if (pAnnChangeParam->uFlags & ANNCHANGE_FLAG_SELECT_ALL) 
         lstrcat(szFlags, TEXT("ANNCHANGE_SELECT_ALL,")); 
      if (pAnnChangeParam->uFlags & ANNCHANGE_FLAG_UNLOCK_SELECTED) 
         lstrcat(szFlags, TEXT("ANNCHANGE_FLAG_UNLOCK_SELECTED,")); 
      if (pAnnChangeParam->uFlags & ANNCHANGE_FLAG_LOCK_SELECTED) 
         lstrcat(szFlags, TEXT("ANNCHANGE_FLAG_LOCK_SELECTED,")); 
      lstrcat(szMsg, szFlags); 
   } 
   return SUCCESS_CHANGE; 
} 
L_VOID DebugLtAnnEvent(int nID, LPARAM lParam) 
{ 
   static int nCount = 0; 
   const L_TCHAR * pszMsg = NULL; 
   L_TCHAR szMsg[500]; 
   HANNOBJECT hObject = (HANNOBJECT)lParam; 
   pANNCHANGEPARAM pAnnChangeParam; 
   if (!gbMessages) 
      return; 
    
   // This displays only the WM_LTANNEVENT LTANNEVENT_AUTOITEMCHANGING events 
   // Remove the line below to display ALL annotation messages 
   if (nID != LTANNEVENT_AUTOITEMCHANGING) 
      return; 
    
   pAnnChangeParam = (pANNCHANGEPARAM)lParam; 
   hObject = pAnnChangeParam->hObject; 
   pAnnChangeParam->nChange = DebugLtAnnEvent_AutoItemChanging(hObject, szMsg, lParam); 
   pszMsg = szMsg; 
    
   if (pszMsg) 
   { 
      L_TCHAR szMsg[300]; 
      L_TCHAR *pszType= NULL; 
      L_UINT uObjectType=999; 
      if (hObject) 
      { 
         L_AnnGetType(hObject, &uObjectType); 
         pszType = annGetObjectString(uObjectType); 
         wsprintf(szMsg, TEXT("[%3d]*** [(%2d) %20s] %s\n"), nCount++, uObjectType, pszType, pszMsg); 
      } 
      else 
      { 
         wsprintf(szMsg, TEXT("[%3d]*** %s\n"), nCount++, pszMsg); 
      } 
      OutputDebugString(szMsg); 
   } 
} 

Help Version 20.0.2018.7.30
Products | Support | Contact Us | Copyright Notices
© 1991-2018 LEAD Technologies, Inc. All Rights Reserved.

LEADTOOLS Raster Imaging C API Help