windows-xp/Source/XPSP1/NT/enduser/netmeeting/ui/wb/textobj.cpp

//
// TEXTOBJ.CPP
// Drawing objects: point, openpolyline, closepolyline, ellipse
//
// Copyright Microsoft 1998-
//
#include "precomp.h"
#include "nmwbobj.h"


TextObj::TextObj(void)
{
#ifdef _DEBUG
    FillMemory(&m_textMetrics, sizeof(m_textMetrics), DBG_UNINIT);
#endif // _DEBUG

    //
    // ALWAYS ZERO OUT m_textMetrics.  Calculations depend on the height
    // and width of chars being zero before the font is set.
    //
    ZeroMemory(&m_textMetrics, sizeof(m_textMetrics));

	SetMyWorkspace(NULL);
	SetOwnerID(g_MyMemberID);

	m_ToolType = TOOLTYPE_TEXT;

	//
	// Created locally, not selected, not editing or deleting.
	//
	CreatedLocally();
	ClearSelectionFlags();
	ClearEditionFlags();
	ClearDeletionFlags();
	SetType(siNonStandardPDU_chosen);

	SetFillColor(RGB(-1,-1,-1),TRUE);
	SetZOrder(front);

	//
	// No attributes changed, they will be set as we change them
	//
	SetWorkspaceHandle(g_pCurrentWorkspace == NULL ? 0 : g_pCurrentWorkspace->GetWorkspaceHandle()); 
	SetType(drawingCreatePDU_chosen);
	SetROP(R2_NOTXORPEN);
	SetPlaneID(1);
	SetMyPosition(NULL);
	SetMyWorkspace(NULL);
	// 1 Pixels for pen thickness
	SetPenThickness(2);
	SetAnchorPoint(0,0);
	
	RECT rect;
    ::SetRectEmpty(&rect);
	SetRect(&rect);
	SetBoundsRect(&rect);

    m_hFontThumb = ::CreateFont(0,0,0,0,FW_NORMAL,0,0,0,0,OUT_TT_PRECIS,
        CLIP_DFA_OVERRIDE, DRAFT_QUALITY,FF_SWISS,NULL);

	m_hFont = ::CreateFont(0,0,0,0,FW_NORMAL,0,0,0,0,OUT_TT_PRECIS,
				    CLIP_DFA_OVERRIDE, 
				    DRAFT_QUALITY,
				    FF_SWISS,NULL);

	m_nKerningOffset = 0;
	ResetAttrib();

}

TextObj::~TextObj( void )
{
	RemoveObjectFromResendList(this);
	RemoveObjectFromRequestHandleList(this);

	TRACE_DEBUG(("drawingHandle = %d", GetThisObjectHandle() ));

	//
	// Tell other nodes that we are gone
	//
	if(GetMyWorkspace() != NULL && WasDeletedLocally())
	{
		OnObjectDelete();
	}

	if(m_hFont)
	{
		::DeleteFont(m_hFont);
        m_hFont = NULL;
	}


	if (m_hFontThumb)
    {
        ::DeleteFont(m_hFontThumb);
        m_hFontThumb = NULL;
    }


	strTextArray.ClearOut();
    strTextArray.RemoveAll();

}

void TextObj::TextEditObj (TEXTPDU_ATTRIB* pEditAttrib )
{

	RECT		rect;
	POSITION	pos;
	POINT		anchorPoint;
	LONG 		deltaX = 0;
	LONG		deltaY = 0;

	TRACE_DEBUG(("TextEditObj drawingHandle = %d", GetThisObjectHandle() ));

	//
	// Was edited remotely
	//
	ClearEditionFlags();

	//
	// Get the previous anchor point
	//
	GetAnchorPoint(&anchorPoint);

	//
	// Read attributes
	//
	m_dwChangedAttrib = pEditAttrib->attributesFlag;
	GetTextAttrib(pEditAttrib);

	//
	// Change the anchor point
	//
	if(HasAnchorPointChanged())
	{
		{
			//
			// Get the delta from previous anchor point
			//
			deltaX -= anchorPoint.x; 
			deltaY -= anchorPoint.y;

			//
			// Get the new anchor point
			//
			GetAnchorPoint(&anchorPoint);
			deltaX += anchorPoint.x; 
			deltaY += anchorPoint.y;
			TRACE_DEBUG(("Delta (%d,%d)", deltaX , deltaY));

			//
			// Was edited remotely
			//
			ClearEditionFlags();
		}
		
		UnDraw();

		GetRect(&rect);
		::OffsetRect(&rect,  deltaX, deltaY);
		SetRect(&rect);
		SetBoundsRect(&rect);

	}
	

	if(HasAnchorPointChanged() ||
		HasFillColorChanged() ||
		HasPenColorChanged() ||
		HasFontChanged() ||
		HasTextChanged())
	{
		Draw(NULL);
	}
	else if(HasZOrderChanged())
	{
		if(GetZOrder() == front)
		{
			g_pDraw->BringToTopSelection(FALSE, this);
		}
		else
		{
			g_pDraw->SendToBackSelection(FALSE, this);
		}
	}
	//
	// If it just select/unselected it
	//
	else if(HasViewStateChanged())
	{
		; // do nothing
	}
	//
	// If we have a valid font. 
	//
	else if(GetFont())
	{
		Draw();
	}

	//
	// Reset all the attributes
	//
	ResetAttrib();
}


