magickimage.cpp

下载来的一个看图软件的源代码

          bFoundOption = false;
          if (V_ISBYREF(pvarIndex))
            pDispatch = *V_DISPATCHREF(pvarIndex);
          else
            pDispatch = V_DISPATCH(pvarIndex);

          if (pDispatch)
          {
            DispatchToImage(pDispatch,&pMagickImage);
          }
          break;
        }

        case VT_UNKNOWN:
        {
          IUnknown *pUnknown;

          bFoundOption = false;
          if (V_ISBYREF(pvarIndex))
            pUnknown = *V_UNKNOWNREF(pvarIndex);
          else
            pUnknown = V_UNKNOWN(pvarIndex);

          if (pUnknown)
          {
            UnknownToImage(pUnknown,&pMagickImage);
          }
          break;
        }
#endif

        case VT_BSTR:
        case VT_BSTR | VT_BYREF:
        {
          LPTSTR lpszVal;
				  LPTSTR lpszNext;

          if (V_ISBYREF(pvarIndex))
	          lpszVal = W2T(*V_BSTRREF(pvarIndex));
          else
	          lpszVal = W2T(V_BSTR(pvarIndex));

          bFoundOption = false;
          // is this a command line option argument?
          if ((*lpszVal == _T('+')) || (*lpszVal == _T('-')))
          {
            bFoundOption = true;
				    lpszNext = StrChr(lpszVal, _T('='));
				    if (lpszNext == NULL)
              hr = AddArgs(V_BSTR(pvarIndex));
            else
            {
				      int nLength = lpszNext - lpszVal;
				      if (nLength > 16)
                hr = AddArgs(V_BSTR(pvarIndex));
              else
              {
                *lpszNext = _T('\0');
                hr = AddArgs(lpszVal);
                hr = AddArgs(++lpszNext);
              }
              break;
            }
          }
          else
            hr = AddArgs(lpszVal);
          break;
        }

        case VT_UI1:
        case VT_UI1 | VT_BYREF:
        case VT_I2:
        case VT_I2 | VT_BYREF:
        case VT_I4:
        case VT_I4 | VT_BYREF:
        case VT_R4:
        case VT_R4 | VT_BYREF:
        case VT_R8:
        case VT_R8 | VT_BYREF:
        case VT_DECIMAL:
        case VT_DECIMAL | VT_BYREF:
        {
          VARIANT variant;

          bFoundOption = false;
          VariantInit(&variant);
          hr = VariantChangeTypeEx(&variant, pvarIndex, lcidDefault, 0, VT_BSTR);
          if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR)
          {
            hr = AddArgs(V_BSTR(&variant));
          }
          VariantClear(&variant);
          break;
        }

        default:
          ThrowPerformException(exception,ErrorException,
            "Perform","Unsupported argument type");
      }
    }
  }

	LogInformation(methodName,"before execute");

  ImageInfo
    *image_info;

  image_info=CloneImageInfo((ImageInfo *) NULL);
  hr = Execute(func,&text,image_info,exception);
  DestroyImageInfo(image_info);

	LogInformation(methodName,"after execute");

  if (text != (char *) NULL)
    {
      CComVariant var;
      var = text;
      var.Detach(pVar);
      LiberateMemory((void **) &text);
    }

  if (m_coll.size())
  {
    CComVector<VARIANT> v(m_coll.size());
    if( !v )
    {
      //m_coll.clear();
      ThrowPerformException(exception,ErrorException,
        "Perform","Problems sending back array messages (1)");
    }
    else
    {
      // WARNING: This nested code block is required because
      // CComVectorData ctor performs a SafeArrayAccessData
      // and you have to make sure the SafeArrayUnaccessData
      // is called (which it is in the CComVectorData dtor)
      // before you use the CComVector::DetachTo(...).
      CComVectorData<VARIANT> msgs(v);
      if( !msgs )
      {
        //m_coll.clear();
        ThrowPerformException(exception,ErrorException,
          "Perform","Problems sending back array messages (2)");
      }
      else
      {
        for(int index = 0; index < m_coll.size(); ++index)
        {
          CComVariant vt(m_coll[index]);
          HRESULT hr = vt.Detach(&msgs[index]);
        }
      }
    }    
    V_VT(pVar) = VT_ARRAY | VT_VARIANT;
    V_ARRAY(pVar) = v.Detach();
    //m_coll.clear();
  }
	LogInformation(methodName,"return");
  return hr;
}

