示例#1
0
void CTxFunctionsView::OnButtonApply()
{
    SetUpdateBtnChanges();
    //save the values of delay between blocks
    UINT                    unTimerVal;
    CString                 csTimerVal;
    CTxMsgBlocksView* pomBlockView = NULL;
    pomBlockView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
    if(pomBlockView == NULL)
    {
        return;
    }
    //if(pomBlockView)
    //{
    //    pomBlockView->GetDlgItemText(IDC_EDIT_BLOCK_TRG_TIMER_VAL, csTimerVal);

    //    if(((CButton*) pomBlockView->GetDlgItem(IDC_CHECK_MSG_BLOCK_DELAY))->GetCheck() == BST_CHECKED)
    //    {
    //        CTxWndDataStore::ouGetTxWndDataStoreObj().m_bDelayBetweenMsgBlocks = true;
    //        CTxMsgManager::s_bDelayBetweenBlocksOnly = true;
    //        pomBlockView->m_bDelayBtnBlocks = true;
    //    }
    //    else
    //    {
    //        CTxWndDataStore::ouGetTxWndDataStoreObj().m_bDelayBetweenMsgBlocks = false;
    //        CTxMsgManager::s_bDelayBetweenBlocksOnly = false;
    //        pomBlockView->m_bDelayBtnBlocks = false;
    //    }
    //}

    unTimerVal = (UINT)atol(csTimerVal.GetBuffer(0));

    CTxWndDataStore::ouGetTxWndDataStoreObj().m_unTimeDelayBtwnMsgBlocks = unTimerVal;
    CTxMsgManager::s_unTimeDelayBtnMsgBlocks = unTimerVal;
    this->SetFocus();

    // The following block of code can be enabled if message to be transmitted in following scenario :
    // Message transmission is ON, Empty block is present. Added a message to the
    // empty block and Update button is selected
    /*if(CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_SENDMESG))
    {
        CTxMsgBlocksView* pBlocksView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
        PSMSGBLOCKLIST psMsgCurrentBlock = NULL;
        if (NULL != pomBlockView)
        {
            psMsgCurrentBlock =  pomBlockView->psGetMsgBlockPointer(
                pomBlockView->m_nSelectedMsgBlockIndex,
                pomBlockView->m_psMsgBlockList );
            // If no msg is present at the start of msg transmission and if the
            // user adds a one or more msg and selects the update button, then send the new msg
            if(psMsgCurrentBlock->m_unMsgCount >= 1)
            {
                CTxMsgManager::s_podGetTxMsgManager()->vStartTransmission(0);
            }
        }
    }*/
}
示例#2
0
/*******************************************************************************
  Function Name  : OnBnClickedCheckAutoUpdate
  Input(s)       : -
  Output         : -
  Functionality  : This checkbox updates the content automaticallyan stores it in
                   global store
  Member of      : CTxFunctionsView
  Author(s)      : Ashwin. R. Uchil
  Date Created   : 28.5.2012
  Modifications  :
*******************************************************************************/
void CTxFunctionsView::OnBnClickedCheckAutoUpdate()
{
    CTxMsgBlocksView* pBlocksView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
    if (NULL != pBlocksView)
    {
        if (NULL == pBlocksView->m_psMsgBlockList)
        {
            GetDlgItem(IDC_BTN_UPDATE)->EnableWindow(FALSE);
        }
        else
        {
            GetDlgItem(IDC_BTN_UPDATE)->EnableWindow(TRUE);
        }
    }
    else
    {
        GetDlgItem(IDC_BTN_UPDATE)->EnableWindow(FALSE);
    }

    if((m_CheckBoxAutoUpdate.GetCheck() == BST_CHECKED))
    {
        vAccessButtonApply();
        CTxWndDataStore::ouGetTxWndDataStoreObj().m_bAutoSavedEnabled = true;
        //CTxMsgManager::s_bDelayBetweenBlocksOnly = true;
        if (NULL != pBlocksView)
        {
            UINT                    unTimerVal;
            CString                 csTimerVal;
            pBlocksView->GetDlgItemText(IDC_EDIT_BLOCK_TRG_TIMER_VAL, csTimerVal);
            unTimerVal = (UINT)atol(csTimerVal.GetBuffer(0));
            CTxWndDataStore::ouGetTxWndDataStoreObj().m_unTimeDelayBtwnMsgBlocks = unTimerVal;
            CTxMsgManager::s_unTimeDelayBtnMsgBlocks = unTimerVal;
            //set the status of delay between blocks
            if(pBlocksView->m_omDelayBtwnBlocks.GetCheck() == BST_CHECKED)
            {
                CTxMsgManager::s_bDelayBetweenBlocksOnly = true;
                CTxWndDataStore::ouGetTxWndDataStoreObj().m_bDelayBetweenMsgBlocks = true;
                pBlocksView->m_bDelayBtnBlocks = true;
            }
            else
            {
                CTxMsgManager::s_bDelayBetweenBlocksOnly = false;
                CTxWndDataStore::ouGetTxWndDataStoreObj().m_bDelayBetweenMsgBlocks = false;
                pBlocksView->m_bDelayBtnBlocks = false;
            }
        }
    }
    else
    {
        CTxWndDataStore::ouGetTxWndDataStoreObj().m_bAutoSavedEnabled = false;
        //CTxMsgManager::s_bDelayBetweenBlocksOnly = false;
    }
}
示例#3
0
/*******************************************************************************
 Function Name    : vApplyChanges
 Input(s)         :
 Output           :
 Functionality    : This function is used to apply changes in the global shared
                    memory
 Member of        : CTxFunctionsView
 Friend of        :  -
 Author(s)        : Raja N
 Date Created     : 19.07.2004
 Modification By  :
 Modification on  :
*******************************************************************************/
void CTxFunctionsView::vApplyChanges()
{
    // Get Other view pointers
    CTxMsgBlocksView* pomBlockView = NULL;
    CTxMsgListView* pomListView = NULL;
    pomBlockView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
    pomListView = (CTxMsgListView* )pomGetListViewPointer();

    if( pomBlockView != NULL && pomListView != NULL )
    {
        PSMSGBLOCKLIST psMsgBlock = NULL;
        psMsgBlock = pomBlockView->psGetMsgBlockPointer(
                         pomBlockView->m_nSelectedMsgBlockIndex,
                         pomBlockView->m_psMsgBlockList );
        // Update the last selected message block details in case user has
        // modified it.
        if(psMsgBlock != NULL )
        {
            pomBlockView->vUpdateMsgBlockDetials(psMsgBlock);
            psMsgBlock->m_bModified = true;
        }

        // Set the value in configuration class.
        CTxWndDataStore::ouGetTxWndDataStoreObj().bSetTxData( TX_MSG_BLOCK_COUNT,
                (void*)&(pomBlockView->m_unMsgBlockCount) );
        // Data is set only if messagae block count is more then zero.
        if( pomBlockView->m_unMsgBlockCount > 0 )
        {
            CTxWndDataStore::ouGetTxWndDataStoreObj().bSetTxData( TX_MSG_UPDATE,
                    (void*)(pomBlockView->m_psMsgBlockList) );
            // Allocate memory for globle list
            BOOL bAllocateMemory =
                CTxMsgManager::s_podGetTxMsgManager()->bAllocateMemoryForGlobalTxList();
            // Update Message List
            if(bAllocateMemory == TRUE )
            {
                CTxMsgManager::s_podGetTxMsgManager()->vAssignMsgBlockList();
            }
        }
        //Save Window position
        CTxMsgChildFrame* pTxWnd = (CTxMsgChildFrame*)pomGetParentWindow();
        // Update view pointer
        if( pTxWnd != NULL )
        {
            // Register this view pointer
            pTxWnd->vUpdateWndCo_Ords();

        }
        /* CString                     csTimeDelay;
         ((CEdit*)pomBlockView->GetDlgItem(IDC_EDIT_BLOCK_TRG_TIMER_VAL))->GetWindowTextA(csTimeDelay);
         CTxMsgManager::s_unTimeDelayBtnMsgBlocks = atol(csTimeDelay.GetBuffer(0));*/
    }
}
示例#4
0
void CTxFunctionsView::OnInvokeClose()
{
    CTxMsgBlocksView* pBlocksView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
    bool        bUnChanged = true;

    if(m_CheckBoxAutoUpdate.GetCheck() == BST_CHECKED)  //setting will already be saved so exit
    {
        return;
    }
    if(pBlocksView != NULL)
    {

        PSMSGBLOCKLIST psMsgBlock = NULL;
        psMsgBlock = pBlocksView->psGetMsgBlockPointer(
                         0,
                         pBlocksView->m_psMsgBlockList );

        if(psMsgBlock != NULL)
        {
            bUnChanged = CTxWndDataStore::ouGetTxWndDataStoreObj().nCompareBlockLists(psMsgBlock);
            if(pBlocksView->m_bDelayBtnBlocks != CTxWndDataStore::ouGetTxWndDataStoreObj().m_bDelayBetweenMsgBlocks)
            {
                bUnChanged = false;
            }
            CString  omstrData;
            pBlocksView->m_omTimeDelayBtwnBlocks.GetWindowTextA(omstrData);
            if(atoi(omstrData.GetBuffer(0)) != CTxWndDataStore::ouGetTxWndDataStoreObj().m_unTimeDelayBtwnMsgBlocks)
            {
                bUnChanged = false;
            }
        }
        else if(CTxWndDataStore::ouGetTxWndDataStoreObj().psReturnMsgBlockPointer()!= NULL)
        {
            bUnChanged = false;
        }
        if(bUnChanged == true)
        {
            return;
        }
    }

    if( bUnChanged == false)            //if there are any changes, then save it.
    {
        if( AfxMessageBox( defSTR_TX_SAVE_CONFIRMATION,
                           MB_YESNO | MB_ICONQUESTION ) == IDYES )
        {
            // Save Changes
            OnButtonApply();
        }
    }
}
示例#5
0
void CTxFunctionsView::OnInvokeClose()
{
    if( m_omButtonApply.IsWindowEnabled() == TRUE )
    {
        if( AfxMessageBox( defSTR_TX_SAVE_CONFIRMATION,
                           MB_YESNO | MB_ICONQUESTION ) == IDYES )
        {
            // Save Changes
            OnButtonApply();
        }
        else
        {
            CTxMsgBlocksView* pBlocksView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
            if(pBlocksView != NULL)
            {
                CTxWndDataStore::ouGetTxWndDataStoreObj().m_bDelayBetweenMsgBlocks = pBlocksView->m_bDelayBtnBlocks;
                CTxMsgManager::s_bDelayBetweenBlocksOnly = pBlocksView->m_bDelayBtnBlocks;
            }
        }
    }
}
示例#6
0
void CTxFunctionsView::SetUpdateBtnChanges()
{
    // Apply changed to global Tx Block
    // User is trying to apply late changes
    // Prevent this as some message/block could be deleted after
    // starting the transmission.

    // Get Other view pointers
    CTxMsgBlocksView* pomBlockView = NULL;
    pomBlockView = (CTxMsgBlocksView*)pomGetBlocksViewPointer();
    if( pomBlockView != NULL )
    {
        // Message deletion is not allowed runtime from any block. This is only for Update button Scenario
        if((m_CheckBoxAutoUpdate.GetCheck() == BST_UNCHECKED))
        {
            if( (pomBlockView->m_bModified == TRUE) && (TRUE == CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_SENDMESG)) )
            {
                if(AfxMessageBox( defSTR_RELOAD_CONFIRMATION,
                                  MB_YESNO | MB_DEFBUTTON2) == IDYES )
                {
                    // Reload the data from Configuration
                    vReloadData();
                }
            }
            else
            {
                vApplyChanges();
                m_omButtonApply.EnableWindow(FALSE);
            }
        }
        else
        {
            vApplyChanges();
            // Disable the button
            m_omButtonApply.EnableWindow(FALSE);
            // Update modified flag
            pomBlockView->m_bModified = FALSE;
        }
    }
}
示例#7
0
void CTxFunctionsView::vReloadData()
{
    // Get Other View Ponters
    CTxMsgBlocksView* pomBlockView = NULL;
    CTxMsgListView* pomlistView = NULL;
    CTxMsgDetailsView* pomDetailsView = NULL;
    // Fetch pointers from Tx Child Frame
    pomBlockView = ( CTxMsgBlocksView* )pomGetBlocksViewPointer();
    pomlistView = ( CTxMsgListView* )pomGetListViewPointer();
    pomDetailsView = ( CTxMsgDetailsView* )pomGetDetailsViewPointer();

    if( pomBlockView != NULL && pomlistView != NULL && pomDetailsView != NULL )
    {
        // Clear all data
        pomBlockView->m_omLctrMsgBlockName.DeleteAllItems();
        pomlistView->m_omLctrMsgList.DeleteAllItems();
        pomDetailsView->m_omLctrSigList.DeleteAllItems();

        // Set this flag to avoid processing item change messages during init
        pomBlockView->m_bInitDlg = TRUE;
        pomlistView->m_bInitDlg = TRUE;

        //Clear the existing memory
        CTxWndDataStore::ouGetTxWndDataStoreObj().vReleaseMultiMsgInfo( pomBlockView->m_psMsgBlockList );
        pomBlockView->m_psMsgBlockList = NULL;
        /*vRelease( TX_SEND_MULTI_MSGS,
                         (void**)&(pomBlockView->m_psMsgBlockList) );*/
        // Get the message block count. No memory allocation is required.
        UINT* punCount = &( pomBlockView->m_unMsgBlockCount );
        CTxWndDataStore::ouGetTxWndDataStoreObj().bGetTxData(TX_MSG_BLOCK_COUNT, (void**)&punCount);
        // Make a local copy of the data structure
        // The local copy will be used to manipulate message frame details
        // Memory allocation will be done in the CConfigDetails class.
        // Get the pointer only if there m_unMsgBlockCount>0
        if( pomBlockView->m_unMsgBlockCount > 0 )
        {
            CTxWndDataStore::ouGetTxWndDataStoreObj().bGetTxData( TX_SEND_MULTI_MSGS,
                    (void**)&(pomBlockView->m_psMsgBlockList) );
        }

        if( pomBlockView->m_unMsgBlockCount == 0 )
        {
            pomBlockView->vEnableControls(FALSE);
            /*pomBlockView->m_omButtonTxAllFrame.EnableWindow(FALSE);*/
            pomBlockView->m_omComboAllMsgs.EnableWindow(FALSE);

            pomlistView->m_omButtonDeleteAllMsg.EnableWindow(FALSE);
            pomlistView->m_omButtonDeleteSelMsg.EnableWindow(FALSE);

        }
        else
        {
            pomlistView->m_omButtonDeleteAllMsg.
            EnableWindow(!CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_SENDMESG) );
        }

        PSMSGBLOCKLIST psCurrentMsgBlock = NULL;
        CString omStr = STR_EMPTY;
        psCurrentMsgBlock = pomBlockView->m_psMsgBlockList;

        // Disable AllTxMessage check box
        // This will be updated in the function vDisplayMsgBlockDetails
        // Disabling it here will avoid enabling the control when no blocks or
        // messages are present
        pomBlockView->m_omComboAllMsgs.EnableWindow(FALSE);
        /*pomBlockView->m_omButtonTxAllFrame.EnableWindow( FALSE );*/

        for(UINT i = 0; i< pomBlockView->m_unMsgBlockCount; i++)
        {
            omStr = STR_EMPTY;
            if(psCurrentMsgBlock != NULL )
            {
                pomBlockView->m_omLctrMsgBlockName.InsertItem( i,
                        psCurrentMsgBlock->m_acStrBlockName);
                if(psCurrentMsgBlock->m_bType == TRUE)
                {
                    pomBlockView->m_omLctrMsgBlockName.SetItemText( i,
                            defSUBITEM_MSGBLOCK_TYPE,
                            defMSG_CYCLIC );
                }
                else
                {
                    pomBlockView->m_omLctrMsgBlockName.SetItemText( i,
                            defSUBITEM_MSGBLOCK_TYPE,
                            defMSG_MONOSHOT );
                }

                // Use Macros to find the type
                // Timer?
                if( IS_TIME_TRIGGERED(psCurrentMsgBlock->m_ucTrigger) )
                {
                    omStr.Format( defSTR_TIMER_VAL_FMT_SPECIFIER,
                                  psCurrentMsgBlock->m_unTimeInterval );
                    omStr += defMESSAGE_TRIG_MS;

                    if( IS_KEY_TRIGGERED(psCurrentMsgBlock->m_ucTrigger) )
                    {
                        omStr += defSTR_MSG_BLOCK_TRIGGER_SEPRATOR;
                    }
                }

                // Key ?
                if( IS_KEY_TRIGGERED(psCurrentMsgBlock->m_ucTrigger) )
                {
                    CString omStrKeyVal;
                    omStrKeyVal.Format( defSTR_KEY_VAL_FMT_SPECIFIER,
                                        psCurrentMsgBlock->m_ucKeyValue );
                    omStr += omStrKeyVal;
                }
                pomBlockView->m_omLctrMsgBlockName.SetItemText( i,
                        defSUBITEM_MSGBLOCK_TRG_VAL,
                        omStr );
                pomBlockView->m_omLctrMsgBlockName.SetCheck( i,
                        psCurrentMsgBlock->m_bActive );
                psCurrentMsgBlock = psCurrentMsgBlock->m_psNextMsgBlocksList;
            }
        }
        // Clear Init Flag
        pomBlockView->m_bInitDlg = FALSE;
        pomlistView->m_bInitDlg = FALSE;

        pomBlockView->m_omLctrMsgBlockName.SetItemState(
            pomBlockView->m_nSelectedMsgBlockIndex,
            LVIS_SELECTED|LVIS_FOCUSED,
            LVIS_SELECTED|LVIS_FOCUSED );

        // Clear the Modified Flag
        pomBlockView->m_bModified = FALSE;

        // Disable Update Button
        m_omButtonApply.EnableWindow( FALSE );

    }
}
示例#8
0
void CTxMsgListView::OnDeleteAllMsg()
{
    CTxMsgBlocksView* pomBlocksView = nullptr;
    pomBlocksView = ( CTxMsgBlocksView*)pomGetBlocksViewPointer();

    CTxMsgDetailsView* pomDetailsView = nullptr;
    pomDetailsView = (CTxMsgDetailsView*)pomGetDetailsViewPointer();

    CTxFunctionsView* pomFunctionsView = nullptr;
    pomFunctionsView = (CTxFunctionsView*)pomGetFunctionsViewPointer();

    if( pomBlocksView != nullptr && pomDetailsView != nullptr &&
            pomFunctionsView != nullptr )
    {
        // give a warning message before deleting it.
        if ( AfxMessageBox( _(defDEL_ALL_MSG_FRAME),
                            MB_YESNO|MB_ICONQUESTION) == IDYES)
        {
            // check for valid message block selection index.
            if( pomBlocksView->m_nSelectedMsgBlockIndex != -1)
            {
                BOOL bDeleted = FALSE;
                PSMSGBLOCKLIST psMsgCurrentBlock = nullptr;
                // Get the current message block pointer.
                psMsgCurrentBlock = pomBlocksView->psGetMsgBlockPointer(
                                        pomBlocksView->m_nSelectedMsgBlockIndex,
                                        pomBlocksView->m_psMsgBlockList );
                if(psMsgCurrentBlock != nullptr )
                {
                    // Call function to delete all message and clear the list
                    // control if the delete is successfull.
                    bDeleted = bDeleteAllMsgFromBlock(psMsgCurrentBlock);
                    if(bDeleted == TRUE )
                    {
                        m_omLctrMsgList.DeleteAllItems();
                        //Disable Delete All button
                        m_omButtonDeleteAllMsg.EnableWindow(FALSE);
                        m_omButtonDeleteSelMsg.EnableWindow(FALSE);

                        if(pomFunctionsView->m_CheckBoxAutoUpdate.GetCheck() == BST_UNCHECKED)
                        {
                            pomFunctionsView->m_omButtonApply.EnableWindow(TRUE);
                        }
                        // Update Add button status
                        pomDetailsView->vEnableAddButton( TRUE );
                        // Update Modified Flag
                        pomBlocksView->m_bModified = TRUE;
                    }
                    m_omButtonSendMsg.EnableWindow(FALSE);

                    //changes added to update the Global in case of autoupdate
                    CTxFunctionsView* pView =
                        ( CTxFunctionsView* )pomGetFunctionsViewPointer();
                    if( pView != nullptr )
                    {
                        if(pView->m_CheckBoxAutoUpdate.GetCheck() == BST_CHECKED)
                        {
                            pView->vAccessButtonApply();
                            this->SetFocus();
                        }
                    }
                }
            }
        }
    }
}
示例#9
0
void CTxMsgListView::OnDeleteSelectedMsg()
{
    CTxMsgBlocksView* pomBlocksView = nullptr;
    pomBlocksView = ( CTxMsgBlocksView*)pomGetBlocksViewPointer();

    CTxMsgDetailsView* pomDetailsView = nullptr;
    pomDetailsView = (CTxMsgDetailsView*)pomGetDetailsViewPointer();

    CTxFunctionsView* pomFunctionsView = nullptr;
    pomFunctionsView = (CTxFunctionsView*)pomGetFunctionsViewPointer();

    if( pomBlocksView != nullptr && pomDetailsView != nullptr &&
            pomFunctionsView != nullptr )
    {
        if ( AfxMessageBox( _(defDEL_SEL_MSG_FRAME),
                            MB_YESNO|MB_ICONQUESTION) == IDYES)
        {
            if(m_nSelectedMsgIndex != -1)
            {
                if(pomBlocksView->m_nSelectedMsgBlockIndex != -1 )
                {
                    PSMSGBLOCKLIST psCurrentMsgBlock = nullptr;
                    psCurrentMsgBlock = pomBlocksView->psGetMsgBlockPointer(
                                            pomBlocksView->m_nSelectedMsgBlockIndex,
                                            pomBlocksView->m_psMsgBlockList);

                    if(psCurrentMsgBlock != nullptr )
                    {
                        BOOL bReturn = FALSE;
                        bReturn = bDeleteMsgFromBlock(psCurrentMsgBlock);
                        if(bReturn == TRUE )
                        {
                            if(pomFunctionsView->m_CheckBoxAutoUpdate.GetCheck() == BST_UNCHECKED)
                                pomFunctionsView->m_omButtonApply.
                                EnableWindow(TRUE);

                            pomDetailsView->vEnableAddButton( TRUE );
                            // Update Modified Flag
                            pomBlocksView->m_bModified = TRUE;
                        }
                        // Set the focus to list control back if it is not empty
                        // Shift the selection to item under fucus as selection
                        // deos not move up if an selected item is deleted.
                        m_nSelectedMsgIndex =
                            m_omLctrMsgList.GetNextItem(-1,LVIS_FOCUSED);
                        if(m_nSelectedMsgIndex != -1 )
                        {
                            m_omLctrMsgList.SetItemState(
                                m_nSelectedMsgIndex,
                                LVIS_SELECTED,
                                LVIS_SELECTED);
                        }
                        //changes added to update the Global in case of autoupdate
                        CTxFunctionsView* pView =
                            ( CTxFunctionsView* )pomGetFunctionsViewPointer();
                        if( pView != nullptr )
                        {
                            if(pView->m_CheckBoxAutoUpdate.GetCheck() == BST_CHECKED)
                            {
                                pView->vAccessButtonApply();
                                /*this->SetFocus();*/
                                m_omLctrMsgList.SetFocus();
                            }
                        }

                    }
                }
            }
        }
    }
}
示例#10
0
void CTxMsgListView::OnSendSelectedMsg()
{
    PSTXSELMSGDATA psTxCanMsg = nullptr;
    UINT unTotalSelection = m_omLctrMsgList.GetSelectedCount();

    CTxMsgBlocksView* pomBlocksView = nullptr;
    pomBlocksView = ( CTxMsgBlocksView*)pomGetBlocksViewPointer();
    if( pomBlocksView != nullptr )
    {
        // Get the total selected count.
        if(unTotalSelection > 0 )
        {
            // create the pointer and check if it has created successfully.
            psTxCanMsg  = new STXSELMSGDATA;
            if(psTxCanMsg != nullptr )
            {
                // Fill the structure and create memory for array of message
                // frame to be transmitted.
                psTxCanMsg->m_unCount = unTotalSelection;
                psTxCanMsg->m_psTxMsg = new STCAN_MSG[unTotalSelection];
                if(psTxCanMsg->m_psTxMsg != nullptr )
                {
                    // get the current message block
                    PSMSGBLOCKLIST psMsgBlock = nullptr;
                    psMsgBlock = pomBlocksView->psGetMsgBlockPointer(
                                     pomBlocksView->m_nSelectedMsgBlockIndex,
                                     pomBlocksView->m_psMsgBlockList );
                    if(psMsgBlock != nullptr )
                    {
                        PSTXCANMSGLIST  psTxMsgList = nullptr;
                        INT nCurrentIndex           = -1;
                        // Get the message which is selected for transmission
                        // Since selection may be random so get the selection
                        // index one by one and get the pointer for that message
                        // frame . After that copy it to the structure.
                        for(UINT i =0 ; i<unTotalSelection; i++)
                        {
                            nCurrentIndex = m_omLctrMsgList.GetNextItem(
                                                nCurrentIndex,
                                                LVNI_SELECTED );
                            // If failure to get the index then assign Invalid
                            // message ID to avoid any problem in transmission.
                            if(nCurrentIndex != -1 )
                            {
                                psTxMsgList = psGetMsgDetailPointer (
                                                  nCurrentIndex,
                                                  psMsgBlock );
								updateRollingCntCheckSum(psTxMsgList);
                                if(psTxMsgList != nullptr )
                                {
                                    memcpy( &(psTxCanMsg->m_psTxMsg[i]),
                                            &(psTxMsgList->m_sTxMsgDetails.m_sTxMsg),
                                            sizeof(STCAN_MSG) );
                                }
                                else
                                {
                                    psTxCanMsg->m_psTxMsg[i].m_unMsgID =
                                        static_cast <UINT> (-1);
                                }
                            }
                            else
                            {
                                psTxCanMsg->m_psTxMsg[i].m_unMsgID =
                                    static_cast <UINT> (-1 );
                            }
                        }
                        g_bStopSelectedMsgTx = FALSE;
                        // Get handle of thread and assign it to pulic data
                        // member in app class. This will be used to terminate
                        // the thread.
                        CWinThread* pomThread = nullptr ;
                        pomThread =
                            AfxBeginThread( CTxMsgManager::s_unSendSelectedMsg,
                                            psTxCanMsg );
                        if(pomThread != nullptr  &&
                                CTxMsgManager::s_sUtilThread.m_hThread
                                == nullptr )
                        {
                            CTxMsgManager::s_sUtilThread.m_hThread
                                = pomThread->m_hThread;
                        }
                    }
                }
            }
        }
    }
}
示例#11
0
void CTxMsgListView::OnItemchangedLstcMsgDetails(NMHDR* pNMHDR,
        LRESULT* pResult)
{
    NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;

    CTxMsgBlocksView* pomBlocksView = nullptr;
    pomBlocksView = ( CTxMsgBlocksView*)pomGetBlocksViewPointer();
    if( pomBlocksView != nullptr && m_bInitDlg == FALSE )
    {
        // Get new state of the list control items
        // and check for if it is selected and focused.
        UINT unCurrentState = pNMListView->uNewState & defMASK_LIST_CTRL;
        if(pNMListView->uNewState & (LVIS_FOCUSED|LVIS_SELECTED) )
        {
            if((TRUE == CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_CONNECTED)) && (pNMListView->uNewState & LVIS_SELECTED))
                //&& (pNMListView->uNewState&LVIS_FOCUSED))
            {
                m_omButtonSendMsg.EnableWindow(TRUE);
            }
            if(FALSE == CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_SENDMESG))
            {
                m_omButtonDeleteSelMsg.EnableWindow(!CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_SENDMESG));
                m_omButtonDeleteAllMsg.EnableWindow(!CTxMsgManager::s_TxFlags.nGetFlagStatus(TX_SENDMESG));

            }
        }
        else if(pNMListView->uChanged == LVIF_STATE)
        {

            //Check for the count
            UINT unCount = m_omLctrMsgList.GetItemCount();
            if ( unCount <= 0)
            {
                m_omButtonDeleteAllMsg.EnableWindow(FALSE);
            }
            if(!(pNMListView->uNewState & defMASK_CHECK_UNCHECK))
            {
                m_omButtonSendMsg.EnableWindow(FALSE);
                m_omButtonDeleteSelMsg.EnableWindow(FALSE);
            }
        }
        if( pNMListView->uChanged  == LVIF_STATE )
        {
            PSTXCANMSGLIST   psTxMsgList = nullptr ;
            PSMSGBLOCKLIST    psMsgBlock = nullptr ;
            // check if the item is focused and selected.
            unCurrentState =
                pNMListView->uNewState &(LVIS_FOCUSED |LVIS_SELECTED);
            psMsgBlock = pomBlocksView->psGetMsgBlockPointer(
                             pomBlocksView->m_nSelectedMsgBlockIndex,
                             pomBlocksView->m_psMsgBlockList );
            // If yes, update message information for newly selected item.
            if(unCurrentState != FALSE)
            {
                psTxMsgList = psGetMsgDetailPointer( pNMListView->iItem,
                                                     psMsgBlock );
                m_nSelectedMsgIndex = pNMListView->iItem;
                if(psTxMsgList != nullptr )
                {
                    CTxMsgDetailsView* pView = (CTxMsgDetailsView*)
                                               pomGetDetailsViewPointer();
                    if( pView != nullptr )
                    {
                        pView->vSetValues((psTxMsgList));
                        // Insert Signal List Update Code Here
                        pView->bUpdateSignalList(
                            psTxMsgList->m_sTxMsgDetails.m_sTxMsg );
                        pView->vEnableAddButton( TRUE );
                        // Clear error message if any
                        pView->bSetStatusText("");
                        psMsgBlock->m_bModified = true;
                    }
                }
            }
            else
            {
                m_nSelectedMsgIndex = -1;
            }
        }
        if( pNMListView->uNewState & defMASK_CHECK_UNCHECK )
        {
            PSTXCANMSGLIST   psTxMsgList = nullptr ;
            PSMSGBLOCKLIST    psMsgBlock = nullptr ;

            psMsgBlock = pomBlocksView->psGetMsgBlockPointer(
                             pomBlocksView->m_nSelectedMsgBlockIndex,
                             pomBlocksView->m_psMsgBlockList );

            psTxMsgList = psGetMsgDetailPointer(pNMListView->iItem,psMsgBlock);
            m_nSelectedMsgIndex = pNMListView->iItem ;
            //pNMListView->uNewState =  (LVIS_FOCUSED|LVIS_SELECTED);
            //Ashwin changes for selecting the item during unchecking
            int     nChecked = 0, nUnCkecked = 0;
            for(int nCnt =0; nCnt< m_omLctrMsgList.GetItemCount(); nCnt++)
            {
                if(m_omLctrMsgList.GetCheck(nCnt) == TRUE)
                {
                    nChecked++;
                }
                else if(m_omLctrMsgList.GetCheck(nCnt) == FALSE)
                {
                    nUnCkecked++;
                }
                m_omLctrMsgList.SetItemState(nCnt, 0, LVIS_SELECTED);
            }


            if(nChecked == m_omLctrMsgList.GetItemCount())
            {
                vCheckHeaderCtrl(true);
            }
            else if(nUnCkecked == m_omLctrMsgList.GetItemCount())
            {
                vCheckHeaderCtrl(false);
            }
            m_omLctrMsgList.SetItemState(pNMListView->iItem, LVIS_SELECTED, LVIS_SELECTED);//LVIS_SELECTED

            if(psTxMsgList != nullptr )
            {
                int nCurrentState =
                    m_omLctrMsgList.GetCheck(pNMListView->iItem);
                CTxFunctionsView* pView = (CTxFunctionsView*)
                                          pomGetFunctionsViewPointer();
                if( pView != nullptr )
                {
                    if( nCurrentState !=
                            psTxMsgList->m_sTxMsgDetails.m_bEnabled )
                    {
                        psTxMsgList->m_sTxMsgDetails.m_bEnabled = nCurrentState;
                        psTxMsgList->m_bModified = true;
                        // Enable Update Button
                        if(pView->m_CheckBoxAutoUpdate.GetCheck() == BST_UNCHECKED)
                        {
                            pView->m_omButtonApply.EnableWindow();
                        }
                        psMsgBlock->m_bModified = true;
                    }
                }
                else
                {
                    m_omLctrMsgList.SetCheck( pNMListView->iItem,
                                              psTxMsgList->m_sTxMsgDetails.m_bEnabled );
                }

                if( pView != nullptr )
                {
                    if(pView->m_CheckBoxAutoUpdate.GetCheck() == BST_CHECKED)
                    {
                        pView->vAccessButtonApply();
                        this->SetFocus();
                    }
                }
            }

        }



    }
    *pResult = 0;
}
示例#12
0
void CTxMsgListView::vSetMessageCheckValue(BOOL bCheck)
{
    // Get Other View Pointers
    // Blocks View
    CTxMsgBlocksView* pomBlocksView = nullptr;
    pomBlocksView = ( CTxMsgBlocksView*)pomGetBlocksViewPointer();
    // Message Details View
    CTxMsgDetailsView* pomDetailsView = nullptr;
    pomDetailsView = (CTxMsgDetailsView*)pomGetDetailsViewPointer();
    // Functions view
    CTxFunctionsView* pomFunctionsView = nullptr;
    pomFunctionsView = (CTxFunctionsView*)pomGetFunctionsViewPointer();
    // If all pointers are valid
    if( pomBlocksView != nullptr && pomDetailsView != nullptr &&
            pomFunctionsView != nullptr )
    {
        // If selected message block index is valid
        if(pomBlocksView->m_nSelectedMsgBlockIndex != -1 )
        {
            PSMSGBLOCKLIST psCurrentMsgBlock = nullptr;
            // Get current block pointer
            psCurrentMsgBlock = pomBlocksView->psGetMsgBlockPointer(
                                    pomBlocksView->m_nSelectedMsgBlockIndex,
                                    pomBlocksView->m_psMsgBlockList );
            psCurrentMsgBlock->m_bModified = true;
            // Get the message list
            PSTXCANMSGLIST psMsgList = psCurrentMsgBlock->m_psTxCANMsgList;
            int nIndex = 0;
            // Set programmed UI update to TRUE
            BOOL bModified = FALSE;
            m_bInitDlg = TRUE;

            // Update check box status of all messages in this list
            while(psMsgList != nullptr )
            {
                if( psMsgList->m_sTxMsgDetails.m_bEnabled != bCheck )
                {
                    // Update message list
                    psMsgList->m_sTxMsgDetails.m_bEnabled = bCheck;
                    psMsgList->m_bModified = true;
                    // Update UI Control
                    m_omLctrMsgList.SetCheck( nIndex, bCheck );
                    // Update Modified flag
                    bModified = TRUE;
                }
                // Go to Next Node
                psMsgList = psMsgList->m_psNextMsgDetails;
                // Increment list item index count
                nIndex++;
            }
            // Set programmed UI update to FALSE
            m_bInitDlg = FALSE;
            // Enable Update button only if data got modified
            if( bModified == TRUE )
            {
                // If data is modified then update apply button
                if(pomFunctionsView->m_CheckBoxAutoUpdate.GetCheck() == BST_UNCHECKED)
                {
                    pomFunctionsView->m_omButtonApply.EnableWindow();
                }
            }
        }
    }
}