void    TextObj::GetTextAttrib(TEXTPDU_ATTRIB * pattributes)
{
	if(HasPenColorChanged())
	{
		SetPenColor(pattributes->textPenColor, TRUE);
	}
	
	if(HasFillColorChanged())
	{
		SetFillColor(pattributes->textFillColor, TRUE);
	}
	
	if(HasViewStateChanged())
	{

		//
		// If the other node is selecting the drawing or unselecting
		//
		if(pattributes->textViewState == selected_chosen)
		{
			SelectedRemotely();
		}
		else if(pattributes->textViewState == unselected_chosen)
		{
			ClearSelectionFlags();
		}

		SetViewState(pattributes->textViewState);
	}
	
	if(HasZOrderChanged())
	{
		SetZOrder((ZOrder)pattributes->textZOrder);
	}
	
	if(HasAnchorPointChanged())
	{
		SetAnchorPoint(pattributes->textAnchorPoint.x, pattributes->textAnchorPoint.y );
	}
	
	if(HasFontChanged())
	{
		UnDraw();

		if(m_hFont)
		{
			::DeleteFont(m_hFont);
			m_hFont = NULL;
		}
	    m_hFont = ::CreateFontIndirect(&pattributes->textFont);
	    if (!m_hFont)
	    {
	        // Could not create the font
	        ERROR_OUT(("Failed to create font"));
	    }

        if (m_hFontThumb)
        {
            ::DeleteFont(m_hFontThumb);
            m_hFontThumb = NULL;
        }
        m_hFontThumb = ::CreateFontIndirect(&pattributes->textFont);
        if (!m_hFontThumb)
        {
            // Could not create the font
            ERROR_OUT(("Failed to create thumbnail font"));
        }
	}
	
	int lines = 0;
	UINT maxString = 0;
	
	if(HasTextChanged())
	{

		BYTE * pBuff = (BYTE *)&pattributes->textString;
		VARIABLE_STRING * pVarString = NULL;

		lines = pattributes->numberOfLines;
		int i;
		CHAR * cBuff = NULL;
		LPWSTR   lpWideCharStr;

		for (i = 0; i < lines ; i++)
		{
			pVarString  = (VARIABLE_STRING *) pBuff;

			lpWideCharStr = (LPWSTR)&pVarString->string;
			UINT strSize = 0;
			strSize= WideCharToMultiByte(CP_ACP, 0, lpWideCharStr, -1, NULL, 0, NULL, NULL ); 

			//
			// Get the longest string
			//
			if(strSize > maxString)
			{
				maxString = strSize;
			}
			
			DBG_SAVE_FILE_LINE
		    cBuff = new TCHAR[strSize];
			WideCharToMultiByte(CP_ACP, 0, lpWideCharStr, -1, cBuff, strSize, NULL, NULL );
			strTextArray.SetSize(i);
		    strTextArray.SetAtGrow(i, cBuff );
			delete cBuff;

 			ASSERT(pVarString->header.start.y == i);
			pBuff += pVarString->header.len;

		}

		//
		// Calculate the rect
		//
		if(m_hFont)
		{

			//
			// Remove the old text before we paly with the text size
			//
			UnDraw();

			g_pDraw->PrimeFont(g_pDraw->m_hDCCached, m_hFont, &m_textMetrics);
			g_pDraw->UnPrimeFont(g_pDraw->m_hDCCached);
		}	
	}

}

void    TextObj::SetTextAttrib(TEXTPDU_ATTRIB * pattributes)
{

	if(HasPenColorChanged())
	{
		GetPenColor(&pattributes->textPenColor);
	}
	
	if(HasFillColorChanged())
	{
		GetFillColor(&pattributes->textFillColor);
	}
	
	if(HasViewStateChanged())
	{
		pattributes->textViewState = GetViewState();
	}
	
	if(HasZOrderChanged())
	{
		pattributes->textZOrder = GetZOrder();
	}
	
	if(HasAnchorPointChanged())
	{
		GetAnchorPoint(&pattributes->textAnchorPoint);
	}
	
	if(HasFontChanged())
	{
	    ::GetObject(m_hFont, sizeof(LOGFONT), &pattributes->textFont);
	}
	

	if(HasTextChanged())
	{
		BYTE * pBuff = (BYTE *)&pattributes->textString;
		VARIABLE_STRING * pVarString= NULL;
		LPWSTR   lpWideCharStr;

		int size = strTextArray.GetSize();
		int i;

		for (i = 0; i < size ; i++)
		{
			pVarString = (VARIABLE_STRING *)pBuff;
			lpWideCharStr = (LPWSTR)&pVarString->string;
			int strSize = 0;
			strSize= MultiByteToWideChar(CP_ACP, 0, strTextArray[i], -1, lpWideCharStr, 0)*sizeof(WCHAR); 
			MultiByteToWideChar(CP_ACP, 0, strTextArray[i], -1, lpWideCharStr, strSize);
			pVarString->header.len = strSize + sizeof(VARIABLE_STRING_HEADER);
			pVarString->header.start.x = 0; // JOSEF change that
			pVarString->header.start.y = i;
			pBuff += pVarString->header.len;
		}

		pattributes->numberOfLines = size;

		//
		// Since we are sending text, need to send some font
		//
		::GetObject(m_hFont, sizeof(LOGFONT), &pattributes->textFont);
	}


	
}