void CMagickImage::warninghandler(const ExceptionType warning,const char *message,
  const char *qualifier)
{
#ifdef STORE_MESSAGES
  error_callback->error_number=errno;
  errno=0;
  if (!message)
    return;
  FormatString(error_callback->warning_text,"Warning %d: %.1024s%s%.1024s%s%s%.64s%s",warning,
    message,qualifier ? " (" : "",qualifier ? qualifier : "",
    qualifier? ")" : "",error_callback->error_number ? " [" : "",
    error_callback->error_number ? strerror(error_callback->error_number) : "",error_callback->error_number ? "]" : "");
  CComVariant var(error_callback->warning_text);
  error_callback->m_coll.push_back(var);
#endif
  char warning_text[MaxTextExtent];

  if (!message)
  {
	  LogInformation("warninghandler","called with no message");
    return;
  }
  FormatString(warning_text,"ImageMagickObject - warning %d: %.1024s%s%.1024s%s%s%.64s%s\n",warning,
    message,qualifier ? " (" : "",qualifier ? qualifier : "",
    qualifier? ")" : "",errno ? " [" : "",
    errno ? strerror(errno) : "",errno ? "]" : "");
	DebugString(warning_text);
}

void CMagickImage::errorhandler(const ExceptionType warning,const char *message,
  const char *qualifier)
{
  char error_text[MaxTextExtent];

  if (!message)
  {
	  LogInformation("errorhandler","called with no message");
    return;
  }
  FormatString(error_text,"ImageMagickObject - error %d: %.1024s%s%.1024s%s%s%.64s%s\n",warning,
    message,qualifier ? " (" : "",qualifier ? qualifier : "",
    qualifier? ")" : "",errno ? " [" : "",
    errno ? strerror(errno) : "",errno ? "]" : "");
	DebugString(error_text);
}

void CMagickImage::fatalerrorhandler(const ExceptionType error,const char *message,
  const char *qualifier)
{
  char fatalerror_text[MaxTextExtent];

  if (!message)
  {
	  LogInformation("fatalhandler","called with no message");
    return;
  }
  FormatString(fatalerror_text,"ImageMagickObject - fatal error %d: %.1024s%s%.1024s%s%s%.64s%s",error,
    (message ? message : "ERROR"),
    qualifier ? " (" : "",qualifier ? qualifier : "",qualifier ? ")" : "",
    errno ? " [" : "",errno ? strerror(errno) : "",
    errno? "]" : "");
	DebugString(fatalerror_text);
  _DbgBreak();
}

HRESULT CMagickImage::Execute(
  unsigned int (*func)(ImageInfo *image_info,const int argc,char **argv,char **text,ExceptionInfo *exception),
    char **s,
      ImageInfo *image_info,
        ExceptionInfo *exception)
{
  unsigned int retcode = 0;

  retcode = (func)(image_info, GetArgc(), GetArgv(), s, exception);
  if (!retcode)
    return E_UNEXPECTED;
  return S_OK;
}

