Суббота, Сентябрь 19, 2020

VisualStudio2010 RichEdit Client CAN

#pragma once
#include "afxwin.h"


// OptionsCom dialog

class OptionsCom : public CDialogEx
{
    DECLARE_DYNAMIC(OptionsCom)

public:
    OptionsCom(CWnd* pParent = NULL);   // standard constructor
    virtual ~OptionsCom();

// Dialog Data
    enum { IDD = IDD_OPTIONS_COM };

protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

    DECLARE_MESSAGE_MAP()
public:
    virtual BOOL OnInitDialog();
    int m_NumPort;
    CComboBox m_cbComNum;
    CComboBox m_cbComSpeed;
    int m_speed;
    virtual void OnOK();
    int GetNumPort(void);
    int GetSpeed(void);
    // //сохранение в реестре номера порта
    CString m_csSectionCOMPORT;
    CString m_csEntryPortNum;
    CString m_csEntryPortSpeed;
    int m_RegOptionsPort;
    int m_RegOptionsNum;
    int m_RegOptionSpeed;
};

// OptionsCom.cpp : implementation file
//

#include "stdafx.h"
#include "ComRichProgress.h"
#include "OptionsCom.h"
#include "afxdialogex.h"
#include "serialport.h"
int gNumPort=1;
int gSpeed=806800;
// OptionsCom dialog

IMPLEMENT_DYNAMIC(OptionsCom, CDialogEx)

OptionsCom::OptionsCom(CWnd* pParent /*=NULL*/)
    : CDialogEx(OptionsCom::IDD, pParent)
    , m_NumPort(1)
    , m_speed(806800)
    , m_csSectionCOMPORT(_T("ComPortOptions"))
    , m_csEntryPortNum(_T("PortNum"))
    , m_csEntryPortSpeed(_T("PortSpeed"))
    , m_RegOptionsPort(0)
    , m_RegOptionsNum(0)
    , m_RegOptionSpeed(0)
{

}

OptionsCom::~OptionsCom()
{
}

void OptionsCom::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_COMBO2, m_cbComNum);
    DDX_Control(pDX, IDC_COMBO3, m_cbComSpeed);
}


BEGIN_MESSAGE_MAP(OptionsCom, CDialogEx)
END_MESSAGE_MAP()


// OptionsCom message handlers


BOOL OptionsCom::OnInitDialog()
{
    CDialogEx::OnInitDialog();
    m_cbComNum.AddString(_T("COM1"));
    m_cbComNum.AddString(_T("COM2"));
    m_cbComNum.AddString(_T("COM3"));
    m_cbComNum.AddString(_T("COM4"));
    m_cbComNum.AddString(_T("COM5"));
    m_cbComNum.AddString(_T("COM6"));
    m_cbComNum.AddString(_T("COM7"));
    m_cbComNum.AddString(_T("COM8"));
    m_cbComNum.AddString(_T("COM9"));
    m_cbComNum.AddString(_T("COM10"));
    m_cbComNum.AddString(_T("COM11"));
    m_cbComNum.AddString(_T("COM12"));
    m_cbComNum.AddString(_T("COM13"));
    m_cbComNum.AddString(_T("COM14"));
    m_cbComNum.AddString(_T("COM15"));
    m_cbComNum.AddString(_T("COM16"));
    m_cbComNum.AddString(_T("COM17"));
    m_cbComNum.AddString(_T("COM18"));
    m_cbComNum.AddString(_T("COM19"));
    m_cbComNum.AddString(_T("COM20"));
    m_cbComNum.AddString(_T("COM21"));
    m_cbComNum.AddString(_T("COM22"));
    m_cbComNum.AddString(_T("COM23"));
    m_cbComNum.AddString(_T("COM24"));
    m_cbComNum.AddString(_T("COM25"));
    m_cbComNum.AddString(_T("COM26"));
    m_cbComNum.AddString(_T("COM27"));
    m_cbComNum.AddString(_T("COM28"));
    m_cbComNum.AddString(_T("COM29"));
    m_cbComNum.AddString(_T("COM30"));
    m_cbComNum.SetCurSel(0);

    m_cbComSpeed.AddString(_T("1200"));
    m_cbComSpeed.AddString(_T("1800"));
    m_cbComSpeed.AddString(_T("2400"));
    m_cbComSpeed.AddString(_T("4800"));
    m_cbComSpeed.AddString(_T("7200"));
    m_cbComSpeed.AddString(_T("9600"));
    m_cbComSpeed.AddString(_T("14400"));
    m_cbComSpeed.AddString(_T("19200"));
    m_cbComSpeed.AddString(_T("38400"));
    m_cbComSpeed.AddString(_T("57600"));
    m_cbComSpeed.AddString(_T("115200"));
    m_cbComSpeed.AddString(_T("230400"));
    m_cbComSpeed.AddString(_T("460800"));
    m_cbComSpeed.AddString(_T("806800"));
    m_cbComSpeed.SetCurSel(0);
    return TRUE;  // return TRUE unless you set the focus to a control
    // EXCEPTION: OCX Property Pages should return FALSE
}


