void CheckBox::MouseClick() {
if (! CanAutoChangeCheckState()) {
return;
}
CheckState new_check_state = CheckState::Unchecked;
switch (GetCheckState()) {
case CheckState::Unchecked:
new_check_state = CheckState::Checked;
break;
case CheckState::Checked:
new_check_state = CanBeIndeterminate() ? CheckState::Indeterminate : CheckState::Unchecked;
break;
case CheckState::Indeterminate:
new_check_state = CheckState::Unchecked;
break;
default:
ZAF_FAIL();
break;
}
SetCheckState(new_check_state);
}
void CPropTreeItemCheck::OnBnClicked()
{
int state = GetCheck();
SetCheckState(GetCheck() == BST_CHECKED ? FALSE : TRUE);
CommitChanges();
}
void CTreeView::AddTestCase(unsigned id, const std::string& name, bool check)
{
HTREEITEM hItem = InsertItem(WStr(name), m_iEmpty, m_iEmpty, m_parents.back(), TVI_LAST);
SetItemData(hItem, id);
SetCheckState(hItem, check);
m_items[id] = hItem;
++m_levels[m_depth];
}
void CheckBox::SetCanBeIndeterminate(bool can_be_ndeterminate) {
GetPropertyMap().SetProperty(kCanBeIndeterminatePropertyName, can_be_ndeterminate);
if (! can_be_ndeterminate && (GetCheckState() == CheckState::Indeterminate)) {
SetCheckState(CheckState::Checked);
}
}
void CtrlBreakpointList::reloadBreakpoints()
{
// Update the items we're displaying from the debugger.
displayedBreakPoints_ = CBreakPoints::GetBreakpoints();
displayedMemChecks_= CBreakPoints::GetMemChecks();
Update();
for (int i = 0; i < GetRowCount(); i++)
{
bool isMemory;
int index = getBreakpointIndex(i, isMemory);
if (isMemory)
SetCheckState(i,(displayedMemChecks_[index].result & MEMCHECK_BREAK) != 0);
else
SetCheckState(i,displayedBreakPoints_[index].enabled);
}
}
void CTreeView::SetTestItemState(unsigned id, const TreeViewItemState& state)
{
auto it = m_items.find(id);
if (it == m_items.end())
return;
ExpandTreeViewItem(*this, it->second, state.expand);
SetCheckState(it->second, state.enable);
}
void CTreeView::CheckSubTreeItems(HTREEITEM hItem, bool check)
{
SetCheckState(hItem, check);
HTREEITEM hChild = GetChildItem(hItem);
while (hChild)
{
CheckSubTreeItems(hChild, check);
hChild = GetNextSiblingItem(hChild);
}
}
void CtrlBreakpointList::reloadBreakpoints()
{
// Update the items we're displaying from the debugger.
displayedBreakPoints_ = CBreakPoints::GetBreakpoints();
displayedMemChecks_= CBreakPoints::GetMemChecks();
Update();
for (int i = 0; i < GetRowCount(); i++)
{
bool isMemory;
int index = getBreakpointIndex(i, isMemory);
if (index < 0)
continue;
if (isMemory)
SetCheckState(i, displayedMemChecks_[index].IsEnabled());
else
SetCheckState(i, displayedBreakPoints_[index].IsEnabled());
}
}
void CCheckTreeView::SetCheckState (HTREEITEM hItem, UINT uiState, bool fPropagateUp, bool fPropagateDown)
{
if (!m_fUseCheckMarks)
return;
TV_ITEM tvi;
tvi.hItem = hItem;
tvi.mask = TVIF_STATE;
tvi.state = uiState;
tvi.stateMask = TVIS_STATEIMAGEMASK;
SetItem (&tvi);
// ggf. die Änderung nach oben/unten propagieren
if (m_fUsePartialCheckMarks) {
HTREEITEM hParent = GetParentItem(hItem);
if (fPropagateUp && (TVI_ROOT != hParent && NULL != hParent)) {
UINT uiOldState = GetCheckState(hParent);
UINT uiNewState = CalcParentCheckState(hParent);
if (uiOldState != uiNewState)
SetCheckState(hParent, uiNewState, true, false); // eine Etage hoch, aber nicht wieder runter
}
// wenns eindeutig ist, dann alle drunter liegenden auch umschalten
if (fPropagateDown && (TV_CHECK_ON == uiState || TV_CHECK_OFF == uiState)) {
HTREEITEM hChildItem = NULL;
if (TVI_ROOT == hItem)
hChildItem = GetNextItem (NULL, TVGN_CHILD);
else
hChildItem = GetChildItem (hItem);
while (NULL != hChildItem) {
SetCheckState (hChildItem, uiState, false, true); // nicht wieder nach oben propagieren
hChildItem = GetNextItem (hChildItem, TVGN_NEXT);
}
}
}
}
void CTreeView::EnterTestSuite(unsigned id, const std::string& name, bool check)
{
HTREEITEM hItem = InsertItem(WStr(name), m_iEmpty, m_iEmpty, m_parents.back(), TVI_LAST);
SetItemData(hItem, id);
SetCheckState(hItem, check);
m_items[id] = hItem;
m_parents.push_back(hItem);
++m_levels[m_depth];
++m_depth;
if (m_depth >= static_cast<int>(m_levels.size()))
m_levels.push_back(0);
}
void CPropTreeItemCheck::OnActivate( int activateType, CPoint point ) {
if( activateType == CPropTreeItem::ACTIVATE_TYPE_MOUSE ) {
//Check where the user clicked
if( point.x < m_rc.left + CHECK_BOX_SIZE ) {
SetCheckState( !GetCheckState() );
CommitChanges();
} else {
SetWindowPos( NULL, m_rc.left, m_rc.top, m_rc.Width(), m_rc.Height(), SWP_NOZORDER | SWP_SHOWWINDOW );
SetFocus();
}
} else {
SetWindowPos( NULL, m_rc.left, m_rc.top, m_rc.Width(), m_rc.Height(), SWP_NOZORDER | SWP_SHOWWINDOW );
SetFocus();
}
}
void CTreeView::UncheckTreeItem(HTREEITEM hItem)
{
SetCheckState(hItem, false);
HTREEITEM hParent = GetParentItem(hItem);
if (hParent == nullptr)
return;
HTREEITEM hChild = GetChildItem(hParent);
bool allUnchecked = true;
while (hChild)
{
if (GetCheckState(hChild) != FALSE)
allUnchecked = false;
hChild = GetNextSiblingItem(hChild);
}
if (allUnchecked)
UncheckTreeItem(hParent);
}
///////////////////////////////////////////////////////////////////////////////
// Memberfunktionen
bool CCheckTreeView::ToggleCheckMark (HTREEITEM hItem)
{
if (!UseCheckMarks() || NULL == hItem)
return false;
bool fWasOn = false;
TV_ITEM tvi;
tvi.hItem = hItem;
tvi.mask = TVIF_STATE;
if (GetItem (&tvi)) {
UINT uiState = TV_CHECK_NOMARK;
switch (tvi.state & TVIS_STATEIMAGEMASK) {
case TV_CHECK_OFF:
uiState = TV_CHECK_ON;
break;
case TV_CHECK_ON:
uiState = TV_CHECK_OFF;
fWasOn = true;
break;
case TV_CHECK_PARTIAL_ON:
if (UsePartialCheckMarks()) {
uiState = TV_CHECK_ON;
fWasOn = true;
}
break;
case TV_CHECK_PASSIVE:
case TV_CHECK_NOMARK:
break;
default:
_ASSERTE(FALSE);
break;
}
SetCheckState(hItem, uiState);
}
return fWasOn;
}
void CCheckTreeView::HandleCheckMark(Point point, UINT uiMsg)
{
Rectangle rc = CanvasRect();
CoOrd dY = rc.Top()-rc.Bottom();
TV_HITTESTINFO ht;
ht.pt.x = point.X();
ht.pt.y = dY-point.Y();
HTREEITEM hNewTarget = HitTest (&ht);
if (hNewTarget && (ht.flags & TVHT_ONITEMSTATEICON)) {
UINT uiState = ChangingCheckState (hNewTarget, uiMsg);
if (TV_CHECK_NOCHANGE != uiState) {
if (TV_CHECK_NOMARK != uiState)
SetCheckState (hNewTarget, uiState);
else
ToggleCheckMark (hNewTarget);
NotifyChecked (hNewTarget, uiMsg, GetCheckState(hNewTarget));
}
}
}
void CPropTreeItemCheck::SetItemValue( LPARAM lParam ) {
SetCheckState( ( BOOL )lParam );
}
void CTreeView::Check(unsigned id, bool check)
{
auto it = m_items.find(id);
if (it != m_items.end())
SetCheckState(it->second, check);
}
LRESULT CListViewCtrlEx::OnClick( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
bHandled = FALSE;
LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) pnmh;
// - title collapsed
TListItem *pItem = _GetItemData(lpnmitem->iItem);
if(!pItem)
return 0;
if(pItem->dwFlags & LISTITEM_TITLE)
{
if(pItem->dwFlags & LISTITEM_EXPANDABLE)
{
INT iItem = lpnmitem->iItem;
RECT rcItem = {0};
if( GetItemRect(iItem, &rcItem, LVIR_BOUNDS) )
{
_ExpandItem(pItem, lpnmitem->iItem, pItem->_isclapsed);
InvalidateRect( &rcItem );
}
return 0;
}
}
else
{
// - link check
int iSubItem = lpnmitem->iSubItem;
if(_PtInSubItemLink(lpnmitem->ptAction, lpnmitem->iItem, iSubItem) )
_FireEvent(WMH_LISTEX_LINK, lpnmitem->iItem, iSubItem);
else if( pItem->dwFlags & (LISTITEM_CHECKBOX|LISTITEM_RADIOBOX) )
{
// - check box
BOOL bDirty = FALSE;
if (pItem->dwFlags&LISTITEM_RADIOBOX)
{
bDirty = TRUE;
SetRadioState( lpnmitem->iItem, !_super::GetCheckState(lpnmitem->iItem) );
}
else if (_PtInSubItemCheckBox(lpnmitem->ptAction, lpnmitem->iItem))
{
bDirty = TRUE;
SetCheckState( lpnmitem->iItem, !_super::GetCheckState(lpnmitem->iItem) );
}
if( bDirty )
{
CRect rcItem;
GetItemRect( lpnmitem->iItem, &rcItem, LVIR_BOUNDS);
InvalidateRect( rcItem );
}
/*const TListSubItem *pSubItem = _GetSubItemData(lpnmitem->iItem,lpnmitem->iSubItem);
if(pSubItem->type==SUBITEM_COMBO)
{
}*/
}
}
return 0;
}
BOOL
ProcessGadget( UWORD id, UWORD code )
{
BOOL run = TRUE;
LONG val;
switch( id )
{
case NOSCRTOFRONT_GADID:
RTPrefs.Flags ^= RTPRF_NOSCRTOFRONT;
break;
case IMMSORT_GADID:
RTPrefs.Flags ^= RTPRF_IMMSORT;
break;
case DIRSFIRST_GADID:
RTPrefs.Flags ^= RTPRF_DIRSFIRST;
if( RTPrefs.Flags & RTPRF_DIRSMIXED )
{
SetCheckState( mixdirsgad, FALSE );
RTPrefs.Flags &= ~RTPRF_DIRSMIXED;
}
break;
case DIRSMIXED_GADID:
RTPrefs.Flags ^= RTPRF_DIRSMIXED;
if( RTPrefs.Flags & RTPRF_DIRSFIRST )
{
SetCheckState( dirsfirstgad, FALSE );
RTPrefs.Flags &= ~RTPRF_DIRSFIRST;
}
break;
case NOLED_GADID:
RTPrefs.Flags ^= RTPRF_NOLED;
break;
case MMB_GADID:
RTPrefs.Flags ^= RTPRF_MMBPARENT;
break;
case DEFAULTFONT_GADID:
RTPrefs.Flags ^= RTPRF_DEFAULTFONT;
break;
case DOWHEEL_GADID:
/* First clear all bits */
RTPrefs.Flags &= ~( RTPRF_DOWHEEL | RTPRF_FANCYWHEEL );
/* Then set appropriate ones */
RTPrefs.Flags |= SetWheelType( WheelType = code );
break;
case FKEYS_GADID:
RTPrefs.Flags ^= RTPRF_FKEYS;
break;
case REQTYPE_GADID:
if( CurrentReq != code )
{
CurrentReq = code;
UpdatePrefsWindow( TRUE );
ReqDefs = &RTPrefs.ReqDefaults[ CurrentReq ];
}
break;
case DEFSIZE_GADID:
ReqDefs->Size = code;
break;
case MINENTRIES_GADID:
val = IntGadValue( mingad );
if( val < 3 )
{
val = 3;
}
if( val > ReqDefs->MaxEntries )
{
val = ReqDefs->MaxEntries;
}
if( val != IntGadValue( mingad ) )
{
SetIntGad( mingad, val );
}
ReqDefs->MinEntries = val;
break;
case MAXENTRIES_GADID:
val = IntGadValue( maxgad );
if( val > 50 )
{
val = 50;
}
if( val < ReqDefs->MinEntries )
{
val = ReqDefs->MinEntries;
}
if( val != IntGadValue( maxgad ) )
{
SetIntGad( maxgad, val );
}
ReqDefs->MaxEntries = val;
break;
case POSITION_GADID:
if( ReqDefs->ReqPos != code )
{
ReqDefs->ReqPos = code;
if( code <= REQPOS_CENTERSCR )
{
GadgetOff( xoffgad );
GadgetOff( yoffgad );
}
else
{
GadgetOn( xoffgad );
GadgetOn( yoffgad );
}
}
break;
case OFFSETX_GADID:
ReqDefs->LeftOffset = IntGadValue( xoffgad );
break;
case OFFSETY_GADID:
ReqDefs->TopOffset = IntGadValue( yoffgad );
break;
case SAVE_GADID:
SaveConfig( CONFIGFILE_ARC );
/* FALLTHROUGH! */
case USE_GADID:
{
struct ReqToolsPrefs *prefs;
SaveConfig( CONFIGFILE );
prefs = rtLockPrefs();
CopyMem( &RTPrefs.Flags, &prefs->Flags, PREFSLEN );
rtUnlockPrefs();
}
/* FALLTHROUGH! */
case CANCEL_GADID:
run = FALSE;
break;
}
return( run );
}
static uintptr_t OnConfigureControl( CONTROL_NAME )( uintptr_t psv, PSI_CONTROL parent_frame )
{
PSLIDER_INFO info = (PSLIDER_INFO)psv;
{
PSI_CONTROL frame = NULL;
int okay = 0;
int done = 0;
if( !frame )
{
frame = LoadXMLFrame( "seek_slider_properties.frame" );
if( frame )
{
TEXTCHAR buffer[256];
SetCommonButtonControls( frame );
SetCheckState( GetControl( frame, CHECKBOX_HORIZONTAL ), info->flags.bHorizontal );
SetCheckState( GetControl( frame, CHECKBOX_DRAGGING ), info->flags.bDragging );
SetControlText( GetControl( frame, EDIT_BACKGROUND_IMAGE ), info->image_name );
snprintf(buffer, sizeof(buffer), "%d", info->min);
SetControlText( GetControl( frame, EDIT_MIN ), buffer );
snprintf(buffer, sizeof(buffer), "%d", info->max);
SetControlText( GetControl( frame, EDIT_MAX ), buffer );
snprintf(buffer, sizeof(buffer), "%d", info->current);
SetControlText( GetControl( frame, EDIT_CURRENT ), buffer );
SetCommonButtons( frame, &done, &okay );
DisplayFrameOver( frame, parent_frame );
CommonWait( frame );
if( okay )
{
GetCommonButtonControls( frame );
info->font = InterShell_GetCurrentButtonFont();
if( info->font )
SetCommonFont( info->control, (*info->font ) );
info->color = GetColorFromWell( GetControl( frame, CLR_TEXT_COLOR ) );
info->backcolor = GetColorFromWell( GetControl( frame, CLR_BACKGROUND ) );
{
GetControlText( GetControl( frame, EDIT_BACKGROUND_IMAGE ), buffer, sizeof( buffer ) );
if( info->image_name )
Release( info->image_name );
info->image_name = StrDup( buffer );
}
// SetSliderColor( info->control, info->color );
// SetSliderkBackColor( info->control, info->backcolor );
info->flags.bHorizontal = GetCheckState( GetControl( frame, CHECKBOX_HORIZONTAL ) );
info->flags.bDragging = GetCheckState( GetControl( frame, CHECKBOX_DRAGGING ) );
GetControlText( GetControl( frame, EDIT_MIN), buffer, sizeof( buffer ) );
info->min = atoi(buffer);
GetControlText( GetControl( frame, EDIT_MAX), buffer, sizeof( buffer ) );
info->max = atoi(buffer);
GetControlText( GetControl( frame, EDIT_CURRENT), buffer, sizeof( buffer ) );
info->current = atoi(buffer);
}
DestroyFrame( &frame );
}
}
}
return psv;
}
void CTreeView::CheckTreeItem(HTREEITEM hItem)
{
SetCheckState(hItem, true);
if (HTREEITEM hParent = GetParentItem(hItem))
CheckTreeItem(hParent);
}
void CCheckTreeView::HideStateImage (HTREEITEM hItem)
{
if (m_fUseCheckMarks)
SetCheckState (hItem, TV_CHECK_NOMARK);
}
