SDC C-Project CF Review 프로그램
LYW
2021-07-23 a6552335164ce062567b76aa7d097fd046129474
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
#pragma once
 
#include "akGraph/akGraphLinker.h"
 
#include "akGraph/akMemDC.h"
#include "akGraph/akGraphStruct.h"
#include "akGraph/akSyncObject.h"
#include "akSTL/akStruct.h"
 
 
// akGraphBase
 
#define AKGRAPH_BUTTONDOWN WM_USER+0x1001
#define AKGRAPH_MOUSEMOVE WM_USER+0x1002
 
 
#include <process.h>
class AFX_EXT_CLASS CakGraphThreadDraw;
 
class AFX_EXT_CLASS  CakGraphBase :  public CWnd, public CakSyncObject
{
    DECLARE_DYNAMIC(CakGraphBase)
 
public:
    CakGraphBase();
    virtual ~CakGraphBase();
 
protected:
    DECLARE_MESSAGE_MAP()
 
 
    CakMouseState m_MouseState;
 
 
public:
    virtual BOOL CreateGraph(CWnd* pParent, CRect rect);
    
    virtual void RenderBegin(CDC* pDC, CRect rectDC);
    virtual void RenderGrid(Graphics* grfx, CDC* pDC){};
    virtual void RenderDataArea(Graphics* grfx, CDC* pDC); //µ¥ÀÌÅÍ ¿µ¿ª ±×¸®±â
    virtual void RenderSeries(Graphics* grfx, CDC* pDC){}; //µ¥ÀÌÅÍ ¼±/¹Ù ±×¸®±â
    virtual void RenderLegend(Graphics* grfx, CDC* pDC){}; //¹ü·Ê
    virtual void RenderAxis(Graphics* grfx, CDC* pDC); //Ãà ¿µ¿ª ±×¸®±â
    virtual void RenderTitle(Graphics* grfx, CDC* pDC); //Á¦¸ñ ¿µ¿ª ±×¸®±â
    virtual void RenderLabel(Graphics* grfx, CDC* pDC){}; //ÇØ´ç Ãà¿¡ Æ½±×¸®±â, µ¥ÀÌÅÍ ¿µ¿ª ¿Ü°¢¼± ±×¸®±â
    virtual void RenderEnd(Graphics* grfx, CDC* pDC); //±×¸®´Â ºÎºÐ ¸¶Áö¸·¿¡ Ãß°¡(Redraw false ÇÒ¶§µµ ±×¸²)
    virtual void RenderClossLine(CDC* pDC); //¸¶¿ì½º Å©·Î½º ¶óÀΠ±×¸®±â [±èÅÂÇö 2018/9/7]
    virtual void RenderMouseHoverInfo(CDC* pDC){}; //¸¶¿ì½º ¿Ã·ÁÁ® ÀÖÀ» °æ¿ì µ¥ÀÌÅÍÇ¥½Ã ±×¸®±â [±èÅÂÇö 2018/9/7]
 
    virtual void RenderPerformance(Graphics* grfx, CDC* pDC); 
    
    virtual void GetRenderFrame(CDC* pDC, CRect rect);
 
    virtual void ReDraw(bool bReDrawALL = true);
    
    virtual void SetAutoScale(){}; //ÀÌ·±°Ç ±âº»ÀûÀ¸·Î ÀÖ¾î¾ßµÊ!!
 
    virtual void SetTitle(char* titlename);
    virtual char* GetTitle();
    virtual void SetAxisXTitle(char* titlename){m_AxisX.m_strTitle = titlename;};
    virtual void SetAxisYTitle(char* titlename){m_AxisY.m_strTitle = titlename;};
 
    virtual void OnKeyInput(int key, int mode); //mode 0==keyup, mode 1==keydown //Űº¸µå ÀԷ À̺¥Æ® Ã³¸®
    virtual void OnMouseInput(akMouseEvent mouseevent, CPoint point); //¸¶¿ì½º ÀԷ À̺¥Æ®Ã³¸®
    virtual void MouseInput(CakMouseState mousestate){}; //¸¶¿ì½º »óÅÂó¸®
    virtual void OnSystemKeyInput(int key, int mode); //mode 0==keyup, mode 1==keydown //Űº¸µå ÀԷ À̺¥Æ® Ã³¸®
 
    virtual void EnableThreadDrawMode(int nSleepTime = 30, int nSleepTimeMin = 1);//Çѹø Å°¸é ³¡
    void SetDragStyle(akDragStyle style){m_DragStyle = style;} ; //0Àº ²ô±â, 1Àº ¾çÂʸðµÎ, 2Àº ¼¼·Î¼±¸¸, 3´Â °¡·Î¼±¸¸
    akDragStyle GetDragStyle(){return m_DragStyle;};
    CPoint GetMousePos(){return m_MouseState.Point;};
 
