listviewwindow.cpp

虚拟打印机

		this->DoUpdateDirectLayer(mdp);
	}
}

void ListViewWindow::EndMouseTracking(BOOL bCancel, BOOL bCtrl) {
	if (/*m_bHasMouseCapture*/ m_mouseTrackMode != ListViewWindow::eNotTracking) {
		this->KillTimer(ID_SCROLLTIMER);

		// MUST SET THIS BOOL FIRST, EndMouseTracking SendMessage's WM_CAPTURECHANGED
		//m_bHasMouseCapture = FALSE;
		ListViewWindow::MouseTrackingMode oldMode = m_mouseTrackMode;
		m_mouseTrackMode = ListViewWindow::eNotTracking;
		::ReleaseCapture();
		//::EndMouseTracking();

		switch(oldMode) {
		case ListViewWindow::eTrackViewTranslation:
			break;
		case ListViewWindow::eTrackDragBoxPart:
			if (! ::EqualRect(m_rdDragBoxPart_InitialSelectionBox, m_rdSelectionBox)) {
				this->SendNotification(ListViewWindow::eArrowSelectionBoxChange);
			}
			break;
		case ListViewWindow::eTrackDottedSelection: {
				POINTD ptd;
				m_trans.DoInvTrans(m_ptMouseLast, ptd);
				this->MoveArrowSelectionOutline(m_ptdMouseDown, ptd, TRUE, FALSE);
				if (!bCancel) {
					if (::IsRectEmpty(m_rdArrowSelectionOutline)) {
						this->SetArrowSelection(ptd, bCtrl);
					} else {
						this->SetArrowSelection(m_rdArrowSelectionOutline, bCtrl);
					}
				}
			} break;
		default:
			// DEBUG - FIX -- MAKE THIS COMPILE TIME
			ASSERTFAIL();
			break;
		}

		//switch(m_ct) {
		//case eHand:
		//	break;
		//case eArrow: {
		//	switch(m_arrowSelMode) {
		//	case ListViewWindow::eSelectBox:
		//		if (this->m_bDragBoxPart) {
		//			// 6/1
		//			if (! ::EqualRect(m_rdDragBoxPart_InitialSelectionBox, m_rdSelectionBox)) {
		//				this->SendNotification(ListViewWindow::eArrowSelectionBoxChange);
		//			}
		//			break;
		//		}
		//		// FALL THRU
		//	case ListViewWindow::eSelectItems: {
		//		POINTD ptd;
		//		m_trans.DoInvTrans(m_ptMouseLast, ptd);
		//		this->MoveArrowSelectionOutline(m_ptdMouseDown, ptd, TRUE, FALSE);
		//		if (!bCancel) {
		//			if (::IsRectEmpty(m_rdArrowSelectionOutline)) {
		//				this->SetArrowSelection(ptd, bCtrl);
		//			} else {
		//				this->SetArrowSelection(m_rdArrowSelectionOutline, bCtrl);
		//			}
		//		}
		//	} break;
		//	default:
		//		ASSERTFAIL();
		//		break;
		//	}
		//} break;
		//default:
		//	ASSERTFAIL();
		//	break;
		//}
	}  // if (/*m_bHasMouseCapture*/ m_mouseTrackMode != ListViewWindow::eNotTracking) 
} // void ListViewWindow::EndMouseTracking(BOOL bCancel, BOOL bCtrl) 

BOOL ListViewWindow::IsValidArrowSelectionBox(OUT RECTD& rdBoxAdjusted, const RECTD& rdBox) const {
	BOOL bRetValue = FALSE;
	if (m_pList != NULL) {
		std::vector<uint> vuiItem;
		if (m_pList->ItemsFromRect(vuiItem, rdBox)) {
			// PICK THE FIRST ONE
			uint uiItem = vuiItem[0];
			RECTD rdItem;
			m_pList->GetItemSelectableBounds(uiItem, rdItem);
			RECTD rdIntersect;
			::IntersectRect(rdIntersect, rdItem, rdBox);
			SIZED szdIntersect = { RW(rdIntersect), RH(rdIntersect) };
			if (szdIntersect.cx >= m_szdMinSelectionBox.cx &&
				szdIntersect.cy >= m_szdMinSelectionBox.cy) {
					rdBoxAdjusted = rdIntersect;
					bRetValue = TRUE;
			}
		}
	}
	return bRetValue;
}