void OptionsCom::OnOK()
{
    CWinApp* pRegedit=AfxGetApp();

    m_RegOptionsPort=m_cbComNum.GetCurSel()+1;
    pRegedit->WriteProfileInt(m_csSectionCOMPORT,m_csEntryPortNum,m_RegOptionsPort);

    CString tmp;
    m_cbComSpeed.GetLBText(m_cbComSpeed.GetCurSel(),tmp);
    m_RegOptionSpeed=_ttoi((LPCWSTR)tmp);
    pRegedit->WriteProfileInt(m_csSectionCOMPORT,m_csEntryPortSpeed,m_RegOptionSpeed);

    CSerialPort test;
    try{
        test.Open(m_RegOptionsPort,m_RegOptionSpeed,CSerialPort::NoParity,8,CSerialPort::OneStopBit);
        MessageBeep(0);
        test.Close();
    }
    catch (CSerialException* pEx)
    {
        MessageBox(_T("Нет такого COM порта ! Проверить в Оборудовании компа какой COM порт!"),MB_OK,MB_ICONERROR);
        TRACE(_T("Handle Exception, Message:%s\n"), pEx->GetErrorMessage());
        pEx->Delete();
    }
    
    CDialogEx::OnOK();
}


int OptionsCom::GetNumPort(void)
{
    return gNumPort;
}


int OptionsCom::GetSpeed(void)
{
    return gSpeed;
}


#pragma once
#include "afxwin.h"


// ScanerDialog dialog

class ScanerDialog : public CDialogEx
{
    DECLARE_DYNAMIC(ScanerDialog)

public:
    ScanerDialog(CWnd* pParent = NULL);   // standard constructor
    virtual ~ScanerDialog();

// Dialog Data
    enum { IDD = IDD_DIALOG_SCANER };

protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
    DECLARE_MESSAGE_MAP()
private:
    // Указатель на индикатор прогресса
    CProgressCtrl   *m_pProgressCtrl;
    // Возвращаемое значение для SetTimer
    UINT_PTR        m_nTimer;
    // Счетчик запусков таймера
    unsigned int    m_nCount;
    // Максимальное число запусков таймера
    unsigned int nMaxCount;
public:
    afx_msg void OnTimer(UINT_PTR nIDEvent);
    
    afx_msg void OnBnClickedCancel();
    afx_msg void OnBnClickedOk();
    CComboBox m_cbComboTime;
    virtual BOOL OnInitDialog();
    CListBox m_ListBox;
    int m_index;
    int m_NumPort;
    int m_COMSpeed;
    CEdit m_HIDS1;
    CEdit m_HIDS2;
    CEdit m_HIDS3;
    CEdit m_HIDS4;
    CEdit m_HIDS5;
    CEdit m_HIDS6;
    afx_msg void OnBnClickSetFilter();
    CString m_csSectionCOMPORT;
    CString m_csEntryPortNum;
    CString m_csEntryPortSpeed;
    int m_RegOptionPort;
    int m_RegOptionSpeed;

    afx_msg void OnBnClickedSendByte();
    afx_msg void OnBnClickedButton2();
    afx_msg void OnBnClickedButtonStop();
    afx_msg void OnBnClickedButton3();
    afx_msg void OnBnClickedButton4();
    afx_msg void OnBnClickedButton5();
    afx_msg void OnBnClickedButtonReset();
};
UINT __cdecl ReadSerial(LPVOID pParam);
char* HexToASCII(char* sour, char* dest, int len);

// ScanerDialog.cpp : implementation file
//

