1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxGenericGrid
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "gridg.h"
17 // For compilers that support precompilation, includes "wx/wx.h".
18 #include "wx/wxprec.h"
30 #include "wx/string.h"
31 #include "wx/generic/gridg.h"
32 #include "wx/settings.h"
34 // Set to zero to use no double-buffering
36 #define wxUSE_DOUBLE_BUFFERING 1
38 #define wxUSE_DOUBLE_BUFFERING 0
41 #define wxGRID_DRAG_NONE 0
42 #define wxGRID_DRAG_LEFT_RIGHT 1
43 #define wxGRID_DRAG_UP_DOWN 2
45 IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid
, wxPanel
)
46 IMPLEMENT_DYNAMIC_CLASS(wxGridEvent
, wxEvent
)
48 BEGIN_EVENT_TABLE(wxGenericGrid
, wxPanel
)
49 EVT_SIZE(wxGenericGrid::OnSize
)
50 EVT_PAINT(wxGenericGrid::OnPaint
)
51 EVT_ERASE_BACKGROUND(wxGenericGrid::OnEraseBackground
)
52 EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent
)
53 EVT_TEXT(wxGRID_TEXT_CTRL
, wxGenericGrid::OnText
)
54 EVT_COMMAND_SCROLL(wxGRID_HSCROLL
, wxGenericGrid::OnGridScroll
)
55 EVT_COMMAND_SCROLL(wxGRID_VSCROLL
, wxGenericGrid::OnGridScroll
)
57 // default wxGridEvent handlers
58 EVT_GRID_SELECT_CELL(wxGenericGrid::_OnSelectCell
)
59 EVT_GRID_CREATE_CELL(wxGenericGrid::_OnCreateCell
)
60 EVT_GRID_CHANGE_LABELS(wxGenericGrid::_OnChangeLabels
)
61 EVT_GRID_CHANGE_SEL_LABEL(wxGenericGrid::_OnChangeSelectionLabel
)
62 EVT_GRID_CELL_CHANGE(wxGenericGrid::_OnCellChange
)
63 EVT_GRID_CELL_LCLICK(wxGenericGrid::_OnCellLeftClick
)
64 EVT_GRID_CELL_RCLICK(wxGenericGrid::_OnCellRightClick
)
65 EVT_GRID_LABEL_LCLICK(wxGenericGrid::_OnLabelLeftClick
)
66 EVT_GRID_LABEL_RCLICK(wxGenericGrid::_OnLabelRightClick
)
73 wxGenericGrid::wxGenericGrid(void)
76 m_hScrollBar
= (wxScrollBar
*) NULL
;
77 m_vScrollBar
= (wxScrollBar
*) NULL
;
78 m_cellTextColour
= *wxBLACK
;
79 m_cellBackgroundColour
= *wxWHITE
;
80 m_labelTextColour
= *wxBLACK
;
81 // m_labelBackgroundColour = *wxLIGHT_GREY;
82 m_labelBackgroundColour
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
83 m_labelBackgroundBrush
= (wxBrush
*) NULL
;
84 m_labelTextFont
= (wxFont
*) NULL
;
85 m_cellTextFont
= (wxFont
*) NULL
;
86 m_textItem
= (wxTextCtrl
*) NULL
;
87 m_currentRectVisible
= FALSE
;
89 #if defined(__WIN95__)
90 m_scrollWidth
= wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X
);
94 m_dragStatus
= wxGRID_DRAG_NONE
;
96 m_dragStartPosition
= 0;
97 m_dragLastPosition
= 0;
98 m_divisionPen
= (wxPen
*) NULL
;
99 m_leftOfSheet
= wxGRID_DEFAULT_SHEET_LEFT
;
100 m_topOfSheet
= wxGRID_DEFAULT_SHEET_TOP
;
101 m_cellHeight
= wxGRID_DEFAULT_CELL_HEIGHT
;
102 m_totalGridWidth
= 0;
103 m_totalGridHeight
= 0;
104 m_colWidths
= (short *) NULL
;
105 m_rowHeights
= (short *) NULL
;
106 m_verticalLabelWidth
= wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH
;
107 m_horizontalLabelHeight
= wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT
;
108 m_verticalLabelAlignment
= wxCENTRE
;
109 m_horizontalLabelAlignment
= wxCENTRE
;
110 m_editControlPosition
.x
= wxGRID_DEFAULT_EDIT_X
;
111 m_editControlPosition
.y
= wxGRID_DEFAULT_EDIT_Y
;
112 m_editControlPosition
.width
= wxGRID_DEFAULT_EDIT_WIDTH
;
113 m_editControlPosition
.height
= wxGRID_DEFAULT_EDIT_HEIGHT
;
118 m_editCreated
= FALSE
;
121 m_gridCells
= (wxGridCell
***) NULL
;
122 m_rowLabelCells
= (wxGridCell
**) NULL
;
123 m_colLabelCells
= (wxGridCell
**) NULL
;
124 m_textItem
= (wxTextCtrl
*) NULL
;
125 m_horizontalSashCursor
= (wxCursor
*) NULL
;
126 m_verticalSashCursor
= (wxCursor
*) NULL
;
129 bool wxGenericGrid::Create(wxWindow
*parent
, wxWindowID id
, const wxPoint
& pos
, const wxSize
& size
,
130 long style
, const wxString
& name
)
133 m_editingPanel
= (wxPanel
*) NULL
;
134 m_hScrollBar
= (wxScrollBar
*) NULL
;
135 m_vScrollBar
= (wxScrollBar
*) NULL
;
136 m_horizontalSashCursor
= (wxCursor
*) NULL
;
137 m_verticalSashCursor
= (wxCursor
*) NULL
;
138 m_cellTextColour
= *wxBLACK
;
139 m_cellBackgroundColour
= *wxWHITE
;
140 m_labelTextColour
= *wxBLACK
;
141 // m_labelBackgroundColour = *wxLIGHT_GREY;
142 m_labelBackgroundColour
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
143 m_labelBackgroundBrush
= (wxBrush
*) NULL
;
144 m_labelTextFont
= wxTheFontList
->FindOrCreateFont(10, wxSWISS
, wxNORMAL
, wxBOLD
);
145 m_cellTextFont
= wxTheFontList
->FindOrCreateFont(10, wxSWISS
, wxNORMAL
, wxNORMAL
);
146 m_textItem
= (wxTextCtrl
*) NULL
;
147 m_currentRectVisible
= FALSE
;
149 #if defined(__WIN95__)
150 m_scrollWidth
= wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X
);
154 m_dragStatus
= wxGRID_DRAG_NONE
;
156 m_dragStartPosition
= 0;
157 m_dragLastPosition
= 0;
158 m_divisionPen
= wxThePenList
->FindOrCreatePen("LIGHT GREY", 1, wxSOLID
);
159 m_doubleBufferingBitmap
= (wxBitmap
*) NULL
;
161 if (!m_horizontalSashCursor
)
163 m_horizontalSashCursor
= new wxCursor(wxCURSOR_SIZEWE
);
164 m_verticalSashCursor
= new wxCursor(wxCURSOR_SIZENS
);
167 SetLabelBackgroundColour(m_labelBackgroundColour
);
169 m_leftOfSheet
= wxGRID_DEFAULT_SHEET_LEFT
;
170 m_topOfSheet
= wxGRID_DEFAULT_SHEET_TOP
;
171 m_cellHeight
= wxGRID_DEFAULT_CELL_HEIGHT
;
172 m_totalGridWidth
= 0;
173 m_totalGridHeight
= 0;
174 m_colWidths
= (short *) NULL
;
175 m_rowHeights
= (short *) NULL
;
177 m_verticalLabelWidth
= wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH
;
178 m_horizontalLabelHeight
= wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT
;
179 m_verticalLabelAlignment
= wxCENTRE
;
180 m_horizontalLabelAlignment
= wxCENTRE
;
181 m_editControlPosition
.x
= wxGRID_DEFAULT_EDIT_X
;
182 m_editControlPosition
.y
= wxGRID_DEFAULT_EDIT_Y
;
183 m_editControlPosition
.width
= wxGRID_DEFAULT_EDIT_WIDTH
;
184 m_editControlPosition
.height
= wxGRID_DEFAULT_EDIT_HEIGHT
;
192 /* Store the rect. coordinates for the current cell */
193 SetCurrentRect(m_wCursorRow
, m_wCursorColumn
);
195 m_editCreated
= FALSE
;
199 m_gridCells
= (wxGridCell
***) NULL
;
200 m_rowLabelCells
= (wxGridCell
**) NULL
;
201 m_colLabelCells
= (wxGridCell
**) NULL
;
202 m_textItem
= (wxTextCtrl
*) NULL
;
204 wxPanel::Create(parent
, id
, pos
, size
, style
, name
);
206 m_editingPanel
= new wxPanel(this);
208 m_textItem
= new wxTextCtrl(m_editingPanel
, wxGRID_TEXT_CTRL
, "",
209 wxPoint(m_editControlPosition
.x
, m_editControlPosition
.y
), wxSize(m_editControlPosition
.width
, -1),
211 m_textItem
->Show(TRUE
);
212 m_textItem
->SetFocus();
213 int controlW
, controlH
;
215 m_textItem
->GetSize(&controlW
, &controlH
);
216 m_editControlPosition
.height
= controlH
;
218 m_topOfSheet
= m_editControlPosition
.y
+ controlH
+ 2;
220 m_editCreated
= TRUE
;
222 m_hScrollBar
= new wxScrollBar(this, wxGRID_HSCROLL
, wxPoint(0, 0), wxSize(20, 100), wxHORIZONTAL
);
223 m_vScrollBar
= new wxScrollBar(this, wxGRID_VSCROLL
, wxPoint(0, 0), wxSize(100, 20), wxVERTICAL
);
228 wxGenericGrid::~wxGenericGrid(void)
233 void wxGenericGrid::ClearGrid(void)
238 for (i
= 0; i
< m_totalRows
; i
++)
240 for (j
= 0; j
< m_totalCols
; j
++)
241 if (m_gridCells
[i
][j
])
242 delete m_gridCells
[i
][j
];
243 delete[] m_gridCells
[i
];
245 delete[] m_gridCells
;
246 m_gridCells
= (wxGridCell
***) NULL
;
249 delete[] m_colWidths
;
250 m_colWidths
= (short *) NULL
;
252 delete[] m_rowHeights
;
253 m_rowHeights
= (short *) NULL
;
257 for (i
= 0; i
< m_totalRows
; i
++)
258 delete m_rowLabelCells
[i
];
259 delete[] m_rowLabelCells
;
260 m_rowLabelCells
= (wxGridCell
**) NULL
;
264 for (i
= 0; i
< m_totalCols
; i
++)
265 delete m_colLabelCells
[i
];
266 delete[] m_colLabelCells
;
267 m_colLabelCells
= (wxGridCell
**) NULL
;
269 if (m_doubleBufferingBitmap
)
271 delete m_doubleBufferingBitmap
;
272 m_doubleBufferingBitmap
= (wxBitmap
*) NULL
;
276 bool wxGenericGrid::CreateGrid(int nRows
, int nCols
, wxString
**cellValues
, short *widths
,
277 short defaultWidth
, short defaultHeight
)
283 m_colWidths
= new short[nCols
];
284 m_rowHeights
= new short[nRows
];
285 for (i
= 0; i
< nCols
; i
++)
287 m_colWidths
[i
] = widths
[i
];
289 m_colWidths
[i
] = defaultWidth
;
290 for (i
= 0; i
< nRows
; i
++)
291 m_rowHeights
[i
] = defaultHeight
;
293 m_gridCells
= new wxGridCell
**[nRows
];
295 for (i
= 0; i
< nRows
; i
++)
296 m_gridCells
[i
] = new wxGridCell
*[nCols
];
298 for (i
= 0; i
< nRows
; i
++)
299 for (j
= 0; j
< nCols
; j
++)
302 //m_gridCells[i][j] = OnCreateCell();
303 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CREATE_CELL
, this, i
, j
);
304 GetEventHandler()->ProcessEvent(g_evt
);
305 m_gridCells
[i
][j
] = g_evt
.m_cell
;
306 m_gridCells
[i
][j
]->SetTextValue(cellValues
[i
][j
]);
309 m_gridCells
[i
][j
] = (wxGridCell
*) NULL
;
311 m_rowLabelCells
= new wxGridCell
*[nRows
];
312 for (i
= 0; i
< nRows
; i
++)
313 m_rowLabelCells
[i
] = new wxGridCell(this);
314 m_colLabelCells
= new wxGridCell
*[nCols
];
315 for (i
= 0; i
< nCols
; i
++)
316 m_colLabelCells
[i
] = new wxGridCell(this);
318 m_wCursorRow
= m_wCursorColumn
= 0;
319 SetCurrentRect(0, 0);
321 // Need to determine various dimensions
325 int objectSizeX
= m_totalCols
;
327 int viewLengthX
= m_totalCols
;
330 m_hScrollBar->SetViewLength(viewLengthX);
331 m_hScrollBar->SetObjectLength(objectSizeX);
332 m_hScrollBar->SetPageSize(pageSizeX);
334 m_hScrollBar
->SetScrollbar(m_hScrollBar
->GetPosition(), pageSizeX
, objectSizeX
, viewLengthX
);
336 int objectSizeY
= m_totalRows
;
338 int viewLengthY
= m_totalRows
;
341 m_vScrollBar->SetViewLength(viewLengthY);
342 m_vScrollBar->SetObjectLength(objectSizeY);
343 m_vScrollBar->SetPageSize(pageSizeY);
346 m_vScrollBar
->SetScrollbar(m_vScrollBar
->GetPosition(), pageSizeY
, objectSizeY
, viewLengthY
);
351 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS
, this);
352 GetEventHandler()->ProcessEvent(g_evt
);
354 //OnChangeSelectionLabel();
355 wxGridEvent
g_evt2(GetId(), wxEVT_GRID_CHANGE_SEL_LABEL
, this);
356 GetEventHandler()->ProcessEvent(g_evt2
);
361 // Need to determine various dimensions
362 void wxGenericGrid::UpdateDimensions(void)
364 int canvasWidth
, canvasHeight
;
365 GetSize(&canvasWidth
, &canvasHeight
);
367 if (m_editCreated
&& m_editable
)
369 int controlW
, controlH
;
370 GetTextItem()->GetSize(&controlW
, &controlH
);
371 m_topOfSheet
= m_editControlPosition
.y
+ controlH
+ 2;
375 m_rightOfSheet
= m_leftOfSheet
+ m_verticalLabelWidth
;
377 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
379 if (m_rightOfSheet
> canvasWidth
)
382 m_rightOfSheet
+= m_colWidths
[i
];
384 m_bottomOfSheet
= m_topOfSheet
+ m_horizontalLabelHeight
;
385 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
387 if (m_bottomOfSheet
> canvasHeight
)
390 m_bottomOfSheet
+= m_rowHeights
[i
];
393 m_totalGridWidth
= m_leftOfSheet
+ m_verticalLabelWidth
;
394 for (i
= 0; i
< m_totalCols
; i
++)
396 m_totalGridWidth
+= m_colWidths
[i
];
398 m_totalGridHeight
= m_topOfSheet
+ m_horizontalLabelHeight
;
399 for (i
= 0; i
< m_totalRows
; i
++)
401 m_totalGridHeight
+= m_rowHeights
[i
];
405 wxGridCell
*wxGenericGrid::GetCell(int row
, int col
)
408 return (wxGridCell
*) NULL
;
410 if ((row
>= m_totalRows
) || (col
>= m_totalCols
))
411 return (wxGridCell
*) NULL
;
413 wxGridCell
*cell
= m_gridCells
[row
][col
];
416 // m_gridCells[row][col] = OnCreateCell();
417 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CREATE_CELL
, this, row
, col
);
418 GetEventHandler()->ProcessEvent(g_evt
);
419 m_gridCells
[row
][col
] = g_evt
.m_cell
;
420 return m_gridCells
[row
][col
];
426 void wxGenericGrid::SetGridClippingRegion(wxDC
*dc
)
428 int m_scrollWidthHoriz
= 0;
429 int m_scrollWidthVert
= 0;
431 GetClientSize(&cw
, &ch
);
433 if (m_hScrollBar
&& m_hScrollBar
->IsShown())
434 m_scrollWidthHoriz
= m_scrollWidth
;
435 if (m_vScrollBar
&& m_vScrollBar
->IsShown())
436 m_scrollWidthVert
= m_scrollWidth
;
438 // Don't paint over the scrollbars
439 dc
->SetClippingRegion(m_leftOfSheet
, m_topOfSheet
,
440 cw
- m_scrollWidthVert
- m_leftOfSheet
, ch
- m_scrollWidthHoriz
- m_topOfSheet
);
443 void wxGenericGrid::OnPaint(wxPaintEvent
& WXUNUSED(event
))
446 GetClientSize(&w
, &h
);
448 bool useDoubleBuffering
= (bool) wxUSE_DOUBLE_BUFFERING
;
449 if (useDoubleBuffering
)
451 // Reuse the old bitmap if possible
453 if (!m_doubleBufferingBitmap
||
454 (m_doubleBufferingBitmap
->GetWidth() < w
|| m_doubleBufferingBitmap
->GetHeight() < h
))
456 if (m_doubleBufferingBitmap
)
457 delete m_doubleBufferingBitmap
;
458 m_doubleBufferingBitmap
= new wxBitmap(w
, h
);
460 if (!m_doubleBufferingBitmap
|| !m_doubleBufferingBitmap
->Ok())
462 // If we couldn't create a new bitmap, perhaps because resources were low,
463 // then don't complain, just don't double-buffer
464 if (m_doubleBufferingBitmap
)
465 delete m_doubleBufferingBitmap
;
466 m_doubleBufferingBitmap
= (wxBitmap
*) NULL
;
467 useDoubleBuffering
= FALSE
;
471 if (useDoubleBuffering
)
473 wxPaintDC
paintDC(this);
474 wxMemoryDC
dc(& paintDC
);
475 dc
.SelectObject(* m_doubleBufferingBitmap
);
479 int vertScrollBarWidth
= m_scrollWidth
;
480 int horizScrollBarHeight
= m_scrollWidth
;
481 if (m_vScrollBar
&& !m_vScrollBar
->IsShown())
482 vertScrollBarWidth
= 0;
483 if (m_hScrollBar
&& !m_hScrollBar
->IsShown())
484 horizScrollBarHeight
= 0;
486 paintDC
.Blit(m_leftOfSheet
, m_topOfSheet
, w
- vertScrollBarWidth
- m_leftOfSheet
, h
- horizScrollBarHeight
- m_topOfSheet
,
487 &dc
, m_leftOfSheet
, m_topOfSheet
, wxCOPY
);
489 dc
.SelectObject(wxNullBitmap
);
498 void wxGenericGrid::PaintGrid(wxDC
& dc
)
501 dc
.SetOptimization(FALSE
);
503 SetGridClippingRegion(& dc
);
505 DrawLabelAreas(& dc
);
507 DrawEditableArea(& dc
);
508 DrawColumnLabels(& dc
);
513 /* Hilight present cell */
514 SetCurrentRect(m_wCursorRow
, m_wCursorColumn
);
515 if (m_currentRectVisible
)
518 dc
.DestroyClippingRegion();
519 dc
.SetOptimization(TRUE
);
523 // Erase (some of) the background.
524 // Currently, a Windows-only optimisation.
525 void wxGenericGrid::OnEraseBackground(wxEraseEvent
& WXUNUSED(event
) )
529 dc
.SetOptimization(FALSE
);
532 GetClientSize(& w
, & h
);
533 dc
.SetBrush(*wxLIGHT_GREY_BRUSH
);
534 dc
.SetPen(*wxLIGHT_GREY_PEN
);
536 if (m_hScrollBar
&& m_hScrollBar
->IsShown() && m_vScrollBar
&& m_vScrollBar
->IsShown())
538 dc
.DrawRectangle(w
- m_scrollWidth
, h
- m_scrollWidth
, m_scrollWidth
, m_scrollWidth
);
541 dc
.SetOptimization(TRUE
);
546 void wxGenericGrid::DrawLabelAreas(wxDC
*dc
)
549 GetClientSize(&cw
, &ch
);
551 dc
->SetPen(*wxTRANSPARENT_PEN
);
552 // dc->SetBrush(*dc->GetBackground());
554 // Should blank out any area which isn't going to be painted over.
555 // dc->DrawRectangle(m_leftOfSheet, m_bottomOfSheet, cw - m_leftOfSheet, ch - m_bottomOfSheet);
556 // dc->DrawRectangle(m_rightOfSheet, m_topOfSheet, cw - m_rightOfSheet, ch - m_topOfSheet);
558 // Paint the label areas
559 dc
->SetBrush(*m_labelBackgroundBrush
);
560 // dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_rightOfSheet - m_leftOfSheet + 1, m_horizontalLabelHeight + 1);
561 dc
->DrawRectangle(m_leftOfSheet
, m_topOfSheet
, cw
-m_leftOfSheet
, m_horizontalLabelHeight
+ 1);
562 // dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, m_bottomOfSheet - m_topOfSheet + 1);
563 dc
->DrawRectangle(m_leftOfSheet
, m_topOfSheet
, m_verticalLabelWidth
+ 1, ch
-m_topOfSheet
);
566 void wxGenericGrid::DrawEditableArea(wxDC
*dc
)
569 GetClientSize(&cw
, &ch
);
571 dc
->SetPen(*wxTRANSPARENT_PEN
);
572 dc
->SetBrush(*wxTheBrushList
->FindOrCreateBrush(m_cellBackgroundColour
, wxSOLID
));
573 // dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
574 // m_rightOfSheet-(m_leftOfSheet+m_verticalLabelWidth) + 1, m_bottomOfSheet - (m_topOfSheet+m_horizontalLabelHeight) + 1);
575 dc
->DrawRectangle(m_leftOfSheet
+m_verticalLabelWidth
, m_topOfSheet
+m_horizontalLabelHeight
,
576 cw
-(m_leftOfSheet
+m_verticalLabelWidth
), ch
- (m_topOfSheet
+m_horizontalLabelHeight
));
579 void wxGenericGrid::DrawGridLines(wxDC
*dc
)
582 GetClientSize(&cw
, &ch
);
588 dc
->SetPen(*m_divisionPen
);
590 int heightCount
= m_topOfSheet
+ m_horizontalLabelHeight
;
592 // Draw horizontal grey lines for cells
593 for (i
= m_scrollPosY
; i
< (m_totalRows
+1); i
++)
595 if (heightCount
> ch
)
599 dc
->DrawLine(m_leftOfSheet
, heightCount
,
602 heightCount
+= m_rowHeights
[i
];
607 if (m_verticalLabelWidth
> 0)
609 dc
->SetPen(*wxBLACK_PEN
);
611 // Draw horizontal black lines for row labels
612 int heightCount
= m_topOfSheet
+ m_horizontalLabelHeight
;
613 for (i
= m_scrollPosY
; i
< (m_totalRows
+1); i
++)
615 if (heightCount
> ch
)
619 dc
->DrawLine(m_leftOfSheet
, heightCount
,
620 m_verticalLabelWidth
, heightCount
);
622 heightCount
+= m_rowHeights
[i
];
625 // Draw a black vertical line for row number cells
626 dc
->DrawLine(m_leftOfSheet
+ m_verticalLabelWidth
, m_topOfSheet
,
627 m_leftOfSheet
+ m_verticalLabelWidth
, ch
);
628 // First vertical line
629 dc
->DrawLine(m_leftOfSheet
, m_topOfSheet
, m_leftOfSheet
, ch
);
631 dc
->SetPen(*wxWHITE_PEN
);
633 // Draw highlights on row labels
634 heightCount
= m_topOfSheet
+ m_horizontalLabelHeight
;
635 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
637 if (heightCount
> ch
)
641 dc
->DrawLine(m_leftOfSheet
+1, heightCount
+1,
642 m_verticalLabelWidth
, heightCount
+1);
643 dc
->DrawLine(m_leftOfSheet
+1, heightCount
+1,
644 m_leftOfSheet
+1, heightCount
+ m_rowHeights
[i
] - 1);
645 heightCount
+= m_rowHeights
[i
];
648 // Last one - down to the floor.
649 dc
->DrawLine(m_leftOfSheet
+1, heightCount
+1,
650 m_verticalLabelWidth
, heightCount
+1);
651 dc
->DrawLine(m_leftOfSheet
+1, heightCount
+1,
652 m_leftOfSheet
+1, ch
);
658 dc
->SetPen(*m_divisionPen
);
660 // Draw vertical grey lines for cells
661 int widthCount
= m_leftOfSheet
+ m_verticalLabelWidth
;
662 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
668 // Skip the first one
669 if (i
!= m_scrollPosX
)
671 dc
->DrawLine(widthCount
, m_topOfSheet
+ m_horizontalLabelHeight
,
672 widthCount
, m_bottomOfSheet
);
674 widthCount
+= m_colWidths
[i
];
678 dc
->DrawLine(widthCount
, m_topOfSheet
+ m_horizontalLabelHeight
,
679 widthCount
, m_bottomOfSheet
);
682 dc
->SetPen(*wxBLACK_PEN
);
684 // Draw two black horizontal lines for column number cells
686 m_leftOfSheet
, m_topOfSheet
,
688 dc
->DrawLine(m_leftOfSheet
, m_topOfSheet
+ m_horizontalLabelHeight
,
689 cw
, m_topOfSheet
+ m_horizontalLabelHeight
);
691 if (m_horizontalLabelHeight
> 0)
693 int widthCount
= m_leftOfSheet
+ m_verticalLabelWidth
;
695 // Draw black vertical lines for column number cells
696 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
702 dc
->DrawLine(widthCount
, m_topOfSheet
,
703 widthCount
, m_topOfSheet
+ m_horizontalLabelHeight
);
704 widthCount
+= m_colWidths
[i
];
709 dc
->DrawLine(widthCount
, m_topOfSheet
,
710 widthCount
, m_topOfSheet
+ m_horizontalLabelHeight
);
713 dc
->SetPen(*wxWHITE_PEN
);
714 widthCount
= m_leftOfSheet
+ m_verticalLabelWidth
;
716 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
722 dc
->DrawLine(widthCount
+1, m_topOfSheet
+1,
723 widthCount
+m_colWidths
[i
], m_topOfSheet
+1);
724 dc
->DrawLine(widthCount
+1, m_topOfSheet
+1,
725 widthCount
+1, m_topOfSheet
+m_horizontalLabelHeight
);
726 widthCount
+= m_colWidths
[i
];
729 // Last one - to the right side of the canvas.
730 dc
->DrawLine(widthCount
+1, m_topOfSheet
+1,
732 dc
->DrawLine(widthCount
+1, m_topOfSheet
+1,
733 widthCount
+1, m_topOfSheet
+m_horizontalLabelHeight
);
738 void wxGenericGrid::DrawColumnLabels(wxDC
*dc
)
741 GetClientSize(&cw
, &ch
);
743 if (m_horizontalLabelHeight
== 0)
749 // Draw letters for columns
750 rect
.y
= m_topOfSheet
+ 1;
751 rect
.height
= m_horizontalLabelHeight
- 1;
753 dc
->SetTextBackground(m_labelBackgroundColour
);
754 dc
->SetBackgroundMode(wxTRANSPARENT
);
755 // dc->SetTextForeground(m_labelTextColour);
757 int widthCount
= m_leftOfSheet
+ m_verticalLabelWidth
;
758 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
764 rect
.x
= 1 + widthCount
;
765 rect
.width
= m_colWidths
[i
];
766 DrawColumnLabel(dc
, &rect
, i
);
768 widthCount
+= m_colWidths
[i
];
773 void wxGenericGrid::DrawColumnLabel(wxDC
*dc
, wxRectangle
*rect
, int col
)
775 wxGridCell
*cell
= GetLabelCell(wxHORIZONTAL
, col
);
784 dc
->SetTextForeground(GetLabelTextColour());
785 dc
->SetFont(*GetLabelTextFont());
786 if ( !cell
->GetTextValue().IsNull() )
787 DrawTextRect(dc
, cell
->GetTextValue(), &rect2
, GetLabelAlignment(wxHORIZONTAL
));
791 void wxGenericGrid::DrawRowLabels(wxDC
*dc
)
794 GetClientSize(&cw
, &ch
);
796 if (m_verticalLabelWidth
== 0)
802 // Draw numbers for rows
803 rect
.x
= m_leftOfSheet
;
804 rect
.width
= m_verticalLabelWidth
;
806 int heightCount
= m_topOfSheet
+ m_horizontalLabelHeight
;
808 dc
->SetTextBackground(m_labelBackgroundColour
);
809 dc
->SetBackgroundMode(wxTRANSPARENT
);
811 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
813 if (heightCount
> ch
)
817 rect
.y
= 1 + heightCount
;
818 rect
.height
= m_rowHeights
[i
];
819 DrawRowLabel(dc
, &rect
, i
);
821 heightCount
+= m_rowHeights
[i
];
826 void wxGenericGrid::DrawRowLabel(wxDC
*dc
, wxRectangle
*rect
, int row
)
828 wxGridCell
*cell
= GetLabelCell(wxVERTICAL
, row
);
837 dc
->SetTextForeground(GetLabelTextColour());
838 dc
->SetFont(*GetLabelTextFont());
839 if ( !cell
->GetTextValue().IsNull() )
840 DrawTextRect(dc
, cell
->GetTextValue(), &rect2
, GetLabelAlignment(wxVERTICAL
));
844 void wxGenericGrid::DrawCells(wxDC
*dc
)
847 GetClientSize(&cw
, &ch
);
851 // Draw value corresponding to each cell
852 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
854 for (j
= m_scrollPosX
; j
< m_totalCols
; j
++)
856 SetCurrentRect(i
, j
, cw
, ch
);
857 if (m_currentRectVisible
)
859 DrawCellBackground(dc
, &m_currentRect
, i
, j
);
860 DrawCellValue(dc
, &m_currentRect
, i
, j
);
862 if (m_currentRect
.x
> cw
)
865 if (m_currentRect
.y
> ch
)
868 dc
->SetBackgroundMode(wxSOLID
);
869 dc
->SetPen(*wxBLACK_PEN
);
872 void wxGenericGrid::DrawCellBackground(wxDC
*dc
, wxRectangle
*rect
, int row
, int col
)
874 wxGridCell
*cell
= GetCell(row
, col
);
877 dc
->SetBrush(*cell
->GetBackgroundBrush());
878 dc
->SetPen(*wxTRANSPARENT_PEN
);
880 #if 0 // In wxWin 2.0 the dc code is exact. RR.
882 dc
->DrawRectangle(rect
->x
+1, rect
->y
+1, rect
->width
-1, rect
->height
-1);
884 dc
->DrawRectangle(rect
->x
+1, rect
->y
+1, rect
->width
, rect
->height
);
888 dc
->DrawRectangle(rect
->x
+1, rect
->y
+1, rect
->width
-1, rect
->height
-1);
890 dc
->SetPen(*wxBLACK_PEN
);
894 void wxGenericGrid::DrawCellValue(wxDC
*dc
, wxRectangle
*rect
, int row
, int col
)
896 wxGridCell
*cell
= GetCell(row
, col
);
899 wxBitmap
*bitmap
= cell
->GetCellBitmap();
909 DrawBitmapRect(dc
, bitmap
, &rect2
, cell
->GetAlignment());
913 dc
->SetBackgroundMode(wxTRANSPARENT
);
914 dc
->SetTextForeground(cell
->GetTextColour());
915 dc
->SetFont(*cell
->GetFont());
917 if ( !cell
->GetTextValue().IsNull() )
918 DrawTextRect(dc
, cell
->GetTextValue(), &rect2
, cell
->GetAlignment());
923 void wxGenericGrid::AdjustScrollbars(void)
926 GetClientSize(&cw
, &ch
);
928 // We find the view size by seeing how many rows/cols fit on
930 // BUT... this means that the scrollbar should be adjusted every time
931 // it's scrolled, as well as when sized, because with variable size rows/cols,
932 // the number of rows/col visible on the view differs according to what bit
933 // you're looking at. The object length is always the same, but the
934 // view length differs.
936 // Since this may not be known until the end of this function, we should probably call AdjustScrollbars
938 int vertScrollBarWidth
= m_scrollWidth
;
939 int horizScrollBarHeight
= m_scrollWidth
;
940 if (m_vScrollBar
&& !m_vScrollBar
->IsShown())
941 vertScrollBarWidth
= 0;
942 if (m_hScrollBar
&& !m_hScrollBar
->IsShown())
943 horizScrollBarHeight
= 0;
945 int noHorizSteps
= 0;
948 if (m_totalGridWidth
+ vertScrollBarWidth
<= cw
)
957 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
959 widthCount
+= m_colWidths
[i
];
960 // A partial bit doesn't count, we still have to scroll to see the
962 if (widthCount
+ m_leftOfSheet
+ m_verticalLabelWidth
> (cw
-vertScrollBarWidth
))
971 if (m_totalGridHeight
+ horizScrollBarHeight
<= ch
)
980 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
982 heightCount
+= m_rowHeights
[i
];
983 // A partial bit doesn't count, we still have to scroll to see the
985 if (heightCount
+ m_topOfSheet
+ m_horizontalLabelHeight
> (ch
-horizScrollBarHeight
))
994 if (m_totalGridWidth
+ vertScrollBarWidth
<= cw
)
997 m_hScrollBar
->Show(FALSE
);
1003 m_hScrollBar
->Show(TRUE
);
1006 if (m_totalGridHeight
+ horizScrollBarHeight
<= ch
)
1009 m_vScrollBar
->Show(FALSE
);
1015 m_vScrollBar
->Show(TRUE
);
1018 UpdateDimensions(); // Necessary in case m_scrollPosX/Y changed
1020 vertScrollBarWidth
= m_scrollWidth
;
1021 horizScrollBarHeight
= m_scrollWidth
;
1022 if (m_vScrollBar
&& !m_vScrollBar
->IsShown())
1023 vertScrollBarWidth
= 0;
1024 if (m_hScrollBar
&& !m_hScrollBar
->IsShown())
1025 horizScrollBarHeight
= 0;
1029 int nCols
= GetCols();
1030 m_hScrollBar
->SetScrollbar(m_hScrollBar
->GetPosition(), wxMax(noHorizSteps
, 1), (noHorizSteps
== 0) ? 1 : nCols
, wxMax(noHorizSteps
, 1));
1032 m_hScrollBar
->SetSize(m_leftOfSheet
, ch
- m_scrollWidth
-2,
1033 cw
- vertScrollBarWidth
- m_leftOfSheet
, m_scrollWidth
);
1038 int nRows
= GetRows();
1040 m_vScrollBar
->SetScrollbar(m_vScrollBar
->GetPosition(), wxMax(noVertSteps
, 1), (noVertSteps
== 0) ? 1 : nRows
, wxMax(noVertSteps
, 1));
1041 m_vScrollBar
->SetSize(cw
- m_scrollWidth
, m_topOfSheet
,
1042 m_scrollWidth
, ch
- m_topOfSheet
- horizScrollBarHeight
);
1046 void wxGenericGrid::OnSize(wxSizeEvent
& WXUNUSED(event
) )
1048 if (!m_vScrollBar
|| !m_hScrollBar
)
1054 GetClientSize(&cw
, &ch
);
1056 if (m_editCreated
&& m_editingPanel
&& GetTextItem() && GetTextItem()->IsShown())
1058 m_editingPanel
->SetSize(0, 0, cw
, m_editControlPosition
.height
+ m_editControlPosition
.y
+ 2);
1059 GetTextItem()->SetSize(m_editControlPosition
.x
, m_editControlPosition
.y
,
1060 cw
- m_editControlPosition
.x
, m_editControlPosition
.height
);
1064 bool wxGenericGrid::CellHitTest(int x
, int y
, int *row
, int *col
)
1066 // Find the selected cell and call OnSelectCell
1067 if (x
>= (m_leftOfSheet
+ m_verticalLabelWidth
) && y
>= (m_topOfSheet
+ m_horizontalLabelHeight
) &&
1068 x
<= m_rightOfSheet
&& y
<= m_bottomOfSheet
)
1070 // Calculate the cell number from x and y
1071 x
-= (m_verticalLabelWidth
+ m_leftOfSheet
);
1072 y
-= (m_topOfSheet
+ m_horizontalLabelHeight
);
1076 // Now we need to do a hit test for which row we're on
1077 int currentHeight
= 0;
1078 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
1080 if (y
>= currentHeight
&& y
<= (currentHeight
+ m_rowHeights
[i
]))
1085 currentHeight
+= m_rowHeights
[i
];
1088 // Now we need to do a hit test for which column we're on
1089 int currentWidth
= 0;
1090 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
1092 if (x
>= currentWidth
&& x
<= (currentWidth
+ m_colWidths
[i
]))
1097 currentWidth
+= m_colWidths
[i
];
1104 bool wxGenericGrid::LabelSashHitTest(int x
, int y
, int *orientation
, int *rowOrCol
, int *startPos
)
1109 if (x
>= (m_leftOfSheet
+ m_verticalLabelWidth
) && y
>= m_topOfSheet
&&
1110 x
<= m_rightOfSheet
&& y
<= (m_topOfSheet
+ m_horizontalLabelHeight
))
1112 // We may be on a column label sash.
1113 int currentWidth
= m_leftOfSheet
+ m_verticalLabelWidth
;
1114 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
1116 if (x
>= (currentWidth
+ m_colWidths
[i
] - tolerance
) && x
<= (currentWidth
+ m_colWidths
[i
] + tolerance
))
1118 *orientation
= wxHORIZONTAL
;
1120 *startPos
= currentWidth
;
1123 currentWidth
+= m_colWidths
[i
];
1127 else if (x
>= m_leftOfSheet
&& y
>= (m_topOfSheet
+ m_horizontalLabelHeight
) &&
1128 x
<= (m_leftOfSheet
+ m_verticalLabelWidth
) && y
<= m_bottomOfSheet
)
1130 // We may be on a row label sash.
1131 int currentHeight
= m_topOfSheet
+ m_horizontalLabelHeight
;
1132 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
1134 if (y
>= (currentHeight
+ m_rowHeights
[i
] - tolerance
) && y
<= (currentHeight
+ m_rowHeights
[i
] + tolerance
))
1136 *orientation
= wxVERTICAL
;
1138 *startPos
= currentHeight
;
1141 currentHeight
+= m_rowHeights
[i
];
1148 bool wxGenericGrid::LabelHitTest(int x
, int y
, int *row
, int *col
)
1150 // Find the selected label
1151 if (x
>= m_leftOfSheet
&& y
>= m_topOfSheet
&&
1152 x
<= m_rightOfSheet
&& y
<= m_bottomOfSheet
)
1154 // Calculate the cell number from x and y
1160 // Now we need to do a hit test for which row we're on
1161 int currentHeight
= m_horizontalLabelHeight
;
1162 for (i
= m_scrollPosY
; i
< m_totalRows
; i
++)
1164 if (y
>= currentHeight
&& y
<= (currentHeight
+ m_rowHeights
[i
]))
1169 currentHeight
+= m_rowHeights
[i
];
1171 if (y
>= 0 && y
<= m_horizontalLabelHeight
)
1176 // Now we need to do a hit test for which column we're on
1177 int currentWidth
= m_verticalLabelWidth
;
1178 for (i
= m_scrollPosX
; i
< m_totalCols
; i
++)
1180 if (x
>= currentWidth
&& x
<= (currentWidth
+ m_colWidths
[i
]))
1185 currentWidth
+= m_colWidths
[i
];
1187 if (x
>= 0 && x
<= m_verticalLabelWidth
)
1192 if ((*col
== -1) || (*row
== -1))
1200 void wxGenericGrid::OnMouseEvent(wxMouseEvent
& ev
)
1204 wxClientDC
dc(this);
1208 if (CellHitTest((int)ev
.GetX(), (int)ev
.GetY(), &row
, &col
))
1210 OnSelectCellImplementation(& dc
, row
, col
);
1212 //OnCellLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1213 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CELL_LCLICK
, this,
1214 row
, col
, (int)ev
.GetX(), (int)ev
.GetY(),
1215 ev
.ControlDown(), ev
.ShiftDown());
1216 GetEventHandler()->ProcessEvent(g_evt
);
1219 if (LabelHitTest((int)ev
.GetX(), (int)ev
.GetY(), &row
, &col
))
1221 //OnLabelLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1222 wxGridEvent
g_evt(GetId(), wxEVT_GRID_LABEL_LCLICK
, this,
1223 row
, col
, (int)ev
.GetX(), (int)ev
.GetY(),
1224 ev
.ControlDown(), ev
.ShiftDown());
1225 GetEventHandler()->ProcessEvent(g_evt
);
1230 else if (ev
.Dragging() && ev
.LeftIsDown())
1232 switch (m_dragStatus
)
1234 case wxGRID_DRAG_NONE
:
1237 if (LabelSashHitTest((int)ev
.GetX(), (int)ev
.GetY(), &orientation
, &m_dragRowOrCol
, &m_dragStartPosition
))
1239 if (orientation
== wxHORIZONTAL
)
1241 m_dragStatus
= wxGRID_DRAG_LEFT_RIGHT
;
1242 SetCursor(*m_horizontalSashCursor
);
1243 m_dragLastPosition
= (int)ev
.GetX();
1247 m_dragStatus
= wxGRID_DRAG_UP_DOWN
;
1248 SetCursor(*m_verticalSashCursor
);
1249 m_dragLastPosition
= (int)ev
.GetY();
1251 wxClientDC
dc(this);
1253 dc
.SetLogicalFunction(wxINVERT
);
1254 if (orientation
== wxHORIZONTAL
)
1255 dc
.DrawLine((int)ev
.GetX(), m_topOfSheet
, (int)ev
.GetX(), m_bottomOfSheet
);
1257 dc
.DrawLine(m_leftOfSheet
, (int)ev
.GetY(), m_rightOfSheet
, (int)ev
.GetY());
1264 case wxGRID_DRAG_LEFT_RIGHT
:
1266 wxClientDC
dc(this);
1268 dc
.SetLogicalFunction(wxINVERT
);
1269 dc
.DrawLine(m_dragLastPosition
, m_topOfSheet
, m_dragLastPosition
, m_bottomOfSheet
);
1271 dc
.DrawLine((int)ev
.GetX(), m_topOfSheet
, (int)ev
.GetX(), m_bottomOfSheet
);
1274 m_dragLastPosition
= (int)ev
.GetX();
1275 SetCursor(*m_horizontalSashCursor
);
1278 case wxGRID_DRAG_UP_DOWN
:
1280 wxClientDC
dc(this);
1282 dc
.SetLogicalFunction(wxINVERT
);
1283 dc
.DrawLine(m_leftOfSheet
, m_dragLastPosition
, m_rightOfSheet
, m_dragLastPosition
);
1285 dc
.DrawLine(m_leftOfSheet
, (int)ev
.GetY(), m_rightOfSheet
, (int)ev
.GetY());
1288 m_dragLastPosition
= (int)ev
.GetY();
1289 SetCursor(*m_verticalSashCursor
);
1294 else if (ev
.Moving())
1296 int rowOrCol
, orientation
, startPos
;
1297 if (LabelSashHitTest((int)ev
.GetX(), (int)ev
.GetY(), &orientation
, &rowOrCol
, &startPos
))
1299 if (orientation
== wxHORIZONTAL
)
1300 SetCursor(*m_horizontalSashCursor
);
1302 SetCursor(*m_verticalSashCursor
);
1305 SetCursor(*wxSTANDARD_CURSOR
);
1307 else if (ev
.LeftUp())
1309 switch (m_dragStatus
)
1311 case wxGRID_DRAG_LEFT_RIGHT
:
1313 wxClientDC
dc(this);
1315 dc
.SetLogicalFunction(wxINVERT
);
1316 dc
.DrawLine(m_dragLastPosition
, m_topOfSheet
, m_dragLastPosition
, m_bottomOfSheet
);
1317 dc
.SetLogicalFunction(wxCOPY
);
1321 if (ev
.GetX() > m_dragStartPosition
)
1323 m_colWidths
[m_dragRowOrCol
] = (short)(ev
.GetX() - m_dragStartPosition
);
1328 SetCursor(*wxSTANDARD_CURSOR
);
1330 GetClientSize(&cw
, &ch
);
1335 case wxGRID_DRAG_UP_DOWN
:
1337 wxClientDC
dc(this);
1339 dc
.SetLogicalFunction(wxINVERT
);
1340 dc
.DrawLine(m_leftOfSheet
, m_dragLastPosition
, m_rightOfSheet
, m_dragLastPosition
);
1341 dc
.SetLogicalFunction(wxCOPY
);
1345 if (ev
.GetY() > m_dragStartPosition
)
1347 m_rowHeights
[m_dragRowOrCol
] = (short)(ev
.GetY() - m_dragStartPosition
);
1352 SetCursor(*wxSTANDARD_CURSOR
);
1356 m_dragStatus
= wxGRID_DRAG_NONE
;
1358 else if (ev
.RightDown())
1361 if (CellHitTest((int)ev
.GetX(), (int)ev
.GetY(), &row
, &col
))
1363 //OnCellRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1364 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CELL_RCLICK
, this,
1365 row
, col
, (int)ev
.GetX(), (int)ev
.GetY(),
1366 ev
.ControlDown(), ev
.ShiftDown());
1367 GetEventHandler()->ProcessEvent(g_evt
);
1370 if (LabelHitTest((int)ev
.GetX(), (int)ev
.GetY(), &row
, &col
))
1372 //OnLabelRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1373 wxGridEvent
g_evt(GetId(), wxEVT_GRID_LABEL_RCLICK
, this,
1374 row
, col
, (int)ev
.GetX(), (int)ev
.GetY(),
1375 ev
.ControlDown(), ev
.ShiftDown());
1376 GetEventHandler()->ProcessEvent(g_evt
);
1381 void wxGenericGrid::OnSelectCellImplementation(wxDC
*dc
, int row
, int col
)
1383 m_wCursorColumn
= col
;
1386 //OnChangeSelectionLabel();
1387 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CHANGE_SEL_LABEL
, this);
1388 GetEventHandler()->ProcessEvent(g_evt
);
1390 SetGridClippingRegion(dc
);
1392 // Remove the highlight from the old cell
1393 if (m_currentRectVisible
)
1396 // Highlight the new cell and copy its content to the edit control
1397 SetCurrentRect(m_wCursorRow
, m_wCursorColumn
);
1398 wxGridCell
*cell
= GetCell(m_wCursorRow
, m_wCursorColumn
);
1401 if ( cell
->GetTextValue().IsNull() )
1402 m_textItem
->SetValue("");
1404 m_textItem
->SetValue(cell
->GetTextValue());
1407 SetGridClippingRegion(dc
);
1409 // Why isn't this needed for Windows??
1410 // Probably because of the SetValue??
1411 // Arrrrrgh. This isn't needed anywhere, of course. RR.
1413 // HighlightCell(dc);
1415 dc
->DestroyClippingRegion();
1417 //OnSelectCell(row, col);
1418 wxGridEvent
g_evt2(GetId(), wxEVT_GRID_SELECT_CELL
, this, row
, col
);
1419 GetEventHandler()->ProcessEvent(g_evt2
);
1422 wxGridCell
*wxGenericGrid::OnCreateCell(void)
1424 return new wxGridCell(this);
1427 void wxGenericGrid::OnChangeLabels(void)
1431 for (i
= 0; i
< m_totalRows
; i
++)
1433 sprintf(buf
, "%d", i
+1);
1434 SetLabelValue(wxVERTICAL
, buf
, i
);
1436 // A...Z,AA...ZZ,AAA...ZZZ, etc.
1437 for (i
= 0; i
< m_totalCols
; i
++)
1440 int noTimes
= (i
/26 + 1);
1441 int ch
= (i
% 26) + 65;
1443 for (j
= 0; j
< noTimes
; j
++)
1446 sprintf(buf2
, "%c", (char)ch
);
1449 SetLabelValue(wxHORIZONTAL
, buf
, i
);
1453 void wxGenericGrid::OnChangeSelectionLabel(void)
1458 wxString
rowLabel(GetLabelValue(wxVERTICAL
, GetCursorRow()));
1459 wxString
colLabel(GetLabelValue(wxHORIZONTAL
, GetCursorColumn()));
1461 wxString newLabel
= colLabel
+ rowLabel
;
1462 if ((newLabel
.Length() > 0) && (newLabel
.Length() <= 8) && GetTextItem())
1464 // GetTextItem()->SetLabel(newLabel);
1468 void wxGenericGrid::HighlightCell(wxDC
*dc
)
1470 dc
->SetLogicalFunction(wxINVERT
);
1473 dc
->DrawLine( m_currentRect
.x
+ 1,
1474 m_currentRect
.y
+ 1,
1475 m_currentRect
.x
+ m_currentRect
.width
- 1,
1476 m_currentRect
.y
+ 1);
1478 dc
->DrawLine( m_currentRect
.x
+ m_currentRect
.width
- 1,
1479 m_currentRect
.y
+ 1,
1480 m_currentRect
.x
+ m_currentRect
.width
- 1,
1481 m_currentRect
.y
+m_currentRect
.height
- 1 );
1483 dc
->DrawLine( m_currentRect
.x
+ m_currentRect
.width
- 1,
1484 m_currentRect
.y
+ m_currentRect
.height
- 1,
1485 m_currentRect
.x
+ 1,
1486 m_currentRect
.y
+ m_currentRect
.height
- 1);
1488 dc
->DrawLine( m_currentRect
.x
+ 1,
1489 m_currentRect
.y
+ m_currentRect
.height
- 1,
1490 m_currentRect
.x
+ 1,
1491 m_currentRect
.y
+ 1);
1493 dc
->SetLogicalFunction(wxCOPY
);
1496 void wxGenericGrid::DrawCellText(void)
1498 if (!m_currentRectVisible
)
1501 wxGridCell
*cell
= GetCell(GetCursorRow(), GetCursorColumn());
1505 static char szEdit
[300];
1507 wxClientDC
dc(this);
1510 SetGridClippingRegion(& dc
);
1512 dc
.SetBackgroundMode(wxTRANSPARENT
);
1513 dc
.SetBrush(*cell
->GetBackgroundBrush());
1515 strcpy(szEdit
, m_textItem
->GetValue());
1518 rect
= m_currentRect
;
1524 DrawTextRect(& dc
, " ", &rect
, wxLEFT
);
1525 DrawTextRect(& dc
, szEdit
, &rect
, cell
->GetAlignment());
1527 dc
.DestroyClippingRegion();
1529 dc
.SetBackgroundMode(wxSOLID
);
1534 void wxGenericGrid::SetCurrentRect(int Row
, int Column
, int canvasW
, int canvasH
)
1536 int currentWidth
= m_leftOfSheet
+ m_verticalLabelWidth
;
1538 for (i
= m_scrollPosX
; i
< Column
; i
++)
1539 currentWidth
+= m_colWidths
[i
];
1541 int currentHeight
= m_topOfSheet
+ m_horizontalLabelHeight
;
1542 for (i
= m_scrollPosY
; i
< Row
; i
++)
1543 currentHeight
+= m_rowHeights
[i
];
1545 m_currentRect
.x
= currentWidth
;
1546 m_currentRect
.y
= currentHeight
;
1547 m_currentRect
.width
= m_colWidths
? (m_colWidths
[Column
]) : 0;
1548 m_currentRect
.height
= m_rowHeights
? (m_rowHeights
[Row
]) : 0;
1550 if (Row
< m_scrollPosY
|| Column
< m_scrollPosX
)
1551 m_currentRectVisible
= FALSE
;
1552 else if ((canvasW
!= -1 && canvasH
!= -1) && (m_currentRect
.x
> canvasW
|| m_currentRect
.y
> canvasH
))
1553 m_currentRectVisible
= FALSE
;
1554 else m_currentRectVisible
= TRUE
;
1557 static bool wxRectIntersection(wxRectangle
*rect1
, wxRectangle
*rect2
, wxRectangle
*rect3
)
1559 int x2_1
= rect1
->x
+ rect1
->width
;
1560 int y2_1
= rect1
->y
+ rect1
->height
;
1562 int x2_2
= rect2
->x
+ rect2
->width
;
1563 int y2_2
= rect2
->y
+ rect2
->height
;
1567 // Check for intersection
1568 if ((rect1
->x
> x2_2
) || (rect2
->x
> x2_1
) ||
1569 (rect1
->y
> y2_2
) || (rect2
->y
> y2_1
))
1572 rect3
->x
= rect3
->y
= rect3
->width
= rect3
->height
= 0;
1576 if (rect1
->x
> rect2
->x
)
1577 rect3
->x
= rect1
->x
;
1579 rect3
->x
= rect2
->x
;
1580 if (rect1
->y
> rect2
->y
)
1581 rect3
->y
= rect1
->y
;
1583 rect3
->y
= rect2
->y
;
1594 rect3
->width
= (int)(x2_3
- rect3
->x
);
1595 rect3
->height
= (int)(y2_3
- rect3
->y
);
1599 void wxGenericGrid::DrawTextRect(wxDC
*dc
, const wxString
& text
, wxRectangle
*rect
, int flag
)
1603 // Ultimately, this functionality should be built into wxWindows,
1604 // and optimized for each platform. E.g. on Windows, use DrawText
1605 // passing a clipping rectangle, so that the wxWindows clipping region
1606 // does not have to be used to implement this.
1608 // If we're already clipping, we need to find the intersection
1609 // between current clipping area and text clipping area.
1611 wxRectangle clipRect
;
1612 wxRectangle clipRect2
;
1613 long clipX
, clipY
, clipW
, clipH
;
1614 dc
->GetClippingBox(&clipX
, &clipY
, &clipW
, &clipH
);
1615 clipRect
.x
= (int)clipX
; clipRect
.y
= (int)clipY
;
1616 clipRect
.width
= (int)clipW
; clipRect
.height
= (int)clipH
;
1618 bool alreadyClipping
= TRUE
;
1620 if (clipRect
.x
== 0 && clipRect
.y
== 0 && clipRect
.width
== 0 && clipRect
.height
== 0)
1622 alreadyClipping
= FALSE
;
1623 clipRect2
.x
= rect
->x
; clipRect2
.y
= rect
->y
;
1624 clipRect2
.width
= rect
->width
; clipRect2
.height
= rect
->height
;
1628 // Find intersection.
1629 if (!wxRectIntersection(rect
, &clipRect
, &clipRect2
))
1633 if (alreadyClipping
)
1634 dc
->DestroyClippingRegion();
1636 dc
->SetClippingRegion(clipRect2
.x
, clipRect2
.y
, clipRect2
.width
, clipRect2
.height
);
1637 long textWidth
, textHeight
;
1639 dc
->GetTextExtent(text
, &textWidth
, &textHeight
);
1647 x
= (rect
->x
+ rect
->width
- textWidth
- 1.0);
1648 y
= (rect
->y
+ (rect
->height
- textHeight
)/2.0);
1653 x
= (rect
->x
+ (rect
->width
- textWidth
)/2.0);
1654 y
= (rect
->y
+ (rect
->height
- textHeight
)/2.0);
1660 x
= (rect
->x
+ 1.0);
1661 y
= (rect
->y
+ (rect
->height
- textHeight
)/2.0);
1665 dc
->DrawText(text
, (long)x
, (long)y
);
1667 dc
->DestroyClippingRegion();
1669 // Restore old clipping
1670 if (alreadyClipping
)
1671 dc
->SetClippingRegion(clipRect
.x
, clipRect
.y
, clipRect
.width
, clipRect
.height
);
1676 void wxGenericGrid::DrawBitmapRect(wxDC
*dc
, wxBitmap
*bitmap
, wxRectangle
*rect
, int flag
)
1680 // Ultimately, this functionality should be built into wxWindows,
1681 // and optimized for each platform. E.g. on Windows, use DrawText
1682 // passing a clipping rectangle, so that the wxWindows clipping region
1683 // does not have to be used to implement this.
1685 // If we're already clipping, we need to find the intersection
1686 // between current clipping area and text clipping area.
1688 wxRectangle clipRect
;
1689 wxRectangle clipRect2
;
1690 long clipX
, clipY
, clipW
, clipH
;
1691 dc
->GetClippingBox(&clipX
, &clipY
, &clipW
, &clipH
);
1692 clipRect
.x
= (int)clipX
; clipRect
.y
= (int)clipY
;
1693 clipRect
.width
= (int)clipW
; clipRect
.height
= (int)clipH
;
1695 bool alreadyClipping
= TRUE
;
1697 if (clipRect
.x
== 0 && clipRect
.y
== 0 && clipRect
.width
== 0 && clipRect
.height
== 0)
1699 alreadyClipping
= FALSE
;
1700 clipRect2
.x
= rect
->x
; clipRect2
.y
= rect
->y
;
1701 clipRect2
.width
= rect
->width
; clipRect2
.height
= rect
->height
;
1705 // Find intersection.
1706 if (!wxRectIntersection(rect
, &clipRect
, &clipRect2
))
1710 if (alreadyClipping
)
1711 dc
->DestroyClippingRegion();
1713 dc
->SetClippingRegion(clipRect2
.x
, clipRect2
.y
, clipRect2
.width
, clipRect2
.height
);
1714 float bitmapWidth
, bitmapHeight
;
1716 bitmapWidth
= bitmap
->GetWidth();
1717 bitmapHeight
= bitmap
->GetHeight();
1725 x
= (long)(rect
->x
+ rect
->width
- bitmapWidth
- 1);
1726 y
= (long)(rect
->y
+ (rect
->height
- bitmapHeight
)/2.0);
1731 x
= (long)(rect
->x
+ (rect
->width
- bitmapWidth
)/2.0);
1732 y
= (long)(rect
->y
+ (rect
->height
- bitmapHeight
)/2.0);
1738 x
= (long)(rect
->x
+ 1);
1739 y
= (long)(rect
->y
+ (rect
->height
- bitmapHeight
)/2.0);
1744 dcTemp
.SelectObject(*bitmap
);
1746 dc
->Blit( (long)x
, (long)y
, (long)bitmapWidth
, (long)bitmapHeight
, &dcTemp
, 0, 0);
1747 dcTemp
.SelectObject(wxNullBitmap
);
1749 dc
->DestroyClippingRegion();
1751 // Restore old clipping
1752 if (alreadyClipping
)
1753 dc
->SetClippingRegion(clipRect
.x
, clipRect
.y
, clipRect
.width
, clipRect
.height
);
1758 void wxGenericGrid::OnActivate(bool active
)
1762 // Edit control should always have the focus
1763 if (GetTextItem() && GetEditable())
1765 GetTextItem()->SetFocus();
1766 wxGridCell
*cell
= GetCell(GetCursorRow(), GetCursorColumn());
1768 GetTextItem()->SetValue(cell
->GetTextValue());
1773 void wxGenericGrid::SetCellValue(const wxString
& val
, int row
, int col
)
1775 wxGridCell
*cell
= GetCell(row
, col
);
1778 cell
->SetTextValue(val
);
1780 RefreshCell(row
, col
, TRUE
);
1784 void wxGenericGrid::RefreshCell(int row
, int col
, bool setText
)
1786 // Don't refresh within a pair of batch brackets
1787 if (GetBatchCount() > 0)
1791 GetClientSize(&cw
, &ch
);
1793 SetCurrentRect(row
, col
, cw
, ch
);
1794 if (m_currentRectVisible
)
1796 wxGridCell
*cell
= GetCell(row
, col
);
1798 bool currentPos
= FALSE
;
1799 if (row
== m_wCursorRow
&& col
== m_wCursorColumn
&& GetTextItem() && GetTextItem()->IsShown() && setText
)
1801 GetTextItem()->SetValue(cell
->GetTextValue());
1804 // Gets refreshed anyway in MSW
1809 wxClientDC
dc(this);
1811 DrawCellBackground(& dc
, &m_currentRect
, row
, col
);
1812 DrawCellValue(& dc
, &m_currentRect
, row
, col
);
1818 wxString
& wxGenericGrid::GetCellValue(int row
, int col
)
1820 static wxString
emptyString("");
1822 wxGridCell
*cell
= GetCell(row
, col
);
1824 return cell
->GetTextValue();
1829 void wxGenericGrid::SetColumnWidth(int col
, int width
)
1831 if (col
<= m_totalCols
)
1832 m_colWidths
[col
] = width
;
1835 int wxGenericGrid::GetColumnWidth(int col
)
1837 if (col
<= m_totalCols
)
1838 return m_colWidths
[col
];
1843 void wxGenericGrid::SetRowHeight(int row
, int height
)
1845 if (row
<= m_totalRows
)
1846 m_rowHeights
[row
] = height
;
1849 int wxGenericGrid::GetRowHeight(int row
)
1851 if (row
<= m_totalRows
)
1852 return m_rowHeights
[row
];
1857 void wxGenericGrid::SetLabelSize(int orientation
, int sz
)
1859 if (orientation
== wxHORIZONTAL
)
1860 m_horizontalLabelHeight
= sz
;
1862 m_verticalLabelWidth
= sz
;
1864 SetCurrentRect(GetCursorRow(), GetCursorColumn());
1867 int wxGenericGrid::GetLabelSize(int orientation
)
1869 if (orientation
== wxHORIZONTAL
)
1870 return m_horizontalLabelHeight
;
1872 return m_verticalLabelWidth
;
1875 wxGridCell
*wxGenericGrid::GetLabelCell(int orientation
, int pos
)
1877 if (orientation
== wxHORIZONTAL
)
1879 if (m_colLabelCells
&& pos
< m_totalCols
)
1880 return m_colLabelCells
[pos
];
1882 return (wxGridCell
*) NULL
;
1886 if (m_rowLabelCells
&& pos
< m_totalRows
)
1887 return m_rowLabelCells
[pos
];
1889 return (wxGridCell
*) NULL
;
1893 void wxGenericGrid::SetLabelValue(int orientation
, const wxString
& val
, int pos
)
1895 wxGridCell
*cell
= GetLabelCell(orientation
, pos
);
1897 cell
->SetTextValue(val
);
1900 wxString
& wxGenericGrid::GetLabelValue(int orientation
, int pos
)
1902 static wxString emptyString
= "";
1903 wxGridCell
*cell
= GetLabelCell(orientation
, pos
);
1905 return cell
->GetTextValue();
1910 void wxGenericGrid::SetLabelAlignment(int orientation
, int align
)
1912 if (orientation
== wxHORIZONTAL
)
1913 m_horizontalLabelAlignment
= align
;
1915 m_verticalLabelAlignment
= align
;
1917 SetCurrentRect(GetCursorRow(), GetCursorColumn());
1920 int wxGenericGrid::GetLabelAlignment(int orientation
)
1922 if (orientation
== wxHORIZONTAL
)
1923 return m_horizontalLabelAlignment
;
1925 return m_verticalLabelAlignment
;
1928 void wxGenericGrid::SetLabelTextColour(const wxColour
& colour
)
1930 m_labelTextColour
= colour
;
1934 void wxGenericGrid::SetLabelBackgroundColour(const wxColour
& colour
)
1936 m_labelBackgroundColour
= colour
;
1937 m_labelBackgroundBrush
= wxTheBrushList
->FindOrCreateBrush(m_labelBackgroundColour
, wxSOLID
);
1940 void wxGenericGrid::SetEditable(bool edit
)
1945 int controlW
, controlH
;
1946 m_textItem
->GetSize(&controlW
, &controlH
);
1947 m_editControlPosition
.height
= controlH
;
1949 m_topOfSheet
= m_editControlPosition
.x
+ controlH
+ 2;
1952 m_editingPanel
->Show(TRUE
);
1953 m_textItem
->Show(TRUE
);
1954 m_textItem
->SetFocus();
1962 m_textItem
->Show(FALSE
);
1963 m_editingPanel
->Show(FALSE
);
1967 SetCurrentRect(GetCursorRow(), GetCursorColumn());
1970 GetClientSize(&cw
, &ch
);
1975 int m_scrollWidth = 16;
1976 GetClientSize(&cw, &ch);
1979 m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
1980 m_scrollWidth, ch - m_topOfSheet - m_scrollWidth);
1984 void wxGenericGrid::SetCellAlignment(int flag
, int row
, int col
)
1986 wxGridCell
*cell
= GetCell(row
, col
);
1988 cell
->SetAlignment(flag
);
1991 int wxGenericGrid::GetCellAlignment(int row
, int col
)
1993 wxGridCell
*cell
= GetCell(row
, col
);
1995 return cell
->GetAlignment();
1997 return m_cellAlignment
;
2000 void wxGenericGrid::SetCellAlignment(int flag
)
2002 m_cellAlignment
= flag
;
2004 for (i
= 0; i
< GetRows(); i
++)
2005 for (j
= 0; j
< GetCols(); j
++)
2007 GetCell(i
, j
)->SetAlignment(flag
);
2010 int wxGenericGrid::GetCellAlignment(void)
2012 return m_cellAlignment
;
2015 void wxGenericGrid::SetCellBackgroundColour(const wxColour
& col
)
2017 m_cellBackgroundColour
= col
;
2019 for (i
= 0; i
< GetRows(); i
++)
2020 for (j
= 0; j
< GetCols(); j
++)
2022 GetCell(i
, j
)->SetBackgroundColour(col
);
2025 void wxGenericGrid::SetCellBackgroundColour(const wxColour
& val
, int row
, int col
)
2027 wxGridCell
*cell
= GetCell(row
, col
);
2030 cell
->SetBackgroundColour(val
);
2031 RefreshCell(row
, col
);
2035 wxColour
& wxGenericGrid::GetCellBackgroundColour(int row
, int col
)
2037 wxGridCell
*cell
= GetCell(row
, col
);
2039 return cell
->GetBackgroundColour();
2041 return m_cellBackgroundColour
;
2044 void wxGenericGrid::SetCellTextColour(const wxColour
& val
, int row
, int col
)
2046 wxGridCell
*cell
= GetCell(row
, col
);
2049 cell
->SetTextColour(val
);
2050 RefreshCell(row
, col
);
2054 void wxGenericGrid::SetCellTextFont(wxFont
*fnt
, int row
, int col
)
2056 wxGridCell
*cell
= GetCell(row
, col
);
2060 RefreshCell(row
, col
);
2064 wxFont
*wxGenericGrid::GetCellTextFont(int row
, int col
)
2066 wxGridCell
*cell
= GetCell(row
, col
);
2068 return cell
->GetFont();
2070 return m_cellTextFont
;
2073 wxColour
& wxGenericGrid::GetCellTextColour(int row
, int col
)
2075 wxGridCell
*cell
= GetCell(row
, col
);
2077 return cell
->GetTextColour();
2079 return m_cellTextColour
;
2082 void wxGenericGrid::SetCellTextColour(const wxColour
& val
)
2084 m_cellTextColour
= val
;
2086 for (i
= 0; i
< GetRows(); i
++)
2087 for (j
= 0; j
< GetCols(); j
++)
2089 GetCell(i
, j
)->SetTextColour(val
);
2092 void wxGenericGrid::SetCellTextFont(wxFont
*fnt
)
2094 m_cellTextFont
= fnt
;
2096 for (i
= 0; i
< GetRows(); i
++)
2097 for (j
= 0; j
< GetCols(); j
++)
2099 GetCell(i
, j
)->SetFont(fnt
);
2102 void wxGenericGrid::SetCellBitmap(wxBitmap
*bitmap
, int row
, int col
)
2104 wxGridCell
*cell
= GetCell(row
, col
);
2107 cell
->SetCellBitmap(bitmap
);
2108 RefreshCell(row
, col
);
2112 wxBitmap
*wxGenericGrid::GetCellBitmap(int row
, int col
)
2114 wxGridCell
*cell
= GetCell(row
, col
);
2117 return cell
->GetCellBitmap();
2120 return (wxBitmap
*) NULL
;
2123 bool wxGenericGrid::InsertCols(int pos
, int n
, bool updateLabels
)
2125 if (pos
> m_totalCols
)
2129 return CreateGrid(1, n
);
2134 for (i
= 0; i
< m_totalRows
; i
++)
2136 wxGridCell
**cols
= m_gridCells
[i
];
2137 wxGridCell
**newCols
= new wxGridCell
*[m_totalCols
+ n
];
2138 for (j
= 0; j
< pos
; j
++)
2139 newCols
[j
] = cols
[j
];
2140 for (j
= pos
; j
< pos
+ n
; j
++)
2141 newCols
[j
] = new wxGridCell(this);
2142 for (j
= pos
+ n
; j
< m_totalCols
+ n
; j
++)
2143 newCols
[j
] = cols
[j
- n
];
2146 m_gridCells
[i
] = newCols
;
2150 short *newColWidths
= new short[m_totalCols
+ n
];
2151 for (j
= 0; j
< pos
; j
++)
2152 newColWidths
[j
] = m_colWidths
[j
];
2153 for (j
= pos
; j
< pos
+ n
; j
++)
2154 newColWidths
[j
] = wxGRID_DEFAULT_CELL_WIDTH
;
2155 for (j
= pos
+ n
; j
< m_totalCols
+ n
; j
++)
2156 newColWidths
[j
] = m_colWidths
[j
- n
];
2157 delete[] m_colWidths
;
2158 m_colWidths
= newColWidths
;
2161 wxGridCell
**newLabels
= new wxGridCell
*[m_totalCols
+ n
];
2162 for (j
= 0; j
< pos
; j
++)
2163 newLabels
[j
] = m_colLabelCells
[j
];
2164 for (j
= pos
; j
< pos
+ n
; j
++)
2165 newLabels
[j
] = new wxGridCell(this);
2166 for (j
= pos
+ n
; j
< m_totalCols
+ n
; j
++)
2167 newLabels
[j
] = m_colLabelCells
[j
- n
];
2169 delete[] m_colLabelCells
;
2170 m_colLabelCells
= newLabels
;
2176 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS
, this);
2177 GetEventHandler()->ProcessEvent(g_evt
);
2186 bool wxGenericGrid::InsertRows(int pos
, int n
, bool updateLabels
)
2188 if (pos
> m_totalRows
)
2192 return CreateGrid(n
, 1);
2197 wxGridCell
***rows
= new wxGridCell
**[m_totalRows
+ n
];
2200 for (i
= 0; i
< pos
; i
++)
2201 rows
[i
] = m_gridCells
[i
];
2203 for (i
= pos
; i
< pos
+ n
; i
++)
2205 rows
[i
] = new wxGridCell
*[m_totalCols
];
2206 for (j
= 0; j
< m_totalCols
; j
++)
2207 rows
[i
][j
] = new wxGridCell(this);
2210 for (i
= pos
+ n
; i
< m_totalRows
+ n
; i
++)
2211 rows
[i
] = m_gridCells
[i
- n
];
2213 delete[] m_gridCells
;
2217 short *newRowHeights
= new short[m_totalRows
+ n
];
2218 for (i
= 0; i
< pos
; i
++)
2219 newRowHeights
[i
] = m_rowHeights
[i
];
2220 for (i
= pos
; i
< pos
+ n
; i
++)
2221 newRowHeights
[i
] = wxGRID_DEFAULT_CELL_HEIGHT
;
2222 for (i
= pos
+ n
; i
< m_totalRows
+ n
; i
++)
2223 newRowHeights
[i
] = m_rowHeights
[i
- n
];
2224 delete[] m_rowHeights
;
2225 m_rowHeights
= newRowHeights
;
2228 wxGridCell
**newLabels
= new wxGridCell
*[m_totalRows
+ n
];
2229 for (i
= 0; i
< pos
; i
++)
2230 newLabels
[i
] = m_rowLabelCells
[i
];
2231 for (i
= pos
; i
< pos
+ n
; i
++)
2232 newLabels
[i
] = new wxGridCell(this);
2233 for (i
= pos
+ n
; i
< m_totalRows
+ n
; i
++)
2234 newLabels
[i
] = m_rowLabelCells
[i
- n
];
2236 delete[] m_rowLabelCells
;
2237 m_rowLabelCells
= newLabels
;
2243 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS
, this);
2244 GetEventHandler()->ProcessEvent(g_evt
);
2253 bool wxGenericGrid::AppendCols(int n
, bool updateLabels
)
2255 return InsertCols(GetCols(), n
, updateLabels
);
2258 bool wxGenericGrid::AppendRows(int n
, bool updateLabels
)
2260 return InsertRows(GetRows(), n
, updateLabels
);
2263 bool wxGenericGrid::DeleteRows(int pos
, int n
, bool updateLabels
)
2265 if (pos
> m_totalRows
)
2272 wxGridCell
***rows
= new wxGridCell
**[m_totalRows
- n
];
2275 for (i
= 0; i
< pos
; i
++)
2276 rows
[i
] = m_gridCells
[i
];
2278 for (i
= pos
+ n
; i
< m_totalRows
; i
++)
2279 rows
[i
-n
] = m_gridCells
[i
];
2281 delete[] m_gridCells
;
2285 short *newRowHeights
= new short[m_totalRows
- n
];
2286 for (i
= 0; i
< pos
; i
++)
2287 newRowHeights
[i
] = m_rowHeights
[i
];
2288 for (i
= pos
+ n
; i
< m_totalRows
; i
++)
2289 newRowHeights
[i
-n
] = m_rowHeights
[i
];
2290 delete[] m_rowHeights
;
2291 m_rowHeights
= newRowHeights
;
2294 wxGridCell
**newLabels
= new wxGridCell
*[m_totalRows
- n
];
2295 for (i
= 0; i
< pos
; i
++)
2296 newLabels
[i
] = m_rowLabelCells
[i
];
2297 for (i
= pos
+ n
; i
< m_totalRows
; i
++)
2298 newLabels
[i
-n
] = m_rowLabelCells
[i
];
2300 delete[] m_rowLabelCells
;
2301 m_rowLabelCells
= newLabels
;
2307 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS
, this);
2308 GetEventHandler()->ProcessEvent(g_evt
);
2315 bool wxGenericGrid::DeleteCols(int pos
, int n
, bool updateLabels
)
2317 if (pos
+ n
> m_totalCols
)
2325 for (i
= 0; i
< m_totalRows
; i
++)
2327 wxGridCell
**cols
= m_gridCells
[i
];
2328 wxGridCell
**newCols
= new wxGridCell
*[m_totalCols
- n
];
2329 for (j
= 0; j
< pos
; j
++)
2330 newCols
[j
] = cols
[j
];
2331 for (j
= pos
; j
< pos
+ n
; j
++)
2333 for (j
= pos
+ n
; j
< m_totalCols
; j
++)
2334 newCols
[j
-n
] = cols
[j
];
2337 m_gridCells
[i
] = newCols
;
2341 short *newColWidths
= new short[m_totalCols
- n
];
2342 for (j
= 0; j
< pos
; j
++)
2343 newColWidths
[j
] = m_colWidths
[j
];
2344 for (j
= pos
+ n
; j
< m_totalCols
; j
++)
2345 newColWidths
[j
-n
] = m_colWidths
[j
];
2346 delete[] m_colWidths
;
2347 m_colWidths
= newColWidths
;
2350 wxGridCell
**newLabels
= new wxGridCell
*[m_totalCols
- n
];
2351 for (j
= 0; j
< pos
; j
++)
2352 newLabels
[j
] = m_colLabelCells
[j
];
2353 for (j
= pos
+ n
; j
< m_totalCols
; j
++)
2354 newLabels
[j
-n
] = m_colLabelCells
[j
];
2356 delete[] m_colLabelCells
;
2357 m_colLabelCells
= newLabels
;
2363 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS
, this);
2364 GetEventHandler()->ProcessEvent(g_evt
);
2371 void wxGenericGrid::SetGridCursor(int row
, int col
)
2373 if (row
>= m_totalRows
|| col
>= m_totalCols
)
2376 if (row
== GetCursorRow() && col
== GetCursorColumn())
2379 wxClientDC
dc(this);
2382 SetGridClippingRegion(& dc
);
2384 if (m_currentRectVisible
)
2385 HighlightCell(& dc
);
2388 m_wCursorColumn
= col
;
2391 GetClientSize(&cw
, &ch
);
2393 SetCurrentRect(row
, col
, cw
, ch
);
2395 if (m_currentRectVisible
)
2396 HighlightCell(& dc
);
2398 dc
.DestroyClippingRegion();
2406 wxGridCell::wxGridCell(wxGenericGrid
*window
)
2408 cellBitmap
= (wxBitmap
*) NULL
;
2409 font
= (wxFont
*) NULL
;
2410 backgroundBrush
= (wxBrush
*) NULL
;
2412 textColour
= window
->GetCellTextColour();
2414 textColour
.Set(0,0,0);
2416 backgroundColour
= window
->GetCellBackgroundColour();
2418 backgroundColour
.Set(255,255,255);
2421 font
= window
->GetCellTextFont();
2423 font
= wxTheFontList
->FindOrCreateFont(12, wxSWISS
, wxNORMAL
, wxNORMAL
);
2425 SetBackgroundColour(backgroundColour
);
2428 alignment
= window
->GetCellAlignment();
2433 wxGridCell::~wxGridCell(void)
2437 void wxGridCell::SetBackgroundColour(const wxColour
& colour
)
2439 backgroundColour
= colour
;
2440 backgroundBrush
= wxTheBrushList
->FindOrCreateBrush(backgroundColour
, wxSOLID
);
2443 void wxGenericGrid::OnText(wxCommandEvent
& WXUNUSED(ev
) )
2445 wxGenericGrid
*grid
= this;
2446 wxGridCell
*cell
= grid
->GetCell(grid
->GetCursorRow(), grid
->GetCursorColumn());
2447 if (cell
&& grid
->CurrentCellVisible())
2449 cell
->SetTextValue(grid
->GetTextItem()->GetValue());
2450 wxClientDC
dc(grid
);
2453 grid
->SetGridClippingRegion(& dc
);
2454 grid
->DrawCellBackground(& dc
, &grid
->GetCurrentRect(), grid
->GetCursorRow(), grid
->GetCursorColumn());
2455 grid
->DrawCellValue(& dc
, &grid
->GetCurrentRect(), grid
->GetCursorRow(), grid
->GetCursorColumn());
2456 grid
->HighlightCell(& dc
);
2457 dc
.DestroyClippingRegion();
2460 //grid->OnCellChange(grid->GetCursorRow(), grid->GetCursorColumn());
2461 wxGridEvent
g_evt(GetId(), wxEVT_GRID_CELL_CHANGE
, grid
,
2462 grid
->GetCursorRow(), grid
->GetCursorColumn());
2463 GetEventHandler()->ProcessEvent(g_evt
);
2465 // grid->DrawCellText();
2469 void wxGenericGrid::OnGridScroll(wxScrollEvent
& ev
)
2471 static bool inScroll
= FALSE
;
2477 wxGenericGrid
*win
= this;
2479 bool change
= FALSE
;
2481 if (ev
.GetEventObject() == win
->GetHorizScrollBar())
2483 change
= (ev
.GetPosition() != m_scrollPosX
);
2484 win
->SetScrollPosX(ev
.GetPosition());
2488 change
= (ev
.GetPosition() != m_scrollPosY
);
2489 win
->SetScrollPosY(ev
.GetPosition());
2492 win
->UpdateDimensions();
2494 win
->SetCurrentRect(win
->GetCursorRow(), win
->GetCursorColumn());
2496 // Because rows and columns can be arbitrary sizes,
2497 // the scrollbars will need to be adjusted to reflect the
2501 if (change
) win
->Refresh(FALSE
);
2507 //----------------------------------------------------------------------
2508 // Default wxGridEvent handlers
2509 // (just redirect to the pre-existing virtual methods)
2511 void wxGenericGrid::_OnSelectCell(wxGridEvent
& ev
)
2513 OnSelectCell(ev
.m_row
, ev
.m_col
);
2516 void wxGenericGrid::_OnCreateCell(wxGridEvent
& ev
)
2518 ev
.m_cell
= OnCreateCell();
2521 void wxGenericGrid::_OnChangeLabels(wxGridEvent
& ev
)
2526 void wxGenericGrid::_OnChangeSelectionLabel(wxGridEvent
& ev
)
2528 OnChangeSelectionLabel();
2531 void wxGenericGrid::_OnCellChange(wxGridEvent
& ev
)
2533 OnCellChange(ev
.m_row
, ev
.m_col
);
2536 void wxGenericGrid::_OnCellLeftClick(wxGridEvent
& ev
)
2538 OnCellLeftClick(ev
.m_row
, ev
.m_col
, ev
.m_x
, ev
.m_y
, ev
.m_control
, ev
.m_shift
);
2541 void wxGenericGrid::_OnCellRightClick(wxGridEvent
& ev
)
2543 OnCellRightClick(ev
.m_row
, ev
.m_col
, ev
.m_x
, ev
.m_y
, ev
.m_control
, ev
.m_shift
);
2546 void wxGenericGrid::_OnLabelLeftClick(wxGridEvent
& ev
)
2548 OnLabelLeftClick(ev
.m_row
, ev
.m_col
, ev
.m_x
, ev
.m_y
, ev
.m_control
, ev
.m_shift
);
2551 void wxGenericGrid::_OnLabelRightClick(wxGridEvent
& ev
)
2553 OnLabelRightClick(ev
.m_row
, ev
.m_col
, ev
.m_x
, ev
.m_y
, ev
.m_control
, ev
.m_shift
);