xmlsample.c

labwindow 编程的toolbox例程。

    DisplayActiveXErrorMessageOnFailure (error);
    return 0;
}

int CVICALLBACK ChildGoToChild (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int             index = 0;
    CVIXMLElement   newElem = 0;
    
    switch (event)
    {
    case EVENT_COMMIT:
        if (curElem)
        {
            GetCtrlIndex (panelHandle, PANEL_CHILD_LIST, &index);
            if (index != -1)
            {
                GetValueFromIndex (panelHandle, PANEL_CHILD_LIST, 
                                   index, &newElem);
                CVIXMLDiscardElement (curElem);
                curElem = newElem;
                newElem = 0;
                UpdateUI ();
            }
        }
        break;
    }
        
    CVIXMLDiscardElement (newElem);
    return 0;
}

int CVICALLBACK ChildListChange (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    CVIXMLElement   newElem = 0;
    
    switch (event)
    {
    case EVENT_LEFT_DOUBLE_CLICK:
        ChildGoToChild (panelHandle, PANEL_CHILD_GOTO_CHILD, EVENT_COMMIT, 
                        callbackData, eventData1, eventData2);
        break;
    case EVENT_KEYPRESS:
        if (eventData1 == VAL_INSERT_VKEY)
        {
            ChildInsertBefore (panel, control, EVENT_COMMIT, callbackData, 
                               eventData1, eventData2);
        }
        else if (eventData1 == VAL_ENTER_VKEY)
        {
            ChildGoToChild (panel, control, EVENT_COMMIT, callbackData, 
                            eventData1, eventData2);
        }
        else if (eventData1 == VAL_FWD_DELETE_VKEY)
        {
            ChildDelete (panel, control, EVENT_COMMIT, callbackData, 
                         eventData1, eventData2);
        }
        break;
    }
    
    CVIXMLDiscardElement (newElem);
    return 0;
}

int CVICALLBACK AttrListChange (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    char            name[TEXT_SIZE];
    char            value[TEXT_SIZE];
    Point           colOnePt;
    Point           colTwoPt;
    Point           activePt;
    CVIXMLAttribute newAttr = 0;
    HRESULT         error = S_OK;
    
    switch (event)
    {
    case EVENT_COMMIT:
        if(curElem)
        {
            colOnePt = MakePoint (1, eventData1);
            colTwoPt = MakePoint (2, eventData1);
            GetTableCellVal (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                             colOnePt, name);
            GetTableCellVal (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                             colTwoPt, value);
            if (eventData2 == 1)
            {
                if (!IsValidXML (name))
                {
                    MessagePopup (ERR_MSG_TITLE, INVALID_ATTR_NAME_MSG);
                    SetTableCellVal (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                                     colOnePt, EMPTY_STRING);
                    SetActiveCtrl (attrPanelHandle, ATTRPANEL_ATTR_LIST);
                    SetActiveTableCell (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                                        colOnePt);
                    goto Error;
                }
                hrChk (CVIXMLAddAttribute (curElem, name, value));
                SetTableCellAttribute (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                                       colOnePt, ATTR_CELL_MODE, VAL_INDICATOR);
            }
            else if (eventData2 == 2)
            {
                hrChk (CVIXMLGetAttributeByName (curElem, name, &newAttr));
                if (newAttr)
                    hrChk(CVIXMLSetAttributeValue (newAttr, value));
            }
        }
        break;
    case EVENT_KEYPRESS:
        if (eventData1 == VAL_INSERT_VKEY)
        {
            AttrAdd (panel, control, EVENT_COMMIT, callbackData, 
                     eventData1, eventData2);
        }
        else if (eventData1 == VAL_FWD_DELETE_VKEY)
        {
            GetActiveTableCell (attrPanelHandle, ATTRPANEL_ATTR_LIST, &activePt);
            if (activePt.x == 1)
                AttrDelete (panel, control, EVENT_COMMIT, callbackData, 
                            eventData1, eventData2);
        }
        break;
    }
        
Error:
    CVIXMLDiscardAttribute (newAttr);
    DisplayActiveXErrorMessageOnFailure (error);
    return 0;
}