#include "stdafx.h"
#include "ComRichProgress.h"
#include "ScanerDialog.h"
#include "afxdialogex.h"
#include <fstream>
#include <conio.h>
#include"serialport.h"
#include"OptionsCom.h"
#include <iostream>
#include <io.h>
#include <fcntl.h>
BOOL ThreedBegin = 0;
CString fName=_T(".\\CANLOG.txt");
CSerialPort port;
std::ofstream f;
CString g_HIDS1=0;
CString g_HIDS2=0;
CString g_HIDS3=0;
CString g_HIDS4=0;
CString g_HIDS5=0;
CString g_HIDS6=0;

CString g_tHIDS1=0;
CString g_tHIDS2=0;
CString g_tHIDS3=0;
CString g_tHIDS4=0;
CString g_tHIDS5=0;
CString g_tHIDS6=0;
char wbyte[2]={0x39};
BOOL CreateReadConsole(void)
{
    FreeConsole();        //на всякий случай
    if ( AllocConsole() ) {
        int  hCrt = _open_osfhandle((long)
                                    GetStdHandle(STD_INPUT_HANDLE), _O_TEXT);
        *stdin = *(::_fdopen(hCrt, "r"));
        ::setvbuf(stdin, NULL, _IONBF, 0);
        hCrt = _open_osfhandle((long)
                               GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);
        *stdout = *(::_fdopen(hCrt, "w"));
        ::setvbuf(stdout, NULL, _IONBF, 0);
        *stderr = *(::_fdopen(hCrt, "w"));
        ::setvbuf(stderr, NULL, _IONBF, 0);
        return TRUE;
    }return FALSE;
}
// ScanerDialog dialog
IMPLEMENT_DYNAMIC(ScanerDialog, CDialogEx)

ScanerDialog::ScanerDialog(CWnd* pParent /*=NULL*/)
    : CDialogEx(ScanerDialog::IDD, pParent)
    , m_nTimer(0)
    , m_index(0)
    , m_NumPort(0)
    , m_COMSpeed(0)
    , m_csSectionCOMPORT(_T("ComPortOptions"))
    , m_csEntryPortNum(_T("PortNum"))
    , m_csEntryPortSpeed(_T("PortSpeed"))
{
    m_nCount=0;
    nMaxCount=100;
    CWinApp* pRegedit=AfxGetApp();
    m_RegOptionPort=pRegedit->GetProfileIntW(m_csSectionCOMPORT,
        m_csEntryPortNum,0);
    m_RegOptionSpeed=pRegedit->GetProfileIntW(m_csSectionCOMPORT,
        m_csEntryPortSpeed,0);
}

ScanerDialog::~ScanerDialog()
{
}

void ScanerDialog::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_COMBO1, m_cbComboTime);
    DDX_Control(pDX, IDC_LIST1, m_ListBox);
    DDX_Control(pDX, IDC_EDIT1, m_HIDS1);
    DDX_Control(pDX, IDC_EDIT2, m_HIDS2);
    DDX_Control(pDX, IDC_EDIT3, m_HIDS3);
    DDX_Control(pDX, IDC_EDIT4, m_HIDS4);
    DDX_Control(pDX, IDC_EDIT5, m_HIDS5);
    DDX_Control(pDX, IDC_EDIT6, m_HIDS6);
}


BEGIN_MESSAGE_MAP(ScanerDialog, CDialogEx)
    ON_WM_TIMER()
    ON_BN_CLICKED(IDCANCEL, &ScanerDialog::OnBnClickedCancel)
    ON_BN_CLICKED(IDOK, &ScanerDialog::OnBnClickedOk)
    ON_BN_CLICKED(IDC_BUTTON1, &ScanerDialog::OnBnClickSetFilter)
    ON_BN_CLICKED(IDC_SEND_BYTE, &ScanerDialog::OnBnClickedSendByte)
    ON_BN_CLICKED(IDC_BUTTON2, &ScanerDialog::OnBnClickedButton2)
    ON_BN_CLICKED(IDC_BUTTON_STOP, &ScanerDialog::OnBnClickedButtonStop)
    ON_BN_CLICKED(IDC_BUTTON3, &ScanerDialog::OnBnClickedButton3)
    ON_BN_CLICKED(IDC_BUTTON4, &ScanerDialog::OnBnClickedButton4)
    ON_BN_CLICKED(IDC_BUTTON5, &ScanerDialog::OnBnClickedButton5)
    ON_BN_CLICKED(IDC_BUTTON_RESET, &ScanerDialog::OnBnClickedButtonReset)
END_MESSAGE_MAP()


