menuutil.c

本文件是ni公司的labwindows/cvi软件的部分例子和源程序

/*--------------------------------------------------------------*/
/*  MENUUTIL.C                                                  */
/*--------------------------------------------------------------*/

/*--------------------------------------------------------------*/
/* #include                                                     */
/*--------------------------------------------------------------*/
#ifdef WIN32
  #include <windows.h>
#endif

#include "utility.h"
#include "menuutil.h"

/*--------------------------------------------------------------*/
/* #defines                                                     */
/*--------------------------------------------------------------*/
#define MAX_MENU_ITEM_LENGTH 32

typedef struct menuInfo
{
    menuList handle;
    int menuBarHandle;
    int menuID;
    int beforeMenuItemID;
    int maxItems;
    MenuListCallbackPtr callbackFunc;
    int separator1;
    int separator2;
    int separator1ID;
    int separator2ID;
    int oneCheckItem;
    int checkWhenAdded;
    int allowDuplicates;
    int preAppendShortCut;
    ListType menuItemInfoList;
} menuInfoRec; 

typedef struct menuItemInfo
{
    char  menuName[MAX_MENU_ITEM_LENGTH+1];
    int   menuItemID;
    void *callbackData;
} menuItemInfoRec; 

static ListType sMenuInfoList = NULL;

#if _CVI_DEBUG_
static menuInfoRec * sMenuInfoPtr = NULL; // Global pointer for debug puposes
#endif

/*--------------------------------------------------------------*/
/* exported prototypes                                          */
/*--------------------------------------------------------------*/


/*--------------------------------------------------------------*/
/* static prototypes                                            */
/*--------------------------------------------------------------*/
static int FindMenuInfoInList(ListType menuInfoList, menuList handle);

static int FindMenuItemInfoFromMenuName(ListType menuInfoList, char *longName);

static int FindMenuItemInfoFromMenuItemID(ListType menuInfoList, int menuItemID);

static int UpdateMenuItems(menuInfoRec *menuInfoPtr);

static int RemoveMenuList(menuInfoRec *menuInfoPtr);
static int RemoveMenuListItem(menuInfoRec *menuInfoPtr, int index);
static int UncheckAllCheckedItems(menuInfoRec *menuInfoPtr, int doNotUncheckFirstFound);
static int RemoveDuplicates(menuInfoRec *menuInfoPtr);

static int IniEx_PutRawStringListItem(IniText iniTextHandle, char *sectionName, 
                           char *tagPrefix, char *tagValue, int maxItems);

#ifdef WIN32
static int IniEx_ReadFromRegistry(IniText iniTextHandle, int rootKey, char *baseKeyName);
static int IniEx_WriteToRegistry(IniText iniTextHandle, int rootKey, char *baseKeyName, int removeNonListTags);
#endif
    
/*****************************************************/
/*  GenerateShortFileName()                          */
/*                                                   */
/*  Parameters:                                      */
/*      output buffer to place short filename        */
/*      input buffer with long filename              */
/*      max characters to place in output bugger     */
/*        (This does not include the ending NUL)     */
/*  Return: pointer to outbuffer                     */
/*                                                   */
/*  Purpose: Routine to generate a short filename    */
/*           from a long filename                    */
/*                                                   */
/*  Example:                                         */
/*    LongName  = c:\dir1\dir2\dir3\file.txt         */
/*    ShortName = c:\...dir3\file.txt                */
/*                                                   */
/*****************************************************/
char * CVIFUNC MU_MakeShortFileName(
    char *userOutBuf, 
    char *userInBuf, 
    int max)
{
    int size, sizeOfFilename, sizeOfPrefix;
    char *startOfFilename = NULL;
    char *first = NULL;
    static char outBuf[260];
    char inBuf[260];
    
#ifdef _NI_mswin_
    int byte=92; /* '\' */
#else
    int byte=47; /* '/' */
#endif

#ifdef _NI_mswin_
    /* Windows - outbuf must at least be able to handle "x:\...\A... */
    if (max<11) {                                  /*    01234567890 */
        goto Error;
    }   
#endif

    /* Use internal Out buffer if non supplied */
    if (userOutBuf) 
        strcpy(outBuf, userOutBuf);
        
    /* Verify input buffers */
    if ( (!userInBuf) || (max < 1) ) {
        goto Error;
    }   
    
    if (userInBuf[0]==0) {  
        outBuf[0]=0;
        goto Done;
    } else 
        strcpy(inBuf, userInBuf);

    /* We want to make the first drive letter upper case if using Windows */
#ifdef _NI_mswin_
    if ((inBuf[0]>96) && (inBuf[0]<123))
            inBuf[0] = inBuf[0] - 32;
#endif
    
    /* If inbuf is smaller than max, just copy value into outbuf */ 
    size = strlen(inBuf);
    if (size<=max) {
        strncpy(outBuf, inBuf, size);
        outBuf[size] = 0;
    } else {
        /* Find just the filename and its size */   
        startOfFilename = strrchr (inBuf, byte); /* Last */
        startOfFilename++;      
        sizeOfFilename = strlen(startOfFilename);
        
        /* Find the first part that we want to keep */   
#ifdef _NI_mswin_
        sizeOfPrefix = 3;
#else 
        /* Find first '\' before filename within max limit. */ 
        first = strchr(&inBuf[2], byte);
        if (!first) 
             sizeOfPrefix = 0;
        else sizeOfPrefix = (first-inBuf+1);
#endif

        /* Copy the prefix ("x:\" or /xyz/) to outbuf */
        strncpy (outBuf, inBuf, sizeOfPrefix);
        outBuf[sizeOfPrefix]=0;
        /* Copy "...\" to end of outbuf, and add NULL */
#ifdef _NI_mswin_
        strncpy(&outBuf[sizeOfPrefix], "...\\", 5);
#else 
        strncpy(&outBuf[sizeOfPrefix], ".../", 5);
#endif

        /* If base filename is larger than max-7 just place what you can into outbuf with '...' on end */
        if (sizeOfFilename>max-sizeOfPrefix-4) {
            strncpy(&outBuf[sizeOfPrefix+4], startOfFilename, max-sizeOfPrefix-7);
            /* Copy "..." to end of outbuf, and add NULL */
            strncpy(&outBuf[max-3], "...", 4);
        } else {
            /* Find first '\' after prefix and before filename within max limit. */ 
            first = strchr(&inBuf[size-max+sizeOfPrefix+3], byte);  /* First */
            
            if (!first)
                first = &inBuf[size-max+sizeOfPrefix+3];
            
            strncpy(&outBuf[sizeOfPrefix+3], first, max-sizeOfPrefix-2);
        }   
    }   
Done:
    if (userOutBuf) {
        strcpy(userOutBuf, outBuf);
        return userOutBuf;
    } else 
        return outBuf;
Error:
    return NULL;
}
 

