scemfaxctl.cpp

Source code for EMFexplorer 1.0

// Paper color style
short CSCEMFAxCtrl::GetPaperColorStyle() 
{
	return m_usPaperColorStyle;
}

void CSCEMFAxCtrl::SetPaperColorStyle(short nNewValue) 
{
	m_CtlImage.SCSetPaperColorStyle(m_usPaperColorStyle = nNewValue, m_crPaperColor);

	SetModifiedFlag();
}

/// Paper color
OLE_COLOR CSCEMFAxCtrl::GetPaperColor() 
{
	return m_crPaperColor;
}

void CSCEMFAxCtrl::SetPaperColor(OLE_COLOR nNewValue) 
{
	// TODO: if (failed) return
	m_CtlImage.SCSetPaperColor(m_crPaperColor = nNewValue);

	SetModifiedFlag();
}

/// Fit mode
short CSCEMFAxCtrl::GetFitMode() 
{
	return m_usFitMode;
}

void CSCEMFAxCtrl::SetFitMode(short nNewValue) 
{
	m_CtlImage.SCSetFitMode(m_usFitMode = nNewValue);
	m_fScale = m_CtlImage.SCGetScale();
	SetModifiedFlag();
}

/// Scale
float CSCEMFAxCtrl::GetScale() 
{
	return m_fScale;
}

void CSCEMFAxCtrl::SetScale(float newValue) 
{
	if (SC_FIT_NONE!=m_usFitMode)
		return; // reject the scale

	m_CtlImage.SCSetScale(m_fScale = newValue);
	SetModifiedFlag();
}

/// Margins
OLE_XSIZE_PIXELS CSCEMFAxCtrl::GetMarginL() 
{
	return m_lMarginL;
}

void CSCEMFAxCtrl::SetMarginL(OLE_XSIZE_PIXELS nNewValue) 
{
	m_CtlImage.SCSetLMargin(m_lMarginL=nNewValue);

	SetModifiedFlag();
}

OLE_YSIZE_PIXELS CSCEMFAxCtrl::GetMarginT() 
{
	return m_lMarginT;
}

void CSCEMFAxCtrl::SetMarginT(OLE_YSIZE_PIXELS nNewValue) 
{
	m_CtlImage.SCSetTMargin(m_lMarginT=nNewValue);

	SetModifiedFlag();
}

OLE_XSIZE_PIXELS CSCEMFAxCtrl::GetMarginR() 
{
	return m_lMarginR;
}

void CSCEMFAxCtrl::SetMarginR(OLE_XSIZE_PIXELS nNewValue) 
{
	m_CtlImage.SCSetRMargin(m_lMarginR=nNewValue);

	SetModifiedFlag();
}

OLE_YSIZE_PIXELS CSCEMFAxCtrl::GetMarginB() 
{
	return m_lMarginB;
}

void CSCEMFAxCtrl::SetMarginB(OLE_YSIZE_PIXELS nNewValue) 
{
	m_CtlImage.SCSetBMargin(m_lMarginB=nNewValue);

	SetModifiedFlag();
}

/// Orientation
short CSCEMFAxCtrl::GetPageOrientation() 
{
	return m_usPageOrientation;
}

void CSCEMFAxCtrl::SetPageOrientation(short nNewValue) 
{
	m_CtlImage.SCSetAngle(m_usPageOrientation = nNewValue);
	SetModifiedFlag();
}

/// Transparency
short CSCEMFAxCtrl::GetTransparencyMode() 
{
	return m_usTransparencyMode;
}

void CSCEMFAxCtrl::SetTransparencyMode(short nNewValue) 
{
	m_CtlImage.SCSetTransparencyMode(m_usTransparencyMode = nNewValue);

	SetModifiedFlag();
}

/// Reverse video mode
short CSCEMFAxCtrl::GetReverseVideoMode() 
{
	return m_usReverseVideoMode;
}

void CSCEMFAxCtrl::SetReverseVideoMode(short nNewValue) 
{
	m_CtlImage.SCSetReverseVideoMode(m_usReverseVideoMode = nNewValue);

	SetModifiedFlag();
}

/// GDI+ Engine
BOOL CSCEMFAxCtrl::GetGDIplusEnabled() 
{
	return m_bEnableGDIp;
}

void CSCEMFAxCtrl::SetGDIplusEnabled(BOOL bNewValue) 
{
	m_CtlImage.SCEnableGDIp(m_bEnableGDIp = bNewValue);
	SetModifiedFlag();
}