void TextObj::CreateTextPDU(ASN1octetstring_t *pData, UINT choice)
{

	MSTextPDU * pTextPDU = NULL;
	UINT stringSize = 0;	// Size of all the strings UNICODE
	int lines = 0;			// Number of text lines

	//
	// Calculate the size of the whole pdu
	//
	ULONG length = 0;
	if(choice == textDeletePDU_chosen)
	{
		length = sizeof(MSTextDeletePDU);
	}
	else
	{

		//
		// Calculate the size of the text
		//
		if(HasTextChanged())
		{
			int i;
			lines = strTextArray.GetSize();

			for (i = 0; i < lines ; i++)
			{
				stringSize += MultiByteToWideChar(CP_ACP, 0, strTextArray[i], -1, NULL, 0) * sizeof(WCHAR); 
			}
		}

		length = sizeof(MSTextPDU) + sizeof(VARIABLE_STRING_HEADER)* lines + stringSize;
	}

	DBG_SAVE_FILE_LINE
	pTextPDU = (MSTextPDU *) new BYTE[length];

	//
	// PDU choice: create, edit delete
	//
	pTextPDU->header.nonStandardPDU = choice;

	//
	// This objects handle
	//
	pTextPDU->header.textHandle = GetThisObjectHandle();
	TRACE_DEBUG(("Text >> Text handle  = %d",pTextPDU->header.textHandle ));

	//
	// This objects workspacehandle
	//
	WorkspaceObj * pWorkspace = GetMyWorkspace();
	ASSERT(pWorkspace);
    if(pWorkspace == NULL)
    {
        delete pTextPDU;
        pData->value = NULL;
        pData->length = 0;
        return;
    }
	pTextPDU->header.workspaceHandle = pWorkspace->GetThisObjectHandle();
	TRACE_DEBUG(("Text >> Workspace handle  = %d",pTextPDU->header.workspaceHandle ));

	if(choice != textDeletePDU_chosen)
	{
		//
		// Get all the attributes that changed
		//
		pTextPDU->attrib.attributesFlag = GetPresentAttribs();
		SetTextAttrib(&pTextPDU->attrib);
	}

	//
	// Set the pointer for the data that is going to be encoded
	//
	pData->value = (ASN1octet_t *)pTextPDU;
	pData->length = length;
}




void TextObj::UnDraw(void)
{
	RECT rect;
	GetBoundsRect(&rect);
	g_pDraw->InvalidateSurfaceRect(&rect,TRUE);
}