// Command line argument processing methods
HRESULT CMagickImage::AddArgs(VARIANTARG *rgvarg)
{
  HRESULT hr = S_OK;
  VARTYPE vt = V_VT(rgvarg);

  while (vt == (VT_VARIANT|VT_BYREF))
  {
	  rgvarg = V_VARIANTREF(rgvarg);
	  vt = V_VT(rgvarg);
  }
  if (V_ISARRAY(rgvarg))
  {
	  SAFEARRAY *psa = V_ISBYREF(rgvarg) ? *V_ARRAYREF(rgvarg) : V_ARRAY(rgvarg);
	  void **pav;
	  int index;
	  long *pArrayIndex, *pLowerBound, *pUpperBound;
	  VARIANT variant;

	  int dim = SafeArrayGetDim(psa);

	  VariantInit(&variant);
	  V_VT(&variant) = (vt & ~VT_ARRAY) | VT_BYREF;

	  pArrayIndex = new long [dim];
	  pLowerBound= new long [dim];
	  pUpperBound= new long [dim];
	  pav = new void *[dim];

	  for(index = 0; index < dim; ++index)
    {
      pav[index] = (void *) NULL;
      SafeArrayGetLBound(psa, index+1, &pLowerBound[index]);
      SafeArrayGetLBound(psa, index+1, &pArrayIndex[index]);
      SafeArrayGetUBound(psa, index+1, &pUpperBound[index]);
	  }

	  hr = SafeArrayLock(psa);
	  if (SUCCEEDED(hr))
    {
      while (index >= 0)
      {
		    hr = SafeArrayPtrOfIndex(psa, pArrayIndex, &V_BYREF(&variant));
		    if (FAILED(hr))
		      break;

        hr = AddArgs(&variant);
		    if (FAILED(hr))
		      break;

        for (index = dim-1; index >= 0; --index)
        {
          if (++pArrayIndex[index] <= pUpperBound[index])
            break;

		      pArrayIndex[index] = pLowerBound[index];
        }
      }

      /* preserve previous error code */
      HRESULT hr2 = SafeArrayUnlock(psa);
      if (SUCCEEDED(hr))
        hr = hr2;
	  }

    delete pArrayIndex;
    delete pLowerBound;
    delete pUpperBound;
    delete pav;

    return hr;
  }
  switch(vt & ~VT_BYREF)
  {
    case VT_VARIANT: /* invalid, should never happen */
    case VT_EMPTY:
    case VT_NULL:
      break;

    case VT_BSTR:
    {
      if (V_ISBYREF(rgvarg))
        hr = AddArgs(*V_BSTRREF(rgvarg));
      else
        hr = AddArgs(V_BSTR(rgvarg));
      break;
    }

#ifdef SUPPORT_OBJECTS
    case VT_DISPATCH:
    {
      IDispatch *pDispatch;

      if (V_ISBYREF(rgvarg))
        pDispatch = *V_DISPATCHREF(rgvarg);
      else
        pDispatch = V_DISPATCH(rgvarg);

      if (pDispatch)
      {
        CComBSTR bstrIOType;
        CComBSTR bstrName;
        CComBSTR bstrTemp;

        CComQIPtr<IDispatch> ptrDisp(pDispatch);
        CComQIPtr<IMagickImage> ptrObject;
        ptrObject = ptrDisp;
        ptrObject->get_Name(&bstrIOType);
        ptrObject->get_Name(&bstrName);
        bstrTemp = bstrIOType;
        bstrTemp += _T("@");
        bstrTemp += bstrName;
        hr = AddArgs(bstrTemp);
      }
      break;
    }

    case VT_UNKNOWN:
    {
      IUnknown *pUnknown;

      if (V_ISBYREF(rgvarg))
        pUnknown = *V_UNKNOWNREF(rgvarg);
      else
        pUnknown = V_UNKNOWN(rgvarg);

      if (pUnknown)
      {
        CComBSTR bstrName;

        CComPtr<IUnknown> ptrUnk(pUnknown);
        CComQIPtr<IMagickImage> ptrObject;
        ptrObject = ptrUnk;
        ptrObject->get_Name(&bstrName);
        hr = AddArgs(bstrName);
      }
      break;
    }
#endif

    case VT_DECIMAL:
    {
      VARIANT variant;
      VariantInit(&variant);
      hr = VariantChangeTypeEx(&variant, rgvarg, lcidDefault, 0, VT_R8);
      if (SUCCEEDED(hr) && V_VT(&variant) == VT_R8)
      {
        /* sv_setnv(sv, V_R8(&variant)); */
      }
      VariantClear(&variant);
      break;
    }

    case VT_BOOL:
    case VT_UI1:
    case VT_I2:
    case VT_I4:
    case VT_R4:
    case VT_R8:
    case VT_ERROR:
    case VT_DATE:
    case VT_CY:
    default:
    {
      VARIANT variant;

      VariantInit(&variant);
      hr = VariantChangeTypeEx(&variant, rgvarg, lcidDefault, 0, VT_BSTR);
      if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR)
      {
        hr = AddArgs(V_BSTR(&variant));
      }
      VariantClear(&variant);
      break;
    }
  }
  return hr;
}