////////////////////////////////////////////////
// m_CtlImage::DrawingAttributes update helper
#define SC_SETCTL_ATTR_NEWVALUE(ctlattr, member)\
	member = nNewValue; \
	m_CtlImage.SCSet##ctlattr##(nNewValue); \
	SetModifiedFlag()

////////////////////////////////////////////////

// Text rendering
short CSCEMFAxCtrl::GetTextRenderingHint() 
{
	return m_usTextRenderingHint;
}

void CSCEMFAxCtrl::SetTextRenderingHint(short nNewValue) 
{
	SC_SETCTL_ATTR_NEWVALUE(TextRenderingHint, m_usTextRenderingHint);
}

// Text contrast
short CSCEMFAxCtrl::GetTextContrast() 
{
	return m_usTextContrast;
}

void CSCEMFAxCtrl::SetTextContrast(short nNewValue) 
{
	SC_SETCTL_ATTR_NEWVALUE(TextContrast, m_usTextContrast);
}

// Text contrast
short CSCEMFAxCtrl::GetSmoothingMode() 
{
	return m_usSmoothingMode;
}

void CSCEMFAxCtrl::SetSmoothingMode(short nNewValue) 
{
	SC_SETCTL_ATTR_NEWVALUE(SmoothingMode, m_usSmoothingMode);
}

// Interpolation mode
short CSCEMFAxCtrl::GetInterpolationMode() 
{
	return m_usInterpolationMode;
}

void CSCEMFAxCtrl::SetInterpolationMode(short nNewValue) 
{
	SC_SETCTL_ATTR_NEWVALUE(InterpolationMode, m_usInterpolationMode);
}

// PixelOffset mode
short CSCEMFAxCtrl::GetPixelOffsetMode() 
{
	return m_usPixelOffsetMode;
}

void CSCEMFAxCtrl::SetPixelOffsetMode(short nNewValue) 
{
	SC_SETCTL_ATTR_NEWVALUE(PixelOffsetMode, m_usPixelOffsetMode);
}

//////////////////////////////////////////////////////////////////////////////////
// Support for enumerated properties
//

BOOL CSCEMFAxCtrl::OnGetPredefinedStrings(DISPID dispid, CStringArray* pStringArray, CDWordArray* pCookieArray) 
{
  BOOL bResult = FALSE;

  try
  {
	  switch (dispid)
	  {
	  case dispidTransparencyMode:
		  bResult = SCGetTransparencyModeStrings(pStringArray, pCookieArray);
		  break;

	  case dispidReverseVideoMode:
		  bResult = SCGetReverseVideoModeStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidPaperColorStyle:
	  case dispidCtlColorStyle:
		  bResult = SCGetColorStyleStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidFitMode:
		  bResult = SCGetPageFitModeStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidPageOrientation:
		  bResult = SCGetPageOrientationStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidTextRenderingHint:
		  bResult = SCGetTextRenderingHintStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidTextContrast:
		  bResult = SCGetTextContrastStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidSmoothingMode:
		  bResult = SCGetSmoothingModeStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidInterpolationMode:
		  bResult = SCGetInterpolationModeStrings(pStringArray, pCookieArray);
		  break;
		  
	  case dispidPixelOffsetMode:
		  bResult = SCGetPixelOffsetModeStrings(pStringArray, pCookieArray);
		  break;

	  case dispidCtlBorder:
		  bResult = SCGetCtlBorderStrings(pStringArray, pCookieArray);
		  break;
	  }
  }
  catch(CException* pEx)
  {
	  pStringArray->RemoveAll();
	  pCookieArray->RemoveAll();
	  
	  bResult = FALSE;

	  pEx->Delete();
  }

  if (!bResult)
    return COleControl::OnGetPredefinedStrings(dispid, pStringArray, pCookieArray);

  return TRUE;
}

BOOL CSCEMFAxCtrl::OnGetPredefinedValue(DISPID dispid, DWORD dwCookie, VARIANT* lpvarOut) 
{
  BOOL bResult = FALSE;
  DWORD dwValue;
  switch (dispid)
  {
	  case dispidTransparencyMode:
		  bResult = SCGetTransparencyModePredefinedValue(dwValue, dwCookie);
		  break;

	  case dispidReverseVideoMode:
		  bResult = SCGetReverseVideoModePredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidPaperColorStyle:
	  case dispidCtlColorStyle:
		  bResult = SCGetColorStylePredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidFitMode:
		  bResult = SCGetPageFitModePredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidPageOrientation:
		  bResult = SCGetPageOrientationPredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidTextRenderingHint:
		  bResult = SCGetTextRenderingHintPredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidTextContrast:
		  bResult = SCGetTextContrastPredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidSmoothingMode:
		  bResult = SCGetSmoothingModePredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidInterpolationMode:
		  bResult = SCGetInterpolationModePredefinedValue(dwValue, dwCookie);
		  break;
		  
	  case dispidPixelOffsetMode:
		  bResult = SCGetPixelOffsetModePredefinedValue(dwValue, dwCookie);
		  break;

 	  case dispidCtlBorder:
 		  bResult = SCGetCtlBorderPredefinedValue(dwValue, dwCookie);
		  break;
  }
  if (bResult)
  {
      VariantClear(lpvarOut);
      V_VT(lpvarOut) = VT_I2;
      V_I2(lpvarOut) = (short)dwValue;
	  
      return TRUE;
  }

  return COleControl::OnGetPredefinedValue(dispid, dwCookie, lpvarOut);
}