void TextObj::Draw(HDC hDC, BOOL thumbNail, BOOL bPrinting)
{

	if(!bPrinting)
	{

		//
		// Don't draw anything if we don't belong in this workspace
		//
		if(GetWorkspaceHandle() != g_pCurrentWorkspace->GetThisObjectHandle())
		{
			return;
		}
	}

    RECT        clipBox;
    BOOL        dbcsEnabled = GetSystemMetrics(SM_DBCSENABLED);
    INT		    *tabArray; 
    UINT        ch;
    int         i,j;
    BOOL        zoomed    = g_pDraw->Zoomed();
    int		    oldBkMode = 0;
    int         iIndex    = 0;
    POINT       pointPos;
	int		    nLastTab;
	ABC		    abc;
    int		    iLength;
    TCHAR *     strLine;

    MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::Draw");

	if(hDC == NULL)
	{
		hDC = g_pDraw->m_hDCCached;
	}

    //
    // Only draw anything if the bounding rectangle intersects the current
    // clip box.
    //
    if (::GetClipBox(hDC, &clipBox) == ERROR)
	{
        WARNING_OUT(("Failed to get clip box"));
	}

    //
    // Select the font.
    //
    if (thumbNail)
	{
        TRACE_MSG(("Using thumbnail font"));
        g_pDraw->PrimeFont(hDC, m_hFontThumb, &m_textMetrics);
	}
    else
	{
        TRACE_MSG(("Using standard font"));
        g_pDraw->PrimeFont(hDC, m_hFont, &m_textMetrics);
	}

    //
    // Set the color and mode for drawing.
    //
    COLORREF rgb;
    GetPenColor(&rgb);
    
    ::SetTextColor(hDC, SET_PALETTERGB(rgb));

    //
    // Set the background to be transparent
    //
    oldBkMode = ::SetBkMode(hDC, TRANSPARENT);

    //
    // Calculate the bounding rectangle, accounting for the new font.
    //
    CalculateBoundsRect();

    if (!::IntersectRect(&clipBox, &clipBox, &m_rect))
    {
        TRACE_MSG(("No clip/bounds intersection"));
        return;
    }



    //
    // Get the start point for the text.
    //
    pointPos.x = m_rect.left + m_nKerningOffset;
    pointPos.y = m_rect.top;

    //
    // Loop through the text strings drawing each as we go.
    //
    for (iIndex = 0; iIndex < strTextArray.GetSize(); iIndex++)
	{
        //
        // Get a reference to the line to be printed for convenience.
        //
        strLine  = (LPTSTR)strTextArray[iIndex];
        iLength  = lstrlen(strLine);

        //
        // Only draw the line if there are any characters in it.
        //
        if (iLength > 0)
	  	{
            if (zoomed)
	  		{
				// if new fails just skip it
				DBG_SAVE_FILE_LINE
				tabArray = new INT[iLength+1];
				if( tabArray == NULL )
                {
                    ERROR_OUT(("Failed to allocate tabArray"));
					continue;
                }

				// We are zoomed. Must calculate char spacings
				// ourselfs so that they end up proportionally
				// in the right places. TabbedTextOut will not
				// do this right so we have to use ExtTextOut with
				// a tab array.

				// figure out tab array
                j = 0;
				nLastTab = 0;
                for (i=0; i < iLength; i++)
	  			{
                    ch = strLine[(int)i]; //Don't worry about DBCS here...
					abc = GetTextABC(strLine, 0, i);

					if( j > 0 )
						tabArray[j-1] = abc.abcB - nLastTab;

					nLastTab = abc.abcB;
					j++;
	  			}

				// Now, strip out any tab chars so they don't interact
				// in an obnoxious manner with the tab array we just
				// made and so they don't make ugly little 
				// blocks when they are drawn.
                for (i=0; i < iLength; i++)
	  			{
                    ch = strLine[(int)i];
                    if ((dbcsEnabled) && (IsDBCSLeadByte((BYTE)ch)))
						i++;
					else
                    if(strLine[(int)i] == '\t')
                        strLine[i] = ' '; // blow off tab, tab array 
											   // will compensate for this
	  			}

				// do it
                ::ExtTextOut(hDC, pointPos.x,
                                pointPos.y,
                                0,
                                NULL,
                                strLine,
                                iLength,
                                tabArray);

				delete tabArray; 
			}
            else
			{
                POINT   ptPos;

                GetAnchorPoint(&ptPos);

				// Not zoomed, just do it
				::TabbedTextOut(hDC, pointPos.x,
								 pointPos.y,
								 strLine,
								 iLength,
								 0,
								 NULL,
                                 ptPos.x);
			}
		}

        //
        // Move to the next line.
        //
        ASSERT(m_textMetrics.tmHeight != DBG_UNINIT);
        pointPos.y += (m_textMetrics.tmHeight);
	}

    //
    // Do NOT draw focus if clipboard or printing
    //
	if (WasSelectedLocally() && (hDC == g_pDraw->m_hDCCached))
	{
		DrawRect();
	}


    //
    // Restore the old background mode.
    //
    ::SetBkMode(hDC, oldBkMode);
    g_pDraw->UnPrimeFont(hDC);


	//
	// If we are drawing on top of a remote pointer, draw it.
	//
	BitmapObj* remotePointer = NULL;
	WBPOSITION pos = NULL;
	remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&m_rect, GetPenThickness()/2, NULL);
	while(remotePointer)
	{
		remotePointer->Draw();
		remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&m_rect, GetPenThickness()/2, remotePointer->GetMyPosition());
	}

    
}

void TextObj::SetPenColor(COLORREF rgb, BOOL isPresent)
{
	ChangedPenColor();
	m_bIsPenColorPresent = isPresent;
	if(!isPresent)
	{
		return;
	}
	
	m_penColor.rgbtRed = GetRValue(rgb);
	m_penColor.rgbtGreen = GetGValue(rgb);
	m_penColor.rgbtBlue = GetBValue(rgb);

}

BOOL TextObj::GetPenColor(COLORREF * rgb)
{
	if(m_bIsPenColorPresent)
	{
		*rgb = RGB(m_penColor.rgbtRed, m_penColor.rgbtGreen, m_penColor.rgbtBlue);
	}
	return m_bIsPenColorPresent;
}

BOOL TextObj::GetPenColor(RGBTRIPLE* rgb)
{
	if(m_bIsPenColorPresent)
	{
		*rgb = m_penColor;
	}
	return m_bIsPenColorPresent;
}


