static HRESULT create_http_protocol(BOOL https, void **ppobj)
{
HttpProtocol *ret;
ret = heap_alloc_zero(sizeof(HttpProtocol));
if(!ret)
return E_OUTOFMEMORY;
ret->base.vtbl = &AsyncProtocolVtbl;
ret->IInternetProtocolEx_iface.lpVtbl = &HttpProtocolVtbl;
ret->IInternetPriority_iface.lpVtbl = &HttpPriorityVtbl;
ret->IWinInetHttpInfo_iface.lpVtbl = &WinInetHttpInfoVtbl;
ret->https = https;
ret->ref = 1;
*ppobj = &ret->IInternetProtocolEx_iface;
URLMON_LockModule();
return S_OK;
}
/*****************************************************************************
* GdipCombineRegionRegion [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion *region1,
GpRegion *region2, CombineMode mode)
{
region_element *left, *right = NULL;
GpStatus stat;
GpRegion *reg2copy;
TRACE("%p %p %d\n", region1, region2, mode);
if(!(region1 && region2))
return InvalidParameter;
/* simply replace region data */
if(mode == CombineModeReplace){
stat = GdipCloneRegion(region2, ®2copy);
if(stat != Ok) return stat;
delete_element(®ion1->node);
memcpy(region1, reg2copy, sizeof(GpRegion));
heap_free(reg2copy);
return Ok;
}
left = heap_alloc_zero(sizeof(region_element));
if (!left)
return OutOfMemory;
*left = region1->node;
stat = clone_element(®ion2->node, &right);
if (stat != Ok)
{
heap_free(left);
return OutOfMemory;
}
fuse_region(region1, left, right, mode);
region1->num_children += region2->num_children;
return Ok;
}
static DNS_STATUS dns_copy_record( ns_msg msg, ns_sect section,
unsigned short num, DNS_RECORDA **recp )
{
DNS_STATUS ret;
DNS_RECORDA *record;
WORD dlen;
ns_rr rr;
if (dns_ns_parserr( &msg, section, num, &rr ) < 0)
return DNS_ERROR_BAD_PACKET;
if (!(record = heap_alloc_zero( dns_get_record_size( &rr ) )))
return ERROR_NOT_ENOUGH_MEMORY;
record->pName = dns_strdup_u( rr.name );
if (!record->pName)
{
heap_free( record );
return ERROR_NOT_ENOUGH_MEMORY;
}
record->wType = rr.type;
record->Flags.S.Section = section;
record->Flags.S.CharSet = DnsCharSetUtf8;
record->dwTtl = rr.ttl;
if ((ret = dns_copy_rdata( msg, &rr, record, &dlen )))
{
heap_free( record->pName );
heap_free( record );
return ret;
}
record->wDataLength = dlen;
*recp = record;
TRACE( "found %s record in %s section\n",
dns_type_to_str( rr.type ), dns_section_to_str( section ) );
return ERROR_SUCCESS;
}
GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash,
INT count)
{
INT i;
REAL sum = 0;
TRACE("(%p, %p, %d)\n", pen, dash, count);
if(!pen || !dash)
return InvalidParameter;
if(count <= 0)
return OutOfMemory;
for(i = 0; i < count; i++){
sum += dash[i];
if(dash[i] < 0.0)
return InvalidParameter;
}
if(sum == 0.0 && count)
return InvalidParameter;
heap_free(pen->dashes);
pen->dashes = NULL;
if(count > 0)
pen->dashes = heap_alloc_zero(count * sizeof(REAL));
if(!pen->dashes){
pen->numdashes = 0;
return OutOfMemory;
}
GdipSetPenDashStyle(pen, DashStyleCustom);
memcpy(pen->dashes, dash, count * sizeof(REAL));
pen->numdashes = count;
return Ok;
}
static HRESULT WINAPI JScriptParse_InitNew(IActiveScriptParse *iface)
{
JScript *This = impl_from_IActiveScriptParse(iface);
script_ctx_t *ctx;
HRESULT hres;
TRACE("(%p)\n", This);
if(This->ctx)
return E_UNEXPECTED;
ctx = heap_alloc_zero(sizeof(script_ctx_t));
if(!ctx)
return E_OUTOFMEMORY;
ctx->ref = 1;
ctx->state = SCRIPTSTATE_UNINITIALIZED;
ctx->active_script = &This->IActiveScript_iface;
ctx->safeopt = This->safeopt;
ctx->version = This->version;
ctx->ei.val = jsval_undefined();
heap_pool_init(&ctx->tmp_heap);
hres = create_jscaller(ctx);
if(FAILED(hres)) {
heap_free(ctx);
return hres;
}
ctx->last_match = jsstr_empty();
ctx = InterlockedCompareExchangePointer((void**)&This->ctx, ctx, NULL);
if(ctx) {
script_release(ctx);
return E_UNEXPECTED;
}
return This->site ? set_ctx_site(This) : S_OK;
}
HRESULT HLink_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
{
HlinkImpl * hl;
TRACE("unkOut=%p riid=%s\n", pUnkOuter, debugstr_guid(riid));
*ppv = NULL;
if (pUnkOuter)
return CLASS_E_NOAGGREGATION;
hl = heap_alloc_zero(sizeof(HlinkImpl));
if (!hl)
return E_OUTOFMEMORY;
hl->ref = 1;
hl->IHlink_iface.lpVtbl = &hlvt;
hl->IPersistStream_iface.lpVtbl = &psvt;
hl->IDataObject_iface.lpVtbl = &dovt;
*ppv = hl;
return S_OK;
}
HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
{
HTMLTable *ret;
nsresult nsres;
ret = heap_alloc_zero(sizeof(HTMLTable));
if(!ret)
return E_OUTOFMEMORY;
ret->element.node.vtbl = &HTMLTableImplVtbl;
ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
ret->IHTMLTable2_iface.lpVtbl = &HTMLTable2Vtbl;
ret->IHTMLTable3_iface.lpVtbl = &HTMLTable3Vtbl;
HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;
}
static HRESULT alloc_regexp(script_ctx_t *ctx, jsdisp_t *object_prototype, RegExpInstance **ret)
{
RegExpInstance *regexp;
HRESULT hres;
regexp = heap_alloc_zero(sizeof(RegExpInstance));
if(!regexp)
return E_OUTOFMEMORY;
if(object_prototype)
hres = init_dispex(®exp->dispex, ctx, &RegExp_info, object_prototype);
else
hres = init_dispex_from_constr(®exp->dispex, ctx, &RegExpInst_info, ctx->regexp_constr);
if(FAILED(hres)) {
heap_free(regexp);
return hres;
}
*ret = regexp;
return S_OK;
}
static HRESULT alloc_array(script_ctx_t *ctx, jsdisp_t *object_prototype, ArrayInstance **ret)
{
ArrayInstance *array;
HRESULT hres;
array = heap_alloc_zero(sizeof(ArrayInstance));
if(!array)
return E_OUTOFMEMORY;
if(object_prototype)
hres = init_dispex(&array->dispex, ctx, &Array_info, object_prototype);
else
hres = init_dispex_from_constr(&array->dispex, ctx, &Array_info, ctx->array_constr);
if(FAILED(hres)) {
heap_free(array);
return hres;
}
*ret = array;
return S_OK;
}
static HRESULT create_arguments(script_ctx_t *ctx, IDispatch *calee, unsigned argc, jsval_t *argv, jsdisp_t **ret)
{
jsdisp_t *args;
DWORD i;
HRESULT hres;
static const WCHAR caleeW[] = {'c','a','l','l','e','e',0};
args = heap_alloc_zero(sizeof(jsdisp_t));
if(!args)
return E_OUTOFMEMORY;
hres = init_dispex_from_constr(args, ctx, &Arguments_info, ctx->object_constr);
if(FAILED(hres)) {
heap_free(args);
return hres;
}
for(i=0; i < argc; i++) {
hres = jsdisp_propput_idx(args, i, argv[i]);
if(FAILED(hres))
break;
}
if(SUCCEEDED(hres)) {
hres = jsdisp_propput_name(args, lengthW, jsval_number(argc));
if(SUCCEEDED(hres))
hres = jsdisp_propput_name(args, caleeW, jsval_disp(calee));
}
if(FAILED(hres)) {
jsdisp_release(args);
return hres;
}
*ret = args;
return S_OK;
}
static HRESULT string_alloc(script_ctx_t *ctx, jsdisp_t *object_prototype, jsstr_t *str, StringInstance **ret)
{
StringInstance *string;
HRESULT hres;
string = heap_alloc_zero(sizeof(StringInstance));
if(!string)
return E_OUTOFMEMORY;
if(object_prototype)
hres = init_dispex(&string->dispex, ctx, &String_info, object_prototype);
else
hres = init_dispex_from_constr(&string->dispex, ctx, &StringInst_info, ctx->string_constr);
if(FAILED(hres)) {
heap_free(string);
return hres;
}
string->str = jsstr_addref(str);
*ret = string;
return S_OK;
}
static IHTMLDOMChildrenCollection *create_child_collection(HTMLDocumentNode *doc, nsIDOMNodeList *nslist)
{
HTMLDOMChildrenCollection *ret;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return NULL;
ret->IHTMLDOMChildrenCollection_iface.lpVtbl = &HTMLDOMChildrenCollectionVtbl;
ret->ref = 1;
nsIDOMNodeList_AddRef(nslist);
ret->nslist = nslist;
htmldoc_addref(&doc->basedoc);
ret->doc = doc;
init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLDOMChildrenCollection_iface,
&HTMLDOMChildrenCollection_dispex);
return &ret->IHTMLDOMChildrenCollection_iface;
}
static inline HRESULT XMLView_BindStatusCallback_Create(IBindStatusCallback *bsc_html,
IMoniker *mon, IStream *stream, IBindStatusCallback **ret)
{
BindStatusCallback *bsc;
bsc = heap_alloc_zero(sizeof(BindStatusCallback));
if(!bsc)
return E_OUTOFMEMORY;
bsc->IBindStatusCallback_iface.lpVtbl = &XMLView_BindStatusCallbackVtbl;
bsc->ref = 1;
bsc->bsc = bsc_html;
IBindStatusCallback_AddRef(bsc_html);
bsc->stream = stream;
IStream_AddRef(bsc->stream);
bsc->mon = mon;
IMoniker_AddRef(mon);
*ret = &bsc->IBindStatusCallback_iface;
return S_OK;
}
HRESULT HLinkBrowseContext_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
{
HlinkBCImpl * hl;
TRACE("unkOut=%p riid=%s\n", pUnkOuter, debugstr_guid(riid));
*ppv = NULL;
if (pUnkOuter)
return CLASS_E_NOAGGREGATION;
hl = heap_alloc_zero(sizeof(HlinkBCImpl));
if (!hl)
return E_OUTOFMEMORY;
hl->ref = 1;
hl->IHlinkBrowseContext_iface.lpVtbl = &hlvt;
list_init(&hl->links);
hl->current = NULL;
*ppv = hl;
return S_OK;
}
static HRESULT create_sub_matches(DWORD pos, match_state_t *result, SubMatches **sub_matches)
{
SubMatches *ret;
DWORD i;
HRESULT hres;
hres = init_regexp_typeinfo(SubMatches_tid);
if(FAILED(hres))
return hres;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return E_OUTOFMEMORY;
ret->ISubMatches_iface.lpVtbl = &SubMatchesVtbl;
ret->result = result;
if(result) {
ret->match = heap_alloc((result->match_len+1) * sizeof(WCHAR));
if(!ret->match) {
heap_free(ret);
return E_OUTOFMEMORY;
}
memcpy(ret->match, result->cp-result->match_len, result->match_len*sizeof(WCHAR));
ret->match[result->match_len] = 0;
result->cp = NULL;
for(i=0; i<result->paren_count; i++)
if(result->parens[i].index != -1)
result->parens[i].index -= pos;
}else {
ret->match = NULL;
}
ret->ref = 1;
*sub_matches = ret;
return hres;
}
GpStatus WINGDIPAPI GdipSetImageAttributesRemapTable(GpImageAttributes *imageAttr,
ColorAdjustType type, BOOL enableFlag, UINT mapSize,
GDIPCONST ColorMap *map)
{
ColorMap *new_map;
TRACE("(%p,%u,%i,%u,%p)\n", imageAttr, type, enableFlag, mapSize, map);
if(!imageAttr || type >= ColorAdjustTypeCount)
return InvalidParameter;
if (enableFlag)
{
if(!map || !mapSize)
return InvalidParameter;
new_map = heap_alloc_zero(sizeof(*map) * mapSize);
if (!new_map)
return OutOfMemory;
memcpy(new_map, map, sizeof(*map) * mapSize);
heap_free(imageAttr->colorremaptables[type].colormap);
imageAttr->colorremaptables[type].mapsize = mapSize;
imageAttr->colorremaptables[type].colormap = new_map;
}
else
{
heap_free(imageAttr->colorremaptables[type].colormap);
imageAttr->colorremaptables[type].colormap = NULL;
}
imageAttr->colorremaptables[type].enabled = enableFlag;
return Ok;
}
HRESULT HTMLTableRow_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
{
HTMLTableRow *ret;
nsresult nsres;
ret = heap_alloc_zero(sizeof(HTMLTableRow));
if(!ret)
return E_OUTOFMEMORY;
ret->IHTMLTableRow_iface.lpVtbl = &HTMLTableRowVtbl;
ret->element.node.vtbl = &HTMLTableRowImplVtbl;
HTMLElement_Init(&ret->element, doc, nselem, &HTMLTableRow_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableRowElement, (void**)&ret->nsrow);
/* Share nsrow reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsrow == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
*elem = &ret->element;
return S_OK;
}
static HRESULT alloc_error(script_ctx_t *ctx, DispatchEx *prototype,
DispatchEx *constr, ErrorInstance **ret)
{
ErrorInstance *err;
HRESULT hres;
err = heap_alloc_zero(sizeof(ErrorInstance));
if(!err)
return E_OUTOFMEMORY;
if(prototype)
hres = init_dispex(&err->dispex, ctx, &Error_info, prototype);
else
hres = init_dispex_from_constr(&err->dispex, ctx, &ErrorInst_info,
constr ? constr : ctx->error_constr);
if(FAILED(hres)) {
heap_free(err);
return hres;
}
*ret = err;
return S_OK;
}
HRESULT create_client_object(HWND hwnd, const IID *iid, void **obj)
{
Client *client;
HRESULT hres;
if(!IsWindow(hwnd))
return E_FAIL;
client = heap_alloc_zero(sizeof(Client));
if(!client)
return E_OUTOFMEMORY;
client->IAccessible_iface.lpVtbl = &ClientVtbl;
client->IOleWindow_iface.lpVtbl = &ClientOleWindowVtbl;
client->IEnumVARIANT_iface.lpVtbl = &ClientEnumVARIANTVtbl;
client->ref = 1;
client->hwnd = hwnd;
client->enum_pos = 0;
hres = IAccessible_QueryInterface(&client->IAccessible_iface, iid, obj);
IAccessible_Release(&client->IAccessible_iface);
return hres;
}
HRESULT HTMLStyleElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
{
HTMLStyleElement *ret;
nsresult nsres;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return E_OUTOFMEMORY;
ret->IHTMLStyleElement_iface.lpVtbl = &HTMLStyleElementVtbl;
ret->element.node.vtbl = &HTMLStyleElementImplVtbl;
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLStyleElement, (void**)&ret->nsstyle);
if(NS_FAILED(nsres)) {
ERR("Could not get nsIDOMHTMLStyleElement iface: %08x\n", nsres);
heap_free(ret);
return E_FAIL;
}
HTMLElement_Init(&ret->element, doc, nselem, &HTMLStyleElement_dispex);
*elem = &ret->element;
return S_OK;
}
static HRESULT alloc_error(script_ctx_t *ctx, jsdisp_t *prototype,
jsdisp_t *constr, jsdisp_t **ret)
{
jsdisp_t *err;
HRESULT hres;
err = heap_alloc_zero(sizeof(*err));
if(!err)
return E_OUTOFMEMORY;
if(prototype)
hres = init_dispex(err, ctx, &Error_info, prototype);
else
hres = init_dispex_from_constr(err, ctx, &ErrorInst_info,
constr ? constr : ctx->error_constr);
if(FAILED(hres)) {
heap_free(err);
return hres;
}
*ret = err;
return S_OK;
}
static HRESULT create_function(script_ctx_t *ctx, DWORD flags, BOOL funcprot, DispatchEx *prototype, FunctionInstance **ret)
{
FunctionInstance *function;
HRESULT hres;
function = heap_alloc_zero(sizeof(FunctionInstance));
if(!function)
return E_OUTOFMEMORY;
if(funcprot)
hres = init_dispex(&function->dispex, ctx, &Function_info, prototype);
else
hres = init_dispex_from_constr(&function->dispex, ctx, &Function_info, ctx->function_constr);
if(FAILED(hres))
return hres;
function->flags = flags;
function->length = flags & PROPF_ARGMASK;
if(prototype) {
jsexcept_t jsexcept;
VARIANT var;
V_VT(&var) = VT_DISPATCH;
V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(prototype);
memset(&jsexcept, 0, sizeof(jsexcept));
hres = jsdisp_propput_name(&function->dispex, prototypeW, ctx->lcid, &var, &jsexcept, NULL/*FIXME*/);
if(FAILED(hres)) {
IDispatchEx_Release(_IDispatchEx_(&function->dispex));
return hres;
}
}
*ret = function;
return S_OK;
}
HRESULT create_binding_protocol(LPCWSTR url, BOOL from_urlmon, IInternetProtocol **protocol)
{
BindProtocol *ret = heap_alloc_zero(sizeof(BindProtocol));
ret->lpIInternetProtocolVtbl = &BindProtocolVtbl;
ret->lpInternetBindInfoVtbl = &InternetBindInfoVtbl;
ret->lpInternetPriorityVtbl = &InternetPriorityVtbl;
ret->lpServiceProviderVtbl = &ServiceProviderVtbl;
ret->lpIInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
ret->lpIInternetProtocolHandlerVtbl = &InternetProtocolHandlerVtbl;
ret->lpIWinInetHttpInfoVtbl = &WinInetHttpInfoVtbl;
ret->ref = 1;
ret->from_urlmon = from_urlmon;
ret->apartment_thread = GetCurrentThreadId();
ret->notif_hwnd = get_notif_hwnd();
ret->protocol_handler = PROTOCOLHANDLER(ret);
InitializeCriticalSection(&ret->section);
URLMON_LockModule();
*protocol = PROTOCOL(ret);
return S_OK;
}
static HTMLEventObj *create_event(HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
{
HTMLEventObj *ret;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return NULL;
ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
ret->ref = 1;
ret->type = event_info+eid;
ret->nsevent = nsevent;
if(nsevent) {
nsIDOMEvent_AddRef(nsevent);
}else if(event_types[event_info[eid].type]) {
nsAString type_str;
nsresult nsres;
nsAString_InitDepend(&type_str, event_types[event_info[eid].type]);
nsres = nsIDOMHTMLDocument_CreateEvent(target->doc->nsdoc, &type_str, &ret->nsevent);
nsAString_Finish(&type_str);
if(NS_FAILED(nsres)) {
ERR("Could not create event: %08x\n", nsres);
IHTMLEventObj_Release(&ret->IHTMLEventObj_iface);
return NULL;
}
}
ret->target = target;
IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface);
init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex);
return ret;
}
HRESULT create_plugin_host(HTMLDocumentNode *doc, nsIDOMElement *nselem, IUnknown *unk, const CLSID *clsid, PluginHost **ret)
{
PluginHost *host;
HRESULT hres;
host = heap_alloc_zero(sizeof(*host));
if(!host)
return E_OUTOFMEMORY;
host->IOleClientSite_iface.lpVtbl = &OleClientSiteVtbl;
host->IAdviseSinkEx_iface.lpVtbl = &AdviseSinkExVtbl;
host->IPropertyNotifySink_iface.lpVtbl = &PropertyNotifySinkVtbl;
host->IDispatch_iface.lpVtbl = &DispatchVtbl;
host->IOleInPlaceSiteEx_iface.lpVtbl = &OleInPlaceSiteExVtbl;
host->IOleControlSite_iface.lpVtbl = &OleControlSiteVtbl;
host->IBindHost_iface.lpVtbl = &BindHostVtbl;
host->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
host->ref = 1;
hres = assoc_element(host, doc, nselem);
if(FAILED(hres)) {
heap_free(host);
return hres;
}
IUnknown_AddRef(unk);
host->plugin_unk = unk;
host->clsid = *clsid;
host->doc = doc;
list_add_tail(&doc->plugin_hosts, &host->entry);
*ret = host;
return S_OK;
}
static HRESULT alloc_enumerator(script_ctx_t *ctx, jsdisp_t *object_prototype, EnumeratorInstance **ret)
{
EnumeratorInstance *enumerator;
HRESULT hres;
enumerator = heap_alloc_zero(sizeof(EnumeratorInstance));
if(!enumerator)
return E_OUTOFMEMORY;
if(object_prototype)
hres = init_dispex(&enumerator->dispex, ctx, &Enumerator_info, object_prototype);
else
hres = init_dispex_from_constr(&enumerator->dispex, ctx, &EnumeratorInst_info,
ctx->enumerator_constr);
if(FAILED(hres))
{
heap_free(enumerator);
return hres;
}
*ret = enumerator;
return S_OK;
}
HRESULT HTMLObjectElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
{
HTMLObjectElement *ret;
nsresult nsres;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return E_OUTOFMEMORY;
ret->IHTMLObjectElement_iface.lpVtbl = &HTMLObjectElementVtbl;
ret->IHTMLObjectElement2_iface.lpVtbl = &HTMLObjectElement2Vtbl;
ret->plugin_container.element.node.vtbl = &HTMLObjectElementImplVtbl;
HTMLElement_Init(&ret->plugin_container.element, doc, nselem, &HTMLObjectElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLObjectElement, (void**)&ret->nsobject);
/* Share nsobject reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsobject == ret->plugin_container.element.node.nsnode);
nsIDOMNode_Release(ret->plugin_container.element.node.nsnode);
*elem = &ret->plugin_container.element;
return S_OK;
}
static HRESULT create_webbrowser(int version, IUnknown *outer, REFIID riid, void **ppv)
{
WebBrowser *ret;
HRESULT hres;
TRACE("(%p %s %p) version=%d\n", outer, debugstr_guid(riid), ppv, version);
ret = heap_alloc_zero(sizeof(WebBrowser));
ret->IWebBrowser2_iface.lpVtbl = &WebBrowser2Vtbl;
ret->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
ret->ref = 1;
ret->version = version;
DocHost_Init(&ret->doc_host, &ret->IWebBrowser2_iface, &DocHostContainerVtbl);
ret->visible = VARIANT_TRUE;
ret->menu_bar = VARIANT_TRUE;
ret->address_bar = VARIANT_TRUE;
ret->status_bar = VARIANT_TRUE;
ret->tool_bar = VARIANT_TRUE;
WebBrowser_OleObject_Init(ret);
WebBrowser_ViewObject_Init(ret);
WebBrowser_Persist_Init(ret);
WebBrowser_ClassInfo_Init(ret);
HlinkFrame_Init(&ret->hlink_frame, (IUnknown*)&ret->IWebBrowser2_iface, &ret->doc_host);
lock_module();
hres = IWebBrowser2_QueryInterface(&ret->IWebBrowser2_iface, riid, ppv);
IWebBrowser2_Release(&ret->IWebBrowser2_iface);
return hres;
}
HRESULT CDECL wined3d_palette_create(struct wined3d_device *device, DWORD flags,
unsigned int entry_count, const PALETTEENTRY *entries, struct wined3d_palette **palette)
{
struct wined3d_palette *object;
HRESULT hr;
TRACE("device %p, flags %#x, entry_count %u, entries %p, palette %p.\n",
device, flags, entry_count, entries, palette);
if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = wined3d_palette_init(object, device, flags, entry_count, entries)))
{
WARN("Failed to initialize palette, hr %#x.\n", hr);
heap_free(object);
return hr;
}
TRACE("Created palette %p.\n", object);
*palette = object;
return WINED3D_OK;
}
static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
{
if(!*event_target_ptr)
*event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
return *event_target_ptr;
}