int CVICALLBACK ValChanged (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    char    value[TEXT_SIZE];
    HRESULT error = S_OK;
    
    switch (event)
    {
    case EVENT_COMMIT:
        if (curElem)
        {
            GetCtrlVal (panelHandle, PANEL_ELEM_VAL, value);
            hrChk (CVIXMLSetElementValue (curElem, value));
        }
        break;
    }
        
Error:
    DisplayActiveXErrorMessageOnFailure (error);
    return 0;
}

int CVICALLBACK AttrGet (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event)
    {
    case EVENT_COMMIT:
        UpdateAttributes ();
        InstallPopup (attrPanelHandle);
        break;
    }
        
    return 0;
}

int CVICALLBACK AttrOK (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int numRows;
    
    switch (event)
    {
    case EVENT_COMMIT:
        RemovePopup (attrPanelHandle);
        GetNumTableRows (attrPanelHandle, ATTRPANEL_ATTR_LIST, &numRows);
        if (numRows > 0)
            DeleteTableRows (attrPanelHandle, ATTRPANEL_ATTR_LIST, 1, -1);
        break;
    }
    
    return 0;       
}

static void UpdateUI (void)
{
    UpdateElement ();
    UpdateChildren ();

}

static void UpdateUIDimming (int hasXML)
{
    SetCtrlAttribute (panelHandle, PANEL_ELEM_TAG, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_ELEM_VAL, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_ATTR_GET, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_ELEM_GOTO_PARENT, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_CHILD_LIST, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_CHILD_GOTO_CHILD, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_CHILD_INS_BEFORE, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_CHILD_INS_AFTER, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_CHILD_DELETE, ATTR_DIMMED, !hasXML);
    SetCtrlAttribute (panelHandle, PANEL_SAVE, ATTR_DIMMED, !hasXML);
}

static void UpdateElement (void)
{
    int             length = 0;
    int             numChildren = 0;
    char            *tag = NULL;
    char            *value = NULL;
    CVIXMLElement   parElem = 0;
    HRESULT         error = S_OK;
    
    SetCtrlVal (panelHandle, PANEL_ELEM_TAG, EMPTY_STRING);
    SetCtrlVal (panelHandle, PANEL_ELEM_VAL, EMPTY_STRING);
    
    if (curElem)
    {
        hrChk (CVIXMLGetElementTagLength (curElem, &length));
        tag = calloc (1, length + 1);
        hrChk (CVIXMLGetElementValueLength (curElem, &length));
        value = calloc (1, length + 1);
        if (tag == NULL || value == NULL)
            hrChk(E_OUTOFMEMORY);
        hrChk (CVIXMLGetElementTag (curElem, tag));
        hrChk (CVIXMLGetElementValue (curElem, value));
        RemoveSurroundingWhiteSpace (value);
        SetCtrlVal (panelHandle, PANEL_ELEM_TAG, tag);
        SetCtrlVal (panelHandle, PANEL_ELEM_VAL, value);
        hrChk (CVIXMLGetNumChildElements (curElem, &numChildren));
        if (numChildren)
            SetCtrlAttribute (panelHandle, PANEL_CHILD_GOTO_CHILD, 
                              ATTR_DIMMED, 0);
        else
            hrChk(SetCtrlAttribute (panelHandle, PANEL_CHILD_GOTO_CHILD, 
                                    ATTR_DIMMED, 1));
        hrChk (CVIXMLGetParentElement (curElem, &parElem));
        hrChk(SetCtrlAttribute (panelHandle, PANEL_ELEM_GOTO_PARENT, 
                                ATTR_DIMMED, !parElem));
    }

    tag = NULL;
    value = NULL;
    
Error:
    free (tag);
    free (value);
    CVIXMLDiscardElement (parElem);
    DisplayActiveXErrorMessageOnFailure (error);
}