void TextObj::SetFillColor(COLORREF rgb, BOOL isPresent)
{
	ChangedFillColor();
	m_bIsFillColorPresent = isPresent;
	if(!isPresent)
	{
		return;
	}
	
	m_fillColor.rgbtRed = GetRValue(rgb);
	m_fillColor.rgbtGreen = GetGValue(rgb);
	m_fillColor.rgbtBlue = GetBValue(rgb);

}

BOOL TextObj::GetFillColor(COLORREF* rgb)
{
	if(m_bIsFillColorPresent && rgb !=NULL)
	{
		*rgb = RGB(m_fillColor.rgbtRed, m_fillColor.rgbtGreen, m_fillColor.rgbtBlue);
	}
	return m_bIsFillColorPresent;
}

BOOL TextObj::GetFillColor(RGBTRIPLE* rgb)
{
	if(m_bIsFillColorPresent && rgb!= NULL)
	{
		*rgb = m_fillColor;
	}
	return m_bIsFillColorPresent;
}

//
// Get the encoded buffer for Drawing Create PDU
//
void	TextObj::GetEncodedCreatePDU(ASN1_BUF *pBuf)
{
	SIPDU *sipdu = NULL;
	DBG_SAVE_FILE_LINE
	sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
	if(sipdu)
	{
		sipdu->choice = siNonStandardPDU_chosen;
		CreateNonStandardPDU(&sipdu->u.siNonStandardPDU.nonStandardTransaction, NonStandardTextID);
		CreateTextPDU(&sipdu->u.siNonStandardPDU.nonStandardTransaction.data, textCreatePDU_chosen);
		((MSTextPDU *)sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value)->header.nonStandardPDU = textCreatePDU_chosen;
		ASN1_BUF encodedPDU;
		g_pCoder->Encode(sipdu, pBuf);
		if(sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value)
		{
			delete sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value;
		}
		delete sipdu;
	}
	else
	{
		TRACE_MSG(("Failed to create penMenu"));
        ::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);

	}
}

void TextObj::SendTextPDU(UINT choice)
{

	if(!g_pNMWBOBJ->CanDoText())
	{
		return;
	}

	SIPDU *sipdu = NULL;
	DBG_SAVE_FILE_LINE
	sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
	if(sipdu)
	{
		sipdu->choice = siNonStandardPDU_chosen;
		CreateNonStandardPDU(&sipdu->u.siNonStandardPDU.nonStandardTransaction, NonStandardTextID);
		CreateTextPDU(&sipdu->u.siNonStandardPDU.nonStandardTransaction.data, choice);
        if(sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value == NULL)
        {
            return;
        }

		T120Error rc = SendT126PDU(sipdu);
		if(rc == T120_NO_ERROR)
		{
			ResetAttrib();
			SIPDUCleanUp(sipdu);
		}
	}
	else
	{
		TRACE_MSG(("Failed to create sipdu"));
        ::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
	}

}

//
// UI Created a new Drawing Object
//
void TextObj::SendNewObjectToT126Apps(void)
{
	SendTextPDU(textCreatePDU_chosen);
}

//
// UI Edited the Drawing Object
//
void	TextObj::OnObjectEdit(void)
{
	g_bContentsChanged = TRUE;
	SendTextPDU(textEditPDU_chosen);
}

//
// UI Deleted the Drawing Object
//
void	TextObj::OnObjectDelete(void)
{
	g_bContentsChanged = TRUE;
	SendTextPDU(textDeletePDU_chosen);
}

//
//
// Function:    TextObj::SetFont
//
// Purpose:     Set the font to be used for drawing
//
//
void TextObj::SetFont(HFONT hFont)
{
    MLZ_EntryOut(ZONE_FUNCTION, "TextObj::SetFont");

    // Get the font details
    LOGFONT lfont;
    ::GetObject(hFont, sizeof(LOGFONT), &lfont);

    //
    // Pass the logical font into the SetFont() function
    //
	SetFont(&lfont);
}




//
//
// Function:    TextObj::SetText
//
// Purpose:     Set the text of the object
//
//
void TextObj::SetText(TCHAR * strText)
{
    // Remove all the current stored text
	strTextArray.SetSize(0);

    // Scan the text for carriage return and new-line characters
    int iNext = 0;
    int iLast = 0;
    int textSize = lstrlen(strText);
    TCHAR savedChar[1];

    //
    // In this case, we don't know how many lines there will be.  So we
    // use Add() from the StrArray class.
    //
    while (iNext < textSize)
    {
        // Find the next carriage return or line feed
        iNext += StrCspn(strText + iNext, "\r\n");

        // Extract the text before the terminator
        // and add it to the current list of text lines.

        savedChar[0] = strText[iNext];
        strText[iNext] = 0;
        strTextArray.Add((strText+iLast));
        strText[iNext] = savedChar[0];
    

        if (iNext < textSize)
        {
            // Skip the carriage return
            if (strText[iNext] == '\r')
                iNext++;

            // Skip a following new line (if there is one)
            if (strText[iNext] == '\n')
                iNext++;

            // Update the index of the start of the next line
            iLast = iNext;
        }
    }

	if(textSize)
	{
    
		// Calculate the bounding rectangle for the new text
		CalculateBoundsRect();
		ChangedText();
	}
}