// ScanerDialog message handlers


//Процесс чтения байтов из компорта
UINT ReadSerial(LPVOID pParam)
{
    char readByte[1]={0};
    char asc[3]={0};
    int count=0;
    char tempBuf[12];
    COMSTAT stat;
    CreateReadConsole();
skip:while (ThreedBegin)
    {
        port.GetStatus(stat);
        //stat.cbInQue-Количество байт принято больше или равно 13
        if(stat.cbInQue>=13)
        {
        for(count=0;count<=12;count++)
            {
                
                port.Read(readByte,1);
                HexToASCII(readByte,asc,1);
                if(count==0)
                {
                    if(g_HIDS1==asc)
                    {
                        port.ReadEx(tempBuf,12);
                        goto skip;
                    }
                    if(g_HIDS2==asc)
                    {
                        port.ReadEx(tempBuf,12);
                        goto skip;
                    }
                    if(g_HIDS3==asc)
                    {
                        port.ReadEx(tempBuf,12);
                        goto skip;
                    }
                    if(g_HIDS4==asc)
                    {
                        port.ReadEx(tempBuf,12);
                        goto skip;
                    }
                    if(g_HIDS5==asc)
                    {
                        port.ReadEx(tempBuf,12);
                        goto skip;
                    }
                    if(g_HIDS6==asc)
                    {
                        port.ReadEx(tempBuf,12);
                        goto skip;
                    }
                }
                f<<asc[0];
                f<<asc[1];
                std::cout<<asc[0];
                std::cout<<asc[1];
                f<<' ';
                std::cout<<' ';
                if(count==1)
                {
                    f<<' ';
                    f<<' ';
                    std::cout<<' ';
                    std::cout<<' ';
                }
                else if(count==3)
                {
                    f<<' ';
                    f<<' ';
                    std::cout<<' ';
                    std::cout<<' ';
                }
                else if(count==4)
                {
                    f<<' ';
                    f<<' ';
                    std::cout<<' ';
                    std::cout<<' ';
                }
            }
            f<<'\n';
            std::cout<<std::endl;
        }
    }
     FreeConsole();
    return 0;
}

void ScanerDialog::OnTimer(UINT_PTR nIDEvent)
{
    if (m_nCount > nMaxCount)
    {
        // Индикатор прогресса работу закончил
        ASSERT(KillTimer(0));
        ThreedBegin = 0;
        Sleep(500);

        if(f.is_open())
            f.close();
        Sleep(500);

        if(port.IsOpen())
            port.Close();
        CDialogEx::OnOK();
        return afx_msg void();
    }
    //Делаем кнопки не активными
    GetDlgItem(IDCANCEL)->EnableWindow(0);
    GetDlgItem(IDOK)->EnableWindow(0);
    m_nCount++;
    // Обновляем состояние индикатора прогресса
    m_pProgressCtrl = static_cast< CProgressCtrl * >(GetDlgItem(IDC_PROGRESS1));
    m_pProgressCtrl->SetPos(m_nCount * 100 / nMaxCount);
    
    CDialog::OnTimer(nIDEvent);
}


void ScanerDialog::OnBnClickedCancel()
{
    CDialogEx::OnCancel();
}


void ScanerDialog::OnBnClickedOk()
{
    if ((m_nCount > 0) && (m_nCount < nMaxCount))
         return afx_msg void();
    try{
        port.Open(m_RegOptionPort,m_RegOptionSpeed,CSerialPort::NoParity,8,
            CSerialPort::OneStopBit,CSerialPort::NoFlowControl,0);
     }
     catch (CSerialException* pEx)
    {
        MessageBox(_T("Нет такого COM порта ! Проверить в Оборудовании компа какой COM порт!"),MB_OK,MB_ICONERROR);
        TRACE(_T("Handle Exception, Message:%s\n"), pEx->GetErrorMessage());
        pEx->Delete();
        return;
    }
     f.open(fName,std::ios::out);
     if(!f)
     {
         MessageBox(_T("Файл не создан"));
         return afx_msg void();
     }
     int num=m_cbComboTime.GetCurSel();
     switch(num)
     {
     case 0:
         nMaxCount=50;
         break;
     case 1:
         nMaxCount=200;
         break;
     case 2:
         nMaxCount=300;
         break;
     case 3:
         nMaxCount=400;
         break;
     case 4:
         nMaxCount=500;
         break;
     case 5:
         nMaxCount=600;
         break;
     case 6:
         nMaxCount=700;
         break;
     case 7:
         nMaxCount=800;
         break;
     case 8:
         nMaxCount=900;
         break;
     case 9:
         nMaxCount=1200;
         break;
     case 10:
         nMaxCount=12000;
         break;
     default:
         nMaxCount=100;
         break;
     }
     m_nCount = 0;
     // Запускаем таймер с интервалом 0.1 секунды
     m_nTimer = SetTimer(0, 100, NULL);
     ASSERT(m_nTimer);
     ThreedBegin = 1;
     AfxBeginThread(ReadSerial, this);
}