    void SetWindowSize(int x, int y, int width, int height, UINT flag = NULL, bool reDraw = true);
    void SetWindowSize(int width, int height, UINT flag = NULL, bool reDraw = true);
    void GetWindowSize(int* width, int* height);
 
    inline CakRect GetDataArea(){return m_rectData;};
    inline CakRect GetTitleArea(){return m_rectTitle;};
    inline CakRect GetAxisXArea(){return m_rectAxisX;};
    inline CakRect GetAxisYArea(){return m_rectAxisY;};
 
    void SetTitleSize(int height);//ŸÀÌÆ²¹Ù ¼¼·ÎÃà Å©±â
    void SetAxisXSize(int height);//xÃà ¼¼·Î Å©±â
    void SetAxisYSize(int width);//yÃà °¡·Î Å©±â
 
    void SetSaveImage(char* strFilepathname); 
 
    void SetClossLine(bool flag = true){m_bClossLine = flag;};
 
    //¸¶¿ì½º Á¦¾î ¸ðµå(0:¿ìŬ¸¯ À̵¿¸ðµå, 1:ÁÂŬ¸¯ À̵¿¸ðµå) [±èÅÂÇö 2018/8/22]
    void SetMouseControlMode(int nType){m_nMouseControlMode = nType;};
    inline void SetID(int nID);
    inline int GetID();
 
    virtual void FuncThreadDraw();
protected:
    virtual void CaculatorGraphSize();
    virtual void getLbuttonDragPoint(int* px1, int* py1, int* px2, int* py2);
 
    
private:
    
 
public:
    int m_nID;//¸Þ¼¼Áö º¸³¾¶§ °°ÀÌ º¸³»Áָ鼭.. ÀνºÅϽº¸¦ ±¸ºÐÇÑ´Ù.
 
    CAxis m_AxisX;
    CAxis m_AxisY;
    CAxis m_AxisY2;//¿À¸¥ÂÊ y°ø°£
 
    CTitle m_Title;
 
    CMouseMoveInfo m_MouseMoveInfo;//¸¶¿ì½º ¿òÁ÷ÀÓ¿¡ µû¶ó È­¸é¿¡ Ç¥½ÃµÇ´Â ³»¿ë
 
    CakRectd m_AutoScaleMarginRate;//ÀÚµ¿½ºÄÉÀÏ ¾ç¿· ¾Æ·¡,À§ ¿©¹é ºñÀ² ¼³Á¤
    CakRect m_rectLabelAdjust;
 
    bool m_bCheckDC; //¿Ã¹Ù¸¥ DCÀΰ¡ È®ÀΠÀýÂ÷¸¦ »ý·«ÇÒ °ÍÀÎÁö ¿©ºÎ
 
    bool m_bClossLine;
 
    int     m_nMouseControlMode;
 
    CakGraphThreadDraw* m_pThreadDraw;
protected:
    CWnd* m_pParent; //ºÎ¸ð À©µµ¿ì Å¬·¡½º
 
    
 
    //¸Þ¸ð¸® µð¾¾~
    CDC m_GraphDC; 
    CBitmap m_GraphBitmap, *m_pGraphOldBitmap;
    CRect m_rectGraphBitmap;
 
    //±×·¡ÇÁ ´Ù½Ã ±×·Á¾ß ÇÒ¶§
    bool m_bReRender; 
    
    //±×¸®´Â ºÎºÐ ¿µ¿ª Å©±â
    int m_nWindowSizeWidth, m_nWindowSizeHeight;
 
    //±×¸®´Â ¿µ¿ª °¢°¢ÀÇ Å©±â(¸Å¹ø CaculatorGraphSize() ÇÔ¼ö¿¡ ÀÇÇØ °è»êÀÌ µÈ´Ù)
    CakRect m_rectData; //¼ø¼öÇϰԠ±×·¡ÇÁ ±×¸®´Â ºÎºÐ ¿µ¿ª
    CakRect m_rectChartMargin; //µ¥ÀÌÅÍ ±×¸®´Â ºÎºÐ ¿À¸¥ÂÊ ¿©¹é
    CakRect m_rectAxisX;
    CakRect m_rectAxisY;
    CakRect m_rectTitle;
 
    
    CFont m_fontData; //µ¥ÀÌÅÍ ÆùÆ® 
 
    bool m_bRenderState;
    bool m_bHover;
 
public:
    COLORREF m_colorBack; //¹è°æ»ö
    COLORREF m_colorDataArea; //µ¥ÀÌÅÍ ±×¸®´ÂºÎºÐ ¹è°æ»ö
protected:
    akDragStyle m_DragStyle;
private:
    CFont m_fontWaterMake;
    ULONG_PTR m_gdiplusToken; //GDI+ ÅäÅ«
    CString m_strSaveFilePath;
 