//
//
// Function:    TextObj::SetText
//
// Purpose:     Set the text of the object
//
//
void TextObj::SetText(const StrArray& _strTextArray)
{
    // Scan the text for carriage return and new-line characters
    int iSize = _strTextArray.GetSize();

    //
    // In this case we know how many lines, so set that # then use SetAt()
    // to stick text there.
    //
    strTextArray.RemoveAll();
    strTextArray.SetSize(iSize);

    int iNext = 0;
    for ( ; iNext < iSize; iNext++)
    {
        strTextArray.SetAt(iNext, _strTextArray[iNext]);
    }

    // Calculate the new bounding rectangle
    CalculateBoundsRect();

}



//
//
// Function:    TextObj::SetFont(metrics)
//
// Purpose:     Set the font to be used for drawing
//
//
void TextObj::SetFont(LOGFONT *pLogFont, BOOL bReCalc )
{
    HFONT hNewFont;

    MLZ_EntryOut(ZONE_FUNCTION, "TextObj::SetFont");

    // Ensure that the font can be resized by the zoom function
    // (proof quality prevents font scaling).
    pLogFont->lfQuality = DRAFT_QUALITY;

    //zap FontAssociation mode (bug 3258)
    pLogFont->lfClipPrecision |= CLIP_DFA_OVERRIDE;

    // Always work in cell coordinates to get scaling right
    TRACE_MSG(("Setting font height %d, width %d, face %s, family %d, precis %d",
        pLogFont->lfHeight,pLogFont->lfWidth,pLogFont->lfFaceName,
        pLogFont->lfPitchAndFamily, pLogFont->lfOutPrecision));

    hNewFont = ::CreateFontIndirect(pLogFont);
    if (!hNewFont)
    {
        // Could not create the font
        ERROR_OUT(("Failed to create font"));
        DefaultExceptionHandler(WBFE_RC_WINDOWS, 0);
	    return;
    }

    // We are now guaranteed to be able to delete the old font
    if (m_hFont != NULL)
    {
        DeleteFont(m_hFont);
    }
    m_hFont = hNewFont;


    // Calculate the line height for this font
    ASSERT(g_pDraw);
	g_pDraw->PrimeFont(g_pDraw->GetCachedDC(), m_hFont, &m_textMetrics);

    // Set up the thumbnail font, forcing truetype if not currently TT
    if (!(m_textMetrics.tmPitchAndFamily & TMPF_TRUETYPE))
    {
        pLogFont->lfFaceName[0]    = 0;
        pLogFont->lfOutPrecision   = OUT_TT_PRECIS;
        TRACE_MSG(("Non-True type font"));
    }

    if (m_hFontThumb != NULL)
    {
        ::DeleteFont(m_hFontThumb);
        m_hFontThumb = NULL;
    }
    m_hFontThumb = ::CreateFontIndirect(pLogFont);
    if (!m_hFontThumb)
    {
        // Could not create the font
        ERROR_OUT(("Failed to create thumbnail font"));
    }

    // Calculate the bounding rectangle, accounting for the new font
    if( bReCalc )
	    CalculateBoundsRect();

	ChangedFont();

	g_pDraw->UnPrimeFont(g_pDraw->m_hDCCached);
}


//
//
// Function:    TextObj::CalculateRect
//
// Purpose:     Calculate the bounding rectangle of a portion of the object
//
//
void TextObj::CalculateRect(int iStartX,
                                     int iStartY,
                                     int iStopX,
                                     int iStopY,
                                    LPRECT lprcResult)
{
    RECT    rcResult;
    RECT    rcT;
    int     iIndex;

    MLZ_EntryOut(ZONE_FUNCTION, "TextObj::CalculateRect");

    //
    // NOTE:
    // We must use an intermediate rectangle, so as not to disturb the
    // contents of the passed-in one until done.  lprcResult may be pointing
    // to the current bounds rect, and we call functions from here that
    // may need its current value.
    //

    // Initialize the result rectangle
    ::SetRectEmpty(&rcResult);

    if (!strTextArray.GetSize())
    {
        // Text is empty
        goto DoneCalc;
    }

    // Allow for special limit values and ensure that the start and stop
    // character positions are in range.
    if (iStopY == LAST_LINE)
    {
        iStopY = strTextArray.GetSize() - 1;
    }
    iStopY = min(iStopY, strTextArray.GetSize() - 1);
    iStopY = max(iStopY, 0);

    if (iStopX == LAST_CHAR)
    {
        iStopX = lstrlen(strTextArray[iStopY]);
    }
    iStopX = min(iStopX, lstrlen(strTextArray[iStopY]));
    iStopX = max(iStopX, 0);

    // Loop through the text strings, adding each to the rectangle
    for (iIndex = iStartY; iIndex <= iStopY; iIndex++)
    {
        int iLeftX = ((iIndex == iStartY) ? iStartX : 0);
        int iRightX = ((iIndex == iStopY)
                        ? iStopX : lstrlen(strTextArray[iIndex]));

        GetTextRectangle(iIndex, iLeftX, iRightX, &rcT);
        ::UnionRect(&rcResult, &rcResult, &rcT);
    }

DoneCalc:
    *lprcResult = rcResult;
}