BOOL ScanerDialog::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    // TODO:  Add extra initialization here
    m_cbComboTime.AddString(_T("0,1 мин."));
    m_cbComboTime.AddString(_T("0,2 мин."));
    m_cbComboTime.AddString(_T("0,3 мин."));
    m_cbComboTime.AddString(_T("0,4 мин."));
    m_cbComboTime.AddString(_T("0,8 мин."));
    m_cbComboTime.AddString(_T("1,0 мин."));
    m_cbComboTime.AddString(_T("1,2 мин."));
    m_cbComboTime.AddString(_T("1,4 мин."));
    m_cbComboTime.AddString(_T("1,6 мин."));
    m_cbComboTime.AddString(_T("2,0 мин."));
    m_cbComboTime.AddString(_T("10,0 мин."));
    m_cbComboTime.SetCurSel(0);
    m_HIDS1.SetLimitText(2);
    m_HIDS2.SetLimitText(2);
    m_HIDS3.SetLimitText(2);
    m_HIDS4.SetLimitText(2);
    m_HIDS5.SetLimitText(2);
    m_HIDS6.SetLimitText(2);

    m_ListBox.AddString(g_HIDS1);
    m_ListBox.AddString(g_HIDS2);
    m_ListBox.AddString(g_HIDS3);
    m_ListBox.AddString(g_HIDS4);
    m_ListBox.AddString(g_HIDS5);
    m_ListBox.AddString(g_HIDS6);
    return TRUE;  // return TRUE unless you set the focus to a control
    // EXCEPTION: OCX Property Pages should return FALSE
}
char* HexToASCII(char* sour, char* dest, int len)
{
    int i;
    char tmp;
    int j=0;
    for(i=0;i<len;i++){
        tmp=((sour[i]>>4)&0x0f);
        if(tmp<=9){
            dest[j]=tmp+0x30;
        }
        else if(tmp>=0x0A && tmp<=0x0F){
            dest[j]=tmp+0x37;
        }
        j++;
        tmp=sour[i];
        tmp=tmp &= 0x0f;
        if(tmp<=9){
            dest[j]=tmp+0x30;
        }
        else if(tmp>=0x0A && tmp<=0x0F){
            dest[j]=tmp+0x37;
        }
        j++;
    }
    dest[j]=0;
    return dest;
}

void ScanerDialog::OnBnClickSetFilter()
{
    m_ListBox.ResetContent();
    m_HIDS1.GetLine(0,g_HIDS1.GetBuffer(2),2);
    m_ListBox.AddString(g_HIDS1);
    m_HIDS2.GetLine(0,g_HIDS2.GetBuffer(2),2);
    m_ListBox.AddString(g_HIDS2);
    m_HIDS3.GetLine(0,g_HIDS3.GetBuffer(2),2);
    m_ListBox.AddString(g_HIDS3);
    m_HIDS4.GetLine(0,g_HIDS4.GetBuffer(2),2);
    m_ListBox.AddString(g_HIDS4);
    m_HIDS5.GetLine(0,g_HIDS5.GetBuffer(2),2);
    m_ListBox.AddString(g_HIDS5);
    m_HIDS6.GetLine(0,g_HIDS6.GetBuffer(2),2);
    m_ListBox.AddString(g_HIDS6);
}

void ScanerDialog::OnBnClickedButtonStop()
{
    wbyte[0]=0x39;
    if(port.IsOpen())
    {
        std::cout<<wbyte<<std::endl;
        port.Write(wbyte,1);
    }
}
void ScanerDialog::OnBnClickedSendByte()
{
    
    char t_wbyte[40]={0x30,0xfc,0x00,0x00,0x00,0x08, 0x01,0x20,0x00,0x00,0x00,0x00,0x00,0x00};
//FC 00   00 00   08   01 20 00 00 00 00 00 00 \par
//FD 00   00 00   08   01 60 00 00 00 00 00 00

    if(port.IsOpen())
    {
        std::cout<<t_wbyte<<std::endl;
        port.Write(t_wbyte,14);
    }
}