HRESULT CMagickImage::AddArgs(BSTR widestr)
{
  HRESULT hr = E_OUTOFMEMORY;

  if (m_argvIndex >= m_argc)
    return hr;

  hr = S_OK;
  MAKE_ANSIPTR_FROMWIDE(ptrANSI, widestr);
  m_argv[m_argvIndex++] = ptrANSI;

	DebugString("ImageMagickObject - arg: %s\n",ptrANSI);

  if (m_argvIndex >= m_argc)
    hr = ReAllocateArgs( nDefaultArgumentSize );

  return hr;
}

HRESULT CMagickImage::AddArgs(LPTSTR lpstr)
{
  HRESULT hr = E_OUTOFMEMORY;

  if (m_argvIndex >= m_argc)
    return hr;

  hr = S_OK;
#ifdef _UNICODE
  MAKE_ANSIPTR_FROMWIDE(ptrANSI, lpstr);
#else
  MAKE_COPY_OF_ANSI(ptrANSI, lpstr);
#endif
  m_argv[m_argvIndex++] = ptrANSI;

	DebugString("ImageMagickObject - arg: %s\n",ptrANSI);

  if (m_argvIndex >= m_argc)
    hr = ReAllocateArgs( nDefaultArgumentSize );

  return hr;
}

HRESULT CMagickImage::AllocateArgs(int cArgc)
{
  m_argv = new LPTSTR [cArgc];
  m_argv_t = new LPTSTR [cArgc];

  if ((m_argv == NULL) || (m_argv_t == NULL))
    return E_OUTOFMEMORY;
  m_argc = cArgc;

  m_argvIndex = 0;
  for (int i=0; i<m_argc; i++)
  {
    m_argv[i] = NULL;
    m_argv_t[i] = NULL;
  }
  return S_OK;
}

HRESULT CMagickImage::ReAllocateArgs(int cArgc)
{
  LPTSTR *argv = m_argv;
  LPTSTR *argv_t = m_argv_t;
  int argc = m_argc + cArgc;

  argv = new LPTSTR [argc];
  argv_t = new LPTSTR [argc];

  if ((argv == NULL) || (argv_t == NULL))
    return E_OUTOFMEMORY;

  for (int i=0; i<argc; i++)
  {
    if (i < m_argc)
    {
      argv[i] = m_argv[i];
      argv_t[i] = m_argv_t[i];
    }
    else
    {
      argv[i] = NULL;
      argv_t[i] = NULL;
    }
  }
  if (m_argv)
  {
    delete m_argv;
    m_argv = argv;
  }
  if (m_argv_t)
  {
    delete m_argv_t;
    m_argv_t = argv_t;
  }
  m_argc = argc;
  return S_OK;
}

void CMagickImage::DeleteArgs()
{
  EmptyArgs();
  if (m_argv)
    delete m_argv;
  if (m_argv_t)
    delete m_argv_t;
}

char **CMagickImage::GetArgv()
{
  return m_argv;
}

char **CMagickImage::GetArgvT()
{
  return m_argv_t;
}

int CMagickImage::GetArgc()
{
  return m_argvIndex;
}

void CMagickImage::EmptyArgs()
{
  for (int i=0; i<m_argc; i++)
  {
    if (m_argv[i] != NULL)
      delete (void *) (m_argv[i]);
    m_argv[i] = NULL;
    if (m_argv_t[i] != NULL)
      delete (void *) (m_argv_t[i]);
    m_argv_t[i] = NULL;
  }
  m_argvIndex = 0;
}

LPTSTR CMagickImage::StrChr(LPTSTR lpsz, TCHAR ch)
{
	LPTSTR p = NULL;
	while (*lpsz)
	{
		if (*lpsz == ch)
		{
			p = lpsz;
			break;
		}
		lpsz = CharNext(lpsz);
	}
	return p;
}