/*****************************************************/
/*  FindMenuInfoInList()                             */
/*                                                   */
/*  Parameters:                                      */
/*      menuInfoList handle                          */
/*      menuList                                     */
/*                                                   */
/*  Return: index into list for found item           */
/*                                                   */
/*  Purpose: Routine to search the menuInfo list     */
/*           for the index corresponding to a handle */
/*                                                   */
/*****************************************************/
static int FindMenuInfoInList(
    ListType menuInfoList, 
    menuList handle)
{
    int i, totalItems;
    menuInfoRec * menuInfoPtr = NULL;
    
    if (handle) {
        /* Loop to find handle in list */
        totalItems = ListNumItems (menuInfoList);
        for (i=1;(i<=totalItems);i++) {
            menuInfoPtr = ListGetPtrToItem (menuInfoList, i);
            if ((menuInfoPtr) && (menuInfoPtr->handle==handle) ) {
                return i;
            }   
        }
    }   
    return 0;           
}


/*****************************************************/
/*  FindMenuItemInfoFromMenuItemID()                 */
/*                                                   */
/*  Parameters:                                      */
/*      menuItemInfoList handle                      */
/*      menu item id                                 */
/*                                                   */
/*  Return: index into list for found item           */
/*                                                   */
/*  Purpose: Routine to search the menuItemInfo list */
/*           for the longName passed in              */
/*                                                   */
/*****************************************************/
static int FindMenuItemInfoFromMenuItemID(
    ListType menuItemInfoList, 
    int menuItemID)
{
    int i, totalItems;
    menuItemInfoRec * menuItemInfoPtr = NULL;
            
    if (menuItemInfoList) {
        /* Loop to find handle in list */
        totalItems = ListNumItems (menuItemInfoList);
        for (i=1;(i<=totalItems);i++) {
            menuItemInfoPtr = ListGetPtrToItem (menuItemInfoList, i);
            if ((menuItemInfoPtr) && (menuItemID == menuItemInfoPtr->menuItemID) ) {
                return i;
            }   
        }
    }   
    return 0;           
}

/*****************************************************/
/*  FindMenuItemInfoFromMenuName()                   */
/*                                                   */
/*  Parameters:                                      */
/*      menuItemInfoList handle                      */
/*      buffer for longName to search for            */
/*                                                   */
/*  Return: index into list for found item           */
/*                                                   */
/*  Purpose: Routine to search the menuItemInfo list */
/*           for the longName passed in              */
/*                                                   */
/*****************************************************/
static int FindMenuItemInfoFromMenuName(
    ListType menuItemInfoList, 
    char *menuName)
{
    int i, totalItems;
    menuItemInfoRec * menuItemInfoPtr = NULL;
    
    if ((menuItemInfoList) && (menuName)) {
        /* Loop to find handle in list */
        totalItems = ListNumItems (menuItemInfoList);
        for (i=1;(i<=totalItems);i++) {
            menuItemInfoPtr = ListGetPtrToItem (menuItemInfoList, i);
            if ((menuItemInfoPtr) && (menuItemInfoPtr->menuName) && (!strcmp(menuName, menuItemInfoPtr->menuName)) ) {
                return i;
            }   
        }
    }   
    return 0;           
}



/*****************************************************/
/*  InternalMenuCallback()                           */
/*                                                   */
/*  Parameters:                                      */
/*      menuBarHandle                                */
/*      menuItemID                                   */
/*      callbackData                                 */
/*      panel                                        */
/*                                                   */
/*  Purpose: Call user's menuList callback functions */
/*                                                   */
/*****************************************************/
static void CVICALLBACK InternalMenuCallback (int menuBarHandle, int menuItemID, void *callbackData, int panel)
{
    menuInfoRec * menuInfoPtr = NULL;
    menuItemInfoRec * menuItemInfoPtr = NULL;
    MenuListCallbackPtr callbackFunc;
    int index;
    menuList handle;
    
    /* Get menulist pointer from handle */    
    if ((handle           = (menuList) callbackData) &&
        ((index           = FindMenuInfoInList (sMenuInfoList, handle))>0) &&
        (menuInfoPtr      = ListGetPtrToItem (sMenuInfoList, index)) && 
        (index            = FindMenuItemInfoFromMenuItemID (menuInfoPtr->menuItemInfoList, menuItemID)) &&
        (menuItemInfoPtr  = ListGetPtrToItem (menuInfoPtr->menuItemInfoList, index)) )
    {
        if (callbackFunc = menuInfoPtr->callbackFunc)
            (* callbackFunc) (handle, index, EVENT_COMMIT, menuItemInfoPtr->callbackData);