void ListViewWindow::InvalidateItem(uint uiItem) {
	if (m_pList != NULL) {
		RECTD rdItem;
		this->m_pList->GetItemBounds(uiItem, rdItem);
		RECT rItem;
		m_trans.DoTrans(rdItem, rItem);
		RECT rDest;
		::IntersectRect(&rDest, &rItem, &this->rClient());
		this->InvalidateRect(rDest, TRUE);
	}
}

void ListViewWindow::MoveArrowSelectionBox(BOOL bHasArrowSelectionBox, const RECTD* prdNew, BOOL bWithPaint, BOOL bNotify) {
	RECT rNew;
	if (bHasArrowSelectionBox) {
		m_trans.DoTrans(*prdNew, rNew);
	}

	//if (bHasArrowSelectionBox ^ m_bHasArrowSelectionBox ||
	//	bHasArrowSelectionBox && m_bHasArrowSelectionBox  && ! ::EqualRect(&m_rSelectionBox, &rNew)
	//) {
	if (lxor(bHasArrowSelectionBox, m_bHasArrowSelectionBox) ||
		bHasArrowSelectionBox && m_bHasArrowSelectionBox  && ! ::EqualRect(&m_rSelectionBox, &rNew)
	) {
		if (bHasArrowSelectionBox) {
			m_ps->SetNextBox(rNew);
			m_rSelectionBox = rNew;
			m_rdSelectionBox = *prdNew;
		} else {
			m_ps->SetNextInvisible();
		}
		m_bHasArrowSelectionBox = bHasArrowSelectionBox;
		if (bWithPaint) {
			this->UpdateSpriteOnNextPaint();
		} else {
			this->DoUpdateSprite();
		}
		if (bNotify) {
			this->SendNotification(eArrowSelectionBoxChange);
		}
	}
}

void ListViewWindow::MoveArrowSelectionOutline(const POINTD& ptd1, const POINTD& ptd2, BOOL bEraseOld, BOOL bDrawNew) {
	RECTD rdMouseSelOld = m_rdArrowSelectionOutline;

	m_rdArrowSelectionOutline.left = min(ptd1.x, ptd2.x);
	m_rdArrowSelectionOutline.top = min(ptd1.y, ptd2.y);
	m_rdArrowSelectionOutline.right = max(ptd1.x, ptd2.x);
	m_rdArrowSelectionOutline.bottom = max(ptd1.y, ptd2.y);

	this->DrawArrowSelectionOutline(NULL, rdMouseSelOld, bEraseOld, bDrawNew);
}

void ListViewWindow::ResetRulers(void) {
	const RulerDrawer *prdHorizNew = NULL;
	RulerPlacementSpec rpsHorizNew(RulerPlacementSpec::eHorizontal);
	const RulerDrawer *prdVertNew = NULL;
	RulerPlacementSpec rpsVertNew(RulerPlacementSpec::eVertical);
	if (m_prdp != NULL && m_handsel.bHasHandSel) {
		RECTD rdItem;
		m_pList->GetItemRuledBounds(m_handsel.uiItem, rdItem);
		prdHorizNew = m_prdp->GetRulerDrawer(RW(rdItem));
		prdVertNew = m_prdp->GetRulerDrawer(RH(rdItem));

		if (prdHorizNew != NULL || prdVertNew != NULL) {
			RECT rItem;
			m_trans.DoTrans(rdItem, rItem);
			if (prdHorizNew != NULL) {
				rpsHorizNew.m_rDest = m_rHorizRuler;
				rpsHorizNew.m_rDest.left = max(rpsHorizNew.m_rDest.left, rItem.left);
				rpsHorizNew.m_rDest.right = min(rpsHorizNew.m_rDest.right, rItem.right);
				RECTD rdDest;
				m_trans.DoInvTrans(rpsHorizNew.m_rDest, rdDest);
				OffsetRect(rdDest, -rdItem.left, -rdItem.top);
				rpsHorizNew.m_dTopLeft = rdDest.left;
				rpsHorizNew.m_dBottomRight = rdDest.right;
			}
			if (prdVertNew != NULL) {
				rpsVertNew.m_rDest = m_rVertRuler;
				rpsVertNew.m_rDest.top = max(rpsVertNew.m_rDest.top, rItem.top);
				rpsVertNew.m_rDest.bottom = min(rpsVertNew.m_rDest.bottom, rItem.bottom);
				RECTD rdDest;
				m_trans.DoInvTrans(rpsVertNew.m_rDest, rdDest);
				OffsetRect(rdDest, -rdItem.left, -rdItem.top);
				rpsVertNew.m_dTopLeft = rdDest.top;
				rpsVertNew.m_dBottomRight = rdDest.bottom;
			}
		}
	}

	BOOL bUnitLabelChanged = FALSE;
	Ruler rHorizNew(prdHorizNew, rpsHorizNew, &m_lfkHoriz);
	if (rHorizNew != m_rHoriz) {
		this->InvalidateRect(m_rHorizRuler, TRUE);
		if (::RulerUnitLabelChanged(rHorizNew, m_rHoriz)) {
			bUnitLabelChanged = TRUE;
		}
		m_rHoriz = rHorizNew;
	}
	Ruler rVertNew(prdVertNew, rpsVertNew, &m_lfkVert);
	if (rVertNew != m_rVert) {
		this->InvalidateRect(m_rVertRuler, TRUE);
		if (::RulerUnitLabelChanged(rVertNew, m_rVert)) {
			bUnitLabelChanged = TRUE;
		}
		m_rVert = rVertNew;
	}
	if (bUnitLabelChanged) {
		this->SendNotification(ListViewWindow::eRulerUnitsChange);
	}
}