    //¼º´É Ã¼Å© °ü·Ã
private:
    int m_nShowPerformance;
    int m_nTimeRenderTotal;
    int m_nTimeRenderDraw1stBuffer;
    int m_nTimeRenderDraw2ndBuffer;
 
    int m_nTimeTempTotal;
    int m_nTimeTempDraw1stBuffer;
    int m_nTimeTempDraw2ndBuffer;
    int m_nTimeRenderCount;
 
    int m_nTimerRenderTotalMax;
    int m_nTimerRenderTotalMin;
    
    
    
public:
    static bool m_bAK;
    static void setAK(){CakGraphBase::m_bAK = false;};
    afx_msg void OnPaint();
    afx_msg void OnSize(UINT nType, int cx, int cy);
    virtual BOOL PreTranslateMessage(MSG* pMsg);
    
    afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
    afx_msg BOOL OnEraseBkgnd(CDC* pDC);
 
    //int m_DataState;
    //afx_msg void OnTimer(UINT nIDEvent);
    afx_msg void OnTimer(UINT_PTR nIDEvent);
};
 
 
class AFX_EXT_CLASS CakGraphThreadDraw
{
public:
    CakGraphThreadDraw()
    {
        m_bThreadDrawMode = FALSE;
        m_bDrawByThread = FALSE;
        m_nThreadDrawFlag = 0;
        m_nThreadDrawSleepTimeMin = 1;
        m_nThreadDrawSleepTime = 30;
 
        InitializeCriticalSection(&m_csThreadDraw);
    };
    virtual ~CakGraphThreadDraw()
    {
        if(GetThreadDrawMode())
        {
            m_nThreadDrawFlag = 2;
            int nReTryCount = 10;
            while (m_nThreadDrawFlag != 0 && nReTryCount--)
            {
                Sleep(1);
            }
        }
 
    };
 
public:
    virtual BOOL CreateThreadDraw(CakGraphBase* pBase)
    {
        if(pBase == NULL) return FALSE;
 
        //if(GetThreadDrawMode())
        {
            m_nThreadDrawFlag = 1;
            //_beginthread(threadThreadDraw, NULL, this);
            AfxBeginThread(threadThreadDraw, this, NULL);
            m_pGraphBase = pBase;
            m_bDrawByThread = TRUE;
        }
        return TRUE;
    }
    void SetDrawByThread(BOOL bFlag){m_bDrawByThread = bFlag;};
    void SetThreadDrawMode(BOOL bFlag){m_bThreadDrawMode = bFlag;};
    BOOL GetThreadDrawMode(){return m_bThreadDrawMode;};
    CRITICAL_SECTION* GetCriticalSection(){return &m_csThreadDraw;};
    void SleepMsg(IN DWORD dwMilliseconds)  
    {  
        DWORD dwStart   = 0;  
        MSG   msg       = {0,};  
 
        dwStart  = GetTickCount();  
        while (GetTickCount() - dwStart < dwMilliseconds)  
        {  
            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))  
            {  
                TranslateMessage(&msg);  
                DispatchMessage(&msg);  
            }  
 
            // Lower CPU Usage  
            ::Sleep(1);  
        }  
    }  
 
public:
    int m_nThreadDrawSleepTime;
    int m_nThreadDrawSleepTimeMin;
protected:
    BOOL m_bThreadDrawMode;
 
    //CDC m_ThreadDrawDC; 
    //CBitmap m_ThreadDrawBitmap;
    //CRect m_rectThreadDrawBitmap;
    int m_nThreadDrawFlag;
    BOOL m_bDrawByThread;
 
    CRITICAL_SECTION m_csThreadDraw;
    CakGraphBase* m_pGraphBase;
 
    
protected:
    //static void threadThreadDraw(void* arg)
    static UINT threadThreadDraw(LPVOID arg)
    {
        CakGraphThreadDraw* pThis = (CakGraphThreadDraw*)arg;
        while (pThis->m_nThreadDrawFlag == 1)
        {
            DWORD    dwTimeStart = GetTickCount();
            if(pThis->m_bDrawByThread)
            {
                pThis->m_bDrawByThread = FALSE;
                pThis->funcThreadDraw();
            }
            else
            {
                
            }
 
            int nSleepTimeDynamic = pThis->m_nThreadDrawSleepTime-(GetTickCount()-dwTimeStart);
            nSleepTimeDynamic = max(nSleepTimeDynamic, pThis->m_nThreadDrawSleepTimeMin);
 
            nSleepTimeDynamic = pThis->m_nThreadDrawSleepTime;
            Sleep(nSleepTimeDynamic);
            //pThis->SleepMsg(nSleepTimeDynamic);
        }
        pThis->m_nThreadDrawFlag = 0;
 
        return TRUE;
    };
 
    virtual void funcThreadDraw()
    {
        m_pGraphBase->FuncThreadDraw();
    };
};