static void UpdateChildren (void)
{
    int             i = 0;
    int             length = 0;
    int             numChildren = 0;
    char            *tag = NULL;
    CVIXMLElement   tempElem = 0;
    HRESULT         error = S_OK;
    int             resetCursor = 0;
                
    hrChk (ClearListCtrl (panelHandle, PANEL_CHILD_LIST));
    if (curElem)
    {
        hrChk (CVIXMLGetNumChildElements (curElem, &numChildren));
        SetMouseCursor (VAL_HOUR_GLASS_CURSOR);
        resetCursor = 1;
        for (i = 0; i < numChildren; i++)
        {
            hrChk (CVIXMLGetChildElementByIndex (curElem, i, &tempElem));
            hrChk (CVIXMLGetElementTagLength (tempElem, &length));
            tag = calloc (1, length + 1);
            if (tag == NULL)
                hrChk(E_OUTOFMEMORY);
            hrChk (CVIXMLGetElementTag (tempElem, tag));
            InsertListItem (panelHandle, PANEL_CHILD_LIST, i, tag, tempElem);
            tag = NULL;
            tempElem = 0;
        }
    }
    
Error:
    if (resetCursor)
        SetMouseCursor (VAL_DEFAULT_CURSOR);
    free (tag);
    CVIXMLDiscardElement (tempElem);
    DisplayActiveXErrorMessageOnFailure (error);
}

static void UpdateAttributes (void)
{
    int             i = 0;
    int             numAttr = 0;
    int             length = 0;
    char            *name = NULL;
    char            *value = NULL;
    Point           colOnePt;
    Point           colTwoPt;
    CVIXMLAttribute attr = 0;
    HRESULT         error = S_OK;
    int             resetCursor = 0;
                
    GetNumTableRows (attrPanelHandle, ATTRPANEL_ATTR_LIST, &length);
    if (length)
        DeleteTableRows (attrPanelHandle, ATTRPANEL_ATTR_LIST, 1, -1);
    if (curElem)
    {
        hrChk (CVIXMLGetNumAttributes (curElem, &numAttr));
        if (numAttr)
        {
            InsertTableRows (attrPanelHandle, ATTRPANEL_ATTR_LIST, 1, 
                             numAttr, VAL_CELL_STRING);
            SetCtrlAttribute (attrPanelHandle, ATTRPANEL_ATTR_DELETE, 
                              ATTR_DIMMED, 0);
        }
        SetCtrlAttribute (attrPanelHandle, ATTRPANEL_ATTR_DELETE, 
                          ATTR_DIMMED, !numAttr);

        SetMouseCursor (VAL_HOUR_GLASS_CURSOR);
        resetCursor = 1;
        for (i = 0; i < numAttr; i++)
        {
            colOnePt = MakePoint (1, i + 1);
            colTwoPt = MakePoint (2, i + 1);
            hrChk (CVIXMLGetAttributeByIndex (curElem, i, &attr));
            hrChk (CVIXMLGetAttributeNameLength (attr, &length));
            name = calloc (1, length + 1);
            hrChk (CVIXMLGetAttributeValueLength (attr, &length));
            value = calloc (1, length + 1);
            if(name == NULL || value == NULL)
                hrChk(E_OUTOFMEMORY);
            hrChk (CVIXMLGetAttributeName (attr, name));
            hrChk (CVIXMLGetAttributeValue (attr, value));
            SetTableCellVal (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                             colOnePt, name);
            SetTableCellAttribute (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                                   colOnePt, ATTR_CELL_MODE, 
                                   VAL_INDICATOR);
            SetTableCellVal (attrPanelHandle, ATTRPANEL_ATTR_LIST, 
                             colTwoPt, value);
            name = NULL;
            value = NULL;
        }
    }
    
Error:
    free (name);
    free (value);
    CVIXMLDiscardAttribute (attr);
    if (resetCursor)
        SetMouseCursor (VAL_DEFAULT_CURSOR);
    DisplayActiveXErrorMessageOnFailure (error);
}

static int IsValidXML (char * string)
{
    int i = 0;
    int len = 0;
    int allNums = 0;
    
    if (string[0] == '\0')
        return 0;
    
    len = strlen(string);
    for (i = 0; i < len; i++)
    {
        if (isdigit (string[i]))
        {
            if (i == 0)
                allNums = 1;
        }
        else
        {
            allNums = 0;
        }
        
        if (!isalnum (string[i]) || isspace (string[i]))
            return 0;
    }
    
    if (allNums)
        return 0;
    
    return 1;
}

static void DisplayActiveXErrorMessageOnFailure (HRESULT error)
{
    if (FAILED (error))
    {
        char errBuf [ERR_MSG_SIZE];
        CVIXMLGetErrorString (error, errBuf, sizeof (errBuf));
        MessagePopup (ERR_MSG_TITLE, errBuf);
    }

}