void ListViewWindow::ResetView(void) {
	if (m_pList != NULL) {
		POINT ptClientCenter;
		CenterInRect(ptClientCenter, m_rView);
		RECTD rdList;
		m_pList->GetBounds(rdList);
		POINTD ptdSrcCenter;
		CenterInRect(ptdSrcCenter, rdList);

		m_trans.Reset(ptdSrcCenter, ptClientCenter, 1.0, rdList, m_rView);
	}

	this->InvalidateRect(this->rClient(), TRUE);
}

BOOL ListViewWindow::SelModeVectorHasMode(uint uiSelMode) const {
	for(uint ui = 0; ui < m_vsel.size(); ++ui) {
		if ( (m_vsel[ui] & uiSelMode) == uiSelMode) {
			return TRUE;
		}
	}
	return FALSE;
}

void ListViewWindow::SetArrowSelection(const POINTD& ptd, BOOL bCtrl) {
	if (m_pList != NULL) {
		switch(m_arrowSelMode) {
		case ListViewWindow::eSelectBox: 
			if (m_bHasArrowSelectionBox) {
				this->MoveArrowSelectionBox(FALSE, NULL, FALSE, TRUE);
			}
			break;
		case ListViewWindow::eSelectItems: {
			std::vector<uint> vuiItem;
			uint uiItem;
			if (m_pList->ItemFromPt(uiItem, ptd)) {
				vuiItem.push_back(uiItem);
			}
			this->SetArrowSelection(vuiItem, bCtrl);
		} break;
		default:
			ASSERTFAIL();
			break;
		}
	}
}

void ListViewWindow::SetArrowSelection(const RECTD& rd, BOOL bCtrl) {
	if (m_pList != NULL) {
		switch(m_arrowSelMode) {
		case ListViewWindow::eSelectBox: 
			RECTD rdAdjusted;
			if (this->IsValidArrowSelectionBox(rdAdjusted, rd)) {
				this->MoveArrowSelectionBox(TRUE, &rdAdjusted, FALSE, TRUE);
			} else {
				this->MoveArrowSelectionBox(FALSE, NULL, FALSE, TRUE);
			}
			break;
		case ListViewWindow::eSelectItems: {
			std::vector<uint> vuiItem;
			m_pList->ItemsFromRect(vuiItem, rd);
			this->SetArrowSelection(vuiItem, bCtrl);
		} break;
		default:
			ASSERTFAIL();
			break;
		}
	}
}

