GridCtrl.h
38.7 KB
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
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
/////////////////////////////////////////////////////////////////////////////
// GridCtrl.h : header file
//
// MFC Grid Control - main header
//
// Written by Chris Maunder <cmaunder@mail.com>
// Copyright (c) 1998-2002. All Rights Reserved.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is
// not sold for profit without the authors written consent, and
// providing that this notice and the authors name and all copyright
// notices remains intact.
//
// An email letting me know how you are using it would be nice as well.
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this product may cause.
//
// For use with CGridCtrl v2.20+
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_GRIDCTRL_H__519FA702_722C_11D1_ABBA_00A0243D1382__INCLUDED_)
#define AFX_GRIDCTRL_H__519FA702_722C_11D1_ABBA_00A0243D1382__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
#include "CellRange.h"
#include "GridCell.h"
#include <afxtempl.h>
#include <string>
///////////////////////////////////////////////////////////////////////////////////
// Defines - these determine the features (and the final size) of the final code
///////////////////////////////////////////////////////////////////////////////////
//#define GRIDCONTROL_NO_TITLETIPS // Do not use titletips for cells with large data
//#define GRIDCONTROL_NO_DRAGDROP // Do not use OLE drag and drop
//#define GRIDCONTROL_NO_CLIPBOARD // Do not use clipboard routines
#ifdef _WIN32_WCE
# define GRIDCONTROL_NO_TITLETIPS // Do not use titletips for cells with large data
# define GRIDCONTROL_NO_DRAGDROP // Do not use OLE drag and drop
# define GRIDCONTROL_NO_CLIPBOARD // Do not use clipboard routines
# define GRIDCONTROL_NO_PRINTING // Do not use printing routines
# ifdef WCE_NO_PRINTING // Older versions of CE had different #def's
# define _WIN32_WCE_NO_PRINTING
# endif
# ifdef WCE_NO_CURSOR
# define _WIN32_WCE_NO_CURSOR
# endif
#endif // _WIN32_WCE
// Use this as the classname when inserting this control as a custom control
// in the MSVC++ dialog editor
#define GRIDCTRL_CLASSNAME _T("MFCGridCtrl") // Window class name
#define IDC_INPLACE_CONTROL 8 // ID of inplace edit controls
///////////////////////////////////////////////////////////////////////////////////
// Conditional includes
///////////////////////////////////////////////////////////////////////////////////
#ifndef GRIDCONTROL_NO_TITLETIPS
# include "TitleTip.h"
#endif
#ifndef GRIDCONTROL_NO_DRAGDROP
# include "GridDropTarget.h"
# undef GRIDCONTROL_NO_CLIPBOARD // Force clipboard functions on
#endif
#ifndef GRIDCONTROL_NO_CLIPBOARD
# include <afxole.h>
#endif
///////////////////////////////////////////////////////////////////////////////////
// Helper functions
///////////////////////////////////////////////////////////////////////////////////
// Handy functions
#define IsSHIFTpressed() ( (GetKeyState(VK_SHIFT) & (1 << (sizeof(SHORT)*8-1))) != 0 )
#define IsCTRLpressed() ( (GetKeyState(VK_CONTROL) & (1 << (sizeof(SHORT)*8-1))) != 0 )
// Backwards compatibility for pre 2.20 grid versions
#define DDX_GridControl(pDX, nIDC, rControl) DDX_Control(pDX, nIDC, rControl)
///////////////////////////////////////////////////////////////////////////////////
// Structures
///////////////////////////////////////////////////////////////////////////////////
// This structure sent to Grid's parent in a WM_NOTIFY message
typedef struct tagNM_GRIDVIEW {
NMHDR hdr;
int iRow;
int iColumn;
} NM_GRIDVIEW;
// This is sent to the Grid from child in-place edit controls
typedef struct tagGV_DISPINFO {
NMHDR hdr;
GV_ITEM item;
} GV_DISPINFO;
// This is sent to the Grid from child in-place edit controls
typedef struct tagGV_CACHEHINT {
NMHDR hdr;
CCellRange range;
} GV_CACHEHINT;
// storage typedef for each row in the grid
typedef CTypedPtrArray<CObArray, CGridCellBase*> GRID_ROW;
// For virtual mode callback
typedef BOOL (CALLBACK* GRIDCALLBACK)(GV_DISPINFO *, LPARAM);
///////////////////////////////////////////////////////////////////////////////////
// Defines
///////////////////////////////////////////////////////////////////////////////////
// Grid line/scrollbar selection
#define GVL_NONE 0L // Neither
#define GVL_HORZ 1L // Horizontal line or scrollbar
#define GVL_VERT 2L // Vertical line or scrollbar
#define GVL_BOTH 3L // Both
// Autosizing option
#define GVS_DEFAULT 0
#define GVS_HEADER 1 // Size using column fixed cells data only
#define GVS_DATA 2 // Size using column non-fixed cells data only
#define GVS_BOTH 3 // Size using column fixed and non-fixed
// Cell Searching options
#define GVNI_FOCUSED 0x0001
#define GVNI_SELECTED 0x0002
#define GVNI_DROPHILITED 0x0004
#define GVNI_READONLY 0x0008
#define GVNI_FIXED 0x0010
#define GVNI_MODIFIED 0x0020
#define GVNI_ABOVE LVNI_ABOVE
#define GVNI_BELOW LVNI_BELOW
#define GVNI_TOLEFT LVNI_TOLEFT
#define GVNI_TORIGHT LVNI_TORIGHT
#define GVNI_ALL (LVNI_BELOW|LVNI_TORIGHT|LVNI_TOLEFT)
#define GVNI_AREA (LVNI_BELOW|LVNI_TORIGHT)
// Hit test values (not yet implemented)
#define GVHT_DATA 0x0000
#define GVHT_TOPLEFT 0x0001
#define GVHT_COLHDR 0x0002
#define GVHT_ROWHDR 0x0004
#define GVHT_COLSIZER 0x0008
#define GVHT_ROWSIZER 0x0010
#define GVHT_LEFT 0x0020
#define GVHT_RIGHT 0x0040
#define GVHT_ABOVE 0x0080
#define GVHT_BELOW 0x0100
// Messages sent to the grid's parent (More will be added in future)
#define GVN_BEGINDRAG LVN_BEGINDRAG // LVN_FIRST-9
#define GVN_BEGINLABELEDIT LVN_BEGINLABELEDIT // LVN_FIRST-5
#define GVN_BEGINRDRAG LVN_BEGINRDRAG
#define GVN_COLUMNCLICK LVN_COLUMNCLICK
#define GVN_DELETEITEM LVN_DELETEITEM
#define GVN_ENDLABELEDIT LVN_ENDLABELEDIT // LVN_FIRST-6
#define GVN_SELCHANGING LVN_ITEMCHANGING
#define GVN_SELCHANGED LVN_ITEMCHANGED
#define GVN_GETDISPINFO LVN_GETDISPINFO
#define GVN_ODCACHEHINT LVN_ODCACHEHINT
class CGridCtrl;
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl window
class CGridCtrl : public CWnd
{
DECLARE_DYNCREATE(CGridCtrl)
friend class CGridCell;
friend class CGridCellBase;
// Construction
public:
CGridCtrl(int nRows = 0, int nCols = 0, int nFixedRows = 0, int nFixedCols = 0);
BOOL Create(const RECT& rect, CWnd* parent, UINT nID,
DWORD dwStyle = WS_CHILD | WS_BORDER | WS_TABSTOP | WS_VISIBLE);
///////////////////////////////////////////////////////////////////////////////////
// Attributes
///////////////////////////////////////////////////////////////////////////////////
public:
int GetRowCount() const { return m_nRows; }
int GetColumnCount() const { return m_nCols; }
int GetFixedRowCount() const { return m_nFixedRows; }
int GetFixedColumnCount() const { return m_nFixedCols; }
BOOL SetRowCount(int nRows = 10);
BOOL SetColumnCount(int nCols = 10);
BOOL SetFixedRowCount(int nFixedRows = 1);
BOOL SetFixedColumnCount(int nFixedCols = 1);
int GetRowHeight(int nRow) const;
BOOL SetRowHeight(int row, int height);
int GetColumnWidth(int nCol) const;
BOOL SetColumnWidth(int col, int width);
BOOL GetCellOrigin(int nRow, int nCol, LPPOINT p);
BOOL GetCellOrigin(const CCellID& cell, LPPOINT p);
BOOL GetCellRect(int nRow, int nCol, LPRECT pRect);
BOOL GetCellRect(const CCellID& cell, LPRECT pRect);
BOOL GetTextRect(const CCellID& cell, LPRECT pRect);
BOOL GetTextRect(int nRow, int nCol, LPRECT pRect);
CCellID GetCellFromPt(CPoint point, BOOL bAllowFixedCellCheck = TRUE);
int GetFixedRowHeight() const;
int GetFixedColumnWidth() const;
long GetVirtualWidth() const;
long GetVirtualHeight() const;
CSize GetTextExtent(int nRow, int nCol, LPCTSTR str);
// EFW - Get extent of current text in cell
inline CSize GetCellTextExtent(int nRow, int nCol) { return GetTextExtent(nRow, nCol, GetItemText(nRow,nCol)); }
void SetGridBkColor(COLORREF clr) { m_crGridBkColour = clr; }
COLORREF GetGridBkColor() const { return m_crGridBkColour; }
void SetGridLineColor(COLORREF clr) { m_crGridLineColour = clr; }
COLORREF GetGridLineColor() const { return m_crGridLineColour; }
void SetTitleTipBackClr(COLORREF clr = CLR_DEFAULT) { m_crTTipBackClr = clr; }
COLORREF GetTitleTipBackClr() { return m_crTTipBackClr; }
void SetTitleTipTextClr(COLORREF clr = CLR_DEFAULT) { m_crTTipTextClr = clr; }
COLORREF GetTitleTipTextClr() { return m_crTTipTextClr; }
// ***************************************************************************** //
// These have been deprecated. Use GetDefaultCell and then set the colors
void SetTextColor(COLORREF clr) { m_cellDefault.SetTextClr(clr); }
COLORREF GetTextColor() { return m_cellDefault.GetTextClr(); }
void SetTextBkColor(COLORREF clr) { m_cellDefault.SetBackClr(clr); }
COLORREF GetTextBkColor() { return m_cellDefault.GetBackClr(); }
void SetFixedTextColor(COLORREF clr) { m_cellFixedRowDef.SetTextClr(clr);
m_cellFixedColDef.SetTextClr(clr);
m_cellFixedRowColDef.SetTextClr(clr); }
COLORREF GetFixedTextColor() const { return m_cellFixedRowDef.GetTextClr(); }
void SetFixedBkColor(COLORREF clr) { m_cellFixedRowDef.SetBackClr(clr);
m_cellFixedColDef.SetBackClr(clr);
m_cellFixedRowColDef.SetBackClr(clr); }
COLORREF GetFixedBkColor() const { return m_cellFixedRowDef.GetBackClr(); }
void SetGridColor(COLORREF clr) { SetGridLineColor(clr); }
COLORREF GetGridColor() { return GetGridLineColor(); }
void SetBkColor(COLORREF clr) { SetGridBkColor(clr); }
COLORREF GetBkColor() { return GetGridBkColor(); }
void SetDefCellMargin( int nMargin) { m_cellDefault.SetMargin(nMargin);
m_cellFixedRowDef.SetMargin(nMargin);
m_cellFixedColDef.SetMargin(nMargin);
m_cellFixedRowColDef.SetMargin(nMargin); }
int GetDefCellMargin() const { return m_cellDefault.GetMargin(); }
int GetDefCellHeight() const { return m_cellDefault.GetHeight(); }
void SetDefCellHeight(int nHeight) { m_cellDefault.SetHeight(nHeight);
m_cellFixedRowDef.SetHeight(nHeight);
m_cellFixedColDef.SetHeight(nHeight);
m_cellFixedRowColDef.SetHeight(nHeight); }
int GetDefCellWidth() const { return m_cellDefault.GetWidth(); }
void SetDefCellWidth(int nWidth) { m_cellDefault.SetWidth(nWidth);
m_cellFixedRowDef.SetWidth(nWidth);
m_cellFixedColDef.SetWidth(nWidth);
m_cellFixedRowColDef.SetWidth(nWidth); }
// ***************************************************************************** //
int GetSelectedCount() const { return (int)m_SelectedCellMap.GetCount(); }
CCellID SetFocusCell(CCellID cell);
CCellID SetFocusCell(int nRow, int nCol);
CCellID GetFocusCell() const { return m_idCurrentCell; }
void SetVirtualMode(BOOL bVirtual);
BOOL GetVirtualMode() const { return m_bVirtualMode; }
void SetCallbackFunc(GRIDCALLBACK pCallback,
LPARAM lParam) { m_pfnCallback = pCallback; m_lParam = lParam; }
GRIDCALLBACK GetCallbackFunc() { return m_pfnCallback; }
void SetImageList(CImageList* pList) { m_pImageList = pList; }
CImageList* GetImageList() const { return m_pImageList; }
void SetGridLines(int nWhichLines = GVL_BOTH);
int GetGridLines() const { return m_nGridLines; }
void SetEditable(BOOL bEditable = TRUE) { m_bEditable = bEditable; }
BOOL IsEditable() const { return m_bEditable; }
void SetListMode(BOOL bEnableListMode = TRUE);
BOOL GetListMode() const { return m_bListMode; }
void SetSingleRowSelection(BOOL bSing = TRUE) { m_bSingleRowSelection = bSing; }
BOOL GetSingleRowSelection() { return m_bSingleRowSelection & m_bListMode; }
void SetSingleColSelection(BOOL bSing = TRUE) { m_bSingleColSelection = bSing; }
BOOL GetSingleColSelection() { return m_bSingleColSelection; }
void EnableSelection(BOOL bEnable = TRUE) { ResetSelectedRange(); m_bEnableSelection = bEnable; ResetSelectedRange(); }
BOOL IsSelectable() const { return m_bEnableSelection; }
void SetFixedColumnSelection(BOOL bSelect) { m_bFixedColumnSelection = bSelect;}
BOOL GetFixedColumnSelection() { return m_bFixedColumnSelection; }
void SetFixedRowSelection(BOOL bSelect) { m_bFixedRowSelection = bSelect; }
BOOL GetFixedRowSelection() { return m_bFixedRowSelection; }
void EnableDragAndDrop(BOOL bAllow = TRUE) { m_bAllowDragAndDrop = bAllow; }
BOOL GetDragAndDrop() const { return m_bAllowDragAndDrop; }
void SetRowResize(BOOL bResize = TRUE) { m_bAllowRowResize = bResize; }
BOOL GetRowResize() const { return m_bAllowRowResize; }
void SetColumnResize(BOOL bResize = TRUE) { m_bAllowColumnResize = bResize; }
BOOL GetColumnResize() const { return m_bAllowColumnResize; }
void SetHeaderSort(BOOL bSortOnClick = TRUE) { m_bSortOnClick = bSortOnClick; }
BOOL GetHeaderSort() const { return m_bSortOnClick; }
void SetHandleTabKey(BOOL bHandleTab = TRUE) { m_bHandleTabKey = bHandleTab; }
BOOL GetHandleTabKey() const { return m_bHandleTabKey; }
void SetDoubleBuffering(BOOL bBuffer = TRUE) { m_bDoubleBuffer = bBuffer; }
BOOL GetDoubleBuffering() const { return m_bDoubleBuffer; }
void EnableTitleTips(BOOL bEnable = TRUE) { m_bTitleTips = bEnable; }
BOOL GetTitleTips() { return m_bTitleTips; }
void SetSortColumn(int nCol);
int GetSortColumn() const { return m_nSortColumn; }
void SetSortAscending(BOOL bAscending) { m_bAscending = bAscending; }
BOOL GetSortAscending() const { return m_bAscending; }
void SetTrackFocusCell(BOOL bTrack) { m_bTrackFocusCell = bTrack; }
BOOL GetTrackFocusCell() { return m_bTrackFocusCell; }
void SetFrameFocusCell(BOOL bFrame) { m_bFrameFocus = bFrame; }
BOOL GetFrameFocusCell() { return m_bFrameFocus; }
void SetAutoSizeStyle(int nStyle = GVS_BOTH) { m_nAutoSizeColumnStyle = nStyle; }
int GetAutoSizeStyle() { return m_nAutoSizeColumnStyle; }
void EnableHiddenColUnhide(BOOL bEnable = TRUE){ m_bHiddenColUnhide = bEnable; }
BOOL GetHiddenColUnhide() { return m_bHiddenColUnhide; }
void EnableHiddenRowUnhide(BOOL bEnable = TRUE){ m_bHiddenRowUnhide = bEnable; }
BOOL GetHiddenRowUnhide() { return m_bHiddenRowUnhide; }
void EnableColumnHide(BOOL bEnable = TRUE) { m_bAllowColHide = bEnable; }
BOOL GetColumnHide() { return m_bAllowColHide; }
void EnableRowHide(BOOL bEnable = TRUE) { m_bAllowRowHide = bEnable; }
BOOL GetRowHide() { return m_bAllowRowHide; }
///////////////////////////////////////////////////////////////////////////////////
// default Grid cells. Use these for setting default values such as colors and fonts
///////////////////////////////////////////////////////////////////////////////////
public:
CGridCellBase* GetDefaultCell(BOOL bFixedRow, BOOL bFixedCol) const;
///////////////////////////////////////////////////////////////////////////////////
// Grid cell Attributes
///////////////////////////////////////////////////////////////////////////////////
public:
CGridCellBase* GetCell(int nRow, int nCol) const; // Get the actual cell!
void SetModified(BOOL bModified = TRUE, int nRow = -1, int nCol = -1);
BOOL GetModified(int nRow = -1, int nCol = -1);
BOOL IsCellFixed(int nRow, int nCol);
BOOL SetItem(const GV_ITEM* pItem);
BOOL GetItem(GV_ITEM* pItem);
BOOL SetItemText(int nRow, int nCol, LPCTSTR str, int data_id = 0, long product_id = 0);
// The following was virtual. If you want to override, use
// CGridCellBase-derived class's GetText() to accomplish same thing
CString GetItemText(int nRow, int nCol) const;
// EFW - 06/13/99 - Added to support printf-style formatting codes.
// Also supports use with a string resource ID
#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 210)
BOOL SetItemTextFmt(int nRow, int nCol, LPCTSTR szFmt, ...);
BOOL SetItemTextFmtID(int nRow, int nCol, UINT nID, ...);
#endif
BOOL SetItemData(int nRow, int nCol, LPARAM lParam);
LPARAM GetItemData(int nRow, int nCol) const;
BOOL SetItemImage(int nRow, int nCol, int iImage);
int GetItemImage(int nRow, int nCol) const;
BOOL SetItemState(int nRow, int nCol, UINT state);
UINT GetItemState(int nRow, int nCol) const;
BOOL SetItemFormat(int nRow, int nCol, UINT nFormat);
UINT GetItemFormat(int nRow, int nCol) const;
BOOL SetItemBkColour(int nRow, int nCol, COLORREF cr = CLR_DEFAULT);
COLORREF GetItemBkColour(int nRow, int nCol) const;
BOOL SetItemFgColour(int nRow, int nCol, COLORREF cr = CLR_DEFAULT);
COLORREF GetItemFgColour(int nRow, int nCol) const;
BOOL SetItemFont(int nRow, int nCol, const LOGFONT* lf);
const LOGFONT* GetItemFont(int nRow, int nCol);
BOOL IsItemEditing(int nRow, int nCol);
BOOL SetCellType(int nRow, int nCol, CRuntimeClass* pRuntimeClass);
BOOL SetDefaultCellType( CRuntimeClass* pRuntimeClass);
///////////////////////////////////////////////////////////////////////////////////
// Operations
///////////////////////////////////////////////////////////////////////////////////
public:
int InsertColumn(LPCTSTR strHeading, UINT nFormat = DT_CENTER|DT_VCENTER|DT_SINGLELINE,
int nColumn = -1);
int InsertRow(LPCTSTR strHeading, int nRow = -1);
BOOL DeleteColumn(int nColumn);
BOOL DeleteRow(int nRow);
BOOL DeleteNonFixedRows();
BOOL DeleteAllItems();
void ClearCells(CCellRange Selection);
BOOL AutoSizeRow(int nRow, BOOL bResetScroll = TRUE);
BOOL AutoSizeColumn(int nCol, UINT nAutoSizeStyle = GVS_DEFAULT, BOOL bResetScroll = TRUE);
void AutoSizeRows();
void AutoSizeColumns(UINT nAutoSizeStyle = GVS_DEFAULT);
void AutoSize(UINT nAutoSizeStyle = GVS_DEFAULT);
void ExpandColumnsToFit(BOOL bExpandFixed = TRUE);
void ExpandLastColumn();
void ExpandRowsToFit(BOOL bExpandFixed = TRUE);
void ExpandToFit(BOOL bExpandFixed = TRUE);
void Refresh();
void AutoFill(); // Fill grid with blank cells
void EnsureVisible(CCellID &cell) { EnsureVisible(cell.row, cell.col); }
void EnsureVisible(int nRow, int nCol);
BOOL IsCellVisible(int nRow, int nCol);
BOOL IsCellVisible(CCellID cell);
BOOL IsCellEditable(int nRow, int nCol) const;
BOOL IsCellEditable(CCellID &cell) const;
BOOL IsCellSelected(int nRow, int nCol) const;
BOOL IsCellSelected(CCellID &cell) const;
// SetRedraw stops/starts redraws on things like changing the # rows/columns
// and autosizing, but not for user-intervention such as resizes
void SetRedraw(BOOL bAllowDraw, BOOL bResetScrollBars = FALSE);
BOOL RedrawCell(int nRow, int nCol, CDC* pDC = NULL);
BOOL RedrawCell(const CCellID& cell, CDC* pDC = NULL);
BOOL RedrawRow(int row);
BOOL RedrawColumn(int col);
#ifndef _WIN32_WCE
BOOL Save(LPCTSTR filename, TCHAR chSeparator = _T(','));
BOOL Load(LPCTSTR filename, TCHAR chSeparator = _T(','));
#endif
///////////////////////////////////////////////////////////////////////////////////
// Cell Ranges
///////////////////////////////////////////////////////////////////////////////////
public:
CCellRange GetCellRange() const;
CCellRange GetSelectedCellRange() const;
void SetSelectedRange(const CCellRange& Range, BOOL bForceRepaint = FALSE, BOOL bSelectCells = TRUE);
void SetSelectedRange(int nMinRow, int nMinCol, int nMaxRow, int nMaxCol,
BOOL bForceRepaint = FALSE, BOOL bSelectCells = TRUE);
BOOL IsValid(int nRow, int nCol) const;
BOOL IsValid(const CCellID& cell) const;
BOOL IsValid(const CCellRange& range) const;
///////////////////////////////////////////////////////////////////////////////////
// Clipboard, drag and drop, and cut n' paste operations
///////////////////////////////////////////////////////////////////////////////////
#ifndef GRIDCONTROL_NO_CLIPBOARD
virtual void CutSelectedText();
virtual COleDataSource* CopyTextFromGrid();
virtual BOOL PasteTextToGrid(CCellID cell, COleDataObject* pDataObject, BOOL bSelectPastedCells=TRUE);
#endif
#ifndef GRIDCONTROL_NO_DRAGDROP
public:
virtual void OnBeginDrag();
virtual DROPEFFECT OnDragEnter(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);
virtual DROPEFFECT OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);
virtual void OnDragLeave();
virtual BOOL OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point);
#endif
#ifndef GRIDCONTROL_NO_CLIPBOARD
virtual void OnEditCut();
virtual void OnEditCopy();
virtual void OnEditPaste();
#endif
virtual void OnEditSelectAll();
///////////////////////////////////////////////////////////////////////////////////
// Misc.
///////////////////////////////////////////////////////////////////////////////////
public:
CCellID GetNextItem(CCellID& cell, int nFlags) const;
BOOL SortItems(int nCol, BOOL bAscending, LPARAM data = 0);
BOOL SortTextItems(int nCol, BOOL bAscending, LPARAM data = 0);
BOOL SortItems(PFNLVCOMPARE pfnCompare, int nCol, BOOL bAscending, LPARAM data = 0);
void SetCompareFunction(PFNLVCOMPARE pfnCompare);
// in-built sort functions
static int CALLBACK pfnCellTextCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
static int CALLBACK pfnCellNumericCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
///////////////////////////////////////////////////////////////////////////////////
// Printing
///////////////////////////////////////////////////////////////////////////////////
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
public:
void Print(CPrintDialog* pPrntDialog = NULL);
// EFW - New printing support functions
void EnableWysiwygPrinting(BOOL bEnable = TRUE) { m_bWysiwygPrinting = bEnable; }
BOOL GetWysiwygPrinting() { return m_bWysiwygPrinting; }
void SetShadedPrintOut(BOOL bEnable = TRUE) { m_bShadedPrintOut = bEnable; }
BOOL GetShadedPrintOut(void) { return m_bShadedPrintOut; }
// Use -1 to have it keep the existing value
void SetPrintMarginInfo(int nHeaderHeight, int nFooterHeight,
int nLeftMargin, int nRightMargin, int nTopMargin,
int nBottomMargin, int nGap);
void GetPrintMarginInfo(int &nHeaderHeight, int &nFooterHeight,
int &nLeftMargin, int &nRightMargin, int &nTopMargin,
int &nBottomMargin, int &nGap);
///////////////////////////////////////////////////////////////////////////////////
// Printing overrides for derived classes
///////////////////////////////////////////////////////////////////////////////////
public:
virtual void OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo);
virtual void OnPrint(CDC *pDC, CPrintInfo *pInfo);
virtual void OnEndPrinting(CDC *pDC, CPrintInfo *pInfo);
#endif // #if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
// Implementation
public:
//Merge the selected cells
//by Huang Wei
CGridCellBase* GetCell(CCellID cell);
CCellID GetMergeCellID(CCellID cell);
void UnMergeSelectedCells();
void MergeSelectedCells();
void UnMergeCells(int nStartRow, int nStartCol, int nEndRow, int nEndCol);
void MergeCells(int nStartRow, int nStartCol, int nEndRow, int nEndCol);
int GetMergeCellWidth(CCellID cell);
int GetMergeCellHeight(CCellID cell);
BOOL GetCellOriginNoMerge(int nRow, int nCol, LPPOINT p);
BOOL GetCellOriginNoMerge(const CCellID& cell, LPPOINT p);
virtual ~CGridCtrl();
protected:
BOOL RegisterWindowClass();
BOOL Initialise();
void SetupDefaultCells();
LRESULT SendMessageToParent(int nRow, int nCol, int nMessage) const;
LRESULT SendDisplayRequestToParent(GV_DISPINFO* pDisplayInfo) const;
LRESULT SendCacheHintToParent(const CCellRange& range) const;
BOOL InvalidateCellRect(const int row, const int col);
BOOL InvalidateCellRect(const CCellID& cell);
BOOL InvalidateCellRect(const CCellRange& cellRange);
void EraseBkgnd(CDC* pDC);
BOOL GetCellRangeRect(const CCellRange& cellRange, LPRECT lpRect);
BOOL SetCell(int nRow, int nCol, CGridCellBase* pCell);
int SetMouseMode(int nMode) { int nOldMode = m_MouseMode; m_MouseMode = nMode; return nOldMode; }
int GetMouseMode() const { return m_MouseMode; }
BOOL MouseOverRowResizeArea(CPoint& point);
BOOL MouseOverColumnResizeArea(CPoint& point);
CCellID GetTopleftNonFixedCell(BOOL bForceRecalculation = FALSE);
CCellRange GetUnobstructedNonFixedCellRange(BOOL bForceRecalculation = FALSE);
CCellRange GetVisibleNonFixedCellRange(LPRECT pRect = NULL, BOOL bForceRecalculation = FALSE);
BOOL IsVisibleVScroll() { return ( (m_nBarState & GVL_VERT) > 0); }
BOOL IsVisibleHScroll() { return ( (m_nBarState & GVL_HORZ) > 0); }
void ResetSelectedRange();
void ResetScrollBars();
void EnableScrollBars(int nBar, BOOL bEnable = TRUE);
int GetScrollPos32(int nBar, BOOL bGetTrackPos = FALSE);
BOOL SetScrollPos32(int nBar, int nPos, BOOL bRedraw = TRUE);
BOOL SortTextItems(int nCol, BOOL bAscending, int low, int high);
BOOL SortItems(PFNLVCOMPARE pfnCompare, int nCol, BOOL bAscending, LPARAM data,
int low, int high);
CPoint GetPointClicked(int nRow, int nCol, const CPoint& point);
void ValidateAndModifyCellContents(int nRow, int nCol, LPCTSTR strText);
// Overrrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CGridCtrl)
protected:
virtual void PreSubclassWindow();
//}}AFX_VIRTUAL
protected:
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
// Printing
virtual void PrintFixedRowCells(int nStartColumn, int nStopColumn, int& row, CRect& rect,
CDC *pDC, BOOL& bFirst);
virtual void PrintColumnHeadings(CDC *pDC, CPrintInfo *pInfo);
virtual void PrintHeader(CDC *pDC, CPrintInfo *pInfo);
virtual void PrintFooter(CDC *pDC, CPrintInfo *pInfo);
virtual void PrintRowButtons(CDC *pDC, CPrintInfo* /*pInfo*/);
#endif
#ifndef GRIDCONTROL_NO_DRAGDROP
// Drag n' drop
virtual CImageList* CreateDragImage(CPoint *pHotSpot); // no longer necessary
#endif
// Mouse Clicks
virtual void OnFixedColumnClick(CCellID& cell);
virtual void OnFixedRowClick(CCellID& cell);
// Editing
virtual void OnEditCell(int nRow, int nCol, CPoint point, UINT nChar);
virtual void OnEndEditCell(int nRow, int nCol, CString str);
virtual BOOL ValidateEdit(int nRow, int nCol, LPCTSTR str);
virtual void EndEditing();
// Drawing
virtual void OnDraw(CDC* pDC);
// CGridCellBase Creation and Cleanup
virtual CGridCellBase* CreateCell(int nRow, int nCol);
virtual void DestroyCell(int nRow, int nCol);
// Attributes
protected:
// General attributes
COLORREF m_crFixedTextColour, m_crFixedBkColour;
COLORREF m_crGridBkColour, m_crGridLineColour;
COLORREF m_crWindowText, m_crWindowColour, m_cr3DFace, // System colours
m_crShadow;
COLORREF m_crTTipBackClr, m_crTTipTextClr; // Titletip colours - FNA
BOOL m_bVirtualMode;
LPARAM m_lParam; // lParam for callback
GRIDCALLBACK m_pfnCallback; // The callback function
int m_nGridLines;
BOOL m_bEditable;
BOOL m_bModified;
BOOL m_bAllowDragAndDrop;
BOOL m_bListMode;
BOOL m_bSingleRowSelection;
BOOL m_bSingleColSelection;
BOOL m_bAllowDraw;
BOOL m_bEnableSelection;
BOOL m_bFixedRowSelection, m_bFixedColumnSelection;
BOOL m_bSortOnClick;
BOOL m_bHandleTabKey;
BOOL m_bDoubleBuffer;
BOOL m_bTitleTips;
int m_nBarState;
BOOL m_bWysiwygPrinting;
BOOL m_bHiddenColUnhide, m_bHiddenRowUnhide;
BOOL m_bAllowColHide, m_bAllowRowHide;
BOOL m_bAutoSizeSkipColHdr;
BOOL m_bTrackFocusCell;
BOOL m_bFrameFocus;
UINT m_nAutoSizeColumnStyle;
// Cell size details
int m_nRows, m_nFixedRows, m_nCols, m_nFixedCols;
CUIntArray m_arRowHeights, m_arColWidths;
int m_nVScrollMax, m_nHScrollMax;
// Fonts and images
CRuntimeClass* m_pRtcDefault; // determines kind of Grid Cell created by default
CGridDefaultCell m_cellDefault; // "default" cell. Contains default colours, font etc.
CGridDefaultCell m_cellFixedColDef, m_cellFixedRowDef, m_cellFixedRowColDef;
CFont m_PrinterFont; // for the printer
CImageList* m_pImageList;
// Cell data
CTypedPtrArray<CObArray, GRID_ROW*> m_RowData;
// Mouse operations such as cell selection
int m_MouseMode;
BOOL m_bLMouseButtonDown, m_bRMouseButtonDown;
CPoint m_LeftClickDownPoint, m_LastMousePoint;
CCellID m_LeftClickDownCell, m_SelectionStartCell;
CCellID m_idCurrentCell, m_idTopLeftCell;
int m_nTimerID;
int m_nTimerInterval;
int m_nResizeCaptureRange;
BOOL m_bAllowRowResize, m_bAllowColumnResize;
int m_nRowsPerWheelNotch;
CMap<DWORD,DWORD, CCellID, CCellID&> m_SelectedCellMap, m_PrevSelectedCellMap;
#ifndef GRIDCONTROL_NO_TITLETIPS
CTitleTip m_TitleTip; // Title tips for cells
#endif
// Drag and drop
CCellID m_LastDragOverCell;
#ifndef GRIDCONTROL_NO_DRAGDROP
CGridDropTarget m_DropTarget; // OLE Drop target for the grid
#endif
// Printing information
CSize m_CharSize;
int m_nPageHeight;
CSize m_LogicalPageSize, // Page size in gridctrl units.
m_PaperSize; // Page size in device units.
// additional properties to support Wysiwyg printing
int m_nPageWidth;
int m_nPrintColumn;
int m_nCurrPrintRow;
int m_nNumPages;
int m_nPageMultiplier;
// sorting
int m_bAscending;
int m_nSortColumn;
PFNLVCOMPARE m_pfnCompare;
// EFW - Added to support shaded/unshaded printout. If true, colored
// cells will print as-is. If false, all text prints as black on white.
BOOL m_bShadedPrintOut;
// EFW - Added support for user-definable margins. Top and bottom are in
// lines. Left, right, and gap are in characters (avg width is used).
int m_nHeaderHeight, m_nFooterHeight, m_nLeftMargin,
m_nRightMargin, m_nTopMargin, m_nBottomMargin, m_nGap;
protected:
void SelectAllCells();
void SelectColumns(CCellID currentCell, BOOL bForceRedraw=FALSE, BOOL bSelectCells=TRUE);
void SelectRows(CCellID currentCell, BOOL bForceRedraw=FALSE, BOOL bSelectCells=TRUE);
void SelectCells(CCellID currentCell, BOOL bForceRedraw=FALSE, BOOL bSelectCells=TRUE);
void OnSelecting(const CCellID& currentCell);
// Generated message map functions
//{{AFX_MSG(CGridCtrl)
afx_msg void OnPaint();
afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnTimer(UINT nIDEvent);
afx_msg UINT OnGetDlgCode();
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
afx_msg void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnUpdateEditSelectAll(CCmdUI* pCmdUI);
//}}AFX_MSG
#ifndef _WIN32_WCE_NO_CURSOR
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
#endif
#ifndef _WIN32_WCE
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
afx_msg void OnRButtonUp(UINT nFlags, CPoint point); // EFW - Added
afx_msg void OnSysColorChange();
#endif
#ifndef _WIN32_WCE_NO_CURSOR
afx_msg void OnCaptureChanged(CWnd *pWnd);
#endif
#ifndef GRIDCONTROL_NO_CLIPBOARD
afx_msg void OnUpdateEditCopy(CCmdUI* pCmdUI);
afx_msg void OnUpdateEditCut(CCmdUI* pCmdUI);
afx_msg void OnUpdateEditPaste(CCmdUI* pCmdUI);
#endif
#if (_MFC_VER >= 0x0421) || (_WIN32_WCE >= 210)
afx_msg void OnSettingChange(UINT uFlags, LPCTSTR lpszSection);
#endif
#if !defined(_WIN32_WCE) && (_MFC_VER >= 0x0421)
afx_msg BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt);
#endif
afx_msg LRESULT OnSetFont(WPARAM hFont, LPARAM lParam);
afx_msg LRESULT OnGetFont(WPARAM hFont, LPARAM lParam);
afx_msg LRESULT OnImeChar(WPARAM wCharCode, LPARAM lParam);
afx_msg void OnEndInPlaceEdit(NMHDR* pNMHDR, LRESULT* pResult);
DECLARE_MESSAGE_MAP()
enum eMouseModes { MOUSE_NOTHING, MOUSE_SELECT_ALL, MOUSE_SELECT_COL, MOUSE_SELECT_ROW,
MOUSE_SELECT_CELLS, MOUSE_SCROLLING_CELLS,
MOUSE_OVER_ROW_DIVIDE, MOUSE_SIZING_ROW,
MOUSE_OVER_COL_DIVIDE, MOUSE_SIZING_COL,
MOUSE_PREPARE_EDIT,
#ifndef GRIDCONTROL_NO_DRAGDROP
MOUSE_PREPARE_DRAG, MOUSE_DRAGGING
#endif
};
afx_msg void DeleteComm();
};
// Returns the default cell implementation for the given grid region
inline CGridCellBase* CGridCtrl::GetDefaultCell(BOOL bFixedRow, BOOL bFixedCol) const
{
if (bFixedRow && bFixedCol) return (CGridCellBase*) &m_cellFixedRowColDef;
if (bFixedRow) return (CGridCellBase*) &m_cellFixedRowDef;
if (bFixedCol) return (CGridCellBase*) &m_cellFixedColDef;
return (CGridCellBase*) &m_cellDefault;
}
inline CGridCellBase* CGridCtrl::GetCell(int nRow, int nCol) const
{
if (nRow < 0 || nRow >= m_nRows || nCol < 0 || nCol >= m_nCols)
return NULL;
if (GetVirtualMode())
{
CGridCellBase* pCell = GetDefaultCell(nRow < m_nFixedRows, nCol < m_nFixedCols);
static GV_DISPINFO gvdi;
gvdi.item.row = nRow;
gvdi.item.col = nCol;
gvdi.item.mask = 0xFFFFFFFF;
gvdi.item.nState = 0;
gvdi.item.nFormat = pCell->GetFormat();
gvdi.item.iImage = pCell->GetImage();
gvdi.item.crBkClr = pCell->GetBackClr();
gvdi.item.crFgClr = pCell->GetTextClr();
gvdi.item.lParam = pCell->GetData();
memcpy(&gvdi.item.lfFont, pCell->GetFont(), sizeof(LOGFONT));
gvdi.item.nMargin = pCell->GetMargin();
gvdi.item.strText.Empty();
// Fix the state bits
if (IsCellSelected(nRow, nCol)) gvdi.item.nState |= GVIS_SELECTED;
if (nRow < GetFixedRowCount()) gvdi.item.nState |= (GVIS_FIXED | GVIS_FIXEDROW);
if (nCol < GetFixedColumnCount()) gvdi.item.nState |= (GVIS_FIXED | GVIS_FIXEDCOL);
if (GetFocusCell() == CCellID(nRow, nCol)) gvdi.item.nState |= GVIS_FOCUSED;
if (m_pfnCallback)
m_pfnCallback(&gvdi, m_lParam);
else
SendDisplayRequestToParent(&gvdi);
static CGridCell cell;
cell.SetState(gvdi.item.nState);
cell.SetFormat(gvdi.item.nFormat);
cell.SetImage(gvdi.item.iImage);
cell.SetBackClr(gvdi.item.crBkClr);
cell.SetTextClr(gvdi.item.crFgClr);
cell.SetData(gvdi.item.lParam);
cell.SetFont(&(gvdi.item.lfFont));
cell.SetMargin(gvdi.item.nMargin);
cell.SetText(gvdi.item.strText);
cell.SetGrid((CGridCtrl*)this);
return (CGridCellBase*) &cell;
}
GRID_ROW* pRow = m_RowData[nRow];
if (!pRow) return NULL;
return pRow->GetAt(nCol);
}
inline BOOL CGridCtrl::SetCell(int nRow, int nCol, CGridCellBase* pCell)
{
if (GetVirtualMode())
return FALSE;
if (nRow < 0 || nRow >= m_nRows || nCol < 0 || nCol >= m_nCols)
return FALSE;
GRID_ROW* pRow = m_RowData[nRow];
if (!pRow) return FALSE;
pCell->SetCoords( nRow, nCol);
pRow->SetAt(nCol, pCell);
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_GRIDCTRL_H__519FA702_722C_11D1_ABBA_00A0243D1382__INCLUDED_)