dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/sdk/activex/controls/commondlls/hmmvgrid/celledit.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

2397 lines
56 KiB
C++
Raw Blame History

// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//***************************************************************************
//
// (c) 1996 by Microsoft Corporation
//
// CellEdit.cpp
//
// This file implements a grid cell editor for the CGrid class used in hmmv
// (the HMOM object viewer). This GridCell editor is customized for hmmv such
// that it understands certain datatypes.
//
// This class could be generalized such that it could be used as a "generic" cell
// editor base class so that different types of cell editors could be plugged
// into the grid class.
//
//
// a-larryf 17-Sept-96 Created.
//
//***************************************************************************
#include "precomp.h"
#include "resource.h"
#include "globals.h"
#include "CellEdit.h"
#include "grid.h"
#include "gca.h"
#include "gridhdr.h"
#include "globals.h"
#include "core.h"
#include "utils.h"
#include "notify.h"
#include "DlgObjectType.h"
#define CX_COMBO_DROP 16 // Width of the combo-drop button
#define CX_COMBO_DROP_MARGIN 1 // Margin on right side of combo drop button
#define CY_COMBO_DROP_MARGIN 1 // Margin on bottom side of combo drop botton
#define CY_EDIT_LISTBOX_MAX 100 // The maximum height of the combo listbox
#define CY_EDIT_LISTBOX_MIN 30 // The minimum height of the combo listbox
#define CX_EDIT_LISTBOX_MIN 90 // The minimum width of the listbox
#define CX_EDIT_LISTBOX_EXTEND 110 // The width of the listbox when extended
#define CTL_C 3
//************************************************************************
// Define how the strings in the combo box are mapped back to variant type
// values. This is necessary so that the type of buddy cells can be changed
// when a cell containing a type is changed.
//
//************************************************************************
TMapStringToLong amapAttribType[] = {
{IDS_ATTR_TYPE_BSTR, CIM_STRING},
{IDS_ATTR_TYPE_BOOL, CIM_BOOLEAN},
{IDS_ATTR_TYPE_I4, CIM_SINT32},
{IDS_ATTR_TYPE_R8, CIM_REAL64},
{IDS_ATTR_TYPE_BSTR_ARRAY, CIM_STRING | CIM_FLAG_ARRAY},
{IDS_ATTR_TYPE_BOOL_ARRAY, CIM_BOOLEAN | CIM_FLAG_ARRAY},
{IDS_ATTR_TYPE_I4_ARRAY, CIM_SINT32 | CIM_FLAG_ARRAY},
{IDS_ATTR_TYPE_R8_ARRAY, CIM_REAL64 | CIM_FLAG_ARRAY}
};
CMapStringToLong mapAttribType;
// CMapStringToLong mapCimType;
//*************************************************************
// String arrays for the strings that appear in the drop-down
// combo for cells that have enumerated values.
//
// The strings in these arrays are loaded from the string table
// by passing an array of the strings resource IDs to the CXStringArray
// constructor.
//
//*************************************************************
UINT auiCimtypeStrings[] =
{
IDS_CIMTYPE_UINT8,
IDS_CIMTYPE_SINT8, // I2
IDS_CIMTYPE_UINT16, // VT_I4 Unsigned 16-bit integer
IDS_CIMTYPE_CHAR16, // VT_I2 16 bit character.
IDS_CIMTYPE_SINT16, // VT_I2 Signed 16-bit integer
IDS_CIMTYPE_UINT32, // VT_I4 Unsigned 32-bit integer
IDS_CIMTYPE_SINT32, // VT_I4 Signed 32-bit integer
IDS_CIMTYPE_UINT64, // VT_BSTR Unsigned 64-bit integer
IDS_CIMTYPE_SINT64, // VT_BSTR Signed 64-bit integer
IDS_CIMTYPE_STRING, // VT_BSTR UCS-2 string
IDS_CIMTYPE_BOOL, // VT_BOOL Boolean
IDS_CIMTYPE_REAL32, // VT_R4 IEEE 4-byte floating-point
IDS_CIMTYPE_REAL64, // VT_R8 IEEE 8-byte floating-point
IDS_CIMTYPE_DATETIME, // VT_BSTR A string containing a date-time
IDS_CIMTYPE_REF, // VT_BSTR Weakly-typed reference
IDS_CIMTYPE_UINT8_ARRAY,
IDS_CIMTYPE_SINT8_ARRAY, // I2
IDS_CIMTYPE_UINT16_ARRAY, // VT_I4 Unsigned 16-bit integer
IDS_CIMTYPE_CHAR16_ARRAY, // VT_I2 16 bit character.
IDS_CIMTYPE_SINT16_ARRAY, // VT_I2 Signed 16-bit integer
IDS_CIMTYPE_UINT32_ARRAY, // VT_I4 Unsigned 32-bit integer
IDS_CIMTYPE_SINT32_ARRAY, // VT_I4 Signed 32-bit integer
IDS_CIMTYPE_UINT64_ARRAY, // VT_BSTR Unsigned 64-bit integer
IDS_CIMTYPE_SINT64_ARRAY, // VT_BSTR Signed 64-bit integer
IDS_CIMTYPE_STRING_ARRAY, // VT_BSTR UCS-2 string
IDS_CIMTYPE_BOOL_ARRAY, // VT_BOOL Boolean
IDS_CIMTYPE_REAL32_ARRAY, // VT_R4 IEEE 4-byte floating-point
IDS_CIMTYPE_REAL64_ARRAY, // VT_R8 IEEE 8-byte floating-point
IDS_CIMTYPE_DATETIME_ARRAY, // VT_BSTR A string containing a date-time
IDS_CIMTYPE_REF_ARRAY, // VT_BSTR Weakly-typed reference
IDS_CIMTYPE_OBJECT_ARRAY, // VT_UNKNOWN Weakly-typed embedded instance
IDS_CIMTYPE_OBJECT_DLG
};
UINT auiCimtypeScalarStrings[] =
{
IDS_CIMTYPE_UINT8,
IDS_CIMTYPE_SINT8, // I2
IDS_CIMTYPE_UINT16, // VT_I4 Unsigned 16-bit integer
IDS_CIMTYPE_CHAR16, // VT_I2 16 bit character
IDS_CIMTYPE_SINT16, // VT_I2 Signed 16-bit integer
IDS_CIMTYPE_UINT32, // VT_I4 Unsigned 32-bit integer
IDS_CIMTYPE_SINT32, // VT_I4 Signed 32-bit integer
IDS_CIMTYPE_UINT64, // VT_BSTR Unsigned 64-bit integer
IDS_CIMTYPE_SINT64, // VT_BSTR Signed 64-bit integer
IDS_CIMTYPE_STRING, // VT_BSTR UCS-2 string
IDS_CIMTYPE_BOOL, // VT_BOOL Boolean
IDS_CIMTYPE_REAL32, // VT_R4 IEEE 4-byte floating-point
IDS_CIMTYPE_REAL64, // VT_R8 IEEE 8-byte floating-point
IDS_CIMTYPE_DATETIME, // VT_BSTR A string containing a date-time
IDS_CIMTYPE_REF, // VT_BSTR Weakly-typed reference
// IDS_CIMTYPE_OBJECT, // VT_UNKNOWN Weakly-typed embedded instance
IDS_CIMTYPE_OBJECT_DLG
};
UINT auiAttrTypeStrings[] =
{
IDS_ATTR_TYPE_BSTR,
IDS_ATTR_TYPE_BOOL,
IDS_ATTR_TYPE_I4,
IDS_ATTR_TYPE_R8,
IDS_ATTR_TYPE_BSTR_ARRAY,
IDS_ATTR_TYPE_BOOL_ARRAY,
IDS_ATTR_TYPE_I4_ARRAY,
IDS_ATTR_TYPE_R8_ARRAY
};
UINT auiBoolStrings[] =
{
IDS_TRUE,
IDS_FALSE
};
CXStringArray saAttrType;
CXStringArray saCimType;
CXStringArray saCimtypeScalar;
CXStringArray saScope;
CXStringArray saBoolValues;
/////////////////////////////////////////////////////////////////////////////
// CCellEdit
//***********************************************************
// CCellEdit::CCellEdit
//
// Construct the CellEdit class. CellEdit is used for
// editing cells in the grid. The cell type determines the
// edit mode that will be used.
//
// Currently, only two edit modes are supported. A CEdit is used
// for generic text. Combo-box editing is used for any type that
// has an enumeration. Note that combo-box editing is implemented
// using a separate drop-down button, edit box, and list box to
// get the correct look and feel (the standard combo-box always
// draws an ugly border within the cell)
//
//
// Parameters:
// See the MFC documentation for header control notification
// messages.
//
// Returns:
// Nothing.
//
//************************************************************
CCellEdit::CCellEdit() : m_btnCombo(NOTIFY_CELL_EDIT_COMBO_DROP_CLICKED)
{
m_clrTextDirty = COLOR_DIRTY_CELL_TEXT; // Modified text is drawn in blue
m_clrTextClean = COLOR_CLEAN_CELL_TEXT; // Unmodified text is drawn in black
m_clrBkgnd = RGB( 255, 255, 255 );
m_brBkgnd.CreateSolidBrush( m_clrBkgnd );
m_bWasInitiallyDirty = FALSE;
m_pGrid = NULL;
m_pwndParent = NULL;
m_btnCombo.m_pClient = this;
m_lbCombo.m_pClient = this;
m_pgc = NULL;
m_iRow = NULL_INDEX;
m_iCol = NULL_INDEX;
m_lGridClickTime = 0;
m_pwndContextMenuTarget = NULL;
m_bPropagateChange = NULL;
m_bUIActive = FALSE;
m_bEditWithComboOnly = FALSE;
m_pgcCopy = NULL;
m_ptypeSave = new CGcType;
// Initialize the type maps if they haven't been initialized yet.
mapAttribType.Load(amapAttribType, sizeof(amapAttribType) / sizeof(TMapStringToLong));
// mapCimType.Load(amapCimType, sizeof(amapCimType) / sizeof(TMapStringToLong));
// Initialize the string tables if they haven't been initialized yet.
saAttrType.Load(auiAttrTypeStrings, sizeof(auiAttrTypeStrings)/sizeof(UINT));
saBoolValues.Load(auiBoolStrings, sizeof(auiBoolStrings)/sizeof(UINT));
saCimType.Load(auiCimtypeStrings, sizeof(auiCimtypeStrings)/sizeof(UINT));
saCimtypeScalar.Load(auiCimtypeScalarStrings, sizeof(auiCimtypeScalarStrings)/sizeof(UINT));
}
CCellEdit::~CCellEdit()
{
delete m_ptypeSave;
delete m_pgcCopy;
}
BEGIN_MESSAGE_MAP(CCellEdit, CEdit)
//{{AFX_MSG_MAP(CCellEdit)
ON_WM_CTLCOLOR_REFLECT()
ON_WM_CHAR()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONDBLCLK()
ON_WM_KEYDOWN()
ON_WM_SETFOCUS()
ON_WM_CONTEXTMENU()
ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
ON_COMMAND(ID_EDIT_CUT, OnEditCut)
ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
ON_COMMAND(ID_CMD_SET_CELL_TO_NULL, OnCmdSetCellToNull)
ON_CONTROL_REFLECT(EN_CHANGE, OnChange)
ON_WM_KILLFOCUS()
//}}AFX_MSG_MAP
ON_MESSAGE(WM_PASTE, OnPaste)
END_MESSAGE_MAP()
LRESULT CCellEdit::OnPaste(WPARAM wParam, LPARAM lParam)
{
// bug#58239
if (IsNull())
m_bIsNull = FALSE;
return CEdit::Default();
}
//***************************************************************
// CCellEdit::SetCell
//
// Set the editor's contents to the given cell.
//
// Parameters:
// CGridCell* pGridCell
// Pointer to the grid cell to set the editor's contents to.
//
// int iRow
// The row index of the cell in the grid.
//
// int iCol
// The column index of the cell in the grid.
//
// Returns:
// BOOL
// TRUE if the cell editor wants the focus, FALSE otherwise.
//
//****************************************************************
BOOL CCellEdit::SetCell(CGridCell* pGridCell, int iRow, int iCol)
{
ShowCombo(SW_HIDE);
m_bPropagateChange = FALSE;
m_iRow = iRow;
m_iCol = iCol;
m_pgc = pGridCell;
m_pwndContextMenuTarget = NULL;
SetReadOnly(FALSE);
// Set or remove the enumereration that will be shown in the
// drop-down combo.
SetEnumeration();
BOOL bReadOnly = TRUE;
// Set the value that appears in the CEdit
if (pGridCell == NULL) {
m_menuContext.DestroyMenu();
SetWindowText(_T(""), FALSE);
SetReadOnly(TRUE);
m_bIsNull = TRUE;
}
else {
bReadOnly = pGridCell->IsReadonly() || (pGridCell->GetFlags() &CELLFLAG_READONLY);
// Save a copy of the current state of the grid cell so that the
// state can be restored if the user hits escape.
if (m_pgcCopy) {
delete m_pgcCopy;
}
m_pgcCopy = new CGridCell(*pGridCell);
m_bIsNull = pGridCell->IsNull();
if (m_bIsNull) {
CString sEmpty;
if (m_pGrid->ShowNullAsEmpty()) {
sEmpty = _T("<empty>");
}
SetWindowText(sEmpty, FALSE);
}
else {
CString sValue;
CIMTYPE cimtype;
pGridCell->GetValue(sValue, cimtype);
SetWindowText(sValue, pGridCell->GetModified());
}
SetReadOnly(bReadOnly | m_bEditWithComboOnly);
}
BOOL bWantsFocus;
int nComboCount = m_lbCombo.GetCount();
if (!bReadOnly && m_lbCombo.m_hWnd!=NULL && nComboCount > 0) {
m_btnCombo.ShowWindow(SW_SHOW);
switch(m_pgc->GetType()) {
case CELLTYPE_ATTR_TYPE:
case CELLTYPE_CIMTYPE:
case CELLTYPE_CIMTYPE_SCALAR:
// Don't show any caret when doing combo style editing.
SetSel(-1, 0);
bWantsFocus = FALSE;
break;
default:
SetSel(0, -1);
bWantsFocus = TRUE;
};
}
else {
// Select everything when doing normal editing.
SetSel(GetWindowTextLength( ), 0);
bWantsFocus = TRUE;
}
m_bPropagateChange = TRUE;
return bWantsFocus;
}
//**********************************************************
// CCellEdit::SetEnumeration
//
// This method examines the cell being edited and sets up the
// enumeration listbox if an enumeration is required to edit the
// cell. An enumeration will be displayed if the combo listbox
// is not empty.
//
// Parameters:
// CGridCell* m_pgc
// The grid cell is passed in via this class member.
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::SetEnumeration()
{
// If there is no grid cell, then there is no enumeration.
m_bEditWithComboOnly = FALSE;
m_lbCombo.ResetContent();
if ((m_pgc == NULL) ||
(m_pgc->GetFlags() & CELLFLAG_READONLY) ||
m_pgc->IsReadonly()) {
ShowCombo(SW_HIDE);
Layout();
return;
}
CStringArray saEnumValues;
BOOL bProhibitEditing = TRUE;
// Setup enumerations for the following:
// 1. Boolean values
// 2. Attribute type names.
// 3. HMOM attribute scope.
// 4. Variant type names.
switch(m_pgc->GetType()) {
case CELLTYPE_CIMTYPE:
LoadListBox(saCimType);
break;
case CELLTYPE_CIMTYPE_SCALAR:
LoadListBox(saCimtypeScalar);
break;
case CELLTYPE_CHECKBOX:
case CELLTYPE_PROPMARKER:
case CELLTYPE_VOID:
break;
default:
switch(m_pgc->GetVariantType()) {
case VT_BOOL:
LoadListBox(saBoolValues);
break;
case VT_BSTR:
switch(m_pgc->GetType()) {
case CELLTYPE_ATTR_TYPE:
LoadListBox(saAttrType);
break;
case CELLTYPE_CIMTYPE:
LoadListBox(saCimType);
break;
case CELLTYPE_CIMTYPE_SCALAR:
LoadListBox(saCimtypeScalar);
break;
default:
m_pGrid->GetCellEnumStrings(m_iRow, m_iCol, saEnumValues);
if (saEnumValues.GetSize() > 0) {
LoadListBox(saEnumValues);
bProhibitEditing = FALSE;
}
break;
}
break;
default:
ShowCombo(SW_HIDE);
break;
}
}
if (m_lbCombo.GetCount() > 0) {
if (bProhibitEditing) {
m_bEditWithComboOnly = TRUE;
}
}
Layout();
}
//*********************************************************
// CCellEdit::LoadListBox
//
// Load the listbox with the enumeration strings.
//
// Parameters:
// CStringArray& sa
// A string array containing the strings to fill
// the listbox with.
//
// Returns:
// Nothing.
//
//*********************************************************
void CCellEdit::LoadListBox(CStringArray& sa)
{
LONG nStrings = (LONG) sa.GetSize();
for (LONG iString=0; iString < nStrings; ++iString) {
m_lbCombo.AddString(sa[iString]);
}
}
//**********************************************************
// CCellEdit::GetEditRect
//
// Calculate the rectangle that will be used to display
// the CEdit part of the cell editor. Note that the cell editor
// may consist of the CEdit, the listbox for the drop-down combo
// and the combo-drop button.
//
// Parameters:
// [out] RECT& rcEdit
// The place to return the rectangle for the CEdit portion
// of the cell editor.
//
// [in] BOOL bNeedsComboButton
// TRUE if a combo button needs to be displayed in the cell
// and the CEdit part of the cell should be reduced in size
// so that it doesn't overlap the button.
//
// [in] CRect& rcComboButton
// The rectangle where the combo button will be placed. This
// is valid only if bNeedsComboButton is TRUE.
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::GetEditRect(RECT& rcEdit, BOOL bNeedsComboButton, CRect& rcComboButton)
{
rcEdit.left = m_rcCell.left + CX_CELL_MARGIN;
if (rcEdit.left > m_rcCell.right) {
rcEdit.left = m_rcCell.right;
}
rcEdit.right = m_rcCell.right - CX_CELL_MARGIN;
if (m_lbCombo.m_hWnd && (m_lbCombo.GetCount() > 0)) {
// A combo is being displayed, so make room for the drop-down button.
rcEdit.right -= CX_COMBO_DROP + CX_COMBO_DROP_MARGIN;
}
if (rcEdit.right < rcEdit.left) {
rcEdit.right = rcEdit.left;
}
rcEdit.top = m_rcCell.top + CY_CELL_MARGIN;
if (rcEdit.top > m_rcCell.bottom) {
rcEdit.top = m_rcCell.bottom;
}
rcEdit.bottom = m_rcCell.bottom - CY_CELL_MARGIN;
if (rcEdit.bottom < rcEdit.top) {
rcEdit.bottom = rcEdit.top;
}
if (bNeedsComboButton) {
if (rcEdit.right > rcComboButton.left) {
rcEdit.right = rcComboButton.left;
}
}
else {
CRect rcParent;
m_pwndParent->GetClientRect(rcParent);
if (rcEdit.right > rcParent.right) {
rcEdit.right = rcParent.right;
}
}
}
//**********************************************************
// CCellEdit::GetListBoxRect
//
// Calculate the rectangle that will be used to display
// the CListBox part of the cell editor. Note that the cell editor
// may consist of the CEdit, the listbox for the drop-down combo
// and the combo-drop button.
//
// Parameters:
// RECT& rcListBox
// The place to return the rectangle for the CListBox portion
// of the cell editor.
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::GetListBoxRect(RECT& rcListBox)
{
CRect rcParent;
m_pwndParent->GetClientRect(rcParent);
// Figure out what the desired and the minimum sizes are for
// the listbox. cyText is the desired size. cyMin is the
// minimum size.
int cyText = 0;
if (m_lbCombo.m_hWnd != NULL ) {
cyText = m_lbCombo.GetCount() * CY_FONT;
}
if (cyText > CY_EDIT_LISTBOX_MAX) {
cyText = CY_EDIT_LISTBOX_MAX;
}
int cyMin = CY_EDIT_LISTBOX_MIN;
if (cyMin > cyText) {
cyMin = cyText;
}
// Make sure the listbox doesn't go beyond the parent's client area
rcListBox.left = m_rcCell.left;
rcListBox.right = m_rcCell.right;
if ((rcListBox.right - rcListBox.left) < CX_EDIT_LISTBOX_MIN) {
rcListBox.right = m_rcCell.left + CX_EDIT_LISTBOX_EXTEND;
}
if (rcListBox.right > rcParent.right) {
rcListBox.right = rcParent.right;
rcListBox.left = rcParent.right - CX_EDIT_LISTBOX_EXTEND;
}
if (rcListBox.left < rcParent.left) {
rcListBox.left = rcParent.left;
}
if ((m_rcCell.bottom + cyMin) > rcParent.bottom) {
// Place the listbox above the cell rectangle
rcListBox.top = m_rcCell.top - cyText;
if (rcListBox.top < rcParent.top) {
rcListBox.top = rcParent.top;
}
rcListBox.bottom = m_rcCell.top + 1;
}
else {
// Place the listbox below the cell rectangle
rcListBox.top = m_rcCell.bottom - 1;
rcListBox.bottom = m_rcCell.bottom + cyText;
if (rcListBox.bottom > rcParent.bottom) {
rcListBox.bottom = rcParent.bottom;
}
}
}
//**********************************************************
// CCellEdit::GetComboButtonRect
//
// Calculate the rectangle that will be used to display
// the CButton part of the cell editor. Note that the cell editor
// may consist of the CEdit, the listbox for the drop-down combo
// and the combo-drop button.
//
// Parameters:
// RECT& rcButton
// The place to return the rectangle for the CButton portion
// of the cell editor.
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::GetComboButtonRect(RECT& rcButton)
{
rcButton.left = m_rcCell.right - CX_COMBO_DROP - CX_COMBO_DROP_MARGIN;
if (rcButton.left < m_rcCell.left) {
rcButton.left = m_rcCell.left;
}
rcButton.top = m_rcCell.top;
rcButton.right = m_rcCell.right - CX_COMBO_DROP_MARGIN;
rcButton.bottom = m_rcCell.bottom - CY_COMBO_DROP_MARGIN;
// If the cell is entirely to the right of the parent's client rectangle,
// just return the button rectangle that we've calculated.
CRect rcParent;
m_pwndParent->GetClientRect(rcParent);
if (m_rcCell.left > rcParent.right) {
// ASSERT(FALSE);
return;
}
// If the right side of the cell is obscured by the right edge of the
// window, move the button left so that it is visible.
int cxButton = rcButton.right - rcButton.left;
if (rcButton.right > rcParent.right) {
// Fix up the boundary conditions to prevent the button from
// extending outside of the cell.
rcButton.left = rcParent.right - cxButton;
if (rcButton.left < m_rcCell.left) {
rcButton.left = m_rcCell.left;
}
rcButton.right = rcButton.left + cxButton;
if (rcButton.right > m_rcCell.right) {
rcButton.right = m_rcCell.right;
}
}
}
//**********************************************************
// CCellEdit::FixBuddyCell
//
// When a cell containing the "type" of buddy cell changes, then
// it may be necessary fix the value of the buddy cell to
// reflect the type change.
//
// Parameters:
// None
//
// Returns:
// Nothing
//
//**********************************************************
void CCellEdit::FixBuddyCell()
{
// If there is no buddy for the cell being edited, then
// there is nothing to do.
int iColBuddy = m_pgc->GetBuddy();
if (iColBuddy == NULL_INDEX) {
return;
}
CGridCell* pgcBuddy = &m_pGrid->GetAt(m_iRow, iColBuddy);
// Get the value of this cell and map the value to a variant type.
BOOL bFoundType;
CString sType;
GetWindowText(sType);
CGcType typeBuddy = pgcBuddy->type();
CGcType type = m_pgc->type();
long lTemp;
switch((CellType) type) {
case CELLTYPE_ATTR_TYPE:
bFoundType = mapAttribType.Lookup(sType, lTemp);
typeBuddy.SetCimtype((CIMTYPE) lTemp);
ASSERT(bFoundType);
break;
case CELLTYPE_CIMTYPE:
case CELLTYPE_CIMTYPE_SCALAR:
MapDisplayTypeToGcType(typeBuddy, sType);
typeBuddy.SetCellType(CELLTYPE_VARIANT); // MapDisplayTypeToGcType modifies the CellType
bFoundType = TRUE;
break;
default:
ASSERT(FALSE);
return;
break;
}
// If the new type is different from the buddy's current type,
// then change the type of the buddy to the new type and redraw it.
if (typeBuddy != pgcBuddy->type()) {
pgcBuddy->ChangeType(typeBuddy);
m_pGrid->DrawCell(m_iRow, iColBuddy);
}
}
//****************************************************************
// CCellEdit::GetStrongDisplayType
//
// When the user selects a type from
//**************************************************************
// CCellEdit::GetGcTypeFromCombo
//
// This method is called when the user releases the mouse button
// when selecting a type from the drop-down combo. The type is
// returned as a CGcType value that will carry with it the necessary
// information for strongly typed references and objects, strongly
// typed arrays of references and strongly typed arrays of objects.
//
// The CGcType value can then be mapped back into a displayable type
// that the user sees, and so on.
//
// Parameters:
// [out] CGcType& type
// The type value is returned here.
//
// Returns:
// SCODE
// S_OK if successful, E_FAIL otherwise.
//
//**************************************************************
SCODE CCellEdit::ComboSelectDisplayType(CGcType& type, LPCTSTR pszDisplayType)
{
MapDisplayTypeToGcType(type, pszDisplayType);
CIMTYPE cimtype = (CIMTYPE) type;
CIMTYPE cimtypeT = cimtype & ~CIM_FLAG_ARRAY;
switch(cimtypeT) {
case CIM_OBJECT:
case CIM_REFERENCE:
break;
default:
return S_OK;
}
// The type selected from the combo box may be "object" or "ref". In the
// event that the buddy (value) cell is already of type "object" or "ref",
// we want to get the cimtype string from the buddy so that we can preserve
// the classname for strongly typed references and objects.
CString sCimtype;
int iColBuddy = m_pgc->GetBuddy();
if (iColBuddy == NULL_INDEX) {
sCimtype = type.CimtypeString();
}
else {
CGridCell* pgcBuddy = &m_pGrid->GetAt(m_iRow, iColBuddy);
CGcType typeBuddy = pgcBuddy->type();
CIMTYPE cimtypeBuddy = (CIMTYPE) typeBuddy;
CIMTYPE cimtypeTBuddy = cimtypeBuddy & ~CIM_FLAG_ARRAY;
if (cimtypeT == cimtypeTBuddy) {
// Get the cimtype string from the buddy since it is the
// same basic type (object or reference). This is done
// to preserve the class name when the buddy cell is
// strongly typed.
sCimtype = typeBuddy.CimtypeString();
}
else {
// Changing an object to a reference or vice versa, so just use
// the basic "object" or "reference" for the cimtype string since
// it doesn't really make sense to preserve the classname if the
// buddy is strongly typed.
sCimtype = type.CimtypeString();
}
}
CDlgObjectType dlg;
switch (cimtypeT) {
case CIM_OBJECT:
dlg.EditObjType(m_pgc->Grid(), sCimtype);
type.SetCimtype(cimtype, sCimtype);
break;
case CIM_REFERENCE:
dlg.EditRefType(m_pgc->Grid(), sCimtype);
type.SetCimtype(cimtype, sCimtype);
break;
default:
ASSERT(FALSE);
return E_FAIL;
}
return S_OK;
}
//**********************************************************
// CCellEdit::CatchEvent
//
// Catch events sent from the listbox or the combo-drop button.
//
// Parameters:
// long lEvent
// The event id.
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::CatchEvent(long lEvent)
{
int iItem;
CString sText;
BOOL bChangedCimtype = FALSE;
CGcType type;
switch(lEvent) {
case NOTIFY_CELL_EDIT_COMBO_DROP_CLICKED:
// Control comes here when the user clicks the combo-drop
// button. When this happens, the listbox is shown and the
// focus is set to the listbox, etc.
if (m_lbCombo.IsWindowVisible()) {
m_lbCombo.ShowWindow(SW_HIDE);
SetFocus();
}
else {
CEdit::GetWindowText(sText);
CellType celltype = m_pgc->GetType();
switch(celltype) {
case CELLTYPE_CIMTYPE_SCALAR:
case CELLTYPE_CIMTYPE:
*m_ptypeSave = m_pgc->type();
if (HasObjectPrefix(sText)) {
sText.LoadString(IDS_CIMTYPE_OBJECT_DLG);
}
else if (::IsPrefix(_T("ref"), sText)) {
sText = "ref";
}
break;
}
iItem = m_lbCombo.FindString(-1, sText);
if (iItem >= 0) {
m_lbCombo.SetCurSel(iItem);
}
m_lbCombo.ShowWindow(SW_SHOW);
m_lbCombo.SetFocus();
}
break;
case NOTIFY_CELL_EDIT_LISTBOX_LBUTTON_UP:
m_lbCombo.ShowWindow(SW_HIDE);
ComboSelectionChanged();
SetFocus();
#if 0
// Control comes here when the user completes
// a selection of a value in the list box.
// Now it is necessary to hide the list box
// and set the cell's value to the selection
bModifyPrev = GetModify();
// Hide the list box and copy the selected value to the edit box.
iItem = m_lbCombo.GetCurSel();
if (iItem >= 0) {
m_lbCombo.GetText(iItem, sText);
CellType celltype = m_pgc->GetType();
if ((celltype == CELLTYPE_CIMTYPE) || (celltype == CELLTYPE_CIMTYPE_SCALAR)) {
//SelectCimtypeFromCombo();
sc = ComboSelectDisplayType(type, sText);
if (FAILED(sc)) {
return;
}
bChangedCimtype = (type != *m_ptypeSave);
::MapGcTypeToDisplayType(sText, type);
}
m_bIsNull = FALSE;
CEdit::SetWindowText(sText);
SetModify(TRUE);
}
bModified = GetModify();
// If the modification flag changed, then redraw the window
// so that the text appears in the correct color.
FixBuddyCell();
if (bChangedCimtype) {
m_pGrid->OnChangedCimtype(m_iRow, m_iCol);
}
if (GetModify() != bModifyPrev) {
if (m_pgc) {
m_pgc->SetModified(bModified);
}
if (m_pGrid) {
m_pGrid->SyncCellEditor();
m_pGrid->NotifyCellModifyChange();
RedrawWindow();
}
}
m_pGrid->SyncCellEditor();
m_pGrid->OnEnumSelection(m_iRow, m_iCol);
SetFocus();
#endif //0
break;
}
}
void CCellEdit::ComboSelectionChanged()
{
// Control comes here when the user completes
// a selection of a value in the list box.
// Now it is necessary to hide the list box
// and set the cell's value to the selection
SCODE sc;
BOOL bModifyPrev = GetModify();
BOOL bChangedCimtype = FALSE;
int iItem;
CString sText;
CGcType type;
// Hide the list box and copy the selected value to the edit box.
m_lbCombo.ShowWindow(SW_HIDE);
iItem = m_lbCombo.GetCurSel();
if (iItem >= 0) {
m_lbCombo.GetText(iItem, sText);
CellType celltype = m_pgc->GetType();
if ((celltype == CELLTYPE_CIMTYPE) || (celltype == CELLTYPE_CIMTYPE_SCALAR)) {
//SelectCimtypeFromCombo();
sc = ComboSelectDisplayType(type, sText);
if (FAILED(sc)) {
return;
}
bChangedCimtype = (type != *m_ptypeSave);
::MapGcTypeToDisplayType(sText, type);
}
m_bIsNull = FALSE;
CEdit::SetWindowText(sText);
SetModify(TRUE);
}
BOOL bModified = GetModify();
// If the modification flag changed, then redraw the window
// so that the text appears in the correct color.
FixBuddyCell();
if (bChangedCimtype) {
m_pGrid->OnChangedCimtype(m_iRow, m_iCol);
}
if (GetModify() != bModifyPrev) {
if (m_pgc) {
m_pgc->SetModified(bModified);
}
if (m_pGrid) {
m_pGrid->SyncCellEditor();
m_pGrid->NotifyCellModifyChange();
RedrawWindow();
}
}
m_pGrid->SyncCellEditor();
m_pGrid->OnEnumSelection(m_iRow, m_iCol);
SetFocus();
}
BOOL CCellEdit::EditRefType(BOOL& bChangedReftype)
{
bChangedReftype = FALSE;
#if 0
CString sCurrentText;
GetWindowText(sCurrentText);
SCODE sc;
CString sClass;
CDlgObjectType dlg;
sc = ClassFromReftype(sCurrentText, sClass);
if (SUCCEEDED(sc)) {
sText = sCurrentText;
dlg.SetReftype(sCurrentText);
bChangedReftype = TRUE;
}
int iResult = dlg.DoModal();
switch(iResult) {
case IDOK:
sText = dlg.Cimtype();
if (sText.CompareNoCase(sCurrentText)==0) {
return;
}
bChangedReftype = TRUE;
break;
case IDCANCEL:
return FALSE;
break;
}
#endif //0
return bChangedReftype;
}
//**********************************************************
// CCellEdit::RedrawWindow
//
// Redraw this window and its siblings (the combo listbox and button).
//
// Parameters:
// None
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::RedrawWindow()
{
CEdit::RedrawWindow();
if (m_btnCombo.IsWindowVisible()) {
m_btnCombo.RedrawWindow();
}
if (m_lbCombo.IsWindowVisible()) {
m_lbCombo.RedrawWindow();
}
}
//*************************************************************************
// CCellEdit::Create
//
// Create the cell editor window.
//
// Parameters:
// DWORD dwStyle
// The window style.
//
// RECT& rcCell
// The rectangle that the editor is to occupy in the grid.
//
// CWnd* pwndParent
// The parent window.
//
// UINT nID
// The window ID
//
// Returns:
// BOOL
// TRUE if the window was successfully created, FALSE otherwise.
//
//**************************************************************************
BOOL CCellEdit::Create( DWORD dwStyle, const RECT& rcCell, CWnd* pwndParent, UINT nID )
{
m_rcCell = rcCell;
m_pwndParent = pwndParent;
CRect rcComboButton;
BOOL bNeedsComboButton = UsesComboEditing();
if (bNeedsComboButton) {
GetComboButtonRect(rcComboButton);
}
CRect rcEdit;
GetEditRect(rcEdit, bNeedsComboButton, rcComboButton);
BOOL bDidCreate;
bDidCreate = CEdit::Create(dwStyle | ES_LEFT /* | ES_AUTOHSCROLL */ , rcEdit, pwndParent, nID);
if (!bDidCreate) {
return FALSE;
}
DWORD dwListBoxStyle;
dwListBoxStyle = WS_CHILD | LBS_STANDARD | LBS_WANTKEYBOARDINPUT ;
CRect rcListBox;
GetListBoxRect(rcListBox);
bDidCreate = m_lbCombo.Create(dwListBoxStyle, rcListBox, pwndParent, GenerateWindowID());
// Create the combo button
DWORD dwButtonStyle = (dwStyle & WS_VISIBLE) | WS_CHILD | BS_PUSHBUTTON;
bDidCreate = m_btnCombo.Create(NULL, dwButtonStyle, rcComboButton, pwndParent, GenerateWindowID());
if (bDidCreate) {
m_bmComboDrop.LoadBitmap(MAKEINTRESOURCE(IDB_COMBO_DROP));
m_btnCombo.ModifyStyle(0, BS_BITMAP);
m_btnCombo.SetBitmap((HBITMAP) m_bmComboDrop);
}
return bDidCreate;
}
//*******************************************************
// CCellEdit::Layout
//
// Layout the cell editors parts. This include the CEdit,
// the CButton for the combo-drop button, and the CListBox
// for the enumeration. Each of these windows are moved to
// the desired position in the grid. However, it may be the
// case that one or more of these siblings are not visible.
// For example, the CListBox portion of the window is visible
// only if the combo-drop button was clicked and there is
// an enumeration to show.
//
// Parameters:
// BOOL bRepaint
// TRUE if the windows should be repainted.
//
// Returns:
// Nothing.
//
//*******************************************************
void CCellEdit::Layout(BOOL bRepaint)
{
CRect rc;
CRect rcCurrent;
CRect rcComboButton;
BOOL bNeedsComboButton = UsesComboEditing();
if (bNeedsComboButton) {
GetComboButtonRect(rcComboButton);
}
if (m_hWnd) {
GetEditRect(rc, bNeedsComboButton, rcComboButton);
CEdit::GetWindowRect(rcCurrent);
m_pwndParent->ScreenToClient(rcCurrent);
if (!rc.EqualRect(&rcCurrent)) {
CEdit::MoveWindow(rc, bRepaint);
}
}
if (m_btnCombo.m_hWnd) {
GetComboButtonRect(rc);
m_btnCombo.GetWindowRect(rcCurrent);
m_pwndParent->ScreenToClient(rcCurrent);
if (!rc.EqualRect(&rcCurrent)) {
m_btnCombo.MoveWindow(rc, bRepaint);
}
}
if (m_lbCombo.m_hWnd) {
GetListBoxRect(rc);
m_lbCombo.GetWindowRect(rcCurrent);
m_lbCombo.ClientToScreen(rcCurrent);
if (!rc.EqualRect(&rcCurrent)) {
m_lbCombo.MoveWindow(rc, bRepaint);
}
}
}
//******************************************************
// CCellEdit::SetFont
//
// Set the font to the specified font.
//
// Parameters:
// CFont* pfont
// The font to select.
//
// BOOL bRedraw
// TRUE if the windows should be redrawn.
//
// Returns:
// Nothing.
//
//*******************************************************
void CCellEdit::SetFont(CFont* pfont, BOOL bRedraw)
{
if (m_hWnd) {
CEdit::SetFont(pfont, bRedraw);
}
if (m_lbCombo.m_hWnd) {
m_lbCombo.SetFont(pfont, bRedraw);
}
}
//*********************************************************
// CCellEdit::ShowWindow
//
// Show or hide the cell editor.
//
// Parameters:
// int nCmdShow
// See the MFC documentation for CWnd::ShowWindow
//
// Return:
// BOOL
// TRUE if the window was previously visible.
//
//**********************************************************
BOOL CCellEdit::ShowWindow( int nCmdShow )
{
BOOL bWasVisible = CEdit::ShowWindow(nCmdShow);
// If the listbox is empty, then this is not an enumeration,
// so keep the combo button and listbox hidden.
if (nCmdShow == SW_SHOW) {
if ((m_lbCombo.m_hWnd!=NULL) && (m_lbCombo.GetCount() == 0)) {
return bWasVisible;
}
}
#if 0
// Pass the show command on to the listbox and combo button.
if (nCmdShow != SW_SHOW) {
if (m_lbCombo.m_hWnd) {
m_lbCombo.ShowWindow(nCmdShow);
}
}
if (m_btnCombo.m_hWnd) {
m_btnCombo.ShowWindow(nCmdShow);
}
#endif //0
if (nCmdShow == SW_HIDE) {
ShowCombo(SW_HIDE);
if ((m_iRow != NULL_INDEX ) && (m_iCol != NULL_INDEX)) {
m_pGrid->DrawCell(m_iRow, m_iCol);
}
}
return bWasVisible;
}
void CCellEdit::ShowCombo(int nCmdShow)
{
int i = 0;
if (nCmdShow == SW_SHOW) {
i = 2;
}
if (m_lbCombo.m_hWnd != NULL) {
m_lbCombo.ShowWindow(nCmdShow);
}
if (m_btnCombo.m_hWnd != NULL) {
m_btnCombo.ShowWindow(nCmdShow);
}
}
//**************************************************************
// CCellEdit::MoveWindow
//
// Move the cell editor to a new location on the grid.
//
// Parameters:
// LPRECT lpRect
// A pointer to the destination rectangle.
//
// BOOL bRepaint
// TRUE if the cell editor should be repainted.
//
// Returns:
// Nothing.
//
//*************************************************************
void CCellEdit::MoveWindow( LPCRECT lpRect, BOOL bRepaint)
{
m_rcCell = *lpRect;
Layout(bRepaint);
}
//************************************************************
// CCellEdit::CtlColor
//
// Method for WM_CTLCOLOR to select the colors for this CCellEdit
// control.
//
// Parameters:
// See the MFC documentation for OnCtlColor
//
// Returns:
// HBRUSH
// The brush handle that the background will be painted with.
// A NULL value means use the parent's handler for CtlColor().
//
//***************************************************************
HBRUSH CCellEdit::CtlColor(CDC* pDC, UINT nCtlColor)
{
if (GetModify()) {
pDC->SetTextColor(m_clrTextDirty);
}
else {
pDC->SetTextColor(m_clrTextClean);
}
pDC->SetBkColor( m_clrBkgnd ); // text bkgnd
return m_brBkgnd; // ctl bkgnd
}
//***************************************************************
// CCellEdit::RevertToInitialValue
//
// Revert the cell to its initial value. This method is called
// when an ESC cahracter is entered.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//***************************************************************
void CCellEdit::RevertToInitialValue()
{
if (m_pgcCopy) {
*m_pgc = *m_pgcCopy;
}
SetCell(m_pgc, m_iRow, m_iCol);
FixBuddyCell();
}
BOOL CCellEdit::IsBooleanCell()
{
if (m_pgc == NULL) {
return FALSE;
}
CGcType type = m_pgc->type();
CIMTYPE cimtype = (CIMTYPE) type;
BOOL bIsBoolean = ((cimtype & ~CIM_FLAG_ARRAY) == CIM_BOOLEAN);
return bIsBoolean;
}
void CCellEdit::SetBooleanCellValue(BOOL bValue)
{
ASSERT(IsBooleanCell());
// Initialize the boolean value that we're editing to true
CGcType type = m_pgc->type();
CIMTYPE cimtype = (CIMTYPE) type;
COleVariant varValue;
varValue.ChangeType(VT_BOOL);
varValue.boolVal = bValue ? VARIANT_TRUE : VARIANT_FALSE;
m_pgc->SetValue(type, varValue);
m_bIsNull = FALSE;
}
BOOL CCellEdit::GetBooleanCellValue()
{
ASSERT(IsBooleanCell());
if (m_pgc != NULL) {
COleVariant var;
CIMTYPE cimtype;
m_pgc->GetValue(var, cimtype);
if (var.vt != VT_BOOL) {
return FALSE;
}
return var.boolVal;
}
return FALSE;
}
//***************************************************************
// CCellEdit::OnChar
//
// Called for each character entered into the edit box.
//
// We trap this message so that we can correct the "modify" flag
// to reflect the possibility that the initial text value was
// dirty to start with.
//
// Parameters:
// See the MFC documentation.
//
// Returns:
// Nothing.
//
//***************************************************************
void CCellEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
BOOL bModifyInitial = GetModify();
SCODE sc;
switch (nChar) {
case VK_TAB:
case ESC_CHAR:
case CTL_C:
break;
default:
if (m_pgc && (m_pgc->GetFlags() & CELLFLAG_READONLY)) {
Beep(1700, 40);
return;
}
break;
}
switch (nChar) {
case VK_TAB:
return;
case ESC_CHAR:
RevertToInitialValue();
return;
}
CString sText;
if (IsBooleanCell()) {
BOOL bVal = TRUE;
switch (nChar) {
case ' ':
// Toggle the value.
bVal = GetBooleanCellValue();
bVal = !bVal;
break;
case 'N':
case 'n':
case 'f':
case 'F':
case '0':
bVal = FALSE;
break;
default:
break;
}
SetBooleanCellValue(bVal);
if (bVal) {
sText.LoadString(IDS_TRUE);
}
else {
sText.LoadString(IDS_FALSE);
}
SetWindowText(sText, TRUE);
}
else if (UsesComboEditing()) {
GetWindowText(sText);
if (m_bEditWithComboOnly) {
sc = m_lbCombo.MapCharToItem(sText, nChar);
if (SUCCEEDED(sc)) {
SetWindowText(sText, TRUE);
int iItem = m_lbCombo.FindString(0, sText);
ASSERT(iItem >= 0);
m_lbCombo.SetCurSel(iItem);
ComboSelectionChanged();
}
}
}
// Notify the grid that a WM_CHAR occurred in the cell.
if (m_pGrid) {
m_pGrid->OnCellChar(m_iRow,
m_iCol,
nChar, nRepCnt, nFlags);
}
if (m_lbCombo.GetCount()>0) {
// If this cell contains an enumeration, it doesn't make sense to
// allow the user to directly enter the value. They should use the
// drop-down instead.
switch(m_pgc->GetType()) {
case CELLTYPE_ATTR_TYPE:
case CELLTYPE_CIMTYPE:
case CELLTYPE_CIMTYPE_SCALAR:
return;
};
}
BOOL bModifyPrev = GetModify();
if (IsNull()) {
SetWindowText(_T(""), TRUE);
m_bIsNull = FALSE;
RedrawWindow();
}
CEdit::OnChar(nChar, nRepCnt, nFlags);
if ((nChar == CONTROL_Z_CHAR)) {
CString sText;
GetWindowText(sText);
if (sText != m_sInitialText) {
SetModify(TRUE);
}
else {
SetModify(FALSE);
}
}
// If the modification flag changed, then redraw the window
// so that the text appears in the correct color.
if (m_pGrid) {
if (GetModify() != bModifyInitial) {
m_pGrid->NotifyCellModifyChange();
}
}
if (GetModify() != bModifyPrev) {
RedrawWindow();
}
}
//******************************************************************
// CCellEdit::SetWindowText
//
// This version of SetWindowText has an extra parameter to indicate
// whether or not the text value should be displayed in the "dirty"
// color.
//
// Parameters:
// CString& sText
// The text to display.
//
// BOOL bIsDirtyText
// TRUE if the text is initially dirty. This could happen if
// the user edits a field, thus making it dirty, selects another
// field and then comes back to the same "dirty" field.
//
//*****************************************************************
void CCellEdit::SetWindowText(LPCTSTR pszText, BOOL bIsDirtyText)
{
m_bWasInitiallyDirty = bIsDirtyText;
m_sInitialText = pszText;
CEdit::SetWindowText(pszText);
SetModify(bIsDirtyText);
RedrawWindow();
}
//**********************************************************
// CCellEdit::ReplaceSel
//
// This version of ReplaceSel marks the text as "dirty" and
// the redraws the window in the new color if the previous
// text was clean.
//
// Parameters:
// LPCTSTR pszText
// Pointer to the new window text.
//
// BOOL bCanUndo
// TRUE if undo operations are allowed.
//
// Returns:
// Nothing.
//
//***********************************************************
void CCellEdit::ReplaceSel(LPCTSTR pszText, BOOL bCanUndo)
{
BOOL bModifyPrev = GetModify();
CEdit::ReplaceSel(pszText, bCanUndo);
SetModify(TRUE);
if (GetModify() != bModifyPrev) {
if (m_pGrid) {
m_pGrid->NotifyCellModifyChange();
}
RedrawWindow();
}
}
//******************************************************************
// CCellEdit::OnLButtonDown
//
// When the mouse is clicked on the CEdit part of the cell editor,
// hide the drop-down list if it is not already hidden.
//
// Parameters:
// See the MFC documentation for WM_LBUTTONDOWN
//
// Returns:
// Nothing.
//
//*****************************************************************
void CCellEdit::OnLButtonDown(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
CEdit::OnLButtonDown(nFlags, point);
// Check to see if the cell editor was double clicked. If so,
// tell the parent that a double click occurred.
UINT uiDblClickTime = ::GetDoubleClickTime();
LONG lClickTime = GetMessageTime();
LONG ldtClick;
if (lClickTime > m_lGridClickTime) {
ldtClick = lClickTime - m_lGridClickTime;
}
else {
ldtClick = m_lGridClickTime - lClickTime;
}
if (ldtClick < (LONG) ::GetDoubleClickTime()) {
// Double click detected.
CPoint ptGrid = point;
ClientToScreen(&ptGrid);
m_pGrid->ScreenToClient(&ptGrid);
m_pGrid->SetFocus();
m_pGrid->NotifyDoubleClk(nFlags, ptGrid);
}
if (UsesComboEditing()) {
switch(m_pgc->GetType()) {
case CELLTYPE_ATTR_TYPE:
case CELLTYPE_CIMTYPE:
case CELLTYPE_CIMTYPE_SCALAR:
// Remove the selection.
SetSel(-1, 0);
return;
};
}
if (m_lbCombo.IsWindowVisible()) {
m_lbCombo.ShowWindow(SW_HIDE);
}
}
//******************************************************************
// CCellEdit::OnLButtonDown
//
// When the mouse is double-clicked on the CEdit part of the cell editor,
// hide the drop-down list if it is not already hidden then pass the double-click
// on to the grid control.
//
// Parameters:
// See the MFC documentation for WM_LBUTTONDBLCLICK
//
// Returns:
// Nothing.
//
//*****************************************************************
void CCellEdit::OnLButtonDblClk(UINT nFlags, CPoint point)
{
if (m_lbCombo.IsWindowVisible()) {
m_lbCombo.ShowWindow(SW_HIDE);
}
if (m_pGrid) {
ClientToScreen(&point);
m_pGrid->ScreenToClient(&point);
m_pGrid->NotifyDoubleClk(nFlags, point);
}
}
//****************************************************************
// CCellEdit::UsesComboEditing
//
// Check to see if a combo box is used for the editing.
//
// Parameters:
// See the MFC documentation.
//
// Returns:
// Nothing.
//
//***************************************************************
BOOL CCellEdit::UsesComboEditing()
{
if (!::IsWindow(m_lbCombo.m_hWnd)) {
return FALSE;
}
BOOL bUseComboEditing = m_lbCombo.GetCount() > 0;
return bUseComboEditing;
}
BOOL CCellEdit::PreTranslateMessage(MSG* pMsg)
{
switch (pMsg->message)
{
case WM_KEYDOWN:
switch (pMsg->wParam)
{
case VK_TAB:
m_pGrid->OnTabKey(GetKeyState(VK_SHIFT) < 0);
return TRUE;
}
break;
}
return CEdit::PreTranslateMessage(pMsg);
}
/////////////////////////////////////////////////////////////////////////////
// CLbCombo
//
// This class is the listbox that drops down when the combo-drop button is
// clicked in the cell editor. This class exists for the sole purpose of
// notifying its sibling (the CEdit part of the cell editor) when a selection
// is made in the combo box.
//
/////////////////////////////////////////////////////////////////////////////
CLbCombo::CLbCombo()
{
m_pClient = NULL;
m_bUIActive = FALSE;
}
CLbCombo::~CLbCombo()
{
}
BEGIN_MESSAGE_MAP(CLbCombo, CListBox)
//{{AFX_MSG_MAP(CLbCombo)
ON_WM_LBUTTONUP()
ON_WM_SETFOCUS()
ON_WM_KILLFOCUS()
ON_WM_CHAR()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CLbCombo message handlers
//****************************************************************
// CLbCombo::OnLButtonUp
//
// When the mouse button is released, send a message to the sibling
// window so that it can get the current selection.
//
// Parameters:
// See the MFC documentation.
//
// Returns:
// Nothing.
//
//***************************************************************
void CLbCombo::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
CListBox::OnLButtonUp(nFlags, point);
m_pClient->CatchEvent(NOTIFY_CELL_EDIT_LISTBOX_LBUTTON_UP);
}
void CCellEdit::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
CEdit::OnKeyDown(nChar, nRepCnt, nFlags);
BOOL bWasModified = GetModify();
if (m_pGrid) {
if (m_pGrid->OnCellKeyDown(m_iRow,
m_iCol,
nChar, nRepCnt, nFlags)) {
// The derived class handled the keydown,
// so just set the modified state.
BOOL bIsModified = GetModify();
if (!bWasModified && bIsModified) {
if (m_pGrid) {
m_pGrid->NotifyCellModifyChange();
}
}
return;
}
}
// The derived class, did not handle this keydown
// event.
switch(nChar) {
case VK_UP:
m_pGrid->OnRowUp();
return;
case VK_DOWN:
m_pGrid->OnRowDown();
return;
case VK_TAB:
m_pGrid->OnTabKey(GetKeyState(VK_SHIFT) < 0);
return;
case VK_DELETE:
if (m_pgc && (m_pgc->GetFlags() & CELLFLAG_READONLY)) {
Beep(1700, 40);
}
return;
}
BOOL bIsModified = GetModify();
if (!bWasModified && bIsModified) {
if (m_pGrid) {
m_pGrid->NotifyCellModifyChange();
}
}
}
//*********************************************************
// CCellEdit::OnSetFocus
//
// Hook out OnSetFocus so that we can prevent the focus from
// ever being set to the combo box. In the future it might
// be nice to allow the user to select the text in the combo
// box so that it can be copied, etc.
//
// Parameters:
// CWnd* pOldWnd
// Pointer to the window loosing the focus.
//
// Returns:
// Nothing.
//
//**********************************************************
void CCellEdit::OnSetFocus(CWnd* pOldWnd)
{
if (m_lbCombo.m_hWnd!=NULL && m_lbCombo.GetCount() > 0) {
// Don't allow the focus to be set on a combo box.
switch(m_pgc->GetType()) {
case CELLTYPE_ATTR_TYPE:
case CELLTYPE_CIMTYPE:
case CELLTYPE_CIMTYPE_SCALAR:
return;
break;
};
}
CEdit::OnSetFocus(pOldWnd);
if (!m_bUIActive)
{
m_bUIActive = TRUE;
RequestUIActive();
}
}
void CCellEdit::OnKillFocus(CWnd* pNewWnd)
{
CEdit::OnKillFocus(pNewWnd);
// TODO: Add your message handler code here
m_bUIActive = FALSE;
}
void CCellEdit::OnContextMenu(CWnd* pWnd, CPoint pt)
{
m_menuContext.DestroyMenu();
BOOL bUseCustomMenu = m_pGrid->GetCellEditContextMenu
(m_iRow, m_iCol,
m_pwndContextMenuTarget,
m_menuContext,
m_bContextMenuTargetWantsEditCommands);
// Pass the coordinates of the context menu click on to the grid. Also
// check to see if it wants to display and track the context menu directly.
if (m_pGrid->OnCellEditContextMenu(pWnd, pt)) {
return;
}
if (bUseCustomMenu) {
CMenu* pPopup = m_menuContext.GetSubMenu(0);
ASSERT(pPopup != NULL);
DWORD dwStyle = GetStyle();
BOOL bIsReadonly = dwStyle & ES_READONLY;
BOOL bEnableCopy = TRUE;
BOOL bEnableCut = TRUE;
BOOL bEnablePaste = TRUE;
BOOL bEnableSelectAll = TRUE;
BOOL bEnableClear = TRUE;
int nStartChar;
int nEndChar;
GetSel(nStartChar, nEndChar );
if (nStartChar >= nEndChar) {
// There is nothing to select, so disable the appropriate menu items
bEnableCopy = FALSE;
bEnableCut = FALSE;
bEnableClear = FALSE;
}
if (!CanUndo()) {
pPopup->EnableMenuItem(ID_EDIT_UNDO, MF_DISABLED | MF_GRAYED);
}
CString sText;
GetWindowText(sText);
if (sText.GetLength() == 0) {
// There is no text to select
bEnableSelectAll = FALSE;
}
COleDataObject *pdata = new COleDataObject;
BOOL bDidAttach = pdata->AttachClipboard();
BOOL bCanPaste = FALSE;
if (bDidAttach) {
if (pdata->IsDataAvailable(CF_TEXT)) {
bCanPaste = TRUE;
}
}
if (!bCanPaste) {
// There is no text available for pasting.
pPopup->EnableMenuItem(ID_EDIT_PASTE, MF_DISABLED | MF_GRAYED);
}
if (bIsReadonly) {
bEnableCut = FALSE;
bEnablePaste = FALSE;
bEnableClear = FALSE;
}
pPopup->EnableMenuItem(ID_EDIT_COPY, bEnableCopy ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
pPopup->EnableMenuItem(ID_EDIT_CUT, bEnableCut ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
pPopup->EnableMenuItem(ID_EDIT_PASTE, bEnablePaste ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
pPopup->EnableMenuItem(ID_EDIT_CLEAR, bEnableClear ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
pPopup->EnableMenuItem(ID_EDIT_SELECT_ALL, bEnableSelectAll ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
m_pGrid->ModifyCellEditContextMenu(m_iRow, m_iCol, m_menuContext);
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this);
}
else {
m_pwndContextMenuTarget = NULL;
CEdit::OnContextMenu(pWnd, pt);
}
}
void CCellEdit::OnEditClear()
{
Clear();
}
void CCellEdit::OnEditCopy()
{
Copy();
}
void CCellEdit::OnEditCut()
{
Cut();
}
void CCellEdit::OnEditPaste()
{
Paste();
}
void CCellEdit::OnEditSelectAll()
{
SetSel(0, -1);
}
void CCellEdit::OnEditUndo()
{
Undo();
}
BOOL CCellEdit::OnCommand( WPARAM wParam, LPARAM lParam )
{
if (m_pwndContextMenuTarget) {
CMenu* pPopup = m_menuContext.GetSubMenu(0);
ASSERT(pPopup != NULL);
UINT nItems = pPopup->GetMenuItemCount( );
for (UINT iItem =0; iItem < nItems; ++iItem) {
UINT uiMenuItem = pPopup->GetMenuItemID(iItem);
if (uiMenuItem == wParam) {
if (m_bContextMenuTargetWantsEditCommands) {
// Send all commands to the target, even the editing commands.
m_pwndContextMenuTarget->SendMessage(WM_COMMAND, wParam, lParam);
return TRUE;
}
switch(uiMenuItem) {
case ID_EDIT_CUT:
case ID_EDIT_COPY:
case ID_EDIT_PASTE:
case ID_EDIT_CLEAR:
case ID_EDIT_SELECT_ALL:
case ID_EDIT_UNDO:
case ID_CMD_SET_CELL_TO_NULL:
break;
default:
m_pwndContextMenuTarget->SendMessage(WM_COMMAND, wParam, lParam);
return TRUE;
}
}
}
}
return CEdit::OnCommand(wParam, lParam);
}
//********************************************************************
// CCellEdit::SetToNull
//
// Set the value of the current cell to NULL.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//********************************************************************
void CCellEdit::SetToNull()
{
DWORD dwStyle = GetStyle();
BOOL bIsReadonly = dwStyle & ES_READONLY;
if (bIsReadonly) {
return;
}
if (IsNull()) {
return;
}
BOOL bModified = GetModify();
CString sEmpty;
if (m_pGrid->ShowNullAsEmpty()) {
sEmpty = "<empty>";
}
SetWindowText(sEmpty, TRUE);
m_bIsNull = TRUE;
// If the modification flag changed, then redraw the window
// so that the text appears in the correct color.
FixBuddyCell();
if (GetModify() != bModified) {
if (m_pgc) {
m_pgc->SetModified(bModified);
}
if (m_pGrid) {
m_pGrid->NotifyCellModifyChange();
RedrawWindow();
}
}
}
BOOL CCellEdit::IsNull()
{
#if 0
if (m_bIsNull) {
CString sText;
GetWindowText(sText);
BOOL bTextIsEmpty = sText=="<empty>";
if (!bTextIsEmpty) {
m_bIsNull = FALSE;
}
}
#endif //0
return m_bIsNull;
}
void CCellEdit::OnCmdSetCellToNull()
{
SetToNull();
}
void CCellEdit::OnChange()
{
if (m_pGrid) {
if (m_bPropagateChange) {
m_pGrid->NotifyCellModifyChange();
}
}
}
void CCellEdit::RequestUIActive()
{
if (m_pGrid) {
m_pGrid->OnRequestUIActive();
}
}
void CLbCombo::OnSetFocus(CWnd* pOldWnd)
{
CListBox::OnSetFocus(pOldWnd);
// TODO: Add your message handler code here
if (!m_bUIActive)
{
m_bUIActive = TRUE;
m_pClient->RequestUIActive();
}
}
void CLbCombo::OnKillFocus(CWnd* pNewWnd)
{
CListBox::OnKillFocus(pNewWnd);
// TODO: Add your message handler code here
m_bUIActive = FALSE;
}
void CLbCombo::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// TODO: Add your message handler code here and/or call default
switch(nChar) {
case ESC_CHAR:
m_pClient->CatchEvent(NOTIFY_CELL_EDIT_LISTBOX_LBUTTON_UP);
return;
case VK_TAB:
return;
}
CListBox::OnChar(nChar, nRepCnt, nFlags);
}
//********************************************************************
// CLbCombo::MapCharToItem
//
// Map a character to an item in the list. This is used when the
// user types a character to cycle through the values in the list
// that start with the given character.
//
// Parameters:
// CString& sValue
//
// UINT nChar
//
// Returns:
// Nothing.
//
//********************************************************************
SCODE CLbCombo::MapCharToItem(CString& sValue, UINT nChar)
{
nChar = toupper(nChar);
UINT nCharItem;
int nItems = GetCount();
int iItem;
// If the user repeatedly hits the same character, cycle through the values
// that start with that character.
int iValue = -1;
if (sValue.GetLength() > 0) {
UINT nCharValue = (UINT) toupper(sValue[0]);
if (nCharValue == nChar) {
ASSERT(LB_ERR < 0);
iValue = FindString(-1, sValue);
}
}
CString sItem;
if (iValue >= 0) {
// The value string was found in the list, so start looking at the
// first item past this value for another one that starts with the
// same given character.
for (iItem = iValue + 1; iItem < nItems; ++iItem) {
GetText(iItem, sItem);
if (sItem.GetLength() > 0) {
nCharItem = (UINT) toupper(sItem[0]);
if (nCharItem == nChar) {
sValue = sItem;
return S_OK;
}
}
}
// Start over at the beginning of the list and continue up the
// the current value looking for an item that starts with the specified
// character.
for (iItem = 0; iItem < iValue; ++iItem) {
GetText(iItem, sItem);
if (sItem.GetLength() > 0) {
nCharItem = (UINT) toupper(sItem[0]);
if (nCharItem == nChar) {
sValue = sItem;
return S_OK;
}
}
}
sValue = "";
return E_FAIL;
}
else {
// No string in the list matches the current value, so look through the
// entire list from the beginning for an item that starts with the given
// character.
for (iItem = 0; iItem < nItems; ++iItem) {
GetText(iItem, sItem);
if (sItem.GetLength() > 0) {
nCharItem = (UINT) toupper(sItem[0]);
if (nCharItem == nChar) {
sValue = sItem;
return S_OK;
}
}
}
sValue = "";
return E_FAIL;
}
}
Reference in New Issue View Git Blame Copy Permalink