void ListViewWindow::SetArrowSelection(const std::vector<uint>& vuiItem, BOOL bCtrl) {
	if (m_pList != NULL) {
		switch(m_arrowSelMode) {
		case ListViewWindow::eSelectBox:
			ASSERTFAIL();
			break;
		case ListViewWindow::eSelectItems: {
			std::vector<uint> vuiSelOld = m_vsel;
			std::vector<uint>& vsel = m_vsel;

			if (bCtrl) {
				for(uint ui = 0; ui < vuiItem.size(); ++ui) {
					uint uiItem = vuiItem[ui];
					vsel[uiItem] ^= ViewableList::eArrowSel;
				}
			} else {
				for(uint ui = 0; ui < vsel.size(); ++ui) {
					vsel[ui] &= ~ ViewableList::eArrowSel;
				}
				for(uint ui = 0; ui < vuiItem.size(); ++ui) {
					uint uiItem = vuiItem[ui];
					vsel[uiItem] |= ViewableList::eArrowSel;
				}
			}
			BOOL bChanged = FALSE;
			for(uint ui = 0; ui < vsel.size(); ++ui) {
				if (vsel[ui] != vuiSelOld[ui]) {
					this->InvalidateItem(ui);
					bChanged = TRUE;
				}
			}
			if (bChanged) {
				this->SendNotification(ListViewWindow::eArrowSelectionItemsChange);
			}
		} break;
		default:
			ASSERTFAIL();
			break;
		}
	}
}

void ListViewWindow::SetHandSelection(const HandSelState& handsel) {
	if (handsel != this->m_handsel) {
		switch(m_arrowSelMode) {
			case ListViewWindow::eSelectBox: 
				// FALL THRU
			case ListViewWindow::eSelectItems: {
				std::vector<uint>& vsel = m_vsel;
				if (handsel.bHasHandSel) {
					vsel[handsel.uiItem] |= ViewableList::eHandSel;
					this->InvalidateItem(handsel.uiItem);
				}
				if (m_handsel.bHasHandSel) {
					vsel[m_handsel.uiItem] &= ~ViewableList::eHandSel;
					this->InvalidateItem(m_handsel.uiItem);
				}
				m_handsel = handsel;
				this->ResetRulers();
				this->SendNotification(ListViewWindow::eHandSelChange);
			} break;
			default:
				ASSERTFAIL();
				break;
		}
	}
}

void ListViewWindow::StartMouseTracking(ListViewWindow::MouseTrackingMode mouseTrackMode) {
	// ONLY DEAL WITH THE TRANSITION FROM NOT TRACKING TO TRACKING 
	// WE DONT DEAL WITH TRANSITING FROM ONE TRACKING TO ANOTHER (CURRENTLY) RATHER JUST ASSERT
	// ALSO THIS ROUTINE CAN'T BE USED TO STOP TRACKING (USING EndMouseTracking INSTEAD)

	ASSERT(mouseTrackMode != ListViewWindow::eNotTracking);

	switch(m_mouseTrackMode) {
	case ListViewWindow::eNotTracking:
		this->SetFocus();
		this->Window::SetCapture();
		//m_bHasMouseCapture = TRUE;
		m_mouseTrackMode = mouseTrackMode;
		this->SetTimer(ID_SCROLLTIMER, SCROLLTIMER_MS);
		break;
	default:
		// DONT THINK THIS CASE EVER ACTUALLY OCCURS
		ASSERT(m_mouseTrackMode == mouseTrackMode);
		break;
	}

	//if (! m_bHasMouseCapture) {
	//	this->SetFocus();
	//	this->Window::StartMouseTracking();
	//	m_bHasMouseCapture = TRUE;
	//	this->SetTimer(ID_SCROLLTIMER, SCROLLTIMER_MS);
	//}
}