BOOL CSCEMFAxCtrl::OnGetDisplayString(DISPID dispid, CString& strValue) 
{
  switch (dispid)
  {
	case dispidTransparencyMode:
      return SCGetTransparencyModeDisplayString(strValue, m_usTransparencyMode);

    case dispidReverseVideoMode:
      return SCGetReverseVideoModeDisplayString(strValue, m_usReverseVideoMode);

    case dispidPaperColorStyle:
      return SCGetColorStyleDisplayString(strValue, m_usPaperColorStyle);

    case dispidCtlColorStyle:
      return SCGetColorStyleDisplayString(strValue, m_usCtlColorStyle);

	case dispidFitMode:
	  return SCGetPageFitModeDisplayString(strValue, m_usFitMode);

	case dispidPageOrientation:
	  return SCGetPageOrientationDisplayString(strValue, m_usPageOrientation);

	case dispidTextRenderingHint:
	  return SCGetTextRenderingHintDisplayString(strValue, m_usTextRenderingHint);

	case dispidTextContrast:
	  return SCGetTextContrastDisplayString(strValue, m_usTextContrast);

	case dispidSmoothingMode:
	  return SCGetSmoothingModeDisplayString(strValue, m_usSmoothingMode);

	case dispidInterpolationMode:
	  return SCGetInterpolationModeDisplayString(strValue, m_usInterpolationMode);

	case dispidPixelOffsetMode:
	  return SCGetPixelOffsetModeDisplayString(strValue, m_usPixelOffsetMode);

 	 case dispidCtlBorder:
	  return SCGetCtlBorderDisplayString(strValue, m_usCtlBorder);
  }

  return COleControl::OnGetDisplayString(dispid, strValue);
}

long CSCEMFAxCtrl::SaveAs(LPCTSTR lpszPathName, short nFileType, BOOL bSaveAll) 
{
	// TODO: check the path and return SC_EMFAX_ERR_BADPATH if necessary

	// Convert external type
	int iType;
	switch (nFileType)
	{
	case SC_EMFAX_FTYPE_EMFONLY:	iType = SC_FILETYPE_EMFONLY; break;
	case SC_EMFAX_FTYPE_EMFPLUS:	iType = SC_FILETYPE_EMFPLUS; break;
	case SC_EMFAX_FTYPE_EMFDUAL:	iType = SC_FILETYPE_EMFDUAL; break;
	case SC_EMFAX_FTYPE_WMF:		iType = SC_FILETYPE_WMF; break;
	case SC_EMFAX_FTYPE_JPG:		iType = SC_FILETYPE_JPG; break;
	case SC_EMFAX_FTYPE_PNG:		iType = SC_FILETYPE_PNG; break;
	case SC_EMFAX_FTYPE_BMP:		iType = SC_FILETYPE_BMP; break;
	case SC_EMFAX_FTYPE_GIF:		iType = SC_FILETYPE_GIF; break;
	default:
		{// attempt to guess
			iType = SCFileTypeFromExt(lpszPathName);
			switch (iType)
			{
			case SC_FILETYPE_JPG:
			case SC_FILETYPE_PNG:
			case SC_FILETYPE_BMP:
			case SC_FILETYPE_GIF:
			case SC_FILETYPE_TIFF:
			case SC_FILETYPE_EMFONLY:
			case SC_FILETYPE_EMFPLUS:
			case SC_FILETYPE_EMFDUAL:
				break;
			
			//case SC_FTYPE_UKN:
			default: // and all others
				return SC_EMFAX_ERR_BADFTYPE;
			}
		}
		break;
	}

	// TODO: Get error from SCSaveDocument and convert to EMFAX error
	m_CtlImage.SCSaveDocument(lpszPathName, iType, bSaveAll);
	return SC_EMFAX_NOERR;
}