/************************************************************************** * debugstr_cf */ const char* debugstr_cf(CFTypeRef t) { CFStringRef s; const char* ret; if (!t) return "(null)"; if (CFGetTypeID(t) == CFStringGetTypeID()) s = t; else s = CFCopyDescription(t); ret = CFStringGetCStringPtr(s, kCFStringEncodingUTF8); if (ret) ret = debugstr_a(ret); if (!ret) { const UniChar* u = CFStringGetCharactersPtr(s); if (u) ret = debugstr_wn((const WCHAR*)u, CFStringGetLength(s)); } if (!ret) { UniChar buf[200]; int len = min(CFStringGetLength(s), sizeof(buf)/sizeof(buf[0])); CFStringGetCharacters(s, CFRangeMake(0, len), buf); ret = debugstr_wn(buf, len); } if (s != t) CFRelease(s); return ret; }
static HRESULT WINAPI mxwriter_saxcontent_processingInstruction( ISAXContentHandler *iface, const WCHAR *target, int ntarget, const WCHAR *data, int ndata) { mxwriter *This = impl_from_ISAXContentHandler( iface ); FIXME("(%p)->(%s %s)\n", This, debugstr_wn(target, ntarget), debugstr_wn(data, ndata)); return E_NOTIMPL; }
static HRESULT WINAPI mxwriter_saxcontent_startPrefixMapping( ISAXContentHandler *iface, const WCHAR *prefix, int nprefix, const WCHAR *uri, int nuri) { mxwriter *This = impl_from_ISAXContentHandler( iface ); FIXME("(%p)->(%s %s)\n", This, debugstr_wn(prefix, nprefix), debugstr_wn(uri, nuri)); return E_NOTIMPL; }
/*********************************************************************** * PSDRV_GetTextExtentExPoint */ BOOL PSDRV_GetTextExtentExPoint(PSDRV_PDEVICE *physDev, LPCWSTR str, INT count, INT maxExt, LPINT lpnFit, LPINT alpDx, LPSIZE size) { int nfit = 0; int i; float width = 0.0; float scale; assert(physDev->font.fontloc == Builtin); TRACE("%s %i\n", debugstr_wn(str, count), count); scale = physDev->font.fontinfo.Builtin.scale; for (i = 0; i < count && str[i] != '\0'; ++i) { float scaled_width; width += PSDRV_UVMetrics(str[i], physDev->font.fontinfo.Builtin.afm)->WX; scaled_width = width * scale; if (alpDx) alpDx[i] = scaled_width; if (scaled_width <= maxExt) ++nfit; } size->cx = width * physDev->font.fontinfo.Builtin.scale; size->cy = physDev->font.fontinfo.Builtin.tm.tmHeight; if (lpnFit) *lpnFit = nfit; TRACE("cx=%li cy=%li\n", size->cx, size->cy); return TRUE; }
/****************************************************************************** * SysAllocStringLen [OLEAUT32.4] * * Create a BSTR from an OLESTR of a given wide character length. * * PARAMS * str [I] Source to create BSTR from * len [I] Length of oleStr in wide characters * * RETURNS * Success: A newly allocated BSTR from SysAllocStringByteLen() * Failure: NULL, if len is >= 0x80000000, or memory allocation fails. * * NOTES * See BSTR(), SysAllocStringByteLen(). */ BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len) { bstr_t *bstr; DWORD size; /* Detect integer overflow. */ if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR))) return NULL; TRACE("%s\n", debugstr_wn(str, len)); size = len*sizeof(WCHAR); bstr = alloc_bstr(size); if(!bstr) return NULL; if(str) { memcpy(bstr->u.str, str, size); bstr->u.str[len] = 0; }else { memset(bstr->u.str, 0, size+sizeof(WCHAR)); } return bstr->u.str; }
static int cc_token(parser_ctx_t *ctx, void *lval) { unsigned id_len = 0; cc_var_t *var; static const WCHAR cc_onW[] = {'c','c','_','o','n',0}; static const WCHAR setW[] = {'s','e','t',0}; static const WCHAR elifW[] = {'e','l','i','f',0}; static const WCHAR endW[] = {'e','n','d',0}; ctx->ptr++; if(!check_keyword(ctx, cc_onW, NULL)) return init_cc(ctx); if(!check_keyword(ctx, setW, NULL)) { FIXME("@set not implemented\n"); return lex_error(ctx, E_NOTIMPL); } if(!check_keyword(ctx, ifW, NULL)) { FIXME("@if not implemented\n"); return lex_error(ctx, E_NOTIMPL); } if(!check_keyword(ctx, elifW, NULL)) { FIXME("@elif not implemented\n"); return lex_error(ctx, E_NOTIMPL); } if(!check_keyword(ctx, elseW, NULL)) { FIXME("@else not implemented\n"); return lex_error(ctx, E_NOTIMPL); } if(!check_keyword(ctx, endW, NULL)) { FIXME("@end not implemented\n"); return lex_error(ctx, E_NOTIMPL); } if(!ctx->script->cc) return lex_error(ctx, JS_E_DISABLED_CC); while(ctx->ptr+id_len < ctx->end && is_identifier_char(ctx->ptr[id_len])) id_len++; if(!id_len) return '@'; TRACE("var %s\n", debugstr_wn(ctx->ptr, id_len)); var = find_cc_var(ctx->script->cc, ctx->ptr, id_len); ctx->ptr += id_len; if(!var || var->is_num) { *(literal_t**)lval = new_double_literal(ctx, var ? var->u.n : ret_nan()); return tNumericLiteral; } *(literal_t**)lval = new_boolean_literal(ctx, var->u.b); return tBooleanLiteral; }
static void dump_instr_arg(instr_arg_type_t type, instr_arg_t *arg) { switch(type) { case ARG_STR: TRACE_(jscript_disas)("\t%s", debugstr_w(arg->str)); break; case ARG_BSTR: TRACE_(jscript_disas)("\t%s", debugstr_wn(arg->bstr, SysStringLen(arg->bstr))); break; case ARG_INT: TRACE_(jscript_disas)("\t%d", arg->uint); break; case ARG_UINT: case ARG_ADDR: TRACE_(jscript_disas)("\t%u", arg->uint); break; case ARG_DBL: TRACE_(jscript_disas)("\t%lf", *arg->dbl); break; case ARG_FUNC: case ARG_NONE: break; default: assert(0); } }
static int ME_WordBreakProc(LPWSTR s, INT start, INT len, INT code) { /* FIXME: Native also knows about punctuation */ TRACE("s==%s, start==%d, len==%d, code==%d\n", debugstr_wn(s, len), start, len, code); switch (code) { case WB_ISDELIMITER: return ME_IsWSpace(s[start]); case WB_LEFT: case WB_MOVEWORDLEFT: while (start && ME_IsWSpace(s[start - 1])) start--; while (start && !ME_IsWSpace(s[start - 1])) start--; return start; case WB_RIGHT: case WB_MOVEWORDRIGHT: if (start && ME_IsWSpace(s[start - 1])) { while (start < len && ME_IsWSpace(s[start])) start++; } else { while (start < len && !ME_IsWSpace(s[start])) start++; while (start < len && ME_IsWSpace(s[start])) start++; } return start; } return 0; }
static HRESULT WINAPI dwritefactory_CreateGdiCompatibleTextLayout(IDWriteFactory *iface, WCHAR const* string, UINT32 len, IDWriteTextFormat *format, FLOAT layout_width, FLOAT layout_height, FLOAT pixels_per_dip, DWRITE_MATRIX const* transform, BOOL use_gdi_natural, IDWriteTextLayout **layout) { FIXME("(%s:%u %p %f %f %f %p %d %p): stub\n", debugstr_wn(string, len), len, format, layout_width, layout_height, pixels_per_dip, transform, use_gdi_natural, layout); return E_NOTIMPL; }
static HRESULT WINAPI mxwriter_saxcontent_skippedEntity( ISAXContentHandler *iface, const WCHAR *name, int nname) { mxwriter *This = impl_from_ISAXContentHandler( iface ); FIXME("(%p)->(%s)\n", This, debugstr_wn(name, nname)); return E_NOTIMPL; }
static BOOL OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle) { TRACE("(%p, %x, %s, %x)\n", lpwStr, nwStr, debugstr_wn(lpOle,nOle), nOle); if (lstrcpynW ( lpwStr, lpOle, nwStr)) { return lstrlenW (lpwStr); } return 0; }
static HRESULT WINAPI mxwriter_saxcontent_ignorableWhitespace( ISAXContentHandler *iface, const WCHAR *chars, int nchars) { mxwriter *This = impl_from_ISAXContentHandler( iface ); FIXME("(%p)->(%s)\n", This, debugstr_wn(chars, nchars)); return E_NOTIMPL; }
static BOOL StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr) { TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_wn(lpStrW, nStr), nStr); if (lstrcpynW (lpWide, lpStrW, nWide)) { return lstrlenW (lpWide); } return 0; }
static BOOL CRYPT_ValueToRDN(DWORD dwCertEncodingType, PCERT_NAME_INFO info, PCCRYPT_OID_INFO keyOID, struct X500TokenW *value, LPCWSTR *ppszError) { BOOL ret = FALSE; TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID), debugstr_wn(value->start, value->end - value->start)); if (!info->rgRDN) info->rgRDN = CryptMemAlloc(sizeof(CERT_RDN)); else info->rgRDN = CryptMemRealloc(info->rgRDN, (info->cRDN + 1) * sizeof(CERT_RDN)); if (info->rgRDN) { /* FIXME: support multiple RDN attrs */ info->rgRDN[info->cRDN].rgRDNAttr = CryptMemAlloc(sizeof(CERT_RDN_ATTR)); if (info->rgRDN[info->cRDN].rgRDNAttr) { static const DWORD defaultTypes[] = { CERT_RDN_PRINTABLE_STRING, CERT_RDN_BMP_STRING, 0 }; const DWORD *types; info->rgRDN[info->cRDN].cRDNAttr = 1; info->rgRDN[info->cRDN].rgRDNAttr[0].pszObjId = (LPSTR)keyOID->pszOID; info->rgRDN[info->cRDN].rgRDNAttr[0].dwValueType = CERT_RDN_ENCODED_BLOB; if (keyOID->ExtraInfo.cbData) types = (const DWORD *)keyOID->ExtraInfo.pbData; else types = defaultTypes; /* Remove surrounding quotes */ if (value->start[0] == '"') { value->start++; value->end--; } ret = CRYPT_EncodeValue(dwCertEncodingType, value, &info->rgRDN[info->cRDN].rgRDNAttr[0].Value, types, ppszError); } else SetLastError(ERROR_OUTOFMEMORY); info->cRDN++; } else SetLastError(ERROR_OUTOFMEMORY); return ret; }
/*********************************************************************** * X11DRV_GetTextExtentExPoint */ BOOL X11DRV_GetTextExtentExPoint( PHYSDEV dev, LPCWSTR str, INT count, INT maxExt, LPINT lpnFit, LPINT alpDx, LPSIZE size ) { X11DRV_PDEVICE *physDev = get_x11drv_dev( dev ); fontObject* pfo = XFONT_GetFontObject( physDev->font ); TRACE("%s %d\n", debugstr_wn(str,count), count); if( pfo ) { XChar2b *p = X11DRV_cptable[pfo->fi->cptable].punicode_to_char2b( pfo, str, count ); if (!p) return FALSE; if( !pfo->lpX11Trans ) { int dir, ascent, descent; int info_width; X11DRV_cptable[pfo->fi->cptable].pTextExtents( pfo, p, count, &dir, &ascent, &descent, &info_width, maxExt, lpnFit, alpDx ); size->cx = info_width; size->cy = pfo->fs->ascent + pfo->fs->descent; } else { INT i; INT nfit = 0; float x = 0.0, y = 0.0; float scaled_x = 0.0, pixsize = pfo->lpX11Trans->pixelsize; /* FIXME: Deal with *_char_or_byte2 != 0 situations */ for(i = 0; i < count; i++) { x += pfo->fs->per_char ? pfo->fs->per_char[p[i].byte2 - pfo->fs->min_char_or_byte2].attributes : pfo->fs->min_bounds.attributes; scaled_x = x * pixsize / 1000.0; if (alpDx) alpDx[i] = scaled_x; if (scaled_x <= maxExt) ++nfit; } y = pfo->lpX11Trans->RAW_ASCENT + pfo->lpX11Trans->RAW_DESCENT; TRACE("x = %f y = %f\n", x, y); size->cx = x * pfo->lpX11Trans->pixelsize / 1000.0; size->cy = y * pfo->lpX11Trans->pixelsize / 1000.0; if (lpnFit) *lpnFit = nfit; } size->cx *= pfo->rescale; size->cy *= pfo->rescale; HeapFree( GetProcessHeap(), 0, p ); return TRUE; } dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPoint ); return dev->funcs->pGetTextExtentExPoint( dev, str, count, maxExt, lpnFit, alpDx, size ); }
/*********************************************************************** * PSDRV_ExtTextOut */ BOOL PSDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx ) { PSDRV_PDEVICE *physDev = get_psdrv_dev( dev ); BOOL bResult = TRUE; BOOL bClipped = FALSE; BOOL bOpaque = FALSE; TRACE("(x=%d, y=%d, flags=0x%08x, str=%s, count=%d, lpDx=%p)\n", x, y, flags, debugstr_wn(str, count), count, lpDx); if(physDev->job.id == 0) return FALSE; /* write font if not already written */ PSDRV_SetFont(dev); PSDRV_SetClip(dev); /* set clipping and/or draw background */ if ((flags & (ETO_CLIPPED | ETO_OPAQUE)) && (lprect != NULL)) { PSDRV_WriteGSave(dev); PSDRV_WriteRectangle(dev, lprect->left, lprect->top, lprect->right - lprect->left, lprect->bottom - lprect->top); if (flags & ETO_OPAQUE) { bOpaque = TRUE; PSDRV_WriteGSave(dev); PSDRV_WriteSetColor(dev, &physDev->bkColor); PSDRV_WriteFill(dev); PSDRV_WriteGRestore(dev); } if (flags & ETO_CLIPPED) { bClipped = TRUE; PSDRV_WriteClip(dev); } bResult = PSDRV_Text(dev, x, y, flags, str, count, !(bClipped && bOpaque), lpDx); PSDRV_WriteGRestore(dev); } else { bResult = PSDRV_Text(dev, x, y, flags, str, count, TRUE, lpDx); } PSDRV_ResetClip(dev); return bResult; }
static void STDMETHODCALLTYPE d2d_dc_render_target_DrawText(ID2D1DCRenderTarget *iface, const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode) { struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, " "brush %p, options %#x, measuring_mode %#x.\n", iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect), brush, options, measuring_mode); ID2D1RenderTarget_DrawText(render_target->dxgi_target, string, string_len, text_format, layout_rect, brush, options, measuring_mode); }
static HRESULT WINAPI mxwriter_saxcontent_endElement( ISAXContentHandler *iface, const WCHAR *namespaceUri, int nnamespaceUri, const WCHAR * local_name, int nlocal_name, const WCHAR *QName, int nQName) { mxwriter *This = impl_from_ISAXContentHandler( iface ); TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(namespaceUri, nnamespaceUri), nnamespaceUri, debugstr_wn(local_name, nlocal_name), nlocal_name, debugstr_wn(QName, nQName), nQName); if ((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6) return E_INVALIDARG; if (This->element && QName && !strncmpW(This->element, QName, nQName)) { static const WCHAR closeW[] = {'/','>'}; write_output_buffer(This->buffer, closeW, 2); } else { static const WCHAR closetagW[] = {'<','/'}; static const WCHAR gtW[] = {'>'}; write_output_buffer(This->buffer, closetagW, 2); write_output_buffer(This->buffer, QName, nQName); write_output_buffer(This->buffer, gtW, 1); } set_element_name(This, NULL, 0); return S_OK; }
/************************************************************************* * MsiDecomposeDescriptorW [MSI.@] * * Decomposes an MSI descriptor into product, feature and component parts. * An MSI descriptor is a string of the form: * [base 85 guid] [feature code] '>' [base 85 guid] * * PARAMS * szDescriptor [I] the descriptor to decompose * szProduct [O] buffer of MAX_FEATURE_CHARS+1 for the product guid * szFeature [O] buffer of MAX_FEATURE_CHARS+1 for the feature code * szComponent [O] buffer of MAX_FEATURE_CHARS+1 for the component guid * pUsed [O] the length of the descriptor * * RETURNS * ERROR_SUCCESS if everything worked correctly * ERROR_INVALID_PARAMETER if the descriptor was invalid * */ UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct, LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed ) { UINT r, len; LPWSTR p; GUID product, component; TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct, szFeature, szComponent, pUsed); r = decode_base85_guid( szDescriptor, &product ); if( !r ) return ERROR_INVALID_PARAMETER; TRACE("product %s\n", debugstr_guid( &product )); p = strchrW(&szDescriptor[20],'>'); if( !p ) return ERROR_INVALID_PARAMETER; len = (p - &szDescriptor[20]); if( len > MAX_FEATURE_CHARS ) return ERROR_INVALID_PARAMETER; TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len )); r = decode_base85_guid( p+1, &component ); if( !r ) return ERROR_INVALID_PARAMETER; TRACE("component %s\n", debugstr_guid( &component )); if (szProduct) StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 ); if (szComponent) StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 ); if (szFeature) { memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) ); szFeature[len] = 0; } len = ( &p[21] - szDescriptor ); TRACE("length = %d\n", len); *pUsed = len; return ERROR_SUCCESS; }
/*********************************************************************** * load_strings */ static void load_strings(HINSTANCE instance) { static const unsigned int ids[] = { STRING_MENU_WINE, STRING_MENU_ITEM_HIDE_APPNAME, STRING_MENU_ITEM_HIDE, STRING_MENU_ITEM_HIDE_OTHERS, STRING_MENU_ITEM_SHOW_ALL, STRING_MENU_ITEM_QUIT_APPNAME, STRING_MENU_ITEM_QUIT, STRING_MENU_WINDOW, STRING_MENU_ITEM_MINIMIZE, STRING_MENU_ITEM_ZOOM, STRING_MENU_ITEM_ENTER_FULL_SCREEN, STRING_MENU_ITEM_BRING_ALL_TO_FRONT, }; CFMutableDictionaryRef dict; int i; dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (!dict) { ERR("Failed to create localized strings dictionary\n"); return; } for (i = 0; i < sizeof(ids) / sizeof(ids[0]); i++) { LPCWSTR str; int len = LoadStringW(instance, ids[i], (LPWSTR)&str, 0); if (str && len) { CFNumberRef key = CFNumberCreate(NULL, kCFNumberIntType, &ids[i]); CFStringRef value = CFStringCreateWithCharacters(NULL, (UniChar*)str, len); if (key && value) CFDictionarySetValue(dict, key, value); else ERR("Failed to add string ID 0x%04x %s\n", ids[i], debugstr_wn(str, len)); } else ERR("Failed to load string ID 0x%04x\n", ids[i]); } localized_strings = dict; }
static HRESULT WINAPI mxwriter_saxcontent_characters( ISAXContentHandler *iface, const WCHAR *chars, int nchars) { mxwriter *This = impl_from_ISAXContentHandler( iface ); TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars); if (!chars) return E_INVALIDARG; close_element_starttag(This); set_element_name(This, NULL, 0); if (nchars) write_output_buffer(This->buffer, chars, nchars); return S_OK; }
static HRESULT do_preprocess(const Registrar *This, LPCOLESTR data, strbuf *buf) { LPCOLESTR iter, iter2 = data; rep_list *rep_iter; static const WCHAR wstr[] = {'%',0}; iter = strchrW(data, '%'); while(iter) { strbuf_write(iter2, buf, iter-iter2); iter2 = ++iter; if(!*iter2) return DISP_E_EXCEPTION; iter = strchrW(iter2, '%'); if(!iter) return DISP_E_EXCEPTION; if(iter == iter2) { strbuf_write(wstr, buf, 1); }else { for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) { if(rep_iter->key_len == iter-iter2 && !memicmpW(iter2, rep_iter->key, rep_iter->key_len)) break; } if(!rep_iter) { WARN("Could not find replacement: %s\n", debugstr_wn(iter2, iter-iter2)); return DISP_E_EXCEPTION; } strbuf_write(rep_iter->item, buf, -1); } iter2 = ++iter; iter = strchrW(iter, '%'); } strbuf_write(iter2, buf, -1); TRACE("%s\n", debugstr_w(buf->str)); return S_OK; }
/*********************************************************************** * WindowsCreateString (combase.@) */ HRESULT WINAPI WindowsCreateString(LPCWSTR ptr, UINT32 len, HSTRING *out) { struct hstring_private *priv; TRACE("(%s, %u, %p)\n", debugstr_wn(ptr, len), len, out); if (out == NULL) return E_INVALIDARG; if (len == 0) { *out = NULL; return S_OK; } if (ptr == NULL) return E_POINTER; if (!alloc_string(len, out)) return E_OUTOFMEMORY; priv = impl_from_HSTRING(*out); memcpy(priv->buffer, ptr, len * sizeof(*priv->buffer)); return S_OK; }
/****************************************************************************** * CLIPFORMAT_UserMarshal [OLE32.@] * * Marshals a clip format into a buffer. * * PARAMS * pFlags [I] Flags. See notes. * pBuffer [I] Buffer to marshal the clip format into. * pCF [I] Clip format to marshal. * * RETURNS * The end of the marshaled data in the buffer. * * NOTES * Even though the function is documented to take a pointer to an unsigned * long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which * the first parameter is an unsigned long. * This function is only intended to be called by the RPC runtime. */ unsigned char * __RPC_USER CLIPFORMAT_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF) { wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer; TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &0x%04x\n", pBuffer, *pCF); wirecf->u.dwValue = *pCF; pBuffer += sizeof(*wirecf); /* only need to marshal the name if it is not a pre-defined type and * we are going remote */ if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)) { WCHAR format[255]; INT len; wirecf->fContext = WDT_REMOTE_CALL; len = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1); if (!len) RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL); len += 1; *(INT *)pBuffer = len; pBuffer += sizeof(INT); *(INT *)pBuffer = 0; pBuffer += sizeof(INT); *(INT *)pBuffer = len; pBuffer += sizeof(INT); TRACE("marshaling format name %s\n", debugstr_wn(format, len-1)); lstrcpynW((LPWSTR)pBuffer, format, len); pBuffer += len * sizeof(WCHAR); *(WCHAR *)pBuffer = '\0'; pBuffer += sizeof(WCHAR); } else wirecf->fContext = WDT_INPROC_CALL; return pBuffer; }
/****************************************************************************** * WriteConsoleOutputCharacterW [KERNEL32.@] Copies character to consecutive * cells in the console screen buffer * * PARAMS * hConsoleOutput [I] Handle to screen buffer * str [I] Pointer to buffer with chars to write * length [I] Number of cells to write to * coord [I] Coords of first cell * lpNumCharsWritten [O] Pointer to number of cells written * * RETURNS * Success: TRUE * Failure: FALSE * */ BOOL WINAPI WriteConsoleOutputCharacterW( HANDLE hConsoleOutput, LPCWSTR str, DWORD length, COORD coord, LPDWORD lpNumCharsWritten ) { BOOL ret; TRACE("(%d,%s,%ld,%dx%d,%p)\n", hConsoleOutput, debugstr_wn(str, length), length, coord.X, coord.Y, lpNumCharsWritten); SERVER_START_REQ( write_console_output ) { req->handle = hConsoleOutput; req->x = coord.X; req->y = coord.Y; req->mode = CHAR_INFO_MODE_TEXT; req->wrap = TRUE; wine_server_add_data( req, str, length * sizeof(WCHAR) ); if ((ret = !wine_server_call_err( req ))) { if (lpNumCharsWritten) *lpNumCharsWritten = reply->written; } } SERVER_END_REQ; return ret; }
/*********************************************************************** * WindowsCreateStringReference (combase.@) */ HRESULT WINAPI WindowsCreateStringReference(LPCWSTR ptr, UINT32 len, HSTRING_HEADER *header, HSTRING *out) { struct hstring_private *priv = impl_from_HSTRING_HEADER(header); TRACE("(%s, %u, %p, %p)\n", debugstr_wn(ptr, len), len, header, out); if (out == NULL || header == NULL) return E_INVALIDARG; if (len == 0) { *out = NULL; return S_OK; } if (ptr == NULL) return E_POINTER; if (ptr[len] != '\0') return E_INVALIDARG; priv->buffer = (LPWSTR)ptr; priv->length = len; priv->reference = TRUE; *out = (HSTRING)header; return S_OK; }
static NTSTATUS set_alg_property( struct algorithm *alg, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags ) { switch (alg->id) { case ALG_ID_AES: if (!strcmpW( prop, BCRYPT_CHAINING_MODE )) { if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) { alg->mode = MODE_ID_ECB; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { alg->mode = MODE_ID_CBC; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM, size )) { alg->mode = MODE_ID_GCM; return STATUS_SUCCESS; } else { FIXME( "unsupported mode %s\n", debugstr_wn( (WCHAR *)value, size ) ); return STATUS_NOT_IMPLEMENTED; } } FIXME( "unsupported aes algorithm property %s\n", debugstr_w(prop) ); return STATUS_NOT_IMPLEMENTED; default: FIXME( "unsupported algorithm %u\n", alg->id ); return STATUS_NOT_IMPLEMENTED; } }
HRESULT ClassMoniker_CreateFromDisplayName(LPBC pbc, LPCOLESTR szDisplayName, LPDWORD pchEaten, IMoniker **ppmk) { HRESULT hr; LPCWSTR s = strchrW(szDisplayName, ':'); LPCWSTR end; CLSID clsid; BYTE table[256]; int i; if (!s) return MK_E_SYNTAX; s++; for (end = s; *end && (*end != ':'); end++) ; TRACE("parsing %s\n", debugstr_wn(s, end - s)); /* validate the CLSID string */ if (s[0] == '{') { if ((end - s != 38) || (s[37] != '}')) return MK_E_SYNTAX; s++; } else { if (end - s != 36) return MK_E_SYNTAX; } for (i=0; i<36; i++) { if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) { if (s[i] != '-') return MK_E_SYNTAX; continue; } if (!(((s[i] >= '0') && (s[i] <= '9')) || ((s[i] >= 'a') && (s[i] <= 'f')) || ((s[i] >= 'A') && (s[i] <= 'F')))) return MK_E_SYNTAX; } /* quick lookup table */ memset(table, 0, 256); for (i = 0; i < 10; i++) table['0' + i] = i; for (i = 0; i < 6; i++) { table['A' + i] = i+10; table['a' + i] = i+10; } /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */ clsid.Data1 = (table[s[0]] << 28 | table[s[1]] << 24 | table[s[2]] << 20 | table[s[3]] << 16 | table[s[4]] << 12 | table[s[5]] << 8 | table[s[6]] << 4 | table[s[7]]); clsid.Data2 = table[s[9]] << 12 | table[s[10]] << 8 | table[s[11]] << 4 | table[s[12]]; clsid.Data3 = table[s[14]] << 12 | table[s[15]] << 8 | table[s[16]] << 4 | table[s[17]]; /* these are just sequential bytes */ clsid.Data4[0] = table[s[19]] << 4 | table[s[20]]; clsid.Data4[1] = table[s[21]] << 4 | table[s[22]]; clsid.Data4[2] = table[s[24]] << 4 | table[s[25]]; clsid.Data4[3] = table[s[26]] << 4 | table[s[27]]; clsid.Data4[4] = table[s[28]] << 4 | table[s[29]]; clsid.Data4[5] = table[s[30]] << 4 | table[s[31]]; clsid.Data4[6] = table[s[32]] << 4 | table[s[33]]; clsid.Data4[7] = table[s[34]] << 4 | table[s[35]]; hr = CreateClassMoniker(&clsid, ppmk); if (SUCCEEDED(hr)) *pchEaten = (*end == ':' ? end + 1 : end) - szDisplayName; return hr; }
/********************************************************************** * EMFDRV_ExtTextOut */ BOOL EMFDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx ) { EMREXTTEXTOUTW *pemr; DWORD nSize; BOOL ret; EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE*) dev; int textHeight = 0; int textWidth = 0; const UINT textAlign = GetTextAlign(physDev->hdc); nSize = sizeof(*pemr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT); TRACE("%s %s count %d nSize = %ld\n", debugstr_wn(str, count), wine_dbgstr_rect(lprect), count, nSize); pemr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize); pemr->emr.iType = EMR_EXTTEXTOUTW; pemr->emr.nSize = nSize; pemr->iGraphicsMode = GetGraphicsMode(physDev->hdc); pemr->exScale = pemr->eyScale = 1.0; /* FIXME */ pemr->emrtext.ptlReference.x = x; pemr->emrtext.ptlReference.y = y; pemr->emrtext.nChars = count; pemr->emrtext.offString = sizeof(*pemr); memcpy((char*)pemr + pemr->emrtext.offString, str, count * sizeof(WCHAR)); pemr->emrtext.fOptions = flags; if(!lprect) { pemr->emrtext.rcl.left = pemr->emrtext.rcl.top = 0; pemr->emrtext.rcl.right = pemr->emrtext.rcl.bottom = -1; } else { pemr->emrtext.rcl.left = lprect->left; pemr->emrtext.rcl.top = lprect->top; pemr->emrtext.rcl.right = lprect->right; pemr->emrtext.rcl.bottom = lprect->bottom; } pemr->emrtext.offDx = pemr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR); if(lpDx) { UINT i; SIZE strSize; memcpy((char*)pemr + pemr->emrtext.offDx, lpDx, count * sizeof(INT)); for (i = 0; i < count; i++) { textWidth += lpDx[i]; } GetTextExtentPoint32W(physDev->hdc, str, count, &strSize); textHeight = strSize.cy; } else { UINT i; INT *dx = (INT *)((char*)pemr + pemr->emrtext.offDx); SIZE charSize; for (i = 0; i < count; i++) { GetTextExtentPoint32W(physDev->hdc, str + i, 1, &charSize); dx[i] = charSize.cx; textWidth += charSize.cx; textHeight = max(textHeight, charSize.cy); } } switch (textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER)) { case TA_CENTER: { pemr->rclBounds.left = x - (textWidth / 2) - 1; pemr->rclBounds.right = x + (textWidth / 2) + 1; break; } case TA_RIGHT: { pemr->rclBounds.left = x - textWidth - 1; pemr->rclBounds.right = x; break; } default: { /* TA_LEFT */ pemr->rclBounds.left = x; pemr->rclBounds.right = x + textWidth + 1; } } switch (textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE)) { case TA_BASELINE: { TEXTMETRICW tm; GetTextMetricsW(physDev->hdc, &tm); /* Play safe here... it's better to have a bounding box */ /* that is too big than too small. */ pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y + tm.tmDescent + 1; break; } case TA_BOTTOM: { pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y; break; } default: { /* TA_TOP */ pemr->rclBounds.top = y; pemr->rclBounds.bottom = y + textHeight + 1; } } ret = EMFDRV_WriteRecord( dev, &pemr->emr ); if(ret) EMFDRV_UpdateBBox( dev, &pemr->rclBounds ); HeapFree( GetProcessHeap(), 0, pemr ); return ret; }
/************************************************************************** * WsDecodeUrl [webservices.@] */ HRESULT WINAPI WsDecodeUrl( const WS_STRING *str, ULONG flags, WS_HEAP *heap, WS_URL **ret, WS_ERROR *error ) { HRESULT hr = WS_E_QUOTA_EXCEEDED; WCHAR *p, *q, *decoded = NULL; WS_HTTP_URL *url = NULL; ULONG len, len_decoded, port = 0; TRACE( "%s %08x %p %p %p\n", str ? debugstr_wn(str->chars, str->length) : "null", flags, heap, ret, error ); if (error) FIXME( "ignoring error parameter\n" ); if (!str || !heap) return E_INVALIDARG; if (!str->length) return WS_E_INVALID_FORMAT; if (flags) { FIXME( "unimplemented flags %08x\n", flags ); return E_NOTIMPL; } if (!(decoded = url_decode( str->chars, str->length, heap, &len_decoded )) || !(url = ws_alloc( heap, sizeof(*url) ))) goto error; hr = WS_E_INVALID_FORMAT; p = q = decoded; len = len_decoded; while (len && *q != ':') { q++; len--; }; if (*q != ':') goto error; if ((url->url.scheme = scheme_type( p, q - p )) == ~0u) goto error; if (!--len || *++q != '/') goto error; if (!--len || *++q != '/') goto error; p = ++q; len--; while (len && *q != '/' && *q != ':' && *q != '?' && *q != '#') { q++; len--; }; if (q == p) goto error; url->host.length = q - p; url->host.chars = p; if (len && *q == ':') { p = ++q; len--; while (len && isdigitW( *q )) { if ((port = port * 10 + *q - '0') > 65535) goto error; q++; len--; }; url->port = port; url->portAsString.length = q - p; url->portAsString.chars = p; } if (!port) { url->port = default_port( url->url.scheme ); url->portAsString.length = 0; url->portAsString.chars = NULL; } if (len && *q == '/') { p = q; while (len && *q != '?') { q++; len--; }; url->path.length = q - p; url->path.chars = p; } else url->path.length = 0; if (len && *q == '?') { p = ++q; len--; while (len && *q != '#') { q++; len--; }; url->query.length = q - p; url->query.chars = p; } else url->query.length = 0; if (len && *q == '#') { p = ++q; len--; while (len && *q != '#') { q++; len--; }; url->fragment.length = q - p; url->fragment.chars = p; } else url->fragment.length = 0; *ret = (WS_URL *)url; return S_OK; error: if (decoded != str->chars) ws_free( heap, decoded, len_decoded ); ws_free( heap, url, sizeof(*url) ); return hr; }