ErrorCode HTMLIFrameElement::Load()
{
ASSERT(0);
return 0;
#if 0
ASSERT(m_pFrameContent);
sysstring src = get_src();
if (src.Length())
{
TCHAR result[2048];
{
sysstring documentUrl = m_ownerDocument->get_url();
DWORD resultLen = sizeof(result);
InternetCombineUrl(W2A(documentUrl), W2A(src), result, &resultLen, 0);
}
CComBSTR url = A2W(result);
return m_pFrameContent->LoadSRC(CComQIPtr<IHlinkSite>(m_ownerDocument), url);
}
else
return S_FALSE;
#endif
}
ErrorCode SVGImageElement::Load()
{
if (!m_bTriedLoaded)
{
m_bTriedLoaded = true;
ASSERT(m_document == NULL);
ASSERT(m_pSVGDocumentView == NULL);
ASSERT(m_pImage == NULL);
String src = href_attr()->m_animVal;//GetAnimVal()->m_value;//getStringValue();//m_animated->m_animVal->m_value;
if (src)
{
#if 0
if (!wcsncmp(src, L"data:", 5))
{
// Try to load it as raster bitmap
m_document.Release();
m_pImage = g_Images.OpenImage(src);
}
else
#endif
{
WCHAR result[2048];
{
String documentUrl = m_ownerDocument->get_url();
DWORD resultLen = sizeof(result);
InternetCombineUrl(CStringw(documentUrl).c_str(), CStringw(src).c_str(), result, &resultLen, 0);
}
/*
m_document.CoCreateInstance(CLSID_LSVGDocument);
VARIANT_BOOL bSVGDocument;
m_document->load(_variant_t(result), &bSVGDocument);
if (!bSVGDocument)
*/
{
// Try to load it as raster bitmap
// m_document.Release();
// m_pImage = g_Images.OpenImage(new StringW(string_copy(result)));
Net::UrlBinding binding;
_Ptr<IO::Stream> stream = binding.BindToObject(String(string_copy(result)), NULL);
//Imaging::BitmapLoader loader;
// loader.Load(stream);
m_pImage = new CImage;
m_pImage->m_bitmap = Graphics::Bitmap::FromStream(stream);
}
return 0;
}
}
}
return Error;
}
ErrorCode SVGCursorElement::Load()
{
ASSERT(0);
#if 0
USES_CONVERSION;
if (!m_bTriedLoaded)
{
m_bTriedLoaded = true;
// ATLASSERT(m_document == NULL);
// ATLASSERT(m_pSVGDocumentView == NULL);
ASSERT(m_pImage == NULL);
sysstring src = m_href->m_animated->m_animVal->m_value;
if (src.length())
{
TCHAR result[2048];
{
sysstring documentUrl = m_ownerDocument->get_url();
sysstring baseUrl = documentUrl;
DWORD resultLen = sizeof(result);
InternetCombineUrl(baseUrl, W2A(src), result, &resultLen, 0);
}
/*
m_document.CoCreateInstance(CLSID_LSVGDocument);
bool bSVGDocument;
m_document->load(_bstr_t(result), &bSVGDocument);
if (!bSVGDocument)
*/
{
// Try to load it as raster bitmap
// m_document.Release();
m_pImage = g_Images.OpenImage(result);
}
return S_OK;
}
}
#endif
return Error;
}
HRESULT STDMETHODCALLTYPE WebViewProtocol::CombineUrl(LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl,
DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult,
DWORD dwReserved)
{
if (pwzBaseUrl == NULL || pwzRelativeUrl == NULL || pwzResult == NULL || pcchResult == NULL)
return E_POINTER;
*pcchResult = cchResult;
BOOL ret = InternetCombineUrl(pwzBaseUrl, pwzRelativeUrl, pwzResult, pcchResult, ICU_NO_ENCODE | ICU_NO_META);
if (!ret)
{
DWORD err = GetLastError();
if (err == ERROR_INSUFFICIENT_BUFFER)
return S_FALSE; // Buffer too small
else
return E_FAIL;
}
return S_OK;
}
SVGElementDefElement* SVGExtensionDefsElement::GetElementDef(StringIn namespaceURI, StringIn name)
{
ASSERT(0);
#if 0
if (pVal == NULL) return E_POINTER;
*pVal = NULL;
CComBSTR namespaceAttr;
getAttribute(L"namespace", &namespaceAttr);
if (!cmpbstr(namespaceAttr, namespaceURI))
{
for (int i = 0; i < m_childNodes->m_items.GetSize(); i++)
{
CComQIPtr<ILSVGElementDefElement> elementDef = m_childNodes->m_items[i];
if (elementDef)
{
CComBSTR nameAttr;
elementDef->getAttribute(L"name", &nameAttr);
if (!cmpbstr(nameAttr, name))
{
*pVal = elementDef;
(*pVal)->AddRef();
return S_OK;
}
}
}
}
#if 0
{
BSTR clsidstr; getAttribute(L"classid", &clsidstr);
if (!clsidstr) return;
// TODO, allow white-space
if (!wcsnicmp(clsidstr, L"clsid:", 6))
{
_bstr_t classid = _bstr_t(clsidstr + lstrlen("clsid:"));
if (((BSTR)classid)[0] != L'{') // }
{
classid = L"{" + classid + L"}";
}
CLSID clsid;
HRESULT hr = CLSIDFromString(classid, &clsid);
m_factory.CoCreateInstance(clsid);
}
}
#endif
CComBSTR href;
getAttributeNS(L"http://www.w3.org/1999/xlink", L"href", &href);
if (href.Length())
{
if (m_hrefDocument == NULL) // Loading for first time
{
WCHAR url[4096];
wcscpy(url, href);
WCHAR* id = NULL;
int i = href.Length()-1;
while (i >= 0)
{
if (url[i] == L'#')
{
url[i] = 0;
id = &url[i+1];
break;
}
i--;
}
TCHAR result[2048];
{
CComBSTR documentUrl;
m_ownerDocument->get_url(&documentUrl);
DWORD resultLen = sizeof(result);
InternetCombineUrl(_bstr_t(documentUrl), _bstr_t(url), result, &resultLen, 0);
}
m_hrefDocument.CoCreateInstance(CLSID_LDOMDocument);
if (m_hrefDocument)
{
bool bsuccess;
m_hrefDocument->load(_variant_t(result), &bsuccess);
{
CScriptSite* pScriptSite = CComQIPtr<CLDOMDocumentImplImpl>(m_hrefDocument)->m_pScriptSite;
HRESULT hr;
// Start running scripts
hr = pScriptSite->m_activeScript->SetScriptState(SCRIPTSTATE_STARTED);
ASSERT(SUCCEEDED(hr));
// force the engine to connect any outbound interfaces to the
// host's objects
hr = pScriptSite->m_activeScript->SetScriptState(SCRIPTSTATE_CONNECTED);
ASSERT(SUCCEEDED(hr));
}
if (id)
{
CComPtr<ILDOMElement> element;
m_hrefDocument->getElementById(id, &element);
m_extensionDefsElement = CComQIPtr<ILSVGExtensionDefsElement>(element);
}
}
}
if (m_extensionDefsElement)
{
return static_cast<CLSVGExtensionDefsElement*>(m_extensionDefsElement.p)->GetElementDef(namespaceURI, name, pVal);
}
}
#endif
return NULL;
}
void MovieTexture::CreateTexture(Graphics::RenderTarget* renderTarget)
{
if (m_status == 0)
{
m_status = 1;
if (m_url->get_size() > 0)
{
auto url0 = m_url->get1Value(0);
#if 0
TCHAR fullurl[512];
{
DWORD resultLen = sizeof(fullurl);
InternetCombineUrl(W2A(m_pScene->m_url), W2A(url0), fullurl, &resultLen, 0);
}
ErrorCode hr = LoadURL(_bstr_t(fullurl));
if (SUCCEEDED(hr))
{
/*
CComPtr<IStream> stream;
ErrorCode hr = URLOpenBlockingStream(0, _bstr_t(fullurl), &stream, 0, 0);
LDraw::Bitmap* pBitmap = new LDraw::Bitmap(stream);
if (pBitmap->GetLastStatus() == LDraw::Ok)
{
LDraw::BitmapData bitmapData;
if (pBitmap->LockBits(
&LDraw::Rect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight()),
LDraw::ImageLockModeRead,
PixelFormat32bppARGB, &bitmapData) == 0)
{
}
}
*/
glGenTextures(1, &m_texName);
ASSERT(glGetError() == GL_NO_ERROR);
glBindTexture(GL_TEXTURE_2D, m_texName);
ASSERT(glGetError() == GL_NO_ERROR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, (m_repeatS->m_value)? GL_REPEAT : GL_CLAMP);
ASSERT(glGetError() == GL_NO_ERROR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, (m_repeatT->m_value)? GL_REPEAT : GL_CLAMP);
ASSERT(glGetError() == GL_NO_ERROR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
ASSERT(glGetError() == GL_NO_ERROR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
ASSERT(glGetError() == GL_NO_ERROR);
LVIDEOINFOHEADER2* vih = ((LVIDEOINFOHEADER2*)m_pVideoFilter->m_pInput->m_mt->pbFormat);
int width = vih->bmiHeader.biWidth;
int height = vih->bmiHeader.biHeight;
m_texwidth = 1;
while (m_texwidth < width) m_texwidth <<= 1;
m_texheight = 1;
while (m_texheight < height) m_texheight <<= 1;
//BYTE* p = new BYTE[m_texwidth*m_texheight*3];
glTexImage2D(GL_TEXTURE_2D, 0, 4, m_texwidth, m_texheight, 0/*border*/, GL_RGB, GL_UNSIGNED_BYTE, NULL/*bitmapData.Scan0*/);
ASSERT(glGetError() == GL_NO_ERROR);
// pBitmap->UnlockBits(&bitmapData);
//delete pBitmap;
m_filterGraph->Run();
}
#endif
}
}
}
char * HTParse (const char *aName, const char *relatedName, int wanted)
{
int ret;
char *result, *abs, *rel;
DWORD len;
BOOL bAgain = FALSE;
#if 0
if (aName && *aName) {
abs = xmalloc(strlen(aName) + 2);
strcpy(abs, aName);
strcat(abs, "/");
}
else {
/* FIXME: what does mean a null base url ? */
abs = xstrdup("");
}
#else
abs = xstrdup(aName ? aName : "");
#endif
rel = (relatedName ? relatedName : "");
len = strlen(abs) + strlen(rel) + 45;
result = xmalloc(len*sizeof(char));
#if 0
fprintf(stderr, "HTParse called with aName = %s and relatedName = %s\n",
aName, relatedName);
#endif
do {
if (*rel) {
ret = InternetCombineUrl(abs, rel, result, &len, ICU_BROWSER_MODE);
}
else {
ret = InternetCanonicalizeUrl(abs, result, &len, ICU_BROWSER_MODE);
}
bAgain = FALSE;
if (!ret) {
switch (GetLastError()) {
case ERROR_INSUFFICIENT_BUFFER:
#if 0
fprintf(stderr, "InternetCombineUrl: buffer was not long enough (needed %d)\n", len+1);
#endif
result = xrealloc(result, len+1);
bAgain = TRUE;
break;
case ERROR_BAD_PATHNAME:
fprintf(stderr, "InternetCombineUrl failed, one of the path names is bad:\n\t%s\n\t%s\n",
aName, relatedName);
break;
case ERROR_INTERNET_INVALID_URL:
fprintf(stderr, "InternetCombineUrl failed, url %s is malformed.\n", aName);
break;
case ERROR_INVALID_PARAMETER:
fprintf(stderr, "InternetCombineUrl failed with `invalid parameter'.\n");
break;
default:
break;
}
}
} while (bAgain);
/* abs has always been malloc'ed */
if (abs)
free(abs);
if (!ret) {
/* FIXME: Try this poor thing ! */
sprintf(result, "%s/%s", aName, relatedName);
}
#if 0
fprintf(stderr, "HTParse: result is %s\n", result);
#endif
return result;
}
void CASXMLSchemaModel::IncludeSchema(Element* mergeDocumentElement)
{
// CComPtr<ILDOMDocument> ownerDocument;
// mergeDocumentElement->get_ownerDocument(&ownerDocument);
Node* child = mergeDocumentElement->get_firstChild();
while (child != NULL)
{
Node* nextSibling = child->get_nextSibling();
Element* element = dynamic_cast<Element*>(child);
if (element)
{
String tagName = element->get_tagName();
if (tagName == L"include")
{
ASSERT(0);
#if 0
CComObject<CASXMLInclude>* pEl;
CComObject<CASXMLInclude>::CreateInstance(&pEl);
if (pEl)
{
pEl->AddRef();
pEl->m_pSchema = this;
pEl->m_element = element;
CComObject<CASXMLSchemaModel>::CreateInstance(&pEl->m_asModel);
if (pEl->m_asModel)
{
pEl->m_asModel->AddRef();
m_globalElements->m_items.Add(pEl);
CComBSTR schemaLocation;
element->getAttribute(L"schemaLocation", &schemaLocation);
TCHAR absSchemaLocation[2048];
{
CComBSTR documentUrl;
ownerDocument->get_url(&documentUrl);
_bstr_t baseUrl = documentUrl;
DWORD resultLen = sizeof(absSchemaLocation);
InternetCombineUrl(baseUrl, _bstr_t(schemaLocation), absSchemaLocation, &resultLen, 0);
}
bool bloadedSchema;
pEl->m_asModel->m_xmlDocument.CoCreateInstance(CLSID_LDOMDocument);
pEl->m_asModel->m_xmlDocument->load(_variant_t(absSchemaLocation), &bloadedSchema);
if (bloadedSchema)
{
CComPtr<ILDOMElement> mergeDocumentElement;
pEl->m_asModel->m_xmlDocument->get_documentElement(&mergeDocumentElement);
if (mergeDocumentElement)
{
m_asModels->m_items.Add(pEl->m_asModel);
// AddDocument(schemadoc);
IncludeSchema(mergeDocumentElement); // Recurse
}
else
{
MessageBox(NULL, "Failed to include schema", "", MB_OK);
}
}
else
{
MessageBox(NULL, "Failed to include schema", "", MB_OK);
}
}
}
#endif
}
else
{
CDefinition/*CDefinition*/ * pDef = CreateDefinition(element);
if (pDef)
{
pDef->BuildDefs(element);
m_globalDefs.m_defs.Add(pDef);
m_globalElements->m_items.Add(dynamic_cast<IASDeclaration*>(pDef));
}
//m_schemaElement->appendChild(element, NULL);
}
}
child = nextSibling;
}
}