void ListViewWindow::Translate(IN const POINT& ptDelta) {
	if (ptDelta.x != 0 || ptDelta.y != 0) {
		m_trans.TranslateSrcOrg(ptDelta);

		switch(m_arrowSelMode) {
		case ListViewWindow::eSelectBox: 
			if (m_bHasArrowSelectionBox) {
				this->MoveArrowSelectionBox(TRUE, &m_rdSelectionBox, TRUE, FALSE);
			}
			break;
		case ListViewWindow::eSelectItems:
			break;
		default:
			ASSERTFAIL();
			break;
		}

		switch(m_mouseTrackMode) {
		case ListViewWindow::eNotTracking:
			break;
		case ListViewWindow::eTrackViewTranslation:
			break;
		case ListViewWindow::eTrackDragBoxPart: {
			//POINT ptBoxDelta = { - ptDelta.x, - ptDelta.y };
			//this->DragArrowSelectionBoxPart(ptBoxDelta, TRUE);
			POINT pt1;
			m_trans.DoTrans(this->m_ptdLastGoodDragDelta, pt1);
			POINTD ptdZero = { 0, 0 };
			POINT pt2;
			m_trans.DoTrans(ptdZero, pt2);
			POINT ptBoxDelta = { pt1.x - pt2.x - ptDelta.x, pt1.y - pt2.y - ptDelta.y };
			this->m_ptMouseDown.x += ptDelta.x;
			this->m_ptMouseDown.y += ptDelta.y;
			//this->m_ptdMouseDown IS ONLY USED WITH THE DOTTED ELECTION OUTLINE
			this->DragArrowSelectionBoxPart(ptBoxDelta, TRUE);
		} break;
		case ListViewWindow::eTrackDottedSelection: {
			POINTD ptd;
			m_trans.DoInvTrans(m_ptMouseLast, ptd);
			this->MoveArrowSelectionOutline(ptd, m_ptdMouseDown, TRUE, TRUE);
		} break;
		default:
			// DEBUG - FIX MAKE THIS COMPILE TIME
			ASSERTFAIL();
			break;
		}

		//if (m_bHasMouseCapture) {
		//	switch(m_ct) {
		//	case eHand:
		//		break;
		//	case eArrow: 
		//		switch(m_arrowSelMode) {
		//		case ListViewWindow::eSelectBox:
		//			if (this->m_bDragBoxPart) {
		//				POINT ptBoxDelta = { - ptDelta.x, - ptDelta.y };
		//				this->DragArrowSelectionBoxPart(ptBoxDelta, TRUE);
		//				break;
		//			}
		//			// FALL THRU
		//		case ListViewWindow::eSelectItems:
		//			POINTD ptd;
		//			m_trans.DoInvTrans(m_ptMouseLast, ptd);
		//			this->MoveArrowSelectionOutline(ptd, m_ptdMouseDown, TRUE, TRUE);
		//			break;
		//		default:
		//			ASSERTFAIL();
		//			break;
		//		}
		//		break;
		//	default:
		//		ASSERTFAIL();
		//		break;
		//	}
		//}
		
		// EITHER OF THESE WORKS, FIRST TRANSLATES AS MUCH OF LIST AS POSSIBLE USING A BITBLT
		// AND REPAINTS ONLY THE EDGES (BUT INCURS A SLIGHT INACCURACY DUE TO
		// DIFFERENCE BETWEEN RE-STRETCHBLTING AND TRANSLATING, AT LEAST WITH SOME VIDEO DRIVERS)
#if 1
		this->ScrollWindow(ptDelta.x, ptDelta.y, m_rView);
		//m_ps->Scroll(ptDelta);
		//this->UpdateSpriteOnNextPaint();
#else
		this->InvalidateRect(m_rView, TRUE);
#endif
		this->ResetRulers();
	}
}

// ****************************************************************************************
// **  STATIC:  class ListViewWindow  *****************************************************
// ****************************************************************************************

TCHAR ListViewWindow::atstrWindowClassName[] = LISTVIEWWINDOW_CLASSNAME;




//6/2 MOVED THIS CODE INTO THE ONE FN THAT CALLED IT, "SetList" (WITH MODS)
//void ListViewWindow::ResetSelection(void) {
//	switch(m_arrowSelMode) {
//	case ListViewWindow::eSelectBox:
//		this->MoveArrowSelectionBox(FALSE, NULL, FALSE, TRUE);
//		// FALL THRU
//	case ListViewWindow::eSelectItems: {
//		//std::vector<uint>& vsel = m_vsel;
//		//vsel.clear();
//		//int nList = m_pList->GetCount();
//		//vsel.insert(vsel.begin(), nList, ViewableList::eNormal);
//		std::vector<uint> vselTemp;
//		int nList = m_pList->GetCount();
//		vselTemp.insert(vselTemp.begin(), nList, ViewableList::eNormal);
//		if (vselTemp != m_vsel) {
//			m_vsel = vselTemp;
//			this->SendNotification(ListViewWindow::eArrowSelectionItemsChange);
//		}
//	} break;
//	default:
//		ASSERTFAIL();
//		break;
//	}
//
//	// 5/30
//	// IN THIS ROUTINE WE ARE RESETTING TO DEFAULT STATE, WITHOUT 
//	// ENSURING INVALIDATION OF DIRTY PAINT REGIONS
//	// THE ABOVE CALL TO "MoveArorwSelectionBox" SHOULDN'T BE USED,
//	// BUT SHOULD BE OK (IT DOESN'T MAKE USE OF m_pList)
//	ListViewWindow::HandSelState handsel;
//	//this->SetHandSelection(handsel);
//	this->m_handsel = handsel;
//}
//