//
//
// Function:    TextObj::CalculateBoundsRect
//
// Purpose:     Calculate the bounding rectangle of the object
//
//
void TextObj::CalculateBoundsRect(void)
{
    // Set the new bounding rectangle
    CalculateRect(0, 0, LAST_CHAR, LAST_LINE, &m_rect);
}


//
//
// Function:    TextObj::GetTextABC
//
// Purpose:     Calculate the ABC numbers for a string of text
//																			
// COMMENT BY RAND: The abc returned is for the whole string, not just one
//					char. I.e, ABC.abcA is the offset to the first glyph in
//					the string, ABC.abcB is the sum of all of the glyphs and
//					ABC.abcC is the trailing space after the last glyph. 	
//					ABC.abcA + ABC.abcB + ABC.abcC is the total rendered 	
//					length including overhangs.								
//
// Note - we never use the A spacing so it is always 0
//
ABC TextObj::GetTextABC( LPCTSTR pText,
                                int iStartX,
                                int iStopX)
{
	MLZ_EntryOut(ZONE_FUNCTION, "TextObj::GetTextABC");
	ABC  abcResult;
    HDC  hDC;
	BOOL rc = FALSE;
	ABC  abcFirst;
	ABC  abcLast;
	BOOL zoomed = g_pDraw->Zoomed();
	int  nCharLast;
	int  i;
	LPCTSTR pScanStr;
	
	ZeroMemory( (PVOID)&abcResult, sizeof abcResult );
	ZeroMemory( (PVOID)&abcFirst, sizeof abcFirst );
	ZeroMemory( (PVOID)&abcLast, sizeof abcLast );

	// Get the standard size measure of the text
	LPCTSTR pABC = (pText + iStartX);
	int pABCLength = iStopX - iStartX;
	hDC = g_pDraw->GetCachedDC();
	g_pDraw->PrimeFont(hDC, m_hFont, &m_textMetrics);

	//
	// We must temporarily unzoom if we are currently zoomed since the
	// weird Windows font handling will not give us the same answer for
	// the text extent in zoomed mode for some TrueType fonts
	//
	if (zoomed)
    {
		::ScaleViewportExtEx(hDC, 1, g_pDraw->ZoomFactor(), 1, g_pDraw->ZoomFactor(), NULL);
    }

    DWORD size = ::GetTabbedTextExtent(hDC, pABC, pABCLength, 0, NULL);

	// We now have the advance width of the text
	abcResult.abcB = LOWORD(size);
	TRACE_MSG(("Basic text width is %d",abcResult.abcB));

	// Allow for C space (or overhang)
	if (iStopX > iStartX)
		{
		if (m_textMetrics.tmPitchAndFamily & TMPF_TRUETYPE)
			{
			if(GetSystemMetrics( SM_DBCSENABLED ))
				{
				// have to handle DBCS on both ends
				if( IsDBCSLeadByte( (BYTE)pABC[0] ) )
					{
					// pack multi byte char into a WORD for GetCharABCWidths
					WORD wMultiChar = MAKEWORD( pABC[1], pABC[0] );
					rc = ::GetCharABCWidths(hDC, wMultiChar, wMultiChar, &abcFirst);
					}
				else
					{
					// first char is SBCS
					rc = ::GetCharABCWidths(hDC, pABC[0], pABC[0], &abcFirst );
					}

				// Check for DBCS as last char. Have to scan whole string to be sure
				pScanStr = pABC;
				nCharLast = 0;
				for( i=0; i<pABCLength; i++, pScanStr++ )
					{
					nCharLast = i;
					if( IsDBCSLeadByte( (BYTE)*pScanStr ) )
						{
						i++;
						pScanStr++;
						}
					}

				if( IsDBCSLeadByte( (BYTE)pABC[nCharLast] ) )
					{
					// pack multi byte char into a WORD for GetCharABCWidths
					ASSERT( (nCharLast+1) < pABCLength );
					WORD wMultiChar = MAKEWORD( pABC[nCharLast+1], pABC[nCharLast] );
					rc = ::GetCharABCWidths(hDC, wMultiChar, wMultiChar, &abcLast);
					}
				else
					{
					// last char is SBCS
					rc = ::GetCharABCWidths(hDC, pABC[nCharLast], pABC[nCharLast], &abcLast );
					}
				}
			else
				{
				// SBCS, no special fiddling, just call GetCharABCWidths()
				rc = ::GetCharABCWidths(hDC, pABC[0], pABC[0], &abcFirst );

				nCharLast = pABCLength-1;
				rc = rc && ::GetCharABCWidths(hDC, pABC[nCharLast], pABC[nCharLast], &abcLast );
				}

			TRACE_MSG(("abcFirst: rc=%d, a=%d, b=%d, c=%d", 
						rc, abcFirst.abcA, abcFirst.abcB, abcFirst.abcC) );
			TRACE_MSG(("abcLast: rc=%d, a=%d, b=%d, c=%d", 
						rc, abcLast.abcA, abcLast.abcB, abcLast.abcC) );
			}


		if( rc )
			{
			// The text was trutype and we got good abcwidths
			// Give the C space of the last characters from
			// the string as the C space of the text.
			abcResult.abcA = abcFirst.abcA;
			abcResult.abcC = abcLast.abcC;
			}
		else
			{
			//
			// Mock up C value for a non TT font by taking some of overhang as
			// the negative C value.
			//
			//TRACE_MSG(("Using overhang -%d as C space",m_textMetrics.tmOverhang/2));
			
			// Adjust B by -overhang to make update rect schoot
			// far enough to the left so that the toes of italic cap A's
			// don't get clipped. Ignore comment above.
			abcResult.abcB -= m_textMetrics.tmOverhang;
			}
		}

	//
	// If we temporarily unzoomed then restore it now
	//
	if (zoomed)
    {
		::ScaleViewportExtEx(hDC, g_pDraw->ZoomFactor(), 1, g_pDraw->ZoomFactor(), 1, NULL);
	}

	TRACE_MSG(("Final text width is %d, C space %d",abcResult.abcB,abcResult.abcC));

	return abcResult;
}