void ScanerDialog::OnBnClickedButton2()
{
    wbyte[0]=0x32;
    if(port.IsOpen())
    {
        std::cout<<wbyte<<std::endl;
        port.Write(wbyte,1);
    }
}

void ScanerDialog::OnBnClickedButton3()
{
    wbyte[0]=0x33;
    if(port.IsOpen())
    {
        std::cout<<wbyte<<std::endl;
        port.Write(wbyte,1);
    }
}


void ScanerDialog::OnBnClickedButton4()
{
    wbyte[0]=0x34;
    if(port.IsOpen())
    {
        std::cout<<wbyte<<std::endl;
        port.Write(wbyte,1);
    }
}


void ScanerDialog::OnBnClickedButton5()
{
    wbyte[0]=0x35;
    if(port.IsOpen())
    {
        std::cout<<wbyte<<std::endl;
        port.Write(wbyte,1);
    }
}


void ScanerDialog::OnBnClickedButtonReset()
{
    
    m_nCount=nMaxCount;
}



// ComRichProgressView.cpp : implementation of the CComRichProgressView class
//

#include "stdafx.h"
// SHARED_HANDLERS can be defined in an ATL project implementing preview, thumbnail
// and search filter handlers and allows sharing of document code with that project.
#ifndef SHARED_HANDLERS
#include "ComRichProgress.h"
#endif

#include "ComRichProgressDoc.h"
#include "CntrItem.h"
#include "resource.h"
#include "ComRichProgressView.h"
#include"ScanerDialog.h"
#include"OptionsCom.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CComRichProgressView

IMPLEMENT_DYNCREATE(CComRichProgressView, CRichEditView)

BEGIN_MESSAGE_MAP(CComRichProgressView, CRichEditView)
    ON_WM_DESTROY()
    // Standard printing commands
    ON_COMMAND(ID_FILE_PRINT, &CRichEditView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_DIRECT, &CRichEditView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CComRichProgressView::OnFilePrintPreview)
    ON_WM_CONTEXTMENU()
    ON_WM_RBUTTONUP()
    ON_COMMAND(ID_SCANER_DIALOG, &CComRichProgressView::OnScanerDialog)
    ON_COMMAND(ID_CANBUS_OPTIONS, &CComRichProgressView::OnCanbusOptions)
    ON_COMMAND(ID_CANBUS_OPTIONS_COM, &CComRichProgressView::OnCanbusOptionsCom)
    ON_COMMAND(ID_FORMAT, &CComRichProgressView::OnFormat)
END_MESSAGE_MAP()

// CComRichProgressView construction/destruction

CComRichProgressView::CComRichProgressView()
{
    // TODO: add construction code here

}

CComRichProgressView::~CComRichProgressView()
{
}

BOOL CComRichProgressView::PreCreateWindow(CREATESTRUCT& cs)
{
    // TODO: Modify the Window class or styles here by modifying
    //  the CREATESTRUCT cs
    

    return CRichEditView::PreCreateWindow(cs);
}

void CComRichProgressView::OnInitialUpdate()
{
    CRichEditView::OnInitialUpdate();

    
    // Set the printing margins (720 twips = 1/2 inch)
    SetMargins(CRect(720, 720, 720, 720));
}


// CComRichProgressView printing


void CComRichProgressView::OnFilePrintPreview()
{
#ifndef SHARED_HANDLERS
    AFXPrintPreview(this);
#endif
}

BOOL CComRichProgressView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // default preparation
    return DoPreparePrinting(pInfo);
}


void CComRichProgressView::OnDestroy()
{
    // Deactivate the item on destruction; this is important
    // when a splitter view is being used
   COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
   if (pActiveItem != NULL && pActiveItem->GetActiveView() == this)
   {
      pActiveItem->Deactivate();
      ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
   }
   CRichEditView::OnDestroy();
}


void CComRichProgressView::OnRButtonUp(UINT /* nFlags */, CPoint point)
{
    ClientToScreen(&point);
    OnContextMenu(this, point);
}

void CComRichProgressView::OnContextMenu(CWnd* /* pWnd */, CPoint point)
{
#ifndef SHARED_HANDLERS
    theApp.GetContextMenuManager()->ShowPopupMenu(IDR_POPUP_EDIT, point.x, point.y, this, TRUE);
#endif
}


// CComRichProgressView diagnostics

#ifdef _DEBUG
void CComRichProgressView::AssertValid() const
{
    CRichEditView::AssertValid();
}

void CComRichProgressView::Dump(CDumpContext& dc) const
{
    CRichEditView::Dump(dc);
}

CComRichProgressDoc* CComRichProgressView::GetDocument() const // non-debug version is inline
{
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CComRichProgressDoc)));
    return (CComRichProgressDoc*)m_pDocument;
}
#endif //_DEBUG

// My callback procedure that reads the rich edit control contents
// from a file.
static DWORD CALLBACK
MyStreamInCallback(DWORD dwCookie, LPBYTE pbBuff, LONG cb, LONG *pcb)
{
    CFile* pFile = (CFile*)dwCookie;
    *pcb = pFile->Read(pbBuff, cb);
    return 0;
}
// CComRichProgressView message handlers


void CComRichProgressView::OnScanerDialog()
{
    ScanerDialog dlg;
    dlg.DoModal();
    CRichEditCtrl &theEdit = GetRichEditCtrl();
    CFile cFile(TEXT("CANLOG.txt"), CFile::modeRead);
    if(!cFile)
    {
        MessageBox(_T("Нет файла CANLOG.txt !!!"),MB_OK,MB_ICONERROR);
        return;
    }
    
/////////////////////////////////////////////////////////////
    USES_CONVERSION;

    CHARFORMAT2W cf;
    cf.szFaceName[0] = NULL;
    cf.dwMask = CFM_FACE | CFM_CHARSET;

    cf.bCharSet = RUSSIAN_CHARSET;
    cf.bPitchAndFamily = FF_MODERN;

    theEdit.SetDefaultCharFormat(cf);
    theEdit.SetFocus ();

    
////////////////////////////////////////////////////////////////
    EDITSTREAM es;
    es.dwCookie = (DWORD)&cFile;
    es.pfnCallback = MyStreamInCallback;
    theEdit.StreamIn(SF_TEXT, es);
    MessageBeep(0);
}


void CComRichProgressView::OnCanbusOptions()
{
    // TODO: Add your command handler code here
}


void CComRichProgressView::OnCanbusOptionsCom()
{
    OptionsCom dlg;
    dlg.DoModal();
}

//Создать SDI проект в MFC. В последнем окне мастера выбрать для C...View класса
//базовый класс CRichEditView.В ресурсах выбрать String Table и добавить две
//строки IDC_FONTNAME и IDC_FONTSIZE.Добавить в Меню пункт меню например Format
//добавить обработчик сообщения на этот пункт.
void CComRichProgressView::OnFormat()
{
    USES_CONVERSION;

    CMFCToolBarFontComboBox* pSrcCombo =
        (CMFCToolBarFontComboBox*) CMFCToolBarComboBoxButton::GetByCmd (IDC_FONTNAME, TRUE);
    if (pSrcCombo == NULL)
    {
        CRichEditView::OnFormatFont ();
        return;
    }

    CHARFORMAT2W cf;
    cf.szFaceName[0] = NULL;
    cf.dwMask = CFM_FACE | CFM_CHARSET;

    const CMFCFontInfo* pDesc = pSrcCombo->GetFontDesc ();
    ASSERT_VALID (pDesc);
    ASSERT(pDesc->m_strName.GetLength() < LF_FACESIZE);

    lstrcpyn(cf.szFaceName, pDesc->m_strName, LF_FACESIZE);

    cf.bCharSet = pDesc->m_nCharSet;
    cf.bPitchAndFamily = pDesc->m_nPitchAndFamily;

    CMFCToolBarFontSizeComboBox* pSizeCombo =
        DYNAMIC_DOWNCAST (CMFCToolBarFontSizeComboBox, CMFCToolBarFontSizeComboBox::GetByCmd (IDC_FONTSIZE));
    if (pSizeCombo != NULL)
    {
        int nSize = pSizeCombo->GetTwipSize();
        pSizeCombo->RebuildFontSizes (pDesc->m_strName);
        pSizeCombo->SetTwipSize (nSize);
    }

    SetCharFormat (cf);
    SetFocus ();
}


void CComRichProgressView::OnDraw(CDC* pDC)
{
}


Back to Top