//
//
// Function:    TextObj::GetTextRectangle
//
// Purpose:     Calculate the bounding rectangle of a portion of the object
//
//
void TextObj::GetTextRectangle(int iStartY,
                                        int iStartX,
                                        int iStopX,
                                        LPRECT lprc)
{
	// ABC structures for text sizing
	ABC abcText1;
	ABC abcText2;
	int iLeftOffset = 0;
	MLZ_EntryOut(ZONE_FUNCTION, "TextObj::GetTextRectangle");

    ASSERT(iStartY < strTextArray.GetSize());

	// Here we calculate the width of the text glyphs in which we
	// are interested. In case there are tabs involved we must start
	// with position 0 and get two lengths then subtract them

	abcText1 = GetTextABC(strTextArray[iStartY], 0, iStopX);

	if (iStartX > 0)
	{
		
		// The third param used to be iStartX-1 which is WRONG. It
		// has to point to the first char pos past the string
		// we are using.
		abcText2 = GetTextABC(strTextArray[iStartY], 0, iStartX);

		
		// Just use B part for offset. Adding A snd/or C to it moves the update
		// rectangle too far to the right and clips the char
		iLeftOffset = abcText2.abcB;
		}
	else
		{
		
		ZeroMemory( &abcText2, sizeof abcText2 );
		}

	//
	// We need to allow for A and C space in the bounding rectangle.  Use
	// ABS function just to make sure we get a large enough rectangle.
	//
	
	// Move A and C from original offset calc to here for width of update 
	// rectangle. Add in tmOverhang (non zero for non-tt fonts) to compensate
	// for the kludge in GetTextABC()....THIS EDITBOX CODE HAS GOT TO GO...
	abcText1.abcB = abcText1.abcB - iLeftOffset +	
					  abs(abcText2.abcA) + abs(abcText2.abcC) +
					  abs(abcText1.abcA) + abs(abcText1.abcC) +
					  m_textMetrics.tmOverhang;

	TRACE_DEBUG(("Left offset %d",iLeftOffset));
	TRACE_DEBUG(("B width now %d",abcText1.abcB));

	// Build the result rectangle.
	// Note that we never return an empty rectangle. This allows for the
	// fact that the Windows rectangle functions will ignore empty
	// rectangles completely. This would cause the bounding rectangle
	// calculation (for instance) to go wrong if the top or bottom lines
	// in a text object were empty.
    ASSERT(m_textMetrics.tmHeight != DBG_UNINIT);
	int iLineHeight = m_textMetrics.tmHeight + m_textMetrics.tmExternalLeading;

    lprc->left = 0;
    lprc->top = 0;
    lprc->right = max(1, abcText1.abcB);
    lprc->bottom = iLineHeight;
    ::OffsetRect(lprc, iLeftOffset, iLineHeight * iStartY);

	// rect is the correct width at this point but it might need to be schooted to 
	// the left a bit to allow for kerning of 1st letter (bug 469)
	if( abcText1.abcA < 0 )
	{
        ::OffsetRect(lprc, abcText1.abcA, 0);
		m_nKerningOffset = -abcText1.abcA;
	}
	else
		m_nKerningOffset = 0;

    POINT   pt;
    GetAnchorPoint(&pt);
    ::OffsetRect(lprc, pt.x, pt.y);
}